Example #1
0
        void ObjectSelectHandler(Packet packet, Agent agent)
        {
            ObjectSelectPacket select = (ObjectSelectPacket)packet;

            for (int i = 0; i < select.ObjectData.Length; i++)
            {
                ObjectPropertiesPacket properties = new ObjectPropertiesPacket();
                properties.ObjectData    = new ObjectPropertiesPacket.ObjectDataBlock[1];
                properties.ObjectData[0] = new ObjectPropertiesPacket.ObjectDataBlock();

                SimulationObject obj;
                if (server.Scene.TryGetObject(select.ObjectData[i].ObjectLocalID, out obj))
                {
                    //Logger.DebugLog("Selecting object " + obj.Prim.LocalID);

                    properties.ObjectData[0].BaseMask      = (uint)obj.Prim.Properties.Permissions.BaseMask;
                    properties.ObjectData[0].CreationDate  = Utils.DateTimeToUnixTime(obj.Prim.Properties.CreationDate);
                    properties.ObjectData[0].CreatorID     = obj.Prim.Properties.CreatorID;
                    properties.ObjectData[0].Description   = Utils.StringToBytes(obj.Prim.Properties.Description);
                    properties.ObjectData[0].EveryoneMask  = (uint)obj.Prim.Properties.Permissions.EveryoneMask;
                    properties.ObjectData[0].GroupID       = obj.Prim.Properties.GroupID;
                    properties.ObjectData[0].GroupMask     = (uint)obj.Prim.Properties.Permissions.GroupMask;
                    properties.ObjectData[0].LastOwnerID   = obj.Prim.Properties.LastOwnerID;
                    properties.ObjectData[0].Name          = Utils.StringToBytes(obj.Prim.Properties.Name);
                    properties.ObjectData[0].NextOwnerMask = (uint)obj.Prim.Properties.Permissions.NextOwnerMask;
                    properties.ObjectData[0].ObjectID      = obj.Prim.ID;
                    properties.ObjectData[0].OwnerID       = obj.Prim.Properties.OwnerID;
                    properties.ObjectData[0].OwnerMask     = (uint)obj.Prim.Properties.Permissions.OwnerMask;
                    properties.ObjectData[0].OwnershipCost = obj.Prim.Properties.OwnershipCost;
                    properties.ObjectData[0].SalePrice     = obj.Prim.Properties.SalePrice;
                    properties.ObjectData[0].SaleType      = (byte)obj.Prim.Properties.SaleType;
                    properties.ObjectData[0].SitName       = new byte[0];
                    properties.ObjectData[0].TextureID     = new byte[0];
                    properties.ObjectData[0].TouchName     = new byte[0];

                    server.UDP.SendPacket(agent.AgentID, properties, PacketCategory.Transaction);
                }
                else
                {
                    Logger.Log("ObjectSelect sent for missing object " + select.ObjectData[i].ObjectLocalID,
                               Helpers.LogLevel.Warning);

                    properties.ObjectData[0].Description = new byte[0];
                    properties.ObjectData[0].Name        = new byte[0];
                    properties.ObjectData[0].SitName     = new byte[0];
                    properties.ObjectData[0].TextureID   = new byte[0];
                    properties.ObjectData[0].TouchName   = new byte[0];

                    KillObjectPacket kill = new KillObjectPacket();
                    kill.ObjectData       = new KillObjectPacket.ObjectDataBlock[1];
                    kill.ObjectData[0]    = new KillObjectPacket.ObjectDataBlock();
                    kill.ObjectData[0].ID = select.ObjectData[i].ObjectLocalID;
                    server.UDP.SendPacket(agent.AgentID, kill, PacketCategory.State);
                }
            }
        }
