source: 2015/27/ohjaajat/TheLegendOfGabriel/TheLegendOfGabriel/TheLegendOfGabriel/Item.cs @ 6712

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Jypeli;
using Jypeli.Assets;


abstract class Item
{
    protected Player player;

    // Iso kuvake joka näkyy inventoryssä.
    public Image InventoryImage { get; set; }

    public IntMeter Usages { get; set; }

    // Onko kama tällä hetkellä aktiivisessa käytössä.
    public virtual bool InUse { get; set; }

    // Jos true niin pelaaja ei koske animaatioihinsa.
    public virtual bool OverrideAnimation { get; set; }

    // Tapahtuu kokoajan, jos kama on pelaajalla valittuna tavarana.
    public virtual void UpdateItem(Time time) { }

    // Kaman käyttönappia painettiin.
    public virtual void UseKeyPressed() { }

    // Kaman käyttönappia pidetään pohjassa.
    public virtual void UseKeyDown() { }

    // Kaman käyttönappi laskettiin irti.
    public virtual void UseKeyReleased() { }

    public virtual void CancelUse() { }

    protected Item(Player player)
    {
        Usages = new IntMeter(0, 0, 0);
        this.player = player;
    }
}

class Sword : Item
{
    public Direction SwingDirection { get; set; }

    public PhysicsObject SwordObject { get; set; }

    private readonly Angle[] swordAngles;

    public override bool OverrideAnimation
    {
        get { return InUse; }
    }

    public Sword(Player player)
        : base(player)
    {
        InventoryImage = TheLegendOfGabriel.SmallSwordImage;
        swordAngles = new Angle[5];
        for (var i = 0; i < 5; i++)
        {
            swordAngles[i] = Angle.FromDegrees(45 + -45 * 0.5 * i);
        }
    }

    public override void UpdateItem(Time time)
    {
        if (SwordObject != null && SwordObject.IsDestroyed)
        {
            SwordObject = null;
        }
        if (SwordObject != null && InUse)
        {
            if (player.Animation.CurrentFrameIndex < swordAngles.Length)
            {
                try
                {
                    var dir = SwingDirection;
                    var swordAngle = swordAngles[player.Animation.CurrentFrameIndex];
                    if (dir == Direction.Left)
                        swordAngle = Angle.FromDegrees(swordAngle.Degrees * -1);
                    SwordObject.Position = player.Position + (dir.Angle + swordAngle).GetVector() * 15;
                    SwordObject.Angle = swordAngle +
                                        Angle.FromDegrees(dir == Direction.Left || dir == Direction.Right ? 90 : 0);
                    SwordObject.Angle += Angle.FromDegrees(dir == Direction.Right || dir == Direction.Down ? 180 : 0);
                }
                catch (IndexOutOfRangeException ex)
                {

                }
            }
        }
        base.UpdateItem(time);
    }

    public override void UseKeyPressed()
    {
        InUse = true;

        TheLegendOfGabriel.SwordSound.Play();

        if (SwordObject != null)
            SwordObject.Destroy();

        SwordObject = PhysicsObject.CreateStaticObject(6, 16);
        SwordObject.Tag = "playerattack";
        SwordObject.CollisionIgnoreGroup = player.CollisionIgnoreGroup;
        SwordObject.Position = player.Position;
        SwordObject.Image = TheLegendOfGabriel.SmallSwordImage;
        Game.Instance.Add(SwordObject);

        SwingDirection = player.Velocity.Angle.MainDirection;
        player.Animation = new Animation(player.SwingAnimations[SwingDirection]);
        player.Animation.StopOnLastFrame = true;
        player.Animation.Played += delegate
        {
            InUse = false;
            player.SetWalkAnimation();
            SwordObject.Destroy();
        };
        player.Animation.Start(1);

        base.UseKeyPressed();
    }

    public override void CancelUse()
    {
        InUse = false;
        player.SetWalkAnimation();
        if (SwordObject != null)
        {
            SwordObject.Destroy();
            SwordObject = null;
        }
    }
}

class Pistol : Item
{
    private bool isCharging;

    public Direction ShootDirection { get; set; }

    // Montako sekuntia pistoolilla on tähdätty. Täydellä latauksella voisi ampua isomman ammuksen.
    public DoubleMeter Charge { get; set; }

    public override bool OverrideAnimation
    {
        get { return InUse; }
    }

    public Pistol(Player player)
        : base(player)
    {
        Usages.MaxValue = 15;
        Usages.Value = 15;
        Charge = new DoubleMeter(0, 0, 4);
        InventoryImage = TheLegendOfGabriel.GunImage;
    }

    public override void UpdateItem(Time time)
    {
        if (isCharging)
        {
            Charge.Value += time.SinceLastUpdate.TotalSeconds;
        }
        base.UpdateItem(time);
    }

