Update remaining clients currently in main to use explicit lookup w…

…ith game name.

WargrooveClient.py

@@ -197,7 +197,7 @@ def on_package(self, cmd: str, args: dict):
                     open(print_path, 'w').close()
                     with open(print_path, 'w') as f:
                         f.write("Received " +
-                                self.item_names[network_item.item] +
+                                self.item_names[self.game][network_item.item] +
                                 " from " +
                                 self.player_names[network_item.player])
                         f.close()
@@ -342,7 +342,7 @@ def update_commander_data(self):
             faction_items = 0
             faction_item_names = [faction + ' Commanders' for faction in faction_table.keys()]
             for network_item in self.items_received:
-                if self.item_names[network_item.item] in faction_item_names:
+                if self.item_names[self.game][network_item.item] in faction_item_names:
                     faction_items += 1
             starting_groove = (faction_items - 1) * self.starting_groove_multiplier
             # Must be an integer larger than 0

Zelda1Client.py

@@ -152,7 +152,7 @@ def get_payload(ctx: ZeldaContext):
 
 
 def reconcile_shops(ctx: ZeldaContext):
-    checked_location_names = [ctx.location_names[location] for location in ctx.checked_locations]
+    checked_location_names = [ctx.location_names[ctx.game][location] for location in ctx.checked_locations]
     shops = [location for location in checked_location_names if "Shop" in location]
     left_slots = [shop for shop in shops if "Left" in shop]
     middle_slots = [shop for shop in shops if "Middle" in shop]
@@ -190,7 +190,7 @@ async def parse_locations(locations_array, ctx: ZeldaContext, force: bool, zone=
         locations_checked = []
         location = None
         for location in ctx.missing_locations:
-            location_name = ctx.location_names[location]
+            location_name = ctx.location_names[ctx.game][location]
 
             if location_name in Locations.overworld_locations and zone == "overworld":
                 status = locations_array[Locations.major_location_offsets[location_name]]

worlds/alttp/Client.py

@@ -551,10 +551,11 @@ async def game_watcher(self, ctx):
         if recv_index < len(ctx.items_received) and recv_item == 0:
             item = ctx.items_received[recv_index]
             recv_index += 1
+            sending_game = ctx.slot_info[item.player].game
             logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_names[item.item], 'red', 'bold'),
+                color(ctx.item_names[ctx.game][item.item], 'red', 'bold'),
                 color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_names[item.location], recv_index, len(ctx.items_received)))
+                ctx.location_names[sending_game][item.location], recv_index, len(ctx.items_received)))
 
             snes_buffered_write(ctx, RECV_PROGRESS_ADDR,
                                 bytes([recv_index & 0xFF, (recv_index >> 8) & 0xFF]))

worlds/cv64/client.py

@@ -146,7 +146,7 @@ async def game_watcher(self, ctx: "BizHawkClientContext") -> None:
                         text_color = bytearray([0xA2, 0x0B])
                     else:
                         text_color = bytearray([0xA2, 0x02])
-                    received_text, num_lines = cv64_text_wrap(f"{ctx.item_names[next_item.item]}\n"
+                    received_text, num_lines = cv64_text_wrap(f"{ctx.item_names[ctx.game][next_item.item]}\n"
                                                               f"from {ctx.player_names[next_item.player]}", 96)
                     await bizhawk.guarded_write(ctx.bizhawk_ctx,
                                                 [(0x389BE1, [next_item.item & 0xFF], "RDRAM"),

worlds/dkc3/Client.py

@@ -86,7 +86,7 @@ async def game_watcher(self, ctx):
 
         for new_check_id in new_checks:
             ctx.locations_checked.add(new_check_id)
-            location = ctx.location_names[new_check_id]
+            location = ctx.location_names[ctx.game][new_check_id]
             snes_logger.info(
                 f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
             await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": [new_check_id]}])
@@ -98,10 +98,11 @@ async def game_watcher(self, ctx):
         if recv_index < len(ctx.items_received):
             item = ctx.items_received[recv_index]
             recv_index += 1
+            sending_game = ctx.slot_info[item.player].game
             logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_names[item.item], 'red', 'bold'),
+                color(ctx.item_names[ctx.game][item.item], 'red', 'bold'),
                 color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_names[item.location], recv_index, len(ctx.items_received)))
+                ctx.location_names[sending_game][item.location], recv_index, len(ctx.items_received)))
 
             snes_buffered_write(ctx, DKC3_RECV_PROGRESS_ADDR, bytes([recv_index]))
             if item.item in item_rom_data:

