source: 2015/23/ohjaajat/ValasPeli/ValasPeli/ValasPeli/ValasPeli.cs @ 7033

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

/// <summary>
/// Neljä hämmentynyttä, jalkansa katkaissutta sukeltajaa tutkii
/// merenpohjaa ja törmää satunnaisiin taivasvalaisiin. 
/// Lopulta kolme tukehtuu tai vajoaa pohjaan.
/// </summary>
public class ValasPeli : PhysicsGame
{
    const double nopeus = 200;
    const double hyppyNopeus = 750;
    int pelaajiaLisatty = 0;

    Image taysi = LoadImage("taysi");
    Image tyhja = LoadImage("tyhja");
    Image pohjaMoskaKuva = LoadImage("pohjamoska");
    Image menuKuva = LoadImage("menu");
    Image menuPainikeKuva = LoadImage("painike");
    Image menuPainikeHoverKuva = LoadImage("painikeHover");
    Image[] lonkerot = LoadImages("lonkeroo", "lonkeroo2");

    SoundEffect valaanKuolinHuuto = LoadSoundEffect("simo");

    IntMeter voittoMittari = new IntMeter(0);
    bool won = false;

    Diver[] pelaajat = new Diver[4];

    Image tukehtunutKuva = LoadImage("tukehtunut");
    Image kuollutValas = LoadImage("valaskuoli");
    Image[] pelaajanKuvat = LoadImages("s0001", "s0002", "s0003", "s0004", "s0005", "s0006");
    Image[] pelaajaTukehtunutKuvat = LoadImages("tukehtunut");
    Image[] valasKuvat = LoadImages("valas0001", "valas0002", "valas0003", "valas0004", "valas0005", "valas0006", "valas0007");
    Image[] kultaValasKuvat = LoadImages("kultavalas0001", "kultavalas0002", "kultavalas0003", "kultavalas0004", "kultavalas0005", "kultavalas0006", "kultavalas0007");
    Image[] kuplanKuvat = LoadImages("kupla0001", "kupla0002", "kupla0003", "kupla0004", "kupla0005", "kupla0006", "kupla0007");
    Image[] pieniKuplaKuvat = LoadImages("pkupla0001", "pkupla0002", "pkupla0003", "pkupla0004", "pkupla0005", "pkupla0006", "pkupla0007");
    Image[] alkuKuvat = LoadImages("3", "2", "1", "go");

    Image nuoliOhjainKuva = LoadImage("arrows");
    Image wasdOhjainKuva = LoadImage("wasd");
    Image pad1OhjainKuva = LoadImage("pad1");
    Image pad2OhjainKuva = LoadImage("pad2");

    Dictionary<Color, Image[]> pelaajaKuvaDict = new Dictionary<Color,Image[]>();
    Dictionary<Color, Image[]> pelaajaTukehtunuDict = new Dictionary<Color, Image[]>();

    Image[] LataaVaritettyKuva(Dictionary<Color, Image[]> dict, Image[] alkupKuvat, Color vari)
    {
        if (!dict.ContainsKey(vari))
        {
            dict.Add(vari, VaritaKuvat(alkupKuvat, vari));
        }
        return dict[vari];
    }

    public override void Begin()
    {
        Window.Width = (int)Level.Width;
        Window.Height = (int)(Screen.Height * 0.9);
        Alkuvalikko();
        //AloitaPeli();
    }

    void Alkuvalikko()
    {
        Level.Background.CreateGradient(Color.Blue, Color.SkyBlue);

        Timer kupla = new Timer();
        kupla.Interval = 0.1;
        kupla.Timeout += delegate
        {
            LisaaKerattava();
            kupla.Interval = RandomGen.NextDouble(0.2, 1.0);
        };
        kupla.Start();

        MultiSelectWindow alkuValikko = new MultiSelectWindow("Sukelluspeli", "Aloita peli", "Lopeta");
        foreach(var button in alkuValikko.Buttons)
        {
            button.Image = menuPainikeKuva;
            button.ImagePressed = menuPainikeHoverKuva;
        }
        alkuValikko.Image = menuKuva;
        Add(alkuValikko);
        alkuValikko.AddItemHandler(0, AloitaPeli);
        alkuValikko.AddItemHandler(1, Exit);
    }

