public override string Process(RestBot b, Dictionary<string, string> Parameters) { UUID groupUUID; DebugUtilities.WriteDebug("TR - Entering group key parser"); try { bool check = false; if ( Parameters.ContainsKey("key") ) { DebugUtilities.WriteDebug("TR - Attempting to parse from POST"); check = UUID.TryParse(Parameters["key"].ToString().Replace("_"," "), out groupUUID); DebugUtilities.WriteDebug("TR - Succesfully parsed POST"); } else { return "<error>arguments</error>"; } if ( check ) { DebugUtilities.WriteDebug("TR - Activating group"); string response = activateGroup(b, groupUUID); DebugUtilities.WriteDebug("TR - Complete"); return "<active>" + response.Trim() + "</active>\n"; } else { return "<error>parsekey</error>"; } } catch ( Exception e ) { DebugUtilities.WriteError(e.Message); return "<error>parsekey</error>"; } }
/// <summary> /// Internal method to send a message to a group the 'bot is in. /// </summary> /// <param name="b">A currently active RestBot</param> /// <param name="groupUUID">Group UUID</param> /// <param name="message">Message to send to the group IM</param> /// <returns>String with "message sent", if successful; "timeout" otherwise</returns> private string sendIMGroup(RestBot b, UUID groupUUID, string message) { DebugUtilities.WriteInfo(session.ToString() + " " + MethodName + " Sending message '" + message + "' to group UUID " + groupUUID.ToString()); b.Client.Self.GroupChatJoined += Self_GroupChatJoined; if (!b.Client.Self.GroupChatSessions.ContainsKey(groupUUID)) { WaitForSessionStart.Reset(); b.Client.Self.RequestJoinGroupChat(groupUUID); } else { WaitForSessionStart.Set(); } if (WaitForSessionStart.WaitOne(20000, false)) { b.Client.Self.InstantMessageGroup(groupUUID, message); } else { DebugUtilities.WriteInfo(session.ToString() + " " + MethodName + " Timeout waiting for group session start"); return("timeout"); } b.Client.Self.GroupChatJoined -= Self_GroupChatJoined; DebugUtilities.WriteInfo(session.ToString() + " " + MethodName + " Instant Messaged group " + groupUUID.ToString() + " with message: " + message); return("message sent"); }
/// <summary> /// Returns the UUID of a group, given its name /// </summary> /// <param name="b">A currently active RestBot</param> /// <param name="groupName">Group name to search for</param> /// <returns>UUID for the group name, if it exists; UUID.Zero otherwise</returns> public UUID GroupName2UUID(RestBot b, String groupName) { UUID tryUUID; if (UUID.TryParse(groupName, out tryUUID)) { return(tryUUID); } if (null == GroupsCache) { ReloadGroupsCache(b); if (null == GroupsCache) { return(UUID.Zero); } } lock (GroupsCache) { if (GroupsCache.Count > 0) { foreach (Group currentGroup in GroupsCache.Values) { if (currentGroup.Name.ToLower() == groupName.ToLower()) { return(currentGroup.ID); } } } } return(UUID.Zero); }
getKey(RestBot b, String avatarFirstName, String avatarLastName) { String avatarFullName = avatarFirstName.ToString() + " " + avatarLastName.ToString(); return(getKey(b, avatarFullName)); // it will be set to lowercase by getKey() (gwyneth 20220126). }
} // end ParseArguments /// <summary> /// Register all RestPlugins to the RestBot static plugin dictionary /// </summary> /// <param name="assembly">Given assembly to search for</param> static void RegisterAllCommands(Assembly assembly) { foreach (Type t in assembly.GetTypes()) { try { if (t.IsSubclassOf(typeof(RestPlugin))) { ConstructorInfo?info = t.GetConstructor(Type.EmptyTypes); // ask for parameter-less constructor for this class, if it exists (gwyneth 20220425) if (info == null) { // Not a serious warning, some plugins might be incorrectly configured but still work well DebugUtilities.WriteWarning($"Couldn't get constructor without parameters for plugin {t.GetType().Name}!"); } else { RestPlugin plugin = (RestPlugin)info.Invoke(new object[0]); RestBot.AddPlugin(plugin); } } } catch (Exception e) { DebugUtilities.WriteError(e.Message); } } }
Process(RestBot b, Dictionary <string, string> Parameters) { UUID agentKey; try { bool check = false; if (Parameters.ContainsKey("key")) { check = UUID .TryParse(Parameters["key"].ToString().Replace("_", " "), out agentKey); } else { return("<error>arguments</error>"); } if (check) { bool response = getOnline(b, agentKey); return($"<online>{response.ToString()}</online>"); } else { return("<error>unknown</error>"); } } catch (Exception e) { DebugUtilities.WriteError(e.Message); return("<error>parsekey</error>"); } }
// Accessory functions /// <summary> /// Fetch an inventory item /// </summary> /// <param name="b">RESTbot object</param> /// <param name="itemID">UUID of inventory item to fetch</param> /// <returns>An InventoryItem object if it exists, null if not</returns> /// <remarks>C# 8+ is stricter when returning nulls, thus the <c>InventoryItem?</c> method type.</remarks> private InventoryItem?FetchItem(RestBot b, UUID itemID) { InventoryItem? fetchItem = null; AutoResetEvent fetchItemEvent = new AutoResetEvent(false); EventHandler <ItemReceivedEventArgs> itemReceivedCallback = delegate(object?sender, ItemReceivedEventArgs e) { if (e.Item.UUID == itemID) { fetchItem = e.Item; fetchItemEvent.Set(); } }; b.Client.Inventory.ItemReceived += itemReceivedCallback; b.Client.Inventory.RequestFetchInventory(itemID, b.Client.Self.AgentID); fetchItemEvent.WaitOne(INVENTORY_FETCH_TIMEOUT, false); b.Client.Inventory.ItemReceived -= itemReceivedCallback; return(fetchItem); }
private void PrintFolder(RestBot b, InventoryFolder f, StringBuilder result) { List <InventoryBase>?contents = Manager? .FolderContents(f.UUID, b.Client.Self.AgentID, true, true, InventorySortOrder.ByName, 3000); if (contents != null) { foreach (InventoryBase i in contents) { result .AppendFormat("<item><name>{0}</name><itemid>{1}</itemid></item>", i.Name, i.UUID); if (i is InventoryFolder) { InventoryFolder folder = (InventoryFolder)i; PrintFolder(b, folder, result); } } } }
public override void Initialize(RestBot bot) { session = bot.sessionid; me = bot; DebugUtilities.WriteDebug(session + " " + MethodName + " startup"); base.Initialize(bot); }
/// <summary> /// Initialises the plugin. /// </summary> /// <param name="bot">A currently active RestBot</param> /// <returns>void</returns> public override void Initialize(RestBot bot) { session = bot.sessionid; DebugUtilities.WriteDebug($"{session} {MethodName} startup"); // bot.Client.Network.RegisterCallback(PacketType.AvatarPropertiesReply, new NetworkManager.PacketCallback(AvatarPropertiesReply)); // obsolete bot.Client.Avatars.AvatarPropertiesReply += AvatarPropertiesReply; }
/// <summary> /// Initialises the plugin. /// </summary> /// <param name="bot">A currently active RestBot</param> /// <returns>void</returns> public override void Initialize(RestBot bot) { session = bot.sessionid; DebugUtilities.WriteDebug($"{session} {MethodName} startup"); // bot.Client.Network.RegisterCallback(PacketType.DirPeopleReply, new NetworkManager.PacketCallback(Avatars_OnDirPeopleReply)); // obsolete, now uses DirectoryManager bot.Client.Directory.DirPeopleReply += Avatars_OnDirPeopleReply; }
public override string Process(RestBot b, Dictionary<string, string> Paramaters) { b.Client.Settings.ALWAYS_DECODE_OBJECTS=true; string dilation = b.Client.Network.CurrentSim.Stats.Dilation.ToString(); b.Client.Settings.ALWAYS_DECODE_OBJECTS = false; return("<dilation>" + dilation + "</dilation>\n"); }
public override void Initialize(RestBot bot) { session = bot.sessionid; me = bot; DebugUtilities.WriteDebug($"{session} {MethodName} startup"); base.Initialize(bot); }
/// <summary> /// Initialises the plugin. /// </summary> /// <param name="bot">A currently active RestBot</param> /// <returns>void</returns> public override void Initialize(RestBot bot) { session = bot.sessionid; DebugUtilities.WriteDebug($"{session} {MethodName} startup"); // bot.Client.Avatars.OnAvatarProperties += new AvatarManager.AvatarPropertiesCallback(Avatars_OnAvatarProperties); // obsolete bot.Client.Avatars.AvatarPropertiesReply += Avatars_OnAvatarProperties; }
/// <summary> /// Clears the group cache for this 'bot, and reloads it with all /// the current groups that this 'bot is in. /// </summary> /// <param name="b">A currently active RestBot</param> /// <returns>void</returns> public void ReloadGroupsCache(RestBot b) { b.Client.Groups.CurrentGroups += Groups_CurrentGroups; b.Client.Groups.RequestCurrentGroups(); GroupsEvent.WaitOne(10000, false); b.Client.Groups.CurrentGroups -= Groups_CurrentGroups; GroupsEvent.Reset(); }
/// <summary> /// Initialises the plugin. /// </summary> /// <param name="bot">A currently active RestBot</param> public override void Initialize(RestBot bot) { session = bot.sessionid; // why is this saved? It's never used... (gwyneth 20220213) me = bot; DebugUtilities.WriteDebug($"{session} {MethodName} startup"); base.Initialize(bot); // wtf is this for? (gwyneth 20220212) }
/// <summary> /// Initialises the plugin. /// </summary> /// <param name="bot">A currently active RestBot</param> public override void Initialize(RestBot bot) { // ListenCallbacks = new Dictionary<UUID, String>(); session = bot.sessionid; DebugUtilities.WriteDebug($"{session} {MethodName} startup"); base.Initialize(bot); }
Process(RestBot b, Dictionary <string, string> Parameters) { UUID folderID; DebugUtilities.WriteDebug("Entering folder key parser"); try { bool check = false; if (Parameters.ContainsKey("key")) { DebugUtilities.WriteDebug("Attempting to parse from POST"); check = UUID .TryParse(Parameters["key"].ToString().Replace("_", " "), out folderID); DebugUtilities.WriteDebug("Succesfully parsed POST"); } else { folderID = UUID.Zero; // start with root folder check = true; } if ( check // means that we have a correctly parsed key OR no key ) // which is fine too (attempts root folder) { DebugUtilities.WriteDebug("Entering loop"); Manager = b.Client.Inventory; Inventory = Manager.Store; StringBuilder response = new StringBuilder(); InventoryFolder startFolder = new InventoryFolder(folderID); if (folderID == UUID.Zero) { startFolder = Inventory.RootFolder; } PrintFolder(b, startFolder, response); DebugUtilities.WriteDebug("Complete"); return($"<inventory>{response}</inventory>"); } else { return($"<error>{MethodName}: parsekey</error>"); } } catch (Exception e) { DebugUtilities.WriteError(e.Message); return($"<error>{MethodName}: {e.Message}</error>"); } }
} // end Avatars_OnDirPeopleReply() /// <summary> /// name2key (avatar name to UUID) /// </summary> /// <param name="b">RESTbot object</param> /// <param name="name">Name of avatar to check</param> /// <returns>UUID of corresponding avatar, if it exists</returns> public static UUID getKey(RestBot b, String name) { DebugUtilities.WriteInfo("getKey(): Looking up key for " + name); b.Client.Directory.DirPeopleReply += Avatars_OnDirPeopleReply; name = name.ToLower(); DebugUtilities.WriteDebug("getKey(): Looking up: " + name); DebugUtilities .WriteDebug("getKey(): Key not in cache, requesting directory lookup"); // how do you know? (gwyneth 20220128) lock (KeyLookupEvents) { KeyLookupEvents.Add(name, new AutoResetEvent(false)); } DebugUtilities .WriteDebug("getKey(): Lookup Event added, KeyLookupEvents now has a total of " + KeyLookupEvents.Count.ToString() + " entries"); DirFindQueryPacket find = new DirFindQueryPacket(); find.AgentData.AgentID = b.Client.Self.AgentID; // was Network and not Self find.AgentData.SessionID = b.Client.Self.SessionID; find.QueryData.QueryFlags = 1; //find.QueryData.QueryText = Helpers.StringToField(name); find.QueryData.QueryText = Utils.StringToBytes(name); find.QueryData.QueryID = new UUID("00000000000000000000000000000001"); find.QueryData.QueryStart = 0; b.Client.Network.SendPacket((Packet)find); DebugUtilities .WriteDebug("getKey(): Packet sent - KLE has " + KeyLookupEvents.Count.ToString() + " entries.. now waiting"); if (!KeyLookupEvents[name].WaitOne(15000, true)) { DebugUtilities .WriteWarning("getKey(): timed out on avatar name lookup for " + name); } DebugUtilities.WriteDebug("getKey(): Waiting done!"); lock (KeyLookupEvents) { KeyLookupEvents.Remove(name); } DebugUtilities .WriteDebug($"getKey(): Done with KLE, now has {KeyLookupEvents.Count.ToString()} entries"); UUID response = new UUID(); // hopefully this sets the response to UUID.Zero first... (gwyneth 20220128) if (avatarKeys.ContainsKey(name)) { response = avatarKeys[name]; lock (avatarKeys) { avatarKeys.Remove(name); } } b.Client.Directory.DirPeopleReply -= Avatars_OnDirPeopleReply; return(response); } // end getKey()
/// <summary> /// Handler event for this plugin. /// </summary> /// <param name="b">A currently active RestBot</param> /// <param name="Parameters">not used</param> public override string Process(RestBot b, Dictionary <string, string> Parameters) { b.Client.Settings.ALWAYS_DECODE_OBJECTS = true; string dilation = b.Client.Network.CurrentSim.Stats.Dilation.ToString(); b.Client.Settings.ALWAYS_DECODE_OBJECTS = false; return($"<{MethodName}>{dilation}</{MethodName}>"); }
/// <summary> /// Look up the profile for a UUID /// </summary> /// <param name="b">RESTbot object</param> /// <param name="key">UUID of avatar to retrieve profile</param> /// <returns>Full profile as a string, or null if profile is empty/does not exist</returns> /// <remarks>C# 8+ is stricter when returning nulls, thus the <c>string?</c> method type.</remarks> public string?getProfile(RestBot b, UUID key) { DebugUtilities .WriteInfo(session + " " + MethodName + " Looking up profile for " + key.ToString()); lock (ProfileLookupEvents) { ProfileLookupEvents.Add(key, new AutoResetEvent(false)); } b.Client.Avatars.RequestAvatarProperties(key); ProfileLookupEvents[key].WaitOne(15000, true); lock (ProfileLookupEvents) { ProfileLookupEvents.Remove(key); } if (avatarProfile.ContainsKey(key)) { Avatar.AvatarProperties p = avatarProfile[key]; string response = $@" <profile> <publish>{p.AllowPublish.ToString()}</publish> <firstlife> <text> {p.FirstLifeText.Replace(">", "%3C").Replace("<", "%3E")} </text> <image>{p.FirstLifeImage.ToString()}</image> </firstlife> <partner>{p.Partner.ToString()}</partner> <born>{p.BornOn}</born> <about> {p.AboutText.Replace(">", "%3C").Replace("<", "%3E")} </about> <charter>{p.CharterMember}</charter> <profileimage>{p.ProfileImage.ToString()}</profileimage> <mature>{p.MaturePublish.ToString()}</mature> <identified>{p.Identified.ToString()}</identified> <transacted>{p.Transacted.ToString()}</transacted> <url>{p.ProfileURL}</url> </profile>" ; lock (avatarProfile) { avatarProfile.Remove(key); } return(response); } else { return(null); } }
/// <summary> /// Grab all the subclass type definitions of StatefulPlugin out of an assembly /// </summary> /// <param name="assembly">Given assembly to search for</param> static void RegisterAllStatefulPlugins(Assembly assembly) { foreach (Type t in assembly.GetTypes()) { if (t.IsSubclassOf(typeof(StatefulPlugin))) { RestBot.AddStatefulPluginDefinition(t); } } }
/// <summary> /// Handler event for this plugin. /// </summary> /// <param name="b">A currently active RestBot</param> /// <param name="Parameters">A dictionary containing the group UUID and the message to send to group IM</param> /// <returns>XML with information on the sent group IM message, if successful; /// XML error otherwise</returns> public override string Process(RestBot b, Dictionary <string, string> Parameters) { UUID groupUUID; string message; try { bool check = false; if (Parameters.ContainsKey("key")) { check = UUID.TryParse(Parameters["key"].ToString().Replace("_", " "), out groupUUID); } else { return("<error>arguments: no key</error>"); } if (check) { if (Parameters.ContainsKey("message")) { message = Parameters["message"].ToString().Replace("%20", " ").Replace("+", " "); } else { return("<error>arguments: no message</error>"); } } else { return("<error>parsekey</error>"); } message = message.TrimEnd(); if (message.Length > 1023) { message = message.Remove(1023); DebugUtilities.WriteDebug(session + " " + MethodName + " Message truncated at 1024 characters"); } string response = sendIMGroup(b, groupUUID, message); if (string.IsNullOrEmpty(response)) { return("<error>group message not sent, or answer was empty</error>"); } return("<message>" + response.Trim() + "</message>"); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return("<error>loads of errors</error>"); } }
Process(RestBot b, Dictionary <string, string> Parameters) { uint regionX, regionY; Utils .LongToUInts(b.Client.Network.CurrentSim.Handle, out regionX, out regionY); try { string target = String.Empty; if (Parameters.ContainsKey("target")) { target = Parameters["target"] .ToString() .Replace("%20", " ") .Replace("+", " "); } else { return($"<error>{MethodName}: missing argument for target</error>"); } if (target.Length == 0 || target == "off") { Active = false; targetLocalID = 0; b.Client.Self.AutoPilotCancel(); return($"<{MethodName}>off</{MethodName}>"); } else { if (Follow(target)) { return($"<{MethodName}>on</{MethodName}>"); } else { return($"<error>cannot follow {target}</error>"); } } } catch (Exception e) { DebugUtilities.WriteError(e.Message); return($"<error>{MethodName}: {e.Message}</error>"); } }
Process(RestBot b, Dictionary <string, string> Parameters) { try { return($"<{MethodName}><CurrentSim>{b.Client.Network.CurrentSim.ToString()}</CurrentSim><Position>{b.Client.Self.SimPosition.X},{b.Client.Self.SimPosition.Y},{b.Client.Self.SimPosition.Z}</Position></{MethodName}>"); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return($"<error>{MethodName}: {e.Message}</error>"); } }
Process(RestBot b, Dictionary <string, string> Parameters) { try { b.Client.Self.Stand(); return($"<{MethodName}>standing</{MethodName}>"); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return($"<error>{MethodName}: {e.Message}</error>"); } }
/// <summary> /// Handler event for this plugin. /// </summary> /// <param name="b">A currently active RestBot</param> /// <param name="Parameters">none</param> /// <remarks>This will return (some) avatar data associated with the current session ID</remarks> /// if that session is known to exist.</remarks> public override string Process(RestBot b, Dictionary <string, string> Parameters) { if (b == null) // should be impossible { return("<error>invalid request</error>"); } /// Note: the description below is outdated! (gwyneth 20220504) /// <value>Constructs a XML response with the following data: /// <list type="bullet"> /// <item> /// <description>Avatar first name</description> /// </item> /// <item> /// <description>Avatar last name</description> /// </item> /// <item> /// <description>Avatar last namekey (UUID)</description> /// </item> /// <item> /// <description>Current status, same as returned by the "status" member function</description> /// </item> /// <item> /// <description>Session ID (redundant)</description> /// </item> /// <item> /// <description>Uptime (not sure if it's just seconds since login, or date/time of login; assuming the latter)</description> /// </item> /// <item> /// <description>Start position: can be "home", "last", or an URI describing region and position</description> /// </item> /// </list> /// </value> string response = $@"<{MethodName}> <FirstName>{b.First}</FirstName> <LastName>{b.Last}</LastName> <name>{b.First} {b.Last}</name> <key>{b.Client.Self.AgentID.ToString()}</key> <status>{b.myStatus.ToString()}</status> <session_id>{b.sessionid.ToString()}</session_id> <uptime>{b.getUptimeISO8601()}</uptime> <start>{b.Start}</start> <CurrentSim>{b.Client.Network.CurrentSim.ToString()}</CurrentSim> <Position>{b.Client.Self.SimPosition.X},{b.Client.Self.SimPosition.Y},{b.Client.Self.SimPosition.Z}</Position> <Rotation>{b.Client.Self.SimRotation.X},{b.Client.Self.SimRotation.Y},{b.Client.Self.SimRotation.Z},{b.Client.Self.SimRotation.W}</Rotation> </{MethodName}> "; return(response); } // end Process
public override string Process(RestBot b, Dictionary<string, string> Parameters) { try { return String.Format("<location><CurrentSim>{0}</CurrentSim><Position>{1},{2},{3}</Position></location>", b.Client.Network.CurrentSim.ToString(), b.Client.Self.SimPosition.X, b.Client.Self.SimPosition.Y, b.Client.Self.SimPosition.Z); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<error>" + e.Message + "</error>"; } }
public string getGroups(RestBot b, UUID key) { DebugUtilities.WriteInfo(session + " " + MethodName + " Looking up groups for " + key.ToString()); lock ( GroupsLookupEvents ) { GroupsLookupEvents.Add(key, new AutoResetEvent(false) ); } b.Client.Avatars.RequestAvatarProperties(key); GroupsLookupEvents[key].WaitOne(15000, true); lock ( GroupsLookupEvents ) { GroupsLookupEvents.Remove(key); } if (null == avatarGroups) { DebugUtilities.WriteInfo(session + " " + MethodName + " Groups cache failed."); return null; } if (0 == avatarGroups.Count) { DebugUtilities.WriteInfo(session + " " + MethodName + " No groups"); return null; } if ( avatarGroups.ContainsKey(key) ) { string response = "<groups>\n"; foreach (AvatarGroup g in avatarGroups[key]) { response += "<group>\n"; response += "<name>" + g.GroupName.Replace(">", "%3C").Replace("<", "%3E") + "</name>\n"; response += "<key>" + g.GroupID.ToString() + "</key>\n"; response += "<title>" + g.GroupTitle.Replace(">", "%3C").Replace("<", "%3E") + "</title>\n"; response += "<notices>" + g.AcceptNotices.ToString() + "</notices>\n"; response += "<powers>" + g.GroupPowers.ToString() + "</powers>\n"; response += "<insignia>" + g.GroupInsigniaID.ToString() + "</insignia>\n"; response += "</group>\n"; } response += "</groups>\n"; lock ( avatarGroups ) { avatarGroups.Remove(key); } return response; } else { return null; } }
/// <summary>Initialisation</summary> public override void Initialize(RestBot bot) { session = bot.sessionid; // double-checking this, because I really, really want to force a configuration override to turn this off! // (gwyneth 20220412) if (Program.config != null && Program.config.plugin.reaper == true) { DebugUtilities.WriteDebug($"{session} {MethodName} startup"); Reaper.Init(); //start up the reaper if we havent already (the check to see if we have is in this function) } else { DebugUtilities.WriteDebug(session + " REAPER not starting due to configuration override"); } }
public override string Process(RestBot b, Dictionary <string, string> Parameters) { try { string type = String.Empty; bool check = true; float radius = 0.0f; if (Parameters.ContainsKey("type")) { type = Parameters["type"].ToString().Replace("+", " "); } else { check = false; } if (Parameters.ContainsKey("radius")) { check &= float.TryParse(Parameters["radius"], out radius); } else { check = false; } if (!check) { return("<error>parameters have to be type, radius</error>"); } // *** get current location *** Vector3 location = b.Client.Self.SimPosition; Primitive found = b.Client.Network.CurrentSim.ObjectsPrimitives.Find( delegate(Primitive prim) { return(prim.Properties.Name == type); }); return($"<nearby_prim><pos>{found.Position.X},{found.Position.Y},{found.Position.Z}</pos></nearby_prim>"); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return($"<error>{MethodName}: {e.Message}</error>"); } }
/// <summary> /// name2key (avatar name to UUID) /// </summary> /// <param name="b">RESTbot object</param> /// <param name="name">Name of avatar to check</param> /// <returns>UUID of corresponding avatar, if it exists</returns> public UUID getKey(RestBot b, String name) { DebugUtilities .WriteInfo($"{session} {MethodName} Looking up key for {name}"); name = name.ToLower(); DebugUtilities.WriteDebug($"Looking up: {name}"); DebugUtilities .WriteDebug("Key not in cache, requesting directory lookup"); lock (KeyLookupEvents) { KeyLookupEvents.Add(name, new AutoResetEvent(false)); } DebugUtilities .WriteDebug($"Lookup Event added, KeyLookupEvents now has a total of {KeyLookupEvents.Count.ToString()} entries"); DirFindQueryPacket find = new DirFindQueryPacket(); find.AgentData.AgentID = b.Client.Self.AgentID; // was Network and not Self find.AgentData.SessionID = b.Client.Self.SessionID; find.QueryData.QueryFlags = 1; //find.QueryData.QueryText = Helpers.StringToField(name); find.QueryData.QueryText = Utils.StringToBytes(name); find.QueryData.QueryID = new UUID("00000000000000000000000000000001"); find.QueryData.QueryStart = 0; b.Client.Network.SendPacket((Packet)find); DebugUtilities .WriteDebug($"Packet sent - KLE has {KeyLookupEvents.Count.ToString()} entries... now waiting"); KeyLookupEvents[name].WaitOne(15000, true); DebugUtilities.WriteDebug("Waiting done!"); lock (KeyLookupEvents) { KeyLookupEvents.Remove(name); } DebugUtilities .WriteDebug($"Done with KLE, now has {KeyLookupEvents.Count.ToString()} entries"); UUID response = new UUID(); if (avatarKeys.ContainsKey(name)) { response = avatarKeys[name]; lock (avatarKeys) { avatarKeys.Remove(name); } } return(response); }
Process(RestBot b, Dictionary <string, string> Parameters) { try { return(String .Format("<position>{0},{1},{2}</position>", b.Client.Self.SimPosition.X, b.Client.Self.SimPosition.Y, b.Client.Self.SimPosition.Z)); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return($"<error>{e.Message}</error>"); } }
/// <summary> /// Handler event for this plugin. /// </summary> /// <param name="b">A currently active RestBot</param> /// <param name="Parameters">not used</param> /// <remarks><para>This will list all currently known sessions.</para> /// <para>Also note that there is a way to retrieve all sessions (same method name) /// without requiring a valid bot session, just for my own purposes; <see cref="Program.Main" /></para> /// </remarks> public override string Process(RestBot b, Dictionary <string, string> Parameters) { bool check = false; if (Program.Sessions.Count != 0) // no sessions? that's fine, no need to abort { check = true; } string response = $"<{MethodName}>"; if (check) // optimisation: if empty, no need to run the foreach (gwyneth 20220424) { foreach (KeyValuePair <OpenMetaverse.UUID, RESTBot.Session> kvp in Program.Sessions) { if (kvp.Value.Bot != null && kvp.Value.Bot.Client != null && kvp.Value.Bot.Client.Self != null && kvp.Value.Bot.Client.Network != null) { response += $@" <session> <session_id>{kvp.Key.ToString()}</session_id> <key>{kvp.Value.Bot.Client.Self.AgentID.ToString()}</key> <name>{kvp.Value.Bot.Client.Self.FirstName} {kvp.Value.Bot.Client.Self.LastName}</name> <FirstName>{kvp.Value.Bot.Client.Self.FirstName}</FirstName> <LastName>{kvp.Value.Bot.Client.Self.LastName}</LastName> <status>{kvp.Value.Bot.myStatus.ToString()}</status> <uptime>{kvp.Value.Bot.getUptimeISO8601()}</uptime> <start>{kvp.Value.Bot.Start}</start> <CurrentSim>{kvp.Value.Bot.Client.Network.CurrentSim.ToString()}</CurrentSim> <Position>{kvp.Value.Bot.Client.Self.SimPosition.X},{kvp.Value.Bot.Client.Self.SimPosition.Y},{kvp.Value.Bot.Client.Self.SimPosition.Z}</Position> <Rotation>{kvp.Value.Bot.Client.Self.SimRotation.X},{kvp.Value.Bot.Client.Self.SimRotation.Y},{kvp.Value.Bot.Client.Self.SimRotation.Z},{kvp.Value.Bot.Client.Self.SimRotation.W}</Rotation> </session>" ; } else { // Somehow, we have a session ID that has no bot assigned; // this should never be the case, but... (gwyneth 20220426) response += $"<session><session_id>{kvp.Key.ToString()}</session_id><key>{UUID.Zero.ToString()}</key></session>"; } } } else { response += "no sessions"; } response += $"</{MethodName}>"; return(response); } // end Process
/// <summary> /// Handler event for this plugin. /// </summary> /// <param name="b">A currently active RestBot</param> /// <param name="Parameters">not used</param> /// <remarks>This will list statistics only for the simulator where the 'bot currently is.</remarks> public override string Process(RestBot b, Dictionary <string, string> Parameters) { bool check = false; while (!check) { if (b.Client.Network.CurrentSim.Stats.FPS != 0) { check = true; } } string response = $@"<{MethodName}> <dilation>{b.Client.Network.CurrentSim.Stats.Dilation.ToString()}</dilation> <inbps>{b.Client.Network.CurrentSim.Stats.IncomingBPS.ToString()}</inbps> <outbps>{b.Client.Network.CurrentSim.Stats.OutgoingBPS.ToString()}</outbps> <resentout>{b.Client.Network.CurrentSim.Stats.ResentPackets.ToString()}</resentout> <resentin>{b.Client.Network.CurrentSim.Stats.ReceivedResends.ToString()}</resentin> <queue>{b.Client.Network.InboxCount.ToString()}</queue> <fps>{b.Client.Network.CurrentSim.Stats.FPS.ToString()}</fps> <physfps>{b.Client.Network.CurrentSim.Stats.PhysicsFPS.ToString()}</physfps> <agentupdates>{b.Client.Network.CurrentSim.Stats.AgentUpdates.ToString()}</agentupdates> <objects>{b.Client.Network.CurrentSim.Stats.Objects.ToString()}</objects> <scriptedobjects>{b.Client.Network.CurrentSim.Stats.ScriptedObjects.ToString()}</scriptedobjects> <agents>{b.Client.Network.CurrentSim.Stats.Agents.ToString()}</agents> <childagents>{b.Client.Network.CurrentSim.Stats.ChildAgents.ToString()}</childagents> <activescripts>{b.Client.Network.CurrentSim.Stats.ActiveScripts.ToString()}</activescripts> <lslips>{b.Client.Network.CurrentSim.Stats.LSLIPS.ToString()}</lslips> <inpps>{b.Client.Network.CurrentSim.Stats.INPPS.ToString()}</inpps> <outpps>{b.Client.Network.CurrentSim.Stats.OUTPPS.ToString()}</outpps> <pendingdownloads>{b.Client.Network.CurrentSim.Stats.PendingDownloads.ToString()}</pendingdownloads> <pendinguploads>{b.Client.Network.CurrentSim.Stats.PendingUploads.ToString()}</pendinguploads> <virtualsize>{b.Client.Network.CurrentSim.Stats.VirtualSize.ToString()}</virtualsize> <residentsize>{b.Client.Network.CurrentSim.Stats.ResidentSize.ToString()}</residentsize> <pendinglocaluploads>{b.Client.Network.CurrentSim.Stats.PendingLocalUploads.ToString()}</pendinglocaluploads> <unackedbytes>{b.Client.Network.CurrentSim.Stats.UnackedBytes.ToString()}</unackedbytes> <time> <frame>{b.Client.Network.CurrentSim.Stats.FrameTime.ToString()}</frame> <image>{b.Client.Network.CurrentSim.Stats.ImageTime.ToString()}</image> <physics>{b.Client.Network.CurrentSim.Stats.PhysicsTime.ToString()}</physics> <script>{b.Client.Network.CurrentSim.Stats.ScriptTime.ToString()}</script> <other>{b.Client.Network.CurrentSim.Stats.OtherTime.ToString()}</other> </time> </{MethodName}>"; return(response); }
public override string Process(RestBot b, Dictionary<string, string> Paramaters) { bool check = false; while ( !check ) { if ( b.Client.Network.CurrentSim.Stats.FPS != 0 ) { check = true; } } string response = "<stats>\n"; response += "<dilation>" + b.Client.Network.CurrentSim.Stats.Dilation.ToString() + "</dilation>\n"; response += "<inbps>" + b.Client.Network.CurrentSim.Stats.IncomingBPS.ToString() + "</inbps>\n"; response += "<outbps>" + b.Client.Network.CurrentSim.Stats.OutgoingBPS.ToString() + "</outbps>\n"; response += "<resentout>" + b.Client.Network.CurrentSim.Stats.ResentPackets.ToString() + "</resentout>\n"; response += "<resentin>" + b.Client.Network.CurrentSim.Stats.ReceivedResends.ToString() + "</resentin>\n"; response += "<queue>" + b.Client.Network.InboxCount.ToString() + "</queue>\n"; response += "<fps>" + b.Client.Network.CurrentSim.Stats.FPS.ToString() + "</fps>\n"; response += "<physfps>" + b.Client.Network.CurrentSim.Stats.PhysicsFPS.ToString() + "</physfps>\n"; response += "<agentupdates>" + b.Client.Network.CurrentSim.Stats.AgentUpdates.ToString() + "</agentupdates>\n"; response += "<objects>" + b.Client.Network.CurrentSim.Stats.Objects.ToString() + "</objects>\n"; response += "<scriptedobjects>" + b.Client.Network.CurrentSim.Stats.ScriptedObjects.ToString() + "</scriptedobjects>\n"; response += "<agents>" + b.Client.Network.CurrentSim.Stats.Agents.ToString() + "</agents>\n"; response += "<childagents>" + b.Client.Network.CurrentSim.Stats.ChildAgents.ToString() + "</childagents>\n"; response += "<activescripts>" + b.Client.Network.CurrentSim.Stats.ActiveScripts.ToString() + "</activescripts>\n"; response += "<lslips>" + b.Client.Network.CurrentSim.Stats.LSLIPS.ToString() + "</lslips>\n"; response += "<inpps>" + b.Client.Network.CurrentSim.Stats.INPPS.ToString() + "</inpps>\n"; response += "<outpps>" + b.Client.Network.CurrentSim.Stats.OUTPPS.ToString() + "</outpps>\n"; response += "<pendingdownloads>" + b.Client.Network.CurrentSim.Stats.PendingDownloads.ToString() + "</pendingdownloads>\n"; response += "<pendinguploads>" + b.Client.Network.CurrentSim.Stats.PendingUploads.ToString() + "</pendinguploads>\n"; response += "<virtualsize>" + b.Client.Network.CurrentSim.Stats.VirtualSize.ToString() + "</virtualsize>\n"; response += "<residentsize>" + b.Client.Network.CurrentSim.Stats.ResidentSize.ToString() + "</residentsize>\n"; response += "<pendinglocaluploads>" + b.Client.Network.CurrentSim.Stats.PendingLocalUploads.ToString() + "</pendinglocaluploads>\n"; response += "<unackedbytes>" + b.Client.Network.CurrentSim.Stats.UnackedBytes.ToString() + "</unackedbytes>\n"; response += "<time>\n"; response += "<frame>" + b.Client.Network.CurrentSim.Stats.FrameTime.ToString() + "</frame>\n"; response += "<image>" + b.Client.Network.CurrentSim.Stats.ImageTime.ToString() + "</image>\n"; response += "<physics>" + b.Client.Network.CurrentSim.Stats.PhysicsTime.ToString() + "</physics>\n"; response += "<script>" + b.Client.Network.CurrentSim.Stats.ScriptTime.ToString() + "</script>\n"; response += "<other>" + b.Client.Network.CurrentSim.Stats.OtherTime.ToString() + "</other>\n"; response += "</time>\n"; response += "</stats>\n"; return (response); }
public override string Process(RestBot b, Dictionary<string, string> Paramaters) { try { string type = String.Empty; bool check = true; float radius = 0.0f; if (Paramaters.ContainsKey("type")) { type = Paramaters["type"].ToString().Replace("+", " "); } else check = false; if (Paramaters.ContainsKey("radius")) { check &= float.TryParse(Paramaters["radius"], out radius); } else check = false; if (!check) { return "<error>parameters have to be type, radius</error>"; } // *** get current location *** Vector3 location = b.Client.Self.SimPosition; Primitive found = b.Client.Network.CurrentSim.ObjectsPrimitives.Find( delegate(Primitive prim) { return prim.Properties.Name == type; }); return "<nearby_prim>" + String.Format("<pos>{1},{2},{3}</pos>", found.Position.X, found.Position.Y, found.Position.Z) + "</nearby_prim>"; } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<error>" + e.Message + "</error>"; } }
public override string Process(RestBot b, Dictionary<string, string> Parameters) { uint regionX, regionY; Utils.LongToUInts(b.Client.Network.CurrentSim.Handle, out regionX, out regionY); try { double x = 0.0f, y = 0.0f, z = 0.0f, distance = 0.0f; bool check = true; bool run = false; if (Parameters.ContainsKey("x")) { check &= double.TryParse(Parameters["x"], out x); DebugUtilities.WriteDebug("Parse: " + Parameters["x"] + " into " + x); } else check = false; if (Parameters.ContainsKey("y")) { check &= double.TryParse(Parameters["y"], out y); } else check = false; if (Parameters.ContainsKey("z")) { check &= double.TryParse(Parameters["z"], out z); } else check = false; if (Parameters.ContainsKey("distance")) { check &= double.TryParse(Parameters["distance"], out distance); } if (Parameters.ContainsKey("run")) { check &= bool.TryParse(Parameters["run"], out run); } if (!check) { return "<error>parameters have to be x, y, z, [distance, run]</error>"; } if (run) { b.Client.Self.Movement.AlwaysRun = true; } else { b.Client.Self.Movement.AlwaysRun = false; } goalPos = new Vector3((float)x, (float)y, (float)z); b.Client.Self.Movement.TurnToward(goalPos); b.Client.Self.Movement.SendUpdate(false); prevDistance = Vector3.Distance(goalPos, me.Client.Self.SimPosition); // Convert the local coordinates to global ones by adding the region handle parts to x and y b.Client.Self.AutoPilot(goalPos.X + regionX, goalPos.Y + regionY, goalPos.Z); Active = true; while (Active) { Thread.Sleep(1 * 1000); } DebugUtilities.WriteSpecial("End Thread!"); return String.Format("<move>{0},{1},{2}</move>", b.Client.Self.GlobalPosition.X, b.Client.Self.GlobalPosition.Y, b.Client.Self.GlobalPosition.Z); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<error>" + e.Message + "</error>"; } }
public UUID getKey(RestBot b, String name) { DebugUtilities.WriteInfo(session + " " + MethodName + " Looking up key for " + name); name = name.ToLower(); DebugUtilities.WriteDebug("Looking up: " + name); DebugUtilities.WriteDebug("Key not in cache, requesting directory lookup"); lock ( KeyLookupEvents) { KeyLookupEvents.Add(name, new AutoResetEvent(false)); } DebugUtilities.WriteDebug("Lookup Event added, KeyLookupEvents now has a total of " + KeyLookupEvents.Count.ToString() + " entries"); DirFindQueryPacket find = new DirFindQueryPacket(); find.AgentData.AgentID = b.Client.Self.AgentID; // was Network and not Self find.AgentData.SessionID = b.Client.Self.SessionID; find.QueryData.QueryFlags = 1; //find.QueryData.QueryText = Helpers.StringToField(name); find.QueryData.QueryText = Utils.StringToBytes(name); find.QueryData.QueryID = new UUID("00000000000000000000000000000001"); find.QueryData.QueryStart = 0; b.Client.Network.SendPacket((Packet) find); DebugUtilities.WriteDebug("Packet sent - KLE has " + KeyLookupEvents.Count.ToString() + " entries.. now waiting"); KeyLookupEvents[name].WaitOne(15000,true); DebugUtilities.WriteDebug("Waiting done!"); lock (KeyLookupEvents) { KeyLookupEvents.Remove(name); } DebugUtilities.WriteDebug("Done with KLE, now has " + KeyLookupEvents.Count.ToString() + " entries"); UUID response = new UUID(); if ( avatarKeys.ContainsKey(name) ) { response = avatarKeys[name]; lock ( avatarKeys ) { avatarKeys.Remove(name); } } return response; }
public override string Process(RestBot b, Dictionary<string, string> Paramaters) { try { string type = String.Empty; bool check = true; float radius = 0.0f; if (Paramaters.ContainsKey("type")) { type = Paramaters["type"].ToString().Replace("+", " "); } else check = false; if (Paramaters.ContainsKey("radius")) { check &= float.TryParse(Paramaters["radius"], out radius); } else check = false; if (!check) { return "<error>parameters have to be type, radius</error>"; } // *** get current location *** Vector3 location = b.Client.Self.SimPosition; // *** find all objects in radius *** List<Primitive> prims = b.Client.Network.CurrentSim.ObjectsPrimitives.FindAll( delegate(Primitive prim) { Vector3 pos = prim.Position; return ((prim.ParentID == 0) && (pos != Vector3.Zero) && (Vector3.Distance(pos, location) < radius)); } ); // *** request properties of these objects *** bool complete = RequestObjectProperties(prims, 0); String resultSet = String.Empty; foreach (Primitive p in prims) { string name = p.Properties != null ? p.Properties.Name : null; if (String.IsNullOrEmpty(type) || ((name != null) && (name.Contains(type)))) { resultSet += String.Format("<prim><name>{0}</name><pos>{1},{2},{3}</pos></prim>", name, p.Position.X, p.Position.Y, p.Position.Z); } } return "<nearby_prims>" + resultSet + "</nearby_prims>"; } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<error>" + e.Message + "</error>"; } }
public override string Process(RestBot b, Dictionary<string, string> Parameters) { UUID avatar = UUID.Zero; UUID group = UUID.Zero; UUID role = UUID.Zero; List<UUID> roles = new List<UUID>(); try { bool check = false; if ( Parameters.ContainsKey("avatar") ) { check = UUID.TryParse(Parameters["avatar"].ToString().Replace("_"," "), out avatar); } else { return "<error>arguments: no avatar key</error>"; } if ( check ) { if ( Parameters.ContainsKey("group") ) { check = UUID.TryParse(Parameters["group"].ToString().Replace("_"," "), out group); } else { return "<error>arguments: no group key</error>"; } // to-do: avatars can be invited to multiple roles. if ( Parameters.ContainsKey("role") ) { if (! UUID.TryParse(Parameters["role"].ToString().Replace("_"," "), out role) ) { // just a warning, role is optional DebugUtilities.WriteDebug(session + " " + MethodName + " no role found, but that's ok"); } roles.Add(role); } else { roles.Add(UUID.Zero); // no roles to add } } else { return "<error>parsekey</error>"; } DebugUtilities.WriteDebug(session + " " + MethodName + " Group UUID: " + group + " Avatar UUID to join group: " + avatar + " Role UUID for avatar to join: " + roles.ToString() + " (NULL_KEY is fine)"); b.Client.Groups.Invite(group, roles, avatar); return "<invitation>invited " + avatar + " to " + group + "</invitation>\n"; } catch ( Exception e ) { DebugUtilities.WriteError(e.Message); return "<error>loads of errors</error>"; } }
private string activateGroup(RestBot b, UUID groupUUID) { DebugUtilities.WriteInfo(session.ToString() + " " + MethodName + " Activating group " + groupUUID.ToString()); EventHandler<PacketReceivedEventArgs> pcallback = AgentDataUpdateHandler; b.Client.Network.RegisterCallback(PacketType.AgentDataUpdate, pcallback); b.Client.Groups.ActivateGroup(groupUUID); if ( ! GroupsEvent.WaitOne(15000, true) ) { DebugUtilities.WriteWarning(session + " " + MethodName + " timed out on setting active group"); } // ignore everything and just reset the event b.Client.Network.UnregisterCallback(PacketType.AgentDataUpdate, pcallback); GroupsEvent.Reset(); if (String.IsNullOrEmpty(activeGroup)) DebugUtilities.WriteWarning(session + " " + MethodName + " Failed to activate the group " + groupUUID); return activeGroup; }
public override string Process(RestBot b, Dictionary<string, string> Parameters) { try { string sim = ""; float x = 128.0f, y = 128.0f, z = 30.0f; bool check = true; if (Parameters.ContainsKey("sim")) { sim = Parameters["sim"].ToString(); } else check = false; if (Parameters.ContainsKey("x")) { check &= float.TryParse(Parameters["x"], out x); } else check = false; if (Parameters.ContainsKey("y")) { check &= float.TryParse(Parameters["y"], out y); } else check = false; if (Parameters.ContainsKey("z")) { check &= float.TryParse(Parameters["z"], out z); } else check = false; if (!check) { return "<error>parameters have to be simulator name, x, y, z</error>"; } if (b.Client.Self.Teleport(sim, new Vector3(x, y, z))) return "<teleport>" + b.Client.Network.CurrentSim + "</teleport>"; else return "<error>Teleport failed: " + b.Client.Self.TeleportMessage + "</error>"; } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<error>" + e.Message + "</error>"; } }
/// <summary> /// Process the request through this method /// </summary> /// <param name="b">The RestBot that is doing the processing</param> /// <param name="Paramaters">QueryString and POST parameters</param> /// <returns>XML output</returns> public abstract string Process(RestBot b, Dictionary<string, string> Paramaters);
public override string Process(RestBot b, Dictionary<string, string> Parameters) { try { string name = ""; bool check = true; if (Parameters.ContainsKey("target")) { name = Parameters["target"].ToString().Replace("+", " "); } else check = false; if (!check) { return "<error>parameters have to be target name</error>"; } lock (b.Client.Network.Simulators) { for (int i = 0; i < b.Client.Network.Simulators.Count; i++) { DebugUtilities.WriteDebug("Found Avatars: " + b.Client.Network.Simulators[i].ObjectsAvatars.Count); Avatar target = b.Client.Network.Simulators[i].ObjectsAvatars.Find( delegate(Avatar avatar) { DebugUtilities.WriteDebug("Found avatar: " + avatar.Name); return avatar.Name == name; } ); if (target != null) { return String.Format("<goal_position>{0},{1},{2}</goal_position><curr_position>{3},{4},{5}</curr_position>", target.Position.X, target.Position.Y, target.Position.Z, b.Client.Self.SimPosition.X, b.Client.Self.SimPosition.Y, b.Client.Self.SimPosition.Z); } else { DebugUtilities.WriteError("Error obtaining the avatar: " + name); } } } return "<error>avatar_position failed.</error>"; } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<error>" + e.Message + "</error>"; } }
public string getProfile(RestBot b, UUID key) { DebugUtilities.WriteInfo(session + " " + MethodName + " Looking up profile for " + key.ToString()); lock ( ProfileLookupEvents ) { ProfileLookupEvents.Add(key, new AutoResetEvent(false) ); } b.Client.Avatars.RequestAvatarProperties(key); ProfileLookupEvents[key].WaitOne(15000, true); lock ( ProfileLookupEvents ) { ProfileLookupEvents.Remove(key); } if ( avatarProfile.ContainsKey(key) ) { Avatar.AvatarProperties p = avatarProfile[key]; string response = "<profile>\n"; response += "<publish>" + p.AllowPublish.ToString() + "</publish>\n"; response += "<firstlife>\n"; response += "<text>" + p.FirstLifeText.Replace(">", "%3C").Replace("<", "%3E") + "</text>\n"; response += "<image>" + p.FirstLifeImage.ToString() + "</image>\n"; response += "</firstlife>\n"; response += "<partner>" + p.Partner.ToString() + "</partner>\n"; response += "<born>" + p.BornOn + "</born>\n"; response += "<about>" + p.AboutText.Replace(">", "%3C").Replace("<", "%3E") + "</about>\n"; response += "<charter>" + p.CharterMember + "</charter>\n"; response += "<profileimage>" + p.ProfileImage.ToString() + "</profileimage>\n"; response += "<mature>" + p.MaturePublish.ToString() + "</mature>\n"; response += "<identified>" + p.Identified.ToString() + "</identified>\n"; response += "<transacted>" + p.Transacted.ToString() + "</transacted>\n"; response += "<url>" + p.ProfileURL + "</url>\n"; response += "</profile>\n"; lock ( avatarProfile ) { avatarProfile.Remove(key); } return response; } else { return null; } }
public override void Initialize(RestBot bot) { session = bot.sessionid; DebugUtilities.WriteDebug(session + " " + MethodName + " startup"); // bot.Client.Avatars.OnAvatarProperties += new AvatarManager.AvatarPropertiesCallback(Avatars_OnAvatarProperties); // obsolete bot.Client.Avatars.AvatarPropertiesReply += Avatars_OnAvatarProperties; }
public override string Process(RestBot b, Dictionary<string, string> Paramaters) { UUID agentKey; try { bool check = false; if (Paramaters.ContainsKey("key")) { check = UUID.TryParse(Paramaters["key"].ToString().Replace("_"," "), out agentKey); } else { return "<error>arguments</error>"; } if ( check ) { string response = getProfile(b, agentKey); if ( response == null ) { return "<error>not found</error>"; } else { return response; } } else { return "<error>unknown</error>"; } } catch ( Exception e ) { DebugUtilities.WriteError(e.Message); return "<error>parsekey</error>"; } }
public override string Process(RestBot b, Dictionary<string, string> Parameters) { try { return String.Format("<position>{0},{1},{2}</error>", b.Client.Self.SimPosition.X, b.Client.Self.SimPosition.Y, b.Client.Self.SimPosition.Z); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<error>" + e.Message + "</error>"; } }
private string sendIMGroup(RestBot b, UUID groupUUID, string message) { DebugUtilities.WriteInfo(session.ToString() + " " + MethodName + " Sending message '" + message + "' to group UUID " + groupUUID.ToString()); b.Client.Self.GroupChatJoined += Self_GroupChatJoined; if (!b.Client.Self.GroupChatSessions.ContainsKey(groupUUID)) { WaitForSessionStart.Reset(); b.Client.Self.RequestJoinGroupChat(groupUUID); } else { WaitForSessionStart.Set(); } if (WaitForSessionStart.WaitOne(20000, false)) { b.Client.Self.InstantMessageGroup(groupUUID, message); } else { DebugUtilities.WriteInfo(session.ToString() + " " + MethodName + " Timeout waiting for group session start"); return "timeout"; } b.Client.Self.GroupChatJoined -= Self_GroupChatJoined; DebugUtilities.WriteInfo(session.ToString() + " " + MethodName + " Instant Messaged group " + groupUUID.ToString() + " with message: " + message); return "message sent"; }
/// <summary> /// An optionally overridable method for setting up events and callbacks from a RestBot /// </summary> /// <param name="bot"></param> public virtual void Initialize(RestBot bot) { }
public override void Initialize(RestBot bot) { session = bot.sessionid; DebugUtilities.WriteDebug(session + " " + MethodName + " startup"); // bot.Client.Network.RegisterCallback(PacketType.AvatarPropertiesReply, new NetworkManager.PacketCallback(AvatarPropertiesReply)); // obsolete bot.Client.Avatars.AvatarPropertiesReply += AvatarPropertiesReply; }
public override string Process(RestBot b, Dictionary<string, string> Parameters) { Utils.LongToUInts(b.Client.Network.CurrentSim.Handle, out regionX, out regionY); try { double x = 0.0f, y = 0.0f, z = 0.0f; bool check = true; bool run = false; string avatarName = String.Empty; if (Parameters.ContainsKey("avatar")) { avatarName = Parameters["avatar"].ToString().Replace("+", " "); } else check = false; if (!check) { return "<error>parameters have to be x, y, z, [distance, run]</error>"; } if (run) { b.Client.Self.Movement.AlwaysRun = true; } else { b.Client.Self.Movement.AlwaysRun = false; } lock (b.Client.Network.Simulators) { for (int i = 0; i < b.Client.Network.Simulators.Count; i++) { DebugUtilities.WriteDebug("Found Avatars: " + b.Client.Network.Simulators[i].ObjectsAvatars.Count); target = b.Client.Network.Simulators[i].ObjectsAvatars.Find( delegate(Avatar avatar) { DebugUtilities.WriteDebug("Found avatar: " + avatar.Name); return avatar.Name == avatarName; } ); if (target != null) { goalPos = target.Position; } else { DebugUtilities.WriteError("Error obtaining the avatar: " + avatarName); return String.Format("<error>Error obtaining the avatar</error>"); } } } goalPos = new Vector3((float)x, (float)y, (float)z); b.Client.Self.Movement.TurnToward(goalPos); b.Client.Self.Movement.SendUpdate(false); prevDistance = Vector3.Distance(goalPos, me.Client.Self.SimPosition); if (prevDistance > 30) { b.Client.Self.Movement.AlwaysRun = true; } else { b.Client.Self.Movement.AlwaysRun = false; } // Convert the local coordinates to global ones by adding the region handle parts to x and y b.Client.Self.AutoPilot(goalPos.X + regionX, goalPos.Y + regionY, goalPos.Z); Active = true; while (Active) { Thread.Sleep(1 * 1000); } DebugUtilities.WriteSpecial("End Thread!"); return String.Format("<move>{0},{1},{2}</move>", b.Client.Self.GlobalPosition.X, b.Client.Self.GlobalPosition.Y, b.Client.Self.GlobalPosition.Z); } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<error>" + e.Message + "</error>"; } }
public bool getOnline(RestBot b, UUID key) { DebugUtilities.WriteInfo(session + " " + MethodName + " Looking up online status for " + key.ToString()); lock ( OnlineLookupEvents ) { OnlineLookupEvents.Add(key, new AutoResetEvent(false) ); } // obsolete /* AvatarPropertiesRequestPacket p = new AvatarPropertiesRequestPacket(); p.AgentData.AgentID = b.Client.Network.AgentID; p.AgentData.SessionID = b.Client.Network.SessionID; p.AgentData.AvatarID = key; b.Client.Network.SendPacket( (Packet) p); */ b.Client.Avatars.RequestAvatarProperties(key); OnlineLookupEvents[key].WaitOne(15000, true); lock ( OnlineLookupEvents ) { OnlineLookupEvents.Remove(key); } bool response = avatarOnline[key]; lock ( avatarOnline ) { avatarOnline.Remove(key); } return response; }
public override string Process(RestBot b, Dictionary<string, string> Parameters) { uint regionX, regionY; Utils.LongToUInts(b.Client.Network.CurrentSim.Handle, out regionX, out regionY); try { string target = String.Empty; if (Parameters.ContainsKey("target")) { target = Parameters["target"].ToString().Replace("%20", " ").Replace("+", " "); } else { return "<error>arguments</error>"; } if (target.Length == 0 || target == "off") { Active = false; targetLocalID = 0; b.Client.Self.AutoPilotCancel(); return "<follow>off</follow>"; } else { if (Follow(target)) return "<follow>on</follow>"; else return "<follow>error</follow>"; } } catch (Exception e) { DebugUtilities.WriteError(e.Message); return "<follow>error: " + e.Message + "</follow>"; } }
private string getName(RestBot b, UUID id) { DebugUtilities.WriteInfo(session.ToString() + " " + MethodName + " Looking up name for " + id.ToString()); lock (NameLookupEvents) { NameLookupEvents.Add(id, new AutoResetEvent(false)); } b.Client.Avatars.RequestAvatarName(id); if ( ! NameLookupEvents[id].WaitOne(15000, true) ) { DebugUtilities.WriteWarning(session + " " + MethodName + " timed out on avatar name lookup"); } lock (NameLookupEvents) { NameLookupEvents.Remove(id); } string response = null; if ( avatarNames.ContainsKey(id) ) { response = avatarNames[id]; // .Name removed lock ( avatarNames ) { avatarNames.Remove(id); } } else { response = String.Empty; } return response; }
public override string Process(RestBot b, Dictionary<string, string> Parameters) { string message; string subject; UUID groupUUID = UUID.Zero; UUID attachmentUUID = UUID.Zero; GroupNotice notice; try { if ( Parameters.ContainsKey("subject") ) { subject = Parameters["subject"].ToString().Replace("%20"," ").Replace("+"," "); } else { return "<error>No notice subject</error>"; } if ( Parameters.ContainsKey("message") ) { message = Parameters["message"].ToString().Replace("%20"," ").Replace("+"," "); } else { return "<error>No notice message</error>"; } if ( Parameters.ContainsKey("group") ) { if (! UUID.TryParse(Parameters["group"].ToString().Replace("_"," "), out groupUUID) ) { return "<error>parsekey group</error>"; } } else { return "<error>arguments: no group key</error>"; } if ( Parameters.ContainsKey("attachment") ) { if (! UUID.TryParse(Parameters["attachment"].ToString().Replace("_"," "), out attachmentUUID) ) { return "<error>parsekey attachment</error>"; } } else { // just a warning, attachment can be empty DebugUtilities.WriteWarning(session + " " + MethodName + " Notice has no attachment (no problem)"); } DebugUtilities.WriteDebug(session + " " + MethodName + " Attempting to create a notice"); /* This doesn't work as it should! if (! b.Client.Inventory.Store.Contains(attachmentUUID)) { DebugUtilities.WriteWarning(session + " " + MethodName + " Item UUID " + attachmentUUID.ToString() + " not found on inventory (are you using an Asset UUID by mistake?)"); attachmentUUID = UUID.Zero; } */ notice = new GroupNotice(); notice.Subject = subject; notice.Message = message; notice.AttachmentID = attachmentUUID; // this is the inventory UUID, not the asset UUID notice.OwnerID = b.Client.Self.AgentID; b.Client.Groups.SendGroupNotice(groupUUID, notice); DebugUtilities.WriteDebug(session + " " + MethodName + " Sent Notice from avatar " + notice.OwnerID.ToString() + " to group: " + groupUUID.ToString() + " subject: '" + notice.Subject.ToString() + "' message: '" + notice.Message.ToString() + "' Optional attachment: " + notice.AttachmentID.ToString() + " Serialisation: " + Utils.BytesToString(notice.SerializeAttachment())); return "<notice>sent</notice>\n"; } catch ( Exception e ) { DebugUtilities.WriteError(e.Message); return "<error>loads of errors</error>"; } }
public override string Process(RestBot b, Dictionary<string, string> Paramaters) { string avname = null; if ( Paramaters.ContainsKey("name") ) { avname = Paramaters["name"].ToString().Replace("%20"," ").Replace("+"," "); } else { return "<error>arguments</error>"; } if ( avname != null ) { string response = getKey(b,avname).ToString(); return "<key>" + response + "</key>\n"; } else { return "<error>nokey</error>"; } }
public override string Process(RestBot b, Dictionary<string, string> Parameters) { UUID groupUUID; string message; try { bool check = false; if ( Parameters.ContainsKey("key") ) { check = UUID.TryParse(Parameters["key"].ToString().Replace("_"," "), out groupUUID); } else { return "<error>arguments: no key</error>"; } if ( check ) { if ( Parameters.ContainsKey("message") ) { message = Parameters["message"].ToString().Replace("%20"," ").Replace("+"," "); } else { return "<error>arguments: no message</error>"; } } else { return "<error>parsekey</error>"; } message = message.TrimEnd(); if (message.Length > 1023) { message = message.Remove(1023); DebugUtilities.WriteDebug(session + " " + MethodName + " Message truncated at 1024 characters"); } string response = sendIMGroup(b, groupUUID, message); return "<message>" + response.Trim() + "</message>\n"; } catch ( Exception e ) { DebugUtilities.WriteError(e.Message); return "<error>loads of errors</error>"; } }
public override void Initialize(RestBot bot) { session = bot.sessionid; DebugUtilities.WriteDebug(session + " " + MethodName + " startup"); // bot.Client.Network.RegisterCallback(PacketType.DirPeopleReply, new NetworkManager.PacketCallback(Avatars_OnDirPeopleReply)); // obsolete, now uses DirectoryManager bot.Client.Directory.DirPeopleReply += Avatars_OnDirPeopleReply; }