1.4.3

args/arguments.py

@@ -59,6 +59,10 @@ def __init__(self):
             # if no output_file given add seed to output name
             name, ext = os.path.splitext(self.input_file)
             self.output_file = f"{name}_wc_{self.seed}{ext}"
+        elif os.path.isdir(self.output_file):
+            name, ext = os.path.splitext(os.path.basename(self.input_file))
+            # If output_file is a directory, construct the full path with above filename
+            self.output_file = os.path.join(self.output_file, f"{name}_wc_{self.seed}{ext}")            
 
         if self.debug:
             self.spoiler_log = True

args/coliseum.py

@@ -41,12 +41,12 @@ def flags(args):
     if args.coliseum_opponents_random:
         flags += f" -cor {args.coliseum_opponents_random}"
     elif args.coliseum_opponents_shuffle_random:
-        flags += f" -cor {args.coliseum_opponents_shuffle_random}"
+        flags += f" -cosr {args.coliseum_opponents_shuffle_random}"
 
     if args.coliseum_rewards_random:
         flags += f" -crr {args.coliseum_rewards_random}"
     elif args.coliseum_rewards_shuffle_random:
-        flags += f" -crr {args.coliseum_rewards_shuffle_random}"
+        flags += f" -crsr {args.coliseum_rewards_shuffle_random}"
 
     if args.coliseum_rewards_visible_random:
         flags += f" -crvr {args.coliseum_rewards_visible_random_min} {args.coliseum_rewards_visible_random_max}"
@@ -64,28 +64,45 @@ def flags(args):
 def options(args):
     result = []
 
-    opponents = "Original"
+    # if Coliseum opponents are random
     if args.coliseum_opponents_random:
-        opponents = "Random"
+        result.append(("Opponents", "Random", "opponents"))
+        result.append(("  Random", f"{args.coliseum_opponents_random}%","coliseum_opponents_random"))
+    # if Coliseum opponents are shuffle + random
+    elif args.coliseum_opponents_shuffle_random:
+        result.append(("Opponents", "Random", "opponents"))
+        result.append(("  Shuffle + Random", f"{args.coliseum_opponents_shuffle_random}%","coliseum_opponents_shuffle_random"))
+    # else Coliseum opponents are Original
+    else:
+        result.append(("Opponents", "Original", "opponents"))
 
-    rewards = "Original"
+    # if Coliseum rewards are random
     if args.coliseum_rewards_random:
-        rewards = "Random"
+        result.append(("Rewards", "Random", "rewards"))
+        result.append(("  Random", f"{args.coliseum_rewards_random}%","coliseum_rewards_random"))
+    # if Coliseum opponents are shuffle + random
+    elif args.coliseum_rewards_shuffle_random:
+        result.append(("Rewards", "Random", "rewards"))
+        result.append(("  Shuffle + Random", f"{args.coliseum_rewards_shuffle_random}%","coliseum_rewards_shuffle_random"))
+    # else Coliseum opponents are Original
+    else:
+        result.append(("Rewards", "Original", "rewards"))
 
+    # process rewards menu options
     rewards_visible = "Original"
     if not args.coliseum_rewards_menu:
         rewards_visible = "F"
     else:
         if args.coliseum_rewards_visible_random:
             rewards_visible = f"{args.coliseum_rewards_visible_random_min}-{args.coliseum_rewards_visible_random_max}"
-
-    return [
-        ("Opponents", opponents, "opponents"),
-        ("Rewards", rewards, "rewards"),
-        ("Rewards Visible", rewards_visible, "rewards_visible"),
-        ("No Exp. Eggs", args.coliseum_no_exp_eggs, "coliseum_no_exp_eggs"),
-        ("No Illuminas", args.coliseum_no_illuminas, "coliseum_no_illuminas"),
-    ]
+    # update Coliseum menu display
+    result.append(("Rewards Visible", rewards_visible, "rewards_visible"))
+    # update Coliseum Exp Eggs display
+    result.append(("No Exp. Eggs", args.coliseum_no_exp_eggs, "coliseum_no_exp_eggs"))
+    # update Coliseum Illuminas display
+    result.append(("No Illuminas", args.coliseum_no_illuminas, "coliseum_no_illuminas"))
+
+    return result
 
 def menu(args):
     return (name(), options(args))

args/misc.py

@@ -73,6 +73,8 @@ def flags(args):
         flags += f" -move {args.movement}"
     if args.original_name_display:
         flags += " -ond"
+    if args.scan_all:
+        flags += " -scan"
     if args.warp_all:
         flags += " -warp"
     if args.npc_dialog_tips:

args/shops.py

@@ -29,7 +29,7 @@ def parse(parser):
     shops_sell_fraction.add_argument("-ssf0", "--shop-sell-fraction0", action = "store_true",
                                      help = "Items sell for zero")
 
