void Self_OnChat(string message, byte audible, byte type, byte sourcetype, string fromName, LLUUID id, LLUUID ownerid, LLVector3 position)
		{
			if (message.Length > 0)
			{
				_speechSynthesizer.SpeakAsync(message);
			}
		}
 void Self_OnChat(string message, byte audible, byte type, byte sourcetype, string fromName, LLUUID id, LLUUID ownerid, LLVector3 position)
 {
     if (message.Length > 0 && TestClient.Master == fromName)
     {
         TestClient.Self.Chat(message, 0, MainAvatar.ChatType.Normal);
     }
 }
Exemple #3
0
        /// <summary>
        /// Update client's Position and LookAt from incoming packet
        /// </summary>
        /// <param name="packet">Incoming AgentMovementCompletePacket</param>
        /// <param name="simulator">[UNUSED]</param>
        private void MovementCompleteHandler(Packet packet, Simulator simulator)
        {
            AgentMovementCompletePacket movement = (AgentMovementCompletePacket)packet;

            this.Position = movement.Data.Position;
            this.LookAt   = movement.Data.LookAt;
        }
Exemple #4
0
        public override string Execute(string[] args, LLUUID fromAgentID)
		{
		    if (args.Length == 1)
		    {
		        try
		        {
		            string treeName = args[0].Trim(new char[] { ' ' });
		            ObjectManager.Tree tree = (ObjectManager.Tree)Enum.Parse(typeof(ObjectManager.Tree), treeName);

		            LLVector3 treePosition = new LLVector3(Client.Self.Position.X, Client.Self.Position.Y,
		                Client.Self.Position.Z);
		            treePosition.Z += 3.0f;

		            Client.Objects.AddTree(Client.Network.CurrentSim, new LLVector3(0.5f, 0.5f, 0.5f),
		                LLQuaternion.Identity, treePosition, tree, Client.GroupID, false);

		            return "Attempted to rez a " + treeName + " tree";
		        }
		        catch (Exception)
		        {
		            return "Type !tree for usage";
		        }
		    }

		    string usage = "Usage: !tree [";
		    foreach (string value in Enum.GetNames(typeof(ObjectManager.Tree)))
		    {
		        usage += value + ",";
		    }
		    usage = usage.TrimEnd(new char[] { ',' });
		    usage += "]";
		    return usage;
		}
 /// <summary>
 /// Aims at the specified position, enters mouselook, presses and
 /// releases the left mouse button, and leaves mouselook
 /// </summary>
 /// <param name="target">Target to shoot at</param>
 /// <returns></returns>
 public static bool Shoot(SecondLife client, LLVector3 target)
 {
     if (client.Self.Movement.TurnToward(target))
         return Shoot(client);
     else
         return false;
 }
Exemple #6
0
            /// <summary>
            /// Send new AgentUpdate packet to update our current camera
            /// position and rotation
            /// </summary>
            /// <param name="reliable">Whether to require server acknowledgement
            /// of this packet</param>
            /// <param name="simulator">Simulator to send the update to</param>
            public void SendUpdate(bool reliable, Simulator simulator)
            {
                LLVector3 origin = Camera.Position;
                LLVector3 xAxis  = Camera.LeftAxis;
                LLVector3 yAxis  = Camera.AtAxis;
                LLVector3 zAxis  = Camera.UpAxis;

                // Attempted to sort these in a rough order of how often they might change
                if (agentControls == 0 &&
                    yAxis == LastCameraYAxis &&
                    origin == LastCameraCenter &&
                    State == lastState &&
                    HeadRotation == LastHeadRotation &&
                    BodyRotation == LastBodyRotation &&
                    xAxis == LastCameraXAxis &&
                    Camera.Far == LastFar &&
                    zAxis == LastCameraZAxis)
                {
                    ++duplicateCount;
                }
                else
                {
                    duplicateCount = 0;
                }

                if (Client.Settings.CONTINUOUS_AGENT_UPDATES || duplicateCount < 10)
                {
                    // Store the current state to do duplicate checking in the future
                    LastHeadRotation = HeadRotation;
                    LastBodyRotation = BodyRotation;
                    LastCameraYAxis  = yAxis;
                    LastCameraCenter = origin;
                    LastCameraXAxis  = xAxis;
                    LastCameraZAxis  = zAxis;
                    LastFar          = Camera.Far;
                    lastState        = State;

                    // Build the AgentUpdate packet and send it
                    AgentUpdatePacket update = new AgentUpdatePacket();
                    update.Header.Reliable = reliable;

                    update.AgentData.AgentID        = Client.Self.AgentID;
                    update.AgentData.SessionID      = Client.Self.SessionID;
                    update.AgentData.HeadRotation   = HeadRotation;
                    update.AgentData.BodyRotation   = BodyRotation;
                    update.AgentData.CameraAtAxis   = yAxis;
                    update.AgentData.CameraCenter   = origin;
                    update.AgentData.CameraLeftAxis = xAxis;
                    update.AgentData.CameraUpAxis   = zAxis;
                    update.AgentData.Far            = Camera.Far;
                    update.AgentData.State          = (byte)State;
                    update.AgentData.ControlFlags   = agentControls;
                    update.AgentData.Flags          = (byte)Flags;

                    Client.Network.SendPacket(update, simulator);

                    ResetControlFlags();
                }
            }
 public UserProfile()
 {
     Circuits = new Dictionary<LLUUID, uint>();
     Inventory = new AgentInventory();
     homeregionhandle = Helpers.UIntsToLong((997 * 256), (996 * 256));
     homepos = new LLVector3();
     homelookat = new LLVector3();
 }
Exemple #8
0
 protected void Orthonormalize()
 {
     // Make sure the axis are orthagonal and normalized
     xAxis  = LLVector3.Norm(xAxis);
     yAxis -= xAxis * (xAxis * yAxis);
     yAxis  = LLVector3.Norm(yAxis);
     zAxis  = LLVector3.Cross(xAxis, yAxis);
 }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of type SecondLife to associate with this GridManager instance</param>
        public GridManager(SecondLife client)
        {
            Client = client;
            SunDirection = LLVector3.Zero;

            Client.Network.RegisterCallback(PacketType.MapBlockReply, new NetworkManager.PacketCallback(MapBlockReplyHandler));
            Client.Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, new NetworkManager.PacketCallback(TimeMessageHandler));
        }
