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

use super::{
    get_player_item_or_fail, look,
    open::{attempt_open_immediate, is_door_in_direction, DoorSituation},
    user_error, UResult, UserError, UserVerb, UserVerbRef, VerbContext,
};
#[double]
use crate::db::DBTrans;
use crate::{
    language,
    models::{
        consent::ConsentType,
        item::{ActiveClimb, DoorState, Item, ItemSpecialData, LocationActionType, SkillType},
    },
    regular_tasks::queued_command::{
        queue_command_and_save, MovementSource, QueueCommand, QueueCommandHandler,
        QueuedCommandContext,
    },
    services::{
        check_consent,
        combat::{change_health, handle_resurrect, stop_attacking_mut},
        comms::broadcast_to_room,
        skills::skill_check_and_grind,
    },
    static_content::{
        dynzone::{dynzone_by_type, DynzoneType, ExitTarget as DynExitTarget},
        room::{self, Direction, ExitClimb, ExitType, MaterialType},
    },
    DResult,
};
use ansi::ansi;
use async_trait::async_trait;
use mockall_double::double;
use rand_distr::{Distribution, Normal};
use std::sync::Arc;
use std::time;

pub async fn announce_move(
    trans: &DBTrans,
    character: &Item,
    leaving: &Item,
    arriving: &Item,
) -> DResult<()> {
    let msg_leaving_exp = format!(
        "{} departs towards {}\n",
        &character.display_for_sentence(true, 1, true),
        &arriving.display
    );
    let msg_leaving_nonexp = format!(
        "{} departs towards {}\n",
        character.display_for_sentence(true, 1, false),
        arriving
            .display_less_explicit
            .as_ref()
            .unwrap_or(&arriving.display)
    );
    broadcast_to_room(
        trans,
        &format!("{}/{}", &leaving.item_type, &leaving.item_code),
        None,
        &msg_leaving_exp,
        Some(&msg_leaving_nonexp),
    )
    .await?;

    let msg_arriving_exp = format!(
        "{} arrives from {}\n",
        &character.display_for_sentence(true, 1, true),
        &leaving.display
    );
    let msg_arriving_nonexp = format!(
        "{} arrives from {}\n",
        character.display_for_sentence(true, 1, false),
        leaving
            .display_less_explicit
            .as_ref()
            .unwrap_or(&leaving.display)
    );
    broadcast_to_room(
        trans,
        &format!("{}/{}", &arriving.item_type, &arriving.item_code),
        None,
        &msg_arriving_exp,
        Some(&msg_arriving_nonexp),
    )
    .await?;
    Ok(())
}

async fn move_to_where(
    use_location: &str,
    direction: &Direction,
    ctx: &mut QueuedCommandContext<'_>,
) -> UResult<(String, Option<Item>, Option<&'static ExitClimb>)> {
    // Firstly check dynamic exits, since they apply to rooms and dynrooms...
    if let Some(dynroom_result) = ctx
        .trans
        .find_exact_dyn_exit(use_location, direction)
        .await?
    {
        return Ok((
            format!(
                "{}/{}",
                &dynroom_result.item_type, &dynroom_result.item_code
            ),
            Some(dynroom_result),
            None,
        ));
    }

    let (heretype, herecode) = use_location
        .split_once("/")
        .unwrap_or(("room", "repro_xv_chargen"));

    if heretype == "dynroom" {
        let old_dynroom_item = match ctx.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_by_type()
            .get(&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 {
            DynExitTarget::ExitZone => {
                let (zonetype, zonecode) = old_dynroom_item
                    .location
                    .split_once("/")
                    .ok_or_else(|| UserError("Invalid zone for your room".to_owned()))?;
                let zoneitem = ctx
                    .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(),
                    )?,
                };
                Ok((zone_exit.to_string(), None, None))
            }
            DynExitTarget::Intrazone { subcode } => {
                let to_item = ctx
                    .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((
                    format!("{}/{}", &to_item.item_type, &to_item.item_code),
                    Some(to_item),
                    None,
                ))
            }
        };
    }
    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()))?;

    match exit.exit_type {
        ExitType::Free => {}
        ExitType::Blocked(blocker) => {
            if !blocker.attempt_exit(ctx, exit).await? {
                user_error("Stopping movement".to_owned())?;
            }
        }
    }

    let new_room = room::resolve_exit(room, exit)
        .ok_or_else(|| UserError("Can't find that room".to_owned()))?;
    Ok((
        format!("room/{}", new_room.code),
        None,
        exit.exit_climb.as_ref(),
    ))
}

