public void ObjectAddHandler(Packet packet, Simulator simulator)
        {
            LLVector3 position = null;

            if (WaitingOnUpdate)
            {
                CurrentPrimMutex.WaitOne();

                foreach (Block block in packet.Blocks())
                {
                    foreach (Field field in block.Fields)
                    {
                        if (field.Layout.Name == "RayEnd")
                        {
                            position = (LLVector3)field.Data;
                        }
                    }
                }

                txtLog.AppendText("Received an ObjectAdd, setting CurrentPrim position to " + position.ToString());
                CurrentPrim.Position = position;

                CurrentPrimMutex.ReleaseMutex();
            }
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="simulator"></param>
        /// <param name="seedcaps"></param>
        internal Caps(Simulator simulator, string seedcaps)
        {
            Simulator = simulator;
            _SeedCapsURI = seedcaps;

            MakeSeedRequest();
        }
Ejemplo n.º 3
0
 protected void AttachedSoundHandler(Packet packet, Simulator simulator)
 {
     AttachedSoundPacket sound = (AttachedSoundPacket)packet;
     if (OnAttachSound != null)
     {
         try { OnAttachSound(sound.DataBlock.SoundID, sound.DataBlock.OwnerID, sound.DataBlock.ObjectID, sound.DataBlock.Gain, sound.DataBlock.Flags); }
         catch (Exception e) { Client.Log(e.ToString(), Helpers.LogLevel.Error); }
     }
 }
Ejemplo n.º 4
0
 protected void AttachedSoundGainChangeHandler(Packet packet, Simulator simulator)
 {
     AttachedSoundGainChangePacket change = (AttachedSoundGainChangePacket)packet;
     if (OnAttachSoundGainChange != null)
     {
         try { OnAttachSoundGainChange(change.DataBlock.ObjectID, change.DataBlock.Gain); }
         catch (Exception e) { Client.Log(e.ToString(), Helpers.LogLevel.Error); }
     }
 }
Ejemplo n.º 5
0
        void Network_OnEventQueueRunning(Simulator simulator)
        {
            if (simulator == Client.Network.CurrentSim)
            {
                Console.WriteLine("Event queue connected for the primary simulator, requesting group info");

                Client.Groups.RequestCurrentGroups();
            }
        }
Ejemplo n.º 6
0
 private void AgentDataUpdateHandler(Packet packet, Simulator sim)
 {
     AgentDataUpdatePacket p = (AgentDataUpdatePacket)packet;
     if (p.AgentData.AgentID == Client.Self.AgentID)
     {
         activeGroup = Helpers.FieldToUTF8String(p.AgentData.GroupName) + " ( " + Helpers.FieldToUTF8String(p.AgentData.GroupTitle) + " )";
         GroupsEvent.Set();
     }
 }
Ejemplo n.º 7
0
        void Objects_OnObjectProperties(Simulator simulator, LLObject.ObjectProperties properties)
        {
            lock (PrimsWaiting) {
                Primitive prim;
                if (PrimsWaiting.TryGetValue(properties.ObjectID, out prim)) {
                    prim.Properties = properties;
                }
                PrimsWaiting.Remove(properties.ObjectID);

                if (PrimsWaiting.Count == 0)
                    AllPropertiesReceived.Set();
            }
        }
Ejemplo n.º 8
0
 protected void PreloadSoundHandler(Packet packet, Simulator simulator)
 {
     PreloadSoundPacket preload = (PreloadSoundPacket)packet;
     if (OnPreloadSound != null)
     {
         foreach (PreloadSoundPacket.DataBlockBlock data in preload.DataBlock)
         {
             try
             {
                 OnPreloadSound(data.SoundID, data.OwnerID, data.ObjectID);
             }
             catch (Exception e) { Client.Log(e.ToString(), Helpers.LogLevel.Error); }
         }
     }
 }
Ejemplo n.º 9
0
 private void OnPacket(Packet packet, Simulator simulator)
 {
     lock (Packets)
     {
         if (Count >= Total)
         {
             Done = true;
         }
         else
         {
             Packets.Add(packet);
             Count++;
         }
     }
 }
Ejemplo n.º 10
0
        private void AvatarAppearanceHandler(Packet packet, Simulator simulator)
        {
            AvatarAppearancePacket appearance = (AvatarAppearancePacket)packet;

            LLObject.TextureEntry te = new LLObject.TextureEntry(appearance.ObjectData.TextureEntry, 0, 
                appearance.ObjectData.TextureEntry.Length);

            if (IsNullOrZero(te.FaceTextures[(int)AppearanceManager.TextureIndex.EyesBaked] ) &&
                IsNullOrZero(te.FaceTextures[(int)AppearanceManager.TextureIndex.HeadBaked]) &&
                IsNullOrZero(te.FaceTextures[(int)AppearanceManager.TextureIndex.LowerBaked]) &&
                IsNullOrZero(te.FaceTextures[(int)AppearanceManager.TextureIndex.SkirtBaked]) &&
                IsNullOrZero(te.FaceTextures[(int)AppearanceManager.TextureIndex.UpperBaked]))
            {
                Console.WriteLine("Avatar " + appearance.Sender.ID.ToString() + " may be a bot");
            }
        }
        private void Objects_OnNewAvatar(Simulator simulator, Avatar avatar, ulong regionHandle, ushort timeDilation)
        {
            if (imgManager == null)
            {
                Console.WriteLine("ImageManager not ready yet, queueing Avatar textures.");
                TextureQueue.Enqueue(avatar.FirstLifeImage);
                TextureQueue.Enqueue(avatar.ProfileImage);

                foreach (TextureEntryFace tef in avatar.Textures.FaceTextures.Values)
                {
                    TextureQueue.Enqueue(tef.TextureID);
                }
            }
            else
            {
                if (avatar.FirstLifeImage != null)
                {
                    if (imgManager.isCachedImage(avatar.FirstLifeImage) == false)
                    {
                        imgManager.RequestImageAsync(avatar.FirstLifeImage);
                    }
                }

                if (avatar.ProfileImage != null)
                {
                    if (imgManager.isCachedImage(avatar.FirstLifeImage) == false)
                    {
                        imgManager.RequestImageAsync(avatar.ProfileImage);
                    }
                }

                if (avatar.Textures != null)
                {
                    foreach (TextureEntryFace tef in avatar.Textures.FaceTextures.Values)
                    {
                        if (imgManager.isCachedImage(tef.TextureID) == false)
                        {
                            imgManager.RequestImageAsync(tef.TextureID);
                        }
                        else
                        {
                            Console.WriteLine("Already cached: " + tef.TextureID);
                        }
                    }
                }
            }
        }
Ejemplo n.º 12
0
        void Parcels_OnParcelsDownloaded(Simulator simulator, Dictionary<int, Parcel> Parcels, int[,] map)
        {
            foreach (KeyValuePair<int, Parcel> parcel in Parcels)
            {
                WaterType type = ParcelDownloader.GetWaterType(map, parcel.Value.LocalID);
                float delta = ParcelDownloader.GetHeightRange(map, parcel.Value.LocalID);
                int deviation = ParcelDownloader.GetRectangularDeviation(parcel.Value.AABBMin, parcel.Value.AABBMax, 
                    parcel.Value.Area);

                Console.WriteLine("Parcels[{0}]: Name: \"{1}\", Description: \"{2}\" ACL Count: {3}, " +
                    "Location: {4}, Height Range: {5}, Shape Deviation: {6}", parcel.Key, parcel.Value.Name, 
                    parcel.Value.Desc, parcel.Value.AccessList.Count, type.ToString(), delta, deviation);
            }

            ParcelCount = Parcels.Count;
            ParcelsDownloaded.Set();
        }
        public void ObjectUpdateHandler(Packet packet, Simulator simulator)
        {
            uint id = 0;
            LLUUID uuid = null;

            if (WaitingOnUpdate)
            {
                CurrentPrimMutex.WaitOne();

                foreach (Block block in packet.Blocks())
                {
                    foreach (Field field in block.Fields)
                    {
                        if (field.Layout.Name == "ID")
                        {
                            id = (uint)field.Data;
                        }
                        else if (field.Layout.Name == "FullID")
                        {
                            uuid = (LLUUID)field.Data;
                        }
                        else if (field.Layout.Name == "ObjectData")
                        {
                            byte[] byteArray = (byte[])field.Data;
                            LLVector3 position = new LLVector3(byteArray, 0);
                            if (CurrentPrim != null && position != CurrentPrim.Position)
                            {
                                txtLog.AppendText(position.ToString() + " doesn't match CurrentPrim.Position " +
                                    CurrentPrim.Position.ToString() + "\n"/* + ", ignoring"*/);
                                //return;
                            }
                        }
                    }
                }

                CurrentPrim.ID = id;
                CurrentPrim.UUID = uuid;

                WaitingOnUpdate = false;

                CurrentPrimMutex.ReleaseMutex();
            }
        }
Ejemplo n.º 14
0
        /// <summary>
        /// Fire the events registered for this packet type synchronously
        /// </summary>
        /// <param name="packetType">Incoming packet type</param>
        /// <param name="packet">Incoming packet</param>
        /// <param name="simulator">Simulator this packet was received from</param>
        internal void RaiseEvent(PacketType packetType, Packet packet, Simulator simulator)
        {
            NetworkManager.PacketCallback callback;

            if (_EventTable.TryGetValue(packetType, out callback))
            {
                try
                {
                    callback(packet, simulator);
                }
                catch (Exception ex)
                {
                    Client.Log("Packet Event Handler: " + ex.ToString(), Helpers.LogLevel.Error);
                }
            }
            else if (packetType != PacketType.Default && packetType != PacketType.PacketAck)
            {
                Client.Log("No handler registered for packet event " + packetType, Helpers.LogLevel.Debug);
            }
        }
Ejemplo n.º 15
0
        public static void QueryHandler(Packet packet, Simulator simulator)
        {
            DirPeopleReplyPacket reply = (DirPeopleReplyPacket)packet;

            if (reply.QueryReplies.Length < 1)
            {
                Console.WriteLine("ERROR: Got an empty reply");
            }
            else
            {
                if (reply.QueryReplies.Length > 1)
                {
                    Console.WriteLine("ERROR: Ambiguous name. Returning first match");
                }

                Console.WriteLine("UUID: " + reply.QueryReplies[0].AgentID.ToString());
            }

            waiting = false;
        }
Ejemplo n.º 16
0
        void Terrain_OnLandPatch(Simulator simulator, int x, int y, int width, float[] data)
        {
            if (x >= 16 || y >= 16)
            {
                Console.WriteLine("Bad patch coordinates, x = " + x + ", y = " + y);
                return;
            }

            if (width != 16)
            {
                Console.WriteLine("Unhandled patch size " + width + "x" + width);
                return;
            }

            Bitmap patch = new Bitmap(16, 16, PixelFormat.Format24bppRgb);

            for (int yp = 0; yp < 16; yp++)
            {
                for (int xp = 0; xp < 16; xp++)
                {
                    float height = data[yp * 16 + xp];
                    int colorVal = Helpers.FloatToByte(height, 0.0f, 60.0f);
                    int lesserVal = (int)((float)colorVal * 0.75f);
                    Color color;

                    if (height >= simulator.WaterHeight)
                        color = Color.FromArgb(lesserVal, colorVal, lesserVal);
                    else
                        color = Color.FromArgb(lesserVal, lesserVal, colorVal);

                    patch.SetPixel(xp, yp, color);
                }
            }

            Boxes[x, y].Image = (Image)patch;
        }
Ejemplo n.º 17
0
        private void ParcelPropertiesHandler(Packet packet, Simulator simulator)
        {
            ParcelPropertiesPacket properties = (ParcelPropertiesPacket)packet;

            byte[] Bitmap  = properties.ParcelData.Bitmap;
            int    LocalID = properties.ParcelData.LocalID;

            // Mark this area as downloaded
            int  x, y, index, subindex;
            byte val;

            for (x = 0; x < 64; x++)
            {
                for (y = 0; y < 64; y++)
                {
                    if (simulator.Region.ParcelMarked[y, x] == 0)
                    {
                        index    = ((x * 64) + y);
                        subindex = index % 8;
                        index   /= 8;

                        val = Bitmap[index];

                        simulator.Region.ParcelMarked[y, x] = ((val >> subindex) & 1) == 1 ? LocalID : 0;
                    }
                }
            }

            // Fire off the next request, if we are downloading the whole sim
            bool hasTriggered = false;

            if (simulator.Region.ParcelDownloading)
            {
                for (x = 0; x < 64; x++)
                {
                    for (y = 0; y < 64; y++)
                    {
                        if (simulator.Region.ParcelMarked[x, y] == 0)
                        {
                            ParcelPropertiesRequestPacket tPacket = new ParcelPropertiesRequestPacket();
                            tPacket.AgentData.AgentID     = Client.Network.AgentID;
                            tPacket.AgentData.SessionID   = Client.Network.SessionID;
                            tPacket.ParcelData.SequenceID = -10000;
                            tPacket.ParcelData.West       = (x * 4.0f);
                            tPacket.ParcelData.South      = (y * 4.0f);
                            tPacket.ParcelData.East       = (x * 4.0f) + 4.0f;
                            tPacket.ParcelData.North      = (y * 4.0f) + 4.0f;

                            simulator.SendPacket((Packet)tPacket, true);

                            hasTriggered = true;

                            goto exit;
                        }
                    }
                }
exit:
                ;
            }

            // This map is complete, fire callback
            if (!hasTriggered)
            {
                simulator.Region.FilledParcels();
            }

            Parcel parcel = null;

            lock (simulator.Region.Parcels)
            {
                if (!simulator.Region.Parcels.ContainsKey(LocalID))
                {
                    simulator.Region.Parcels[LocalID] = new Parcel(simulator);
                }

                parcel = simulator.Region.Parcels[LocalID];
            }

            // Save this parcels data
            // TODO: Lots of values are not being stored, Parcel needs to be expanded to take all the data.
            // August2006:  God help me should I have to type this out again... argh.
            // October2006: I really shouldnt have typed that.
            parcel.RequestResult       = properties.ParcelData.RequestResult;
            parcel.SequenceID          = properties.ParcelData.SequenceID;
            parcel.SnapSelection       = properties.ParcelData.SnapSelection;
            parcel.SelfCount           = properties.ParcelData.SelfCount;
            parcel.OtherCount          = properties.ParcelData.OtherCount;
            parcel.PublicCount         = properties.ParcelData.PublicCount;
            parcel.LocalID             = LocalID;
            parcel.OwnerID             = properties.ParcelData.OwnerID;
            parcel.IsGroupOwned        = properties.ParcelData.IsGroupOwned;
            parcel.AuctionID           = properties.ParcelData.AuctionID;
            parcel.ReservedNewbie      = properties.ParcelData.ReservedNewbie;
            parcel.ClaimDate           = properties.ParcelData.ClaimDate;
            parcel.ClaimPrice          = properties.ParcelData.ClaimPrice;
            parcel.RentPrice           = properties.ParcelData.RentPrice;
            parcel.AABBMin             = properties.ParcelData.AABBMin;
            parcel.AABBMax             = properties.ParcelData.AABBMax;
            parcel.Bitmap              = properties.ParcelData.Bitmap;
            parcel.Area                = properties.ParcelData.Area;
            parcel.Status              = properties.ParcelData.Status;
            parcel.SimWideMaxObjects   = properties.ParcelData.SimWideMaxPrims;
            parcel.SimWideTotalObjects = properties.ParcelData.SimWideTotalPrims;
            parcel.MaxObjects          = properties.ParcelData.MaxPrims;
            parcel.TotalObjects        = properties.ParcelData.TotalPrims;
            parcel.OwnerObjects        = properties.ParcelData.OwnerPrims;
            parcel.GroupObjects        = properties.ParcelData.GroupPrims;
            parcel.OtherObjects        = properties.ParcelData.OtherPrims;
            parcel.ParcelObjectBonus   = properties.ParcelData.ParcelPrimBonus;
            parcel.OtherCleanTime      = properties.ParcelData.OtherCleanTime;
            parcel.ParcelFlags         = properties.ParcelData.ParcelFlags;
            parcel.SalePrice           = properties.ParcelData.SalePrice;
            parcel.Name                = Helpers.FieldToString(properties.ParcelData.Name);
            parcel.Desc                = Helpers.FieldToString(properties.ParcelData.Desc);
            parcel.MusicURL            = Helpers.FieldToString(properties.ParcelData.MusicURL);
            parcel.MediaURL            = Helpers.FieldToString(properties.ParcelData.MediaURL);
            parcel.MediaID             = properties.ParcelData.MediaID;
            parcel.MediaAutoScale      = properties.ParcelData.MediaAutoScale;
            parcel.GroupID             = properties.ParcelData.GroupID;
            parcel.PassPrice           = properties.ParcelData.PassPrice;
            parcel.PassHours           = properties.ParcelData.PassHours;
            parcel.Category            = properties.ParcelData.Category;
            parcel.AuthBuyerID         = properties.ParcelData.AuthBuyerID;
            parcel.SnapshotID          = properties.ParcelData.SnapshotID;
            parcel.UserLocation        = properties.ParcelData.UserLocation;
            parcel.UserLookAt          = properties.ParcelData.UserLookAt;
            parcel.LandingType         = properties.ParcelData.LandingType;
        }
Ejemplo n.º 18
0
        /// <summary>
        /// Connect to a simulator
        /// </summary>
        /// <param name="endPoint">IP address and port to connect to</param>
        /// <param name="handle">Handle for this simulator, to identify its
        /// location in the grid</param>
        /// <param name="setDefault">Whether to set CurrentSim to this new
        /// connection, use this if the avatar is moving in to this simulator</param>
        /// <param name="seedcaps">URL of the capabilities server to use for
        /// this sim connection</param>
        /// <returns>A Simulator object on success, otherwise null</returns>
        public Simulator Connect(IPEndPoint endPoint, ulong handle, bool setDefault, string seedcaps)
        {
            Simulator simulator = FindSimulator(endPoint);

            if (simulator == null)
            {
                // We're not tracking this sim, create a new Simulator object
                simulator = new Simulator(Client, endPoint, handle);

                // Immediately add this simulator to the list of current sims. It will be removed if the
                // connection fails
                lock (Simulators) Simulators.Add(simulator);
            }

            if (!simulator.Connected)
            {
                if (!connected)
                {
                    // Mark that we are connecting/connected to the grid
                    connected = true;

                    // restart the blocking queue in case of re-connect
                    PacketInbox.Open();

                    // Start the packet decoding thread
                    Thread decodeThread = new Thread(new ThreadStart(PacketHandler));
                    decodeThread.Start();
                }

                // Fire the OnSimConnecting event
                if (OnSimConnecting != null)
                {
                    try
                    {
                        if (!OnSimConnecting(simulator))
                        {
                            // Callback is requesting that we abort this connection
                            lock (Simulators) Simulators.Remove(simulator);
                            return(null);
                        }
                    }
                    catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
                }

                // Attempt to establish a connection to the simulator
                if (simulator.Connect(setDefault))
                {
                    if (DisconnectTimer == null)
                    {
                        // Start a timer that checks if we've been disconnected
                        DisconnectTimer = new Timer(new TimerCallback(DisconnectTimer_Elapsed), null,
                                                    Client.Settings.SIMULATOR_TIMEOUT, Client.Settings.SIMULATOR_TIMEOUT);
                    }

                    if (setDefault)
                    {
                        SetCurrentSim(simulator, seedcaps);
                    }

                    // Fire the simulator connection callback if one is registered
                    if (OnSimConnected != null)
                    {
                        try { OnSimConnected(simulator); }
                        catch (Exception e) { Logger.Log(e.Message, Helpers.LogLevel.Error, Client, e); }
                    }

                    // If enabled, send an AgentThrottle packet to the server to increase our bandwidth
                    if (Client.Settings.SEND_AGENT_THROTTLE)
                    {
                        Client.Throttle.Set(simulator);
                    }

                    return(simulator);
                }
                else
                {
                    // Connection failed, remove this simulator from our list and destroy it
                    lock (Simulators) Simulators.Remove(simulator);
                    return(null);
                }
            }
            else if (setDefault)
            {
                // We're already connected to this server, but need to set it to the default
                SetCurrentSim(simulator, seedcaps);

                // Move in to this simulator
                Client.Self.CompleteAgentMovement(simulator);

                // Send an initial AgentUpdate to complete our movement in to the sim
                if (Client.Settings.SEND_AGENT_UPDATES)
                {
                    Client.Self.Movement.SendUpdate(true, simulator);
                }

                return(simulator);
            }
            else
            {
                // Already connected to this simulator and wasn't asked to set it as the default,
                // just return a reference to the existing object
                return(simulator);
            }
        }
Ejemplo n.º 19
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="simulator"></param>
 public Parcel(Simulator simulator)
 {
     Sim = simulator;
     init();
 }
Ejemplo n.º 20
0
        public void RequestTaskInventory(uint objectLocalID, Simulator simulator)
        {
            RequestTaskInventoryPacket request = new RequestTaskInventoryPacket();
            request.AgentData.AgentID = _Client.Self.AgentID;
            request.AgentData.SessionID = _Client.Self.SessionID;
            request.InventoryData.LocalID = objectLocalID;

            _Client.Network.SendPacket(request, simulator);
        }
Ejemplo n.º 21
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);
 }