    /// <summary>
    /// Aloittaa uuden pelin.
    /// </summary>
    void AloitaPeli()
    {
        ClearAll();

        SmoothTextures = false;
        IsFullScreen = false;

        LuoKentta();
        Camera.ZoomFactor = 1.0;

        Label alkuLabel = new Label();
        alkuLabel.Width = alkuKuvat[0].Width;
        alkuLabel.Height = alkuKuvat[0].Height;
        alkuLabel.Image = alkuKuvat[0];
        Add(alkuLabel);

        Timer alkuAjastin = new Timer();
        alkuAjastin.Interval = 1.0;
        alkuAjastin.Timeout += delegate
        {
            int index = (int) alkuAjastin.CurrentTime;
            if (index < alkuKuvat.Length)
            {
                alkuLabel.Image = alkuKuvat[index];
                alkuLabel.Width = alkuLabel.Image.Width;
                alkuLabel.Height = alkuLabel.Image.Height;
            }
            else
            {
                alkuLabel.Destroy();
                alkuAjastin.Stop();
            }
        };
        alkuAjastin.Start();

        // Painovoima tulee vasta hetken päästä, jotta valaita ehtii tulemaan.
        Timer.SingleShot(5.0, delegate
        {
            Gravity = new Vector(0, -200);
        });
    }

    /// <summary>
    /// Luo kentän ja pelaajat.
    /// </summary>
    void LuoKentta()
    {
        pelaajiaLisatty = 0;

        Level.CreateHorizontalBorders(0, false, Color.Black);

        PhysicsObject pohja = Level.CreateBottomBorder(0, true);
        AddCollisionHandler(pohja, "pelaaja", PelaajaTuhoutui);
        pohja.Color = Color.BrownGreen;

        PhysicsObject toppi = Level.CreateTopBorder(1, false);
        AddCollisionHandler(toppi, "pelaaja", TyonnaPelaajaa);

        Level.Background.CreateGradient(Color.Blue, Color.SkyBlue);

        //pelaajat[0] = LuoPelaaja(new Vector(20, 200), pelaajanKuvat, NappaimistoOhjaimet);
        //pelaajat[1] = LuoPelaaja(new Vector(-20, 200), punainen, OhjainOhjaimet(ControllerOne));
        //pelaajat[2] = LuoPelaaja(new Vector(60, 200), vihrea, OhjainOhjaimet(ControllerTwo));
        //pelaajat[3] = LuoPelaaja(new Vector(-60, 200), sininen, NappaimistoSurullinenKopio);
        pelaajat[0] = LuoPelaaja(new Vector(20, 200), Color.Yellow, NappaimistoOhjaimet, nuoliOhjainKuva);
        pelaajat[1] = LuoPelaaja(new Vector(-20, 200), Color.Red, OhjainOhjaimet(ControllerOne), pad1OhjainKuva);
        pelaajat[2] = LuoPelaaja(new Vector(60, 200), Color.Green, OhjainOhjaimet(ControllerTwo), pad2OhjainKuva);
        pelaajat[3] = LuoPelaaja(new Vector(-60, 200), Color.Blue, NappaimistoSurullinenKopio, wasdOhjainKuva);

        LuoLevaa();

        GameObject pohjamoska = new GameObject(Level.Width, 200);
        pohjamoska.Bottom = Level.Bottom;
        pohjamoska.Image = pohjaMoskaKuva;
        Add(pohjamoska, -1);

        #region Ajastimet
        Timer.SingleShot(4.0, delegate
        {
            // Valaan luontiajastin.
            Timer ajastin = new Timer();
            ajastin.Interval = 0.1;
            ajastin.Timeout += delegate
            {
                LisaaValas();
                ajastin.Interval = RandomGen.NextDouble(2.0, 4.0);
            };
            ajastin.Start();

            // Kivasti kopsittu.
            Timer kupla = new Timer();
            kupla.Interval = 2;
            kupla.Timeout += delegate
            {
                LisaaKerattava();
                kupla.Interval = RandomGen.NextDouble(0.2, 2.0);
            };
            kupla.Start();

            won = false;
            voittoMittari.Value = 0;
            voittoMittari.MaxValue = pelaajiaLisatty - 1;
            voittoMittari.UpperLimit += Voitto;
        });
        #endregion
    }

