sneak/Shared/World.cs

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Newtonsoft.Json.Linq;
using System;
using System.Collections.Generic;

namespace SemiColinGames {

  public sealed class World : IDisposable {

    public const int TileSize = 16;

    // Size of World in terms of tile grid.
    private int gridWidth;
    private int gridHeight;
    private readonly Tile[] obstacles;
    private readonly Tile[] decorations;
    // Kept around for resetting the world's entities after player death or level restart.
    private readonly JToken entitiesLayer;
    private NPC[] npcs;

    public Player Player { get; private set; }
    public AABB[] CollisionTargets { get; }
    public LinesOfSight LinesOfSight { get; private set; }

    // Size of World in pixels.
    public int Width {
      get { return gridWidth * TileSize; }
    }

    public int Height {
      get { return gridHeight * TileSize; }
    }

    public World(GraphicsDevice graphics, string json) {
      LinesOfSight = new LinesOfSight(graphics);

      JObject root = JObject.Parse(json);

      List<Tile> hazardTiles = new List<Tile>();
      List<Tile> obstacleTiles = new List<Tile>();
      List<Tile> decorationTiles = new List<Tile>();
      List<Tile> backgroundTiles = new List<Tile>();
      foreach (JToken layer in root.SelectToken("layers").Children()) {
        string layerName = layer.SelectToken("name").Value<string>();
        if (layerName == "entities") {
          entitiesLayer = layer;
          (Player, npcs) = ParseEntities(layer);
          continue;
        }
        List<Tile> tileList = ParseLayer(layer);
        if (layerName == "hazards") {
          hazardTiles = tileList;
        } else if (layerName == "obstacles") {
          obstacleTiles = tileList;
        } else if (layerName == "decorations") {
          decorationTiles = tileList;
        } else if (layerName == "background") {
          backgroundTiles = tileList;
        }
      }
      // Get all the obstacles into a single array, sorted by X.
      obstacleTiles.AddRange(hazardTiles);
      obstacles = obstacleTiles.ToArray();
      Array.Sort(obstacles, Tile.CompareByX);
      // The background tiles are added before the rest of the decorations, so that they're drawn
      // in the back.
      backgroundTiles.AddRange(decorationTiles);
      decorations = backgroundTiles.ToArray();
      Debug.WriteLine("world size: {0}x{1}", gridWidth, gridHeight);

      // The obstacles are sorted by x-position. We maintain this invariant so that it's possible
      // to efficiently find CollisionTargets that are nearby a given x-position.
      CollisionTargets = new AABB[obstacles.Length + 2];

      // Add a synthetic collisionTarget on the left side of the world.
      CollisionTargets[0] = new AABB(new Vector2(-1, 0), new Vector2(1, float.MaxValue));

      // Now add all the normal collisionTargets for every obstacle.
      Vector2 halfSize = new Vector2(TileSize / 2, TileSize / 2);
      for (int i = 0; i < obstacles.Length; i++) {
        Vector2 center = new Vector2(
          obstacles[i].Position.Left + halfSize.X, obstacles[i].Position.Top + halfSize.Y);
        CollisionTargets[i + 1] = new AABB(center, halfSize, obstacles[i]);
      }

      // Add a final synthetic collisionTarget on the right side of the world.
      CollisionTargets[obstacles.Length + 1] = new AABB(
          new Vector2(Width + 1, 0), new Vector2(1, float.MaxValue));
    }

    ~World() {
      Dispose();
    }

    public void Dispose() {
      LinesOfSight.Dispose();
      GC.SuppressFinalize(this);
    }

    private List<Tile> ParseLayer(JToken layer) {
      string layerName = layer.SelectToken("name").Value<string>();

      var tileList = new List<Tile>();

      int layerWidth = layer.SelectToken("gridCellsX").Value<int>();
      int layerHeight = layer.SelectToken("gridCellsY").Value<int>();
      gridWidth = Math.Max(gridWidth, layerWidth);
      gridHeight = Math.Max(gridHeight, layerHeight);

      int dataIndex = -1;
      int tileWidth = layer.SelectToken("gridCellWidth").Value<int>();
      int tileHeight = layer.SelectToken("gridCellHeight").Value<int>();
      int textureWidth = Textures.Grassland.Get.Width / tileWidth;
      foreach (int textureIndex in layer.SelectToken("data").Values<int>()) {
        dataIndex++;
        if (textureIndex == -1) {
          continue;
        }
        int i = dataIndex % layerWidth;
        int j = dataIndex / layerWidth;
        Rectangle position = new Rectangle(
            i * tileWidth, j * tileHeight, tileWidth, tileHeight);
        int x = textureIndex % textureWidth;
        int y = textureIndex / textureWidth;
        Rectangle textureSource = new Rectangle(
            x * tileWidth, y * tileHeight, tileWidth, tileHeight);
        bool isHazard = layerName == "hazards";
        tileList.Add(new Tile(Textures.Grassland, textureSource, position, isHazard));
      }

      return tileList;
    }

    private (Player, NPC[]) ParseEntities(JToken layer) {
      Player player = null;
      List<NPC> npcs = new List<NPC>();
      foreach (JToken entity in layer.SelectToken("entities").Children()) {
        string name = entity.SelectToken("name").Value<string>();
        int x = entity.SelectToken("x").Value<int>();
        int y = entity.SelectToken("y").Value<int>();
        int facing = entity.SelectToken("flippedX").Value<bool>() ? -1 : 1;
        if (name == "player") {
          player = new Player(new Point(x, y), facing);
        } else if (name == "executioner") {
          npcs.Add(new NPC(new Point(x, y), facing));
        }
      }
      return (player, npcs.ToArray());
    }

    private void Reset() {
      (Player, npcs) = ParseEntities(entitiesLayer);
    }

    public void Update(float modelTime, History<Input> input) {
      Player.Update(modelTime, this, input);
      foreach (NPC npc in npcs) {
        npc.Update(modelTime, this);
      }
      if (Player.Health <= 0) {
        Reset();
      }
      LinesOfSight.Update(npcs, CollisionTargets);
    }

    // Draws everything that's behind the player, from back to front.
    public void DrawBackground(SpriteBatch spriteBatch) {
      foreach (Tile t in decorations) {
        t.Draw(spriteBatch);
      }
      foreach (NPC npc in npcs) {
        npc.Draw(spriteBatch);
      }
    }

    // Draws everything that's in front of the player, from back to front.
    public void DrawForeground(SpriteBatch spriteBatch) {
      foreach (Tile t in obstacles) {
        t.Draw(spriteBatch);
      }
    }
  }

  public class Tile {
    public static int CompareByX(Tile t1, Tile t2) {
      return t1.Position.X.CompareTo(t2.Position.X);
    }

    private readonly TextureRef texture;
    private readonly Rectangle textureSource;

    public Tile(TextureRef texture, Rectangle textureSource, Rectangle position, bool isHazard) {
      Position = position;
      this.texture = texture;
      this.textureSource = textureSource;
      IsHazard = isHazard;
    }

    public Rectangle Position { get; private set; }
    public bool IsHazard = false;

    public void Draw(SpriteBatch spriteBatch) {
      spriteBatch.Draw(
          texture.Get, Position.Location.ToVector2(), textureSource, Color.White);
    }
  }
}