Merge pull request #2635 from 2dos/dev

dtm

Author: theballaam96

.bumpversion.cfg

@@ -1,7 +1,7 @@
 [bumpversion]
 commit = True
 tag = False
-current_version = 4.11.33
+current_version = 4.11.50
 
 [bumpversion:file:version.py]
 search = version = "{current_version}"

__init__.py

@@ -130,7 +130,7 @@ def copy_dependencies(zip_path, file):
     from randomizer.Spoiler import Spoiler
     from randomizer.Settings import Settings
     from randomizer.ShuffleWarps import LinkWarps
-    from randomizer.Enums.Settings import ShuffleLoadingZones
+    from randomizer.Enums.Settings import LogicType, ShuffleLoadingZones
     from randomizer.Patching.ApplyRandomizer import patching_response
     from version import version
     from randomizer.Patching.EnemyRando import randomize_enemies_0
@@ -141,9 +141,11 @@ def copy_dependencies(zip_path, file):
     from randomizer.Enums.Levels import Levels
     from randomizer.Enums.Maps import Maps
     from randomizer.Enums.Locations import Locations as DK64RLocations
-    from randomizer.Enums.Settings import WinConditionComplex, SwitchsanityLevel
+    from randomizer.Enums.Settings import WinConditionComplex, SwitchsanityLevel, GlitchesSelected
     from randomizer.Enums.Switches import Switches
+    from randomizer.Enums.SwitchTypes import SwitchType
     from randomizer.Lists import Item as DK64RItem
+    from randomizer.Lists.Switches import SwitchInfo
     from worlds.LauncherComponents import Component, components, Type, icon_paths
     import randomizer.ShuffleExits as ShuffleExits
     from Utils import open_filename
@@ -283,7 +285,24 @@ def generate_early(self):
             settings_dict["medal_requirement"] = self.options.medal_requirement.value
             settings_dict["rareware_gb_fairies"] = self.options.rareware_gb_fairies.value
             settings_dict["krool_key_count"] = self.options.krool_key_count.value
+            if hasattr(self.multiworld, "generation_is_fake"):
+                settings_dict["krool_key_count"] = 8  # if gen is fake, don't pick random keys to start with, trust the slot data
             settings_dict["switchsanity"] = self.options.switchsanity.value
+            settings_dict["logic_type"] = self.options.logic_type.value
+            settings_dict["glitches_selected"] = []
+            for glitch in self.options.glitches_selected:
+                if glitch == "advanced_platforming":
+                    settings_dict["glitches_selected"].append(GlitchesSelected.advanced_platforming)
+                elif glitch == "moonkicks":
+                    settings_dict["glitches_selected"].append(GlitchesSelected.moonkicks)
+                elif glitch == "phase_swimming":
+                    settings_dict["glitches_selected"].append(GlitchesSelected.phase_swimming)
+                elif glitch == "swim_through_shores":
+                    settings_dict["glitches_selected"].append(GlitchesSelected.swim_through_shores)
+                elif glitch == "troff_n_scoff_skips":
+                    settings_dict["glitches_selected"].append(GlitchesSelected.troff_n_scoff_skips)
+                elif glitch == "moontail":
+                    settings_dict["glitches_selected"].append(GlitchesSelected.moontail)
             settings_dict["starting_keys_list_selected"] = []
             for item in self.options.start_inventory:
                 if item == "Key 1":
@@ -305,25 +324,46 @@ def generate_early(self):
             if self.options.goal == Goal.option_all_keys:
                 settings_dict["win_condition_item"] = WinConditionComplex.req_key
                 settings_dict["win_condition_count"] = 8
+            if self.options.goal == Goal.option_dk_rap:
+                settings_dict["win_condition_item"] = WinConditionComplex.dk_rap_items
             settings = Settings(settings_dict, self.random)
             # Set all the static slot data that UT needs to know. Most of these would have already been decided in normal generation by now, so they are just overwritten here.
             if hasattr(self.multiworld, "generation_is_fake"):
                 if hasattr(self.multiworld, "re_gen_passthrough"):
                     if "Donkey Kong 64" in self.multiworld.re_gen_passthrough:
                         passthrough = self.multiworld.re_gen_passthrough["Donkey Kong 64"]
                         settings.level_order = passthrough["LevelOrder"]
+                        # Switch logic lifted out of level shuffle due to static levels for UT
+                        if settings.alter_switch_allocation:
+                            allocation = [1, 1, 1, 1, 2, 2, 3, 3]
+                            for x in range(8):
+                                level = settings.level_order[x + 1]
+                                settings.switch_allocation[level] = allocation[x]
                         settings.starting_kong_list = passthrough["StartingKongs"]
+                        settings.starting_kong = settings.starting_kong_list[0]  # fake a starting kong so that we don't force a different kong
+                        settings.medal_requirement = passthrough["JetpacReq"]
+                        settings.rareware_gb_fairies = passthrough["FairyRequirement"]
+                        settings.medal_cb_req = passthrough["MedalCBRequirement"]
                         settings.BossBananas = passthrough["BossBananas"]
                         settings.boss_maps = passthrough["BossMaps"]
                         settings.boss_kongs = passthrough["BossKongs"]
                         settings.lanky_freeing_kong = passthrough["LankyFreeingKong"]
                         settings.helm_order = passthrough["HelmOrder"]
