source: 2012/kerho/vivevinu/trunk/Poing/Poing/Poing.cs @ 3900

using System;
using System.Collections.Generic;
using Jypeli;
using Jypeli.Assets;
using Jypeli.Controls;
using Jypeli.Effects;
using Jypeli.Widgets;
using System.IO;

public class Poing : PhysicsGame
{
    private const int HORIZONTAL_RADIUS = 900;
    private const int VERTICAL_RADIUS = 600;

    private static Image seitti = LoadImage("seitti");
    private static Image sydan = LoadImage("sydan");
    private static Image rajahdys = LoadImage("rajahdys");
    private static Image pilvi = LoadImage("pilvi");
    private static Image jaaPuikko = LoadImage("jaapuikko");
    private static Image[] aarreJaLahde = LoadImages("aarrearkku", "lahde");
    private static Image[] kolikkoKuvat = LoadImages("coinFront", "coinTurning1", "coinTurning2", "coinTurning3");
    private static Animation pyorivaKolikko;
    private static Image boost = LoadImage("boost");
    private static Image raketti = LoadImage("ohjus");
    private static Image kilpi = LoadImage("mystic");
    private static Image pelaajanKuva = LoadImage("tuliolio");
    private static Image tulipallo = LoadImage("tulipallo2");
    private static Image jaapallo = LoadImage("icebolt");
    private static Image tulipallo2 = LoadImage("firebolt");
    private static Image tulipallo3 = LoadImage("firebolt2");

    private Jumper pelaaja;
    private DoubleMeter omaHP;
    private double speed;
    private double jumpPower;
    private double maximumJumpPower = 3000;
    private List<Label> inventory = new List<Label>();

    private Shape icicleShape;
    private Timer apuAjastin;
    private int tasks;
    private const String TIEDOSTO = "Data.txt";

    private String tunnusGlob = "";
    private int profiili = -1;
    private bool lock2 = true;
    private bool lock3 = true;


    /// <summary>
    /// tehdaan lyhyet alkuvalmistelut (hiiri nakyville ja muoto talteen) ja siirrytaan aloitusvalikkoon
    /// </summary>
    public override void Begin()
    {
        IsMouseVisible = true;
        icicleShape = Shape.FromImage(jaaPuikko);
        Valikko();
    }


    /// <summary>
    /// luodaan aloitusvalikko, josta siirrytaan kenttiin, hallitaan profiileja ja katsotaan ohjeet
    /// </summary>
    public void Valikko()
    {
        pyorivaKolikko = new Animation(kolikkoKuvat[0], kolikkoKuvat[1], kolikkoKuvat[2], kolikkoKuvat[3], Image.Mirror(kolikkoKuvat[3]), Image.Mirror(kolikkoKuvat[2]), Image.Mirror(kolikkoKuvat[1]));
        Level.Background.CreateGradient(Color.Crimson, Color.DarkAzure);
        Label[] otsikko = LuoOtsikko();
        Label naytto = NaytaKirjautunut();

        String teksti2 = lock2 ? "2. kentta (locked)" : "2. kentta";
        String teksti3 = lock3 ? "3. kentta (locked)" : "3. kentta";
        MultiSelectWindow msw = new MultiSelectWindow("", "1. kentta", teksti2, teksti3, "kirjaudu sisaan", "luo tunnus", "ohjeet", "Poistu");
        msw.ItemSelected += delegate(int valittu)
        {
            apuAjastin = null;
            naytto.Destroy();
            foreach (Label kirjain in otsikko) kirjain.Destroy();
            switch (valittu)
            {
                case 0:
                    AloitaKentta1();
                    break;
                case 1:
                    if (lock2) Valikko();
                    else AloitaKentta2();
                    break;
                case 2:
                    if (lock3) Valikko();
                    else AloitaKentta3();
                    break;
                case 3:
                    KasitteleKirjautuminen();
                    break;
                case 4:
                    LuoTunnus();
                    break;
                case 5:
                    NaytaOhjeet();
                    break;
                default:
                    Exit();
                    break;
            }
        };
        msw.Y = -100;
        Add(msw);
    }


    /// <summary>
    /// kysytaan kayttajatunnus ja salasana, ja jos annetut sopivat yhteen niin siirrytaan ko. profiilille
    /// </summary>
    private void KasitteleKirjautuminen()
    {
        if (!File.Exists(TIEDOSTO))
        {
            MessageDisplay.Add("Profiileja ei ole luotu");
            Valikko();
            return;
        }
        FileStream tiedostovirta = new FileStream(TIEDOSTO, FileMode.Open);
        StreamReader virtaLukija = new StreamReader(tiedostovirta);

        List<String> tunnukset = new List<String>();
        List<String> salasanat = new List<String>();
        List<bool> locks2 = new List<bool>();
        List<bool> locks3 = new List<bool>();

        String rivi;
        while ((rivi = virtaLukija.ReadLine()) != null && rivi != "")
        {
            String[] data = rivi.Split(' ');
            tunnukset.Add(data[0]);
            salasanat.Add(data[1]);
            locks2.Add(bool.Parse(data[2]));
            locks3.Add(bool.Parse(data[3]));
        }
        virtaLukija.Close();

        InputWindow iw = new InputWindow("Syota kayttajatunnuksesi");
        iw.TextEntered += delegate
        {
            String tunnus = Encode(iw.InputBox.Text);
            if (tunnukset.Contains(tunnus))
            {
                int index = tunnukset.IndexOf(tunnus);
                String salasana = "";
                InputWindow iw2 = new InputWindow("Syota salasanasi");
                iw2.InputBox.TextChanged += delegate
                {
                    try
                    {
                        int lastIndex = iw2.InputBox.Text.Length - 1;
                        salasana += iw2.InputBox.Text[lastIndex];
                        iw2.InputBox.Text = iw2.InputBox.Text.Substring(0, lastIndex) + "*";
                    }
                    catch (IndexOutOfRangeException iore)
                    {
                        MessageDisplay.Add("Lue ohjeet");
                        iw2.Destroy();
                    }
                };
                iw2.TextEntered += delegate
                {
                    if (salasanat[index] == Encode(salasana))
                    {
                        lock2 = locks2[index];
                        lock3 = locks3[index];
                        profiili = index;
                        tunnusGlob = iw.InputBox.Text;
                    }
                    else MessageDisplay.Add("Salasana-tunnus-pari on kelvoton");
                    Valikko();
                };
                Add(iw2);
            }
            else
            {
                MessageDisplay.Add("Pyydetty tunnus ei ole olemassa");
                Valikko();
            }
        };
        Add(iw);
    }


    /// <summary>
    /// luodaan uusi kayttajatunnus
    /// </summary>
    private void LuoTunnus()
    {
        InputWindow iw = new InputWindow("Syota uusi kayttajatunnuksesi");
        iw.TextEntered += delegate
        {
            String tunnus = Encode(iw.InputBox.Text);
            if (tunnus.Length < 1)
            {
                iw.Destroy();
                Valikko();
                return;
            }
            int pituus = 0;
            if (File.Exists(TIEDOSTO))
            {
                FileStream tiedostovirta = new FileStream(TIEDOSTO, FileMode.Open);
                StreamReader virtaLukija = new StreamReader(tiedostovirta);

                List<String> tunnukset = new List<String>();
                List<String> salasanat = new List<String>();

                String rivi;
                while ((rivi = virtaLukija.ReadLine()) != null && rivi != "")
                {
                    String[] data = rivi.Split(' ');
                    tunnukset.Add(data[0]);
                    salasanat.Add(data[1]);
                    pituus++;
                }
                virtaLukija.Close();
                if (tunnukset.Contains(tunnus))
                {
                    MessageDisplay.Add("Tunnus on jo olemassa");
                    LuoTunnus();
                    return;
                }
            }

            String salasana = "";
            InputWindow iw2 = new InputWindow("Syota salasana");
            iw2.InputBox.TextChanged += delegate
            {
                try
                {
                    int lastIndex = iw2.InputBox.Text.Length - 1;
                    salasana += iw2.InputBox.Text[lastIndex];
                    iw2.InputBox.Text = iw2.InputBox.Text.Substring(0, lastIndex) + "*";
                }
                catch (IndexOutOfRangeException iore)
                {
                    MessageDisplay.Add("Lue ohjeet");
                    iw2.Destroy();
                }
            };
            iw2.TextEntered += delegate
            {
                if (salasana.Length < 4)
                {
                    MessageDisplay.Add("Vaaditaan pidempi salasana");
                    Valikko();
                    return;
                }
                FileStream tiedostovirta2;
                if (!File.Exists(TIEDOSTO))
                {
                    tiedostovirta2 = new FileStream(TIEDOSTO, FileMode.Create);
                    tiedostovirta2.Close();
                }
                FileStream tiedostovirta3 = new FileStream(TIEDOSTO, FileMode.Append);
                StreamWriter virtakirjoittaja = new StreamWriter(tiedostovirta3);
                virtakirjoittaja.WriteLine(tunnus + " " + Encode(salasana) + " true true");
                virtakirjoittaja.Close();

                tunnusGlob = iw.InputBox.Text;
                profiili = pituus;
                lock2 = true;
                lock3 = true;
                Valikko();
            };
            Add(iw2);
        };
        Add(iw);
    }


