source: 2015/27/ohjaajat/TheLegendOfGabriel/TheLegendOfGabriel/TheLegendOfGabriel/LevelCreation.cs @ 6716

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Jypeli;
using Jypeli.Assets;
using Jypeli.Widgets;

/*
 *Klassisia muistutuksia 
 * 3
 * 2    Pelaajan päällä näkyvät elementit
 * 1    Pelaaja, kojootit
 * 0    Lisäkoriste
 * -1   Perustiili
 * -2
 */


public partial class TheLegendOfGabriel : PhysicsGame
{
    /// <summary>
    /// Luo kentän .tmx tiedostosta.
    /// </summary>
    void CreateLevel(string levelName)
    {
        bossSpawnPositions.Clear();

        var level = TiledTileMap.FromLevelAsset(levelName);
        level.SetTileMethod("base", CreateBaseTile);
        level.SetTileMethod("foreground", CreateForegroundTile);
        level.SetObjectMethod("exit", CreateExit);
        level.SetTileMethod("decoration", CreateDecoration);
        level.SetTileMethod("cover", CreateCover);
        level.SetObjectMethod("story", CreateEncounter);
        //level.SetObjectMethod("player", CreatePlayer);
        level.SetObjectMethod("blockade", CreateBlock);
        level.SetObjectMethod("coyote", CreateCoyote);
        level.SetObjectMethod("boss", CreateBoss);
        level.SetObjectMethod("bossspawn", CreateBossSpawn);
        level.Execute();

       // Level.CreateBorders(false);

        Level.Background.Color = Color.Black;
    }

    void CreateEncounter(Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties)
    {
        if (storyItems.Count < 2)
        {
            PhysicsObject invisible = new PhysicsObject(width, height) { IsVisible = false, Tag = "storyTime" };
            invisible.MakeStatic();
            Add(invisible);
        }
    }

    void CreateBossSpawn(Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties)
    {
        bossSpawnPositions.Add(position);
    }

    void CreateBoss(Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties)
    {
        MediaPlayer.Play("boss");
        MediaPlayer.IsRepeating = true;

        BossHealth = new IntMeter(10, 0, 10);

        var bar = new ProgressBar(Level.Width * 0.7, TILE_SIZE * 0.5);
        bar.Y = Screen.Top - TILE_SIZE * 0.5;
        bar.BindTo(BossHealth);
        Add(bar);

        // Juna ilmestyy välillä satunnaiseen spawniin.
        var bossTimer = new Timer();
        bossTimer.Interval = 8;
        bossTimer.Timeout += delegate
        {
            // Luodaan päävaunu.
            var pos = RandomGen.SelectOne<Vector>(bossSpawnPositions);
            var train = CreateBossTrainPart(pos.X, pos.Y, trainAnimation);
            double newPositionX = pos.X + train.Width;

            // Luodaan muut vaunut.
            int carriages = (int)(BossHealth.Value / (double)BossHealth.MaxValue * 6);
            for (int i = 0; i < carriages; i++)
            {
                var part = CreateBossTrainPart(newPositionX, pos.Y, carriageAnimation);
                newPositionX += part.Width;
            }
        };
        bossTimer.Start();

        BossHealth.LowerLimit += delegate
        {
            EnemyDieSound.Play();
            bossTimer.Stop();
            Timer.SingleShot(4.0, Victory);

            foreach (var part in GetObjectsWithTag("boss"))
            {
                part.Destroy();
                var smoke = new GameObject(80, 160);
                smoke.X = part.X;
                smoke.Bottom = part.Bottom;
                smoke.Animation = new Animation(smokeAnimation);
                smoke.Animation.Start(1);
                smoke.Animation.Played += () => smoke.Destroy();
                Add(smoke);
            }
        };
    }

    PhysicsObject CreateBossTrainPart(double left, double y, Animation anim)
    {
        var part = PhysicsObject.CreateStaticObject(70, 40);
        part.Left = left;
        part.Y = y;
        part.Animation = anim;
        part.Animation.Start();
        part.Velocity = new Vector(-80, 0);
        part.Tag = "boss";
        part.CollisionIgnoreGroup = 3;
        Add(part);

        // Pala on näkyvillä vain kentän sisäpuolella.
        var appearTimer = new Timer();
        appearTimer.Interval = 0.05;
        appearTimer.Timeout += delegate
        {
            part.IsVisible = part.Left < Level.Right;

            if (part.Right < Level.Left)
            {
                part.Destroy();
                appearTimer.Stop();
            }
        };
        appearTimer.Start();

        // Palat luo vihollisia jatkuvasti.
        var enemySpawnTimer = new Timer();
        enemySpawnTimer.Interval = 2.0;
        enemySpawnTimer.Timeout += delegate
        {
            if (part.Right < Level.Right)
            {
                CreateNorwegianHammerThrower(part.Position, TILE_SIZE, TILE_SIZE, Angle.Zero, Shape.Rectangle, "", null);
            }
        };
        enemySpawnTimer.Start();

        part.Destroyed += delegate
        {
            appearTimer.Stop();
            enemySpawnTimer.Stop();
        };

        return part;
    }

