/* * Copyright (c) 2007-2009, openmetaverse.org * All rights reserved. * * - Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * - Redistributions of source code must retain the above copyright notice, this * list of conditions and the following disclaimer. * - Neither the name of the openmetaverse.org nor the names * of its contributors may be used to endorse or promote products derived from * this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE * POSSIBILITY OF SUCH DAMAGE. */ using System; using System.Net; using System.Text; using System.Threading; using System.Reflection; using System.Collections.Generic; using OpenMetaverse.StructuredData; using OpenMetaverse.Http; using OpenMetaverse.Assets; using OpenMetaverse.Packets; using OpenMetaverse.Interfaces; using OpenMetaverse.Messages.Linden; namespace OpenMetaverse { #region Enums /// /// Permission request flags, asked when a script wants to control an Avatar /// [Flags] public enum ScriptPermission : int { /// Placeholder for empty values, shouldn't ever see this None = 0, /// Script wants ability to take money from you Debit = 1 << 1, /// Script wants to take camera controls for you TakeControls = 1 << 2, /// Script wants to remap avatars controls RemapControls = 1 << 3, /// Script wants to trigger avatar animations /// This function is not implemented on the grid TriggerAnimation = 1 << 4, /// Script wants to attach or detach the prim or primset to your avatar Attach = 1 << 5, /// Script wants permission to release ownership /// This function is not implemented on the grid /// The concept of "public" objects does not exist anymore. ReleaseOwnership = 1 << 6, /// Script wants ability to link/delink with other prims ChangeLinks = 1 << 7, /// Script wants permission to change joints /// This function is not implemented on the grid ChangeJoints = 1 << 8, /// Script wants permissions to change permissions /// This function is not implemented on the grid ChangePermissions = 1 << 9, /// Script wants to track avatars camera position and rotation TrackCamera = 1 << 10, /// Script wants to control your camera ControlCamera = 1 << 11 } /// /// Special commands used in Instant Messages /// public enum InstantMessageDialog : byte { /// Indicates a regular IM from another agent MessageFromAgent = 0, /// Simple notification box with an OK button MessageBox = 1, // Used to show a countdown notification with an OK // button, deprecated now //[Obsolete] //MessageBoxCountdown = 2, /// You've been invited to join a group. GroupInvitation = 3, /// Inventory offer InventoryOffered = 4, /// Accepted inventory offer InventoryAccepted = 5, /// Declined inventory offer InventoryDeclined = 6, /// Group vote GroupVote = 7, // A message to everyone in the agent's group, no longer // used //[Obsolete] //DeprecatedGroupMessage = 8, /// An object is offering its inventory TaskInventoryOffered = 9, /// Accept an inventory offer from an object TaskInventoryAccepted = 10, /// Decline an inventory offer from an object TaskInventoryDeclined = 11, /// Unknown NewUserDefault = 12, /// Start a session, or add users to a session SessionAdd = 13, /// Start a session, but don't prune offline users SessionOfflineAdd = 14, /// Start a session with your group SessionGroupStart = 15, /// Start a session without a calling card (finder or objects) SessionCardlessStart = 16, /// Send a message to a session SessionSend = 17, /// Leave a session SessionDrop = 18, /// Indicates that the IM is from an object MessageFromObject = 19, /// Sent an IM to a busy user, this is the auto response BusyAutoResponse = 20, /// Shows the message in the console and chat history ConsoleAndChatHistory = 21, /// Send a teleport lure RequestTeleport = 22, /// Response sent to the agent which inititiated a teleport invitation AcceptTeleport = 23, /// Response sent to the agent which inititiated a teleport invitation DenyTeleport = 24, /// Only useful if you have Linden permissions GodLikeRequestTeleport = 25, /// A placeholder type for future expansion, currently not /// used CurrentlyUnused = 26, // Notification of a new group election, this is // deprecated //[Obsolete] //DeprecatedGroupElection = 27, /// IM to tell the user to go to an URL GotoUrl = 28, /// IM for help Session911Start = 29, /// IM sent automatically on call for help, sends a lure /// to each Helper reached Lure911 = 30, /// Like an IM but won't go to email FromTaskAsAlert = 31, /// IM from a group officer to all group members GroupNotice = 32, /// Unknown GroupNoticeInventoryAccepted = 33, /// Unknown GroupNoticeInventoryDeclined = 34, /// Accept a group invitation GroupInvitationAccept = 35, /// Decline a group invitation GroupInvitationDecline = 36, /// Unknown GroupNoticeRequested = 37, /// An avatar is offering you friendship FriendshipOffered = 38, /// An avatar has accepted your friendship offer FriendshipAccepted = 39, /// An avatar has declined your friendship offer FriendshipDeclined = 40, /// Indicates that a user has started typing StartTyping = 41, /// Indicates that a user has stopped typing StopTyping = 42 } /// /// Flag in Instant Messages, whether the IM should be delivered to /// offline avatars as well /// public enum InstantMessageOnline { /// Only deliver to online avatars Online = 0, /// If the avatar is offline the message will be held until /// they login next, and possibly forwarded to their e-mail account Offline = 1 } /// /// Conversion type to denote Chat Packet types in an easier-to-understand format /// public enum ChatType : byte { /// Whisper (5m radius) Whisper = 0, /// Normal chat (10/20m radius), what the official viewer typically sends Normal = 1, /// Shouting! (100m radius) Shout = 2, // Say chat (10/20m radius) - The official viewer will // print "[4:15] You say, hey" instead of "[4:15] You: hey" //[Obsolete] //Say = 3, /// Event message when an Avatar has begun to type StartTyping = 4, /// Event message when an Avatar has stopped typing StopTyping = 5, /// Send the message to the debug channel Debug = 6, /// Event message when an object uses llOwnerSay OwnerSay = 8, /// Special value to support llRegionSay, never sent to the client RegionSay = Byte.MaxValue, } /// /// Identifies the source of a chat message /// public enum ChatSourceType : byte { /// Chat from the grid or simulator System = 0, /// Chat from another avatar Agent = 1, /// Chat from an object Object = 2 } /// /// /// public enum ChatAudibleLevel : sbyte { /// Not = -1, /// Barely = 0, /// Fully = 1 } /// /// Effect type used in ViewerEffect packets /// public enum EffectType : byte { /// Text = 0, /// Icon, /// Connector, /// FlexibleObject, /// AnimalControls, /// AnimationObject, /// Cloth, /// Project a beam from a source to a destination, such as /// the one used when editing an object Beam, /// Glow, /// Point, /// Trail, /// Create a swirl of particles around an object Sphere, /// Spiral, /// Edit, /// Cause an avatar to look at an object LookAt, /// Cause an avatar to point at an object PointAt } /// /// The action an avatar is doing when looking at something, used in /// ViewerEffect packets for the LookAt effect /// public enum LookAtType : byte { /// None, /// Idle, /// AutoListen, /// FreeLook, /// Respond, /// Hover, /// Deprecated [Obsolete] Conversation, /// Select, /// Focus, /// Mouselook, /// Clear } /// /// The action an avatar is doing when pointing at something, used in /// ViewerEffect packets for the PointAt effect /// public enum PointAtType : byte { /// None, /// Select, /// Grab, /// Clear } /// /// Money transaction types /// public enum MoneyTransactionType : int { /// None = 0, /// FailSimulatorTimeout = 1, /// FailDataserverTimeout = 2, /// ObjectClaim = 1000, /// LandClaim = 1001, /// GroupCreate = 1002, /// ObjectPublicClaim = 1003, /// GroupJoin = 1004, /// TeleportCharge = 1100, /// UploadCharge = 1101, /// LandAuction = 1102, /// ClassifiedCharge = 1103, /// ObjectTax = 2000, /// LandTax = 2001, /// LightTax = 2002, /// ParcelDirFee = 2003, /// GroupTax = 2004, /// ClassifiedRenew = 2005, /// GiveInventory = 3000, /// ObjectSale = 5000, /// Gift = 5001, /// LandSale = 5002, /// ReferBonus = 5003, /// InventorySale = 5004, /// RefundPurchase = 5005, /// LandPassSale = 5006, /// DwellBonus = 5007, /// PayObject = 5008, /// ObjectPays = 5009, /// GroupLandDeed = 6001, /// GroupObjectDeed = 6002, /// GroupLiability = 6003, /// GroupDividend = 6004, /// GroupMembershipDues = 6005, /// ObjectRelease = 8000, /// LandRelease = 8001, /// ObjectDelete = 8002, /// ObjectPublicDecay = 8003, /// ObjectPublicDelete = 8004, /// LindenAdjustment = 9000, /// LindenGrant = 9001, /// LindenPenalty = 9002, /// EventFee = 9003, /// EventPrize = 9004, /// StipendBasic = 10000, /// StipendDeveloper = 10001, /// StipendAlways = 10002, /// StipendDaily = 10003, /// StipendRating = 10004, /// StipendDelta = 10005 } /// /// /// [Flags] public enum TransactionFlags : byte { /// None = 0, /// SourceGroup = 1, /// DestGroup = 2, /// OwnerGroup = 4, /// SimultaneousContribution = 8, /// ContributionRemoval = 16 } /// /// /// public enum MeanCollisionType : byte { /// None, /// Bump, /// LLPushObject, /// SelectedObjectCollide, /// ScriptedObjectCollide, /// PhysicalObjectCollide } /// /// Flags sent when a script takes or releases a control /// /// NOTE: (need to verify) These might be a subset of the ControlFlags enum in Movement, [Flags] public enum ScriptControlChange : uint { /// No Flags set None = 0, /// Forward (W or up Arrow) Forward = 1, /// Back (S or down arrow) Back = 2, /// Move left (shift+A or left arrow) Left = 4, /// Move right (shift+D or right arrow) Right = 8, /// Up (E or PgUp) Up = 16, /// Down (C or PgDown) Down = 32, /// Rotate left (A or left arrow) RotateLeft = 256, /// Rotate right (D or right arrow) RotateRight = 512, /// Left Mouse Button LeftButton = 268435456, /// Left Mouse button in MouseLook MouseLookLeftButton = 1073741824 } /// /// Currently only used to hide your group title /// [Flags] public enum AgentFlags : byte { /// No flags set None = 0, /// Hide your group title HideTitle = 0x01, } /// /// Action state of the avatar, which can currently be typing and /// editing /// [Flags] public enum AgentState : byte { /// None = 0x00, /// Typing = 0x04, /// Editing = 0x10 } /// /// Current teleport status /// public enum TeleportStatus { /// Unknown status None, /// Teleport initialized Start, /// Teleport in progress Progress, /// Teleport failed Failed, /// Teleport completed Finished, /// Teleport cancelled Cancelled } /// /// /// [Flags] public enum TeleportFlags : uint { /// No flags set, or teleport failed Default = 0, /// Set when newbie leaves help island for first time SetHomeToTarget = 1 << 0, /// SetLastToTarget = 1 << 1, /// Via Lure ViaLure = 1 << 2, /// Via Landmark ViaLandmark = 1 << 3, /// Via Location ViaLocation = 1 << 4, /// Via Home ViaHome = 1 << 5, /// Via Telehub ViaTelehub = 1 << 6, /// Via Login ViaLogin = 1 << 7, /// Linden Summoned ViaGodlikeLure = 1 << 8, /// Linden Forced me Godlike = 1 << 9, /// NineOneOne = 1 << 10, /// Agent Teleported Home via Script DisableCancel = 1 << 11, /// ViaRegionID = 1 << 12, /// IsFlying = 1 << 13, /// ResetHome = 1 << 14, /// forced to new location for example when avatar is banned or ejected ForceRedirect = 1 << 15, /// Teleport Finished via a Lure FinishedViaLure = 1 << 26, /// Finished, Sim Changed FinishedViaNewSim = 1 << 28, /// Finished, Same Sim FinishedViaSameSim = 1 << 29 } /// /// /// [Flags] public enum TeleportLureFlags { /// NormalLure = 0, /// GodlikeLure = 1, /// GodlikePursuit = 2 } /// /// /// [Flags] public enum ScriptSensorTypeFlags { /// Agent = 1, /// Active = 2, /// Passive = 4, /// Scripted = 8, } #endregion Enums #region Structs /// /// Instant Message /// public struct InstantMessage { /// Key of sender public UUID FromAgentID; /// Name of sender public string FromAgentName; /// Key of destination avatar public UUID ToAgentID; /// ID of originating estate public uint ParentEstateID; /// Key of originating region public UUID RegionID; /// Coordinates in originating region public Vector3 Position; /// Instant message type public InstantMessageDialog Dialog; /// Group IM session toggle public bool GroupIM; /// Key of IM session, for Group Messages, the groups UUID public UUID IMSessionID; /// Timestamp of the instant message public DateTime Timestamp; /// Instant message text public string Message; /// Whether this message is held for offline avatars public InstantMessageOnline Offline; /// Context specific packed data public byte[] BinaryBucket; /// Print the struct data as a string /// A string containing the field name, and field value public override string ToString() { return Helpers.StructToString(this); } } #endregion Structs /// /// Manager class for our own avatar /// public partial class AgentManager { #region Event Delegates /// The event subscribers. null if no subcribers private EventHandler m_Chat; /// Raises the ChatFromSimulator event /// A ChatEventArgs object containing the /// data returned from the data server protected virtual void OnChat(ChatEventArgs e) { EventHandler handler = m_Chat; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_ChatLock = new object(); /// Raised when a scripted object or agent within range sends a public message public event EventHandler ChatFromSimulator { add { lock (m_ChatLock) { m_Chat += value; } } remove { lock (m_ChatLock) { m_Chat -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_ScriptDialog; /// Raises the ScriptDialog event /// A SctriptDialogEventArgs object containing the /// data returned from the data server protected virtual void OnScriptDialog(ScriptDialogEventArgs e) { EventHandler handler = m_ScriptDialog; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_ScriptDialogLock = new object(); /// Raised when a scripted object sends a dialog box containing possible /// options an agent can respond to public event EventHandler ScriptDialog { add { lock (m_ScriptDialogLock) { m_ScriptDialog += value; } } remove { lock (m_ScriptDialogLock) { m_ScriptDialog -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_ScriptQuestion; /// Raises the ScriptQuestion event /// A ScriptQuestionEventArgs object containing the /// data returned from the data server protected virtual void OnScriptQuestion(ScriptQuestionEventArgs e) { EventHandler handler = m_ScriptQuestion; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_ScriptQuestionLock = new object(); /// Raised when an object requests a change in the permissions an agent has permitted public event EventHandler ScriptQuestion { add { lock (m_ScriptQuestionLock) { m_ScriptQuestion += value; } } remove { lock (m_ScriptQuestionLock) { m_ScriptQuestion -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_LoadURL; /// Raises the LoadURL event /// A LoadUrlEventArgs object containing the /// data returned from the data server protected virtual void OnLoadURL(LoadUrlEventArgs e) { EventHandler handler = m_LoadURL; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_LoadUrlLock = new object(); /// Raised when a script requests an agent open the specified URL public event EventHandler LoadURL { add { lock (m_LoadUrlLock) { m_LoadURL += value; } } remove { lock (m_LoadUrlLock) { m_LoadURL -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_Balance; /// Raises the MoneyBalance event /// A BalanceEventArgs object containing the /// data returned from the data server protected virtual void OnBalance(BalanceEventArgs e) { EventHandler handler = m_Balance; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_BalanceLock = new object(); /// Raised when an agents currency balance is updated public event EventHandler MoneyBalance { add { lock (m_BalanceLock) { m_Balance += value; } } remove { lock (m_BalanceLock) { m_Balance -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_MoneyBalance; /// Raises the MoneyBalanceReply event /// A MoneyBalanceReplyEventArgs object containing the /// data returned from the data server protected virtual void OnMoneyBalanceReply(MoneyBalanceReplyEventArgs e) { EventHandler handler = m_MoneyBalance; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_MoneyBalanceReplyLock = new object(); /// Raised when a transaction occurs involving currency such as a land purchase public event EventHandler MoneyBalanceReply { add { lock (m_MoneyBalanceReplyLock) { m_MoneyBalance += value; } } remove { lock (m_MoneyBalanceReplyLock) { m_MoneyBalance -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_InstantMessage; /// Raises the IM event /// A InstantMessageEventArgs object containing the /// data returned from the data server protected virtual void OnInstantMessage(InstantMessageEventArgs e) { EventHandler handler = m_InstantMessage; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_InstantMessageLock = new object(); /// Raised when an ImprovedInstantMessage packet is recieved from the simulator, this is used for everything from /// private messaging to friendship offers. The Dialog field defines what type of message has arrived public event EventHandler IM { add { lock (m_InstantMessageLock) { m_InstantMessage += value; } } remove { lock (m_InstantMessageLock) { m_InstantMessage -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_Teleport; /// Raises the TeleportProgress event /// A TeleportEventArgs object containing the /// data returned from the data server protected virtual void OnTeleport(TeleportEventArgs e) { EventHandler handler = m_Teleport; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_TeleportLock = new object(); /// Raised when an agent has requested a teleport to another location, or when responding to a lure. Raised multiple times /// for each teleport indicating the progress of the request public event EventHandler TeleportProgress { add { lock (m_TeleportLock) { m_Teleport += value; } } remove { lock (m_TeleportLock) { m_Teleport += value; } } } /// The event subscribers. null if no subcribers private EventHandler m_AgentData; /// Raises the AgentDataReply event /// A AgentDataReplyEventArgs object containing the /// data returned from the data server protected virtual void OnAgentData(AgentDataReplyEventArgs e) { EventHandler handler = m_AgentData; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_AgentDataLock = new object(); /// Raised when a simulator sends agent specific information for our avatar. public event EventHandler AgentDataReply { add { lock (m_AgentDataLock) { m_AgentData += value; } } remove { lock (m_AgentDataLock) { m_AgentData -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_AnimationsChanged; /// Raises the AnimationsChanged event /// A AnimationsChangedEventArgs object containing the /// data returned from the data server protected virtual void OnAnimationsChanged(AnimationsChangedEventArgs e) { EventHandler handler = m_AnimationsChanged; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_AnimationsChangedLock = new object(); /// Raised when our agents animation playlist changes public event EventHandler AnimationsChanged { add { lock (m_AnimationsChangedLock) { m_AnimationsChanged += value; } } remove { lock (m_AnimationsChangedLock) { m_AnimationsChanged -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_MeanCollision; /// Raises the MeanCollision event /// A MeanCollisionEventArgs object containing the /// data returned from the data server protected virtual void OnMeanCollision(MeanCollisionEventArgs e) { EventHandler handler = m_MeanCollision; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_MeanCollisionLock = new object(); /// Raised when an object or avatar forcefully collides with our agent public event EventHandler MeanCollision { add { lock (m_MeanCollisionLock) { m_MeanCollision += value; } } remove { lock (m_MeanCollisionLock) { m_MeanCollision -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_RegionCrossed; /// Raises the RegionCrossed event /// A RegionCrossedEventArgs object containing the /// data returned from the data server protected virtual void OnRegionCrossed(RegionCrossedEventArgs e) { EventHandler handler = m_RegionCrossed; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_RegionCrossedLock = new object(); /// Raised when our agent crosses a region border into another region public event EventHandler RegionCrossed { add { lock (m_RegionCrossedLock) { m_RegionCrossed += value; } } remove { lock (m_RegionCrossedLock) { m_RegionCrossed -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_GroupChatJoined; /// Raises the GroupChatJoined event /// A GroupChatJoinedEventArgs object containing the /// data returned from the data server protected virtual void OnGroupChatJoined(GroupChatJoinedEventArgs e) { EventHandler handler = m_GroupChatJoined; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_GroupChatJoinedLock = new object(); /// Raised when our agent succeeds or fails to join a group chat session public event EventHandler GroupChatJoined { add { lock (m_GroupChatJoinedLock) { m_GroupChatJoined += value; } } remove { lock (m_GroupChatJoinedLock) { m_GroupChatJoined -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_GroupChatLeft; /// Raises the GroupChatLeft event /// A GroupChatLeftEventArgs object containing the /// data returned from the data server protected virtual void OnGroupChatLeft(GroupChatLeftEventArgs e) { EventHandler handler = m_GroupChatLeft; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_GroupChatLeftLock = new object(); /// Raised when our agent exits a group chat session public event EventHandler GroupChatLeft { add { lock (m_GroupChatLeftLock) { m_GroupChatLeft += value; } } remove { lock (m_GroupChatLeftLock) { m_GroupChatLeft -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_AlertMessage; /// Raises the AlertMessage event /// A AlertMessageEventArgs object containing the /// data returned from the data server protected virtual void OnAlertMessage(AlertMessageEventArgs e) { EventHandler handler = m_AlertMessage; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_AlertMessageLock = new object(); /// Raised when a simulator sends an urgent message usually indication the recent failure of /// another action we have attempted to take such as an attempt to enter a parcel where we are denied access public event EventHandler AlertMessage { add { lock (m_AlertMessageLock) { m_AlertMessage += value; } } remove { lock (m_AlertMessageLock) { m_AlertMessage -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_ScriptControl; /// Raises the ScriptControlChange event /// A ScriptControlEventArgs object containing the /// data returned from the data server protected virtual void OnScriptControlChange(ScriptControlEventArgs e) { EventHandler handler = m_ScriptControl; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_ScriptControlLock = new object(); /// Raised when a script attempts to take or release specified controls for our agent public event EventHandler ScriptControlChange { add { lock (m_ScriptControlLock) { m_ScriptControl += value; } } remove { lock (m_ScriptControlLock) { m_ScriptControl -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_CameraConstraint; /// Raises the CameraConstraint event /// A CameraConstraintEventArgs object containing the /// data returned from the data server protected virtual void OnCameraConstraint(CameraConstraintEventArgs e) { EventHandler handler = m_CameraConstraint; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_CameraConstraintLock = new object(); /// Raised when the simulator detects our agent is trying to view something /// beyond its limits public event EventHandler CameraConstraint { add { lock (m_CameraConstraintLock) { m_CameraConstraint += value; } } remove { lock (m_CameraConstraintLock) { m_CameraConstraint -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_ScriptSensorReply; /// Raises the ScriptSensorReply event /// A ScriptSensorReplyEventArgs object containing the /// data returned from the data server protected virtual void OnScriptSensorReply(ScriptSensorReplyEventArgs e) { EventHandler handler = m_ScriptSensorReply; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_ScriptSensorReplyLock = new object(); /// Raised when a script sensor reply is received from a simulator public event EventHandler ScriptSensorReply { add { lock (m_ScriptSensorReplyLock) { m_ScriptSensorReply += value; } } remove { lock (m_ScriptSensorReplyLock) { m_ScriptSensorReply -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_AvatarSitResponse; /// Raises the AvatarSitResponse event /// A AvatarSitResponseEventArgs object containing the /// data returned from the data server protected virtual void OnAvatarSitResponse(AvatarSitResponseEventArgs e) { EventHandler handler = m_AvatarSitResponse; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_AvatarSitResponseLock = new object(); /// Raised in response to a request public event EventHandler AvatarSitResponse { add { lock (m_AvatarSitResponseLock) { m_AvatarSitResponse += value; } } remove { lock (m_AvatarSitResponseLock) { m_AvatarSitResponse -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_ChatSessionMemberAdded; /// Raises the ChatSessionMemberAdded event /// A ChatSessionMemberAddedEventArgs object containing the /// data returned from the data server protected virtual void OnChatSessionMemberAdded(ChatSessionMemberAddedEventArgs e) { EventHandler handler = m_ChatSessionMemberAdded; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_ChatSessionMemberAddedLock = new object(); /// Raised when an avatar enters a group chat session we are participating in public event EventHandler ChatSessionMemberAdded { add { lock (m_ChatSessionMemberAddedLock) { m_ChatSessionMemberAdded += value; } } remove { lock (m_ChatSessionMemberAddedLock) { m_ChatSessionMemberAdded -= value; } } } /// The event subscribers. null if no subcribers private EventHandler m_ChatSessionMemberLeft; /// Raises the ChatSessionMemberLeft event /// A ChatSessionMemberLeftEventArgs object containing the /// data returned from the data server protected virtual void OnChatSessionMemberLeft(ChatSessionMemberLeftEventArgs e) { EventHandler handler = m_ChatSessionMemberLeft; if (handler != null) handler(this, e); } /// Thread sync lock object private readonly object m_ChatSessionMemberLeftLock = new object(); /// Raised when an agent exits a group chat session we are participating in public event EventHandler ChatSessionMemberLeft { add { lock (m_ChatSessionMemberLeftLock) { m_ChatSessionMemberLeft += value; } } remove { lock (m_ChatSessionMemberLeftLock) { m_ChatSessionMemberLeft -= value; } } } #endregion Callbacks #region Events #endregion Events /// Reference to the GridClient instance private readonly GridClient Client; /// Used for movement and camera tracking public readonly AgentMovement Movement; /// Currently playing animations for the agent. Can be used to /// check the current movement status such as walking, hovering, aiming, /// etc. by checking against system animations found in the Animations class public InternalDictionary SignaledAnimations = new InternalDictionary(); /// Dictionary containing current Group Chat sessions and members public InternalDictionary> GroupChatSessions = new InternalDictionary>(); #region Properties /// Your (client) avatars /// "client", "agent", and "avatar" all represent the same thing public UUID AgentID { get { return id; } } /// Temporary assigned to this session, used for /// verifying our identity in packets public UUID SessionID { get { return sessionID; } } /// Shared secret that is never sent over the wire public UUID SecureSessionID { get { return secureSessionID; } } /// Your (client) avatar ID, local to the current region/sim public uint LocalID { get { return localID; } } /// Where the avatar started at login. Can be "last", "home" /// or a login public string StartLocation { get { return startLocation; } } /// The access level of this agent, usually M or PG public string AgentAccess { get { return agentAccess; } } /// The CollisionPlane of Agent public Vector4 CollisionPlane { get { return collisionPlane; } } /// An representing the velocity of our agent public Vector3 Velocity { get { return velocity; } } /// An representing the acceleration of our agent public Vector3 Acceleration { get { return acceleration; } } /// A which specifies the angular speed, and axis about which an Avatar is rotating. public Vector3 AngularVelocity { get { return angularVelocity; } } /// Position avatar client will goto when login to 'home' or during /// teleport request to 'home' region. public Vector3 HomePosition { get { return homePosition; } } /// LookAt point saved/restored with HomePosition public Vector3 HomeLookAt { get { return homeLookAt; } } /// Avatar First Name (i.e. Philip) public string FirstName { get { return firstName; } } /// Avatar Last Name (i.e. Linden) public string LastName { get { return lastName; } } /// Avatar Full Name (i.e. Philip Linden) public string Name { get { // This is a fairly common request, so assume the name doesn't // change mid-session and cache the result if (fullName == null || fullName.Length < 2) fullName = String.Format("{0} {1}", firstName, lastName); return fullName; } } /// Gets the health of the agent public float Health { get { return health; } } /// Gets the current balance of the agent public int Balance { get { return balance; } } /// Gets the local ID of the prim the agent is sitting on, /// zero if the avatar is not currently sitting public uint SittingOn { get { return sittingOn; } } /// Gets the of the agents active group. public UUID ActiveGroup { get { return activeGroup; } } /// Gets the Agents powers in the currently active group public GroupPowers ActiveGroupPowers { get { return activeGroupPowers; } } /// Current status message for teleporting public string TeleportMessage { get { return teleportMessage; } } /// Current position of the agent as a relative offset from /// the simulator, or the parent object if we are sitting on something public Vector3 RelativePosition { get { return relativePosition; } } /// Current rotation of the agent as a relative rotation from /// the simulator, or the parent object if we are sitting on something public Quaternion RelativeRotation { get { return relativeRotation; } } /// Current position of the agent in the simulator public Vector3 SimPosition { get { if (sittingOn != 0) { Primitive parent; if (Client.Network.CurrentSim != null && Client.Network.CurrentSim.ObjectsPrimitives.TryGetValue(sittingOn, out parent)) { return parent.Position + Vector3.Transform(relativePosition, Matrix4.CreateFromQuaternion(parent.Rotation)); } else { Logger.Log("Currently sitting on object " + sittingOn + " which is not tracked, SimPosition will be inaccurate", Helpers.LogLevel.Warning, Client); return relativePosition; } } else { return relativePosition; } } } /// /// A representing the agents current rotation /// public Quaternion SimRotation { get { if (sittingOn != 0) { Primitive parent; if (Client.Network.CurrentSim != null && Client.Network.CurrentSim.ObjectsPrimitives.TryGetValue(sittingOn, out parent)) { return relativeRotation * parent.Rotation; } else { Logger.Log("Currently sitting on object " + sittingOn + " which is not tracked, SimRotation will be inaccurate", Helpers.LogLevel.Warning, Client); return relativeRotation; } } else { return relativeRotation; } } } /// Returns the global grid position of the avatar public Vector3d GlobalPosition { get { if (Client.Network.CurrentSim != null) { uint globalX, globalY; Utils.LongToUInts(Client.Network.CurrentSim.Handle, out globalX, out globalY); Vector3 pos = SimPosition; return new Vector3d( (double)globalX + (double)pos.X, (double)globalY + (double)pos.Y, (double)pos.Z); } else return Vector3d.Zero; } } #endregion Properties internal uint localID; internal Vector3 relativePosition; internal Quaternion relativeRotation = Quaternion.Identity; internal Vector4 collisionPlane; internal Vector3 velocity; internal Vector3 acceleration; internal Vector3 angularVelocity; internal uint sittingOn; internal int lastInterpolation; #region Private Members private UUID id; private UUID sessionID; private UUID secureSessionID; private string startLocation = String.Empty; private string agentAccess = String.Empty; private Vector3 homePosition; private Vector3 homeLookAt; private string firstName = String.Empty; private string lastName = String.Empty; private string fullName; private string teleportMessage = String.Empty; private TeleportStatus teleportStat = TeleportStatus.None; private ManualResetEvent teleportEvent = new ManualResetEvent(false); private uint heightWidthGenCounter; private float health; private int balance; private UUID activeGroup; private GroupPowers activeGroupPowers; private Dictionary gestureCache = new Dictionary(); #endregion Private Members /// /// Constructor, setup callbacks for packets related to our avatar /// /// A reference to the Class public AgentManager(GridClient client) { Client = client; Movement = new AgentMovement(Client); Client.Network.Disconnected += Network_OnDisconnected; // Teleport callbacks Client.Network.RegisterCallback(PacketType.TeleportStart, TeleportHandler); Client.Network.RegisterCallback(PacketType.TeleportProgress, TeleportHandler); Client.Network.RegisterCallback(PacketType.TeleportFailed, TeleportHandler); Client.Network.RegisterCallback(PacketType.TeleportCancel, TeleportHandler); Client.Network.RegisterCallback(PacketType.TeleportLocal, TeleportHandler); // these come in via the EventQueue Client.Network.RegisterEventCallback("TeleportFailed", new Caps.EventQueueCallback(TeleportFailedEventHandler)); Client.Network.RegisterEventCallback("TeleportFinish", new Caps.EventQueueCallback(TeleportFinishEventHandler)); // Instant message callback Client.Network.RegisterCallback(PacketType.ImprovedInstantMessage, InstantMessageHandler); // Chat callback Client.Network.RegisterCallback(PacketType.ChatFromSimulator, ChatHandler); // Script dialog callback Client.Network.RegisterCallback(PacketType.ScriptDialog, ScriptDialogHandler); // Script question callback Client.Network.RegisterCallback(PacketType.ScriptQuestion, ScriptQuestionHandler); // Script URL callback Client.Network.RegisterCallback(PacketType.LoadURL, LoadURLHandler); // Movement complete callback Client.Network.RegisterCallback(PacketType.AgentMovementComplete, MovementCompleteHandler); // Health callback Client.Network.RegisterCallback(PacketType.HealthMessage, HealthHandler); // Money callback Client.Network.RegisterCallback(PacketType.MoneyBalanceReply, MoneyBalanceReplyHandler); //Agent update callback Client.Network.RegisterCallback(PacketType.AgentDataUpdate, AgentDataUpdateHandler); // Animation callback Client.Network.RegisterCallback(PacketType.AvatarAnimation, AvatarAnimationHandler); // Object colliding into our agent callback Client.Network.RegisterCallback(PacketType.MeanCollisionAlert, MeanCollisionAlertHandler); // Region Crossing Client.Network.RegisterCallback(PacketType.CrossedRegion, CrossedRegionHandler); Client.Network.RegisterEventCallback("CrossedRegion", new Caps.EventQueueCallback(CrossedRegionEventHandler)); // CAPS callbacks Client.Network.RegisterEventCallback("EstablishAgentCommunication", new Caps.EventQueueCallback(EstablishAgentCommunicationEventHandler)); // Incoming Group Chat Client.Network.RegisterEventCallback("ChatterBoxInvitation", new Caps.EventQueueCallback(ChatterBoxInvitationEventHandler)); // Outgoing Group Chat Reply Client.Network.RegisterEventCallback("ChatterBoxSessionEventReply", new Caps.EventQueueCallback(ChatterBoxSessionEventReplyEventHandler)); Client.Network.RegisterEventCallback("ChatterBoxSessionStartReply", new Caps.EventQueueCallback(ChatterBoxSessionStartReplyEventHandler)); Client.Network.RegisterEventCallback("ChatterBoxSessionAgentListUpdates", new Caps.EventQueueCallback(ChatterBoxSessionAgentListUpdatesEventHandler)); // Login Client.Network.RegisterLoginResponseCallback(new NetworkManager.LoginResponseCallback(Network_OnLoginResponse)); // Alert Messages Client.Network.RegisterCallback(PacketType.AlertMessage, AlertMessageHandler); // script control change messages, ie: when an in-world LSL script wants to take control of your agent. Client.Network.RegisterCallback(PacketType.ScriptControlChange, ScriptControlChangeHandler); // Camera Constraint (probably needs to move to AgentManagerCamera TODO: Client.Network.RegisterCallback(PacketType.CameraConstraint, CameraConstraintHandler); Client.Network.RegisterCallback(PacketType.ScriptSensorReply, ScriptSensorReplyHandler); Client.Network.RegisterCallback(PacketType.AvatarSitResponse, AvatarSitResponseHandler); } #region Chat and instant messages /// /// Send a text message from the Agent to the Simulator /// /// A containing the message /// The channel to send the message on, 0 is the public channel. Channels above 0 /// can be used however only scripts listening on the specified channel will see the message /// Denotes the type of message being sent, shout, whisper, etc. public void Chat(string message, int channel, ChatType type) { ChatFromViewerPacket chat = new ChatFromViewerPacket(); chat.AgentData.AgentID = this.id; chat.AgentData.SessionID = Client.Self.SessionID; chat.ChatData.Channel = channel; chat.ChatData.Message = Utils.StringToBytes(message); chat.ChatData.Type = (byte)type; Client.Network.SendPacket(chat); } /// /// Request any instant messages sent while the client was offline to be resent. /// public void RetrieveInstantMessages() { RetrieveInstantMessagesPacket p = new RetrieveInstantMessagesPacket(); p.AgentData.AgentID = Client.Self.AgentID; p.AgentData.SessionID = Client.Self.SessionID; Client.Network.SendPacket(p); } /// /// Send an Instant Message to another Avatar /// /// The recipients /// A containing the message to send public void InstantMessage(UUID target, string message) { InstantMessage(Name, target, message, AgentID.Equals(target) ? AgentID : target ^ AgentID, InstantMessageDialog.MessageFromAgent, InstantMessageOnline.Offline, this.SimPosition, UUID.Zero, Utils.EmptyBytes); } /// /// Send an Instant Message to an existing group chat or conference chat /// /// The recipients /// A containing the message to send /// IM session ID (to differentiate between IM windows) public void InstantMessage(UUID target, string message, UUID imSessionID) { InstantMessage(Name, target, message, imSessionID, InstantMessageDialog.MessageFromAgent, InstantMessageOnline.Offline, this.SimPosition, UUID.Zero, Utils.EmptyBytes); } /// /// Send an Instant Message /// /// The name this IM will show up as being from /// Key of Avatar /// Text message being sent /// IM session ID (to differentiate between IM windows) /// IDs of sessions for a conference public void InstantMessage(string fromName, UUID target, string message, UUID imSessionID, UUID[] conferenceIDs) { byte[] binaryBucket; if (conferenceIDs != null && conferenceIDs.Length > 0) { binaryBucket = new byte[16 * conferenceIDs.Length]; for (int i = 0; i < conferenceIDs.Length; ++i) Buffer.BlockCopy(conferenceIDs[i].GetBytes(), 0, binaryBucket, i * 16, 16); } else { binaryBucket = Utils.EmptyBytes; } InstantMessage(fromName, target, message, imSessionID, InstantMessageDialog.MessageFromAgent, InstantMessageOnline.Offline, Vector3.Zero, UUID.Zero, binaryBucket); } /// /// Send an Instant Message /// /// The name this IM will show up as being from /// Key of Avatar /// Text message being sent /// IM session ID (to differentiate between IM windows) /// Type of instant message to send /// Whether to IM offline avatars as well /// Senders Position /// RegionID Sender is In /// Packed binary data that is specific to /// the dialog type public void InstantMessage(string fromName, UUID target, string message, UUID imSessionID, InstantMessageDialog dialog, InstantMessageOnline offline, Vector3 position, UUID regionID, byte[] binaryBucket) { if (target != UUID.Zero) { ImprovedInstantMessagePacket im = new ImprovedInstantMessagePacket(); if (imSessionID.Equals(UUID.Zero) || imSessionID.Equals(AgentID)) imSessionID = AgentID.Equals(target) ? AgentID : target ^ AgentID; im.AgentData.AgentID = Client.Self.AgentID; im.AgentData.SessionID = Client.Self.SessionID; im.MessageBlock.Dialog = (byte)dialog; im.MessageBlock.FromAgentName = Utils.StringToBytes(fromName); im.MessageBlock.FromGroup = false; im.MessageBlock.ID = imSessionID; im.MessageBlock.Message = Utils.StringToBytes(message); im.MessageBlock.Offline = (byte)offline; im.MessageBlock.ToAgentID = target; if (binaryBucket != null) im.MessageBlock.BinaryBucket = binaryBucket; else im.MessageBlock.BinaryBucket = Utils.EmptyBytes; // These fields are mandatory, even if we don't have valid values for them im.MessageBlock.Position = Vector3.Zero; //TODO: Allow region id to be correctly set by caller or fetched from Client.* im.MessageBlock.RegionID = regionID; // Send the message Client.Network.SendPacket(im); } else { Logger.Log(String.Format("Suppressing instant message \"{0}\" to UUID.Zero", message), Helpers.LogLevel.Error, Client); } } /// /// Send an Instant Message to a group /// /// of the group to send message to /// Text Message being sent. public void InstantMessageGroup(UUID groupID, string message) { InstantMessageGroup(Name, groupID, message); } /// /// Send an Instant Message to a group the agent is a member of /// /// The name this IM will show up as being from /// of the group to send message to /// Text message being sent public void InstantMessageGroup(string fromName, UUID groupID, string message) { lock (GroupChatSessions.Dictionary) if (GroupChatSessions.ContainsKey(groupID)) { ImprovedInstantMessagePacket im = new ImprovedInstantMessagePacket(); im.AgentData.AgentID = Client.Self.AgentID; im.AgentData.SessionID = Client.Self.SessionID; im.MessageBlock.Dialog = (byte)InstantMessageDialog.SessionSend; im.MessageBlock.FromAgentName = Utils.StringToBytes(fromName); im.MessageBlock.FromGroup = false; im.MessageBlock.Message = Utils.StringToBytes(message); im.MessageBlock.Offline = 0; im.MessageBlock.ID = groupID; im.MessageBlock.ToAgentID = groupID; im.MessageBlock.Position = Vector3.Zero; im.MessageBlock.RegionID = UUID.Zero; im.MessageBlock.BinaryBucket = Utils.StringToBytes("\0"); Client.Network.SendPacket(im); } else { Logger.Log("No Active group chat session appears to exist, use RequestJoinGroupChat() to join one", Helpers.LogLevel.Error, Client); } } /// /// Send a request to join a group chat session /// /// of Group to leave public void RequestJoinGroupChat(UUID groupID) { ImprovedInstantMessagePacket im = new ImprovedInstantMessagePacket(); im.AgentData.AgentID = Client.Self.AgentID; im.AgentData.SessionID = Client.Self.SessionID; im.MessageBlock.Dialog = (byte)InstantMessageDialog.SessionGroupStart; im.MessageBlock.FromAgentName = Utils.StringToBytes(Client.Self.Name); im.MessageBlock.FromGroup = false; im.MessageBlock.Message = Utils.EmptyBytes; im.MessageBlock.ParentEstateID = 0; im.MessageBlock.Offline = 0; im.MessageBlock.ID = groupID; im.MessageBlock.ToAgentID = groupID; im.MessageBlock.BinaryBucket = Utils.EmptyBytes; im.MessageBlock.Position = Client.Self.SimPosition; im.MessageBlock.RegionID = UUID.Zero; Client.Network.SendPacket(im); } /// /// Exit a group chat session. This will stop further Group chat messages /// from being sent until session is rejoined. /// /// of Group chat session to leave public void RequestLeaveGroupChat(UUID groupID) { ImprovedInstantMessagePacket im = new ImprovedInstantMessagePacket(); im.AgentData.AgentID = Client.Self.AgentID; im.AgentData.SessionID = Client.Self.SessionID; im.MessageBlock.Dialog = (byte)InstantMessageDialog.SessionDrop; im.MessageBlock.FromAgentName = Utils.StringToBytes(Client.Self.Name); im.MessageBlock.FromGroup = false; im.MessageBlock.Message = Utils.EmptyBytes; im.MessageBlock.Offline = 0; im.MessageBlock.ID = groupID; im.MessageBlock.ToAgentID = groupID; im.MessageBlock.BinaryBucket = Utils.EmptyBytes; im.MessageBlock.Position = Vector3.Zero; im.MessageBlock.RegionID = UUID.Zero; Client.Network.SendPacket(im); } /// /// Reply to script dialog questions. /// /// Channel initial request came on /// Index of button you're "clicking" /// Label of button you're "clicking" /// of Object that sent the dialog request /// public void ReplyToScriptDialog(int channel, int buttonIndex, string buttonlabel, UUID objectID) { ScriptDialogReplyPacket reply = new ScriptDialogReplyPacket(); reply.AgentData.AgentID = Client.Self.AgentID; reply.AgentData.SessionID = Client.Self.SessionID; reply.Data.ButtonIndex = buttonIndex; reply.Data.ButtonLabel = Utils.StringToBytes(buttonlabel); reply.Data.ChatChannel = channel; reply.Data.ObjectID = objectID; Client.Network.SendPacket(reply); } /// /// Accept invite for to a chatterbox session /// /// of session to accept invite to public void ChatterBoxAcceptInvite(UUID session_id) { if (Client.Network.CurrentSim == null || Client.Network.CurrentSim.Caps == null) throw new Exception("ChatSessionRequest capability is not currently available"); Uri url = Client.Network.CurrentSim.Caps.CapabilityURI("ChatSessionRequest"); if (url != null) { ChatSessionAcceptInvitation acceptInvite = new ChatSessionAcceptInvitation(); acceptInvite.SessionID = session_id; CapsClient request = new CapsClient(url); request.BeginGetResponse(acceptInvite.Serialize(), OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT); } else { throw new Exception("ChatSessionRequest capability is not currently available"); } } /// /// Start a friends conference /// /// List of UUIDs to start a conference with /// the temportary session ID returned in the callback> public void StartIMConference(List participants, UUID tmp_session_id) { if (Client.Network.CurrentSim == null || Client.Network.CurrentSim.Caps == null) throw new Exception("ChatSessionRequest capability is not currently available"); Uri url = Client.Network.CurrentSim.Caps.CapabilityURI("ChatSessionRequest"); if (url != null) { ChatSessionRequestStartConference startConference = new ChatSessionRequestStartConference(); startConference.AgentsBlock = new UUID[participants.Count]; for (int i = 0; i < participants.Count; i++) startConference.AgentsBlock[i] = participants[i]; startConference.SessionID = tmp_session_id; CapsClient request = new CapsClient(url); request.BeginGetResponse(startConference.Serialize(), OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT); } else { throw new Exception("ChatSessionRequest capability is not currently available"); } } #endregion Chat and instant messages #region Viewer Effects /// /// Start a particle stream between an agent and an object /// /// Key of the source agent /// Key of the target object /// /// The type from the enum /// A unique for this effect public void PointAtEffect(UUID sourceAvatar, UUID targetObject, Vector3d globalOffset, PointAtType type, UUID effectID) { ViewerEffectPacket effect = new ViewerEffectPacket(); effect.AgentData.AgentID = Client.Self.AgentID; effect.AgentData.SessionID = Client.Self.SessionID; effect.Effect = new ViewerEffectPacket.EffectBlock[1]; effect.Effect[0] = new ViewerEffectPacket.EffectBlock(); effect.Effect[0].AgentID = Client.Self.AgentID; effect.Effect[0].Color = new byte[4]; effect.Effect[0].Duration = (type == PointAtType.Clear) ? 0.0f : Single.MaxValue / 4.0f; effect.Effect[0].ID = effectID; effect.Effect[0].Type = (byte)EffectType.PointAt; byte[] typeData = new byte[57]; if (sourceAvatar != UUID.Zero) Buffer.BlockCopy(sourceAvatar.GetBytes(), 0, typeData, 0, 16); if (targetObject != UUID.Zero) Buffer.BlockCopy(targetObject.GetBytes(), 0, typeData, 16, 16); Buffer.BlockCopy(globalOffset.GetBytes(), 0, typeData, 32, 24); typeData[56] = (byte)type; effect.Effect[0].TypeData = typeData; Client.Network.SendPacket(effect); } /// /// Start a particle stream between an agent and an object /// /// Key of the source agent /// Key of the target object /// A representing the beams offset from the source /// A which sets the avatars lookat animation /// of the Effect public void LookAtEffect(UUID sourceAvatar, UUID targetObject, Vector3d globalOffset, LookAtType type, UUID effectID) { ViewerEffectPacket effect = new ViewerEffectPacket(); effect.AgentData.AgentID = Client.Self.AgentID; effect.AgentData.SessionID = Client.Self.SessionID; float duration; switch (type) { case LookAtType.Clear: duration = 0.0f; break; case LookAtType.Hover: duration = 1.0f; break; case LookAtType.FreeLook: duration = 2.0f; break; case LookAtType.Idle: duration = 3.0f; break; case LookAtType.AutoListen: case LookAtType.Respond: duration = 4.0f; break; case LookAtType.None: case LookAtType.Select: case LookAtType.Focus: case LookAtType.Mouselook: duration = Single.MaxValue / 2.0f; break; default: duration = 0.0f; break; } effect.Effect = new ViewerEffectPacket.EffectBlock[1]; effect.Effect[0] = new ViewerEffectPacket.EffectBlock(); effect.Effect[0].AgentID = Client.Self.AgentID; effect.Effect[0].Color = new byte[4]; effect.Effect[0].Duration = duration; effect.Effect[0].ID = effectID; effect.Effect[0].Type = (byte)EffectType.LookAt; byte[] typeData = new byte[57]; if (sourceAvatar != UUID.Zero) Buffer.BlockCopy(sourceAvatar.GetBytes(), 0, typeData, 0, 16); if (targetObject != UUID.Zero) Buffer.BlockCopy(targetObject.GetBytes(), 0, typeData, 16, 16); typeData[56] = (byte)type; effect.Effect[0].TypeData = typeData; Client.Network.SendPacket(effect); } /// /// Create a particle beam between an avatar and an primitive /// /// The ID of source avatar /// The ID of the target primitive /// global offset /// A object containing the combined red, green, blue and alpha /// color values of particle beam /// a float representing the duration the parcicle beam will last /// A Unique ID for the beam /// public void BeamEffect(UUID sourceAvatar, UUID targetObject, Vector3d globalOffset, Color4 color, float duration, UUID effectID) { ViewerEffectPacket effect = new ViewerEffectPacket(); effect.AgentData.AgentID = Client.Self.AgentID; effect.AgentData.SessionID = Client.Self.SessionID; effect.Effect = new ViewerEffectPacket.EffectBlock[1]; effect.Effect[0] = new ViewerEffectPacket.EffectBlock(); effect.Effect[0].AgentID = Client.Self.AgentID; effect.Effect[0].Color = color.GetBytes(); effect.Effect[0].Duration = duration; effect.Effect[0].ID = effectID; effect.Effect[0].Type = (byte)EffectType.Beam; byte[] typeData = new byte[56]; Buffer.BlockCopy(sourceAvatar.GetBytes(), 0, typeData, 0, 16); Buffer.BlockCopy(targetObject.GetBytes(), 0, typeData, 16, 16); Buffer.BlockCopy(globalOffset.GetBytes(), 0, typeData, 32, 24); effect.Effect[0].TypeData = typeData; Client.Network.SendPacket(effect); } /// /// Create a particle swirl around a target position using a packet /// /// global offset /// A object containing the combined red, green, blue and alpha /// color values of particle beam /// a float representing the duration the parcicle beam will last /// A Unique ID for the beam public void SphereEffect(Vector3d globalOffset, Color4 color, float duration, UUID effectID) { ViewerEffectPacket effect = new ViewerEffectPacket(); effect.AgentData.AgentID = Client.Self.AgentID; effect.AgentData.SessionID = Client.Self.SessionID; effect.Effect = new ViewerEffectPacket.EffectBlock[1]; effect.Effect[0] = new ViewerEffectPacket.EffectBlock(); effect.Effect[0].AgentID = Client.Self.AgentID; effect.Effect[0].Color = color.GetBytes(); effect.Effect[0].Duration = duration; effect.Effect[0].ID = effectID; effect.Effect[0].Type = (byte)EffectType.Sphere; byte[] typeData = new byte[56]; Buffer.BlockCopy(UUID.Zero.GetBytes(), 0, typeData, 0, 16); Buffer.BlockCopy(UUID.Zero.GetBytes(), 0, typeData, 16, 16); Buffer.BlockCopy(globalOffset.GetBytes(), 0, typeData, 32, 24); effect.Effect[0].TypeData = typeData; Client.Network.SendPacket(effect); } #endregion Viewer Effects #region Movement Actions /// /// Sends a request to sit on the specified object /// /// of the object to sit on /// Sit at offset public void RequestSit(UUID targetID, Vector3 offset) { AgentRequestSitPacket requestSit = new AgentRequestSitPacket(); requestSit.AgentData.AgentID = Client.Self.AgentID; requestSit.AgentData.SessionID = Client.Self.SessionID; requestSit.TargetObject.TargetID = targetID; requestSit.TargetObject.Offset = offset; Client.Network.SendPacket(requestSit); } /// /// Follows a call to to actually sit on the object /// public void Sit() { AgentSitPacket sit = new AgentSitPacket(); sit.AgentData.AgentID = Client.Self.AgentID; sit.AgentData.SessionID = Client.Self.SessionID; Client.Network.SendPacket(sit); } /// Stands up from sitting on a prim or the ground /// true of AgentUpdate was sent public bool Stand() { if (Client.Settings.SEND_AGENT_UPDATES) { Movement.SitOnGround = false; Movement.StandUp = true; Movement.SendUpdate(); Movement.StandUp = false; Movement.SendUpdate(); return true; } else { Logger.Log("Attempted to Stand() but agent updates are disabled", Helpers.LogLevel.Warning, Client); return false; } } /// /// Does a "ground sit" at the avatar's current position /// public void SitOnGround() { Movement.SitOnGround = true; Movement.SendUpdate(true); } /// /// Starts or stops flying /// /// True to start flying, false to stop flying public void Fly(bool start) { if (start) Movement.Fly = true; else Movement.Fly = false; Movement.SendUpdate(true); } /// /// Starts or stops crouching /// /// True to start crouching, false to stop crouching public void Crouch(bool crouching) { Movement.UpNeg = crouching; Movement.SendUpdate(true); } /// /// Starts a jump (begin holding the jump key) /// public void Jump(bool jumping) { Movement.UpPos = jumping; Movement.FastUp = jumping; Movement.SendUpdate(true); } /// /// Use the autopilot sim function to move the avatar to a new /// position. Uses double precision to get precise movements /// /// The z value is currently not handled properly by the simulator /// Global X coordinate to move to /// Global Y coordinate to move to /// Z coordinate to move to public void AutoPilot(double globalX, double globalY, double z) { GenericMessagePacket autopilot = new GenericMessagePacket(); autopilot.AgentData.AgentID = Client.Self.AgentID; autopilot.AgentData.SessionID = Client.Self.SessionID; autopilot.AgentData.TransactionID = UUID.Zero; autopilot.MethodData.Invoice = UUID.Zero; autopilot.MethodData.Method = Utils.StringToBytes("autopilot"); autopilot.ParamList = new GenericMessagePacket.ParamListBlock[3]; autopilot.ParamList[0] = new GenericMessagePacket.ParamListBlock(); autopilot.ParamList[0].Parameter = Utils.StringToBytes(globalX.ToString()); autopilot.ParamList[1] = new GenericMessagePacket.ParamListBlock(); autopilot.ParamList[1].Parameter = Utils.StringToBytes(globalY.ToString()); autopilot.ParamList[2] = new GenericMessagePacket.ParamListBlock(); autopilot.ParamList[2].Parameter = Utils.StringToBytes(z.ToString()); Client.Network.SendPacket(autopilot); } /// /// Use the autopilot sim function to move the avatar to a new position /// /// The z value is currently not handled properly by the simulator /// Integer value for the global X coordinate to move to /// Integer value for the global Y coordinate to move to /// Floating-point value for the Z coordinate to move to public void AutoPilot(ulong globalX, ulong globalY, float z) { GenericMessagePacket autopilot = new GenericMessagePacket(); autopilot.AgentData.AgentID = Client.Self.AgentID; autopilot.AgentData.SessionID = Client.Self.SessionID; autopilot.AgentData.TransactionID = UUID.Zero; autopilot.MethodData.Invoice = UUID.Zero; autopilot.MethodData.Method = Utils.StringToBytes("autopilot"); autopilot.ParamList = new GenericMessagePacket.ParamListBlock[3]; autopilot.ParamList[0] = new GenericMessagePacket.ParamListBlock(); autopilot.ParamList[0].Parameter = Utils.StringToBytes(globalX.ToString()); autopilot.ParamList[1] = new GenericMessagePacket.ParamListBlock(); autopilot.ParamList[1].Parameter = Utils.StringToBytes(globalY.ToString()); autopilot.ParamList[2] = new GenericMessagePacket.ParamListBlock(); autopilot.ParamList[2].Parameter = Utils.StringToBytes(z.ToString()); Client.Network.SendPacket(autopilot); } /// /// Use the autopilot sim function to move the avatar to a new position /// /// The z value is currently not handled properly by the simulator /// Integer value for the local X coordinate to move to /// Integer value for the local Y coordinate to move to /// Floating-point value for the Z coordinate to move to public void AutoPilotLocal(int localX, int localY, float z) { uint x, y; Utils.LongToUInts(Client.Network.CurrentSim.Handle, out x, out y); AutoPilot((ulong)(x + localX), (ulong)(y + localY), z); } /// Macro to cancel autopilot sim function /// Not certain if this is how it is really done /// true if control flags were set and AgentUpdate was sent to the simulator public bool AutoPilotCancel() { if (Client.Settings.SEND_AGENT_UPDATES) { Movement.AtPos = true; Movement.SendUpdate(); Movement.AtPos = false; Movement.SendUpdate(); return true; } else { Logger.Log("Attempted to AutoPilotCancel() but agent updates are disabled", Helpers.LogLevel.Warning, Client); return false; } } #endregion Movement actions #region Touch and grab /// /// Grabs an object /// /// an unsigned integer of the objects ID within the simulator /// public void Grab(uint objectLocalID) { Grab(objectLocalID, Vector3.Zero, Vector3.Zero, Vector3.Zero, 0, Vector3.Zero, Vector3.Zero, Vector3.Zero); } /// /// Overload: Grab a simulated object /// /// an unsigned integer of the objects ID within the simulator /// /// The texture coordinates to grab /// The surface coordinates to grab /// The face of the position to grab /// The region coordinates of the position to grab /// The surface normal of the position to grab (A normal is a vector perpindicular to the surface) /// The surface binormal of the position to grab (A binormal is a vector tangen to the surface /// pointing along the U direction of the tangent space public void Grab(uint objectLocalID, Vector3 grabOffset, Vector3 uvCoord, Vector3 stCoord, int faceIndex, Vector3 position, Vector3 normal, Vector3 binormal) { ObjectGrabPacket grab = new ObjectGrabPacket(); grab.AgentData.AgentID = Client.Self.AgentID; grab.AgentData.SessionID = Client.Self.SessionID; grab.ObjectData.LocalID = objectLocalID; grab.ObjectData.GrabOffset = grabOffset; grab.SurfaceInfo = new ObjectGrabPacket.SurfaceInfoBlock[1]; grab.SurfaceInfo[0] = new ObjectGrabPacket.SurfaceInfoBlock(); grab.SurfaceInfo[0].UVCoord = uvCoord; grab.SurfaceInfo[0].STCoord = stCoord; grab.SurfaceInfo[0].FaceIndex = faceIndex; grab.SurfaceInfo[0].Position = position; grab.SurfaceInfo[0].Normal = normal; grab.SurfaceInfo[0].Binormal = binormal; Client.Network.SendPacket(grab); } /// /// Drag an object /// /// of the object to drag /// Drag target in region coordinates public void GrabUpdate(UUID objectID, Vector3 grabPosition) { GrabUpdate(objectID, grabPosition, Vector3.Zero, Vector3.Zero, Vector3.Zero, 0, Vector3.Zero, Vector3.Zero, Vector3.Zero); } /// /// Overload: Drag an object /// /// of the object to drag /// Drag target in region coordinates /// /// The texture coordinates to grab /// The surface coordinates to grab /// The face of the position to grab /// The region coordinates of the position to grab /// The surface normal of the position to grab (A normal is a vector perpindicular to the surface) /// The surface binormal of the position to grab (A binormal is a vector tangen to the surface /// pointing along the U direction of the tangent space public void GrabUpdate(UUID objectID, Vector3 grabPosition, Vector3 grabOffset, Vector3 uvCoord, Vector3 stCoord, int faceIndex, Vector3 position, Vector3 normal, Vector3 binormal) { ObjectGrabUpdatePacket grab = new ObjectGrabUpdatePacket(); grab.AgentData.AgentID = Client.Self.AgentID; grab.AgentData.SessionID = Client.Self.SessionID; grab.ObjectData.ObjectID = objectID; grab.ObjectData.GrabOffsetInitial = grabOffset; grab.ObjectData.GrabPosition = grabPosition; grab.ObjectData.TimeSinceLast = 0; grab.SurfaceInfo = new ObjectGrabUpdatePacket.SurfaceInfoBlock[1]; grab.SurfaceInfo[0] = new ObjectGrabUpdatePacket.SurfaceInfoBlock(); grab.SurfaceInfo[0].UVCoord = uvCoord; grab.SurfaceInfo[0].STCoord = stCoord; grab.SurfaceInfo[0].FaceIndex = faceIndex; grab.SurfaceInfo[0].Position = position; grab.SurfaceInfo[0].Normal = normal; grab.SurfaceInfo[0].Binormal = binormal; Client.Network.SendPacket(grab); } /// /// Release a grabbed object /// /// The Objects Simulator Local ID /// /// /// public void DeGrab(uint objectLocalID) { DeGrab(objectLocalID, Vector3.Zero, Vector3.Zero, 0, Vector3.Zero, Vector3.Zero, Vector3.Zero); } /// /// Release a grabbed object /// /// The Objects Simulator Local ID /// The texture coordinates to grab /// The surface coordinates to grab /// The face of the position to grab /// The region coordinates of the position to grab /// The surface normal of the position to grab (A normal is a vector perpindicular to the surface) /// The surface binormal of the position to grab (A binormal is a vector tangen to the surface /// pointing along the U direction of the tangent space public void DeGrab(uint objectLocalID, Vector3 uvCoord, Vector3 stCoord, int faceIndex, Vector3 position, Vector3 normal, Vector3 binormal) { ObjectDeGrabPacket degrab = new ObjectDeGrabPacket(); degrab.AgentData.AgentID = Client.Self.AgentID; degrab.AgentData.SessionID = Client.Self.SessionID; degrab.ObjectData.LocalID = objectLocalID; degrab.SurfaceInfo = new ObjectDeGrabPacket.SurfaceInfoBlock[1]; degrab.SurfaceInfo[0] = new ObjectDeGrabPacket.SurfaceInfoBlock(); degrab.SurfaceInfo[0].UVCoord = uvCoord; degrab.SurfaceInfo[0].STCoord = stCoord; degrab.SurfaceInfo[0].FaceIndex = faceIndex; degrab.SurfaceInfo[0].Position = position; degrab.SurfaceInfo[0].Normal = normal; degrab.SurfaceInfo[0].Binormal = binormal; Client.Network.SendPacket(degrab); } /// /// Touches an object /// /// an unsigned integer of the objects ID within the simulator /// public void Touch(uint objectLocalID) { Client.Self.Grab(objectLocalID); Client.Self.DeGrab(objectLocalID); } #endregion Touch and grab #region Money /// /// Request the current L$ balance /// public void RequestBalance() { MoneyBalanceRequestPacket money = new MoneyBalanceRequestPacket(); money.AgentData.AgentID = Client.Self.AgentID; money.AgentData.SessionID = Client.Self.SessionID; money.MoneyData.TransactionID = UUID.Zero; Client.Network.SendPacket(money); } /// /// Give Money to destination Avatar /// /// UUID of the Target Avatar /// Amount in L$ public void GiveAvatarMoney(UUID target, int amount) { GiveMoney(target, amount, String.Empty, MoneyTransactionType.Gift, TransactionFlags.None); } /// /// Give Money to destination Avatar /// /// UUID of the Target Avatar /// Amount in L$ /// Description that will show up in the /// recipients transaction history public void GiveAvatarMoney(UUID target, int amount, string description) { GiveMoney(target, amount, description, MoneyTransactionType.Gift, TransactionFlags.None); } /// /// Give L$ to an object /// /// object to give money to /// amount of L$ to give /// name of object public void GiveObjectMoney(UUID target, int amount, string objectName) { GiveMoney(target, amount, objectName, MoneyTransactionType.PayObject, TransactionFlags.None); } /// /// Give L$ to a group /// /// group to give money to /// amount of L$ to give public void GiveGroupMoney(UUID target, int amount) { GiveMoney(target, amount, String.Empty, MoneyTransactionType.Gift, TransactionFlags.DestGroup); } /// /// Give L$ to a group /// /// group to give money to /// amount of L$ to give /// description of transaction public void GiveGroupMoney(UUID target, int amount, string description) { GiveMoney(target, amount, description, MoneyTransactionType.Gift, TransactionFlags.DestGroup); } /// /// Pay texture/animation upload fee /// public void PayUploadFee() { GiveMoney(UUID.Zero, Client.Settings.UPLOAD_COST, String.Empty, MoneyTransactionType.UploadCharge, TransactionFlags.None); } /// /// Pay texture/animation upload fee /// /// description of the transaction public void PayUploadFee(string description) { GiveMoney(UUID.Zero, Client.Settings.UPLOAD_COST, description, MoneyTransactionType.UploadCharge, TransactionFlags.None); } /// /// Give Money to destination Object or Avatar /// /// UUID of the Target Object/Avatar /// Amount in L$ /// Reason (Optional normally) /// The type of transaction /// Transaction flags, mostly for identifying group /// transactions public void GiveMoney(UUID target, int amount, string description, MoneyTransactionType type, TransactionFlags flags) { MoneyTransferRequestPacket money = new MoneyTransferRequestPacket(); money.AgentData.AgentID = this.id; money.AgentData.SessionID = Client.Self.SessionID; money.MoneyData.Description = Utils.StringToBytes(description); money.MoneyData.DestID = target; money.MoneyData.SourceID = this.id; money.MoneyData.TransactionType = (int)type; money.MoneyData.AggregatePermInventory = 0; // This is weird, apparently always set to zero though money.MoneyData.AggregatePermNextOwner = 0; // This is weird, apparently always set to zero though money.MoneyData.Flags = (byte)flags; money.MoneyData.Amount = amount; Client.Network.SendPacket(money); } #endregion Money #region Gestures /// /// Plays a gesture /// /// Asset of the gesture public void PlayGesture(UUID gestureID) { Thread t = new Thread(new ThreadStart(delegate() { // First fetch the guesture AssetGesture gesture = null; if (gestureCache.ContainsKey(gestureID)) { gesture = gestureCache[gestureID]; } else { AutoResetEvent gotAsset = new AutoResetEvent(false); Client.Assets.RequestAsset(gestureID, AssetType.Gesture, true, delegate(AssetDownload transfer, Asset asset) { if (transfer.Success) { gesture = (AssetGesture)asset; } gotAsset.Set(); } ); gotAsset.WaitOne(30 * 1000, false); if (gesture != null && gesture.Decode()) { lock (gestureCache) { if (!gestureCache.ContainsKey(gestureID)) { gestureCache[gestureID] = gesture; } } } } // We got it, now we play it if (gesture != null) { for (int i = 0; i < gesture.Sequence.Count; i++) { GestureStep step = gesture.Sequence[i]; switch (step.GestureStepType) { case GestureStepType.Chat: Chat(((GestureStepChat)step).Text, 0, ChatType.Normal); break; case GestureStepType.Animation: GestureStepAnimation anim = (GestureStepAnimation)step; if (anim.AnimationStart) { if (SignaledAnimations.ContainsKey(anim.ID)) { AnimationStop(anim.ID, true); } AnimationStart(anim.ID, true); } else { AnimationStop(anim.ID, true); } break; case GestureStepType.Sound: Client.Sound.PlaySound(((GestureStepSound)step).ID); break; case GestureStepType.Wait: GestureStepWait wait = (GestureStepWait)step; if (wait.WaitForTime) { Thread.Sleep((int)(1000f * wait.WaitTime)); } if (wait.WaitForAnimation) { // TODO: implement waiting for all animations to end that were triggered // during playing of this guesture sequence } break; } } } })); t.IsBackground = true; t.Name = "Gesture thread: " + gestureID; t.Start(); } /// /// Mark gesture active /// /// Inventory of the gesture /// Asset of the gesture public void ActivateGesture(UUID invID, UUID assetID) { ActivateGesturesPacket p = new ActivateGesturesPacket(); p.AgentData.AgentID = AgentID; p.AgentData.SessionID = SessionID; p.AgentData.Flags = 0x00; ActivateGesturesPacket.DataBlock b = new ActivateGesturesPacket.DataBlock(); b.ItemID = invID; b.AssetID = assetID; b.GestureFlags = 0x00; p.Data = new ActivateGesturesPacket.DataBlock[1]; p.Data[0] = b; Client.Network.SendPacket(p); } /// /// Mark gesture inactive /// /// Inventory of the gesture public void DeactivateGesture(UUID invID) { DeactivateGesturesPacket p = new DeactivateGesturesPacket(); p.AgentData.AgentID = AgentID; p.AgentData.SessionID = SessionID; p.AgentData.Flags = 0x00; DeactivateGesturesPacket.DataBlock b = new DeactivateGesturesPacket.DataBlock(); b.ItemID = invID; b.GestureFlags = 0x00; p.Data = new DeactivateGesturesPacket.DataBlock[1]; p.Data[0] = b; Client.Network.SendPacket(p); } #endregion #region Animations /// /// Send an AgentAnimation packet that toggles a single animation on /// /// The of the animation to start playing /// Whether to ensure delivery of this packet or not public void AnimationStart(UUID animation, bool reliable) { Dictionary animations = new Dictionary(); animations[animation] = true; Animate(animations, reliable); } /// /// Send an AgentAnimation packet that toggles a single animation off /// /// The of a /// currently playing animation to stop playing /// Whether to ensure delivery of this packet or not public void AnimationStop(UUID animation, bool reliable) { Dictionary animations = new Dictionary(); animations[animation] = false; Animate(animations, reliable); } /// /// Send an AgentAnimation packet that will toggle animations on or off /// /// A list of animation s, and whether to /// turn that animation on or off /// Whether to ensure delivery of this packet or not public void Animate(Dictionary animations, bool reliable) { AgentAnimationPacket animate = new AgentAnimationPacket(); animate.Header.Reliable = reliable; animate.AgentData.AgentID = Client.Self.AgentID; animate.AgentData.SessionID = Client.Self.SessionID; animate.AnimationList = new AgentAnimationPacket.AnimationListBlock[animations.Count]; int i = 0; foreach (KeyValuePair animation in animations) { animate.AnimationList[i] = new AgentAnimationPacket.AnimationListBlock(); animate.AnimationList[i].AnimID = animation.Key; animate.AnimationList[i].StartAnim = animation.Value; i++; } // TODO: Implement support for this animate.PhysicalAvatarEventList = new AgentAnimationPacket.PhysicalAvatarEventListBlock[0]; Client.Network.SendPacket(animate); } #endregion Animations #region Teleporting /// /// Teleports agent to their stored home location /// /// true on successful teleport to home location public bool GoHome() { return Teleport(UUID.Zero); } /// /// Teleport agent to a landmark /// /// of the landmark to teleport agent to /// true on success, false on failure public bool Teleport(UUID landmark) { teleportStat = TeleportStatus.None; teleportEvent.Reset(); TeleportLandmarkRequestPacket p = new TeleportLandmarkRequestPacket(); p.Info = new TeleportLandmarkRequestPacket.InfoBlock(); p.Info.AgentID = Client.Self.AgentID; p.Info.SessionID = Client.Self.SessionID; p.Info.LandmarkID = landmark; Client.Network.SendPacket(p); teleportEvent.WaitOne(Client.Settings.TELEPORT_TIMEOUT, false); if (teleportStat == TeleportStatus.None || teleportStat == TeleportStatus.Start || teleportStat == TeleportStatus.Progress) { teleportMessage = "Teleport timed out."; teleportStat = TeleportStatus.Failed; } return (teleportStat == TeleportStatus.Finished); } /// /// Attempt to look up a simulator name and teleport to the discovered /// destination /// /// Region name to look up /// Position to teleport to /// True if the lookup and teleport were successful, otherwise /// false public bool Teleport(string simName, Vector3 position) { return Teleport(simName, position, new Vector3(0, 1.0f, 0)); } /// /// Attempt to look up a simulator name and teleport to the discovered /// destination /// /// Region name to look up /// Position to teleport to /// Target to look at /// True if the lookup and teleport were successful, otherwise /// false public bool Teleport(string simName, Vector3 position, Vector3 lookAt) { if (Client.Network.CurrentSim == null) return false; teleportStat = TeleportStatus.None; if (simName != Client.Network.CurrentSim.Name) { // Teleporting to a foreign sim GridRegion region; if (Client.Grid.GetGridRegion(simName, GridLayerType.Objects, out region)) { return Teleport(region.RegionHandle, position, lookAt); } else { teleportMessage = "Unable to resolve name: " + simName; teleportStat = TeleportStatus.Failed; return false; } } else { // Teleporting to the sim we're already in return Teleport(Client.Network.CurrentSim.Handle, position, lookAt); } } /// /// Teleport agent to another region /// /// handle of region to teleport agent to /// position in destination sim to teleport to /// true on success, false on failure /// This call is blocking public bool Teleport(ulong regionHandle, Vector3 position) { return Teleport(regionHandle, position, new Vector3(0.0f, 1.0f, 0.0f)); } /// /// Teleport agent to another region /// /// handle of region to teleport agent to /// position in destination sim to teleport to /// direction in destination sim agent will look at /// true on success, false on failure /// This call is blocking public bool Teleport(ulong regionHandle, Vector3 position, Vector3 lookAt) { if (Client.Network.CurrentSim == null || Client.Network.CurrentSim.Caps == null || !Client.Network.CurrentSim.Caps.IsEventQueueRunning) { // Wait a bit to see if the event queue comes online AutoResetEvent queueEvent = new AutoResetEvent(false); EventHandler queueCallback = delegate(object sender, EventQueueRunningEventArgs e) { if (e.Simulator == Client.Network.CurrentSim) queueEvent.Set(); }; Client.Network.EventQueueRunning += queueCallback; queueEvent.WaitOne(10 * 1000, false); Client.Network.EventQueueRunning -= queueCallback; } teleportStat = TeleportStatus.None; teleportEvent.Reset(); RequestTeleport(regionHandle, position, lookAt); teleportEvent.WaitOne(Client.Settings.TELEPORT_TIMEOUT, false); if (teleportStat == TeleportStatus.None || teleportStat == TeleportStatus.Start || teleportStat == TeleportStatus.Progress) { teleportMessage = "Teleport timed out."; teleportStat = TeleportStatus.Failed; } return (teleportStat == TeleportStatus.Finished); } /// /// Request teleport to a another simulator /// /// handle of region to teleport agent to /// position in destination sim to teleport to public void RequestTeleport(ulong regionHandle, Vector3 position) { RequestTeleport(regionHandle, position, new Vector3(0.0f, 1.0f, 0.0f)); } /// /// Request teleport to a another simulator /// /// handle of region to teleport agent to /// position in destination sim to teleport to /// direction in destination sim agent will look at public void RequestTeleport(ulong regionHandle, Vector3 position, Vector3 lookAt) { if (Client.Network.CurrentSim != null && Client.Network.CurrentSim.Caps != null && Client.Network.CurrentSim.Caps.IsEventQueueRunning) { TeleportLocationRequestPacket teleport = new TeleportLocationRequestPacket(); teleport.AgentData.AgentID = Client.Self.AgentID; teleport.AgentData.SessionID = Client.Self.SessionID; teleport.Info.LookAt = lookAt; teleport.Info.Position = position; teleport.Info.RegionHandle = regionHandle; Logger.Log("Requesting teleport to region handle " + regionHandle.ToString(), Helpers.LogLevel.Info, Client); Client.Network.SendPacket(teleport); } else { teleportMessage = "CAPS event queue is not running"; teleportEvent.Set(); teleportStat = TeleportStatus.Failed; } } /// /// Teleport agent to a landmark /// /// of the landmark to teleport agent to public void RequestTeleport(UUID landmark) { TeleportLandmarkRequestPacket p = new TeleportLandmarkRequestPacket(); p.Info = new TeleportLandmarkRequestPacket.InfoBlock(); p.Info.AgentID = Client.Self.AgentID; p.Info.SessionID = Client.Self.SessionID; p.Info.LandmarkID = landmark; Client.Network.SendPacket(p); } /// /// Send a teleport lure to another avatar with default "Join me in ..." invitation message /// /// target avatars to lure public void SendTeleportLure(UUID targetID) { SendTeleportLure(targetID, "Join me in " + Client.Network.CurrentSim.Name + "!"); } /// /// Send a teleport lure to another avatar with custom invitation message /// /// target avatars to lure /// custom message to send with invitation public void SendTeleportLure(UUID targetID, string message) { StartLurePacket p = new StartLurePacket(); p.AgentData.AgentID = Client.Self.id; p.AgentData.SessionID = Client.Self.SessionID; p.Info.LureType = 0; p.Info.Message = Utils.StringToBytes(message); p.TargetData = new StartLurePacket.TargetDataBlock[] { new StartLurePacket.TargetDataBlock() }; p.TargetData[0].TargetID = targetID; Client.Network.SendPacket(p); } /// /// Respond to a teleport lure by either accepting it and initiating /// the teleport, or denying it /// /// of the avatar sending the lure /// true to accept the lure, false to decline it public void TeleportLureRespond(UUID requesterID, bool accept) { InstantMessage(Name, requesterID, String.Empty, UUID.Random(), accept ? InstantMessageDialog.AcceptTeleport : InstantMessageDialog.DenyTeleport, InstantMessageOnline.Offline, this.SimPosition, UUID.Zero, Utils.EmptyBytes); if (accept) { TeleportLureRequestPacket lure = new TeleportLureRequestPacket(); lure.Info.AgentID = Client.Self.AgentID; lure.Info.SessionID = Client.Self.SessionID; lure.Info.LureID = Client.Self.AgentID; lure.Info.TeleportFlags = (uint)TeleportFlags.ViaLure; Client.Network.SendPacket(lure); } } #endregion Teleporting #region Misc /// /// Update agent profile /// /// struct containing updated /// profile information public void UpdateProfile(Avatar.AvatarProperties profile) { AvatarPropertiesUpdatePacket apup = new AvatarPropertiesUpdatePacket(); apup.AgentData.AgentID = id; apup.AgentData.SessionID = sessionID; apup.PropertiesData.AboutText = Utils.StringToBytes(profile.AboutText); apup.PropertiesData.AllowPublish = profile.AllowPublish; apup.PropertiesData.FLAboutText = Utils.StringToBytes(profile.FirstLifeText); apup.PropertiesData.FLImageID = profile.FirstLifeImage; apup.PropertiesData.ImageID = profile.ProfileImage; apup.PropertiesData.MaturePublish = profile.MaturePublish; apup.PropertiesData.ProfileURL = Utils.StringToBytes(profile.ProfileURL); Client.Network.SendPacket(apup); } /// /// Update agents profile interests /// /// selection of interests from struct public void UpdateInterests(Avatar.Interests interests) { AvatarInterestsUpdatePacket aiup = new AvatarInterestsUpdatePacket(); aiup.AgentData.AgentID = id; aiup.AgentData.SessionID = sessionID; aiup.PropertiesData.LanguagesText = Utils.StringToBytes(interests.LanguagesText); aiup.PropertiesData.SkillsMask = interests.SkillsMask; aiup.PropertiesData.SkillsText = Utils.StringToBytes(interests.SkillsText); aiup.PropertiesData.WantToMask = interests.WantToMask; aiup.PropertiesData.WantToText = Utils.StringToBytes(interests.WantToText); Client.Network.SendPacket(aiup); } /// /// Set the height and the width of the client window. This is used /// by the server to build a virtual camera frustum for our avatar /// /// New height of the viewer window /// New width of the viewer window public void SetHeightWidth(ushort height, ushort width) { AgentHeightWidthPacket heightwidth = new AgentHeightWidthPacket(); heightwidth.AgentData.AgentID = Client.Self.AgentID; heightwidth.AgentData.SessionID = Client.Self.SessionID; heightwidth.AgentData.CircuitCode = Client.Network.CircuitCode; heightwidth.HeightWidthBlock.Height = height; heightwidth.HeightWidthBlock.Width = width; heightwidth.HeightWidthBlock.GenCounter = heightWidthGenCounter++; Client.Network.SendPacket(heightwidth); } /// /// Request the list of muted objects and avatars for this agent /// public void RequestMuteList() { MuteListRequestPacket mute = new MuteListRequestPacket(); mute.AgentData.AgentID = Client.Self.AgentID; mute.AgentData.SessionID = Client.Self.SessionID; mute.MuteData.MuteCRC = 0; Client.Network.SendPacket(mute); } /// /// Sets home location to agents current position /// /// will fire an AlertMessage () with /// success or failure message public void SetHome() { SetStartLocationRequestPacket s = new SetStartLocationRequestPacket(); s.AgentData = new SetStartLocationRequestPacket.AgentDataBlock(); s.AgentData.AgentID = Client.Self.AgentID; s.AgentData.SessionID = Client.Self.SessionID; s.StartLocationData = new SetStartLocationRequestPacket.StartLocationDataBlock(); s.StartLocationData.LocationPos = Client.Self.SimPosition; s.StartLocationData.LocationID = 1; s.StartLocationData.SimName = Utils.StringToBytes(String.Empty); s.StartLocationData.LocationLookAt = Movement.Camera.AtAxis; Client.Network.SendPacket(s); } /// /// Move an agent in to a simulator. This packet is the last packet /// needed to complete the transition in to a new simulator /// /// Object public void CompleteAgentMovement(Simulator simulator) { CompleteAgentMovementPacket move = new CompleteAgentMovementPacket(); move.AgentData.AgentID = Client.Self.AgentID; move.AgentData.SessionID = Client.Self.SessionID; move.AgentData.CircuitCode = Client.Network.CircuitCode; Client.Network.SendPacket(move, simulator); } /// /// Reply to script permissions request /// /// Object /// of the itemID requesting permissions /// of the taskID requesting permissions /// list of permissions to allow public void ScriptQuestionReply(Simulator simulator, UUID itemID, UUID taskID, ScriptPermission permissions) { ScriptAnswerYesPacket yes = new ScriptAnswerYesPacket(); yes.AgentData.AgentID = Client.Self.AgentID; yes.AgentData.SessionID = Client.Self.SessionID; yes.Data.ItemID = itemID; yes.Data.TaskID = taskID; yes.Data.Questions = (int)permissions; Client.Network.SendPacket(yes, simulator); } /// /// Respond to a group invitation by either accepting or denying it /// /// UUID of the group (sent in the AgentID field of the invite message) /// IM Session ID from the group invitation message /// Accept the group invitation or deny it public void GroupInviteRespond(UUID groupID, UUID imSessionID, bool accept) { InstantMessage(Name, groupID, String.Empty, imSessionID, accept ? InstantMessageDialog.GroupInvitationAccept : InstantMessageDialog.GroupInvitationDecline, InstantMessageOnline.Offline, Vector3.Zero, UUID.Zero, Utils.EmptyBytes); } /// /// Requests script detection of objects and avatars /// /// name of the object/avatar to search for /// UUID of the object or avatar to search for /// Type of search from ScriptSensorTypeFlags /// range of scan (96 max?) /// the arc in radians to search within /// an user generated ID to correlate replies with /// Simulator to perform search in public void RequestScriptSensor(string name, UUID searchID, ScriptSensorTypeFlags type, float range, float arc, UUID requestID, Simulator sim) { ScriptSensorRequestPacket request = new ScriptSensorRequestPacket(); request.Requester.Arc = arc; request.Requester.Range = range; request.Requester.RegionHandle = sim.Handle; request.Requester.RequestID = requestID; request.Requester.SearchDir = Quaternion.Identity; // TODO: this needs to be tested request.Requester.SearchID = searchID; request.Requester.SearchName = Utils.StringToBytes(name); request.Requester.SearchPos = Vector3.Zero; request.Requester.SearchRegions = 0; // TODO: ? request.Requester.SourceID = Client.Self.AgentID; request.Requester.Type = (int)type; Client.Network.SendPacket(request, sim); } /// /// Create or update profile pick /// /// UUID of the pick to update, or random UUID to create a new pick /// Is this a top pick? (typically false) /// UUID of the parcel (UUID.Zero for the current parcel) /// Name of the pick /// Global position of the pick landmark /// UUID of the image displayed with the pick /// Long description of the pick public void PickInfoUpdate(UUID pickID, bool topPick, UUID parcelID, string name, Vector3d globalPosition, UUID textureID, string description) { PickInfoUpdatePacket pick = new PickInfoUpdatePacket(); pick.AgentData.AgentID = Client.Self.AgentID; pick.AgentData.SessionID = Client.Self.SessionID; pick.Data.PickID = pickID; pick.Data.Desc = Utils.StringToBytes(description); pick.Data.CreatorID = Client.Self.AgentID; pick.Data.TopPick = topPick; pick.Data.ParcelID = parcelID; pick.Data.Name = Utils.StringToBytes(name); pick.Data.SnapshotID = textureID; pick.Data.PosGlobal = globalPosition; pick.Data.SortOrder = 0; pick.Data.Enabled = false; Client.Network.SendPacket(pick); } /// /// Delete profile pick /// /// UUID of the pick to delete public void PickDelete(UUID pickID) { PickDeletePacket delete = new PickDeletePacket(); delete.AgentData.AgentID = Client.Self.AgentID; delete.AgentData.SessionID = Client.Self.sessionID; delete.Data.PickID = pickID; Client.Network.SendPacket(delete); } /// /// Create or update profile Classified /// /// UUID of the classified to update, or random UUID to create a new classified /// Defines what catagory the classified is in /// UUID of the image displayed with the classified /// Price that the classified will cost to place for a week /// Global position of the classified landmark /// Name of the classified /// Long description of the classified /// if true, auto renew classified after expiration public void UpdateClassifiedInfo(UUID classifiedID, DirectoryManager.ClassifiedCategories category, UUID snapshotID, int price, Vector3d position, string name, string desc, bool autoRenew) { ClassifiedInfoUpdatePacket classified = new ClassifiedInfoUpdatePacket(); classified.AgentData.AgentID = Client.Self.AgentID; classified.AgentData.SessionID = Client.Self.SessionID; classified.Data.ClassifiedID = classifiedID; classified.Data.Category = (uint)category; classified.Data.ParcelID = UUID.Zero; // TODO: verify/fix ^ classified.Data.ParentEstate = 0; // TODO: verify/fix ^ classified.Data.SnapshotID = snapshotID; classified.Data.PosGlobal = position; classified.Data.ClassifiedFlags = autoRenew ? (byte)32 : (byte)0; // TODO: verify/fix ^ classified.Data.PriceForListing = price; classified.Data.Name = Utils.StringToBytes(name); classified.Data.Desc = Utils.StringToBytes(desc); Client.Network.SendPacket(classified); } /// /// Create or update profile Classified /// /// UUID of the classified to update, or random UUID to create a new classified /// Defines what catagory the classified is in /// UUID of the image displayed with the classified /// Price that the classified will cost to place for a week /// Name of the classified /// Long description of the classified /// if true, auto renew classified after expiration public void UpdateClassifiedInfo(UUID classifiedID, DirectoryManager.ClassifiedCategories category, UUID snapshotID, int price, string name, string desc, bool autoRenew) { UpdateClassifiedInfo(classifiedID, category, snapshotID, price, Client.Self.GlobalPosition, name, desc, autoRenew); } /// /// Delete a classified ad /// /// The classified ads ID public void DeleteClassfied(UUID classifiedID) { ClassifiedDeletePacket classified = new ClassifiedDeletePacket(); classified.AgentData.AgentID = Client.Self.AgentID; classified.AgentData.SessionID = Client.Self.SessionID; classified.Data.ClassifiedID = classifiedID; Client.Network.SendPacket(classified); } #endregion Misc #region Packet Handlers /// /// Take an incoming ImprovedInstantMessage packet, auto-parse, and if /// OnInstantMessage is defined call that with the appropriate arguments /// /// The sender /// The EventArgs object containing the packet data protected void InstantMessageHandler(object sender, PacketReceivedEventArgs e) { Packet packet = e.Packet; Simulator simulator = e.Simulator; if (packet.Type == PacketType.ImprovedInstantMessage) { ImprovedInstantMessagePacket im = (ImprovedInstantMessagePacket)packet; if (m_InstantMessage != null) { InstantMessage message; message.FromAgentID = im.AgentData.AgentID; message.FromAgentName = Utils.BytesToString(im.MessageBlock.FromAgentName); message.ToAgentID = im.MessageBlock.ToAgentID; message.ParentEstateID = im.MessageBlock.ParentEstateID; message.RegionID = im.MessageBlock.RegionID; message.Position = im.MessageBlock.Position; message.Dialog = (InstantMessageDialog)im.MessageBlock.Dialog; message.GroupIM = im.MessageBlock.FromGroup; message.IMSessionID = im.MessageBlock.ID; message.Timestamp = new DateTime(im.MessageBlock.Timestamp); message.Message = Utils.BytesToString(im.MessageBlock.Message); message.Offline = (InstantMessageOnline)im.MessageBlock.Offline; message.BinaryBucket = im.MessageBlock.BinaryBucket; OnInstantMessage(new InstantMessageEventArgs(message, simulator)); } } } /// /// Take an incoming Chat packet, auto-parse, and if OnChat is defined call /// that with the appropriate arguments. /// /// The sender /// The EventArgs object containing the packet data protected void ChatHandler(object sender, PacketReceivedEventArgs e) { if (m_Chat != null) { Packet packet = e.Packet; ChatFromSimulatorPacket chat = (ChatFromSimulatorPacket)packet; OnChat(new ChatEventArgs(e.Simulator, Utils.BytesToString(chat.ChatData.Message), (ChatAudibleLevel)chat.ChatData.Audible, (ChatType)chat.ChatData.ChatType, (ChatSourceType)chat.ChatData.SourceType, Utils.BytesToString(chat.ChatData.FromName), chat.ChatData.SourceID, chat.ChatData.OwnerID, chat.ChatData.Position)); } } /// /// Used for parsing llDialogs /// /// The sender /// The EventArgs object containing the packet data protected void ScriptDialogHandler(object sender, PacketReceivedEventArgs e) { if (m_ScriptDialog != null) { Packet packet = e.Packet; ScriptDialogPacket dialog = (ScriptDialogPacket)packet; List buttons = new List(); foreach (ScriptDialogPacket.ButtonsBlock button in dialog.Buttons) { buttons.Add(Utils.BytesToString(button.ButtonLabel)); } OnScriptDialog(new ScriptDialogEventArgs(Utils.BytesToString(dialog.Data.Message), Utils.BytesToString(dialog.Data.ObjectName), dialog.Data.ImageID, dialog.Data.ObjectID, Utils.BytesToString(dialog.Data.FirstName), Utils.BytesToString(dialog.Data.LastName), dialog.Data.ChatChannel, buttons)); } } /// /// Used for parsing llRequestPermissions dialogs /// /// The sender /// The EventArgs object containing the packet data protected void ScriptQuestionHandler(object sender, PacketReceivedEventArgs e) { if (m_ScriptQuestion != null) { Packet packet = e.Packet; Simulator simulator = e.Simulator; ScriptQuestionPacket question = (ScriptQuestionPacket)packet; OnScriptQuestion(new ScriptQuestionEventArgs(simulator, question.Data.TaskID, question.Data.ItemID, Utils.BytesToString(question.Data.ObjectName), Utils.BytesToString(question.Data.ObjectOwner), (ScriptPermission)question.Data.Questions)); } } /// /// Handles Script Control changes when Script with permissions releases or takes a control /// /// The sender /// The EventArgs object containing the packet data private void ScriptControlChangeHandler(object sender, PacketReceivedEventArgs e) { if (m_ScriptControl != null) { Packet packet = e.Packet; ScriptControlChangePacket change = (ScriptControlChangePacket)packet; for (int i = 0; i < change.Data.Length; i++) { OnScriptControlChange(new ScriptControlEventArgs((ScriptControlChange)change.Data[i].Controls, change.Data[i].PassToAgent, change.Data[i].TakeControls)); } } } /// /// Used for parsing llLoadURL Dialogs /// /// The sender /// The EventArgs object containing the packet data protected void LoadURLHandler(object sender, PacketReceivedEventArgs e) { if (m_LoadURL != null) { Packet packet = e.Packet; LoadURLPacket loadURL = (LoadURLPacket)packet; OnLoadURL(new LoadUrlEventArgs( Utils.BytesToString(loadURL.Data.ObjectName), loadURL.Data.ObjectID, loadURL.Data.OwnerID, loadURL.Data.OwnerIsGroup, Utils.BytesToString(loadURL.Data.Message), Utils.BytesToString(loadURL.Data.URL) )); } } /// /// Update client's Position, LookAt and region handle from incoming packet /// /// The sender /// The EventArgs object containing the packet data /// This occurs when after an avatar moves into a new sim private void MovementCompleteHandler(object sender, PacketReceivedEventArgs e) { Packet packet = e.Packet; Simulator simulator = e.Simulator; AgentMovementCompletePacket movement = (AgentMovementCompletePacket)packet; relativePosition = movement.Data.Position; Movement.Camera.LookDirection(movement.Data.LookAt); simulator.Handle = movement.Data.RegionHandle; simulator.SimVersion = Utils.BytesToString(movement.SimData.ChannelVersion); } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void HealthHandler(object sender, PacketReceivedEventArgs e) { Packet packet = e.Packet; health = ((HealthMessagePacket)packet).HealthData.Health; } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void AgentDataUpdateHandler(object sender, PacketReceivedEventArgs e) { Packet packet = e.Packet; Simulator simulator = e.Simulator; AgentDataUpdatePacket p = (AgentDataUpdatePacket)packet; if (p.AgentData.AgentID == simulator.Client.Self.AgentID) { firstName = Utils.BytesToString(p.AgentData.FirstName); lastName = Utils.BytesToString(p.AgentData.LastName); activeGroup = p.AgentData.ActiveGroupID; activeGroupPowers = (GroupPowers)p.AgentData.GroupPowers; if (m_AgentData != null) { string groupTitle = Utils.BytesToString(p.AgentData.GroupTitle); string groupName = Utils.BytesToString(p.AgentData.GroupName); OnAgentData(new AgentDataReplyEventArgs(firstName, lastName, activeGroup, groupTitle, activeGroupPowers, groupName)); } } else { Logger.Log("Got an AgentDataUpdate packet for avatar " + p.AgentData.AgentID.ToString() + " instead of " + Client.Self.AgentID.ToString() + ", this shouldn't happen", Helpers.LogLevel.Error, Client); } } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void MoneyBalanceReplyHandler(object sender, PacketReceivedEventArgs e) { Packet packet = e.Packet; if (packet.Type == PacketType.MoneyBalanceReply) { MoneyBalanceReplyPacket reply = (MoneyBalanceReplyPacket)packet; this.balance = reply.MoneyData.MoneyBalance; if (m_MoneyBalance != null) { OnMoneyBalanceReply(new MoneyBalanceReplyEventArgs(reply.MoneyData.TransactionID, reply.MoneyData.TransactionSuccess, reply.MoneyData.MoneyBalance, reply.MoneyData.SquareMetersCredit, reply.MoneyData.SquareMetersCommitted, Utils.BytesToString(reply.MoneyData.Description))); } } if (m_Balance != null) { OnBalance(new BalanceEventArgs(balance)); } } protected void EstablishAgentCommunicationEventHandler(string capsKey, IMessage message, Simulator simulator) { EstablishAgentCommunicationMessage msg = (EstablishAgentCommunicationMessage)message; if (Client.Settings.MULTIPLE_SIMS) { IPEndPoint endPoint = new IPEndPoint(msg.Address, msg.Port); Simulator sim = Client.Network.FindSimulator(endPoint); if (sim == null) { Logger.Log("Got EstablishAgentCommunication for unknown sim " + msg.Address + ":" + msg.Port, Helpers.LogLevel.Error, Client); // FIXME: Should we use this opportunity to connect to the simulator? } else { Logger.Log("Got EstablishAgentCommunication for " + sim.ToString(), Helpers.LogLevel.Info, Client); sim.SetSeedCaps(msg.SeedCapability.ToString()); } } } /// /// Process TeleportFailed message sent via EventQueue, informs agent its last teleport has failed and why. /// /// The Message Key /// An IMessage object Deserialized from the recieved message event /// The simulator originating the event message public void TeleportFailedEventHandler(string messageKey, IMessage message, Simulator simulator) { TeleportFailedMessage msg = (TeleportFailedMessage)message; TeleportFailedPacket failedPacket = new TeleportFailedPacket(); failedPacket.Info.AgentID = msg.AgentID; failedPacket.Info.Reason = Utils.StringToBytes(msg.Reason); TeleportHandler(this, new PacketReceivedEventArgs(failedPacket, simulator)); } /// /// Process TeleportFinish from Event Queue and pass it onto our TeleportHandler /// /// The message system key for this event /// IMessage object containing decoded data from OSD /// The simulator originating the event message private void TeleportFinishEventHandler(string capsKey, IMessage message, Simulator simulator) { TeleportFinishMessage msg = (TeleportFinishMessage)message; TeleportFinishPacket p = new TeleportFinishPacket(); p.Info.AgentID = msg.AgentID; p.Info.LocationID = (uint)msg.LocationID; p.Info.RegionHandle = msg.RegionHandle; p.Info.SeedCapability = Utils.StringToBytes(msg.SeedCapability.ToString()); // FIXME: Check This p.Info.SimAccess = (byte)msg.SimAccess; p.Info.SimIP = Utils.IPToUInt(msg.IP); p.Info.SimPort = (ushort)msg.Port; p.Info.TeleportFlags = (uint)msg.Flags; // pass the packet onto the teleport handler TeleportHandler(this, new PacketReceivedEventArgs(p, simulator)); } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void TeleportHandler(object sender, PacketReceivedEventArgs e) { Packet packet = e.Packet; Simulator simulator = e.Simulator; bool finished = false; TeleportFlags flags = TeleportFlags.Default; if (packet.Type == PacketType.TeleportStart) { TeleportStartPacket start = (TeleportStartPacket)packet; teleportMessage = "Teleport started"; flags = (TeleportFlags)start.Info.TeleportFlags; teleportStat = TeleportStatus.Start; Logger.DebugLog("TeleportStart received, Flags: " + flags.ToString(), Client); } else if (packet.Type == PacketType.TeleportProgress) { TeleportProgressPacket progress = (TeleportProgressPacket)packet; teleportMessage = Utils.BytesToString(progress.Info.Message); flags = (TeleportFlags)progress.Info.TeleportFlags; teleportStat = TeleportStatus.Progress; Logger.DebugLog("TeleportProgress received, Message: " + teleportMessage + ", Flags: " + flags.ToString(), Client); } else if (packet.Type == PacketType.TeleportFailed) { TeleportFailedPacket failed = (TeleportFailedPacket)packet; teleportMessage = Utils.BytesToString(failed.Info.Reason); teleportStat = TeleportStatus.Failed; finished = true; Logger.DebugLog("TeleportFailed received, Reason: " + teleportMessage, Client); } else if (packet.Type == PacketType.TeleportFinish) { TeleportFinishPacket finish = (TeleportFinishPacket)packet; flags = (TeleportFlags)finish.Info.TeleportFlags; string seedcaps = Utils.BytesToString(finish.Info.SeedCapability); finished = true; Logger.DebugLog("TeleportFinish received, Flags: " + flags.ToString(), Client); // Connect to the new sim Simulator newSimulator = Client.Network.Connect(new IPAddress(finish.Info.SimIP), finish.Info.SimPort, finish.Info.RegionHandle, true, seedcaps); if (newSimulator != null) { teleportMessage = "Teleport finished"; teleportStat = TeleportStatus.Finished; Logger.Log("Moved to new sim " + newSimulator.ToString(), Helpers.LogLevel.Info, Client); } else { teleportMessage = "Failed to connect to the new sim after a teleport"; teleportStat = TeleportStatus.Failed; // We're going to get disconnected now Logger.Log(teleportMessage, Helpers.LogLevel.Error, Client); } } else if (packet.Type == PacketType.TeleportCancel) { //TeleportCancelPacket cancel = (TeleportCancelPacket)packet; teleportMessage = "Cancelled"; teleportStat = TeleportStatus.Cancelled; finished = true; Logger.DebugLog("TeleportCancel received from " + simulator.ToString(), Client); } else if (packet.Type == PacketType.TeleportLocal) { TeleportLocalPacket local = (TeleportLocalPacket)packet; teleportMessage = "Teleport finished"; flags = (TeleportFlags)local.Info.TeleportFlags; teleportStat = TeleportStatus.Finished; relativePosition = local.Info.Position; Movement.Camera.LookDirection(local.Info.LookAt); // This field is apparently not used for anything //local.Info.LocationID; finished = true; Logger.DebugLog("TeleportLocal received, Flags: " + flags.ToString(), Client); } if (m_Teleport != null) { OnTeleport(new TeleportEventArgs(teleportMessage, teleportStat, flags)); } if (finished) teleportEvent.Set(); } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void AvatarAnimationHandler(object sender, PacketReceivedEventArgs e) { Packet packet = e.Packet; AvatarAnimationPacket animation = (AvatarAnimationPacket)packet; if (animation.Sender.ID == Client.Self.AgentID) { lock (SignaledAnimations.Dictionary) { // Reset the signaled animation list SignaledAnimations.Dictionary.Clear(); for (int i = 0; i < animation.AnimationList.Length; i++) { UUID animID = animation.AnimationList[i].AnimID; int sequenceID = animation.AnimationList[i].AnimSequenceID; // Add this animation to the list of currently signaled animations SignaledAnimations.Dictionary[animID] = sequenceID; if (i < animation.AnimationSourceList.Length) { // FIXME: The server tells us which objects triggered our animations, // we should store this info //animation.AnimationSourceList[i].ObjectID } if (i < animation.PhysicalAvatarEventList.Length) { // FIXME: What is this? } if (Client.Settings.SEND_AGENT_UPDATES) { // We have to manually tell the server to stop playing some animations if (animID == Animations.STANDUP || animID == Animations.PRE_JUMP || animID == Animations.LAND || animID == Animations.MEDIUM_LAND) { Movement.FinishAnim = true; Movement.SendUpdate(true); Movement.FinishAnim = false; } } } } } if (m_AnimationsChanged != null) { OnAnimationsChanged(new AnimationsChangedEventArgs(this.SignaledAnimations)); } } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void MeanCollisionAlertHandler(object sender, PacketReceivedEventArgs e) { if (m_MeanCollision != null) { Packet packet = e.Packet; MeanCollisionAlertPacket collision = (MeanCollisionAlertPacket)packet; for (int i = 0; i < collision.MeanCollision.Length; i++) { MeanCollisionAlertPacket.MeanCollisionBlock block = collision.MeanCollision[i]; DateTime time = Utils.UnixTimeToDateTime(block.Time); MeanCollisionType type = (MeanCollisionType)block.Type; OnMeanCollision(new MeanCollisionEventArgs(type, block.Perp, block.Victim, block.Mag, time)); } } } private void Network_OnLoginResponse(bool loginSuccess, bool redirect, string message, string reason, LoginResponseData reply) { id = reply.AgentID; sessionID = reply.SessionID; secureSessionID = reply.SecureSessionID; firstName = reply.FirstName; lastName = reply.LastName; startLocation = reply.StartLocation; agentAccess = reply.AgentAccess; Movement.Camera.LookDirection(reply.LookAt); homePosition = reply.HomePosition; homeLookAt = reply.HomeLookAt; } private void Network_OnDisconnected(object sender, DisconnectedEventArgs e) { // Null out the cached fullName since it can change after logging // in again (with a different account name or different login // server but using the same GridClient object fullName = null; } /// /// Crossed region handler for message that comes across the EventQueue. Sent to an agent /// when the agent crosses a sim border into a new region. /// /// The message key /// the IMessage object containing the deserialized data sent from the simulator /// The which originated the packet private void CrossedRegionEventHandler(string capsKey, IMessage message, Simulator simulator) { CrossedRegionMessage crossed = (CrossedRegionMessage)message; IPEndPoint endPoint = new IPEndPoint(crossed.IP, crossed.Port); Logger.DebugLog("Crossed in to new region area, attempting to connect to " + endPoint.ToString(), Client); Simulator oldSim = Client.Network.CurrentSim; Simulator newSim = Client.Network.Connect(endPoint, crossed.RegionHandle, true, crossed.SeedCapability.ToString()); if (newSim != null) { Logger.Log("Finished crossing over in to region " + newSim.ToString(), Helpers.LogLevel.Info, Client); if (m_RegionCrossed != null) { OnRegionCrossed(new RegionCrossedEventArgs(oldSim, newSim)); } } else { // The old simulator will (poorly) handle our movement still, so the connection isn't // completely shot yet Logger.Log("Failed to connect to new region " + endPoint.ToString() + " after crossing over", Helpers.LogLevel.Warning, Client); } } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data /// This packet is now being sent via the EventQueue protected void CrossedRegionHandler(object sender, PacketReceivedEventArgs e) { Packet packet = e.Packet; CrossedRegionPacket crossing = (CrossedRegionPacket)packet; string seedCap = Utils.BytesToString(crossing.RegionData.SeedCapability); IPEndPoint endPoint = new IPEndPoint(crossing.RegionData.SimIP, crossing.RegionData.SimPort); Logger.DebugLog("Crossed in to new region area, attempting to connect to " + endPoint.ToString(), Client); Simulator oldSim = Client.Network.CurrentSim; Simulator newSim = Client.Network.Connect(endPoint, crossing.RegionData.RegionHandle, true, seedCap); if (newSim != null) { Logger.Log("Finished crossing over in to region " + newSim.ToString(), Helpers.LogLevel.Info, Client); if (m_RegionCrossed != null) { OnRegionCrossed(new RegionCrossedEventArgs(oldSim, newSim)); } } else { // The old simulator will (poorly) handle our movement still, so the connection isn't // completely shot yet Logger.Log("Failed to connect to new region " + endPoint.ToString() + " after crossing over", Helpers.LogLevel.Warning, Client); } } /// /// Group Chat event handler /// /// The capability Key /// IMessage object containing decoded data from OSD /// protected void ChatterBoxSessionEventReplyEventHandler(string capsKey, IMessage message, Simulator simulator) { ChatterboxSessionEventReplyMessage msg = (ChatterboxSessionEventReplyMessage)message; if (!msg.Success) { Logger.Log("Attempt to send group chat to non-existant session for group " + msg.SessionID, Helpers.LogLevel.Info, Client); } } /// /// Response from request to join a group chat /// /// /// IMessage object containing decoded data from OSD /// protected void ChatterBoxSessionStartReplyEventHandler(string capsKey, IMessage message, Simulator simulator) { if (m_GroupChatJoined != null) { ChatterBoxSessionStartReplyMessage msg = (ChatterBoxSessionStartReplyMessage)message; OnGroupChatJoined(new GroupChatJoinedEventArgs(msg.SessionID, msg.SessionName, msg.TempSessionID, msg.Success)); } } /// /// Someone joined or left group chat /// /// /// IMessage object containing decoded data from OSD /// private void ChatterBoxSessionAgentListUpdatesEventHandler(string capsKey, IMessage message, Simulator simulator) { ChatterBoxSessionAgentListUpdatesMessage msg = (ChatterBoxSessionAgentListUpdatesMessage)message; lock (GroupChatSessions.Dictionary) if (!GroupChatSessions.ContainsKey(msg.SessionID)) GroupChatSessions.Add(msg.SessionID, new List()); for (int i = 0; i < msg.Updates.Length; i++) { ChatSessionMember fndMbr; lock (GroupChatSessions.Dictionary) { fndMbr = GroupChatSessions[msg.SessionID].Find(delegate(ChatSessionMember member) { return member.AvatarKey == msg.Updates[i].AgentID; }); } if (msg.Updates[i].Transition != null) { if (msg.Updates[i].Transition.Equals("ENTER")) { if (fndMbr.AvatarKey == UUID.Zero) { fndMbr = new ChatSessionMember(); fndMbr.AvatarKey = msg.Updates[i].AgentID; lock (GroupChatSessions.Dictionary) GroupChatSessions[msg.SessionID].Add(fndMbr); if (m_ChatSessionMemberAdded != null) { OnChatSessionMemberAdded(new ChatSessionMemberAddedEventArgs(msg.SessionID, fndMbr.AvatarKey)); } } } else if (msg.Updates[i].Transition.Equals("LEAVE")) { if (fndMbr.AvatarKey != UUID.Zero) lock (GroupChatSessions.Dictionary) GroupChatSessions[msg.SessionID].Remove(fndMbr); if (m_ChatSessionMemberLeft != null) { OnChatSessionMemberLeft(new ChatSessionMemberLeftEventArgs(msg.SessionID, msg.Updates[i].AgentID)); } if (msg.Updates[i].AgentID == Client.Self.AgentID) { OnGroupChatLeft(new GroupChatLeftEventArgs(msg.SessionID)); } } } // handle updates ChatSessionMember update_member = GroupChatSessions.Dictionary[msg.SessionID].Find(delegate(ChatSessionMember m) { return m.AvatarKey == msg.Updates[i].AgentID; }); update_member.MuteText = msg.Updates[i].MuteText; update_member.MuteVoice = msg.Updates[i].MuteVoice; update_member.CanVoiceChat = msg.Updates[i].CanVoiceChat; update_member.IsModerator = msg.Updates[i].IsModerator; // replace existing member record lock (GroupChatSessions.Dictionary) { int found = GroupChatSessions.Dictionary[msg.SessionID].FindIndex(delegate(ChatSessionMember m) { return m.AvatarKey == msg.Updates[i].AgentID; }); if (found >= 0) GroupChatSessions.Dictionary[msg.SessionID][found] = update_member; } } } /// /// Handle a group chat Invitation /// /// Caps Key /// IMessage object containing decoded data from OSD /// Originating Simulator private void ChatterBoxInvitationEventHandler(string capsKey, IMessage message, Simulator simulator) { if (m_InstantMessage != null) { ChatterBoxInvitationMessage msg = (ChatterBoxInvitationMessage)message; InstantMessage im = new InstantMessage(); im.FromAgentID = msg.FromAgentID; im.FromAgentName = msg.FromAgentName; im.ToAgentID = msg.ToAgentID; im.ParentEstateID = (uint)msg.ParentEstateID; im.RegionID = msg.RegionID; im.Position = msg.Position; im.Dialog = msg.Dialog; im.GroupIM = msg.GroupIM; im.IMSessionID = msg.IMSessionID; im.Timestamp = msg.Timestamp; im.Message = msg.Message; im.Offline = msg.Offline; im.BinaryBucket = msg.BinaryBucket; OnInstantMessage(new InstantMessageEventArgs(im, simulator)); } } /// /// Moderate a chat session /// /// the of the session to moderate, for group chats this will be the groups UUID /// the of the avatar to moderate /// Either "voice" to moderate users voice, or "text" to moderate users text session /// true to moderate (silence user), false to allow avatar to speak public void ModerateChatSessions(UUID sessionID, UUID memberID, string key, bool moderate) { if (Client.Network.CurrentSim == null || Client.Network.CurrentSim.Caps == null) throw new Exception("ChatSessionRequest capability is not currently available"); Uri url = Client.Network.CurrentSim.Caps.CapabilityURI("ChatSessionRequest"); if (url != null) { ChatSessionRequestMuteUpdate req = new ChatSessionRequestMuteUpdate(); req.RequestKey = key; req.RequestValue = moderate; req.SessionID = sessionID; req.AgentID = memberID; CapsClient request = new CapsClient(url); request.BeginGetResponse(req.Serialize(), OSDFormat.Xml, Client.Settings.CAPS_TIMEOUT); } else { throw new Exception("ChatSessionRequest capability is not currently available"); } } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void AlertMessageHandler(object sender, PacketReceivedEventArgs e) { if (m_AlertMessage != null) { Packet packet = e.Packet; AlertMessagePacket alert = (AlertMessagePacket)packet; OnAlertMessage(new AlertMessageEventArgs(Utils.BytesToString(alert.AlertData.Message))); } } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void CameraConstraintHandler(object sender, PacketReceivedEventArgs e) { if (m_CameraConstraint != null) { Packet packet = e.Packet; CameraConstraintPacket camera = (CameraConstraintPacket)packet; OnCameraConstraint(new CameraConstraintEventArgs(camera.CameraCollidePlane.Plane)); } } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void ScriptSensorReplyHandler(object sender, PacketReceivedEventArgs e) { if (m_ScriptSensorReply != null) { Packet packet = e.Packet; ScriptSensorReplyPacket reply = (ScriptSensorReplyPacket)packet; for (int i = 0; i < reply.SensedData.Length; i++) { ScriptSensorReplyPacket.SensedDataBlock block = reply.SensedData[i]; ScriptSensorReplyPacket.RequesterBlock requestor = reply.Requester; OnScriptSensorReply(new ScriptSensorReplyEventArgs(requestor.SourceID, block.GroupID, Utils.BytesToString(block.Name), block.ObjectID, block.OwnerID, block.Position, block.Range, block.Rotation, (ScriptSensorTypeFlags)block.Type, block.Velocity)); } } } /// Process an incoming packet and raise the appropriate events /// The sender /// The EventArgs object containing the packet data protected void AvatarSitResponseHandler(object sender, PacketReceivedEventArgs e) { if (m_AvatarSitResponse != null) { Packet packet = e.Packet; AvatarSitResponsePacket sit = (AvatarSitResponsePacket)packet; OnAvatarSitResponse(new AvatarSitResponseEventArgs(sit.SitObject.ID, sit.SitTransform.AutoPilot, sit.SitTransform.CameraAtOffset, sit.SitTransform.CameraEyeOffset, sit.SitTransform.ForceMouselook, sit.SitTransform.SitPosition, sit.SitTransform.SitRotation)); } } #endregion Packet Handlers } #region Event Argument Classes /// /// /// public class ChatEventArgs : EventArgs { private readonly Simulator m_Simulator; private readonly string m_Message; private readonly ChatAudibleLevel m_AudibleLevel; private readonly ChatType m_Type; private readonly ChatSourceType m_SourceType; private readonly string m_FromName; private readonly UUID m_SourceID; private readonly UUID m_OwnerID; private readonly Vector3 m_Position; /// Get the simulator sending the message public Simulator Simulator { get { return m_Simulator; } } /// Get the message sent public string Message { get { return m_Message; } } /// Get the audible level of the message public ChatAudibleLevel AudibleLevel { get { return m_AudibleLevel; } } /// Get the type of message sent: whisper, shout, etc public ChatType Type { get { return m_Type; } } /// Get the source type of the message sender public ChatSourceType SourceType { get { return m_SourceType; } } /// Get the name of the agent or object sending the message public string FromName { get { return m_FromName; } } /// Get the ID of the agent or object sending the message public UUID SourceID { get { return m_SourceID; } } /// Get the ID of the object owner, or the agent ID sending the message public UUID OwnerID { get { return m_OwnerID; } } /// Get the position of the agent or object sending the message public Vector3 Position { get { return m_Position; } } /// /// Construct a new instance of the ChatEventArgs object /// /// The message sent /// The audible level of the message /// The type of message sent: whisper, shout, etc /// The source type of the message sender /// The name of the agent or object sending the message /// The ID of the agent or object sending the message /// The ID of the object owner, or the agent ID sending the message /// The position of the agent or object sending the message public ChatEventArgs(Simulator simulator, string message, ChatAudibleLevel audible, ChatType type, ChatSourceType sourceType, string fromName, UUID sourceId, UUID ownerid, Vector3 position) { this.m_Simulator = simulator; this.m_Message = message; this.m_AudibleLevel = audible; this.m_Type = type; this.m_SourceType = sourceType; this.m_FromName = fromName; this.m_SourceID = sourceId; this.m_Position = position; this.m_OwnerID = ownerid; } } /// Contains the data sent when a primitive opens a dialog with this agent public class ScriptDialogEventArgs : EventArgs { private readonly string m_Message; private readonly string m_ObjectName; private readonly UUID m_ImageID; private readonly UUID m_ObjectID; private readonly string m_FirstName; private readonly string m_LastName; private readonly int m_Channel; private readonly List m_ButtonLabels; /// Get the dialog message public string Message { get { return m_Message; } } /// Get the name of the object that sent the dialog request public string ObjectName { get { return m_ObjectName; } } /// Get the ID of the image to be displayed public UUID ImageID { get { return m_ImageID; } } /// Get the ID of the primitive sending the dialog public UUID ObjectID { get { return m_ObjectID; } } /// Get the first name of the senders owner public string FirstName { get { return m_FirstName; } } /// Get the last name of the senders owner public string LastName { get { return m_LastName; } } /// Get the communication channel the dialog was sent on, responses /// should also send responses on this same channel public int Channel { get { return m_Channel; } } /// Get the string labels containing the options presented in this dialog public List ButtonLabels { get { return m_ButtonLabels; } } /// /// Construct a new instance of the ScriptDialogEventArgs /// /// The dialog message /// The name of the object that sent the dialog request /// The ID of the image to be displayed /// The ID of the primitive sending the dialog /// The first name of the senders owner /// The last name of the senders owner /// The communication channel the dialog was sent on /// The string labels containing the options presented in this dialog public ScriptDialogEventArgs(string message, string objectName, UUID imageID, UUID objectID, string firstName, string lastName, int chatChannel, List buttons) { this.m_Message = message; this.m_ObjectName = objectName; this.m_ImageID = imageID; this.m_ObjectID = objectID; this.m_FirstName = firstName; this.m_LastName = lastName; this.m_Channel = chatChannel; this.m_ButtonLabels = buttons; } } /// Contains the data sent when a primitive requests debit or other permissions /// requesting a YES or NO answer public class ScriptQuestionEventArgs : EventArgs { private readonly Simulator m_Simulator; private readonly UUID m_TaskID; private readonly UUID m_ItemID; private readonly string m_ObjectName; private readonly string m_ObjectOwnerName; private readonly ScriptPermission m_Questions; /// Get the simulator containing the object sending the request public Simulator Simulator { get { return m_Simulator; } } /// Get the ID of the script making the request public UUID TaskID { get { return m_TaskID; } } /// Get the ID of the primitive containing the script making the request public UUID ItemID { get { return m_ItemID; } } /// Get the name of the primitive making the request public string ObjectName { get { return m_ObjectName; } } /// Get the name of the owner of the object making the request public string ObjectOwnerName { get { return m_ObjectOwnerName; } } /// Get the permissions being requested public ScriptPermission Questions { get { return m_Questions; } } /// /// Construct a new instance of the ScriptQuestionEventArgs /// /// The simulator containing the object sending the request /// The ID of the script making the request /// The ID of the primitive containing the script making the request /// The name of the primitive making the request /// The name of the owner of the object making the request /// The permissions being requested public ScriptQuestionEventArgs(Simulator simulator, UUID taskID, UUID itemID, string objectName, string objectOwner, ScriptPermission questions) { this.m_Simulator = simulator; this.m_TaskID = taskID; this.m_ItemID = itemID; this.m_ObjectName = objectName; this.m_ObjectOwnerName = objectOwner; this.m_Questions = questions; } } /// Contains the data sent when a primitive sends a request /// to an agent to open the specified URL public class LoadUrlEventArgs : EventArgs { private readonly string m_ObjectName; private readonly UUID m_ObjectID; private readonly UUID m_OwnerID; private readonly bool m_OwnerIsGroup; private readonly string m_Message; private readonly string m_URL; /// Get the name of the object sending the request public string ObjectName { get { return m_ObjectName; } } /// Get the ID of the object sending the request public UUID ObjectID { get { return m_ObjectID; } } /// Get the ID of the owner of the object sending the request public UUID OwnerID { get { return m_OwnerID; } } /// True if the object is owned by a group public bool OwnerIsGroup { get { return m_OwnerIsGroup; } } /// Get the message sent with the request public string Message { get { return m_Message; } } /// Get the URL the object sent public string URL { get { return m_URL; } } /// /// Construct a new instance of the LoadUrlEventArgs /// /// The name of the object sending the request /// The ID of the object sending the request /// The ID of the owner of the object sending the request /// True if the object is owned by a group /// The message sent with the request /// The URL the object sent public LoadUrlEventArgs(string objectName, UUID objectID, UUID ownerID, bool ownerIsGroup, string message, string URL) { this.m_ObjectName = objectName; this.m_ObjectID = objectID; this.m_OwnerID = ownerID; this.m_OwnerIsGroup = ownerIsGroup; this.m_Message = message; this.m_URL = URL; } } /// The date received from an ImprovedInstantMessage public class InstantMessageEventArgs : EventArgs { private readonly InstantMessage m_IM; private readonly Simulator m_Simulator; /// Get the InstantMessage object public InstantMessage IM { get { return m_IM; } } /// Get the simulator where the InstantMessage origniated public Simulator Simulator { get { return m_Simulator; } } /// /// Construct a new instance of the InstantMessageEventArgs object /// /// the InstantMessage object /// the simulator where the InstantMessage origniated public InstantMessageEventArgs(InstantMessage im, Simulator simulator) { this.m_IM = im; this.m_Simulator = simulator; } } /// Contains the currency balance public class BalanceEventArgs : EventArgs { private readonly int m_Balance; /// /// Get the currenct balance /// public int Balance { get { return m_Balance; } } /// /// Construct a new BalanceEventArgs object /// /// The currenct balance public BalanceEventArgs(int balance) { this.m_Balance = balance; } } /// Contains the transaction summary when an item is purchased, /// money is given, or land is purchased public class MoneyBalanceReplyEventArgs : EventArgs { private readonly UUID m_TransactionID; private readonly bool m_Success; private readonly int m_Balance; private readonly int m_MetersCredit; private readonly int m_MetersCommitted; private readonly string m_Description; /// Get the ID of the transaction public UUID TransactionID { get { return m_TransactionID; } } /// True of the transaction was successful public bool Success { get { return m_Success; } } /// Get the remaining currency balance public int Balance { get { return m_Balance; } } /// Get the meters credited public int MetersCredit { get { return m_MetersCredit; } } /// Get the meters comitted public int MetersCommitted { get { return m_MetersCommitted; } } /// Get the description of the transaction public string Description { get { return m_Description; } } /// /// Construct a new instance of the MoneyBalanceReplyEventArgs object /// /// The ID of the transaction /// True of the transaction was successful /// The current currency balance /// The meters credited /// The meters comitted /// A brief description of the transaction public MoneyBalanceReplyEventArgs(UUID transactionID, bool transactionSuccess, int balance, int metersCredit, int metersCommitted, string description) { this.m_TransactionID = transactionID; this.m_Success = transactionSuccess; this.m_Balance = balance; this.m_MetersCredit = metersCredit; this.m_MetersCommitted = metersCommitted; this.m_Description = description; } } // string message, TeleportStatus status, TeleportFlags flags public class TeleportEventArgs : EventArgs { private readonly string m_Message; private readonly TeleportStatus m_Status; private readonly TeleportFlags m_Flags; public string Message { get { return m_Message; } } public TeleportStatus Status { get { return m_Status; } } public TeleportFlags Flags { get { return m_Flags; } } public TeleportEventArgs(string message, TeleportStatus status, TeleportFlags flags) { this.m_Message = message; this.m_Status = status; this.m_Flags = flags; } } /// Data sent from the simulator containing information about your agent and active group information public class AgentDataReplyEventArgs : EventArgs { private readonly string m_FirstName; private readonly string m_LastName; private readonly UUID m_ActiveGroupID; private readonly string m_GroupTitle; private readonly GroupPowers m_GroupPowers; private readonly string m_GroupName; /// Get the agents first name public string FirstName { get { return m_FirstName; } } /// Get the agents last name public string LastName { get { return m_LastName; } } /// Get the active group ID of your agent public UUID ActiveGroupID { get { return m_ActiveGroupID; } } /// Get the active groups title of your agent public string GroupTitle { get { return m_GroupTitle; } } /// Get the combined group powers of your agent public GroupPowers GroupPowers { get { return m_GroupPowers; } } /// Get the active group name of your agent public string GroupName { get { return m_GroupName; } } /// /// Construct a new instance of the AgentDataReplyEventArgs object /// /// The agents first name /// The agents last name /// The agents active group ID /// The group title of the agents active group /// The combined group powers the agent has in the active group /// The name of the group the agent has currently active public AgentDataReplyEventArgs(string firstName, string lastName, UUID activeGroupID, string groupTitle, GroupPowers groupPowers, string groupName) { this.m_FirstName = firstName; this.m_LastName = lastName; this.m_ActiveGroupID = activeGroupID; this.m_GroupTitle = groupTitle; this.m_GroupPowers = groupPowers; this.m_GroupName = groupName; } } /// Data sent by the simulator to indicate the active/changed animations /// applied to your agent public class AnimationsChangedEventArgs : EventArgs { private readonly InternalDictionary m_Animations; /// Get the dictionary that contains the changed animations public InternalDictionary Animations { get { return m_Animations; } } /// /// Construct a new instance of the AnimationsChangedEventArgs class /// /// The dictionary that contains the changed animations public AnimationsChangedEventArgs(InternalDictionary agentAnimations) { this.m_Animations = agentAnimations; } } /// /// Data sent from a simulator indicating a collision with your agent /// public class MeanCollisionEventArgs : EventArgs { private readonly MeanCollisionType m_Type; private readonly UUID m_Aggressor; private readonly UUID m_Victim; private readonly float m_Magnitude; private readonly DateTime m_Time; /// Get the Type of collision public MeanCollisionType Type { get { return m_Type; } } /// Get the ID of the agent or object that collided with your agent public UUID Aggressor { get { return m_Aggressor; } } /// Get the ID of the agent that was attacked public UUID Victim { get { return m_Victim; } } /// A value indicating the strength of the collision public float Magnitude { get { return m_Magnitude; } } /// Get the time the collision occurred public DateTime Time { get { return m_Time; } } /// /// Construct a new instance of the MeanCollisionEventArgs class /// /// The type of collision that occurred /// The ID of the agent or object that perpetrated the agression /// The ID of the Victim /// The strength of the collision /// The Time the collision occurred public MeanCollisionEventArgs(MeanCollisionType type, UUID perp, UUID victim, float magnitude, DateTime time) { this.m_Type = type; this.m_Aggressor = perp; this.m_Victim = victim; this.m_Magnitude = magnitude; this.m_Time = time; } } /// Data sent to your agent when it crosses region boundaries public class RegionCrossedEventArgs : EventArgs { private readonly Simulator m_OldSimulator; private readonly Simulator m_NewSimulator; /// Get the simulator your agent just left public Simulator OldSimulator { get { return m_OldSimulator; } } /// Get the simulator your agent is now in public Simulator NewSimulator { get { return m_NewSimulator; } } /// /// Construct a new instance of the RegionCrossedEventArgs class /// /// The simulator your agent just left /// The simulator your agent is now in public RegionCrossedEventArgs(Simulator oldSim, Simulator newSim) { this.m_OldSimulator = oldSim; this.m_NewSimulator = newSim; } } /// Data sent from the simulator when your agent joins a group chat session public class GroupChatJoinedEventArgs : EventArgs { private readonly UUID m_SessionID; private readonly string m_SessionName; private readonly UUID m_TmpSessionID; private readonly bool m_Success; /// Get the ID of the group chat session public UUID SessionID { get { return m_SessionID; } } /// Get the name of the session public string SessionName { get { return m_SessionName; } } /// Get the temporary session ID used for establishing new sessions public UUID TmpSessionID { get { return m_TmpSessionID; } } /// True if your agent successfully joined the session public bool Success { get { return m_Success; } } /// /// Construct a new instance of the GroupChatJoinedEventArgs class /// /// The ID of the session /// The name of the session /// A temporary session id used for establishing new sessions /// True of your agent successfully joined the session public GroupChatJoinedEventArgs(UUID groupChatSessionID, string sessionName, UUID tmpSessionID, bool success) { this.m_SessionID = groupChatSessionID; this.m_SessionName = sessionName; this.m_TmpSessionID = tmpSessionID; this.m_Success = success; } } /// The session information when your agent exits a group chat session public class GroupChatLeftEventArgs : EventArgs { private readonly UUID m_SessionID; /// Get the ID of the session your agent left public UUID SessionID { get { return m_SessionID; } } /// /// Construct a new instance of the GroupChatLeftEventArgs class /// /// The ID of the session your agent left public GroupChatLeftEventArgs(UUID chatSessionID) { this.m_SessionID = chatSessionID; } } /// Data sent by the simulator containing urgent messages public class AlertMessageEventArgs : EventArgs { private readonly string m_Message; /// Get the alert message public string Message { get { return m_Message; } } /// /// Construct a new instance of the AlertMessageEventArgs class /// /// The alert message public AlertMessageEventArgs(string message) { this.m_Message = message; } } /// Data sent by a script requesting to take or release specified controls to your agent public class ScriptControlEventArgs : EventArgs { private readonly ScriptControlChange m_Controls; private readonly bool m_Pass; private readonly bool m_Take; /// Get the controls the script is attempting to take or release to the agent public ScriptControlChange Controls { get { return m_Controls; } } /// True if the script is passing controls back to the agent public bool Pass { get { return m_Pass; } } /// True if the script is requesting controls be released to the script public bool Take { get { return m_Take; } } /// /// Construct a new instance of the ScriptControlEventArgs class /// /// The controls the script is attempting to take or release to the agent /// True if the script is passing controls back to the agent /// True if the script is requesting controls be released to the script public ScriptControlEventArgs(ScriptControlChange controls, bool pass, bool take) { m_Controls = controls; m_Pass = pass; m_Take = take; } } /// /// Data sent from the simulator to an agent to indicate its view limits /// public class CameraConstraintEventArgs : EventArgs { private readonly Vector4 m_CollidePlane; /// Get the collision plane public Vector4 CollidePlane { get { return m_CollidePlane; } } /// /// Construct a new instance of the CameraConstraintEventArgs class /// /// The collision plane public CameraConstraintEventArgs(Vector4 collidePlane) { m_CollidePlane = collidePlane; } } /// /// Data containing script sensor requests which allow an agent to know the specific details /// of a primitive sending script sensor requests /// public class ScriptSensorReplyEventArgs : EventArgs { private readonly UUID m_RequestorID; private readonly UUID m_GroupID; private readonly string m_Name; private readonly UUID m_ObjectID; private readonly UUID m_OwnerID; private readonly Vector3 m_Position; private readonly float m_Range; private readonly Quaternion m_Rotation; private readonly ScriptSensorTypeFlags m_Type; private readonly Vector3 m_Velocity; /// Get the ID of the primitive sending the sensor public UUID RequestorID { get { return m_RequestorID; } } /// Get the ID of the group associated with the primitive public UUID GroupID { get { return m_GroupID; } } /// Get the name of the primitive sending the sensor public string Name { get { return m_Name; } } /// Get the ID of the primitive sending the sensor public UUID ObjectID { get { return m_ObjectID; } } /// Get the ID of the owner of the primitive sending the sensor public UUID OwnerID { get { return m_OwnerID; } } /// Get the position of the primitive sending the sensor public Vector3 Position { get { return m_Position; } } /// Get the range the primitive specified to scan public float Range { get { return m_Range; } } /// Get the rotation of the primitive sending the sensor public Quaternion Rotation { get { return m_Rotation; } } /// Get the type of sensor the primitive sent public ScriptSensorTypeFlags Type { get { return m_Type; } } /// Get the velocity of the primitive sending the sensor public Vector3 Velocity { get { return m_Velocity; } } /// /// Construct a new instance of the ScriptSensorReplyEventArgs /// /// The ID of the primitive sending the sensor /// The ID of the group associated with the primitive /// The name of the primitive sending the sensor /// The ID of the primitive sending the sensor /// The ID of the owner of the primitive sending the sensor /// The position of the primitive sending the sensor /// The range the primitive specified to scan /// The rotation of the primitive sending the sensor /// The type of sensor the primitive sent /// The velocity of the primitive sending the sensor public ScriptSensorReplyEventArgs(UUID requestorID, UUID groupID, string name, UUID objectID, UUID ownerID, Vector3 position, float range, Quaternion rotation, ScriptSensorTypeFlags type, Vector3 velocity) { this.m_RequestorID = requestorID; this.m_GroupID = groupID; this.m_Name = name; this.m_ObjectID = objectID; this.m_OwnerID = ownerID; this.m_Position = position; this.m_Range = range; this.m_Rotation = rotation; this.m_Type = type; this.m_Velocity = velocity; } } /// Contains the response data returned from the simulator in response to a public class AvatarSitResponseEventArgs : EventArgs { private readonly UUID m_ObjectID; private readonly bool m_Autopilot; private readonly Vector3 m_CameraAtOffset; private readonly Vector3 m_CameraEyeOffset; private readonly bool m_ForceMouselook; private readonly Vector3 m_SitPosition; private readonly Quaternion m_SitRotation; /// Get the ID of the primitive the agent will be sitting on public UUID ObjectID { get { return m_ObjectID; } } /// True if the simulator Autopilot functions were involved public bool Autopilot { get { return m_Autopilot; } } /// Get the camera offset of the agent when seated public Vector3 CameraAtOffset { get { return m_CameraAtOffset; } } /// Get the camera eye offset of the agent when seated public Vector3 CameraEyeOffset { get { return m_CameraEyeOffset; } } /// True of the agent will be in mouselook mode when seated public bool ForceMouselook { get { return m_ForceMouselook; } } /// Get the position of the agent when seated public Vector3 SitPosition { get { return m_SitPosition; } } /// Get the rotation of the agent when seated public Quaternion SitRotation { get { return m_SitRotation; } } /// Construct a new instance of the AvatarSitResponseEventArgs object public AvatarSitResponseEventArgs(UUID objectID, bool autoPilot, Vector3 cameraAtOffset, Vector3 cameraEyeOffset, bool forceMouselook, Vector3 sitPosition, Quaternion sitRotation) { this.m_ObjectID = objectID; this.m_Autopilot = autoPilot; this.m_CameraAtOffset = cameraAtOffset; this.m_CameraEyeOffset = cameraEyeOffset; this.m_ForceMouselook = forceMouselook; this.m_SitPosition = sitPosition; this.m_SitRotation = sitRotation; } } /// Data sent when an agent joins a chat session your agent is currently participating in public class ChatSessionMemberAddedEventArgs : EventArgs { private readonly UUID m_SessionID; private readonly UUID m_AgentID; /// Get the ID of the chat session public UUID SessionID { get { return m_SessionID; } } /// Get the ID of the agent that joined public UUID AgentID { get { return m_AgentID; } } /// /// Construct a new instance of the ChatSessionMemberAddedEventArgs object /// /// The ID of the chat session /// The ID of the agent joining public ChatSessionMemberAddedEventArgs(UUID sessionID, UUID agentID) { this.m_SessionID = sessionID; this.m_AgentID = agentID; } } /// Data sent when an agent exits a chat session your agent is currently participating in public class ChatSessionMemberLeftEventArgs : EventArgs { private readonly UUID m_SessionID; private readonly UUID m_AgentID; /// Get the ID of the chat session public UUID SessionID { get { return m_SessionID; } } /// Get the ID of the agent that left public UUID AgentID { get { return m_AgentID; } } /// /// Construct a new instance of the ChatSessionMemberLeftEventArgs object /// /// The ID of the chat session /// The ID of the Agent that left public ChatSessionMemberLeftEventArgs(UUID sessionID, UUID agentID) { this.m_SessionID = sessionID; this.m_AgentID = agentID; } } #endregion }