rom24-quickmud-python 2.4.2__py3-none-any.whl → 2.5.1__py3-none-any.whl

mud/affects/saves.py

@@ -90,7 +90,10 @@ def _check_immune(victim: Character, dam_type: int) -> int:
         immune = IS_IMMUNE
     elif (victim.res_flags & bit) and immune != IS_IMMUNE:
         immune = IS_RESISTANT
-    elif victim.vuln_flags & bit:
+
+    # ROM C handler.c:306-314 - vuln check runs AFTER imm/res checks
+    # This is NOT elif - it runs independently to allow downgrading immunity
+    if victim.vuln_flags & bit:
         if immune == IS_IMMUNE:
             immune = IS_RESISTANT
         elif immune == IS_RESISTANT:
@@ -126,10 +129,7 @@ def saves_spell(level: int, victim: Character, dam_type: int) -> bool:
         save -= 2
 
     # Not NPC → apply fMana reduction if class gains mana
-    if (
-        not victim.is_npc
-        and FMANA_BY_CLASS.get(victim.ch_class, False)
-    ):
+    if not victim.is_npc and FMANA_BY_CLASS.get(victim.ch_class, False):
         save = c_div(9 * save, 10)
 
     save = urange(5, save, 95)

mud/ai/aggressive.py

@@ -117,3 +117,8 @@ def aggressive_update() -> None:
                 continue
 
             multi_hit(mob, victim)
+
+            # ROM src/fight.c:90 - Check for assist after combat starts
+            from mud.combat.assist import check_assist
+
+            check_assist(mob, victim)

mud/combat/__init__.py

@@ -1,6 +1,7 @@
 """Combat engine utilities."""
 
+from .assist import check_assist
 from .engine import attack_round, multi_hit
 from .messages import dam_message
 
-__all__ = ["attack_round", "multi_hit", "dam_message"]
+__all__ = ["attack_round", "check_assist", "dam_message", "multi_hit"]

mud/combat/assist.py