    /// <summary>
    /// Levänluonti + animaatio
    /// </summary>
    private void LuoLevaa()
    {
        for (int i = 0; i < 20; i++)
        {
            LisaaLonkero();
        }
    }

    /// <summary>
    /// Zoomailee jännästi voittajapelaajaan
    /// </summary>
    void Voitto()
    {
        if (won)
        {
            return;
        }
        won = true;

        foreach(Diver sukeltaja in pelaajat)
        {
            if(sukeltaja.HasDrowned == false)
            {
                MessageDisplay.Add(sukeltaja.Name + " on voittanut kivasti");
                sukeltaja.IgnoresPhysicsLogics = true;
                sukeltaja.IgnoresCollisionResponse = true;
                sukeltaja.CollisionIgnoreGroup = 3;
                sukeltaja.StopBreathing();
                sukeltaja.LifeCounter = null;
              

                PhysicsObject voittaja = PhysicsObject.CreateStaticObject(sukeltaja.Width, sukeltaja.Height);
                voittaja.IgnoresCollisionResponse = true;
                voittaja.Image = sukeltaja.Image;
                voittaja.Position = sukeltaja.Position;
                voittaja.Animation = sukeltaja.Animation;
                //voittaja.Animation.Start();
                Add(voittaja);

                sukeltaja.Destroy();

                /*
                Timer voittoAjastin = new Timer();
                voittoAjastin.Interval = 0.5;
                voittoAjastin.Timeout += delegate
                {
                    if (Camera.ZoomFactor < 3)
                    {
                        Camera.Follow(sukeltaja);
                        Camera.Zoom((voittoAjastin.SecondCounter.Value + 1) * Camera.ZoomFactor);
                    }
                    else { voittoAjastin.Stop(); }
                };
                voittoAjastin.Start();
                 */

                Timer parempiVoittoAjastin = new Timer();
                parempiVoittoAjastin.Interval = 0.05;
                parempiVoittoAjastin.Timeout += delegate
                {
                    if (Camera.ZoomFactor < 2.5)
                    {
                        Camera.Follow(voittaja);
                        Camera.Zoom(1.0 + (parempiVoittoAjastin.SecondCounter.Value * 0.01));
                    }
                    else { parempiVoittoAjastin.Stop(); }
                };
                parempiVoittoAjastin.Start();
            }
        }
    }

    void TyonnaPelaajaa(PhysicsObject tormatty, PhysicsObject pelaaja)
    {
        pelaaja.Hit(new Vector(0, -3500));
    }

    void PelaajaTuhoutui(PhysicsObject tormatty, PhysicsObject pelaaja)
    {
        Diver sukeltaja = pelaaja as Diver;
        sukeltaja.Drown();
        MessageDisplay.Add(sukeltaja.Name + " on hukkunut! Lellll.");
        voittoMittari.Value++;

        sukeltaja.LifeCounter = null;
        sukeltaja.Destroy();

        PhysicsObject tukehtunut = PhysicsObject.CreateStaticObject(sukeltaja.Width, sukeltaja.Height);
        tukehtunut.IgnoresCollisionResponse = true;
        tukehtunut.Image = sukeltaja.TukehdusKuvat[0];
        tukehtunut.Position = sukeltaja.Position;
        tukehtunut.Velocity = new Vector(0, 50);

        Add(tukehtunut);
    }

