Grinch-AP/worlds/blasphemous/__init__.py

from typing import Dict, Set, List, Any
from collections import Counter
from BaseClasses import Region, Entrance, Location, Item, Tutorial, ItemClassification
from ..AutoWorld import World, WebWorld
from .Items import base_id, item_table, group_table, tears_set, reliquary_set, skill_set
from .Locations import location_table, shop_set
from .Exits import region_exit_table, exit_lookup_table
from .Rules import rules
from worlds.generic.Rules import set_rule
from .Options import blasphemous_options
from . import Vanilla


class BlasphemousWeb(WebWorld):
    theme = "stone"
    tutorials = [Tutorial(
        "Multiworld Setup Guide",
        "A guide to setting up the Blasphemous randomizer connected to an Archipelago Multiworld",
        "English",
        "setup_en.md",
        "setup/en",
        ["TRPG"]
    )]


class BlasphemousWorld(World):
    """
    Blasphemous is a challenging Metroidvania set in the cursed land of Cvstodia. Play as the Penitent One, trapped
    in an endless cycle of death and rebirth, and free the world from it's terrible fate in your quest to break
    your eternal damnation!
    """

    game: str = "Blasphemous"
    web = BlasphemousWeb()
    data_version = 1

    item_name_to_id = {item["name"]: (base_id + index) for index, item in enumerate(item_table)}
    location_name_to_id = {loc["name"]: (base_id + index) for index, loc in enumerate(location_table)}
    location_name_to_game_id = {loc["name"]: loc["game_id"] for loc in location_table}

    item_name_groups = group_table
    option_definitions = blasphemous_options


    def set_rules(self):
        rules(self)


    def create_item(self, name: str) -> "BlasphemousItem":
        item_id: int = self.item_name_to_id[name]
        id = item_id - base_id

        return BlasphemousItem(name, item_table[id]["classification"], item_id, player=self.player)


    def create_event(self, event: str):
        return BlasphemousItem(event, ItemClassification.progression_skip_balancing, None, self.player)


    def get_filler_item_name(self) -> str:
        return self.multiworld.random.choice(tears_set)


    def create_items(self):
        placed_items = []

        placed_items.extend(Vanilla.unrandomized_dict.values())

        if not self.multiworld.reliquary_shuffle[self.player]:
            placed_items.extend(reliquary_set)
        elif self.multiworld.reliquary_shuffle[self.player]:
            placed_items.append("Tears of Atonement (250)")
            placed_items.append("Tears of Atonement (300)")
            placed_items.append("Tears of Atonement (500)")

        if not self.multiworld.cherub_shuffle[self.player]:
            for i in range(38):
                placed_items.append("Child of Moonlight")

        if not self.multiworld.life_shuffle[self.player]:
            for i in range(6):
                placed_items.append("Life Upgrade")

        if not self.multiworld.fervour_shuffle[self.player]:
            for i in range(6):
                placed_items.append("Fervour Upgrade")

        if not self.multiworld.sword_shuffle[self.player]:
            for i in range(7):
                placed_items.append("Mea Culpa Upgrade")

        if not self.multiworld.blessing_shuffle[self.player]:
            placed_items.extend(Vanilla.blessing_dict.values())

        if not self.multiworld.dungeon_shuffle[self.player]:
            placed_items.extend(Vanilla.dungeon_dict.values())

        if not self.multiworld.tirso_shuffle[self.player]:
            placed_items.extend(Vanilla.tirso_dict.values())

        if not self.multiworld.miriam_shuffle[self.player]:
            placed_items.append("Cantina of the Blue Rose")

        if not self.multiworld.redento_shuffle[self.player]:
            placed_items.extend(Vanilla.redento_dict.values())

        if not self.multiworld.jocinero_shuffle[self.player]:
            placed_items.extend(Vanilla.jocinero_dict.values())
        
        if not self.multiworld.altasgracias_shuffle[self.player]:
            placed_items.extend(Vanilla.altasgracias_dict.values())

        if not self.multiworld.tentudia_shuffle[self.player]:
            placed_items.extend(Vanilla.tentudia_dict.values())

        if not self.multiworld.gemino_shuffle[self.player]:
            placed_items.extend(Vanilla.gemino_dict.values())

        if not self.multiworld.guilt_shuffle[self.player]:
            placed_items.append("Weight of True Guilt")

        if not self.multiworld.ossuary_shuffle[self.player]:
            placed_items.extend(Vanilla.ossuary_dict.values())

        if not self.multiworld.boss_shuffle[self.player]:
            placed_items.extend(Vanilla.boss_dict.values())

        if not self.multiworld.wound_shuffle[self.player]:
            placed_items.extend(Vanilla.wound_dict.values())

        if not self.multiworld.mask_shuffle[self.player]:
            placed_items.extend(Vanilla.mask_dict.values())

        if not self.multiworld.eye_shuffle[self.player]:
            placed_items.extend(Vanilla.eye_dict.values())

        if not self.multiworld.herb_shuffle[self.player]:
            placed_items.extend(Vanilla.herb_dict.values())

        if not self.multiworld.church_shuffle[self.player]:
            placed_items.extend(Vanilla.church_dict.values())

        if not self.multiworld.shop_shuffle[self.player]:
            placed_items.extend(Vanilla.shop_dict.values())

        if self.multiworld.thorn_shuffle[self.player] == 2:
            for i in range(8):
                placed_items.append("Thorn Upgrade")

        if not self.multiworld.candle_shuffle[self.player]:
            placed_items.extend(Vanilla.candle_dict.values())

        if self.multiworld.start_wheel[self.player]:
            placed_items.append("The Young Mason's Wheel")

        if not self.multiworld.skill_randomizer[self.player]:
            placed_items.extend(Vanilla.skill_dict.values())

        counter = Counter(placed_items)

        pool = []

        for item in item_table:
            count = item["count"] - counter[item["name"]]
            
            if count <= 0:
                continue
            else:
                for i in range(count):
                    pool.append(self.create_item(item["name"]))

        self.multiworld.itempool += pool


    def pre_fill(self):
        self.place_items_from_dict(Vanilla.unrandomized_dict)

        if not self.multiworld.cherub_shuffle[self.player]:
            self.place_items_from_set(Vanilla.cherub_set, "Child of Moonlight")

        if not self.multiworld.life_shuffle[self.player]:
            self.place_items_from_set(Vanilla.life_set, "Life Upgrade")

        if not self.multiworld.fervour_shuffle[self.player]:
            self.place_items_from_set(Vanilla.fervour_set, "Fervour Upgrade")

        if not self.multiworld.sword_shuffle[self.player]:
            self.place_items_from_set(Vanilla.sword_set, "Mea Culpa Upgrade")

        if not self.multiworld.blessing_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.blessing_dict)

        if not self.multiworld.dungeon_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.dungeon_dict)

        if not self.multiworld.tirso_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.tirso_dict)

        if not self.multiworld.miriam_shuffle[self.player]:
            self.multiworld.get_location("AtTotS: Miriam's gift", self.player)\
                .place_locked_item(self.create_item("Cantina of the Blue Rose"))

        if not self.multiworld.redento_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.redento_dict)

        if not self.multiworld.jocinero_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.jocinero_dict)

        if not self.multiworld.altasgracias_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.altasgracias_dict)

        if not self.multiworld.tentudia_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.tentudia_dict)

        if not self.multiworld.gemino_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.gemino_dict)

        if not self.multiworld.guilt_shuffle[self.player]:
            self.multiworld.get_location("GotP: Confessor Dungeon room", self.player)\
                .place_locked_item(self.create_item("Weight of True Guilt"))

        if not self.multiworld.ossuary_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.ossuary_dict)

        if not self.multiworld.boss_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.boss_dict)

        if not self.multiworld.wound_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.wound_dict)

        if not self.multiworld.mask_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.mask_dict)

        if not self.multiworld.eye_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.eye_dict)

        if not self.multiworld.herb_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.herb_dict)

        if not self.multiworld.church_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.church_dict)

        if not self.multiworld.shop_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.shop_dict)

        if self.multiworld.thorn_shuffle[self.player] == 2:
            self.place_items_from_set(Vanilla.thorn_set, "Thorn Upgrade")

        if not self.multiworld.candle_shuffle[self.player]:
            self.place_items_from_dict(Vanilla.candle_dict)

        if self.multiworld.start_wheel[self.player]:
            self.multiworld.get_location("BotSS: Beginning gift", self.player)\
                .place_locked_item(self.create_item("The Young Mason's Wheel"))

        if not self.multiworld.skill_randomizer[self.player]:
            self.place_items_from_dict(Vanilla.skill_dict)

        if self.multiworld.thorn_shuffle[self.player] == 1:
            self.multiworld.local_items[self.player].value.add("Thorn Upgrade")
        

    def place_items_from_set(self, location_set: Set[str], name: str):
        for loc in location_set:
            self.multiworld.get_location(loc, self.player)\
                .place_locked_item(self.create_item(name))

    
    def place_items_from_dict(self, option_dict: Dict[str, str]):
        for loc, item in option_dict.items():
            self.multiworld.get_location(loc, self.player)\
                .place_locked_item(self.create_item(item))


    def create_regions(self) -> None:
        
        player = self.player
        world = self.multiworld

        region_table: Dict[str, Region] = {
            "menu"    : Region("Menu", player, world),
            "albero"  : Region("Albero", player, world),
            "attots"  : Region("All the Tears of the Sea", player, world),
            "ar"      : Region("Archcathedral Rooftops", player, world),
            "bottc"   : Region("Bridge of the Three Cavalries", player, world),
            "botss"   : Region("Brotherhood of the Silent Sorrow", player, world),
            "coolotcv": Region("Convent of Our Lady of the Charred Visage", player, world),
            "dohh"    : Region("Deambulatory of His Holiness", player, world),
            "dc"      : Region("Desecrated Cistern", player, world),
            "eos"     : Region("Echoes of Salt", player, world),
            "ft"      : Region("Ferrous Tree", player, world),
            "gotp"    : Region("Graveyard of the Peaks", player, world),
            "ga"      : Region("Grievance Ascends", player, world),
            "hotd"    : Region("Hall of the Dawning", player, world),
            "jondo"   : Region("Jondo", player, world),
            "kottw"   : Region("Knot of the Three Words", player, world),
            "lotnw"   : Region("Library of the Negated Words", player, world),
            "md"      : Region("Mercy Dreams", player, world),
            "mom"     : Region("Mother of Mothers", player, world),
            "moted"   : Region("Mountains of the Endless Dusk", player, world),
            "mah"     : Region("Mourning and Havoc", player, world),
            "potss"   : Region("Patio of the Silent Steps", player, world),
            "petrous" : Region("Petrous", player, world),
            "thl"     : Region("The Holy Line", player, world),
            "trpots"  : Region("The Resting Place of the Sister", player, world),
            "tsc"     : Region("The Sleeping Canvases", player, world),
            "wothp"   : Region("Wall of the Holy Prohibitions", player, world),
            "wotbc"   : Region("Wasteland of the Buried Churches", player, world),
            "wotw"    : Region("Where Olive Trees Wither", player, world),
            "dungeon" : Region("Dungeons", player, world)
        }

        for rname, reg in region_table.items():
            world.regions.append(reg)

            for ename, exits in region_exit_table.items():
                if ename == rname:
                    for i in exits:
                        ent = Entrance(player, i, reg)
                        reg.exits.append(ent)

                        for e, r in exit_lookup_table.items():
                            if i == e:
                                ent.connect(region_table[r])

        for loc in location_table:
            id = base_id + location_table.index(loc)
            region_table[loc["region"]].locations\
                .append(BlasphemousLocation(self.player, loc["name"], id, region_table[loc["region"]]))
        
        victory = Location(self.player, "His Holiness Escribar", None, self.multiworld.get_region("Deambulatory of His Holiness", self.player))
        victory.place_locked_item(self.create_event("Victory"))
        self.multiworld.get_region("Deambulatory of His Holiness", self.player).locations.append(victory)

        if self.multiworld.ending[self.player].value == 1:
            set_rule(victory, lambda state: state.has("Thorn Upgrade", player, 8))
        elif self.multiworld.ending[self.player].value == 2:
            set_rule(victory, lambda state: state.has("Thorn Upgrade", player, 8) and \
                state.has("Holy Wound of Abnegation", player))

        self.multiworld.completion_condition[self.player] = lambda state: state.has("Victory", self.player)

    
    def fill_slot_data(self) -> Dict[str, Any]:
        slot_data: Dict[str, Any] = {}
        locations = []

        for loc in self.multiworld.get_filled_locations(self.player):
            if loc.name == "His Holiness Escribar":
                continue
            else:
                data = {
                    "id": self.location_name_to_game_id[loc.name],
                    "ap_id": loc.address,
                    "name": loc.item.name,
                    "player_name": self.multiworld.player_name[loc.item.player]
                }

                if loc.name in shop_set:
                    data["type"] = loc.item.classification.name

                locations.append(data)

        config = {
            "versionCreated": "AP",
            "general": {
                "teleportationAlwaysUnlocked": bool(self.multiworld.prie_dieu_warp[self.player].value),
                "skipCutscenes": bool(self.multiworld.skip_cutscenes[self.player].value),
                "enablePenitence": bool(self.multiworld.penitence[self.player].value),
                "hardMode": False,
                "customSeed": 0,
                "allowHints": bool(self.multiworld.corpse_hints[self.player].value)
            },
            "items": {
                "type": 1,
                "lungDamage": False,
                "disableNPCDeath": True,
                "startWithWheel": bool(self.multiworld.start_wheel[self.player].value),
                "shuffleReliquaries": bool(self.multiworld.reliquary_shuffle[self.player].value)
            },
            "enemies": {
                "type": self.multiworld.enemy_randomizer[self.player].value,
                "maintainClass": bool(self.multiworld.enemy_groups[self.player].value),
                "areaScaling": bool(self.multiworld.enemy_scaling[self.player].value)
            },
            "prayers": {
                "type": 0,
                "removeMirabis": False
            },
            "doors": {
                "type": 0
            },
            "debug": {
                "type": 0
            }
        }
    
        slot_data = {
            "locations": locations,
            "cfg": config,
            "ending": self.multiworld.ending[self.player].value,
            "death_link": bool(self.multiworld.death_link[self.player].value)
        }
    
        return slot_data


class BlasphemousItem(Item):
    game: str = "Blasphemous"


class BlasphemousLocation(Location):
    game: str = "Blasphemous"