blastmud/blastmud_game/src/message_handler/user_commands/get.rs

use super::{
    VerbContext,
    UserVerb,
    UserVerbRef,
    UResult,
    ItemSearchParams,
    user_error,
    get_player_item_or_fail,
    search_items_for_user,
    parsing::parse_count
};
use crate::{
    static_content::possession_type::possession_data,
    regular_tasks::queued_command::{
        QueueCommandHandler,
        QueueCommand,
        queue_command
    },
    services::{
        comms::broadcast_to_room,
        capacity::{
            check_item_capacity,
            CapacityLevel,
        }
    },
    models::item::LocationActionType,
};
use async_trait::async_trait;
use std::time;

pub struct QueueHandler;
#[async_trait]
impl QueueCommandHandler for QueueHandler {
    async fn start_command(&self, ctx: &mut VerbContext<'_>, command: &QueueCommand)
                           -> UResult<time::Duration> {
        let player_item = get_player_item_or_fail(ctx).await?;
        if player_item.is_dead {
            user_error("You try to get it, but your ghostly hands slip through it uselessly".to_owned())?;
        }
        let item_id = match command {
            QueueCommand::Get { 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
        };
        if item.location != player_item.location {
            user_error(
                format!("You try to get {} but realise it is no longer there",
                        item.display_for_sentence(!ctx.session_dat.less_explicit_mode, 1, false)
                )
            )?
        }
        let msg_exp = format!("{} fumbles around trying to pick up {}\n",
                              &player_item.display_for_sentence(true, 1, true),
                              &item.display_for_sentence(true, 1, false));
        let msg_nonexp = format!("{} fumbles around trying to pick up {}\n",
                                 &player_item.display_for_sentence(false, 1, true),
                                 &item.display_for_sentence(false, 1, false));
        broadcast_to_room(ctx.trans, &player_item.location, None, &msg_exp, Some(&msg_nonexp)).await?;
        Ok(time::Duration::from_secs(1))
    }

    #[allow(unreachable_patterns)]
    async fn finish_command(&self, ctx: &mut VerbContext<'_>, command: &QueueCommand)
                            -> UResult<()> {
        let player_item = get_player_item_or_fail(ctx).await?;
        if player_item.is_dead {
            user_error("You try to get it, but your ghostly hands slip through it uselessly".to_owned())?;
        }
        let item_id = match command {
            QueueCommand::Get { 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
        };
        if item.location != player_item.location {
            user_error(format!("You try to get {} but realise it is no longer there",
                               &item.display_for_sentence(!ctx.session_dat.less_explicit_mode, 1, false)))?
        }

        let possession_data = match item.possession_type.as_ref().and_then(|pt| possession_data().get(&pt)) {
            None => user_error("That item no longer exists in the game so can't be handled".to_owned())?,
            Some(pd) => pd
        };
        
        let player_as_loc = format!("{}/{}", &player_item.item_type, &player_item.item_code);
        match check_item_capacity(ctx.trans, &player_as_loc, possession_data.weight).await? {
            CapacityLevel::AboveItemLimit => user_error("You just can't hold that many things!".to_owned())?,
            CapacityLevel::OverBurdened => user_error(format!(
                "{} You drop {} because it is too heavy!",
                if ctx.session_dat.less_explicit_mode { "Rats!" } else { "Fuck!" },
                &player_item.display_for_sentence(!ctx.session_dat.less_explicit_mode, 1, false)
            ))?,
            _ => ()
        }
        
        let msg_exp = format!("{} picks up {}\n",
                              &player_item.display_for_sentence(true, 1, true),
                              &item.display_for_sentence(true, 1, false));
        let msg_nonexp = format!("{} picks up {}\n",
                                 &player_item.display_for_sentence(false, 1, true),
                                 &item.display_for_sentence(false, 1, false));
        broadcast_to_room(ctx.trans, &player_item.location, None, &msg_exp, Some(&msg_nonexp)).await?;
        let mut item_mut = (*item).clone();
        item_mut.location = player_as_loc;
        item_mut.action_type = LocationActionType::Normal;
        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?;
        // TODO: Parse "get target from container" variant
        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_loc_contents: true,
            item_type_only: Some("possession"),
            limit: get_limit.unwrap_or(100),
            ..ItemSearchParams::base(&player_item, &remaining)
        }).await?;
        if player_item.is_dead {
            user_error("You try to get it, but your ghostly hands slip through it uselessly".to_owned())?;
        }

        let mut did_anything: bool = false;
        for target in targets.iter().filter(|t| t.action_type.is_visible_in_look()) {
            if target.item_type != "possession" {
                user_error("You can't get that!".to_owned())?;
            }
            did_anything = true;
            queue_command(ctx, &QueueCommand::Get { possession_id: target.item_code.clone() }).await?;
        }
        if !did_anything {
            user_error("I didn't find anything matching.".to_owned())?;
        }
        Ok(())
    }
}
static VERB_INT: Verb = Verb;
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;