1 files changed, 1866 insertions, 1919 deletions

diff --git a/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs b/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs
index af535cc..d7aa962 100644
--- a/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs
+++ b/OpenSim/Region/Environment/Scenes/SceneObjectPart.cs
@@ -1,3 +1,5 @@
+#region Header
+
 /*
  * Copyright (c) Contributors, http://opensimulator.org/
  * See CONTRIBUTORS.TXT for a full list of copyright holders.
@@ -25,6 +27,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+#endregion Header
+
 using System;
 using System.Collections.Generic;
 using System.Drawing;
@@ -32,15 +36,33 @@ using System.Runtime.Serialization;
 using System.Security.Permissions;
 using System.Xml;
 using System.Xml.Serialization;
+
 using Axiom.Math;
+
 using libsecondlife;
 using libsecondlife.Packets;
+
 using OpenSim.Framework;
 using OpenSim.Region.Environment.Scenes.Scripting;
 using OpenSim.Region.Physics.Manager;
 
 namespace OpenSim.Region.Environment.Scenes
 {
+    #region Enumerations
+
+    [Flags]
+    public enum Changed : uint
+    {
+        INVENTORY = 1,
+        COLOR = 2,
+        SHAPE = 4,
+        SCALE = 8,
+        TEXTURE = 16,
+        LINK = 32,
+        ALLOWED_DROP = 64,
+        OWNER = 128
+    }
+
     // I don't really know where to put this except here.
     // Can't access the OpenSim.Region.ScriptEngine.Common.LSL_BaseClass.Changed constants
     [Flags]
@@ -56,18 +78,7 @@ namespace OpenSim.Region.Environment.Scenes
         Something5 = 64,
         Something6 = 128
     }
-    [Flags]
-    public enum Changed : uint
-    {
-        INVENTORY = 1,
-        COLOR = 2,
-        SHAPE = 4,
-        SCALE = 8,
-        TEXTURE = 16,
-        LINK = 32,
-        ALLOWED_DROP = 64,
-        OWNER = 128
-    }
+
     [Flags]
     public enum TextureAnimFlags : byte
     {
@@ -81,74 +92,96 @@ namespace OpenSim.Region.Environment.Scenes
         SCALE = 0x40
     }
 
+    #endregion Enumerations
 
     [Serializable]
     public partial class SceneObjectPart : IScriptHost, ISerializable
     {
-        [XmlIgnore] public PhysicsActor PhysActor = null;
+        #region Fields
 
+        [XmlIgnore]
+        public bool AllowedDrop = false;
+        public uint BaseMask = (uint)PermissionMask.All;
+        public uint Category;
+        public Int32 CreationDate;
+        public LLUUID CreatorID;
+        [XmlIgnore]
+        public bool DIE_AT_EDGE = false;
+        public uint EveryoneMask = (uint)PermissionMask.None;
+        public LLObject.ObjectFlags Flags = LLObject.ObjectFlags.None;
+        public LLUUID GroupID;
+        public uint GroupMask = (uint)PermissionMask.None;
         public LLUUID LastOwnerID;
+        public uint NextOwnerMask = (uint)PermissionMask.All;
+        public byte ObjectSaleType;
         public LLUUID OwnerID;
-        public LLUUID GroupID;
+        public uint OwnerMask = (uint)PermissionMask.All;
         public int OwnershipCost;
-        public byte ObjectSaleType;
-        public int SalePrice;
-        public uint Category;
+        public uint ParentID = 0;
 
         // TODO: This needs to be persisted in next XML version update!
-        [XmlIgnore] public int[] PayPrice = {-2,-2,-2,-2,-2};
-        [XmlIgnore] public bool AllowedDrop = false;
-        [XmlIgnore] private Dictionary<LLUUID, scriptEvents> m_scriptEvents = new Dictionary<LLUUID, scriptEvents>();
-        [XmlIgnore] public scriptEvents m_aggregateScriptEvents=0;
-        [XmlIgnore] private LLObject.ObjectFlags LocalFlags = LLObject.ObjectFlags.None;
-        [XmlIgnore] public bool DIE_AT_EDGE = false;
-                [XmlIgnore] private int m_scriptAccessPin = 0;
-
-        [XmlIgnore] public bool m_IsAttachment = false;
-        [XmlIgnore] public uint m_attachmentPoint = (byte)0;
-        [XmlIgnore] public LLUUID m_attachedAvatar = LLUUID.Zero;
-        [XmlIgnore] public LLVector3 m_attachedPos = LLVector3.Zero;
-        [XmlIgnore] public LLUUID fromAssetID = LLUUID.Zero;
-
-        [XmlIgnore] public bool m_undoing = false;
+        [XmlIgnore]
+        public int[] PayPrice = {-2,-2,-2,-2,-2};
+        [XmlIgnore]
+        public PhysicsActor PhysActor = null;
+        public int SalePrice;
 
-        public Int32 CreationDate;
-        public uint ParentID = 0;
+        //Xantor 20080528 Sound stuff:
+        //  Note: This isn't persisted in the database right now, as the fields for that aren't just there yet.
+        //        Not a big problem as long as the script that sets it remains in the prim on startup.
+        //        for SL compatibility it should be persisted though (set sound / displaytext / particlesystem, kill script)
+        [XmlIgnore]
+        public LLUUID Sound;
+        [XmlIgnore]
+        public byte SoundFlags;
+        [XmlIgnore]
+        public double SoundGain;
+        [XmlIgnore]
+        public double SoundRadius;
+        [XmlIgnore]
+        public uint TimeStampFull = 0;
+        [XmlIgnore]
+        public uint TimeStampLastActivity = 0; // Will be used for AutoReturn
+        [XmlIgnore]
+        public uint TimeStampTerse = 0;
+        [XmlIgnore]
+        public LLUUID fromAssetID = LLUUID.Zero;
+        [XmlIgnore]
+        public bool m_IsAttachment = false;
+        [XmlIgnore]
+        public scriptEvents m_aggregateScriptEvents = 0;
+        [XmlIgnore]
+        public LLUUID m_attachedAvatar = LLUUID.Zero;
+        [XmlIgnore]
+        public LLVector3 m_attachedPos = LLVector3.Zero;
+        [XmlIgnore]
+        public uint m_attachmentPoint = (byte)0;
+        [XmlIgnore]
+        public PhysicsVector m_rotationAxis = new PhysicsVector(1f,1f,1f);
+        public LLUUID m_sitTargetAvatar = LLUUID.Zero;
+        [XmlIgnore]
+        public bool m_undoing = false;
 
+        [XmlIgnore]
+        private LLObject.ObjectFlags LocalFlags = LLObject.ObjectFlags.None;
+        private byte[] m_TextureAnimation;
+        private byte m_clickAction = 0;
+        private Color m_color = Color.Black;
+        private string m_description = String.Empty;
         private List<uint> m_lastColliders = new List<uint>();
-
         private PhysicsVector m_lastRotationalVelocity = PhysicsVector.Zero;
-        private Vector3 m_sitTargetPosition = new Vector3(0, 0, 0);
+        private int m_linkNum = 0;
+        [XmlIgnore]
+        private int m_scriptAccessPin = 0;
+        [XmlIgnore]
+        private Dictionary<LLUUID, scriptEvents> m_scriptEvents = new Dictionary<LLUUID, scriptEvents>();
+        private string m_sitName = String.Empty;
         private Quaternion m_sitTargetOrientation = new Quaternion(0, 0, 0, 1);
-        public  LLUUID m_sitTargetAvatar = LLUUID.Zero;
-        [XmlIgnore] public PhysicsVector m_rotationAxis = new PhysicsVector(1f,1f,1f);
-
-        #region Permissions
-
-        public uint BaseMask = (uint)PermissionMask.All;
-        public uint OwnerMask = (uint)PermissionMask.All;
-        public uint GroupMask = (uint)PermissionMask.None;
-        public uint EveryoneMask = (uint)PermissionMask.None;
-        public uint NextOwnerMask = (uint)PermissionMask.All;
-
+        private Vector3 m_sitTargetPosition = new Vector3(0, 0, 0);
+        private string m_text = String.Empty;
+        private string m_touchName = String.Empty;
         private UndoStack<UndoState> m_undo = new UndoStack<UndoState>(5);
 
-        public LLObject.ObjectFlags Flags = LLObject.ObjectFlags.None;
-
-        public uint ObjectFlags
-        {
-            get { return (uint)Flags; }
-            set { Flags = (LLObject.ObjectFlags)value; }
-        }
-
-        #endregion
-
-        protected byte[] m_particleSystem = new byte[0];
-
-        [XmlIgnore] public uint TimeStampFull = 0;
-        [XmlIgnore] public uint TimeStampTerse = 0;
-        [XmlIgnore] public uint TimeStampLastActivity = 0; // Will be used for AutoReturn
-
         /// <summary>
         /// Only used internally to schedule client updates.
         /// 0 - no update is scheduled
@@ -159,174 +192,213 @@ namespace OpenSim.Region.Environment.Scenes
         /// </summary>
         private byte m_updateFlag;
 
-        #region Properties
-
-        public LLUUID CreatorID;
+        protected LLVector3 m_acceleration;
+        protected LLVector3 m_angularVelocity;
 
-        public LLUUID ObjectCreator
-        {
-            get { return CreatorID; }
-        }
+        //unkown if this will be kept, added as a way of removing the group position from the group class
+        protected LLVector3 m_groupPosition;
+        protected uint m_localId;
+        protected LLObject.MaterialType m_material = 0;
+        protected string m_name;
+        protected LLVector3 m_offsetPosition;
 
+        // FIXME, TODO, ERROR: 'ParentGroup' can't be in here, move it out.
+        protected SceneObjectGroup m_parentGroup;
+        protected byte[] m_particleSystem = new byte[0];
+        protected ulong m_regionHandle;
+        protected LLQuaternion m_rotationOffset;
+        protected LLVector3 m_rotationalvelocity;
+        protected PrimitiveBaseShape m_shape;
         protected LLUUID m_uuid;
+        protected LLVector3 m_velocity;
 
-        public LLUUID UUID
-        {
-            get { return m_uuid; }
-            set { m_uuid = value; }
-        }
+        #endregion Fields
 
-        protected uint m_localId;
+        #region Constructors
 
-        public uint LocalId
+        /// <summary>
+        /// No arg constructor called by region restore db code
+        /// </summary>
+        public SceneObjectPart()
         {
-            get { return m_localId; }
-            set { m_localId = value; }
+            // It's not necessary to persist this
+            m_TextureAnimation = new byte[0];
         }
 
-        protected string m_name;
-
-        public virtual string Name
+        public SceneObjectPart(ulong regionHandle, SceneObjectGroup parent, LLUUID ownerID, uint localID,
+            PrimitiveBaseShape shape, LLVector3 groupPosition, LLVector3 offsetPosition)
+            : this(regionHandle, parent, ownerID, localID, shape, groupPosition, LLQuaternion.Identity, offsetPosition)
         {
-            get { return m_name; }
-            set { m_name = value; }
         }
 
-        public scriptEvents ScriptEvents
+        /// <summary>
+        /// Create a completely new SceneObjectPart (prim)
+        /// </summary>
+        /// <param name="regionHandle"></param>
+        /// <param name="parent"></param>
+        /// <param name="ownerID"></param>
+        /// <param name="localID"></param>
+        /// <param name="shape"></param>
+        /// <param name="position"></param>
+        public SceneObjectPart(ulong regionHandle, SceneObjectGroup parent, LLUUID ownerID, uint localID,
+            PrimitiveBaseShape shape, LLVector3 groupPosition, LLQuaternion rotationOffset,
+            LLVector3 offsetPosition)
         {
-            get { return m_aggregateScriptEvents; }
-        }
-
-        protected LLObject.MaterialType m_material = 0;
+            m_name = "Primitive";
+            m_regionHandle = regionHandle;
+            m_parentGroup = parent;
 
-        public byte Material
-        {
-            get { return (byte) m_material; }
-            set { m_material = (LLObject.MaterialType) value; }
-        }
+            CreationDate = (Int32) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;
+            OwnerID = ownerID;
+            CreatorID = OwnerID;
+            LastOwnerID = LLUUID.Zero;
+            UUID = LLUUID.Random();
+            LocalId = (uint) (localID);
+            Shape = shape;
+            // Todo: Add More Object Parameter from above!
+            OwnershipCost = 0;
+            ObjectSaleType = (byte) 0;
+            SalePrice = 0;
+            Category = (uint) 0;
+            LastOwnerID = CreatorID;
+            // End Todo: ///
+            GroupPosition = groupPosition;
+            OffsetPosition = offsetPosition;
+            RotationOffset = rotationOffset;
+            Velocity = new LLVector3(0, 0, 0);
+            m_rotationalvelocity = new LLVector3(0, 0, 0);
+            AngularVelocity = new LLVector3(0, 0, 0);
+            Acceleration = new LLVector3(0, 0, 0);
+            m_TextureAnimation = new byte[0];
 
-        protected ulong m_regionHandle;
+            // Prims currently only contain a single folder (Contents).  From looking at the Second Life protocol,
+            // this appears to have the same UUID (!) as the prim.  If this isn't the case, one can't drag items from
+            // the prim into an agent inventory (Linden client reports that the "Object not found for drop" in its log
 
-        public ulong RegionHandle
-        {
-            get { return m_regionHandle; }
-            set { m_regionHandle = value; }
-        }
-                
-                public int ScriptAccessPin
-                {
-                        get { return m_scriptAccessPin; }
-                        set     { m_scriptAccessPin = (int)value; }
-                }
+            Flags = 0;
+            Flags |= LLObject.ObjectFlags.CreateSelected;
 
-        public uint GetEffectiveObjectFlags()
-        {
-            LLObject.ObjectFlags f = Flags;
-            if (m_parentGroup == null || m_parentGroup.RootPart == this)
-                f &= ~(LLObject.ObjectFlags.Touch | LLObject.ObjectFlags.Money);
+            TrimPermissions();
+            //m_undo = new UndoStack<UndoState>(ParentGroup.GetSceneMaxUndo());
 
-            return (uint)Flags | (uint)LocalFlags;
+            ScheduleFullUpdate();
         }
 
-        //unkown if this will be kept, added as a way of removing the group position from the group class
-        protected LLVector3 m_groupPosition;
-
         /// <summary>
-        /// Method for a prim to get it's world position from the group.
-        /// Remember, the Group Position simply gives the position of the group itself
+        /// Re/create a SceneObjectPart (prim)
+        /// currently not used, and maybe won't be
         /// </summary>
-        /// <returns>A Linked Child Prim objects position in world</returns>
-        public LLVector3 GetWorldPosition()
+        /// <param name="regionHandle"></param>
+        /// <param name="parent"></param>
+        /// <param name="ownerID"></param>
+        /// <param name="localID"></param>
+        /// <param name="shape"></param>
+        /// <param name="position"></param>
+        public SceneObjectPart(ulong regionHandle, SceneObjectGroup parent, int creationDate, LLUUID ownerID,
+            LLUUID creatorID, LLUUID lastOwnerID, uint localID, PrimitiveBaseShape shape,
+            LLVector3 position, LLQuaternion rotation, uint flags)
         {
+            m_regionHandle = regionHandle;
+            m_parentGroup = parent;
+            TimeStampTerse = (uint) Util.UnixTimeSinceEpoch();
+            CreationDate = creationDate;
+            OwnerID = ownerID;
+            CreatorID = creatorID;
+            LastOwnerID = lastOwnerID;
+            UUID = LLUUID.Random();
+            LocalId = (uint) (localID);
+            Shape = shape;
+            OwnershipCost = 0;
+            ObjectSaleType = (byte) 0;
+            SalePrice = 0;
+            Category = (uint) 0;
+            LastOwnerID = CreatorID;
+            OffsetPosition = position;
+            RotationOffset = rotation;
+            ObjectFlags = flags;
 
-            Quaternion parentRot = new Quaternion(
-            ParentGroup.RootPart.RotationOffset.W,
-            ParentGroup.RootPart.RotationOffset.X,
-            ParentGroup.RootPart.RotationOffset.Y,
-            ParentGroup.RootPart.RotationOffset.Z);
-
-            Vector3 axPos
-                = new Vector3(
-                    OffsetPosition.X,
-                    OffsetPosition.Y,
-                    OffsetPosition.Z);
+            // Since we don't store script state, this is only a 'temporary' objectflag now
+            // If the object is scripted, the script will get loaded and this will be set again
+            ObjectFlags &= ~(uint)(LLObject.ObjectFlags.Scripted | LLObject.ObjectFlags.Touch);
 
-            axPos = parentRot * axPos;
-            LLVector3 translationOffsetPosition = new LLVector3(axPos.x, axPos.y, axPos.z);
-            return GroupPosition + translationOffsetPosition;
+            TrimPermissions();
+            // ApplyPhysics();
 
-            //return (new LLVector3(axiomPos.x, axiomPos.y, axiomPos.z) + AbsolutePosition);
+            ScheduleFullUpdate();
         }
 
-        /// <summary>
-        /// Gets the rotation of this prim offset by the group rotation
-        /// </summary>
-        /// <returns></returns>
-        public LLQuaternion GetWorldRotation()
+        protected SceneObjectPart(SerializationInfo info, StreamingContext context)
         {
+            //System.Console.WriteLine("SceneObjectPart Deserialize BGN");
 
-            Quaternion newRot;
-
-            if (this.LinkNum == 0)
+            if (info == null)
             {
-                newRot = new Quaternion(RotationOffset.W,RotationOffset.X,RotationOffset.Y,RotationOffset.Z);
-
+                throw new ArgumentNullException("info");
             }
-            else
-            {
-                Quaternion parentRot = new Quaternion(
-                ParentGroup.RootPart.RotationOffset.W,
-                ParentGroup.RootPart.RotationOffset.X,
-                ParentGroup.RootPart.RotationOffset.Y,
-                ParentGroup.RootPart.RotationOffset.Z);
 
-                Quaternion oldRot
-                    = new Quaternion(
-                        RotationOffset.W,
-                        RotationOffset.X,
-                        RotationOffset.Y,
-                        RotationOffset.Z);
+            /*
+            m_queue = (Queue<SceneObjectPart>)info.GetValue("m_queue", typeof(Queue<SceneObjectPart>));
+            m_ids = (List<LLUUID>)info.GetValue("m_ids", typeof(List<LLUUID>));
+            */
 
-                newRot = parentRot * oldRot;
-            }
-            return new LLQuaternion(newRot.x, newRot.y, newRot.z, newRot.w);
+            //System.Console.WriteLine("SceneObjectPart Deserialize END");
+        }
 
-            //return new LLQuaternion(axiomPartRotation.x, axiomPartRotation.y, axiomPartRotation.z, axiomPartRotation.w);
+        #endregion Constructors
+
+        #region Public Properties
+
+        public LLVector3 AbsolutePosition
+        {
+            get {
+                if (m_IsAttachment)
+                    return GroupPosition;
 
+                return m_offsetPosition + m_groupPosition; }
         }
 
