improve new boss setup automation

BOSS_UPDATE_GUIDE.md

@@ -25,19 +25,28 @@ The official client supplies:
 - gold reward range
 - possible sword and shield drops
 - item-specific sword and shield drop chances
+- room capacity rules for each world number
 
-The optimizer automatically picks the rarest configured sword and shield in the
-boss drop pool as the featured epic drops.
+The setup helper lists every newly discovered enemy so the actual boss can be
+selected. It then lists only that enemy's official sword and shield drops and
+asks which two are the featured boss drops. If their world label contains a
+number such as `W11`, the matching official room capacity is selected
+automatically and can still be confirmed or changed.
 
 ## What still needs one measurement
 
 - effective downtime from the killing hit to the first hit after respawn
 - normal gold divisor
-- maximum accounts per room, if the new world does not use 8
+- world number or room capacity only if the official item labels do not identify
+  the world clearly
 
 These values are stored in `boss_overrides.json`. The website settings can
 override both drop chances and room capacity at any time.
 
+Until a timing measurement is supplied, effective downtime defaults to the
+official raw respawn plus `1.15` seconds. The existing three main bosses all
+matched this offset closely, but a new boss should still be measured once.
+
 ## Add a new boss
 
 1. Start the optimizer locally.
@@ -67,8 +76,9 @@ SM_BOSS_PROBE.copyJson()
 7. Run `configure_new_boss.bat`.
 
 The batch refreshes the official catalog, reads the probe JSON from the
-clipboard, asks only for the remaining values, updates `boss_overrides.json`,
-and pushes the optimizer files. The new boss then appears as a settings preset.
+clipboard, asks which new enemy and boss drops to use, confirms the inferred
+world and remaining measured values, updates `boss_overrides.json`, and pushes
+the optimizer files. The new boss then appears as a settings preset.
 
 If the optimizer uses another port, replace `8000` in the fetch command with
 that port.

game_catalog.json

@@ -13,6 +13,19 @@
     "data_sha256": "f52cbba9daf2b84ae9d311b17ee2072088ac87ae63c10b0aa82b3078804b4f70"
   },
   "level_scale_per_level": 0.25,
+  "world_room_capacities": {
+    "default": 8,
+    "by_world": {
+      "3": 4,
+      "6": 4,
+      "100": 16,
+      "102": 16,
+      "103": 32,
+      "104": 6,
+      "105": 16,
+      "106": -1
+    }
+  },
   "enemies": [
     {
       "name": "Roundhead",

tests/test_game_catalog_sync.py

@@ -3,7 +3,12 @@ from pathlib import Path
 
 import pytest
 
-from tools.sync_game_catalog import CatalogError, _evaluate_arithmetic
+from tools.sync_game_catalog import (
+    CatalogError,
+    _evaluate_arithmetic,
+    _parse_decoded_world_room_capacities,
+)
+from tools.configure_new_boss import room_capacity_for_world, world_number_from_items
 
 
 ROOT = Path(__file__).resolve().parents[1]
@@ -23,6 +28,9 @@ def test_generated_catalog_contains_complete_official_item_sets():
     ))
     assert catalog["level_scale_per_level"] == pytest.approx(0.25)
     assert len(catalog["enemies"]) >= 26
+    assert catalog["world_room_capacities"]["default"] == 8
+    assert catalog["world_room_capacities"]["by_world"]["3"] == 4
+    assert catalog["world_room_capacities"]["by_world"]["6"] == 4
 
 
 def test_catalog_keeps_stats_and_images_aligned_by_game_type():
@@ -55,3 +63,46 @@ def test_rotation_expression_parser_only_accepts_arithmetic():
     assert _evaluate_arithmetic("-12/0x3*(4+2)") == pytest.approx(-24)
     with pytest.raises(CatalogError):
         _evaluate_arithmetic("__import__('os').system('echo no')")