    /// <summary>
    /// luodaan naytto kuvaruudun vasempaan ylakulmaan, jossa on muuttujan tunnusGlob arvo.
    /// Paitsi jos tunnusBlob == "", jolloin nayton teksti on "Ei kirjauduttu"
    /// </summary>
    /// <returns>luotu naytto</returns>
    private Label NaytaKirjautunut()
    {
        Label naytto = new Label("Kirjautuneena: " + tunnusGlob);
        if (tunnusGlob == "") naytto.Text = "Ei kirjauduttu";
        naytto.TextScale = new Vector(1.5, 1.5);
        naytto.TextColor = Color.LightCyan;
        naytto.X = -500;
        naytto.Y = 350;
        Add(naytto);
        return naytto;
    }


    /// <summary>
    /// tuo nakyville lyhyet ohjeet pelia varten
    /// </summary>
    private void NaytaOhjeet()
    {
        MessageWindow mw = new MessageWindow("Ohjeita pelaamiseen:\nVoit liikkua ja hypata ollessasi tasolla sopivassa kulmassa nuolinappaimilla;\nVoit kaantya nappaimilla 1 ja 2;\nVoit ampua kirjoittamalla 'fire';\nKeratessasi tavaran ruudun vasempaan laitaan tulee teksti, jonka kirjoittamalla voit kayttaa tavaran\n\nOhjeita kayttajatunnuksiin:\nKun lapaiset kentan, seuraava aukeaa nykyiselle kayttajatunnukselle;\nKayttajatunnus ei saa olla tyhja,\nsalasanan on oltava vahintaan nelja (4) merkkia pitka;\nAla kayta erikoismerkkeja, salasanaa kirjoitettaessa merkkeja ei voi kumittaa (vaikka silta nayttaakin)");
        mw.Closed += delegate { Valikko(); };
        Add(mw);
    }


    /// <summary>
    /// muuttaa tekstijonoa
    /// </summary>
    /// <param name="koodattava">muutettava tekstijono</param>
    /// <returns>uusi tekstijono (koostuu numeroista)</returns>
    private String Encode(String koodattava)
    {
        String koodattu = "";
        for (int i = 0; i < koodattava.Length / 2; i++)
        {
            int kanta = koodattava[2 * i];
            for (int j = 0; j < 16; j++) kanta *= 2;
            kanta += koodattava[2 * i + 1];
            int seed = 1;
            for (int j = 0; j < koodattava[2 * i]; j++) seed = (3 * seed) % kanta;
            koodattu += seed.ToString();
            for (int j = 0; j < koodattava[2 * i + 1]; j++) seed = (3 * seed) % kanta;
            koodattu += seed.ToString();
        }
        if (koodattava.Length % 2 == 1) koodattu += ((int)koodattava[koodattava.Length - 1]).ToString();
        return koodattu;
    }


    /// <summary>
    /// luodaan kuvaruudun ylalaitaan otsikko "Poing", jossa kirjaimet hyppivat jaksollisesti.
    /// palautetaan otsikon kirjaimet taulukossa
    /// </summary>
    private Label[] LuoOtsikko()
    {
        Label[] otsikko = new Label[5];
        double size = 100;
        double korkeus = 300;

        otsikko[0] = LuoTeksti("P", new Vector(-2 * size, korkeus), size);
        otsikko[1] = LuoTeksti("o", new Vector(-size, korkeus), size);
        otsikko[2] = LuoTeksti("i", new Vector(0, korkeus), size);
        otsikko[3] = LuoTeksti("n", new Vector(size, korkeus), size);
        otsikko[4] = LuoTeksti("g", new Vector(2 * size, korkeus), size);

        int kirjainNro = 0;
        apuAjastin = new Timer();
        apuAjastin.Interval = 0.4;
        apuAjastin.Timeout += delegate
        {
            int kirjainNroNyt = kirjainNro;
            otsikko[kirjainNro].MoveTo(new Vector((kirjainNro - 2) * size, korkeus + size), 500, delegate
            {
                otsikko[kirjainNroNyt].MoveTo(new Vector((kirjainNroNyt - 2) * size, korkeus), 500);
            });
            kirjainNro = (kirjainNro + 1) % 5;
        };
        apuAjastin.Start();
        return otsikko;
    }

    /// <summary>
    /// luodaan Label, jossa annettu teksti ja palautetaan se
    /// </summary>
    /// <param name="sana">teksti</param>
    /// <param name="paikka">tekstin paikka kuvaruudulla</param>
    /// <param name="koko">Labelin koko, johon teksti asetetaan</param>
    /// <returns>luotu Label, jossa teksti</returns>
    private Label LuoTeksti(String sana, Vector paikka, double koko)
    {
        Label word = new Label(koko, koko, sana);
        word.Position = paikka;
        //word.Font = Font.DefaultLarge;
        //word.SizeMode = TextSizeMode.StretchText;
        word.TextScale = new Vector(7, 7);
        word.TextColor = Color.OrangeRed;
        Add(word);
        return word;
    }


    /// <summary>
    /// piirretaan kutistuvat merkit 3, 2, 1, GO! ;
    /// aikaa prosessiin kuluu 20 sekuntia
    /// </summary>
    private void Lahtolaskenta()
    {
        LahtolaskentaYksiKutistus("3", -300, 600);
        Timer.SingleShot(5, delegate { LahtolaskentaYksiKutistus("2", -300, 600); });
        Timer.SingleShot(10, delegate { LahtolaskentaYksiKutistus("1", -300, 600); });
        Timer.SingleShot(15, delegate { LahtolaskentaYksiKutistus("GO!", -900, 600); });
    }

    /// <summary>
    /// luodaan teksti joka kutistuu kuvaruudun kokoisesta pieneksi viiden (5) sekunnin kuluessa
    /// </summary>
    /// <param name="teksti">kutistettava teksti</param>
    /// <param name="x">tekstin x-koordinaatti (huom. ei toimi "tavallisesti")</param>
    /// <param name="y">teksitn y-koordinaatti (huom. ei toimi "tavallisesti")</param>
    private void LahtolaskentaYksiKutistus(String teksti, double x, double y)
    {
        Label _321GO = new Label(300, 300, teksti);
        _321GO.X = x;
        _321GO.Y = y;
        _321GO.TextColor = Color.Red;
        _321GO.TextScale = new Vector(50, 50);
        Add(_321GO);
        _321GO.MaximumLifetime = TimeSpan.FromSeconds(5);

        apuAjastin = new Timer();
        apuAjastin.Interval = 0.1;
        apuAjastin.Timeout += delegate
        {
            _321GO.TextScale *= 0.95;
            _321GO.Position *= 0.95;
        };
        apuAjastin.Start(50);
    }


    /// <summary>
    /// luodaan kenttapohja, pelaaja, viholiset, kerattavat esineet, ja asetataan kontrollit
    /// </summary>
    private void AloitaKentta1()
    {
        Camera.ZoomToLevel();
        LuoKentta1();
        Lahtolaskenta();
        tasks = 3;
        Timer.SingleShot(20, delegate
        {
            LuoPelaaja(100, 60, 1000, 1);
            LuoVihut1();
            AsetaKontrollit();

            LueSanat(new String[] { "fire", "burst", "heal" },
                new Action[] {
                new Action(delegate
                {
                    Vector voima = Vector.FromLengthAndAngle(500, pelaaja.Angle + Angle.RightAngle);
                    Ammu(pelaaja.Position + pelaaja.Height * voima.Normalize() / 2, voima); 
                }),
                new Action(delegate
                {
                    if (InventoryContains("burst"))
                    {
                        PaivitaVarastoa("burst", false);
                        Burst(9);
                        Timer.SingleShot(1.5, delegate { Burst(9); });
                    }
                    else MessageDisplay.Add("No bursts left");
                }),
                new Action(delegate
                
                {
                    if (InventoryContains("heal"))
                    {
                        PaivitaVarastoa("heal", false);
                        omaHP.Value = omaHP.MaxValue;
                    }
                    else MessageDisplay.Add("No heals left");
                })});

            apuAjastin = new Timer();
            apuAjastin.Interval = 7;
            apuAjastin.Timeout += delegate
            {
                if (RandomGen.NextInt(4) == 0) LuoKerattava("heal", sydan, Level.Bottom, Level.Top, Level.Left, Level.Right);
                if (RandomGen.NextInt(4) == 0) LuoKerattava("burst", rajahdys, Level.Bottom, Level.Top, Level.Left, Level.Right);
            };
            apuAjastin.Start();
        });
    }


    /// <summary>
    /// laittaa pelaajan ampumaan monta panosta kerrallaan (kerran)
    /// </summary>
    /// <param name="panoksia">kuinka monta panosta ammutaan</param>
    private void Burst(int panoksia)
    {
        Random rand = new Random();
        for (int i = 0; i < panoksia; i++)
        {
            Vector voima = Vector.FromLengthAndAngle(500, pelaaja.Angle + Angle.FromDegrees(rand.Next(160)));
            Ammu(pelaaja.Position + pelaaja.Height * voima.Normalize() / 2, voima);
        }
    }


