Example #1
0
        /// <summary>
        /// Set the current Windlight scene to a target avatar
        /// </summary>
        /// <param name="rules"></param>
        /// <returns>success: true or false</returns>
        public int lsSetWindlightSceneTargeted(LSL_List rules, LSL_Key target)
        {
            if (!m_LSFunctionsEnabled)
            {
                LSShoutError("LightShare functions are not enabled.");
                return(0);
            }
            if (!World.RegionInfo.EstateSettings.IsEstateManager(m_host.OwnerID) && World.GetScenePresence(m_host.OwnerID).GodLevel < 200)
            {
                LSShoutError("lsSetWindlightSceneTargeted can only be used by estate managers or owners.");
                return(0);
            }
            int success = 0;

            /*if (m_lightShareModule.EnableWindLight)
             * {
             *  RegionLightShareData wl = getWindlightProfileFromRules(rules);
             *  m_lightShareModule.SendWindlightProfileTargeted(wl, new UUID(target.m_string));
             *  success = 1;
             * }
             * else
             * {
             *  LSShoutError("Windlight module is disabled");
             *  return 0;
             * }*/
            return(success);
        }
Example #2
0
        /// <summary>
        ///   Set the current Windlight scene
        /// </summary>
        /// <param name = "rules"></param>
        /// <returns>success: true or false</returns>
        public int lsSetWindlightScene(LSL_List rules)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Moderate, "lsSetWindlightScene", m_host, "LS", m_itemID))
            {
                return(0);
            }

            if (!World.RegionInfo.EstateSettings.IsEstateManager(m_host.OwnerID) &&
                World.GetScenePresence(m_host.OwnerID).GodLevel < 200)
            {
                LSShoutError("lsSetWindlightScene can only be used by estate managers or owners.");
                return(0);
            }
            int success = 0;

            /*if (m_lightShareModule.EnableWindLight)
             * {
             *  RegionLightShareData wl = getWindlightProfileFromRules(rules);
             *  //m_lightShareModule.SaveWindLightSettings(0, wl);
             *  success = 1;
             * }
             * else
             * {
             *  LSShoutError("Windlight module is disabled");
             *  return 0;
             * }*/
            return(success);
        }
Example #3
0
        public void botSetMap(string keyOfBot, LSL_List positions, LSL_List movementType, LSL_Integer flags)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Moderate, "botSetMap", m_host, "bot", m_itemID))
            {
                return;
            }
            List <Vector3> PositionsMap = new List <Vector3>();

            for (int i = 0; i < positions.Length; i++)
            {
                LSL_Vector pos = positions.GetVector3Item(i);
                PositionsMap.Add(new Vector3((float)pos.x, (float)pos.y, (float)pos.z));
            }
            List <TravelMode> TravelMap = new List <TravelMode>();

            for (int i = 0; i < movementType.Length; i++)
            {
                LSL_Integer travel = movementType.GetLSLIntegerItem(i);
                TravelMap.Add((TravelMode)travel.value);
            }

            IBotManager manager = World.RequestModuleInterface <IBotManager>();

            if (manager != null)
            {
                manager.SetBotMap(UUID.Parse(keyOfBot), PositionsMap, TravelMap, flags.value, m_host.OwnerID);
            }
        }
Example #4
0
        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);
        }
Example #5
0
        public LSL_String aaSerializeXML(LSL_List keys, LSL_List values)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.Moderate, "AASerializeXML", m_host, "AA");
            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));
        }
Example #6
0
        public LSL_List aaDeserializeXMLKeys(LSL_String xmlFile)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Moderate, "AADeserializeXMLKeys", m_host, "AA", m_itemID))
            {
                return(new LSL_List());
            }
            XmlDocument doc = new XmlDocument();

            doc.LoadXml(xmlFile.m_string);
            XmlNodeList children = doc.ChildNodes;
            LSL_List    keys     = new LSL_List();

            foreach (XmlNode node in children)
            {
                keys.Add(node.Name);
            }
            return(keys);
        }
Example #7
0
        public LSL_List aaGetTeamMembers(LSL_String team)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Low, "AAGetTeamMembers", m_host, "AA", m_itemID))
            {
                return(new LSL_List());
            }
            List <UUID>   Members = new List <UUID>();
            ICombatModule module  = World.RequestModuleInterface <ICombatModule>();

            if (module != null)
            {
                Members = module.GetTeammates(team);
            }
            LSL_List members = new LSL_List();

            foreach (UUID member in Members)
            {
                members.Add(new LSL_Key(member.ToString()));
            }
            return(members);
        }
Example #8
0
        public LSL_List botGetBotsWithTag(string tag)
        {
            if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Moderate, "botGetBotsWithTag", m_host, "bot", m_itemID))
            {
                return(new LSL_List());
            }
            IBotManager manager = World.RequestModuleInterface <IBotManager>();
            List <UUID> bots    = new List <UUID>();

            if (manager != null)
            {
                bots = manager.GetBotsWithTag(tag);
            }
            LSL_List b = new LSL_List();

            foreach (UUID bot in bots)
            {
                b.Add(bot.ToString());
            }

            return(b);
        }
Example #9
0
        public void botSetMap(string keyOfBot, LSL_List positions, LSL_List movementType)
        {
            List <Vector3> PositionsMap = new List <Vector3>();

            for (int i = 0; i < positions.Length; i++)
            {
                LSL_Vector pos = positions.GetVector3Item(i);
                PositionsMap.Add(new Vector3((float)pos.x, (float)pos.y, (float)pos.z));
            }
            List <TravelMode> TravelMap = new List <TravelMode>();

            for (int i = 0; i < movementType.Length; i++)
            {
                LSL_Integer travel = movementType.GetLSLIntegerItem(i);
                TravelMap.Add((TravelMode)travel.value);
            }

            IBotManager manager = World.RequestModuleInterface <IBotManager>();

            if (manager != null)
            {
                manager.SetBotMap(UUID.Parse(keyOfBot), PositionsMap, TravelMap);
            }
        }
Example #10
0
        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;
        }
Example #11
0
 public LSL_String AASerializeXML(LSL_List keys, LSL_List values)
 {
     return m_AA_Functions.AASerializeXML(keys, values);
 }
Example #12
0
 public LSL_List llParseStringKeepNulls(string src, LSL_List separators, LSL_List spacers)
 {
     ScriptProtection.CheckThreatLevel(ThreatLevel.None, "llParseStringKeepNulls", m_host, "LSL");
     return this.ParseString(src, separators, spacers, true);
 }
Example #13
0
 public LSL_List aaGetTeamMembers(LSL_String team)
 {
     if (!ScriptProtection.CheckThreatLevel(ThreatLevel.Low, "AAGetTeamMembers", m_host, "AA", m_itemID))
         return new LSL_List();
     List<UUID> Members = new List<UUID>();
     ICombatModule module = World.RequestModuleInterface<ICombatModule>();
     if (module != null)
     {
         Members = module.GetTeammates(team);
     }
     LSL_List members = new LSL_List();
     foreach (UUID member in Members)
         members.Add(new LSL_Key(member.ToString()));
     return members;
 }
Example #14
0
 public LSL_List llGetPrimitiveParams(LSL_List rules)
 {
     ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
     
     return GetLinkPrimitiveParams(m_host, rules);
 }
