source: 2015/26/ohjaajat/HillbillyRun/HillbillyRun/HillbillyRun/HillbillyRun/HillbillyRun.cs @ 6214

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

/* Muistutuksia.
 * 
 * Layerit
 *   3 - 
 *   2 - 
 *   1 - 
 *   0 -
 *  -1 - Näkyvä maanpinta.
 *  -2 - Talot taustalla.
 *  
 * CollisionIgnoreGroupit
 *  3 - Ryömivät ja liekit. //TODO: lisätä noidatkin tänne
 *  2 - Kärry.
 * 
*/


//Luokka maajussien erikoisuuksille.
class HillBilly : PlatformCharacter
{
    private IntMeter lifeCounter = new IntMeter(2, 0, 2);
    public IntMeter Life 
    {
        set { lifeCounter = value; }
        get { return lifeCounter; } 
    }



    public HillBilly(double leveys, double korkeus)
        : base(leveys, korkeus)
    {
        
    }
}

/// <summary>
/// An MMO where you go to war with mages in the lava kingdom.
/// </summary>
public class HillbillyRun : PhysicsGame
{
    private List<HillBilly> players = new List<HillBilly>();
    private List<HillBilly> startingPlayers = new List<HillBilly>();

    //private List<double> playerPositionsX = new List<double>();
    //private List<double> playerPositionsY = new List<double>();

    private const double TILE_SIZE = 70;

    private double cameraTargetX; // Sijainti jossa kameran pitäisi olla.
    private Vector cameraTarget;

    private double cameraOffset = 400; // TODO: Tämän voisi ehkä laskea jostain (esim. ikkunan leveydestä kolmasosa tai jotain).
    private double cameraSpeed = 2.0; // Kameran liikkumisnopeus.

    # region Images
    private Image[] groundImages = LoadImages("ground");    //Näitä ei tosin kaikkia kenties jaksa tehdä erilaisiksi levelistä riippuen
    private Image[] groundTopImages = LoadImages("ground_top");
    private Image[] foregroundDecorations = LoadImages("viljaa");
    private Image[] blockImages = LoadImages("box");

    private Image[] houseImages = LoadImages("house", "houseburned");

    private Image cartImage = LoadImage("cart");
    private Image milkImage = LoadImage("tonkka");
    
    private Image cartWheelImage = LoadImage("cartwheel");

    private Image smokeImage1 = LoadImage("smoke1");
    private Image smokeImage2 = LoadImage("smoke2");

    private Animation crawl;
    private Animation blaze;
    #endregion 

    private double leftCamLimit;
    private double rightCamLimit;
    private double bottomCamLimit;

    private int levelNumber = 0;
   
    public override void Begin()
    {
        //IntroSequence();
        //MainMenu();
        StartGame();
    }

    #region Intro
    void IntroSequence()
    {
        Level.Background.Color = Color.Black;

        Label storyLabel = new Label("Once upon a time...");
        storyLabel.TextColor = Color.Gray;
        Add(storyLabel);

        Timer textTimer = new Timer();
        textTimer.Interval = 0.5;
        textTimer.Timeout += delegate
        {
            // TODO vaalenna tekstiä näkyville läpinäkyvyyttä tms. säätämällä
            
        };

        // TODO siirrä aliohjelmaan, jolle voi antaa parametrina stringin, joka näytetään siististi feidaamalla esille



        // TODO replace this SingleShot with something else. It must be the last thing after the intro sequence
        
        // Clean up after the intro:
        Timer.SingleShot(5, delegate
        {
            storyLabel.Destroy();

            ClearAll();
            MainMenu();
        });
    }

    void MainMenu()
    {
        Level.Background.Color = Color.MediumBlue;

        MultiSelectWindow mainmenu = new MultiSelectWindow("Main menu",
"Start game", "Credits", "Exit");
        mainmenu.AddItemHandler(0, StartGame);
        mainmenu.AddItemHandler(1, ShowCredits);
        mainmenu.AddItemHandler(2, Exit);
        mainmenu.DefaultCancel = 2;
        Add(mainmenu);
    }

    void ShowCredits()
    {
        MessageWindow win = new MessageWindow("This game was made in one week by\nSimo Rinne,\nEmma Heikura,\n and Jouni Potila\n using University of Jyväskylä's\n game programming library Jypeli");
        win.Closed += delegate
        {
            ClearAll();
            MainMenu();
        };
        Add(win);
    }
    #endregion