-        public void StoreUndoState()
+        /// <summary></summary>
+        public LLVector3 Acceleration
         {
-            if (!m_undoing)
-            {
-                if (m_parentGroup != null)
-                {
-                    if (m_undo.Count > 0)
-                    {
-                        UndoState last = m_undo.Peek();
-                        if (last != null)
-                        {
-                            if (last.Compare(this))
-                                return;
-                        }
-                    }
+            get { return m_acceleration; }
+            set { m_acceleration = value; }
+        }
 
+        /// <summary></summary>
+        public LLVector3 AngularVelocity
+        {
+            get { return m_angularVelocity; }
+            set { m_angularVelocity = value; }
+        }
 
-                    if (m_parentGroup.GetSceneMaxUndo() > 0)
-                    {
-                        UndoState nUndo = new UndoState(this);
+        public byte ClickAction
+        {
+            get { return m_clickAction; }
+            set
+            {
+                m_clickAction = value;
+            }
+        }
 
-                        m_undo.Push(nUndo);
+        public Color Color
+        {
+            get { return m_color; }
+            set
+            {
+                m_color = value;
+                TriggerScriptChangedEvent(Changed.COLOR);
 
-                    }
-                }
+                /* ScheduleFullUpdate() need not be called b/c after
+                 * setting the color, the text will be set, so then
+                 * ScheduleFullUpdate() will be called. */
+                //ScheduleFullUpdate();
             }
         }
 
-        public void ClearUndoState()
+        public string Description
         {
-            m_undo.Clear();
-            StoreUndoState();
+            get { return m_description; }
+            set { m_description = value; }
         }
 
         public LLVector3 GroupPosition
@@ -391,9 +463,50 @@ namespace OpenSim.Region.Environment.Scenes
             }
         }
 
-        private byte[] m_TextureAnimation;
+        public int LinkNum
+        {
+            get { return m_linkNum; }
+            set
+            {
+                m_linkNum = value;
+                TriggerScriptChangedEvent(Changed.LINK);
 
-        protected LLVector3 m_offsetPosition;
+            }
+        }
+
+        public uint LocalId
+        {
+            get { return m_localId; }
+            set { m_localId = value; }
+        }
+
+        public byte Material
+        {
+            get { return (byte) m_material; }
+            set { m_material = (LLObject.MaterialType) value; }
+        }
+
+        public virtual string Name
+        {
+            get { return m_name; }
+            set { m_name = value; }
+        }
+
+        public LLUUID ObjectCreator
+        {
+            get { return CreatorID; }
+        }
+
+        public uint ObjectFlags
+        {
+            get { return (uint)Flags; }
+            set { Flags = (LLObject.ObjectFlags)value; }
+        }
+
+        public LLUUID ObjectOwner
+        {
+            get { return OwnerID; }
+        }
 
         public LLVector3 OffsetPosition
         {
@@ -416,16 +529,16 @@ namespace OpenSim.Region.Environment.Scenes
             }
         }
 
-        public LLVector3 AbsolutePosition
+        public SceneObjectGroup ParentGroup
         {
-            get {
-                if (m_IsAttachment)
-                    return GroupPosition;
-
-                return m_offsetPosition + m_groupPosition; }
+            get { return m_parentGroup; }
         }
 
-        protected LLQuaternion m_rotationOffset;
+        public ulong RegionHandle
+        {
+            get { return m_regionHandle; }
+            set { m_regionHandle = value; }
+        }
 
         public LLQuaternion RotationOffset
         {
@@ -479,11 +592,7 @@ namespace OpenSim.Region.Environment.Scenes
             }
         }
 
-        protected LLVector3 m_velocity;
-        protected LLVector3 m_rotationalvelocity;
-
-        /// <summary></summary>
-        public LLVector3 Velocity
+        public LLVector3 RotationalVelocity
         {
             get
             {
@@ -494,103 +603,86 @@ namespace OpenSim.Region.Environment.Scenes
                 {
                     if (PhysActor.IsPhysical)
                     {
-                        m_velocity.X = PhysActor.Velocity.X;
-                        m_velocity.Y = PhysActor.Velocity.Y;
-                        m_velocity.Z = PhysActor.Velocity.Z;
+                        m_rotationalvelocity.FromBytes(PhysActor.RotationalVelocity.GetBytes(),0);
                     }
                 }
 
-                return m_velocity;
-            }
-            
-            set 
-            {
-                m_velocity = value;
-                if (PhysActor != null)
-                {
-                    if (PhysActor.IsPhysical)
-                    {
-                        PhysActor.Velocity = new PhysicsVector(value.X, value.Y, value.Z);
-                        m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
-                    }
-                }
+                return m_rotationalvelocity;
             }
+            set { m_rotationalvelocity = value; }
         }
 
-        public LLVector3 RotationalVelocity
+        public LLVector3 Scale
         {
-            get
+            get { return m_shape.Scale; }
+            set
             {
-                //if (PhysActor.Velocity.x != 0 || PhysActor.Velocity.y != 0
-                //|| PhysActor.Velocity.z != 0)
-                //{
-                if (PhysActor != null)
+                StoreUndoState();
+                m_shape.Scale = value;
+
+                if (PhysActor != null && m_parentGroup != null)
                 {
-                    if (PhysActor.IsPhysical)
+                    if (m_parentGroup.Scene != null)
                     {
-                        m_rotationalvelocity.FromBytes(PhysActor.RotationalVelocity.GetBytes(),0);
+                        if (m_parentGroup.Scene.PhysicsScene != null)
+                        {
+                            PhysActor.Size = new PhysicsVector(m_shape.Scale.X, m_shape.Scale.Y, m_shape.Scale.Z);
+                            m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+                        }
                     }
                 }
-
-                return m_rotationalvelocity;
+                TriggerScriptChangedEvent(Changed.SCALE);
             }
-            set { m_rotationalvelocity = value; }
-        }
-
-
-        protected LLVector3 m_angularVelocity;
-
-        /// <summary></summary>
-        public LLVector3 AngularVelocity
-        {
-            get { return m_angularVelocity; }
-            set { m_angularVelocity = value; }
         }
 
-        protected LLVector3 m_acceleration;
-
-        /// <summary></summary>
-        public LLVector3 Acceleration
+        public int ScriptAccessPin
         {
-            get { return m_acceleration; }
-            set { m_acceleration = value; }
+            get { return m_scriptAccessPin; }
+            set { m_scriptAccessPin = (int)value; }
         }
 
-        private string m_description = String.Empty;
-
-        public string Description
+        public scriptEvents ScriptEvents
         {
-            get { return m_description; }
-            set { m_description = value; }
+            get { return m_aggregateScriptEvents; }
         }
 
-        private Color m_color = Color.Black;
-
-        public Color Color
+        public PrimitiveBaseShape Shape
         {
-            get { return m_color; }
+            get { return m_shape; }
             set
             {
-                m_color = value;
-                TriggerScriptChangedEvent(Changed.COLOR);
-
-                /* ScheduleFullUpdate() need not be called b/c after
-                 * setting the color, the text will be set, so then
-                 * ScheduleFullUpdate() will be called. */
-                //ScheduleFullUpdate();
+                m_shape = value;
+                TriggerScriptChangedEvent(Changed.SHAPE);
             }
         }
 
-        private string m_text = String.Empty;
+        public string SitName
+        {
+            get { return m_sitName; }
+            set { m_sitName = value; }
+        }
+
+        public Quaternion SitTargetOrientation
+        {
+            get { return m_sitTargetOrientation; }
+        }
 
         public Vector3 SitTargetPosition
         {
             get { return m_sitTargetPosition; }
         }
 
-        public Quaternion SitTargetOrientation
+        public bool Stopped
         {
-            get { return m_sitTargetOrientation; }
+            get {
+                double threshold = 0.02;
+                return (Math.Abs(Velocity.X) < threshold &&
+                        Math.Abs(Velocity.Y) < threshold &&
+                        Math.Abs(Velocity.Z) < threshold &&
+                        Math.Abs(AngularVelocity.X) < threshold &&
+                        Math.Abs(AngularVelocity.Y) < threshold &&
+                        Math.Abs(AngularVelocity.Z) < threshold);
+            }
         }
 
         public string Text
@@ -610,61 +702,209 @@ namespace OpenSim.Region.Environment.Scenes
             }
         }
 
-        //Xantor 20080528 Sound stuff:
-        //  Note: This isn't persisted in the database right now, as the fields for that aren't just there yet.
-        //        Not a big problem as long as the script that sets it remains in the prim on startup.
-        //        for SL compatibility it should be persisted though (set sound / displaytext / particlesystem, kill script)
-        [XmlIgnore]
-        public LLUUID Sound;
-        [XmlIgnore]
-        public byte SoundFlags;
-        [XmlIgnore]
-        public double SoundGain;
-        [XmlIgnore]
-        public double SoundRadius;
+        public string TouchName
+        {
+            get { return m_touchName; }
+            set { m_touchName = value; }
+        }
 
+        public LLUUID UUID
+        {
+            get { return m_uuid; }
+            set { m_uuid = value; }
+        }
 
-        private string m_sitName = String.Empty;
+        public byte UpdateFlag
+        {
+            get { return m_updateFlag; }
+            set { m_updateFlag = value; }
+        }
 
-        public string SitName
+        /// <summary></summary>
+        public LLVector3 Velocity
         {
-            get { return m_sitName; }
-            set { m_sitName = value; }
+            get
+            {
+                //if (PhysActor.Velocity.x != 0 || PhysActor.Velocity.y != 0
+                //|| PhysActor.Velocity.z != 0)
+                //{
+                if (PhysActor != null)
+                {
+                    if (PhysActor.IsPhysical)
+                    {
+                        m_velocity.X = PhysActor.Velocity.X;
+                        m_velocity.Y = PhysActor.Velocity.Y;
+                        m_velocity.Z = PhysActor.Velocity.Z;
+                    }
+                }
+
+                return m_velocity;
+            }
+
+            set 
+            {
+                m_velocity = value;
+                if (PhysActor != null)
+                {
+                    if (PhysActor.IsPhysical)
+                    {
+                        PhysActor.Velocity = new PhysicsVector(value.X, value.Y, value.Z);
+                        m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+                    }
+                }
+            }
         }
 
-        private string m_touchName = String.Empty;
+        #endregion Public Properties
 
-        public string TouchName
+        #region Private Methods
+
+        private uint ApplyMask(uint val, bool set, uint mask)
         {
-            get { return m_touchName; }
-            set { m_touchName = value; }
+            if (set)
+            {
+                return val |= mask;
+            }
+            else
+            {
+                return val &= ~mask;
+            }
         }
 
-        private int m_linkNum = 0;
+        /// <summary>
+        /// Clear all pending updates
+        /// </summary>
+        private void ClearUpdateSchedule()
+        {
+            m_updateFlag = 0;
+        }
 
-        public int LinkNum
+        private void SendObjectPropertiesToClient(LLUUID AgentID)
         {
-            get { return m_linkNum; }
-            set
+            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
+            for (int i = 0; i < avatars.Count; i++)
             {
-                m_linkNum = value;
-                TriggerScriptChangedEvent(Changed.LINK);
+                // Ugly reference :(
+                if (avatars[i].UUID == AgentID)
+                {
+                    m_parentGroup.GetProperties(avatars[i].ControllingClient);
+                }
+            }
+        }
+
+        private void handleTimerAccounting(uint localID, double interval)
+        {
+            if (localID == LocalId)
+            {
+
+                float sec = (float)interval;
+                if (m_parentGroup != null)
+                {
+                    if (sec == 0)
+                    {
+                        if (m_parentGroup.scriptScore + 0.001f >= float.MaxValue - 0.001)
+                            m_parentGroup.scriptScore = 0;
+
+                        m_parentGroup.scriptScore += 0.001f;
+                        return;
+                    }
+
+                    if (m_parentGroup.scriptScore + (0.001f / sec) >= float.MaxValue - (0.001f / sec))
+                        m_parentGroup.scriptScore = 0;
+                    m_parentGroup.scriptScore += (0.001f / sec);
+                }
 
             }
         }
 
-        private byte m_clickAction = 0;
+        #endregion Private Methods
 
-        public byte ClickAction
+        #region Public Methods
+
+        public void AddFlag(LLObject.ObjectFlags flag)
         {
-            get { return m_clickAction; }
-            set
+            LLObject.ObjectFlags prevflag = Flags;
+            //uint objflags = Flags;
+            if ((ObjectFlags & (uint) flag) == 0)
             {
-                m_clickAction = value;
+                //Console.WriteLine("Adding flag: " + ((LLObject.ObjectFlags) flag).ToString());
+                Flags |= flag;
             }
+            //uint currflag = (uint)Flags;
+            //System.Console.WriteLine("Aprev: " + prevflag.ToString() + " curr: " + Flags.ToString());
+            //ScheduleFullUpdate();
         }
 
-        protected PrimitiveBaseShape m_shape;
+        /// <summary>
+        /// Tell all scene presences that they should send updates for this part to their clients
+        /// </summary>
+        public void AddFullUpdateToAllAvatars()
+        {
+            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
+            for (int i = 0; i < avatars.Count; i++)
+            {
+                avatars[i].QueuePartForUpdate(this);
+            }
+        }
+
+        public void AddFullUpdateToAvatar(ScenePresence presence)
+        {
+            presence.QueuePartForUpdate(this);
+        }
+
+        public void AddNewParticleSystem(Primitive.ParticleSystem pSystem)
+        {
+            m_particleSystem = pSystem.GetBytes();
+        }
+
+        /// Terse updates
+        public void AddTerseUpdateToAllAvatars()
+        {
+            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
+            for (int i = 0; i < avatars.Count; i++)
+            {
+                avatars[i].QueuePartForUpdate(this);
+            }
+        }
+
+        public void AddTerseUpdateToAvatar(ScenePresence presence)
+        {
+            presence.QueuePartForUpdate(this);
+        }
+
+        public void AddTextureAnimation(Primitive.TextureAnimation pTexAnim)
+        {
+            byte[] data = new byte[16];
+            int pos = 0;
+
+            // The flags don't like conversion from uint to byte, so we have to do
+            // it the crappy way.  See the above function :(
+
+            data[pos] = ConvertScriptUintToByte(pTexAnim.Flags); pos++;
+            data[pos] = (byte)pTexAnim.Face; pos++;
+            data[pos] = (byte)pTexAnim.SizeX; pos++;
+            data[pos] = (byte)pTexAnim.SizeY; pos++;
+
+            Helpers.FloatToBytes(pTexAnim.Start).CopyTo(data, pos);
+            Helpers.FloatToBytes(pTexAnim.Length).CopyTo(data, pos + 4);
+            Helpers.FloatToBytes(pTexAnim.Rate).CopyTo(data, pos + 8);
+
+            m_TextureAnimation = data;
+        }
+
+        public void AdjustSoundGain(double volume)
+        {
+            if (volume > 1)
+                volume = 1;
+            if (volume < 0)
+                volume = 0;
+
+            List<ScenePresence> avatarts = m_parentGroup.Scene.GetAvatars();
+            foreach (ScenePresence p in avatarts)
+            {
+                p.ControllingClient.SendAttachedSoundGainChange(UUID, (float)volume);
+            }
+        }
 
         /// <summary>
         /// hook to the physics scene to apply impulse
@@ -697,283 +937,1316 @@ namespace OpenSim.Region.Environment.Scenes
             }
         }
 
