Lingo: New game

worlds/lingo/Options.py

@@ -0,0 +1,104 @@
+from typing import Dict, Union
+from BaseClasses import MultiWorld
+from Options import Toggle, Option, Choice, DefaultOnToggle, Range
+
+
+class ShuffleDoors(Choice):
+    """If on, opening doors will require their respective "keys".
+    In "simple", doors are sorted into logical groups, which are all opened by receiving an item.
+    In "complex", the items are much more granular, and will usually only open a single door each."""
+    display_name = "Shuffle Doors"
+    option_none = 0
+    option_simple = 1
+    option_complex = 2
+
+
+class ProgressiveOrangeTower(DefaultOnToggle):
+    """When "Shuffle Doors" is on, this setting governs the manner in which the Orange Tower floors open up.
+    If off, there is an item for each floor of the tower, and each floor's item is the only one needed to access that floor.
+    If on, there are six progressive items, which open up the tower from the bottom floor upward.
+    """
+    display_name = "Progressive Orange Tower"
+
+
+class ReduceChecks(Toggle):
+    """When "Shuffle Doors" is off, there are far more location checks than there are items.
+    Enabling reduce checks will remove many of the locations that are associated with opening doors.
+    This option is ignored if "Shuffle Doors" is on."""
+    display_name = "Reduce Checks"
+
+
+class ShuffleColors(Toggle):
+    """If on, an item is added to the pool for every puzzle color (besides White).
+    You will need to unlock the requisite colors in order to be able to solve puzzles of that color."""
+    display_name = "Shuffle Colors"
+
+
+class ShufflePanels(Choice):
+    """If on, the puzzles on each panel are randomized.
+    On "rearrange", the puzzles are the same as the ones in the base game, but are placed in different areas."""
+    display_name = "Shuffle Panels"
+    option_none = 0
+    option_rearrange = 1
+
+
+class ShufflePaintings(Toggle):
+    """If on, the destination, location, and appearance of the painting warps in the game will be randomized."""
+    display_name = "Shuffle Paintings"
+
+
+class VictoryCondition(Choice):
+    """Change the victory condition."""
+    display_name = "Victory Condition"
+    option_the_end = 0
+    option_the_master = 1
+
+
+class MasteryAchievements(Range):
+    """The number of achievements required to unlock THE MASTER.
+    In the base game, 21 achievements are needed.
+    If you include The Scientific and The Unchallenged, which are in the base game but are not counted for mastery, 23 would be required.
+    If you include the custom achievement (The Wanderer), 24 would be required.
+    """
+    display_name = "Mastery Achievements"
+    range_start = 1
+    range_end = 24
+    default = 21
+
+
+class TrapPercentage(Range):
+    """Replaces junk items with traps, at the specified rate."""
+    display_name = "Trap Percentage"
+    range_start = 0
+    range_end = 100
+    default = 20
+
+
+class DeathLink(Toggle):
+    """If on: Whenever another player on death link dies, you will be returned to the starting room."""
+    display_name = "Death Link"
+
+
+lingo_options: Dict[str, type] = {
+    "shuffle_doors": ShuffleDoors,
+    "progressive_orange_tower": ProgressiveOrangeTower,
+    "reduce_checks": ReduceChecks,
+    "shuffle_colors": ShuffleColors,
+    "shuffle_panels": ShufflePanels,
+    "shuffle_paintings": ShufflePaintings,
+    "victory_condition": VictoryCondition,
+    "mastery_achievements": MasteryAchievements,
+    "trap_percentage": TrapPercentage,
+    "death_link": DeathLink
+}
+
+
+def get_option_value(world: MultiWorld, player: int, name: str) -> Union[bool, int]:
+    option = getattr(world, name, None)
+
+    if option is None:
+        return 0
+
+    if issubclass(lingo_options[name], Toggle):
+        return bool(option[player].value)
+    return option[player].value

worlds/lingo/__init__.py