Example #2
0
        /// <summary>
        /// Select multiple objects. This will cause the <see cref="Simulator"/> to send us 
        /// an <see cref="ObjectPropertiesPacket"/> which will raise the <see cref="ObjectProperties"/> event
        /// </summary>        
        /// <param name="simulator">The <see cref="Simulator"/> the objects are located</param> 
        /// <param name="localIDs">An array containing the Local IDs of the objects</param>
        /// <param name="automaticDeselect">Should objects be deselected immediately after selection</param>
        /// <seealso cref="ObjectPropertiesFamilyEventArgs"/>
        public void SelectObjects(Simulator simulator, uint[] localIDs, bool automaticDeselect)
        {
            ObjectSelectPacket select = new ObjectSelectPacket();

            select.AgentData.AgentID = Client.Self.AgentID;
            select.AgentData.SessionID = Client.Self.SessionID;

            select.ObjectData = new ObjectSelectPacket.ObjectDataBlock[localIDs.Length];

            for (int i = 0; i < localIDs.Length; i++)
            {
                select.ObjectData[i] = new ObjectSelectPacket.ObjectDataBlock();
                select.ObjectData[i].ObjectLocalID = localIDs[i];
            }

            Client.Network.SendPacket(select, simulator);

            if (automaticDeselect)
            {
                DeselectObjects(simulator, localIDs);
            }
        }
Example #3
0
        /// <summary>
        /// Select a single object. This will cause the <see cref="Simulator"/> to send us 
        /// an <see cref="ObjectPropertiesPacket"/> which will raise the <see cref="ObjectProperties"/> event
        /// </summary>
        /// <param name="simulator">The <see cref="Simulator"/> the object is located</param>
        /// <param name="localID">The Local ID of the object</param>
        /// <param name="automaticDeselect">if true, a call to <see cref="DeselectObject"/> is
        /// made immediately following the request</param>
        /// <seealso cref="ObjectPropertiesFamilyEventArgs"/>
        public void SelectObject(Simulator simulator, uint localID, bool automaticDeselect)
        {
            ObjectSelectPacket select = new ObjectSelectPacket();

            select.AgentData.AgentID = Client.Self.AgentID;
            select.AgentData.SessionID = Client.Self.SessionID;

            select.ObjectData = new ObjectSelectPacket.ObjectDataBlock[1];
            select.ObjectData[0] = new ObjectSelectPacket.ObjectDataBlock();
            select.ObjectData[0].ObjectLocalID = localID;

            Client.Network.SendPacket(select, simulator);

            if (automaticDeselect)
            {
                DeselectObject(simulator, localID);
            }
        }