Exemple #10
0
        /// <summary>
        /// Calculates the distance between two vectors
        /// </summary>
        public static float VecDist(LLVector3 pointA, LLVector3 pointB)
        {
            float xd = pointB.X - pointA.X;
            float yd = pointB.Y - pointA.Y;
            float zd = pointB.Z - pointA.Z;

            return((float)Math.Sqrt(xd * xd + yd * yd + zd * zd));
        }
		void Self_OnChat(string message, MainAvatar.ChatAudibleLevel audible, MainAvatar.ChatType type, 
            MainAvatar.ChatSourceType sourcetype, string fromName, LLUUID id, LLUUID ownerid, LLVector3 position)
		{
			if (message.Length > 0 && Client.MasterKey == id)
			{
			    Client.Self.Chat(message, 0, MainAvatar.ChatType.Normal);
			}
		}
Exemple #12
0
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of type SecondLife to associate with this GridManager instance</param>
        public GridManager(SecondLife client)
        {
            Client       = client;
            SunDirection = LLVector3.Zero;

            Client.Network.RegisterCallback(PacketType.MapBlockReply, new NetworkManager.PacketCallback(MapBlockReplyHandler));
            Client.Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, new NetworkManager.PacketCallback(TimeMessageHandler));
        }
Exemple #13
0
        public void LookAt(LLVector3 origin, LLVector3 target, LLVector3 upDirection)
        {
            this.origin = origin;
            LLVector3 at = new LLVector3(target - origin);

            at = LLVector3.Norm(at);

            LookDirection(at, upDirection);
        }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of type SecondLife to associate with this GridManager instance</param>
        public GridManager(SecondLife client)
        {
            Client       = client;
            Regions      = new Dictionary <string, GridRegion>();
            SunDirection = new LLVector3();

            Client.Network.RegisterCallback(PacketType.MapBlockReply, new PacketCallback(MapBlockReplyHandler));
            Client.Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, new PacketCallback(TimeMessageHandler));
        }
        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="client">Instance of type SecondLife to associate with this GridManager instance</param>
        public GridManager(SecondLife client)
        {
            Client = client;
            Regions = new Dictionary<string, GridRegion>();
            SunDirection = new LLVector3();

            Client.Network.RegisterCallback(PacketType.MapBlockReply, new PacketCallback(MapBlockReplyHandler));
            Client.Network.RegisterCallback(PacketType.SimulatorViewerTimeMessage, new PacketCallback(TimeMessageHandler));
        }
Exemple #16
0
        public CoordinateFrame(LLVector3 origin, LLVector3 direction)
        {
            this.origin = origin;
            LookDirection(direction);

            if (!IsFinite())
            {
                throw new ArgumentException("Non-finite in CoordinateFrame constructor");
            }
        }
Exemple #17
0
                public void SetPositionOrientation(LLVector3 position, float roll, float pitch, float yaw)
                {
                    Frame.Origin = position;

                    Frame.ResetAxes();

                    Frame.Roll(roll);
                    Frame.Pitch(pitch);
                    Frame.Yaw(yaw);
                }
Exemple #18
0
 /// <summary>
 /// Creates a new Entity (should not occur on it's own)
 /// </summary>
 public Entity()
 {
     uuid = new libsecondlife.LLUUID();
     localid = 0;
     m_pos = new LLVector3();
     velocity = new LLVector3();
     rotation = new Quaternion();
     m_name = "(basic entity)";
     children = new List<Entity>();
 }
Exemple #19
0
        /// <summary>
        /// Get sim time from the appropriate packet
        /// </summary>
        /// <param name="packet">Incoming SimulatorViewerTimeMessagePacket from SL</param>
        /// <param name="simulator">Unused</param>
        private void TimeMessageHandler(Packet packet, Simulator simulator)
        {
            SimulatorViewerTimeMessagePacket time = (SimulatorViewerTimeMessagePacket)packet;

            sunPhase       = time.TimeInfo.SunPhase;
            sunDirection   = time.TimeInfo.SunDirection;
            sunAngVelocity = time.TimeInfo.SunAngVelocity;

            // TODO: Does anyone have a use for the time stuff?
        }
Exemple #20
0
 /// <summary>
 /// Aims at the specified position, enters mouselook, presses and
 /// releases the left mouse button, and leaves mouselook
 /// </summary>
 /// <param name="target">Target to shoot at</param>
 /// <returns></returns>
 public bool Shoot(LLVector3 target)
 {
     if (TurnToward(target))
     {
         return(Shoot());
     }
     else
     {
         return(false);
     }
 }
Exemple #21
0
 public ChatEventArgs(string message, ChatAudibleLevel audible, ChatType type, ChatSourceType sourceType, string fromName, LLUUID id, LLUUID ownerid, LLVector3 position)
 {
     this.message = message;
     this.audible = audible;
     this.type = type;
     this.sourceType = sourceType;
     this.fromName = fromName;
     this.id = id;
     this.ownerid = ownerid;
     this.position = position;
 }
Exemple #22
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="o"></param>
        /// <returns></returns>
        public override bool Equals(object o)
        {
            if (!(o is LLVector3))
            {
                return(false);
            }

            LLVector3 vector = (LLVector3)o;

            return(X == vector.X && Y == vector.Y && Z == vector.Z);
        }
Exemple #23
0
        public CoordinateFrame(LLVector3 origin)
        {
            this.origin = origin;
            xAxis       = X_AXIS;
            yAxis       = Y_AXIS;
            zAxis       = Z_AXIS;

            if (!this.origin.IsFinite())
            {
                throw new ArgumentException("Non-finite in CoordinateFrame constructor");
            }
        }
