morgan/Grinch-AP
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Files
ecc3094c70b3ee1f3e18d9299c03198564ec261a
Grinch-AP/worlds/blasphemous/Rules.py
Trevor L 54a7bb5664 Blasphemous: Total overhaul (#3355) 
* Blasphemous: WIP overhaul

* Entrance rule mistake

* stuff

* Getting closer

* Real?? Maybe??

* Don't fail me now 🙏

* Add starting location tests

* More tests (it still doesn't work actually 😔)

* REAL

* Add unreachable regions to test_reachability.py

* PR ready

- Remove unused functions from init
- Use group exclusive functions in rules
- Style changes

* Bump required client version

* Clean up unused imports

* Change slot data

* Review fixes

- Prevent strength calculations from including excess items
- Add new lines to ends of files
- Fix missed deprecated option and random usage in init

* Update option docstrings, add groups

* Add preprocessor files

* Update option docstrings again actually

* Update player strength calculation

* Rename group methods

* Fix missing logic for RESCUED_CHERUB_06

* Register indirect conditions

* Register indirect conditions (part 2)

* Update extracted logic, change slot data key

* Add region to excluded list

* A capital letter

* Use camelCase keys in preprocessor

* Write some of new setup guide

* Remove indents before list points

* Change locationinfo to list of dictonaries

* Finish docs, update extractor config and data

* Mark region_data.py as generated

* Suggested changes

* More suggested changes

* Suggested changes again

- Use OptionError
- Create list of disabled locations before looping
- Check if options are equal to str instead of int
- Clean up start location override
- Reword some of setup guide
- Organize location list
- Remove unnecessary escaped quotes from option docstrings
- Add world type to test base

* C# moment

* Requested changes

* Update .gitattributes

---------

Co-authored-by: NewSoupVi <57900059+NewSoupVi@users.noreply.github.com>
2024-08-21 01:18:28 +02:00

1389 lines
54 KiB
Python
Raw Blame History

from typing import Dict, List, Tuple, Any, Callable, TYPE_CHECKING
from BaseClasses import CollectionState
if TYPE_CHECKING:
from . import BlasphemousWorld
else:
BlasphemousWorld = object
class BlasRules:
player: int
world: BlasphemousWorld
string_rules: Dict[str, Callable[[CollectionState], bool]]
def __init__(self, world: "BlasphemousWorld") -> None:
self.player = world.player
self.world = world
self.multiworld = world.multiworld
self.indirect_conditions: List[Tuple[str, str]] = []
# BrandenEK/Blasphemous.Randomizer/ItemRando/BlasphemousInventory.cs
self.string_rules = {
# Visibility flags
"DoubleJump": lambda state: bool(self.world.options.purified_hand),
"NormalLogic": lambda state: self.world.options.difficulty >= 1,
"NormalLogicAndDoubleJump": lambda state: self.world.options.difficulty >= 1 \
and bool(self.world.options.purified_hand),
"HardLogic": lambda state: self.world.options.difficulty >= 2,
"HardLogicAndDoubleJump": lambda state: self.world.options.difficulty >= 2 \
and bool(self.world.options.purified_hand),
"EnemySkips": self.enemy_skips_allowed,
"EnemySkipsAndDoubleJump": lambda state: self.enemy_skips_allowed(state) \
and bool(self.world.options.purified_hand),
# Relics
"blood": self.blood,
# skip "root"
"linen": self.linen,
"nail": self.nail,
"shroud": self.shroud,
# skip "lung"
# Keys
"bronzeKey": self.bronze_key,
"silverKey": self.silver_key,
"goldKey": self.gold_key,
"peaksKey": self.peaks_key,
"elderKey": self.elder_key,
"woodKey": self.wood_key,
# Collections
"cherubs20": lambda state: self.cherubs(state) >= 20,
"cherubs38": lambda state: self.cherubs(state) >= 38,
"bones4": lambda state: self.bones(state) >= 4,
"bones8": lambda state: self.bones(state) >= 8,
"bones12": lambda state: self.bones(state) >= 12,
"bones16": lambda state: self.bones(state) >= 16,
"bones20": lambda state: self.bones(state) >= 20,
"bones24": lambda state: self.bones(state) >= 24,
"bones28": lambda state: self.bones(state) >= 28,
"bones30": lambda state: self.bones(state) >= 30,
"bones32": lambda state: self.bones(state) >= 32,
"bones36": lambda state: self.bones(state) >= 36,
"bones40": lambda state: self.bones(state) >= 40,
"bones44": lambda state: self.bones(state) >= 44,
"tears0": lambda state: True,
# Special items
"dash": self.dash,
"wallClimb": self.wall_climb,
# skip "airImpulse"
"boots": self.boots,
"doubleJump": self.double_jump,
# Speed boosts
"wheel": self.wheel,
# skip "dawnHeart"
# Health boosts
# skip "flasks"
# skip "quicksilver"
# Puzzles
"redWax1": lambda state: self.red_wax(state) >= 1,
"redWax3": lambda state: self.red_wax(state) >= 3,
"blueWax1": lambda state: self.blue_wax(state) >= 1,
"blueWax3": lambda state: self.blue_wax(state) >= 3,
"chalice": self.chalice,
# Cherubs
"debla": self.debla,
"lorquiana": self.lorquiana,
"zarabanda": self.zarabanda,
"taranto": self.taranto,
"verdiales": self.verdiales,
"cante": self.cante,
"cantina": self.cantina,
"aubade": self.aubade,
"tirana": self.tirana,
"ruby": self.ruby,
"tiento": self.tiento,
# skip "anyPrayer"
"pillar": self.pillar,
# Stats
# skip "healthLevel"
# skip "fervourLevel"
# skip "swordLevel"
# Skills
# skip "combo"
# skip "charged"
# skip "ranged"
# skip "dive"
# skip "lunge"
"chargeBeam": self.charge_beam,
"rangedAttack": lambda state: self.ranged(state) > 0,
# Main quest
"holyWounds3": lambda state: self.holy_wounds(state) >= 3,
"masks1": lambda state: self.masks(state) >= 1,
"masks2": lambda state: self.masks(state) >= 2,
"masks3": lambda state: self.masks(state) >= 3,
"guiltBead": self.guilt_bead,
# LOTL quest
"cloth": self.cloth,
"hand": self.hand,
"hatchedEgg": self.hatched_egg,
# Tirso quest
"herbs1": lambda state: self.herbs(state) >= 1,
"herbs2": lambda state: self.herbs(state) >= 2,
"herbs3": lambda state: self.herbs(state) >= 3,
"herbs4": lambda state: self.herbs(state) >= 4,
"herbs5": lambda state: self.herbs(state) >= 5,
"herbs6": lambda state: self.herbs(state) >= 6,
# Tentudia quest
"tentudiaRemains1": lambda state: self.tentudia_remains(state) >= 1,
"tentudiaRemains2": lambda state: self.tentudia_remains(state) >= 2,
"tentudiaRemains3": lambda state: self.tentudia_remains(state) >= 3,
# Gemino quest
"emptyThimble": self.empty_thimble,
"fullThimble": self.full_thimble,
"driedFlowers": self.dried_flowers,
# Altasgracias quest
"ceremonyItems3": lambda state: self.ceremony_items(state) >= 3,
"egg": self.egg,
# Redento quest
# skip "limestones", not actually used
# skip "knots", not actually used
# Cleofas quest
"marksOfRefuge3": lambda state: self.marks_of_refuge(state) >= 3,
"cord": self.cord,
# Crisanta quest
"scapular": self.scapular,
"trueHeart": self.true_heart,
"traitorEyes2": lambda state: self.traitor_eyes(state) >= 2,
# Jibrael quest
"bell": self.bell,
"verses4": lambda state: self.verses(state) >= 4,
# Movement tech
"canAirStall": self.can_air_stall,
"canDawnJump": self.can_dawn_jump,
"canWaterJump": self.can_water_jump,
# Breakable tech
"canBreakHoles": self.can_break_holes,
"canDiveLaser": self.can_dive_laser,
# Root tech
"canWalkOnRoot": self.can_walk_on_root,
"canClimbOnRoot": self.can_climb_on_root,
# Lung tech
"canSurvivePoison1": self.can_survive_poison_1,
"canSurvivePoison2": self.can_survive_poison_2,
"canSurvivePoison3": self.can_survive_poison_3,
# Enemy tech
"canEnemyBounce": self.can_enemy_bounce,
"canEnemyUpslash": self.can_enemy_upslash,
# Reaching rooms
"guiltRooms1": lambda state: self.guilt_rooms(state) >= 1,
"guiltRooms2": lambda state: self.guilt_rooms(state) >= 2,
"guiltRooms3": lambda state: self.guilt_rooms(state) >= 3,
"guiltRooms4": lambda state: self.guilt_rooms(state) >= 4,
"guiltRooms5": lambda state: self.guilt_rooms(state) >= 5,
"guiltRooms6": lambda state: self.guilt_rooms(state) >= 6,
"guiltRooms7": lambda state: self.guilt_rooms(state) >= 7,
"swordRooms1": lambda state: self.sword_rooms(state) >= 1,
"swordRooms2": lambda state: self.sword_rooms(state) >= 2,
"swordRooms3": lambda state: self.sword_rooms(state) >= 3,
"swordRooms4": lambda state: self.sword_rooms(state) >= 4,
"swordRooms5": lambda state: self.sword_rooms(state) >= 5,
"swordRooms6": lambda state: self.sword_rooms(state) >= 6,
"swordRooms7": lambda state: self.sword_rooms(state) >= 7,
"redentoRooms2": lambda state: self.redento_rooms(state) >= 2,
"redentoRooms3": lambda state: self.redento_rooms(state) >= 3,
"redentoRooms4": lambda state: self.redento_rooms(state) >= 4,
"redentoRooms5": lambda state: self.redento_rooms(state) >= 5,
"miriamRooms5": lambda state: self.miriam_rooms(state) >= 5,
"amanecidaRooms1": lambda state: self.amanecida_rooms(state) >= 1,
"amanecidaRooms2": lambda state: self.amanecida_rooms(state) >= 2,
"amanecidaRooms3": lambda state: self.amanecida_rooms(state) >= 3,
"amanecidaRooms4": lambda state: self.amanecida_rooms(state) >= 4,
"chaliceRooms3": lambda state: self.chalice_rooms(state) >= 3,
# Crossing gaps
"canCrossGap1": self.can_cross_gap_1,
"canCrossGap2": self.can_cross_gap_2,
"canCrossGap3": self.can_cross_gap_3,
"canCrossGap4": self.can_cross_gap_4,
"canCrossGap5": self.can_cross_gap_5,
"canCrossGap6": self.can_cross_gap_6,
"canCrossGap7": self.can_cross_gap_7,
"canCrossGap8": self.can_cross_gap_8,
"canCrossGap9": self.can_cross_gap_9,
"canCrossGap10": self.can_cross_gap_10,
"canCrossGap11": self.can_cross_gap_11,
# Events in different scenes
"openedDCGateW": self.opened_dc_gate_w,
"openedDCGateE": self.opened_dc_gate_e,
"openedDCLadder": self.opened_dc_ladder,
"openedWOTWCave": self.opened_wotw_cave,
"rodeGotPElevator": self.rode_gotp_elevator,
"openedConventLadder": self.opened_convent_ladder,
"brokeJondoBellW": self.broke_jondo_bell_w,
"brokeJondoBellE": self.broke_jondo_bell_e,
"openedMoMLadder": self.opened_mom_ladder,
"openedTSCGate": self.opened_tsc_gate,
"openedARLadder": self.opened_ar_ladder,
"brokeBotTCStatue": self.broke_bottc_statue,
"openedWotHPGate": self.opened_wothp_gate,
"openedBotSSLadder": self.opened_botss_ladder,
# Special skips
"upwarpSkipsAllowed": self.upwarp_skips_allowed,
"mourningSkipAllowed": self.mourning_skip_allowed,
"enemySkipsAllowed": self.enemy_skips_allowed,
"obscureSkipsAllowed": self.obscure_skips_allowed,
"preciseSkipsAllowed": self.precise_skips_allowed,
# Bosses
"canBeatBrotherhoodBoss": self.can_beat_brotherhood_boss,
"canBeatMercyBoss": self.can_beat_mercy_boss,
"canBeatConventBoss": self.can_beat_convent_boss,
"canBeatGrievanceBoss": self.can_beat_grievance_boss,
"canBeatBridgeBoss": self.can_beat_bridge_boss,
"canBeatMothersBoss": self.can_beat_mothers_boss,
"canBeatCanvasesBoss": self.can_beat_canvases_boss,
"canBeatPrisonBoss": self.can_beat_prison_boss,
"canBeatRooftopsBoss": self.can_beat_rooftops_boss,
"canBeatOssuaryBoss": self.can_beat_ossuary_boss,
"canBeatMourningBoss": self.can_beat_mourning_boss,
"canBeatGraveyardBoss": self.can_beat_graveyard_boss,
"canBeatJondoBoss": self.can_beat_jondo_boss,
"canBeatPatioBoss": self.can_beat_patio_boss,
"canBeatWallBoss": self.can_beat_wall_boss,
"canBeatHallBoss": self.can_beat_hall_boss,
"canBeatPerpetua": self.can_beat_perpetua,
"canBeatLegionary": self.can_beat_legionary
}
boss_strength_indirect_regions: List[str] = [
# flasks
"D01Z05S05[SW]",
"D02Z02S04[W]",
"D03Z02S08[W]",
"D03Z03S04[SW]",
"D04Z02S13[W]",
"D05Z01S08[NW]",
"D20Z01S07[NE]",
# quicksilver
"D01Z05S01[W]"
]
guilt_indirect_regions: List[str] = [
"D01Z04S01[NE]",
"D02Z02S11[W]",
"D03Z03S02[NE]",
"D04Z02S02[SE]",
"D05Z01S05[NE]",
"D09Z01S05[W]",
"D17Z01S04[W]"
]
sword_indirect_regions: List[str] = [
"D01Z02S07[E]",
"D01Z02S02[SW]",
"D20Z01S04[E]",
"D01Z05S23[W]",
"D02Z03S02[NE]",
"D04Z02S21[NE]",
"D05Z01S21[NW]",
"D06Z01S15[NE]",
"D17Z01S07[SW]"
]
redento_indirect_regions: List[str] = [
"D03Z01S04[E]",
"D03Z02S10[N]",
"D17Z01S05[S]",
"D17BZ02S01[FrontR]",
"D01Z03S04[E]",
"D08Z01S01[W]",
"D04Z01S03[E]",
"D04Z02S01[W]",
"D06Z01S18[-Cherubs]",
"D04Z02S08[E]",
"D04BZ02S01[Redento]",
"D17Z01S07[NW]"
]
miriam_indirect_regions: List[str] = [
"D02Z03S07[NWW]",
"D03Z03S07[NW]",
"D04Z04S01[E]",
"D05Z01S06[W]",
"D06Z01S17[E]"
]
chalice_indirect_regions: List[str] = [
"D03Z01S02[E]",
"D01Z05S02[W]",
"D20Z01S03[N]",
"D05Z01S11[SE]",
"D05Z02S02[NW]",
"D09Z01S09[E]",
"D09Z01S10[W]",
"D09Z01S08[SE]",
"D09Z01S02[SW]"
]
self.indirect_regions: Dict[str, List[str]] = {
"openedDCGateW": ["D20Z01S04[E]",
"D01Z05S23[W]"],
"openedDCGateE": ["D01Z05S10[SE]",
"D01Z04S09[W]"],
"openedDCLadder": ["D01Z05S25[NE]",
"D01Z05S02[S]"],
"openedWOTWCave": ["D02Z01S01[SW]",
"D02Z01S08[E]",
"D02Z01S02[]"],
"rodeGotPElevator": ["D02Z03S14[E]",
"D02Z02S13[W]",
"D02Z02S06[E]",
"D02Z02S12[W]",
"D02Z02S08[W]"],
"openedConventLadder": ["D02Z03S02[N]",
"D02Z03S15[E]",
"D02Z03S19[E]",
"D02Z03S10[W]",
"D02Z03S22[W]"],
"brokeJondoBellW": ["D03Z02S08[N]",
"D03Z02S12[E]",
"D03Z02S10[S]",
"D03Z02S10[-Cherubs]"],
"brokeJondoBellE": ["D03Z02S04[NE]",
"D03Z02S11[W]",
"D03Z02S03[E]"],
"openedMoMLadder": ["D04Z02S11[E]",
"D04Z02S09[W]",
"D06Z01S23[S]",
"D04Z02S04[N]"],
"openedTSCGate": ["D05Z02S06[SE]",
"D05Z01S21[-Cherubs]"],
"openedARLadder": ["D06Z01S22[Sword]",
"D06Z01S20[W]",
"D04Z02S06[N]",
"D06Z01S01[-Cherubs]"],
"brokeBotTCStatue": ["D08Z03S03[W]",
"D08Z02S03[W]"],
"openedWotHPGate": ["D09Z01S13[E]",
"D09Z01S03[W]",
"D09Z01S08[W]"],
"openedBotSSLadder": ["D17Z01S05[S]",
"D17BZ02S01[FrontR]"],
"canBeatBrotherhoodBoss": [*boss_strength_indirect_regions,
"D17Z01S05[E]",
"D17Z01S03[W]"],
"canBeatMercyBoss": [*boss_strength_indirect_regions,
"D01Z04S19[E]",
"D01Z04S12[W]"],
"canBeatConventBoss": [*boss_strength_indirect_regions,
"D02Z03S09[E]",
"D02Z03S21[W]"],
"canBeatGrievanceBoss": [*boss_strength_indirect_regions,
"D03Z03S11[E]",
"D03Z03S16[W]"],
"canBeatBridgeBoss": [*boss_strength_indirect_regions,
"D01Z03S06[E]",
"D08Z02S01[W]"],
"canBeatMothersBoss": [*boss_strength_indirect_regions,
"D04Z02S15[E]",
"D04Z02S21[W]"],
"canBeatCanvasesBoss": [*boss_strength_indirect_regions,
"D05Z02S06[NE]",
"D05Z01S21[SW]"],
"canBeatPrisonBoss": [*boss_strength_indirect_regions,
"D09Z01S05[SE]",
"D09Z01S08[S]"],
"canBeatRooftopsBoss": [*boss_strength_indirect_regions,
"D06Z01S19[E]",
"D07Z01S01[W]"],
"canBeatOssuaryBoss": [*boss_strength_indirect_regions,
"D01BZ06S01[E]"],
"canBeatMourningBoss": [*boss_strength_indirect_regions,
"D20Z02S07[W]"],
"canBeatGraveyardBoss": [*boss_strength_indirect_regions,
"D01Z06S01[Santos]",
"D02Z03S18[NW]",
"D02Z02S03[NE]"],
"canBeatJondoBoss": [*boss_strength_indirect_regions,
"D01Z06S01[Santos]",
"D20Z01S06[NE]",
"D20Z01S04[W]",
"D03Z01S04[E]",
"D03Z02S10[N]"],
"canBeatPatioBoss": [*boss_strength_indirect_regions,
"D01Z06S01[Santos]",
"D06Z01S02[W]",
"D04Z01S03[E]",
"D04Z01S01[W]",
"D06Z01S18[-Cherubs]"],
"canBeatWallBoss": [*boss_strength_indirect_regions,
"D01Z06S01[Santos]",
"D09Z01S09[Cell24]",
"D09Z01S11[E]",
"D06Z01S13[W]"],
"canBeatHallBoss": [*boss_strength_indirect_regions,
"D08Z01S02[NE]",
"D08Z03S02[NW]"],
"canBeatPerpetua": boss_strength_indirect_regions,
"canBeatLegionary": boss_strength_indirect_regions,
"guiltRooms1": guilt_indirect_regions,
"guiltRooms2": guilt_indirect_regions,
"guiltRooms3": guilt_indirect_regions,
"guiltRooms4": guilt_indirect_regions,
"guiltRooms5": guilt_indirect_regions,
"guiltRooms6": guilt_indirect_regions,
"guiltRooms7": guilt_indirect_regions,
"swordRooms1": sword_indirect_regions,
"swordRooms2": sword_indirect_regions,
"swordRooms3": sword_indirect_regions,
"swordRooms4": sword_indirect_regions,
"swordRooms5": sword_indirect_regions,
"swordRooms6": sword_indirect_regions,
"swordRooms7": sword_indirect_regions,
"redentoRooms2": redento_indirect_regions,
"redentoRooms3": redento_indirect_regions,
"redentoRooms4": redento_indirect_regions,
"redentoRooms5": redento_indirect_regions,
"miriamRooms5": miriam_indirect_regions,
"chaliceRooms3": chalice_indirect_regions
}
self.indirect_regions["amanecidaRooms1"] = [*self.indirect_regions["canBeatGraveyardBoss"],
*self.indirect_regions["canBeatJondoBoss"],
*self.indirect_regions["canBeatPatioBoss"],
*self.indirect_regions["canBeatWallBoss"]]
self.indirect_regions["amanecidaRooms2"] = [*self.indirect_regions["canBeatGraveyardBoss"],
*self.indirect_regions["canBeatJondoBoss"],
*self.indirect_regions["canBeatPatioBoss"],
*self.indirect_regions["canBeatWallBoss"]]
self.indirect_regions["amanecidaRooms3"] = [*self.indirect_regions["canBeatGraveyardBoss"],
*self.indirect_regions["canBeatJondoBoss"],
*self.indirect_regions["canBeatPatioBoss"],
*self.indirect_regions["canBeatWallBoss"]]
self.indirect_regions["amanecidaRooms4"] = [*self.indirect_regions["canBeatGraveyardBoss"],
*self.indirect_regions["canBeatJondoBoss"],
*self.indirect_regions["canBeatPatioBoss"],
*self.indirect_regions["canBeatWallBoss"]]
def req_is_region(self, string: str) -> bool:
return (string[0] == "D" and string[3] == "Z" and string[6] == "S")\
or (string[0] == "D" and string[3] == "B" and string[4] == "Z" and string[7] == "S")
def load_rule(self, obj_is_region: bool, name: str, obj: Dict[str, Any]) -> Callable[[CollectionState], bool]:
clauses = []
for clause in obj["logic"]:
reqs = []
for req in clause["item_requirements"]:
if self.req_is_region(req):
if obj_is_region:
# add to indirect conditions if object and requirement are doors
self.indirect_conditions.append((req, f"{name} -> {obj['target']}"))
reqs.append(lambda state, req=req: state.can_reach_region(req, self.player))
else:
if obj_is_region and req in self.indirect_regions:
# add to indirect conditions if object is door and requirement has list of regions
for region in self.indirect_regions[req]:
self.indirect_conditions.append((region, f"{name} -> {obj['target']}"))
reqs.append(self.string_rules[req])
if len(reqs) == 1:
clauses.append(reqs[0])
else:
clauses.append(lambda state, reqs=reqs: all(req(state) for req in reqs))
if not clauses:
return lambda state: True
elif len(clauses) == 1:
return clauses[0]
else:
return lambda state: any(clause(state) for clause in clauses)
# Relics
def blood(self, state: CollectionState) -> bool:
return state.has("Blood Perpetuated in Sand", self.player)
def root(self, state: CollectionState) -> bool:
return state.has("Three Gnarled Tongues", self.player)
def linen(self, state: CollectionState) -> bool:
return state.has("Linen of Golden Thread", self.player)
def nail(self, state: CollectionState) -> bool:
return state.has("Nail Uprooted from Dirt", self.player)
def shroud(self, state: CollectionState) -> bool:
return state.has("Shroud of Dreamt Sins", self.player)
def lung(self, state: CollectionState) -> bool:
return state.has("Silvered Lung of Dolphos", self.player)
# Keys
def bronze_key(self, state: CollectionState) -> bool:
return state.has("Key of the Secular", self.player)
def silver_key(self, state: CollectionState) -> bool:
return state.has("Key of the Scribe", self.player)
def gold_key(self, state: CollectionState) -> bool:
return state.has("Key of the Inquisitor", self.player)
def peaks_key(self, state: CollectionState) -> bool:
return state.has("Key of the High Peaks", self.player)
def elder_key(self, state: CollectionState) -> bool:
return state.has("Key to the Chamber of the Eldest Brother", self.player)
def wood_key(self, state: CollectionState) -> bool:
return state.has("Key Grown from Twisted Wood", self.player)
# Collections
def cherubs(self, state: CollectionState) -> int:
return state.count("Child of Moonlight", self.player)
def bones(self, state: CollectionState) -> int:
return state.count_group_unique("bones", self.player)
# def tears():
# Special items
def dash(self, state: CollectionState) -> bool:
return state.has("Dash Ability", self.player)
def wall_climb(self, state: CollectionState) -> bool:
return state.has("Wall Climb Ability", self.player)
#def air_impulse():
def boots(self, state: CollectionState) -> bool:
return state.has("Boots of Pleading", self.player)
def double_jump(self, state: CollectionState) -> bool:
return state.has("Purified Hand of the Nun", self.player)
# Speed boosts
def wheel(self, state: CollectionState) -> bool:
return state.has("The Young Mason's Wheel", self.player)
def dawn_heart(self, state: CollectionState) -> bool:
return state.has("Brilliant Heart of Dawn", self.player)
# Health boosts
def flasks(self, state: CollectionState) -> int:
doors = {
"D01Z05S05[SW]",
"D02Z02S04[W]",
"D03Z02S08[W]",
"D03Z03S04[SW]",
"D04Z02S13[W]",
"D05Z01S08[NW]",
"D20Z01S07[NE]"
}
return state.count("Empty Bile Vessel", self.player) \
if sum(state.can_reach_region(door, self.player) for door in doors) >= 1 else 0
def quicksilver(self, state: CollectionState) -> int:
return state.count("Quicksilver", self.player) if state.can_reach_region("D01Z05S01[W]", self.player) else 0
# Puzzles
def red_wax(self, state: CollectionState) -> int:
return state.count("Bead of Red Wax", self.player)
def blue_wax(self, state: CollectionState) -> int:
return state.count("Bead of Blue Wax", self.player)
def chalice(self, state: CollectionState) -> bool:
return state.has("Chalice of Inverted Verses", self.player)
# Cherubs
def debla(self, state: CollectionState) -> bool:
return state.has("Debla of the Lights", self.player)
def lorquiana(self, state: CollectionState) -> bool:
return state.has("Lorquiana", self.player)
def zarabanda(self, state: CollectionState) -> bool:
return state.has("Zarabanda of the Safe Haven", self.player)
def taranto(self, state: CollectionState) -> bool:
return state.has("Taranto to my Sister", self.player)
def verdiales(self, state: CollectionState) -> bool:
return state.has("Verdiales of the Forsaken Hamlet", self.player)
def cante(self, state: CollectionState) -> bool:
return state.has("Cante Jondo of the Three Sisters", self.player)
def cantina(self, state: CollectionState) -> bool:
return state.has("Cantina of the Blue Rose", self.player)
def aubade(self, state: CollectionState) -> bool:
return (
state.has("Aubade of the Nameless Guardian", self.player)
and self.total_fervour(state) >= 90
)
def tirana(self, state: CollectionState) -> bool:
return (
state.has("Tirana of the Celestial Bastion", self.player)
and self.total_fervour(state) >= 90
)
def ruby(self, state: CollectionState) -> bool:
return state.has("Cloistered Ruby", self.player)
def tiento(self, state: CollectionState) -> bool:
return state.has("Tiento to my Sister", self.player)
def any_small_prayer(self, state: CollectionState) -> bool:
return (
self.debla(state)
or self.lorquiana(state)
or self.zarabanda(state)
or self.taranto(state)
or self.verdiales(state)
or self.cante(state)
or self.cantina(state)
or self.tiento(state)
or state.has_any({
"Campanillero to the Sons of the Aurora",
"Mirabras of the Return to Port",
"Romance to the Crimson Mist",
"Saeta Dolorosa",
"Seguiriya to your Eyes like Stars",
"Verdiales of the Forsaken Hamlet",
"Zambra to the Resplendent Crown"
}, self.player)
)
def pillar(self, state: CollectionState) -> bool:
return (
self.debla(state)
or self.taranto(state)
or self.ruby(state)
)
def can_use_any_prayer(self, state: CollectionState) -> bool:
return (
self.any_small_prayer(state)
or self.tirana(state)
or self.aubade(state)
)
# Stats
def total_fervour(self, state: CollectionState) -> int:
return (
60
+ (20 * min(6, state.count("Fervour Upgrade", self.player)))
+ (10 * min(3, state.count("Bead of Blue Wax", self.player)))
)
# Skills
def combo(self, state: CollectionState) -> int:
return state.count("Combo Skill", self.player)
def charged(self, state: CollectionState) -> int:
return state.count("Charged Skill", self.player)
def ranged(self, state: CollectionState) -> int:
return state.count("Ranged Skill", self.player)
def dive(self, state: CollectionState) -> int:
return state.count("Dive Skill", self.player)
def lunge(self, state: CollectionState) -> int:
return state.count("Lunge Skill", self.player)
def charge_beam(self, state: CollectionState) -> bool:
return self.charged(state) >= 3
# Main quest
def holy_wounds(self, state: CollectionState) -> int:
return state.count_group_unique("wounds", self.player)
def masks(self, state: CollectionState) -> int:
return state.count_group_unique("masks", self.player)
def guilt_bead(self, state: CollectionState) -> bool:
return state.has("Weight of True Guilt", self.player)
# LOTL quest
def cloth(self, state: CollectionState) -> bool:
return state.has("Linen Cloth", self.player)
def hand(self, state: CollectionState) -> bool:
return state.has("Severed Hand", self.player)
def hatched_egg(self, state: CollectionState) -> bool:
return state.has("Hatched Egg of Deformity", self.player)
# Tirso quest
def herbs(self, state: CollectionState) -> int:
return state.count_group_unique("tirso", self.player)
# Tentudia quest
def tentudia_remains(self, state: CollectionState) -> int:
return state.count_group_unique("tentudia", self.player)
# Gemino quest
def empty_thimble(self, state: CollectionState) -> bool:
return state.has("Empty Golden Thimble", self.player)
def full_thimble(self, state: CollectionState) -> bool:
return state.has("Golden Thimble Filled with Burning Oil", self.player)
def dried_flowers(self, state: CollectionState) -> bool:
return state.has("Dried Flowers bathed in Tears", self.player)
# Altasgracias quest
def ceremony_items(self, state: CollectionState) -> int:
return state.count_group_unique("egg", self.player)
def egg(self, state: CollectionState) -> bool:
return state.has("Egg of Deformity", self.player)
# Redento quest
def limestones(self, state: CollectionState) -> int:
return state.count_group_unique("toe", self.player)
def knots(self, state: CollectionState) -> int:
return state.count("Knot of Rosary Rope", self.player) if state.can_reach_region("D17Z01S07[NW]", self.player)\
else 0
# Cleofas quest
def marks_of_refuge(self, state: CollectionState) -> int:
return state.count_group_unique("marks", self.player)
def cord(self, state: CollectionState) -> bool:
return state.has("Cord of the True Burying", self.player)
# Crisanta quest
def scapular(self, state: CollectionState) -> bool:
return state.has("Incomplete Scapular", self.player)
def true_heart(self, state: CollectionState) -> bool:
return state.has("Apodictic Heart of Mea Culpa", self.player)
def traitor_eyes(self, state: CollectionState) -> int:
return state.count_group_unique("eye", self.player)
# Jibrael quest
def bell(self, state: CollectionState) -> bool:
return state.has("Petrified Bell", self.player)
def verses(self, state: CollectionState) -> int:
return state.count("Verses Spun from Gold", self.player)
# Movement tech
def can_air_stall(self, state: CollectionState) -> bool:
return (
self.ranged(state) > 0
and self.world.options.difficulty >= 1
)
def can_dawn_jump(self, state: CollectionState) -> bool:
return (
self.dawn_heart(state)
and self.dash(state)
and self.world.options.difficulty >= 1
)
def can_water_jump(self, state: CollectionState) -> bool:
return (
self.nail(state)
or self.double_jump(state)
)
# Breakable tech
def can_break_holes(self, state: CollectionState) -> bool:
return (
self.charged(state) > 0
or self.dive(state) > 0
or self.lunge(state) >= 3 and self.dash(state)
or self.can_use_any_prayer(state)
)
def can_dive_laser(self, state: CollectionState) -> bool:
return (
self.dive(state) >= 3
and self.world.options.difficulty >= 2
)
# Root tech
def can_walk_on_root(self, state: CollectionState) -> bool:
return self.root(state)
def can_climb_on_root(self, state: CollectionState) -> bool:
return (
self.root(state)
and self.wall_climb(state)
)
# Lung tech
def can_survive_poison_1(self, state: CollectionState) -> bool:
return (
self.lung(state)
or self.world.options.difficulty >= 1
and self.tiento(state)
or self.world.options.difficulty >= 2
)
def can_survive_poison_2(self, state: CollectionState) -> bool:
return (
self.lung(state)
or self.world.options.difficulty >= 1
and self.tiento(state)
)
def can_survive_poison_3(self, state: CollectionState) -> bool:
return (
self.lung(state)
or self.world.options.difficulty >= 2
and self.tiento(state)
and self.total_fervour(state) >= 120
)
# Enemy tech
def can_enemy_bounce(self, state: CollectionState) -> bool:
return self.enemy_skips_allowed(state)
def can_enemy_upslash(self, state: CollectionState) -> bool:
return (
self.combo(state) >= 2
and self.enemy_skips_allowed(state)
)
# Crossing gaps
def can_cross_gap_1(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
or self.can_dawn_jump(state)
or self.wheel(state)
or self.can_air_stall(state)
)
def can_cross_gap_2(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
or self.can_dawn_jump(state)
or self.wheel(state)
)
def can_cross_gap_3(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
or self.can_dawn_jump(state)
or self.wheel(state)
and self.can_air_stall(state)
)
def can_cross_gap_4(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
or self.can_dawn_jump(state)
)
def can_cross_gap_5(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
or self.can_dawn_jump(state)
and self.can_air_stall(state)
)
def can_cross_gap_6(self, state: CollectionState) -> bool:
return self.double_jump(state)
def can_cross_gap_7(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
and (
self.can_dawn_jump(state)
or self.wheel(state)
or self.can_air_stall(state)
)
)
def can_cross_gap_8(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
and (
self.can_dawn_jump(state)
or self.wheel(state)
)
)
def can_cross_gap_9(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
and (
self.can_dawn_jump(state)
or self.wheel(state)
and self.can_air_stall(state)
)
)
def can_cross_gap_10(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
and self.can_dawn_jump(state)
)
def can_cross_gap_11(self, state: CollectionState) -> bool:
return (
self.double_jump(state)
and self.can_dawn_jump(state)
and self.can_air_stall(state)
)
# Events that trigger in different scenes
def opened_dc_gate_w(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D20Z01S04[E]", self.player)
or state.can_reach_region("D01Z05S23[W]", self.player)
)
def opened_dc_gate_e(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D01Z05S10[SE]", self.player)
or state.can_reach_region("D01Z04S09[W]", self.player)
)
def opened_dc_ladder(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D01Z05S25[NE]", self.player)
or state.can_reach_region("D01Z05S02[S]", self.player)
)
def opened_wotw_cave(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D02Z01S01[SW]", self.player)
or self.wall_climb(state)
and state.can_reach_region("D02Z01S08[E]", self.player)
or state.can_reach_region("D02Z01S02[]", self.player)
)
def rode_gotp_elevator(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D02Z03S14[E]", self.player)
or state.can_reach_region("D02Z02S13[W]", self.player)
or state.can_reach_region("D02Z02S06[E]", self.player)
or state.can_reach_region("D02Z02S12[W]", self.player)
or state.can_reach_region("D02Z02S08[W]", self.player)
)
def opened_convent_ladder(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D02Z03S02[N]", self.player)
or state.can_reach_region("D02Z03S15[E]", self.player)
or state.can_reach_region("D02Z03S19[E]", self.player)
or state.can_reach_region("D02Z03S10[W]", self.player)
or state.can_reach_region("D02Z03S22[W]", self.player)
)
def broke_jondo_bell_w(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D03Z02S08[N]", self.player)
or state.can_reach_region("D03Z02S12[E]", self.player)
and self.dash(state)
or state.can_reach_region("D03Z02S10[S]", self.player)
or state.can_reach_region("D03Z02S10[-Cherubs]", self.player)
)
def broke_jondo_bell_e(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D03Z02S04[NE]", self.player)
or state.can_reach_region("D03Z02S11[W]", self.player)
or state.can_reach_region("D03Z02S03[E]", self.player)
and (
self.can_cross_gap_5(state)
or self.can_enemy_bounce(state)
and self.can_cross_gap_3(state)
)
)
def opened_mom_ladder(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D04Z02S11[E]", self.player)
or state.can_reach_region("D04Z02S09[W]", self.player)
or state.can_reach_region("D06Z01S23[S]", self.player)
or state.can_reach_region("D04Z02S04[N]", self.player)
)
def opened_tsc_gate(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D05Z02S06[SE]", self.player)
or state.can_reach_region("D05Z01S21[-Cherubs]", self.player)
)
def opened_ar_ladder(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D06Z01S22[Sword]", self.player)
or state.can_reach_region("D06Z01S20[W]", self.player)
or state.can_reach_region("D04Z02S06[N]", self.player)
or state.can_reach_region("D06Z01S01[-Cherubs]", self.player)
)
def broke_bottc_statue(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D08Z03S03[W]", self.player)
or state.can_reach_region("D08Z02S03[W]", self.player)
)
def opened_wothp_gate(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D09Z01S13[E]", self.player)
or state.can_reach_region("D09Z01S03[W]", self.player)
or state.can_reach_region("D09Z01S08[W]", self.player)
)
def opened_botss_ladder(self, state: CollectionState) -> bool:
return (
state.can_reach_region("D17Z01S05[S]", self.player)
or state.can_reach_region("D17BZ02S01[FrontR]", self.player)
)
# Special skips
def upwarp_skips_allowed(self, state: CollectionState) -> bool:
return self.world.options.difficulty >= 2
def mourning_skip_allowed(self, state: CollectionState) -> bool:
return self.world.options.difficulty >= 2
def enemy_skips_allowed(self, state: CollectionState) -> bool:
return (
self.world.options.difficulty >= 2
and not self.world.options.enemy_randomizer
)
def obscure_skips_allowed(self, state: CollectionState) -> bool:
return self.world.options.difficulty >= 2
def precise_skips_allowed(self, state: CollectionState) -> bool:
return self.world.options.difficulty >= 2
# Bosses
def can_beat_brotherhood_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "warden")
and (
state.can_reach_region("D17Z01S05[E]", self.player)
or state.can_reach_region("D17Z01S03[W]", self.player)
)
)
def can_beat_mercy_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "ten-piedad")
and (
state.can_reach_region("D01Z04S19[E]", self.player)
or state.can_reach_region("D01Z04S12[W]", self.player)
)
)
def can_beat_convent_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "charred-visage")
and (
state.can_reach_region("D02Z03S09[E]", self.player)
or state.can_reach_region("D02Z03S21[W]", self.player)
)
)
def can_beat_grievance_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "tres-angustias")
and (
self.wall_climb(state)
or self.double_jump(state)
) and (
state.can_reach_region("D03Z03S11[E]", self.player)
or state.can_reach_region("D03Z03S16[W]", self.player)
)
)
def can_beat_bridge_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "esdras")
and (
state.can_reach_region("D01Z03S06[E]", self.player)
or state.can_reach_region("D08Z02S01[W]", self.player)
)
)
def can_beat_mothers_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "melquiades")
and (
state.can_reach_region("D04Z02S15[E]", self.player)
or state.can_reach_region("D04Z02S21[W]", self.player)
)
)
def can_beat_canvases_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "exposito")
and (
state.can_reach_region("D05Z02S06[NE]", self.player)
or state.can_reach_region("D05Z01S21[SW]", self.player)
)
)
def can_beat_prison_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "quirce")
and (
state.can_reach_region("D09Z01S05[SE]", self.player)
or state.can_reach_region("D09Z01S08[S]", self.player)
)
)
def can_beat_rooftops_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "crisanta")
and (
state.can_reach_region("D06Z01S19[E]", self.player)
or state.can_reach_region("D07Z01S01[W]", self.player)
)
)
def can_beat_ossuary_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "isidora")
and state.can_reach_region("D01BZ06S01[E]", self.player)
)
def can_beat_mourning_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "sierpes")
and state.can_reach_region("D20Z02S07[W]", self.player)
)
def can_beat_graveyard_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "amanecida")
and self.wall_climb(state)
and state.can_reach_region("D01Z06S01[Santos]", self.player)
and state.can_reach_region("D02Z03S18[NW]", self.player)
and state.can_reach_region("D02Z02S03[NE]", self.player)
)
def can_beat_jondo_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "amanecida")
and state.can_reach_region("D01Z06S01[Santos]", self.player)
and (
state.can_reach_region("D20Z01S06[NE]", self.player)
or state.can_reach_region("D20Z01S04[W]", self.player)
)
and (
state.can_reach_region("D03Z01S04[E]", self.player)
or state.can_reach_region("D03Z02S10[N]", self.player)
)
)
def can_beat_patio_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "amanecida")
and state.can_reach_region("D01Z06S01[Santos]", self.player)
and state.can_reach_region("D06Z01S02[W]", self.player)
and (
state.can_reach_region("D04Z01S03[E]", self.player)
or state.can_reach_region("D04Z01S01[W]", self.player)
or state.can_reach_region("D06Z01S18[-Cherubs]", self.player)
)
)
def can_beat_wall_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "amanecida")
and state.can_reach_region("D01Z06S01[Santos]", self.player)
and state.can_reach_region("D09Z01S09[Cell24]", self.player)
and (
state.can_reach_region("D09Z01S11[E]", self.player)
or state.can_reach_region("D06Z01S13[W]", self.player)
)
)
def can_beat_hall_boss(self, state: CollectionState) -> bool:
return (
self.has_boss_strength(state, "laudes")
and (
state.can_reach_region("D08Z01S02[NE]", self.player)
or state.can_reach_region("D08Z03S02[NW]", self.player)
)
)
def can_beat_perpetua(self, state: CollectionState) -> bool:
return self.has_boss_strength(state, "perpetua")
def can_beat_legionary(self, state: CollectionState) -> bool:
return self.has_boss_strength(state, "legionary")
def has_boss_strength(self, state: CollectionState, boss: str) -> bool:
life: int = state.count("Life Upgrade", self.player)
sword: int = state.count("Mea Culpa Upgrade", self.player)
fervour: int = state.count("Fervour Upgrade", self.player)
flasks: int = self.flasks(state)
quicksilver: int = self.quicksilver(state)
player_strength: float = (
min(6, life) * 0.25 / 6
+ min(7, sword) * 0.25 / 7
+ min(6, fervour) * 0.20 / 6
+ min(8, flasks) * 0.15 / 8
+ min(5, quicksilver) * 0.15 / 5
)
bosses: Dict[str, float] = {
"warden": -0.10,
"ten-piedad": 0.05,
"charred-visage": 0.20,
"tres-angustias": 0.15,
"esdras": 0.25,
"melquiades": 0.25,
"exposito": 0.30,
"quirce": 0.35,
"crisanta": 0.50,
"isidora": 0.70,
"sierpes": 0.70,
"amanecida": 0.60,
"laudes": 0.60,
"perpetua": -0.05,
"legionary": 0.20
}
boss_strength: float = bosses[boss]
return player_strength >= (boss_strength - 0.10 if self.world.options.difficulty >= 2 else
(boss_strength if self.world.options.difficulty >= 1 else boss_strength + 0.10))
def guilt_rooms(self, state: CollectionState) -> int:
doors = [
"D01Z04S01[NE]",
"D02Z02S11[W]",
"D03Z03S02[NE]",
"D04Z02S02[SE]",
"D05Z01S05[NE]",
"D09Z01S05[W]",
"D17Z01S04[W]",
]
return sum(state.can_reach_region(door, self.player) for door in doors)
def sword_rooms(self, state: CollectionState) -> int:
doors = [
["D01Z02S07[E]", "D01Z02S02[SW]"],
["D20Z01S04[E]", "D01Z05S23[W]"],
["D02Z03S02[NE]"],
["D04Z02S21[NE]"],
["D05Z01S21[NW]"],
["D06Z01S15[NE]"],
["D17Z01S07[SW]"]
]
total: int = 0
for subdoors in doors:
for door in subdoors:
if state.can_reach_region(door, self.player):
total += 1
break
return total
def redento_rooms(self, state: CollectionState) -> int:
if (
state.can_reach_region("D03Z01S04[E]", self.player)
or state.can_reach_region("D03Z02S10[N]", self.player)
):
if (
state.can_reach_region("D17Z01S05[S]", self.player)
or state.can_reach_region("D17BZ02S01[FrontR]", self.player)
):
if (
state.can_reach_region("D01Z03S04[E]", self.player)
or state.can_reach_region("D08Z01S01[W]", self.player)
):
if (
state.can_reach_region("D04Z01S03[E]", self.player)
or state.can_reach_region("D04Z02S01[W]", self.player)
or state.can_reach_region("D06Z01S18[-Cherubs]", self.player)
):
if (
self.knots(state) >= 1
and self.limestones(state) >= 3
and (
state.can_reach_region("D04Z02S08[E]", self.player)
or state.can_reach_region("D04BZ02S01[Redento]", self.player)
)
):
return 5
return 4
return 3
return 2
return 1
return 0
def miriam_rooms(self, state: CollectionState) -> int:
doors = [
"D02Z03S07[NWW]",
"D03Z03S07[NW]",
"D04Z04S01[E]",
"D05Z01S06[W]",
"D06Z01S17[E]"
]
return sum(state.can_reach_region(door, self.player) for door in doors)
def amanecida_rooms(self, state: CollectionState) -> int:
total: int = 0
if self.can_beat_graveyard_boss(state):
total += 1
if self.can_beat_jondo_boss(state):
total += 1
if self.can_beat_patio_boss(state):
total += 1
if self.can_beat_wall_boss(state):
total += 1
return total
def chalice_rooms(self, state: CollectionState) -> int:
doors = [
["D03Z01S02[E]", "D01Z05S02[W]", "D20Z01S03[N]"],
["D05Z01S11[SE]", "D05Z02S02[NW]"],
["D09Z01S09[E]", "D09Z01S10[W]", "D09Z01S08[SE]", "D09Z01S02[SW]"]
]
total: int = 0
for subdoors in doors:
for door in subdoors:
if state.can_reach_region(door, self.player):
total += 1
break
return total
Reference in New Issue View Git Blame Copy Permalink