split stuff up into multiple files

src/environment.rs

@@ -0,0 +1,126 @@
+//! Room environment
+
+use serde_derive::Deserialize;
+
+/// Type of environment for the room
+#[derive(Debug, Deserialize)]
+pub enum Environment {
+    /// Inside a building
+    Inside,
+
+    /// Out in the wild
+    Wilderness,
+
+    /// On a road
+    Road,
+
+    /// Horse load
+    Horse,
+
+    /// In a swamp
+    Swamp,
+
+    /// In the water
+    Water,
+
+    /// A drinking source
+    Drink,
+
+    /// Weapon shop
+    Weaponsmith,
+
+    /// Armor shop
+    Armorer,
+
+    /// Master blacksmith
+    Blacksmith,
+
+    /// Bank
+    Bank,
+
+    /// Stables
+    Stables,
+
+    /// Place to rent
+    Rent,
+
+    /// Grocer
+    Grocer,
+
+    /// Warrior practice
+    Warrior,
+
+    /// Rogue practice
+    Rogue,
+
+    /// Hunter practice
+    Hunter,
+
+    /// Possible PK objective
+    Pk,
+
+    /// Other
+    Other,
+}
+
+impl From<i64> for Environment {
+    fn from(num: i64) -> Self {
+        match num {
+            20 => Self::Inside,
+            21 => Self::Wilderness,
+            22 => Self::Road,
+            23 => Self::Horse,
+            24 => Self::Swamp,
+            25 => Self::Water,
+            26 => Self::Drink,
+            27 => Self::Weaponsmith,
+            28 => Self::Armorer,
+            29 => Self::Blacksmith,
+            30 => Self::Bank,
+            31 => Self::Stables,
+            32 => Self::Rent,
+            33 => Self::Grocer,
+            34 => Self::Warrior,
+            35 => Self::Rogue,
+            36 => Self::Hunter,
+            37 => Self::Pk,
+            _ => Self::Other,
+        }
+    }
+}
+
+impl Environment {
+    /// Some room environments have a symbol to put in the room on the map
+    pub fn symbol(&self) -> String {
+        match self {
+            Self::Horse => "<bba>H",
+            Self::Drink => "<abf>D",
+            Self::Weaponsmith => "<eac>W",
+            Self::Armorer => "<eac>A",
+            Self::Blacksmith => "<cbf>B",
+            Self::Bank => "<afa>$",
+            Self::Stables => "<bba>S",
+            Self::Rent => "<efd>R",
+            Self::Grocer => "<eac>G",
+            Self::Warrior => "<fdc>W",
+            Self::Rogue => "<fdc>R",
+            Self::Hunter => "<fdc>H",
+            Self::Pk => "<ffd>P",
+            _ => "",
+        }
+        .to_string()
+    }
+
+    /// Color of the room
+    pub fn color(&self) -> String {
+        match self {
+            Self::Inside => "<g12>",
+            Self::Wilderness => "<bca>",
+            Self::Road => "<cba>",
+            Self::Swamp => "<adb>",
+            Self::Water => "<abf>",
+            _ => "",
+        }
+        .to_string()
+    }
+}

src/main.rs

@@ -1,207 +1,129 @@
-use std::collections::{BTreeMap, HashMap};
+mod environment;
+mod mudlet;
+mod tintin;
+
+use std::collections::BTreeMap;
 use std::error::Error;
 use std::io;
 use std::io::Read;
 
-use serde_derive::Deserialize;
 use serde_json::Value;
 
