source: 2012/09-22/SanteriH/Kynari/Kynari/Kynari/Kynari.cs @ 3948

using System;

using Jypeli;
using Jypeli.Widgets;
using Jypeli.Assets;
using Jypeli.Controls;
using Physics2DDotNet.Ignorers;

public class Pelaaja : PlatformCharacter
{
    public bool voikoPoimiaAseen { get; set; }
    public Explosion ViimeisinRajahdys { get; set; }
    public DoubleMeter HPLaskuri { get; set; }
    public Pelaaja(double width, double height, Shape shape)
        : base(width, height, shape)
    {
        voikoPoimiaAseen = true;
    }
}

// Yksinkertainen tasohyppely.
public class Kynari : PhysicsGame
{
    #region Muuttujat

    const double LIIKEVOIMA = 400;
    const double HYPPYVOIMA = 850;
    const double RUUDUNLEVEYS = 30;
    const double RUUDUNKORKEUS = 30;
    const int PISTEMAARA_JOLLA_VOITTAA_PELIN = 3;

    Pelaaja pelaaja1 = new Pelaaja(40, 40, Shape.Circle);
    Pelaaja pelaaja2 = new Pelaaja(40, 40, Shape.Circle);
    //DoubleMeter hpLaskuri1 = new DoubleMeter(100);
    //DoubleMeter hpLaskuri2 = new DoubleMeter(100);

    Image kranaatinheittimenkuva = LoadImage("grenadelauncher");
    Image kranaatinkuva = LoadImage("grenade");
    Image magnumkuva = LoadImage("magnum");
    Image norsu = LoadImage("norsu");
    Image haulikonkuva = LoadImage("shotgun");
    Image pistoolinkuva = LoadImage("pistol");
    Image kivaarinkuva = LoadImage("assaultrifle");
    Image raketinheittimenkuva = LoadImage("rocketlauncher");
    Image raketinkuva = LoadImage("rocket");
    Image sniperinkuva = LoadImage("sniper");
    bool saaAmpua = false;
    //bool peliohi = false;

    SoundEffect hyppyAani = LoadSoundEffect("hyppays");

    ProgressBar hpNaytto;
    ProgressBar hpNaytto2;

    IntMeter pelaajan1Pisteet;
    IntMeter pelaajan2Pisteet;

    #endregion

    #region Alustukset
    public override void Begin()
    {
        pelaajan1Pisteet = new IntMeter(0);
        pelaajan2Pisteet = new IntMeter(0);

        DrawPerimeter = false; // ei haluta piirtää kentän reunoja
        LuoAlkuValikko();
    }

    void AloitaUusiPeli()
    {

        MessageDisplay.Clear();
        // ladataan kenttä
        //seuraavaKentta();
        LuoKentta(1);
        lisaaNappaimet();
        LisaaLaskurit();
        LisaaHPNaytot();
        naytaTiedot();
        //peliohi = false;
        saaAmpua = false;
        Timer.SingleShot(0.1, delegate
        {
            saaAmpua = true;
        });
    }
    #endregion


    #region KentanLataus

    void LuoKentta(int kenttaNro)
    {
        ClearAll();
        TileMap ruudut = TileMap.FromLevelAsset("kentta1");
        ruudut.SetTileMethod('x', LuoReuna);
        ruudut.SetTileMethod('t', LuoTaso);
        ruudut.SetTileMethod('A', LuoAse, new Vector(39, 13), "Kivääri", kivaarinkuva);
        ruudut.SetTileMethod('G', LuoAse, new Vector(42, 15), "Kranaatinheitin", kranaatinheittimenkuva);
        ruudut.SetTileMethod('S', LuoAse, new Vector(42, 10), "Haulikko", haulikonkuva);
        ruudut.SetTileMethod('M', LuoAse, new Vector(17, 12), "Magnum", magnumkuva);
        ruudut.SetTileMethod('R', LuoAse, new Vector(48, 15), "Raketinheitin", raketinheittimenkuva);
        ruudut.SetTileMethod('U', LuoAse, new Vector(42, 11), "Sniper", sniperinkuva);
        ruudut.SetTileMethod('1', delegate(Vector paikka, double leveys, double korkeus) { pelaaja1 = LuoPelaaja(paikka, leveys, korkeus, pelaaja1); });
        ruudut.SetTileMethod('2', delegate(Vector paikka, double leveys, double korkeus) { pelaaja2 = LuoPelaaja(paikka, leveys, korkeus, pelaaja2); });
        ruudut.Execute(RUUDUNLEVEYS, RUUDUNKORKEUS);
        Level.Background.CreateGradient(Color.White, Color.Gray);
        Gravity = new Vector(0, -1500);

        Timer timer = new Timer();
        timer.Interval = 0.1;
        timer.Timeout += delegate { TarkistaReunat(Level.Right - 1.5 * RUUDUNLEVEYS, Level.Top - 1.5 * RUUDUNKORKEUS); };
        timer.Start();
    }

