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

using System;

using Jypeli;
using Jypeli.Widgets;
using Jypeli.Assets;
using Jypeli.Controls;

public class Pelaaja : PlatformCharacter
{
    public bool voikoPoimiaAseen { 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("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");
    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(37, 19), "Kranaatinheitin", kranaatinheittimenkuva);
        ruudut.SetTileMethod('S', LuoAse, new Vector(39, 13), "Haulikko", haulikonkuva);
        ruudut.SetTileMethod('M', LuoAse, new Vector(17, 12), "Magnum", magnumkuva);
        ruudut.SetTileMethod('R', LuoAse, new Vector(48, 15), "Raketinheitin", raketinheittimenkuva);
        ruudut.SetTileMethod('1', delegate(Vector paikka, double leveys, double korkeus) { pelaaja1 = LuoPelaaja(paikka, leveys, korkeus, pelaaja1, hpLaskuri1); });
        ruudut.SetTileMethod('2', delegate(Vector paikka, double leveys, double korkeus) { pelaaja2 = LuoPelaaja(paikka, leveys, korkeus, pelaaja2, hpLaskuri2); });
        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.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.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(hpLaskuri1);
        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(hpLaskuri2);
        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, DoubleMeter hpLaskuri)
    {
        pelaaja = new Pelaaja(40, 40, Shape.Circle);
        pelaaja.Image = norsu;
        pelaaja.Position = paikka;
        pelaaja.Tag = "pelaaja";

        hpLaskuri.MaxValue = 100;
        hpLaskuri.Value = 100;
        hpLaskuri.LowerLimit += delegate() { 
            PelaajaKuoli(pelaaja); 
        };
        Add(pelaaja);

        Bullet luoti = new Bullet(1);
        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);
            }
        }

    }

    // Vanha
    void lisaaPelaajat()
    {
        pelaaja1 = new Pelaaja(40, 40, Shape.Circle);
        pelaaja1.Image = norsu;
        pelaaja1.X = -700;
        pelaaja1.Y = Level.Bottom + 50;
        pelaaja1.Tag = "pelaaja";

        pelaaja2 = new Pelaaja(40, 40, Shape.Circle);
        pelaaja2.Image = norsu;
        pelaaja2.X = 700;
        pelaaja2.Y = Level.Bottom + 50;
        pelaaja2.Tag = "pelaaja";

        hpLaskuri1.MaxValue = 100;
        hpLaskuri1.Value = 100;
        hpLaskuri1.LowerLimit += delegate() { PelaajaKuoli(pelaaja1); };

        hpLaskuri2.MaxValue = 100;
        hpLaskuri2.Value = 100;
        hpLaskuri2.LowerLimit += delegate() { PelaajaKuoli(pelaaja2); };

        Add(pelaaja1);
        Add(pelaaja2);
    }

    // Vanha
    void pelaaja1Kuoli()
    {
        if (pelaaja1.IsDestroying)
        {
            return;
        }

        pelaaja1.Destroy();
        PudotaAseenHahmo(pelaaja1);
        MessageDisplay.Clear();
        MessageDisplay.X = 0;
        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);
        }
    }

    // Vanha
    void pelaaja2Kuoli()
    {
        if (pelaaja2.IsDestroying)
        {
            return;
        }
        pelaaja2.Destroy();
        PudotaAseenHahmo(pelaaja2);
        //MessageDisplay.Clear();
        MessageDisplay.X = 0;
        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();
        if (pelaaja == pelaaja1)
        {
            PudotaAseenHahmo(pelaaja1); // tiputtaa asetta vastaavan fysiikkaolion maahan kerättäväksi uudestaan
            LuoAsePelaajalle(ase, pelaaja1);
        }

        if (pelaaja == pelaaja2)
        {
            PudotaAseenHahmo(pelaaja2); // tiputtaa vanhan aseen maahan
            LuoAsePelaajalle(ase, pelaaja2);
        }
        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 (kohde.Tag.ToString() == "pelaaja")
        {
            ammus.Destroy();
        }
    }

    void RakettiOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        ammus.Destroy();
    }

    void PaineaaltoOsuu(IPhysicsObject kohde, Vector shokki)
    {
        if (kohde == pelaaja1) { hpLaskuri1.Value -= 75; }
        if (kohde == pelaaja2) { hpLaskuri2.Value -= 75; }
    }

    void RaketinPaineaaltoOsuu(IPhysicsObject kohde, Vector shokki)
    {
        if (kohde == pelaaja1) { hpLaskuri1.Value -= 40; }
        if (kohde == pelaaja2) { hpLaskuri2.Value -= 40; }
    }

    void AmmusOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if ((string)kohde.Tag != "ammus")
        {
            ammus.Destroy();
        }

        if (kohde.Tag.ToString() == "pelaaja")
        {
            if (kohde == pelaaja1) { hpLaskuri1.Value -= 15; }
            if (kohde == pelaaja2) { hpLaskuri2.Value -= 15; }
        }
    }
    void KivaariOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if ((string)kohde.Tag != "ammus")
        {
            ammus.Destroy();
        }
        if (kohde.Tag.ToString() == "pelaaja")
        {
            if (kohde == pelaaja1) { hpLaskuri1.Value -= 10; }
            if (kohde == pelaaja2) { hpLaskuri2.Value -= 10; }
        }
    }
    void MagnumOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if ((string)kohde.Tag != "ammus")
        {
            ammus.Destroy();
        }
        if (kohde.Tag.ToString() == "pelaaja")
        {
            if (kohde == pelaaja1) { hpLaskuri1.Value -= 35; }
            if (kohde == pelaaja2) { hpLaskuri2.Value -= 35; }
        }
    }
    void HaulikkoOsui(PhysicsObject ammus, PhysicsObject kohde)
    {
        if ((string)kohde.Tag != "ammus")
        {
            ammus.Destroy();
        }

        if (kohde.Tag.ToString() == "pelaaja")
        {
            if (kohde == pelaaja1) { hpLaskuri1.Value -= 13; }
            if (kohde == pelaaja2) { hpLaskuri2.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(39, 13);
            ase.FireRate = 0.75;
            ase.ProjectileCollision = HaulikkoOsui;
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(0.4);
            ase.Tag = "Haulikko";
            ase.Image = haulikonkuva;
        }

        if (aseenHahmo.Tag.ToString() == "Kranaatinheitin")
        {
            ase = new Cannon(37, 19);
            ase.FireRate = 0.5;
            ase.ProjectileCollision = KranaattiOsui;
            ase.MaxAmmoLifetime = TimeSpan.FromSeconds(2);
            ase.Tag = "Kranaatinheitin";
            ase.Image = kranaatinheittimenkuva;
        }
        if (aseenHahmo.Tag.ToString() == "Raketinheitin")
        {
            ase = new PlasmaCannon(48, 15);
            ase.FireRate = 0.5;
            ase.ProjectileCollision = RakettiOsui;
            ase.Power.DefaultValue = 3000;
            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;
    }

    // Vanha
    void lisaaKerattavaAse()
    {
        //Täällä lisätään ase kenttään
        /*Bullet luoti = new Bullet(1);
        Bullet luoti2 = new Bullet(1);
        Bullet hauli = new Bullet(1);

        Grenade kranaatti = new Grenade(1);
        kranaatti.Explosion = new Explosion(20);
        */
        // kranaatti.ExplodeCondition = OnkoPelaaja; TODO: räjähtää kun osuu pelaajaan!

        PhysicsObject kivaari = new PhysicsObject(39, 13);
        kivaari.X = 200;
        kivaari.Y = -150;
        kivaari.Tag = "Kivääri";
        kivaari.Image = kivaarinkuva;
        Add(kivaari);

        PhysicsObject magnum = new PhysicsObject(17, 12);
        magnum.X = 0;
        magnum.Y = -350;
        magnum.Tag = "Magnum";
        magnum.Image = magnumkuva;
        Add(magnum);

        PhysicsObject haulikko = new PhysicsObject(39, 13);
        haulikko.X = -550;
        haulikko.Y = -150;
        haulikko.Tag = "Haulikko";
        haulikko.Image = haulikonkuva;
        Add(haulikko);

        PhysicsObject kranaatinheitin = new PhysicsObject(37, 19);
        kranaatinheitin.X = -180;
        kranaatinheitin.Y = -100;
        kranaatinheitin.Tag = "Kranaatinheitin";
        kranaatinheitin.Image = kranaatinheittimenkuva;
        Add(kranaatinheitin);

        //Lisää myös törmäyksen käsittelijä aseelle, jossa kutsutaan keraaAse -aliohjelmaa
        AddCollisionHandler<PhysicsObject, Pelaaja>(kivaari, "pelaaja", keraaAse);
        AddCollisionHandler<PhysicsObject, Pelaaja>(haulikko, "pelaaja", keraaAse);
        AddCollisionHandler<PhysicsObject, Pelaaja>(kranaatinheitin, "pelaaja", keraaAse);
        AddCollisionHandler<PhysicsObject, Pelaaja>(magnum, "pelaaja", keraaAse);
    }

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

        LuoAsePelaajalle(pistol1, pelaaja1);
        LuoAsePelaajalle(pistol1, pelaaja2);
    }

    #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.Enter, ButtonState.Down, Ammu, "Ammu", pelaaja2);

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

        Keyboard.Listen(Key.LeftShift, ButtonState.Pressed, Testi, "testi");

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

    void Testi()
    {
        MessageDisplay.Add("testi");
    }
    void lisaaGamePadNappaimet(GamePad pelaajaNro, PlatformCharacter pelaaja)
    {
        //Yleiset näppäimet
        //pelaajaNro.Listen(pelaajaNro, Button.Start, ButtonState.Pressed, uusiPeli, "Aloittaa uuden pelin");

        //pelaajaNro.Listen(pelaajaNro, Button.DPadLeft, ButtonState.Down, liikuta, "Pelaaja liikkuu vasemmalle", pelaaja, new Vector(-liikeVoima, 0));
        //pelaajaNro.Listen(pelaajaNro, Button.DPadRight, ButtonState.Down, liikuta, "Pelaaja liikkuu oikealle", pelaaja, new Vector(liikeVoima, 0));
        //pelaajaNro.Listen(pelaajaNro, Button.A, ButtonState.Pressed, hyppaa, "Pelaaja hyppää", pelaaja, hyppyVoima);
        //pelaajaNro.Listen(pelaajaNro, 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(e.Time, 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 == false)
        {
            return;
        }

        PhysicsObject ammus = hahmo.Weapon.Shoot();

        if (ammus != null)
        {
            ammus.Tag = "ammus";
            ammus.IgnoresCollisionResponse = true;
            ammus.IgnoresExplosions = true;

            if ((string)hahmo.Weapon.Tag == "Kranaatinheitin")
            {
                ammus.Destroying += delegate { KranaattiRajahdys(ammus); };
                ammus.IgnoresCollisionResponse = false;

                Timer.SingleShot(0.1, delegate { ammus.CollisionIgnorer = null; });
            }
            if ((string)hahmo.Weapon.Tag == "Raketinheitin")
            {
                ammus.Destroying += delegate { RakettiRajahdys(ammus); };
                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.CollisionIgnoreGroup = 2;
                    ammus2.CollisionIgnorer = ammus.CollisionIgnorer;
                    ammus2.Tag = "ammus";
                    ammus2.IgnoresCollisionResponse = true;
                    ammus2.IgnoresExplosions = true;
                    AddCollisionHandler(ammus2, HaulikkoOsui);
                    Add(ammus2);
                }
            }
            Add(ammus);
        }

        return;
    }

    void KranaattiRajahdys(PhysicsObject ammus)
    {
        Explosion rajahdys = new Explosion(100);
        rajahdys.Position = ammus.Position;
        rajahdys.AddShockwaveHandler("pelaaja", PaineaaltoOsuu);
        Add(rajahdys);
        rajahdys.Force = 100;
        rajahdys.Speed = 1000;
    }
    void RakettiRajahdys(PhysicsObject ammus)
    {
        Explosion rajahdys = new Explosion(50);
        rajahdys.Position = ammus.Position;
        rajahdys.AddShockwaveHandler("pelaaja", RaketinPaineaaltoOsuu);
        Add(rajahdys);
        rajahdys.Force = 100;
        rajahdys.Speed = 1000;
    }

    void hyppaa(PlatformCharacter hahmo, double voima)
    {
        //PlatformCharacter hahmo = e.Parameter0 as PlatformCharacter;
        //double voima = e.Parameter1.ToDouble();

        /* if (Math.Abs(hahmo.Velocity.Y) > 0.001)
         {
             return;
         }
         */

        if (hahmo.Jump(voima))
        {
            hyppyAani.Play();
        }
    }

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


}