@@ -0,0 +1,205 @@
+"""
+Combat assist mechanics - auto-assist for group combat.
+
+ROM Reference: src/fight.c check_assist (lines 105-181)
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from mud.characters import is_same_group
+from mud.combat.engine import multi_hit, is_good, is_evil, is_neutral
+from mud.combat.safety import is_safe
+from mud.models.constants import AffectFlag, OffFlag, PlayerFlag
+from mud.utils import rng_mm
+from mud.world.vision import can_see_character
+
+if TYPE_CHECKING:
+    from mud.models.character import Character
+
+
+def check_assist(ch: Character, victim: Character) -> None:
+    """
+    Check for auto-assist in combat following ROM C src/fight.c:check_assist (L105-181).
+
+    This function is called when 'ch' attacks 'victim' to see if anyone in the room
+    will automatically assist either side.
+
+    Handles six assist types:
+    1. ASSIST_PLAYERS: Mobs help players fighting weaker mobs (lines 116-124)
+    2. PLR_AUTOASSIST: Players auto-assist group members (lines 126-135)
+    3. ASSIST_ALL: Mobs assist any mob in the room (line 141)
+    4. ASSIST_RACE: Mobs assist same race (lines 143-144)
+    5. ASSIST_ALIGN: Mobs assist same alignment (lines 145-148)
+    6. ASSIST_VNUM: Mobs assist same vnum (lines 149-150)
+
+    Args:
+        ch: Character currently attacking (the aggressor)
+        victim: Character being attacked by ch
+
+    ROM C Reference:
+        src/fight.c:105-181
+    """
+    # Get all characters in the same room
+    room = getattr(ch, "room", None)
+    if not room:
+        return
+
+    people_in_room = getattr(room, "people", [])
+    if not people_in_room:
+        return
+
+    # Loop through all characters in the room
+    # NOTE: We need to be careful about list modification during iteration
+    # ROM uses rch_next pattern to handle this
+    for rch in list(people_in_room):  # Create a copy to avoid modification issues
+        # Skip if not awake or already fighting
+        if not _is_awake(rch):
+            continue
+
+        if getattr(rch, "fighting", None) is not None:
+            continue
+
+        # --- ASSIST_PLAYERS: Mobs help players fighting weaker mobs (ROM lines 116-124) ---
+        if not _is_npc(ch) and _is_npc(rch):
+            rch_off_flags = getattr(rch, "off_flags", 0)
+            if rch_off_flags & OffFlag.ASSIST_PLAYERS:
+                rch_level = getattr(rch, "level", 1)
+                victim_level = getattr(victim, "level", 1)
+                if rch_level + 6 > victim_level:
+                    _emote(rch, "screams and attacks!")
+                    multi_hit(rch, victim, None)
+                    continue
+
+        # --- PCs next (ROM lines 126-135) ---
+        # Player characters or charmed mobs can auto-assist
+        if not _is_npc(ch) or _is_affected(ch, AffectFlag.CHARM):
+            # Check if rch is a player with autoassist or a charmed mob
+            rch_act = getattr(rch, "act", 0)
+            is_rch_autoassist = not _is_npc(rch) and (rch_act & PlayerFlag.AUTOASSIST)
+            is_rch_charmed = _is_affected(rch, AffectFlag.CHARM)
+
+            if (is_rch_autoassist or is_rch_charmed) and is_same_group(ch, rch):
+                if not is_safe(rch, victim):
+                    multi_hit(rch, victim, None)
+
+            continue
+
+        # --- NPC assist cases (ROM lines 137-178) ---
+        # Only NPCs that aren't charmed can use these assist types
+        if _is_npc(ch) and not _is_affected(ch, AffectFlag.CHARM):
+            if not _is_npc(rch):
+                continue  # rch must be NPC for these assist types
+
+            rch_off_flags = getattr(rch, "off_flags", 0)
+            should_assist = False
+
+            # ASSIST_ALL: Assist any mob
+            if rch_off_flags & OffFlag.ASSIST_ALL:
+                should_assist = True
+
+            # ASSIST_RACE: Assist same race
+            elif rch_off_flags & OffFlag.ASSIST_RACE:
+                ch_race = getattr(ch, "race", None)
+                rch_race = getattr(rch, "race", None)
+                if ch_race and rch_race and ch_race == rch_race:
+                    should_assist = True
+
+            # ASSIST_ALIGN: Assist same alignment
+            elif rch_off_flags & OffFlag.ASSIST_ALIGN:
+                if (
+                    (is_good(rch) and is_good(ch))
+                    or (is_evil(rch) and is_evil(ch))
+                    or (is_neutral(rch) and is_neutral(ch))
+                ):
+                    should_assist = True
+
+            # ASSIST_VNUM: Assist same vnum (same mob prototype)
+            elif rch_off_flags & OffFlag.ASSIST_VNUM:
+                ch_vnum = getattr(ch, "vnum", None)
+                rch_vnum = getattr(rch, "vnum", None)
+                if ch_vnum is not None and rch_vnum is not None and ch_vnum == rch_vnum:
+                    should_assist = True
+
+            # Group assist: NPCs in same group help each other
+            ch_group = getattr(ch, "group", None)
+            rch_group = getattr(rch, "group", None)
+            if ch_group and rch_group and ch_group == rch_group:
+                should_assist = True
+
+            if should_assist:
+                # ROM lines 156-157: 50% chance to skip assist
+                if rng_mm.number_bits(1) == 0:
+                    continue
+
+                # ROM lines 159-170: Randomly select target from victim's group
+                target = None
+                number = 0
+
+                # Use reservoir sampling to pick random group member
+                for vch in list(people_in_room):
+                    if can_see_character(rch, vch) and is_same_group(vch, victim):
+                        if rng_mm.number_range(0, number) == 0:
+                            target = vch
+                        number += 1
+
+                # ROM lines 172-176: Attack the selected target
+                if target is not None:
+                    _emote(rch, "screams and attacks!")
+                    multi_hit(rch, target, None)
+
+
+def _is_awake(char: Character) -> bool:
+    """Check if character is awake (ROM IS_AWAKE macro)."""
+    from mud.models.constants import Position
+
+    position = getattr(char, "position", Position.STANDING)
+    return position > Position.SLEEPING
+
+
+def _is_npc(char: Character) -> bool:
+    """Check if character is NPC (ROM IS_NPC macro)."""
+    return getattr(char, "is_npc", False)
+
+
+def _is_affected(char: Character, flag: AffectFlag) -> bool:
+    """Check if character has affect flag (ROM IS_AFFECTED macro)."""
+    affected_by = getattr(char, "affected_by", 0)
+    return bool(affected_by & flag)
+
+
+def _emote(char: Character, message: str) -> None:
+    """
+    Make character perform an emote.
+
+    ROM C uses: do_function(rch, &do_emote, "screams and attacks!");
+    Python equivalent: Send message to room.
+    """
+    from mud.models.social import expand_placeholders
+
+    room = getattr(char, "room", None)
+    if not room:
+        return
+
+    # Format: "Name screams and attacks!"
+    char_name = getattr(char, "name", "Someone")
+    full_message = f"{char_name} {message}"
+
+    # Send to everyone in the room
+    people = getattr(room, "people", [])
+    for person in people:
+        if person != char:
+            _send_to_char(person, full_message)
+
+
+def _send_to_char(char: Character, message: str) -> None:
+    """Send a message to a character."""
+    send = getattr(char, "send", None)
+    if callable(send):
+        send(message + "\n")
+    else:
+        # Fallback: add to messages list if it exists
+        messages = getattr(char, "messages", None)
+        if isinstance(messages, list):
+            messages.append(message + "\n")

mud/combat/engine.py

@@ -307,6 +307,11 @@ def multi_hit(attacker: Character, victim: Character, dt: str | int | None = Non
     if victim.position == Position.DEAD or not hasattr(attacker, "fighting") or attacker.fighting != victim:
         return results
 
+    # ROM src/fight.c:90 - Check for assist after first attack
+    from mud.combat.assist import check_assist
+
+    check_assist(attacker, victim)
+
     # ROM allows only a single strike for backstab.
     if _normalize_dt(dt) == "backstab":
         return results
@@ -475,6 +480,7 @@ def apply_damage(
 
     Handles:
     - Defense checks (parry, dodge, shield_block) - ROM checks these AFTER hit but BEFORE damage
+    - Damage type resistance/vulnerability (ROM fight.c:804-816)
     - Damage application and hit point reduction
     - Position updates based on remaining hit points
     - Fighting state management (set_fighting, stop_fighting)
@@ -504,6 +510,24 @@ def apply_damage(
         if check_dodge(attacker, victim):
             return f"{victim.name} dodges your attack."
 
+    # Apply damage type resistance/vulnerability modifiers (ROM fight.c:804-816)
+    # This must happen AFTER defense checks but BEFORE damage application
+    if dam_type is not None:
+        IS_IMMUNE = 1
+        IS_RESISTANT = 2
+        IS_VULNERABLE = 3
+
+        immune_check = _riv_check(victim, dam_type)
+        if immune_check == IS_IMMUNE:
+            immune = True
+            damage = 0
+        elif immune_check == IS_RESISTANT:
+            # ROM: dam -= dam / 3 (reduces damage by 33%)
+            damage -= c_div(damage, 3)
+        elif immune_check == IS_VULNERABLE:
+            # ROM: dam += dam / 2 (increases damage by 50%)
+            damage += c_div(damage, 2)
+
     message_bundle: DamageMessages | None = None
     if show:
         message_bundle = dam_message(attacker, victim, damage, dt, immune)

mud/commands/combat.py

@@ -246,14 +246,17 @@ def do_rescue(char: Character, args: str) -> str:
 
 
 def _find_room_target(char: Character, name: str) -> Character | None:
+    """Find a character in the same room by name.
+
+    ROM Reference: src/act_info.c get_char_room()
+    Note: ROM allows finding self - individual commands check victim == ch.
+    """
     room = getattr(char, "room", None)
     if room is None or not name:
         return None
 
     lowered = name.lower()
     for candidate in getattr(room, "people", []) or []:
-        if candidate is char:
-            continue
         candidate_name = getattr(candidate, "name", "") or ""
         if lowered in candidate_name.lower():
             return candidate
@@ -529,19 +532,42 @@ def do_berserk(char: Character, args: str) -> str:
 
 
 def do_surrender(char: Character, args: str) -> str:
+    """
+    Surrender to opponent, ending combat.
+
+    ROM Reference: src/fight.c do_surrender (lines 3222-3242)
+
+    Allows a character to yield to their opponent. If surrendering to an NPC,
+    the NPC's TRIG_SURR mobprog is triggered if present. By default, NPCs
+    ignore surrender and continue attacking.
+    """
+    # Must be fighting (ROM fight.c:3225-3229)
     opponent = getattr(char, "fighting", None)
     if opponent is None:
-        return "But you're not fighting!"
+        return "But you're not fighting!\n\r"
+
+    # Messages (ROM fight.c:3230-3232)
+    opponent_name = getattr(opponent, "name", "someone")
+    messages = [f"You surrender to {opponent_name}!"]
 
+    # Stop fighting (ROM fight.c:3233 - stop_fighting(ch, TRUE))
     stop_fighting(char, True)
     if getattr(opponent, "fighting", None) is char:
         opponent.fighting = None
 
+    # Check for TRIG_SURR mobprog if player surrendering to NPC
+    # ROM fight.c:3235-3241
     if not getattr(char, "is_npc", False) and getattr(opponent, "is_npc", False):
+        # Try to trigger surrender mobprog
         if not mobprog.mp_surr_trigger(opponent, char):
-            multi_hit(opponent, char)
+            # No mobprog or mobprog didn't handle it - NPC ignores and attacks
+            messages.append(f"{opponent_name} seems to ignore your cowardly act!")
+            # ROM: multi_hit(mob, ch, TYPE_UNDEFINED)
+            attack_messages = multi_hit(opponent, char)
+            if attack_messages:
+                messages.extend(attack_messages)
 
-    return "You surrender."
+    return "\n".join(messages) if len(messages) > 1 else messages[0]
 
 
 def do_flee(char: Character, args: str) -> str:
@@ -571,10 +597,10 @@ def do_flee(char: Character, args: str) -> str:
         dex = char.get_curr_stat(Stat.DEX)
     else:
         dex = 13  # Default dex
-    
+
     if dex is None:
         dex = 13
-    
+
     chance = 50 + (dex - 13) * 5  # Base 50%, +/- 5% per dex point
 
     # Reduce chance if badly hurt
@@ -597,17 +623,17 @@ def do_flee(char: Character, args: str) -> str:
     for direction, exit_data in exits.items():
         if exit_data:
             # Handle both dict-style and Exit object style
-            if hasattr(exit_data, 'exit_info'):
+            if hasattr(exit_data, "exit_info"):
                 # Exit object
-                closed = bool(getattr(exit_data, 'exit_info', 0) & 1)  # EX_ISDOOR and closed
-                to_room = getattr(exit_data, 'to_room', None)
+                closed = bool(getattr(exit_data, "exit_info", 0) & 1)  # EX_ISDOOR and closed
+                to_room = getattr(exit_data, "to_room", None)
             elif isinstance(exit_data, dict):
                 # Dict style
                 closed = exit_data.get("closed", False)
                 to_room = exit_data.get("to_room")
             else:
                 continue
-            
+
             if not closed and to_room:
                 valid_exits.append((direction, to_room))
 
@@ -754,16 +780,16 @@ def do_cast(char: Character, args: str) -> str:
 def do_dirt(char: Character, args: str) -> str:
     """
     Kick dirt in opponent's eyes to blind them.