-        public void MoveToTarget(LLVector3 target, float tau)
+        /// <summary>
+        /// Apply physics to this part.
+        /// </summary>
+        /// <param name="rootObjectFlags"></param>
+        /// <param name="m_physicalPrim"></param>
+        public void ApplyPhysics(uint rootObjectFlags, bool m_physicalPrim)
         {
-            if (tau > 0)
+            bool isPhysical = (((rootObjectFlags & (uint) LLObject.ObjectFlags.Physics) != 0) && m_physicalPrim);
+            bool isPhantom = ((rootObjectFlags & (uint) LLObject.ObjectFlags.Phantom) != 0);
+
+            // Added clarification..   since A rigid body is an object that you can kick around, etc.
+            bool RigidBody = isPhysical && !isPhantom;
+
+            // The only time the physics scene shouldn't know about the prim is if it's phantom
+            if (!isPhantom)
             {
-                m_parentGroup.moveToTarget(target, tau);
+                PhysActor = m_parentGroup.Scene.PhysicsScene.AddPrimShape(
+                    Name,
+                    Shape,
+                    new PhysicsVector(AbsolutePosition.X, AbsolutePosition.Y,
+                                      AbsolutePosition.Z),
+                    new PhysicsVector(Scale.X, Scale.Y, Scale.Z),
+                    new Quaternion(RotationOffset.W, RotationOffset.X,
+                                   RotationOffset.Y, RotationOffset.Z), RigidBody);
+
+                // Basic Physics returns null..  joy joy joy.
+                if (PhysActor != null)
+                {
+                    PhysActor.LocalID = LocalId;
+                    DoPhysicsPropertyUpdate(RigidBody, true);
+                }
+            }
+        }
+
+        public void ClearUndoState()
+        {
+            m_undo.Clear();
+            StoreUndoState();
+        }
+
+        public byte ConvertScriptUintToByte(uint indata)
+        {
+            byte outdata = (byte)TextureAnimFlags.NONE;
+            if ((indata & 1) != 0) outdata |= (byte)TextureAnimFlags.ANIM_ON;
+            if ((indata & 2) != 0) outdata |= (byte)TextureAnimFlags.LOOP;
+            if ((indata & 4) != 0) outdata |= (byte)TextureAnimFlags.REVERSE;
+            if ((indata & 8) != 0) outdata |= (byte)TextureAnimFlags.PING_PONG;
+            if ((indata & 16) != 0) outdata |= (byte)TextureAnimFlags.SMOOTH;
+            if ((indata & 32) != 0) outdata |= (byte)TextureAnimFlags.ROTATE;
+            if ((indata & 64) != 0) outdata |= (byte)TextureAnimFlags.SCALE;
+            return outdata;
+        }
+
+        /// <summary>
+        /// Duplicates this part.
+        /// </summary>
+        /// <returns></returns>
+        public SceneObjectPart Copy(uint localID, LLUUID AgentID, LLUUID GroupID, int linkNum, bool userExposed)
+        {
+            SceneObjectPart dupe = (SceneObjectPart) MemberwiseClone();
+            dupe.m_shape = m_shape.Copy();
+            dupe.m_regionHandle = m_regionHandle;
+            if (userExposed)
+                dupe.UUID = LLUUID.Random();
+
+            dupe.LocalId = localID;
+            dupe.OwnerID = AgentID;
+            dupe.GroupID = GroupID;
+            dupe.GroupPosition = new LLVector3(GroupPosition.X, GroupPosition.Y, GroupPosition.Z);
+            dupe.OffsetPosition = new LLVector3(OffsetPosition.X, OffsetPosition.Y, OffsetPosition.Z);
+            dupe.RotationOffset =
+                new LLQuaternion(RotationOffset.X, RotationOffset.Y, RotationOffset.Z, RotationOffset.W);
+            dupe.Velocity = new LLVector3(0, 0, 0);
+            dupe.Acceleration = new LLVector3(0, 0, 0);
+            dupe.AngularVelocity = new LLVector3(0, 0, 0);
+            dupe.ObjectFlags = ObjectFlags;
+
+            dupe.OwnershipCost = OwnershipCost;
+            dupe.ObjectSaleType = ObjectSaleType;
+            dupe.SalePrice = SalePrice;
+            dupe.Category = Category;
+
+            dupe.TaskInventory = (TaskInventoryDictionary)dupe.TaskInventory.Clone();
+
+            if (userExposed)
+                dupe.ResetIDs(linkNum);
+
+            // This may be wrong...    it might have to be applied in SceneObjectGroup to the object that's being duplicated.
+            dupe.LastOwnerID = ObjectOwner;
+
+            byte[] extraP = new byte[Shape.ExtraParams.Length];
+            Array.Copy(Shape.ExtraParams, extraP, extraP.Length);
+            dupe.Shape.ExtraParams = extraP;
+
+            if (userExposed)
+            {
+                if (dupe.m_shape.SculptEntry && dupe.m_shape.SculptTexture != LLUUID.Zero)
+                {
+                    m_parentGroup.Scene.AssetCache.GetAsset(dupe.m_shape.SculptTexture, dupe.SculptTextureCallback, true);
+                }
+                bool UsePhysics = ((dupe.ObjectFlags & (uint)LLObject.ObjectFlags.Physics) != 0);
+                dupe.DoPhysicsPropertyUpdate(UsePhysics, true);
+            }
+            return dupe;
+        }
+
+        public static SceneObjectPart Create()
+        {
+            SceneObjectPart part = new SceneObjectPart();
+            part.UUID = LLUUID.Random();
+
+            PrimitiveBaseShape shape = PrimitiveBaseShape.Create();
+            part.Shape = shape;
+
+            part.Name = "Primitive";
+            part.OwnerID = LLUUID.Random();
+
+            return part;
+        }
+
+        public void DoPhysicsPropertyUpdate(bool UsePhysics, bool isNew)
+        {
+            if (PhysActor != null)
+            {
+                if (UsePhysics != PhysActor.IsPhysical || isNew)
+                {
+                    if (PhysActor.IsPhysical)
+                    {
+                        if (!isNew)
+                            ParentGroup.Scene.RemovePhysicalPrim(1);
+
+                        PhysActor.OnRequestTerseUpdate -= PhysicsRequestingTerseUpdate;
+                        PhysActor.OnOutOfBounds -= PhysicsOutOfBounds;
+                        PhysActor.delink();
+                    }
+
+                    PhysActor.IsPhysical = UsePhysics;
+
+
+                    // If we're not what we're supposed to be in the physics scene, recreate ourselves.
+                    //m_parentGroup.Scene.PhysicsScene.RemovePrim(PhysActor);
+                    /// that's not wholesome.  Had to make Scene public
+                    //PhysActor = null;
+
+                    if ((ObjectFlags & (uint) LLObject.ObjectFlags.Phantom) == 0)
+                    {
+                        //PhysActor = m_parentGroup.Scene.PhysicsScene.AddPrimShape(
+                        //Name,
+                        //Shape,
+                        //new PhysicsVector(AbsolutePosition.X, AbsolutePosition.Y,
+                        //AbsolutePosition.Z),
+                        //new PhysicsVector(Scale.X, Scale.Y, Scale.Z),
+                        //new Quaternion(RotationOffset.W, RotationOffset.X,
+                        //RotationOffset.Y, RotationOffset.Z), UsePhysics);
+                        if (UsePhysics)
+                        {
+                            ParentGroup.Scene.AddPhysicalPrim(1);
+
+                            PhysActor.OnRequestTerseUpdate += PhysicsRequestingTerseUpdate;
+                            PhysActor.OnOutOfBounds += PhysicsOutOfBounds;
+                            if (ParentID != 0 && ParentID != LocalId)
+                            {
+                                if (ParentGroup.RootPart.PhysActor != null)
+                                {
+                                    PhysActor.link(ParentGroup.RootPart.PhysActor);
+                                }
+                            }
+                        }
+                    }
+                }
+                m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+            }
+        }
+
+        /// <summary>
+        /// Restore this part from the serialized xml representation.
+        /// </summary>
+        /// <param name="xmlreader"></param>
+        /// <returns></returns>
+        public static SceneObjectPart FromXml(XmlReader xmlReader)
+        {
+            // It's not necessary to persist this
+
+            XmlSerializer serializer = new XmlSerializer(typeof (SceneObjectPart));
+            SceneObjectPart newobject = (SceneObjectPart) serializer.Deserialize(xmlReader);
+            return newobject;
+        }
+
+        public LLUUID GetAvatarOnSitTarget()
+        {
+            return m_sitTargetAvatar;
+        }
+
+        public bool GetDieAtEdge()
+        {
+            if (m_parentGroup == null)
+                return false;
+            if (m_parentGroup.RootPart == null)
+                return false;
+
+            return m_parentGroup.RootPart.DIE_AT_EDGE;
+        }
+
+        public double GetDistanceTo(Vector3 a, Vector3 b)
+        {
+            float dx = a.x - b.x;
+            float dy = a.y - b.y;
+            float dz = a.z - b.z;
+            return Math.Sqrt(dx * dx + dy * dy + dz * dz);
+        }
+
+        public uint GetEffectiveObjectFlags()
+        {
+            LLObject.ObjectFlags f = Flags;
+            if (m_parentGroup == null || m_parentGroup.RootPart == this)
+                f &= ~(LLObject.ObjectFlags.Touch | LLObject.ObjectFlags.Money);
+
+            return (uint)Flags | (uint)LocalFlags;
+        }
+
+        public LLVector3 GetGeometricCenter()
+        {
+            if (PhysActor != null)
+            {
+                return new LLVector3(PhysActor.CenterOfMass.X, PhysActor.CenterOfMass.Y, PhysActor.CenterOfMass.Z);
             }
             else
             {
-                StopMoveToTarget();
+                return new LLVector3(0, 0, 0);
             }
+        }
 
+        public float GetMass()
+        {
+            if (PhysActor != null)
+            {
+                return PhysActor.Mass;
+            }
+            else
+            {
+                return 0;
+            }
         }
 
-        public void StopMoveToTarget()
+        [SecurityPermission(SecurityAction.LinkDemand,
+            Flags = SecurityPermissionFlag.SerializationFormatter)]
+        public virtual void GetObjectData(
+            SerializationInfo info, StreamingContext context)
         {
-            m_parentGroup.stopMoveToTarget();
+            if (info == null)
+            {
+                throw new ArgumentNullException("info");
+            }
+
+            info.AddValue("m_inventoryFileName", GetInventoryFileName());
+            info.AddValue("m_folderID", UUID);
+            info.AddValue("PhysActor", PhysActor);
+
+            Dictionary<Guid, TaskInventoryItem> TaskInventory_work = new Dictionary<Guid, TaskInventoryItem>();
+
+            foreach (LLUUID id in TaskInventory.Keys)
+            {
+                TaskInventory_work.Add(id.UUID, TaskInventory[id]);
+            }
+
+            info.AddValue("TaskInventory", TaskInventory_work);
+
+            info.AddValue("LastOwnerID", LastOwnerID.UUID);
+            info.AddValue("OwnerID", OwnerID.UUID);
+            info.AddValue("GroupID", GroupID.UUID);
+
+            info.AddValue("OwnershipCost", OwnershipCost);
+            info.AddValue("ObjectSaleType", ObjectSaleType);
+            info.AddValue("SalePrice", SalePrice);
+            info.AddValue("Category", Category);
+
+            info.AddValue("CreationDate", CreationDate);
+            info.AddValue("ParentID", ParentID);
+
+            info.AddValue("OwnerMask", OwnerMask);
+            info.AddValue("NextOwnerMask", NextOwnerMask);
+            info.AddValue("GroupMask", GroupMask);
+            info.AddValue("EveryoneMask", EveryoneMask);
+            info.AddValue("BaseMask", BaseMask);
+
+            info.AddValue("m_particleSystem", m_particleSystem);
+
+            info.AddValue("TimeStampFull", TimeStampFull);
+            info.AddValue("TimeStampTerse", TimeStampTerse);
+            info.AddValue("TimeStampLastActivity", TimeStampLastActivity);
+
+            info.AddValue("m_updateFlag", m_updateFlag);
+            info.AddValue("CreatorID", CreatorID.UUID);
+
+            info.AddValue("m_inventorySerial", m_inventorySerial);
+            info.AddValue("m_uuid", m_uuid.UUID);
+            info.AddValue("m_localID", m_localId);
+            info.AddValue("m_name", m_name);
+            info.AddValue("m_flags", Flags);
+            info.AddValue("m_material", m_material);
+            info.AddValue("m_regionHandle", m_regionHandle);
+
+            info.AddValue("m_groupPosition.X", m_groupPosition.X);
+            info.AddValue("m_groupPosition.Y", m_groupPosition.Y);
+            info.AddValue("m_groupPosition.Z", m_groupPosition.Z);
+
+            info.AddValue("m_offsetPosition.X", m_offsetPosition.X);
+            info.AddValue("m_offsetPosition.Y", m_offsetPosition.Y);
+            info.AddValue("m_offsetPosition.Z", m_offsetPosition.Z);
+
+            info.AddValue("m_rotationOffset.W", m_rotationOffset.W);
+            info.AddValue("m_rotationOffset.X", m_rotationOffset.X);
+            info.AddValue("m_rotationOffset.Y", m_rotationOffset.Y);
+            info.AddValue("m_rotationOffset.Z", m_rotationOffset.Z);
+
+            info.AddValue("m_velocity.X", m_velocity.X);
+            info.AddValue("m_velocity.Y", m_velocity.Y);
+            info.AddValue("m_velocity.Z", m_velocity.Z);
+
+            info.AddValue("m_rotationalvelocity.X", m_rotationalvelocity.X);
+            info.AddValue("m_rotationalvelocity.Y", m_rotationalvelocity.Y);
+            info.AddValue("m_rotationalvelocity.Z", m_rotationalvelocity.Z);
+
+            info.AddValue("m_angularVelocity.X", m_angularVelocity.X);
+            info.AddValue("m_angularVelocity.Y", m_angularVelocity.Y);
+            info.AddValue("m_angularVelocity.Z", m_angularVelocity.Z);
+
+            info.AddValue("m_acceleration.X", m_acceleration.X);
+            info.AddValue("m_acceleration.Y", m_acceleration.Y);
+            info.AddValue("m_acceleration.Z", m_acceleration.Z);
+
+            info.AddValue("m_description", m_description);
+            info.AddValue("m_color", m_color);
+            info.AddValue("m_text", m_text);
+            info.AddValue("m_sitName", m_sitName);
+            info.AddValue("m_touchName", m_touchName);
+            info.AddValue("m_clickAction", m_clickAction);
+            info.AddValue("m_shape", m_shape);
+            info.AddValue("m_parentGroup", m_parentGroup);
+            info.AddValue("PayPrice", PayPrice);
         }
 
-        public void TriggerScriptChangedEvent(Changed val)
+        public void GetProperties(IClientAPI client)
+        {
+            client.SendObjectPropertiesReply(LLUUID.Zero, (ulong)CreationDate, CreatorID, LLUUID.Zero, LLUUID.Zero,
+                                               GroupID, (short)InventorySerial, LastOwnerID, UUID, OwnerID,
+                                               ParentGroup.RootPart.TouchName, new byte[0], ParentGroup.RootPart.SitName, Name, Description,
+                                               ParentGroup.RootPart.OwnerMask, ParentGroup.RootPart.NextOwnerMask, ParentGroup.RootPart.GroupMask, ParentGroup.RootPart.EveryoneMask,
+                                               ParentGroup.RootPart.BaseMask);
+        }
+
+        public LLUUID GetRootPartUUID()
         {
             if (m_parentGroup != null)
             {
-                if (m_parentGroup.Scene != null)
-                    m_parentGroup.Scene.TriggerObjectChanged(LocalId, (uint)val);
+                return m_parentGroup.UUID;
             }
+            return LLUUID.Zero;
+        }
 
+        public Quaternion GetSitTargetOrientation()
+        {
+            return m_sitTargetOrientation;
         }
 
-        public PrimitiveBaseShape Shape
+        public LLQuaternion GetSitTargetOrientationLL()
         {
-            get { return m_shape; }
-            set
+            return
+                new LLQuaternion(m_sitTargetOrientation.x, m_sitTargetOrientation.y, m_sitTargetOrientation.z,
+                                 m_sitTargetOrientation.w);
+        }
+
+        public Vector3 GetSitTargetPosition()
+        {
+            return m_sitTargetPosition;
+        }
+
+        public LLVector3 GetSitTargetPositionLL()
+        {
+            return new LLVector3(m_sitTargetPosition.x, m_sitTargetPosition.y, m_sitTargetPosition.z);
+        }
+
+        /// <summary>
+        /// Method for a prim to get it's world position from the group.
+        /// Remember, the Group Position simply gives the position of the group itself
+        /// </summary>
+        /// <returns>A Linked Child Prim objects position in world</returns>
+        public LLVector3 GetWorldPosition()
+        {
+            Quaternion parentRot = new Quaternion(
+            ParentGroup.RootPart.RotationOffset.W,
+            ParentGroup.RootPart.RotationOffset.X,
+            ParentGroup.RootPart.RotationOffset.Y,
+            ParentGroup.RootPart.RotationOffset.Z);
+
+            Vector3 axPos
+                = new Vector3(
+                    OffsetPosition.X,
+                    OffsetPosition.Y,
+                    OffsetPosition.Z);
+
+            axPos = parentRot * axPos;
+            LLVector3 translationOffsetPosition = new LLVector3(axPos.x, axPos.y, axPos.z);
+            return GroupPosition + translationOffsetPosition;
+
+            //return (new LLVector3(axiomPos.x, axiomPos.y, axiomPos.z) + AbsolutePosition);
+        }
+
+        /// <summary>
+        /// Gets the rotation of this prim offset by the group rotation
+        /// </summary>
+        /// <returns></returns>
+        public LLQuaternion GetWorldRotation()
+        {
+            Quaternion newRot;
+
+            if (this.LinkNum == 0)
             {
-                m_shape = value;
-                TriggerScriptChangedEvent(Changed.SHAPE);
+                newRot = new Quaternion(RotationOffset.W,RotationOffset.X,RotationOffset.Y,RotationOffset.Z);
+
+            }
+            else
+            {
+                Quaternion parentRot = new Quaternion(
+                ParentGroup.RootPart.RotationOffset.W,
+                ParentGroup.RootPart.RotationOffset.X,
+                ParentGroup.RootPart.RotationOffset.Y,
+                ParentGroup.RootPart.RotationOffset.Z);
+
+                Quaternion oldRot
+                    = new Quaternion(
+                        RotationOffset.W,
+                        RotationOffset.X,
+                        RotationOffset.Y,
+                        RotationOffset.Z);
+
+                newRot = parentRot * oldRot;
             }
+            return new LLQuaternion(newRot.x, newRot.y, newRot.z, newRot.w);
+
+            //return new LLQuaternion(axiomPartRotation.x, axiomPartRotation.y, axiomPartRotation.z, axiomPartRotation.w);
         }
 
-        public LLVector3 Scale
+        public void MoveToTarget(LLVector3 target, float tau)
         {
-            get { return m_shape.Scale; }
-            set
+            if (tau > 0)
             {
-                StoreUndoState();
-                m_shape.Scale = value;
+                m_parentGroup.moveToTarget(target, tau);
+            }
+            else
+            {
+                StopMoveToTarget();
+            }
+        }
 
