318 lines
14 KiB
Python
318 lines
14 KiB
Python
from worlds.AutoWorld import World, WebWorld
|
|
from worlds.generic.Rules import set_rule
|
|
from BaseClasses import Region, Item, ItemClassification, Entrance, Tutorial
|
|
from typing import List
|
|
from math import floor
|
|
|
|
from .Options import musedash_options
|
|
from .Items import MuseDashSongItem, MuseDashFixedItem
|
|
from .Locations import MuseDashLocation
|
|
from .MuseDashCollection import MuseDashCollections
|
|
|
|
|
|
class MuseDashWebWorld(WebWorld):
|
|
theme = "partyTime"
|
|
|
|
bug_report_page = "https://github.com/DeamonHunter/ArchipelagoMuseDash/issues"
|
|
setup_en = Tutorial(
|
|
"Mod Setup and Use Guide",
|
|
"A guide to setting up the Muse Dash Archipelago Mod on your computer.",
|
|
"English",
|
|
"setup_en.md",
|
|
"setup/en",
|
|
["DeamonHunter"]
|
|
)
|
|
|
|
tutorials = [setup_en]
|
|
|
|
|
|
class MuseDashWorld(World):
|
|
"""Muse Dash is a rhythm game where you hit objects to the beat of one of 400+ songs.
|
|
Play through a selection of randomly chosen songs, collecting music sheets
|
|
until you have enough to play and complete the goal song!"""
|
|
|
|
# FUTURE OPTIONS
|
|
# - Album Rando.
|
|
# - Added items for characters/elfin/portraits.
|
|
# - Support for blacklisting/plando-ing certain songs.
|
|
|
|
# World Options
|
|
game = "Muse Dash"
|
|
option_definitions = musedash_options
|
|
topology_present = False
|
|
data_version = 9
|
|
web = MuseDashWebWorld()
|
|
|
|
# Necessary Data
|
|
md_collection = MuseDashCollections()
|
|
|
|
item_name_to_id = {name: code for name, code in md_collection.item_names_to_id.items()}
|
|
location_name_to_id = {name: code for name, code in md_collection.location_names_to_id.items()}
|
|
|
|
# Working Data
|
|
victory_song_name: str = ""
|
|
starting_songs: List[str]
|
|
included_songs: List[str]
|
|
needed_token_count: int
|
|
location_count: int
|
|
|
|
def generate_early(self):
|
|
dlc_songs = self.multiworld.allow_just_as_planned_dlc_songs[self.player]
|
|
streamer_mode = self.multiworld.streamer_mode_enabled[self.player]
|
|
(lower_diff_threshold, higher_diff_threshold) = self.get_difficulty_range()
|
|
|
|
# The minimum amount of songs to make an ok rando would be Starting Songs + 10 interim songs + Goal song.
|
|
# - Interim songs being equal to max starting song count.
|
|
# Note: The worst settings still allow 25 songs (Streamer Mode + No DLC).
|
|
starter_song_count = self.multiworld.starting_song_count[self.player].value
|
|
|
|
while True:
|
|
# In most cases this should only need to run once
|
|
available_song_keys = self.md_collection.get_songs_with_settings(
|
|
dlc_songs, streamer_mode, lower_diff_threshold, higher_diff_threshold)
|
|
|
|
available_song_keys = self.handle_plando(available_song_keys)
|
|
|
|
count_needed_for_start = max(0, starter_song_count - len(self.starting_songs))
|
|
if len(available_song_keys) + len(self.included_songs) >= count_needed_for_start + 11:
|
|
final_song_list = available_song_keys
|
|
break
|
|
|
|
# If the above fails, we want to adjust the difficulty thresholds.
|
|
# Easier first, then harder
|
|
if lower_diff_threshold <= 1 and higher_diff_threshold >= 11:
|
|
raise Exception("Failed to find enough songs, even with maximum difficulty thresholds.")
|
|
elif lower_diff_threshold <= 1:
|
|
higher_diff_threshold += 1
|
|
else:
|
|
lower_diff_threshold -= 1
|
|
|
|
self.create_song_pool(final_song_list)
|
|
|
|
for song in self.starting_songs:
|
|
self.multiworld.push_precollected(self.create_item(song))
|
|
|
|
def handle_plando(self, available_song_keys: List[str]) -> List[str]:
|
|
song_items = self.md_collection.song_items
|
|
|
|
start_items = self.multiworld.start_inventory[self.player].value.keys()
|
|
include_songs = self.multiworld.include_songs[self.player].value
|
|
exclude_songs = self.multiworld.exclude_songs[self.player].value
|
|
|
|
self.starting_songs = [s for s in start_items if s in song_items]
|
|
self.included_songs = [s for s in include_songs if s in song_items and s not in self.starting_songs]
|
|
|
|
return [s for s in available_song_keys if s not in start_items
|
|
and s not in include_songs and s not in exclude_songs]
|
|
|
|
def create_song_pool(self, available_song_keys: List[str]):
|
|
starting_song_count = self.multiworld.starting_song_count[self.player].value
|
|
additional_song_count = self.multiworld.additional_song_count[self.player].value
|
|
|
|
self.random.shuffle(available_song_keys)
|
|
|
|
# First, we must double check if the player has included too many guaranteed songs
|
|
included_song_count = len(self.included_songs)
|
|
if included_song_count > additional_song_count:
|
|
# If so, we want to thin the list, thus let's get the goal song and starter songs while we are at it.
|
|
self.random.shuffle(self.included_songs)
|
|
self.victory_song_name = self.included_songs.pop()
|
|
while len(self.included_songs) > additional_song_count:
|
|
next_song = self.included_songs.pop()
|
|
if len(self.starting_songs) < starting_song_count:
|
|
self.starting_songs.append(next_song)
|
|
else:
|
|
# If not, choose a random victory song from the available songs
|
|
chosen_song = self.random.randrange(0, len(available_song_keys) + included_song_count)
|
|
if chosen_song < included_song_count:
|
|
self.victory_song_name = self.included_songs[chosen_song]
|
|
del self.included_songs[chosen_song]
|
|
else:
|
|
self.victory_song_name = available_song_keys[chosen_song - included_song_count]
|
|
del available_song_keys[chosen_song - included_song_count]
|
|
|
|
# Next, make sure the starting songs are fufilled
|
|
if len(self.starting_songs) < starting_song_count:
|
|
for _ in range(len(self.starting_songs), starting_song_count):
|
|
if len(available_song_keys) > 0:
|
|
self.starting_songs.append(available_song_keys.pop())
|
|
else:
|
|
self.starting_songs.append(self.included_songs.pop())
|
|
|
|
# Then attempt to fufill any remaining songs for interim songs
|
|
if len(self.included_songs) < additional_song_count:
|
|
for _ in range(len(self.included_songs), self.multiworld.additional_song_count[self.player]):
|
|
if len(available_song_keys) <= 0:
|
|
break
|
|
self.included_songs.append(available_song_keys.pop())
|
|
|
|
self.location_count = len(self.starting_songs) + len(self.included_songs)
|
|
location_multiplier = 1 + (self.get_additional_item_percentage() / 100.0)
|
|
self.location_count = floor(self.location_count * location_multiplier)
|
|
|
|
minimum_location_count = len(self.included_songs) + self.get_music_sheet_count()
|
|
if self.location_count < minimum_location_count:
|
|
self.location_count = minimum_location_count
|
|
|
|
def create_item(self, name: str) -> Item:
|
|
if name == self.md_collection.MUSIC_SHEET_NAME:
|
|
return MuseDashFixedItem(name, ItemClassification.progression_skip_balancing,
|
|
self.md_collection.MUSIC_SHEET_CODE, self.player)
|
|
|
|
trap = self.md_collection.vfx_trap_items.get(name)
|
|
if trap:
|
|
return MuseDashFixedItem(name, ItemClassification.trap, trap, self.player)
|
|
|
|
trap = self.md_collection.sfx_trap_items.get(name)
|
|
if trap:
|
|
return MuseDashFixedItem(name, ItemClassification.trap, trap, self.player)
|
|
|
|
album = self.md_collection.album_items.get(name)
|
|
if album:
|
|
return MuseDashSongItem(name, self.player, album)
|
|
|
|
song = self.md_collection.song_items.get(name)
|
|
return MuseDashSongItem(name, self.player, song)
|
|
|
|
def create_items(self) -> None:
|
|
song_keys_in_pool = self.included_songs.copy()
|
|
|
|
# Note: Item count will be off if plando is involved.
|
|
item_count = self.get_music_sheet_count()
|
|
|
|
# First add all goal song tokens
|
|
for _ in range(0, item_count):
|
|
self.multiworld.itempool.append(self.create_item(self.md_collection.MUSIC_SHEET_NAME))
|
|
|
|
# Then add all traps
|
|
trap_count = self.get_trap_count()
|
|
trap_list = self.get_available_traps()
|
|
if len(trap_list) > 0 and trap_count > 0:
|
|
for _ in range(0, trap_count):
|
|
index = self.random.randrange(0, len(trap_list))
|
|
self.multiworld.itempool.append(self.create_item(trap_list[index]))
|
|
|
|
item_count += trap_count
|
|
|
|
# Next fill all remaining slots with song items
|
|
needed_item_count = self.location_count
|
|
while item_count < needed_item_count:
|
|
# If we have more items needed than keys, just iterate the list and add them all
|
|
if len(song_keys_in_pool) <= needed_item_count - item_count:
|
|
for key in song_keys_in_pool:
|
|
self.multiworld.itempool.append(self.create_item(key))
|
|
|
|
item_count += len(song_keys_in_pool)
|
|
continue
|
|
|
|
# Otherwise add a random assortment of songs
|
|
self.random.shuffle(song_keys_in_pool)
|
|
for i in range(0, needed_item_count - item_count):
|
|
self.multiworld.itempool.append(self.create_item(song_keys_in_pool[i]))
|
|
|
|
item_count = needed_item_count
|
|
|
|
def create_regions(self) -> None:
|
|
menu_region = Region("Menu", self.player, self.multiworld)
|
|
song_select_region = Region("Song Select", self.player, self.multiworld)
|
|
self.multiworld.regions += [menu_region, song_select_region]
|
|
menu_region.connect(song_select_region)
|
|
|
|
# Make a collection of all songs available for this rando.
|
|
# 1. All starting songs
|
|
# 2. All other songs shuffled
|
|
# Doing it in this order ensures that starting songs are first in line to getting 2 locations.
|
|
# Final song is excluded as for the purpose of this rando, it doesn't matter.
|
|
|
|
all_selected_locations = self.starting_songs.copy()
|
|
included_song_copy = self.included_songs.copy()
|
|
|
|
self.random.shuffle(included_song_copy)
|
|
all_selected_locations.extend(included_song_copy)
|
|
|
|
two_item_location_count = self.location_count - len(all_selected_locations)
|
|
|
|
# Make a region per song/album, then adds 1-2 item locations to them
|
|
for i in range(0, len(all_selected_locations)):
|
|
name = all_selected_locations[i]
|
|
region = Region(name, self.player, self.multiworld)
|
|
self.multiworld.regions.append(region)
|
|
song_select_region.connect(region, name, lambda state, place=name: state.has(place, self.player))
|
|
|
|
# Up to 2 Locations are defined per song
|
|
region.add_locations({name + "-0": self.md_collection.song_locations[name + "-0"]}, MuseDashLocation)
|
|
if i < two_item_location_count:
|
|
region.add_locations({name + "-1": self.md_collection.song_locations[name + "-1"]}, MuseDashLocation)
|
|
|
|
def set_rules(self) -> None:
|
|
self.multiworld.completion_condition[self.player] = lambda state: \
|
|
state.has(self.md_collection.MUSIC_SHEET_NAME, self.player, self.get_music_sheet_win_count())
|
|
|
|
def get_available_traps(self) -> List[str]:
|
|
dlc_songs = self.multiworld.allow_just_as_planned_dlc_songs[self.player]
|
|
|
|
trap_list = []
|
|
if self.multiworld.available_trap_types[self.player].value & 1 != 0:
|
|
trap_list += self.md_collection.vfx_trap_items.keys()
|
|
|
|
# SFX options are only available under Just as Planned DLC.
|
|
if dlc_songs and self.multiworld.available_trap_types[self.player].value & 2 != 0:
|
|
trap_list += self.md_collection.sfx_trap_items.keys()
|
|
|
|
return trap_list
|
|
|
|
def get_additional_item_percentage(self) -> int:
|
|
trap_count = self.multiworld.trap_count_percentage[self.player].value
|
|
song_count = self.multiworld.music_sheet_count_percentage[self.player].value
|
|
return max(trap_count + song_count, self.multiworld.additional_item_percentage[self.player].value)
|
|
|
|
def get_trap_count(self) -> int:
|
|
multiplier = self.multiworld.trap_count_percentage[self.player].value / 100.0
|
|
trap_count = (len(self.starting_songs) * 2) + len(self.included_songs)
|
|
return max(0, floor(trap_count * multiplier))
|
|
|
|
def get_music_sheet_count(self) -> int:
|
|
multiplier = self.multiworld.music_sheet_count_percentage[self.player].value / 100.0
|
|
song_count = (len(self.starting_songs) * 2) + len(self.included_songs)
|
|
return max(1, floor(song_count * multiplier))
|
|
|
|
def get_music_sheet_win_count(self) -> int:
|
|
multiplier = self.multiworld.music_sheet_win_count_percentage[self.player].value / 100.0
|
|
sheet_count = self.get_music_sheet_count()
|
|
return max(1, floor(sheet_count * multiplier))
|
|
|
|
def get_difficulty_range(self) -> List[int]:
|
|
difficulty_mode = self.multiworld.song_difficulty_mode[self.player]
|
|
|
|
# Valid difficulties are between 1 and 11. But make it 0 to 12 for safety
|
|
difficulty_bounds = [0, 12]
|
|
if difficulty_mode == 1:
|
|
difficulty_bounds[1] = 3
|
|
elif difficulty_mode == 2:
|
|
difficulty_bounds[0] = 4
|
|
difficulty_bounds[1] = 5
|
|
elif difficulty_mode == 3:
|
|
difficulty_bounds[0] = 6
|
|
difficulty_bounds[1] = 7
|
|
elif difficulty_mode == 4:
|
|
difficulty_bounds[0] = 8
|
|
difficulty_bounds[1] = 9
|
|
elif difficulty_mode == 5:
|
|
difficulty_bounds[0] = 10
|
|
elif difficulty_mode == 6:
|
|
minimum_difficulty = self.multiworld.song_difficulty_min[self.player].value
|
|
maximum_difficulty = self.multiworld.song_difficulty_max[self.player].value
|
|
|
|
difficulty_bounds[0] = min(minimum_difficulty, maximum_difficulty)
|
|
difficulty_bounds[1] = max(minimum_difficulty, maximum_difficulty)
|
|
|
|
return difficulty_bounds
|
|
|
|
def fill_slot_data(self):
|
|
return {
|
|
"victoryLocation": self.victory_song_name,
|
|
"deathLink": self.multiworld.death_link[self.player].value,
|
|
"musicSheetWinCount": self.get_music_sheet_win_count(),
|
|
"gradeNeeded": self.multiworld.grade_needed[self.player].value
|
|
}
|