Exemple #24
0
        public CoordinateFrame(LLVector3 origin, LLVector3 xAxis, LLVector3 yAxis, LLVector3 zAxis)
        {
            this.origin = origin;
            this.xAxis  = xAxis;
            this.yAxis  = yAxis;
            this.zAxis  = zAxis;

            if (!IsFinite())
            {
                throw new ArgumentException("Non-finite in CoordinateFrame constructor");
            }
        }
Exemple #25
0
        public CoordinateFrame(LLVector3 origin, LLMatrix3 rotation)
        {
            this.origin = origin;
            xAxis       = rotation[0];
            yAxis       = rotation[1];
            zAxis       = rotation[2];

            if (!IsFinite())
            {
                throw new ArgumentException("Non-finite in CoordinateFrame constructor");
            }
        }
Exemple #26
0
        private void FromBytes(byte[] data, int pos)
        {
            int i = pos;

            Softness = ((data[i] & 0x80) >> 6) | ((data[i + 1] & 0x80) >> 7);

            Tension = (data[i++] & 0x7F) / 10.0f;
            Drag    = (data[i++] & 0x7F) / 10.0f;
            Gravity = (data[i++] / 10.0f) - 10.0f;
            Wind    = data[i++] / 10.0f;
            Force   = new LLVector3(data, i);
        }
Exemple #27
0
        public void Rotate(LLMatrix3 m)
        {
            xAxis = LLVector3.Rot(xAxis, m);
            yAxis = LLVector3.Rot(yAxis, m);

            Orthonormalize();

            if (!IsFinite())
            {
                throw new Exception("Non-finite in CoordinateFrame.Rotate()");
            }
        }
Exemple #28
0
 private void init()
 {
     OwnerID      = new LLUUID();
     AABBMin      = new LLVector3();
     AABBMax      = new LLVector3();
     Bitmap       = new byte[512];
     MediaID      = new LLUUID();
     GroupID      = new LLUUID();
     AuthBuyerID  = new LLUUID();
     SnapshotID   = new LLUUID();
     UserLocation = new LLVector3();
     UserLookAt   = new LLVector3();
 }
Exemple #29
0
 private void init()
 {
     OwnerID      = LLUUID.Zero;
     AABBMin      = LLVector3.Zero;
     AABBMax      = LLVector3.Zero;
     Bitmap       = new byte[512];
     MediaID      = LLUUID.Zero;
     GroupID      = LLUUID.Zero;
     AuthBuyerID  = LLUUID.Zero;
     SnapshotID   = LLUUID.Zero;
     UserLocation = LLVector3.Zero;
     UserLookAt   = LLVector3.Zero;
 }
Exemple #30
0
        public CoordinateFrame(LLVector3 origin, LLQuaternion rotation)
        {
            LLMatrix3 m = new LLMatrix3(rotation);

            this.origin = origin;
            xAxis       = m[0];
            yAxis       = m[1];
            zAxis       = m[2];

            if (!IsFinite())
            {
                throw new ArgumentException("Non-finite in CoordinateFrame constructor");
            }
        }
Exemple #31
0
        public void Self_OnChat(string message, ChatAudibleLevel audible, ChatType type, 
            ChatSourceType sourcetype, string fromName, LLUUID id, LLUUID ownerid, LLVector3 position)
        {
            Console.WriteLine(fromName+":" + message);

            if (message.Length > 0 && message.ToLower().Contains(Client.Self.FirstName.ToLower()) && Client.Self.AgentID != id) {
                WebRequest request = WebRequest.Create("http://www.mr-technicl.com/slfutura.php?nick="+ fromName + "&message="+ message);
                WebResponse response = request.GetResponse();
                StreamReader input = new StreamReader(response.GetResponseStream());
                string say = input.ReadToEnd();
                input.Close();
                libsecondlife.Utilities.Realism.Chat(Client, say, ChatType.Normal, 25);
            }
        }
Exemple #32
0
        /// <summary>
        /// Plays a sound
        /// </summary>
        /// <param name="soundID">UUID of the sound to be played.</param>
        /// <param name="handle">handle id for the sim to be played in.</param>
        /// <param name="position">position for the sound to be played at. Normally the avatar.</param>
        /// <param name="gain">volume of the sound, from 0.0 to 1.0</param>
        public void SoundTrigger(LLUUID soundID, ulong handle, LLVector3 position, float gain)
        {
            SoundTriggerPacket soundtrigger = new SoundTriggerPacket();

            soundtrigger.SoundData          = new SoundTriggerPacket.SoundDataBlock();
            soundtrigger.SoundData.SoundID  = soundID;
            soundtrigger.SoundData.ObjectID = LLUUID.Zero;
            soundtrigger.SoundData.OwnerID  = LLUUID.Zero;
            soundtrigger.SoundData.ParentID = LLUUID.Zero;
            soundtrigger.SoundData.Handle   = handle;
            soundtrigger.SoundData.Position = position;
            soundtrigger.SoundData.Gain     = gain;
            Client.Network.SendPacket(soundtrigger);
        }