Example #15
0
        public LSL_List GetLinkPrimitiveParams(SceneObjectPart part, LSL_List rules)
        {
            LSL_List res = new LSL_List();
            int idx = 0;
            while (idx < rules.Length)
            {
                int code = (int)rules.GetLSLIntegerItem(idx++);
                int remain = rules.Length - idx;
                Primitive.TextureEntry tex = part.Shape.Textures;
                int face = 0;
                if (idx < rules.Length)
                    face = (int)rules.GetLSLIntegerItem(idx++);

                Primitive.TextureEntryFace texFace = tex.GetFace((uint)face);

                if (code == (int)ScriptBaseClass.PRIM_NAME)
                {
                    res.Add(new LSL_Integer(part.Name));
                }

                if (code == (int)ScriptBaseClass.PRIM_DESC)
                {
                    res.Add(new LSL_Integer(part.Description));
                }

                if (code == (int)ScriptBaseClass.PRIM_MATERIAL)
                {
                    res.Add(new LSL_Integer(part.Material));
                }

                if (code == (int)ScriptBaseClass.PRIM_PHYSICS)
                {
                    if ((part.GetEffectiveObjectFlags() & (uint)PrimFlags.Physics) != 0)
                        res.Add(new LSL_Integer(1));
                    else
                        res.Add(new LSL_Integer(0));
                }

                if (code == (int)ScriptBaseClass.PRIM_TEMP_ON_REZ)
                {
                    if ((part.GetEffectiveObjectFlags() & (uint)PrimFlags.TemporaryOnRez) != 0)
                        res.Add(new LSL_Integer(1));
                    else
                        res.Add(new LSL_Integer(0));
                }

                if (code == (int)ScriptBaseClass.PRIM_PHANTOM)
                {
                    if ((part.GetEffectiveObjectFlags() & (uint)PrimFlags.Phantom) != 0)
                        res.Add(new LSL_Integer(1));
                    else
                        res.Add(new LSL_Integer(0));
                }

                if (code == (int)ScriptBaseClass.PRIM_POSITION)
                {
                    Vector3 tmp = part.AbsolutePosition;
                    LSL_Vector v = new LSL_Vector(tmp.X,
                                                  tmp.Y,
                                                  tmp.Z);
                    // For some reason, the part.AbsolutePosition.* values do not change if the
                    // linkset is rotated; they always reflect the child prim's world position
                    // as though the linkset is unrotated. This is incompatible behavior with SL's
                    // implementation, so will break scripts imported from there (not to mention it
                    // makes it more difficult to determine a child prim's actual inworld position).
                    if (part.ParentID != 0)
                        {
                        LSL_Rotation rtmp = llGetRootRotation();
                        LSL_Vector rpos = llGetRootPosition();
                        v = ((v - rpos) * rtmp) + rpos;
                        }
                    res.Add(v);
                }

                if (code == (int)ScriptBaseClass.PRIM_SIZE)
                {
                    Vector3 tmp = part.Scale;
                    res.Add(new LSL_Vector(tmp.X,
                                                  tmp.Y,
                                                  tmp.Z));
                }

                if (code == (int)ScriptBaseClass.PRIM_ROTATION)
                {
                    res.Add(GetPartRot(part));
                }

                if (code == (int)ScriptBaseClass.PRIM_TYPE)
                {
                    // implementing box
                    PrimitiveBaseShape Shape = part.Shape;
                    int primType = (int)part.GetPrimType();
                    res.Add(new LSL_Integer(primType));
                    double topshearx = (double)(sbyte)Shape.PathShearX / 100.0; // Fix negative values for PathShearX
                    double topsheary = (double)(sbyte)Shape.PathShearY / 100.0; // and PathShearY.
                    if (primType == ScriptBaseClass.PRIM_TYPE_BOX ||
                         ScriptBaseClass.PRIM_TYPE_CYLINDER ||
                         ScriptBaseClass.PRIM_TYPE_PRISM)
                    {
                        res.Add(new LSL_Integer(Shape.ProfileCurve));
                        res.Add(new LSL_Vector(Shape.ProfileBegin / 50000.0, 1 - Shape.ProfileEnd / 50000.0, 0));
                        res.Add(new LSL_Float(Shape.ProfileHollow / 50000.0));
                        res.Add(new LSL_Vector(Shape.PathTwistBegin / 100.0, Shape.PathTwist / 100.0, 0));
                        res.Add(new LSL_Vector(1 - (Shape.PathScaleX / 100.0 - 1), 1 - (Shape.PathScaleY / 100.0 - 1), 0));
                        res.Add(new LSL_Vector(topshearx, topsheary, 0));
                    }

                    if (primType == ScriptBaseClass.PRIM_TYPE_SPHERE)
                    {
                        res.Add(new LSL_Integer(Shape.ProfileCurve));
                        res.Add(new LSL_Vector(Shape.PathBegin / 50000.0, 1 - Shape.PathEnd / 50000.0, 0));
                        res.Add(new LSL_Float(Shape.ProfileHollow / 50000.0));
                        res.Add(new LSL_Vector(Shape.PathTwistBegin / 100.0, Shape.PathTwist / 100.0, 0));
                        res.Add(new LSL_Vector(Shape.ProfileBegin / 50000.0, 1 - Shape.ProfileEnd / 50000.0, 0));
                    }

                    if (primType == ScriptBaseClass.PRIM_TYPE_SCULPT)
                    {
                        res.Add(Shape.SculptTexture.ToString());
                        res.Add(new LSL_Integer(Shape.SculptType));
                    }
                    if (primType == ScriptBaseClass.PRIM_TYPE_RING ||
                     ScriptBaseClass.PRIM_TYPE_TUBE ||
                     ScriptBaseClass.PRIM_TYPE_TORUS)
                    {
                        // holeshape
                        res.Add(new LSL_Integer(Shape.ProfileCurve));

                        // cut
                        res.Add(new LSL_Vector(Shape.PathBegin / 50000.0, 1 - Shape.PathEnd / 50000.0, 0));

                        // hollow
                        res.Add(new LSL_Float(Shape.ProfileHollow / 50000.0));

                        // twist
                        res.Add(new LSL_Vector(Shape.PathTwistBegin / 100.0, Shape.PathTwist / 100.0, 0));

                        // vector holesize
                        res.Add(new LSL_Vector(1 - (Shape.PathScaleX / 100.0 - 1), 1 - (Shape.PathScaleY / 100.0 - 1), 0));

                        // vector topshear
                        res.Add(new LSL_Vector(topshearx, topsheary, 0));

                        // vector profilecut
                        res.Add(new LSL_Vector(Shape.ProfileBegin / 50000.0, 1 - Shape.ProfileEnd / 50000.0, 0));

                        // vector tapera
                        res.Add(new LSL_Vector(Shape.PathTaperX / 100.0, Shape.PathTaperY / 100.0, 0));

                        // float revolutions
                        res.Add(new LSL_Float((Shape.PathRevolutions * 0.015) + 1.0)); // Slightly inaccurate, because an unsigned
                        // byte is being used to represent the entire
                        // range of floating-point values from 1.0
                        // through 4.0 (which is how SL does it). 

                        // float radiusoffset
                        res.Add(new LSL_Float(Shape.PathRadiusOffset / 100.0));

                        // float skew
                        res.Add(new LSL_Float(Shape.PathSkew / 100.0));
                    }
                }

                if (code == (int)ScriptBaseClass.PRIM_TEXTURE)
                {
                    if (remain < 1)
                        return res;

                    if (face == ScriptBaseClass.ALL_SIDES)
                    {
                        for (face = 0; face < GetNumberOfSides(part); face++)
                        {
                            Primitive.TextureEntryFace texface = tex.GetFace((uint)face);

                            res.Add(new LSL_String(texface.TextureID.ToString()));
                            res.Add(new LSL_Vector(texface.RepeatU,
                                                   texface.RepeatV,
                                                   0));
                            res.Add(new LSL_Vector(texface.OffsetU,
                                                   texface.OffsetV,
                                                   0));
                            res.Add(new LSL_Float(texface.Rotation));
                        }
                    }
                    else
                    {
                        if (face >= 0 && face < GetNumberOfSides(part))
                        {
                            Primitive.TextureEntryFace texface = tex.GetFace((uint)face);

                            res.Add(new LSL_String(texface.TextureID.ToString()));
                            res.Add(new LSL_Vector(texface.RepeatU,
                                                   texface.RepeatV,
                                                   0));
                            res.Add(new LSL_Vector(texface.OffsetU,
                                                   texface.OffsetV,
                                                   0));
                            res.Add(new LSL_Float(texface.Rotation));
                        }
                    }
                }

                if (code == (int)ScriptBaseClass.PRIM_COLOR)
                {
                    if (remain < 1)
                        return res;

                    tex = part.Shape.Textures;
                    Color4 texcolor;
                    if (face == ScriptBaseClass.ALL_SIDES)
                    {
                        for (face = 0; face < GetNumberOfSides(part); face++)
                        {
                            texcolor = tex.GetFace((uint)face).RGBA;
                            res.Add(new LSL_Vector(texcolor.R,
                                                   texcolor.G,
                                                   texcolor.B));
                            res.Add(new LSL_Float(texcolor.A));
                        }
                    }
                    else
                    {
                        texcolor = tex.GetFace((uint)face).RGBA;
                        res.Add(new LSL_Vector(texcolor.R,
                                               texcolor.G,
                                               texcolor.B));
                        res.Add(new LSL_Float(texcolor.A));
                    }
                }

                if (code == (int)ScriptBaseClass.PRIM_BUMP_SHINY)
                {
                    if (remain < 1)
                        return res;

                    face = (int)rules.GetLSLIntegerItem(idx++);
                    texFace = tex.GetFace((uint)face);

                    if (face == ScriptBaseClass.ALL_SIDES)
                    {
                        for (face = 0; face < GetNumberOfSides(part); face++)
                        {
                            Primitive.TextureEntryFace texface = tex.GetFace((uint)face);
                            // Convert Shininess to PRIM_SHINY_*
                            res.Add(new LSL_Integer((uint)texface.Shiny >> 6));
                            // PRIM_BUMP_*
                            res.Add(new LSL_Integer((int)texface.Bump));
                        }
                    }
                    else
                    {
                        if (face >= 0 && face < GetNumberOfSides(part))
                        {
                            Primitive.TextureEntryFace texface = tex.GetFace((uint)face);
                            // Convert Shininess to PRIM_SHINY_*
                            res.Add(new LSL_Integer((uint)texface.Shiny >> 6));
                            // PRIM_BUMP_*
                            res.Add(new LSL_Integer((int)texface.Bump));
                        }
                    }
                }

                if (code == (int)ScriptBaseClass.PRIM_FULLBRIGHT)
                {
                    if (remain < 1)
                        return res;

                    face = (int)rules.GetLSLIntegerItem(idx++);
                    tex = part.Shape.Textures;
                    if (face == ScriptBaseClass.ALL_SIDES)
                    {
                        for (face = 0; face < GetNumberOfSides(part); face++)
                        {
                            Primitive.TextureEntryFace texface = tex.GetFace((uint)face);
                            res.Add(new LSL_Integer(texface.Fullbright ? 1 : 0));
                        }
                    }
                    else
                    {
                        if (face >= 0 && face < GetNumberOfSides(part))
                        {
                            Primitive.TextureEntryFace texface = tex.GetFace((uint)face);
                            res.Add(new LSL_Integer(texface.Fullbright ? 1 : 0));
                        }
                    }
                }

                if (code == (int)ScriptBaseClass.PRIM_FLEXIBLE)
                {
                    PrimitiveBaseShape shape = part.Shape;

                    if (shape.FlexiEntry)
                        res.Add(new LSL_Integer(1));              // active
                    else
                        res.Add(new LSL_Integer(0));
                    res.Add(new LSL_Integer(shape.FlexiSoftness));// softness
                    res.Add(new LSL_Float(shape.FlexiGravity));   // gravity
                    res.Add(new LSL_Float(shape.FlexiDrag));      // friction
                    res.Add(new LSL_Float(shape.FlexiWind));      // wind
                    res.Add(new LSL_Float(shape.FlexiTension));   // tension
                    res.Add(new LSL_Vector(shape.FlexiForceX,       // force
                                           shape.FlexiForceY,
                                           shape.FlexiForceZ));
                }

                if (code == (int)ScriptBaseClass.PRIM_TEXGEN)
                {
                    if (remain < 1)
                        return res;

                    face = (int)rules.GetLSLIntegerItem(idx++);
                    if (face == ScriptBaseClass.ALL_SIDES)
                    {
                        for (face = 0; face < GetNumberOfSides(part); face++)
                        {
                            MappingType texgen = tex.GetFace((uint)face).TexMapType;
                            // Convert MappingType to PRIM_TEXGEN_DEFAULT, PRIM_TEXGEN_PLANAR etc.
                            res.Add(new LSL_Integer((uint)texgen >> 1));
                        }
                    }
                    else
                    {
                        if (face >= 0 && face < GetNumberOfSides(part))
                        {
                            MappingType texgen = tex.GetFace((uint)face).TexMapType;
                            res.Add(new LSL_Integer((uint)texgen >> 1));
                        }
                    }
                }

                if (code == (int)ScriptBaseClass.PRIM_POINT_LIGHT)
                {
                    PrimitiveBaseShape shape = part.Shape;

                    if (shape.LightEntry)
                        res.Add(new LSL_Integer(1));              // active
                    else
                        res.Add(new LSL_Integer(0));
                    res.Add(new LSL_Vector(shape.LightColorR,       // color
                                           shape.LightColorG,
                                           shape.LightColorB));
                    res.Add(new LSL_Float(shape.LightIntensity)); // intensity
                    res.Add(new LSL_Float(shape.LightRadius));    // radius
                    res.Add(new LSL_Float(shape.LightFalloff));   // falloff
                }

                if (code == (int)ScriptBaseClass.PRIM_GLOW)
                {
                    if (remain < 1)
                        return res;

                    face = (int)rules.GetLSLIntegerItem(idx++);
                    if (face == ScriptBaseClass.ALL_SIDES)
                    {
                        for (face = 0; face < GetNumberOfSides(part); face++)
                        {
                            Primitive.TextureEntryFace texface = tex.GetFace((uint)face);
                            res.Add(new LSL_Float(texface.Glow));
                        }
                    }
                    else
                    {
                        if (face >= 0 && face < GetNumberOfSides(part))
                        {
                            Primitive.TextureEntryFace texface = tex.GetFace((uint)face);
                            res.Add(new LSL_Float(texface.Glow));
                        }
                    }
                }

                if (code == (int)ScriptBaseClass.PRIM_TEXT)
                {
                    Color4 textColor = part.GetTextColor();
                    res.Add(part.Text);
                    res.Add(new LSL_Vector(textColor.R,
                                           textColor.G,
                                           textColor.B));
                    res.Add(new LSL_Float(textColor.A));
                }
                if (code == (int)ScriptBaseClass.PRIM_ROT_LOCAL)
                {
                    Quaternion rtmp = part.RotationOffset;
                    res.Add(new LSL_Rotation(rtmp.X, rtmp.Y, rtmp.Z, rtmp.W));
                }
            }
            return res;
        }
