1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
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
|
"""
Archipelago init file for Lingo 2
"""
from typing import ClassVar
from BaseClasses import ItemClassification, Item, Tutorial
from Options import OptionError
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 worlds.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()
start_game: bool = True
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):
if hasattr(self.multiworld, "re_gen_passthrough") and "Lingo 2" in self.multiworld.re_gen_passthrough:
self.player_logic.rte_mapping = [self.world.static_logic.map_id_by_name[map_name]
for map_name in self.multiworld.re_gen_passthrough["Lingo 2"]["rte"]]
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 = {
self.static_logic.port_id_by_ap_id[int(fp)]: self.static_logic.port_id_by_ap_id[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()))
if not any(ItemClassification.progression in item.classification for item in pool):
raise OptionError(f"Lingo 2 player {self.player} has no progression items. Please enable at least one "
f"option that would add progression gating to your world, such as Shuffle Doors or "
f"Shuffle Letters.")
self.multiworld.itempool += pool
for name in self.player_logic.starting_items:
self.push_precollected(self.create_item(name))
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_only",
"daedalus_roof_access",
"enable_gift_maps",
"enable_icarus",
"endings_requirement",
"fast_travel_access",
"keyholder_sanity",
"masteries_requirement",
"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),
"rte": [self.static_logic.objects.maps[map_id].name for map_id in self.player_logic.rte_mapping],
"version": self.static_logic.get_data_version(),
}
if self.options.shuffle_worldports:
def get_port_ap_id(port_id):
return self.static_logic.objects.ports[port_id].ap_id
slot_data["port_pairings"] = {get_port_ap_id(from_id): get_port_ap_id(to_id)
for from_id, to_id in self.port_pairings.items()}
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)
|