Ejemplo n.º 22
0
        private void PacketHandler()
        {
            IncomingPacket incomingPacket = new IncomingPacket();
            Packet         packet         = null;
            Simulator      simulator      = null;

            while (connected)
            {
                // Reset packet to null for the check below
                packet = null;

                if (PacketInbox.Dequeue(200, ref incomingPacket))
                {
                    packet    = incomingPacket.Packet;
                    simulator = incomingPacket.Simulator;

                    if (packet != null)
                    {
                        // Skip the ACK handling on packets synthesized from CAPS messages
                        if (packet.Header.Sequence != 0)
                        {
                            #region ACK accounting
                            // TODO: Replace PacketArchive Queue<> with something more efficient

                            // Check the archives to see whether we already received this packet
                            lock (simulator.PacketArchive)
                            {
                                if (simulator.PacketArchive.Contains(packet.Header.Sequence))
                                {
                                    if (packet.Header.Resent)
                                    {
                                        Logger.DebugLog("Received resent packet #" + packet.Header.Sequence, Client);
                                    }
                                    else
                                    {
                                        Logger.Log(String.Format("Received a duplicate of packet #{0}, current type: {1}",
                                                                 packet.Header.Sequence, packet.Type), Helpers.LogLevel.Warning, Client);
                                    }

                                    // Avoid firing a callback twice for the same packet
                                    continue;
                                }
                                else
                                {
                                    // Keep the PacketArchive size within a certain capacity
                                    while (simulator.PacketArchive.Count >= Settings.PACKET_ARCHIVE_SIZE)
                                    {
                                        simulator.PacketArchive.Dequeue(); simulator.PacketArchive.Dequeue();
                                        simulator.PacketArchive.Dequeue(); simulator.PacketArchive.Dequeue();
                                    }

                                    simulator.PacketArchive.Enqueue(packet.Header.Sequence);
                                }
                            }

                            #endregion ACK accounting

                            #region ACK handling

                            // Handle appended ACKs
                            if (packet.Header.AppendedAcks)
                            {
                                lock (simulator.NeedAck)
                                {
                                    for (int i = 0; i < packet.Header.AckList.Length; i++)
                                    {
                                        simulator.NeedAck.Remove(packet.Header.AckList[i]);
                                    }
                                }
                            }

                            // Handle PacketAck packets
                            if (packet.Type == PacketType.PacketAck)
                            {
                                PacketAckPacket ackPacket = (PacketAckPacket)packet;

                                lock (simulator.NeedAck)
                                {
                                    for (int i = 0; i < ackPacket.Packets.Length; i++)
                                    {
                                        simulator.NeedAck.Remove(ackPacket.Packets[i].ID);
                                    }
                                }
                            }

                            #endregion ACK handling
                        }

                        #region FireCallbacks

                        if (Client.Settings.SYNC_PACKETCALLBACKS)
                        {
                            PacketEvents.RaiseEvent(PacketType.Default, packet, simulator);
                            PacketEvents.RaiseEvent(packet.Type, packet, simulator);
                        }
                        else
                        {
                            PacketEvents.BeginRaiseEvent(PacketType.Default, packet, simulator);
                            PacketEvents.BeginRaiseEvent(packet.Type, packet, simulator);
                        }

                        #endregion FireCallbacks
                    }
                }
            }
        }
