Weapon.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: Tero Jäntti, Tomi Karppinen, Janne Nikkanen.
 */

using System;

namespace Jypeli.Assets
{
    public abstract class Weapon : GameObject
    {
        private TimeSpan timeOfLastUse;

        public virtual bool IsReady
        {
            get
            {
                return ( Ammo > 0 ) && ( ( Game.Time.SinceStartOfGame - timeOfLastUse ) > TimeBetweenUse );
            }
        }

        public bool CanHitOwner { get; set; }

        public DoubleMeter Power { get; protected set; }

        public IntMeter Ammo { get; protected set; }

        public bool InfiniteAmmo
        {
            get { return Ammo.Value == Int32.MaxValue; }
            set
            {
                if ( !value && Ammo.Value == Int32.MaxValue )
                    Ammo.Value = 100;
                else if ( value )
                    Ammo.Value = Int32.MaxValue;
            }
        }

        public bool AmmoIgnoresGravity { get; set; }

        public bool AmmoIgnoresExplosions { get; set; }

        public TimeSpan MaxAmmoLifetime { get; set; }

        public SoundEffect AttackSound { get; set; }

        public TimeSpan TimeBetweenUse { get; set; }

        public double FireRate
        {
            get { return 1 / TimeBetweenUse.TotalSeconds; }
            set
            {
                if (value < 0) throw new ArgumentException("Fire rate cannot be negative!");
                if (value == 0) TimeBetweenUse = TimeSpan.MaxValue;
                else TimeBetweenUse = TimeSpan.FromSeconds( 1 / value );
            }
        }

        public event Action<PhysicsObject> Shooting;

        protected void OnShooting( PhysicsObject projectile )
        {
            if ( Shooting != null )
                Shooting( projectile );
        }

        public CollisionHandler<PhysicsObject, PhysicsObject> ProjectileCollision { get; set; }

        public Weapon( double width, double height )
            : base( width, height )
        {
            Shape = Shape.Rectangle;
            Power = new DoubleMeter( 0 );
            Power.MinValue = 0;
            Ammo = new IntMeter( Int32.MaxValue, 0, Int32.MaxValue );
            Ammo.MinValue = 0;
            MaxAmmoLifetime = TimeSpan.MaxValue;
        }

        protected abstract PhysicsObject CreateProjectile();

        public PhysicsObject Shoot()
        {
            if ( IsReady )
            {
                timeOfLastUse = Game.Time.SinceStartOfGame;

                if (AttackSound != null)
                    AttackSound.Play();

                PhysicsObject p = CreateProjectile();

                SetCollisionHandler( p, ProjectileCollision );
                p.IgnoresGravity = AmmoIgnoresGravity;
                p.IgnoresExplosions = AmmoIgnoresExplosions;
                p.MaximumLifetime = MaxAmmoLifetime;
                ShootProjectile( p, Power.Value );
                if ( !InfiniteAmmo ) Ammo.Value--;
                Power.Reset();
                OnShooting( p );

                return p;
            }

            return null;
        }

        protected void ShootProjectile( PhysicsObject projectile, double power )
        {
            if ( !IsAddedToGame )
                return;

            Vector impulse = Vector.FromLengthAndAngle( power, AbsoluteAngle );
            Vector direction = Vector.FromLengthAndAngle( 1.0, AbsoluteAngle );
            Vector position = this.Position;

            if ( Parent != null )
            {
                //0.75 * max(width, height) -> projectiles don't hit the PlatformCharacter's collisionHelpers.
                //Would be better to choose the width or height manually based on the direction.
                position = this.AbsolutePosition + direction * 0.75 * ( Math.Max(this.Parent.Width, this.Parent.Height) );
            }

            projectile.Position = position;
            projectile.Angle = this.AbsoluteAngle;

            if ( Parent is PhysicsObject && !CanHitOwner )
            {
                // The projectile can not hit the owner of the weapon.
                // Owner's CollisionIgnorer can be null if no CollisionIgnorer is set for the owner
                // Must set CollisionIgnorer separetly for PlatformCharacter because of it's CollisionHelpers
                PhysicsObject physParent = (PhysicsObject)Parent;
                if (physParent.Body.CollisionIgnorer == null)
                {
                    if (physParent is PlatformCharacter)
                        (physParent as PlatformCharacter).CollisionIgnorer = new Physics2DDotNet.Ignorers.ObjectIgnorer();
                    else
                        physParent.Body.CollisionIgnorer = new Physics2DDotNet.Ignorers.ObjectIgnorer();
                }
                projectile.Body.CollisionIgnorer = physParent.Body.CollisionIgnorer;
            }

            Game.Instance.Add( projectile );
            projectile.Hit( impulse );
        }

        protected void SetCollisionHandler( PhysicsObject projectile, CollisionHandler<PhysicsObject, PhysicsObject> handler )
        {
            if ( handler == null )
                return;

            if ( Game.Instance is PhysicsGameBase )
            {
                PhysicsGameBase pg = (PhysicsGameBase)Game.Instance;
                pg.AddCollisionHandler( projectile, handler );
            }
            else
                throw new InvalidOperationException( "Cannot set a collision handler to non-physics game!" );
        }
    }
}