Example #16
0
        public void llLinkParticleSystem(int linknumber, LSL_List rules)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            List<SceneObjectPart> parts = GetLinkParts(linknumber);

            foreach (var part in parts)
            {
                SetParticleSystem(part, rules);
            }
        }
Example #17
0
        public LSL_List llGetAnimationList(string id)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            LSL_List l = new LSL_List();
            ScenePresence av = World.GetScenePresence((UUID)id);
            if (av == null || av.IsChildAgent) // only if in the region
                return l;
            UUID[] anims;
            anims = av.Animator.GetAnimationArray();
            foreach (UUID foo in anims)
                l.Add(foo.ToString());
            return l;
        }
Example #18
0
        /// <summary>
        /// Insert the list identified by <src> into the
        /// list designated by <dest> such that the first
        /// new element has the index specified by <index>
        /// </summary>

        public LSL_List llListInsertList(LSL_List dest, LSL_List src, int index)
        {
			ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            
            LSL_List pref = null;
            LSL_List suff = null;

            

            if (index < 0)
            {
                index = index+dest.Length;
                if (index < 0)
                {
                    index = 0;
                }
            }

            if (index != 0)
            {
                pref = dest.GetSublist(0,index-1);
                if (index < dest.Length)
                {
                    suff = dest.GetSublist(index,-1);
                    return pref + src + suff;
                }
                else
                {
                    return pref + src;
                }
            }
            else
            {
                if (index < dest.Length)
                {
                    suff = dest.GetSublist(index,-1);
                    return src + suff;
                }
                else
                {
                    return src;
                }
            }

        }
Example #19
0
        /// <summary>
        /// Returns the index of the first occurrence of test
        /// in src.
        /// </summary>

        public LSL_Integer llListFindList(LSL_List src, LSL_List test)
        {

            int index  = -1;
            int length = src.Length - test.Length + 1;

            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            // If either list is empty, do not match

            if (src.Length != 0 && test.Length != 0)
            {
                for (int i = 0; i < length; i++)
                {
                    if (src.Data[i].Equals(test.Data[0]))
                    {
                        int j;
                        for (j = 1; j < test.Length; j++)
                            if (!src.Data[i+j].Equals(test.Data[j]))
                                break;
                        if (j == test.Length)
                        {
                            index = i;
                            break;
                        }
                    }
                }
            }

            return index;

        }
Example #20
0
        /// <summary>
        /// Elements in the source list starting with 0 and then
        /// every i+stride. If the stride is negative then the scan
        /// is backwards producing an inverted result.
        /// Only those elements that are also in the specified
        /// range are included in the result.
        /// </summary>

        public LSL_List llList2ListStrided(LSL_List src, int start, int end, int stride)
        {

            LSL_List result = new LSL_List();
            int[] si = new int[2];
            int[] ei = new int[2];
            bool twopass = false;

            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            //  First step is always to deal with negative indices

            if (start < 0)
                start = src.Length+start;
            if (end   < 0)
                end   = src.Length+end;

            //  Out of bounds indices are OK, just trim them
            //  accordingly

            if (start > src.Length)
                start = src.Length;

            if (end > src.Length)
                end = src.Length;

            if (stride == 0)
                stride = 1;

            //  There may be one or two ranges to be considered

            if (start != end)
            {

                if (start <= end)
                {
                   si[0] = start;
                   ei[0] = end;
                }
                else
                {
                   si[1] = start;
                   ei[1] = src.Length;
                   si[0] = 0;
                   ei[0] = end;
                   twopass = true;
                }

                //  The scan always starts from the beginning of the
                //  source list, but members are only selected if they
                //  fall within the specified sub-range. The specified
                //  range values are inclusive.
                //  A negative stride reverses the direction of the
                //  scan producing an inverted list as a result.

                if (stride > 0)
                {
                    for (int i = 0; i < src.Length; i += stride)
                    {
                        if (i<=ei[0] && i>=si[0])
                            result.Add(src.Data[i]);
                        if (twopass && i>=si[1] && i<=ei[1])
                            result.Add(src.Data[i]);
                    }
                }
                else if (stride < 0)
                {
                    for (int i = src.Length - 1; i >= 0; i += stride)
                    {
                        if (i <= ei[0] && i >= si[0])
                            result.Add(src.Data[i]);
                        if (twopass && i >= si[1] && i <= ei[1])
                            result.Add(src.Data[i]);
                    }
                }
            }
            else
            {
                if (start%stride == 0)
                {
                    result.Add(src.Data[start]);
                }
            }

            return result;
        }
Example #21
0
        ///  <summary>
        ///  Randomizes the list, be arbitrarily reordering
        ///  sublists of stride elements. As the stride approaches
        ///  the size of the list, the options become very
        ///  limited.
        ///  </summary>
        ///  <remarks>
        ///  This could take a while for very large list
        ///  sizes.
        ///  </remarks>

        public LSL_List llListRandomize(LSL_List src, int stride)
        {
            LSL_List result;
            Random rand           = new Random();

            int   chunkk;
            int[] chunks;

            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            if (stride <= 0)
            {
                stride = 1;
            }

            // Stride MUST be a factor of the list length
            // If not, then return the src list. This also
            // traps those cases where stride > length.

            if (src.Length != stride && src.Length%stride == 0)
            {
                chunkk = src.Length/stride;

                chunks = new int[chunkk];

                for (int i = 0; i < chunkk; i++)
                    chunks[i] = i;

                // Knuth shuffle the chunkk index
                for (int i = chunkk - 1; i >= 1; i--)
                {
                    // Elect an unrandomized chunk to swap
                    int index = rand.Next(i + 1);
                    int tmp;

                    // and swap position with first unrandomized chunk
                    tmp = chunks[i];
                    chunks[i] = chunks[index];
                    chunks[index] = tmp;
                }

                // Construct the randomized list

                result = new LSL_List();

                for (int i = 0; i < chunkk; i++)
                {
                    for (int j = 0; j < stride; j++)
                    {
                        result.Add(src.Data[chunks[i]*stride+j]);
                    }
                }
            }
            else {
                object[] array = new object[src.Length];
                Array.Copy(src.Data, 0, array, 0, src.Length);
                result = new LSL_List(array);
            }

            return result;
        }
Example #22
0
        /// <summary>
        /// The supplied string is scanned for commas
        /// and converted into a list. Commas are only
        /// effective if they are encountered outside
        /// of '<' '>' delimiters. Any whitespace
        /// before or after an element is trimmed.
        /// </summary>

        public LSL_List llCSV2List(string src)
        {

            LSL_List result = new LSL_List();
            int parens = 0;
            int start  = 0;
            int length = 0;

            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            for (int i = 0; i < src.Length; i++)
            {
                switch (src[i])
                {
                    case '<':
                        parens++;
                        length++;
                        break;
                    case '>':
                        if (parens > 0)
                            parens--;
                        length++;
                        break;
                    case ',':
                        if (parens == 0)
                        {
                            result.Add(new LSL_String(src.Substring(start,length).Trim()));
                            start += length+1;
                            length = 0;
                        }
                        else
                        {
                            length++;
                        }
                        break;
                    default:
                        length++;
                        break;
                }
            }

            result.Add(src.Substring(start,length).Trim());

            return result;
        }
Example #23
0
        /// <summary>
        /// Process the supplied list and return the
        /// content of the list formatted as a comma
        /// separated list. There is a space after
        /// each comma.
        /// </summary>

        public LSL_String llList2CSV(LSL_List src)
        {

            string ret = String.Empty;
            int    x   = 0;

            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            if (src.Data.Length > 0)
            {
                ret = src.Data[x++].ToString();
                for (; x < src.Data.Length; x++)
                {
                    ret += ", "+src.Data[x].ToString();
                }
            }

            return ret;
        }
Example #24
0
 public void llParticleSystem(LSL_List rules)
 {
     ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
     
     SetParticleSystem(m_host, rules);
 }
