WeaponTemplates.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;
using System.ComponentModel;
using Physics2DDotNet;
using Physics2DDotNet.Ignorers;


namespace Jypeli.Assets
{
    public class Cannon : Weapon
    {       
        public Cannon( double width, double height )
            : base( width, height )
        {
            Power.DefaultValue = 15000;
            TimeBetweenUse = TimeSpan.FromSeconds( 1 );

            Image = Game.LoadImageFromResources( "Cannon" );
            AttackSound = Game.LoadSoundEffectFromResources( "CannonFire" );
        }

        protected override PhysicsObject CreateProjectile()
        {
            return new CannonBall( 5 );
        }
    }

    public class AssaultRifle : Weapon
    {
        public AssaultRifle( double width, double height )
            : base( width, height )
        {
            AmmoIgnoresGravity = true;
            Power.DefaultValue = 200;
            TimeBetweenUse = TimeSpan.FromSeconds( 0.2 );

            Image = Game.LoadImageFromResources( "AsRifle" );
            AttackSound = Game.LoadSoundEffectFromResources( "MGAttack" );
        }

        protected override PhysicsObject CreateProjectile()
        {
            return new Bullet( 5 );
        }
    }

    public class PlasmaCannon : Weapon
    {
        public PlasmaCannon( double width, double height )
            : base( width, height )
        {
            Power.DefaultValue = 6000;
            AmmoIgnoresGravity = true;
            AmmoIgnoresExplosions = true;
            MaxAmmoLifetime = TimeSpan.FromSeconds( 0.7 );

            Image = Game.LoadImageFromResources( "PlasmaCannon" );
            AttackSound = Game.LoadSoundEffectFromResources( "PlasmaAttack" );
            TimeBetweenUse = TimeSpan.FromSeconds( 0.1 );
        }

        protected override PhysicsObject  CreateProjectile()
        {
            return new Projectile( 3, 5, Color.Green );
        }
    }

    public class LaserGun : Weapon
    {
        public LaserGun( double width, double height )
            : base( width, height )
        {
            Power.DefaultValue = 500;
            Ammo.DefaultValue = Int32.MaxValue;
            AmmoIgnoresGravity = true;
            AmmoIgnoresExplosions = true;
            //MaxAmmoLifetime = TimeSpan.FromSeconds( 0.7 );

            Image = Game.LoadImageFromResources( "PlasmaCannon" );
            AttackSound = Game.LoadSoundEffectFromResources( "laser" );
            TimeBetweenUse = TimeSpan.FromSeconds( 0 );
        }

        protected override PhysicsObject CreateProjectile()
        {
            //return new Projectile( 10, 1, 5, Color.Red );
            PhysicsObject beam = new PhysicsObject( new RaySegment( Vector.Zero, Vector.UnitX, 10 ) );
            beam.Color = Color.Red;
            return beam;
        }
    }    

    public class CannonBall : Projectile
    {
        public CannonBall( double radius )
            : base( radius, 20, "CannonBall" )
        {
        }
    }

    public class Bullet : Projectile
    {
        public Bullet( double radius )
            : base( radius, 0.2, "Bullet" )
        {
        }
    }

    public class Grenade : Projectile
    {
        public Explosion Explosion { get; set; }

        [Obsolete("Use Explosion.MaxRadius")]
        public double ExplosionRadius
        {
            get { return Explosion.MaxRadius; }
            set { Explosion.MaxRadius = value; }
        }

        [Obsolete( "Use Explosion.Speed" )]
        public double ExplosionSpeed
        {
            get { return Explosion.Speed; }
            set { Explosion.Speed = value; }
        }

        [Obsolete( "Use Explosion.Force" )]
        public double ExplosionForce
        {
            get { return Explosion.Force; }
            set { Explosion.Force = value; }
        }

        public TimeSpan FuseTime { get; set; }

        public Grenade( double radius )
            : this( radius, TimeSpan.FromSeconds( 3 ) )
        {
        }

        public Grenade( double radius, TimeSpan fuseTime )
            : base( radius, 20, "Grenade" )
        {
            FuseTime = fuseTime;
            IsUpdated = true;
            Explosion = new Assets.Explosion( 150 ) { Speed = 150, Force = 1000 };
        }

        public virtual void Explode()
        {
            if ( !IsAddedToGame )
                return;

            this.Destroy();
            Explosion.Position = this.Position;
            Game.Instance.Add( Explosion );
        }

        [EditorBrowsable( EditorBrowsableState.Never )]
        public override void Update( Time time )
        {
            if ( ( time.SinceStartOfGame - CreationTime ) > FuseTime && IsAddedToGame )
            {
                // Boom!
                Explode();
            }

            base.Update( time );
        }
    }

    public class ClusterGrenade : Grenade
    {
        private int clusterlevel = 0;

        public int NumberOfClusters { get; set; }

        public Angle ClusterDirection { get; set; }

        public double ClusterArc { get; set; }

        public ClusterGrenade( double radius, int cl )
            : base( radius )
        {
            Mass = 20;
            Body.CollisionIgnorer = new ObjectIgnorer();
            NumberOfClusters = 3;
            ClusterDirection = Angle.FromRadians( Math.PI / 2 );
            ClusterArc = Math.PI;
            clusterlevel = cl - 1;
        }

        public override void Explode()
        {
            if ( !IsAddedToGame ) return;

            Vector posOffset;
            double direction;

            base.Explode();

            for ( int i = 0; i < NumberOfClusters; i++ )
            {
                double currentRadius = Width / 2;
                double r = currentRadius * 0.6;
                // TODO: The mass could be evenly distributed to the clusters and the main projectile.
                Grenade g = ( clusterlevel > 0 ) ?
                    new ClusterGrenade( r, clusterlevel - 1 ) : new Grenade( r );

                direction = ClusterDirection.Radians - ( ( i - NumberOfClusters / 2 ) * ClusterArc / NumberOfClusters );
                posOffset = Vector.FromLengthAndAngle( 2 + this.Size.Magnitude, Angle.FromRadians( direction ) );

                g.Position = this.Position + posOffset;
                g.Mass = this.Mass / NumberOfClusters;
                g.Image = this.Image;
                g.Color = this.Color;
                g.FuseTime = this.FuseTime;
                g.ExplosionForce = this.ExplosionForce / 2;
                g.ExplosionRadius = this.ExplosionRadius / 2;
                g.ExplosionSpeed = this.ExplosionSpeed / 2;
                g.Body.CollisionIgnorer = this.Body.CollisionIgnorer;
                Game.Instance.Add( g );
            }
        }
    }
}