-                if (PhysActor != null && m_parentGroup != null)
+        public virtual void OnGrab(LLVector3 offsetPos, IClientAPI remoteClient)
+        {
+        }
+
+        public void PhysicsCollision(EventArgs e)
+        {
+            // single threaded here
+            if (e == null)
+            {
+                return;
+            }
+
+            CollisionEventUpdate a = (CollisionEventUpdate)e;
+            Dictionary<uint, float> collissionswith = a.m_objCollisionList;
+            List<uint> thisHitColliders = new List<uint>();
+            List<uint> endedColliders = new List<uint>();
+            List<uint> startedColliders = new List<uint>();
+
+            // calculate things that started colliding this time
+            // and build up list of colliders this time
+            foreach (uint localid in collissionswith.Keys)
+            {
+                if (localid != 0)
                 {
-                    if (m_parentGroup.Scene != null)
+                    thisHitColliders.Add(localid);
+                    if (!m_lastColliders.Contains(localid))
                     {
-                        if (m_parentGroup.Scene.PhysicsScene != null)
+                        startedColliders.Add(localid);
+                    }
+
+                    //m_log.Debug("[OBJECT]: Collided with:" + localid.ToString() + " at depth of: " + collissionswith[localid].ToString());
+                }
+            }
+
+            // calculate things that ended colliding
+            foreach (uint localID in m_lastColliders)
+            {
+                if (!thisHitColliders.Contains(localID))
+                {
+                    endedColliders.Add(localID);
+                }
+            }
+
+            //add the items that started colliding this time to the last colliders list.
+            foreach (uint localID in startedColliders)
+            {
+                m_lastColliders.Add(localID);
+            }
+            // remove things that ended colliding from the last colliders list
+            foreach (uint localID in endedColliders)
+            {
+                m_lastColliders.Remove(localID);
+            }
+            if (m_parentGroup == null)
+                return;
+            if (m_parentGroup.RootPart == null)
+                return;
+
+            if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.collision_start) != 0)
+            {
+                // do event notification
+                if (startedColliders.Count > 0)
+                {
+                    ColliderArgs StartCollidingMessage = new ColliderArgs();
+                    List<DetectedObject> colliding = new List<DetectedObject>();
+                    foreach (uint localId in startedColliders)
+                    {
+                        // always running this check because if the user deletes the object it would return a null reference.
+                        if (m_parentGroup == null)
+                            return;
+                        if (m_parentGroup.Scene == null)
+                            return;
+                        SceneObjectPart obj = m_parentGroup.Scene.GetSceneObjectPart(localId);
+                        if (obj != null)
                         {
-                            PhysActor.Size = new PhysicsVector(m_shape.Scale.X, m_shape.Scale.Y, m_shape.Scale.Z);
-                            m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+                            DetectedObject detobj = new DetectedObject();
+                            detobj.keyUUID = obj.UUID;
+                            detobj.nameStr = obj.Name;
+                            detobj.ownerUUID = obj.OwnerID;
+                            detobj.posVector = obj.AbsolutePosition;
+                            detobj.rotQuat = obj.GetWorldRotation();
+                            detobj.velVector = obj.Velocity;
+                            detobj.colliderType = 0;
+                            detobj.groupUUID = obj.GroupID;
+                            colliding.Add(detobj);
                         }
+                        else
+                        {
+                            List<ScenePresence> avlist = m_parentGroup.Scene.GetScenePresences();
+                            if (avlist != null)
+                            {
+                                foreach (ScenePresence av in avlist)
+                                {
+                                    if (av.LocalId == localId)
+                                    {
+                                        DetectedObject detobj = new DetectedObject();
+                                        detobj.keyUUID = av.UUID;
+                                        detobj.nameStr = av.ControllingClient.Name;
+                                        detobj.ownerUUID = av.UUID;
+                                        detobj.posVector = av.AbsolutePosition;
+                                        detobj.rotQuat = new LLQuaternion(av.Rotation.x, av.Rotation.y, av.Rotation.z, av.Rotation.w);
+                                        detobj.velVector = av.Velocity;
+                                        detobj.colliderType = 0;
+                                        detobj.groupUUID = av.ControllingClient.ActiveGroupId;
+                                        colliding.Add(detobj);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    if (colliding.Count > 0)
+                    {
+                        StartCollidingMessage.Colliders = colliding;
+                        // always running this check because if the user deletes the object it would return a null reference.
+                        if (m_parentGroup == null)
+                            return;
+                        if (m_parentGroup.Scene == null)
+                            return;
+                        m_parentGroup.Scene.EventManager.TriggerScriptCollidingStart(LocalId, StartCollidingMessage);
                     }
                 }
-                TriggerScriptChangedEvent(Changed.SCALE);
+            }
+            if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.collision) != 0)
+            {
+                if (m_lastColliders.Count > 0)
+                {
+                    ColliderArgs CollidingMessage = new ColliderArgs();
+                    List<DetectedObject> colliding = new List<DetectedObject>();
+                    foreach (uint localId in m_lastColliders)
+                    {
+                        // always running this check because if the user deletes the object it would return a null reference.
+                        if (localId == 0)
+                            continue;
+
+                        if (m_parentGroup == null)
+                            return;
+                        if (m_parentGroup.Scene == null)
+                            return;
+                        SceneObjectPart obj = m_parentGroup.Scene.GetSceneObjectPart(localId);
+                        if (obj != null)
+                        {
+                            DetectedObject detobj = new DetectedObject();
+                            detobj.keyUUID = obj.UUID;
+                            detobj.nameStr = obj.Name;
+                            detobj.ownerUUID = obj.OwnerID;
+                            detobj.posVector = obj.AbsolutePosition;
+                            detobj.rotQuat = obj.GetWorldRotation();
+                            detobj.velVector = obj.Velocity;
+                            detobj.colliderType = 0;
+                            detobj.groupUUID = obj.GroupID;
+                            colliding.Add(detobj);
+                        }
+                        else
+                        {
+                            List<ScenePresence> avlist = m_parentGroup.Scene.GetScenePresences();
+                            if (avlist != null)
+                            {
+                                foreach (ScenePresence av in avlist)
+                                {
+                                    if (av.LocalId == localId)
+                                    {
+                                        DetectedObject detobj = new DetectedObject();
+                                        detobj.keyUUID = av.UUID;
+                                        detobj.nameStr = av.Name;
+                                        detobj.ownerUUID = av.UUID;
+                                        detobj.posVector = av.AbsolutePosition;
+                                        detobj.rotQuat = new LLQuaternion(av.Rotation.x, av.Rotation.y, av.Rotation.z, av.Rotation.w);
+                                        detobj.velVector = av.Velocity;
+                                        detobj.colliderType = 0;
+                                        detobj.groupUUID = av.ControllingClient.ActiveGroupId;
+                                        colliding.Add(detobj);
+                                    }
+                                }
+
+                            }
+                        }
+                    }
+                    if (colliding.Count > 0)
+                    {
+                        CollidingMessage.Colliders = colliding;
+                        // always running this check because if the user deletes the object it would return a null reference.
+                        if (m_parentGroup == null)
+                            return;
+                        if (m_parentGroup.Scene == null)
+                            return;
+                        m_parentGroup.Scene.EventManager.TriggerScriptColliding(LocalId, CollidingMessage);
+                    }
+
+                }
+            }
+            if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.collision_end) != 0)
+            {
+                if (endedColliders.Count > 0)
+                {
+                    ColliderArgs EndCollidingMessage = new ColliderArgs();
+                    List<DetectedObject> colliding = new List<DetectedObject>();
+                    foreach (uint localId in endedColliders)
+                    {
+                        if (localId == 0)
+                            continue;
+
+                        // always running this check because if the user deletes the object it would return a null reference.
+                        if (m_parentGroup == null)
+                            return;
+                        if (m_parentGroup.Scene == null)
+                            return;
+                        SceneObjectPart obj = m_parentGroup.Scene.GetSceneObjectPart(localId);
+                        if (obj != null)
+                        {
+                            DetectedObject detobj = new DetectedObject();
+                            detobj.keyUUID = obj.UUID;
+                            detobj.nameStr = obj.Name;
+                            detobj.ownerUUID = obj.OwnerID;
+                            detobj.posVector = obj.AbsolutePosition;
+                            detobj.rotQuat = obj.GetWorldRotation();
+                            detobj.velVector = obj.Velocity;
+                            detobj.colliderType = 0;
+                            detobj.groupUUID = obj.GroupID;
+                            colliding.Add(detobj);
+                        }
+                        else
+                        {
+                            List<ScenePresence> avlist = m_parentGroup.Scene.GetScenePresences();
+                            if (avlist != null)
+                            {
+                                foreach (ScenePresence av in avlist)
+                                {
+                                    if (av.LocalId == localId)
+                                    {
+                                        DetectedObject detobj = new DetectedObject();
+                                        detobj.keyUUID = av.UUID;
+                                        detobj.nameStr = av.Name;
+                                        detobj.ownerUUID = av.UUID;
+                                        detobj.posVector = av.AbsolutePosition;
+                                        detobj.rotQuat = new LLQuaternion(av.Rotation.x, av.Rotation.y, av.Rotation.z, av.Rotation.w);
+                                        detobj.velVector = av.Velocity;
+                                        detobj.colliderType = 0;
+                                        detobj.groupUUID = av.ControllingClient.ActiveGroupId;
+                                        colliding.Add(detobj);
+                                    }
+                                }
+
+                            }
+                        }
+                    }
+                    if (colliding.Count > 0)
+                    {
+                        EndCollidingMessage.Colliders = colliding;
+                        // always running this check because if the user deletes the object it would return a null reference.
+                        if (m_parentGroup == null)
+                            return;
+                        if (m_parentGroup.Scene == null)
+                            return;
+                        m_parentGroup.Scene.EventManager.TriggerScriptCollidingEnd(LocalId, EndCollidingMessage);
+                    }
+
+                }
             }
         }
 
-        public bool Stopped
+        public void PhysicsOutOfBounds(PhysicsVector pos)
         {
-            get {
-                double threshold = 0.02;
-                return (Math.Abs(Velocity.X) < threshold &&
-                        Math.Abs(Velocity.Y) < threshold &&
-                        Math.Abs(Velocity.Z) < threshold &&
-                        Math.Abs(AngularVelocity.X) < threshold &&
-                        Math.Abs(AngularVelocity.Y) < threshold &&
-                        Math.Abs(AngularVelocity.Z) < threshold);
+            m_log.Info("[PHYSICS]: Physical Object went out of bounds.");
+            RemFlag(LLObject.ObjectFlags.Physics);
+            DoPhysicsPropertyUpdate(false, true);
+            //m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+        }
+
+        public void PhysicsRequestingTerseUpdate()
+        {
+            if (PhysActor != null)
+            {
+                LLVector3 newpos = new LLVector3(PhysActor.Position.GetBytes(), 0);
+                if (newpos.X > 257f || newpos.X < -1f || newpos.Y > 257f || newpos.Y < -1f)
+                {
+                    m_parentGroup.AbsolutePosition = newpos;
+                    return;
+                }
             }
+            ScheduleTerseUpdate();
+
+            //SendTerseUpdateToAllClients();
         }
 
-        #endregion
+        public void PreloadSound(string sound)
+        {
+            LLUUID ownerID = OwnerID;
+            LLUUID objectID = UUID;
+            LLUUID soundID = LLUUID.Zero;
 
-        public LLUUID ObjectOwner
+            if (!LLUUID.TryParse(sound, out soundID))
+            {
+                //Trys to fetch sound id from prim's inventory.
+                //Prim's inventory doesn't support non script items yet
+                SceneObjectPart op = this;
+                foreach (KeyValuePair<LLUUID, TaskInventoryItem> item in op.TaskInventory)
+                {
+                    if (item.Value.Name == sound)
+                    {
+                        soundID = item.Value.ItemID;
+                        break;
+                    }
+                }
+            }
+
+            List<ScenePresence> avatarts = m_parentGroup.Scene.GetAvatars();
+            foreach (ScenePresence p in avatarts)
+            {
+                // TODO: some filtering by distance of avatar
+
+                p.ControllingClient.SendPreLoadSound(objectID, objectID, soundID);
+            }
+        }
+
+        public void RemFlag(LLObject.ObjectFlags flag)
         {
-            get { return OwnerID; }
+            LLObject.ObjectFlags prevflag = Flags;
+            if ((ObjectFlags & (uint) flag) != 0)
+            {
+                //Console.WriteLine("Removing flag: " + ((LLObject.ObjectFlags)flag).ToString());
+                Flags &= ~flag;
+            }
+            //System.Console.WriteLine("prev: " + prevflag.ToString() + " curr: " + Flags.ToString());
+            //ScheduleFullUpdate();
         }
 
-        // FIXME, TODO, ERROR: 'ParentGroup' can't be in here, move it out.
-        protected SceneObjectGroup m_parentGroup;
+        public void RemoveScriptEvents(LLUUID scriptid)
+        {
+            lock (m_scriptEvents)
+            {
+                if (m_scriptEvents.ContainsKey(scriptid))
+                {
+                    scriptEvents oldparts = scriptEvents.None;
+                    oldparts = (scriptEvents) m_scriptEvents[scriptid];
 
-        public SceneObjectGroup ParentGroup
+                    // remove values from aggregated script events
+                    m_aggregateScriptEvents &= ~oldparts;
+                    m_scriptEvents.Remove(scriptid);
+                }
+            }
+            aggregateScriptEvents();
+        }
+
+        /// <summary>
+        /// Reset LLUUIDs for this part.  This involves generate this part's own LLUUID and
+        /// generating new LLUUIDs for all the items in the inventory.
+        /// </summary>
+        /// <param name="linkNum">Link number for the part</param>
+        public void ResetIDs(int linkNum)
         {
-            get { return m_parentGroup; }
+            UUID = LLUUID.Random();
+            LinkNum = linkNum;
+
+            ResetInventoryIDs();
         }
 
-        public byte UpdateFlag
+        /// <summary>
+        /// Resize this part.
+        /// </summary>
+        /// <param name="scale"></param>
+        public void Resize(LLVector3 scale)
         {
-            get { return m_updateFlag; }
-            set { m_updateFlag = value; }
+            StoreUndoState();
+            m_shape.Scale = scale;
+
+            ParentGroup.HasGroupChanged = true;
+            ScheduleFullUpdate();
         }
 
-        #region Constructors
+        /// <summary>
+        /// Schedules this prim for a full update
+        /// </summary>
+        public void ScheduleFullUpdate()
+        {
+            if (m_parentGroup != null)
+            {
+                m_parentGroup.QueueForUpdateCheck();
+            }
+
+            int timeNow = Util.UnixTimeSinceEpoch();
+
+            // If multiple updates are scheduled on the same second, we still need to perform all of them
+            // So we'll force the issue by bumping up the timestamp so that later processing sees these need
+            // to be performed.
+            if (timeNow <= TimeStampFull)
+            {
+                TimeStampFull += 1;
+            }
+            else
+            {
+                TimeStampFull = (uint)timeNow;
+            }
+
+            m_updateFlag = 2;
+
+            //            m_log.DebugFormat(
+            //                "[SCENE OBJECT PART]: Scheduling full  update for {0}, {1} at {2}",
+            //                UUID, Name, TimeStampFull);
+        }
 
         /// <summary>
-        /// No arg constructor called by region restore db code
+        /// Schedule a terse update for this prim.  Terse updates only send position,
+        /// rotation, velocity, rotational velocity and shape information.
         /// </summary>
-        public SceneObjectPart()
+        public void ScheduleTerseUpdate()
         {
-            // It's not necessary to persist this
-            m_TextureAnimation = new byte[0];
+            if (m_updateFlag < 1)
+            {
+                if (m_parentGroup != null)
+                {
+                    m_parentGroup.HasGroupChanged = true;
+                    m_parentGroup.QueueForUpdateCheck();
+                }
+                TimeStampTerse = (uint) Util.UnixTimeSinceEpoch();
+                m_updateFlag = 1;
+
+            //                m_log.DebugFormat(
+            //                    "[SCENE OBJECT PART]: Scheduling terse update for {0}, {1} at {2}",
+            //                    UUID, Name, TimeStampTerse);
+            }
         }
 
-        public SceneObjectPart(ulong regionHandle, SceneObjectGroup parent, LLUUID ownerID, uint localID,
-                               PrimitiveBaseShape shape, LLVector3 groupPosition, LLVector3 offsetPosition)
-            : this(regionHandle, parent, ownerID, localID, shape, groupPosition, LLQuaternion.Identity, offsetPosition)
+        public void ScriptSetPhantomStatus(bool Phantom)
+        {
+            if (m_parentGroup != null)
+            {
+                m_parentGroup.ScriptSetPhantomStatus(Phantom);
+            }
+        }
+
+        public void ScriptSetPhysicsStatus(bool UsePhysics)
         {
+            if (m_parentGroup != null)
+            {
+                m_parentGroup.ScriptSetPhysicsStatus(UsePhysics);
+            }
+        }
+
+        public void SculptTextureCallback(LLUUID textureID, AssetBase texture)
+        {
+            if (m_shape.SculptEntry)
+            {
+                if (texture != null)
+                {
+                    m_shape.SculptData = texture.Data;
+                    if (PhysActor != null)
+                    {
+                        // Tricks physics engine into thinking we've changed the part shape.
+                        PrimitiveBaseShape m_newshape = m_shape.Copy();
+                        PhysActor.Shape = m_newshape;
+                        m_shape = m_newshape;
+                    }
+                }
+            }
         }
 
         /// <summary>
-        /// Create a completely new SceneObjectPart (prim)
+        ///
         /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="parent"></param>
-        /// <param name="ownerID"></param>
-        /// <param name="localID"></param>
-        /// <param name="shape"></param>
-        /// <param name="position"></param>
-        public SceneObjectPart(ulong regionHandle, SceneObjectGroup parent, LLUUID ownerID, uint localID,
-                               PrimitiveBaseShape shape, LLVector3 groupPosition, LLQuaternion rotationOffset,
-                               LLVector3 offsetPosition)
+        /// <param name="remoteClient"></param>
+        public void SendFullUpdate(IClientAPI remoteClient, uint clientFlags)
         {
-            m_name = "Primitive";
-            m_regionHandle = regionHandle;
-            m_parentGroup = parent;
+            m_parentGroup.SendPartFullUpdate(remoteClient, this, clientFlags);
+        }
 
-            CreationDate = (Int32) (DateTime.UtcNow - new DateTime(1970, 1, 1)).TotalSeconds;
-            OwnerID = ownerID;
-            CreatorID = OwnerID;
-            LastOwnerID = LLUUID.Zero;
-            UUID = LLUUID.Random();
-            LocalId = (uint) (localID);
-            Shape = shape;
-            // Todo: Add More Object Parameter from above!
-            OwnershipCost = 0;
-            ObjectSaleType = (byte) 0;
-            SalePrice = 0;
-            Category = (uint) 0;
-            LastOwnerID = CreatorID;
-            // End Todo: ///
-            GroupPosition = groupPosition;
-            OffsetPosition = offsetPosition;
-            RotationOffset = rotationOffset;
-            Velocity = new LLVector3(0, 0, 0);
-            m_rotationalvelocity = new LLVector3(0, 0, 0);
-            AngularVelocity = new LLVector3(0, 0, 0);
-            Acceleration = new LLVector3(0, 0, 0);
-            m_TextureAnimation = new byte[0];
+        /// <summary>
+        ///
+        /// </summary>
+        public void SendFullUpdateToAllClients()
+        {
+            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
+            for (int i = 0; i < avatars.Count; i++)
+            {
+                // Ugly reference :(
+                m_parentGroup.SendPartFullUpdate(avatars[i].ControllingClient, this,
+                                                 avatars[i].GenerateClientFlags(UUID));
+            }
+        }
 
-            // Prims currently only contain a single folder (Contents).  From looking at the Second Life protocol,
-            // this appears to have the same UUID (!) as the prim.  If this isn't the case, one can't drag items from
-            // the prim into an agent inventory (Linden client reports that the "Object not found for drop" in its log
+        public void SendFullUpdateToAllClientsExcept(LLUUID agentID)
+        {
+            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
+            for (int i = 0; i < avatars.Count; i++)
+            {
+                // Ugly reference :(
+                if (avatars[i].UUID != agentID)
+                {
+                    m_parentGroup.SendPartFullUpdate(avatars[i].ControllingClient, this,
+                                                    avatars[i].GenerateClientFlags(UUID));
+                }
+            }
+        }
 
-            Flags = 0;
-            Flags |= LLObject.ObjectFlags.CreateSelected;
+        /// <summary>
+        /// Sends a full update to the client
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="clientFlags"></param>
+        public void SendFullUpdateToClient(IClientAPI remoteClient, uint clientflags)
+        {
+            LLVector3 lPos;
+            lPos = OffsetPosition;
+            SendFullUpdateToClient(remoteClient, lPos, clientflags);
+        }
 
-            TrimPermissions();
-            //m_undo = new UndoStack<UndoState>(ParentGroup.GetSceneMaxUndo());
+        /// <summary>
+        /// Sends a full update to the client
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        /// <param name="lPos"></param>
+        /// <param name="clientFlags"></param>
+        public void SendFullUpdateToClient(IClientAPI remoteClient, LLVector3 lPos, uint clientFlags)
+        {
+            clientFlags &= ~(uint) LLObject.ObjectFlags.CreateSelected;
 
-            ScheduleFullUpdate();
+            if (remoteClient.AgentId == OwnerID)
+            {
+                if ((uint) (Flags & LLObject.ObjectFlags.CreateSelected) != 0)
+                {
+                    clientFlags |= (uint) LLObject.ObjectFlags.CreateSelected;
+                    Flags &= ~LLObject.ObjectFlags.CreateSelected;
+                }
+            }
+
+            byte[] color = new byte[] {m_color.R, m_color.G, m_color.B, m_color.A};
+            remoteClient.SendPrimitiveToClient(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, m_shape,
+                                               lPos, Velocity, Acceleration, RotationOffset, RotationalVelocity, clientFlags, m_uuid, OwnerID,
+                                               m_text, color, ParentID, m_particleSystem, m_clickAction, m_TextureAnimation, m_IsAttachment,
+                                               m_attachmentPoint,fromAssetID, Sound, SoundGain, SoundFlags, SoundRadius);
         }
 
         /// <summary>
-        /// Re/create a SceneObjectPart (prim)
-        /// currently not used, and maybe won't be
+        /// Tell all the prims which have had updates scheduled
         /// </summary>
-        /// <param name="regionHandle"></param>
-        /// <param name="parent"></param>
-        /// <param name="ownerID"></param>
-        /// <param name="localID"></param>
-        /// <param name="shape"></param>
-        /// <param name="position"></param>
-        public SceneObjectPart(ulong regionHandle, SceneObjectGroup parent, int creationDate, LLUUID ownerID,
-                               LLUUID creatorID, LLUUID lastOwnerID, uint localID, PrimitiveBaseShape shape,
-                               LLVector3 position, LLQuaternion rotation, uint flags)
+        public void SendScheduledUpdates()
         {
-            m_regionHandle = regionHandle;
-            m_parentGroup = parent;
-            TimeStampTerse = (uint) Util.UnixTimeSinceEpoch();
-            CreationDate = creationDate;
-            OwnerID = ownerID;
-            CreatorID = creatorID;
-            LastOwnerID = lastOwnerID;
-            UUID = LLUUID.Random();
-            LocalId = (uint) (localID);
-            Shape = shape;
-            OwnershipCost = 0;
-            ObjectSaleType = (byte) 0;
-            SalePrice = 0;
-            Category = (uint) 0;
-            LastOwnerID = CreatorID;
-            OffsetPosition = position;
-            RotationOffset = rotation;
-            ObjectFlags = flags;
+            if (m_updateFlag == 1) //some change has been made so update the clients
+            {
+                AddTerseUpdateToAllAvatars();
+                ClearUpdateSchedule();
 
-            // Since we don't store script state, this is only a 'temporary' objectflag now
-            // If the object is scripted, the script will get loaded and this will be set again
-            ObjectFlags &= ~(uint)(LLObject.ObjectFlags.Scripted | LLObject.ObjectFlags.Touch);
+                // This causes the Scene to 'poll' physical objects every couple of frames
+                // bad, so it's been replaced by an event driven method.
+                //if ((ObjectFlags & (uint)LLObject.ObjectFlags.Physics) != 0)
+                //{
+                // Only send the constant terse updates on physical objects!
+                //ScheduleTerseUpdate();
+                //}
+            }
+            else
+            {
+                if (m_updateFlag == 2) // is a new prim, just created/reloaded or has major changes
+                {
+                    AddFullUpdateToAllAvatars();
+                    ClearUpdateSchedule();
+                }
+            }
+        }
 
-            TrimPermissions();
-            // ApplyPhysics();
+        public void SendSound(string sound, double volume, bool triggered, byte flags)
+        {
+            if (volume > 1)
+                volume = 1;
+            if (volume < 0)
+                volume = 0;
 
-            ScheduleFullUpdate();
+            LLUUID ownerID = OwnerID;
+            LLUUID objectID = UUID;
+            LLUUID parentID = GetRootPartUUID();
+            LLUUID soundID = LLUUID.Zero;
+            LLVector3 position = AbsolutePosition; // region local
+            ulong regionHandle = m_parentGroup.Scene.RegionInfo.RegionHandle;
+
+            //byte flags = 0;
+
+            if (!LLUUID.TryParse(sound, out soundID))
+            {
+                // search sound file from inventory
+                SceneObjectPart op = this;
+                foreach (KeyValuePair<LLUUID, TaskInventoryItem> item in op.TaskInventory)
+                {
+                    if (item.Value.Name == sound && item.Value.Type == (int)AssetType.Sound)
+                    {
+                        soundID = item.Value.ItemID;
+                        break;
+                    }
+                }
+            }
+
+            if (soundID == LLUUID.Zero)
+                return;
+
+            List<ScenePresence> avatarts = m_parentGroup.Scene.GetAvatars();
+            foreach (ScenePresence p in avatarts)
+            {
+                double dis=Util.GetDistanceTo(p.AbsolutePosition, position);
+                if (dis > 100.0) // Max audio distance
+                    continue;
+
+                // Scale by distance
+                volume*=((100.0-dis)/100.0);
+
+                if (triggered)
+                {
+                    p.ControllingClient.SendTriggeredSound(soundID, ownerID, objectID, parentID, regionHandle, position, (float)volume);
+                }
+                else
+                {
+                    p.ControllingClient.SendPlayAttachedSound(soundID, objectID, ownerID, (float)volume, flags);
+                }
+            }
         }
 
-        #endregion
+        /// <summary>
+        /// Send a terse update to the client.
+        /// </summary>
+        /// <param name="remoteClient"></param>
+        public void SendTerseUpdate(IClientAPI remoteClient)
+        {
+            m_parentGroup.SendPartTerseUpdate(remoteClient, this);
+        }
 
         /// <summary>
-        /// Restore this part from the serialized xml representation.
+        ///
         /// </summary>
-        /// <param name="xmlreader"></param>
-        /// <returns></returns>
-        public static SceneObjectPart FromXml(XmlReader xmlReader)
+        public void SendTerseUpdateToAllClients()
         {
-            // It's not necessary to persist this
+            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
+            for (int i = 0; i < avatars.Count; i++)
+            {
+                m_parentGroup.SendPartTerseUpdate(avatars[i].ControllingClient, this);
+            }
+        }
 
-            XmlSerializer serializer = new XmlSerializer(typeof (SceneObjectPart));
-            SceneObjectPart newobject = (SceneObjectPart) serializer.Deserialize(xmlReader);
-            return newobject;
+        public void SendTerseUpdateToClient(IClientAPI remoteClient)
+        {
+            LLVector3 lPos;
+            lPos = OffsetPosition;
+            LLQuaternion mRot = RotationOffset;
+            // TODO: I have no idea why we are making this check.  This should be sorted out
+            if ((ObjectFlags & (uint) LLObject.ObjectFlags.Physics) == 0)
+            {
+                remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity, RotationalVelocity, Shape.State, fromAssetID);
+            }
+            else
+            {
+                remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity,
+                                                 RotationalVelocity);
+                //System.Console.WriteLine("LID: " + LocalID + " RVel:" + RotationalVelocity.ToString() + " TD: " + ((ushort)(m_parentGroup.Scene.TimeDilation * 500000f)).ToString() + ":" + m_parentGroup.Scene.TimeDilation.ToString());
+            }
+        }
+
+        public void SendTerseUpdateToClient(IClientAPI remoteClient, LLVector3 lPos)
+        {
+            LLQuaternion mRot = RotationOffset;
+            if (m_IsAttachment)
+            {
+                remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity, RotationalVelocity, (byte)((m_attachmentPoint % 16) * 16 + (m_attachmentPoint / 16)),fromAssetID);
+            }
+            else
+            {
+                if ((ObjectFlags & (uint)LLObject.ObjectFlags.Physics) == 0)
+                {
+                    remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity, RotationalVelocity, Shape.State, fromAssetID);
+                }
+                else
+                {
+                    remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity,
+                                                     RotationalVelocity);
+                    //System.Console.WriteLine("LID: " + LocalID + "RVel:" + RotationalVelocity.ToString() + " TD: " + ((ushort)(m_parentGroup.Scene.TimeDilation * 500000f)).ToString() + ":" + m_parentGroup.Scene.TimeDilation.ToString());
+                }
+            }
+        }
+
+        public void SetAttachmentPoint(uint AttachmentPoint)
+        {
+            m_attachmentPoint = AttachmentPoint;
+
+            // save the attachment point.
+            //if (AttachmentPoint != 0)
+            //{
+                m_shape.State = (byte)AttachmentPoint;
+            //}
+        }
+
+        public void SetAvatarOnSitTarget(LLUUID avatarID)
+        {
+            m_sitTargetAvatar = avatarID;
+            TriggerScriptChangedEvent(Changed.LINK);
+        }
+
+        public void SetAxisRotation(int axis, int rotate)
+        {
+            if (m_parentGroup != null)
+            {
+                m_parentGroup.SetAxisRotation(axis, rotate);
+            }
+        }
+
+        public void SetBuoyancy(float fvalue)
+        {
+            if (PhysActor != null)
+            {
+                PhysActor.Buoyancy = fvalue;
+            }
+        }
+
+        public void SetDieAtEdge(bool p)
+        {
+            if (m_parentGroup == null)
+                return;
+            if (m_parentGroup.RootPart == null)
+                return;
+
+            m_parentGroup.RootPart.DIE_AT_EDGE = p;
+        }
+
+        public void SetFloatOnWater(int floatYN)
+        {
+            if (PhysActor != null)
+            {
+                if (floatYN == 1)
+                {
+                    PhysActor.FloatOnWater = true;
+                }
+                else
+                {
+                    PhysActor.FloatOnWater = false;
+                }
+            }
+        }
+
+        public void SetGroup(LLUUID groupID, IClientAPI client)
+        {
+            GroupID = groupID;
+            GetProperties(client);
+            m_updateFlag = 2;
         }
 
         /// <summary>