    /// <summary>
    /// Luodaan jotain kerättävää hurdur.
    /// </summary>
    private void LisaaKerattava()
    {
        PhysicsObject kerattava = PhysicsObject.CreateStaticObject(kuplanKuvat[0].Width, kuplanKuvat[0].Height); 
        kerattava.Shape = Shape.Circle;
        kerattava.Position = RandomGen.NextVector(Level.Left + 50, Level.Bottom, Level.Right - 50, Level.Bottom);
        kerattava.Velocity = new Vector(0.0, (RandomGen.NextDouble(50, 300)));
        kerattava.Oscillate(Vector.UnitX, 200, 0.1, RandomGen.NextDouble(0.0, 2.0 * Math.PI));
        AddCollisionHandler(kerattava, "pelaaja", Hapeta);
        kerattava.Image = kuplanKuvat[0];
        kerattava.Animation = new Animation(kuplanKuvat);
        kerattava.Animation.Start();
        kerattava.IgnoresCollisionResponse = true;
        kerattava.CollisionIgnoreGroup = 3;
        Add(kerattava);
    }

    /// <summary>
    /// Antaa pelaajalle lisää happea
    /// </summary>
    /// <param name="esine">esine, johon törmäsi</param>
    /// <param name="pelaaja">pelaaja, joka törmäsi</param>
    void Hapeta(PhysicsObject esine, PhysicsObject pelaaja)
    {
        Diver sukeltaja = pelaaja as Diver; 
        ((Diver)pelaaja).Oxygen += sukeltaja.MaxOxygen/5;
        esine.Destroy();
    }

    /// <summary>
    /// Luo yksittäisen pelaajan.
    /// </summary>
    /// <param name="nappainLisaaja">Aliohjelma, joka lisää pelaajalle ohjaimet</param>
    /// <returns>luotu pelaaja</returns>
    Diver LuoPelaaja(Vector paikka, Color vari, Action<Diver> nappainLisaaja, Image ohjainKuva)
    {
        Image[] kuvat = LataaVaritettyKuva(pelaajaKuvaDict, pelaajanKuvat, vari);
        Animation anim = new Animation(kuvat);
        anim.FPS = 7;

        Diver pelaaja = new Diver(pelaajanKuvat[0].Width, pelaajanKuvat[0].Height);
        pelaaja.TukehdusKuvat = LataaVaritettyKuva(pelaajaTukehtunuDict, pelaajaTukehtunutKuvat, vari);
        pelaaja.CollisionIgnoreGroup = 2;
        pelaaja.Position = paikka;
        pelaaja.Mass = 4.0;
        pelaaja.Tag = "pelaaja";
        pelaaja.Image = kuvat[0];
        pelaaja.AnimWalk = anim;
        pelaaja.AnimJump = anim;
        pelaaja.AnimIdle = anim;
        Add(pelaaja);

        Label ohjain = new Label(ohjainKuva);
        ohjain.Width = ohjainKuva.Width;
        ohjain.Height = ohjainKuva.Height;
        ohjain.Y = pelaaja.Height;
        pelaaja.Add(ohjain);

        Timer.SingleShot(7.0, delegate
        {
            ohjain.Destroy();
        });

        AddCollisionHandler(pelaaja, "valaskalanen", PompunSeuraukset);

        pelaaja.LosingOxygen.Timeout += delegate { LuoKupla(pelaaja); };


        pelaaja.LifeCounter.LowerLimit += delegate
        {
            PelaajaTuhoutui(null, pelaaja);
        };

        pelaaja.VisibleLife.BarImage = taysi;
        pelaaja.VisibleLife.Image = tyhja;

        pelaaja.Name = "Pelaaja " + ++pelaajiaLisatty;

        nappainLisaaja(pelaaja);
        return pelaaja;
    }