pub async fn check_room_access(trans: &DBTrans, player: &Item, room: &Item) -> UResult<()> {
    let (owner_t, owner_c) = match room.owner.as_ref().and_then(|o| o.split_once("/")) {
        None => return Ok(()),
        Some(v) => v,
    };
    if owner_t == &player.item_type && owner_c == &player.item_code {
        return Ok(());
    }
    let owner = match trans.find_item_by_type_code(owner_t, owner_c).await? {
        None => return Ok(()),
        Some(v) => v,
    };

    if check_consent(trans, "enter", &ConsentType::Visit, player, &owner).await? {
        return Ok(());
    }

    let mut player_hypothet = (*player).clone();
    // We are asking hypothetically if they entered the room, could they fight
    // the owner? We won't save this yet.
    player_hypothet.location = room.refstr();
    if check_consent(
        trans,
        "enter",
        &ConsentType::Fight,
        &player_hypothet,
        &owner,
    )
    .await?
    {
        return Ok(());
    }

    user_error(ansi!("<yellow>Your wristpad buzzes and your muscles lock up, stopping you entering.<reset> \
                      It seems this is private property and you haven't been invited here with \
                      <bold>allow visit<reset>, nor do you have a <bold>allow fight<reset> in force with \
                      the owner here.").to_owned())?
}

pub async fn handle_fall(trans: &DBTrans, faller: &mut Item, fall_dist: u64) -> UResult<String> {
    // TODO depend on distance, armour, etc...
    // This is deliberately less damage than real life for the distance,
    // since we'll assume the wristpad provides reflexes to buffer some damage.

    let damage_modifier = match faller.location.split_once("/") {
        Some((ltype, lcode)) if ltype == "room" => match room::room_map_by_code().get(lcode) {
            None => 1.0,
            Some(room) => match room.material_type {
                MaterialType::WaterSurface | MaterialType::Underwater => {
                    return Ok("lands with a splash".to_owned());
                }
                MaterialType::Soft { damage_modifier } => damage_modifier,
                MaterialType::Normal => 1.0,
            },
        },
        _ => 1.0,
    };

    let modified_safe_distance = 5.0 / damage_modifier;
    if (fall_dist as f64) < modified_safe_distance {
        return Ok("lands softly".to_owned());
    }
    // The force is proportional to the square root of the fall distance.
    let damage = ((fall_dist as f64 - modified_safe_distance).sqrt()
        * 3.0
        * damage_modifier
        * Normal::new(1.0, 0.3)?.sample(&mut rand::thread_rng())) as i64;

    if damage > 0 {
        change_health(trans, -damage, faller, "You fell", "You fell").await?;
    }

    let descriptor = if damage >= 30 {
        "smashes violently into the ground like a comet with a massive boom"
    } else if damage >= 25 {
        "smashes violently into the ground with a very loud bang"
    } else if damage >= 20 {
        "smashes violently into the ground with a loud bang"
    } else if damage >= 15 {
        "smashes into the ground with a loud thump"
    } else if damage >= 10 {
        "smashes into the ground with a thump"
    } else {
        "lands with a thump"
    };
    Ok(descriptor.to_owned())
}

