2022-01-19 14:47:58 -05:00
|
|
|
mod item_use_system;
|
|
|
|
|
2021-12-24 10:38:44 -05:00
|
|
|
use ::specs::prelude::*;
|
2022-01-19 14:47:58 -05:00
|
|
|
pub use item_use_system::ItemUseSystem;
|
2021-11-03 15:11:19 -04:00
|
|
|
|
2021-12-10 20:16:48 -05:00
|
|
|
use crate::components::*;
|
|
|
|
use crate::game_log::GameLog;
|
2022-01-19 14:47:58 -05:00
|
|
|
use crate::{raws, MasterDungeonMap};
|
2021-12-10 20:16:48 -05:00
|
|
|
|
2022-01-19 14:35:13 -05:00
|
|
|
fn obfuscate_name(
|
|
|
|
item: Entity,
|
|
|
|
names: &ReadStorage<Name>,
|
|
|
|
magic_items: &ReadStorage<MagicItem>,
|
|
|
|
obfuscated_names: &ReadStorage<ObfuscatedName>,
|
|
|
|
dm: &MasterDungeonMap,
|
|
|
|
) -> String {
|
|
|
|
if let Some(name) = names.get(item) {
|
|
|
|
if magic_items.get(item).is_some() {
|
|
|
|
if dm.identified_items.contains(&name.name) {
|
|
|
|
name.name.clone()
|
|
|
|
} else if let Some(obfuscated) = obfuscated_names.get(item) {
|
|
|
|
obfuscated.name.clone()
|
|
|
|
} else {
|
|
|
|
"Unidentified magic item".to_string()
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
name.name.clone()
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
"Nameless item (bug)".to_string()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-11-03 15:11:19 -04:00
|
|
|
pub struct ItemCollectionSystem {}
|
|
|
|
|
|
|
|
impl<'a> System<'a> for ItemCollectionSystem {
|
|
|
|
#[allow(clippy::type_complexity)]
|
|
|
|
type SystemData = (
|
|
|
|
ReadExpect<'a, Entity>,
|
|
|
|
WriteExpect<'a, GameLog>,
|
|
|
|
WriteStorage<'a, WantsToPickupItem>,
|
|
|
|
WriteStorage<'a, Position>,
|
|
|
|
ReadStorage<'a, Name>,
|
|
|
|
WriteStorage<'a, InBackpack>,
|
2022-01-13 10:14:13 -05:00
|
|
|
WriteStorage<'a, EquipmentChanged>,
|
2022-01-19 14:35:13 -05:00
|
|
|
ReadStorage<'a, MagicItem>,
|
|
|
|
ReadStorage<'a, ObfuscatedName>,
|
|
|
|
ReadExpect<'a, MasterDungeonMap>,
|
2021-11-03 15:11:19 -04:00
|
|
|
);
|
|
|
|
|
|
|
|
fn run(&mut self, data: Self::SystemData) {
|
2022-01-13 10:14:13 -05:00
|
|
|
let (
|
|
|
|
player_entity,
|
|
|
|
mut gamelog,
|
|
|
|
mut wants_pickup,
|
|
|
|
mut positions,
|
|
|
|
names,
|
|
|
|
mut backpack,
|
|
|
|
mut dirty,
|
2022-01-19 14:35:13 -05:00
|
|
|
magic_items,
|
|
|
|
obfuscated_names,
|
|
|
|
dm,
|
2022-01-13 10:14:13 -05:00
|
|
|
) = data;
|
2021-11-03 15:11:19 -04:00
|
|
|
|
|
|
|
for pickup in wants_pickup.join() {
|
|
|
|
positions.remove(pickup.item);
|
|
|
|
backpack
|
|
|
|
.insert(
|
|
|
|
pickup.item,
|
|
|
|
InBackpack {
|
|
|
|
owner: pickup.collected_by,
|
|
|
|
},
|
|
|
|
)
|
|
|
|
.expect("Failed to add item to backpack");
|
2022-01-13 10:14:13 -05:00
|
|
|
dirty
|
|
|
|
.insert(pickup.collected_by, EquipmentChanged {})
|
|
|
|
.expect("Unable to insert equipment change");
|
2021-11-03 15:11:19 -04:00
|
|
|
|
|
|
|
if pickup.collected_by == *player_entity {
|
2021-11-19 11:30:25 -05:00
|
|
|
gamelog.append(format!(
|
2021-11-03 15:11:19 -04:00
|
|
|
"You pick up the {}.",
|
2022-01-19 14:35:13 -05:00
|
|
|
obfuscate_name(pickup.item, &names, &magic_items, &obfuscated_names, &dm)
|
2021-11-03 15:11:19 -04:00
|
|
|
));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
wants_pickup.clear();
|
|
|
|
}
|
|
|
|
}
|
2021-11-03 15:59:23 -04:00
|
|
|
|
2021-11-04 09:40:58 -04:00
|
|
|
pub struct ItemDropSystem {}
|
|
|
|
|
|
|
|
impl<'a> System<'a> for ItemDropSystem {
|
2021-11-15 13:55:31 -05:00
|
|
|
#[allow(clippy::type_complexity)]
|
2021-11-04 09:40:58 -04:00
|
|
|
type SystemData = (
|
|
|
|
ReadExpect<'a, Entity>,
|
|
|
|
WriteExpect<'a, GameLog>,
|
|
|
|
Entities<'a>,
|
|
|
|
WriteStorage<'a, WantsToDropItem>,
|
|
|
|
ReadStorage<'a, Name>,
|
|
|
|
WriteStorage<'a, Position>,
|
|
|
|
WriteStorage<'a, InBackpack>,
|
2022-01-13 10:14:13 -05:00
|
|
|
WriteStorage<'a, EquipmentChanged>,
|
2022-01-19 14:35:13 -05:00
|
|
|
ReadStorage<'a, MagicItem>,
|
|
|
|
ReadStorage<'a, ObfuscatedName>,
|
|
|
|
ReadExpect<'a, MasterDungeonMap>,
|
2021-11-04 09:40:58 -04:00
|
|
|
);
|
|
|
|
|
|
|
|
fn run(&mut self, data: Self::SystemData) {
|
|
|
|
let (
|
|
|
|
player_entity,
|
|
|
|
mut gamelog,
|
|
|
|
entities,
|
|
|
|
mut wants_drop,
|
|
|
|
names,
|
|
|
|
mut positions,
|
|
|
|
mut backpack,
|
2022-01-13 10:14:13 -05:00
|
|
|
mut dirty,
|
2022-01-19 14:35:13 -05:00
|
|
|
magic_items,
|
|
|
|
obfuscated_names,
|
|
|
|
dm,
|
2021-11-04 09:40:58 -04:00
|
|
|
) = data;
|
|
|
|
|
|
|
|
for (entity, to_drop) in (&entities, &wants_drop).join() {
|
|
|
|
let mut dropper_pos: Position = Position { x: 0, y: 0 };
|
|
|
|
{
|
|
|
|
let dropped_pos = positions.get(entity).unwrap();
|
|
|
|
dropper_pos.x = dropped_pos.x;
|
|
|
|
dropper_pos.y = dropped_pos.y;
|
|
|
|
}
|
|
|
|
|
|
|
|
positions
|
|
|
|
.insert(
|
|
|
|
to_drop.item,
|
|
|
|
Position {
|
|
|
|
x: dropper_pos.x,
|
|
|
|
y: dropper_pos.y,
|
|
|
|
},
|
|
|
|
)
|
|
|
|
.expect("Unable to drop item to position");
|
|
|
|
|
|
|
|
backpack.remove(to_drop.item);
|
|
|
|
|
2022-01-13 10:14:13 -05:00
|
|
|
dirty
|
|
|
|
.insert(entity, EquipmentChanged {})
|
|
|
|
.expect("Unable to insert equipment change");
|
|
|
|
|
2021-11-04 09:40:58 -04:00
|
|
|
if entity == *player_entity {
|
2021-11-19 11:30:25 -05:00
|
|
|
gamelog.append(format!(
|
2021-11-04 09:40:58 -04:00
|
|
|
"You drop the {}.",
|
2022-01-19 14:35:13 -05:00
|
|
|
obfuscate_name(to_drop.item, &names, &magic_items, &obfuscated_names, &dm)
|
2021-11-04 09:40:58 -04:00
|
|
|
));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
wants_drop.clear();
|
|
|
|
}
|
|
|
|
}
|
2021-11-15 11:32:09 -05:00
|
|
|
|
|
|
|
pub struct ItemRemoveSystem {}
|
|
|
|
|
|
|
|
impl<'a> System<'a> for ItemRemoveSystem {
|
2021-11-15 13:55:31 -05:00
|
|
|
#[allow(clippy::type_complexity)]
|
2021-11-15 11:32:09 -05:00
|
|
|
type SystemData = (
|
|
|
|
Entities<'a>,
|
|
|
|
WriteStorage<'a, WantsToRemoveItem>,
|
|
|
|
WriteStorage<'a, Equipped>,
|
2021-11-15 13:27:40 -05:00
|
|
|
WriteStorage<'a, InBackpack>,
|
2021-11-15 11:32:09 -05:00
|
|
|
);
|
|
|
|
|
|
|
|
fn run(&mut self, data: Self::SystemData) {
|
|
|
|
let (entities, mut wants_remove, mut equipped, mut backpack) = data;
|
|
|
|
|
|
|
|
for (entity, to_remove) in (&entities, &wants_remove).join() {
|
|
|
|
equipped.remove(to_remove.item);
|
2021-11-15 13:27:40 -05:00
|
|
|
backpack
|
|
|
|
.insert(to_remove.item, InBackpack { owner: entity })
|
2021-11-15 11:32:09 -05:00
|
|
|
.expect("Unable to remove item and put in backpack");
|
|
|
|
}
|
|
|
|
|
|
|
|
wants_remove.clear();
|
|
|
|
}
|
|
|
|
}
|
2022-01-19 11:04:10 -05:00
|
|
|
|
|
|
|
pub struct ItemIdentificationSystem {}
|
|
|
|
|
|
|
|
impl<'a> System<'a> for ItemIdentificationSystem {
|
|
|
|
#[allow(clippy::type_complexity)]
|
|
|
|
type SystemData = (
|
|
|
|
ReadStorage<'a, Player>,
|
|
|
|
WriteStorage<'a, IdentifiedItem>,
|
|
|
|
WriteExpect<'a, MasterDungeonMap>,
|
|
|
|
ReadStorage<'a, Item>,
|
|
|
|
ReadStorage<'a, Name>,
|
|
|
|
WriteStorage<'a, ObfuscatedName>,
|
|
|
|
Entities<'a>,
|
|
|
|
);
|
|
|
|
|
|
|
|
fn run(&mut self, data: Self::SystemData) {
|
|
|
|
let (player, mut identified, mut dm, items, names, mut obfuscated_names, entities) = data;
|
|
|
|
|
|
|
|
for (_p, id) in (&player, &identified).join() {
|
|
|
|
if !dm.identified_items.contains(&id.name) && raws::is_tag_magic(&id.name) {
|
|
|
|
dm.identified_items.insert(id.name.clone());
|
|
|
|
|
|
|
|
for (entity, _item, name) in (&entities, &items, &names).join() {
|
|
|
|
if name.name == id.name {
|
|
|
|
obfuscated_names.remove(entity);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Clean up
|
|
|
|
identified.clear();
|
|
|
|
}
|
|
|
|
}
|