@@ -0,0 +1,149 @@
+"""
+Archipelago init file for Lingo
+"""
+import typing
+
+from BaseClasses import Region, Location, MultiWorld, Item, Entrance, Tutorial, ItemClassification
+from worlds.AutoWorld import World, WebWorld
+from .static_logic import StaticLingoLogic, Room, RoomEntrance
+from .items import LingoItem, StaticLingoItems
+from .locations import LingoLocation, StaticLingoLocations
+from .Options import lingo_options, get_option_value
+from .testing import LingoTestOptions
+from worlds.generic.Rules import set_rule
+from .rules import LingoLogic, set_rules
+from .player_logic import LingoPlayerLogic
+from .regions import create_regions
+from math import floor
+
+
+class LingoWebWorld(WebWorld):
+    theme = "grass"
+    tutorials = [Tutorial(
+        "Multiworld Setup Guide",
+        "A guide to playing Lingo with Archipelago.",
+        "English",
+        "setup_en.md",
+        "setup/en",
+        ["hatkirby"]
+    )]
+
+
+class LingoWorld(World):
+    """
+    Lingo is a first person indie puzzle game in the vein of The Witness. You find yourself in a mazelike, non-Euclidean
+    world filled with 800 word puzzles that use a variety of different mechanics.
+    """
+    game = "Lingo"
+    web = LingoWebWorld()
+
+    base_id = 444400
+    topology_present = True
+    data_version = 1
+
+    static_logic = StaticLingoLogic()
+    static_items = StaticLingoItems(base_id)
+    static_locat = StaticLingoLocations(base_id)
+    option_definitions = lingo_options
+
+    item_name_to_id = {
+        name: data.code for name, data in static_items.ALL_ITEM_TABLE.items()
+    }
+    location_name_to_id = {
+        name: data.code for name, data in static_locat.ALL_LOCATION_TABLE.items()
+        if data.code is not None
+    }
+
+    # This is just used for unit testing. It should remain at the default values for actual play.
+    test_options: LingoTestOptions = LingoTestOptions()
+
+    def _get_slot_data(self):
+        return {
+            'door_ids_by_item_id': {
+                data.code: data.door_ids for data in self.static_items.ALL_ITEM_TABLE.values()
+                if data.code is not None and len(data.door_ids) > 0
+            },
+            'painting_ids_by_item_id': {
+                data.code: data.painting_ids for data in self.static_items.ALL_ITEM_TABLE.values()
+                if data.code is not None and len(data.painting_ids) > 0
+            },
+            'panel_ids_by_location_id': {
+                data.code: data.panel_ids() for data in self.static_locat.ALL_LOCATION_TABLE.values()
+                if data.code is not None
+            },
+            'seed': self.multiworld.per_slot_randoms[self.player].randint(0, 1000000),
+        }
+
+    def generate_early(self):
+        self.player_logic = LingoPlayerLogic(self.multiworld, self.player, self.static_logic, self.test_options)
+
+    def create_regions(self):
+        create_regions(self.multiworld, self.player, self.static_logic, self.player_logic)
+
+    def create_items(self):
+        pool = []
+
+        for name in self.player_logic.REAL_ITEMS:
+            new_item = self.create_item(name)
+            pool.append(new_item)
+
+        for location, item in self.player_logic.EVENT_LOC_TO_ITEM.items():
+            event_item = LingoItem(item, ItemClassification.progression, None, player=self.player)
+            location_obj = self.multiworld.get_location(location, self.player)
+            location_obj.place_locked_item(event_item)
+
+        if self.player_logic.FORCED_GOOD_ITEM != "":
+            new_item = self.create_item(self.player_logic.FORCED_GOOD_ITEM)
+            location_obj = self.multiworld.get_location("Starting Room - HI", self.player)
+            location_obj.place_locked_item(new_item)
+
+        item_difference = len(self.player_logic.REAL_LOCATIONS) - len(pool)
+        if item_difference > 0:
+            trap_percentage = get_option_value(self.multiworld, self.player, "trap_percentage")
+            traps = floor(item_difference * trap_percentage / 100.0)
+            non_traps = item_difference - traps
+
+            for i in range(0, non_traps):
+                pool.append(self.create_item("Nothing"))
+
+            if traps > 0:
+                traps_list = ["Slowness Trap", "Iceland Trap", "Atbash Trap"]
+
+                for i in range(0, traps):
+                    pool.append(self.create_item(traps_list[i % len(traps_list)]))
+
+        self.multiworld.itempool += pool
+
+    def create_item(self, name: str) -> Item:
+        item = StaticLingoItems.ALL_ITEM_TABLE[name]
+
+        if item.progression:
+            classification = ItemClassification.progression
+        elif item.trap:
+            classification = ItemClassification.trap
+        else:
+            classification = ItemClassification.filler
+
+        new_item = LingoItem(name, classification, item.code, player=self.player)
+        return new_item
+
+    def set_rules(self):
+        set_rules(self.multiworld, self.player, self.player_logic)
+
+        self.multiworld.completion_condition[self.player] = \
+            lambda state: state.has("Victory", self.player)
+
+    def fill_slot_data(self):
+        slot_data = self._get_slot_data()
+
+        for option_name in lingo_options:
+            slot_data[option_name] = get_option_value(self.multiworld, self.player, option_name)
+
+        if get_option_value(self.multiworld, self.player, "shuffle_paintings"):
+            slot_data["painting_entrance_to_exit"] = self.player_logic.PAINTING_MAPPING
+            slot_data["paintings"] = {
+                painting.id: {"orientation": painting.orientation, "move": painting.move}
+                for painting in self.static_logic.PAINTINGS.values()
+            }
+
+        return slot_data

