split stuff up into multiple files

master
rascul 3 years ago
parent 32c2f1fcef
commit e688da14ae

@ -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()
}
}

@ -1,153 +1,55 @@
use std::collections::{BTreeMap, HashMap}; mod environment;
mod mudlet;
mod tintin;
use std::collections::BTreeMap;
use std::error::Error; use std::error::Error;
use std::io; use std::io;
use std::io::Read; use std::io::Read;
use serde_derive::Deserialize;
use serde_json::Value; 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>> { 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 areas = match mudlet_map.get("areas") {
Some(areas) => match areas.as_array() {
Some(areas) => areas,
None => panic!("Areas not an array"),
},
None => panic!("No areas found"),
};
for area in areas {
let id: i64 = match area.get("id") {
Some(id) => match id.as_i64() {
Some(id) => id,
None => continue,
},
None => continue,
};
if id < 0 {
continue;
}
let mudlet_area: mudlet::Area = serde_json::from_value(area.to_owned())?;
let mut tintin_rooms: BTreeMap<i64, TinTinRoom> = BTreeMap::new(); // hold the tintin version of the rooms
let mut tintin_rooms: BTreeMap<i64, tintin::Room> = BTreeMap::new();
for mudlet_room in mudlet_map.rooms { for mudlet_room in mudlet_area.rooms {
let mut tintin_exits: Vec<TinTinExit> = Vec::new(); // hold the tintin version of room exits
let mut tintin_exits: Vec<tintin::Exit> = Vec::new();
for mudlet_exit in mudlet_room.exits { for mudlet_exit in mudlet_room.exits {
// map the exit direction
let (dir_num, dir_short) = match mudlet_exit.name.as_str() { let (dir_num, dir_short) = match mudlet_exit.name.as_str() {
"north" => (1, 'n'), "north" => (1, 'n'),
"east" => (2, 'e'), "east" => (2, 'e'),
@ -158,7 +60,8 @@ fn main() -> Result<(), Box<dyn Error>> {
_ => panic!("Unknown exit: {}", mudlet_exit.name), _ => panic!("Unknown exit: {}", mudlet_exit.name),
}; };
let tintin_exit = TinTinExit { // create a tintin exit from the mudlet exit
let tintin_exit = tintin::Exit {
vnum: mudlet_exit.exitId, vnum: mudlet_exit.exitId,
name: dir_short.into(), name: dir_short.into(),
cmd: dir_short.into(), cmd: dir_short.into(),
@ -170,17 +73,25 @@ fn main() -> Result<(), Box<dyn Error>> {
decay: 0.0, decay: 0.0,
}; };
// add tintin exit to list of tintin exits for the room
tintin_exits.push(tintin_exit); tintin_exits.push(tintin_exit);
} }
let tintin_room = TinTinRoom { let userdata = match mudlet_room.userData {
Some(userdata) => userdata,
None => continue,
};
let environment = Environment::from(mudlet_room.environment);
let tintin_room = tintin::Room {
vnum: mudlet_room.id, vnum: mudlet_room.id,
flags: 0, flags: 0,
color: String::new(), color: environment.color(),
name: mudlet_room.name, name: mudlet_room.name,
symbol: ' ', symbol: environment.symbol(),
desc: mudlet_room.userData.description.replace("\n", " ").replace (" ", " "), desc: userdata.description.replace("\n", " ").replace(" ", " "),
area: mudlet_room.userData.zone, area: userdata.zone,
note: String::new(), note: String::new(),
terrain: String::new(), terrain: String::new(),
data: String::new(), data: String::new(),
@ -196,12 +107,23 @@ fn main() -> Result<(), Box<dyn Error>> {
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); 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 { 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!(
"E {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}} {{{}}}",
exit.vnum,
exit.name,
exit.cmd,
exit.dir,
exit.flags,
exit.data,
exit.weight,
exit.color,
exit.decay
);
} }
println!(); println!();
} }
}
Ok(()) Ok(())
} }

@ -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>,
}

@ -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>,
}

@ -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;

@ -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>,
}

@ -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>,
}

@ -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,
}

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

@ -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>,
}
Loading…
Cancel
Save