-        /// Apply physics to this part.
+        ///
         /// </summary>
-        /// <param name="rootObjectFlags"></param>
-        /// <param name="m_physicalPrim"></param>
-        public void ApplyPhysics(uint rootObjectFlags, bool m_physicalPrim)
+        public void SetParent(SceneObjectGroup parent)
         {
-            bool isPhysical = (((rootObjectFlags & (uint) LLObject.ObjectFlags.Physics) != 0) && m_physicalPrim);
-            bool isPhantom = ((rootObjectFlags & (uint) LLObject.ObjectFlags.Phantom) != 0);
+            m_parentGroup = parent;
+        }
 
-            // Added clarification..   since A rigid body is an object that you can kick around, etc.
-            bool RigidBody = isPhysical && !isPhantom;
+        // Use this for attachments!  LocalID should be avatar's localid
+        public void SetParentLocalId(uint localID)
+        {
+            ParentID = localID;
+        }
 
-            // The only time the physics scene shouldn't know about the prim is if it's phantom
-            if (!isPhantom)
+        public void SetPhysicsAxisRotation()
+        {
+            PhysActor.LockAngularMotion(m_rotationAxis);
+            m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
+        }
+
+        public void SetScriptEvents(LLUUID scriptid, int events)
+        {
+            scriptEvents oldparts;
+            lock (m_scriptEvents)
             {
-                PhysActor = m_parentGroup.Scene.PhysicsScene.AddPrimShape(
-                    Name,
-                    Shape,
-                    new PhysicsVector(AbsolutePosition.X, AbsolutePosition.Y,
-                                      AbsolutePosition.Z),
-                    new PhysicsVector(Scale.X, Scale.Y, Scale.Z),
-                    new Quaternion(RotationOffset.W, RotationOffset.X,
-                                   RotationOffset.Y, RotationOffset.Z), RigidBody);
+                if (m_scriptEvents.ContainsKey(scriptid))
+                {
+                    oldparts = m_scriptEvents[scriptid];
 
-                // Basic Physics returns null..  joy joy joy.
-                if (PhysActor != null)
+                    // remove values from aggregated script events
+                    m_scriptEvents[scriptid] = (scriptEvents) events;
+                }
+                else
                 {
-                    PhysActor.LocalID = LocalId;
-                    DoPhysicsPropertyUpdate(RigidBody, true);
+                    m_scriptEvents.Add(scriptid, (scriptEvents) events);
                 }
             }
+            aggregateScriptEvents();
         }
 
-        public void TrimPermissions()
+        public void SetSitTarget(Vector3 offset, Quaternion orientation)
         {
+            m_sitTargetPosition = offset;
+            m_sitTargetOrientation = orientation;
+        }
 
-            BaseMask &= (uint)PermissionMask.All;
-            OwnerMask &= (uint)PermissionMask.All;
-            GroupMask &= (uint)PermissionMask.All;
-            EveryoneMask &= (uint)PermissionMask.All;
-            NextOwnerMask &= (uint)PermissionMask.All;
+        // Utility function so the databases don't have to reference axiom.math
+        public void SetSitTargetLL(LLVector3 offset, LLQuaternion orientation)
+        {
+            if (
+                !(offset.X == 0 && offset.Y == 0 && offset.Z == 0 && (orientation.W == 0 || orientation.W == 1) &&
+                  orientation.X == 0 && orientation.Y == 0 && orientation.Z == 0))
+            {
+                m_sitTargetPosition = new Vector3(offset.X, offset.Y, offset.Z);
+                m_sitTargetOrientation = new Quaternion(orientation.W, orientation.X, orientation.Y, orientation.Z);
+            }
+        }
 
+        /// <summary>
+        /// Set the text displayed for this part.
+        /// </summary>
+        /// <param name="text"></param>
+        public void SetText(string text)
+        {
+            Text = text;
+
+            ParentGroup.HasGroupChanged = true;
+            ScheduleFullUpdate();
         }
 
         /// <summary>
-        /// Serialize this part to xml.
+        /// Set the text displayed for this part.
         /// </summary>
-        /// <param name="xmlWriter"></param>
-        public void ToXml(XmlWriter xmlWriter)
+        /// <param name="text"></param>
+        /// <param name="color"></param>
+        /// <param name="alpha"></param>
+        public void SetText(string text, Vector3 color, double alpha)
         {
-            XmlSerializer serializer = new XmlSerializer(typeof (SceneObjectPart));
-            serializer.Serialize(xmlWriter, this);
+            Color = Color.FromArgb(0xff - (int) (alpha*0xff),
+                                   (int) (color.x*0xff),
+                                   (int) (color.y*0xff),
+                                   (int) (color.z*0xff));
+            SetText(text);
+        }
+
+        public void StopMoveToTarget()
+        {
+            m_parentGroup.stopMoveToTarget();
+        }
+
+        public void StoreUndoState()
+        {
+            if (!m_undoing)
+            {
+                if (m_parentGroup != null)
+                {
+                    if (m_undo.Count > 0)
+                    {
+                        UndoState last = m_undo.Peek();
+                        if (last != null)
+                        {
+                            if (last.Compare(this))
+                                return;
+                        }
+                    }
+
+
+                    if (m_parentGroup.GetSceneMaxUndo() > 0)
+                    {
+                        UndoState nUndo = new UndoState(this);
+
+                        m_undo.Push(nUndo);
+
+                    }
+                }
+            }
         }
 
         public EntityIntersection TestIntersection(Ray iray, Quaternion parentrot)
@@ -1086,14 +2359,6 @@ namespace OpenSim.Region.Environment.Scenes
             return returnresult;
         }
 
-        public double GetDistanceTo(Vector3 a, Vector3 b)
-        {
-            float dx = a.x - b.x;
-            float dy = a.y - b.y;
-            float dz = a.z - b.z;
-            return Math.Sqrt(dx * dx + dy * dy + dz * dz);
-        }
-
         public EntityIntersection TestIntersectionOBB(Ray iray, Quaternion parentrot, bool frontFacesOnly, bool faceCenters)
         {
             // In this case we're using a rectangular prism, which has 6 faces and therefore 6 planes
@@ -1183,7 +2448,7 @@ namespace OpenSim.Region.Environment.Scenes
             tScale = new Vector3(AXscale.x, -AXscale.y, AXscale.z);
             rScale = ((AXrot * tScale));
             vertexes[0] = (new Vector3((pos.X + rScale.x), (pos.Y + rScale.y), (pos.Z + rScale.z)));
-           // vertexes[0].x = pos.X + vertexes[0].x;
+               // vertexes[0].x = pos.X + vertexes[0].x;
             //vertexes[0].y = pos.Y + vertexes[0].y;
             //vertexes[0].z = pos.Z + vertexes[0].z;
 
@@ -1195,8 +2460,8 @@ namespace OpenSim.Region.Environment.Scenes
             rScale = ((AXrot * tScale));
             vertexes[1] = (new Vector3((pos.X + rScale.x), (pos.Y + rScale.y), (pos.Z + rScale.z)));
 
-           // vertexes[1].x = pos.X + vertexes[1].x;
-           // vertexes[1].y = pos.Y + vertexes[1].y;
+               // vertexes[1].x = pos.X + vertexes[1].x;
+               // vertexes[1].y = pos.Y + vertexes[1].y;
             //vertexes[1].z = pos.Z + vertexes[1].z;
 
             FaceB[0] = vertexes[1];
@@ -1221,8 +2486,8 @@ namespace OpenSim.Region.Environment.Scenes
             vertexes[3] = (new Vector3((pos.X + rScale.x), (pos.Y + rScale.y), (pos.Z + rScale.z)));
 
             //vertexes[3].x = pos.X + vertexes[3].x;
-           // vertexes[3].y = pos.Y + vertexes[3].y;
-           // vertexes[3].z = pos.Z + vertexes[3].z;
+               // vertexes[3].y = pos.Y + vertexes[3].y;
+               // vertexes[3].z = pos.Z + vertexes[3].z;
 
             FaceD[0] = vertexes[3];
             FaceC[1] = vertexes[3];
@@ -1232,9 +2497,9 @@ namespace OpenSim.Region.Environment.Scenes
             rScale = ((AXrot * tScale));
             vertexes[4] = (new Vector3((pos.X + rScale.x), (pos.Y + rScale.y), (pos.Z + rScale.z)));
 
-           // vertexes[4].x = pos.X + vertexes[4].x;
-           // vertexes[4].y = pos.Y + vertexes[4].y;
-           // vertexes[4].z = pos.Z + vertexes[4].z;
+               // vertexes[4].x = pos.X + vertexes[4].x;
+               // vertexes[4].y = pos.Y + vertexes[4].y;
+               // vertexes[4].z = pos.Z + vertexes[4].z;
 
             FaceB[1] = vertexes[4];
             FaceA[2] = vertexes[4];
@@ -1244,9 +2509,9 @@ namespace OpenSim.Region.Environment.Scenes
             rScale = ((AXrot * tScale));
             vertexes[5] = (new Vector3((pos.X + rScale.x), (pos.Y + rScale.y), (pos.Z + rScale.z)));
 
-           // vertexes[5].x = pos.X + vertexes[5].x;
-           // vertexes[5].y = pos.Y + vertexes[5].y;
-           // vertexes[5].z = pos.Z + vertexes[5].z;
+               // vertexes[5].x = pos.X + vertexes[5].x;
+               // vertexes[5].y = pos.Y + vertexes[5].y;
+               // vertexes[5].z = pos.Z + vertexes[5].z;
 
             FaceD[1] = vertexes[5];
             FaceC[2] = vertexes[5];
@@ -1256,9 +2521,9 @@ namespace OpenSim.Region.Environment.Scenes
             rScale = ((AXrot * tScale));
             vertexes[6] = (new Vector3((pos.X + rScale.x), (pos.Y + rScale.y), (pos.Z + rScale.z)));
 
-           // vertexes[6].x = pos.X + vertexes[6].x;
-           // vertexes[6].y = pos.Y + vertexes[6].y;
-           // vertexes[6].z = pos.Z + vertexes[6].z;
+               // vertexes[6].x = pos.X + vertexes[6].x;
+               // vertexes[6].y = pos.Y + vertexes[6].y;
+               // vertexes[6].z = pos.Z + vertexes[6].z;
 
             FaceB[2] = vertexes[6];
             FaceA[3] = vertexes[6];
@@ -1268,9 +2533,9 @@ namespace OpenSim.Region.Environment.Scenes
             rScale = ((AXrot * tScale));
             vertexes[7] = (new Vector3((pos.X + rScale.x), (pos.Y + rScale.y), (pos.Z + rScale.z)));
 
-           // vertexes[7].x = pos.X + vertexes[7].x;
-           // vertexes[7].y = pos.Y + vertexes[7].y;
-           // vertexes[7].z = pos.Z + vertexes[7].z;
+               // vertexes[7].x = pos.X + vertexes[7].x;
+               // vertexes[7].y = pos.Y + vertexes[7].y;
+               // vertexes[7].z = pos.Z + vertexes[7].z;
 
             FaceD[2] = vertexes[7];
             FaceC[3] = vertexes[7];
@@ -1352,7 +2617,7 @@ namespace OpenSim.Region.Environment.Scenes
             //if (fmax > 0)
             //    a= fmax;
             //else
-           //     a=fmin;
+               //     a=fmin;
 
             //q = iray.Origin + a * iray.Direction;
             #endregion
@@ -1437,370 +2702,122 @@ namespace OpenSim.Region.Environment.Scenes
             return returnresult;
         }
 
-        // Use this for attachments!  LocalID should be avatar's localid
-        public void SetParentLocalId(uint localID)
-        {
-            ParentID = localID;
-        }
-
-        public void SetAttachmentPoint(uint AttachmentPoint)
-        {
-            m_attachmentPoint = AttachmentPoint;
-
-            // save the attachment point.
-            //if (AttachmentPoint != 0)
-            //{
-                m_shape.State = (byte)AttachmentPoint;
-            //}
-        }
-
         /// <summary>
-        ///
+        /// Serialize this part to xml.
         /// </summary>
