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

using System;
using System.Collections.Generic;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using System.Runtime.InteropServices;
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.
 * 
*/

#region Improvement
public abstract class Improvement : PlatformCharacter
{
    public List<Animation> Animations { get; set; }

    protected Improvement(double width, double height)
        : base(width, height)
    {

    }

    public HillBilly Owner
    {
        get { return owner; }
        set { owner = value; }
    }
    private HillBilly owner;

    public virtual void DoTheThing(HillbillyRun game) { }

    public SoundEffect sound;

    public void Rid()
    {
        Owner.AnimWalk = Owner.Animations[0];
        Owner.AnimIdle = Owner.Animations[1];
        Owner.Improvement = null;
        Owner = null;
    }
}

public class MilkImprovement : Improvement
{
    public override void DoTheThing(HillbillyRun game)
    {
        //HillbillyRun game = this.Game as HillbillyRun;
        Owner.PlayAnimation(Animations[1]);
        game.CreateMilkParticles(this.Owner, 10, 200, 300, new Vector(0, -30), "milkparticle");
        this.sound.Play();
    }

    public MilkImprovement(double width, double height)
        : base(width, height)
    {

    }
}


public class PitchForkImprovement : Improvement
{
    public override void DoTheThing(HillbillyRun game)
    {
        //HillbillyRun game = this.Game as HillbillyRun;
        //game.CreateMilkParticles(this.Owner, 10, 200, 300, new Vector(0, -30), "milkparticle");
        //TODO: hitting things w/ pitchfork
        game.ForkThings(Owner);
    }

    public PitchForkImprovement(double width, double height)
        : base(width, height)
    {

    }
}
#endregion

public class HillBilly : PlatformCharacter
{
    public List<Animation> Animations { get; set; }

    private IntMeter lifeCounter = new IntMeter(4, 0, 4);
    public IntMeter Life
    {
        set { lifeCounter = value; }
        get { return lifeCounter; }
    }

    public Improvement Improvement { get; set; }

    public Label Name { get; set; }

    private ProgressBar visibleLife;
    public ProgressBar VisibleLife
    {
        get { return visibleLife; }
        set { visibleLife = value; }
    }

    public void GainImprovement(Improvement improvement)
    {

        this.AnimWalk = improvement.Animations[0];
        this.AnimIdle = new Animation(improvement.Animations[0].CurrentFrame);
        this.Improvement = improvement;
        improvement.Owner = this;

        //improvement.Destroy();
    }

    public void UseImprovement()
    {
        HillbillyRun game = this.Game as HillbillyRun;
        if (this.Improvement == null)
        {
            game.CreateMilkParticles(this, 5, 100, 100, new Vector(0, Height / 3), "tears");
        }
        else if (Animation != this.Improvement.Animations[1])
        {
            this.Improvement.DoTheThing(game);
        }
    }

    public HillBilly(double leveys, double korkeus, String name)
        : base(leveys, korkeus)
    {

        this.visibleLife = new ProgressBar(50, 15); //(this.Width, this.Height/8);
        this.Add(visibleLife);
        this.visibleLife.Position += new Vector(0, this.Height / 2 + this.Height / 5);
        this.visibleLife.BindTo(this.lifeCounter);
        this.visibleLife.Color = Color.Black;

        this.Name = new Label(name);
        this.Add(Name);
        this.Name.Position += new Vector(0, this.Height / 2 + this.Height / 3);
    }
}

