source: 2015/27/ohjaajat/TheLegendOfGabriel/TheLegendOfGabriel/TheLegendOfGabriel/TiledTileMap.cs @ 6539

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;
using Jypeli;
using TiledSharp;


public class TiledTileMap
{
    public delegate void ObjectMethod(
        Vector position, double width, double height, Angle angle, Shape shape, string name, Dictionary<string, string> properties);

    public delegate void TileMethod(
        Vector position, double width, double height, Image image, string layerName, Dictionary<string, string> properties);

    private readonly Dictionary<string, ObjectMethod> objectLegend = new Dictionary<string, ObjectMethod>();

    private readonly Dictionary<string, TileMethod> tileLegend = new Dictionary<string, TileMethod>();

    private readonly TmxMap level;

    private Image[] tileImages;

    private TiledTileMap(TmxMap tmxMap)
    {
        this.level = tmxMap;
    }

    public static TiledTileMap FromLevelAsset(string assetName)
    {
        TmxMap tmxMap = new TmxMap(string.Format("Content/{0}.tmx", assetName));
        TiledTileMap map = new TiledTileMap(tmxMap);
        map.LoadTileImages();
        return map;
    }

    public void SetObjectMethod(string layerName, ObjectMethod objectMethod)
    {
        objectLegend[layerName] = objectMethod;
    }

    public void SetTileMethod(string layerName, TileMethod tileMethod)
    {
        tileLegend[layerName] = tileMethod;
    }

    public void Execute()
    {
        Game game = Game.Instance;
        game.Level.Width = level.Width * level.TileWidth;
        game.Level.Height = level.Height * level.TileHeight;

        foreach (var tmxLayer in level.Layers)
        {
            CreateTile(tmxLayer, game);
        }

        foreach (var group in level.ObjectGroups)
        {
            CreateObject(group, game);
        }
    }

    private void CreateTile(TmxLayer layer, Game game)
    {
        TileMethod method;
        if (!tileLegend.TryGetValue(layer.Name, out method)) return;

        double tileWidth = level.TileWidth;
        double tileHeight = level.TileHeight;

        for (int i = 0; i < layer.Tiles.Count; i++)
        {
            var tile = layer.Tiles[i];
            int gid = tile.Gid;
            if (gid == 0)
                continue;

            int tileIndex = tile.Gid - 1;
            double realX = game.Level.Left + (tile.X * tileWidth) + (tileWidth / 2);
            double realY = game.Level.Top - (tile.Y * tileHeight) - (tileHeight / 2);
            Dictionary<string,string> props = level.Tilesets[0].Tiles.Where(t => level.Tilesets[0].FirstGid + t.Id == tile.Gid).Select(t => t.Properties).FirstOrDefault();
            props = props ?? new Dictionary<string, string>();
            method(new Vector(realX, realY), tileWidth, tileHeight, tileImages[tileIndex], layer.Name, props);
        }
    }

    private void CreateObject(TmxObjectGroup group, Game game)
    {
        ObjectMethod method;
        if (!objectLegend.TryGetValue(group.Name, out method)) return;
        foreach (var obj in group.Objects)
        {
            Shape shape = Shape.Rectangle;
            if (obj.ObjectType == TmxObjectGroup.TmxObjectType.Ellipse)
                shape = Shape.Circle;

            var angle = Angle.FromDegrees(-obj.Rotation);
            var topLeft = new Vector(game.Level.Left + obj.X, game.Level.Top - obj.Y);
            var len = Math.Sqrt(Math.Pow(obj.Width * 0.5, 2) + Math.Pow(obj.Height * 0.5, 2));
            var positionFix = Vector.FromLengthAndAngle(len, angle + Angle.FromRadians(-Math.Atan2(obj.Height, obj.Width)));
            method(topLeft + positionFix, obj.Width, obj.Height, angle, shape, obj.Name, obj.Properties);
        }
    }

    private void LoadTileImages()
    {
        int tileCount = level.Tilesets.Sum(t => (t.Image.Width.Value / t.TileWidth) * (t.Image.Height.Value / t.TileHeight));
        tileImages = new Image[tileCount];

        foreach (var tileSet in level.Tilesets)
        {
            Image tilesetImage = Game.LoadImage(Path.GetFileNameWithoutExtension(tileSet.Image.Source));
            int tilesW = tileSet.Image.Width.Value / tileSet.TileWidth;
            int tilesH = tileSet.Image.Height.Value / tileSet.TileHeight;
            for (int y = 0; y < tilesH; y++)
            {
                for (int x = 0; x < tilesW; x++)
                {
                    int index = tileSet.FirstGid + (y * tilesW + x) - 1; // Tiled uses one-based indexing for tiles.
                    tileImages[index] = tilesetImage.Area(x * tileSet.TileWidth, y * tilesH, (x + 1) * tileSet.TileWidth,
                        (y + 1) * tileSet.TileHeight);
                }
            }
        }
    }
}