From e473c47bcfb104b99755f223c29b91432fe641b0 Mon Sep 17 00:00:00 2001 From: holychowders Date: Wed, 4 May 2022 08:24:19 -0500 Subject: [PATCH] Distinguish stealth from armor and stealth from sneaking. Also fixes #1525. - Armor and sneaking have exclusive effects on overall stealth, rather than armor taking effect only while sneaking. Gameplay: - Agents factor in stealth from armor in all cases, not only when sneaking. - Max stealth takes place when sneaking (final multiplier of `0.7`) and with stealth from armor up to `0.7` (`0.3` multiplier), resulting in a max distance modifier of about `0.5`, approximately what it was previously. - Min stealth score from armor is now 0 instead of 2. Internals: - Stealth getter accounts for sneaking in final calculation, not just armor. - Prevents potential division by zero. - Stealth getter returns value that should be multiplied instead of divided. - Legitimized stealth as a score between 0 and 1. Notes: - FIXME: Someone more familiar with the different armor types may want to adjust their stealths. - Armor stealths seem to be valued between `0.0` and `1.0`, and I've reinforced this in the code. However, it is possible, particularly for the `Dragonscale` armors, to cumulatively reach a value of `2.0`. --- common/src/combat.rs | 52 +++++++++++++++++++++++++++++++++++------ server/src/sys/agent.rs | 27 +++++++-------------- 2 files changed, 54 insertions(+), 25 deletions(-) diff --git a/common/src/combat.rs b/common/src/combat.rs index dd305c19b9..d0b9c4575c 100644 --- a/common/src/combat.rs +++ b/common/src/combat.rs @@ -34,6 +34,9 @@ use std::{ops::MulAssign, time::Duration}; #[cfg(not(target_arch = "wasm32"))] use vek::*; #[cfg(not(target_arch = "wasm32"))] + +const STEALTH_SUM_FROM_ITEMS_MAX: f32 = 0.3; + #[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize, Deserialize)] pub enum GroupTarget { InGroup, @@ -1164,13 +1167,48 @@ pub fn compute_max_energy_mod(inventory: Option<&Inventory>) -> f32 { }) } -/// Computes the sneak coefficient from armor. Agent perception distances are -/// divided by the resulting f32. +pub fn is_stealth_from_items_maxed(inventory: Option<&Inventory>) -> bool { + let sum = compute_stealth_sum_from_items(inventory); + + sum >= STEALTH_SUM_FROM_ITEMS_MAX +} + +/// Returns a value to be included as a multiplicative factor in perception +/// distance checks. #[cfg(not(target_arch = "wasm32"))] -pub fn compute_stealth_coefficient(inventory: Option<&Inventory>) -> f32 { - // Starts with a value of 2.0 when summing the stats from each armor piece, and - // defaults to a value of 2.0 if no inventory is equipped - inventory.map_or(2.0, |inv| { +pub fn perception_dist_multiplier_from_stealth( + inventory: Option<&Inventory>, + character_state: Option<&CharacterState>, +) -> f32 { + const SNEAK_MULTIPLIER: f32 = 0.7; + const STEALTH_SUM_FROM_ITEMS_MIN: f32 = 0.0; + const MULTIPLIER_FROM_ITEMS_MAX: f32 = 0.7; + const MULTIPLIER_FROM_ITEMS_MIN: f32 = 1.0; + + let stealth_sum = compute_stealth_sum_from_items(inventory); + let is_sneaking = character_state.map_or(false, |state| state.is_stealthy()); + + let mut multiplier; + + if stealth_sum > STEALTH_SUM_FROM_ITEMS_MAX { + multiplier = MULTIPLIER_FROM_ITEMS_MAX; + } else if stealth_sum < STEALTH_SUM_FROM_ITEMS_MIN { + multiplier = MULTIPLIER_FROM_ITEMS_MIN; + } else { + multiplier = 1.0 - stealth_sum; + } + + if is_sneaking { + multiplier *= SNEAK_MULTIPLIER; + } + + multiplier +} + +/// Returns sum of stealth from items equipped. +#[cfg(not(target_arch = "wasm32"))] +pub fn compute_stealth_sum_from_items(inventory: Option<&Inventory>) -> f32 { + inventory.map_or(0.0, |inv| { inv.equipped_items() .filter_map(|item| { if let ItemKind::Armor(armor) = &item.kind() { @@ -1179,7 +1217,7 @@ pub fn compute_stealth_coefficient(inventory: Option<&Inventory>) -> f32 { None } }) - .fold(2.0, |a, b| a + b.max(0.0)) + .fold(0.0, |a, b| a + b) }) } diff --git a/server/src/sys/agent.rs b/server/src/sys/agent.rs index fe3908161f..3d1e142920 100644 --- a/server/src/sys/agent.rs +++ b/server/src/sys/agent.rs @@ -20,7 +20,7 @@ use crate::{ }, }; use common::{ - combat::compute_stealth_coefficient, + combat::perception_dist_multiplier_from_stealth, comp::{ self, agent::{ @@ -2429,26 +2429,17 @@ impl<'a> AgentData<'a> { other_pos: &Pos, read_data: &ReadData, ) -> bool { - let other_stealth_coefficient = { - let is_other_stealthy = read_data - .char_states - .get(other) - .map_or(false, CharacterState::is_stealthy); + let other_stealth_multiplier = { + let other_inventory = read_data.inventories.get(other); + let other_char_state = read_data.char_states.get(other); - if is_other_stealthy { - // TODO: We shouldn't have to check CharacterState. This should be factored in - // by the function (such as the one we're calling below) that supposedly - // computes a coefficient given stealthy-ness. - compute_stealth_coefficient(read_data.inventories.get(other)) - } else { - 1.0 - } + perception_dist_multiplier_from_stealth(other_inventory, other_char_state) }; - let dist_sqrd = other_pos.0.distance_squared(self.pos.0); - let within_sight_dist = { - let sight_dist = agent.psyche.sight_dist / other_stealth_coefficient; + let sight_dist = agent.psyche.sight_dist * other_stealth_multiplier; + let dist_sqrd = other_pos.0.distance_squared(self.pos.0); + dist_sqrd < sight_dist.powi(2) }; @@ -2458,7 +2449,7 @@ impl<'a> AgentData<'a> { let other_body = read_data.bodies.get(other); - within_sight_dist + (within_sight_dist) && within_fov && entities_have_line_of_sight(self.pos, self.body, other_pos, other_body, read_data) }