Moved tests

kiln-core/src/tests/map_file/grid_errors.rs

@@ -0,0 +1,53 @@
+use crate::archetype::Archetype;
+use crate::board::Board;
+use crate::map_file::MapFile;
+use super::minimal_toml;
+
+#[test]
+fn grid_wrong_row_count_returns_error() {
+    // height = 3 but only 2 rows in the grid
+    let toml = minimal_toml(3, 3, &["...", "..."]);
+    let mf: MapFile = toml::from_str(&toml).unwrap();
+    let result = Board::try_from(mf);
+    assert!(result.is_err());
+    let msg = result.err().unwrap();
+    assert!(msg.contains("2 rows"), "expected row count in error, got: {msg}");
+    assert!(msg.contains("height = 3"), "expected declared height in error, got: {msg}");
+}
+
+#[test]
+fn grid_wrong_row_width_returns_error() {
+    // width = 4 but second row is only 3 characters
+    let toml = minimal_toml(4, 2, &["....", "..."]);
+    let mf: MapFile = toml::from_str(&toml).unwrap();
+    let result = Board::try_from(mf);
+    assert!(result.is_err());
+    let msg = result.err().unwrap();
+    assert!(msg.contains("3 characters"), "expected col count in error, got: {msg}");
+    assert!(msg.contains("width = 4"), "expected declared width in error, got: {msg}");
+}
+
+#[test]
+fn object_archetype_in_palette_produces_error_block() {
+    // "object" is no longer a valid palette archetype; it should produce ErrorBlock.
+    // Player is placed away from the O cell so it isn't cleared.
+    let toml = r##"
+[map]
+name = "Test"
+width = 2
+height = 1
+player_start = [1, 0]
+
+[palette]
+"O" = { archetype = "object", tile = 64, fg = "#00FFFF", bg = "#000000" }
+"." = { archetype = "empty", tile = 46, fg = "#000000", bg = "#000000" }
+
+[grid]
+content = """
+O.
+"""
+"##;
+    let mf: MapFile = toml::from_str(toml).unwrap();
+    let board = Board::try_from(mf).unwrap();
+    assert_eq!(*board.get(0, 0), (Archetype::ErrorBlock.default_glyph(), Archetype::ErrorBlock));
+}

kiln-core/src/tests/map_file/mod.rs

@@ -0,0 +1,89 @@
+mod grid_errors;
+mod object_placement;
+mod player_placement;
+mod round_trip;
+
+use crate::board::Board;
+use crate::map_file::MapFile;
+
+fn load_board(toml: &str) -> Board {
+    let mf: MapFile = toml::from_str(toml).expect("parse toml");
+    Board::try_from(mf).expect("convert to board")
+}
+
+/// A 3×1 map (`empty` palette `.`) whose grid is `grid`, plus the given
+/// `[[objects]]` TOML appended. Keeps placement tests compact.
+fn map_3x1(grid: &str, objects: &str) -> String {
+    format!(
+        r##"
+[map]
+name = "Test"
+width = 3
+height = 1
+player_start = [2, 0]
+
+[palette]
+"." = {{ archetype = "empty", tile = 46, fg = "#000000", bg = "#000000" }}
+"#" = {{ archetype = "wall", tile = 35, fg = "#808080", bg = "#606060" }}
+
+[grid]
+content = """
+{grid}
+"""
+{objects}
+"##
+    )
+}
+
+/// A standard `[[objects]]` block placed by palette char `ch`.
+fn obj_palette(ch: &str, extra: &str) -> String {
+    format!(
+        "[[objects]]\npalette = \"{ch}\"\ntile = 64\nfg = \"#00FFFF\"\nbg = \"#000000\"\n{extra}"
+    )
+}
+
+/// A 1-row map of the given `width` with a raw `player_start` TOML value
+/// (`start`, e.g. `[1, 0]` or `"@"`), grid, and objects block.
+fn player_map(width: usize, start: &str, grid: &str, objects: &str) -> String {
+    format!(
+        r##"
+[map]
+name = "Test"
+width = {width}
+height = 1
+player_start = {start}
+
+[palette]
+"." = {{ archetype = "empty", tile = 46, fg = "#000000", bg = "#000000" }}
+"#" = {{ archetype = "wall", tile = 35, fg = "#808080", bg = "#606060" }}
+
+[grid]
+content = """
+{grid}
+"""
+{objects}
+"##
+    )
+}
+
+/// Minimal valid TOML with a configurable grid, used as a base for dimension tests.
+fn minimal_toml(width: usize, height: usize, grid_rows: &[&str]) -> String {
+    let content = grid_rows.join("\n");
+    format!(
+        r##"
+[map]
+name = "Test"
+width = {width}
+height = {height}
+player_start = [0, 0]
+
+[palette]
+"." = {{ archetype = "empty", tile = 46, fg = "#000000", bg = "#000000" }}
+
+[grid]
+content = """
+{content}
+"""
+"##
+    )
+}

kiln-core/src/tests/map_file/object_placement.rs