Ejemplo n.º 23
0
 private void Network_OnEventQueueRunning(Simulator simulator)
 {
     Logger.DebugLog("Event queue is running for " + simulator.ToString() + ", enabling uploads", Client);
     EnableUpload();
 }
Ejemplo n.º 24
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);
 }
Ejemplo n.º 25
0
        private void InventoryDescendentsHandler(Packet packet, Simulator simulator)
        {
            InventoryDescendentsPacket reply = (InventoryDescendentsPacket)packet;

            if (reply.AgentData.Descendents > 0)
            {
                // InventoryDescendantsReply sends a null folder if the parent doesnt contain any folders
                if (reply.FolderData[0].FolderID != LLUUID.Zero)
                {
                    // Iterate folders in this packet
                    for (int i = 0; i < reply.FolderData.Length; i++)
                    {
                        InventoryFolder folder = new InventoryFolder(reply.FolderData[i].FolderID);
                        folder.ParentUUID = reply.FolderData[i].ParentID;
                        folder.Name = Helpers.FieldToUTF8String(reply.FolderData[i].Name);
                        folder.PreferredType = (AssetType)reply.FolderData[i].Type;
                        folder.OwnerID = reply.AgentData.OwnerID;

                        _Store[folder.UUID] = folder;
                    }
                }

                // InventoryDescendantsReply sends a null item if the parent doesnt contain any items.
                if (reply.ItemData[0].ItemID != LLUUID.Zero)
                {
                    // Iterate items in this packet
                    for (int i = 0; i < reply.ItemData.Length; i++)
                    {
                        if (reply.ItemData[i].ItemID != LLUUID.Zero)
                        {
                            InventoryItem item = CreateInventoryItem((InventoryType)reply.ItemData[i].InvType,reply.ItemData[i].ItemID);
                            item.ParentUUID = reply.ItemData[i].FolderID;
                            item.CreatorID = reply.ItemData[i].CreatorID;
                            item.AssetType = (AssetType)reply.ItemData[i].Type;
                            item.AssetUUID = reply.ItemData[i].AssetID;
                            item.CreationDate = Helpers.UnixTimeToDateTime((uint)reply.ItemData[i].CreationDate);
                            item.Description = Helpers.FieldToUTF8String(reply.ItemData[i].Description);
                            item.Flags = reply.ItemData[i].Flags;
                            item.Name = Helpers.FieldToUTF8String(reply.ItemData[i].Name);
                            item.GroupID = reply.ItemData[i].GroupID;
                            item.GroupOwned = reply.ItemData[i].GroupOwned;
                            item.Permissions = new Permissions(
                                reply.ItemData[i].BaseMask,
                                reply.ItemData[i].EveryoneMask,
                                reply.ItemData[i].GroupMask,
                                reply.ItemData[i].NextOwnerMask,
                                reply.ItemData[i].OwnerMask);
                            item.SalePrice = reply.ItemData[i].SalePrice;
                            item.SaleType = (SaleType)reply.ItemData[i].SaleType;
                            item.OwnerID = reply.AgentData.OwnerID;

                            _Store[item.UUID] = item;
                        }
                    }
                }
            }

            InventoryFolder parentFolder = null;

            if (_Store.Contains(reply.AgentData.FolderID) &&
                _Store[reply.AgentData.FolderID] is InventoryFolder)
            {
                parentFolder = _Store[reply.AgentData.FolderID] as InventoryFolder;
            }
            else
            {
                _Client.Log("Don't have a reference to FolderID " + reply.AgentData.FolderID.ToString() +
                    " or it is not a folder", Helpers.LogLevel.Error);
                return;
            }

            if (reply.AgentData.Version < parentFolder.Version)
            {
                _Client.Log("Got an outdated InventoryDescendents packet for folder " + parentFolder.Name +
                    ", this version = " + reply.AgentData.Version + ", latest version = " + parentFolder.Version,
                    Helpers.LogLevel.Warning);
                return;
            }

            parentFolder.Version = reply.AgentData.Version;
            // FIXME: reply.AgentData.Descendants is not parentFolder.DescendentCount if we didn't 
            // request items and folders
            parentFolder.DescendentCount = reply.AgentData.Descendents;

            #region FindObjectsByPath Handling

            if (_Searches.Count > 0)
            {
                lock (_Searches)
                {
                StartSearch:

                    // Iterate over all of the outstanding searches
                    for (int i = 0; i < _Searches.Count; i++)
                    {
                        InventorySearch search = _Searches[i];
                        List<InventoryBase> folderContents = _Store.GetContents(search.Folder);

                        // Iterate over all of the inventory objects in the base search folder
                        for (int j = 0; j < folderContents.Count; j++)
                        {
                            // Check if this inventory object matches the current path node
                            if (folderContents[j].Name == search.Path[search.Level])
                            {
                                if (search.Level == search.Path.Length - 1)
                                {
                                    _Client.DebugLog("Finished patch search of " + String.Join("/", search.Path));

                                    // This is the last node in the path, fire the callback and clean up
                                    if (OnFindObjectByPath != null)
                                    {
                                        try { OnFindObjectByPath(String.Join("/", search.Path), folderContents[j].UUID); }
                                        catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
                                    }

                                    // Remove this entry and restart the loop since we are changing the collection size
                                    _Searches.RemoveAt(i);
                                    goto StartSearch;
                                }
                                else
                                {
                                    // We found a match but it is not the end of the path, request the next level
                                    _Client.DebugLog(String.Format("Matched level {0}/{1} in a path search of {2}",
                                        search.Level, search.Path.Length - 1, String.Join("/", search.Path)));

                                    search.Folder = folderContents[j].UUID;
                                    search.Level++;
                                    _Searches[i] = search;

                                    RequestFolderContents(search.Folder, search.Owner, true, true, 
                                        InventorySortOrder.ByName);
                                }
                            }
                        }
                    }
                }
            }

            #endregion FindObjectsByPath Handling

            // Callback for inventory folder contents being updated
            if (OnFolderUpdated != null)
            {
                try { OnFolderUpdated(parentFolder.UUID); }
                catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
            }
        }
