added combat persistence to ensure we dont end combat too soon

thogard785 · thogard785 · commit bb8ab3af410b · 2025-07-10T04:52:26.000-07:00
diff --git a/src/battle-nads/Balances.sol b/src/battle-nads/Balances.sol
@@ -170,7 +170,7 @@ abstract contract Balances is GasRelayWithScheduling, Instances {
             revert Errors.InvalidCaller(msg.sender);
         }
         if (_oldOwner != combatant.owner || combatant.owner != key.owner) {
-            if (revertIfInvalid) {
+            if (revertIfInvalid && !combatant.isDead()) {
                 revert Errors.InvalidCaller(msg.sender);
             }
             _deactivateSessionKey(msg.sender);
diff --git a/src/battle-nads/Constants.sol b/src/battle-nads/Constants.sol
@@ -69,9 +69,9 @@ contract Constants {
     uint8 internal constant NO_COMBAT_ZONE_SPACING = 5;
     uint256 internal constant RESERVED_BOSS_INDEX = 1;
 
-    uint256 internal constant DAMAGE_DILUTION_FACTOR = 620;
-    uint256 internal constant ABILITY_DILUTION_FACTOR = 780;
-    uint256 internal constant HEALING_DILUTION_FACTOR = 420;
+    uint256 internal constant DAMAGE_DILUTION_FACTOR = 760;
+    uint256 internal constant ABILITY_DILUTION_FACTOR = 880;
+    uint256 internal constant HEALING_DILUTION_FACTOR = 460;
     uint256 internal constant DAMAGE_DILUTION_BASE = 1000;
 
     // BALANCES
diff --git a/src/battle-nads/Handler.sol b/src/battle-nads/Handler.sol
@@ -158,8 +158,6 @@ abstract contract Handler is Balances {
             monster = _loadExistingMonster(player, monsterIndex);
         }
 
-        // Flag for combat
-        (monster, player) = _enterMutualCombatToTheDeath(monster, player);
         if (monster.isDead()) {
             player = _exitCombat(player);
             player.stats.nextTargetIndex = 0;
@@ -168,19 +166,23 @@ abstract contract Handler is Balances {
             return player;
         }
 
+        // Flag for combat
+        (monster, player) = _enterMutualCombatToTheDeath(monster, player);
+
         // Create tasks
         bool scheduledTask = false;
 
         // Only create for monster if task doesn't already exist
         if (newMonster) {
             uint256 targetBlock = block.number + _cooldown(monster.stats) + COMBAT_COLD_START_DELAY_MONSTER;
             (monster, scheduledTask) = _createOrRescheduleCombatTask(monster, targetBlock);
-            if (!scheduledTask) {
-                monster.owner = _EMPTY_ADDRESS;
+            if (scheduledTask) {
+                monster.owner = player.owner;
                 monster.tracker.updateOwner = true;
+            } else {
                 emit Events.TaskNotScheduledInHandler(3, monster.id, block.number, targetBlock);
             }
-        } else {
+        } else if (!monster.isDead()) {
             // If task is no longer active, start a new one
             (scheduledTask,) = _checkClearTasks(monster);
             if (!scheduledTask || !_isValidAddress(monster.owner)) {
@@ -316,19 +318,17 @@ abstract contract Handler is Balances {
         // Create tasks
         // Only create for attacker and defendant if tasks don't already exist
         (bool scheduledTask,) = _checkClearTasks(defender);
-        if (defender.isMonster()) {
+        if (defender.isMonster() && !defender.isDead()) {
             if (!scheduledTask || !_isValidAddress(defender.owner)) {
-                if (!scheduledTask) {
-                    (defender, scheduledTask) =
-                        _createOrRescheduleCombatTask(defender, block.number + _cooldown(defender.stats));
-                    if (scheduledTask) {
-                        defender.owner = attacker.owner;
-                        defender.tracker.updateOwner = true;
-                    } else {
-                        emit Events.TaskNotScheduledInHandler(
-                            1, defender.id, block.number, block.number + _cooldown(defender.stats)
-                        );
-                    }
+                (defender, scheduledTask) =
+                    _createOrRescheduleCombatTask(defender, block.number + _cooldown(defender.stats));
+                if (scheduledTask) {
+                    defender.owner = attacker.owner;
+                    defender.tracker.updateOwner = true;
+                } else {
+                    emit Events.TaskNotScheduledInHandler(
+                        1, defender.id, block.number, block.number + _cooldown(defender.stats)
+                    );
                 }
             }
         }
@@ -533,13 +533,11 @@ abstract contract Handler is Balances {
         // If it's a monster, update defender's owner to n
         // Only do this if there was a funding issue with prev task
 
-        if (defender.isMonster() && !attacker.isMonster()) {
-            if (defender.owner != attacker.owner && _isValidAddress(defender.owner)) {
-                (bool hasActiveCombatTask,) = _checkClearTasks(defender);
-                if (!hasActiveCombatTask) {
-                    defender.owner = _EMPTY_ADDRESS;
-                    defender.tracker.updateOwner = true;
-                }
+        if (!defender.isDead() && defender.isMonster() && !attacker.isMonster() && _isValidAddress(defender.owner)) {
+            (bool hasActiveCombatTask,) = _checkClearTasks(defender);
+            if (!hasActiveCombatTask && !defender.isDead()) {
+                defender.owner = _EMPTY_ADDRESS;
+                defender.tracker.updateOwner = true;
             }
         }
 
@@ -554,13 +552,12 @@ abstract contract Handler is Balances {
             // This prevents the bug where the wrong player would be stored later
             if (
                 _isValidID(newDefender.id) && newDefender.id != defender.id && newDefender.id != attacker.id
-                    && !defender.isDead()
+                    && !newDefender.isDead()
             ) {
-                defender = newDefender;
-            } else {
-                // Set defender to empty so we don't store it again at line 526
-                defender.id = bytes32(0);
+                _storeBattleNad(newDefender);
             }
+        } else {
+            _storeBattleNad(defender);
         }
 
         // Handle health regen and storage, then return the necessary data
@@ -584,12 +581,6 @@ abstract contract Handler is Balances {
         // Store area
         _storeArea(area, attacker.stats.depth, attacker.stats.x, attacker.stats.y);
 
-        // Store defender (if valid)
-        // Dead defenders were already stored in _processDeathDuringKillerTurn
-        if (_isValidID(defender.id)) {
-            _storeBattleNad(defender);
-        }
-
         return (attacker, reschedule, nextExecutionBlock);
     }
 
@@ -743,7 +734,7 @@ abstract contract Handler is Balances {
             if (!attackerInCombat || !defenderInCombat) {
                 (attacker, defender) = _enterMutualCombatToTheDeath(attacker, defender);
             }
-            if (defender.isMonster() && !attacker.isMonster()) {
+            if (!defender.isDead() && defender.isMonster() && !attacker.isMonster()) {
                 if (!_isTask()) {
                     (bool scheduledTask,) = _checkClearTasks(defender);
                     if (!scheduledTask || !_isValidAddress(defender.owner)) {
diff --git a/src/battle-nads/MonsterFactory.sol b/src/battle-nads/MonsterFactory.sol
@@ -37,10 +37,13 @@ abstract contract MonsterFactory is CharacterFactory {
 
         // Most recent player to enter combat with the monster is its 'owner'
         address owner = owners[monster.id];
+        monster.owner = owner;
+        /*
         monster.owner = player.owner;
         if (monster.owner != owner) {
             monster.tracker.updateOwner = true;
         }
+        */
 
         // Return monster
         return monster;
@@ -88,8 +91,11 @@ abstract contract MonsterFactory is CharacterFactory {
         monster.tracker.updateStats = true;
 
         // Update the owner
-        monster.owner = player.owner;
-        owners[monster.id] = player.owner;
+        // monster.owner = player.owner;
+        // owners[monster.id] = player.owner;
+        monster.owner = _EMPTY_ADDRESS;
+        //monster.tracker.updateOwner = true;
+        //owners[monster.id] = _EMPTY_ADDRESS;
         characterTasks[monster.id] = _NULL_ID;
         killMap[monster.id] = _UNKILLED;
 
diff --git a/src/battle-nads/TaskHandler.sol b/src/battle-nads/TaskHandler.sol
@@ -67,13 +67,21 @@ contract TaskHandler is Handler, GeneralReschedulingTask {
         uint256 targetBlock;
         (attacker, reschedule, targetBlock) = _handleCombatTurn(attacker);
 
-        reschedule = _validatePersistOwnerDuringTask(attacker, false);
+        // If attacker exited combat then the keys are invalidated at that point
+        if (attacker.isInCombat()) {
+            reschedule = _validatePersistOwnerDuringTask(attacker, false);
+        }
 
         // Set reschedule lock for reimbursement call afterwards
         if (reschedule) {
             (attacker, reschedule) = _createOrRescheduleCombatTask(attacker, targetBlock);
             if (!reschedule) {
                 emit Events.TaskNotScheduledInTaskHandler(20, attacker.id, block.number, targetBlock);
+                if (attacker.isMonster()) {
+                    attacker.owner = _EMPTY_ADDRESS;
+                    attacker.tracker.updateOwner = true;
+                    _clearActiveTask(characterID);
+                }
             }
         } else {
             _clearActiveTask(characterID);
@@ -208,7 +216,11 @@ contract TaskHandler is Handler, GeneralReschedulingTask {
         returns (BattleNad memory, bool)
     {
         if (!_isValidAddress(combatant.owner)) {
-            revert Errors.CharacterNotOwned(combatant.id);
+            if (_isTask()) {
+                return (combatant, false);
+            } else if (!combatant.isMonster()) {
+                revert Errors.CharacterNotOwned(combatant.id);
+            }
         }
 
         // Calculate the maximum payment
@@ -347,15 +359,22 @@ contract TaskHandler is Handler, GeneralReschedulingTask {
             return combatant;
         }
 
+        if (!_isValidAddress(combatant.owner)) {
+            _clearActiveTask(combatant.id);
+            if (!combatant.isMonster()) {
+                AbilityTracker memory activeAbility = _loadAbility(combatant.id);
+                if (_isValidAddress(activeAbility.taskAddress)) {
+                    combatant = _checkClearAbility(combatant);
+                }
+            }
+            return combatant;
+        }
+
         bytes32 taskID = _loadActiveTaskID(combatant.id);
         address activeTask = address(uint160(uint256(taskID)));
 
         combatant.activeTask.taskAddress = activeTask;
 
-        if (!_isValidAddress(combatant.owner)) {
-            combatant.owner = _loadOwner(combatant.id);
-        }
-
         if (_isValidAddress(activeTask)) {
             _clearActiveTask(combatant.id);
             combatant.activeTask.taskAddress = _EMPTY_ADDRESS;
@@ -389,6 +408,8 @@ contract TaskHandler is Handler, GeneralReschedulingTask {
             return (hasActiveCombatTask, activeTask);
         }
 
+        if (!!_isValidAddress(combatant.owner)) { }
+
         bytes32 taskID = _loadActiveTaskID(combatant.id);
         activeTask = address(uint160(uint256(taskID)));
 
diff --git a/test/battle-nads/BattleNads.t.sol b/test/battle-nads/BattleNads.t.sol
@@ -79,7 +79,7 @@ contract BattleNadsTest is BattleNadsBaseTest {
         _rollForward(1);	
 
         uint256 i = 0;	
-        while (i < 100) {	
+        while (i < 8) {	
             uint256 remainder = i % 4;	
 
             if (remainder == 0) {	
@@ -133,7 +133,7 @@ contract BattleNadsTest is BattleNadsBaseTest {
         vm.prank(userSessionKey3);	
         battleNads.attack(character3, uint256(monster.stats.index));
 
-        while (i < 100) {	
+        while (i < 18) {	
 
             player = _battleNad(3);	
             monster = _battleNad(opponentID);	

Original file line number	Diff line number	Diff line change
`@@ -170,7 +170,7 @@ abstract contract Balances is GasRelayWithScheduling, Instances {`
`170`	`170`	`revert Errors.InvalidCaller(msg.sender);`
`171`	`171`	`}`
`172`	`172`	`if (_oldOwner != combatant.owner \|\| combatant.owner != key.owner) {`
`173`		`- if (revertIfInvalid) {`
	`173`	`+ if (revertIfInvalid && !combatant.isDead()) {`
`174`	`174`	`revert Errors.InvalidCaller(msg.sender);`
`175`	`175`	`}`
`176`	`176`	`_deactivateSessionKey(msg.sender);`