public override void FromOSD(OpenMetaverse.StructuredData.OSDMap map)
 {
     PrincipalID = map["PrincipalID"];
     Friend = map["Friend"];
     MyFlags = map["MyFlags"];
     TheirFlags = map["TheirFlags"];
 }

        internal AvatarAppearance ToAppearance(OpenMetaverse.UUID owner)
        {
            AvatarAppearance app =
                new AvatarAppearance
                {
                    Owner = owner,
                    Serial = this.Serial,
                    VisualParams = this.VisualParams
                };

            List<AvatarWearable> wearables = new List<AvatarWearable>();

            for (int i = 0; i < AvatarWearable.MAX_WEARABLES && i < this.Wearables.Length; i++)
            {
                OpenMetaverse.UUID itemID = new OpenMetaverse.UUID(this.Wearables[i].ItemId);
                OpenMetaverse.UUID assetID = new OpenMetaverse.UUID(this.Wearables[i].AssetId);

                wearables.Add(new AvatarWearable(i, itemID, assetID));
            }

            app.SetWearables(wearables);

            var te = new OpenMetaverse.Primitive.TextureEntry(this.TextureEntry, 0, this.TextureEntry.Length);
            app.SetTextureEntries(te);

            app.SetHeight();

            return app;
        }

 public AddForceCmd(PhysicsActor actor, OpenMetaverse.Vector3 force, OpenMetaverse.Vector3 forceOffset, ForceType type)
 {
     Actor = actor;
     Force = force;
     Type = type;
     ForceOffset = forceOffset;
 }

        public PrimVisualCylinder(OpenMetaverse.Primitive prim)
            : base(prim)
        {
            NumberFaces = 1;
            FirstOuterFace = 0;
            LastOuterFace = 0;

            OuterFaces = new CrossSection[1];
            OuterFaces[0] = new CrossSection();

            if (prim.PrimData.ProfileHollow != 0)
            {
                hollow = true;
                InnerFaces = new CrossSection[1];
                InnerFaces[0] = new CrossSection();

                //for (int i = 0; i < 4; i++)
                //{
                //    InnerFaces[i] = new CrossSection();
                //}
            }

            if (prim.PrimData.ProfileBegin != 0 || prim.PrimData.ProfileEnd != 1)
            {
                cut = true;
                CutFaces = new CrossSection[2];
                for (int i = 0; i < 2; i++)
                {
                    CutFaces[i] = new CrossSection();
                }
            }

            BuildFaces();
        }

        public void StartTrace(TraceSession parent, OpenMetaverse.AgentManager avatarManager)
        {
            mGridClient = parent.Client;
            mAgentManager = avatarManager;

            mLastUpdate = DateTime.Now;
        }

 public override PhysicsActor AddAvatar(string avName, OpenMetaverse.Vector3 position, OpenMetaverse.Vector3 size, bool isFlying)
 {
     BasicActor act = new BasicActor();
     act.Position = position;
     act.Flying = isFlying;
     _actors.Add(act);
     return act;
 }

        public static PhysX.Math.Matrix PositionToMatrix(OpenMetaverse.Vector3 position, OpenMetaverse.Quaternion rotation)
        {
            MakeFinite(ref position);
            MakeFinite(ref rotation);

            return PhysX.Math.Matrix.RotationQuaternion(new PhysX.Math.Quaternion(rotation.X, rotation.Y, rotation.Z, rotation.W)) *
                        PhysX.Math.Matrix.Translation(position.X, position.Y, position.Z);
        }

 public override void FromOSD(OpenMetaverse.StructuredData.OSDMap map)
 {
     GlobalPosX = map["GlobalPosX"];
     GlobalPosY = map["GlobalPosY"];
     LandData = new LandData();
     LandData.FromOSD((OSDMap) map["LandData"]);
     RegionName = map["RegionName"];
     RegionType = map["RegionType"];
 }

 public RotationalPrimVisual(OpenMetaverse.Primitive prim)
     : base(prim)
 {
     // TODO: This is temporary, for debugging and entertainment purposes
     Random rand = new Random((int)prim.LocalID + Environment.TickCount);
     byte r = (byte)rand.Next(256);
     byte g = (byte)rand.Next(256);
     byte b = (byte)rand.Next(256);
     color = new Color(r, g, b);
 }

 public CreateCharacterCmd(float height, float radius, OpenMetaverse.Vector3 pos,
     OpenMetaverse.Quaternion rot, bool flying, OpenMetaverse.Vector3 initialVelocity)
 {
     _height = height;
     _radius = radius;
     _position = pos;
     _rotation = rot;
     _flying = flying;
     _initialVelocity = initialVelocity;
 }

 public override void FromOSD(OpenMetaverse.StructuredData.OSDMap map)
 {
     TotalTierDebit = map["TotalTierDebit"];
     TotalTierCredits = map["TotalTierCredits"];
     ParcelDirectoryFee = map["ParcelDirectoryFee"];
     LandFee = map["LandFee"];
     ObjectFee = map["ObjectFee"];
     GroupFee = map["GroupFee"];
     StartingDate = map["StartingDate"];
 }

        public static void Self_ChatFromSimulator(object sender, OpenMetaverse.ChatEventArgs e)
        {
            posCamarero = e.Position;
            dialogo = new ControlDialogo(e, calcularDistancia());

            if (bot.cliente.Self.AgentID != e.OwnerID)
            {
                dialogo.responder();
            }
        }

        public static float[] CreateScaleMatrix(OpenMetaverse.Vector3 v)
        {
            float[] mat = new float[16];

            mat[0] = v.X;
            mat[5] = v.Y;
            mat[10] = v.Z;
            mat[15] = 1;

            return mat;
        }

        public ChangeChildPrimOffsetCmd(PhysxPrim parent, PhysxPrim child, OpenMetaverse.Vector3 newOffset,
            OpenMetaverse.Quaternion rotOffset)
        {
            Util.ThrowIfNull(parent, "parent");
            Util.ThrowIfNull(child, "child");

            _parent = parent;
            _child = child;
            _newOffset = newOffset;
            _rotOffset = rotOffset;
            _affectedPrims = new List<PhysxPrim> { parent, child };
        }

        public static PhysX.Math.Vector3[] OmvVectorArrayToPhysx(OpenMetaverse.Vector3[] omvArray)
        {
            PhysX.Math.Vector3[] physxArray = new PhysX.Math.Vector3[omvArray.Length];

            for (int i = 0; i < omvArray.Length; ++i)
            {
                OpenMetaverse.Vector3 omvVec = omvArray[i];
                physxArray[i] = new PhysX.Math.Vector3(omvVec.X, omvVec.Y, omvVec.Z);
            }

            return physxArray;
        }

 public override bool Excecute(SteelCityAutomaton.Automaton am, OpenMetaverse.GridClient client, bool force)
 {
     if (!client.Network.Connected) { result.message = "Not Connected to grid"; return true; }
     UUID target;
     if (UUID.TryParse(uuid, out target) && amount > 0)
     {
         client.Self.GiveAvatarMoney(target, amount,description);
         result.success = true;
     }
     else result.message = "Invalid key or ammount";
     return true;
 }

 internal OpenSim.Framework.ItemPermissionBlock ToItemPermissionBlock(OpenMetaverse.UUID itemId)
 {
     return new OpenSim.Framework.ItemPermissionBlock
     {
         BasePermissions = this.BasePermissions,
         CurrentPermissions = this.CurrentPermissions,
         EveryOnePermissions = this.EveryonePermissions,
         GroupPermissions = this.GroupPermissions,
         ItemId = itemId,
         NextPermissions = this.NextPermissions
     };
 }

 public override void ComputeAndSetLocalInertia(OMV.Vector3 inertiaFactor, float linksetMass)
 {
     OMV.Vector3 inertia = m_physicsScene.PE.CalculateLocalInertia(LinksetRoot.PhysShape.physShapeInfo, linksetMass);
     LinksetRoot.Inertia = inertia * inertiaFactor;
     m_physicsScene.PE.SetMassProps(LinksetRoot.PhysBody, linksetMass, LinksetRoot.Inertia);
     m_physicsScene.PE.UpdateInertiaTensor(LinksetRoot.PhysBody);
 }

    public BSPrim(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
                       OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
            : base(parent_scene, localID, primName, "BSPrim")
    {
        // m_log.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID);
        _physicsActorType = (int)ActorTypes.Prim;
        RawPosition = pos;
        _size = size;
        Scale = size;   // prims are the size the user wants them to be (different for BSCharactes).
        RawOrientation = rotation;
        _buoyancy = 0f;
        RawVelocity = OMV.Vector3.Zero;
        _rotationalVelocity = OMV.Vector3.Zero;
        BaseShape = pbs;
        _isPhysical = pisPhysical;
        _isVolumeDetect = false;

        _mass = CalculateMass();

        DetailLog("{0},BSPrim.constructor,pbs={1}", LocalID, BSScene.PrimitiveBaseShapeToString(pbs));
        // DetailLog("{0},BSPrim.constructor,call", LocalID);
        // do the actual object creation at taint time
        PhysScene.TaintedObject(LocalID, "BSPrim.create", delegate()
        {
            // Make sure the object is being created with some sanity.
            ExtremeSanityCheck(true /* inTaintTime */);

            CreateGeomAndObject(true);

            CurrentCollisionFlags = PhysScene.PE.GetCollisionFlags(PhysBody);

            IsInitialized = true;
        });
    }

        public BSPrim(uint localID, String primName, BSScene parent_scene, OMV.Vector3 pos, OMV.Vector3 size,
            OMV.Quaternion rotation, PrimitiveBaseShape pbs, bool pisPhysical)
            : base(parent_scene, localID, primName, "BSPrim")
        {
            // MainConsole.Instance.DebugFormat("{0}: BSPrim creation of {1}, id={2}", LogHeader, primName, localID);
            _position = pos;
            _size = size;
            Scale = size;   // prims are the size the user wants them to be (different for BSCharactes).
            _orientation = rotation;
            _buoyancy = 0f;
            RawVelocity = OMV.Vector3.Zero;
            _rotationalVelocity = OMV.Vector3.Zero;
            BaseShape = pbs;
            _isPhysical = pisPhysical;
            _isVolumeDetect = false;

            // We keep a handle to the vehicle actor so we can set vehicle parameters later.
            VehicleActor = new BSDynamics(PhysicsScene, this, VehicleActorName);
            PhysicalActors.Add(VehicleActorName, VehicleActor);

            _mass = CalculateMass();

            // DetailLog("{0},BSPrim.constructor,call", LocalID);
            // do the actual object creation at taint time
            PhysicsScene.TaintedObject("BSPrim.create", delegate()
            {
            // Make sure the object is being created with some sanity.
            ExtremeSanityCheck(true /* inTaintTime */);

            CreateGeomAndObject(true);

            CurrentCollisionFlags = PhysicsScene.PE.GetCollisionFlags(PhysBody);
            });
        }