-#[derive(Debug, Deserialize)]
+use environment::Environment;
-struct MudletMap {
-	/// area id
-	id: i64,
-
-	/// area name
-	name: String,
-
-	/// rooms
-	rooms: Vec<MudletRoom>,
-
-	#[serde(flatten)]
-	_extra: HashMap<String, Value>,
-}
-
-#[derive(Debug, Deserialize)]
-struct MudletRoom {
-	/// exits
-	exits: Vec<MudletExit>,
-
-	/// room number
-	id: i64,
-
-	/// room name
-	name: String,
-
-	/// user data
-	userData: MudletUserData,
-
-	#[serde(flatten)]
-	_extra: HashMap<String, Value>,
-}
-
-#[derive(Debug, Deserialize)]
-struct MudletExit {
-	/// connected room
-	exitId: i64,
-
-	/// direction
-	name: String,
-
-	#[serde(flatten)]
-	_extra: HashMap<String, Value>,
-}
-
-#[derive(Debug, Deserialize)]
-struct MudletUserData {
-	/// room description
-	description: String,
-
-	/// zone name
-	zone: String,
-
-	#[serde(flatten)]
-	_extra: HashMap<String, Value>,
-}
-
-#[derive(Debug)]
-struct TinTinRoom {
-	/// room number
-	vnum: i64,
-
-	/// flags
-	flags: i64,
-
-	/// color
-	color: String,
-
-	/// room name
-	name: String,
-
-	/// room symbol
-	symbol: char,
-
-	/// room description
-	desc: String,
-
-	/// area that room is in
-	area: String,
-
-	/// notes
-	note: String,
-
-	/// type of terrain
-	terrain: String,
-
-	/// extra data
-	data: String,
-
-	/// movement cost
-	weight: f64,
-
-	/// room id
-	id: String,
-
-	/// exits
-	exits: Vec<TinTinExit>,
-}
-
-#[derive(Debug)]
-struct TinTinExit {
-	/// vnum
-	vnum: i64,
-
-	/// exit name
-	name: String,
-
-	/// command to use the exit
-	cmd: String,
-
-	/// exit direction
-	dir: i8,
-
-	/// exit flags
-	flags: i64,
-
-	/// extra data
-	data: String,
-
-	/// movement cost?
-	weight: f64,
-
-	/// exit color
-	color: String,
-
-	/// decay?
-	decay: f64,
-}
 
 fn main() -> Result<(), Box<dyn Error>> {
-	let mut buffer = String::new();
+    let mut buffer = String::new();
-	let mut stdin = io::stdin();
+    let mut stdin = io::stdin();
-	stdin.read_to_string(&mut buffer)?;
+    stdin.read_to_string(&mut buffer)?;
-	
+
-	let mudlet_map: MudletMap = serde_json::from_str(&buffer)?;
+    let mudlet_map: Value = serde_json::from_str(&buffer)?;
-
+
-	let mut tintin_rooms: BTreeMap<i64, TinTinRoom> = BTreeMap::new();
+    let areas = match mudlet_map.get("areas") {
-
+        Some(areas) => match areas.as_array() {
-	for mudlet_room in mudlet_map.rooms {
+            Some(areas) => areas,
-		let mut tintin_exits: Vec<TinTinExit> = Vec::new();
+            None => panic!("Areas not an array"),
-
+        },
-		for mudlet_exit in mudlet_room.exits {
+        None => panic!("No areas found"),
-			let (dir_num, dir_short) = match mudlet_exit.name.as_str() {
+    };
-				"north" => (1, 'n'),
+
-				"east" => (2, 'e'),
+    for area in areas {
-				"south" => (4, 's'),
+        let id: i64 = match area.get("id") {
-				"west" => (8, 'w'),
+            Some(id) => match id.as_i64() {
-				"up" => (16, 'u'),
+                Some(id) => id,
-				"down" => (32, 'd'),
+                None => continue,
-				_ => panic!("Unknown exit: {}", mudlet_exit.name),
+            },
-			};
+            None => continue,
-
+        };
-			let tintin_exit = TinTinExit {
+
-				vnum: mudlet_exit.exitId,
+        if id < 0 {
-				name: dir_short.into(),
+            continue;
-				cmd: dir_short.into(),
+        }
-				dir: dir_num,
+
-				flags: 0,
+        let mudlet_area: mudlet::Area = serde_json::from_value(area.to_owned())?;
-				data: String::new(),
+
-				weight: 1.0,
+        // hold the tintin version of the rooms
-				color: String::new(),
+        let mut tintin_rooms: BTreeMap<i64, tintin::Room> = BTreeMap::new();
-				decay: 0.0,
+
-			};
+        for mudlet_room in mudlet_area.rooms {
-
+            // hold the tintin version of room exits
-			tintin_exits.push(tintin_exit);
+            let mut tintin_exits: Vec<tintin::Exit> = Vec::new();
-		}
+
-
+            for mudlet_exit in mudlet_room.exits {
-		let tintin_room = TinTinRoom {
+                // map the exit direction
-			vnum: mudlet_room.id,
+                let (dir_num, dir_short) = match mudlet_exit.name.as_str() {
-			flags: 0,
+                    "north" => (1, 'n'),
-			color: String::new(),
+                    "east" => (2, 'e'),
-			name: mudlet_room.name,
+                    "south" => (4, 's'),
-			symbol: ' ',
+                    "west" => (8, 'w'),
-			desc: mudlet_room.userData.description.replace("\n", " ").replace ("  ", " "),
+                    "up" => (16, 'u'),
-			area: mudlet_room.userData.zone,
+                    "down" => (32, 'd'),
-			note: String::new(),
+                    _ => panic!("Unknown exit: {}", mudlet_exit.name),
-			terrain: String::new(),
+                };
-			data: String::new(),
+
-			weight: 1.0,
+                // create a tintin exit from the mudlet exit
-			id: String::new(),
+                let tintin_exit = tintin::Exit {
-			exits: tintin_exits,
+                    vnum: mudlet_exit.exitId,
-		};
+                    name: dir_short.into(),
-
+                    cmd: dir_short.into(),
-		tintin_rooms.insert(tintin_room.vnum, tintin_room);
+                    dir: dir_num,
-	}
+                    flags: 0,
-
+                    data: String::new(),
-	for (vnum, room) in tintin_rooms {
+                    weight: 1.0,
-		println!("R {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}}", vnum, room.flags, room.color, room.name, room.symbol, room.desc, room.area, room.note, room.terrain, room.data, room.weight, room.id);
+                    color: String::new(),
-		
+                    decay: 0.0,
-		for exit in room.exits {
+                };
-			println!("E {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}}", exit.vnum, exit.name, exit.cmd, exit.dir, exit.flags, exit.data, exit.weight, exit.color, exit.decay);
+
-		}
+                // add tintin exit to list of tintin exits for the room
-
+                tintin_exits.push(tintin_exit);
-		println!();
+            }
-	}
+
-
+            let userdata = match mudlet_room.userData {
-	Ok(())
+                Some(userdata) => userdata,
-
+                None => continue,
+            };
+
+            let environment = Environment::from(mudlet_room.environment);
+
+            let tintin_room = tintin::Room {
+                vnum: mudlet_room.id,
+                flags: 0,
+                color: environment.color(),
+                name: mudlet_room.name,
+                symbol: environment.symbol(),
+                desc: userdata.description.replace("\n", " ").replace("  ", " "),
+                area: userdata.zone,
+                note: String::new(),
+                terrain: String::new(),
+                data: String::new(),
+                weight: 1.0,
+                id: String::new(),
+                exits: tintin_exits,
+            };
+
+            tintin_rooms.insert(tintin_room.vnum, tintin_room);
+        }
+
+        for (vnum, room) in tintin_rooms {
+            println!("R {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}}", vnum, room.flags, room.color, room.name, room.symbol, room.desc, room.area, room.note, room.terrain, room.data, room.weight, room.id);
+
+            for exit in room.exits {
+                println!(
+                    "E {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}}",
+                    exit.vnum,
+                    exit.name,
+                    exit.cmd,
+                    exit.dir,
+                    exit.flags,
+                    exit.data,
+                    exit.weight,
+                    exit.color,
+                    exit.decay
+                );
+            }
+
+            println!();
+        }
+    }
+
+    Ok(())
 }

