202 lines
9.6 KiB
C#
202 lines
9.6 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using Microsoft.Xna.Framework;
|
|
using Microsoft.Xna.Framework.Audio;
|
|
using Microsoft.Xna.Framework.Graphics;
|
|
using MLEM.Cameras;
|
|
using MLEM.Extended.Extensions;
|
|
using MLEM.Extended.Tiled;
|
|
using MLEM.Extensions;
|
|
using MLEM.Font;
|
|
using MLEM.Misc;
|
|
using MLEM.Startup;
|
|
using MLEM.Textures;
|
|
using MLEM.Ui;
|
|
using MonoGame.Extended;
|
|
using MonoGame.Extended.Tiled;
|
|
using RectangleF = MLEM.Misc.RectangleF;
|
|
|
|
namespace GreatSpringGameJam {
|
|
public class Map {
|
|
|
|
public static readonly SoundEffect ForgetMeNotPlatformSound = MlemGame.LoadContent<SoundEffect>("Sounds/PlatformAppear");
|
|
private static readonly UniformTextureAtlas BackgroundTexture = new(MlemGame.LoadContent<Texture2D>("Textures/Backgrounds"), 8, 8);
|
|
|
|
public Point SizeInPixels => new(this.map.WidthInPixels, this.map.HeightInPixels);
|
|
public Point SpawnPoint => new(this.map.Properties.GetInt("StartX"), this.map.Properties.GetInt("StartY"));
|
|
public Point Size => new(this.map.Width, this.map.Height);
|
|
public Vector2 TileSize => this.map.GetTileSize();
|
|
public readonly int TotalSnow;
|
|
public readonly int TotalSeeds;
|
|
public readonly int TotalGnomes;
|
|
public readonly string Name;
|
|
public TimeSpan ForgetMeNotTime;
|
|
|
|
private readonly TiledMap map;
|
|
private readonly IndividualTiledMapRenderer renderer;
|
|
private readonly TiledMapCollisions collisions;
|
|
private readonly List<Entity> entities = new();
|
|
|
|
public Map(TiledMap map, string name) {
|
|
this.map = map;
|
|
this.Name = name;
|
|
this.renderer = new IndividualTiledMapRenderer(this.map);
|
|
this.collisions = new TiledMapCollisions(this.map, (collisions, info) => {
|
|
// snow should only "collide" with the snow blower wind
|
|
if (info.Layer.Name == "Snow")
|
|
return;
|
|
foreach (var obj in info.TilesetTile.Objects) {
|
|
// level exits shouldn't be collidable
|
|
if (obj.Properties.GetBool("LevelExit"))
|
|
continue;
|
|
collisions.Add(obj.GetArea(info.Map, info.Position, info.Tile.Flags));
|
|
}
|
|
});
|
|
this.TotalSnow = this.GetTotalTiles("Snow") / 2;
|
|
this.TotalSeeds = this.GetTotalTiles("Seed");
|
|
|
|
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();
|
|
}
|
|
|
|
public void AddEntity(Entity entity) {
|
|
this.entities.Add(entity);
|
|
}
|
|
|
|
public void RemoveEntity(Entity entity) {
|
|
this.entities.Remove(entity);
|
|
}
|
|
|
|
public IEnumerable<T> GetEntities<T>() where T : Entity {
|
|
return this.entities.OfType<T>();
|
|
}
|
|
|
|
public void Update(GameTime time) {
|
|
this.renderer.UpdateAnimations(time);
|
|
for (var i = this.entities.Count - 1; i >= 0; i--)
|
|
this.entities[i].Update(time);
|
|
if (this.ForgetMeNotTime > TimeSpan.Zero) {
|
|
// if the time is about to run out, we play the platform disappear sound
|
|
if (this.ForgetMeNotTime > ForgetMeNotPlatformSound.Duration && this.ForgetMeNotTime - time.ElapsedGameTime <= ForgetMeNotPlatformSound.Duration)
|
|
ForgetMeNotPlatformSound.Play();
|
|
this.ForgetMeNotTime -= time.ElapsedGameTime;
|
|
}
|
|
}
|
|
|
|
public TiledMapTile GetTile(string layer, int x, int y) {
|
|
return this.map.GetTile(layer, x, y);
|
|
}
|
|
|
|
public void SetTile(string layer, int x, int y, int globalId) {
|
|
var index = this.map.GetTileLayerIndex(layer);
|
|
this.map.SetTile(layer, x, y, globalId);
|
|
this.renderer.UpdateDrawInfo(index, x, y);
|
|
this.collisions.UpdateCollisionInfo(index, x, y);
|
|
}
|
|
|
|
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);
|
|
}
|
|
|
|
public RectangleF GetArea(TiledMapObject obj, Vector2? pos = null) {
|
|
return obj.GetArea(this.map, pos).ToMlem();
|
|
}
|
|
|
|
public void Draw(GameTime time, SpriteBatch batch, Camera camera) {
|
|
batch.Begin(SpriteSortMode.Deferred, null, SamplerState.PointClamp, transformMatrix: camera.ViewMatrix);
|
|
// 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);
|
|
var clouds = BackgroundTexture[0, 4, 8, 2];
|
|
for (var x = -2; x < parW / clouds.Width / 2; x++) {
|
|
var pos = new Vector2(x * clouds.Width * 2, parH - mountains.Height * 2 - clouds.Height * 4);
|
|
batch.Draw(clouds, parallax + pos + new Vector2((float) time.TotalGameTime.TotalSeconds * 3 % (clouds.Width * 2), 0), Color.White * 0.5F, 0, Vector2.Zero, 2, SpriteEffects.None, 0);
|
|
batch.Draw(clouds, parallax + pos + new Vector2(clouds.Width + (float) time.TotalGameTime.TotalSeconds * 2.5F % (clouds.Width * 2), clouds.Height * 1.5F), Color.White * 0.5F, 0, Vector2.Zero, 2, SpriteEffects.None, 0);
|
|
}
|
|
// render map etc.
|
|
this.DrawLayer(batch, "Background", camera);
|
|
this.DrawLayer(batch, "Ground", camera);
|
|
|
|
var ui = GameImpl.Instance.UiSystem;
|
|
foreach (var obj in this.GetLevelEntrances()) {
|
|
var pos = obj.GetArea(this.map).Center;
|
|
var textTop = (pos - new Vector2(0, 4)) * this.TileSize;
|
|
var alpha = MathHelper.Clamp(1 - (Vector2.Distance(GameImpl.Instance.Player.Position + Vector2.One / 2, pos + Vector2.One / 2) - 2) / 3, 0.25F, 1);
|
|
ui.Style.Font.DrawString(batch, obj.Properties.Get("DisplayName"), textTop, TextAlign.Center, ui.Style.TextColor * alpha, 0, Vector2.Zero, 0.025F, SpriteEffects.None, 0);
|
|
GameImpl.Instance.Scores.TryGetValue(obj.Name, out var score);
|
|
ui.Style.Font.DrawString(batch, $"{score}% Completed", textTop + new Vector2(0, 0.75F) * this.TileSize, TextAlign.Center, ui.Style.TextColor * alpha, 0, Vector2.Zero, 0.02F, SpriteEffects.None, 0);
|
|
}
|
|
|
|
foreach (var entity in this.entities)
|
|
entity.Draw(time, batch);
|
|
|
|
this.DrawLayer(batch, "Snow", camera);
|
|
if (this.ForgetMeNotTime > TimeSpan.Zero) {
|
|
this.DrawLayer(batch, "ForgetMeNot", camera, (_, info) => {
|
|
var alpha = Easings.OutCubic.AndReverse().Invoke((float) this.ForgetMeNotTime.TotalSeconds / 10);
|
|
batch.Draw(info.Tileset.Texture, new Vector2(info.Position.X * this.map.TileWidth, info.Position.Y * this.map.TileHeight), info.Tileset.GetTextureRegion(info.TilesetTile), Color.White * alpha, 0, Vector2.Zero, 1, info.Tile.GetSpriteEffects(), info.Depth);
|
|
});
|
|
}
|
|
|
|
batch.End();
|
|
}
|
|
|
|
public int GetTotalTiles(string type) {
|
|
return this.EnumerateTiles(type).Count();
|
|
}
|
|
|
|
public IEnumerable<(LayerPosition, TiledMapTilesetTile)> EnumerateTiles(string type) {
|
|
for (var x = 0; x < this.map.Width; x++) {
|
|
for (var y = 0; y < this.map.Height; y++) {
|
|
foreach (var layer in this.map.TileLayers) {
|
|
var tile = layer.GetTile(x, y);
|
|
if (tile.IsBlank)
|
|
continue;
|
|
var tilesetTile = this.GetTilesetTile(tile, this.GetTileset(tile));
|
|
if (tilesetTile.Properties.GetBool(type))
|
|
yield return (new LayerPosition(layer.Name, x, y), tilesetTile);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public IEnumerable<TiledMapObject> GetLevelEntrances() {
|
|
var layer = this.map.GetLayer<TiledMapObjectLayer>("Entrances");
|
|
if (layer != null) {
|
|
foreach (var obj in layer.Objects)
|
|
yield return obj;
|
|
}
|
|
}
|
|
|
|
public IEnumerable<(Vector2, float)> GetPenetrations(Func<RectangleF> getArea, bool prioritizeX) {
|
|
return this.collisions.GetPenetrations(() => getArea().ToExtended(), i => {
|
|
if (i.Layer.Name == "ForgetMeNot")
|
|
return this.ForgetMeNotTime > TimeSpan.Zero;
|
|
return true;
|
|
}, prioritizeX);
|
|
}
|
|
|
|
private void DrawLayer(SpriteBatch batch, string layer, Camera camera, IndividualTiledMapRenderer.DrawDelegate drawDelegate = null) {
|
|
var id = this.map.GetTileLayerIndex(layer);
|
|
if (id >= 0)
|
|
this.renderer.DrawLayer(batch, id, camera.GetVisibleRectangle().ToExtended(), drawDelegate);
|
|
}
|
|
|
|
}
|
|
} |