Ejemplo n.º 26
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;
        }
Ejemplo n.º 27
0
        private void MoveInventoryItemHandler(Packet packet, Simulator simulator)
        {
            MoveInventoryItemPacket move = (MoveInventoryItemPacket)packet;

            for (int i = 0; i < move.InventoryData.Length; i++)
            {
                // FIXME: Do something here
                string newName = Helpers.FieldToUTF8String(move.InventoryData[i].NewName);

                _Client.Log(String.Format(
                    "MoveInventoryItemHandler: Item {0} is moving to Folder {1} with new name \"{2}\". Someone write this function!",
                    move.InventoryData[i].ItemID.ToString(), move.InventoryData[i].FolderID.ToString(),
                    newName), Helpers.LogLevel.Warning);
            }
        }
Ejemplo n.º 28
0
        private void SaveAssetIntoInventoryHandler(Packet packet, Simulator simulator)
        {
            SaveAssetIntoInventoryPacket save = (SaveAssetIntoInventoryPacket)packet;

            // FIXME: Find this item in the inventory structure and mark the parent as needing an update
            //save.InventoryData.ItemID;
            _Client.Log("SaveAssetIntoInventory packet received, someone write this function!",
                Helpers.LogLevel.Error);
        }
Ejemplo n.º 29
0
        private void FetchInventoryReplyHandler(Packet packet, Simulator simulator)
        {
            FetchInventoryReplyPacket reply = packet as FetchInventoryReplyPacket;

            foreach (FetchInventoryReplyPacket.InventoryDataBlock dataBlock in reply.InventoryData) 
            {
                if (dataBlock.InvType == (sbyte)InventoryType.Folder)
                {
                    _Client.Log("Received FetchInventoryReply for an inventory folder, this should not happen!",
                        Helpers.LogLevel.Error);
                    continue;
                }

                InventoryItem item = CreateInventoryItem((InventoryType)dataBlock.InvType,dataBlock.ItemID);
                item.AssetType = (AssetType)dataBlock.Type;
                item.AssetUUID = dataBlock.AssetID;
                item.CreationDate = Helpers.UnixTimeToDateTime(dataBlock.CreationDate);
                item.CreatorID = dataBlock.CreatorID;
                item.Description = Helpers.FieldToUTF8String(dataBlock.Description);
                item.Flags = dataBlock.Flags;
                item.GroupID = dataBlock.GroupID;
                item.GroupOwned = dataBlock.GroupOwned;
                item.Name = Helpers.FieldToUTF8String(dataBlock.Name);
                item.OwnerID = dataBlock.OwnerID;
                item.ParentUUID = dataBlock.FolderID;
                item.Permissions = new Permissions(
                    dataBlock.BaseMask, 
                    dataBlock.EveryoneMask, 
                    dataBlock.GroupMask, 
                    dataBlock.NextOwnerMask, 
                    dataBlock.OwnerMask);
                item.SalePrice = dataBlock.SalePrice;
                item.SaleType = (SaleType)dataBlock.SaleType;

                _Store[item.UUID] = item;

                // Fire the callback for an item being fetched
                if (OnItemReceived != null)
                {
                    try { OnItemReceived(item); }
                    catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
                }
            }
        }
