source: 2010/23/hniemi/ShootEmUp/ShootEmUp/Peli.cs @ 932

using System;
using Jypeli;
using Jypeli.ScreenObjects;
using Jypeli.Assets;
using System.Collections.Generic;


namespace ShootEmUp
{
    public class Peli : PhysicsGame
    {
        #region Julistukset
        
        
        //Liikkumisnopeudet
        private const double NOPEUS = 300;
        private Vector nopeusPysty = new Vector(0,NOPEUS);
        private Vector nopeusVaaka = new Vector(NOPEUS, 0);

        //Kentän rakenne
        private Alus pelaajaAlus;
        private PhysicsObject vasenLaita;
        private PhysicsObject oikeaLaita;
        private PhysicsObject pohja;
        private PhysicsObject katto;
        private PhysicsObject exitZone;

        //Viholliset
        private const int VIHOLLISKUVIA = 3;

        //Statistiikka
        private int kentannro = 0;
        private IntMeter score = new IntMeter(0);
        private Weapon[] weapons;

        #endregion

        protected override void Begin()
        {
            LataaKentta(kentannro);
        }

        #region Kentän lataaminen

        /// <summary>
        /// Tulee lataamaan numeroa vastaavan kentän
        /// Kentän tiedot siis tallennettaisiin level1.txt, level2.txt...
        /// </summary>
        /// <param name="kentanNumero">Ei vielä käytössä</param>
        void LataaKentta(int kentanNumero)
        {
            ClearAll();
            Level.Width = 600;
            Level.Height = 800;

            Camera.Move(new Vector(250, 0));

            //Laidat
            LisaData tieto;
            tieto.Tyyppi = "seina";
            tieto.Rajahtaa = true;
            tieto.Damage = 5;
            vasenLaita = Level.CreateLeftBorder();
            vasenLaita.Tag = tieto;
            oikeaLaita = Level.CreateRightBorder();
            oikeaLaita.Tag = tieto;
            pohja = Level.CreateBottomBorder();
            pohja.Tag = tieto;
            katto = Level.CreateTopBorder();
            katto.Tag = tieto;

            //Exit-alueen tekeminen.
            exitZone = PhysicsObject.CreateStaticObject(Level.Width, 200);
            exitZone.Position = new Vector(Level.Center.X, Level.Bottom - exitZone.Size.Y / 2 - 5);
            exitZone.Tag = tieto;
            Add(exitZone);

            LuoPelaaja();
            LataaKontrollit(pelaajaAlus);
            //LataaTausta(kentanNumero);
            LataaViholliset(20, 4,10);
            LataaHUD();
        }

        /// <summary>
        /// Luo näytölle tarvittavat mittarit
        /// </summary>
        void LataaHUD()
        {
            ValueDisplay hpNaytto = new ValueDisplay();
            hpNaytto.BindTo(pelaajaAlus.HpMeter);
            Add(hpNaytto);
            hpNaytto.Position = new Vector(Level.Right + 40, Level.Top - 80);
            hpNaytto.Text = "HP: ";

            ValueDisplay scoreNaytto = new ValueDisplay();
            scoreNaytto.BindTo(score);
            Add(scoreNaytto);
            scoreNaytto.Position = new Vector(Level.Right + 40, Level.Top - 100);
            scoreNaytto.Text = "SCORE: ";

        }

        /// <summary>
        /// Luo pelaajan ja sijoittaa sen kentälle.
        /// Asettaa pelaajalle myös aseen.
        /// </summary>
        void LuoPelaaja()
        {
            pelaajaAlus = new Alus(60, 55, 10);
            pelaajaAlus.Shape = Shapes.Triangle;
            
            pelaajaAlus.Animation = new Animation(LoadImages("sankarialus/sankarialusThrust1", "sankarialus/sankarialusThrust2"));
            pelaajaAlus.Animation.Start();

            LisaData tieto;
            tieto.Tyyppi = "oma";
            tieto.Rajahtaa = true;
            tieto.Damage = 5;
            pelaajaAlus.Tag = tieto;

            pelaajaAlus.Angle += Angle.Degrees(90);

            pelaajaAlus.IgnoresCollisionResponse = false;
            pelaajaAlus.Y = Level.Bottom + 40;
            pelaajaAlus.KineticFriction = 1.0;
            pelaajaAlus.Mass = 100000;

            weapons = new Weapon[3];

            weapons[0] = new Beam(1, 1);
            ((Beam)weapons[0]).BeamCollision = AmmusOsuu;
            weapons[0].Position = new Vector(0, -40);
            weapons[1] = new Missile(1, 1);
            ((Missile)weapons[1]).MissileCollision = AmmusOsuu;

            weapons[2] = new Photon(1, 1);
            ((Photon)weapons[2]).PhotonCollision = AmmusOsuu;

            for (int i = 0; i < weapons.Length; i++)
            {
                pelaajaAlus.Add(weapons[i]);
            }

            Add(pelaajaAlus);
            pelaajaAlus.SetWeapon(weapons[2]);
            
            AddCollisionHandler(pelaajaAlus, PelaajaTormaa);
            
        }