    /// <summary>
    /// Luodaan kentta, joka sisaltaa:
    /// ellipsimuodostelmassa liikkuvat laatat;
    /// reunat, jotka tekevat kentasta topologisesti toroidin
    /// ts. siirtavat tormaajan toiselle puolelle kenttaa;
    /// painovoiman ja taustavarin
    /// </summary>
    private void LuoKentta1()
    {
        MovingLevel[] laatat = new MovingLevel[9];
        int l = laatat.Length;
        for (int i = 0; i < l; i++)
        {
            MovingLevel laatta = new MovingLevel(100, 20, 25);
            laatta.X = HORIZONTAL_RADIUS * Math.Cos(2 * Math.PI * i / l) / 2;
            laatta.Y = VERTICAL_RADIUS * Math.Sin(2 * Math.PI * i / l) / 2;
            laatta.Color = Color.Brown;
            Add(laatta);
            laatta.Angle = Angle.FromRadians(2 * Math.PI * (i - 1) / l + Math.PI / 6);
            laatta.Move(i, l, HORIZONTAL_RADIUS, VERTICAL_RADIUS);
            laatat[i] = laatta;
        }

        Gravity = new Vector(0, -300);
        Level.Background.CreateGradient(Color.White, Color.SkyBlue);

        #region reunat
        PhysicsObject ylareuna = PhysicsObject.CreateStaticObject(Screen.Width, 10);
        ylareuna.Color = new Color(0, 0, 0, 0);
        ylareuna.Y = Screen.Top + 30;
        ylareuna.IgnoresCollisionResponse = true;
        AddCollisionHandler(ylareuna, delegate(IPhysicsObject reuna, IPhysicsObject tormaaja)
        {
            tormaaja.Y = Screen.Bottom - 20 + Math.Max(tormaaja.Width, tormaaja.Height) / 2;
        });
        Add(ylareuna);

        PhysicsObject alareuna = PhysicsObject.CreateStaticObject(Screen.Width, 10);
        alareuna.Color = new Color(0, 0, 0, 0);
        alareuna.Y = Screen.Bottom - 30;
        alareuna.IgnoresCollisionResponse = true;
        AddCollisionHandler(alareuna, delegate(IPhysicsObject reuna, IPhysicsObject tormaaja)
        {
            tormaaja.Y = Screen.Top + 20 - Math.Max(tormaaja.Width, tormaaja.Height) / 2;
        });
        Add(alareuna);

        PhysicsObject oikeareuna = PhysicsObject.CreateStaticObject(10, Screen.Height);
        oikeareuna.Color = new Color(0, 0, 0, 0);
        oikeareuna.X = Screen.Right + 30;
        oikeareuna.IgnoresCollisionResponse = true;
        AddCollisionHandler(oikeareuna, delegate(IPhysicsObject reuna, IPhysicsObject tormaaja)
        {
            tormaaja.X = Screen.Left - 20 + Math.Max(tormaaja.Width, tormaaja.Height) / 2;
        });
        Add(oikeareuna);

        PhysicsObject vasenreuna = PhysicsObject.CreateStaticObject(10, Screen.Height);
        vasenreuna.Color = new Color(0, 0, 0, 0);
        vasenreuna.X = Screen.Left - 30;
        vasenreuna.IgnoresCollisionResponse = true;
        AddCollisionHandler(vasenreuna, delegate(IPhysicsObject reuna, IPhysicsObject tormaaja)
        {
            tormaaja.X = Screen.Right + 20 - Math.Max(tormaaja.Width, tormaaja.Height) / 2;
        });
        Add(vasenreuna);
        #endregion
    }


    /// <summary>
    /// luodaan pelaaja
    /// </summary>
    /// <param name="hp">pelaajalle annettavat elamapisteet</param>
    /// <param name="vauhti">liikkumisnopeus</param>
    private void LuoPelaaja(double hp, double vauhti, double hyppyvoima, int kentta)
    {
        pelaaja = new Jumper(30, 30, 1);
        pelaaja.Image = pelaajanKuva;
        Add(pelaaja);
        speed = vauhti;
        jumpPower = hyppyvoima;

        omaHP = new DoubleMeter(hp, 0, hp);
        omaHP.LowerLimit += delegate { Tappio(kentta); };
        Timer healer = new Timer();
        healer.Interval = 5;
        healer.Timeout += delegate { omaHP.AddValue(2); };
        healer.Start();

        LuoPalkkiNaytto(omaHP, "your health", new Vector(600, 250));
    }


    /// <summary>
    /// luodaan annettua mittaria nayttava palkki otsikolla
    /// </summary>
    /// <param name="mittari">mittari, joka esitetaan graafisesti palkilla</param>
    /// <param name="otsikko">palkin otsikko</param>
    /// <param name="paikka">paikka, johon palkki luodaan</param>
    /// <returns>palkki, johon mittari on sidottu</returns>
    private ProgressBar LuoPalkkiNaytto(DoubleMeter mittari, String otsikko, Vector paikka)
    {
        Label title = new Label(otsikko);
        title.TextColor = Color.DarkGreen;
        title.X = paikka.X;
        title.Y = paikka.Y + title.Height / 2;
        Add(title);

        ProgressBar palkki = new ProgressBar(60, 10);
        palkki.BindTo(mittari);
        palkki.X = paikka.X;
        palkki.Y = paikka.Y - palkki.Height / 2;
        palkki.Color = Color.White;
        palkki.BorderColor = Color.Black;
        palkki.BarColor = new Color((int)Math.Round(255 * (1 - mittari.Value / mittari.MaxValue)), (int)Math.Round(255 * mittari.Value / mittari.MaxValue), 0);
        mittari.Changed += delegate
        {
            palkki.BarColor = new Color((int)Math.Round(255 * (1 - mittari.Value / mittari.MaxValue)), (int)Math.Round(255 * mittari.Value / mittari.MaxValue), 0);
        };
        Add(palkki);

        Timer seuraa = new Timer();
        seuraa.Interval = 0.05;
        seuraa.Timeout += delegate { title.X = palkki.X; title.Y = palkki.Y + title.Height; };
        seuraa.Start();

        return palkki;
    }


    /// <summary>
    /// lopettaa kentan ja tuo esille valikon, josta voi siirtya eteenpain
    /// </summary>
    private void Tappio(int kentta)
    {
        ClearAll();
        Timer.SingleShot(0.1, delegate
        {
            ClearAll();
            MultiSelectWindow msw = new MultiSelectWindow("Havisit pelin :(", "yrita uudestaan", "palaa aloitusvalikkoon");
            msw.ItemSelected += delegate(int item)
            {
                if (item == 0)
                {
                    if (kentta == 1) AloitaKentta1();
                    if (kentta == 2) AloitaKentta2();
                    if (kentta == 3) AloitaKentta3();
                }
                if (item == 1) Valikko();
            };
            Add(msw);
        });
    }


    /// <summary>
    /// asetetaan "peruskontrollit" eli liikkuminen pelaajalle ja pelista poistuminen
    /// </summary>
    private void AsetaKontrollit()
    {
        Keyboard.Listen(Key.Left, ButtonState.Pressed, delegate { pelaaja.MoveOnLevel(speed); }, "kierra tasoa vastapaivaan");
        Keyboard.Listen(Key.Left, ButtonState.Released, pelaaja.MoveOnLevel, null, 0.0);
        Keyboard.Listen(Key.Right, ButtonState.Pressed, delegate { pelaaja.MoveOnLevel(-speed); }, "kierra tasoa myotapaivaan");
        Keyboard.Listen(Key.Right, ButtonState.Released, pelaaja.MoveOnLevel, null, 0.0);

        Keyboard.Listen(Key.Up, ButtonState.Pressed, delegate { pelaaja.Jump(Math.Min(jumpPower, maximumJumpPower)); }, "hyppaa");

        Keyboard.Listen(Key.D1, ButtonState.Down, pelaaja.Turn, "kaanny vastapaivaan", 1.0);
        Keyboard.Listen(Key.D1, ButtonState.Released, pelaaja.Turn, null, 0.0);
        Keyboard.Listen(Key.D2, ButtonState.Down, pelaaja.Turn, "kaanny myotapaivaan", -1.0);
        Keyboard.Listen(Key.D2, ButtonState.Released, pelaaja.Turn, null, 0.0);

        Keyboard.Listen(Key.Escape, ButtonState.Pressed, delegate
        {
            MultiSelectWindow valikko = new MultiSelectWindow("Peli jatkuu, valitse nopeasti :)", "jatka pelaamista", "palaa aloitusvalikkoon");
            valikko.ItemSelected += delegate(int item)
            {
                switch (item)
                {
                    case 0:
                        break;
                    case 1:
                        ClearAll();
                        Valikko();
                        break;
                }
            };
            Add(valikko);
        }, "palaa aloitusvalikkoon");
    }