Example #25
0
        protected void SetPrimParams(ISceneEntity part, LSL_List rules)
        {
            int idx = 0;

            while (idx < rules.Length)
            {
                int code = rules.GetLSLIntegerItem(idx++);

                int remain = rules.Length - idx;

                int face;
                LSL_Vector v;

                if (code == (int)ScriptBaseClass.PRIM_NAME)
                {
                    if (remain < 1)
                        return;

                    string name = rules.Data[idx++].ToString();
                    if (part is SceneObjectPart)
                        (part as SceneObjectPart).Name = name;
                }

                else if (code == (int)ScriptBaseClass.PRIM_DESC)
                {
                    if (remain < 1)
                        return;

                    string desc = rules.Data[idx++].ToString();
                    if (part is SceneObjectPart)
                        (part as SceneObjectPart).Description = desc;
                }

                else if (code == (int)ScriptBaseClass.PRIM_ROT_LOCAL)
                {
                    if (remain < 1)
                        return;
                    LSL_Rotation lr = rules.GetQuaternionItem(idx++);
                    if (part is SceneObjectPart)
                        SetRot((part as SceneObjectPart), Rot2Quaternion(lr));
                }

                else if (code == (int)ScriptBaseClass.PRIM_POSITION)
                {
                    if (remain < 1)
                        return;

                    v = rules.GetVector3Item(idx++);
                    if (part is SceneObjectPart)
                        SetPos(part as SceneObjectPart, v);
                    else if (part is ScenePresence)
                    {
                        (part as ScenePresence).OffsetPosition = new Vector3((float)v.x, (float)v.y, (float)v.z);
                        (part as ScenePresence).SendTerseUpdateToAllClients();
                    }
                }
                else if (code == (int)ScriptBaseClass.PRIM_SIZE)
                {
                    if (remain < 1)
                        return;


                    v = rules.GetVector3Item(idx++);
                    if (part is SceneObjectPart)
                        SetScale(part as SceneObjectPart, v);

                }
                else if (code == (int)ScriptBaseClass.PRIM_ROTATION)
                {
                    if (remain < 1)
                        return;

                    if (part is SceneObjectPart) { }
                    else return;

                    LSL_Rotation q = rules.GetQuaternionItem(idx++);
                    // try to let this work as in SL...
                    if ((part as SceneObjectPart).ParentID == 0)
                    {
                        // special case: If we are root, rotate complete SOG to new rotation
                        SetRot(part as SceneObjectPart, Rot2Quaternion(q));
                    }
                    else
                    {
                        // we are a child. The rotation values will be set to the one of root modified by rot, as in SL. Don't ask.
                        SceneObjectGroup group = (part as SceneObjectPart).ParentGroup;
                        if (group != null) // a bit paranoid, maybe
                        {
                            SceneObjectPart rootPart = group.RootPart;
                            if (rootPart != null) // again, better safe than sorry
                            {
                                SetRot((part as SceneObjectPart), rootPart.RotationOffset * Rot2Quaternion(q));
                            }
                        }
                    }

                }

                else if (code == (int)ScriptBaseClass.PRIM_TYPE)
                {
                    if (remain < 3)
                        return;

                    if (part is SceneObjectPart) { }
                    else
                        return;

                    code = (int)rules.GetLSLIntegerItem(idx++);

                    remain = rules.Length - idx;
                    float hollow;
                    LSL_Vector twist;
                    LSL_Vector taper_b;
                    LSL_Vector topshear;
                    float revolutions;
                    float radiusoffset;
                    float skew;
                    LSL_Vector holesize;
                    LSL_Vector profilecut;

                    if (code == (int)ScriptBaseClass.PRIM_TYPE_BOX)
                    {
                        if (remain < 6)
                            return;

                        face = (int)rules.GetLSLIntegerItem(idx++);
                        v = rules.GetVector3Item(idx++); // cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);

                        (part as SceneObjectPart).Shape.PathCurve = (byte)Extrusion.Straight;
                        SetPrimitiveShapeParams((part as SceneObjectPart), face, v, hollow, twist, taper_b, topshear, 1);

                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_CYLINDER)
                    {
                        if (remain < 6)
                            return;

                        face = (int)rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); // cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        (part as SceneObjectPart).Shape.ProfileShape = ProfileShape.Circle;
                        (part as SceneObjectPart).Shape.PathCurve = (byte)Extrusion.Straight;
                        SetPrimitiveShapeParams((part as SceneObjectPart), face, v, hollow, twist, taper_b, topshear, 0);

                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_PRISM)
                    {
                        if (remain < 6)
                            return;

                        face = (int)rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); //cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        (part as SceneObjectPart).Shape.PathCurve = (byte)Extrusion.Straight;
                        SetPrimitiveShapeParams((part as SceneObjectPart), face, v, hollow, twist, taper_b, topshear, 3);

                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_SPHERE)
                    {
                        if (remain < 5)
                            return;

                        face = (int)rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); // cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++); // dimple
                        (part as SceneObjectPart).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as SceneObjectPart), face, v, hollow, twist, taper_b, 5);

                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_TORUS)
                    {
                        if (remain < 11)
                            return;

                        face = (int)rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); //cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        holesize = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        profilecut = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++); // taper_a
                        revolutions = (float)rules.GetLSLFloatItem(idx++);
                        radiusoffset = (float)rules.GetLSLFloatItem(idx++);
                        skew = (float)rules.GetLSLFloatItem(idx++);
                        (part as SceneObjectPart).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as SceneObjectPart), face, v, hollow, twist, holesize, topshear, profilecut, taper_b,
                                                revolutions, radiusoffset, skew, 0);
                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_TUBE)
                    {
                        if (remain < 11)
                            return;

                        face = (int)rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); //cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        holesize = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        profilecut = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++); // taper_a
                        revolutions = (float)rules.GetLSLFloatItem(idx++);
                        radiusoffset = (float)rules.GetLSLFloatItem(idx++);
                        skew = (float)rules.GetLSLFloatItem(idx++);
                        (part as SceneObjectPart).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as SceneObjectPart), face, v, hollow, twist, holesize, topshear, profilecut, taper_b,
                                                revolutions, radiusoffset, skew, 1);
                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_RING)
                    {
                        if (remain < 11)
                            return;

                        face = (int)rules.GetLSLIntegerItem(idx++); // holeshape
                        v = rules.GetVector3Item(idx++); //cut
                        hollow = (float)rules.GetLSLFloatItem(idx++);
                        twist = rules.GetVector3Item(idx++);
                        holesize = rules.GetVector3Item(idx++);
                        topshear = rules.GetVector3Item(idx++);
                        profilecut = rules.GetVector3Item(idx++);
                        taper_b = rules.GetVector3Item(idx++); // taper_a
                        revolutions = (float)rules.GetLSLFloatItem(idx++);
                        radiusoffset = (float)rules.GetLSLFloatItem(idx++);
                        skew = (float)rules.GetLSLFloatItem(idx++);
                        (part as SceneObjectPart).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as SceneObjectPart), face, v, hollow, twist, holesize, topshear, profilecut, taper_b,
                                                revolutions, radiusoffset, skew, 3);
                    }

                    else if (code == (int)ScriptBaseClass.PRIM_TYPE_SCULPT)
                    {
                        if (remain < 2)
                            return;

                        string map = rules.Data[idx++].ToString();
                        face = (int)rules.GetLSLIntegerItem(idx++); // type
                        (part as SceneObjectPart).Shape.PathCurve = (byte)Extrusion.Curve1;
                        SetPrimitiveShapeParams((part as SceneObjectPart), map, face);
                    }
                }

                else if (code == (int)ScriptBaseClass.PRIM_TEXTURE)
                {
                    if (remain < 5)
                        return;
                    if (part is SceneObjectPart) { }
                    else
                        return;
                    face = (int)rules.GetLSLIntegerItem(idx++);
                    string tex = rules.Data[idx++].ToString();
                    LSL_Vector repeats = rules.GetVector3Item(idx++);
                    LSL_Vector offsets = rules.GetVector3Item(idx++);
                    double rotation = (double)rules.GetLSLFloatItem(idx++);

                    SetTexture((part as SceneObjectPart), tex, face);
                    ScaleTexture((part as SceneObjectPart), repeats.x, repeats.y, face);
                    OffsetTexture((part as SceneObjectPart), offsets.x, offsets.y, face);
                    RotateTexture((part as SceneObjectPart), rotation, face);

                }

                else if (code == (int)ScriptBaseClass.PRIM_COLOR)
                {
                    if (remain < 3)
                        return;
                    if (part is SceneObjectPart) { }
                    else
                        return;
                    face = (int)rules.GetLSLIntegerItem(idx++);
                    LSL_Vector color = rules.GetVector3Item(idx++);
                    double alpha = (double)rules.GetLSLFloatItem(idx++);

                    (part as SceneObjectPart).SetFaceColor(new Vector3((float)color.x, (float)color.y, (float)color.z), face);
                    SetAlpha((part as SceneObjectPart), alpha, face);

                }

                else if (code == (int)ScriptBaseClass.PRIM_FLEXIBLE)
                {
                    if (remain < 7)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    bool flexi = rules.GetLSLIntegerItem(idx++);
                    int softness = rules.GetLSLIntegerItem(idx++);
                    float gravity = (float)rules.GetLSLFloatItem(idx++);
                    float friction = (float)rules.GetLSLFloatItem(idx++);
                    float wind = (float)rules.GetLSLFloatItem(idx++);
                    float tension = (float)rules.GetLSLFloatItem(idx++);
                    LSL_Vector force = rules.GetVector3Item(idx++);

                    SetFlexi((part as SceneObjectPart), flexi, softness, gravity, friction, wind, tension, force);
                }
                else if (code == (int)ScriptBaseClass.PRIM_POINT_LIGHT)
                {
                    if (remain < 5)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    bool light = rules.GetLSLIntegerItem(idx++);
                    LSL_Vector lightcolor = rules.GetVector3Item(idx++);
                    float intensity = (float)rules.GetLSLFloatItem(idx++);
                    float radius = (float)rules.GetLSLFloatItem(idx++);
                    float falloff = (float)rules.GetLSLFloatItem(idx++);

                    SetPointLight((part as SceneObjectPart), light, lightcolor, intensity, radius, falloff);

                }

                else if (code == (int)ScriptBaseClass.PRIM_GLOW)
                {
                    if (remain < 2)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    face = rules.GetLSLIntegerItem(idx++);
                    float glow = (float)rules.GetLSLFloatItem(idx++);

                    SetGlow((part as SceneObjectPart), face, glow);

                }
                else if (code == (int)ScriptBaseClass.PRIM_BUMP_SHINY)
                {
                    if (remain < 3)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    face = (int)rules.GetLSLIntegerItem(idx++);
                    int shiny = (int)rules.GetLSLIntegerItem(idx++);
                    Bumpiness bump = (Bumpiness)Convert.ToByte((int)rules.GetLSLIntegerItem(idx++));

                    SetShiny((part as SceneObjectPart), face, shiny, bump);

                }
                else if (code == (int)ScriptBaseClass.PRIM_FULLBRIGHT)
                {
                    if (remain < 2)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    face = rules.GetLSLIntegerItem(idx++);
                    bool st = rules.GetLSLIntegerItem(idx++);
                    SetFullBright((part as SceneObjectPart), face, st);
                }

                else if (code == (int)ScriptBaseClass.PRIM_MATERIAL)
                {
                    if (remain < 1)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    int mat = rules.GetLSLIntegerItem(idx++);
                    if (mat < 0 || mat > 7)
                        return;

                    (part as SceneObjectPart).Material = Convert.ToByte(mat);
                }
                else if (code == (int)ScriptBaseClass.PRIM_PHANTOM)
                {
                    if (remain < 1)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    string ph = rules.Data[idx++].ToString();
                    bool phantom;

                    if (ph.Equals("1"))
                        phantom = true;
                    else
                        phantom = false;

                    (part as SceneObjectPart).ScriptSetPhantomStatus(phantom);
                }
                else if (code == (int)ScriptBaseClass.PRIM_PHYSICS)
                {
                    if (remain < 1)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    string phy = rules.Data[idx++].ToString();
                    bool physics;

                    if (phy.Equals("1"))
                        physics = true;
                    else
                        physics = false;

                    (part as SceneObjectPart).ScriptSetPhysicsStatus(physics);
                }
                else if (code == (int)ScriptBaseClass.PRIM_TEMP_ON_REZ)
                {
                    if (remain < 1)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    string temp = rules.Data[idx++].ToString();
                    bool tempOnRez;

                    if (temp.Equals("1"))
                        tempOnRez = true;
                    else
                        tempOnRez = false;

                    (part as SceneObjectPart).ScriptSetTemporaryStatus(tempOnRez);
                }
                else if (code == (int)ScriptBaseClass.PRIM_TEXGEN)
                {
                    if (remain < 2)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    //face,type
                    face = rules.GetLSLIntegerItem(idx++);
                    int style = rules.GetLSLIntegerItem(idx++);
                    SetTexGen((part as SceneObjectPart), face, style);
                }
                else if (code == (int)ScriptBaseClass.PRIM_TEXT)
                {
                    if (remain < 3)
                        return;
                    if (!(part is SceneObjectPart))
                        return;
                    string primText = rules.GetLSLStringItem(idx++);
                    LSL_Vector primTextColor = rules.GetVector3Item(idx++);
                    LSL_Float primTextAlpha = rules.GetLSLFloatItem(idx++);
                    Vector3 av3 = new Vector3(Util.Clip((float)primTextColor.x, 0.0f, 1.0f),
                                  Util.Clip((float)primTextColor.y, 0.0f, 1.0f),
                                  Util.Clip((float)primTextColor.z, 0.0f, 1.0f));
                    (part as SceneObjectPart).SetText(primText, av3, Util.Clip((float)primTextAlpha, 0.0f, 1.0f));

                }
            }
        }
