public override void RemoveAvatar(PhysicsActor character)
 {
     POSCharacter act = (POSCharacter) character;
     if (_characters.Contains(act))
     {
         _characters.Remove(act);
     }
 }

 public override void RemoveAvatar(PhysicsActor actor)
 {
     BasicActor act = (BasicActor) actor;
     if (_actors.Contains(act))
     {
         _actors.Remove(act);
     }
 }

 public override void RemovePrim(PhysicsActor prim)
 {
     POSPrim p = (POSPrim) prim;
     if (_prims.Contains(p))
     {
         _prims.Remove(p);
     }
 }

 public override void AddPhysicsActorTaint(PhysicsActor prim)
 {
     //throw new NotSupportedException("AddPhysicsActorTaint must be called with a taint type");
 }

 public override void RemoveAvatar(PhysicsActor actor)
 {
     this.QueueCommand(new Commands.RemoveCharacterCmd((PhysxCharacter)actor));
 }

    public override void RemovePrim(PhysicsActor prim)
    {
        if (!m_initialized) return;

        BSPhysObject bsprim = prim as BSPhysObject;
        if (bsprim != null)
        {
            DetailLog("{0},RemovePrim,call", bsprim.LocalID);
            // m_log.DebugFormat("{0}: RemovePrim. id={1}/{2}", LogHeader, bsprim.Name, bsprim.LocalID);
            try
            {
                lock (PhysObjects) PhysObjects.Remove(bsprim.LocalID);
            }
            catch (Exception e)
            {
                m_log.ErrorFormat("{0}: Attempt to remove prim that is not in physics scene: {1}", LogHeader, e);
            }
            bsprim.Destroy();
            // bsprim.dispose();
        }
        else
        {
            m_log.ErrorFormat("{0}: Attempt to remove prim that is not a BSPrim type.", LogHeader);
        }
    }

 public override void link(PhysicsActor obj) { return; }

 public virtual void RemoveAllJointsConnectedToActorThreadLocked(PhysicsActor actor)
 { return; }

 /// <summary>
 /// Remove an avatar.
 /// </summary>
 /// <param name="actor"></param>
 public abstract void RemoveAvatar(PhysicsActor actor);

 public override void RemovePrim(PhysicsActor prim)
 {
     if (prim is BulletXPrim)
     {
         lock (BulletXLock)
         {
             try
             {
                 ddWorld.RemoveRigidBody(((BulletXPrim) prim).RigidBody);
             }
             catch (Exception ex)
             {
                 BulletXMessage(is_ex_message + ex.Message, true);
                 ((BulletXPrim) prim).RigidBody.ActivationState = ActivationState.DisableSimulation;
                 AddForgottenRigidBody(((BulletXPrim) prim).RigidBody);
             }
             _prims.Remove(((BulletXPrim) prim).RigidBody);
         }
         GC.Collect();
     }
 }

 public override void RemoveAvatar(PhysicsActor actor)
 {
     if (actor is BulletXCharacter)
     {
         lock (BulletXLock)
         {
             try
             {
                 ddWorld.RemoveRigidBody(((BulletXCharacter) actor).RigidBody);
             }
             catch (Exception ex)
             {
                 BulletXMessage(is_ex_message + ex.Message, true);
                 ((BulletXCharacter) actor).RigidBody.ActivationState = ActivationState.DisableSimulation;
                 AddForgottenRigidBody(((BulletXCharacter) actor).RigidBody);
             }
             _characters.Remove(((BulletXCharacter) actor).RigidBody);
         }
         GC.Collect();
     }
 }

 public abstract void link(PhysicsActor obj);

        private void changelink(float timestep)
        {
            // If the newly set parent is not null
            // create link
            if (_parent == null && m_taintparent != null)
            {
                if (m_taintparent.PhysicsActorType == (int)ActorTypes.Prim)
                {
                    OdePrim obj = (OdePrim)m_taintparent;
                    //obj.disableBody();
//Console.WriteLine("changelink calls ParentPrim");
                    obj.AddChildPrim(this);

                    /*
                    if (obj.Body != (IntPtr)0 && Body != (IntPtr)0 && obj.Body != Body)
                    {
                        _linkJointGroup = d.JointGroupCreate(0);
                        m_linkJoint = d.JointCreateFixed(_parent_scene.world, _linkJointGroup);
                        d.JointAttach(m_linkJoint, obj.Body, Body);
                        d.JointSetFixed(m_linkJoint);
                    }
                     */
                }
            }
            // If the newly set parent is null
            // destroy link
            else if (_parent != null && m_taintparent == null)
            {
//Console.WriteLine("  changelink B");
            
                if (_parent is OdePrim)
                {
                    OdePrim obj = (OdePrim)_parent;
                    obj.ChildDelink(this);
                    childPrim = false;
                    //_parent = null;
                }
                
                /*
                    if (Body != (IntPtr)0 && _linkJointGroup != (IntPtr)0)
                    d.JointGroupDestroy(_linkJointGroup);
                        
                    _linkJointGroup = (IntPtr)0;
                    m_linkJoint = (IntPtr)0;
                */
            }
 
            _parent = m_taintparent;
            m_taintPhysics = IsPhysical;
        }

 public override void link(PhysicsActor obj)
 {
     m_taintparent = obj;
 }

 public override void RemoveAvatar(PhysicsActor actor)
 {
 }

 public override void RemovePrim(PhysicsActor prim)
 {
 }

 public override void LinkToNewParent(PhysicsActor obj, Vector3 localPos, Quaternion localRot)
 {
     
 }

 /// <summary>
 /// Remove a prim.
 /// </summary>
 /// <param name="prim"></param>
 public abstract void RemovePrim(PhysicsActor prim);

        public void AttachToPhysicsShape(PhysicsActor shape, bool isChild)
        {
            PhysActor = shape;
            SetPhysActorRelationProperties();

            if (!isChild)
            {
                PhysActor.OnRequestTerseUpdate -= this.PhysicsRequestingTerseUpdate;
                PhysActor.OnRequestTerseUpdate += this.PhysicsRequestingTerseUpdate;
                PhysActor.OnComplexityError -= new PhysicsActor.ComplexityError(PhysActor_OnComplexityError);
                PhysActor.OnComplexityError += new PhysicsActor.ComplexityError(PhysActor_OnComplexityError);
                PhysActor.OnPhysicsRequestingOBB -= PhysActor_OnPhysicsRequestingOBB;
                PhysActor.OnPhysicsRequestingOBB += PhysActor_OnPhysicsRequestingOBB;
            }

            PhysActor.OnNeedsPersistence -= new PhysicsActor.RequestPersistence(PhysActor_OnNeedsPersistence);
            PhysActor.OnNeedsPersistence += new PhysicsActor.RequestPersistence(PhysActor_OnNeedsPersistence);
            PhysActor.OnPositionUpdate -= new PositionUpdate(PhysActor_OnPositionUpdate);
            PhysActor.OnPositionUpdate += new PositionUpdate(PhysActor_OnPositionUpdate);

            this.CheckForScriptCollisionEventsAndSubscribe();
        }

 public abstract void AddPhysicsActorTaint(PhysicsActor prim);