-    
+
     ROM Reference: src/fight.c do_dirt (lines 2489-2640)
     """
     target_name = (args or "").strip()
-    
+
     # Check if character has the skill
     skill_level = char.skills.get("dirt kicking", 0)
     if skill_level == 0:
         return "You get your feet dirty."
-    
+
     # Find target
     if not target_name:
         victim = getattr(char, "fighting", None)
@@ -773,63 +799,38 @@ def do_dirt(char: Character, args: str) -> str:
         victim = _find_room_target(char, target_name)
         if victim is None:
             return "They aren't here."
-    
-    # Check if already blinded
+
+    # Match ROM safety/validation gates in the command layer.
+    if victim is char:
+        return "Very funny."
+
     victim_affected = getattr(victim, "affected_by", 0)
     if victim_affected & AffectFlag.BLIND:
         return "They're already blinded."
-    
-    if victim is char:
-        return "Very funny."
-    
-    # Safety checks
+
     safety_msg = _kill_safety_message(char, victim)
     if safety_msg:
         return safety_msg
-    
-    # Calculate chance
-    chance = skill_level
-    char_dex = skill_handlers._coerce_int(getattr(char, "perm_stat", [13]*5)[1] if isinstance(getattr(char, "perm_stat", []), list) else 13)
-    victim_dex = skill_handlers._coerce_int(getattr(victim, "perm_stat", [13]*5)[1] if isinstance(getattr(victim, "perm_stat", []), list) else 13)
-    chance += char_dex - 2 * victim_dex
-    
-    # Level modifier
-    char_level = skill_handlers._coerce_int(getattr(char, "level", 1))
-    victim_level = skill_handlers._coerce_int(getattr(victim, "level", 1))
-    chance += (char_level - victim_level) * 2
-    
-    # Roll
-    if rng_mm.number_percent() < chance:
-        # Success - blind the victim
-        victim.affected_by = victim_affected | AffectFlag.BLIND
-        skill_registry._apply_wait_state(char, get_pulse_violence())
-        
-        # Start combat if not already fighting
-        if not getattr(char, "fighting", None):
-            char.fighting = victim
-        if not getattr(victim, "fighting", None):
-            victim.fighting = char
-        
-        check_killer(char, victim)
-        return f"You kick dirt into {getattr(victim, 'name', 'their')} eyes!"
-    else:
-        skill_registry._apply_wait_state(char, get_pulse_violence())
-        return "You kick dirt but miss their eyes."
+
+    # Delegate parity math/effects to the skill handler.
+    result = skill_handlers.dirt_kicking(char, target=victim)
+    check_killer(char, victim)
+    return result
 
 
 def do_trip(char: Character, args: str) -> str:
     """
     Trip opponent to knock them down.
