source: 2010/30/tekrjant/Seikkailu/Peli.cs @ 1543

#region MIT License
/*
 * Copyright (c) 2010 Tero Jäntti.
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#endregion

using System;
using System.Collections.Generic;
using Jypeli;
using Jypeli.Widgets;
using Jypeli.Effects;
using Physics2DDotNet.Ignorers;


public class Peli : PhysicsGame
{
    const double PelaajanNopeus = 2.0;
    const double PelaajanKulmanopeus = 3.0;

    List<GameObject> ruohot = new List<GameObject>();

    Timer energiaAmpumisAjastin = new Timer() { Interval = 0.1 };
    ObjectIgnorer energiaIgnorer = new ObjectIgnorer();

    EsineRuutu esineRuutu;
    EsineValikko esineValikko;

    PhysicsObject pelaaja;
    Esine viimeksiKoskettuEsine;

    Image[] ottiaisenKuvat = LoadImages( "ottiainen1", "ottiainen2", "ottiainen3", "ottiainen4" );
    Image[] ottiaisenSyomisKuvat = LoadImages(
        "ottiainen_syo1", "ottiainen_syo2", "ottiainen_syo3", "ottiainen_syo4",
        "ottiainen_syo5", "ottiainen_syo6", "ottiainen_syo7", "ottiainen_syo8" );
    Image ottiainenKuollutKuva = LoadImage( "ottiainen_kuollut" );
    Image ottiainenPalanutKuva = LoadImage( "ottiainen_palanut" );
    Image liekinKuva = LoadImage( "liekki" );
    Image ruohoTekstuuri = LoadImage( "ruoho" );
    Image lyhdynKuva = LoadImage( "lyhty" );
    Image timantinKuva = LoadImage( "timantti" );
    Image taikasauvanKuva = LoadImage( "taikasauva" );
    Image taikasauva2Kuva = LoadImage( "taikasauva2" );
    Image[] energiaKuvat = LoadImages( "energia1", "energia2", "energia3", "energia4" );

    Lieska tuliJaLeimaus;
    Light lyhdynValo;

    Timer lyhtyAjastin;

    const double ruudunLeveys = 5;
    const double ruudunKorkeus = 5;

    const int MaanTaso = 0;
    const int TavaraTaso = 1;
    const int OtusTaso = 2;


    protected override void Begin()
    {
        LuoKentta();
        LuoHUD();
        AsetaOhjaimet();
    }

    void LuoHUD()
    {
        esineRuutu = new EsineRuutu( 200, 50 );
        esineRuutu.X = Screen.Center.X + Screen.Width / 4;
        esineRuutu.Y = Screen.Top - esineRuutu.Height / 2;
        Add( esineRuutu );

        esineValikko = new EsineValikko( 100, 100 );
        esineValikko.X = 0;
        esineValikko.Y = Screen.Bottom + esineValikko.Height / 2;
        Add( esineValikko );
    }

    void LuoKentta()
    {
        ClearAll();
        Level.BackgroundColor = Color.DarkGreen;
        Level.Width = 20;
        Level.Height = 20;

        TileMap kartta = TileMap.FromFile( "kentat\\luola1.txt" );
        kartta['#'] = LuoSeina;
        kartta['.'] = LuoLattia;
        kartta['\''] = LuoRuoho;
        kartta.Insert( ruudunLeveys, ruudunKorkeus );

        Level.AmbientLight = 0.2;
        lyhdynValo = new Light();
        lyhdynValo.Intensity = 0.0;
        Add( lyhdynValo );

        lyhtyAjastin = new Timer();
        lyhtyAjastin.Interval = 0.1;
        lyhtyAjastin.Trigger += PaivitaLyhtya;

        energiaAmpumisAjastin.Trigger += AmmuEnergiaPallo;

        tuliJaLeimaus = new Lieska( liekinKuva );
        Add( tuliJaLeimaus );

        PhysicsObject vasenSeina = Level.CreateLeftBorder();
        PhysicsObject oikeaSeina = Level.CreateRightBorder();
        PhysicsObject ylaSeina = Level.CreateTopBorder();
        PhysicsObject alaSeina = Level.CreateBottomBorder();

        //for ( int i = 0; i < 100; i++ )
        //{
        //    PhysicsObject omena = new PhysicsObject( 0.1, 0.1, Shapes.Circle );
        //    omena.Tag = "ruoka";
        //    omena.IgnoresCollisionResponse = true;
        //    omena.X = RandomGen.NextDouble( Level.Left, Level.Right );
        //    omena.Y = RandomGen.NextDouble( Level.Bottom, Level.Top );
        //    omena.Color = Color.Red;
        //    Add( omena, TavaraTaso );
        //}

        Esine taikasauva = new Esine( 0.8, 0.1, Shapes.Rectangle, EsineenTyyppi.TuliSauva );
        taikasauva.Image = taikasauvanKuva;
        taikasauva.X = 2;
        taikasauva.Y = 0;
        Add( taikasauva, TavaraTaso );

        Esine energiaSauva = new Esine( 0.8, 0.1, Shapes.Rectangle, EsineenTyyppi.EnergiaSauva );
        energiaSauva.Image = taikasauva2Kuva;
        energiaSauva.X = -1;
        energiaSauva.Y = -1;
        Add( energiaSauva, TavaraTaso );

        Esine lyhty = new Esine( 0.6, 0.6, Shapes.Circle, EsineenTyyppi.Lyhty );
        lyhty.Image = lyhdynKuva;
        lyhty.X = 2;
        lyhty.Y = -1;
        Add( lyhty, TavaraTaso );

        pelaaja = new PhysicsObject( 0.8, 0.8, Shapes.Circle );
        pelaaja.Color = Color.Blue;
        pelaaja.Mass = 80;
        pelaaja.LinearDamping = 0.96;
        pelaaja.AngularDamping = 0.96;
        Add( pelaaja, OtusTaso );

        AddCollisionHandler( pelaaja, PelaajaOsuu );

        GameObject suuntaTikku = new GameObject( 0.2, 0.1 );
        suuntaTikku.Color = Color.Green;
        suuntaTikku.X = 0.5;
        pelaaja.Add( suuntaTikku );

        foreach ( GameObject ruoho in ruohot )
        {
            Otus otti = LuoOttiainen();
            otti.X = ruoho.X + RandomGen.NextDouble( -ruudunLeveys / 2, ruudunLeveys / 2 );
            otti.Y = ruoho.Y + RandomGen.NextDouble( -ruudunKorkeus / 2, ruudunKorkeus / 2 );
        }

        Esine timantti = new Esine( 0.3, 0.3, Shapes.Circle, EsineenTyyppi.Timantti );
        timantti.X = RandomGen.NextDouble( Level.Left, Level.Right );
        timantti.Y = RandomGen.NextDouble( Level.Bottom, Level.Top );
        timantti.Image = timantinKuva;
        Add( timantti, TavaraTaso );

        Camera.StayInLevel = true;
        Camera.ZoomFactor = 50.0;
        Camera.Follow( pelaaja );
    }

    GameObject LuoRuoho()
    {
        GameObject ruoho = new GameObject( ruudunLeveys, ruudunKorkeus );
        ruoho.Image = ruohoTekstuuri;
        ruohot.Add( ruoho );
        return ruoho;
    }

    GameObject LuoLattia()
    {
        GameObject lattia = new GameObject( ruudunLeveys, ruudunKorkeus );
        lattia.Color = Color.Brown;
        return lattia;
    }

    GameObject LuoSeina()
    {
        PhysicsObject seina = PhysicsObject.CreateStaticObject( ruudunLeveys, ruudunKorkeus );
        seina.Color = Color.DarkGray;
        return seina;
    }

    void PelaajaOsuu( PhysicsObject pelaaja, PhysicsObject kohde )
    {
        if ( kohde is Esine )
        {
            viimeksiKoskettuEsine = (Esine)kohde;
            esineRuutu.Nayta( viimeksiKoskettuEsine );
        }
    }

    Otus LuoOttiainen()
    {
        Otus ottiainen = new Otus( 0.6, 0.6, new Animation( ottiaisenKuvat[0] ) );
        ottiainen.Mass = 20;
        ottiainen.LiikkumisAnimaatio = new Animation( ottiaisenKuvat ) { FPS = 5 };
        ottiainen.HyokkaysAnimaatio = new Animation( ottiaisenSyomisKuvat ) { FPS = 20 };
        ottiainen.KuollutKuva = ottiainenKuollutKuva;
        ottiainen.PalanutKuva = ottiainenPalanutKuva;
        ottiainen.Angle = RandomGen.NextAngle();
        Add( ottiainen, OtusTaso );
        return ottiainen;
    }

    void PaivitaLyhtya( Timer ajastin )
    {
        lyhdynValo.Position = pelaaja.Position;
        lyhdynValo.Distance = RandomGen.NextDouble( 28, 32 );
        lyhdynValo.Intensity = RandomGen.NextDouble( 0.8, 1.0 );
    }

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

    void AsetaOhjaimet()
    {
        Keyboard.Listen( Key.Escape, ButtonState.Pressed, Exit, null );
        Keyboard.Listen( Key.F11, ButtonState.Pressed, TogglaaValaistusta, null );

        Keyboard.Listen( Key.Up, ButtonState.Down, Etene, null );
        Keyboard.Listen( Key.Up, ButtonState.Released, pelaaja.Stop, null );

        Keyboard.Listen( Key.Left, ButtonState.Down, KaannaVasemmalle, null );
        Keyboard.Listen( Key.Right, ButtonState.Down, KaannaOikealle, null );
        Keyboard.Listen( Key.Left, ButtonState.Released, EiKaanny, null );
        Keyboard.Listen( Key.Right, ButtonState.Released, EiKaanny, null );

        Keyboard.Listen( Key.Q, ButtonState.Pressed, esineValikko.Vasemmalle, null );
        Keyboard.Listen( Key.W, ButtonState.Pressed, esineValikko.Oikealle, null );
        Keyboard.Listen( Key.Space, ButtonState.Pressed, KaytaValittuaEsinetta, null );

        Keyboard.Listen( Key.P, ButtonState.Pressed, Keraa, null );
    }

    void TogglaaValaistusta()
    {
        if ( Level.AmbientLight < 0.3 )
        {
            Level.AmbientLight = 0.9;
        }
        else
        {
            Level.AmbientLight = 0.2;
        }
    }

    void KaytaValittuaEsinetta()
    {
        Esine valittu = esineValikko.ValittuEsine;
        if ( valittu == null )
            return;

        switch ( valittu.Tyyppi )
        {
            case EsineenTyyppi.TuliSauva:
                KaytaTaikaSauvaa();
                break;
            case EsineenTyyppi.EnergiaSauva:
                energiaAmpumisAjastin.Start( 5 );
                break;
            case EsineenTyyppi.Lyhty:
                KaytaLamppua();
                break;
            case EsineenTyyppi.Timantti:
                break;
            default:
                break;
        }
    }

    void AmmuEnergiaPallo( Timer ajastin )
    {
        PhysicsObject energia = new PhysicsObject( 1, 1, Shapes.Circle );
        energia.MaximumLifetime = TimeSpan.FromSeconds( 6 );
        energia.Restitution = 1.5;
        energia.CollisionIgnorer = energiaIgnorer;
        AddCollisionHandler( energia, EnergiaPalloOsuu );

        energia.Animation = new Animation( energiaKuvat );
        energia.Animation.FPS = 20;
        energia.Animation.Start();

        Angle kulmanVaihtelu = RandomGen.NextAngle( Angle.Degrees( -5 ), Angle.Degrees( 5 ) );
        Vector suunta = Vector.FromLengthAndAngle( 1, pelaaja.Angle + kulmanVaihtelu );
        energia.Position = pelaaja.Position + suunta * 1;
        energia.Velocity = suunta * 3;
        energia.Angle = pelaaja.Angle;
        Add( energia, OtusTaso );
    }

    void EnergiaPalloOsuu( PhysicsObject energia, PhysicsObject kohde )
    {
        if ( kohde is Otus )
        {
            Otus otus = (Otus)kohde;
            // TODO: efekti.
            otus.TeeVahinkoa( 2 );
        }
    }

    double Etaisyys( Vector p1, Vector p2 )
    {
        double dx = p2.X - p1.X;
        double dy = p2.Y - p1.Y;
        return Math.Abs( dx * dx + dy * dy );
    }

    void Keraa()
    {
        if ( viimeksiKoskettuEsine == null )
            return;

        if ( ( Etaisyys( pelaaja.Position, viimeksiKoskettuEsine.Position ) - pelaaja.Width / 2 - viimeksiKoskettuEsine.Width / 2 ) > 0 )
            return;

        Remove( viimeksiKoskettuEsine );
        esineValikko.Add( viimeksiKoskettuEsine );

        switch ( viimeksiKoskettuEsine.Tyyppi )
        {
            case EsineenTyyppi.TuliSauva:
                GameObject klooni = new GameObject( viimeksiKoskettuEsine.Width, viimeksiKoskettuEsine.Height );
                klooni.Image = viimeksiKoskettuEsine.Image;
                pelaaja.Add( klooni );
                klooni.X = pelaaja.Width / 2 + klooni.Width / 4;
                break;
            case EsineenTyyppi.Lyhty:
                break;
            case EsineenTyyppi.Timantti:
                Level.AmbientLight = 0.8;
                MessageBox viesti = new MessageBox(
                    "Peli läpi!", "Löysit timantin, pimeys poistui maasta. Onneksi olkoon!" );
                Add( viesti );
                break;
            default:
                break;
        }

        viimeksiKoskettuEsine = null;
    }

    void KaytaLamppua()
    {
        if ( lyhdynValo.Intensity <= 0.1 )
        {
           lyhtyAjastin.Start();
        }
        else
        {
            lyhtyAjastin.Stop();
            lyhdynValo.Intensity = 0.0;
        }
    }

    void KaytaTaikaSauvaa()
    {
        Vector paikka = pelaaja.Position + Vector.FromLengthAndAngle( 1, pelaaja.Angle );
        tuliJaLeimaus.Suunta = pelaaja.Angle;
        tuliJaLeimaus.AddEffect( paikka.X, paikka.Y, 40 );

        int sateidenMaara = 5;
        Angle pieninKulma = pelaaja.Angle + Angle.Degrees( -10 );
        Angle suurinKulma = pelaaja.Angle + Angle.Degrees( 10 );
        Angle sateidenVali = ( suurinKulma - pieninKulma ) / sateidenMaara;

        for ( int i = 0; i < sateidenMaara; i++ )
        {
            Angle kulma = pieninKulma + i * sateidenVali;
            Vector suuntaVektori = Vector.FromLengthAndAngle( 1, kulma );
            RaySegment sadeKuvio = new RaySegment( suuntaVektori * 1.0, suuntaVektori, 5 );
            PhysicsObject liekinSade = new PhysicsObject( sadeKuvio );
            liekinSade.MaximumLifetime = TimeSpan.FromSeconds( 0.5 );
            liekinSade.Position = pelaaja.Position;
            liekinSade.Color = Color.Red;
            liekinSade.IsVisible = false;
            Add( liekinSade, OtusTaso );

            AddCollisionHandler( liekinSade, LiekkiSadeOsuu );
        }
    }

    void LiekkiSadeOsuu( PhysicsObject sade, PhysicsObject kohde )
    {
        if ( kohde is Otus && kohde != pelaaja )
        {
            sade.Destroy();
            Otus otus = (Otus)kohde;
            otus.Liekita();
        }
    }

    void Etene()
    {
        pelaaja.Velocity = Vector.FromLengthAndAngle( PelaajanNopeus, pelaaja.Angle );
    }

    void KaannaVasemmalle()
    {
        pelaaja.AngularVelocity = PelaajanKulmanopeus;
    }

    void KaannaOikealle()
    {
        pelaaja.AngularVelocity = -PelaajanKulmanopeus;
    }

    void EiKaanny()
    {
        pelaaja.AngularVelocity = 0;
    }
}