feat: add battle system (#156)

manlikeHB · web-flow · commit 57b5aa352d2d · 2025-06-29T11:42:14.000-06:00
diff --git a/backend/dojo_examples/combat_game/.tool-versions b/backend/dojo_examples/combat_game/.tool-versions
@@ -1,2 +1,2 @@
-dojo 1.1.1
+dojo 1.2.1
 scarb 2.9.2
diff --git a/backend/dojo_examples/combat_game/src/achievements/achievement.cairo b/backend/dojo_examples/combat_game/src/achievements/achievement.cairo
@@ -112,7 +112,8 @@ pub impl AchievementImpl of AchievementTrait {
     fn tasks(self: Achievement) -> Span<Task> {
         match self {
             Achievement::None => [].span(),
-            Achievement::FirstBlood => array![TaskTrait::new('First Blood', 1, "Win a game")].span(),
+            Achievement::FirstBlood => array![TaskTrait::new('First Blood', 1, "Win a game")]
+                .span(),
             Achievement::Warrior => array![TaskTrait::new('Warrior', 5, "Win 5 games")].span(),
             Achievement::Veteran => array![TaskTrait::new('Veteran', 15, "Win 15 games")].span(),
             Achievement::Champion => array![TaskTrait::new('Champion', 30, "Win 30 games")].span(),
@@ -164,4 +165,4 @@ pub impl IntoU8Achievement of Into<u8, Achievement> {
             _ => Achievement::None,
         }
     }
-}
+}
diff --git a/backend/dojo_examples/combat_game/src/helpers/experience_utils.cairo b/backend/dojo_examples/combat_game/src/helpers/experience_utils.cairo
@@ -2,7 +2,7 @@ pub trait ExperienceCalculator {
     fn calculate_exp_needed_for_level(level: u8) -> u16;
 
     fn should_level_up(current_level: u8, current_exp: u16) -> bool;
-    
+
     fn remaining_exp_after_level_up(current_level: u8, current_exp: u16) -> u16;
 }
 
@@ -19,21 +19,18 @@ pub impl ExperienceCalculatorImpl of ExperienceCalculator {
     fn remaining_exp_after_level_up(current_level: u8, current_exp: u16) -> u16 {
         if current_exp >= (current_level.into() * current_level.into() * 10_u16) {
             current_exp - (current_level.into() * current_level.into() * 10_u16)
-        }
-
-        else {
+        } else {
             current_exp
         }
     }
 }
 
 #[cfg(test)]
 mod test {
-    
     use super::ExperienceCalculatorImpl;
 
     #[test]
-    fn test_calculate_exp_needed_for_level(){
+    fn test_calculate_exp_needed_for_level() {
         let level_1: u8 = 1;
         let level_2: u8 = 2;
         let level_5: u8 = 5;
@@ -46,75 +43,241 @@ mod test {
         let exp_needed_for_level_10: u16 = 1000;
         let exp_needed_for_level_20: u16 = 4000;
 
-        assert_eq!(ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_1), exp_needed_for_level_1, "Experience needed for level 1 should be 10");
-        assert_eq!(ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_2), exp_needed_for_level_2, "Experience needed for level 2 should be 40");
-        assert_eq!(ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_5), exp_needed_for_level_5, "Experience needed for level 5 should be 250");
-        assert_eq!(ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_10), exp_needed_for_level_10, "Experience needed for level 10 should be 1000");
-        assert_eq!(ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_20), exp_needed_for_level_20, "Experience needed for level 10 should be 1000");
+        assert_eq!(
+            ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_1),
+            exp_needed_for_level_1,
+            "Experience needed for level 1 should be 10",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_2),
+            exp_needed_for_level_2,
+            "Experience needed for level 2 should be 40",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_5),
+            exp_needed_for_level_5,
+            "Experience needed for level 5 should be 250",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_10),
+            exp_needed_for_level_10,
+            "Experience needed for level 10 should be 1000",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::calculate_exp_needed_for_level(level_20),
+            exp_needed_for_level_20,
+            "Experience needed for level 10 should be 1000",
+        );
     }
 
     #[test]