Ejemplo n.º 30
0
        /// <summary>
        /// UpdateCreateInventoryItem packets are received when a new inventory item 
        /// is created. This may occur when an object that's rezzed in world is
        /// taken into inventory, when an item is created using the CreateInventoryItem
        /// packet, or when an object is purchased
        /// </summary>
        private void UpdateCreateInventoryItemHandler(Packet packet, Simulator simulator)
        {
            UpdateCreateInventoryItemPacket reply = packet as UpdateCreateInventoryItemPacket;

            foreach (UpdateCreateInventoryItemPacket.InventoryDataBlock dataBlock in reply.InventoryData)
            {
                if (dataBlock.InvType == (sbyte)InventoryType.Folder)
                {
                    _Client.Log("Received InventoryFolder in an UpdateCreateInventoryItem packet, this should not happen!",
                        Helpers.LogLevel.Error);
                    continue;
                }

                InventoryItem item = CreateInventoryItem((InventoryType)dataBlock.InvType,dataBlock.ItemID);
                item.AssetType = (AssetType)dataBlock.Type;
                item.AssetUUID = dataBlock.AssetID;
                item.CreationDate = Helpers.UnixTimeToDateTime(dataBlock.CreationDate);
                item.CreatorID = dataBlock.CreatorID;
                item.Description = Helpers.FieldToUTF8String(dataBlock.Description);
                item.Flags = dataBlock.Flags;
                item.GroupID = dataBlock.GroupID;
                item.GroupOwned = dataBlock.GroupOwned;
                item.Name = Helpers.FieldToUTF8String(dataBlock.Name);
                item.OwnerID = dataBlock.OwnerID;
                item.ParentUUID = dataBlock.FolderID;
                item.Permissions = new Permissions(
                        dataBlock.BaseMask,
                        dataBlock.EveryoneMask,
                        dataBlock.GroupMask,
                        dataBlock.NextOwnerMask,
                        dataBlock.OwnerMask);
                item.SalePrice = dataBlock.SalePrice;
                item.SaleType = (SaleType)dataBlock.SaleType;

                // Update the local copy
                _Store[item.UUID] = item;

                // Look for an "item created" callback
                ItemCreatedCallback createdCallback;
                if (_ItemCreatedCallbacks.TryGetValue(dataBlock.CallbackID, out createdCallback))
                {
                    _ItemCreatedCallbacks.Remove(dataBlock.CallbackID);

                    try { createdCallback(true, item); }
                    catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
                }

                // TODO: Is this callback even triggered when items are copied?
                // Look for an "item copied" callback
                ItemCopiedCallback copyCallback;
                if (_ItemCopiedCallbacks.TryGetValue(dataBlock.CallbackID, out copyCallback))
                {
                    _ItemCopiedCallbacks.Remove(dataBlock.CallbackID);

                    try { copyCallback(item); }
                    catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
                }
                
                //This is triggered when an item is received from a task
                if (OnTaskItemReceived != null)
                {
                    try { OnTaskItemReceived(item.UUID, dataBlock.FolderID, item.CreatorID, item.AssetUUID, 
                        item.InventoryType); }
                    catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
                }
            }
        }