Example #26
0
        private void SetParticleSystem(SceneObjectPart part, LSL_List rules)
        {
            if (rules.Length == 0)
            {
                part.RemoveParticleSystem();
                part.ParentGroup.HasGroupChanged = true;
            }
            else
            {
                Primitive.ParticleSystem prules = getNewParticleSystemWithSLDefaultValues();
                LSL_Vector tempv = new LSL_Vector();

                float tempf = 0;

                for (int i = 0; i < rules.Length; i += 2)
                {
                    LSL_Integer rule = rules.GetLSLIntegerItem(i);
                    if (rule == (int)ScriptBaseClass.PSYS_PART_FLAGS)
                    {
                        prules.PartDataFlags = (Primitive.ParticleSystem.ParticleDataFlags)(uint)rules.GetLSLIntegerItem(i + 1);
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_PART_START_COLOR)
                    {
                        tempv = rules.GetVector3Item(i + 1);
                        prules.PartStartColor.R = (float)tempv.x;
                        prules.PartStartColor.G = (float)tempv.y;
                        prules.PartStartColor.B = (float)tempv.z;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_PART_START_ALPHA)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.PartStartColor.A = tempf;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_PART_END_COLOR)
                    {
                        tempv = rules.GetVector3Item(i + 1);
                        prules.PartEndColor.R = (float)tempv.x;
                        prules.PartEndColor.G = (float)tempv.y;
                        prules.PartEndColor.B = (float)tempv.z;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_PART_END_ALPHA)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.PartEndColor.A = tempf;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_PART_START_SCALE)
                    {
                        tempv = rules.GetVector3Item(i + 1);
                        prules.PartStartScaleX = (float)tempv.x;
                        prules.PartStartScaleY = (float)tempv.y;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_PART_END_SCALE)
                    {
                        tempv = rules.GetVector3Item(i + 1);
                        prules.PartEndScaleX = (float)tempv.x;
                        prules.PartEndScaleY = (float)tempv.y;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_PART_MAX_AGE)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.PartMaxAge = tempf;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_ACCEL)
                    {
                        tempv = rules.GetVector3Item(i + 1);
                        prules.PartAcceleration.X = (float)tempv.x;
                        prules.PartAcceleration.Y = (float)tempv.y;
                        prules.PartAcceleration.Z = (float)tempv.z;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_PATTERN)
                    {
                        int tmpi = (int)rules.GetLSLIntegerItem(i + 1);
                        prules.Pattern = (Primitive.ParticleSystem.SourcePattern)tmpi;
                    }

                    // PSYS_SRC_INNERANGLE and PSYS_SRC_ANGLE_BEGIN use the same variables. The
                    // PSYS_SRC_OUTERANGLE and PSYS_SRC_ANGLE_END also use the same variable. The
                    // client tells the difference between the two by looking at the 0x02 bit in
                    // the PartFlags variable.
                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_INNERANGLE)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.InnerAngle = (float)tempf;
                        prules.PartFlags &= 0xFFFFFFFD; // Make sure new angle format is off.
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_OUTERANGLE)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.OuterAngle = (float)tempf;
                        prules.PartFlags &= 0xFFFFFFFD; // Make sure new angle format is off.
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_TEXTURE)
                    {
                        prules.Texture = KeyOrName(rules.GetLSLStringItem(i + 1));
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_BURST_RATE)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.BurstRate = (float)tempf;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_BURST_PART_COUNT)
                    {
                        prules.BurstPartCount = (byte)(int)rules.GetLSLIntegerItem(i + 1);
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_BURST_RADIUS)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.BurstRadius = (float)tempf;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_BURST_SPEED_MIN)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.BurstSpeedMin = (float)tempf;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_BURST_SPEED_MAX)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.BurstSpeedMax = (float)tempf;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_MAX_AGE)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.MaxAge = (float)tempf;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_TARGET_KEY)
                    {
                        UUID key = UUID.Zero;
                        if (UUID.TryParse(rules.Data[i + 1].ToString(), out key))
                        {
                            prules.Target = key;
                        }
                        else
                        {
                            prules.Target = part.UUID;
                        }
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_OMEGA)
                    {
                        // AL: This is an assumption, since it is the only thing that would match.
                        tempv = rules.GetVector3Item(i + 1);
                        prules.AngularVelocity.X = (float)tempv.x;
                        prules.AngularVelocity.Y = (float)tempv.y;
                        prules.AngularVelocity.Z = (float)tempv.z;
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_ANGLE_BEGIN)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.InnerAngle = (float)tempf;
                        prules.PartFlags |= 0x02; // Set new angle format.
                    }

                    else if (rule == (int)ScriptBaseClass.PSYS_SRC_ANGLE_END)
                    {
                        tempf = (float)rules.GetLSLFloatItem(i + 1);
                        prules.OuterAngle = (float)tempf;
                        prules.PartFlags |= 0x02; // Set new angle format.
                    }
                }
                prules.CRC = 1;

                part.AddNewParticleSystem(prules);
                part.ParentGroup.HasGroupChanged = true;
            }
            part.ScheduleUpdate(PrimUpdateFlags.Particles);
        }
Example #27
0
        /// <summary>
        /// A partial implementation.
        /// http://lslwiki.net/lslwiki/wakka.php?wakka=llGetBoundingBox
        /// So far only valid for standing/flying/ground sitting avatars and single prim objects.
        /// If the object has multiple prims and/or a sitting avatar then the bounding
        /// box is for the root prim only.
        /// </summary>
        public LSL_List llGetBoundingBox(string obj)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            
            UUID objID = UUID.Zero;
            LSL_List result = new LSL_List();
            if (!UUID.TryParse(obj, out objID))
            {
                result.Add(new LSL_Vector());
                result.Add(new LSL_Vector());
                return result;
            }
            ScenePresence presence = World.GetScenePresence(objID);
            if (presence != null)
            {
                if (presence.ParentID == UUID.Zero) // not sat on an object
                {
                    LSL_Vector lower;
                    LSL_Vector upper;
                    if (presence.Animator.Animations.DefaultAnimation.AnimID 
                        == AnimationSet.Animations.AnimsUUID["SIT_GROUND_CONSTRAINED"])
                    {
                        // This is for ground sitting avatars
                        float height = presence.Appearance.AvatarHeight / 2.66666667f;
                        lower = new LSL_Vector(-0.3375f, -0.45f, height * -1.0f);
                        upper = new LSL_Vector(0.3375f, 0.45f, 0.0f);
                    }
                    else
                    {
                        // This is for standing/flying avatars
                        float height = presence.Appearance.AvatarHeight / 2.0f;
                        lower = new LSL_Vector(-0.225f, -0.3f, height * -1.0f);
                        upper = new LSL_Vector(0.225f, 0.3f, height + 0.05f);
                    }
                    result.Add(lower);
                    result.Add(upper);
                    return result;
                }
                else
                {
                    // sitting on an object so we need the bounding box of that
                    // which should include the avatar so set the UUID to the
                    // UUID of the object the avatar is sat on and allow it to fall through
                    // to processing an object
                    SceneObjectPart p = World.GetSceneObjectPart(presence.ParentID);
                    objID = p.UUID;
                }
            }
            SceneObjectPart part = World.GetSceneObjectPart(objID);
            // Currently only works for single prims without a sitting avatar
            if (part != null)
            {
                Vector3 halfSize = part.Scale * 0.5f;
                LSL_Vector lower = new LSL_Vector(halfSize.X * -1.0f, halfSize.Y * -1.0f, halfSize.Z * -1.0f);
                LSL_Vector upper = new LSL_Vector(halfSize.X, halfSize.Y, halfSize.Z);
                result.Add(lower);
                result.Add(upper);
                return result;
            }

            // Not found so return empty values
            result.Add(new LSL_Vector());
            result.Add(new LSL_Vector());
            return result;
        }
Example #28
0
        public void llGiveInventoryList(string destination, string category, LSL_List inventory)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            UUID destID;
            if (!UUID.TryParse(destination, out destID))
                return;

            List<UUID> itemList = new List<UUID>();

            foreach (Object item in inventory.Data)
            {
                UUID itemID;
                if (UUID.TryParse(item.ToString(), out itemID))
                {
                    itemList.Add(itemID);
                }
                else
                {
                    itemID = GetTaskInventoryItem(item.ToString());
                    if (itemID != UUID.Zero)
                        itemList.Add(itemID);
                }
            }

            if (itemList.Count == 0)
                return;
            UUID folderID = UUID.Zero;
            ILLClientInventory inventoryModule = World.RequestModuleInterface<ILLClientInventory>();
            if (inventoryModule != null)
                folderID = inventoryModule.MoveTaskInventoryItemsToUserInventory(destID, category, m_host, itemList);

            if (folderID == UUID.Zero)
                return;

            byte[] bucket = new byte[17];
            bucket[0] = (byte)AssetType.Folder;
            byte[] objBytes = folderID.GetBytes();
            Array.Copy(objBytes, 0, bucket, 1, 16);

            GridInstantMessage msg = new GridInstantMessage(World,
                    m_host.UUID, m_host.Name+", an object owned by "+
                    resolveName(m_host.OwnerID)+",", destID,
                    (byte)InstantMessageDialog.InventoryOffered,
                    false, category+"\n"+m_host.Name+" is located at "+
                    World.RegionInfo.RegionName+" "+
                    m_host.AbsolutePosition.ToString(),
                    folderID, true, m_host.AbsolutePosition,
                    bucket);

            if (m_TransferModule != null)
                m_TransferModule.SendInstantMessage(msg);
        }
