forked from blasthavers/blastmud
114 lines
4.8 KiB
Rust
114 lines
4.8 KiB
Rust
use super::{
|
|
VerbContext, UserVerb, UserVerbRef, UResult, UserError, user_error,
|
|
get_player_item_or_fail,
|
|
look
|
|
};
|
|
use async_trait::async_trait;
|
|
use crate::{
|
|
DResult,
|
|
regular_tasks::queued_command::{
|
|
QueueCommandHandler,
|
|
QueueCommand,
|
|
queue_command
|
|
},
|
|
static_content::room::{self, Direction, ExitType},
|
|
db::DBTrans,
|
|
models::item::Item,
|
|
services::broadcast_to_room,
|
|
};
|
|
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, &leaving.display);
|
|
let msg_leaving_nonexp = format!("{} departs towards {}\n",
|
|
character.display_less_explicit
|
|
.as_ref()
|
|
.unwrap_or(&character.display),
|
|
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, &leaving.display);
|
|
let msg_arriving_nonexp = format!("{} arrives from {}\n",
|
|
character.display_less_explicit
|
|
.as_ref()
|
|
.unwrap_or(&character.display),
|
|
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(())
|
|
}
|
|
|
|
pub struct QueueHandler;
|
|
#[async_trait]
|
|
impl QueueCommandHandler for QueueHandler {
|
|
async fn start_command(&self, _ctx: &mut VerbContext<'_>, _command: &QueueCommand)
|
|
-> UResult<time::Duration> {
|
|
Ok(time::Duration::from_secs(1))
|
|
}
|
|
|
|
#[allow(unreachable_patterns)]
|
|
async fn finish_command(&self, ctx: &mut VerbContext<'_>, command: &QueueCommand)
|
|
-> UResult<()> {
|
|
let direction = match command {
|
|
QueueCommand::Movement { direction } => direction,
|
|
_ => user_error("Unexpected command".to_owned())?
|
|
};
|
|
let player_item = get_player_item_or_fail(ctx).await?;
|
|
let (heretype, herecode) = player_item.location.split_once("/").unwrap_or(("room", "repro_xv_chargen"));
|
|
if heretype != "room" {
|
|
// Fix this when we have planes / boats / roomkits.
|
|
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, &player_item, 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()))?;
|
|
let mut new_player_item = (*player_item).clone();
|
|
new_player_item.location = format!("{}/{}", "room", new_room.code);
|
|
ctx.trans.save_item_model(&new_player_item).await?;
|
|
|
|
|
|
look::VERB.handle(ctx, "look", "").await?;
|
|
|
|
if let Some(old_room_item) = ctx.trans.find_item_by_type_code("room", room.code).await? {
|
|
if let Some(new_room_item) = ctx.trans.find_item_by_type_code("room", new_room.code).await? {
|
|
announce_move(&ctx.trans, &new_player_item, &old_room_item, &new_room_item).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).ok_or_else(|| UserError("Unknown direction".to_owned()))?;
|
|
if remaining.trim() != "" {
|
|
user_error("Movement commands don't take extra data at the end.".to_owned())?;
|
|
}
|
|
queue_command(ctx, &QueueCommand::Movement { direction: dir.clone() }).await
|
|
}
|
|
}
|
|
static VERB_INT: Verb = Verb;
|
|
pub static VERB: UserVerbRef = &VERB_INT as UserVerbRef;
|