sneak/Shared/World.cs

194 lines
6.4 KiB
C#
Raw Normal View History

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using System;
using System.Collections.Generic;
using System.Linq;
namespace SemiColinGames {
enum Terrain {
Grass,
GrassL,
GrassR,
Rock,
RockL,
RockR,
Water,
Block
}
enum TileSet {
Cemetery,
Crypt,
Dungeon,
Forest,
Garden,
Grassland,
Ruins,
Sewer,
Temple,
Village,
}
class TileFactory {
struct TextureSource {
public Texture2D texture;
public Rectangle source;
public TextureSource(Texture2D texture, Rectangle source) {
this.texture = texture;
this.source = source;
}
}
static readonly Dictionary<TileSet, string> tileSetToContentPath =
new Dictionary<TileSet, string>() {
{ TileSet.Cemetery, "tiles/anokolisa/cemetery" },
{ TileSet.Crypt, "tiles/anokolisa/crypt" },
{ TileSet.Dungeon, "tiles/anokolisa/dungeon" },
{ TileSet.Forest, "tiles/anokolisa/forest" },
{ TileSet.Garden, "tiles/anokolisa/garden" },
{ TileSet.Grassland, "tiles/anokolisa/grassland" },
{ TileSet.Ruins, "tiles/anokolisa/ruins" },
{ TileSet.Sewer, "tiles/anokolisa/sewer" },
{ TileSet.Temple, "tiles/anokolisa/temple" },
{ TileSet.Village, "tiles/anokolisa/village" },
};
readonly Dictionary<Terrain, TextureSource> terrainToTexture =
new Dictionary<Terrain, TextureSource>();
readonly Texture2D[] textures;
public TileFactory(ContentManager content) {
Array tileSets = Enum.GetValues(typeof(TileSet));
textures = new Texture2D[tileSets.Length];
foreach (TileSet tileSet in tileSets) {
textures[(int) tileSet] = content.Load<Texture2D>(tileSetToContentPath[tileSet]);
}
terrainToTexture[Terrain.Grass] = GetTextureSource(TileSet.Grassland, 3, 0);
terrainToTexture[Terrain.GrassL] = GetTextureSource(TileSet.Grassland, 2, 0);
terrainToTexture[Terrain.GrassR] = GetTextureSource(TileSet.Grassland, 4, 0);
terrainToTexture[Terrain.Rock] = GetTextureSource(TileSet.Grassland, 3, 1);
terrainToTexture[Terrain.RockL] = GetTextureSource(TileSet.Grassland, 1, 2);
terrainToTexture[Terrain.RockR] = GetTextureSource(TileSet.Grassland, 5, 2);
terrainToTexture[Terrain.Water] = GetTextureSource(TileSet.Grassland, 9, 2);
terrainToTexture[Terrain.Block] = GetTextureSource(TileSet.Grassland, 6, 3);
}
public Tile MakeTile(Terrain terrain, Rectangle position) {
TextureSource textureSource = terrainToTexture[terrain];
return new Tile(terrain, position, textureSource.texture, textureSource.source);
}
private TextureSource GetTextureSource(TileSet tileSet, int x, int y) {
Texture2D texture = textures[(int) tileSet];
int size = World.TileSize;
Rectangle position = new Rectangle(x * size, y * size, size, size);
return new TextureSource(texture, position);
}
}
class Tile {
readonly Texture2D texture;
readonly Rectangle textureSource;
public Tile(Terrain terrain, Rectangle position, Texture2D texture, Rectangle textureSource) {
Terrain = terrain;
Position = position;
this.texture = texture;
this.textureSource = textureSource;
}
public Rectangle Position { get; private set; }
public Terrain Terrain { get; private set; }
public void Draw(SpriteBatch spriteBatch) {
spriteBatch.Draw(texture, Position.Location.ToVector2(), textureSource, Color.White);
}
}
class World {
public const int TileSize = 16;
readonly Tile[] tiles;
// Size of World in terms of tile grid.
private readonly int tileWidth;
private readonly int tileHeight;
// Size of World in pixels.
public int Width {
get { return tileWidth * TileSize; }
}
public int Height {
get { return tileHeight * TileSize; }
}
private static readonly Dictionary<char, Terrain> charToTerrain =
new Dictionary<char, Terrain>() {
{ '=', Terrain.Grass },
{ '<', Terrain.GrassL },
{ '>', Terrain.GrassR },
{ '.', Terrain.Rock },
{ '[', Terrain.RockL },
{ ']', Terrain.RockR },
{ '~', Terrain.Water },
{ 'X', Terrain.Block }
};
public World(ContentManager content, string levelSpecification) {
TileFactory factory = new TileFactory(content);
var tilesList = new List<Tile>();
string[] worldDesc = levelSpecification.Split('\n');
tileWidth = worldDesc.AsQueryable().Max(a => a.Length);
tileHeight = worldDesc.Length;
Debug.WriteLine("world size: {0}x{1}", tileWidth, tileHeight);
for (int i = 0; i < tileWidth; i++) {
for (int j = 0; j < tileHeight; j++) {
if (i < worldDesc[j].Length) {
char key = worldDesc[j][i];
if (charToTerrain.ContainsKey(key)) {
Terrain terrain = charToTerrain[key];
var position = new Rectangle(i * TileSize, j * TileSize, TileSize, TileSize);
tilesList.Add(factory.MakeTile(terrain, position));
}
}
}
}
tiles = tilesList.ToArray();
// Because we added tiles from left to right, the CollisionTargets 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[tiles.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 static terrain tile.
Vector2 halfSize = new Vector2(TileSize / 2, TileSize / 2);
for (int i = 0; i < tiles.Length; i++) {
Vector2 center = new Vector2(
tiles[i].Position.Left + halfSize.X, tiles[i].Position.Top + halfSize.Y);
CollisionTargets[i + 1] = new AABB(center, halfSize);
}
// Add a final synthetic collisionTarget on the right side of the world.
CollisionTargets[tiles.Length + 1] = new AABB(
new Vector2(Width + 1, 0), new Vector2(1, float.MaxValue));
}
public void Draw(SpriteBatch spriteBatch) {
foreach (Tile t in tiles) {
t.Draw(spriteBatch);
}
}
public AABB[] CollisionTargets { get; }
}
}