    void LuoReuna(Vector paikka, double leveys, double korkeus)
    {
        PhysicsObject reuna = new PhysicsObject(leveys, korkeus);
        reuna.Position = paikka;
        reuna.Color = Color.Gray;
        reuna.Tag = "reuna";
        reuna.MakeStatic();
        Add(reuna);
    }

    void LuoTaso(Vector paikka, double leveys, double korkeus)
    {
        PhysicsObject taso = new PhysicsObject(leveys, korkeus);
        taso.Position = paikka;
        taso.Color = Color.Gray;
        taso.Tag = "taso";
        taso.MakeStatic();
        Add(taso);
    }


    void TarkistaReunat(double leveys, double korkeus)
    {
        if (pelaaja1.Position.X < -leveys) pelaaja1.Position = new Vector(-leveys, pelaaja1.Position.Y);
        if (pelaaja1.Position.X > leveys) pelaaja1.Position = new Vector(leveys, pelaaja1.Position.Y);
        if (pelaaja1.Position.Y < -korkeus) pelaaja1.Position = new Vector(pelaaja1.Position.X, -korkeus);
        if (pelaaja1.Position.Y > korkeus) pelaaja1.Position = new Vector(pelaaja1.Position.Y, korkeus);
        if (pelaaja2.Position.X < -leveys) pelaaja2.Position = new Vector(-leveys, pelaaja2.Position.Y);
        if (pelaaja2.Position.X > leveys) pelaaja2.Position = new Vector(leveys, pelaaja2.Position.Y);
        if (pelaaja2.Position.Y < -korkeus) pelaaja2.Position = new Vector(pelaaja2.Position.X, -korkeus);
        if (pelaaja2.Position.Y > korkeus) pelaaja2.Position = new Vector(pelaaja2.Position.Y, korkeus);
    }

    void LuoAlkuValikko()
    {
        ClearAll();
        NollaaLaskurit();
        MultiSelectWindow alkuValikko = new MultiSelectWindow("Kynäri",
        "Aloita peli", "Lopeta");
        Add(alkuValikko);
        alkuValikko.AddItemHandler(0, AloitaUusiPeli);
        alkuValikko.AddItemHandler(1, Exit);
        alkuValikko.DefaultCancel = 1;
        alkuValikko.Color = Color.Gray;
        Level.BackgroundColor = Color.Gray;
    }

    void luoTasot()
    {
        PhysicsObject alusta = new PhysicsObject(Level.Width, 300);
        alusta.Color = Color.Gray;
        alusta.X = 0;
        alusta.Y = Level.Bottom - alusta.Height / 2;
        Add(alusta);

        lisaaPieniTaso(-200, -350);
        lisaaPieniTaso(0, -400);
        lisaaPieniTaso(100, -300);
        lisaaPieniTaso(400, -350);
        lisaaPieniTaso(450, -200);
        lisaaPieniTaso(-500, -400);
        lisaaPieniTaso(-550, -200);
        lisaaPieniTaso(-400, -300);
        lisaaPieniTaso(-150, -150);
        lisaaPieniTaso(-870, -350);
        lisaaPieniTaso(-700, -400);

        lisaaPieniTaso(600, -300);
        lisaaPieniTaso(850, -300);
        lisaaPieniTaso(750, -400);
        lisaaPieniTaso(200, -200);
        lisaaPieniTaso(-200, -150);

        lisaaPystyTaso(600, -450);
        lisaaPystyTaso(-600, -500);
        lisaaPystyTaso(0, -450);

        lisaaReuna(-1375, 0);
        lisaaReuna(1375, 0);
    }

