Merge pull request #544 from Vrixyz/291-weight-component

Weight logic to Knockback

Author: ozkriff

src/core/battle.rs

@@ -1,4 +1,4 @@
-use std::default::Default;
+use std::{default::Default, fmt};
 
 use serde::{Deserialize, Serialize};
 
@@ -43,6 +43,38 @@ pub struct Id(i32);
 #[derive(Serialize, Deserialize, Default, Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub struct Strength(pub i32);
 
+#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub enum Weight {
+    Normal = 0,
+    Heavy = 1,
+    Immovable = 2,
+}
+
+impl Default for Weight {
+    fn default() -> Self {
+        Weight::Normal
+    }
+}
+
+impl fmt::Display for Weight {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        match *self {
+            Weight::Normal => write!(f, "Normal"),
+            Weight::Heavy => write!(f, "Heavy"),
+            Weight::Immovable => write!(f, "Immovable"),
+        }
+    }
+}
+
+#[derive(Serialize, Deserialize, Default, Clone, Copy, Debug, PartialEq, PartialOrd)]
+pub struct PushStrength(pub Weight);
+
+impl PushStrength {
+    pub fn can_push(self, weight: Weight) -> bool {
+        weight != Weight::Immovable && self.0 >= weight
+    }
+}
+
 #[derive(Serialize, Deserialize, Default, Clone, Copy, Debug, PartialEq, PartialOrd)]
 pub struct Attacks(pub i32);
 

src/core/battle/ability.rs