    void StartGame()
    {
        Initializing();
        CreateLevel();
        ScreenSettings();

        // Testailen tässä kärryn luomista.
        //double size = 0.7;
        //PhysicsObject cart = new PhysicsObject(400 * size, 80 * size);
        //cart.X = -1600;
        //cart.Y = 200;
        //cart.Image = cartImage;
        //cart.CollisionIgnoreGroup = 2;
        //Add(cart);
        //PhysicsObject cartWheel = new PhysicsObject(160 * size, 160 * size, Shape.Circle);
        //cartWheel.Image = cartWheelImage;
        //cartWheel.Position = cart.Position + new Vector(-110, -30) * size;
        //cartWheel.CollisionIgnoreGroup = 2;
        //Add(cartWheel);
        //AxleJoint joint = new AxleJoint(cart, cartWheel);
        //Add(joint);
    }

    void Initializing()
    {
        crawl = LoadAnimation("crawl");
        blaze = LoadAnimation("flame");
    }

    void ScreenSettings()
    {
        Window.Width = 1800;
        Window.Height = 900;

        leftCamLimit = Level.Left + Window.Width / 2.0;
        rightCamLimit = Level.Right - Window.Width / 2.0;
        bottomCamLimit = Level.Bottom + Window.Height / 2.0;

        //Camera.X = cameraTargetX = players[0].X;
        //Camera.ZoomToLevel();
        Camera.X = cameraTargetX = leftCamLimit;

        Timer cameraTimer = new Timer();
        cameraTimer.Interval = 1 / 30.0;
        cameraTimer.Timeout += UpdateCamera;
        cameraTimer.Start();
    }

    #region LevelCreation
    void CreateLevel()
    {
        Gravity = new Vector(0, -1000);

        ColorTileMap level = ColorTileMap.FromLevelAsset("level" + levelNumber);
        level.SetTileMethod(Color.Black, CreateGroundTop);
        level.SetTileMethod(Color.Brown, CreateGround);

        level.SetTileMethod(Color.Cyan, CreateHouse);
        level.SetTileMethod(Color.PaintDotNetBlue, CreateBurnedHouse);

        level.SetTileMethod(Color.Gold, CreatePlayer);
        level.SetTileMethod(Color.Harlequin, CreateCart);
        level.SetTileMethod(Color.White, CreateBlockObject); 
        level.SetTileMethod(Color.DarkGray, CreateMilk);   
        level.SetTileMethod(Color.Gray, CreateCrawly);  
        level.SetTileMethod(Color.Red, CreateDummy, Color.Red);    //TODO: CreateWitch
        level.SetTileMethod(Color.Rose, CreateFlame);   
        //level.SetTileMethod(Color.Azure, CreateDummy, Color.Azure);   //TODO: CreateSmoke
        //level.SetTileMethod(Color.Orange, CreateDummy, Color.Orange); //TODO: CreateTombstone
        level.Execute(TILE_SIZE, TILE_SIZE);
        level.Optimize(Color.Black, Color.Brown);

        //TileMap level = TileMap.FromLevelAsset("level" + levelNumber);
        //level.SetTileMethod('P', CreatePlayer);
        //level.SetTileMethod('#', CreateGroundTop);
        //level.SetTileMethod('%', CreateGround);
        //level.Optimize('#', '%');
        //level.Execute(TILE_SIZE, TILE_SIZE);
        //Level.CreateBorders(true);

        SetControls();
    }

    void CreateFlame(Vector position, double width, double height)
    {
        PhysicsObject flame = PhysicsObject.CreateStaticObject(width, height * 2);
        //flame.Image = flameImage;
        flame.Color = Color.Red;
        double hieman = height * 0.3;
        flame.Position = position - new Vector(0, hieman);
        flame.CollisionIgnoreGroup = 3;
        flame.Tag = "burn";
        flame.Animation = new Animation(blaze) { FPS = RandomGen.NextInt(20, 26) };
        flame.Animation.Step(RandomGen.NextInt(0, 12));
        flame.Animation.Resume();
        Add(flame);

        Smoke savu = new Smoke();
        savu.ParticleImage = smokeImage1;
        savu.OuterParticleImage = smokeImage2;
        savu.MaxLifetime = 1.0;
        savu.MaxScale = 200;
        savu.MinScale = 10;
        savu.Position = flame.Position;
        Wind = new Vector(-10, 0);
        Add(savu);
    }