-    shops.add_argument("-sdm", "--shop-dried-meat", default = 1, type = int, choices = range(6), metavar = "COUNT",
+    shops.add_argument("-sdm", "--shop-dried-meat", default = 1, type = int, choices = range(11), metavar = "COUNT",
                         help = "%(metavar)s shops will contain dried meat")
     shops.add_argument("-npi", "--no-priceless-items", action = "store_true",
                        help = "Assign values to items which normally sell for 1 gold. Recommended with random inventory")

data/enemy_packs.py

@@ -150,16 +150,19 @@ def randomize_event_bosses(self):
         from constants.objectives.conditions import names as possible_condition_names
 
         boss_condition_name = "Boss"
+        bosses_condition_name = "Bosses"
         dragon_condition_name = "Dragon"
         dragons_condition_name = "Dragons"
         assert boss_condition_name in possible_condition_names
+        assert bosses_condition_name in possible_condition_names
         assert dragon_condition_name in possible_condition_names
         assert dragons_condition_name in possible_condition_names
 
         required_boss_formations = set()
         required_dragon_formations = set()
         required_statue_formations = set()
 
+        min_boss_formations = 0
         min_dragon_formations = 0
         for objective in objectives:
             for condition in objective.conditions:
@@ -169,15 +172,41 @@ def randomize_event_bosses(self):
                         required_statue_formations.add(formation)
                     else:
                         required_boss_formations.add(formation)
+                # if this condition is a set number of bosses, make sure we always get the highest amount for the minimum req # of formations
+                elif condition.NAME == bosses_condition_name and condition.count > min_boss_formations:
+                    min_boss_formations = condition.count
                 elif condition.NAME == dragon_condition_name:
                     required_dragon_formations.add(condition.dragon_formation)
                 elif condition.NAME == dragons_condition_name and condition.count > min_dragon_formations:
                     min_dragon_formations = condition.count
 
+        # amount of bosses needed is the minimum from above minus the required bosses + required statues
+        boss_formations_needed = min_boss_formations - (len(required_boss_formations) + len(required_statue_formations))
+        # if the extra required number needed non-zero
+        if boss_formations_needed > 0:
+            # initialize all boss formations set
+            all_boss_formations = set(bosses.normal_formation_name)
+            # remaining bosses is all bosses - required bosses | required statues
+            required_formations = set(required_boss_formations | required_statue_formations)
+            remaining_boss_formations = sorted(all_boss_formations - required_formations)
+            # the random boss formation list is a sample of the remaining bosses for the amount needed to fulfill objectives
+            random_boss_formations = random.sample(remaining_boss_formations, boss_formations_needed)
+            # add these boss formations into the appropriate set 
+            # (required_boss_formations or required_statue_formations)
+            for formation_id in random_boss_formations:
+                # if this formation is a statue
+                if formation_id in bosses.statue_formation_name:
+                    # add to required statue formations
+                    required_statue_formations.add(formation_id)
+                # else a regular boss
+                else:
+                    # add to required boss formations
+                    required_boss_formations.add(formation_id)
+
         dragon_formations_needed = min_dragon_formations - len(required_dragon_formations)
         if dragon_formations_needed > 0:
             all_dragon_formations = set(bosses.dragon_formation_name)
-            remaining_dragon_formations = list(all_dragon_formations - required_dragon_formations)
+            remaining_dragon_formations = sorted(all_dragon_formations - required_dragon_formations)
             random_dragon_formations = random.sample(remaining_dragon_formations, dragon_formations_needed)
             required_dragon_formations |= set(random_dragon_formations)
 

data/espers.py

@@ -345,7 +345,7 @@ def get_random_esper(self):
         if not self.available_espers:
             return None
 
-        rand_esper = random.sample(self.available_espers, 1)[0]
+        rand_esper = random.sample(sorted(self.available_espers), 1)[0]
         self.available_espers.remove(rand_esper)
         return rand_esper
 

data/shops.py

@@ -145,11 +145,16 @@ def clear_inventories(self):
     def assign_dried_meats(self):
         dried_meat_id = self.items.get_id("Dried Meat")
         dried_meat_type = self.items.get_type(dried_meat_id)
+        excluded_shops = ["Figaro Castle WOR (Left)","Figaro Castle WOR (Right)","Phantom Train"]
 
         dried_meat_shops = []
         no_dried_meat_shops = []
+
         for shop in self.shops:
-            if shop.contains(dried_meat_id):
+            if shop.contains(dried_meat_id) and shop.name() in excluded_shops:
+                shop.remove(dried_meat_id)
+                no_dried_meat_shops.append(shop)
+            elif shop.contains(dried_meat_id):
                 dried_meat_shops.append(shop)
             elif shop.type == Shop.ITEM or shop.type == Shop.VENDOR:
                 no_dried_meat_shops.append(shop)
@@ -167,50 +172,18 @@ def assign_dried_meats(self):
             # add a dried meat if space, otherwise replace a random item with dried meat
             for index in range(number_shops_with_dried_meat, self.args.shop_dried_meat):
                 random_shop = random.choice(no_dried_meat_shops)
+
+                while random_shop.name() in excluded_shops: # keep looping if shop is on the "bad" list
+                    random_shop = random.choice(no_dried_meat_shops)
+
                 if not random_shop.full():
                     random_shop.append(dried_meat_id)
                 else:
                     random_index = random.randrange(random_shop.item_count)
                     random_shop.items[random_index] = dried_meat_id
                 no_dried_meat_shops.remove(random_shop)
+                dried_meat_shops.append(random_shop)
 
-    def no_dried_meat_phantom_train(self):
-        # move dried meat from phantom train shop to a different shop
-        phantom_train_shop_id = 85
-        phantom_train_shop = self.all_shops[phantom_train_shop_id]
-
-        dried_meat_id = self.items.get_id("Dried Meat")
-        dried_meat_type = self.items.get_type(dried_meat_id)
-        dried_meat_index = phantom_train_shop.index(dried_meat_id)
-        if dried_meat_index is None:
-            return # phantom train shop does not have dried meat
-
-        # possible shops the dried meat can be moved to
-        possible_shops = self.type_shops[Shop.ITEM] + self.type_shops[Shop.VENDOR]
-
-        import random
-        random.shuffle(possible_shops)
-
-        for random_shop in possible_shops:
-            if random_shop.contains(dried_meat_id):
-                continue
-
-            # try to swap an empty slot with the dried meat
-            if not random_shop.full():
-                random_shop.append(dried_meat_id)
-                phantom_train_shop.remove(dried_meat_id)
-                return
-
-            # try to find an item in random_shop that phantom train does not have and swap them
-            item_indices = list(range(random_shop.item_count))
-            random.shuffle(item_indices)
-            for item_index in item_indices:
-                item = random_shop.items[item_index]
-                item_type = self.items.get_type(item)
-                if item_type == dried_meat_type and not phantom_train_shop.contains(item):
-                    phantom_train_shop.items[dried_meat_index] = item
-                    random_shop.items[item_index] = dried_meat_id
-                    return
 
     def remove_excluded_items(self):
         exclude = self.items.get_excluded()

event/event_reward.py

@@ -1,4 +1,5 @@
 from enum import Flag, unique, auto
+from typing import Collection
 @unique
 class RewardType(Flag):
     NONE = auto()
@@ -15,6 +16,10 @@ def __init__(self, event, possible_types):
         self.possible_types = possible_types
 
     def single_possible_type(self):
+        # python version difference -- in 3.9, "self.possible_types in RewardType" will only be true if there's a single reward and self.possible_types would not be a collection
+        # however, in python 3.12+, Collections of objects are also considered that object, so it would always be true even with multiple rewards, so we have to check the length
+        if (isinstance(self.possible_types, Collection)):
+            return len(self.possible_types) == 1
         return self.possible_types in RewardType
 
     def __str__(self):

event/mt_zozo.py

@@ -8,10 +8,7 @@ def character_gate(self):
         return self.characters.CYAN
 
     def init_rewards(self):
-        if self.args.no_free_characters_espers:
-            self.reward = self.add_reward(RewardType.ITEM)
-        else:
-            self.reward = self.add_reward(RewardType.CHARACTER | RewardType.ESPER | RewardType.ITEM)
+        self.reward = self.add_reward(RewardType.CHARACTER | RewardType.ESPER | RewardType.ITEM)
 
     def init_event_bits(self, space):
         space.write(

event/phantom_train.py

@@ -54,12 +54,6 @@ def add_gating_condition(self):
             field.ReturnIfEventBitClear(event_bit.character_recruited(self.character_gate())),
         )
 
-        sabin_path = self.characters.get_character_path(self.characters.SABIN)
-        veldt_gate = self.events["Veldt"].character_gate()
-        if veldt_gate in sabin_path and self.args.shop_dried_meat == 1:
-            # sabin requires veldt gate character and there is only one dried meat in shops
-            # make sure it is not in the phantom train
-            self.shops.no_dried_meat_phantom_train()
 
     def _load_world_map(self):
         src = [
@@ -82,6 +76,7 @@ def esper_item_mod(self, esper_item_instructions):
             esper_item_instructions,
 
             field.HideEntity(ghost_npc_id),
+            field.RefreshEntities(),
             field.SetEventBit(event_bit.GOT_PHANTOM_TRAIN_REWARD),
             field.FinishCheck(),
             field.Return(),
@@ -100,6 +95,7 @@ def esper_item_mod(self, esper_item_instructions):
         space.write(
             field.ReturnIfEventBitClear(event_bit.GOT_PHANTOM_TRAIN_REWARD),
             field.HideEntity(ghost_npc_id),
+            field.RefreshEntities(),
             field.Return(),
         )
         self.maps.set_entrance_event(0x98, inside_last_car_entrance_event - EVENT_CODE_START)

graphics/palettes/custom/Flowey-pomariin-Undertale.pal

@@ -0,0 +1 @@
+\c�+
�y�gK�&�S'��Q6��

graphics/palettes/custom/Purple Heart-HoxNorf-Neptunia.pal

@@ -0,0 +1 @@
+Bc�o�qW~Oe�[�>�(d�a+I�F-R:ZO

graphics/palettes/palettes.py

@@ -295,6 +295,32 @@
     357 : "Lenna (Thief)-HoxNorf-FF5",
     358 : "Lenna (Summoner)-HoxNorf-FF5",
     359 : "Lenna (Beastmaster)-HoxNorf-FF5",
+    360 : "Purple Heart-HoxNorf-Neptunia",
+    361 : "Reimu (PC98)-HoxNorf-Touhou",
+    362 : "Mokou-HoxNorf-Touhou",
+    363 : "Youmu-HoxNorf-Touhou",
+    364 : "Kirby-HoxNorf-Kirby",
+    365 : "Toadette (Sailor)-HoxNorf-Mario",
+    366 : "Shulk-HoxNorf-Xenoblade",
+    367 : "Miko-HoxNorf-Touhou",
+    368 : "Flowey-pomariin-Undertale",
+    369 : "Meiling-HoxNorf-Touhou",
+    370 : "Olimar-HoxNorf-Pikmin",
+    371 : "Tao-HoxNorf-Shining",
+    372 : "Tycoon-HoxNorf-FF5",
+    373 : "Chaz-HoxNorf-PS4",
+    374 : "Alys-HoxNorf-PS4",
+    375 : "Fox-CtrlxZ-Starfox",
+    376 : "Falco-Badass-Starfox",
+    377 : "Lutz-HoxNorf-PS1",
+    378 : "Yukari-HoxNorf-Touhou",
+    379 : "Demi-HoxNorf-PS4",
+    380 : "Ike (Ranger)-HoxNorf-FE",
+    381 : "Bartz (Dancer)-HoxNorf-FF5",
+    382 : "Marisa2-HoxNorf-Touhou",
+    383 : "Tewi-HoxNorf-Touhou",
+    384 : "Bow-HoxNorf-Mario",
+    385 : "Megumin-HoxNorf-Konosuba",
 }
 
 def get_path(id_):

graphics/portraits/custom/Ike (Ranger)-HoxNorf-FE.pal

@@ -0,0 +1 @@
+|�n%�$1J=�I1Zsf�42^Wy)d�F

graphics/portraits/custom/Lutz-HoxNorf-PS1.pal

@@ -0,0 +1 @@
+|�Nn�rJn{>�n2�r�%�M�U/{ot�

graphics/portraits/custom/Megumin-HoxNorf-Konosuba.pal

@@ -0,0 +1 @@
+|�!�.%~_P)�)=W�cX>�F�N�5�*

graphics/portraits/custom/Meiling-HoxNorf-Touhou.pal

@@ -0,0 +1,2 @@
+|]c�-2X%�1�%�o�WFS[B
+�Z�2

graphics/portraits/custom/Mokou-HoxNorf-Touhou.pal

@@ -0,0 +1 @@
+|�k�V\_�{VF�o�=�cn1g��RR;C�(

graphics/portraits/custom/Olimar-HoxNorf-Pikmin.pal

@@ -0,0 +1 @@
+|))�w�?OZoW�F:z>�g�=�^>%!

graphics/portraits/custom/Shulk-HoxNorf-Xenoblade.pal

@@ -0,0 +1 @@
+|=K2e�B�,%x:�%k�W��=�fuV;-

graphics/portraits/custom/Tycoon-metalliguy_Gens-FF5.pal

@@ -0,0 +1 @@
+|�Nv>�i�z'a�T3{�-!�c+z��{�

graphics/portraits/custom/Youmu-HoxNorf-Touhou.pal

@@ -0,0 +1 @@
+||o�oZk�g�w�btV�{(-J}c�Z�N�=

graphics/portraits/custom/Yukari-HoxNorf-Touhou.pal

@@ -0,0 +1 @@
+|�o01zBM=�b�J3Z�(� 7>�M�9s5o]_