PhysicsGameBase.cs

Siirry tämän tiedoston dokumentaatioon.

using System;
using System.Collections.Generic;
using System.ComponentModel;
using Jypeli.Physics;
 
namespace Jypeli
{
    public abstract partial 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;
            }
        }
 
        public IPhysicsEngine Engine { get; private set; }
 
        private SynchronousList<IAxleJoint> Joints = new SynchronousList<IAxleJoint>();
        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>>();
        
        private Vector gravity = Vector.Zero;
 
        public Vector Gravity
        {
            get
            {
                return gravity;
            }
            set
            {
                gravity = value;
                Engine.Gravity = value;
            }
        }
 
        public static new PhysicsGameBase Instance
        {
            get
            {
                if ( Game.Instance == null ) throw new InvalidOperationException( "Game class is not initialized" );
                if ( !( Game.Instance is PhysicsGameBase ) ) throw new InvalidOperationException( "Game class is not PhysicsGame" );
 
                return (PhysicsGameBase)( Game.Instance );
            }
        }
 
        public bool PhysicsEnabled { get; set; }
 
        public PhysicsGameBase( IPhysicsEngine engine )
            : base()
        {
            this.Engine = engine;
            PhysicsEnabled = true;
 
            Joints.ItemAdded += OnJointAdded;
            Joints.ItemRemoved += OnJointRemoved;
        }
 
        void OnJointAdded( IAxleJoint j )
        {
            if ( !j.Object1.IsAddedToGame )
            {
                j.SetEngine( Engine );
                j.Object1.AddedToGame += j.AddToEngine;
            }
            else if ( j.Object2 != null && !j.Object2.IsAddedToGame )
            {
                j.SetEngine( Engine );
                j.Object2.AddedToGame += j.AddToEngine;
            }
            else
            {
                Engine.AddJoint( j );
            }
        }
 
        void OnJointRemoved( IAxleJoint j )
        {
            Engine.RemoveJoint( j );
        }
 
        protected override void OnObjectAdded( IGameObject obj )
        {
            if ( obj is PhysicsObject )
            {
                PhysicsObject po = (PhysicsObject)obj;
                Engine.AddBody( po.Body );
            }
 
            base.OnObjectAdded( obj );
        }
 
        protected override void OnObjectRemoved( IGameObject obj )
        {
            if ( obj is PhysicsObject )
            {
                PhysicsObject po = (PhysicsObject)obj;
                Engine.RemoveBody( po.Body );
            }
 
            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();
            RemoveCollisionHandlers();
            base.ClearAll();
        }
 
        private void ClearPhysics()
        {
            Engine.Clear();
        }
 
        protected override void Update( Time time )
        {
            double dt = time.SinceLastUpdate.TotalSeconds;
 
            if ( PhysicsEnabled )
            {
                Engine.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 );
        }
 
        public void Add( IAxleJoint j )
        {
            Joints.Add( j );
        }
 
        internal void Remove( IAxleJoint j )
        {
            Joints.Remove( j );
        }
 
        #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 );
        }
 
        [EditorBrowsable( EditorBrowsableState.Never )]
        public 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);
            }
        }
 
        [EditorBrowsable( EditorBrowsableState.Never )]
        public 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
    }
}