import orjson
import os
from pkgutil import get_data
from copy import deepcopy
from typing import TYPE_CHECKING, List, Dict, Optional, Union, Callable
from BaseClasses import Region, CollectionState
from worlds.generic.Rules import add_item_rule
from .locations import KDL3Location
from .names import location_name
from .options import BossShuffle
from .room import KDL3Room
if TYPE_CHECKING:
from . import KDL3World
default_levels = {
1: [0x770000, 0x770001, 0x770002, 0x770003, 0x770004, 0x770005, 0x770200],
2: [0x770006, 0x770007, 0x770008, 0x770009, 0x77000A, 0x77000B, 0x770201],
3: [0x77000C, 0x77000D, 0x77000E, 0x77000F, 0x770010, 0x770011, 0x770202],
4: [0x770012, 0x770013, 0x770014, 0x770015, 0x770016, 0x770017, 0x770203],
5: [0x770018, 0x770019, 0x77001A, 0x77001B, 0x77001C, 0x77001D, 0x770204],
}
first_stage_blacklist = {
# We want to confirm that the first stage can be completed without any items
0x77000A, # 2-5 needs Kine
0x770010, # 3-5 needs Cutter
0x77001B, # 5-4 needs Burning
}
first_world_limit = {
# We need to limit the number of very restrictive stages in level 1 on solo gens
*first_stage_blacklist, # all three of the blacklist stages need 2+ items for both checks
0x770006,
0x770007,
0x770012,
0x77001D,
}
def generate_valid_level(world: "KDL3World", level: int, stage: int,
possible_stages: List[int], placed_stages: List[Optional[int]]) -> int:
new_stage = world.random.choice(possible_stages)
if level == 1:
if stage == 0 and new_stage in first_stage_blacklist:
possible_stages.remove(new_stage)
return generate_valid_level(world, level, stage, possible_stages, placed_stages)
elif (not (world.multiworld.players > 1 or world.options.consumables or world.options.starsanity) and
new_stage in first_world_limit and
sum(p_stage in first_world_limit for p_stage in placed_stages)
>= (2 if world.options.open_world else 1)):
return generate_valid_level(world, level, stage, possible_stages, placed_stages)
return new_stage
def generate_rooms(world: "KDL3World", level_regions: Dict[int, Region]) -> None:
level_names = {location_name.level_names[level]: level for level in location_name.level_names}
room_data = orjson.loads(get_data(__name__, os.path.join("data", "Rooms.json")))
rooms: Dict[str, KDL3Room] = dict()
for room_entry in room_data:
room = KDL3Room(room_entry["name"], world.player, world.multiworld, None, room_entry["level"],
room_entry["stage"], room_entry["room"], room_entry["pointer"], room_entry["music"],
room_entry["default_exits"], room_entry["animal_pointers"], room_entry["enemies"],
room_entry["entity_load"], room_entry["consumables"], room_entry["consumables_pointer"])
room.add_locations({location: world.location_name_to_id[location] if location in world.location_name_to_id else
None for location in room_entry["locations"]
if (not any(x in location for x in ["1-Up", "Maxim"]) or
world.options.consumables.value) and ("Star" not in location
or world.options.starsanity.value)},
KDL3Location)
rooms[room.name] = room
for location in room.locations:
if "Animal" in location.name:
add_item_rule(location, lambda item: item.name in {
"Rick Spawn", "Kine Spawn", "Coo Spawn", "Nago Spawn", "ChuChu Spawn", "Pitch Spawn"
})
world.rooms = list(rooms.values())
world.multiworld.regions.extend(world.rooms)
first_rooms: Dict[int, KDL3Room] = dict()
for name, room in rooms.items():
if room.room == 0:
if room.stage == 7:
first_rooms[0x770200 + room.level - 1] = room
else:
first_rooms[0x770000 + ((room.level - 1) * 6) + room.stage - 1] = room
exits: Dict[str, Callable[[CollectionState], bool]] = dict()
for def_exit in room.default_exits:
target = f"{level_names[room.level]} {room.stage} - {def_exit['room']}"
access_rule = tuple(def_exit["access_rule"])
exits[target] = lambda state, rule=access_rule: state.has_all(rule, world.player)
room.add_exits(
exits.keys(),
exits
)
if world.options.open_world:
if any("Complete" in location.name for location in room.locations):
room.add_locations({f"{level_names[room.level]} {room.stage} - Stage Completion": None},
KDL3Location)
for level in world.player_levels:
for stage in range(6):
proper_stage = world.player_levels[level][stage]
stage_name = world.multiworld.get_location(world.location_id_to_name[proper_stage],
world.player).name.replace(" - Complete", "")
stage_regions = [rooms[room] for room in rooms if stage_name in rooms[room].name]
for region in stage_regions:
region.level = level
region.stage = stage
if world.options.open_world or stage == 0:
level_regions[level].add_exits([first_rooms[proper_stage].name])
else:
world.multiworld.get_location(world.location_id_to_name[world.player_levels[level][stage - 1]],
world.player).parent_region.add_exits([first_rooms[proper_stage].name])
if world.options.open_world:
level_regions[level].add_exits([first_rooms[0x770200 + level - 1].name])
else:
world.multiworld.get_location(world.location_id_to_name[world.player_levels[level][5]], world.player) \
.parent_region.add_exits([first_rooms[0x770200 + level - 1].name])
def generate_valid_levels(world: "KDL3World", shuffle_mode: int) -> Dict[int, List[int]]:
if shuffle_mode:
levels: Dict[int, List[Optional[int]]] = {
1: [None] * 7,
2: [None] * 7,
3: [None] * 7,
4: [None] * 7,
5: [None] * 7,
}
possible_stages = [default_levels[level][stage] for level in default_levels for stage in range(6)]
if world.options.plando_connections:
for connection in world.options.plando_connections:
try:
entrance_world, entrance_stage = connection.entrance.rsplit(" ", 1)
stage_world, stage_stage = connection.exit.rsplit(" ", 1)
new_stage = default_levels[location_name.level_names[stage_world.strip()]][int(stage_stage) - 1]
levels[location_name.level_names[entrance_world.strip()]][int(entrance_stage) - 1] = new_stage
possible_stages.remove(new_stage)
except Exception:
raise Exception(
f"Invalid connection: {connection.entrance} =>"
f" {connection.exit} for player {world.player} ({world.player_name})")
for level in range(1, 6):
for stage in range(6):
# Randomize bosses separately
if levels[level][stage] is None:
stage_candidates = [candidate for candidate in possible_stages
if (shuffle_mode == 1 and candidate in default_levels[level])
or (shuffle_mode == 2 and (candidate & 0x00FFFF) % 6 == stage)
or (shuffle_mode == 3)
]
if not stage_candidates:
raise Exception(
f"Failed to find valid stage for {level}-{stage}. Remaining Stages:{possible_stages}")
new_stage = generate_valid_level(world, level, stage, stage_candidates, levels[level])
possible_stages.remove(new_stage)
levels[level][stage] = new_stage
else:
levels = deepcopy(default_levels)
for level in levels:
levels[level][6] = None
# now handle bosses
boss_shuffle: Union[int, str] = world.options.boss_shuffle.value
plando_bosses = []
if isinstance(boss_shuffle, str):
# boss plando
options = boss_shuffle.split(";")
boss_shuffle = BossShuffle.options[options.pop()]
for option in options:
if "-" in option:
loc, plando_boss = option.split("-")
loc = loc.title()
plando_boss = plando_boss.title()
levels[location_name.level_names[loc]][6] = location_name.boss_names[plando_boss]
plando_bosses.append(location_name.boss_names[plando_boss])
else:
option = option.title()
for level in levels:
if levels[level][6] is None:
levels[level][6] = location_name.boss_names[option]
plando_bosses.append(location_name.boss_names[option])
if boss_shuffle > 0:
if boss_shuffle == BossShuffle.option_full:
possible_bosses = [default_levels[world.random.randint(1, 5)][6]
for _ in range(5 - len(plando_bosses))]
elif boss_shuffle == BossShuffle.option_singularity:
boss = world.random.randint(1, 5)
possible_bosses = [default_levels[boss][6] for _ in range(5 - len(plando_bosses))]
else:
possible_bosses = [default_levels[level][6] for level in default_levels
if default_levels[level][6] not in plando_bosses]
for level in levels:
if levels[level][6] is None:
boss = world.random.choice(possible_bosses)
levels[level][6] = boss
possible_bosses.remove(boss)
else:
for level in levels:
if levels[level][6] is None:
levels[level][6] = default_levels[level][6]
for level in levels:
for stage in range(7):
assert levels[level][stage] is not None, "Level tried to be sent with a None stage, incorrect plando?"
return levels
def create_levels(world: "KDL3World") -> None:
menu = Region("Menu", world.player, world.multiworld)
level1 = Region("Grass Land", world.player, world.multiworld)
level2 = Region("Ripple Field", world.player, world.multiworld)
level3 = Region("Sand Canyon", world.player, world.multiworld)
level4 = Region("Cloudy Park", world.player, world.multiworld)
level5 = Region("Iceberg", world.player, world.multiworld)
level6 = Region("Hyper Zone", world.player, world.multiworld)
levels = {
1: level1,
2: level2,
3: level3,
4: level4,
5: level5,
}
level_shuffle = world.options.stage_shuffle.value
if hasattr(world.multiworld, "re_gen_passthrough"):
world.player_levels = getattr(world.multiworld, "re_gen_passthrough")["Kirby's Dream Land 3"]["player_levels"]
else:
world.player_levels = generate_valid_levels(world, level_shuffle)
generate_rooms(world, levels)
level6.add_locations({location_name.goals[world.options.goal.value]: None}, KDL3Location)
menu.connect(level1, "Start Game")
level1.connect(level2, "To Level 2")
level2.connect(level3, "To Level 3")
level3.connect(level4, "To Level 4")
level4.connect(level5, "To Level 5")
menu.connect(level6, "To Level 6") # put the connection on menu, since you can reach it before level 5 on fast goal
world.multiworld.regions += [menu, level1, level2, level3, level4, level5, level6]