385 lines
13 KiB
Python
385 lines
13 KiB
Python
|
"""Reference data mappings: PokeDB identifiers → seed format values."""
|
||
|
|
|
||
|
|
from __future__ import annotations
|
||
|
|
|
||
|
|
import json
|
||
|
|
import re
|
||
|
|
import sys
|
||
|
|
from pathlib import Path
|
||
|
|
from typing import Any
|
||
|
|
|
||
|
|
from .loader import PokeDBData
|
||
|
|
|
||
|
|
|
||
|
|
# ---------------------------------------------------------------------------
|
||
|
|
# Encounter method mapping
|
||
|
|
# ---------------------------------------------------------------------------
|
||
|
|
|
||
|
|
# PokeDB encounter_method_identifier → our simplified method name.
|
||
|
|
# Keys can be exact matches or prefix patterns (ending with *).
|
||
|
|
ENCOUNTER_METHOD_MAP: dict[str, str] = {
|
||
|
|
# Walking / grass / cave
|
||
|
|
"walking-tall-grass": "walk",
|
||
|
|
"walking-long-grass": "walk",
|
||
|
|
"walking-cave": "walk",
|
||
|
|
"walking-bridge": "walk",
|
||
|
|
"walking-building": "walk",
|
||
|
|
"walking-sand": "walk",
|
||
|
|
"walking-snow": "walk",
|
||
|
|
"walking-rough-terrain": "walk",
|
||
|
|
"walking-marsh": "walk",
|
||
|
|
"walking-puddle": "walk",
|
||
|
|
"walking-flower-field": "walk",
|
||
|
|
"walking-ice": "walk",
|
||
|
|
"walking-forest": "walk",
|
||
|
|
"walking-snowfield": "walk",
|
||
|
|
"dark-grass": "walk",
|
||
|
|
"shaking-grass": "walk",
|
||
|
|
"rustling-grass": "walk",
|
||
|
|
"yellow-flowers": "walk",
|
||
|
|
"red-flowers": "walk",
|
||
|
|
"purple-flowers": "walk",
|
||
|
|
# Surfing
|
||
|
|
"surfing": "surf",
|
||
|
|
"surfing-ocean": "surf",
|
||
|
|
"surfing-puddle": "surf",
|
||
|
|
"surfing-rapids": "surf",
|
||
|
|
"surfing-underwater": "surf",
|
||
|
|
"rippling-water": "surf",
|
||
|
|
# Fishing
|
||
|
|
"fishing-old-rod": "old-rod",
|
||
|
|
"fishing-good-rod": "good-rod",
|
||
|
|
"fishing-super-rod": "super-rod",
|
||
|
|
"fishing": "fishing",
|
||
|
|
"fishing-special": "fishing",
|
||
|
|
# Rock smash
|
||
|
|
"rock-smash": "rock-smash",
|
||
|
|
# Headbutt
|
||
|
|
"headbutt-low": "headbutt",
|
||
|
|
"headbutt-normal": "headbutt",
|
||
|
|
"headbutt-high": "headbutt",
|
||
|
|
# Gift / special acquisition
|
||
|
|
"npc-gift": "gift",
|
||
|
|
"egg": "gift",
|
||
|
|
"revive": "gift",
|
||
|
|
"fossil": "gift",
|
||
|
|
# Trade
|
||
|
|
"npc-trade": "trade",
|
||
|
|
# Overworld / symbol encounters (Gen 8+)
|
||
|
|
"symbol-encounter": "walk",
|
||
|
|
"wanderer": "walk",
|
||
|
|
"flying": "walk",
|
||
|
|
# Static / fixed
|
||
|
|
"fixed-encounter": "static",
|
||
|
|
"static-encounter": "static",
|
||
|
|
"legendary-encounter": "static",
|
||
|
|
"interactable": "static",
|
||
|
|
# Special methods
|
||
|
|
"swarm": "swarm",
|
||
|
|
"poke-radar": "pokeradar",
|
||
|
|
"dual-slot-mode": "dual-slot",
|
||
|
|
"honey-tree": "honey",
|
||
|
|
"trophy-garden": "walk",
|
||
|
|
"great-marsh": "walk",
|
||
|
|
"cave-spot": "walk",
|
||
|
|
"bubble-spot": "surf",
|
||
|
|
"sand-spot": "walk",
|
||
|
|
"horde": "walk",
|
||
|
|
"sos-encounter": "walk",
|
||
|
|
"ambush": "walk",
|
||
|
|
# Seaweed / diving
|
||
|
|
"diving": "surf",
|
||
|
|
"seaweed": "surf",
|
||
|
|
# Raids
|
||
|
|
"max-raid": "raid",
|
||
|
|
"dynamax-adventure": "raid",
|
||
|
|
"tera-raid": "raid",
|
||
|
|
# Misc
|
||
|
|
"roaming": "roaming",
|
||
|
|
"safari-zone": "walk",
|
||
|
|
"bug-contest": "walk",
|
||
|
|
}
|
||
|
|
|
||
|
|
# Prefix-based fallbacks for methods not explicitly listed above.
|
||
|
|
_METHOD_PREFIX_MAP: list[tuple[str, str]] = [
|
||
|
|
("walking-", "walk"),
|
||
|
|
("surfing-", "surf"),
|
||
|
|
("fishing-", "fishing"),
|
||
|
|
("headbutt-", "headbutt"),
|
||
|
|
("flying-", "walk"),
|
||
|
|
]
|
||
|
|
|
||
|
|
|
||
|
|
def map_encounter_method(method_identifier: str) -> str | None:
|
||
|
|
"""Map a PokeDB encounter method to our simplified method name.
|
||
|
|
|
||
|
|
Returns None if the method is unrecognized.
|
||
|
|
"""
|
||
|
|
if method_identifier in ENCOUNTER_METHOD_MAP:
|
||
|
|
return ENCOUNTER_METHOD_MAP[method_identifier]
|
||
|
|
|
||
|
|
for prefix, mapped in _METHOD_PREFIX_MAP:
|
||
|
|
if method_identifier.startswith(prefix):
|
||
|
|
return mapped
|
||
|
|
|
||
|
|
return None
|
||
|
|
|
||
|
|
|
||
|
|
# ---------------------------------------------------------------------------
|
||
|
|
# Version mapping
|
||
|
|
# ---------------------------------------------------------------------------
|
||
|
|
|
||
|
|
# PokeDB version identifiers that differ from our game slugs.
|
||
|
|
# Most are 1:1, these handle exceptions.
|
||
|
|
_VERSION_OVERRIDES: dict[str, str] = {
|
||
|
|
"lets-go-pikachu": "lets-go-pikachu",
|
||
|
|
"lets-go-eevee": "lets-go-eevee",
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
def build_version_map(
|
||
|
|
pokedb: PokeDBData,
|
||
|
|
version_groups: dict[str, Any],
|
||
|
|
) -> dict[str, str]:
|
||
|
|
"""Build a mapping from PokeDB version_identifier → our game slug.
|
||
|
|
|
||
|
|
Returns the mapping dict. Logs warnings for unmapped versions.
|
||
|
|
"""
|
||
|
|
# Collect all our known game slugs
|
||
|
|
our_slugs: set[str] = set()
|
||
|
|
for vg in version_groups.values():
|
||
|
|
for slug in vg.get("versions", []):
|
||
|
|
our_slugs.add(slug)
|
||
|
|
|
||
|
|
# Collect all PokeDB version identifiers
|
||
|
|
pokedb_versions: set[str] = set()
|
||
|
|
for v in pokedb.versions:
|
||
|
|
identifier = v.get("identifier", "")
|
||
|
|
if identifier:
|
||
|
|
pokedb_versions.add(identifier)
|
||
|
|
|
||
|
|
mapping: dict[str, str] = {}
|
||
|
|
|
||
|
|
for pdb_ver in sorted(pokedb_versions):
|
||
|
|
if pdb_ver in _VERSION_OVERRIDES:
|
||
|
|
mapping[pdb_ver] = _VERSION_OVERRIDES[pdb_ver]
|
||
|
|
elif pdb_ver in our_slugs:
|
||
|
|
mapping[pdb_ver] = pdb_ver
|
||
|
|
# else: PokeDB version not in our version_groups (expected for some)
|
||
|
|
|
||
|
|
# Report our games that have no PokeDB mapping
|
||
|
|
mapped_slugs = set(mapping.values())
|
||
|
|
unmapped_ours = our_slugs - mapped_slugs
|
||
|
|
if unmapped_ours:
|
||
|
|
print(f" Versions in our config with no PokeDB match: {sorted(unmapped_ours)}")
|
||
|
|
|
||
|
|
return mapping
|
||
|
|
|
||
|
|
|
||
|
|
# ---------------------------------------------------------------------------
|
||
|
|
# Pokemon form mapping
|
||
|
|
# ---------------------------------------------------------------------------
|
||
|
|
|
||
|
|
def _normalize_slug(identifier: str) -> str:
|
||
|
|
"""Normalize a PokeDB pokemon_form_identifier to a PokeAPI-style slug.
|
||
|
|
|
||
|
|
PokeDB uses "pidgey-default" for base forms — strip the "-default" suffix.
|
||
|
|
Non-default forms like "rattata-alola" are already PokeAPI-style slugs.
|
||
|
|
"""
|
||
|
|
if identifier.endswith("-default"):
|
||
|
|
return identifier[: -len("-default")]
|
||
|
|
return identifier
|
||
|
|
|
||
|
|
|
||
|
|
def _name_to_slug(name: str) -> str:
|
||
|
|
"""Convert a display name to a PokeAPI-style slug.
|
||
|
|
|
||
|
|
"Bulbasaur" → "bulbasaur"
|
||
|
|
"Mr. Mime" → "mr-mime"
|
||
|
|
"Farfetch'd" → "farfetchd"
|
||
|
|
"Nidoran♀" → "nidoran-f"
|
||
|
|
"Nidoran♂" → "nidoran-m"
|
||
|
|
"Flabébé" → "flabebe"
|
||
|
|
"Type: Null" → "type-null"
|
||
|
|
"""
|
||
|
|
s = name.lower()
|
||
|
|
s = s.replace("♀", "-f").replace("♂", "-m")
|
||
|
|
s = s.replace("'", "").replace("'", "").replace(".", "").replace(":", "")
|
||
|
|
s = s.replace("é", "e").replace("É", "e")
|
||
|
|
s = s.replace(" ", "-")
|
||
|
|
# Collapse multiple hyphens
|
||
|
|
s = re.sub(r"-+", "-", s)
|
||
|
|
return s.strip("-")
|
||
|
|
|
||
|
|
|
||
|
|
def _name_to_form_slug(name: str) -> str | None:
|
||
|
|
"""Convert a display name with form suffix to a PokeAPI-style slug.
|
||
|
|
|
||
|
|
"Rattata (Alola)" → "rattata-alola"
|
||
|
|
"Basculin (Blue Striped)" → "basculin-blue-striped"
|
||
|
|
"Deoxys Normal" → "deoxys-normal" (space-separated variant)
|
||
|
|
"""
|
||
|
|
# Try parenthesized form: "Base (Suffix)"
|
||
|
|
m = re.match(r"^(.+?)\s*\((.+)\)$", name)
|
||
|
|
if m:
|
||
|
|
base = _name_to_slug(m.group(1))
|
||
|
|
suffix = _name_to_slug(m.group(2))
|
||
|
|
return f"{base}-{suffix}"
|
||
|
|
|
||
|
|
# Try space-separated form: "Deoxys Normal"
|
||
|
|
parts = name.split()
|
||
|
|
if len(parts) >= 2:
|
||
|
|
return _name_to_slug(name)
|
||
|
|
|
||
|
|
return None
|
||
|
|
|
||
|
|
|
||
|
|
class PokemonMapper:
|
||
|
|
"""Maps PokeDB pokemon_form_identifier → (pokeapi_id, display_name)."""
|
||
|
|
|
||
|
|
def __init__(self, pokemon_json_path: Path, pokedb: PokeDBData) -> None:
|
||
|
|
# Build slug → (pokeapi_id, name) from existing pokemon.json
|
||
|
|
self._slug_to_info: dict[str, tuple[int, str]] = {}
|
||
|
|
self._id_to_info: dict[int, tuple[int, str]] = {} # pokeapi_id → (national_dex, name)
|
||
|
|
self._unmapped: set[str] = set()
|
||
|
|
|
||
|
|
if pokemon_json_path.exists():
|
||
|
|
with open(pokemon_json_path) as f:
|
||
|
|
pokemon_list = json.load(f)
|
||
|
|
|
||
|
|
for p in pokemon_list:
|
||
|
|
pid = p["pokeapi_id"]
|
||
|
|
name = p["name"]
|
||
|
|
ndex = p["national_dex"]
|
||
|
|
self._id_to_info[pid] = (ndex, name)
|
||
|
|
|
||
|
|
# Index by base slug (from pokeapi_id for base forms)
|
||
|
|
slug = _name_to_slug(name)
|
||
|
|
self._slug_to_info[slug] = (pid, name)
|
||
|
|
|
||
|
|
# Also index by form slug if it has a form suffix
|
||
|
|
form_slug = _name_to_form_slug(name)
|
||
|
|
if form_slug and form_slug != slug:
|
||
|
|
self._slug_to_info[form_slug] = (pid, name)
|
||
|
|
|
||
|
|
# Build index from PokeDB pokemon_forms.json if it has useful fields
|
||
|
|
self._pokedb_form_index: dict[str, dict] = {}
|
||
|
|
for form in pokedb.pokemon_forms:
|
||
|
|
identifier = form.get("identifier", "")
|
||
|
|
if identifier:
|
||
|
|
self._pokedb_form_index[identifier] = form
|
||
|
|
|
||
|
|
def lookup(self, pokemon_form_identifier: str | None) -> tuple[int, str] | None:
|
||
|
|
"""Look up a PokeDB pokemon_form_identifier.
|
||
|
|
|
||
|
|
Returns (pokeapi_id, display_name) or None if unmapped.
|
||
|
|
"""
|
||
|
|
if not pokemon_form_identifier:
|
||
|
|
return None
|
||
|
|
|
||
|
|
slug = _normalize_slug(pokemon_form_identifier)
|
||
|
|
|
||
|
|
# Direct slug match
|
||
|
|
if slug in self._slug_to_info:
|
||
|
|
return self._slug_to_info[slug]
|
||
|
|
|
||
|
|
# Try the PokeDB form record for a pokemon_id field
|
||
|
|
form_record = self._pokedb_form_index.get(pokemon_form_identifier, {})
|
||
|
|
pokemon_id = form_record.get("pokemon_id")
|
||
|
|
if pokemon_id and pokemon_id in self._id_to_info:
|
||
|
|
ndex, name = self._id_to_info[pokemon_id]
|
||
|
|
# Cache for future lookups
|
||
|
|
self._slug_to_info[slug] = (pokemon_id, name)
|
||
|
|
return (pokemon_id, name)
|
||
|
|
|
||
|
|
# Track unmapped
|
||
|
|
if pokemon_form_identifier not in self._unmapped:
|
||
|
|
self._unmapped.add(pokemon_form_identifier)
|
||
|
|
|
||
|
|
return None
|
||
|
|
|
||
|
|
def report_unmapped(self) -> None:
|
||
|
|
"""Print warnings for any unmapped identifiers."""
|
||
|
|
if self._unmapped:
|
||
|
|
print(
|
||
|
|
f"\nWarning: {len(self._unmapped)} unmapped pokemon form identifiers:",
|
||
|
|
file=sys.stderr,
|
||
|
|
)
|
||
|
|
for ident in sorted(self._unmapped):
|
||
|
|
print(f" - {ident}", file=sys.stderr)
|
||
|
|
|
||
|
|
|
||
|
|
# ---------------------------------------------------------------------------
|
||
|
|
# Location area mapping
|
||
|
|
# ---------------------------------------------------------------------------
|
||
|
|
|
||
|
|
# Region prefixes to strip from location identifiers (matching Go tool behavior).
|
||
|
|
_REGION_PREFIXES = [
|
||
|
|
"kanto-", "johto-", "hoenn-", "sinnoh-",
|
||
|
|
"unova-", "kalos-", "alola-", "galar-",
|
||
|
|
"hisui-", "paldea-",
|
||
|
|
]
|
||
|
|
|
||
|
|
|
||
|
|
def _identifier_to_name(identifier: str) -> str:
|
||
|
|
"""Convert a hyphenated identifier to a Title Case display name.
|
||
|
|
|
||
|
|
"route-01-kanto" → "Route 01 Kanto" (region stripping done separately)
|
||
|
|
"viridian-forest" → "Viridian Forest"
|
||
|
|
"""
|
||
|
|
return identifier.replace("-", " ").title()
|
||
|
|
|
||
|
|
|
||
|
|
class LocationMapper:
|
||
|
|
"""Maps PokeDB location_area_identifier → (location_name, area_suffix)."""
|
||
|
|
|
||
|
|
def __init__(self, pokedb: PokeDBData) -> None:
|
||
|
|
# Build location_area_identifier → location_identifier lookup
|
||
|
|
self._area_to_location: dict[str, str] = {}
|
||
|
|
# location_identifier → location display name
|
||
|
|
self._location_names: dict[str, str] = {}
|
||
|
|
# location_area_identifier → area display name
|
||
|
|
self._area_names: dict[str, str] = {}
|
||
|
|
|
||
|
|
# Index locations
|
||
|
|
for loc in pokedb.locations:
|
||
|
|
identifier = loc.get("identifier", "")
|
||
|
|
name = loc.get("name", "")
|
||
|
|
if identifier:
|
||
|
|
self._location_names[identifier] = name if name else self._clean_location_name(identifier)
|
||
|
|
|
||
|
|
# Index location areas
|
||
|
|
for area in pokedb.location_areas:
|
||
|
|
area_id = area.get("identifier", "")
|
||
|
|
loc_id = area.get("location_identifier", "")
|
||
|
|
area_name = area.get("name", "")
|
||
|
|
if area_id:
|
||
|
|
self._area_to_location[area_id] = loc_id
|
||
|
|
self._area_names[area_id] = area_name if area_name else ""
|
||
|
|
|
||
|
|
@staticmethod
|
||
|
|
def _clean_location_name(identifier: str) -> str:
|
||
|
|
"""Clean a location identifier into a display name."""
|
||
|
|
name = identifier
|
||
|
|
for prefix in _REGION_PREFIXES:
|
||
|
|
if name.startswith(prefix):
|
||
|
|
name = name[len(prefix):]
|
||
|
|
break
|
||
|
|
return _identifier_to_name(name)
|
||
|
|
|
||
|
|
def get_location_name(self, location_area_identifier: str) -> str:
|
||
|
|
"""Get the display name for a location area's parent location."""
|
||
|
|
loc_id = self._area_to_location.get(location_area_identifier, "")
|
||
|
|
if loc_id and loc_id in self._location_names:
|
||
|
|
return self._location_names[loc_id]
|
||
|
|
# Fallback: derive from the area identifier itself
|
||
|
|
return self._clean_location_name(location_area_identifier)
|
||
|
|
|
||
|
|
def get_area_name(self, location_area_identifier: str) -> str:
|
||
|
|
"""Get the display name for a specific location area."""
|
||
|
|
return self._area_names.get(location_area_identifier, "")
|
||
|
|
|
||
|
|
def get_location_identifier(self, location_area_identifier: str) -> str:
|
||
|
|
"""Get the parent location identifier for a location area."""
|
||
|
|
return self._area_to_location.get(location_area_identifier, "")
|