-        public void SetParent(SceneObjectGroup parent)
-        {
-            m_parentGroup = parent;
-        }
-
-        public void SetSitTarget(Vector3 offset, Quaternion orientation)
-        {
-            m_sitTargetPosition = offset;
-            m_sitTargetOrientation = orientation;
-        }
-
-        public void SetBuoyancy(float fvalue)
+        /// <param name="xmlWriter"></param>
+        public void ToXml(XmlWriter xmlWriter)
         {
-            if (PhysActor != null)
-            {
-                PhysActor.Buoyancy = fvalue;
-            }
+            XmlSerializer serializer = new XmlSerializer(typeof (SceneObjectPart));
+            serializer.Serialize(xmlWriter, this);
         }
 
-        public void SetAxisRotation(int axis, int rotate)
+        public void TriggerScriptChangedEvent(Changed val)
         {
             if (m_parentGroup != null)
             {
-                m_parentGroup.SetAxisRotation(axis, rotate);
-            }
-        }
-
-        public void SetPhysicsAxisRotation()
-        {
-            PhysActor.LockAngularMotion(m_rotationAxis);
-            m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
-        }
-
-        public void SetFloatOnWater(int floatYN)
-        {
-            if (PhysActor != null)
-            {
-                if (floatYN == 1)
-                {
-                    PhysActor.FloatOnWater = true;
-                }
-                else
-                {
-                    PhysActor.FloatOnWater = false;
-                }
-            }
-        }
-
-        public LLVector3 GetSitTargetPositionLL()
-        {
-            return new LLVector3(m_sitTargetPosition.x, m_sitTargetPosition.y, m_sitTargetPosition.z);
-        }
-
-        public LLQuaternion GetSitTargetOrientationLL()
-        {
-            return
-                new LLQuaternion(m_sitTargetOrientation.x, m_sitTargetOrientation.y, m_sitTargetOrientation.z,
-                                 m_sitTargetOrientation.w);
-        }
-
-        // Utility function so the databases don't have to reference axiom.math
-        public void SetSitTargetLL(LLVector3 offset, LLQuaternion orientation)
-        {
-            if (
-                !(offset.X == 0 && offset.Y == 0 && offset.Z == 0 && (orientation.W == 0 || orientation.W == 1) &&
-                  orientation.X == 0 && orientation.Y == 0 && orientation.Z == 0))
-            {
-                m_sitTargetPosition = new Vector3(offset.X, offset.Y, offset.Z);
-                m_sitTargetOrientation = new Quaternion(orientation.W, orientation.X, orientation.Y, orientation.Z);
+                if (m_parentGroup.Scene != null)
+                    m_parentGroup.Scene.TriggerObjectChanged(LocalId, (uint)val);
             }
         }
 
-        public Vector3 GetSitTargetPosition()
-        {
-            return m_sitTargetPosition;
-        }
-
-        public Quaternion GetSitTargetOrientation()
-        {
-            return m_sitTargetOrientation;
-        }
-
-        public void SetAvatarOnSitTarget(LLUUID avatarID)
-        {
-            m_sitTargetAvatar = avatarID;
-            TriggerScriptChangedEvent(Changed.LINK);
-        }
-
-        public LLUUID GetAvatarOnSitTarget()
+        public void TrimPermissions()
         {
-            return m_sitTargetAvatar;
+            BaseMask &= (uint)PermissionMask.All;
+            OwnerMask &= (uint)PermissionMask.All;
+            GroupMask &= (uint)PermissionMask.All;
+            EveryoneMask &= (uint)PermissionMask.All;
+            NextOwnerMask &= (uint)PermissionMask.All;
         }
 
-        public LLUUID GetRootPartUUID()
+        public void Undo()
         {
-            if (m_parentGroup != null)
+            if (m_undo.Count > 0)
             {
-                return m_parentGroup.UUID;
+                UndoState goback = m_undo.Pop();
+                if (goback != null)
+                    goback.PlaybackState(this);
             }
-            return LLUUID.Zero;
-        }
-
-        public static SceneObjectPart Create()
-        {
-            SceneObjectPart part = new SceneObjectPart();
-            part.UUID = LLUUID.Random();
-
-            PrimitiveBaseShape shape = PrimitiveBaseShape.Create();
-            part.Shape = shape;
-
-            part.Name = "Primitive";
-            part.OwnerID = LLUUID.Random();
-
-            return part;
         }
 
-        #region Copying
-
-        /// <summary>
-        /// Duplicates this part.
-        /// </summary>
-        /// <returns></returns>
-        public SceneObjectPart Copy(uint localID, LLUUID AgentID, LLUUID GroupID, int linkNum, bool userExposed)
+        public void UpdateExtraParam(ushort type, bool inUse, byte[] data)
         {
-            SceneObjectPart dupe = (SceneObjectPart) MemberwiseClone();
-            dupe.m_shape = m_shape.Copy();
-            dupe.m_regionHandle = m_regionHandle;
-            if (userExposed)
-                dupe.UUID = LLUUID.Random();
-            
-            dupe.LocalId = localID;
-            dupe.OwnerID = AgentID;
-            dupe.GroupID = GroupID;
-            dupe.GroupPosition = new LLVector3(GroupPosition.X, GroupPosition.Y, GroupPosition.Z);
-            dupe.OffsetPosition = new LLVector3(OffsetPosition.X, OffsetPosition.Y, OffsetPosition.Z);
-            dupe.RotationOffset =
-                new LLQuaternion(RotationOffset.X, RotationOffset.Y, RotationOffset.Z, RotationOffset.W);
-            dupe.Velocity = new LLVector3(0, 0, 0);
-            dupe.Acceleration = new LLVector3(0, 0, 0);
-            dupe.AngularVelocity = new LLVector3(0, 0, 0);
-            dupe.ObjectFlags = ObjectFlags;
-
-            dupe.OwnershipCost = OwnershipCost;
-            dupe.ObjectSaleType = ObjectSaleType;
-            dupe.SalePrice = SalePrice;
-            dupe.Category = Category;
-
-            dupe.TaskInventory = (TaskInventoryDictionary)dupe.TaskInventory.Clone();
-
-            if (userExposed)
-                dupe.ResetIDs(linkNum);
-
-            // This may be wrong...    it might have to be applied in SceneObjectGroup to the object that's being duplicated.
-            dupe.LastOwnerID = ObjectOwner;
-
-            byte[] extraP = new byte[Shape.ExtraParams.Length];
-            Array.Copy(Shape.ExtraParams, extraP, extraP.Length);
-            dupe.Shape.ExtraParams = extraP;
+            m_shape.ReadInUpdateExtraParam(type, inUse, data);
 
-            if (userExposed)
+            if (type == 0x30)
             {
-                if (dupe.m_shape.SculptEntry && dupe.m_shape.SculptTexture != LLUUID.Zero)
+                if (m_shape.SculptEntry && m_shape.SculptTexture != LLUUID.Zero)
                 {
-                    m_parentGroup.Scene.AssetCache.GetAsset(dupe.m_shape.SculptTexture, dupe.SculptTextureCallback, true);
+                    //AssetBase tx = m_parentGroup.Scene.getase
+                    m_parentGroup.Scene.AssetCache.GetAsset(m_shape.SculptTexture, SculptTextureCallback, true);
                 }
-                bool UsePhysics = ((dupe.ObjectFlags & (uint)LLObject.ObjectFlags.Physics) != 0);
-                dupe.DoPhysicsPropertyUpdate(UsePhysics, true);
             }
-            return dupe;
-        }
 
-        #endregion
-
-        /// <summary>
-        /// Reset LLUUIDs for this part.  This involves generate this part's own LLUUID and
-        /// generating new LLUUIDs for all the items in the inventory.
-        /// </summary>
-        /// <param name="linkNum">Link number for the part</param>
-        public void ResetIDs(int linkNum)
-        {
-            UUID = LLUUID.Random();
-            LinkNum = linkNum;
-
-            ResetInventoryIDs();
-        }
-
-        #region Update Scheduling
-
-        /// <summary>
-        /// Clear all pending updates
-        /// </summary>
-        private void ClearUpdateSchedule()
-        {
-            m_updateFlag = 0;
-        }
-
-        /// <summary>
-        /// Schedules this prim for a full update
-        /// </summary>
-        public void ScheduleFullUpdate()
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.QueueForUpdateCheck();
-            }
-
-            int timeNow = Util.UnixTimeSinceEpoch();
-
-            // If multiple updates are scheduled on the same second, we still need to perform all of them
-            // So we'll force the issue by bumping up the timestamp so that later processing sees these need
-            // to be performed.
-            if (timeNow <= TimeStampFull)
-            {
-                TimeStampFull += 1;
-            }
-            else
-            {
-                TimeStampFull = (uint)timeNow;
-            }
-
-            m_updateFlag = 2;
-
-//            m_log.DebugFormat(
-//                "[SCENE OBJECT PART]: Scheduling full  update for {0}, {1} at {2}",
-//                UUID, Name, TimeStampFull);
+            ParentGroup.HasGroupChanged = true;
+            ScheduleFullUpdate();
         }
 
-        public void AddFlag(LLObject.ObjectFlags flag)
+        public void UpdateGroupPosition(LLVector3 pos)
         {
-            LLObject.ObjectFlags prevflag = Flags;
-            //uint objflags = Flags;
-            if ((ObjectFlags & (uint) flag) == 0)
+            if ((pos.X != GroupPosition.X) ||
+                (pos.Y != GroupPosition.Y) ||
+                (pos.Z != GroupPosition.Z))
             {
-                //Console.WriteLine("Adding flag: " + ((LLObject.ObjectFlags) flag).ToString());
-                Flags |= flag;
+                LLVector3 newPos = new LLVector3(pos.X, pos.Y, pos.Z);
+                GroupPosition = newPos;
+                ScheduleTerseUpdate();
             }
-            //uint currflag = (uint)Flags;
-            //System.Console.WriteLine("Aprev: " + prevflag.ToString() + " curr: " + Flags.ToString());
-            //ScheduleFullUpdate();
         }
 
-        public void RemFlag(LLObject.ObjectFlags flag)
+        public virtual void UpdateMovement()
         {
-            LLObject.ObjectFlags prevflag = Flags;
-            if ((ObjectFlags & (uint) flag) != 0)
-            {
-                //Console.WriteLine("Removing flag: " + ((LLObject.ObjectFlags)flag).ToString());
-                Flags &= ~flag;
-            }
-            //System.Console.WriteLine("prev: " + prevflag.ToString() + " curr: " + Flags.ToString());
-            //ScheduleFullUpdate();
         }
 
         /// <summary>
-        /// Schedule a terse update for this prim.  Terse updates only send position,
-        /// rotation, velocity, rotational velocity and shape information.
+        ///
         /// </summary>
-        public void ScheduleTerseUpdate()
+        /// <param name="pos"></param>
+        public void UpdateOffSet(LLVector3 pos)
         {
-            if (m_updateFlag < 1)
+            if ((pos.X != OffsetPosition.X) ||
+                (pos.Y != OffsetPosition.Y) ||
+                (pos.Z != OffsetPosition.Z))
             {
-                if (m_parentGroup != null)
-                {
-                    m_parentGroup.HasGroupChanged = true;
-                    m_parentGroup.QueueForUpdateCheck();
-                }
-                TimeStampTerse = (uint) Util.UnixTimeSinceEpoch();
-                m_updateFlag = 1;
-
-//                m_log.DebugFormat(
-//                    "[SCENE OBJECT PART]: Scheduling terse update for {0}, {1} at {2}",
-//                    UUID, Name, TimeStampTerse);
+                LLVector3 newPos = new LLVector3(pos.X, pos.Y, pos.Z);
+                OffsetPosition = newPos;
+                ScheduleTerseUpdate();
             }
         }
 
-        /// <summary>
-        /// Tell all the prims which have had updates scheduled
-        /// </summary>
-        public void SendScheduledUpdates()
+        public void UpdatePermissions(LLUUID AgentID, byte field, uint localID, uint mask, byte addRemTF)
         {
-            if (m_updateFlag == 1) //some change has been made so update the clients
-            {
-                AddTerseUpdateToAllAvatars();
-                ClearUpdateSchedule();
+            bool set = addRemTF == 1;
 
-                // This causes the Scene to 'poll' physical objects every couple of frames
-                // bad, so it's been replaced by an event driven method.
-                //if ((ObjectFlags & (uint)LLObject.ObjectFlags.Physics) != 0)
-                //{
-                // Only send the constant terse updates on physical objects!
-                //ScheduleTerseUpdate();
-                //}
-            }
-            else
+            // Are we the owner?
+            if (AgentID == OwnerID)
             {
-                if (m_updateFlag == 2) // is a new prim, just created/reloaded or has major changes
+                switch (field)
                 {
-                    AddFullUpdateToAllAvatars();
-                    ClearUpdateSchedule();
+                    case 2:
+                        OwnerMask = ApplyMask(OwnerMask, set, mask);
+                        break;
+                    case 4:
+                        GroupMask = ApplyMask(GroupMask, set, mask);
+                        break;
+                    case 8:
+                        EveryoneMask = ApplyMask(EveryoneMask, set, mask);
+                        break;
+                    case 16:
+                        NextOwnerMask = ApplyMask(NextOwnerMask, set, mask);
+                        break;
                 }
-            }
-        }
-
-        #endregion
+                SendFullUpdateToAllClients();
 
-        #region Shape
+                SendObjectPropertiesToClient(AgentID);
 
-        /// <summary>
-        /// Update the shape of this part.
-        /// </summary>
-        /// <param name="shapeBlock"></param>
-        public void UpdateShape(ObjectShapePacket.ObjectDataBlock shapeBlock)
-        {
-            m_shape.PathBegin = shapeBlock.PathBegin;
-            m_shape.PathEnd = shapeBlock.PathEnd;
-            m_shape.PathScaleX = shapeBlock.PathScaleX;
-            m_shape.PathScaleY = shapeBlock.PathScaleY;
-            m_shape.PathShearX = shapeBlock.PathShearX;
-            m_shape.PathShearY = shapeBlock.PathShearY;
-            m_shape.PathSkew = shapeBlock.PathSkew;
-            m_shape.ProfileBegin = shapeBlock.ProfileBegin;
-            m_shape.ProfileEnd = shapeBlock.ProfileEnd;
-            m_shape.PathCurve = shapeBlock.PathCurve;
-            m_shape.ProfileCurve = shapeBlock.ProfileCurve;
-            m_shape.ProfileHollow = shapeBlock.ProfileHollow;
-            m_shape.PathRadiusOffset = shapeBlock.PathRadiusOffset;
-            m_shape.PathRevolutions = shapeBlock.PathRevolutions;
-            m_shape.PathTaperX = shapeBlock.PathTaperX;
-            m_shape.PathTaperY = shapeBlock.PathTaperY;
-            m_shape.PathTwist = shapeBlock.PathTwist;
-            m_shape.PathTwistBegin = shapeBlock.PathTwistBegin;
-            if (PhysActor != null)
-            {
-                PhysActor.Shape = m_shape;
             }
-            
-            ParentGroup.HasGroupChanged = true;
-            ScheduleFullUpdate();
         }
 
-        #endregion
-
-        #region ExtraParams
-
         public void UpdatePrimFlags(ushort type, bool inUse, byte[] data)
         {
             //m_log.Info("TSomething1:" + ((type & (ushort)ExtraParamType.Something1) == (ushort)ExtraParamType.Something1));
@@ -1930,152 +2947,49 @@ namespace OpenSim.Region.Environment.Scenes
             ScheduleFullUpdate();
         }
 
-        public void ScriptSetPhysicsStatus(bool UsePhysics)
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.ScriptSetPhysicsStatus(UsePhysics);
-            }
-        }
-
-        public void ScriptSetPhantomStatus(bool Phantom)
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.ScriptSetPhantomStatus(Phantom);
-            }
-        }
-
-        public void DoPhysicsPropertyUpdate(bool UsePhysics, bool isNew)
-        {
-            if (PhysActor != null)
-            {
-                if (UsePhysics != PhysActor.IsPhysical || isNew)
-                {
-                    if (PhysActor.IsPhysical)
-                    {
-                        if (!isNew)
-                            ParentGroup.Scene.RemovePhysicalPrim(1);
-
-                        PhysActor.OnRequestTerseUpdate -= PhysicsRequestingTerseUpdate;
-                        PhysActor.OnOutOfBounds -= PhysicsOutOfBounds;
-                        PhysActor.delink();
-                    }
-
-                    PhysActor.IsPhysical = UsePhysics;
-
-
-                    // If we're not what we're supposed to be in the physics scene, recreate ourselves.
-                    //m_parentGroup.Scene.PhysicsScene.RemovePrim(PhysActor);
-                    /// that's not wholesome.  Had to make Scene public
-                    //PhysActor = null;
-
-                    if ((ObjectFlags & (uint) LLObject.ObjectFlags.Phantom) == 0)
-                    {
-                        //PhysActor = m_parentGroup.Scene.PhysicsScene.AddPrimShape(
-                        //Name,
-                        //Shape,
-                        //new PhysicsVector(AbsolutePosition.X, AbsolutePosition.Y,
-                        //AbsolutePosition.Z),
-                        //new PhysicsVector(Scale.X, Scale.Y, Scale.Z),
-                        //new Quaternion(RotationOffset.W, RotationOffset.X,
-                        //RotationOffset.Y, RotationOffset.Z), UsePhysics);
-                        if (UsePhysics)
-                        {
-                            ParentGroup.Scene.AddPhysicalPrim(1);
-
-                            PhysActor.OnRequestTerseUpdate += PhysicsRequestingTerseUpdate;
-                            PhysActor.OnOutOfBounds += PhysicsOutOfBounds;
-                            if (ParentID != 0 && ParentID != LocalId)
-                            {
-                                if (ParentGroup.RootPart.PhysActor != null)
-                                {
-                                    PhysActor.link(ParentGroup.RootPart.PhysActor);
-                                }
-                            }
-                        }
-                    }
-                }
-                m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
-            }
-        }
-
-        public void UpdateExtraParam(ushort type, bool inUse, byte[] data)
-        {
-            m_shape.ReadInUpdateExtraParam(type, inUse, data);
-            
-            if (type == 0x30)
-            {
-                if (m_shape.SculptEntry && m_shape.SculptTexture != LLUUID.Zero)
-                {
-                    //AssetBase tx = m_parentGroup.Scene.getase
-                    m_parentGroup.Scene.AssetCache.GetAsset(m_shape.SculptTexture, SculptTextureCallback, true);
-                }
-            }
-            
-            ParentGroup.HasGroupChanged = true;
-            ScheduleFullUpdate();
-        }
-        
-        public void SculptTextureCallback(LLUUID textureID, AssetBase texture)
-        {
-            if (m_shape.SculptEntry)
-            {
-                if (texture != null)
-                {
-                    m_shape.SculptData = texture.Data;
-                    if (PhysActor != null)
-                    {
-                        // Tricks physics engine into thinking we've changed the part shape.
-                        PrimitiveBaseShape m_newshape = m_shape.Copy();
-                        PhysActor.Shape = m_newshape;
-                        m_shape = m_newshape;
-                    }
-                }
-            }
-        }
-
-        #endregion
-
-        #region Physics
-
-        public float GetMass()
+        public void UpdateRotation(LLQuaternion rot)
         {
-            if (PhysActor != null)
-            {
-                return PhysActor.Mass;
-            }
-            else
+            if ((rot.X != RotationOffset.X) ||
+                (rot.Y != RotationOffset.Y) ||
+                (rot.Z != RotationOffset.Z) ||
+                (rot.W != RotationOffset.W))
             {
-                return 0;
+                //StoreUndoState();
+                RotationOffset = new LLQuaternion(rot.X, rot.Y, rot.Z, rot.W);
+                ParentGroup.HasGroupChanged = true;
+                ScheduleTerseUpdate();
             }
         }
 