Example #4
0
        protected virtual void ProcessInPacket(Packet Pack)
        {
            ack_pack(Pack);
            if (debug)
            {
                if (Pack.Type != PacketType.AgentUpdate)
                {
                    Console.WriteLine(Pack.Type.ToString());
                }
            }

            if (this.ProcessPacketMethod(Pack))
            {
                //there is a handler registered that handled this packet type
                return;
            }
            else
            {
                System.Text.Encoding _enc = System.Text.Encoding.ASCII;

                switch (Pack.Type)
                {
                case PacketType.CompleteAgentMovement:
                    if (this.m_child)
                    {
                        this.UpgradeClient();
                    }
                    ClientAvatar.CompleteMovement(m_world);
                    ClientAvatar.SendInitialPosition();
                    break;

                case PacketType.RegionHandshakeReply:
                    m_world.SendLayerData(this);
                    break;

                case PacketType.AgentWearablesRequest:
                    ClientAvatar.SendInitialAppearance();
                    foreach (SimClient client in m_clientThreads.Values)
                    {
                        if (client.AgentID != this.AgentID)
                        {
                            ObjectUpdatePacket objupdate = client.ClientAvatar.CreateUpdatePacket();
                            this.OutPacket(objupdate);
                            client.ClientAvatar.SendAppearanceToOtherAgent(this);
                        }
                    }
                    m_world.GetInitialPrims(this);
                    break;

                case PacketType.AgentIsNowWearing:
                    AgentIsNowWearingPacket wear = (AgentIsNowWearingPacket)Pack;
                    //Console.WriteLine(Pack.ToString());
                    break;

                case PacketType.AgentSetAppearance:
                    AgentSetAppearancePacket appear = (AgentSetAppearancePacket)Pack;
                    // Console.WriteLine(appear.ToString());
                    this.ClientAvatar.SetAppearance(appear);
                    break;

                case PacketType.ObjectAdd:
                    m_world.AddNewPrim((ObjectAddPacket)Pack, this);
                    break;

                case PacketType.ObjectLink:
                    OpenSim.Framework.Console.MainConsole.Instance.WriteLine(Pack.ToString());
                    ObjectLinkPacket        link         = (ObjectLinkPacket)Pack;
                    uint                    parentprimid = 0;
                    OpenSim.world.Primitive parentprim   = null;
                    if (link.ObjectData.Length > 1)
                    {
                        parentprimid = link.ObjectData[0].ObjectLocalID;
                        foreach (Entity ent in m_world.Entities.Values)
                        {
                            if (ent.localid == parentprimid)
                            {
                                parentprim = (OpenSim.world.Primitive)ent;
                            }
                        }
                        for (int i = 1; i < link.ObjectData.Length; i++)
                        {
                            foreach (Entity ent in m_world.Entities.Values)
                            {
                                if (ent.localid == link.ObjectData[i].ObjectLocalID)
                                {
                                    ((OpenSim.world.Primitive)ent).MakeParent(parentprim);
                                }
                            }
                        }
                    }
                    break;

                case PacketType.ObjectScale:
                    OpenSim.Framework.Console.MainConsole.Instance.WriteLine(Pack.ToString());
                    break;

                case PacketType.ObjectShape:
                    ObjectShapePacket shape = (ObjectShapePacket)Pack;
                    for (int i = 0; i < shape.ObjectData.Length; i++)
                    {
                        foreach (Entity ent in m_world.Entities.Values)
                        {
                            if (ent.localid == shape.ObjectData[i].ObjectLocalID)
                            {
                                ((OpenSim.world.Primitive)ent).UpdateShape(shape.ObjectData[i]);
                            }
                        }
                    }
                    break;

                case PacketType.RequestImage:
                    RequestImagePacket imageRequest = (RequestImagePacket)Pack;
                    for (int i = 0; i < imageRequest.RequestImage.Length; i++)
                    {
                        m_assetCache.AddTextureRequest(this, imageRequest.RequestImage[i].Image);
                    }
                    break;

                case PacketType.TransferRequest:
                    //Console.WriteLine("OpenSimClient.cs:ProcessInPacket() - Got transfer request");
                    TransferRequestPacket transfer = (TransferRequestPacket)Pack;
                    m_assetCache.AddAssetRequest(this, transfer);
                    break;

                case PacketType.AgentUpdate:
                    ClientAvatar.HandleUpdate((AgentUpdatePacket)Pack);
                    break;

                case PacketType.ObjectImage:
                    ObjectImagePacket imagePack = (ObjectImagePacket)Pack;
                    for (int i = 0; i < imagePack.ObjectData.Length; i++)
                    {
                        foreach (Entity ent in m_world.Entities.Values)
                        {
                            if (ent.localid == imagePack.ObjectData[i].ObjectLocalID)
                            {
                                ((OpenSim.world.Primitive)ent).UpdateTexture(imagePack.ObjectData[i].TextureEntry);
                            }
                        }
                    }
                    break;

                case PacketType.ObjectFlagUpdate:
                    ObjectFlagUpdatePacket flags = (ObjectFlagUpdatePacket)Pack;
                    foreach (Entity ent in m_world.Entities.Values)
                    {
                        if (ent.localid == flags.AgentData.ObjectLocalID)
                        {
                            ((OpenSim.world.Primitive)ent).UpdateObjectFlags(flags);
                        }
                    }
                    break;

                case PacketType.AssetUploadRequest:
                    AssetUploadRequestPacket request = (AssetUploadRequestPacket)Pack;
                    this.UploadAssets.HandleUploadPacket(request, request.AssetBlock.TransactionID.Combine(this.SecureSessionID));
                    break;

                case PacketType.RequestXfer:
                    //Console.WriteLine(Pack.ToString());
                    break;

                case PacketType.SendXferPacket:
                    this.UploadAssets.HandleXferPacket((SendXferPacketPacket)Pack);
                    break;

                case PacketType.CreateInventoryFolder:
                    CreateInventoryFolderPacket invFolder = (CreateInventoryFolderPacket)Pack;
                    m_inventoryCache.CreateNewInventoryFolder(this, invFolder.FolderData.FolderID, (ushort)invFolder.FolderData.Type, Util.FieldToString(invFolder.FolderData.Name), invFolder.FolderData.ParentID);
                    //Console.WriteLine(Pack.ToString());
                    break;

                case PacketType.CreateInventoryItem:
                    //Console.WriteLine(Pack.ToString());
                    CreateInventoryItemPacket createItem = (CreateInventoryItemPacket)Pack;
                    if (createItem.InventoryBlock.TransactionID != LLUUID.Zero)
                    {
                        this.UploadAssets.CreateInventoryItem(createItem);
                    }
                    else
                    {
                        // Console.Write(Pack.ToString());
                        this.CreateInventoryItem(createItem);
                    }
                    break;

                case PacketType.FetchInventory:
                    //Console.WriteLine("fetch item packet");
                    FetchInventoryPacket FetchInventory = (FetchInventoryPacket)Pack;
                    m_inventoryCache.FetchInventory(this, FetchInventory);
                    break;

                case PacketType.FetchInventoryDescendents:
                    FetchInventoryDescendentsPacket Fetch = (FetchInventoryDescendentsPacket)Pack;
                    m_inventoryCache.FetchInventoryDescendents(this, Fetch);
                    break;

                case PacketType.UpdateInventoryItem:
                    UpdateInventoryItemPacket update = (UpdateInventoryItemPacket)Pack;
                    //Console.WriteLine(Pack.ToString());
                    for (int i = 0; i < update.InventoryData.Length; i++)
                    {
                        if (update.InventoryData[i].TransactionID != LLUUID.Zero)
                        {
                            AssetBase asset = m_assetCache.GetAsset(update.InventoryData[i].TransactionID.Combine(this.SecureSessionID));
                            if (asset != null)
                            {
                                // Console.WriteLine("updating inventory item, found asset" + asset.FullID.ToStringHyphenated() + " already in cache");
                                m_inventoryCache.UpdateInventoryItemAsset(this, update.InventoryData[i].ItemID, asset);
                            }
                            else
                            {
                                asset = this.UploadAssets.AddUploadToAssetCache(update.InventoryData[i].TransactionID);
                                if (asset != null)
                                {
                                    //Console.WriteLine("updating inventory item, adding asset" + asset.FullID.ToStringHyphenated() + " to cache");
                                    m_inventoryCache.UpdateInventoryItemAsset(this, update.InventoryData[i].ItemID, asset);
                                }
                                else
                                {
                                    //Console.WriteLine("trying to update inventory item, but asset is null");
                                }
                            }
                        }
                        else
                        {
                            m_inventoryCache.UpdateInventoryItemDetails(this, update.InventoryData[i].ItemID, update.InventoryData[i]);;
                        }
                    }
                    break;

                case PacketType.ViewerEffect:
                    ViewerEffectPacket viewer = (ViewerEffectPacket)Pack;
                    foreach (SimClient client in m_clientThreads.Values)
                    {
                        if (client.AgentID != this.AgentID)
                        {
                            viewer.AgentData.AgentID   = client.AgentID;
                            viewer.AgentData.SessionID = client.SessionID;
                            client.OutPacket(viewer);
                        }
                    }
                    break;

                case PacketType.RequestTaskInventory:
                    // Console.WriteLine(Pack.ToString());
                    RequestTaskInventoryPacket requesttask = (RequestTaskInventoryPacket)Pack;
                    ReplyTaskInventoryPacket   replytask   = new ReplyTaskInventoryPacket();
                    bool foundent = false;
                    foreach (Entity ent in m_world.Entities.Values)
                    {
                        if (ent.localid == requesttask.InventoryData.LocalID)
                        {
                            replytask.InventoryData.TaskID   = ent.uuid;
                            replytask.InventoryData.Serial   = 0;
                            replytask.InventoryData.Filename = new byte[0];
                            foundent = true;
                        }
                    }
                    if (foundent)
                    {
                        this.OutPacket(replytask);
                    }
                    break;

                case PacketType.UpdateTaskInventory:
                    // Console.WriteLine(Pack.ToString());
                    UpdateTaskInventoryPacket updatetask  = (UpdateTaskInventoryPacket)Pack;
                    AgentInventory            myinventory = this.m_inventoryCache.GetAgentsInventory(this.AgentID);
                    if (myinventory != null)
                    {
                        if (updatetask.UpdateData.Key == 0)
                        {
                            if (myinventory.InventoryItems[updatetask.InventoryData.ItemID] != null)
                            {
                                if (myinventory.InventoryItems[updatetask.InventoryData.ItemID].Type == 7)
                                {
                                    LLUUID    noteaid = myinventory.InventoryItems[updatetask.InventoryData.ItemID].AssetID;
                                    AssetBase assBase = this.m_assetCache.GetAsset(noteaid);
                                    if (assBase != null)
                                    {
                                        foreach (Entity ent in m_world.Entities.Values)
                                        {
                                            if (ent.localid == updatetask.UpdateData.LocalID)
                                            {
                                                if (ent is OpenSim.world.Primitive)
                                                {
                                                    this.m_world.AddScript(ent, Util.FieldToString(assBase.Data));
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                    break;

                case PacketType.AgentAnimation:
                    if (!m_child)
                    {
                        AgentAnimationPacket AgentAni = (AgentAnimationPacket)Pack;
                        for (int i = 0; i < AgentAni.AnimationList.Length; i++)
                        {
                            if (AgentAni.AnimationList[i].StartAnim)
                            {
                                ClientAvatar.current_anim = AgentAni.AnimationList[i].AnimID;
                                ClientAvatar.anim_seq     = 1;
                                ClientAvatar.SendAnimPack();
                            }
                        }
                    }
                    break;

                case PacketType.ObjectSelect:
                    ObjectSelectPacket incomingselect = (ObjectSelectPacket)Pack;
                    for (int i = 0; i < incomingselect.ObjectData.Length; i++)
                    {
                        foreach (Entity ent in m_world.Entities.Values)
                        {
                            if (ent.localid == incomingselect.ObjectData[i].ObjectLocalID)
                            {
                                ((OpenSim.world.Primitive)ent).GetProperites(this);
                                break;
                            }
                        }
                    }
                    break;
                }
            }
        }
Example #5
0
        /// <summary>
        /// Select an object. This will trigger the simulator to send us back 
        /// an ObjectProperties packet so we can get the full information for
        /// this object
        /// </summary>
        /// <param name="simulator">Simulator where the object resides</param>
        /// <param name="localID">Sim-local ID of the object to select</param>
        public void SelectObject(Simulator simulator, uint localID)
        {
            ObjectSelectPacket select = new ObjectSelectPacket();

            select.AgentData.AgentID = Client.Network.AgentID;
            select.AgentData.SessionID = Client.Network.SessionID;

            select.ObjectData = new ObjectSelectPacket.ObjectDataBlock[1];
            select.ObjectData[0] = new ObjectSelectPacket.ObjectDataBlock();
            select.ObjectData[0].ObjectLocalID = localID;

            Client.Network.SendPacket(select, simulator);
        }