    void CreateBlockObject(Vector position, double width, double height)
    {
        PhysicsObject block = PhysicsObject.CreateStaticObject(width, height);
        block.Image = blockImages[levelNumber];
        block.Position = position;
        Add(block);
    }

    void CreateMilk(Vector position, double width, double height)
    {
        GameObject milk = new GameObject(milkImage.Width, milkImage.Height);
        milk.Image = milkImage;
        milk.Position = position;
        milk.Tag = "milk";
        Add(milk);
    }

    void CreateCrawly(Vector position, double width, double height)
    {
        PlatformCharacter crawly = new PlatformCharacter(width * 2, height);
        crawly.Position = position;
        crawly.Color = Color.Gray;
        crawly.Animation = crawl;
        crawly.Animation.Start();
        crawly.Tag = "burn";
        crawly.CollisionIgnoreGroup = 3;
        Add(crawly);

        PlatformWandererBrain brain = new PlatformWandererBrain();
        brain.Speed = 20;
        brain.FallsOffPlatforms = true;

        crawly.Brain = brain;
    }

    void CreateHouse(Vector position, double width, double height)
    {
        // Näkyvä talo
        GameObject house = new GameObject(width * 10, height * 8);
        house.Image = houseImages[0];
        house.Position = position - new Vector(0, height * 2.5);
        Add(house, -2);

        //Seisottava tasanne
        PhysicsObject platform = PhysicsObject.CreateStaticObject(house.Width - (TILE_SIZE * 3.25), 1);     //Tätä kohtaa on nyt vähän hakemalla haettu.
        platform.IsVisible = false;
        platform.Position = new Vector(house.X + (TILE_SIZE * 0.5), house.Top);
        Add(platform);
    }

    void CreateBurnedHouse(Vector position, double width, double height)
    {
        GameObject house = new GameObject(width * 10, height * 8);
        house.Image = houseImages[1];
        house.Position = position - new Vector(0, height * 2.5);
        Add(house, -2);

        PhysicsObject platform = PhysicsObject.CreateStaticObject(house.Width* 0.25, 1);
        platform.IsVisible = false;
        platform.Position = new Vector(house.X + platform.Width * 0.5, house.Top);
        Add(platform);
    }

    private void CreateCart(Vector position, double width, double height)
    {
        double size = 0.7;
        PhysicsObject cart = new PhysicsObject(400 * size, 80 * size);
        cart.Position = position;
        cart.Image = cartImage;
        cart.CollisionIgnoreGroup = 2;
        Add(cart);
        PhysicsObject cartWheel = new PhysicsObject(160 * size, 160 * size, Shape.Circle);
        cartWheel.Image = cartWheelImage;
        cartWheel.Position = cart.Position + new Vector(-110, -30) * size;
        cartWheel.CollisionIgnoreGroup = 2;
        Add(cartWheel);
        AxleJoint joint = new AxleJoint(cart, cartWheel);
        Add(joint);
    }


    private void CreateDummy(Vector position, double width, double height, Color color)
    {
        PhysicsObject dummy = PhysicsObject.CreateStaticObject(width, height);
        dummy.Position = position;
        dummy.Color = color;
        Add(dummy);
    }

    void CreatePlayer(Vector position, double width, double height)
    {
        HillBilly player = new HillBilly(width, height * 2);
        player.Shape = Shape.Rectangle;
        player.Position = position + new Vector(0, height * 0.5);
        player.Color = Color.White;
        players.Add(player);
        startingPlayers.Add(player);
        Add(player);
        AddCollisionHandler(player, "burn", delegate(PhysicsObject p, PhysicsObject t) 
        {
            HillBilly billy = p as HillBilly;
            billy.Life.Value--;

        }
        );

        player.Life.LowerLimit += delegate 
        { 
            players.Remove(player); player.Destroy();
            if (players.Count < 1)
            {
                Loss();
            }
        };
    }

    void CreateGroundTop(Vector position, double width, double height)
    {
        // Puolet pienempi näkymätön palikka alla johon törmää.
        PhysicsObject ground = PhysicsObject.CreateStaticObject(width, height / 2.0);
        ground.IsVisible = false;
        ground.Position = position - new Vector(0.0, TILE_SIZE / 4.0);
        Add(ground);

        // Maanpinnan näkyvä osa.
        GameObject visibleGround = new GameObject(width, height);
        visibleGround.Image = groundImages[levelNumber];
        visibleGround.Position = position;
        visibleGround.TextureWrapSize = new Vector(width / TILE_SIZE, height / TILE_SIZE);
        Add(visibleGround, -1);

        int probability = RandomGen.NextInt(100);
        bool wheat = probability < 20;

        if(wheat)
        {
            GameObject wheatBlock = new GameObject(width * 1.5, height * 3);
            wheatBlock.Image = foregroundDecorations[0];
            wheatBlock.Position = visibleGround.Position;
            Add(wheatBlock, 2);
        }
    }