    /// <summary>
    /// kirjoitettaessa tietty sana (vain kirjaimilla), niin tapahtuu
    /// tietty tapahtuma. sanaa kirjoitettaessa tulostetaan kirjaimet nakyville
    /// </summary>
    /// <param name="sanat">sanat, joihin liittyy tapahtuma (annettava yhta paljon kuin tapahtumia)</param>
    /// <param name="tapahtumat">tapahtumat, jotka on sidottu sanoihin (annettava yhta paljon kuin sanoja)</param>
    private void LueSanat(String[] sanat, Action[] tapahtumat)
    {
        int paikka = 0;
        List<String> mahdollisetSanat = new List<String>();
        foreach (String sana in sanat) mahdollisetSanat.Add(sana);

        Label naytto = new Label();
        naytto.Y = 350;
        naytto.TextColor = new Color(0, 0, 0, 100);
        Add(naytto);

        Keyboard.ListenAll(ButtonState.Pressed, delegate(Key painettu)
        {
            if (!Keyboard.IsChar(painettu) || Char.IsDigit(Keyboard.ToChar(painettu))) return;
            char merkki = Keyboard.ToChar(painettu);
            naytto.Text += merkki;
            for (int i = 0; i < mahdollisetSanat.Count; i++)
            {
                if (mahdollisetSanat[i][paikka] != merkki) mahdollisetSanat.RemoveAt(i--);
            }

            if (mahdollisetSanat.Count == 0)
            {
                mahdollisetSanat.Clear();
                foreach (String sana in sanat) mahdollisetSanat.Add(sana);
                naytto.Text = "";
                paikka = 0;
                return;
            }
            paikka++;
            for (int i = 0; i < mahdollisetSanat.Count; i++)
            {
                if (mahdollisetSanat[i].Length == paikka)
                {
                    tapahtumat[Array.IndexOf(sanat, mahdollisetSanat[i])]();

                    mahdollisetSanat.Clear();
                    foreach (String sana in sanat) mahdollisetSanat.Add(sana);
                    paikka = 0;
                    naytto.Text = "";
                    return;
                }
            }
        });
    }


    /// <summary>
    /// luodaan kentan 1 viholliset:
    /// 1) "perus" kohti tuleva ja hyokkaava vihu, jonka panoksista lisaksi jaa esteita
    /// 2) tasoilla liikkuva vihu, joka hyokkaa seka kaukaa, etta lahelta
    /// 3) melkolailla paikallaan pysyva vihu, joka voi vahingoittaa myos muita vihuja
    /// </summary>
    private void LuoVihut1()
    {
        Freezer kylmaVihu = LuoJaadyttaja(new Vector(600, -300), 65, 65, 13, "Freezer's health", 12, 600, 150);
        kylmaVihu.HP.LowerLimit += delegate { tasks--; if (tasks == 0) Voitto(1); };
        Add(kylmaVihu);
        Spider hamahakki = LuoHamahakki(2, new Vector(-180, 400), 50, 40, 10, "Spider's health", 24, 6, 600, 10);
        hamahakki.HP.LowerLimit += delegate { tasks--; if (tasks == 0) Voitto(1); };
        Add(hamahakki);
        LightningCaster ukkonen = LuoMyrskypilvi(new Vector(550, 300), 150, 80, 22, "Cloud's health", 20, 3, 600, 80);
        ukkonen.HP.LowerLimit += delegate { tasks--; if (tasks == 0) Voitto(1); };
        ukkonen.AddVulnerable(kylmaVihu);
        ukkonen.AddVulnerable(hamahakki);
        Add(ukkonen);
    }


    /// <summary>
    /// palauttaa (ei lisaa peliin) ilmassa liikkuvan vihollisen, joka hyokkaa kaukaa pelaajaan
    /// luoden samalla (liikkuvia) esteita
    /// </summary>
    /// <param name="paikka">mika annetaan paikaksi</param>
    /// <param name="leveys">leveys</param>
    /// <param name="korkeus">korkeus</param>
    /// <param name="hp">elamapisteet</param>
    /// <param name="hpPalkkiOtsikko">hp palkin otsikko</param>
    /// <param name="vahinko">vahinko osuessa pelaajaan</param>
    /// <param name="hpPalkkiX">hp palkin x-koordinaatti, jos NaN, niin seuraa vihollista</param>
    /// <param name="hpPalkkiY">hp palkin y-koordinaatti, jos NaN, niin seuraa vihollista</param>
    /// <param name="vauhti">nopeus, jolla vihollinen liikkuu</param>
    /// <returns>alustettu vihollinen</returns>
    private Freezer LuoJaadyttaja(Vector paikka, double leveys, double korkeus, double hp, String hpPalkkiOtsikko = "", double vahinko = 12, double hpPalkkiX = double.NaN, double hpPalkkiY = double.NaN, double vauhti = 50)
    {
        Freezer kylmaVihu = new Freezer(leveys, korkeus, hp, vauhti);
        kylmaVihu.Shape = Shape.Ellipse;
        kylmaVihu.Target = pelaaja;
        kylmaVihu.HitAction = delegate
        {
            omaHP.Value -= vahinko;
            speed /= 2;
            Timer.SingleShot(7, delegate { speed *= 2; });
        };
        kylmaVihu.IgnoresGravity = true;
        kylmaVihu.Position = paikka;
        kylmaVihu.Tag = "vihu";

        ProgressBar naytto = LuoPalkkiNaytto(kylmaVihu.HP, hpPalkkiOtsikko, Vector.Zero);
        if (double.IsNaN(hpPalkkiX) || double.IsNaN(hpPalkkiY))
        {
            naytto.Position = kylmaVihu.Position + new Vector(0, kylmaVihu.Height) - Camera.Position;
            Timer seuraa = new Timer();
            seuraa.Interval = 0.05;
            seuraa.Timeout += delegate { naytto.Position = kylmaVihu.Position + new Vector(0, kylmaVihu.Height) - Camera.Position; };
            seuraa.Start();
            kylmaVihu.HP.LowerLimit += delegate { seuraa.Stop(); };
        }
        else naytto.Position = new Vector(hpPalkkiX, hpPalkkiY);
        kylmaVihu.HP.LowerLimit += delegate { kylmaVihu.Destroy(); naytto.Destroy(); };
        return kylmaVihu;
    }

    /// <summary>
    /// palautetaan tasoilla liikkuva vihollinen, joka hyokkaa kaukaa ja lahelta pelaajaan
    /// </summary>
    /// <param name="id">CollisionIgnoreGroup, johon vihollinen ja taso, jolla ollaan siirtyvat</param>
    /// <param name="paikka">vihollisen paikka</param>
    /// <param name="leveys">leveys</param>
    /// <param name="korkeus">korkeus</param>
    /// <param name="hp">elemapisteet</param>
    /// <param name="hpPalkkiOtsikko">otsikko hpPalkille</param>
    /// <param name="lahiVahinko">lahelta tehtavassa iskussa tuotettava vahinko</param>
    /// <param name="kaukoVahinko">kaukaa tehtavassa iskussa tuotettava vahinko</param>
    /// <param name="hpPalkkiX">hp palkin x-koordinaatti, jos NaN, niin seuraa vihollista</param>
    /// <param name="hpPalkkiY">hp palkin y-koordinaatti, jos NaN, niin seuraa vihollista</param>
    /// <param name="vauhti">vauhti, jolla vihollinen liikkuu tasolla</param>
    /// <param name="regeneration">20 sekuntin valein lisattava hp maara</param>
    /// <returns>alustettu vihollinen</returns>
    private Spider LuoHamahakki(int id, Vector paikka, double leveys, double korkeus, double hp, String hpPalkkiOtsikko = "", double lahiVahinko = 24, double kaukoVahinko = 6, double hpPalkkiX = double.NaN, double hpPalkkiY = double.NaN, double vauhti = 80, double regeneration = 1)
    {
        Spider hamahakki = new Spider(leveys, korkeus, hp, id);
        hamahakki.Position = paikka;
        hamahakki.Target = pelaaja;
        hamahakki.Speed = vauhti;
        hamahakki.Mass = 100;
        hamahakki.Tag = "vihu";
        hamahakki.RangeHitAction = delegate
        {
            omaHP.Value -= kaukoVahinko;
            if (omaHP.Value > 0)
            {
                PhysicsObject net = new PhysicsObject(40, 40, Shape.Ellipse);
                net.Position = pelaaja.Position;
                net.Image = seitti;
                net.LinearDamping = 0.95;
                net.MaximumLifetime = TimeSpan.FromSeconds(8);
                Add(net);
                AxleJoint liitos = new AxleJoint(net, pelaaja);
                liitos.Softness = 10;
                Add(liitos);
                Timer.SingleShot(9, delegate { liitos.Destroy(); });
            }
        };
        hamahakki.MeleeHitAction = delegate
        {
            omaHP.Value -= lahiVahinko;
        };

        Timer healer = new Timer();
        healer.Interval = 20;
        healer.Timeout += delegate { hamahakki.HP.AddValue(regeneration); };
        healer.Start();
        ProgressBar naytto = LuoPalkkiNaytto(hamahakki.HP, hpPalkkiOtsikko, Vector.Zero);
        if (double.IsNaN(hpPalkkiX) || double.IsNaN(hpPalkkiY))
        {
            naytto.Position = hamahakki.Position + new Vector(0, hamahakki.Height) - Camera.Position;
            Timer seuraa = new Timer();
            seuraa.Interval = 0.05;
            seuraa.Timeout += delegate { naytto.Position = hamahakki.Position + new Vector(0, hamahakki.Height) - Camera.Position; };
            seuraa.Start();
            hamahakki.HP.LowerLimit += delegate { seuraa.Stop(); };
        }
        else naytto.Position = new Vector(hpPalkkiX, hpPalkkiY);
        hamahakki.HP.LowerLimit += delegate { hamahakki.Destroy(); healer.Stop(); naytto.Destroy(); };
        return hamahakki;
    }

