forked from blasthavers/blastmud
292 lines
13 KiB
Rust
292 lines
13 KiB
Rust
|
use crate::{
|
||
|
|
services::{
|
||
|
|
broadcast_to_room,
|
||
|
|
skills::skill_check_and_grind,
|
||
|
|
skills::skill_check_only,
|
||
|
|
},
|
||
|
|
models::{
|
||
|
|
item::{Item, LocationActionType, Subattack, SkillType},
|
||
|
|
task::{Task, TaskMeta, TaskDetails}
|
||
|
|
},
|
||
|
|
static_content::{
|
||
|
|
possession_type::{WeaponData, possession_data, fist},
|
||
|
|
npc::npc_by_code,
|
||
|
|
},
|
||
|
|
message_handler::user_commands::{user_error, UResult},
|
||
|
|
regular_tasks::{TaskRunContext, TaskHandler},
|
||
|
|
DResult,
|
||
|
|
db::DBTrans,
|
||
|
|
};
|
||
|
|
use async_trait::async_trait;
|
||
|
|
use chrono::Utc;
|
||
|
|
use async_recursion::async_recursion;
|
||
|
|
use std::time;
|
||
|
|
use ansi::ansi;
|
||
|
|
use rand_distr::{Normal, Distribution};
|
||
|
|
|
||
|
|
#[derive(Clone)]
|
||
|
|
pub struct AttackTaskHandler;
|
||
|
|
#[async_trait]
|
||
|
|
impl TaskHandler for AttackTaskHandler {
|
||
|
|
async fn do_task(&self, ctx: &mut TaskRunContext) -> DResult<Option<time::Duration>> {
|
||
|
|
let (ctype, ccode) = ctx.task.meta.task_code.split_once("/")
|
||
|
|
.ok_or("Invalid AttackTick task code")?;
|
||
|
|
let mut attacker_item = match ctx.trans.find_item_by_type_code(ctype, ccode).await? {
|
||
|
|
None => { return Ok(None); } // Player is gone
|
||
|
|
Some(item) => (*item).clone()
|
||
|
|
};
|
||
|
|
|
||
|
|
let (vtype, vcode) =
|
||
|
|
match attacker_item.active_combat.as_ref().and_then(|ac| ac.attacking.as_ref()).and_then(|v| v.split_once("/")) {
|
||
|
|
None => return Ok(None),
|
||
|
|
Some(x) => x
|
||
|
|
};
|
||
|
|
let mut victim_item = match ctx.trans.find_item_by_type_code(vtype, vcode).await? {
|
||
|
|
None => { return Ok(None); }
|
||
|
|
Some(item) => (*item).clone()
|
||
|
|
};
|
||
|
|
|
||
|
|
if attacker_item.is_dead || victim_item.is_dead {
|
||
|
|
return Ok(None)
|
||
|
|
}
|
||
|
|
|
||
|
|
let weapon = what_wielded(ctx.trans, &attacker_item).await?;
|
||
|
|
|
||
|
|
let attack_skill = *attacker_item.total_skills.get(&weapon.uses_skill).unwrap_or(&0.0);
|
||
|
|
let victim_dodge_skill = *victim_item.total_skills.get(&SkillType::Dodge).unwrap_or(&0.0);
|
||
|
|
|
||
|
|
let dodge_result = skill_check_and_grind(ctx.trans, &mut victim_item, &SkillType::Dodge,
|
||
|
|
attack_skill).await?;
|
||
|
|
let user_opt = if ctype == "player" { ctx.trans.find_by_username(ccode).await? } else { None };
|
||
|
|
let attack_result = if let Some(user) = user_opt {
|
||
|
|
let raw_skill = *user.raw_skills.get(&weapon.uses_skill).unwrap_or(&0.0);
|
||
|
|
if raw_skill >= weapon.raw_min_to_learn && raw_skill <= weapon.raw_max_to_learn {
|
||
|
|
skill_check_and_grind(ctx.trans, &mut attacker_item, &weapon.uses_skill,
|
||
|
|
victim_dodge_skill).await?
|
||
|
|
} else {
|
||
|
|
skill_check_only(&attacker_item, &weapon.uses_skill, victim_dodge_skill)
|
||
|
|
}
|
||
|
|
} else {
|
||
|
|
skill_check_only(&attacker_item, &weapon.uses_skill, victim_dodge_skill)
|
||
|
|
};
|
||
|
|
|
||
|
|
if dodge_result > attack_result {
|
||
|
|
let msg_exp = format!("{} dodges out of the way of {}'s attack.\n",
|
||
|
|
victim_item.display_for_sentence(true, 1, true),
|
||
|
|
attacker_item.display_for_sentence(true, 1, false));
|
||
|
|
let msg_nonexp = format!("{} dodges out of the way of {}'s attack.\n",
|
||
|
|
victim_item.display_for_sentence(false, 1, true),
|
||
|
|
attacker_item.display_for_sentence(false, 1, false));
|
||
|
|
broadcast_to_room(ctx.trans, &attacker_item.location, None, &msg_exp, Some(&msg_nonexp)).await?;
|
||
|
|
} else {
|
||
|
|
// TODO: Parry system of some kind?
|
||
|
|
|
||
|
|
// Determine body part...
|
||
|
|
let part = victim_item.species.sample_body_part();
|
||
|
|
|
||
|
|
// TODO: Armour / soaks
|
||
|
|
|
||
|
|
// TODO: Calculate damage etc... and display health impact.
|
||
|
|
let mut mean_damage: f64 = weapon.normal_attack_mean_damage;
|
||
|
|
for scaling in weapon.normal_attack_skill_scaling.iter() {
|
||
|
|
let skill = *attacker_item.total_skills.get(&scaling.skill).unwrap_or(&0.0);
|
||
|
|
if skill >= scaling.min_skill {
|
||
|
|
mean_damage += (skill - scaling.min_skill) * scaling.mean_damage_per_point_over_min;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let actual_damage = Normal::new(mean_damage,
|
||
|
|
weapon.normal_attack_stdev_damage)?
|
||
|
|
.sample(&mut rand::thread_rng()).floor().max(1.0) as u64;
|
||
|
|
let new_health = if actual_damage > victim_item.health { 0 } else { victim_item.health - actual_damage };
|
||
|
|
let msg_exp = format!(ansi!("[ <red>{}<reset> <bold>{}/{}<reset> ] {}.\n"),
|
||
|
|
actual_damage,
|
||
|
|
new_health,
|
||
|
|
max_health(&victim_item),
|
||
|
|
weapon.normal_attack_success_message(&attacker_item, &victim_item, &part, true));
|
||
|
|
let msg_nonexp =
|
||
|
|
format!(ansi!("[ <red>{}<reset> <bold>{}/{}<reset> ] {}.\n"),
|
||
|
|
actual_damage,
|
||
|
|
new_health,
|
||
|
|
max_health(&victim_item),
|
||
|
|
weapon.normal_attack_success_message(&attacker_item, &victim_item, &part, false));
|
||
|
|
broadcast_to_room(ctx.trans, &attacker_item.location, None, &msg_exp, Some(&msg_nonexp)).await?;
|
||
|
|
victim_item.health = new_health;
|
||
|
|
if new_health == 0 {
|
||
|
|
handle_death(ctx.trans, &mut victim_item).await?;
|
||
|
|
ctx.trans.save_item_model(&attacker_item).await?;
|
||
|
|
ctx.trans.save_item_model(&victim_item).await?;
|
||
|
|
return Ok(None);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
let msg_exp = &(weapon.normal_attack_start_message(&attacker_item, &victim_item, true) + ".\n");
|
||
|
|
let msg_nonexp = &(weapon.normal_attack_start_message(&attacker_item, &victim_item, false) + ".\n");
|
||
|
|
broadcast_to_room(ctx.trans, &attacker_item.location, None, msg_exp, Some(msg_nonexp)).await?;
|
||
|
|
ctx.trans.save_item_model(&attacker_item).await?;
|
||
|
|
ctx.trans.save_item_model(&victim_item).await?;
|
||
|
|
Ok(Some(attack_speed(&attacker_item)))
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
pub async fn handle_death(trans: &DBTrans, whom: &mut Item) -> DResult<()> {
|
||
|
|
whom.is_dead = true;
|
||
|
|
let msg_exp = format!(
|
||
|
|
ansi!("<red>{} stiffens and collapses dead.<reset>\n"),
|
||
|
|
&whom.display_for_sentence(true, 1, true)
|
||
|
|
);
|
||
|
|
let msg_nonexp = format!(
|
||
|
|
ansi!("<red>{} stiffens and collapses dead.<reset>\n"),
|
||
|
|
&whom.display_for_sentence(false, 1, true)
|
||
|
|
);
|
||
|
|
|
||
|
|
if let Some(ac) = &whom.active_combat {
|
||
|
|
let at_str = ac.attacking.clone();
|
||
|
|
for attacker in ac.attacked_by.clone().iter() {
|
||
|
|
if let Some((atype, acode)) = attacker.split_once("/") {
|
||
|
|
if let Some(aitem) = trans.find_item_by_type_code(atype, acode).await? {
|
||
|
|
let mut new_aitem = (*aitem).clone();
|
||
|
|
stop_attacking_mut(trans, &mut new_aitem, whom).await?;
|
||
|
|
trans.save_item_model(&new_aitem).await?;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if let Some((vtype, vcode)) = at_str.as_ref().and_then(|a| a.split_once("/")) {
|
||
|
|
if let Some(vitem) = trans.find_item_by_type_code(vtype, vcode).await? {
|
||
|
|
let mut new_vitem = (*vitem).clone();
|
||
|
|
stop_attacking_mut(trans, whom, &mut new_vitem).await?;
|
||
|
|
trans.save_item_model(&new_vitem).await?;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
broadcast_to_room(trans, &whom.location, None, &msg_exp, Some(&msg_nonexp)).await
|
||
|
|
}
|
||
|
|
|
||
|
|
pub fn max_health(_whom: &Item) -> u64 {
|
||
|
|
24
|
||
|
|
}
|
||
|
|
|
||
|
|
pub static TASK_HANDLER: &(dyn TaskHandler + Sync + Send) = &AttackTaskHandler;
|
||
|
|
|
||
|
|
pub async fn stop_attacking_mut(trans: &DBTrans, new_by_whom: &mut Item, new_to_whom: &mut Item) ->
|
||
|
|
DResult<()>
|
||
|
|
{
|
||
|
|
trans.delete_task("AttackTick",
|
||
|
|
&format!("{}/{}",
|
||
|
|
new_by_whom.item_type,
|
||
|
|
new_by_whom.item_code)).await?;
|
||
|
|
if let Some(ac) = new_to_whom.active_combat.as_mut() {
|
||
|
|
let old_attacker = format!("{}/{}", new_by_whom.item_type, new_by_whom.item_code);
|
||
|
|
ac.attacked_by.retain(|v| v != &old_attacker);
|
||
|
|
}
|
||
|
|
if let Some(ac) = new_by_whom.active_combat.as_mut() {
|
||
|
|
ac.attacking = None;
|
||
|
|
}
|
||
|
|
new_by_whom.action_type = LocationActionType::Normal;
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
pub async fn stop_attacking(trans: &DBTrans, by_whom: &Item, to_whom: &Item) -> DResult<()> {
|
||
|
|
let mut new_by_whom = (*by_whom).clone();
|
||
|
|
let mut new_to_whom = (*to_whom).clone();
|
||
|
|
stop_attacking_mut(trans, &mut new_by_whom, &mut new_to_whom).await?;
|
||
|
|
trans.save_item_model(&new_by_whom).await?;
|
||
|
|
trans.save_item_model(&new_to_whom).await?;
|
||
|
|
Ok(())
|
||
|
|
}
|
||
|
|
|
||
|
|
async fn what_wielded(_trans: &DBTrans, who: &Item) -> DResult<&'static WeaponData> {
|
||
|
|
// TODO: Search inventory for wielded item first.
|
||
|
|
if who.item_type == "npc" {
|
||
|
|
if let Some(intrinsic) = npc_by_code().get(who.item_code.as_str())
|
||
|
|
.and_then(|npc| npc.intrinsic_weapon.as_ref()) {
|
||
|
|
if let Some(weapon) = possession_data().get(intrinsic).and_then(|p| p.weapon_data.as_ref()) {
|
||
|
|
return Ok(weapon)
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Ok(fist())
|
||
|
|
}
|
||
|
|
|
||
|
|
fn attack_speed(_who: &Item) -> time::Duration {
|
||
|
|
time::Duration::from_secs(5)
|
||
|
|
}
|
||
|
|
|
||
|
|
#[async_recursion]
|
||
|
|
pub async fn start_attack(trans: &DBTrans, by_whom: &Item, to_whom: &Item) -> UResult<()> {
|
||
|
|
let mut msg_exp = String::new();
|
||
|
|
let mut msg_nonexp = String::new();
|
||
|
|
let mut verb: String = "attacks".to_string();
|
||
|
|
match by_whom.action_type {
|
||
|
|
LocationActionType::Sitting | LocationActionType::Reclining => {
|
||
|
|
msg_exp.push_str(&format!(ansi!("{} stands up.\n"), &by_whom.display));
|
||
|
|
msg_nonexp.push_str(&format!(ansi!("{} stands up.\n"),
|
||
|
|
by_whom.display_less_explicit.as_ref().unwrap_or(&by_whom.display)));
|
||
|
|
},
|
||
|
|
LocationActionType::Attacking(_) => {
|
||
|
|
match by_whom.active_combat.as_ref().and_then(|ac| ac.attacking.as_ref().and_then(|s| s.split_once("/"))) {
|
||
|
|
Some((cur_type, cur_code)) if cur_type == to_whom.item_type && cur_code == to_whom.item_code =>
|
||
|
|
user_error(format!("You're already attacking {}!", to_whom.pronouns.object))?,
|
||
|
|
Some((cur_type, cur_code)) => {
|
||
|
|
if let Some(cur_item_arc) = trans.find_item_by_type_code(cur_type, cur_code).await? {
|
||
|
|
stop_attacking(trans, by_whom, &cur_item_arc).await?;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
_ => {}
|
||
|
|
}
|
||
|
|
verb = "refocuses ".to_string() + &by_whom.pronouns.possessive + " attacks on";
|
||
|
|
},
|
||
|
|
_ => {}
|
||
|
|
}
|
||
|
|
|
||
|
|
msg_exp.push_str(&format!(
|
||
|
|
ansi!("<red>{} {} {}.<reset>\n"),
|
||
|
|
&by_whom.display_for_sentence(true, 1, true),
|
||
|
|
verb,
|
||
|
|
&to_whom.display_for_sentence(true, 1, false))
|
||
|
|
);
|
||
|
|
msg_nonexp.push_str(&format!(
|
||
|
|
ansi!("<red>{} {} {}.<reset>\n"),
|
||
|
|
&by_whom.display_for_sentence(false, 1, true),
|
||
|
|
verb,
|
||
|
|
&to_whom.display_for_sentence(false, 1, false))
|
||
|
|
);
|
||
|
|
|
||
|
|
let wielded = what_wielded(trans, by_whom).await?;
|
||
|
|
msg_exp.push_str(&(wielded.normal_attack_start_message(by_whom, to_whom, true) + ".\n"));
|
||
|
|
msg_nonexp.push_str(&(wielded.normal_attack_start_message(by_whom, to_whom, false) + ".\n"));
|
||
|
|
|
||
|
|
broadcast_to_room(trans, &by_whom.location, None::<&Item>, &msg_exp, Some(msg_nonexp.as_str())).await?;
|
||
|
|
|
||
|
|
let mut by_whom_for_update = by_whom.clone();
|
||
|
|
by_whom_for_update.active_combat.get_or_insert_with(|| Default::default()).attacking =
|
||
|
|
Some(format!("{}/{}",
|
||
|
|
&to_whom.item_type, &to_whom.item_code));
|
||
|
|
by_whom_for_update.action_type = LocationActionType::Attacking(Subattack::Normal);
|
||
|
|
let mut to_whom_for_update = to_whom.clone();
|
||
|
|
to_whom_for_update.active_combat.get_or_insert_with(|| Default::default()).attacked_by.push(
|
||
|
|
format!("{}/{}",
|
||
|
|
&by_whom.item_type, &by_whom.item_code)
|
||
|
|
);
|
||
|
|
|
||
|
|
trans.upsert_task(&Task {
|
||
|
|
meta: TaskMeta {
|
||
|
|
task_code: format!("{}/{}", by_whom.item_type, by_whom.item_code),
|
||
|
|
next_scheduled: Utc::now() + chrono::Duration::milliseconds(
|
||
|
|
attack_speed(by_whom).as_millis() as i64),
|
||
|
|
..Default::default()
|
||
|
|
},
|
||
|
|
details: TaskDetails::AttackTick
|
||
|
|
}).await?;
|
||
|
|
trans.save_item_model(&by_whom_for_update).await?;
|
||
|
|
trans.save_item_model(&to_whom_for_update).await?;
|
||
|
|
// Auto-counterattack if victim isn't busy.
|
||
|
|
if to_whom_for_update.active_combat.as_ref().and_then(|ac| ac.attacking.as_ref()) == None {
|
||
|
|
start_attack(trans, &to_whom_for_update, &by_whom_for_update).await?;
|
||
|
|
}
|
||
|
|
|
||
|
|
Ok(())
|
||
|
|
}
|