Backup before cleanup

2026-02-05 15:00:49 +01:00
parent e6747b1d05
commit 1b7ffd614d
60 changed files with 3013 additions and 460 deletions
--- a/api/game_logic.py
+++ b/api/game_logic.py
@@ -335,6 +335,55 @@ async def use_item(player_id: int, item_id: str, items_manager, locale: str = 'e
    effects = {}
    effects_msg = []
    
+    # 1. Apply Status Effects (e.g. Regeneration from Bandage)
+    if 'status_effect' in item.effects:
+        status_data = item.effects['status_effect']
+        
+        # Check if effect already exists
+        current_effects = await db.get_player_effects(player_id)
+        effect_name = status_data['name']
+        
+        # Handle potential dict/string difference in validation (db stores as string usually)
+        # But we need to compare with what's in the DB.
+        # DB get_player_effects returns list of dicts with 'effect_name' key.
+        
+        is_active = False
+        for effect in current_effects:
+            # Simple string comparison should suffice as both should be localized keys or raw strings
+            if effect['effect_name'] == effect_name:
+                is_active = True
+                break
+        
+        if is_active:
+             return {"success": False, "message": get_game_message('effect_already_active', locale)}
+
+        await db.add_effect(
+            player_id=player['id'],
+            effect_name=status_data['name'],
+            effect_icon=status_data.get('icon', '✨'),
+            effect_type=status_data.get('type', 'buff'),
+            damage_per_tick=status_data.get('damage_per_tick', 0),
+            value=status_data.get('value', 0),
+            ticks_remaining=status_data.get('ticks', 3),
+            persist_after_combat=True, # Consumable effects usually persist
+            source=f"item:{item.id}"
+        )
+        effects['status_applied'] = status_data['name']
+        effects_msg.append(f"Applied {get_locale_string(status_data['name'], locale) if isinstance(status_data['name'], dict) else status_data['name']}")
+
+    # 2. Cure Status Effects
+    if 'cures' in item.effects:
+        cures = item.effects['cures']
+        cured_list = []
+        for cure_effect in cures:
+            if await db.remove_effect(player['id'], cure_effect):
+                cured_list.append(cure_effect)
+        
+        if cured_list:
+            effects['cured'] = cured_list
+            effects_msg.append(f"{get_game_message('cured', locale)}: {', '.join(cured_list)}")
+
+    # 3. Direct Healing (Legacy/Instant)
    if 'hp_restore' in item.effects:
        hp_restore = item.effects['hp_restore']
        old_hp = player['hp']
@@ -496,15 +545,17 @@ async def check_and_apply_level_up(player_id: int) -> Dict[str, Any]:
 # STATUS EFFECTS UTILITIES
 # ============================================================================

-def calculate_status_damage(effects: list) -> int:
+def calculate_status_impact(effects: list) -> int:
    """
-    Calculate total damage from all status effects.
+    Calculate total impact from all status effects.
+    Positive value = Damage
+    Negative value = Healing
    
    Args:
        effects: List of status effect dicts
    
    Returns:
-        Total damage per tick
+        Total impact per tick
    """
    return sum(effect.get('damage_per_tick', 0) for effect in effects)

@@ -513,8 +564,6 @@ def calculate_status_damage(effects: list) -> int:
 # COMBAT UTILITIES
 # ============================================================================

-    return message, player_defeated
-

 def generate_npc_intent(npc_def, combat_state: dict) -> dict:
    """
@@ -548,6 +597,96 @@ async def npc_attack(player_id: int, combat: dict, npc_def, reduce_armor_func) -
    if not player:
        return [], True
    
+    messages = []
+    
+    # 1. PROCESS NPC STATUS EFFECTS
+    npc_hp = combat['npc_hp']
+    npc_max_hp = combat['npc_max_hp']
+    npc_status_str = combat.get('npc_status_effects', '')
+    
+    if npc_status_str:
+        # Parse status: "bleeding:5:3" (name:dmg:ticks) or multiple "bleeding:5:3|burning:2:2"
+        # Handling multiple effects separated by |
+        effects_list = npc_status_str.split('|')
+        active_effects = []
+        npc_damage_taken = 0
+        npc_healing_received = 0
+        
+        for effect_str in effects_list:
+            if not effect_str: continue
+            try:
+                parts = effect_str.split(':')
+                if len(parts) >= 3:
+                    name = parts[0]
+                    dmg = int(parts[1])
+                    ticks = int(parts[2])
+                    
+                    # Apply effect
+                    if ticks > 0:
+                        if dmg > 0:
+                            npc_damage_taken += dmg
+                            messages.append(create_combat_message(
+                                "effect_damage",
+                                origin="enemy",
+                                damage=dmg,
+                                effect_name=name,
+                                npc_name=npc_def.name
+                            ))
+                        elif dmg < 0:
+                            heal = abs(dmg)
+                            npc_healing_received += heal
+                            messages.append(create_combat_message(
+                                "effect_heal", # Check if this message type exists or fallback
+                                origin="enemy",
+                                heal=heal,
+                                effect_name=name,
+                                npc_name=npc_def.name
+                            ))
+                        
+                        # Decrement tick
+                        ticks -= 1
+                        if ticks > 0:
+                            active_effects.append(f"{name}:{dmg}:{ticks}")
+            except Exception as e:
+                print(f"Error parsing NPC status: {e}")
+        
+        # Update NPC active effects
+        new_status_str = "|".join(active_effects)
+        if new_status_str != npc_status_str:
+            await db.update_combat(player_id, {'npc_status_effects': new_status_str})
+             
+        # Apply Total Damage/Healing
+        if npc_damage_taken > 0:
+            npc_hp = max(0, npc_hp - npc_damage_taken)
+        
+        if npc_healing_received > 0:
+            npc_hp = min(npc_max_hp, npc_hp + npc_healing_received)
+            
+        # Update NPC HP in DB
+        await db.update_combat(player_id, {'npc_hp': npc_hp})
+        
+        # Check if NPC died from effects
+        if npc_hp <= 0:
+            messages.append(create_combat_message(
+                "victory", 
+                origin="neutral", 
+                npc_name=npc_def.name
+            ))
+             # Award XP/Loot logic handled in combat route mostly, but we need to signal it.
+             # Returning true for player_defeated is definitely WRONG here if NPC died.
+             # The router usually handles "victory" check after action. 
+             # But here this is triggered during NPC turn (which happens after Player turn).
+             # If NPC dies on its OWN turn, we need to handle it.
+             # However, typically NPC dies on Player turn.
+             # If NPC dies from bleeding on its turn, the player wins.
+             # We need to signal this back to router.
+             # But the current return signature is (messages, player_defeated).
+             # We might need to handle the win logic here or update signature.
+             # For now, let's update HP and let the flow continue. 
+             # Wait, if NPC is dead, it shouldn't attack!
+            # returning here prevents NPC from attacking if it died from status effects
+            return messages, False 
+             
    # Parse current intent (stored in DB as string or JSON, assuming simple string for now or we parse it)
    current_intent_str = combat.get('npc_intent', 'attack')
    # Handle legacy/null
@@ -556,84 +695,98 @@ async def npc_attack(player_id: int, combat: dict, npc_def, reduce_armor_func) -
        
    intent_type = current_intent_str
    
-    messages = []
    actual_damage = 0
    
    # EXECUTE INTENT
-    if intent_type == 'defend':
-        # NPC defends - heals 5% HP
-        heal_amount = int(combat['npc_max_hp'] * 0.05)
-        new_npc_hp = min(combat['npc_max_hp'], combat['npc_hp'] + heal_amount)
-        await db.update_combat(player_id, {'npc_hp': new_npc_hp})
-        
-        messages.append(create_combat_message(
-            "enemy_defend", 
-            origin="enemy", 
-            npc_name=npc_def.name,
-            heal=heal_amount
-        ))
-        
-    elif intent_type == 'special':
-        # Strong attack (1.5x damage)
-        npc_damage = int(random.randint(npc_def.damage_min, npc_def.damage_max) * 1.5)
-        armor_absorbed, broken_armor = await reduce_armor_func(player_id, npc_damage)
-        actual_damage = max(1, npc_damage - armor_absorbed)
-        new_player_hp = max(0, player['hp'] - actual_damage)
-        
-        messages.append(create_combat_message(
-            "enemy_special", 
-            origin="enemy", 
-            npc_name=npc_def.name, 
-            damage=npc_damage,
-            armor_absorbed=armor_absorbed
-        ))
+    if npc_hp > 0: # Only attack if alive
+        if intent_type == 'defend':
+            # NPC defends - heals 5% HP
+            heal_amount = int(combat['npc_max_hp'] * 0.05)
+            new_npc_hp = min(combat['npc_max_hp'], combat['npc_hp'] + heal_amount)
+            await db.update_combat(player_id, {'npc_hp': new_npc_hp})
            
-        if broken_armor:
-            for armor in broken_armor:
-                messages.append(create_combat_message(
-                    "item_broken",
-                    origin="player",
-                    item_name=armor['name'],
-                    emoji=armor['emoji']
-                ))
-                
-        await db.update_player(player_id, hp=new_player_hp)
-        
-    else: # Default 'attack'
-        npc_damage = random.randint(npc_def.damage_min, npc_def.damage_max)
-        
-        # Enrage bonus if NPC is below 30% HP
-        is_enraged = combat['npc_hp'] / combat['npc_max_hp'] < 0.3
-        if is_enraged:
-            npc_damage = int(npc_damage * 1.5)
            messages.append(create_combat_message(
-                "enemy_enraged",
-                origin="enemy",
-                npc_name=npc_def.name
+                "enemy_defend", 
+                origin="enemy", 
+                npc_name=npc_def.name,
+                heal=heal_amount
            ))
            
-        armor_absorbed, broken_armor = await reduce_armor_func(player_id, npc_damage)
-        actual_damage = max(1, npc_damage - armor_absorbed)
-        new_player_hp = max(0, player['hp'] - actual_damage)
-        
-        messages.append(create_combat_message(
-            "enemy_attack", 
-            origin="enemy", 
-            npc_name=npc_def.name, 
-            damage=npc_damage, 
-            armor_absorbed=armor_absorbed
-        ))
+        elif intent_type == 'special':
+            # Strong attack (1.5x damage)
+            npc_damage = int(random.randint(npc_def.damage_min, npc_def.damage_max) * 1.5)
+            armor_absorbed, broken_armor = await reduce_armor_func(player_id, npc_damage)
+            actual_damage = max(1, npc_damage - armor_absorbed)
+            new_player_hp = max(0, player['hp'] - actual_damage)
            
-        if broken_armor:
-            for armor in broken_armor:
-                messages.append(create_combat_message(
-                    "item_broken",
-                    origin="player",
-                    item_name=armor['name'],
-                    emoji=armor['emoji']
-                ))
+            messages.append(create_combat_message(
+                "enemy_special", 
+                origin="enemy", 
+                npc_name=npc_def.name, 
+                damage=npc_damage,
+                armor_absorbed=armor_absorbed
+            ))
                
-        await db.update_player(player_id, hp=new_player_hp)
+            if broken_armor:
+                for armor in broken_armor:
+                    messages.append(create_combat_message(
+                        "item_broken",
+                        origin="player",
+                        item_name=armor['name'],
+                        emoji=armor['emoji']
+                    ))
+                    
+            await db.update_player(player_id, hp=new_player_hp)
+            
+        else: # Default 'attack'
+            npc_damage = random.randint(npc_def.damage_min, npc_def.damage_max)
+            
+            # Enrage bonus if NPC is below 30% HP
+            is_enraged = combat['npc_hp'] / combat['npc_max_hp'] < 0.3
+            if is_enraged:
+                npc_damage = int(npc_damage * 1.5)
+                messages.append(create_combat_message(
+                    "enemy_enraged",
+                    origin="enemy",
+                    npc_name=npc_def.name
+                ))
+            
+            # Check if player is defending (reduces damage by value%)
+            player_effects = await db.get_player_effects(player_id)
+            defending_effect = next((e for e in player_effects if e['effect_name'] == 'defending'), None)
+            if defending_effect:
+                reduction = defending_effect.get('value', 50) / 100  # Default 50% reduction
+                npc_damage = int(npc_damage * (1 - reduction))
+                messages.append(create_combat_message(
+                    "damage_reduced",
+                    origin="player",
+                    reduction=int(reduction * 100)
+                ))
+                # Remove defending effect after use
+                await db.remove_effect(player_id, 'defending')
+                
+            armor_absorbed, broken_armor = await reduce_armor_func(player_id, npc_damage)
+            actual_damage = max(1, npc_damage - armor_absorbed)
+            new_player_hp = max(0, player['hp'] - actual_damage)
+            
+            messages.append(create_combat_message(
+                "enemy_attack", 
+                origin="enemy", 
+                npc_name=npc_def.name, 
+                damage=npc_damage, 
+                armor_absorbed=armor_absorbed
+            ))
+                
+            if broken_armor:
+                for armor in broken_armor:
+                    messages.append(create_combat_message(
+                        "item_broken",
+                        origin="player",
+                        item_name=armor['name'],
+                        emoji=armor['emoji']
+                    ))
+                    
+            await db.update_player(player_id, hp=new_player_hp)

    # GENERATE NEXT INTENT