src/mudlet/area.rs

@@ -0,0 +1,21 @@
+use std::collections::HashMap;
+
+use serde_derive::Deserialize;
+use serde_json::Value;
+
+use crate::mudlet;
+
+#[derive(Debug, Deserialize)]
+pub struct Area {
+    /// area id
+    //id: i64,
+
+    /// area name
+    //name: String,
+
+    /// rooms
+    pub rooms: Vec<mudlet::Room>,
+
+    #[serde(flatten)]
+    _extra: HashMap<String, Value>,
+}

src/mudlet/exit.rs

@@ -0,0 +1,16 @@
+use std::collections::HashMap;
+
+use serde_derive::Deserialize;
+use serde_json::Value;
+
+#[derive(Debug, Deserialize)]
+pub struct Exit {
+    /// connected room
+    pub exitId: i64,
+
+    /// direction
+    pub name: String,
+
+    #[serde(flatten)]
+    _extra: HashMap<String, Value>,
+}

src/mudlet/mod.rs

@@ -0,0 +1,9 @@
+mod area;
+mod exit;
+mod room;
+mod userdata;
+
+pub use area::Area;
+pub use exit::Exit;
+pub use room::Room;
+pub use userdata::UserData;

src/mudlet/room.rs

@@ -0,0 +1,22 @@
+use serde_derive::Deserialize;
+
+use crate::mudlet;
+
+#[derive(Debug, Deserialize)]
+pub struct Room {
+    /// environment
+    pub environment: i64,
+
+    /// exits
+    pub exits: Vec<mudlet::Exit>,
+
+    /// room number
+    pub id: i64,
+
+    /// room name
+    #[serde(default)]
+    pub name: String,
+
+    /// user data
+    pub userData: Option<mudlet::UserData>,
+}