@@ -0,0 +1,65 @@
+use crate::archetype::Archetype;
+use super::{load_board, map_3x1, obj_palette};
+
+#[test]
+fn palette_placement_puts_object_on_empty_floor() {
+    // `G` appears once, isn't a palette key → object lands there, cell is Empty.
+    let board = load_board(&map_3x1("G..", &obj_palette("G", "")));
+    assert_eq!(board.objects.len(), 1);
+    assert_eq!((board.objects[&1].x, board.objects[&1].y), (0, 0));
+    assert_eq!(board.get(0, 0).1, Archetype::Empty);
+}
+
+#[test]
+fn palette_char_absent_from_grid_drops_object() {
+    let board = load_board(&map_3x1("...", &obj_palette("G", "")));
+    assert!(board.objects.is_empty());
+    assert!(!board.is_valid());
+}
+
+#[test]
+fn palette_char_appearing_twice_uses_first() {
+    // `G` appears at (0,0) and (2,0): the object lands at the first, and the
+    // map is flagged invalid (an extra appearance was reported).
+    let board = load_board(&map_3x1("G.G", &obj_palette("G", "")));
+    assert_eq!(board.objects.len(), 1);
+    assert_eq!((board.objects[&1].x, board.objects[&1].y), (0, 0));
+    assert!(!board.is_valid());
+}
+
+#[test]
+fn palette_char_reused_by_two_objects_keeps_first() {
+    // Two objects claim `G`: the first keeps it, the later one is dropped.
+    let two = format!("{}\n{}", obj_palette("G", ""), obj_palette("G", ""));
+    let board = load_board(&map_3x1("G..", &two));
+    assert_eq!(board.objects.len(), 1);
+    assert!(!board.is_valid());
+}
+
+#[test]
+fn palette_char_colliding_with_palette_key_drops_object() {
+    // `#` is a terrain palette key, so it can't be an object placeholder.
+    let board = load_board(&map_3x1("#..", &obj_palette("#", "")));
+    assert!(board.objects.is_empty());
+}
+
+#[test]
+fn solid_object_on_wall_is_dropped_but_non_solid_is_kept() {
+    // Solid object at the wall cell (0,0): dropped for conflicting with the wall.
+    let solid = "[[objects]]\nx = 0\ny = 0\ntile = 64\nfg = \"#00FFFF\"\nbg = \"#000000\"\n";
+    let board = load_board(&map_3x1("#..", solid));
+    assert!(board.objects.is_empty());
+
+    // Same placement but non-solid: kept (it doesn't claim the cell's solidity).
+    let nonsolid = format!("{solid}solid = false\n");
+    let board = load_board(&map_3x1("#..", &nonsolid));
+    assert_eq!(board.objects.len(), 1);
+}
+
+#[test]
+fn second_solid_object_on_a_cell_is_dropped() {
+    let obj = "[[objects]]\nx = 1\ny = 0\ntile = 64\nfg = \"#00FFFF\"\nbg = \"#000000\"\n";
+    let board = load_board(&map_3x1("...", &format!("{obj}{obj}")));
+    assert_eq!(board.objects.len(), 1);
+    assert!(!board.is_valid());
+}

kiln-core/src/tests/map_file/player_placement.rs

@@ -0,0 +1,70 @@
+use crate::archetype::Archetype;
+use super::{load_board, player_map};
+
+#[test]
+fn player_coords_place_the_player() {
+    let b = load_board(&player_map(3, "[1, 0]", "...", ""));
+    assert_eq!((b.player.x, b.player.y), (1, 0));
+    assert!(b.is_valid());
+}
+
+#[test]
+fn player_char_places_on_empty_floor() {
+    let b = load_board(&player_map(3, "\"@\"", ".@.", ""));
+    assert_eq!((b.player.x, b.player.y), (1, 0));
+    assert_eq!(b.get(1, 0).1, Archetype::Empty);
+    assert!(b.is_valid());
+}
+
+#[test]
+fn player_wins_solid_terrain_silently() {
+    // Player coords land on a wall: the wall is cleared, no error reported.
+    let b = load_board(&player_map(3, "[0, 0]", "#..", ""));
+    assert_eq!((b.player.x, b.player.y), (0, 0));
+    assert_eq!(b.get(0, 0).1, Archetype::Empty);
+    assert!(b.is_valid());
+}
+
+#[test]
+fn player_wins_against_a_solid_object_silently() {
+    // A solid object on the player's cell is dropped, silently (player wins).
+    let obj = "[[objects]]\nx = 1\ny = 0\ntile = 64\nfg = \"#00FFFF\"\nbg = \"#000000\"\n";
+    let b = load_board(&player_map(3, "[1, 0]", "...", obj));
+    assert!(b.objects.is_empty());
+    assert!(b.is_valid());
+}
+
+#[test]
+fn player_char_is_reserved_from_objects() {
+    // An object trying to use '@' is dropped; the player is still placed.
+    let obj = "[[objects]]\npalette = \"@\"\ntile = 64\nfg = \"#00FFFF\"\nbg = \"#000000\"\n";
+    let b = load_board(&player_map(3, "\"@\"", "@..", obj));
+    assert_eq!((b.player.x, b.player.y), (0, 0));
+    assert!(b.objects.is_empty());
+    assert!(!b.is_valid());
+}
+
+#[test]
+fn player_char_appearing_twice_uses_first() {
+    let b = load_board(&player_map(3, "\"@\"", "@.@", ""));
+    assert_eq!((b.player.x, b.player.y), (0, 0));
+    assert!(!b.is_valid());
+}
+
+#[test]
+fn player_char_missing_falls_back_to_origin() {
+    let b = load_board(&player_map(3, "\"@\"", "...", ""));
+    assert_eq!((b.player.x, b.player.y), (0, 0));
+    assert!(!b.is_valid());
+}
+
+#[test]
+fn player_fallback_to_origin_clears_solid_terrain() {
+    // The '@' char is absent, so the player falls back to (0, 0) — which holds a
+    // wall. The player wins its cell: the wall is cleared so one-solid-per-cell
+    // holds. The fallback is still reported.
+    let b = load_board(&player_map(3, "\"@\"", "#..", ""));
+    assert_eq!((b.player.x, b.player.y), (0, 0));
+    assert_eq!(b.get(0, 0).1, Archetype::Empty);
+    assert!(!b.is_valid());
+}

