morgan/Grinch-AP
1
0
Fork 0
mirror of https://github.com/MarioSpore/Grinch-AP.git synced 2025-10-21 20:21:32 -06:00
Code Issues Packages Projects Releases Wiki Activity

Bomb Rush Cyberfunk: Implement new game (#2925)

Browse Source 
Adds Team Reptile's Bomb Rush Cyberfunk as a new game.
This commit is contained in:
Trevor L
2024-05-17 04:13:40 -06:00
committed by GitHub
parent 2447be92d8
commit 68323b46a9
14 changed files with 3296 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

214
worlds/bomb_rush_cyberfunk/__init__.py Normal file
View File

@@ -0,0 +1,214 @@
from typing import Any, Dict
from BaseClasses import MultiWorld, Region, Location, Item, Tutorial, ItemClassification, CollectionState
from worlds.AutoWorld import World, WebWorld
from .Items import base_id, item_table, group_table, BRCType
from .Locations import location_table, event_table
from .Regions import region_exits
from .Rules import rules
from .Options import BombRushCyberfunkOptions, StartStyle
class BombRushCyberfunkWeb(WebWorld):
theme = "ocean"
tutorials = [Tutorial(
"Multiworld Setup Guide",
"A guide to setting up Bomb Rush Cyberfunk randomizer and connecting to an Archipelago Multiworld",
"English",
"setup_en.md",
"setup/en",
["TRPG"]
)]
class BombRushCyberfunkWorld(World):
"""Bomb Rush Cyberfunk is 1 second per second of advanced funkstyle. Battle rival crews and dispatch militarized
police to conquer the five boroughs of New Amsterdam. Become All City."""
game = "Bomb Rush Cyberfunk"
web = BombRushCyberfunkWeb()
item_name_to_id = {item["name"]: (base_id + index) for index, item in enumerate(item_table)}
item_name_to_type = {item["name"]: item["type"] for item in item_table}
location_name_to_id = {loc["name"]: (base_id + index) for index, loc in enumerate(location_table)}
item_name_groups = group_table
options_dataclass = BombRushCyberfunkOptions
options: BombRushCyberfunkOptions
def __init__(self, multiworld: MultiWorld, player: int):
super(BombRushCyberfunkWorld, self).__init__(multiworld, player)
self.item_classification: Dict[BRCType, ItemClassification] = {
BRCType.Music: ItemClassification.filler,
BRCType.GraffitiM: ItemClassification.progression,
BRCType.GraffitiL: ItemClassification.progression,
BRCType.GraffitiXL: ItemClassification.progression,
BRCType.Outfit: ItemClassification.filler,
BRCType.Character: ItemClassification.progression,
BRCType.REP: ItemClassification.progression_skip_balancing,
BRCType.Camera: ItemClassification.progression
}
def collect(self, state: "CollectionState", item: "Item") -> bool:
change = super().collect(state, item)
if change and "REP" in item.name:
rep: int = int(item.name[0:len(item.name)-4])
state.prog_items[item.player]["rep"] += rep
return change
def remove(self, state: "CollectionState", item: "Item") -> bool:
change = super().remove(state, item)
if change and "REP" in item.name:
rep: int = int(item.name[0:len(item.name)-4])
state.prog_items[item.player]["rep"] -= rep
return change
def set_rules(self):
rules(self)
def get_item_classification(self, item_type: BRCType) -> ItemClassification:
classification = ItemClassification.filler
if item_type in self.item_classification.keys():
classification = self.item_classification[item_type]
return classification
def create_item(self, name: str) -> "BombRushCyberfunkItem":
item_id: int = self.item_name_to_id[name]
item_type: BRCType = self.item_name_to_type[name]
classification = self.get_item_classification(item_type)
return BombRushCyberfunkItem(name, classification, item_id, self.player)
def create_event(self, event: str) -> "BombRushCyberfunkItem":
return BombRushCyberfunkItem(event, ItemClassification.progression_skip_balancing, None, self.player)
def get_filler_item_name(self) -> str:
item = self.random.choice(item_table)
while self.get_item_classification(item["type"]) == ItemClassification.progression:
item = self.random.choice(item_table)
return item["name"]
def generate_early(self):
if self.options.starting_movestyle == StartStyle.option_skateboard:
self.item_classification[BRCType.Skateboard] = ItemClassification.filler
else:
self.item_classification[BRCType.Skateboard] = ItemClassification.progression
if self.options.starting_movestyle == StartStyle.option_inline_skates:
self.item_classification[BRCType.InlineSkates] = ItemClassification.filler
else:
self.item_classification[BRCType.InlineSkates] = ItemClassification.progression
if self.options.starting_movestyle == StartStyle.option_bmx:
self.item_classification[BRCType.BMX] = ItemClassification.filler
else:
self.item_classification[BRCType.BMX] = ItemClassification.progression
def create_items(self):
rep_locations: int = 87
if self.options.skip_polo_photos:
rep_locations -= 18
self.options.total_rep.round_to_nearest_step()
rep_counts = self.options.total_rep.get_rep_item_counts(self.random, rep_locations)
#print(sum([8*rep_counts[0], 16*rep_counts[1], 24*rep_counts[2], 32*rep_counts[3], 48*rep_counts[4]]), \
# rep_counts)
pool = []
for item in item_table:
if "REP" in item["name"]:
count: int = 0
if item["name"] == "8 REP":
count = rep_counts[0]
elif item["name"] == "16 REP":
count = rep_counts[1]
elif item["name"] == "24 REP":
count = rep_counts[2]
elif item["name"] == "32 REP":
count = rep_counts[3]
elif item["name"] == "48 REP":
count = rep_counts[4]
if count > 0:
for _ in range(count):
pool.append(self.create_item(item["name"]))
else:
pool.append(self.create_item(item["name"]))
self.multiworld.itempool += pool
def create_regions(self):
multiworld = self.multiworld
player = self.player
menu = Region("Menu", player, multiworld)
multiworld.regions.append(menu)
for n in region_exits:
multiworld.regions += [Region(n, player, multiworld)]
menu.add_exits({"Hideout": "New Game"})
for n in region_exits:
self.get_region(n).add_exits(region_exits[n])
for index, loc in enumerate(location_table):
if self.options.skip_polo_photos and "Polo" in loc["name"]:
continue
stage: Region = self.get_region(loc["stage"])
stage.add_locations({loc["name"]: base_id + index})
for e in event_table:
stage: Region = self.get_region(e["stage"])
event = BombRushCyberfunkLocation(player, e["name"], None, stage)
event.show_in_spoiler = False
event.place_locked_item(self.create_event(e["item"]))
stage.locations += [event]
multiworld.completion_condition[player] = lambda state: state.has("Victory", player)
def fill_slot_data(self) -> Dict[str, Any]:
options = self.options
slot_data: Dict[str, Any] = {
"locations": {loc["game_id"]: (base_id + index) for index, loc in enumerate(location_table)},
"logic": options.logic.value,
"skip_intro": bool(options.skip_intro.value),
"skip_dreams": bool(options.skip_dreams.value),
"skip_statue_hands": bool(options.skip_statue_hands.value),
"total_rep": options.total_rep.value,
"extra_rep_required": bool(options.extra_rep_required.value),
"starting_movestyle": options.starting_movestyle.value,
"limited_graffiti": bool(options.limited_graffiti.value),
"small_graffiti_uses": options.small_graffiti_uses.value,
"skip_polo_photos": bool(options.skip_polo_photos.value),
"dont_save_photos": bool(options.dont_save_photos.value),
"score_difficulty": int(options.score_difficulty.value),
"damage_multiplier": options.damage_multiplier.value,
"death_link": bool(options.death_link.value)
}
return slot_data
class BombRushCyberfunkItem(Item):
game: str = "Bomb Rush Cyberfunk"
class BombRushCyberfunkLocation(Location):
game: str = "Bomb Rush Cyberfunk"