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, Rami Pasanen.
 */
 
using System;
using System.ComponentModel;
 
 
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.png");
            AttackSound = Game.LoadSoundEffectFromResources("CannonFire.wav");
        }
 
        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.png");
            AttackSound = Game.LoadSoundEffectFromResources("MGAttack.wav");
        }
 
        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.png");
            AttackSound = Game.LoadSoundEffectFromResources("PlasmaAttack.wav");
            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.png");
            AttackSound = Game.LoadSoundEffectFromResources("Laser.wav");
            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.png")
        {
        }
    }
 
    public class Bullet : Projectile
    {
        public Bullet(double radius)
            : base(radius, 0.2, "Bullet.png")
        {
        }
    }
 
    public class Grenade : Projectile
    {
        public Explosion Explosion { get; set; }
 
        public bool Exploded { 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.png")
        {
            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);
            Exploded = true;
        }
 
        [EditorBrowsable(EditorBrowsableState.Never)]
        public override void Update(Time time)
        {
            if ((time.SinceStartOfGame - CreationTime) > FuseTime && IsAddedToGame && !Exploded)
            {
                // 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;
            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.Explosion.Force = this.Explosion.Force / 2;
                g.Explosion.MaxRadius = this.Explosion.MaxRadius / 2;
                g.Explosion.Speed = this.Explosion.Speed / 2;
                g.CollisionIgnorer = this.CollisionIgnorer;
                Game.Instance.Add(g);
            }
        }
    }
}