cthangover/mod_rpg
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Mod unit tests: map grid, walking rules, encounters, save round trip

Browse Source
This commit is contained in:
cthangover committed 2026-10-21 13:32:59 +02:00
1 parent 09d601ee14
commit 657353b959
3 files changed
+299
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

tests/RpgMapGridTests.cs
+122
View File
@@ -0,0 +1,122 @@
namespace Cthangover.Mods.Rpg.Tests
{
using System.Collections.Generic;
using Cthangover.Core.Mods.Testing;
/// <summary>
/// Map layers are hand-edited text: parsing must be forgiving and give a
/// grid of exactly the declared size, and writing must read back the same.
/// </summary>
public class RpgMapGridTests
{
[ModTest("grid/parse_reads_rows_and_collision")]
static void ParseReadsRowsAndCollision(ModTestContext ctx)
{
var map = new RpgMap
{
Width = 3,
Height = 2,
Layers = new RpgMapLayers
{
Back = new List<string> { "0 1 2", "3 . 5" },
Main = new List<string> { ". 8" },
Front = new List<string>(),
},
Collision = new List<string> { "#o.", ".x" },
};
var grid = RpgMapGrid.Parse(map);
ModAssert.Equal(1, grid.GetTile(RpgLayer.Back, 1, 0), "back (1,0)");
ModAssert.Equal(-1, grid.GetTile(RpgLayer.Back, 1, 1), "a dot is empty");
ModAssert.Equal(8, grid.GetTile(RpgLayer.Main, 1, 0), "main (1,0)");
ModAssert.Equal(-1, grid.GetTile(RpgLayer.Main, 2, 1), "a missing row is empty");
ModAssert.Equal("#", grid.GetCollision(0, 0).ToString(), "block code");
ModAssert.Equal("o", grid.GetCollision(1, 0).ToString(), "open code");
ModAssert.Equal(".", grid.GetCollision(1, 1).ToString(), "an unknown code is auto");
ModAssert.Equal("#", grid.GetCollision(5, 5).ToString(), "outside the map is blocked");
}
[ModTest("grid/parse_is_forgiving")]
static void ParseIsForgiving(ModTestContext ctx)
{
var map = new RpgMap
{
Width = 2,
Height = 1,
Layers = new RpgMapLayers { Back = new List<string> { "7 abc 9 9" } },
};
var grid = RpgMapGrid.Parse(map);
ModAssert.Equal(2, grid.Width, "width stays declared");
ModAssert.Equal(7, grid.GetTile(RpgLayer.Back, 0, 0), "first cell");
ModAssert.Equal(-1, grid.GetTile(RpgLayer.Back, 1, 0), "an unreadable token is empty");
ModAssert.Equal(-1, grid.GetTile(RpgLayer.Back, 2, 0), "extra cells are cut off");
}
[ModTest("grid/write_reads_back")]
static void WriteReadsBack(ModTestContext ctx)
{
var grid = new RpgMapGrid(3, 2);
grid.SetTile(RpgLayer.Back, 0, 0, 12);
grid.SetTile(RpgLayer.Main, 2, 1, 3);
grid.SetTile(RpgLayer.Front, 1, 0, 0);
grid.SetCollision(1, 1, RpgCollision.Block);
var map = new RpgMap();
grid.WriteTo(map);
var back = RpgMapGrid.Parse(map);
ModAssert.Equal(3, map.Width, "width written");
ModAssert.Equal(2, map.Height, "height written");
ModAssert.Equal("12 . .", map.Layers.Back[0], "indices are aligned to one width");
ModAssert.Equal(12, back.GetTile(RpgLayer.Back, 0, 0), "back");
ModAssert.Equal(3, back.GetTile(RpgLayer.Main, 2, 1), "main");
ModAssert.Equal(0, back.GetTile(RpgLayer.Front, 1, 0), "front tile 0 is not empty");
ModAssert.Equal("#", back.GetCollision(1, 1).ToString(), "collision");
}
[ModTest("grid/all_auto_collision_writes_no_rows")]
static void AllAutoCollisionWritesNoRows(ModTestContext ctx)
{
var map = new RpgMap();
new RpgMapGrid(4, 4).WriteTo(map);
ModAssert.Equal(0, map.Collision.Count, "no collision rows");
ModAssert.Equal(4, map.Layers.Main.Count, "layer rows are always written");
}
[ModTest("grid/resize_keeps_top_left")]
static void ResizeKeepsTopLeft(ModTestContext ctx)
{
var grid = new RpgMapGrid(2, 2);
grid.SetTile(RpgLayer.Back, 1, 1, 5);
grid.SetCollision(0, 1, RpgCollision.Open);
grid.Resize(4, 1);
ModAssert.Equal(4, grid.Width, "new width");
ModAssert.Equal(1, grid.Height, "new height");
ModAssert.Equal(-1, grid.GetTile(RpgLayer.Back, 1, 1), "a cut row is gone");
ModAssert.Equal(-1, grid.GetTile(RpgLayer.Back, 3, 0), "new cells are empty");
grid.Resize(2, 2);
ModAssert.Equal(".", grid.GetCollision(0, 1).ToString(), "a row cut once does not come back");
}
[ModTest("grid/clone_is_independent")]
static void CloneIsIndependent(ModTestContext ctx)
{
var grid = new RpgMapGrid(2, 2);
grid.SetTile(RpgLayer.Main, 0, 0, 4);
var copy = grid.Clone();
copy.SetTile(RpgLayer.Main, 0, 0, 9);
copy.SetCollision(1, 1, RpgCollision.Block);
ModAssert.Equal(4, grid.GetTile(RpgLayer.Main, 0, 0), "original tile");
ModAssert.Equal(".", grid.GetCollision(1, 1).ToString(), "original collision");
}
}
}
tests/RpgRulesTests.cs
+101
View File
@@ -0,0 +1,101 @@
namespace Cthangover.Mods.Rpg.Tests
{
using System;
using System.Collections.Generic;
using Cthangover.Core.Mods.Testing;
/// <summary>Walking rules and random battles: the terrain decisions the world makes on every step.</summary>
public class RpgRulesTests
{
private static RpgTileset Tileset() => new()
{
ID = "test",
Tiles = new List<RpgTileInfo>
{
new() { Index = 5, Solid = true },
new() { Index = 9, Solid = false },
},
};
[ModTest("rules/solid_tile_blocks_on_back_and_main_only")]
static void SolidTileBlocksOnBackAndMainOnly(ModTestContext ctx)
{
var grid = new RpgMapGrid(3, 1);
grid.SetTile(RpgLayer.Back, 0, 0, 5);
grid.SetTile(RpgLayer.Main, 1, 0, 5);
grid.SetTile(RpgLayer.Front, 2, 0, 5);
ModAssert.False(RpgPassability.IsWalkable(grid, Tileset(), 0, 0), "solid on back");
ModAssert.False(RpgPassability.IsWalkable(grid, Tileset(), 1, 0), "solid on main");
ModAssert.True(RpgPassability.IsWalkable(grid, Tileset(), 2, 0), "front tiles are walked under");
ModAssert.False(RpgPassability.IsWalkable(grid, Tileset(), 3, 0), "outside the map");
}
[ModTest("rules/collision_layer_overrides_tiles")]
static void CollisionLayerOverridesTiles(ModTestContext ctx)
{
var grid = new RpgMapGrid(2, 1);
grid.SetTile(RpgLayer.Main, 0, 0, 5);
grid.SetCollision(0, 0, RpgCollision.Open);
grid.SetCollision(1, 0, RpgCollision.Block);
ModAssert.True(RpgPassability.IsWalkable(grid, Tileset(), 0, 0), "open beats a solid tile");
ModAssert.False(RpgPassability.IsWalkable(grid, Tileset(), 1, 0), "block on empty ground");
}
[ModTest("rules/tileset_solid_lookup")]
static void TilesetSolidLookup(ModTestContext ctx)
{
var tileset = Tileset();
ModAssert.True(tileset.IsSolid(5), "listed solid");
ModAssert.False(tileset.IsSolid(9), "listed walkable");
ModAssert.False(tileset.IsSolid(1), "unlisted");
ModAssert.False(tileset.IsSolid(-1), "empty cell");
}
[ModTest("rules/encounter_off_without_table")]
static void EncounterOffWithoutTable(ModTestContext ctx)
{
var random = new Random(1);
ModAssert.Null(RpgEncounterRoller.Roll(null, random), "no table");
ModAssert.Null(RpgEncounterRoller.Roll(new RpgEncounterTable { Steps = 0, Groups = new() { "a" } }, random), "steps 0");
ModAssert.Null(RpgEncounterRoller.Roll(new RpgEncounterTable { Steps = 1 }, random), "no groups");
}
[ModTest("rules/encounter_every_step_picks_a_group")]
static void EncounterEveryStepPicksAGroup(ModTestContext ctx)
{
var table = new RpgEncounterTable { Steps = 1, Groups = new() { "slime", "wolf,slime" } };
var random = new Random(7);
var seen = new HashSet<string>();
for (var i = 0; i < 50; i++)
seen.Add(RpgEncounterRoller.Roll(table, random));
ModAssert.Equal(2, seen.Count, "both groups are picked, never null");
ModAssert.True(seen.Contains("wolf,slime"), "groups come back as written");
}
[ModTest("rules/encounter_rate_follows_steps")]
static void EncounterRateFollowsSteps(ModTestContext ctx)
{
var table = new RpgEncounterTable { Steps = 10, Groups = new() { "slime" } };
var random = new Random(3);
var battles = 0;
for (var i = 0; i < 10000; i++)
{
if (RpgEncounterRoller.Roll(table, random) != null)
battles++;
}
ModAssert.True(battles > 800 && battles < 1200, $"about one battle in ten steps, got {battles}");
}
[ModTest("rules/directions")]
static void Directions(ModTestContext ctx)
{
ModAssert.Equal(-1, RpgDirections.Delta(RpgDirection.Up).Y, "up is y-1");
ModAssert.Equal(1, RpgDirections.Delta(RpgDirection.Right).X, "right is x+1");
ModAssert.Equal("Up", RpgDirections.Opposite(RpgDirection.Down).ToString(), "opposite of down");
ModAssert.Equal("Left", RpgDirections.Opposite(RpgDirection.Right).ToString(), "opposite of right");
}
}
}
tests/RpgStateTests.cs
+76
View File
@@ -0,0 +1,76 @@
namespace Cthangover.Mods.Rpg.Tests
{
using System.Text.Json;
using Cthangover.Core.Mods.Testing;
using Cthangover.Core.Settings;
/// <summary>The saved position and the map file format survive a JSON round trip.</summary>
public class RpgStateTests
{
[ModTest("state/save_and_load_round_trip")]
static void SaveAndLoadRoundTrip(ModTestContext ctx)
{
var state = RpgState.Instance;
var before = state.Data;
try
{
state.Place("rpg_forest", 4, 7, RpgDirection.Left);
var slot = new ModSlot();
var saveable = new RpgSaveable();
saveable.OnSave(slot);
var json = JsonSerializer.Serialize(slot);
var restored = JsonSerializer.Deserialize<ModSlot>(json);
state.Reset();
ModAssert.True(saveable.OnLoad(restored, out var error), error);
ModAssert.Equal("rpg_forest", state.Data.Map, "map");
ModAssert.Equal(4, state.Data.X, "x");
ModAssert.Equal(7, state.Data.Y, "y");
ModAssert.Equal("Left", state.Data.Dir.ToString(), "facing");
}
finally
{
state.Data = before;
}
}
[ModTest("state/load_without_data_goes_to_spawn")]
static void LoadWithoutDataGoesToSpawn(ModTestContext ctx)
{
var state = RpgState.Instance;
var before = state.Data;
try
{
state.Place("rpg_forest", 1, 1, RpgDirection.Up);
ModAssert.True(new RpgSaveable().OnLoad(new ModSlot(), out _), "an empty slot is accepted");
ModAssert.Null(state.Data.Map, "no map: the next entry uses the spawn");
}
finally
{
state.Data = before;
}
}
[ModTest("state/map_file_round_trip")]
static void MapFileRoundTrip(ModTestContext ctx)
{
var json = @"{""Id"":""m"",""Tileset"":""village"",""Width"":2,""Height"":1,
""Spawn"":{""X"":1,""Y"":0,""Dir"":""left""},
""Events"":[{""Id"":""door"",""X"":0,""Y"":0,""Trigger"":""touch"",""Teleport"":{""Map"":""x"",""X"":3,""Y"":4,""Dir"":""Up""}}],
""Encounters"":{""Steps"":20,""Groups"":[""slime""]}}";
var map = JsonSerializer.Deserialize<RpgMap>(json, Cthangover.Core.Utils.JsonOptionsProvider.ReadOptions);
var again = JsonSerializer.Deserialize<RpgMap>(JsonSerializer.Serialize(map), Cthangover.Core.Utils.JsonOptionsProvider.ReadOptions);
ModAssert.Equal("m", again.ID, "id");
ModAssert.Equal("Left", again.Spawn.Dir.ToString(), "spawn facing, read in any case");
ModAssert.Equal("Touch", again.Events[0].Trigger.ToString(), "trigger");
ModAssert.Equal("x", again.Events[0].Teleport.Map, "teleport map");
ModAssert.Equal(4, again.Events[0].Teleport.Y, "teleport y");
ModAssert.False(again.Events[0].IsSolid, "an invisible event does not block");
ModAssert.Equal(20, again.Encounters.Steps, "encounter steps");
ModAssert.Equal(2, again.Zoom, "zoom default");
}
}
}