@@ -3,14 +3,14 @@ use std::fmt;
 use serde::{Deserialize, Serialize};
 
 use crate::core::{
-    battle::{Attacks, Strength},
+    battle::{Attacks, PushStrength, Strength},
     map::Distance,
 };
 
 /// Active ability.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, derive_more::From)]
 pub enum Ability {
-    Knockback,
+    Knockback(Knockback),
     Club,
     Jump(Jump),
     Poison,
@@ -31,6 +31,12 @@ pub enum Ability {
     Bloodlust,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+pub struct Knockback {
+    #[serde(default)]
+    pub strength: PushStrength,
+}
+
 // TODO: use named fields?
 #[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
 pub struct Jump(pub Distance);
@@ -92,7 +98,7 @@ pub struct RechargeableAbility {
 impl fmt::Display for Ability {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            Ability::Knockback => write!(f, "Knockback"),
+            Ability::Knockback(a) => write!(f, "Knockback-{}", a.strength.0),
             Ability::Club => write!(f, "Club"),
             Ability::Jump(a) => write!(f, "Jump-{}", (a.0).0),
             Ability::Poison => write!(f, "Poison"),

src/core/battle/check.rs

@@ -101,7 +101,7 @@ fn check_command_use_ability(state: &State, command: &command::UseAbility) -> Re
     check_agent_can_attack(state, command.id)?;
     check_agent_ability_ready(state, command.id, &command.ability)?;
     match command.ability {
-        Ability::Knockback => check_ability_knockback(state, command.id, command.pos),
+        Ability::Knockback(a) => check_ability_knockback(state, command.id, command.pos, a),
         Ability::Club => check_ability_club(state, command.id, command.pos),
         Ability::Jump(a) => check_ability_jump(state, command.id, command.pos, a),
         Ability::Poison => check_ability_poison(state, command.id, command.pos),
@@ -123,7 +123,12 @@ fn check_command_use_ability(state: &State, command: &command::UseAbility) -> Re
     }
 }
 
-fn check_ability_knockback(state: &State, id: Id, pos: PosHex) -> Result<(), Error> {
+fn check_ability_knockback(
+    state: &State,
+    id: Id,
+    pos: PosHex,
+    _: ability::Knockback,
+) -> Result<(), Error> {
     let selected_pos = state.parts().pos.get(id).0;
     check_min_distance(selected_pos, pos, Distance(1))?;
     check_max_distance(selected_pos, pos, Distance(1))?;

src/core/battle/component.rs

@@ -17,7 +17,10 @@ pub struct Pos(pub map::PosHex);
 
 /// Blocks the whole tile. Two blocker objects can't coexist in one tile.
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
-pub struct Blocker;
+pub struct Blocker {
+    #[serde(default)]
+    pub weight: battle::Weight,
+}
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct Strength {

src/core/battle/effect.rs

@@ -3,7 +3,7 @@ use serde::{Deserialize, Serialize};
 use crate::core::{
     battle::{
         component::{Component, ObjType},
-        Phase, PosHex, Strength,
+        Phase, PosHex, PushStrength, Strength,
     },
     map::Dir,
 };
@@ -110,6 +110,7 @@ pub struct Create {
 pub struct FlyOff {
     pub from: PosHex,
     pub to: PosHex,
+    pub strength: PushStrength,
 }
 
 #[derive(Clone, Debug, Deserialize, PartialEq)]
@@ -127,4 +128,5 @@ pub struct Dodge {
 pub struct Knockback {
     pub from: PosHex,
     pub to: PosHex,
+    pub strength: PushStrength,
 }

src/core/battle/execute.rs

@@ -14,7 +14,7 @@ use crate::core::{
         event::{self, ActiveEvent, Event},
         movement::Path,
         state::{self, BattleResult, State},
-        Id, Moves, Phase, PlayerId, Strength,
+        Id, Moves, Phase, PlayerId, PushStrength, Strength, Weight,
     },
     map::{self, Dir, PosHex},
     utils,
@@ -369,9 +369,16 @@ fn try_execute_passive_abilities_on_attack(
                 PassiveAbility::HeavyImpact => {
                     let dir = Dir::get_dir_from_to(attacker_pos, target_pos);
                     let from = target_pos;
-                    let to = Dir::get_neighbor_pos(target_pos, dir);
-                    if state.map().is_inboard(to) && !state::is_tile_blocked(state, to) {
-                        let effect = effect::FlyOff { from, to }.into();
+                    let strength = PushStrength(Weight::Normal);
+                    let blocker_weight = state.parts().blocker.get(target_id).weight;
+                    let to = if strength.can_push(blocker_weight) {
+                        Dir::get_neighbor_pos(target_pos, dir)
+                    } else {
+                        from
+                    };
+                    let is_inboard = state.map().is_inboard(to);
+                    if to == from || is_inboard && !state::is_tile_blocked(state, to) {
+                        let effect = effect::FlyOff { from, to, strength }.into();
                         effects.instant.push(effect);
                     }
                 }
@@ -673,15 +680,22 @@ impl ExecuteContext {
 fn execute_use_ability_knockback(
     state: &mut State,
     command: &command::UseAbility,
+    ability: ability::Knockback,
 ) -> ExecuteContext {
     let mut context = ExecuteContext::default();
     let id = state::blocker_id_at(state, command.pos);
     let from = command.pos;
+    let strength = ability.strength;
     let actor_pos = state.parts().pos.get(command.id).0;
     let dir = Dir::get_dir_from_to(actor_pos, command.pos);
-    let to = Dir::get_neighbor_pos(command.pos, dir);
-    if state.map().is_inboard(to) && !state::is_tile_blocked(state, to) {
-        let effect = effect::Knockback { from, to }.into();
+    let blocker_weight = state.parts().blocker.get(id).weight;
+    let to = if strength.can_push(blocker_weight) {
+        Dir::get_neighbor_pos(command.pos, dir)
+    } else {
+        from
+    };
+    if to == from || state.map().is_inboard(to) && !state::is_tile_blocked(state, to) {
+        let effect = effect::Knockback { from, to, strength }.into();
         context.instant_effects.push((id, vec![effect]));
         context.moved_actor_ids.push(id);
     }
@@ -936,11 +950,21 @@ fn execute_use_ability_explode_push(
         if distance.0 > 1 || command.id == id {
             continue;
         }
+        let blocker_weight = state.parts().blocker.get(id).weight;
         let dir = Dir::get_dir_from_to(from, pos);
-        let to = Dir::get_neighbor_pos(pos, dir);
+        let to = if PushStrength(Weight::Normal).can_push(blocker_weight) {
+            Dir::get_neighbor_pos(pos, dir)
+        } else {
+            pos
+        };
         let mut effects = Vec::new();
-        if state.map().is_inboard(to) && !state::is_tile_blocked(state, to) {
-            effects.push(effect::Knockback { from: pos, to }.into());
+        if to == pos || (state.map().is_inboard(to) && !state::is_tile_blocked(state, to)) {
+            let effect = effect::Knockback {
+                from: pos,
+                to,
+                strength: PushStrength(Weight::Normal),
+            };
+            effects.push(effect.into());
             context.moved_actor_ids.push(id);
         }
         context.instant_effects.push((id, effects));
@@ -1126,7 +1150,7 @@ fn execute_use_ability_bloodlust(
 
 fn execute_use_ability(state: &mut State, cb: Cb, command: &command::UseAbility) {
     let mut context = match command.ability {
-        Ability::Knockback => execute_use_ability_knockback(state, command),
+        Ability::Knockback(a) => execute_use_ability_knockback(state, command, a),
         Ability::Club => execute_use_ability_club(state, command),
         Ability::Jump(_) => execute_use_ability_jump(state, command),
         Ability::Dash => execute_use_ability_dash(state, command),

src/core/battle/state/apply.rs

@@ -338,15 +338,20 @@ fn apply_effect_wound(state: &mut State, id: Id, effect: &effect::Wound) {
 
 fn apply_effect_knockback(state: &mut State, id: Id, effect: &effect::Knockback) {
     assert!(state.map().is_inboard(effect.from));
+    if effect.to == effect.from {
+        return;
+    }
     assert!(state.map().is_inboard(effect.to));
     assert!(!state::is_tile_blocked(state, effect.to));
     let parts = state.parts_mut();
     parts.pos.get_mut(id).0 = effect.to;
-    // TODO: push anyone who's in the way aside
 }
 
 fn apply_effect_fly_off(state: &mut State, id: Id, effect: &effect::FlyOff) {
     assert!(state.map().is_inboard(effect.from));
+    if effect.to == effect.from {
+        return;
+    }
     assert!(state.map().is_inboard(effect.to));
     assert!(!state::is_tile_blocked(state, effect.to));
     let parts = state.parts_mut();