AxleJoint.cs

Siirry tämän tiedoston dokumentaatioon.

#region MIT License
/*
 * Copyright (c) 2009 University of Jyväskylä, Department of Mathematical
 * Information Technology.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

/*
 * Authors: Vesa Lappalainen, Tero Jäntti, Tomi Karppinen.
 */

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using AdvanceMath;

using XnaJoint = Physics2DDotNet.Joints.Joint;
using XnaHingeJoint = Physics2DDotNet.Joints.HingeJoint;
using XnaFixedHinge = Physics2DDotNet.Joints.FixedHingeJoint;

namespace Jypeli
{
    public class AxleJoint : Destroyable, IDisposable
    {
        Vector pivot;
        Vector initialPosition;

        public PhysicsObject Object1 { get; private set; }

        public PhysicsObject Object2 { get; private set; }

        public Vector AxlePoint
        {
            get
            {
                return Object2 != null ? pivot + Object2.Position - initialPosition : pivot;
            }
        }

        internal XnaJoint innerJoint;

        public double Softness
        {
            get
            {
                if ( innerJoint is XnaHingeJoint )
                    return ( (XnaHingeJoint)innerJoint ).Softness;
                else if ( innerJoint is XnaFixedHinge )
                    return ( (XnaFixedHinge)innerJoint ).Softness;
                else
                    throw new ArgumentException( "Invalid type for inner joint: " + innerJoint.GetType() );
            }
            set
            {
                if ( innerJoint is XnaHingeJoint )
                    ( (XnaHingeJoint)innerJoint ).Softness = value;
                else if ( innerJoint is XnaFixedHinge )
                    ( (XnaFixedHinge)innerJoint ).Softness = value;
                else
                    throw new ArgumentException( "Invalid type for inner joint: " + innerJoint.GetType() );
            }
        }

        public AxleJoint( PhysicsObject obj )
        {
            Vector2D pos = new Vector2D( obj.AbsolutePosition.X, obj.AbsolutePosition.Y );
            innerJoint = new XnaFixedHinge( obj.Body, pos, new Physics2DDotNet.Lifespan() );
            Object1 = obj;
            Object2 = null;
            pivot = obj.AbsolutePosition;
        }

        public AxleJoint( PhysicsObject obj, Vector axlePosition )
        {
            Vector2D pos = new Vector2D( axlePosition.X, axlePosition.Y );
            innerJoint = new XnaFixedHinge( obj.Body, pos, new Physics2DDotNet.Lifespan() );
            Object1 = obj;
            Object2 = null;
            pivot = axlePosition;
        }

        public AxleJoint( PhysicsObject firstObject, PhysicsObject secondObject, Vector axlePosition )
        {
            Vector2D pos = new Vector2D( axlePosition.X, axlePosition.Y );
            innerJoint = new XnaHingeJoint( firstObject.Body, secondObject.Body, pos, new Physics2DDotNet.Lifespan() );
            Object1 = firstObject;
            Object2 = secondObject;
            pivot = axlePosition;
            initialPosition = secondObject.AbsolutePosition;
        }

        public AxleJoint( PhysicsObject firstObject, PhysicsObject secondObject )
        {
            Vector2D pos = new Vector2D( secondObject.AbsolutePosition.X, secondObject.AbsolutePosition.Y );
            innerJoint = new XnaHingeJoint( firstObject.Body, secondObject.Body, pos, new Physics2DDotNet.Lifespan() );
            Object1 = firstObject;
            Object2 = secondObject;
            pivot = secondObject.AbsolutePosition;
            initialPosition = secondObject.AbsolutePosition;
        }

        internal void DelayedAddJoint()
        {
            if ( !Object1.IsAddedToGame || ( Object2 != null && !Object2.IsAddedToGame ) )
                return;

            ( (PhysicsGameBase)( Game.Instance ) ).Add( innerJoint );
            Object1.AddedToGame -= this.DelayedAddJoint;
            if ( Object2 != null ) Object2.AddedToGame -= this.DelayedAddJoint;
        }

        #region Destroyable

        public bool IsDestroyed
        {
            get { return innerJoint.Lifetime.IsExpired; }
        }

        public event Action Destroyed;

        public void Destroy()
        {
            innerJoint.Lifetime.IsExpired = true;
        }

        #endregion

        #region IDisposable

        public void Dispose()
        {
            Destroy();
        }

        #endregion
    }
}