+
+
+def test_room_capacity_parser_reads_default_and_special_worlds():
+    source = (
+        "this['onlineCounter']['element']&&(0x3===this['worldNumber']||"
+        "0x6===this['worldNumber']?this['maxClients']=0x4:this['maxClients']=0x8,"
+        "0x64!=this['worldNumber']&&0x66!=this['worldNumber']||(this['maxClients']=0x10),"
+        "0x67==this['worldNumber']&&(this['maxClients']=0x20),"
+        "0x68==this['worldNumber']&&(this['maxClients']=0x6),"
+        "0x69==this['worldNumber']&&(this['maxClients']=0x10),"
+        "0x6a==this['worldNumber']&&(this['maxClients']=-0x1));"
+    )
+    rules = _parse_decoded_world_room_capacities(source)
+
+    assert rules["default"] == 8
+    assert rules["by_world"] == {
+        "3": 4,
+        "6": 4,
+        "100": 16,
+        "102": 16,
+        "103": 32,
+        "104": 6,
+        "105": 16,
+        "106": -1,
+    }
+
+
+def test_boss_config_infers_world_and_room_capacity_from_selected_drops():
+    catalog = {
+        "world_room_capacities": {
+            "default": 8,
+            "by_world": {"3": 4, "6": 4},
+        }
+    }
+    items = [
+        {"name": "Drop Sword", "world": "New Realm W11"},
+        {"name": "Drop Shield", "world": "New Realm W11"},
+    ]
+
+    world_number = world_number_from_items(items)
+    assert world_number == 11
+    assert room_capacity_for_world(catalog, world_number) == 8
+    assert room_capacity_for_world(catalog, 3) == 4

tools/configure_new_boss.py

@@ -45,6 +45,14 @@ def prompt(label: str, default: Any, cast=str):
     return cast(raw)
 
 
+def prompt_optional_int(label: str, default: int | None = None) -> int | None:
+    suffix = f" [{default}]" if default is not None else " [unknown]"
+    raw = input(f"{label}{suffix}: ").strip()
+    if not raw:
+        return default
+    return int(raw)
+
+
 def slug(value: str) -> str:
     return re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-")
 