        #endregion
        #region Kontrollit ja liikkuminen
        /// <summary>
        /// Asettaa kontrollit ohjaamaan haluttua alusta
        /// </summary>
        /// <param name="pelaaja">Alus, jota halutaan ohjata</param>
        void LataaKontrollit(Alus pelaaja)
        {
            Keyboard.Listen(Key.Escape, ButtonState.Pressed, Exit, "Lopettaa pelin");
            Keyboard.Listen(Key.Up, ButtonState.Down, Liikuta, "Liikuttaa alusta ylös", pelaaja, nopeusPysty);
            Keyboard.Listen(Key.Up, ButtonState.Released, pelaaja.StopVertical, null);
            Keyboard.Listen(Key.Down, ButtonState.Down, Liikuta, "Liikuttaa alusta alas", pelaaja, -nopeusPysty);
            Keyboard.Listen(Key.Down, ButtonState.Released, pelaaja.StopVertical, null);
            Keyboard.Listen(Key.Left, ButtonState.Down, Liikuta, "Liikuttaa alusta vasemmalle", pelaaja, -nopeusVaaka);
            Keyboard.Listen(Key.Left, ButtonState.Released, pelaaja.StopHorizontal, null);
            Keyboard.Listen(Key.Right, ButtonState.Down, Liikuta, "Liikuttaa alusta oikealle", pelaaja, nopeusVaaka);
            Keyboard.Listen(Key.Right, ButtonState.Released, pelaaja.StopHorizontal, null);
            Keyboard.Listen(Key.LeftControl, ButtonState.Down, Ammu, "Lopettaa pelin", pelaajaAlus);
            Keyboard.Listen(Key.D1, ButtonState.Pressed, VaihdaAsetta, "Valitsee säde-aseen", 1);
            Keyboard.Listen(Key.D2, ButtonState.Pressed, VaihdaAsetta, "Valitsee ohjuksen", 2);
            Keyboard.Listen(Key.D3, ButtonState.Pressed, VaihdaAsetta, "Valitsee fotoniaseen", 2);
        }

        /// <summary>
        /// Liikuttaa alusta haluttuun suuntaan
        /// </summary>
        /// <param name="alus">Liikutettava alus</param>
        /// <param name="suunta">Liikutettava suunta</param>
        void Liikuta(Alus alus, Vector suunta)
        {
            if (-NOPEUS < alus.Velocity.Y && alus.Velocity.Y < NOPEUS && suunta.Y != 0)
            {
                alus.Velocity += suunta;
            }
            if (-NOPEUS < alus.Velocity.X && alus.Velocity.X < NOPEUS && suunta.X != 0)
            {
                alus.Velocity += suunta;
            }
        }

        void VaihdaAsetta(int aseenNumero)
        {
            if (aseenNumero > 0 && aseenNumero < 4)
            pelaajaAlus.SetWeapon(weapons[aseenNumero-1]);
        }

        /// <summary>
        /// Ampuu aluksella
        /// </summary>
        /// <param name="alus">Alus joka ampuu</param>
        void Ammu(Alus alus)
        {
            alus.Shoot();
        }

