260 lines
9.6 KiB
Rust
260 lines
9.6 KiB
Rust
use std::fs::{ File, create_dir_all };
|
|
use std::io::{ self, Write };
|
|
use std::time::SystemTime;
|
|
use super::Map;
|
|
use crate::gamelog;
|
|
use crate::components::*;
|
|
use crate::gui::{ Class, Ancestry, unobf_name_ecs };
|
|
use specs::prelude::*;
|
|
use rltk::prelude::*;
|
|
use rltk::to_char;
|
|
use std::collections::HashMap;
|
|
use crate::data::events::*;
|
|
|
|
#[cfg(target_arch = "wasm32")]
|
|
pub fn create_morgue_file(ecs: &World) {
|
|
console::log("wasm32 doesn't support writing files yet, so here's the morgue info:");
|
|
let morgue_info = create_morgue_string(ecs);
|
|
console::log(morgue_info);
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
pub fn create_morgue_file(ecs: &World) {
|
|
let morgue_dir = "morgue";
|
|
if let Err(err) = create_dir_all(&morgue_dir) {
|
|
console::log(format!("Unable to create the directory (/{}): {}", morgue_dir, err));
|
|
}
|
|
let morgue_info = create_morgue_string(ecs);
|
|
let file_name = create_file_name(ecs, morgue_dir);
|
|
if let Err(err) = write_morgue_file(file_name.as_str(), morgue_info.as_str()) {
|
|
console::log(format!("Unable to write the morgue file: {}", err));
|
|
};
|
|
}
|
|
|
|
fn create_file_name(ecs: &World, morgue_dir: &str) -> String {
|
|
let e = ecs.fetch::<Entity>();
|
|
let pools = ecs.read_storage::<Pools>();
|
|
let pool = pools.get(*e).unwrap();
|
|
let class = match ecs.read_storage::<HasClass>().get(*e).unwrap().name {
|
|
Class::Fighter => "fighter",
|
|
Class::Wizard => "wizard",
|
|
Class::Rogue => "rogue",
|
|
Class::Villager => "villager",
|
|
};
|
|
let ancestry = match ecs.read_storage::<HasAncestry>().get(*e).unwrap().name {
|
|
Ancestry::Human => "human",
|
|
Ancestry::Elf => "elf",
|
|
Ancestry::Dwarf => "dwarf",
|
|
Ancestry::Gnome => "gnome",
|
|
Ancestry::Catfolk => "catfolk",
|
|
Ancestry::NULL => "NULL",
|
|
};
|
|
return format!("{}/lv{}-{}-{}-{}.txt", morgue_dir, &pool.level, &ancestry, &class, get_timestamp());
|
|
}
|
|
|
|
fn create_morgue_string(ecs: &World) -> String {
|
|
// Initialise default
|
|
let mut morgue_info: String = Default::default();
|
|
let e = ecs.fetch::<Entity>();
|
|
let class = match ecs.read_storage::<HasClass>().get(*e).unwrap().name {
|
|
Class::Fighter => "fighter",
|
|
Class::Wizard => "wizard",
|
|
Class::Rogue => "rogue",
|
|
Class::Villager => "villager",
|
|
};
|
|
let ancestry = match ecs.read_storage::<HasAncestry>().get(*e).unwrap().name {
|
|
Ancestry::Human => "human",
|
|
Ancestry::Elf => "elf",
|
|
Ancestry::Dwarf => "dwarf",
|
|
Ancestry::Gnome => "gnome",
|
|
Ancestry::Catfolk => "catfolk",
|
|
Ancestry::NULL => "NULL",
|
|
};
|
|
let pools = ecs.read_storage::<Pools>();
|
|
let pool = pools.get(*e).unwrap();
|
|
let header = format!("{} {}, level {}/{}", &ancestry, &class, &pool.level, &pool.xp);
|
|
morgue_info.push_str(&create_boxed_text(header.as_str(), None));
|
|
morgue_info.push_str(&draw_tombstone(ecs, header.len()));
|
|
morgue_info.push_str(&draw_map(ecs));
|
|
morgue_info.push_str("\n");
|
|
morgue_info.push_str(&create_boxed_text("Equipment", None));
|
|
morgue_info.push_str(&draw_equipment(ecs));
|
|
morgue_info.push_str(&create_boxed_text("Backpack", None));
|
|
morgue_info.push_str(&draw_backpack(ecs));
|
|
morgue_info.push_str(&create_boxed_text("Significant Events", None));
|
|
morgue_info.push_str(&draw_events_list());
|
|
|
|
return morgue_info;
|
|
}
|
|
|
|
fn write_morgue_file(file_name: &str, morgue_info: &str) -> Result<(), io::Error> {
|
|
// Save to file
|
|
let mut file = File::create(&file_name)?; // Open/create morgue file
|
|
file.write_all(morgue_info.as_bytes())?;
|
|
Ok(())
|
|
}
|
|
|
|
fn get_timestamp() -> String {
|
|
return SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap().as_secs().to_string();
|
|
}
|
|
|
|
fn create_boxed_text(content: &str, width: Option<usize>) -> String {
|
|
let width = if width.is_some() { width.unwrap() } else { content.len() + 2 };
|
|
let horizontal = format!("{:═^w$}", "", w = width);
|
|
return format!("╔{h}╗\n║ {c} ║\n╚{h}╝\n", h = horizontal, c = content);
|
|
}
|
|
|
|
fn draw_tombstone(ecs: &World, len: usize) -> String {
|
|
let pad = (len - 17) / 2;
|
|
let map = ecs.fetch::<Map>();
|
|
let pools = ecs.read_storage::<Pools>();
|
|
let pool = pools.get(*ecs.fetch::<Entity>()).unwrap();
|
|
let attrs = ecs.read_storage::<Attributes>();
|
|
let attr = attrs.get(*ecs.fetch::<Entity>()).unwrap();
|
|
return format!(
|
|
"{:^p$} .-'~~~`-. HP {}/{} MP {}/{}\n{:^p$} .' `.\n{:^p$} | rest | STR {:>2} ({:+}) CON {:>2} ({:+}) WIS {:>2} ({:+})\n{:^p$} | in | DEX {:>2} ({:+}) INT {:>2} ({:+}) CHA {:>2} ({:+})\n{:^p$} | peace |\n{:^p$}\\\\| |// You died in {} [id {}], after {} turns.\n{:^p$}^^^^^^^^^^^^^^^^^{:^p$}\n",
|
|
"",
|
|
pool.hit_points.current,
|
|
pool.hit_points.max,
|
|
pool.mana.current,
|
|
pool.mana.max,
|
|
"",
|
|
"",
|
|
attr.strength.base + attr.strength.modifiers,
|
|
attr.strength.bonus,
|
|
attr.constitution.base + attr.constitution.modifiers,
|
|
attr.constitution.bonus,
|
|
attr.wisdom.base + attr.wisdom.modifiers,
|
|
attr.wisdom.bonus,
|
|
"",
|
|
attr.dexterity.base + attr.dexterity.modifiers,
|
|
attr.dexterity.bonus,
|
|
attr.intelligence.base + attr.intelligence.modifiers,
|
|
attr.intelligence.bonus,
|
|
attr.charisma.base + attr.charisma.modifiers,
|
|
attr.charisma.bonus,
|
|
"",
|
|
"",
|
|
map.name,
|
|
map.id,
|
|
gamelog::get_event_count(EVENT::COUNT_TURN),
|
|
"",
|
|
"",
|
|
p = pad
|
|
);
|
|
}
|
|
|
|
fn draw_map(ecs: &World) -> String {
|
|
let map = ecs.fetch::<Map>();
|
|
let mut result: String = Default::default();
|
|
let point = ecs.fetch::<Point>();
|
|
for y in 0..map.height {
|
|
for x in 0..map.width {
|
|
let idx = map.xy_idx(x, y);
|
|
let mut glyph_u16: u16 = 0;
|
|
if idx == map.xy_idx(point.x, point.y) {
|
|
glyph_u16 = to_cp437('@');
|
|
} else if crate::spatial::has_tile_content(idx) {
|
|
let mut render_order = 0;
|
|
crate::spatial::for_each_tile_content(idx, |e| {
|
|
if let Some(renderable) = ecs.read_storage::<Renderable>().get(e) {
|
|
if renderable.render_order >= render_order {
|
|
render_order = renderable.render_order;
|
|
glyph_u16 = renderable.glyph;
|
|
}
|
|
}
|
|
});
|
|
} else {
|
|
glyph_u16 = crate::map::themes::get_tile_renderables_for_id(idx, &*map, None).0;
|
|
}
|
|
let char = to_char((glyph_u16 & 0xff) as u8);
|
|
result.push_str(&char.to_string());
|
|
}
|
|
result.push_str("\n");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
fn draw_equipment(ecs: &World) -> String {
|
|
// Get all of the player's equipment.
|
|
let mut equip: HashMap<Entity, i32> = HashMap::new();
|
|
let equipped = ecs.read_storage::<Equipped>();
|
|
for (entity, _e, _n) in (&ecs.entities(), &equipped, &ecs.read_storage::<Name>())
|
|
.join()
|
|
.filter(|item| item.1.owner == *ecs.fetch::<Entity>()) {
|
|
equip
|
|
.entry(entity)
|
|
.and_modify(|count| {
|
|
*count += 1;
|
|
})
|
|
.or_insert(1);
|
|
}
|
|
let mut result: String = Default::default();
|
|
for item in equip {
|
|
let slot = match equipped.get(item.0).unwrap().slot {
|
|
EquipmentSlot::Melee => "l-hand -",
|
|
EquipmentSlot::Shield => "r-hand -",
|
|
EquipmentSlot::Head => "head -",
|
|
EquipmentSlot::Body => "body -",
|
|
EquipmentSlot::Feet => "feet -",
|
|
EquipmentSlot::Hands => "hands -",
|
|
EquipmentSlot::Back => "back -",
|
|
EquipmentSlot::Neck => "neck -",
|
|
};
|
|
let name = if item.1 != 1 { unobf_name_ecs(ecs, item.0).1 } else { unobf_name_ecs(ecs, item.0).0 };
|
|
result.push_str(&format!("{:>8} {}\n", slot, name));
|
|
}
|
|
result.push_str("\n");
|
|
return result;
|
|
}
|
|
|
|
fn draw_backpack(ecs: &World) -> String {
|
|
// Get all of the player's backpack.
|
|
let mut pack: HashMap<(String, String), (i32, Entity)> = HashMap::new();
|
|
for (entity, _bp, _n) in (&ecs.entities(), &ecs.read_storage::<InBackpack>(), &ecs.read_storage::<Name>())
|
|
.join()
|
|
.filter(|item| item.1.owner == *ecs.fetch::<Entity>()) {
|
|
pack.entry(unobf_name_ecs(ecs, entity))
|
|
.and_modify(|(count, _e)| {
|
|
*count += 1;
|
|
})
|
|
.or_insert((1, entity));
|
|
}
|
|
let mut result: String = Default::default();
|
|
for item in pack {
|
|
let name = if item.1.0 != 1 {
|
|
format!("{} {}", item.1.0, item.0.1)
|
|
} else {
|
|
// TODO: Get correct article (a/an/some) here, write a fn for it.
|
|
item.0.0
|
|
};
|
|
result.push_str(&format!("- {}\n", name));
|
|
}
|
|
result.push_str("\n");
|
|
return result;
|
|
}
|
|
|
|
fn draw_events_list() -> String {
|
|
// Initialise default (empty) string
|
|
let mut result: String = Default::default();
|
|
// Get lock on events mutex
|
|
let lock = gamelog::EVENTS.lock().unwrap();
|
|
// Collect all keys, and sort in ascending value (by turn count)
|
|
let mut sorted_keys: Vec<u32> = lock
|
|
.keys()
|
|
.map(|k| *k)
|
|
.collect();
|
|
sorted_keys.sort();
|
|
// Iterate through sorted keys, looking for corresponding values, and append on newline
|
|
for key in sorted_keys {
|
|
if let Some(value) = lock.get(&key) {
|
|
result.push_str(&format!("{:<4} | ", key));
|
|
for event in value.iter() {
|
|
result.push_str(&format!("{}", event));
|
|
}
|
|
result.push_str("\n");
|
|
}
|
|
}
|
|
|
|
return result;
|
|
}
|