-        public LLVector3 GetGeometricCenter()
+        /// <summary>
+        /// Update the shape of this part.
+        /// </summary>
+        /// <param name="shapeBlock"></param>
+        public void UpdateShape(ObjectShapePacket.ObjectDataBlock shapeBlock)
         {
+            m_shape.PathBegin = shapeBlock.PathBegin;
+            m_shape.PathEnd = shapeBlock.PathEnd;
+            m_shape.PathScaleX = shapeBlock.PathScaleX;
+            m_shape.PathScaleY = shapeBlock.PathScaleY;
+            m_shape.PathShearX = shapeBlock.PathShearX;
+            m_shape.PathShearY = shapeBlock.PathShearY;
+            m_shape.PathSkew = shapeBlock.PathSkew;
+            m_shape.ProfileBegin = shapeBlock.ProfileBegin;
+            m_shape.ProfileEnd = shapeBlock.ProfileEnd;
+            m_shape.PathCurve = shapeBlock.PathCurve;
+            m_shape.ProfileCurve = shapeBlock.ProfileCurve;
+            m_shape.ProfileHollow = shapeBlock.ProfileHollow;
+            m_shape.PathRadiusOffset = shapeBlock.PathRadiusOffset;
+            m_shape.PathRevolutions = shapeBlock.PathRevolutions;
+            m_shape.PathTaperX = shapeBlock.PathTaperX;
+            m_shape.PathTaperY = shapeBlock.PathTaperY;
+            m_shape.PathTwist = shapeBlock.PathTwist;
+            m_shape.PathTwistBegin = shapeBlock.PathTwistBegin;
             if (PhysActor != null)
             {
-                return new LLVector3(PhysActor.CenterOfMass.X, PhysActor.CenterOfMass.Y, PhysActor.CenterOfMass.Z);
-            }
-            else
-            {
-                return new LLVector3(0, 0, 0);
+                PhysActor.Shape = m_shape;
             }
-        }
-
-        #endregion
 
-        #region Texture
-
-        /// <summary>
-        /// Update the texture entry for this part.
-        /// </summary>
-        /// <param name="textureEntry"></param>
-        public void UpdateTextureEntry(byte[] textureEntry)
-        {
-            m_shape.TextureEntry = textureEntry;
-            TriggerScriptChangedEvent(Changed.TEXTURE);
-            
             ParentGroup.HasGroupChanged = true;
             ScheduleFullUpdate();
         }
@@ -2107,684 +3021,19 @@ namespace OpenSim.Region.Environment.Scenes
             UpdateTextureEntry(tex.ToBytes());
         }
 
-        public byte ConvertScriptUintToByte(uint indata)
-        {
-            byte outdata = (byte)TextureAnimFlags.NONE;
-            if ((indata & 1) != 0) outdata |= (byte)TextureAnimFlags.ANIM_ON;
-            if ((indata & 2) != 0) outdata |= (byte)TextureAnimFlags.LOOP;
-            if ((indata & 4) != 0) outdata |= (byte)TextureAnimFlags.REVERSE;
-            if ((indata & 8) != 0) outdata |= (byte)TextureAnimFlags.PING_PONG;
-            if ((indata & 16) != 0) outdata |= (byte)TextureAnimFlags.SMOOTH;
-            if ((indata & 32) != 0) outdata |= (byte)TextureAnimFlags.ROTATE;
-            if ((indata & 64) != 0) outdata |= (byte)TextureAnimFlags.SCALE;
-            return outdata;
-        }
-
-        public void AddTextureAnimation(Primitive.TextureAnimation pTexAnim)
-        {
-            byte[] data = new byte[16];
-            int pos = 0;
-
-            // The flags don't like conversion from uint to byte, so we have to do
-            // it the crappy way.  See the above function :(
-
-            data[pos] = ConvertScriptUintToByte(pTexAnim.Flags); pos++;
-            data[pos] = (byte)pTexAnim.Face; pos++;
-            data[pos] = (byte)pTexAnim.SizeX; pos++;
-            data[pos] = (byte)pTexAnim.SizeY; pos++;
-
-            Helpers.FloatToBytes(pTexAnim.Start).CopyTo(data, pos);
-            Helpers.FloatToBytes(pTexAnim.Length).CopyTo(data, pos + 4);
-            Helpers.FloatToBytes(pTexAnim.Rate).CopyTo(data, pos + 8);
-
-            m_TextureAnimation = data;
-        }
-
-        #endregion
-
-        #region ParticleSystem
-
-        public void AddNewParticleSystem(Primitive.ParticleSystem pSystem)
-        {
-            m_particleSystem = pSystem.GetBytes();
-        }
-
-        #endregion
-
-        #region Position
-
         /// <summary>
-        ///
-        /// </summary>
-        /// <param name="pos"></param>
-        public void UpdateOffSet(LLVector3 pos)
-        {
-            if ((pos.X != OffsetPosition.X) ||
-                (pos.Y != OffsetPosition.Y) ||
-                (pos.Z != OffsetPosition.Z))
-            {
-                LLVector3 newPos = new LLVector3(pos.X, pos.Y, pos.Z);
-                OffsetPosition = newPos;
-                ScheduleTerseUpdate();
-            }
-        }
-
-        public void UpdateGroupPosition(LLVector3 pos)
-        {
-            if ((pos.X != GroupPosition.X) ||
-                (pos.Y != GroupPosition.Y) ||
-                (pos.Z != GroupPosition.Z))
-            {
-                LLVector3 newPos = new LLVector3(pos.X, pos.Y, pos.Z);
-                GroupPosition = newPos;
-                ScheduleTerseUpdate();
-            }
-        }
-
-        #endregion
-
-        #region rotation
-
-        public void UpdateRotation(LLQuaternion rot)
-        {
-            if ((rot.X != RotationOffset.X) ||
-                (rot.Y != RotationOffset.Y) ||
-                (rot.Z != RotationOffset.Z) ||
-                (rot.W != RotationOffset.W))
-            {
-                //StoreUndoState();
-                RotationOffset = new LLQuaternion(rot.X, rot.Y, rot.Z, rot.W);
-                ParentGroup.HasGroupChanged = true;
-                ScheduleTerseUpdate();
-            }
-        }
-
-        #endregion
-
-        #region Sound
-        public void PreloadSound(string sound)
-        {
-            LLUUID ownerID = OwnerID;
-            LLUUID objectID = UUID;
-            LLUUID soundID = LLUUID.Zero;
-
-            if (!LLUUID.TryParse(sound, out soundID))
-            {
-                //Trys to fetch sound id from prim's inventory.
-                //Prim's inventory doesn't support non script items yet
-                SceneObjectPart op = this;
-                foreach (KeyValuePair<LLUUID, TaskInventoryItem> item in op.TaskInventory)
-                {
-                    if (item.Value.Name == sound)
-                    {
-                        soundID = item.Value.ItemID;
-                        break;
-                    }
-                }
-            }
-
-            List<ScenePresence> avatarts = m_parentGroup.Scene.GetAvatars();
-            foreach (ScenePresence p in avatarts)
-            {
-                // TODO: some filtering by distance of avatar
-
-                p.ControllingClient.SendPreLoadSound(objectID, objectID, soundID);
-            }
-        }
-
-        public void AdjustSoundGain(double volume)
-        {
-            if (volume > 1)
-                volume = 1;
-            if (volume < 0)
-                volume = 0;
-
-            List<ScenePresence> avatarts = m_parentGroup.Scene.GetAvatars();
-            foreach (ScenePresence p in avatarts)
-            {
-                p.ControllingClient.SendAttachedSoundGainChange(UUID, (float)volume);
-            }
-        }
-
-        public void SendSound(string sound, double volume, bool triggered, byte flags)
-        {
-            if (volume > 1)
-                volume = 1;
-            if (volume < 0)
-                volume = 0;
-
-            LLUUID ownerID = OwnerID;
-            LLUUID objectID = UUID;
-            LLUUID parentID = GetRootPartUUID();
-            LLUUID soundID = LLUUID.Zero;
-            LLVector3 position = AbsolutePosition; // region local
-            ulong regionHandle = m_parentGroup.Scene.RegionInfo.RegionHandle;
-
-            //byte flags = 0;
-
-            if (!LLUUID.TryParse(sound, out soundID))
-            {
-                // search sound file from inventory
-                SceneObjectPart op = this;
-                foreach (KeyValuePair<LLUUID, TaskInventoryItem> item in op.TaskInventory)
-                {
-                    if (item.Value.Name == sound && item.Value.Type == (int)AssetType.Sound)
-                    {
-                        soundID = item.Value.ItemID;
-                        break;
-                    }
-                }
-            }
-
-            if (soundID == LLUUID.Zero)
-                return;
-
-            List<ScenePresence> avatarts = m_parentGroup.Scene.GetAvatars();
-            foreach (ScenePresence p in avatarts)
-            {
-                double dis=Util.GetDistanceTo(p.AbsolutePosition, position);
-                if (dis > 100.0) // Max audio distance
-                    continue;
-
-                // Scale by distance
-                volume*=((100.0-dis)/100.0);
-
-                if (triggered)
-                {
-                    p.ControllingClient.SendTriggeredSound(soundID, ownerID, objectID, parentID, regionHandle, position, (float)volume);
-                }
-                else
-                {
-                    p.ControllingClient.SendPlayAttachedSound(soundID, objectID, ownerID, (float)volume, flags);
-                }
-            }
-        }
-
-        #endregion
-
-        #region Resizing/Scale
-
-        /// <summary>
-        /// Resize this part.
-        /// </summary>
-        /// <param name="scale"></param>
-        public void Resize(LLVector3 scale)
-        {
-            StoreUndoState();
-            m_shape.Scale = scale;
-
-            ParentGroup.HasGroupChanged = true;
-            ScheduleFullUpdate();
-        }
-
-        #endregion
-
-        public void UpdatePermissions(LLUUID AgentID, byte field, uint localID, uint mask, byte addRemTF)
-        {
-            bool set = addRemTF == 1;
-
-            // Are we the owner?
-            if (AgentID == OwnerID)
-            {
-                switch (field)
-                {
-                    case 2:
-                        OwnerMask = ApplyMask(OwnerMask, set, mask);
-                        break;
-                    case 4:
-                        GroupMask = ApplyMask(GroupMask, set, mask);
-                        break;
-                    case 8:
-                        EveryoneMask = ApplyMask(EveryoneMask, set, mask);
-                        break;
-                    case 16:
-                        NextOwnerMask = ApplyMask(NextOwnerMask, set, mask);
-                        break;
-                }
-                SendFullUpdateToAllClients();
-
-                SendObjectPropertiesToClient(AgentID);
-
-            }
-        }
-
-        private void SendObjectPropertiesToClient(LLUUID AgentID)
-        {
-            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
-            for (int i = 0; i < avatars.Count; i++)
-            {
-                // Ugly reference :(
-                if (avatars[i].UUID == AgentID)
-                {
-                    m_parentGroup.GetProperties(avatars[i].ControllingClient);
-                }
-            }
-        }
-
-        private uint ApplyMask(uint val, bool set, uint mask)
-        {
-            if (set)
-            {
-                return val |= mask;
-            }
-            else
-            {
-                return val &= ~mask;
-            }
-        }
-
-        #region Client Update Methods
-
-        /// <summary>
-        /// Tell all scene presences that they should send updates for this part to their clients
-        /// </summary>
-        public void AddFullUpdateToAllAvatars()
-        {
-            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
-            for (int i = 0; i < avatars.Count; i++)
-            {
-                avatars[i].QueuePartForUpdate(this);
-            }
-        }
-
-        public void SendFullUpdateToAllClientsExcept(LLUUID agentID)
-        {
-            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
-            for (int i = 0; i < avatars.Count; i++)
-            {
-                // Ugly reference :(
-                if (avatars[i].UUID != agentID)
-                {
-                    m_parentGroup.SendPartFullUpdate(avatars[i].ControllingClient, this,
-                                                    avatars[i].GenerateClientFlags(UUID));
-                }
-            }
-        }
-
-        public void AddFullUpdateToAvatar(ScenePresence presence)
-        {
-            presence.QueuePartForUpdate(this);
-        }
-
-        /// <summary>
-        ///
-        /// </summary>
-        public void SendFullUpdateToAllClients()
-        {
-            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
-            for (int i = 0; i < avatars.Count; i++)
-            {
-                // Ugly reference :(
-                m_parentGroup.SendPartFullUpdate(avatars[i].ControllingClient, this,
-                                                 avatars[i].GenerateClientFlags(UUID));
-            }
-        }
-
-        /// <summary>
-        ///
-        /// </summary>
-        /// <param name="remoteClient"></param>
-        public void SendFullUpdate(IClientAPI remoteClient, uint clientFlags)
-        {
-            m_parentGroup.SendPartFullUpdate(remoteClient, this, clientFlags);
-        }
-
-        /// <summary>
-        /// Sends a full update to the client
-        /// </summary>
-        /// <param name="remoteClient"></param>
-        /// <param name="clientFlags"></param>
-        public void SendFullUpdateToClient(IClientAPI remoteClient, uint clientflags)
-        {
-            LLVector3 lPos;
-            lPos = OffsetPosition;
-            SendFullUpdateToClient(remoteClient, lPos, clientflags);
-        }
-
-        /// <summary>
-        /// Sends a full update to the client
-        /// </summary>
-        /// <param name="remoteClient"></param>
-        /// <param name="lPos"></param>
-        /// <param name="clientFlags"></param>
-        public void SendFullUpdateToClient(IClientAPI remoteClient, LLVector3 lPos, uint clientFlags)
-        {
-            clientFlags &= ~(uint) LLObject.ObjectFlags.CreateSelected;
-
-            if (remoteClient.AgentId == OwnerID)
-            {
-                if ((uint) (Flags & LLObject.ObjectFlags.CreateSelected) != 0)
-                {
-                    clientFlags |= (uint) LLObject.ObjectFlags.CreateSelected;
-                    Flags &= ~LLObject.ObjectFlags.CreateSelected;
-                }
-            }
-
-            byte[] color = new byte[] {m_color.R, m_color.G, m_color.B, m_color.A};
-            remoteClient.SendPrimitiveToClient(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, m_shape,
-                                               lPos, Velocity, Acceleration, RotationOffset, RotationalVelocity, clientFlags, m_uuid, OwnerID,
-                                               m_text, color, ParentID, m_particleSystem, m_clickAction, m_TextureAnimation, m_IsAttachment,
-                                               m_attachmentPoint,fromAssetID, Sound, SoundGain, SoundFlags, SoundRadius);
-        }
-
-        /// Terse updates
-        public void AddTerseUpdateToAllAvatars()
-        {
-            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
-            for (int i = 0; i < avatars.Count; i++)
-            {
-                avatars[i].QueuePartForUpdate(this);
-            }
-        }
-
-        public void AddTerseUpdateToAvatar(ScenePresence presence)
-        {
-            presence.QueuePartForUpdate(this);
-        }
-
-        /// <summary>
-        ///
-        /// </summary>
-        public void SendTerseUpdateToAllClients()
-        {
-            List<ScenePresence> avatars = m_parentGroup.Scene.GetScenePresences();
-            for (int i = 0; i < avatars.Count; i++)
-            {
-                m_parentGroup.SendPartTerseUpdate(avatars[i].ControllingClient, this);
-            }
-        }
-
-        /// <summary>
-        /// Send a terse update to the client.
+        /// Update the texture entry for this part.
         /// </summary>
-        /// <param name="remoteClient"></param>
-        public void SendTerseUpdate(IClientAPI remoteClient)
-        {
-            m_parentGroup.SendPartTerseUpdate(remoteClient, this);
-        }
-
-        public void SendTerseUpdateToClient(IClientAPI remoteClient)
-        {
-            LLVector3 lPos;
-            lPos = OffsetPosition;
-            LLQuaternion mRot = RotationOffset;
-            // TODO: I have no idea why we are making this check.  This should be sorted out
-            if ((ObjectFlags & (uint) LLObject.ObjectFlags.Physics) == 0)
-            {
-                remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity, RotationalVelocity, Shape.State, fromAssetID);
-            }
-            else
-            {
-                remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity,
-                                                 RotationalVelocity);
-                //System.Console.WriteLine("LID: " + LocalID + " RVel:" + RotationalVelocity.ToString() + " TD: " + ((ushort)(m_parentGroup.Scene.TimeDilation * 500000f)).ToString() + ":" + m_parentGroup.Scene.TimeDilation.ToString());
-            }
-        }
-
-        public void SendTerseUpdateToClient(IClientAPI remoteClient, LLVector3 lPos)
-        {
-            LLQuaternion mRot = RotationOffset;
-            if (m_IsAttachment)
-            {
-                remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity, RotationalVelocity, (byte)((m_attachmentPoint % 16) * 16 + (m_attachmentPoint / 16)),fromAssetID);
-            }
-            else
-            {
-                if ((ObjectFlags & (uint)LLObject.ObjectFlags.Physics) == 0)
-                {
-                    remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity, RotationalVelocity, Shape.State, fromAssetID);
-                }
-                else
-                {
-                    remoteClient.SendPrimTerseUpdate(m_regionHandle, (ushort)(m_parentGroup.GetTimeDilation() * (float)ushort.MaxValue), LocalId, lPos, mRot, Velocity,
-                                                     RotationalVelocity);
-                    //System.Console.WriteLine("LID: " + LocalID + "RVel:" + RotationalVelocity.ToString() + " TD: " + ((ushort)(m_parentGroup.Scene.TimeDilation * 500000f)).ToString() + ":" + m_parentGroup.Scene.TimeDilation.ToString());
-                }
-            }
-        }
-
-        #endregion
-
-        public virtual void UpdateMovement()
-        {
-        }
-
-        #region Events
-
-        public void PhysicsRequestingTerseUpdate()
-        {
-            if (PhysActor != null)
-            {
-                LLVector3 newpos = new LLVector3(PhysActor.Position.GetBytes(), 0);
-                if (newpos.X > 257f || newpos.X < -1f || newpos.Y > 257f || newpos.Y < -1f)
-                {
-                    m_parentGroup.AbsolutePosition = newpos;
-                    return;
-                }
-            }
-            ScheduleTerseUpdate();
-
-            //SendTerseUpdateToAllClients();
-        }
-
-        #endregion
-
-        public void PhysicsOutOfBounds(PhysicsVector pos)
-        {
-            m_log.Info("[PHYSICS]: Physical Object went out of bounds.");
-            RemFlag(LLObject.ObjectFlags.Physics);
-            DoPhysicsPropertyUpdate(false, true);
-            //m_parentGroup.Scene.PhysicsScene.AddPhysicsActorTaint(PhysActor);
-        }
-
-        public virtual void OnGrab(LLVector3 offsetPos, IClientAPI remoteClient)
+        /// <param name="textureEntry"></param>
+        public void UpdateTextureEntry(byte[] textureEntry)
         {
-        }
+            m_shape.TextureEntry = textureEntry;
+            TriggerScriptChangedEvent(Changed.TEXTURE);
 
-        /// <summary>
-        /// Set the text displayed for this part.
-        /// </summary>
-        /// <param name="text"></param>
-        public void SetText(string text)
-        {
-            Text = text;
-            
             ParentGroup.HasGroupChanged = true;
             ScheduleFullUpdate();
         }
 
