2021-03-07 22:23:51 +01:00
|
|
|
using System.Collections.Generic;
|
2021-03-09 23:21:52 +01:00
|
|
|
using System.Linq;
|
2021-03-07 22:23:51 +01:00
|
|
|
using Microsoft.Xna.Framework;
|
|
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
|
|
using MLEM.Cameras;
|
|
|
|
using MLEM.Extended.Extensions;
|
|
|
|
using MLEM.Extended.Tiled;
|
2021-03-09 02:37:44 +01:00
|
|
|
using MLEM.Extensions;
|
2021-03-07 22:23:51 +01:00
|
|
|
using MLEM.Misc;
|
|
|
|
using MLEM.Startup;
|
2021-03-09 02:37:44 +01:00
|
|
|
using MLEM.Textures;
|
|
|
|
using MonoGame.Extended;
|
2021-03-07 22:23:51 +01:00
|
|
|
using MonoGame.Extended.Tiled;
|
2021-03-10 02:26:36 +01:00
|
|
|
using RectangleF = MLEM.Misc.RectangleF;
|
2021-03-07 22:23:51 +01:00
|
|
|
|
|
|
|
namespace GreatSpringGameJam {
|
|
|
|
public class Map {
|
|
|
|
|
2021-03-09 02:37:44 +01:00
|
|
|
private static readonly UniformTextureAtlas BackgroundTexture = new(MlemGame.LoadContent<Texture2D>("Textures/Backgrounds"), 8, 8);
|
2021-03-07 22:23:51 +01:00
|
|
|
public Point SizeInPixels => new(this.map.WidthInPixels, this.map.HeightInPixels);
|
2021-03-09 02:37:44 +01:00
|
|
|
public Point SpawnPoint => new(this.map.Properties.GetInt("StartX"), this.map.Properties.GetInt("StartY"));
|
2021-03-09 18:29:07 +01:00
|
|
|
public Point Size => new(this.map.Width, this.map.Height);
|
2021-03-07 22:23:51 +01:00
|
|
|
public Vector2 TileSize => this.map.GetTileSize();
|
|
|
|
public readonly TiledMapCollisions Collisions;
|
2021-03-08 19:08:41 +01:00
|
|
|
public readonly int TotalSnow;
|
|
|
|
public readonly int TotalSeeds;
|
2021-03-09 20:13:26 +01:00
|
|
|
public readonly int TotalGnomes;
|
2021-03-07 22:23:51 +01:00
|
|
|
|
|
|
|
private readonly TiledMap map;
|
|
|
|
private readonly IndividualTiledMapRenderer renderer;
|
|
|
|
private readonly List<Entity> entities = new();
|
|
|
|
|
2021-03-09 18:29:07 +01:00
|
|
|
public Map(TiledMap map) {
|
|
|
|
this.map = map;
|
2021-03-07 22:23:51 +01:00
|
|
|
this.renderer = new IndividualTiledMapRenderer(this.map);
|
2021-03-10 02:26:36 +01:00
|
|
|
this.Collisions = new TiledMapCollisions(this.map, (collisions, info) => {
|
|
|
|
// snow should only "collide" with the snow blower wind
|
|
|
|
if (info.Layer.Name != "Snow")
|
|
|
|
TiledMapCollisions.DefaultCollectCollisions(collisions, info);
|
|
|
|
});
|
|
|
|
this.TotalSnow = this.GetTotalTiles("Snow") / 2;
|
2021-03-08 19:08:41 +01:00
|
|
|
this.TotalSeeds = this.GetTotalTiles("Seed");
|
2021-03-09 23:21:52 +01:00
|
|
|
|
|
|
|
foreach (var (pos, _) in this.EnumerateTiles("Gnome")) {
|
|
|
|
this.entities.Add(new Gnome(this, new Vector2(pos.X, pos.Y)));
|
|
|
|
this.SetTile(pos.Layer, pos.X, pos.Y, 0);
|
|
|
|
}
|
|
|
|
this.TotalGnomes = this.entities.OfType<Gnome>().Count();
|
2021-03-07 22:23:51 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
public void AddEntity(Entity entity) {
|
|
|
|
this.entities.Add(entity);
|
|
|
|
}
|
|
|
|
|
2021-03-08 02:37:40 +01:00
|
|
|
public void RemoveEntity(Entity entity) {
|
|
|
|
this.entities.Remove(entity);
|
|
|
|
}
|
|
|
|
|
2021-03-09 23:21:52 +01:00
|
|
|
public IEnumerable<T> GetEntities<T>() where T : Entity {
|
|
|
|
return this.entities.OfType<T>();
|
|
|
|
}
|
|
|
|
|
2021-03-07 22:23:51 +01:00
|
|
|
public void Update(GameTime time) {
|
|
|
|
this.renderer.UpdateAnimations(time);
|
2021-03-08 02:37:40 +01:00
|
|
|
for (var i = this.entities.Count - 1; i >= 0; i--)
|
|
|
|
this.entities[i].Update(time);
|
|
|
|
}
|
|
|
|
|
|
|
|
public TiledMapTile GetTile(string layer, int x, int y) {
|
|
|
|
return this.map.GetTile(layer, x, y);
|
|
|
|
}
|
|
|
|
|
2021-03-09 20:13:26 +01:00
|
|
|
public void SetTile(string layer, int x, int y, int globalId) {
|
2021-03-08 02:37:40 +01:00
|
|
|
var index = this.map.GetTileLayerIndex(layer);
|
2021-03-09 20:13:26 +01:00
|
|
|
this.map.SetTile(layer, x, y, globalId);
|
2021-03-08 02:37:40 +01:00
|
|
|
this.renderer.UpdateDrawInfo(index, x, y);
|
|
|
|
this.Collisions.UpdateCollisionInfo(index, x, y);
|
|
|
|
}
|
|
|
|
|
2021-03-09 20:13:26 +01:00
|
|
|
public void SetTile(string layer, int x, int y, TiledMapTileset tileset, TiledMapTilesetTile tile) {
|
|
|
|
this.SetTile(layer, x, y, tile.GetGlobalIdentifier(tileset, this.map));
|
|
|
|
}
|
|
|
|
|
|
|
|
public TiledMapTilesetTile GetTilesetTile(TiledMapTile tile, TiledMapTileset tileset) {
|
|
|
|
return tileset.GetTilesetTile(tile, this.map);
|
|
|
|
}
|
|
|
|
|
|
|
|
public TiledMapTileset GetTileset(TiledMapTile tile) {
|
|
|
|
return tile.GetTileset(this.map);
|
2021-03-07 22:23:51 +01:00
|
|
|
}
|
|
|
|
|
2021-03-10 02:26:36 +01:00
|
|
|
public RectangleF GetArea(TiledMapObject obj, Vector2? pos = null) {
|
|
|
|
return obj.GetArea(this.map, pos).ToMlem();
|
|
|
|
}
|
|
|
|
|
2021-03-07 22:23:51 +01:00
|
|
|
public void Draw(GameTime time, SpriteBatch batch, Camera camera) {
|
|
|
|
batch.Begin(SpriteSortMode.Deferred, null, SamplerState.PointClamp, transformMatrix: camera.ViewMatrix);
|
2021-03-09 02:37:44 +01:00
|
|
|
// render background
|
|
|
|
const float parallaxFactor = 0.5F;
|
|
|
|
var parallax = camera.Position * parallaxFactor;
|
|
|
|
var (parW, parH) = this.SizeInPixels.ToVector2() * (1 - parallaxFactor) + camera.ScaledViewport * parallaxFactor;
|
|
|
|
var mountains = BackgroundTexture[0, 0, 8, 4];
|
|
|
|
for (var x = 0; x < parW; x += mountains.Width * 2) {
|
|
|
|
batch.Draw(mountains, parallax + new Vector2(x, parH - mountains.Height * 2), Color.White * 0.5F, 0, Vector2.Zero, 2, SpriteEffects.None, 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
// render map etc.
|
2021-03-09 20:13:26 +01:00
|
|
|
this.DrawLayer(batch, "Background", camera);
|
2021-03-08 02:37:40 +01:00
|
|
|
this.DrawLayer(batch, "Ground", camera);
|
2021-03-07 22:23:51 +01:00
|
|
|
foreach (var entity in this.entities)
|
|
|
|
entity.Draw(time, batch);
|
2021-03-08 19:08:41 +01:00
|
|
|
this.DrawLayer(batch, "Foreground", camera);
|
2021-03-08 02:37:40 +01:00
|
|
|
this.DrawLayer(batch, "Snow", camera);
|
2021-03-07 22:23:51 +01:00
|
|
|
batch.End();
|
|
|
|
}
|
|
|
|
|
2021-03-08 19:08:41 +01:00
|
|
|
public int GetTotalTiles(string type) {
|
2021-03-09 23:21:52 +01:00
|
|
|
return this.EnumerateTiles(type).Count();
|
|
|
|
}
|
|
|
|
|
|
|
|
public IEnumerable<(LayerPosition, TiledMapTilesetTile)> EnumerateTiles(string type) {
|
2021-03-08 19:08:41 +01:00
|
|
|
for (var x = 0; x < this.map.Width; x++) {
|
|
|
|
for (var y = 0; y < this.map.Height; y++) {
|
2021-03-09 23:21:52 +01:00
|
|
|
foreach (var layer in this.map.TileLayers) {
|
|
|
|
var tile = layer.GetTile(x, y);
|
2021-03-08 19:08:41 +01:00
|
|
|
if (tile.IsBlank)
|
|
|
|
continue;
|
2021-03-09 20:13:26 +01:00
|
|
|
var tilesetTile = this.GetTilesetTile(tile, this.GetTileset(tile));
|
2021-03-08 19:08:41 +01:00
|
|
|
if (tilesetTile.Properties.GetBool(type))
|
2021-03-09 23:21:52 +01:00
|
|
|
yield return (new LayerPosition(layer.Name, x, y), tilesetTile);
|
2021-03-08 19:08:41 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-03-08 02:37:40 +01:00
|
|
|
private void DrawLayer(SpriteBatch batch, string layer, Camera camera) {
|
2021-03-09 20:13:26 +01:00
|
|
|
var id = this.map.GetTileLayerIndex(layer);
|
|
|
|
if (id >= 0)
|
|
|
|
this.renderer.DrawLayer(batch, id, camera.GetVisibleRectangle().ToExtended());
|
2021-03-08 02:37:40 +01:00
|
|
|
}
|
|
|
|
|
2021-03-07 22:23:51 +01:00
|
|
|
}
|
|
|
|
}
|