    /// <summary>
    /// Näkymättömiä esteitä.
    /// </summary>
    void CreateBlock(Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties)
    {
        PhysicsObject block = PhysicsObject.CreateStaticObject(width, height);
        block.Position = position;
        block.IsVisible = false;
        Add(block);

    }

    void CreateCoyote(Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties)
    {
        CreateEnemy(position, width, height, DirectionalAnimations(coyoteLeft, coyoteRight, coyoteUp, coyoteDown));
    }

    void CreateNorwegianHammerThrower(Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties)
    {
        CreateEnemy(position, width, height, DirectionalAnimations(nWalkLeft, nWalkRight, nWalkUp, nWalkDown));
    }

    void CreateEnemy(Vector position, double width, double height, Dictionary<Direction, Animation> anims)
    {
        var enemy = new Creature(width, height, 1);
        enemy.MoveAnimations = anims;
        enemy.Image = enemy.MoveAnimations[Direction.Right].CurrentFrame;
        enemy.Position = position;
        enemy.Tag = "enemy";
        enemy.Brain = new FollowerBrain(player) { Speed = 50 };
        enemy.CollisionIgnoreGroup = 3;
        Add(enemy, 1);
        enemies.Add(enemy);

        AddCollisionHandler(enemy, "playerattack", delegate(PhysicsObject e, PhysicsObject a)
        {
            enemy.Health.Value--;
        });
        
        enemy.Health.LowerLimit += delegate
        {
            enemy.Destroy();
            RandomItemDrop(enemy.Position);

            EnemyDieSound.Play();

            var smoke = new GameObject(20, 40);
            smoke.X = enemy.X;
            smoke.Bottom = enemy.Bottom;
            smoke.Animation = new Animation(smokeAnimation);
            smoke.Animation.Start(1);
            smoke.Animation.Played += () => smoke.Destroy();
            Add(smoke);
        };
    }

    void RandomItemDrop(Vector position)
    {
        var chance = RandomGen.NextDouble(0, 100);
        if (chance < 20)
        {
            int itemType = RandomGen.NextInt(1, 3);
            var item = PhysicsObject.CreateStaticObject(10, 10);
            item.Position = position;
            item.Image = itemType == 1 ? GrenadeBoxImage : AmmoBoxImage;
            item.Tag = itemType == 1 ? "grenadebox" : "ammobox";
            item.IgnoresCollisionResponse = true;
            Add(item);
        }
    }

    /// <summary>
    /// Maassa oleva tiili.
    /// </summary>
    void CreateBaseTile(Vector position, double width, double height, Image image, string layerName, Dictionary<string, string> properties)
    {
        CreateBasicTile(position, width, height, image, -1, properties);
    }

    /// <summary>
    /// Pohjan päällä, pelaajan alla näkyvä tiili.
    /// </summary>
    void CreateDecoration(Vector position, double width, double height, Image image, string layerName, Dictionary<string, string> properties)
    {
        CreateBasicTile(position, width, height, image, 0, properties);
    }

    /// <summary>
    /// Pelaajan päällä näkyvä tiili.
    /// </summary>
    void CreateForegroundTile(Vector position, double width, double height, Image image, string layerName, Dictionary<string, string> properties)
    {
        CreateBasicTile(position, width, height, image, 2, properties);
    }

    void CreateCover(Vector position, double width, double height, Image image, string layername, Dictionary<string, string> properties)
    {
        var tile = new GameObject(width, height);
        tile.Tag = "cover";
        tile.Image = image;
        tile.Position = position;
        Add(tile, 3);
    }

    /// <summary>
    /// Luo tavallisen tiilen.
    /// </summary>
    void CreateBasicTile(Vector position, double width, double height, Image image, int layer, Dictionary<string, string> properties)
    {
        //var tile = new GameObject(width, height);
        var tile = properties.ContainsKey("collide") ? PhysicsObject.CreateStaticObject(width, height) : new GameObject(width, height); //new PhysicsObject(width, height)  PhysicsObject.CreateStaticObject(width, height)
        tile.Image = image;
        tile.Position = position;
        Add(tile, layer);
    }

    /// <summary>
    /// Luo uloskäynnin, joka vie toiseen kenttään.
    /// </summary>
    void CreateExit(Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties)
    {
        var target = properties["goto"] == "disabled" ? null : properties["goto"].Split('@'); // Jos peli kaatuu tälle riville niin joltain exitiltä puuttuu goto-property.
        var exit = new Exit(width, height);
        exit.Position = position;
        if (target != null)
        {
            exit.TargetLevel = target[0];
            exit.TargetExitName = target[1];
        }
        exit.Name = name;
        Add(exit);
        exits.Add(exit);

        bool create = properties.ContainsKey("block");
        if(create && !woodDestroyed)
        {
            PhysicsObject fence = PhysicsObject.CreateStaticObject(TILE_SIZE, TILE_SIZE);
            fence.Image = FenceImage;
            fence.Position = exit.Position - new Vector(0, TILE_SIZE);
            Add(fence, 3);

            AddCollisionHandler(fence, "playerattack", delegate(PhysicsObject destroyable, PhysicsObject a)
            {
               destroyable.Destroy();
               woodDestroyed = true;
            });
        
        }
    }
}