    /// <summary>
    /// Valaantappo.
    /// </summary>
    /// <param name="pelaaja"></param>
    /// <param name="kalanen"></param>
    void PompunSeuraukset(PhysicsObject pelaaja, PhysicsObject kalanen)
    {
        Valas valas = kalanen as Valas;

        if (valas.SuperValas)
            return;

        valas.PomppuLaskuri.Value--;
        valas.Tag = "kalanen";
        valas.Pompattu.Start();

        if(valas.PomppuLaskuri.Value == valas.PomppuLaskuri.MinValue)
        {
            valaanKuolinHuuto.Play();

            PhysicsObject kuoleva = new PhysicsObject(valas.Width, valas.Height);
            kuoleva.Shape = Shape.Circle;
            kuoleva.Image = kuollutValas;
           /* kuoleva.Animation = new Animation(valasKuvat);
            kuoleva.Animation.FPS = 5;
            kuoleva.Animation.Start(); */
            kuoleva.Position = valas.Position;
            kuoleva.IgnoresCollisionResponse = true;
            kuoleva.IgnoresPhysicsLogics = true;
            kuoleva.Velocity = new Vector(0, 40);
            kuoleva.AngularVelocity = RandomGen.NextDouble(-0.2, 0.2);
            Add(kuoleva);

            Timer raadonSyoja = new Timer();
            raadonSyoja.Interval = 30;
            raadonSyoja.Timeout += delegate { kuoleva.Destroy(); raadonSyoja.Stop(); };
            raadonSyoja.Start();

            valas.Destroy();
        }
    }

    /// <summary>
    /// Kasilta syömään, huoneen palautus 10.
    /// </summary>
    /// <param name="pelaaja">Siivoa huoneesi</param>
    void LuoKupla(Diver pelaaja)
    {
        if (pelaaja.HasDrowned == false)
        {
            PhysicsObject kupla = PhysicsObject.CreateStaticObject(kuplanKuvat[0].Width * 0.3, kuplanKuvat[0].Height * 0.3);
            kupla.Shape = Shape.Circle;
            kupla.Position = pelaaja.Position + new Vector(0, (pelaaja.Height * 0.5));
            kupla.Velocity = new Vector(0.0, (RandomGen.NextDouble(50, 300)));
            kupla.Oscillate(Vector.UnitX, 50, 0.1, RandomGen.NextDouble(0.0, 2.0 * Math.PI));
            kupla.Image = pieniKuplaKuvat[0];
            kupla.Animation = new Animation(pieniKuplaKuvat);
            kupla.Animation.Start();
            kupla.IgnoresCollisionResponse = true;
            kupla.CollisionIgnoreGroup = 3;
            Add(kupla);
        }

    }

    /// <summary>
    /// Lisää yksittäisen taivasvalaan pelikentälle
    /// </summary>
    void LisaaValas()
    {
        int todennakoisyys = RandomGen.NextInt(100);
        bool super = todennakoisyys < 4;

        Valas valas = new Valas(valasKuvat[0].Width, valasKuvat[0].Height, super);
        valas.Shape = Shape.Circle;
        valas.Image = valasKuvat[0];
        valas.Animation = new Animation(valasKuvat);
        valas.Animation.FPS = 5;
        valas.Animation.Start();
        valas.Position = RandomGen.NextVector(Level.Right, Level.Bottom + 100, Level.Right, Level.Top - 100);
        valas.Velocity = new Vector(RandomGen.NextDouble(-300, -20), 0.0);
        valas.Oscillate(Vector.UnitY, 100, 0.1, RandomGen.NextDouble(0.0, 2.0 * Math.PI));
        valas.CollisionIgnoreGroup = 3;
        valas.Tag = "valaskalanen";
        Add(valas);

        valas.Pompattu.Interval = 0.4;
        valas.Pompattu.Timeout += delegate { valas.Tag = "valaskalanen"; valas.Pompattu.Stop(); };

        if (super) //SUPERVALAS
        {
            valas.Animation = new Animation(kultaValasKuvat);
            valas.Animation.FPS = 5;
            valas.Animation.Start();
            valas.Position -= new Vector(0, valas.Height / 2);  //näin valas ei tapa meitä aina
            valas.Size *= 3;
        }
    }

    void LisaaLonkero()
    {
        GameObject lonkero = new GameObject(40, 70);
        lonkero.Position = new Vector(RandomGen.NextDouble(Level.Left, Level.Right), Level.Bottom + RandomGen.NextDouble(50,90));
        lonkero.Image = lonkerot[0];
        lonkero.Animation = new Animation(lonkerot);
        lonkero.Animation.FPS = RandomGen.NextInt(1,4);
        lonkero.Animation.Start();
        Add(lonkero);
    }

