1040 lines
39 KiB
Python
1040 lines
39 KiB
Python
from worlds.generic.Rules import set_rule, add_rule
|
|
from BaseClasses import CollectionState
|
|
from typing import Dict
|
|
from .Regions import Stages
|
|
|
|
|
|
def graffitiM(state: CollectionState, player: int, limit: bool, spots: int) -> bool:
|
|
return state.count_group_unique("graffitim", player) * 7 >= spots if limit \
|
|
else state.has_group("graffitim", player)
|
|
|
|
|
|
def graffitiL(state: CollectionState, player: int, limit: bool, spots: int) -> bool:
|
|
return state.count_group_unique("graffitil", player) * 6 >= spots if limit \
|
|
else state.has_group("graffitil", player)
|
|
|
|
|
|
def graffitiXL(state: CollectionState, player: int, limit: bool, spots: int) -> bool:
|
|
return state.count_group_unique("graffitixl", player) * 4 >= spots if limit \
|
|
else state.has_group("graffitixl", player)
|
|
|
|
|
|
def skateboard(state: CollectionState, player: int, movestyle: int) -> bool:
|
|
return True if movestyle == 2 else state.has_group("skateboard", player)
|
|
|
|
|
|
def inline_skates(state: CollectionState, player: int, movestyle: int) -> bool:
|
|
return True if movestyle == 3 else state.has_group("skates", player)
|
|
|
|
|
|
def bmx(state: CollectionState, player: int, movestyle: int) -> bool:
|
|
return True if movestyle == 1 else state.has_group("bmx", player)
|
|
|
|
|
|
def camera(state: CollectionState, player: int) -> bool:
|
|
return state.has("Camera App", player)
|
|
|
|
|
|
def is_girl(state: CollectionState, player: int) -> bool:
|
|
return state.has_group("girl", player)
|
|
|
|
|
|
def current_chapter(state: CollectionState, player: int, chapter: int) -> bool:
|
|
return state.has("Chapter Completed", player, chapter-1)
|
|
|
|
|
|
def versum_hill_entrance(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 20)
|
|
|
|
|
|
def versum_hill_ch1_roadblock(state: CollectionState, player: int, limit: bool) -> bool:
|
|
return graffitiL(state, player, limit, 10)
|
|
|
|
|
|
def versum_hill_challenge1(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 50)
|
|
|
|
|
|
def versum_hill_challenge2(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 58)
|
|
|
|
|
|
def versum_hill_challenge3(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 65)
|
|
|
|
|
|
def versum_hill_all_challenges(state: CollectionState, player: int) -> bool:
|
|
return versum_hill_challenge3(state, player)
|
|
|
|
|
|
def versum_hill_basketball_court(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 90)
|
|
|
|
|
|
def versum_hill_oldhead(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 120)
|
|
|
|
|
|
def versum_hill_crew_battle(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
rep(state, player, 90)
|
|
and graffitiM(state, player, limit, 98)
|
|
)
|
|
else:
|
|
return (
|
|
rep(state, player, 90)
|
|
and graffitiM(state, player, limit, 27)
|
|
)
|
|
|
|
|
|
def versum_hill_rietveld(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
current_chapter(state, player, 2)
|
|
and graffitiM(state, player, limit, 114)
|
|
)
|
|
else:
|
|
return (
|
|
current_chapter(state, player, 2)
|
|
and graffitiM(state, player, limit, 67)
|
|
)
|
|
|
|
|
|
def versum_hill_rave(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
if current_chapter(state, player, 4):
|
|
return (
|
|
graffitiL(state, player, limit, 90)
|
|
and graffitiXL(state, player, limit, 51)
|
|
)
|
|
elif current_chapter(state, player, 3):
|
|
return (
|
|
graffitiL(state, player, limit, 89)
|
|
and graffitiXL(state, player, limit, 51)
|
|
)
|
|
else:
|
|
return (
|
|
graffitiL(state, player, limit, 85)
|
|
and graffitiXL(state, player, limit, 48)
|
|
)
|
|
else:
|
|
return (
|
|
graffitiL(state, player, limit, 26)
|
|
and graffitiXL(state, player, limit, 10)
|
|
)
|
|
|
|
|
|
def millennium_square_entrance(state: CollectionState, player: int) -> bool:
|
|
return current_chapter(state, player, 2)
|
|
|
|
|
|
def brink_terminal_entrance(state: CollectionState, player: int) -> bool:
|
|
return (
|
|
is_girl(state, player)
|
|
and rep(state, player, 180)
|
|
and current_chapter(state, player, 2)
|
|
)
|
|
|
|
|
|
def brink_terminal_challenge1(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 188)
|
|
|
|
|
|
def brink_terminal_challenge2(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 200)
|
|
|
|
|
|
def brink_terminal_challenge3(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 220)
|
|
|
|
|
|
def brink_terminal_all_challenges(state: CollectionState, player: int) -> bool:
|
|
return brink_terminal_challenge3(state, player)
|
|
|
|
|
|
def brink_terminal_plaza(state: CollectionState, player: int) -> bool:
|
|
return brink_terminal_all_challenges(state, player)
|
|
|
|
|
|
def brink_terminal_tower(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 280)
|
|
|
|
|
|
def brink_terminal_oldhead_underground(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 250)
|
|
|
|
|
|
def brink_terminal_oldhead_dock(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 320)
|
|
|
|
|
|
def brink_terminal_crew_battle(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
rep(state, player, 280)
|
|
and graffitiL(state, player, limit, 103)
|
|
)
|
|
else:
|
|
return (
|
|
rep(state, player, 280)
|
|
and graffitiL(state, player, limit, 62)
|
|
)
|
|
|
|
|
|
def brink_terminal_mesh(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
graffitiM(state, player, limit, 114)
|
|
and graffitiXL(state, player, limit, 45)
|
|
)
|
|
else:
|
|
return (
|
|
graffitiM(state, player, limit, 67)
|
|
and graffitiXL(state, player, limit, 45)
|
|
)
|
|
|
|
|
|
def millennium_mall_entrance(state: CollectionState, player: int) -> bool:
|
|
return (
|
|
rep(state, player, 380)
|
|
and current_chapter(state, player, 3)
|
|
)
|
|
|
|
|
|
def millennium_mall_oldhead_ceiling(state: CollectionState, player: int, limit: bool) -> bool:
|
|
return (
|
|
rep(state, player, 580)
|
|
or millennium_mall_theater(state, player, limit)
|
|
)
|
|
|
|
|
|
def millennium_mall_switch(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
graffitiM(state, player, limit, 114)
|
|
and current_chapter(state, player, 3)
|
|
)
|
|
else:
|
|
return (
|
|
graffitiM(state, player, limit, 72)
|
|
and current_chapter(state, player, 3)
|
|
)
|
|
|
|
|
|
def millennium_mall_big(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
return millennium_mall_switch(state, player, limit, glitched)
|
|
|
|
|
|
def millennium_mall_oldhead_race(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 530)
|
|
|
|
|
|
def millennium_mall_challenge1(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 434)
|
|
|
|
|
|
def millennium_mall_challenge2(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 442)
|
|
|
|
|
|
def millennium_mall_challenge3(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 450)
|
|
|
|
|
|
def millennium_mall_challenge4(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 458)
|
|
|
|
|
|
def millennium_mall_all_challenges(state: CollectionState, player: int) -> bool:
|
|
return millennium_mall_challenge4(state, player)
|
|
|
|
|
|
def millennium_mall_theater(state: CollectionState, player: int, limit: bool) -> bool:
|
|
return (
|
|
rep(state, player, 491)
|
|
and graffitiM(state, player, limit, 78)
|
|
)
|
|
|
|
|
|
def millennium_mall_crew_battle(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
rep(state, player, 491)
|
|
and graffitiM(state, player, limit, 114)
|
|
and graffitiL(state, player, limit, 107)
|
|
)
|
|
else:
|
|
return (
|
|
rep(state, player, 491)
|
|
and graffitiM(state, player, limit, 78)
|
|
and graffitiL(state, player, limit, 80)
|
|
)
|
|
|
|
|
|
def pyramid_island_entrance(state: CollectionState, player: int) -> bool:
|
|
return current_chapter(state, player, 4)
|
|
|
|
|
|
def pyramid_island_gate(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 620)
|
|
|
|
|
|
def pyramid_island_oldhead(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 780)
|
|
|
|
|
|
def pyramid_island_challenge1(state: CollectionState, player: int) -> bool:
|
|
return (
|
|
rep(state, player, 630)
|
|
and current_chapter(state, player, 4)
|
|
)
|
|
|
|
|
|
def pyramid_island_race(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
pyramid_island_challenge1(state, player)
|
|
and graffitiL(state, player, limit, 108)
|
|
)
|
|
else:
|
|
return (
|
|
pyramid_island_challenge1(state, player)
|
|
and graffitiL(state, player, limit, 93)
|
|
)
|
|
|
|
|
|
def pyramid_island_challenge2(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 650)
|
|
|
|
|
|
def pyramid_island_challenge3(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 660)
|
|
|
|
|
|
def pyramid_island_all_challenges(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
graffitiM(state, player, limit, 114)
|
|
and rep(state, player, 660)
|
|
)
|
|
else:
|
|
return (
|
|
graffitiM(state, player, limit, 88)
|
|
and rep(state, player, 660)
|
|
)
|
|
|
|
|
|
def pyramid_island_upper_half(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
return pyramid_island_all_challenges(state, player, limit, glitched)
|
|
|
|
|
|
def pyramid_island_crew_battle(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
rep(state, player, 730)
|
|
and graffitiL(state, player, limit, 108)
|
|
)
|
|
else:
|
|
return (
|
|
rep(state, player, 730)
|
|
and graffitiL(state, player, limit, 97)
|
|
)
|
|
|
|
|
|
def pyramid_island_top(state: CollectionState, player: int) -> bool:
|
|
return current_chapter(state, player, 5)
|
|
|
|
|
|
def mataan_entrance(state: CollectionState, player: int) -> bool:
|
|
return current_chapter(state, player, 2)
|
|
|
|
|
|
def mataan_smoke_wall(state: CollectionState, player: int) -> bool:
|
|
return (
|
|
current_chapter(state, player, 5)
|
|
and rep(state, player, 850)
|
|
)
|
|
|
|
|
|
def mataan_challenge1(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
current_chapter(state, player, 5)
|
|
and rep(state, player, 864)
|
|
and graffitiL(state, player, limit, 108)
|
|
)
|
|
else:
|
|
return (
|
|
current_chapter(state, player, 5)
|
|
and rep(state, player, 864)
|
|
and graffitiL(state, player, limit, 98)
|
|
)
|
|
|
|
|
|
def mataan_deep_city(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
return mataan_challenge1(state, player, limit, glitched)
|
|
|
|
|
|
def mataan_oldhead(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 935)
|
|
|
|
|
|
def mataan_challenge2(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
rep(state, player, 880)
|
|
and graffitiXL(state, player, limit, 59)
|
|
)
|
|
else:
|
|
return (
|
|
rep(state, player, 880)
|
|
and graffitiXL(state, player, limit, 57)
|
|
)
|
|
|
|
|
|
def mataan_challenge3(state: CollectionState, player: int) -> bool:
|
|
return rep(state, player, 920)
|
|
|
|
|
|
def mataan_all_challenges(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
return (
|
|
mataan_challenge2(state, player, limit, glitched)
|
|
and mataan_challenge3(state, player)
|
|
)
|
|
|
|
|
|
def mataan_smoke_wall2(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
return (
|
|
mataan_all_challenges(state, player, limit, glitched)
|
|
and rep(state, player, 960)
|
|
)
|
|
|
|
|
|
def mataan_crew_battle(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
if glitched:
|
|
return (
|
|
mataan_smoke_wall2(state, player, limit, glitched)
|
|
and graffitiM(state, player, limit, 122)
|
|
and graffitiXL(state, player, limit, 59)
|
|
)
|
|
else:
|
|
return (
|
|
mataan_smoke_wall2(state, player, limit, glitched)
|
|
and graffitiM(state, player, limit, 117)
|
|
and graffitiXL(state, player, limit, 57)
|
|
)
|
|
|
|
|
|
def mataan_deepest(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
return mataan_crew_battle(state, player, limit, glitched)
|
|
|
|
|
|
def mataan_faux(state: CollectionState, player: int, limit: bool, glitched: bool) -> bool:
|
|
return (
|
|
mataan_deepest(state, player, limit, glitched)
|
|
and graffitiM(state, player, limit, 122)
|
|
)
|
|
|
|
|
|
def spots_s_glitchless(state: CollectionState, player: int, limit: bool, access_cache: Dict[str, bool]) -> int:
|
|
total: int = 10
|
|
conditions: Dict[str, int] = {
|
|
"versum_hill_entrance": 1,
|
|
"versum_hill_ch1_roadblock": 11,
|
|
"chapter2": 12,
|
|
"versum_hill_oldhead": 1,
|
|
"brink_terminal_entrance": 9,
|
|
"brink_terminal_plaza": 3,
|
|
"brink_terminal_tower": 0,
|
|
"chapter3": 6,
|
|
"brink_terminal_oldhead_dock": 1,
|
|
"millennium_mall_entrance": 3,
|
|
"millennium_mall_switch": 4,
|
|
"millennium_mall_theater": 3,
|
|
"chapter4": 2,
|
|
"pyramid_island_gate": 5,
|
|
"pyramid_island_upper_half": 8,
|
|
"pyramid_island_oldhead": 2,
|
|
"mataan_smoke_wall": 3,
|
|
"mataan_deep_city": 5,
|
|
"mataan_oldhead": 3,
|
|
"mataan_deepest": 2
|
|
}
|
|
|
|
for access_name, graffiti_count in conditions.items():
|
|
if access_cache[access_name]:
|
|
total += graffiti_count
|
|
else:
|
|
break
|
|
|
|
if limit:
|
|
sprayable: int = 5 + (state.count_group_unique("characters", player) * 5)
|
|
if total <= sprayable:
|
|
return total
|
|
else:
|
|
return sprayable
|
|
else:
|
|
return total
|
|
|
|
|
|
def spots_s_glitched(state: CollectionState, player: int, limit: bool, access_cache: Dict[str, bool]) -> int:
|
|
total: int = 75
|
|
conditions: Dict[str, int] = {
|
|
"brink_terminal_entrance": 13,
|
|
"chapter3": 6
|
|
}
|
|
|
|
for access_name, graffiti_count in conditions.items():
|
|
if access_cache[access_name]:
|
|
total += graffiti_count
|
|
else:
|
|
break
|
|
|
|
if limit:
|
|
sprayable: int = 5 + (state.count_group_unique("characters", player) * 5)
|
|
if total <= sprayable:
|
|
return total
|
|
else:
|
|
return sprayable
|
|
else:
|
|
return total
|
|
|
|
|
|
def spots_m_glitchless(state: CollectionState, player: int, limit: bool, access_cache: Dict[str, bool]) -> int:
|
|
total: int = 4
|
|
conditions: Dict[str, int] = {
|
|
"versum_hill_entrance": 3,
|
|
"versum_hill_ch1_roadblock": 13,
|
|
"versum_hill_all_challenges": 3,
|
|
"chapter2": 16,
|
|
"versum_hill_oldhead": 4,
|
|
"brink_terminal_entrance": 13,
|
|
"brink_terminal_plaza": 4,
|
|
"brink_terminal_tower": 0,
|
|
"chapter3": 3,
|
|
"brink_terminal_oldhead_dock": 4,
|
|
"millennium_mall_entrance": 5,
|
|
"millennium_mall_big": 6,
|
|
"millennium_mall_theater": 4,
|
|
"chapter4": 2,
|
|
"millennium_mall_oldhead_ceiling": 1,
|
|
"pyramid_island_gate": 3,
|
|
"pyramid_island_upper_half": 8,
|
|
"chapter5": 2,
|
|
"pyramid_island_oldhead": 5,
|
|
"mataan_deep_city": 7,
|
|
"skateboard": 1,
|
|
"mataan_oldhead": 1,
|
|
"mataan_smoke_wall2": 1,
|
|
"mataan_deepest": 10
|
|
}
|
|
|
|
for access_name, graffiti_count in conditions.items():
|
|
if access_cache[access_name]:
|
|
total += graffiti_count
|
|
elif access_name != "skateboard":
|
|
break
|
|
|
|
if limit:
|
|
sprayable: int = state.count_group_unique("graffitim", player) * 7
|
|
if total <= sprayable:
|
|
return total
|
|
else:
|
|
return sprayable
|
|
else:
|
|
if state.has_group("graffitim", player):
|
|
return total
|
|
else:
|
|
return 0
|
|
|
|
|
|
def spots_m_glitched(state: CollectionState, player: int, limit: bool, access_cache: Dict[str, bool]) -> int:
|
|
total: int = 99
|
|
conditions: Dict[str, int] = {
|
|
"brink_terminal_entrance": 21,
|
|
"chapter3": 3
|
|
}
|
|
|
|
for access_name, graffiti_count in conditions.items():
|
|
if access_cache[access_name]:
|
|
total += graffiti_count
|
|
else:
|
|
break
|
|
|
|
if limit:
|
|
sprayable: int = state.count_group_unique("graffitim", player) * 7
|
|
if total <= sprayable:
|
|
return total
|
|
else:
|
|
return sprayable
|
|
else:
|
|
if state.has_group("graffitim", player):
|
|
return total
|
|
else:
|
|
return 0
|
|
|
|
|
|
def spots_l_glitchless(state: CollectionState, player: int, limit: bool, access_cache: Dict[str, bool]) -> int:
|
|
total: int = 7
|
|
conditions: Dict[str, int] = {
|
|
"inline_skates": 1,
|
|
"versum_hill_entrance": 2,
|
|
"versum_hill_ch1_roadblock": 13,
|
|
"versum_hill_all_challenges": 1,
|
|
"chapter2": 14,
|
|
"versum_hill_oldhead": 2,
|
|
"brink_terminal_entrance": 10,
|
|
"brink_terminal_plaza": 2,
|
|
"brink_terminal_oldhead_underground": 1,
|
|
"brink_terminal_tower": 1,
|
|
"chapter3": 4,
|
|
"brink_terminal_oldhead_dock": 4,
|
|
"millennium_mall_entrance": 3,
|
|
"millennium_mall_big": 8,
|
|
"millennium_mall_theater": 4,
|
|
"chapter4": 5,
|
|
"millennium_mall_oldhead_ceiling": 3,
|
|
"pyramid_island_gate": 4,
|
|
"pyramid_island_upper_half": 5,
|
|
"pyramid_island_crew_battle": 1,
|
|
"chapter5": 1,
|
|
"pyramid_island_oldhead": 2,
|
|
"mataan_smoke_wall": 1,
|
|
"mataan_deep_city": 2,
|
|
"skateboard": 1,
|
|
"mataan_oldhead": 2,
|
|
"mataan_deepest": 7
|
|
}
|
|
|
|
for access_name, graffiti_count in conditions.items():
|
|
if access_cache[access_name]:
|
|
total += graffiti_count
|
|
elif not (access_name == "inline_skates" or access_name == "skateboard"):
|
|
break
|
|
|
|
if limit:
|
|
sprayable: int = state.count_group_unique("graffitil", player) * 6
|
|
if total <= sprayable:
|
|
return total
|
|
else:
|
|
return sprayable
|
|
else:
|
|
if state.has_group("graffitil", player):
|
|
return total
|
|
else:
|
|
return 0
|
|
|
|
|
|
def spots_l_glitched(state: CollectionState, player: int, limit: bool, access_cache: Dict[str, bool]) -> int:
|
|
total: int = 88
|
|
conditions: Dict[str, int] = {
|
|
"brink_terminal_entrance": 18,
|
|
"chapter3": 4,
|
|
"chapter4": 1
|
|
}
|
|
|
|
for access_name, graffiti_count in conditions.items():
|
|
if access_cache[access_name]:
|
|
total += graffiti_count
|
|
else:
|
|
break
|
|
|
|
if limit:
|
|
sprayable: int = state.count_group_unique("graffitil", player) * 6
|
|
if total <= sprayable:
|
|
return total
|
|
else:
|
|
return sprayable
|
|
else:
|
|
if state.has_group("graffitil", player):
|
|
return total
|
|
else:
|
|
return 0
|
|
|
|
|
|
def spots_xl_glitchless(state: CollectionState, player: int, limit: bool, access_cache: Dict[str, bool]) -> int:
|
|
total: int = 3
|
|
conditions: Dict[str, int] = {
|
|
"versum_hill_ch1_roadblock": 6,
|
|
"versum_hill_basketball_court": 1,
|
|
"chapter2": 9,
|
|
"brink_terminal_entrance": 3,
|
|
"brink_terminal_plaza": 1,
|
|
"brink_terminal_oldhead_underground": 1,
|
|
"brink_terminal_tower": 1,
|
|
"chapter3": 3,
|
|
"brink_terminal_oldhead_dock": 2,
|
|
"millennium_mall_entrance": 2,
|
|
"millennium_mall_big": 5,
|
|
"millennium_mall_theater": 5,
|
|
"chapter4": 3,
|
|
"millennium_mall_oldhead_ceiling": 1,
|
|
"pyramid_island_upper_half": 5,
|
|
"pyramid_island_oldhead": 3,
|
|
"mataan_smoke_wall": 2,
|
|
"mataan_deep_city": 2,
|
|
"mataan_oldhead": 2,
|
|
"mataan_deepest": 2
|
|
}
|
|
|
|
for access_name, graffiti_count in conditions.items():
|
|
if access_cache[access_name]:
|
|
total += graffiti_count
|
|
else:
|
|
break
|
|
|
|
if limit:
|
|
sprayable: int = state.count_group_unique("graffitixl", player) * 4
|
|
if total <= sprayable:
|
|
return total
|
|
else:
|
|
return sprayable
|
|
else:
|
|
if state.has_group("graffitixl", player):
|
|
return total
|
|
else:
|
|
return 0
|
|
|
|
|
|
def spots_xl_glitched(state: CollectionState, player: int, limit: bool, access_cache: Dict[str, bool]) -> int:
|
|
total: int = 51
|
|
conditions: Dict[str, int] = {
|
|
"brink_terminal_entrance": 7,
|
|
"chapter3": 3,
|
|
"chapter4": 1
|
|
}
|
|
|
|
for access_name, graffiti_count in conditions.items():
|
|
if access_cache[access_name]:
|
|
total += graffiti_count
|
|
else:
|
|
break
|
|
|
|
if limit:
|
|
sprayable: int = state.count_group_unique("graffitixl", player) * 4
|
|
if total <= sprayable:
|
|
return total
|
|
else:
|
|
return sprayable
|
|
else:
|
|
if state.has_group("graffitixl", player):
|
|
return total
|
|
else:
|
|
return 0
|
|
|
|
|
|
def build_access_cache(state: CollectionState, player: int, movestyle: int, limit: bool, glitched: bool) -> Dict[str, bool]:
|
|
funcs: Dict[str, tuple] = {
|
|
"versum_hill_entrance": (state, player),
|
|
"versum_hill_ch1_roadblock": (state, player, limit),
|
|
"versum_hill_oldhead": (state, player),
|
|
"versum_hill_all_challenges": (state, player),
|
|
"versum_hill_basketball_court": (state, player),
|
|
"brink_terminal_entrance": (state, player),
|
|
"brink_terminal_oldhead_underground": (state, player),
|
|
"brink_terminal_oldhead_dock": (state, player),
|
|
"brink_terminal_plaza": (state, player),
|
|
"brink_terminal_tower": (state, player),
|
|
"millennium_mall_entrance": (state, player),
|
|
"millennium_mall_switch": (state, player, limit, glitched),
|
|
"millennium_mall_oldhead_ceiling": (state, player, limit),
|
|
"millennium_mall_big": (state, player, limit, glitched),
|
|
"millennium_mall_theater": (state, player, limit),
|
|
"pyramid_island_gate": (state, player),
|
|
"pyramid_island_oldhead": (state, player),
|
|
"pyramid_island_upper_half": (state, player, limit, glitched),
|
|
"pyramid_island_crew_battle": (state, player, limit, glitched),
|
|
"mataan_smoke_wall": (state, player),
|
|
"mataan_deep_city": (state, player, limit, glitched),
|
|
"mataan_oldhead": (state, player),
|
|
"mataan_smoke_wall2": (state, player, limit, glitched),
|
|
"mataan_deepest": (state, player, limit, glitched)
|
|
}
|
|
|
|
access_cache: Dict[str, bool] = {
|
|
"skateboard": skateboard(state, player, movestyle),
|
|
"inline_skates": inline_skates(state, player, movestyle),
|
|
"chapter2": current_chapter(state, player, 2),
|
|
"chapter3": current_chapter(state, player, 3),
|
|
"chapter4": current_chapter(state, player, 4),
|
|
"chapter5": current_chapter(state, player, 5)
|
|
}
|
|
|
|
stop: bool = False
|
|
for fname, fvars in funcs.items():
|
|
if stop:
|
|
access_cache[fname] = False
|
|
continue
|
|
func = globals()[fname]
|
|
access: bool = func(*fvars)
|
|
access_cache[fname] = access
|
|
if not access and "oldhead" not in fname:
|
|
stop = True
|
|
|
|
return access_cache
|
|
|
|
|
|
def graffiti_spots(state: CollectionState, player: int, movestyle: int, limit: bool, glitched: bool, spots: int) -> bool:
|
|
access_cache = build_access_cache(state, player, movestyle, limit, glitched)
|
|
|
|
total: int = 0
|
|
|
|
if glitched:
|
|
total = spots_s_glitched(state, player, limit, access_cache) \
|
|
+ spots_m_glitched(state, player, limit, access_cache) \
|
|
+ spots_l_glitched(state, player, limit, access_cache) \
|
|
+ spots_xl_glitched(state, player, limit, access_cache)
|
|
else:
|
|
total = spots_s_glitchless(state, player, limit, access_cache) \
|
|
+ spots_m_glitchless(state, player, limit, access_cache) \
|
|
+ spots_l_glitchless(state, player, limit, access_cache) \
|
|
+ spots_xl_glitchless(state, player, limit, access_cache)
|
|
|
|
return total >= spots
|
|
|
|
|
|
def rep(state: CollectionState, player: int, required: int) -> bool:
|
|
return state.has("rep", player, required)
|
|
|
|
|
|
def rules(brcworld):
|
|
multiworld = brcworld.multiworld
|
|
player = brcworld.player
|
|
|
|
movestyle = brcworld.options.starting_movestyle
|
|
limit = brcworld.options.limited_graffiti
|
|
glitched = brcworld.options.logic
|
|
extra = brcworld.options.extra_rep_required
|
|
photos = not brcworld.options.skip_polo_photos
|
|
|
|
# entrances
|
|
for e in multiworld.get_region(Stages.BT1, player).entrances:
|
|
set_rule(e, lambda state: brink_terminal_entrance(state, player))
|
|
|
|
if not glitched:
|
|
# versum hill
|
|
for e in multiworld.get_region(Stages.VH1, player).entrances:
|
|
set_rule(e, lambda state: versum_hill_entrance(state, player))
|
|
for e in multiworld.get_region(Stages.VH2, player).entrances:
|
|
set_rule(e, lambda state: versum_hill_ch1_roadblock(state, player, limit))
|
|
for e in multiworld.get_region(Stages.VHO, player).entrances:
|
|
set_rule(e, lambda state: versum_hill_oldhead(state, player))
|
|
for e in multiworld.get_region(Stages.VH3, player).entrances:
|
|
set_rule(e, lambda state: versum_hill_all_challenges(state, player))
|
|
for e in multiworld.get_region(Stages.VH4, player).entrances:
|
|
set_rule(e, lambda state: versum_hill_basketball_court(state, player))
|
|
|
|
# millennium square
|
|
for e in multiworld.get_region(Stages.MS, player).entrances:
|
|
set_rule(e, lambda state: millennium_square_entrance(state, player))
|
|
|
|
# brink terminal
|
|
for e in multiworld.get_region(Stages.BTO1, player).entrances:
|
|
set_rule(e, lambda state: brink_terminal_oldhead_underground(state, player))
|
|
for e in multiworld.get_region(Stages.BTO2, player).entrances:
|
|
set_rule(e, lambda state: brink_terminal_oldhead_dock(state, player))
|
|
for e in multiworld.get_region(Stages.BT2, player).entrances:
|
|
set_rule(e, lambda state: brink_terminal_plaza(state, player))
|
|
for e in multiworld.get_region(Stages.BT3, player).entrances:
|
|
set_rule(e, lambda state: brink_terminal_tower(state, player))
|
|
|
|
# millennium mall
|
|
for e in multiworld.get_region(Stages.MM1, player).entrances:
|
|
set_rule(e, lambda state: millennium_mall_entrance(state, player))
|
|
for e in multiworld.get_region(Stages.MMO1, player).entrances:
|
|
set_rule(e, lambda state: millennium_mall_oldhead_ceiling(state, player, limit))
|
|
for e in multiworld.get_region(Stages.MM2, player).entrances:
|
|
set_rule(e, lambda state: millennium_mall_big(state, player, limit, glitched))
|
|
for e in multiworld.get_region(Stages.MMO2, player).entrances:
|
|
set_rule(e, lambda state: millennium_mall_oldhead_race(state, player))
|
|
for e in multiworld.get_region(Stages.MM3, player).entrances:
|
|
set_rule(e, lambda state: millennium_mall_theater(state, player, limit))
|
|
|
|
# pyramid island
|
|
for e in multiworld.get_region(Stages.PI1, player).entrances:
|
|
set_rule(e, lambda state: pyramid_island_entrance(state, player))
|
|
for e in multiworld.get_region(Stages.PI2, player).entrances:
|
|
set_rule(e, lambda state: pyramid_island_gate(state, player))
|
|
for e in multiworld.get_region(Stages.PIO, player).entrances:
|
|
set_rule(e, lambda state: pyramid_island_oldhead(state, player))
|
|
for e in multiworld.get_region(Stages.PI3, player).entrances:
|
|
set_rule(e, lambda state: pyramid_island_upper_half(state, player, limit, glitched))
|
|
for e in multiworld.get_region(Stages.PI4, player).entrances:
|
|
set_rule(e, lambda state: pyramid_island_top(state, player))
|
|
|
|
# mataan
|
|
for e in multiworld.get_region(Stages.MA1, player).entrances:
|
|
set_rule(e, lambda state: mataan_entrance(state, player))
|
|
for e in multiworld.get_region(Stages.MA2, player).entrances:
|
|
set_rule(e, lambda state: mataan_smoke_wall(state, player))
|
|
for e in multiworld.get_region(Stages.MA3, player).entrances:
|
|
set_rule(e, lambda state: mataan_deep_city(state, player, limit, glitched))
|
|
for e in multiworld.get_region(Stages.MAO, player).entrances:
|
|
set_rule(e, lambda state: mataan_oldhead(state, player))
|
|
for e in multiworld.get_region(Stages.MA4, player).entrances:
|
|
set_rule(e, lambda state: mataan_smoke_wall2(state, player, limit, glitched))
|
|
for e in multiworld.get_region(Stages.MA5, player).entrances:
|
|
set_rule(e, lambda state: mataan_deepest(state, player, limit, glitched))
|
|
|
|
# locations
|
|
# hideout
|
|
set_rule(multiworld.get_location("Hideout: BMX garage skateboard", player),
|
|
lambda state: bmx(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Hideout: Unlock phone app", player),
|
|
lambda state: current_chapter(state, player, 2))
|
|
set_rule(multiworld.get_location("Hideout: Vinyl joins the crew", player),
|
|
lambda state: current_chapter(state, player, 4))
|
|
set_rule(multiworld.get_location("Hideout: Solace joins the crew", player),
|
|
lambda state: current_chapter(state, player, 5))
|
|
|
|
# versum hill
|
|
set_rule(multiworld.get_location("Versum Hill: Wallrunning challenge reward", player),
|
|
lambda state: versum_hill_challenge1(state, player))
|
|
set_rule(multiworld.get_location("Versum Hill: Manual challenge reward", player),
|
|
lambda state: versum_hill_challenge2(state, player))
|
|
set_rule(multiworld.get_location("Versum Hill: Corner challenge reward", player),
|
|
lambda state: versum_hill_challenge3(state, player))
|
|
set_rule(multiworld.get_location("Versum Hill: BMX gate outfit", player),
|
|
lambda state: bmx(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Versum Hill: Glass floor skates", player),
|
|
lambda state: inline_skates(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Versum Hill: Basketball court shortcut CD", player),
|
|
lambda state: current_chapter(state, player, 2))
|
|
set_rule(multiworld.get_location("Versum Hill: Rave joins the crew", player),
|
|
lambda state: versum_hill_rave(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Versum Hill: Frank joins the crew", player),
|
|
lambda state: current_chapter(state, player, 2))
|
|
set_rule(multiworld.get_location("Versum Hill: Rietveld joins the crew", player),
|
|
lambda state: versum_hill_rietveld(state, player, limit, glitched))
|
|
if photos:
|
|
set_rule(multiworld.get_location("Versum Hill: Big Polo", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Versum Hill: Trash Polo", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Versum Hill: Fruit stand Polo", player),
|
|
lambda state: camera(state, player))
|
|
|
|
# millennium square
|
|
if photos:
|
|
set_rule(multiworld.get_location("Millennium Square: Half pipe Polo", player),
|
|
lambda state: camera(state, player))
|
|
|
|
# brink terminal
|
|
set_rule(multiworld.get_location("Brink Terminal: Upside grind challenge reward", player),
|
|
lambda state: brink_terminal_challenge1(state, player))
|
|
set_rule(multiworld.get_location("Brink Terminal: Manual challenge reward", player),
|
|
lambda state: brink_terminal_challenge2(state, player))
|
|
set_rule(multiworld.get_location("Brink Terminal: Score challenge reward", player),
|
|
lambda state: brink_terminal_challenge3(state, player))
|
|
set_rule(multiworld.get_location("Brink Terminal: BMX gate graffiti", player),
|
|
lambda state: bmx(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Brink Terminal: Mesh's skateboard", player),
|
|
lambda state: brink_terminal_mesh(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Brink Terminal: Rooftop glass CD", player),
|
|
lambda state: inline_skates(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Brink Terminal: Mesh joins the crew", player),
|
|
lambda state: brink_terminal_mesh(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Brink Terminal: Eclipse joins the crew", player),
|
|
lambda state: current_chapter(state, player, 3))
|
|
if photos:
|
|
set_rule(multiworld.get_location("Brink Terminal: Behind glass Polo", player),
|
|
lambda state: camera(state, player))
|
|
|
|
# millennium mall
|
|
set_rule(multiworld.get_location("Millennium Mall: Glass cylinder CD", player),
|
|
lambda state: inline_skates(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Millennium Mall: Trick challenge reward", player),
|
|
lambda state: millennium_mall_challenge1(state, player))
|
|
set_rule(multiworld.get_location("Millennium Mall: Slide challenge reward", player),
|
|
lambda state: millennium_mall_challenge2(state, player))
|
|
set_rule(multiworld.get_location("Millennium Mall: Fish challenge reward", player),
|
|
lambda state: millennium_mall_challenge3(state, player))
|
|
set_rule(multiworld.get_location("Millennium Mall: Score challenge reward", player),
|
|
lambda state: millennium_mall_challenge4(state, player))
|
|
set_rule(multiworld.get_location("Millennium Mall: Atrium BMX gate BMX", player),
|
|
lambda state: bmx(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Millennium Mall: Shine joins the crew", player),
|
|
lambda state: current_chapter(state, player, 4))
|
|
set_rule(multiworld.get_location("Millennium Mall: DOT.EXE joins the crew", player),
|
|
lambda state: current_chapter(state, player, 4))
|
|
|
|
# pyramid island
|
|
set_rule(multiworld.get_location("Pyramid Island: BMX gate BMX", player),
|
|
lambda state: bmx(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Pyramid Island: Score challenge reward", player),
|
|
lambda state: pyramid_island_challenge1(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Score challenge 2 reward", player),
|
|
lambda state: pyramid_island_challenge2(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Quarter pipe challenge reward", player),
|
|
lambda state: pyramid_island_challenge3(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Shortcut glass CD", player),
|
|
lambda state: inline_skates(state, player, movestyle))
|
|
set_rule(multiworld.get_location("Pyramid Island: Maze outfit", player),
|
|
lambda state: skateboard(state, player, movestyle))
|
|
if not glitched:
|
|
add_rule(multiworld.get_location("Pyramid Island: Rise joins the crew", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Devil Theory joins the crew", player),
|
|
lambda state: current_chapter(state, player, 5))
|
|
if photos:
|
|
set_rule(multiworld.get_location("Pyramid Island: Polo pile 1", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Polo pile 2", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Polo pile 3", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Polo pile 4", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Maze glass Polo", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Maze classroom Polo", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Maze vent Polo", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Big maze Polo", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Maze desk Polo", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Pyramid Island: Maze forklift Polo", player),
|
|
lambda state: camera(state, player))
|
|
|
|
# mataan
|
|
set_rule(multiworld.get_location("Mataan: Race challenge reward", player),
|
|
lambda state: mataan_challenge1(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Mataan: Wallrunning challenge reward", player),
|
|
lambda state: mataan_challenge2(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Mataan: Score challenge reward", player),
|
|
lambda state: mataan_challenge3(state, player))
|
|
if photos:
|
|
set_rule(multiworld.get_location("Mataan: Trash Polo", player),
|
|
lambda state: camera(state, player))
|
|
set_rule(multiworld.get_location("Mataan: Shopping Polo", player),
|
|
lambda state: camera(state, player))
|
|
|
|
# events
|
|
set_rule(multiworld.get_location("Versum Hill: Complete Chapter 1", player),
|
|
lambda state: versum_hill_crew_battle(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Brink Terminal: Complete Chapter 2", player),
|
|
lambda state: brink_terminal_crew_battle(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Millennium Mall: Complete Chapter 3", player),
|
|
lambda state: millennium_mall_crew_battle(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Pyramid Island: Complete Chapter 4", player),
|
|
lambda state: pyramid_island_crew_battle(state, player, limit, glitched))
|
|
set_rule(multiworld.get_location("Defeat Faux", player),
|
|
lambda state: mataan_faux(state, player, limit, glitched))
|
|
|
|
if extra:
|
|
add_rule(multiworld.get_location("Defeat Faux", player),
|
|
lambda state: rep(state, player, 1000))
|
|
|
|
# graffiti spots
|
|
spots: int = 0
|
|
while spots < 385:
|
|
spots += 5
|
|
set_rule(multiworld.get_location(f"Tagged {spots} Graffiti Spots", player),
|
|
lambda state, spot_count=spots: graffiti_spots(state, player, movestyle, limit, glitched, spot_count))
|
|
|
|
set_rule(multiworld.get_location("Tagged 389 Graffiti Spots", player),
|
|
lambda state: graffiti_spots(state, player, movestyle, limit, glitched, 389))
|