Ejemplo n.º 31
0
        private void Self_OnInstantMessage(InstantMessage im, Simulator simulator)
        {
            // TODO: MainAvatar.InstantMessageDialog.GroupNotice can also be an inventory offer, should we
            // handle it here?

            if (OnObjectOffered != null && 
                (im.Dialog == InstantMessageDialog.InventoryOffered || im.Dialog == InstantMessageDialog.TaskInventoryOffered))
            {
                AssetType type = AssetType.Unknown;
                LLUUID objectID = LLUUID.Zero;
                bool fromTask = false;

                if (im.Dialog == InstantMessageDialog.InventoryOffered)
                {
                    if (im.BinaryBucket.Length == 17)
                    {
                        type = (AssetType)im.BinaryBucket[0];
                        objectID = new LLUUID(im.BinaryBucket, 1);
                        fromTask = false;
                    }
                    else
                    {
                        _Client.Log("Malformed inventory offer from agent", Helpers.LogLevel.Warning);
                        return;
                    }
                }
                else if (im.Dialog == InstantMessageDialog.TaskInventoryOffered)
                {
                    if (im.BinaryBucket.Length == 1)
                    {
                        type = (AssetType)im.BinaryBucket[0];
                        fromTask = true;
                    }
                    else
                    {
                        _Client.Log("Malformed inventory offer from object", Helpers.LogLevel.Warning);
                        return;
                    }
                }

                // Find the folder where this is going to go
                LLUUID destinationFolderID = FindFolderForType(type);

                // Fire the callback
                try
                {
                    ImprovedInstantMessagePacket imp = new ImprovedInstantMessagePacket();
                    imp.AgentData.AgentID = _Client.Self.AgentID;
                    imp.AgentData.SessionID = _Client.Self.SessionID;
                    imp.MessageBlock.FromGroup = false;
                    imp.MessageBlock.ToAgentID = im.FromAgentID;
                    imp.MessageBlock.Offline = 0;
                    imp.MessageBlock.ID = im.IMSessionID;
                    imp.MessageBlock.Timestamp = 0;
                    imp.MessageBlock.FromAgentName = Helpers.StringToField(_Client.Self.Name);
                    imp.MessageBlock.Message = new byte[0];
                    imp.MessageBlock.ParentEstateID = 0;
                    imp.MessageBlock.RegionID = LLUUID.Zero;
                    imp.MessageBlock.Position = _Client.Self.SimPosition;

                    if (OnObjectOffered(im.FromAgentID, im.FromAgentName, im.ParentEstateID, im.RegionID, im.Position,
                        im.Timestamp, type, objectID, fromTask))
                    {
                        // Accept the inventory offer
                        switch (im.Dialog)
                        {
                            case InstantMessageDialog.InventoryOffered:
                                imp.MessageBlock.Dialog = (byte)InstantMessageDialog.InventoryAccepted;
                                break;
                            case InstantMessageDialog.TaskInventoryOffered:
                                imp.MessageBlock.Dialog = (byte)InstantMessageDialog.TaskInventoryAccepted;
                                break;
                            case InstantMessageDialog.GroupNotice:
                                imp.MessageBlock.Dialog = (byte)InstantMessageDialog.GroupNoticeInventoryAccepted;
                                break;
                        }

                        imp.MessageBlock.BinaryBucket = destinationFolderID.GetBytes();
                    }
                    else
                    {
                        // Decline the inventory offer
                        switch (im.Dialog)
                        {
                            case InstantMessageDialog.InventoryOffered:
                                imp.MessageBlock.Dialog = (byte)InstantMessageDialog.InventoryDeclined;
                                break;
                            case InstantMessageDialog.TaskInventoryOffered:
                                imp.MessageBlock.Dialog = (byte)InstantMessageDialog.TaskInventoryDeclined;
                                break;
                            case InstantMessageDialog.GroupNotice:
                                imp.MessageBlock.Dialog = (byte)InstantMessageDialog.GroupNoticeInventoryDeclined;
                                break;
                        }

                        imp.MessageBlock.BinaryBucket = new byte[0];
                    }

                    _Client.Network.SendPacket(imp, simulator);
                }
                catch (Exception e)
                {
                    _Client.Log(e.ToString(), Helpers.LogLevel.Error);
                }
            }
        }
