command_block_lists.py

# Command-state names corresponding to nmspy's EnvironmentLocation values.
# nmspy's internal enum calls value 1 "Default", while the game-facing
# cGcEnvironmentLocation enum calls the same value "Space".  It covers open
# space in both a ship and on-foot EVA; it is not the unknown/default fallback.
# The unset None_ value (0) intentionally resolves to UNKNOWN.
COMMAND_STATE_BY_LOCATION_VALUE = {
    0: "UNKNOWN",
    1: "Space",
    2: "SpaceStation",
    3: "PlanetOnFoot",
    4: "PlanetInShip",
    5: "PlanetInVehicle",
    6: "Underwater",
    7: "Cave",
    8: "IndoorInBase",
    9: "Freighter",
    10: "FreighterInternals",
    11: "AbandonedFreighter",
    12: "InFleet",
    13: "InSpaceObject",
    14: "Nexus",
    15: "Anomaly",
}

COMMAND_STATE_BY_LOCATION_NAME = {
    "Default": "Space",
}

# The state logger can retain a trustworthy coarse state while the live
# EnvironmentLocation pointer is temporarily unavailable or corrupt.  Use the
# most conservative matching granular state as a fallback in that case.
COMMAND_STATE_BY_GAME_STATE = {
    "ON_FOOT": "PlanetOnFoot",
    "IN_COCKPIT": "PlanetInShip",
    "NOT_ON_FOOT": "UNKNOWN",
}

ON_PLANET_STATES = {
    "PlanetOnFoot",
    "PlanetInShip",
    "PlanetInVehicle",
    "Underwater",
    "Cave",
    "IndoorInBase",
}

# Restrictions shared by states where the player controls the character.
ON_FOOT_BLOCKED_COMMANDS = [
    "land",
    "anomaly",
    "boost",
    "cruise",
]

# Most character-control states block launch. Omit this layer in states where
# launching should remain available.
LAUNCH_BLOCKED_COMMANDS = [
    "launch",
]

# Restrictions shared by states where the player controls a ship.
IN_COCKPIT_BLOCKED_COMMANDS = [
    "sky",
    "jet",
    "walk",
    "coords",
    "ship",
    "pet",
    "dance",
    "sit",
    "selfie",
]

# EnvironmentLocation cannot distinguish a ship in open space from on-foot
# EVA. Keep the conservative cockpit restrictions there, except that jet and
# walk must remain usable for EVA recovery.
SPACE_BLOCKED_COMMANDS = [
    command for command in IN_COCKPIT_BLOCKED_COMMANDS
    if command not in {"jet", "walk"}
]

# Add commands here to block them in every planetary environment.
ON_PLANET_BLOCKED_COMMANDS = [
]

# Teleport is a recovery mechanism as well as normal travel, so location must
# never prevent it. Loading/in-progress guards still prevent overlapping warps.
LOCATION_INDEPENDENT_COMMANDS = {
    "teleport",
}

# Restrictions shared by stations, space, freighters, and other non-planets.
OFF_PLANET_BLOCKED_COMMANDS = ["nuke"]

# Unknown includes the conservative cockpit baseline plus off-planet rules.
UNKNOWN_BLOCKED_COMMANDS = [
    *IN_COCKPIT_BLOCKED_COMMANDS,
    *OFF_PLANET_BLOCKED_COMMANDS,
]


BLOCKED_COMMANDS_BY_STATE = {
    "Space": [
        *SPACE_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "SpaceStation": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "PlanetOnFoot": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *ON_PLANET_BLOCKED_COMMANDS,
    ],
    "PlanetInShip": [
        *IN_COCKPIT_BLOCKED_COMMANDS,
        *ON_PLANET_BLOCKED_COMMANDS,
    ],
    "PlanetInVehicle": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *ON_PLANET_BLOCKED_COMMANDS,
    ],
    "Underwater": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *ON_PLANET_BLOCKED_COMMANDS,
    ],
    "Cave": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *ON_PLANET_BLOCKED_COMMANDS,
    ],
    "IndoorInBase": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *ON_PLANET_BLOCKED_COMMANDS,
    ],
    "Freighter": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "FreighterInternals": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "AbandonedFreighter": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "InFleet": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "InSpaceObject": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *LAUNCH_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "Nexus": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "Anomaly": [
        *ON_FOOT_BLOCKED_COMMANDS,
        *OFF_PLANET_BLOCKED_COMMANDS,
    ],
    "GALAXY_MAP": [
        *UNKNOWN_BLOCKED_COMMANDS,
    ],
    "UNKNOWN": [
        *UNKNOWN_BLOCKED_COMMANDS,
    ],
}


def resolve_command_state(data, fallback="UNKNOWN"):
    """Resolve a state snapshot to one of the command block-list keys."""
    data = data or {}
    game_state = data.get("state")
    if game_state == "GALAXY_MAP":
        return game_state

    coarse_fallback = COMMAND_STATE_BY_GAME_STATE.get(game_state)

    environment = data.get("environment") or {}
    location = environment.get("location_stable")
    if location is None:
        location = environment.get("location")
    location = COMMAND_STATE_BY_LOCATION_NAME.get(location, location)
    if location in BLOCKED_COMMANDS_BY_STATE:
        return location

    raw = environment.get("location_stable_raw")
    if raw is None:
        raw = environment.get("location_raw")
    try:
        location = COMMAND_STATE_BY_LOCATION_VALUE.get(int(raw))
    except (TypeError, ValueError):
        location = None

    # Raw zero means the granular location is unset, not that it should
    # overrule a valid coarse state reported by the state logger.
    if location == "UNKNOWN" and coarse_fallback:
        location = None

    fallback = COMMAND_STATE_BY_GAME_STATE.get(fallback, fallback)
    fallback = COMMAND_STATE_BY_LOCATION_NAME.get(fallback, fallback)
    if coarse_fallback and fallback == "UNKNOWN":
        fallback = coarse_fallback
    elif fallback not in BLOCKED_COMMANDS_BY_STATE:
        fallback = coarse_fallback

    return location or (fallback if fallback in BLOCKED_COMMANDS_BY_STATE else "UNKNOWN")


def blocked_commands_for_state(state):
    """Return the configured list, failing closed for an unrecognized state."""
    state = COMMAND_STATE_BY_LOCATION_NAME.get(state, state)
    blocked = BLOCKED_COMMANDS_BY_STATE.get(state, BLOCKED_COMMANDS_BY_STATE["UNKNOWN"])
    return [command for command in blocked if command not in LOCATION_INDEPENDENT_COMMANDS]