FF1: Bizhawk Client and APWorld Support (#4448)

Co-authored-by: beauxq <beauxq@yahoo.com>
Co-authored-by: Exempt-Medic <60412657+Exempt-Medic@users.noreply.github.com>

worlds/LauncherComponents.py

@@ -224,8 +224,6 @@ components: List[Component] = [
     Component('OoT Client', 'OoTClient',
               file_identifier=SuffixIdentifier('.apz5')),
     Component('OoT Adjuster', 'OoTAdjuster'),
-    # FF1
-    Component('FF1 Client', 'FF1Client'),
     # TLoZ
     Component('Zelda 1 Client', 'Zelda1Client', file_identifier=SuffixIdentifier('.aptloz')),
     # ChecksFinder

worlds/ff1/Client.py

@@ -0,0 +1,328 @@
+import logging
+from collections import deque
+from typing import TYPE_CHECKING
+
+from NetUtils import ClientStatus
+
+import worlds._bizhawk as bizhawk
+from worlds._bizhawk.client import BizHawkClient
+
+if TYPE_CHECKING:
+    from worlds._bizhawk.context import BizHawkClientContext
+
+
+base_id = 7000
+logger = logging.getLogger("Client")
+
+
+rom_name_location = 0x07FFE3
+locations_array_start = 0x200
+locations_array_length = 0x100
+items_obtained = 0x03
+gp_location_low = 0x1C
+gp_location_middle = 0x1D
+gp_location_high = 0x1E
+weapons_arrays_starts = [0x118, 0x158, 0x198, 0x1D8]
+armors_arrays_starts = [0x11C, 0x15C, 0x19C, 0x1DC]
+status_a_location = 0x102
+status_b_location = 0x0FC
+status_c_location = 0x0A3
+
+key_items = ["Lute", "Crown", "Crystal", "Herb", "Key", "Tnt", "Adamant", "Slab", "Ruby", "Rod",
+             "Floater", "Chime", "Tail", "Cube", "Bottle", "Oxyale", "EarthOrb", "FireOrb", "WaterOrb", "AirOrb"]
+
+consumables = ["Shard", "Tent", "Cabin", "House", "Heal", "Pure", "Soft"]
+
+weapons = ["WoodenNunchucks", "SmallKnife", "WoodenRod", "Rapier", "IronHammer", "ShortSword", "HandAxe", "Scimitar",
+           "IronNunchucks", "LargeKnife", "IronStaff", "Sabre", "LongSword", "GreatAxe", "Falchon", "SilverKnife",
+           "SilverSword", "SilverHammer", "SilverAxe", "FlameSword", "IceSword", "DragonSword", "GiantSword",
+           "SunSword", "CoralSword", "WereSword", "RuneSword", "PowerRod", "LightAxe", "HealRod", "MageRod", "Defense",
+           "WizardRod", "Vorpal", "CatClaw", "ThorHammer", "BaneSword", "Katana", "Xcalber", "Masamune"]
+
+armor = ["Cloth", "WoodenArmor", "ChainArmor", "IronArmor", "SteelArmor", "SilverArmor", "FlameArmor", "IceArmor",
+         "OpalArmor", "DragonArmor", "Copper", "Silver", "Gold", "Opal", "WhiteShirt", "BlackShirt", "WoodenShield",
+         "IronShield", "SilverShield", "FlameShield", "IceShield", "OpalShield", "AegisShield", "Buckler", "ProCape",
+         "Cap", "WoodenHelm", "IronHelm", "SilverHelm", "OpalHelm", "HealHelm", "Ribbon", "Gloves", "CopperGauntlets",
+         "IronGauntlets", "SilverGauntlets", "ZeusGauntlets", "PowerGauntlets", "OpalGauntlets", "ProRing"]
+
+gold_items = ["Gold10", "Gold20", "Gold25", "Gold30", "Gold55", "Gold70", "Gold85", "Gold110", "Gold135", "Gold155",
+              "Gold160", "Gold180", "Gold240", "Gold255", "Gold260", "Gold295", "Gold300", "Gold315", "Gold330",
+              "Gold350", "Gold385", "Gold400", "Gold450", "Gold500", "Gold530", "Gold575", "Gold620", "Gold680",
+              "Gold750", "Gold795", "Gold880", "Gold1020", "Gold1250", "Gold1455", "Gold1520", "Gold1760", "Gold1975",
+              "Gold2000", "Gold2750", "Gold3400", "Gold4150", "Gold5000", "Gold5450", "Gold6400", "Gold6720",
+              "Gold7340", "Gold7690", "Gold7900", "Gold8135", "Gold9000", "Gold9300", "Gold9500", "Gold9900",
+              "Gold10000", "Gold12350", "Gold13000", "Gold13450", "Gold14050", "Gold14720", "Gold15000", "Gold17490",
+              "Gold18010", "Gold19990", "Gold20000", "Gold20010", "Gold26000", "Gold45000", "Gold65000"]
+
+extended_consumables = ["FullCure", "Phoenix", "Blast", "Smoke",
+                        "Refresh", "Flare", "Black", "Guard",
+                        "Quick", "HighPotion", "Wizard", "Cloak"]
+
+ext_consumables_lookup = {"FullCure": "Ext1", "Phoenix": "Ext2", "Blast": "Ext3", "Smoke": "Ext4",
+                          "Refresh": "Ext1", "Flare": "Ext2", "Black": "Ext3", "Guard": "Ext4",
+                          "Quick": "Ext1", "HighPotion": "Ext2", "Wizard": "Ext3", "Cloak": "Ext4"}
+
+ext_consumables_locations = {"Ext1": 0x3C, "Ext2": 0x3D, "Ext3": 0x3E, "Ext4": 0x3F}
+
+
+movement_items = ["Ship", "Bridge", "Canal", "Canoe"]
+
+no_overworld_items = ["Sigil", "Mark"]
+
+
+class FF1Client(BizHawkClient):
+    game = "Final Fantasy"
+    system = "NES"
+
+    weapons_queue: deque[int]
+    armor_queue: deque[int]
+    consumable_stack_amounts: dict[str, int] | None
+
+    def __init__(self) -> None:
+        self.wram = "RAM"
+        self.sram = "WRAM"
+        self.rom = "PRG ROM"
+        self.consumable_stack_amounts = None
+        self.weapons_queue = deque()
+        self.armor_queue = deque()
+        self.guard_character = 0x00
+
+    async def validate_rom(self, ctx: "BizHawkClientContext") -> bool:
+        try:
+            # Check ROM name/patch version
+            rom_name = ((await bizhawk.read(ctx.bizhawk_ctx, [(rom_name_location, 0x0D, self.rom)]))[0])
+            rom_name = rom_name.decode("ascii")
+            if rom_name != "FINAL FANTASY":
+                return False  # Not a Final Fantasy 1 ROM
+        except bizhawk.RequestFailedError:
+            return False  # Not able to get a response, say no for now
+
+        ctx.game = self.game
+        ctx.items_handling = 0b111
+        ctx.want_slot_data = True
+        # Resetting these in case of switching ROMs
+        self.consumable_stack_amounts = None
+        self.weapons_queue = deque()
+        self.armor_queue = deque()
+
+        return True
+
+    async def game_watcher(self, ctx: "BizHawkClientContext") -> None:
+        if ctx.server is None:
+            return
+
+        if ctx.slot is None:
+            return
+        try:
+            self.guard_character = await self.read_sram_value(ctx, status_a_location)
+            # If the first character's name starts with a 0 value, we're at the title screen/character creation.
+            # In that case, don't allow any read/writes.
+            # We do this by setting the guard to 1 because that's neither a valid character nor the initial value.
+            if self.guard_character == 0:
+                self.guard_character = 0x01
+
+            if self.consumable_stack_amounts is None:
+                self.consumable_stack_amounts = {}
+                self.consumable_stack_amounts["Shard"] = 1
+                other_consumable_amounts = await self.read_rom(ctx, 0x47400, 10)
+                self.consumable_stack_amounts["Tent"] = other_consumable_amounts[0] + 1
+                self.consumable_stack_amounts["Cabin"] = other_consumable_amounts[1] + 1
+                self.consumable_stack_amounts["House"] = other_consumable_amounts[2] + 1
+                self.consumable_stack_amounts["Heal"] = other_consumable_amounts[3] + 1
+                self.consumable_stack_amounts["Pure"] = other_consumable_amounts[4] + 1
+                self.consumable_stack_amounts["Soft"] = other_consumable_amounts[5] + 1
+                self.consumable_stack_amounts["Ext1"] = other_consumable_amounts[6] + 1
+                self.consumable_stack_amounts["Ext2"] = other_consumable_amounts[7] + 1
+                self.consumable_stack_amounts["Ext3"] = other_consumable_amounts[8] + 1
+                self.consumable_stack_amounts["Ext4"] = other_consumable_amounts[9] + 1
+
+            await self.location_check(ctx)
+            await self.received_items_check(ctx)
+            await self.process_weapons_queue(ctx)
+            await self.process_armor_queue(ctx)
+
+        except bizhawk.RequestFailedError:
+            # The connector didn't respond. Exit handler and return to main loop to reconnect
+            pass
+
+    async def location_check(self, ctx: "BizHawkClientContext"):
+        locations_data = await self.read_sram_values_guarded(ctx, locations_array_start, locations_array_length)
+        if locations_data is None:
+            return
+        locations_checked = []
+        if len(locations_data) > 0xFE and locations_data[0xFE] & 0x02 != 0 and not ctx.finished_game:
+            await ctx.send_msgs([
+                {"cmd": "StatusUpdate",
+                 "status": ClientStatus.CLIENT_GOAL}
+            ])
+            ctx.finished_game = True
+        for location in ctx.missing_locations:
+            # index will be - 0x100 or 0x200
+            index = location
+            if location < 0x200:
+                # Location is a chest
+                index -= 0x100
+                flag = 0x04
+            else:
+                # Location is an NPC
+                index -= 0x200
+                flag = 0x02
+            if locations_data[index] & flag != 0:
+                locations_checked.append(location)
+
+        found_locations = await ctx.check_locations(locations_checked)
+        for location in found_locations:
+            ctx.locations_checked.add(location)
+            location_name = ctx.location_names.lookup_in_game(location)
+            logger.info(
+                f'New Check: {location_name} ({len(ctx.locations_checked)}/'
+                f'{len(ctx.missing_locations) + len(ctx.checked_locations)})')
+
+
+    async def received_items_check(self, ctx: "BizHawkClientContext") -> None:
+        assert self.consumable_stack_amounts, "shouldn't call this function without reading consumable_stack_amounts"
+        write_list: list[tuple[int, list[int], str]] = []
+        items_received_count = await self.read_sram_value_guarded(ctx, items_obtained)
+        if items_received_count is None:
+            return
+        if items_received_count < len(ctx.items_received):
+            current_item = ctx.items_received[items_received_count]
+            current_item_id = current_item.item
+            current_item_name = ctx.item_names.lookup_in_game(current_item_id, ctx.game)
+            if current_item_name in key_items:
+                location = current_item_id - 0xE0
+                write_list.append((location, [1], self.sram))
+            elif current_item_name in movement_items:
+                location = current_item_id - 0x1E0
+                if current_item_name != "Canal":
+                    write_list.append((location, [1], self.sram))
+                else:
+                    write_list.append((location, [0], self.sram))
+            elif current_item_name in no_overworld_items:
+                if current_item_name == "Sigil":
+                    location = 0x28
+                else:
+                    location = 0x12
+                write_list.append((location, [1], self.sram))
+            elif current_item_name in gold_items:
+                gold_amount = int(current_item_name[4:])
+                current_gold_value = await self.read_sram_values_guarded(ctx, gp_location_low, 3)
+                if current_gold_value is None:
+                    return
+                current_gold = int.from_bytes(current_gold_value, "little")
+                new_gold = min(gold_amount + current_gold, 999999)
+                lower_byte = new_gold % (2 ** 8)
+                middle_byte = (new_gold // (2 ** 8)) % (2 ** 8)
+                upper_byte = new_gold // (2 ** 16)
+                write_list.append((gp_location_low, [lower_byte], self.sram))
+                write_list.append((gp_location_middle, [middle_byte], self.sram))
+                write_list.append((gp_location_high, [upper_byte], self.sram))
+            elif current_item_name in consumables:
+                location = current_item_id - 0xE0
+                current_value = await self.read_sram_value_guarded(ctx, location)
+                if current_value is None:
+                    return
+                amount_to_add = self.consumable_stack_amounts[current_item_name]
+                new_value = min(current_value + amount_to_add, 99)
+                write_list.append((location, [new_value], self.sram))
+            elif current_item_name in extended_consumables:
+                ext_name = ext_consumables_lookup[current_item_name]
+                location = ext_consumables_locations[ext_name]
+                current_value = await self.read_sram_value_guarded(ctx, location)
+                if current_value is None:
+                    return
+                amount_to_add = self.consumable_stack_amounts[ext_name]
+                new_value = min(current_value + amount_to_add, 99)
+                write_list.append((location, [new_value], self.sram))
+            elif current_item_name in weapons:
+                self.weapons_queue.appendleft(current_item_id - 0x11B)
+            elif current_item_name in armor:
+                self.armor_queue.appendleft(current_item_id - 0x143)
+            write_list.append((items_obtained, [items_received_count + 1], self.sram))
+            write_successful = await self.write_sram_values_guarded(ctx, write_list)
+            if write_successful:
+                await bizhawk.display_message(ctx.bizhawk_ctx, f"Received {current_item_name}")
+
+    async def process_weapons_queue(self, ctx: "BizHawkClientContext"):
+        empty_slots = deque()
+        char1_slots = await self.read_sram_values_guarded(ctx, weapons_arrays_starts[0], 4)
+        char2_slots = await self.read_sram_values_guarded(ctx, weapons_arrays_starts[1], 4)
+        char3_slots = await self.read_sram_values_guarded(ctx, weapons_arrays_starts[2], 4)
+        char4_slots = await self.read_sram_values_guarded(ctx, weapons_arrays_starts[3], 4)
+        if char1_slots is None or char2_slots is None or char3_slots is None or char4_slots is None:
+            return
+        for i, slot in enumerate(char1_slots):
+            if slot == 0:
+                empty_slots.appendleft(weapons_arrays_starts[0] + i)
+        for i, slot in enumerate(char2_slots):
+            if slot == 0:
+                empty_slots.appendleft(weapons_arrays_starts[1] + i)
+        for i, slot in enumerate(char3_slots):
+            if slot == 0:
+                empty_slots.appendleft(weapons_arrays_starts[2] + i)
+        for i, slot in enumerate(char4_slots):
+            if slot == 0:
+                empty_slots.appendleft(weapons_arrays_starts[3] + i)
+        while len(empty_slots) > 0 and len(self.weapons_queue) > 0:
+            current_slot = empty_slots.pop()
+            current_weapon = self.weapons_queue.pop()
+            await self.write_sram_guarded(ctx, current_slot, current_weapon)
+
+    async def process_armor_queue(self, ctx: "BizHawkClientContext"):
+        empty_slots = deque()
+        char1_slots = await self.read_sram_values_guarded(ctx, armors_arrays_starts[0], 4)
+        char2_slots = await self.read_sram_values_guarded(ctx, armors_arrays_starts[1], 4)
+        char3_slots = await self.read_sram_values_guarded(ctx, armors_arrays_starts[2], 4)
+        char4_slots = await self.read_sram_values_guarded(ctx, armors_arrays_starts[3], 4)
+        if char1_slots is None or char2_slots is None or char3_slots is None or char4_slots is None:
+            return
+        for i, slot in enumerate(char1_slots):
+            if slot == 0:
+                empty_slots.appendleft(armors_arrays_starts[0] + i)
+        for i, slot in enumerate(char2_slots):
+            if slot == 0:
+                empty_slots.appendleft(armors_arrays_starts[1] + i)
+        for i, slot in enumerate(char3_slots):
+            if slot == 0:
+                empty_slots.appendleft(armors_arrays_starts[2] + i)
+        for i, slot in enumerate(char4_slots):
+            if slot == 0:
+                empty_slots.appendleft(armors_arrays_starts[3] + i)
+        while len(empty_slots) > 0 and len(self.armor_queue) > 0:
+            current_slot = empty_slots.pop()
+            current_armor = self.armor_queue.pop()
+            await self.write_sram_guarded(ctx, current_slot, current_armor)
+
+
+    async def read_sram_value(self, ctx: "BizHawkClientContext", location: int):
+        value = ((await bizhawk.read(ctx.bizhawk_ctx, [(location, 1, self.sram)]))[0])
+        return int.from_bytes(value, "little")
+
+    async def read_sram_values_guarded(self, ctx: "BizHawkClientContext", location: int, size: int):
+        value = await bizhawk.guarded_read(ctx.bizhawk_ctx,
+                                           [(location, size, self.sram)],
+                                           [(status_a_location, [self.guard_character], self.sram)])
+        if value is None:
+            return None
+        return value[0]
+
+    async def read_sram_value_guarded(self, ctx: "BizHawkClientContext", location: int):
+        value = await bizhawk.guarded_read(ctx.bizhawk_ctx,
+                                           [(location, 1, self.sram)],
+                                           [(status_a_location, [self.guard_character], self.sram)])
+        if value is None:
+            return None
+        return int.from_bytes(value[0], "little")
+
+    async def read_rom(self, ctx: "BizHawkClientContext", location: int, size: int):
+        return (await bizhawk.read(ctx.bizhawk_ctx, [(location, size, self.rom)]))[0]
+
+    async def write_sram_guarded(self, ctx: "BizHawkClientContext", location: int, value: int):
+        return await bizhawk.guarded_write(ctx.bizhawk_ctx,
+                                           [(location, [value], self.sram)],
+                                           [(status_a_location, [self.guard_character], self.sram)])
+
+    async def write_sram_values_guarded(self, ctx: "BizHawkClientContext", write_list):
+        return await bizhawk.guarded_write(ctx.bizhawk_ctx,
+                                           write_list,
+                                           [(status_a_location, [self.guard_character], self.sram)])

worlds/ff1/Items.py

@@ -1,5 +1,5 @@
 import json
-from pathlib import Path
+import pkgutil
 from typing import Dict, Set, NamedTuple, List
 
 from BaseClasses import Item, ItemClassification
@@ -37,15 +37,13 @@ class FF1Items:
     _item_table_lookup: Dict[str, ItemData] = {}
 
     def _populate_item_table_from_data(self):
-        base_path = Path(__file__).parent
-        file_path = (base_path / "data/items.json").resolve()
-        with open(file_path) as file:
-            items = json.load(file)
-            # Hardcode progression and categories for now
-            self._item_table = [ItemData(name, code, "FF1Item", ItemClassification.progression if name in
-                                FF1_PROGRESSION_LIST else ItemClassification.useful if name in FF1_USEFUL_LIST else
-                                ItemClassification.filler) for name, code in items.items()]
-            self._item_table_lookup = {item.name: item for item in self._item_table}
+        file = pkgutil.get_data(__name__, "data/items.json").decode("utf-8")
+        items = json.loads(file)
+        # Hardcode progression and categories for now
+        self._item_table = [ItemData(name, code, "FF1Item", ItemClassification.progression if name in
+                            FF1_PROGRESSION_LIST else ItemClassification.useful if name in FF1_USEFUL_LIST else
+                            ItemClassification.filler) for name, code in items.items()]
+        self._item_table_lookup = {item.name: item for item in self._item_table}
 
     def _get_item_table(self) -> List[ItemData]:
         if not self._item_table or not self._item_table_lookup:

worlds/ff1/Locations.py

@@ -1,5 +1,5 @@
 import json
-from pathlib import Path
+import pkgutil
 from typing import Dict, NamedTuple, List, Optional
 
 from BaseClasses import Region, Location, MultiWorld
@@ -18,13 +18,11 @@ class FF1Locations:
     _location_table_lookup: Dict[str, LocationData] = {}
 
     def _populate_item_table_from_data(self):
-        base_path = Path(__file__).parent
-        file_path = (base_path / "data/locations.json").resolve()
-        with open(file_path) as file:
-            locations = json.load(file)
-            # Hardcode progression and categories for now
-            self._location_table = [LocationData(name, code) for name, code in locations.items()]
-            self._location_table_lookup = {item.name: item for item in self._location_table}
+        file = pkgutil.get_data(__name__, "data/locations.json")
+        locations = json.loads(file)
+        # Hardcode progression and categories for now
+        self._location_table = [LocationData(name, code) for name, code in locations.items()]
+        self._location_table_lookup = {item.name: item for item in self._location_table}
 
     def _get_location_table(self) -> List[LocationData]:
         if not self._location_table or not self._location_table_lookup:

worlds/ff1/__init__.py

@@ -7,6 +7,7 @@ from .Items import ItemData, FF1Items, FF1_STARTER_ITEMS, FF1_PROGRESSION_LIST,
 from .Locations import EventId, FF1Locations, generate_rule, CHAOS_TERMINATED_EVENT
 from .Options import FF1Options
 from ..AutoWorld import World, WebWorld
+from .Client import FF1Client
 
 
 class FF1Settings(settings.Group):

worlds/ff1/docs/en_Final Fantasy.md

@@ -22,11 +22,6 @@ All items can appear in other players worlds, including consumables, shards, wea
 
 ## What does another world's item look like in Final Fantasy
 
-All local and remote items appear the same. Final Fantasy will say that you received an item, then BOTH the client log and the
-emulator will display what was found external to the in-game text box.
+All local and remote items appear the same. Final Fantasy will say that you received an item, then the client log will 
+display what was found external to the in-game text box.
 
-## Unique Local Commands
-The following commands are only available when using the FF1Client for the Final Fantasy Randomizer.
-
-- `/nes` Shows the current status of the NES connection.
-- `/toggle_msgs` Toggle displaying messages in EmuHawk

worlds/ff1/docs/multiworld_en.md

@@ -2,10 +2,10 @@
 
 ## Required Software
 
-- The FF1Client
-    - Bundled with Archipelago: [Archipelago Releases Page](https://github.com/ArchipelagoMW/Archipelago/releases)
-- The BizHawk emulator. Versions 2.3.1 and higher are supported. Version 2.7 is recommended
-    - [BizHawk at TASVideos](https://tasvideos.org/BizHawk)
+- BizHawk: [BizHawk Releases from TASVideos](https://tasvideos.org/BizHawk/ReleaseHistory)
+  - Detailed installation instructions for BizHawk can be found at the above link.
+  - Windows users must run the prerequisite installer first, which can also be found at the above link.
+- The built-in BizHawk client, which can be installed [here](https://github.com/ArchipelagoMW/Archipelago/releases)
 - Your legally obtained Final Fantasy (USA Edition) ROM file, probably named `Final Fantasy (USA).nes`. Neither
   Archipelago.gg nor the Final Fantasy Randomizer Community can supply you with this.
 
@@ -13,7 +13,7 @@
 
 1. Download and install the latest version of Archipelago.
     1. On Windows, download Setup.Archipelago.<HighestVersion\>.exe and run it
-2. Assign EmuHawk version 2.3.1 or higher as your default program for launching `.nes` files.
+2. Assign EmuHawk as your default program for launching `.nes` files.
     1. Extract your BizHawk folder to your Desktop, or somewhere you will remember. Below are optional additional steps
        for loading ROMs more conveniently
         1. Right-click on a ROM file and select **Open with...**
@@ -46,7 +46,7 @@ please refer to the [game agnostic setup guide](/tutorial/Archipelago/setup/en).
 
 Once the Archipelago server has been hosted:
 
-1. Navigate to your Archipelago install folder and run `ArchipelagoFF1Client.exe`
+1. Navigate to your Archipelago install folder and run `ArchipelagoBizhawkClient.exe`
 2. Notice the `/connect command` on the server hosting page (It should look like `/connect archipelago.gg:*****`
    where ***** are numbers)
 3. Type the connect command into the client OR add the port to the pre-populated address on the top bar (it should
@@ -54,16 +54,11 @@ Once the Archipelago server has been hosted:
 
 ### Running Your Game and Connecting to the Client Program
 
-1. Open EmuHawk 2.3.1 or higher and load your ROM OR click your ROM file if it is already associated with the
+1. Open EmuHawk and load your ROM OR click your ROM file if it is already associated with the
    extension `*.nes`
-2. Navigate to where you installed Archipelago, then to `data/lua`, and drag+drop the `connector_ff1.lua` script onto
-   the main EmuHawk window.
-    1. You could instead open the Lua Console manually, click `Script` 〉 `Open Script`, and navigate to
-       `connector_ff1.lua` with the file picker.
-    2. If it gives a `NLua.Exceptions.LuaScriptException: .\socket.lua:13: module 'socket.core' not found:` exception
-       close your emulator entirely, restart it and re-run these steps
-    3. If it says `Must use a version of BizHawk 2.3.1 or higher`, double-check your BizHawk version by clicking **
-       Help** -> **About**
+2. Navigate to where you installed Archipelago, then to `data/lua`, and drag+drop the `connector_bizhawk_generic.lua` 
+script onto the main EmuHawk window. You can also instead open the Lua Console manually, click `Script` 〉 `Open Script`,
+and navigate to `connector_bizhawk_generic.lua` with the file picker.
 
 ## Play the game