Ejemplo n.º 32
0
        private void BulkUpdateInventoryHandler(Packet packet, Simulator simulator)
        {
            BulkUpdateInventoryPacket update = packet as BulkUpdateInventoryPacket;

            if (update.FolderData.Length > 0 && update.FolderData[0].FolderID != LLUUID.Zero)
            {
                foreach (BulkUpdateInventoryPacket.FolderDataBlock dataBlock in update.FolderData)
                {
                    if (!_Store.Contains(dataBlock.FolderID))
                        _Client.Log("Received BulkUpdate for unknown folder: " + dataBlock.FolderID, Helpers.LogLevel.Warning);

                    InventoryFolder folder = new InventoryFolder(dataBlock.FolderID);
                    folder.Name = Helpers.FieldToUTF8String(dataBlock.Name);
                    folder.OwnerID = update.AgentData.AgentID;
                    folder.ParentUUID = dataBlock.ParentID;
                    _Store[folder.UUID] = folder;
                }
            }

            if (update.ItemData.Length > 0 && update.ItemData[0].ItemID != LLUUID.Zero)
            {
                for (int i = 0; i < update.ItemData.Length; i++)
                {
                    BulkUpdateInventoryPacket.ItemDataBlock dataBlock = update.ItemData[i];

                    if (!_Store.Contains(dataBlock.ItemID))
                        _Client.Log("Received BulkUpdate for unknown item: " + dataBlock.ItemID, Helpers.LogLevel.Warning);

                    InventoryItem item = SafeCreateInventoryItem((InventoryType)dataBlock.InvType, dataBlock.ItemID);

                    item.AssetType = (AssetType)dataBlock.Type;
                    if (dataBlock.AssetID != LLUUID.Zero) item.AssetUUID = dataBlock.AssetID;
                    item.CreationDate = Helpers.UnixTimeToDateTime(dataBlock.CreationDate);
                    item.CreatorID = dataBlock.CreatorID;
                    item.Description = Helpers.FieldToUTF8String(dataBlock.Description);
                    item.Flags = dataBlock.Flags;
                    item.GroupID = dataBlock.GroupID;
                    item.GroupOwned = dataBlock.GroupOwned;
                    item.Name = Helpers.FieldToUTF8String(dataBlock.Name);
                    item.OwnerID = dataBlock.OwnerID;
                    item.ParentUUID = dataBlock.FolderID;
                    item.Permissions = new Permissions(
                        dataBlock.BaseMask,
                        dataBlock.EveryoneMask,
                        dataBlock.GroupMask,
                        dataBlock.NextOwnerMask,
                        dataBlock.OwnerMask);
                    item.SalePrice = dataBlock.SalePrice;
                    item.SaleType = (SaleType)dataBlock.SaleType;

                    _Store[item.UUID] = item;

                    // Look for an "item created" callback
                    ItemCreatedCallback callback;
                    if (_ItemCreatedCallbacks.TryGetValue(dataBlock.CallbackID, out callback))
                    {
                        _ItemCreatedCallbacks.Remove(dataBlock.CallbackID);

                        try { callback(true, item); }
                        catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
                    }

                    // Look for an "item copied" callback
                    ItemCopiedCallback copyCallback;
                    if (_ItemCopiedCallbacks.TryGetValue(dataBlock.CallbackID, out copyCallback))
                    {
                        _ItemCopiedCallbacks.Remove(dataBlock.CallbackID);

                        try { copyCallback(item); }
                        catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
                    }
                }
            }
        }