Exemple #33
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="prim"></param>
        /// <param name="position"></param>
        /// <param name="avatarPosition"></param>
        public void RezObject(PrimObject prim, LLVector3 position, LLVector3 rayStart,
                              LLUUID groupID)
        {
            ObjectAddPacket add = new ObjectAddPacket();

            add.AgentData.AgentID   = Client.Network.AgentID;
            add.AgentData.SessionID = Client.Network.SessionID;
            add.AgentData.GroupID   = groupID;
            // TODO: Why 2?
            add.ObjectData.AddFlags             = 2;
            add.ObjectData.BypassRaycast        = 1;
            add.ObjectData.Material             = (byte)prim.Material;
            add.ObjectData.PathBegin            = PrimObject.PathBeginByte(prim.PathBegin);
            add.ObjectData.PathCurve            = (byte)prim.PathCurve;
            add.ObjectData.PathEnd              = PrimObject.PathEndByte(prim.PathEnd);
            add.ObjectData.PathRadiusOffset     = PrimObject.PathRadiusOffsetByte(prim.PathRadiusOffset);
            add.ObjectData.PathRevolutions      = PrimObject.PathRevolutionsByte(prim.PathRevolutions);
            add.ObjectData.PathScaleX           = PrimObject.PathScaleByte(prim.PathScaleX);
            add.ObjectData.PathScaleY           = PrimObject.PathScaleByte(prim.PathScaleY);
            add.ObjectData.PathShearX           = PrimObject.PathShearByte(prim.PathShearX);
            add.ObjectData.PathShearY           = PrimObject.PathShearByte(prim.PathShearY);
            add.ObjectData.PathSkew             = PrimObject.PathSkewByte(prim.PathSkew);
            add.ObjectData.PathTaperX           = PrimObject.PathTaperByte(prim.PathTaperX);
            add.ObjectData.PathTaperY           = PrimObject.PathTaperByte(prim.PathTaperY);
            add.ObjectData.PathTwist            = PrimObject.PathTwistByte(prim.PathTwist);
            add.ObjectData.PathTwistBegin       = PrimObject.PathTwistByte(prim.PathTwistBegin);
            add.ObjectData.PCode                = (byte)prim.PCode;
            add.ObjectData.ProfileBegin         = PrimObject.ProfileBeginByte(prim.ProfileBegin);
            add.ObjectData.ProfileCurve         = (byte)prim.ProfileCurve;
            add.ObjectData.ProfileEnd           = PrimObject.ProfileEndByte(prim.ProfileEnd);
            add.ObjectData.ProfileHollow        = (byte)prim.ProfileHollow;
            add.ObjectData.RayEnd               = position;
            add.ObjectData.RayEndIsIntersection = 0;
            add.ObjectData.RayStart             = rayStart;
            add.ObjectData.RayTargetID          = LLUUID.GenerateUUID();
            add.ObjectData.Rotation             = prim.Rotation;
            add.ObjectData.Scale                = prim.Scale;
            add.ObjectData.State                = (byte)prim.State;
            if (prim.Textures != null)
            {
                add.ObjectData.TextureEntry = prim.Textures.ToBytes();
            }
            else
            {
                add.ObjectData.TextureEntry = new byte[0];
            }

            Client.Network.SendPacket(add);
        }
Exemple #34
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="regionHandle"></param>
        /// <param name="position"></param>
        /// <param name="lookAt"></param>
        /// <returns></returns>
        public bool Teleport(ulong regionHandle, LLVector3 position, LLVector3 lookAt)
        {
            TeleportStat = TeleportStatus.None;

            TeleportLocationRequestPacket teleport = new TeleportLocationRequestPacket();

            teleport.AgentData.AgentID   = Client.Network.AgentID;
            teleport.AgentData.SessionID = Client.Network.SessionID;
            teleport.Info.LookAt         = lookAt;
            teleport.Info.Position       = position;

            teleport.Info.RegionHandle = regionHandle;

            Client.Log("Teleporting to region " + regionHandle.ToString(), Helpers.LogLevel.Info);

            // Start the timeout check
            TeleportTimeout = false;
            TeleportTimer.Start();

            Client.Network.SendPacket(teleport);

            while (TeleportStat != TeleportStatus.Failed && TeleportStat != TeleportStatus.Finished && !TeleportTimeout)
            {
                Client.Tick();
            }

            TeleportTimer.Stop();

            if (TeleportTimeout)
            {
                TeleportMessage = "Teleport timed out.";
                TeleportStat    = TeleportStatus.Failed;

                if (OnTeleport != null)
                {
                    OnTeleport(TeleportMessage, TeleportStat);
                }
            }
            else
            {
                if (OnTeleport != null)
                {
                    OnTeleport(TeleportMessage, TeleportStat);
                }
            }

            return(TeleportStat == TeleportStatus.Finished);
        }
        /// <summary>
        /// Handle friend location updates
        /// </summary>
        /// <param name="packet">The Packet</param>
        /// <param name="simulator">The Simulator</param>
        public void OnFindAgentReplyHandler(Packet packet, Simulator simulator)
        {
            if (OnFriendFound != null)
            {
                FindAgentPacket reply = (FindAgentPacket)packet;

                float  x, y;
                LLUUID prey         = reply.AgentBlock.Prey;
                ulong  regionHandle = Helpers.GlobalPosToRegionHandle((float)reply.LocationBlock[0].GlobalX,
                                                                      (float)reply.LocationBlock[0].GlobalY, out x, out y);
                LLVector3 xyz = new LLVector3(x, y, 0f);

                try { OnFriendFound(prey, regionHandle, xyz); }
                catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
            }
        }
Exemple #36
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="regionHandle"></param>
        /// <param name="position"></param>
        /// <param name="lookAt"></param>
        /// <param name="tc"></param>
        public void BeginTeleport(ulong regionHandle, LLVector3 position, LLVector3 lookAt, TeleportCallback tc)
        {
            OnBeginTeleport = tc;

            TeleportLocationRequestPacket teleport = new TeleportLocationRequestPacket();

            teleport.AgentData.AgentID   = Client.Network.AgentID;
            teleport.AgentData.SessionID = Client.Network.SessionID;
            teleport.Info.LookAt         = lookAt;
            teleport.Info.Position       = position;
            teleport.Info.RegionHandle   = regionHandle;

            Client.Log("Teleporting to region " + regionHandle.ToString(), Helpers.LogLevel.Info);

            Client.Network.SendPacket(teleport);
        }
 public ChatEventArgs(
     string message, SLChatType type, LLVector3 sourcePos, SLSourceType sourceType,
     LLUUID sourceId, LLUUID ownerId, string fromName,
     bool audible, byte command, LLUUID commandId)
 {
     _message = message;
     _type = type;
     _sourcePos = sourcePos;
     _sourceType = sourceType;
     _sourceId = sourceId;
     _ownerId = ownerId;
     _fromName = fromName;
     _audible = audible;
     _command = command;
     _commandId = commandId;
 }