src/mudlet/userdata.rs

@@ -0,0 +1,17 @@
+use std::collections::HashMap;
+
+use serde_derive::Deserialize;
+use serde_json::Value;
+
+#[derive(Debug, Deserialize)]
+pub struct UserData {
+    /// room description
+    pub description: String,
+
+    /// zone name
+    #[serde(default)]
+    pub zone: String,
+
+    #[serde(flatten)]
+    _extra: HashMap<String, Value>,
+}

src/tintin/exit.rs

@@ -0,0 +1,29 @@
+#[derive(Debug)]
+pub struct Exit {
+    /// vnum
+    pub vnum: i64,
+
+    /// exit name
+    pub name: String,
+
+    /// command to use the exit
+    pub cmd: String,
+
+    /// exit direction
+    pub dir: i8,
+
+    /// exit flags
+    pub flags: i64,
+
+    /// extra data
+    pub data: String,
+
+    /// movement cost?
+    pub weight: f64,
+
+    /// exit color
+    pub color: String,
+
+    /// decay?
+    pub decay: f64,
+}

src/tintin/mod.rs

@@ -0,0 +1,5 @@
+mod exit;
+mod room;
+
+pub use exit::Exit;
+pub use room::Room;

src/tintin/room.rs

@@ -0,0 +1,43 @@
+use crate::tintin;
+
+#[derive(Debug)]
+pub struct Room {
+    /// room number
+    pub vnum: i64,
+
+    /// flags
+    pub flags: i64,
+
+    /// color
+    pub color: String,
+
+    /// room name
+    pub name: String,
+
+    /// room symbol
+    pub symbol: String,
+
+    /// room description
+    pub desc: String,
+
+    /// area that room is in
+    pub area: String,
+
+    /// notes
+    pub note: String,
+
+    /// type of terrain
+    pub terrain: String,
+
+    /// extra data
+    pub data: String,
+
+    /// movement cost
+    pub weight: f64,
+
+    /// room id
+    pub id: String,
+
+    /// exits
+    pub exits: Vec<tintin::Exit>,
+}