Load maps from TOML files with XPM-style palette

Introduces a map file format: TOML with a [palette] mapping characters
to (Glyph, Element) definitions and a [grid] multi-line string. Board
now owns the player position, objects, and portals. map_file::load()
deserializes a file and converts it to a Board via From<MapFile>.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

src/game.rs

@@ -1,8 +1,7 @@
 use eframe::egui::Color32;
+use serde::Deserialize;
 
-pub const BOARD_W: usize = 60;
-pub const BOARD_H: usize = 25;
-
+#[derive(Clone, Copy)]
 pub struct Glyph {
     pub ch: char,
     pub fg: Color32,
@@ -10,14 +9,6 @@ pub struct Glyph {
 }
 
 impl Glyph {
-    pub fn floor() -> Self {
-        Self { ch: ' ', fg: Color32::BLACK, bg: Color32::BLACK }
-    }
-
-    pub fn wall() -> Self {
-        Self { ch: '#', fg: Color32::GRAY, bg: Color32::DARK_GRAY }
-    }
-
     pub fn player() -> Self {
         Self { ch: '@', fg: Color32::LIGHT_BLUE, bg: Color32::BLACK }
     }
@@ -27,14 +18,41 @@ pub struct Element {
     pub passable: bool,
 }
 
+#[derive(Deserialize)]
+#[allow(dead_code)]
+pub struct ObjectDef {
+    pub x: usize,
+    pub y: usize,
+    pub script: String,
+}
+
+#[derive(Deserialize)]
+#[allow(dead_code)]
+pub struct PortalDef {
+    pub x: usize,
+    pub y: usize,
+    pub target_map: String,
+    pub target_entry: String,
+}
+
+pub struct Player {
+    pub x: i32,
+    pub y: i32,
+}
+
+#[allow(dead_code)]
 pub struct Board {
     pub width: usize,
     pub height: usize,
     pub elements: Vec<Element>,
-    cells: Vec<(Glyph, usize)>,
+    pub(crate) cells: Vec<(Glyph, usize)>,
+    pub player: Player,
+    pub objects: Vec<ObjectDef>,
+    pub portals: Vec<PortalDef>,
 }
 
 impl Board {
+    #[allow(dead_code)]
     pub fn add_element(&mut self, element: Element) -> usize {
         let idx = self.elements.len();
         self.elements.push(element);
@@ -45,6 +63,7 @@ impl Board {
         &self.cells[y * self.width + x]
     }
 
+    #[allow(dead_code)]
     pub fn get_mut(&mut self, x: usize, y: usize) -> &mut (Glyph, usize) {
         &mut self.cells[y * self.width + x]
     }
@@ -55,59 +74,24 @@ impl Board {
     }
 }
 
-pub struct Player {
-    pub x: i32,
-    pub y: i32,
-}
-
 pub struct GameState {
     pub board: Board,
-    pub player: Player,
 }
 
 impl GameState {
-    pub fn new() -> Self {
-        let w = BOARD_W;
-        let h = BOARD_H;
-
-        let mut board = Board {
-            width: w,
-            height: h,
-            elements: Vec::new(),
-            cells: Vec::new(),
-        };
-
-        let floor = board.add_element(Element { passable: true });
-        let wall  = board.add_element(Element { passable: false });
-
-        board.cells = (0..w * h)
-            .map(|_| (Glyph::floor(), floor))
-            .collect();
-
-        for x in 0..w {
-            *board.get_mut(x, 0)     = (Glyph::wall(), wall);
-            *board.get_mut(x, h - 1) = (Glyph::wall(), wall);
-        }
-        for y in 0..h {
-            *board.get_mut(0, y)     = (Glyph::wall(), wall);
-            *board.get_mut(w - 1, y) = (Glyph::wall(), wall);
-        }
-
-        Self {
-            board,
-            player: Player { x: 30, y: 12 },
-        }
+    pub fn new(board: Board) -> Self {
+        Self { board }
     }
 
     pub fn try_move(&mut self, dx: i32, dy: i32) {
-        let nx = self.player.x + dx;
-        let ny = self.player.y + dy;
+        let nx = self.board.player.x + dx;
+        let ny = self.board.player.y + dy;
         if nx >= 0 && ny >= 0 {
             let nx = nx as usize;
             let ny = ny as usize;
             if nx < self.board.width && ny < self.board.height && self.board.is_passable(nx, ny) {
-                self.player.x = nx as i32;
-                self.player.y = ny as i32;
+                self.board.player.x = nx as i32;
+                self.board.player.y = ny as i32;
             }
         }
     }

src/main.rs

@@ -2,7 +2,8 @@ use eframe::egui;
 use egui::{Align2, FontId, Key, Pos2, Rect, vec2};
 
 mod game;
-use game::{GameState, Glyph, BOARD_W, BOARD_H};
+mod map_file;
+use game::{GameState, Glyph};
 
 const CELL_W: f32 = 14.0;
 const CELL_H: f32 = 20.0;
@@ -11,8 +12,10 @@ const MENU_H: f32 = 24.0;
 const PANEL_MARGIN: f32 = 8.0;
 
 fn main() -> eframe::Result<()> {
-    let board_px_w = BOARD_W as f32 * CELL_W + 2.0 * PANEL_MARGIN;
-    let board_px_h = BOARD_H as f32 * CELL_H + MENU_H + 2.0 * PANEL_MARGIN;
+    let board = map_file::load("maps/start.toml").expect("failed to load maps/start.toml");
+    let board_px_w = board.width as f32 * CELL_W + 2.0 * PANEL_MARGIN;
+    let board_px_h = board.height as f32 * CELL_H + MENU_H + 2.0 * PANEL_MARGIN;
+
     let options = eframe::NativeOptions {
         viewport: egui::ViewportBuilder::default()
             .with_inner_size([board_px_w, board_px_h])
@@ -22,7 +25,7 @@ fn main() -> eframe::Result<()> {
     eframe::run_native(
         "Viberogue",
         options,
-        Box::new(|_cc| Ok(Box::new(App::new()))),
+        Box::new(move |_cc| Ok(Box::new(App::new(board)))),
     )
 }
 
@@ -31,8 +34,8 @@ struct App {
 }
 
 impl App {
-    fn new() -> Self {
-        Self { state: GameState::new() }
+    fn new(board: game::Board) -> Self {
+        Self { state: GameState::new(board) }
     }
 }
 
@@ -74,8 +77,8 @@ impl eframe::App for App {
             draw_glyph(
                 painter,
                 origin,
-                self.state.player.x as usize,
-                self.state.player.y as usize,
+                self.state.board.player.x as usize,
+                self.state.board.player.y as usize,
                 &player_glyph,
             );
         });

src/map_file.rs

@@ -0,0 +1,97 @@
+use std::collections::HashMap;
+use serde::Deserialize;
+use eframe::egui::Color32;
+use crate::game::{Board, Element, Glyph, ObjectDef, Player, PortalDef};
+
+#[derive(Deserialize)]
+pub struct MapFile {
+    pub map: MapHeader,
+    pub palette: HashMap<String, PaletteEntry>,
+    pub grid: GridData,
+    #[serde(default)]
+    pub objects: Vec<ObjectDef>,
+    #[serde(default)]
+    pub portals: Vec<PortalDef>,
+}
+
+#[derive(Deserialize)]
+pub struct MapHeader {
+    #[allow(dead_code)]
+    pub name: String,
+    pub width: usize,
+    pub height: usize,
+    pub player_start: [i32; 2],
+}
+
+#[derive(Deserialize)]
+pub struct PaletteEntry {
+    pub passable: bool,
+    pub ch: char,
+    pub fg: String,
+    pub bg: String,
+}
+
+#[derive(Deserialize)]
+pub struct GridData {
+    pub content: String,
+}
+
+fn parse_color(hex: &str) -> Color32 {
+    let hex = hex.trim_start_matches('#');
+    if hex.len() != 6 {
+        return Color32::BLACK;
+    }
+    let r = u8::from_str_radix(&hex[0..2], 16).unwrap_or(0);
+    let g = u8::from_str_radix(&hex[2..4], 16).unwrap_or(0);
+    let b = u8::from_str_radix(&hex[4..6], 16).unwrap_or(0);
+    Color32::from_rgb(r, g, b)
+}
+
+impl From<MapFile> for Board {
+    fn from(mf: MapFile) -> Self {
+        let w = mf.map.width;
+        let h = mf.map.height;
+
+        let mut elements: Vec<Element> = Vec::new();
+        let mut palette: HashMap<char, (Glyph, usize)> = HashMap::new();
+
+        for (key, entry) in &mf.palette {
+            let key_char = key.chars().next().unwrap_or(' ');
+            let idx = elements.len();
+            elements.push(Element { passable: entry.passable });
+            palette.insert(key_char, (Glyph {
+                ch: entry.ch,
+                fg: parse_color(&entry.fg),
+                bg: parse_color(&entry.bg),
+            }, idx));
+        }
+
+        let mut cells: Vec<(Glyph, usize)> = Vec::with_capacity(w * h);
+        for line in mf.grid.content.lines() {
+            for ch in line.chars() {
+                if let Some(&(glyph, idx)) = palette.get(&ch) {
+                    cells.push((glyph, idx));
+                }
+            }
+        }
+
+        Board {
+            width: w,
+            height: h,
+            elements,
+            cells,
+            player: Player {
+                x: mf.map.player_start[0],
+                y: mf.map.player_start[1],
+            },
+            objects: mf.objects,
+            portals: mf.portals,
+        }
+    }
+}
+
+pub fn load(path: &str) -> Result<Board, Box<dyn std::error::Error>> {
+    let content = std::fs::read_to_string(path)?;
+    let map_file: MapFile = toml::from_str(&content)?;
+    Ok(Board::from(map_file))
+}