    /// <summary>
    /// palauttaa melko paikallaan pysyvan vihollisen, joka hyokkaa kaukaa haarautvilla iskuilla kohti pelaajaa
    /// </summary>
    /// <param name="paikka">vihollisen paikka</param>
    /// <param name="leveys">leveys</param>
    /// <param name="korkeus">korkeus</param>
    /// <param name="hp">elamapisteet</param>
    /// <param name="hpPalkkiOtsikko">hp palkin otsikko</param>
    /// <param name="vahinko">vahinko pelaajaan</param>
    /// <param name="vihuVahinko">vahinko, jonka "vihu" tagilla varustetut vahingoittuvat kohteet karsivat</param>
    /// <param name="hpPalkkiX">hp palkin x-koordinaatti, jos NaN, niin seuraa vihollista</param>
    /// <param name="hpPalkkiY">hp palkin y-koordinaatti, jos NaN, niin seuraa vihollista</param>
    /// <param name="vauhti">nopeus, jolla vihollinen liikkuu</param>
    /// <returns>alustettu vihollinen</returns>
    private LightningCaster LuoMyrskypilvi(Vector paikka, double leveys, double korkeus, double hp, String hpPalkkiOtsikko = "", double vahinko = 20, double vihuVahinko = 3, double hpPalkkiX = double.NaN, double hpPalkkiY = double.NaN, double vauhti = 20)
    {
        LightningCaster ukkonen = new LightningCaster(leveys, korkeus, Shape.Ellipse, hp);
        ukkonen.Position = paikka;
        ukkonen.WantedPosition = paikka;
        ukkonen.IgnoresGravity = true;
        ukkonen.Tag = "vihu";
        ukkonen.Mass = 100;
        ukkonen.CanRotate = false;
        ukkonen.HitAction = delegate(IPhysicsObject kohde)
        {
            if (kohde == pelaaja) omaHP.Value -= vahinko;
            if (kohde.Tag == "vihu") Vahingoita(kohde, vihuVahinko);
        };

        ukkonen.Target = pelaaja;
        ukkonen.AddVulnerable(pelaaja);

        ProgressBar naytto = LuoPalkkiNaytto(ukkonen.HP, hpPalkkiOtsikko, Vector.Zero);
        if (double.IsNaN(hpPalkkiX) || double.IsNaN(hpPalkkiY))
        {
            naytto.Position = ukkonen.Position + new Vector(0, ukkonen.Height) - Camera.Position;
            Timer seuraa = new Timer();
            seuraa.Interval = 0.05;
            seuraa.Timeout += delegate { naytto.Position = ukkonen.Position + new Vector(0, ukkonen.Height) - Camera.Position; };
            seuraa.Start();
            ukkonen.HP.LowerLimit += delegate { seuraa.Stop(); };
        }
        else naytto.Position = new Vector(hpPalkkiX, hpPalkkiY);
        ukkonen.HP.LowerLimit += delegate { ukkonen.Destroy(); naytto.Destroy(); };
        return ukkonen;
    }


    /// <summary>
    /// vahingoittaa annettua objektia. tata voi kayttaa myos Spidereihin
    /// </summary>
    /// <param name="kohde">objekti, jota vahingoitetaan</param>
    /// <param name="vahinko">arvo, joka verran kohteen elamapisteita pienennetaan</param>
    private void Vahingoita(IPhysicsObject kohde, double vahinko)
    {
        HealthObject tmp1 = kohde as HealthObject;
        if (tmp1 != null) tmp1.HP.Value -= vahinko;
        Spider tmp2 = kohde as Spider;
        if (tmp2 != null) tmp2.HP.Value -= vahinko;
    }


    /// <summary>
    /// lopetetaan kentta ja luodaan valikko, josta voi jatkaa eteenpain
    /// </summary>
    private void Voitto(int kentta)
    {
        ClearAll();

        if (0 <= profiili && File.Exists(TIEDOSTO) && kentta < 3)
        {
            FileStream tiedostovirta = new FileStream(TIEDOSTO, FileMode.Open, FileAccess.ReadWrite);
            StreamReader virtalukija = new StreamReader(tiedostovirta);

            String sisalto = virtalukija.ReadToEnd();
            String[] rivit = sisalto.Split(new String[] { "\r\n" }, StringSplitOptions.None);
            String[] palat = rivit[profiili].Split(' ');
            if (kentta == 1)
            {
                rivit[profiili] = palat[0] + " " + palat[1] + " false " + palat[3];
                lock2 = false;
            }
            else
            {
                rivit[profiili] = palat[0] + " " + palat[1] + " " + palat[2] + " false";
                lock3 = false;
            }
            virtalukija.Close();

            tiedostovirta = new FileStream(TIEDOSTO, FileMode.Truncate);
            tiedostovirta.Close();
            tiedostovirta = new FileStream(TIEDOSTO, FileMode.Append);
            StreamWriter virtakirjoittaja = new StreamWriter(tiedostovirta);
            for (int i = 0; i < rivit.Length; i++) virtakirjoittaja.WriteLine(rivit[i]);
            virtakirjoittaja.Close();
        }

        Timer.SingleShot(0.1, delegate
        {
            ClearAll();
            MultiSelectWindow msw = new MultiSelectWindow("Lapaisit kentan :)", "jatka eteenpain", "aloita alusta", "palaa aloitusvalikkoon");
            msw.ItemSelected += delegate(int item)
            {
                if (item == 0)
                {
                    if (kentta == 1) AloitaKentta2();
                    if (kentta == 2) AloitaKentta3();
                    if (kentta == 3) ;
                }
                if (item == 1)
                {
                    if (kentta == 1) AloitaKentta1();
                    if (kentta == 2) AloitaKentta2();
                    if (kentta == 3) AloitaKentta3();
                }
                if (item == 2) Valikko();
            };
            Add(msw);
        });
    }


    /// <summary>
    /// luodaan kerattava esine satunnaisesti annetulle alueelle. kerattaessa esineen
    /// teksti lisataan pelaajan tavaroihin (inventory)
    /// </summary>
    /// <param name="name">tavaran teksti (jonka perusteella maaraytyy mitä tavaralla voi tehda)</param>
    /// <param name="kuva">kuva, joka annetaan kerattavalle tavaralle</param>
    /// <param name="bottom">luontialueen alaraja</param>
    /// <param name="top">luontialueen ylaraja</param>
    /// <param name="left">luontialueen vasen raja</param>
    /// <param name="right">luontialueen oikea raja</param>
    /// <param name="animaatio">tavaralle annettava animaatio</param>
    /// <param name="lifeTime">kuinka monen sekuntin kuluttu luonnista tavara viimeistaan tuhotaan</param>
    /// <param name="ig">jos true, niin tavaroihin ei vaikuta painovoima</param>
    private void LuoKerattava(String name, Image kuva, double bottom, double top, double left, double right, Animation animaatio = null, double lifeTime = 10, bool ig = true)
    {
        PhysicsObject item = new PhysicsObject(20, 20);
        item.Position = RandomGen.NextVector(left, bottom, right, top);
        item.IgnoresCollisionResponse = true;
        item.MaximumLifetime = TimeSpan.FromSeconds(lifeTime);
        item.IgnoresGravity = ig;
        if (animaatio == null) item.Image = kuva;
        else
        {
            item.Animation = animaatio;
            item.Animation.Start();
        }
        item.Oscillate(Vector.UnitX, 8, 1);
        UnlimitedAngle tmp = new UnlimitedAngle();
        tmp.Radians = Math.PI / 6;
        item.OscillateAngle(1, tmp, 1.4);
        Add(item);
        AddCollisionHandler(item, pelaaja, delegate
        {
            item.Destroy();
            PaivitaVarastoa(name, true);
        });
    }


    /// <summary>
    /// tonaistaan annettua oliota annetulla voimalla
    /// </summary>
    /// <param name="voima">voima (suuruus ja suunta), jolla oliota tonaistaan</param>
    /// <param name="liikkuja">olio, jota tonaistaan</param>
    private void Tonaise(Vector voima, PhysicsObject liikkuja)
    {
        liikkuja.Hit(voima);
    }