Example #29
0
        public LSL_List llGetLinkPrimitiveParams(int linknumber, LSL_List rules)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            
            
            List<SceneObjectPart> parts = GetLinkParts(linknumber);

            LSL_List res = new LSL_List();

            foreach (var part in parts)
            {
                LSL_List partRes = GetLinkPrimitiveParams(part, rules);
                res += partRes;
            }

            return res;
        }
Example #30
0
 public LSL_String llDumpList2String(LSL_List src, string seperator)
 {
     ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
     
     if (src.Length == 0)
     {
         return String.Empty;
     }
     string ret = String.Empty;
     foreach (object o in src.Data)
     {
         ret = ret + o.ToString() + seperator;
     }
     ret = ret.Substring(0, ret.Length - seperator.Length);
     return ret;
 }
Example #31
0
        //  <summary>
        //  Scan the string supplied in 'src' and
        //  tokenize it based upon two sets of
        //  tokenizers provided in two lists,
        //  separators and spacers.
        //  </summary>
        //
        //  <remarks>
        //  Separators demarcate tokens and are
        //  elided as they are encountered. Spacers
        //  also demarcate tokens, but are themselves
        //  retained as tokens.
        //
        //  Both separators and spacers may be arbitrarily
        //  long strings. i.e. ":::".
        //
        //  The function returns an ordered list
        //  representing the tokens found in the supplied
        //  sources string. If two successive tokenizers
        //  are encountered, then a NULL entry is added
        //  to the list.
        //
        //  It is a precondition that the source and
        //  toekizer lisst are non-null. If they are null,
        //  then a null pointer exception will be thrown
        //  while their lengths are being determined.
        //
        //  A small amount of working memoryis required
        //  of approximately 8*#tokenizers.
        //
        //  There are many ways in which this function
        //  can be implemented, this implementation is
        //  fairly naive and assumes that when the
        //  function is invooked with a short source
        //  string and/or short lists of tokenizers, then
        //  performance will not be an issue.
        //
        //  In order to minimize the perofrmance
        //  effects of long strings, or large numbers
        //  of tokeizers, the function skips as far as
        //  possible whenever a toekenizer is found,
        //  and eliminates redundant tokenizers as soon
        //  as is possible.
        //
        //  The implementation tries to avoid any copying
        //  of arrays or other objects.
        //  </remarks>

        private LSL_List ParseString(string src, LSL_List separators, LSL_List spacers, bool keepNulls)
        {
            int beginning = 0;
            int srclen = src.Length;
            int seplen = separators.Length;
            object[] separray = separators.Data;
            int spclen = spacers.Length;
            object[] spcarray = spacers.Data;
            int mlen = seplen + spclen;

            int[] offset = new int[mlen + 1];
            bool[] active = new bool[mlen];

            int best;
            int j;

            //    Initial capacity reduces resize cost

            LSL_List tokens = new LSL_List();

            //    All entries are initially valid

            for (int i = 0; i < mlen; i++)
                active[i] = true;

            offset[mlen] = srclen;

            while (beginning < srclen)
            {

                best = mlen;    // as bad as it gets

                //    Scan for separators

                for (j = 0; j < seplen; j++)
                {
                    if (separray[j].ToString() == String.Empty)
                        active[j] = false;

                    if (active[j])
                    {
                        // scan all of the markers
                        if ((offset[j] = src.IndexOf(separray[j].ToString(), beginning)) == -1)
                        {
                            // not present at all
                            active[j] = false;
                        }
                        else
                        {
                            // present and correct
                            if (offset[j] < offset[best])
                            {
                                // closest so far
                                best = j;
                                if (offset[best] == beginning)
                                    break;
                            }
                        }
                    }
                }

                //    Scan for spacers

                if (offset[best] != beginning)
                {
                    for (j = seplen; (j < mlen) && (offset[best] > beginning); j++)
                    {
                        if (spcarray[j - seplen].ToString() == String.Empty)
                            active[j] = false;

                        if (active[j])
                        {
                            // scan all of the markers
                            if ((offset[j] = src.IndexOf(spcarray[j - seplen].ToString(), beginning)) == -1)
                            {
                                // not present at all
                                active[j] = false;
                            }
                            else
                            {
                                // present and correct
                                if (offset[j] < offset[best])
                                {
                                    // closest so far
                                    best = j;
                                }
                            }
                        }
                    }
                }

                //    This is the normal exit from the scanning loop

                if (best == mlen)
                {
                    // no markers were found on this pass
                    // so we're pretty much done
                    if ((keepNulls) || ((!keepNulls) && (srclen - beginning) > 0))
                        tokens.Add(new LSL_String(src.Substring(beginning, srclen - beginning)));
                    break;
                }

                //    Otherwise we just add the newly delimited token
                //    and recalculate where the search should continue.
                if ((keepNulls) || ((!keepNulls) && (offset[best] - beginning) > 0))
                    tokens.Add(new LSL_String(src.Substring(beginning, offset[best] - beginning)));

                if (best < seplen)
                {
                    beginning = offset[best] + (separray[best].ToString()).Length;
                }
                else
                {
                    beginning = offset[best] + (spcarray[best - seplen].ToString()).Length;
                    string str = spcarray[best - seplen].ToString();
                    if ((keepNulls) || ((!keepNulls) && (str.Length > 0)))
                        tokens.Add(new LSL_String(str));
                }
            }

            //    This an awkward an not very intuitive boundary case. If the
            //    last substring is a tokenizer, then there is an implied trailing
            //    null list entry. Hopefully the single comparison will not be too
            //    arduous. Alternatively the 'break' could be replced with a return
            //    but that's shabby programming.

            if ((beginning == srclen) && (keepNulls))
            {
                if (srclen != 0)
                    tokens.Add(new LSL_String(""));
            }

            return tokens;
        }
Example #32
0
 private RegionLightShareData getWindlightProfileFromRules(LSL_List rules)
 {
     /*RegionLightShareData wl = m_lightShareModule.WindLightSettings;
      *
      * LSL_List values = new LSL_List();
      * int idx = 0;
      * while (idx < rules.Length)
      * {
      *  uint rule = (uint)rules.GetLSLIntegerItem(idx);
      *  LSL_Types.Quaternion iQ;
      *  LSL_Types.Vector3 iV;
      *  switch (rule)
      *  {
      *      case (int)ScriptBaseClass.WL_SUN_MOON_POSITION:
      *          idx++;
      *          wl.sunMoonPosition = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_AMBIENT:
      *          idx++;
      *          iQ = rules.GetQuaternionItem(idx);
      *          wl.ambient = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
      *          break;
      *      case (int)ScriptBaseClass.WL_BIG_WAVE_DIRECTION:
      *          idx++;
      *          iV = rules.GetVector3Item(idx);
      *          wl.bigWaveDirection = new Vector2((float)iV.x, (float)iV.y);
      *          break;
      *      case (int)ScriptBaseClass.WL_BLUE_DENSITY:
      *          idx++;
      *          iQ = rules.GetQuaternionItem(idx);
      *          wl.blueDensity = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
      *          break;
      *      case (int)ScriptBaseClass.WL_BLUR_MULTIPLIER:
      *          idx++;
      *          wl.blurMultiplier = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_COLOR:
      *          idx++;
      *          iQ = rules.GetQuaternionItem(idx);
      *          wl.cloudColor = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_COVERAGE:
      *          idx++;
      *          wl.cloudCoverage = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_DETAIL_XY_DENSITY:
      *          idx++;
      *          iV = rules.GetVector3Item(idx);
      *          wl.cloudDetailXYDensity = new Vector3((float)iV.x, (float)iV.y, (float)iV.z);
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_SCALE:
      *          idx++;
      *          wl.cloudScale = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_SCROLL_X:
      *          idx++;
      *          wl.cloudScrollX = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_SCROLL_X_LOCK:
      *          idx++;
      *          wl.cloudScrollXLock = rules.GetLSLIntegerItem(idx).value == 1 ? true : false;
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_SCROLL_Y:
      *          idx++;
      *          wl.cloudScrollY = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_SCROLL_Y_LOCK:
      *          idx++;
      *          wl.cloudScrollYLock = rules.GetLSLIntegerItem(idx).value == 1 ? true : false;
      *          break;
      *      case (int)ScriptBaseClass.WL_CLOUD_XY_DENSITY:
      *          idx++;
      *          iV = rules.GetVector3Item(idx);
      *          wl.cloudXYDensity = new Vector3((float)iV.x, (float)iV.y, (float)iV.z);
      *          break;
      *      case (int)ScriptBaseClass.WL_DENSITY_MULTIPLIER:
      *          idx++;
      *          wl.densityMultiplier = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_DISTANCE_MULTIPLIER:
      *          idx++;
      *          wl.distanceMultiplier = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_DRAW_CLASSIC_CLOUDS:
      *          idx++;
      *          wl.drawClassicClouds = rules.GetLSLIntegerItem(idx).value == 1 ? true : false;
      *          break;
      *      case (int)ScriptBaseClass.WL_EAST_ANGLE:
      *          idx++;
      *          wl.eastAngle = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_FRESNEL_OFFSET:
      *          idx++;
      *          wl.fresnelOffset = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_FRESNEL_SCALE:
      *          idx++;
      *          wl.fresnelScale = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_HAZE_DENSITY:
      *          idx++;
      *          wl.hazeDensity = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_HAZE_HORIZON:
      *          idx++;
      *          wl.hazeHorizon = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_HORIZON:
      *          idx++;
      *          iQ = rules.GetQuaternionItem(idx);
      *          wl.horizon = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
      *          break;
      *      case (int)ScriptBaseClass.WL_LITTLE_WAVE_DIRECTION:
      *          idx++;
      *          iV = rules.GetVector3Item(idx);
      *          wl.littleWaveDirection = new Vector2((float)iV.x, (float)iV.y);
      *          break;
      *      case (int)ScriptBaseClass.WL_MAX_ALTITUDE:
      *          idx++;
      *          wl.maxAltitude = (ushort)rules.GetLSLIntegerItem(idx).value;
      *          break;
      *      case (int)ScriptBaseClass.WL_NORMAL_MAP_TEXTURE:
      *          idx++;
      *          wl.normalMapTexture = new UUID(rules.GetLSLStringItem(idx).m_string);
      *          break;
      *      case (int)ScriptBaseClass.WL_REFLECTION_WAVELET_SCALE:
      *          idx++;
      *          iV = rules.GetVector3Item(idx);
      *          wl.reflectionWaveletScale = new Vector3((float)iV.x, (float)iV.y, (float)iV.z);
      *          break;
      *      case (int)ScriptBaseClass.WL_REFRACT_SCALE_ABOVE:
      *          idx++;
      *          wl.refractScaleAbove = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_REFRACT_SCALE_BELOW:
      *          idx++;
      *          wl.refractScaleBelow = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_SCENE_GAMMA:
      *          idx++;
      *          wl.sceneGamma = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_STAR_BRIGHTNESS:
      *          idx++;
      *          wl.starBrightness = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_SUN_GLOW_FOCUS:
      *          idx++;
      *          wl.sunGlowFocus = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_SUN_GLOW_SIZE:
      *          idx++;
      *          wl.sunGlowSize = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_SUN_MOON_COLOR:
      *          idx++;
      *          iQ = rules.GetQuaternionItem(idx);
      *          wl.sunMoonColor = new Vector4((float)iQ.x, (float)iQ.y, (float)iQ.z, (float)iQ.s);
      *          break;
      *      case (int)ScriptBaseClass.WL_UNDERWATER_FOG_MODIFIER:
      *          idx++;
      *          wl.underwaterFogModifier = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *      case (int)ScriptBaseClass.WL_WATER_COLOR:
      *          idx++;
      *          iV = rules.GetVector3Item(idx);
      *          wl.waterColor = new Vector4((float)iV.x, (float)iV.y, (float)iV.z, 0);
      *          break;
      *      case (int)ScriptBaseClass.WL_WATER_FOG_DENSITY_EXPONENT:
      *          idx++;
      *          wl.waterFogDensityExponent = (float)rules.GetLSLFloatItem(idx);
      *          break;
      *  }
      *  idx++;
      * }
      * wl.regionID = m_host.ParentGroup.Scene.RegionInfo.RegionID;
      * return wl;*/
     return(null);
 }