@@ -57,10 +65,18 @@ def item_by_type(catalog: dict[str, Any], category: str) -> dict[int, dict[str,
     }
 
 
-def featured_drop(catalog: dict[str, Any], enemy: dict[str, Any], category: str):
+def drop_candidates(
+    catalog: dict[str, Any],
+    enemy: dict[str, Any],
+    category: str,
+) -> list[dict[str, Any]]:
     list_key = "dropsSword" if category == "swords" else "dropsShield"
     items = item_by_type(catalog, category)
-    candidates = [items[value] for value in enemy.get(list_key, []) if value in items]
+    return [items[value] for value in enemy.get(list_key, []) if value in items]
+
+
+def featured_drop(catalog: dict[str, Any], enemy: dict[str, Any], category: str):
+    candidates = drop_candidates(catalog, enemy, category)
     if not candidates:
         return "", 0.0
     chosen = min(
@@ -74,6 +90,60 @@ def featured_drop(catalog: dict[str, Any], enemy: dict[str, Any], category: str)
     return chosen["name"], chance
 
 
+def choose_drop(
+    catalog: dict[str, Any],
+    enemy: dict[str, Any],
+    category: str,
+    existing_name: str = "",
+) -> tuple[dict[str, Any] | None, float]:
+    candidates = drop_candidates(catalog, enemy, category)
+    singular = "sword" if category == "swords" else "shield"
+    if not candidates:
+        print(f"No official {singular} drops are configured for this enemy.")
+        return None, 0.0
+
+    default_name, _default_chance = featured_drop(catalog, enemy, category)
+    default_index = next(
+        (
+            index
+            for index, item in enumerate(candidates, start=1)
+            if item["name"] == (existing_name or default_name)
+        ),
+        1,
+    )
+    print(f"\nOfficial {singular} drop candidates:")
+    for index, item in enumerate(candidates, start=1):
+        chance = float(item.get("drop_chance", item.get("commonnessPercentage", 0.0)) or 0.0)
+        world = str(item.get("world") or "unknown world")
+        print(f"  {index:>2}  {item['name']}  {chance:g}%  ({world})")
+    selected = prompt(f"Boss {singular} number", default_index, int)
+    if not 1 <= selected <= len(candidates):
+        raise SystemExit(f"Boss {singular} number must be between 1 and {len(candidates)}.")
+    item = candidates[selected - 1]
+    chance = float(item.get("drop_chance", item.get("commonnessPercentage", 0.0)) or 0.0)
+    return item, chance
+
+
+def world_number_from_items(items: list[dict[str, Any] | None]) -> int | None:
+    values = set()
+    for item in items:
+        if not item:
+            continue
+        match = re.search(r"\bW(\d+)\b", str(item.get("world") or ""), re.IGNORECASE)
+        if match:
+            values.add(int(match.group(1)))
+    return next(iter(values)) if len(values) == 1 else None
+
+
+def room_capacity_for_world(catalog: dict[str, Any], world_number: int | None) -> int:
+    rules = catalog.get("world_room_capacities") or {}
+    default = int(rules.get("default", 8) or 8)
+    if world_number is None:
+        return default
+    limit = int((rules.get("by_world") or {}).get(str(world_number), default))
+    return 50 if limit < 0 else limit
+
+
 def choose_enemy(catalog: dict[str, Any], overrides: dict[str, Any], wanted: int | None):
     enemies = catalog.get("enemies") or []
     if wanted is not None:
@@ -130,8 +200,19 @@ def main() -> int:
     enemy = choose_enemy(catalog, overrides, wanted_type)
     enemy_type = int(enemy["type"])
     existing = (overrides.get("bosses") or {}).get(str(enemy_type), {})
-    sword_name, sword_chance = featured_drop(catalog, enemy, "swords")
-    shield_name, shield_chance = featured_drop(catalog, enemy, "shields")
+    sword_item, sword_chance = choose_drop(
+        catalog, enemy, "swords", str(existing.get("sword_item") or "")
+    )
+    shield_item, shield_chance = choose_drop(
+        catalog, enemy, "shields", str(existing.get("shield_item") or "")
+    )
+    sword_name = str((sword_item or {}).get("name") or "")
+    shield_name = str((shield_item or {}).get("name") or "")
+    inferred_world = world_number_from_items([sword_item, shield_item])
+    existing_world = existing.get("world_number")
+    default_world = int(existing_world) if existing_world is not None else inferred_world
+    world_number = prompt_optional_int("World number", default_world)
+    inferred_capacity = room_capacity_for_world(catalog, world_number)
     default_delay = float(overrides.get("default_first_hit_delay_seconds", 1.15))
     automatic_respawn = float(enemy.get("respawDelay", 0.0)) / 1000.0 + default_delay
     measured_respawn = probe.get("effective_respawn_seconds")
@@ -151,6 +232,7 @@ def main() -> int:
         "key": prompt("Preset key", existing.get("key") or slug(enemy["name"])),
         "display_name": prompt("Displayed boss name", existing.get("display_name") or enemy["name"]),
         "order": prompt("Preset order", existing.get("order", enemy_type), int),
+        "world_number": world_number,
         "effective_respawn_seconds": prompt(
             "Kill hit -> first respawn hit (seconds)",
             measured_respawn if measured_respawn is not None else existing.get(
@@ -160,7 +242,7 @@ def main() -> int:
         ),
         "room_capacity": prompt(
             "Maximum accounts in one room",
-            existing.get("room_capacity", 8),
+            existing.get("room_capacity", inferred_capacity),
             int,
         ),
         "normal_gold_divisor": prompt(
@@ -170,13 +252,13 @@ def main() -> int:
             ),
             float,
         ),
-        "sword_item": prompt("Featured sword", existing.get("sword_item", sword_name)),
+        "sword_item": sword_name,
         "sword_drop_chance": prompt(
             "Sword drop chance as decimal (1% = 0.01)",
             existing.get("sword_drop_chance", sword_chance / 100.0),
             float,
         ),
-        "shield_item": prompt("Featured shield", existing.get("shield_item", shield_name)),
+        "shield_item": shield_name,
         "shield_drop_chance": prompt(
             "Shield drop chance as decimal (1% = 0.01)",
             existing.get("shield_drop_chance", shield_chance / 100.0),

tools/sync_game_catalog.py

@@ -302,6 +302,62 @@ def _find_item_arrays(bundle: str) -> dict[str, list[dict[str, Any]]]:
     return arrays
 
 
+def _parse_decoded_world_room_capacities(source: str) -> dict[str, Any]:
+    world = r"this\['worldNumber'\]"
+    clients = r"this\['maxClients'\]"
+    default_match = re.search(
+        rf"0x([0-9a-f]+)==={world}\|\|0x([0-9a-f]+)==={world}"
+        rf"\?{clients}=(0x[0-9a-f]+):{clients}=(0x[0-9a-f]+)",
+        source,
+        re.IGNORECASE,
+    )
+    pair_match = re.search(
+        rf"0x([0-9a-f]+)!={world}&&0x([0-9a-f]+)!={world}"
+        rf"\|\|\({clients}=(0x[0-9a-f]+)\)",
+        source,
+        re.IGNORECASE,
+    )
+    if not default_match or not pair_match:
+        raise CatalogError("Could not parse the official room-capacity defaults.")
+
+    first_world, second_world, shared_limit, default_limit = (
+        int(value, 16) for value in default_match.groups()
+    )
+    pair_first, pair_second, pair_limit = (
+        int(value, 16) for value in pair_match.groups()
+    )
+    by_world = {
+        str(first_world): shared_limit,
+        str(second_world): shared_limit,
+        str(pair_first): pair_limit,
+        str(pair_second): pair_limit,
+    }
+    for match in re.finditer(
+        rf"0x([0-9a-f]+)=={world}&&\({clients}=(-?0x[0-9a-f]+)\)",
+        source,
+        re.IGNORECASE,
+    ):
+        world_number = int(match.group(1), 16)
+        raw_limit = match.group(2)
+        limit = -int(raw_limit[3:], 16) if raw_limit.startswith("-") else int(raw_limit, 16)
+        by_world[str(world_number)] = limit
+
+    return {
+        "default": default_limit,
+        "by_world": dict(sorted(by_world.items(), key=lambda row: int(row[0]))),
+    }
+
+
+def _extract_world_room_capacities(bundle: str) -> dict[str, Any]:
+    decode_calls = _build_string_decoder(bundle)
+    marker = "this['maxClients']=0x6"
+    marker_pos = bundle.find(marker)
+    if marker_pos < 0:
+        raise CatalogError("Could not identify the official room-capacity rules.")
+    source = decode_calls(bundle[max(0, marker_pos - 1800) : marker_pos + 900])
+    return _parse_decoded_world_room_capacities(source)
+
+
 def _find_enemy_array(bundle: str) -> list[dict[str, Any]]:
     decode_calls = _build_string_decoder(bundle)
     best: list[dict[str, Any]] = []
@@ -615,6 +671,7 @@ def build_catalog(
             "data_sha256": hashlib.sha256(data_raw).hexdigest(),
         },
         "level_scale_per_level": _extract_level_scale(bundle),
+        "world_room_capacities": _extract_world_room_capacities(bundle),
         "enemies": enemies,
         "swords": [item for item in rows["swords"] if item["name"] != "Empty"],
         "shields": [item for item in rows["shields"] if item["name"] != "Empty"],