    void LisaaHPNaytot()
    {
        // luodaan elämänäyttö
        hpNaytto = new ProgressBar(250, 30);
        //hpNaytto.Angle = Angle.FromDegrees(90);
        hpNaytto.BarColor = Color.LightGreen;
        hpNaytto.Color = Color.Red;
        hpNaytto.BindTo(pelaaja1.HPLaskuri);
        hpNaytto.Position = new Vector(Screen.LeftSafe + 300, Screen.TopSafe - 170);
        Add(hpNaytto);

        hpNaytto2 = new ProgressBar(250, 30);
        //hpNaytto2.Angle = Angle.FromDegrees(90);
        hpNaytto2.BarColor = Color.LightGreen;
        hpNaytto2.Color = Color.Red;
        hpNaytto2.BindTo(pelaaja2.HPLaskuri);
        hpNaytto2.Position = new Vector(Screen.RightSafe - 300, Screen.TopSafe - 170);
        Add(hpNaytto2);
    }

    void LisaaLaskurit()
    {
        LuoPisteLaskuri(Screen.Left + 100.0, Screen.Top - 175.0, pelaajan1Pisteet);
        LuoPisteLaskuri(Screen.Right - 100.0, Screen.Top - 175.0, pelaajan2Pisteet);
        pelaajan1Pisteet.MaxValue = PISTEMAARA_JOLLA_VOITTAA_PELIN;
        pelaajan2Pisteet.MaxValue = PISTEMAARA_JOLLA_VOITTAA_PELIN;
        pelaajan1Pisteet.UpperLimit += delegate() { PelaajaVoittaa(pelaaja1, "Pelaaja 1", pelaaja2, pelaajan2Pisteet); };
        pelaajan2Pisteet.UpperLimit += delegate() { PelaajaVoittaa(pelaaja2, "Pelaaja 2", pelaaja1, pelaajan1Pisteet); };
    }

    void NollaaLaskurit()
    {
        pelaajan1Pisteet.Reset();
        pelaajan2Pisteet.Reset();
    }

    IntMeter LuoPisteLaskuri(double x, double y, IntMeter laskuri)
    {
        Label naytto = new Label();
        naytto.BindTo(laskuri);
        naytto.X = x;
        naytto.Y = y;
        Add(naytto);
        return laskuri;
    }

    void PelaajaVoittaa(Pelaaja voittaja, String voittajanNimi, Pelaaja haviaja, IntMeter haviajanPisteet)
    {
        MessageDisplay.Clear();
        if (voittaja.IsDestroying && haviajanPisteet.Value == haviajanPisteet.MaxValue)
        {
            MessageDisplay.Add("Tasapeli!");
        }
        else
        {
            MessageDisplay.Add(voittajanNimi + " voittaa!");
        }

    }

    //Vanha
    void Pelaaja1Voitti()
    {

        MessageDisplay.Clear();
        if (pelaaja1.IsDestroying && pelaajan2Pisteet.Value == pelaajan2Pisteet.MaxValue)
        {
            MessageDisplay.Add("Tasapeli!");
        }
        else
        {
            MessageDisplay.Add("Pelaaja 1 voittaa!");
        }
        MessageDisplay.X = 0;
    }

    //Vanha
    void Pelaaja2Voitti()
    {
        MessageDisplay.Clear();
        if (pelaaja2.IsDestroying && pelaajan1Pisteet.Value == pelaajan1Pisteet.MaxValue)
        {
            MessageDisplay.Add("Tasapeli!");
        }
        else
        {
            MessageDisplay.Add("Pelaaja 2 voittaa!");
        }
        MessageDisplay.X = 0;

    }

