365 lines
18 KiB
Rust
365 lines
18 KiB
Rust
use super::{VerbContext, UserVerb, UserVerbRef, UResult, UserError, user_error,
|
|
get_player_item_or_fail, search_item_for_user};
|
|
use async_trait::async_trait;
|
|
use ansi::{ansi, flow_around, word_wrap};
|
|
use crate::{
|
|
db::ItemSearchParams,
|
|
models::{item::{
|
|
Item, LocationActionType, Subattack, ItemFlag, ItemSpecialData
|
|
}},
|
|
static_content::{
|
|
room::{self, Direction},
|
|
dynzone::self,
|
|
possession_type::possession_data,
|
|
},
|
|
language,
|
|
services::combat::max_health,
|
|
};
|
|
use super::map::{render_map, render_map_dyn};
|
|
use itertools::Itertools;
|
|
use std::sync::Arc;
|
|
use mockall_double::double;
|
|
#[double] use crate::db::DBTrans;
|
|
|
|
|
|
pub async fn describe_normal_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.display).cmp(&it2.display));
|
|
|
|
let all_groups: Vec<Vec<&Arc<Item>>> = items
|
|
.iter()
|
|
.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);
|
|
if head.action_type == LocationActionType::Wielded {
|
|
details.push_str(" (wielded)");
|
|
}
|
|
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"));
|
|
}
|
|
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));
|
|
}
|
|
}
|
|
|
|
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!(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 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()
|
|
.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 => buf.push_str("sitting "),
|
|
LocationActionType::Reclining => buf.push_str("reclining "),
|
|
LocationActionType::Normal | LocationActionType::Attacking(_) if is_creature => {
|
|
if head.is_dead {
|
|
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 rem_trim = remaining.trim().to_lowercase();
|
|
let use_location = if player_item.is_dead { "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) {
|
|
direction_to_item(&ctx.trans, use_location, &dir).await?
|
|
.ok_or_else(|| UserError("There's nothing in that direction".to_owned()))?
|
|
} 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(ctx, &item).await?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
static VERB_INT: Verb = Verb;
|
|
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;
|