worlds/factorio/Client.py

@@ -247,7 +247,7 @@ async def game_watcher(ctx: FactorioContext):
                     if ctx.locations_checked != research_data:
                         bridge_logger.debug(
                             f"New researches done: "
-                            f"{[ctx.location_names[rid] for rid in research_data - ctx.locations_checked]}")
+                            f"{[ctx.location_names[ctx.game][rid] for rid in research_data - ctx.locations_checked]}")
                         ctx.locations_checked = research_data
                         await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": tuple(research_data)}])
                     death_link_tick = data.get("death_link_tick", 0)
@@ -360,7 +360,7 @@ async def factorio_server_watcher(ctx: FactorioContext):
                     transfer_item: NetworkItem = ctx.items_received[ctx.send_index]
                     item_id = transfer_item.item
                     player_name = ctx.player_names[transfer_item.player]
-                    item_name = ctx.item_names[item_id]
+                    item_name = ctx.item_names[ctx.game][item_id]
                     factorio_server_logger.info(f"Sending {item_name} to Nauvis from {player_name}.")
                     commands[ctx.send_index] = f"/ap-get-technology {item_name}\t{ctx.send_index}\t{player_name}"
                     ctx.send_index += 1

worlds/kdl3/Client.py

@@ -329,10 +329,11 @@ async def game_watcher(self, ctx) -> None:
             if recv_amount < len(ctx.items_received):
                 item = ctx.items_received[recv_amount]
                 recv_amount += 1
+                sending_game = ctx.slot_info[item.player].game
                 logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                    color(ctx.item_names[item.item], 'red', 'bold'),
+                    color(ctx.item_names[ctx.game][item.item], 'red', 'bold'),
                     color(ctx.player_names[item.player], 'yellow'),
-                    ctx.location_names[item.location], recv_amount, len(ctx.items_received)))
+                    ctx.location_names[sending_game][item.location], recv_amount, len(ctx.items_received)))
 
                 snes_buffered_write(ctx, KDL3_RECV_COUNT, pack("H", recv_amount))
                 item_idx = item.item & 0x00000F
@@ -415,7 +416,7 @@ async def game_watcher(self, ctx) -> None:
 
             for new_check_id in new_checks:
                 ctx.locations_checked.add(new_check_id)
-                location = ctx.location_names[new_check_id]
+                location = ctx.location_names[ctx.game][new_check_id]
                 snes_logger.info(
                     f'New Check: {location} ({len(ctx.locations_checked)}/'
                     f'{len(ctx.missing_locations) + len(ctx.checked_locations)})')

worlds/lufia2ac/Client.py

@@ -145,11 +145,12 @@ async def game_watcher(self, ctx: SNIContext) -> None:
                 item: NetworkItem = ctx.items_received[snes_items_received]
                 item_code: int = item.item - items_start_id
                 snes_items_received += 1
+                sending_game = ctx.slot_info[item.player].game
 
                 snes_logger.info("Received %s from %s (%s) (%d/%d in list)" % (
-                    ctx.item_names[item.item],
+                    ctx.item_names[ctx.game][item.item],
                     ctx.player_names[item.player],
-                    ctx.location_names[item.location],
+                    ctx.location_names[sending_game][item.location],
                     snes_items_received, len(ctx.items_received)))
                 snes_buffered_write(ctx, L2AC_RX_ADDR + 2 * (snes_items_received + 1), item_code.to_bytes(2, "little"))
                 snes_buffered_write(ctx, L2AC_RX_ADDR, snes_items_received.to_bytes(2, "little"))

worlds/sc2/Client.py

@@ -244,10 +244,10 @@ def print_faction_title():
                     self.formatted_print(f" [u]{faction.name}[/u] ")
 
             for item_id in categorized_items[faction]:
-                item_name = self.ctx.item_names[item_id]
+                item_name = self.ctx.item_names[self.ctx.game][item_id]
                 received_child_items = items_received_set.intersection(parent_to_child.get(item_id, []))
                 matching_children = [child for child in received_child_items
-                                    if item_matches_filter(self.ctx.item_names[child])]
+                                    if item_matches_filter(self.ctx.item_names[self.ctx.game][child])]
                 received_items_of_this_type = items_received.get(item_id, [])
                 item_is_match = item_matches_filter(item_name)
                 if item_is_match or len(matching_children) > 0:
@@ -1165,7 +1165,7 @@ def request_unfinished_missions(ctx: SC2Context) -> None:
             objectives = set(ctx.locations_for_mission(mission))
             if objectives:
                 remaining_objectives = objectives.difference(ctx.checked_locations)
-                unfinished_locations[mission] = [ctx.location_names[location_id] for location_id in remaining_objectives]
+                unfinished_locations[mission] = [ctx.location_names[ctx.game][location_id] for location_id in remaining_objectives]
             else:
                 unfinished_locations[mission] = []
 

worlds/sc2/ClientGui.py

@@ -269,7 +269,7 @@ def sort_unfinished_locations(self, mission_name: str) -> Tuple[Dict[LocationTyp
         for loc in self.ctx.locations_for_mission(mission_name):
             if loc in self.ctx.missing_locations:
                 count += 1
-                locations[lookup_location_id_to_type[loc]].append(self.ctx.location_names[loc])
+                locations[lookup_location_id_to_type[loc]].append(self.ctx.location_names[self.ctx.game][loc])
 
         plando_locations = []
         for plando_loc in self.ctx.plando_locations:

worlds/sm/Client.py

@@ -123,7 +123,7 @@ async def game_watcher(self, ctx):
             location_id = locations_start_id + item_index
 
             ctx.locations_checked.add(location_id)
-            location = ctx.location_names[location_id]
+            location = ctx.location_names[ctx.game][location_id]
             snes_logger.info(
                 f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
             await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": [location_id]}])
@@ -150,10 +150,10 @@ async def game_watcher(self, ctx):
             item_out_ptr += 1
             snes_buffered_write(ctx, SM_RECV_QUEUE_WCOUNT,
                                 bytes([item_out_ptr & 0xFF, (item_out_ptr >> 8) & 0xFF]))
+            sending_game = ctx.slot_info[item.player].game
             logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_names[item.item], 'red', 'bold'),
+                color(ctx.item_names[ctx.game][item.item], 'red', 'bold'),
                 color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_names[item.location], item_out_ptr, len(ctx.items_received)))
+                ctx.location_names[sending_game][item.location], item_out_ptr, len(ctx.items_received)))
 
         await snes_flush_writes(ctx)
-

worlds/smw/Client.py

@@ -448,7 +448,7 @@ async def game_watcher(self, ctx):
 
         for new_check_id in new_checks:
             ctx.locations_checked.add(new_check_id)
-            location = ctx.location_names[new_check_id]
+            location = ctx.location_names[ctx.game][new_check_id]
             snes_logger.info(
                 f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
             await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": [new_check_id]}])
@@ -499,23 +499,24 @@ async def game_watcher(self, ctx):
         if recv_index < len(ctx.items_received):
             item = ctx.items_received[recv_index]
             recv_index += 1
+            sending_game = ctx.slot_info[item.player].game
             logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_names[item.item], 'red', 'bold'),
+                color(ctx.item_names[ctx.game][item.item], 'red', 'bold'),
                 color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_names[item.location], recv_index, len(ctx.items_received)))
+                ctx.location_names[sending_game][item.location], recv_index, len(ctx.items_received)))
 
             if self.should_show_message(ctx, item):
                 if item.item != 0xBC0012 and item.item not in trap_rom_data:
                     # Don't send messages for Boss Tokens