    public override void UseKeyPressed()
    {
        if (Usages.Value == 0)
        {
            base.UseKeyPressed();
            return;
        }

        InUse = true;
        isCharging = true; // Ase alkaa latautumaan.
        Charge.Value = Charge.MinValue; // Aseen lataus aluksi nollaan.

        // Hidastetaan pelaajaa samalla kun se tähtää.
        player.MovementSpeed.Value = player.MovementSpeed.MaxValue * 0.333;

        ShootDirection = player.Velocity.Angle.MainDirection;
        player.Animation = new Animation(player.ShootAnimations[ShootDirection]);
        player.Animation.StopOnLastFrame = true;
        player.Animation.Start(1);
        base.UseKeyPressed();
    }

    public override void UseKeyReleased()
    {
        // Pistoolilla voi ampua vain jos tähtäysanimaatio on ehtinyt loppuun.
        if (InUse && Usages.Value > 0 && player.Animation.CurrentFrameIndex == player.Animation.FrameCount - 1)
        {
            Usages.Value--;
            TheLegendOfGabriel.GunSound.Play();

            var bullet = new PhysicsObject(4, 4);
            bullet.Tag = "playerattack";
            bullet.Image = TheLegendOfGabriel.BulletImage;
            bullet.Position = player.Position + ShootDirection.GetVector() * player.Width * 0.7;
            bullet.Hit(ShootDirection.GetVector() * 500);
            Game.Instance.Add(bullet);

            ((TheLegendOfGabriel)Game.Instance).AddCollisionHandler(bullet,
                delegate(PhysicsObject b, PhysicsObject e)
                {
                    bullet.Destroy();
                });
        }
        CancelUse();

        base.UseKeyReleased();
    }

    public override void CancelUse()
    {
        InUse = false;
        isCharging = false;
        player.MovementSpeed.Value = player.MovementSpeed.MaxValue;
        player.SetWalkAnimation();
        base.CancelUse();
    }
}

class Grenade : Item
{
    public Grenade(Player player)
        : base(player)
    {
        Usages.MaxValue = 15;
        Usages.Value = 15;
        InventoryImage = TheLegendOfGabriel.GrenadeImage;
    }

    public override void UseKeyPressed()
    {
        if (Usages.Value > 0)
        {
            Usages.Value--;

            var grenade = new PhysicsObject(6, 6);
            grenade.Image = TheLegendOfGabriel.GrenadeSmallImage;
            grenade.Position = player.Position + player.LastDirection.GetVector() * player.Width * 0.7;
            grenade.Hit(player.LastDirection.GetVector() * 500);
            grenade.ApplyTorque(9000);
            grenade.LinearDamping = 0.9;
            grenade.AngularDamping = 0.9;
            Game.Instance.Add(grenade);

            Timer.SingleShot(1.5, delegate
            {
                var expl = new Explosion(50);
                expl.Position = grenade.Position;
                expl.ShockwaveReachesObject += delegate(IPhysicsObject o, Vector vector)
                {
                    var cre = o as Creature;
                    if (cre != null)
                    {
                        cre.Health.Value--;
                    }
                };
                Game.Instance.Add(expl);
                grenade.Destroy();
            });
        }
        base.UseKeyPressed();
    }
}

class Monocle : Item
{
    private GameObject bigMonocle;

    public Monocle(Player player)
        : base(player)
    {
        InventoryImage = TheLegendOfGabriel.MonocleImage;
    }

    public override void UpdateItem(Time time)
    {
        if (bigMonocle != null)
            bigMonocle.Position = player.Position;
        base.UpdateItem(time);
    }

    public override void UseKeyPressed()
    {
        InUse = true;
        CreateMonocle();
        base.UseKeyPressed();
    }

    public override void UseKeyDown()
    {
        if (bigMonocle == null)
            return;

        foreach (var tile in Game.Instance.GetObjectsWithTag("cover"))
        {
            tile.IsVisible = Vector.Distance(player.Position, tile.Position) > bigMonocle.Width * 0.5;
        }
        base.UseKeyDown();
    }

    public override void UseKeyReleased()
    {
        CancelUse();
        base.UseKeyReleased();
    }

    public override void CancelUse()
    {
        InUse = false;
        if (bigMonocle != null)
        {
            bigMonocle.Destroy();
            bigMonocle = null;
        }
        foreach (var tile in Game.Instance.GetObjectsWithTag("cover"))
        {
            tile.IsVisible = true;
        }
        base.CancelUse();
    }

    private void CreateMonocle()
    {
        bigMonocle = new GameObject(150, 150);
        bigMonocle.Image = TheLegendOfGabriel.BigMonocleImage;
        bigMonocle.Position = player.Position;
        Game.Instance.Add(bigMonocle, 3);
    }
}