-    
+
     ROM Reference: src/fight.c do_trip (lines 2641-2760)
     """
     target_name = (args or "").strip()
-    
+
     # Check if character has the skill
     skill_level = char.skills.get("trip", 0)
     if skill_level == 0:
         return "Tripping? What's that?"
-    
+
     # Find target
     if not target_name:
         victim = getattr(char, "fighting", None)
@@ -839,56 +840,60 @@ def do_trip(char: Character, args: str) -> str:
         victim = _find_room_target(char, target_name)
         if victim is None:
             return "They aren't here."
-    
+
     # Safety checks
     safety_msg = _kill_safety_message(char, victim)
     if safety_msg:
         return safety_msg
-    
+
     # Can't trip flying targets
     victim_affected = getattr(victim, "affected_by", 0)
     if victim_affected & AffectFlag.FLYING:
         return "Their feet aren't on the ground."
-    
+
     # Can't trip someone already down
     victim_pos = getattr(victim, "position", Position.STANDING)
     if victim_pos < Position.FIGHTING:
         return "They are already down."
-    
+
     if victim is char:
         skill_registry._apply_wait_state(char, get_pulse_violence() * 2)
         return "You fall flat on your face!"
-    
+
     # Calculate chance
     chance = skill_level
-    
+
     # Size modifier
     char_size = skill_handlers._coerce_int(getattr(char, "size", 2))
     victim_size = skill_handlers._coerce_int(getattr(victim, "size", 2))
     if char_size < victim_size:
         chance += (char_size - victim_size) * 10
-    
+
     # Dex modifier
-    char_dex = skill_handlers._coerce_int(getattr(char, "perm_stat", [13]*5)[1] if isinstance(getattr(char, "perm_stat", []), list) else 13)
-    victim_dex = skill_handlers._coerce_int(getattr(victim, "perm_stat", [13]*5)[1] if isinstance(getattr(victim, "perm_stat", []), list) else 13)
+    char_dex = skill_handlers._coerce_int(
+        getattr(char, "perm_stat", [13] * 5)[1] if isinstance(getattr(char, "perm_stat", []), list) else 13
+    )
+    victim_dex = skill_handlers._coerce_int(
+        getattr(victim, "perm_stat", [13] * 5)[1] if isinstance(getattr(victim, "perm_stat", []), list) else 13
+    )
     chance += char_dex - victim_dex * 3 // 2
-    
+
     # Level modifier
     char_level = skill_handlers._coerce_int(getattr(char, "level", 1))
     victim_level = skill_handlers._coerce_int(getattr(victim, "level", 1))
     chance += (char_level - victim_level) * 2
-    
+
     # Roll
     if rng_mm.number_percent() < chance:
         # Success
         victim.position = Position.RESTING
         skill_registry._apply_wait_state(char, get_pulse_violence())
         skill_registry._apply_wait_state(victim, get_pulse_violence() * 2)
-        
+
         # Damage
         damage_amt = rng_mm.number_range(2, 2 + 2 * victim_size + skill_level // 20)
         apply_damage(char, victim, damage_amt, DamageType.BASH)
-        
+
         check_killer(char, victim)
         return f"You trip {getattr(victim, 'name', 'them')} and they go down!"
     else:
@@ -899,67 +904,34 @@ def do_trip(char: Character, args: str) -> str:
 def do_disarm(char: Character, args: str) -> str:
     """
     Attempt to disarm opponent's weapon.