Ejemplo n.º 33
0
        private void DisableSimulatorHandler(Packet packet, Simulator simulator)
        {
            Logger.DebugLog("Received a DisableSimulator packet from " + simulator + ", shutting it down", Client);

            DisconnectSim(simulator, false);
        }
Ejemplo n.º 34
0
        private void ReplyTaskInventoryHandler(Packet packet, Simulator simulator)
        {
            if (OnTaskInventoryReply != null)
            {
                ReplyTaskInventoryPacket reply = (ReplyTaskInventoryPacket)packet;

                try
                {
                    OnTaskInventoryReply(reply.InventoryData.TaskID, reply.InventoryData.Serial,
                        Helpers.FieldToUTF8String(reply.InventoryData.Filename));
                }
                catch (Exception e) { _Client.Log(e.ToString(), Helpers.LogLevel.Error); }
            }
        }
Ejemplo n.º 35
0
        private void SimStatsHandler(Packet packet, Simulator simulator)
        {
            if (!Client.Settings.ENABLE_SIMSTATS)
            {
                return;
            }
            SimStatsPacket stats = (SimStatsPacket)packet;

            for (int i = 0; i < stats.Stat.Length; i++)
            {
                SimStatsPacket.StatBlock s = stats.Stat[i];
                switch (s.StatID)
                {
                case 0:
                    simulator.Stats.Dilation = s.StatValue;
                    break;

                case 1:
                    simulator.Stats.FPS = Convert.ToInt32(s.StatValue);
                    break;

                case 2:
                    simulator.Stats.PhysicsFPS = s.StatValue;
                    break;

                case 3:
                    simulator.Stats.AgentUpdates = s.StatValue;
                    break;

                case 4:
                    simulator.Stats.FrameTime = s.StatValue;
                    break;

                case 5:
                    simulator.Stats.NetTime = s.StatValue;
                    break;

                case 6:
                    simulator.Stats.OtherTime = s.StatValue;
                    break;

                case 7:
                    simulator.Stats.PhysicsTime = s.StatValue;
                    break;

                case 8:
                    simulator.Stats.AgentTime = s.StatValue;
                    break;

                case 9:
                    simulator.Stats.ImageTime = s.StatValue;
                    break;

                case 10:
                    simulator.Stats.ScriptTime = s.StatValue;
                    break;

                case 11:
                    simulator.Stats.Objects = Convert.ToInt32(s.StatValue);
                    break;

                case 12:
                    simulator.Stats.ScriptedObjects = Convert.ToInt32(s.StatValue);
                    break;

                case 13:
                    simulator.Stats.Agents = Convert.ToInt32(s.StatValue);
                    break;

                case 14:
                    simulator.Stats.ChildAgents = Convert.ToInt32(s.StatValue);
                    break;

                case 15:
                    simulator.Stats.ActiveScripts = Convert.ToInt32(s.StatValue);
                    break;

                case 16:
                    simulator.Stats.LSLIPS = Convert.ToInt32(s.StatValue);
                    break;

                case 17:
                    simulator.Stats.INPPS = Convert.ToInt32(s.StatValue);
                    break;

                case 18:
                    simulator.Stats.OUTPPS = Convert.ToInt32(s.StatValue);
                    break;

                case 19:
                    simulator.Stats.PendingDownloads = Convert.ToInt32(s.StatValue);
                    break;

                case 20:
                    simulator.Stats.PendingUploads = Convert.ToInt32(s.StatValue);
                    break;

                case 21:
                    simulator.Stats.VirtualSize = Convert.ToInt32(s.StatValue);
                    break;

                case 22:
                    simulator.Stats.ResidentSize = Convert.ToInt32(s.StatValue);
                    break;

                case 23:
                    simulator.Stats.PendingLocalUploads = Convert.ToInt32(s.StatValue);
                    break;

                case 24:
                    simulator.Stats.UnackedBytes = Convert.ToInt32(s.StatValue);
                    break;
                }
            }
        }
Ejemplo n.º 36
0
 static void client_OnEventQueueRunning(Simulator sim) {
     EventQueueRunningEvent.Set();
 }
Ejemplo n.º 37
0
        private void MapItemReplyHandler(Packet packet, Simulator simulator)
        {
            if (OnGridItems != null)
            {
                MapItemReplyPacket reply = (MapItemReplyPacket)packet;
                GridItemType       type  = (GridItemType)reply.RequestData.ItemType;
                List <GridItem>    items = new List <GridItem>();

                for (int i = 0; i < reply.Data.Length; i++)
                {
                    string name = Helpers.FieldToUTF8String(reply.Data[i].Name);

                    switch (type)
                    {
                    case GridItemType.AgentLocations:
                        GridAgentLocation location = new GridAgentLocation();
                        location.GlobalX     = reply.Data[i].X;
                        location.GlobalY     = reply.Data[i].Y;
                        location.Identifier  = name;
                        location.AvatarCount = reply.Data[i].Extra;

                        items.Add(location);

                        break;

                    case GridItemType.Classified:
                        //FIXME:
                        Client.Log("FIXME", Helpers.LogLevel.Error);
                        break;

                    case GridItemType.LandForSale:
                        //FIXME:
                        Client.Log("FIXME", Helpers.LogLevel.Error);
                        break;

                    case GridItemType.MatureEvent:
                    case GridItemType.PgEvent:
                        //FIXME:
                        Client.Log("FIXME", Helpers.LogLevel.Error);
                        break;

                    case GridItemType.Popular:
                        //FIXME:
                        Client.Log("FIXME", Helpers.LogLevel.Error);
                        break;

                    case GridItemType.Telehub:
                        //FIXME:
                        Client.Log("FIXME", Helpers.LogLevel.Error);
                        break;

                    default:
                        Client.Log("Unknown map item type " + type, Helpers.LogLevel.Warning);
                        break;
                    }
                }

                try { OnGridItems(type, items); }
                catch (Exception e) { Client.Log(e.ToString(), Helpers.LogLevel.Error); }
            }
        }