PlatformCharacter2.cs

Siirry tämän tiedoston dokumentaatioon.

#if DEBUG
// #define VISUALIZE
#endif

using System;
using System.ComponentModel;
using System.Collections.Generic;
using System.Linq;
using Jypeli;
using Jypeli.Assets;
using Physics2DDotNet;


public class PlatformCharacter2 : PhysicsObject
{
    private int _tolerance = 5;
    private double _accel = 1000;
    private double _maxVel = 500;

    private enum PlatformCharacterState { Idle, Falling, Jumping }
    private PlatformCharacterState state = PlatformCharacterState.Idle;

    private Weapon weapon = null;
    private Vector _cachedGravity = Vector.Zero;
    private double _cachedGravityMagnitude = 0;
    private Vector _cachedGravityNormal = Vector.Zero;

    private bool collisionDetected = false;
    private int noCollisionCount = 0;
    private int walkSteps = 0;
    private Direction _curDirection = Direction.Right;
    private Timer detachTimer = new Timer();

    private bool customAnimPlaying = false;
    private Action customAnimAction;

    private double gravityMagnitude
    {
        get
        {
            updateGravity();
            return _cachedGravityMagnitude;
        }
    }

    private Vector gravityNormal
    {
        get
        {
            updateGravity();
            return _cachedGravityNormal;
        }
    }

    public int PlatformTolerance
    {
        get { return _tolerance; }
        set { _tolerance = value; }
    }

    public Direction FacingDirection
    {
        get { return _curDirection; }
        set { Turn( value ); }
    }

    public double Acceleration
    {
        get { return _accel; }
        set { _accel = value; }
    }

    public double MaxVelocity
    {
        get { return _maxVel; }
        set { _maxVel = value; }
    }

#if VISUALIZE
    private GameObject ssurface = new GameObject( 1, 2, Shape.Rectangle ) { Color = Color.Blue };
    private PhysicsObject _platform = null;

    public PhysicsObject Platform
    {
        get { return _platform; }
        set
        {
            if ( value != null )
            {
                Vector distNormal = this.Position - value.Position;
                double sideWidth = Math.Sqrt( Width * Width + Height * Height );
                ssurface.Position = this.Position - Vector.FromLengthAndAngle( sideWidth, distNormal.Angle );
                ssurface.Color = Color.Red;
            }
            else
            {
                ssurface.Color = Color.Blue;
                PlatformNormal = Vector.Zero;
            }

            _platform = value;
        }
    }
#else
    public PhysicsObject Platform { get; set; }
#endif

    public Vector PlatformNormal { get; private set; }

    public Weapon Weapon
    {
        get { return weapon; }
        set
        {
            // First check: same weapon
            if ( weapon == value ) return;

            // Remove the previous weapon if any
            if ( weapon != null )
            {
                // Reset the weapon when removing

                if ( !IsWeaponFacingRight() )
                {
                    weapon.X *= -1;
                    weapon.TextureWrapSize = new Vector( 1, 1 );
                }

                weapon.Angle = Angle.Zero;
                this.Remove( weapon );
            }

            this.weapon = value;
            if ( value == null )
                return;

            this.Add( value );

            if ( FacingDirection == Direction.Left )
            {
                // If facing left, set the weapon to match the direction
                weapon.X *= -1;
                weapon.Angle = Angle.StraightAngle;
                weapon.TextureWrapSize = new Vector( 1, -1 );
            }
        }
    }

    public bool CanMoveOnAir { get; set; }

    public Animation AnimWalk { get; set; }

    public Animation AnimJump { get; set; }

    public Animation AnimFall { get; set; }

    public bool LoopJumpAnim { get; set; }

    public bool LoopFallAnim { get; set; }

    public Animation AnimIdle { get; set; }

    public bool WalkOnAir { get; set; }

    public event Action<Direction> DirectionChanged;