    void lisaaPieniTaso(double x, double y)
    {
        PhysicsObject taso = PhysicsObject.CreateStaticObject(100, 30, Shape.Rectangle);
        taso.Color = Color.Gray;
        taso.X = x;
        taso.Y = y;
        Add(taso);
    }

    void lisaaReuna(double x, double y)
    {
        PhysicsObject taso = PhysicsObject.CreateStaticObject(1000, 1000, Shape.Rectangle);
        taso.Color = Color.Gray;
        taso.X = x;
        taso.Y = y;
        Add(taso);
    }

    void lisaaPystyTaso(double x, double y)
    {
        PhysicsObject taso = PhysicsObject.CreateStaticObject(30, 100, Shape.Rectangle);
        taso.Color = Color.Gray;
        taso.X = x;
        taso.Y = y;
        Add(taso);
    }

    Pelaaja LuoPelaaja(Vector paikka, double leveys, double korkeus, Pelaaja pelaaja)
    {
        pelaaja = new Pelaaja(40, 40, Shape.Circle);
        pelaaja.Image = norsu;
        pelaaja.Position = paikka;
        pelaaja.Tag = "pelaaja";

        pelaaja.HPLaskuri = new DoubleMeter(100, 0, 100);
        pelaaja.HPLaskuri.MaxValue = 100;
        pelaaja.HPLaskuri.Value = 100;
        pelaaja.HPLaskuri.LowerLimit += delegate()
        {
            PelaajaKuoli(pelaaja);
        };
        Add(pelaaja);

        //lisaaAsePelaajalle(ase, pelaaja);
        PhysicsObject pistol = new PhysicsObject(16, 11);
        pistol.Image = pistoolinkuva;
        pistol.Tag = "Pistooli";

        LuoAsePelaajalle(pistol, pelaaja);
        return pelaaja;
    }

    void PelaajaKuoli(Pelaaja pelaaja)
    {
        if (pelaaja.IsDestroying)
        {
            return;
        }

        pelaaja.Destroy();
        PudotaAseenHahmo(pelaaja);
        MessageDisplay.Clear();
        MessageDisplay.X = 0;

        if (pelaaja == pelaaja1)
        {
            pelaajan2Pisteet.Value += 1;

            if (!(pelaajan1Pisteet.Value == pelaajan1Pisteet.MaxValue || pelaajan2Pisteet.Value == pelaajan2Pisteet.MaxValue))
            {
                if (pelaaja2.IsDestroying && pelaajan1Pisteet.Value != pelaajan1Pisteet.MaxValue)
                {
                    MessageDisplay.Clear();
                    MessageDisplay.Add("Erä tasan!");
                }
                else if (pelaajan1Pisteet.Value != pelaajan1Pisteet.MaxValue)
                {
                    MessageDisplay.Add("Pelaaja 2 voitti erän!");
                }

                Timer.SingleShot(3.0, AloitaUusiPeli);
            }
            else if (pelaajan2Pisteet.Value == pelaajan2Pisteet.MaxValue)
            {
                Pelaaja2Voitti();
                ClearTimers();
                Timer.SingleShot(3.0, LuoAlkuValikko);
            }
        }

        if (pelaaja == pelaaja2)
        {
            pelaajan1Pisteet.Value += 1;

            if (!(pelaajan2Pisteet.Value == pelaajan2Pisteet.MaxValue || pelaajan1Pisteet.Value == pelaajan1Pisteet.MaxValue))
            {
                if (pelaaja1.IsDestroying && pelaajan2Pisteet.Value != pelaajan2Pisteet.MaxValue)
                {
                    MessageDisplay.Clear();
                    MessageDisplay.Add("Erä tasan!");
                }
                else if (pelaajan1Pisteet.Value != pelaajan2Pisteet.MaxValue)
                {
                    MessageDisplay.Add("Pelaaja 1 voitti erän!");
                }

                Timer.SingleShot(3.0, AloitaUusiPeli);
            }
            else if (pelaajan1Pisteet.Value == pelaajan1Pisteet.MaxValue)
            {
                Pelaaja1Voitti();
                ClearTimers();
                Timer.SingleShot(3.0, LuoAlkuValikko);
            }
        }

    }