/// <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 PLAYER_SPEED = 180;
    public const double TILE_SIZE = 70;

    public String[] names = new String[] { "Adolfiina", "Rasputiina", "Hermanniina", "Joosefiina" };

    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", "ground_forest", "ground_volcano");
    private Image[] groundTopImages = LoadImages("ground_top", "ground_top_forest", "ground_top_volcano");
    private Image[] foregroundDecorations = LoadImages("viljaa", "grass", "grass");
    private Image[] blockImages = LoadImages("box2", "rock");
    private Image[] decorationImages = LoadImages("paali", "tree1");

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

    private Image cartImage = LoadImage("cart");
    private Image milkImage = LoadImage("tonkkaitem");
    private Image pitchforkImage = LoadImage("fork");

    private Image cartWheelImage = LoadImage("cartwheel");

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

    private Image treeTrunkImage = LoadImage("bigtree");
    private Image treeBottomImage = LoadImage("bigtree3x2");
    private Image treeBranchImage = LoadImage("bigtreebranch");
    private Image forestBackgroundImage = LoadImage("forestbackground");
    private Image volcanoBackgroundImage = LoadImage("volcanobackground");
    private Image swingTrapImage = LoadImage("tukki");

    private Image gateImage = LoadImage("gate");
    private Image leverLeftImage = LoadImage("lever_left");
    private Image leverRightImage = LoadImage("lever_right");

    private Image lavaWallImage = LoadImage("lavawall");
    private Image lavaFloorImage = LoadImage("lavafloor");
    private Image spikeImage = LoadImage("spikes");
    private Image spikeLeftImage = LoadImage("spikeleft");

    private Image prisonerImage = LoadImage("prisoner");

    private Image deathImage = LoadImage("loppukuva");

    private Animation crawl;
    private Animation blaze;

    private Animation pitchforkAttack;
    private Animation pitchforkWalk;
    private Animation milkThrow;
    private Animation milkWalk;
    private Animation normalWalk;
    private Animation playerIdle;
    private Animation playerJump;
    private Animation playerFall;
    private Animation firemageAnimation;
    private Animation firemageCastAnimation;
    private Animation wormAnimation;
    private Animation tattiMageAnimation;
    private Animation tattiMageCastAnimation;
    private Animation fireballAnimation;
    private Animation hedgehogAnimation;

    private Animation bossRiseAnimation;
    private Animation bossFallAnimation;
    private Animation bossHitAnimation;
    private Animation bossHurtAnimation;
    #endregion

    #region Sounds
    private SoundEffect splash = LoadSoundEffect("splash");
    #endregion

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

    private int levelNumber = 0;

    private bool invincibility = false;
    private Action activateBoss;
    private Timer fireballTimer;

    public override void Begin()
    {
        Initializing();
        IntroSequence();
        //MainMenu();
        //StartGame();
    }

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

        Keyboard.Listen(Key.Escape, ButtonState.Pressed, SkipIntro, "Skip");
        Keyboard.Listen(Key.Enter, ButtonState.Pressed, SkipIntro, "Skip");

        ShowMadeWithJypeli();

        Timer.SingleShot(4.0, delegate // TODO get rid of fixed amount of seconds
        {
            ShowBackgroundStory();
        });



    }

    void ShowMadeWithJypeli()
    {
        Image madewithImage = LoadImage("madewithjypeli");

        double w = Window.Width / 4;
        double h = w * (madewithImage.Height / (double)madewithImage.Width); // take aspect ratio from the picture

        GameObject madewithjypeliObject = new GameObject(w, h);
        madewithjypeliObject.Image = madewithImage;
        Add(madewithjypeliObject);

        // Tässä oli jotain epätehokasta feidailua tuolle Made with Jypeli -kuvalle. Ei tunnu päivittyvän joka framella tai on muuten vain tosi raskas...

        //fadeTimer = new Timer();
        //fadeTimer.Interval = 0.5;
        //fadeTimer.Timeout += delegate
        //{
        //    madewithjypeliObject.Image = LerpImage(madewithjypeliObject.Image, Color.Black, 0.6);
        //};
        //fadeTimer.Start(5);

        Timer.SingleShot(1.2, delegate
        {
            madewithjypeliObject.Destroy();
        });

    }

    Image LerpImage(Image original, Color targetColor, double ratio)
    {
        Image newImage = new Image(original.Width, original.Height, Color.Transparent);
        for (int y = 0; y < original.Height; y++)
        {
            for (int x = 0; x < original.Width; x++)
            {
                newImage[y, x] = Color.Lerp(original[y, x], targetColor, ratio);
            }
        }
        return newImage;
    }

    void ShowBackgroundStory()
    {
        MediaPlayer.Play("hillbilly_intro");
        ShowStoryText(new Queue<string>(new[] { "Innit just da warmest here, sis?", "Seems to me our establishment's a-burnin'.", "...Musta been 'em nasty witches!" }));
    }

    void ShowStoryText(Queue<string> messages)
    {
        // Mennään alkuvalikkoon jos ei ole enää viestejä.
        if (messages.Count == 0)
        {
            MainMenu();
            return;
        }

        // Näytetään nykyinen viesti.
        var storyLabel = new Label(messages.Dequeue()) { TextColor = Color.Black, TextScale = new Vector(3, 3) };
        Add(storyLabel);

        var textTimer = new Timer { Interval = 0.05 };
        textTimer.Timeout += () => storyLabel.TextColor = Color.Lerp(storyLabel.TextColor, Color.White, 0.05);
        textTimer.Start();

        // Näytetään seuraava viesti muutaman sekunnin päästä.
        Timer.SingleShot(4, delegate { storyLabel.Destroy(); ShowStoryText(messages); });
    }

    void SkipIntro()
    {
        ClearTimers();
        ClearAll();
        Keyboard.Clear();
        MainMenu();
    }

    void MainMenu()
    {
        Level.Background.CreateGradient(Color.DarkBrown, Color.Black);
        
        if (MediaPlayer.IsPlaying == false) MediaPlayer.Play("hillbilly_intro");

        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);
        mainmenu.Color = Color.DarkBrown;
        mainmenu.FadeColorTo(Color.Brown, 30);
        mainmenu.SetButtonColor(Color.Charcoal);
        mainmenu.SelectionColor = Color.DarkBlue;
        mainmenu.SetButtonTextColor(Color.LightGray);
        

    }

    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()
    {
        ClearAll();
        CreateLevel();
        ScreenSettings();
        SetControls();
    }

    public void NextLevel()
    {
        levelNumber++;
        StartGame();
    }

    void Initializing()
    {
        crawl = LoadAnimation("crawl");
        blaze = LoadAnimation("flame");
        pitchforkAttack = LoadAnimation("attack");
        pitchforkWalk = LoadAnimation("hanko");
        milkThrow = LoadAnimation("heitto");
        milkWalk = LoadAnimation("tonkka");
        normalWalk = LoadAnimation("pwalk");
        playerIdle = LoadAnimation("idle");
        playerJump = LoadAnimation("jump");
        playerFall = LoadAnimation("fall");
        firemageAnimation = LoadAnimation("firemage");
        firemageCastAnimation = LoadAnimation("firemagecast");
        wormAnimation = LoadAnimation("worm");
        tattiMageAnimation = LoadAnimation("tattimage");
        tattiMageCastAnimation = LoadAnimation("tattimagecast");
        bossRiseAnimation = LoadAnimation("bossrise");
        bossFallAnimation = LoadAnimation("bossfall");
        bossHitAnimation = LoadAnimation("bosshit");
        bossHurtAnimation = LoadAnimation("bosshurt");
        fireballAnimation = LoadAnimation("fireball");
        hedgehogAnimation = LoadAnimation("siili");

        cameraOffset = Window.Width / 4;
    }

    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 = cameraTarget.X = cameraTargetX = leftCamLimit;

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

        // Background trees.
        if (levelNumber < 2)
        {
            GameObject forestBackground = new GameObject(Level.Width, Level.Height);
            forestBackground.Image = forestBackgroundImage;
            forestBackground.TextureWrapSize = new Vector(5, 1);
            Add(forestBackground, -3);
            Layers[-3].RelativeTransition = new Vector(0.5, 1.0);
        }

        // Background color.
        if (levelNumber == 0)
        {
            Level.Background.CreateGradient(Color.Black, Color.SkyBlue);
        }
        else if (levelNumber == 1)
        {
            Level.Background.CreateGradient(Color.Black, Color.FromHexCode("495147"));
        }
        else if (levelNumber == 2)
        {
            Level.Background.Image = volcanoBackgroundImage;
            Level.Background.FitToLevel();
        }
    }

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

        //Tilemap
        ColorTileMap level = ColorTileMap.FromLevelAsset("level" + levelNumber);
        //ColorTileMap level = ColorTileMap.FromLevelAsset("bosstest");
        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.FromHexCode("A17FFF"), CreatePitchfork);

        level.SetTileMethod(Color.Gray, (new AbstractTileMap<Color>.TileMethod[] { CreateCrawly, CreateWorm, null })[levelNumber]); // ಠ_ಠ
        level.SetTileMethod(Color.Red, (new AbstractTileMap<Color>.TileMethod[] { CreateFireMage, CreateShroom, CreateBoss })[levelNumber]);
        level.SetTileMethod(Color.White, CreateBlockObject);
        level.SetTileMethod(Color.DarkGray, CreateMilk);
        level.SetTileMethod(Color.Rose, CreateFlame, true);
        level.SetTileMethod(Color.FromHexCode("0094FF"), CreateDecoration);   //TODO: CreateSmoke
        level.SetTileMethod(Color.FromHexCode("E256FF"), CreateHedgehog);
        //level.SetTileMethod(Color.Orange, CreateDummy, Color.Orange); //TODO: CreateTombstone

        level.SetTileMethod(Color.FromHexCode("FF6A00"), CreateTreeTrunk);  
        level.SetTileMethod(Color.FromHexCode("57007F"), CreateTreeRoot);   
        level.SetTileMethod(Color.FromHexCode("00FF21"), CreateTreeBranch);
        level.SetTileMethod(Color.FromHexCode("5B7F00"), CreateSwingTrap);

        level.SetTileMethod(Color.FromHexCode("7FBA00"), CreateGate);
        level.SetTileMethod(Color.FromHexCode("4C7F00"), CreateLevel);

        level.SetTileMethod(Color.FromHexCode("FF00DC"), CreateSpike, spikeImage);
        level.SetTileMethod(Color.FromHexCode("C600AC"), CreateSpike, spikeLeftImage);

        level.SetTileMethod(Color.FromHexCode("FF8C8C"), CreateLava);

        level.SetTileMethod(Color.FromHexCode("BADA55"), CreatePrisoner); // Lempivärini.

        level.Optimize(Color.Brown);    //Color.Black   //Tekee jännittäviä asioita wheatille, jos optimoidaan (tietysti). Jotenn. 
        level.Execute(TILE_SIZE, TILE_SIZE);

        // Kolmanteen kenttään laavaseinä ja tulipalloja
        if (levelNumber == 2)
        {
            GameObject lava = new GameObject(300, Level.Height);
            lava.Image = lavaWallImage;
            lava.X = Camera.ScreenToWorld(new Vector(-Window.Width / 2.0, 0)).X;
            Add(lava, 3);

            PhysicsObject lavaCollision = PhysicsObject.CreateStaticObject(50, Level.Height);
            lavaCollision.IsVisible = false;
            lavaCollision.Left = lava.Left;
            lavaCollision.Tag = "lava";
            Add(lavaCollision);

            var updateTimer = new Timer { Interval = 0.01 };
            updateTimer.Timeout += delegate
            {
                lava.Left = Camera.X - Window.Width / 2.0;
                lavaCollision.Left = lava.Left;
            };
            updateTimer.Start();

            fireballTimer = new Timer { Interval = 10.0 };
            fireballTimer.Timeout += delegate
            {
                var fireball = PhysicsObject.CreateStaticObject(100, 40);
                fireball.IgnoresCollisionResponse = true;
                fireball.Animation = new Animation(fireballAnimation);
                fireball.Animation.Start();
                fireball.Y = RandomGen.SelectOne<HillBilly>(players).Position.Y;
                fireball.X = Camera.X + Window.Width / 2.0;
                fireball.Velocity = new Vector(-100, 0);
                fireball.LifetimeLeft = TimeSpan.FromSeconds(20);
                fireball.Tag = "burn";
                Add(fireball);
            };
            fireballTimer.Start();
        }
    }

    void CreateHedgehog(Vector position, double width, double height)
    {
        PlatformCharacter hedgehog = new PlatformCharacter(width, height * 0.6);
        hedgehog.Position = position;
        hedgehog.Animation = hedgehogAnimation;
        hedgehog.Animation.FPS = RandomGen.NextInt(18, 24);
        hedgehog.Animation.Step(RandomGen.NextInt(0, 16));
        hedgehog.Animation.Resume();
        hedgehog.Tag = "burn";
        hedgehog.CollisionIgnoreGroup = 3;
        Add(hedgehog, 1);

        PlatformWandererBrain brain = new PlatformWandererBrain();
        brain.Speed = 60;
        brain.FallsOffPlatforms = false;
        brain.TriesToJump = true;
        hedgehog.Brain = brain;

        AddCollisionHandler(hedgehog, "pitchfork", delegate(PhysicsObject w, PhysicsObject p) { w.Destroy(); });
    }

    void CreateDecoration(Vector position, double width, double height)
    {
        GameObject decoration = new GameObject(width * 2, height * 3);
        decoration.Position = position;
        //decoration.Top = position.Y - height * 0.5;
        //decoration.Animation = bossRiseAnimation;
        decoration.Image = decorationImages[levelNumber];
        Add(decoration, -2);
    }

    void CreateBoss(Vector position, double width, double height)
    {
        GameObject boss = new GameObject(700, 522);
        boss.Position = position;
        boss.Top = position.Y - height * 0.5;
        boss.Animation = bossRiseAnimation;
        Add(boss, -3);

        List<PhysicsObject> eyes = null; // Lista jotta voi käyttää kätevästi ForEach:ia.
        var health = new IntMeter(3, 0, 3); // Vähenee vain heinähangolla.
        var eyeHealth = new IntMeter(30, 0, 30); // Vähenee maidon loiskutuksella.

        eyeHealth.LowerLimit += delegate
        {
            // Bossi kaatuaa maahan.
            eyes.ForEach(e => e.IsVisible = false);
            boss.Animation = bossFallAnimation;
            boss.Animation.StopOnLastFrame = true;
            boss.Animation.Start(1);

            // Bossi palautuu takaisin lyöntianimaatioonsa hetken päästä.
            Timer.SingleShot(5.0, delegate
            {
                boss.Animation = bossHitAnimation;
                eyeHealth.Value = eyeHealth.MaxValue;
                eyes.ForEach(e => e.IsVisible = true);
            });
        };

        // Alue johon pitää lyödä heinähangolla.
        var headCollision = PhysicsObject.CreateStaticObject(50, 50);
        headCollision.IsVisible = false;
        headCollision.IgnoresCollisionResponse = true;
        Add(headCollision);
        AddCollisionHandler(headCollision, "pitchfork", delegate(PhysicsObject h, PhysicsObject fork)
        {
            if (boss.Animation == bossFallAnimation)
            {
                health.Value--;

                boss.Animation = bossHurtAnimation;
                boss.Animation.Start(1);
                boss.Animation.Played += () => boss.Animation = bossFallAnimation;
            }
        });
        var headMoveTimer = new Timer { Interval = 0.01 };
        headMoveTimer.Timeout += delegate
        {
            headCollision.Position = boss.Position + new Vector(-10, 0);
        };
        headMoveTimer.Start();
        headCollision.Destroyed += headMoveTimer.Stop;

        // Lyöntianimaation päätteeksi lisätään kiviä.
        bossHitAnimation.Played += delegate
        {
            var rock = new PhysicsObject(30, 30);
            rock.Position = boss.Position + new Vector(RandomGen.NextDouble(-650, 100), 300);
            rock.Image = blockImages[1];
            rock.Tag = "burn";
            rock.LifetimeLeft = TimeSpan.FromSeconds(2.0);
            Add(rock);
        };

        // Silmien luonti funktio.
        Func<int, int, PhysicsObject> eyeFlame = (x, y) =>
        {
            var flame = PhysicsObject.CreateStaticObject(width * 0.3, height * 0.6);
            flame.Animation = new Animation(blaze);
            flame.IgnoresCollisionResponse = true;
            flame.IsVisible = false;
            flame.Animation.Start();
            Add(flame);
            AddCollisionHandler(flame, "milkparticle", delegate(PhysicsObject f, PhysicsObject particle)
            {
                // Otetaan vahinkoa vain kun ollaan näkyvillä.
                if (flame.IsVisible)
                {
                    particle.Destroy();
                    eyeHealth.Value--;
                }
            });
            var moveTimer = new Timer { Interval = 0.01 };
            moveTimer.Timeout += delegate
            {
                flame.Position = boss.Position + new Vector(x, y);
            };
            moveTimer.Start();
            flame.Destroyed += moveTimer.Stop;
            return flame;
        };

        eyes = new List<PhysicsObject>(new[] { eyeFlame(0, 150), eyeFlame(40, 145) });

        // Tuhotaan bossi kun se kuolee.
        health.LowerLimit += delegate
        {
            eyes.ForEach(e => e.Destroy());
            boss.Destroy();
            headCollision.Destroy();
            Timer.SingleShot(4.0, Victory);
        };

        // Kutsutaan kun pelaajat saapuu kentän päähän.
        activateBoss = delegate
        {
            // Nostetaan bossi ylös maasta.
            boss.MoveTo(position + new Vector(0, boss.Height * 0.4), 500);
            boss.Animation.Start(1);
            boss.Animation.StopOnLastFrame = true;
            boss.Animation.Played += delegate
            {
                // Taistelu alkaa.
                eyes.ForEach(e => e.IsVisible = true);

                // Laitetaan lyöntianimaatio päälle.
                boss.Animation = bossHitAnimation;
                boss.Animation.Start();
            };
        };
    }

    void CreatePrisoner(Vector position, double width, double height)
    {
        GameObject prisoner = new GameObject(width * 1.2, height * 2);
        prisoner.Position = position;
        prisoner.Y -= height / 2.0;
        prisoner.Image = prisonerImage;
        Add(prisoner, 1);
    }

    void CreateSpike(Vector position, double width, double height, Image img)
    {
        PhysicsObject spike = PhysicsObject.CreateStaticObject(width, height);
        spike.Image = img;
        spike.Position = position;
        spike.Y -= (img == spikeImage) ? height * 0.5 : 0.0;
        spike.Tag = "burn";
        Add(spike);
    }

    void CreateLava(Vector position, double width, double height)
    {
        GameObject lava = new GameObject(width * 13, height * 5);
        lava.Image = lavaFloorImage;
        lava.Position = position;
        lava.Left = position.X - width * 0.5;
        lava.Bottom = position.Y - height * 0.5;
        Add(lava, 3);

        PhysicsObject lavaCollision = PhysicsObject.CreateStaticObject(width * 13, height);
        lavaCollision.IsVisible = false;
        lavaCollision.Position = position;
        lavaCollision.Left = position.X - width * 0.5;
        lavaCollision.Tag = "lava";
        Add(lavaCollision);
    }

    void CreateGate(Vector position, double width, double height)
    {
        PhysicsObject gate = PhysicsObject.CreateStaticObject(width, height);
        gate.Image = gateImage;
        gate.Color = Color.HotPink;
        gate.Position = position;
        gate.Y -= height / 2.0;
        gate.Tag = "gate";
        Add(gate);
    }

    void CreateLevel(Vector position, double width, double height)
    {
        PhysicsObject lever = PhysicsObject.CreateStaticObject(width * 0.5, height);
        lever.Image = leverLeftImage;
        lever.Color = Color.Green;
        lever.Position = position;
        lever.Y -= height / 2.0;
        lever.IgnoresCollisionResponse = true;
        Add(lever);

        AddCollisionHandler(lever, "player", delegate(PhysicsObject p, PhysicsObject l)
        {
            if (lever.Image == leverLeftImage)
            {
                lever.Image = leverRightImage;
                GetObjectsWithTag("gate").ForEach(g => g.Destroy());
            }
        });
    }

    void CreateSwingTrap(Vector position, double width, double height)
    {
        const double swingArc = 30; // Heiluu 30 astetta edestakaisin.
        const double swingSpeed = 1.5;
        const double ropeLength = 400;
        var center = position + new Vector(0, ropeLength);

        // Ajastukset heilutteluun.
        double deltaTime = 1 / 60.0;
        double time = 0.0;

        PhysicsObject swing = PhysicsObject.CreateStaticObject(width, height);
        swing.Image = swingTrapImage;
        swing.Position = position;
        Add(swing);

        GameObject rope = new GameObject(ropeLength, 10);
        rope.Color = new Color(10, 30, 10);
        Add(rope);

        var updateTimer = new Timer { Interval = deltaTime };
        updateTimer.Timeout += delegate
        {
            time += deltaTime;

            // Heilurin kulma on sinimuotoinen funktio ajan suhteen.
            var angle = Angle.FromDegrees(-90.0 + Math.Sin(time * swingSpeed) * swingArc);
            swing.Position = center + angle.GetVector() * ropeLength;
            swing.Angle = angle;

            // Päivitetään narun sijainti ja kulma.
            rope.Angle = angle;
            rope.Position = center + angle.GetVector() * ropeLength * 0.5;
        };
        updateTimer.Start();
    }

    void CreatePitchfork(Vector position, double width, double height)
    {
        double size = 30;
        double ratio = pitchforkImage.Width / pitchforkImage.Height;

        Improvement fork = new PitchForkImprovement(size * ratio, size);
        fork.Image = pitchforkImage;
        fork.Animations = new List<Animation> { pitchforkWalk, pitchforkAttack };
        fork.Position = position;
        fork.Tag = "improvement";
        Add(fork);

    }

    void CreateTreeBranch(Vector position, double width, double height)
    {
        PhysicsObject branch = PhysicsObject.CreateStaticObject(width, height);
        branch.Position = position;
        branch.Image = treeBranchImage;
        Add(branch, -1);
    }

    void CreateTreeTrunk(Vector position, double width, double height)
    {
        GameObject trunk = new GameObject(width * 3, height);
        trunk.Position = position;
        trunk.Image = treeTrunkImage;
        Add(trunk, -1);
    }

    void CreateTreeRoot(Vector position, double width, double height)
    {
        GameObject roots = new GameObject(width * 9, height * 4);
        roots.Position = position;
        roots.Y -= height;
        roots.Image = treeBottomImage;
        Add(roots, -1);
    }

    void CreateFlame(Vector position, double width, double height, bool suuri)
    {
        PhysicsObject flame = new PhysicsObject(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();
        flame.CanRotate = false;
        Add(flame, 1);

        Smoke savu = new Smoke();
        if (suuri)
        {
            flame.IgnoresCollisionResponse = true;

            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);
            flame.MakeStatic();
        }

        AddCollisionHandler(flame, "milkparticle", delegate(PhysicsObject c, PhysicsObject particle)
        {
            particle.Destroy();
            flame.Destroy();
            savu.Destroy();

        });
    }

    void CreateBlockObject(Vector position, double width, double height)
    {
        // Säädin vähän tätä jotta laatikko näkyy hyvin. Pitää ehkä tehdä laatikolle ihan oma metodi.
        PhysicsObject block = PhysicsObject.CreateStaticObject(width, height);
        block.IsVisible = false;
        //block.Image = blockImages[levelNumber];
        block.Position = position;
        block.Y -= height / 2.0;
        Add(block, 1);

        GameObject visibleBlock = new GameObject(width, height * 1.5);
        visibleBlock.Position = position;
        visibleBlock.Image = blockImages[levelNumber];
        visibleBlock.Y -= height / 2.0;
        Add(visibleBlock, -1);
    }

    void CreateMilk(Vector position, double width, double height)
    {
        double size = 30;
        double ratio = milkImage.Height / milkImage.Width;

        Improvement milk = new MilkImprovement(size, size * ratio);
        milk.Image = milkImage;
        milk.Animations = new List<Animation> { milkWalk, milkThrow };
        milk.Position = position;
        //milk.Tag = "milk";
        milk.Tag = "improvement";
        milk.sound = splash;
        Add(milk);

        //PhysicsObject milk = new PhysicsObject(size, size * ratio);
        //milk.Image = milkImage;
        //milk.Position = position;
        //milk.Tag = "milk";
        //Add(milk);
    }

    void CreateWorm(Vector position, double width, double height)
    {
        PlatformCharacter worm = new PlatformCharacter(width, height * 0.6);
        worm.Position = position;
        worm.Animation = new Animation(wormAnimation);
        worm.Animation.FPS = RandomGen.NextInt(18, 24);
        worm.Animation.Step(RandomGen.NextInt(0, 16));
        worm.Animation.Resume();
        worm.Tag = "worm";
        worm.CollisionIgnoreGroup = 3;
        Add(worm, 1);

        PlatformWandererBrain brain = new PlatformWandererBrain();
        brain.Speed = 60;
        brain.FallsOffPlatforms = false;
        brain.TriesToJump = true;
        worm.Brain = brain;

        AddCollisionHandler(worm, "pitchfork", delegate(PhysicsObject w, PhysicsObject p) { w.Destroy(); });
    }

    void CreateCrawly(Vector position, double width, double height)
    {
        PlatformCharacter crawly = new PlatformCharacter(width * 2, height * 0.6);
        crawly.Position = position;
        crawly.Color = Color.Gray;
        crawly.Animation = new Animation(crawl);
        crawly.Animation.FPS = RandomGen.NextInt(18, 24);
        crawly.Animation.Step(RandomGen.NextInt(0, 16));
        crawly.Animation.Resume();
        crawly.Tag = "burn";
        crawly.CollisionIgnoreGroup = 3;
        Add(crawly, 1);

        GameObject flame = new GameObject(width * 1.4, height * 2);
        flame.Animation = new Animation(blaze) { FPS = RandomGen.NextInt(20, 26) };
        flame.Animation.Step(RandomGen.NextInt(0, 12));
        flame.Animation.Resume();
        Add(flame);

        // Pakko liikutella näin koska lapsioliona liekki näkyisi ryömijän päällä.
        Timer flameMover = new Timer { Interval = 0.05 };
        flameMover.Timeout += delegate
        {
            double hieman = height * 0.75;
            flame.Position = crawly.Position + new Vector(0, hieman);
        };
        flameMover.Start();

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

        crawly.Brain = brain;

        // Sammuu törmätessään maitoon.
        AddCollisionHandler(crawly, "milkparticle", delegate(PhysicsObject c, PhysicsObject particle)
        {
            particle.Destroy();
            crawly.Brain = null;
            crawly.Animation = new Animation(crawly.Animation.CurrentFrame);
            crawly.Tag = "";
            flame.Destroy();
            RemoveCollisionHandlers(crawly);
        });
    }

    void CreateShroom(Vector position, double width, double height)
    {
        PlatformCharacter shroom = new PlatformCharacter(width, height * 2);
        shroom.Position = position + new Vector(0, shroom.Height / 2);
        shroom.Tag = "burn";
        shroom.Tag += "shroom";
        shroom.AnimWalk = new Animation(tattiMageAnimation);
        shroom.CollisionIgnoreGroup = 3;
        Add(shroom, 1);
        //bool immune = false;

        PlatformWandererBrain brain = new PlatformWandererBrain();
        brain.Speed = 20;
        brain.FallsOffPlatforms = false;
        shroom.Brain = brain;

        FollowerBrain attackBrain = new FollowerBrain("player");
        attackBrain.DistanceFar = Window.Width / 2.5;
        attackBrain.DistanceClose = Window.Width / 2;
        attackBrain.StopWhenTargetClose = false;
        attackBrain.Speed = brain.Speed * 6;
        attackBrain.FarBrain = brain;
        shroom.Brain = attackBrain;

        int matoja = RandomGen.NextInt(1, 3);
        int rahkeet = 10;

        //// Taiotaan matoja
        var castTimer = new Timer { Interval = 6.0 };
        castTimer.Timeout += delegate
        {
            shroom.PlayAnimation(tattiMageCastAnimation);

            Timer.SingleShot(RandomGen.NextDouble(3, 5), delegate { shroom.Brain = attackBrain; });

            Timer.SingleShot(1.5,
                delegate
                {
                    for (int i = 0; i < matoja; i++)
                    {
                        CreateWorm(shroom.Position + RandomGen.NextVector(-200, shroom.Height * 1.5, 200, shroom.Height * 2), TILE_SIZE, TILE_SIZE);
                        shroom.Brain = brain;
                    }
                });


        };

        attackBrain.TargetClose += delegate()
        {
            if (!castTimer.Enabled)
            {
                castTimer.Start();
            }
        };

        AddCollisionHandler(shroom, "pitchfork", delegate(PhysicsObject s, PhysicsObject f)
        {
            matoja += RandomGen.NextInt(1, 2);
            rahkeet--;
            if (rahkeet < 1)
            {
                shroom.Destroy();
                castTimer.Stop();
                Timer.SingleShot(6, NextLevel);
            }
        });
    }

    void CreateFireMage(Vector position, double width, double height)
    {
        PlatformCharacter mage = new PlatformCharacter(width * 3, height * 4);
        mage.Position = position;
        mage.Y += mage.Height / 2.0;
        mage.Tag = "burn";
        mage.Tag += "fireMage";
        mage.AnimWalk = new Animation(firemageAnimation);
        mage.CollisionIgnoreGroup = 3;
        Add(mage, 1);
        bool immune = false;

        // Pään päällä oleva liekki (taitaa olla vähän huonossa kohtaa tällä hetkellä)
        PhysicsObject flame = new PhysicsObject(width * 1.4, height * 2);
        flame.Y += mage.Height * 0.65;
        flame.X += mage.FacingDirection.GetVector().X + 30;
        flame.Animation = new Animation(blaze);
        flame.IgnoresPhysicsLogics = true;
        flame.Animation.Start();
        mage.Add(flame);

        PlatformWandererBrain brain = new PlatformWandererBrain();
        brain.Speed = 20;
        brain.FallsOffPlatforms = false;
        //mage.Brain = brain;

        //PhysicsObject trigger = PhysicsObject.CreateStaticObject(10, Level.Height); //A truly cool and efficient way to make the boogeyman react only to our closeness
        //trigger.Position = mage.Position - new Vector(Window.Width / 2, 0);
        ////trigger.Color = Color.Red;
        //trigger.IsVisible = false;
        //trigger.IgnoresCollisionResponse = true;
        //Add(trigger);

        FollowerBrain attackBrain = new FollowerBrain("player");
        attackBrain.DistanceFar = Window.Width / 2.5;
        attackBrain.DistanceClose = Window.Width / 2;
        attackBrain.StopWhenTargetClose = false;
        attackBrain.Speed = brain.Speed * 6;
        attackBrain.FarBrain = brain;
        mage.Brain = attackBrain;

        // Taiotaan tulta välillä.
        var castTimer = new Timer { Interval = 10.0 };
        castTimer.Timeout += delegate
        {
            // TODO: Kävelyanimaatio pysähtyy jostain syystä tämän animaation jälkeen.
            mage.PlayAnimation(firemageCastAnimation);

            Timer.SingleShot(RandomGen.NextDouble(5, 8), delegate { mage.Brain = attackBrain; });

            Timer.SingleShot(1.5,
                delegate
                {
                    for (int i = 0; i < 6; i++)
                    {
                        CreateFlame(new Vector(attackBrain.CurrentTarget.X + RandomGen.NextDouble(-300, 300), mage.Y + mage.Height * 1.5), 30, 60, false);
                        mage.Brain = brain;
                    }
                });

        };

        attackBrain.DistanceToTarget.AddTrigger(Window.Width / 2, TriggerDirection.Down, delegate()
        {
            castTimer.Start();
            attackBrain.DistanceToTarget.RemoveTriggers(Window.Width / 2);
        });

        //castTimer.Start();

        AddCollisionHandler(mage, "milkparticle", delegate(PhysicsObject fireMage, PhysicsObject milk)
        {
            if (milk.Y > fireMage.Y + fireMage.Height * 0.15 && !immune)
            {
                flame.Size *= 0.95;
                immune = true;
                if (flame.Height < height)
                {
                    castTimer.Stop();
                    CreatePitchfork(mage.Position, TILE_SIZE, TILE_SIZE);
                    mage.Destroy();
                    Timer.SingleShot(6, NextLevel);
                }
                Timer.SingleShot(0.5, delegate { immune = false; });

            }
        });

        //AddCollisionHandler(trigger, "player", delegate(PhysicsObject a, PhysicsObject b) { castTimer.Start(); });
    }

    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, names[players.Count()]);
        player.Shape = Shape.Rectangle;
        player.Position = position + new Vector(0, height * 0.5);
        player.Color = Color.White;
        player.AnimWalk = new Animation(normalWalk);
        player.AnimIdle = new Animation(playerIdle);
        player.AnimJump = new Animation(playerJump);
        player.AnimFall = new Animation(playerFall);
        player.Animations = new List<Animation>();
        player.Animations.Add(normalWalk);
        player.Animations.Add(playerIdle);
        player.AnimFall.StopOnLastFrame = true;
        players.Add(player);
        startingPlayers.Add(player);
        player.Tag = "player";
        Add(player);

        AddCollisionHandler(player, "burn", delegate(PhysicsObject p, PhysicsObject t)
        {
            if (!invincibility)
                player.Life.Value--;
        });

        AddCollisionHandler(player, "lava", delegate(PhysicsObject p, PhysicsObject t)
        {
            if (!invincibility)
                player.Life.Value = player.Life.MinValue;
        });

        AddCollisionHandler(player, "worm", delegate(PhysicsObject p, PhysicsObject worm)
        {
            if (player.Y > worm.Y && Math.Abs(player.X - worm.X) < worm.Width / 2.0)
            {
                worm.Destroy();
            }
            else
            {
                if (!invincibility)
                    player.Life.Value--;
            }
        });

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

        AddCollisionHandler(player, "improvement", CollectImprovement);
    }

    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 = groundTopImages[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 && levelNumber < 2)
        {
            GameObject wheatBlock = new GameObject(width * 1.5, height * 2);
            wheatBlock.Image = foregroundDecorations[levelNumber];
            wheatBlock.X = visibleGround.X;
            wheatBlock.Bottom = visibleGround.Bottom;
            wheatBlock.TextureWrapSize = new Vector(width / TILE_SIZE, height / TILE_SIZE);
            Add(wheatBlock, 2);
        }
    }

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

    void Victory()
    {
        ClearAll();
        MessageDisplay.Add("Voitit muutes belin.");
    }

    void SetControls()
    {
        Keyboard.Listen(Key.A, ButtonState.Down, delegate { startingPlayers[0].Walk(-PLAYER_SPEED); }, "Player 1 moves left");
        Keyboard.Listen(Key.D, ButtonState.Down, delegate { startingPlayers[0].Walk(PLAYER_SPEED); }, "Player 1 moves right");
        Keyboard.Listen(Key.W, ButtonState.Down, delegate { startingPlayers[0].Jump(PLAYER_SPEED * 2); }, "Player 1 jumps");    //Just PLAYER_SPEED felt alright as well
        Keyboard.Listen(Key.E, ButtonState.Pressed, delegate { startingPlayers[0].UseImprovement(); }, "Player 1 uses their tools");
        Keyboard.Listen(Key.Tab, ButtonState.Pressed, GetRidOfImprovement, "Player 1 throws their tools away", startingPlayers[0]);

        Keyboard.Listen(Key.Left, ButtonState.Down, delegate { startingPlayers[1].Walk(-PLAYER_SPEED); }, "Player 2 moves left");
        Keyboard.Listen(Key.Right, ButtonState.Down, delegate { startingPlayers[1].Walk(PLAYER_SPEED); }, "Player 2 moves right");
        Keyboard.Listen(Key.Up, ButtonState.Down, delegate { startingPlayers[1].Jump(PLAYER_SPEED * 2); }, "Player 2 jumps");
        Keyboard.Listen(Key.RightShift, ButtonState.Pressed, delegate { startingPlayers[1].UseImprovement(); }, "Player 2 uses their tools");
        Keyboard.Listen(Key.Enter, ButtonState.Pressed, GetRidOfImprovement, "Player 1 throws their tools away", startingPlayers[1]);

        Keyboard.Listen(Key.F8, ButtonState.Pressed, Invincibility, null); // Demonstraatio tarkoituksiin.
        Keyboard.Listen(Key.F9, ButtonState.Pressed, Loss, null);
        Keyboard.Listen(Key.F12, ButtonState.Pressed, NextLevel, null);
        Keyboard.Listen(Key.R, ButtonState.Pressed, StartGame, null);

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

    void Invincibility()
    {
        invincibility = !invincibility;
        MessageDisplay.Add("Invincibility mode " + (invincibility ? "on" : "off"));
    }

    void GetRidOfImprovement(HillBilly player)
    {
        if (player.Improvement != null)
        {
            Improvement parannus = player.Improvement;
            parannus.Position = player.Position + player.FacingDirection.GetVector() * 100;
            parannus.IsVisible = true;
            parannus.IgnoresCollisionResponse = false;
            parannus.Tag = "improvement";
            player.Improvement.Rid();
        }
    }

    public void CreateMilkParticles(HillBilly billy, int size, int xBase, int yBase, Vector position, String tag)
    {
        for (int i = 0; i < 10; i++)
        {
            const double maxLife = 1.0;
            PhysicsObject milkParticle = new PhysicsObject(size, size, Shape.Circle);
            milkParticle.Color = new Color(255, 255, 255, 128);
            milkParticle.Position = billy.Position + position;
            milkParticle.IgnoresCollisionResponse = true;
            milkParticle.Tag = tag;
            milkParticle.LifetimeLeft = TimeSpan.FromSeconds(maxLife);
            Add(milkParticle);

            // Väri muuttuu läpinäkyväksi.
            var fadeTimer = new Timer { Interval = 0.07 };
            fadeTimer.Timeout += delegate
            {
                byte c = 255;
                milkParticle.Color = new Color(c, c, c, (byte)(128 * milkParticle.LifetimeLeft.TotalSeconds / maxLife));
            };
            fadeTimer.Start();
            milkParticle.Destroyed += fadeTimer.Stop;

            // Random lentonopeus.
            var rx = RandomGen.NextDouble(-50, 50);
            var ry = RandomGen.NextDouble(-50, 50);
            milkParticle.Hit(new Vector(billy.FacingDirection.GetVector().X * (xBase + rx), yBase + ry));
        }
    }

    void Loss()
    {
        ClearAll();
        cameraTarget = Camera.Position = Vector.Zero;
        Level.Background.Color = Color.Black;

        GameObject img = new GameObject(Window.Width * 0.3, Window.Height * 0.5);
        img.Image = deathImage;
        Add(img);

        Label gameover = new Label("Game Over");
        gameover.Position = new Vector(0, Screen.Top - 150);
        gameover.TextColor = Color.White;
        gameover.TextScale *= 3;
        Add(gameover);

        Keyboard.Listen(Key.Escape, ButtonState.Pressed, StartGame, null);
    }

    void CollectImprovement(PhysicsObject player, PhysicsObject milk)
    {
        HillBilly billy = player as HillBilly;
        if (billy == null || billy.Improvement != null)
            return;

        Improvement milkI = milk as Improvement;
        billy.GainImprovement(milkI);

        milk.IsVisible = false;
        milk.IgnoresCollisionResponse = true;
        milk.Tag = "none";

        //Remove(milk);
        //billy.AnimWalk = new Animation(milkWalk);
        //billy.AnimIdle = new Animation(milkWalk.CurrentFrame);
    }

    public void ForkThings(HillBilly Owner)
    {
        PhysicsObject evilClone = new PhysicsObject(Owner.Width, Owner.Height * 0.7);
        evilClone.Position = Owner.Position + Owner.FacingDirection.GetVector() * 40 + new Vector(0, -(Owner.Height * 0.3));
        evilClone.Color = Color.Red;
        evilClone.IsVisible = false;
        evilClone.Tag = "pitchfork";
        evilClone.IgnoresCollisionResponse = true;
        evilClone.IgnoresPhysicsLogics = true;
        evilClone.LifetimeLeft = TimeSpan.FromSeconds(Owner.Animation.FPS * Owner.Animation.FrameCount);
        Add(evilClone);

        Owner.PlayAnimation(Owner.Improvement.Animations[1], evilClone.Destroy);
    }

    #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);

        if (levelNumber < 2)
        {
            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);
        }
        else if (levelNumber == 2)
        {
            cameraTarget.Y = ((minPosition + maxPosition) * 0.5).Y;
            cameraTarget.Y = Math.Max(cameraTarget.Y, bottomCamLimit);

            // Pakotetaan kameraa eteenpäin. Jos kaikki pelaajat on näytön oikealla puolella, niin liikutetaan nopeammin.
            double cameraSpeed = players.All(p => Camera.WorldToScreen(p.Position).X > 0) ? 4.0 : 1.0;
            cameraTarget.X += cameraSpeed;

            cameraTarget.X = Math.Min(cameraTarget.X, rightCamLimit);

            if (cameraTarget.X == rightCamLimit && activateBoss != null)
            {
                fireballTimer.Stop();
                activateBoss();
                activateBoss = null;
            }
        }

        // Pelaajien sijainnin rajaus ikkunaan.
        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


}