    public PlatformCharacter2(double width, double height)
        : this(width, height, Shape.Circle)
    {
    }

    public PlatformCharacter2( double width, double height, Shape shape )
        : base( width, height, shape /*, CollisionShapeQuality.FromValue(0.7)*/ )
    {
        KineticFriction = 0.0;
        Restitution = 0.2;
        CanRotate = false;
        CanMoveOnAir = true;

        // This avoids high speeds, particularly when falling. This then avoids
        // going through objects.
        LinearDamping = 0.96;

        AddedToGame += AddCollisionHandler;
        IsUpdated = true;
    }

    private void SetAnimation( Animation anim, bool loop = true )
    {
        if ( customAnimPlaying || anim == null || Animation == anim || anim.FrameCount == 0 )
            return;

        Animation = anim;

        if ( loop )
            Animation.Start();
        else
            AnimJump.Start( 1 );
    }

    public void PlayAnimation( Animation anim, Action onPlayed = null )
    {
        customAnimPlaying = true;
        customAnimAction = onPlayed;
        this.Animation = anim;
        anim.Played += AnimationPlayed;
        anim.Start( 1 );
    }

    private void AnimationPlayed()
    {
        Animation.Played -= AnimationPlayed;
        customAnimPlaying = false;

        if ( customAnimAction != null )
            customAnimAction();
    }

    private void updateGravity()
    {
        PhysicsGame physGame = Game.Instance as PhysicsGame;
        if ( physGame == null ) return;

        if ( physGame.Gravity != _cachedGravity )
        {
            _cachedGravity = physGame.Gravity;
            _cachedGravityMagnitude = _cachedGravity.Magnitude;
            _cachedGravityNormal = _cachedGravity / _cachedGravityMagnitude;

#if VISUALIZE
            ssurface.Angle = gravityNormal.LeftNormal.Angle;
#endif
        }
    }

    private void AddCollisionHandler()
    {
        PhysicsGameBase physicsGame = Game.Instance as PhysicsGameBase;
        if ( physicsGame == null ) throw new InvalidOperationException( "Cannot have a platform character in non-physics game" );

        this.Body.Colliding += delegate( object sender, CollisionEventArgs args )
        {
            PhysicsObject other = (PhysicsObject)args.Other.Tag;
            Vector normal = new Vector( args.Contact.Points[0].Normal.X, args.Contact.Points[0].Normal.Y );
            OnColliding( this, other, normal );
        };

        #if VISUALIZE
        ssurface.Width = 2 * Math.Sqrt( Game.Level.Width * Game.Level.Width + Game.Level.Height * Game.Level.Height );
        Game.Instance.Add( ssurface );
        #endif
    }

    public void Walk()
    {
        walkSteps++;
        
        if ( state == PlatformCharacterState.Idle || WalkOnAir )
            SetAnimation( AnimWalk );
    }

    public void Walk( Direction direction )
    {
        Turn( direction );
        walkSteps++;

        if ( state == PlatformCharacterState.Idle || WalkOnAir )
            SetAnimation( AnimWalk );
    }
    
    public void Turn( Direction direction )
    {
        if ( direction == FacingDirection || ( direction != Direction.Left && direction != Direction.Right ) )
            return;

        walkSteps = 0;
        TextureWrapSize = new Vector( -TextureWrapSize.X, TextureWrapSize.Y );

        if ( Weapon != null )
        {
            Weapon.X *= -1;
            Weapon.TextureWrapSize = new Vector( 1, -Weapon.TextureWrapSize.Y );
            Weapon.Angle = Angle.Supplement( Weapon.Angle );
        }

        _curDirection = direction;

        if ( DirectionChanged != null )
        {
            DirectionChanged( direction );
        }
    }

    public void StopWalking()
    {
        walkSteps = 0;
        if ( state == PlatformCharacterState.Idle )
            SetAnimation( AnimIdle );
    }

