"""
Archipelago init file for Lingo 2
"""
from typing import ClassVar
from BaseClasses import ItemClassification, Item, Tutorial
from settings import Group, UserFilePath
from worlds.AutoWorld import WebWorld, World
from .items import Lingo2Item, ANTI_COLLECTABLE_TRAPS
from .options import Lingo2Options
from .player_logic import Lingo2PlayerLogic
from .regions import create_regions, shuffle_entrances, connect_ports_from_ut
from .static_logic import Lingo2StaticLogic
from .version import APWORLD_VERSION
from ..LauncherComponents import Component, Type, components, launch as launch_component, icon_paths
class Lingo2WebWorld(WebWorld):
rich_text_options_doc = True
theme = "grass"
tutorials = [Tutorial(
"Multiworld Setup Guide",
"A guide to playing Lingo 2 with Archipelago.",
"English",
"en_Lingo_2.md",
"setup/en",
["hatkirby"]
)]
class Lingo2Settings(Group):
class ExecutableFile(UserFilePath):
"""Path to the Lingo 2 executable"""
is_exe = True
exe_file: ExecutableFile = ExecutableFile()
class Lingo2World(World):
"""
Lingo 2 is a first person indie puzzle game where you solve word puzzles in a labyrinthe world. Compared to its
predecessor, Lingo 2 has new mechanics, more areas, and a unique progression system where you have to unlock letters
before using them in puzzle solutions.
"""
game = "Lingo 2"
web = Lingo2WebWorld()
settings: ClassVar[Lingo2Settings]
settings_key = "lingo2_options"
topology_present = True
options_dataclass = Lingo2Options
options: Lingo2Options
static_logic = Lingo2StaticLogic()
item_name_to_id = static_logic.item_name_to_id
location_name_to_id = static_logic.location_name_to_id
item_name_groups = static_logic.item_name_groups
location_name_groups = static_logic.location_name_groups
for_tracker: ClassVar[bool] = False
player_logic: Lingo2PlayerLogic
port_pairings: dict[int, int]
def generate_early(self):
self.player_logic = Lingo2PlayerLogic(self)
self.port_pairings = {}
def create_regions(self):
create_regions(self)
def connect_entrances(self):
if self.options.shuffle_worldports:
if hasattr(self.multiworld, "re_gen_passthrough") and "Lingo 2" in self.multiworld.re_gen_passthrough:
slot_value = self.multiworld.re_gen_passthrough["Lingo 2"]["port_pairings"]
self.port_pairings = {int(fp): int(tp) for fp, tp in slot_value.items()}
connect_ports_from_ut(self.port_pairings, self)
else:
shuffle_entrances(self)
from Utils import visualize_regions
visualize_regions(self.multiworld.get_region("Menu", self.player), "my_world.puml")
def create_items(self):
pool = [self.create_item(name) for name in self.player_logic.real_items]
total_locations = sum(len(locs) for locs in self.player_logic.locations_by_room.values())
item_difference = total_locations - len(pool)
if self.options.trap_percentage > 0:
num_traps = int(item_difference * self.options.trap_percentage / 100)
item_difference = item_difference - num_traps
trap_names = []
trap_weights = []
for letter_name, weight in self.static_logic.letter_weights.items():
trap_names.append(f"Anti {letter_name}")
trap_weights.append(weight)
bad_letters = self.random.choices(trap_names, weights=trap_weights, k=num_traps)
pool += [self.create_item(trap_name) for trap_name in bad_letters]
for i in range(0, item_difference):
pool.append(self.create_item(self.get_filler_item_name()))
self.multiworld.itempool += pool
def create_item(self, name: str) -> Item:
return Lingo2Item(name, ItemClassification.filler if name == self.get_filler_item_name() else
ItemClassification.trap if name in ANTI_COLLECTABLE_TRAPS else
ItemClassification.progression,
self.item_name_to_id.get(name), 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_options = [
"cyan_door_behavior",
"daedalus_roof_access",
"keyholder_sanity",
"shuffle_control_center_colors",
"shuffle_doors",
"shuffle_gallery_paintings",
"shuffle_letters",
"shuffle_symbols",
"shuffle_worldports",
"strict_cyan_ending",
"strict_purple_ending",
"victory_condition",
]
slot_data: dict[str, object] = {
**self.options.as_dict(*slot_options),
"version": [self.static_logic.get_data_version(), APWORLD_VERSION],
}
if self.options.shuffle_worldports:
slot_data["port_pairings"] = self.port_pairings
return slot_data
def get_filler_item_name(self) -> str:
return "A Job Well Done"
# for the universal tracker, doesn't get called in standard gen
# docs: https://github.com/FarisTheAncient/Archipelago/blob/tracker/worlds/tracker/docs/re-gen-passthrough.md
@staticmethod
def interpret_slot_data(slot_data: dict[str, object]) -> dict[str, object]:
# returning slot_data so it regens, giving it back in multiworld.re_gen_passthrough
# we are using re_gen_passthrough over modifying the world here due to complexities with ER
return slot_data
def launch_client(*args):
from .context import client_main
launch_component(client_main, name="Lingo2Client", args=args)
icon_paths["lingo2_ico"] = f"ap:{__name__}/logo.png"
component = Component("Lingo 2 Client", component_type=Type.CLIENT, func=launch_client,
description="Open Lingo 2.", supports_uri=True, game_name="Lingo 2", icon="lingo2_ico")
components.append(component)
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
from enum import IntEnum, auto
from .generated import data_pb2 as data_pb2
from .items import SYMBOL_ITEMS
from typing import TYPE_CHECKING, NamedTuple
from .options import VictoryCondition, ShuffleLetters, CyanDoorBehavior
if TYPE_CHECKING:
from . import Lingo2World
def calculate_letter_histogram(solution: str) -> dict[str, int]:
histogram = dict()
for l in solution:
if l.isalpha():
real_l = l.upper()
histogram[real_l] = min(histogram.get(real_l, 0) + 1, 2)
return histogram
class AccessRequirements:
items: set[str]
progressives: dict[str, int]
rooms: set[str]
letters: dict[str, int]
cyans: bool
# This is an AND of ORs.
or_logic: list[list["AccessRequirements"]]
def __init__(self):
self.items = set()
self.progressives = dict()
self.rooms = set()
self.letters = dict()
self.cyans = False
self.or_logic = list()
def merge(self, other: "AccessRequirements"):
for item in other.items:
self.items.add(item)
for item, amount in other.progressives.items():
self.progressives[item] = max(amount, self.progressives.get(item, 0))
for room in other.rooms:
self.rooms.add(room)
for letter, level in other.letters.items():
self.letters[letter] = max(self.letters.get(letter, 0), level)
self.cyans = self.cyans or other.cyans
for disjunction in other.or_logic:
self.or_logic.append(disjunction)
def is_empty(self) -> bool:
return (len(self.items) == 0 and len(self.progressives) == 0 and len(self.rooms) == 0 and len(self.letters) == 0
and not self.cyans and len(self.or_logic) == 0)
def __repr__(self):
parts = []
if len(self.items) > 0:
parts.append(f"items={self.items}")
if len(self.progressives) > 0:
parts.append(f"progressives={self.progressives}")
if len(self.rooms) > 0:
parts.append(f"rooms={self.rooms}")
if len(self.letters) > 0:
parts.append(f"letters={self.letters}")
if self.cyans:
parts.append(f"cyans=True")
if len(self.or_logic) > 0:
parts.append(f"or_logic={self.or_logic}")
return f"AccessRequirements({", ".join(parts)})"
class PlayerLocation(NamedTuple):
code: int | None
reqs: AccessRequirements
class LetterBehavior(IntEnum):
VANILLA = auto()
ITEM = auto()
UNLOCKED = auto()
class Lingo2PlayerLogic:
world: "Lingo2World"
locations_by_room: dict[int, list[PlayerLocation]]
event_loc_item_by_room: dict[int, dict[str, str]]
item_by_door: dict[int, tuple[str, int]]
panel_reqs: dict[int, AccessRequirements]
proxy_reqs: dict[int, dict[str, AccessRequirements]]
door_reqs: dict[int, AccessRequirements]
real_items: list[str]
double_letter_amount: dict[str, int]
def __init__(self, world: "Lingo2World"):
self.world = world
self.locations_by_room = {}
self.event_loc_item_by_room = {}
self.item_by_door = {}
self.panel_reqs = dict()
self.proxy_reqs = dict()
self.door_reqs = dict()
self.real_items = list()
self.double_letter_amount = dict()
if self.world.options.shuffle_doors:
for progressive in world.static_logic.objects.progressives:
for i in range(0, len(progressive.doors)):
self.item_by_door[progressive.doors[i]] = (progressive.name, i + 1)
self.real_items.append(progressive.name)
for door_group in world.static_logic.objects.door_groups:
if door_group.type == data_pb2.DoorGroupType.CONNECTOR:
if not self.world.options.shuffle_doors:
continue
elif door_group.type == data_pb2.DoorGroupType.COLOR_CONNECTOR:
if not self.world.options.shuffle_control_center_colors:
continue
elif door_group.type == data_pb2.DoorGroupType.SHUFFLE_GROUP:
if not self.world.options.shuffle_doors:
continue
else:
continue
for door in door_group.doors:
self.item_by_door[door] = (door_group.name, 1)
self.real_items.append(door_group.name)
# We iterate through the doors in two parts because it is essential that we determine which doors are shuffled
# before we calculate any access requirements.
for door in world.static_logic.objects.doors:
if door.type in [data_pb2.DoorType.EVENT, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
continue
if door.id in self.item_by_door:
continue
if (door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.ITEM_ONLY] and
not self.world.options.shuffle_doors):
continue
if (door.type == data_pb2.DoorType.CONTROL_CENTER_COLOR and
not self.world.options.shuffle_control_center_colors):
continue
door_item_name = self.world.static_logic.get_door_item_name(door)
self.item_by_door[door.id] = (door_item_name, 1)
self.real_items.append(door_item_name)
# We handle cyan_door_behavior = Item after door shuffle, because cyan doors that are impacted by door shuffle
# should be exempt from cyan_door_behavior.
if world.options.cyan_door_behavior == CyanDoorBehavior.option_item:
for door_group in world.static_logic.objects.door_groups:
if door_group.type != data_pb2.DoorGroupType.CYAN_DOORS:
continue
for door in door_group.doors:
if not door in self.item_by_door:
self.item_by_door[door] = (door_group.name, 1)
self.real_items.append(door_group.name)
for door in world.static_logic.objects.doors:
if door.type in [data_pb2.DoorType.STANDARD, data_pb2.DoorType.LOCATION_ONLY, data_pb2.DoorType.GRAVESTONE]:
self.locations_by_room.setdefault(door.room_id, []).append(PlayerLocation(door.ap_id,
self.get_door_reqs(door.id)))
for letter in world.static_logic.objects.letters:
self.locations_by_room.setdefault(letter.room_id, []).append(PlayerLocation(letter.ap_id,
AccessRequirements()))
behavior = self.get_letter_behavior(letter.key, letter.level2)
if behavior == LetterBehavior.VANILLA:
letter_name = f"{letter.key.upper()}{'2' if letter.level2 else '1'}"
event_name = f"{letter_name} (Collected)"
self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
if letter.level2:
event_name = f"{letter_name} (Double Collected)"
self.event_loc_item_by_room.setdefault(letter.room_id, {})[event_name] = letter.key.upper()
elif behavior == LetterBehavior.ITEM:
self.real_items.append(letter.key.upper())
if behavior != LetterBehavior.UNLOCKED:
self.double_letter_amount[letter.key.upper()] = self.double_letter_amount.get(letter.key.upper(), 0) + 1
for mastery in world.static_logic.objects.masteries:
self.locations_by_room.setdefault(mastery.room_id, []).append(PlayerLocation(mastery.ap_id,
AccessRequirements()))
for ending in world.static_logic.objects.endings:
# Don't ever create a location for White Ending. Don't even make an event for it if it's not the victory
# condition, since it is necessarily going to be in the postgame.
if ending.name == "WHITE":
if self.world.options.victory_condition != VictoryCondition.option_white_ending:
continue
else:
self.locations_by_room.setdefault(ending.room_id, []).append(PlayerLocation(ending.ap_id,
AccessRequirements()))
event_name = f"{ending.name.capitalize()} Ending (Achieved)"
item_name = event_name
if world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
item_name = "Victory"
self.event_loc_item_by_room.setdefault(ending.room_id, {})[event_name] = item_name
if self.world.options.keyholder_sanity:
for keyholder in world.static_logic.objects.keyholders:
if keyholder.HasField("key"):
reqs = AccessRequirements()
if self.get_letter_behavior(keyholder.key, False) != LetterBehavior.UNLOCKED:
reqs.letters[keyholder.key.upper()] = 1
self.locations_by_room.setdefault(keyholder.room_id, []).append(PlayerLocation(keyholder.ap_id,
reqs))
if self.world.options.shuffle_symbols:
for symbol_name in SYMBOL_ITEMS.values():
self.real_items.append(symbol_name)
def get_panel_reqs(self, panel_id: int, answer: str | None) -> AccessRequirements:
if answer is None:
if panel_id not in self.panel_reqs:
self.panel_reqs[panel_id] = self.calculate_panel_reqs(panel_id, answer)
return self.panel_reqs.get(panel_id)
else:
if panel_id not in self.proxy_reqs or answer not in self.proxy_reqs.get(panel_id):
self.proxy_reqs.setdefault(panel_id, {})[answer] = self.calculate_panel_reqs(panel_id, answer)
return self.proxy_reqs.get(panel_id).get(answer)
def calculate_panel_reqs(self, panel_id: int, answer: str | None) -> AccessRequirements:
panel = self.world.static_logic.objects.panels[panel_id]
reqs = AccessRequirements()
reqs.rooms.add(self.world.static_logic.get_room_region_name(panel.room_id))
if answer is not None:
self.add_solution_reqs(reqs, answer)
elif len(panel.proxies) > 0:
possibilities = []
already_filled = False
for proxy in panel.proxies:
proxy_reqs = AccessRequirements()
self.add_solution_reqs(proxy_reqs, proxy.answer)
if not proxy_reqs.is_empty():
possibilities.append(proxy_reqs)
else:
already_filled = True
break
if not already_filled and not any(proxy.answer == panel.answer for proxy in panel.proxies):
proxy_reqs = AccessRequirements()
self.add_solution_reqs(proxy_reqs, panel.answer)
if not proxy_reqs.is_empty():
possibilities.append(proxy_reqs)
else:
already_filled = True
if not already_filled:
reqs.or_logic.append(possibilities)
else:
self.add_solution_reqs(reqs, panel.answer)
if self.world.options.shuffle_symbols:
for symbol in panel.symbols:
reqs.items.add(SYMBOL_ITEMS.get(symbol))
if panel.HasField("required_door"):
door_reqs = self.get_door_open_reqs(panel.required_door)
reqs.merge(door_reqs)
if panel.HasField("required_room"):
reqs.rooms.add(self.world.static_logic.get_room_region_name(panel.required_room))
return reqs
# This gets/calculates the requirements described by the door object. This is most notably used as the requirements
# for clearing a location, or opening a door when the door is not shuffled.
def get_door_reqs(self, door_id: int) -> AccessRequirements:
if door_id not in self.door_reqs:
self.door_reqs[door_id] = self.calculate_door_reqs(door_id)
return self.door_reqs.get(door_id)
def calculate_door_reqs(self, door_id: int) -> AccessRequirements:
door = self.world.static_logic.objects.doors[door_id]
reqs = AccessRequirements()
# TODO: lavender_cubes, endings
if not door.HasField("complete_at") or door.complete_at == 0:
for proxy in door.panels:
panel_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
reqs.merge(panel_reqs)
elif door.complete_at == 1:
disjunction = []
for proxy in door.panels:
proxy_reqs = self.get_panel_reqs(proxy.panel, proxy.answer if proxy.HasField("answer") else None)
if proxy_reqs.is_empty():
disjunction.clear()
break
else:
disjunction.append(proxy_reqs)
if len(disjunction) > 0:
reqs.or_logic.append(disjunction)
else:
# TODO: Handle complete_at > 1
pass
if door.HasField("control_center_color"):
# TODO: Logic for ensuring two CC states aren't needed at once.
reqs.rooms.add("Control Center - Main Area")
self.add_solution_reqs(reqs, door.control_center_color)
if door.double_letters:
if self.world.options.cyan_door_behavior == CyanDoorBehavior.option_collect_h2:
reqs.rooms.add("The Repetitive - Main Room")
elif self.world.options.cyan_door_behavior == CyanDoorBehavior.option_any_double_letter:
if self.world.options.shuffle_letters != ShuffleLetters.option_unlocked:
reqs.cyans = True
elif self.world.options.cyan_door_behavior == CyanDoorBehavior.option_item:
# There shouldn't be any locations that are cyan doors.
pass
for keyholder_uses in door.keyholders:
key_name = keyholder_uses.key.upper()
if (self.get_letter_behavior(keyholder_uses.key, False) != LetterBehavior.UNLOCKED
and key_name not in reqs.letters):
reqs.letters[key_name] = 1
keyholder = self.world.static_logic.objects.keyholders[keyholder_uses.keyholder]
reqs.rooms.add(self.world.static_logic.get_room_region_name(keyholder.room_id))
for room in door.rooms:
reqs.rooms.add(self.world.static_logic.get_room_region_name(room))
for ending_id in door.endings:
ending = self.world.static_logic.objects.endings[ending_id]
if self.world.options.victory_condition.current_key.removesuffix("_ending").upper() == ending.name:
reqs.items.add("Victory")
else:
reqs.items.add(f"{ending.name.capitalize()} Ending (Achieved)")
for sub_door_id in door.doors:
sub_reqs = self.get_door_open_reqs(sub_door_id)
reqs.merge(sub_reqs)
return reqs
# This gets the requirements to open a door within the world. When a door is shuffled, this means having the item
# that acts as the door's key.
def get_door_open_reqs(self, door_id: int) -> AccessRequirements:
if door_id in self.item_by_door:
reqs = AccessRequirements()
item_name, amount = self.item_by_door.get(door_id)
if amount == 1:
reqs.items.add(item_name)
else:
reqs.progressives[item_name] = amount
return reqs
else:
return self.get_door_reqs(door_id)
def get_letter_behavior(self, letter: str, level2: bool) -> LetterBehavior:
if self.world.options.shuffle_letters == ShuffleLetters.option_unlocked:
return LetterBehavior.UNLOCKED
if self.world.options.shuffle_letters in [ShuffleLetters.option_vanilla_cyan, ShuffleLetters.option_item_cyan]:
if level2:
if self.world.options.shuffle_letters == ShuffleLetters.option_vanilla_cyan:
return LetterBehavior.VANILLA
else:
return LetterBehavior.ITEM
else:
return LetterBehavior.UNLOCKED
if not level2 and letter in ["h", "i", "n", "t"]:
return LetterBehavior.UNLOCKED
if self.world.options.shuffle_letters == ShuffleLetters.option_progressive:
return LetterBehavior.ITEM
return LetterBehavior.VANILLA
def add_solution_reqs(self, reqs: AccessRequirements, solution: str):
histogram = calculate_letter_histogram(solution)
for l, a in histogram.items():
needed = min(a, 2)
level2 = (needed == 2)
if level2 and self.get_letter_behavior(l.lower(), True) == LetterBehavior.UNLOCKED:
needed = 1
if self.get_letter_behavior(l.lower(), False) == LetterBehavior.UNLOCKED:
needed = needed - 1
if needed > 0:
reqs.letters[l] = max(reqs.letters.get(l, 0), needed)
|