Example #33
0
 public LSL_List aaDeserializeXMLValues(LSL_String xmlFile)
 {
     if (
         !ScriptProtection.CheckThreatLevel(ThreatLevel.Moderate, "AADeserializeXMLValues", m_host, "AA",
                                            m_itemID)) return new LSL_List();
     XmlDocument doc = new XmlDocument();
     doc.LoadXml(xmlFile.m_string);
     XmlNodeList children = doc.ChildNodes;
     LSL_List values = new LSL_List();
     foreach (XmlNode node in children)
     {
         values.Add(node.InnerText);
     }
     return values;
 }
Example #34
0
 public void aaSetEnv(LSL_String name, LSL_List value)
 {
     if (name == ScriptBaseClass.ENABLE_GRAVITY)
     {
         LSL_Integer enabled = value.GetLSLIntegerItem(0);
         float[]     grav    = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.SetGravityForce(enabled == 1, grav[0], grav[1], grav[2]);
     }
     else if (name == ScriptBaseClass.GRAVITY_FORCE_X)
     {
         LSL_Float f    = value.GetLSLFloatItem(0);
         float[]   grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.SetGravityForce(true, (float)f.value, grav[1], grav[2]);
     }
     else if (name == ScriptBaseClass.GRAVITY_FORCE_Y)
     {
         LSL_Float f    = value.GetLSLFloatItem(0);
         float[]   grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.SetGravityForce(true, grav[0], (float)f.value, grav[2]);
     }
     else if (name == ScriptBaseClass.GRAVITY_FORCE_Z)
     {
         LSL_Float f    = value.GetLSLFloatItem(0);
         float[]   grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.SetGravityForce(true, grav[0], grav[1], (float)f.value);
     }
     else if (name == ScriptBaseClass.ADD_GRAVITY_POINT)
     {
         LSL_Vector  pos       = value.GetVector3Item(0);
         LSL_Float   gravForce = value.GetLSLFloatItem(1);
         LSL_Float   radius    = value.GetLSLFloatItem(2);
         LSL_Integer ident     = value.GetLSLIntegerItem(3);
         float[]     grav      = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.AddGravityPoint(false,
                                                                new Vector3((float)pos.x, (float)pos.y,
                                                                            (float)pos.z),
                                                                0, 0, 0, (float)gravForce.value,
                                                                (float)radius.value, ident.value);
     }
     else if (name == ScriptBaseClass.ADD_GRAVITY_FORCE)
     {
         LSL_Vector  pos    = value.GetVector3Item(0);
         LSL_Float   xForce = value.GetLSLFloatItem(1);
         LSL_Float   yForce = value.GetLSLFloatItem(2);
         LSL_Float   zForce = value.GetLSLFloatItem(3);
         LSL_Float   radius = value.GetLSLFloatItem(4);
         LSL_Integer ident  = value.GetLSLIntegerItem(5);
         float[]     grav   = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.AddGravityPoint(true,
                                                                new Vector3((float)pos.x, (float)pos.y,
                                                                            (float)pos.z),
                                                                (float)xForce, (float)yForce, (float)zForce, 0,
                                                                (float)radius.value, ident.value);
     }
     else if (name == ScriptBaseClass.START_TIME_REVERSAL_SAVING)
     {
         IPhysicsStateModule physicsState = World.RequestModuleInterface <IPhysicsStateModule>();
         if (physicsState != null)
         {
             physicsState.StartSavingPhysicsTimeReversalStates();
         }
     }
     else if (name == ScriptBaseClass.STOP_TIME_REVERSAL_SAVING)
     {
         IPhysicsStateModule physicsState = World.RequestModuleInterface <IPhysicsStateModule>();
         if (physicsState != null)
         {
             physicsState.StopSavingPhysicsTimeReversalStates();
         }
     }
     else if (name == ScriptBaseClass.START_TIME_REVERSAL)
     {
         IPhysicsStateModule physicsState = World.RequestModuleInterface <IPhysicsStateModule>();
         if (physicsState != null)
         {
             physicsState.StartPhysicsTimeReversal();
         }
     }
     else if (name == ScriptBaseClass.STOP_TIME_REVERSAL)
     {
         IPhysicsStateModule physicsState = World.RequestModuleInterface <IPhysicsStateModule>();
         if (physicsState != null)
         {
             physicsState.StopPhysicsTimeReversal();
         }
     }
 }
Example #35
0
 public void aaSetEnv(LSL_String name, LSL_List value)
 {
     if (name == ScriptBaseClass.ENABLE_GRAVITY)
     {
         LSL_Integer enabled = value.GetLSLIntegerItem(0);
         float[] grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.SetGravityForce(enabled == 1, grav[0], grav[1], grav[2]);
     }
     else if (name == ScriptBaseClass.GRAVITY_FORCE_X)
     {
         LSL_Float f = value.GetLSLFloatItem(0);
         float[] grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.SetGravityForce(true, (float) f.value, grav[1], grav[2]);
     }
     else if (name == ScriptBaseClass.GRAVITY_FORCE_Y)
     {
         LSL_Float f = value.GetLSLFloatItem(0);
         float[] grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.SetGravityForce(true, grav[0], (float) f.value, grav[2]);
     }
     else if (name == ScriptBaseClass.GRAVITY_FORCE_Z)
     {
         LSL_Float f = value.GetLSLFloatItem(0);
         float[] grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.SetGravityForce(true, grav[0], grav[1], (float) f.value);
     }
     else if (name == ScriptBaseClass.ADD_GRAVITY_POINT)
     {
         LSL_Vector pos = value.GetVector3Item(0);
         LSL_Float gravForce = value.GetLSLFloatItem(1);
         LSL_Float radius = value.GetLSLFloatItem(2);
         LSL_Integer ident = value.GetLSLIntegerItem(3);
         float[] grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.AddGravityPoint(false,
                                                                new Vector3((float) pos.x, (float) pos.y,
                                                                            (float) pos.z),
                                                                0, 0, 0, (float) gravForce.value,
                                                                (float) radius.value, ident.value);
     }
     else if (name == ScriptBaseClass.ADD_GRAVITY_FORCE)
     {
         LSL_Vector pos = value.GetVector3Item(0);
         LSL_Float xForce = value.GetLSLFloatItem(1);
         LSL_Float yForce = value.GetLSLFloatItem(2);
         LSL_Float zForce = value.GetLSLFloatItem(3);
         LSL_Float radius = value.GetLSLFloatItem(4);
         LSL_Integer ident = value.GetLSLIntegerItem(5);
         float[] grav = m_host.ParentEntity.Scene.PhysicsScene.GetGravityForce();
         m_host.ParentEntity.Scene.PhysicsScene.AddGravityPoint(true,
                                                                new Vector3((float) pos.x, (float) pos.y,
                                                                            (float) pos.z),
                                                                (float) xForce, (float) yForce, (float) zForce, 0,
                                                                (float) radius.value, ident.value);
     }
     else if (name == ScriptBaseClass.START_TIME_REVERSAL_SAVING)
     {
         IPhysicsStateModule physicsState = World.RequestModuleInterface<IPhysicsStateModule>();
         if (physicsState != null)
             physicsState.StartSavingPhysicsTimeReversalStates();
     }
     else if (name == ScriptBaseClass.STOP_TIME_REVERSAL_SAVING)
     {
         IPhysicsStateModule physicsState = World.RequestModuleInterface<IPhysicsStateModule>();
         if (physicsState != null)
             physicsState.StopSavingPhysicsTimeReversalStates();
     }
     else if (name == ScriptBaseClass.START_TIME_REVERSAL)
     {
         IPhysicsStateModule physicsState = World.RequestModuleInterface<IPhysicsStateModule>();
         if (physicsState != null)
             physicsState.StartPhysicsTimeReversal();
     }
     else if (name == ScriptBaseClass.STOP_TIME_REVERSAL)
     {
         IPhysicsStateModule physicsState = World.RequestModuleInterface<IPhysicsStateModule>();
         if (physicsState != null)
             physicsState.StopPhysicsTimeReversal();
     }
 }
Example #36
0
        public void llSetLinkPrimitiveParams(int linknumber, LSL_List rules)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            

            List<ISceneEntity> parts = GetLinkPartsAndEntities(linknumber);

            foreach (ISceneEntity part in parts)
                SetPrimParams(part, rules);
        }