    void keraaAse(PhysicsObject ase, Pelaaja pelaaja)
    {
        if (!pelaaja.voikoPoimiaAseen) return;
        ase.Destroy();
        PudotaAseenHahmo(pelaaja); // tiputtaa asetta vastaavan fysiikkaolion maahan kerättäväksi uudestaan
        LuoAsePelaajalle(ase, pelaaja);
        naytaTiedot();
    }


    private void PudotaAseenHahmo(Pelaaja pelaaja)
    {
        if (pelaaja.Weapon == null) return;

        pelaaja.voikoPoimiaAseen = false;
        Timer.SingleShot(0.5, delegate { pelaaja.voikoPoimiaAseen = true; });
        String aseenTagi = pelaaja.Weapon.Tag.ToString();
        Vector koko = pelaaja.Weapon.Size;
        Vector paikka = pelaaja.Position;

        PhysicsObject tiputettuAse = new PhysicsObject(koko.X, koko.Y);
        tiputettuAse.Position = paikka;
        tiputettuAse.Tag = aseenTagi;
        tiputettuAse.CollisionIgnoreGroup = 1;
        pelaaja.CollisionIgnoreGroup = 1;
        Timer.SingleShot(1.0, delegate
        {
            tiputettuAse.CollisionIgnoreGroup = 0;
            pelaaja.CollisionIgnoreGroup = 0;
        });
        Add(tiputettuAse);
        tiputettuAse.Image = pelaaja.Weapon.Image;
        AddCollisionHandler<PhysicsObject, Pelaaja>(tiputettuAse, "pelaaja", keraaAse);

        pelaaja.Weapon = null;
    }

    void KranaattiOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if (ammus.IsDestroying) return;
        if (!(kohde is Pelaaja)) return;
        RajaytaKranaatti(ammus);