        #endregion
        #region Viholliset
        /// <summary>
        /// Lataa viholliset
        /// TODO: Kentän numeron huomioiminen
        /// </summary>
        void LataaViholliset(int maara, double min, double max)
        {
            List<AikaTapahtuma> vihollistenTuloajat = new List<AikaTapahtuma>();
            /*
            for (int i = 0; i < maara; i++)
            {
                vihollistenTuloajat.Add(new AikaTapahtuma(2 + (i * 5), LahetaSatunnainenVihollislaivue, 4, 10));
            }
            */
            vihollistenTuloajat.Add(new AikaTapahtuma(1/*2 + (maara * 7)*/, LahetaLoppupomo, 1, 20));

            foreach (AikaTapahtuma tapahtuma in vihollistenTuloajat)
            {
                Timer ajastin = new Timer();
                ajastin.Tag = tapahtuma.Lahtopaikka;
                ajastin.Interval = tapahtuma.Aika;
                ajastin.Trigger += tapahtuma.Tapahtuma;
                Add(ajastin);
                ajastin.Start(1);
            }
        }

        /// <summary>
        /// Luo alukset ja lähettää ne matkaan
        /// </summary>
        /// <param name="sender">Timerin tagissa on lähtökoordinaatti</param>
        /// <param name="lahetysX">X-koordinaatti, josta muodostelma lähtee</param>
        void LahetaLoppupomo(Timer sender)
        {
            double taso = ((Vector)sender.Tag).X;

            List<Alus> alukset = new List<Alus>();
            Image vihollisenKuva = LoadImage("loppuvastus" + 1);
            alukset.Add(LuoVihollinen(vihollisenKuva, 400));
            alukset[0].Position = new Vector(0, Level.Top + 200);
            alukset[0].Angle = Angle.Degrees(270);
            Add(alukset[0]);

            //Aseen säätö
            Photon ase = new Photon(10, 10);
            LisaData ammuksenData;
            ammuksenData.Damage = 20;
            ammuksenData.Rajahtaa = false;
            ammuksenData.Tyyppi = "vihollinen";
            ase.Tag = ammuksenData;
            alukset[0].Add(ase);
            alukset[0].SetWeapon(ase);
            alukset[0].UsedWeapon.IsVisible = false;
            ase.PhotonCollision = AmmusOsuu;

            Timer ampumaAjastin = new Timer();
            ampumaAjastin.Interval = 0.7;
            ampumaAjastin.Trigger += alukset[0].TimerShoot;
            Add(ampumaAjastin);
            ampumaAjastin.Start();

            List<Vector> reitti = new List<Vector>();
            reitti.Add(new Vector(-200, Level.Top - 100 ));
            reitti.Add(new Vector(200, Level.Top - 100));

            Muodostelma muodostelma = new Muodostelma(alukset, reitti, LuoLahettaja());
            muodostelma.MovingSpeed = 100;
            muodostelma.Start();
        }

        /// <summary>
        /// Arpoo ja lähettää satunnaisen vihollislaivueen
        /// Laivueessa on tällä hetkellä 10 alusta
        /// Aluksen kuva arvotaan tiedostoista, joiden nimi on "vihollinen#.png"
        /// </summary>
        /// <param name="sender"></param>
        void LahetaSatunnainenVihollislaivue(Timer sender)
        {
            List<Alus> alukset = new List<Alus>();
            Image vihollisenKuva = LoadImage("vihollinen" + RandomGen.NextInt(1,VIHOLLISKUVIA));

            int min = (int)((Vector)sender.Tag).X;
            int max = (int)((Vector)sender.Tag).Y;
            int koko = RandomGen.NextInt(min, max);

            for (int i = 0; i < koko; i++)
            {
                alukset.Add(LuoVihollinen(vihollisenKuva, 40));
                Add(alukset[i]);
                Angle alas = new Angle();
                alas.Degree = 270;
                alukset[i].Angle = Angle.Degrees(270);
                alukset[i].Position = new Vector(0, Level.Top + 200);
                AddCollisionHandler(alukset[i], VihollinenTormaa);
            }

            List<Vector> reitti = ArvoReitti(RandomGen.NextInt(0,5));
            Muodostelma muodostelma = new Muodostelma(alukset, reitti, LuoLahettaja());
            muodostelma.MovingSpeed = 100;
            muodostelma.Start();
        }