-                    item_name = ctx.item_names[item.item]
+                    item_name = ctx.item_names[ctx.game][item.item]
                     player_name = ctx.player_names[item.player]
 
                     receive_message = generate_received_text(item_name, player_name)
                     self.add_message_to_queue(receive_message)
 
             snes_buffered_write(ctx, SMW_RECV_PROGRESS_ADDR, bytes([recv_index&0xFF, (recv_index>>8)&0xFF]))
             if item.item in trap_rom_data:
-                item_name = ctx.item_names[item.item]
+                item_name = ctx.item_names[ctx.game][item.item]
                 player_name = ctx.player_names[item.player]
 
                 receive_message = generate_received_text(item_name, player_name)
@@ -596,7 +597,7 @@ async def game_watcher(self, ctx):
         for loc_id in ctx.checked_locations:
             if loc_id not in ctx.locations_checked:
                 ctx.locations_checked.add(loc_id)
-                loc_name = ctx.location_names[loc_id]
+                loc_name = ctx.location_names[ctx.game][loc_id]
 
                 if loc_name not in location_id_to_level_id:
                     continue

worlds/smz3/Client.py

@@ -109,7 +109,7 @@ async def game_watcher(self, ctx):
             location_id = locations_start_id + convertLocSMZ3IDToAPID(item_index)
 
             ctx.locations_checked.add(location_id)
-            location = ctx.location_names[location_id]
+            location = ctx.location_names[ctx.game][location_id]
             snes_logger.info(f'New Check: {location} ({len(ctx.locations_checked)}/{len(ctx.missing_locations) + len(ctx.checked_locations)})')
             await ctx.send_msgs([{"cmd": 'LocationChecks', "locations": [location_id]}])
 
@@ -131,9 +131,9 @@ async def game_watcher(self, ctx):
                                 bytes([player_id & 0xFF, (player_id >> 8) & 0xFF, item_id & 0xFF, (item_id >> 8) & 0xFF]))
             item_out_ptr += 1
             snes_buffered_write(ctx, SMZ3_RECV_PROGRESS_ADDR + recv_progress_addr_table_offset, bytes([item_out_ptr & 0xFF, (item_out_ptr >> 8) & 0xFF]))
+            sending_game = ctx.slot_info[item.player].game
             logging.info('Received %s from %s (%s) (%d/%d in list)' % (
-                color(ctx.item_names[item.item], 'red', 'bold'), color(ctx.player_names[item.player], 'yellow'),
-                ctx.location_names[item.location], item_out_ptr, len(ctx.items_received)))
+                color(ctx.item_names[ctx.game][item.item], 'red', 'bold'), color(ctx.player_names[item.player], 'yellow'),
+                ctx.location_names[sending_game][item.location], item_out_ptr, len(ctx.items_received)))
 
         await snes_flush_writes(ctx)
-

worlds/yoshisisland/Client.py

@@ -116,7 +116,7 @@ async def game_watcher(self, ctx: "SNIContext") -> None:
 
         for new_check_id in new_checks:
             ctx.locations_checked.add(new_check_id)
-            location = ctx.location_names[new_check_id]
+            location = ctx.location_names[ctx.game][new_check_id]
             total_locations = len(ctx.missing_locations) + len(ctx.checked_locations)
             snes_logger.info(f"New Check: {location} ({len(ctx.locations_checked)}/{total_locations})")
             await ctx.send_msgs([{"cmd": "LocationChecks", "locations": [new_check_id]}])
@@ -126,10 +126,11 @@ async def game_watcher(self, ctx: "SNIContext") -> None:
         if recv_index < len(ctx.items_received):
             item = ctx.items_received[recv_index]
             recv_index += 1
+            sending_game = ctx.slot_info[item.player].game
             logging.info("Received %s from %s (%s) (%d/%d in list)" % (
-                color(ctx.item_names[item.item], "red", "bold"),
+                color(ctx.item_names[ctx.game][item.item], "red", "bold"),
                 color(ctx.player_names[item.player], "yellow"),
-                ctx.location_names[item.location], recv_index, len(ctx.items_received)))
+                ctx.location_names[sending_game][item.location], recv_index, len(ctx.items_received)))
 
             snes_buffered_write(ctx, ITEMQUEUE_HIGH, pack("H", recv_index))
             if item.item in item_values: