Add test script for verifying animation event sound fix

Author: claude

test_animevents.py

@@ -0,0 +1,269 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the animation event sound fix for NPC variants.
+
+This script extracts animevents.cfg from the game assets and shows which
+death sounds would play for each stormtrooper variant under the old (buggy)
+vs new (fixed) lookup logic.
+
+Usage:
+    python3 test_animevents.py ~/Library/Application\ Support/OpenJK/base/
+
+Optionally play sounds (requires pygame):
+    python3 test_animevents.py ~/Library/Application\ Support/OpenJK/base/ --play
+"""
+
+import os
+import sys
+import zipfile
+import re
+from pathlib import Path
+
+# NPC variants that use the "stormtrooper" playermodel
+NPC_VARIANTS = [
+    "stormtrooper",   # base NPC
+    "stormtrooper2",
+    "stofficer",
+    "stofficeralt",
+    "stcommander",
+    "rockettrooper",
+]
+
+# The actual model directory these NPCs use
+MODEL_NAME = "stormtrooper"
+
+
+def extract_from_pk3(base_path, internal_path):
+    """Extract a file from pk3 archives (which are just zip files)."""
+    base_path = Path(base_path)
+
+    # Search pk3 files in reverse order (higher numbers override lower)
+    pk3_files = sorted(base_path.glob("assets*.pk3"), reverse=True)
+
+    for pk3 in pk3_files:
+        try:
+            with zipfile.ZipFile(pk3, 'r') as zf:
+                if internal_path in zf.namelist():
+                    return zf.read(internal_path).decode('utf-8', errors='ignore')
+        except Exception as e:
+            print(f"Warning: Could not read {pk3}: {e}")
+
+    return None
+
+
+def parse_animevents(content):
+    """Parse animevents.cfg and extract sound events with modelOnly filters."""
+    events = []
+
+    # Find BOTH/TORSO/LEGS events with AEV_SOUND type
+    # Format: ANIM_NAME AEV_SOUNDCHAN frame sound [modelOnly <model>]
+
+    lines = content.split('\n')
+    in_block = None
+
+    for line in lines:
+        line = line.strip()
+
+        if line.startswith('//') or not line:
+            continue
+
+        if 'UPPEREVENTS' in line or 'TORSOEVENTS' in line:
+            in_block = 'torso'
+            continue
+        elif 'LOWEREVENTS' in line or 'LEGSEVENTS' in line:
+            in_block = 'legs'
+            continue
+        elif line == '{':
+            continue
+        elif line == '}':
+            in_block = None
+            continue
+
+        if in_block and 'AEV_SOUND' in line:
+            # Parse the event line
+            parts = line.split()
+            if len(parts) >= 4:
+                anim_name = parts[0]
+                event_type = parts[1]
+
+                # Find the sound file (usually .mp3 or .wav)
+                sound_file = None
+                model_only = None
+
+                for i, part in enumerate(parts):
+                    if '.mp3' in part.lower() or '.wav' in part.lower():
+                        sound_file = part
+                    if part.lower() == 'modelonly' and i + 1 < len(parts):
+                        model_only = parts[i + 1]
+
+                if sound_file and 'bodyfall' in sound_file.lower():
+                    events.append({
+                        'anim': anim_name,
+                        'type': event_type,
+                        'sound': sound_file,
+                        'modelOnly': model_only,
+                        'block': in_block,
+                    })
+
+    return events
+
+
+def simulate_lookup(events, npc_type, model_name):
+    """Simulate which events would trigger for an NPC."""
+    matching = []
+
+    for event in events:
+        model_only = event['modelOnly']
+
+        if model_only is None:
+            # No filter, applies to all
+            matching.append(event)
+        elif model_only.lower() == npc_type.lower():
+            # Old logic: compare against NPC_type
+            matching.append(event)
+
+    return matching
+
+
+def simulate_lookup_fixed(events, npc_type, model_name):
+    """Simulate which events would trigger with the fix."""
+    matching = []
+
+    for event in events:
+        model_only = event['modelOnly']
+
+        if model_only is None:
+            # No filter, applies to all
+            matching.append(event)
+        elif model_only.lower() == model_name.lower():
+            # Fixed logic: compare against model name from animFileSet
+            matching.append(event)
+
+    return matching
+
+
+def extract_sound_from_pk3(base_path, sound_path):
+    """Extract a sound file from pk3 archives."""
+    base_path = Path(base_path)
+    pk3_files = sorted(base_path.glob("assets*.pk3"), reverse=True)
+
+    # Normalize path
+    if not sound_path.startswith('sound/'):
+        sound_path = 'sound/' + sound_path
+
+    for pk3 in pk3_files:
+        try:
+            with zipfile.ZipFile(pk3, 'r') as zf:
+                if sound_path in zf.namelist():
+                    return zf.read(sound_path)
+        except:
+            pass
+    return None
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(__doc__)
+        sys.exit(1)
+
+    base_path = sys.argv[1]
+    play_sounds = '--play' in sys.argv
+
+    if not os.path.isdir(base_path):
+        print(f"Error: Directory not found: {base_path}")
+        sys.exit(1)
+
+    # Extract animevents.cfg for stormtrooper model
+    animevents_path = f"models/players/{MODEL_NAME}/animevents.cfg"
+    content = extract_from_pk3(base_path, animevents_path)
+
+    if not content:
+        print(f"Error: Could not find {animevents_path} in pk3 files")
+        print(f"Searched in: {base_path}")
+        sys.exit(1)
+
+    print(f"Found {animevents_path}")
+    print("=" * 70)
+
+    # Parse events
+    events = parse_animevents(content)
+
+    if not events:
+        print("No bodyfall sound events found in animevents.cfg")
+        print("\nRaw content preview:")
+        print(content[:2000])
+        sys.exit(1)
+
+    print(f"\nFound {len(events)} death sound events:")
+    for e in events:
+        model_filter = f" (modelOnly: {e['modelOnly']})" if e['modelOnly'] else ""
+        print(f"  - {e['anim']}: {e['sound']}{model_filter}")
+
+    print("\n" + "=" * 70)
+    print("COMPARISON: Old (buggy) vs Fixed lookup")
+    print("=" * 70)
+
+    # Compare old vs new logic for each NPC variant
+    print(f"\n{'NPC Type':<20} {'Old (NPC_type)':<25} {'Fixed (model name)':<25}")
+    print("-" * 70)
+
+    for npc_type in NPC_VARIANTS:
+        old_matches = simulate_lookup(events, npc_type, MODEL_NAME)
+        new_matches = simulate_lookup_fixed(events, npc_type, MODEL_NAME)
+
+        old_count = len(old_matches)
+        new_count = len(new_matches)
+
+        old_status = f"{old_count} sounds" if old_count > 0 else "NO SOUNDS"
+        new_status = f"{new_count} sounds" if new_count > 0 else "NO SOUNDS"
+
+        # Highlight the difference
+        if old_count == 0 and new_count > 0:
+            old_status = f"\033[91m{old_status}\033[0m"  # Red
+            new_status = f"\033[92m{new_status}\033[0m"  # Green
+
+        print(f"{npc_type:<20} {old_status:<35} {new_status:<35}")
+
+    print("\n" + "=" * 70)
+    print("LEGEND:")
+    print("  - Old logic uses NPC_type (e.g., 'stormtrooper2')")
+    print("  - Fixed logic uses model name from animFileSet (e.g., 'stormtrooper')")
+    print("  - Events with 'modelOnly: stormtrooper' only match 'stormtrooper'")
+    print("=" * 70)
+
+    # Optional: Play sounds
+    if play_sounds:
+        try:
+            import pygame
+            pygame.mixer.init()
+
+            print("\n\nSOUND PLAYBACK TEST")
+            print("=" * 70)
+
+            for event in events[:4]:  # Play first 4 sounds
+                sound_path = event['sound']
+                sound_data = extract_sound_from_pk3(base_path, sound_path)
+
+                if sound_data:
+                    import tempfile
+                    with tempfile.NamedTemporaryFile(suffix='.mp3', delete=False) as f:
+                        f.write(sound_data)
+                        temp_path = f.name
+
+                    print(f"Playing: {sound_path}")
+                    pygame.mixer.music.load(temp_path)
+                    pygame.mixer.music.play()
+
+                    while pygame.mixer.music.get_busy():
+                        pygame.time.wait(100)
+
+                    os.unlink(temp_path)
+                else:
+                    print(f"Could not find: {sound_path}")
+
+        except ImportError:
+            print("\nTo play sounds, install pygame: pip3 install pygame")
+
+
+if __name__ == '__main__':
+    main()