From f38a80b0c7f21a41c1e5baa5821cb7647dc6ea95 Mon Sep 17 00:00:00 2001
From: Alex Page <alex@anpage.me>
Date: Thu, 3 Feb 2022 20:16:06 -0500
Subject: [PATCH] Implement deserializing non-random levels

---
 src/main.rs          |  2 +-
 src/resources/map.rs | 91 ++++++++++++++++++++++++++------------------
 src/tile_data.rs     | 58 ++++++++++++++++++++++++++++
 3 files changed, 114 insertions(+), 37 deletions(-)

diff --git a/src/main.rs b/src/main.rs
index 7504bf0..6a847bd 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -32,7 +32,7 @@ fn main() -> BError {
 
     let mut world = World::new();
 
-    let mut map = Map::from_level(levels::get_level(starting_level));
+    let mut map = Map::from(levels::get_level(starting_level));
     map.spawn_entities(&mut world);
 
     let resources = Resources {
diff --git a/src/resources/map.rs b/src/resources/map.rs
index 76ad3b2..bef1dc5 100644
--- a/src/resources/map.rs
+++ b/src/resources/map.rs
@@ -44,42 +44,6 @@ impl Map {
         }
     }
 
-    pub fn from_level(level: Level) -> Self {
-        match level {
-            Level::Normal(_data) => todo!(),
-            Level::Randomized(data) => {
-                let mut rng = RandomNumberGenerator::new();
-                let mut map = Self::new();
-                for (tile, count) in data {
-                    for _ in 0..count {
-                        loop {
-                            let point = Point {
-                                x: rng.range(0, MAP_WIDTH as i32),
-                                y: rng.range(0, MAP_HEIGHT as i32),
-                            };
-                            if map.get_tile_at(point) == TileType::Floor {
-                                map.set_tile_at(point, tile);
-                                break;
-                            }
-                        }
-                    }
-                }
-                loop {
-                    let point = Point {
-                        x: rng.range(0, MAP_WIDTH as i32),
-                        y: rng.range(0, MAP_HEIGHT as i32),
-                    };
-                    if map.get_tile_at(point) == TileType::Floor {
-                        map.set_tile_at(point, TileType::Player);
-                        break;
-                    }
-                }
-                map
-            }
-            Level::End => todo!(),
-        }
-    }
-
     pub fn spawn_entities(&mut self, world: &mut World) {
         for (index, tile) in self
             .tiles
@@ -246,3 +210,58 @@ impl Map {
         self.tiles[index] = tile;
     }
 }
+
+impl From<Level> for Map {
+    fn from(level: Level) -> Self {
+        match level {
+            Level::Normal(data) => {
+                assert_eq!(data.len(), MAP_HEIGHT, "Level data is incorrect height!");
+
+                let mut map = Self::new();
+                for (y, line) in data.iter().enumerate() {
+                    assert_eq!(line.len(), MAP_WIDTH, "Level data is incorrect width!");
+                    for (x, c) in line.chars().enumerate() {
+                        map.set_tile_at(
+                            Point {
+                                x: x as i32,
+                                y: y as i32,
+                            },
+                            TileType::from(c),
+                        );
+                    }
+                }
+                map
+            }
+            Level::Randomized(data) => {
+                let mut rng = RandomNumberGenerator::new();
+                let mut map = Self::new();
+                for (tile, count) in data {
+                    for _ in 0..count {
+                        loop {
+                            let point = Point {
+                                x: rng.range(0, MAP_WIDTH as i32),
+                                y: rng.range(0, MAP_HEIGHT as i32),
+                            };
+                            if map.get_tile_at(point) == TileType::Floor {
+                                map.set_tile_at(point, tile);
+                                break;
+                            }
+                        }
+                    }
+                }
+                loop {
+                    let point = Point {
+                        x: rng.range(0, MAP_WIDTH as i32),
+                        y: rng.range(0, MAP_HEIGHT as i32),
+                    };
+                    if map.get_tile_at(point) == TileType::Floor {
+                        map.set_tile_at(point, TileType::Player);
+                        break;
+                    }
+                }
+                map
+            }
+            Level::End => todo!(),
+        }
+    }
+}
diff --git a/src/tile_data.rs b/src/tile_data.rs
index 775889b..a6bc744 100644
--- a/src/tile_data.rs
+++ b/src/tile_data.rs
@@ -375,3 +375,61 @@ pub fn tile_data(tile: TileType) -> TileData {
         },
     }
 }
+
+impl From<char> for TileType {
+    fn from(c: char) -> Self {
+        match c {
+            ' ' => TileType::Floor,
+            '1' => TileType::Slow,
+            '2' => TileType::Medium,
+            '3' => TileType::Fast,
+            'X' => TileType::Block,
+            'W' => TileType::Whip,
+            'L' => TileType::Stairs,
+            'C' => TileType::Chest,
+            'S' => TileType::SlowTime,
+            '+' => TileType::Gem,
+            'I' => TileType::Invisible,
+            'T' => TileType::Teleport,
+            'K' => TileType::Key,
+            'D' => TileType::Door,
+            '#' => TileType::Wall,
+            'F' => TileType::SpeedTime,
+            '.' => TileType::Trap,
+            'R' => TileType::River,
+            'Q' => TileType::Power,
+            '/' => TileType::Forest,
+            '\\' => TileType::Tree,
+            'B' => TileType::Bomb,
+            'V' => TileType::Lava,
+            '=' => TileType::Pit,
+            'A' => TileType::Tome,
+            'U' => TileType::Tunnel,
+            'Z' => TileType::Freeze,
+            '*' => TileType::Nugget,
+            'E' => TileType::Quake,
+            ';' => TileType::InvisibleBlock,
+            ':' => TileType::InvisibleWall,
+            '`' => TileType::InvisibleDoor,
+            '-' => TileType::Stop,
+            '%' => TileType::Zap,
+            ']' => TileType::Create,
+            'G' => TileType::Generator,
+            '@' => TileType::Trap2,
+            ')' => TileType::Trap3,
+            '(' => TileType::Trap4,
+            '$' => TileType::Trap5,
+            'α' => TileType::Trap6,
+            'ß' => TileType::Trap7,
+            'Γ' => TileType::Trap8,
+            'π' => TileType::Trap9,
+            'Σ' => TileType::Trap10,
+            'σ' => TileType::Trap11,
+            'µ' => TileType::Trap12,
+            'τ' => TileType::Trap13,
+            'P' => TileType::Player,
+            '!' => TileType::Punctuation,
+            _ => TileType::Letter(c),
+        }
+    }
+}