+                        settings.logic_type = LogicType[passthrough["LogicType"]]
+                        settings.glitches_selected = passthrough["GlitchesSelected"]
+                        settings.open_lobbies = passthrough["OpenLobbies"]
+                        settings.starting_key_list = passthrough["StartingKeyList"]
                         # There's multiple sources of truth for helm order.
                         settings.helm_donkey = 0 in settings.helm_order
                         settings.helm_diddy = 4 in settings.helm_order
                         settings.helm_lanky = 3 in settings.helm_order
                         settings.helm_tiny = 2 in settings.helm_order
                         settings.helm_chunky = 1 in settings.helm_order
+                        # Switchsanity
+                        for switch, data in passthrough["SwitchSanity"].items():
+                            needed_kong = Kongs[data["kong"]]
+                            switch_type = SwitchType[data["type"]]
+                            settings.switchsanity_data[Switches[switch]] = SwitchInfo(switch, needed_kong, switch_type, 0, 0, [])
             # We need to set the freeing kongs here early, as they won't get filled in any other part of the AP process
             settings.diddy_freeing_kong = self.random.randint(0, 4)
             # Lanky freeing kong actually changes logic, so UT should use the slot data rather than genning a new one.
@@ -577,6 +617,8 @@ def fill_slot_data(self) -> dict:
                 "ClimbingShuffle": self.options.climbing_shuffle.value,
                 "PlayerNum": self.player,
                 "death_link": self.options.death_link.value,
+                "ring_link": self.options.ring_link.value,
+                "tag_link": self.options.tag_link.value,
                 "receive_notifications": self.options.receive_notifications.value,
                 "LevelOrder": ", ".join([level.name for order, level in self.logic_holder.settings.level_order.items()]),
                 "StartingKongs": ", ".join([kong.name for kong in self.logic_holder.settings.starting_kong_list]),
@@ -596,6 +638,9 @@ def fill_slot_data(self) -> dict:
                 "OpenLobbies": self.logic_holder.settings.open_lobbies,
                 "KroolInBossPool": self.logic_holder.settings.krool_in_boss_pool,
                 "SwitchSanity": {switch.name: {"kong": data.kong.name, "type": data.switch_type.name} for switch, data in self.logic_holder.settings.switchsanity_data.items()},
+                "LogicType": self.logic_holder.settings.logic_type.name,
+                "GlitchesSelected": ", ".join([glitch.name for glitch in self.logic_holder.settings.glitches_selected]),
+                "StartingKeyList": ", ".join([key.name for key in self.logic_holder.settings.starting_key_list]),
             }
 
         def write_spoiler(self, spoiler_handle: typing.TextIO):
@@ -648,6 +693,9 @@ def create_item(self, name: str, force_non_progression=False) -> Item:
                 classification = ItemClassification.filler
             elif data.progression:
                 classification = ItemClassification.progression
+            elif hasattr(self.multiworld, "generation_is_fake"):
+                # UT needs to classify things as progression or it won't track them
+                classification = ItemClassification.progression
             else:
                 classification = ItemClassification.filler
 
@@ -667,17 +715,35 @@ def interpret_slot_data(self, slot_data: dict[str, any]) -> dict[str, any]:
             # Parse the string data
             level_order = slot_data["LevelOrder"].split(", ")
             starting_kongs = slot_data["StartingKongs"].split(", ")
+            medal_cb_req = slot_data["MedalCBRequirement"]
+            fairy_req = slot_data["FairyRequirement"]
+            pearl_req = slot_data["MermaidPearls"]
+            jetpac_req = slot_data["JetpacReq"]
             boss_bananas = slot_data["BossBananas"].split(", ")
             boss_maps = slot_data["BossMaps"].split(", ")
             boss_kongs = slot_data["BossKongs"].split(", ")
             helm_order = slot_data["HelmOrder"].split(", ")
+            open_lobbies = slot_data["OpenLobbies"]
+            switchsanity = slot_data["SwitchSanity"]
+            logic_type = slot_data["LogicType"]
+            glitches_selected = slot_data["GlitchesSelected"].split(", ")
+            starting_key_list = slot_data["StartingKeyList"].split(", ")
 
             relevant_data = {}
             relevant_data["LevelOrder"] = dict(enumerate([Levels[level] for level in level_order], start=1))
             relevant_data["StartingKongs"] = [Kongs[kong] for kong in starting_kongs]
+            relevant_data["MedalCBRequirement"] = medal_cb_req
+            relevant_data["FairyRequirement"] = fairy_req
+            relevant_data["MermaidPearls"] = pearl_req
+            relevant_data["JetpacReq"] = jetpac_req
             relevant_data["BossBananas"] = [int(cost) for cost in boss_bananas]
             relevant_data["BossMaps"] = [Maps[map] for map in boss_maps]
             relevant_data["BossKongs"] = [Kongs[kong] for kong in boss_kongs]
             relevant_data["LankyFreeingKong"] = slot_data["LankyFreeingKong"]
             relevant_data["HelmOrder"] = [int(room) for room in helm_order]
+            relevant_data["SwitchSanity"] = switchsanity
+            relevant_data["OpenLobbies"] = open_lobbies
+            relevant_data["LogicType"] = logic_type
+            relevant_data["GlitchesSelected"] = [GlitchesSelected[glitch] for glitch in glitches_selected if glitch != ""]
+            relevant_data["StartingKeyList"] = [DK64RItems[key] for key in starting_key_list if key != ""]
             return relevant_data

ap_version.py

@@ -1,3 +1,3 @@
 """Holds the version for Archipelago."""
 
-version = "1.0.27"
+version = "1.0.35"