-    fn should_level_up_test(){
+    fn should_level_up_test() {
         let level_1: u8 = 1;
         let level_2: u8 = 2;
         let level_5: u8 = 5;
         let level_10: u8 = 10;
         let level_20: u8 = 20;
 
+        ///For each level instance test  there is an instance of the exact exp needed to level up,
+        ///currentexp greater the exp needed to level up, currentexp is less than what is needed.
 
-        ///For each level instance test  there is an instance of the exact exp needed to level up, currentexp greater the exp needed to level up, 
-        ///currentexp is less than what is needed.
-
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_1, current_exp: 10), true, "Should pass, exp needed to level up is 10");
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_1, current_exp: 11), true, "Should pass, exp needed to level up is 10");
-        assert_ne!(ExperienceCalculatorImpl::should_level_up(current_level: level_1, current_exp: 9), true, "Should pass, exp needed to level up is 10");
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_1, current_exp: 10),
+            true,
+            "Should pass, exp needed to level up is 10",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_1, current_exp: 11),
+            true,
+            "Should pass, exp needed to level up is 10",
+        );
+        assert_ne!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_1, current_exp: 9),
+            true,
+            "Should pass, exp needed to level up is 10",
+        );
 
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_2, current_exp: 41), true, "Should pass, exp needed to level up is 40");
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_2, current_exp: 40), true, "Should pass, exp needed to level up is 40");
-        assert_ne!(ExperienceCalculatorImpl::should_level_up(current_level: level_2, current_exp: 39), true, "Should pass, exp needed to level up is 40");
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_2, current_exp: 41),
+            true,
+            "Should pass, exp needed to level up is 40",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_2, current_exp: 40),
+            true,
+            "Should pass, exp needed to level up is 40",
+        );
+        assert_ne!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_2, current_exp: 39),
+            true,
+            "Should pass, exp needed to level up is 40",
+        );
 
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_5, current_exp: 250), true, "Should pass, exp needed to level up is 250");
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_5, current_exp: 251), true, "Should pass, exp needed to level up is 250");
-        assert_ne!(ExperienceCalculatorImpl::should_level_up(current_level: level_5, current_exp: 249), true, "Should pass, exp needed to level up is 250");
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_5, current_exp: 250),
+            true,
+            "Should pass, exp needed to level up is 250",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_5, current_exp: 251),
+            true,
+            "Should pass, exp needed to level up is 250",
+        );
+        assert_ne!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_5, current_exp: 249),
+            true,
+            "Should pass, exp needed to level up is 250",
+        );
 
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_10, current_exp: 1000), true, "Should pass, exp needed to level up is 100");
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_10, current_exp: 1001), true, "Should pass, exp needed to level up is 100");
-        assert_ne!(ExperienceCalculatorImpl::should_level_up(current_level: level_10, current_exp: 999), true, "Should pass, exp needed to level up is 100");
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_10, current_exp: 1000),
+            true,
+            "Should pass, exp needed to level up is 100",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_10, current_exp: 1001),
+            true,
+            "Should pass, exp needed to level up is 100",
+        );
+        assert_ne!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_10, current_exp: 999),
+            true,
+            "Should pass, exp needed to level up is 100",
+        );
 
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_20, current_exp: 4000), true, "Should pass, exp needed to level up is 4000");
-        assert_eq!(ExperienceCalculatorImpl::should_level_up(current_level: level_20, current_exp: 4001), true, "Should pass, exp needed to level up is 4000");
-        assert_ne!(ExperienceCalculatorImpl::should_level_up(current_level: level_20, current_exp: 3999), true, "Should pass, exp needed to level up is 4000");         
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_20, current_exp: 4000),
+            true,
+            "Should pass, exp needed to level up is 4000",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_20, current_exp: 4001),
+            true,
+            "Should pass, exp needed to level up is 4000",
+        );
+        assert_ne!(
+            ExperienceCalculatorImpl::should_level_up(current_level: level_20, current_exp: 3999),
+            true,
+            "Should pass, exp needed to level up is 4000",
+        );
     }
 
     #[test]
