forked from mirror/Archipelago
fadcfbdfea
### Logic Fixes: - Old Site A - Logic now allows for going backwards from the `Awake` checkpoint - Golden Ridge A - `Golden Strawberry` now requires `Moving Platforms` as it should - Mirror Temple A - `Room b-01c Strawberry` and `Room b-10 Strawberry` no longer erroneously require `Red Boosters` - `Golden Strawberry` now requires `Dash Refills` as it should - Reflection A - Logic now allows for going backwards from the `Reflection` checkpoint - Reflection B - Logic now allows for going backwards from the `Reflection` checkpoint - Farewell - `Power Source Key 2` now logically requires `Dash Switches` and `Double Dash Refills` as it should
362 lines
17 KiB
Python
362 lines
17 KiB
Python
from copy import deepcopy
|
|
import math
|
|
from typing import TextIO
|
|
|
|
from BaseClasses import ItemClassification, Location, MultiWorld, Region, Tutorial
|
|
from Utils import visualize_regions
|
|
from worlds.AutoWorld import WebWorld, World
|
|
|
|
from .Items import CelesteItem, generate_item_table, generate_item_data_table, generate_item_groups, level_item_lists, level_cassette_items,\
|
|
cassette_item_data_table, crystal_heart_item_data_table, trap_item_data_table
|
|
from .Locations import CelesteLocation, location_data_table, generate_location_groups, checkpoint_location_data_table, location_id_offsets
|
|
from .Names import ItemName
|
|
from .Options import CelesteOptions, celeste_option_groups, resolve_options
|
|
from .Levels import Level, LocationType, load_logic_data, goal_area_option_to_name, goal_area_option_to_display_name, goal_area_to_location_name
|
|
|
|
|
|
class CelesteOpenWebWorld(WebWorld):
|
|
theme = "ice"
|
|
|
|
setup_en = Tutorial(
|
|
tutorial_name="Start Guide",
|
|
description="A guide to playing Celeste (Open World) in Archipelago.",
|
|
language="English",
|
|
file_name="guide_en.md",
|
|
link="guide/en",
|
|
authors=["PoryGone"]
|
|
)
|
|
|
|
tutorials = [setup_en]
|
|
|
|
option_groups = celeste_option_groups
|
|
|
|
|
|
class CelesteOpenWorld(World):
|
|
"""
|
|
Celeste (Open World) is a randomizer for the original Celeste. In this acclaimed platformer created by ExOK Games, you control Madeline as she attempts to climb the titular mountain, meeting friends and obstacles along the way. Progression is found in unlocking the ability to interact with various objects in the areas, such as springs, traffic blocks, feathers, and many more. Please be safe on the climb.
|
|
"""
|
|
|
|
# Class Data
|
|
game = "Celeste (Open World)"
|
|
web = CelesteOpenWebWorld()
|
|
options_dataclass = CelesteOptions
|
|
options: CelesteOptions
|
|
|
|
apworld_version = 10007
|
|
|
|
level_data: dict[str, Level] = load_logic_data()
|
|
|
|
location_name_to_id: dict[str, int] = location_data_table
|
|
location_name_groups: dict[str, list[str]] = generate_location_groups()
|
|
item_name_to_id: dict[str, int] = generate_item_table()
|
|
item_name_groups: dict[str, list[str]] = generate_item_groups()
|
|
|
|
|
|
# Instance Data
|
|
madeline_one_dash_hair_color: int
|
|
madeline_two_dash_hair_color: int
|
|
madeline_no_dash_hair_color: int
|
|
madeline_feather_hair_color: int
|
|
|
|
active_levels: set[str]
|
|
active_items: set[str]
|
|
|
|
|
|
def generate_early(self) -> None:
|
|
if not self.player_name.isascii():
|
|
raise RuntimeError(f"Invalid player_name {self.player_name} for game {self.game}. Name must be ascii.")
|
|
|
|
resolve_options(self)
|
|
|
|
self.goal_area: str = goal_area_option_to_name[self.options.goal_area.value]
|
|
|
|
self.active_levels = {"0a", "1a", "2a", "3a", "4a", "5a", "6a", "7a", "8a"}
|
|
if self.options.include_core:
|
|
self.active_levels.add("9a")
|
|
if self.options.include_farewell >= 1:
|
|
self.active_levels.add("10a")
|
|
if self.options.include_farewell == 2:
|
|
self.active_levels.add("10b")
|
|
if self.options.include_b_sides:
|
|
self.active_levels.update({"1b", "2b", "3b", "4b", "5b", "6b", "7b"})
|
|
if self.options.include_core:
|
|
self.active_levels.add("9b")
|
|
if self.options.include_c_sides:
|
|
self.active_levels.update({"1c", "2c", "3c", "4c", "5c", "6c", "7c"})
|
|
if self.options.include_core:
|
|
self.active_levels.add("9c")
|
|
|
|
self.active_levels.add(self.goal_area)
|
|
if self.goal_area == "10c":
|
|
self.active_levels.add("10a")
|
|
self.active_levels.add("10b")
|
|
elif self.goal_area == "10b":
|
|
self.active_levels.add("10a")
|
|
|
|
self.active_items = set()
|
|
for level in self.active_levels:
|
|
self.active_items.update(level_item_lists[level])
|
|
|
|
|
|
def create_regions(self) -> None:
|
|
from .Locations import create_regions_and_locations
|
|
|
|
create_regions_and_locations(self)
|
|
|
|
|
|
def create_item(self, name: str, force_useful: bool = False) -> CelesteItem:
|
|
item_data_table = generate_item_data_table()
|
|
|
|
if name == ItemName.strawberry and force_useful:
|
|
return CelesteItem(name, ItemClassification.useful, item_data_table[name].code, self.player)
|
|
elif name in item_data_table:
|
|
return CelesteItem(name, item_data_table[name].type, item_data_table[name].code, self.player)
|
|
else:
|
|
return CelesteItem(name, ItemClassification.progression, None, self.player)
|
|
|
|
def create_items(self) -> None:
|
|
item_pool: list[CelesteItem] = []
|
|
|
|
location_count: int = len(self.get_locations())
|
|
goal_area_location_count: int = sum(goal_area_option_to_display_name[self.options.goal_area] in loc.name for loc in self.get_locations())
|
|
|
|
# Goal Items
|
|
goal_item_loc: Location = self.get_location(goal_area_to_location_name[self.goal_area])
|
|
goal_item_loc.place_locked_item(self.create_item(ItemName.house_keys))
|
|
location_count -= 1
|
|
|
|
epilogue_region: Region = self.get_region(self.epilogue_start_region)
|
|
epilogue_region.add_locations({ItemName.victory: None }, CelesteLocation)
|
|
victory_loc: Location = self.get_location(ItemName.victory)
|
|
victory_loc.place_locked_item(self.create_item(ItemName.victory))
|
|
|
|
# Checkpoints
|
|
for item_name in self.active_checkpoint_names:
|
|
if self.options.checkpointsanity:
|
|
if not self.options.goal_area_checkpointsanity and goal_area_option_to_display_name[self.options.goal_area] in item_name:
|
|
checkpoint_loc: Location = self.get_location(item_name)
|
|
checkpoint_loc.place_locked_item(self.create_item(item_name))
|
|
location_count -= 1
|
|
else:
|
|
item_pool.append(self.create_item(item_name))
|
|
else:
|
|
checkpoint_loc: Location = self.get_location(item_name)
|
|
checkpoint_loc.place_locked_item(self.create_item(item_name))
|
|
location_count -= 1
|
|
|
|
# Keys
|
|
if self.options.keysanity:
|
|
item_pool += [self.create_item(item_name) for item_name in self.active_key_names]
|
|
else:
|
|
for item_name in self.active_key_names:
|
|
key_loc: Location = self.get_location(item_name)
|
|
key_loc.place_locked_item(self.create_item(item_name))
|
|
location_count -= 1
|
|
|
|
# Summit Gems
|
|
if self.options.gemsanity:
|
|
item_pool += [self.create_item(item_name) for item_name in self.active_gem_names]
|
|
else:
|
|
for item_name in self.active_gem_names:
|
|
gem_loc: Location = self.get_location(item_name)
|
|
gem_loc.place_locked_item(self.create_item(item_name))
|
|
location_count -= 1
|
|
|
|
# Clutter Events
|
|
for item_name in self.active_clutter_names:
|
|
clutter_loc: Location = self.get_location(item_name)
|
|
clutter_loc.place_locked_item(self.create_item(item_name))
|
|
location_count -= 1
|
|
|
|
# Interactables
|
|
item_pool += [self.create_item(item_name) for item_name in sorted(self.active_items)]
|
|
|
|
# Strawberries
|
|
real_total_strawberries: int = min(self.options.total_strawberries.value, location_count - goal_area_location_count - len(item_pool))
|
|
self.strawberries_required = int(real_total_strawberries * (self.options.strawberries_required_percentage / 100))
|
|
|
|
menu_region = self.get_region("Menu")
|
|
if getattr(self, "goal_start_region", None):
|
|
menu_region.add_exits([self.goal_start_region], {self.goal_start_region: lambda state: state.has(ItemName.strawberry, self.player, self.strawberries_required)})
|
|
if getattr(self, "goal_checkpoint_names", None):
|
|
for region_name, location_name in self.goal_checkpoint_names.items():
|
|
checkpoint_rule = lambda state, location_name=location_name: state.has(location_name, self.player) and state.has(ItemName.strawberry, self.player, self.strawberries_required)
|
|
menu_region.add_exits([region_name], {region_name: checkpoint_rule})
|
|
|
|
menu_region.add_exits([self.epilogue_start_region], {self.epilogue_start_region: lambda state: (state.has(ItemName.strawberry, self.player, self.strawberries_required) and state.has(ItemName.house_keys, self.player))})
|
|
|
|
item_pool += [self.create_item(ItemName.strawberry) for _ in range(self.strawberries_required)]
|
|
|
|
# Filler and Traps
|
|
non_required_strawberries = (real_total_strawberries - self.strawberries_required)
|
|
replacement_filler_count = math.floor(non_required_strawberries * (self.options.junk_fill_percentage.value / 100.0))
|
|
remaining_extra_strawberries = non_required_strawberries - replacement_filler_count
|
|
item_pool += [self.create_item(ItemName.strawberry, True) for _ in range(remaining_extra_strawberries)]
|
|
|
|
trap_weights = []
|
|
trap_weights += ([ItemName.bald_trap] * self.options.bald_trap_weight.value)
|
|
trap_weights += ([ItemName.literature_trap] * self.options.literature_trap_weight.value)
|
|
trap_weights += ([ItemName.stun_trap] * self.options.stun_trap_weight.value)
|
|
trap_weights += ([ItemName.invisible_trap] * self.options.invisible_trap_weight.value)
|
|
trap_weights += ([ItemName.fast_trap] * self.options.fast_trap_weight.value)
|
|
trap_weights += ([ItemName.slow_trap] * self.options.slow_trap_weight.value)
|
|
trap_weights += ([ItemName.ice_trap] * self.options.ice_trap_weight.value)
|
|
trap_weights += ([ItemName.reverse_trap] * self.options.reverse_trap_weight.value)
|
|
trap_weights += ([ItemName.screen_flip_trap] * self.options.screen_flip_trap_weight.value)
|
|
trap_weights += ([ItemName.laughter_trap] * self.options.laughter_trap_weight.value)
|
|
trap_weights += ([ItemName.hiccup_trap] * self.options.hiccup_trap_weight.value)
|
|
trap_weights += ([ItemName.zoom_trap] * self.options.zoom_trap_weight.value)
|
|
|
|
total_filler_count: int = (location_count - len(item_pool))
|
|
|
|
# Cassettes
|
|
if self.options.require_cassettes:
|
|
shuffled_active_levels = sorted(self.active_levels)
|
|
self.random.shuffle(shuffled_active_levels)
|
|
for level_name in shuffled_active_levels:
|
|
if level_name == "10b" or level_name == "10c":
|
|
continue
|
|
if level_name not in self.multiworld.precollected_items[self.player]:
|
|
if total_filler_count > 0:
|
|
item_pool.append(self.create_item(level_cassette_items[level_name]))
|
|
total_filler_count -= 1
|
|
else:
|
|
self.multiworld.push_precollected(self.create_item(level_cassette_items[level_name]))
|
|
|
|
# Crystal Hearts
|
|
for name in crystal_heart_item_data_table.keys():
|
|
if total_filler_count > 0:
|
|
if name not in self.multiworld.precollected_items[self.player]:
|
|
item_pool.append(self.create_item(name))
|
|
total_filler_count -= 1
|
|
|
|
trap_count = 0 if (len(trap_weights) == 0) else math.ceil(total_filler_count * (self.options.trap_fill_percentage.value / 100.0))
|
|
total_filler_count -= trap_count
|
|
|
|
item_pool += [self.create_item(ItemName.raspberry) for _ in range(total_filler_count)]
|
|
|
|
trap_pool = []
|
|
for i in range(trap_count):
|
|
trap_item = self.random.choice(trap_weights)
|
|
trap_pool.append(self.create_item(trap_item))
|
|
|
|
item_pool += trap_pool
|
|
|
|
self.multiworld.itempool += item_pool
|
|
|
|
def get_filler_item_name(self) -> str:
|
|
return ItemName.raspberry
|
|
|
|
|
|
def set_rules(self) -> None:
|
|
self.multiworld.completion_condition[self.player] = lambda state: state.has(ItemName.victory, self.player)
|
|
|
|
|
|
def fill_slot_data(self):
|
|
return {
|
|
"apworld_version": self.apworld_version,
|
|
"min_mod_version": 10000,
|
|
|
|
"death_link": self.options.death_link.value,
|
|
"death_link_amnesty": self.options.death_link_amnesty.value,
|
|
"trap_link": self.options.trap_link.value,
|
|
|
|
"active_levels": self.active_levels,
|
|
"goal_area": self.goal_area,
|
|
"lock_goal_area": self.options.lock_goal_area.value,
|
|
"strawberries_required": self.strawberries_required,
|
|
|
|
"checkpointsanity": self.options.checkpointsanity.value,
|
|
"binosanity": self.options.binosanity.value,
|
|
"keysanity": self.options.keysanity.value,
|
|
"gemsanity": self.options.gemsanity.value,
|
|
"carsanity": self.options.carsanity.value,
|
|
"roomsanity": self.options.roomsanity.value,
|
|
"include_goldens": self.options.include_goldens.value,
|
|
|
|
"include_core": self.options.include_core.value,
|
|
"include_farewell": self.options.include_farewell.value,
|
|
"include_b_sides": self.options.include_b_sides.value,
|
|
"include_c_sides": self.options.include_c_sides.value,
|
|
|
|
"trap_expiration_action": self.options.trap_expiration_action.value,
|
|
"trap_expiration_amount": self.options.trap_expiration_amount.value,
|
|
"active_traps": self.output_active_traps(),
|
|
|
|
"madeline_hair_length": self.options.madeline_hair_length.value,
|
|
"madeline_one_dash_hair_color": self.madeline_one_dash_hair_color,
|
|
"madeline_two_dash_hair_color": self.madeline_two_dash_hair_color,
|
|
"madeline_no_dash_hair_color": self.madeline_no_dash_hair_color,
|
|
"madeline_feather_hair_color": self.madeline_feather_hair_color,
|
|
|
|
"music_shuffle": self.options.music_shuffle.value,
|
|
"music_map": self.generate_music_data(),
|
|
"require_cassettes": self.options.require_cassettes.value,
|
|
"chosen_poem": self.random.randint(0, 119),
|
|
}
|
|
|
|
@classmethod
|
|
def stage_write_spoiler_header(cls, multiworld: MultiWorld, spoiler_handle: TextIO):
|
|
major: int = cls.apworld_version // 10000
|
|
minor: int = (cls.apworld_version % 10000) // 100
|
|
bugfix: int = (cls.apworld_version % 100)
|
|
spoiler_handle.write(f"\nCeleste (Open World) APWorld v{major}.{minor}.{bugfix}\n")
|
|
|
|
def output_active_traps(self) -> dict[int, int]:
|
|
trap_data = {}
|
|
|
|
trap_data[0x20] = self.options.bald_trap_weight.value
|
|
trap_data[0x21] = self.options.literature_trap_weight.value
|
|
trap_data[0x22] = self.options.stun_trap_weight.value
|
|
trap_data[0x23] = self.options.invisible_trap_weight.value
|
|
trap_data[0x24] = self.options.fast_trap_weight.value
|
|
trap_data[0x25] = self.options.slow_trap_weight.value
|
|
trap_data[0x26] = self.options.ice_trap_weight.value
|
|
trap_data[0x28] = self.options.reverse_trap_weight.value
|
|
trap_data[0x29] = self.options.screen_flip_trap_weight.value
|
|
trap_data[0x2A] = self.options.laughter_trap_weight.value
|
|
trap_data[0x2B] = self.options.hiccup_trap_weight.value
|
|
trap_data[0x2C] = self.options.zoom_trap_weight.value
|
|
|
|
return trap_data
|
|
|
|
def generate_music_data(self) -> dict[int, int]:
|
|
if self.options.music_shuffle == "consistent":
|
|
musiclist_o = list(range(0, 48))
|
|
musiclist_s = musiclist_o.copy()
|
|
self.random.shuffle(musiclist_s)
|
|
|
|
return dict(zip(musiclist_o, musiclist_s))
|
|
elif self.options.music_shuffle == "singularity":
|
|
musiclist_o = list(range(0, 48))
|
|
musiclist_s = [self.random.choice(musiclist_o)] * len(musiclist_o)
|
|
|
|
return dict(zip(musiclist_o, musiclist_s))
|
|
else:
|
|
musiclist_o = list(range(0, 48))
|
|
musiclist_s = musiclist_o.copy()
|
|
|
|
return dict(zip(musiclist_o, musiclist_s))
|
|
|
|
|
|
# Useful Debugging tools, kept around for later.
|
|
#@classmethod
|
|
#def stage_assert_generate(cls, _multiworld: MultiWorld) -> None:
|
|
# with open("./worlds/celeste_open_world/data/IDs.txt", "w") as f:
|
|
# print("Items:", file=f)
|
|
# for name in sorted(CelesteOpenWorld.item_name_to_id, key=CelesteOpenWorld.item_name_to_id.get):
|
|
# id = CelesteOpenWorld.item_name_to_id[name]
|
|
# print(f"{{ 0x{id:X}, \"{name}\" }},", file=f)
|
|
# print("\nLocations:", file=f)
|
|
# for name in sorted(CelesteOpenWorld.location_name_to_id, key=CelesteOpenWorld.location_name_to_id.get):
|
|
# id = CelesteOpenWorld.location_name_to_id[name]
|
|
# print(f"{{ 0x{id:X}, \"{name}\" }},", file=f)
|
|
# print("\nLocations 2:", file=f)
|
|
# for name in sorted(CelesteOpenWorld.location_name_to_id, key=CelesteOpenWorld.location_name_to_id.get):
|
|
# id = CelesteOpenWorld.location_name_to_id[name]
|
|
# print(f"{{ \"{name}\", 0x{id:X} }},", file=f)
|
|
#
|
|
#def generate_output(self, output_directory: str):
|
|
# visualize_regions(self.get_region("Menu"), f"Player{self.player}.puml", show_entrance_names=False,
|
|
# regions_to_highlight=self.multiworld.get_all_state(self.player).reachable_regions[self.player])
|