PhysicsGameBase.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Physics2DDotNet;
using Physics2DDotNet.Joints;

namespace Jypeli
{
    public abstract class PhysicsGameBase : Game
    {
        protected struct CollisionRecord
        {
            public IPhysicsObject obj;
            public IPhysicsObject target;
            public object targetTag;
            public Delegate handler;

            public CollisionRecord( IPhysicsObject obj, IPhysicsObject target, object targetTag, Delegate handler )
            {
                this.obj = obj;
                this.target = target;
                this.targetTag = targetTag;
                this.handler = handler;
            }
        }

        protected PhysicsEngine phsEngine;
        private SynchronousList<Joint> Joints = new SynchronousList<Joint>();
        protected Dictionary<CollisionRecord, CollisionHandler<IPhysicsObject, IPhysicsObject>> collisionHandlers =
            new Dictionary<CollisionRecord, CollisionHandler<IPhysicsObject, IPhysicsObject>>();
        protected Dictionary<CollisionRecord, CollisionHandler<IPhysicsObject, IPhysicsObject>> protectedCollisionHandlers =
            new Dictionary<CollisionRecord, CollisionHandler<IPhysicsObject, IPhysicsObject>>();

        public bool PhysicsEnabled { get; set; }

        public PhysicsGameBase( int device )
            : base( device )
        {
            PhysicsEnabled = true;
            phsEngine = new PhysicsEngine();

            Joints.ItemAdded += OnJointAdded;
            Joints.ItemRemoved += OnJointRemoved;
        }

        void OnJointAdded( Joint j )
        {
            j.Lifetime.IsExpired = false;
            phsEngine.AddJoint( j );
        }

        void OnJointRemoved( Joint j )
        {
            j.Lifetime.IsExpired = true;
        }

        protected override void OnObjectAdded( IGameObject obj )
        {
            if ( obj is PhysicsObject )
            {
                AddToEngine( (PhysicsObject)obj );
            }

            base.OnObjectAdded( obj );
        }

        protected override void OnObjectRemoved( IGameObject obj )
        {
            if ( obj is PhysicsObject )
            {
                RemoveFromEngine( (PhysicsObject)obj );
            }

            base.OnObjectRemoved( obj );
        }

        public void StopAll()
        {
            foreach ( var layer in Layers )
            {
                foreach ( var obj in layer.Objects )
                {
                    if ( obj is PhysicsObject )
                        ( (PhysicsObject)obj ).Stop();
                }
            }
        }

        public override void ClearAll()
        {
            ClearPhysics();
            base.ClearAll();
        }

        private void ClearPhysics()
        {
            phsEngine.Clear();
        }

        private void AddToEngine( PhysicsObject po )
        {
            if ( po.Body.Engine != null )
                return;

            po.Body.Lifetime.IsExpired = false;
            phsEngine.AddBody( po.Body );
        }

        private void RemoveFromEngine( PhysicsObject po )
        {
            if ( po.Body.Engine == null )
                return;

            po.Body.Lifetime.IsExpired = true;
        }

        public void Add( Physics2DDotNet.Joints.Joint j )
        {
            Joints.Add( j );
        }

        internal void Remove( Physics2DDotNet.Joints.Joint j )
        {
            Joints.Remove( j );
        }

        internal void Remove( AxleJoint j )
        {
            Joints.Remove( j.innerJoint );
        }

        public void Add( AxleJoint j )
        {
            bool obj1ok = j.Object1.IsAddedToGame;
            bool obj2ok = j.Object2 == null || j.Object2.IsAddedToGame;

            if ( obj1ok && obj2ok )
            {
                Add( j.innerJoint );
            }
            else
            {
                if ( !obj1ok ) j.Object1.AddedToGame += j.DelayedAddJoint;
                if ( !obj2ok ) j.Object2.AddedToGame += j.DelayedAddJoint;
            }
        }

        protected override void Update( Time time )
        {
            double dt = time.SinceLastUpdate.TotalSeconds;

            if ( PhysicsEnabled )
            {
                phsEngine.Update( dt );
            }

            base.Update( time );

            // Updating joints must be after base.Update so that the bodies 
            // are added to the engine before the joints
            Joints.Update( time );
        }

        #region Collision handlers

        public void AddCollisionHandler<O, T>( O obj, CollisionHandler<O, T> handler )
            where O : IPhysicsObject
            where T : IPhysicsObject
        {
            if ( obj == null ) throw new NullReferenceException( "Colliding object must not be null" );
            if ( handler == null ) throw new NullReferenceException( "Handler must not be null" );

            CollisionHandler<IPhysicsObject, IPhysicsObject> targetHandler =
                delegate( IPhysicsObject collider, IPhysicsObject collidee )
                {
                    if ( collidee is T )
                        handler( (O)collider, (T)collidee );
                };

            obj.Collided += targetHandler;
            collisionHandlers.Add( new CollisionRecord( obj, null, null, handler ), targetHandler );
        }

        internal void AddProtectedCollisionHandler<O, T>( O obj, CollisionHandler<O, T> handler )
            where O : IPhysicsObject
            where T : IPhysicsObject
        {
            if ( obj == null ) throw new NullReferenceException( "Colliding object must not be null" );
            if ( handler == null ) throw new NullReferenceException( "Handler must not be null" );

            CollisionHandler<IPhysicsObject, IPhysicsObject> targetHandler =
                delegate( IPhysicsObject collider, IPhysicsObject collidee )
                {
                    if ( collidee is T )
                        handler( (O)collider, (T)collidee );
                };

            obj.Collided += targetHandler;
            protectedCollisionHandlers.Add( new CollisionRecord( obj, null, null, handler ), targetHandler );
        }