Exemple #38
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="at">Looking direction, must be a normalized vector</param>
        /// <param name="upDirection">Up direction, must be a normalized vector</param>
        public void LookDirection(LLVector3 at, LLVector3 upDirection)
        {
            // The two parameters cannot be parallel
            LLVector3 left = LLVector3.Cross(upDirection, at);

            if (left == LLVector3.Zero)
            {
                // Prevent left from being zero
                at.X += 0.01f;
                at    = LLVector3.Norm(at);
                left  = LLVector3.Cross(upDirection, at);
            }
            left = LLVector3.Norm(left);

            xAxis = at;
            yAxis = left;
            zAxis = LLVector3.Cross(at, left);
        }
        private void MyOnFrame(IScriptContext context)
        {
            LLVector3 pos = context.Entity.Pos;

            IScriptReadonlyEntity avatar;

            if (context.TryGetRandomAvatar(out avatar))
            {
                LLVector3 avatarPos = avatar.Pos;

                float x = pos.X + ((float)avatarPos.X.CompareTo(pos.X)) / 2;
                float y = pos.Y + ((float)avatarPos.Y.CompareTo(pos.Y)) / 2;

                LLVector3 newPos = new LLVector3(x, y, pos.Z);

                context.Entity.Pos = newPos;
            }
        }
Exemple #40
0
            public static FlexibleData FromLLSD(LLSD llsd)
            {
                FlexibleData flex = new FlexibleData();

                if (llsd.Type == LLSDType.Map)
                {
                    LLSDMap map = (LLSDMap)llsd;

                    flex.Softness = map["simulate_lod"].AsInteger();
                    flex.Gravity  = (float)map["gravity"].AsReal();
                    flex.Drag     = (float)map["air_friction"].AsReal();
                    flex.Wind     = (float)map["wind_sensitivity"].AsReal();
                    flex.Tension  = (float)map["tension"].AsReal();
                    flex.Force    = LLVector3.FromLLSD(map["user_force"]);
                }

                return(flex);
            }
Exemple #41
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="simName"></param>
        /// <param name="position"></param>
        /// <param name="lookAt"></param>
        /// <returns></returns>
        public bool Teleport(string simName, LLVector3 position, LLVector3 lookAt)
        {
            int attempts = 0;

            TeleportStat = TeleportStatus.None;

            simName = simName.ToLower();

            GridRegion region = Client.Grid.GetGridRegion(simName);

            if (region != null)
            {
                return(Teleport(region.RegionHandle, position, lookAt));
            }
            else
            {
                while (attempts++ < 5)
                {
                    region = Client.Grid.GetGridRegion(simName);

                    if (region != null)
                    {
                        return(Teleport(region.RegionHandle, position, lookAt));
                    }
                    else
                    {
                        // Request the region info again
                        Client.Grid.AddSim(simName);

                        System.Threading.Thread.Sleep(1000);
                    }
                }
            }

            if (OnTeleport != null)
            {
                TeleportMessage = "Unable to resolve name: " + simName;
                TeleportStat    = TeleportStatus.Failed;
                OnTeleport(TeleportMessage, TeleportStat);
            }

            return(false);
        }
Exemple #42
0
        /// <summary>
        /// Constructor, aka 'CallBack Central' - Setup callbacks for packets related to our avatar
        /// </summary>
        /// <param name="client"></param>
        public MainAvatar(SecondLife client)
        {
            PacketCallback callback;

            Client          = client;
            TeleportMessage = "";

            // Create emtpy vectors for now
            HomeLookAt = HomePosition = Position = LookAt = new LLVector3();
            Rotation   = new LLQuaternion();

            // Coarse location callback
            Client.Network.RegisterCallback(PacketType.CoarseLocationUpdate, new PacketCallback(CoarseLocationHandler));

            // Teleport callbacks
            callback = new PacketCallback(TeleportHandler);
            Client.Network.RegisterCallback(PacketType.TeleportStart, callback);
            Client.Network.RegisterCallback(PacketType.TeleportProgress, callback);
            Client.Network.RegisterCallback(PacketType.TeleportFailed, callback);
            Client.Network.RegisterCallback(PacketType.TeleportFinish, callback);

            // Instant Message callback
            Client.Network.RegisterCallback(PacketType.ImprovedInstantMessage, new PacketCallback(InstantMessageHandler));

            // Chat callback
            Client.Network.RegisterCallback(PacketType.ChatFromSimulator, new PacketCallback(ChatHandler));

            TeleportTimer          = new Timer(18000);
            TeleportTimer.Elapsed += new ElapsedEventHandler(TeleportTimerEvent);
            TeleportTimeout        = false;

            // Movement complete callback
            Client.Network.RegisterCallback(PacketType.AgentMovementComplete, new PacketCallback(MovementCompleteHandler));

            // Health callback
            Client.Network.RegisterCallback(PacketType.HealthMessage, new PacketCallback(HealthHandler));

            // Money callbacks
            callback = new PacketCallback(BalanceHandler);
            Client.Network.RegisterCallback(PacketType.MoneyBalanceReply, callback);
            Client.Network.RegisterCallback(PacketType.MoneySummaryReply, callback);
            Client.Network.RegisterCallback(PacketType.AdjustBalance, callback);
        }
