// 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 LSL_List osMatchString(string src, string pattern, int start)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.High, "osMatchString", m_host, "OSSL", m_itemID))
                return new LSL_List();

            LSL_List result = new LSL_List();

            // Normalize indices (if negative).
            // After normlaization they may still be
            // negative, but that is now relative to
            // the start, rather than the end, of the
            // sequence.
            if (start < 0)
            {
                start = src.Length + start;
            }

            if (start < 0 || start >= src.Length)
            {
                return result; // empty list
            }

            // Find matches beginning at start position
            Regex matcher = new Regex(pattern);
            Match match = matcher.Match(src, start);
            while (match.Success)
            {
                foreach (Group g in match.Groups)
                {
                    if (g.Success)
                    {
                        result.Add(new LSL_Integer(g.Value));
                        result.Add(new LSL_Integer(g.Index));
                    }
                }
                match = match.NextMatch();
            }

            return result;
        }

        public LSL_List aaWindlightGetScene (int dayCycleIndex, LSL_List rules)
        {
            IEnvironmentSettingsModule environmentSettings = World.RequestModuleInterface<IEnvironmentSettingsModule> ();
            if (environmentSettings == null)
                return new LSL_List (new object [] { ScriptBaseClass.WL_ERROR, ScriptBaseClass.WL_ERROR_NO_SCENE_SET });

            WindlightDayCycle cycle = environmentSettings.GetCurrentDayCycle ();
            if (cycle == null)
                return new LSL_List (new object [] { ScriptBaseClass.WL_ERROR, ScriptBaseClass.WL_ERROR_NO_SCENE_SET });

            if (cycle.Cycle.IsStaticDayCycle)
                return
                    new LSL_List (new object []
                                     {ScriptBaseClass.WL_ERROR, ScriptBaseClass.WL_ERROR_SCENE_MUST_NOT_BE_STATIC});

            if (dayCycleIndex >= cycle.Cycle.DataSettings.Count)
                return new LSL_List (new object [] { ScriptBaseClass.WL_ERROR, ScriptBaseClass.WL_ERROR_NO_PRESET_FOUND });

            LSL_List list = new LSL_List ();
            for (int i = 0; i < rules.Data.Length; i++) {
                int rule = rules.GetLSLIntegerItem (i);

                ConvertWindlightDayCycle (cycle, dayCycleIndex, rule, ref list);
            }
            return list;
        }

        public LSL_List aaWindlightGetDayCycle ()
        {
            IEnvironmentSettingsModule environmentSettings = World.RequestModuleInterface<IEnvironmentSettingsModule> ();
            if (environmentSettings == null)
                return new LSL_List (new object [] { ScriptBaseClass.WL_ERROR, ScriptBaseClass.WL_ERROR_NO_SCENE_SET });

            WindlightDayCycle cycle = environmentSettings.GetCurrentDayCycle ();
            if (cycle == null)
                return new LSL_List (new object [] { ScriptBaseClass.WL_ERROR, ScriptBaseClass.WL_ERROR_NO_SCENE_SET });

            if (cycle.Cycle.IsStaticDayCycle)
                return new LSL_List (new object [] { 0, -1, cycle.Cycle.DataSettings ["-1"].preset_name });

            LSL_List list = new LSL_List ();

            int i = 0;
            foreach (var key in cycle.Cycle.DataSettings) {
                list.Add (i++);
                list.Add (key.Key);
                list.Add (key.Value.preset_name);
            }

            return list;
        }

        /// <summary>
        ///     Like osGetAgents but returns enough info for a radar
        /// </summary>
        /// <returns>Strided list of the UUID, position and name of each avatar in the region</returns>
        public LSL_List osGetAvatarList()
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.None, "osGetAvatarList", m_host, "OSSL", m_itemID))
                return new LSL_List();

            LSL_List result = new LSL_List();
            World.ForEachScenePresence(delegate(IScenePresence avatar)
                                           {
                                               if (avatar != null && avatar.UUID != m_host.OwnerID)
                                               {
                                                   if (!avatar.IsChildAgent)
                                                   {
                                                       result.Add(new LSL_Key(avatar.UUID.ToString()));
                                                       result.Add(new LSL_Vector(avatar.AbsolutePosition.X,
                                                                                 avatar.AbsolutePosition.Y,
                                                                                 avatar.AbsolutePosition.Z));
                                                       result.Add(new LSL_String(avatar.Name));
                                                   }
                                               }
                                           });
            return result;
        }

        public LSL_List aaQueryDatabase (LSL_String key, LSL_String token)
        {
            if (!ScriptProtection.CheckThreatLevel (ThreatLevel.Moderate, "aaQueryDatabase", m_host, "AA", m_itemID))
                return new LSL_List ();

            List<string> query = AssetConnector.FindLSLData (token.m_string, key.m_string);
            LSL_List list = new LSL_List (query.ToArray ());

            return list;
        }

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