        Pelaaja pelaaja = (Pelaaja)kohde;
        ammus.Destroy();
        pelaaja.HPLaskuri.Value -= 25;
    }

    void RajaytaKranaatti(PhysicsObject ammus)
    {
        if (ammus.IsDestroying || ammus.IsDestroyed) return;
        Explosion rajahdys = new Explosion(100);
        rajahdys.Position = ammus.Position;
        rajahdys.ShockwaveReachesObject += delegate(IPhysicsObject p, Vector shokki) { PaineaaltoOsuu(p, shokki, rajahdys, 50.0); };
        Add(rajahdys);
        rajahdys.Force = 50;
        rajahdys.Speed = 1000;
        ammus.Destroy();
    }

    void RakettiOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if (ammus.IsDestroying) return;
        Explosion rajahdys = new Explosion(75);
        rajahdys.Position = ammus.Position;
        rajahdys.ShockwaveReachesObject += delegate(IPhysicsObject p, Vector shokki) { PaineaaltoOsuu(p, shokki, rajahdys, 40.0); };
        Add(rajahdys);
        rajahdys.Force = 50;
        rajahdys.Speed = 1000;

        ammus.Destroy(); // ei voi taata tapahtuuko tämä "heti". Siksi tarvitaan alkuun tarkistus, että onko ammus tuhoutumassa.
        if (!(kohde is Pelaaja)) return;
        Pelaaja pelaaja = (Pelaaja)kohde;
        pelaaja.HPLaskuri.Value -= 20;
    }

    void PaineaaltoOsuu(IPhysicsObject kohde, Vector shokki, Explosion e, double damagenMaara)
    {
        if (!(kohde is Pelaaja)) return;
        Pelaaja p = (Pelaaja)kohde;
        if (p.ViimeisinRajahdys == e) return;
        p.ViimeisinRajahdys = e;
        p.HPLaskuri.Value -= damagenMaara;
    }

    void AmmusOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if (ammus.IsDestroying) return;
        if (kohde.Tag.ToString() != "ammus") ammus.Destroy();
        if (!(kohde is Pelaaja)) return;
        Pelaaja p = (Pelaaja)kohde;
        p.HPLaskuri.Value -= 15;
    }

    void KivaariOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if (ammus.IsDestroying) return;
        if ((string)kohde.Tag != "ammus") ammus.Destroy();
        if (!(kohde is Pelaaja)) return;
        Pelaaja p = (Pelaaja)kohde;
        p.HPLaskuri.Value -= 10;
    }

    void SniperOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if (ammus.IsDestroying) return;
        if ((string)kohde.Tag != "ammus") ammus.Destroy();
        if (!(kohde is Pelaaja)) return;
        Pelaaja p = (Pelaaja)kohde;
        p.HPLaskuri.Value -= 80;
    }

    void MagnumOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if (ammus.IsDestroying) return;
        if ((string)kohde.Tag != "ammus") ammus.Destroy();
        if (!(kohde is Pelaaja)) return;
        Pelaaja p = (Pelaaja)kohde;
        p.HPLaskuri.Value -= 35;
    }

    void HaulikkoOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if (ammus.IsDestroying) return;
        if ((string)kohde.Tag != "ammus") ammus.Destroy();
        if (!(kohde is Pelaaja)) return;
        Pelaaja p = (Pelaaja)kohde;
        p.HPLaskuri.Value -= 13;
    }

    void LuoAse(Vector paikka, double leveys, double korkeus, Vector koko, String tagi, Image kuva)
    {
        PhysicsObject ase = new PhysicsObject(koko.X, koko.Y);
        ase.Position = paikka;
        ase.Tag = tagi;
        ase.Image = kuva;
        Add(ase);
        AddCollisionHandler<PhysicsObject, Pelaaja>(ase, "pelaaja", keraaAse);
    }


    /// <summary>
    /// 
    /// </summary>
    /// <param name="aseenHahmo">Fysiikkaolio, jonka perusteella laitetaan pelaajalle ase</param>
    /// <param name="pelaaja">Pelaaja jolle ase luodaan</param>
    /// <returns></returns>
    private void LuoAsePelaajalle(PhysicsObject aseenHahmo, Pelaaja pelaaja)
    {
        if (aseenHahmo == null) return;

        // Varsinainen ase
        Weapon ase = null;

        if (aseenHahmo.Tag.ToString() == "Kivääri")
        {
            ase = new AssaultRifle(39, 13);
            ase.FireRate = 7;
            ase.ProjectileCollision = KivaariOsui;
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(10);
            ase.Tag = "Kivääri";
            ase.Image = kivaarinkuva;
        }
        if (aseenHahmo.Tag.ToString() == "Magnum")
        {
            ase = new AssaultRifle(17, 12);
            ase.FireRate = 1.2;
            ase.ProjectileCollision = MagnumOsui;
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(10);
            ase.Tag = "Magnum";
            ase.Image = magnumkuva;

            // Paikka suhteessa pelaajaan
            ase.X = 10;
            ase.Y = 10;
        }

        if (aseenHahmo.Tag.ToString() == "Haulikko")
        {
            ase = new AssaultRifle(42, 10);
            ase.FireRate = 0.75;
            ase.ProjectileCollision = HaulikkoOsui;
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(0.4);
            ase.Tag = "Haulikko";
            ase.Image = haulikonkuva;
        }

        if (aseenHahmo.Tag.ToString() == "Sniper")
        {
            ase = new AssaultRifle(42, 11);
            ase.FireRate = 0.4;
            ase.ProjectileCollision = SniperOsui;
            ase.Power.Value = 400;
            ase.Power.DefaultValue = 400;
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(10);
            ase.Tag = "Sniper";
            ase.Image = sniperinkuva;
        }

        if (aseenHahmo.Tag.ToString() == "Kranaatinheitin")
        {
            ase = new Cannon(42, 15);
            ase.FireRate = 0.5;
            ase.ProjectileCollision = delegate(PhysicsObject ammus, PhysicsObject kohde) { KranaattiOsui(ammus, kohde); };
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(3);
            ase.Tag = "Kranaatinheitin";
            ase.Image = kranaatinheittimenkuva;
        }
        if (aseenHahmo.Tag.ToString() == "Raketinheitin")
        {
            ase = new AssaultRifle(48, 15);
            ase.FireRate = 0.5;
            ase.ProjectileCollision = delegate(PhysicsObject ammus, PhysicsObject kohde) { RakettiOsui(ammus, kohde); };
            ase.Power.Value = 125;
            ase.Power.DefaultValue = 125;
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(10);
            ase.Tag = "Raketinheitin";
            ase.Image = raketinheittimenkuva;
        }

        if (aseenHahmo.Tag.ToString() == "Pistooli")
        {
            ase = new AssaultRifle(16, 11);
            ase.FireRate = 2;
            ase.ProjectileCollision = AmmusOsui;
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(10);
            ase.Tag = "Pistooli";
            ase.Image = pistoolinkuva;
            ase.X = 10;
            ase.Y = 10;
        }

        pelaaja.Weapon = ase;
    }

    void lisaaAsePelaajalle(PhysicsObject ase, Pelaaja pelaaja)
    {
        Bullet luoti = new Bullet(1);
        PhysicsObject pistol = new PhysicsObject(16, 11);
        pistol.Image = pistoolinkuva;
        pistol.Tag = "Pistooli";

        LuoAsePelaajalle(ase, pelaaja);
    }

    #endregion


    #region Nappaimet
    // Lisää peliin kaikki näppäimet
    void lisaaNappaimet()
    {
        ClearControls();
        //Yleiset näppäimet
        Keyboard.Listen(Key.F1, ButtonState.Pressed, uusiPeli, "Aloittaa uuden pelin");

        // Pelaajan näppäimet
        Keyboard.Listen(Key.A, ButtonState.Down, liikuta, "Liikkuu vasemmalle", pelaaja1, new Vector(-LIIKEVOIMA, 0));
        Keyboard.Listen(Key.D, ButtonState.Down, liikuta, "Liikkuu oikealle", pelaaja1, new Vector(LIIKEVOIMA, 0));
        Keyboard.Listen(Key.W, ButtonState.Pressed, hyppaa, "Hyppää", pelaaja1, HYPPYVOIMA);
        Keyboard.Listen(Key.Space, ButtonState.Down, Ammu, "Ammu", pelaaja1);

        Keyboard.Listen(Key.Left, ButtonState.Down, liikuta, "Liikkuu vasemmalle", pelaaja2, new Vector(-LIIKEVOIMA, 0));
        Keyboard.Listen(Key.Right, ButtonState.Down, liikuta, "Liikkuu oikealle", pelaaja2, new Vector(LIIKEVOIMA, 0));
        Keyboard.Listen(Key.Up, ButtonState.Pressed, hyppaa, "Hyppää", pelaaja2, HYPPYVOIMA);
        Keyboard.Listen(Key.RightControl, ButtonState.Down, Ammu, "Ammu", pelaaja2);

        Keyboard.Listen(Key.Escape, ButtonState.Pressed, PeliPauselle, "Pysäyttää pelin");

        lisaaGamePadNappaimet(ControllerOne, pelaaja1);
        lisaaGamePadNappaimet(ControllerTwo, pelaaja2);
    }

    void lisaaGamePadNappaimet(GamePad pelaajaNro, PlatformCharacter pelaaja)
    {
        //Yleiset näppäimet
        pelaajaNro.Listen(Button.Start, ButtonState.Pressed, PeliPauselle, "Pysäyttää pelin");

        //pelaajaNro.ListenAnalog(AnalogControl.LeftStick, 0.1, liikuta, "Pelaaja liikkuu vasemmalle", pelaaja, new Vector(-LIIKEVOIMA, 0));
        //pelaajaNro.ListenAnalog(AnalogControl.LeftStick, 0.1, liikuta, "Pelaaja liikkuu vasemmalle", pelaaja, new Vector(-LIIKEVOIMA, 0));
        pelaajaNro.Listen(Button.DPadLeft, ButtonState.Down, liikuta, "Pelaaja liikkuu vasemmalle", pelaaja, new Vector(-LIIKEVOIMA, 0));
        pelaajaNro.Listen(Button.DPadRight, ButtonState.Down, liikuta, "Pelaaja liikkuu oikealle", pelaaja, new Vector(LIIKEVOIMA, 0));
        pelaajaNro.Listen(Button.A, ButtonState.Pressed, hyppaa, "Pelaaja hyppää", pelaaja, HYPPYVOIMA);
        pelaajaNro.Listen(Button.RightTrigger, ButtonState.Down, Ammu, "Ammu", pelaaja);
    }

    void PeliPauselle()
    {
        Pause();
        MultiSelectWindow PauseValikko = new MultiSelectWindow("Kynäri",
        "Jatka peliä", "Aloita peli alusta", "Päävalikko", "Lopeta");
        Add(PauseValikko);
        PauseValikko.AddItemHandler(0, Pause);
        PauseValikko.AddItemHandler(1, delegate { uusiPeli(); Pause(); });
        PauseValikko.AddItemHandler(2, delegate { LuoAlkuValikko(); Pause(); });
        PauseValikko.AddItemHandler(3, Exit);
        PauseValikko.DefaultCancel = 0;
        PauseValikko.Color = Color.Gray;
    }

    // Näppäimiin liitetyt toiminnot alkavat tästä -->
    void liikuta(PlatformCharacter hahmo, Vector voima)
    {
        hahmo.Walk(voima.X);
    }

    void naytaTiedot()
    {
        MessageDisplay.Clear();
        MessageDisplay.X = 0;
        if (pelaaja1.Weapon != null)
        {
            MessageDisplay.Add("Pelaaja 1: " + pelaaja1.Weapon.Tag);
        }
        if (pelaaja2.Weapon != null)
        {
            MessageDisplay.Add("Pelaaja 2: " + pelaaja2.Weapon.Tag);
        }
    }

    void Ammu(PlatformCharacter hahmo)
    {
        if (hahmo.IsDestroyed || !saaAmpua) return;
        PhysicsObject ammus = hahmo.Weapon.Shoot();
        if (ammus == null) return;

        ammus.Tag = "ammus";
        ammus.IgnoresCollisionResponse = true;
        ammus.IgnoresExplosions = true;

        if (hahmo.Weapon.Tag.ToString() == "Kranaatinheitin")
        {
            ammus.Image = kranaatinkuva;
            ammus.Size += new Vector(2, 1);
            Timer.SingleShot(2.0, delegate { RajaytaKranaatti(ammus); });
            ammus.IgnoresCollisionResponse = false;
            Timer.SingleShot(0.1, delegate { ammus.CollisionIgnorer = null; });
        }

        if ((string)hahmo.Weapon.Tag == "Raketinheitin")
        {
            ammus.Image = raketinkuva;
            ammus.Size += new Vector(3, 1);
            ammus.IgnoresCollisionResponse = false;
            Timer.SingleShot(0.1, delegate { ammus.CollisionIgnorer = null; });
        }
        if ((string)hahmo.Weapon.Tag == "Haulikko")
        {
            for (int i = 0; i < 5; i++)
            {
                PhysicsObject ammus2 = new PhysicsObject(ammus.Image);
                ammus2.IgnoresGravity = true;
                ammus2.Size = ammus.Size;
                ammus2.Position = ammus.Position;
                ammus2.Velocity = ammus.Velocity;
                ammus2.MaximumLifetime = TimeSpan.FromSeconds(0.4);
                ammus2.Hit(new Vector(RandomGen.NextDouble(-100, 100), RandomGen.NextDouble(-300, 300)));
                ammus2.CollisionIgnorer = ammus.CollisionIgnorer;
                ammus2.Tag = "ammus";
                ammus2.IgnoresCollisionResponse = true;
                ammus2.IgnoresExplosions = true;
                AddCollisionHandler(ammus2, HaulikkoOsui);
                Add(ammus2);
            }
        }
        Add(ammus);
    }

    void hyppaa(PlatformCharacter hahmo, double voima)
    {
        if (hahmo.Jump(voima)) hyppyAani.Play();
    }

    void uusiPeli()
    {
        NollaaLaskurit();
        AloitaUusiPeli();
    }
    #endregion


}