        /// <summary>
        /// Arpoo koneelle reitin, joka lähteee ylhäältä ja päätyy alas
        /// </summary>
        /// <param name="valipisteet">Välipisteiden määrä, 0 -></param>
        /// <returns></returns>
        List<Vector> ArvoReitti(int valipisteet)
        {
            List<Vector> reitti = new List<Vector>();
            reitti.Add(new Vector(RandomGen.NextDouble(Level.Left + 30, Level.Right - 30),Level.Top + 80));
            for (int i = 0; i < valipisteet; i++)
            {
                reitti.Add(new Vector(RandomGen.NextDouble(Level.Left + 30, Level.Right - 30),
                                     (RandomGen.NextDouble(Level.Bottom + 30, Level.Top - 100))));
            }
            reitti.Add(new Vector(RandomGen.NextDouble(Level.Left + 30, Level.Right - 30), Level.Bottom - 35));
            return reitti;
        }

        Alus LuoVihollinen(Image kuva, int hp)
        {
            
            Alus vihollinen = new Alus(kuva.Width/5, kuva.Height/5, hp);
            vihollinen.Image = kuva;
            LisaData tieto;
            tieto.Tyyppi = "vihollinen";
            tieto.Rajahtaa = true;
            tieto.Damage = 5;
            vihollinen.Tag = tieto;
            return vihollinen;
        }

        /// <summary>
        /// Luo ajastimen
        /// Lisää myös ajastimen, joten voidaan kutsua suoraan Muodostelman muodostajassa.
        /// </summary>
        /// <returns></returns>
        Timer LuoLahettaja()
        {
            Timer ajastin = new Timer();
            ajastin.Interval = 0.5;
            Add(ajastin);
            return ajastin;
        }
        #endregion
        #region Tapahtumat
        /// <summary>
        /// Pelaajan törmäyksen käsittelijä
        /// 
        /// Katsoo myös, että pelaaja ei juutu seiniin
        /// </summary>
        /// <param name="tormaaja"></param>
        /// <param name="kohde"></param>
        void PelaajaTormaa(PhysicsObject tormaaja, PhysicsObject kohde)
        {
            if (((LisaData)kohde.Tag).Tyyppi == "vihollinen") 
            {
                ((Alus)tormaaja).TakeHit(5);
                if (kohde is Alus) ((Alus)kohde).TakeHit(20);
            }

            if (kohde == vasenLaita)
            {
                tormaaja.X = Level.Left + tormaaja.Height / 2 + 1;
                tormaaja.StopHorizontal();
            }

            if (kohde == oikeaLaita)
            {
                tormaaja.X = Level.Right - tormaaja.Height / 2 - 1;
                tormaaja.StopHorizontal();
            }
            if (kohde == katto)
            {
                tormaaja.Y = Level.Top - tormaaja.Width / 2 - 1;
                tormaaja.StopVertical();
            }
            if (kohde == pohja)
            {
                tormaaja.Y = Level.Bottom + tormaaja.Width/2 +1;
                tormaaja.StopVertical();
            }

        }

        /// <summary>
        /// Mitä tapahtuu, kun vihollinen tulee ns. poistumisalueelle
        /// </summary>
        /// <param name="tormaaja"></param>
        /// <param name="kohde"></param>
        void VihollinenTormaa(PhysicsObject tormaaja, PhysicsObject kohde)
        {
            if (kohde == exitZone) Remove(tormaaja);
            
        }

        void AmmusOsuu(PhysicsObject ammus, PhysicsObject toinen)
        {

            if (toinen.Tag.ToString() == "seina" || ((LisaData)toinen.Tag).Tyyppi != ((LisaData)ammus.Tag).Tyyppi)
            {
                ammus.Destroy();
                if (((LisaData)ammus.Tag).Rajahtaa)
                {
                    Explosion rajahdys = new Explosion(100);
                    rajahdys.Position = toinen.Position;
                    Add(rajahdys);
                }

                if (((LisaData)toinen.Tag).Tyyppi == "vihollinen")
                {
                    if (toinen is Alus) 
                    {
                        ((Alus)toinen).TakeHit(((LisaData)ammus.Tag).Damage);
                        if (toinen.IsDestroyed()) score.Value++;
                    }
                    
                }
            }


        }
        #endregion
    }

    public class AikaTapahtuma 
    {
        public int Aika;
        public Timer.TriggerHandler Tapahtuma;
        private Vector lahtopaikka;

        public Vector Lahtopaikka 
        {
            get{ return lahtopaikka; }
        }

        public AikaTapahtuma(int aika, Timer.TriggerHandler tapahtuma, double param1, double param2)
        {
            this.Aika = aika;
            this.Tapahtuma = tapahtuma;
            this.lahtopaikka = new Vector(param1, param2);
        }
    }
}