| |
| """Analyze a raw weapon table dump from the debug CLI. |
| |
| Usage: |
| python tools/analyze_weapon_table.py /tmp/weapon_table.bin |
| |
| Reads 71 x 0x1D0 byte entries and prints field analysis. |
| """ |
|
|
| import struct |
| import sys |
| from pathlib import Path |
|
|
| ENTRY_SIZE = 0x1D0 |
| ENTRY_COUNT = 71 |
| FIRE_PARAMS_OFFSET = 0x3C |
|
|
| WEAPON_NAMES = [ |
| "None", "Bazooka", "HomingMissile", "Mortar", "HomingPigeon", |
| "SheepLauncher", "Grenade", "ClusterBomb", "BananaBomb", "BattleAxe", |
| "Earthquake", "Shotgun", "Handgun", "Uzi", "Minigun", |
| "Longbow", "FirePunch", "DragonBall", "Kamikaze", "SuicideBomber", |
| "Prod", "Dynamite", "Mine", "Sheep", "SuperSheep", |
| "AquaSheep", "MoleBomb", "AirStrike", "NapalmStrike", "MailStrike", |
| "MineStrike", "MoleSquadron", "BlowTorch", "PneumaticDrill", "Girder", |
| "BaseballBat", "GirderPack", "NinjaRope", "Bungee", "Parachute", |
| "Teleport", "ScalesOfJustice", "SuperBanana", "HolyGrenade", "FlameThrower", |
| "SalvationArmy", "MbBomb", "PetrolBomb", "Skunk", "MingVase", |
| "SheepStrike", "CarpetBomb", "MadCow", "OldWoman", "Donkey", |
| "NuclearTest", "Armageddon", "SkipGo", "Surrender", "SelectWorm", |
| "Freeze", "MagicBullet", "JetPack", "LowGravity", "FastWalk", |
| "LaserSight", "Invisibility", "DamageX2", "CrateSpy", "DoubleTurnTime", |
| "CrateShower", |
| ] |
|
|
| FIRE_TYPE_NAMES = {0: "none", 1: "projectile", 2: "rope", 3: "grenade", 4: "special"} |
|
|
| |
| KNOWN_FIELDS = { |
| 0x00: "name1_ptr", |
| 0x04: "name2_ptr", |
| 0x08: "panel_state", |
| 0x0C: "_unknown_0c", |
| 0x10: "defined", |
| 0x24: "availability", |
| 0x28: "enabled", |
| 0x30: "fire_type", |
| 0x34: "fire_subtype_34", |
| 0x38: "fire_subtype_38", |
| } |
|
|
|
|
| def read_entries(data: bytes) -> list[bytes]: |
| assert len(data) == ENTRY_SIZE * ENTRY_COUNT, f"Expected {ENTRY_SIZE * ENTRY_COUNT} bytes, got {len(data)}" |
| return [data[i * ENTRY_SIZE:(i + 1) * ENTRY_SIZE] for i in range(ENTRY_COUNT)] |
|
|
|
|
| def dword_at(entry: bytes, offset: int) -> int: |
| return struct.unpack_from("<I", entry, offset)[0] |
|
|
|
|
| def sdword_at(entry: bytes, offset: int) -> int: |
| return struct.unpack_from("<i", entry, offset)[0] |
|
|
|
|
| def print_header_fields(entries: list[bytes]): |
| """Print known header fields (0x00-0x3B) for all weapons.""" |
| print("=" * 80) |
| print("WEAPON ENTRY HEADER (0x00-0x3B)") |
| print("=" * 80) |
|
|
| fmt = "{:<4} {:<16} {:>4} {:>4} {:>4} {:>12} {:>4} {:>4} {:>4} {:>4}" |
| print(fmt.format("ID", "Name", "panl", "unk0C", "def", "avail", "enab", "ftyp", "sub34", "sub38")) |
| print("-" * 80) |
|
|
| for i, entry in enumerate(entries): |
| name = WEAPON_NAMES[i] |
| panel = sdword_at(entry, 0x08) |
| unk0c = sdword_at(entry, 0x0C) |
| defined = sdword_at(entry, 0x10) |
| avail = sdword_at(entry, 0x24) |
| enabled = sdword_at(entry, 0x28) |
| ftype = sdword_at(entry, 0x30) |
| sub34 = sdword_at(entry, 0x34) |
| sub38 = sdword_at(entry, 0x38) |
|
|
| type_name = FIRE_TYPE_NAMES.get(ftype, f"?{ftype}") |
| print(f"{i:<4} {name:<16} {panel:>4} {unk0c:>4} {defined:>4} {avail:>12} {enabled:>4} {type_name:<11} {sub34:>4} {sub38:>4}") |
|
|
|
|
| def print_unknown_header_region(entries: list[bytes]): |
| """Print the unknown 0x14-0x23 region.""" |
| print("\n" + "=" * 80) |
| print("UNKNOWN HEADER REGION (0x14-0x23)") |
| print("=" * 80) |
|
|
| for i, entry in enumerate(entries): |
| vals = [dword_at(entry, off) for off in range(0x14, 0x24, 4)] |
| if any(v != 0 for v in vals): |
| print(f"{i:<4} {WEAPON_NAMES[i]:<16} " + " ".join(f"{v:08X}" for v in vals)) |
| print("(only non-zero entries shown)") |
|
|
|
|
| def analyze_fire_params(entries: list[bytes]): |
| """Analyze fire_params region (0x3C-0x1CF) across all weapons.""" |
| print("\n" + "=" * 80) |
| print("FIRE PARAMS ANALYSIS (0x3C-0x1CF, 0x194 bytes = 101 DWORDs)") |
| print("=" * 80) |
|
|
| num_dwords = (ENTRY_SIZE - FIRE_PARAMS_OFFSET) // 4 |
|
|
| |
| interesting = [] |
| all_zero = [] |
|
|
| for di in range(num_dwords): |
| byte_off = FIRE_PARAMS_OFFSET + di * 4 |
| values = [dword_at(entry, byte_off) for entry in entries] |
| unique = set(values) |
| nonzero = [v for v in values if v != 0] |
|
|
| if len(unique) == 1 and values[0] == 0: |
| all_zero.append(di) |
| elif len(unique) <= 3: |
| interesting.append((di, byte_off, values, "few_values")) |
| else: |
| interesting.append((di, byte_off, values, "varied")) |
|
|
| print(f"\nAll-zero DWORDs ({len(all_zero)} of {num_dwords}): indices {all_zero[:20]}{'...' if len(all_zero) > 20 else ''}") |
| print(f"Non-trivial DWORDs: {len(interesting)}") |
|
|
| |
| print("\n--- Fields with few distinct values (likely flags/enums) ---") |
| for di, byte_off, values, kind in interesting: |
| if kind != "few_values": |
| continue |
| unique = sorted(set(values)) |
| |
| val_weapons = {} |
| for i, v in enumerate(values): |
| val_weapons.setdefault(v, []).append(i) |
|
|
| print(f"\n +0x{byte_off:03X} (fire_params[{di - FIRE_PARAMS_OFFSET // 4}]):") |
| for v in unique: |
| weapons = val_weapons[v] |
| names = [WEAPON_NAMES[w] for w in weapons[:8]] |
| suffix = f" +{len(weapons)-8} more" if len(weapons) > 8 else "" |
| print(f" {v:>10} ({v:#010x}): {', '.join(names)}{suffix}") |
|
|
| print("\n--- Fields with many distinct values (likely parameters) ---") |
| print(f"{'Offset':<10} {'Min':>10} {'Max':>10} {'Unique':>6} Sample values (Bazooka, Grenade, Shotgun, NinjaRope)") |
| print("-" * 90) |
|
|
| for di, byte_off, values, kind in interesting: |
| if kind != "varied": |
| continue |
| unique_count = len(set(values)) |
| min_v = min(values) |
| max_v = max(values) |
| samples = [values[1], values[6], values[11], values[37]] |
|
|
| sample_str = ", ".join(f"{v:>8}" for v in samples) |
| print(f"+0x{byte_off:03X} {min_v:>10} {max_v:>10} {unique_count:>6} [{sample_str}]") |
|
|
|
|
| def print_fire_params_by_type(entries: list[bytes]): |
| """Group weapons by fire_type and print fire_params for each group.""" |
| groups: dict[int, list[int]] = {} |
| for i, entry in enumerate(entries): |
| ftype = sdword_at(entry, 0x30) |
| groups.setdefault(ftype, []).append(i) |
|
|
| print("\n" + "=" * 80) |
| print("FIRE PARAMS BY WEAPON TYPE") |
| print("=" * 80) |
|
|
| for ftype in sorted(groups.keys()): |
| if ftype == 0: |
| continue |
| type_name = FIRE_TYPE_NAMES.get(ftype, f"type_{ftype}") |
| weapon_ids = groups[ftype] |
| print(f"\n--- Type {ftype} ({type_name}): {len(weapon_ids)} weapons ---") |
| print(f"Weapons: {', '.join(WEAPON_NAMES[w] for w in weapon_ids)}") |
|
|
| |
| num_dwords = (ENTRY_SIZE - FIRE_PARAMS_OFFSET) // 4 |
| for di in range(min(num_dwords, 40)): |
| byte_off = FIRE_PARAMS_OFFSET + di * 4 |
| values = {w: dword_at(entries[w], byte_off) for w in weapon_ids} |
| unique = set(values.values()) |
| if len(unique) > 1 or (len(unique) == 1 and list(unique)[0] != 0): |
| val_str = ", ".join(f"{WEAPON_NAMES[w][:8]}={values[w]}" for w in weapon_ids[:6]) |
| print(f" +0x{byte_off:03X} fp[{di}]: {val_str}") |
|
|
|
|
| def main(): |
| if len(sys.argv) < 2: |
| print(f"Usage: {sys.argv[0]} <weapon_table.bin>") |
| sys.exit(1) |
|
|
| data = Path(sys.argv[1]).read_bytes() |
| entries = read_entries(data) |
|
|
| print_header_fields(entries) |
| print_unknown_header_region(entries) |
| analyze_fire_params(entries) |
| print_fire_params_by_type(entries) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
