Add additional configuration options, bugfixes (ArchipelagoMW#4)

* Update item list

* Start updating rules, victory condition

* Add all items and locations

* Add rules for Research Table item recipes

* Regenerate items with requirements, fix bugs

* More logic updates

* Add progressives, friendly names

* Add Relay Station quest

* New locations

* Update version

* Add configuration but build broken atm

* Add Caravan Island Frequency

* Reorder progressives, revert location change

* Add more options

* Fixup item generation issue

* Slight polishing

* Change to resourcepacks.json, comments

* Add more frequency location options

* Add item duplication option

* Make tests pass, allow dupe resource pack usage

Author: SunnyBat

worlds/raft/Items.py

@@ -1,23 +1,56 @@
 import json
 import os
 
+def createResourcePackName(amount: int, itemName: str):
+    return "Resource Pack: " + str(amount) + " " + itemName
+
 with open(os.path.join(os.path.dirname(__file__), 'items.json'), 'r') as file:
     item_table = json.loads(file.read())
+with open(os.path.join(os.path.dirname(__file__), 'progressives.json'), 'r') as file:
+    progressive_table = json.loads(file.read())
+with open(os.path.join(os.path.dirname(__file__), 'resourcepacks.json'), 'r') as file:
+    resourcepack_items = json.loads(file.read())
 
 lookup_id_to_name = {}
 lookup_name_to_item = {}
 advancement_item_names = set()
-non_advancement_item_names = set()
 
+lastItemId = -1
 for item in item_table:
     item_name = item["name"]
     lookup_id_to_name[item["id"]] = item_name
     lookup_name_to_item[item_name] = item
     if item["progression"]:
         advancement_item_names.add(item_name)
-    else:
-        non_advancement_item_names.add(item_name)
+    lastItemId = max(lastItemId, item["id"])
 
-lookup_id_to_name[None] = "Victory"
+progressive_item_list = {}
+for item in progressive_table:
+    progressiveName = progressive_table[item]
+    if progressiveName not in progressive_item_list:
+        progressive_item_list[progressiveName] = []
+    progressive_item_list[progressiveName].append(item)
+
+for progressiveItemName in progressive_item_list.keys():
+    lastItemId += 1
+    generatedItem = {}
+    generatedItem["id"] = lastItemId
+    generatedItem["name"] = progressiveItemName
+    generatedItem["progression"] = lookup_name_to_item[progressive_item_list[progressiveItemName][0]]["progression"]
+    lookup_name_to_item[progressiveItemName] = generatedItem
+    lookup_id_to_name[lastItemId] = progressiveItemName
 
+# Generate resource pack items
+for packItem in resourcepack_items:
+    for i in range(1, 16): # 1-15
+        lastItemId += 1
+        rpName = createResourcePackName(i, packItem)
+        generatedItem = {}
+        generatedItem["id"] = lastItemId
+        generatedItem["name"] = rpName
+        generatedItem["progression"] = False
+        lookup_name_to_item[rpName] = generatedItem
+        lookup_id_to_name[lastItemId] = rpName
+
+lookup_id_to_name[None] = "Victory"
 lookup_name_to_id = {name: id for id, name in lookup_id_to_name.items()}

worlds/raft/Items.txt

@@ -1,23 +1,61 @@
-from Options import Range
+from Options import Range, Toggle, DefaultOnToggle, Choice
 
-class ResearchCostMultiplier(Range):
-    """The amount of each research item required in the Research Table
-	   to research a given technology"""
-    displayname = "Research Cost Multiplier"
+class UseResourcePacks(DefaultOnToggle):
+    """Uses Resource Packs to fill out the item pool from Raft. Resource Packs have basic earlygame items such as planks, plastic, or food."""
+    displayname = "Use resource packs"
+
+class MinimumResourcePackAmount(Range):
+    """The minimum amount of resources available in a resource pack"""
+    displayname = "Minimum resource pack amount"
     range_start = 1
-    range_end = 10
+    range_end = 15
     default = 1
 
-class ResourcePackMultiplier(Range):
-    """This will multiply the amount of resources obtained from random
-       resource drops"""
-    displayname = "Resource Pack Multipler"
+class MaximumResourcePackAmount(Range):
+    """The maximum amount of resources available in a resource pack"""
+    displayname = "Maximum resource pack amount"
     range_start = 1
-    range_end = 5
+    range_end = 15
+    default = 5
+
+class DuplicateItems(Choice):
+    """Adds duplicates of items to the item pool. These will be selected alongside
+    Resource Packs (if configured). Note that there are not many progression items,
+    and selecting Progression may produce many of the same duplicate item."""
+    displayname = "Duplicate items"
+    option_off = 0
+    option_progression = 1
+    option_non_progression = 2
+    option_any = 3
+
+class IslandFrequencyLocations(Choice):
+    """Sets where frequencies for story islands are located."""
+    displayname = "Frequency locations"
+    option_vanilla = 0
+    option_random_on_island = 1
+    option_progressive = 2
+    option_anywhere = 3
     default = 1
 
+class ProgressiveItems(DefaultOnToggle):
+    """Makes some items, like the Bow and Arrow, progressive rather than raw unlocks."""
+    displayname = "Progressive items"
+
+class BigIslandEarlyCrafting(Toggle):
+    """Allows recipes that require items from big islands (eg leather) to lock earlygame items like the Receiver, Bolt, or Smelter."""
+    displayname = "Early recipes behind big islands"
+
+class PaddleboardMode(Toggle):
+    """Sets later story islands to in logic without an Engine or Steering Wheel. May require lots of paddling. Not recommended."""
+    displayname = "Paddleboard Mode"
 
-options = {
-    "research_cost_multiplier": ResearchCostMultiplier,
-    "resource_pack_multiplier": ResourcePackMultiplier
+raft_options = {
+    "use_resource_packs": UseResourcePacks,
+    "minimum_resource_pack_amount": MinimumResourcePackAmount,
+    "maximum_resource_pack_amount": MaximumResourcePackAmount,
+    "duplicate_items": DuplicateItems,
+    "island_frequency_locations": IslandFrequencyLocations,
+    "progressive_items": ProgressiveItems,
+    "big_island_early_crafting": BigIslandEarlyCrafting,
+    "paddleboard_mode": PaddleboardMode
 }

worlds/raft/Options.py

@@ -15,7 +15,6 @@ def create_regions(world, player: int):
         if len(exit_array) == 0:
             exit_array = None
         new_region = create_region(world, player, region, [location["name"] for location in location_table if location["region"] == region], exit_array)
-            
         world.regions += [new_region]
 
     menu = create_region(world, player, "Menu", None, ["Raft"])

worlds/raft/Progressives.py

@@ -3,15 +3,13 @@
 from .Regions import regionMap
 from ..AutoWorld import LogicMixin
 
-# TODOs
-# - Maybe put large island unlockables behind Receiver
-# -- This will make getting them more consistent
-# - Blueprint fuel pipe on Balboa didn't trigger Archipelago sendable ("Error finding ID for location Blueprint_Pipe_Fuel")
-# -- Same with Blueprint_Fueltank
-# -- All blueprints :(
-# - Blueprint_Firework from doll after explosive barrel on Caravan Island doesn't disappear when picked up
-
 class RaftLogic(LogicMixin):
+    def paddleboard_mode_enabled(self, player):
+        return self.world.paddleboard_mode[player].value
+    
+    def big_islands_available(self, player):
+        return self.world.big_island_early_crafting[player].value or self.can_access_radio_tower(player)
+
     def can_smelt_items(self, player):
         return self.has("Smelter", player)
 
@@ -81,8 +79,6 @@ def can_drive(self, player): # The player can go wherever they want with the eng
         return self.can_craft_engine(player) and self.can_craft_steeringWheel(player)
 
     def can_access_radio_tower(self, player):
-        # Technically the player doesn't need things like the sail to reach the Radio Tower,
-        # but paddling there is not very efficient or engaging gameplay.
         return self.can_navigate(player)
 
     def can_complete_radio_tower(self, player):
@@ -95,25 +91,26 @@ def can_complete_vasagatan(self, player):
         return self.can_access_vasagatan(player)
 
     def can_access_balboa_island(self, player):
-        return self.can_complete_vasagatan(player) and self.can_drive(player) and self.has("Balboa Island Frequency", player)
+        return (self.can_complete_vasagatan(player)
+            and (self.can_drive(player) or self.paddleboard_mode_enabled(player))
+            and self.has("Balboa Island Frequency", player))
 
     def can_complete_balboa_island(self, player):
         return self.can_access_balboa_island(player) and self.can_craft_machete(player) and self.can_fire_bow(player)
 
     def can_access_caravan_island(self, player):
-        return self.can_complete_balboa_island(player) and self.can_drive(player) # Coordinates are given from Relay Station quest
+        return self.can_complete_balboa_island(player) and (self.can_drive(player) or self.paddleboard_mode_enabled(player)) and self.has("Caravan Island Frequency", player)
 
     def can_complete_caravan_island(self, player):
         return self.can_access_caravan_island(player) and self.can_craft_ziplineTool(player)
 
     def can_access_tangaroa(self, player):
-        return self.can_complete_caravan_island(player) and self.can_drive(player) and self.has("Tangaroa Frequency", player)
+        return self.can_complete_caravan_island(player) and (self.can_drive(player) or self.paddleboard_mode_enabled(player)) and self.has("Tangaroa Frequency", player)
 
     def can_complete_tangaroa(self, player):
         return self.can_access_tangaroa(player)
 
 def set_rules(world, player):
-    # Map region to check to see if we can access it
     regionChecks = {
         "Raft": lambda state: True,
         "ResearchTable": lambda state: True,
@@ -133,14 +130,14 @@ def set_rules(world, player):
         "Scrap": lambda state: True,
         "SeaVine": lambda state: True,
         "Brick_Dry": lambda state: True,
-        "Leather": lambda state: True, # Conflicting info on whetherwe need state.can_navigate(player) instead, personal testing indicates this is correct
         "Thatch": lambda state: True, # Palm Leaf
         "Placeable_GiantClam": lambda state: True,
-        "Feather": lambda state: state.can_craft_birdNest(player), # Maybe add config for this since you technically don't need bird nest
+        "Leather": lambda state: state.big_islands_available(player),
+        "Feather": lambda state: state.big_islands_available(player) or state.can_craft_birdNest(player),
         "MetalIngot": lambda state: state.can_smelt_items(player),
         "CopperIngot": lambda state: state.can_smelt_items(player),
         "VineGoo": lambda state: state.can_smelt_items(player),
-        "ExplosivePowder": lambda state: state.can_smelt_items(player),
+        "ExplosivePowder": lambda state: state.big_islands_available(player) and state.can_smelt_items(player),
         "Glass": lambda state: state.can_smelt_items(player),
         "Bolt": lambda state: state.can_craft_bolt(player),
         "Hinge": lambda state: state.can_craft_hinge(player),
@@ -158,26 +155,26 @@ def set_rules(world, player):
         "Zipline tool": lambda state: state.can_craft_ziplineTool(player)
     }
 
-    # Location rules
+    # Region access rules
     for region in regionMap:
         if region != "Menu":
             for exitRegion in world.get_region(region, player).exits:
                 set_rule(world.get_entrance(exitRegion.name, player), regionChecks[region])
 
-    # Process locations
+    # Location access rules
     for location in location_table:
         locFromWorld = world.get_location(location["name"], player)
-        if "requiresAccessToItems" in location:
-            def ruleLambda(state, location=location):
+        if "requiresAccessToItems" in location: # Specific item access required
+            def fullLocationCheck(state, location=location):
                 canAccess = regionChecks[location["region"]](state)
                 for item in location["requiresAccessToItems"]:
                     if not itemChecks[item](state):
                         canAccess = False
                         break
                 return canAccess
-            set_rule(locFromWorld, ruleLambda)
-        else:
+            set_rule(locFromWorld, fullLocationCheck)
+        else: # Only region access required
             set_rule(locFromWorld, regionChecks[location["region"]])
 
-    # Victory location
-    world.completion_condition[player] = lambda state: state.has('Victory', player)
+    # Victory requirement
+    world.completion_condition[player] = lambda state: state.has("Victory", player)