Exemple #43
0
        /// <summary>
        /// Calculate the rotation between two vectors
        /// </summary>
        /// <param name="a">Directional vector, such as 1,0,0 for the forward face</param>
        /// <param name="b">Target vector - normalize first with VecNorm</param>
        public static LLQuaternion RotBetween(LLVector3 a, LLVector3 b)
        {
            //A and B should both be normalized
            //dotProduct is 0 if a and b are perpendicular. I think that's normal?
            float dotProduct = (a.X * b.X) + (a.Y * b.Y) + (a.Z * b.Z);

            LLVector3 crossProduct = new LLVector3();

            crossProduct.X = a.Y * b.Z - a.Z * b.Y;
            crossProduct.Y = a.Z * b.X - a.X * b.Z;
            crossProduct.Z = a.X * b.Y - a.Y * b.X;

            //float scalarProduct = (a.X * b.Y) + (a.Y * b.Z) + (a.Z * b.X); //not used?
            float  magProduct = VecMag(a) * VecMag(b);
            double angle      = Math.Acos(dotProduct / magProduct);

            LLVector3 axis = VecNorm(crossProduct);
            float     s    = (float)Math.Sin(angle / 2);

            return(new LLQuaternion(axis.X * s, axis.Y * s, axis.Z * s, (float)Math.Cos(angle / 2)));
        }
        public PrimData(byte[] data)
        {
            int i =0;

            this.OwnerID = new LLUUID(data, i); i += 16;
            this.PCode = data[i++];
            this.PathBegin = (ushort)(data[i++] + (data[i++] << 8));
            this.PathEnd = (ushort)(data[i++] + (data[i++] << 8));
            this.PathScaleX = data[i++];
            this.PathScaleY = data[i++];
            this.PathShearX = data[i++];
            this.PathShearY = data[i++];
            this.PathSkew = (sbyte)data[i++];
            this.ProfileBegin = (ushort)(data[i++] + (data[i++] << 8));
            this.ProfileEnd = (ushort)(data[i++] + (data[i++] << 8));
            this.Scale = new LLVector3(data, i); i += 12;
            this.PathCurve = data[i++];
            this.ProfileCurve = data[i++];
            this.ParentID = (uint)(data[i++] + (data[i++] << 8) + (data[i++] << 16) + (data[i++] << 24));
            this.ProfileHollow = (ushort)(data[i++] + (data[i++] << 8));
            this.PathRadiusOffset = (sbyte)data[i++];
            this.PathRevolutions = data[i++];
            this.PathTaperX = (sbyte)data[i++];
            this.PathTaperY =(sbyte) data[i++];
            this.PathTwist = (sbyte) data[i++];
            this.PathTwistBegin = (sbyte) data[i++];
            ushort length = (ushort)(data[i++] + (data[i++] << 8));
            this.Texture = new byte[length];
            Array.Copy(data, i, Texture, 0, length); i += length;
            this.CreationDate = (Int32)(data[i++] + (data[i++] << 8) + (data[i++] << 16) + (data[i++] << 24));
            this.OwnerMask = (uint)(data[i++] + (data[i++] << 8) + (data[i++] << 16) + (data[i++] << 24));
            this.NextOwnerMask = (uint)(data[i++] + (data[i++] << 8) + (data[i++] << 16) + (data[i++] << 24));
            this.GroupMask = (uint)(data[i++] + (data[i++] << 8) + (data[i++] << 16) + (data[i++] << 24));
            this.EveryoneMask = (uint)(data[i++] + (data[i++] << 8) + (data[i++] << 16) + (data[i++] << 24));
            this.BaseMask = (uint)(data[i++] + (data[i++] << 8) + (data[i++] << 16) + (data[i++] << 24));
            this.Position = new LLVector3(data, i); i += 12;
            this.Rotation = new LLQuaternion(data,i, true); i += 12;
            this.LocalID = (uint)(data[i++] + (data[i++] << 8) + (data[i++] << 16) + (data[i++] << 24));
            this.FullID = new LLUUID(data, i); i += 16;
        }
        protected void doStuff(string sim, LLVector3 coords)
        {
            Client.Grid.OnRegionAdd += new GridRegionCallback(GridRegionHandler);

            Console.WriteLine("Caching estate sims...");
            Client.Grid.AddEstateSims();
            System.Threading.Thread.Sleep(3000);

            if (RegionHandle == 0)
            {
                Client.Grid.BeginGetGridRegion(sim, new GridRegionCallback(GridRegionHandler));

                int start = Environment.TickCount;

                while (RegionHandle == 0)
                {
                    Client.Tick();

                    if (Environment.TickCount - start > 10000)
                    {
                        Console.WriteLine("Region handle lookup failed");
                        Disconnect();
                        return;
                    }
                }
            }

            Client.Self.OnTeleport += new TeleportCallback(Avatar_OnTeleportMessage);

            DoneTeleporting = false;
            Client.Self.Teleport(RegionHandle, coords);

            while (!DoneTeleporting)
            {
                Client.Tick();
            }
        }
Exemple #46
0
 /// <summary>
 /// Rez an object from inventory
 /// </summary>
 /// <param name="simulator">Simulator to place object in</param>
 /// <param name="rotation">Rotation of the object when rezzed</param>
 /// <param name="position">Vector of where to place object</param>
 /// <param name="item">InventoryObject object containing item details</param>
 /// <param name="groupOwner">LLUUID of group to own the object</param>
 public LLUUID RequestRezFromInventory(Simulator simulator, LLQuaternion rotation, LLVector3 position,
     InventoryObject item, LLUUID groupOwner)
 {
     return RequestRezFromInventory(simulator, rotation, position, item, groupOwner, LLUUID.Random(), false);
 }
Exemple #47
0
 /// <summary>
 /// Rez an object from inventory
 /// </summary>
 /// <param name="simulator">Simulator to place object in</param>
 /// <param name="rotation">Rotation of the object when rezzed</param>
 /// <param name="position">Vector of where to place object</param>
 /// <param name="item">InventoryObject object containing item details</param>
 public LLUUID RequestRezFromInventory(Simulator simulator, LLQuaternion rotation, LLVector3 position,
     InventoryObject item)
 {
     return RequestRezFromInventory(simulator, rotation, position, item, _Client.Self.ActiveGroup,
         LLUUID.Random(), false);
 }
Exemple #48
0
 public int GetRectangularDeviation(LLVector3 aabbmin, LLVector3 aabbmax, int area)
 {
     int xlength = (int)(aabbmax.X - aabbmin.X);
     int ylength = (int)(aabbmax.Y - aabbmin.Y);
     int aabbarea = xlength * ylength;
     return (aabbarea - area) / 16;
 }