    /// <summary>
    /// luo panoksen, joka tormatessaan vahingoittaa objekteja, joilla on maaratty tagi
    /// </summary>
    /// <param name="paikka">paikka, josta ammus lahtee</param>
    /// <param name="voima">voima (suunta ja suuruus), jolla ammus ammutaan</param>
    /// <param name="noCollisionResponse">jos true, niin ammus voi kulkea esteiden lapi</param>
    /// <param name="tag">ammuksen mahdollisten kohteiden tagi</param>
    private void Ammu(Vector paikka, Vector voima, bool noCollisionResponse = false, String tag = "vihu")
    {
        PhysicsObject ammus = new PhysicsObject(15, 15);
        ammus.Position = paikka;
        ammus.MaximumLifetime = TimeSpan.FromSeconds(4);
        ammus.Image = tulipallo;
        Add(ammus);
        ammus.Hit(voima);
        AddCollisionHandler<PhysicsObject, HealthObject>(ammus, "vihu", delegate(PhysicsObject tama, HealthObject vihu) { vihu.HP.Value--; ammus.Destroy(); });
        AddCollisionHandler<PhysicsObject, Spider>(ammus, "vihu", delegate(PhysicsObject tama, Spider vihu) { vihu.HP.Value--; ammus.Destroy(); });
        AddCollisionHandler<PhysicsObject, Wizard>(ammus, "vihu", delegate(PhysicsObject tama, Wizard vihu) { ((HealthObject)vihu).HP.Value--; ammus.Destroy(); });
    }


    /// <summary>
    /// luo panoksen, joka tormatessaan vahingoittaa objekteja, joilla on maaratty tagi
    /// </summary>
    /// <param name="paikka">paikka, josta ammus lahtee</param>
    /// <param name="voima">voima (suunta ja suuruus), jolla ammus ammutaan</param>
    /// <param name="lifeTime">ammuksen elinaika</param>
    /// <param name="ammuksenKuva">ammuksen kuva</param>
    /// <param name="noCollisionResponse">jos true, niin ammus voi kulkea esteiden lapi</param>
    /// <param name="tag">ammuksen mahdollisten kohteiden tagi</param>
    private void Ammu(Vector paikka, Vector voima, Image ammuksenKuva, double lifeTime = 4, bool noCollisionResponse = false, String tag = "vihu")
    {
        PhysicsObject ammus = new PhysicsObject(15, 15);
        ammus.Position = paikka;
        ammus.MaximumLifetime = TimeSpan.FromSeconds(lifeTime);
        ammus.Image = ammuksenKuva;
        Add(ammus);
        ammus.Hit(voima);
        AddCollisionHandler<PhysicsObject, HealthObject>(ammus, "vihu", delegate(PhysicsObject tama, HealthObject vihu) { vihu.HP.Value--; ammus.Destroy(); });
        AddCollisionHandler<PhysicsObject, Spider>(ammus, "vihu", delegate(PhysicsObject tama, Spider vihu) { vihu.HP.Value--; ammus.Destroy(); });
        AddCollisionHandler<PhysicsObject, Wizard>(ammus, "vihu", delegate(PhysicsObject tama, Wizard vihu) { ((HealthObject)vihu).HP.Value--; ammus.Destroy(); });
    }


    /// <summary>
    /// kaantaa olion kulmaan siten, etta alapuoli osoittaa kulkusuuntaan
    /// </summary>
    /// <param name="olio">kaannettava objekti</param>
    public static void AsetaKulma(GameObject olio)
    {
        olio.Angle = Angle.FromRadians(olio.Position.Angle.Radians - Math.PI / 2);
    }


    /// <summary>
    /// palauttaa tiedon sisaltaako inventory ko. tekstin omaavan alkion
    /// </summary>
    /// <param name="name">teksti, jota etsitaan inventoryn alkioilta</param>
    /// <returns>onko inventoryssa alkio, jolla on etsitty teksti</returns>
    private bool InventoryContains(String name)
    {
        bool contains = false;
        foreach (Label item in inventory) contains |= item.Text == name;
        return contains;
    }


    /// <summary>
    /// lisataan tai poistetaan varastosta annetun niminen tavara
    /// </summary>
    /// <param name="name">lisattavan tai poistettavan tavaran nimi</param>
    /// <param name="lisaa">true = lisaa; false = poista</param>
    private void PaivitaVarastoa(String name, bool lisaa)
    {
        if (lisaa)
        {
            Label naytto = new Label(name);
            naytto.TextScale = 1.5 * Vector.Diagonal;
            naytto.TextColor = new Color(0, 0, 0, 150);
            naytto.X = -600;
            Add(naytto);
            inventory.Add(naytto);
        }
        else
        {
            for (int i = 0; i < inventory.Count; i++)
            {
                if (inventory[i].Text == name)
                {
                    inventory[i].Destroy();
                    inventory.RemoveAt(i);
                    break;
                }
            }
        }
        for (int i = 0; i < inventory.Count; i++)
        {
            inventory[i].Y = 100 * (3 - i);
        }
    }


    /// <summary>
    /// aloitetaan 2. kentta
    /// </summary>
    private void AloitaKentta2()
    {
        LuoPelaaja(100, 90, 800, 2);
        List<PhysicsObject> pilvet = LuoKentta2();
        AsetaKontrollit();
        LuoVihut2();
        tasks = 4;

        // kolikon tiputuspaikat
        Vector[] loppuPaikka = new Vector[] { new Vector(-1200, 460), new Vector(1200, 460) };
        String[] loppuPaikkaNimi = new String[] { "chest", "fountain" };
        int kumpi = RandomGen.NextInt(2);
        MessageDisplay.Clear();
        MessageDisplay.Add("Get a coin from the top level and drop it to the " + loppuPaikkaNimi[kumpi] + ". You'll need to do that four times so hurry up!");
        for (int i = 0; i < 2; i++)
        {
            PhysicsObject place = PhysicsObject.CreateStaticObject(80, 50);
            place.Position = loppuPaikka[i];
            place.Image = aarreJaLahde[i];
            place.Oscillate(Vector.UnitX, 10, 1);
            Add(place);
        }

        // aika, jossa suoritettava tehtavat
        double aika = 1000;
        Label naytto = new Label();
        DoubleMeter kello = new DoubleMeter(aika);
        naytto.BindTo(kello);
        kello.AddOverTime(-aika, aika, delegate { Tappio(2); });
        naytto.Position = new Vector(600, 350);
        Add(naytto);

        LueSanat(new String[] 
        {
            "fire", "dropcoin", "heal", "boost", "shield", "missile"
        }, new Action[]
        { 
            new Action(delegate
                {
                    Vector voima = Vector.FromLengthAndAngle(1000, pelaaja.Angle + Angle.RightAngle);
                    Ammu(pelaaja.Position + pelaaja.Height * voima.Normalize() / 2, voima); 
                }),
            new Action(delegate
                {
                    if (InventoryContains("dropcoin"))
                    {
                        if (Vector.Distance(pelaaja.Position, loppuPaikka[kumpi]) < 100)
                        {
                            PaivitaVarastoa("dropcoin", false);
                            tasks--;
                            if (tasks == 0) 
                            {
                                tasks = pilvet.Count;
                                kello.Stop();
                                MessageDisplay.Add("Well done! You shall be revarded at the top level - if you get there...");
                                VaihdaPilvet(pilvet.ToArray(), 0);
                                LuoFinaaliTavarat();
                                return;
                            }
                            LuoKerattava("dropcoin", null, 1600, 1610, -10, 10, pyorivaKolikko, 1000000000);
                            kumpi = RandomGen.NextInt(2);
                            MessageDisplay.Add("Get a coin from the top level and drop it to the " + loppuPaikkaNimi[kumpi]);
                        }
                        else MessageDisplay.Add("Drop your coin to the " + loppuPaikkaNimi[kumpi]);
                    }
                    else MessageDisplay.Add("You don't have a coin to drop");
                }),
            new Action(delegate
                {
                    if (InventoryContains("heal"))
                    {
                        PaivitaVarastoa("heal", false);
                        omaHP.Value = omaHP.MaxValue;
                    }
                    else MessageDisplay.Add("No heals left");
                }),
            new Action(delegate
                {
                    if (InventoryContains("boost"))
                    {
                        PaivitaVarastoa("boost", false);
                        speed *= 2;
                        jumpPower *= 3;
                        omaHP.AddOverTime(60, 30);
                        Timer.SingleShot(30, delegate { speed /= 2; jumpPower /= 3; });
                    }
                    else MessageDisplay.Add("No boosts left");
                }),
            new Action(delegate
                {
                    if (InventoryContains("shield"))
                    {
                        PaivitaVarastoa("shield", false);
                        PhysicsObject shield = new PhysicsObject(100, 100, Shape.Ellipse);
                        shield.Position = pelaaja.Position;
                        shield.IgnoresCollisionResponse = true;
                        shield.IgnoresGravity = true;
                        shield.Color = new Color(255, 0, 100, 150);
                        shield.Mass = 0.1;
                        shield.Tag = "shield";
                        Add(shield);
                        AxleJoint joint = new AxleJoint(shield, pelaaja);
                        Add(joint);
                        AddCollisionHandler<PhysicsObject, HealthObject>(shield, "vihu", delegate(PhysicsObject tama, HealthObject vihu){vihu.HP.Value = 0;});
                        AddCollisionHandler<PhysicsObject, Spider>(shield, "vihu", delegate(PhysicsObject tama, Spider vihu) { vihu.HP.Value = 0; });
                        AddCollisionHandler<PhysicsObject, PhysicsObject>(shield, "icicle", delegate(PhysicsObject tama, PhysicsObject jaa) { jaa.Destroy(); });
                        shield.MaximumLifetime = TimeSpan.FromSeconds(150);
                        double factor = 1000000;
                        omaHP.MaxValue *= factor;
                        omaHP.Value *= factor;
                        Timer.SingleShot(150, delegate
                        {
                            omaHP.Value /= factor;
                            omaHP.MaxValue /= factor;
                        });
                    }
                    else MessageDisplay.Add("No shields left");
                }),
            new Action(delegate
                {
                    if (InventoryContains("missile"))
                    {
                        PaivitaVarastoa("missile", false);
                        PhysicsObject ohjus = new PhysicsObject(50, 10);
                        ohjus.Image = raketti;
                        ohjus.IgnoresGravity = true;
                        ohjus.Position = pelaaja.Position + new Vector(0, 30);
                        Add(ohjus);
                        ohjus.Collided += delegate(IPhysicsObject tama, IPhysicsObject kohde)
                        {
                            if (kohde == pelaaja || kohde.Tag == "shield") return;
                            Explosion paineaalto = new Explosion(200);
                            paineaalto.Position = ohjus.Position;
                            ohjus.Destroy();
                            if (kohde.Tag == "vihu")
                            {
                                HealthObject tyypitetty = kohde as HealthObject;
                                if (tyypitetty != null) tyypitetty.HP.Value = 0;
                                else ((Spider)kohde).HP.Value = 0;
                            }
                            else if (kohde.Tag == "icicle") kohde.Destroy();
                            paineaalto.ShockwaveReachesObject += delegate(IPhysicsObject kohde2, Vector vektori)
                            {
                                if (kohde2.Tag == "vihu")
                                {
                                    HealthObject kohdeTyypitetty = kohde2 as HealthObject;
                                    if (kohdeTyypitetty != null) kohdeTyypitetty.HP.Value = 0;
                                    else ((Spider)kohde2).HP.Value = 0;
                                }
                                else if (kohde2.Tag == "icicle") kohde.Destroy();
                            };
                            Add(paineaalto);
                        };
                        Timer liiku = new Timer();
                        liiku.Interval = 0.5;
                        liiku.Timeout += delegate
                        {
                            Vector suunta = (Mouse.PositionOnWorld - ohjus.Position).Normalize(); 
                            ohjus.Velocity = 500 * (Mouse.PositionOnWorld - ohjus.Position).Normalize();
                            ohjus.Angle = suunta.Angle + Angle.StraightAngle;
                        };
                        liiku.Start();
                    }
                    else MessageDisplay.Add("No missiles left");
                })
        });

        // kerattavia esineita
        apuAjastin = new Timer();
        apuAjastin.Interval = 6;
        apuAjastin.Timeout += delegate
        {
            LuoKerattava("heal", sydan, -350, 1600, -1000, 1000);
            LuoKerattava("boost", boost, -350, 1600, -1000, 1000);
            if (RandomGen.NextInt(4) == 0) LuoKerattava("shield", kilpi, -350, 1600, -1000, 1000);
            if (RandomGen.NextInt(4) == 0) LuoKerattava("missile", raketti, 1000, 1600, -1000, 1000);
        };
        apuAjastin.Start();
    }