    void CreateGround(Vector position, double width, double height) 
    {
        PhysicsObject ground = PhysicsObject.CreateStaticObject(width, height);
        ground.Image = groundTopImages[levelNumber];
        ground.Position = position;
        ground.TextureWrapSize = new Vector(width / TILE_SIZE, height / TILE_SIZE);
        Add(ground);
    }
    #endregion

    void SetControls()
    {
        Keyboard.Listen(Key.A, ButtonState.Down, delegate { startingPlayers[0].Walk(-300); }, "Player 1 moves left");
        Keyboard.Listen(Key.D, ButtonState.Down, delegate { startingPlayers[0].Walk(300); }, "Player 1 moves right");
        Keyboard.Listen(Key.W, ButtonState.Down, delegate { startingPlayers[0].Jump(1000); }, "Player 1 jumps");

        Keyboard.Listen(Key.Left, ButtonState.Down, delegate { startingPlayers[1].Walk(-300); }, "Player 2 moves left");
        Keyboard.Listen(Key.Right, ButtonState.Down, delegate { startingPlayers[1].Walk(300); }, "Player 2 moves right");
        Keyboard.Listen(Key.Up, ButtonState.Down, delegate { startingPlayers[1].Jump(1000); }, "Player 2 jumps");

        Keyboard.Listen(Key.F1, ButtonState.Pressed, ShowControlHelp, "Show help");
        Keyboard.Listen(Key.Escape, ButtonState.Pressed, ConfirmExit, "Exit game");
    }

    void Loss()
    {
        //TODO: Sumthin' flashy for our fallen friends.
        Exit();
    }

    #region Camera
    void UpdateCamera()
    {
        double minY = players.Min(p => p.Y);
        double maxY = players.Max(p => p.Y);
        double minX = players.Min(p => p.X) + cameraOffset;

        Vector minPosition = new Vector(Math.Max(minX, cameraTargetX), minY);
        Vector maxPosition = new Vector(minX, maxY);

        cameraTarget = (minPosition + maxPosition) * 0.5;
        cameraTarget.X = Math.Max(cameraTargetX, minX);     //Lellllll.

        //cameraTarget.Y = Math.Max(cameraTarget.X, Level.Bottom + Window.Height/2.0);

        cameraTargetX = Math.Max(cameraTargetX, minX);

        cameraTarget.X = Math.Min(cameraTargetX, rightCamLimit);
        cameraTarget.Y = Math.Max(cameraTarget.Y, bottomCamLimit);

        double windowMax = Camera.ScreenToWorld(new Vector(Window.Width / 2.0, 0)).X;
        double windowMin = Camera.ScreenToWorld(new Vector(-Window.Width / 2.0, 0)).X;
        foreach (var player in players)
        {
            player.Left = Math.Max(player.Left, windowMin);
            player.Right = Math.Min(player.Right, windowMax);
        }
    }

    protected override void Update(Time time)
    {
        Camera.Position += (cameraTarget - Camera.Position) * time.SinceLastUpdate.TotalSeconds * cameraSpeed;
        //Camera.X += (cameraTargetX - Camera.X) * time.SinceLastUpdate.TotalSeconds * cameraSpeed;


        base.Update(time);
    }

    /// <summary>
    /// Yritän leikkiä kameralla. Vielä varmaan hetken pidempään.
    /// </summary>
    /// <param name="gameTime"></param>
    /*
    protected override void Update(Microsoft.Xna.Framework.GameTime gameTime)
    {
        foreach(HillBilly player in players)
        {
            playerPositionsX.Add(player.Position.X);
            playerPositionsY.Add(player.Position.Y);
        }

        double maxX = playerPositionsX.Max();
        double maxY = playerPositionsY.Max();
        double minX = playerPositionsX.Min();
        double minY = playerPositionsY.Min();

        Vector minPosition = new Vector(minX, minY);
        Vector maxPosition = new Vector(maxX, maxY);

        Camera.Position = (minPosition + maxPosition) * 0.5;

        playerPositionsX.Clear();
        playerPositionsY.Clear();

        base.Update(gameTime);
    }
     */
    #endregion
}