worlds/lingo/docs/en_Lingo.md

@@ -0,0 +1,43 @@
+# Lingo
+
+## Where is the settings page?
+
+The [player settings page for this game](../player-settings) contains all the options you need to configure and export a
+config file.
+
+## What does randomization do to this game?
+
+There are a couple of modes of randomization currently available, and you can pick and choose which ones you would like
+to use.
+
+* **Door shuffle**: There are many doors in the game, which are opened by completing a set of panels. With door shuffle
+  on, the doors become items and only open up once you receive the corresponding item. The panel sets that would
+  ordinarily open the doors become locations.
+
+* **Color shuffle**: There are ten different colours of puzzle in the game, each representing a different mechanic. With
+  color
+  shuffle on, you would start with only access to white puzzles. Puzzles of other colours will require you to receive an
+  item in order to solve them (e.g. you can't solve any red puzzles until you receive the "Red" item).
+
+* **Panel shuffle**: Panel shuffling replaces the puzzles on each panel with different ones. So far, the only mode of
+  panel shuffling is "rearrange" mode, which simply shuffles the already-existing puzzles from the base game onto
+  different panels.
+
+* **Painting shuffle**: This randomizes the appearance of the paintings in the game, as well as which of them are warps,
+  and the locations that they warp you to. It is the equivalent of an entrance randomizer in another game.
+
+## What is a "check" in this game?
+
+Most panels / panel sets that open a door are now location checks, even if door shuffle is not enabled. Various other
+puzzles are also location checks, including the achievement panels for each area.
+
+## What about wall snipes?
+
+"Wall sniping" refers to the fact that you are able to solve puzzles on the other side of opaque walls. This randomizer
+does not change how wall snipes work, but it will never require the use of them. There are three puzzles from the base
+game that you would ordinarily be expected to wall snipe. The randomizer moves these panels out of the wall or otherwise
+reveals them so that a snipe is not necessary.
+
+Because of this, all wall snipes are considered out of logic. This includes sniping The Bearer's MIDDLE while standing
+outside The Bold, sniping The Colorful without opening all of the color doors, and sniping WELCOME from next to WELCOME
+BACK.

worlds/lingo/docs/setup_en.md

@@ -0,0 +1,38 @@
+# Lingo Randomizer Setup
+
+## Required Software
+
+- [Lingo](https://store.steampowered.com/app/1814170/Lingo/)
+- [Lingo Archipelago Randomizer](https://github.com/hatkirby/lingo-archipelago/releases)
+
+## Optional Software
+
+- [Archipelago Text Client](https://github.com/ArchipelagoMW/Archipelago/releases)
+- [Lingo AP Tracker](https://github.com/hatkirby/lingo-ap-tracker/releases)
+
+## Installation
+
+1. Download the Lingo Archipelago Randomizer from the above link.
+2. Open up Lingo, go to settings, and click View Game Data. This should open up a folder in Windows Explorer.
+3. Unzip the contents of the randomizer into the "maps" folder.
+4. Installation complete! You may have to click Return to go back to the main menu and then click Settings again in
+   order to get the randomizer to show up in the level selection list.
+
+## Joining a Multiworld game
+
+1. Launch Lingo
+2. Click on Settings, and then Level. Choose Archipelago from the list.
+3. Start a new game. Leave the name field blank (anything you type in will be ignored).
+4. Enter the Archipelago address, slot name, and password into the fields.
+5. Press Connect.
+6. Enjoy!
+
+To continue an earlier game, you can perform the exact same steps as above. You do not have to re-select Archipelago in
+the level selection screen if you were using Archipelago the last time you launched the game.
+
+In order to play the base game again, simply return to the level selection screen and choose Level 1 (or whatever else
+you want to play). The randomizer will not affect gameplay unless you launch it by starting a new game while it is
+selected in the level selection screen, so it is safe to play the game normally while the client is installed.
+
+**Note**: Running the randomizer modifies the game's memory. If you want to play the base game after playing the randomizer,
+you need to restart Lingo first.