Exemple #49
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="map"></param>
        /// <param name="localid"></param>
        /// <returns></returns>
        public WaterType GetWaterType(int[,] map, int localid)
        {
            if (!Client.Settings.STORE_LAND_PATCHES)
            {
                Client.Log("GetWaterType() will not work without Settings.STORE_LAND_PATCHES set to true",
                    Helpers.LogLevel.Error);
                return WaterType.Unknown;
            }
            else if (!Client.Network.Connected && Client.Network.CurrentSim != null)
            {
                Client.Log("GetWaterType() can only be used with an online client", Helpers.LogLevel.Error);
                return WaterType.Unknown;
            }

            bool underwater = false;
            bool abovewater = false;

            for (int y = 0; y < 64; y++)
            {
                for (int x = 0; x < 64; x++)
                {
                    if (map[y, x] == localid)
                    {
                        for (int y1 = 0; y1 < 4; y1++)
                        {
                            for (int x1 = 0; x1 < 4; x1++)
                            {
                                float height;
                                int tries = 0;

                            CheckHeight:
                                tries++;

                                if (Client.Terrain.TerrainHeightAtPoint(Client.Network.CurrentSim.Handle,
                                    x * 4 + x1, y * 4 + y1, out height))
                                {
                                    if (height < Client.Network.CurrentSim.WaterHeight)
                                    {
                                        underwater = true;
                                    }
                                    else
                                    {
                                        abovewater = true;
                                    }
                                }
                                else if (tries > 4)
                                {
                                    Client.Log("Too many tries on this terrain block, skipping", 
                                        Helpers.LogLevel.Warning);
                                    continue;
                                }
                                else
                                {
                                    Client.Log(String.Format("Terrain height is null at {0},{1} retrying",
                                        x * 4 + x1, y * 4 + y1), Helpers.LogLevel.Info);

                                    // Terrain at this point hasn't been downloaded, move the camera to this spot
                                    // and try again
                                    LLVector3 position = new LLVector3((float)(x * 4 + x1), (float)(y * 4 + y1),
                                        Client.Self.SimPosition.Z);
                                    Client.Self.Movement.Camera.Position = position;

                                    Client.Self.Movement.SendUpdate(true);

                                    Thread.Sleep(1000);
                                    goto CheckHeight;
                                }
                            }
                        }
                    }
                }
            }

            if (underwater && abovewater)
            {
                return WaterType.Waterfront;
            }
            else if (abovewater)
            {
                return WaterType.Dry;
            }
            else if (underwater)
            {
                return WaterType.Underwater;
            }
            else
            {
                Client.Log("Error decoding terrain for parcel " + localid, Helpers.LogLevel.Error);
                return WaterType.Unknown;
            }
        }
Exemple #50
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="map"></param>
        /// <param name="localid"></param>
        /// <returns></returns>
        public float GetHeightRange(int[,] map, int localid)
        {
            float min = Single.MaxValue;
            float max = 0.0f;

            for (int y = 0; y < 64; y++)
            {
                for (int x = 0; x < 64; x++)
                {
                    if (map[y, x] == localid)
                    {
                        for (int y1 = 0; y1 < 4; y1++)
                        {
                            for (int x1 = 0; x1 < 4; x1++)
                            {
                                float height;
                                int tries = 0;

                            CheckHeight:

                                if (Client.Terrain.TerrainHeightAtPoint(Client.Network.CurrentSim.Handle,
                                    x * 4 + x1, y * 4 + y1, out height))
                                {
                                    if (height < min)
                                        min = height;
                                    if (height > max)
                                        max = height;
                                }
                                else if (tries > 4)
                                {
                                    Client.Log("Too many tries on this terrain block, skipping",
                                        Helpers.LogLevel.Warning);
                                    continue;
                                }
                                else
                                {
                                    Client.Log(String.Format("Terrain height is null at {0},{1} retrying",
                                        x * 4 + x1, y * 4 + y1), Helpers.LogLevel.Info);

                                    // Terrain at this point hasn't been downloaded, move the camera to this spot
                                    // and try again
                                    LLVector3 position = new LLVector3((float)(x * 4 + x1), (float)(y * 4 + y1),
                                        Client.Self.SimPosition.Z);
                                    Client.Self.Movement.Camera.Position = position;

                                    Client.Self.Movement.SendUpdate(true);

                                    Thread.Sleep(1000);
                                    goto CheckHeight;
                                }
                            }
                        }
                    }
                }
            }

            if (min != Single.MaxValue)
            {
                return max - min;
            }
            else
            {
                Client.Log("Error decoding terrain for parcel " + localid, Helpers.LogLevel.Error);
                return Single.NaN;
            }
        }
Exemple #51
0
 public void StayInSim(ulong handle, LLVector3 desiredPosition)
 {
     SimHandle = handle;
     Position = desiredPosition;
     CheckTimer.Start();
 }
Exemple #52
0
 /// <summary>
 /// Plays a sound in the specified sim
 /// </summary>
 /// <param name="soundID">UUID of the sound to be played.</param>
 /// <param name="sim">UUID of the sound to be played.</param>
 /// <param name="position">position for the sound to be played at. Normally the avatar.</param>
 /// <param name="gain">volume of the sound, from 0.0 to 1.0</param>
 public void SoundTrigger(LLUUID soundID, Simulator sim, LLVector3 position, float gain)
 {
     SoundTrigger(soundID, sim.Handle, position, 1.0f);
 }
        private void FromBytes(byte[] data, int pos)
        {
            int i = pos;

            Softness = ((data[i] & 0x80) >> 6) | ((data[i + 1] & 0x80) >> 7);

            Tension = (data[i++] & 0x7F) / 10.0f;
            Drag = (data[i++] & 0x7F) / 10.0f;
            Gravity = (data[i++] / 10.0f) - 10.0f;
            Wind = data[i++] / 10.0f;
            Force = new LLVector3(data, i);
        }