    /// <summary>
    /// luo kenttapohjan, jossa on erilaisia melko stationaarisia tasoja, joilla voi hyppia, ja
    /// laitetaan kamera seuraamaan pelaajaa
    /// </summary>
    private List<PhysicsObject> LuoKentta2()
    {
        Camera.Follow(pelaaja);
        Gravity = new Vector(0, -500);
        Level.Background.CreateGradient(Color.White, Color.SkyBlue);

        JumpingLevel pohja = new JumpingLevel(2000, 100);
        pohja.MakeStatic();
        pohja.Y = Level.Bottom;
        pohja.Color = Color.Brown;
        Add(pohja);
        PhysicsObject seina1 = PhysicsObject.CreateStaticObject(2000, 50);
        seina1.X = 1500;
        seina1.Y = 500 * Math.Sqrt(3) + Level.Bottom;
        seina1.Angle = Angle.FromRadians(Math.PI / 3);
        seina1.Color = Color.Brown;
        Add(seina1);
        PhysicsObject seina2 = PhysicsObject.CreateStaticObject(2000, 50);
        seina2.X = -1500;
        seina2.Y = 500 * Math.Sqrt(3) + Level.Bottom;
        seina2.Angle = Angle.FromRadians(2 * Math.PI / 3);
        seina2.Color = Color.Brown;
        Add(seina2);

        List<PhysicsObject> pilviLaatat = new List<PhysicsObject>();
        for (int i = -9; i < 10; i++)
        {
            if (i == 0) continue;
            JumpingLevel laatta = new JumpingLevel(150, 30);
            Vector paikka = new Vector(130 * i, -350 + 80 * Math.Abs(i));
            laatta.Position = paikka;
            laatta.IgnoresGravity = true;
            laatta.Image = pilvi;
            AxleJoint joint = new AxleJoint(laatta, paikka);
            joint.Softness = 4;
            Add(joint);
            laatta.Mass = 80;
            Add(laatta);
            pilviLaatat.Add(laatta);
        }
        MessageDisplay.Add(pelaaja.Mass.ToString());

        for (int i = 0; i < 10; i++)
        {
            JumpingLevel laatta = new JumpingLevel(70, 35 * Math.Sqrt(3), Shape.Triangle);
            if (i % 2 == 0) laatta.X = 200;
            else laatta.X = -200;
            laatta.Y = 120 * (i + 1);
            laatta.MakeStatic();
            laatta.AngularVelocity = 0.5;
            laatta.Color = RandomGen.NextColor();
            Add(laatta);
        }

        JumpingLevel katto = new JumpingLevel(500, 70);
        katto.Y = 1500;
        katto.MakeStatic();
        katto.Color = Color.Silver;
        Add(katto);
        bool exists = false;
        AddCollisionHandler(katto, pelaaja, delegate
        {
            if (!exists)
            {
                Spider hamahakki = LuoHamahakki(1, RandomGen.NextVector(-200, 1580, 200, 1600), 50, 40, 10);
                hamahakki.HP.LowerLimit += delegate { exists = false; };
                Add(hamahakki);
                exists = true;
            }
        });

        LuoKerattava("dropcoin", null, 1600, 1610, -10, 10, pyorivaKolikko, 1000000000);
        return pilviLaatat;
    }


    /// <summary>
    /// luodaan osa 2. kentan vihollisista siis jaadyttajia pienin aikavalein
    /// </summary>
    private void LuoVihut2()
    {
        Timer lisaaVihuja = new Timer();
        lisaaVihuja.Interval = 120;
        lisaaVihuja.Timeout += delegate { Add(LuoJaadyttaja(RandomGen.NextVector(-1000, 800, 1000, 2000), 60, 60, 3, "", 7)); };
        lisaaVihuja.Start();
    }


    /// <summary>
    /// Vaihdetaan hitaasti kaikki pilvet taulukon alkiot vihollisiksi. Naiden tappamisesta tehtavat vahenevat (siis tasks--).
    /// </summary>
    /// <param name="pilvet">fysiikkaoliot, jotka muutetaan vihollisiki</param>
    /// <param name="index">aloitusindeksi, aloitetaan seka alusta etta lopusta</param>
    private void VaihdaPilvet(PhysicsObject[] pilvet, int index)
    {
        if (pilvet.Length <= 2 * index) return;
        VaihdaPilvetApu(pilvet[index]);
        VaihdaPilvetApu(pilvet[pilvet.Length - index - 1]);
        Timer.SingleShot(15, delegate { VaihdaPilvet(pilvet, index + 1); });
    }

    /// <summary>
    /// vaihdetaan annettu fysiikkaolio vihollisolioksi (siis tuhotaan annettu olio ja luodaan uusi)
    /// </summary>
    /// <param name="pilvi">vahdettava (tuhottava) olio</param>
    private void VaihdaPilvetApu(PhysicsObject pilvi)
    {
        LightningCaster ukkospilvi = LuoMyrskypilvi(pilvi.Position, pilvi.Width, pilvi.Height, 11);
        ukkospilvi.WantedPosition = new Vector(0, 1700);
        ukkospilvi.Speed = 5;
        ukkospilvi.Angle = pilvi.Angle;
        ukkospilvi.HP.LowerLimit += delegate { tasks--; if (tasks == 0) Voitto(2); };
        Add(ukkospilvi);
        pilvi.Destroy();
    }


    /// <summary>
    /// luodaan 2. kentassa tavaroita ylatasolle
    /// </summary>
    private void LuoFinaaliTavarat()
    {
        for (int i = 0; i < 5; i++) LuoKerattava("missile", raketti, 1580, 1590, -200, 200, null, 1000000);
        for (int i = 0; i < 3; i++) LuoKerattava("heal", sydan, 1580, 1590, -200, 200, null, 1000000);
        LuoKerattava("shield", kilpi, 1580, 1590, -200, 200, null, 1000000);
    }