-    fn remaining_exp_after_level_up_test(){
+    fn remaining_exp_after_level_up_test() {
         let level_1: u8 = 1;
         let level_2: u8 = 2;
         let level_5: u8 = 5;
         let level_10: u8 = 10;
         let level_20: u8 = 20;
 
-    
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_1, current_exp: 12,
+            ),
+            2,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_1, current_exp: 17,
+            ),
+            7,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_1, current_exp: 8,
+            ),
+            8,
+            "The remaining exp should be current_exp - exp_needed",
+        );
 
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_1, current_exp: 12), 2, "The remaining exp should be current_exp - exp_needed"); 
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_1, current_exp: 17), 7, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_1, current_exp:8), 8, "The remaining exp should be current_exp - exp_needed");
-        
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_2, current_exp:44), 4, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_2, current_exp:160), 120, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_2, current_exp: 32), 32, "The remaining exp should be current_exp - exp_needed");
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_2, current_exp: 44,
+            ),
+            4,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_2, current_exp: 160,
+            ),
+            120,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_2, current_exp: 32,
+            ),
+            32,
+            "The remaining exp should be current_exp - exp_needed",
+        );
 
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_5, current_exp: 260), 10, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_5, current_exp: 400), 150, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_5, current_exp: 200), 200, "The remaining exp should be current_exp - exp_needed");
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_5, current_exp: 260,
+            ),
+            10,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_5, current_exp: 400,
+            ),
+            150,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_5, current_exp: 200,
+            ),
+            200,
+            "The remaining exp should be current_exp - exp_needed",
+        );
 
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_10, current_exp:  1020), 20, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_10, current_exp:  2000), 1000, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_10, current_exp:  950), 950, "The remaining exp should be current_exp - exp_needed");
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_10, current_exp: 1020,
+            ),
+            20,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_10, current_exp: 2000,
+            ),
+            1000,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_10, current_exp: 950,
+            ),
+            950,
+            "The remaining exp should be current_exp - exp_needed",
+        );
 
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_20, current_exp:  4100), 100, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_20, current_exp:  4700), 700, "The remaining exp should be current_exp - exp_needed");
-        assert_eq!(ExperienceCalculatorImpl::remaining_exp_after_level_up(current_level: level_20, current_exp:  3800), 3800, "The remaining exp should be current_exp - exp_needed");
-        
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_20, current_exp: 4100,
+            ),
+            100,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_20, current_exp: 4700,
+            ),
+            700,
+            "The remaining exp should be current_exp - exp_needed",
+        );
+        assert_eq!(
+            ExperienceCalculatorImpl::remaining_exp_after_level_up(
+                current_level: level_20, current_exp: 3800,
+            ),
+            3800,
+            "The remaining exp should be current_exp - exp_needed",
+        );
     }
 }
diff --git a/backend/dojo_examples/combat_game/src/lib.cairo b/backend/dojo_examples/combat_game/src/lib.cairo
@@ -41,4 +41,6 @@ pub mod achievements {
     pub mod achievement;
 }
 
-pub mod tests {}
+pub mod tests {
+    mod test_battle;
+}
diff --git a/backend/dojo_examples/combat_game/src/store.cairo b/backend/dojo_examples/combat_game/src/store.cairo
@@ -4,7 +4,8 @@ use combat_game::{
     constants::SECONDS_PER_DAY,
     models::{
         player::Player, beast::{Beast, BeastTrait}, skill, skill::{Skill, SkillTrait},
-        beast_skill::BeastSkill, beast_stats::{BeastStats, BeastStatsActionTrait}, battle::{Battle, BattleTrait},
+        beast_skill::BeastSkill, beast_stats::{BeastStats, BeastStatsActionTrait},
+        battle::{Battle, BattleTrait},
     },
     types::{
         beast_type::BeastType, skill::SkillType, status_condition::StatusCondition,
@@ -20,7 +21,7 @@ struct Store {
 }
 
 #[generate_trait]
-impl StoreImpl of StoreTrait {
+pub impl StoreImpl of StoreTrait {
     fn new(world: WorldStorage) -> Store {
         Store { world: world }
     }
@@ -242,7 +243,9 @@ impl StoreImpl of StoreTrait {
     fn create_rematch(ref self: Store, battle_id: u256) -> Battle {
         let battle = self.read_battle(battle_id);
 
-        let rematch = BattleTrait::new(battle_id, battle.player1, battle.player2, battle.battle_type);
+        let rematch = BattleTrait::new(
+            battle_id, battle.player1, battle.player2, battle.battle_type,
+        );
         self.world.write_model(@rematch);
         rematch
     }
diff --git a/backend/dojo_examples/combat_game/src/systems/battle.cairo b/backend/dojo_examples/combat_game/src/systems/battle.cairo
diff --git a/backend/dojo_examples/combat_game/src/tests/test_battle.cairo b/backend/dojo_examples/combat_game/src/tests/test_battle.cairo

Original file line number	Diff line number	Diff line change
`@@ -1,2 +1,2 @@`
`1`		`-dojo 1.1.1`
	`1`	`+dojo 1.2.1`
`2`	`2`	`scarb 2.9.2`
Original file line number	Diff line number	Diff line change
`@@ -41,4 +41,6 @@ pub mod achievements {`
`41`	`41`	`pub mod achievement;`
`42`	`42`	`}`
`43`	`43`
`44`		`-pub mod tests {}`
	`44`	`+pub mod tests {`
	`45`	`+ mod test_battle;`
	`46`	`+}`