forked from blasthavers/blastmud
821 lines
31 KiB
Rust
821 lines
31 KiB
Rust
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,
|
|
language,
|
|
models::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, SpeciesType},
|
|
},
|
|
};
|
|
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(true, 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(
|
|
!ctx.session_dat.less_explicit_mode,
|
|
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_session(&ctx.session_dat);
|
|
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 {
|
|
if !ctx.session_dat.less_explicit_mode {
|
|
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");
|
|
}
|
|
} else if (item.item_type == "npc" || item.item_type == "player")
|
|
&& item.species == SpeciesType::Human
|
|
&& !ctx.session_dat.less_explicit_mode
|
|
{
|
|
contents_desc.push_str(&format!(
|
|
"{} is completely naked.\n",
|
|
&language::caps_first(&item.pronouns.subject)
|
|
));
|
|
}
|
|
|
|
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 ctx
|
|
.trans
|
|
.check_task_by_type_code(
|
|
"DelayedHealth",
|
|
&format!("{}/{}/bandage", &item.item_type, &item.item_code),
|
|
)
|
|
.await?
|
|
{
|
|
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(charge_data) = item
|
|
.possession_type
|
|
.as_ref()
|
|
.and_then(|pt| possession_data().get(&pt))
|
|
.and_then(|pd| pd.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 = if ctx.session_dat.less_explicit_mode {
|
|
pd.display_less_explicit.unwrap_or(pd.display)
|
|
} else {
|
|
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",
|
|
if ctx.session_dat.less_explicit_mode {
|
|
pd.display_less_explicit.unwrap_or(pd.display)
|
|
} else {
|
|
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_session(&ctx.session_dat),
|
|
item.details_for_session(&ctx.session_dat).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 describe_room(
|
|
ctx: &VerbContext<'_>,
|
|
item: &Item,
|
|
room: &room::Room,
|
|
contents: &str,
|
|
) -> UResult<()> {
|
|
let zone = room::zone_details()
|
|
.get(room.zone)
|
|
.map(|z| z.display)
|
|
.unwrap_or("Outside of time");
|
|
ctx.trans
|
|
.queue_for_session(
|
|
ctx.session,
|
|
Some(&flow_around(
|
|
&render_map(room, 5, 5),
|
|
10,
|
|
ansi!("<reset> "),
|
|
&word_wrap(
|
|
&format!(
|
|
ansi!("<yellow>{}<reset> (<blue>{}<reset>)\n{}.{}\n{}\n"),
|
|
item.display_for_session(&ctx.session_dat),
|
|
zone,
|
|
item.details_for_session(&ctx.session_dat).unwrap_or(""),
|
|
contents,
|
|
exits_for(room)
|
|
),
|
|
|row| if row >= 5 { 80 } else { 68 },
|
|
),
|
|
68,
|
|
)),
|
|
)
|
|
.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_session(&ctx.session_dat),
|
|
dynzone.zonename,
|
|
item.details_for_session(&ctx.session_dat).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_session(&ctx.session_dat);
|
|
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())
|
|
.group_by(|i| i.display_for_sentence(true, 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(
|
|
!ctx.session_dat.less_explicit_mode,
|
|
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_session(&ctx.session_dat));
|
|
}
|
|
}
|
|
}
|
|
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_session(&ctx.session_dat));
|
|
}
|
|
}
|
|
}
|
|
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_session(&ctx.session_dat)),
|
|
}
|
|
}
|
|
},
|
|
}
|
|
}
|
|
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, &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;
|