430 lines
16 KiB
C#
430 lines
16 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using BetterSecondBotShared.IO;
|
|
using BetterSecondBotShared.Json;
|
|
using BetterSecondBotShared.logs;
|
|
using BetterSecondBotShared.Static;
|
|
using Newtonsoft.Json;
|
|
using OpenMetaverse;
|
|
|
|
namespace BetterSecondBotShared.bottypes
|
|
{
|
|
public abstract class BasicBot
|
|
{
|
|
protected UUID master_uuid = UUID.Zero;
|
|
protected BasicBot()
|
|
{
|
|
LastStatusMessage = "No status";
|
|
}
|
|
|
|
|
|
protected Dictionary<UUID, Group> mygroups = new Dictionary<UUID, Group>();
|
|
|
|
protected Dictionary<UUID, KeyValuePair<long, List<GroupRole>>> mygrouprolesstorage = new Dictionary<UUID, KeyValuePair<long, List<GroupRole>>>();
|
|
public Dictionary<UUID, Group> MyGroups { get { return mygroups; } }
|
|
public Dictionary<UUID, KeyValuePair<long, List<GroupRole>>> MyGroupRolesStorage { get { return mygrouprolesstorage; } }
|
|
|
|
protected GridClient Client;
|
|
public GridClient GetClient { get { return Client; } }
|
|
protected List<string> SubMasters = new List<string>();
|
|
public bool Is_avatar_master(string name)
|
|
{
|
|
if (name == myconfig.Security_MasterUsername)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return SubMasters.Contains(name);
|
|
}
|
|
}
|
|
|
|
protected bool running_in_docker = false;
|
|
public void AsDocker()
|
|
{
|
|
running_in_docker = true;
|
|
}
|
|
|
|
protected bool killMe;
|
|
protected JsonConfig myconfig;
|
|
public JsonConfig getMyConfig { get { return myconfig; } }
|
|
protected string version = "NotSet V1.0.0.0";
|
|
|
|
public bool reconnect;
|
|
|
|
public string MyVersion { get { return version; } }
|
|
public string Name { get { return myconfig.Basic_BotUserName; } }
|
|
public string OwnerName { get { return myconfig.Security_MasterUsername; } }
|
|
public bool GetAllowFunds { get { return myconfig.Setting_AllowFunds; } }
|
|
public string LastStatusMessage { get; set; }
|
|
|
|
public virtual bool KillMe { get { return killMe; } }
|
|
|
|
protected bool teleported;
|
|
public void SetTeleported()
|
|
{
|
|
teleported = true;
|
|
}
|
|
|
|
public bool TeleportStatus()
|
|
{
|
|
return teleported;
|
|
}
|
|
|
|
|
|
public string use_folder = "";
|
|
public void setFolder(string folder)
|
|
{
|
|
use_folder = folder;
|
|
}
|
|
|
|
protected Dictionary<string, string[]> custom_commands = new Dictionary<string, string[]>();
|
|
public Dictionary<string, string[]> getCustomCommands { get { return custom_commands; } }
|
|
protected bool loaded_custom_commands = false;
|
|
protected void LoadCustomCommands()
|
|
{
|
|
if (running_in_docker == true)
|
|
{
|
|
// search env for cmd_
|
|
foreach (System.Collections.DictionaryEntry env in Environment.GetEnvironmentVariables())
|
|
{
|
|
string name = env.Key.ToString();
|
|
if (name.StartsWith("cmd_") == true)
|
|
{
|
|
string[] steps = env.Value.ToString().Split(new [] { "{-}" }, StringSplitOptions.None);
|
|
name = name.Replace("cmd_", "");
|
|
name = name.ToLowerInvariant();
|
|
custom_commands.Add(name, steps);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// search for file called "commands.cmd"
|
|
JsonCommandsfile LoadedCommands = new JsonCommandsfile
|
|
{
|
|
CustomCommands = new [] { "sayexample!!!say|||Hello{-}delay|||2500{-}say|||Bye" }
|
|
};
|
|
string CommandsFile = "custom_commands.json";
|
|
SimpleIO io = new SimpleIO();
|
|
io.ChangeRoot(use_folder);
|
|
if (SimpleIO.FileType(CommandsFile, "json") == true)
|
|
{
|
|
if (io.Exists(CommandsFile) == true)
|
|
{
|
|
string json = io.ReadFile(CommandsFile);
|
|
if (json.Length > 0)
|
|
{
|
|
try
|
|
{
|
|
LoadedCommands = JsonConvert.DeserializeObject<JsonCommandsfile>(json);
|
|
foreach (string loaded in LoadedCommands.CustomCommands)
|
|
{
|
|
string[] bits = loaded.Split(new [] { "!!!" }, StringSplitOptions.None);
|
|
if (bits.Length == 2)
|
|
{
|
|
string[] steps = bits[1].Split(new [] { "{-}" }, StringSplitOptions.None);
|
|
custom_commands.Add(bits[0].ToLowerInvariant(), steps);
|
|
}
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
io.MarkOld(CommandsFile);
|
|
io.WriteJsonCommands(LoadedCommands, CommandsFile);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
io.WriteJsonCommands(LoadedCommands, CommandsFile);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
io.WriteJsonCommands(LoadedCommands, CommandsFile);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
io.WriteJsonCommands(LoadedCommands, CommandsFile);
|
|
}
|
|
}
|
|
if (custom_commands.Count > 0)
|
|
{
|
|
Info("Custom commands: " + custom_commands.Count.ToString());
|
|
}
|
|
}
|
|
|
|
public virtual void KillMePlease()
|
|
{
|
|
killMe = true;
|
|
Client.Network.BeginLogout();
|
|
}
|
|
public virtual void Setup(JsonConfig config, string Version)
|
|
{
|
|
version = Version;
|
|
myconfig = config;
|
|
if (myconfig.Security_SignedCommandkey.Length < 8)
|
|
{
|
|
myconfig.Security_SignedCommandkey = helpers.GetSHA1("" + myconfig.Basic_BotUserName + "" + myconfig.Basic_BotPassword + "" + helpers.UnixTimeNow().ToString() + "").Substring(0, 8);
|
|
Warn("Given code is not acceptable (min length 8)");
|
|
}
|
|
List<string> bits = myconfig.Basic_BotUserName.Split(' ', StringSplitOptions.RemoveEmptyEntries).ToList();
|
|
if (bits.Count == 1)
|
|
{
|
|
bits.Add("Resident");
|
|
myconfig.Basic_BotUserName = String.Join(' ', bits);
|
|
}
|
|
bits = myconfig.Security_MasterUsername.Split(' ', StringSplitOptions.RemoveEmptyEntries).ToList();
|
|
if (bits.Count == 1)
|
|
{
|
|
bits.Add("Resident");
|
|
myconfig.Security_MasterUsername = String.Join(" ", bits);
|
|
|
|
}
|
|
if (helpers.notempty(myconfig.Security_SubMasters) == true)
|
|
{
|
|
SubMasters.Clear();
|
|
string[] submaster_names = myconfig.Security_SubMasters.Split(",", StringSplitOptions.RemoveEmptyEntries);
|
|
foreach (string a in submaster_names)
|
|
{
|
|
if (a.Length > 3)
|
|
{
|
|
bits = a.Split(' ', StringSplitOptions.RemoveEmptyEntries).ToList();
|
|
if (bits.Count == 1)
|
|
{
|
|
bits.Add("Resident");
|
|
}
|
|
string namesubmaster = String.Join(" ", bits);
|
|
if (namesubmaster != myconfig.Security_MasterUsername)
|
|
{
|
|
SubMasters.Add(namesubmaster);
|
|
Info("Sub-Master: " + namesubmaster);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Info("Build: " + version);
|
|
}
|
|
protected virtual string[] getNextHomeArgs()
|
|
{
|
|
return new string[] { };
|
|
}
|
|
public virtual void Start()
|
|
{
|
|
Start(false);
|
|
}
|
|
protected virtual void AvoidSim(string simname)
|
|
{
|
|
}
|
|
|
|
|
|
protected LoginParams LoginLocation(LoginParams LP, bool use_home_region_redirect)
|
|
{
|
|
if (helpers.notempty(myconfig.Basic_LoginLocation) == false)
|
|
{
|
|
myconfig.Basic_LoginLocation = "home";
|
|
Info("LoginLocation: is empty using home!");
|
|
return LP;
|
|
}
|
|
|
|
if (use_home_region_redirect == true)
|
|
{
|
|
if(myconfig.Basic_LoginLocation == "home")
|
|
{
|
|
LP.Start = "last";
|
|
}
|
|
else
|
|
{
|
|
LP.Start = "home";
|
|
}
|
|
Info("LoginLocation: Recovery mode [Using "+ LP.Start+"]");
|
|
myconfig.Basic_LoginLocation = LP.Start;
|
|
LP.LoginLocation = "";
|
|
return LP;
|
|
}
|
|
if ((myconfig.Basic_LoginLocation != "home") && (myconfig.Basic_LoginLocation != "last"))
|
|
{
|
|
LP.Start = "custom";
|
|
LP.LoginLocation = myconfig.Basic_LoginLocation;
|
|
Info("LoginLocation: First login using->" + LP.LoginLocation);
|
|
return LP;
|
|
}
|
|
|
|
LP.Start = myconfig.Basic_LoginLocation;
|
|
LP.LoginLocation = "";
|
|
Info("LoginLocation: First login using->" + LP.Start);
|
|
return LP;
|
|
}
|
|
|
|
public virtual void Start(bool use_home_region_redirect)
|
|
{
|
|
Client = new GridClient();
|
|
Client.Settings.LOG_RESENDS = false;
|
|
Client.Settings.ALWAYS_REQUEST_OBJECTS = true;
|
|
Client.Settings.AVATAR_TRACKING = true;
|
|
List<string> bits = myconfig.Basic_BotUserName.Split(' ').ToList();
|
|
LoginParams Lp;
|
|
string AgentChannel = myconfig.Agent_Channel;
|
|
string AgentVersion = myconfig.Agent_Version;
|
|
if((AgentChannel == "auto") || (AgentChannel == ""))
|
|
{
|
|
AgentChannel = "BetterSecondBot";
|
|
}
|
|
if ((AgentVersion == "auto") || (AgentVersion == ""))
|
|
{
|
|
AgentVersion = version;
|
|
}
|
|
Lp = new LoginParams(Client, bits[0], bits[1], myconfig.Basic_BotPassword, AgentChannel, AgentVersion);
|
|
Lp = LoginLocation(Lp, use_home_region_redirect);
|
|
if (myconfig.Setting_loginURI != "secondlife")
|
|
{
|
|
if (myconfig.Setting_loginURI != null)
|
|
{
|
|
if (myconfig.Setting_loginURI.Length > 5)
|
|
{
|
|
Info("Using custom login server");
|
|
Lp = new LoginParams(Client, bits[0], bits[1], myconfig.Basic_BotPassword, AgentChannel, AgentVersion, myconfig.Setting_loginURI);
|
|
}
|
|
}
|
|
}
|
|
if (reconnect == false)
|
|
{
|
|
BotStartHandler();
|
|
}
|
|
Client.Network.BeginLogin(Lp);
|
|
}
|
|
protected virtual void BotStartHandler()
|
|
{
|
|
Debug("BotStartHandler proc not overridden");
|
|
}
|
|
|
|
protected string GetSimPositionAsString()
|
|
{
|
|
if (Client.Network.Connected == true)
|
|
{
|
|
if (Client.Network.CurrentSim != null)
|
|
{
|
|
int X = Convert.ToInt32(Math.Floor(Client.Self.SimPosition.X));
|
|
int Y = Convert.ToInt32(Math.Floor(Client.Self.SimPosition.Y));
|
|
int Z = Convert.ToInt32(Math.Floor(Client.Self.SimPosition.Z));
|
|
return "" + X.ToString() + "," + Y.ToString() + "," + Z.ToString() + "";
|
|
}
|
|
}
|
|
return "0,0,0";
|
|
}
|
|
|
|
protected string BasicBot_laststatus = "";
|
|
public virtual string GetStatus()
|
|
{
|
|
string reply = "Info: No client";
|
|
if (Client != null)
|
|
{
|
|
reply = "Network: Not ready";
|
|
if (Client.Network != null)
|
|
{
|
|
reply = "Network: Not connected";
|
|
if (Client.Network.Connected)
|
|
{
|
|
reply = "Sim: Not on sim";
|
|
if (Client.Network.CurrentSim != null)
|
|
{
|
|
reply = "Sim: " + Client.Network.CurrentSim.Name + " " + GetSimPositionAsString() + "";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
BasicBot_laststatus = reply;
|
|
return reply;
|
|
}
|
|
|
|
protected virtual void LoginHandler(object o, LoginProgressEventArgs e)
|
|
{
|
|
Debug("LoginHandler proc not overridden");
|
|
}
|
|
|
|
public virtual void AfterBotLoginHandler()
|
|
{
|
|
Debug("AfterBotLoginHandler proc not overridden");
|
|
}
|
|
|
|
|
|
protected virtual void GroupInvite(InstantMessageEventArgs e)
|
|
{
|
|
Debug("GroupInvite proc not overridden");
|
|
}
|
|
protected virtual void FriendshipOffer(UUID IMSessionID, string FromAgentName, UUID FromAgentID)
|
|
{
|
|
Debug("FriendshipOffer proc not overridden");
|
|
}
|
|
|
|
protected virtual void RequestLure(UUID IMSessionID, string FromAgentName, UUID FromAgentID)
|
|
{
|
|
if (Is_avatar_master(FromAgentName) == true)
|
|
{
|
|
Client.Self.SendTeleportLure(FromAgentID);
|
|
}
|
|
}
|
|
|
|
protected List<UUID> accept_next_teleport_from = new List<UUID>();
|
|
public void Add_uuid_to_teleport_list(UUID avatar)
|
|
{
|
|
if (accept_next_teleport_from.Contains(avatar) == false)
|
|
{
|
|
accept_next_teleport_from.Add(avatar);
|
|
}
|
|
}
|
|
|
|
protected virtual void RequestTeleport(UUID IMSessionID, string FromAgentName, UUID FromAgentID)
|
|
{
|
|
Debug("RequestTeleport proc not overridden");
|
|
}
|
|
|
|
protected virtual void ChatInputHandler(object sender, ChatEventArgs e)
|
|
{
|
|
Debug("ChatInputHandler proc not overridden");
|
|
}
|
|
|
|
public virtual void ResetAnimations()
|
|
{
|
|
Debug("reset_animations not enabled at this level");
|
|
}
|
|
|
|
public virtual void Warn(string message)
|
|
{
|
|
Log2File(LogFormater.Warn(message, false), ConsoleLogLogLevel.Warn);
|
|
}
|
|
public virtual void Crit(string message)
|
|
{
|
|
Log2File(LogFormater.Crit(message, false), ConsoleLogLogLevel.Crit);
|
|
}
|
|
public virtual void Info(string message)
|
|
{
|
|
Log2File(LogFormater.Info(message, false), ConsoleLogLogLevel.Info);
|
|
}
|
|
public virtual void Status(string message)
|
|
{
|
|
Log2File(LogFormater.Status(message, false), ConsoleLogLogLevel.Status);
|
|
}
|
|
public virtual void Debug(string message)
|
|
{
|
|
Log2File(LogFormater.Debug(message, false), ConsoleLogLogLevel.Debug);
|
|
}
|
|
|
|
public virtual void Log2File(string message, ConsoleLogLogLevel Level)
|
|
{
|
|
if (myconfig == null)
|
|
{
|
|
Console.WriteLine(message);
|
|
}
|
|
else
|
|
{
|
|
if (myconfig.Log2File_Level >= (int)Level)
|
|
{
|
|
Console.WriteLine(message);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|