async fn attempt_move_immediate(
    direction: &Direction,
    mut ctx: &mut QueuedCommandContext<'_>,
    source: &MovementSource,
) -> UResult<()> {
    let use_location = if ctx.item.death_data.is_some() {
        if ctx.item.item_type != "player" {
            user_error("Dead players don't move".to_owned())?;
        }
        "room/repro_xv_respawn".to_owned()
    } else {
        ctx.item.location.clone()
    };

    let session = ctx.get_session().await?;

    match is_door_in_direction(ctx.trans, direction, &use_location).await? {
        DoorSituation::NoDoor
        | DoorSituation::DoorOutOfRoom {
            state: DoorState { open: true, .. },
            ..
        } => {}
        DoorSituation::DoorIntoRoom {
            state: DoorState { open: true, .. },
            room_with_door,
            ..
        } => {
            check_room_access(ctx.trans, ctx.item, &room_with_door).await?;
        }
        _ => {
            attempt_open_immediate(ctx, direction).await?;
            // Players take an extra step. So tell them to come back.
            ctx.item.queue.push_front(QueueCommand::Movement {
                direction: direction.clone(),
                source: source.clone(),
            });
            return Ok(());
        }
    }

    let (new_loc, new_loc_item, climb_opt) = move_to_where(&use_location, direction, ctx).await?;

    let mut skip_escape_check: bool = false;
    let mut escape_check_only: bool = false;

    if let Some(climb) = climb_opt {
        if let Some(active_climb) = ctx.item.active_climb.clone() {
            skip_escape_check = true; // Already done if we get here.
            let skills = skill_check_and_grind(
                ctx.trans,
                ctx.item,
                &SkillType::Climb,
                climb.difficulty as f64,
            )
            .await?;
            let mut narrative = String::new();
            if skills <= -0.25 {
                // Crit fail - they have fallen.
                let (fall_dist, from_room, to_room) = if climb.height < 0 {
                    // At least they get to where they want to go!
                    ctx.item.location = new_loc.clone();
                    (
                        climb.height.abs() as u64 - active_climb.height,
                        new_loc.to_owned(),
                        use_location.clone(),
                    )
                } else {
                    (
                        active_climb.height,
                        use_location.clone(),
                        new_loc.to_owned(),
                    )
                };
                ctx.item.active_climb = None;
                let descriptor = handle_fall(&ctx.trans, ctx.item, fall_dist).await?;
                let msg_exp = format!(
                    "{} loses {} grip from {} metres up and {}!\n",
                    ctx.item.display_for_sentence(true, 1, true),
                    ctx.item.pronouns.possessive,
                    fall_dist,
                    &descriptor
                );
                let msg_nonexp = format!(
                    "{} loses {} grip from {} metres up and {}!\n",
                    ctx.item.display_for_sentence(false, 1, true),
                    &ctx.item.pronouns.possessive,
                    fall_dist,
                    &descriptor
                );
                broadcast_to_room(ctx.trans, &from_room, None, &msg_exp, Some(&msg_nonexp)).await?;
                broadcast_to_room(ctx.trans, &to_room, None, &msg_exp, Some(&msg_nonexp)).await?;
                ctx.item.queue.truncate(0);
                return Ok(());
            } else if skills <= 0.0 {
                if climb.height >= 0 {
                    narrative.push_str("You lose your grip and slide a metre back down");
                } else {
                    narrative.push_str(
                        "You struggle to find a foothold and reluctantly climb a metre back up",
                    );
                }
                if let Some(ac) = ctx.item.active_climb.as_mut() {
                    if ac.height > 0 {
                        ac.height -= 1;
                    }
                }
            } else {
                if climb.height < 0 {
                    narrative.push_str("You climb down another metre");
                } else {
                    narrative.push_str("You climb up another metre");
                }
                if let Some(ac) = ctx.item.active_climb.as_mut() {
                    ac.height += 1;
                }
            }
            if let Some(ac) = ctx.item.active_climb.as_ref() {
                if climb.height >= 0 && ac.height >= climb.height as u64 {
                    if let Some((sess, _)) = session.as_ref() {
                        ctx.trans
                            .queue_for_session(
                                sess,
                                Some(
                                    "You brush yourself off and finish climbing - you \
                                     made it to the top!\n",
                                ),
                            )
                            .await?;
                    }
                    ctx.item.active_climb = None;
                } else if climb.height < 0 && ac.height >= (-climb.height) as u64 {
                    if let Some((sess, _)) = session.as_ref() {
                        ctx.trans
                            .queue_for_session(
                                sess,
                                Some(
                                    "You brush yourself off and finish climbing - you \
                                     made it down!\n",
                                ),
                            )
                            .await?;
                    }
                    ctx.item.active_climb = None;
                } else {
                    let progress_quant =
                        (((ac.height as f64) / (climb.height.abs() as f64)) * 10.0) as u64;
                    if let Some((sess, _)) = session {
                        ctx.trans.queue_for_session(
                            &sess,
                            Some(&format!(ansi!("<bold>[<reset><cyan>{}{}<reset><bold>] [<reset>{}/{} m<bold>]<reset> {}\n"),
                                          "=".repeat(progress_quant as usize), " ".repeat((10 - progress_quant) as usize),
                                          ac.height, climb.height.abs(), &narrative
                            ))).await?;
                    }
                    ctx.item.queue.push_front(QueueCommand::Movement {
                        direction: direction.clone(),
                        source: source.clone(),
                    });
                    return Ok(());
                }
            }
        } else {
            let msg_exp = format!(
                "{} starts climbing {}\n",
                &ctx.item.display_for_sentence(true, 1, true),
                &direction.describe_climb(if climb.height > 0 { "up" } else { "down" })
            );
            let msg_nonexp = format!(
                "{} starts climbing {}\n",
                &ctx.item.display_for_sentence(true, 1, false),
                &direction.describe_climb(if climb.height > 0 { "up" } else { "down" })
            );
            broadcast_to_room(&ctx.trans, &use_location, None, &msg_exp, Some(&msg_nonexp)).await?;

            ctx.item.active_climb = Some(ActiveClimb {
                ..Default::default()
            });

            ctx.item.queue.push_front(QueueCommand::Movement {
                direction: direction.clone(),
                source: source.clone(),
            });
            escape_check_only = true;
        }
    }

    if !skip_escape_check {
        match ctx
            .item
            .active_combat
            .as_ref()
            .and_then(|ac| ac.attacking.clone())
        {
            None => {}
            Some(old_victim) => {
                if let Some((vcode, vtype)) = old_victim.split_once("/") {
                    if let Some(vitem) = ctx.trans.find_item_by_type_code(vcode, vtype).await? {
                        let mut vitem_mut = (*vitem).clone();
                        stop_attacking_mut(ctx.trans, ctx.item, &mut vitem_mut, false).await?;
                        ctx.trans.save_item_model(&vitem_mut).await?
                    }
                }
            }
        }
        match ctx
            .item
            .active_combat
            .clone()
            .as_ref()
            .map(|ac| &ac.attacked_by[..])
        {
            None | Some([]) => {}
            Some(attackers) => {
                let mut attacker_names = Vec::new();
                let mut attacker_items = Vec::new();
                if let Some((_, session_dat)) = session.as_ref() {
                    for attacker in &attackers[..] {
                        if let Some((acode, atype)) = attacker.split_once("/") {
                            if let Some(aitem) =
                                ctx.trans.find_item_by_type_code(acode, atype).await?
                            {
                                attacker_names.push(aitem.display_for_session(session_dat));
                                attacker_items.push(aitem);
                            }
                        }
                    }
                }
                let attacker_names_ref = attacker_names
                    .iter()
                    .map(|n| n.as_str())
                    .collect::<Vec<&str>>();
                let attacker_names_str = language::join_words(&attacker_names_ref[..]);
                if skill_check_and_grind(
                    ctx.trans,
                    ctx.item,
                    &SkillType::Dodge,
                    attackers.len() as f64 + 8.0,
                )
                .await?
                    >= 0.0
                {
                    if let Some((sess, _)) = session.as_ref() {
                        ctx.trans
                            .queue_for_session(
                                sess,
                                Some(&format!(
                                    "You successfully get away from {}\n",
                                    &attacker_names_str
                                )),
                            )
                            .await?;
                    }
                    for item in &attacker_items[..] {
                        let mut item_mut = (**item).clone();
                        stop_attacking_mut(ctx.trans, &mut item_mut, ctx.item, true).await?;
                        ctx.trans.save_item_model(&item_mut).await?;
                    }
                } else {
                    if let Some((sess, _)) = session.as_ref() {
                        ctx.trans
                            .queue_for_session(
                                sess,
                                Some(&format!(
                                    "You try and fail to run past {}\n",
                                    &attacker_names_str
                                )),
                            )
                            .await?;
                    }
                    return Ok(());
                }
            }
        }
    }
    if escape_check_only {
        return Ok(());
    }

    if ctx.item.death_data.is_some() {
        if !handle_resurrect(ctx.trans, ctx.item).await? {
            user_error("You couldn't be resurrected.".to_string())?;
        }
    }

    ctx.item.location = new_loc.clone();
    ctx.item.action_type = LocationActionType::Normal;
    ctx.item.active_combat = None;

    if let Some((sess, mut session_dat)) = session {
        let mut user = ctx.trans.find_by_username(&ctx.item.item_code).await?;
        // Look reads it, so we ensure we save it first.
        ctx.trans.save_item_model(&ctx.item).await?;
        look::VERB
            .handle(
                &mut VerbContext {
                    session: &sess,
                    session_dat: &mut session_dat,
                    trans: ctx.trans,
                    user_dat: &mut user,
                },
                "look",
                "",
            )
            .await?;
    }

    if let Some((old_loc_type, old_loc_code)) = use_location.split_once("/") {
        if let Some(old_room_item) = ctx
            .trans
            .find_item_by_type_code(old_loc_type, old_loc_code)
            .await?
        {
            if let Some((new_loc_type, new_loc_code)) = new_loc.split_once("/") {
                if let Some(new_room_item) = match new_loc_item {
                    None => {
                        ctx.trans
                            .find_item_by_type_code(new_loc_type, new_loc_code)
                            .await?
                    }
                    v => v.map(Arc::new),
                } {
                    announce_move(&ctx.trans, ctx.item, &old_room_item, &new_room_item).await?;
                }
            }
        }
    }

    Ok(())
}

