Merge branch veloren:master into jcoxeye/price-entries

2024-08-30 18:12:32 +00:00 · 2024-01-15 22:47:06 +00:00 · 2024-01-15 22:47:06 +00:00 · 941e953348
commit 941e953348
parent be951e747c 05ca01ce89
11 changed files with 222 additions and 84 deletions
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -96,6 +96,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixed Perforate icon not displaying
 - Make cave entrances easier to follow
 - Renamed Twiggy Shoulders to match the Twig Armor set 
+- No longer stack buffs of the same kind with equal attributes, this could lead to a DoS if ie. an entity stayed long enough in lava.

 ## [0.15.0] - 2023-07-01

--- a/Cargo.lock
+++ b/Cargo.lock
@ -7088,6 +7088,7 @@ dependencies = [
 "tracing",
 "vek 0.15.8",
 "veloren-common",
+ "veloren-common-assets",
 "veloren-common-base",
 "veloren-common-ecs",
 "veloren-common-net",
--- a/README.md
+++ b/README.md
@ -48,7 +48,6 @@ Most Veloren servers require you to register with the official authentication se
 - [Website](https://veloren.net)
 - [Discord](https://discord.gg/veloren-community-449602562165833758)
 - [Matrix](https://matrix.to/#/#veloren-space:fachschaften.org)
- [Twitter](https://twitter.com/velorenproject)
 - [Mastodon](https://floss.social/@veloren)
 - [Reddit](https://www.reddit.com/r/Veloren)
 - [YouTube](https://youtube.com/@Veloren)
--- a/assets/voxygen/i18n/en/command.ftl
+++ b/assets/voxygen/i18n/en/command.ftl
@ -64,6 +64,8 @@ command-battlemode-available-modes = Available modes: pvp, pve
 command-battlemode-same = Attempted to set the same battlemode
 command-battlemode-updated = New battlemode: { $battlemode }
 command-buff-unknown = Unknown buff: { $buff }
+command-buff-data = Buff argument '{ $buff }' requires additional data
+command-buff-body-unknown = Unknown body spec: { $spec }
 command-skillpreset-load-error = Error while loading presets
 command-skillpreset-broken = Skill preset is broken
 command-skillpreset-missing = Preset does not exist: { $preset }
--- a/common/assets/src/lib.rs
+++ b/common/assets/src/lib.rs
@ -31,13 +31,13 @@ pub use walk::{walk_tree, Walk};

 #[cfg(feature = "plugins")]
 lazy_static! {
-/// The HashMap where all loaded assets are stored in.
-static ref ASSETS: plugin_cache::CombinedCache = plugin_cache::CombinedCache::new().unwrap();
+    /// The HashMap where all loaded assets are stored in.
+    static ref ASSETS: plugin_cache::CombinedCache = plugin_cache::CombinedCache::new().unwrap();
 }
 #[cfg(not(feature = "plugins"))]
 lazy_static! {
-/// The HashMap where all loaded assets are stored in.
-static ref ASSETS: AssetCache<fs::FileSystem> =
+    /// The HashMap where all loaded assets are stored in.
+    static ref ASSETS: AssetCache<fs::FileSystem> =
            AssetCache::with_source(fs::FileSystem::new().unwrap());
 }

--- a/common/src/cmd.rs
+++ b/common/src/cmd.rs
@ -201,9 +201,10 @@ lazy_static! {
    };

    static ref BUFFS: Vec<String> = {
-        let mut buff_pack: Vec<_> = BUFF_PARSER.keys().cloned().collect();
-        // Add all as valid command
-        buff_pack.push("all".to_string());
+        let mut buff_pack: Vec<String> = BUFF_PARSER.keys().cloned().collect();
+
+        // Add `all` as valid command
+        buff_pack.push("all".to_owned());
        buff_pack
    };

@ -429,6 +430,7 @@ impl ServerChatCommand {
                    Enum("buff", BUFFS.clone(), Required),
                    Float("strength", 0.01, Optional),
                    Float("duration", 10.0, Optional),
+                    Any("buff data spec", Optional),
                ],
                "Cast a buff on player",
                Some(Admin),
--- a/common/src/combat.rs
+++ b/common/src/combat.rs
@ -791,7 +791,7 @@ impl AttackDamage {
    }
 }

-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct AttackEffect {
    target: Option<GroupTarget>,
    effect: CombatEffect,
@ -890,7 +890,7 @@ impl CombatEffect {
    }
 }

-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub enum CombatRequirement {
    AnyDamage,
    Energy(f32),
@ -898,7 +898,7 @@ pub enum CombatRequirement {
    TargetHasBuff(BuffKind),
 }

-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub enum DamagedEffect {
    Combo(i32),
 }
--- a/common/src/comp/buff.rs
+++ b/common/src/comp/buff.rs
@ -165,19 +165,38 @@ pub enum BuffKind {
    /// Results from drinking a potion.
    /// Decreases the health gained from subsequent potions.
    PotionSickness,
-    /// Changed into another body.
-    Polymorphed,
    /// Slows movement speed and reduces energy reward.
    /// Both scales non-linearly to strength, 0.5 lead to movespeed reduction
    /// by 25% and energy reward reduced by 150%, 1.0 lead to MS reduction by
    /// 33.3% and energy reward reduced by 200%. Energy reward can't be
    /// reduced by more than 200%, to a minimum value of -100%.
    Heatstroke,
+    // Complex, non-obvious buffs
+    /// Changed into another body.
+    Polymorphed,
+}
+
+/// Tells a little more about the buff kind than simple buff/debuff
+pub enum BuffDescriptor {
+    /// Simple positive buffs, like `BuffKind::Saturation`
+    SimplePositive,
+    /// Simple negative buffs, like `BuffKind::Bleeding`
+    SimpleNegative,
+    /// Buffs that require unusual data that can't be governed just by strength
+    /// and duration, like `BuffKind::Polymorhped`
+    Complex,
+    // For future additions, we may want to tell about non-obvious buffs,
+    // like Agility.
+    // Also maybe extend Complex to differentiate between Positive, Negative
+    // and Neutral buffs?
+    // For now, Complex is assumed to be neutral/non-obvious.
 }

 impl BuffKind {
-    /// Checks if buff is buff or debuff.
-    pub fn is_buff(self) -> bool {
+    /// Tells a little more about buff kind than simple buff/debuff
+    ///
+    /// Read more in [BuffDescriptor].
+    pub fn differentiate(self) -> BuffDescriptor {
        match self {
            BuffKind::Regeneration
            | BuffKind::Saturation
@ -202,7 +221,7 @@ impl BuffKind {
            | BuffKind::Sunderer
            | BuffKind::Defiance
            | BuffKind::Bloodfeast
-            | BuffKind::Berserk => true,
+            | BuffKind::Berserk => BuffDescriptor::SimplePositive,
            BuffKind::Bleeding
            | BuffKind::Cursed
            | BuffKind::Burning
@ -213,8 +232,23 @@ impl BuffKind {
            | BuffKind::Poisoned
            | BuffKind::Parried
            | BuffKind::PotionSickness
-            | BuffKind::Polymorphed
-            | BuffKind::Heatstroke => false,
+            | BuffKind::Heatstroke => BuffDescriptor::SimpleNegative,
+            BuffKind::Polymorphed => BuffDescriptor::Complex,
+        }
+    }
+
+    /// Checks if buff is buff or debuff.
+    pub fn is_buff(self) -> bool {
+        match self.differentiate() {
+            BuffDescriptor::SimplePositive => true,
+            BuffDescriptor::SimpleNegative | BuffDescriptor::Complex => false,
+        }
+    }
+
+    pub fn is_simple(self) -> bool {
+        match self.differentiate() {
+            BuffDescriptor::SimplePositive | BuffDescriptor::SimpleNegative => true,
+            BuffDescriptor::Complex => false,
        }
    }

@ -460,9 +494,6 @@ pub struct BuffData {
    pub strength: f32,
    pub duration: Option<Secs>,
    pub delay: Option<Secs>,
-    /// Force the buff effects to be applied each tick, ignoring num_ticks
-    #[serde(default)]
-    pub force_immediate: bool,
    /// Used for buffs that have rider buffs (e.g. Flame, Frigid)
    pub secondary_duration: Option<Secs>,
    /// Used to add random data to buffs if needed (e.g. polymorphed)
@ -479,7 +510,6 @@ impl BuffData {
        Self {
            strength,
            duration,
-            force_immediate: false,
            delay: None,
            secondary_duration: None,
            misc_data: None,
@ -496,12 +526,6 @@ impl BuffData {
        self
    }

-    /// Force the buff effects to be applied each tick, ignoring num_ticks
-    pub fn with_force_immediate(mut self, force_immediate: bool) -> Self {
-        self.force_immediate = force_immediate;
-        self
-    }
-
    pub fn with_misc_data(mut self, misc_data: MiscBuffData) -> Self {
        self.misc_data = Some(misc_data);
        self
@ -524,14 +548,14 @@ pub enum BuffCategory {
    SelfBuff,
 }

-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub enum ModifierKind {
    Additive,
    Multiplicative,
 }

 /// Data indicating and configuring behaviour of a de/buff.
-#[derive(Clone, Debug, Serialize, Deserialize)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub enum BuffEffect {
    /// Periodically damages or heals entity
    HealthChangeOverTime {
@ -782,11 +806,44 @@ impl Buffs {

    pub fn insert(&mut self, buff: Buff, current_time: Time) -> BuffKey {
        let kind = buff.kind;
+        // Try to find another overlaping non-queueable buff with same data, cat_ids and
+        // source.
+        let other_key = if kind.queues() {
+            None
+        } else {
+            self.kinds[kind].as_ref().and_then(|(keys, _)| {
+                keys.iter()
+                    .find(|key| {
+                        self.buffs.get(**key).map_or(false, |other_buff| {
+                            other_buff.data == buff.data
+                                && other_buff.cat_ids == buff.cat_ids
+                                && other_buff.source == buff.source
+                                && other_buff
+                                    .end_time
+                                    .map_or(true, |end_time| end_time.0 >= buff.start_time.0)
+                        })
+                    })
+                    .copied()
+            })
+        };
+
+        // If another buff with the same fields is found, update end_time and effects
+        let key = if let Some((other_buff, key)) =
+            other_key.and_then(|key| Some((self.buffs.get_mut(key)?, key)))
+        {
+            other_buff.end_time = buff.end_time;
+            other_buff.effects = buff.effects;
+            key
+        // Otherwise, insert a new buff
+        } else {
            let key = self.buffs.insert(buff);
            self.kinds[kind]
                .get_or_insert_with(|| (Vec::new(), current_time))
                .0
                .push(key);
+            key
+        };
+
        self.sort_kind(kind);
        if kind.queues() {
            self.delay_queueable_buffs(kind, current_time);
--- a/common/state/Cargo.toml
+++ b/common/state/Cargo.toml
@ -6,7 +6,7 @@ version = "0.10.0"

 [features]
 simd = ["vek/platform_intrinsics"]
-plugins = ["toml", "tar", "wasmer", "wasmer-wasix-types", "bincode", "plugin-api", "serde"]
+plugins = ["common-assets/plugins", "toml", "tar", "wasmer", "wasmer-wasix-types", "bincode", "plugin-api", "serde"]

 default = ["simd"]

@ -15,6 +15,7 @@ common = { package = "veloren-common", path = ".." }
 common-net = { package = "veloren-common-net", path = "../net" }
 common-ecs = { package = "veloren-common-ecs", path = "../ecs" }
 common-base = { package = "veloren-common-base", path = "../base" }
+common-assets = { package = "veloren-common-assets", path = "../assets", optional = true}

 rayon = { workspace = true }
 num_cpus = "1.0"
--- a/common/systems/src/buff.rs
+++ b/common/systems/src/buff.rs
@ -161,7 +161,7 @@ impl<'a> System<'a> for Sys {
                        entity,
                        buff_change: BuffChange::Add(Buff::new(
                            BuffKind::Bleeding,
-                            BuffData::new(1.0, Some(Secs(6.0))).with_force_immediate(true),
+                            BuffData::new(1.0, Some(Secs(6.0))),
                            Vec::new(),
                            BuffSource::World,
                            *read_data.time,
@ -179,7 +179,7 @@ impl<'a> System<'a> for Sys {
                        entity,
                        buff_change: BuffChange::Add(Buff::new(
                            BuffKind::Bleeding,
-                            BuffData::new(5.0, Some(Secs(3.0))).with_force_immediate(true),
+                            BuffData::new(5.0, Some(Secs(3.0))),
                            Vec::new(),
                            BuffSource::World,
                            *read_data.time,
@ -215,7 +215,7 @@ impl<'a> System<'a> for Sys {
                        entity,
                        buff_change: BuffChange::Add(Buff::new(
                            BuffKind::Bleeding,
-                            BuffData::new(15.0, Some(Secs(0.1))).with_force_immediate(true),
+                            BuffData::new(15.0, Some(Secs(0.1))),
                            Vec::new(),
                            BuffSource::World,
                            *read_data.time,
@ -420,7 +420,6 @@ impl<'a> System<'a> for Sys {
                            execute_effect(
                                effect,
                                buff.kind,
-                                &buff.data,
                                buff.start_time,
                                kind_start_time,
                                &read_data,
@ -478,7 +477,6 @@ impl<'a> System<'a> for Sys {
 fn execute_effect(
    effect: &BuffEffect,
    buff_kind: BuffKind,
-    buff_data: &BuffData,
    buff_start_time: Time,
    buff_kind_start_time: Time,
    read_data: &ReadData,
@ -516,9 +514,7 @@ fn execute_effect(
        let prev_tick = ((time_passed - dt).max(0.0) / tick_dur.0).floor();
        let whole_ticks = curr_tick - prev_tick;

-        if buff_data.force_immediate {
-            Some((1.0 / tick_dur.0 * dt) as f32)
-        } else if buff_will_expire {
+        if buff_will_expire {
            // If the buff is ending, include the fraction of progress towards the next
            // tick.
            let fractional_tick = (time_passed % tick_dur.0) / tick_dur.0;
--- a/server/src/cmd.rs
+++ b/server/src/cmd.rs
@ -26,7 +26,7 @@ use common::{
    },
    comp::{
        self,
-        buff::{Buff, BuffData, BuffKind, BuffSource},
+        buff::{Buff, BuffData, BuffKind, BuffSource, MiscBuffData},
        inventory::{
            item::{tool::AbilityMap, MaterialStatManifest, Quality},
            slot::Slot,
@ -4140,25 +4140,110 @@ fn handle_buff(
    args: Vec<String>,
    action: &ServerChatCommand,
 ) -> CmdResult<()> {
-    if let (Some(buff), strength, duration) = parse_cmd_args!(args, String, f32, f64) {
+    let (Some(buff), strength, duration, misc_data_spec) =
+        parse_cmd_args!(args, String, f32, f64, String)
+    else {
+        return Err(Content::Plain(action.help_string()));
+    };
+
    let strength = strength.unwrap_or(0.01);
-        let duration = duration.unwrap_or(1.0);
+
+    if buff == "all" {
+        let duration = duration.unwrap_or(5.0);
        let buffdata = BuffData::new(strength, Some(Secs(duration)));
-        if buff != "all" {
-            cast_buff(&buff, buffdata, server, target)
-        } else {
-            for kind in BUFF_PACK.iter() {
-                cast_buff(kind, buffdata, server, target)?;
-            }
+
+        // apply every(*) non-complex buff
+        //
+        // (*) BUFF_PACK contains all buffs except
+        // invulnerability
+        BUFF_PACK
+            .iter()
+            .filter_map(|kind_key| parse_buffkind(kind_key))
+            .filter(|buffkind| buffkind.is_simple())
+            .for_each(|buffkind| cast_buff(buffkind, buffdata, server, target));
        Ok(())
-        }
    } else {
-        Err(Content::Plain(action.help_string()))
+        let buffkind = parse_buffkind(&buff).ok_or_else(|| {
+            Content::localized_with_args("command-buff-unknown", [("buff", buff.clone())])
+        })?;
+
+        if buffkind.is_simple() {
+            let duration = duration.unwrap_or(10.0);
+            let buffdata = BuffData::new(strength, Some(Secs(duration)));
+            cast_buff(buffkind, buffdata, server, target);
+            Ok(())
+        } else {
+            // default duration is longer for complex buffs
+            let duration = duration.unwrap_or(20.0);
+            let spec = misc_data_spec.ok_or_else(|| {
+                Content::localized_with_args("command-buff-data", [("buff", buff.clone())])
+            })?;
+            cast_buff_complex(buffkind, server, target, spec, strength, duration)
+        }
    }
 }

-fn cast_buff(kind: &str, data: BuffData, server: &mut Server, target: EcsEntity) -> CmdResult<()> {
-    if let Some(buffkind) = parse_buffkind(kind) {
+fn cast_buff_complex(
+    buffkind: BuffKind,
+    server: &mut Server,
+    target: EcsEntity,
+    spec: String,
+    strength: f32,
+    duration: f64,
+) -> CmdResult<()> {
+    // explicit match to remember that this function exists
+    let misc_data = match buffkind {
+        BuffKind::Polymorphed => {
+            let Ok(npc::NpcBody(_id, mut body)) = spec.parse() else {
+                return Err(Content::localized_with_args("command-buff-body-unknown", [
+                    ("spec", spec.clone()),
+                ]));
+            };
+            MiscBuffData::Body(body())
+        },
+        BuffKind::Regeneration
+        | BuffKind::Saturation
+        | BuffKind::Potion
+        | BuffKind::Agility
+        | BuffKind::CampfireHeal
+        | BuffKind::Frenzied
+        | BuffKind::EnergyRegen
+        | BuffKind::IncreaseMaxEnergy
+        | BuffKind::IncreaseMaxHealth
+        | BuffKind::Invulnerability
+        | BuffKind::ProtectingWard
+        | BuffKind::Hastened
+        | BuffKind::Fortitude
+        | BuffKind::Reckless
+        | BuffKind::Flame
+        | BuffKind::Frigid
+        | BuffKind::Lifesteal
+        | BuffKind::ImminentCritical
+        | BuffKind::Fury
+        | BuffKind::Sunderer
+        | BuffKind::Defiance
+        | BuffKind::Bloodfeast
+        | BuffKind::Berserk
+        | BuffKind::Bleeding
+        | BuffKind::Cursed
+        | BuffKind::Burning
+        | BuffKind::Crippled
+        | BuffKind::Frozen
+        | BuffKind::Wet
+        | BuffKind::Ensnared
+        | BuffKind::Poisoned
+        | BuffKind::Parried
+        | BuffKind::PotionSickness
+        | BuffKind::Heatstroke => unreachable!("is_simple() above"),
+    };
+
+    let buffdata = BuffData::new(strength, Some(Secs(duration))).with_misc_data(misc_data);
+
+    cast_buff(buffkind, buffdata, server, target);
+    Ok(())
+}
+
+fn cast_buff(buffkind: BuffKind, data: BuffData, server: &mut Server, target: EcsEntity) {
    let ecs = &server.state.ecs();
    let mut buffs_all = ecs.write_storage::<comp::Buffs>();
    let stats = ecs.read_storage::<comp::Stats>();
@ -4178,12 +4263,6 @@ fn cast_buff(kind: &str, data: BuffData, server: &mut Server, target: EcsEntity)
            *time,
        );
    }
-        Ok(())
-    } else {
-        Err(Content::localized_with_args("command-buff-unknown", [(
-            "buff", kind,
-        )]))
-    }
 }

 fn parse_buffkind(buff: &str) -> Option<BuffKind> { BUFF_PARSER.get(buff).copied() }