-        /// <summary>
-        /// Set the text displayed for this part.
-        /// </summary>
-        /// <param name="text"></param>
-        /// <param name="color"></param>
-        /// <param name="alpha"></param>
-        public void SetText(string text, Vector3 color, double alpha)
-        {
-            Color = Color.FromArgb(0xff - (int) (alpha*0xff),
-                                   (int) (color.x*0xff),
-                                   (int) (color.y*0xff),
-                                   (int) (color.z*0xff));
-            SetText(text);
-        }
-
-        public int registerTargetWaypoint(LLVector3 target, float tolerance)
-        {
-            if (m_parentGroup != null)
-            {
-                return m_parentGroup.registerTargetWaypoint(target, tolerance);
-            }
-            return 0;
-        }
-        public void unregisterTargetWaypoint(int handle)
-        {
-            if (m_parentGroup != null)
-            {
-                m_parentGroup.unregisterTargetWaypoint(handle);
-            }
-        }
-        protected SceneObjectPart(SerializationInfo info, StreamingContext context)
-        {
-            //System.Console.WriteLine("SceneObjectPart Deserialize BGN");
-
-            if (info == null)
-            {
-                throw new ArgumentNullException("info");
-            }
-
-            /*
-            m_queue = (Queue<SceneObjectPart>)info.GetValue("m_queue", typeof(Queue<SceneObjectPart>));
-            m_ids = (List<LLUUID>)info.GetValue("m_ids", typeof(List<LLUUID>));
-            */
-
-            //System.Console.WriteLine("SceneObjectPart Deserialize END");
-        }
-
-        [SecurityPermission(SecurityAction.LinkDemand,
-            Flags = SecurityPermissionFlag.SerializationFormatter)]
-        public virtual void GetObjectData(
-                        SerializationInfo info, StreamingContext context)
-        {
-            if (info == null)
-            {
-                throw new ArgumentNullException("info");
-            }
-
-            info.AddValue("m_inventoryFileName", GetInventoryFileName());
-            info.AddValue("m_folderID", UUID);
-            info.AddValue("PhysActor", PhysActor);
-
-            Dictionary<Guid, TaskInventoryItem> TaskInventory_work = new Dictionary<Guid, TaskInventoryItem>();
-
-            foreach (LLUUID id in TaskInventory.Keys)
-            {
-                TaskInventory_work.Add(id.UUID, TaskInventory[id]);
-            }
-
-            info.AddValue("TaskInventory", TaskInventory_work);
-
-            info.AddValue("LastOwnerID", LastOwnerID.UUID);
-            info.AddValue("OwnerID", OwnerID.UUID);
-            info.AddValue("GroupID", GroupID.UUID);
-
-            info.AddValue("OwnershipCost", OwnershipCost);
-            info.AddValue("ObjectSaleType", ObjectSaleType);
-            info.AddValue("SalePrice", SalePrice);
-            info.AddValue("Category", Category);
-
-            info.AddValue("CreationDate", CreationDate);
-            info.AddValue("ParentID", ParentID);
-
-            info.AddValue("OwnerMask", OwnerMask);
-            info.AddValue("NextOwnerMask", NextOwnerMask);
-            info.AddValue("GroupMask", GroupMask);
-            info.AddValue("EveryoneMask", EveryoneMask);
-            info.AddValue("BaseMask", BaseMask);
-
-            info.AddValue("m_particleSystem", m_particleSystem);
-
-            info.AddValue("TimeStampFull", TimeStampFull);
-            info.AddValue("TimeStampTerse", TimeStampTerse);
-            info.AddValue("TimeStampLastActivity", TimeStampLastActivity);
-
-            info.AddValue("m_updateFlag", m_updateFlag);
-            info.AddValue("CreatorID", CreatorID.UUID);
-
-            info.AddValue("m_inventorySerial", m_inventorySerial);
-            info.AddValue("m_uuid", m_uuid.UUID);
-            info.AddValue("m_localID", m_localId);
-            info.AddValue("m_name", m_name);
-            info.AddValue("m_flags", Flags);
-            info.AddValue("m_material", m_material);
-            info.AddValue("m_regionHandle", m_regionHandle);
-
-            info.AddValue("m_groupPosition.X", m_groupPosition.X);
-            info.AddValue("m_groupPosition.Y", m_groupPosition.Y);
-            info.AddValue("m_groupPosition.Z", m_groupPosition.Z);
-
-            info.AddValue("m_offsetPosition.X", m_offsetPosition.X);
-            info.AddValue("m_offsetPosition.Y", m_offsetPosition.Y);
-            info.AddValue("m_offsetPosition.Z", m_offsetPosition.Z);
-
-            info.AddValue("m_rotationOffset.W", m_rotationOffset.W);
-            info.AddValue("m_rotationOffset.X", m_rotationOffset.X);
-            info.AddValue("m_rotationOffset.Y", m_rotationOffset.Y);
-            info.AddValue("m_rotationOffset.Z", m_rotationOffset.Z);
-
-            info.AddValue("m_velocity.X", m_velocity.X);
-            info.AddValue("m_velocity.Y", m_velocity.Y);
-            info.AddValue("m_velocity.Z", m_velocity.Z);
-
-            info.AddValue("m_rotationalvelocity.X", m_rotationalvelocity.X);
-            info.AddValue("m_rotationalvelocity.Y", m_rotationalvelocity.Y);
-            info.AddValue("m_rotationalvelocity.Z", m_rotationalvelocity.Z);
-
-            info.AddValue("m_angularVelocity.X", m_angularVelocity.X);
-            info.AddValue("m_angularVelocity.Y", m_angularVelocity.Y);
-            info.AddValue("m_angularVelocity.Z", m_angularVelocity.Z);
-
-            info.AddValue("m_acceleration.X", m_acceleration.X);
-            info.AddValue("m_acceleration.Y", m_acceleration.Y);
-            info.AddValue("m_acceleration.Z", m_acceleration.Z);
-
-            info.AddValue("m_description", m_description);
-            info.AddValue("m_color", m_color);
-            info.AddValue("m_text", m_text);
-            info.AddValue("m_sitName", m_sitName);
-            info.AddValue("m_touchName", m_touchName);
-            info.AddValue("m_clickAction", m_clickAction);
-            info.AddValue("m_shape", m_shape);
-            info.AddValue("m_parentGroup", m_parentGroup);
-            info.AddValue("PayPrice", PayPrice);
-        }
-
-        public void Undo()
-        {
-            if (m_undo.Count > 0)
-            {
-                UndoState goback = m_undo.Pop();
-                if (goback != null)
-                    goback.PlaybackState(this);
-            }
-        }
-
-        public void SetScriptEvents(LLUUID scriptid, int events)
-        {
-            scriptEvents oldparts;
-            lock (m_scriptEvents)
-            {
-                if (m_scriptEvents.ContainsKey(scriptid))
-                {
-                    oldparts = m_scriptEvents[scriptid];
-
-                    // remove values from aggregated script events
-                    m_scriptEvents[scriptid] = (scriptEvents) events;
-                }
-                else
-                {
-                    m_scriptEvents.Add(scriptid, (scriptEvents) events);
-                }
-            }
-            aggregateScriptEvents();
-        }
-
-        public void RemoveScriptEvents(LLUUID scriptid)
-        {
-            lock (m_scriptEvents)
-            {
-                if (m_scriptEvents.ContainsKey(scriptid))
-                {
-                    scriptEvents oldparts = scriptEvents.None;
-                    oldparts = (scriptEvents) m_scriptEvents[scriptid];
-
-                    // remove values from aggregated script events
-                    m_aggregateScriptEvents &= ~oldparts;
-                    m_scriptEvents.Remove(scriptid);
-                }
-            }
-            aggregateScriptEvents();
-        }
-
         public void aggregateScriptEvents()
         {
             // Aggregate script events
@@ -2856,325 +3105,23 @@ namespace OpenSim.Region.Environment.Scenes
                 ScheduleFullUpdate();
         }
 
-        public void PhysicsCollision(EventArgs e)
+        public int registerTargetWaypoint(LLVector3 target, float tolerance)
         {
-            // single threaded here
-            if (e == null)
-            {
-                return;
-            }
-            
-            CollisionEventUpdate a = (CollisionEventUpdate)e;
-            Dictionary<uint, float> collissionswith = a.m_objCollisionList;
-            List<uint> thisHitColliders = new List<uint>();
-            List<uint> endedColliders = new List<uint>();
-            List<uint> startedColliders = new List<uint>();
-
-            // calculate things that started colliding this time
-            // and build up list of colliders this time
-            foreach (uint localid in collissionswith.Keys)
-            {
-                if (localid != 0)
-                {
-                    thisHitColliders.Add(localid);
-                    if (!m_lastColliders.Contains(localid))
-                    {
-                        startedColliders.Add(localid);
-                    }
-
-                    //m_log.Debug("[OBJECT]: Collided with:" + localid.ToString() + " at depth of: " + collissionswith[localid].ToString());
-                }
-            }
-
-            // calculate things that ended colliding
-            foreach (uint localID in m_lastColliders)
-            {
-                if (!thisHitColliders.Contains(localID))
-                {
-                    endedColliders.Add(localID);
-                }
-            }
-
-            //add the items that started colliding this time to the last colliders list.
-            foreach (uint localID in startedColliders)
-            {
-                m_lastColliders.Add(localID);
-            }
-            // remove things that ended colliding from the last colliders list
-            foreach (uint localID in endedColliders)
-            {
-                m_lastColliders.Remove(localID);
-            }
-            if (m_parentGroup == null)
-                return;
-            if (m_parentGroup.RootPart == null)
-                return;
-
-            if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.collision_start) != 0)
-            {
-                // do event notification
-                if (startedColliders.Count > 0)
-                {
-                    ColliderArgs StartCollidingMessage = new ColliderArgs();
-                    List<DetectedObject> colliding = new List<DetectedObject>();
-                    foreach (uint localId in startedColliders)
-                    {
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
-                        if (m_parentGroup.Scene == null)
-                            return;
-                        SceneObjectPart obj = m_parentGroup.Scene.GetSceneObjectPart(localId);
-                        if (obj != null)
-                        {
-                            DetectedObject detobj = new DetectedObject();
-                            detobj.keyUUID = obj.UUID;
-                            detobj.nameStr = obj.Name;
-                            detobj.ownerUUID = obj.OwnerID;
-                            detobj.posVector = obj.AbsolutePosition;
-                            detobj.rotQuat = obj.GetWorldRotation();
-                            detobj.velVector = obj.Velocity;
-                            detobj.colliderType = 0;
-                            detobj.groupUUID = obj.GroupID;
-                            colliding.Add(detobj);
-                        }
-                        else
-                        {
-                            List<ScenePresence> avlist = m_parentGroup.Scene.GetScenePresences();
-                            if (avlist != null)
-                            {
-                                foreach (ScenePresence av in avlist)
-                                {
-                                    if (av.LocalId == localId)
-                                    {
-                                        DetectedObject detobj = new DetectedObject();
-                                        detobj.keyUUID = av.UUID;
-                                        detobj.nameStr = av.ControllingClient.Name;
-                                        detobj.ownerUUID = av.UUID;
-                                        detobj.posVector = av.AbsolutePosition;
-                                        detobj.rotQuat = new LLQuaternion(av.Rotation.x, av.Rotation.y, av.Rotation.z, av.Rotation.w);
-                                        detobj.velVector = av.Velocity;
-                                        detobj.colliderType = 0;
-                                        detobj.groupUUID = av.ControllingClient.ActiveGroupId;
-                                        colliding.Add(detobj);
-                                    }
-                                }
-                            }
-                        }
-                    }
-                    if (colliding.Count > 0)
-                    {
-                        StartCollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
-                        if (m_parentGroup.Scene == null)
-                            return;
-                        m_parentGroup.Scene.EventManager.TriggerScriptCollidingStart(LocalId, StartCollidingMessage);
-                    }
-                }
-            }
-            if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.collision) != 0)
-            {
-                if (m_lastColliders.Count > 0)
-                {
-                    ColliderArgs CollidingMessage = new ColliderArgs();
-                    List<DetectedObject> colliding = new List<DetectedObject>();
-                    foreach (uint localId in m_lastColliders)
-                    {
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (localId == 0)
-                            continue;
-
-                        if (m_parentGroup == null)
-                            return;
-                        if (m_parentGroup.Scene == null)
-                            return;
-                        SceneObjectPart obj = m_parentGroup.Scene.GetSceneObjectPart(localId);
-                        if (obj != null)
-                        {
-                            DetectedObject detobj = new DetectedObject();
-                            detobj.keyUUID = obj.UUID;
-                            detobj.nameStr = obj.Name;
-                            detobj.ownerUUID = obj.OwnerID;
-                            detobj.posVector = obj.AbsolutePosition;
-                            detobj.rotQuat = obj.GetWorldRotation();
-                            detobj.velVector = obj.Velocity;
-                            detobj.colliderType = 0;
-                            detobj.groupUUID = obj.GroupID;
-                            colliding.Add(detobj);
-                        }
-                        else
-                        {
-                            List<ScenePresence> avlist = m_parentGroup.Scene.GetScenePresences();
-                            if (avlist != null)
-                            {
-                                foreach (ScenePresence av in avlist)
-                                {
-                                    if (av.LocalId == localId)
-                                    {
-                                        DetectedObject detobj = new DetectedObject();
-                                        detobj.keyUUID = av.UUID;
-                                        detobj.nameStr = av.Name;
-                                        detobj.ownerUUID = av.UUID;
-                                        detobj.posVector = av.AbsolutePosition;
-                                        detobj.rotQuat = new LLQuaternion(av.Rotation.x, av.Rotation.y, av.Rotation.z, av.Rotation.w);
-                                        detobj.velVector = av.Velocity;
-                                        detobj.colliderType = 0;
-                                        detobj.groupUUID = av.ControllingClient.ActiveGroupId;
-                                        colliding.Add(detobj);
-                                    }
-                                }
-
-                            }
-                        }
-                    }
-                    if (colliding.Count > 0)
-                    {
-                        CollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
-                        if (m_parentGroup.Scene == null)
-                            return;
-                        m_parentGroup.Scene.EventManager.TriggerScriptColliding(LocalId, CollidingMessage);
-                    }
-
-                }
-            }
-            if ((m_parentGroup.RootPart.ScriptEvents & scriptEvents.collision_end) != 0)
+            if (m_parentGroup != null)
             {
-                if (endedColliders.Count > 0)
-                {
-                    ColliderArgs EndCollidingMessage = new ColliderArgs();
-                    List<DetectedObject> colliding = new List<DetectedObject>();
-                    foreach (uint localId in endedColliders)
-                    {
-                        if (localId == 0)
-                            continue;
-
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
-                        if (m_parentGroup.Scene == null)
-                            return;
-                        SceneObjectPart obj = m_parentGroup.Scene.GetSceneObjectPart(localId);
-                        if (obj != null)
-                        {
-                            DetectedObject detobj = new DetectedObject();
-                            detobj.keyUUID = obj.UUID;
-                            detobj.nameStr = obj.Name;
-                            detobj.ownerUUID = obj.OwnerID;
-                            detobj.posVector = obj.AbsolutePosition;
-                            detobj.rotQuat = obj.GetWorldRotation();
-                            detobj.velVector = obj.Velocity;
-                            detobj.colliderType = 0;
-                            detobj.groupUUID = obj.GroupID;
-                            colliding.Add(detobj);
-                        }
-                        else
-                        {
-                            List<ScenePresence> avlist = m_parentGroup.Scene.GetScenePresences();
-                            if (avlist != null)
-                            {
-                                foreach (ScenePresence av in avlist)
-                                {
-                                    if (av.LocalId == localId)
-                                    {
-                                        DetectedObject detobj = new DetectedObject();
-                                        detobj.keyUUID = av.UUID;
-                                        detobj.nameStr = av.Name;
-                                        detobj.ownerUUID = av.UUID;
-                                        detobj.posVector = av.AbsolutePosition;
-                                        detobj.rotQuat = new LLQuaternion(av.Rotation.x, av.Rotation.y, av.Rotation.z, av.Rotation.w);
-                                        detobj.velVector = av.Velocity;
-                                        detobj.colliderType = 0;
-                                        detobj.groupUUID = av.ControllingClient.ActiveGroupId;
-                                        colliding.Add(detobj);
-                                    }
-                                }
-
-                            }
-                        }
-                    }
-                    if (colliding.Count > 0)
-                    {
-                        EndCollidingMessage.Colliders = colliding;
-                        // always running this check because if the user deletes the object it would return a null reference.
-                        if (m_parentGroup == null)
-                            return;
-                        if (m_parentGroup.Scene == null)
-                            return;
-                        m_parentGroup.Scene.EventManager.TriggerScriptCollidingEnd(LocalId, EndCollidingMessage);
-                    }
-
-                }
+                return m_parentGroup.registerTargetWaypoint(target, tolerance);
             }
+            return 0;
         }
 
-
-
-        public void SetDieAtEdge(bool p)
-        {
-            if (m_parentGroup == null)
-                return;
-            if (m_parentGroup.RootPart == null)
-                return;
-
-            m_parentGroup.RootPart.DIE_AT_EDGE = p;
-        }
-        public bool GetDieAtEdge()
-        {
-            if (m_parentGroup == null)
-                return false;
-            if (m_parentGroup.RootPart == null)
-                return false;
-
-            return m_parentGroup.RootPart.DIE_AT_EDGE;
-        }
-
-        public void GetProperties(IClientAPI client)
-        {
-
-            client.SendObjectPropertiesReply(LLUUID.Zero, (ulong)CreationDate, CreatorID, LLUUID.Zero, LLUUID.Zero,
-                                               GroupID, (short)InventorySerial, LastOwnerID, UUID, OwnerID,
-                                               ParentGroup.RootPart.TouchName, new byte[0], ParentGroup.RootPart.SitName, Name, Description,
-                                               ParentGroup.RootPart.OwnerMask, ParentGroup.RootPart.NextOwnerMask, ParentGroup.RootPart.GroupMask, ParentGroup.RootPart.EveryoneMask,
-                                               ParentGroup.RootPart.BaseMask);
-
-        }
-        
-        public void SetGroup(LLUUID groupID, IClientAPI client)
-        {
-            GroupID = groupID;
-            GetProperties(client);
-            m_updateFlag = 2;
-        }
-        
-        private void handleTimerAccounting(uint localID, double interval)
+        public void unregisterTargetWaypoint(int handle)
         {
-            if (localID == LocalId)
+            if (m_parentGroup != null)
             {
-
-                float sec = (float)interval;
-                if (m_parentGroup != null)
-                {
-                    if (sec == 0)
-                    {
-                        if (m_parentGroup.scriptScore + 0.001f >= float.MaxValue - 0.001)
-                            m_parentGroup.scriptScore = 0;
-
-                        m_parentGroup.scriptScore += 0.001f;
-                        return;
-                    }
-
-                    if (m_parentGroup.scriptScore + (0.001f / sec) >= float.MaxValue - (0.001f / sec))
-                        m_parentGroup.scriptScore = 0;
-                    m_parentGroup.scriptScore += (0.001f / sec);
-                }
-
+                m_parentGroup.unregisterTargetWaypoint(handle);
             }
         }
 
+        #endregion Public Methods
     }
-}
+}
\ No newline at end of file