Condorra2/blastmud
1
0
Fork 0
forked from blasthavers/blastmud
Code Issues Pull Requests Packages Projects Releases Wiki Activity
36086b809c
blastmud/blastmud_game/src/message_handler/user_commands/look.rs

843 lines
32 KiB
Rust
Raw Blame History

use super::{
get_player_item_or_fail,
map::{render_map, render_map_dyn},
open::{is_door_in_direction, DoorSituation},
search_item_for_user, user_error, UResult, UserError, UserVerb, UserVerbRef, VerbContext,
};
#[double]
use crate::db::DBTrans;
use crate::{
db::{ItemSearchParams, ObjectRef},
language,
models::{
effect::EffectType,
item::{
DoorState, Item, ItemFlag, ItemSpecialData, LiquidDetails, LiquidType,
LocationActionType, Subattack,
},
},
services::{combat::max_health, skills::calc_level_gap},
static_content::{
dynzone,
possession_type::{possession_data, recipe_craft_by_recipe},
room::{self, Direction},
species::species_info_map,
},
};
use ansi::{ansi, flow_around, word_wrap};
use async_trait::async_trait;
use itertools::Itertools;
use mockall_double::double;
use std::collections::BTreeSet;
use std::sync::Arc;
pub async fn describe_normal_item(
player_item: &Item,
ctx: &VerbContext<'_>,
item: &Item,
) -> UResult<()> {
let mut contents_desc = String::new();
let mut items = ctx
.trans
.find_items_by_location(&format!("{}/{}", item.item_type, item.item_code))
.await?;
items.sort_unstable_by(|it1, it2| {
(&it1.action_type)
.cmp(&it2.action_type)
.then((&it1.display).cmp(&it2.display))
});
let all_groups: Vec<Vec<&Arc<Item>>> = items
.iter()
.filter(|it| it.action_type != LocationActionType::Worn)
.group_by(|i| (i.display_for_sentence(1, false), &i.action_type))
.into_iter()
.map(|(_, g)| g.collect::<Vec<&Arc<Item>>>())
.collect::<Vec<Vec<&Arc<Item>>>>();
if all_groups.len() > 0 {
contents_desc.push_str(&(language::caps_first(&item.pronouns.subject)));
if item.item_type == "player" || item.item_type == "npc" {
contents_desc.push_str("'s carrying ");
} else {
contents_desc.push_str(" contains ");
}
let mut phrases = Vec::<String>::new();
for group_items in all_groups {
let head = &group_items[0];
let mut details = head.display_for_sentence(group_items.len(), false);
match head.action_type {
LocationActionType::Wielded => details.push_str(" (wielded)"),
LocationActionType::Worn => continue,
_ => {}
}
phrases.push(details);
}
let phrases_str: Vec<&str> = phrases.iter().map(|p| p.as_str()).collect();
contents_desc.push_str(&(language::join_words(&phrases_str) + ".\n"));
}
if let Some(liq_data) = item
.static_data()
.and_then(|sd| sd.liquid_container_data.as_ref())
{
match item.liquid_details.as_ref() {
Some(LiquidDetails { contents, .. }) if !contents.is_empty() => {
let total_volume: u64 = contents.iter().map(|c| c.1.clone()).sum();
let vol_frac = (total_volume as f64) / (liq_data.capacity as f64);
if vol_frac >= 0.99 {
contents_desc.push_str("It's full to the top with");
} else if vol_frac >= 0.75 {
contents_desc.push_str("It's nearly completely full of");
} else if vol_frac > 0.6 {
contents_desc.push_str("It's more than half full of");
} else if vol_frac > 0.4 {
contents_desc.push_str("It's about half full of");
} else if vol_frac > 0.29 {
contents_desc.push_str("It's about a third full of");
} else if vol_frac > 0.22 {
contents_desc.push_str("It's about a quarter full of");
} else {
contents_desc.push_str("It contains a tiny bit of");
}
contents_desc.push_str(" ");
let mut it = contents.iter();
let f1_opt = it.next();
let f2_opt = it.next();
match (f1_opt, f2_opt) {
(Some((&LiquidType::Water, _)), None) => contents_desc.push_str("water"),
_ => contents_desc.push_str("mixed fluids"),
}
contents_desc.push_str(".\n");
}
_ => contents_desc.push_str("It's completely dry.\n"),
}
}
let anything_worn = items
.iter()
.any(|it| it.action_type == LocationActionType::Worn);
if anything_worn {
let mut any_part_text = false;
let mut seen_clothes: BTreeSet<String> = BTreeSet::new();
for part in species_info_map()
.get(&item.species)
.map(|s| s.body_parts.clone())
.unwrap_or_else(|| vec![])
{
if let Some((top_item, covering_parts)) = items
.iter()
.filter_map(|it| {
if it.action_type != LocationActionType::Worn {
None
} else {
it.possession_type
.as_ref()
.and_then(|pt| possession_data().get(&pt))
.and_then(|pd| pd.wear_data.as_ref())
.and_then(|wd| {
if wd.covers_parts.contains(&part) {
Some((it, wd.covers_parts.clone()))
} else {
None
}
})
}
})
.filter_map(|(it, parts)| it.action_type_started.map(|st| ((it, parts), st)))
.max_by_key(|(_it, st)| st.clone())
.map(|(it, _)| it)
{
any_part_text = true;
let display = top_item.display_for_sentence(1, false);
if !seen_clothes.contains(&display) {
seen_clothes.insert(display.clone());
contents_desc.push_str(&format!(
"On {} {}, you see {}. ",
&item.pronouns.possessive,
&language::join_words(
&covering_parts
.iter()
.map(|p| p.display(None))
.collect::<Vec<&'static str>>()
),
&display
));
}
} else {
any_part_text = true;
contents_desc.push_str(&format!(
"{} {} {} completely bare. ",
&language::caps_first(&item.pronouns.possessive),
part.display(item.sex.clone()),
part.copula(item.sex.clone())
));
}
}
if any_part_text {
contents_desc.push_str("\n");
}
}
let health_max = max_health(&item);
if health_max > 0 {
let health_ratio = (item.health as f64) / (health_max as f64);
if item.item_type == "player" || item.item_type == "npc" {
if health_ratio == 1.0 {
contents_desc.push_str(&format!(
"{} is in perfect health.\n",
&language::caps_first(&item.pronouns.subject)
));
} else if health_ratio >= 0.75 {
contents_desc.push_str(&format!(
"{} has some minor cuts and bruises.\n",
&language::caps_first(&item.pronouns.subject)
));
} else if health_ratio >= 0.5 {
contents_desc.push_str(&format!(
"{} has deep wounds all over {} body.\n",
&language::caps_first(&item.pronouns.subject),
&item.pronouns.possessive
));
} else if health_ratio >= 0.25 {
contents_desc.push_str(&format!(
"{} looks seriously injured.\n",
&language::caps_first(&item.pronouns.subject)
));
} else {
contents_desc.push_str(&format!(
"{} looks like {}'s on death's door.\n",
&language::caps_first(&item.pronouns.subject),
&item.pronouns.possessive
));
}
if item
.active_effects
.iter()
.any(|e| e.0 == EffectType::Bandages)
{
contents_desc.push_str(&format!(
"{} is wrapped up in bandages.\n",
&language::caps_first(&item.pronouns.subject)
));
}
} else if item.item_type == "possession" {
if health_ratio == 1.0 {
contents_desc.push_str(&format!(
"{}'s in perfect condition.\n",
&language::caps_first(&item.pronouns.subject)
));
} else if health_ratio >= 0.75 {
contents_desc.push_str(&format!(
"{}'s slightly beaten up.\n",
&language::caps_first(&item.pronouns.subject)
));
} else if health_ratio >= 0.5 {
contents_desc.push_str(&format!(
"{}'s pretty beaten up.\n",
&language::caps_first(&item.pronouns.subject)
));
} else if health_ratio >= 0.25 {
contents_desc.push_str(&format!(
"{}'s seriously damaged.\n",
&language::caps_first(&item.pronouns.subject)
));
} else {
contents_desc.push_str(&format!(
"{}'s nearly completely destroyed.\n",
&language::caps_first(&item.pronouns.subject)
));
}
}
}
if item.item_type == "possession" {
if let Some(poss_data) = item
.possession_type
.as_ref()
.and_then(|pt| possession_data().get(&pt))
{
if let Some(describer) = poss_data.computed_extra_details {
contents_desc.push_str(
&describer
.describe_for(&ctx.trans, item, player_item)
.await?,
);
}
if let Some(charge_data) = poss_data.charge_data.as_ref() {
let unit = if item.charges == 1 {
charge_data.charge_name_prefix.to_owned() + " " + charge_data.charge_name_suffix
} else {
language::pluralise(charge_data.charge_name_prefix)
+ " "
+ charge_data.charge_name_suffix
};
contents_desc.push_str(&format!("It has {} {} left.\n", item.charges, unit));
}
}
if let Some(recipe_craft_data) = item
.possession_type
.as_ref()
.and_then(|pt| recipe_craft_by_recipe().get(pt))
{
contents_desc.push_str("You will need:\n");
for (input_pt, count) in &recipe_craft_data.craft_data.inputs.iter().counts() {
if let Some(pd) = possession_data().get(&input_pt) {
let thing = pd.display;
contents_desc.push_str(&format!(
" {} {}\n",
count,
&(if count != &1 {
language::pluralise(thing)
} else {
thing.to_owned()
})
));
}
}
match recipe_craft_data.bench.as_ref() {
None => contents_desc.push_str("You can make this without any special bench.\n"),
Some(bench) => {
if let Some(pd) = possession_data().get(bench) {
contents_desc
.push_str(&format!("You'll need to make this on a {}.\n", pd.display))
}
}
}
let diff = calc_level_gap(
&player_item,
&recipe_craft_data.craft_data.skill,
recipe_craft_data.craft_data.difficulty,
);
let challenge_level = if diff > 5.0 {
"You are rather unlikely to succeed in making this."
} else if diff >= 4.0 {
"You're not that likely to succeed in making this, and you're likely to be too confused to learn anything making it."
} else if diff >= 3.0 {
"You've got about a 1/4 chance to succeed at making this, and you might learn something making it."
} else if diff >= 2.0 {
"You've got about a 1/3 chance to succeed at making this, and you might learn something making it."
} else if diff >= 0.0 {
"You've got a less than 50/50 chance to succeed at making this, and you'll probably learn a lot."
} else if diff >= -2.0 {
"You've got a better than 50/50 chance to succeed at making this, and you'll probably learn a lot."
} else if diff >= -3.0 {
"Three out of four times, you'll succeed at making this, and you might still learn something."
} else if diff >= -4.0 {
"Most of the time, you'll succeed at making this, but you'll only rarely learn something new."
} else {
"You're highly likely to succeed at making this, but unlikely to learn anything new."
};
contents_desc.push_str(&format!("{}\n", challenge_level));
}
}
ctx.trans
.queue_for_session(
ctx.session,
Some(&format!(
"{}\n{}\n{}",
&item.display_for_sentence(1, false),
&item.details.as_ref().map(|d| d.as_str()).unwrap_or(""),
contents_desc,
)),
)
.await?;
Ok(())
}
fn exits_for(room: &room::Room) -> String {
let exit_text: Vec<String> = room
.exits
.iter()
.map(|ex| {
format!(
"{}{}",
if ex.exit_climb.is_some() {
ansi!("<red>^")
} else {
ansi!("<yellow>")
},
ex.direction.describe()
)
})
.collect();
format!(
ansi!("<cyan>[ Exits: <bold>{} <reset><cyan>]<reset>"),
exit_text.join(" ")
)
}
fn exits_for_dyn(dynroom: &dynzone::Dynroom) -> String {
let exit_text: Vec<String> = dynroom
.exits
.iter()
.map(|ex| format!(ansi!("<yellow>{}"), ex.direction.describe()))
.collect();
format!(
ansi!("<cyan>[ Exits: <bold>{} <reset><cyan>]<reset>"),
exit_text.join(" ")
)
}
pub async fn is_room_illuminated(
ctx: &VerbContext<'_>,
player_item: &Item,
location: &Item,
room: &room::Room,
) -> UResult<bool> {
let consider_exits: Vec<ObjectRef> = room
.exits
.iter()
.filter_map(|ex| room::resolve_exit(room, ex))
// Do we want to consider skipping exits behind closed doors?
.map(|r| ObjectRef {
item_type: "room".to_owned(),
item_code: r.code.to_owned(),
})
.collect();
Ok(ctx
.trans
.is_illuminated(player_item, location, &consider_exits)
.await?)
}
pub async fn describe_room(
ctx: &VerbContext<'_>,
player_item: &Item,
item: &Item,
room: &room::Room,
contents: &str,
) -> UResult<()> {
let zone = room::zone_details()
.get(room.zone.as_str())
.map(|z| z.display)
.unwrap_or("Outside of time");
let illum = is_room_illuminated(ctx, player_item, item, room).await?;
let desc = flow_around(
&render_map(room, 5, 5),
10,
ansi!("<reset> "),
&word_wrap(
&format!(
ansi!("<yellow>{}<reset> (<blue>{}<reset>)\n{}{}.{}\n{}\n"),
item.display_for_sentence(1, false),
zone,
&item.details.as_ref().map(|d| d.as_str()).unwrap_or(""),
item.details_dyn_suffix
.as_ref()
.map(|d| d.as_str())
.unwrap_or(""),
contents,
exits_for(room)
),
|row| if row >= 5 { 80 } else { 68 },
),
68,
);
ctx.trans
.queue_for_session(
ctx.session,
Some(if illum {
&desc
} else {
"It's too dark to see much.\n"
}),
)
.await?;
Ok(())
}
pub async fn describe_dynroom(
ctx: &VerbContext<'_>,
item: &Item,
dynzone: &dynzone::Dynzone,
dynroom: &dynzone::Dynroom,
contents: &str,
) -> UResult<()> {
ctx.trans
.queue_for_session(
ctx.session,
Some(&flow_around(
&render_map_dyn(dynzone, dynroom, 5, 5),
10,
ansi!("<reset> "),
&word_wrap(
&format!(
ansi!("<yellow>{}<reset> (<blue>{}<reset>)\n{}.{}\n{}\n"),
item.display_for_sentence(1, false),
dynzone.zonename,
&item.details.as_ref().map(|d| d.as_str()).unwrap_or(""),
contents,
exits_for_dyn(dynroom)
),
|row| if row >= 5 { 80 } else { 68 },
),
68,
)),
)
.await?;
Ok(())
}
async fn describe_door(
ctx: &VerbContext<'_>,
room_item: &Item,
state: &DoorState,
direction: &Direction,
) -> UResult<()> {
let mut msg = format!("That exit is blocked by {}.", &state.description);
if let Some(lock) = ctx
.trans
.find_by_action_and_location(
&room_item.refstr(),
&LocationActionType::InstalledOnDoorAsLock((*direction).clone()),
)
.await?
.first()
{
let lock_desc = lock.display_for_sentence(1, false);
msg.push_str(&format!(" The door is locked with {}", &lock_desc));
}
msg.push('\n');
ctx.trans.queue_for_session(ctx.session, Some(&msg)).await?;
Ok(())
}
async fn list_room_contents<'l>(ctx: &'l VerbContext<'_>, item: &'l Item) -> UResult<String> {
if item.flags.contains(&ItemFlag::NoSeeContents) {
return Ok(" It is too foggy to see who or what else is here.".to_owned());
}
let mut buf = String::new();
let mut items = ctx
.trans
.find_items_by_location(&format!("{}/{}", item.item_type, item.item_code))
.await?;
items.sort_unstable_by(|it1, it2| (&it1.display).cmp(&it2.display));
let all_groups: Vec<Vec<&Arc<Item>>> = items
.iter()
.filter(|i| {
i.action_type.is_visible_in_look() && !i.flags.contains(&ItemFlag::DontListInLook)
})
.group_by(|i| i.display_for_sentence(1, false))
.into_iter()
.map(|(_, g)| g.collect::<Vec<&Arc<Item>>>())
.collect::<Vec<Vec<&Arc<Item>>>>();
for group_items in all_groups {
let head = &group_items[0];
let is_creature = head.item_type == "player" || head.item_type.starts_with("npc");
buf.push(' ');
buf.push_str(&head.display_for_sentence(group_items.len(), true));
buf.push_str(if group_items.len() > 1 {
" are "
} else {
" is "
});
match head.action_type {
LocationActionType::Sitting(ref on) => {
buf.push_str("sitting ");
if let Some((on_type, on_code)) =
on.as_ref().and_then(|on_ref| on_ref.split_once("/"))
{
if let Some(sit_on) = ctx.trans.find_item_by_type_code(on_type, on_code).await?
{
buf.push_str("on ");
buf.push_str(&sit_on.display_for_sentence(1, false));
}
}
}
LocationActionType::Reclining(ref on) => {
buf.push_str("reclining ");
if let Some((on_type, on_code)) =
on.as_ref().and_then(|on_ref| on_ref.split_once("/"))
{
if let Some(sit_on) = ctx.trans.find_item_by_type_code(on_type, on_code).await?
{
buf.push_str("on ");
buf.push_str(&sit_on.display_for_sentence(1, false));
}
}
}
LocationActionType::Normal | LocationActionType::Attacking(_) if is_creature => {
if head.death_data.is_some() {
buf.push_str("lying ");
} else {
buf.push_str("standing ");
}
}
_ => {}
}
buf.push_str("here");
if let LocationActionType::Attacking(subattack) = &head.action_type {
match subattack {
Subattack::Powerattacking => buf.push_str(", powerattacking "),
Subattack::Feinting => buf.push_str(", feinting "),
Subattack::Grabbing => buf.push_str(", grabbing "),
Subattack::Wrestling => buf.push_str(", wrestling "),
_ => buf.push_str(", attacking "),
}
match &head
.active_combat
.as_ref()
.and_then(|ac| ac.attacking.clone())
.or_else(|| head.presence_target.clone())
{
None => buf.push_str("someone"),
Some(who) => match who.split_once("/") {
None => buf.push_str("someone"),
Some((ttype, tcode)) => {
match ctx.trans.find_item_by_type_code(ttype, tcode).await? {
None => buf.push_str("someone"),
Some(it) => buf.push_str(&it.display_for_sentence(1, false)),
}
}
},
}
}
buf.push('.');
}
Ok(buf)
}
pub async fn direction_to_item(
trans: &DBTrans,
use_location: &str,
direction: &Direction,
) -> UResult<Option<Arc<Item>>> {
// Firstly check dynamic exits, since they apply to rooms and dynrooms...
if let Some(dynroom_result) = trans.find_exact_dyn_exit(use_location, direction).await? {
return Ok(Some(Arc::new(dynroom_result)));
}
let (heretype, herecode) = use_location
.split_once("/")
.unwrap_or(("room", "repro_xv_chargen"));
if heretype == "dynroom" {
let old_dynroom_item = match trans.find_item_by_type_code(heretype, herecode).await? {
None => user_error("Your current room has vanished!".to_owned())?,
Some(v) => v,
};
let (dynzone_code, dynroom_code) = match old_dynroom_item.special_data.as_ref() {
Some(ItemSpecialData::DynroomData {
dynzone_code,
dynroom_code,
}) => (dynzone_code, dynroom_code),
_ => user_error("Your current room is invalid!".to_owned())?,
};
let dynzone = dynzone::dynzone_by_type()
.get(
&dynzone::DynzoneType::from_str(dynzone_code).ok_or_else(|| {
UserError("The type of your current zone no longer exists".to_owned())
})?,
)
.ok_or_else(|| {
UserError("The type of your current zone no longer exists".to_owned())
})?;
let dynroom = dynzone
.dyn_rooms
.get(dynroom_code.as_str())
.ok_or_else(|| UserError("Your current room type no longer exists".to_owned()))?;
let exit = dynroom
.exits
.iter()
.find(|ex| ex.direction == *direction)
.ok_or_else(|| UserError("There is nothing in that direction".to_owned()))?;
return match exit.target {
dynzone::ExitTarget::ExitZone => {
let (zonetype, zonecode) = old_dynroom_item
.location
.split_once("/")
.ok_or_else(|| UserError("Invalid zone for your room".to_owned()))?;
let zoneitem = trans
.find_item_by_type_code(zonetype, zonecode)
.await?
.ok_or_else(|| UserError("Can't find your zone".to_owned()))?;
let zone_exit = match zoneitem.special_data.as_ref() {
Some(ItemSpecialData::DynzoneData {
zone_exit: None, ..
}) => user_error("That exit doesn't seem to go anywhere".to_owned())?,
Some(ItemSpecialData::DynzoneData {
zone_exit: Some(zone_exit),
..
}) => zone_exit,
_ => user_error(
"The zone you are in has invalid data associated with it".to_owned(),
)?,
};
let (zone_exit_type, zone_exit_code) =
zone_exit.split_once("/").ok_or_else(|| {
UserError("Oops, that way out seems to be broken.".to_owned())
})?;
Ok(trans
.find_item_by_type_code(zone_exit_type, zone_exit_code)
.await?)
}
dynzone::ExitTarget::Intrazone { subcode } => {
let to_item = trans
.find_item_by_location_dynroom_code(&old_dynroom_item.location, &subcode)
.await?
.ok_or_else(|| {
UserError("Can't find the room in that direction.".to_owned())
})?;
Ok(Some(Arc::new(to_item)))
}
};
}
if heretype != "room" {
user_error("Navigating outside rooms not yet supported.".to_owned())?
}
let room = room::room_map_by_code()
.get(herecode)
.ok_or_else(|| UserError("Can't find your current location".to_owned()))?;
let exit = room
.exits
.iter()
.find(|ex| ex.direction == *direction)
.ok_or_else(|| UserError("There is nothing in that direction".to_owned()))?;
let new_room = room::resolve_exit(room, exit)
.ok_or_else(|| UserError("Can't find that room".to_owned()))?;
Ok(trans.find_item_by_type_code("room", &new_room.code).await?)
}
pub struct Verb;
#[async_trait]
impl UserVerb for Verb {
async fn handle(
self: &Self,
ctx: &mut VerbContext,
_verb: &str,
remaining: &str,
) -> UResult<()> {
let player_item = get_player_item_or_fail(ctx).await?;
let mut rem_trim = remaining.trim().to_lowercase();
let rem_orig = rem_trim.clone();
if rem_trim.starts_with("in ") {
rem_trim = rem_trim[3..].trim_start().to_owned();
}
let use_location = if player_item.death_data.is_some() {
"room/repro_xv_respawn"
} else {
&player_item.location
};
let (heretype, herecode) = use_location
.split_once("/")
.unwrap_or(("room", "repro_xv_chargen"));
let item: Arc<Item> = if rem_trim == "" {
ctx.trans
.find_item_by_type_code(heretype, herecode)
.await?
.ok_or_else(|| UserError("Sorry, that no longer exists".to_owned()))?
} else if let Some(dir) =
Direction::parse(&rem_trim).or_else(|| Direction::parse(&rem_orig))
{
// This is complex because "in" is overloaded, and if this fails, we want
// to also consider if they are looking in a container.
match is_door_in_direction(&ctx.trans, &dir, use_location).await {
Ok(DoorSituation::NoDoor)
| Ok(DoorSituation::DoorOutOfRoom {
state: DoorState { open: true, .. },
..
})
| Ok(DoorSituation::DoorIntoRoom {
state: DoorState { open: true, .. },
..
})
| Err(UserError(_)) => {}
Ok(DoorSituation::DoorIntoRoom {
state,
room_with_door,
..
}) => {
if let Some(rev_dir) = dir.reverse() {
return describe_door(ctx, &room_with_door, &state, &rev_dir).await;
}
}
Ok(DoorSituation::DoorOutOfRoom {
state,
room_with_door,
..
}) => {
return describe_door(ctx, &room_with_door, &state, &dir).await;
}
Err(e) => Err(e)?,
}
match direction_to_item(&ctx.trans, use_location, &dir).await {
Ok(Some(item)) => item,
Ok(None) | Err(UserError(_)) => search_item_for_user(
&ctx,
&ItemSearchParams {
include_contents: true,
include_loc_contents: true,
limit: 1,
..ItemSearchParams::base(&player_item, &rem_trim)
},
)
.await
.map_err(|e| match e {
UserError(_) => UserError("There's nothing in that direction".to_owned()),
e => e,
})?,
Err(e) => Err(e)?,
}
} else if rem_trim == "me" || rem_trim == "self" {
player_item.clone()
} else {
search_item_for_user(
&ctx,
&ItemSearchParams {
include_contents: true,
include_loc_contents: true,
limit: 1,
..ItemSearchParams::base(&player_item, &rem_trim)
},
)
.await?
};
if item.item_type == "room" {
let room = room::room_map_by_code()
.get(item.item_code.as_str())
.ok_or_else(|| UserError("Sorry, that room no longer exists".to_owned()))?;
describe_room(
ctx,
&player_item,
&item,
&room,
&list_room_contents(ctx, &item).await?,
)
.await?;
} else if item.item_type == "dynroom" {
let (dynzone, dynroom) = match &item.special_data {
Some(ItemSpecialData::DynroomData {
dynzone_code,
dynroom_code,
}) => dynzone::DynzoneType::from_str(dynzone_code.as_str())
.and_then(|dz_t| dynzone::dynzone_by_type().get(&dz_t))
.and_then(|dz| dz.dyn_rooms.get(dynroom_code.as_str()).map(|dr| (dz, dr)))
.ok_or_else(|| UserError("Dynamic room doesn't exist anymore.".to_owned()))?,
_ => user_error("Expected dynroom to have DynroomData".to_owned())?,
};
describe_dynroom(
ctx,
&item,
&dynzone,
&dynroom,
&list_room_contents(ctx, &item).await?,
)
.await?;
} else {
describe_normal_item(&player_item, ctx, &item).await?;
}
Ok(())
}
}
static VERB_INT: Verb = Verb;
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;
Reference in New Issue View Git Blame Copy Permalink