C# OpenMetaverse.Simulator类代码示例

        void Objects_OnNewAvatar(Simulator simulator, Avatar avatar, ulong regionHandle, ushort timeDilation)
        {
            if (enabled)
            {
                // Search this avatar for textures
                for (int i = 0; i < avatar.Textures.FaceTextures.Length; i++)
                {
                    Primitive.TextureEntryFace face = avatar.Textures.FaceTextures[i];

                    if (face != null)
                    {
                        if (!alreadyRequested.ContainsKey(face.TextureID))
                        {
                            alreadyRequested[face.TextureID] = face.TextureID;

                            // Determine if this is a baked outfit texture or a normal texture
                            ImageType type = ImageType.Normal;
                            AppearanceManager.TextureIndex index = (AppearanceManager.TextureIndex)i;
                            switch (index)
                            {
                                case AppearanceManager.TextureIndex.EyesBaked:
                                case AppearanceManager.TextureIndex.HeadBaked:
                                case AppearanceManager.TextureIndex.LowerBaked:
                                case AppearanceManager.TextureIndex.SkirtBaked:
                                case AppearanceManager.TextureIndex.UpperBaked:
                                    type = ImageType.Baked;
                                    break;
                            }

                            Client.Assets.RequestImage(face.TextureID, type);
                        }
                    }
                }
            }
        }

 public void SendPacket(Packet packet, Simulator sim)
 {
     if (OnPacketSent != null)
     {
         OnPacketSent(packet, sim);
     }
 }

 public void Objects_OnObjectProperties11(Simulator simulator, Primitive prim, Primitive.ObjectProperties props)
 {
     //Primitive prim = GetPrimitive(props.ObjectID, simulator);
     if (prim == null)
     {
         prim = GetPrimitive(props.ObjectID, simulator);
     }
     DeclareProperties(prim, props, simulator);
     if (prim != null)
     {
         prim.RegionHandle = simulator.Handle;
         SimObject updateMe = GetSimObject(prim, simulator);
         if (updateMe == null)
         {
             return;
         }
         if (prim.ParentID == 0 && !SimRegion.OutOfRegion(prim.Position))
         {
             updateMe.ResetPrim(prim, client, simulator);
         }
         if (MaintainObjectProperties)
         {
             //updateMe.Properties = null;
             updateMe.Properties = (props);
         }
         //Debug("UpdateProperties: {0}", updateMe.DebugInfo());
         describePrimToAI(prim, simulator);
     }
 }

        /// <summary>
        /// Default constructor
        /// </summary>
        /// <param name="simulator"></param>
        /// <param name="seedcaps"></param>
        internal Caps(Simulator simulator, string seedcaps)
        {
            Simulator = simulator;
            _SeedCapsURI = seedcaps;

            MakeSeedRequest();
        }

        private void ProcessAnimationsPacket(Packet packet, Simulator simulator)
        {
            if (!(packet is AvatarAnimationPacket))
                return;

            AvatarAnimationPacket animation = (AvatarAnimationPacket)packet;

            SimData simData;
            if (!Ox.DataStore.World.SimCollection.TryGet(simulator.ID.ToString(), out simData))
                return;

            ObjectData objectData;
            if (!simData.TryGet(animation.Sender.ID.ToString(), out objectData))
                return;

            if (!(objectData is AvatarData))
                return;

            AvatarData avatarData = objectData as AvatarData;

            List<AvatarData.Animation> anims = new List<AvatarData.Animation>();
            foreach (AvatarAnimationPacket.AnimationListBlock block in animation.AnimationList)
                anims.Add(new AvatarData.Animation(block.AnimID.ToString(), block.AnimSequenceID));
            avatarData.UpdateAnimation(anims.ToArray());

            string msg = JsonUtil.SerializeMessage(JsonType.ObjectUpdated, new JsonObjectUpdated(
                simulator.ID.ToString(),
                animation.Sender.ID.ToString(),
                (int)JsonObjectUpdated.PrimType.Avatar,
                (int)JsonObjectUpdated.Type.UpdateAnimation
                ));
            Ox.EventFire(msg, true);
        }

        public ntfPermissions(RadegastInstance instance, Simulator simulator, UUID taskID, UUID itemID, string objectName, string objectOwner, ScriptPermission questions)
            : base(NotificationType.PermissionsRequest)
        {
            InitializeComponent();

            this.instance = instance;
            this.simulator = simulator;
            this.taskID = taskID;
            this.itemID = itemID;
            this.objectName = objectName;
            this.objectOwner = objectOwner;
            this.questions = questions;

            txtMessage.BackColor = instance.MainForm.NotificationBackground;
            txtMessage.Text = "Object " + objectName + " owned by " + objectOwner + " is asking permission to " + questions.ToString() + ". Do you accept?";

            // Fire off event
            NotificationEventArgs args = new NotificationEventArgs(instance);
            args.Text = txtMessage.Text;
            args.Buttons.Add(btnYes);
            args.Buttons.Add(btnNo);
            args.Buttons.Add(btnMute);
            FireNotificationCallback(args);

            Radegast.GUI.GuiHelpers.ApplyGuiFixes(this);
        }

 public LandPatchReceivedEventArgs(Simulator simulator, int x, int y, int patchSize, float[] heightMap)
 {
     this.m_Simulator = simulator;
     this.m_X = x;
     this.m_Y = y;
     this.m_PatchSize = patchSize;
     this.m_HeightMap = heightMap;
 }

 private bool Network_SkipEvent(PacketType type, Simulator sim)
 {
     if (PacketTypeRegional.Contains(type))
     {
         if (!IsMaster(sim)) return true;
     }
     return false;
 }

        public static string Serialize(Simulator settings, RegionSettings reg)
        {
            StringWriter sw = new StringWriter();
            XmlTextWriter xtw = new XmlTextWriter(sw);
            xtw.Formatting = Formatting.Indented;
            xtw.WriteStartDocument();

            xtw.WriteStartElement("RegionSettings");

            xtw.WriteStartElement("General");
            xtw.WriteElementString("AllowDamage", ((settings.Flags & RegionFlags.AllowDamage) != 0).ToString());
            xtw.WriteElementString("AllowLandResell", ((settings.Flags & RegionFlags.BlockLandResell) == 0).ToString());
            xtw.WriteElementString("AllowLandJoinDivide", ((settings.Flags & RegionFlags.AllowParcelChanges) != 0).ToString());
            xtw.WriteElementString("BlockFly", ((settings.Flags & RegionFlags.NoFly) != 0).ToString());
            xtw.WriteElementString("BlockLandShowInSearch", ((settings.Flags & RegionFlags.BlockParcelSearch) != 0).ToString());
            xtw.WriteElementString("BlockTerraform", ((settings.Flags & RegionFlags.BlockTerraform) != 0).ToString());
            xtw.WriteElementString("DisableCollisions", ((settings.Flags & RegionFlags.SkipCollisions) != 0).ToString());
            xtw.WriteElementString("DisablePhysics", ((settings.Flags & RegionFlags.SkipPhysics) != 0).ToString());
            xtw.WriteElementString("DisableScripts", ((settings.Flags & RegionFlags.SkipScripts) != 0).ToString());
            xtw.WriteElementString("MaturityRating", settings.Access.ToString());
            xtw.WriteElementString("RestrictPushing", ((settings.Flags & RegionFlags.RestrictPushObject) != 0).ToString());
            xtw.WriteElementString("AgentLimit", reg.AgentLimit.ToString());
            xtw.WriteElementString("ObjectBonus", reg.ObjectBonus.ToString());
            xtw.WriteEndElement();

            xtw.WriteStartElement("GroundTextures");
            xtw.WriteElementString("Texture1", settings.TerrainDetail0.ToString());
            xtw.WriteElementString("Texture2", settings.TerrainDetail1.ToString());
            xtw.WriteElementString("Texture3", settings.TerrainDetail2.ToString());
            xtw.WriteElementString("Texture4", settings.TerrainDetail3.ToString());
            xtw.WriteElementString("ElevationLowSW", settings.TerrainStartHeight00.ToString());
            xtw.WriteElementString("ElevationLowNW", settings.TerrainStartHeight01.ToString());
            xtw.WriteElementString("ElevationLowSE", settings.TerrainStartHeight10.ToString());
            xtw.WriteElementString("ElevationLowNE", settings.TerrainStartHeight11.ToString());
            xtw.WriteElementString("ElevationHighSW", settings.TerrainHeightRange00.ToString());
            xtw.WriteElementString("ElevationHighNW", settings.TerrainHeightRange01.ToString());
            xtw.WriteElementString("ElevationHighSE", settings.TerrainHeightRange10.ToString());
            xtw.WriteElementString("ElevationHighNE", settings.TerrainHeightRange11.ToString());
            xtw.WriteEndElement();

            xtw.WriteStartElement("Terrain");
            xtw.WriteElementString("WaterHeight", settings.WaterHeight.ToString());
            xtw.WriteElementString("TerrainRaiseLimit", reg.TerrainRaiseLimit.ToString());
            xtw.WriteElementString("TerrainLowerLimit", reg.TerrainLowerLimit.ToString());
            xtw.WriteElementString("UseEstateSun", reg.UseEstateSun.ToString());
            xtw.WriteElementString("FixedSun", reg.FixedSun.ToString());
            //todo xtw.WriteElementString("SunPosition", settings.SunPosition.ToString());
            // Note: 'SunVector' isn't saved because this value is owned by the Sun Module, which
            // calculates it automatically according to the date and other factors.
            xtw.WriteEndElement();

            xtw.WriteEndElement();

            xtw.Close();
            sw.Close();

            return sw.ToString();
        }

 /// <summary>
 /// Construct a new instance of the SoundTriggerEventArgs class
 /// </summary>
 /// <param name="sim">Simulator where the event originated</param>
 /// <param name="soundID">The sound asset id</param>
 /// <param name="ownerID">The ID of the owner</param>
 /// <param name="objectID">The ID of the object</param>
 /// <param name="gain">The volume level</param>
 /// <param name="flags">The <see cref="SoundFlags"/></param>
 public AttachedSoundEventArgs(Simulator sim, UUID soundID, UUID ownerID, UUID objectID, float gain, SoundFlags flags)
 {
     this.m_Simulator = sim;
     this.m_SoundID = soundID;
     this.m_OwnerID = ownerID;
     this.m_ObjectID = objectID;
     this.m_Gain = gain;
     this.m_Flags = flags;
 }

 private void AgentDataUpdateHandler(Packet packet, Simulator sim)
 {
     AgentDataUpdatePacket p = (AgentDataUpdatePacket)packet;
     if (p.AgentData.AgentID == Client.Self.AgentID)
     {
         activeGroup = Utils.BytesToString(p.AgentData.GroupName) + " ( " + Utils.BytesToString(p.AgentData.GroupTitle) + " )";
         GroupsEvent.Set();
     }
 }

 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();
     }
 }

        void Nurse_OnInstantMessage(InstantMessage im, Simulator simulator)
        {
            if (im.Message.Equals("Reset"))
            {
                Reset();
                return;
            }

            if (im.Message.Equals("Stop"))
            {
                Stop();
                return;
            }

            if (im.Message.Equals("Start"))
            {
                Start();
                return;
            }

            if (state != States.idle)
            {
                client.Self.InstantMessage(im.FromAgentID, "busy");
                return;
            }

            List<Vector3> wayPointList = null;
            if (im.Message.Equals("thirsty"))
            {
                state = States.water;
                wayPointList = WaypointService.GetWayPoints(client.Self.SimPosition, "room5");
                client.Self.Chat("Ok " + im.FromAgentName + ", I'll get you a drink.", 0, ChatType.Normal);
                TraverseWayPoints(wayPointList);
                client.Self.Chat("I'm getting water for the patient in " + roomName, 0, ChatType.Normal);
                wayPointList = WaypointService.GetWayPoints(client.Self.SimPosition, roomName);
                TraverseWayPoints(wayPointList);
                client.Self.Chat("Here is your water.", 0, ChatType.Normal);
            }
            if (im.Message.Equals("pain"))
            {
                state = States.drugs;
                wayPointList = WaypointService.GetWayPoints(client.Self.SimPosition, "pharmacy");
                client.Self.Chat("Ok " + im.FromAgentName + ", I'll see what they have in the pharmacy", 0, ChatType.Normal);
                TraverseWayPoints(wayPointList);
                client.Self.Chat("I'm getting drugs for the patient in " + roomName, 0, ChatType.Normal);
                wayPointList = WaypointService.GetWayPoints(client.Self.SimPosition, roomName);
                TraverseWayPoints(wayPointList);
                client.Self.Chat("Here is your morphine.", 0, ChatType.Normal);
            }

            state = States.travelling;
            wayPointList = WaypointService.GetWayPoints(client.Self.SimPosition, "lobby");
            TraverseWayPoints(wayPointList);

            state = States.idle;
        }

 static void Self_OnInstantMessage(InstantMessage im, Simulator simulator)
 {
     if (im.Dialog == InstantMessageDialog.RequestTeleport)
     {
         if (im.FromAgentID == _MasterID)
         {
             _Client.Self.TeleportLureRespond(im.FromAgentID, true);
         }
     }
 }

        void Objects_OnObjectProperties(Simulator simulator, Primitive.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();
            }
        }