pub struct QueueHandler;
#[async_trait]
impl QueueCommandHandler for QueueHandler {
    async fn start_command(&self, _ctx: &mut QueuedCommandContext<'_>) -> UResult<time::Duration> {
        Ok(time::Duration::from_secs(1))
    }

    #[allow(unreachable_patterns)]
    async fn finish_command(&self, ctx: &mut QueuedCommandContext<'_>) -> UResult<()> {
        let (direction, source) = match ctx.command {
            QueueCommand::Movement { direction, source } => (direction, source),
            _ => user_error("Unexpected command".to_owned())?,
        };
        attempt_move_immediate(direction, ctx, source).await?;
        Ok(())
    }
}

pub struct Verb;

#[async_trait]
impl UserVerb for Verb {
    async fn handle(
        self: &Self,
        ctx: &mut VerbContext,
        verb: &str,
        remaining: &str,
    ) -> UResult<()> {
        let dir = Direction::parse(&(verb.to_owned() + " " + remaining.trim()).trim())
            .ok_or_else(|| UserError("Unknown direction".to_owned()))?;
        let player_item = get_player_item_or_fail(ctx).await?;
        queue_command_and_save(
            ctx,
            &player_item,
            &QueueCommand::Movement {
                direction: dir.clone(),
                source: MovementSource::Command,
            },
        )
        .await
    }
}
static VERB_INT: Verb = Verb;
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;