    private bool IsWeaponFacingRight()
    {
        return (-Math.PI / 2) < Weapon.Angle.Radians
            && Weapon.Angle.Radians < (Math.PI / 2);
    }

    public void Jump( double speed )
    {
        if ( Platform == null || state == PlatformCharacterState.Jumping ) return;
        ForceJump( speed );
    }

    public void ForceJump( double speed )
    {
        IgnoresGravity = false;
        this.Hit( Mass * speed * -gravityNormal );
        Platform = null;
        
        state = PlatformCharacterState.Jumping;
        SetAnimation( AnimJump, LoopJumpAnim );

        Timer t = new Timer();
        t.Interval = 0.01;
        t.Timeout += delegate
        {
            if ( this.Velocity.Y < 0 )
            {
                t.Stop();
                state = PlatformCharacterState.Falling;
                SetAnimation( AnimFall, LoopFallAnim );
            }
        };
        t.Start();
    }

    protected override void PrepareThrowable( PhysicsObject obj, Angle angle, double force, double distanceDelta, double axialDelta )
    {
        double d = ( this.Width + obj.Width ) / 2;
        Angle throwAngle = FacingDirection == Direction.Left ? Angle.StraightAngle - angle : angle;
        obj.Position = this.AbsolutePosition + this.FacingDirection.GetVector() * d + gravityNormal * axialDelta;
        obj.Hit( Vector.FromLengthAndAngle( force, throwAngle ) );
    }
    
    private void OnColliding( PhysicsObject collisionHelperObject, PhysicsObject target, Vector normal )
    {
        if ( target.IgnoresCollisionResponse )
            return;

        double dot = Vector.DotProduct( normal, gravityNormal );
        if ( Math.Abs( dot ) < 0.5 )
            return;

        if ( Platform != null && Platform != target )
            return;

        if ( Platform == null )
            Platform = target;
            
        collisionDetected = true;
        noCollisionCount = 0;
        PlatformNormal = normal;

        if ( state == PlatformCharacterState.Falling )
            state = PlatformCharacterState.Idle;
    }

    [EditorBrowsable(EditorBrowsableState.Never)]
    public override void Update(Time time)
    {
        if ( Platform != null && !collisionDetected )
        {
            if ( ++noCollisionCount > PlatformTolerance )
            {
                Platform = null;

                if ( state != PlatformCharacterState.Jumping )
                {
                    state = PlatformCharacterState.Falling;
                    SetAnimation( AnimFall, LoopFallAnim );
                }
            }
        }

        collisionDetected = false;

        if ( walkSteps > 0 )
        {
            // Walking
            double impulse = Mass * Acceleration * time.SinceLastUpdate.TotalSeconds;
            Vector unitX = gravityMagnitude > 0 ? gravityNormal.LeftNormal : Vector.UnitX;

            if ( _curDirection == Direction.Left && -Velocity.X < MaxVelocity )
                this.Push( Mass * Acceleration * -unitX );
            else if ( _curDirection == Direction.Right && Velocity.X < MaxVelocity )
                this.Push( Mass * Acceleration * unitX );

            walkSteps--;

            if ( state == PlatformCharacterState.Idle )
                SetAnimation( AnimWalk );
        }
        else
        {
            // Not walking
            if ( state == PlatformCharacterState.Idle )
                SetAnimation( AnimIdle );
            /*switch ( state )
            {
                case PlatformCharacterState.Idle: SetAnimation( AnimIdle ); break;
                case PlatformCharacterState.Falling: SetAnimation( AnimFall ); break;
                case PlatformCharacterState.Jumping: SetAnimation( AnimJump ); break;
            }*/
        }

        base.Update(time);
    }

    public override void Move( Vector movement )
    {
        if ( movement.X > 0 ) Walk( Direction.Right );
        else if ( movement.X < 0 ) Walk( Direction.Left );
        if ( movement.Y > 0 ) Jump( movement.Y );
    }
}