Lingo: New game

worlds/lingo/Options.py

@@ -0,0 +1,125 @@
+from typing import Dict
+from Options import Toggle, 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 LocationChecks(Choice):
+    """On "normal", there will be a location check for each panel set that would ordinarily open a door, as well as for
+    achievement panels and a small handful of other panels.
+    On "reduced", many of the locations that are associated with opening doors are removed.
+    On "insanity", every individual panel in the game is a location check."""
+    display_name = "Location Checks"
+    option_normal = 0
+    option_reduced = 1
+    option_insanity = 2
+
+
+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
+    option_level_2 = 2
+
+
+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 Level2Requirement(Range):
+    """The number of panel solves required to unlock LEVEL 2.
+    In the base game, 223 are needed.
+    Note that this count includes ANOTHER TRY.
+    """
+    display_name = "Level 2 Requirement"
+    range_start = 2
+    range_end = 800
+    default = 223
+
+
+class EarlyColorHallways(Toggle):
+    """When on, a painting warp to the color hallways area will appear in the starting room.
+    This lets you avoid being trapped in the starting room for long periods of time when door shuffle is on."""
+    display_name = "Early Color Hallways"
+
+
+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 PuzzleSkipPercentage(Range):
+    """Replaces junk items with puzzle skips, at the specified rate."""
+    display_name = "Puzzle Skip 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,
+    "location_checks": LocationChecks,
+    "shuffle_colors": ShuffleColors,
+    "shuffle_panels": ShufflePanels,
+    "shuffle_paintings": ShufflePaintings,
+    "victory_condition": VictoryCondition,
+    "mastery_achievements": MasteryAchievements,
+    "level_2_requirement": Level2Requirement,
+    "early_color_hallways": EarlyColorHallways,
+    "trap_percentage": TrapPercentage,
+    "puzzle_skip_percentage": PuzzleSkipPercentage,
+    "death_link": DeathLink
+}

worlds/lingo/__init__.py

@@ -0,0 +1,111 @@
+"""
+Archipelago init file for Lingo
+"""
+
+from BaseClasses import Item, Tutorial
+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
+from .testing import LingoTestOptions
+from .player_logic import LingoPlayerLogic
+from .regions import create_regions
+
+
+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(static_logic)
+    static_locat = StaticLingoLocations(static_logic)
+    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()
+    }
+
+    def generate_early(self):
+        self.player_logic = LingoPlayerLogic(self, self.static_logic, self.static_items, self.static_locat)
+
+    def create_regions(self):
+        create_regions(self, self.static_logic, self.player_logic)
+
+    def create_items(self):
+        pool = [self.create_item(name) for name in self.player_logic.REAL_ITEMS]
+
+        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:
+            trap_percentage = getattr(self.multiworld, "trap_percentage")[self.player]
+            traps = int(item_difference * trap_percentage / 100.0)
+            non_traps = item_difference - traps
+
+            if non_traps:
+                skip_percentage = getattr(self.multiworld, "puzzle_skip_percentage")[self.player]
+                skips = int(non_traps * skip_percentage / 100.0)
+                non_skips = non_traps - skips
+
+                filler_list = [":)", "The Feeling of Being Lost", "Wanderlust", "Empty White Hallways"]
+                for i in range(0, non_skips):
+                    pool.append(self.create_item(filler_list[i % len(filler_list)]))
+
+                for i in range(0, skips):
+                    pool.append(self.create_item("Puzzle Skip"))
+
+            if traps:
+                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 = self.static_items.ALL_ITEM_TABLE[name]
+        return LingoItem(name, item.classification, item.code, player=self.player)
+
+    def set_rules(self):
+        self.multiworld.completion_condition[self.player] = \
+            lambda state: state.has("Victory", self.player)
+
+    def fill_slot_data(self):
+        slot_data = {"seed": self.random.randint(0, 1000000)}
+
+        for option_name in ["death_link", "victory_condition", "shuffle_colors", "shuffle_doors", "shuffle_paintings",
+                            "shuffle_panels", "mastery_achievements", "level_2_requirement", "location_checks",
+                            "early_color_hallways"]:
+            slot_data[option_name] = int(getattr(self.multiworld, option_name)[self.player])
+
+        if getattr(self.multiworld, "shuffle_paintings")[self.player]:
+            slot_data["painting_entrance_to_exit"] = self.player_logic.PAINTING_MAPPING
+
+        return slot_data

worlds/lingo/docs/en_Lingo.md

@@ -0,0 +1,42 @@
+# 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 colors 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 colors 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.