C# LSL_Types.list类代码示例

        // Get a list of all the avatars/agents in the region
        public LSL_List osGetAgents()
        {
            // threat level is None as we could get this information with an
            // in-world script as well, just not as efficient
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "osGetAgents", m_host, "OSSL", m_itemID))
                return new LSL_List();

            LSL_List result = new LSL_List();
            World.ForEachScenePresence(delegate(IScenePresence sp)
                                           {
                                               if (!sp.IsChildAgent)
                                                   result.Add(new LSL_String(sp.Name));
                                           });
            return result;
        }

        // Threat level is 'Low' because certain users could possibly be tricked into
        // dropping an unverified script into one of their own objects, which could
        // then gather the physical construction details of the object and transmit it
        // to an unscrupulous third party, thus permitting unauthorized duplication of
        // the object's form.
        //
        public LSL_List osGetLinkPrimitiveParams(int linknumber, LSL_List rules)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.High, "osGetLinkPrimitiveParams", m_host, "OSSL",
                                                   m_itemID)) return new LSL_List();

            InitLSL();
            LSL_List retVal = new LSL_List();
            //Assign requested part directly
            ISceneChildEntity part = m_host.ParentEntity.GetLinkNumPart(linknumber) as ISceneChildEntity;

            //Check to see if the requested part exists (NOT null) and if so, get it's rules
            if (part != null) retVal = m_LSL_Api.GetLinkPrimitiveParams(part, rules, true);

            //Will retun rules for specific part, or an empty list if part == null
            return retVal;
        }

        public double osList2Double(LSL_List src, int index)
        {
            // There is really no double type in OSSL. C# and other
            // have one, but the current implementation of LSL_Types.list
            // is not allowed to contain any.
            // This really should be removed.
            //
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "osList2Double", m_host, "OSSL", m_itemID))
                return 0;

            if (index < 0)
            {
                index = src.Length + index;
            }
            if (index >= src.Length)
            {
                return 0.0;
            }
            return Convert.ToDouble(src.Data[index]);
        }

        void ConvertWindlightDayCycle (WindlightDayCycle cycle, int preset, int rule, ref LSL_List list)
        {
            var skyDatas = cycle.Cycle.DataSettings.Values.ToList ();
            var skyData = skyDatas [preset];

            switch (rule) {
            case ScriptBaseClass.WL_AMBIENT:
                list.Add (new LSL_Rotation (skyData.ambient.X, skyData.ambient.Y,
                                            skyData.ambient.Z, skyData.ambient.W));
                break;
            case ScriptBaseClass.WL_SKY_BLUE_DENSITY:
                list.Add (new LSL_Rotation (skyData.blue_density.X, skyData.blue_density.Y,
                                            skyData.blue_density.Z, skyData.blue_density.W));
                break;
            case ScriptBaseClass.WL_SKY_BLUR_HORIZON:
                list.Add (new LSL_Rotation (skyData.blue_horizon.X, skyData.blue_horizon.Y,
                                            skyData.blue_horizon.Z, skyData.blue_horizon.W));
                break;
            case ScriptBaseClass.WL_CLOUD_COLOR:
                list.Add (new LSL_Rotation (skyData.cloud_color.X, skyData.cloud_color.Y,
                                            skyData.cloud_color.Z, skyData.cloud_color.W));
                break;
            case ScriptBaseClass.WL_CLOUD_POS_DENSITY1:
                list.Add (new LSL_Rotation (skyData.cloud_pos_density1.X, skyData.cloud_pos_density1.Y,
                                            skyData.cloud_pos_density1.Z, skyData.cloud_pos_density1.W));
                break;
            case ScriptBaseClass.WL_CLOUD_POS_DENSITY2:
                list.Add (new LSL_Rotation (skyData.cloud_pos_density2.X, skyData.cloud_pos_density2.Y,
                                            skyData.cloud_pos_density2.Z, skyData.cloud_pos_density2.W));
                break;
            case ScriptBaseClass.WL_CLOUD_SCALE:
                list.Add (new LSL_Rotation (skyData.cloud_scale.X, skyData.cloud_scale.Y,
                                            skyData.cloud_scale.Z, skyData.cloud_scale.W));
                break;
            case ScriptBaseClass.WL_CLOUD_SCROLL_X:
                list.Add (new LSL_Float (skyData.cloud_scroll_rate.X));
                break;
            case ScriptBaseClass.WL_CLOUD_SCROLL_X_LOCK:
                list.Add (new LSL_Integer (skyData.enable_cloud_scroll.X));
                break;
            case ScriptBaseClass.WL_CLOUD_SCROLL_Y:
                list.Add (new LSL_Float (skyData.cloud_scroll_rate.Y));
                break;
            case ScriptBaseClass.WL_CLOUD_SCROLL_Y_LOCK:
                list.Add (new LSL_Integer (skyData.enable_cloud_scroll.Y));
                break;
            case ScriptBaseClass.WL_CLOUD_SHADOW:
                list.Add (new LSL_Rotation (skyData.cloud_shadow.X, skyData.cloud_shadow.Y,
                                            skyData.cloud_shadow.Z, skyData.cloud_shadow.W));
                break;
            case ScriptBaseClass.WL_SKY_DENSITY_MULTIPLIER:
                list.Add (new LSL_Rotation (skyData.density_multiplier.X, skyData.density_multiplier.Y,
                                            skyData.density_multiplier.Z, skyData.density_multiplier.W));
                break;
            case ScriptBaseClass.WL_SKY_DISTANCE_MULTIPLIER:
                list.Add (new LSL_Rotation (skyData.distance_multiplier.X, skyData.distance_multiplier.Y,
                                            skyData.distance_multiplier.Z, skyData.distance_multiplier.W));
                break;
            case ScriptBaseClass.WL_SKY_GAMMA:
                list.Add (new LSL_Rotation (skyData.gamma.X, skyData.gamma.Y, skyData.gamma.Z, skyData.gamma.W));
                break;
            case ScriptBaseClass.WL_SKY_GLOW:
                list.Add (new LSL_Rotation (skyData.glow.X, skyData.glow.Y, skyData.glow.Z, skyData.glow.W));
                break;
            case ScriptBaseClass.WL_SKY_HAZE_DENSITY:
                list.Add (new LSL_Rotation (skyData.haze_density.X, skyData.haze_density.Y,
                                            skyData.haze_density.Z, skyData.haze_density.W));
                break;
            case ScriptBaseClass.WL_SKY_HAZE_HORIZON:
                list.Add (new LSL_Rotation (skyData.haze_horizon.X, skyData.haze_horizon.Y,
                                            skyData.haze_horizon.Z, skyData.haze_horizon.W));
                break;
            case ScriptBaseClass.WL_SKY_LIGHT_NORMALS:
                list.Add (new LSL_Rotation (skyData.lightnorm.X, skyData.lightnorm.Y,
                                            skyData.lightnorm.Z, skyData.lightnorm.W));
                break;
            case ScriptBaseClass.WL_SKY_MAX_ALTITUDE:
                list.Add (new LSL_Rotation (skyData.max_y.X, skyData.max_y.Y, skyData.max_y.Z, skyData.max_y.W));
                break;
            case ScriptBaseClass.WL_SKY_STAR_BRIGHTNESS:
                list.Add (new LSL_Float (skyData.star_brightness));
                break;
            case ScriptBaseClass.WL_SKY_SUNLIGHT_COLOR:
                list.Add (new LSL_Rotation (skyData.sunlight_color.X, skyData.sunlight_color.Y,
                                            skyData.sunlight_color.Z, skyData.sunlight_color.W));
                break;
            case ScriptBaseClass.WL_WATER_BLUR_MULTIPLIER:
                list.Add (new LSL_Float (cycle.Water.blurMultiplier));
                break;
            case ScriptBaseClass.WL_WATER_FRESNEL_OFFSET:
                list.Add (new LSL_Float (cycle.Water.fresnelOffset));
                break;
            case ScriptBaseClass.WL_WATER_FRESNEL_SCALE:
                list.Add (new LSL_Float (cycle.Water.fresnelScale));
                break;
            case ScriptBaseClass.WL_WATER_NORMAL_MAP:
                list.Add (new LSL_String (cycle.Water.normalMap));
                break;
            case ScriptBaseClass.WL_WATER_NORMAL_SCALE:
                list.Add (new LSL_Vector (cycle.Water.normScale.X, cycle.Water.normScale.Y, cycle.Water.normScale.Z));
//.........这里部分代码省略.........

        public LSL_Integer aaWindlightSetScene (int dayCycleIndex, LSL_List list)
        {
            IEnvironmentSettingsModule environmentSettings = World.RequestModuleInterface<IEnvironmentSettingsModule> ();
            if (environmentSettings == null)
                return ScriptBaseClass.WL_ERROR_NO_SCENE_SET;

            WindlightDayCycle cycle = environmentSettings.GetCurrentDayCycle ();
            if (cycle == null)
                return ScriptBaseClass.WL_ERROR_NO_SCENE_SET;

            if (!cycle.Cycle.IsStaticDayCycle)
                return ScriptBaseClass.WL_ERROR_SCENE_MUST_BE_STATIC;

            if (dayCycleIndex >= cycle.Cycle.DataSettings.Count)
                return ScriptBaseClass.WL_ERROR_BAD_SETTING;

            ConvertLSLToWindlight (ref cycle, dayCycleIndex, list);
            environmentSettings.SetDayCycle (cycle);
            environmentSettings.TriggerWindlightUpdate (1);

            return ScriptBaseClass.WL_OK;
        }

        void ConvertLSLToWindlight (ref WindlightDayCycle cycle, int preset, LSL_List list)
        {
            var skyDatas = cycle.Cycle.DataSettings.Values.ToList ();
            var skyData = skyDatas [preset];

            for (int i = 0; i < list.Data.Length; i += 2) {
                int key = list.GetLSLIntegerItem (i);
                switch (key) {
                case ScriptBaseClass.WL_AMBIENT: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.ambient = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_COLOR: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.cloud_color = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_POS_DENSITY1: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.cloud_pos_density1 = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_POS_DENSITY2: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.cloud_pos_density2 = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_SCALE: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.cloud_scale = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_SCROLL_X: {
                        LSL_Integer integer = list.GetLSLIntegerItem (i + 1);
                        skyData.cloud_scroll_rate.X = integer;
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_SCROLL_Y: {
                        LSL_Integer integer = list.GetLSLIntegerItem (i + 1);
                        skyData.cloud_scroll_rate.Y = integer;
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_SCROLL_X_LOCK: {
                        LSL_Integer integer = list.GetLSLIntegerItem (i + 1);
                        skyData.enable_cloud_scroll.X = integer;
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_SCROLL_Y_LOCK: {
                        LSL_Integer integer = list.GetLSLIntegerItem (i + 1);
                        skyData.enable_cloud_scroll.Y = integer;
                        break;
                    }
                case ScriptBaseClass.WL_CLOUD_SHADOW: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.cloud_shadow = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_BLUE_DENSITY: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.blue_density = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_BLUR_HORIZON: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.blue_horizon = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_DENSITY_MULTIPLIER: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.density_multiplier = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_DISTANCE_MULTIPLIER: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.distance_multiplier = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_GAMMA: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.gamma = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_GLOW: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.glow = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_HAZE_DENSITY: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.haze_density = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_HAZE_HORIZON: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
                        skyData.haze_horizon = rot.ToVector4 ();
                        break;
                    }
                case ScriptBaseClass.WL_SKY_LIGHT_NORMALS: {
                        LSL_Rotation rot = list.GetQuaternionItem (i + 1);
//.........这里部分代码省略.........

        public void llSetLinkPrimitiveParams(int linknumber, LSL_List rules)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL", m_itemID)) return;

            List<IEntity> parts = GetLinkPartsAndEntities(linknumber);

            foreach (IEntity part in parts)
                SetPrimParams(part, rules, m_allowOpenSimParams);

            PScriptSleep(m_sleepMsOnSetLinkPrimitiveParams);
        }

        public void osSetLinkPrimitiveParams(LSL_Integer link, LSL_List rules)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Low, "osSetLinkPrimitiveParams", m_host, "OSSL", m_itemID))
                return;

            InitLSL();
            List<IEntity> parts = m_LSL_Api.GetLinkPartsAndEntities(link);

            foreach (IEntity part in parts)
                m_LSL_Api.SetPrimParams(part, rules, true);
        }

        public LSL_List osGetPrimitiveParams(LSL_Key prim, LSL_List rules)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.High, "osGetPrimitiveParams", m_host, "OSSL", m_itemID))
                return new LSL_List();

            InitLSL();
            return m_LSL_Api.GetLinkPrimitiveParamsEx(prim, rules);
        }

        public LSL_String osFormatString(string str, LSL_List strings)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Low, "osFormatString", m_host, "OSSL", m_itemID))
                return new LSL_String();

            return String.Format(str, strings.Data);
        }

        public LSL_String aaSerializeXML (LSL_List keys, LSL_List values)
        {
            if (!ScriptProtection.CheckThreatLevel (ThreatLevel.Moderate, "aaSerializeXML", m_host, "AA", m_itemID))
                return new LSL_String ();

            XmlDocument doc = new XmlDocument ();
            for (int i = 0; i < keys.Length; i++) {
                string key = keys.GetLSLStringItem (i);
                string value = values.GetLSLStringItem (i);
                XmlNode node = doc.CreateNode (XmlNodeType.Element, key, "");
                node.InnerText = value;
                doc.AppendChild (node);
            }

            return new LSL_String (doc.OuterXml);
        }

        public LSL_Integer llSetPrimMediaParams(LSL_Integer face, LSL_List rules)
        {
            PScriptSleep(m_sleepMsOnSetPrimMediaParams);

            // LSL Spec http://wiki.secondlife.com/wiki/LlSetPrimMediaParams says to fail silently if face is invalid
            // Assuming silently fail means sending back STATUS_OK.  Ideally, need to check this.
            // Don't perform the media check directly
            if (face < 0 || face > m_host.GetNumberOfSides() - 1)
                return ScriptBaseClass.STATUS_OK;
            return SetPrimMediaParams(m_host, face, rules);
        }

        public LSL_List GetLinkPrimitiveParamsEx(LSL_Key prim, LSL_List rules)
        {
            ISceneChildEntity obj = World.GetSceneObjectPart(prim);
            if (obj == null)
                return new LSL_List();

            if (obj.OwnerID == m_host.OwnerID)
                return new LSL_List();

            return GetLinkPrimitiveParams(obj, rules, true);
        }

        public void llSetPrimitiveParams(LSL_List rules)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL", m_itemID)) return;

            SetPrimParams(m_host, rules, m_allowOpenSimParams);
            PScriptSleep(m_sleepMsOnSetPrimitiveParams);
        }

        public void llSetPayPrice(int price, LSL_List quick_pay_buttons)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL", m_itemID)) return;
            m_host.ParentEntity.RootChild.PayPrice[0] = price;

            if (quick_pay_buttons.Data.Length > 0)
                m_host.ParentEntity.RootChild.PayPrice[1] = (LSL_Integer)quick_pay_buttons.Data[0];
            else
                m_host.ParentEntity.RootChild.PayPrice[1] = (LSL_Integer)(-2);
            if (quick_pay_buttons.Data.Length > 1)
                m_host.ParentEntity.RootChild.PayPrice[2] = (LSL_Integer)quick_pay_buttons.Data[1];
            else
                m_host.ParentEntity.RootChild.PayPrice[2] = (LSL_Integer)(-2);
            if (quick_pay_buttons.Data.Length > 2)
                m_host.ParentEntity.RootChild.PayPrice[3] = (LSL_Integer)quick_pay_buttons.Data[2];
            else
                m_host.ParentEntity.RootChild.PayPrice[3] = (LSL_Integer)(-2);
            if (quick_pay_buttons.Data.Length > 3)
                m_host.ParentEntity.RootChild.PayPrice[4] = (LSL_Integer)quick_pay_buttons.Data[3];
            else
                m_host.ParentEntity.RootChild.PayPrice[4] = (LSL_Integer)(-2);
        }