mirror of
https://github.com/ArchipelagoMW/Archipelago.git
synced 2026-04-01 23:23:23 -07:00
9bec9377fd
* Provide config path so OpenGOAL can use mod-specific saves and settings. * Add versioning to MemoryReader. Harden the client against user errors. * Updated comments. * Add Deathlink as a "statement of intent" to the YAML. Small updates to client. * Revert deathlink changes. * Update error message. * Added color markup to log messages printed in text client. * Separate loggers by agent, write markup to GUI and non-markup to disk simultaneously. * Refactor MemoryReader callbacks from main_tick to constructor. * Make callback names more... informative. * Give users explicit instructions in error messages.
444 lines
20 KiB
Python
444 lines
20 KiB
Python
import logging
|
|
import os
|
|
import subprocess
|
|
from logging import Logger
|
|
|
|
import colorama
|
|
|
|
import asyncio
|
|
from asyncio import Task
|
|
|
|
from typing import Set, Awaitable, Optional, List
|
|
|
|
import pymem
|
|
from pymem.exception import ProcessNotFound
|
|
|
|
import Utils
|
|
from NetUtils import ClientStatus
|
|
from CommonClient import ClientCommandProcessor, CommonContext, server_loop, gui_enabled
|
|
from .Options import EnableOrbsanity
|
|
|
|
from .GameID import jak1_name
|
|
from .client.ReplClient import JakAndDaxterReplClient
|
|
from .client.MemoryReader import JakAndDaxterMemoryReader
|
|
|
|
import ModuleUpdate
|
|
ModuleUpdate.update()
|
|
|
|
|
|
logger = logging.getLogger("JakClient")
|
|
all_tasks: Set[Task] = set()
|
|
|
|
|
|
def create_task_log_exception(awaitable: Awaitable) -> asyncio.Task:
|
|
async def _log_exception(a):
|
|
try:
|
|
return await a
|
|
except Exception as e:
|
|
logger.exception(e)
|
|
finally:
|
|
all_tasks.remove(task)
|
|
task = asyncio.create_task(_log_exception(awaitable))
|
|
all_tasks.add(task)
|
|
return task
|
|
|
|
|
|
class JakAndDaxterClientCommandProcessor(ClientCommandProcessor):
|
|
ctx: "JakAndDaxterContext"
|
|
|
|
# The command processor is not async so long-running operations like the /repl connect command
|
|
# (which takes 10-15 seconds to compile the game) have to be requested with user-initiated flags.
|
|
# The flags are checked by the agents every main_tick.
|
|
def _cmd_repl(self, *arguments: str):
|
|
"""Sends a command to the OpenGOAL REPL. Arguments:
|
|
- connect : connect the client to the REPL (goalc).
|
|
- status : check internal status of the REPL."""
|
|
if arguments:
|
|
if arguments[0] == "connect":
|
|
self.ctx.on_log_info(logger, "This may take a bit... Wait for the success audio cue before continuing!")
|
|
self.ctx.repl.initiated_connect = True
|
|
if arguments[0] == "status":
|
|
create_task_log_exception(self.ctx.repl.print_status())
|
|
|
|
def _cmd_memr(self, *arguments: str):
|
|
"""Sends a command to the Memory Reader. Arguments:
|
|
- connect : connect the memory reader to the game process (gk).
|
|
- status : check the internal status of the Memory Reader."""
|
|
if arguments:
|
|
if arguments[0] == "connect":
|
|
self.ctx.memr.initiated_connect = True
|
|
if arguments[0] == "status":
|
|
create_task_log_exception(self.ctx.memr.print_status())
|
|
|
|
|
|
class JakAndDaxterContext(CommonContext):
|
|
game = jak1_name
|
|
items_handling = 0b111 # Full item handling
|
|
command_processor = JakAndDaxterClientCommandProcessor
|
|
|
|
# We'll need two agents working in tandem to handle two-way communication with the game.
|
|
# The REPL Client will handle the server->game direction by issuing commands directly to the running game.
|
|
# But the REPL cannot send information back to us, it only ingests information we send it.
|
|
# Luckily OpenGOAL sets up memory addresses to write to, that AutoSplit can read from, for speedrunning.
|
|
# We'll piggyback off this system with a Memory Reader, and that will handle the game->server direction.
|
|
repl: JakAndDaxterReplClient
|
|
memr: JakAndDaxterMemoryReader
|
|
|
|
# And two associated tasks, so we have handles on them.
|
|
repl_task: asyncio.Task
|
|
memr_task: asyncio.Task
|
|
|
|
def __init__(self, server_address: Optional[str], password: Optional[str]) -> None:
|
|
self.repl = JakAndDaxterReplClient(self.on_log_error,
|
|
self.on_log_warn,
|
|
self.on_log_success,
|
|
self.on_log_info)
|
|
self.memr = JakAndDaxterMemoryReader(self.on_location_check,
|
|
self.on_finish_check,
|
|
self.on_deathlink_check,
|
|
self.on_deathlink_toggle,
|
|
self.on_orb_trade,
|
|
self.on_log_error,
|
|
self.on_log_warn,
|
|
self.on_log_success,
|
|
self.on_log_info)
|
|
# self.repl.load_data()
|
|
# self.memr.load_data()
|
|
super().__init__(server_address, password)
|
|
|
|
def run_gui(self):
|
|
from kvui import GameManager
|
|
|
|
class JakAndDaxterManager(GameManager):
|
|
logging_pairs = [
|
|
("Client", "Archipelago")
|
|
]
|
|
base_title = "Jak and Daxter ArchipelaGOAL Client"
|
|
|
|
self.ui = JakAndDaxterManager(self)
|
|
self.ui_task = asyncio.create_task(self.ui.async_run(), name="UI")
|
|
|
|
async def server_auth(self, password_requested: bool = False):
|
|
if password_requested and not self.password:
|
|
await super(JakAndDaxterContext, self).server_auth(password_requested)
|
|
await self.get_username()
|
|
self.tags = set()
|
|
await self.send_connect()
|
|
|
|
def on_package(self, cmd: str, args: dict):
|
|
|
|
if cmd == "Connected":
|
|
slot_data = args["slot_data"]
|
|
orbsanity_option = slot_data["enable_orbsanity"]
|
|
if orbsanity_option == EnableOrbsanity.option_per_level:
|
|
orbsanity_bundle = slot_data["level_orbsanity_bundle_size"]
|
|
elif orbsanity_option == EnableOrbsanity.option_global:
|
|
orbsanity_bundle = slot_data["global_orbsanity_bundle_size"]
|
|
else:
|
|
orbsanity_bundle = 1
|
|
|
|
create_task_log_exception(
|
|
self.repl.setup_options(orbsanity_option,
|
|
orbsanity_bundle,
|
|
slot_data["fire_canyon_cell_count"],
|
|
slot_data["mountain_pass_cell_count"],
|
|
slot_data["lava_tube_cell_count"],
|
|
slot_data["citizen_orb_trade_amount"],
|
|
slot_data["oracle_orb_trade_amount"],
|
|
slot_data["jak_completion_condition"]))
|
|
|
|
# Because Orbsanity and the orb traders in the game are intrinsically linked, we need the server
|
|
# to track our trades at all times to support async play. "Retrieved" will tell us the orbs we lost,
|
|
# while "ReceivedItems" will tell us the orbs we gained. This will give us the correct balance.
|
|
if orbsanity_option in [EnableOrbsanity.option_per_level, EnableOrbsanity.option_global]:
|
|
async def get_orb_balance():
|
|
await self.send_msgs([{"cmd": "Get", "keys": [f"jakanddaxter_{self.auth}_orbs_paid"]}])
|
|
|
|
create_task_log_exception(get_orb_balance())
|
|
|
|
if cmd == "Retrieved":
|
|
if f"jakanddaxter_{self.auth}_orbs_paid" in args["keys"]:
|
|
orbs_traded = args["keys"][f"jakanddaxter_{self.auth}_orbs_paid"]
|
|
orbs_traded = orbs_traded if orbs_traded is not None else 0
|
|
create_task_log_exception(self.repl.subtract_traded_orbs(orbs_traded))
|
|
|
|
if cmd == "ReceivedItems":
|
|
for index, item in enumerate(args["items"], start=args["index"]):
|
|
logger.debug(f"index: {str(index)}, item: {str(item)}")
|
|
self.repl.item_inbox[index] = item
|
|
|
|
async def json_to_game_text(self, args: dict):
|
|
if "type" in args and args["type"] in {"ItemSend"}:
|
|
my_item_name: Optional[str] = None
|
|
my_item_finder: Optional[str] = None
|
|
their_item_name: Optional[str] = None
|
|
their_item_owner: Optional[str] = None
|
|
|
|
item = args["item"]
|
|
recipient = args["receiving"]
|
|
|
|
# Receiving an item from the server.
|
|
if self.slot_concerns_self(recipient):
|
|
my_item_name = self.item_names.lookup_in_game(item.item)
|
|
|
|
# Did we find it, or did someone else?
|
|
if self.slot_concerns_self(item.player):
|
|
my_item_finder = "MYSELF"
|
|
else:
|
|
my_item_finder = self.player_names[item.player]
|
|
|
|
# Sending an item to the server.
|
|
if self.slot_concerns_self(item.player):
|
|
their_item_name = self.item_names.lookup_in_slot(item.item, recipient)
|
|
|
|
# Does it belong to us, or to someone else?
|
|
if self.slot_concerns_self(recipient):
|
|
their_item_owner = "MYSELF"
|
|
else:
|
|
their_item_owner = self.player_names[recipient]
|
|
|
|
# Write to game display.
|
|
self.repl.queue_game_text(my_item_name, my_item_finder, their_item_name, their_item_owner)
|
|
|
|
def on_print_json(self, args: dict) -> None:
|
|
|
|
# Even though N items come in as 1 ReceivedItems packet, there are still N PrintJson packets to process,
|
|
# and they all arrive before the ReceivedItems packet does. Defer processing of these packets as
|
|
# async tasks to speed up large releases of items.
|
|
create_task_log_exception(self.json_to_game_text(args))
|
|
super(JakAndDaxterContext, self).on_print_json(args)
|
|
|
|
def on_deathlink(self, data: dict):
|
|
if self.memr.deathlink_enabled:
|
|
self.repl.received_deathlink = True
|
|
super().on_deathlink(data)
|
|
|
|
async def ap_inform_location_check(self, location_ids: List[int]):
|
|
message = [{"cmd": "LocationChecks", "locations": location_ids}]
|
|
await self.send_msgs(message)
|
|
|
|
def on_location_check(self, location_ids: List[int]):
|
|
create_task_log_exception(self.ap_inform_location_check(location_ids))
|
|
|
|
async def ap_inform_finished_game(self):
|
|
if not self.finished_game and self.memr.finished_game:
|
|
message = [{"cmd": "StatusUpdate", "status": ClientStatus.CLIENT_GOAL}]
|
|
await self.send_msgs(message)
|
|
self.finished_game = True
|
|
|
|
def on_finish_check(self):
|
|
create_task_log_exception(self.ap_inform_finished_game())
|
|
|
|
async def ap_inform_deathlink(self):
|
|
if self.memr.deathlink_enabled:
|
|
player = self.player_names[self.slot] if self.slot is not None else "Jak"
|
|
death_text = self.memr.cause_of_death.replace("Jak", player)
|
|
await self.send_death(death_text)
|
|
self.on_log_warn(logger, death_text)
|
|
|
|
# Reset all flags, but leave the death count alone.
|
|
self.memr.send_deathlink = False
|
|
self.memr.cause_of_death = ""
|
|
|
|
def on_deathlink_check(self):
|
|
create_task_log_exception(self.ap_inform_deathlink())
|
|
|
|
async def ap_inform_deathlink_toggle(self):
|
|
await self.update_death_link(self.memr.deathlink_enabled)
|
|
|
|
def on_deathlink_toggle(self):
|
|
create_task_log_exception(self.ap_inform_deathlink_toggle())
|
|
|
|
async def ap_inform_orb_trade(self, orbs_changed: int):
|
|
if self.memr.orbsanity_enabled:
|
|
await self.send_msgs([{"cmd": "Set",
|
|
"key": f"jakanddaxter_{self.auth}_orbs_paid",
|
|
"default": 0,
|
|
"want_reply": False,
|
|
"operations": [{"operation": "add", "value": orbs_changed}]
|
|
}])
|
|
|
|
def on_orb_trade(self, orbs_changed: int):
|
|
create_task_log_exception(self.ap_inform_orb_trade(orbs_changed))
|
|
|
|
def on_log_error(self, lg: Logger, message: str):
|
|
lg.error(message)
|
|
if self.ui:
|
|
color = self.jsontotextparser.color_codes["red"]
|
|
self.ui.log_panels["Archipelago"].on_message_markup(f"[color={color}]{message}[/color]")
|
|
self.ui.log_panels["All"].on_message_markup(f"[color={color}]{message}[/color]")
|
|
|
|
def on_log_warn(self, lg: Logger, message: str):
|
|
lg.warning(message)
|
|
if self.ui:
|
|
color = self.jsontotextparser.color_codes["orange"]
|
|
self.ui.log_panels["Archipelago"].on_message_markup(f"[color={color}]{message}[/color]")
|
|
self.ui.log_panels["All"].on_message_markup(f"[color={color}]{message}[/color]")
|
|
|
|
def on_log_success(self, lg: Logger, message: str):
|
|
lg.info(message)
|
|
if self.ui:
|
|
color = self.jsontotextparser.color_codes["green"]
|
|
self.ui.log_panels["Archipelago"].on_message_markup(f"[color={color}]{message}[/color]")
|
|
self.ui.log_panels["All"].on_message_markup(f"[color={color}]{message}[/color]")
|
|
|
|
def on_log_info(self, lg: Logger, message: str):
|
|
lg.info(message)
|
|
if self.ui:
|
|
self.ui.log_panels["Archipelago"].on_message_markup(f"{message}")
|
|
self.ui.log_panels["All"].on_message_markup(f"{message}")
|
|
|
|
async def run_repl_loop(self):
|
|
while True:
|
|
await self.repl.main_tick()
|
|
await asyncio.sleep(0.1)
|
|
|
|
async def run_memr_loop(self):
|
|
while True:
|
|
await self.memr.main_tick()
|
|
await asyncio.sleep(0.1)
|
|
|
|
|
|
async def run_game(ctx: JakAndDaxterContext):
|
|
|
|
# These may already be running. If they are not running, try to start them.
|
|
# TODO - Support other OS's. cmd for some reason does not work with goalc. Pymem is Windows-only.
|
|
gk_running = False
|
|
try:
|
|
pymem.Pymem("gk.exe") # The GOAL Kernel
|
|
gk_running = True
|
|
except ProcessNotFound:
|
|
ctx.on_log_warn(logger, "Game not running, attempting to start.")
|
|
|
|
goalc_running = False
|
|
try:
|
|
pymem.Pymem("goalc.exe") # The GOAL Compiler and REPL
|
|
goalc_running = True
|
|
except ProcessNotFound:
|
|
ctx.on_log_warn(logger, "Compiler not running, attempting to start.")
|
|
|
|
try:
|
|
# Validate folder and file structures of the ArchipelaGOAL root directory.
|
|
root_path = Utils.get_settings()["jakanddaxter_options"]["root_directory"]
|
|
|
|
# Always trust your instincts.
|
|
if "/" not in root_path:
|
|
msg = (f"The ArchipelaGOAL root directory contains no path. (Are you missing forward slashes?)\n"
|
|
f"Please check that the value of 'jakanddaxter_options > root_directory' in your host.yaml file "
|
|
f"is a valid existing path, and all backslashes have been replaced with forward slashes.")
|
|
ctx.on_log_error(logger, msg)
|
|
return
|
|
|
|
# Start by checking the existence of the root directory provided in the host.yaml file.
|
|
root_path = os.path.normpath(root_path)
|
|
if not os.path.exists(root_path):
|
|
msg = (f"The ArchipelaGOAL root directory does not exist, unable to locate the Game and Compiler.\n"
|
|
f"Please check that the value of 'jakanddaxter_options > root_directory' in your host.yaml file "
|
|
f"is a valid existing path, and all backslashes have been replaced with forward slashes.")
|
|
ctx.on_log_error(logger, msg)
|
|
return
|
|
|
|
# Now double-check the existence of the two executables we need.
|
|
gk_path = os.path.join(root_path, "gk.exe")
|
|
goalc_path = os.path.join(root_path, "goalc.exe")
|
|
if not os.path.exists(gk_path) or not os.path.exists(goalc_path):
|
|
msg = (f"The Game and Compiler could not be found in the ArchipelaGOAL root directory.\n"
|
|
f"Please check the value of 'jakanddaxter_options > root_directory' in your host.yaml file, "
|
|
f"and ensure that path contains gk.exe, goalc.exe, and a data folder.")
|
|
ctx.on_log_error(logger, msg)
|
|
return
|
|
|
|
# IMPORTANT: Before we check the existence of the next piece, we must ask "Are you a developer?"
|
|
# The OpenGOAL Compiler checks the existence of the "data" folder to determine if you're running from source
|
|
# or from a built package. As a developer, your repository folder itself IS the data folder and the Compiler
|
|
# knows this. You would have created your "iso_data" folder here as well, so we can skip the "iso_data" check.
|
|
# HOWEVER, for everyone who is NOT a developer, we must ensure that they copied the "iso_data" folder INTO
|
|
# the "data" folder per the setup instructions.
|
|
data_path = os.path.join(root_path, "data")
|
|
if os.path.exists(data_path):
|
|
|
|
# NOW double-check the existence of the iso_data folder under <root directory>/data. This is necessary
|
|
# for the compiler to compile the game correctly.
|
|
# TODO - If the GOALC compiler is updated to take the iso_data folder as a runtime argument,
|
|
# we may be able to remove this step.
|
|
iso_data_path = os.path.join(root_path, "data", "iso_data")
|
|
if not os.path.exists(iso_data_path):
|
|
msg = (f"The iso_data folder could not be found in the ArchipelaGOAL data directory.\n"
|
|
f"Please follow these steps:\n"
|
|
f" Run the OpenGOAL Launcher, click Jak and Daxter > Advanced > Open Game Data Folder.\n"
|
|
f" Copy the iso_data folder from this location.\n"
|
|
f" Click Jak and Daxter > Features > Mods > ArchipelaGOAL > Advanced > Open Game Data Folder.\n"
|
|
f" Paste the iso_data folder in this location.\n"
|
|
f" Click Advanced > Compile. When this is done, click Continue.\n"
|
|
f" Close all launchers, games, clients, and Powershell windows, then restart Archipelago.\n"
|
|
f"(See Setup Guide for more details.)")
|
|
ctx.on_log_error(logger, msg)
|
|
return
|
|
|
|
# Now we can FINALLY attempt to start the programs.
|
|
if not gk_running:
|
|
# Per-mod saves and settings are stored in a spot that is a little unusual to get to. We have to .. out of
|
|
# ArchipelaGOAL root folder, then traverse down to _settings/archipelagoal. Then we normalize this path
|
|
# and pass it in as an argument to gk. This folder will be created if it does not exist.
|
|
config_relative_path = "../_settings/archipelagoal"
|
|
config_path = os.path.normpath(
|
|
os.path.join(
|
|
os.path.normpath(root_path),
|
|
os.path.normpath(config_relative_path)))
|
|
|
|
# Prefixing ampersand and wrapping in quotes is necessary for paths with spaces in them.
|
|
gk_process = subprocess.Popen(
|
|
["powershell.exe",
|
|
f"& \"{gk_path}\"",
|
|
f"--config-path \"{config_path}\"",
|
|
"--game jak1",
|
|
"--", "-v", "-boot", "-fakeiso", "-debug"],
|
|
creationflags=subprocess.CREATE_NEW_CONSOLE) # These need to be new consoles for stability.
|
|
|
|
if not goalc_running:
|
|
# Prefixing ampersand and wrapping goalc_path in quotes is necessary for paths with spaces in them.
|
|
goalc_process = subprocess.Popen(
|
|
["powershell.exe", f"& \"{goalc_path}\"", "--game jak1"],
|
|
creationflags=subprocess.CREATE_NEW_CONSOLE) # These need to be new consoles for stability.
|
|
|
|
except AttributeError as e:
|
|
ctx.on_log_error(logger, f"Host.yaml does not contain {e.args[0]}, unable to locate game executables.")
|
|
return
|
|
except FileNotFoundError as e:
|
|
msg = (f"The ArchipelaGOAL root directory path is invalid.\n"
|
|
f"Please check that the value of 'jakanddaxter_options > root_directory' in your host.yaml file "
|
|
f"is a valid existing path, and all backslashes have been replaced with forward slashes.")
|
|
ctx.on_log_error(logger, msg)
|
|
return
|
|
|
|
# Auto connect the repl and memr agents. Sleep 5 because goalc takes just a little bit of time to load,
|
|
# and it's not something we can await.
|
|
ctx.on_log_info(logger, "This may take a bit... Wait for the game's title sequence before continuing!")
|
|
await asyncio.sleep(5)
|
|
ctx.repl.initiated_connect = True
|
|
ctx.memr.initiated_connect = True
|
|
|
|
|
|
async def main():
|
|
Utils.init_logging("JakAndDaxterClient", exception_logger="Client")
|
|
|
|
ctx = JakAndDaxterContext(None, None)
|
|
ctx.server_task = asyncio.create_task(server_loop(ctx), name="server loop")
|
|
ctx.repl_task = create_task_log_exception(ctx.run_repl_loop())
|
|
ctx.memr_task = create_task_log_exception(ctx.run_memr_loop())
|
|
|
|
if gui_enabled:
|
|
ctx.run_gui()
|
|
ctx.run_cli()
|
|
|
|
# Find and run the game (gk) and compiler/repl (goalc).
|
|
create_task_log_exception(run_game(ctx))
|
|
await ctx.exit_event.wait()
|
|
await ctx.shutdown()
|
|
|
|
|
|
def launch():
|
|
colorama.init()
|
|
asyncio.run(main())
|
|
colorama.deinit()
|