-    
+
     ROM Reference: src/fight.c do_disarm (lines 3145-3220)
     """
     # Check if character has the skill
     skill_level = char.skills.get("disarm", 0)
     if skill_level == 0:
         return "You don't know how to disarm opponents."
-    
+
     # Must be fighting
     victim = getattr(char, "fighting", None)
     if victim is None:
         return "You aren't fighting anyone."
-    
+
+    # Attacker must have a weapon, or meet ROM hand-to-hand / NPC OFF_DISARM exception.
+    caster_weapon = get_wielded_weapon(char)
+    hth_skill = char.skills.get("hand to hand", 0)
+    if caster_weapon is None and hth_skill == 0:
+        return "You must wield a weapon to disarm."
+
     # Victim must be wielding a weapon
-    victim_equipped = getattr(victim, "equipped", {})
-    victim_weapon = victim_equipped.get("wield") or victim_equipped.get("main_hand")
+    victim_weapon = get_wielded_weapon(victim)
     if victim_weapon is None:
         return "Your opponent is not wielding a weapon."
-    
-    # Attacker should have weapon (or hand-to-hand skill)
-    char_equipped = getattr(char, "equipped", {})
-    char_weapon = char_equipped.get("wield") or char_equipped.get("main_hand")
-    hth_skill = char.skills.get("hand to hand", 0)
-    
-    if char_weapon is None and hth_skill == 0:
-        return "You must wield a weapon to disarm."
-    
-    # Calculate chance
-    if char_weapon is None:
-        chance = skill_level * hth_skill // 150
-    else:
-        chance = skill_level
-    
-    # Dex vs Str
-    char_dex = skill_handlers._coerce_int(getattr(char, "perm_stat", [13]*5)[1] if isinstance(getattr(char, "perm_stat", []), list) else 13)
-    victim_str = skill_handlers._coerce_int(getattr(victim, "perm_stat", [13]*5)[0] if isinstance(getattr(victim, "perm_stat", []), list) else 13)
-    chance += char_dex - 2 * victim_str
-    
-    # Level modifier
-    char_level = skill_handlers._coerce_int(getattr(char, "level", 1))
-    victim_level = skill_handlers._coerce_int(getattr(victim, "level", 1))
-    chance += (char_level - victim_level) * 2
-    
-    skill_registry._apply_wait_state(char, get_pulse_violence())
-    
-    # Roll
-    if rng_mm.number_percent() < chance:
-        # Success - remove weapon from victim
-        if "wield" in victim_equipped:
-            del victim_equipped["wield"]
-        elif "main_hand" in victim_equipped:
-            del victim_equipped["main_hand"]
-        
-        # Drop to room
-        victim_room = getattr(victim, "room", None)
-        if victim_room and hasattr(victim_room, "contents"):
-            victim_room.contents.append(victim_weapon)
-            victim_weapon.in_room = victim_room
-        
-        check_killer(char, victim)
-        return f"You disarm {getattr(victim, 'name', 'them')}!"
-    else:
-        return f"You fail to disarm {getattr(victim, 'name', 'them')}."
 
+    success = skill_handlers.disarm(char, target=victim)
+    check_killer(char, victim)
+
+    victim_name = getattr(victim, "name", "them")
+    if success:
+        return f"You disarm {victim_name}!"
+    return f"You fail to disarm {victim_name}."