        public void AddCollisionHandler( IPhysicsObject obj, CollisionHandler<IPhysicsObject, IPhysicsObject> handler )
        {
            AddCollisionHandler<IPhysicsObject, IPhysicsObject>( obj, handler );
        }

        public void AddCollisionHandler( PhysicsObject obj, CollisionHandler<PhysicsObject, PhysicsObject> handler )
        {
            AddCollisionHandler<PhysicsObject, PhysicsObject>( obj, handler );
        }

        public void AddCollisionHandler( PhysicsObject obj, CollisionHandler<PhysicsObject, PhysicsStructure> handler )
        {
            AddCollisionHandler<PhysicsObject, PhysicsStructure>( obj, handler );
        }

        public void AddCollisionHandler( PhysicsStructure obj, CollisionHandler<PhysicsStructure, PhysicsObject> handler )
        {
            AddCollisionHandler<PhysicsStructure, PhysicsObject>( obj, handler );
        }

        public void AddCollisionHandler( PhysicsStructure obj, CollisionHandler<PhysicsStructure, PhysicsStructure> handler )
        {
            AddCollisionHandler<PhysicsStructure, PhysicsStructure>( obj, handler );
        }

        public void AddCollisionHandlerByRef<O, T>( O obj, T target, CollisionHandler<O, T> handler )
            where O : IPhysicsObject
            where T : IPhysicsObject
        {
            if ( obj == null ) throw new NullReferenceException( "Colliding object must not be null" );
            if ( target == null ) throw new NullReferenceException( "Collision target must not be null" );
            if ( handler == null ) throw new NullReferenceException( "Handler must not be null" );

            CollisionHandler<IPhysicsObject, IPhysicsObject> targetHandler =
                delegate( IPhysicsObject collider, IPhysicsObject collidee )
                {
                    if ( object.ReferenceEquals( collidee, target ) )
                        handler( (O)collider, (T)collidee );
                };

            obj.Collided += targetHandler;
            collisionHandlers.Add( new CollisionRecord( obj, target, null, handler ), targetHandler );
        }

        public void AddCollisionHandlerByTag<O, T>( O obj, object tag, CollisionHandler<O, T> handler )
            where O : IPhysicsObject
            where T : IPhysicsObject
        {
            if ( obj == null ) throw new NullReferenceException( "Colliding object must not be null" );
            if ( tag == null ) throw new NullReferenceException( "Tag must not be null" );
            if ( handler == null ) throw new NullReferenceException( "Handler must not be null" );

            CollisionHandler<IPhysicsObject, IPhysicsObject> targetHandler =
                delegate( IPhysicsObject collider, IPhysicsObject collidee )
                {
                    if ( collidee is T && StringHelpers.StringEquals( collidee.Tag, tag ) )
                        handler( (O)collider, (T)collidee );
                };

            obj.Collided += targetHandler;
            collisionHandlers.Add( new CollisionRecord( obj, null, tag, handler ), targetHandler );
        }

        public void AddCollisionHandler<O, T>( O obj, object target, CollisionHandler<O, T> handler )
            where O : IPhysicsObject
            where T : IPhysicsObject
        {
            if ( target is T )
                AddCollisionHandlerByRef( obj, (T)target, handler );
            else
                AddCollisionHandlerByTag( obj, target, handler );
        }

        public void AddCollisionHandler( IPhysicsObject obj, object tag, CollisionHandler<IPhysicsObject, IPhysicsObject> handler )
        {
            AddCollisionHandler<IPhysicsObject, IPhysicsObject>( obj, tag, handler );
        }

        public void AddCollisionHandler( PhysicsObject obj, object tag, CollisionHandler<PhysicsObject, PhysicsObject> handler )
        {
            AddCollisionHandler<PhysicsObject, PhysicsObject>( obj, tag, handler );
        }

        public void RemoveCollisionHandlers( PhysicsObject obj = null, PhysicsObject target = null, object tag = null, Delegate handler = null )
        {
            Predicate<CollisionRecord> pred = rec =>
                ( obj == null || object.ReferenceEquals( obj, rec.obj ) ) &&
                ( target == null || target == rec.target ) &&
                ( tag == null || StringHelpers.StringEquals( tag, rec.targetTag ) ) &&
                ( handler == null || object.ReferenceEquals( handler, rec.handler ) );

            List<CollisionRecord> remove = new List<CollisionRecord>();

            foreach (var key in collisionHandlers.Keys)
            {
                if (pred(key)) remove.Add(key);
            }

            foreach (var key in remove)
            {
                key.obj.Collided -= collisionHandlers[key];
                collisionHandlers.Remove(key);
            }
        }

        internal void RemoveProtectedCollisionHandlers( PhysicsObject obj = null, PhysicsObject target = null, object tag = null, Delegate handler = null )
        {
            Predicate<CollisionRecord> pred = rec =>
                ( obj == null || object.ReferenceEquals( obj, rec.obj ) ) &&
                ( target == null || target == rec.target ) &&
                ( tag == null || tag.Equals( rec.targetTag ) ) &&
                ( handler == null || object.ReferenceEquals( handler, rec.handler ) );

            List<CollisionRecord> remove = new List<CollisionRecord>();

            foreach ( var key in collisionHandlers.Keys )
            {
                if ( pred( key ) ) remove.Add( key );
            }

            foreach ( var key in remove )
            {
                key.obj.Collided -= protectedCollisionHandlers[key];
                protectedCollisionHandlers.Remove( key );
            }
        }

        #endregion
    }
}