Exemple #54
0
        private bool Inventory_OnInventoryObjectReceived(LLUUID fromAgentID, string fromAgentName,
            uint parentEstateID, LLUUID regionID, LLVector3 position, DateTime timestamp, AssetType type,
            LLUUID objectID, bool fromTask)
        {
            if (MasterKey != LLUUID.Zero)
            {
                if (fromAgentID != MasterKey)
                    return false;
            }
            else if (GroupMembers != null && !GroupMembers.ContainsKey(fromAgentID))
            {
                return false;
            }

            return true;
        }
 // SayToUser: send a message to the user as in-world chat
 private static void SayToUser(string message)
 {
     Hashtable blocks = new Hashtable();
     Hashtable fields;
     fields = new Hashtable();
     fields["FromName"] = "Analyst";
     fields["SourceID"] = new LLUUID(true);
     fields["OwnerID"] = agentID;
     fields["SourceType"] = (byte)2;
     fields["ChatType"] = (byte)1;
     fields["Audible"] = (byte)1;
     fields["Position"] = new LLVector3(0, 0, 0);
     fields["Message"] = message;
     blocks[fields] = "ChatData";
     Packet packet = PacketBuilder.BuildPacket("ChatFromSimulator", protocolManager, blocks, Helpers.MSG_RELIABLE);
     proxy.InjectPacket(packet, Direction.Incoming);
 }
Exemple #56
0
 /// <summary>
 /// Plays a sound in the current region
 /// </summary>
 /// <param name="soundID">UUID of the sound to be played.</param>
 /// <param name="position">position for the sound to be played at. Normally the avatar.</param>
 /// <param name="gain">volume of the sound, from 0.0 to 1.0</param>
 public void SoundTrigger(LLUUID soundID, LLVector3 position, float gain)
 {
     SoundTrigger(soundID, Client.Network.CurrentSim.Handle, position, 1.0f);
 }
Exemple #57
0
 /// <summary>
 /// Plays a sound in the current region at full volume
 /// </summary>
 /// <param name="soundID">UUID of the sound to be played.</param>
 /// <param name="position">position for the sound to be played at. Normally the avatar.</param>
 public void SoundTrigger(LLUUID soundID, LLVector3 position)
 {
     SoundTrigger(soundID, Client.Self.SimPosition, 1.0f);
 }
Exemple #58
0
        /// <summary>
        /// Rez an object from inventory
        /// </summary>
        /// <param name="simulator">Simulator to place object in</param>
        /// <param name="rotation">Rotation of the object when rezzed</param>
        /// <param name="position">Vector of where to place object</param>
        /// <param name="item">InventoryObject object containing item details</param>
        /// <param name="groupOwner">LLUUID of group to own the object</param>        
        /// <param name="queryID">User defined queryID to correlate replies</param>
        /// <param name="requestObjectDetails">if set to true the simulator
        /// will automatically send object detail packet(s) back to the client</param>
        public LLUUID RequestRezFromInventory(Simulator simulator, LLQuaternion rotation, LLVector3 position,
            InventoryObject item, LLUUID groupOwner, LLUUID queryID, bool requestObjectDetails)
        {
            RezObjectPacket add = new RezObjectPacket();

            add.AgentData.AgentID = _Client.Self.AgentID;
            add.AgentData.SessionID = _Client.Self.SessionID;
            add.AgentData.GroupID = groupOwner;

            add.RezData.FromTaskID = LLUUID.Zero;
            add.RezData.BypassRaycast = 1;
            add.RezData.RayStart = position;
            add.RezData.RayEnd = position;
            add.RezData.RayTargetID = LLUUID.Zero;
            add.RezData.RayEndIsIntersection = false;
            add.RezData.RezSelected = requestObjectDetails;
            add.RezData.RemoveItem = false;
            add.RezData.ItemFlags = item.Flags;
            add.RezData.GroupMask = (uint)item.Permissions.GroupMask;
            add.RezData.EveryoneMask = (uint)item.Permissions.EveryoneMask;
            add.RezData.NextOwnerMask = (uint)item.Permissions.NextOwnerMask;

            add.InventoryData.ItemID = item.UUID;
            add.InventoryData.FolderID = item.ParentUUID;
            add.InventoryData.CreatorID = item.CreatorID;
            add.InventoryData.OwnerID = item.OwnerID;
            add.InventoryData.GroupID = item.GroupID;
            add.InventoryData.BaseMask = (uint)item.Permissions.BaseMask;
            add.InventoryData.OwnerMask = (uint)item.Permissions.OwnerMask;
            add.InventoryData.GroupMask = (uint)item.Permissions.GroupMask;
            add.InventoryData.EveryoneMask = (uint)item.Permissions.EveryoneMask;
            add.InventoryData.NextOwnerMask = (uint)item.Permissions.NextOwnerMask;
            add.InventoryData.GroupOwned = item.GroupOwned;
            add.InventoryData.TransactionID = queryID;
            add.InventoryData.Type = (sbyte)item.InventoryType;
            add.InventoryData.InvType = (sbyte)item.InventoryType;
            add.InventoryData.Flags = item.Flags;
            add.InventoryData.SaleType = (byte)item.SaleType;
            add.InventoryData.SalePrice = item.SalePrice;
            add.InventoryData.Name = Helpers.StringToField(item.Name);
            add.InventoryData.Description = Helpers.StringToField(item.Description);
            add.InventoryData.CreationDate = (int)Helpers.DateTimeToUnixTime(item.CreationDate);

            _Client.Network.SendPacket(add, simulator);

            return queryID;
        }
Exemple #59
0
 /// <summary>
 /// Plays a sound
 /// </summary>
 /// <param name="soundID">UUID of the sound to be played.</param>
 /// <param name="handle">handle id for the sim to be played in.</param>
 /// <param name="position">position for the sound to be played at. Normally the avatar.</param>
 /// <param name="gain">volume of the sound, from 0.0 to 1.0</param>
 public void SoundTrigger(LLUUID soundID, ulong handle , LLVector3 position, float gain)
 {
     SoundTriggerPacket soundtrigger = new SoundTriggerPacket();
     soundtrigger.SoundData = new SoundTriggerPacket.SoundDataBlock();
     soundtrigger.SoundData.SoundID = soundID;
     soundtrigger.SoundData.ObjectID = LLUUID.Zero;
     soundtrigger.SoundData.OwnerID = LLUUID.Zero;
     soundtrigger.SoundData.ParentID = LLUUID.Zero;
     soundtrigger.SoundData.Handle = handle;
     soundtrigger.SoundData.Position = position;
     soundtrigger.SoundData.Gain = gain;
     Client.Network.SendPacket(soundtrigger);
 }
Exemple #60
0
 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;
 }