Example #37
0
 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);
 }
Example #38
0
        public void llSetLinkPrimitiveParamsFast(int linknumber, LSL_List rules)
        {
            List<SceneObjectPart> parts = GetLinkParts(linknumber);

            foreach (SceneObjectPart part in parts)
                SetPrimParams(part, rules);
        }
Example #39
0
        /// <summary>
        /// Get the current Windlight scene
        /// </summary>
        /// <returns>List of windlight parameters</returns>
        public LSL_List lsGetWindlightScene(LSL_List rules)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "lsGetWindlightScene", m_host, "LS");

            /*RegionLightShareData wl = m_lightShareModule.WindLightSettings;
             *
             * LSL_List values = new LSL_List();
             * int idx = 0;
             * while (idx < rules.Length)
             * {
             *  uint rule = (uint)rules.GetLSLIntegerItem(idx);
             *  LSL_List toadd = new LSL_List();
             *
             *  switch (rule)
             *  {
             *      case (int)ScriptBaseClass.WL_AMBIENT:
             *          toadd.Add(new LSL_Rotation(wl.ambient.X, wl.ambient.Y, wl.ambient.Z, wl.ambient.W));
             *          break;
             *      case (int)ScriptBaseClass.WL_BIG_WAVE_DIRECTION:
             *          toadd.Add(new LSL_Vector(wl.bigWaveDirection.X, wl.bigWaveDirection.Y, 0.0f));
             *          break;
             *      case (int)ScriptBaseClass.WL_BLUE_DENSITY:
             *          toadd.Add(new LSL_Rotation(wl.blueDensity.X, wl.blueDensity.Y, wl.blueDensity.Z, wl.blueDensity.W));
             *          break;
             *      case (int)ScriptBaseClass.WL_BLUR_MULTIPLIER:
             *          toadd.Add(new LSL_Float(wl.blurMultiplier));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_COLOR:
             *          toadd.Add(new LSL_Rotation(wl.cloudColor.X, wl.cloudColor.Y, wl.cloudColor.Z, wl.cloudColor.W));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_COVERAGE:
             *          toadd.Add(new LSL_Float(wl.cloudCoverage));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_DETAIL_XY_DENSITY:
             *          toadd.Add(new LSL_Vector(wl.cloudDetailXYDensity.X, wl.cloudDetailXYDensity.Y, wl.cloudDetailXYDensity.Z));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_SCALE:
             *          toadd.Add(new LSL_Float(wl.cloudScale));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_SCROLL_X:
             *          toadd.Add(new LSL_Float(wl.cloudScrollX));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_SCROLL_X_LOCK:
             *          toadd.Add(new LSL_Integer(wl.cloudScrollXLock ? 1 : 0));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_SCROLL_Y:
             *          toadd.Add(new LSL_Float(wl.cloudScrollY));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_SCROLL_Y_LOCK:
             *          toadd.Add(new LSL_Integer(wl.cloudScrollYLock ? 1 : 0));
             *          break;
             *      case (int)ScriptBaseClass.WL_CLOUD_XY_DENSITY:
             *          toadd.Add(new LSL_Vector(wl.cloudXYDensity.X, wl.cloudXYDensity.Y, wl.cloudXYDensity.Z));
             *          break;
             *      case (int)ScriptBaseClass.WL_DENSITY_MULTIPLIER:
             *          toadd.Add(new LSL_Float(wl.densityMultiplier));
             *          break;
             *      case (int)ScriptBaseClass.WL_DISTANCE_MULTIPLIER:
             *          toadd.Add(new LSL_Float(wl.distanceMultiplier));
             *          break;
             *      case (int)ScriptBaseClass.WL_DRAW_CLASSIC_CLOUDS:
             *          toadd.Add(new LSL_Integer(wl.drawClassicClouds ? 1 : 0));
             *          break;
             *      case (int)ScriptBaseClass.WL_EAST_ANGLE:
             *          toadd.Add(new LSL_Float(wl.eastAngle));
             *          break;
             *      case (int)ScriptBaseClass.WL_FRESNEL_OFFSET:
             *          toadd.Add(new LSL_Float(wl.fresnelOffset));
             *          break;
             *      case (int)ScriptBaseClass.WL_FRESNEL_SCALE:
             *          toadd.Add(new LSL_Float(wl.fresnelScale));
             *          break;
             *      case (int)ScriptBaseClass.WL_HAZE_DENSITY:
             *          toadd.Add(new LSL_Float(wl.hazeDensity));
             *          break;
             *      case (int)ScriptBaseClass.WL_HAZE_HORIZON:
             *          toadd.Add(new LSL_Float(wl.hazeHorizon));
             *          break;
             *      case (int)ScriptBaseClass.WL_HORIZON:
             *          toadd.Add(new LSL_Rotation(wl.horizon.X, wl.horizon.Y, wl.horizon.Z, wl.horizon.W));
             *          break;
             *      case (int)ScriptBaseClass.WL_LITTLE_WAVE_DIRECTION:
             *          toadd.Add(new LSL_Vector(wl.littleWaveDirection.X, wl.littleWaveDirection.Y, 0.0f));
             *          break;
             *      case (int)ScriptBaseClass.WL_MAX_ALTITUDE:
             *          toadd.Add(new LSL_Integer(wl.maxAltitude));
             *          break;
             *      case (int)ScriptBaseClass.WL_NORMAL_MAP_TEXTURE:
             *          toadd.Add(new LSL_Key(wl.normalMapTexture.ToString()));
             *          break;
             *      case (int)ScriptBaseClass.WL_REFLECTION_WAVELET_SCALE:
             *          toadd.Add(new LSL_Vector(wl.reflectionWaveletScale.X, wl.reflectionWaveletScale.Y, wl.reflectionWaveletScale.Z));
             *          break;
             *      case (int)ScriptBaseClass.WL_REFRACT_SCALE_ABOVE:
             *          toadd.Add(new LSL_Float(wl.refractScaleAbove));
             *          break;
             *      case (int)ScriptBaseClass.WL_REFRACT_SCALE_BELOW:
             *          toadd.Add(new LSL_Float(wl.refractScaleBelow));
             *          break;
             *      case (int)ScriptBaseClass.WL_SCENE_GAMMA:
             *          toadd.Add(new LSL_Float(wl.sceneGamma));
             *          break;
             *      case (int)ScriptBaseClass.WL_STAR_BRIGHTNESS:
             *          toadd.Add(new LSL_Float(wl.starBrightness));
             *          break;
             *      case (int)ScriptBaseClass.WL_SUN_GLOW_FOCUS:
             *          toadd.Add(new LSL_Float(wl.sunGlowFocus));
             *          break;
             *      case (int)ScriptBaseClass.WL_SUN_GLOW_SIZE:
             *          toadd.Add(new LSL_Float(wl.sunGlowSize));
             *          break;
             *      case (int)ScriptBaseClass.WL_SUN_MOON_COLOR:
             *          toadd.Add(new LSL_Rotation(wl.sunMoonColor.X, wl.sunMoonColor.Y, wl.sunMoonColor.Z, wl.sunMoonColor.W));
             *          break;
             *      case (int)ScriptBaseClass.WL_UNDERWATER_FOG_MODIFIER:
             *          toadd.Add(new LSL_Float(wl.underwaterFogModifier));
             *          break;
             *      case (int)ScriptBaseClass.WL_WATER_COLOR:
             *          toadd.Add(new LSL_Vector(wl.waterColor.X, wl.waterColor.Y, wl.waterColor.Z));
             *          break;
             *      case (int)ScriptBaseClass.WL_WATER_FOG_DENSITY_EXPONENT:
             *          toadd.Add(new LSL_Float(wl.waterFogDensityExponent));
             *          break;
             *  }
             *
             *  if (toadd.Length > 0)
             *  {
             *      values.Add(rule);
             *      values.Add(toadd.Data[0]);
             *  }
             *  idx++;
             * }
             *
             *
             * return values;
             */
            return(null);
        }
Example #40
0
        public LSL_Integer llGetListEntryType(LSL_List src, int index)
        {
            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            
            if (index < 0)
            {
                index = src.Length + index;
            }
            if (index >= src.Length)
            {
                return 0;
            }

            if (src.Data[index] is LSL_Integer || src.Data[index] is Int32)
                return 1;
            if (src.Data[index] is LSL_Float || src.Data[index] is Single || src.Data[index] is Double)
                return 2;
            if (src.Data[index] is LSL_String || src.Data[index] is String)
            {
                UUID tuuid;
                if (UUID.TryParse(src.Data[index].ToString(), out tuuid))
                {
                    return 4;
                }
                else
                {
                    return 3;
                }
            }
            if (src.Data[index] is LSL_Vector)
                return 5;
            if (src.Data[index] is LSL_Rotation)
                return 6;
            if (src.Data[index] is LSL_List)
                return 7;
            return 0;

        }
Example #41
0
        public DateTime llDialog(string avatar, string message, LSL_List buttons, int chat_channel)
        {
            IDialogModule dm = World.RequestModuleInterface<IDialogModule>();

            if (dm == null)
                return DateTime.Now;

            ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
            
            UUID av = new UUID();
            if (!UUID.TryParse(avatar,out av))
            {
                //Silently accepted in in SL NOTE: it does sleep though!
                //LSLError("First parameter to llDialog needs to be a key");
                return PScriptSleep(1000);
            }
            if (buttons.Length > 12)
            {
                LSLError("No more than 12 buttons can be shown");
                return DateTime.Now;
            }
            string[] buts = new string[buttons.Length];
            for (int i = 0; i < buttons.Length; i++)
            {
                if (buttons.Data[i].ToString() == String.Empty)
                {
                    LSLError("button label cannot be blank");
                    return DateTime.Now;
                }
                if (buttons.Data[i].ToString().Length > 24)
                {
                    LSLError("button label cannot be longer than 24 characters");
                    return DateTime.Now;
                }
                buts[i] = buttons.Data[i].ToString();
            }
            if (buts.Length == 0)
                buts = new string[1] { "OK" };

            dm.SendDialogToUser(
                av, m_host.Name, m_host.UUID, m_host.OwnerID,
                message, new UUID("00000000-0000-2222-3333-100000001000"), chat_channel, buts);

            return PScriptSleep(1000);
        }
Example #42
0
 public void llSetPrimitiveParams(LSL_List rules)
 {
     ScriptProtection.CheckThreatLevel(ThreatLevel.None, "LSL", m_host, "LSL");
     
     SetPrimParams(m_host, rules);
 }