kiln-core/src/tests/map_file/round_trip.rs

@@ -0,0 +1,100 @@
+use color::Rgba8;
+use crate::board::Board;
+use crate::glyph::Glyph;
+use crate::map_file::{MapFile, parse_color};
+use super::load_board;
+
+#[test]
+fn object_glyph_round_trips_through_toml() {
+    // Objects must survive a save→load cycle with their glyph intact.
+    let toml = r##"
+[map]
+name = "Test"
+width = 3
+height = 3
+player_start = [0, 0]
+
+[palette]
+"." = { archetype = "empty", tile = 46, fg = "#000000", bg = "#000000" }
+
+[grid]
+content = """
+...
+...
+...
+"""
+
+[[objects]]
+x = 1
+y = 1
+tile = 64
+fg = "#00FFFF"
+bg = "#000000"
+"##;
+    let mf: MapFile = toml::from_str(toml).unwrap();
+    let board = Board::try_from(mf).unwrap();
+    assert_eq!(board.objects.len(), 1);
+    let obj = &board.objects[&1];
+    assert_eq!(obj.x, 1);
+    assert_eq!(obj.y, 1);
+    assert_eq!(obj.glyph.tile, 64);
+    assert_eq!(obj.glyph.fg, Rgba8 { r: 0x00, g: 0xFF, b: 0xFF, a: 255 });
+    assert_eq!(obj.glyph.bg, Rgba8 { r: 0, g: 0, b: 0, a: 255 });
+
+    // Save back to TOML and reload; glyph must survive.
+    let toml_out = toml::to_string_pretty(&MapFile::from(&board)).unwrap();
+    let mf2: MapFile = toml::from_str(&toml_out).unwrap();
+    let board2 = Board::try_from(mf2).unwrap();
+    let obj2 = &board2.objects[&1];
+    assert_eq!(obj2.glyph.tile, obj.glyph.tile);
+    assert_eq!(obj2.glyph.fg, obj.glyph.fg);
+    assert_eq!(obj2.glyph.bg, obj.glyph.bg);
+}
+
+#[test]
+fn floor_spec_round_trips_through_toml() {
+    // A 2×2 board with a grid floor (a generator and a fixed glyph) must survive
+    // save→load with its `[floor]` declaration intact, and the reloaded board's
+    // computed floor must place the fixed glyph back at its declared cell.
+    let toml = r##"
+[map]
+name = "Test"
+width = 2
+height = 2
+player_start = [0, 0]
+
+[palette]
+"." = { archetype = "empty", tile = 46, fg = "#000000", bg = "#000000" }
+
+[grid]
+content = """
+..
+..
+"""
+
+[floor]
+content = """
+g.
+.g
+"""
+
+[floor.palette]
+"g" = "grass"
+"." = { tile = "#", fg = "#010203", bg = "#040506" }
+"##;
+    let board = load_board(toml);
+    assert!(board.floor_spec.is_some());
+    let fixed = Glyph {
+        tile: '#' as u32,
+        fg: parse_color("#010203"),
+        bg: parse_color("#040506"),
+    };
+    // (1,0) is the fixed `.` floor glyph (the cell archetype is Empty).
+    assert_eq!(board.glyph_at(1, 0), fixed);
+
+    // Save back to TOML and reload; the floor declaration must be preserved.
+    let toml_out = toml::to_string_pretty(&MapFile::from(&board)).unwrap();
+    let board2 = load_board(&toml_out);
+    assert!(board2.floor_spec.is_some());
+    assert_eq!(board2.glyph_at(1, 0), fixed);
+}