277 lines
14 KiB
Python
277 lines
14 KiB
Python
import string
|
||
|
||
from .Items import RiskOfRainItem, item_table, item_pool_weights, environment_offest
|
||
from .Locations import RiskOfRainLocation, get_classic_item_pickups, item_pickups, orderedstage_location
|
||
from .Rules import set_rules
|
||
from .RoR2Environments import *
|
||
|
||
from BaseClasses import Region, Entrance, Item, ItemClassification, MultiWorld, Tutorial
|
||
from .Options import ror2_options, ItemWeights
|
||
from worlds.AutoWorld import World, WebWorld
|
||
from .Regions import create_regions
|
||
|
||
|
||
class RiskOfWeb(WebWorld):
|
||
tutorials = [Tutorial(
|
||
"Multiworld Setup Guide",
|
||
"A guide to setting up the Risk of Rain 2 integration for Archipelago multiworld games.",
|
||
"English",
|
||
"setup_en.md",
|
||
"setup/en",
|
||
["Ijwu"]
|
||
)]
|
||
|
||
|
||
class RiskOfRainWorld(World):
|
||
"""
|
||
Escape a chaotic alien planet by fighting through hordes of frenzied monsters – with your friends, or on your own.
|
||
Combine loot in surprising ways and master each character until you become the havoc you feared upon your
|
||
first crash landing.
|
||
"""
|
||
game: str = "Risk of Rain 2"
|
||
option_definitions = ror2_options
|
||
topology_present = False
|
||
|
||
item_name_to_id = item_table
|
||
location_name_to_id = item_pickups
|
||
|
||
data_version = 7
|
||
required_client_version = (0, 4, 2)
|
||
web = RiskOfWeb()
|
||
total_revivals: int
|
||
|
||
def __init__(self, multiworld: "MultiWorld", player: int):
|
||
super().__init__(multiworld, player)
|
||
self.junk_pool: Dict[str, int] = {}
|
||
|
||
def generate_early(self) -> None:
|
||
# figure out how many revivals should exist in the pool
|
||
if self.multiworld.goal[self.player] == "classic":
|
||
total_locations = self.multiworld.total_locations[self.player].value
|
||
else:
|
||
total_locations = len(
|
||
orderedstage_location.get_locations(
|
||
chests=self.multiworld.chests_per_stage[self.player].value,
|
||
shrines=self.multiworld.shrines_per_stage[self.player].value,
|
||
scavengers=self.multiworld.scavengers_per_stage[self.player].value,
|
||
scanners=self.multiworld.scanner_per_stage[self.player].value,
|
||
altars=self.multiworld.altars_per_stage[self.player].value,
|
||
dlc_sotv=self.multiworld.dlc_sotv[self.player].value
|
||
)
|
||
)
|
||
self.total_revivals = int(self.multiworld.total_revivals[self.player].value / 100 *
|
||
total_locations)
|
||
# self.total_revivals = self.multiworld.total_revivals[self.player].value
|
||
if self.multiworld.start_with_revive[self.player].value:
|
||
self.total_revivals -= 1
|
||
|
||
def create_items(self) -> None:
|
||
# shortcut for starting_inventory... The start_with_revive option lets you start with a Dio's Best Friend
|
||
if self.multiworld.start_with_revive[self.player]:
|
||
self.multiworld.push_precollected(self.multiworld.create_item("Dio's Best Friend", self.player))
|
||
|
||
environments_pool = {}
|
||
# only mess with the environments if they are set as items
|
||
if self.multiworld.goal[self.player] == "explore":
|
||
|
||
# figure out all available ordered stages for each tier
|
||
environment_available_orderedstages_table = environment_vanilla_orderedstages_table
|
||
if self.multiworld.dlc_sotv[self.player]:
|
||
environment_available_orderedstages_table = collapse_dict_list_vertical(environment_available_orderedstages_table, environment_sotv_orderedstages_table)
|
||
|
||
environments_pool = shift_by_offset(environment_vanilla_table, environment_offest)
|
||
|
||
if self.multiworld.dlc_sotv[self.player]:
|
||
environment_offset_table = shift_by_offset(environment_sotv_table, environment_offest)
|
||
environments_pool = {**environments_pool, **environment_offset_table}
|
||
environments_to_precollect = 5 if self.multiworld.begin_with_loop[self.player].value else 1
|
||
# percollect environments for each stage (or just stage 1)
|
||
for i in range(environments_to_precollect):
|
||
unlock = self.multiworld.random.choices(list(environment_available_orderedstages_table[i].keys()), k=1)
|
||
self.multiworld.push_precollected(self.create_item(unlock[0]))
|
||
environments_pool.pop(unlock[0])
|
||
|
||
# Generate item pool
|
||
itempool: List = []
|
||
# Add revive items for the player
|
||
itempool += ["Dio's Best Friend"] * self.total_revivals
|
||
itempool += ["Beads of Fealty"]
|
||
|
||
for env_name, _ in environments_pool.items():
|
||
itempool += [env_name]
|
||
|
||
if self.multiworld.goal[self.player] == "classic":
|
||
# classic mode
|
||
total_locations = self.multiworld.total_locations[self.player].value
|
||
else:
|
||
# explore mode
|
||
total_locations = len(
|
||
orderedstage_location.get_locations(
|
||
chests=self.multiworld.chests_per_stage[self.player].value,
|
||
shrines=self.multiworld.shrines_per_stage[self.player].value,
|
||
scavengers=self.multiworld.scavengers_per_stage[self.player].value,
|
||
scanners=self.multiworld.scanner_per_stage[self.player].value,
|
||
altars=self.multiworld.altars_per_stage[self.player].value,
|
||
dlc_sotv=self.multiworld.dlc_sotv[self.player].value
|
||
)
|
||
)
|
||
# Create junk items
|
||
self.junk_pool = self.create_junk_pool()
|
||
# Fill remaining items with randomly generated junk
|
||
while len(itempool) < total_locations:
|
||
itempool.append(self.get_filler_item_name())
|
||
|
||
# Convert itempool into real items
|
||
itempool = list(map(lambda name: self.create_item(name), itempool))
|
||
self.multiworld.itempool += itempool
|
||
|
||
def set_rules(self) -> None:
|
||
set_rules(self.multiworld, self.player)
|
||
|
||
def get_filler_item_name(self) -> str:
|
||
if not self.junk_pool:
|
||
self.junk_pool = self.create_junk_pool()
|
||
weights = [data for data in self.junk_pool.values()]
|
||
filler = self.multiworld.random.choices([filler for filler in self.junk_pool.keys()], weights,
|
||
k=1)[0]
|
||
return filler
|
||
|
||
def create_junk_pool(self) -> Dict:
|
||
# if presets are enabled generate junk_pool from the selected preset
|
||
pool_option = self.multiworld.item_weights[self.player].value
|
||
junk_pool: Dict[str, int] = {}
|
||
if self.multiworld.item_pool_presets[self.player]:
|
||
# generate chaos weights if the preset is chosen
|
||
if pool_option == ItemWeights.option_chaos:
|
||
for name, max_value in item_pool_weights[pool_option].items():
|
||
junk_pool[name] = self.multiworld.random.randint(0, max_value)
|
||
else:
|
||
junk_pool = item_pool_weights[pool_option].copy()
|
||
else: # generate junk pool from user created presets
|
||
junk_pool = {
|
||
"Item Scrap, Green": self.multiworld.green_scrap[self.player].value,
|
||
"Item Scrap, Red": self.multiworld.red_scrap[self.player].value,
|
||
"Item Scrap, Yellow": self.multiworld.yellow_scrap[self.player].value,
|
||
"Item Scrap, White": self.multiworld.white_scrap[self.player].value,
|
||
"Common Item": self.multiworld.common_item[self.player].value,
|
||
"Uncommon Item": self.multiworld.uncommon_item[self.player].value,
|
||
"Legendary Item": self.multiworld.legendary_item[self.player].value,
|
||
"Boss Item": self.multiworld.boss_item[self.player].value,
|
||
"Lunar Item": self.multiworld.lunar_item[self.player].value,
|
||
"Void Item": self.multiworld.void_item[self.player].value,
|
||
"Equipment": self.multiworld.equipment[self.player].value
|
||
}
|
||
|
||
# remove lunar items from the pool if they're disabled in the yaml unless lunartic is rolled
|
||
if not (self.multiworld.enable_lunar[self.player] or pool_option == ItemWeights.option_lunartic):
|
||
junk_pool.pop("Lunar Item")
|
||
# remove void items from the pool
|
||
if not (self.multiworld.dlc_sotv[self.player] or pool_option == ItemWeights.option_void):
|
||
junk_pool.pop("Void Item")
|
||
|
||
return junk_pool
|
||
|
||
def create_regions(self) -> None:
|
||
|
||
if self.multiworld.goal[self.player] == "classic":
|
||
# classic mode
|
||
menu = create_region(self.multiworld, self.player, "Menu")
|
||
self.multiworld.regions.append(menu)
|
||
# By using a victory region, we can define it as being connected to by several regions
|
||
# which can then determine the availability of the victory.
|
||
victory_region = create_region(self.multiworld, self.player, "Victory")
|
||
self.multiworld.regions.append(victory_region)
|
||
petrichor = create_region(self.multiworld, self.player, "Petrichor V",
|
||
get_classic_item_pickups(self.multiworld.total_locations[self.player].value))
|
||
self.multiworld.regions.append(petrichor)
|
||
|
||
# classic mode can get to victory from the beginning of the game
|
||
to_victory = Entrance(self.player, "beating game", petrichor)
|
||
petrichor.exits.append(to_victory)
|
||
to_victory.connect(victory_region)
|
||
|
||
connection = Entrance(self.player, "Lobby", menu)
|
||
menu.exits.append(connection)
|
||
connection.connect(petrichor)
|
||
else:
|
||
# explore mode
|
||
create_regions(self.multiworld, self.player)
|
||
|
||
create_events(self.multiworld, self.player)
|
||
|
||
def fill_slot_data(self):
|
||
return {
|
||
"itemPickupStep": self.multiworld.item_pickup_step[self.player].value,
|
||
"shrineUseStep": self.multiworld.shrine_use_step[self.player].value,
|
||
"goal": self.multiworld.goal[self.player].value,
|
||
"seed": "".join(self.multiworld.per_slot_randoms[self.player].choice(string.digits) for _ in range(16)),
|
||
"totalLocations": self.multiworld.total_locations[self.player].value,
|
||
"chestsPerStage": self.multiworld.chests_per_stage[self.player].value,
|
||
"shrinesPerStage": self.multiworld.shrines_per_stage[self.player].value,
|
||
"scavengersPerStage": self.multiworld.scavengers_per_stage[self.player].value,
|
||
"scannerPerStage": self.multiworld.scanner_per_stage[self.player].value,
|
||
"altarsPerStage": self.multiworld.altars_per_stage[self.player].value,
|
||
"totalRevivals": self.multiworld.total_revivals[self.player].value,
|
||
"startWithDio": self.multiworld.start_with_revive[self.player].value,
|
||
"finalStageDeath": self.multiworld.final_stage_death[self.player].value,
|
||
"deathLink": self.multiworld.death_link[self.player].value,
|
||
}
|
||
|
||
def create_item(self, name: str) -> Item:
|
||
item_id = item_table[name]
|
||
classification = ItemClassification.filler
|
||
if name in {"Dio's Best Friend", "Beads of Fealty"}:
|
||
classification = ItemClassification.progression
|
||
elif name in {"Legendary Item", "Boss Item"}:
|
||
classification = ItemClassification.useful
|
||
elif name == "Lunar Item":
|
||
classification = ItemClassification.trap
|
||
|
||
# Only check for an item to be a environment unlock if those are known to be in the pool.
|
||
# This should shave down comparisons.
|
||
|
||
elif name in environment_ALL_table.keys():
|
||
if name in {"Hidden Realm: Bulwark's Ambry", "Hidden Realm: Gilded Coast,"}:
|
||
classification = ItemClassification.useful
|
||
else:
|
||
classification = ItemClassification.progression
|
||
|
||
item = RiskOfRainItem(name, classification, item_id, self.player)
|
||
return item
|
||
|
||
|
||
def create_events(world: MultiWorld, player: int) -> None:
|
||
total_locations = world.total_locations[player].value
|
||
num_of_events = total_locations // 25
|
||
if total_locations / 25 == num_of_events:
|
||
num_of_events -= 1
|
||
world_region = world.get_region("Petrichor V", player)
|
||
if world.goal[player] == "classic":
|
||
# only setup Pickups when using classic_mode
|
||
for i in range(num_of_events):
|
||
event_loc = RiskOfRainLocation(player, f"Pickup{(i + 1) * 25}", None, world_region)
|
||
event_loc.place_locked_item(RiskOfRainItem(f"Pickup{(i + 1) * 25}", ItemClassification.progression, None, player))
|
||
event_loc.access_rule = \
|
||
lambda state, i=i: state.can_reach(f"ItemPickup{((i + 1) * 25) - 1}", "Location", player)
|
||
world_region.locations.append(event_loc)
|
||
elif world.goal[player] == "explore":
|
||
for n in range(1, 6):
|
||
|
||
event_region = world.get_region(f"OrderedStage_{n}", player)
|
||
event_loc = RiskOfRainLocation(player, f"Stage_{n}", None, event_region)
|
||
event_loc.place_locked_item(RiskOfRainItem(f"Stage_{n}", ItemClassification.progression, None, player))
|
||
event_loc.show_in_spoiler = False
|
||
event_region.locations.append(event_loc)
|
||
|
||
victory_region = world.get_region("Victory", player)
|
||
victory_event = RiskOfRainLocation(player, "Victory", None, victory_region)
|
||
victory_event.place_locked_item(RiskOfRainItem("Victory", ItemClassification.progression, None, player))
|
||
world_region.locations.append(victory_event)
|
||
|
||
|
||
def create_region(world: MultiWorld, player: int, name: str, locations: Dict[str, int] = {}) -> Region:
|
||
ret = Region(name, player, world)
|
||
for location_name, location_id in locations.items():
|
||
ret.locations.append(RiskOfRainLocation(player, location_name, location_id, ret))
|
||
return ret
|