    /// <summary>
    /// Lisää vaihtoehtoiset näppäimet yhdelle pelaajista
    /// </summary>
    /// <param name="pelaaja"></param>
    void NappaimistoSurullinenKopio(Diver pelaaja)
    {
        Keyboard.Listen(Key.A, ButtonState.Down, Liikuta, "Liikkuu vasemmalle", pelaaja, Direction.Left);
        Keyboard.Listen(Key.D, ButtonState.Down, Liikuta, "Liikkuu oikealle", pelaaja, Direction.Right);
        Keyboard.Listen(Key.W, ButtonState.Down, Hyppaa, "Pelaaja hyppää", pelaaja, hyppyNopeus);
        Keyboard.Listen(Key.S, ButtonState.Down, Sukella, "Pelaaja sukeltaa", pelaaja, new Vector(0, -nopeus));
    }

    void Sukella(Diver hahmo, Vector impulssi)
    {
        hahmo.Push(impulssi *2);
    }

    protected override void Update(Time time)
    {
        base.Update(time);
    }

    void NappaimistoOhjaimet(Diver pelaaja)
    {
        Keyboard.Listen(Key.F1, ButtonState.Pressed, ShowControlHelp, "Näytä ohjeet");
        Keyboard.Listen(Key.Escape, ButtonState.Pressed, ConfirmExit, "Lopeta peli");
        Keyboard.Listen(Key.R, ButtonState.Pressed, AloitaPeli, "Restart");

        Keyboard.Listen(Key.Left, ButtonState.Down, Liikuta, "Liikkuu vasemmalle", pelaaja, Direction.Left);
        Keyboard.Listen(Key.Right, ButtonState.Down, Liikuta, "Liikkuu oikealle", pelaaja, Direction.Right);
        Keyboard.Listen(Key.Up, ButtonState.Down, Hyppaa, "Pelaaja hyppää", pelaaja, hyppyNopeus);
        Keyboard.Listen(Key.Down, ButtonState.Down, Sukella, "Pelaaja sukeltaa", pelaaja, new Vector(0, -nopeus));
    }

    Action<Diver> OhjainOhjaimet(GamePad ohjain)
    {
        return delegate(Diver pelaaja)
        {
            ohjain.Listen(Button.DPadLeft, ButtonState.Down, Liikuta, "Pelaaja liikkuu vasemmalle", pelaaja, Direction.Left);
            ohjain.Listen(Button.DPadRight, ButtonState.Down, Liikuta, "Pelaaja liikkuu oikealle", pelaaja, Direction.Right);
            ohjain.Listen(Button.A, ButtonState.Down, Hyppaa, "Pelaaja hyppää", pelaaja, hyppyNopeus);
            ohjain.Listen(Button.DPadDown, ButtonState.Down, Sukella, "Pelaaja sukeltaa", pelaaja, new Vector(0, -nopeus));
        };
    }

    void Liikuta(Diver hahmo, Direction suunta)
    {
        hahmo.Walk(suunta);
    }

    void Hyppaa(Diver hahmo, double nopeus)
    {
        hahmo.Jump(nopeus);
    }

    Image VaritaKuva(Image kuva, Color vari)
    {
        Image uusi = new Image(kuva.Width, kuva.Height, Color.Transparent);
        for (int y = 0; y < kuva.Height; y++)
        {
            for (int x = 0; x < kuva.Width; x++)
            {
                double suhde = 0.0;
                if (Math.Abs(kuva[y, x].GreenComponent - 255) < 40)
                {
                    suhde = 1.0;
                }
                if (kuva[y, x].AlphaComponent == 0)
                {
                    suhde = 0.0;
                }
                uusi[y, x] = Color.Lerp(kuva[y, x], vari, suhde);
            }
        }
        return uusi;
    }

    Image[] VaritaKuvat(Image[] kuvat, Color vari)
    {
        Image[] uudet = new Image[kuvat.Length];
        for (int i = 0; i < kuvat.Length; i++)
        {
            uudet[i] = VaritaKuva(kuvat[i], vari);
        }
        return uudet;
    }
}