    /// <summary>
    /// aloitetaan 3. kentta
    /// </summary>
    private void AloitaKentta3()
    {
        LuoPelaaja(100, 90, 800, 3);
        LuoKentta3();
        AsetaKontrollit();
        LuoVihut3();

        LueSanat(new String[] { "fire", "heal", "boost", "autofire", "flamebolt" }, new Action[] 
        {
            new Action(delegate
                {
                    Vector voima = Vector.FromLengthAndAngle(1000, pelaaja.Angle + Angle.RightAngle);
                    Ammu(pelaaja.Position + pelaaja.Height * voima.Normalize() / 2, voima); 
                }),
            new Action(delegate
                {
                    if (InventoryContains("heal"))
                    {
                        PaivitaVarastoa("heal", false);
                        omaHP.Value = omaHP.MaxValue;
                    }
                    else MessageDisplay.Add("No heals left");
                }),
            new Action(delegate
                {
                    if (InventoryContains("boost"))
                    {
                        PaivitaVarastoa("boost", false);
                        speed *= 2;
                        jumpPower *= 3;
                        omaHP.AddOverTime(60, 30);
                        Timer.SingleShot(30, delegate { speed /= 2; jumpPower /= 3; });
                    }
                    else MessageDisplay.Add("No boosts left");
                }),
            new Action(delegate
                {
                    if (InventoryContains("autofire"))
                    {
                        PaivitaVarastoa("autofire", false);
                        Timer fire = new Timer();
                        fire.Interval = 2;
                        fire.Timeout += delegate { Ammu(pelaaja.Position, 800 * (Mouse.PositionOnWorld - pelaaja.Position).Normalize(), tulipallo2, 2, true); };
                        fire.Start(30);
                    }
                    else MessageDisplay.Add("No autofires left");
                }), 
            new Action(delegate
                {
                    if (InventoryContains("flamebolt"))
                    {
                        PaivitaVarastoa("flamebolt", false);
                        PhysicsObject flamebolt = new PhysicsObject(200, 150);
                        flamebolt.Position = pelaaja.Position;
                        flamebolt.Image = tulipallo3;
                        flamebolt.IgnoresGravity = true;
                        flamebolt.IgnoresCollisionResponse = true;
                        flamebolt.MaximumLifetime = TimeSpan.FromSeconds(10);
                        Add(flamebolt);
                        AddCollisionHandler(flamebolt, "vihu", delegate(IPhysicsObject bolt, HealthObject vihu) { vihu.HP.Value -= 10; });
                        AddCollisionHandler(flamebolt, "vihu", delegate(IPhysicsObject bolt, Wizard vihu) { ((HealthObject)vihu).HP.Value -= 10; });
                        AddCollisionHandler(flamebolt, "icicle", delegate(IPhysicsObject bolt, IPhysicsObject jaapuikko) { jaapuikko.Destroy(); });
                        AddCollisionHandler(flamebolt, "icelevel", delegate(IPhysicsObject bolt, IPhysicsObject jaataso) { jaataso.Destroy(); });
                        AddCollisionHandler(flamebolt, "teleport", delegate(IPhysicsObject bolt, IPhysicsObject teleportti) { teleportti.Destroy(); });
                        flamebolt.Angle = pelaaja.Angle + Angle.RightAngle;
                        flamebolt.Hit(Vector.FromLengthAndAngle(500, pelaaja.Angle + Angle.RightAngle));
                    }
                    else MessageDisplay.Add("No flamebolts left");
                })
        });

        apuAjastin = new Timer();
        apuAjastin.Interval = 5;
        apuAjastin.Timeout += delegate
        {
            LuoKerattava("heal", sydan, Level.Bottom + 50, 1500, -1000, 1000);
            if (RandomGen.NextInt(2) == 0) LuoKerattava("boost", boost, Level.Bottom + 50, 900, -1000, 1000);
            if (RandomGen.NextInt(5) == 0) LuoKerattava("autofire", tulipallo2, 1000, 2000, -1500, 1500);
            if (RandomGen.NextInt(6) == 0) LuoKerattava("flamebolt", tulipallo, 1000, 2000, -1500, 1500);
        };
        apuAjastin.Start();
    }


    /// <summary>
    /// luodaan 3. kentan pohja eli pohjataso (jolla voi liikkua) ja pitkat ulospain vinot reunat (joilla ei voi liikkua)
    /// </summary>
    private void LuoKentta3()
    {
        Camera.Follow(pelaaja);
        Gravity = new Vector(0, -500);
        Level.Background.CreateGradient(Color.White, Color.SkyBlue);

        JumpingLevel pohja = new JumpingLevel(2000, 100);
        pohja.Y = Level.Bottom;
        pohja.Color = Color.Brown;
        pohja.MakeStatic();
        Add(pohja);

        PhysicsObject reuna = PhysicsObject.CreateStaticObject(2000, 50);
        reuna.X = -1500;
        reuna.Y = Level.Bottom + 500 * Math.Sqrt(3);
        reuna.Angle = Angle.FromRadians(2 * Math.PI / 3);
        reuna.Color = Color.Brown;
        Add(reuna);

        reuna = PhysicsObject.CreateStaticObject(2000, 50);
        reuna.X = 1500;
        reuna.Y = Level.Bottom + 500 * Math.Sqrt(3);
        reuna.Angle = Angle.FromRadians(Math.PI / 3);
        reuna.Color = Color.Brown;
        Add(reuna);

        reuna = PhysicsObject.CreateStaticObject(2000, 50);
        reuna.X = -2500;
        reuna.Y = Level.Bottom + 1500 * Math.Sqrt(3);
        reuna.Angle = Angle.FromRadians(2 * Math.PI / 3);
        reuna.Color = Color.Brown;
        Add(reuna);

        reuna = PhysicsObject.CreateStaticObject(2000, 50);
        reuna.X = 2500;
        reuna.Y = Level.Bottom + 1500 * Math.Sqrt(3);
        reuna.Angle = Angle.FromRadians(Math.PI / 3);
        reuna.Color = Color.Brown;
        Add(reuna);

        reuna = PhysicsObject.CreateStaticObject(2000, 50);
        reuna.X = -3500;
        reuna.Y = Level.Bottom + 2500 * Math.Sqrt(3);
        reuna.Angle = Angle.FromRadians(2 * Math.PI / 3);
        reuna.Color = Color.Brown;
        Add(reuna);

        reuna = PhysicsObject.CreateStaticObject(2000, 50);
        reuna.X = 3500;
        reuna.Y = Level.Bottom + 2500 * Math.Sqrt(3);
        reuna.Angle = Angle.FromRadians(Math.PI / 3);
        reuna.Color = Color.Brown;
        Add(reuna);
    }


    /// <summary>
    /// luodaan 3. kentan vihollisia siis yksi velho paavastukseksi ja sen loitsuista lisaa voihollisia
    /// </summary>
    private void LuoVihut3()
    {
        Wizard boss = new Wizard(40, 60, 50);
        boss.X = -100;
        boss.Y = Level.Bottom + 80;
        boss.Tag = "vihu";
        boss.Target = pelaaja;
        LuoPalkkiNaytto(((HealthObject)boss).HP, "Wizard's health", new Vector(600, 150));
        ((HealthObject)boss).HP.LowerLimit += delegate { Voitto(3); };
        boss.AddSpell(delegate
        {
            LightningCaster ukkonen = LuoMyrskypilvi(boss.Position + new Vector(0, 80), 100, 60, 9, "", 14);
            ukkonen.Wanders = true;
            Add(ukkonen);
            Timer sade = new Timer();
            sade.Interval = 20;
            sade.Timeout += delegate { Add(LuoJaadyttaja(ukkonen.Position + new Vector(0, -45), 30, 30, 3, "", 7)); };
            sade.Start();
            ukkonen.HP.LowerLimit += delegate { sade.Stop(); };
        }, 15, 500);
        boss.AddSpell(delegate
        {
            GameObject[] icebolts = new GameObject[4];
            for (int i = 0; i < 4; i++)
            {
                icebolts[i] = new GameObject(400, 100);
                icebolts[i].Image = jaapallo;
                icebolts[i].Position = Vector.FromLengthAndAngle(500, Angle.FromRadians(Math.PI * (1 + 2 * i) / 4));
                icebolts[i].Angle = Angle.FromRadians(Math.PI * (5 + 2 * i) / 4);
                pelaaja.Add(icebolts[i]);
            }
            Timer liike = new Timer();
            liike.Interval = 0.1;
            liike.Timeout += delegate
            {
                for (int i = 0; i < 4; i++)
                {
                    icebolts[i].Size *= 0.92;
                    icebolts[i].Position *= 0.9;
                }
            };
            liike.Start(20);
            Timer.SingleShot(2, delegate
            {
                for (int i = 0; i < 4; i++) icebolts[i].Destroy();
                omaHP.Value -= 20;
                PhysicsObject icicle = new PhysicsObject(jaaPuikko);
                icicle.Shape = icicleShape;
                icicle.Position = pelaaja.Position + new Vector(0, -200);
                icicle.MaximumLifetime = TimeSpan.FromSeconds(40);
                icicle.Tag = "icicle";
                Add(icicle, -1);
                Timer.SingleShot(20, delegate
                {
                    Timer sula = new Timer();
                    sula.Interval = 0.1;
                    sula.Timeout += delegate { icicle.Size *= 0.982; };
                    sula.Start(200);
                });
            });
        }, 15);
        Add(boss);
    }
}