239 lines
8.4 KiB
Rust
239 lines
8.4 KiB
Rust
use super::{
|
|
get_player_item_or_fail, parsing::parse_count, search_items_for_user, user_error,
|
|
ItemSearchParams, UResult, UserError, UserVerb, UserVerbRef, VerbContext,
|
|
};
|
|
use crate::{
|
|
models::item::{Buff, BuffCause, BuffImpact, LocationActionType, SkillType},
|
|
regular_tasks::queued_command::{
|
|
queue_command, QueueCommand, QueueCommandHandler, QueuedCommandContext,
|
|
},
|
|
services::{comms::broadcast_to_room, skills::calculate_total_stats_skills_for_user},
|
|
static_content::possession_type::possession_data,
|
|
};
|
|
use async_trait::async_trait;
|
|
use chrono::Utc;
|
|
use std::time;
|
|
|
|
pub struct QueueHandler;
|
|
#[async_trait]
|
|
impl QueueCommandHandler for QueueHandler {
|
|
async fn start_command(&self, ctx: &mut QueuedCommandContext<'_>) -> UResult<time::Duration> {
|
|
if ctx.item.death_data.is_some() {
|
|
user_error(
|
|
"You try to wear it, but your ghostly hands slip through it uselessly".to_owned(),
|
|
)?;
|
|
}
|
|
let item_id = match ctx.command {
|
|
QueueCommand::Wear { possession_id } => possession_id,
|
|
_ => user_error("Unexpected command".to_owned())?,
|
|
};
|
|
let item = match ctx
|
|
.trans
|
|
.find_item_by_type_code("possession", &item_id)
|
|
.await?
|
|
{
|
|
None => user_error("Item not found".to_owned())?,
|
|
Some(it) => it,
|
|
};
|
|
let explicit = ctx.explicit().await?;
|
|
if item.location != ctx.item.refstr() {
|
|
user_error(format!(
|
|
"You try to wear {} but realise you no longer have it",
|
|
item.display_for_sentence(explicit, 1, false)
|
|
))?
|
|
}
|
|
|
|
if item.action_type == LocationActionType::Worn {
|
|
user_error("You realise you're already wearing it!".to_owned())?;
|
|
}
|
|
|
|
let poss_data = item
|
|
.possession_type
|
|
.as_ref()
|
|
.and_then(|pt| possession_data().get(&pt))
|
|
.ok_or_else(|| {
|
|
UserError("That item no longer exists in the game so can't be handled".to_owned())
|
|
})?;
|
|
|
|
poss_data
|
|
.wear_data
|
|
.as_ref()
|
|
.ok_or_else(|| UserError("You can't wear that!".to_owned()))?;
|
|
|
|
let msg = format!(
|
|
"{} fumbles around trying to put on {}\n",
|
|
&ctx.item.display_for_sentence(true, 1, true),
|
|
&item.display_for_sentence(true, 1, false)
|
|
);
|
|
broadcast_to_room(ctx.trans, &ctx.item.location, None, &msg).await?;
|
|
Ok(time::Duration::from_secs(1))
|
|
}
|
|
|
|
#[allow(unreachable_patterns)]
|
|
async fn finish_command(&self, ctx: &mut QueuedCommandContext<'_>) -> UResult<()> {
|
|
if ctx.item.death_data.is_some() {
|
|
user_error(
|
|
"You try to wear it, but your ghostly hands slip through it uselessly".to_owned(),
|
|
)?;
|
|
}
|
|
let item_id = match ctx.command {
|
|
QueueCommand::Wear { possession_id } => possession_id,
|
|
_ => user_error("Unexpected command".to_owned())?,
|
|
};
|
|
let item = match ctx
|
|
.trans
|
|
.find_item_by_type_code("possession", &item_id)
|
|
.await?
|
|
{
|
|
None => user_error("Item not found".to_owned())?,
|
|
Some(it) => it,
|
|
};
|
|
let explicit = ctx.explicit().await?;
|
|
if item.location != ctx.item.refstr() {
|
|
user_error(format!(
|
|
"You try to wear {} but realise it is no longer there.",
|
|
&item.display_for_sentence(explicit, 1, false)
|
|
))?
|
|
}
|
|
|
|
if item.action_type == LocationActionType::Worn {
|
|
user_error("You realise you're already wearing it!".to_owned())?;
|
|
}
|
|
|
|
let poss_data = item
|
|
.possession_type
|
|
.as_ref()
|
|
.and_then(|pt| possession_data().get(&pt))
|
|
.ok_or_else(|| {
|
|
UserError("That item no longer exists in the game so can't be handled".to_owned())
|
|
})?;
|
|
|
|
let wear_data = poss_data
|
|
.wear_data
|
|
.as_ref()
|
|
.ok_or_else(|| UserError("You can't wear that!".to_owned()))?;
|
|
|
|
let other_clothes = ctx
|
|
.trans
|
|
.find_by_action_and_location(&ctx.item.refstr(), &LocationActionType::Worn)
|
|
.await?;
|
|
for part in &wear_data.covers_parts {
|
|
let thickness: f64 =
|
|
other_clothes
|
|
.iter()
|
|
.fold(wear_data.thickness, |tot, other_item| {
|
|
match other_item
|
|
.possession_type
|
|
.as_ref()
|
|
.and_then(|pt| possession_data().get(&pt))
|
|
.and_then(|pd| pd.wear_data.as_ref())
|
|
{
|
|
Some(wd) if wd.covers_parts.contains(&part) => tot + wd.thickness,
|
|
_ => tot,
|
|
}
|
|
});
|
|
if thickness > 12.0 {
|
|
user_error(format!(
|
|
"You're wearing too much on your {} already.",
|
|
part.display(ctx.item.sex.clone())
|
|
))?;
|
|
}
|
|
}
|
|
|
|
let msg = format!(
|
|
"{} wears {}\n",
|
|
&ctx.item.display_for_sentence(true, 1, true),
|
|
&item.display_for_sentence(true, 1, false)
|
|
);
|
|
broadcast_to_room(ctx.trans, &ctx.item.location, None, &msg).await?;
|
|
let mut item_mut = (*item).clone();
|
|
item_mut.action_type = LocationActionType::Worn;
|
|
item_mut.action_type_started = Some(Utc::now());
|
|
|
|
if wear_data.dodge_penalty != 0.0 {
|
|
ctx.item.temporary_buffs.push(Buff {
|
|
description: "Dodge penalty".to_owned(),
|
|
cause: BuffCause::ByItem {
|
|
item_type: item_mut.item_type.clone(),
|
|
item_code: item_mut.item_code.clone(),
|
|
},
|
|
impacts: vec![BuffImpact::ChangeSkill {
|
|
skill: SkillType::Dodge,
|
|
magnitude: -wear_data.dodge_penalty,
|
|
}],
|
|
});
|
|
if ctx.item.item_type == "player" {
|
|
if let Some(usr) = ctx.trans.find_by_username(&ctx.item.item_code).await? {
|
|
calculate_total_stats_skills_for_user(ctx.item, &usr);
|
|
}
|
|
}
|
|
}
|
|
|
|
ctx.trans.save_item_model(&item_mut).await?;
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
pub struct Verb;
|
|
#[async_trait]
|
|
impl UserVerb for Verb {
|
|
async fn handle(
|
|
self: &Self,
|
|
ctx: &mut VerbContext,
|
|
_verb: &str,
|
|
mut remaining: &str,
|
|
) -> UResult<()> {
|
|
let player_item = get_player_item_or_fail(ctx).await?;
|
|
let mut get_limit = Some(1);
|
|
if remaining == "all" || remaining.starts_with("all ") {
|
|
remaining = remaining[3..].trim();
|
|
get_limit = None;
|
|
} else if let (Some(n), remaining2) = parse_count(remaining) {
|
|
get_limit = Some(n);
|
|
remaining = remaining2;
|
|
}
|
|
let targets = search_items_for_user(
|
|
ctx,
|
|
&ItemSearchParams {
|
|
include_contents: true,
|
|
item_type_only: Some("possession"),
|
|
limit: get_limit.unwrap_or(100),
|
|
item_action_type_only: Some(&LocationActionType::Normal),
|
|
..ItemSearchParams::base(&player_item, &remaining)
|
|
},
|
|
)
|
|
.await?;
|
|
if player_item.death_data.is_some() {
|
|
user_error("The dead don't dress themselves".to_owned())?;
|
|
}
|
|
|
|
let mut did_anything: bool = false;
|
|
let mut player_item_mut = (*player_item).clone();
|
|
for target in targets
|
|
.iter()
|
|
.filter(|t| t.action_type.is_visible_in_look())
|
|
{
|
|
if target.item_type != "possession" {
|
|
user_error("You can't wear that!".to_owned())?;
|
|
}
|
|
did_anything = true;
|
|
queue_command(
|
|
ctx,
|
|
&mut player_item_mut,
|
|
&QueueCommand::Wear {
|
|
possession_id: target.item_code.clone(),
|
|
},
|
|
)
|
|
.await?;
|
|
}
|
|
if !did_anything {
|
|
user_error("I didn't find anything matching.".to_owned())?;
|
|
} else {
|
|
ctx.trans.save_item_model(&player_item_mut).await?;
|
|
}
|
|
Ok(())
|
|
}
|
|
}
|
|
static VERB_INT: Verb = Verb;
|
|
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;
|