dungeon: bsp generate should return a floor to use same single rng

- `Floor::new` is now `Floor::from_parts` and takes in and rng
- updated bps tests to operate on a floor
- removed pos < MAP_SIZE checks, since `Pos` gurentees this
- bsp::generate now returns a floor

1 files changed, 31 insertions, 34 deletions

diff --git a/dungeon/tests/bsp_tests.rs b/dungeon/tests/bsp_tests.rs
index 0a494b8..09d2d3a 100644
--- a/dungeon/tests/bsp_tests.rs
+++ b/dungeon/tests/bsp_tests.rs
@@ -17,11 +17,9 @@ mod tests {
 	fn test_bsp_integration() {
 		let test_seeds = generate_test_seeds(123456);
 		for seed in test_seeds {
-			let (tiles, player_start) = bsp::generate(seed);
+			let floor = bsp::generate(seed);
 			// Basic integration test: ensure we get valid data
-			assert!(!tiles.is_empty());
-			assert!(player_start.x() < map::MAP_SIZE);
-			assert!(player_start.y() < map::MAP_SIZE);
+			assert!(!floor.tiles().is_empty());
 		}
 	}
 
@@ -30,13 +28,10 @@ mod tests {
 	fn test_bsp_player_start() {
 		let test_seeds = generate_test_seeds(654321);
 		for seed in test_seeds {
-			let (tiles, player_start) = bsp::generate(seed);
-			// Ensure player start is within bounds
-			assert!(player_start.x() < map::MAP_SIZE);
-			assert!(player_start.y() < map::MAP_SIZE);
+			let floor = bsp::generate(seed);
 			// Ensure player start is a room tile
-			let idx = player_start.idx();
-			assert_eq!(tiles[idx], map::Tile::Room);
+			let start = floor.player_start();
+			assert_eq!(floor.get(start), map::Tile::Room);
 		}
 	}
 
@@ -45,9 +40,10 @@ mod tests {
 	fn test_bsp_2_or_more_rooms() {
 		let test_seeds = generate_test_seeds(111222);
 		for seed in test_seeds {
-			let (tiles, _player_start) = bsp::generate(seed);
+			let floor = bsp::generate(seed);
 			// Ensure we have at least one room tile
-			let room_count = tiles
+			let room_count = floor
+				.tiles()
 				.iter()
 				.filter(|&&tile| tile == map::Tile::Room)
 				.count();
@@ -63,19 +59,15 @@ mod tests {
 	fn test_bsp_walls_on_borders() {
 		let test_seeds = generate_test_seeds(777888);
 		for seed in test_seeds {
-			let (tiles, _player_start) = bsp::generate(seed);
+			let floor = bsp::generate(seed);
 			// Go through all tiles, and ensure border tiles are walls
-			for x in 0..map::MAP_SIZE {
-				for y in 0..map::MAP_SIZE {
-					let pos = Pos::new(x, y).unwrap_or(const_pos!(1, 1));
-					if pos.is_border() {
-						let idx = pos.idx();
-						assert_eq!(
-							tiles[idx],
-							map::Tile::Wall,
-							"Expected wall at border position {pos:?}"
-						);
-					}
+			for pos in Pos::values() {
+				if pos.is_border() {
+					assert_eq!(
+						floor.get(pos),
+						map::Tile::Wall,
+						"Expected wall at border position {pos:?}"
+					);
 				}
 			}
 		}
@@ -86,11 +78,16 @@ mod tests {
 	fn test_bsp_reproducibility() {
 		let test_seeds = generate_test_seeds(111111);
 		for seed in test_seeds {
-			let (tiles1, player_start1) = bsp::generate(seed);
-			let (tiles2, player_start2) = bsp::generate(seed);
-			assert_eq!(tiles1, tiles2, "Tiles differ for same seed {seed}");
+			let floor1 = bsp::generate(seed);
+			let floor2 = bsp::generate(seed);
 			assert_eq!(
-				player_start1, player_start2,
+				floor1.tiles(),
+				floor2.tiles(),
+				"Tiles differ for same seed {seed}"
+			);
+			assert_eq!(
+				floor1.player_start(),
+				floor2.player_start(),
 				"Player starts differ for same seed {seed}"
 			);
 		}
@@ -107,22 +104,22 @@ mod tests {
 
 	// Helper function to check that all air tiles are reachable from player start
 	fn check_air_tiles_reachable(seed: u64) {
-		let (tiles, player_start) = bsp::generate(seed);
+		let floor = bsp::generate(seed);
 
 		// BFS to find all reachable air tiles
-		let mut visited = vec![false; tiles.len()];
-		let mut queue = vec![player_start];
-		visited[player_start.idx()] = true;
+		let mut visited = vec![false; TILE_COUNT];
+		let mut queue = vec![floor.player_start()];
+		visited[floor.player_start().idx()] = true;
 		while let Some(pos) = queue.pop() {
 			for neighbor in pos.neighbors() {
 				let idx = neighbor.idx();
-				if !visited[idx] && tiles[idx] != map::Tile::Wall {
+				if !visited[idx] && floor.get(neighbor) != map::Tile::Wall {
 					visited[idx] = true;
 					queue.push(neighbor);
 				}
 			}
 		}
-		for (i, &tile) in tiles.iter().enumerate() {
+		for (i, &tile) in floor.tiles().iter().enumerate() {
 			if tile == map::Tile::Room || tile == map::Tile::Hallway {
 				assert!(visited[i], "Unreachable air tile at index {i}");
 			}