diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml index d1134012be..7729102720 100644 --- a/.github/workflows/rust.yml +++ b/.github/workflows/rust.yml @@ -73,6 +73,8 @@ jobs: - uses: Swatinem/rust-cache@v2 with: workspaces: rust + - name: Lane allocation regressions + run: python -I -B ../Scripts/test_lane.py - name: Build run: cargo build --workspace --all-targets --locked # Successor of the C# "Scripts Compile" step (the GM scripts are compiled into the binary). diff --git a/Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md b/Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md index 2d106a00dc..33303f91c5 100644 --- a/Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md +++ b/Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md @@ -93,6 +93,69 @@ from the C# version is still read between `Config.Local.json` and the environment variables, but it can no longer be managed with a tool; move those values to `Config.Local.json` or environment variables.) +## Web API authentication and migration + +The game Web API now defaults to `127.0.0.1:1280`. Only `GET /status` is +anonymous; it returns uptime, player count and task/skill metrics. Every other +registered route requires `Authorization: Bearer `, including character, +world and auction reads, mail listing, GM commands and mail with attachments. +Missing, invalid or duplicate credentials return HTTP 401 with a Bearer challenge. +Commands still use the selected online character's command access level. + +For local status tooling, use this game's `Config.Local.json` override: + +```json +{ + "WebApiNetwork": { + "Host": "127.0.0.1", + "Port": 1280, + "Enabled": true, + "ApiKey": null + } +} +``` + +An absent, null or empty `ApiKey` disables access to every authenticated route, +including requests from localhost. To enable administrative tools, configure a +private, randomly generated key of at least 32 random bytes in the game process's +`WebApiNetwork__ApiKey` environment variable, or in the gitignored +`Config.Local.json` field `WebApiNetwork.ApiKey`. Keys accept ASCII letters, +digits and `-._~+/=`; whitespace is rejected. Keep the key separate from the +Login/Game `SecretKey`. Never put the key in URLs or commit it. + +For example, generate a key privately in PowerShell before starting the game +process from the same environment (these commands do not print the key): + +```powershell +$webApiRandom = [System.Security.Cryptography.RandomNumberGenerator]::Create() +$webApiBytes = New-Object byte[] 32 +$webApiRandom.GetBytes($webApiBytes) +$webApiRandom.Dispose() +$env:WebApiNetwork__ApiKey = [Convert]::ToBase64String($webApiBytes) +``` + +An administrative caller using that same private environment can supply the header: + +```powershell +$webApiHeaders = @{ Authorization = 'Bearer ' + $env:WebApiNetwork__ApiKey } +Invoke-RestMethod -Uri http://127.0.0.1:1280/api/world/logged-characters -Headers $webApiHeaders +``` + +Existing configurations with `Host: "*"`, `0.0.0.0`, `::`, or any other +non-loopback address now fail startup unless a nonempty valid key is configured. +For local monitoring, change the host to `127.0.0.1`; for remote administration, +configure the private key and use an HTTPS reverse proxy or SSH tunnel so the +Bearer token is encrypted in transit. The HTTP listener itself does not provide TLS. +Authentication does not make anonymous routes private: `/status` remains public +on the configured interface. Restart the game process after changing the bind, +key or `Enabled` setting; configuration reload does not restart the listener or +rotate its credential snapshot. + +To disable the API even when the shipped config contains the section, set +`"WebApiNetwork": { "Enabled": false }` in `Config.Local.json`. A missing or null +section also disables it. Existing clients must add the Bearer header to every +`/api` request; local `/status` checks continue to work without credentials. + ## Tower defense event schedules Tower defense controllers are reserved for events instead of spawning permanently. diff --git a/Scripts/lane.sh b/Scripts/lane.sh index e81a2b0fbf..f8975f6920 100755 --- a/Scripts/lane.sh +++ b/Scripts/lane.sh @@ -39,6 +39,38 @@ setvar() { # setvar KEY VALUE: rewrite one KEY= line of the registry file local f; f=$(reg "$1"); grep -v "^$2=" "$f" > "$f.tmp" || true; echo "$2=$3" >> "$f.tmp"; mv "$f.tmp" "$f"; } mysql_up() { "${MYSQL[@]}" -N -e "select 1" >/dev/null 2>&1; } +# mkdir is atomic in Git Bash as well as on Unix (flock is not shipped with Git for Windows). +# Hold this across allocation AND publication, and serialize destructive cleanup with it too. +# Never reclaim a lock by PID or age: PIDs are reused, and a killed shell may leave git running. +# An interrupted/stale lock fails closed. After verifying ALL creators and their children have +# stopped, inspect its files and any partial worktree/branch/target before removing it manually. +allocation_lock() { + ALLOCATION_LOCK="$LANES/.allocation.lock" + ALLOCATION_OWNER="" + local timeout=${AAEMU_LANE_LOCK_TIMEOUT:-30} start=$SECONDS + [[ "$timeout" =~ ^[0-9]{1,6}$ ]] || die "AAEMU_LANE_LOCK_TIMEOUT must be seconds (0-999999)" + timeout=$((10#$timeout)) + mkdir -p "$LANES" + trap 'allocation_unlock' EXIT + trap 'exit 129' HUP; trap 'exit 130' INT; trap 'exit 143' TERM + until mkdir "$ALLOCATION_LOCK" 2>/dev/null; do + # The owner may release it between the failed mkdir and this loop; retry even if gone. + if (( SECONDS - start >= timeout )); then + die "allocation/cleanup locked ($ALLOCATION_LOCK); retry. If interrupted, verify all creators and children stopped and inspect partial resources before manual recovery; never remove a lock by PID or age" + fi + sleep 0.1 + done + # A unique marker also prevents our EXIT trap from releasing a replacement owner's lock. + # Interruption before the marker exists deliberately leaves a stale lock, never an unsafe unlock. + ALLOCATION_OWNER=$(mktemp -d "$ALLOCATION_LOCK/owner.XXXXXXXXXX") +} +allocation_owned() { [ -n "${ALLOCATION_OWNER:-}" ] && [ -d "$ALLOCATION_OWNER" ]; } +allocation_unlock() { + allocation_owned || return 0 + rm -f "$ALLOCATION_OWNER/lane.env" + rmdir "$ALLOCATION_OWNER" && rmdir "$ALLOCATION_LOCK" +} + # The lane whose worktree contains $PWD (or the script), unless a name was given. current() { local n=${1:-} @@ -65,7 +97,7 @@ clients_on() { } port_free() { ! netstat -ano 2>/dev/null | grep LISTENING | grep -q ":$1 "; } -cmd_new() { +cmd_new() ( local name="" type=fix base=$BASE_DEFAULT while [ $# -gt 0 ]; do case "$1" in @@ -74,13 +106,18 @@ cmd_new() { esac; shift done [[ "$name" =~ ^[a-z0-9][a-z0-9-]{1,30}$ ]] || die "name: 2-31 chars of a-z 0-9 - (e.g. quest-crash)" - [ -f "$(reg "$name")" ] && die "lane '$name' exists (Scripts/lane.sh info $name)" + allocation_lock + if [ -e "$(reg "$name")" ] || [ -L "$(reg "$name")" ]; then + die "lane '$name' exists (Scripts/lane.sh info $name)" + fi # Never share a target dir between worktrees: identical artifact names make cargo's mtime # fingerprints miss edits, so tests can silently run another worktree's code. local wt="$WT_ROOT/$name" branch="$type/$name" target="$TARGET_ROOT/$name" - [ -e "$wt" ] && die "$wt already exists" - [ -e "$target" ] && die "$target already exists (Scripts/lane.sh gc)" - mkdir -p "$LANES" + if [ -e "$wt" ] || [ -L "$wt" ]; then die "$wt already exists"; fi + if [ -e "$target" ] || [ -L "$target" ]; then die "$target already exists (Scripts/lane.sh gc)"; fi + git -C "$REPO" check-ref-format "refs/heads/$branch" || die "invalid branch '$branch'" + if git -C "$REPO" show-ref --verify --quiet "refs/heads/$branch"; then die "branch '$branch' already exists"; fi + local head; head=$(git -C "$REPO" rev-parse --verify "$base^{commit}") local prefix="" for p in "${PORT_PREFIXES[@]}"; do @@ -90,7 +127,60 @@ cmd_new() { done [ -n "$prefix" ] || die "no free port block (24xxx-39xxx); finish old lanes first" + # Until lane.env is published the lock reserves all four resources. Roll back only artifacts + # we know we created, while still holding that lock. Ambiguous/partial Git failures retain it + # for inspection rather than deleting a pre-existing branch or allowing prefix reuse. + local target_started=0 target_created=0 worktree_started=0 worktree_created=0 published=0 + new_exit() { + local status=$? clean=1 + trap - EXIT + if ! allocation_owned; then + echo "lane: allocation lock ownership lost; leaving resources untouched" >&2 + exit 1 + fi + if [ "$published" = 0 ] && [ ! "$(reg "$name")" -ef "$ALLOCATION_OWNER/lane.env" ]; then + if [ "$worktree_created" = 1 ]; then + rm -f "$wt/rust/.cargo/config.toml" || clean=0 + # No --force: unexpected changes or removal errors require inspection. + git -C "$REPO" worktree remove "$wt" || clean=0 + if [ "$clean" = 1 ]; then + git -C "$REPO" update-ref -d "refs/heads/$branch" "$head" || clean=0 + fi + elif [ "$worktree_started" = 1 ]; then + if [ -e "$wt" ] || git -C "$REPO" show-ref --verify --quiet "refs/heads/$branch"; then clean=0; fi + fi + if [ "$target_created" = 1 ] && [ "$clean" = 1 ]; then rmdir "$target" || clean=0; fi + if [ "$target_started" = 1 ] && [ "$target_created" = 0 ]; then + if [ -e "$target" ] || [ -L "$target" ]; then clean=0; fi + fi + fi + if [ "$clean" = 1 ]; then allocation_unlock + else echo "lane: partial creation retained with $ALLOCATION_LOCK; inspect $wt, $branch and $target before manual recovery" >&2; fi + exit "$status" + } + trap new_exit EXIT + # Leave the reservation details inside the lock for inspection after a hard interruption. + local db=${name//-/_} + cat > "$ALLOCATION_OWNER/lane.env" < "$wt/rust/.cargo/config.toml" < "$(reg "$name")" < = deadline: + raise TimeoutError(f"barrier not reached: {paths}") + time.sleep(0.02) + + +def fake_git(args): + """Only implement commands used by new/rollback; unexpected commands fail closed.""" + root = Path(os.environ["LANE_TEST_ROOT"]).resolve() + refs = root / "refs" + if args[:1] != ["-C"]: + raise AssertionError(args) + args = args[2:] + + def ref_path(ref): + return refs / ref.removeprefix("refs/heads/") + + def owned_path(value): + path = Path(value).resolve() + if not path.is_relative_to(root): + raise AssertionError(f"path outside fixture: {path}") + return path + + if args[:1] == ["check-ref-format"]: + return 0 + if args[:3] == ["show-ref", "--verify", "--quiet"]: + return 0 if ref_path(args[3]).is_file() else 1 + if args[:2] == ["rev-parse", "--verify"]: + if args[2] == "missing^{commit}": + return 70 + print(HEAD) + return 0 + if args[:2] == ["worktree", "add"]: + _, _, quiet, wt, flag, branch, base = args + assert (quiet, flag) == ("-q", "-b") + wt = owned_path(wt) + name = wt.name + (root / f"add.{name}").touch() + if os.environ.get("LANE_TEST_HOLD") == name: + wait_for(root / f"release.{name}") + failure = os.environ.get("LANE_TEST_FAIL") + if failure == "add": + return 70 + ref = ref_path(branch) + ref.parent.mkdir(parents=True, exist_ok=True) + with ref.open("x") as file: + file.write(HEAD) + wt.mkdir() + (wt / ".git").write_text("isolated fake worktree\n") + if failure == "partial-add": + return 70 + return 0 + if args[:2] == ["worktree", "remove"]: + if os.environ.get("LANE_TEST_FAIL") == "config-remove": + return 73 + wt = owned_path(args[2]) + shutil.rmtree(wt) + return 0 + if args[:2] == ["update-ref", "-d"]: + ref = ref_path(args[2]) + if not ref.is_file() or ref.read_text() != args[3]: + return 74 + ref.unlink() + return 0 + raise AssertionError(f"unexpected Git command: {args}") + + +class AllocationTests(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.bash = os.environ.get("LANE_TEST_BASH") + if not cls.bash and os.name == "nt": + git = shutil.which("git") + candidate = Path(git).parent.parent / "bin/bash.exe" if git else None + cls.bash = str(candidate) if candidate and candidate.exists() else None + cls.bash = cls.bash or shutil.which("bash") + if not cls.bash: + raise unittest.SkipTest("Bash (Git Bash on Windows) is required") + + def setUp(self): + # Keep scratch space in this checkout and delete it only after our subprocesses exit. + self.temp = tempfile.TemporaryDirectory(prefix=".lane-lock-test-", dir=SCRIPT.parent.parent) + self.root = Path(self.temp.name).resolve() + self.addCleanup(self.temp.cleanup) + self.processes = [] + self.addCleanup(self.reap) + self.repo = self.root / "repo" + (self.repo / "Scripts").mkdir(parents=True) + shutil.copyfile(SCRIPT, self.repo / "Scripts/lane.sh") + self.registry = self.root / "registry" + self.registry.mkdir() + self.lock = self.registry / ".allocation.lock" + self.shims = self.root / "shims" + self.shims.mkdir() + self.env = {key: value for key, value in os.environ.items() if not key.startswith("AAEMU_")} + self.env.update({ + "AAEMU_LANES": self.registry.as_posix(), + "AAEMU_WT_ROOT": (self.root / "wt").as_posix(), + "AAEMU_TARGET_ROOT": (self.root / "target").as_posix(), + "AAEMU_LIVE_PREFIX": (self.root / "live-").as_posix(), + "AAEMU_LIVE_TEMPLATE": (self.root / "template").as_posix(), + "AAEMU_MYSQL_BIN": self.shims.as_posix(), + "AAEMU_LANE_BASE": "fixture-base", + "AAEMU_LANE_JOBS": "2", + "AAEMU_LANE_LOCK_TIMEOUT": "30", + "LANE_TEST_ROOT": self.root.as_posix(), + "LANE_TEST_HELPER": Path(__file__).resolve().as_posix(), + "LANE_TEST_PYTHON": Path(sys.executable).as_posix(), + "LANE_TEST_SHIMS": self.shims.as_posix(), + # Even a broken shim setup must not discover the enclosing real repository. + "GIT_DIR": (self.repo / ".git").as_posix(), + "BASH_ENV": "", + "PATH": str(self.shims) + os.pathsep + self.env["PATH"], + }) + self.shim("git", 'exec "$LANE_TEST_PYTHON" "$LANE_TEST_HELPER" --fake-git "$@"') + self.shim("netstat", 'printf " TCP 127.0.0.1:25237 0.0.0.0:0 LISTENING 1\\n"') + self.shim("mkdir", ''' +case "${*: -1}" in + */.allocation.lock) + if /usr/bin/mkdir "$@"; then exit 0; fi + : > "$LANE_TEST_ROOT/blocked.${LANE_TEST_ID:-test}" + if [ "${LANE_TEST_HOLD_DENIED:-}" = "${LANE_TEST_ID:-test}" ]; then + start=$SECONDS + until [ -f "$LANE_TEST_ROOT/retry.$LANE_TEST_ID" ]; do + [ $((SECONDS - start)) -lt 30 ] || exit 98 + sleep 0.02 + done + fi + exit 1 ;; +esac +if [ "${*: -1}" = "$AAEMU_TARGET_ROOT/broken" ] && [ "${LANE_TEST_FAIL:-}" = term-target ]; then + /usr/bin/mkdir "$@" + kill -TERM "$PPID"; exit 0 +fi +exec /usr/bin/mkdir "$@" +''') + self.shim("cat", ''' +[ -f "$LANE_TEST_ROOT/refs/fix/broken" ] || exec /usr/bin/cat "$@" +case "${LANE_TEST_FAIL:-}" in + config|config-remove) exit 71 ;; + term-config) kill -TERM "$PPID"; exit 0 ;; + kill-config) kill -KILL "$PPID"; exit 0 ;; +esac +exec /usr/bin/cat "$@" +''') + self.shim("ln", ''' +case "${LANE_TEST_FAIL:-}" in + publish) exit 72 ;; + publish-moved) + printf '%040d' 0 > "$LANE_TEST_ROOT/refs/fix/broken" + exit 72 ;; + publish-term) + /usr/bin/ln "$@" + kill -TERM "$PPID"; exit 0 ;; +esac +exec /usr/bin/ln "$@" +''') + for command in ("cargo", "powershell", "taskkill", "mysql.exe"): + self.shim(command, f'echo "unexpected {command}" >> "$LANE_TEST_ROOT/forbidden"; exit 99') + + def shim(self, name, body): + path = self.shims / name + path.write_text("#!/usr/bin/env bash\nset -eu\n" + body + "\n", encoding="utf-8", newline="\n") + path.chmod(0o755) + + def reap(self): + # Unblock only our fixture children, even when an assertion fails. + for path in self.root.glob("add.*"): + (self.root / path.name.replace("add.", "release.", 1)).touch() + for path in self.root.glob("blocked.*"): + (self.root / path.name.replace("blocked.", "retry.", 1)).touch() + for process in self.processes: + try: + process.communicate(timeout=40) + except subprocess.TimeoutExpired: + process.kill() + process.communicate(timeout=40) + self.assertFalse((self.root / "forbidden").exists(), "a forbidden tool was invoked") + + def start(self, *args, **env): + process = subprocess.Popen( + # Git's bin/bash.exe launcher prepends /mingw64/bin and /usr/bin to PATH. + # Install shims inside that shell, then exec Bash directly so they stay first. + [self.bash, "--noprofile", "--norc", "-c", + 'export PATH="$(cd "$LANE_TEST_SHIMS" && pwd):$PATH"; ' + 'exec /usr/bin/bash --noprofile --norc "$@"', "lane-test", + (self.repo / "Scripts/lane.sh").as_posix(), *args], + cwd=self.repo, env=self.env | env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, + text=True, + ) + self.processes.append(process) + return process + + def finish(self, process, success=True): + output, _ = process.communicate(timeout=40) + if success: + self.assertEqual(process.returncode, 0, output) + else: + self.assertNotEqual(process.returncode, 0, output) + return output + + def create(self, name, **env): + return self.start("new", name, **env) + + def entry(self, name): + return dict(line.split("=", 1) for line in (self.registry / f"{name}.env").read_text().splitlines()) + + def assert_rolled_back(self, name): + for path in (self.root / "wt" / name, self.root / "target" / name, + self.root / "refs/fix" / name, self.registry / f"{name}.env", self.lock): + self.assertFalse(path.exists(), f"rollback left {path}") + + def test_concurrent_creators_get_distinct_prefixes_and_overrides(self): + # Preserve an existing lane and skip an occupied OS port (25237). + existing = self.registry / "running.env" + existing.write_text("PORT_PREFIX=24\nOTHER=unchanged\n", newline="\n") + first = self.create("first", LANE_TEST_HOLD="first", LANE_TEST_ID="first") + wait_for(self.root / "add.first") + second = self.start("new", "second", "--type", "feat", "--base", "explicit-base", + LANE_TEST_ID="second", LANE_TEST_HOLD_DENIED="second") + wait_for_any((self.root / "blocked.second", self.root / "add.second")) + self.assertFalse((self.root / "add.second").exists(), "second creator entered locked section") + (self.root / "release.first").touch() + self.finish(first) + # Return the failed mkdir only AFTER the owner removed the lock: acquisition must retry + # rather than treating this normal release race as an inability to create the lock. + (self.root / "retry.second").touch() + self.finish(second) + a, b = self.entry("first"), self.entry("second") + self.assertEqual(set(b), {"LANE", "BRANCH", "BASE", "WT", "TARGET", "PORT_PREFIX", "LIVE", + "DB_GAME", "DB_LOGIN", "CREATED", "CHECKED"}) + self.assertEqual((a["PORT_PREFIX"], b["PORT_PREFIX"]), ("26", "27")) + self.assertEqual((a["BASE"], b["BASE"], b["BRANCH"]), ("fixture-base", "explicit-base", "feat/second")) + self.assertEqual(b["WT"], (self.root / "wt/second").as_posix()) + self.assertEqual(b["TARGET"], (self.root / "target/second").as_posix()) + self.assertEqual(b["LIVE"], (self.root / "live-second").as_posix()) + self.assertEqual(b["DB_GAME"], "lane_second_game") + self.assertEqual(b["DB_LOGIN"], "lane_second_login") + self.assertEqual(b["CHECKED"], "") + config = (self.root / "wt/second/rust/.cargo/config.toml").read_text() + self.assertIn("jobs = 2", config) + self.assertIn(f'target-dir = "{b["TARGET"]}"', config) + self.assertTrue(Path(b["TARGET"]).is_dir()) + self.assertEqual(existing.read_text(), "PORT_PREFIX=24\nOTHER=unchanged\n") + self.assertFalse(self.lock.exists()) + + def test_concurrent_same_name_has_one_owner(self): + first = self.create("same", LANE_TEST_HOLD="same") + wait_for(self.root / "add.same") + second = self.create("same", LANE_TEST_ID="second") + wait_for(self.root / "blocked.second") + (self.root / "release.same").touch() + self.finish(first) + self.assertIn("lane 'same' exists", self.finish(second, success=False)) + self.assertTrue((self.root / "wt/same/.git").is_file()) + self.assertEqual(self.entry("same")["PORT_PREFIX"], "24") + self.assertFalse(self.lock.exists()) + + def test_existing_registry_path_target_and_branch_are_never_removed(self): + paths = { + "entry": self.registry / "entry.env", + "worktree": self.root / "wt/worktree/keep", + "target": self.root / "target/target/in-use", + "branch": self.root / "refs/fix/branch", + } + for name, path in paths.items(): + with self.subTest(name=name): + path.parent.mkdir(parents=True, exist_ok=True) + path.write_text("preserve") + self.finish(self.create(name), success=False) + self.assertEqual(path.read_text(), "preserve") + self.assertFalse((self.root / f"add.{name}").exists()) + self.assertFalse(self.lock.exists()) + + def test_failures_roll_back_only_the_failed_creator_and_release_lock(self): + self.finish(self.create("keeper")) + before = (self.registry / "keeper.env").read_bytes() + for failure in ("add", "config", "publish", "term-config"): + with self.subTest(failure=failure): + self.finish(self.create("broken", LANE_TEST_FAIL=failure), success=False) + self.assert_rolled_back("broken") + self.assertEqual((self.registry / "keeper.env").read_bytes(), before) + self.assertTrue((self.root / "wt/keeper/.git").exists()) + self.finish(self.create("broken")) + self.assertEqual(self.entry("broken")["PORT_PREFIX"], "26") + + def test_missing_base_or_exhausted_prefixes_release_lock_without_creating_resources(self): + self.finish(self.start("new", "broken", "--base", "missing"), success=False) + self.assert_rolled_back("broken") + for prefix in range(24, 40): + (self.registry / f"occupied{prefix}.env").write_text(f"PORT_PREFIX={prefix}\n", newline="\n") + output = self.finish(self.create("broken"), success=False) + self.assertIn("no free port block", output) + self.assert_rolled_back("broken") + self.assertFalse((self.root / "add.broken").exists()) + + def test_partial_git_failure_retains_reservation(self): + output = self.finish(self.create("broken", LANE_TEST_FAIL="partial-add"), success=False) + self.assertIn("partial creation retained", output) + self.assertTrue((self.root / "refs/fix/broken").exists()) + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertTrue((self.root / "target/broken").exists()) + self.assertTrue(self.lock.exists()) + self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertFalse((self.root / "add.other").exists()) + + def test_registry_publication_never_clobbers_an_existing_file_or_directory(self): + for name, directory in (("fileowner", False), ("dirowner", True)): + with self.subTest(directory=directory): + process = self.create(name, LANE_TEST_HOLD=name) + wait_for(self.root / f"add.{name}") + entry = self.registry / f"{name}.env" + if directory: + entry.mkdir() + marker = entry / "keep" + else: + marker = entry + marker.write_text("another owner") + (self.root / f"release.{name}").touch() + self.finish(process, success=False) + self.assertEqual(marker.read_text(), "another owner") + if directory: + self.assertEqual(list(entry.iterdir()), [marker]) + for path in (self.root / "wt" / name, self.root / "target" / name, + self.root / "refs/fix" / name, self.lock): + self.assertFalse(path.exists(), f"rollback left {path}") + + def test_signal_immediately_after_publication_preserves_committed_lane(self): + self.finish(self.create("broken", LANE_TEST_FAIL="publish-term"), success=False) + self.assertEqual(self.entry("broken")["PORT_PREFIX"], "24") + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertTrue((self.root / "target/broken").exists()) + self.assertTrue((self.root / "refs/fix/broken").exists()) + self.assertFalse(self.lock.exists()) + self.finish(self.create("other")) + self.assertEqual(self.entry("other")["PORT_PREFIX"], "26") + + def test_cleanup_failure_does_not_delete_moved_branch(self): + self.finish(self.create("broken", LANE_TEST_FAIL="publish-moved"), success=False) + self.assertEqual((self.root / "refs/fix/broken").read_text(), "0" * 40) + self.assertTrue(self.lock.exists()) + self.assertTrue((self.root / "target/broken").exists()) + + def test_failed_worktree_removal_retains_branch_and_lock(self): + self.finish(self.create("broken", LANE_TEST_FAIL="config-remove"), success=False) + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertEqual((self.root / "refs/fix/broken").read_text(), HEAD) + self.assertTrue(self.lock.exists()) + + def test_hard_interruption_keeps_lock_until_manual_inspection(self): + self.finish(self.create("broken", LANE_TEST_FAIL="kill-config"), success=False) + self.assertTrue(self.lock.exists()) + self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertTrue((self.root / "refs/fix/broken").exists()) + self.assertFalse((self.root / "add.other").exists()) + journal, = self.lock.glob("owner.*/lane.env") + self.assertIn("LANE=broken\n", journal.read_text()) + self.assertIn("PORT_PREFIX=24\n", journal.read_text()) + + def test_signal_after_target_mkdir_retains_ambiguous_reservation(self): + output = self.finish(self.create("broken", LANE_TEST_FAIL="term-target"), success=False) + self.assertIn("partial creation retained", output) + self.assertTrue((self.root / "target/broken").is_dir()) + self.assertTrue(self.lock.is_dir()) + self.assertFalse((self.root / "add.broken").exists()) + self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertFalse((self.root / "add.other").exists()) + + def test_stale_empty_or_pid_reused_lock_is_never_reclaimed(self): + self.lock.mkdir() + self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertEqual(list(self.lock.iterdir()), []) + for content in ("", f"PID={os.getpid()}\nSTARTED=1900-01-01\n", "PID=999999999\n"): + with self.subTest(content=content): + owner = self.lock / "owner.stale" + owner.write_text(content) + os.utime(self.lock, (1, 1)) + output = self.finish(self.create("other", AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertIn("never remove a lock by PID or age", output) + self.assertEqual(owner.read_text(), content) + self.assertFalse((self.root / "add.other").exists()) + + def test_cleanup_never_releases_a_replacement_owners_lock(self): + process = self.create("broken", LANE_TEST_HOLD="broken", LANE_TEST_FAIL="config") + wait_for(self.root / "add.broken") + self.lock.rename(self.registry / "old-lock") + self.lock.mkdir() + replacement = self.lock / "owner.replacement" + replacement.write_text("another creator") + entry = self.registry / "other.env" + entry.write_text("PORT_PREFIX=24\n") + (self.root / "release.broken").touch() + self.assertIn("ownership lost", self.finish(process, success=False)) + self.assertEqual(replacement.read_text(), "another creator") + self.assertEqual(entry.read_text(), "PORT_PREFIX=24\n") + self.assertTrue((self.root / "wt/broken/.git").exists()) + self.assertTrue((self.root / "target/broken").exists()) + + def test_waiters_and_destructive_cleanup_cannot_release_an_active_creators_lock(self): + process = self.create("first", LANE_TEST_HOLD="first") + wait_for(self.root / "add.first") + for args in (("new", "second"), ("done", "first", "--force"), ("gc", "--apply")): + with self.subTest(args=args): + self.finish(self.start(*args, AAEMU_LANE_LOCK_TIMEOUT="0"), success=False) + self.assertTrue(self.lock.exists()) + self.assertTrue((self.root / "target/first").is_dir()) + (self.root / "release.first").touch() + self.finish(process) + + +if __name__ == "__main__": + if sys.argv[1:2] == ["--fake-git"]: + sys.exit(fake_git(sys.argv[2:])) + unittest.main(verbosity=2) diff --git a/rust/Cargo.lock b/rust/Cargo.lock index 52e779434d..190c500796 100644 --- a/rust/Cargo.lock +++ b/rust/Cargo.lock @@ -52,6 +52,7 @@ dependencies = [ "serde", "serde_json", "sqlx", + "subtle", "thiserror 1.0.69", "tokio", "tokio-util", diff --git a/rust/crates/aaemu-game/Cargo.toml b/rust/crates/aaemu-game/Cargo.toml index c7cc92ade8..2214d62f70 100644 --- a/rust/crates/aaemu-game/Cargo.toml +++ b/rust/crates/aaemu-game/Cargo.toml @@ -35,8 +35,12 @@ aes.workspace = true cbc.workspace = true roxmltree.workspace = true rand.workspace = true +subtle.workspace = true axum.workspace = true twilight-gateway.workspace = true twilight-http.workspace = true twilight-model.workspace = true +[dev-dependencies] +tokio = { workspace = true, features = ["test-util"] } + diff --git a/rust/crates/aaemu-game/PORTING.md b/rust/crates/aaemu-game/PORTING.md index 2d9fa9895d..9ec47922e9 100644 --- a/rust/crates/aaemu-game/PORTING.md +++ b/rust/crates/aaemu-game/PORTING.md @@ -168,6 +168,54 @@ Each subsystem records its status here, in its own section only (see `CONTRIBUTI | Movement hooks (`CSMoveUnit.RemoveEffects`, `Character.SetPosition` Move removal, fall damage) | `systems/skills/mod.rs` (`on_move_request`, `on_moved`) | done | Called from `world::session::move_unit`. | | `Skill.EndChanneling` target buff (`ChannelingTargetBuffId`) | `systems/skills/{skill,buffs}.rs` (`end_channeling`, `finish_effect_by_skill`) | deviation | **Deviation:** the C# `Buffs.RemoveEffect(templateId, skillId)` raised the buff's `OnTimeout` triggers on every removal; the Rust removal skips them for explicit removals (dispels, a stopped channel; see the FISH escape in `buff_removal_tests.rs`). Quest item grants hang on that trigger (GainItem on buff 3896 of skill 18449 'Extract Earth Crystal', 4 s channel under a 6 s buff, and the other channeling-target-buff quest skills of the item triage), so a channel that **runs to its end** now fires the target buff's Timeout triggers before removing it. A stopped / cancelled channel fires nothing (the C# granted the item then too). The caster-side `ChannelingBuffId` and buffs applied by skill effects (buff 1963 of 'Capture Crayfish') are unchanged: the latter expire on their own timer and fire Timeout already. | +#### Raw attribute bounds and permanent pStats (2026-10-25) + +`systems::skills`: all 21 `unit_attribute_limits` overrides are loaded with native +defaults of -2,000,000,000..2,000,000,000 (1.2 `39577A20`, +`D:/aa-re/client12/decomp/x2game12.c:1178985`, `:1179175-1179181`). The consumer +`398A0BC0` calls `395729F0` after formula, equipment and bonus arithmetic +(`:1991333-1991338`, clamp at `:1169345-1169352`), before raw-unit conversions. +The server preserves its existing bonus ordering and units and applies this final +raw bound to character, NPC and vehicle calculations and direct UnitBase readers +(XP and haste included). MoveSpeedMul starts at 1000, so its 3000 maximum means +3x speed; ExpMul starts at 100 percentage points and has range 0..500. Limits are +per-GameServer data shared by Arc with each unit, including detached refresh paths. +As a numeric-safety policy, infinities saturate, NaN uses zero within the range, +and NPC/vehicle integer bonus intermediates are widened before the final cap. +This does not claim native parity for extreme overflow or non-finite inputs. + +The five `character_p_stat_limits` rows (0..10000) are loaded separately. Native +`39752FC0` loads max/min (`:1647826-1647832`), and `3939DD10` checks proposed +permanent pStat + delta (`:765713-765775`); they are **not final primary stat caps**. +Character still lacks permanent pStat contribution state/persistence, and +`world/unit_state.rs` emits six zero pStats. That feature remains open. Applying +the table to final character attributes or to NPC/mate/slave primaries would +invent a different rule. No storage, wire format or client/compact assets change. + +#### AoE diminishing compatibility policy (2026-10-25) + +`systems::skills`: `aoe_diminishings` loads authored float percentages by id (native 1.2 +`sub_39620E90`, `D:/aa-re/client12/decomp/x2game12.c:1321108`). Searing Rain 11939 / plot 1 +resets through plot-effect row 5680 (descriptor 2, event 246); next-event 288 repeats every +500 ms. Next-event 3195 fans event 3 out per target at speed 20 to flagged event 2723 / Damage +3172. Thus resetting on each child invocation would give every projectile the first rate. + +The chosen **server compatibility policy is provisional, not proven retail parity**: each plot +instance keeps first-seen distinct-target ranks in existing execution order, shared across +sibling damage events. Misses and immunity occupy ranks; repeat hits reuse their wave rank. +Only flagged plot Damage effects participate. Reset clears only the calling plot's map. +Targets beyond the last authored id use its final rate; storage is limited to N identities, +where N is the last authored id (10 in 1.2). Rates apply after existing damage/modifier reductions to the +integer result, then truncate with minimum 1 for landed damage, as the native 1.2 diagnostic +`sub_39898330` describes (`x2game12.c:1984147-1984167`). Other damage, heals, buffs and CC retain +their existing paths, and wire formats are unchanged. + +The native damage diagnostic (10.x `sub_39CECDB0`, parameter `+444`) is serialized debug data +supplied by the world server; the available client/zone plot dispatcher executes visual +effects, not the authoritative counter. Its producer is unavailable in these binaries. +`plots::aoe_tests::aoe_policy_*` covers the compatibility policy through plot/combat flows; +an authoritative native lifecycle experiment and live verification remain unperformed. + #### Special effects added from data (2026-10-20) These `SpecialType` bodies were TODO stubs that only logged in the C# (`git show a2ab80abd^:AAEmu.Game/Models/Game/Skills/Effects/SpecialEffects/...`); the behaviour below is derived from the 1.2 data because value1..4 are 0. @@ -231,6 +279,56 @@ connected by `systems::economy::wiring`). | Item skill-effect bodies (grade enchant, socketing, conversion, cap scale, UCC imprint, ...), mate / slave equipment packets | `systems/economy/item_effects*.rs` | done | Called by the skills subsystem's effects. UCC imprint / cleanup require owned source and target items; client UCC casts require the actual source item's configured use skill, preserving the unrelated legacy bound-item portal exception. Dyeing checks the loaded `dyeable_items` allowlist. Invalid UCC / dye effects cancel deferred reagent consumption. | | Item skill-effect stubs given data-derived bodies (`GainItemWithPosImprint` 32, `RechargeItemBuff` 95, `ExpToItem` 96) | `systems/economy/item_effects.rs` | done (data-derived) | The C# `Execute` bodies were `// TODO` stubs, so the behaviour comes from `special_effects` 405 / 546 / 547 / 548 (32: create `value1` x1 with `SkillEffectGainItemWithPos`), 12446 / 17017 (95) and 12462 (96: `value1` XP -> `value2` x1 with `SkillEffectExpToItem`) plus the tool skills that cast them. `GainItemWithPosImprint` stores no position imprint: the 1.2 item details have no such field. `ExpToItem` subtracts the experience directly instead of through `AddExp` (which recomputes the level and could level the character down), sends `SCExpChangedPacket(-value1)`, checks bag room before spending the XP, and cancels so the reagent is kept. `RechargeItemBuff` takes the cast's item target, resets `charge_start_time` (and `charge_count` when the template has one) and re-applies the equipped item's gear buff through `apply_gear_buffs` with the item both removed and added, so the recharge buff is not stacked; the 1 s item timers read the new charge window on their next tick, so nothing is re-scheduled. | +#### Cargo escrow and stale rack references (2026-10-25) + +Merchant-ship rack deposits now revalidate the exact equipped pack and a vacant +rack in one economy transaction. Recovery validates System escrow and backpack +space, moves the same item ID, and clears the rack reference together. A rejected +pickup preserves the pack, the current backpack and recorded item effects. +The shared path covers other hulls and ordinary racks; the real-data regression +uses Merchant hull 75, item 23398 and its twenty attachment points 60..79. + +Error 14 (`INTERACTION_RECOVER_PARENT`) on this path means the referenced item is +outside System escrow; it does not establish that another pack is physically on +top. The separate persistent-child removal check uses error 207. Provably dangling +persistent cargo references can return to the authored empty phase without moving +or creating an item. Ambiguous references remain blocked with rack/item/container +and hull diagnostics; current child allocation identity and parent/instance must +match before a child can block repair or removal. + +Both live and saved-row cleanup receive the original doodad metadata. Original +rack/cargo/Slave references never authorize deleting the current item at a recycled +GUID. Ordinary furniture cleanup requires a unique singleton matching the original +template and owner in that owner's System escrow. Items in inventory, equipment, +bank or another owner's containers are retained. Saved container GUIDs alone never +authorize container deletion. Saved-row removal checks its selected reference +fields before invoking cleanup. + +This conservative policy protects unloaded rack aliases and recovered/recycled +items. Metadata matching does not establish allocation generation. Cargo and +ambiguous item references, plus saved containers, may be retained after the last +rack disappears; reconciliation and orphan collection remain open. Regression +sources cover shuffled twenty-rack cycles, stale sources, failed recovery, +allocator reuse and private-MySQL saved aliases. At `198b7d482`, the official lane +check, the game unit suite, the real-compact twenty-rack cycles and both private-MySQL +cargo fixtures pass. A bounded headless live run with one fresh owner (80 positive rack +operations over four passes, forty drops, twenty pickups) kept the twenty original +item IDs through every cycle and ended with twenty System ground references and twenty +empty saved racks; an independent cargo and SQL audit found no P1/P2 for that +positive run. The same run's bag-full negative left items, racks and phases unchanged, +and a hard close with reselect kept the same loaded hull registered with a single +current root. In a second summon of the same item the skill executed (started, fired, +ended); the subsequent loaded-hull replacement was refused with error 801 +(`SLAVE_EQUIPMENT_LOADED_ITEM`), the loaded hull, racks, cargo and phases were +preserved and only the initial SCSlaveCreated appears in the captures. That shows +loaded-hull preservation; unloaded replacement and completion of the 600-second +timer were not exercised in this live run. This is observational evidence on the +Rust-server path, not retail parity or global atomicity; the post-STOP SQL proves +persisted state, not save order, and the process stop was forced, so the logs are not +warning- or error-free. Independent cargo/SQL and control reviews support this +bounded observation with that replacement-refusal qualification; wider audit items +remain open. + ### systems::social | Area (C#) | Rust | Status | Notes | @@ -319,6 +417,45 @@ Cross-subsystem: mates are despawned on dungeon entry and `PlayerCanEnter` check | `BaseUnit.GetDistanceTo` for shipyard targets (skill range check, `Skill.cs` `max_range`) | `systems/skills/geometry.rs` (`distance_to`), `systems/vehicles/shipyards.rs` (`shipyard_radius`) | deviation | **Deviation:** the C# measured skill range to the shipyard's center point (shipyard models are prefab models without an actor radius, so `ModelSize` was 0), which made the shipyard build skills (`min_range 0`, `max_range 4`) unusable anywhere but the exact center of a drydock ("Target is too far"). The Rust subtracts the shipyard template's `build_radius * Scale`, like the house `GardenRadius` rule. | | Mate / slave / transfer / shipyard C2G and G2C packets | `systems/vehicles/packets.rs` | done | 18 C->S, 16 S->C (byte-exact tests). `CSChangeSlaveTargetPacket` has no 1.2 opcode (0xfff). | | Hooks / physics | `systems/vehicles/{hooks,ship_physics}.rs` | done | `VehicleItemHooks` (`EndCraft`, economy). Ship physics and water call `systems::ai::physics` directly (`AddShip` / `RemoveShip`, helm request, driver seat, `GetWaterSurface` / `IsWater`); `ShipPhysicsHooks` (harpoon lines / tension / lifetime, `Throttle` / `Steering` after a move) and the radar ship lists are installed here. The npcs / social hooks call the mate / slave / dismount functions directly. | +#### Summon replacement and retained cargo (2026-10-25) + +Player summons use root-only owner lookup across worlds and serialize requests by +owner and persistent summon item. Session/departure generations and allocation +identity are checked again after loading. Saved hull, child and doodad rows load +before replacement; query failures, item-update failures, loaded-hull removal +refusal and invalid explicit placement stop without replacing the prior hull. +Invalid placement now refuses rather than falling back to another position. + +The final synchronous publication boundary coordinates ordinary item operations, +direct despawn and current-session identity. Loaded cargo receipts are checked +against the exact live hull/rack allocation and unique matching System escrow +before metadata changes or deletion. This rejects a stale loaded row fetched +before its original pack was recovered. Different inactive saved hulls can still +restore legitimate cargo belonging to another player. The existing 600-second +offline retention and delayed portal rendering remain intentional. + +The per-server item outer scope is thread-bound and reentrant; the inner economy +ops mutex remains nonreentrant. Callback-bearing paths acquire the outer scope +before existing auction/housing/spawn locks; callbacks retain their normal +placement outside ops/object guards. No synchronous guard spans an await. +Guardless quest item operations and direct writes bypassing coordinated APIs +remain explicit limits, rather than a claim of global lock freedom. + +The read-only `/slave audit` command reports registered and retained allocations, +pending task leases, item identities and rack observations with bounded replies. +It explicitly returns `consistent:false` and `authority_consistent:false`: queue, +HP, world-removal and temporal phase/transform observations do not share a global +snapshot boundary. Normalized, filtered headless control captures supplement these +observations; they do not establish native UI behavior or original compressed wire +bytes. Deterministic flow tests cover the concurrency cases separately. The +combined source has passed independent reviews and all-target compilation; +all 57 Testclient library and 16 control/config tests pass at `96a67a5a7`. +These include literal native decoding, filtered compressed batches, real loopback +socket closure and timeout completion. Synchronous checks reject expired output, +command and global budgets before polling gameplay: an already-expired Tokio +timer alone can initially return Pending. Final combined Game tests, lane CI and +live acceptance remain pending. + ### systems::services | Area (C#) | Rust | Status | Notes | @@ -903,6 +1040,14 @@ is no longer mirrored (see "Known deviations", dead NPC returned and healed). `CSBuySpecialtyItemPacket`, `CSReturnMailPacket` have no 1.2 opcode (0xfff): decoders exist, the 1.2 client never sends them. The specialty / trade-pack mail delay use the C# defaults (no `Specialty` config section yet). +* systems::economy (native 1.2 protocol, 2026-10-25): correction to the preceding ReturnMail + claim: the Return button (`read_mail.lua:946`) calls `ReturnMailById` (`3948B630` -> + `393CD290`), which sends opcode `0xa3` with an i64 mail id (`397BA450`). The preserved + opcode table misnames that slot `CSReportSpamPacket`; economy now registers ReturnMail + using that legacy constant, and social no longer claims it. The historical C# registry + fixture stays intact with an explicit native correction in its comparison test. Native + `SCLootItemFailedPacket` reader `397C2F00` consumes `ErrorMessage:i16`, an eight-byte + lootable and `type:u32` (14 bytes); the C# int error width is no longer mirrored. * systems::economy: the localized item names are loaded by four modules (items search, auction, mail, cash shop); a later cleanup can share one cache. * systems::services: authenticated `CSRequestCharBriefPacket` and `CSCharDetailPacket` requests @@ -1218,6 +1363,12 @@ is no longer mirrored (see "Known deviations", dead NPC returned and healed). `CreatedAt` of characters created in the running session is written without the `Z` of a `DateTimeKind.Utc` value. The auction controllers serialise the lot's `Item` with its stored fields only (Id, TemplateId, Count, Grade, OwnerId, SlotType, Slot). +* systems::services (WebApi security, 2026-10-25): unlike C#, the HTTP listener defaults to + loopback and rejects non-loopback binds without a configured `WebApiNetwork.ApiKey`. + Every route except read-only `GET /status` requires a Bearer credential, compared using + `subtle::ConstantTimeEq`; an absent or empty key grants no administrative access, including + on localhost. `Enabled: false` disables the listener. Keys and bind settings are snapshotted + at listener start; changes require restart. Existing tools must add the Authorization header. * systems::services: `TaskManager.GetQueueCount` (WebApi `/status`) only counts the tasks of this queue; the other subsystems run their timers as Tokio tasks. * systems::services: `TimedRewardsManager.DoTick` skips connections without an account (C# diff --git a/rust/crates/aaemu-game/README.md b/rust/crates/aaemu-game/README.md index b3b07889de..149bb1224b 100644 --- a/rust/crates/aaemu-game/README.md +++ b/rust/crates/aaemu-game/README.md @@ -58,8 +58,10 @@ The configuration structure is as follows: "Port": 1250 }, "WebApiNetwork": { - "Host": "*", - "Port": 1280 + "Host": "127.0.0.1", + "Port": 1280, + "Enabled": true, + "ApiKey": null }, "LoginNetwork": { "Host": "%login_host%", <-- the IP address of the login server @@ -81,6 +83,12 @@ The configuration structure is as follows: ### Create Configuration File +The Web API permits anonymous `GET /status` only. All `/api` routes require an +explicit `WebApiNetwork.ApiKey` through the `Authorization: Bearer ` header; +a missing key disables those routes. Non-loopback binds require a key or startup +fails. See the [Web API migration guide](../../../Docs/wiki/Working-with-the-Config.json-files-and-server-listings.md#web-api-authentication-and-migration) +for private key generation, remote access and disabling the listener. + 1. Create a file named `Config.Local.json` next to `Config.json` in the application directory (by default `rust/crates/aaemu-game/app/`). It is gitignored and overrides the default `Config.json` with your local changes. `ExampleConfig.Local.json` is a starting point. diff --git a/rust/crates/aaemu-game/app/Config.json b/rust/crates/aaemu-game/app/Config.json index dfe19d7640..802afa1ab5 100644 --- a/rust/crates/aaemu-game/app/Config.json +++ b/rust/crates/aaemu-game/app/Config.json @@ -12,8 +12,10 @@ "Port": 1250 }, "WebApiNetwork": { - "Host": "*", - "Port": 1280 + "Host": "127.0.0.1", + "Port": 1280, + "Enabled": true, + "ApiKey": null }, "LoginNetwork": { "Host": "%login_host%", diff --git a/rust/crates/aaemu-game/app/Data/slave_attach_points.json b/rust/crates/aaemu-game/app/Data/slave_attach_points.json index 00b7b53005..3d5c8c5d6d 100644 --- a/rust/crates/aaemu-game/app/Data/slave_attach_points.json +++ b/rust/crates/aaemu-game/app/Data/slave_attach_points.json @@ -2520,5 +2520,791 @@ "Z": 11.144756 } } + }, + { + "Name": "Native 1.2 model 5", + "ModelId": 5, + "AttachPoints": { + "24": { + "X": -1.42433345, + "Y": -6.89326668, + "Z": 0.83646423, + "Roll": 7.89580808, + "Pitch": 0.0, + "Yaw": 179.99999135 + }, + "35": { + "X": -0.39981079, + "Y": 2.3511963, + "Z": 15.238708, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "81": { + "X": -1.98440182, + "Y": -1.09256768, + "Z": 14.48642063, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 867", + "ModelId": 867, + "AttachPoints": { + "35": { + "X": 0.0, + "Y": -2.2049498, + "Z": 2.60459892, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 892", + "ModelId": 892, + "AttachPoints": { + "9": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 898", + "ModelId": 898, + "AttachPoints": { + "9": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 899", + "ModelId": 899, + "AttachPoints": { + "9": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 1024", + "ModelId": 1024, + "AttachPoints": { + "9": { + "X": -4.29276672, + "Y": 2.23506424, + "Z": 4.4205661, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 83.00000122 + }, + "10": { + "X": -4.4767865, + "Y": 0.2020467, + "Z": 4.48708954, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 83.99995896 + }, + "11": { + "X": -4.57174072, + "Y": -3.67801453, + "Z": 4.64193115, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 92.00001601 + }, + "12": { + "X": -4.46449463, + "Y": -5.55405579, + "Z": 4.74579041, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 93.99999888 + }, + "13": { + "X": 4.30832184, + "Y": 2.23506409, + "Z": 4.4205661, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -82.00000269 + }, + "14": { + "X": 4.49234192, + "Y": 0.20204668, + "Z": 4.48708954, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -86.00000112 + }, + "15": { + "X": 4.58729614, + "Y": -3.67801453, + "Z": 4.64193115, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -92.99999467 + }, + "16": { + "X": 4.48005005, + "Y": -5.5540564, + "Z": 4.74579102, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -93.99998923 + }, + "17": { + "X": -0.02580078, + "Y": -17.12161865, + "Z": 6.53128357, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "19": { + "X": -1.91e-06, + "Y": 10.39880371, + "Z": 4.53841064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "20": { + "X": 6.1e-07, + "Y": -2.66621552, + "Z": 4.55662964, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "21": { + "X": -1.34e-06, + "Y": 10.39880371, + "Z": 4.53841064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "22": { + "X": 1.13e-06, + "Y": -2.66621552, + "Z": 4.55662811, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "23": { + "X": 0.0, + "Y": 13.83623413, + "Z": 4.65069, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "24": { + "X": -3.63965759, + "Y": -8.43711731, + "Z": 1.66250549, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 90.0 + }, + "25": { + "X": 3.16607452, + "Y": -8.43917725, + "Z": 1.51600861, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -90.0 + }, + "26": { + "X": -4.9426236, + "Y": 9.73896606, + "Z": 4.52553986, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "27": { + "X": 4.81819489, + "Y": 9.7243042, + "Z": 4.52553986, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -173.00000315 + }, + "28": { + "X": -3.58012238, + "Y": -10.39539673, + "Z": 8.99327942, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 21.64487823 + }, + "29": { + "X": 3.62164337, + "Y": -10.28855225, + "Z": 8.99328064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -9.99999827 + }, + "35": { + "X": 0.00038204, + "Y": -13.99029541, + "Z": 6.92423584, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 1.19121086, + "Y": 14.19112061, + "Z": 5.12247559, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "37": { + "X": 5.11665863, + "Y": -0.7226757, + "Z": 3.33382629, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "38": { + "X": -0.24652342, + "Y": -8.87354675, + "Z": 5.2601709, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "39": { + "X": -0.92987915, + "Y": -10.47005615, + "Z": 1.97258972, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "46": { + "X": -0.07826172, + "Y": -3.24843933, + "Z": 38.54605469, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "58": { + "X": -1.04451965, + "Y": -14.86150757, + "Z": -2.14507004, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 179.99998133 + }, + "59": { + "X": 1.04451706, + "Y": -14.86150879, + "Z": -2.145065, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 179.99996403 + } + } + }, + { + "Name": "Native 1.2 model 1287", + "ModelId": 1287, + "AttachPoints": { + "2": { + "X": -0.47789001, + "Y": 0.36952, + "Z": 0.9364399, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "35": { + "X": 0.39533997, + "Y": -0.12314003, + "Z": 1.41565994, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.0, + "Y": -1.81697433, + "Z": 1.82779999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 1323", + "ModelId": 1323, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1371", + "ModelId": 1371, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1385", + "ModelId": 1385, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 15.15861938, + "Z": 1.93809326, + "Roll": -1.6090013, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "22": { + "X": 0.0, + "Y": 1.55865067, + "Z": 1.32873474, + "Roll": -1.6090013, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "24": { + "X": -2.40109009, + "Y": 12.69552368, + "Z": -1.10956696, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 71.01340743 + }, + "25": { + "X": 2.44303604, + "Y": 12.69552246, + "Z": -1.10635902, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -63.9865921 + }, + "36": { + "X": -1.60562973, + "Y": -2.22354645, + "Z": 1.34844727, + "Roll": -31.84449881, + "Pitch": 3.04776432, + "Yaw": -147.0619414 + }, + "37": { + "X": 2.99039398, + "Y": -0.53385757, + "Z": 1.22506035, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "38": { + "X": 0.76255249, + "Y": -10.80150879, + "Z": 1.83097321, + "Roll": -17.3346917, + "Pitch": -3.82501679, + "Yaw": -150.04003415 + }, + "39": { + "X": -1.69008774, + "Y": 13.50393433, + "Z": 1.87254852, + "Roll": -66.7200763, + "Pitch": -66.38009821, + "Yaw": 66.34809364 + }, + "58": { + "X": -1.91337097, + "Y": -12.50181641, + "Z": -1.46283188, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -179.99999135 + }, + "59": { + "X": 1.91337036, + "Y": -12.50181641, + "Z": -1.46283188, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -179.99999135 + }, + "60": { + "X": -2.38570313, + "Y": 12.47859131, + "Z": 4.42517761, + "Roll": -5.84543976, + "Pitch": 0.01637078, + "Yaw": 86.80389012 + }, + "61": { + "X": 3.77372406, + "Y": 11.7718396, + "Z": 5.30033264, + "Roll": 14.61988617, + "Pitch": -3.46511977, + "Yaw": 108.08774205 + }, + "62": { + "X": -4.77853394, + "Y": 2.81668457, + "Z": 3.8049884, + "Roll": -17.63500494, + "Pitch": 5.84323429, + "Yaw": 77.92499954 + }, + "63": { + "X": 3.68675873, + "Y": 3.93022034, + "Z": 3.87374054, + "Roll": 13.35100355, + "Pitch": -3.18382401, + "Yaw": 86.95435664 + }, + "64": { + "X": -3.90936157, + "Y": -4.94448669, + "Z": 5.00377747, + "Roll": -2.59864108, + "Pitch": -1.49955419, + "Yaw": 69.03402673 + }, + "65": { + "X": 1.47495453, + "Y": -10.06739441, + "Z": 4.89309875, + "Roll": 10.83311746, + "Pitch": -1.54938953, + "Yaw": 123.05834985 + }, + "66": { + "X": -2.29154297, + "Y": 6.43949036, + "Z": -0.64560669, + "Roll": -131.47489857, + "Pitch": 12.30072769, + "Yaw": 70.05732348 + }, + "67": { + "X": 2.25987289, + "Y": 8.95768433, + "Z": -0.4294125, + "Roll": 130.59802495, + "Pitch": -14.98278824, + "Yaw": 79.18461482 + }, + "68": { + "X": -2.20217819, + "Y": -8.47400269, + "Z": -0.35781158, + "Roll": -131.09412862, + "Pitch": 10.24646171, + "Yaw": 77.10754877 + }, + "69": { + "X": 1.90979797, + "Y": -8.05894348, + "Z": -1.06294098, + "Roll": 133.31709473, + "Pitch": -12.74193914, + "Yaw": 70.72046603 + }, + "70": { + "X": -0.58215088, + "Y": 5.17909302, + "Z": 1.28867584, + "Roll": 1.18520879, + "Pitch": -0.6037615, + "Yaw": -0.27913618 + }, + "71": { + "X": 0.6358844, + "Y": 5.21191528, + "Z": 1.29706161, + "Roll": 1.15850286, + "Pitch": -0.99305488, + "Yaw": 0.09124448 + }, + "76": { + "X": -0.58215027, + "Y": -2.47363617, + "Z": 1.28406952, + "Roll": -2.97758005, + "Pitch": -0.60376143, + "Yaw": -0.27913616 + } + } + }, + { + "Name": "Native 1.2 model 1442", + "ModelId": 1442, + "AttachPoints": { + "9": { + "X": 1.31732416, + "Y": -2.06066918, + "Z": 2.79388428, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "10": { + "X": -0.12301, + "Y": -3.09071016, + "Z": 3.20470023, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + } + } + }, + { + "Name": "Native 1.2 model 1444", + "ModelId": 1444, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1460", + "ModelId": 1460, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1461", + "ModelId": 1461, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } + }, + { + "Name": "Native 1.2 model 1462", + "ModelId": 1462, + "AttachPoints": { + "21": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "36": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "60": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "61": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + } + } } ] diff --git a/rust/crates/aaemu-game/src/config.rs b/rust/crates/aaemu-game/src/config.rs index f9a40dce69..5ca983ad6f 100644 --- a/rust/crates/aaemu-game/src/config.rs +++ b/rust/crates/aaemu-game/src/config.rs @@ -62,7 +62,7 @@ pub struct AppConfig { pub login_network: NetworkConfig, /// `WebApiNetwork` (`None` = section missing: "WebApi will not start"). #[serde(rename = "webapinetwork")] - pub web_api_network: Option, + pub web_api_network: Option, /// `MaxConcurencyThreadPool` (bound but unused by the C# server as well). #[serde(rename = "maxconcurencythreadpool", deserialize_with = "lenient")] pub max_concurency_thread_pool: i32, @@ -177,6 +177,42 @@ pub struct NetworkConfig { pub num_connections: i32, } +/// HTTP listener configuration. An absent key leaves only `/status` accessible. +#[derive(Clone, Deserialize)] +#[serde(default)] +pub struct WebApiConfig { + #[serde(rename = "host")] + pub host: String, + #[serde(rename = "port", deserialize_with = "lenient")] + pub port: u16, + #[serde(rename = "enabled", deserialize_with = "lenient")] + pub enabled: bool, + #[serde(rename = "apikey")] + pub api_key: Option, +} + +impl Default for WebApiConfig { + fn default() -> Self { + Self { + host: "127.0.0.1".into(), + port: 1280, + enabled: true, + api_key: None, + } + } +} + +impl std::fmt::Debug for WebApiConfig { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("WebApiConfig") + .field("host", &self.host) + .field("port", &self.port) + .field("enabled", &self.enabled) + .field("api_key", &self.api_key.as_ref().map(|_| "[redacted]")) + .finish() + } +} + #[derive(Debug, Clone, Default, Deserialize)] #[serde(default)] pub struct DbConnections { @@ -1141,7 +1177,9 @@ mod tests { assert_eq!(cfg.login_network.port, 1234); assert_eq!(cfg.connections.mysql_provider.port, 3306); let web = cfg.web_api_network.as_ref().expect("WebApiNetwork"); - assert_eq!((web.host.as_str(), web.port), ("*", 1280)); + assert_eq!((web.host.as_str(), web.port), ("127.0.0.1", 1280)); + assert!(web.enabled); + assert!(web.api_key.is_none()); assert_eq!(cfg.max_concurency_thread_pool, 8); assert!(cfg.discord_token.is_none()); // World.json @@ -1178,6 +1216,29 @@ mod tests { assert_eq!(cfg.events.halloween.end, ""); } + #[test] + fn web_api_security_settings_bind_from_environment() { + let mut value = json!({"WebApiNetwork": {"Host": "127.0.0.1"}}); + apply_env( + &mut value, + [ + ( + "WebApiNetwork__ApiKey".into(), + "synthetic-environment-key".into(), + ), + ("WebApiNetwork__Enabled".into(), "false".into()), + ], + ); + let config = AppConfig::from_value(value).unwrap(); + let web = config.web_api_network.unwrap(); + assert_eq!(web.api_key.as_deref(), Some("synthetic-environment-key")); + assert!(!web.enabled); + assert!(AppConfig::from_value(json!({"WebApiNetwork": null})) + .unwrap() + .web_api_network + .is_none()); + } + #[test] fn overrides_apply_in_builder_order() { let dir = std::env::temp_dir().join(format!("aaemu-cfg-{}", std::process::id())); diff --git a/rust/crates/aaemu-game/src/data/attribute_limits.rs b/rust/crates/aaemu-game/src/data/attribute_limits.rs new file mode 100644 index 0000000000..ff7f869a0c --- /dev/null +++ b/rust/crates/aaemu-game/src/data/attribute_limits.rs @@ -0,0 +1,117 @@ +//! Native 1.2 attribute bounds (read-only compact data). +//! +//! `x2game12.c` 39577A20 (:1178985, :1179175-81) initializes unit limits to +//! +/-2,000,000,000 then loads `unit_attribute_limits`. 398A0BC0 (:1991333-38) +//! calls 395729F0 AFTER formula, equipment and buff arithmetic, before the raw +//! attribute is converted to a ratio, percentage, delay, etc. These are bounds on +//! the resulting raw attribute, never on each bonus or its accumulated modifier. +//! +//! `character_p_stat_limits` is separate: 39752FC0 (:1647826-32) loads max/min; +//! 3939DD10 (:765713-59) validates permanent pStat + delta. It does NOT bound final +//! primary attributes including equipment/buffs. Permanent pStats are not yet +//! modeled/persisted by this server; loading their five ranges does not implement +//! that feature or justify applying them to NPCs or to character stat getters. + +use std::collections::HashMap; + +use rusqlite::Connection; + +use crate::models::unit::UnitAttribute; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct AttributeLimit { + pub minimum: i32, + pub maximum: i32, +} + +impl Default for AttributeLimit { + fn default() -> Self { + Self { + minimum: -2_000_000_000, + maximum: 2_000_000_000, + } + } +} + +impl AttributeLimit { + /// Invalid numeric input cannot escape into casts/timers; infinities saturate + /// and NaN uses zero within the authored range (server numeric-safety policy). + pub fn clamp(self, value: f64) -> f64 { + let value = if value.is_nan() { 0.0 } else { value }; + value.clamp(f64::from(self.minimum), f64::from(self.maximum)) + } +} + +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct UnitAttributeLimits { + pub attributes: HashMap, +} + +fn invalid(message: impl Into) -> rusqlite::Error { + rusqlite::Error::InvalidParameterName(message.into()) +} + +fn limit(minimum: i32, maximum: i32) -> rusqlite::Result { + if minimum > maximum { + return Err(invalid(format!( + "inverted attribute limit {minimum}..{maximum}" + ))); + } + Ok(AttributeLimit { minimum, maximum }) +} + +impl UnitAttributeLimits { + pub fn load(conn: &Connection) -> rusqlite::Result { + let mut result = Self::default(); + let mut stmt = + conn.prepare("SELECT unit_attribute_id, minimum, maximum FROM unit_attribute_limits")?; + let mut rows = stmt.query([])?; + while let Some(row) = rows.next()? { + let id: u8 = row.get(0)?; + let attribute = UnitAttribute::from_u8(id) + .ok_or_else(|| invalid(format!("unknown unit attribute limit {id}")))?; + let range = limit(row.get(1)?, row.get(2)?)?; + if result.attributes.insert(attribute, range).is_some() { + return Err(invalid(format!("duplicate unit attribute limit {id}"))); + } + } + Ok(result) + } + + pub fn clamp(&self, attribute: UnitAttribute, value: f64) -> f64 { + self.attributes + .get(&attribute) + .copied() + .unwrap_or_default() + .clamp(value) + } +} + +/// Ranges for permanent character pStat contributions; not final stat caps. +#[derive(Debug, Clone, Default, PartialEq, Eq)] +pub struct CharacterPStatLimits { + pub contributions: HashMap, +} + +impl CharacterPStatLimits { + pub fn load(conn: &Connection) -> rusqlite::Result { + let mut result = Self::default(); + let mut stmt = conn.prepare("SELECT p_stat_id, max, min FROM character_p_stat_limits")?; + let mut rows = stmt.query([])?; + while let Some(row) = rows.next()? { + let id: u8 = row.get(0)?; + if !(1..=5).contains(&id) { + return Err(invalid(format!("unknown character pStat limit {id}"))); + } + let range = limit(row.get(2)?, row.get(1)?)?; + if result.contributions.insert(id, range).is_some() { + return Err(invalid(format!("duplicate character pStat limit {id}"))); + } + } + Ok(result) + } +} + +#[cfg(test)] +#[path = "attribute_limits_tests.rs"] +pub(crate) mod tests; diff --git a/rust/crates/aaemu-game/src/data/attribute_limits_tests.rs b/rust/crates/aaemu-game/src/data/attribute_limits_tests.rs new file mode 100644 index 0000000000..7cd670897a --- /dev/null +++ b/rust/crates/aaemu-game/src/data/attribute_limits_tests.rs @@ -0,0 +1,197 @@ +use super::*; + +// Native 1.2 compact rows, selected read-only from the table consumed by 39577A20. +// Deliberately literal fixtures; neither the production clamp nor a round trip +// generates expected values. +pub(crate) const UNIT_ROWS: [(u8, i32, i32); 21] = [ + (6, -2_000_000_000, 10_000_000), + (8, 0, 1_000_000), + (10, -10_000, 3_000), + (16, 0, 2_000_000_000), + (21, 0, 2_000_000_000), + (22, 0, 2_000_000_000), + (25, 0, 2_000_000_000), + (30, 0, 2_000_000_000), + (33, 0, 10_000_000), + (34, 0, 10_000_000), + (35, 0, 10_000_000), + (51, -1_000, 5_000), + (52, -1_000, 5_000), + (53, -1_000, 5_000), + (54, -800, 4_000), + (55, -800, 4_000), + (71, -600, 4_000), + (74, -800, 4_000), + (95, 0, 500), + (119, -800, 4_000), + (120, -800, 5_000), +]; + +pub(crate) fn fixture() -> (UnitAttributeLimits, CharacterPStatLimits) { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE unit_attribute_limits (unit_attribute_id INTEGER, minimum INTEGER, maximum INTEGER); + CREATE TABLE character_p_stat_limits (p_stat_id INTEGER, min INTEGER, max INTEGER);", + ) + .unwrap(); + for (id, min, max) in UNIT_ROWS { + conn.execute( + "INSERT INTO unit_attribute_limits VALUES (?1,?2,?3)", + (id, min, max), + ) + .unwrap(); + } + for id in 1..=5 { + conn.execute( + "INSERT INTO character_p_stat_limits VALUES (?1,0,10000)", + [id], + ) + .unwrap(); + } + ( + UnitAttributeLimits::load(&conn).unwrap(), + CharacterPStatLimits::load(&conn).unwrap(), + ) +} + +#[test] +fn attribute_limits_native_boundaries_and_finite_numeric_policy() { + let (limits, primary) = fixture(); + assert_eq!(limits.attributes.len(), 21); + for (id, min, max) in UNIT_ROWS { + let attr = UnitAttribute::from_u8(id).unwrap(); + for (value, expected) in [ + (f64::from(min) - 1.0, f64::from(min)), + (f64::from(min), f64::from(min)), + (f64::from(min) + 0.5, f64::from(min) + 0.5), + (f64::from(max) - 0.5, f64::from(max) - 0.5), + (f64::from(max), f64::from(max)), + (f64::from(max) + 1.0, f64::from(max)), + (f64::INFINITY, f64::from(max)), + (f64::NEG_INFINITY, f64::from(min)), + (f64::NAN, 0.0), + ] { + assert_eq!(limits.clamp(attr, value), expected, "{attr:?}: {value}"); + } + } + // The five pStat ranges bound permanent contributions only, not these final + // unit attributes. Fai has no character_p_stat_limits row at all. + assert_eq!(primary.contributions.len(), 5); + for id in 1..=5 { + let range = primary.contributions[&id]; + assert_eq!( + range, + AttributeLimit { + minimum: 0, + maximum: 10_000 + } + ); + for (input, expected) in [ + (-1.0, 0.0), + (0.0, 0.0), + (10_000.0, 10_000.0), + (10_001.0, 10_000.0), + ] { + assert_eq!(range.clamp(input), expected); + } + } + assert!(!primary.contributions.contains_key(&0)); + assert!(!primary.contributions.contains_key(&6)); + assert_eq!(limits.clamp(UnitAttribute::Str, 10_001.0), 10_001.0); + assert_eq!(limits.clamp(UnitAttribute::Str, -1.0), -1.0); + assert_eq!( + limits.clamp(UnitAttribute::Fai, f64::INFINITY), + 2_000_000_000.0 + ); +} + +#[test] +fn attribute_limits_reject_malformed_ranges_ids_and_duplicates() { + for (table, columns, values, primary) in [ + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "8,10,0", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "9,0,10", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "256,0,10", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "8,0,2147483648", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "8,NULL,10", + false, + ), + ( + "unit_attribute_limits", + "unit_attribute_id, minimum, maximum", + "8,0,10),(8,0,20", + false, + ), + ( + "character_p_stat_limits", + "p_stat_id, max, min", + "1,0,10", + true, + ), + ( + "character_p_stat_limits", + "p_stat_id, max, min", + "0,10,0", + true, + ), + ( + "character_p_stat_limits", + "p_stat_id, max, min", + "6,10,0", + true, + ), + ( + "character_p_stat_limits", + "p_stat_id, max, min", + "1,10,0),(1,20,0", + true, + ), + ] { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch(&format!( + "CREATE TABLE {table} ({columns}); INSERT INTO {table} VALUES ({values});" + )) + .unwrap(); + let failed = if primary { + CharacterPStatLimits::load(&conn).is_err() + } else { + UnitAttributeLimits::load(&conn).is_err() + }; + assert!(failed, "accepted {table} ({values})"); + } +} + +#[test] +#[ignore = "needs AAEMU_COMPACT_DB (read-only)"] +fn attribute_limits_real_compact_db_pins_all_21_and_5_rows() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let (unit, primary) = fixture(); + assert_eq!(UnitAttributeLimits::load(&conn).unwrap(), unit); + assert_eq!(CharacterPStatLimits::load(&conn).unwrap(), primary); +} diff --git a/rust/crates/aaemu-game/src/data/character_templates.rs b/rust/crates/aaemu-game/src/data/character_templates.rs index 8234dcfbeb..37669c1c0c 100644 --- a/rust/crates/aaemu-game/src/data/character_templates.rs +++ b/rust/crates/aaemu-game/src/data/character_templates.rs @@ -6,6 +6,7 @@ use std::collections::HashMap; use std::path::Path; +use std::sync::Arc; use rusqlite::Connection; use serde::Deserialize; @@ -20,6 +21,7 @@ use super::GameDataError; pub struct CharacterTemplate { pub race: u8, pub gender: u8, + pub creatable: bool, pub model_id: u32, pub faction_id: u32, pub zone_id: u32, @@ -88,6 +90,10 @@ pub struct ExpertLimit { #[derive(Debug, Clone, Default)] pub struct CharacterData { + /// Shared by every unit belonging to this GameServer, including non-characters. + pub unit_attribute_limits: Arc, + /// Permanent pStat contribution ranges; the contribution feature is still unimplemented. + pub p_stat_limits: super::attribute_limits::CharacterPStatLimits, /// keyed by `16 * gender + race`. pub templates: HashMap, pub ability_items: HashMap, @@ -99,6 +105,14 @@ pub struct CharacterData { pub actability_categories: HashMap, /// `_expertLimits` by step. pub expert_limits: Vec, + /// `blocked_texts` rows with `check_name`; independent of the configured name regex. + pub blocked_names: Vec, +} + +#[derive(Debug, Clone, PartialEq, Eq)] +pub struct BlockedName { + pub text: String, + pub partial_match: bool, } #[derive(Debug, Deserialize, Default)] @@ -135,6 +149,8 @@ impl CharacterData { pub fn template(&self, race: u8, gender: u8) -> Option<&CharacterTemplate> { self.templates .get(&(16u8.wrapping_mul(gender).wrapping_add(race))) + // The packed key alone aliases malformed race/gender bytes (e.g. gender 17). + .filter(|t| t.race == race && t.gender == gender) } pub fn actability(&self, id: u32) -> Option<&ActabilityTemplate> { @@ -164,7 +180,14 @@ impl CharacterData { zone_of: impl Fn(f32, f32) -> u32, default_world_id: u32, ) -> Result { - let mut d = CharacterData::default(); + let mut d = CharacterData { + unit_attribute_limits: Arc::new(super::attribute_limits::UnitAttributeLimits::load( + conn, + )?), + p_stat_limits: super::attribute_limits::CharacterPStatLimits::load(conn)?, + blocked_names: load_blocked_names(conn)?, + ..CharacterData::default() + }; let mut temp: HashMap = HashMap::new(); let mut rows = Vec::new(); for_each_row(conn, "SELECT * FROM characters", [], |r| { @@ -173,6 +196,7 @@ impl CharacterData { CharacterTemplate { race: r.u8("char_race_id")?, gender: r.u8("char_gender_id")?, + creatable: r.bool_str("creatable")?, model_id: r.u32("model_id")?, faction_id: r.u32("faction_id")?, zone_id: r.u32("starting_zone_id")?, @@ -383,3 +407,73 @@ impl CharacterData { Ok(d) } } + +fn load_blocked_names(conn: &Connection) -> Result, GameDataError> { + let mut names = Vec::new(); + for_each_row(conn, "SELECT * FROM blocked_texts", [], |r| { + if r.bool_str("check_name")? { + names.push(BlockedName { + text: r.string("utf8str")?, + partial_match: r.bool_str("partial_match")?, + }); + } + Ok(()) + })?; + Ok(names) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn lobby_blocked_names_load_only_check_name_and_preserve_partial_match() { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE blocked_texts (check_name TEXT, check_chat TEXT, partial_match TEXT, utf8str TEXT); + INSERT INTO blocked_texts VALUES + ('t', 'f', 't', 'Admin'), ('1', 'f', 'f', 'GM'), + ('f', 't', 't', 'ChatOnly'), ('f', 'f', 'f', 'Ignored');", + ) + .unwrap(); + assert_eq!( + load_blocked_names(&conn).unwrap(), + vec![ + BlockedName { + text: "Admin".into(), + partial_match: true + }, + BlockedName { + text: "GM".into(), + partial_match: false + }, + ] + ); + } + + #[test] + #[ignore = "needs AAEMU_COMPACT_DB (read-only)"] + fn lobby_rules_real_compact_db() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let app = Path::new(env!("CARGO_MANIFEST_DIR")).join("app"); + let data = CharacterData::load(&conn, &app, |_, _| 0, 0).unwrap(); + for (race, gender) in [(1, 1), (1, 2), (4, 1), (4, 2), (5, 1), (5, 2)] { + assert!(data.template(race, gender).unwrap().creatable); + } + for (race, gender) in [(2, 2), (3, 1), (3, 2), (7, 1), (8, 1)] { + assert!(!data.template(race, gender).unwrap().creatable); + } + assert!(data + .blocked_names + .iter() + .any(|n| n.text == "Admin" && n.partial_match)); + assert!(data + .blocked_names + .iter() + .any(|n| n.text == "GM" && !n.partial_match)); + } +} diff --git a/rust/crates/aaemu-game/src/data/mod.rs b/rust/crates/aaemu-game/src/data/mod.rs index 76d62981cb..7fe4b8aad6 100644 --- a/rust/crates/aaemu-game/src/data/mod.rs +++ b/rust/crates/aaemu-game/src/data/mod.rs @@ -14,6 +14,7 @@ //! //! As in the 1.2 C# (no tolerant loaders), a failing table aborts startup. +pub mod attribute_limits; pub mod character_templates; pub mod client_files; pub mod experience; diff --git a/rust/crates/aaemu-game/src/managers/character.rs b/rust/crates/aaemu-game/src/managers/character.rs index f3759a97a5..e75c5af34b 100644 --- a/rust/crates/aaemu-game/src/managers/character.rs +++ b/rust/crates/aaemu-game/src/managers/character.rs @@ -30,8 +30,12 @@ use crate::packets::world::{ use crate::server::GameServer; use crate::world::unit_state::create_character_response; -/// `ErrorMessageType.CannotDeleteCharWhileBotSuspected`. -pub const ERROR_CANNOT_DELETE_CHAR_WHILE_BOT_SUSPECTED: i16 = 624; +/// Matches `AcAuthResponse.slot_count` in aaemu-login (base slots, without paid slots). +pub const MAX_CHARACTERS_PER_ACCOUNT: i64 = 6; + +// Native 1.2 x2game12.c:391136-391163 (HandleErrorMessage, lobby errors). +const ERROR_CHARACTER_EXPEDITION_OWNER: i16 = 333; +const ERROR_CANNOT_DELETE_CHAR_WHILE_ON_PLAY: i16 = 575; /// The data `CSCreateCharacterPacket` carries. #[derive(Debug, Clone, PartialEq)] @@ -309,12 +313,33 @@ pub async fn create( req: CreateCharacterRequest, ) -> Result<()> { let name = normalize_name(&req.name); + let data = &server.game_data; + // Reject unavailable and malformed race/gender pairs before allocating names or assets. + let Some(template) = data + .characters + .template(req.race, req.gender) + .filter(|t| t.creatable) + .cloned() + else { + conn.send(&SCCharacterCreationFailedPacket { + reason: CharacterCreateError::Failed as u8, + }); + return Ok(()); + }; + // The same lock covers name validation, setup, slot counting and the SQL commit. In-flight + // creates on distinct connections cannot both claim the last slot or the same name. Drop + // (including cancellation) releases it after NewCharacter has rolled back its assets. + let _transaction = server.save.transaction_lock().await; let pending = if server.names.name_exists(&name) { is_character_pending_deletion(&server.db, &name).await? } else { false }; - let code = server.names.validate_character_name(&name, || pending); + let code = server.names.validate_character_name_with_blocks( + &name, + &data.characters.blocked_names, + || pending, + ); if code != CharacterCreateError::Ok { conn.send(&SCCharacterCreationFailedPacket { reason: code as u8 }); return Ok(()); @@ -340,7 +365,6 @@ pub async fn create( } // Inventory::new registers containers immediately. Exclude world/departure snapshots // throughout setup, SQL commit and failure cleanup, including setup errors below. - let _transaction = server.save.transaction_lock().await; let id = server .ids .character @@ -353,18 +377,6 @@ pub async fn create( committed: false, }; server.names.add_character(id, &name, conn.account_id()); - let data = &server.game_data; - let template = data - .characters - .template(req.race, req.gender) - .cloned() - .ok_or_else(|| { - GameError::Protocol(format!( - "no template for race {} gender {}", - req.race, req.gender - )) - })?; - let mut c = Character::new(id, conn.account_id(), req.model_params.clone()); c.unit.name = name.clone(); c.race = req.race; @@ -505,6 +517,34 @@ pub async fn create( c.unit.mp = c.unit.max_mp; c.restore_saved_hp_mp(); + // Use persisted rows, not a connection's stale/empty lobby list. Pending deletions still + // occupy slots until deleted=1. Keep the save lock through the subsequent commit; the next + // create sees this one, and a failed create leaves neither a slot nor an inventory behind. + let slots = sqlx::query_scalar::<_, i64>( + "SELECT COUNT(*) FROM characters WHERE account_id = ? AND deleted = 0", + ) + .bind(conn.account_id()) + .fetch_one(&server.db) + .await; + match slots { + Ok(count) if count >= MAX_CHARACTERS_PER_ACCOUNT => { + conn.send(&SCCharacterCreationFailedPacket { + reason: CharacterCreateError::WorldLimit as u8, + }); + return Ok(()); + } + Err(e) => { + tracing::error!( + "Cannot count character slots for account {}: {e}", + conn.account_id() + ); + conn.send(&SCCharacterCreationFailedPacket { + reason: CharacterCreateError::Failed as u8, + }); + return Ok(()); + } + Ok(_) => {} + } if save_new_character_locked(server, &mut c).await { creation.committed = true; let resp = create_character_response(&c); @@ -519,6 +559,22 @@ pub async fn create( Ok(()) } +/// Excludes a concurrent select until the deletion request is committed. Never release an +/// existing session's reservation, including one owned by this very connection. +struct DeleteReservation<'a> { + server: &'a GameServer, + character_id: u32, + connection_id: u32, +} + +impl Drop for DeleteReservation<'_> { + fn drop(&mut self) { + self.server + .enter_world + .release_character(self.character_id, self.connection_id); + } +} + /// Learn the selected ability's starters and make its first spell the primary shortcut. fn initialize_starting_skills(server: &GameServer, c: &mut Character) -> Result<()> { let data = &server.game_data; @@ -574,7 +630,42 @@ pub async fn set_delete_character( conn: &mut GameConnection, character_id: u32, ) -> Result<()> { - if let Some(i) = conn.characters.iter().position(|c| c.id == character_id) { + if let Some(i) = conn + .characters + .iter() + .position(|c| c.id == character_id && c.account_id == conn.account_id()) + { + if server.world.character_by_id(character_id).is_some() + || server.enter_world.reserve_character(character_id, conn.id) != Ok(true) + { + conn.send(&SCErrorMsgPacket::new( + ERROR_CANNOT_DELETE_CHAR_WHILE_ON_PLAY, + 0, + false, + )); + return Ok(()); + } + let _reservation = DeleteReservation { + server, + character_id, + connection_id: conn.id, + }; + let _transaction = server.save.transaction_lock().await; + // The loaded lobby copy can predate an ownership transfer. Use the guild ledger, + // including guilds absent from that copy's expedition_id. + if server + .expeditions + .all() + .iter() + .any(|e| !e.is_disbanded && e.faction.owner_id == character_id) + { + conn.send(&SCErrorMsgPacket::new( + ERROR_CHARACTER_EXPEDITION_OWNER, + 0, + false, + )); + return Ok(()); + } let now = Utc::now().timestamp(); let level = conn.characters[i].unit.level; let mut delay = 0; @@ -583,11 +674,21 @@ pub async fn set_delete_character( delay = t.delay; } } - let c = &mut conn.characters[i]; - c.delete_request_time = now; - c.delete_time = now + i64::from(delay) * 60; - let (req, del) = (c.delete_request_time, c.delete_time); - if set_delete_times(&server.db, character_id, req, del).await? == 1 { + let (req, del) = (now, now + i64::from(delay) * 60); + let affected = sqlx::query( + "UPDATE characters SET delete_request_time = ?, delete_time = ? \ + WHERE id = ? AND account_id = ? AND deleted = 0", + ) + .bind(crate::db::from_unix(req)) + .bind(crate::db::from_unix(del)) + .bind(character_id) + .bind(conn.account_id()) + .execute(&server.db) + .await?; + if affected.rows_affected() == 1 { + let c = &mut conn.characters[i]; + c.delete_request_time = req; + c.delete_time = del; conn.send(&SCDeleteCharacterResponsePacket { character_id, status: 2, @@ -595,12 +696,12 @@ pub async fn set_delete_character( delete_time: del, }); } else { - // Not the correct message, but it seems funny enough (C#) - conn.send(&SCErrorMsgPacket::new( - ERROR_CANNOT_DELETE_CHAR_WHILE_BOT_SUSPECTED, - 0, - true, - )); + conn.send(&SCDeleteCharacterResponsePacket { + character_id, + status: 0, + delete_request_time: 0, + delete_time: 0, + }); } } else { conn.send(&SCDeleteCharacterResponsePacket { diff --git a/rust/crates/aaemu-game/src/managers/character_tests.rs b/rust/crates/aaemu-game/src/managers/character_tests.rs index 18941fd11e..57efc2417b 100644 --- a/rust/crates/aaemu-game/src/managers/character_tests.rs +++ b/rust/crates/aaemu-game/src/managers/character_tests.rs @@ -83,6 +83,7 @@ fn creation_data() -> GameData { CharacterTemplate { race: 1, gender: 1, + creatable: true, num_inventory_slot: 50, num_bank_slot: 50, ..Default::default() @@ -142,6 +143,546 @@ fn creation_request(name: &str) -> CreateCharacterRequest { } } +async fn lobby_create( + server: &crate::GameServer, + client: &mut crate::test_support::TestClient, + request: CreateCharacterRequest, +) -> crate::Result<()> { + use crate::net::registry::ClientPacket; + crate::packets::c2g_world::CSCreateCharacterPacket(request) + .handle(server, &mut client.conn) + .await +} + +/// One pinned connection: all writes are shadowed by TEMPORARY tables and disappear at close. +async fn private_lobby_pool() -> Option { + use crate::systems::social::achievement_persistence::temporary_shadow_definition; + use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; + use std::str::FromStr; + let url = std::env::var("AAEMU_TEST_MYSQL").ok()?; + let options = MySqlConnectOptions::from_str(&url).expect("valid private MySQL URL"); + assert_eq!( + options.get_port(), + 3317, + "only private MySQL3317 is allowed" + ); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .unwrap(); + for table in [ + "items", + "item_containers", + "characters", + "options", + "abilities", + "actabilities", + "appellations", + "character_active_buffs", + "portal_book_coords", + "portal_visited_district", + "friends", + "blocked", + "skills", + "quests", + "completed_quests", + "accounts", + "character_records", + "character_achievements", + ] { + let (_, definition): (String, String) = + sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&temporary_shadow_definition(&definition)) + .execute(&pool) + .await + .unwrap(); + } + sqlx::query("SET SESSION sql_mode='STRICT_ALL_TABLES'") + .execute(&pool) + .await + .unwrap(); + Some(pool) +} + +async fn persisted_lobby_count(pool: &sqlx::MySqlPool, account: u32) -> i64 { + sqlx::query_scalar("SELECT COUNT(*) FROM characters WHERE account_id = ? AND deleted = 0") + .bind(account) + .fetch_one(pool) + .await + .unwrap() +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; temporary tables only"] +async fn private_mysql_lobby_slots_five_six_seven_parallel_rollback_retry_and_account_isolation() { + use crate::test_support::TestClient; + let Some(pool) = private_lobby_pool().await else { + return; + }; + let mut server = test_server_with(creation_data()); + server.db = pool.clone(); + sqlx::query("INSERT INTO accounts (account_id, labor) VALUES (1007, 1000), (1008, 1000)") + .execute(&pool) + .await + .unwrap(); + let mut seed = TestClient::new(&server, 1, 1007); + for index in 0..5 { + lobby_create( + &server, + &mut seed, + creation_request(&format!("Seed{index}")), + ) + .await + .unwrap(); + assert!(seed + .drain_ops() + .contains(&crate::opcodes::sc::SCCreateCharacterResponsePacket)); + } + assert_eq!(persisted_lobby_count(&pool, 1007).await, 5); + let pending_id = seed.conn.characters[0].id; + sqlx::query("UPDATE characters SET delete_request_time=UTC_TIMESTAMP(), delete_time=DATE_ADD(UTC_TIMESTAMP(), INTERVAL 1 DAY) WHERE id=?") + .bind(pending_id).execute(&pool).await.unwrap(); + let inventory_rows: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM items") + .fetch_one(&pool) + .await + .unwrap(); + + // Reproduce a later SQL failure at slot 5: the refused sixth character must roll back. + // A required, unprovided column rejects the skill write after the character row; unlike + // triggers or CHECK constraints this also works on MySQL TEMPORARY tables. + sqlx::query("ALTER TABLE skills ADD COLUMN lobby_required INT NOT NULL") + .execute(&pool) + .await + .unwrap(); + let mut retry = TestClient::new(&server, 2, 1007); // deliberately no loaded character list + lobby_create(&server, &mut retry, creation_request("Retry")) + .await + .unwrap(); + assert_creation_failure(&mut retry, 2); + assert_eq!(persisted_lobby_count(&pool, 1007).await, 5); + assert!(!server.names.name_exists("Retry")); + let after_failure: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM items") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(after_failure, inventory_rows); + sqlx::query("ALTER TABLE skills DROP COLUMN lobby_required") + .execute(&pool) + .await + .unwrap(); + + let mut parallel = TestClient::new(&server, 3, 1007); + { + let transaction = server.save.transaction_lock().await; + let creates = async { + tokio::join!( + lobby_create(&server, &mut retry, creation_request("Retry")), + lobby_create(&server, &mut parallel, creation_request("Parallel")), + ) + }; + tokio::pin!(creates); + assert!( + tokio::time::timeout(std::time::Duration::from_millis(20), &mut creates) + .await + .is_err() + ); + drop(transaction); + let (a, b) = tokio::time::timeout(std::time::Duration::from_secs(10), creates) + .await + .unwrap(); + a.unwrap(); + b.unwrap(); + } + assert_eq!( + retry.conn.characters.len() + parallel.conn.characters.len(), + 1 + ); + let frames = [retry.drain(), parallel.drain()]; + assert_eq!( + frames + .iter() + .flatten() + .filter( + |(op, body)| *op == crate::opcodes::sc::SCCharacterCreationFailedPacket + && body == &[9] + ) + .count(), + 1 + ); + assert_eq!( + persisted_lobby_count(&pool, 1007).await, + 6, + "pending deletion still consumes a slot" + ); + lobby_create(&server, &mut seed, creation_request("Seventh")) + .await + .unwrap(); + assert_creation_failure(&mut seed, 9); + + // A full account never consumes a different account's slot or leaves its failed name. + let mut other = TestClient::new(&server, 4, 1008); + lobby_create(&server, &mut other, creation_request("Seventh")) + .await + .unwrap(); + assert_eq!(other.conn.characters.len(), 1); + assert_eq!(persisted_lobby_count(&pool, 1008).await, 1); + other.drain(); + let historical_id = other.conn.characters[0].id; + // Model a pre-existing over-limit account (7 rows), independently of the cached lists. + sqlx::query("UPDATE characters SET account_id=1007 WHERE id=?") + .bind(historical_id) + .execute(&pool) + .await + .unwrap(); + assert_eq!(persisted_lobby_count(&pool, 1007).await, 7); + lobby_create(&server, &mut seed, creation_request("Eighth")) + .await + .unwrap(); + assert_creation_failure(&mut seed, 9); + + // Fully deleted rows free slots; scheduled deletions above did not. + sqlx::query("UPDATE characters SET deleted=1 WHERE id IN (?, ?)") + .bind(historical_id) + .bind(seed.conn.characters[1].id) + .execute(&pool) + .await + .unwrap(); + assert_eq!(persisted_lobby_count(&pool, 1007).await, 5); + lobby_create(&server, &mut seed, creation_request("Eighth")) + .await + .unwrap(); + assert!(seed + .drain_ops() + .contains(&crate::opcodes::sc::SCCreateCharacterResponsePacket)); + assert_eq!(persisted_lobby_count(&pool, 1007).await, 6); + assert_eq!( + server + .names + .get_character_account(server.names.get_character_id("Eighth")), + 1007 + ); + pool.close().await; +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; temporary tables only"] +async fn private_mysql_lobby_delete_changes_timestamps_only_for_current_owned_undeleted_row() { + use crate::test_support::TestClient; + let Some(pool) = private_lobby_pool().await else { + return; + }; + let mut server = test_server_with(creation_data()); + server.db = pool.clone(); + sqlx::query("INSERT INTO accounts (account_id, labor) VALUES (1007, 1000)") + .execute(&pool) + .await + .unwrap(); + let mut client = TestClient::new(&server, 1, 1007); + lobby_create(&server, &mut client, creation_request("Deletable")) + .await + .unwrap(); + client.drain(); + let id = client.conn.characters[0].id; + for (account, deleted) in [(1008u32, 0), (1007, 1)] { + sqlx::query("UPDATE characters SET account_id=?, deleted=? WHERE id=?") + .bind(account) + .bind(deleted) + .bind(id) + .execute(&pool) + .await + .unwrap(); + lobby_delete(&server, &mut client, id).await.unwrap(); + let frames = client.drain(); + assert_eq!(frames.len(), 1); + assert_eq!( + frames[0].0, + crate::opcodes::sc::SCDeleteCharacterResponsePacket + ); + let mut expected = id.to_le_bytes().to_vec(); + expected.extend_from_slice(&[0; 17]); // native status=0 + two zero i64 timestamps + assert_eq!(frames[0].1, expected); + assert_eq!(client.conn.characters[0].delete_request_time, 0); + assert_eq!(client.conn.characters[0].delete_time, 0); + assert_eq!(server.enter_world.character_owner(id), None); + } + sqlx::query("UPDATE characters SET account_id=1007, deleted=0 WHERE id=?") + .bind(id) + .execute(&pool) + .await + .unwrap(); + lobby_delete(&server, &mut client, id).await.unwrap(); + let frames = client.drain(); + assert_eq!(frames.len(), 1); + assert_eq!( + frames[0].0, + crate::opcodes::sc::SCDeleteCharacterResponsePacket + ); + assert_eq!(frames[0].1.len(), 21); + assert_eq!(frames[0].1[4], 2); + let persisted: (i64, i64) = sqlx::query_as( + "SELECT CAST(UNIX_TIMESTAMP(delete_request_time) AS SIGNED), CAST(UNIX_TIMESTAMP(delete_time) AS SIGNED) FROM characters WHERE id=?", + ).bind(id).fetch_one(&pool).await.unwrap(); + let c = &client.conn.characters[0]; + assert!(c.delete_request_time > 0); + assert_eq!(persisted, (c.delete_request_time, c.delete_time)); + assert_eq!(server.enter_world.character_owner(id), None); + pool.close().await; +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; temporary tables only"] +async fn private_mysql_lobby_parallel_names_have_one_owner_and_pending_names_use_native_reason() { + use crate::test_support::TestClient; + let Some(pool) = private_lobby_pool().await else { + return; + }; + let mut server = test_server_with(creation_data()); + server.db = pool.clone(); + sqlx::query("INSERT INTO accounts (account_id, labor) VALUES (1007, 1000), (1008, 1000)") + .execute(&pool) + .await + .unwrap(); + let mut a = TestClient::new(&server, 1, 1007); + let mut b = TestClient::new(&server, 2, 1008); + let (first, second) = tokio::join!( + lobby_create(&server, &mut a, creation_request("Unique")), + lobby_create(&server, &mut b, creation_request("uNIQUE")), + ); + first.unwrap(); + second.unwrap(); + assert_eq!(a.conn.characters.len() + b.conn.characters.len(), 1); + let owner = if a.conn.characters.is_empty() { + assert_creation_failure(&mut a, 4); + b.conn.account_id() + } else { + assert_creation_failure(&mut b, 4); + a.conn.account_id() + }; + let id = server.names.get_character_id("Unique"); + assert_eq!(server.names.get_character_account(id), owner); + assert_eq!( + persisted_lobby_count(&pool, 1007).await + persisted_lobby_count(&pool, 1008).await, + 1 + ); + a.drain(); + b.drain(); + sqlx::query("UPDATE characters SET delete_request_time=UTC_TIMESTAMP() WHERE id=?") + .bind(id) + .execute(&pool) + .await + .unwrap(); + lobby_create(&server, &mut a, creation_request("UNIQUE")) + .await + .unwrap(); + assert_creation_failure(&mut a, 6); // native 'character name is to be deleted' + pool.close().await; +} + +async fn lobby_delete( + server: &crate::GameServer, + client: &mut crate::test_support::TestClient, + character_id: u32, +) -> crate::Result<()> { + use crate::net::registry::ClientPacket; + crate::packets::c2g_world::CSDeleteCharacterPacket { character_id } + .handle(server, &mut client.conn) + .await +} + +fn assert_creation_failure(client: &mut crate::test_support::TestClient, reason: u8) { + // Native 1.2 sub_397B3060 (x2game12.c:1749639): exactly one u8, no i32 enum. + assert_eq!( + client.drain(), + vec![( + crate::opcodes::sc::SCCharacterCreationFailedPacket, + vec![reason] + )] + ); +} + +#[tokio::test] +async fn lobby_create_rejects_unavailable_and_aliased_race_gender_before_allocating_assets() { + let mut data = creation_data(); + let mut unavailable = data.characters.template(1, 1).unwrap().clone(); + unavailable.race = 3; + unavailable.creatable = false; + data.characters.templates.insert(19, unavailable); + let server = test_server_with(data); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + for (race, gender) in [(3, 1), (1, 0), (1, 17), (17, 0), (255, 255)] { + let mut req = creation_request("Unavailable"); + req.race = race; + req.gender = gender; + lobby_create(&server, &mut client, req).await.unwrap(); + assert_creation_failure(&mut client, 2); // native general server failure, not continent block + assert!(client.conn.characters.is_empty()); + assert!(server.names.no_names_registered()); + assert!(server.items.all_containers().is_empty()); + } + assert_eq!(server.ids.character.get_next_id().unwrap(), 1); +} + +#[tokio::test] +async fn lobby_create_filters_invalid_blocked_and_case_variant_names() { + use crate::data::character_templates::BlockedName; + let mut data = creation_data(); + data.characters.blocked_names = vec![ + BlockedName { + text: "Admin".into(), + partial_match: true, + }, + BlockedName { + text: "GM".into(), + partial_match: false, + }, + ]; + let server = test_server_with(data); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + for name in ["bad name", "", "Admin", "AdMiN", "TheAdMiNhero", "gM"] { + lobby_create(&server, &mut client, creation_request(name)) + .await + .unwrap(); + assert_creation_failure(&mut client, 5); // sub_391D3330: forbidden name + assert!(server.names.no_names_registered()); + assert!(server.items.all_containers().is_empty()); + } + for name in ["Accepted", "Павел", "GMhero"] { + lobby_create(&server, &mut client, creation_request(name)) + .await + .unwrap(); + // Reaches the closed DB, rather than being refused by the name filter. + assert_creation_failure(&mut client, 2); + assert!(server.names.no_names_registered()); + assert!(server.items.all_containers().is_empty()); + } +} + +fn lobby_character(client: &mut crate::test_support::TestClient, id: u32) { + let mut c = Character::new(id, client.conn.account_id(), Default::default()); + c.unit.name = "Deletable".into(); + c.unit.level = 10; + client.conn.characters.push(c); +} + +fn assert_delete_error(client: &mut crate::test_support::TestClient, expected: &[u8]) { + // Native 1.2 sub_397C3030 (x2game12.c:1761305): i16, i16, u32, bool. + // isNotify=false is required for HandleErrorMessage's dedicated lobby-error events. + assert_eq!( + client.drain(), + vec![(crate::opcodes::sc::SCErrorMsgPacket, expected.to_vec())] + ); +} + +#[tokio::test] +async fn lobby_delete_refuses_online_and_inflight_select_on_any_connection() { + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + lobby_character(&mut client, 50); + for owner in [1, 2] { + assert_eq!(server.enter_world.reserve_character(50, owner), Ok(true)); + lobby_delete(&server, &mut client, 50).await.unwrap(); + assert_delete_error(&mut client, &[0x3f, 0x02, 0x3f, 0x02, 0, 0, 0, 0, 0]); // 575 + assert_eq!(server.enter_world.character_owner(50), Some(owner)); + assert_eq!(client.conn.characters[0].delete_request_time, 0); + server.enter_world.release_character(50, owner); + } + // Also protect a live world object when no session reservation is present. + let mut c = client.conn.characters[0].clone(); + c.obj_id = 500; + let p = crate::world::Player::new(c, client.conn.handle()); + assert!(server.world.try_add_character(&p)); + lobby_delete(&server, &mut client, 50).await.unwrap(); + assert_delete_error(&mut client, &[0x3f, 0x02, 0x3f, 0x02, 0, 0, 0, 0, 0]); + assert_eq!(server.enter_world.character_owner(50), None); +} + +#[tokio::test] +async fn lobby_delete_uses_current_expedition_owner_and_releases_refused_reservations() { + use crate::data::world_data::SystemFaction; + use crate::systems::social::expedition::Expedition; + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + lobby_character(&mut client, 50); + // The stale lobby character has expedition_id=0, but is now the authoritative owner. + server.expeditions.add(Expedition { + faction: SystemFaction { + id: 700, + owner_id: 50, + ..Default::default() + }, + members: vec![], + policies: vec![], + removed_members: vec![], + is_disbanded: false, + }); + lobby_delete(&server, &mut client, 50).await.unwrap(); + assert_delete_error(&mut client, &[0x4d, 0x01, 0x4d, 0x01, 0, 0, 0, 0, 0]); // 333 + assert_eq!(client.conn.characters[0].delete_request_time, 0); + assert_eq!(server.enter_world.character_owner(50), None); + + // After ownership changes, the stale lobby expedition field must not block deletion. + client.conn.characters[0].unit.expedition_id = 700; + server + .expeditions + .with_mut(700, |e| e.faction.owner_id = 51) + .unwrap(); + assert!(lobby_delete(&server, &mut client, 50).await.is_err()); // reaches the closed DB + assert!(client.drain().is_empty()); + assert_eq!(client.conn.characters[0].delete_request_time, 0); + assert_eq!(server.enter_world.character_owner(50), None); + assert_eq!(server.enter_world.reserve_character(50, 2), Ok(true)); + server.enter_world.release_character(50, 2); +} + +#[tokio::test] +async fn lobby_delete_cannot_mutate_another_accounts_lobby_character() { + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + lobby_character(&mut client, 50); + client.conn.characters[0].account_id = 1008; + lobby_delete(&server, &mut client, 50).await.unwrap(); + // sub_397B2F50 / sub_391EA8C0: id:u32, status:u8=0, two zero i64 timestamps. + assert_eq!( + client.drain(), + vec![( + crate::opcodes::sc::SCDeleteCharacterResponsePacket, + vec![50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + )] + ); + assert_eq!(client.conn.characters[0].delete_request_time, 0); + assert_eq!(server.enter_world.character_owner(50), None); +} + +#[tokio::test] +async fn lobby_delete_blocks_select_while_waiting_and_releases_on_cancellation() { + let server = test_server_with(creation_data()); + server.db.close().await; + let mut client = crate::test_support::TestClient::new(&server, 1, 1007); + lobby_character(&mut client, 50); + let transaction = server.save.transaction_lock().await; + let mut deletion = Box::pin(lobby_delete(&server, &mut client, 50)); + assert!( + tokio::time::timeout(std::time::Duration::from_millis(20), &mut deletion) + .await + .is_err() + ); + assert_eq!(server.enter_world.reserve_character(50, 2), Err(1)); + drop(deletion); + assert_eq!(server.enter_world.reserve_character(50, 2), Ok(true)); + server.enter_world.release_character(50, 2); + drop(transaction); +} + #[tokio::test] async fn create_character_starting_kit_helpers_preserve_equipment_and_stacks() { use crate::data::character_templates::EquipItemsTemplate; diff --git a/rust/crates/aaemu-game/src/managers/name.rs b/rust/crates/aaemu-game/src/managers/name.rs index 3fa90f02a2..84581f01b2 100644 --- a/rust/crates/aaemu-game/src/managers/name.rs +++ b/rust/crates/aaemu-game/src/managers/name.rs @@ -7,15 +7,20 @@ use regex::Regex; use sqlx::mysql::MySqlPool; use sqlx::Row; +use crate::data::character_templates::BlockedName; + /// `CharacterCreateError`. #[derive(Debug, Clone, Copy, PartialEq, Eq)] #[repr(u8)] pub enum CharacterCreateError { Ok = 0, - /// Also generates "Name is pending deletion". - Failed = 3, + /// Native 1.2 `sub_3961BBC0`: general server error. + Failed = 2, NameAlreadyExists = 4, InvalidCharacters = 5, + NamePendingDeletion = 6, + /// Native 1.2 `sub_3961BBC0`: limit by world server. + WorldLimit = 9, } /// `NameManager.DefaultCharacterNameRegexPattern`. @@ -153,7 +158,7 @@ impl NameManager { ) -> CharacterCreateError { if self.name_exists(name) { if pending_deletion() { - return CharacterCreateError::Failed; + return CharacterCreateError::NamePendingDeletion; } return CharacterCreateError::NameAlreadyExists; } @@ -163,6 +168,33 @@ impl NameManager { CharacterCreateError::Ok } + pub fn validate_character_name_with_blocks( + &self, + name: &str, + blocked_names: &[BlockedName], + pending_deletion: impl FnOnce() -> bool, + ) -> CharacterCreateError { + let result = self.validate_character_name(name, pending_deletion); + if result != CharacterCreateError::Ok { + return result; + } + // Native 1.2 x2game12.c:1738997-1739029, sub_397A7540: + // check_name uses XlFindStringI for partial_match, otherwise XlCompareStringI. + // Lowercasing covers the Latin/Cyrillic alphabet supported by the default regex. + let folded = name.to_lowercase(); + if blocked_names.iter().any(|rule| { + let text = rule.text.to_lowercase(); + if rule.partial_match { + folded.contains(&text) + } else { + folded == text + } + }) { + return CharacterCreateError::InvalidCharacters; + } + CharacterCreateError::Ok + } + /// `AddCharacter`. pub fn add_character(&self, id: u32, name: &str, account_id: u32) { let normalized = normalize_name(name); @@ -254,7 +286,7 @@ mod tests { ); assert_eq!( m.validate_character_name("Taken", || true), - CharacterCreateError::Failed + CharacterCreateError::NamePendingDeletion ); assert_eq!( m.validate_character_name("Bad name", || false), diff --git a/rust/crates/aaemu-game/src/managers/name_tests.rs b/rust/crates/aaemu-game/src/managers/name_tests.rs index 1b85da8a91..aa3c4ea5b3 100644 --- a/rust/crates/aaemu-game/src/managers/name_tests.rs +++ b/rust/crates/aaemu-game/src/managers/name_tests.rs @@ -67,7 +67,7 @@ fn validation_character_name_pending_deletion_failed() { let result = sut.validate_character_name(&char_name, || true); - assert_eq!(result, CharacterCreateError::Failed); + assert_eq!(result, CharacterCreateError::NamePendingDeletion); } #[test] @@ -112,3 +112,45 @@ fn remove_character_id_works_as_expected() { assert_eq!(sut.get_character_id(&char_name), 0); assert_eq!(sut.get_character_account(char_id), 0); } + +#[test] +fn lobby_blocked_names_match_native_partial_and_exact_rules_without_changing_regex() { + let rules = [ + BlockedName { + text: "Admin".into(), + partial_match: true, + }, + BlockedName { + text: "GM".into(), + partial_match: false, + }, + BlockedName { + text: "Иван".into(), + partial_match: true, + }, + ]; + let sut = NameManager::default(); + for name in ["Admin", "ADMIN", "MyAdMiNhero", "gM", "ИВАН", "НовыйИван"] { + assert_eq!( + sut.validate_character_name_with_blocks(name, &rules, || false), + CharacterCreateError::InvalidCharacters, + "{name}" + ); + } + for name in ["Roger", "GMhero", "SomeGM", "Павел", "Игрок123"] { + assert_eq!( + sut.validate_character_name_with_blocks(name, &rules, || false), + CharacterCreateError::Ok, + "{name}" + ); + } + let custom = NameManager::new(Some("^[a-zA-Z_-]{1,18}$")); + assert_eq!( + custom.validate_character_name_with_blocks("Valid-name", &rules, || false), + CharacterCreateError::Ok + ); + assert_eq!( + custom.validate_character_name_with_blocks("AdMiN-name", &rules, || false), + CharacterCreateError::InvalidCharacters + ); +} diff --git a/rust/crates/aaemu-game/src/managers/save.rs b/rust/crates/aaemu-game/src/managers/save.rs index fa194c5aa4..4647fce3d9 100644 --- a/rust/crates/aaemu-game/src/managers/save.rs +++ b/rust/crates/aaemu-game/src/managers/save.rs @@ -30,6 +30,7 @@ pub(crate) struct FinancialSnapshot { /// Capture property transactions before any database await. Claim/capture, tax payments, /// certificates, receipts and wallets must describe the same logical operation boundary. pub(crate) fn capture_financial_snapshot(server: &GameServer) -> FinancialSnapshot { + let _items = server.systems.economy.operation_scope(); let _auction = server.systems.economy.auction.operation_lock(); let _housing = server .systems diff --git a/rust/crates/aaemu-game/src/models/buff.rs b/rust/crates/aaemu-game/src/models/buff.rs index 8421e351ec..2138a98e63 100644 --- a/rust/crates/aaemu-game/src/models/buff.rs +++ b/rust/crates/aaemu-game/src/models/buff.rs @@ -10,6 +10,8 @@ //! counters, triggers, `TriggerRemoveOn`, tag checks, modifier-cache updates, //! `SCBuffCreatedPacket` broadcasts) is `systems::skills::buffs`. +use std::sync::atomic::{AtomicU64, Ordering}; + use aaemu_commons::PacketStream; use crate::data::skills::{save_rule, stack_rule, BuffKind, BuffTemplate}; @@ -23,6 +25,8 @@ const MINIMUM_BUFF_DURATION_TO_SAVE: i32 = 60_000; /// `BuffConstants.LoggedOn`. pub const BUFF_LOGGED_ON: u32 = 2423; +static NEXT_BUFF_INSTANCE: AtomicU64 = AtomicU64::new(1); + /// `SkillCaster` as written by `SkillCaster.Write` (type + bc obj id). Only `SkillCasterUnit` /// is used by this phase. #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)] @@ -35,6 +39,9 @@ pub struct SkillCaster { #[derive(Debug, Clone, PartialEq)] pub struct Buff { pub index: u32, + /// Internal lifetime identity. Explicit/wrapped indices can be reused; refreshes keep + /// this identity. Not serialized or persisted, and assigned only on insertion. + pub(crate) instance_id: u64, pub template: BuffTemplate, pub skill_caster: SkillCaster, /// `Caster?.Id` / `Caster?.Level` (`None` = no caster unit). @@ -87,6 +94,7 @@ impl Buff { ) -> Self { Self { index: 0, + instance_id: 0, template, skill_caster, caster, @@ -109,6 +117,12 @@ impl Buff { } } + /// Whether a queued event / callback still refers to this inserted effect. A clone + /// retains its identity, whereas reinserting even that clone starts a new lifetime. + pub fn same_instance(&self, other: &Buff) -> bool { + self.instance_id != 0 && self.index == other.index && self.instance_id == other.instance_id + } + /// `GetTimeLeft` (-1 for a permanent buff). pub fn time_left(&self, now_ms: i64) -> f64 { if self.duration == 0 { @@ -412,6 +426,7 @@ impl Buffs { .push(BuffEvent::Refreshed(self.effects[i].clone())); } None => { + buff.instance_id = NEXT_BUFF_INSTANCE.fetch_add(1, Ordering::Relaxed); buff.tick = buff.template.tick; buff.in_use = true; self.events.push(BuffEvent::Started(buff.clone())); diff --git a/rust/crates/aaemu-game/src/models/character.rs b/rust/crates/aaemu-game/src/models/character.rs index b74cd11124..e6aae4996f 100644 --- a/rust/crates/aaemu-game/src/models/character.rs +++ b/rust/crates/aaemu-game/src/models/character.rs @@ -220,6 +220,8 @@ pub struct Character { /// Character skill / combat state (`SkillCancelled`, `LastCast`, `IsInAggroListOf`, ...). pub skill_char: crate::systems::skills::state::CharacterSkillState, // ---- phase 3 / npcs: add this subsystem's Character fields below ---- + /// Closed-zone warning task and the last verified open-zone position (session only). + pub zone_access: crate::world::session::ZoneAccessState, /// `Bonding` (`BondDoodad`: the doodad seat / bed the character is attached to). pub bonding: Option, // ---- phase 3 / economy: add this subsystem's Character fields below ---- @@ -365,6 +367,7 @@ impl Character { // ---- phase 3 / skills ---- skill_char: Default::default(), // ---- phase 3 / npcs ---- + zone_access: Default::default(), bonding: None, // ---- phase 3 / economy ---- diff --git a/rust/crates/aaemu-game/src/models/unit.rs b/rust/crates/aaemu-game/src/models/unit.rs index 2735c7a9c2..23398e534d 100644 --- a/rust/crates/aaemu-game/src/models/unit.rs +++ b/rust/crates/aaemu-game/src/models/unit.rs @@ -19,7 +19,9 @@ //! holding one; collect what you need, drop the guard, then act (see `world::object`). use std::collections::HashMap; +use std::sync::Arc; +use crate::data::attribute_limits::UnitAttributeLimits; use crate::models::buff::Buffs; use crate::models::transform::Transform; use crate::models::unit_model::UnitCustomModelParams; @@ -268,9 +270,17 @@ impl DynamicBonus { pub struct Bonuses { pub statics: Vec<(u32, Vec)>, pub dynamics: Vec<(u32, Vec)>, + /// Per-server data, bound before world insertion or detached stat calculation. + pub attribute_limits: Arc, } impl Bonuses { + pub fn bind_attribute_limits(&mut self, limits: &Arc) { + if !Arc::ptr_eq(&self.attribute_limits, limits) { + self.attribute_limits = Arc::clone(limits); + } + } + /// `AddBonus(bonusIndex, bonus)`. pub fn add_bonus(&mut self, index: u32, bonus: Bonus) { match self.statics.iter_mut().find(|(i, _)| *i == index) { @@ -326,7 +336,19 @@ impl Bonuses { /// `CalculateWithBonuses(value, attr)`: static flat, dynamic flat, static percent, dynamic /// percent. (`value * bonus.Value / 100f` is float arithmetic in C#.) - pub fn calculate(&self, mut value: f64, attr: UnitAttribute, now_ms: i64) -> f64 { + pub fn calculate(&self, value: f64, attr: UnitAttribute, now_ms: i64) -> f64 { + self.calculate_with_limits(value, attr, now_ms, &self.attribute_limits) + } + + /// Explicit data also covers detached, immutable character evaluators. Apply the + /// native bound to the final raw attribute, preserving flat/percent bonus order. + pub fn calculate_with_limits( + &self, + mut value: f64, + attr: UnitAttribute, + now_ms: i64, + limits: &UnitAttributeLimits, + ) -> f64 { let statics = self.bonuses(attr); let dynamics = self.dynamic_bonuses(attr); for b in &statics { @@ -353,7 +375,7 @@ impl Bonuses { } } } - value + limits.clamp(attr, value) } } @@ -361,14 +383,25 @@ impl Bonuses { #[derive(Debug, Clone, Default, PartialEq)] pub struct UnitCooldowns { pub cooldowns: HashMap, + /// Shared expiry by authored `skills.cooldown_tag_id`, local to this unit. + pub tag_cooldowns: HashMap, } impl UnitCooldowns { /// `AddCooldown(skillId, duration)` (an existing cooldown is kept). pub fn add_cooldown(&mut self, skill_id: u32, duration_ms: u32, now_ms: i64) { + if duration_ms == 0 { + return; + } + let end = now_ms.saturating_add(i64::from(duration_ms)); self.cooldowns .entry(skill_id) - .or_insert(now_ms + i64::from(duration_ms)); + .and_modify(|old| { + if *old <= now_ms { + *old = end; + } + }) + .or_insert(end); } /// `CheckCooldown(skillId)`: true while more than 250 ms are left; an (almost) expired @@ -377,13 +410,43 @@ impl UnitCooldowns { let Some(&end) = self.cooldowns.get(&skill_id) else { return false; }; - if end - now_ms > 250 { + if end.saturating_sub(now_ms) > 250 { return true; } self.cooldowns.remove(&skill_id); false } + /// Start or extend a shared cooldown without shortening an existing expiry. + pub fn add_tag_cooldown(&mut self, tag_id: u32, duration_ms: u32, now_ms: i64) { + self.tag_cooldowns.retain(|_, end| *end > now_ms); + if tag_id == 0 || duration_ms == 0 { + return; + } + let end = now_ms.saturating_add(i64::from(duration_ms)); + self.tag_cooldowns + .entry(tag_id) + .and_modify(|old| *old = (*old).max(end)) + .or_insert(end); + } + + /// A tagged member can be cooling down even if this unit has never used it. + /// Keep the existing 250 ms admission tolerance for both stores. + pub fn check_skill_cooldown(&mut self, skill_id: u32, tag_id: u32, now_ms: i64) -> bool { + let individual = self.check_cooldown(skill_id, now_ms); + self.tag_cooldowns + .retain(|_, end| end.saturating_sub(now_ms) > 250); + individual || (tag_id != 0 && self.tag_cooldowns.contains_key(&tag_id)) + } + + /// Match the native skill/tag reset without touching other individual timers or groups. + pub fn remove_skill_cooldown(&mut self, skill_id: u32, tag_id: u32) { + self.remove_cooldown(skill_id); + if tag_id != 0 { + self.tag_cooldowns.remove(&tag_id); + } + } + /// `RemoveCooldown(skillId)`. pub fn remove_cooldown(&mut self, skill_id: u32) { self.cooldowns.remove(&skill_id); diff --git a/rust/crates/aaemu-game/src/packets/mod.rs b/rust/crates/aaemu-game/src/packets/mod.rs index a7422f6953..705296f599 100644 --- a/rust/crates/aaemu-game/src/packets/mod.rs +++ b/rust/crates/aaemu-game/src/packets/mod.rs @@ -92,8 +92,8 @@ mod tests { } /// Every `RegisterPacket` call of the C# `GameNetwork()` constructor is registered in Rust - /// under the same (level, opcode) with the same packet class name, and Rust registers - /// nothing the C# does not. The C# table is a checked-in snapshot + /// under the same (level, opcode) with the same packet class name, except for documented + /// native 1.2 corrections. The C# table is a checked-in historical snapshot /// (`tests/fixtures/csharp_game_network_registry.tsv`) taken while the C# sources existed. #[test] fn registry_matches_csharp_game_network() { @@ -111,6 +111,13 @@ mod tests { let name = cols.next().unwrap().to_string(); expected.insert((level, opcode), name); } + // Native 1.2 ReturnMailById (3948B630 -> 393CD290, serializer 397BA450) + // sends 0xa3. C# called that slot ReportSpam and stranded ReturnMail on 0xfff. + // Preserve the historical fixture while checking the corrected live dispatch. + assert_eq!( + expected.insert((1, 0x0a3), "CSReturnMailPacket".into()), + Some("CSReportSpamPacket".into()) + ); assert!( expected.len() > 250, "parsed only {} registrations", @@ -131,8 +138,6 @@ mod tests { } } for ((level, opcode), reg) in r.iter() { - // `CSReturnMailPacket` is commented out in C# (opcode 0xfff, never sent by 1.2): - // registering it is harmless. // `CSTakeScheduleItemPacket` is a 1.2 client packet the C# never registered // (`systems::npcs::schedule_item_packets`, opcode read off the client). // `CSRankSnapshotPacket` (0x130), `CSRequestSetBountyMoneyPacket` (0x11f), diff --git a/rust/crates/aaemu-game/src/systems/ai/npc.rs b/rust/crates/aaemu-game/src/systems/ai/npc.rs index 80fafa443f..03939c213a 100644 --- a/rust/crates/aaemu-game/src/systems/ai/npc.rs +++ b/rust/crates/aaemu-game/src/systems/ai/npc.rs @@ -93,14 +93,14 @@ pub fn move_speed_mul(obj: &WorldObject) -> f32 { /// `NpcAi.GetRealMovementSpeed(baseMoveSpeed)`. pub fn real_movement_speed(obj: &WorldObject, base_move_speed: f64) -> f64 { let now = now_ms(); + // The native limit bounds the complete raw attribute, including its neutral 1000. let speed_mul = obj .with_unit(|u| { u.unit() - .calculate_with_bonuses(0.0, UnitAttribute::MoveSpeedMul, now) + .calculate_with_bonuses(1000.0, UnitAttribute::MoveSpeedMul, now) }) - .unwrap_or(0.0) - / 1000.0 - + 1.0; + .unwrap_or(1000.0) + / 1000.0; if (speed_mul - 1.0).abs() > f64::EPSILON { base_move_speed * speed_mul } else { diff --git a/rust/crates/aaemu-game/src/systems/economy/auction.rs b/rust/crates/aaemu-game/src/systems/economy/auction.rs index cfc4997fe8..cffa4504a9 100644 --- a/rust/crates/aaemu-game/src/systems/economy/auction.rs +++ b/rust/crates/aaemu-game/src/systems/economy/auction.rs @@ -711,7 +711,8 @@ impl AuctionManager { .extend(failed); } - /// Serialises the auction operations (outermost lock; mails are sent while it is held). + /// Serialises auction operations inside the item operation scope. Mail callbacks may + /// start ItemTxn while this lock is held, so mutating entries acquire the scope first. fn op(&self) -> MutexGuard<'_, ()> { self.op.lock().unwrap_or_else(|e| e.into_inner()) } @@ -720,6 +721,11 @@ impl AuctionManager { self.op() } + #[cfg(test)] + pub(super) fn try_operation_lock(&self) -> std::sync::TryLockResult> { + self.op.try_lock() + } + pub(crate) fn prepare_save(&self, server: &GameServer) -> AuctionSaveBatch { let ids = self.deleted_ids(); let versions = self @@ -875,6 +881,7 @@ impl AuctionManager { /// `CancelAuctionLot(player, auctionId)`: only the seller may cancel a lot without bids. /// Return the original escrow item, preserving its ID and details. pub fn cancel_auction_lot(&self, server: &GameServer, player: &PlayerRef, auction_id: u64) { + let _items = server.systems.economy.operation_scope(); let _op = self.op(); let Some(lot) = self.lot(auction_id) else { tracing::warn!("AuctionLot with ID {auction_id} not found."); @@ -936,6 +943,7 @@ impl AuctionManager { lot_id: u64, mut bid: AuctionBid, ) { + let _items = server.systems.economy.operation_scope(); let _op = self.op(); let Some(mut lot) = self.lot(lot_id) else { tracing::warn!("Invalid auctionItem passed to BidOnAuctionLot."); @@ -1165,6 +1173,7 @@ impl AuctionManager { /// `UpdateAuctionHouse()` (`AuctionHouseTask`). pub fn update_auction_house(&self, server: &GameServer, now: DateTime) { tracing::trace!("Updating Auction House!"); + let _items = server.systems.economy.operation_scope(); let _op = self.op(); self.retry_pending_settlements(server); let expired: Vec = self @@ -1241,6 +1250,7 @@ impl AuctionManager { buyout_price: i32, duration: u8, ) { + let _items = server.systems.economy.operation_scope(); let _op = self.op(); let mut txn = ItemTxn::begin(server); // Only the player's own unbound inventory item can enter auction escrow. diff --git a/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs b/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs new file mode 100644 index 0000000000..fc91bdc53f --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/bench_tests.rs @@ -0,0 +1,543 @@ +//! Craft station authorization through CSExecuteCraft and the real skill/CraftEffect flow. +//! Source fixtures: read-only 1.2 compact, native `sub_398A9480`, and PACKETS.md CS 0xf8 / +//! SC 0x10a (D:/aa-re/client12/decomp). No packet bytes are derived from Rust encoders. + +use std::sync::Arc; + +use aaemu_commons::PacketStream; + +use super::{doodad_func_permission as permission, CSExecuteCraft}; +use crate::data::{items::ItemTemplate, GameData}; +use crate::models::doodad::{doodad_owner_type, Doodad}; +use crate::models::house::{housing_permission, House}; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::server::GameServer; +use crate::systems::economy::bridges::{EconomyComposite, EconomyForSkills}; +use crate::systems::economy::craft_data::{Craft, CraftProduct, CraftSkill}; +use crate::systems::economy::inventory::Inv; +use crate::systems::npcs::doodad::templates::{ + DoodadFunc, DoodadFuncCraftPack, DoodadFuncParentInfo, FuncTemplate, +}; +use crate::systems::skills::data::{EffectKind, EffectTemplate, SkillTemplate}; +use crate::systems::skills::types::SkillTargetType; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::{DoodadRef, Entity, HouseRef, PlayerRef}; + +const TAX: u32 = 76; +const CERTIFICATE: u32 = 31892; +const SKILL: u32 = 16767; +const BENCH: u32 = 0x300; +const RESTRICTED_GROUP: u32 = 90000; +const WRONG_PACK_GROUP: u32 = 90001; +const PORTABLE: u32 = 90002; +const OTHER_RECIPE: u32 = 90003; +const HOUSE_PERMISSION_GROUP: u32 = 90004; +const SAME_ACCOUNT_GROUP: u32 = 90005; + +// One live tax CraftPack phase per plaque template (other authored phases are checked by +// the ignored real-data test below). The recipe's req_doodad_id is always canonical 2392. +const PLAQUES: [(u32, u32, u32); 8] = [ + (2392, 6172, 298), + (973, 1240, 297), + (5767, 14787, 313), + (7340, 20054, 301), + (7341, 20058, 305), + (7342, 20062, 309), + (8249, 23031, 325), + (7308, 19956, 300), +]; + +fn add_pack(data: &mut GameData, group: u32, func_id: u32, pack: u32, perm: u8) { + let doodads = &mut data.systems.npcs.doodad; + doodads.funcs_by_groups.insert( + group, + vec![ + // ParentInfo precedes CraftPack on the real plaques. Its permission must not + // authorize a different function (especially the owner-only pack below). + DoodadFunc { + group_id: group, + func_id: 1, + func_type: "DoodadFuncParentInfo".into(), + ..Default::default() + }, + DoodadFunc { + group_id: group, + func_id, + func_type: "DoodadFuncCraftPack".into(), + perm_id: u32::from(perm), + ..Default::default() + }, + ], + ); + doodads + .func_templates + .entry("DoodadFuncParentInfo") + .or_default() + .insert(1, FuncTemplate::ParentInfo(DoodadFuncParentInfo { id: 1 })); + doodads + .func_templates + .entry("DoodadFuncCraftPack") + .or_default() + .insert( + func_id, + FuncTemplate::CraftPack(DoodadFuncCraftPack { + id: func_id, + craft_pack_id: pack, + }), + ); +} + +fn data(cast_time: i32) -> GameData { + let mut data = crate::systems::economy::tests::test_data(); + data.items + .templates + .insert(CERTIFICATE, ItemTemplate::plain(CERTIFICATE, 1000)); + for (id, skill_id, req_doodad_id, is_pack) in [ + (TAX, SKILL, 2392, true), + (PORTABLE, PORTABLE, 0, false), + (OTHER_RECIPE, SKILL, 2392, true), + ] { + data.systems.economy.craft.crafts.insert( + id, + Craft { + id, + skill_id, + req_doodad_id, + is_pack, + craft_products: vec![CraftProduct { + craft_id: id, + item_id: CERTIFICATE, + amount: 5, + rate: 100, + ..Default::default() + }], + ..Default::default() + }, + ); + } + data.systems + .economy + .craft + .craft_pack_crafts + .insert(3, [TAX].into()); + data.systems + .economy + .craft + .craft_pack_crafts + .insert(4, [OTHER_RECIPE].into()); + for (id, target_type) in [ + (SKILL, SkillTargetType::Doodad), + (PORTABLE, SkillTargetType::SelfTarget), + ] { + data.systems.economy.craft.skills.insert( + id, + CraftSkill { + id, + consume_labor_power: 200, + actability_group_id: 19, + // Give the test time to change permissions between completed batch steps. + cooldown_time: 50, + }, + ); + data.systems.skills.add_skill(SkillTemplate { + target_type: target_type as i32, + max_range: 12, + consume_labor_power: 200, + actability_group_id: 19, + casting_time: cast_time, + target_selection: 2, + target_area_count: 1, + effects: vec![crate::systems::skills::tests::skill_effect( + 1, + EffectKind::CraftEffect, + 1, + )], + ..crate::systems::skills::tests::skill_template(id) + }); + } + data.systems.skills.add_effect( + EffectKind::CraftEffect, + EffectTemplate::Craft { + id: 1, + world_interaction: 37, + }, + 1, + ); + data.systems + .npcs + .area_trigger + .world_interaction_groups + .insert( + 37, + crate::systems::npcs::area_trigger::world_interaction_group::CRAFT, + ); + for (_, group, func) in PLAQUES { + add_pack(&mut data, group, func, 3, permission::ANY); + } + add_pack( + &mut data, + RESTRICTED_GROUP, + 90000, + 3, + permission::OWNER_ONLY, + ); + add_pack(&mut data, WRONG_PACK_GROUP, 90001, 4, permission::ANY); + add_pack( + &mut data, + SAME_ACCOUNT_GROUP, + 90005, + 3, + permission::SAME_ACCOUNT, + ); + add_pack( + &mut data, + HOUSE_PERMISSION_GROUP, + 90004, + 3, + permission::PERMISSION1, + ); + data +} + +struct Fixture { + server: Arc, + client: TestClient, + visitor: PlayerRef, + owner_client: TestClient, + owner: PlayerRef, + house: HouseRef, + bench: DoodadRef, +} + +fn fixture(template: u32, group: u32, cast_time: i32) -> Fixture { + let server = Arc::new(test_server_with(data(cast_time))); + server.set_self(); + crate::systems::skills::install_hooks(&server); + server + .systems + .skills + .ext + .items + .install(Arc::new(EconomyForSkills)); + server + .systems + .economy + .craft + .hooks + .install(Arc::new(EconomyComposite)); + let mut client = TestClient::new(&server, 1, 1001); + let mut owner_client = TestClient::new(&server, 2, 1002); + let visitor = spawn_player( + &server, + &client, + test_character(1, "Visitor", 100.0, 100.0), + 0x100, + ); + let owner = spawn_player( + &server, + &owner_client, + test_character(2, "Owner", 101.0, 100.0), + 0x101, + ); + client.conn.active_char = Some(visitor.clone()); + owner_client.conn.active_char = Some(owner.clone()); + // Real characters have one entry per actability group. Construction (19) is + // required by ChangeLabor; omitting it makes the production path reject the debit. + for player in [&visitor, &owner] { + let mut c = player.data(); + c.labor_power = 1000; + c.actability + .actabilities + .push(crate::models::char_data::Actability { + id: 19, + point: 0, + step: 0, + }); + } + server.names.add_character(1, "Visitor", 1001); + server.names.add_character(2, "Owner", 1002); + let mut house = House::new(1, 267); + house.current_step = -1; + house.unit.owner_id = 2; + house.account_id = 1002; + let house = Entity::new(0x200, house); + assert!(server.systems.housing.manager.insert(&house)); + let mut bench = Doodad::new(template); + bench.owner_type = doodad_owner_type::HOUSING; + bench.owner_db_id = 1; + bench.owner_id = 2; + bench.func_group_id = group; + bench.transform.set_xyz(101.0, 100.0, 100.0); + let bench = Entity::new(BENCH, bench); + server + .world + .world(0) + .unwrap() + .spawn(&bench, &server.view_ctx()); + client.drain(); + owner_client.drain(); + Fixture { + server, + client, + visitor, + owner_client, + owner, + house, + bench, + } +} + +async fn request( + server: &GameServer, + client: &mut TestClient, + craft: u32, + target: u32, + count: i32, +) { + // Native 1.2 CS 0xf8: recipe:u32, object:BC (3 bytes), count:i32. + let body = [ + craft.to_le_bytes().as_slice(), + &target.to_le_bytes()[..3], + &count.to_le_bytes(), + ] + .concat(); + let packet = CSExecuteCraft::read(&mut PacketStream::from_bytes(body)).unwrap(); + packet.handle(server, &mut client.conn).await.unwrap(); +} + +fn certificates(player: &PlayerRef) -> i32 { + Inv::of(player).items_count(CERTIFICATE, -1) +} + +fn assert_denied(f: &mut Fixture) { + assert!(!f.server.systems.economy.craft.is_crafting(1)); + assert_eq!(certificates(&f.visitor), 0); + // Native 1.2 SC 0x10a: i16 148, i16 135, u32 0, bool false (PACKETS.md). + assert!(f + .client + .drain() + .contains(&(sc::SCErrorMsgPacket, vec![148, 0, 135, 0, 0, 0, 0, 0, 0]))); +} + +#[tokio::test] +async fn private_farm_visitor_crafts_tax_at_all_eight_authored_plaques_for_200_labor() { + for (template, group, _) in PLAQUES { + let mut f = fixture(template, group, 0); + assert!(!crate::systems::housing::allowed_to_interact( + &f.server, &f.house, &f.visitor + )); + request(&f.server, &mut f.client, TAX, BENCH, 1).await; + assert_eq!(certificates(&f.visitor), 5, "plaque {template}"); + assert_eq!(f.visitor.data().labor_power, 800, "plaque {template}"); + assert_eq!(f.visitor.data().actability.actabilities[0].point, 200); + } +} + +#[tokio::test] +async fn current_craft_pack_permission_beats_first_parent_info_and_public_house() { + let mut f = fixture(2392, RESTRICTED_GROUP, 0); + request(&f.server, &mut f.client, TAX, BENCH, 1).await; + assert_denied(&mut f); + f.house.data().permission = housing_permission::PUBLIC; + request(&f.server, &mut f.client, TAX, BENCH, 1).await; + assert_denied(&mut f); + assert_eq!(f.visitor.data().labor_power, 1000); + request(&f.server, &mut f.owner_client, TAX, BENCH, 1).await; + assert_eq!(certificates(&f.owner), 5); + assert_eq!(f.owner.data().labor_power, 800); +} + +#[tokio::test] +async fn same_account_crafting_requires_a_resolved_matching_owner_account() { + for case in 0..3 { + let mut f = fixture(2392, SAME_ACCOUNT_GROUP, 0); + f.house.data().permission = housing_permission::PUBLIC; + match case { + 0 => {} // Public housing does not waive the function's account requirement. + 1 => f.house.data().account_id = f.visitor.data().account_id, + 2 => f.bench.data().owner_type = 0, // No authoritative account to compare. + _ => unreachable!(), + } + request(&f.server, &mut f.client, TAX, BENCH, 1).await; + if case == 1 { + assert_eq!(certificates(&f.visitor), 5); + assert_eq!(f.visitor.data().labor_power, 800); + } else { + assert_denied(&mut f); + assert_eq!(f.visitor.data().labor_power, 1000); + } + } +} + +#[tokio::test] +async fn craft_packet_rejects_wrong_recipe_pack_and_inactive_phase_even_at_canonical_id() { + for (recipe, group) in [ + (OTHER_RECIPE, 6172), + (TAX, WRONG_PACK_GROUP), + (TAX, 0), + (PORTABLE, 6172), + ] { + let mut f = fixture(2392, group, 0); + request(&f.server, &mut f.client, recipe, BENCH, 1).await; + assert_denied(&mut f); + assert_eq!(f.visitor.data().labor_power, 1000); + } +} + +#[tokio::test] +async fn craft_packet_rejects_unknown_deleted_missing_house_far_and_cross_instance_benches() { + for case in 0..9 { + let mut f = fixture(973, 1240, 0); + let target = match case { + 0 => 0x999, + 1 => 0, // tax certificates require a station + 2 => { + f.bench.data().phase.deleted = true; + BENCH + } + 3 => { + f.bench.data().owner_db_id = 999; + BENCH + } + 4 => { + f.bench.data().transform.set_xyz(200.0, 100.0, 100.0); + BENCH + } + 5 => { + f.bench.data().transform.instance_id = 1; + BENCH + } + 6 => { + f.house.data().unit.transform.instance_id = 1; + BENCH + } + 7 => { + f.bench.data().transform.x = f32::NAN; + BENCH + } + _ => f.owner.obj_id, // a unit is not a station + }; + request(&f.server, &mut f.client, TAX, target, 1).await; + assert_denied(&mut f); + assert_eq!(f.visitor.data().labor_power, 1000, "case {case}"); + } +} + +#[tokio::test] +async fn portable_craft_still_completes_without_a_doodad() { + for target in [0, 0x100] { + let mut f = fixture(973, 1240, 0); + request(&f.server, &mut f.client, PORTABLE, target, 1).await; + assert_eq!(certificates(&f.visitor), 5); + assert_eq!(f.visitor.data().labor_power, 800); + } +} + +async fn wait_for_batch_stop(f: &Fixture) { + tokio::time::timeout(std::time::Duration::from_secs(2), async { + while f + .server + .systems + .economy + .craft + .state(1) + .current_craft + .is_some() + { + tokio::time::sleep(std::time::Duration::from_millis(10)).await; + } + }) + .await + .expect("craft must finish or refuse the remaining batch"); +} + +#[tokio::test] +async fn changing_craft_function_during_a_batch_rechecks_before_product_commit() { + for group in [RESTRICTED_GROUP, WRONG_PACK_GROUP] { + // The real skill timer leaves a window to change the active phase during casting. + let mut f = fixture(973, 1240, 100); + crate::systems::skills::bind(&f.server); + request(&f.server, &mut f.client, TAX, BENCH, 2).await; + assert!(f.server.systems.economy.craft.is_crafting(1)); + assert_eq!(certificates(&f.visitor), 0); + f.bench.data().func_group_id = group; + wait_for_batch_stop(&f).await; + assert_denied(&mut f); + } +} + +#[tokio::test] +async fn changing_craft_function_between_batch_steps_refuses_the_next_cast() { + let mut f = fixture(973, 1240, 0); + request(&f.server, &mut f.client, TAX, BENCH, 2).await; + assert_eq!(certificates(&f.visitor), 5); + assert_eq!(f.visitor.data().labor_power, 800); + f.bench.data().func_group_id = RESTRICTED_GROUP; + wait_for_batch_stop(&f).await; + assert_eq!(certificates(&f.visitor), 5); + assert_eq!(f.visitor.data().labor_power, 800); + assert!(f + .client + .drain() + .contains(&(sc::SCErrorMsgPacket, vec![148, 0, 135, 0, 0, 0, 0, 0, 0]))); +} + +#[tokio::test] +async fn changing_house_permission_during_a_batch_rechecks_before_product_commit() { + let mut f = fixture(973, HOUSE_PERMISSION_GROUP, 100); + f.house.data().permission = housing_permission::PUBLIC; + crate::systems::skills::bind(&f.server); + request(&f.server, &mut f.client, TAX, BENCH, 2).await; + assert!(f.server.systems.economy.craft.is_crafting(1)); + f.house.data().permission = housing_permission::PRIVATE; + wait_for_batch_stop(&f).await; + assert_denied(&mut f); +} + +#[tokio::test] +#[ignore] +async fn real_compact_db_bench_craft_packs_include_every_tax_plaque_phase() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + rusqlite::Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .unwrap(); + let files = + crate::data::client_files::ClientFileManager::from_sources(&[], std::path::Path::new(".")); + let ctx = crate::systems::DataLoadCtx { + conn: &conn, + files: &files, + app_path: std::path::Path::new("."), + language: "en_us", + }; + let mut data = GameData::empty(); + data.systems.economy.craft = + crate::systems::economy::craft_data::CraftData::load(&ctx).unwrap(); + data.systems.npcs.doodad = + crate::systems::npcs::doodad::data::DoodadData::load_from(&conn).unwrap(); + assert_eq!( + data.systems.economy.craft.craft(TAX).unwrap().req_doodad_id, + 2392 + ); + assert!(data.systems.economy.craft.craft_pack_crafts[&3].contains(&TAX)); + // Exercise all phases that actually contain CraftPack (not the Garden's loot phase). + let phases: Vec<(u32, u32)> = conn.prepare( + "SELECT g.doodad_almighty_id, g.id FROM doodad_func_groups g JOIN doodad_funcs f ON f.doodad_func_group_id = g.id WHERE f.actual_func_type = 'DoodadFuncCraftPack' AND g.doodad_almighty_id IN (2392,973,5767,7340,7341,7342,8249,7308)" + ).unwrap().query_map([], |r| Ok((r.get(0)?, r.get(1)?))).unwrap().collect::>().unwrap(); + assert_eq!(phases.len(), 23); + let server = test_server_with(data); + for (template, group) in phases { + let mut doodad = Doodad::new(template); + doodad.func_group_id = group; + assert_eq!( + crate::systems::npcs::bridges::doodad_craft_permission( + &server, + &Entity::new(BENCH, doodad), + TAX + ), + Some(permission::ANY) + ); + } +} diff --git a/rust/crates/aaemu-game/src/systems/economy/bridges.rs b/rust/crates/aaemu-game/src/systems/economy/bridges.rs index b4e4518020..643284e7e0 100644 --- a/rust/crates/aaemu-game/src/systems/economy/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/economy/bridges.rs @@ -2124,6 +2124,222 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { move_to_system_container(server, player, task, item_id) } + fn try_store_doodad_item( + &self, + server: &GameServer, + player: &PlayerRef, + doodad: &DoodadRef, + expected: &Item, + required_count: i32, + ) -> bool { + let mut txn = ItemTxn::begin(server); + doodad.data().phase.to_next_phase = false; + let inv = Inv::of(player); + let equipment = inv.equipment(); + let Some(system) = inv.get(slot_type::SYSTEM) else { + return false; + }; + if required_count != 1 + || expected.count != required_count + || expected.slot_type != slot_type::EQUIPMENT + || expected.owner_id != u64::from(inv.character_id) + { + return false; + } + // The rack lock spans the container move and its reference update. No character or + // world lookup happens while it is held; item effects flush after both locks drop. + let mut d = doodad.data(); + d.phase.to_next_phase = false; + if d.phase.deleted || d.item_id != 0 || d.item_template_id != 0 { + return false; + } + let moved = { + let (mut target, source) = inventory::lock_pair(&system, &equipment); + let Some(mut source) = source else { + return false; + }; + let matches = source.owner_id == inv.character_id + && source.slot_type == slot_type::EQUIPMENT + && source.get_item_by_slot(expected.slot).is_some_and(|item| { + item.id == expected.id + && item.template_id == expected.template_id + && item.count == required_count + && item.slot_type == slot_type::EQUIPMENT + && item.owner_id == u64::from(inv.character_id) + }); + matches + && target.move_item_from( + &mut source, + task_type::DOODAD_ITEM_CHANGER, + expected.id, + -1, + txn.data(), + &mut txn.env.fx, + ) + }; + if moved { + d.item_id = expected.id; + d.item_template_id = expected.template_id; + } + moved + } + + fn recover_doodad_cargo( + &self, + server: &GameServer, + player: &PlayerRef, + doodad: &DoodadRef, + ) -> crate::systems::npcs::hooks::CargoRecovery { + use crate::systems::npcs::doodad::funcs::items::cargo_empty_phase; + use crate::systems::npcs::hooks::CargoRecovery; + + let mut txn = ItemTxn::begin(server); + doodad.data().phase.to_next_phase = false; + let inv = Inv::of(player); + let Some(empty) = cargo_empty_phase(server, doodad) else { + return CargoRecovery::Failed; + }; + let Some(can_repair) = cargo_attachment(server, doodad) else { + return CargoRecovery::Failed; + }; + let (item_id, template_id, group, attachment) = { + let d = doodad.data(); + ( + d.item_id, + d.item_template_id, + d.func_group_id, + ( + d.parent_obj_id, + d.transform.parent_obj_id, + d.owner_db_id, + d.attach_point, + ), + ) + }; + if item_id == 0 || !inventory::is_auto_equip_trade_pack(txn.data(), template_id) { + return CargoRecovery::Failed; + } + let item = server.items.item_by_id(item_id); + let holder = server.items.holding_container(item_id); + let occurrences: usize = server + .items + .all_containers() + .iter() + .map(|container| { + lock(container) + .items + .iter() + .filter(|i| i.id == item_id) + .count() + }) + .sum(); + let outside_escrow = match (&item, &holder) { + (None, None) => occurrences == 0, + (Some(item), Some(holder)) if occurrences == 1 => { + let holder = lock(holder); + holder.slot_type != slot_type::SYSTEM + && item.slot_type == holder.slot_type + && item.template_id == template_id + && item.class == ItemClass::Backpack + && item.count == 1 + } + _ => false, // Loose or multiply held items do not prove a dangling reference. + }; + let mut d = doodad.data(); + d.phase.to_next_phase = false; + if d.phase.deleted + || (d.item_id, d.item_template_id, d.func_group_id) != (item_id, template_id, group) + || ( + d.parent_obj_id, + d.transform.parent_obj_id, + d.owner_db_id, + d.attach_point, + ) != attachment + { + return CargoRecovery::Failed; + } + if outside_escrow { + if !can_repair { + return CargoRecovery::Failed; + } + d.item_id = 0; + d.item_template_id = 0; + return CargoRecovery::ClearedStale(empty); + } + let (Some(item), Some(holder)) = (item, holder) else { + return CargoRecovery::Failed; + }; + if occurrences != 1 + || item.slot_type != slot_type::SYSTEM + || item.class != ItemClass::Backpack + || item.template_id != template_id + || item.count != 1 + || lock(&holder).slot_type != slot_type::SYSTEM + { + return CargoRecovery::Failed; + } + let equipment = inv.equipment(); + if !lock(&equipment).can_accept( + &item, + txn.data().template(template_id), + equip_slot::BACKPACK, + ) { + return CargoRecovery::Failed; + } + let backpack = inv.equipped(equip_slot::BACKPACK); + let bag = inv.bag(); + if backpack.as_ref().is_some_and(|backpack| { + !matches!(txn.data().template(backpack.template_id).map(|t| &t.kind), + Some(TemplateKind::Backpack { backpack_type }) + if *backpack_type == crate::data::items::backpack_type::GLIDER) + || lock(&bag).place(backpack, -1, txn.data()).is_none() + }) { + return CargoRecovery::Failed; + } + // Preflight every destination before moving the glider. Keep a rollback snapshot for + // an unexpected failed second move; no failed operation may move the player's backpack. + let rollback = backpack.as_ref().map(|_| { + let equipment_before = lock(&equipment).clone(); + let bag_before = lock(&bag).clone(); + ( + equipment_before, + bag_before, + server.systems.economy.previous_backpack(inv.character_id), + ) + }); + if !inventory::take_off_backpack(&mut txn, &inv, task_type::RECOVER_DOODAD_ITEM, true) { + return CargoRecovery::Failed; + } + let moved = { + let (mut target, source) = inventory::lock_pair(&equipment, &holder); + source.is_some_and(|mut source| { + target.move_item_from( + &mut source, + task_type::RECOVER_DOODAD_ITEM, + item_id, + equip_slot::BACKPACK, + txn.data(), + &mut txn.env.fx, + ) + }) + }; + if !moved { + if let Some((equipment_before, bag_before, previous)) = rollback { + *lock(&equipment) = equipment_before; + *lock(&bag) = bag_before; + server + .systems + .economy + .set_previous_backpack(inv.character_id, previous); + txn.env.fx.0.clear(); + } + return CargoRecovery::Failed; + } + d.item_id = 0; + d.item_template_id = 0; + CargoRecovery::Recovered + } + fn remove_equipment_item( &self, server: &GameServer, @@ -2361,6 +2577,9 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { } else { inv.item_by_id(item_id) }?; + if !inventory::item_use_zone_allowed(server, player, item.template_id) { + return None; + } let t = server.game_data.items.template(item.template_id); Some(crate::systems::npcs::hooks::DoodadSourceItem { item_id: item.id, @@ -2510,44 +2729,184 @@ impl crate::systems::npcs::hooks::EconomyBridge for EconomyForNpcs { true } - fn remove_expired_doodad_item(&self, server: &GameServer, item_id: u64) { - let Some(c) = server.items.holding_container(item_id) else { - return; - }; + fn remove_expired_doodad_item( + &self, + server: &GameServer, + source: crate::systems::npcs::hooks::DoodadItemCleanup, + ) { let mut txn = ItemTxn::begin(server); - let mut g = lock(&c); - if matches!(g.slot_type, slot_type::NONE | slot_type::SYSTEM) { - g.remove_item_task(task_type::INVALID, item_id, true, &mut txn.env); - } - } - - fn release_deleted_doodad_items(&self, server: &GameServer, item_id: u64, container_id: u64) { - // item._holdingContainer = null; itemManager.ReleaseId(item.Id) - if item_id != 0 && server.items.item_by_id(item_id).is_some() { - if let Some(c) = server.items.holding_container(item_id) { - lock(&c).remove_item(item_id); - } - server.items.release_id(item_id, &server.ids.item); - } - // itemManager.DeleteItemContainer(container) - if container_id != 0 && server.items.forget_container(container_id) { - if let Ok(rt) = tokio::runtime::Handle::try_current() { - let pool = server.db.clone(); - rt.spawn(async move { - if let Err(e) = crate::managers::item::ItemManager::delete_container_row( - &pool, - container_id, - ) - .await - { - tracing::error!("DeleteItemContainer {container_id}: {e}"); - } - }); - } + cleanup_doodad_escrow_item(&mut txn, source); + } + + fn release_deleted_doodad_items( + &self, + server: &GameServer, + source: crate::systems::npcs::hooks::DoodadItemCleanup, + ) { + let mut txn = ItemTxn::begin(server); + cleanup_doodad_escrow_item(&mut txn, source); + if source.container_id != 0 { + // A coffer's container has no immutable doodad/generation association. Even an + // empty container with a matching owner may be a reused allocation; retain it. + tracing::warn!(?source, "Retained doodad container: allocation provenance unavailable; reconciliation deferred"); } } } +/// Original rack references cannot authorize destruction after GUID reuse, regardless of the +/// current item's class. Other doodads may remove only a unique, matching singleton in their +/// original character owner's System escrow. Bag/equipment/bank, loose, foreign and mismatched +/// items are retained. These checks establish escrow authority, not an allocation generation. +/// Cargo/ambiguous item references and all saved container references still need reconciliation; +/// these synchronous hooks do not prove absence of unloaded aliases or collect those orphans. +fn cleanup_doodad_escrow_item( + txn: &mut ItemTxn<'_>, + source: crate::systems::npcs::hooks::DoodadItemCleanup, +) { + use crate::models::doodad::doodad_owner_type; + + let server = txn.server; + if source.item_id == 0 { + return; + } + let doodads = &server.game_data.systems.npcs.doodad; + let rack = doodads + .doodad_func_groups(source.doodad_template_id) + .iter() + .any(|group| { + doodads + .funcs_for_group(group.id) + .iter() + .any(|f| f.func_type == "DoodadFuncConsumeChanger") + }); + let template = server.game_data.items.template(source.item_template_id); + let cargo = match template.map(|t| &t.kind) { + Some(TemplateKind::Backpack { backpack_type }) => !matches!( + *backpack_type, + crate::data::items::backpack_type::GLIDER | crate::data::items::backpack_type::TOY_FLAG + ), + _ => false, + }; + if rack + || cargo + || source.owner_type == doodad_owner_type::SLAVE + || !matches!( + source.owner_type, + doodad_owner_type::CHARACTER | doodad_owner_type::HOUSING + ) + || source.owner_id == 0 + || source.item_template_id == 0 + || !doodads.templates.contains_key(&source.doodad_template_id) + || !template.is_some_and(|t| t.max_count == 1) + { + tracing::warn!(?source, "Retained doodad item: original escrow authority is ambiguous or cargo-origin; reconciliation deferred"); + return; + } + let copies: usize = server + .items + .all_containers() + .iter() + .map(|c| { + lock(c) + .items + .iter() + .filter(|i| i.id == source.item_id) + .count() + }) + .sum(); + if copies != 1 { + return; + } + let Some(container) = server.items.holding_container(source.item_id) else { + return; + }; + let mut container = lock(&container); + let matches = container.slot_type == slot_type::SYSTEM + && container.owner_id == source.owner_id + && container + .get_item_by_id(source.item_id) + .is_some_and(|item| { + item.slot_type == slot_type::SYSTEM + && item.owner_id == u64::from(source.owner_id) + && item.template_id == source.item_template_id + && item.count == 1 + }); + if matches { + container.remove_item_task(task_type::INVALID, source.item_id, true, &mut txn.env); + } else { + tracing::warn!( + ?source, + actual_container_id = container.container_id, + actual_container_owner = container.owner_id, + actual_slot_type = container.slot_type, + "Retained doodad item: current holder does not match original owned System escrow" + ); + } +} + +/// A live cargo attachment, plus whether its persistent authored binding proves it safe to +/// repair. Nonpersistent or equipment-created racks can recover normally but are not repaired. +fn cargo_attachment(server: &GameServer, rack: &DoodadRef) -> Option { + let (instance, parent, transform_parent, hull_id, point, template_id, persistent) = { + let d = rack.data(); + ( + d.transform.instance_id, + d.parent_obj_id, + d.transform.parent_obj_id, + d.owner_db_id, + d.attach_point, + d.template_id, + d.is_persistent && !d.phase.deleted, + ) + }; + if parent == 0 || parent != transform_parent { + return None; + } + let world = server.world.world(instance)?; + if !world + .doodad(rack.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, rack)) + { + return None; + } + let hull = world.slave(parent)?; + let (id, hull_template, attached) = { + let hull = hull.data(); + ( + hull.id, + hull.unit.template_id, + hull.attached_doodads.contains(&rack.obj_id), + ) + }; + if id != hull_id || !attached { + return None; + } + let repairable = persistent + && hull_id > 0 + && server + .game_data + .systems + .vehicles + .slave_template(hull_template) + .is_some_and(|t| { + t.doodad_bindings + .iter() + .any(|b| b.persist && b.attach_point_id == point && b.doodad_id == template_id) + }); + Some( + repairable + && !rack.core().children().iter().any(|child| { + world.object(child.obj_id()).is_some_and(|live| { + // ObjectCore belongs to the immutable Arc allocation, not its recycled id. + std::ptr::eq(child.core(), live.core()) && { + let transform = live.transform(); + transform.parent_obj_id == rack.obj_id && transform.instance_id == instance + } + }) + }), + ) +} + /// `Inventory.SystemContainer.AddOrMoveExistingItem(task, item)`. fn move_to_system_container( server: &GameServer, @@ -3444,20 +3803,6 @@ impl super::craft::CraftHooks for EconomyComposite { crate::systems::skills::skill::interrupt_skills(server, &me); } - fn doodad_func_permission(&self, server: &GameServer, doodad: &DoodadRef) -> u8 { - let group = doodad.data().func_group_id; - server - .game_data - .systems - .npcs - .doodad - .doodad_funcs(group) - .first() - .map_or(super::craft::doodad_func_permission::ANY, |f| { - f.perm_id as u8 - }) - } - fn account_house_zone_ids(&self, server: &GameServer, account_id: u32) -> Vec { server .systems @@ -3628,3 +3973,7 @@ pub fn install(server: &GameServer) { }); crate::systems::services::shutdown::BUYBACK_WIPE.install(wipe); } + +#[cfg(test)] +#[path = "cargo_flow_tests.rs"] +mod cargo_flow_tests; diff --git a/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs new file mode 100644 index 0000000000..846f43065f --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/cargo_flow_tests.rs @@ -0,0 +1,1206 @@ +//! Merchant cargo regressions through the production economy bridge and authored phase dispatch. + +use std::sync::Arc; + +use crate::data::items::{backpack_type, ItemTemplate, TemplateKind}; +use crate::data::GameData; +use crate::models::character::Inventory; +use crate::models::container::{equip_slot, slot_type}; +use crate::models::doodad::{doodad_owner_type, Doodad}; +use crate::models::item::Item; +use crate::models::item_task::task_type; +use crate::models::slave::Slave; +use crate::opcodes::sc; +use crate::systems::economy::inventory::{Inv, ItemTxn}; +use crate::systems::economy::tests::{give, test_data, World, SINGLE}; +use crate::systems::npcs::doodad::runtime::DoodadCtx; +use crate::systems::npcs::doodad::templates::*; +use crate::systems::npcs::doodad::{funcs::items, interactions, manager, phase}; +use crate::systems::npcs::hooks::{DoodadItemCleanup, EconomyBridge}; +use crate::systems::vehicles::data::{SlaveDoodadBinding, SlaveTemplate}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::{DoodadRef, Entity, SlaveRef, WorldObject}; + +use super::EconomyForNpcs; + +const HULL: u32 = 75; +const RACK: u32 = 3446; +const EMPTY: u32 = 8264; +const LOADED: u32 = 8265; +const STORE_SKILL: u32 = 15307; +const RECOVER_SKILL: u32 = 15309; +const PACK: u32 = 18469; +const GLIDER: u32 = 99991; +const FURNITURE: u32 = 60000; + +fn authored_data() -> GameData { + let mut data = test_data(); + for (id, kind) in [(PACK, 1), (GLIDER, backpack_type::GLIDER)] { + data.items.templates.insert( + id, + ItemTemplate { + kind: TemplateKind::Backpack { + backpack_type: kind, + }, + ..ItemTemplate::plain(id, 1) + }, + ); + } + let groups = vec![ + DoodadFuncGroups { + id: EMPTY, + almighty: RACK, + group_kind_id: doodad_func_group_kind::START, + ..Default::default() + }, + DoodadFuncGroups { + id: LOADED, + almighty: RACK, + group_kind_id: doodad_func_group_kind::NORMAL, + ..Default::default() + }, + ]; + let doodads = &mut data.systems.npcs.doodad; + doodads.templates.insert( + FURNITURE, + DoodadTemplate { + id: FURNITURE, + ..Default::default() + }, + ); + doodads.templates.insert( + RACK, + DoodadTemplate { + id: RACK, + func_groups: groups, + ..Default::default() + }, + ); + for (group, key, id, kind, skill, next) in [ + ( + EMPTY, + 7481, + 2, + "DoodadFuncConsumeChanger", + STORE_SKILL, + LOADED, + ), + ( + LOADED, + 9998, + 393, + "DoodadFuncRecoverItem", + RECOVER_SKILL, + EMPTY, + ), + ] { + doodads.funcs_by_groups.insert( + group, + vec![DoodadFunc { + group_id: group, + func_id: id, + func_key: key, + func_type: kind.into(), + next_phase: next as i32, + skill_id: skill, + perm_id: 5, + ..Default::default() + }], + ); + } + doodads + .func_templates + .entry("DoodadFuncConsumeChanger") + .or_default() + .insert( + 2, + FuncTemplate::ConsumeChanger(DoodadFuncConsumeChanger { + id: 2, + slot_id: 26, + count: 1, + }), + ); + doodads + .func_templates + .entry("DoodadFuncRecoverItem") + .or_default() + .insert( + 393, + FuncTemplate::RecoverItem(DoodadFuncRecoverItem { id: 393 }), + ); + doodads + .consume_changer_items + .push(DoodadFuncConsumeChangerItem { + id: 10, + doodad_func_consume_changer_id: 2, + item_id: PACK, + }); + data.systems.vehicles.slave_templates.insert( + HULL, + SlaveTemplate { + id: HULL, + name: "Merchant Schooner".into(), + model_id: 1205, + slave_kind: 2, + doodad_bindings: (60..80) + .map(|point| SlaveDoodadBinding { + id: u32::from(point), + owner_id: HULL, + owner_type: "Slave".into(), + attach_point_id: point, + doodad_id: RACK, + persist: true, + scale: 1.0, + }) + .collect(), + ..Default::default() + }, + ); + data +} + +struct CargoWorld { + w: World, + hull: SlaveRef, + racks: Vec, +} + +fn world(data: GameData) -> CargoWorld { + world_with_pool(data, None) +} + +fn world_with_pool(data: GameData, pool: Option) -> CargoWorld { + let bindings = data + .systems + .vehicles + .slave_template(HULL) + .unwrap() + .doodad_bindings + .iter() + .filter(|b| b.doodad_id == RACK) + .cloned() + .collect::>(); + assert_eq!(bindings.len(), 20); + let mut server = test_server_with(data); + if let Some(pool) = pool { + server.db = pool; + } + let server = Arc::new(server); + super::install(&server); + let mut a = TestClient::new(&server, 1, 1001); + let mut b = TestClient::new(&server, 2, 1002); + let mut alice = test_character(1, "Alice", 100.0, 100.0); + alice.inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); + let mut bob = test_character(2, "Bob", 101.0, 100.0); + bob.inventory = Inventory::new(2, 50, 50, &server.items, &server.ids.container); + let pa = spawn_player(&server, &a, alice, server.ids.object.get_next_id().unwrap()); + let pb = spawn_player(&server, &b, bob, server.ids.object.get_next_id().unwrap()); + a.conn.active_char = Some(pa.clone()); + b.conn.active_char = Some(pb.clone()); + let instance = server.world.world(0).unwrap(); + let mut hull = Slave::new(700, HULL); + hull.unit.model_id = 1205; + hull.unit.transform.set_xyz(100.0, 100.0, 100.0); + hull.summoner_id = 1; + hull.summoner_obj_id = pa.obj_id; + let hull = Entity::new(server.ids.object.get_next_id().unwrap(), hull); + instance.spawn(&hull, &server.view_ctx()); + let racks = bindings + .into_iter() + .map(|binding| { + let rack = manager::create(&server, &instance, 0, RACK, None, true).unwrap(); + { + let mut d = rack.data(); + d.owner_type = doodad_owner_type::SLAVE; + d.owner_id = 1; + d.owner_db_id = 700; + d.parent_obj_id = hull.obj_id; + d.attach_point = binding.attach_point_id; + d.is_persistent = true; + } + instance.attach_child(&WorldObject::from(&hull), &WorldObject::from(&rack)); + hull.data().attached_doodads.push(rack.obj_id); + instance.spawn(&rack, &server.view_ctx()); + rack + }) + .collect(); + a.drain(); + b.drain(); + CargoWorld { + w: World { + server, + a, + pa, + b, + pb, + }, + hull, + racks, + } +} + +fn use_rack(c: &CargoWorld, index: usize, skill: u32) { + assert!(interactions::execute_interaction( + &c.w.server, + interactions::world_interaction_type::USE, + &WorldObject::from(&c.w.pa), + Some(&WorldObject::from(&c.racks[index])), + skill, + 0, + None + )); +} + +fn transfer(c: &CargoWorld, item_id: u64, target_type: u8, slot: i32) { + let mut txn = ItemTxn::begin(&c.w.server); + let target = Inv::of(&c.w.pa).get(target_type).unwrap(); + assert!(crate::systems::economy::mail::add_or_move_existing_item( + &mut txn, + &target, + task_type::INVALID, + item_id, + slot + )); +} + +fn equipped(c: &CargoWorld) -> Item { + Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).unwrap() +} + +fn cargo_state(rack: &DoodadRef) -> (u32, u64, u32) { + let d = rack.data(); + (d.func_group_id, d.item_id, d.item_template_id) +} + +fn cleanup_source(item_id: u64, template: u32) -> DoodadItemCleanup { + DoodadItemCleanup { + doodad_template_id: if template == PACK { RACK } else { FURNITURE }, + owner_id: 1, + owner_type: if template == PACK { + doodad_owner_type::SLAVE + } else { + doodad_owner_type::CHARACTER + }, + item_id, + item_template_id: template, + ..Default::default() + } +} + +fn repeated_cycles(c: &mut CargoWorld) { + let ids: Vec<_> = (0..20) + .map(|_| { + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + transfer(c, id, slot_type::SYSTEM, -1); + id + }) + .collect(); + for cycle in 0..3 { + for step in 0..20 { + let index = (step * 7 + cycle * 3) % 20; + transfer(c, ids[index], slot_type::EQUIPMENT, equip_slot::BACKPACK); + use_rack(c, index, STORE_SKILL); + assert_eq!(cargo_state(&c.racks[index]), (LOADED, ids[index], PACK)); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); + } + for step in 0..20 { + let index = (step * 9 + cycle * 5) % 20; + use_rack(c, index, RECOVER_SKILL); + assert_eq!(equipped(c).id, ids[index]); + assert_eq!(cargo_state(&c.racks[index]), (EMPTY, 0, 0)); + transfer(c, ids[index], slot_type::SYSTEM, -1); + } + for id in &ids { + let copies: usize = + c.w.server + .items + .all_containers() + .iter() + .map(|container| { + container + .lock() + .unwrap() + .items + .iter() + .filter(|i| i.id == *id) + .count() + }) + .sum(); + assert_eq!(copies, 1); + } + } + assert_eq!(c.hull.data().attached_doodads.len(), 20); + assert!(!c.w.a.drain_ops().contains(&sc::SCErrorMsgPacket)); +} + +#[tokio::test] +async fn merchant_all_twenty_racks_survive_shuffled_repeated_load_unload() { + repeated_cycles(&mut world(authored_data())); +} + +#[tokio::test] +async fn cargo_checks_are_shared_with_other_hulls_and_nonpersistent_racks() { + let mut data = authored_data(); + let mut other = data.systems.vehicles.slave_template(HULL).unwrap().clone(); + other.id = 21; + for binding in &mut other.doodad_bindings { + binding.owner_id = other.id; + binding.persist = false; + } + data.systems + .vehicles + .slave_templates + .insert(other.id, other); + let c = world(data); + c.hull.data().unit.template_id = 21; + c.racks[11].data().is_persistent = false; + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 11, STORE_SKILL); + use_rack(&c, 11, RECOVER_SKILL); + assert_eq!(equipped(&c).id, id); + assert_eq!(cargo_state(&c.racks[11]), (EMPTY, 0, 0)); +} + +#[tokio::test] +async fn missing_deposit_source_and_zero_guid_cargo_cannot_reuse_old_success() { + let c = world(authored_data()); + c.racks[0].data().phase.to_next_phase = true; + let ctx = DoodadCtx::of(&c.w.server, &c.racks[0]).unwrap(); + items::consume_changer( + &DoodadFuncConsumeChanger { + id: 2, + slot_id: 26, + count: 1, + }, + &ctx, + Some(&WorldObject::from(&c.w.pa)), + ); + assert!(!c.racks[0].data().phase.to_next_phase); + assert_eq!(cargo_state(&c.racks[0]), (EMPTY, 0, 0)); + c.racks[0].data().item_template_id = PACK; + phase::set_func_group_id(&c.w.server, &c.racks[0], LOADED); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[0]), (LOADED, 0, PACK)); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); +} + +#[tokio::test] +async fn stale_captured_source_cannot_be_deposited_in_a_second_rack() { + let c = world(authored_data()); + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + let captured = equipped(&c); + use_rack(&c, 7, STORE_SKILL); + c.racks[18].data().phase.to_next_phase = true; + let _housing = c.w.server.systems.housing.operation_lock.lock().unwrap(); + assert!(!EconomyForNpcs.try_store_doodad_item( + &c.w.server, + &c.w.pa, + &c.racks[18], + &captured, + 1 + )); + assert_eq!(cargo_state(&c.racks[7]), (LOADED, id, PACK)); + assert_eq!(cargo_state(&c.racks[18]), (EMPTY, 0, 0)); + assert!(!c.racks[18].data().phase.to_next_phase); + assert_eq!( + c.w.server.items.item_by_id(id).unwrap().slot_type, + slot_type::SYSTEM + ); +} + +#[tokio::test] +async fn occupied_rack_and_changed_source_reject_without_overwriting_escrow() { + let mut c = world(authored_data()); + let first = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 3, STORE_SKILL); + let second = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + c.w.a.drain(); + c.racks[3].data().phase.to_next_phase = true; + let ctx = DoodadCtx::of(&c.w.server, &c.racks[3]).unwrap(); + items::consume_changer( + &DoodadFuncConsumeChanger { + id: 2, + slot_id: 26, + count: 1, + }, + &ctx, + Some(&WorldObject::from(&c.w.pa)), + ); + assert_eq!(cargo_state(&c.racks[3]), (LOADED, first, PACK)); + assert_eq!(equipped(&c).id, second); + assert!(!c.racks[3].data().phase.to_next_phase); + assert!(!c.w.a.drain_ops().contains(&sc::SCItemTaskSuccessPacket)); + for change in 0..3 { + let mut captured = equipped(&c); + match change { + 0 => captured.template_id += 1, + 1 => captured.count = 2, + _ => captured.slot -= 1, + } + let _housing = c.w.server.systems.housing.operation_lock.lock().unwrap(); + assert!(!EconomyForNpcs.try_store_doodad_item( + &c.w.server, + &c.w.pa, + &c.racks[4], + &captured, + 1 + )); + assert_eq!(cargo_state(&c.racks[4]), (EMPTY, 0, 0)); + assert_eq!(equipped(&c).id, second); + } +} + +#[tokio::test] +async fn failed_recovery_keeps_glider_and_cargo_then_retries_with_the_same_ids() { + let mut c = world(authored_data()); + let pack = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 19, STORE_SKILL); + let glider = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + GLIDER, + 1, + equip_slot::BACKPACK, + ); + Inv::of(&c.w.pa).bag().lock().unwrap().set_container_size(1); + let filler = give(&c.w, &c.w.pa, slot_type::INVENTORY, SINGLE, 1, 0); + c.w.a.drain(); + c.racks[19].data().phase.to_next_phase = true; + use_rack(&c, 19, RECOVER_SKILL); + assert_eq!(equipped(&c).id, glider); + assert_eq!(cargo_state(&c.racks[19]), (LOADED, pack, PACK)); + assert!(!c.racks[19].data().phase.to_next_phase); + assert_eq!( + c.w.server.items.item_by_id(pack).unwrap().slot_type, + slot_type::SYSTEM + ); + assert!(!c.w.a.drain_ops().contains(&sc::SCItemTaskSuccessPacket)); + { + let mut txn = ItemTxn::begin(&c.w.server); + Inv::of(&c.w.pa).bag().lock().unwrap().remove_item_task( + task_type::INVALID, + filler, + true, + &mut txn.env, + ); + } + use_rack(&c, 19, RECOVER_SKILL); + assert_eq!(equipped(&c).id, pack); + assert_eq!(cargo_state(&c.racks[19]), (EMPTY, 0, 0)); + assert_eq!( + c.w.server.items.item_by_id(glider).unwrap().slot_type, + slot_type::INVENTORY + ); + use_rack(&c, 19, STORE_SKILL); + let other_pack = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 19, RECOVER_SKILL); + assert_eq!(equipped(&c).id, other_pack); + assert_eq!(cargo_state(&c.racks[19]), (LOADED, pack, PACK)); + transfer(&c, other_pack, slot_type::SYSTEM, -1); + use_rack(&c, 19, RECOVER_SKILL); + assert_eq!(equipped(&c).id, pack); + assert_eq!(cargo_state(&c.racks[19]), (EMPTY, 0, 0)); +} + +#[tokio::test] +async fn duplicate_cleanup_preserves_the_sole_pack_for_the_surviving_rack() { + let c = world(authored_data()); + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 0, STORE_SKILL); + { + let mut duplicate = c.racks[1].data(); + duplicate.item_id = id; + duplicate.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[1], LOADED); + let instance = c.w.server.world.world(0).unwrap(); + manager::delete(&c.w.server, &instance, &c.racks[1]); + assert_eq!( + c.w.server.items.item_by_id(id).unwrap().slot_type, + slot_type::SYSTEM + ); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(equipped(&c).id, id); +} + +#[tokio::test] +async fn both_cleanup_hooks_retain_cargo_without_any_spawned_reference() { + for persisted_row_route in [false, true] { + let c = world(authored_data()); + let id = give(&c.w, &c.w.pa, slot_type::SYSTEM, PACK, 1, -1); + assert!(c + .w + .server + .world + .world(0) + .unwrap() + .all_doodads() + .iter() + .all(|d| d.data().item_id != id)); + if persisted_row_route { + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, cleanup_source(id, PACK)); + } else { + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, cleanup_source(id, PACK)); + } + assert!(!c.w.server.items.removed_items().contains(&id)); + assert_eq!( + c.w.server.items.item_by_id(id).unwrap().slot_type, + slot_type::SYSTEM + ); + // Model the surviving saved rack becoming available after cleanup. + { + let mut survivor = c.racks[0].data(); + survivor.item_id = id; + survivor.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[0], LOADED); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(equipped(&c).id, id); + assert!(!c.w.server.items.removed_items().contains(&id)); + // Replayed cleanup of the stale alias cannot delete the pack after its recovery either. + if persisted_row_route { + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, cleanup_source(id, PACK)); + } else { + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, cleanup_source(id, PACK)); + } + assert_eq!(equipped(&c).id, id); + assert!(!c.w.server.items.removed_items().contains(&id)); + } +} + +#[tokio::test] +async fn cargo_preservation_does_not_disable_ordinary_item_or_glider_cleanup() { + for persisted_row_route in [false, true] { + for template in [SINGLE, GLIDER] { + let c = world(authored_data()); + let id = give(&c.w, &c.w.pa, slot_type::SYSTEM, template, 1, -1); + if persisted_row_route { + EconomyForNpcs + .release_deleted_doodad_items(&c.w.server, cleanup_source(id, template)); + } else { + EconomyForNpcs + .remove_expired_doodad_item(&c.w.server, cleanup_source(id, template)); + } + assert!(c.w.server.items.item_by_id(id).is_none()); + assert!(c.w.server.items.removed_items().contains(&id)); + } + } +} + +fn recycle_pack_guid(c: &CargoWorld, id: u64, template: u32, slot_type: u8, slot: i32) { + { + let mut txn = ItemTxn::begin(&c.w.server); + let system = Inv::of(&c.w.pa) + .get(crate::models::container::slot_type::SYSTEM) + .unwrap(); + assert!(system + .lock() + .unwrap() + .remove_item_task(task_type::INVALID, id, true, &mut txn.env) + .is_some()); + } + assert_eq!( + give(&c.w, &c.w.pb, slot_type, template, 1, slot), + id, + "exercise actual allocator reuse, not just a stale item snapshot" + ); + assert!(!c.w.server.items.removed_items().contains(&id)); +} + +fn record_item_releases(c: &CargoWorld) -> Arc>> { + let releases = Arc::new(std::sync::Mutex::new(Vec::new())); + let observed = releases.clone(); + c.w.server + .ids + .item + .install_release_hook(move |id| observed.lock().unwrap().push(id)); + releases +} + +#[tokio::test] +async fn both_cleanup_hooks_reject_recycled_foreign_items_and_unrelated_containers() { + for (template, target, slot) in [ + (SINGLE, slot_type::INVENTORY, 0), + (SINGLE, slot_type::BANK, 0), + (SINGLE, slot_type::SYSTEM, -1), + (GLIDER, slot_type::EQUIPMENT, equip_slot::BACKPACK), + ] { + let c = world(authored_data()); + let releases = record_item_releases(&c); + let id = give(&c.w, &c.w.pa, slot_type::SYSTEM, PACK, 1, -1); + recycle_pack_guid(&c, id, template, target, slot); + releases.lock().unwrap().clear(); + let before = c.w.server.items.item_by_id(id).unwrap(); + let foreign = Inv::of(&c.w.pb).get(target).unwrap(); + let mut sources = vec![cleanup_source(id, PACK), cleanup_source(id, template)]; + if target != slot_type::SYSTEM { + let mut same_owner = cleanup_source(id, template); + same_owner.owner_id = 2; + sources.push(same_owner); + } + for mut source in sources { + source.container_id = foreign.lock().unwrap().container_id; + EconomyForNpcs.remove_expired_doodad_item(&c.w.server, source); + EconomyForNpcs.release_deleted_doodad_items(&c.w.server, source); + assert_eq!(c.w.server.items.item_by_id(id).unwrap(), before); + assert!(releases.lock().unwrap().is_empty()); + assert!(!c.w.server.items.removed_items().contains(&id)); + assert!(Arc::ptr_eq( + &c.w.server + .items + .container_by_id(source.container_id) + .unwrap(), + &foreign + )); + } + } +} + +#[tokio::test] +async fn dangling_rack_repair_does_not_move_another_players_pack_or_create_one() { + let mut c = world(authored_data()); + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 0, STORE_SKILL); + { + let mut txn = ItemTxn::begin(&c.w.server); + assert!(crate::systems::economy::mail::add_or_move_existing_item( + &mut txn, + &Inv::of(&c.w.pb).equipment(), + task_type::INVALID, + id, + equip_slot::BACKPACK + )); + } + let before = Inv::of(&c.w.pb).equipped(equip_slot::BACKPACK).unwrap(); + c.w.a.drain(); + c.w.b.drain(); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[0]), (EMPTY, 0, 0)); + assert_eq!( + Inv::of(&c.w.pb).equipped(equip_slot::BACKPACK).unwrap(), + before + ); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); + assert!(!c.w.a.drain_ops().contains(&sc::SCItemTaskSuccessPacket)); + assert!(!c.w.b.drain_ops().contains(&sc::SCItemTaskSuccessPacket)); + + // A legacy pack in another actor's bag is outside escrow too: repair the rack only. + let foreign_equipment = Inv::of(&c.w.pb).equipment(); + let mut in_bag = foreign_equipment.lock().unwrap().remove_item(id).unwrap(); + in_bag.slot_type = slot_type::INVENTORY; + in_bag.slot = 0; + let foreign_bag = Inv::of(&c.w.pb).bag(); + foreign_bag.lock().unwrap().items.push(in_bag.clone()); + { + let mut d = c.racks[3].data(); + d.item_id = id; + d.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[3], LOADED); + use_rack(&c, 3, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[3]), (EMPTY, 0, 0)); + assert_eq!(c.w.server.items.item_by_id(id).unwrap(), in_bag); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); + + // A missing item is also dangling, but only the rack reference/phase is repaired. + { + let mut d = c.racks[2].data(); + d.item_id = id + 99999; + d.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[2], LOADED); + use_rack(&c, 2, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[2]), (EMPTY, 0, 0)); + assert!(c.w.server.items.item_by_id(id + 99999).is_none()); +} + +#[tokio::test] +async fn ambiguous_escrow_and_wrong_hull_graph_are_not_repaired() { + let c = world(authored_data()); + let id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 5, STORE_SKILL); + let source = c.w.server.items.item_by_id(id).unwrap(); + let mut second_copy = source.clone(); + second_copy.slot_type = slot_type::INVENTORY; + second_copy.owner_id = u64::from(c.w.pb.character_id); + second_copy.slot = 0; + let foreign_bag = Inv::of(&c.w.pb).bag(); + foreign_bag.lock().unwrap().items.push(second_copy); + use_rack(&c, 5, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[5]), (LOADED, id, PACK)); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); + foreign_bag.lock().unwrap().remove_item(id); + c.w.server.items.add_loose(source.clone()); + // Loose items are not inferred as missing if the persistent holder disappears. + let system = Inv::of(&c.w.pa).get(slot_type::SYSTEM).unwrap(); + system.lock().unwrap().remove_item(id); + use_rack(&c, 5, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[5]), (LOADED, id, PACK)); + c.w.server.items.take_loose(id); + c.racks[5].data().owner_db_id += 1; + use_rack(&c, 5, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[5]), (LOADED, id, PACK)); +} + +#[tokio::test] +async fn removal_ignores_stale_children_but_blocks_a_live_persistent_child() { + let c = world(authored_data()); + let instance = c.w.server.world.world(0).unwrap(); + let mut data = Doodad::new(RACK); + data.is_persistent = true; + let child = Entity::new(0x900, data); + instance.spawn(&child, &c.w.server.view_ctx()); + instance.attach_child(&WorldObject::from(&c.racks[0]), &WorldObject::from(&child)); + assert!(!interactions::doodad_allow_removal( + &c.w.server, + &c.racks[0] + )); + // Existing attach_child leaves the old parent's entry behind when reparenting. + instance.attach_child(&WorldObject::from(&c.racks[1]), &WorldObject::from(&child)); + assert!(interactions::doodad_allow_removal(&c.w.server, &c.racks[0])); + assert!(!interactions::doodad_allow_removal( + &c.w.server, + &c.racks[1] + )); + instance.remove_object(child.obj_id); + assert!(interactions::doodad_allow_removal(&c.w.server, &c.racks[1])); + let replacement = Entity::new(child.obj_id, child.data().clone()); + instance.spawn(&replacement, &c.w.server.view_ctx()); + assert!(interactions::doodad_allow_removal(&c.w.server, &c.racks[1])); +} + +#[tokio::test] +async fn dangling_cargo_repair_requires_live_child_identity_not_a_reused_id() { + let c = world(authored_data()); + let missing_item = 9_000_000; + { + let mut rack = c.racks[0].data(); + rack.item_id = missing_item; + rack.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[0], LOADED); + let instance = c.w.server.world.world(0).unwrap(); + let mut data = Doodad::new(RACK); + data.is_persistent = true; + let child = Entity::new(0x900, data); + instance.spawn(&child, &c.w.server.view_ctx()); + instance.attach_child(&WorldObject::from(&c.racks[0]), &WorldObject::from(&child)); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[0]), (LOADED, missing_item, PACK)); + // The cached child retains its old parent, but this live allocation with its id is unrelated. + instance.remove_object(child.obj_id); + let unrelated = Entity::new(child.obj_id, Doodad::new(RACK)); + instance.spawn(&unrelated, &c.w.server.view_ctx()); + use_rack(&c, 0, RECOVER_SKILL); + assert_eq!(cargo_state(&c.racks[0]), (EMPTY, 0, 0)); + assert!(Arc::ptr_eq( + &instance.doodad(unrelated.obj_id).unwrap(), + &unrelated + )); + assert!(c.w.server.items.item_by_id(missing_item).is_none()); + assert!(Inv::of(&c.w.pa).equipped(equip_slot::BACKPACK).is_none()); +} + +async fn private_doodad_pool() -> sqlx::MySqlPool { + use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; + use std::str::FromStr; + + let options = MySqlConnectOptions::from_str( + &std::env::var("AAEMU_TEST_MYSQL").expect("AAEMU_TEST_MYSQL"), + ) + .unwrap(); + assert_eq!(options.get_port(), 3317); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .idle_timeout(None) + .max_lifetime(None) + .connect_with(options) + .await + .unwrap(); + for table in ["doodads", "items", "item_containers"] { + let (_, ddl): (String, String) = sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&ddl.replacen("CREATE TABLE", "CREATE TEMPORARY TABLE", 1)) + .execute(&pool) + .await + .unwrap(); + } + pool +} + +#[tokio::test] +#[ignore = "private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary tables"] +async fn private_mysql_saved_offline_rack_alias_survives_both_cleanup_routes() { + use crate::systems::npcs::doodad::db; + let pool = private_doodad_pool().await; + + for persisted_row_route in [false, true] { + // `doodads` is the connection-local temporary table created above. + sqlx::query("DELETE FROM doodads") + .execute(&pool) + .await + .unwrap(); + let c = world_with_pool(authored_data(), Some(pool.clone())); + let item_id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 0, STORE_SKILL); + { + let mut survivor = c.racks[1].data(); + survivor.item_id = item_id; + survivor.item_template_id = PACK; + } + phase::set_func_group_id(&c.w.server, &c.racks[1], LOADED); + c.w.server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + let deleted_id = c.racks[0].data().db_id; + let survivor_id = c.racks[1].data().db_id; + let aliases: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM doodads WHERE item_id = ?") + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(aliases, 2); + let instance = c.w.server.world.world(0).unwrap(); + // Unload the surviving object without deleting its saved row or its escrow item. + instance.delete(&c.racks[1]); + if persisted_row_route { + instance.delete(&c.racks[0]); + let mut connection = pool.acquire().await.unwrap(); + assert!( + db::delete_doodad_by_id(&c.w.server, &mut connection, deleted_id) + .await + .unwrap() + ); + } else { + manager::delete(&c.w.server, &instance, &c.racks[0]); + } + c.w.server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + assert!(instance + .all_doodads() + .iter() + .all(|d| d.data().item_id != item_id)); + assert_eq!( + c.w.server.items.item_by_id(item_id).unwrap().slot_type, + slot_type::SYSTEM + ); + assert!(!c.w.server.items.removed_items().contains(&item_id)); + let survivors: Vec = + sqlx::query_scalar("SELECT CAST(id AS UNSIGNED) FROM doodads WHERE item_id = ?") + .bind(item_id) + .fetch_all(&pool) + .await + .unwrap(); + assert_eq!(survivors, vec![u64::from(survivor_id)]); + let spawns = c.w.server.systems.npcs.spawns.get_or_create(&instance); + assert_eq!( + spawns + .spawn_persistent_doodads( + &c.w.server, + doodad_owner_type::SLAVE, + 700, + Some(&WorldObject::from(&c.hull)), + true + ) + .await + .unwrap(), + 1 + ); + let restored = instance.doodad_by_db_id(survivor_id).unwrap(); + assert!(interactions::execute_interaction( + &c.w.server, + interactions::world_interaction_type::USE, + &WorldObject::from(&c.w.pa), + Some(&WorldObject::from(&restored)), + RECOVER_SKILL, + 0, + None + )); + assert_eq!(equipped(&c).id, item_id); + assert!(!c.w.server.items.removed_items().contains(&item_id)); + c.w.server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + } +} + +async fn persist_inventory(c: &CargoWorld, pool: &sqlx::MySqlPool) { + let batch = { + let _economy = c.w.server.systems.economy.ops_lock(); + c.w.server.items.prepare_save() + }; + let mut tx = pool.begin().await.unwrap(); + c.w.server + .items + .write_prepared(&mut tx, batch) + .await + .unwrap(); + tx.commit().await.unwrap(); + c.w.server.items.commit_save(); +} + +#[tokio::test] +#[ignore = "private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary tables"] +async fn private_mysql_stale_rack_guid_reuse_preserves_foreign_items_and_container() { + use crate::models::doodad::DoodadCofferState; + use crate::systems::npcs::doodad::db; + + let pool = private_doodad_pool().await; + for (template, target, slot) in [ + (SINGLE, slot_type::INVENTORY, 0), + (SINGLE, slot_type::BANK, 0), + (GLIDER, slot_type::EQUIPMENT, equip_slot::BACKPACK), + ] { + for table in ["doodads", "items", "item_containers"] { + // All three names refer to this connection's temporary tables. + sqlx::query(&format!("DELETE FROM `{table}`")) + .execute(&pool) + .await + .unwrap(); + } + let c = world_with_pool(authored_data(), Some(pool.clone())); + let releases = record_item_releases(&c); + let original_coffer = + c.w.server + .items + .new_coffer_container(1, &c.w.server.ids.container); + let container_id = original_coffer.lock().unwrap().container_id; + // Legacy rows may carry stale item-container references as well as cargo item GUIDs. + c.racks[0].data().coffer = Some(DoodadCofferState { + capacity: 1, + container_id, + opened_by: None, + }); + let item_id = give( + &c.w, + &c.w.pa, + slot_type::EQUIPMENT, + PACK, + 1, + equip_slot::BACKPACK, + ); + use_rack(&c, 0, STORE_SKILL); + c.w.server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + let deleted_id = c.racks[0].data().db_id; + recycle_pack_guid(&c, item_id, template, target, slot); + assert!(c.w.server.items.forget_container(container_id)); + c.w.server.ids.container.release_id(container_id as u32); + let foreign_coffer = + c.w.server + .items + .new_coffer_container(2, &c.w.server.ids.container); + assert_eq!( + foreign_coffer.lock().unwrap().container_id, + container_id, + "exercise actual container allocator reuse" + ); + persist_inventory(&c, &pool).await; + let before = c.w.server.items.item_by_id(item_id).unwrap(); + releases.lock().unwrap().clear(); + c.w.server.world.world(0).unwrap().delete(&c.racks[0]); + { + let mut conn = pool.acquire().await.unwrap(); + assert!(db::delete_doodad_by_id(&c.w.server, &mut conn, deleted_id) + .await + .unwrap()); + } + assert_eq!(c.w.server.items.item_by_id(item_id).unwrap(), before); + assert!(!c.w.server.items.removed_items().contains(&item_id)); + assert!(releases.lock().unwrap().is_empty()); + assert!(Arc::ptr_eq( + &c.w.server.items.container_by_id(container_id).unwrap(), + &foreign_coffer + )); + persist_inventory(&c, &pool).await; + let foreign_owner: u64 = + sqlx::query_scalar("SELECT CAST(owner AS UNSIGNED) FROM items WHERE id = ?") + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(foreign_owner, 2); + let container_owner: u64 = sqlx::query_scalar( + "SELECT CAST(owner_id AS UNSIGNED) FROM item_containers WHERE container_id = ?", + ) + .bind(container_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(container_owner, 2); + } + + for table in ["doodads", "items", "item_containers"] { + sqlx::query(&format!("DELETE FROM `{table}`")) + .execute(&pool) + .await + .unwrap(); + } + // Control: a saved ordinary furniture reference still owns a matching System-escrow item. + let c = world_with_pool(authored_data(), Some(pool.clone())); + let releases = record_item_releases(&c); + let item_id = give(&c.w, &c.w.pa, slot_type::SYSTEM, SINGLE, 1, -1); + let instance = c.w.server.world.world(0).unwrap(); + let furniture = manager::create(&c.w.server, &instance, 0, FURNITURE, None, true).unwrap(); + { + let mut d = furniture.data(); + d.is_persistent = true; + d.owner_type = doodad_owner_type::CHARACTER; + d.owner_id = 1; + d.item_id = item_id; + d.item_template_id = SINGLE; + } + db::save_now(&c.w.server, &furniture).await.unwrap(); + persist_inventory(&c, &pool).await; + let db_id = furniture.data().db_id; + { + let mut conn = pool.acquire().await.unwrap(); + assert!(db::delete_doodad_by_id(&c.w.server, &mut conn, db_id) + .await + .unwrap()); + } + assert!(c.w.server.items.item_by_id(item_id).is_none()); + assert!(c.w.server.items.removed_items().contains(&item_id)); + assert_eq!(*releases.lock().unwrap(), vec![item_id as u32]); + persist_inventory(&c, &pool).await; + let remaining: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM items WHERE id = ?") + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(remaining, 0); +} + +#[tokio::test] +#[ignore = "needs AAEMU_COMPACT_DB"] +async fn real_compact_merchant_all_twenty_racks_survive_shuffled_cycles() { + use crate::data::client_files::ClientFileManager; + use crate::systems::DataLoadCtx; + + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + rusqlite::Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .unwrap(); + let app = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("app"); + let files = ClientFileManager::from_sources(&[], &app); + let ctx = DataLoadCtx { + conn: &conn, + app_path: &app, + files: &files, + language: "en_us", + }; + let mut data = GameData::empty(); + data.items = crate::data::ItemData::load(&conn).unwrap(); + data.systems.npcs.doodad = crate::systems::npcs::doodad::data::DoodadData::load(&ctx).unwrap(); + data.systems.vehicles = crate::systems::vehicles::Data::load(&ctx).unwrap(); + assert!(matches!( + data.items.template(23398).unwrap().kind, + TemplateKind::SummonSlave { slave_id: HULL } + )); + repeated_cycles(&mut world(data)); +} diff --git a/rust/crates/aaemu-game/src/systems/economy/craft.rs b/rust/crates/aaemu-game/src/systems/economy/craft.rs index a28fdafb41..55cdc005f3 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft.rs @@ -33,10 +33,17 @@ use crate::systems::HookSlot; use crate::world::{DoodadRef, PlayerRef, WorldObject}; use super::craft_data::Craft; +#[cfg(test)] +#[path = "craft_publication_tests.rs"] +mod publication_tests; use super::error_message; use super::inventory::{self, Inv, ItemTxn, Out}; use super::item_handlers::{active, sync_client_packet}; +#[cfg(test)] +#[path = "bench_tests.rs"] +mod bench_tests; + /// `DoodadFuncPermission`. pub mod doodad_func_permission { pub const ANY: u8 = 0; @@ -49,7 +56,8 @@ pub mod doodad_func_permission { pub const ZONE_RESIDENTS: u8 = 8; } -/// What crafting needs from other subsystems. Every method has a "not ported yet" default. +/// What crafting needs from other subsystems. Station authorization defaults to the loaded +/// NPC/craft data; the skill, housing bonus and quest hooks are installed at startup. pub trait CraftHooks: Send + Sync { /// skills: `new Skill(SkillManager.GetSkillTemplate(skillId)) { CastTimeMultiplier } /// .Use(owner, SkillCasterUnit(owner.ObjId), SkillCastDoodadTarget(doodadObjId), null, @@ -73,9 +81,15 @@ pub trait CraftHooks: Send + Sync { /// Owner.InterruptSkills();`. fn cancel_craft_skill(&self, _server: &GameServer, _player: &PlayerRef) {} - /// npcs: `Doodad.FuncPermission` (`PermId` of the first current func, `Any` without one). - fn doodad_func_permission(&self, _server: &GameServer, _doodad: &DoodadRef) -> u8 { - doodad_func_permission::ANY + /// npcs: permission of the current crafting function whose authored list contains the + /// recipe. Missing membership denies access, including at the canonical req_doodad_id. + fn doodad_craft_permission( + &self, + server: &GameServer, + doodad: &DoodadRef, + craft_id: u32, + ) -> Option { + crate::systems::npcs::bridges::doodad_craft_permission(server, doodad, craft_id) } /// housing: `HousingManager.GetByAccountId(accountId)` -> the `Transform.ZoneId` of every @@ -221,65 +235,129 @@ pub fn zone_group_id(server: &GameServer, zone_key: u32) -> u32 { .map_or(0, |z| z.group_id) } -/// A direct crafting packet must obey the same house access rules as interacting with -/// its furniture. Portable crafts and public world stations keep their normal skill checks. -fn housing_bench_access( +/// Authorize the recipe against the live station at both cast start and product commit. +fn bench_access( server: &GameServer, player: &PlayerRef, doodad_id: u32, - skill_id: u32, + craft: &Craft, + hooks: &dyn CraftHooks, ) -> bool { - match housing_bench_denial(server, player, doodad_id, skill_id) { + match bench_denial(server, player, doodad_id, craft, hooks) { None => true, Some(reason) => { tracing::warn!( - "{} may not craft at doodad {doodad_id} (skill {skill_id}): {reason}", - player.data().unit.name + craft_id = craft.id, + skill_id = craft.skill_id, + "{} may not craft at doodad {doodad_id}: {reason}", + player.data().unit.name, ); false } } } -/// Why [`housing_bench_access`] refuses (`None` = allowed). -fn housing_bench_denial( +/// Why [`bench_access`] refuses (`None` = allowed). +fn bench_denial( server: &GameServer, player: &PlayerRef, doodad_id: u32, - skill_id: u32, + craft: &Craft, + hooks: &dyn CraftHooks, ) -> Option<&'static str> { - // Not a doodad (portable craft, id 0): allowed. - let doodad = server + // Portable skills can name no target or the crafter. Neither form may bypass a + // station recipe's requirements; every other nonzero target must be a real bench. + if doodad_id == 0 || doodad_id == player.obj_id { + return (craft.req_doodad_id != 0 || craft.is_pack) + .then_some("the recipe requires a crafting station"); + } + let Some(doodad) = server .world .object(doodad_id) - .and_then(|o| o.as_doodad().cloned())?; - let (owner_type, house_id, instance_id, deleted) = { + .and_then(|o| o.as_doodad().cloned()) + else { + return Some("the crafting station does not exist"); + }; + let (owner_type, house_id, owner_id, instance_id, deleted) = { let d = doodad.data(); ( d.owner_type, d.owner_db_id, + d.owner_id, d.transform.instance_id, d.phase.deleted, ) }; - if owner_type != crate::models::doodad::doodad_owner_type::HOUSING { - return None; - } - let Some(house) = crate::systems::housing::house_by_id(server, house_id) else { - return Some("the bench's house does not exist"); - }; if deleted { return Some("the bench is deleted"); } - if player.data().unit.transform.instance_id != instance_id - || house.data().unit.transform.instance_id != instance_id - { - return Some("player, bench and house are in different instances"); + if player.data().unit.transform.instance_id != instance_id { + return Some("player and bench are in different instances"); } - if !crate::systems::housing::allowed_to_interact(server, &house, player) { - return Some("the house does not allow the player to interact"); + let Some(perm) = hooks.doodad_craft_permission(server, &doodad, craft.id) else { + return Some("the current crafting function does not offer this recipe"); + }; + use crate::models::doodad::doodad_owner_type as owner; + let house = if owner_type == owner::HOUSING { + let Some(house) = crate::systems::housing::house_by_id(server, house_id) else { + return Some("the bench's house does not exist"); + }; + if house.data().unit.transform.instance_id != instance_id { + return Some("bench and house are in different instances"); + } + // CraftPack Any explicitly opens the recipe to visitors (including the eight tax + // plaques). Other functions retain the house's access rules. + if perm != doodad_func_permission::ANY + && !crate::systems::housing::allowed_to_interact(server, &house, player) + { + let h = house.data(); + tracing::warn!( + house_id, + house_owner = h.unit.owner_id, + house_permission = h.permission, + craft_id = craft.id, + "Craft bench house access denied" + ); + return Some("the house does not allow the player to interact"); + } + Some(house) + } else { + None + }; + use doodad_func_permission as p; + match perm { + p::ANY | p::PERMISSION1 | p::PERMISSION2 | p::PERMISSION4 | p::OWNER_RAID_MEMBERS => {} + p::OWNER_ONLY => { + let owner_id = house.as_ref().map_or(owner_id, |h| h.data().unit.owner_id); + if owner_id == 0 || player.character_id != owner_id { + return Some("the crafting function requires its owner"); + } + } + p::SAME_ACCOUNT => { + let account = house.as_ref().map(|h| h.data().account_id).or_else(|| { + (owner_type == owner::CHARACTER) + .then(|| server.names.get_character_account(owner_id)) + }); + if account.is_none_or(|a| a == 0 || a != player.data().account_id) { + return Some("the crafting function requires the owner's account"); + } + } + p::ZONE_RESIDENTS => { + let zone_group = zone_group_id(server, doodad.data().transform.zone_id); + let account = player.data().account_id; + if !hooks + .account_house_zone_ids(server, account) + .into_iter() + .any(|zone| zone_group_id(server, zone) == zone_group) + { + return Some("the crafting function requires a zone resident"); + } + } + _ => return Some("the crafting function has an unknown permission"), } - let template = server.game_data.systems.skills.skill(skill_id)?; + let Some(template) = server.game_data.systems.skills.skill(craft.skill_id) else { + return Some("the craft skill does not exist"); + }; if template.max_range <= 0 { return None; } @@ -368,99 +446,11 @@ pub fn craft(server: &GameServer, player: &PlayerRef, craft_id: u32, count: i32, return; } - // Check if we have permission to actually use the doodad (mostly sanity check since the - // client already checks this before you can craft) - let mut has_permission = true; - if !housing_bench_access(server, player, doodad_id, craft.skill_id) { - error2( - &mut out, - player, - error_message::CRAFT_CANT_ACT_ANY_MORE, - error_message::CRAFT_PERMISSION_DENY, - 0, - false, - ); - cancel_craft(server, player); + if !bench_access(server, player, doodad_id, craft, hooks.as_ref()) { + abort_craft_with(server, player, error_message::CRAFT_PERMISSION_DENY); return; } let world = server.world.world_of(&WorldObject::from(player)); - let doodad = world.as_ref().and_then(|w| w.doodad(doodad_id)); - if let Some(doodad) = &doodad { - let perm = hooks.doodad_func_permission(server, doodad); - if perm != doodad_func_permission::ANY { - use doodad_func_permission as p; - match perm { - p::ANY - | p::PERMISSION1 - | p::PERMISSION2 - | p::OWNER_ONLY - | p::PERMISSION4 - | p::OWNER_RAID_MEMBERS => {} - p::SAME_ACCOUNT => { - let (owner_type, owner_id) = { - let d = doodad.data(); - (d.owner_type, d.owner_id) - }; - if owner_type == crate::models::doodad::doodad_owner_type::CHARACTER { - let my_account = player.data().account_id; - has_permission = match server.world.character_by_id(owner_id) { - Some(o) => o.data().account_id == my_account, - None => { - // C#: GetCharacterById(...).AccountId -> NullReferenceException - // (the client stayed locked). Deviation: no permission. - tracing::error!( - "Craft: doodad owner {owner_id} is not online (C# throws)" - ); - false - } - }; - } - } - p::ZONE_RESIDENTS => { - has_permission = false; - let zone_group = zone_group_id(server, doodad.data().transform.zone_id); - let account = player.data().account_id; - for house_zone in hooks.account_house_zone_ids(server, account) { - if zone_group_id(server, house_zone) == zone_group { - has_permission = true; - break; - } - } - } - _ => { - // C#: throw new ArgumentOutOfRangeException (the client stayed locked). - // Deviation: no permission. - tracing::error!("Craft: unknown DoodadFuncPermission {perm}"); - has_permission = false; - } - } - let (template_id, obj_id) = (doodad.data().template_id, doodad.obj_id); - send_debug_message( - server, - &mut out, - player, - &format!( - "Crafting using @DOODAD_NAME({template_id}) - {template_id} (objId: {obj_id}) with current permission {} = {}", - permission_name(perm), - if has_permission { "True" } else { "False" } - ), - ); - } - } - - if !has_permission { - // TODO not verified - error2( - &mut out, - player, - error_message::CRAFT_CANT_ACT_ANY_MORE, - error_message::CRAFT_PERMISSION_DENY, - 0, - false, - ); - cancel_craft(server, player); - return; - } mgr.update(char_id, |s| s.is_crafting = true); @@ -628,21 +618,6 @@ pub fn cast_failed(server: &GameServer, player: &PlayerRef, skill_id: u32, resul } } -fn permission_name(perm: u8) -> &'static str { - use doodad_func_permission as p; - match perm { - p::ANY => "Any", - p::PERMISSION1 => "Permission1", - p::PERMISSION2 => "Permission2", - p::OWNER_ONLY => "OwnerOnly", - p::PERMISSION4 => "Permission4", - p::OWNER_RAID_MEMBERS => "OwnerRaidMembers", - p::SAME_ACCOUNT => "SameAccount", - p::ZONE_RESIDENTS => "ZoneResidents", - _ => "?", - } -} - /// `CharacterCraft.EndCraft()` (called by the skills subsystem when the craft skill's /// `CraftEffect` applies). pub fn end_craft(server: &GameServer, player: &PlayerRef) { @@ -684,7 +659,8 @@ pub fn end_craft(server: &GameServer, player: &PlayerRef) { } // Keep the permission check and product/material commit together with house transfers - // and permission changes. Economy transactions are acquired after this housing lock. + // and permission changes. Enter the item scope before housing; ItemTxn follows it. + let _items = server.systems.economy.operation_scope(); let housing_bench = server .world .object(state.doodad_id) @@ -698,7 +674,7 @@ pub fn end_craft(server: &GameServer, player: &PlayerRef) { .lock() .unwrap_or_else(|e| e.into_inner()) }); - if !housing_bench_access(server, player, state.doodad_id, craft.skill_id) { + if !bench_access(server, player, state.doodad_id, craft, mgr.hooks().as_ref()) { drop(operation); error2( &mut Out::Direct, diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_data.rs b/rust/crates/aaemu-game/src/systems/economy/craft_data.rs index a8c0a9981c..3054170602 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft_data.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft_data.rs @@ -2,7 +2,7 @@ //! `craft_materials`, `craft_pack_crafts`) and the `SkillTemplate` members `CharacterCraft` reads //! for a craft's skill (`consume_lp`, `actability_group_id`, `cooldown_time`). -use std::collections::HashMap; +use std::collections::{HashMap, HashSet}; use crate::data::items::TemplateKind; use crate::data::sqlite::for_each_row; @@ -81,6 +81,8 @@ pub struct CraftData { pub crafts: HashMap, /// Skill facts of every skill a craft uses (`SkillManager.GetSkillTemplate(craft.SkillId)`). pub skills: HashMap, + /// Recipes explicitly offered by each `DoodadFuncCraftPack`. + pub craft_pack_crafts: HashMap>, } impl CraftData { @@ -120,7 +122,8 @@ impl CraftData { amount: r.i32_or("amount", 1)?, // We always want to produce at least 1 item ? rate: r.i32("rate")?, show_lower_crafts: r.bool("show_lower_crafts")?, - use_grade: r.bool("use_grade")?, + // Native 1.2 LoadCraftProductDescs (0x3982E6C0) reads text 't' / '1'. + use_grade: r.bool_str("use_grade")?, item_grade_id: r.u32("item_grade_id")?, }); Ok(()) @@ -135,13 +138,19 @@ impl CraftData { craft_id, item_id: r.u32("item_id")?, amount: r.i32_or("amount", 1)?, // We always want to cost at least 1 item ? - main_grade: r.bool("main_grade")?, + // Native 1.2 LoadCraftMaterialDescs (0x3982E4D0) reads text 't' / '1'. + main_grade: r.bool_str("main_grade")?, }); Ok(()) })?; for_each_row(ctx.conn, "SELECT * FROM craft_pack_crafts", [], |r| { - if let Some(craft) = d.crafts.get_mut(&r.u32("craft_id")?) { + let craft_id = r.u32("craft_id")?; + if let Some(craft) = d.crafts.get_mut(&craft_id) { craft.is_pack = true; + d.craft_pack_crafts + .entry(r.u32("craft_pack_id")?) + .or_default() + .insert(craft_id); } Ok(()) })?; diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs new file mode 100644 index 0000000000..ae947f131d --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/craft_publication_tests.rs @@ -0,0 +1,267 @@ +//! The real craft -> quest component -> force_spawn callback contends with an expired +//! source-item doodad's real cleanup. Channel/gate waits are bounded on both threads. +use super::*; +use crate::data::items::ItemTemplate; +use crate::data::GameData; +use crate::models::character::Inventory; +use crate::models::doodad::{doodad_owner_type, Doodad}; +use crate::systems::economy::bridges::EconomyForNpcs; +use crate::systems::economy::craft_data::{Craft, CraftProduct}; +use crate::systems::npcs::doodad::spawner::{NpcSpawnerDef, SpawnerBase}; +use crate::systems::npcs::doodad::templates::DoodadTemplate; +use crate::systems::npcs::npc::data::NpcTemplate; +use crate::systems::npcs::npc::spawner_data::{NpcSpawnerData, NpcSpawnerNpc, NpcSpawnerTemplate}; +use crate::systems::npcs::spawn_manager; +use crate::systems::quests::{ + self, events, + model::kind, + templates::{ActKind, QuestComponentTemplate, QuestTemplate}, +}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::Entity; +use std::sync::mpsc; +use std::time::Duration; + +struct CraftQuest(mpsc::SyncSender<()>); +impl CraftHooks for CraftQuest { + fn on_craft(&self, server: &GameServer, player: &PlayerRef, craft_id: u32) { + assert!(!crate::systems::economy::System::ops_held_on_this_thread()); + self.0.send(()).unwrap(); + // The timer has reached the real outer gate. With reversed ordering it would + // already own spawn_lock here and the following quest callback would deadlock. + server.systems.economy.wait_until_operation_blocked(); + events::on_craft(server, player, craft_id); + // Run the queued component while this callback still owns the outer item + // scope, so the actual quest-driven spawn contends with expired cleanup. + server.systems.quests.run_queued_evaluations(server); + } +} + +#[tokio::test] +async fn expired_source_item_doodad_contends_with_craft_quest_npc_spawn() { + const SOURCE: u32 = 4001; + const PRODUCT: u32 = 4002; + let mut data = GameData::empty(); + for id in [SOURCE, PRODUCT] { + data.items.templates.insert(id, ItemTemplate::plain(id, 1)); + } + data.systems.economy.craft.crafts.insert( + 1, + Craft { + id: 1, + craft_products: vec![CraftProduct { + craft_id: 1, + item_id: PRODUCT, + amount: 1, + ..Default::default() + }], + ..Default::default() + }, + ); + let q = &mut data.systems.quests; + q.add_template(QuestTemplate { + id: 1, + ..Default::default() + }); + for (id, step, spawner) in [ + (10, kind::START, 0), + (11, kind::PROGRESS, 10), + (12, kind::READY, 0), + ] { + q.add_component(QuestComponentTemplate { + id, + quest_id: 1, + kind_id: step, + npc_spawner_id: spawner, + ..Default::default() + }); + } + q.add_act( + 11, + 11, + 11, + 1, + ActKind::ObjCraft { + craft_id: 1, + use_alias: false, + alias_id: 0, + highlight_doodad_id: 0, + highlight_doodad_phase: -1, + }, + ); + q.add_act( + 12, + 12, + 12, + 0, + ActKind::ConReportNpc { + npc_id: 500, + use_alias: false, + alias_id: 0, + }, + ); + q.finish(); + data.systems.npcs.npc.templates.insert( + 500, + NpcTemplate { + id: 500, + ..Default::default() + }, + ); + data.systems.npcs.npc_spawners = NpcSpawnerData::from_parts( + vec![NpcSpawnerTemplate { + id: 10, + max_population: 1, + ..Default::default() + }], + vec![NpcSpawnerNpc { + id: 100, + npc_spawner_template_id: 10, + member_id: 500, + member_type: "Npc".into(), + weight: 1.0, + unit_id: 0, + }], + ) + .unwrap(); + data.systems.npcs.doodad.templates.insert( + 7000, + DoodadTemplate { + id: 7000, + ..Default::default() + }, + ); + let server = Arc::new(test_server_with(data)); + server.set_self(); + quests::install_hooks(&server); + server + .systems + .npcs + .hooks + .economy + .install(Arc::new(EconomyForNpcs)); + let client = TestClient::new(&server, 1, 1001); + let mut character = test_character(1, "Crafter", 100.0, 100.0); + character.inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); + let player_obj_id = server.ids.object.get_next_id().unwrap(); + let player = spawn_player(&server, &client, character, player_obj_id); + let world = server.world.world(0).unwrap(); + let manager = server.systems.npcs.spawns.get_or_create(&world); + let mut base = SpawnerBase { + unit_id: 500, + ..Default::default() + }; + base.position.x = 101.0; + base.position.y = 100.0; + base.position.z = 100.0; + manager + .add_npc_spawner( + &server, + NpcSpawnerDef { + base, + count: 1, + npc_spawner_ids: vec![10], + }, + ) + .unwrap(); + assert_eq!(manager.get_npc_spawner(10).len(), 1); + events::add_quest(&server, &player, 1, false); + server.systems.quests.run_queued_evaluations(&server); + assert_eq!(player.data().quests.active[0].step, kind::PROGRESS); + assert!(world.all_npcs().is_empty()); + let source = server + .items + .create( + SOURCE, + 1, + 0, + 1, + &server.game_data.items, + &server.ids.item, + 0, + ) + .unwrap(); + let source_id = source.id; + Inv::of(&player) + .get(slot_type::SYSTEM) + .unwrap() + .lock() + .unwrap() + .add_new_item(source, -1, &server.game_data.items) + .unwrap(); + let mut doodad = Doodad::new(7000); + doodad.owner_type = doodad_owner_type::CHARACTER; + doodad.owner_id = 1; + doodad.item_id = source_id; + doodad.item_template_id = SOURCE; + let doodad = Entity::new(server.ids.object.get_next_id().unwrap(), doodad); + world.spawn(&doodad, &server.view_ctx()); + assert_ne!(doodad.obj_id, player.obj_id); + assert!(world + .doodad(doodad.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, &doodad))); + manager.add_player_doodad(doodad.clone()); + manager.add_despawn( + &server, + WorldObject::from(&doodad), + Some(spawn_manager::now()), + ); + server.systems.economy.craft.update(1, |state| { + state.current_craft = Some(1); + state.count = 1; + }); + let (start, ready) = mpsc::sync_channel(1); + server + .systems + .economy + .craft + .hooks + .install(Arc::new(CraftQuest(start))); + let (tick_done, tick_result) = mpsc::channel(); + let (craft_done, craft_result) = mpsc::channel(); + let runtime = tokio::runtime::Handle::current(); + let (tick_server, tick_runtime) = (server.clone(), runtime.clone()); + let tick_manager = manager.clone(); + let tick = std::thread::spawn(move || { + let _runtime = tick_runtime.enter(); + ready.recv_timeout(Duration::from_secs(5)).unwrap(); + tick_manager.check_respawns_tick(&tick_server); + tick_done.send(()).unwrap(); + }); + let (craft_server, crafter) = (server.clone(), player.clone()); + let craft = std::thread::spawn(move || { + let _runtime = runtime.enter(); + end_craft(&craft_server, &crafter); + craft_done.send(()).unwrap(); + }); + craft_result + .recv_timeout(Duration::from_secs(5)) + .expect("craft/quest/spawn cycle must finish"); + tick_result + .recv_timeout(Duration::from_secs(5)) + .expect("expired source cleanup must finish"); + craft.join().unwrap(); + tick.join().unwrap(); + assert_eq!( + Inv::of(&player).items_count_in(slot_type::INVENTORY, PRODUCT, -1), + 1 + ); + assert_eq!(player.data().quests.active[0].step, kind::READY); + assert_eq!(player.data().quests.active[0].objectives[0], 1); + let npcs = world.all_npcs(); + assert_eq!(npcs.len(), 1); + assert_eq!(npcs[0].data().unit.template_id, 500); + assert!(world.doodad(doodad.obj_id).is_none()); + assert!(world.object(doodad.obj_id).is_none()); + assert!(doodad.data().phase.deleted); + assert!(!manager + .get_all_player_doodads() + .iter() + .any(|live| Arc::ptr_eq(live, &doodad))); + assert!(!manager.has_pending_timers(doodad.obj_id)); + assert!(world + .object(player.obj_id) + .is_some_and(|live| live.same(&WorldObject::from(&player)))); + assert!(server.items.item_by_id(source_id).is_none()); + assert!(server.items.removed_items().contains(&source_id)); +} diff --git a/rust/crates/aaemu-game/src/systems/economy/craft_store_tests.rs b/rust/crates/aaemu-game/src/systems/economy/craft_store_tests.rs index 2b384955c4..03f39fc94c 100644 --- a/rust/crates/aaemu-game/src/systems/economy/craft_store_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/craft_store_tests.rs @@ -16,7 +16,9 @@ use crate::opcodes::sc; use crate::packets::world::SCErrorMsgPacket; use crate::server::GameServer; use crate::systems::economy::craft::{self, CSExecuteCraft, CraftHooks, SCCraftFailedPacket}; -use crate::systems::economy::craft_data::{Craft, CraftMaterial, CraftProduct, CraftSkill}; +use crate::systems::economy::craft_data::{ + Craft, CraftData, CraftMaterial, CraftProduct, CraftSkill, +}; use crate::systems::economy::hooks::{NpcEconomyHooks, NpcShopInfo}; use crate::systems::economy::inventory::Inv; use crate::systems::economy::item_packets::{ @@ -570,6 +572,123 @@ fn execute_craft(w: &mut World, craft_id: u32, count: i32) { run::(w, 0, s.as_bytes()); } +fn load_craft_sql(rows: &str) -> CraftData { + let conn = rusqlite::Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE crafts (id, cast_delay, tool_id, skill_id, wi_id, milestone_id, + req_doodad_id, need_bind, ac_id, actability_limit, show_upper_crafts, + recommend_level, visible_order); + INSERT INTO crafts VALUES (1, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0); + CREATE TABLE craft_products (id, craft_id, item_id, amount, rate, + show_lower_crafts, use_grade, item_grade_id); + CREATE TABLE craft_materials (id, craft_id, item_id, amount, main_grade); + CREATE TABLE craft_pack_crafts (craft_id); + CREATE TABLE skills (id, consume_lp, actability_group_id, cooldown_time); + INSERT INTO skills VALUES (10, 5, 0, 0);", + ) + .unwrap(); + conn.execute_batch(rows).unwrap(); + let files = + crate::data::client_files::ClientFileManager::from_sources(&[], std::path::Path::new(".")); + CraftData::load(&crate::systems::DataLoadCtx { + conn: &conn, + app_path: std::path::Path::new("."), + files: &files, + language: "en_us", + }) + .unwrap() +} + +#[test] +fn craft_grade_flags_load_sqlite_text() { + // Native 1.2 LoadCraftProductDescs / LoadCraftMaterialDescs (0x3982E6C0 / 0x3982E4D0) + // read the text flags, not sqlite3_column_int('t') == 0. + let d = load_craft_sql( + "INSERT INTO craft_products VALUES + (1, 1, 5000, 1, 100, 'f', 't', 3), + (2, 1, 5000, 1, 100, 'f', 'f', 0), + (3, 1, 5000, 1, 100, 'f', 1, 2), + (4, 1, 5000, 1, 100, 'f', 0, 0), + (5, 1, 5000, 1, 100, 'f', NULL, 0); + INSERT INTO craft_materials VALUES + (1, 1, 1000, 1, 'f'), (2, 1, 7000, 1, 't'), + (3, 1, 1000, 1, 0), (4, 1, 7000, 1, 1), (5, 1, 1000, 1, NULL);", + ); + let c = d.craft(CRAFT).unwrap(); + assert_eq!( + c.craft_products + .iter() + .map(|p| (p.use_grade, p.item_grade_id)) + .collect::>(), + vec![(true, 3), (false, 0), (true, 2), (false, 0), (false, 0)] + ); + assert_eq!( + c.craft_materials + .iter() + .map(|m| m.main_grade) + .collect::>(), + vec![false, true, false, true, false] + ); +} + +#[tokio::test] +async fn craft_loaded_grade_recipes_create_expected_inventory() { + for (use_grade, main_grade, material, product_grade, fixed_grade, gradable, expected) in [ + ("t", "f", STACK, 3, -1, true, 3), + ("f", "t", SWORD, 0, -1, true, 4), + // Keep the 1.2 equipment-material heuristic when the main_grade flag is unset. + ("f", "f", SWORD, 0, -1, true, 4), + ("t", "f", STACK, 3, 2, false, 2), + ("f", "f", STACK, 0, -1, true, 0), + ] { + let mut d = data(); + d.systems.economy.craft = load_craft_sql(&format!( + "INSERT INTO craft_products VALUES (1, 1, {PRODUCT}, 1, 100, 'f', '{use_grade}', {product_grade}); + INSERT INTO craft_materials VALUES (1, 1, {material}, 1, '{main_grade}');" + )); + let recipe = d.systems.economy.craft.craft(CRAFT).unwrap(); + assert_eq!(recipe.craft_products[0].use_grade, use_grade == "t"); + assert_eq!(recipe.craft_materials[0].main_grade, main_grade == "t"); + let t = d.items.templates.get_mut(&PRODUCT).unwrap(); + t.fixed_grade = fixed_grade; + t.gradable = gradable; + d.items.grades.insert( + 4, + crate::data::items::GradeTemplate { + grade: 4, + grade_order: 4, + durability: 1.0, + }, + ); + let mut w = world_with_data(d); + let rec = install_craft_hooks(&w); + let pa = w.pa.clone(); + pa.data().labor_power = 100; + let id = give(&w, &pa, slot_type::INVENTORY, material, 1, 0); + Inv::of(&pa) + .bag() + .lock() + .unwrap() + .get_item_by_id_mut(id) + .unwrap() + .grade = 4; + execute_craft(&mut w, CRAFT, 1); + assert_eq!(rec.casts.lock().unwrap().len(), 1); + craft::end_craft(&w.server, &pa); + let inv = Inv::of(&pa); + assert_eq!(inv.items_count(material, -1), 0); + let bag = inv.bag(); + let bag = bag.lock().unwrap(); + assert_eq!(bag.items.len(), 1); + let product = &bag.items[0]; + assert_eq!( + (product.template_id, product.count, product.grade), + (PRODUCT, 1, expected) + ); + assert_eq!(*rec.crafted.lock().unwrap(), vec![CRAFT]); + } +} + #[tokio::test] async fn craft_batch_consumes_materials_adds_products_and_reschedules() { let mut w = world(); @@ -878,8 +997,8 @@ impl NpcEconomyHooks for Shops { }) } - fn merchant_sells(&self, _server: &GameServer, pack_id: u32, item_id: u32) -> bool { - pack_id == 7 && item_id == STACK + fn merchant_sells(&self, _server: &GameServer, pack_id: u32, item_id: u32, grade: u8) -> bool { + pack_id == 7 && item_id == STACK && grade == 0 } } @@ -903,6 +1022,144 @@ fn buy_body(npc: u32, buy: &[(u32, i32, u8)], buy_back: &[i32]) -> Vec { s.into_bytes() } +fn catalog_world(mut d: GameData, stock: &[(u32, u8)]) -> World { + let mut goods = crate::systems::npcs::npc::data::MerchantGoods { + id: 7, + items: Vec::new(), + }; + for &(item, grade) in stock { + goods.add_item_to_stock(item, grade); + } + d.systems.npcs.npc.goods.insert(7, goods); + d.systems.npcs.npc.templates.insert( + 1234, + crate::systems::npcs::npc::data::NpcTemplate { + id: 1234, + merchant: true, + merchant_pack_id: 7, + ..Default::default() + }, + ); + let mut w = world_with_data(d); + // Use the real NPC catalog bridge, including its native fixed-grade normalization. + crate::systems::npcs::bridges::install_economy(&w.server); + spawn_npc(&mut w, MERCHANT_NPC, 1234, 101.0); + w +} + +async fn buy_grade(w: &mut World, item_id: u32, grade: u8, count: i32, currency: u8) { + use crate::net::registry::ClientPacket; + CSBuyItemsPacket { + npc_obj_id: MERCHANT_NPC, + doodad_obj_id: 0, + unk_id: 0, + buy: vec![BuyEntry { + item_id, + grade, + count, + currency, + }], + buy_back: Vec::new(), + use_aa_point: false, + } + .handle(&w.server, &mut w.a.conn) + .await + .unwrap(); +} + +#[tokio::test] +async fn shop_catalog_grades_create_distinct_paid_inventory() { + let mut d = data(); + d.items.templates.get_mut(&STACK).unwrap().gradable = true; + let sword = d.items.templates.get_mut(&SWORD).unwrap(); + sword.gradable = true; + sword.fixed_grade = -1; + sword.honor_price = 9; + let mut w = catalog_world(d, &[(STACK, 0), (STACK, 4), (STACK, 11), (SWORD, 4)]); + w.pa.data().money = 1000; + w.pa.data().honor_point = 100; + give(&w, &w.pa, slot_type::INVENTORY, STACK, 5, 0); + buy_grade(&mut w, STACK, 4, 2, shop_currency_type::MONEY).await; + buy_grade(&mut w, STACK, 11, 1, shop_currency_type::MONEY).await; + buy_grade(&mut w, SWORD, 4, 1, shop_currency_type::HONOR).await; + buy_grade(&mut w, STACK, 0, 1, shop_currency_type::MONEY).await; + let inv = Inv::of(&w.pa); + assert_eq!(inv.items_count(STACK, 0), 6); + assert_eq!(inv.items_count(STACK, 4), 2); + assert_eq!(inv.items_count(STACK, 11), 1); + assert_eq!(inv.items_count(SWORD, 4), 1); + let c = w.pa.data(); + assert_eq!((c.money, c.honor_point, c.vocation_point), (960, 91, 0)); +} + +#[tokio::test] +async fn shop_catalog_grades_reject_unlisted_grade_without_charge() { + for currency in [shop_currency_type::MONEY, shop_currency_type::HONOR] { + for grade in [0, 11] { + let mut d = data(); + d.items.templates.get_mut(&STACK).unwrap().gradable = true; + let mut w = catalog_world(d, &[(STACK, 4)]); + w.pa.data().money = 1000; + w.pa.data().honor_point = 100; + buy_grade(&mut w, STACK, grade, 1, currency).await; + assert!(Inv::of(&w.pa).bag().lock().unwrap().items.is_empty()); + let c = w.pa.data(); + assert_eq!((c.money, c.honor_point), (1000, 100)); + } + } +} + +#[tokio::test] +async fn shop_catalog_grades_respect_fixed_and_basic_templates() { + // Stock grade zero is basic for gradable gear; it is not "any grade" or "use default". + // Fixed grades are sent after normalization by native 1.2 sub_397CD260. + for (stock, fixed, gradable, requested, accepted) in [ + (0, -1, true, 0, true), + (0, -1, true, 11, false), + (0, 2, false, 2, true), + (0, 2, false, 0, false), + (4, 2, false, 2, true), + (4, 2, false, 4, false), + (0, 2, true, 2, true), + (0, 2, true, 0, false), + (4, -1, false, 0, true), + (4, -1, false, 4, false), + ] { + let mut d = data(); + let t = d.items.templates.get_mut(&STACK).unwrap(); + t.fixed_grade = fixed; + t.gradable = gradable; + let mut w = catalog_world(d, &[(STACK, stock)]); + w.pa.data().money = 100; + buy_grade(&mut w, STACK, requested, 1, shop_currency_type::MONEY).await; + assert_eq!(Inv::of(&w.pa).items_count(STACK, -1), i32::from(accepted)); + assert_eq!(w.pa.data().money, if accepted { 90 } else { 100 }); + if accepted { + assert_eq!( + item_at(&w.pa, slot_type::INVENTORY, 0).unwrap().grade, + requested + ); + } + } +} + +#[tokio::test] +async fn shop_catalog_grades_full_bag_rolls_back() { + let mut d = data(); + d.items.templates.get_mut(&STACK).unwrap().gradable = true; + let mut w = catalog_world(d, &[(STACK, 0), (STACK, 4)]); + w.pa.data().honor_point = 100; + let bag = Inv::of(&w.pa).bag(); + bag.lock().unwrap().set_container_size(1); + give(&w, &w.pa, slot_type::INVENTORY, STACK, 5, 0); + let before = bag.lock().unwrap().items.clone(); + // A partial basic stack cannot take a higher-grade purchase. + buy_grade(&mut w, STACK, 4, 1, shop_currency_type::HONOR).await; + assert_eq!(bag.lock().unwrap().items, before); + assert_eq!(w.pa.data().honor_point, 100); + assert!(w.a.drain().is_empty()); +} + #[tokio::test] async fn shop_checkout_rejects_money_only_and_mixed_currency_shortages() { for (money, honor, vocation, purchases) in [ @@ -1661,6 +1918,24 @@ fn real_compact_db_craft_and_store_tables() { assert_eq!(products, 6938 - 10); assert_eq!(materials, 23475 - 54); assert_eq!(craft.crafts.values().filter(|c| c.is_pack).count(), 2153); + assert_eq!( + craft + .crafts + .values() + .flat_map(|c| &c.craft_products) + .filter(|p| p.use_grade) + .count(), + 356 + ); + assert_eq!( + craft + .crafts + .values() + .flat_map(|c| &c.craft_materials) + .filter(|m| m.main_grade) + .count(), + 101 + ); // The 't'/'f' columns read through GetBoolean(column) are all false. assert!(craft .crafts diff --git a/rust/crates/aaemu-game/src/systems/economy/econ_data_tests.rs b/rust/crates/aaemu-game/src/systems/economy/econ_data_tests.rs index e82a2aebef..cd3df90e05 100644 --- a/rust/crates/aaemu-game/src/systems/economy/econ_data_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/econ_data_tests.rs @@ -383,16 +383,14 @@ async fn taking_loot_from_far_away_is_refused() { .write_u16(0) .write_u16(0); run::(&mut w, 0, s.as_bytes()); - let refused = SCLootItemFailedPacket { - error_message: super::error_message::TOO_FAR_AWAY, - loot_owner_type: 1, - loot_owner_obj_id: NPC_OBJ, - item_index: 1, - item_template_id: super::tests::STACK, - }; + // Native 1.2 reader 397C2F00: i16 error, u64 lootable, u32 item template. + // TOO_FAR_AWAY=154, index=1, NPC=1/0x200, STACK=1000; exactly 14 bytes. assert_eq!( w.a.drain(), - vec![(sc::SCLootItemFailedPacket, body(&refused))], + vec![( + sc::SCLootItemFailedPacket, + vec![0x9a, 0, 1, 0, 1, 0, 0, 2, 0, 0, 0xe8, 3, 0, 0] + )], "the out-of-range take must be refused with TOO_FAR_AWAY" ); assert_eq!( @@ -461,16 +459,13 @@ async fn full_bag_fails_and_restores_the_entry() { assert!(!LootManager::try_take_loot( &w.server, &w.pa, NPC_OBJ, 1, false )); - let failed = SCLootItemFailedPacket { - error_message: super::error_message::BAG_FULL, - loot_owner_type: 1, - loot_owner_obj_id: NPC_OBJ, - item_index: 1, - item_template_id: super::tests::STACK, - }; + // Native 1.2 reader 397C2F00: BAG_FULL=25, then the same lootable and template. assert_eq!( w.a.drain(), - vec![(sc::SCLootItemFailedPacket, body(&failed))] + vec![( + sc::SCLootItemFailedPacket, + vec![25, 0, 1, 0, 1, 0, 0, 2, 0, 0, 0xe8, 3, 0, 0] + )] ); assert_eq!(w.server.systems.economy.loot.item_count(NPC_OBJ), 3); } diff --git a/rust/crates/aaemu-game/src/systems/economy/fishing/tests.rs b/rust/crates/aaemu-game/src/systems/economy/fishing/tests.rs index d10a111a4d..ddc6de1880 100644 --- a/rust/crates/aaemu-game/src/systems/economy/fishing/tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/fishing/tests.rs @@ -180,10 +180,7 @@ impl FishDamageFixture { #[tokio::test] async fn fish_creator_blocks_foreign_ordinary_siege_damage() { - use crate::systems::skills::packets::SCUnitDamagedPacket; - use crate::systems::skills::types::{CastAction, SkillCaster, SkillHitType}; use crate::systems::skills::{buffs, types::DamageType}; - use aaemu_commons::PacketStream; let mut f = FishDamageFixture::new(); let original = f.fish.data().unit.buffs.effects[0].clone(); assert_eq!(original.caster_obj_id, f.fish.obj_id); @@ -212,20 +209,12 @@ async fn fish_creator_blocks_foreign_ordinary_siege_damage() { assert_eq!(f.fish.data().unit.skill_state.aggro_table, aggro); assert_eq!(f.foreign.data().unit.summarize_damage, 0); assert_eq!(f.fish.data().unit.buffs.effects[0], original); - let mut immune = SCUnitDamagedPacket::new( - CastAction::Skill { - skill_id: 91000, - tl_id: 0, - }, - SkillCaster::Unit(f.foreign.obj_id), - f.foreign.obj_id, - f.fish.obj_id, - 1, - 0, - ); - immune.hit_type = SkillHitType::Immune; - let mut expected = PacketStream::new(); - expected.write(&immune); + // Native 1.2 damage reader 397C8760: skill 91000, unit caster 0x720, + // target 0x730, zero damage/healing, Immune flags. Immunity never reports 1 HP. + let expected = vec![ + 0, 120, 99, 1, 0, 0, 0, 0, 32, 7, 0, 32, 7, 0, 48, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 50, + 1, 1, 1, + ]; let frames = f.foreign_client.drain(); assert_eq!( frames @@ -240,7 +229,7 @@ async fn fish_creator_blocks_foreign_ordinary_siege_damage() { .find(|p| p.0 == sc::SCUnitDamagedPacket) .unwrap() .1, - expected.into_bytes(), + expected, ); // A valid fishing skill tag still cannot override a different creator. f.damage_with_skill(&foreign, 3, Some(21196)); diff --git a/rust/crates/aaemu-game/src/systems/economy/hooks.rs b/rust/crates/aaemu-game/src/systems/economy/hooks.rs index 58b629d074..322409caa9 100644 --- a/rust/crates/aaemu-game/src/systems/economy/hooks.rs +++ b/rust/crates/aaemu-game/src/systems/economy/hooks.rs @@ -99,8 +99,14 @@ pub trait NpcEconomyHooks: Send + Sync { None } - /// `NpcManager.GetGoods(packId)?.SellsItem(itemId)`. - fn merchant_sells(&self, _server: &GameServer, _pack_id: u32, _item_id: u32) -> bool { + /// Whether the catalog offers this item at the grade sent by the 1.2 client. + fn merchant_sells( + &self, + _server: &GameServer, + _pack_id: u32, + _item_id: u32, + _grade: u8, + ) -> bool { false } diff --git a/rust/crates/aaemu-game/src/systems/economy/inventory.rs b/rust/crates/aaemu-game/src/systems/economy/inventory.rs index 01d8d84612..08204c9508 100644 --- a/rust/crates/aaemu-game/src/systems/economy/inventory.rs +++ b/rust/crates/aaemu-game/src/systems/economy/inventory.rs @@ -77,6 +77,10 @@ impl<'a> ItemTxn<'a> { /// lock (the quest "locked hooks"): starting a normal transaction there could deadlock with /// an operation that holds the lock and waits for that character. Hand the effects to /// [`ItemTxn::into_fx`] and flush them once the character lock is released. + /// This path deliberately bypasses both the ops mutex and the outer publication scope. + /// It is not protected against concurrent world publication; callers must keep its quest + /// mutations confined to their already-locked character and must never acquire the outer + /// scope while holding that character lock. pub fn unlocked(server: &'a GameServer) -> Self { Self { server, @@ -1732,6 +1736,29 @@ pub fn actability_time_multiplier(step: u8) -> f32 { T[usize::from(step).min(T.len() - 1)] } +/// Validate item-cast location before costs, placement, summoning or item consumption. +pub(crate) fn item_use_zone_allowed( + server: &GameServer, + player: &PlayerRef, + template_id: u32, +) -> bool { + let banned = + crate::systems::skills::data::zone_rules::current_group(server, &WorldObject::from(player)) + .is_some_and(|group| { + server + .game_data + .systems + .skills + .zone_rules + .bans_item(group, template_id) + }); + if banned { + // Native 1.2 x2game12.c:1163648: ErrorMessage 440 = item_cannot_use_here. + send_error_message(player, error_message::ITEM_CANNOT_USE_HERE, 0, true); + } + !banned +} + /// `Character.ItemUse(item)` (`Events.OnItemUse` -> quests). pub fn item_use(server: &GameServer, player: &PlayerRef, template_id: u32) { if template_id == 0 { diff --git a/rust/crates/aaemu-game/src/systems/economy/loot_packets.rs b/rust/crates/aaemu-game/src/systems/economy/loot_packets.rs index 3a2f619caa..6fa6be33e9 100644 --- a/rust/crates/aaemu-game/src/systems/economy/loot_packets.rs +++ b/rust/crates/aaemu-game/src/systems/economy/loot_packets.rs @@ -120,7 +120,7 @@ impl Marshal for SCLootItemTookPacket { /// itemTemplateId)`. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct SCLootItemFailedPacket { - /// `ErrorMessageType` (written as an `int`). + /// Native 1.2 `ErrorMessage` is i16 (reader 397C2F00), unlike the C# int. pub error_message: i16, pub loot_owner_type: u16, pub loot_owner_obj_id: u32, @@ -134,7 +134,7 @@ packet_def!( ); impl Marshal for SCLootItemFailedPacket { fn write(&self, s: &mut PacketStream) { - s.write_i32(i32::from(self.error_message)) + s.write_i16(self.error_message) .write_u16(self.item_index) .write_u16(self.loot_owner_type) .write_bc(self.loot_owner_obj_id) @@ -298,7 +298,7 @@ mod tests { } #[test] - fn took_failed_state_packets_are_byte_exact() { + fn took_and_state_packets_are_byte_exact() { let took = SCLootItemTookPacket { item_template_id: 0x0102_0304, item_index: 2, @@ -310,17 +310,6 @@ mod tests { body(&took), vec![4, 3, 2, 1, 2, 0, 1, 0, 0xef, 0xcd, 0xab, 0, 5, 0, 0, 0] ); - let failed = SCLootItemFailedPacket { - error_message: 25, - loot_owner_type: 1, - loot_owner_obj_id: 0x10, - item_index: 3, - item_template_id: 9, - }; - assert_eq!( - body(&failed), - vec![25, 0, 0, 0, 3, 0, 1, 0, 0x10, 0, 0, 0, 9, 0, 0, 0] - ); let st = SCLootableStatePacket { loot_owner_type: 1, loot_owner_obj_id: 0x020304, @@ -334,6 +323,37 @@ mod tests { assert_eq!(body(&ls), vec![7, 0, 0, 2]); } + #[test] + fn loot_item_failed_matches_native_1_2_i16_error_and_14_byte_body() { + // Native 1.2 x2game12.c, reader 397C2F00 (SC 0xfa): ErrorMessage:i16, + // lootable:u64 (index:u16, owner:u16, object:bc, padding:u8), type:u32. + // Distinct nonzero fields expose any shift; the negative error pins signed width. + for (error_message, expected) in [ + ( + 25, + [ + 0x19, 0, 0x34, 0x12, 0x78, 0x56, 0xde, 0xbc, 0x9a, 0, 0x78, 0x56, 0x34, 0x12, + ], + ), + ( + -257, + [ + 0xff, 0xfe, 0x34, 0x12, 0x78, 0x56, 0xde, 0xbc, 0x9a, 0, 0x78, 0x56, 0x34, 0x12, + ], + ), + ] { + let actual = body(&SCLootItemFailedPacket { + error_message, + item_index: 0x1234, + loot_owner_type: 0x5678, + loot_owner_obj_id: 0x009a_bcde, + item_template_id: 0x1234_5678, + }); + assert_eq!(actual.len(), 14); + assert_eq!(actual, expected); + } + } + #[test] fn dice_packets_are_byte_exact() { let i = item(); diff --git a/rust/crates/aaemu-game/src/systems/economy/mail.rs b/rust/crates/aaemu-game/src/systems/economy/mail.rs index bbdae782a7..d9e9d6e2ba 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail.rs @@ -22,9 +22,9 @@ use sqlx::Row; use crate::data::Feature; use crate::db::{dt, from_unix, int, unix}; use crate::models::char_data::CountUnreadMail; -use crate::models::container::{slot_type, ContainerRef}; +use crate::models::container::{expire_item, slot_type, ContainerRef, MIN_DATE_TIME}; use crate::models::item::{Item, UnixTime}; -use crate::models::item_task::{task_type, ItemFxList}; +use crate::models::item_task::{task_type, ItemFx, ItemFxList}; use crate::server::GameServer; use crate::systems::HookSlot; use crate::world::PlayerRef; @@ -153,7 +153,8 @@ pub const COST_EXPRESS_ATTACHMENT: i32 = 80; pub const COST_FREE_ATTACHMENT_COUNT: i32 = 1; /// `MailManager.NormalMailDelay` (30 minutes), in seconds. pub const NORMAL_MAIL_DELAY_SECS: i64 = 30 * 60; -/// `MailManager.MailExpireDelay` (14 days), in seconds (unused in C#). +/// Ordinary player mail retention (the formerly unused `MailManager.MailExpireDelay`). +/// Policy: 14 days from scheduled receipt, including a fresh period after a return. pub const MAIL_EXPIRE_DELAY_SECS: i64 = 14 * 24 * 3600; /// `AppConfiguration.Specialty.TradePackMailDelayInMinutes` default. pub const DEFAULT_TRADE_PACK_MAIL_DELAY_MINUTES: f64 = 480.0; @@ -295,6 +296,19 @@ impl BaseMail { && (self.mail_type == mail_type::NORMAL || self.mail_type == mail_type::EXPRESS) } + /// Only player mail belongs to this timer. System/quest rewards can also use NORMAL + /// but have sender id zero; tax, auction and commercial mail have separate owners. + fn is_expired_at(&self, time: UnixTime) -> bool { + self.header.sender_id > 0 + && self.header.receiver_id > 0 + && matches!( + self.mail_type, + mail_type::NORMAL | mail_type::EXPRESS | mail_type::REGISTERED + ) + && self.body.recv_date <= time + && time.saturating_sub(self.body.recv_date) >= MAIL_EXPIRE_DELAY_SECS + } + /// `MailHeader` as written on the wire. pub fn header_wire(&self) -> MailHeaderWire { MailHeaderWire { @@ -951,12 +965,15 @@ fn new_mail_id(server: &GameServer, st: &mut MailState) -> u32 { /// `DeleteMail(long id)` on a locked store. pub fn delete_mail_in(server: &GameServer, st: &mut MailState, id: i64) -> bool { + if st.all.remove(id).is_none() { + return false; + } if !st.deleted.contains(&id) { st.deleted.push(id); st.deletion_versions.insert(id, Arc::new(())); } server.ids.mail.release_id(id as u32); - st.all.remove(id).is_some() + true } /// `ExtractExtraForHouse(extra, out zoneGroupId, out houseId)` -> `(zoneGroupId, houseId)`. @@ -1207,10 +1224,20 @@ pub fn notify_new_mail_by_name_if_online( fx: &mut ItemFxList, m: &mut BaseMail, receiver_name: &str, +) -> bool { + notify_new_mail_at(server, fx, m, receiver_name, now()) +} + +fn notify_new_mail_at( + server: &GameServer, + fx: &mut ItemFxList, + m: &mut BaseMail, + receiver_name: &str, + time: UnixTime, ) -> bool { tracing::trace!("NotifyNewMailByNameIfOnline() - {receiver_name}"); // If unread and ready to deliver - if m.header.status != mail_status::READ && m.body.recv_date <= now() && !m.is_delivered { + if m.header.status != mail_status::READ && m.body.recv_date <= time && !m.is_delivered { if let Some(player) = server.world.character_by_name(receiver_name) { // TODO: Mia mail stuff let add_body = m.mail_type == mail_type::CHARGED; @@ -1270,9 +1297,10 @@ pub fn notify_delete_mail_by_name_if_online( /// `SCGotMailPacket` is sent for every unread mail; every unread mail gets `IsDelivered`. pub fn get_current_mail_list(txn: &mut ItemTxn<'_>, character_id: u32) -> Vec { let server = txn.server; + let now = now(); + expire_ordinary_mail_at(txn, now); // Try to grab the actual online Character object to send live updates let character = server.world.character_by_id(character_id); - let now = now(); let mut st = server.systems.economy.mail.state(); let ids: Vec = st .all @@ -1321,28 +1349,167 @@ pub fn get_current_mail_list_for(server: &GameServer, character_id: u32) -> Vec< /// `CheckAllMailTimings()` (the `MailDeliveryTask`). pub fn check_all_mail_timings(txn: &mut ItemTxn<'_>) { + check_all_mail_timings_at(txn, now()); +} + +/// The timer and deterministic lifecycle tests share the same operation and clock value. +pub fn check_all_mail_timings_at(txn: &mut ItemTxn<'_>, time: UnixTime) { tracing::trace!("CheckAllMailTimings"); + // Expire before delivery: logging in after the deadline must not first announce stale mail. + expire_ordinary_mail_at(txn, time); let server = txn.server; - let now = now(); let mut st = server.systems.economy.mail.state(); let undelivered: Vec = st .all .iter() - .filter(|(_, m)| m.body.recv_date <= now && !m.is_delivered) + .filter(|(_, m)| m.body.recv_date <= time && !m.is_delivered && !m.is_expired_at(time)) .map(|(k, _)| k) .collect(); let mut delivered = 0; for id in &undelivered { let m = st.all.get_mut(*id).expect("listed"); let name = m.receiver_name.clone(); - if notify_new_mail_by_name_if_online(server, &mut txn.env.fx, m, &name) { + if notify_new_mail_at(server, &mut txn.env.fx, m, &name, time) { delivered += 1; } } if delivered > 0 { tracing::debug!("{delivered}/{} mail(s) delivered", undelivered.len()); } - // TODO: Return expired mails back to owner if undelivered/unread +} + +fn expire_ordinary_mail_at(txn: &mut ItemTxn<'_>, time: UnixTime) { + let ids: Vec<_> = txn + .server + .systems + .economy + .mail + .state() + .all + .iter() + .filter(|(_, m)| m.is_expired_at(time)) + .map(|(id, _)| id) + .collect(); + for id in ids { + expire_mail_at(txn, id, time); + } +} + +/// is_delivered is reconstructed from dates on restart, while a newly selected +/// character's counters start at zero. Recount after removal/return instead of +/// decrementing a counter that might never have included this letter. +fn refresh_received_count( + server: &GameServer, + player: &PlayerRef, + time: UnixTime, +) -> CountUnreadMail { + let mut received = CountUnreadMail::default(); + { + let st = server.systems.economy.mail.state(); + for (_, m) in st.all.iter() { + if m.header.receiver_id == player.character_id + && m.is_delivered + && m.body.recv_date <= time + && m.header.status != mail_status::READ + { + received.update_received(m.mail_type, 1); + } + } + } + let mut c = player.data(); + c.unread_mail.received = received.received; + c.unread_mail.mia_received = received.mia_received; + c.unread_mail.commercial_received = received.commercial_received; + c.unread_mail +} + +/// Returns true when a requested ordinary mail has expired (also when a damaged escrow +/// needs repair). Packet operations must not claim/delete/return it between timer ticks. +/// All mutations use the caller's ItemTxn, like sends, takes and financial save snapshots. +pub(super) fn expire_mail_at(txn: &mut ItemTxn<'_>, id: i64, time: UnixTime) -> bool { + let server = txn.server; + let Some(mail) = server.systems.economy.mail.get_mail_by_id(id) else { + return false; + }; + if !mail.is_expired_at(time) { + return false; + } + if mail.can_return_mail() + && server + .names + .get_character_name(mail.header.sender_id) + .is_some() + { + // A failed relocation leaves the original letter intact for retry, never deletes + // escrow that was meant to be refunded, and never credits a wallet directly. + if !return_to_sender_at(txn, id, time) { + tracing::debug!( + mail_id = id, + "Expired mail return deferred: escrow needs repair" + ); + } + return true; + } + + // Read, registered, self-addressed, already returned, or sender deleted: terminal + // expiry. Only this receiver's mail escrow may be destroyed. A stale reference to + // an item already taken into a bag must never delete that item. + for &item_id in &mail.body.attachments { + let Some(mut item) = server.items.item_by_id(item_id) else { + continue; + }; + if item.owner_id != u64::from(mail.header.receiver_id) || item.slot_type != slot_type::MAIL + { + continue; + } + if let Some(container) = server.items.holding_container(item_id) { + // Mail escrow expiry is unconditional, like item expiry; CanDestroy (for an + // active summon item) must not orphan an attachment when the letter disappears. + container + .lock() + .expect("container poisoned") + .remove_item(item_id); + } else { + server.items.take_loose(item_id); + } + if item.expiration_online_minutes_left > 0.0 + || item.expiration_time > MIN_DATE_TIME + || item.unpack_time > MIN_DATE_TIME + { + txn.env + .fx + .push(expire_item(&mut item).with_owner(mail.header.receiver_id)); + } + txn.env.fx.push(ItemFx::ReleaseId(item_id)); + } + server.systems.economy.mail.delete_mail(server, id); + if let Some(receiver) = server.world.character_by_id(mail.header.receiver_id) { + let modified = mail.is_delivered && mail.header.status != mail_status::READ; + let count = refresh_received_count(server, &receiver, time); + txn.env.fx.send( + receiver.character_id, + SCMailDeletedPacket { + is_sent: false, + mail_id: id, + is_unread_mail_count_modified: modified, + count, + }, + ); + } + if mail.header.sender_id != mail.header.receiver_id { + if let Some(sender) = server.world.character_by_id(mail.header.sender_id) { + txn.env.fx.send( + sender.character_id, + SCMailDeletedPacket { + is_sent: true, + mail_id: id, + is_unread_mail_count_modified: false, + count: sender.data().unread_mail, + }, + ); + } + } + true } /// Schedules the `MailDeliveryTask` (30 s, then every 5 s). @@ -1398,6 +1565,7 @@ pub fn pay_housing_tax( mail_id: i64, auto_use_aa_point: bool, ) -> bool { + let _items = server.systems.economy.operation_scope(); let operation = server .systems .housing @@ -1658,6 +1826,10 @@ pub fn delete_house_mails(txn: &mut ItemTxn<'_>, house_id: u32) { /// Return the existing mail once, preserving its item IDs and attached money. pub fn return_to_sender(txn: &mut ItemTxn<'_>, mail_id: i64) -> bool { + return_to_sender_at(txn, mail_id, now()) +} + +fn return_to_sender_at(txn: &mut ItemTxn<'_>, mail_id: i64, time: UnixTime) -> bool { let server = txn.server; let mails = &server.systems.economy.mail; let Some(mail) = mails.get_mail_by_id(mail_id) else { @@ -1669,6 +1841,31 @@ pub fn return_to_sender(txn: &mut ItemTxn<'_>, mail_id: i64) -> bool { let Some(original_sender) = server.names.get_character_name(mail.header.sender_id) else { return false; }; + if mail.body.attachments.iter().any(|id| { + server.items.item_by_id(*id).is_none_or(|item| { + item.owner_id != u64::from(mail.header.receiver_id) || item.slot_type != slot_type::MAIL + }) + }) { + return false; + } + let mut swapped = mail.clone(); + swapped.header.receiver_id = mail.header.sender_id; + swapped.receiver_name = original_sender.clone(); + swapped.is_dirty = true; + swapped.header.sender_id = mail.header.receiver_id; + swapped.header.sender_name = mail.receiver_name.clone(); + swapped.header.returned = true; + swapped.header.status = mail_status::UNREAD; + swapped.open_date = 0; + swapped.body.recv_date = time; + swapped.is_delivered = false; + swapped.header.attachments = swapped.get_total_attachment_count(); + // Move escrow before publishing the new owner or sending any success packet. The + // mail containers do not stack attachments. Failure keeps the original row retryable. + if !relocate_attachments(txn, &swapped) { + relocate_attachments(txn, &mail); + return false; + } if let Some(r) = server.world.character_by_id(mail.header.receiver_id) { txn.env.fx.send( r.character_id, @@ -1678,43 +1875,23 @@ pub fn return_to_sender(txn: &mut ItemTxn<'_>, mail_id: i64) -> bool { }, ); } - let swapped = mails.with_mail_mut(mail_id, |m| { - let original_receiver_id = m.header.receiver_id; - let original_receiver_name = m.receiver_name.clone(); - m.header.receiver_id = m.header.sender_id; - m.receiver_name = original_sender.clone(); - m.is_dirty = true; - m.header.sender_id = original_receiver_id; - m.header.sender_name = original_receiver_name; - m.header.returned = true; - m.header.status = mail_status::UNREAD; - m.open_date = 0; - m.body.recv_date = now(); - m.is_delivered = false; - // Send(): recount + renumber before MailManager.Send - m.header.attachments = m.get_total_attachment_count(); - m.clone() - }); - let Some(swapped) = swapped else { return false }; - renumber_slots(server, &swapped); - if !relocate_attachments(txn, &swapped) { - return false; - } + mails.with_mail_mut(mail_id, |m| *m = swapped); if mail.is_delivered && mail.header.status == mail_status::UNREAD { if let Some(receiver) = server.world.character_by_id(mail.header.receiver_id) { - receiver - .data() - .unread_mail - .update_received(mail.mail_type, -1); + refresh_received_count(server, &receiver, time); super::mail_character::send_unread_mail_count(&mut txn.env.fx, &receiver); } } mails.with_mail_mut(mail_id, |m| { - notify_new_mail_by_name_if_online(server, &mut txn.env.fx, m, &original_sender) + notify_new_mail_at(server, &mut txn.env.fx, m, &original_sender, time) }); true } +#[cfg(test)] +#[path = "mail_expiry_tests.rs"] +mod expiry_tests; + /// The money / item part `send_system_mail` callers commonly need: a ready-to-send system mail /// (sender id 0) to `receiver_id` with `copper` attached and already-created loose `items` /// (at most [`MAX_MAIL_ATTACHMENTS`]). Builds the same mail the C# callers build by hand diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_character.rs b/rust/crates/aaemu-game/src/systems/economy/mail_character.rs index 528a6e6513..7ea99b5f4f 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_character.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_character.rs @@ -69,8 +69,9 @@ pub fn open_mailbox(txn: &mut ItemTxn<'_>, player: &PlayerRef) { pub fn read_mail(txn: &mut ItemTxn<'_>, player: &PlayerRef, is_sent: bool, id: i64) { let server = txn.server; let mails = &server.systems.economy.mail; - let mut st = mails.state(); - let Some(m) = st.all.get_mut(id) else { return }; + let Some(m) = mails.get_mail_by_id(id) else { + return; + }; let owner = if is_sent { m.header.sender_id } else { @@ -79,6 +80,11 @@ pub fn read_mail(txn: &mut ItemTxn<'_>, player: &PlayerRef, is_sent: bool, id: i if owner != player.character_id { return; } + if mail::expire_mail_at(txn, id, mail::now()) { + return; + } + let mut st = mails.state(); + let Some(m) = st.all.get_mut(id) else { return }; if !is_sent && (!m.is_delivered || m.body.recv_date > mail::now()) { return; } @@ -258,6 +264,9 @@ pub fn get_attached( if this_mail.header.receiver_id != cid { return Ok(false); } + if mail::expire_mail_at(txn, mail_id, mail::now()) { + return Ok(false); + } if !this_mail.is_delivered || this_mail.body.recv_date > mail::now() { return Ok(false); } @@ -453,6 +462,18 @@ pub fn get_attached( /// `DeleteMail(id, isSent)`: only the receiver may delete received mail. pub fn delete_mail(txn: &mut ItemTxn<'_>, player: &PlayerRef, id: i64, is_sent: bool) { + if !is_sent + && txn + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .is_some_and(|m| m.header.receiver_id == player.character_id) + && mail::expire_mail_at(txn, id, mail::now()) + { + return; + } let server = txn.server; let mails = &server.systems.economy.mail; let mut st = mails.state(); @@ -488,10 +509,13 @@ pub fn return_mail(txn: &mut ItemTxn<'_>, player: &PlayerRef, id: i64) { let Some(this_mail) = server.systems.economy.mail.get_mail_by_id(id) else { return; }; - if this_mail.header.receiver_id != player.character_id - || !this_mail.is_delivered - || this_mail.body.recv_date > mail::now() - { + if this_mail.header.receiver_id != player.character_id { + return; + } + if mail::expire_mail_at(txn, id, mail::now()) { + return; + } + if !this_mail.is_delivered || this_mail.body.recv_date > mail::now() { return; } mail::return_to_sender(txn, id); diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs b/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs new file mode 100644 index 0000000000..96bfdc16de --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/mail_expiry_tests.rs @@ -0,0 +1,851 @@ +//! Ordinary-mail lifecycle regressions. No wall-clock sleeps, fake manager, or wire round trips. +//! Native 1.2 evidence: decomp/x2game12.c builders 393CCCD0 (money), 393CD1D0 +//! (delete), serializer 397BA450 (return), header/body at 1995740-42/1995902-09, +//! and ui/scripts/x2ui/mailbox/mail/read_mail.lua:129-139 +//! (receipt vs send date). No ordinary-mail expiry field/TTL is exposed there: the +//! 14-day receipt-time retention is an explicit server policy using the existing constant. + +use super::*; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::systems::economy::mail_character; +use crate::systems::economy::mail_packets::CSTakeAttachmentSequentially; +use crate::systems::economy::tests::{give, world, World, SINGLE}; + +fn mail_world() -> World { + let w = world(); + w.server.names.add_character(1, "Alice", 1001); + w.server.names.add_character(2, "Bob", 1002); + for p in [&w.pa, &w.pb] { + for (_, container) in Inv::of(p).containers { + w.server.items.add_container(container); + } + } + w +} + +fn send_player_mail(w: &World, kind: u8, count: i32, copper: i32) -> (i64, Vec) { + w.pa.data().money = 10_000; + let ids: Vec<_> = (0..count) + .map(|slot| give(w, &w.pa, slot_type::INVENTORY, SINGLE, 1, slot)) + .collect(); + let slots: Vec<_> = (0..count) + .map(|slot| (slot_type::INVENTORY, slot as u8)) + .collect(); + let mut txn = ItemTxn::begin(&w.server); + assert_eq!( + mail_character::send_mail_to_player( + &mut txn, &w.pa, kind, "Bob", "expiry", "original", 0, copper, 0, 0, 0, &slots, + ), + mail_result::SUCCESS + ); + let id = w.server.systems.economy.mail.state().all.keys()[0]; + (id, ids) +} + +fn tick(server: &GameServer, time: UnixTime) { + let mut txn = ItemTxn::begin(server); + check_all_mail_timings_at(&mut txn, time); +} + +fn frame(opcode: u16, id: i64) -> Vec { + let mut frame = vec![0xdd, 1, 0, 0]; + frame.extend_from_slice(&opcode.to_le_bytes()); + frame.extend_from_slice(&id.to_le_bytes()); + frame +} + +#[tokio::test] +async fn expiry_receipt_boundary_returns_zero_one_ten_attachments_once() { + for count in [0, 1, 10] { + for kind in [mail_type::NORMAL, mail_type::EXPRESS] { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, kind, count, 125); + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + let money = (w.pa.data().money, w.pb.data().money); + let due = original.body.recv_date + MAIL_EXPIRE_DELAY_SECS; + tick(&w.server, due - 1); + assert!( + !w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .returned + ); + if kind == mail_type::NORMAL { + assert!((NORMAL_MAIL_DELAY_SECS..=NORMAL_MAIL_DELAY_SECS + 2) + .contains(&(original.body.recv_date - original.body.send_date))); + } + w.a.drain(); + w.b.drain(); + tick(&w.server, due); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(returned.header.returned && returned.is_dirty && returned.is_delivered); + assert_eq!( + (returned.header.receiver_id, returned.header.sender_id), + (1, 2) + ); + assert_eq!(returned.body.recv_date, due); + assert_eq!(returned.body.send_date, original.body.send_date); + assert_eq!(returned.body.attachments, ids); + assert_eq!(returned.body.copper_coins, 125); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + assert_eq!( + ( + w.pa.data().unread_mail.received, + w.pb.data().unread_mail.received + ), + (1, 0) + ); + assert_eq!(w.a.drain_ops(), vec![sc::SCGotMailPacket]); + assert_eq!( + w.b.drain_ops(), + vec![sc::SCMailReturnedPacket, sc::SCCountUnreadMailPacket] + ); + for &item in &ids { + let item = w.server.items.item_by_id(item).unwrap(); + assert_eq!((item.owner_id, item.slot_type), (1, slot_type::MAIL)); + } + tick(&w.server, due); + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS - 1); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + returned + ); + assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); + + // A returned letter has one last retention period; it never bounces back. + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS); + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS + 1); + assert_eq!(w.server.systems.economy.mail.count(), 0); + assert_eq!(w.pa.data().unread_mail.received, 0); + assert_eq!(w.pb.data().unread_mail.received, 0); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + for item in ids { + assert!(w.server.items.item_by_id(item).is_none()); + assert!(w.server.items.holding_container(item).is_none()); + assert_eq!( + w.server + .items + .removed_items() + .iter() + .filter(|&&id| id == item) + .count(), + 1 + ); + } + assert_eq!(w.server.systems.economy.mail.state().deleted, vec![id]); + } + } +} + +#[tokio::test] +async fn expiry_read_registered_self_and_deleted_sender_are_terminal() { + for case in 0..4 { + let mut w = mail_world(); + let kind = if case == 1 { + mail_type::REGISTERED + } else { + mail_type::EXPRESS + }; + let (id, ids) = send_player_mail(&w, kind, 10, 50); + if case == 0 { + let mut txn = ItemTxn::begin(&w.server); + mail_character::read_mail(&mut txn, &w.pb, false, id); + } + if case == 1 { + // Reconnect resets counters before the reconstructed delivery flags. + w.pb.data().unread_mail.reset_received(); + } + w.server.systems.economy.mail.with_mail_mut(id, |m| { + if case == 2 { + m.header.sender_id = 2; + m.header.sender_name = "Bob".into(); + } + if case == 3 { + m.header.sender_id = 999; + } + }); + let money = (w.pa.data().money, w.pb.data().money); + let due = w + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .recv_date + + MAIL_EXPIRE_DELAY_SECS; + w.a.drain(); + w.b.drain(); + tick(&w.server, due); + tick(&w.server, due + 1); + assert!(w.server.systems.economy.mail.get_mail_by_id(id).is_none()); + assert_eq!(w.pb.data().unread_mail.received, 0); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + assert_eq!(w.b.drain_ops(), vec![sc::SCMailDeletedPacket]); + for id in ids { + assert!(w.server.items.item_by_id(id).is_none()); + } + } +} + +#[tokio::test] +async fn expiry_zero_receipt_and_clock_rollback_obey_the_same_boundary() { + let w = mail_world(); + let (id, _) = send_player_mail(&w, mail_type::EXPRESS, 0, 0); + w.server.systems.economy.mail.with_mail_mut(id, |m| { + m.body.send_date = 0; + m.body.recv_date = 0; + }); + for time in [-1, 0, MAIL_EXPIRE_DELAY_SECS - 1] { + tick(&w.server, time); + assert!( + !w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .returned + ); + } + tick(&w.server, MAIL_EXPIRE_DELAY_SECS); + assert!( + w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .returned + ); +} + +#[tokio::test] +async fn expiry_disposes_loose_escrow_but_preserves_a_stale_reference_to_taken_item() { + let w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 2, 50); + let container = mail_container(&w.pb).unwrap(); + let loose = container.lock().unwrap().remove_item(ids[0]).unwrap(); + w.server.items.add_loose(loose); + { + let mut txn = ItemTxn::begin(&w.server); + assert!(add_or_move_existing_item( + &mut txn, + &Inv::of(&w.pb).bag(), + task_type::INVALID, + ids[1], + -1 + )); + } + w.server + .systems + .economy + .mail + .with_mail_mut(id, |m| m.header.returned = true); + let released = Arc::new(Mutex::new(Vec::new())); + let item_releases = released.clone(); + w.server + .ids + .item + .install_release_hook(move |id| item_releases.lock().unwrap().push(id)); + let mail_released = Arc::new(Mutex::new(Vec::new())); + let mail_releases = mail_released.clone(); + w.server + .ids + .mail + .install_release_hook(move |id| mail_releases.lock().unwrap().push(id)); + let due = w + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .recv_date + + MAIL_EXPIRE_DELAY_SECS; + tick(&w.server, due); + tick(&w.server, due + 1); + assert!(w.server.items.item_by_id(ids[0]).is_none()); + assert!(w.server.items.holding_container(ids[0]).is_none()); + assert_eq!( + w.server.items.item_by_id(ids[1]).unwrap().slot_type, + slot_type::INVENTORY + ); + assert_eq!(*released.lock().unwrap(), vec![ids[0] as u32]); + assert_eq!(*mail_released.lock().unwrap(), vec![id as u32]); + assert_eq!(w.server.items.removed_items(), vec![ids[0]]); +} + +#[tokio::test] +async fn expiry_offline_return_reload_and_reconnect_do_not_repeat_refund() { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 1, 75); + w.server.systems.economy.mail.with_mail_mut(id, |m| { + m.body.recv_date = now() - MAIL_EXPIRE_DELAY_SECS - 10; + }); + w.server.world.world(0).unwrap().delete(&w.pa); + w.server.world.world(0).unwrap().delete(&w.pb); + assert!(w.server.world.try_remove_character(w.pa.obj_id)); + assert!(w.server.world.try_remove_character(w.pb.obj_id)); + assert!(w.server.world.character_by_id(1).is_none()); + assert!(w.server.world.character_by_id(2).is_none()); + let due = w + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .recv_date + + MAIL_EXPIRE_DELAY_SECS; + w.a.drain(); + w.b.drain(); + tick(&w.server, due); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(returned.header.returned && !returned.is_delivered); + assert_eq!(w.server.items.item_by_id(ids[0]).unwrap().owner_id, 1); + assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); + // Production row loader has no persisted is_delivered flag; returned + receipt date + // must alone prevent another refund after a restart. + let rows = vec![row(&returned)]; + w.server + .systems + .economy + .mail + .load_rows(&w.server, rows, due); + tick(&w.server, due); + assert_eq!(w.server.systems.economy.mail.count(), 1); + assert_eq!( + w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .receiver_id, + 1 + ); + w.pa.data().unread_mail.reset_received(); + assert!(w.server.world.try_add_character(&w.pa)); + w.server + .world + .world(0) + .unwrap() + .spawn(&w.pa, &w.server.view_ctx()); + { + let mut txn = ItemTxn::begin(&w.server); + assert_eq!(get_current_mail_list(&mut txn, 1), vec![id]); + } + assert_eq!(w.pa.data().unread_mail.received, 1); + let before = w.pa.data().money; + let mut txn = ItemTxn::begin(&w.server); + assert_eq!( + mail_character::get_attached(&mut txn, &w.pa, id, true, true, true, 0), + Ok(true) + ); + assert_eq!( + mail_character::get_attached(&mut txn, &w.pa, id, true, true, true, 0), + Ok(true) + ); + assert_eq!(w.pa.data().money, before + 75); + assert_eq!( + w.server.items.item_by_id(ids[0]).unwrap().slot_type, + slot_type::INVENTORY + ); +} + +#[tokio::test] +async fn expiry_packet_edges_enforce_current_owner_before_timer_and_return_auth() { + for opcode in [0x09eu16, 0x0a1, 0x0a3, 0x09c] { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 1, 25); + let past = now() - MAIL_EXPIRE_DELAY_SECS - 1; + w.server + .systems + .economy + .mail + .with_mail_mut(id, |m| m.body.recv_date = past); + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + let mut request = frame(opcode, id); + if opcode == 0x0a1 { + request.push(0); + } + if opcode == 0x09c { + request = vec![0xdd, 1, 0, 0, 0x9c, 0, 0]; + request.extend_from_slice(&id.to_le_bytes()); + } + // Sender may read their sent copy, but cannot operate the recipient's copy. + w.server + .handle_frame(&mut w.a.conn, &request) + .await + .unwrap(); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + original + ); + let money = (w.pa.data().money, w.pb.data().money); + w.server + .handle_frame(&mut w.b.conn, &request) + .await + .unwrap(); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(returned.header.returned); + assert_eq!(returned.header.receiver_id, 1); + assert_eq!(returned.body.copper_coins, 25); + assert_eq!(w.server.items.item_by_id(ids[0]).unwrap().owner_id, 1); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + // Replay by the former receiver cannot take or delete the returned escrow. + w.server + .handle_frame(&mut w.b.conn, &request) + .await + .unwrap(); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + returned + ); + } +} + +#[tokio::test] +async fn expiry_serializes_with_take_delete_and_send() { + for take_first in [false, true] { + let w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 1, 100); + let due = w + .server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .recv_date + + MAIL_EXPIRE_DELAY_SECS; + let sender_money = w.pa.data().money; + let receiver_money = w.pb.data().money; + // Force either lock acquisition order, then let a second tick, take, delete and + // send contend for the real economy lock on separate OS threads. + if take_first { + let mut txn = ItemTxn::begin(&w.server); + mail_character::get_attached(&mut txn, &w.pb, id, true, true, true, 0).unwrap(); + } else { + tick(&w.server, due); + } + let new_id = w.server.systems.economy.mail.get_new_mail_id(&w.server); + let server = w.server.clone(); + let receiver = w.pb.clone(); + crate::test_support::finishes_in_time("mail expiry/take/delete/send", move || { + let runtime = tokio::runtime::Handle::current(); + std::thread::scope(|scope| { + scope.spawn(|| { + let _runtime = runtime.enter(); + tick(&server, due); + }); + scope.spawn(|| { + let _runtime = runtime.enter(); + let mut txn = ItemTxn::begin(&server); + mail_character::get_attached(&mut txn, &receiver, id, true, true, true, 0) + .unwrap(); + mail_character::delete_mail(&mut txn, &receiver, id, false); + }); + scope.spawn(|| { + let _runtime = runtime.enter(); + let mut txn = ItemTxn::begin(&server); + let mut reward = BaseMail { + id: i64::from(new_id), + mail_type: mail_type::NORMAL, + receiver_name: "Bob".into(), + title: "reward".into(), + ..BaseMail::default() + }; + reward.header.receiver_id = 2; + reward.body.recv_date = now(); + assert_eq!(send_mail(&mut txn, reward), Some(i64::from(new_id))); + }); + }); + }); + let item = w.server.items.item_by_id(ids[0]).unwrap(); + if take_first { + assert_eq!((item.owner_id, item.slot_type), (2, slot_type::INVENTORY)); + assert_eq!(w.pb.data().money, receiver_money + 100); + assert!(w.server.systems.economy.mail.get_mail_by_id(id).is_none()); + } else { + assert_eq!((item.owner_id, item.slot_type), (1, slot_type::MAIL)); + assert_eq!(w.pb.data().money, receiver_money); + assert_eq!( + w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .body + .copper_coins, + 100 + ); + } + assert_eq!(w.pa.data().money, sender_money); + } +} + +#[tokio::test] +async fn expiry_preserves_system_tax_auction_quest_and_legacy_billing_metadata() { + let w = mail_world(); + let (id, _) = send_player_mail(&w, mail_type::EXPRESS, 0, 25); + // New P2P sending rejects money1/2. Historical demand/point fields are opaque: + // neither an expiry nor a return may convert these into copper. + w.server + .systems + .economy + .mail + .with_mail_mut(id, |m| m.attach_money(25, 5000, 7000)); + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + let due = original.body.recv_date + MAIL_EXPIRE_DELAY_SECS; + { + let mut txn = ItemTxn::begin(&w.server); + for kind in [ + mail_type::NORMAL, + mail_type::EXPRESS, + mail_type::BILLING, + mail_type::AUC_OFF_FAIL, + mail_type::AUC_OFF_SUCCESS, + mail_type::AUC_BID_WIN, + mail_type::SYS_EXPRESS, + mail_type::CHARGED, + mail_type::SYS_SELL_BACKPACK, + ] { + assert!(send_system_mail( + &mut txn, + kind, + "__QUEST__", + 2, + "owned elsewhere", + "", + 10, + vec![] + )); + } + } + let protected: Vec<_> = w + .server + .systems + .economy + .mail + .state() + .all + .iter() + .filter(|(key, _)| *key != id) + .map(|(_, m)| m.clone()) + .collect(); + let money = (w.pa.data().money, w.pb.data().money); + tick(&w.server, due); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert_eq!( + ( + returned.body.copper_coins, + returned.body.billing_amount, + returned.body.money_amount2 + ), + (25, 5000, 7000) + ); + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS); + assert_eq!((w.pa.data().money, w.pb.data().money), money); + for m in protected { + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(m.id).unwrap(), + m + ); + } +} + +#[tokio::test] +async fn expiry_failed_return_does_not_publish_owner_or_success_then_retries() { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 2, 100); + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + let item = w.server.items.item_by_id(ids[0]).unwrap(); + // A mismatched escrow must not steal an inventory item or announce a refund. + mutate_item(&w.server, ids[0], |i| i.slot_type = slot_type::INVENTORY); + w.a.drain(); + w.b.drain(); + let due = original.body.recv_date + MAIL_EXPIRE_DELAY_SECS; + tick(&w.server, due); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + original + ); + assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); + mutate_item(&w.server, ids[0], |i| *i = item); + let target = mail_container(&w.pa).unwrap(); + target.lock().unwrap().set_container_size(1); + // First attachment moves, second cannot fit. The original row and every item's + // ownership must survive rollback before a later retry can publish the return. + tick(&w.server, due); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + original + ); + for &item in &ids { + assert_eq!(w.server.items.item_by_id(item).unwrap().owner_id, 2); + } + assert!(w.a.drain().is_empty() && w.b.drain().is_empty()); + target.lock().unwrap().set_container_size(-1); + tick(&w.server, due); + assert_eq!( + w.server + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .header + .receiver_id, + 1 + ); +} + +fn row(m: &BaseMail) -> MailRow { + let mut attachment_ids = [0; MAX_MAIL_ATTACHMENTS]; + attachment_ids[..m.body.attachments.len()].copy_from_slice(&m.body.attachments); + MailRow { + id: m.id, + mail_type: i64::from(m.mail_type), + status: i64::from(m.header.status), + title: m.title.clone(), + text: m.body.text.clone(), + sender_id: i64::from(m.header.sender_id), + sender_name: m.header.sender_name.clone(), + attachment_count: i64::from(m.header.attachments), + receiver_id: i64::from(m.header.receiver_id), + receiver_name: m.receiver_name.clone(), + open_date: m.open_date, + send_date: m.body.send_date, + received_date: m.body.recv_date, + returned: i64::from(m.header.returned), + extra: m.header.extra, + money1: i64::from(m.body.copper_coins), + money2: i64::from(m.body.billing_amount), + money3: i64::from(m.body.money_amount2), + attachment_ids, + } +} + +#[tokio::test] +async fn expiry_old_save_ack_preserves_new_return_and_terminal_deletion() { + let w = mail_world(); + let (id, _) = send_player_mail(&w, mail_type::EXPRESS, 1, 50); + let mails = &w.server.systems.economy.mail; + let before = mails.prepare_save(); + let due = mails.get_mail_by_id(id).unwrap().body.recv_date + MAIL_EXPIRE_DELAY_SECS; + tick(&w.server, due); + mails.acknowledge_committed(before); + assert!(mails.get_mail_by_id(id).unwrap().is_dirty); + let returned = mails.prepare_save(); + assert_eq!(returned.dirty.len(), 1); + tick(&w.server, due + MAIL_EXPIRE_DELAY_SECS); + mails.acknowledge_committed(returned); + assert_eq!(mails.state().deleted, vec![id]); + assert!(mails.prepare_save().dirty.is_empty()); + let deletion = mails.prepare_save(); + mails.acknowledge_committed(deletion); + assert!(mails.state().deleted.is_empty()); +} + +#[tokio::test] +async fn expiry_sequential_packet_claims_returned_money_and_items_only_once() { + let mut w = mail_world(); + let (id, ids) = send_player_mail(&w, mail_type::EXPRESS, 10, 100); + // Return with a past (but unexpired) new receipt date so normal packet clocks apply. + let mut txn = ItemTxn::begin(&w.server); + assert!(return_to_sender_at(&mut txn, id, now() - 1)); + drop(txn); + let money = w.pa.data().money; + for _ in 0..2 { + CSTakeAttachmentSequentially { mail_id: id } + .handle(&w.server, &mut w.a.conn) + .await + .unwrap(); + tick(&w.server, now()); + } + assert_eq!(w.pa.data().money, money + 100); + for id in ids { + let item = w.server.items.item_by_id(id).unwrap(); + assert_eq!((item.owner_id, item.slot_type), (1, slot_type::INVENTORY)); + } +} + +#[tokio::test] +#[ignore = "private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary tables only"] +async fn private_mysql_expiry_return_rollback_retry_reload_and_disposal() { + use sqlx::mysql::{MySqlConnectOptions, MySqlPoolOptions}; + use std::str::FromStr; + + let url = std::env::var("AAEMU_TEST_MYSQL").expect("AAEMU_TEST_MYSQL"); + let options = MySqlConnectOptions::from_str(&url).unwrap(); + assert_eq!( + options.get_port(), + 3317, + "Only private MySQL3317 is allowed" + ); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .unwrap(); + for table in ["mails", "items", "item_containers"] { + let (_, ddl): (String, String) = sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + sqlx::query(&ddl.replacen("CREATE TABLE", "CREATE TEMPORARY TABLE", 1)) + .execute(&pool) + .await + .unwrap(); + } + fn server(pool: &sqlx::MySqlPool) -> Arc { + let mut server = + crate::test_support::test_server_with(crate::systems::economy::tests::test_data()); + server.db = pool.clone(); + let server = Arc::new(server); + server.set_self(); + server.names.add_character(1, "Alice", 1001); + server.names.add_character(2, "Bob", 1002); + server + } + async fn persist(server: &GameServer, pool: &sqlx::MySqlPool, commit: bool) { + let _save = server.save.transaction_lock().await; + let (mails, items) = { + let _economy = server.systems.economy.ops_lock(); + ( + server.systems.economy.mail.prepare_save(), + server.items.prepare_save(), + ) + }; + let mut tx = pool.begin().await.unwrap(); + server + .systems + .economy + .mail + .write_prepared(&mut tx, mails) + .await + .unwrap(); + server.items.write_prepared(&mut tx, items).await.unwrap(); + if commit { + tx.commit().await.unwrap(); + server.systems.economy.mail.commit_save(); + server.items.commit_save(); + } else { + tx.rollback().await.unwrap(); + } + } + let original = server(&pool); + let item = original + .items + .create( + SINGLE, + 1, + 0, + 1, + &original.game_data.items, + &original.ids.item, + now(), + ) + .unwrap(); + let item_id = item.id; + original.items.add_loose(item); + let due = now() - 1; + let id = { + let mut m = BaseMail { + mail_type: mail_type::EXPRESS, + receiver_name: "Bob".into(), + ..BaseMail::default() + }; + m.header.sender_id = 1; + m.header.sender_name = "Alice".into(); + m.header.receiver_id = 2; + m.body.recv_date = due - MAIL_EXPIRE_DELAY_SECS; + m.body.send_date = m.body.recv_date; + m.body.attachments.push(item_id); + m.attach_money(125, 0, 0); + let mut txn = ItemTxn::begin(&original); + send_mail(&mut txn, m).unwrap() + }; + persist(&original, &pool, true).await; + tick(&original, due); + persist(&original, &pool, false).await; + let receiver: i32 = sqlx::query_scalar("SELECT receiver_id FROM mails WHERE id=?") + .bind(id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(receiver, 2); + assert!( + original + .systems + .economy + .mail + .get_mail_by_id(id) + .unwrap() + .is_dirty + ); + persist(&original, &pool, true).await; + + let restarted = server(&pool); + restarted + .items + .load_user_items( + &pool, + &restarted.game_data.items, + 1, + &restarted.ids.container, + &restarted.ids.item, + ) + .await + .unwrap(); + restarted + .systems + .economy + .mail + .load(&restarted) + .await + .unwrap(); + let m = restarted.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(m.header.returned && !m.is_dirty); + assert_eq!( + (m.header.receiver_id, m.body.copper_coins, m.body.recv_date), + (1, 125, due) + ); + let item = restarted.items.item_by_id(item_id).unwrap(); + assert_eq!((item.owner_id, item.slot_type), (1, slot_type::MAIL)); + tick(&restarted, due); + assert_eq!( + restarted.systems.economy.mail.get_mail_by_id(id).unwrap(), + m + ); + + tick(&restarted, due + MAIL_EXPIRE_DELAY_SECS); + persist(&restarted, &pool, false).await; + assert_eq!(restarted.systems.economy.mail.state().deleted, vec![id]); + assert!(restarted.items.removed_items().contains(&item_id)); + persist(&restarted, &pool, true).await; + let remaining: i64 = + sqlx::query_scalar("SELECT (SELECT COUNT(*) FROM mails) + (SELECT COUNT(*) FROM items)") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(remaining, 0); + assert!(restarted.systems.economy.mail.state().deleted.is_empty()); + assert!(restarted.items.removed_items().is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_packets.rs b/rust/crates/aaemu-game/src/systems/economy/mail_packets.rs index 48bf5e2fca..3bbe920871 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_packets.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_packets.rs @@ -1,7 +1,7 @@ //! The mail packets. C->S: `CSSendMailPacket`, `CSListMailPacket`, `CSListMailContinuePacket`, //! `CSReadMailPacket`, `CSTakeAttachmentItemPacket`, `CSTakeAttachmentMoneyPacket`, //! `CSTakeAttachmentSequentially`, `CSTakeAllAttachmentItemPacket`, `CSPayChargeMoneyPacket`, -//! `CSDeleteMailPacket`, `CSReturnMailPacket` (0xfff in 1.2: never sent by the client). +//! `CSDeleteMailPacket`, `CSReturnMailPacket` (native 1.2 opcode 0x0a3). //! S->C: `SCMailFailedPacket`, `SCMailSentPacket`, `SCGotMailPacket`, `SCMailListPacket`, //! `SCMailListEndPacket`, `SCMailBodyPacket`, `SCMailReceiverOpenedPacket`, //! `SCAttachmentTakenPacket`, `SCChargeMoneyPaidPacket`, `SCMailDeletedPacket`, @@ -39,7 +39,10 @@ pub fn register(reg: &mut PacketRegistry) { reg.register::(LEVEL_PLAIN, cs::CSTakeAttachmentSequentially); reg.register::(LEVEL_PLAIN, cs::CSPayChargeMoneyPacket); reg.register::(LEVEL_PLAIN, cs::CSDeleteMailPacket); - reg.register::(LEVEL_PLAIN, cs::CSReturnMailPacket); + // Native 1.2 ReturnMailById (3948B630 -> 393CD290) sends 0xa3, historically + // mislabeled CSReportSpamPacket in the preserved C# opcode table. The 1.2 + // ReportSpam binding (3948B310) sends nothing; CSReturnMailPacket is 0xfff there. + reg.register::(LEVEL_PLAIN, cs::CSReportSpamPacket); reg.register::(LEVEL_PLAIN, cs::CSTakeAllAttachmentItemPacket); } @@ -719,7 +722,7 @@ impl CSDeleteMailPacket { } sync_client_packet!(CSDeleteMailPacket); -/// `CSReturnMailPacket` (opcode 0xfff: not in the 1.2 offsets). +/// Native 1.2 `ReturnMailById`: opcode 0xa3, mail id i64 (serializer 397BA450). #[derive(Debug, Clone, PartialEq, Eq)] pub struct CSReturnMailPacket { pub mail_id: i64, diff --git a/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs b/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs index e1c32f802c..e58bcf24da 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mail_tests.rs @@ -439,6 +439,20 @@ fn client_packets_decode() { let _: CSListMailContinuePacket = read(Vec::new()); } +#[test] +fn native_return_mail_request_decodes_i64() { + // Native 1.2 x2game12.c: ReturnMailById (3948B630) -> 393CD290, opcode 0xa3; + // serializer 397BA450 writes the mail id as a single i64 (archive slot +72). + let mut s = PacketStream::from_bytes(vec![8, 7, 6, 5, 4, 3, 2, 1]); + assert_eq!( + CSReturnMailPacket::read(&mut s).unwrap().mail_id, + 0x0102_0304_0506_0708 + ); + assert!(s.unread().is_empty()); + let mut truncated = PacketStream::from_bytes(vec![8, 7, 6, 5, 4, 3, 2]); + assert!(CSReturnMailPacket::read(&mut truncated).is_err()); +} + #[test] fn dotnet_dict_reuses_freed_slots_lifo() { let mut d = DotNetDict::default(); @@ -2020,6 +2034,7 @@ async fn send_rejects_name_mismatch_and_return_preserves_the_original_mail() { #[tokio::test] async fn load_rows_restore_mails() { let w = mail_world(); + let received = mail::now() - 1; let item = give(&w, &w.pa.clone(), slot_type::MAIL, STACK, 2, 0); let mut ids = [0u64; 10]; ids[0] = item; @@ -2036,8 +2051,8 @@ async fn load_rows_restore_mails() { attachment_count: 9, receiver_id: 2, receiver_name: "Bob".into(), - send_date: 10, - received_date: 20, + send_date: received - 10, + received_date: received, money1: 5, attachment_ids: ids, ..MailRow::default() @@ -2163,6 +2178,7 @@ async fn private_mysql_quest_mail_auction_rollback_retry_and_reconnect() { crate::data::character_templates::CharacterTemplate { race: 1, gender: 1, + creatable: true, ..Default::default() }, ); @@ -2549,3 +2565,82 @@ async fn return_preserves_zero_one_and_ten_attachments_without_charging_a_fee() } } } + +#[tokio::test] +async fn native_return_mail_frame_checks_recipient_and_returns_attachments() { + let mut w = mail_world(); + w.pa.data().money = 1000; + let item = give(&w, &w.pa, slot_type::INVENTORY, SINGLE, 1, 0); + assert_eq!( + send_p2p( + &w, + mail_type::EXPRESS, + "Bob", + 50, + &[(slot_type::INVENTORY, 0)], + ), + mail_result::SUCCESS + ); + let id = bob_mail_ids(&w.server)[0]; + let original = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert!(original.is_delivered && original.can_return_mail()); + let original_item = w.server.items.item_by_id(item).unwrap(); + let alice_money = w.pa.data().money; + let bob_money = w.pb.data().money; + assert_eq!(w.pb.data().unread_mail.received, 1); + w.a.drain(); + w.b.drain(); + + // The 1.2 UI's read_mail.lua:946 ReturnMailById -> native 393CD290 builds 0xa3, + // NOT the historical CSReturnMailPacket placeholder 0xfff. Keep the opcode literal + // and spell out the frame rather than using the server's registration/encoder. + let mut frame = vec![0xdd, 1, 0, 0, 0xa3, 0]; + frame.extend_from_slice(&id.to_le_bytes()); + + // The original sender knows the id, but only the current recipient may return it. + w.server.handle_frame(&mut w.a.conn, &frame).await.unwrap(); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + original + ); + assert_eq!(w.server.items.item_by_id(item).unwrap(), original_item); + assert!(w.a.drain().is_empty()); + assert!(w.b.drain().is_empty()); + assert_eq!(w.pb.data().unread_mail.received, 1); + + w.server.handle_frame(&mut w.b.conn, &frame).await.unwrap(); + let returned = w.server.systems.economy.mail.get_mail_by_id(id).unwrap(); + assert_eq!(w.server.systems.economy.mail.count(), 1); + assert_eq!(returned.header.receiver_id, 1); + assert_eq!(returned.receiver_name, "Alice"); + assert_eq!(returned.header.sender_id, 2); + assert_eq!(returned.header.sender_name, "Bob"); + assert!(returned.header.returned && returned.is_delivered); + assert_eq!(returned.body.attachments, vec![item]); + assert_eq!(returned.body.copper_coins, 50); + assert_eq!(returned.body.text, original.body.text); + let returned_item = w.server.items.item_by_id(item).unwrap(); + assert_eq!(returned_item.owner_id, 1); + assert_eq!(returned_item.slot_type, slot_type::MAIL); + assert_eq!(returned_item.template_id, original_item.template_id); + assert_eq!(w.pa.data().money, alice_money); + assert_eq!(w.pb.data().money, bob_money); + assert_eq!(w.pb.data().unread_mail.received, 0); + assert_eq!(w.pa.data().unread_mail.received, 1); + let replies = w.b.drain(); + assert_eq!( + ops(&replies), + vec![sc::SCMailReturnedPacket, sc::SCCountUnreadMailPacket] + ); + assert_eq!(&replies[0].1[..8], &id.to_le_bytes()); + assert_eq!(w.a.drain_ops(), vec![sc::SCGotMailPacket]); + + // Even the new recipient cannot return a letter that was already returned. + w.server.handle_frame(&mut w.a.conn, &frame).await.unwrap(); + assert_eq!( + w.server.systems.economy.mail.get_mail_by_id(id).unwrap(), + returned + ); + assert!(w.a.drain().is_empty()); + assert!(w.b.drain().is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/economy/mod.rs b/rust/crates/aaemu-game/src/systems/economy/mod.rs index d7615b6db2..cdb36af874 100644 --- a/rust/crates/aaemu-game/src/systems/economy/mod.rs +++ b/rust/crates/aaemu-game/src/systems/economy/mod.rs @@ -57,6 +57,9 @@ pub mod mail_packets; #[cfg(test)] mod mail_tests; pub mod mate_equipment; +mod operation_scope; +#[cfg(test)] +mod operation_scope_tests; #[cfg(test)] mod ported_unit_tests; pub mod repair; @@ -86,6 +89,8 @@ pub struct System { pub hooks: hooks::EconomyHooks, /// Serialises item operations (see [`inventory::ItemTxn`]). ops: Mutex<()>, + /// Callback-bearing synchronous publications exclude ordinary item operations here. + operation_scope: operation_scope::OperationScope, /// `Inventory.PreviousBackPackItemId` by character id (glider re-equip after a trade pack). previous_backpack: Mutex>, /// Account-wide attributes (`account_attributes`, auction posting authority, ...). @@ -118,22 +123,40 @@ thread_local! { } /// The held item-operation lock ([`System::ops_lock`]); tracks the holding thread. -pub struct OpsGuard<'a>(Option>); +pub struct OpsGuard<'a> { + guard: Option>, + _scope: operation_scope::OperationScopeGuard<'a>, +} impl Drop for OpsGuard<'_> { fn drop(&mut self) { - self.0.take(); + self.guard.take(); OPS_HELD.with(|held| held.set(held.get().saturating_sub(1))); } } impl System { + /// Acquire before world/publication locks and after all awaits. Callback ItemTxn scopes + /// may reenter this outer boundary; callbacks must still run outside the ops mutex. + pub(crate) fn operation_scope(&self) -> operation_scope::OperationScopeGuard<'_> { + self.operation_scope.enter() + } + /// The item-operation lock (outermost lock of every economy operation; never taken while a /// character or container lock is held). pub fn ops_lock(&self) -> OpsGuard<'_> { + let scope = self.operation_scope(); let guard = self.ops.lock().unwrap_or_else(|e| e.into_inner()); OPS_HELD.with(|held| held.set(held.get() + 1)); - OpsGuard(Some(guard)) + OpsGuard { + guard: Some(guard), + _scope: scope, + } + } + + #[cfg(test)] + pub(crate) fn wait_until_operation_blocked(&self) { + self.operation_scope.wait_until_blocked(); } /// Whether the current thread holds the item-operation lock. The lock is not re-entrant, so diff --git a/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs b/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs new file mode 100644 index 0000000000..02f8c0cb7d --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/operation_scope.rs @@ -0,0 +1,97 @@ +//! Synchronous operation boundary around callback-bearing world/item changes. The inner +//! economy ops mutex stays non-reentrant; only this outer scope permits same-thread entry. +//! +//! Acquire this scope before callback-bearing manager/publication locks. Financial capture +//! keeps its existing auction -> housing -> authority order inside the scope, followed by +//! ops -> object/container leaf locks (at most one object data guard). Mutation callbacks +//! run after ops/object guards drop and may then enter ItemTxn again on the same thread. +//! Snapshot-only manager locks which never wait for an item operation need no scope. +//! ItemTxn::unlocked remains guardless: callers under a character lock must not acquire +//! this scope to compensate. +//! Callback-bearing spawn chains enter scope -> spawn lock -> spawner/instance leaf locks +//! before item callbacks. The bare spawn lock stays available for pure bookkeeping; adding +//! an implicit scope there would invert callers which already hold character/object locks. + +use std::marker::PhantomData; +use std::rc::Rc; +use std::sync::{Condvar, Mutex}; +use std::thread::{self, ThreadId}; + +#[derive(Debug, Default)] +struct Owner { + thread: Option, + depth: usize, + #[cfg(test)] + waiters: usize, +} + +#[derive(Debug, Default)] +pub(super) struct OperationScope { + owner: Mutex, + available: Condvar, + #[cfg(test)] + waiting: Condvar, +} + +/// The Rc marker binds acquisition/release to one thread, without unsafe Send/Sync impls. +pub(crate) struct OperationScopeGuard<'a> { + scope: &'a OperationScope, + _thread_bound: PhantomData>, +} + +impl OperationScope { + pub(super) fn enter(&self) -> OperationScopeGuard<'_> { + let current = thread::current().id(); + let mut owner = self.owner.lock().unwrap_or_else(|e| e.into_inner()); + loop { + if owner.thread.is_none() || owner.thread == Some(current) { + owner.thread = Some(current); + owner.depth += 1; + return OperationScopeGuard { + scope: self, + _thread_bound: PhantomData, + }; + } + #[cfg(test)] + { + owner.waiters += 1; + self.waiting.notify_all(); + } + owner = self + .available + .wait(owner) + .unwrap_or_else(|e| e.into_inner()); + #[cfg(test)] + { + owner.waiters -= 1; + } + } + } + + #[cfg(test)] + pub(super) fn wait_until_blocked(&self) { + let owner = self.owner.lock().unwrap_or_else(|e| e.into_inner()); + let (owner, timeout) = self + .waiting + .wait_timeout_while(owner, std::time::Duration::from_secs(5), |owner| { + owner.waiters == 0 + }) + .unwrap_or_else(|e| e.into_inner()); + assert!( + !timeout.timed_out() && owner.waiters != 0, + "ordinary operation must reach the outer scope" + ); + } +} + +impl Drop for OperationScopeGuard<'_> { + fn drop(&mut self) { + let mut owner = self.scope.owner.lock().unwrap_or_else(|e| e.into_inner()); + debug_assert_eq!(owner.thread, Some(thread::current().id())); + owner.depth -= 1; + if owner.depth == 0 { + owner.thread = None; + self.scope.available.notify_one(); + } + } +} diff --git a/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs b/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs new file mode 100644 index 0000000000..35124d1a14 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/economy/operation_scope_tests.rs @@ -0,0 +1,365 @@ +use super::*; +use crate::data::items::ItemTemplate; +use crate::data::GameData; +use crate::models::character::Inventory; +use crate::models::container::slot_type; +use crate::models::house::House; +use crate::models::item_task::ItemFx; +use crate::systems::housing; +use crate::test_support::{ + spawn_player, test_character, test_server, test_server_with, TestClient, +}; +use crate::world::{Entity, HouseRef, PlayerRef}; +use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering}; +use std::sync::mpsc; +use std::time::Duration; + +#[test] +fn direct_ops_lock_waits_for_the_outer_scope() { + let economy = Arc::new(System::default()); + let scope = economy.operation_scope(); + let worker_economy = economy.clone(); + let (done, received) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _ops = worker_economy.ops_lock(); + done.send(()).unwrap(); + }); + economy.wait_until_operation_blocked(); + assert!(received.try_recv().is_err()); + drop(scope); + received.recv_timeout(Duration::from_secs(5)).unwrap(); + worker.join().unwrap(); +} + +#[test] +fn failure_and_panic_release_every_scope_depth() { + let economy = Arc::new(System::default()); + let fail = || -> Option<()> { + let _outer = economy.operation_scope(); + let _inner = economy.operation_scope(); + None + }; + assert!(fail().is_none()); + let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| { + let _outer = economy.operation_scope(); + let _ops = economy.ops_lock(); + panic!("deliberate publication failure"); + })); + assert!(result.is_err()); + assert!(!System::ops_held_on_this_thread()); + let worker_economy = economy.clone(); + let (done, received) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _ops = worker_economy.ops_lock(); + done.send(()).unwrap(); + }); + received.recv_timeout(Duration::from_secs(5)).unwrap(); + worker.join().unwrap(); +} + +#[tokio::test] +async fn scopes_of_different_game_servers_are_independent() { + let first = Arc::new(test_server()); + let second = Arc::new(test_server()); + let _first_scope = first.systems.economy.operation_scope(); + let (done, received) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _ops = second.systems.economy.ops_lock(); + done.send(()).unwrap(); + }); + received.recv_timeout(Duration::from_secs(5)).unwrap(); + worker.join().unwrap(); +} + +struct Reenter(AtomicUsize); + +impl hooks::QuestItemHooks for Reenter { + fn on_items_acquired(&self, server: &GameServer, _player: &PlayerRef, _id: u32, _count: i32) { + assert!(!System::ops_held_on_this_thread()); + let _callback = inventory::ItemTxn::begin(server); + self.0.fetch_add(1, Ordering::SeqCst); + } +} + +#[tokio::test] +async fn item_callbacks_reenter_the_outer_scope_after_releasing_ops() { + let server = Arc::new(test_server()); + server.set_self(); + let client = TestClient::new(&server, 1, 1); + spawn_player( + &server, + &client, + test_character(1, "Owner", 100.0, 100.0), + 0x100, + ); + let callback = Arc::new(Reenter(AtomicUsize::new(0))); + server + .systems + .economy + .hooks + .quests + .install(callback.clone()); + let _publication = server.systems.economy.operation_scope(); + let mut txn = inventory::ItemTxn::begin(&server); + txn.env.fx.push(ItemFx::Acquired { + owner: 1, + template_id: 1, + count: 1, + }); + drop(txn); + assert_eq!(callback.0.load(Ordering::SeqCst), 1); + assert!(!System::ops_held_on_this_thread()); +} + +/// A publication callback reaches the same managers as financial/property operations, +/// then starts an ordinary item operation. try_lock makes an ordering regression fail +/// immediately instead of deadlocking the test's publication thread. +struct PublicationCallback { + active: AtomicBool, + calls: AtomicUsize, +} + +impl hooks::QuestItemHooks for PublicationCallback { + fn on_items_acquired(&self, server: &GameServer, _player: &PlayerRef, _id: u32, _count: i32) { + if !self.active.load(Ordering::SeqCst) { + return; + } + assert!(!System::ops_held_on_this_thread()); + { + let _auction = server + .systems + .economy + .auction + .try_operation_lock() + .expect("waiting operation must not hold auction before the outer scope"); + let _housing = server + .systems + .housing + .operation_lock + .try_lock() + .expect("waiting operation must not hold housing before the outer scope"); + } + let _callback = inventory::ItemTxn::begin(server); + self.calls.fetch_add(1, Ordering::SeqCst); + } +} + +fn contend_with_publication( + server: &Arc, + operation: impl FnOnce(&GameServer) + Send + 'static, +) { + let callback = Arc::new(PublicationCallback { + active: AtomicBool::new(true), + calls: AtomicUsize::new(0), + }); + server + .systems + .economy + .hooks + .quests + .install(callback.clone()); + let publication = server.systems.economy.operation_scope(); + let worker_server = server.clone(); + let runtime = tokio::runtime::Handle::current(); + let (done, received) = mpsc::channel(); + let worker = std::thread::spawn(move || { + let _runtime = runtime.enter(); + operation(&worker_server); + done.send(()).unwrap(); + }); + // This observes the real gate's waiter count, not a pre-entry barrier. The worker + // cannot finish until publication releases its scope, and holds no manager yet. + server.systems.economy.wait_until_operation_blocked(); + assert!(received.try_recv().is_err()); + let mut txn = inventory::ItemTxn::begin(server); + txn.env.fx.push(ItemFx::Acquired { + owner: 1, + template_id: 1, + count: 1, + }); + drop(txn); + assert_eq!(callback.calls.load(Ordering::SeqCst), 1); + callback.active.store(false, Ordering::SeqCst); + drop(publication); + received + .recv_timeout(Duration::from_secs(5)) + .expect("operation must finish after publication releases the scope"); + worker.join().unwrap(); +} + +const LISTED_ITEM: u32 = 5001; +const HOUSE: u32 = 300; + +fn property_server() -> (Arc, PlayerRef) { + let mut data = GameData::empty(); + for id in [LISTED_ITEM, housing::manager::APPRAISAL_CERTIFICATE] { + data.items + .templates + .insert(id, ItemTemplate::plain(id, 100)); + } + data.systems + .housing + .add_template(housing::data::HousingTemplate { + id: HOUSE, + is_sellable: true, + ..Default::default() + }); + let server = Arc::new(test_server_with(data)); + server.set_self(); + server + .systems + .housing + .hooks + .install(Arc::new(bridges::EconomyForHousing)); + let client = TestClient::new(&server, 1, 1001); + let mut character = test_character(1, "Owner", 100.0, 100.0); + character.inventory = Inventory::new(1, 50, 50, &server.items, &server.ids.container); + let player = spawn_player(&server, &client, character, 0x100); + player.data().money = 100_000; + server.names.add_character(1, "Owner", 1001); + (server, player) +} + +fn give_property_item(server: &GameServer, player: &PlayerRef, template: u32, count: i32) -> u64 { + let item = server + .items + .create( + template, + count, + 0, + 1, + &server.game_data.items, + &server.ids.item, + 0, + ) + .unwrap(); + let id = item.id; + inventory::Inv::of(player) + .bag() + .lock() + .unwrap() + .add_new_item(item, -1, &server.game_data.items) + .unwrap(); + id +} + +fn sale_house(server: &GameServer, player: &PlayerRef) -> HouseRef { + let house = Entity::new( + server.ids.object.get_next_id().unwrap(), + House::new(1, HOUSE), + ); + { + let mut h = house.data(); + h.unit.owner_id = player.character_id; + h.protection_end_date = housing::manager::now() + 3600; + h.current_step = -1; + } + house +} + +#[tokio::test] +async fn financial_capture_waits_before_auction_and_housing_callback_locks() { + let (server, _) = property_server(); + contend_with_publication(&server, |server| { + let snapshot = crate::managers::save::capture_financial_snapshot(server); + assert_eq!(snapshot.characters.len(), 1); + }); +} + +#[tokio::test] +async fn auction_list_and_bid_wait_before_publication_callback_locks() { + let (server, seller) = property_server(); + let item = give_property_item(&server, &seller, LISTED_ITEM, 1); + let listing_seller = seller.clone(); + contend_with_publication(&server, move |server| { + server.systems.economy.auction.post_lot_on_auction( + server, + &listing_seller, + item, + 10, + 1000, + auction::auction_duration::HOURS_6, + ); + }); + let lot = server.systems.economy.auction.all_lots().pop().unwrap(); + assert_eq!(lot.item_id(), item); + assert_eq!( + server.items.item_by_id(item).unwrap().slot_type, + slot_type::AUCTION + ); + let client = TestClient::new(&server, 2, 1002); + let buyer = spawn_player( + &server, + &client, + test_character(2, "Buyer", 101.0, 100.0), + 0x101, + ); + buyer.data().money = 100; + let bidder = buyer.clone(); + contend_with_publication(&server, move |server| { + server.systems.economy.auction.bid_on_auction_lot( + server, + &bidder, + lot.id, + auction::AuctionBid { + lot_id: lot.id, + money: 20, + ..Default::default() + }, + ); + }); + assert_eq!(buyer.data().money, 80); + assert_eq!(server.systems.economy.auction.all_lots()[0].bidder_id, 2); +} + +#[tokio::test] +async fn housing_sale_waits_before_callback_locks_then_uses_real_economy_bridge() { + let (server, seller) = property_server(); + let certificate = + give_property_item(&server, &seller, housing::manager::APPRAISAL_CERTIFICATE, 2); + let house = sale_house(&server, &seller); + let listed_house = house.clone(); + contend_with_publication(&server, move |server| { + assert!(housing::ops::set_for_sale( + server, + &listed_house, + 100_000, + 0, + Some(&seller) + )); + }); + assert_eq!(house.data().sell_price, 100_000); + assert_eq!(server.items.item_by_id(certificate).unwrap().count, 1); +} + +#[tokio::test] +async fn housing_build_refusal_waits_before_callback_locks() { + let (server, player) = property_server(); + let item = give_property_item(&server, &player, LISTED_ITEM, 1); + contend_with_publication(&server, move |server| { + // Owned item but no design mapping: the normal construction refusal must still + // enter in the same order and leave its item and wallet untouched. + housing::ops::build( + server, + &player, + 1001, + &housing::packets::CSCreateHousePacket { + design_id: HOUSE, + x: 100.0, + y: 100.0, + z: 100.0, + z_rot: 0.0, + item_id: item, + money_amount: 0, + ht: 0, + auto_use_aa_point: false, + }, + ); + assert_eq!(player.data().money, 100_000); + }); + assert_eq!( + server.items.item_by_id(item).unwrap().slot_type, + slot_type::INVENTORY + ); + assert!(server.systems.housing.manager.all().is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/economy/store.rs b/rust/crates/aaemu-game/src/systems/economy/store.rs index 91bf59bc5b..eaec41c604 100644 --- a/rust/crates/aaemu-game/src/systems/economy/store.rs +++ b/rust/crates/aaemu-game/src/systems/economy/store.rs @@ -404,7 +404,7 @@ impl CSBuyItemsPacket { return; } let sells = match (pack_id, &npc_hooks) { - (Some(pack), Some(h)) => h.merchant_sells(server, pack, e.item_id), + (Some(pack), Some(h)) => h.merchant_sells(server, pack, e.item_id, e.grade), _ => false, }; if !sells { @@ -435,7 +435,7 @@ impl CSBuyItemsPacket { return; }; *total = sum; - items_buy.push((e.item_id, e.count)); + items_buy.push((e.item_id, e.count, e.grade)); } let inv = Inv::of(&p); @@ -489,12 +489,12 @@ impl CSBuyItemsPacket { let mut staged_bag = bag.clone(); let mut staged_buyback = buyback.clone(); let mut succeeded = true; - for (item_id, count) in items_buy { + for (item_id, count, grade) in items_buy { let template = txn.data().template(item_id).expect("preflight template"); let existing: Vec<_> = staged_bag .items .iter() - .filter(|i| i.template_id == item_id) + .filter(|i| i.template_id == item_id && i.grade == grade) .collect(); let units: i64 = existing.iter().map(|i| i64::from(i.count)).sum(); let capacity = (existing.len() as i64 + i64::from(staged_bag.free_slot_count())) @@ -507,7 +507,7 @@ impl CSBuyItemsPacket { task_type::STORE_BUY, item_id, count, - -1, + i32::from(grade), 0, &mut txn.env, ) diff --git a/rust/crates/aaemu-game/src/systems/housing/access_tests.rs b/rust/crates/aaemu-game/src/systems/housing/access_tests.rs index 69fb9c22df..ce247cb438 100644 --- a/rust/crates/aaemu-game/src/systems/housing/access_tests.rs +++ b/rust/crates/aaemu-game/src/systems/housing/access_tests.rs @@ -329,6 +329,38 @@ fn fixture_with_limits(always_public: bool, overall_limit: u32, group_limit: Opt 1, FuncTemplate::RecoverItem(DoodadFuncRecoverItem { id: 1 }), ); + // Crafting requires a current function that explicitly offers the recipe. Permission1 + // retains the house policy exercised below; recoverable furniture alone is no bench. + data.systems.npcs.doodad.funcs_by_groups.insert( + 71, + vec![DoodadFunc { + group_id: 71, + func_id: 1, + func_type: "DoodadFuncCraftPack".into(), + perm_id: 1, + ..Default::default() + }], + ); + data.systems + .npcs + .doodad + .func_templates + .entry("DoodadFuncCraftPack") + .or_default() + .insert( + 1, + FuncTemplate::CraftPack( + crate::systems::npcs::doodad::templates::DoodadFuncCraftPack { + id: 1, + craft_pack_id: 88, + }, + ), + ); + data.systems + .economy + .craft + .craft_pack_crafts + .insert(88, [88].into()); let server = test_server_with(data); let eco = Arc::new(Eco::default()); server.systems.housing.hooks.install(eco.clone()); @@ -493,6 +525,7 @@ impl crate::systems::economy::craft::CraftHooks for BenchRecorder { fn bench(fx: &Fx) -> (DoodadRef, Arc) { let d = recoverable(fx); + d.data().func_group_id = 71; d.data().transform.set_xyz(101.0, 100.0, 100.0); fx.server .world diff --git a/rust/crates/aaemu-game/src/systems/housing/dominion/runtime.rs b/rust/crates/aaemu-game/src/systems/housing/dominion/runtime.rs index bf40dd2fdd..b25207a7fe 100644 --- a/rust/crates/aaemu-game/src/systems/housing/dominion/runtime.rs +++ b/rust/crates/aaemu-game/src/systems/housing/dominion/runtime.rs @@ -390,6 +390,7 @@ pub fn complete_effect(server: &GameServer, args: &EffectArgs<'_>) { ) else { return; }; + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -565,6 +566,7 @@ pub fn handle_tower_death(server: &GameServer, victim: &WorldObject) -> bool { let Some((zone, identity)) = tower_identity(server, house) else { return false; }; + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -726,6 +728,7 @@ pub fn start_tick(server: &Arc) { } } { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/housing/manager.rs b/rust/crates/aaemu-game/src/systems/housing/manager.rs index 17cdedcc7e..f3bfeddafb 100644 --- a/rust/crates/aaemu-game/src/systems/housing/manager.rs +++ b/rust/crates/aaemu-game/src/systems/housing/manager.rs @@ -1090,6 +1090,7 @@ pub fn pay_weekly_tax_for(server: &GameServer, house: &HouseRef, payer_id: Optio /// `CheckHousingTaxes()` (the `HousingTaxTask`, every 10 s). pub fn check_housing_taxes(server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let manager = &server.systems.housing.manager; if manager.checking_tax.swap(true, Ordering::SeqCst) { return; @@ -1392,6 +1393,7 @@ pub fn reconcile_bound_doodads(server: &GameServer) -> (usize, usize) { /// `RemoveDeadHouse(house)` (`House.OnDeath`). pub fn remove_dead_house(server: &GameServer, house: &HouseRef) { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/housing/ops.rs b/rust/crates/aaemu-game/src/systems/housing/ops.rs index bac0bcf95c..d28e08e21e 100644 --- a/rust/crates/aaemu-game/src/systems/housing/ops.rs +++ b/rust/crates/aaemu-game/src/systems/housing/ops.rs @@ -165,6 +165,7 @@ pub fn house_tax_info(server: &GameServer, player: &PlayerRef, tl: u16) { /// `Build(connection, designId, posX, posY, posZ, zRot, itemId, moneyAmount, ht, /// autoUseAaPoint)`. pub fn build(server: &GameServer, player: &PlayerRef, account_id: u32, p: &CSCreateHousePacket) { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -494,6 +495,7 @@ pub fn demolish( failed_to_pay_tax: bool, force_restore_all_decor: bool, ) { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1006,6 +1008,7 @@ pub fn set_for_sale( buyer_id: u32, seller: Option<&PlayerRef>, ) -> bool { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1106,6 +1109,7 @@ fn zone_group_text(server: &GameServer, house: &House) -> String { /// `CancelForSale(house, returnCertificates)`. pub fn cancel_for_sale(server: &GameServer, house: &HouseRef, return_certificates: bool) -> bool { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1218,6 +1222,7 @@ pub fn update_furniture_owner( /// `BuyHouse(houseTlId, money, character)`. pub fn buy_house(server: &GameServer, tl: u16, money: u32, player: &PlayerRef) -> bool { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1373,6 +1378,7 @@ pub fn decorate_house( player: &PlayerRef, p: &CSDecorateHousePacket, ) -> Result { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -1605,6 +1611,7 @@ fn craft_building_with_payment( used_skill: u32, pay: impl FnOnce() -> Option, ) -> Result<(), BuildActionError> { + let _items = server.systems.economy.operation_scope(); let operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/instances/tower_def.rs b/rust/crates/aaemu-game/src/systems/instances/tower_def.rs index 2c0267d2d7..d82a45e453 100644 --- a/rust/crates/aaemu-game/src/systems/instances/tower_def.rs +++ b/rust/crates/aaemu-game/src/systems/instances/tower_def.rs @@ -362,6 +362,7 @@ pub fn initialize(server: &GameServer) -> anyhow::Result<()> { } pub fn start(server: &GameServer, key: EventKey, zone_id: u32) -> anyhow::Result<()> { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let event = prepare(server, key, zone_id)?; let first_wave_after = event.def.first_wave_after; @@ -430,6 +431,7 @@ fn spawn_controllers(server: &GameServer, key: EventKey, id: u32) -> anyhow::Res /// Advance exactly one wave. GM requests cannot skip waves or replay an active wave. pub fn next_wave(server: &GameServer, key: EventKey, step: u32) -> anyhow::Result<()> { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let (zone_id, targets, removed, removed_doodads) = { let mut state = manager(server) @@ -518,6 +520,7 @@ pub fn end(server: &GameServer, key: EventKey) -> anyhow::Result<()> { } fn end_event(server: &GameServer, key: EventKey, keep_corpses: bool) -> anyhow::Result<()> { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let event = manager(server) .state @@ -773,6 +776,7 @@ pub fn on_death(server: &GameServer, victim: &WorldObject) { let Some(npc) = victim.as_npc() else { return; }; + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let (world_id, zone_id, template) = { let n = npc.data(); @@ -837,6 +841,7 @@ fn wave_complete(p: &TowerDefProg, kills: &HashMap, elapsed: f32) -> b } pub fn tick(server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); schedule_tick(server); let now = spawn_manager::now(); @@ -1064,6 +1069,7 @@ fn broadcast(server: &GameServer, world_id: u32, packet: impl ServerPacket + Clo /// End events before an instance is removed, while its NPCs are still reachable. pub fn cleanup_world(server: &GameServer, world_id: u32) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let keys: Vec<_> = manager(server) .state diff --git a/rust/crates/aaemu-game/src/systems/instances/worlds.rs b/rust/crates/aaemu-game/src/systems/instances/worlds.rs index 0a42fd9bb5..9f8beb8c5e 100644 --- a/rust/crates/aaemu-game/src/systems/instances/worlds.rs +++ b/rust/crates/aaemu-game/src/systems/instances/worlds.rs @@ -174,6 +174,7 @@ pub fn world_name(world: &WorldInstance) -> String { /// `WorldManager.RemoveWorld(worldInstanceId)`. pub fn remove_world(server: &GameServer, world_id: u32) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); super::tower_def::cleanup_world(server, world_id); if !server.world.remove_world(world_id) { @@ -190,6 +191,7 @@ pub fn release_world_id(server: &GameServer, world_id: u32) { /// `WorldInstance.CleanupInstance()`: stops the respawn loop, removes the spawners and what they /// spawned, then despawns whatever is left; the instance's `SpawnManager` is dropped. pub fn cleanup_instance(server: &GameServer, world_id: u32) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); super::tower_def::cleanup_world(server, world_id); let spawns = &server.systems.npcs.spawns; diff --git a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs index 89a2ff1c09..f0943af958 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/bridges.rs @@ -28,6 +28,43 @@ use super::doodad::manager as doodads; /// `BaseUnitType.Npc`. const BASE_UNIT_TYPE_NPC: u32 = 1; + +/// Permission of the current function that actually offers this recipe. The 1.2 client's +/// `sub_398A9480` checks both legacy CraftStart lists and CraftPack membership before sending +/// CSExecuteCraft; another function in the same phase (such as ParentInfo) grants no access. +pub fn doodad_craft_permission( + server: &GameServer, + doodad: &crate::world::DoodadRef, + craft_id: u32, +) -> Option { + use super::doodad::templates::FuncTemplate; + let group = doodad.data().func_group_id; + let data = &server.game_data.systems.npcs.doodad; + let crafts = &server.game_data.systems.economy.craft; + data.doodad_funcs(group).iter().find_map(|func| { + let offers_craft = match data.func_template(func.func_id, &func.func_type)? { + FuncTemplate::CraftPack(pack) => crafts + .craft_pack_crafts + .get(&pack.craft_pack_id) + .is_some_and(|recipes| recipes.contains(&craft_id)), + FuncTemplate::CraftStart(start) => data + .phase_func_templates + .get("DoodadFuncCraftStartCraft") + .is_some_and(|recipes| { + recipes.values().any(|recipe| { + matches!(recipe, FuncTemplate::CraftStartCraft(r) + if r.doodad_func_craft_start_id == start.id && r.craft_id == craft_id) + }) + }), + _ => false, + }; + if !offers_craft { + return None; + } + u8::try_from(func.perm_id).ok() + }) +} + /// Installs this subsystem's hook implementations into the other subsystems. pub fn install(server: &GameServer) { install_economy(server); @@ -838,6 +875,7 @@ fn npc_spawner_spawn_effect( e: &crate::systems::skills::data::effects::NpcSpawnerSpawnEffect, args: &EffectArgs<'_>, ) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); tracing::info!( "NpcSpawnerSpawnEffect: SpawnerId={}, LifeTime={}, UseSummonerAggroTarget={}, ActivationState={}", @@ -1117,7 +1155,10 @@ impl crate::systems::economy::hooks::NpcEconomyHooks for NpcsForEconomy { }) } - fn merchant_sells(&self, server: &GameServer, pack_id: u32, item_id: u32) -> bool { + fn merchant_sells(&self, server: &GameServer, pack_id: u32, item_id: u32, grade: u8) -> bool { + let Some(template) = server.game_data.items.template(item_id) else { + return false; + }; server .game_data .systems @@ -1125,7 +1166,7 @@ impl crate::systems::economy::hooks::NpcEconomyHooks for NpcsForEconomy { .npc .goods .get(&pack_id) - .is_some_and(|g| g.sells_item(item_id)) + .is_some_and(|g| g.sells_item_at_grade(template, grade)) } fn specialty_coin_id(&self, server: &GameServer, npc: &NpcRef) -> u32 { diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/db.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/db.rs index b20e979c93..f936321e18 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/db.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/db.rs @@ -306,32 +306,49 @@ pub async fn delete_doodad_by_id( server.systems.npcs.doodads.persistence.flush().await?; // First grab the item related data let row = sqlx::query( - "SELECT CAST(item_id AS UNSIGNED) AS item_id, \ + "SELECT CAST(owner_id AS UNSIGNED) AS owner_id, CAST(owner_type AS UNSIGNED) AS owner_type, \ + CAST(template_id AS UNSIGNED) AS template_id, \ + CAST(item_template_id AS UNSIGNED) AS item_template_id, CAST(item_id AS UNSIGNED) AS item_id, \ CAST(item_container_id AS UNSIGNED) AS item_container_id FROM doodads WHERE id = ? LIMIT 1", ) .bind(db_id) .fetch_optional(&mut *conn) .await?; - let (item_id, container_id) = match row { - Some(r) => ( - r.try_get::("item_id")?, - r.try_get::("item_container_id")?, - ), - None => (0, 0), + let source = match row { + Some(r) => crate::systems::npcs::hooks::DoodadItemCleanup { + doodad_db_id: db_id, + doodad_template_id: r.try_get::("template_id")? as u32, + owner_id: r.try_get::("owner_id")? as u32, + owner_type: r.try_get::("owner_type")? as u8, + item_id: r.try_get::("item_id")?, + item_template_id: r.try_get::("item_template_id")? as u32, + container_id: r.try_get::("item_container_id")?, + }, + None => return Ok(false), }; - let n = sqlx::query("DELETE FROM doodads WHERE id = ?") - .bind(db_id) - .execute(&mut *conn) - .await? - .rows_affected(); + // Do not clean up the selected reference if another writer replaced its owner or items. + let n = sqlx::query( + "DELETE FROM doodads WHERE id = ? AND owner_id = ? AND owner_type = ? \ + AND template_id = ? AND item_id = ? AND item_template_id = ? AND item_container_id = ?", + ) + .bind(db_id) + .bind(source.owner_id) + .bind(source.owner_type) + .bind(source.doodad_template_id) + .bind(source.item_id) + .bind(source.item_template_id) + .bind(source.container_id) + .execute(&mut *conn) + .await? + .rows_affected(); if n == 0 { tracing::error!("Failed to delete doodad from DB Id: {db_id}"); return Ok(false); } server.ids.doodad.release_id(db_id); // Free up the Id - if item_id > 0 || container_id > 0 { + if source.item_id > 0 || source.container_id > 0 { if let Some(h) = server.systems.npcs.hooks.economy.get() { - h.release_deleted_doodad_items(server, item_id, container_id); + h.release_deleted_doodad_items(server, source); } } Ok(true) diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs index f33b350db2..f9edf65cd9 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/items.rs @@ -9,12 +9,85 @@ use crate::models::container::{equip_slot, slot_type}; use crate::models::doodad::doodad_owner_type; use crate::systems::npcs::doodad::runtime::DoodadCtx; use crate::systems::npcs::doodad::templates::{ - DoodadFuncBuyFish, DoodadFuncConsumeChanger, DoodadFuncLootItem, DoodadFuncLootPack, - DoodadFuncPurchase, DoodadFuncRecoverItem, DoodadFuncRemoveItem, + doodad_func_group_kind, DoodadFuncBuyFish, DoodadFuncConsumeChanger, DoodadFuncLootItem, + DoodadFuncLootPack, DoodadFuncPurchase, DoodadFuncRecoverItem, DoodadFuncRemoveItem, }; +use crate::systems::npcs::hooks::CargoRecovery; use crate::systems::social::achievement::char_record_kind; use crate::systems::social::achievement_hooks::{AchievementInput, RecordMatch}; -use crate::world::{PlayerRef, WorldObject}; +use crate::world::{DoodadRef, PlayerRef, WorldObject}; + +/// The authored loaded -> empty transition of a vehicle storage, not ordinary furniture. +pub(crate) fn cargo_empty_phase( + server: &crate::server::GameServer, + rack: &DoodadRef, +) -> Option { + let (owner_type, template_id, group) = { + let d = rack.data(); + (d.owner_type, d.template_id, d.func_group_id) + }; + cargo_empty_phase_for(server, owner_type, template_id, group) +} + +/// The same authored transition for a prefetched row, without allocating a live rack. +pub(crate) fn cargo_empty_phase_for( + server: &crate::server::GameServer, + owner_type: u8, + template_id: u32, + group: u32, +) -> Option { + if owner_type != doodad_owner_type::SLAVE { + return None; + } + let data = &server.game_data.systems.npcs.doodad; + let recover = data + .funcs_for_group(group) + .iter() + .find(|f| f.func_type == "DoodadFuncRecoverItem" && f.next_phase > 0)?; + let empty = recover.next_phase as u32; + (data + .doodad_func_groups(template_id) + .iter() + .any(|g| g.id == empty && g.group_kind_id == doodad_func_group_kind::START) + && data + .funcs_for_group(empty) + .iter() + .any(|f| f.func_type == "DoodadFuncConsumeChanger" && f.next_phase == group as i32)) + .then_some(empty) +} + +pub(crate) fn warn_item_reference( + server: &crate::server::GameServer, + rack: &DoodadRef, + item_id: u64, + reason: &str, +) { + let (rack_db_id, hull_db_id, hull_obj_id, attach_point) = { + let d = rack.data(); + (d.db_id, d.owner_db_id, d.parent_obj_id, d.attach_point) + }; + let (container_id, container_slot_type, container_owner_id) = server + .items + .holding_container(item_id) + .map(|c| { + let c = c.lock().expect("container poisoned"); + (c.container_id, c.slot_type, c.owner_id) + }) + .unwrap_or_default(); + tracing::warn!( + rack_obj_id = rack.obj_id, + rack_db_id, + item_id, + container_id, + container_slot_type, + container_owner_id, + hull_db_id, + hull_obj_id, + attach_point, + reason, + "Doodad item reference refused or repaired" + ); +} /// `SCUnitEquipmentsChangedPacket`: one definition per opcode (`crate::systems::economy::item_packets::SCUnitEquipmentsChangedPacket`). pub use crate::systems::economy::item_packets::SCUnitEquipmentsChangedPacket; @@ -145,10 +218,12 @@ pub fn recover_item( skill_id: u32, next_phase: i32, ) { + set_to_next_phase(ctx, false); // `caster.Name` / `(Character)caster` throw for a null / non-character caster. let Some(player) = DoodadCtx::as_player(caster) else { return; }; + let _items = ctx.server.systems.economy.operation_scope(); let _operation = ctx .server .systems @@ -169,9 +244,6 @@ pub fn recover_item( d.template_id, ) }; - // Recovery can also be reached through an InteractionEffect, outside the phase - // machine's normal result reset. A failed recovery must never reuse an old success. - set_to_next_phase(ctx, false); if owner_type == doodad_owner_type::HOUSING && owner_db_id > 0 { let allowed = crate::systems::housing::house_by_id(ctx.server, owner_db_id).is_some_and(|house| { @@ -198,6 +270,49 @@ pub fn recover_item( ); let server = ctx.server; let eco = economy(server); + if cargo_empty_phase(server, &ctx.doodad).is_some() { + match eco.recover_doodad_cargo(server, player, &ctx.doodad) { + CargoRecovery::Recovered => { + if let Some(moved) = server.items.item_by_id(item_id) { + crate::world::broadcast( + &ctx.world, + player, + &SCUnitEquipmentsChangedPacket { + obj_id: player.obj_id, + items: vec![(moved.slot as u8, Some(moved))], + }, + false, + ); + } + set_to_next_phase(ctx, true); + } + CargoRecovery::ClearedStale(empty) => { + warn_item_reference( + server, + &ctx.doodad, + item_id, + "cleared dangling cargo reference without moving an item", + ); + super::super::manager::do_change_phase( + server, + &ctx.world, + &ctx.doodad, + Some(&WorldObject::from(player)), + empty as i32, + ); + } + CargoRecovery::Failed => { + warn_item_reference( + server, + &ctx.doodad, + item_id, + "cargo recovery failed escrow, rack or backpack preflight", + ); + send_error(player, err::FAILED_TO_USE_ITEM); + } + } + return; + } let mut added_item = false; let item = server.items.item_by_id(item_id); if item_id > 0 { @@ -406,16 +521,27 @@ pub fn consume_changer( caster: Option<&WorldObject>, ) { tracing::trace!("DoodadFuncConsumeChanger"); + set_to_next_phase(ctx, false); let Some(player) = DoodadCtx::as_player(caster) else { return; }; + let _items = ctx.server.systems.economy.operation_scope(); + let _operation = ctx + .server + .systems + .housing + .operation_lock + .lock() + .unwrap_or_else(|e| e.into_inner()); + if ctx.doodad.data().phase.deleted { + return; + } let source = { let equipment = player.data().inventory.equipment().clone(); let c = equipment.lock().expect("container poisoned"); - c.get_item_by_slot(f.slot_id as i32) - .map(|i| (i.id, i.template_id)) + c.get_item_by_slot(f.slot_id as i32).cloned() }; - let Some((source_id, source_template)) = source else { + let Some(source) = source else { send_error(player, err::UNKNOWN_ITEM); return; }; @@ -423,41 +549,21 @@ pub fn consume_changer( if !ctx .data() .consume_changer_items(f.id) - .contains(&source_template) + .contains(&source.template_id) { send_error(player, err::STORE_INVALID_ITEM); return; } - let (template_id, owner_id) = { - let d = ctx.doodad.data(); - (d.template_id, d.owner_id) - }; - // TODO (C#): if this item count would be different from 1, this would cause issues - if f.count > 1 { - tracing::warn!( - "DoodadFuncConsumeChanger, expected source count is higher than one ({}) for slot {} on doodad type {} ({}) from player {}", - f.count, - f.slot_id, - template_id, - owner_id, - player.data().unit.name + if !economy(ctx.server).try_store_doodad_item(ctx.server, player, &ctx.doodad, &source, f.count) + { + warn_item_reference( + ctx.server, + &ctx.doodad, + source.id, + "cargo deposit source changed or rack occupied", ); - } - // Move the actual item to the owner's SystemContainer - if !economy(ctx.server).move_item_to_system_container( - ctx.server, - player, - item_task::DOODAD_ITEM_CHANGER, - source_id, - ) { - set_to_next_phase(ctx, false); send_error(player, err::STORE_INVALID_ITEM); return; } - { - let mut d = ctx.doodad.data(); - d.item_id = source_id; - d.item_template_id = source_template; - } set_to_next_phase(ctx, true); } diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/tests.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/tests.rs index 6ee632ba9b..5bff440162 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/tests.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/funcs/tests.rs @@ -82,14 +82,22 @@ impl EconomyBridge for Rec { self.push(format!("consume {task} {t} {c}")); self.consumed } - fn move_item_to_system_container( + fn try_store_doodad_item( &self, _s: &GameServer, _p: &PlayerRef, - task: u8, - id: u64, + doodad: &DoodadRef, + source: &Item, + _count: i32, ) -> bool { - self.push(format!("system {task} {id}")); + self.push(format!( + "system {} {}", + item_task::DOODAD_ITEM_CHANGER, + source.id + )); + let mut d = doodad.data(); + d.item_id = source.id; + d.item_template_id = source.template_id; true } } diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/interactions.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/interactions.rs index 6380954a62..1c13f11427 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/interactions.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/interactions.rs @@ -365,12 +365,30 @@ pub fn doodad_allow_removal(server: &GameServer, doodad: &DoodadRef) -> bool { if !coffer::coffer_is_empty(server, doodad) { return false; } + let instance = doodad.data().transform.instance_id; !doodad .core() .children() .iter() .filter_map(WorldObject::as_doodad) - .any(|c| c.data().is_persistent) + .any(|child| { + let (persistent, parent, child_instance) = { + let d = child.data(); + ( + d.is_persistent && !d.phase.deleted, + d.transform.parent_obj_id, + d.transform.instance_id, + ) + }; + persistent + && parent == doodad.obj_id + && child_instance == instance + && server + .world + .world(instance) + .and_then(|world| world.doodad(child.obj_id)) + .is_some_and(|live| std::sync::Arc::ptr_eq(&live, child)) + }) } /// `RecoverItem.Execute`. diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/manager.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/manager.rs index 1c866d82e7..dd52ac9abe 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/manager.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/manager.rs @@ -245,14 +245,26 @@ pub fn delete(server: &GameServer, world: &Arc, doodad: &DoodadRe world.delete(doodad); area_trigger::remove_doodad_area_triggers(server, doodad.obj_id); - let (item_id, persistent, db_id) = { + let (source, persistent, db_id) = { let d = doodad.data(); - (d.item_id, d.is_persistent, d.db_id) + ( + crate::systems::npcs::hooks::DoodadItemCleanup { + doodad_db_id: d.db_id, + doodad_template_id: d.template_id, + owner_id: d.owner_id, + owner_type: d.owner_type, + item_id: d.item_id, + item_template_id: d.item_template_id, + container_id: d.coffer.as_ref().map_or(0, |c| c.container_id), + }, + d.is_persistent, + d.db_id, + ) }; // Delete associated item if expired - if item_id > 0 { + if source.item_id > 0 { if let Some(h) = server.systems.npcs.hooks.economy.get() { - h.remove_expired_doodad_item(server, item_id); + h.remove_expired_doodad_item(server, source); } } if let Some(spawns) = server.systems.npcs.spawns.get(world.id) { diff --git a/rust/crates/aaemu-game/src/systems/npcs/doodad/spawner.rs b/rust/crates/aaemu-game/src/systems/npcs/doodad/spawner.rs index 7ff2b0047b..29376db9aa 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/doodad/spawner.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/doodad/spawner.rs @@ -387,6 +387,7 @@ impl DoodadSpawner { { return false; } + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); if spawn { if spawner.last().is_none() { @@ -585,6 +586,7 @@ impl DoodadSpawner { item_id: u64, char_obj_id: u32, ) -> Option { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); self.reset_for_spawn(); // C#: WorldManager.GetCharacterByObjId(charId).ParentWorld (null -> exception). @@ -610,6 +612,7 @@ impl DoodadSpawner { /// `Spawn(objId)` (initial spawn and respawns). Only `objId == 0` creates a doodad. pub fn spawn(self: &Arc, server: &GameServer, obj_id: u32) -> Option { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); // TODO (C#): clean up each doodad using the same call self.reset_for_spawn(); @@ -667,6 +670,7 @@ impl DoodadSpawner { /// `Despawn(doodad)`. pub fn despawn(&self, server: &GameServer, doodad: &DoodadRef) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let spawns = &server.systems.npcs.spawns; // Spawn replaces the local list, but the world can still contain older linked spawns. @@ -769,6 +773,7 @@ impl DoodadSpawner { /// `DoDespawn(doodad)` (`Doodad.DoDespawn` / `DoodadSpawnerDoDespawnTask`). pub fn do_despawn(self: &Arc, server: &GameServer, doodad: &DoodadRef) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let (template_id, obj_id, func_group_id) = { let d = doodad.data(); @@ -822,6 +827,7 @@ impl DoodadSpawner { /// `DoSpawn()`: spawns `Last` (with the game schedule checks). pub fn do_spawn(self: &Arc, server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let schedule = &server.game_data.systems.npcs.schedule; let last_obj_id = self.last().map_or(0, |l| l.obj_id); diff --git a/rust/crates/aaemu-game/src/systems/npcs/hooks.rs b/rust/crates/aaemu-game/src/systems/npcs/hooks.rs index ad551b92a4..ba4bea8565 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/hooks.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/hooks.rs @@ -12,7 +12,15 @@ use crate::server::GameServer; use crate::systems::HookSlot; -use crate::world::{NpcRef, PlayerRef, WorldObject}; +use crate::world::{DoodadRef, NpcRef, PlayerRef, WorldObject}; + +/// Result of recovering an authored vehicle cargo rack; stale repair never grants an item. +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum CargoRecovery { + Failed, + Recovered, + ClearedStale(u32), +} /// Implemented by the **skills** subsystem (`SkillManager`, `Skill.Use`, buffs, combat). pub trait SkillsBridge: Send + Sync { @@ -418,6 +426,30 @@ pub trait EconomyBridge: Send + Sync { false } + /// Check the exact equipped source and vacant rack, then move and record it atomically. + /// The caller holds the housing operation lock before entering the economy operation. + fn try_store_doodad_item( + &self, + _server: &GameServer, + _player: &PlayerRef, + _doodad: &DoodadRef, + _source: &crate::models::item::Item, + _required_count: i32, + ) -> bool { + false + } + + /// Recover vehicle cargo from System escrow, including backpack-space preflight, in one + /// item operation. Ordinary furniture recovery retains its separate behavior. + fn recover_doodad_cargo( + &self, + _server: &GameServer, + _player: &PlayerRef, + _doodad: &DoodadRef, + ) -> CargoRecovery { + CargoRecovery::Failed + } + /// `Equipment.RemoveItem(task, item, true)` (`DoodadFuncBuyFish` / `ConvertFish`). fn remove_equipment_item( &self, @@ -618,19 +650,15 @@ pub trait EconomyBridge: Send + Sync { ) { } - /// `Doodad.Delete()` item cleanup: `GetItemByItemId(itemId)` held by a `None` / `System` - /// container -> `RemoveItem(Invalid, item, true)`. Default: nothing. - fn remove_expired_doodad_item(&self, _server: &GameServer, _item_id: u64) {} + /// `Doodad.Delete()` item cleanup. The original doodad context, not a possibly recycled + /// item's current class, determines whether ordinary owned System escrow may be removed. + /// Cargo and ambiguous references are retained for reconciliation. Default: nothing. + fn remove_expired_doodad_item(&self, _server: &GameServer, _source: DoodadItemCleanup) {} - /// `DeleteDoodadById` item part: the attached item loses its container and its id is - /// released; the attached container is deleted. Default: nothing. - fn release_deleted_doodad_items( - &self, - _server: &GameServer, - _item_id: u64, - _container_id: u64, - ) { - } + /// `DeleteDoodadById` item part. Only matching ordinary owned System escrow may be removed. + /// Container GUIDs have no immutable link to the deleted row, so their deletion is deferred. + /// Default: nothing. + fn release_deleted_doodad_items(&self, _server: &GameServer, _source: DoodadItemCleanup) {} /// `HousingManager.GetHouseAtLocation(x, y)` (database id of the house whose land covers /// the point). Default: the housing subsystem. @@ -639,6 +667,19 @@ pub trait EconomyBridge: Send + Sync { } } +/// Original live/saved doodad metadata for item cleanup. Item and container GUIDs can be reused; +/// this describes the source reference and does not assert an allocation-generation identity. +#[derive(Debug, Clone, Copy, Default)] +pub struct DoodadItemCleanup { + pub doodad_db_id: u32, + pub doodad_template_id: u32, + pub owner_id: u32, + pub owner_type: u8, + pub item_id: u64, + pub item_template_id: u32, + pub container_id: u64, +} + /// The item fields `CSCreateDoodadPacket` / `CreatePlayerDoodad` read. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct DoodadSourceItem { diff --git a/rust/crates/aaemu-game/src/systems/npcs/npc/data.rs b/rust/crates/aaemu-game/src/systems/npcs/npc/data.rs index e96681b935..301cf1470d 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/npc/data.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/npc/data.rs @@ -27,6 +27,7 @@ use std::collections::HashMap; use rusqlite::Connection; use crate::data::formulas::Formula; +use crate::data::items::ItemTemplate; use crate::data::sqlite::{for_each_row, SqlRow}; use crate::models::unit::{BonusTemplate, UnitAttribute, UnitModifierType}; use crate::models::unit_model::{FaceModel, UnitCustomModelParams, UnitCustomModelType}; @@ -442,9 +443,29 @@ impl MerchantGoods { .any(|i| i.item_template_id == item_template_id) } - /// `AddItemToStock` (the first grade of an item wins). + /// The client normalizes each stock grade through the item template before buying + /// (1.2 `sub_394FC6E0` -> `sub_397CD260`). A fixed grade takes precedence; an + /// ungradable template without a fixed grade uses basic. Zero is a grade, not a wildcard. + pub fn sells_item_at_grade(&self, template: &ItemTemplate, grade: u8) -> bool { + self.items.iter().any(|i| { + let offered_grade = if template.fixed_grade >= 0 { + template.fixed_grade as u8 + } else if template.gradable { + i.grade + } else { + 0 + }; + i.item_template_id == template.id && offered_grade == grade + }) + } + + /// Keep each item / grade pair offered by the catalog. pub fn add_item_to_stock(&mut self, item_template_id: u32, grade: u8) { - if self.sells_item(item_template_id) { + if self + .items + .iter() + .any(|i| i.item_template_id == item_template_id && i.grade == grade) + { return; } self.items.push(MerchantGoodsItem { @@ -922,7 +943,8 @@ impl NpcData { for_each_row(conn, "SELECT * FROM merchant_goods", [], |r| { let id = r.u32("merchant_pack_id")?; let item_id = r.u32("item_id")?; - let grade = r.u8("grade_id")?; + // The 1.2 client reads this with sqlite3_column_int: NULL is basic (0). + let grade = r.u8_or("grade_id", 0)?; d.goods .entry(id) .or_insert_with(|| MerchantGoods { @@ -1264,16 +1286,70 @@ mod tests { "; #[test] - fn merchant_goods_first_grade_wins() { + fn merchant_goods_preserve_distinct_grades() { let mut g = MerchantGoods::default(); g.add_item_to_stock(5, 1); g.add_item_to_stock(5, 3); + g.add_item_to_stock(5, 1); g.add_item_to_stock(6, 0); - assert_eq!(g.items.len(), 2); - assert_eq!(g.items[0].grade, 1); + assert_eq!(g.items.len(), 3); + assert_eq!((g.items[0].grade, g.items[1].grade), (1, 3)); assert!(g.sells_item(6) && !g.sells_item(7)); } + #[test] + fn merchant_goods_load_null_grade_as_basic() { + let c = Connection::open_in_memory().unwrap(); + c.execute_batch(TEST_SCHEMA).unwrap(); + c.execute_batch("INSERT INTO merchant_goods VALUES (4, 77, 12, NULL), (5, 77, 12, 0);") + .unwrap(); + let d = NpcData::load_conn(&c, "en_us").unwrap(); + assert_eq!( + d.goods(77).unwrap().items, + vec![ + MerchantGoodsItem { + item_template_id: 10, + grade: 0 + }, + MerchantGoodsItem { + item_template_id: 11, + grade: 0 + }, + MerchantGoodsItem { + item_template_id: 10, + grade: 2 + }, + MerchantGoodsItem { + item_template_id: 12, + grade: 0 + }, + ] + ); + } + + #[test] + fn merchant_goods_validate_native_purchase_grade() { + let mut g = MerchantGoods::default(); + g.add_item_to_stock(5, 0); + g.add_item_to_stock(5, 3); + let mut t = ItemTemplate::plain(5, 1); + t.gradable = true; + assert!(g.sells_item_at_grade(&t, 0)); + assert!(g.sells_item_at_grade(&t, 3)); + assert!(!g.sells_item_at_grade(&t, 11)); + t.fixed_grade = 2; + assert!(g.sells_item_at_grade(&t, 2)); + assert!(!g.sells_item_at_grade(&t, 0)); + assert!(!g.sells_item_at_grade(&t, 3)); + t.gradable = false; + assert!(g.sells_item_at_grade(&t, 2)); + t.fixed_grade = -1; + assert!(g.sells_item_at_grade(&t, 0)); + assert!(!g.sells_item_at_grade(&t, 3)); + t.id = 7; + assert!(!g.sells_item_at_grade(&t, 0)); + } + #[test] fn body_parts_take_last_entry_and_template_hair() { let mut ibp = HashMap::new(); @@ -1336,7 +1412,7 @@ mod tests { let t2 = d.template(101).unwrap(); assert_eq!(t2.model_params.kind, UnitCustomModelType::SKIN); assert_eq!((t2.race, t2.gender), (0, 0)); - assert_eq!(d.goods(77).unwrap().items.len(), 2); + assert_eq!(d.goods(77).unwrap().items.len(), 3); assert!(d.is_fly_or_swim(2) && !d.is_fly_or_swim(10) && !d.is_fly_or_swim(3)); assert_eq!(d.weapons[&601].level, 20); assert_eq!(d.localized_name(100, "x"), "Guard"); diff --git a/rust/crates/aaemu-game/src/systems/npcs/npc/spawner.rs b/rust/crates/aaemu-game/src/systems/npcs/npc/spawner.rs index 8b8bb9a514..67b7b94906 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/npc/spawner.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/npc/spawner.rs @@ -411,6 +411,7 @@ impl NpcSpawner { /// `Update()`: despawn (schedule / no player around) has priority over spawning. pub fn update(self: &Arc, server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let _lock = server.systems.npcs.spawns.spawn_lock(); let mut did_action = false; if self.can_despawn_npcs(server) { @@ -439,6 +440,7 @@ impl NpcSpawner { warm_present: bool, budget: i64, ) -> usize { + let _items = server.systems.economy.operation_scope(); let _lock = server.systems.npcs.spawns.spawn_lock(); let mut did_action = false; if self.can_despawn_npcs(server) { @@ -945,6 +947,7 @@ impl NpcSpawner { /// cannot block or duplicate it. Corpse despawn timers, other placements and other instances /// stay intact; a cancelled id is released only when no world object or corpse timer owns it. pub fn force_spawn(self: &Arc, server: &GameServer, _obj_id: u32) -> Option { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); if self.spawned_map().is_empty() { let t = self.template(); @@ -1255,6 +1258,7 @@ impl NpcSpawner { /// living population and the still-reserved respawn deadlines all still apply, and a failed /// pass leaves the spawner unscheduled so it is retried. pub fn do_spawn_bounded(self: &Arc, server: &GameServer, budget: i64) -> usize { + let _items = server.systems.economy.operation_scope(); if budget <= 0 { return 0; } @@ -1614,6 +1618,7 @@ impl NpcSpawner { ) { // Creation, event ownership and population bookkeeping must finish before an // event can end and delete the summoner's descendants. + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let Some(template) = server .game_data diff --git a/rust/crates/aaemu-game/src/systems/npcs/npc/stats.rs b/rust/crates/aaemu-game/src/systems/npcs/npc/stats.rs index 5994c99b97..450a8e9359 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/npc/stats.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/npc/stats.rs @@ -15,6 +15,7 @@ use std::collections::HashMap; +use crate::data::attribute_limits::UnitAttributeLimits; use crate::data::formulas::{ FormulaManager, FormulaOwnerType, UnitFormulaKind, UnitFormulaVariableType, }; @@ -92,25 +93,38 @@ pub struct NpcStatCalc<'a> { pub template: &'a NpcTemplate, pub level: u8, pub bonuses: &'a Bonuses, + pub limits: &'a UnitAttributeLimits, pub mainhand: Option, pub offhand: Option, pub ranged: Option, } /// The int-getter bonus loop. -fn apply_int(bonuses: &Bonuses, attr: UnitAttribute, mut res: i32) -> i32 { +fn apply_int( + bonuses: &Bonuses, + limits: &UnitAttributeLimits, + attr: UnitAttribute, + res: i32, +) -> i32 { + // Widen intermediates so a large stack cannot wrap before the final raw cap. + let mut res = f64::from(res); for b in bonuses.bonuses(attr) { if b.template.modifier_type == UnitModifierType::Percent { - res = res.wrapping_add((res.wrapping_mul(b.value) as f32 / 100.0) as i32); + res += f64::from(((res * f64::from(b.value)) as f32 / 100.0).trunc()); } else { - res = res.wrapping_add(b.value); + res += f64::from(b.value); } } - res + limits.clamp(attr, res) as i32 } /// The double-getter bonus loop (`DpsInc`, `RangedDpsInc`, `MDpsInc`). -fn apply_f64(bonuses: &Bonuses, attr: UnitAttribute, mut res: f64) -> f64 { +fn apply_f64( + bonuses: &Bonuses, + limits: &UnitAttributeLimits, + attr: UnitAttribute, + mut res: f64, +) -> f64 { for b in bonuses.bonuses(attr) { if b.template.modifier_type == UnitModifierType::Percent { res += res * f64::from(b.value) / 100.0; @@ -118,7 +132,7 @@ fn apply_f64(bonuses: &Bonuses, attr: UnitAttribute, mut res: f64) -> f64 { res += f64::from(b.value); } } - res + limits.clamp(attr, res) } /// Base attributes passed to the derived formulas. @@ -175,7 +189,12 @@ impl NpcStatCalc<'_> { } fn base_attr(&self, kind: UnitFormulaKind, attr: UnitAttribute) -> i32 { - apply_int(self.bonuses, attr, self.eval(kind, None, false) as i32) + apply_int( + self.bonuses, + self.limits, + attr, + self.eval(kind, None, false) as i32, + ) } fn base(&self) -> Base { @@ -190,12 +209,17 @@ impl NpcStatCalc<'_> { } fn derived_int(&self, b: Base, kind: UnitFormulaKind, attr: UnitAttribute, add: i32) -> i32 { - let res = (self.eval(kind, Some(b), false) as i32).wrapping_add(add); - apply_int(self.bonuses, attr, res) + let res = (self.eval(kind, Some(b), false) as i32).saturating_add(add); + apply_int(self.bonuses, self.limits, attr, res) } fn derived_f64(&self, b: Base, kind: UnitFormulaKind, attr: UnitAttribute) -> i32 { - apply_f64(self.bonuses, attr, self.eval(kind, Some(b), false)) as i32 + apply_f64( + self.bonuses, + self.limits, + attr, + self.eval(kind, Some(b), false), + ) as i32 } /// `Dps` / `OffhandDps` / `RangedDps`: float `weapon.Dps + stat / 10f` with the bonuses, @@ -210,7 +234,7 @@ impl NpcStatCalc<'_> { res += b.value as f32; } } - (res * 1000.0) as i32 + self.limits.clamp(attr, f64::from(res * 1000.0)) as i32 } /// Every getter. @@ -228,7 +252,7 @@ impl NpcStatCalc<'_> { res += f64::from(bo.value); } } - (res * 1000.0) as i32 + self.limits.clamp(A::SpellDps, res * 1000.0) as i32 }; let kill_exp = if self.template.no_exp { 0 @@ -290,6 +314,7 @@ pub fn npc_stats(gd: &GameData, npc: &Npc) -> Option { template, level: npc.unit.level, bonuses: &npc.unit.bonuses, + limits: &gd.characters.unit_attribute_limits, mainhand: weapon(equip_slot::MAINHAND), offhand: weapon(equip_slot::OFFHAND), ranged: weapon(equip_slot::RANGED), @@ -300,6 +325,9 @@ pub fn npc_stats(gd: &GameData, npc: &Npc) -> Option { /// Caches `MaxHp`, `MaxMp` and the regen getters in `npc.unit` (shared code reads those). pub fn refresh_cached_stats(gd: &GameData, npc: &mut Npc) { + npc.unit + .bonuses + .bind_attribute_limits(&gd.characters.unit_attribute_limits); let Some(s) = npc_stats(gd, npc) else { return; }; @@ -384,6 +412,7 @@ pub(crate) mod tests { template: t, level, bonuses: b, + limits: &b.attribute_limits, mainhand: Some(WeaponDps { dps: 30.5, mdps: 12.25, diff --git a/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs b/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs index eadd7be941..6803af99cf 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/portal/mod.rs @@ -613,6 +613,18 @@ pub fn open_portal( tracing::error!("OpenPortal: portal {} is not in the book", effect.id); return None; }; + let instance = owner.data().unit.transform.instance_id; + if !session::zone_access_allowed( + server, + owner, + instance, + portal_info.zone_id, + portal_info.x, + portal_info.y, + ) { + owner.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); + return None; + } if !check_can_open_portal(server, owner, portal_info.zone_id) { return None; } @@ -852,6 +864,17 @@ pub fn use_portal_with_preference( tracing::warn!("UsePortal: npc {obj_id} is not a portal"); return; }; + if !session::zone_access_allowed( + server, + player, + teleport.instance_id, + teleport.zone_id, + teleport.x, + teleport.y, + ) { + player.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); + return; + } if only_my_portal && owner_id != player.character_id { player.send(SCErrorMsgPacket::new(error_message::NOT_MY_PORTAL, 0, true)); return; @@ -1088,6 +1111,11 @@ pub fn navi_teleport(server: &GameServer, player: &PlayerRef, obj_id: u32) { return; } let pos = world.world_pos_rot(&WorldObject::from(&doodad)); + let zone_id = doodad.data().transform.zone_id; + if !session::zone_access_allowed(server, player, world.id, zone_id, pos.x, pos.y) { + player.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); + return; + } run_navi_func(server, &doodad, player, &func); player.data().set_disabled_set_position(true); player.send(packets::SCNaviTeleportPacket { @@ -1190,6 +1218,10 @@ pub fn use_teleport( if money_amount < 0 { return; } + if !session::zone_access_allowed(server, player, instance_id, dest.zone_id, dest.x, dest.y) { + player.send(SCErrorMsgPacket::new(session::CLOSED_ZONE, 0, true)); + return; + } if money_amount > 0 { let paid = server.systems.npcs.hooks.economy.get().is_some_and(|eco| { eco.change_money(server, player, -i64::from(money_amount), ITEM_TASK_TELEPORT) diff --git a/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs b/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs index 6d02ad71cd..2dda286d30 100644 --- a/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs +++ b/rust/crates/aaemu-game/src/systems/npcs/spawn_manager.rs @@ -61,6 +61,215 @@ pub const FIRST_FAKE_SPAWNER_ID: u32 = 9_000_001; /// spawners) quadratically, so a pathological configuration is clamped to a modest ring. pub const MAX_PREWARM_REGION_MARGIN: u32 = 4; +/// Fully decoded persistent rows. Fetching/validating this batch allocates no world objects, +/// changes no parent links and queues no persistence writes. +#[derive(Debug, Default)] +pub(crate) struct PersistentDoodads { + rows: Vec, +} + +#[derive(Debug)] +struct PreparedDoodad { + row: crate::systems::npcs::doodad::db::DoodadRow, + interaction_counts: HashMap, +} + +impl PersistentDoodads { + pub(crate) fn prepare( + server: &GameServer, + rows: Vec, + ) -> anyhow::Result { + let mut prepared = Vec::with_capacity(rows.len()); + for row in rows { + anyhow::ensure!(row.id != 0, "persistent doodad has no database id"); + let template = server + .game_data + .systems + .npcs + .doodad + .template(row.template_id) + .ok_or_else(|| { + anyhow::anyhow!( + "persistent doodad {}: template {} does not exist", + row.id, + row.template_id + ) + })?; + anyhow::ensure!( + [row.x, row.y, row.z, row.roll, row.pitch, row.yaw, row.scale] + .iter() + .all(|value| value.is_finite()), + "persistent doodad {}: non-finite transform", + row.id + ); + anyhow::ensure!( + row.current_phase_id == 0 + || template + .func_groups + .iter() + .any(|group| group.id == row.current_phase_id), + "persistent doodad {}: phase {} does not belong to template {}", + row.id, + row.current_phase_id, + row.template_id + ); + let interaction_counts = serde_json::from_str(&row.interaction_counts)?; + prepared.push(PreparedDoodad { + row, + interaction_counts, + }); + } + Ok(Self { rows: prepared }) + } + + /// Called inside the item/publication scopes, before replacing any hull. Compare the + /// fetched receipt, not the before/after emptiness of the hull: a store/recover ABA can + /// leave an empty live rack while SQL has captured its former loaded reference. + pub(crate) fn validate_slave_cargo( + &self, + server: &GameServer, + hull_id: u32, + live_hull: Option<&crate::world::SlaveRef>, + ) -> anyhow::Result<()> { + use crate::models::container::slot_type; + use crate::models::item::ItemClass; + use crate::systems::npcs::doodad::funcs::items::cargo_empty_phase_for; + + let mut row_ids = HashSet::new(); + let mut packs = HashSet::new(); + anyhow::ensure!( + live_hull.is_none_or(|h| h.data().id == hull_id), + "cargo preflight has a different live hull identity" + ); + for prepared in &self.rows { + let row = &prepared.row; + anyhow::ensure!( + row.owner_type == doodad_owner_type::SLAVE + && row.house_id == hull_id + && row_ids.insert(row.id), + "persistent doodad batch has a duplicate or different hull identity" + ); + let cargo = server + .game_data + .systems + .npcs + .doodad + .doodad_func_groups(row.template_id) + .iter() + .any(|group| { + cargo_empty_phase_for(server, row.owner_type, row.template_id, group.id) + .is_some() + }); + if !cargo { + continue; + } + if row.item_id == 0 { + anyhow::ensure!( + row.item_template_id == 0 + && cargo_empty_phase_for( + server, + row.owner_type, + row.template_id, + row.current_phase_id + ) + .is_none(), + "saved empty cargo rack has loaded metadata" + ); + continue; + } + anyhow::ensure!( + cargo_empty_phase_for( + server, + row.owner_type, + row.template_id, + row.current_phase_id + ) + .is_some(), + "saved cargo item is not in its loaded phase" + ); + anyhow::ensure!(packs.insert(row.item_id), "aliased saved cargo item"); + // A live version of this exact persistent hull must agree with the fetched + // loaded receipt. Other inactive summon items have no live rack to compare. + if let Some(hull) = live_hull { + let world = server + .world + .world_of(&WorldObject::from(hull)) + .ok_or_else(|| anyhow::anyhow!("cargo hull is no longer live"))?; + let matched = world.all_doodads().into_iter().any(|rack| { + let d = rack.data(); + !d.phase.deleted + && d.db_id == row.id + && d.owner_type == row.owner_type + && d.owner_id == row.owner_id + && d.owner_db_id == hull_id + && d.template_id == row.template_id + && d.attach_point == row.attach_point + && d.parent_obj_id == hull.obj_id + && d.transform.parent_obj_id == hull.obj_id + && d.func_group_id == row.current_phase_id + && d.item_id == row.item_id + && d.item_template_id == row.item_template_id + }); + anyhow::ensure!(matched, "saved cargo receipt changed during hull load"); + } + // System escrow alone is insufficient: the same GUID could now be stored on + // a different live hull. Include hidden/retiring registry objects in this scan. + for world in server.world.worlds() { + for rack in world.all_doodads() { + let d = rack.data(); + if !d.phase.deleted && d.item_id == row.item_id { + anyhow::ensure!( + live_hull.is_some_and(|h| d.parent_obj_id == h.obj_id) + && d.db_id == row.id + && d.owner_db_id == hull_id, + "saved cargo item is referenced by another live rack" + ); + } + } + } + let holder = server + .items + .holding_container(row.item_id) + .ok_or_else(|| anyhow::anyhow!("saved cargo item left escrow"))?; + { + let holder = holder.lock().expect("container poisoned"); + anyhow::ensure!( + holder.slot_type == slot_type::SYSTEM + && holder.get_item_by_id(row.item_id).is_some_and(|item| { + item.slot_type == slot_type::SYSTEM + && item.owner_id == u64::from(holder.owner_id) + && item.template_id == row.item_template_id + && item.class == ItemClass::Backpack + && item.count == 1 + }), + "saved cargo item no longer matches its escrow receipt" + ); + } + let occurrences: usize = server + .items + .all_containers() + .iter() + .map(|container| { + container + .lock() + .expect("container poisoned") + .items + .iter() + .filter(|item| item.id == row.item_id) + .count() + }) + .sum(); + anyhow::ensure!(occurrences == 1, "saved cargo item has multiple holders"); + } + Ok(()) + } +} + +#[cfg(test)] +pub(crate) type PersistentDoodadLoad = dyn Fn(u8, i64) -> futures::future::BoxFuture<'static, anyhow::Result> + + Send + + Sync; + /// The configured prewarm margin, clamped to [`MAX_PREWARM_REGION_MARGIN`]. pub fn prewarm_region_margin(config: &WorldConfig) -> u32 { config @@ -296,6 +505,8 @@ pub struct SpawnManagers { activation_rotation: AtomicU32, #[cfg(test)] pub(crate) test_backend: Mutex>>, + #[cfg(test)] + pub(crate) test_persistent_loader: Mutex>>, } impl std::fmt::Debug for SpawnManagers { @@ -324,6 +535,8 @@ impl Default for SpawnManagers { activation_rotation: AtomicU32::new(0), #[cfg(test)] test_backend: Mutex::new(None), + #[cfg(test)] + test_persistent_loader: Mutex::new(None), } } } @@ -360,7 +573,10 @@ impl SpawnManagers { v } - /// `lock (_spawnLock)`. + /// `lock (_spawnLock)`. Callback-bearing entries acquire the economy operation scope + /// before this lock and before their own manager/object locks. Keep this primitive bare: + /// pure bookkeeping does not enter the economy, and a caller under a character lock + /// cannot safely acquire the item scope here. Quest NPC components remain deferred. pub fn spawn_lock(&self) -> ReentrantGuard<'_> { self.spawn_lock.lock() } @@ -1277,8 +1493,8 @@ impl SpawnManager { // ----- persistent doodads ----- - /// `SpawnPersistentDoodads(ownerType, ownerId, useParentObject, doSpawn)`: the `doodads` - /// rows of an owner type (optionally of one `house_id`) into `PlayerDoodads`. + /// Compatibility entry point for startup/housing callers. Ships preload the same batch + /// before touching their old hull and call the synchronous publication method later. pub async fn spawn_persistent_doodads( &self, server: &GameServer, @@ -1287,9 +1503,41 @@ impl SpawnManager { use_parent_object: Option<&WorldObject>, do_spawn: bool, ) -> anyhow::Result { - use crate::db::{dt, int, unix}; + let prepared = self + .fetch_persistent_doodads(server, owner_type_to_spawn, owner_to_spawn_id) + .await?; + let _items = use_parent_object + .and_then(WorldObject::as_slave) + .map(|_| server.systems.economy.operation_scope()); + let _parent_scope = use_parent_object + .and_then(WorldObject::as_slave) + .map(|_| server.systems.vehicles.slave_summons.publication_scope()); + self.publish_persistent_doodads(server, prepared, use_parent_object, do_spawn) + } + + pub(crate) async fn fetch_persistent_doodads( + &self, + server: &GameServer, + owner_type_to_spawn: u8, + owner_to_spawn_id: i64, + ) -> anyhow::Result { + use crate::db::{int, min_value}; + use crate::systems::npcs::doodad::db::DoodadRow; use sqlx::Row; - + #[cfg(test)] + { + let loader = server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .expect("test persistent loader poisoned") + .clone(); + if let Some(loader) = loader { + return loader(owner_type_to_spawn, owner_to_spawn_id).await; + } + } let mut sql = String::from( "SELECT CAST(id AS SIGNED) AS id, CAST(template_id AS SIGNED) AS template_id, \ CAST(current_phase_id AS SIGNED) AS current_phase_id, x, y, z, roll, pitch, yaw, scale, \ @@ -1310,27 +1558,110 @@ impl SpawnManager { q = q.bind(owner_to_spawn_id); } let rows = q.fetch_all(&server.db).await?; + let rows = rows + .into_iter() + .map(|r| -> anyhow::Result { + let float = |column: &str| -> sqlx::Result { r.try_get(column) }; + let time = |column: &str| -> sqlx::Result { + Ok(r.try_get::, _>(column)? + .unwrap_or_else(min_value)) + }; + Ok(DoodadRow { + id: int(&r, "id")? as u32, + owner_id: int(&r, "owner_id")? as u32, + owner_type: int(&r, "owner_type")? as u8, + attach_point: int(&r, "attach_point")? as u8, + template_id: int(&r, "template_id")? as u32, + current_phase_id: int(&r, "current_phase_id")? as u32, + plant_time: time("plant_time")?, + growth_time: time("growth_time")?, + phase_time: time("phase_time")?, + x: float("x")?, + y: float("y")?, + z: float("z")?, + roll: float("roll")?, + pitch: float("pitch")?, + yaw: float("yaw")?, + scale: float("scale")?, + item_id: r.try_get("item_id")?, + house_id: int(&r, "house_id")? as u32, + parent_doodad: int(&r, "parent_doodad")? as u32, + item_template_id: int(&r, "item_template_id")? as u32, + item_container_id: r.try_get("item_container_id")?, + data: int(&r, "data")? as i32, + farm_type: int(&r, "farm_type")? as u8, + interaction_counts: r + .try_get::, _>("interaction_counts")? + .unwrap_or_else(|| "{}".into()), + }) + }) + .collect::>>()?; + PersistentDoodads::prepare(server, rows) + } + + /// Caller coordinates parent removal for the whole synchronous publication. The pointer + /// check rejects batches fetched for an earlier generation of a reused parent object id. + pub(crate) fn publish_persistent_doodads( + &self, + server: &GameServer, + prepared: PersistentDoodads, + use_parent_object: Option<&WorldObject>, + do_spawn: bool, + ) -> anyhow::Result { + use crate::db::unix; + use crate::systems::npcs::doodad::db::DoodadRow; + if let Some(parent) = use_parent_object { + anyhow::ensure!( + self.world + .object(parent.obj_id()) + .is_some_and(|live| std::ptr::eq(live.core(), parent.core())), + "persistent doodad parent is no longer live" + ); + if let Some(slave) = parent.as_slave() { + let db_id = slave.data().id; + anyhow::ensure!( + prepared + .rows + .iter() + .all(|d| d.row.owner_type == doodad_owner_type::SLAVE + && d.row.house_id == db_id), + "persistent doodad batch does not belong to this hull" + ); + } + } let mut count = 0; let mut new_coffers = Vec::new(); - for r in rows { - let template_id = int(&r, "template_id")? as u32; - let db_id = int(&r, "id")? as u32; - let f = |c: &str| -> anyhow::Result { Ok(r.try_get::(c)?) }; - let (x, y, z) = (f("x")?, f("y")?, f("z")?); - let (roll, pitch, yaw) = (f("roll")?, f("pitch")?, f("yaw")?); - let scale = f("scale")?; - let owner_id = int(&r, "owner_id")? as u32; - let owner_type = int(&r, "owner_type")? as u8; - let attach_point = int(&r, "attach_point")? as u8; - let item_id: u64 = r.try_get("item_id")?; - let house_id = int(&r, "house_id")? as u32; - let parent_doodad = int(&r, "parent_doodad")? as u32; - let item_template_id = int(&r, "item_template_id")? as u32; - let item_container_id: u64 = r.try_get("item_container_id")?; - let data = int(&r, "data")? as i32; - let farm_type = int(&r, "farm_type")? as u8; - let phase_id = int(&r, "current_phase_id")? as u32; - + for PreparedDoodad { + row, + interaction_counts, + } in prepared.rows + { + let DoodadRow { + id: db_id, + owner_id, + owner_type, + attach_point, + template_id, + current_phase_id: phase_id, + plant_time, + growth_time, + phase_time, + x, + y, + z, + roll, + pitch, + yaw, + scale, + item_id, + house_id, + parent_doodad, + item_template_id, + item_container_id, + data, + farm_type, + interaction_counts: _, + } = row; let Some(doodad) = backend::doodad_create(server, &self.world, 0, template_id, None, true) else { @@ -1346,17 +1677,14 @@ impl SpawnManager { .get() .and_then(|h| h.item_template_and_ucc(server, item_id)) .unwrap_or((item_template_id, 0)); - let plant_time = dt(&r, "plant_time"); - let growth_time = dt(&r, "growth_time"); - let phase_time = dt(&r, "phase_time"); { let mut d = doodad.data(); d.db_id = db_id; d.owner_id = owner_id; d.owner_type = owner_type; d.attach_point = attach_point; - d.plant_time = unix(plant_time); - d.growth_time_ms = growth_time.map_or(0, |t| t.and_utc().timestamp_millis().max(0)); + d.plant_time = unix(Some(plant_time)); + d.growth_time_ms = growth_time.and_utc().timestamp_millis().max(0); d.item_id = item_id; d.owner_db_id = house_id; d.scale = if scale != 0.0 { scale } else { 1.0 }; @@ -1368,16 +1696,12 @@ impl SpawnManager { // `FuncGroupId = phaseId` (setter: PhaseTime = now, Save, phase caches), then // `OverridePhaseTime = PhaseTime = phase_time`. crate::systems::npcs::doodad::manager::set_func_group_id(server, &doodad, phase_id); - let interaction_counts = r - .try_get::, _>("interaction_counts")? - .map(|json| serde_json::from_str(&json)) - .transpose()?; { - let pt = phase_time.map_or(0, |t| t.and_utc().timestamp_millis().max(0)); + let pt = phase_time.and_utc().timestamp_millis().max(0); let mut d = doodad.data(); d.phase.override_phase_time_ms = pt; d.phase_time_ms = pt; - d.phase.interaction_counts = interaction_counts.unwrap_or_default(); + d.phase.interaction_counts = interaction_counts; } let doodad_obj = WorldObject::from(&doodad); let mut has_parent = false; @@ -1454,7 +1778,7 @@ impl SpawnManager { } } // Slave AttachedDoodads - if owner_type_to_spawn == doodad_owner_type::SLAVE { + if owner_type == doodad_owner_type::SLAVE { if let Some(slave) = use_parent_object.and_then(WorldObject::as_slave) { let mut s = slave.data(); if !s.attached_doodads.contains(&doodad.obj_id) { @@ -1842,6 +2166,7 @@ impl SpawnManager { /// One iteration of `CheckRespawns` (the 1 s respawn / despawn thread). pub fn check_respawns_tick(&self, server: &GameServer) { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); for e in Self::ready( &self.respawns, @@ -1962,6 +2287,7 @@ impl SpawnManager { if group == 0 { return 0; } + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let spawners: Vec<_> = { let inner = self.inner(); @@ -2265,6 +2591,7 @@ impl SpawnManager { /// the instance is left to track, so a deliberately emptied instance cannot leave a growing /// set of placements whose 9 999 999 s respawn timers never drain). pub fn despawn_all(&self, server: &GameServer) -> usize { + let _items = server.systems.economy.operation_scope(); let _serial = server.systems.npcs.spawns.spawn_lock(); let spawns = &server.systems.npcs.spawns; let mut res = 0; @@ -2305,6 +2632,7 @@ impl SpawnManager { /// `DeleteAllSpawners()`: removes every spawner and what they spawned. pub fn delete_all_spawners(&self, server: &GameServer) { + let _items = server.systems.economy.operation_scope(); // Serialized with the activation pass so a stale queue cannot create NPCs between // despawning a placement's old members and detaching / resetting it. let _serial = server.systems.npcs.spawns.spawn_lock(); @@ -2773,6 +3101,7 @@ fn spawner_has_nonresident_live_npc( /// `World.NpcWarmRetentionSeconds` (residents stay after their first preparation) and expired /// ordinary ones are reclaimed within the same per-tick budget, counted in actual NPCs. pub fn active_region_tick_stats(server: &GameServer) -> ActivationStats { + let _items = server.systems.economy.operation_scope(); // The whole pass holds the spawners' reentrant lock: creation, despawn, placement reload and // delete-all serialize against the queued candidates (sync fn, never held across an await). let _serial = server.systems.npcs.spawns.spawn_lock(); diff --git a/rust/crates/aaemu-game/src/systems/quests/bridges.rs b/rust/crates/aaemu-game/src/systems/quests/bridges.rs index 7063a7dc20..584560163e 100644 --- a/rust/crates/aaemu-game/src/systems/quests/bridges.rs +++ b/rust/crates/aaemu-game/src/systems/quests/bridges.rs @@ -681,6 +681,8 @@ impl crate::systems::economy::cash_shop::CashShopQuestHooks for QuestsForEconomy } /// Execute authored component NPC behavior after releasing the quest owner's lock. +/// Keep this on the deferred path: `with_quests` also drops ops before calling it, so +/// callback-bearing spawners can enter item scope -> spawn lock without character inversion. pub(crate) fn run_npc_component( server: &GameServer, player: &PlayerRef, diff --git a/rust/crates/aaemu-game/src/systems/services/commands/scripts/despawn.rs b/rust/crates/aaemu-game/src/systems/services/commands/scripts/despawn.rs index 68bab59890..043b0fc4e7 100644 --- a/rust/crates/aaemu-game/src/systems/services/commands/scripts/despawn.rs +++ b/rust/crates/aaemu-game/src/systems/services/commands/scripts/despawn.rs @@ -14,6 +14,7 @@ impl Despawn { /// `ObjectIdManager.Instance.ReleaseId(obj.ObjId); obj.Delete();` pub(crate) fn release_and_delete(server: &GameServer, obj: &WorldObject) { + let _items = server.systems.economy.operation_scope(); if let WorldObject::Npc(npc) = obj { // Deviation: an NPC that still has a queued respawn / corpse timer (a dead spawner NPC) // keeps its object id until the spawn manager's timers are done with it. Releasing it diff --git a/rust/crates/aaemu-game/src/systems/services/commands/scripts/dominion.rs b/rust/crates/aaemu-game/src/systems/services/commands/scripts/dominion.rs index e97fdd924f..28f02d8b98 100644 --- a/rust/crates/aaemu-game/src/systems/services/commands/scripts/dominion.rs +++ b/rust/crates/aaemu-game/src/systems/services/commands/scripts/dominion.rs @@ -126,6 +126,7 @@ fn participation( ); return Ok(()); }; + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -309,6 +310,7 @@ impl Command for Dominion { CommandManager::send_default_help_text(self, out); return Ok(()); }; + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/services/commands/scripts/sub/slaves.rs b/rust/crates/aaemu-game/src/systems/services/commands/scripts/sub/slaves.rs index 28d34aa581..8179c6e45e 100644 --- a/rust/crates/aaemu-game/src/systems/services/commands/scripts/sub/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/services/commands/scripts/sub/slaves.rs @@ -488,8 +488,42 @@ impl SubCommand for SlaveSaveSubCommand { } /// `SlaveCmd`. +#[derive(Default)] +pub struct SlaveAuditSubCommand { + base: SubCommandBase, +} + +impl SubCommand for SlaveAuditSubCommand { + fn base(&self) -> &SubCommandBase { + &self.base + } + + fn execute_args( + &self, + ctx: &CommandContext<'_>, + _trigger: &str, + args: &[String], + out: &mut dyn MessageOutput, + ) -> anyhow::Result<()> { + use crate::systems::vehicles::audit; + // Raw args deliberately enforce exact arity (the generic typed-parameter loader + // ignores extra positional arguments). Authorization remains on the slave root. + let request = audit::Request::parse(args)?; + let snapshot = audit::snapshot(ctx.server()?, &request); + for chunk in audit::chunks(&request, &snapshot)? { + out.send_message(&chunk); + } + Ok(()) + } + + fn send_help_message(&self, out: &mut dyn MessageOutput) { + out.send_message("/slave audit ; read-only, aaemu-slave-audit/1"); + } +} + pub fn slave_cmd() -> RootCommand { RootCommand::new(&["slave"], "[slave]", "Root command to manage Slaves", "") + .register(Arc::new(SlaveAuditSubCommand::default()), &["audit"]) .register(Arc::new(SlaveInformationSubCommand::default()), &["info"]) .register( Arc::new(SlavePositionSubCommand::default()), diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/auth.rs b/rust/crates/aaemu-game/src/systems/services/webapi/auth.rs new file mode 100644 index 0000000000..1b5783b5e7 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/services/webapi/auth.rs @@ -0,0 +1,34 @@ +//! Bearer authentication for the administrative HTTP API. + +use axum::http::{header::AUTHORIZATION, HeaderMap}; +use subtle::ConstantTimeEq; + +/// Empty keys disable authenticated routes; malformed keys must never enable a listener. +pub(super) fn validate_key(key: Option<&str>) -> anyhow::Result<()> { + if let Some(key) = key.filter(|key| !key.is_empty()) { + anyhow::ensure!( + key.bytes() + .all(|b| b.is_ascii_alphanumeric() || b"-._~+/=".contains(&b)), + "WebApiNetwork.ApiKey must contain only bearer-token characters" + ); + } + Ok(()) +} + +pub(super) fn authorized(key: Option<&str>, headers: &HeaderMap) -> bool { + let Some(key) = key.filter(|key| !key.is_empty()) else { + return false; + }; + // Reject duplicate credentials rather than relying on which value a proxy selects. + let mut values = headers.get_all(AUTHORIZATION).iter(); + let Some(value) = values.next() else { + return false; + }; + if values.next().is_some() { + return false; + } + let Some((scheme, token)) = value.to_str().ok().and_then(|s| s.split_once(' ')) else { + return false; + }; + scheme.eq_ignore_ascii_case("Bearer") && bool::from(key.as_bytes().ct_eq(token.as_bytes())) +} diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/auth_tests.rs b/rust/crates/aaemu-game/src/systems/services/webapi/auth_tests.rs new file mode 100644 index 0000000000..dce5970d31 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/services/webapi/auth_tests.rs @@ -0,0 +1,341 @@ +//! Security regressions through the production route dispatcher and HTTP adapter. No live +//! stack or database is needed; privileged handlers leave observable in-memory effects. + +use std::sync::{Arc, Mutex}; + +use axum::http::{header::AUTHORIZATION, HeaderValue, Request}; +use serde_json::json; + +use super::hooks::{WebApiEconomyHooks, WebApiMail}; +use super::*; +use crate::config::{AppConfig, WebApiConfig}; +use crate::data::{items::ItemTemplate, GameData}; +use crate::systems::services::commands::{output::MessageOutput, Command, CommandContext}; +use crate::test_support::{ + spawn_player, test_character, test_server, test_server_with, TestClient, +}; + +pub(super) const TEST_KEY: &str = "synthetic-webapi-test-key"; + +pub(super) fn authenticated(mut request: HttpRequest) -> HttpRequest { + request.headers.insert( + AUTHORIZATION, + HeaderValue::from_static("Bearer synthetic-webapi-test-key"), + ); + request +} + +fn api(server: &Arc, key: Option<&str>) -> WebApiServer { + server.config.update(|c| { + c.web_api_network = Some(WebApiConfig { + api_key: key.map(str::to_owned), + ..Default::default() + }); + }); + WebApiServer::new(Arc::downgrade(server)).unwrap() +} + +fn post(url: &str, body: &str) -> HttpRequest { + HttpRequest::new("POST", url, "HTTP/1.1").with_body(body) +} + +fn invalid(mut request: HttpRequest) -> HttpRequest { + request.headers.insert( + AUTHORIZATION, + HeaderValue::from_static("Bearer synthetic-webapi-bad-key"), + ); + request +} + +fn assert_unauthorized(response: &HttpResponse) { + assert_eq!(response.status, 401); + assert_eq!(response.status_phrase, "Unauthorized"); + assert!(response.headers.iter().any(|(name, value)| { + name == "WWW-Authenticate" && value == "Bearer realm=\"AAEmu Web API\"" + })); + assert!(!response.body.contains(TEST_KEY)); +} + +struct SetHp; + +impl Command for SetHp { + fn command_names(&self) -> Vec { + vec!["auth-test".into()] + } + + fn execute( + &self, + ctx: &CommandContext<'_>, + _args: &[String], + _out: &mut dyn MessageOutput, + ) -> anyhow::Result<()> { + ctx.player()?.data().unit.hp = 42; + Ok(()) + } + + fn get_command_line_help(&self) -> String { + String::new() + } + + fn get_command_help_text(&self) -> String { + String::new() + } +} + +#[tokio::test] +async fn command_requires_credentials_before_executing_as_online_gm() { + let server = Arc::new(test_server()); + let client = TestClient::new(&server, 1, 1); + let mut character = test_character(1, "SyntheticGM", 10.0, 10.0); + character.access_level = 100; + character.unit.hp = 100; + let player = spawn_player(&server, &client, character, 0x100); + server + .systems + .services + .commands + .register("auth-test", Arc::new(SetHp)); + let api = api(&server, Some(TEST_KEY)); + let request = post( + "/api/commands/auth-test", + r#"{"character":"SyntheticGM","arguments":"fixture"}"#, + ); + for denied in [request.clone(), invalid(request.clone())] { + assert_unauthorized(&on_received_request(&api, denied).await); + assert_eq!(player.data().unit.hp, 100); + } + let response = on_received_request(&api, authenticated(request)).await; + assert_eq!(response.status, 200); + assert_eq!(player.data().unit.hp, 42); +} + +#[derive(Default)] +struct Sent(Mutex>); + +impl WebApiEconomyHooks for Sent { + fn send_mail(&self, _server: &GameServer, mail: WebApiMail) -> bool { + self.0.lock().unwrap().push(mail); + true + } +} + +#[tokio::test] +async fn mail_with_items_requires_credentials_in_http_adapter() { + let mut data = GameData::empty(); + data.items + .templates + .insert(12345, ItemTemplate::plain(12345, 20)); + let server = Arc::new(test_server_with(data)); + let sent = Arc::new(Sent::default()); + server + .systems + .services + .webapi_economy_hooks + .install(sent.clone()); + let client = TestClient::new(&server, 1, 1); + spawn_player( + &server, + &client, + test_character(1, "Bob", 10.0, 10.0), + 0x100, + ); + let api = Arc::new(api(&server, Some(TEST_KEY))); + for credential in [ + None, + Some("Bearer synthetic-webapi-bad-key"), + Some("Bearer synthetic-webapi-test-key"), + ] { + let mut builder = Request::builder().method("POST").uri("/api/mail/send"); + if let Some(credential) = credential { + // HTTP header names and the Bearer scheme are case-insensitive. + builder = builder.header("aUtHoRiZaTiOn", credential); + } + let request = builder.body(Body::from( + r#"{"Title":"fixture","Body":"fixture","RecipientType":3,"Money":5,"AttachmentItems":[{"Id":12345,"Count":2}]}"#, + )).unwrap(); + let response = dispatch(State(api.clone()), request).await; + if credential == Some("Bearer synthetic-webapi-test-key") { + assert_eq!(response.status(), 200); + let mails = sent.0.lock().unwrap(); + assert_eq!(mails.len(), 1); + assert_eq!(mails[0].receiver_name, "Bob"); + assert_eq!(mails[0].copper_coins, 5); + assert_eq!(mails[0].attachments.len(), 1); + assert_eq!(mails[0].attachments[0].template_id, 12345); + assert_eq!(mails[0].attachments[0].count, 2); + } else { + assert_eq!(response.status(), 401); + assert!(sent.0.lock().unwrap().is_empty()); + } + } +} + +#[tokio::test] +async fn all_api_routes_require_auth_even_with_legacy_regex_urls() { + let server = Arc::new(test_server()); + let api = api(&server, Some(TEST_KEY)); + for (method, url) in [ + ("POST", "/api/commands/kick"), + ("POST", "/api/mail/send"), + ("POST", "/api/mail/delete"), + ("POST", "/api/mail/list"), + ("POST", "/api/auction/add"), + ("POST", "/api/auction/generate"), + ("GET", "/api/character/list"), + ("GET", "/api/world/logged-characters"), + ("GET", "/api/expedition/list"), + ("GET", "/api/auction/list"), + ("GET", "/api/auction/search"), + ("POST", "/status?next=/api/mail/send"), + ("POST", "/prefix/API/COMMANDS/kick?status=1"), + ("POST", "/?next=/api/mail/send"), + ] { + // Invalid JSON must not be parsed before authentication. + let request = HttpRequest::new(method, url, "HTTP/1.1").with_body("invalid JSON"); + for denied in [request.clone(), invalid(request)] { + assert_unauthorized(&on_received_request(&api, denied).await); + } + } +} + +#[tokio::test] +async fn status_remains_public_and_missing_key_never_grants_api_access() { + let server = Arc::new(test_server()); + for key in [None, Some(""), Some(TEST_KEY)] { + let api = api(&server, key); + let response = + on_received_request(&api, HttpRequest::new("GET", "/status", "HTTP/1.1")).await; + assert_eq!(response.status, 200); + assert!(response.body.contains("Players online: 0")); + if key != Some(TEST_KEY) { + for url in ["/api/commands/kick", "/api/mail/send"] { + assert_unauthorized( + &on_received_request(&api, authenticated(post(url, "{}"))).await, + ); + } + } + } +} + +#[test] +fn bearer_parser_rejects_malformed_and_duplicate_credentials() { + let request = post("/api/mail/send", "{}"); + for value in [ + "", + "Bearer", + "Bearer ", + "Basic synthetic-webapi-test-key", + "Bearer synthetic-webapi-test-key", + "Bearer synthetic-webapi-test-key, synthetic-webapi-bad-key", + ] { + let mut bad = request.clone(); + bad.headers + .insert(AUTHORIZATION, HeaderValue::from_str(value).unwrap()); + assert!(!auth::authorized(Some(TEST_KEY), &bad.headers)); + } + let mut good = request; + good.headers.insert( + AUTHORIZATION, + HeaderValue::from_static("bEaReR synthetic-webapi-test-key"), + ); + assert!(auth::authorized(Some(TEST_KEY), &good.headers)); + good.headers.append( + AUTHORIZATION, + HeaderValue::from_static("Bearer synthetic-webapi-test-key"), + ); + assert!(!auth::authorized(Some(TEST_KEY), &good.headers)); +} + +#[test] +fn binding_requires_key_for_every_nonloopback_address() { + for host in [ + "*", + "0.0.0.0", + "::", + "192.0.2.1", + "2001:db8::1", + "::ffff:127.0.0.1", + ] { + for key in [None, Some("")] { + let config = WebApiConfig { + host: host.into(), + api_key: key.map(str::to_owned), + ..Default::default() + }; + assert!(bind_address(&config).is_err(), "{host}"); + } + let config = WebApiConfig { + host: host.into(), + api_key: Some(TEST_KEY.into()), + ..Default::default() + }; + assert!(bind_address(&config).is_ok(), "{host}"); + } + for host in ["127.0.0.1", "127.0.0.2", "::1"] { + assert!(bind_address(&WebApiConfig { + host: host.into(), + ..Default::default() + }) + .is_ok()); + } + for key in [" ", "key with spaces", "key\n", "key,other"] { + let config = WebApiConfig { + api_key: Some(key.into()), + ..Default::default() + }; + let error = bind_address(&config).unwrap_err().to_string(); + assert_eq!( + error, + "WebApiNetwork.ApiKey must contain only bearer-token characters" + ); + } +} + +#[tokio::test] +async fn unsafe_legacy_configuration_fails_before_listener_start() { + let server = Arc::new(test_server()); + for host in ["*", "0.0.0.0", "::", "192.0.2.1"] { + let config = + AppConfig::from_value(json!({"WebApiNetwork": {"Host": host, "Port": 0}})).unwrap(); + server + .config + .update(|c| c.web_api_network = config.web_api_network); + let service = WebApiService::default(); + let error = service.start(&server).await.unwrap_err(); + assert!(error.to_string().contains("ApiKey is required")); + assert!(!service.is_started()); + } +} + +#[tokio::test] +async fn disabled_or_absent_api_never_starts_a_listener() { + let server = Arc::new(test_server()); + for config in [ + None, + Some(WebApiConfig { + enabled: false, + host: "invalid-address".into(), + ..Default::default() + }), + ] { + server.config.update(|c| c.web_api_network = config); + let service = WebApiService::default(); + service.start(&server).await.unwrap(); + assert!(!service.is_started()); + } +} + +#[test] +fn configuration_defaults_and_diagnostics_do_not_expose_the_key() { + let config = AppConfig::from_value(json!({"WebApiNetwork": {}})).unwrap(); + let web = config.web_api_network.unwrap(); + assert_eq!((web.host.as_str(), web.port), ("127.0.0.1", 1280)); + assert!(web.enabled); + assert!(web.api_key.is_none()); + let config = + AppConfig::from_value(json!({"WebApiNetwork": {"ApiKey": TEST_KEY, "Enabled": "false"}})) + .unwrap(); + assert!(!config.web_api_network.as_ref().unwrap().enabled); + assert!(!format!("{config:?}").contains(TEST_KEY)); + assert!(!format!("{:?}", authenticated(post("/api/mail/send", "{}"))).contains(TEST_KEY)); +} diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/controllers/tests.rs b/rust/crates/aaemu-game/src/systems/services/webapi/controllers/tests.rs index a4cf2bb5da..b766683010 100644 --- a/rust/crates/aaemu-game/src/systems/services/webapi/controllers/tests.rs +++ b/rust/crates/aaemu-game/src/systems/services/webapi/controllers/tests.rs @@ -3,23 +3,30 @@ use std::sync::Arc; +use super::super::auth_tests::{authenticated, TEST_KEY}; use super::super::http::HttpRequest; use super::super::{on_received_request, WebApiServer}; use super::*; use crate::test_support::{spawn_player, test_character, test_server, TestClient}; fn api(server: &Arc) -> WebApiServer { + server.config.update(|c| { + c.web_api_network = Some(crate::config::WebApiConfig { + api_key: Some(TEST_KEY.into()), + ..Default::default() + }); + }); WebApiServer::new(Arc::downgrade(server)).unwrap() } async fn get(api: &WebApiServer, url: &str) -> HttpResponse { - on_received_request(api, HttpRequest::new("GET", url, "HTTP/1.1")).await + on_received_request(api, authenticated(HttpRequest::new("GET", url, "HTTP/1.1"))).await } async fn post(api: &WebApiServer, url: &str, body: &str) -> HttpResponse { on_received_request( api, - HttpRequest::new("POST", url, "HTTP/1.1").with_body(body), + authenticated(HttpRequest::new("POST", url, "HTTP/1.1").with_body(body)), ) .await } diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/http.rs b/rust/crates/aaemu-game/src/systems/services/webapi/http.rs index 274233bfbe..6515bc45cb 100644 --- a/rust/crates/aaemu-game/src/systems/services/webapi/http.rs +++ b/rust/crates/aaemu-game/src/systems/services/webapi/http.rs @@ -4,13 +4,14 @@ use super::json::JValue; /// `NetCoreServer.HttpRequest` (the members the controllers read). -#[derive(Debug, Clone, Default, PartialEq, Eq)] +#[derive(Clone, Default, PartialEq, Eq)] pub struct HttpRequest { /// `Method` as sent (`GET`, `POST`, ...). pub method: String, /// `Url`: the request target (path and query string, not decoded). pub url: String, pub protocol: String, + pub headers: axum::http::HeaderMap, /// `Body` (UTF-8). pub body: String, } @@ -22,6 +23,7 @@ impl HttpRequest { method: method.to_string(), url: url.to_string(), protocol: protocol.to_string(), + headers: axum::http::HeaderMap::new(), body: String::new(), } } @@ -32,6 +34,17 @@ impl HttpRequest { } } +impl std::fmt::Debug for HttpRequest { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + // Authorization values must never appear in request diagnostics. + f.debug_struct("HttpRequest") + .field("method", &self.method) + .field("url", &self.url) + .field("protocol", &self.protocol) + .finish_non_exhaustive() + } +} + /// `NetCoreServer.HttpResponse`. #[derive(Debug, Clone, PartialEq, Eq)] pub struct HttpResponse { diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/mod.rs b/rust/crates/aaemu-game/src/systems/services/webapi/mod.rs index 679633c7d6..9fa8604461 100644 --- a/rust/crates/aaemu-game/src/systems/services/webapi/mod.rs +++ b/rust/crates/aaemu-game/src/systems/services/webapi/mod.rs @@ -5,6 +5,7 @@ //! (`OnReceivedRequest`), which keeps the C# routing (regex routes on the raw URL), status //! codes and bodies. +mod auth; pub mod controllers; pub mod hooks; pub mod http; @@ -19,15 +20,17 @@ use axum::extract::State; use axum::response::Response; use tokio_util::sync::CancellationToken; -use self::http::{HttpRequest, HttpResponse}; -use self::route_mapper::{ControllerCtx, RouteMapper}; -use crate::config::NetworkConfig; +use self::http::{error_model, json_response, HttpRequest, HttpResponse}; +use self::route_mapper::{ControllerCtx, Method, RouteMapper}; +use crate::config::WebApiConfig; use crate::server::GameServer; /// `WebApiServer`: the routes plus the server the controllers reach. pub struct WebApiServer { pub route_mapper: RouteMapper, server: Weak, + /// Snapshot at listener creation; rotating the key requires a WebAPI restart. + api_key: Option, } impl WebApiServer { @@ -35,17 +38,22 @@ impl WebApiServer { pub fn new(server: Weak) -> Result { let mut route_mapper = RouteMapper::new(); route_mapper.discover_routes()?; - Ok(Self { - route_mapper, - server, - }) + Ok(Self::with_routes(route_mapper, server)) } /// `new WebApiServer(address, port, routeMapper)`. pub fn with_routes(route_mapper: RouteMapper, server: Weak) -> Self { + let api_key = server.upgrade().and_then(|s| { + s.config + .web_api_network + .as_ref() + .filter(|c| c.enabled) + .and_then(|c| c.api_key.clone()) + }); Self { route_mapper, server, + api_key, } } } @@ -62,6 +70,14 @@ pub async fn on_received_request(server: &WebApiServer, request: HttpRequest) -> response.set_body("Not found"); return Ok(response); }; + // Check the selected route, not a URL prefix: legacy regexes also match inside + // query strings and prefixed paths. Only the read-only status handler is public. + let public_status = route.method == Method::Get && route.path == "/status"; + if !(public_status || auth::authorized(server.api_key.as_deref(), &request.headers)) { + let mut response = json_response(401, &error_model("Unauthorized")); + response.set_header("WWW-Authenticate", "Bearer realm=\"AAEmu Web API\""); + return Ok(response); + } let target = route.target.clone(); let ctx = ControllerCtx { server: server.server.upgrade(), @@ -121,6 +137,7 @@ async fn dispatch( method: parts.method.as_str().to_string(), url, protocol: format!("{:?}", parts.version), + headers: parts.headers, body: String::from_utf8_lossy(&bytes).into_owned(), }; to_axum(on_received_request(&server, request).await) @@ -141,7 +158,8 @@ impl std::fmt::Debug for WebApiService { } /// `config.Host.Equals("*") ? IPAddress.Any : IPAddress.Parse(config.Host)`. -pub fn bind_address(config: &NetworkConfig) -> anyhow::Result { +pub fn bind_address(config: &WebApiConfig) -> anyhow::Result { + auth::validate_key(config.api_key.as_deref())?; let ip: IpAddr = if config.host == "*" { IpAddr::V4(Ipv4Addr::UNSPECIFIED) } else { @@ -150,6 +168,10 @@ pub fn bind_address(config: &NetworkConfig) -> anyhow::Result { .parse() .map_err(|_| anyhow::anyhow!("An invalid IP address was specified."))? }; + anyhow::ensure!( + ip.is_loopback() || config.api_key.as_ref().is_some_and(|key| !key.is_empty()), + "WebApiNetwork.ApiKey is required for a non-loopback Host; use 127.0.0.1 for local status tooling or set Enabled to false" + ); Ok(SocketAddr::new(ip, config.port)) } @@ -160,8 +182,15 @@ impl WebApiService { tracing::warn!("WebApi server configuration not found. WebApi will not start"); return Ok(()); }; + if !config.enabled { + tracing::info!("WebApi server disabled by configuration"); + return Ok(()); + } let addr = bind_address(&config)?; - let api = Arc::new(WebApiServer::new(Arc::downgrade(server))?); + let mut api = WebApiServer::new(Arc::downgrade(server))?; + // Use the same snapshot that passed the bind check even during a config reload. + api.api_key = config.api_key.clone(); + let api = Arc::new(api); let listener = match tokio::net::TcpListener::bind(addr).await { Ok(l) => l, Err(e) => { @@ -202,5 +231,7 @@ impl WebApiService { } } +#[cfg(test)] +mod auth_tests; #[cfg(test)] mod session_tests; diff --git a/rust/crates/aaemu-game/src/systems/services/webapi/session_tests.rs b/rust/crates/aaemu-game/src/systems/services/webapi/session_tests.rs index abbcd6d17a..a0f2d2384b 100644 --- a/rust/crates/aaemu-game/src/systems/services/webapi/session_tests.rs +++ b/rust/crates/aaemu-game/src/systems/services/webapi/session_tests.rs @@ -3,6 +3,7 @@ use std::sync::Weak; +use super::auth_tests::{authenticated, TEST_KEY}; use super::http::{ok_html, HttpRequest}; use super::route_mapper::{handler, Controller, Method, RouteMapper, RouteSpec}; use super::*; @@ -65,7 +66,9 @@ fn server() -> WebApiServer { mapper .discover_routes_from_type::() .unwrap(); - WebApiServer::with_routes(mapper, Weak::new()) + let mut api = WebApiServer::with_routes(mapper, Weak::new()); + api.api_key = Some(TEST_KEY.into()); + api } #[tokio::test] @@ -89,7 +92,11 @@ async fn on_received_request_when_route_found_should_return_html() { ("GET", "/test/1", "test"), ("POST", "/test/1", "test-post"), ] { - let r = on_received_request(&server(), HttpRequest::new(method, path, "HTTP/1.1")).await; + let r = on_received_request( + &server(), + authenticated(HttpRequest::new(method, path, "HTTP/1.1")), + ) + .await; assert_eq!(r.status, 200, "{method} {path}"); assert_eq!(r.status_phrase, "OK"); assert_eq!(r.content_type(), Some("text/html")); @@ -111,7 +118,11 @@ async fn on_received_request_when_route_found_with_regex_should_return_html_with ["players", "search"], ), ] { - let r = on_received_request(&server(), HttpRequest::new(method, path, "HTTP/1.1")).await; + let r = on_received_request( + &server(), + authenticated(HttpRequest::new(method, path, "HTTP/1.1")), + ) + .await; assert_eq!(r.status, 200); assert_eq!(r.status_phrase, "OK"); assert_eq!(r.content_type(), Some("text/html")); @@ -126,7 +137,11 @@ async fn on_received_request_when_route_found_with_regex_should_return_html_with #[tokio::test] async fn controller_errors_produce_the_500_page() { - let r = on_received_request(&server(), HttpRequest::new("GET", "/fail", "HTTP/1.1")).await; + let r = on_received_request( + &server(), + authenticated(HttpRequest::new("GET", "/fail", "HTTP/1.1")), + ) + .await; assert_eq!(r.status, 500); assert_eq!(r.status_phrase, "Internal Server Error"); assert_eq!(r.content_type(), Some("text/html")); @@ -168,7 +183,7 @@ async fn served_over_http() { }); let mut s = tokio::net::TcpStream::connect(addr).await.unwrap(); s.write_all( - b"POST /multipleMatches/a/b?x=1 HTTP/1.1\r\nHost: x\r\nContent-Length: 0\r\nConnection: close\r\n\r\n", + b"POST /multipleMatches/a/b?x=1 HTTP/1.1\r\nHost: x\r\nAuthorization: Bearer synthetic-webapi-test-key\r\nContent-Length: 0\r\nConnection: close\r\n\r\n", ) .await .unwrap(); diff --git a/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs b/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs new file mode 100644 index 0000000000..f1ff6490db --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/attribute_limits_tests.rs @@ -0,0 +1,607 @@ +//! Regression scenarios for the native final-raw-attribute clamp. These use the +//! real buff lifecycle, gear hook, stat evaluators and XP/haste consumers. Native +//! numeric evidence and the literal compact fixture are in data::attribute_limits. + +use std::sync::Arc; + +use crate::data::attribute_limits::{tests::fixture as limits_fixture, AttributeLimit}; +use crate::data::items::{EquipTemplate, ItemTemplate, TemplateKind}; +use crate::data::GameData; +use crate::models::container::equip_slot; +use crate::models::item::Item; +use crate::models::unit::{ + Bonus, BonusTemplate, UnitAttribute as A, UnitBase, UnitModifierType as M, +}; +use crate::systems::skills::{self, data::BuffTemplate, types::SkillCaster}; +use crate::test_support::test_experience; +use crate::world::{Entity, WorldObject}; + +use super::{stat, stats, CharInputs, CharStats, StatKind as S}; + +fn data() -> GameData { + let mut d = GameData::empty(); + let (unit, primary) = limits_fixture(); + d.characters.unit_attribute_limits = Arc::new(unit); + d.characters.p_stat_limits = primary; + d.experience = test_experience(55); + d.formulas = crate::systems::vehicles::stats::tests::formulas( + &[ + (1, "100", 22, 0), + (2, "100", 23, 0), + (3, "100", 24, 0), + (4, "100", 25, 0), + (5, "100", 26, 0), + (6, "100", 27, 0), + (7, "1000 + sta * 10", 14, 0), + (8, "100", 15, 0), + (9, "100", 18, 0), + ], + &[], + ); + d +} + +fn modifier(attr: A, kind: M, value: i32) -> BonusTemplate { + BonusTemplate { + attribute: attr, + modifier_type: kind, + value, + linear_level_bonus: 0, + } +} + +fn boost(d: &mut GameData, id: u32, modifiers: Vec) { + d.systems.skills.add_buff(BuffTemplate { + id, + kind: 1, + stack_rule: 1, + bonuses: modifiers, + ..Default::default() + }); +} + +fn apply(server: &crate::GameServer, obj: &WorldObject, id: u32) { + skills::buffs::apply_template( + server, + server.game_data.systems.skills.buff(id).unwrap(), + Some(obj), + &SkillCaster::Unit(obj.obj_id()), + obj, + None, + ); + assert!(obj.with_unit(|u| u.unit().buffs.check_buff(id)).unwrap()); +} + +#[tokio::test] +async fn attribute_limits_equipment_and_stacked_buff_flow_caps_only_final_value() { + let mut d = data(); + const ITEM: u32 = 60001; + d.items.templates.insert( + ITEM, + ItemTemplate::new(ITEM, TemplateKind::Weapon(EquipTemplate::default())), + ); + d.systems.skills.item_unit_modifiers.insert( + ITEM, + vec![ + modifier(A::MaxHealth, M::Value, 20_000_000), + modifier(A::Armor, M::Value, 2_000_000), + ], + ); + boost( + &mut d, + 60002, + vec![ + modifier(A::MaxHealth, M::Value, -15_000_000), + modifier(A::Armor, M::Value, -1_500_000), + ], + ); + boost(&mut d, 60003, vec![modifier(A::MaxHealth, M::Percent, 100)]); + let (server, _client, p, _) = skills::cast_validation_tests::fixture(d); + crate::systems::economy::bridges::install(&server); + let obj = WorldObject::from(&p); + assert_eq!( + stats(&server, &obj, &[S::MaxHp, S::Armor]), + vec![2_000.0, 100.0] + ); + + let t = server.game_data.items.template(ITEM).unwrap(); + let mut item = Item::create(42, t, 1, 0, 0, &server.game_data.items, 0); + item.class = t.class_type(); + item.owner_id = u64::from(p.character_id); + item.slot_type = crate::models::container::slot_type::EQUIPMENT; + item.slot = equip_slot::MAINHAND; + p.data() + .inventory + .equipment() + .lock() + .unwrap() + .items + .push(item.clone()); + let gear = server.systems.economy.hooks.gear.get().unwrap(); + gear.update_gear_bonuses(&server, &obj, Some(&item), None); + assert_eq!( + stats(&server, &obj, &[S::MaxHp, S::Armor]), + vec![10_000_000.0, 1_000_000.0] + ); + assert_eq!(p.data().unit.max_hp, 10_000_000); + + // The original +20M item modifier remains intact. Clamping that modifier or + // the intermediate result would produce a different answer when -15M arrives. + apply(&server, &obj, 60002); + assert_eq!( + stats(&server, &obj, &[S::MaxHp, S::Armor]), + vec![5_002_000.0, 500_100.0] + ); + apply(&server, &obj, 60003); + assert_eq!(stat(&server, &obj, S::MaxHp), 10_000_000.0); + skills::buffs::remove_buff(&server, &obj, 60003); + assert_eq!(p.data().unit.max_hp, 5_002_000); + skills::buffs::remove_buff(&server, &obj, 60002); + assert_eq!(p.data().unit.max_hp, 10_000_000); + p.data().inventory.equipment().lock().unwrap().items.clear(); + gear.update_gear_bonuses(&server, &obj, None, Some(&item)); + assert_eq!( + stats(&server, &obj, &[S::MaxHp, S::Armor]), + vec![2_000.0, 100.0] + ); + assert_eq!(p.data().unit.max_hp, 2_000); +} + +#[tokio::test] +async fn attribute_limits_extreme_buff_xp_haste_and_multiplier_units() { + let mut d = data(); + let attrs = [ + A::MoveSpeedMul, + A::MeleeSpeedMul, + A::RangedSpeedMul, + A::GlobalCooldownMul, + A::CastingTimeMul, + A::MeleeDamageMul, + A::RangedDamageMul, + A::SpellDamageMul, + A::HealMul, + A::ExpMul, + ]; + for (id, value) in [(60010, i32::MAX), (60011, i32::MIN)] { + boost( + &mut d, + id, + attrs.map(|a| modifier(a, M::Value, value)).to_vec(), + ); + } + let (server, _client, p, _) = skills::cast_validation_tests::fixture(d); + let obj = WorldObject::from(&p); + let kinds = [ + S::MoveSpeedMul, + S::GlobalCooldownMul, + S::CastTimeMul, + S::MeleeDamageMul, + S::RangedDamageMul, + S::SpellDamageMul, + S::HealMul, + ]; + assert_eq!( + stats(&server, &obj, &kinds), + vec![1.0, 100.0, 1.0, 1.0, 1.0, 1.0, 1.0] + ); + p.data().experience = 10_000; + let delay = |id| { + skills::skill::attack_delay( + &server, + &skills::data::SkillTemplate { + id, + ..Default::default() + }, + &obj, + false, + 0.0, + ) + }; + assert_eq!(delay(2), 1500.0); + assert_eq!(delay(4), 1800.0); + let base = skills::progress::add_exp_locked(&server, &mut p.data(), 100, false).unwrap(); + assert_eq!(base.exp, 100); + + apply(&server, &obj, 60010); + assert_eq!( + stats(&server, &obj, &kinds), + vec![3.0, 20.0, 5.0, 6.0, 6.0, 6.0, 6.0] + ); + for attr in [A::MeleeSpeedMul, A::RangedSpeedMul] { + assert_eq!(p.data().unit.calculate_with_bonuses(0.0, attr, 0), 4000.0); + } + assert_eq!(delay(2), 60.0); // 1500 * GCD(.2) * haste(.2) + assert_eq!(delay(4), 72.0); + let gain = skills::progress::add_exp_locked(&server, &mut p.data(), 100, false).unwrap(); + assert_eq!(gain.exp, 500); + skills::buffs::remove_buff(&server, &obj, 60010); + + apply(&server, &obj, 60011); + let values = stats(&server, &obj, &kinds); + for (value, expected) in values + .into_iter() + .zip([-10.0, 500.0, 0.4, 0.0, 0.0, 0.0, 0.2]) + { + assert!((value - expected).abs() < 1e-6, "{value} != {expected}"); + } + for attr in [A::MeleeSpeedMul, A::RangedSpeedMul] { + assert_eq!(p.data().unit.calculate_with_bonuses(0.0, attr, 0), -800.0); + } + assert_eq!(delay(2), 37500.0); // 1500 * GCD(5) * haste(5) + assert_eq!(delay(4), 45000.0); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut p.data(), 100, false) + .unwrap() + .exp, + 0 + ); + // XP loss still bypasses bonuses; positive gain still saturates before i32 conversion. + assert_eq!( + skills::progress::add_exp_locked(&server, &mut p.data(), -10, false) + .unwrap() + .exp, + -10 + ); + skills::buffs::remove_buff(&server, &obj, 60011); + assert_eq!( + stats(&server, &obj, &kinds), + vec![1.0, 100.0, 1.0, 1.0, 1.0, 1.0, 1.0] + ); +} + +#[tokio::test] +async fn attribute_limits_detached_xp_and_character_formulas_use_server_data() { + let server = crate::test_support::test_server_with(data()); + let mut c = crate::test_support::test_character(1, "Detached", 0.0, 0.0); + c.experience = 10_000; + c.unit.bonuses.add_bonus( + 1, + Bonus { + template: modifier(A::ExpMul, M::Value, 10000), + value: 10000, + }, + ); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, 100, false) + .unwrap() + .exp, + 500 + ); + assert!(Arc::ptr_eq( + &c.unit.bonuses.attribute_limits, + &server.game_data.characters.unit_attribute_limits + )); + for (attr, value) in [ + (A::Str, 10_000), + (A::Dex, -101), + (A::MoveSpeedMul, 99999), + (A::MaxHealth, 99999999), + ] { + c.unit.bonuses.add_bonus( + 2, + Bonus { + template: modifier(attr, M::Value, value), + value, + }, + ); + } + let mut calc = CharStats::new(&server, &c, CharInputs::default(), 0); + assert_eq!(calc.get(S::Str), 10_100.0); // pStat limits cannot cap equipment/buffs + assert_eq!(calc.get(S::Dex), -1.0); + assert_eq!(calc.get(S::MoveSpeedMul), 3.0); + assert_eq!(calc.get(S::MaxHp), 10_000_000.0); + + // Explicit evaluator data must also work before any mutable path has bound + // this unit, and must not reuse the limits from another GameServer. + let mut other = data(); + Arc::make_mut(&mut other.characters.unit_attribute_limits) + .attributes + .insert( + A::MaxHealth, + AttributeLimit { + minimum: 0, + maximum: 5000, + }, + ); + let other = crate::test_support::test_server_with(other); + assert_eq!( + CharStats::new(&other, &c, CharInputs::default(), 0).get(S::MaxHp), + 5000.0 + ); + assert_eq!( + CharStats::new(&server, &c, CharInputs::default(), 0).get(S::MaxHp), + 10_000_000.0 + ); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, i32::MAX, false) + .unwrap() + .exp, + i32::MAX + ); + assert!(c.experience >= 10_000); // positive gain cannot wrap into negative XP +} + +#[tokio::test] +async fn attribute_limits_detached_npc_and_vehicle_getters_widen_before_final_cap() { + use crate::models::npc::Npc; + use crate::systems::npcs::npc::{data::NpcTemplate, stats as npc_stats}; + use crate::systems::vehicles::stats::{refresh_pools, stats_of, VehicleKind}; + let mut d = data(); + // Synthetic extreme formulas make incorrect character-only 10000 caps and + // overflow in the separate NPC/vehicle integer loops observable. + let mut rows = vec![]; + let mut id = 1; + for owner in [1, 2, 4, 5, 6] { + for (formula, kind) in [("20000", 22), ("1000", 14), ("100", 18)] { + rows.push((id, formula, kind, owner)); + id += 1; + } + } + d.formulas = crate::systems::vehicles::stats::tests::formulas(&rows, &[]); + d.systems.npcs.npc.templates.insert( + 1, + NpcTemplate { + id: 1, + ..Default::default() + }, + ); + let server = crate::test_support::test_server_with(d); + let mut npc = Npc::new(1); + let baseline = npc_stats::npc_stats(&server.game_data, &npc).unwrap(); + assert_eq!( + (baseline.str_, baseline.max_hp, baseline.armor), + (20000, 1000, 100) + ); + for attr in [A::MaxHealth, A::Armor] { + for index in 1..=2 { + npc.unit.bonuses.add_bonus( + index, + Bonus { + template: modifier(attr, M::Value, i32::MAX), + value: i32::MAX, + }, + ); + } + } + let boosted = npc_stats::npc_stats(&server.game_data, &npc).unwrap(); + assert_eq!( + (boosted.str_, boosted.max_hp, boosted.armor), + (20000, 10_000_000, 1_000_000) + ); + npc_stats::refresh_cached_stats(&server.game_data, &mut npc); + assert_eq!(npc.unit.max_hp, 10_000_000); + assert!(Arc::ptr_eq( + &npc.unit.bonuses.attribute_limits, + &server.game_data.characters.unit_attribute_limits + )); + + for kind in [ + VehicleKind::Mate { mate_kind_id: 1 }, + VehicleKind::Slave, + VehicleKind::Transfer, + VehicleKind::Shipyard, + ] { + let mut u = UnitBase::default(); + assert_eq!( + stats_of(&server, kind, &u, &[S::Str, S::MaxHp]), + vec![20000.0, 1000.0] + ); + for index in 1..=2 { + u.bonuses.add_bonus( + index, + Bonus { + template: modifier(A::MaxHealth, M::Value, i32::MAX), + value: i32::MAX, + }, + ); + } + assert_eq!( + stats_of(&server, kind, &u, &[S::Str, S::MaxHp]), + vec![20000.0, 10_000_000.0] + ); + refresh_pools(&server, kind, &mut u); + assert_eq!(u.max_hp, 10_000_000); + assert!(Arc::ptr_eq( + &u.bonuses.attribute_limits, + &server.game_data.characters.unit_attribute_limits + )); + u.bonuses.statics.clear(); + for index in 1..=2 { + u.bonuses.add_bonus( + index, + Bonus { + template: modifier(A::MaxHealth, M::Value, i32::MIN), + value: i32::MIN, + }, + ); + } + refresh_pools(&server, kind, &mut u); + assert_eq!(u.max_hp, -2_000_000_000); + } +} + +#[test] +fn attribute_limits_dynamic_percent_order_and_extreme_stacks_remain_finite() { + use crate::models::unit::{DynamicBonus, DynamicBonusTemplate, LinearFuncTemplate}; + let (limits, _) = limits_fixture(); + let mut u = UnitBase::default(); + u.bonuses.bind_attribute_limits(&Arc::new(limits)); + for (index, kind, value) in [ + (1, M::Percent, 100), + (2, M::Value, 2000), + (3, M::Value, -2500), + ] { + u.bonuses.add_bonus( + index, + Bonus { + template: modifier(A::MoveSpeedMul, kind, value), + value, + }, + ); + } + u.bonuses.add_dynamic_bonus( + 4, + DynamicBonus { + template: DynamicBonusTemplate { + attribute: A::MoveSpeedMul, + modifier_type: M::Percent, + func_id: 1, + func_type: "LinearFunc".into(), + }, + source_buff_index: 4, + source_start_ms: 0, + source_duration: 1000, + linear_func: Some(LinearFuncTemplate { + id: 1, + start_value: 100, + end_value: 100, + }), + manual_values: None, + source_tick_ms: 100.0, + }, + ); + // (1000 + 2000 - 2500) * 2 * 2; no intermediate clamp despite reaching 3000. + assert_eq!( + u.calculate_with_bonuses(1000.0, A::MoveSpeedMul, 500), + 2000.0 + ); + for index in 5..150 { + u.bonuses.add_bonus( + index, + Bonus { + template: modifier(A::MoveSpeedMul, M::Percent, i32::MAX), + value: i32::MAX, + }, + ); + } + assert_eq!( + u.calculate_with_bonuses(1000.0, A::MoveSpeedMul, 500), + 3000.0 + ); + assert_eq!( + u.calculate_with_bonuses(f64::NAN, A::MoveSpeedMul, 500), + 0.0 + ); +} + +#[tokio::test] +async fn attribute_limits_ai_movement_matches_stat_getter_at_raw_boundaries() { + use crate::systems::ai::npc; + + // Literal native limits: complete MoveSpeedMul starts at 1000 and is bounded + // to -10000..3000 before /1000. Adding 1 after clamping a zero-based bonus + // made +5000 move at 4x while the stat getter correctly reported 3x. + let cases = [ + (0, 0, 1.0), + (500, 0, 1.5), + (2000, 0, 3.0), + (2001, 0, 3.0), + (5000, 0, 3.0), + (-500, 0, 0.5), + (-1000, 0, 0.0), + (-10999, 0, -9.999), + (-11000, 0, -10.0), + (-11001, 0, -10.0), + (0, 50, 1.5), + (500, 100, 3.0), + (0, -50, 0.5), + ]; + let mut d = data(); + for (index, (flat, percent, _)) in cases.iter().enumerate() { + boost( + &mut d, + 60100 + index as u32, + vec![ + modifier(A::MoveSpeedMul, M::Value, *flat), + modifier(A::MoveSpeedMul, M::Percent, *percent), + ], + ); + } + let (server, _client, _player, n) = skills::cast_validation_tests::fixture(d); + let obj = WorldObject::from(&n); + for (index, (flat, percent, expected_mul)) in cases.into_iter().enumerate() { + let buff_id = 60100 + index as u32; + assert_eq!(npc::real_movement_speed(&obj, 4.5), 4.5); + apply(&server, &obj, buff_id); + for base in [0.0, 0.75, 4.5] { + // Exercise the actual AI helper before evaluating the separate getter. + let actual = npc::real_movement_speed(&obj, base); + let expected = base * expected_mul; + let stat_speed = base * stat(&server, &obj, S::MoveSpeedMul); + assert!( + (actual - expected).abs() < 1e-5, + "flat {flat}, percent {percent}, base {base}: {actual} != {expected}" + ); + assert!( + (actual - stat_speed).abs() < 1e-5, + "AI {actual} != stat-derived speed {stat_speed}" + ); + } + skills::buffs::remove_buff(&server, &obj, buff_id); + assert_eq!(npc::real_movement_speed(&obj, 4.5), 4.5); + } +} + +#[tokio::test] +async fn attribute_limits_are_per_server_for_every_spawned_unit_kind() { + let a = data(); + let mut b = data(); + Arc::make_mut(&mut b.characters.unit_attribute_limits) + .attributes + .insert( + A::MoveSpeedMul, + AttributeLimit { + minimum: -500, + maximum: 1250, + }, + ); + let sa = crate::test_support::test_server_with(a); + let sb = crate::test_support::test_server_with(b); + use crate::models::{ + gimmick::Gimmick, + house::House, + mate::Mate, + npc::Npc, + shipyard::{Shipyard, ShipyardData}, + slave::Slave, + transfer::Transfer, + }; + let objects = vec![ + WorldObject::from(Entity::new(100, Npc::new(1))), + WorldObject::from(Entity::new(101, Mate::new(1, 1))), + WorldObject::from(Entity::new(102, Slave::new(1, 1))), + WorldObject::from(Entity::new(103, House::new(1, 1))), + WorldObject::from(Entity::new(104, Transfer::new(1))), + WorldObject::from(Entity::new(105, Shipyard::new(ShipyardData::default()))), + WorldObject::from(Entity::new(106, Gimmick::new(1))), + ]; + for obj in objects { + obj.with_unit(|u| { + u.unit_mut().bonuses.add_bonus( + 1, + Bonus { + template: modifier(A::MoveSpeedMul, M::Value, 5000), + value: 5000, + }, + ); + }); + for (server, expected) in [(&sa, 3000.0), (&sb, 1250.0), (&sa, 3000.0)] { + server + .world + .world(0) + .unwrap() + .spawn(&obj, &server.view_ctx()); + assert_eq!( + obj.with_unit(|u| u.unit().calculate_with_bonuses(1000.0, A::MoveSpeedMul, 0)), + Some(expected) + ); + assert!(obj + .with_unit(|u| Arc::ptr_eq( + &u.unit().bonuses.attribute_limits, + &server.game_data.characters.unit_attribute_limits + )) + .unwrap()); + server.world.world(0).unwrap().delete(&obj); + } + } +} diff --git a/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs b/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs new file mode 100644 index 0000000000..ec1efef273 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/buff_breaker_tests.rs @@ -0,0 +1,1208 @@ +//! Authored 1.2 breaker relations. IDs/tags below are pinned again by the ignored compact +//! regression. No packet round trips: BuffRemoved's native reader is 397C6360, handler +//! 391D5E90 (x2game12.c:1763754-1763769 / 382144-382148): 3-byte owner, u32 buff index. +//! Relation loaders: native 1.2 395D17B0 (x2game12.c:1256462-1256496), 10.x 39B41DE0 +//! (x2game-dev_dedicate.c:2323838-2323904). Those prove ownership/direction only. Traced +//! 10.x ZoneBuffMan::Create 39450740 and its tick 3944FC90 do not establish a breaker-set +//! consumer. Immediate accepted-state reconciliation is the server compatibility policy; +//! exact retail apply-vs-tick timing remains a native-parity limitation. + +use std::sync::Arc; +use std::time::Duration; + +use crate::data::GameData; +use crate::models::buff::Buff; +use crate::models::npc::Npc; +use crate::models::unit::{ + BonusTemplate, BuffAttribute, BuffModifier, CombatBuffTemplate, SkillAttribute, SkillModifier, + UnitAttribute, UnitModifierType, +}; +use crate::opcodes::sc; +use crate::server::GameServer; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::{now_ms, Entity, MateRef, WorldObject}; + +use super::super::controllers::{self, ScState}; +use super::super::data::effects::{BuffEffect, DispelEffect}; +use super::super::data::{ + BuffTemplate, BuffTolerance, BuffTriggerTemplate, EffectKind, EffectTemplate, SkillTemplate, + TickEffect, +}; +use super::super::state::{ + CancelToken, SkillRef, SkillRun, SkillTaskKind, SkillTaskSlot, ToleranceCounter, +}; +use super::super::types::{BuffEventTriggerKind, SkillCaster}; + +const SONGS: [u32; 4] = [656, 662, 667, 778]; +const GLIDER: u32 = 1029; +const STUN: u32 = 93; +const SLEEP: u32 = 84; // Leech: Sleep tag 97, despite its stun flag in the export. +const SILENCE: u32 = 245; +const IRRELEVANT: u32 = 60_001; +const IMMUNITY: u32 = 60_002; +const ORIGINAL_TAG: u32 = 60_030; +const MARKER: u32 = 60_031; +const MARKER_TAG: u32 = 60_032; +const TRIGGER_EFFECT: u32 = 60_033; +const MODIFIER_TARGET: u32 = 60_034; + +fn data() -> GameData { + let mut data = GameData::empty(); + let d = &mut data.systems.skills; + for id in SONGS { + d.add_buff(BuffTemplate { + id, + kind: 3, + duration: 15_000, + tick: 500.0, + stack_rule: 1, + max_stack: 1, + bonuses: vec![BonusTemplate { + attribute: UnitAttribute::Str, + modifier_type: UnitModifierType::Value, + value: 100, + linear_level_bonus: 0, + }], + ..BuffTemplate::default() + }); + d.buff_breakers + .insert(id, vec![6, 12, 13, 97, 99, 107, 150, 346]); + } + d.add_buff(BuffTemplate { + id: GLIDER, + kind: 1, + duration: 180_000, + gliding: true, + stack_rule: 1, + max_stack: 1, + ..BuffTemplate::default() + }); + d.buff_breakers + .insert(GLIDER, vec![6, 12, 13, 27, 97, 99, 107, 150, 346]); + d.buff_tags.insert(GLIDER, vec![10, 294]); + for (id, duration) in [(431, 15_000), (2170, 10_000)] { + d.add_buff(BuffTemplate { + id, + kind: 1, + duration, + ..BuffTemplate::default() + }); + d.buff_breakers.insert(id, vec![294]); + } + for (id, tag, duration, stun, silence) in [ + (STUN, 6, 4000, true, false), + (SLEEP, 97, 5000, true, false), + (SILENCE, 99, 3500, false, true), + (IRRELEVANT, 60_000, 10_000, true, false), + ] { + d.add_buff(BuffTemplate { + id, + kind: 2, + duration, + stun, + silence, + stack_rule: 1, + max_stack: 1, + ..BuffTemplate::default() + }); + d.buff_tags.insert(id, vec![tag]); + d.tagged_buffs.insert(tag, vec![id]); + } + data +} + +fn fixture(data: GameData) -> (Arc, TestClient, WorldObject) { + let server = Arc::new(test_server_with(data)); + server.set_self(); + crate::systems::skills::bind(&server); + let client = TestClient::new(&server, 1, 1); + let owner = spawn_player( + &server, + &client, + test_character(1, "Bard", 100.0, 100.0), + 0x300, + ); + // Visibility serialization can add its synthetic state buffs. Start this fixture's + // bookkeeping at index 2 so the native removal-body expectations remain literal. + owner.data().unit.buffs = crate::models::buff::Buffs::default(); + (server, client, WorldObject::from(&owner)) +} + +fn add(server: &GameServer, owner: &WorldObject, id: u32) { + super::add_buff_by_id(server, owner, id, owner, 0); +} + +fn has(owner: &WorldObject, id: u32) -> bool { + owner.with_base_unit(|u| u.buffs().check_buff(id)) +} + +fn removed(client: &mut TestClient) -> Vec> { + client + .drain() + .into_iter() + .filter_map(|(op, body)| (op == sc::SCBuffRemovedPacket).then_some(body)) + .collect() +} + +// Unit-caster Created prefix from native 397CA670 -> 397C85B0 / 397C9070: +// caster kind+bc, caster DB id, owner bc, index u32, buff id u32. Removed: owner bc,index. +// Read the emitted notices; expected IDs/order below are independent literals. +fn notices(client: &mut TestClient) -> Vec<(u16, u32, u32)> { + client + .drain() + .into_iter() + .filter_map(|(op, body)| { + if op == sc::SCBuffCreatedPacket { + assert_eq!(body[0], 0, "fixture uses unit casters"); + Some(( + op, + u32::from_le_bytes(body[15..19].try_into().unwrap()), + u32::from_le_bytes(body[11..15].try_into().unwrap()), + )) + } else if op == sc::SCBuffRemovedPacket { + assert_eq!(body.len(), 7); + Some((op, 0, u32::from_le_bytes(body[3..7].try_into().unwrap()))) + } else { + None + } + }) + .collect() +} + +fn trigger(d: &mut GameData, kind: BuffEventTriggerKind, effect: (EffectKind, u32), no_tag: u32) { + d.systems + .skills + .buff_triggers + .entry(SONGS[0]) + .or_default() + .push(BuffTriggerTemplate { + id: effect.1, + kind: kind as u16, + effect_on_source: false, + effect, + use_damage_amount: false, + use_original_source: false, + target_buff_tag_id: 0, + target_no_buff_tag_id: no_tag, + synergy: false, + }); +} + +fn trigger_buff( + d: &mut GameData, + kind: BuffEventTriggerKind, + effect_id: u32, + buff_id: u32, + no_tag: u32, +) { + d.systems.skills.add_effect( + EffectKind::BuffEffect, + EffectTemplate::Buff(BuffEffect { + id: effect_id, + buff_id: Some(buff_id), + chance: 100, + stack: 1, + ab_level: 0, + }), + 0, + ); + trigger(d, kind, (EffectKind::BuffEffect, effect_id), no_tag); +} + +fn reentrant_data() -> GameData { + let mut d = data(); + let skills = &mut d.systems.skills; + let original = Arc::make_mut(skills.buffs.get_mut(&SONGS[0]).unwrap()); + original.stun = true; // Would unmount/interrupt if the removed Started hook resumed. + original.gliding = true; // Would start a controller for non-character owners. + original.tick = 10.0; + original.tick_effects = vec![TickEffect { + effect_id: TRIGGER_EFFECT + 1, + target_buff_tag_id: 0, + target_no_buff_tag_id: 0, + }]; + skills.add_effect( + EffectKind::BuffEffect, + EffectTemplate::Buff(BuffEffect { + id: TRIGGER_EFFECT + 1, + buff_id: Some(MARKER), + chance: 100, + stack: 1, + ab_level: 0, + }), + TRIGGER_EFFECT + 1, + ); + Arc::make_mut(skills.buffs.get_mut(&IRRELEVANT).unwrap()).stun = false; + skills.buff_tags.insert(IRRELEVANT, vec![6]); + skills.tagged_buffs.insert(6, vec![STUN, IRRELEVANT]); + skills.buff_tags.insert(SONGS[0], vec![ORIGINAL_TAG]); + skills.tagged_buffs.insert(ORIGINAL_TAG, vec![SONGS[0]]); + skills.add_buff(BuffTemplate { + id: MARKER, + kind: 1, + ..Default::default() + }); + skills.buff_tags.insert(MARKER, vec![MARKER_TAG]); + skills.tagged_buffs.insert(MARKER_TAG, vec![MARKER]); + skills.skill_modifiers.insert( + SONGS[0], + vec![SkillModifier { + id: MODIFIER_TARGET, + owner_id: SONGS[0], + tag_id: 0, + skill_attribute: SkillAttribute::CastTime, + unit_modifier_type: UnitModifierType::Value, + value: 17, + skill_id: MODIFIER_TARGET, + synergy: false, + }], + ); + skills.buff_game_data.buff_modifiers.insert( + SONGS[0], + vec![BuffModifier { + id: MODIFIER_TARGET, + owner_id: SONGS[0], + tag_id: 0, + buff_attribute: BuffAttribute::Duration, + unit_modifier_type: UnitModifierType::Value, + value: 23, + buff_id: MODIFIER_TARGET, + synergy: false, + }], + ); + skills.combat_buffs.insert( + SONGS[0], + vec![CombatBuffTemplate { + id: MODIFIER_TARGET, + hit_skill_id: 0, + hit_type: 1, + req_skill_id: 0, + buff_id: MARKER, + buff_from_source: false, + buff_to_source: false, + req_buff_id: SONGS[0], + is_heal_spell: false, + }], + ); + trigger_buff( + &mut d, + BuffEventTriggerKind::Started, + TRIGGER_EFFECT, + IRRELEVANT, + MARKER_TAG, + ); + d +} + +fn channel(server: &GameServer, owner: &WorldObject, matching: bool) -> (SkillRef, CancelToken) { + let skill = SkillRun::new( + Arc::new(SkillTemplate { + id: MODIFIER_TARGET, + channeling_buff_id: if matching { + SONGS[0] + } else { + MODIFIER_TARGET + 1 + }, + channeling_time: 30_000, + ..Default::default() + }), + 1, + ); + skill.state().tl_id = server + .systems + .skills + .tl_ids + .next_id(owner.obj_id(), skill.template.id); + let cancel = CancelToken::new(); + owner.with_unit(|u| { + u.unit_mut().skill_state.skill_task = Some(SkillTaskSlot { + kind: SkillTaskKind::EndChanneling { channel_doodad: 0 }, + skill: skill.clone(), + cancel: cancel.clone(), + }); + }); + (skill, cancel) +} + +fn queue_original(server: &GameServer, owner: &WorldObject, skill: Option<&SkillRef>) -> Buff { + let template = server.game_data.systems.skills.buff(SONGS[0]).unwrap(); + let mut b = super::new_buff( + server, + template, + Some(owner), + &SkillCaster::Unit(owner.obj_id()), + skill.map(|s| s.as_ref()), + now_ms(), + ); + b.duration = template.duration; + owner.with_base_unit(|u| u.buffs_mut().add_buff_with_duration(b, 0, now_ms())); + super::get_buff(owner, 2).unwrap() +} + +fn assert_no_original_state(server: &GameServer, owner: &WorldObject, original: &Buff) { + assert!(!has(owner, SONGS[0])); + assert!(!super::check_buff_tag(server, owner, ORIGINAL_TAG)); + assert!(controllers::active(owner).is_none()); + assert!(!owner.with_base_unit(|u| u.buffs().has_events())); + let (skill_mod, buff_mod, bonus, combat) = owner + .with_unit(|u| { + let u = u.unit(); + ( + u.skill_modifiers + .apply(MODIFIER_TARGET, &[], SkillAttribute::CastTime, 0.0), + u.buff_modifiers + .apply(MODIFIER_TARGET, &[], BuffAttribute::Duration, 0.0), + u.bonuses.calculate(0.0, UnitAttribute::Str, now_ms()), + u.combat_buffs + .by_hit_type + .values() + .map(Vec::len) + .sum::(), + ) + }) + .unwrap(); + assert_eq!((skill_mod, buff_mod, bonus, combat), (0.0, 0.0, 0.0, 0)); + assert!(!server + .systems + .skills + .triggers + .lock() + .unwrap() + .iter() + .any(|s| { s.owner_obj == owner.obj_id() && s.buff_instance_id == original.instance_id })); + super::dispel_task(server, owner.obj_id(), original.index, original.task_gen); + assert!(!has(owner, SONGS[0])); +} + +fn npc_owner(server: &GameServer) -> WorldObject { + let mut npc = Npc::new(1); + npc.unit.hp = 100; + npc.unit.max_hp = 100; + npc.unit.transform.set_xyz(100.0, 100.0, 100.0); + let owner = WorldObject::from(Entity::new(0x400, npc)); + server + .world + .world(0) + .unwrap() + .spawn(&owner, &server.view_ctx()); + owner +} + +fn mount_data(d: &mut GameData) { + use crate::data::items::{ItemTemplate, TemplateKind}; + use crate::systems::npcs::npc::data::NpcTemplate; + d.experience = crate::test_support::test_experience(55); + d.formulas = crate::systems::vehicles::stats::tests::formulas( + &[(1, "1000", 14, 5), (2, "100", 15, 5)], + &[], + ); + d.systems.npcs.npc.templates.insert( + 60_090, + NpcTemplate { + id: 60_090, + name: "Horse".into(), + level: 1, + model_id: 77, + scale: 1.0, + ..Default::default() + }, + ); + d.items.templates.insert( + 60_091, + ItemTemplate { + kind: TemplateKind::SummonMate { npc_id: 60_090 }, + ..ItemTemplate::plain(60_091, 1) + }, + ); +} + +fn mount(server: &GameServer, owner: &WorldObject) -> MateRef { + use crate::models::container::slot_type; + use crate::models::item::Item; + use crate::systems::vehicles::{data::attach_point, mates}; + let player = owner.as_player().unwrap(); + let template = server.game_data.items.template(60_091).unwrap(); + let mut item = Item::create(0x7001, template, 1, 0, 1, &server.game_data.items, 0); + item.slot_type = slot_type::INVENTORY; + item.slot = 0; + let bag = player + .data() + .inventory + .get(slot_type::INVENTORY) + .cloned() + .unwrap(); + bag.lock().unwrap().items.push(item); + mates::spawn_mount(server, player, 0x7001); + let mate = server + .systems + .vehicles + .mates + .get(0) + .get_active_mates(player.character_id) + .pop() + .unwrap(); + let tl = u32::from(mate.data().unit.tl_id); + mates::mount_mate(server, player, tl, attach_point::DRIVER, 1); + assert!(player.data().is_riding); + mate +} + +#[tokio::test] +async fn buff_breakers_bard_songs_end_on_real_stun_sleep_and_silence_tags() { + for cc in [STUN, SLEEP, SILENCE] { + for song in SONGS { + let (server, mut client, owner) = fixture(data()); + add(&server, &owner, song); + let song_buff = owner.with_base_unit(|u| u.buffs().effects[0].clone()); + client.drain(); + add(&server, &owner, cc); + assert!(!has(&owner, song), "song {song}, CC {cc}"); + assert!(has(&owner, cc)); + assert_eq!(removed(&mut client), vec![vec![0, 3, 0, 2, 0, 0, 0]]); + assert_eq!( + owner.with_unit(|u| u + .unit() + .bonuses + .calculate(0.0, UnitAttribute::Str, now_ms())), + Some(0.0) + ); + // A queued song timer may no longer tick, resurrect, or remove twice. + super::dispel_task(&server, owner.obj_id(), song_buff.index, song_buff.task_gen); + assert!(removed(&mut client).is_empty()); + assert!(!has(&owner, song)); + } + } +} + +#[tokio::test] +async fn buff_breakers_glider_controller_stops_through_normal_dispel() { + let (server, _client, _player) = fixture(data()); + let mut npc = Npc::new(1); + npc.unit.hp = 100; + npc.unit.max_hp = 100; + npc.unit.transform.set_xyz(100.0, 100.0, 100.0); + let npc = Entity::new(0x400, npc); + let owner = WorldObject::from(&npc); + server + .world + .world(0) + .unwrap() + .spawn(&owner, &server.view_ctx()); + add(&server, &owner, GLIDER); + let controller = controllers::active(&owner).unwrap(); + assert_eq!(controller.source_buff_id(), GLIDER); + assert_eq!(controller.state(), ScState::Running); + add(&server, &owner, SILENCE); + assert!(!has(&owner, GLIDER)); + assert_eq!(controller.state(), ScState::Ended); + assert!(controllers::active(&owner).is_none()); + tokio::time::sleep(Duration::from_millis(70)).await; + assert_eq!(npc.data().unit.transform.z, 100.0); +} + +#[tokio::test] +async fn buff_breakers_ignore_irrelevant_tags_and_rejected_incoming_buffs() { + let mut d = data(); + d.systems.skills.add_buff(BuffTemplate { + id: IMMUNITY, + kind: 1, + immune_buff_tag_id: 99, + ..BuffTemplate::default() + }); + let (server, mut client, owner) = fixture(d); + add(&server, &owner, SONGS[0]); + add(&server, &owner, IRRELEVANT); + assert!(has(&owner, SONGS[0]), "CC flags alone are not breaker tags"); + add(&server, &owner, IMMUNITY); + client.drain(); + let silence = server.game_data.systems.skills.buff(SILENCE).unwrap(); + super::apply_template( + &server, + silence, + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + &owner, + None, + ); + assert!(has(&owner, SONGS[0])); + assert!(!has(&owner, SILENCE)); + assert!(removed(&mut client).is_empty()); + + let mut d = data(); + Arc::make_mut(d.systems.skills.buffs.get_mut(&SILENCE).unwrap()).require_buff_id = 60_004; + let (server, mut client, owner) = fixture(d); + add(&server, &owner, SONGS[0]); + client.drain(); + let rejected = server.game_data.systems.skills.buff(SILENCE).unwrap(); + super::apply_template( + &server, + rejected, + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + &owner, + None, + ); + assert!(has(&owner, SONGS[0])); + assert!(!has(&owner, SILENCE)); + assert!(removed(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_tolerance_rejection_does_not_end_song() { + let mut d = data(); + d.systems.skills.buff_game_data.tolerances.insert( + 6, + BuffTolerance { + id: 1, + buff_tag_id: 6, + step_duration: 60, + final_step_buff_id: IMMUNITY, + character_time_reduction: 0, + steps: vec![(1, 100, 0)], + }, + ); + let (server, mut client, owner) = fixture(d); + owner.with_unit(|u| { + u.unit_mut().skill_state.tolerance_counters.insert( + 1, + ToleranceCounter { + tolerance_id: 1, + current_step: (1, 100, 0), + last_step_ms: now_ms(), + }, + ); + }); + add(&server, &owner, SONGS[0]); + client.drain(); + add(&server, &owner, STUN); // No next tolerance step: existing rejection path. + assert!(!has(&owner, STUN)); + assert!(has(&owner, SONGS[0])); + assert!(removed(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_cancel_only_the_corresponding_channel_without_reentering_removal() { + let mut d = data(); + // Snare tag 27 is authored for gliders, without the generic stun/silence interrupt. + Arc::make_mut(d.systems.skills.buffs.get_mut(&IRRELEVANT).unwrap()).stun = false; + d.systems.skills.buff_tags.insert(IRRELEVANT, vec![27]); + let (server, mut client, owner) = fixture(d); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + id: 60_010, + channeling_buff_id: GLIDER, + channeling_time: 10_000, + ..SkillTemplate::default() + }), + 1, + ); + skill.state().tl_id = server + .systems + .skills + .tl_ids + .next_id(owner.obj_id(), skill.template.id); + let cancel = CancelToken::new(); + owner.with_unit(|u| { + u.unit_mut().skill_state.skill_task = Some(SkillTaskSlot { + kind: SkillTaskKind::EndChanneling { channel_doodad: 0 }, + skill: skill.clone(), + cancel: cancel.clone(), + }); + }); + let template = server.game_data.systems.skills.buff(GLIDER).unwrap(); + let buff = super::new_buff( + &server, + template, + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + Some(&skill), + now_ms(), + ); + super::add_buff(&server, &owner, buff, 0, 0); + client.drain(); + add(&server, &owner, IRRELEVANT); + assert!(!has(&owner, GLIDER)); + assert!(cancel.is_cancelled()); + assert!(skill.cancelled()); + assert!(owner + .with_unit(|u| u.unit().skill_state.skill_task.is_none()) + .unwrap()); + assert_eq!(server.systems.skills.tl_ids.in_use(), 0); + assert_eq!(removed(&mut client), vec![vec![0, 3, 0, 2, 0, 0, 0]]); +} + +#[tokio::test] +async fn buff_breakers_timer_applied_cc_uses_the_same_acceptance_path() { + let mut d = data(); + d.systems.skills.add_buff(BuffTemplate { + id: 60_020, + kind: 3, + duration: 10_000, + tick: 10.0, + tick_effects: vec![TickEffect { + effect_id: 60_021, + target_buff_tag_id: 0, + target_no_buff_tag_id: 0, + }], + ..BuffTemplate::default() + }); + d.systems.skills.add_effect( + EffectKind::BuffEffect, + EffectTemplate::Buff(BuffEffect { + id: 60_021, + buff_id: Some(SILENCE), + chance: 100, + stack: 1, + ab_level: 0, + }), + 60_021, + ); + let (server, mut client, owner) = fixture(d); + add(&server, &owner, SONGS[0]); + add(&server, &owner, 60_020); + client.drain(); + for _ in 0..40 { + if !has(&owner, SONGS[0]) { + break; + } + tokio::time::sleep(Duration::from_millis(5)).await; + } + assert!(has(&owner, SILENCE)); + assert!(!has(&owner, SONGS[0])); + assert_eq!(removed(&mut client), vec![vec![0, 3, 0, 2, 0, 0, 0]]); +} + +#[tokio::test] +async fn buff_breakers_multiple_tags_remove_each_song_once_in_index_order() { + let mut d = data(); + d.systems.skills.buff_tags.insert(STUN, vec![99, 6, 97, 6]); + let (server, mut client, owner) = fixture(d); + for song in SONGS { + add(&server, &owner, song); + } + client.drain(); + add(&server, &owner, STUN); + for song in SONGS { + assert!(!has(&owner, song)); + } + assert_eq!( + removed(&mut client), + vec![ + vec![0, 3, 0, 2, 0, 0, 0], + vec![0, 3, 0, 3, 0, 0, 0], + vec![0, 3, 0, 4, 0, 0, 0], + vec![0, 3, 0, 5, 0, 0, 0], + ] + ); +} + +#[tokio::test] +async fn buff_breakers_mutual_batch_removal_does_not_start_a_stale_buff_event() { + let mut d = data(); + for id in [SONGS[0], GLIDER] { + d.systems.skills.buff_tags.insert(id, vec![6]); + } + let (server, mut client, owner) = fixture(d); + for id in [SONGS[0], GLIDER] { + let template = server.game_data.systems.skills.buff(id).unwrap(); + let mut buff = super::new_buff( + &server, + template, + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + None, + now_ms(), + ); + buff.duration = template.duration; + owner.with_base_unit(|u| u.buffs_mut().add_buff_with_duration(buff, 0, now_ms())); + } + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert!(!has(&owner, SONGS[0])); + assert!(!has(&owner, GLIDER)); + assert_eq!( + removed(&mut client), + vec![vec![0, 3, 0, 2, 0, 0, 0], vec![0, 3, 0, 3, 0, 0, 0]] + ); + assert!(controllers::active(&owner).is_none()); +} + +#[tokio::test] +async fn buff_breakers_existing_cc_prevents_restarting_a_song() { + let (server, _client, owner) = fixture(data()); + add(&server, &owner, SILENCE); + add(&server, &owner, SONGS[0]); + assert!(has(&owner, SILENCE)); + assert!(!has(&owner, SONGS[0])); + assert_eq!( + owner.with_unit(|u| u + .unit() + .bonuses + .calculate(0.0, UnitAttribute::Str, now_ms())), + Some(0.0) + ); +} + +#[tokio::test] +async fn buff_breakers_gliding_tag_ends_frigid_tracks_and_deadeye() { + let (server, mut client, owner) = fixture(data()); + add(&server, &owner, 431); + add(&server, &owner, 2170); + client.drain(); + add(&server, &owner, GLIDER); + assert!(!has(&owner, 431)); + assert!(!has(&owner, 2170)); + assert!(has(&owner, GLIDER)); + assert_eq!( + removed(&mut client), + vec![vec![0, 3, 0, 2, 0, 0, 0], vec![0, 3, 0, 3, 0, 0, 0]] + ); +} + +#[test] +fn buff_breakers_loader_preserves_direction_and_deduplicates_tags() { + let conn = rusqlite::Connection::open_in_memory().unwrap(); + conn.execute_batch("CREATE TABLE buff_breakers (buff_id, buff_tag_id); INSERT INTO buff_breakers VALUES (656,99),(656,6),(656,6),(1029,27);").unwrap(); + let breakers = super::super::data::load_buff_breakers(&conn).unwrap(); + assert_eq!(breakers[&656], vec![6, 99]); + assert_eq!(breakers[&1029], vec![27]); + assert!(!breakers.contains_key(&6)); +} + +#[tokio::test] +async fn buff_breakers_started_trigger_cc_does_not_resume_removed_buff_or_disturb_mount() { + use crate::systems::vehicles::data::attach_point; + for matching in [false, true] { + let mut d = reentrant_data(); + mount_data(&mut d); + let (server, mut client, owner) = fixture(d); + let mate = mount(&server, &owner); + // Mount visibility may serialize state buffs. Keep this buff transaction isolated. + owner.with_base_unit(|u| *u.buffs_mut() = Default::default()); + let (skill, cancel) = channel(&server, &owner, matching); + let original = queue_original(&server, &owner, Some(&skill)); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert_no_original_state(&server, &owner, &original); + assert!(has(&owner, IRRELEVANT)); + assert!(!has(&owner, MARKER)); + assert_eq!(cancel.is_cancelled(), matching); + assert_eq!(skill.cancelled(), matching); + assert_eq!(server.systems.skills.tl_ids.in_use(), u32::from(!matching)); + assert_eq!( + owner.with_unit(|u| u.unit().skill_state.skill_task.is_none()), + Some(matching) + ); + let player = owner.as_player().unwrap(); + assert!( + player.data().is_riding, + "removed buff must not reach its unmount step" + ); + assert_eq!(player.data().unit.transform.parent_obj_id, mate.obj_id); + assert_eq!( + mate.data().passenger(attach_point::DRIVER).unwrap().obj_id, + owner.obj_id() + ); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, IRRELEVANT, 3), + (sc::SCBuffRemovedPacket, 0, 2), + ] + ); + if !matching { + super::super::skill::stop(&server, &skill, &owner, 0); + } + assert_eq!(server.systems.skills.tl_ids.in_use(), 0); + } +} + +#[tokio::test] +async fn buff_breakers_started_trigger_cc_cleans_npc_controller_and_timer_paths() { + let (server, mut client, _player) = fixture(reentrant_data()); + let owner = npc_owner(&server); + let (skill, cancel) = channel(&server, &owner, true); + let original = queue_original(&server, &owner, Some(&skill)); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert_no_original_state(&server, &owner, &original); + assert!(cancel.is_cancelled()); + assert_eq!(server.systems.skills.tl_ids.in_use(), 0); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, IRRELEVANT, 3), + (sc::SCBuffRemovedPacket, 0, 2), + ] + ); + tokio::time::sleep(Duration::from_millis(70)).await; + assert!(!has(&owner, MARKER), "removed tick must not run"); + assert_eq!(owner.transform().z, 100.0); + assert!(controllers::active(&owner).is_none()); + assert!(notices(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_started_self_dispel_finishes_even_without_a_breaker_relation() { + let mut d = reentrant_data(); + // An unknown faction is attackable even against itself, so a friendly self-cure + // needs the same known faction as a live character. + d.factions.add(crate::data::world_data::SystemFaction { + id: 101, + ..Default::default() + }); + d.systems.skills.buff_breakers.clear(); + d.systems.skills.buff_triggers.clear(); + // Also cover the permanent/non-ticking start branch, which must not turn a deferred + // explicit exit back into ACTING after its own Started trigger dispels it. + let original = Arc::make_mut(d.systems.skills.buffs.get_mut(&SONGS[0]).unwrap()); + original.kind = 2; // Model the friendly self-cure fixture as a bad buff. + original.duration = 0; + original.tick = 0.0; + original.tick_effects.clear(); + d.systems.skills.add_effect( + EffectKind::DispelEffect, + EffectTemplate::Dispel(DispelEffect { + id: TRIGGER_EFFECT, + dispel_count: 0, + cure_count: 1, + buff_tag_id: ORIGINAL_TAG, + }), + 0, + ); + trigger( + &mut d, + BuffEventTriggerKind::Started, + (EffectKind::DispelEffect, TRIGGER_EFFECT), + 0, + ); + let (server, mut client, owner) = fixture(d); + let (skill, cancel) = channel(&server, &owner, false); + let original = queue_original(&server, &owner, Some(&skill)); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert_no_original_state(&server, &owner, &original); + assert!( + !cancel.is_cancelled(), + "self-dispel must not resume the stun interrupt" + ); + assert!(!has(&owner, IRRELEVANT)); + assert_eq!(notices(&mut client), vec![(sc::SCBuffRemovedPacket, 0, 2)]); + super::super::skill::stop(&server, &skill, &owner, 0); +} + +#[tokio::test] +async fn buff_breakers_started_mutual_breakers_keep_dispelled_callback_and_cleanup_order() { + let mut d = reentrant_data(); + d.systems + .skills + .buff_breakers + .insert(IRRELEVANT, vec![ORIGINAL_TAG]); + Arc::make_mut(d.systems.skills.buffs.get_mut(&IRRELEVANT).unwrap()).gliding = true; + trigger_buff( + &mut d, + BuffEventTriggerKind::Dispelled, + TRIGGER_EFFECT + 2, + MARKER, + 0, + ); + let (server, mut client, _player) = fixture(d); + let owner = npc_owner(&server); + let original = queue_original(&server, &owner, None); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + assert_no_original_state(&server, &owner, &original); + assert!(!has(&owner, IRRELEVANT)); + assert!( + has(&owner, MARKER), + "Dispelled callback still runs during nested removal" + ); + assert!(!super::check_buff_tag(&server, &owner, 6)); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, IRRELEVANT, 3), + (sc::SCBuffCreatedPacket, MARKER, 4), + (sc::SCBuffRemovedPacket, 0, 2), + (sc::SCBuffRemovedPacket, 0, 3), + ] + ); + tokio::time::sleep(Duration::from_millis(70)).await; + assert_eq!(owner.transform().z, 100.0); + assert!(controllers::active(&owner).is_none()); + assert!(notices(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_started_channel_callback_reuses_index_without_resuming_old_lifetime() { + let mut d = reentrant_data(); + d.systems + .skills + .buff_breakers + .insert(IRRELEVANT, vec![ORIGINAL_TAG]); + let (server, mut client, owner) = fixture(d); + let (skill, cancel) = channel(&server, &owner, true); + let weak = Arc::downgrade(&server); + let callback_owner = owner.clone(); + *skill.callback.lock().unwrap() = Some(Box::new(move || { + let server = weak.upgrade().unwrap(); + super::remove_buff(&server, &callback_owner, IRRELEVANT); + // Replace the later mutual-breaker candidate at its index too. The outer removal + // snapshot must not remove this new lifetime. Its tag gates the new song's trigger. + let marker = super::new_buff( + &server, + server.game_data.systems.skills.buff(MARKER).unwrap(), + Some(&callback_owner), + &SkillCaster::Unit(callback_owner.obj_id()), + None, + now_ms(), + ); + super::add_buff(&server, &callback_owner, marker, 3, 0); + let t = server.game_data.systems.skills.buff(SONGS[0]).unwrap(); + let b = super::new_buff( + &server, + t, + Some(&callback_owner), + &SkillCaster::Unit(callback_owner.obj_id()), + None, + now_ms(), + ); + super::add_buff(&server, &callback_owner, b, 2, 0); + })); + let original = queue_original(&server, &owner, Some(&skill)); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + let replacement = super::get_buff(&owner, 2).unwrap(); + assert_eq!(replacement.template.id, original.template.id); + assert!(!replacement.same_instance(&original)); + assert!( + has(&owner, MARKER), + "later candidate's replacement survives" + ); + assert_eq!(replacement.state, crate::models::buff::effect_state::ACTING); + assert_ne!(replacement.task_gen, 0); + assert!(cancel.is_cancelled()); + assert!(owner + .with_unit(|u| u.unit().skill_state.skill_task.is_none()) + .unwrap()); + assert_eq!(server.systems.skills.tl_ids.in_use(), 0); + assert_eq!( + owner.with_unit(|u| ( + u.unit() + .skill_modifiers + .apply(MODIFIER_TARGET, &[], SkillAttribute::CastTime, 0.0), + u.unit() + .buff_modifiers + .apply(MODIFIER_TARGET, &[], BuffAttribute::Duration, 0.0), + u.unit() + .combat_buffs + .by_hit_type + .values() + .map(Vec::len) + .sum::(), + )), + Some((17.0, 23.0, 1)), + "replacement gets exactly one set of modifiers" + ); + let subscriptions: Vec<_> = server + .systems + .skills + .triggers + .lock() + .unwrap() + .iter() + .filter(|s| s.owner_obj == owner.obj_id() && s.buff_index == 2) + .map(|s| s.buff_instance_id) + .collect(); + assert_eq!(subscriptions, vec![replacement.instance_id]); + super::dispel_task(&server, owner.obj_id(), original.index, original.task_gen); + assert!( + has(&owner, SONGS[0]), + "old lifetime's timer cannot remove replacement" + ); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, IRRELEVANT, 3), + (sc::SCBuffRemovedPacket, 0, 2), + (sc::SCBuffRemovedPacket, 0, 3), + (sc::SCBuffCreatedPacket, MARKER, 3), + (sc::SCBuffCreatedPacket, SONGS[0], 2), + ] + ); + super::exit(&server, &owner, 2, false); + assert_no_original_state(&server, &owner, &replacement); +} + +#[tokio::test] +async fn buff_breakers_accepted_refresh_reconciles_restored_active_buff_against_cc() { + let mut d = data(); + d.systems.skills.add_buff(BuffTemplate { + id: MARKER, + kind: 1, + ..Default::default() + }); + trigger_buff( + &mut d, + BuffEventTriggerKind::Started, + TRIGGER_EFFECT, + MARKER, + 0, + ); + let (server, mut client, owner) = fixture(d); + let cc = super::new_buff( + &server, + server.game_data.systems.skills.buff(SILENCE).unwrap(), + Some(&owner), + &SkillCaster::Unit(owner.obj_id()), + None, + now_ms(), + ); + super::add_buff(&server, &owner, cc, 99, 0); + // Reconstruct pre-hook/restored state through bookkeeping + lifecycle only. Drain + // Started so this regression can fail independently of Started reconciliation. + let original = queue_original(&server, &owner, None); + owner.with_base_unit(|u| u.buffs_mut().take_events()); + super::schedule_effect(&server, &owner, original.index, false); + let acting = super::get_buff(&owner, original.index).unwrap(); + assert!(acting.in_use && acting.same_instance(&original)); + assert!(!has(&owner, MARKER)); + client.drain(); + add(&server, &owner, SONGS[0]); // REFRESH keeps the index; must still reconcile. + assert!(!has(&owner, SONGS[0])); + assert!( + !has(&owner, MARKER), + "refresh must not fire Started triggers" + ); + assert!(has(&owner, SILENCE)); + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, SONGS[0], 2), + (sc::SCBuffRemovedPacket, 0, 2), + ] + ); + super::dispel_task(&server, owner.obj_id(), acting.index, acting.task_gen); + assert!(notices(&mut client).is_empty()); +} + +#[tokio::test] +async fn buff_breakers_valid_refresh_keeps_identity_and_single_modifier_set() { + let mut d = reentrant_data(); + d.systems.skills.buff_triggers.clear(); + Arc::make_mut(d.systems.skills.buffs.get_mut(&SONGS[0]).unwrap()).stun = false; + let (server, mut client, owner) = fixture(d); + add(&server, &owner, SONGS[0]); + let original = super::get_buff(&owner, 2).unwrap(); + client.drain(); + super::add_buff_by_id(&server, &owner, SONGS[0], &owner, 30_000); + let refreshed = super::get_buff(&owner, 2).unwrap(); + assert!(refreshed.same_instance(&original)); + assert_ne!(refreshed.task_gen, original.task_gen); + assert_eq!(refreshed.duration, 30_000); + assert_eq!( + owner.with_unit(|u| ( + u.unit() + .skill_modifiers + .apply(MODIFIER_TARGET, &[], SkillAttribute::CastTime, 0.0), + u.unit() + .combat_buffs + .by_hit_type + .values() + .map(Vec::len) + .sum::(), + )), + Some((17.0, 1)) + ); + assert_eq!( + notices(&mut client), + vec![(sc::SCBuffCreatedPacket, SONGS[0], 2)] + ); + super::dispel_task(&server, owner.obj_id(), original.index, original.task_gen); + assert!(has(&owner, SONGS[0])); + super::exit(&server, &owner, 2, false); + assert_no_original_state(&server, &owner, &refreshed); +} + +#[tokio::test] +async fn buff_breakers_started_self_refresh_retains_lifetime_and_installs_modifiers_once() { + let mut d = reentrant_data(); + d.systems.skills.buff_triggers.clear(); + trigger_buff( + &mut d, + BuffEventTriggerKind::Started, + TRIGGER_EFFECT, + SONGS[0], + 0, + ); + let (server, mut client, owner) = fixture(d); + let original = queue_original(&server, &owner, None); + client.drain(); + crate::systems::dispatch_buff_events(&server, &owner); + let active = super::get_buff(&owner, 2).unwrap(); + assert!(active.same_instance(&original)); + assert_eq!(active.state, crate::models::buff::effect_state::ACTING); + assert_eq!( + owner.with_unit(|u| ( + u.unit() + .skill_modifiers + .apply(MODIFIER_TARGET, &[], SkillAttribute::CastTime, 0.0), + u.unit() + .buff_modifiers + .apply(MODIFIER_TARGET, &[], BuffAttribute::Duration, 0.0), + u.unit() + .combat_buffs + .by_hit_type + .values() + .map(Vec::len) + .sum::(), + u.unit().bonuses.bonuses(UnitAttribute::Str).len(), + )), + Some((17.0, 23.0, 1, 1)) + ); + // Preserve existing order: the nested refresh publishes its update before the outer + // start completes, and both refer to the same effect. No Removed notice is valid. + assert_eq!( + notices(&mut client), + vec![ + (sc::SCBuffCreatedPacket, SONGS[0], 2), + (sc::SCBuffCreatedPacket, SONGS[0], 2), + ] + ); + super::exit(&server, &owner, 2, false); + assert_no_original_state(&server, &owner, &active); +} + +#[test] +#[ignore = "requires AAEMU_COMPACT_DB (read-only 1.2 compact.sqlite3)"] +fn buff_breakers_real_compact_db_song_glider_and_cc_relations() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + rusqlite::Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) + .unwrap(); + let breakers = super::super::data::load_buff_breakers(&conn).unwrap(); + assert_eq!(breakers.len(), 92); + assert_eq!(breakers.values().map(Vec::len).sum::(), 661); + for song in SONGS { + assert_eq!(breakers[&song], vec![6, 12, 13, 97, 99, 107, 150, 346]); + } + assert_eq!( + breakers[&GLIDER], + vec![6, 12, 13, 27, 97, 99, 107, 150, 346] + ); + for (id, tag) in [(STUN, 6), (SLEEP, 97), (SILENCE, 99)] { + let count: i32 = conn + .query_row( + "SELECT count(*) FROM tagged_buffs WHERE buff_id=?1 AND tag_id=?2", + [id, tag], + |r| r.get(0), + ) + .unwrap(); + assert_eq!(count, 1); + } + // Frigid Tracks and Deadeye break on Gliding, rather than arbitrary CC flags. + assert_eq!(breakers[&431], vec![294]); + assert_eq!(breakers[&2170], vec![294]); +} diff --git a/rust/crates/aaemu-game/src/systems/skills/buffs.rs b/rust/crates/aaemu-game/src/systems/skills/buffs.rs index b666888394..6f876d97c4 100644 --- a/rust/crates/aaemu-game/src/systems/skills/buffs.rs +++ b/rust/crates/aaemu-game/src/systems/skills/buffs.rs @@ -159,6 +159,10 @@ pub fn get_buff(owner: &WorldObject, index: u32) -> Option { owner.with_base_unit(|b| b.buffs().effect_by_index(index).cloned()) } +fn current_buff(owner: &WorldObject, expected: &Buff) -> Option { + get_buff(owner, expected.index).filter(|b| b.same_instance(expected)) +} + fn set_buff(owner: &WorldObject, index: u32, f: impl FnOnce(&mut Buff) -> R) -> Option { owner.with_base_unit(|b| b.buffs_mut().effect_by_index_mut(index).map(f)) } @@ -502,18 +506,106 @@ pub fn buff_ab_level( /// `UnitHooks.on_buff_event`: the inline C# behaviour around `_effects` changes. pub fn on_buff_event(server: &GameServer, owner: &WorldObject, event: &BuffEvent) { match event { - BuffEvent::Started(b) => on_started(server, owner, b), - BuffEvent::Refreshed(b) => on_refreshed(server, owner, b), + BuffEvent::Started(b) | BuffEvent::Refreshed(b) => { + // An earlier event in the same batch can already have removed this effect. + if current_buff(owner, b).is_none() { + return; + } + if matches!(event, BuffEvent::Started(_)) { + on_started(server, owner, b); + } else { + on_refreshed(server, owner, b); + } + remove_broken_buffs(server, owner); + } BuffEvent::Removed(b) => on_removed(server, owner, b), } } +/// Reconcile authored breaker tags after an accepted start/refresh, including effects +/// applied by buff timers. Immunity/requirements/tolerance/stack rejection happens before +/// these events. Immediate accepted-state reconciliation is the server compatibility +/// policy. The native loaders establish direction, but the available client/zone dumps +/// do not establish an authoritative consumer's apply-vs-tick timing. +fn remove_broken_buffs(server: &GameServer, owner: &WorldObject) { + let data = &server.game_data.systems.skills; + let mut broken: Vec = owner.with_base_unit(|u| { + let effects = &u.buffs().effects; + effects + .iter() + .filter(|b| !b.is_ended()) + .filter(|b| { + data.buff_breakers.get(&b.template.id).is_some_and(|tags| { + effects.iter().any(|other| { + other.index != b.index + && !other.is_ended() + && data + .buff_tags(other.template.id) + .iter() + .any(|t| tags.contains(t)) + }) + }) + }) + .cloned() + .collect() + }); + // Decide from one accepted snapshot. Mutual breakers and duplicate tags must not + // depend on HashMap order, or on callbacks changing the remaining candidates. + broken.sort_unstable_by_key(|b| b.index); + for b in broken { + // A preceding removal callback may have replaced a later candidate at its index. + if current_buff(owner, &b).is_none() { + continue; + } + let channel = owner + .with_unit(|u| u.unit().skill_state.skill_task.clone()) + .flatten() + .filter(|task| { + b.caster_obj_id == owner.obj_id() + && task.skill.template.id == b.skill_id + && (task.skill.template.channeling_buff_id == b.template.id + || task.skill.template.toggle_buff_id == b.template.id) + }); + exit(server, owner, b.index, false); + // A batch may contain an effect whose Started hook has not run yet. Finish its + // explicit exit now; the stale Started event above must not revive its controller. + if current_buff(owner, &b).is_some_and(|e| e.state == effect_state::FINISHING) { + schedule_effect(server, owner, b.index, false); + } + // Remove first: stopping a channel can itself remove its channel/toggle buffs. + // Only cancel the channel that owns this buff, outside all object/controller locks. + if let Some(task) = channel { + // A removal callback can start a different cast of the same skill. + let still_current = owner + .with_unit(|u| { + u.unit() + .skill_state + .skill_task + .as_ref() + .is_some_and(|live| Arc::ptr_eq(&live.skill, &task.skill)) + }) + .unwrap_or(false); + if still_current { + if let super::state::SkillTaskKind::EndChanneling { channel_doodad } = task.kind { + super::skill::stop(server, &task.skill, owner, channel_doodad); + } + } + } + } +} + fn on_started(server: &GameServer, owner: &WorldObject, b: &Buff) { let data = &server.game_data.systems.skills; let template = full_template(server, &b.template); // Triggers.SubscribeEvents + Events.OnBuffStarted subscribe_triggers(server, owner, b); fire_buff_trigger(server, owner, b.index, BuffEventTriggerKind::Started); + // Started effects run synchronously and can dispel/end this CREATED buff, apply a + // breaker, or replace it at the same explicit index. Preserve trigger order, but do + // not install modifiers, unmount, interrupt, or start a controller/timer afterwards. + let Some(b) = resume_started_buff(server, owner, b) else { + return; + }; if template.id > 0 { let skill_mods = data.skill_modifiers_by_owner(template.id).to_vec(); let buff_mods = data.buff_modifiers_for_buff(template.id).to_vec(); @@ -531,9 +623,15 @@ fn on_started(server: &GameServer, owner: &WorldObject, b: &Buff) { } } if template.stun || template.silence || template.sleep { + if resume_started_buff(server, owner, &b).is_none() { + return; + } super::skill::interrupt_skills(server, owner); } } + let Some(b) = resume_started_buff(server, owner, &b) else { + return; + }; if b.duration > 0 || !template.tick_effects.is_empty() { // SetInUse(true, false) -> ScheduleEffect(false) schedule_effect(server, owner, b.index, false); @@ -551,10 +649,26 @@ fn on_started(server: &GameServer, owner: &WorldObject, b: &Buff) { } } +/// Finish an explicit exit deferred while the buff was CREATED. The existing queued +/// CREATED removal path still runs Started triggers before reaching this boundary. +fn resume_started_buff(server: &GameServer, owner: &WorldObject, b: &Buff) -> Option { + let live = current_buff(owner, b)?; + if live.is_ended() { + if live.state == effect_state::FINISHING { + schedule_effect(server, owner, live.index, false); + } + return None; + } + Some(live) +} + fn on_refreshed(server: &GameServer, owner: &WorldObject, b: &Buff) { // SetInUse(true, true) -> UpdateEffect let template = full_template(server, &b.template); start(server, owner, b.index); + if !current_buff(owner, b).is_some_and(|live| !live.is_ended()) { + return; + } let now = now_ms(); let Some(gen) = set_buff(owner, b.index, |e| { if e.duration == 0 { @@ -734,6 +848,9 @@ fn stop_effect_task(server: &GameServer, owner: &WorldObject, index: u32, timed_ fire_buff_trigger(server, owner, index, BuffEventTriggerKind::Timeout); } unsubscribe_triggers(server, owner, &b); + if current_buff(owner, &b).is_none() { + return; + } owner.with_base_unit(|u| u.buffs_mut().remove_effect_by_index(index)); crate::systems::dispatch_buff_events(server, owner); } @@ -1535,6 +1652,8 @@ pub struct TriggerSub { pub source_obj: u32, pub owner_obj: u32, pub buff_index: u32, + /// Internal buff lifetime, since an explicit index can be reused by a callback. + pub buff_instance_id: u64, pub template: BuffTriggerTemplate, /// `DamagedBuffTrigger` (else the generic `BuffTrigger`). pub damaged: bool, @@ -1596,6 +1715,7 @@ fn subscribe_triggers(server: &GameServer, owner: &WorldObject, b: &Buff) { source_obj: if unit_event { owner.obj_id() } else { 0 }, owner_obj: owner.obj_id(), buff_index: b.index, + buff_instance_id: b.instance_id, template: t.clone(), damaged, }); @@ -1612,7 +1732,11 @@ fn unsubscribe_triggers(server: &GameServer, owner: &WorldObject, b: &Buff) { .triggers .lock() .expect("triggers poisoned") - .retain(|s| !(s.owner_obj == owner_id && s.buff_index == b.index)); + .retain(|s| { + !(s.owner_obj == owner_id + && s.buff_index == b.index + && s.buff_instance_id == b.instance_id) + }); } /// Fires a buff-level event (`Started`, `Timeout`, `Dispelled`) of the buff at `index`. @@ -1644,6 +1768,7 @@ fn fire_buff_trigger_with( .filter(|s| { s.owner_obj == owner_id && s.buff_index == b.index + && s.buff_instance_id == b.instance_id && s.source_obj == 0 && s.template.kind == kind as u16 }) @@ -1674,6 +1799,9 @@ pub fn fire_unit_event(server: &GameServer, unit: u32, kind: BuffEventTriggerKin let Some(b) = get_buff(&owner, s.buff_index) else { continue; }; + if b.instance_id != s.buff_instance_id { + continue; + } execute_trigger(server, &owner, &b, &s, amount); } } @@ -1769,3 +1897,7 @@ pub type Attr = UnitAttribute; #[cfg(test)] #[path = "buff_removal_tests.rs"] mod buff_removal_tests; + +#[cfg(test)] +#[path = "buff_breaker_tests.rs"] +mod buff_breaker_tests; diff --git a/rust/crates/aaemu-game/src/systems/skills/combat.rs b/rust/crates/aaemu-game/src/systems/skills/combat.rs index 21efdb94f3..3581d6434e 100644 --- a/rust/crates/aaemu-game/src/systems/skills/combat.rs +++ b/rust/crates/aaemu-game/src/systems/skills/combat.rs @@ -1067,6 +1067,36 @@ pub fn add_unit_aggro( kind: AggroKind, unit: &WorldObject, amount: i32, +) -> bool { + add_aggro_amounts(server, owner, kind, unit, amount, None) +} + +/// Damage effects award actual damage credit independently of their authored threat. +/// Other callers retain `add_unit_aggro`'s historical zero/negative amount semantics. +pub fn add_damage_aggro( + server: &GameServer, + owner: &WorldObject, + unit: &WorldObject, + damage: i32, + threat: i32, +) -> bool { + add_aggro_amounts( + server, + owner, + AggroKind::Damage, + unit, + threat.max(0), + Some(damage.max(0)), + ) +} + +fn add_aggro_amounts( + server: &GameServer, + owner: &WorldObject, + kind: AggroKind, + unit: &WorldObject, + amount: i32, + damage_credit: Option, ) -> bool { if buffs::check_buff_tag(server, owner, tags::NO_FIGHT) || buffs::check_buff_tag(server, owner, tags::RETURNING) @@ -1081,19 +1111,29 @@ pub fn add_unit_aggro( return false; } if kind == AggroKind::Damage { - add_tagger(server, owner, unit, amount); + add_tagger(server, owner, unit, damage_credit.unwrap_or(amount)); } let aggro_mul = super::stats::stat(server, unit, super::stats::StatKind::AggroMul); let incoming = super::stats::stat(server, owner, super::stats::StatKind::IncomingAggroMul); let amount = (amount as f32 * (aggro_mul as f32 / 100.0)) as i32; let amount = (amount as f32 * (incoming as f32 / 100.0)) as i32; let unit_id = unit.obj_id(); + if damage_credit.is_some() && amount <= 0 { + // A zero-threat hit still earns damage credit, but creates no aggro/watch. + return owner + .with_unit(|u| u.unit().skill_state.aggro_table.contains_key(&unit_id)) + .unwrap_or(false); + } let existed = owner .with_unit(|u| { let table = &mut u.unit_mut().skill_state.aggro_table; match table.get_mut(&unit_id) { Some(a) => { - a.add(kind, amount); + if damage_credit.is_some() { + a.damage_aggro = a.damage_aggro.saturating_add(amount); + } else { + a.add(kind, amount); + } true } None => { diff --git a/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs new file mode 100644 index 0000000000..08efeae598 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/cooldown_tag_flow_tests.rs @@ -0,0 +1,837 @@ +//! Native 1.2 evidence: x2game12.c 397B2350 reads i32 skillCount and tagCount, +//! each followed by (id, total, remaining) u32 triples; 39899D40 appends them, +//! 3989A290 selects the longest skill/tag timer, and 39899F90 never shortens a tag. +//! UI baselib.lua:346-383 consumes remaining/total on item/skill_cooldown updates. +//! Server membership comes from authored cooldown_tag_id, never a generic-tag lookup. +//! Shared state stays in the native tag list so one native tag reset clears the same +//! state on both sides. Expected bytes are literal native-reader fixtures, never +//! generated by a second encoder. + +use std::sync::Arc; + +use aaemu_commons::{Marshal, PacketStream}; + +use crate::data::GameData; +use crate::models::unit::{SkillAttribute, SkillModifier, UnitCooldowns, UnitModifierType}; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::server::GameServer; +use crate::systems::skills; +use crate::test_support::{open_client_skills, spawn_player, test_character, TestClient}; +use crate::world::{now_ms, NpcRef, PlayerRef, WorldObject}; + +use skills::data::SkillTemplate; +use skills::handlers::{start_skill, CSStartSkillPacket}; +use skills::packets::SCCooldownsPacket; +use skills::types::{skill_result, SkillCastTarget, SkillCaster, SkillObject}; + +const POTION: u32 = 11717; +const POTION_NEXT: u32 = 11720; +const FOOD: u32 = 11816; +const FOOD_NEXT: u32 = 11817; +const GLIDER: u32 = 13411; +const GLIDER_ZERO: u32 = 12373; +const UNTAGGED: u32 = 21001; + +fn data() -> GameData { + let mut data = GameData::empty(); + for (id, tag, duration) in [ + (POTION, 144, 60_000), + // Deliberately different durations: use the started skill's duration for the group. + (POTION_NEXT, 144, 3_000), + (FOOD, 9, 3_000), + (FOOD_NEXT, 9, 3_000), + (GLIDER, 296, 10_000), + (GLIDER_ZERO, 296, 0), + (UNTAGGED, 0, 0), + ] { + data.systems.skills.add_skill(SkillTemplate { + cooldown_tag_id: tag, + cooldown_time: duration, + mana_cost: 25, + ..skills::tests::skill_template(id) + }); + } + // An unrelated generic tag must not become server cooldown-group membership. + data.systems.skills.skill_tags.insert(UNTAGGED, vec![144]); + data +} + +fn fixture(mut data: GameData) -> (Arc, TestClient, PlayerRef, NpcRef) { + open_client_skills(&mut data); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + client.conn.active_char = Some(player.clone()); + client.drain(); + (server, client, player, npc) +} + +fn edit(data: &mut GameData, id: u32, change: impl FnOnce(&mut SkillTemplate)) { + change(Arc::make_mut( + data.systems.skills.skills.get_mut(&id).unwrap(), + )); +} + +fn cast(server: &GameServer, client: &mut TestClient, id: u32, target: u32) { + let player = client.conn.active_char.clone().unwrap(); + { + let mut p = player.data(); + // Isolate skill/tag cooldown admission from the existing per-press/GCD throttle. + p.unit.skill_last_used_ms = 0; + p.unit.global_cooldown_ms = 0; + } + // CS 1.2 caster/target unions: unit kind 0, 3-byte object ids (397C85B0/397C7A40). + let mut request = Vec::from(id.to_le_bytes()); + request.push(0); + request.extend_from_slice(&player.obj_id.to_le_bytes()[..3]); + request.push(0); + request.extend_from_slice(&target.to_le_bytes()[..3]); + request.push(0); + let packet = CSStartSkillPacket::read(&mut PacketStream::from_bytes(request)).unwrap(); + start_skill(server, &mut client.conn, packet); +} + +type UiCooldownEntry = (u32, u32, u32); + +/// Minimal native 397B2350/39899D40 reader and 3989A290 remaining-time lookup. +#[derive(Debug, Default)] +struct UiCooldowns { + skills: Vec, + tags: Vec, +} + +impl UiCooldowns { + fn read(bytes: &[u8]) -> Self { + let mut body = PacketStream::from_bytes(bytes.to_vec()); + let mut read_list = || { + let count = body.read_i32().unwrap(); + assert!((0..=150).contains(&count)); + (0..count) + .map(|_| { + ( + body.read_u32().unwrap(), + body.read_u32().unwrap(), + body.read_u32().unwrap(), + ) + }) + .collect::>() + }; + let skills = read_list(); + let tags = read_list(); + assert_eq!(bytes.len(), 8 + (skills.len() + tags.len()) * 12); + Self { skills, tags } + } + + fn remaining(&self, skill_id: u32, authored_tag: u32) -> u32 { + self.skills + .iter() + .filter(|e| e.0 == skill_id) + .chain( + self.tags + .iter() + .filter(|e| authored_tag != 0 && e.0 == authored_tag), + ) + .map(|e| e.2) + .max() + .unwrap_or(0) + } + + /// Native 391D6420 -> 39899EC0/39899F00 clears the named record in each list. + fn reset(&mut self, bytes: &[u8], unit_id: u32) { + let mut body = PacketStream::from_bytes(bytes.to_vec()); + assert_eq!(body.read_bc().unwrap(), unit_id); + let skill_id = body.read_u32().unwrap(); + let tag = body.read_u32().unwrap(); + assert!(!body.read_bool().unwrap()); + for (list, id) in [(&mut self.skills, skill_id), (&mut self.tags, tag)] { + if let Some(entry) = list.iter_mut().find(|e| e.0 == id) { + entry.2 = 0; + } + } + } +} + +fn cooldown_lists(frames: &[(u16, Vec)]) -> UiCooldowns { + let packets: Vec<_> = frames + .iter() + .filter(|(op, _)| *op == sc::SCCooldownsPacket) + .collect(); + assert_eq!( + packets.len(), + 1, + "one UI application per accepted tagged cast" + ); + UiCooldowns::read(&packets[0].1) +} + +fn assert_denied(frames: &[(u16, Vec)], result: u8) { + assert!(!frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + let errors: Vec<_> = frames + .iter() + .filter(|(op, _)| *op == sc::SCSkillStartedPacket) + .collect(); + assert_eq!(errors.len(), 1); + // Native 397CA290 -> 397B1EF0: the error byte follows the extra-flags byte at the end. + assert_eq!(&errors[0].1[errors[0].1.len() - 2..], &[1, result]); +} + +#[tokio::test] +async fn packet_flow_denies_never_used_member_and_preserves_long_individual_cooldown() { + let (server, mut client, player, npc) = fixture(data()); + let long_end = now_ms() + 120_000; + player + .data() + .unit + .cooldowns + .cooldowns + .insert(POTION_NEXT, long_end); + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + let ui = cooldown_lists(&frames); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.skills[0].0, POTION); + assert_eq!(ui.tags.len(), 1); + assert_eq!(ui.tags[0].0, 144); + assert!(ui.remaining(POTION_NEXT, 144) <= 60_000); + assert!(ui.remaining(POTION_NEXT, 144) > 59_000); + assert!(!ui.skills.iter().any(|e| e.0 == POTION_NEXT)); + assert_eq!( + player.data().unit.cooldowns.cooldowns[&POTION_NEXT], + long_end + ); + // Remove only the fixture's old individual cooldown: this member has never been cast. + player.data().unit.cooldowns.remove_cooldown(POTION_NEXT); + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); + assert_eq!(player.data().unit.mp, 75); + assert!(!player + .data() + .unit + .cooldowns + .cooldowns + .contains_key(&POTION_NEXT)); +} + +#[tokio::test] +async fn native_start_update_bytes_keep_current_individual_separate_from_shared_expiry() { + let (server, mut client, player, _) = fixture(data()); + { + let mut p = player.data(); + p.unit.cooldowns.add_cooldown(POTION, 120_000, 1000); + p.unit.cooldowns.add_tag_cooldown(144, 180_000, 1000); + } + let caster = WorldObject::from(&player); + let skill = super::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(POTION) + .unwrap() + .clone(), + Some(&caster), + ); + super::start_skill_cooldown(&server, &skill, &caster, 1000); + let frames = client.drain(); + let packet = frames + .iter() + .find(|(op, _)| *op == sc::SCCooldownsPacket) + .unwrap(); + // 397B2350: one skill (11717, 120000, 120000), then one tag (144, 180000, 180000). + assert_eq!( + packet.1, + [ + 1, 0, 0, 0, 0xc5, 0x2d, 0, 0, 0xc0, 0xd4, 1, 0, 0xc0, 0xd4, 1, 0, 1, 0, 0, 0, 0x90, 0, + 0, 0, 0x20, 0xbf, 2, 0, 0x20, 0xbf, 2, 0, + ] + ); + let ui = cooldown_lists(&frames); + assert_eq!(ui.skills[0].2, 120_000); + assert_eq!(ui.remaining(POTION, 144), 180_000); + assert_eq!(player.data().unit.cooldowns.cooldowns[&POTION], 121_000); + assert_eq!(player.data().unit.cooldowns.tag_cooldowns[&144], 181_000); +} + +#[tokio::test] +async fn food_glider_zero_duration_members_and_players_have_independent_groups() { + let (server, mut client, player, npc) = fixture(data()); + for (id, member, tag) in [ + (POTION, POTION_NEXT, 144), + (FOOD, FOOD_NEXT, 9), + (GLIDER, GLIDER_ZERO, 296), + ] { + player.data().unit.mp = 100; + cast(&server, &mut client, id, npc.obj_id); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.skills[0].0, id); + assert_eq!(ui.tags.len(), 1); + assert_eq!(ui.tags[0].0, tag); + assert!(ui.remaining(member, tag) > 0); + } + cast(&server, &mut client, GLIDER_ZERO, npc.obj_id); + assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); + player.data().unit.mp = 100; + cast(&server, &mut client, UNTAGGED, npc.obj_id); + assert!(client.drain_ops().contains(&sc::SCSkillFiredPacket)); + assert!(!player + .data() + .unit + .cooldowns + .cooldowns + .contains_key(&UNTAGGED)); + let mut other = TestClient::new(&server, 2, 2); + let mut c = test_character(2, "Other", 100.0, 100.0); + c.unit.hp = 1000; + c.unit.mp = 100; + c.unit.max_mp = 1000; + let other_player = spawn_player(&server, &other, c, 0x101); + other.conn.active_char = Some(other_player.clone()); + other.drain(); + client.drain(); + cast(&server, &mut other, POTION_NEXT, npc.obj_id); + assert_eq!(other_player.data().unit.mp, 75); + let ui = cooldown_lists(&other.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.tags.len(), 1); + assert!(!client.drain_ops().contains(&sc::SCCooldownsPacket)); +} + +#[tokio::test] +async fn untagged_skill_keeps_its_individual_cooldown_and_negative_tags_are_not_groups() { + for tag in [0, -1] { + let mut data = data(); + edit(&mut data, UNTAGGED, |s| { + s.cooldown_time = 10_000; + s.cooldown_tag_id = tag; + }); + let (server, mut client, player, npc) = fixture(data); + cast(&server, &mut client, UNTAGGED, npc.obj_id); + assert!(client.drain_ops().contains(&sc::SCSkillFiredPacket)); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + cast(&server, &mut client, UNTAGGED, npc.obj_id); + assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); + assert_eq!(player.data().unit.mp, 75); + } +} + +#[tokio::test] +async fn group_uses_started_skills_cooldown_modifier_and_expiry_allows_a_new_member() { + let (server, mut client, player, npc) = fixture(data()); + player + .data() + .unit + .skill_modifiers + .add_modifiers(&[SkillModifier { + id: 1, + owner_id: 1, + tag_id: 0, + skill_attribute: SkillAttribute::Cooldown, + unit_modifier_type: UnitModifierType::Percent, + value: -50, + skill_id: POTION, + synergy: false, + }]); + cast(&server, &mut client, POTION, npc.obj_id); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.tags.len(), 1); + assert!(ui.remaining(POTION_NEXT, 144) > 29_000); + assert!(ui.remaining(POTION_NEXT, 144) <= 30_000); + player + .data() + .unit + .cooldowns + .tag_cooldowns + .insert(144, now_ms() - 1); + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.skills[0].0, POTION_NEXT); + assert!(ui.skills[0].2 <= 3_000); + assert_eq!(ui.tags.len(), 1); + assert!(ui.tags[0].2 <= 3_000); + assert!(player.data().unit.cooldowns.cooldowns[&POTION] > now_ms() + 29_000); + assert_eq!(player.data().unit.mp, 50); +} + +#[tokio::test] +async fn cast_cost_failure_and_new_group_during_cast_do_not_start_cooldowns() { + for group_started in [false, true] { + let mut data = data(); + edit(&mut data, POTION_NEXT, |s| s.casting_time = 60_000); + let (server, mut client, player, npc) = fixture(data); + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + let task = player.data().unit.skill_state.skill_task.clone().unwrap(); + assert!(player.data().unit.cooldowns.cooldowns.is_empty()); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + assert_eq!(player.data().unit.mp, 100); + client.drain(); + if group_started { + player + .data() + .unit + .cooldowns + .add_tag_cooldown(144, 60_000, now_ms()); + } else { + player.data().unit.mp = 0; + } + let before = player.data().unit.cooldowns.clone(); + super::cast( + &server, + &task.skill, + &super::CastCtx { + caster: WorldObject::from(&player), + caster_caster: SkillCaster::Unit(player.obj_id), + target: skills::geometry::Target::Obj(WorldObject::from(&npc)), + target_caster: SkillCastTarget::Unit(npc.obj_id), + skill_object: SkillObject::None, + }, + ); + task.cancel.cancel(); + let frames = client.drain(); + assert!(!frames + .iter() + .any(|(op, _)| *op == sc::SCSkillFiredPacket || *op == sc::SCCooldownsPacket)); + assert_eq!(player.data().unit.cooldowns, before); + assert_eq!(player.data().unit.mp, if group_started { 100 } else { 0 }); + } +} + +#[tokio::test(start_paused = true)] +async fn channel_commits_cost_and_shared_cooldown_once_and_stop_keeps_them() { + let mut data = data(); + edit(&mut data, FOOD, |s| s.channeling_time = 60_000); + let (server, mut client, player, npc) = fixture(data); + cast(&server, &mut client, FOOD, npc.obj_id); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.tags.len(), 1); + assert_eq!(player.data().unit.mp, 75); + let task = player.data().unit.skill_state.skill_task.clone().unwrap(); + let before = player.data().unit.cooldowns.clone(); + super::stop(&server, &task.skill, &WorldObject::from(&player), 0); + assert_eq!(player.data().unit.cooldowns, before); + assert!(!client.drain_ops().contains(&sc::SCCooldownsPacket)); +} + +#[tokio::test] +async fn gm_override_bypasses_shared_admission_and_resets_the_native_tag() { + let (server, mut client, player, npc) = fixture(data()); + player.data().skill_char.ignore_skill_cooldowns = true; + for _ in 0..2 { + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + let reset = frames + .iter() + .find(|(op, _)| *op == sc::SCSkillCooldownResetPacket) + .unwrap(); + // Native 397B5770 / OnSkillCooldownReset 391D6420: bc chr, u32 skill/tag, bool gcd. + assert_eq!(reset.1, [0, 1, 0, 0xc5, 0x2d, 0, 0, 0x90, 0, 0, 0, 0]); + } + assert_eq!(player.data().unit.mp, 50); + assert!(player.data().unit.cooldowns.cooldowns.is_empty()); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + player + .data() + .unit + .cooldowns + .add_tag_cooldown(144, 60_000, now_ms()); + player.data().unit.mp = 100; + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + assert!(client.drain_ops().contains(&sc::SCSkillFiredPacket)); +} + +#[tokio::test] +async fn gm_ignore_then_off_clears_the_same_native_records_and_preserves_longer_members() { + let (server, mut client, player, npc) = fixture(data()); + let now = now_ms(); + { + let mut p = player.data(); + let cds = &mut p.unit.cooldowns; + cds.add_cooldown(POTION, 60_000, now); + cds.add_cooldown(POTION_NEXT, 120_000, now); + cds.add_cooldown(FOOD, 60_000, now); + cds.add_tag_cooldown(144, 60_000, now); + cds.add_tag_cooldown(9, 60_000, now); + } + let before = player.data().unit.cooldowns.clone(); + // Feed the UI actual encoded server bytes, including a longer individual timer. + let initial = SCCooldownsPacket::from_cooldowns(&before, now); + client.conn.send(&initial); + let mut ui = cooldown_lists(&client.drain()); + assert_eq!(ui.remaining(POTION, 144), 60_000); + assert_eq!(ui.remaining(POTION_NEXT, 144), 120_000); + + let mut other = TestClient::new(&server, 2, 2); + let mut character = test_character(2, "Foreign", 100.0, 100.0); + character.unit.cooldowns = before.clone(); + let foreign = spawn_player(&server, &other, character, 0x101); + other.drain(); + client.drain(); + + player.data().skill_char.ignore_skill_cooldowns = true; + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + let resets: Vec<_> = frames + .iter() + .filter(|(op, _)| *op == sc::SCSkillCooldownResetPacket) + .collect(); + assert_eq!(resets.len(), 1); + // Literal native 397B5770 record: bc 0x100, skill 11717, tag 144, gcd false. + assert_eq!(resets[0].1, [0, 1, 0, 0xc5, 0x2d, 0, 0, 0x90, 0, 0, 0, 0]); + ui.reset(&resets[0].1, player.obj_id); + player.data().skill_char.ignore_skill_cooldowns = false; + assert!( + now_ms() < before.tag_cooldowns[&144], + "old shared expiry is still in the future" + ); + assert_eq!(ui.remaining(POTION, 144), 0); + assert_eq!(ui.remaining(POTION_NEXT, 144), 120_000); + assert_eq!(ui.remaining(FOOD, 9), 60_000); + { + let p = player.data(); + let cds = &p.unit.cooldowns; + assert!(!cds.cooldowns.contains_key(&POTION)); + assert!(!cds.tag_cooldowns.contains_key(&144)); + assert_eq!(cds.cooldowns[&POTION_NEXT], before.cooldowns[&POTION_NEXT]); + assert_eq!(cds.cooldowns[&FOOD], before.cooldowns[&FOOD]); + assert_eq!(cds.tag_cooldowns[&9], before.tag_cooldowns[&9]); + } + assert_eq!(foreign.data().unit.cooldowns, before); + assert!(!other.drain_ops().contains(&sc::SCSkillCooldownResetPacket)); + + // Ignore is off: the long member still refuses, while the reset skill can start + // again before its original tag expiry, matching the UI's two native stores. + cast(&server, &mut client, POTION_NEXT, npc.obj_id); + assert_denied(&client.drain(), skill_result::COOLDOWN_TIME); + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + let update = cooldown_lists(&frames); + assert_eq!(update.skills.len(), 1); + assert_eq!(update.skills[0].0, POTION); + assert_eq!(update.tags.len(), 1); + assert_eq!(update.tags[0].0, 144); +} + +#[tokio::test] +async fn controlled_unit_shared_cooldown_does_not_populate_owners_native_snapshot() { + let (server, mut client, player, _) = fixture(data()); + let now = now_ms(); + player + .data() + .unit + .cooldowns + .add_tag_cooldown(9, 120_000, now); + let owner_cooldowns = player.data().unit.cooldowns.clone(); + let mut data = crate::models::mate::Mate::new(1, 1); + data.owner_obj_id = player.obj_id; + let mate = crate::world::Entity::new(0x300, data); + let caster = WorldObject::from(&mate); + let skill = super::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(POTION) + .unwrap() + .clone(), + Some(&caster), + ); + client.drain(); + super::start_skill_cooldown(&server, &skill, &caster, now); + assert_eq!(mate.data().unit.cooldowns.cooldowns[&POTION], now + 60_000); + assert_eq!(mate.data().unit.cooldowns.tag_cooldowns[&144], now + 60_000); + assert!(mate + .data() + .unit + .cooldowns + .check_skill_cooldown(POTION_NEXT, 144, now)); + assert_eq!(player.data().unit.cooldowns, owner_cooldowns); + // 391D43C0 imports this subject-less packet into the local character manager. + assert!(!client.drain_ops().contains(&sc::SCCooldownsPacket)); +} + +#[tokio::test] +async fn gm_reset_targets_the_controlled_units_native_store_instead_of_its_owners() { + let (server, mut client, player, _) = fixture(data()); + let now = now_ms(); + player.data().skill_char.ignore_skill_cooldowns = true; + player + .data() + .unit + .cooldowns + .add_cooldown(POTION, 60_000, now); + player + .data() + .unit + .cooldowns + .add_tag_cooldown(144, 60_000, now); + let owner_cooldowns = player.data().unit.cooldowns.clone(); + let mut data = crate::models::mate::Mate::new(1, 1); + data.owner_obj_id = player.obj_id; + data.unit.cooldowns = owner_cooldowns.clone(); + let mate = crate::world::Entity::new(0x300, data); + let caster = WorldObject::from(&mate); + let skill = super::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(POTION) + .unwrap() + .clone(), + Some(&caster), + ); + super::reset_cooldown_if_ignored(&server, &skill, &caster); + let frames = client.drain(); + let reset = frames + .iter() + .find(|(op, _)| *op == sc::SCSkillCooldownResetPacket) + .unwrap(); + // The owner receives the packet, but its bc subject is the mate, 0x300. + assert_eq!(reset.1, [0, 3, 0, 0xc5, 0x2d, 0, 0, 0x90, 0, 0, 0, 0]); + assert!(mate.data().unit.cooldowns.cooldowns.is_empty()); + assert!(mate.data().unit.cooldowns.tag_cooldowns.is_empty()); + assert_eq!(player.data().unit.cooldowns, owner_cooldowns); +} + +#[tokio::test] +async fn npc_policy_keeps_accepting_server_skills_without_shortening_group_expiry() { + let (server, _client, player, npc) = fixture(data()); + let caster = WorldObject::from(&npc); + npc.data().unit.mp = 100; + npc.data() + .unit + .cooldowns + .add_tag_cooldown(144, 120_000, now_ms()); + let longer = npc.data().unit.cooldowns.tag_cooldowns[&144]; + for id in [POTION, POTION_NEXT] { + let skill = super::new_skill_for( + &server, + server.game_data.systems.skills.skill(id).unwrap().clone(), + Some(&caster), + ); + assert_eq!( + super::use_skill( + &server, + &skill, + &caster, + SkillCaster::Unit(npc.obj_id), + &mut SkillCastTarget::Unit(player.obj_id), + None, + true + ) + .0, + skill_result::SUCCESS + ); + assert_eq!(npc.data().unit.cooldowns.tag_cooldowns[&144], longer); + } +} + +#[tokio::test] +async fn select_snapshot_keeps_native_lists_and_preserves_long_individual_expiry() { + let server = crate::test_support::test_server_with(data()); + let mut client = TestClient::new(&server, 1, 1); + let now = now_ms(); + let mut character = test_character(1, "Restored", 100.0, 100.0); + character.unit.cooldowns.add_tag_cooldown(144, 60_000, now); + character + .unit + .cooldowns + .add_cooldown(POTION_NEXT, 120_000, now); + character + .unit + .cooldowns + .add_tag_cooldown(9, 3_000, now - 10_000); + crate::world::session::select_loaded(&server, &mut client.conn, character, Default::default()) + .unwrap(); + let ui = cooldown_lists(&client.drain()); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.skills[0].0, POTION_NEXT); + assert_eq!(ui.tags.len(), 1); + assert_eq!(ui.tags[0].0, 144); + assert!(ui.remaining(POTION, 144) > 59_000); + assert!(ui.remaining(POTION_NEXT, 144) > 119_000); +} + +#[tokio::test] +async fn native_snapshot_bytes_use_longest_expiry_and_omit_expired_or_unrelated_members() { + let mut cooldowns = UnitCooldowns::default(); + cooldowns.add_tag_cooldown(144, 60_000, 0); + cooldowns.add_cooldown(POTION_NEXT, 120_000, 0); + let packet = SCCooldownsPacket::from_cooldowns(&cooldowns, 1000); + let mut body = PacketStream::new(); + packet.write(&mut body); + assert_eq!( + body.into_bytes(), + [ + 1, 0, 0, 0, 0xc8, 0x2d, 0, 0, 0xd8, 0xd0, 1, 0, 0xd8, 0xd0, 1, 0, 1, 0, 0, 0, 0x90, 0, + 0, 0, 0x78, 0xe6, 0, 0, 0x78, 0xe6, 0, 0, + ] + ); + assert_eq!( + SCCooldownsPacket::from_cooldowns(&cooldowns, 120_000), + Default::default() + ); +} + +#[test] +fn native_snapshot_lists_are_sorted_capped_independently_and_expiry_safe() { + let mut cds = UnitCooldowns::default(); + for id in (1..=152).rev() { + cds.cooldowns.insert(id, 60_000); + cds.tag_cooldowns.insert(id + 1000, 120_000); + } + cds.cooldowns.insert(0, 1000); + cds.tag_cooldowns.insert(0, 1000); + let packet = SCCooldownsPacket::from_cooldowns(&cds, 1000); + assert_eq!(packet.skills.len(), 150); + assert_eq!(packet.tags.len(), 150); + assert_eq!( + packet.skills.iter().map(|e| e.id).collect::>(), + (1..=150).collect::>() + ); + assert_eq!( + packet.tags.iter().map(|e| e.id).collect::>(), + (1001..=1150).collect::>() + ); + let mut body = PacketStream::new(); + packet.write(&mut body); + let ui = UiCooldowns::read(&body.into_bytes()); + assert_eq!(ui.skills.len(), 150); + assert_eq!(ui.tags.len(), 150); + assert_eq!(ui.remaining(1, 1001), 119_000); + cds.cooldowns.clear(); + cds.tag_cooldowns.clear(); + cds.cooldowns.insert(POTION, i64::MAX); + cds.tag_cooldowns.insert(144, i64::MAX); + let packet = SCCooldownsPacket::from_cooldowns(&cds, i64::MIN); + assert_eq!(packet.skills[0].remaining_ms, u32::MAX); + assert_eq!(packet.tags[0].remaining_ms, u32::MAX); +} + +#[tokio::test] +async fn zero_negative_and_overflow_durations_never_wrap_or_create_spurious_cooldowns() { + for duration in [0, -1, i32::MIN] { + let mut data = data(); + edit(&mut data, POTION, |s| s.cooldown_time = duration); + let (server, mut client, player, npc) = fixture(data); + cast(&server, &mut client, POTION, npc.obj_id); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + assert!(player.data().unit.cooldowns.cooldowns.is_empty()); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + } + let (server, _client, player, _) = fixture(data()); + player.data().unit.skill_modifiers.add_modifiers(&[ + SkillModifier { + id: 1, + owner_id: 1, + tag_id: 0, + skill_attribute: SkillAttribute::Cooldown, + unit_modifier_type: UnitModifierType::Value, + value: i32::MAX, + skill_id: POTION, + synergy: false, + }, + SkillModifier { + id: 2, + owner_id: 2, + tag_id: 0, + skill_attribute: SkillAttribute::Cooldown, + unit_modifier_type: UnitModifierType::Percent, + value: i32::MAX, + skill_id: POTION, + synergy: false, + }, + ]); + let caster = WorldObject::from(&player); + let skill = super::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(POTION) + .unwrap() + .clone(), + Some(&caster), + ); + super::start_skill_cooldown(&server, &skill, &caster, 0); + assert_eq!( + player.data().unit.cooldowns.tag_cooldowns[&144], + i64::from(u32::MAX) + ); + player.data().unit.cooldowns = UnitCooldowns::default(); + super::start_skill_cooldown(&server, &skill, &caster, i64::MAX - 100); + assert_eq!(player.data().unit.cooldowns.tag_cooldowns[&144], i64::MAX); + let mut cds = UnitCooldowns::default(); + cds.add_tag_cooldown(144, 60_000, 0); + cds.add_tag_cooldown(144, 1_000, 10); + assert_eq!(cds.tag_cooldowns[&144], 60_000); + assert!(cds.check_skill_cooldown(POTION_NEXT, 144, 59_749)); + assert!(!cds.check_skill_cooldown(POTION_NEXT, 144, 59_750)); + assert!(cds.tag_cooldowns.is_empty()); +} + +#[tokio::test] +async fn plot_end_keeps_modified_shared_expiry_nonnegative_and_sends_only_one_ui_update() { + for duration in [60_000, 0, -1] { + let mut data = data(); + edit(&mut data, POTION, |s| { + s.plot_only = true; + s.plot_id = Some(77); + s.cooldown_time = duration; + }); + let (server, mut client, player, npc) = fixture(data); + player + .data() + .unit + .skill_modifiers + .add_modifiers(&[SkillModifier { + id: 1, + owner_id: 1, + tag_id: 0, + skill_attribute: SkillAttribute::Cooldown, + unit_modifier_type: UnitModifierType::Percent, + value: -50, + skill_id: POTION, + synergy: false, + }]); + cast(&server, &mut client, POTION, npc.obj_id); + // Missing tree executes do_plot_end through the real scheduler without a cast path. + tokio::time::timeout(std::time::Duration::from_secs(1), async { + while player.data().unit.skill_state.active_plot.is_some() { + tokio::task::yield_now().await; + } + }) + .await + .expect("plot reaches do_plot_end"); + let frames = client.drain(); + assert!(frames.iter().any(|(op, _)| *op == sc::SCPlotEndedPacket)); + if duration > 0 { + let ui = cooldown_lists(&frames); + assert_eq!(ui.skills.len(), 1); + assert_eq!(ui.tags.len(), 1); + assert!(ui.remaining(POTION_NEXT, 144) > 29_000); + assert!(ui.remaining(POTION_NEXT, 144) <= 30_000); + let cds = &player.data().unit.cooldowns; + assert_eq!(cds.cooldowns[&POTION], cds.tag_cooldowns[&144]); + } else { + assert!(!frames.iter().any(|(op, _)| *op == sc::SCCooldownsPacket)); + assert!(player.data().unit.cooldowns.cooldowns.is_empty()); + assert!(player.data().unit.cooldowns.tag_cooldowns.is_empty()); + } + } +} diff --git a/rust/crates/aaemu-game/src/systems/skills/data/mod.rs b/rust/crates/aaemu-game/src/systems/skills/data/mod.rs index fbfc031c9b..acb7d9f65f 100644 --- a/rust/crates/aaemu-game/src/systems/skills/data/mod.rs +++ b/rust/crates/aaemu-game/src/systems/skills/data/mod.rs @@ -6,6 +6,7 @@ pub mod effects; pub mod misc; pub mod plots; pub mod templates; +pub mod zone_rules; #[cfg(test)] mod buff_game_data_tests; @@ -71,10 +72,14 @@ pub struct Data { pub buff_tags: HashMap>, /// `_taggedBuffs`: tag id -> buff ids. pub tagged_buffs: HashMap>, + /// `buff_breakers`: buff id -> tags on the owner that end that buff. + pub buff_breakers: HashMap>, /// `_skillTags`. pub skill_tags: HashMap>, /// `_taggedSkills`. pub tagged_skills: HashMap>, + /// Authored zone-group restrictions and item tag membership. + pub zone_rules: zone_rules::ZoneRules, /// `_skillModifiers` by owner id. pub skill_modifiers: HashMap>, /// `_buffTriggers` by buff id. @@ -131,6 +136,7 @@ impl Data { let mut d = Data { plots: PlotData::load(conn)?, anims: AnimData::load(conn, files)?, + zone_rules: zone_rules::ZoneRules::load(conn)?, ..Data::default() }; // skills @@ -296,6 +302,8 @@ impl Data { d.tagged_buffs.entry(tag).or_default().push(buff); Ok(()) })?; + d.buff_breakers = load_buff_breakers(conn)?; + d.buff_breakers.retain(|id, _| buffs.contains_key(id)); for_each_row(conn, "SELECT * FROM skill_modifiers", [], |r| { let attr = r.u32("skill_attribute_id")? as u8; let Some(skill_attribute) = SkillAttribute::from_u8(attr) else { @@ -635,6 +643,29 @@ impl Data { } } +/// The 1.2 loader (`395D17B0`) attaches each breaker tag to its `buff_id`, rather than +/// treating `buff_id` as the buff to apply. The 10.x loader (`39B41DE0`) uses a set. +pub(super) fn load_buff_breakers(conn: &Connection) -> rusqlite::Result>> { + let mut breakers: HashMap> = HashMap::new(); + for_each_row( + conn, + "SELECT buff_id, buff_tag_id FROM buff_breakers", + [], + |r| { + breakers + .entry(r.u32("buff_id")?) + .or_default() + .push(r.u32("buff_tag_id")?); + Ok(()) + }, + )?; + for tags in breakers.values_mut() { + tags.sort_unstable(); + tags.dedup(); + } + Ok(breakers) +} + #[cfg(test)] mod tests { use super::*; diff --git a/rust/crates/aaemu-game/src/systems/skills/data/plots.rs b/rust/crates/aaemu-game/src/systems/skills/data/plots.rs index 2b3202a6e8..0f61a99a98 100644 --- a/rust/crates/aaemu-game/src/systems/skills/data/plots.rs +++ b/rust/crates/aaemu-game/src/systems/skills/data/plots.rs @@ -129,6 +129,9 @@ pub struct PlotData { pub events: HashMap, pub conditions: HashMap, pub trees: HashMap, + /// `aoe_diminishings.id -> rate` in authored percentage units (100 means 100%). + /// Counter lifetime and lookup outside the authored ids are separate runtime rules. + pub aoe_diminishings: HashMap, } impl PlotData { @@ -152,6 +155,12 @@ impl PlotData { pub fn load(conn: &Connection) -> rusqlite::Result { let mut d = PlotData::default(); + // Native 1.2 sub_39620E90 (x2game12.c:1321108-1321129) stores each float rate + // under its authored id. The 10.x reference sub_39BDC250 does the same. + for_each_row(conn, "SELECT id, rate FROM aoe_diminishings", [], |r| { + d.aoe_diminishings.insert(r.u32("id")?, r.f32("rate")?); + Ok(()) + })?; let dup = |what: &str, id: u32| { rusqlite::Error::InvalidParameterName(format!("duplicate {what} {id} (Dictionary.Add)")) }; @@ -365,11 +374,11 @@ mod tests { assert_eq!(v, vec![(1, 'b'), (2, 'a'), (2, 'c'), (3, 'd')]); } - #[test] - fn trees_share_nodes_per_next_event() { + fn plot_db() -> Connection { let c = Connection::open_in_memory().unwrap(); c.execute_batch( - "CREATE TABLE plots (id, name, target_type_id); + "CREATE TABLE aoe_diminishings (id, rate); + CREATE TABLE plots (id, name, target_type_id); INSERT INTO plots VALUES (1, 'p', 0); CREATE TABLE plot_events (id, plot_id, position, name, source_update_method_id, target_update_method_id, target_update_method_param1, target_update_method_param2, @@ -377,7 +386,7 @@ mod tests { target_update_method_param5, target_update_method_param6, target_update_method_param7, aoe_diminishing, target_update_method_param8, target_update_method_param9); - INSERT INTO plot_events VALUES (10,1,1,'',1,2,0,0,0,1,0,0,0,0,'f',0,0); + INSERT INTO plot_events VALUES (10,1,1,'',1,2,0,0,0,1,0,0,0,0,'t',0,0); INSERT INTO plot_events VALUES (11,1,2,'',1,2,0,0,0,1,0,0,0,0,'f',0,0); CREATE TABLE plot_conditions (id, not_condition, kind_id, param1, param2, param3); CREATE TABLE plot_event_conditions (id, event_id, condition_id, position, source_id, target_id, notify_failure); @@ -390,6 +399,12 @@ mod tests { INSERT INTO plot_next_events VALUES (101,11,1,11,'f','f',500,0,'f',0,'f','f','f','f','f','f');", ) .unwrap(); + c + } + + #[test] + fn trees_share_nodes_per_next_event() { + let c = plot_db(); let d = PlotData::load(&c).unwrap(); let t = d.tree(1).unwrap(); // root -> node(11) -> node(11 via 101) -> (101 already built) itself @@ -399,4 +414,64 @@ mod tests { assert_eq!(t.nodes[2].children, vec![2]); assert_eq!(d.parent_next_event(t, 2).unwrap().delay, 500); } + + #[test] + fn aoe_diminishing_loader_preserves_authored_ids_rates_and_event_flags() { + let c = plot_db(); + // The 1.2 compact's ten authored rows, deliberately out of id order. Native + // sub_39620E90 keys on id; neither SQL row order nor event position is the key. + c.execute_batch( + "INSERT INTO aoe_diminishings VALUES + (10,10.0),(9,10.0),(8,10.0),(7,25.0),(6,40.0), + (5,55.0),(4,70.0),(3,80.0),(2,90.0),(1,100.0);", + ) + .unwrap(); + let d = PlotData::load(&c).unwrap(); + assert_eq!(d.aoe_diminishings.len(), 10); + let rates: Vec<_> = (1..=10).map(|id| d.aoe_diminishings[&id]).collect(); + assert_eq!( + rates, + [100.0, 90.0, 80.0, 70.0, 55.0, 40.0, 25.0, 10.0, 10.0, 10.0] + ); + assert!(d.event(10).unwrap().aoe_diminishing); + assert!(!d.event(11).unwrap().aoe_diminishing); + } + + #[test] + fn aoe_diminishing_loader_retains_fractional_percentages() { + let c = plot_db(); + c.execute_batch("INSERT INTO aoe_diminishings VALUES (3,77.5);") + .unwrap(); + let d = PlotData::load(&c).unwrap(); + assert_eq!(d.aoe_diminishings.get(&3), Some(&77.5)); + assert_eq!(d.aoe_diminishings.len(), 1); + } + + #[test] + #[ignore = "requires AAEMU_COMPACT_DB pointing to the native 1.2 compact.sqlite3"] + fn real_compact_db_aoe_diminishings() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let c = + Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let d = PlotData::load(&c).unwrap(); + assert_eq!(d.aoe_diminishings.len(), 10); + let rates: Vec<_> = (1..=10).map(|id| d.aoe_diminishings[&id]).collect(); + assert_eq!( + rates, + [100.0, 90.0, 80.0, 70.0, 55.0, 40.0, 25.0, 10.0, 10.0, 10.0] + ); + let mut flagged: Vec<_> = d + .events + .values() + .filter(|e| e.aoe_diminishing) + .map(|e| e.id) + .collect(); + flagged.sort_unstable(); + assert_eq!( + flagged, + [189, 239, 1141, 2149, 2723, 2903, 3481, 4627, 4631, 4700, 5323, 5511, 8110] + ); + } } diff --git a/rust/crates/aaemu-game/src/systems/skills/data/zone_rules.rs b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules.rs new file mode 100644 index 0000000000..94aaf45198 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules.rs @@ -0,0 +1,92 @@ +//! Native 1.2 zone-group restrictions (`x2game12.c:1646640`, LoadZoneGroupBannedTagDescs). + +use std::collections::HashMap; + +use rusqlite::Connection; + +use crate::data::sqlite::for_each_row; +use crate::server::GameServer; +use crate::world::WorldObject; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub struct BannedTag { + pub id: u32, + pub tag_id: u32, + pub banned_periods_id: u32, +} + +#[derive(Debug, Default)] +pub struct ZoneRules { + /// Keep conditional rows intact: an unresolved schedule must not become an always-on ban. + pub banned_tags: HashMap>, + pub item_tags: HashMap>, +} + +impl ZoneRules { + pub fn load(conn: &Connection) -> rusqlite::Result { + let mut data = Self::default(); + for_each_row(conn, "SELECT * FROM zone_group_banned_tags", [], |row| { + data.banned_tags + .entry(row.u32("zone_group_id")?) + .or_default() + .push(BannedTag { + id: row.u32("id")?, + tag_id: row.u32("tag_id")?, + banned_periods_id: row.u32("banned_periods_id")?, + }); + Ok(()) + })?; + for_each_row(conn, "SELECT * FROM tagged_items", [], |row| { + data.item_tags + .entry(row.u32("item_id")?) + .or_default() + .push(row.u32("tag_id")?); + Ok(()) + })?; + let conditional = data + .banned_tags + .values() + .flatten() + .filter(|rule| rule.banned_periods_id != 0) + .count(); + if conditional != 0 { + // 1.2 exports nine guard-summon rows with period 24 but no period definition. + // Native loader evidence establishes the field, not its scheduling semantics. + tracing::warn!( + conditional, + "Scheduled zone banned tags retained but not enforced: native period semantics unresolved" + ); + } + Ok(data) + } + + pub fn bans_any(&self, group: u32, tags: &[u32]) -> bool { + self.banned_tags.get(&group).is_some_and(|rules| { + rules + .iter() + .any(|rule| rule.banned_periods_id == 0 && tags.contains(&rule.tag_id)) + }) + } + + pub fn bans_item(&self, group: u32, item: u32) -> bool { + self.item_tags + .get(&item) + .is_some_and(|tags| self.bans_any(group, tags)) + } +} + +/// Resolve the current sector in the actual instance's template, including attached players. +/// Cached Transform.ZoneId/WorldId may still describe the previous zone or a different world. +pub(crate) fn current_group(server: &GameServer, caster: &WorldObject) -> Option { + let world = server.world.world(caster.transform().instance_id)?; + let pos = world.world_pos_rot(caster); + server + .game_data + .zones + .zone_by_key(world.template.zone_id_at(pos.x, pos.y)) + .map(|zone| zone.group_id) +} + +#[cfg(test)] +#[path = "zone_rules_tests.rs"] +mod tests; diff --git a/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs new file mode 100644 index 0000000000..82011e949c --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/data/zone_rules_tests.rs @@ -0,0 +1,514 @@ +//! Authored 1.2 relation subsets; coordinates/world instances are synthetic geometry. +//! Native evidence: D:/aa-re/client12/decomp/x2game12.c +//! - 1646640..1646705: banned tag descriptor fields, including banned_periods_id. +//! - 1983345..1983346: SkillResult 58 = ZONE_BANNED. +//! - 1163648..1163649: ErrorMessage 440 = item_cannot_use_here. +//! - 1766270..1766291 + 1748773..1748807: started-skill body, flags and byte result. +//! - 1761305..1761336: two i16 errors, u32 type, bool notify in SCErrorMsg. +//! - 1765129..1765192: caster discriminator, three-byte object ID and item fields. +//! +//! These literal failure bodies are native-layout fixtures, not Rust encode/decode round trips. + +use std::sync::Arc; +use std::time::Duration; + +use aaemu_commons::PacketStream; +use rusqlite::Connection; + +use super::{current_group, ZoneRules}; +use crate::data::items::ItemTemplate; +use crate::data::world_data::Zone; +use crate::data::world_templates::WorldTemplate; +use crate::net::registry::ClientPacket; +use crate::opcodes::sc; +use crate::systems::economy::inventory::Inv; +use crate::systems::skills::data::{EffectKind, EffectTemplate, SkillItemAmount, SkillTemplate}; +use crate::systems::skills::handlers::{start_skill, CSStartSkillPacket}; +use crate::systems::skills::state::{SkillRef, SkillRun}; +use crate::systems::skills::types::{SkillCastTarget, SkillCaster, SkillObject}; +use crate::systems::skills::{self, skill}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use crate::world::{PlayerRef, WorldObject}; +use crate::GameServer; + +const GLIDER: u32 = 12373; +const FISHING: u32 = 21571; +const GUARD: u32 = 24133; +const MOUNT_ITEM: u32 = 34580; +const SHIP_ITEM: u32 = 34314; +const GLIDER_ITEM: u32 = 14677; +const LUMBER: u32 = 8337; +const PLACEMENT_ITEM: u32 = 32095; + +fn relations() -> ZoneRules { + let conn = Connection::open_in_memory().unwrap(); + // Exact authored tuples (id, group, tag, period) from compact 1.2. Library index + // has banned-tag rows but NO tagged_items/tagged_skills rows in this export. + conn.execute_batch( + "CREATE TABLE zone_group_banned_tags (id, zone_group_id, tag_id, banned_periods_id); + INSERT INTO zone_group_banned_tags VALUES + (2,45,471,0),(3,45,472,0),(16,45,629,0),(21,45,296,0), + (13,45,628,0),(185,45,1348,0),(380,45,1581,0),(337,1,1581,0), + (271,70,472,0),(280,70,296,0),(281,70,629,0),(277,70,1348,0), + (203,63,1338,24); + CREATE TABLE tagged_items (tag_id, item_id); + INSERT INTO tagged_items VALUES (471,34580),(472,34314),(629,14677),(628,32095);", + ) + .unwrap(); + ZoneRules::load(&conn).unwrap() +} + +struct Fixture { + server: Arc, + client: TestClient, + player: PlayerRef, +} + +impl Fixture { + fn new() -> Self { + let mut data = crate::systems::economy::tests::test_data(); + for (id, key, group) in [(1, 129, 1), (168, 236, 45), (200, 288, 63), (209, 296, 70)] { + data.zones.zones.insert( + key, + Zone { + id, + zone_key: key, + group_id: group, + ..Default::default() + }, + ); + data.zones.zone_id_to_key.insert(id, key); + } + let skills = &mut data.systems.skills; + skills.zone_rules = relations(); + // Use the existing skill tag index; do not create another skill-tag loader. + skills.skill_tags.insert(GLIDER, vec![296]); + skills.skill_tags.insert(FISHING, vec![1348]); + skills.skill_tags.insert(GUARD, vec![1338]); + skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 100))), + 1, + ); + for id in [GLIDER, FISHING, GUARD, 10602, 15802] { + let mut effect = skills::tests::skill_effect(1, EffectKind::DamageEffect, 1); + effect.always_hit = true; + skills.add_skill(SkillTemplate { + // Authored IDs/tags with synthetic costs and a damage sentinel to expose + // accidental side effects in a denied cast. + id, + target_type: 0, + max_range: 30, + mana_cost: 25, + consume_labor_power: 10, + gain_life_point: 5, + cooldown_time: 1000, + default_gcd: true, + damage_type_id: 1, + level_rule_no_consideration: true, + effects: vec![effect], + ..Default::default() + }); + skills.skill_reagents.push(SkillItemAmount { + id, + skill_id: id, + item_id: LUMBER, + amount: 1, + }); + data.skills.add_client_sourced_skill(id); + } + for (item, skill) in [ + (MOUNT_ITEM, 10602), + (SHIP_ITEM, 15802), + (GLIDER_ITEM, GLIDER), + ] { + let mut template = ItemTemplate::plain(item, 10); + template.use_skill_id = skill; + template.use_skill_as_reagent = true; + data.items.templates.insert(item, template); + } + data.items + .templates + .insert(LUMBER, ItemTemplate::plain(LUMBER, 10)); + data.items + .templates + .insert(PLACEMENT_ITEM, ItemTemplate::plain(PLACEMENT_ITEM, 10)); + let server = Arc::new(test_server_with(data)); + server.set_self(); + skills::bind(&server); + crate::systems::economy::bridges::install(&server); + server.world.remove_world(0); + server.world.create_world_instance( + Arc::new(WorldTemplate::synthetic(0, "main_world", 2, 2, 129)), + 0, + ); + let dungeon = Arc::new(WorldTemplate::synthetic( + 1, + "instance_burntcastle_armory", + 2, + 2, + 236, + )); + server.world.create_world_instance(dungeon.clone(), 1); + // An instanced copy has an ephemeral instance ID, NOT its world-template ID. + server.world.create_world_instance(dungeon, 9001); + server.world.create_world_instance( + Arc::new(WorldTemplate::synthetic(2, "instance_library_1", 2, 2, 296)), + 9002, + ); + let mut client = TestClient::new(&server, 1, 1); + let mut character = test_character(1, "Caster", 100.0, 100.0); + character.unit.hp = 1000; + character.unit.max_hp = 1000; + character.unit.mp = 100; + character.unit.max_mp = 100; + character.labor_power = 100; + let player = spawn_player(&server, &client, character, 0x100); + client.conn.active_char = Some(player.clone()); + server.items.add_container(Inv::of(&player).bag()); + let result = Self { + server, + client, + player, + }; + result.give(LUMBER, 0); + result + } + + fn give(&self, template: u32, slot: i32) -> u64 { + let item = self + .server + .items + .create( + template, + 2, + 0, + 1, + &self.server.game_data.items, + &self.server.ids.item, + 0, + ) + .unwrap(); + let id = item.id; + Inv::of(&self.player) + .bag() + .lock() + .unwrap() + .add_new_item(item, slot, &self.server.game_data.items) + .unwrap(); + id + } + + fn enter(&mut self, instance: u32) { + self.player.data().unit.transform.instance_id = instance; + let obj = WorldObject::from(&self.player); + self.server.world.leave_other_instance(&obj, instance); + self.server + .world + .world(instance) + .unwrap() + .spawn(&self.player, &self.server.view_ctx()); + // Deliberately stale; only the actual world's sector mapping is authoritative. + let mut c = self.player.data(); + c.unit.transform.zone_id = if instance == 0 { 236 } else { 129 }; + c.unit.transform.world_id = 0; + drop(c); + self.client.drain(); + } + + fn assert_no_costs_or_effects(&self) { + let c = self.player.data(); + assert_eq!( + (c.unit.hp, c.unit.mp, c.labor_power, c.vocation_point), + (1000, 100, 100, 0) + ); + assert!(c.unit.cooldowns.cooldowns.is_empty()); + assert_eq!(c.unit.global_cooldown_ms, 0); + assert!(c.unit.skill_state.skill_task.is_none()); + drop(c); + assert_eq!(Inv::of(&self.player).items_count(LUMBER, -1), 2); + } + + fn run(&self, id: u32, source: SkillCaster, casting_time: i32) -> (SkillRef, (u8, u32)) { + let mut template = (**self.server.game_data.systems.skills.skill(id).unwrap()).clone(); + template.casting_time = casting_time; + let run = SkillRun::new(Arc::new(template), 1); + let result = skill::use_skill( + &self.server, + &run, + &WorldObject::from(&self.player), + source, + &mut SkillCastTarget::Unit(self.player.obj_id), + Some(SkillObject::None), + false, + ); + (run, result) + } +} + +#[test] +fn zone_rules_preserve_conditional_rows_without_widening_bans() { + let rules = relations(); + assert_eq!(rules.banned_tags[&63][0].banned_periods_id, 24); + assert!(!rules.bans_any(63, &[1338])); + assert!(rules.bans_any(45, &[296])); + assert!(!rules.bans_any(45, &[1338])); + assert!(rules.bans_any(1, &[1581])); + assert!(!rules.bans_any(70, &[1581])); + assert!(!rules.item_tags.values().any(|tags| tags.contains(&1581))); +} + +#[test] +fn zone_rules_missing_period_cannot_silently_become_an_unconditional_ban() { + let conn = Connection::open_in_memory().unwrap(); + conn.execute_batch( + "CREATE TABLE zone_group_banned_tags (id, zone_group_id, tag_id, banned_periods_id); + INSERT INTO zone_group_banned_tags VALUES (203,63,1338,NULL); + CREATE TABLE tagged_items (tag_id, item_id);", + ) + .unwrap(); + assert!(ZoneRules::load(&conn).is_err()); +} + +#[tokio::test] +async fn zone_rules_attached_caster_uses_composed_position_in_actual_world() { + use crate::models::slave::Slave; + use crate::world::Entity; + let f = Fixture::new(); + let mut template = WorldTemplate::synthetic(0, "main_world", 2, 2, 129); + // Synthetic sector boundary using real zone keys: local (100,100) is open, but + // the parent's (1000,100) offset places the player at (1100,200), sector (17,3). + assert!(template.set_zone_key_at(17, 3, 236)); + let world = f + .server + .world + .create_world_instance(Arc::new(template), 9003); + f.player.data().unit.transform.instance_id = 9003; + let obj = WorldObject::from(&f.player); + f.server.world.leave_other_instance(&obj, 9003); + world.spawn(&f.player, &f.server.view_ctx()); + let mut parent = Slave::new(0x200, 1); + parent.unit.transform.set_xyz(1000.0, 100.0, 0.0); + let parent = Entity::new(0x200, parent); + world.spawn(&parent, &f.server.view_ctx()); + world.attach_child(&WorldObject::from(&parent), &obj); + assert_eq!(f.player.data().unit.transform.zone_id, 129); + assert_eq!(current_group(&f.server, &obj), Some(45)); + assert_eq!( + f.run(GLIDER, SkillCaster::Unit(f.player.obj_id), 0).1, + (58, 0) + ); + f.assert_no_costs_or_effects(); +} + +#[tokio::test] +async fn zone_rules_direct_skill_packet_is_denied_in_actual_instance_for_players_and_gms() { + for instance in [1, 9001, 9002] { + for access in [0, 100] { + let mut f = Fixture::new(); + f.enter(instance); + f.player.data().access_level = access; + assert_eq!( + current_group(&f.server, &WorldObject::from(&f.player)), + Some(if instance == 9002 { 70 } else { 45 }) + ); + // Native CSStartSkill (0x052): u32 skill, unit caster + BC id, unit target + BC id, + // flag zero. IDs are glider 12373 and this fixture's player object 0x100. + let mut body = + PacketStream::from_bytes(vec![0x55, 0x30, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0]); + let packet = CSStartSkillPacket::read(&mut body).unwrap(); + start_skill(&f.server, &mut f.client.conn, packet); + let frames = f.client.drain(); + assert_eq!( + frames, + vec![( + sc::SCSkillStartedPacket, + vec![0x55, 0x30, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 58,] + )] + ); + f.assert_no_costs_or_effects(); + assert_eq!(f.player.data().unit.skill_last_used_ms, 0); + } + } +} + +#[tokio::test] +async fn zone_rules_item_request_uses_owned_template_before_costs_or_summons() { + for (item, skill) in [ + (MOUNT_ITEM, 10602), + (SHIP_ITEM, 15802), + (GLIDER_ITEM, GLIDER), + ] { + let mut f = Fixture::new(); + f.enter(9001); + let id = f.give(item, 1); + start_skill( + &f.server, + &mut f.client.conn, + CSStartSkillPacket { + skill_id: skill, + caster: SkillCaster::Item { + obj_id: f.player.obj_id, + item_id: id, + item_template_id: LUMBER, // forged untagged template hint + type1: 0, + type2: 0, + }, + target: SkillCastTarget::Unit(f.player.obj_id), + flag: 0, + skill_object: SkillObject::None, + }, + ); + let frames = f.client.drain(); + assert_eq!(frames.len(), 2); + assert_eq!( + frames[0], + (sc::SCErrorMsgPacket, vec![0xb8, 1, 0xb8, 1, 0, 0, 0, 0, 1]) + ); + assert_eq!(frames[1].0, sc::SCSkillStartedPacket); + assert_eq!(frames[1].1.last(), Some(&58)); + assert_eq!(Inv::of(&f.player).items_count(item, -1), 2); + f.assert_no_costs_or_effects(); + assert_eq!(f.player.data().unit.skill_last_used_ms, 0); + let world = f.server.world.world(9001).unwrap(); + assert!(world.all_of_kind(crate::world::ObjectKind::Mate).is_empty()); + assert!(world.all_slaves().is_empty()); + assert!(world.all_doodads().is_empty()); + } +} + +#[tokio::test] +async fn zone_rules_direct_doodad_item_request_is_denied_before_placement() { + use crate::systems::npcs::doodad::packets::CSCreateDoodadPacket; + let mut f = Fixture::new(); + let item = f.give(PLACEMENT_ITEM, 1); + // This item is otherwise visible to the placement bridge in the normal world. + assert!(f + .server + .systems + .npcs + .hooks + .economy + .get() + .unwrap() + .doodad_source_item(&f.server, &f.player, item, true) + .is_some()); + f.enter(9001); + CSCreateDoodadPacket { + id: 7876, + x: 100.0, + y: 100.0, + z: 100.0, + z_rot: 0.0, + scale: 1.0, + item_id: item, + } + .handle(&f.server, &mut f.client.conn) + .await + .unwrap(); + assert_eq!( + f.client.drain(), + vec![(sc::SCErrorMsgPacket, vec![0xb8, 1, 0xb8, 1, 0, 0, 0, 0, 1])] + ); + f.assert_no_costs_or_effects(); + assert_eq!(Inv::of(&f.player).items_count(PLACEMENT_ITEM, -1), 2); + assert!(f.server.world.world(9001).unwrap().all_doodads().is_empty()); +} + +#[tokio::test] +async fn zone_rules_fishing_denies_but_unrelated_tag_and_open_world_allow_casts() { + let mut f = Fixture::new(); + f.enter(1); + assert_eq!( + f.run(FISHING, SkillCaster::Unit(f.player.obj_id), 0).1, + (58, 0) + ); + f.assert_no_costs_or_effects(); + // Guard skill has a different tag; a conditional ban in another group cannot block it. + let (_, result) = f.run(GUARD, SkillCaster::Unit(f.player.obj_id), 0); + assert_eq!(result, (0, 0)); + assert!(f.player.data().unit.mp < 100); + assert!(f.player.data().unit.hp < 1000); + assert_eq!(Inv::of(&f.player).items_count(LUMBER, -1), 1); + let mut f = Fixture::new(); + f.enter(0); // stale zone 236 must not ban gliders in actual Gweonid sector 129. + assert_eq!( + current_group(&f.server, &WorldObject::from(&f.player)), + Some(1) + ); + assert_eq!( + f.run(GLIDER, SkillCaster::Unit(f.player.obj_id), 0).1, + (0, 0) + ); +} + +#[tokio::test] +async fn zone_rules_pending_skill_and_item_casts_recheck_zone_before_payment() { + for item_cast in [false, true] { + let mut f = Fixture::new(); + f.enter(0); + let source = if item_cast { + SkillCaster::Item { + obj_id: f.player.obj_id, + item_id: f.give(MOUNT_ITEM, 1), + item_template_id: MOUNT_ITEM, + type1: 0, + type2: 0, + } + } else { + SkillCaster::Unit(f.player.obj_id) + }; + let id = if item_cast { 10602 } else { GLIDER }; + let (run, result) = f.run(id, source, 50); + assert_eq!(result, (0, 0)); + assert_ne!(run.tl_id(), 0); + assert!(f.player.data().unit.skill_state.skill_task.is_some()); + f.enter(9001); + let deadline = tokio::time::Instant::now() + Duration::from_secs(1); + while run.tl_id() != 0 && tokio::time::Instant::now() < deadline { + tokio::time::sleep(Duration::from_millis(5)).await; + } + assert!(run.cancelled()); + assert_eq!(run.tl_id(), 0); + f.assert_no_costs_or_effects(); + let frames = f.client.drain(); + assert!(frames + .iter() + .any(|(op, body)| *op == sc::SCSkillStartedPacket && body.last() == Some(&58))); + assert!(!frames.iter().any(|(op, _)| *op == sc::SCSkillFiredPacket)); + if item_cast { + assert_eq!(Inv::of(&f.player).items_count(MOUNT_ITEM, -1), 2); + } + } +} + +#[test] +#[ignore = "requires AAEMU_COMPACT_DB pointing to the native 1.2 reference data"] +fn zone_rules_real_compact_db_preserves_all_authored_relations() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = + Connection::open_with_flags(path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let rules = ZoneRules::load(&conn).unwrap(); + let rows: Vec<_> = rules.banned_tags.values().flatten().collect(); + assert_eq!(rows.len(), 333); + assert_eq!( + rows.iter().filter(|r| r.banned_periods_id == 0).count(), + 324 + ); + assert_eq!( + rows.iter() + .filter(|r| r.banned_periods_id == 24 && r.tag_id == 1338) + .count(), + 9 + ); + assert!(rules.bans_item(45, MOUNT_ITEM)); + assert!(rules.bans_item(45, SHIP_ITEM)); + assert!(rules.bans_item(45, GLIDER_ITEM)); + assert!(rules.bans_any(45, &[1348])); + assert!(!rules.bans_any(63, &[1338])); + assert!(rules.bans_any(1, &[1581])); + assert!(!rules.bans_any(70, &[1581])); + assert!(!rules.item_tags.values().any(|tags| tags.contains(&1581))); +} diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs b/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs index f1d5eb2162..069d533870 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/combat.rs @@ -98,7 +98,10 @@ pub fn trigger_combat_buffs( } fn level_range(lvl_md: f32, skill_level: i32, va_start: i32, va_end: i32) -> (f32, f32) { - let level_modifier = ((skill_level - 1) / 49 * (va_end - va_start) + va_start) as f32 * 0.01; + // Native 1.2 sub_398A7380: float interpolation, not the mirrored C# integer division. + let level_modifier = ((skill_level as f32 - 1.0) / 49.0 * (va_end as f32 - va_start as f32) + + va_start as f32) + * 0.01; ( lvl_md - level_modifier * lvl_md + 0.5, (level_modifier + 1.0) * lvl_md + 0.5, @@ -111,11 +114,24 @@ pub fn damage( e: &DamageEffect, args: &EffectArgs<'_>, packets: Option<&mut CompressedGamePackets>, +) { + damage_with_aoe(server, e, args, packets, None); +} + +pub(super) fn damage_with_aoe( + server: &GameServer, + e: &DamageEffect, + args: &EffectArgs<'_>, + packets: Option<&mut CompressedGamePackets>, + aoe_multiplier: Option, ) { let Some(trg) = args.target.as_obj().filter(|o| o.is_unit()).cloned() else { return; }; - if trg.with_unit(|u| u.unit().hp).unwrap_or(0) <= 0 { + let (target_hp, target_max_hp) = trg + .with_unit(|u| (u.unit().hp, u.unit().max_hp)) + .unwrap_or_default(); + if target_hp <= 0 { return; } let Some(caster) = args.caster.clone() else { @@ -143,7 +159,7 @@ pub fn damage( args.caster_caster, caster.obj_id(), trg.obj_id(), - 1, + 0, 0, ); p.hit_type = SkillHitType::Immune; @@ -255,12 +271,13 @@ pub fn damage( e.level_va_start, e.level_va_end, ); - level_min += a; - level_max += b; + // sub_398A7380 adds 0.5 then truncates each endpoint before composing the base. + level_min += a.trunc(); + level_max += b.trunc(); } let dps_inc = match damage_type { Some(DamageType::Melee) => cs[4] as i32, - Some(DamageType::Magic) => cs[5] as i32 + cs[6] as i32, + Some(DamageType::Magic) => (cs[5] as i32).saturating_add(cs[6] as i32), Some(DamageType::Ranged) => cs[7] as i32, _ => 0, }; @@ -295,9 +312,32 @@ pub fn damage( min = level_min + (variable_damage - scaled); max = level_max + (variable_damage + scaled); } + if e.use_percent_damage { + // 1.2 descriptors retain whole percentages (e.g. 4754/5162: 99% current HP). + // The diagnostic sub_39898330 has separate integer fixed/percent/level terms. + // Server-side percent evaluation is unavailable: /100 and truncation here are + // the compatibility interpretation of those authored rows, not a 10.x rule. + let health = if e.use_current_health { + target_hp + } else { + target_max_hp + } + .max(0); + let percent = |ratio: i32| { + (i64::from(health) * i64::from(ratio) / 100).clamp(0, i64::from(i32::MAX)) as f32 + }; + min += percent(e.percent_min); + max += percent(e.percent_max); + if e.use_fixed_damage { + min += e.fixed_min as f32; + max += e.fixed_max as f32; + } + } min *= e.multiplier; max *= e.multiplier; - let damage_mul = match damage_type { + // sub_3941B030 returns before unit attributes when its unit source is null. + // Doodad/environment sources have no stats; their neutral multiplier is 1. + let damage_mul = match damage_type.filter(|_| caster.is_unit()) { Some(DamageType::Melee) => cs[11] as f32, Some(DamageType::Magic) => cs[12] as f32, Some(DamageType::Ranged) => cs[13] as f32, @@ -365,10 +405,33 @@ pub fn damage( } } } - if e.use_fixed_damage { + // Preserve the existing standalone fixed-damage override. Combined fixed/percent + // descriptors (4821, 4944, 6198, ...) contribute both terms to the base above. + if e.use_fixed_damage && !e.use_percent_damage { min = e.fixed_min as f32; max = e.fixed_max as f32; } + // Native 1.2 sub_3941B030 / sub_39354450: a buff source + // uses BuffAttribute::Damage (3), including fixed damage; it is not a skill modifier. + if let Some(b) = args.source.buff.as_ref().filter(|_| skill.is_none()) { + let tags = server.game_data.systems.skills.buff_tags(b.id); + caster.with_unit(|u| { + let modifiers = &u.unit().buff_modifiers; + let apply = |value: f32| { + modifiers + .apply( + b.id, + tags, + crate::models::unit::BuffAttribute::Damage, + f64::from(value), + ) + .max(0.0) + .min(f64::from(i32::MAX)) as f32 + }; + min = apply(min); + max = apply(max); + }); + } let mut final_damage = rand_float(min, max); if e.target_buff_tag_id > 0 && buffs::check_buff_tag(server, &trg, e.target_buff_tag_id) { final_damage *= e.target_buff_bonus_mul; @@ -403,10 +466,17 @@ pub fn damage( } _ => final_damage *= ts[7] as f32, } - let value = (final_damage * reduction_mul) as i32; - let absorbed = (final_damage * (1.0 - reduction_mul)) as i32; - let health_stolen = (value as f32 * (e.health_steal_ratio as f32 / 100.0)) as i32; - let mana_stolen = (value as f32 * (e.mana_steal_ratio as f32 / 100.0)) as i32; + let value = ((final_damage * reduction_mul) as i32).max(0); + // Native 1.2 damage diagnostic sub_39898330 (x2game12.c:1984147-1984167) + // multiplies the already integer damage, truncates, then enforces minimum 1. + // The final floor is unconditional in this landed-hit diagnostic, including + // multiplier 1. Misses and immunity returned above; only opted-in plots scale. + let value = aoe_multiplier + .map_or(value, |multiplier| (value as f32 * multiplier) as i32) + .max(1); + let absorbed = ((final_damage * (1.0 - reduction_mul)) as i32).max(0); + let health_stolen = ((value as f32 * (e.health_steal_ratio as f32 / 100.0)) as i32).max(0); + let mana_stolen = ((value as f32 * (e.mana_steal_ratio as f32 / 100.0)) as i32).max(0); let caster_t = Target::Obj(caster.clone()); let trg_t = Target::Obj(trg.clone()); let test_drive = matches!(args.cast, CastAction::Buff { buff_id: 6151, .. }); @@ -416,12 +486,15 @@ pub fn damage( return; } unit_combat::reduce_current_hp(server, &trg, Some(&caster), value, KillReason::Damage); - caster.with_unit(|u| u.unit_mut().summarize_damage += value); + caster.with_unit(|u| { + let u = u.unit_mut(); + u.summarize_damage = u.summarize_damage.saturating_add(value); + }); if health_stolen > 0 || mana_stolen > 0 { let pts = caster.with_unit(|u| { let u = u.unit_mut(); - u.hp = u.max_hp.min(u.hp + health_stolen); - u.mp = u.max_mp.min(u.mp + mana_stolen); + u.hp = u.max_hp.min(u.hp.saturating_add(health_stolen)); + u.mp = u.max_mp.min(u.mp.saturating_add(mana_stolen)); (u.hp, u.mp) }); if let Some((hp, mp)) = pts { @@ -510,7 +583,8 @@ pub fn damage( }, ); // Npc.OnDamageReceived: aggro + AI (npc subsystem) - unit_combat::add_unit_aggro(server, &trg, AggroKind::Damage, &caster, value); + let threat = ((value as f32 * e.aggro_multiplier) as i32).max(0); + unit_combat::add_damage_aggro(server, &trg, &caster, value, threat); server .systems .skills @@ -663,6 +737,19 @@ pub fn heal( } } value = (value as f32 * cs[4] as f32) as i32; + if let Some(skill) = args.source.skill() { + // Native 1.2 sub_3941A460: Heal (12) follows HealMul, for fixed and + // computed healing alike. Reuse the cache's percent/value conventions. + value = super::super::skill::apply_skill_modifiers( + server, + skill, + &caster, + crate::models::unit::SkillAttribute::Heal, + f64::from(value), + ) + .max(0.0) + .min(f64::from(i32::MAX)) as i32; + } if let Some(p) = caster.as_player() { if e.actability_group_id > 0 { let act = p @@ -714,7 +801,7 @@ pub fn heal( let Some((old, hp, mp)) = trg.with_unit(|u| { let u = u.unit_mut(); let old = u.hp; - u.hp = (u.hp + value).min(u.max_hp); + u.hp = u.hp.saturating_add(value).min(u.max_hp); (old, u.hp, u.mp) }) else { return; @@ -1056,17 +1143,5 @@ pub fn level_damage_range( } #[cfg(test)] -mod tests { - use super::*; - - #[test] - fn level_range_matches_csharp_integer_math() { - // (Level - 1) / 49 is an integer division: levels 1..49 use VaStart only. - let (lo, hi) = level_damage_range(100.0, 1.0, 10, 80, 120); - assert!((lo - (100.0 - 0.8 * 100.0 + 0.5)).abs() < 1e-4); - assert!((hi - (1.8 * 100.0 + 0.5)).abs() < 1e-4); - let (lo, hi) = level_damage_range(100.0, 1.0, 50, 80, 120); - assert!((lo - (100.0 - 1.2 * 100.0 + 0.5)).abs() < 1e-4); - assert!((hi - (2.2 * 100.0 + 0.5)).abs() < 1e-4); - } -} +#[path = "damage_pipeline_tests.rs"] +mod damage_pipeline_tests; diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs b/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs new file mode 100644 index 0000000000..c57895d552 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/effects/damage_pipeline_tests.rs @@ -0,0 +1,563 @@ +//! Damage pipeline regressions. Native 1.2 evidence: x2game12.c sub_398A7380 +//! (float level range), sub_39898330 (integer terms, final min 1 and late AoE), +//! sub_397C8760/sub_397C7A40/sub_397C85B0 (damage/cast/caster wire fields). +//! Percent evaluation is a compatibility interpretation of actual 1.2 descriptors; +//! the authoritative server formula is unavailable. No 10.x factors are imported. + +use std::sync::Arc; + +use aaemu_commons::PacketStream; + +use crate::data::world_data::SystemFaction; +use crate::data::GameData; +use crate::models::doodad::Doodad; +use crate::models::npc::Npc; +use crate::models::unit::{Bonus, BonusTemplate, UnitAttribute, UnitModifierType}; +use crate::opcodes::sc; +use crate::test_support::TestClient; +use crate::world::{Entity, WorldObject}; + +use super::super::super as skills; +use super::super::EffectSource; +use super::*; + +fn fixture_data() -> GameData { + let mut data = GameData::empty(); + data.formulas = crate::systems::vehicles::stats::tests::formulas( + // Character formulas use owner 0; owner 5 belongs to mates. + &[(1, "100000", 14, 0), (2, "1000", 15, 0), (3, "100", 12, 0)], + &[], + ); + for id in [3, 4] { + data.factions.add(SystemFaction { + id, + ..Default::default() + }); + } + data.systems.skills.add_buff(skills::data::BuffTemplate { + id: 900, + kind: 1, + stack_rule: 1, + melee_immune: true, + ..Default::default() + }); + data +} + +fn args(caster: WorldObject, target: WorldObject, level: u8) -> EffectArgs<'static> { + let skill = skills::state::SkillRun::new(Arc::new(skills::tests::skill_template(1)), level); + EffectArgs { + caster_caster: if caster.is_unit() { + SkillCaster::Unit(caster.obj_id()) + } else { + SkillCaster::Doodad(caster.obj_id()) + }, + caster: Some(caster), + target_caster: skills::types::SkillCastTarget::Unit(target.obj_id()), + target: Target::Obj(target), + cast: CastAction::Skill { + skill_id: 1, + tl_id: 0, + }, + source: EffectSource::from_skill(skill), + skill_object: &skills::types::SkillObject::None, + } +} + +fn packet(client: &mut TestClient, caster: u32, target: u32) -> (i32, u16, Vec) { + let frames: Vec<_> = client + .drain() + .into_iter() + .filter(|(op, _)| *op == sc::SCUnitDamagedPacket) + .collect(); + assert_eq!(frames.len(), 1); + let body = frames.into_iter().next().unwrap().1; + // Read in native 1.2 sub_397C8760 order; expected data is not encoded locally. + let mut s = PacketStream::from_bytes(body.clone()); + assert_eq!(s.read_u8().unwrap(), 0); + assert_eq!(s.read_u32().unwrap(), 1); + assert_eq!(s.read_u16().unwrap(), 0); + assert_eq!(s.read_u8().unwrap(), if caster == 0x300 { 4 } else { 0 }); + assert_eq!(s.read_bc().unwrap(), caster); + assert_eq!(s.read_bc().unwrap(), caster); + assert_eq!(s.read_bc().unwrap(), target); + assert_eq!(s.read_u8().unwrap(), 0); + let damage = s.read_pisc_w(3).unwrap(); + assert_eq!(damage[2], 0); + assert_eq!(s.read_pisc_w(3).unwrap(), [0, 0, 0]); + assert_eq!(s.read_u8().unwrap(), 0); + let dice = s.read_u16().unwrap(); + assert_eq!(s.read_u8().unwrap(), 1); + assert_eq!(s.read_u8().unwrap(), 1); + assert_eq!(s.remaining(), 0); + (damage[0] as i32, dice, body) +} + +fn bonus(obj: &WorldObject, attribute: UnitAttribute, value: i32) { + obj.with_unit(|u| { + u.unit_mut().bonuses.add_bonus( + attribute as u32, + Bonus { + template: BonusTemplate { + attribute, + modifier_type: UnitModifierType::Value, + value, + linear_level_bonus: 0, + }, + value, + }, + ) + }); +} + +#[test] +fn damage_pipeline_native_level_endpoints_interpolate_at_every_rank() { + // Actual 1.2 damage effect 1007: level_md .5, VaStart 10, VaEnd 1. + // sub_398A7380: +0.5, then truncation into each integer output. + for (level, expected) in [(1, (45, 55)), (25, (47, 53)), (50, (50, 51))] { + let (lo, hi) = level_damage_range(100.0, 0.5, level, 10, 1); + assert_eq!((lo as i32, hi as i32), expected); + } + for (start, end) in [(10, 1), (1, 15), (10, 15)] { + let ranges: Vec<_> = (1..=50) + .map(|level| level_damage_range(100.0, 0.5, level, start, end)) + .collect(); + for pair in ranges.windows(2) { + if start > end { + assert!(pair[1].0 >= pair[0].0 && pair[1].1 <= pair[0].1); + } else { + assert!(pair[1].0 <= pair[0].0 && pair[1].1 >= pair[0].1); + } + } + } +} + +#[tokio::test] +async fn damage_pipeline_level_ranges_reach_hp_packets_and_threat() { + for (level, range) in [(1, 45..=55), (25, 47..=53), (50, 50..=51)] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(1007, 0); + effect.use_fixed_damage = false; + effect.use_level_damage = true; + effect.level_md = 0.5; + effect.level_va_start = 10; + effect.level_va_end = 1; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), level), + None, + ); + let (dealt, dice, _) = packet(&mut client, player.obj_id, npc.obj_id); + assert!(range.contains(&dealt)); + assert_eq!(dice & 0x1f, SkillHitType::MeleeHit as u16); + let n = npc.data(); + assert_eq!(n.unit.hp, 1000 - dealt); + assert_eq!( + n.unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + dealt + ); + } +} + +#[tokio::test] +async fn damage_pipeline_authored_percent_and_current_health_bases() { + // Actual compact flags/percentages: 4754 = 99% current, 5027 = 1% maximum, + // 6047 = 50% maximum, 6198 enables fixed + level + percent together. + // Weapon and level terms are reduced to deterministic values in this fixture. + for (id, current, ratio, fixed, hp, maximum, expected) in [ + (4754, true, 99, false, 501, 1000, 495), + (4754, true, 99, false, 901, 1000, 891), + (5027, false, 1, false, 501, 1001, 10), + (6047, false, 50, false, 901, 1001, 500), + (6198, true, 10, true, 501, 1000, 150), + ] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(id, if fixed { 100 } else { 0 }); + effect.use_fixed_damage = fixed; + effect.use_percent_damage = true; + effect.percent_min = ratio; + effect.percent_max = ratio; + effect.use_current_health = current; + if id == 6198 { + effect.use_level_damage = true; + effect.level_md = 1.0; + } + { + let mut n = npc.data(); + n.unit.hp = hp; + n.unit.max_hp = maximum; + } + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + let expected = expected + if id == 6198 { 100 } else { 0 }; + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, expected); + let n = npc.data(); + assert_eq!(n.unit.hp, hp - expected); + assert_eq!( + n.unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + expected + ); + } + // use_current_health alone does not enable percentage damage (actual row 4957). + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(4957, 100); + effect.use_current_health = true; + effect.percent_min = 90; + effect.percent_max = 90; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, 100); +} + +#[tokio::test] +async fn damage_pipeline_scaled_threat_preserves_damage_and_kill_credit() { + for multiplier in [0.0, 1.0, 3.0, 100.0] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(2180, 100); + effect.aggro_multiplier = multiplier; + let target = WorldObject::from(&npc); + // Another player tagged first. Inflated threat must not steal its >50% credit. + npc.data().unit.skill_state.tagging.tagger = 0x999; + bonus(&WorldObject::from(&player), UnitAttribute::AggroMul, 50); + bonus(&target, UnitAttribute::IncomingAggroMul, 100); + client.drain(); + damage(&server, &effect, &args((&player).into(), target, 1), None); + let (dealt, _, body) = packet(&mut client, player.obj_id, npc.obj_id); + assert_eq!(dealt, 100); + // Literal native 1.2 wire fixture (cast skill 1, unit 0x100 -> 0x200, + // damage 100, absorbed/mana zero, melee hit). sub_397C8760, not a round trip. + assert_eq!( + body, + [ + 0, 1, 0, 0, 0, 0, 0, // cast + 0, 0, 1, 0, // unit caster + 0, 1, 0, 0, 2, 0, 0, // source, target, crime + 0, 100, 0, 0, // damage/absorbed/unused PISC + 0, 0, 0, 0, // mana PISC + 0, 0x21, 1, 1, 1, // holdable, dice, flags + ] + ); + let n = npc.data(); + assert_eq!(n.unit.hp, 900); + assert_eq!(n.unit.skill_state.tagging.taggers, [(player.obj_id, 100)]); + assert_eq!(n.unit.skill_state.tagging.tagger, 0x999); + if multiplier == 0.0 { + assert!(n.unit.skill_state.aggro_table.is_empty()); + assert!(!server + .systems + .skills + .aggro_watch + .lock() + .unwrap() + .contains_key(&player.obj_id)); + } else { + assert_eq!( + n.unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + (100.0 * multiplier * 1.5 * 2.0) as i32 + ); + } + } +} + +struct Armored; +impl skills::ext::NpcSkillHooks for Armored { + fn npc_attribute(&self, _: &GameServer, _: &Npc, attr: StatKind) -> Option { + (attr == StatKind::Armor).then_some(5300.0) + } +} + +#[tokio::test] +async fn damage_pipeline_minimum_and_late_aoe_apply_once_after_armor() { + for (amount, aoe, expected) in [ + (7, None, 3), + (7, Some(0.9), 2), + (1, None, 1), + (1, Some(0.1), 1), + (0, None, 1), + (-100, None, 1), + ] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + server.systems.skills.ext.npcs.install(Arc::new(Armored)); + let effect = skills::tests::damage_effect(1, amount); + client.drain(); + damage_with_aoe( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + aoe, + ); + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, expected); + assert_eq!(npc.data().unit.hp, 1000 - expected); + } +} + +#[tokio::test] +async fn damage_pipeline_percent_descriptor_multiplier_and_aoe_each_apply_once() { + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + let mut effect = skills::tests::damage_effect(5839, 0); + effect.use_fixed_damage = false; + effect.use_percent_damage = true; + effect.percent_min = 70; + effect.percent_max = 70; + effect.multiplier = 0.5; + client.drain(); + damage_with_aoe( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + Some(0.9), + ); + // 1000 max HP * 70% * descriptor .5 -> integer 350 * AoE .9 -> 315. + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, 315); + assert_eq!(npc.data().unit.hp, 685); + assert_eq!( + npc.data().unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + 315 + ); +} + +#[tokio::test] +async fn damage_pipeline_misses_and_immunity_stay_zero_with_or_without_aoe() { + for aoe in [None, Some(0.1)] { + for immune in [false, true] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + let a = args((&player).into(), (&npc).into(), 1); + if immune { + buffs::apply_template( + &server, + server.game_data.systems.skills.buff(900).unwrap(), + a.caster.as_ref(), + &a.caster_caster, + &WorldObject::from(&npc), + None, + ); + } else { + a.source + .skill + .as_ref() + .unwrap() + .state() + .hit_types + .insert(npc.obj_id, SkillHitType::MeleeMiss); + } + client.drain(); + damage_with_aoe( + &server, + &skills::tests::damage_effect(1, 100), + &a, + None, + aoe, + ); + let (dealt, dice, _) = packet(&mut client, player.obj_id, npc.obj_id); + assert_eq!(dealt, 0); + assert_eq!( + dice & 0x1f, + if immune { + SkillHitType::Immune + } else { + SkillHitType::MeleeMiss + } as u16 + ); + let n = npc.data(); + assert_eq!(n.unit.hp, 1000); + assert!(n.unit.skill_state.aggro_table.is_empty()); + assert!(n.unit.skill_state.tagging.taggers.is_empty()); + } + } +} + +#[tokio::test] +async fn damage_pipeline_nonunit_sources_and_hostile_target_authority() { + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + let mut d = Doodad::new(1); + d.transform.set_xyz(100.0, 100.0, 100.0); + let doodad = Entity::new(0x300, d); + server + .world + .world(0) + .unwrap() + .spawn(&doodad, &server.view_ctx()); + let effect = skills::tests::damage_effect(1, 100); + client.drain(); + damage( + &server, + &effect, + &args((&doodad).into(), (&npc).into(), 1), + None, + ); + assert_eq!(packet(&mut client, doodad.obj_id, npc.obj_id).0, 100); + assert_eq!(npc.data().unit.hp, 900); + assert!(npc.data().unit.skill_state.tagging.taggers.is_empty()); + let mut percent = skills::tests::damage_effect(861, 0); + percent.use_fixed_damage = false; + percent.use_percent_damage = true; + percent.percent_min = 35; + percent.percent_max = 35; + damage( + &server, + &percent, + &args((&doodad).into(), (&npc).into(), 1), + None, + ); + assert_eq!(packet(&mut client, doodad.obj_id, npc.obj_id).0, 350); + assert_eq!(npc.data().unit.hp, 550); + player.data().unit.faction_id = 4; + npc.data().unit.faction_id = 4; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + assert!(client + .drain() + .into_iter() + .all(|(op, _)| op != sc::SCUnitDamagedPacket)); + assert_eq!(npc.data().unit.hp, 550); + npc.data().unit.faction_id = 3; + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, 100); + assert_eq!(npc.data().unit.hp, 450); + damage( + &server, + &effect, + &args((&player).into(), (&doodad).into(), 1), + None, + ); + assert!(client + .drain() + .into_iter() + .all(|(op, _)| op != sc::SCUnitDamagedPacket)); +} + +#[tokio::test] +async fn damage_pipeline_npc_percent_attacks_select_pre_hit_player_hp() { + for (current, expected) in [(true, 495), (false, 990)] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + { + let mut p = player.data(); + p.unit.hp = 1001; + p.unit.max_hp = 2001; + } + let mut effect = skills::tests::damage_effect(4754, 0); + effect.use_fixed_damage = false; + effect.use_percent_damage = true; + effect.use_current_health = current; + effect.percent_min = 99; + effect.percent_max = 99; + // 5300 armor would halve melee damage; keep this sample at 0 armor, and + // use 50% incoming damage to observe both bases without killing the player. + bonus( + &WorldObject::from(&player), + UnitAttribute::IncomingMeleeDamageMul, + -500, + ); + client.drain(); + damage( + &server, + &effect, + &args((&npc).into(), (&player).into(), 1), + None, + ); + assert_eq!(packet(&mut client, npc.obj_id, player.obj_id).0, expected); + assert_eq!(player.data().unit.hp, 1001 - expected); + } +} + +#[tokio::test] +async fn damage_pipeline_new_threat_saturates_and_legacy_zero_callers_are_unchanged() { + let (server, _client, player, npc) = skills::cast_validation_tests::fixture(fixture_data()); + let target = WorldObject::from(&npc); + let caster = WorldObject::from(&player); + unit_combat::add_unit_aggro(&server, &target, AggroKind::Damage, &caster, 0); + assert!(npc + .data() + .unit + .skill_state + .aggro_table + .contains_key(&player.obj_id)); + unit_combat::add_damage_aggro(&server, &target, &caster, 10, i32::MAX); + unit_combat::add_damage_aggro(&server, &target, &caster, 10, i32::MAX); + let n = npc.data(); + assert_eq!( + n.unit.skill_state.aggro_table[&player.obj_id].damage_aggro, + i32::MAX + ); + assert_eq!(n.unit.skill_state.tagging.taggers, [(player.obj_id, 20)]); +} + +#[tokio::test] +async fn damage_pipeline_extreme_and_negative_inputs_never_heal_or_wrap() { + for amount in [i32::MIN, i32::MAX] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + // Health theft clamps to the cached pool, populated during normal stat refresh. + skills::stats::refresh_cached_stats(&server, &WorldObject::from(&player)); + player.data().unit.summarize_damage = i32::MAX; + player.data().unit.hp = 50; + let mut effect = skills::tests::damage_effect(1, amount); + effect.health_steal_ratio = i32::MAX; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + let dealt = packet(&mut client, player.obj_id, npc.obj_id).0; + assert_eq!(dealt, amount.max(1)); + assert_eq!(npc.data().unit.hp, (1000_i32).saturating_sub(dealt).max(0)); + assert_eq!(player.data().unit.summarize_damage, i32::MAX); + assert!(player.data().unit.hp >= 50); + } +} + +#[tokio::test] +async fn damage_pipeline_percent_uses_wide_arithmetic_and_never_emits_negative_damage() { + for ratio in [i32::MIN, i32::MAX] { + let (server, mut client, player, npc) = + skills::cast_validation_tests::fixture(fixture_data()); + npc.data().unit.max_hp = i32::MAX; + let mut effect = skills::tests::damage_effect(1, 0); + effect.use_fixed_damage = false; + effect.use_percent_damage = true; + effect.percent_min = ratio; + effect.percent_max = ratio; + client.drain(); + damage( + &server, + &effect, + &args((&player).into(), (&npc).into(), 1), + None, + ); + let expected = if ratio < 0 { 1 } else { i32::MAX }; + assert_eq!(packet(&mut client, player.obj_id, npc.obj_id).0, expected); + assert_eq!(npc.data().unit.hp, 1000_i32.saturating_sub(expected).max(0)); + } +} diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/mod.rs b/rust/crates/aaemu-game/src/systems/skills/effects/mod.rs index 4271576a70..75dd16753c 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/mod.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/mod.rs @@ -103,6 +103,35 @@ pub fn chance_succeeds(chance: i32) -> bool { chance > 0 && (chance >= 100 || rand::thread_rng().gen_range(0..100) < chance) } +/// Plot-specific context is explicit so resets and sibling damage invocations refer to +/// the originating plot instance, even when its SkillRun or caster has another active plot. +pub(super) fn apply_plot( + server: &GameServer, + kind: EffectKind, + template: &EffectTemplate, + args: &EffectArgs<'_>, + plot: &super::plots::PlotState, + aoe_diminishing: bool, +) { + match template { + EffectTemplate::Damage(t) => { + let multiplier = args + .target + .as_obj() + .filter(|target| aoe_diminishing && target.is_unit()) + .map(|target| { + plot.aoe_damage_multiplier( + &server.game_data.systems.skills.plots.aoe_diminishings, + target.obj_id(), + ) + }); + combat::damage_with_aoe(server, t, args, None, multiplier); + } + EffectTemplate::ResetAoeDiminishing { .. } => plot.reset_aoe_diminishing(), + _ => apply(server, kind, template, args, None), + } +} + /// `EffectTemplate.Apply` dispatch. pub fn apply( server: &GameServer, @@ -124,6 +153,7 @@ pub fn apply( T::Aggro(t) => combat::aggro(server, t, args), T::Special(t) => special::apply(server, t, args), T::FlyingStateChange { .. } => combat::flying_state_change(server, template, args), + // A reset has meaning only with its originating plot's context (`apply_plot`). T::ResetAoeDiminishing { .. } => {} T::SkillController(t) => combat::skill_controller(server, t, args), T::Bubble { id, kind_id } => unit_fx::bubble(server, *id, *kind_id, args), diff --git a/rust/crates/aaemu-game/src/systems/skills/effects/special/movement.rs b/rust/crates/aaemu-game/src/systems/skills/effects/special/movement.rs index 8aea4bb280..0cc66460e7 100644 --- a/rust/crates/aaemu-game/src/systems/skills/effects/special/movement.rs +++ b/rust/crates/aaemu-game/src/systems/skills/effects/special/movement.rs @@ -657,6 +657,21 @@ pub fn return_(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { } if let Some(t) = &trp { if in_instance { + if !crate::world::session::zone_access_allowed( + server, + p, + instance_id, + t.zone_id, + t.x, + t.y, + ) { + p.send(SCErrorMsgPacket::new( + crate::world::session::CLOSED_ZONE, + 0, + true, + )); + return; + } move_within_instance(server, p, t); return; } @@ -664,6 +679,21 @@ pub fn return_(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { trp }; if let Some(t) = &trp { + if !crate::world::session::zone_access_allowed( + server, + p, + DEFAULT_INSTANCE_ID, + t.zone_id, + t.x, + t.y, + ) { + p.send(SCErrorMsgPacket::new( + crate::world::session::CLOSED_ZONE, + 0, + true, + )); + return; + } p.data().set_disabled_set_position(true); p.send(SCLoadInstancePacket { instance_id: DEFAULT_INSTANCE_ID, @@ -682,6 +712,21 @@ pub fn return_(server: &GameServer, args: &EffectArgs<'_>, v: [i32; 4]) { PositionAndRotation::new(t.x, t.y, t.z, 0.0, 0.0, deg_to_rad(t.yaw)), ); } else if let Some(m) = npcs.main_world_position(server, p).filter(|_| !in_instance) { + if !crate::world::session::zone_access_allowed( + server, + p, + m.instance_id, + m.zone_id, + m.pos.x, + m.pos.y, + ) { + p.send(SCErrorMsgPacket::new( + crate::world::session::CLOSED_ZONE, + 0, + true, + )); + return; + } p.data().set_disabled_set_position(true); p.send(SCLoadInstancePacket { instance_id: m.instance_id, diff --git a/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs new file mode 100644 index 0000000000..7f81fcec1f --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/modifier_flow_tests.rs @@ -0,0 +1,704 @@ +//! Modifier application regressions. Rows below retain the 1.2 compact IDs/units; +//! reduced channel times keep the scheduler tests short. Packet fields are read in native +//! 1.2 order (D:/aa-re/client12/decomp/x2game12.c): 397C6580 (XP), 397CA390 +//! (fired), 397C8760 (damage), 397C8EF0 (heal). No encoder generates expected packets. + +use std::sync::Arc; +use std::time::Duration; + +use aaemu_commons::PacketStream; + +use crate::data::GameData; +use crate::models::unit::{ + BonusTemplate, BuffAttribute, BuffModifier, SkillAttribute, SkillModifier, UnitAttribute, + UnitModifierType, +}; +use crate::opcodes::sc; +use crate::systems::skills; +use crate::test_support::{test_experience, TestClient}; +use crate::world::{NpcRef, PlayerRef, WorldObject}; + +use skills::data::effects::HealEffect; +use skills::data::{BuffTemplate, EffectKind, EffectTemplate, SkillTemplate, TickEffect}; +use skills::state::{AutoAttackSlot, CancelToken, SkillRef, SkillRun}; +use skills::types::{SkillCastTarget, SkillCaster, SkillObject}; + +fn data() -> GameData { + let mut data = GameData::empty(); + data.experience = test_experience(55); + data.formulas = crate::systems::vehicles::stats::tests::formulas( + &[(1, "100000", 14, 0), (2, "1000", 15, 0)], + &[], + ); + data +} + +fn bonus(attribute: UnitAttribute, value: i32) -> BonusTemplate { + BonusTemplate { + attribute, + modifier_type: UnitModifierType::Value, + value, + linear_level_bonus: 0, + } +} + +fn add_boost(data: &mut GameData, id: u32, bonuses: Vec) { + data.systems.skills.add_buff(BuffTemplate { + id, + kind: 1, + stack_rule: 1, + bonuses, + ..Default::default() + }); +} + +fn add_skill_modifier( + data: &mut GameData, + owner: u32, + skill_id: u32, + attr: SkillAttribute, + kind: UnitModifierType, + value: i32, +) { + add_boost(data, owner, vec![]); + data.systems + .skills + .skill_modifiers + .entry(owner) + .or_default() + .push(SkillModifier { + id: owner, + owner_id: owner, + tag_id: 0, + skill_attribute: attr, + unit_modifier_type: kind, + value, + skill_id, + synergy: false, + }); +} + +fn apply_boost(server: &crate::GameServer, player: &PlayerRef, id: u32) { + let me = WorldObject::from(player); + skills::buffs::apply_template( + server, + server.game_data.systems.skills.buff(id).unwrap(), + Some(&me), + &SkillCaster::Unit(player.obj_id), + &me, + None, + ); + assert!(player.data().unit.buffs.check_buff(id)); +} + +fn cast(server: &crate::GameServer, player: &PlayerRef, target: u32, skill: &SkillRef) { + assert_eq!( + super::use_skill( + server, + skill, + &WorldObject::from(player), + SkillCaster::Unit(player.obj_id), + &mut SkillCastTarget::Unit(target), + Some(SkillObject::None), + true, + ) + .0, + 0, + ); +} + +// Native 1.2 sub_397C7A40 (cast union), sub_397C85B0 (caster), and the readers above. +fn read_effect(s: &mut PacketStream, op: u16) -> (u32, i64) { + match s.read_u8().unwrap() { + 0 => { + s.read_u32().unwrap(); + s.read_u16().unwrap(); + } + 2 => { + s.read_u32().unwrap(); + s.read_bc().unwrap(); + s.read_u32().unwrap(); + s.read_bool().unwrap(); + s.read_bool().unwrap(); + } + other => panic!("unexpected cast union {other}"), + } + assert_eq!(s.read_u8().unwrap(), 0); // unit caster + assert_eq!(s.read_bc().unwrap(), 0x100); + if op == sc::SCUnitDamagedPacket { + assert_eq!(s.read_bc().unwrap(), 0x100); // caster ID + let target = s.read_bc().unwrap(); + s.read_u8().unwrap(); // crime + let damage = s.read_pisc_w(3).unwrap(); + s.read_pisc_w(3).unwrap(); // mana burn + s.read_u8().unwrap(); // holdable + s.read_u16().unwrap(); // dice + s.read_u8().unwrap(); + s.read_u8().unwrap(); + (target, damage[0]) + } else { + assert_eq!(op, sc::SCUnitHealedPacket); + let target = s.read_bc().unwrap(); + assert_eq!(s.read_u8().unwrap(), 0); // health + assert_eq!(s.read_u8().unwrap(), 13); // noncritical heal + let value = s.read_i32().unwrap(); + assert_eq!(s.read_i32().unwrap(), 0); // overheal field + assert!(s.read_bool().unwrap()); + (target, i64::from(value)) + } +} + +fn effects(client: &mut TestClient) -> Vec<(u32, i64)> { + let mut out = vec![]; + for (op, body) in client.drain() { + if op & 0x8000 != 0 { + let raw = skills::packets::inflate_stored(&body).unwrap(); + let mut s = PacketStream::from_bytes(raw); + for _ in 0..(op & 0x7fff) { + assert_eq!(s.read_u16().unwrap(), 0); + let op = s.read_u16().unwrap(); + out.push(read_effect(&mut s, op)); + } + assert!(s.unread().is_empty()); + } else if op == sc::SCUnitDamagedPacket || op == sc::SCUnitHealedPacket { + out.push(read_effect(&mut PacketStream::from_bytes(body), op)); + } + } + out +} + +#[tokio::test] +async fn modifier_exp_buff_boosts_positive_xp_and_active_abilities_only() { + let mut data = data(); + // compact unit_modifiers: buff 3084, ExpMul, Value +20 (percentage points). + add_boost(&mut data, 3084, vec![bonus(UnitAttribute::ExpMul, 20)]); + let (server, mut client, player, _) = skills::cast_validation_tests::fixture(data); + { + let mut c = player.data(); + c.experience = 10_000; + [c.ability1, c.ability2, c.ability3] = [1, 2, 3]; + for a in c.abilities.abilities.iter_mut().take(3) { + a.exp = 10_000; + } + } + client.drain(); + skills::progress::add_exp(&server, &player, 100, true); + // Native 1.2 sub_397C6580: BC unit ID, signed i32 XP delta, boolean ability flag. + assert!(client + .drain() + .contains(&(sc::SCExpChangedPacket, vec![0, 1, 0, 100, 0, 0, 0, 1]))); + apply_boost(&server, &player, 3084); + client.drain(); + skills::progress::add_exp(&server, &player, 100, true); + assert!(client + .drain() + .contains(&(sc::SCExpChangedPacket, vec![0, 1, 0, 120, 0, 0, 0, 1]))); + assert_eq!(player.data().experience, 10_220); + for a in &player.data().abilities.abilities { + assert_eq!(a.exp, if a.id <= 3 { 10_220 } else { 0 }); + } + skills::progress::add_exp(&server, &player, -30, true); + assert_eq!(player.data().experience, 10_190); // death/ordinary loss unchanged + skills::progress::add_exp(&server, &player, 100, false); + assert_eq!(player.data().experience, 10_310); + assert_eq!(player.data().abilities.abilities[0].exp, 10_190); + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 3084); + skills::progress::add_exp(&server, &player, 100, true); + assert_eq!(player.data().experience, 10_410); +} + +#[tokio::test] +async fn modifier_exp_config_composes_and_large_gains_preserve_level_caps() { + let mut data = data(); + add_boost(&mut data, 3084, vec![bonus(UnitAttribute::ExpMul, 20)]); + let server = crate::test_support::test_server_with(data); + server.config.update(|c| c.world.exp_rate = 2.0); + let mut c = crate::test_support::test_character(1, "XP", 100.0, 100.0); + c.experience = 10_000; + c.ability1 = 1; + c.unit.bonuses.add_bonus( + 1, + crate::models::unit::Bonus { + template: bonus(UnitAttribute::ExpMul, 20), + value: 20, + }, + ); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, 100, true) + .unwrap() + .exp, + 240 + ); + skills::progress::add_exp_locked(&server, &mut c, i32::MAX, true).unwrap(); + assert_eq!(c.unit.level, 55); + assert_eq!(c.experience, 55_000); + assert_eq!(c.abilities.abilities[0].exp, 55_000); + server.config.update(|c| c.world.exp_rate = -1.0); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, 100, true) + .unwrap() + .exp, + 0 + ); + assert_eq!( + skills::progress::add_exp_locked(&server, &mut c, -10, false) + .unwrap() + .exp, + -10 + ); +} + +struct Weapons; +impl skills::ext::ItemSkillHooks for Weapons { + fn weapon_holdable( + &self, + _: &crate::GameServer, + _: &WorldObject, + slot: i32, + ) -> Option { + Some(skills::ext::HoldableInfo { + speed: match slot { + 15 => 1500.0, + 16 => 2000.0, + 17 => 1800.0, + _ => return None, + }, + slot_type_id: skills::stats::slot_type::ONE_HANDED, + max_range: 30.0, + ..Default::default() + }) + } +} + +#[tokio::test] +async fn modifier_attack_delay_uses_the_weapon_and_matching_haste_once() { + let mut data = data(); + // compact buff 933: MeleeSpeedMul +300; ranged should be unchanged. + add_boost( + &mut data, + 933, + vec![bonus(UnitAttribute::MeleeSpeedMul, 300)], + ); + add_boost( + &mut data, + 1447, + vec![bonus(UnitAttribute::RangedSpeedMul, -200)], + ); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 100))), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + server.systems.skills.ext.items.install(Arc::new(Weapons)); + let me = WorldObject::from(&player); + for (id, slot, base, boosted) in [ + (2, 15, 1500.0, 1500.0 / 1.3), + (3, 16, 2000.0, 2000.0 / 1.3), + (4, 17, 1800.0, 1800.0), + ] { + let t = SkillTemplate { + weapon_slot_for_auto_attack_id: slot, + effects: vec![skills::tests::skill_effect(1, EffectKind::DamageEffect, 1)], + ..skills::tests::skill_template(id) + }; + assert_eq!(super::attack_delay(&server, &t, &me, true, 1000.0), base); + apply_boost(&server, &player, 933); + assert!((super::attack_delay(&server, &t, &me, true, 1000.0) - boosted).abs() < 0.001); + let skill = SkillRun::new(Arc::new(t), 1); + let cancel = CancelToken::new(); + { + let mut c = player.data(); + c.unit.current_target = npc.obj_id; + c.unit.skill_state.auto_attack = Some(AutoAttackSlot { + skill: skill.clone(), + cancel: cancel.clone(), + }); + } + client.drain(); + assert_eq!( + super::auto_attack_tick(&server, &player, &skill, &cancel), + Some(boosted as i64) + ); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 100)]); + skills::buffs::remove_buff(&server, &me, 933); + } + apply_boost(&server, &player, 1447); + let t = skills::tests::skill_template(4); + assert_eq!(super::attack_delay(&server, &t, &me, true, 1000.0), 2250.0); + // Haste and GCD are distinct attributes; the GCD factor is included once. + player.data().unit.bonuses.add_bonus( + 999, + crate::models::unit::Bonus { + template: bonus(UnitAttribute::GlobalCooldownMul, 1000), + value: 1000, + }, + ); + assert_eq!(super::attack_delay(&server, &t, &me, true, 1000.0), 1125.0); +} + +fn heal_effect() -> HealEffect { + HealEffect { + id: 1, + use_fixed_heal: true, + fixed_min: 100, + fixed_max: 100, + use_level_heal: false, + level_md: 0.0, + level_va_start: 0, + level_va_end: 0, + percent: false, + use_charged_buff: false, + charged_buff_id: 0, + charged_mul: 0.0, + slave_applicable: false, + ignore_heal_aggro: false, + dps_multiplier: 0.0, + actability_group_id: 0, + actability_step: 0, + actability_mul: 0.0, + actability_add: 0.0, + } +} + +#[tokio::test] +async fn modifier_heal_buff_changes_actual_healing_and_packet_once() { + for fixed in [false, true] { + heal_with_modifier(fixed).await; + } +} + +async fn heal_with_modifier(fixed: bool) { + let mut data = data(); + // compact row 412: buff 5254, Fervent Healing 14929, Heal +7 percent. + add_skill_modifier( + &mut data, + 5254, + 14929, + SkillAttribute::Heal, + UnitModifierType::Percent, + 7, + ); + let mut effect = heal_effect(); + effect.use_fixed_heal = fixed; + effect.dps_multiplier = 1.0; + data.systems + .skills + .add_effect(EffectKind::HealEffect, EffectTemplate::Heal(effect), 1); + add_boost(&mut data, 999, vec![bonus(UnitAttribute::HealDps, 100_000)]); + let (server, mut client, player, _) = skills::cast_validation_tests::fixture(data); + apply_boost(&server, &player, 999); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + target_type: 0, + effects: vec![skills::tests::skill_effect(1, EffectKind::HealEffect, 1)], + ..skills::tests::skill_template(14929) + }), + 1, + ); + for (boosted, expected) in [(false, 100), (true, 107), (false, 100)] { + if boosted { + apply_boost(&server, &player, 5254); + } else { + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 5254); + } + player.data().unit.hp = 500; + client.drain(); + cast(&server, &player, player.obj_id, &skill); + assert_eq!(player.data().unit.hp, 500 + expected); + assert_eq!( + effects(&mut client), + vec![(player.obj_id, i64::from(expected))] + ); + } +} + +#[tokio::test] +async fn modifier_existing_skill_damage_is_still_applied_once() { + let mut data = data(); + add_skill_modifier( + &mut data, + 900, + 10001, + SkillAttribute::Damage, + UnitModifierType::Percent, + 10, + ); + add_boost( + &mut data, + 901, + // Keep both f32 weapon-damage endpoints exact before floor/ceil, so + // random sampling cannot obscure whether the modifier was applied once. + vec![bonus(UnitAttribute::MainhandDps, 80_000)], + ); + let mut damage = skills::tests::damage_effect(1, 0); + damage.use_fixed_damage = false; + damage.use_mainhand_weapon = true; + damage.dps_multiplier = 1.0; + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(damage)), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + apply_boost(&server, &player, 901); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + effects: vec![skills::tests::skill_effect(1, EffectKind::DamageEffect, 1)], + ..skills::tests::skill_template(10001) + }), + 1, + ); + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 80)]); + assert_eq!(npc.data().unit.hp, 920); + apply_boost(&server, &player, 900); + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 88)]); + assert_eq!(npc.data().unit.hp, 832); + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 900); + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + assert_eq!(effects(&mut client), vec![(npc.obj_id, 80)]); + assert_eq!(npc.data().unit.hp, 752); +} + +#[tokio::test] +async fn modifier_native_channel_upgrade_adds_four_seconds() { + let mut data = data(); + // Unscaled compact row 470: Protective Wings 10714, buff 5326, +4000ms. + add_skill_modifier( + &mut data, + 5326, + 10714, + SkillAttribute::ChannelingTime, + UnitModifierType::Value, + 4000, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + channeling_time: 18000, + channeling_tick: 1000, + ..skills::tests::skill_template(10714) + }), + 1, + ); + for (boosted, expected) in [(false, 1810), (true, 2210)] { + if boosted { + apply_boost(&server, &player, 5326); + } + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + let fired = client + .drain() + .into_iter() + .find(|(op, _)| *op == sc::SCSkillFiredPacket) + .unwrap() + .1; + assert_eq!( + i16::from_le_bytes(fired[17..19].try_into().unwrap()), + expected + ); + super::stop(&server, &skill, &WorldObject::from(&player), 0); + } +} + +#[tokio::test] +async fn modifier_buff_damage_matches_buff_id_or_tag_and_disappears_on_removal() { + for by_tag in [false, true] { + let mut data = data(); + let owner = if by_tag { 5263 } else { 356 }; + add_boost(&mut data, owner, vec![]); + data.systems.skills.buff_game_data.buff_modifiers.insert( + owner, + vec![BuffModifier { + id: if by_tag { 95 } else { 2 }, + owner_id: owner, + buff_id: if by_tag { 0 } else { 121 }, + tag_id: if by_tag { 36 } else { 0 }, + buff_attribute: BuffAttribute::Damage, + unit_modifier_type: UnitModifierType::Percent, + value: 10, + synergy: false, + }], + ); + data.systems.skills.buff_tags.insert(121, vec![36]); + data.systems.skills.add_buff(BuffTemplate { + id: 121, + kind: 2, + duration: 1000, + tick: 1000.0, + stack_rule: 1, + tick_effects: vec![TickEffect { + effect_id: 1, + target_buff_tag_id: 0, + target_no_buff_tag_id: 0, + }], + ..Default::default() + }); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 100))), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + let me = WorldObject::from(&player); + let target = WorldObject::from(&npc); + for (boosted, expected) in [(false, 100), (true, 110), (false, 100)] { + if boosted { + apply_boost(&server, &player, owner); + } else { + skills::buffs::remove_buff(&server, &me, owner); + } + skills::buffs::apply_template( + &server, + server.game_data.systems.skills.buff(121).unwrap(), + Some(&me), + &SkillCaster::Unit(player.obj_id), + &target, + None, + ); + let index = npc + .data() + .unit + .buffs + .effects + .iter() + .find(|b| b.template.id == 121) + .unwrap() + .index; + let before = npc.data().unit.hp; + client.drain(); + // Drive the real buff tick synchronously; do not duplicate its EffectSource setup. + skills::buffs::schedule_effect(&server, &target, index, false); + assert_eq!(npc.data().unit.hp, before - expected); + assert_eq!( + effects(&mut client), + vec![(npc.obj_id, i64::from(expected))] + ); + skills::buffs::remove_buff(&server, &target, 121); + } + } +} + +#[tokio::test] +async fn modifier_area_buff_expands_real_target_selection_in_meters() { + let mut data = data(); + // compact row 371: buff 5206 adds 5m to skill 11395's 5m radius. + add_skill_modifier( + &mut data, + 5206, + 11395, + SkillAttribute::AreaRadius, + UnitModifierType::Value, + 5, + ); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 100))), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + player.data().unit.transform.set_xyz(100.0, 90.0, 100.0); + let world = server.world.world(0).unwrap(); + let mut other = crate::models::npc::Npc::new(1); + other.unit.hp = 1000; + other.unit.max_hp = 1000; + other.unit.transform.set_xyz(100.0, 112.0, 100.0); // 7m from original target + let other: NpcRef = crate::world::Entity::new(0x201, other); + world.spawn(&other, &server.view_ctx()); + let skill = SkillRun::new( + Arc::new(SkillTemplate { + target_area_radius: 5, + target_relation: 0, + target_selection: 1, + effects: vec![skills::tests::skill_effect(1, EffectKind::DamageEffect, 1)], + ..skills::tests::skill_template(11395) + }), + 1, + ); + for (boosted, count) in [(false, 1), (true, 2), (false, 1)] { + if boosted { + apply_boost(&server, &player, 5206); + } else { + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 5206); + } + client.drain(); + let before = other.data().unit.hp; + cast(&server, &player, npc.obj_id, &skill); + let packets = effects(&mut client); + assert_eq!(packets.len(), count); + assert!(packets.contains(&(npc.obj_id, 100))); + assert_eq!(other.data().unit.hp, before - if boosted { 100 } else { 0 }); + } +} + +#[tokio::test(start_paused = true)] +async fn modifier_channel_packet_and_ticks_share_a_snapshot_of_duration() { + for boosted in [false, true] { + let mut data = data(); + // Same Value/millisecond semantics as compact 5326 (+4000ms). Small values + // let this test observe expiry and the ticks beyond the original duration. + add_skill_modifier( + &mut data, + 5326, + 10714, + SkillAttribute::ChannelingTime, + UnitModifierType::Value, + 200, + ); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(skills::tests::damage_effect(1, 10))), + 1, + ); + let (server, mut client, player, npc) = skills::cast_validation_tests::fixture(data); + if boosted { + apply_boost(&server, &player, 5326); + } + let skill = SkillRun::new( + Arc::new(SkillTemplate { + channeling_time: 200, + channeling_tick: 50, + effects: vec![skills::tests::skill_effect(1, EffectKind::DamageEffect, 1)], + ..skills::tests::skill_template(10714) + }), + 1, + ); + client.drain(); + cast(&server, &player, npc.obj_id, &skill); + let fired = client + .drain() + .into_iter() + .find(|(op, _)| *op == sc::SCSkillFiredPacket) + .unwrap() + .1; + // Native sub_397CA390: ID, timeline, caster, target, object, two msec fields. + // Pin the current wire's duration field independently of the packet encoder. + let wire_duration = i16::from_le_bytes(fired[17..19].try_into().unwrap()); + assert_eq!(wire_duration, if boosted { 50 } else { 30 }); + skills::buffs::remove_buff(&server, &WorldObject::from(&player), 5326); + // Install the spawned timers, then visit each deadline. Wall-clock sleeps + // can skip a tick under unrelated machine load and don't test this snapshot. + tokio::task::yield_now().await; + for _ in 0..5 { + tokio::time::advance(Duration::from_millis(50)).await; + tokio::task::yield_now().await; + } + tokio::time::advance(Duration::from_millis(20)).await; + tokio::task::yield_now().await; + assert_eq!(player.data().unit.skill_state.skill_task.is_some(), boosted); + for step in [30, 50, 50, 50] { + tokio::time::advance(Duration::from_millis(step)).await; + tokio::task::yield_now().await; + } + assert!(player.data().unit.skill_state.skill_task.is_none()); + let packets = effects(&mut client); + assert_eq!(packets.len(), if boosted { 7 } else { 3 }); + assert!(packets.iter().all(|p| *p == (npc.obj_id, 10))); + assert_eq!(npc.data().unit.hp, if boosted { 930 } else { 970 }); + } +} diff --git a/rust/crates/aaemu-game/src/systems/skills/packets.rs b/rust/crates/aaemu-game/src/systems/skills/packets.rs index c64c192185..d8b50b83ff 100644 --- a/rust/crates/aaemu-game/src/systems/skills/packets.rs +++ b/rust/crates/aaemu-game/src/systems/skills/packets.rs @@ -404,8 +404,8 @@ pub struct CooldownEntry { /// `SCCooldownsPacket`: the unit's running skill / tag cooldowns (`i32` count + entries each). /// The C# only ever sent it empty. The client's record reader (`397b64d0` -> `397b2350`) /// appends to its cooldown manager (an empty packet is not a reset) and holds 150 entries per -/// list, so the writer never emits more. The server tracks no tag cooldowns, and keeps only the -/// end time of a skill cooldown, so `total` is reported as the remaining time. +/// list, so the writer never emits more. The server keeps expiry times for both stores, +/// so `total` is reported as the remaining time. #[derive(Debug, Clone, PartialEq, Eq, Default)] pub struct SCCooldownsPacket { pub skills: Vec, @@ -415,26 +415,28 @@ impl SCCooldownsPacket { /// Entry cap per list of the client's record. pub const MAX_ENTRIES: usize = 150; - /// The still-running cooldowns of `cooldowns` at `now_ms`, ordered by skill id. + /// Still-running individual and shared cooldowns, each ordered by id and capped. pub fn from_cooldowns(cooldowns: &crate::models::unit::UnitCooldowns, now_ms: i64) -> Self { - let mut skills: Vec = cooldowns - .cooldowns - .iter() - .filter(|(_, &end)| end > now_ms) - .map(|(&id, &end)| { - let remaining = (end - now_ms).min(i64::from(u32::MAX)) as u32; - CooldownEntry { - id, - total_ms: remaining, - remaining_ms: remaining, - } - }) - .collect(); - skills.sort_by_key(|e| e.id); - skills.truncate(Self::MAX_ENTRIES); + let entries = |store: &std::collections::HashMap| { + let mut entries: Vec = store + .iter() + .filter(|(_, &end)| end > now_ms) + .map(|(&id, &end)| { + let remaining = end.saturating_sub(now_ms).min(i64::from(u32::MAX)) as u32; + CooldownEntry { + id, + total_ms: remaining, + remaining_ms: remaining, + } + }) + .collect(); + entries.sort_by_key(|e| e.id); + entries.truncate(Self::MAX_ENTRIES); + entries + }; Self { - skills, - tags: Vec::new(), + skills: entries(&cooldowns.cooldowns), + tags: entries(&cooldowns.tag_cooldowns), } } diff --git a/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs b/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs new file mode 100644 index 0000000000..0e08499fc1 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/skills/plot_aoe_tests.rs @@ -0,0 +1,617 @@ +//! Provisional server AoE policy regressions, not retail parity claims. Native clients +//! expose descriptors/diagnostics, but the authoritative world-server counter is unavailable. +//! These tests drive real plot effects and combat; expected ranks implement the reviewed +//! compatibility policy in PORTING.md. No client packet format is introduced or changed. + +use super::*; + +use crate::data::world_data::SystemFaction; +use crate::data::GameData; +use crate::models::npc::Npc; +use crate::models::unit::{Bonus, BonusTemplate, SkillModifier, UnitAttribute, UnitModifierType}; +use crate::test_support::TestClient; +use crate::world::{Entity, NpcRef, PlayerRef}; + +use super::super::data::effects::{BuffEffect, HealEffect}; +use super::super::data::misc::AreaShape; +use super::super::data::plots::{PlotEventEffect, PlotNextEvent, PlotNode}; +use super::super::data::{BuffTemplate, SkillTemplate}; +use super::super::state::SkillRun; +use super::super::types::{SkillCastTarget, SkillCaster, SkillHitType, SkillObject}; + +const PLOT: u32 = 1; +const SKILL: u32 = 11939; +const DAMAGE: u32 = 3172; +const DAMAGE_EVENT: u32 = 2723; +const RESET_EVENT: u32 = 246; +const UNFLAGGED_EVENT: u32 = 900_001; +const OTHER_FLAGGED_EVENT: u32 = 900_002; +const NON_DAMAGE_EVENT: u32 = 900_003; +const HP: i32 = 100_000; + +fn plot_effect(actual_type: &str, actual_id: u32) -> PlotEventEffect { + PlotEventEffect { + position: 1, + source_id: 1, + target_id: 4, + actual_id, + actual_type: actual_type.into(), + } +} + +fn event(id: u32, diminishing: bool, effects: Vec) -> PlotEventTemplate { + PlotEventTemplate { + id, + plot_id: PLOT, + position: 1, + source_update_method_id: 1, + target_update_method_id: 4, + aoe_diminishing: diminishing, + effects, + ..Default::default() + } +} + +fn data() -> GameData { + let mut data = GameData::empty(); + data.formulas = crate::systems::vehicles::stats::tests::formulas( + &[(1, "100000", 14, 0), (2, "1000", 15, 0)], + &[], + ); + for id in [3, 4] { + data.factions.add(SystemFaction { + id, + ..Default::default() + }); + } + let skills = &mut data.systems.skills; + skills.plots.aoe_diminishings = [ + (1, 100.0), + (2, 90.0), + (3, 80.0), + (4, 70.0), + (5, 55.0), + (6, 40.0), + (7, 25.0), + (8, 10.0), + (9, 10.0), + (10, 10.0), + ] + .into(); + skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(super::super::tests::damage_effect(DAMAGE, 1000))), + 1, + ); + skills.add_effect( + EffectKind::ResetAoeDiminishingEffect, + EffectTemplate::ResetAoeDiminishing { id: 2 }, + 2, + ); + for (id, diminishing) in [ + (DAMAGE_EVENT, true), + (UNFLAGGED_EVENT, false), + (OTHER_FLAGGED_EVENT, true), + ] { + skills.plots.events.insert( + id, + event(id, diminishing, vec![plot_effect("DamageEffect", DAMAGE)]), + ); + } + // Native plot_effects row 5680: event 246, descriptor 2, source 1, target 3. + let mut reset = plot_effect("ResetAoeDiminishingEffect", 2); + reset.target_id = 3; + skills + .plots + .events + .insert(RESET_EVENT, event(RESET_EVENT, false, vec![reset])); + data +} + +fn fixture(data: GameData, count: u32) -> (Arc, TestClient, PlayerRef, Vec) { + let (server, client, player, _) = super::super::cast_validation_tests::fixture(data); + player.data().unit.faction_id = 4; + super::super::stats::refresh_cached_stats(&server, &WorldObject::from(&player)); + let targets = (0..count) + .map(|i| { + let mut npc = Npc::new(1); + npc.unit.hp = HP; + npc.unit.max_hp = HP; + npc.unit.faction_id = 3; + npc.unit + .transform + .set_xyz(100.0 + i as f32 * 0.01, 100.0, 100.0); + let npc = Entity::new(0x300 + i, npc); + server + .world + .world(0) + .unwrap() + .spawn(&npc, &server.view_ctx()); + npc + }) + .collect(); + (server, client, player, targets) +} + +fn state(caster: &WorldObject, target: &NpcRef, skill: Option) -> Arc { + let skill = skill.unwrap_or_else(|| { + SkillRun::new( + Arc::new(SkillTemplate { + plot_id: Some(PLOT), + plot_only: true, + target_alive: true, + target_relation: 4, + ..super::super::tests::skill_template(SKILL) + }), + 1, + ) + }); + PlotState::new( + skill, + CastCtx { + caster: caster.clone(), + caster_caster: SkillCaster::Unit(caster.obj_id()), + target: Target::Obj(WorldObject::from(target)), + target_caster: SkillCastTarget::Unit(target.obj_id), + skill_object: SkillObject::None, + }, + ) +} + +fn node(event_id: u32) -> PlotNode { + PlotNode { + event_id, + parent: None, + parent_next_event: None, + children: vec![], + } +} + +/// Real PlotNode -> apply_plot_effect -> effect dispatch -> damage/heal/buff execution. +fn fire(server: &GameServer, state: &Arc, event_id: u32, targets: &[NpcRef]) { + let mut ti = PlotTargetInfo::new( + Some(Target::Obj(state.caster().clone())), + Some(Target::Obj(WorldObject::from(&targets[0]))), + ); + ti.effected = targets + .iter() + .map(|t| Target::Obj(WorldObject::from(t))) + .collect(); + execute_node( + server, + &PlotTree { + plot_id: PLOT, + nodes: vec![node(event_id)], + }, + 0, + state, + &ti, + ); +} + +fn damage( + server: &GameServer, + state: &Arc, + event_id: u32, + targets: &[NpcRef], +) -> Vec { + let before: Vec<_> = targets.iter().map(|t| t.data().unit.hp).collect(); + fire(server, state, event_id, targets); + before + .into_iter() + .zip(targets) + .map(|(hp, t)| hp - t.data().unit.hp) + .collect() +} + +#[tokio::test] +async fn aoe_policy_plot_damage_targets_one_through_twelve_and_reuses_floor_targets() { + let (server, _client, player, targets) = fixture(data(), 12); + let state = state(&WorldObject::from(&player), &targets[0], None); + assert_eq!( + damage(&server, &state, DAMAGE_EVENT, &targets), + [1000, 900, 800, 700, 550, 400, 250, 100, 100, 100, 100, 100] + ); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 10); + // Stored early identities retain their rank, and unstored late identities retain the floor. + let reverse: Vec<_> = targets.into_iter().rev().collect(); + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &reverse), + [100, 100, 100, 100, 100, 250, 400, 550, 700, 800, 900, 1000] + ); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 10); +} + +#[tokio::test] +async fn aoe_policy_unflagged_damage_neither_diminishes_nor_consumes_a_rank() { + let (server, _client, player, targets) = fixture(data(), 3); + let state = state(&WorldObject::from(&player), &targets[0], None); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets[..1]), [1000]); + assert_eq!( + damage(&server, &state, UNFLAGGED_EVENT, &targets[1..]), + [1000, 1000] + ); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 1); + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &targets[2..]), + [900] + ); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets[..1]), [1000]); +} + +#[tokio::test] +async fn aoe_policy_reset_is_local_to_plot_even_with_reused_skill_and_other_casters() { + let (server, _client, player, targets) = fixture(data(), 4); + let caster = WorldObject::from(&player); + let first = state(&caster, &targets[0], None); + // Deliberately reuse the same SkillRun across two plot instances: context must remain explicit. + let second = state(&caster, &targets[0], Some(first.skill.clone())); + let other = state(&WorldObject::from(&targets[3]), &targets[0], None); + assert_eq!( + damage(&server, &first, DAMAGE_EVENT, &targets[..2]), + [1000, 900] + ); + assert_eq!( + damage(&server, &second, DAMAGE_EVENT, &targets[..2]), + [1000, 900] + ); + // This caster has no faction, so the ordinary can_attack null-faction rule permits the hit. + targets[3].data().unit.faction_id = 0; + assert_eq!(damage(&server, &other, DAMAGE_EVENT, &targets[..1]), [1000]); + fire(&server, &first, RESET_EVENT, &targets[..1]); + assert!(first.inner().aoe_diminishing_ranks.is_empty()); + assert_eq!(second.inner().aoe_diminishing_ranks.len(), 2); + assert_eq!(other.inner().aoe_diminishing_ranks.len(), 1); + assert_eq!( + damage(&server, &first, DAMAGE_EVENT, &targets[2..3]), + [1000] + ); + assert_eq!( + damage(&server, &second, DAMAGE_EVENT, &targets[2..3]), + [800] + ); + assert_eq!(damage(&server, &other, DAMAGE_EVENT, &targets[1..2]), [900]); + let weak = Arc::downgrade(&first); + drop(first); + assert!( + weak.upgrade().is_none(), + "no plot context may be retained in its SkillRun or caster" + ); + let fresh = state(&caster, &targets[0], Some(second.skill.clone())); + assert_eq!( + damage(&server, &fresh, DAMAGE_EVENT, &targets[2..3]), + [1000] + ); +} + +#[tokio::test] +async fn aoe_policy_repeat_waves_reuse_ranks_until_authored_reset_effect() { + let (server, _client, player, targets) = fixture(data(), 3); + let state = state(&WorldObject::from(&player), &targets[0], None); + for wave in 0..3 { + let mut order = targets.clone(); + order.rotate_left(wave); + assert_eq!( + damage(&server, &state, DAMAGE_EVENT, &order[..2]), + [1000, 900] + ); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &order[2..]), [800]); + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &order[..2]), + [1000, 900] + ); + fire(&server, &state, RESET_EVENT, &targets[..1]); + assert!(state.inner().aoe_diminishing_ranks.is_empty()); + } +} + +fn next(id: u32, event_id: u32, per_target: bool, delay: i32, speed: i32) -> PlotNextEvent { + PlotNextEvent { + id, + event_id, + position: 1, + per_target, + delay, + speed, + casting: false, + channeling: false, + casting_inc: 0, + add_anim_cs_time: false, + casting_delayable: false, + casting_cancelable: false, + cancel_on_big_hit: false, + use_exe_time: false, + fail: false, + } +} + +#[tokio::test] +async fn aoe_policy_queued_per_target_projectiles_share_one_plot_wave() { + let mut data = data(); + data.systems.skills.area_shapes.insert( + 1, + AreaShape { + id: 1, + kind: 1, + value1: 10.0, + value2: 0.0, + value3: 0.0, + }, + ); + let mut area = event(3, false, vec![]); + area.target_update_method_id = 5; + area.target_update_method_params = [1, 12, 0, 0, 0, 0, 0, 4, 2]; + // Actual Searing Rain fan-out: next 3195, event 3 -> 2723, per_target, speed 20. + // Targets are within 11cm of the caster to keep real projectile delays short. + area.next_events.push(next(3195, DAMAGE_EVENT, true, 0, 20)); + data.systems.skills.plots.events.insert(3, area); + let mut root = node(3); + root.children = vec![1]; + let mut child = node(DAMAGE_EVENT); + child.parent = Some(0); + child.parent_next_event = Some((3, 0)); + data.systems.skills.plots.trees.insert( + PLOT, + PlotTree { + plot_id: PLOT, + nodes: vec![root, child], + }, + ); + let (server, _client, player, targets) = fixture(data, 12); + let state = state(&WorldObject::from(&player), &targets[0], None); + execute_tree(&server, PLOT, &state).await; + // World iteration decides which target is first. Do not impose a new sort on production. + let mut dealt: Vec<_> = targets.iter().map(|t| HP - t.data().unit.hp).collect(); + dealt.sort_unstable(); + assert_eq!( + dealt, + [100, 100, 100, 100, 100, 250, 400, 550, 700, 800, 900, 1000] + ); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 10); + assert_eq!(state.inner().tickets[&DAMAGE_EVENT], 12); +} + +#[tokio::test] +async fn aoe_policy_misses_and_immunity_occupy_and_reuse_ranks() { + let mut data = data(); + data.systems.skills.add_buff(BuffTemplate { + id: 900, + kind: 1, + stack_rule: 1, + melee_immune: true, + ..Default::default() + }); + let (server, _client, player, targets) = fixture(data, 3); + let caster = WorldObject::from(&player); + let state = state(&caster, &targets[0], None); + state + .skill + .state() + .hit_types + .insert(targets[0].obj_id, SkillHitType::MeleeMiss); + super::super::buffs::apply_template( + &server, + server.game_data.systems.skills.buff(900).unwrap(), + Some(&caster), + &SkillCaster::Unit(player.obj_id), + &WorldObject::from(&targets[1]), + None, + ); + assert!(super::super::buffs::check_damage_immune( + &server, + &WorldObject::from(&targets[1]), + Some(super::super::types::DamageType::Melee), + )); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets), [0, 0, 800]); + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 3); + state + .skill + .state() + .hit_types + .insert(targets[0].obj_id, SkillHitType::MeleeHit); + super::super::buffs::remove_buff(&server, &WorldObject::from(&targets[1]), 900); + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &targets[..2]), + [1000, 900] + ); +} + +#[tokio::test] +async fn aoe_policy_flagged_heals_and_buffs_do_not_consume_ranks_or_scale() { + let mut data = data(); + let skills = &mut data.systems.skills; + skills.add_buff(BuffTemplate { + id: 901, + kind: 2, + stack_rule: 1, + stun: true, + ..Default::default() + }); + skills.buff_tags.insert(901, vec![6]); // Native 1.2 Stun tag. + skills.add_effect( + EffectKind::BuffEffect, + EffectTemplate::Buff(BuffEffect { + id: 8, + buff_id: Some(901), + chance: 100, + stack: 1, + ab_level: 1, + }), + 8, + ); + skills.add_effect( + EffectKind::HealEffect, + EffectTemplate::Heal(HealEffect { + id: 9, + use_fixed_heal: true, + fixed_min: 1000, + fixed_max: 1000, + use_level_heal: false, + level_md: 0.0, + level_va_start: 0, + level_va_end: 0, + percent: false, + use_charged_buff: false, + charged_buff_id: 0, + charged_mul: 0.0, + slave_applicable: false, + ignore_heal_aggro: true, + dps_multiplier: 0.0, + actability_group_id: 0, + actability_step: 0, + actability_mul: 0.0, + actability_add: 0.0, + }), + 9, + ); + skills.plots.events.insert( + NON_DAMAGE_EVENT, + event( + NON_DAMAGE_EVENT, + true, + vec![plot_effect("HealEffect", 9), plot_effect("BuffEffect", 8)], + ), + ); + let (server, _client, player, targets) = fixture(data, 3); + let state = state(&WorldObject::from(&player), &targets[0], None); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets[..1]), [1000]); + for target in &targets { + target.data().unit.hp = 50_000; + } + fire(&server, &state, NON_DAMAGE_EVENT, &targets); + for target in &targets { + let unit = &target.data().unit; + assert_eq!(unit.hp, 51_000); + assert!(unit.buffs.check_buff(901)); + } + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 1); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets[2..]), [900]); +} + +fn add_bonus(unit: &mut crate::models::unit::UnitBase, attribute: UnitAttribute, value: i32) { + unit.bonuses.add_bonus( + 999, + Bonus { + template: BonusTemplate { + attribute, + modifier_type: UnitModifierType::Value, + value, + linear_level_bonus: 0, + }, + value, + }, + ); +} + +struct Armored; + +impl super::super::ext::NpcSkillHooks for Armored { + fn npc_attribute(&self, _: &GameServer, _: &Npc, attr: StatKind) -> Option { + // Exercise the real damage reduction without requiring NPC reference-data loaders. + (attr == StatKind::Armor).then_some(5300.0) + } +} + +#[tokio::test] +async fn aoe_policy_late_fractional_rate_preserves_physical_fixed_and_modifier_order() { + let mut data = data(); + data.systems.skills.plots.aoe_diminishings.insert(2, 77.5); + let mut physical = super::super::tests::damage_effect(10, 0); + physical.use_fixed_damage = false; + physical.use_mainhand_weapon = true; + physical.dps_multiplier = 1.0; + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(physical)), + 10, + ); + data.systems.skills.plots.events.insert( + OTHER_FLAGGED_EVENT, + event( + OTHER_FLAGGED_EVENT, + true, + vec![plot_effect("DamageEffect", 10)], + ), + ); + let (server, _client, player, targets) = fixture(data, 2); + server.systems.skills.ext.npcs.install(Arc::new(Armored)); + { + let unit = &mut player.data().unit; + // Exactly one DPS avoids random floor/ceil widening in the weapon-damage base. + add_bonus(unit, UnitAttribute::MainhandDps, 1000); + unit.skill_modifiers.add_modifiers(&[SkillModifier { + id: 1, + owner_id: 1, + tag_id: 0, + skill_attribute: SkillAttribute::Damage, + unit_modifier_type: UnitModifierType::Value, + value: 109, + skill_id: SKILL, + synergy: false, + }]); + } + let state = state(&WorldObject::from(&player), &targets[0], None); + // Physical 1 -> skill modifier +109 -> armor 55 -> authored target-2 rate 77.5% -> 42. + assert_eq!( + damage(&server, &state, OTHER_FLAGGED_EVENT, &targets), + [55, 42] + ); + // Fixed 1000 still replaces skill-modified base damage before the existing armor reduction. + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets), [500, 387]); + assert_eq!( + damage(&server, &state, UNFLAGGED_EVENT, &targets), + [500, 500] + ); +} + +#[tokio::test] +async fn aoe_policy_minimum_applies_after_integer_damage_truncation_and_never_heals() { + let mut data = data(); + let mut tiny = super::super::tests::damage_effect(DAMAGE, 7); + tiny.health_steal_ratio = 100; + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(tiny)), + 1, + ); + data.systems.skills.plots.aoe_diminishings.insert(2, 90.0); + data.systems.skills.plots.aoe_diminishings.insert(3, -100.0); + let (server, _client, player, targets) = fixture(data, 3); + server.systems.skills.ext.npcs.install(Arc::new(Armored)); + let state = state(&WorldObject::from(&player), &targets[0], None); + // Armor leaves 3.5 -> integer 3, then rank-2 90% -> 2. Multiplying before that + // first truncation would incorrectly produce 3. A negative authored rate cannot heal. + player.data().unit.hp = 100; + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets), [3, 2, 1]); + assert_eq!(player.data().unit.hp, 106); +} + +#[tokio::test] +async fn aoe_policy_negative_damage_cannot_raise_target_health() { + let mut data = data(); + data.systems.skills.add_effect( + EffectKind::DamageEffect, + EffectTemplate::Damage(Box::new(super::super::tests::damage_effect(DAMAGE, -10))), + 1, + ); + let (server, _client, player, targets) = fixture(data, 1); + let state = state(&WorldObject::from(&player), &targets[0], None); + assert_eq!(damage(&server, &state, DAMAGE_EVENT, &targets), [1]); +} + +#[tokio::test] +async fn aoe_policy_rank_storage_is_bounded_and_missing_table_retains_no_state() { + let (server, _client, player, targets) = fixture(data(), 1); + let state = state(&WorldObject::from(&player), &targets[0], None); + let rates = &server.game_data.systems.skills.plots.aoe_diminishings; + for id in 1..=10_000 { + state.aoe_damage_multiplier(rates, id); + } + assert_eq!(state.inner().aoe_diminishing_ranks.len(), 10); + assert_eq!(state.aoe_damage_multiplier(rates, 1), 1.0); + assert_eq!(state.aoe_damage_multiplier(rates, 10_000), 0.1); + fire(&server, &state, RESET_EVENT, &targets); + assert!(state.inner().aoe_diminishing_ranks.is_empty()); + assert_eq!(state.aoe_damage_multiplier(&HashMap::new(), 1), 1.0); + assert!(state.inner().aoe_diminishing_ranks.is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/skills/plots.rs b/rust/crates/aaemu-game/src/systems/skills/plots.rs index e215439f35..c0ed2110c4 100644 --- a/rust/crates/aaemu-game/src/systems/skills/plots.rs +++ b/rust/crates/aaemu-game/src/systems/skills/plots.rs @@ -28,6 +28,10 @@ use super::state::{PlotStateRef, SkillRef}; use super::stats::{stat, StatKind}; use super::types::{tags, CastAction, PlotObject, RelationState, SkillTargetRelation}; +#[cfg(test)] +#[path = "plot_aoe_tests.rs"] +mod aoe_tests; + /// The mutable part of `PlotState`. #[derive(Debug, Default)] pub struct PlotStateInner { @@ -40,6 +44,9 @@ pub struct PlotStateInner { pub channeled_buffs: Vec<(WorldObject, u32)>, /// `HitObjects` (event id -> obj ids). pub hit_objects: HashMap>, + /// Compatibility policy: first-seen distinct targets in this plot's current AoE wave. + /// Retain only the first authored maximum rank; later targets all use the final rate. + aoe_diminishing_ranks: HashMap, } /// `PlotState`. @@ -92,6 +99,33 @@ impl PlotState { pub fn caster(&self) -> &WorldObject { &self.ctx.caster } + + /// Server compatibility policy, not a recovered retail counter (see PORTING.md). + /// Called before damage hit resolution, including miss/immunity checks. Sibling + /// projectiles share this plot instance; repeat hits reuse their target's wave rank. + pub(super) fn aoe_damage_multiplier(&self, rates: &HashMap, target_id: u32) -> f32 { + let Some(last_rank) = rates.keys().copied().max().filter(|&rank| rank > 0) else { + return 1.0; + }; + let mut inner = self.inner(); + let ranks = &mut inner.aoe_diminishing_ranks; + let rank = if let Some(&rank) = ranks.get(&target_id) { + rank + } else if ranks.len() < last_rank as usize { + let rank = ranks.len() as u32 + 1; + ranks.insert(target_id, rank); + rank + } else { + // No need to retain more identities: every subsequent target, including + // repeat hits on one of those targets, receives the same final rate. + last_rank + }; + rates.get(&rank).copied().unwrap_or(100.0).max(0.0) / 100.0 + } + + pub(super) fn reset_aoe_diminishing(&self) { + self.inner().aoe_diminishing_ranks.clear(); + } } /// `PlotTargetInfo`. @@ -389,20 +423,9 @@ fn do_plot_end(server: &GameServer, state: &Arc) { let tl = skill.tl_id(); broadcast(server, &caster, &SCPlotEndedPacket { tl }, true); end_plot_channel(server, state); - let now = now_ms(); - let (id, cd) = (skill.template.id, skill.template.cooldown_time); - caster.with_unit(|u| u.unit_mut().cooldowns.add_cooldown(id, cd as u32, now)); - if let Some(o) = super::relation::owner_character(server, &caster) { - if o.data().skill_char.ignore_skill_cooldowns { - o.send(super::packets::SCSkillCooldownResetPacket { - obj_id: o.obj_id, - skill_id: id, - tag_id: 0, - gcd: false, - }); - caster.with_unit(|u| u.unit_mut().cooldowns.remove_cooldown(id)); - } - } + // Cooldowns are committed at accepted plot-only use or successful cast, once. + // Plot completion must not reapply raw durations, extend the tag, or send a second UI update. + super::skill::reset_cooldown_if_ignored(server, skill, &caster); // Release only what this call took: a concurrent `end_skill` (interrupt) takes the id the // same way, so whichever comes second releases 0. server.systems.skills.tl_ids.release(skill.take_tl_id()); @@ -1154,7 +1177,7 @@ fn apply_plot_effect( source: EffectSource::from_skill(state.skill.clone()), skill_object: &state.ctx.skill_object, }; - effects::apply(server, kind, template, &args, None); + effects::apply_plot(server, kind, template, &args, state, event.aoe_diminishing); } } diff --git a/rust/crates/aaemu-game/src/systems/skills/progress.rs b/rust/crates/aaemu-game/src/systems/skills/progress.rs index 63a30787be..f9a5cf014c 100644 --- a/rust/crates/aaemu-game/src/systems/skills/progress.rs +++ b/rust/crates/aaemu-game/src/systems/skills/progress.rs @@ -10,6 +10,7 @@ use aaemu_commons::{Marshal, PacketStream}; use crate::data::formulas::FormulaKind; use crate::models::char_data::{ability, Skill}; use crate::models::character::Character; +use crate::models::unit::UnitAttribute; use crate::net::packet::LEVEL_PLAIN; use crate::opcodes::sc; use crate::packets::packet_def; @@ -122,7 +123,7 @@ fn actability_exp_multiplier(_step: u8) -> f32 { /// character's lock is released. #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub struct ExpGain { - /// The applied delta (after `ExpRate`). + /// The applied delta (after `ExpRate` and the caster's XP bonuses). pub exp: i32, pub should_add_ability_exp: bool, /// The new level when the character leveled up. @@ -137,14 +138,29 @@ pub fn add_exp_locked( mut exp_delta: i32, add_ability_exp: bool, ) -> Option { + c.unit + .bonuses + .bind_attribute_limits(&server.game_data.characters.unit_attribute_limits); if exp_delta == 0 { return None; } if exp_delta > 0 { - exp_delta = (f64::from(exp_delta) * server.config.world.exp_rate) as i32; + // Native 1.2 sub_398A0D60: ExpMul (95) starts at 100, unlike damage/haste's + // per-mille attributes. Apply Bonuses to that base so Percent rows work too. + let multiplier = c + .unit + .calculate_with_bonuses(100.0, UnitAttribute::ExpMul, now_ms()); + let gain = + f64::from(exp_delta) * server.config.world.exp_rate.max(0.0) * multiplier.max(0.0) + / 100.0; + exp_delta = gain.max(0.0).min(f64::from(i32::MAX)) as i32; } let exp_table = &server.game_data.experience; - let mut new_exp = c.experience.wrapping_add(exp_delta); + let mut new_exp = if exp_delta > 0 { + c.experience.saturating_add(exp_delta) + } else { + c.experience.wrapping_add(exp_delta) + }; let (new_level, overflow) = match exp_table.level_from_exp(new_exp, c.unit.level, false) { Ok(v) => v, Err(e) => { @@ -167,7 +183,11 @@ pub fn add_exp_locked( continue; } if let Some(ab) = c.abilities.get_mut(a) { - ab.exp = (ab.exp + exp_delta).min(max_exp); + ab.exp = if exp_delta > 0 { + ab.exp.saturating_add(exp_delta).min(max_exp) + } else { + (ab.exp + exp_delta).min(max_exp) + }; } } } diff --git a/rust/crates/aaemu-game/src/systems/skills/skill.rs b/rust/crates/aaemu-game/src/systems/skills/skill.rs index 447c3171cd..9df68311d2 100644 --- a/rust/crates/aaemu-game/src/systems/skills/skill.rs +++ b/rust/crates/aaemu-game/src/systems/skills/skill.rs @@ -9,7 +9,7 @@ use std::sync::Arc; use rand::Rng; use crate::models::transform::PositionAndRotation; -use crate::models::unit::SkillAttribute; +use crate::models::unit::{SkillAttribute, UnitAttribute, UnitCooldowns}; use crate::server::GameServer; use crate::systems::social::achievement::char_record_kind; use crate::systems::social::achievement_hooks::{AchievementInput, RecordMatch}; @@ -21,8 +21,8 @@ use super::data::{EffectKind, EffectTemplate, SkillEffect, SkillTemplate}; use super::effects::{self, EffectArgs, EffectSource}; use super::geometry::{distance_to, is_front, world_of, world_pos, PosUnit, Target}; use super::packets::{ - CompressedGamePackets, SCCastingStoppedPacket, SCSkillCooldownResetPacket, SCSkillEndedPacket, - SCSkillFiredPacket, SCSkillStartedPacket, SCSkillStoppedPacket, + CompressedGamePackets, SCCastingStoppedPacket, SCCooldownsPacket, SCSkillCooldownResetPacket, + SCSkillEndedPacket, SCSkillFiredPacket, SCSkillStartedPacket, SCSkillStoppedPacket, }; use super::relation::{can_attack, filter_with_relation, owner_character, relation_to}; use super::state::{AutoAttackSlot, CancelToken, SkillRef, SkillRun, SkillTaskKind, SkillTaskSlot}; @@ -180,6 +180,91 @@ fn start_global_cooldown(server: &GameServer, skill: &SkillRef, caster: &WorldOb caster.with_unit(|u| u.unit_mut().global_cooldown_ms = now + ms); } +fn cooldown_ignored(server: &GameServer, caster: &WorldObject) -> bool { + caster + .as_player() + .cloned() + .or_else(|| owner_character(server, caster)) + .is_some_and(|owner| owner.data().skill_char.ignore_skill_cooldowns) +} + +fn on_skill_cooldown( + server: &GameServer, + skill: &SkillRun, + caster: &WorldObject, + now: i64, +) -> bool { + // Preserve the existing server-controlled NPC policy: only a character or its + // controlled unit is subject to skill cooldown admission, on that unit's own store. + let owner = caster + .as_player() + .cloned() + .or_else(|| owner_character(server, caster)); + let Some(owner) = owner else { + return false; + }; + if owner.data().skill_char.ignore_skill_cooldowns { + return false; + } + caster + .with_unit(|u| { + u.unit_mut().cooldowns.check_skill_cooldown( + skill.template.id, + skill.template.cooldown_tag_id.max(0) as u32, + now, + ) + }) + .unwrap_or(false) +} + +fn start_skill_cooldown(server: &GameServer, skill: &SkillRun, caster: &WorldObject, now: i64) { + if cooldown_ignored(server, caster) { + return; + } + // Native 1.2 `3989A360` -> `3989F900`, attribute 1: modify the started skill's + // own cooldown, not each member's authored duration. Never cast a signed duration to u32. + let duration = apply_skill_modifiers( + server, + skill, + caster, + SkillAttribute::Cooldown, + f64::from(skill.template.cooldown_time), + ) + .clamp(0.0, f64::from(u32::MAX)) as u32; + if duration == 0 { + return; + } + let tag = skill.template.cooldown_tag_id.max(0) as u32; + let packet = caster + .with_unit(|u| { + let cooldowns = &mut u.unit_mut().cooldowns; + cooldowns.add_cooldown(skill.template.id, duration, now); + cooldowns.add_tag_cooldown(tag, duration, now); + if tag == 0 { + return None; + } + // Native 1.2 397B2350 keeps these lists separate; 3989A290 takes + // max(individual, tag). Never manufacture individual entries for other members. + let mut affected = UnitCooldowns::default(); + affected + .cooldowns + .insert(skill.template.id, cooldowns.cooldowns[&skill.template.id]); + affected + .tag_cooldowns + .insert(tag, cooldowns.tag_cooldowns[&tag]); + Some(SCCooldownsPacket::from_cooldowns(&affected, now)) + }) + .flatten(); + if let Some(packet) = packet.filter(|p| !p.is_empty()) { + // OnCooldowns (native 391D43C0) addresses the local character's manager; + // unlike SkillCooldownReset, the packet has no subject object ID. A mate's + // shared timers must not populate its owner's character cooldown store. + if let Some(player) = caster.as_player() { + player.send(packet); + } + } +} + fn lookup_base_unit(server: &GameServer, caster: &WorldObject, obj_id: u32) -> Option { world_of(server, caster).and_then(|w| w.object(obj_id)) } @@ -384,6 +469,9 @@ pub fn use_skill( if !caster.is_unit() { return (skill_result::INVALID_SOURCE, 0); } + if let Err(result) = super::validation::check_item_zone(server, caster, &caster_caster) { + return result; + } let template = skill.template.clone(); let resolved_target = initial_target(server, skill, caster, &caster_caster, target_caster); let Some(target) = &resolved_target else { @@ -435,9 +523,6 @@ pub fn use_skill( return (skill_result::INVALID_TARGET, 0); } let character = caster.as_player().cloned(); - let cooldown_owner = character - .clone() - .or_else(|| owner_character(server, caster)); let req = unit_reqs::can_use_skill_on_target( server, &template, @@ -504,21 +589,13 @@ pub fn use_skill( return result; } if let Some(c) = &character { - if let Some(result) = portal_zone_check(server, &template, c) { + if let Some(result) = portal_zone_check(server, &template, c, skill_object.as_ref()) { return (result, 0); } } let now = now_ms(); - if template.cooldown_time > 0 { - if let Some(o) = &cooldown_owner { - let ignore = o.data().skill_char.ignore_skill_cooldowns; - let on_cd = caster - .with_unit(|u| u.unit_mut().cooldowns.check_cooldown(template.id, now)) - .unwrap_or(false); - if !ignore && on_cd { - return (skill_result::COOLDOWN_TIME, 0); - } - } + if on_skill_cooldown(server, skill, caster, now) { + return (skill_result::COOLDOWN_TIME, 0); } skill.state().bypass_gcd = bypass_gcd; if !bypass_gcd { @@ -630,17 +707,14 @@ pub fn use_skill( skill_object: skill_object.clone(), }; if let Some(plot_id) = template.plot_id { - super::plots::run_plot(server, plot_id, ctx.clone(), skill.clone()); if template.plot_only { - // `cast` never runs for a plot-only skill: start the GCD and the skill's own - // cooldown now, so it cannot be recast while the plot runs (`do_plot_end` adds the - // cooldown too, but `add_cooldown` keeps this earlier entry). + // Plot-only skills never enter `cast`; commit cooldowns once at acceptance, + // before a plot can finish synchronously. start_global_cooldown(server, skill, caster, now); - caster.with_unit(|u| { - u.unit_mut() - .cooldowns - .add_cooldown(template.id, template.cooldown_time as u32, now) - }); + start_skill_cooldown(server, skill, caster, now); + } + super::plots::run_plot(server, plot_id, ctx.clone(), skill.clone()); + if template.plot_only { return (skill_result::SUCCESS, 0); } } @@ -706,6 +780,7 @@ fn portal_zone_check( server: &GameServer, template: &SkillTemplate, c: &crate::world::PlayerRef, + skill_object: Option<&SkillObject>, ) -> Option { let (access, district, faction, instance) = { let d = c.data(); @@ -720,40 +795,88 @@ fn portal_zone_check( return None; } let data = &server.game_data.systems.skills; - let first = template.effects.first()?; - let (kind, id) = first.template?; - let mut zone_id: Option = None; - match data.effect(kind, id)? { - EffectTemplate::Special(s) if s.special_effect_type_id == 25 => { - if s.value1 > 0 { - // PortalManager.GetWorldGatesById: world gates are not loaded (portals subsystem) - } else { - let rp = server - .game_data - .portals - .district_return_point(district, faction); - zone_id = server - .game_data - .portals - .recalls - .values() - .flatten() - .find(|p| p.id == rp) - .map(|p| p.zone_id); - } - } - EffectTemplate::OpenPortal { .. } if instance != 0 => { - return Some(skill_result::INVALID_LOCATION); - } - // character.Portals.GetPortalInfo(portalInfo.Id): portals subsystem - _ => {} - } - let zone_id = zone_id?; - match server.game_data.zones.zone_by_key(zone_id) { - None => Some(skill_result::NO_PERM), - Some(z) if z.closed => Some(skill_result::NO_PERM), - _ => None, + for effect in &template.effects { + let Some((kind, id)) = effect.template else { + continue; + }; + let mut destination_instance = instance; + let destination = match data.effect(kind, id) { + Some(EffectTemplate::Special(s)) if s.special_effect_type_id == 25 => { + if s.value1 > 0 { + crate::systems::npcs::portal::world_gates_by_id(server, s.value1 as u32) + .cloned() + .or_else(|| { + if instance != 0 { + return None; + } + let t = c.data().main_world_position?; + destination_instance = t.instance_id; + Some(crate::data::world_data::Portal { + zone_id: t.zone_id, + x: t.x, + y: t.y, + z: t.z, + ..Default::default() + }) + }) + } else { + destination_instance = crate::models::character::DEFAULT_INSTANCE_ID; + let rp = server + .game_data + .portals + .district_return_point(district, faction); + server + .game_data + .portals + .recalls + .values() + .flatten() + .find(|p| p.id == rp) + .cloned() + .or_else(|| { + if rp == 0 || instance != 0 { + return None; + } + let t = c.data().main_world_position?; + destination_instance = t.instance_id; + Some(crate::data::world_data::Portal { + zone_id: t.zone_id, + x: t.x, + y: t.y, + z: t.z, + ..Default::default() + }) + }) + } + } + Some(EffectTemplate::OpenPortal { .. }) => { + if instance != 0 { + return Some(skill_result::INVALID_LOCATION); + } + match skill_object { + Some(SkillObject::PortalInfo { id, .. }) => { + crate::systems::npcs::portal::portal_info(&c.data().portals, *id as u32) + .cloned() + } + _ => None, + } + } + _ => None, + }; + if let Some(p) = destination { + if !crate::world::session::zone_access_allowed( + server, + c, + destination_instance, + p.zone_id, + p.x, + p.y, + ) { + return Some(skill_result::NO_PERM); + } + } } + None } /// `Skill.Cast(caster, casterCaster, target, targetCaster, skillObject)`. @@ -778,7 +901,19 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { return; } // Source, target and resources may change while the cast timer is running. - let ready = super::validation::check(server, skill, caster, &ctx.target) + let ready = caster + .as_player() + .and_then(|p| portal_zone_check(server, &skill.template, p, Some(&ctx.skill_object))) + .map_or(Ok(()), |result| Err((result, 0))) + .and_then(|()| super::validation::check_item_zone(server, caster, &ctx.caster_caster)) + .and_then(|()| super::validation::check(server, skill, caster, &ctx.target)) + .and_then(|()| { + if on_skill_cooldown(server, skill, caster, now_ms()) { + Err((skill_result::COOLDOWN_TIME, 0)) + } else { + Ok(()) + } + }) .and_then(|()| super::validation::check_resources(server, skill, caster)) .and_then(|()| { super::validation::check_build_materials(server, skill, caster, &ctx.target) @@ -806,8 +941,6 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { return; } let t = &skill.template; - let now = now_ms(); - start_global_cooldown(server, skill, caster, now); if caster.as_npc().is_some() && t.skill_controller_id != 0 { if let Some(sc) = server .game_data @@ -829,14 +962,7 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { } } } - caster.with_unit(|u| u.unit_mut().skill_state.skill_task = None); - consume_mana(server, skill, caster); - caster.with_unit(|u| { - u.unit_mut() - .cooldowns - .add_cooldown(t.id, t.cooldown_time as u32, now) - }); - // Validate the cast item + // Validate the cast item before committing mana or cooldowns. if let ( Some(p), SkillCaster::Item { @@ -867,6 +993,11 @@ pub fn cast(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { } } } + let now = now_ms(); + start_global_cooldown(server, skill, caster, now); + caster.with_unit(|u| u.unit_mut().skill_state.skill_task = None); + consume_mana(server, skill, caster); + start_skill_cooldown(server, skill, caster, now); if t.channeling_time > 0 { start_channeling(server, skill, ctx); } else { @@ -882,6 +1013,17 @@ pub fn start_channeling(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { .map(|target| (target.obj_id(), target.core() as *const _ as usize)); let caster = &ctx.caster; let t = &skill.template; + // Native 1.2 sub_398A01B0, attribute 11: milliseconds, independent of CastTime. + // The fired packet encodes duration as signed i16 (ms / 10 + 10). + let channeling_time = apply_skill_modifiers( + server, + skill, + caster, + SkillAttribute::ChannelingTime, + f64::from(t.channeling_time), + ) + .max(0.0) + .min(f64::from((i32::from(i16::MAX) - 10) * 10)) as i32; let data = &server.game_data.systems.skills; if t.channeling_buff_id != 0 { if let Some(b) = data.buff(t.channeling_buff_id).cloned() { @@ -931,7 +1073,7 @@ pub fn start_channeling(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { target: ctx.target_caster, skill_object: ctx.skill_object.clone(), computed_delay: 0, - channeling_time: t.channeling_time, + channeling_time, fire_anim_id: t.fire_anim_id, }, true, @@ -953,11 +1095,12 @@ pub fn start_channeling(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { ctx.clone(), cancel.clone(), t.channeling_tick, + channeling_time, ); } let skill2 = skill.clone(); let ctx2 = ctx.clone(); - let scheduled = super::tasks::schedule(server, i64::from(t.channeling_time), move |srv| { + let scheduled = super::tasks::schedule(server, i64::from(channeling_time), move |srv| { if cancel.is_cancelled() { return; } @@ -990,9 +1133,10 @@ fn schedule_channel_tick( ctx: CastCtx, cancel: CancelToken, elapsed: i32, + duration: i32, ) { let interval = skill.template.channeling_tick; - if interval <= 0 || elapsed >= skill.template.channeling_time { + if interval <= 0 || elapsed >= duration { return; } super::tasks::schedule(server, i64::from(interval), move |server| { @@ -1044,6 +1188,7 @@ fn schedule_channel_tick( ctx.clone(), cancel, elapsed.saturating_add(interval), + duration, ); }); } @@ -1367,10 +1512,11 @@ fn append_hostile_ships_hit_by_siege_hull_aoe( caster: &Target, target_self: &Target, ctx: &CastCtx, + radius: f32, possible: &mut Vec, ) { use crate::systems::ai::physics::{siege_point_hits_ship, SIEGE_PIVOT_QUERY_SLACK_METERS}; - if t.target_area_radius <= 0 { + if radius <= 0.0 { return; } if DamageType::from_raw(i64::from(t.damage_type_id)) != Some(DamageType::Siege) { @@ -1382,7 +1528,6 @@ fn append_hostile_ships_hit_by_siege_hull_aoe( ) { return; } - let radius = t.target_area_radius as f32; let p = super::geometry::world_pos(server, target_self); let relation = SkillTargetRelation::from_raw(i64::from(t.target_relation)) .unwrap_or(SkillTargetRelation::Any); @@ -1426,6 +1571,16 @@ pub fn apply_effects(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { let caster_t = Target::Obj(caster.clone()); let target_self = &ctx.target; let selection = SkillTargetSelection::from_raw(i64::from(t.target_selection)); + // Native 1.2 sub_398A01B0 attribute 3 / sub_39420B30: radius is in meters. + let area_radius = apply_skill_modifiers( + server, + skill, + caster, + SkillAttribute::AreaRadius, + f64::from(t.target_area_radius), + ) + .max(0.0) + .min(f64::from(i32::MAX)) as f32; let mut possible: Vec = Vec::new(); if t.target_siege && selection == Some(SkillTargetSelection::Source) @@ -1433,8 +1588,7 @@ pub fn apply_effects(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { { possible.push(target_self.clone()); } else if t.target_area_radius > 0 { - let mut units = - super::geometry::around_radius(server, target_self, t.target_area_radius as f32, true); + let mut units = super::geometry::around_radius(server, target_self, area_radius, true); if selection == Some(SkillTargetSelection::Source) { if let Some(o) = target_self.as_obj() { units.push(o.clone()); @@ -1456,6 +1610,7 @@ pub fn apply_effects(server: &GameServer, skill: &SkillRef, ctx: &CastCtx) { &caster_t, target_self, ctx, + area_radius, &mut possible, ); // Distinct @@ -1949,16 +2104,25 @@ pub fn end_skill(server: &GameServer, skill: &SkillRef, caster: &WorldObject) { } } -fn reset_cooldown_if_ignored(server: &GameServer, skill: &SkillRun, caster: &WorldObject) { +pub(super) fn reset_cooldown_if_ignored( + server: &GameServer, + skill: &SkillRun, + caster: &WorldObject, +) { if let Some(o) = owner_character(server, caster) { if o.data().skill_char.ignore_skill_cooldowns { + let tag = skill.template.cooldown_tag_id.max(0) as u32; + caster.with_unit(|u| { + u.unit_mut() + .cooldowns + .remove_skill_cooldown(skill.template.id, tag); + }); o.send(SCSkillCooldownResetPacket { - obj_id: o.obj_id, + obj_id: caster.obj_id(), skill_id: skill.template.id, - tag_id: 0, + tag_id: tag, gcd: false, }); - caster.with_unit(|u| u.unit_mut().cooldowns.remove_cooldown(skill.template.id)); } } } @@ -2133,10 +2297,20 @@ pub fn attack_delay( ) -> f64 { let gcd_mul = stat(server, caster, StatKind::GlobalCooldownMul); if matches!(t.id, 2..=4) && caster.as_player().is_some() { - let (slot, fallback) = match t.id { - 2 => (equip_slot::MAINHAND, 1500.0), - 3 => (equip_slot::OFFHAND, 1500.0), - _ => (equip_slot::RANGED, 1800.0), + let slot = match t.weapon_slot_for_auto_attack_id { + equip_slot::MAINHAND | equip_slot::OFFHAND | equip_slot::RANGED => { + t.weapon_slot_for_auto_attack_id + } + _ => match t.id { + 2 => equip_slot::MAINHAND, + 3 => equip_slot::OFFHAND, + _ => equip_slot::RANGED, + }, + }; + let fallback = if slot == equip_slot::RANGED { + 1800.0 + } else { + 1500.0 }; let speed = server .systems @@ -2144,9 +2318,22 @@ pub fn attack_delay( .ext .items() .weapon_holdable(server, caster, slot) - .filter(|h| h.speed > 0.0) + .filter(|h| h.speed.is_finite() && h.speed > 0.0) .map_or(fallback, |h| f64::from(h.speed)); - return (speed * (gcd_mul / 100.0)).clamp(400.0, 5000.0); + let attr = if slot == equip_slot::RANGED { + UnitAttribute::RangedSpeedMul + } else { + UnitAttribute::MeleeSpeedMul + }; + let haste = caster + .with_unit(|u| u.unit().calculate_with_bonuses(0.0, attr, now_ms())) + .unwrap_or(0.0); + // Native 1.2 sub_398B49E0: weapon delay * 1000 / (1000 + haste), + // guarding the denominator at 1. Offhand uses melee haste, ranged its own. + // Only this server repeat timer applies haste; the GCD remains once-only. + return (speed * (gcd_mul / 100.0) * 1000.0 / (1000.0 + haste.max(-999.0))) + .max(0.0) + .min(f64::from(i32::MAX)); } let cast_mul = stat(server, caster, StatKind::CastTimeMul); let cast = f64::from(t.casting_time) * cast_mul; @@ -2364,3 +2551,11 @@ mod auto_attack_lifecycle_tests { #[cfg(test)] #[path = "owned_npc_target_tests.rs"] mod owned_npc_target_tests; + +#[cfg(test)] +#[path = "modifier_flow_tests.rs"] +mod modifier_flow_tests; + +#[cfg(test)] +#[path = "cooldown_tag_flow_tests.rs"] +mod cooldown_tag_flow_tests; diff --git a/rust/crates/aaemu-game/src/systems/skills/stats.rs b/rust/crates/aaemu-game/src/systems/skills/stats.rs index 1c11856519..0418c0b7a5 100644 --- a/rust/crates/aaemu-game/src/systems/skills/stats.rs +++ b/rust/crates/aaemu-game/src/systems/skills/stats.rs @@ -1,6 +1,6 @@ //! Unit attribute getters (`Unit` virtual properties, the `Character` overrides evaluated through //! `FormulaManager` + `CalculateWithBonuses` + equipment, the `Npc` overrides through the npc -//! subsystem hook). One call locks the object once and evaluates any number of attributes. +//! subsystem hook). One call evaluates any number of attributes under the object's lock. use std::collections::HashMap; @@ -221,11 +221,23 @@ pub fn composed_regen(base: f64, persistent: f64) -> f64 { /// The base `Unit` getter values (no override). pub fn base_unit_stat(u: &UnitBase, kind: StatKind, now: i64) -> f64 { + base_unit_stat_with_limits(u, kind, now, &u.bonuses.attribute_limits) +} + +/// Explicit per-server data for detached vehicle evaluators too. +pub fn base_unit_stat_with_limits( + u: &UnitBase, + kind: StatKind, + now: i64, + limits: &crate::data::attribute_limits::UnitAttributeLimits, +) -> f64 { use StatKind as S; match kind { S::MoveSpeedMul => { - (u.calculate_with_bonuses(1000.0, UnitAttribute::MoveSpeedMul, now) as f32 / 1000.0) - as f64 + (u.bonuses + .calculate_with_limits(1000.0, UnitAttribute::MoveSpeedMul, now, limits) + as f32 + / 1000.0) as f64 } S::GlobalCooldownMul => f64::from(u.global_cooldown_mul), S::MaxHp => f64::from(u.max_hp), @@ -247,9 +259,14 @@ pub fn base_unit_stat(u: &UnitBase, kind: StatKind, now: i64) -> f64 { | S::IncomingRangedDamageMul | S::IncomingSpellDamageMul | S::IncomingSiegeDamageMul => 1.0, - S::AggroMul => u.calculate_with_bonuses(100.0, UnitAttribute::AggroMul, now) as f32 as f64, + S::AggroMul => u + .bonuses + .calculate_with_limits(100.0, UnitAttribute::AggroMul, now, limits) + as f32 as f64, S::IncomingAggroMul => { - u.calculate_with_bonuses(100.0, UnitAttribute::IncomingAggroMul, now) as f32 as f64 + u.bonuses + .calculate_with_limits(100.0, UnitAttribute::IncomingAggroMul, now, limits) + as f32 as f64 } _ => 0.0, } @@ -287,7 +304,12 @@ impl<'a> CharStats<'a> { } fn cwb(&self, v: f64, a: UnitAttribute) -> f64 { - self.c.unit.calculate_with_bonuses(v, a, self.now) + self.c.unit.bonuses.calculate_with_limits( + v, + a, + self.now, + &self.server.game_data.characters.unit_attribute_limits, + ) } fn formula(&self, kind: UnitFormulaKind, params: &HashMap<&str, f64>) -> f64 { @@ -608,14 +630,15 @@ impl<'a> CharStats<'a> { S::HealCriticalMul => self.cwb(0.0, A::HealCriticalMul) as f32 as f64, S::Armor => { let pa = self.all_params(); - let res = self.formula(F::Armor, &pa) as i32 + self.inputs.gear.armor; - f64::from(self.cwb(f64::from(res), A::Armor) as i32) + let res = f64::from(self.formula(F::Armor, &pa) as i32) + + f64::from(self.inputs.gear.armor); + f64::from(self.cwb(res, A::Armor) as i32) } S::MagicResistance => { let pa = self.all_params(); - let res = - self.formula(F::MagicResist, &pa) as i32 + self.inputs.gear.magic_resistance; - f64::from(self.cwb(f64::from(res), A::MagicResist) as i32) + let res = f64::from(self.formula(F::MagicResist, &pa) as i32) + + f64::from(self.inputs.gear.magic_resistance); + f64::from(self.cwb(res, A::MagicResist) as i32) } S::DefensePenetration => f64::from(self.cwb(0.0, A::IgnoreArmor) as i32), S::MagicPenetration => f64::from(self.cwb(0.0, A::MagicPenetration) as i32), @@ -652,9 +675,9 @@ impl<'a> CharStats<'a> { res as f32 as f64 } S::LungCapacity => f64::from(self.cwb(60000.0, A::LungCapacity) as u32), - S::MoveSpeedMul | S::AggroMul | S::IncomingAggroMul => { - base_unit_stat(&self.c.unit, kind, self.now) - } + S::MoveSpeedMul => (self.cwb(1000.0, A::MoveSpeedMul) as f32 / 1000.0) as f64, + S::AggroMul => self.cwb(100.0, A::AggroMul) as f32 as f64, + S::IncomingAggroMul => self.cwb(100.0, A::IncomingAggroMul) as f32 as f64, } } } @@ -674,8 +697,13 @@ pub fn char_inputs(server: &GameServer, p: &crate::world::PlayerRef) -> CharInpu } } -/// Evaluates `kinds` for one object (locks it once). Doodads and non-units give 0. +/// Binds per-server limits, then evaluates `kinds` for one object. Doodads and non-units give 0. pub fn stats(server: &GameServer, obj: &WorldObject, kinds: &[StatKind]) -> Vec { + obj.with_unit(|u| { + u.unit_mut() + .bonuses + .bind_attribute_limits(&server.game_data.characters.unit_attribute_limits); + }); let now = now_ms(); match obj { WorldObject::Player(p) => { @@ -906,6 +934,10 @@ pub fn update_npc_gear_bonuses( update_unit_gear_bonuses(server, &WorldObject::from(npc), added, removed); } +#[cfg(test)] +#[path = "attribute_limits_tests.rs"] +mod attribute_limits_tests; + #[cfg(test)] mod vehicle_gear_tests { use std::sync::Arc; diff --git a/rust/crates/aaemu-game/src/systems/skills/validation.rs b/rust/crates/aaemu-game/src/systems/skills/validation.rs index d81431690f..665aa0a0cc 100644 --- a/rust/crates/aaemu-game/src/systems/skills/validation.rs +++ b/rust/crates/aaemu-game/src/systems/skills/validation.rs @@ -16,6 +16,31 @@ fn fail(key: &str) -> Result<(), (u8, u32)> { Err((skill_result_for_key(key), 0)) } +/// Item-caster tags belong to the owned item's server-side template, never the wire hint. +pub(super) fn check_item_zone( + server: &GameServer, + caster: &WorldObject, + source: &super::types::SkillCaster, +) -> Result<(), (u8, u32)> { + if let (Some(player), super::types::SkillCaster::Item { item_id, .. }) = + (caster.as_player(), source) + { + if let Some((template, _)) = server + .systems + .skills + .ext + .items() + .owned_item(server, player, *item_id) + { + if !crate::systems::economy::inventory::item_use_zone_allowed(server, player, template) + { + return fail("SKILL_CANNOT_USE_HERE"); + } + } + } + Ok(()) +} + fn in_water(server: &GameServer, target: &Target) -> bool { if target .as_obj() @@ -139,6 +164,20 @@ pub(super) fn check( target: &Target, ) -> Result<(), (u8, u32)> { let template = &skill.template; + // Like the other cast restrictions, this also applies to administrators. A GM's + // cooldown override does not grant permission to use forbidden tags. + if caster.as_player().is_some() + && super::data::zone_rules::current_group(server, caster).is_some_and(|group| { + let data = &server.game_data.systems.skills; + data.zone_rules.bans_any( + group, + data.skill_tags.get(&skill.id).map_or(&[], Vec::as_slice), + ) + }) + { + // Native 1.2 x2game12.c:1983345: SkillResult 58 = ZONE_BANNED. + return fail("SKILL_CANNOT_USE_HERE"); + } if let Some(doodad) = target.as_obj().and_then(WorldObject::as_doodad) { if !crate::systems::npcs::doodad::gathering::allows_skill(server, doodad, template, caster) { diff --git a/rust/crates/aaemu-game/src/systems/social/dominion.rs b/rust/crates/aaemu-game/src/systems/social/dominion.rs index a92e3dbcb8..f27bcbb33b 100644 --- a/rust/crates/aaemu-game/src/systems/social/dominion.rs +++ b/rust/crates/aaemu-game/src/systems/social/dominion.rs @@ -373,6 +373,7 @@ pub(crate) fn is_expedition_leader( /// Match the original native IsDominionOwner gate and its inclusive 0..50 slider. pub fn update_tax_rate(server: &GameServer, player: &PlayerRef, zone: u16, tax_rate: i32) { + let _items = server.systems.economy.operation_scope(); let _operation = server .systems .housing @@ -445,6 +446,7 @@ pub fn declare_effect(server: &GameServer, args: &EffectArgs<'_>) { { return; } + let _items = server.systems.economy.operation_scope(); let operation = server .systems .housing diff --git a/rust/crates/aaemu-game/src/systems/social/packets/misc.rs b/rust/crates/aaemu-game/src/systems/social/packets/misc.rs index 918f3ee34a..3f69cf3f5c 100644 --- a/rust/crates/aaemu-game/src/systems/social/packets/misc.rs +++ b/rust/crates/aaemu-game/src/systems/social/packets/misc.rs @@ -239,16 +239,6 @@ sc_packet!( } ); -cs_packet!( - /// `CSReportSpamPacket` (logged only, as in C#). - CSReportSpamPacket { mail_id: i64 } - read |s| { Ok(Self { mail_id: s.read_i64()? }) } - handle |self, server, conn| { - tracing::debug!("ReportSpam, mailId: {}", self.mail_id); - Ok(()) - } -); - // ---- Achievements (no achievement manager in the 1.2 C#; the Rust manager sends all of these // except `SCAchievementResetedPacket`) ---- @@ -317,7 +307,6 @@ impl SCAchievementResetedPacket { pub fn register(reg: &mut PacketRegistry) { reg.register::(LEVEL_PLAIN, cs::CSUpdateDominionTaxRatePacket); - reg.register::(LEVEL_PLAIN, cs::CSReportSpamPacket); } #[cfg(test)] @@ -714,10 +703,5 @@ mod tests { tax_rate: 10 } ); - let mut s = PacketStream::from_bytes((-5i64).to_le_bytes().to_vec()); - assert_eq!( - CSReportSpamPacket::read(&mut s).unwrap(), - CSReportSpamPacket { mail_id: -5 } - ); } } diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit.rs new file mode 100644 index 0000000000..0647b809d0 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit.rs @@ -0,0 +1,475 @@ +//! Read-only ship diagnostics. This is observation, never a second ownership index. +//! +//! The item operation scope must precede the publication gate. These protect summon item / +//! hull publication together, but do NOT protect the spawn manager's direct world removals, +//! every phase timer, or world-instance creation. Consequently v1 always says consistent:false. +//! HP writers can also change the live-root lookup predicate before vehicle death protection. +//! Queue, HP and world removal observations do not constitute an atomic authority snapshot. +//! A complete authority cut needs a spawn-manager reference snapshot under a boundary shared +//! with its queue drain and world removal. Its current public accessor exposes IDs only. +//! Transform, visibility, phase and queue deadlines are explicitly temporal samples. A settled +//! snapshot cannot prove an interval between calls. Release manifests must supply binary/HEAD +//! provenance; this module does not guess the source commit from a developer checkout. + +use std::collections::BTreeMap; +use std::sync::{Arc, Mutex, Weak}; + +use serde::Serialize; +use serde_json::{json, Value}; + +use crate::models::doodad::Doodad; +use crate::models::item::Item; +use crate::models::slave::Slave; +use crate::models::unit::BaseUnitType; +use crate::server::GameServer; +use crate::systems::npcs::spawn_manager; +use crate::world::{DoodadRef, Entity, SlaveRef}; + +use super::slaves; + +pub const PROTOCOL: &str = "aaemu-slave-audit/1"; +pub const PREFIX: &str = "AAEMU_SLAVE_AUDIT/1"; +const CAPABILITY: &str = "ship-audit/1;prepoll-leases;weak-retirements;sampled-queues"; +const MAX_BYTES: usize = 65_536; +const CHUNK_BYTES: usize = 160; + +#[derive(Debug, Clone)] +pub struct Request { + pub character_id: u32, + pub item_id: u64, + pub nonce: String, +} + +impl Request { + pub fn parse(args: &[String]) -> anyhow::Result { + anyhow::ensure!( + args.len() == 3, + "usage: /slave audit " + ); + anyhow::ensure!( + args[..2] + .iter() + .all(|s| !s.is_empty() && s.bytes().all(|b| b.is_ascii_digit())), + "IDs must be unsigned decimal integers" + ); + let character_id = args[0].parse::()?; + let item_id = args[1].parse::()?; + anyhow::ensure!(character_id != 0 && item_id != 0, "IDs must be nonzero"); + let nonce = &args[2]; + anyhow::ensure!( + (1..=32).contains(&nonce.len()) + && nonce + .bytes() + .all(|b| b.is_ascii_alphanumeric() || b == b'_' || b == b'-'), + "nonce must be 1..32 ASCII letters, digits, '_' or '-'" + ); + Ok(Self { + character_id, + item_id, + nonce: nonce.clone(), + }) + } +} + +#[derive(Debug, Clone, Serialize)] +pub(super) struct Job { + id: u64, + kind: &'static str, + owner: u32, + item: u64, + pub(super) phase: &'static str, + root: Option, + generation: Option, +} + +#[derive(Debug)] +struct Retirement { + world: u32, + slave: Weak>, + doodads: Vec>>, +} + +#[derive(Debug, Default)] +struct State { + sequence: u64, + jobs: BTreeMap, + retirements: Vec, +} + +/// Leases describe actual futures and never decide whether those futures may publish. +#[derive(Debug, Clone, Default)] +pub(super) struct Diagnostics(Arc>); + +#[derive(Debug)] +pub(super) struct Lease { + state: Arc>, + id: u64, +} + +impl Diagnostics { + pub(super) fn summon(&self, owner: u32, item: u64) -> Lease { + self.job("summon", owner, item, "queued", None, None) + } + + pub(super) fn retirement(&self, slave: &SlaveRef, generation: u64) -> Lease { + let (owner, item, instance) = { + let d = slave.data(); + ( + d.summoner_id, + d.summoning_item_id, + d.unit.transform.instance_id, + ) + }; + self.retiring(instance, slave, &[]); + self.job( + "retirement", + owner, + item, + "waiting_timer", + Some(slave.obj_id), + Some(generation), + ) + } + + fn job( + &self, + kind: &'static str, + owner: u32, + item: u64, + phase: &'static str, + root: Option, + generation: Option, + ) -> Lease { + let mut state = self.0.lock().unwrap_or_else(|e| e.into_inner()); + state.sequence += 1; + let id = state.sequence; + state.jobs.insert( + id, + Job { + id, + kind, + owner, + item, + phase, + root, + generation, + }, + ); + Lease { + state: self.0.clone(), + id, + } + } + + /// Weak handles retain neither the hull nor its children beyond existing queue/task owners. + pub(super) fn retiring(&self, world: u32, slave: &SlaveRef, doodads: &[DoodadRef]) { + let mut state = self.0.lock().unwrap_or_else(|e| e.into_inner()); + state.retirements.retain(|r| r.slave.strong_count() != 0); + if let Some(existing) = state + .retirements + .iter_mut() + .find(|r| r.slave.ptr_eq(&Arc::downgrade(slave))) + { + for d in doodads { + let weak = Arc::downgrade(d); + if !existing.doodads.iter().any(|w| w.ptr_eq(&weak)) { + existing.doodads.push(weak); + } + } + } else { + state.retirements.push(Retirement { + world, + slave: Arc::downgrade(slave), + doodads: doodads.iter().map(Arc::downgrade).collect(), + }); + } + } + + pub(super) fn jobs(&self, request: &Request) -> Vec { + self.0 + .lock() + .unwrap_or_else(|e| e.into_inner()) + .jobs + .values() + .filter(|j| j.owner == request.character_id || j.item == request.item_id) + .cloned() + .collect() + } +} + +impl Lease { + pub(super) fn phase(&self, phase: &'static str) { + if let Some(job) = self + .state + .lock() + .unwrap_or_else(|e| e.into_inner()) + .jobs + .get_mut(&self.id) + { + job.phase = phase; + } + } +} + +impl Drop for Lease { + fn drop(&mut self) { + // Also runs for an unpolled future, cancellation, and unwind. Recovering poison here + // avoids a second panic during unwind; this lock never guards gameplay authority. + self.state + .lock() + .unwrap_or_else(|e| e.into_inner()) + .jobs + .remove(&self.id); + } +} + +fn item_snapshot(server: &GameServer, id: u64) -> Value { + let Some(item) = server.items.item_by_id(id) else { + return Value::Null; + }; + let containers: Vec<_> = server + .items + .all_containers() + .into_iter() + .filter_map(|c| { + let c = c.lock().expect("container poisoned"); + let matches: Vec<_> = c + .items + .iter() + .filter(|i| i.id == id) + .map(item_fields) + .collect(); + (!matches.is_empty()).then(|| { + json!({"id": c.container_id, "kind": c.kind.type_name(), + "owner_id": c.owner_id, "slot_type": c.slot_type, "mate_id": c.mate_id, + "size": c.container_size(), "items": matches}) + }) + }) + .collect(); + json!({"lookup": item_fields(&item), "containers": containers}) +} + +fn item_fields(i: &Item) -> Value { + json!({"id": i.id, "template_id": i.template_id, "class": i.class.type_name(), + "owner_id": i.owner_id, "slot_type": i.slot_type, "slot": i.slot, "count": i.count, + "grade": i.grade, "flags": i.flags, "dirty": i.dirty, + "saved_slave_db_id": i.details.slave_db_id, + "detail_type_and_body_hex": hex(&i.detail_type_and_details())}) +} + +/// Cached attached object IDs and Doodad.parent_obj_id can outlive a parent relation. The +/// registered hull allocation is checked separately before using this live transform relation. +pub(super) fn rack_parent_matches(rack: &Doodad, instance: u32, hull: u32) -> bool { + rack.transform.instance_id == instance && rack.transform.parent_obj_id == hull +} + +/// No grants, find-or-create container calls, saves, SQL, or repairs. All guards are synchronous. +pub fn snapshot(server: &GameServer, request: &Request) -> Value { + let _items = server.systems.economy.operation_scope(); + let summons = &server.systems.vehicles.slave_summons; + let _publication = summons.publication_scope(); + let (sample, retiring) = { + let mut state = summons + .diagnostics + .0 + .lock() + .unwrap_or_else(|e| e.into_inner()); + state.sequence += 1; + ( + state.sequence, + state + .retirements + .iter() + .filter_map(|r| { + Some(( + r.world, + r.slave.upgrade()?, + r.doodads + .iter() + .filter_map(Weak::upgrade) + .collect::>(), + )) + }) + .collect::>(), + ) + }; + let jobs = summons.diagnostics.jobs(request); + let retirement_references: Vec<_> = retiring.iter().map(|(_, s, _)| s.clone()).collect(); + let mut worlds = server.world.worlds(); + worlds.sort_by_key(|w| w.id); + let mut references = Vec::new(); + for world in &worlds { + for slave in slaves::all_slaves(world) { + references.push((world.id, slave, Vec::new())); + } + } + for (world, slave, doodads) in retiring { + if let Some((_, _, existing)) = references + .iter_mut() + .find(|(_, s, _)| Arc::ptr_eq(s, &slave)) + { + existing.extend(doodads); + } else { + references.push((world, slave, doodads)); + } + } + references.sort_by_key(|(w, s, _)| (*w, s.obj_id)); + let owner_roots = slaves::owned_roots(server, request.character_id); + let owner_object_lookups: Vec<_> = server.world.all_characters().into_iter() + .filter(|p| p.character_id == request.character_id) + .map(|p| json!({"character_id": p.character_id, "object_id": p.obj_id, "connection_id": p.conn.id, + "worlds": worlds.iter().map(|w| json!({"world_instance": w.id, + "get_active_slave_by_owner_obj_id": slaves::get_active_slave_by_owner_obj_id(w, p.obj_id).map(|s| s.obj_id)})).collect::>()})).collect(); + let mut candidates = Vec::new(); + for (instance, slave, mut doodads) in references { + // Copy one entity, then release its data guard before any world or item lookup. + let d = slave.data().clone(); + if d.summoner_id != request.character_id && d.summoning_item_id != request.item_id { + continue; + } + let world = worlds.iter().find(|w| w.id == instance); + let registered = world.is_some_and(|w| { + w.slave(slave.obj_id) + .is_some_and(|s| Arc::ptr_eq(&s, &slave)) + }); + let retained_doodads = doodads.clone(); + // An old departure future can retain a hull after its object ID was recycled. Only + // the registered allocation may discover racks through numeric world parent fields. + // For an unregistered hull keep only weak references captured from its own lifetime. + if let Some(world) = world.filter(|_| registered) { + for rack in world.all_doodads() { + let matches = { + let r = rack.data(); + rack_parent_matches(&r, instance, slave.obj_id) + }; + if matches && !doodads.iter().any(|r| Arc::ptr_eq(r, &rack)) { + doodads.push(rack); + } + } + } + doodads.sort_by_key(|r| r.obj_id); + let racks: Vec<_> = doodads.iter().map(|rack| { + let r = rack.data().clone(); + let rack_registered = world.is_some_and(|w| w.doodad(rack.obj_id).is_some_and(|live| Arc::ptr_eq(&live, rack))); + let current = registered && rack_registered && rack_parent_matches(&r, instance, slave.obj_id); + json!({"object_id": rack.obj_id, "db_id": r.db_id, "template_id": r.template_id, + "parent": r.parent_obj_id, "transform_parent": r.transform.parent_obj_id, + "attach": r.attach_point, "owner_id": r.owner_id, "owner_db_id": r.owner_db_id, + "owner_type": r.owner_type, "registered": rack_registered, "persistent": r.is_persistent, + "captured_retirement_reference": retained_doodads.iter().any(|old| Arc::ptr_eq(old, rack)), + "current_hull_association": current, + "association": if current { "registered_hull_parent" } else { "retained_hull_lifetime" }, + "phase": r.func_group_id, "phase_time_ms": r.phase_time_ms, + "interaction_counts": r.phase.interaction_counts, "deleted": r.phase.deleted, + "func_task": r.phase.func_task, "item_id": r.item_id, "item_template_id": r.item_template_id, + "item": if r.item_id == 0 { Value::Null } else { item_snapshot(server, r.item_id) }}) + }).collect(); + // Historical references remain visible above but never count as current racks/cargo. + let rack_attach: Vec<_> = racks + .iter() + .filter(|r| r["current_hull_association"] == true) + .filter_map(|r| r["attach"].as_u64().map(|a| a as u8)) + .collect(); + let missing: Vec<_> = (60..=79u8).filter(|p| !rack_attach.contains(p)).collect(); + let duplicate: Vec<_> = (60..=79u8) + .filter(|p| rack_attach.iter().filter(|a| *a == p).count() > 1) + .collect(); + candidates.push(json!({"world_instance": instance, "object_id": slave.obj_id, + "transport_id": d.unit.tl_id, "db_id": d.id, "template_id": d.unit.template_id, + "model_id": d.unit.model_id, "parent": d.unit.transform.parent_obj_id, + "attach": d.attach_point_id, "summoner_id": d.summoner_id, "summoner_object_id": d.summoner_obj_id, + "summoning_item_id": d.summoning_item_id, "owner_type": d.owner_type as u8, + "owner_id": d.unit.owner_id, "owner_object_id": d.owner_obj_id, + "visible": slave.is_visible(), "dead": d.unit.is_dead(), "leave_generation": d.leave_task, + "registered": registered, "owner_root_lookup_member": owner_roots.iter().any(|(_, s)| Arc::ptr_eq(s, &slave)), + "observed_retirement_reference": retirement_references.iter().any(|s| Arc::ptr_eq(s, &slave)), + "item_live_root_lookup_member": registered && d.owner_type == BaseUnitType::Character && !d.unit.is_dead() && d.summoning_item_id == request.item_id, + "local_transform_sample": [d.unit.transform.x, d.unit.transform.y, d.unit.transform.z, d.unit.transform.rot_x, d.unit.transform.rot_y, d.unit.transform.rot_z], + "attached_slaves": d.attached_slaves, "attached_doodads": d.attached_doodads, + "rack_summary_scope": "current_registered_hull_parent", + "missing_rack_attach": missing, "duplicate_rack_attach": duplicate, "doodads": racks})); + } + let queues: Vec<_> = worlds.iter().map(|world| { + let manager = server.systems.npcs.spawns.get(world.id); + let rows: Vec<_> = manager.as_ref().map(|m| m.pending_despawns()).unwrap_or_default().into_iter() + .filter(|(id, _)| candidates.iter().any(|c| c["world_instance"] == world.id && (c["object_id"] == *id || c["attached_slaves"].as_array().is_some_and(|a| a.iter().any(|v| v.as_u64() == Some(u64::from(*id)))) || c["attached_doodads"].as_array().is_some_and(|a| a.iter().any(|v| v.as_u64() == Some(u64::from(*id))))))) + .map(|(id, at)| json!({"object_id": id, "due_in_ms_sample": at.map(|t| t.saturating_duration_since(spawn_manager::now()).as_millis())})).collect(); + json!({"world_instance": world.id, "matching_despawns_sample": rows}) + }).collect(); + json!({"protocol": PROTOCOL, "nonce": request.nonce, "character_id": request.character_id, + "item_id": request.item_id, "source_capability": CAPABILITY, "package_version": env!("CARGO_PKG_VERSION"), + "source_head": Value::Null, "provenance": "exact binary/source identity requires release manifest", + "sample_sequence": sample, "consistent": false, "authority_consistent": false, + "pending_supported": true, "retirement_consistent": false, + "unsupported": ["spawn queue retained references/direct world removals have no shared audit boundary", "HP writers affect live-root membership outside publication protection; world enumeration/removal has no shared snapshot boundary", "phase/transform/visibility and queue deadlines are temporal samples; no interval proof"], + "publication_scope_held": true, "item_operation_scope_held": true, + "world_instances": worlds.iter().map(|w| w.id).collect::>(), + "summon_item": item_snapshot(server, request.item_id), + "jobs": jobs, "pending_summons": jobs.iter().filter(|j| j.kind == "summon").count(), + "pending_retirement_tasks": jobs.iter().filter(|j| j.kind == "retirement").count(), + "identity_state": summons.audit_identity(request.character_id, request.item_id), + "owner_object_lookups": owner_object_lookups, + "item_has_other_live_root": slaves::item_has_other_live_root(server, request.item_id, request.character_id), + "item_root_lookup": candidates.iter().filter(|c| c["item_live_root_lookup_member"] == true).map(|c| json!({"world_instance": c["world_instance"], "object_id": c["object_id"]})).collect::>(), + "owner_root_lookup": owner_roots.iter().map(|(w, s)| json!({"world_instance": w.id, "object_id": s.obj_id})).collect::>(), + "candidates": candidates, "queues": queues}) +} + +fn hex(bytes: &[u8]) -> String { + const DIGITS: &[u8; 16] = b"0123456789abcdef"; + bytes + .iter() + .flat_map(|b| { + [ + DIGITS[(b >> 4) as usize] as char, + DIGITS[(b & 15) as usize] as char, + ] + }) + .collect() +} + +/// FNV-1a/64 is a completeness checksum, not an authenticity or cryptographic claim. +fn digest(bytes: &[u8]) -> String { + format!( + "{:016x}", + bytes + .iter() + .fold(0xcbf29ce484222325u64, |h, b| (h ^ u64::from(*b)) + .wrapping_mul(0x100000001b3)) + ) +} + +/// ASCII hex permits splitting UTF-8 JSON at byte boundaries. Every line is < 450 bytes; +/// max 410 data records + END. Consumers require all unique indices, exact length, digest, +/// matching nonce/sequence and END. END means transport completeness, never an audit pass. +pub fn chunks(request: &Request, snapshot: &Value) -> anyhow::Result> { + let mut bytes = serde_json::to_vec(snapshot)?; + if bytes.len() > MAX_BYTES { + bytes = serde_json::to_vec(&json!({"protocol": PROTOCOL, "nonce": request.nonce, + "character_id": request.character_id, "item_id": request.item_id, + "sample_sequence": snapshot["sample_sequence"], "consistent": false, "authority_consistent": false, + "pending_supported": false, "unsupported": ["snapshot exceeds 65536 byte transport limit"], "source_capability": CAPABILITY}))?; + } + let sequence = &snapshot["sample_sequence"]; + let sum = digest(&bytes); + let count = bytes.len().div_ceil(CHUNK_BYTES); + let mut lines: Vec<_> = bytes + .chunks(CHUNK_BYTES) + .enumerate() + .map(|(i, b)| { + format!( + "{PREFIX} {} {sequence} DATA {}/{count} {} fnv1a64:{sum} hex:{}", + request.nonce, + i + 1, + bytes.len(), + hex(b) + ) + }) + .collect(); + lines.push(format!( + "{PREFIX} {} {sequence} END {count} {} fnv1a64:{sum}", + request.nonce, + bytes.len() + )); + Ok(lines) +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs new file mode 100644 index 0000000000..5075d9de61 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/vehicles/audit_tests.rs @@ -0,0 +1,648 @@ +//! Deterministic source tests; no runtime DB, live stack, or asset dependency. + +use super::*; +use crate::data::items::{ItemTemplate, TemplateKind}; +use crate::data::GameData; +use crate::models::doodad::Doodad; +use crate::systems::vehicles::audit::{self, Request}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient}; +use futures::{poll, FutureExt}; +use serde_json::{json, Value}; + +fn request() -> Request { + Request::parse(&["7".into(), "4001".into(), "test_N-1".into()]).unwrap() +} + +fn fixture() -> (Arc, TestClient, PlayerRef) { + let mut data = GameData::empty(); + data.items.templates.insert( + 23398, + ItemTemplate { + kind: TemplateKind::SummonSlave { slave_id: 75 }, + ..ItemTemplate::plain(23398, 1) + }, + ); + data.systems.vehicles.slave_templates.insert( + 75, + SlaveTemplate { + id: 75, + ..Default::default() + }, + ); + let server = Arc::new(test_server_with(data)); + server.set_self(); + let client = TestClient::new(&server, 7, 1007); + let owner = spawn_player( + &server, + &client, + test_character(7, "Owner", 100.0, 100.0), + 700, + ); + let bag = owner + .data() + .inventory + .get(slot_type::INVENTORY) + .unwrap() + .clone(); + let mut item = Item::new(0); + item.id = 4001; + item.class = ItemClass::SummonSlave; + item.template_id = 23398; + item.owner_id = 7; + item.slot_type = slot_type::INVENTORY; + item.count = 1; + item.details.slave_db_id = 123; + bag.lock().unwrap().items.push(item); + server.items.add_container(bag); + (server, client, owner) +} + +#[tokio::test] +async fn audit_pending_before_poll_and_early_completion_release() { + let (server, _client, owner) = fixture(); + let future = create_for_owner(&server, &owner, 4001, 23398, false, None, None, 0.0); + let snap = audit::snapshot(&server, &request()); + assert_eq!(snap["pending_summons"], 1); + assert_eq!(snap["jobs"][0]["phase"], "queued"); + assert!(snap["candidates"].as_array().unwrap().is_empty()); + drop(future); // Never polled, so no reservation/DB/gameplay work has run. + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + let world = server.world.world(0).unwrap(); + let unpolled = create( + &server, + &world, + Some(&owner), + 75, + server.items.item_by_id(4001), + false, + None, + ); + assert_eq!( + audit::snapshot(&server, &request())["jobs"][0]["phase"], + "queued" + ); + drop(unpolled); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + assert!( + create_for_owner(&server, &owner, 4001, 0, false, None, None, 0.0) + .await + .is_none() + ); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); +} + +#[tokio::test] +async fn audit_real_owner_and_item_waiters_release_on_cancellation() { + let (server, _client, owner) = fixture(); + let summons = &server.systems.vehicles.slave_summons; + *summons.test_loader.lock().unwrap() = Some(TestSlaveLoader(Arc::new(|_, _| { + Box::pin(std::future::pending()) + }))); + let mut active = Box::pin(create_for_owner( + &server, &owner, 4001, 23398, false, None, None, 0.0, + )); + assert!(poll!(&mut active).is_pending()); + let mut waiter = Box::pin(create_for_owner( + &server, &owner, 4001, 23398, false, None, None, 0.0, + )); + assert!(poll!(&mut waiter).is_pending()); + let snap = audit::snapshot(&server, &request()); + assert_eq!(snap["pending_summons"], 2); + assert_eq!(snap["jobs"][0]["phase"], "active"); + assert_eq!(snap["jobs"][1]["phase"], "waiting_owner"); + drop(waiter); + drop(active); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + let item_lock = summons + .reservation(SummonKey::Item(4001)) + .lock_owned() + .await; + let mut waiter = Box::pin(create_for_owner( + &server, &owner, 4001, 23398, false, None, None, 0.0, + )); + assert!(poll!(&mut waiter).is_pending()); + assert_eq!( + audit::snapshot(&server, &request())["jobs"][0]["phase"], + "waiting_item" + ); + drop(waiter); + drop(item_lock); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + assert!(summons.reservation(SummonKey::Owner(7)).try_lock().is_ok()); +} + +#[tokio::test] +async fn audit_real_loader_panic_releases_job_and_authority_reservations() { + let (server, _client, owner) = fixture(); + let summons = &server.systems.vehicles.slave_summons; + *summons.test_loader.lock().unwrap() = Some(TestSlaveLoader(Arc::new(|_, _| { + Box::pin(async { panic!("audit loader unwind") }) + }))); + let future = create_for_owner(&server, &owner, 4001, 23398, false, None, None, 0.0); + assert!(std::panic::AssertUnwindSafe(future) + .catch_unwind() + .await + .is_err()); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); + assert!(summons.reservation(SummonKey::Owner(7)).try_lock().is_ok()); + assert!(summons + .reservation(SummonKey::Item(4001)) + .try_lock() + .is_ok()); +} + +#[tokio::test] +async fn audit_detached_skill_is_pending_before_runtime_polls_it() { + let (server, _client, owner) = fixture(); + let entered = Arc::new(tokio::sync::Semaphore::new(0)); + let signal = entered.clone(); + *server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .unwrap() = Some(TestSlaveLoader(Arc::new(move |_, _| { + let signal = signal.clone(); + Box::pin(async move { + signal.add_permits(1); + Err(sqlx::Error::RowNotFound) + }) + }))); + create_from_skill( + &server, + &owner, + &SkillCaster::Item { + obj_id: owner.obj_id, + item_id: 4001, + item_template_id: 23398, + type1: 0, + type2: 0, + }, + None, + 0.0, + ); + assert_eq!( + audit::snapshot(&server, &request())["jobs"][0]["phase"], + "queued" + ); + entered.acquire().await.unwrap().forget(); + assert_eq!(audit::snapshot(&server, &request())["pending_summons"], 0); +} + +fn hull(world: &WorldInstance, object: u32, owner: u32, item: u64, child: bool) -> SlaveRef { + let mut slave = Slave::new(object + 1000, 75); + slave.summoner_id = owner; + slave.summoning_item_id = item; + slave.owner_type = if child { + BaseUnitType::Slave + } else { + BaseUnitType::Character + }; + slave.unit.hp = 10; + slave.unit.transform.instance_id = world.id; + let slave = Entity::new(object, slave); + world.add_object(&slave); // Hidden objects must be included without visibility filtering. + slave +} + +#[tokio::test] +async fn audit_retirement_task_leases_release_on_abort_and_panic() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let root = hull(&world, 850, 7, 4001, false); + let diagnostics = &server.systems.vehicles.slave_summons.diagnostics; + let lease = diagnostics.retirement(&root, 1); + let task = tokio::spawn(async move { + let _lease = lease; + std::future::pending::<()>().await; + }); + // No await since construction: the task has not been polled on this runtime. + assert_eq!( + audit::snapshot(&server, &request())["pending_retirement_tasks"], + 1 + ); + task.abort(); + assert!(task.await.unwrap_err().is_cancelled()); + assert_eq!( + audit::snapshot(&server, &request())["pending_retirement_tasks"], + 0 + ); + let lease = diagnostics.retirement(&root, 2); + let task: tokio::task::JoinHandle<()> = tokio::spawn(async move { + let _lease = lease; + panic!("retirement task unwind"); + }); + assert!(task.await.unwrap_err().is_panic()); + assert_eq!( + audit::snapshot(&server, &request())["pending_retirement_tasks"], + 0 + ); +} + +#[tokio::test] +async fn audit_observation_does_not_extend_retired_hull_lifetime() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let root = hull(&world, 851, 7, 4001, false); + audit_retirement(&server, &world, &root); + world.remove_object(root.obj_id); + assert_eq!(Arc::strong_count(&root), 1); + assert_eq!( + audit::snapshot(&server, &request())["candidates"] + .as_array() + .unwrap() + .len(), + 1 + ); + assert_eq!(Arc::strong_count(&root), 1); + drop(root); + assert!(audit::snapshot(&server, &request())["candidates"] + .as_array() + .unwrap() + .is_empty()); +} + +fn rack( + world: &WorldInstance, + object: u32, + parent: u32, + attach: u8, + item: u64, +) -> crate::world::DoodadRef { + let mut data = Doodad::new(3446); + data.db_id = object + 1000; + data.parent_obj_id = parent; + data.transform.parent_obj_id = parent; + data.transform.instance_id = world.id; + data.attach_point = attach; + data.item_id = item; + data.item_template_id = 20090; + data.func_group_id = 8265; + let rack = Entity::new(object, data); + world.add_object(&rack); + rack +} + +#[tokio::test] +async fn audit_reused_hull_and_rack_ids_preserve_each_allocation() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let old = hull(&world, 860, 7, 4001, false); + let old_rack = rack(&world, 861, old.obj_id, 60, 10_060); + old.data().attached_doodads.push(old_rack.obj_id); + old.data().leave_task = 88; + let _departure = server + .systems + .vehicles + .slave_summons + .diagnostics + .retirement(&old, 88); + audit_retirement(&server, &world, &old); + // The invalidated departure future still owns old handles after world removal. Both + // numeric IDs are then reused, while the captured weak references still name the old Arcs. + old.data().leave_task = 0; + world.remove_object(old_rack.obj_id); + world.remove_object(old.obj_id); + let replacement = hull(&world, old.obj_id, 7, 4001, false); + replacement.data().id = 2860; + let new_rack = rack(&world, old_rack.obj_id, replacement.obj_id, 60, 20_060); + new_rack.data().db_id = 2861; + // A later observation of the old timer must not capture the replacement via cached IDs. + audit_retirement(&server, &world, &old); + // Deliberately leave the new hull's cache empty: valid world-parent discovery still works. + let snap = audit::snapshot(&server, &request()); + let candidates = snap["candidates"].as_array().unwrap(); + assert_eq!(candidates.len(), 2); + let historic = candidates + .iter() + .find(|c| c["registered"] == false) + .unwrap(); + let current = candidates.iter().find(|c| c["registered"] == true).unwrap(); + assert_eq!(historic["object_id"], current["object_id"]); + assert_eq!(historic["db_id"], 1860); + assert_eq!(current["db_id"], 2860); + let old_rows = historic["doodads"].as_array().unwrap(); + let new_rows = current["doodads"].as_array().unwrap(); + assert_eq!(old_rows.len(), 1); + assert_eq!(new_rows.len(), 1); + assert_eq!(old_rows[0]["db_id"], 1861); + assert_eq!(old_rows[0]["item_id"], 10_060); + assert_eq!(old_rows[0]["registered"], false); + assert_eq!(old_rows[0]["captured_retirement_reference"], true); + assert_eq!(old_rows[0]["association"], "retained_hull_lifetime"); + assert_eq!(old_rows[0]["current_hull_association"], false); + assert_eq!(new_rows[0]["db_id"], 2861); + assert_eq!(new_rows[0]["item_id"], 20_060); + assert_eq!(new_rows[0]["registered"], true); + assert_eq!(new_rows[0]["captured_retirement_reference"], false); + assert_eq!(new_rows[0]["association"], "registered_hull_parent"); + assert_eq!(new_rows[0]["current_hull_association"], true); + assert!(historic["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(60))); + assert!(!current["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(60))); + assert_eq!(historic["duplicate_rack_attach"], json!([])); + assert_eq!(current["duplicate_rack_attach"], json!([])); + assert_eq!(snap["consistent"], false); + assert_eq!(snap["authority_consistent"], false); +} + +#[tokio::test] +async fn audit_registered_hull_ignores_recycled_cached_child_id() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let root = hull(&world, 870, 7, 4001, false); + let old_rack = rack(&world, 871, root.obj_id, 60, 10_060); + root.data().attached_doodads.push(old_rack.obj_id); + audit_retirement(&server, &world, &root); + world.remove_object(old_rack.obj_id); + // A recycled cached ID alone is not a live transform relation. + let _unrelated = rack(&world, old_rack.obj_id, 999, 60, 20_060); + // Nor is a stale model parent, without the matching transform relation. + let stale_model_parent = rack(&world, 874, 999, 63, 20_063); + stale_model_parent.data().parent_obj_id = root.obj_id; + // A valid transform parent in a different instance is not this hull's current rack either. + let wrong_instance = rack(&world, 872, root.obj_id, 61, 20_061); + wrong_instance.data().transform.instance_id = 42; + root.data().attached_doodads.push(wrong_instance.obj_id); + // Re-capturing retirement evidence must not promote stale cached IDs to historical refs. + audit_retirement(&server, &world, &root); + let live = rack(&world, 873, root.obj_id, 62, 20_062); + let snap = audit::snapshot(&server, &request()); + let candidate = &snap["candidates"][0]; + assert_eq!(candidate["registered"], true); + let rows = candidate["doodads"].as_array().unwrap(); + // The legitimate old weak reference survives as history; the unrelated allocations do not. + assert_eq!(rows.len(), 2); + let historic = rows.iter().find(|r| r["item_id"] == 10_060).unwrap(); + assert_eq!(historic["captured_retirement_reference"], true); + assert_eq!(historic["current_hull_association"], false); + assert_eq!(historic["association"], "retained_hull_lifetime"); + let current = rows.iter().find(|r| r["object_id"] == live.obj_id).unwrap(); + assert_eq!(current["current_hull_association"], true); + assert!(rows + .iter() + .all(|r| r["item_id"] != 20_060 && r["item_id"] != 20_061 && r["item_id"] != 20_063)); + assert!(candidate["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(60))); + assert!(candidate["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(61))); + assert!(!candidate["missing_rack_attach"] + .as_array() + .unwrap() + .contains(&json!(62))); + assert_eq!(candidate["duplicate_rack_attach"], json!([])); +} + +#[tokio::test] +async fn audit_all_worlds_hidden_dead_children_retiring_and_owner_item_isolation() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let other = server + .world + .create_world_instance(world.template.clone(), 42); + let root = hull(&world, 800, 7, 4001, false); + let child = hull(&other, 801, 7, 0, true); + child.data().unit.hp = 0; + let foreign_item = hull(&other, 802, 8, 4001, false); + let _unrelated = hull(&other, 803, 8, 4002, false); + let retiring = hull(&world, 804, 7, 4001, false); + let retirement = server + .systems + .vehicles + .slave_summons + .diagnostics + .retirement(&retiring, 88); + audit_retirement(&server, &world, &retiring); + server + .systems + .npcs + .spawns + .get_or_create(&world) + .add_despawn( + &server, + WorldObject::from(&retiring), + Some(spawn_manager::now()), + ); + world.remove_object(retiring.obj_id); + let _unrelated_job = server + .systems + .vehicles + .slave_summons + .diagnostics + .summon(8, 4002); + let snap = audit::snapshot(&server, &request()); + assert_eq!(snap["world_instances"], json!([0, 42])); + let candidates = snap["candidates"].as_array().unwrap(); + assert_eq!(candidates.len(), 4); + let get = |id: u32| candidates.iter().find(|c| c["object_id"] == id).unwrap(); + assert_eq!(get(root.obj_id)["visible"], false); + assert_eq!(get(root.obj_id)["owner_root_lookup_member"], true); + assert_eq!(get(child.obj_id)["dead"], true); + assert_eq!(get(child.obj_id)["owner_root_lookup_member"], false); + assert_eq!( + get(foreign_item.obj_id)["item_live_root_lookup_member"], + true + ); + assert_eq!(get(retiring.obj_id)["registered"], false); + assert_eq!(snap["pending_retirement_tasks"], 1); + assert_eq!(snap["pending_summons"], 0); + assert_eq!( + snap["queues"][0]["matching_despawns_sample"][0]["object_id"], + retiring.obj_id + ); + assert_eq!(snap["consistent"], false); + drop(retirement); + assert_eq!( + audit::snapshot(&server, &request())["pending_retirement_tasks"], + 0 + ); +} + +#[tokio::test] +async fn audit_twenty_real_rack_references_and_items_are_read_only() { + let (server, _client, _owner) = fixture(); + let world = server.world.world(0).unwrap(); + let root = hull(&world, 900, 7, 4001, false); + let system = + server + .items + .container_for_character(7, slot_type::SYSTEM, 0, &server.ids.container); + let mut racks = Vec::new(); + for attach in 60..=79u8 { + let mut item = Item::new(0); + item.id = 10_000 + u64::from(attach); + item.template_id = 20090; + item.count = 1; + item.owner_id = 7; + item.slot_type = slot_type::SYSTEM; + let mut rack = Doodad::new(3446); + rack.db_id = 100 + u32::from(attach); + rack.attach_point = attach; + rack.parent_obj_id = root.obj_id; + rack.transform.parent_obj_id = root.obj_id; + rack.func_group_id = 8265; + rack.item_id = item.id; + rack.item_template_id = item.template_id; + system.lock().unwrap().items.push(item); + let rack = Entity::new(1000 + u32::from(attach), rack); + world.add_object(&rack); + root.data().attached_doodads.push(rack.obj_id); + racks.push(rack); + } + let root_before = root.data().clone(); + let racks_before: Vec<_> = racks.iter().map(|r| r.data().clone()).collect(); + let items_before = system.lock().unwrap().items.clone(); + let dirty_before = system.lock().unwrap().dirty; + let removed_before = server.items.removed_items(); + let containers_before = server.items.all_containers().len(); + let snap = audit::snapshot(&server, &request()); + assert_eq!(snap["summon_item"]["lookup"]["saved_slave_db_id"], 123); + let candidate = &snap["candidates"][0]; + assert_eq!(candidate["doodads"].as_array().unwrap().len(), 20); + assert_eq!(candidate["missing_rack_attach"], json!([])); + for rack in candidate["doodads"].as_array().unwrap() { + let attach = rack["attach"].as_u64().unwrap(); + assert_eq!(rack["item"]["lookup"]["id"], 10_000 + attach); + assert_eq!( + rack["item"]["containers"][0]["slot_type"], + slot_type::SYSTEM + ); + assert_eq!(rack["item"]["containers"][0]["items"][0]["count"], 1); + } + assert_eq!(*root.data(), root_before); + assert_eq!( + racks.iter().map(|r| r.data().clone()).collect::>(), + racks_before + ); + assert_eq!(system.lock().unwrap().items, items_before); + assert_eq!(system.lock().unwrap().dirty, dirty_before); + assert_eq!(server.items.removed_items(), removed_before); + assert_eq!(server.items.all_containers().len(), containers_before); +} + +#[test] +fn audit_request_rejects_malformed_ids_nonce_and_extra_arguments() { + for args in [ + vec!["7", "1"], + vec!["0", "1", "n"], + vec!["7", "0", "n"], + vec!["-1", "1", "n"], + vec!["+7", "1", "n"], + vec!["4294967296", "1", "n"], + vec!["7", "18446744073709551616", "n"], + vec!["7", "1", "bad|nonce"], + vec!["7", "1", "n", "extra"], + vec!["7", "1", ""], + vec!["7", "1", "é"], + ] { + assert!( + Request::parse(&args.iter().map(|s| (*s).into()).collect::>()).is_err(), + "{args:?}" + ); + } + assert!(Request::parse(&["7".into(), "1".into(), "x".repeat(33)]).is_err()); + assert!(Request::parse(&[u32::MAX.to_string(), u64::MAX.to_string(), "x".repeat(32)]).is_ok()); +} + +// A strict independent consumer: reject missing, stale, duplicate, corrupt or partial replies. +fn reassemble(lines: &[String]) -> Option { + let end: Vec<_> = lines.last()?.split_ascii_whitespace().collect(); + if end.len() != 7 || end[0] != audit::PREFIX || end[3] != "END" { + return None; + } + let count = end[4].parse::().ok()?; + let length = end[5].parse::().ok()?; + if lines.len() != count + 1 { + return None; + } + let mut bytes = Vec::new(); + for (index, line) in lines[..count].iter().enumerate() { + let fields: Vec<_> = line.split_ascii_whitespace().collect(); + if fields.len() != 8 + || fields[..3] != end[..3] + || fields[3] != "DATA" + || fields[4] != format!("{}/{count}", index + 1) + || fields[5] != end[5] + || fields[6] != end[6] + { + return None; + } + let payload = fields[7].strip_prefix("hex:")?; + if !payload.len().is_multiple_of(2) { + return None; + } + for i in (0..payload.len()).step_by(2) { + bytes.push(u8::from_str_radix(payload.get(i..i + 2)?, 16).ok()?); + } + } + let hash = bytes.iter().fold(0xcbf29ce484222325u64, |h, b| { + (h ^ u64::from(*b)).wrapping_mul(0x100000001b3) + }); + if bytes.len() != length || end[6] != format!("fnv1a64:{hash:016x}") { + return None; + } + let value: Value = serde_json::from_slice(&bytes).ok()?; + let sequence: u64 = serde_json::from_str(end[2]).ok()?; + if value["nonce"] != end[1] || value["sample_sequence"].as_u64()? != sequence { + return None; + } + Some(value) +} + +#[test] +fn audit_chunks_are_bounded_complete_and_reject_corrupt_or_stale_data() { + let req = request(); + let value = json!({"nonce": req.nonce, "sample_sequence": 83, "payload": "船".repeat(300)}); + let lines = audit::chunks(&req, &value).unwrap(); + assert!(lines.iter().all(|l| l.len() < 450)); + assert_eq!(reassemble(&lines), Some(value)); + assert!(reassemble(&lines[..lines.len() - 1]).is_none()); + let mut missing = lines.clone(); + missing.remove(1); + assert!(reassemble(&missing).is_none()); + let mut duplicate = lines.clone(); + duplicate[1] = duplicate[0].clone(); + assert!(reassemble(&duplicate).is_none()); + let mut stale = lines.clone(); + stale[0] = stale[0].replace("test_N-1", "old"); + assert!(reassemble(&stale).is_none()); + let mut corrupt = lines.clone(); + corrupt[0].push_str("00"); + assert!(reassemble(&corrupt).is_none()); + let huge = json!({"nonce": req.nonce, "sample_sequence": 83, "payload": "x".repeat(70_000)}); + let unsupported = reassemble(&audit::chunks(&req, &huge).unwrap()).unwrap(); + assert_eq!(unsupported["consistent"], false); + assert_eq!(unsupported["authority_consistent"], false); + assert!(unsupported.get("payload").is_none()); +} + +#[tokio::test] +async fn audit_invalid_command_and_gm_authorization_use_existing_root() { + use crate::systems::services::commands::scripts::harness; + let server = harness::server(); + let gm = harness::pc(&server, 7, "Observer", 100.0, 100.0); + let (_, denied) = harness::run_at(&server, &gm.p, "slave audit 7 4001 valid", 0).await; + assert!(denied.iter().all(|s| !s.starts_with(audit::PREFIX))); + for command in [ + "slave audit 7 4001 bad|nonce", + "slave audit 7 4001 n extra", + "slave audit 0 4001 n", + ] { + let (_, lines) = harness::run(&server, &gm.p, command).await; + assert!(lines.iter().all(|s| !s.starts_with(audit::PREFIX))); + } + let (_, lines) = harness::run(&server, &gm.p, "slave audit 7 4001 valid").await; + assert_eq!(reassemble(&lines).unwrap()["consistent"], false); + // This also verifies requesting an absent owner/item does not create any containers/items. + assert!(server.items.all_containers().is_empty()); +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs index 1bbedf8efc..c672978fb1 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/flow_tests.rs @@ -49,6 +49,9 @@ mod deck_standing_tests; #[path = "pr38_regression_tests.rs"] mod pr38_regression_tests; +#[path = "ship_identity_tests.rs"] +mod ship_identity_tests; + fn exp_table() -> ExperienceTable { ExperienceTable::from_templates( (1..=3u8) @@ -134,6 +137,14 @@ fn data() -> GameData { fn server_with(d: GameData) -> Arc { let s = Arc::new(test_server_with(d)); s.set_self(); + // This synthetic server has no MySQL. Explicitly supply an empty saved-hull store; + // persistence/error regressions use their own loader or private temporary tables. + *s.systems.vehicles.slave_summons.test_loader.lock().unwrap() = + Some(slaves::TestSlaveLoader(Arc::new(|_, _| { + Box::pin(async { Ok(slaves::LoadedHull::default()) }) + }))); + *s.systems.npcs.spawns.test_persistent_loader.lock().unwrap() = + Some(Arc::new(|_, _| Box::pin(async { Ok(Default::default()) }))); s } @@ -160,6 +171,7 @@ fn player_with_item( .unwrap() .clone(); let mut item = Item::create(item_id, &t, 1, 0, 1, &server.game_data.items, 0); + item.owner_id = u64::from(id); item.slot_type = slot_type::INVENTORY; item.slot = 0; let bag = p @@ -3375,23 +3387,30 @@ async fn summon_pos_places_the_vehicle_at_the_chosen_spot() { } #[tokio::test] -async fn summon_pos_outside_the_valid_area_errors_and_falls_back_in_front() { +async fn summon_pos_outside_the_valid_area_errors_without_spawning() { let server = server_with(summon_pos_data(10)); crate::systems::economy::bridges::install(&server); crate::systems::npcs::install_hooks(&server); super::install_hooks(&server); let (mut a, _pa, item_id, world) = summon_pos_client(&server); cast_summon_pos(&server, &mut a, item_id, 130.0, 100.0, 0.0, 1.25); - let slave = wait_for_slave(&world).await; - let frames = a.drain(); + let frames = tokio::time::timeout(Duration::from_secs(5), async { + let mut frames = Vec::new(); + loop { + frames.extend(a.drain()); + if error_codes(&frames).contains(&super::error::SLAVE_SPAWN_ERROR_INVALID_AREA) { + break frames; + } + tokio::task::yield_now().await; + } + }) + .await + .expect("invalid summon placement must be handled"); assert!( error_codes(&frames).contains(&super::error::SLAVE_SPAWN_ERROR_INVALID_AREA), "invalid placement must send SlaveSpawnErrorInvalidArea" ); - // C# fallback: SpawnYOffset clamped to 5 m in front, 90 degrees CCW of the owner. - let t = slave.data().unit.transform; - assert_eq!((t.x, t.y), (100.0, 105.0)); - assert!((t.rot_z - std::f32::consts::FRAC_PI_2).abs() < 1e-6); + assert!(slaves::get_active_slave_by_owner_obj_id(&world, PA).is_none()); } #[tokio::test] @@ -3619,6 +3638,9 @@ const SLOT20_ITEM: u32 = 5003; fn ship_equip_data() -> GameData { use super::data::{ItemSlaveEquipment, SlaveEquipSlot, SlaveInitialItem}; let mut d = slave_data(); + d.items.templates.get_mut(&SLAVE_ITEM).unwrap().kind = TemplateKind::SummonSlave { + slave_id: SHIP_HULL, + }; d.systems.vehicles.slave_templates.insert( SHIP_HULL, SlaveTemplate { diff --git a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs index 30f6723fcd..9d7476f9f3 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/mod.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/mod.rs @@ -21,6 +21,7 @@ //! | [`hooks`] | physics / economy hooks, the skills / social hook wrappers | //! | [`packets`] | every vehicle C->S / S->C packet | +pub mod audit; pub mod data; pub mod effects; pub mod harpoon; @@ -56,6 +57,8 @@ pub struct System { pub mates: mates::MateManagers, /// The loaded `SlaveSpawner`s. pub slave_spawners: slaves::SlaveSpawners, + /// Summon identity reservations, departure/publication ordering and pending hull saves. + pub(crate) slave_summons: slaves::SlaveSummons, /// `world.TransferManager` of every instance + the transfer spawners. pub transfers: transfers::TransferManagers, /// `ShipyardManager`. @@ -432,16 +435,11 @@ pub fn active_region_tick(server: &GameServer) { pub fn on_character_selected(server: &GameServer, player: &PlayerRef) { let char_id = player.data().id; mates::on_character_selected(server, char_id); - let instance = player.data().unit.transform.instance_id; - if let Some(world) = server.world.world(instance) { - if let Some(slave) = slaves::get_active_slave_by_owner_obj_id(&world, player.obj_id) { - tracing::warn!( - "{}: Abort the task of disabling vehicles", - player.data().unit.name - ); - slave.data().leave_task = 0; - } - } + server + .systems + .vehicles + .slave_summons + .reconnect(server, player); } /// `CharacterMates.Load` (called from `Character.Load` at character select). @@ -467,18 +465,25 @@ pub async fn save_character(server: &GameServer, character_id: u32) { /// The logout extension of `EnterWorldManager.Leave` (+10 minutes with an active vehicle). pub fn leave_extra_logout_ms(server: &GameServer, player: &PlayerRef) -> i32 { - let instance = player.data().unit.transform.instance_id; - match server.world.world(instance) { - Some(w) if slaves::get_active_slave_by_owner_obj_id(&w, player.obj_id).is_some() => { - 1000 * 60 * 10 - } - _ => 0, + if slaves::owned_roots(server, player.character_id).is_empty() { + 0 + } else { + 1000 * 60 * 10 } } /// `EnterWorldManager.LeaveWorldTask` part: despawn the owned mates and slaves (the caller then /// closes coffers and calls [`force_dismount`], as the C# order). pub fn on_leave_world(server: &GameServer, player: &PlayerRef) { + let _items = server.systems.economy.operation_scope(); + let Some(_departure) = server + .systems + .vehicles + .slave_summons + .departure(server, player) + else { + return; + }; let (instance, id) = { let c = player.data(); (c.unit.transform.instance_id, c.id) @@ -493,6 +498,15 @@ pub fn on_leave_world(server: &GameServer, player: &PlayerRef) { /// `GameConnection.OnDisconnect` part: `RemoveAndDespawnActiveOwnedMatesSlaves()` (owned mates /// now, the active vehicle 10 minutes later unless the character logs in again). pub fn on_disconnect(server: &GameServer, player: &PlayerRef) { + let _items = server.systems.economy.operation_scope(); + let Some(_departure) = server + .systems + .vehicles + .slave_summons + .departure(server, player) + else { + return; + }; let (instance, id) = { let c = player.data(); (c.unit.transform.instance_id, c.id) @@ -513,26 +527,44 @@ pub fn force_dismount_and_despawn( time_to_despawn_ms: u64, ) -> bool { let res = force_dismount(server, player, slaves::attach_reason::PREFAB_CHANGED); - let instance = player.data().unit.transform.instance_id; - let Some(world) = server.world.world(instance) else { - return res; - }; - let Some(slave) = slaves::get_active_slave_by_owner_obj_id(&world, player.obj_id) else { - return res; - }; - let gen = LEAVE_TASK_GEN.fetch_add(1, std::sync::atomic::Ordering::Relaxed); - slave.data().leave_task = gen; - let (Some(server), Ok(rt)) = (server.self_arc(), tokio::runtime::Handle::try_current()) else { - return res; - }; - let (player, slave) = (player.clone(), slave.clone()); - rt.spawn(async move { - tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; - if slave.data().leave_task != gen { - return; - } - slaves::remove_and_despawn_all_active_owned_slaves(&server, &player, false); - }); + for (world, slave) in slaves::owned_roots(server, player.character_id) { + let gen = LEAVE_TASK_GEN.fetch_add(1, std::sync::atomic::Ordering::Relaxed); + slave.data().leave_task = gen; + let (Some(server), Ok(rt)) = (server.self_arc(), tokio::runtime::Handle::try_current()) + else { + continue; + }; + let player = player.clone(); + let lease = server + .systems + .vehicles + .slave_summons + .diagnostics + .retirement(&slave, gen); + rt.spawn(async move { + let task_lease = lease; + tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; + task_lease.phase("active"); + let _items = server.systems.economy.operation_scope(); + let _publication = server + .systems + .vehicles + .slave_summons + .publication_gate + .lock(); + if slave.data().leave_task != gen { + return; + } + if !world + .slave(slave.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, &slave)) + { + return; + } + // A timer belongs to this hull, not whichever ship the owner summons later. + slaves::delete(&server, Some(&player), world.id, slave.obj_id, false); + }); + } res } @@ -554,12 +586,30 @@ pub fn force_dismount_and_despawn_test_slave( return res; }; let (player, slave) = (player.clone(), slave.clone()); + let lease = server + .systems + .vehicles + .slave_summons + .diagnostics + .retirement(&slave, gen); rt.spawn(async move { + let task_lease = lease; tokio::time::sleep(Duration::from_millis(time_to_despawn_ms)).await; + task_lease.phase("active"); + let _items = server.systems.economy.operation_scope(); + let _publication = server.systems.vehicles.slave_summons.publication_scope(); if slave.data().leave_task != gen { return; } let instance = slave.data().unit.transform.instance_id; + if !server + .world + .world(instance) + .and_then(|w| w.slave(slave.obj_id)) + .is_some_and(|live| Arc::ptr_eq(&live, &slave)) + { + return; + } slaves::delete(&server, Some(&player), instance, slave.obj_id, false); }); res diff --git a/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs new file mode 100644 index 0000000000..97d2c24de2 --- /dev/null +++ b/rust/crates/aaemu-game/src/systems/vehicles/ship_identity_tests.rs @@ -0,0 +1,1543 @@ +//! Ship identity and session regressions. Synthetic fixtures exercise lifecycle ordering; +//! the gated temporary-table fixture exercises the production MySQL lookup/save fence. + +use super::*; +use crate::models::doodad::{doodad_owner_type, Doodad}; +use crate::models::unit::BaseUnitType; +use crate::world::{Entity, SlaveRef}; +use futures::poll; +use std::sync::atomic::{AtomicUsize, Ordering}; +use tokio::sync::Semaphore; + +const MERCHANT: u32 = 75; +const MERCHANT_ITEM: u32 = 23398; +const SECOND_SHIP_ITEM: u32 = 23400; + +fn identity_data() -> GameData { + let mut data = ship_equip_data(); + for id in [511, 1205] { + data.systems + .vehicles + .model_types + .insert(id, (id, "ShipModel".into())); + data.systems.vehicles.ship_models.insert( + id, + super::super::data::ShipModel { + id, + mass: 100.0, + mass_box_size_x: 2.0, + mass_box_size_y: 6.0, + mass_box_size_z: 2.0, + ..Default::default() + }, + ); + } + use crate::systems::npcs::doodad::templates::{DoodadFuncGroups, DoodadTemplate}; + data.systems.npcs.doodad.templates.insert( + 3446, + DoodadTemplate { + id: 3446, + func_groups: [8264, 8265] + .into_iter() + .map(|id| DoodadFuncGroups { + id, + almighty: 3446, + group_kind_id: if id == 8264 { 1 } else { 2 }, + ..Default::default() + }) + .collect(), + ..Default::default() + }, + ); + data.systems + .vehicles + .slave_templates + .get_mut(&SHIP_HULL) + .unwrap() + .slave_kind = super::super::data::slave_kind::SMALL_SAILING_SHIP; + let mut merchant = data.systems.vehicles.slave_templates[&SHIP_HULL].clone(); + merchant.id = MERCHANT; + merchant.name = "Merchant Ship".into(); + merchant.model_id = 1205; + merchant.slave_kind = super::super::data::slave_kind::MERCHANT_SHIP; + merchant.portal_time = 2.0; + for binding in &mut merchant.slave_bindings { + binding.owner_id = MERCHANT; + } + let mut slots = data.systems.vehicles.slave_equip_slots[&SHIP_HULL].clone(); + for slot in &mut slots { + slot.slave_id = MERCHANT; + } + data.systems + .vehicles + .slave_templates + .insert(MERCHANT, merchant); + data.systems + .vehicles + .slave_equip_slots + .insert(MERCHANT, slots); + let points = data.systems.vehicles.attach_points[&511].clone(); + data.systems.vehicles.attach_points.insert(1205, points); + data.systems + .vehicles + .slave_equip_packs + .get_mut(&4) + .unwrap() + .push(MERCHANT); + for (item_id, hull_id) in [(MERCHANT_ITEM, MERCHANT), (SECOND_SHIP_ITEM, SHIP_HULL)] { + data.items.templates.insert( + item_id, + ItemTemplate { + kind: TemplateKind::SummonSlave { slave_id: hull_id }, + ..ItemTemplate::plain(item_id, 1) + }, + ); + } + data +} + +fn owner_with_ship( + server: &GameServer, + client: &TestClient, + character_id: u32, + obj_id: u32, + template: u32, +) -> (PlayerRef, u64) { + let (owner, item_id) = player_with_item( + server, + client, + character_id, + obj_id, + (100.0, 100.0), + template, + ); + let bag = owner.data().inventory.bag().clone(); + bag.lock().unwrap().items[0].owner_id = u64::from(character_id); + server.items.add_container(bag); + (owner, item_id) +} + +fn second_item(server: &GameServer, owner: &PlayerRef, item_id: u64, template: u32) { + let mut item = Item::create( + item_id, + server.game_data.items.template(template).unwrap(), + 1, + 0, + 1, + &server.game_data.items, + 0, + ); + item.owner_id = u64::from(owner.character_id); + item.slot_type = slot_type::INVENTORY; + item.slot = 1; + let bag = owner.data().inventory.bag().clone(); + bag.lock().unwrap().items.push(item); +} + +fn root(server: &GameServer, owner: &PlayerRef, item_id: u64, hull_id: u32) -> SlaveRef { + let world = server.world.world(0).unwrap(); + server.systems.npcs.spawns.get_or_create(&world); + let item = mates::owned_item(server, owner, item_id).unwrap(); + slaves::create_core( + server, + &world, + Some(owner), + None, + hull_id, + Some(item), + false, + Some(crate::models::transform::Transform { + x: 100.0, + y: 100.0, + z: 200.0, + ..Default::default() + }), + None, + ) + .unwrap() +} + +fn roots(server: &GameServer, owner: u32) -> Vec { + server + .world + .worlds() + .into_iter() + .flat_map(|world| slaves::all_slaves(&world)) + .filter(|slave| { + let d = slave.data(); + d.owner_type == BaseUnitType::Character && d.summoner_id == owner && !d.unit.is_dead() + }) + .collect() +} + +fn persistent_id(slave: &SlaveRef) -> u32 { + slave.data().id +} + +fn loaded_rack(server: &GameServer, hull: &SlaveRef) -> crate::world::DoodadRef { + let world = server.world.world(0).unwrap(); + let mut rack = Doodad::new(3446); + rack.item_id = 0xdead; + rack.item_template_id = 29203; + rack.attach_point = 60; + rack.func_group_id = 8265; + rack.owner_type = doodad_owner_type::SLAVE; + rack.owner_id = hull.data().summoner_id; + rack.owner_db_id = hull.data().id; + let rack = Entity::new(server.ids.object.get_next_id().unwrap(), rack); + world.attach_child(&WorldObject::from(hull), &WorldObject::from(&rack)); + hull.data().attached_doodads.push(rack.obj_id); + world.spawn(&rack, &server.view_ctx()); + rack +} + +/// Model a saved hull's identity without a database. The production persistence tests below +/// bypass this loader; a nonzero detail id is explicitly a saved identity, never a live flag. +fn install_memory_loader(server: &Arc) { + let weak = Arc::downgrade(server); + *server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .unwrap() = Some(slaves::TestSlaveLoader(Arc::new(move |_, item_id| { + let server = weak.upgrade().unwrap(); + let id = server + .items + .item_by_id(item_id) + .unwrap() + .details + .slave_db_id; + Box::pin(async move { + Ok(slaves::LoadedHull { + saved: (id != 0).then_some(slaves::SavedSlave { + id, + name: "Saved hull".into(), + hp: 100, + mp: 10, + }), + children: Vec::new(), + ..Default::default() + }) + }) + }))); +} + +fn install_barrier_loader(server: &GameServer) -> (Arc, Arc) { + let entered = Arc::new(AtomicUsize::new(0)); + let release = Arc::new(Semaphore::new(0)); + let (calls, permits) = (entered.clone(), release.clone()); + *server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .unwrap() = Some(slaves::TestSlaveLoader(Arc::new(move |_, _| { + calls.fetch_add(1, Ordering::SeqCst); + let permits = permits.clone(); + Box::pin(async move { + permits.acquire_owned().await.unwrap().forget(); + Ok(slaves::LoadedHull::default()) + }) + }))); + (entered, release) +} + +async fn summon( + server: &GameServer, + owner: &PlayerRef, + item_id: u64, + template: u32, +) -> Option { + slaves::create_for_owner(server, owner, item_id, template, false, None, None, 0.0).await +} + +fn saved_rack_row(parent: u32) -> crate::systems::npcs::doodad::db::DoodadRow { + crate::systems::npcs::doodad::db::DoodadRow { + id: 500, + owner_id: 1, + owner_type: doodad_owner_type::SLAVE, + attach_point: 60, + template_id: 3446, + current_phase_id: 8265, + plant_time: crate::db::min_value(), + growth_time: crate::db::min_value(), + phase_time: crate::db::min_value(), + x: 0.0, + y: 0.0, + z: 0.0, + roll: 0.0, + pitch: 0.0, + yaw: 0.0, + scale: 1.0, + item_id: 0, + house_id: parent, + parent_doodad: 0, + item_template_id: 0, + item_container_id: 0, + data: 0, + farm_type: 0, + interaction_counts: "{}".into(), + } +} + +async fn ordinary_mutation_waits_after_final_clone(destroy: bool) { + use crate::net::registry::ClientPacket; + use crate::systems::economy::inventory::{self, Inv, ItemTxn}; + use std::sync::mpsc; + let server = server_with(identity_data()); + install_memory_loader(&server); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let prior = root(&server, &owner, item_id, SHIP_HULL); + let (release, continuation) = mpsc::channel(); + let continuation = Mutex::new(continuation); + let (entered, ready) = tokio::sync::oneshot::channel(); + let entered = Mutex::new(Some(entered)); + *server + .systems + .vehicles + .slave_summons + .test_after_item_validation + .lock() + .unwrap() = Some(slaves::TestPublicationHook(Arc::new(move |server| { + assert!(!crate::systems::economy::System::ops_held_on_this_thread()); + // A callback may open its own normal transaction under the outer scope. + drop(ItemTxn::begin(server)); + entered.lock().unwrap().take().unwrap().send(()).unwrap(); + continuation + .lock() + .unwrap() + .recv_timeout(Duration::from_secs(5)) + .unwrap(); + }))); + let creation_server = server.clone(); + let creation_owner = owner.clone(); + let creation = tokio::spawn(async move { + summon(&creation_server, &creation_owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap() + .obj_id + }); + ready.await.unwrap(); + let mutation_server = server.clone(); + let mutation_owner = owner.clone(); + let runtime = tokio::runtime::Handle::current(); + let mutation = std::thread::spawn(move || { + let _runtime = runtime.enter(); + if destroy { + let mut client = TestClient::new(&mutation_server, 2, 1); + client.conn.active_char = Some(mutation_owner); + futures::executor::block_on( + crate::systems::economy::item_handlers::CSDestroyItemPacket { + item_id, + slot_type: slot_type::INVENTORY, + slot: 0, + count: 1, + } + .handle(&mutation_server, &mut client.conn), + ) + .unwrap(); + } else { + let mut txn = ItemTxn::begin(&mutation_server); + let inv = Inv::of(&mutation_owner); + assert!(inventory::split_or_move_item( + &mut txn, + &inv, + crate::models::item_task::task_type::SWAP_ITEMS, + item_id, + slot_type::INVENTORY, + 0, + 0, + slot_type::BANK, + 0, + 0 + )); + } + }); + server.systems.economy.wait_until_operation_blocked(); + assert_eq!(roots(&server, 1)[0].obj_id, prior.obj_id); + assert_eq!( + mates::owned_item(&server, &owner, item_id) + .unwrap() + .slot_type, + slot_type::INVENTORY + ); + release.send(()).unwrap(); + let published = creation.await.unwrap(); + mutation.join().unwrap(); + assert_ne!(published, prior.obj_id); + assert_eq!(roots(&server, 1)[0].obj_id, published); + let item = mates::owned_item(&server, &owner, item_id); + if destroy { + assert!(item.is_none()); + } else { + assert_eq!(item.unwrap().slot_type, slot_type::BANK); + } +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn ordinary_destroy_waits_until_ship_publication_finishes() { + ordinary_mutation_waits_after_final_clone(true).await; +} + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn ordinary_bank_move_waits_until_ship_publication_finishes() { + ordinary_mutation_waits_after_final_clone(false).await; +} + +#[tokio::test] +async fn missing_actual_metadata_update_fails_before_prior_hull_replacement() { + let server = server_with(identity_data()); + install_memory_loader(&server); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let prior = root(&server, &owner, item_id, SHIP_HULL); + let prior_state = prior.data().clone(); + let bag = owner.data().inventory.bag().clone(); + *server + .systems + .vehicles + .slave_summons + .test_after_item_validation + .lock() + .unwrap() = Some(slaves::TestPublicationHook(Arc::new(move |server| { + // Explicit limitation: unlocked quest-style writes do not enter the outer scope. + let mut txn = crate::systems::economy::inventory::ItemTxn::unlocked(server); + bag.lock() + .unwrap() + .remove_item_task( + crate::models::item_task::task_type::DESTROY, + item_id, + true, + &mut txn.env, + ) + .unwrap(); + }))); + client.drain(); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(roots(&server, 1)[0].obj_id, prior.obj_id); + assert_eq!(*prior.data(), prior_state); + let packets = client.drain(); + for opcode in [ + sc::SCSlaveCreatedPacket, + sc::SCSlaveDespawnPacket, + sc::SCSlaveRemovedPacket, + ] { + assert!(!ops(&packets).contains(&opcode)); + } +} + +#[tokio::test] +async fn panic_after_final_validation_releases_publication_and_item_reservations() { + let server = server_with(identity_data()); + install_memory_loader(&server); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let prior = root(&server, &owner, item_id, SHIP_HULL); + *server + .systems + .vehicles + .slave_summons + .test_after_item_validation + .lock() + .unwrap() = Some(slaves::TestPublicationHook(Arc::new(|_| { + panic!("deliberate pre-publication panic") + }))); + let task_server = server.clone(); + let task_owner = owner.clone(); + let task = + tokio::spawn( + async move { summon(&task_server, &task_owner, item_id, SECOND_SHIP_ITEM).await }, + ); + assert!(task.await.unwrap_err().is_panic()); + assert_eq!(roots(&server, 1)[0].obj_id, prior.obj_id); + server + .systems + .vehicles + .slave_summons + .test_after_item_validation + .lock() + .unwrap() + .take(); + let retry = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!(persistent_id(&retry), persistent_id(&prior)); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test] +async fn persistent_query_then_direct_despawn_cannot_publish_orphan_racks_or_physics() { + use crate::net::registry::ClientPacket; + use crate::systems::ai::physics; + let mut data = identity_data(); + data.systems.ai.ai.ship_models.insert( + 1205, + crate::systems::ai::data::ShipModel { + id: 1205, + mass: 100.0, + mass_box_size_x: 2.0, + mass_box_size_y: 6.0, + mass_box_size_z: 2.0, + water_density: 1000.0, + ..Default::default() + }, + ); + let server = server_with(data); + server.systems.ai.physics.set_manual_ticks(true); + install_memory_loader(&server); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + client.conn.active_char = Some(owner.clone()); + let prior = root(&server, &owner, item_id, MERCHANT); + let physics_world = server.systems.ai.physics.world(0).unwrap(); + physics::run_world_tick(&server, &physics_world, 40); + assert!(physics::ship_state(&server, prior.obj_id).is_some()); + let release = Arc::new(Semaphore::new(0)); + let entered = Arc::new(AtomicUsize::new(0)); + let (permits, calls, weak) = (release.clone(), entered.clone(), Arc::downgrade(&server)); + *server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .unwrap() = Some(Arc::new(move |_, parent| { + let prepared = crate::systems::npcs::spawn_manager::PersistentDoodads::prepare( + &weak.upgrade().unwrap(), + vec![saved_rack_row(parent as u32)], + ) + .unwrap(); + calls.fetch_add(1, Ordering::SeqCst); + let permits = permits.clone(); + Box::pin(async move { + permits.acquire_owned().await.unwrap().forget(); + Ok(prepared) + }) + })); + client.drain(); + let mut creation = Box::pin(summon(&server, &owner, item_id, MERCHANT_ITEM)); + assert!(poll!(creation.as_mut()).is_pending()); + assert_eq!(entered.load(Ordering::SeqCst), 1); + super::super::packets::CSDespawnSlavePacket { + slave_obj_id: prior.obj_id, + } + .handle(&server, &mut client.conn) + .await + .unwrap(); + physics::run_world_tick(&server, &physics_world, 40); + assert!(physics::ship_state(&server, prior.obj_id).is_none()); + release.add_permits(1); + assert!(creation.await.is_none()); + physics::run_world_tick(&server, &physics_world, 40); + assert!(physics::ship_state(&server, prior.obj_id).is_none()); + assert!(roots(&server, 1).is_empty()); + assert!(server.world.world(0).unwrap().all_doodads().is_empty()); + assert!(server + .systems + .npcs + .spawns + .get(0) + .unwrap() + .get_all_player_doodads() + .is_empty()); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); +} + +#[tokio::test] +async fn persistent_query_failure_preserves_prior_hull_cargo_and_emits_no_creation() { + let server = server_with(identity_data()); + install_memory_loader(&server); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let prior = root(&server, &owner, item_id, MERCHANT); + let rack = loaded_rack(&server, &prior); + { + let mut rack = rack.data(); + rack.item_id = 0; + rack.item_template_id = 0; + } + let hull_before = prior.data().clone(); + let rack_before = rack.data().clone(); + let item_before = mates::owned_item(&server, &owner, item_id).unwrap(); + let calls = Arc::new(AtomicUsize::new(0)); + let queries = calls.clone(); + *server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .unwrap() = Some(Arc::new(move |_, _| { + queries.fetch_add(1, Ordering::SeqCst); + Box::pin(async { anyhow::bail!("deliberate persistent doodad query failure") }) + })); + client.drain(); + assert!(summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert_eq!(*prior.data(), hull_before); + assert_eq!(*rack.data(), rack_before); + assert_eq!( + mates::owned_item(&server, &owner, item_id).unwrap(), + item_before + ); + assert_eq!(roots(&server, 1)[0].obj_id, prior.obj_id); + assert_eq!(server.world.world(0).unwrap().all_doodads().len(), 1); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); +} + +#[tokio::test] +async fn persistent_batch_validation_and_stale_parent_have_no_world_side_effects() { + use crate::systems::npcs::spawn_manager::PersistentDoodads; + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let parent = root(&server, &owner, item_id, MERCHANT); + let row = saved_rack_row(persistent_id(&parent)); + let mut malformed = row.clone(); + malformed.id += 1; + malformed.interaction_counts = "invalid JSON".into(); + assert!(PersistentDoodads::prepare(&server, vec![row.clone(), malformed]).is_err()); + let prepared = PersistentDoodads::prepare(&server, vec![row]).unwrap(); + let world = server.world.world(0).unwrap(); + world.remove_object(parent.obj_id); + let replacement = Entity::new(parent.obj_id, parent.data().clone()); + world.spawn(&replacement, &server.view_ctx()); + let manager = server.systems.npcs.spawns.get(0).unwrap(); + assert!(manager + .publish_persistent_doodads(&server, prepared, Some(&WorldObject::from(&parent)), true) + .is_err()); + assert!(world.all_doodads().is_empty()); + assert!(manager.get_all_player_doodads().is_empty()); +} + +fn cargo_identity_data() -> GameData { + use crate::systems::npcs::doodad::templates::DoodadFunc; + let mut data = identity_data(); + data.items.templates.insert( + 29203, + ItemTemplate { + kind: TemplateKind::Backpack { backpack_type: 1 }, + ..ItemTemplate::plain(29203, 1) + }, + ); + for (group, kind, next) in [ + (8264, "DoodadFuncConsumeChanger", 8265), + (8265, "DoodadFuncRecoverItem", 8264), + ] { + data.systems.npcs.doodad.funcs_by_groups.insert( + group, + vec![DoodadFunc { + group_id: group, + func_type: kind.into(), + next_phase: next, + ..Default::default() + }], + ); + } + data +} + +fn original_pack(server: &GameServer, owner: &PlayerRef, slot: u8) -> u64 { + use crate::systems::economy::inventory::Inv; + let inventory = crate::models::character::Inventory::new( + owner.character_id, + 50, + 50, + &server.items, + &server.ids.container, + ); + owner.data().inventory = inventory; + let id = loop { + let id = u64::from(server.ids.item.get_next_id().unwrap()); + if server.items.item_by_id(id).is_none() { + break id; + } + }; + let pack = Item::create( + id, + server.game_data.items.template(29203).unwrap(), + 1, + 0, + 1, + &server.game_data.items, + 0, + ); + let container = Inv::of(owner).get(slot).unwrap(); + let position = if slot == slot_type::EQUIPMENT { + crate::models::container::equip_slot::BACKPACK + } else { + -1 + }; + container + .lock() + .unwrap() + .add_new_item(pack, position, &server.game_data.items) + .unwrap(); + id +} + +#[tokio::test] +async fn prefetched_loaded_rack_then_same_pack_recovery_refuses_same_item_replacement() { + use crate::systems::economy::bridges::EconomyForNpcs; + use crate::systems::economy::inventory::Inv; + use crate::systems::npcs::hooks::{CargoRecovery, EconomyBridge}; + use crate::systems::npcs::{doodad::db, spawn_manager::PersistentDoodads}; + let server = server_with(cargo_identity_data()); + install_memory_loader(&server); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let hull = root(&server, &owner, item_id, MERCHANT); + let rack = loaded_rack(&server, &hull); + { + let mut d = rack.data(); + d.item_id = 0; + d.item_template_id = 0; + d.func_group_id = 8264; + d.is_persistent = true; + d.parent_obj_id = hull.obj_id; + } + server + .systems + .npcs + .spawns + .get(0) + .unwrap() + .add_player_doodad(rack.clone()); + let pack_id = original_pack(&server, &owner, slot_type::EQUIPMENT); + let expected = server.items.item_by_id(pack_id).unwrap(); + let release = Arc::new(Semaphore::new(0)); + let entered = Arc::new(AtomicUsize::new(0)); + let (weak, loading_owner, loading_rack, permits, calls) = ( + Arc::downgrade(&server), + owner.clone(), + rack.clone(), + release.clone(), + entered.clone(), + ); + *server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .unwrap() = Some(Arc::new(move |_, _| { + let server = weak.upgrade().unwrap(); + // Initial hull preflight saw an empty rack. SQL captures the loaded state while + // the same real pack is in System escrow, then pauses after preparing that row. + assert!(EconomyForNpcs.try_store_doodad_item( + &server, + &loading_owner, + &loading_rack, + &expected, + 1 + )); + loading_rack.data().func_group_id = 8265; + let row = db::snapshot(&server, &loading_rack).unwrap(); + assert_eq!(row.item_id, pack_id); + let prepared = PersistentDoodads::prepare(&server, vec![row]).unwrap(); + calls.fetch_add(1, Ordering::SeqCst); + let permits = permits.clone(); + Box::pin(async move { + permits.acquire_owned().await.unwrap().forget(); + Ok(prepared) + }) + })); + client.drain(); + let mut creation = Box::pin(summon(&server, &owner, item_id, MERCHANT_ITEM)); + assert!(poll!(creation.as_mut()).is_pending()); + assert_eq!(entered.load(Ordering::SeqCst), 1); + assert_eq!( + server.items.item_by_id(pack_id).unwrap().slot_type, + slot_type::SYSTEM + ); + assert!(matches!( + EconomyForNpcs.recover_doodad_cargo(&server, &owner, &rack), + CargoRecovery::Recovered + )); + rack.data().func_group_id = 8264; + assert_eq!( + Inv::of(&owner) + .equipped(crate::models::container::equip_slot::BACKPACK) + .unwrap() + .id, + pack_id + ); + let hull_before = hull.data().clone(); + let rack_before = rack.data().clone(); + let item_before = server.items.item_by_id(item_id).unwrap(); + let pack_before = server.items.item_by_id(pack_id).unwrap(); + release.add_permits(1); + assert!( + tokio::time::timeout(std::time::Duration::from_secs(5), creation) + .await + .unwrap() + .is_none() + ); + assert!(Arc::ptr_eq(&roots(&server, 1)[0], &hull)); + assert_eq!(*hull.data(), hull_before); + assert_eq!(*rack.data(), rack_before); + assert_eq!(server.items.item_by_id(item_id).unwrap(), item_before); + assert_eq!(server.items.item_by_id(pack_id).unwrap(), pack_before); + let occurrences: usize = server + .items + .all_containers() + .iter() + .map(|c| { + c.lock() + .unwrap() + .items + .iter() + .filter(|i| i.id == pack_id) + .count() + }) + .sum(); + assert_eq!(occurrences, 1); + assert_eq!(server.world.world(0).unwrap().all_doodads().len(), 1); + assert_eq!( + server + .systems + .npcs + .spawns + .get(0) + .unwrap() + .get_all_player_doodads() + .len(), + 1 + ); + assert!(!server.items.removed_items().contains(&pack_id)); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); +} + +#[tokio::test] +async fn different_inactive_saved_hull_restores_another_owners_system_cargo() { + use crate::systems::npcs::spawn_manager::PersistentDoodads; + let server = server_with(cargo_identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let active = root(&server, &owner, item_id, SHIP_HULL); + let contributor_client = TestClient::new(&server, 2, 2); + let contributor = spawn_player( + &server, + &contributor_client, + test_character(2, "Contributor", 100.0, 100.0), + PB, + ); + let pack_id = original_pack(&server, &contributor, slot_type::SYSTEM); + let mut row = saved_rack_row(777); + row.item_id = pack_id; + row.item_template_id = 29203; + { + let prepared = PersistentDoodads::prepare(&server, vec![row.clone()]).unwrap(); + let _items = server.systems.economy.operation_scope(); + assert!(prepared.validate_slave_cargo(&server, 777, None).is_ok()); + } + let target_item = loop { + let id = u64::from(server.ids.item.get_next_id().unwrap()); + if server.items.item_by_id(id).is_none() { + break id; + } + }; + second_item(&server, &owner, target_item, MERCHANT_ITEM); + server + .items + .update_item(target_item, |item| item.details.slave_db_id = 777) + .unwrap(); + install_memory_loader(&server); + let weak = Arc::downgrade(&server); + *server + .systems + .npcs + .spawns + .test_persistent_loader + .lock() + .unwrap() = Some(Arc::new(move |_, parent| { + assert_eq!(parent, 777); + let prepared = + PersistentDoodads::prepare(&weak.upgrade().unwrap(), vec![row.clone()]).unwrap(); + Box::pin(async move { Ok(prepared) }) + })); + let restored = tokio::time::timeout( + std::time::Duration::from_secs(5), + summon(&server, &owner, target_item, MERCHANT_ITEM), + ) + .await + .unwrap() + .unwrap(); + assert_eq!(persistent_id(&restored), 777); + assert_eq!(restored.data().summoning_item_id, target_item); + assert!(!Arc::ptr_eq(&restored, &active)); + assert_eq!(roots(&server, 1).len(), 1); + assert!(Arc::ptr_eq(&roots(&server, 1)[0], &restored)); + let racks = server.world.world(0).unwrap().all_doodads(); + assert_eq!(racks.len(), 1); + assert_eq!(racks[0].data().item_id, pack_id); + assert_eq!(racks[0].data().parent_obj_id, restored.obj_id); + assert_eq!( + server.items.item_by_id(pack_id).unwrap().slot_type, + slot_type::SYSTEM + ); + assert_eq!(server.items.item_by_id(pack_id).unwrap().owner_id, 2); + assert!(!server.items.removed_items().contains(&pack_id)); +} + +#[tokio::test] +async fn merchant_loaded_refusal_preserves_hull_rider_gunner_and_item_identity() { + let server = server_with(identity_data()); + let mut owner_client = TestClient::new(&server, 1, 1); + let mut gunner_client = TestClient::new(&server, 2, 2); + let (owner, item_id) = owner_with_ship(&server, &owner_client, 1, PA, MERCHANT_ITEM); + let gunner = spawn_player( + &server, + &gunner_client, + test_character(2, "Gunner", 100.0, 100.0), + PB, + ); + let hull = root(&server, &owner, item_id, MERCHANT); + let world = server.world.world(0).unwrap(); + let cannon_id = hull.data().attached_slaves[0]; + let cannon = world.slave(cannon_id).unwrap(); + let tl = u32::from(hull.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &owner, tl); + let pos = world.world_pos_rot(&WorldObject::from(&cannon)); + gunner.data().unit.transform.set_xyz(pos.x, pos.y, pos.z); + world.attach_child(&WorldObject::from(&hull), &WorldObject::from(&gunner)); + let cannon_tl = u32::from(cannon.data().unit.tl_id); + slaves::bind_slave_by_tl(&server, &gunner, cannon_tl); + assert!(!hull.data().attached_characters.is_empty()); + assert!(!cannon.data().attached_characters.is_empty()); + let rack = loaded_rack(&server, &hull); + let hull_before = hull.data().clone(); + let cannon_before = cannon.data().clone(); + let rack_before = rack.data().clone(); + let item_before = mates::owned_item(&server, &owner, item_id).unwrap(); + owner_client.drain(); + gunner_client.drain(); + + slaves::delete(&server, Some(&owner), world.id, hull.obj_id, false); + assert!(summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + let item = mates::owned_item(&server, &owner, item_id).unwrap(); + assert!(slaves::create( + &server, + &world, + Some(&owner), + MERCHANT, + Some(item), + false, + None + ) + .await + .is_none()); + assert_eq!( + roots(&server, 1) + .iter() + .map(|s| s.obj_id) + .collect::>(), + vec![hull.obj_id] + ); + assert_eq!(*hull.data(), hull_before); + assert_eq!(*cannon.data(), cannon_before); + assert_eq!(*rack.data(), rack_before); + assert_eq!( + mates::owned_item(&server, &owner, item_id).unwrap(), + item_before + ); + assert_eq!(owner.data().unit.transform.parent_obj_id, hull.obj_id); + assert_eq!(gunner.data().unit.transform.parent_obj_id, cannon.obj_id); + let frames = owner_client.drain(); + let gunner_frames = gunner_client.drain(); + assert!(error_codes(&frames).contains(&super::super::error::SLAVE_EQUIPMENT_LOADED_ITEM)); + for op in [ + sc::SCSlaveCreatedPacket, + sc::SCSlaveDespawnPacket, + sc::SCSlaveRemovedPacket, + sc::SCUnitDetachedPacket, + sc::SCItemTaskSuccessPacket, + ] { + assert!(!ops(&frames).contains(&op)); + assert!(!ops(&gunner_frames).contains(&op)); + } + assert!(server + .systems + .npcs + .spawns + .get(0) + .unwrap() + .pending_despawns() + .is_empty()); +} + +#[tokio::test] +async fn cannon_children_never_qualify_as_an_active_root() { + let server = server_with(identity_data()); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let hull = root(&server, &owner, item_id, SHIP_HULL); + let world = server.world.world(0).unwrap(); + assert!(!hull.data().attached_slaves.is_empty()); + assert_eq!( + slaves::get_active_slave_by_owner_obj_id(&world, PA) + .unwrap() + .obj_id, + hull.obj_id + ); + client.drain(); + slaves::send_my_slave_packet_to_all_owners(&server); + let notifications = client.drain(); + assert_eq!(ops(¬ifications), vec![sc::SCMySlavePacket]); + assert!(body(¬ifications, sc::SCMySlavePacket).starts_with(&bc(hull.obj_id))); + // Deterministic: even when it is the only slave in the table, the cannon is not a root. + world.remove_object(hull.obj_id); + assert!(slaves::get_active_slave_by_owner_obj_id(&world, PA).is_none()); + assert_eq!(super::super::leave_extra_logout_ms(&server, &owner), 0); + slaves::send_my_slave_packet_to_all_owners(&server); + assert!(client.drain().is_empty()); +} + +#[tokio::test] +async fn invalid_item_placement_and_repair_leave_the_prior_hull_intact() { + let server = server_with(identity_data()); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let hull = root(&server, &owner, item_id, SHIP_HULL); + let original = hull.data().clone(); + client.drain(); + assert!(summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + assert!(slaves::create_for_owner( + &server, + &owner, + item_id, + SECOND_SHIP_ITEM, + false, + None, + Some(crate::systems::skills::ext::SummonPlacement { + x: 500.0, + y: 500.0, + z: 200.0, + yaw: 0.0, + }), + 10.0 + ) + .await + .is_none()); + mates::update_owned_item(&server, Some(&owner), item_id, |item| { + item.details.slave_is_destroyed = 1; + item.details.slave_repair_start_time = chrono::Utc::now().timestamp(); + }); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(*hull.data(), original); + assert_eq!(roots(&server, 1).len(), 1); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveDespawnPacket)); +} + +#[tokio::test] +async fn owner_reservation_serializes_requests_across_the_load_await() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let (calls, release) = install_barrier_loader(&server); + let mut first = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + let mut second = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(first.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert!(poll!(second.as_mut()).is_pending()); + assert_eq!( + calls.load(Ordering::SeqCst), + 1, + "second request must wait before querying" + ); + release.add_permits(1); + let first_hull = first.await.unwrap(); + assert!(poll!(second.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 2); + release.add_permits(1); + let second_hull = second.await.unwrap(); + assert_ne!(first_hull.obj_id, second_hull.obj_id); + assert_eq!( + roots(&server, 1) + .iter() + .map(|s| s.obj_id) + .collect::>(), + vec![second_hull.obj_id] + ); +} + +#[tokio::test] +async fn cancelled_load_releases_reservation_and_departed_session_cannot_publish() { + let server = server_with(identity_data()); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let (calls, release) = install_barrier_loader(&server); + let mut cancelled = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(cancelled.as_mut()).is_pending()); + drop(cancelled); + let mut pending = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(pending.as_mut()).is_pending()); + assert_eq!( + calls.load(Ordering::SeqCst), + 2, + "cancel released owner and item guards" + ); + super::super::on_disconnect(&server, &owner); + // Even before world removal, the departure marker closes the publication window. + release.add_permits(1); + assert!(pending.await.is_none()); + assert!(roots(&server, 1).is_empty()); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); + + server.world.world(0).unwrap().delete(&owner); + server.world.try_remove_character(owner.obj_id); + let reconnect = TestClient::new(&server, 2, 1); + let (new_owner, new_item) = owner_with_ship(&server, &reconnect, 1, PA, SECOND_SHIP_ITEM); + super::super::on_character_selected(&server, &new_owner); + install_memory_loader(&server); + assert!(summon(&server, &new_owner, new_item, SECOND_SHIP_ITEM) + .await + .is_some()); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test] +async fn reconnect_during_an_old_sessions_load_cannot_publish_its_retained_player() { + let server = server_with(identity_data()); + let mut old_client = TestClient::new(&server, 1, 1); + let (old_owner, item_id) = owner_with_ship(&server, &old_client, 1, PA, SECOND_SHIP_ITEM); + let (calls, release) = install_barrier_loader(&server); + let mut old_request = Box::pin(summon(&server, &old_owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(old_request.as_mut()).is_pending()); + super::super::on_disconnect(&server, &old_owner); + server.world.world(0).unwrap().delete(&old_owner); + server.world.try_remove_character(old_owner.obj_id); + let reconnect = TestClient::new(&server, 2, 1); + let character = old_owner.data().clone(); + let new_owner = spawn_player(&server, &reconnect, character, PA); + super::super::on_character_selected(&server, &new_owner); + let mut new_request = Box::pin(summon(&server, &new_owner, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(new_request.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + release.add_permits(1); + assert!(old_request.await.is_none()); + assert!(!ops(&old_client.drain()).contains(&sc::SCSlaveCreatedPacket)); + assert!(poll!(new_request.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 2); + release.add_permits(1); + new_request.await.unwrap(); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test] +async fn another_owner_can_load_while_the_first_owner_is_waiting() { + let server = server_with(identity_data()); + let a = TestClient::new(&server, 1, 1); + let b = TestClient::new(&server, 2, 2); + let (owner, item_id) = owner_with_ship(&server, &a, 1, PA, SECOND_SHIP_ITEM); + let (other, other_item) = owner_with_ship(&server, &b, 2, PB, SECOND_SHIP_ITEM); + let (calls, _) = install_barrier_loader(&server); + let mut first = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + let mut second = Box::pin(summon(&server, &other, other_item, SECOND_SHIP_ITEM)); + assert!(poll!(first.as_mut()).is_pending()); + assert!(poll!(second.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 2); +} + +#[tokio::test] +async fn item_reservation_also_serializes_conflicting_owners() { + let server = server_with(identity_data()); + let a = TestClient::new(&server, 1, 1); + let b = TestClient::new(&server, 2, 2); + let (owner, item_id) = owner_with_ship(&server, &a, 1, PA, SECOND_SHIP_ITEM); + let (other, _) = owner_with_ship(&server, &b, 2, PB, SECOND_SHIP_ITEM); + // Deliberately conflicting inventory snapshots must not publish the same persistent item + // twice, even when each request initially sees its own character as the item owner. + let bag = other.data().inventory.bag().clone(); + bag.lock().unwrap().items[0].id = item_id; + let (calls, release) = install_barrier_loader(&server); + let mut first = Box::pin(summon(&server, &owner, item_id, SECOND_SHIP_ITEM)); + let mut conflicting = Box::pin(summon(&server, &other, item_id, SECOND_SHIP_ITEM)); + assert!(poll!(first.as_mut()).is_pending()); + assert!(poll!(conflicting.as_mut()).is_pending()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + release.add_permits(1); + first.await.unwrap(); + assert!(conflicting.await.is_none()); + assert_eq!(calls.load(Ordering::SeqCst), 1); + assert_eq!(roots(&server, 1).len(), 1); + assert!(roots(&server, 2).is_empty()); +} + +#[tokio::test] +async fn switching_distinct_items_preserves_each_identity_and_other_owners() { + let server = server_with(identity_data()); + install_memory_loader(&server); + let a = TestClient::new(&server, 1, 1); + let b = TestClient::new(&server, 2, 2); + let (owner, first_item) = owner_with_ship(&server, &a, 1, PA, MERCHANT_ITEM); + let (other, other_item) = owner_with_ship(&server, &b, 2, PB, SECOND_SHIP_ITEM); + second_item(&server, &owner, 0x8000, SECOND_SHIP_ITEM); + let first = summon(&server, &owner, first_item, MERCHANT_ITEM) + .await + .unwrap(); + let unaffected = summon(&server, &other, other_item, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert!(summon(&server, &owner, other_item, SECOND_SHIP_ITEM) + .await + .is_none()); + let second = summon(&server, &owner, 0x8000, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_ne!(persistent_id(&first), persistent_id(&second)); + assert_eq!(roots(&server, 1).len(), 1); + assert_eq!(roots(&server, 2)[0].obj_id, unaffected.obj_id); + let again = summon(&server, &owner, first_item, MERCHANT_ITEM) + .await + .unwrap(); + assert_eq!(persistent_id(&again), persistent_id(&first)); + assert_ne!(again.obj_id, first.obj_id); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test(start_paused = true)] +async fn retained_reconnect_cancels_the_hull_timer_and_cannot_duplicate_loaded_merchant() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let hull = root(&server, &owner, item_id, MERCHANT); + loaded_rack(&server, &hull); + super::super::on_disconnect(&server, &owner); + assert_ne!(hull.data().leave_task, 0); + tokio::task::yield_now().await; + tokio::time::advance(Duration::from_secs(599)).await; + assert_eq!(roots(&server, 1)[0].obj_id, hull.obj_id); + server.world.world(0).unwrap().delete(&owner); + server.world.try_remove_character(owner.obj_id); + let reconnect = TestClient::new(&server, 2, 1); + let mut character = owner.data().clone(); + character.unit.transform.parent_obj_id = 0; + let new_owner = spawn_player(&server, &reconnect, character, PA); + super::super::on_character_selected(&server, &new_owner); + assert_eq!(hull.data().leave_task, 0); + assert!(summon(&server, &new_owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + tokio::time::advance(Duration::from_secs(2)).await; + tokio::task::yield_now().await; + assert_eq!(roots(&server, 1)[0].obj_id, hull.obj_id); + // A late disconnect callback from the old connection cannot schedule the new session's hull. + super::super::on_disconnect(&server, &owner); + assert_eq!(hull.data().leave_task, 0); +} + +#[tokio::test] +async fn a_root_in_another_world_still_blocks_a_loaded_replacement() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let hull = root(&server, &owner, item_id, MERCHANT); + let rack = loaded_rack(&server, &hull); + let old_world = server.world.world(0).unwrap(); + let template = Arc::new(WorldTemplate::synthetic(1, "other_world", 2, 2, TEST_ZONE)); + let other_world = server.world.create_world_instance(template, 1); + old_world.delete(&owner); + owner.data().unit.transform.instance_id = 1; + other_world.spawn(&owner, &server.view_ctx()); + assert!(summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .is_none()); + assert!(other_world + .all_of_kind(crate::world::ObjectKind::Slave) + .is_empty()); + assert!(old_world.slave(hull.obj_id).is_some()); + { + let mut rack = rack.data(); + rack.item_id = 0; + rack.item_template_id = 0; + } + install_memory_loader(&server); + let replacement = summon(&server, &owner, item_id, MERCHANT_ITEM) + .await + .unwrap(); + assert_eq!(persistent_id(&replacement), persistent_id(&hull)); + assert!(old_world.slave(hull.obj_id).is_none()); + assert!(other_world.slave(replacement.obj_id).is_some()); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test(start_paused = true)] +async fn offline_hull_remains_for_600_seconds_then_uses_delayed_portal_removal() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let hull = root(&server, &owner, item_id, MERCHANT); + super::super::on_disconnect(&server, &owner); + tokio::task::yield_now().await; + tokio::time::advance(Duration::from_secs(599)).await; + assert_eq!(roots(&server, 1)[0].obj_id, hull.obj_id); + tokio::time::advance(Duration::from_secs(1)).await; + tokio::task::yield_now().await; + assert!(roots(&server, 1).is_empty()); + assert!( + hull.core().is_visible(), + "portal rendering survives authoritative removal" + ); + let spawns = server.systems.npcs.spawns.get(0).unwrap(); + crate::systems::npcs::spawn_manager::advance_test_clock(Duration::from_secs(3)); + spawns.check_respawns_tick(&server); + assert!(!hull.core().is_visible()); +} + +#[tokio::test(start_paused = true)] +async fn old_disconnect_timer_cannot_delete_another_hull_reusing_the_object_id() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, MERCHANT_ITEM); + let old_hull = root(&server, &owner, item_id, MERCHANT); + super::super::on_disconnect(&server, &owner); + tokio::task::yield_now().await; + let world = server.world.world(0).unwrap(); + world.delete(&old_hull); + // Model a later allocation after the old object's portal/death timer released its id. + let mut data = crate::models::slave::Slave::new(900, MERCHANT); + data.summoner_id = 1; + data.summoner_obj_id = PA; + data.owner_obj_id = PA; + data.summoning_item_id = 0xbeef; + data.unit.hp = 1; + data.unit.transform.set_xyz(100.0, 100.0, 100.0); + let replacement = Entity::new(old_hull.obj_id, data); + world.spawn(&replacement, &server.view_ctx()); + tokio::time::advance(Duration::from_secs(600)).await; + tokio::task::yield_now().await; + assert!(Arc::ptr_eq( + &world.slave(replacement.obj_id).unwrap(), + &replacement + )); +} + +#[tokio::test] +async fn failed_lookup_releases_reservations_without_changing_the_prior_hull() { + let server = server_with(identity_data()); + let client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let hull = root(&server, &owner, item_id, SHIP_HULL); + *server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .unwrap() = Some(slaves::TestSlaveLoader(Arc::new(|_, _| { + Box::pin(async { Err(sqlx::Error::Protocol("deliberate failed SELECT".into())) }) + }))); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(roots(&server, 1)[0].obj_id, hull.obj_id); + install_memory_loader(&server); + let retry = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!(persistent_id(&retry), persistent_id(&hull)); + assert_eq!(roots(&server, 1).len(), 1); +} + +#[tokio::test] +#[ignore = "requires private MySQL3317 via AAEMU_TEST_MYSQL; connection-local temporary tables only"] +async fn private_mysql_ship_save_fence_query_failure_retry_and_restart() { + use sqlx::mysql::MySqlConnectOptions; + use std::str::FromStr; + + let options = + MySqlConnectOptions::from_str(&std::env::var("AAEMU_TEST_MYSQL").unwrap()).unwrap(); + assert_eq!(options.get_port(), 3317); + assert!(matches!(options.get_host(), "127.0.0.1" | "localhost")); + let pool = MySqlPoolOptions::new() + .max_connections(1) + .connect_with(options) + .await + .unwrap(); + let mut slave_ddl = String::new(); + for table in ["slaves", "doodads"] { + let (_, ddl): (String, String) = sqlx::query_as(&format!("SHOW CREATE TABLE `{table}`")) + .fetch_one(&pool) + .await + .unwrap(); + let ddl = ddl.replacen("CREATE TABLE", "CREATE TEMPORARY TABLE", 1); + if table == "slaves" { + slave_ddl = ddl; + sqlx::query("CREATE TEMPORARY TABLE slaves (id INT UNSIGNED PRIMARY KEY)") + .execute(&pool) + .await + .unwrap(); + } else { + sqlx::query(&ddl).execute(&pool).await.unwrap(); + } + } + let make_server = || { + let mut data = identity_data(); + data.systems + .vehicles + .attach_points + .get_mut(&511) + .unwrap() + .push((60, WorldSpawnPosition::default())); + data.systems + .vehicles + .slave_templates + .get_mut(&SHIP_HULL) + .unwrap() + .doodad_bindings + .push(super::super::data::SlaveDoodadBinding { + id: 1, + owner_id: SHIP_HULL, + owner_type: "Slave".into(), + attach_point_id: 60, + doodad_id: 3446, + persist: true, + scale: 1.0, + }); + let mut server = test_server_with(data); + server.db = pool.clone(); + let server = Arc::new(server); + server.set_self(); + server + }; + let server = make_server(); + let mut client = TestClient::new(&server, 1, 1); + let (owner, item_id) = owner_with_ship(&server, &client, 1, PA, SECOND_SHIP_ITEM); + let before = mates::owned_item(&server, &owner, item_id).unwrap(); + // A genuine SQL error must not become "no row" and allocate/publish a new identity. + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(mates::owned_item(&server, &owner, item_id).unwrap(), before); + assert!(roots(&server, 1).is_empty()); + // No writes/tasks exist yet, so restoring this temporary fixture cannot expose a real table + // to an in-flight writer during the DROP/CREATE interval. + sqlx::query("DROP TEMPORARY TABLE slaves") + .execute(&pool) + .await + .unwrap(); + sqlx::query(&slave_ddl).execute(&pool).await.unwrap(); + let first = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + let db_id = first.data().id; + let second = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!( + second.data().id, + db_id, + "SELECT must observe queued save before replacement" + ); + assert_ne!(second.obj_id, first.obj_id); + assert_eq!(roots(&server, 1).len(), 1); + slaves::delete(&server, Some(&owner), 0, second.obj_id, false); + let third = summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!( + third.data().id, + db_id, + "manual despawn's queued save is fenced too" + ); + let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM slaves WHERE item_id = ?") + .bind(item_id) + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!(count, 1); + let item_before_failed_racks = mates::owned_item(&server, &owner, item_id).unwrap(); + let hull_before_failed_racks = third.data().clone(); + server + .systems + .npcs + .doodads + .persistence + .flush() + .await + .unwrap(); + let rows_before_failed_racks: Vec<(u32, i32, u64)> = + sqlx::query_as("SELECT id, current_phase_id, item_id FROM doodads ORDER BY id") + .fetch_all(&pool) + .await + .unwrap(); + assert_eq!(rows_before_failed_racks.len(), 1); + client.drain(); + // The writer was drained. Fail the persistent SELECT itself: the saved rack must survive + // without a replacement/default persistent row being seeded. + sqlx::query("ALTER TABLE doodads RENAME COLUMN interaction_counts TO unavailable_counts") + .execute(&pool) + .await + .unwrap(); + assert!(summon(&server, &owner, item_id, SECOND_SHIP_ITEM) + .await + .is_none()); + assert_eq!(*third.data(), hull_before_failed_racks); + assert_eq!( + mates::owned_item(&server, &owner, item_id).unwrap(), + item_before_failed_racks + ); + assert!(!ops(&client.drain()).contains(&sc::SCSlaveCreatedPacket)); + let rack_count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM doodads") + .fetch_one(&pool) + .await + .unwrap(); + assert_eq!( + rack_count, 1, + "a failed rack query must not seed default persistent rows" + ); + let rows_after_failed_racks: Vec<(u32, i32, u64)> = + sqlx::query_as("SELECT id, current_phase_id, item_id FROM doodads ORDER BY id") + .fetch_all(&pool) + .await + .unwrap(); + assert_eq!(rows_after_failed_racks, rows_before_failed_racks); + sqlx::query("ALTER TABLE doodads RENAME COLUMN unavailable_counts TO interaction_counts") + .execute(&pool) + .await + .unwrap(); + { + let _transaction = server.save.transaction_lock().await; + let mut tx = pool.begin().await.unwrap(); + slaves::save_all(&server, &mut tx).await.unwrap(); + tx.commit().await.unwrap(); + } + // Keep unknown legacy duplicates intact. The actual item's saved id wins the lookup, + // while the fresh server still admits only one live root for that item. + let mut legacy_duplicate = slaves::snapshot(&server, &third)[0].clone(); + legacy_duplicate.id = db_id + 10_000; + slaves::write_row(&mut pool.acquire().await.unwrap(), &legacy_duplicate) + .await + .unwrap(); + let restart = make_server(); + let restarted_client = TestClient::new(&restart, 2, 1); + let mut character = owner.data().clone(); + character.unit.transform.parent_obj_id = 0; + let restarted_owner = spawn_player(&restart, &restarted_client, character, PA); + let bag = restarted_owner.data().inventory.bag().clone(); + restart.items.add_container(bag); + let restored = summon(&restart, &restarted_owner, item_id, SECOND_SHIP_ITEM) + .await + .unwrap(); + assert_eq!(restored.data().id, db_id); + assert_eq!(roots(&restart, 1).len(), 1); + pool.close().await; +} diff --git a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs index af828d279e..d2828bb3d1 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/slaves.rs @@ -4,7 +4,8 @@ //! //! Locking: one object data lock at a time; world calls never hold a data lock. -use std::sync::{Arc, Mutex}; +use std::collections::HashMap; +use std::sync::{Arc, Mutex, Weak}; use dashmap::DashMap; use rand::Rng; @@ -14,7 +15,7 @@ use crate::data::world_templates::WorldSpawnPosition; use crate::models::container::{slot_type, ContainerRef}; use crate::models::doodad::doodad_owner_type; use crate::models::item::{Item, ItemClass}; -use crate::models::item_task::task_type; +use crate::models::item_task::{task_type, ItemTask}; use crate::models::slave::Slave; use crate::models::transform::Transform; use crate::models::unit::{BaseUnitType, Bonus}; @@ -65,6 +66,180 @@ pub mod buff { const BASE_WATER_DENSITY: f32 = 1.025; const SHIP_WATER_DENSITY_MUL: f32 = 3.0; +#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)] +enum SummonKey { + Owner(u32), + Item(u64), +} + +/// Owner/item guards survive database awaits; the separate synchronous gate orders hull +/// publication with departure. No object lock or synchronous guard crosses an await. +#[derive(Debug, Default)] +pub(crate) struct SlaveSummons { + pub(super) diagnostics: super::audit::Diagnostics, + reservations: Mutex>>>, + pub(super) departing: Mutex>, + /// Serializes complete synchronous hull publication/removal, including nested callbacks. + pub(super) publication_gate: spawn_manager::ReentrantLock, + pending_saves: Mutex>>>, + #[cfg(test)] + pub(crate) test_loader: Mutex>, + #[cfg(test)] + pub(crate) test_after_item_validation: Mutex>, +} + +#[cfg(test)] +type TestSlaveLoad = + dyn Fn(u32, u64) -> futures::future::BoxFuture<'static, sqlx::Result> + Send + Sync; + +#[cfg(test)] +#[derive(Clone)] +pub(crate) struct TestSlaveLoader(pub Arc); + +#[cfg(test)] +impl std::fmt::Debug for TestSlaveLoader { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("TestSlaveLoader") + } +} + +#[cfg(test)] +#[derive(Clone)] +pub(crate) struct TestPublicationHook(pub Arc); + +#[cfg(test)] +impl std::fmt::Debug for TestPublicationHook { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str("TestPublicationHook") + } +} + +impl SlaveSummons { + /// Observe the actual reservation table; never acquire or create an authority reservation. + pub(super) fn audit_identity(&self, owner: u32, item: u64) -> serde_json::Value { + let reservations = self + .reservations + .lock() + .expect("slave reservations poisoned"); + let mut rows = Vec::new(); + for (key, weak) in reservations.iter() { + let matches = match key { + SummonKey::Owner(id) => *id == owner, + SummonKey::Item(id) => *id == item, + }; + if !matches { + continue; + } + if let Some(lock) = weak.upgrade() { + rows.push(serde_json::json!({"key": match key { SummonKey::Owner(_) => "owner", SummonKey::Item(_) => "item" }, "held_sample": lock.try_lock().is_err()})); + } + } + rows.sort_by_key(|r| r["key"].as_str().unwrap_or_default().to_owned()); + drop(reservations); + let saves = self.pending_saves.lock().expect("slave saves poisoned"); + let pending: Vec<_> = saves.iter().filter(|(id, rows)| **id == item || rows.iter().any(|r| r.summoner == owner)).map(|(id, rows)| serde_json::json!({"item": id, "rows": rows.iter().map(|r| serde_json::json!({"db_id": r.id, "item": r.item_id, "summoner": r.summoner, "owner_id": r.owner_id, "owner_type": r.owner_type, "attach": r.attach_point, "template": r.template_id})).collect::>()})).collect(); + serde_json::json!({"reservations_sample": rows, + "departing_connection": self.departing.lock().expect("slave departures poisoned").get(&owner).copied(), + "pending_hull_saves": pending}) + } + + pub(crate) fn publication_scope(&self) -> spawn_manager::ReentrantGuard<'_> { + self.publication_gate.lock() + } + + fn reservation(&self, key: SummonKey) -> Arc> { + let mut locks = self + .reservations + .lock() + .expect("slave reservations poisoned"); + locks.retain(|_, lock| lock.strong_count() != 0); + if let Some(lock) = locks.get(&key).and_then(Weak::upgrade) { + return lock; + } + let lock = Arc::new(tokio::sync::Mutex::new(())); + locks.insert(key, Arc::downgrade(&lock)); + lock + } + + fn publication<'a>( + &'a self, + server: &GameServer, + player: &PlayerRef, + ) -> Option> { + let publication = self.publication_gate.lock(); + let state = self.departing.lock().expect("slave departures poisoned"); + if state.get(&player.character_id) == Some(&player.conn.id) + || !current_session(server, player) + { + return None; + } + Some(publication) + } + + pub(super) fn departure<'a>( + &'a self, + server: &GameServer, + player: &PlayerRef, + ) -> Option> { + let publication = self.publication_gate.lock(); + let mut state = self.departing.lock().expect("slave departures poisoned"); + if !current_session(server, player) + || state.get(&player.character_id) == Some(&player.conn.id) + { + return None; + } + state.insert(player.character_id, player.conn.id); + Some(publication) + } + + pub(super) fn reconnect(&self, server: &GameServer, player: &PlayerRef) { + let _items = server.systems.economy.operation_scope(); + let _publication = self.publication_gate.lock(); + let mut state = self.departing.lock().expect("slave departures poisoned"); + if !current_session(server, player) { + return; + } + state.remove(&player.character_id); + drop(state); + for (world, root) in owned_roots(server, player.character_id) { + let (children, doodads) = { + let mut d = root.data(); + d.leave_task = 0; + d.summoner_obj_id = player.obj_id; + d.owner_obj_id = player.obj_id; + (d.attached_slaves.clone(), d.attached_doodads.clone()) + }; + for child in children { + if let Some(child) = world.slave(child) { + child.data().summoner_obj_id = player.obj_id; + } + } + for doodad in doodads { + if let Some(doodad) = world.doodad(doodad) { + doodad.data().owner_obj_id = player.obj_id; + } + } + } + } + + fn queue_save(&self, server: &GameServer, slave: &SlaveRef) -> Arc> { + // Capture and enqueue in one order, so an older snapshot cannot overwrite a newer one. + let mut pending = self.pending_saves.lock().expect("slave saves poisoned"); + let rows = Arc::new(snapshot(server, slave)); + if let Some(row) = rows.first().filter(|row| row.item_id != 0) { + pending.insert(row.item_id, rows.clone()); + } + rows + } +} + +fn current_session(server: &GameServer, player: &PlayerRef) -> bool { + server + .world + .character_by_obj_id(player.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, player)) +} + // --------------------------------------------------------------------------------------------- // SlaveSpawner // --------------------------------------------------------------------------------------------- @@ -246,7 +421,46 @@ pub fn all_slaves(world: &WorldInstance) -> Vec { pub fn get_active_slave_by_owner_obj_id(world: &WorldInstance, obj_id: u32) -> Option { all_slaves(world).into_iter().find(|s| { let d = s.data(); - d.summoner_obj_id != 0 && d.summoner_obj_id == obj_id && !d.unit.is_dead() + d.owner_type == BaseUnitType::Character + && d.summoner_obj_id != 0 + && d.summoner_obj_id == obj_id + && !d.unit.is_dead() + }) +} + +/// Persistent owner identity, across instances. Cannon children share the summoner but are +/// owned by a slave, so they must never stand in for a summoned root. +pub(super) fn owned_roots( + server: &GameServer, + owner_id: u32, +) -> Vec<(Arc, SlaveRef)> { + server + .world + .worlds() + .into_iter() + .flat_map(|world| { + all_slaves(&world) + .into_iter() + .filter(|slave| { + let d = slave.data(); + d.owner_type == BaseUnitType::Character + && d.summoner_id == owner_id + && !d.unit.is_dead() + }) + .map(move |slave| (world.clone(), slave)) + }) + .collect() +} + +pub(super) fn item_has_other_live_root(server: &GameServer, item_id: u64, owner_id: u32) -> bool { + server.world.worlds().into_iter().any(|world| { + all_slaves(&world).into_iter().any(|slave| { + let d = slave.data(); + d.owner_type == BaseUnitType::Character + && !d.unit.is_dead() + && d.summoning_item_id == item_id + && d.summoner_id != owner_id + }) }) } @@ -1358,6 +1572,35 @@ fn spawn_manager_of( server.systems.npcs.spawns.get(world_id) } +fn audit_retirement(server: &GameServer, world: &WorldInstance, root: &SlaveRef) { + let diagnostics = &server.systems.vehicles.slave_summons.diagnostics; + if !world + .slave(root.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, root)) + { + // Numeric cached children cannot identify this lifetime after the hull ID was reused. + diagnostics.retiring(world.id, root, &[]); + return; + } + let (children, doodads) = { + let d = root.data(); + (d.attached_slaves.clone(), d.attached_doodads.clone()) + }; + let doodads: Vec<_> = doodads + .into_iter() + .filter_map(|id| world.doodad(id)) + .filter(|rack| super::audit::rack_parent_matches(&rack.data(), world.id, root.obj_id)) + .collect(); + diagnostics.retiring(world.id, root, &doodads); + for child in children.into_iter().filter_map(|id| world.slave(id)) { + diagnostics.retiring(world.id, &child, &[]); + } +} + +#[cfg(test)] +#[path = "audit_tests.rs"] +mod audit_tests; + /// `Delete(owner, objId, ignoreAttachedItemWarning)`. pub fn delete( server: &GameServer, @@ -1366,15 +1609,69 @@ pub fn delete( obj_id: u32, ignore_attached_item_warning: bool, ) { + try_delete( + server, + owner, + instance_id, + obj_id, + ignore_attached_item_warning, + ); +} + +fn can_delete( + world: &WorldInstance, + slave: &SlaveRef, + owner: Option<&PlayerRef>, + ignore_attached_item_warning: bool, +) -> bool { + if owner.is_some_and(|player| slave.data().summoner_id != player.character_id) { + return false; + } + if !ignore_attached_item_warning { + let doodads = slave.data().attached_doodads.clone(); + for id in doodads { + if let Some(doodad) = world.doodad(id) { + let loaded = { + let d = doodad.data(); + d.item_id != 0 || d.item_template_id != 0 + }; + if loaded { + if let Some(owner) = owner { + error(owner, error::SLAVE_EQUIPMENT_LOADED_ITEM); + } + return false; + } + } + } + } + true +} + +/// Refusal is checked before saves, rider/gunner detachment, physics or success packets. +fn try_delete( + server: &GameServer, + owner: Option<&PlayerRef>, + instance_id: u32, + obj_id: u32, + ignore_attached_item_warning: bool, +) -> bool { + let _items = server.systems.economy.operation_scope(); + let _publication = server + .systems + .vehicles + .slave_summons + .publication_gate + .lock(); let Some(world) = server.world.world(instance_id) else { - return; + return false; }; let Some(slave) = world.slave(obj_id) else { - return; + return false; }; - if owner.is_some_and(|player| slave.data().summoner_obj_id != player.obj_id) { - return; + if !can_delete(&world, &slave, owner, ignore_attached_item_warning) { + return false; } + audit_retirement(server, &world, &slave); save(server, &slave); let (attached_chars, tl) = { let d = slave.data(); @@ -1401,22 +1698,6 @@ pub fn delete( d.unit.template_id, ) }; - if !ignore_attached_item_warning { - for id in &doodad_ids { - if let Some(d) = world.doodad(*id) { - let (item, tpl) = { - let d = d.data(); - (d.item_id, d.item_template_id) - }; - if item != 0 || tpl != 0 { - if let Some(o) = owner { - error(o, error::SLAVE_EQUIPMENT_LOADED_ITEM); - } - return; - } - } - } - } let now = spawn_manager::now(); let despawn_delayed = spawn_manager::add_secs(now, f64::from(portal_time - 0.5)); // slaveInfo.Transform.DetachAll() @@ -1465,6 +1746,7 @@ pub fn delete( ); } let _ = template_id; + true } /// `DestroyAndSpawnSlave` (special effect 72; row 8224 is the only row, on skill 19165 "destroy @@ -1543,13 +1825,13 @@ pub fn remove_and_despawn_all_active_owned_slaves( owner: &PlayerRef, force: bool, ) { - if let Some(world) = player_world(server, owner) { - if let Some(active) = get_active_slave_by_owner_obj_id(&world, owner.obj_id) { - save(server, &active); - delete(server, Some(owner), world.id, active.obj_id, force); - } + let mut removed = true; + for (world, active) in owned_roots(server, owner.character_id) { + removed &= try_delete(server, Some(owner), world.id, active.obj_id, force); + } + if removed { + clear_slave_attachment_state(server, owner); } - clear_slave_attachment_state(server, owner); } /// `RidersEscape(player, positionTarget)`. @@ -1641,6 +1923,27 @@ pub struct SavedChildSlave { pub mp: i32, } +#[derive(Debug, Default)] +pub(crate) struct LoadedHull { + pub(crate) saved: Option, + pub(crate) children: Vec, + pub(crate) doodads: spawn_manager::PersistentDoodads, +} + +fn owned_summon_item( + server: &GameServer, + owner: &PlayerRef, + item_id: u64, + item_template_id: u32, +) -> Option { + let item = super::mates::owned_item(server, owner, item_id)?; + (item.owner_id == u64::from(owner.character_id) + && item.slot_type == slot_type::INVENTORY + && item.class == ItemClass::SummonSlave + && item.template_id == item_template_id) + .then_some(item) +} + /// `SlaveManager.Create(owner, skillData)` (the `SpawnSlave` special effect): runs the async /// creation on a task. `placement` is the `SummonPos` spot the client chose; it is validated /// against the slave's `spawn_valid_area_range` / the skill range before use. @@ -1663,8 +1966,16 @@ pub fn create_from_skill( return; }; let owner = owner.clone(); + // Construct the lease before the detached future exists, so even a never-polled task + // remains pending evidence. The captured lease drops on no runtime, abort and unwind. + let lease = server + .systems + .vehicles + .slave_summons + .diagnostics + .summon(owner.character_id, item_id); let fut = async move { - create_for_owner( + create_for_owner_job( &server, &owner, item_id, @@ -1673,6 +1984,7 @@ pub fn create_from_skill( None, placement, max_range, + lease, ) .await; }; @@ -1708,6 +2020,9 @@ fn validated_summon_placement( None }; let owner_pos = world.world_pos_rot(&WorldObject::from(owner)); + if [p.x, p.y, p.z, p.yaw].iter().any(|v| !v.is_finite()) { + return invalid("non-finite coordinates"); + } // `slaves.spawn_valid_area_range` is the data-side limit (50 m in the 1.2 DB); the skill's // own MaxRange is 0 for the boat summon (15802). Use the smaller nonzero limit. let limit = [max_range, template.spawn_valid_area_range as f32] @@ -1768,7 +2083,37 @@ fn validated_summon_placement( /// `Create(owner, skillData, hideSpawnEffect, positionOverride)`. #[allow(clippy::too_many_arguments)] -pub async fn create_for_owner( +pub fn create_for_owner<'a>( + server: &'a GameServer, + owner: &'a PlayerRef, + item_id: u64, + item_template_id: u32, + hide_spawn_effect: bool, + position_override: Option, + placement: Option, + max_range: f32, +) -> impl std::future::Future> + Send + 'a { + let lease = server + .systems + .vehicles + .slave_summons + .diagnostics + .summon(owner.character_id, item_id); + create_for_owner_job( + server, + owner, + item_id, + item_template_id, + hide_spawn_effect, + position_override, + placement, + max_range, + lease, + ) +} + +#[allow(clippy::too_many_arguments)] +async fn create_for_owner_job( server: &GameServer, owner: &PlayerRef, item_id: u64, @@ -1777,18 +2122,15 @@ pub async fn create_for_owner( position_override: Option, placement: Option, max_range: f32, + lease: super::audit::Lease, ) -> Option { + lease.phase("validating"); let world = player_world(server, owner)?; - if let Some(active) = get_active_slave_by_owner_obj_id(&world, owner.obj_id) { - save(server, &active); - // TODO (C#): If too far away, don't delete - delete(server, Some(owner), world.id, active.obj_id, false); - } if item_id == 0 || item_template_id == 0 { return None; } // skillData.SkillSourceItem = ItemManager.GetItemByItemId(ItemId) - let item = super::mates::owned_item(server, owner, item_id)?; + let item = owned_summon_item(server, owner, item_id, item_template_id)?; let slave_id = match server .game_data .items @@ -1805,11 +2147,13 @@ pub async fn create_for_owner( .slave_template(slave_id)? .clone(); let position_override = if placement.is_some() { - validated_summon_placement(server, &world, owner, &template, placement, max_range) + Some(validated_summon_placement( + server, &world, owner, &template, placement, max_range, + )?) } else { position_override }; - create( + create_with_placement( server, &world, Some(owner), @@ -1817,118 +2161,428 @@ pub async fn create_for_owner( Some(item), hide_spawn_effect, position_override, + placement, + max_range, + &lease, ) .await } /// `Create(owner, null, templateId, item, hideSpawnEffect, positionOverride)` with the DB parts /// (saved slave, its persistent doodads, its saved child slaves). -pub async fn create( +pub fn create<'a>( + server: &'a GameServer, + world: &'a Arc, + owner: Option<&'a PlayerRef>, + template_id: u32, + item: Option, + hide_spawn_effect: bool, + position_override: Option, +) -> impl std::future::Future> + Send + 'a { + let lease = server.systems.vehicles.slave_summons.diagnostics.summon( + owner.map_or(0, |o| o.character_id), + item.as_ref().map_or(0, |i| i.id), + ); + async move { + create_with_placement( + server, + world, + owner, + template_id, + item, + hide_spawn_effect, + position_override, + None, + 0.0, + &lease, + ) + .await + } +} + +#[allow(clippy::too_many_arguments)] +async fn create_with_placement( server: &GameServer, world: &Arc, owner: Option<&PlayerRef>, template_id: u32, item: Option, hide_spawn_effect: bool, - position_override: Option, + mut position_override: Option, + placement: Option, + max_range: f32, + lease: &super::audit::Lease, ) -> Option { server .game_data .systems .vehicles .slave_template(template_id)?; - let owner_id = owner.map_or(0, |o| o.data().id); - let mut saved = None; - if owner_id > 0 { - if let Some(item) = &item { - if item.id > 0 { - saved = load_saved_slave(server, owner_id, item.id).await; + if position_override.is_some_and(|t| { + [t.x, t.y, t.z, t.rot_x, t.rot_y, t.rot_z] + .iter() + .any(|v| !v.is_finite()) + }) { + return None; + } + let summons = &server.systems.vehicles.slave_summons; + let owner_id = owner.map_or(0, |o| o.character_id); + // Acquire in one order. Owned async guards release on all errors and future cancellation. + lease.phase("waiting_owner"); + let _owner_reservation = match owner { + Some(_) => Some( + summons + .reservation(SummonKey::Owner(owner_id)) + .lock_owned() + .await, + ), + None => None, + }; + lease.phase("waiting_item"); + let _item_reservation = match (&item, owner) { + (Some(item), Some(_)) if item.id != 0 => Some( + summons + .reservation(SummonKey::Item(item.id)) + .lock_owned() + .await, + ), + _ => None, + }; + lease.phase("active"); + let mut item = match (item, owner) { + (Some(item), Some(owner)) => { + let item = owned_summon_item(server, owner, item.id, item.template_id)?; + if !matches!(server.game_data.items.template(item.template_id).map(|t| &t.kind), + Some(crate::data::items::TemplateKind::SummonSlave { slave_id }) if *slave_id == template_id) + { + return None; + } + if let Some(left) = repair_seconds_left(&item, chrono::Utc::now().timestamp()) { + owner.send(crate::packets::world::SCErrorMsgPacket::new( + error::SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME, + left as u32, + true, + )); + return None; } + Some(item) } + (item, _) => item, + }; + let prior = if let Some(owner) = owner { + let _publication = summons.publication(server, owner)?; + if player_world(server, owner)?.id != world.id + || item + .as_ref() + .is_some_and(|i| item_has_other_live_root(server, i.id, owner_id)) + { + return None; + } + let prior = owned_roots(server, owner_id); + if prior + .iter() + .any(|(world, slave)| !can_delete(world, slave, Some(owner), false)) + { + return None; + } + for (_, slave) in &prior { + save(server, slave); + } + prior + } else { + Vec::new() + }; + let loaded = if let Some(item) = item.as_ref().filter(|_| owner_id != 0) { + let mut flush_items: Vec<_> = prior + .iter() + .map(|(_, s)| s.data().summoning_item_id) + .collect(); + flush_items.push(item.id); + match load_hull(server, world, owner_id, item, template_id, &flush_items).await { + Ok(loaded) => loaded, + Err(e) => { + tracing::error!("SlaveManager.Create({owner_id}, {}): {e}", item.id); + return None; + } + } + } else { + LoadedHull::default() + }; + if loaded.saved.as_ref().is_some_and(|saved| saved.id == 0) { + tracing::error!("Saved hull has no persistent identity"); + return None; } - let spawned = create_spawn( - server, - world, - owner, - None, - template_id, - item.clone(), - hide_spawn_effect, - position_override, - saved, - )?; - let db_id = spawned.slave.data().id; - if spawned.is_loaded { - // If this was a previously saved slave, load doodads from DB and spawn them - if let Some(sm) = spawn_manager_of(server, world.id) { - match sm - .spawn_persistent_doodads( - server, - doodad_owner_type::SLAVE, - i64::from(db_id), - Some(&WorldObject::from(&spawned.slave)), - true, - ) - .await + for child in &loaded.children { + if child.id == 0 + || server + .game_data + .systems + .vehicles + .slave_template(child.template_id) + .is_none() + { + tracing::error!( + "Saved slave child {} has invalid template {}", + child.id, + child.template_id + ); + return None; + } + } + { + let _items = server.systems.economy.operation_scope(); + let _publication = match owner { + Some(owner) => Some(summons.publication(server, owner)?), + None => None, + }; + if let (Some(owner), Some(current)) = (owner, &item) { + // Inventory and session may have changed during the DB await. + let fresh = owned_summon_item(server, owner, current.id, current.template_id)?; + if player_world(server, owner)?.id != world.id + || item_has_other_live_root(server, fresh.id, owner_id) { - Ok(n) => tracing::debug!( - "Loaded {n} doodads from DB for Slave {} (Db: {db_id}", - spawned.slave.obj_id - ), - Err(e) => tracing::error!("SpawnPersistentDoodads (slave {db_id}): {e}"), + return None; + } + if repair_seconds_left(&fresh, chrono::Utc::now().timestamp()).is_some() { + return None; + } + item = Some(fresh); + } + #[cfg(test)] + { + let hook = summons + .test_after_item_validation + .lock() + .expect("test publication hook poisoned") + .clone(); + if let Some(hook) = hook { + (hook.0)(server); + } + } + if let Some(owner) = owner { + let current = owned_roots(server, owner_id); + if current.len() != prior.len() + || prior.iter().any(|(world, slave)| { + !world + .slave(slave.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, slave)) + || !current.iter().any(|(_, live)| Arc::ptr_eq(live, slave)) + }) + { + return None; + } + if placement.is_some() { + let template = server + .game_data + .systems + .vehicles + .slave_template(template_id)?; + position_override = Some(validated_summon_placement( + server, world, owner, template, placement, max_range, + )?); + } + let prior = owned_roots(server, owner_id); + if prior + .iter() + .any(|(w, s)| !can_delete(w, s, Some(owner), false)) + { + return None; + } + } + if let Some(saved) = &loaded.saved { + let live_hull = prior.iter().map(|(_, hull)| hull).find(|hull| { + let h = hull.data(); + h.id == saved.id + && item + .as_ref() + .is_some_and(|item| h.summoning_item_id == item.id) + }); + if let Err(error) = loaded + .doodads + .validate_slave_cargo(server, saved.id, live_hull) + { + tracing::warn!("SlaveManager.Create cargo preflight: {error}"); + return None; } } + // Commit the actual item update before altering the prior hull. A missing or moved + // source (including an unlocked quest mutation) must fail at this boundary. + let committed = if let (Some(owner), Some(item)) = (owner, &item) { + let new_id = loaded.saved.is_none(); + let db_id = match &loaded.saved { + Some(saved) => saved.id, + None => server.ids.character.get_next_id().ok()?, + }; + match commit_summon_item(server, owner, item, db_id) { + Some(committed) => Some(committed), + None => { + if new_id { + server.ids.character.release_id(db_id); + } + return None; + } + } + } else { + None + }; + if let Some(owner) = owner { + for (w, s) in owned_roots(server, owner_id) { + if !try_delete(server, Some(owner), w.id, s.obj_id, false) { + return None; + } + } + } + let spawned = create_spawn_committed( + server, + world, + owner, + None, + template_id, + item.clone(), + hide_spawn_effect, + position_override, + loaded.saved, + committed, + )?; + if spawned.is_loaded { + let manager = server.systems.npcs.spawns.get_or_create(world); + if let Err(error) = manager.publish_persistent_doodads( + server, + loaded.doodads, + Some(&WorldObject::from(&spawned.slave)), + true, + ) { + tracing::error!("Publish persistent slave doodads: {error}"); + return None; + } + } + if !world + .slave(spawned.slave.obj_id) + .is_some_and(|live| Arc::ptr_eq(&live, &spawned.slave)) + { + return None; + } + finish_create( + server, + world, + owner, + &spawned.slave, + &spawned.template, + item.as_ref(), + spawned.is_loaded, + loaded.children, + ) } - let children = if db_id > 0 { - load_saved_children(server, db_id, owner_id).await - } else { - Vec::new() +} + +async fn load_hull( + server: &GameServer, + world: &Arc, + owner_id: u32, + item: &Item, + template_id: u32, + flush_items: &[u64], +) -> anyhow::Result { + #[cfg(test)] + { + let loader = server + .systems + .vehicles + .slave_summons + .test_loader + .lock() + .expect("test slave loader poisoned") + .clone(); + if let Some(loader) = loader { + let loaded = (loader.0)(owner_id, item.id).await?; + return load_hull_doodads(server, world, loaded).await; + } + } + let _transaction = server.save.transaction_lock().await; + for item_id in flush_items.iter().copied().filter(|id| *id != 0) { + flush_pending_save(server, item_id).await?; + } + server.systems.npcs.doodads.persistence.flush().await?; + let saved = load_saved_slave( + server, + owner_id, + item.id, + item.details.slave_db_id, + template_id, + ) + .await?; + let children = match &saved { + Some(saved) => load_saved_children(server, saved.id, owner_id).await?, + None => Vec::new(), }; - finish_create( + load_hull_doodads( server, world, - owner, - &spawned.slave, - &spawned.template, - item.as_ref(), - spawned.is_loaded, - children, + LoadedHull { + saved, + children, + ..Default::default() + }, ) + .await } -async fn load_saved_slave(server: &GameServer, owner_id: u32, item_id: u64) -> Option { +async fn load_hull_doodads( + server: &GameServer, + world: &Arc, + mut loaded: LoadedHull, +) -> anyhow::Result { + if let Some(saved) = &loaded.saved { + loaded.doodads = server + .systems + .npcs + .spawns + .get_or_create(world) + .fetch_persistent_doodads(server, doodad_owner_type::SLAVE, i64::from(saved.id)) + .await?; + } + Ok(loaded) +} + +async fn load_saved_slave( + server: &GameServer, + owner_id: u32, + item_id: u64, + preferred_id: u32, + template_id: u32, +) -> sqlx::Result> { let r = sqlx::query( - "SELECT CAST(id AS UNSIGNED) AS id, name, CAST(hp AS SIGNED) AS hp, CAST(mp AS SIGNED) AS mp \ - FROM slaves WHERE (owner_type = 0) AND (owner_id = ?) AND (summoner = ?) AND (item_id = ?) LIMIT 1", + "SELECT CAST(id AS UNSIGNED) AS id, CAST(template_id AS UNSIGNED) AS template_id, name, CAST(hp AS SIGNED) AS hp, CAST(mp AS SIGNED) AS mp \ + FROM slaves WHERE (owner_type = 0) AND (owner_id = ?) AND (summoner = ?) AND (item_id = ?) \ + ORDER BY (id = ?) DESC, id LIMIT 1", ) .bind(owner_id) .bind(owner_id) .bind(item_id) + .bind(preferred_id) .fetch_optional(&server.db) - .await; - match r { - Ok(Some(r)) => Some(SavedSlave { - id: r.try_get::("id").ok()? as u32, - name: r - .try_get::, _>("name") - .ok()? - .unwrap_or_default(), - hp: r.try_get::, _>("hp").ok()?.unwrap_or(0) as i32, - mp: r.try_get::, _>("mp").ok()?.unwrap_or(0) as i32, - }), - Ok(None) => None, - Err(e) => { - tracing::error!("load saved slave: {e}"); - None + .await?; + r.map(|r| { + if r.try_get::, _>("template_id")? != Some(u64::from(template_id)) { + return Err(sqlx::Error::Protocol( + "saved hull does not match its summon item template".into(), + )); } - } + Ok(SavedSlave { + id: r.try_get::("id")? as u32, + name: r.try_get::, _>("name")?.unwrap_or_default(), + hp: r.try_get::, _>("hp")?.unwrap_or(0) as i32, + mp: r.try_get::, _>("mp")?.unwrap_or(0) as i32, + }) + }) + .transpose() } async fn load_saved_children( server: &GameServer, parent_db_id: u32, summoner_id: u32, -) -> Vec { +) -> sqlx::Result> { let rows = sqlx::query( "SELECT CAST(id AS UNSIGNED) AS id, CAST(template_id AS UNSIGNED) AS template_id, \ CAST(attach_point AS SIGNED) AS attach_point, name, CAST(hp AS SIGNED) AS hp, \ @@ -1937,35 +2591,19 @@ async fn load_saved_children( .bind(parent_db_id) .bind(summoner_id) .fetch_all(&server.db) - .await; - match rows { - Ok(rows) => rows - .into_iter() - .filter_map(|r| { - Some(SavedChildSlave { - id: r.try_get::("id").ok()? as u32, - template_id: r - .try_get::, _>("template_id") - .ok()? - .unwrap_or(0) as u32, - attach_point: r - .try_get::, _>("attach_point") - .ok()? - .unwrap_or(0) as u8, - name: r - .try_get::, _>("name") - .ok()? - .unwrap_or_default(), - hp: r.try_get::, _>("hp").ok()?.unwrap_or(0) as i32, - mp: r.try_get::, _>("mp").ok()?.unwrap_or(0) as i32, - }) + .await?; + rows.into_iter() + .map(|r| { + Ok(SavedChildSlave { + id: r.try_get::("id")? as u32, + template_id: r.try_get::, _>("template_id")?.unwrap_or(0) as u32, + attach_point: r.try_get::, _>("attach_point")?.unwrap_or(0) as u8, + name: r.try_get::, _>("name")?.unwrap_or_default(), + hp: r.try_get::, _>("hp")?.unwrap_or(0) as i32, + mp: r.try_get::, _>("mp")?.unwrap_or(0) as i32, }) - .collect(), - Err(e) => { - tracing::error!("load saved child slaves: {e}"); - Vec::new() - } - } + }) + .collect() } /// `ApplySlaveBonuses(summonedSlave)`. @@ -2091,6 +2729,52 @@ fn repair_seconds_left(item: &Item, now: i64) -> Option { (left > 0).then_some(left) } +struct CommittedSummonItem { + db_id: u32, + task: ItemTask, +} + +fn commit_summon_item( + server: &GameServer, + owner: &PlayerRef, + source: &Item, + db_id: u32, +) -> Option { + let result = { + let _ops = server.systems.economy.ops_lock(); + super::mates::update_owned_item(server, Some(owner), source.id, |item| { + if item.id != source.id + || item.template_id != source.template_id + || item.owner_id != u64::from(owner.character_id) + || item.class != ItemClass::SummonSlave + || item.slot_type != slot_type::INVENTORY + { + return Err(None); + } + if let Some(left) = repair_seconds_left(item, chrono::Utc::now().timestamp()) { + return Err(Some(left)); + } + item.details.slave_type = 0x02; + item.details.slave_db_id = db_id; + item.details.slave_repair_start_time = 0; + item.dirty = true; + Ok(super::packets::item_update(item)) + }) + }; + match result { + Some(Ok(task)) => Some(CommittedSummonItem { db_id, task }), + Some(Err(Some(left))) => { + owner.send(crate::packets::world::SCErrorMsgPacket::new( + error::SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME, + left as u32, + true, + )); + None + } + Some(Err(None)) | None => None, + } +} + /// The first half of `Create`: template, position, summon item checks, `SCSlaveCreatedPacket`, /// the slave itself (bonuses, HP / MP, initial items) and `Spawn()`. `saved` is the /// `load_saved_slave` row (owner + item only). @@ -2105,6 +2789,33 @@ pub(crate) fn create_spawn( hide_spawn_effect: bool, position_override: Option, saved: Option, +) -> Option { + create_spawn_committed( + server, + world, + owner, + spawner, + template_id, + item, + hide_spawn_effect, + position_override, + saved, + None, + ) +} + +#[allow(clippy::too_many_arguments)] +fn create_spawn_committed( + server: &GameServer, + world: &Arc, + owner: Option<&PlayerRef>, + spawner: Option<&Arc>, + template_id: u32, + item: Option, + hide_spawn_effect: bool, + position_override: Option, + saved: Option, + committed: Option, ) -> Option { let data = &server.game_data.systems.vehicles; let template = data @@ -2251,44 +2962,25 @@ pub(crate) fn create_spawn( spawn_pos.rot_z = yaw; } + if let Some(committed) = &committed { + db_id = committed.db_id; + } // Get new Id to save if it has a player as owner if owner_id > 0 && db_id == 0 { db_id = server.ids.character.get_next_id().ok()?; } - // Update the summoning item - if let (Some(it), Some(o)) = (&item, owner) { - if it.class == ItemClass::SummonSlave { - let now = chrono::Utc::now().timestamp(); - let res = super::mates::update_owned_item(server, Some(o), it.id, |i| { - i.details.slave_type = 0x02; - i.details.slave_db_id = db_id; - if let Some(left) = repair_seconds_left(i, now) { - return Err(left as f64); - } - // SummonLocation (not part of the 1.2 detail bytes); RepairStartTime = MinValue - i.details.slave_repair_start_time = 0; - i.dirty = true; - Ok(super::packets::item_update(i)) - }); - match res { - Some(Err(left)) => { - // Slave was destroyed and is on cooldown - o.send(crate::packets::world::SCErrorMsgPacket::new( - error::SLAVE_SPAWN_ERROR_NEED_REPAIR_TIME, - left.round_ties_even() as u32, - true, - )); - return None; - } - Some(Ok(task)) => o.send(SCItemTaskSuccessPacket { - action: item_task_type::UPDATE_SUMMON_MATE_ITEM, - tasks: vec![task], - force_remove: Vec::new(), - }), - None => {} - } - } + let committed = match (committed, &item, owner) { + (Some(committed), _, _) => Some(committed), + (None, Some(item), Some(owner)) => Some(commit_summon_item(server, owner, item, db_id)?), + _ => None, + }; + if let (Some(committed), Some(owner)) = (committed, owner) { + owner.send(SCItemTaskSuccessPacket { + action: item_task_type::UPDATE_SUMMON_MATE_ITEM, + tasks: vec![committed.task], + force_remove: Vec::new(), + }); } // Create the Slave (packet) @@ -2934,7 +3626,12 @@ pub fn do_die( killer: Option<&WorldObject>, kill_reason: KillReason, ) { + let _items = server.systems.economy.operation_scope(); + let _publication = server.systems.vehicles.slave_summons.publication_scope(); let obj = WorldObject::from(slave); + if let Some(world) = server.world.world_of(&obj) { + audit_retirement(server, &world, slave); + } crate::systems::skills::skill::interrupt_skills(server, &obj); crate::systems::skills::buffs::fire_unit_event( server, @@ -3239,6 +3936,9 @@ pub fn send_my_slave_packet_to_all_owners(server: &GameServer) { let obj = WorldObject::from(&slave); let (summoner, p) = { let d = slave.data(); + if d.owner_type != BaseUnitType::Character { + continue; + } ( d.summoner_obj_id, ( @@ -3368,23 +4068,22 @@ pub fn save(server: &GameServer, slave: &SlaveRef) { if slave.data().summoning_item_id == 0 { return; } - let rows = snapshot(server, slave); + let rows = server + .systems + .vehicles + .slave_summons + .queue_save(server, slave); if rows.is_empty() { return; } - let db = server.db.clone(); + let item_id = rows[0].item_id; + let Some(server) = server.self_arc() else { + return; + }; let fut = async move { - let mut conn = match db.acquire().await { - Ok(c) => c, - Err(e) => { - tracing::error!("Slave.Save: {e}"); - return; - } - }; - for r in &rows { - if let Err(e) = write_row(&mut conn, r).await { - tracing::error!("Slave.Save: {e}"); - } + let _transaction = server.save.transaction_lock().await; + if let Err(e) = flush_pending_save(&server, item_id).await { + tracing::error!("Slave.Save: {e}"); } }; if let Ok(rt) = tokio::runtime::Handle::try_current() { @@ -3392,6 +4091,38 @@ pub fn save(server: &GameServer, slave: &SlaveRef) { } } +/// Caller owns SaveManager's transaction lock. A failed write stays queued for retry; a +/// later summon must flush it before SELECT, never interpret an unfinished save as absence. +async fn flush_pending_save(server: &GameServer, item_id: u64) -> sqlx::Result<()> { + let pending = &server.systems.vehicles.slave_summons.pending_saves; + loop { + let rows = pending + .lock() + .expect("slave saves poisoned") + .get(&item_id) + .cloned(); + let Some(rows) = rows else { return Ok(()) }; + let mut tx = server.db.begin().await?; + for row in rows.iter() { + write_row(&mut tx, row).await?; + } + tx.commit().await?; + let flushed = { + let mut pending = pending.lock().expect("slave saves poisoned"); + let current = pending + .get(&item_id) + .is_some_and(|current| Arc::ptr_eq(current, &rows)); + if current { + pending.remove(&item_id); + } + current + }; + if flushed { + return Ok(()); + } + } +} + /// The `SaveManager.DoSave` slave part: `slave.Save(connection, transaction)` for every slave /// of every world (children are written again by their parent, as in C#). Returns the number /// of slaves saved. @@ -3402,7 +4133,11 @@ pub async fn save_all( let mut n = 0; for world in server.world.worlds() { for slave in all_slaves(&world) { - let rows = snapshot(server, &slave); + let rows = server + .systems + .vehicles + .slave_summons + .queue_save(server, &slave); if rows.is_empty() { continue; } @@ -3433,15 +4168,23 @@ pub async fn on_delete_slave_item( if slave_db_id == 0 { return false; } - if let Some(world) = player_world(server, owner) { - if let Some(s) = get_slave_by_db_id(&world, slave_db_id) { - let summoner = s.data().summoner_obj_id; - if let Some(p) = server.world.character_by_obj_id(summoner) { - let tl = s.data().unit.tl_id; - remove_active_slave(server, &p, tl, true); - } + let summons = &server.systems.vehicles.slave_summons; + let _owner = summons + .reservation(SummonKey::Owner(owner.character_id)) + .lock_owned() + .await; + for (world, slave) in owned_roots(server, owner.character_id) { + if slave.data().id == slave_db_id { + delete(server, Some(owner), world.id, slave.obj_id, true); } } + // Queued fire-and-forget saves must not resurrect the row after item destruction. + let _transaction = server.save.transaction_lock().await; + summons + .pending_saves + .lock() + .expect("slave saves poisoned") + .retain(|_, rows| rows.first().is_none_or(|row| row.id != slave_db_id)); let mut conn = match server.db.acquire().await { Ok(c) => c, Err(e) => { diff --git a/rust/crates/aaemu-game/src/systems/vehicles/stats.rs b/rust/crates/aaemu-game/src/systems/vehicles/stats.rs index f8a0afccd2..8301c78429 100644 --- a/rust/crates/aaemu-game/src/systems/vehicles/stats.rs +++ b/rust/crates/aaemu-game/src/systems/vehicles/stats.rs @@ -7,10 +7,11 @@ use std::collections::HashMap; +use crate::data::attribute_limits::UnitAttributeLimits; use crate::data::formulas::{FormulaOwnerType, UnitFormulaKind, UnitFormulaVariableType}; use crate::models::unit::{UnitAttribute, UnitBase, UnitModifierType}; use crate::server::GameServer; -use crate::systems::skills::stats::{base_unit_stat, StatKind}; +use crate::systems::skills::stats::{base_unit_stat_with_limits, StatKind}; use crate::world::WorldObject; /// Which getter set a unit kind uses. @@ -37,19 +38,27 @@ impl VehicleKind { } /// `foreach (var bonus in GetBonuses(attr))` on an `int` result. -fn int_bonuses(u: &UnitBase, mut res: i32, attr: UnitAttribute) -> i32 { +fn int_bonuses(u: &UnitBase, limits: &UnitAttributeLimits, res: i32, attr: UnitAttribute) -> i32 { + // Keep the int getter's per-bonus truncation, widening before a large stack + // can overflow. Only the complete raw attribute receives its data bound. + let mut res = f64::from(res); for b in u.bonuses.bonuses(attr) { if b.template.modifier_type == UnitModifierType::Percent { - res += (res as f32 * b.value as f32 / 100.0) as i32; + res += f64::from((res as f32 * b.value as f32 / 100.0).trunc()); } else { - res += b.value; + res += f64::from(b.value); } } - res + limits.clamp(attr, res) as i32 } /// `foreach (var bonus in GetBonuses(attr))` on a `double` result. -fn float_bonuses(u: &UnitBase, mut res: f64, attr: UnitAttribute) -> f64 { +fn float_bonuses( + u: &UnitBase, + limits: &UnitAttributeLimits, + mut res: f64, + attr: UnitAttribute, +) -> f64 { for b in u.bonuses.bonuses(attr) { if b.template.modifier_type == UnitModifierType::Percent { res += res * f64::from(b.value as f32 / 100.0); @@ -57,7 +66,7 @@ fn float_bonuses(u: &UnitBase, mut res: f64, attr: UnitAttribute) -> f64 { res += f64::from(b.value); } } - res + limits.clamp(attr, res) } struct Eval<'a> { @@ -86,7 +95,12 @@ impl Eval<'_> { fn base_attr(&self, kind: UnitFormulaKind, attr: UnitAttribute) -> i32 { let p = HashMap::from([("level", self.level())]); - int_bonuses(self.u, self.formula(kind, &p) as i32, attr) + int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + self.formula(kind, &p) as i32, + attr, + ) } fn str_(&self) -> i32 { @@ -171,30 +185,51 @@ impl Eval<'_> { let res = self.formula(K::MaxHealth, &self.pool_params(true, K::MaxHealth)) as i32; if mate { // `CalculateWithBonuses(res, MaxHealth)` - f64::from( - self.u - .calculate_with_bonuses(f64::from(res), A::MaxHealth, self.now) - as i32, - ) + f64::from(self.u.bonuses.calculate_with_limits( + f64::from(res), + A::MaxHealth, + self.now, + &self.server.game_data.characters.unit_attribute_limits, + ) as i32) } else { - f64::from(int_bonuses(self.u, res, A::MaxHealth)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::MaxHealth, + )) } } S::MaxMp => { let res = self.formula(K::MaxMana, &self.pool_params(true, K::MaxMana)) as i32; - f64::from(int_bonuses(self.u, res, A::MaxMana)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::MaxMana, + )) } S::HpRegen => { let mut res = self.formula(K::HealthRegen, &self.pool_params(false, K::HealthRegen)) as i32; res += self.spi() / 10; - f64::from(int_bonuses(self.u, res, A::HealthRegen)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::HealthRegen, + )) } S::MpRegen => { let mut res = self.formula(K::ManaRegen, &self.pool_params(false, K::ManaRegen)) as i32; res += self.spi() / 10; - f64::from(int_bonuses(self.u, res, A::ManaRegen)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::ManaRegen, + )) } S::PersistentHpRegen => { let mut res = self.formula( @@ -204,7 +239,12 @@ impl Eval<'_> { if persistent_div { res /= 5; } - f64::from(int_bonuses(self.u, res, A::PersistentHealthRegen)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::PersistentHealthRegen, + )) } S::PersistentMpRegen => { let mut res = self.formula( @@ -214,7 +254,12 @@ impl Eval<'_> { if persistent_div { res /= 5; } - f64::from(int_bonuses(self.u, res, A::PersistentManaRegen)) + f64::from(int_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + res, + A::PersistentManaRegen, + )) } S::LevelDps if combat => { let ab = if mate { self.level() } else { 0.0 }; @@ -228,6 +273,7 @@ impl Eval<'_> { let p = self.full_params(); f64::from(int_bonuses( self.u, + &self.server.game_data.characters.unit_attribute_limits, self.formula(K::Armor, &p) as i32, A::Armor, )) @@ -236,6 +282,7 @@ impl Eval<'_> { let p = self.full_params(); f64::from(int_bonuses( self.u, + &self.server.game_data.characters.unit_attribute_limits, self.formula(K::MagicResist, &p) as i32, A::MagicResist, )) @@ -246,13 +293,23 @@ impl Eval<'_> { S::OffhandDps if slave => self.weapon_dps(f64::from(self.str_()), A::OffhandDps), S::RangedDps if slave => self.weapon_dps(f64::from(self.dex()), A::RangedDps), S::MDps if slave => self.weapon_dps(f64::from(self.int()), A::SpellDps), - other => base_unit_stat(self.u, other, self.now), + other => base_unit_stat_with_limits( + self.u, + other, + self.now, + &self.server.game_data.characters.unit_attribute_limits, + ), } } fn inc(&self, kind: UnitFormulaKind, attr: UnitAttribute) -> f64 { let p = self.full_params(); - f64::from(float_bonuses(self.u, self.formula(kind, &p), attr) as i32) + f64::from(float_bonuses( + self.u, + &self.server.game_data.characters.unit_attribute_limits, + self.formula(kind, &p), + attr, + ) as i32) } fn weapon_dps(&self, attr_value: f64, attr: UnitAttribute) -> f64 { @@ -264,7 +321,13 @@ impl Eval<'_> { res += b.value as f32; } } - f64::from((res * 1000.0) as i32) + f64::from( + self.server + .game_data + .characters + .unit_attribute_limits + .clamp(attr, f64::from(res * 1000.0)) as i32, + ) } } @@ -315,6 +378,8 @@ pub fn stats_of( /// Recomputes the cached pool values (`max_hp`, `max_mp`, regen) of a detached unit. pub fn refresh_pools(server: &GameServer, kind: VehicleKind, u: &mut UnitBase) { + u.bonuses + .bind_attribute_limits(&server.game_data.characters.unit_attribute_limits); let v = stats_of( server, kind, diff --git a/rust/crates/aaemu-game/src/world/mod.rs b/rust/crates/aaemu-game/src/world/mod.rs index 9fef75d610..d18954ee06 100644 --- a/rust/crates/aaemu-game/src/world/mod.rs +++ b/rust/crates/aaemu-game/src/world/mod.rs @@ -834,6 +834,11 @@ impl WorldInstance { /// `GameObject.Spawn()` (`ParentWorld.AddObject(this); Show()`). pub fn spawn(&self, obj: impl Into, ctx: &ViewCtx<'_>) -> Vec { let obj = obj.into(); + obj.with_unit(|u| { + u.unit_mut() + .bonuses + .bind_attribute_limits(&ctx.data.characters.unit_attribute_limits) + }); self.add_object(&obj); self.show(obj, ctx) } diff --git a/rust/crates/aaemu-game/src/world/session.rs b/rust/crates/aaemu-game/src/world/session.rs index fe644be3d6..66131e12f3 100644 --- a/rust/crates/aaemu-game/src/world/session.rs +++ b/rust/crates/aaemu-game/src/world/session.rs @@ -32,6 +32,13 @@ use crate::server::GameServer; use crate::systems::skills::packets::SCCooldownsPacket; use crate::world::{broadcast, unit_state, Player, PlayerRef, WorldInstance, WorldObject}; +#[path = "zone_access.rs"] +mod zone_access; +pub use zone_access::{zone_access_allowed, ZoneAccessState, CLOSED_ZONE}; +#[cfg(test)] +#[path = "zone_access_tests.rs"] +mod zone_access_tests; + /// `LeaveWorldTargetType`. pub mod leave_target { pub const QUIT_GAME: u8 = 0; @@ -77,11 +84,17 @@ fn mother_id(server: &GameServer, faction_id: u32) -> u32 { /// `Character.IsOnline` setter. pub fn set_online(server: &GameServer, p: &PlayerRef, value: bool) { + if !value { + zone_access::cancel(p); + } if p.data().is_online == value { return; } crate::systems::social::friend::send_status_change(server, p, true, value); p.data().is_online = value; + if value { + zone_access::update(server, p); + } // !value -> TeamManager.SetOffline crate::systems::social::session::on_online_changed(server, p, value); } @@ -187,15 +200,13 @@ pub fn on_zone_change(server: &GameServer, p: &PlayerRef, last_zone: u32, new_zo ability: 0, language_type: 0, }); - // Later phase: the forced transport out of closed zones for access level < 100 - // (5 x SCErrorMsg(ClosedZone) every 2 s, then SCCharacterResurrected at the closest - // return portal). tracing::warn!("{} entered closed zone {}", p.data().unit.name, z.zone_key); } None => { tracing::warn!("{} entered unknown zone {new_zone}", p.data().unit.name); } } + zone_access::update(server, p); } /// `ChatManager.GetZoneChat(zoneKey)`. @@ -931,6 +942,9 @@ pub async fn move_unit(server: &GameServer, conn: &mut GameConnection, obj_id: u let t = target.transform(); (t.x, t.y, t.z) }; + if let Some(player) = target.as_player() { + zone_access::remember_open_position(server, player); + } // An actor standing on an object sends its primary position in the // supporting object's frame and the auxiliary position in world // coordinates, whatever the object kind (gcFlags 1 unit, 2 gimmick, @@ -974,6 +988,9 @@ pub async fn move_unit(server: &GameServer, conn: &mut GameConnection, obj_id: u .leave_other_instance(&crate::world::WorldObject::from(&target), world.id); let changes = world.add_visible_object(&target, &server.view_ctx()); handle_zone_changes(server, changes); + if let Some(player) = target.as_player() { + zone_access::update(server, player); + } // FinalizeTransform: every 5 s the movement speed analysis (SusManager) let new_pos = { let t = target.transform(); @@ -1380,6 +1397,7 @@ pub async fn save_and_remove_from_world(server: &GameServer, active: Option<&Pla let Some(p) = active else { return; }; + zone_access::cancel(p); // A duel / battlefield faction is temporary: restore it before the departure save so the // character is never persisted with its Red / Blue team or corps faction (RPA-09). server @@ -1415,6 +1433,7 @@ pub async fn on_disconnect(server: &GameServer, conn: &mut GameConnection) { server.enter_world.release_connection(conn.id); return; }; + zone_access::cancel(&p); crate::systems::housing::dominion::runtime::abort_character(server, p.character_id); crate::systems::housing::dominion::participants::clear_player(server, &p); crate::systems::economy::on_disconnect(server, &p); @@ -1471,6 +1490,7 @@ pub fn force_release_connection(server: &GameServer, connection_id: u32) { if p.conn.id != connection_id { continue; } + zone_access::cancel(&p); // Drop the server-wide entry first: if the grid removal below panics on a poisoned // instance lock, the character must still not be lookable up by id / obj id. server.world.try_remove_character(p.obj_id); diff --git a/rust/crates/aaemu-game/src/world/zone_access.rs b/rust/crates/aaemu-game/src/world/zone_access.rs new file mode 100644 index 0000000000..d8aacbad0e --- /dev/null +++ b/rust/crates/aaemu-game/src/world/zone_access.rs @@ -0,0 +1,329 @@ +//! Closed-zone transport from `a2ab80abd^:AAEmu.Game/Models/Game/Char/Character.cs`, +//! `OnZoneChange` (five 2 s warnings, dismount/despawn, 200 ms grace, return portal). +//! Unknown keys can be +//! world.xml placeholders (e.g. main-world 202, o_temp_b), not necessarily closed zones. + +use std::sync::Arc; +use std::time::Duration; + +use tokio_util::sync::CancellationToken; + +use crate::models::character::DEFAULT_INSTANCE_ID; +use crate::models::transform::Transform; +use crate::packets::world::SCErrorMsgPacket; +use crate::server::GameServer; +use crate::systems::npcs::portal; +use crate::systems::skills::packets_special::{SCCharacterResurrectedPacket, SCLoadInstancePacket}; +use crate::world::{broadcast, PlayerRef, WorldObject}; + +/// Native 1.2 `x2game12.c:1163240`, error-name switch case 287 = `closed_zone`. +pub const CLOSED_ZONE: i16 = 287; + +#[derive(Debug, Clone, Default)] +pub struct ZoneAccessState { + // Retain a completed attempt until departure: a missing safe route must not start a loop. + attempt: Option, + safe_position: Option, +} + +fn is_closed(server: &GameServer, zone: u32) -> bool { + server + .game_data + .zones + .zone_by_key(zone) + .is_some_and(|z| z.closed) +} + +/// Check both the saved zone and the actual destination sector before charging or moving. +/// A missing static zone row alone is not evidence that a coordinate is forbidden. +pub fn zone_access_allowed( + server: &GameServer, + player: &PlayerRef, + instance: u32, + zone: u32, + x: f32, + y: f32, +) -> bool { + if player.data().access_level >= 100 { + return true; + } + !is_closed(server, zone) + && !server + .world + .worlds() + .iter() + .any(|w| w.id == instance && is_closed(server, w.template.zone_id_at(x, y))) +} + +pub(super) fn cancel(player: &PlayerRef) { + if let Some(token) = player.data().zone_access.attempt.take() { + token.cancel(); + } +} + +fn world_transform(server: &GameServer, player: &PlayerRef) -> Option { + let mut t = player.data().unit.transform; + let world = server.world.world(t.instance_id)?; + let pos = world.world_pos_rot(&WorldObject::from(player)); + t.set_position(pos.x, pos.y, pos.z, pos.rot_x, pos.rot_y, pos.rot_z); + t.parent_obj_id = 0; + t.world_id = world.template.id; + t.zone_id = world.template.zone_id_at(t.x, t.y); + Some(t) +} + +// Eviction destinations require positive open-zone evidence, a live world and real coordinates. +// This deliberately rejects GetClosestReturnPortal's synthetic current-position fail-safe. +fn safe_destination(server: &GameServer, t: &Transform) -> bool { + [t.x, t.y, t.z, t.rot_x, t.rot_y, t.rot_z] + .iter() + .all(|v| v.is_finite()) + && server + .game_data + .zones + .zone_by_key(t.zone_id) + .is_some_and(|z| !z.closed) + && server.world.worlds().iter().any(|w| { + w.id == t.instance_id + && w.template.id == t.world_id + && w.template.zone_id_at(t.x, t.y) == t.zone_id + }) +} + +pub(super) fn remember_open_position(server: &GameServer, player: &PlayerRef) { + if let Some(t) = world_transform(server, player).filter(|t| safe_destination(server, t)) { + player.data().zone_access.safe_position = Some(t); + } +} + +fn needs_return(server: &GameServer, player: &PlayerRef) -> bool { + let (online, access, t) = { + let c = player.data(); + (c.is_online, c.access_level, c.unit.transform) + }; + online + && access < 100 + && !server.is_shutting_down() + && server + .world + .character_by_obj_id(player.obj_id) + .is_some_and(|p| Arc::ptr_eq(&p, player)) + && (is_closed(server, t.zone_id) + || world_transform(server, player).is_some_and(|t| is_closed(server, t.zone_id))) +} + +pub(super) fn update(server: &GameServer, player: &PlayerRef) { + if !needs_return(server, player) { + cancel(player); + remember_open_position(server, player); + return; + } + let Some(server) = server.self_arc() else { + return; + }; + let token = { + let mut c = player.data(); + if c.zone_access.attempt.is_some() { + return; + } + let token = CancellationToken::new(); + c.zone_access.attempt = Some(token.clone()); + token + }; + // Weak handles prevent a sleeping warning from retaining a departed session/server. + let weak_server = Arc::downgrade(&server); + let weak_player = Arc::downgrade(player); + let started = tokio::time::Instant::now(); + player.send(SCErrorMsgPacket::new(CLOSED_ZONE, 0, false)); + tokio::spawn(async move { + for tick in 1..=5 { + tokio::select! { + _ = token.cancelled() => return, + _ = tokio::time::sleep_until(started + Duration::from_secs(tick * 2)) => {} + } + let (Some(server), Some(player)) = (weak_server.upgrade(), weak_player.upgrade()) + else { + return; + }; + if token.is_cancelled() { + return; + } + if !needs_return(&server, &player) { + cancel(&player); + return; + } + if tick < 5 { + player.send(SCErrorMsgPacket::new(CLOSED_ZONE, 0, false)); + } + } + let (Some(server), Some(player)) = (weak_server.upgrade(), weak_player.upgrade()) else { + return; + }; + let Some(destination) = return_destination(&server, &player) else { + tracing::warn!( + character_id = player.character_id, + "Closed zone: no verified open return route" + ); + return; + }; + crate::systems::vehicles::force_dismount( + &server, + &player, + crate::systems::vehicles::slaves::attach_reason::PREFAB_CHANGED, + ); + let instance = player.data().unit.transform.instance_id; + crate::systems::vehicles::mates::remove_and_despawn_all_active_owned_mates( + &server, + instance, + player.character_id, + ); + // Match the historical 200 ms dismount grace; recheck cancellation and identity after it. + tokio::select! { + _ = token.cancelled() => return, + _ = tokio::time::sleep(Duration::from_millis(200)) => {} + } + if token.is_cancelled() { + return; + } + if !needs_return(&server, &player) || !safe_destination(&server, &destination) { + cancel(&player); + return; + } + transport(&server, &player, destination); + }); +} + +fn return_destination(server: &GameServer, player: &PlayerRef) -> Option { + let (instance, recorded, main) = { + let c = player.data(); + ( + c.unit.transform.instance_id, + c.zone_access.safe_position, + c.main_world_position, + ) + }; + // In an instance, prefer its recorded open route over a respawn in another world. + if let Some(t) = recorded.filter(|t| { + instance != DEFAULT_INSTANCE_ID && t.instance_id == instance && safe_destination(server, t) + }) { + return Some(t); + } + if instance != DEFAULT_INSTANCE_ID { + if let Some(t) = main.filter(|t| safe_destination(server, t)) { + return Some(t); + } + } + let p = portal::closest_return_portal(server, player); + let t = Transform { + instance_id: DEFAULT_INSTANCE_ID, + world_id: 0, + zone_id: p.zone_id, + x: p.x, + y: p.y, + z: p.z, + rot_z: p.z_rot, + ..Transform::default() + }; + safe_destination(server, &t) + .then_some(t) + .or_else(|| recorded.filter(|t| safe_destination(server, t))) +} + +fn transport(server: &GameServer, player: &PlayerRef, destination: Transform) { + let old = player.data().unit.transform; + let Some(world) = server.world.world(destination.instance_id) else { + return; + }; + if old.instance_id != destination.instance_id + && !crate::systems::vehicles::on_instance_change(server, player) + { + return; + } + if old.instance_id != destination.instance_id { + leave_instance_membership(server, player, old.instance_id); + } + if let Some(old_world) = server.world.world_of(&WorldObject::from(player)) { + old_world.detach_child(&WorldObject::from(player)); + // Old observers must receive the forced displacement before the player leaves their view. + broadcast( + &old_world, + player, + &SCCharacterResurrectedPacket { + unit_id: player.obj_id, + x: destination.x, + y: destination.y, + z: destination.z, + z_rot: destination.rot_z, + }, + true, + ); + } + if old.instance_id != destination.instance_id { + player.send(SCLoadInstancePacket { + instance_id: destination.instance_id, + zone_id: destination.zone_id, + x: destination.x, + y: destination.y, + z: destination.z, + ang_x: destination.rot_x, + ang_y: destination.rot_y, + ang_z: destination.rot_z, + }); + } + { + let mut c = player.data(); + c.set_disabled_set_position(true); + // Native OnCharacterResurrected (391D3AD0) does not acknowledge a same-world + // displacement with TeleportEnded. Only a world load waits for InstanceLoaded. + if old.instance_id == destination.instance_id { + c.set_disabled_set_position(false); + } + c.unit.transform = destination; + } + server + .world + .leave_other_instance(&WorldObject::from(player), destination.instance_id); + if old.instance_id != destination.instance_id { + if let Some(previous) = server.world.world(old.instance_id) { + previous.remove_object(player.obj_id); + } + } + world.add_object(player); + let changes = world.add_visible_object(player, &server.view_ctx()); + super::handle_zone_changes(server, changes); + if old.zone_id != destination.zone_id { + super::on_zone_change(server, player, old.zone_id, destination.zone_id); + } + update(server, player); +} + +/// The membership part of a normal instance leave, without replaying its saved return +/// transform (which may itself be closed). The verified destination is applied by transport. +fn leave_instance_membership(server: &GameServer, player: &PlayerRef, instance: u32) { + use crate::systems::instances::events::CharEvent; + let events = &server.systems.instances.events.characters; + if let Some(dungeon) = server.systems.instances.dungeon_of_world(instance) { + { + let mut state = dungeon.st(); + state + .leave_requests + .retain(|(id, _)| *id != player.character_id); + state.enter_requests.retain(|p| !Arc::ptr_eq(p, player)); + } + for event in [ + CharEvent::TeamJoin, + CharEvent::TeamKick, + CharEvent::TeamLeave, + CharEvent::DungeonLeave, + CharEvent::Disconnect, + ] { + events.unsubscribe(player, event, dungeon.uid); + } + } + if let Some(game) = server.systems.instances.instant_games.current(player) { + crate::systems::instances::instant_game::on_disconnect(server, player); + crate::systems::instances::instant_game::remove_player(server, &game, player); + crate::systems::social::faction::restore_temporary_faction(server, player); + events.unsubscribe(player, CharEvent::Kill, game.uid); + } +} diff --git a/rust/crates/aaemu-game/src/world/zone_access_tests.rs b/rust/crates/aaemu-game/src/world/zone_access_tests.rs new file mode 100644 index 0000000000..235d29c868 --- /dev/null +++ b/rust/crates/aaemu-game/src/world/zone_access_tests.rs @@ -0,0 +1,650 @@ +//! Regressions for the actual movement, session and portal/skill entry paths. Timer tests +//! use Tokio's paused clock; no MySQL, client files or servers are involved. + +use std::sync::Arc; +use std::time::Duration; + +use crate::data::world_data::{DistrictReturnPoint, Portal, Zone}; +use crate::data::world_templates::{WorldTemplate, WorldTemplates}; +use crate::data::GameData; +use crate::models::movement::{MoveKind, MoveType, UnitMove}; +use crate::models::npc::{Npc, PortalInfo}; +use crate::models::transform::Transform; +use crate::net::packet::encode_raw; +use crate::opcodes::{cs, sc}; +use crate::server::GameServer; +use crate::systems::npcs::portal::{self, PortalEffectObject, PortalTables}; +use crate::systems::skills::data::{effects::SpecialEffect, EffectKind, EffectTemplate}; +use crate::systems::skills::types::{skill_result, SkillCastTarget, SkillCaster, SkillObject}; +use crate::test_support::{spawn_player, test_character, test_server_with, TestClient, TEST_ZONE}; +use crate::world::{Entity, PlayerRef, WorldObject}; + +use super::{on_zone_change, zone_access}; + +const CLOSED: u32 = 200; +const GATE_SKILL: u32 = 90001; +const OPEN_SKILL: u32 = 90002; +const GATE: u32 = 10; + +fn data(respawn: bool) -> GameData { + let mut data = GameData::empty(); + for (key, closed) in [(TEST_ZONE, false), (CLOSED, true), (201, true)] { + data.zones.zones.insert( + key, + Zone { + zone_key: key, + closed, + ..Default::default() + }, + ); + } + let point = |zone_id, x| Portal { + id: GATE, + zone_id, + x, + y: 100.0, + z: 100.0, + ..Default::default() + }; + data.systems.npcs.portal = PortalTables::from_parts( + if respawn { + vec![point(TEST_ZONE, 128.0)] + } else { + vec![] + }, + vec![point(CLOSED, 1400.0)], + vec![], + vec![], + ) + .unwrap(); + data.portals.recalls.insert(1, vec![point(CLOSED, 1400.0)]); + data.systems.npcs.portal.recalls_key.insert(GATE, 1); + data.portals + .district_return_points + .push(DistrictReturnPoint { + id: 1, + district_id: 1, + faction_id: 101, + return_point_id: GATE, + }); + data.systems.npcs.npc.templates.insert( + 900, + crate::systems::npcs::npc::data::NpcTemplate { + id: 900, + teleporter: true, + ..Default::default() + }, + ); + data.systems.skills.add_effect( + EffectKind::SpecialEffect, + EffectTemplate::Special(SpecialEffect { + id: 1, + special_effect_type_id: 25, + value1: GATE as i32, + value2: 0, + value3: 0, + value4: 0, + }), + 1, + ); + data.systems + .skills + .add_skill(crate::systems::skills::data::SkillTemplate { + target_type: 0, + mana_cost: 20, + cooldown_time: 10000, + effects: vec![crate::systems::skills::tests::skill_effect( + 1, + EffectKind::SpecialEffect, + 1, + )], + ..crate::systems::skills::tests::skill_template(GATE_SKILL) + }); + data.systems.skills.add_effect( + EffectKind::OpenPortalEffect, + EffectTemplate::OpenPortal { + id: 2, + distance: 5.0, + }, + 2, + ); + data.systems + .skills + .add_skill(crate::systems::skills::data::SkillTemplate { + target_type: 0, + mana_cost: 20, + cooldown_time: 10000, + effects: vec![crate::systems::skills::tests::skill_effect( + 2, + EffectKind::OpenPortalEffect, + 2, + )], + ..crate::systems::skills::tests::skill_template(OPEN_SKILL) + }); + data +} + +fn server(respawn: bool) -> Arc { + let mut server = test_server_with(data(respawn)); + let mut template = WorldTemplate::synthetic(0, "main_world", 2, 2, TEST_ZONE); + for x in 16..32 { + for y in 0..32 { + template.set_zone_key_at(x, y, if x < 24 { CLOSED } else { 201 }); + } + } + Arc::get_mut(&mut server.game_data).unwrap().worlds = + WorldTemplates::from_templates(vec![template], vec![]).unwrap(); + server.world = Arc::new(crate::world::WorldManager::default()); + server.world.create_world_instance( + Arc::new( + server + .game_data + .worlds + .get_world_template_by_name("main_world") + .unwrap() + .clone(), + ), + 0, + ); + let server = Arc::new(server); + server.set_self(); + crate::systems::npcs::install_hooks(&server); + server +} + +fn player(server: &GameServer, id: u32, x: f32) -> (TestClient, PlayerRef) { + let mut client = TestClient::new(server, id, 1000 + id); + let mut character = test_character(id, "ZoneTester", x, 100.0); + character.is_online = true; + character.unit.hp = 100; + character.unit.max_hp = 100; + character.unit.mp = 100; + character.unit.max_mp = 100; + let p = spawn_player(server, &client, character, 0x100 + id); + client.conn.active_char = Some(p.clone()); + client.drain(); + (client, p) +} + +async fn walk(server: &GameServer, client: &mut TestClient, p: &PlayerRef, x: f32) { + crate::world::session::move_unit( + server, + &mut client.conn, + p.obj_id, + MoveType::new(MoveKind::Unit(UnitMove { + x, + y: 100.0, + z: 100.0, + vel_x: 10, + ..Default::default() + })), + ) + .await; + tokio::task::yield_now().await; +} + +async fn advance(ms: u64) { + tokio::time::advance(Duration::from_millis(ms)).await; + tokio::task::yield_now().await; +} + +fn warning_count(client: &mut TestClient) -> usize { + client + .drain() + .into_iter() + .filter(|(op, body)| { + // Native 1.2 397C3030: ErrorMessage:i16 twice, type:u32, isNotify:bool. + *op == sc::SCErrorMsgPacket && body.as_slice() == [0x1f, 1, 0x1f, 1, 0, 0, 0, 0, 0] + }) + .count() +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_walk_warns_five_times_then_returns_and_refiles_visibility() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + let (mut arrival, a) = player(&server, 2, 128.0); + let (mut departure, d) = player(&server, 3, 1400.0); + walk(&server, &mut client, &p, 1400.0).await; + assert_eq!(p.data().unit.transform.zone_id, CLOSED); + assert_eq!(warning_count(&mut client), 1); + for _ in 0..4 { + // Duplicate callbacks must not allocate another timer or extend its deadline. + on_zone_change(&server, &p, CLOSED, CLOSED); + advance(2000).await; + assert_eq!(warning_count(&mut client), 1); + } + arrival.drain(); + departure.drain(); + advance(2000).await; + assert_eq!(p.data().unit.transform.x, 1400.0); + advance(200).await; + let t = p.data().unit.transform; + assert_eq!( + (t.instance_id, t.zone_id, t.x, t.y), + (0, TEST_ZONE, 128.0, 100.0) + ); + assert!(!p.data().disabled_set_position); + let frames = client.drain(); + assert_eq!( + frames + .iter() + .filter(|f| f.0 == sc::SCCharacterResurrectedPacket) + .count(), + 1 + ); + assert!(arrival.drain_ops().contains(&sc::SCUnitStatePacket)); + assert!(departure.drain_ops().contains(&sc::SCUnitsRemovedPacket)); + let world = server.world.world(0).unwrap(); + let around = world.players_around(WorldObject::from(&p)); + assert!(around.iter().any(|x| Arc::ptr_eq(x, &a))); + assert!(!around.iter().any(|x| Arc::ptr_eq(x, &d))); + // Native resurrection has no TeleportEnded acknowledgement: movement remains usable. + walk(&server, &mut client, &p, 130.0).await; + assert_eq!(p.data().unit.transform.x, 130.0); + advance(20000).await; + assert_eq!(warning_count(&mut client), 0); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_departure_cancels_and_reentry_gets_a_fresh_deadline() { + let server = server(false); + let (mut client, p) = player(&server, 1, 100.0); + walk(&server, &mut client, &p, 1400.0).await; + assert_eq!(warning_count(&mut client), 1); + advance(2000).await; + client.drain(); + walk(&server, &mut client, &p, 200.0).await; + advance(4000).await; + assert_eq!(warning_count(&mut client), 0); + walk(&server, &mut client, &p, 1400.0).await; + assert_eq!(warning_count(&mut client), 1); + advance(4000).await; + assert!(!client + .drain_ops() + .contains(&sc::SCCharacterResurrectedPacket)); + assert_eq!(p.data().unit.transform.x, 1400.0); + advance(6000).await; + advance(200).await; + // With no respawn data, the last recorded open position is a real fallback. + let t = p.data().unit.transform; + assert_eq!((t.zone_id, t.x), (TEST_ZONE, 200.0)); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_no_safe_route_does_not_teleport_or_repeat() { + let server = server(false); + let (mut client, p) = player(&server, 1, 1400.0); + on_zone_change(&server, &p, 0, CLOSED); + assert_eq!(warning_count(&mut client), 1); + advance(10000).await; + advance(200).await; + assert!(!client + .drain_ops() + .contains(&sc::SCCharacterResurrectedPacket)); + assert_eq!(p.data().unit.transform.x, 1400.0); + walk(&server, &mut client, &p, 1600.0).await; + advance(20000).await; + assert_eq!(warning_count(&mut client), 0); + assert_eq!(p.data().unit.transform.x, 1600.0); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_gm_entry_and_escalation_are_exempt() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + p.data().access_level = 100; + walk(&server, &mut client, &p, 1400.0).await; + advance(12000).await; + assert_eq!(warning_count(&mut client), 0); + assert_eq!(p.data().unit.transform.x, 1400.0); + p.data().access_level = 99; + walk(&server, &mut client, &p, 1401.0).await; + assert_eq!(warning_count(&mut client), 1); + p.data().access_level = 100; + advance(12000).await; + assert_eq!(warning_count(&mut client), 0); + assert_eq!(p.data().unit.transform.x, 1401.0); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_offline_and_stale_player_cancel_pending_transport() { + for offline in [true, false] { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + walk(&server, &mut client, &p, 1400.0).await; + assert_eq!(warning_count(&mut client), 1); + if offline { + crate::world::session::set_online(&server, &p, false); + } else { + server.world.try_remove_character(p.obj_id); + // Same obj id in a different session must not make the old timer valid. + let replacement = crate::world::Player::new(p.data().clone(), p.conn.clone()); + server.world.try_add_character(&replacement); + } + advance(20000).await; + assert!(client.drain_ops().iter().all(|op| ![ + sc::SCErrorMsgPacket, + sc::SCCharacterResurrectedPacket + ] + .contains(op))); + assert_eq!(p.data().unit.transform.x, 1400.0); + } +} + +#[tokio::test] +async fn closed_zone_portal_packet_and_open_portal_reject_before_side_effects() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + let destination = Transform { + zone_id: TEST_ZONE, + x: 1400.0, + y: 100.0, + z: 100.0, + ..Default::default() + }; + let mut npc = Npc::new(portal::PORTAL_ENTRANCE_TEMPLATE_ID); + npc.unit.transform.set_xyz(101.0, 100.0, 100.0); + npc.portal = Some(PortalInfo { + teleport_position: destination, + linked_portal_obj_id: 0, + }); + let npc = Entity::new(0x123456, npc); + server + .world + .world(0) + .unwrap() + .spawn(&npc, &server.view_ctx()); + client.drain(); + let before = p.data().unit.transform; + // Native x2game12.c:1756168..1756179 = bc(objId), onlyMyPortal:bool; + // deliberately misleading saved zone. + server + .handle_frame( + &mut client.conn, + &encode_raw(1, cs::CSUsePortalPacket, &[0x56, 0x34, 0x12, 0]), + ) + .await + .unwrap(); + let frames = client.drain(); + assert_eq!( + frames, + vec![(sc::SCErrorMsgPacket, vec![0x1f, 1, 0x1f, 1, 0, 0, 0, 0, 1])] + ); + assert_eq!(p.data().unit.transform, before); + p.data().portals.private_portals.push(Portal { + id: 10, + zone_id: CLOSED, + x: 1400.0, + y: 100.0, + ..Default::default() + }); + assert!(portal::open_portal( + &server, + &p, + &PortalEffectObject { + id: 10, + ..Default::default() + } + ) + .is_none()); + assert_eq!(client.drain_ops(), vec![sc::SCErrorMsgPacket]); + p.data().access_level = 100; + server + .handle_frame( + &mut client.conn, + &encode_raw(1, cs::CSUsePortalPacket, &[0x56, 0x34, 0x12, 0]), + ) + .await + .unwrap(); + assert!(client.drain_ops().contains(&sc::SCTeleportUnitPacket)); +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_logout_and_disconnect_cancel_during_dismount_grace() { + for disconnect in [false, true] { + let server = server(true); + server.db.close().await; + let (mut client, p) = player(&server, 1, 100.0); + walk(&server, &mut client, &p, 1400.0).await; + client.drain(); + advance(10000).await; + client.drain(); + if disconnect { + crate::world::session::on_disconnect(&server, &mut client.conn).await; + } else { + crate::world::session::leave_world_task( + &server, + Some(&mut client.conn), + super::leave_target::CHARACTER_SELECT, + Some(p.clone()), + ) + .await; + } + client.drain(); + advance(20000).await; + assert!(!client + .drain_ops() + .contains(&sc::SCCharacterResurrectedPacket)); + assert!(server.world.character_by_obj_id(p.obj_id).is_none()); + assert_eq!(p.data().unit.transform.x, 1400.0); + } +} + +#[tokio::test(start_paused = true)] +async fn closed_zone_instance_return_moves_the_world_registration_and_visibility() { + let server = server(true); + let template = WorldTemplate::synthetic(2, "closed_instance", 2, 2, CLOSED); + let instance = server.world.create_world_instance(Arc::new(template), 77); + let (mut arrival, _) = player(&server, 2, 128.0); + let mut client = TestClient::new(&server, 1, 1001); + let mut character = test_character(1, "InstanceTester", 100.0, 100.0); + character.obj_id = 0x101; + character.is_online = true; + character.unit.transform.instance_id = 77; + character.unit.transform.world_id = 2; + character.unit.transform.zone_id = CLOSED; + let p = crate::world::Player::new(character, client.conn.handle()); + server.world.try_add_character(&p); + instance.spawn(&p, &server.view_ctx()); + client.conn.active_char = Some(p.clone()); + on_zone_change(&server, &p, 0, CLOSED); + client.drain(); + arrival.drain(); + advance(10000).await; + advance(200).await; + let t = p.data().unit.transform; + assert_eq!((t.instance_id, t.world_id, t.zone_id), (0, 0, TEST_ZONE)); + assert!(instance.character_by_obj_id(p.obj_id).is_none()); + assert!(server + .world + .world(0) + .unwrap() + .character_by_obj_id(p.obj_id) + .is_some_and(|live| Arc::ptr_eq(&p, &live))); + assert_eq!(p.region().map(|r| r.0), Some(0)); + assert!(client.drain_ops().contains(&sc::SCLoadInstancePacket)); + assert!(arrival.drain_ops().contains(&sc::SCUnitStatePacket)); + crate::systems::instances::worlds::instance_loaded(&server, &p); + assert!(!p.data().disabled_set_position); + advance(20000).await; + assert_eq!(warning_count(&mut client), 0); +} + +#[tokio::test] +async fn closed_zone_npc_teleport_does_not_charge_the_fare() { + struct Wallet; + impl crate::systems::npcs::hooks::EconomyBridge for Wallet { + fn change_money( + &self, + _server: &GameServer, + p: &PlayerRef, + amount: i64, + _task: u8, + ) -> bool { + p.data().money += amount; + true + } + } + let server = server(true); + server.systems.npcs.hooks.economy.install(Arc::new(Wallet)); + let (mut client, p) = player(&server, 1, 100.0); + p.data().money = 500; + let mut npc = Npc::new(900); + npc.unit.transform.set_xyz(101.0, 100.0, 100.0); + let npc = Entity::new(0x123456, npc); + server + .world + .world(0) + .unwrap() + .spawn(&npc, &server.view_ctx()); + client.drain(); + // Native 1.2 397CB0E0 (x2game12.c:1766873): return point:u32, money:i32, npc:bc. + let request = [10, 0, 0, 0, 120, 0, 0, 0, 0x56, 0x34, 0x12]; + server + .handle_frame( + &mut client.conn, + &encode_raw(1, cs::CSUseTeleportPacket, &request), + ) + .await + .unwrap(); + assert_eq!(p.data().money, 500); + assert_eq!(client.drain_ops(), vec![sc::SCErrorMsgPacket]); + assert!(!p.data().disabled_set_position); + p.data().access_level = 100; + server + .handle_frame( + &mut client.conn, + &encode_raw(1, cs::CSUseTeleportPacket, &request), + ) + .await + .unwrap(); + assert_eq!(p.data().money, 380); + assert_eq!(client.drain_ops(), vec![sc::SCTeleportUnitPacket]); +} + +#[tokio::test] +async fn closed_zone_worldgate_skill_is_rejected_before_mana_and_cooldown() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + let caster = WorldObject::from(&p); + let skill = crate::systems::skills::skill::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(GATE_SKILL) + .unwrap() + .clone(), + Some(&caster), + ); + let before = p.data().unit.transform; + let result = crate::systems::skills::skill::use_skill( + &server, + &skill, + &caster, + SkillCaster::Unit(p.obj_id), + &mut SkillCastTarget::Unit(p.obj_id), + None, + false, + ); + assert_eq!(result, (skill_result::NO_PERM, 0)); + assert_eq!(p.data().unit.mp, 100); + assert!(!p + .data() + .unit + .cooldowns + .check_cooldown(GATE_SKILL, crate::world::now_ms())); + assert_eq!(p.data().unit.transform, before); + assert!(client.drain().is_empty()); +} + +#[tokio::test] +async fn closed_zone_open_portal_skill_rejects_the_saved_book_destination_before_charging() { + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + p.data().portals.private_portals.push(Portal { + id: GATE, + zone_id: CLOSED, + x: 1400.0, + y: 100.0, + ..Default::default() + }); + let caster = WorldObject::from(&p); + let skill = crate::systems::skills::skill::new_skill_for( + &server, + server + .game_data + .systems + .skills + .skill(OPEN_SKILL) + .unwrap() + .clone(), + Some(&caster), + ); + let result = crate::systems::skills::skill::use_skill( + &server, + &skill, + &caster, + SkillCaster::Unit(p.obj_id), + &mut SkillCastTarget::Unit(p.obj_id), + Some(SkillObject::PortalInfo { + kind: 0, + id: GATE as i32, + x: 101.0, + y: 100.0, + z: 100.0, + }), + false, + ); + assert_eq!(result, (skill_result::NO_PERM, 0)); + assert_eq!(p.data().unit.mp, 100); + assert!(!p + .data() + .unit + .cooldowns + .check_cooldown(OPEN_SKILL, crate::world::now_ms())); + assert!(client.drain().is_empty()); +} + +#[tokio::test] +async fn closed_zone_saved_return_and_unknown_mapping_are_checked_without_fabrication() { + use crate::systems::skills::effects::{EffectArgs, EffectSource}; + use crate::systems::skills::types::CastAction; + let server = server(true); + let (mut client, p) = player(&server, 1, 100.0); + p.data().return_district_id = 1; + let before = p.data().unit.transform; + let caster = WorldObject::from(&p); + let args = EffectArgs { + caster: Some(caster.clone()), + caster_caster: SkillCaster::Unit(p.obj_id), + target: crate::systems::skills::geometry::Target::Obj(caster), + target_caster: SkillCastTarget::Unit(p.obj_id), + cast: CastAction::Skill { + skill_id: GATE_SKILL, + tl_id: 1, + }, + source: EffectSource::default(), + skill_object: &SkillObject::None, + }; + crate::systems::skills::effects::special::execute(&server, 25, &args, [0; 4]); + assert_eq!(p.data().unit.transform, before); + assert_eq!(client.drain_ops(), vec![sc::SCErrorMsgPacket]); + p.data().main_world_position = Some(Transform { + zone_id: CLOSED, + x: 1400.0, + ..before + }); + crate::systems::skills::effects::special::execute(&server, 25, &args, [9999, 0, 0, 0]); + assert_eq!(p.data().unit.transform, before); + assert_eq!(client.drain_ops(), vec![sc::SCErrorMsgPacket]); + // Unknown zone keys alone do not make an otherwise open coordinate closed. + assert!(zone_access::zone_access_allowed( + &server, &p, 0, 202, 100.0, 100.0 + )); + assert!(!zone_access::zone_access_allowed( + &server, &p, 0, 202, 1400.0, 100.0 + )); +} diff --git a/rust/crates/aaemu-game/src/world_flow_tests.rs b/rust/crates/aaemu-game/src/world_flow_tests.rs index fc20f19784..49e1d4a174 100644 --- a/rust/crates/aaemu-game/src/world_flow_tests.rs +++ b/rust/crates/aaemu-game/src/world_flow_tests.rs @@ -449,6 +449,7 @@ async fn create_character_save_failure_releases_assets_and_allows_retry() { CharacterTemplate { race: 1, gender: 1, + creatable: true, faction_id: 101, num_inventory_slot: 50, num_bank_slot: 50, @@ -583,7 +584,7 @@ async fn create_character_save_failure_releases_assets_and_allows_retry() { a.frame(&s, cs::CSCreateCharacterPacket, &body(&req)).await; assert_eq!( a.drain(), - vec![(sc::SCCharacterCreationFailedPacket, vec![3])] + vec![(sc::SCCharacterCreationFailedPacket, vec![2])] ); assert_released(); assert!(a.conn.characters.is_empty()); @@ -607,7 +608,7 @@ async fn create_character_save_failure_releases_assets_and_allows_retry() { a.frame(&s, cs::CSCreateCharacterPacket, &body(&req)).await; assert_eq!( a.drain(), - vec![(sc::SCCharacterCreationFailedPacket, vec![3])] + vec![(sc::SCCharacterCreationFailedPacket, vec![2])] ); assert_released(); assert!(a.conn.characters.is_empty()); diff --git a/rust/crates/aaemu-game/tests/slave_attach_coverage.rs b/rust/crates/aaemu-game/tests/slave_attach_coverage.rs new file mode 100644 index 0000000000..eff16b3de2 --- /dev/null +++ b/rust/crates/aaemu-game/tests/slave_attach_coverage.rs @@ -0,0 +1,164 @@ +//! Native 1.2 attach-data regressions. Source nodes and SHA-256s: +//! `rust/tools/slave_attach_points.provenance.json`; generator/conventions: +//! `rust/tools/slave_attach_points.py`. No client bytes are fixtures here. +//! +//! `AAEMU_COMPACT_DB= cargo test -p aaemu-game --test slave_attach_coverage -- --ignored` + +use std::collections::{BTreeMap, BTreeSet}; + +use aaemu_game::data::world_templates::WorldSpawnPosition; +use aaemu_game::systems::vehicles::data::parse_attach_points; +use rusqlite::{Connection, OpenFlags}; + +const REPAIRED: &[(u32, &[u8])] = &[ + (5, &[24, 35, 81]), + (867, &[35]), + (892, &[9]), + (898, &[9]), + (899, &[9]), + ( + 1024, + &[ + 9, 10, 11, 12, 13, 14, 15, 16, 17, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 35, 36, + 37, 38, 39, 46, 58, 59, + ], + ), + (1287, &[2, 35, 36]), + (1323, &[21, 36, 60, 61]), + (1371, &[21, 36, 60, 61]), + ( + 1385, + &[ + 21, 22, 24, 25, 36, 37, 38, 39, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, + 76, + ], + ), + (1442, &[9, 10]), + (1444, &[21, 36, 60, 61]), + (1460, &[21, 36, 60, 61]), + (1461, &[21, 36, 60, 61]), + (1462, &[21, 36, 60, 61]), +]; + +fn shipped() -> BTreeMap<(u32, u8), WorldSpawnPosition> { + let text = include_str!("../app/Data/slave_attach_points.json"); + let mut points = BTreeMap::new(); + for (model, entries) in parse_attach_points(text).expect("shipped attach JSON") { + for (point, location) in entries { + assert!( + points.insert((model, point), location).is_none(), + "duplicate attach point ({model}, {point})" + ); + } + } + points +} + +#[test] +fn recovered_native_attach_points_are_shipped() { + let points = shipped(); + assert_eq!(REPAIRED.iter().map(|(_, p)| p.len()).sum::(), 87); + for &(model, indexes) in REPAIRED { + for &point in indexes { + let p = points + .get(&(model, point)) + .unwrap_or_else(|| panic!("missing recovered native attach ({model}, {point})")); + assert_ne!(point, 0, "None is not an attachment helper"); + assert!([p.x, p.y, p.z, p.roll, p.pitch, p.yaw] + .into_iter() + .all(f32::is_finite)); + assert!(p.x != 0.0 || p.y != 0.0 || p.z != 0.0, "origin placeholder"); + } + } +} + +#[test] +fn native_attach_literal_transforms_preserve_units_axes_and_parent_space() { + let points = shipped(); + // Literal native 1.2 bind poses, independently inspected in the CHRs/CGFs + // (not a serializer roundtrip or a comparison to generated provenance). + // Tank cannon0 includes Bip01/Pelvis/bone_yaw/pocenter/bone_rail already. + for (model, point, expected) in [ + (892, 9, [0.804_689_94, -2.049_110_2, 2.161_2]), + (1323, 21, [0.0, 0.870_579_96, 1.181_04]), + (1323, 60, [-0.520_054_64, -2.167_765, 0.683_005_2]), + (1442, 10, [-0.123_01, -3.090_71, 3.204_7]), + // Direct prefab $helms overrides the embedded CHR's different $helms. + (5, 35, [-0.399_810_8, 2.351_196_3, 15.238_708]), + // Existing 1406 CGF-derived entry from a9dc41b8 remains intact. CHR's + // heal_point0 differs from its sibling CGF; don't copy this into cars. + (1406, 36, [0.671_114, -0.043_841, 1.030_234]), + ] { + let actual = points[&(model, point)]; + for (got, want) in [actual.x, actual.y, actual.z].into_iter().zip(expected) { + assert!( + (got - want).abs() < 0.000_01, + "({model}, {point}): {got} != {want}" + ); + } + } + let box0 = points[&(1323, 60)]; + for (got, degrees) in [box0.roll, box0.pitch, box0.yaw] + .into_iter() + .zip([-90.0_f32, -55.0, -90.0]) + { + assert!((got - degrees.to_radians()).abs() < 0.000_01); + } + let ladder = points[&(5, 24)]; + assert!((ladder.roll - 7.895_808_f32.to_radians()).abs() < 0.000_01); + assert!((ladder.yaw.abs() - std::f32::consts::PI).abs() < 0.000_01); +} + +#[test] +#[ignore = "needs AAEMU_COMPACT_DB"] +fn real_compact_attach_bindings_and_equipment_have_only_documented_content_gaps() { + let Ok(path) = std::env::var("AAEMU_COMPACT_DB") else { + return; + }; + let conn = Connection::open_with_flags(path, OpenFlags::SQLITE_OPEN_READ_ONLY).unwrap(); + let mut query = conn + .prepare( + "SELECT s.model_id, b.attach_point_id FROM slave_doodad_bindings b JOIN slaves s ON s.id=b.owner_id + UNION SELECT s.model_id, b.attach_point_id FROM slave_bindings b JOIN slaves s ON s.id=b.owner_id WHERE b.owner_type='Slave' + UNION SELECT s.model_id, b.attach_point_id FROM slave_healing_point_doodads b JOIN slaves s ON s.id=b.owner_id + UNION SELECT s.model_id, b.attach_point_id FROM slave_equip_slots b JOIN slaves s ON s.id=b.slave_id", + ) + .unwrap(); + let required: BTreeSet<(u32, u8)> = query + .query_map([], |r| Ok((r.get(0)?, r.get(1)?))) + .unwrap() + .map(Result::unwrap) + // Index0 is None, not a helper, in five of the audit's 27 models. + .filter(|(_, point)| *point != 0) + .collect(); + assert!(!required.is_empty()); + let points = shipped(); + let missing: BTreeSet<_> = required + .into_iter() + .filter(|key| !points.contains_key(key)) + .collect(); + // Absent native assets/prefabs or absent helpers. Keep these explicit and + // open; notably the smallboat has NO cannon0/cannon1 for slave55's 9/10. + let gaps: &[(u32, &[u8])] = &[ + (115, &[9, 10, 11, 12, 18]), + (129, &[9, 10]), + (130, &[9]), + ( + 512, + &[ + 2, 3, 9, 10, 11, 12, 13, 14, 15, 16, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, + 35, 36, 37, 38, 39, + ], + ), + (857, &[2]), + (866, &[35]), + (1402, &[21]), + (1427, &[21, 36, 60, 61]), + ]; + let expected: BTreeSet<_> = gaps + .iter() + .flat_map(|(model, indexes)| indexes.iter().map(move |point| (*model, *point))) + .collect(); + assert_eq!(missing, expected, "unreviewed native attach content gaps"); + assert_eq!(missing.len(), 41); +} diff --git a/rust/crates/aaemu-testclient/src/control.rs b/rust/crates/aaemu-testclient/src/control.rs new file mode 100644 index 0000000000..3efc632379 --- /dev/null +++ b/rust/crates/aaemu-testclient/src/control.rs @@ -0,0 +1,1647 @@ +//! Bounded stdio controller, using the same session and packet paths as scenarios. +//! +//! First send `{"protocol":"aaemu-control/1","id":1,"method":"hello","params":{}}`. +//! Its response is the ready boundary. Every subsequent request has the same envelope and +//! a unique string (1..64 bytes) or unsigned integer id. All params objects are strict. +//! Stdout contains only versioned responses, independent game events and lifecycle records; +//! tracing goes to stderr. Events preceding a response have `seq <= response.event_seq`. +//! This boundary orders observations; it does not imply that a server action has settled. + +use std::collections::{HashSet, VecDeque}; +use std::future::Future; +use std::io::{BufRead, Write}; +use std::path::Path; +use std::time::Duration; + +use aaemu_game::opcodes::cs; +use aaemu_testclient::record::Recorder; +use aaemu_testclient::scenario::{self, BotConfig, ControlSession}; +use anyhow::{bail, ensure, Context}; +use serde::{Deserialize, Serialize}; +use serde_json::{json, Value}; +use tokio::sync::{mpsc, oneshot, watch}; +use tokio::time::Instant; + +const PROTOCOL: &str = "aaemu-control/1"; +const MAX_LINE: usize = 16 * 1024; +const MAX_BODY: usize = 4096; +const MAX_GM: usize = 1024; +const MAX_COMMANDS: usize = 4096; +const MAX_PUMP_MS: u64 = 5000; +const MAX_DEADLINE_MS: u64 = 600_000; +const COMMAND_TIMEOUT: Duration = Duration::from_secs(5); +const CONNECT_TIMEOUT: Duration = Duration::from_secs(60); +// Included in (never added to) command/connect/global ceilings. Socket cleanup and one +// completion retain this slice even when the gameplay action never receives an answer. +const REPORT_RESERVE: Duration = Duration::from_millis(250); +const INPUT_QUEUE: usize = 16; +const OUTPUT_BYTES: usize = 8 * 1024 * 1024; +const OUTPUT_COUNT: usize = 8192; + +pub(crate) fn describe() -> Value { + json!({ + "protocol": PROTOCOL, + "methods": ["hello", "pump", "gm", "tp", "rawcs", "state", + "disconnect_hard", "reconnect", "close"], + "request": {"protocol": PROTOCOL, "id": 1, "method": "hello", "params": {}}, + "params": { + "hello": {}, "pump": {"ms": "u64 <= 5000"}, + "gm": {"command": "GM command without leading slash"}, + "tp": {"x": "finite f32", "y": "finite f32", "z": "finite f32"}, + "rawcs": {"opcode": "literal u16", "body_hex": "contiguous hex"}, + "state": {}, "disconnect_hard": {}, + "reconnect": {"character_id": "previous ready character_id (u32)"}, "close": {} + }, + "limits": { + "line_bytes": MAX_LINE, "body_bytes": MAX_BODY, "gm_bytes": MAX_GM, + "id_bytes": 64, "commands": MAX_COMMANDS, "pump_ms": MAX_PUMP_MS, + "command_ms": COMMAND_TIMEOUT.as_millis(), + "connect_ms": CONNECT_TIMEOUT.as_millis(), "deadline_ms": MAX_DEADLINE_MS, + "cleanup_report_ms": REPORT_RESERVE.as_millis(), + "event_queue_bytes": 8 * 1024 * 1024, "event_queue_count": 8192, + "input_queue_count": INPUT_QUEUE, "output_queue_bytes": OUTPUT_BYTES, + "output_queue_count": OUTPUT_COUNT + }, + "incremental_game_capture": true, + "capture_create_new": true, + "auth_frames_omitted": true, + "opaque_game_batches": "unsupported structures rejected; supported native DD04 expanded", + "game_batches": "validated native DD04 expanded into ordinary level-1 events; auth entries omitted; unknown/nested structures rejected", + "batch_limits": {"frame_bytes": aaemu_testclient::game::MAX_GAME_FRAME, + "inflated_bytes": aaemu_testclient::game::MAX_BATCH_BYTES, + "packets": aaemu_testclient::game::MAX_BATCH_PACKETS}, + "eof": "cancels active action and discards queued commands", + "capture_start": "post-lobby character select/spawn (each session)", + "handshake_before_network": true, + "initial_character": "existing configured name, never first/create", + "state_source": "client_observation", + "automatic_retry": false, + "command_timeout": "one command_deadline response after socket closure; control remains disconnected for state, explicit same-character reconnect, or close", + "hard_close": "local game write/read halves and stream; no CSLeaveWorld; FIN/RST, not logout", + "completion": "one response per input line; event_seq is an observation boundary", + "cleanup": "close, EOF, input/output failure or deadline closes only this session" + }) +} + +#[derive(Clone, Debug, PartialEq, Eq, Hash, Deserialize, Serialize)] +#[serde(untagged)] +enum RequestId { + Number(u64), + Text(String), +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Request { + protocol: String, + id: RequestId, + method: String, + #[serde(deserialize_with = "unique_params")] + params: Value, +} + +fn unique_params<'de, D: serde::Deserializer<'de>>(deserializer: D) -> Result { + struct Params; + impl<'de> serde::de::Visitor<'de> for Params { + type Value = Value; + + fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + formatter.write_str("a params object with unique keys") + } + + fn visit_map>(self, mut map: M) -> Result { + let mut values = serde_json::Map::new(); + while let Some(key) = map.next_key::()? { + if values.contains_key(&key) { + return Err(serde::de::Error::custom("duplicate param")); + } + values.insert(key, map.next_value()?); + } + Ok(Value::Object(values)) + } + } + deserializer.deserialize_map(Params) +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Empty {} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Pump { + ms: u64, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Gm { + command: String, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Tp { + x: f32, + y: f32, + z: f32, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct RawCs { + opcode: u16, + body_hex: String, +} + +#[derive(Deserialize)] +#[serde(deny_unknown_fields)] +struct Reconnect { + character_id: u32, +} + +enum Command { + Hello, + Pump(Pump), + Gm(Gm), + Tp(Tp), + RawCs(u16, Vec), + State, + DisconnectHard, + Reconnect(u32), + Close, +} + +struct Rejected { + id: Option, + code: &'static str, + fatal: bool, +} + +fn command(request: &Request) -> anyhow::Result { + let params = request.params.clone(); + Ok(match request.method.as_str() { + "hello" | "state" | "disconnect_hard" | "close" => { + serde_json::from_value::(params)?; + match request.method.as_str() { + "hello" => Command::Hello, + "state" => Command::State, + "disconnect_hard" => Command::DisconnectHard, + _ => Command::Close, + } + } + "pump" => { + let p: Pump = serde_json::from_value(params)?; + ensure!(p.ms <= MAX_PUMP_MS, "pump limit"); + Command::Pump(p) + } + "gm" => { + let p: Gm = serde_json::from_value(params)?; + ensure!( + !p.command.trim().is_empty() + && p.command.len() <= MAX_GM + && !p.command.starts_with('/') + && !p.command.chars().any(char::is_control), + "GM command limit/format" + ); + Command::Gm(p) + } + "tp" => { + let p: Tp = serde_json::from_value(params)?; + ensure!( + p.x.is_finite() && p.y.is_finite() && p.z.is_finite(), + "position" + ); + Command::Tp(p) + } + "rawcs" => { + let p: RawCs = serde_json::from_value(params)?; + ensure!(p.body_hex.len() <= MAX_BODY * 2, "raw body limit"); + // Authentication belongs exclusively to the shared session implementation. + ensure!(p.opcode != cs::X2EnterWorldPacket, "authentication packet"); + Command::RawCs(p.opcode, hex::decode(p.body_hex)?) + } + "reconnect" => { + let p: Reconnect = serde_json::from_value(params)?; + ensure!(p.character_id != 0, "character id 0"); + Command::Reconnect(p.character_id) + } + _ => bail!("unknown method"), + }) +} + +/// Errors deliberately contain no request body, config value, credential or packet bytes. +fn parse(line: &[u8]) -> Result<(RequestId, Command), Rejected> { + if line.len() > MAX_LINE { + return Err(Rejected { + id: None, + code: "line_limit", + fatal: true, + }); + } + let r: Request = serde_json::from_slice(line).map_err(|_| Rejected { + id: None, + code: "invalid_request", + fatal: false, + })?; + let reject = |code, fatal| Rejected { + id: Some(r.id.clone()), + code, + fatal, + }; + if r.protocol != PROTOCOL { + return Err(reject("protocol_mismatch", true)); + } + if matches!(&r.id, RequestId::Text(s) if s.is_empty() || s.len() > 64) { + return Err(Rejected { + id: None, + code: "invalid_id", + fatal: false, + }); + } + let cmd = command(&r).map_err(|_| reject("invalid_method_or_params", false))?; + Ok((r.id, cmd)) +} + +/// Bounded even if the sender never terminates an oversized line. A partial final line is +/// rejected, so EOF cannot turn a truncated gameplay request into a command. +fn read_line(reader: &mut impl BufRead) -> Result>, &'static str> { + let mut line = Vec::new(); + loop { + let bytes = reader.fill_buf().map_err(|_| "input_io")?; + if bytes.is_empty() { + return if line.is_empty() { + Ok(None) + } else { + Err("truncated_line") + }; + } + let newline = bytes.iter().position(|&b| b == b'\n'); + let len = newline.unwrap_or(bytes.len()); + if len > MAX_LINE.saturating_sub(line.len()) { + return Err("line_limit"); + } + line.extend_from_slice(&bytes[..len]); + reader.consume(len + usize::from(newline.is_some())); + if newline.is_some() { + if line.last() == Some(&b'\r') { + line.pop(); + } + return Ok(Some(line)); + } + } +} + +/// Terminal notification cannot sit behind queued gameplay. In particular EOF cancels +/// the active action and invalidates every queued line before another action is polled. +struct Input { + lines: mpsc::Receiver>, + terminal: watch::Receiver>, +} + +fn read_input( + mut reader: impl BufRead, + lines: mpsc::Sender>, + terminal: watch::Sender>, +) { + let reason = loop { + match read_line(&mut reader) { + Ok(Some(line)) => match lines.try_send(line) { + Ok(()) => {} + Err(mpsc::error::TrySendError::Full(_)) => break "input_queue_limit", + Err(mpsc::error::TrySendError::Closed(_)) => return, + }, + Ok(None) => break "eof", + Err(code) => break code, + } + }; + terminal.send_replace(Some(reason)); +} + +async fn termination(terminal: &mut watch::Receiver>) -> &'static str { + loop { + let reason = *terminal.borrow_and_update(); + if let Some(reason) = reason { + return reason; + } + if terminal.changed().await.is_err() { + return "eof"; + } + } +} + +/// Timer futures provide wakeups, but an already-expired timer can initially poll Pending. +/// Check synchronously before polling gameplay or consuming another command. EOF retains +/// priority, including a closed input worker that has not published a terminal value. +fn check_stop( + terminal: &watch::Receiver>, + until: Instant, + output_until: Option, + deadline_reason: &'static str, +) -> anyhow::Result> { + if let Some(reason) = *terminal.borrow() { + return Ok(Some(reason)); + } + if terminal.has_changed().is_err() { + return Ok(Some("eof")); + } + let now = Instant::now(); + if now >= until { + return Ok(Some(deadline_reason)); + } + if let Some(until) = output_until { + ensure!(now < until, "stdout budget exhausted"); + } + Ok(None) +} + +struct Output { + bytes: Vec, + ack: oneshot::Sender>, +} + +/// Detached, bounded stdio workers avoid Tokio's uncancellable blocking stdin read keeping +/// the runtime alive after deadline. They own no sockets and are never joined on shutdown. +fn stdio() -> anyhow::Result<(Input, mpsc::Sender)> { + let (input_tx, input_rx) = mpsc::channel(INPUT_QUEUE); + let (terminal_tx, terminal_rx) = watch::channel(None); + std::thread::Builder::new() + .name("control-input".into()) + .spawn(move || { + read_input(std::io::stdin().lock(), input_tx, terminal_tx); + })?; + let (output_tx, mut output_rx) = mpsc::channel::(1); + // Use an owned OS handle rather than holding Rust's global stdout lock. A blocked + // writer must not prevent runtime/process cleanup after its acknowledgement times out. + #[cfg(windows)] + let mut stdout = { + use std::os::windows::io::AsHandle; + std::fs::File::from(std::io::stdout().as_handle().try_clone_to_owned()?) + }; + #[cfg(unix)] + let mut stdout = { + use std::os::fd::AsFd; + std::fs::File::from(std::io::stdout().as_fd().try_clone_to_owned()?) + }; + #[cfg(not(any(windows, unix)))] + let mut stdout = std::io::stdout(); + std::thread::Builder::new() + .name("control-output".into()) + .spawn(move || { + while let Some(out) = output_rx.blocking_recv() { + let result = stdout.write_all(&out.bytes).and_then(|()| stdout.flush()); + let failed = result.is_err(); + let _ = out.ack.send(result); + if failed { + break; + } + } + })?; + Ok(( + Input { + lines: input_rx, + terminal: terminal_rx, + }, + output_tx, + )) +} + +struct QueuedOutput { + bytes: Vec, + until: Instant, +} + +struct InFlight { + ack: oneshot::Receiver>, + until: Instant, + len: usize, +} + +struct Reporter { + output: mpsc::Sender, + deadline: Instant, + budget: Instant, + seq: u64, + queue: VecDeque, + queued_bytes: usize, + flight: Option, +} + +impl Reporter { + fn new(output: mpsc::Sender, deadline: Instant) -> Self { + Self { + output, + deadline, + budget: deadline, + seq: 0, + queue: VecDeque::new(), + queued_bytes: 0, + flight: None, + } + } + + fn write(&mut self, mut value: Value) -> anyhow::Result<()> { + value["protocol"] = PROTOCOL.into(); + let mut bytes = serde_json::to_vec(&value)?; + bytes.push(b'\n'); + ensure!( + self.queue.len() + usize::from(self.flight.is_some()) < OUTPUT_COUNT + && bytes.len() <= OUTPUT_BYTES.saturating_sub(self.queued_bytes), + "stdout queue limit" + ); + self.queued_bytes += bytes.len(); + self.queue.push_back(QueuedOutput { + bytes, + until: self.budget, + }); + Ok(()) + } + + fn events(&mut self, rec: &Recorder) -> anyhow::Result<()> { + for event in rec.take_live_events()? { + self.seq += 1; + self.write(json!({"type": "event", "seq": self.seq, "event": event}))?; + } + Ok(()) + } + + fn response( + &mut self, + id: Option, + result: Result, + ) -> anyhow::Result<()> { + let value = match result { + Ok(value) => json!({"type": "response", "id": id, "ok": true, + "result": value, "event_seq": self.seq}), + Err(code) => json!({"type": "response", "id": id, "ok": false, + "error": {"code": code}, "event_seq": self.seq}), + }; + self.write(value) + } + + fn has_work(&self) -> bool { + self.flight.is_some() || !self.queue.is_empty() + } + + fn next_deadline(&self) -> Option { + self.queue + .iter() + .map(|queued| queued.until) + .chain(self.flight.as_ref().map(|flight| flight.until)) + .min() + } + + /// One cancellation-safe output step, polled alongside action/EOF/deadline futures. + /// The ack and queued bytes live on Reporter, so losing a select race never loses them. + /// Every frame retains the shared action budget at enqueue time; acknowledgments cannot + /// restart a command's deadline. A one-second stalled-writer ceiling is additional. + async fn progress(&mut self) -> anyhow::Result<()> { + if let Some(until) = self.next_deadline() { + ensure!(Instant::now() < until, "stdout budget exhausted"); + } + if self.flight.is_none() { + let Some(front) = self.queue.front() else { + return std::future::pending().await; + }; + let until = self + .next_deadline() + .unwrap_or(front.until) + .min(Instant::now() + Duration::from_secs(1)); + ensure!(Instant::now() < until, "stdout budget exhausted"); + let permit = tokio::time::timeout_at(until, self.output.reserve()) + .await + .context("stdout budget")? + .context("stdout worker closed")?; + ensure!(Instant::now() < until, "stdout budget exhausted"); + let queued = self.queue.pop_front().context("stdout queue empty")?; + let len = queued.bytes.len(); + let (ack, completed) = oneshot::channel(); + permit.send(Output { + bytes: queued.bytes, + ack, + }); + self.flight = Some(InFlight { + ack: completed, + until, + len, + }); + // Starting a write can introduce an earlier stalled-writer ceiling. Return + // control so drive/serve recompute it before any further action poll. + return Ok(()); + } + let flight = self.flight.as_mut().context("stdout ack missing")?; + ensure!(Instant::now() < flight.until, "stdout budget exhausted"); + tokio::time::timeout_at(flight.until, &mut flight.ack) + .await + .context("stdout budget")? + .context("stdout worker stopped")??; + ensure!(Instant::now() < flight.until, "stdout budget exhausted"); + let flight = self.flight.take().context("stdout ack missing")?; + self.queued_bytes -= flight.len; + Ok(()) + } + + /// Called only after sockets are closed. Earlier command budgets remain in force. + async fn finish(&mut self) -> anyhow::Result<()> { + let until = (Instant::now() + Duration::from_secs(1)) + .min(self.deadline + Duration::from_millis(200)); + tokio::time::timeout_at(until, async { + while self.has_work() { + self.progress().await?; + } + Ok::<_, anyhow::Error>(()) + }) + .await + .context("terminal stdout budget")??; + Ok(()) + } +} + +struct Controller { + cfg: BotConfig, + rec: Recorder, + session: Option, + handshaken: bool, + character_id: Option, + generation: u32, + started: Instant, + clock: u32, +} + +fn reconnect_allowed(connected: bool, previous: Option, requested: u32) -> bool { + !connected && requested != 0 && previous == Some(requested) +} + +impl Controller { + fn state(&self) -> Value { + let observed = self.session.as_ref().map(|session| { + let game = &session.game; + json!({ + "account_id": game.account_id, "character_id": game.state.selected_char, + "self_obj": game.state.self_obj, "position": game.state.observed_self_pos, + "position_source": "SCUnitState/SCOneUnitMovement/SCTeleportUnit", + "observation_seq": game.state.observation_seq, + "observation_errors": game.state.observation_errors, + "units_seen": game.state.units.len(), "doodads_seen": game.state.doodads.len() + }) + }); + json!({"source": "client_observation", "authoritative": false, + "connected": self.session.is_some(), "character_id": self.character_id, + "session_generation": self.generation, + "sampled_t_ms": self.started.elapsed().as_millis(), "observed": observed}) + } + + async fn disconnect(&mut self, reason: &str) -> Value { + let old = self.session.take(); + let old_self_obj = old.as_ref().map(|s| s.game.state.self_obj); + let had_session = old.is_some(); + if let Some(session) = old { + session.disconnect_hard().await; + } + json!({"reason": reason, "t_ms": self.started.elapsed().as_millis(), + "session_generation": self.generation, "old_self_obj": old_self_obj, + "had_session": had_session, "game_read_closed": had_session, + "game_write_closed": had_session, "stream_closed": had_session, + "closure_scope": "local socket handles", "sent_leave_world": false}) + } + + async fn execute(&mut self, cmd: Command, until: Instant) -> anyhow::Result { + match cmd { + Command::Hello => { + ensure!(!self.handshaken, "already handshaken"); + self.handshaken = true; + let session = scenario::connect_control(&self.cfg, &self.rec, None).await?; + self.character_id = Some(session.game.state.selected_char); + self.generation += 1; + self.session = Some(session); + Ok(json!({"ready": true, "state": self.state()})) + } + Command::Reconnect(id) => { + ensure!( + reconnect_allowed(self.session.is_some(), self.character_id, id), + "reconnect identity/session" + ); + let session = scenario::connect_control(&self.cfg, &self.rec, Some(id)).await?; + self.generation += 1; + self.session = Some(session); + Ok(json!({"ready": true, "state": self.state()})) + } + Command::State => Ok(self.state()), + Command::DisconnectHard => { + self.rec.flush_live()?; + Ok(self.disconnect("disconnect_hard").await) + } + Command::Close => { + let closed = self.disconnect("close").await; + self.rec.flush_live()?; + Ok(closed) + } + command => { + let game = &mut self.session.as_mut().context("no connected session")?.game; + match command { + Command::Pump(p) => { + let until = (Instant::now() + Duration::from_millis(p.ms)).min( + until + .checked_sub(Duration::from_millis(20)) + .unwrap_or(until), + ); + while Instant::now() < until { + game.recv_within(until.saturating_duration_since(Instant::now())) + .await?; + } + } + Command::Gm(p) => scenario::control_gm(game, &p.command).await?, + Command::Tp(p) => { + self.clock = self.clock.wrapping_add(1500); + scenario::control_tp(game, p.x, p.y, p.z, self.clock, until).await?; + } + Command::RawCs(opcode, body) => game.send_cs(opcode, &body).await?, + _ => unreachable!("handled lifecycle method"), + } + // Control consumers use raw events, not scenario-specific accumulated histories. + game.state.events.clear(); + game.state.social.clear(); + Ok(self.state()) + } + } + } + + async fn idle(&mut self) -> anyhow::Result<()> { + if let Some(session) = self.session.as_mut() { + for _ in 0..128 { + if session + .game + .recv_within(Duration::from_millis(1)) + .await? + .is_none() + { + break; + } + } + session.game.state.events.clear(); + session.game.state.social.clear(); + } + Ok(()) + } +} + +enum Completion { + Done(anyhow::Result), + Stopped(&'static str), +} + +/// No output branch awaits a batch. Action receive/keep-alive, terminal input, and +/// command/global timers remain independently pollable while an output ack is delayed. +async fn drive( + future: impl Future>, + until: Instant, + rec: &Recorder, + report: &mut Reporter, + input: &mut Input, +) -> anyhow::Result { + tokio::pin!(future); + let until = until.min(report.deadline); + let terminal = input.terminal.clone(); + let mut tick = tokio::time::interval(Duration::from_millis(20)); + loop { + let output_until = report.next_deadline(); + if let Some(reason) = check_stop(&terminal, until, output_until, "command_deadline")? { + return Ok(Completion::Stopped(reason)); + } + tokio::select! { + biased; + reason = termination(&mut input.terminal) => return Ok(Completion::Stopped(reason)), + _ = tokio::time::sleep_until(until) => return Ok(Completion::Stopped("command_deadline")), + _ = tokio::time::sleep_until(output_until.unwrap_or(until)), if output_until.is_some() => bail!("stdout budget exhausted"), + result = std::future::poll_fn(|cx| { + // A select can remain suspended across many executor polls. The loop + // check alone does not guard a ready action on a later wakeup. + match check_stop(&terminal, until, output_until, "command_deadline") { + Ok(Some(reason)) => std::task::Poll::Ready(Ok(Completion::Stopped(reason))), + Err(error) => std::task::Poll::Ready(Err(error)), + Ok(None) => future.as_mut().poll(cx).map(|result| Ok(Completion::Done(result))), + } + }) => return result, + result = report.progress(), if output_until.is_some() => { result?; }, + _ = tick.tick() => report.events(rec)?, + } + } +} + +async fn serve( + controller: &mut Controller, + report: &mut Reporter, + input: &mut Input, +) -> anyhow::Result<&'static str> { + let mut ids = HashSet::new(); + let mut count = 0; + let mut next_poll = Instant::now(); + report.write(json!({"type": "capabilities", "capabilities": describe()}))?; + loop { + if let Some(reason) = check_stop( + &input.terminal, + report.deadline, + report.next_deadline(), + "deadline", + )? { + return Ok(reason); + } + // Poll receive/keep-alive even if stdin continuously supplies commands. + if Instant::now() >= next_poll { + let rec = controller.rec.clone(); + let idle = async { + controller.idle().await?; + Ok(Value::Null) + }; + match drive(idle, report.deadline, &rec, report, input).await? { + Completion::Done(Ok(_)) => {} + Completion::Done(Err(_)) => { + let closed = controller.disconnect("session_error").await; + report.write(json!({"type": "lifecycle", "closed": closed}))?; + } + Completion::Stopped("command_deadline") => return Ok("deadline"), + Completion::Stopped(reason) => return Ok(reason), + } + report.events(&rec)?; + next_poll = Instant::now() + Duration::from_millis(50); + } + let output_until = report.next_deadline(); + if let Some(reason) = + check_stop(&input.terminal, report.deadline, output_until, "deadline")? + { + return Ok(reason); + } + let line = tokio::select! { + biased; + reason = termination(&mut input.terminal) => return Ok(reason), + _ = tokio::time::sleep_until(report.deadline) => return Ok("deadline"), + _ = tokio::time::sleep_until(output_until.unwrap_or(report.deadline)), if output_until.is_some() => bail!("stdout budget exhausted"), + _ = tokio::time::sleep_until(next_poll) => continue, + result = report.progress(), if output_until.is_some() => { result?; continue; }, + line = input.lines.recv() => match line { Some(line) => line, None => return Ok("eof") }, + }; + if let Some(reason) = check_stop( + &input.terminal, + report.deadline, + report.next_deadline(), + "deadline", + )? { + return Ok(reason); + } + count += 1; + if count > MAX_COMMANDS { + report.response(None, Err("command_limit"))?; + return Ok("command_limit"); + } + let (id, cmd) = match parse(&line) { + Ok(parsed) => parsed, + Err(e) => { + if let Some(id) = &e.id { + if !ids.insert(id.clone()) { + report.response(None, Err("duplicate_id"))?; + return Ok("duplicate_id"); + } + } + report.response(e.id, Err(e.code))?; + if e.fatal { + return Ok(e.code); + } + continue; + } + }; + if !ids.insert(id.clone()) { + report.response(None, Err("duplicate_id"))?; + return Ok("duplicate_id"); + } + if !controller.handshaken && !matches!(&cmd, Command::Hello) { + report.response(Some(id), Err("handshake_required"))?; + return Ok("handshake_required"); + } + if (controller.handshaken && matches!(&cmd, Command::Hello)) + || matches!(&cmd, Command::Reconnect(id) + if !reconnect_allowed(controller.session.is_some(), controller.character_id, *id)) + { + report.response(Some(id), Err("invalid_session_state"))?; + continue; + } + let closing = matches!(&cmd, Command::Close); + let connecting = matches!(&cmd, Command::Hello | Command::Reconnect(_)); + let allowance = if connecting { + CONNECT_TIMEOUT + } else { + COMMAND_TIMEOUT + }; + let until = (Instant::now() + allowance).min(report.deadline); + // Local state/cleanup remain usable in the global reporting slice; they do not + // wait for a gameplay acknowledgment. Network actions stop before that slice. + let work_until = if matches!( + &cmd, + Command::State | Command::Close | Command::DisconnectHard + ) { + until + } else { + until + .checked_sub(REPORT_RESERVE) + .unwrap_or_else(Instant::now) + .max(Instant::now()) + }; + report.budget = until; + controller.rec.step(&format!("control.{count}")); + let rec = controller.rec.clone(); + let done = drive( + controller.execute(cmd, work_until), + work_until, + &rec, + report, + input, + ) + .await?; + let mut stop = None; + let result = match done { + Completion::Done(Ok(value)) => Ok(value), + Completion::Done(Err(_)) => { + // Native parser failures can retain input. No Display/Debug/cause logging. + tracing::debug!("control action failed"); + let code = if Instant::now() >= work_until { + "command_deadline" + } else { + "session_error" + }; + let closed = controller.disconnect(code).await; + report.write(json!({"type": "lifecycle", "closed": closed}))?; + Err(code) + } + Completion::Stopped(code) => { + let closed = controller.disconnect(code).await; + report.write(json!({"type": "lifecycle", "closed": closed}))?; + if code != "command_deadline" || Instant::now() >= report.deadline { + stop = Some(code); + } + Err(code) + } + }; + report.events(&rec)?; + report.response(Some(id), result)?; + report.budget = report.deadline; + if closing { + return Ok("close"); + } + if let Some(reason) = stop { + return Ok(reason); + } + } +} + +pub(crate) async fn run(cfg: BotConfig, capture: &Path, deadline_ms: u64) -> anyhow::Result<()> { + ensure!( + (1..=MAX_DEADLINE_MS).contains(&deadline_ms), + "deadline-ms must be 1..=600000" + ); + ensure!( + !cfg.create_new_character, + "control cannot create characters" + ); + let started = Instant::now(); + let rec = Recorder::incremental_game(capture)?; + let (mut input, output) = stdio()?; + let mut report = Reporter::new(output, started + Duration::from_millis(deadline_ms)); + let mut controller = Controller { + cfg, + rec: rec.clone(), + session: None, + handshaken: false, + character_id: None, + generation: 0, + started, + clock: 40_000, + }; + let outcome = match tokio::time::timeout_at( + report.deadline, + serve(&mut controller, &mut report, &mut input), + ) + .await + { + Ok(result) => result, + Err(_) => Ok("deadline"), + }; + let reason = outcome.as_ref().copied().unwrap_or("control_error"); + // Always clean up before attempting terminal output, including a broken stdout/capture. + let closed = controller.disconnect(reason).await; + let flushed = rec.flush_live(); + if outcome.is_ok() { + report.budget = report.deadline + Duration::from_millis(200); + report.events(&rec)?; + report.write(json!({"type": "closed", "closed": closed}))?; + } + report.finish().await?; + flushed?; + let reason = outcome?; + ensure!( + matches!(reason, "close" | "eof"), + "control stopped: {reason}" + ); + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + use std::io::{BufReader, Cursor}; + use std::sync::{ + atomic::{AtomicBool, Ordering}, + Arc, + }; + + struct Released(Arc); + + impl Drop for Released { + fn drop(&mut self) { + self.0.store(true, Ordering::SeqCst); + } + } + + fn request(method: &str, params: Value) -> Vec { + serde_json::to_vec( + &json!({"protocol": PROTOCOL, "id": "probe-1", "method": method, "params": params}), + ) + .unwrap() + } + + #[test] + fn strict_envelope_rejects_incompatible_or_ambiguous_commands() { + for input in [ + br#"{"id":1,"method":"hello","params":{}}"#.as_slice(), + br#"{"protocol":"aaemu-control/2","id":1,"method":"hello","params":{}}"#, + br#"{"protocol":"aaemu-control/1","id":null,"method":"hello","params":{}}"#, + br#"{"protocol":"aaemu-control/1","id":1,"method":"hello","params":{},"extra":1}"#, + br#"{"protocol":"aaemu-control/1","id":1,"id":2,"method":"hello","params":{}}"#, + br#"{"protocol":"aaemu-control/1","id":1,"method":"pump","params":{"ms":0,"ms":1}}"#, + br#"{"protocol":"aaemu-control/1","id":1,"method":"hello","params":null}"#, + b"\xff", + b"", + ] { + assert!(parse(input).is_err(), "accepted incompatible request"); + } + assert!(matches!( + parse(&request("hello", json!({}))), + Ok((_, Command::Hello)) + )); + let wrong = parse(br#"{"protocol":"wrong","id":7,"method":"hello","params":{}}"#) + .err() + .unwrap(); + assert!(wrong.fatal); + assert_eq!(wrong.id, Some(RequestId::Number(7))); + } + + #[test] + fn literal_packet_and_action_limits_do_not_coerce_or_truncate() { + for (method, params) in [ + ("pump", json!({"ms": MAX_PUMP_MS + 1})), + ("pump", json!({"ms": -1})), + ("state", json!({"authoritative": true})), + ("gm", json!({"command": "x".repeat(MAX_GM + 1)})), + ("gm", json!({"command": "move 1 2 3\nitem add self 1"})), + ("rawcs", json!({"opcode": "0x03a", "body_hex": "00"})), + ("rawcs", json!({"opcode": 65536, "body_hex": "00"})), + ("rawcs", json!({"opcode": 58, "body_hex": "0"})), + ("rawcs", json!({"opcode": 58, "body_hex": "00 01"})), + ( + "rawcs", + json!({"opcode": 58, "body_hex": "00".repeat(MAX_BODY + 1)}), + ), + ( + "rawcs", + json!({"opcode": cs::X2EnterWorldPacket, "body_hex": "00"}), + ), + ("reconnect", json!({"character_id": 0})), + ] { + assert!( + parse(&request(method, params)).is_err(), + "accepted invalid {method}" + ); + } + let (_, cmd) = parse(&request("rawcs", json!({"opcode": 58, "body_hex": "abcd"}))) + .ok() + .unwrap(); + assert!(matches!(cmd, Command::RawCs(58, body) if body == [0xab, 0xcd])); + assert!(parse(&request("pump", json!({"ms": MAX_PUMP_MS}))).is_ok()); + assert!(parse(&request( + "rawcs", + json!({"opcode": 58, "body_hex": "00".repeat(MAX_BODY)}) + )) + .is_ok()); + } + + #[test] + fn framing_handles_split_crlf_and_rejects_truncation_or_unterminated_overflow() { + let mut reader = BufReader::with_capacity(3, Cursor::new(b"{}\r\nsecond\n")); + assert_eq!(read_line(&mut reader).unwrap(), Some(b"{}".to_vec())); + assert_eq!(read_line(&mut reader).unwrap(), Some(b"second".to_vec())); + assert_eq!(read_line(&mut reader).unwrap(), None); + assert_eq!(read_line(&mut Cursor::new(b"{}")), Err("truncated_line")); + assert_eq!( + read_line(&mut Cursor::new(vec![b'a'; MAX_LINE + 1])), + Err("line_limit") + ); + let mut exact = vec![b'a'; MAX_LINE]; + exact.push(b'\n'); + assert_eq!( + read_line(&mut Cursor::new(exact)).unwrap().unwrap().len(), + MAX_LINE + ); + } + + #[test] + fn reconnect_requires_disconnected_session_and_the_exact_prior_character() { + assert!(!reconnect_allowed(false, None, 42)); + assert!(!reconnect_allowed(true, Some(42), 42)); + assert!(!reconnect_allowed(false, Some(42), 43)); + assert!(!reconnect_allowed(false, Some(0), 0)); + assert!(reconnect_allowed(false, Some(42), 42)); + } + + fn input_pair() -> ( + Input, + mpsc::Sender>, + watch::Sender>, + ) { + let (lines, rx) = mpsc::channel(INPUT_QUEUE); + let (terminal, stopped) = watch::channel(None); + ( + Input { + lines: rx, + terminal: stopped, + }, + lines, + terminal, + ) + } + + #[tokio::test] + async fn eof_cancels_an_active_action_without_waiting_for_its_timeout() { + let rec = Recorder::new(false); + let (output, _reader) = mpsc::channel(1); + let until = Instant::now() + CONNECT_TIMEOUT; + let mut report = Reporter::new(output, until); + let (mut input, _lines, terminal) = input_pair(); + terminal.send_replace(Some("eof")); + let released = Arc::new(AtomicBool::new(false)); + let resource = Released(released.clone()); + let result = drive( + async move { + let _resource = resource; + std::future::pending().await + }, + until, + &rec, + &mut report, + &mut input, + ) + .await + .unwrap(); + assert!(matches!(result, Completion::Stopped("eof"))); + assert!(released.load(Ordering::SeqCst)); + } + + #[tokio::test] + async fn expired_deadline_cancels_even_when_input_is_idle() { + let rec = Recorder::new(false); + let (output, _reader) = mpsc::channel(1); + let until = Instant::now(); + let mut report = Reporter::new(output, until); + let (mut input, _lines, _terminal) = input_pair(); + let released = Arc::new(AtomicBool::new(false)); + let resource = Released(released.clone()); + let result = drive( + async move { + let _resource = resource; + std::future::pending().await + }, + until, + &rec, + &mut report, + &mut input, + ) + .await + .unwrap(); + assert!(matches!(result, Completion::Stopped("command_deadline"))); + assert!(released.load(Ordering::SeqCst)); + } + + #[tokio::test] + async fn already_expired_command_or_global_deadline_never_polls_ready_action() { + for global_expired in [false, true] { + let rec = Recorder::new(false); + let (output, _consumer) = mpsc::channel(1); + let expired = Instant::now(); + let later = expired + CONNECT_TIMEOUT; + let (command_until, global_until) = if global_expired { + (later, expired) + } else { + (expired, later) + }; + let mut report = Reporter::new(output, global_until); + let (mut input, _lines, _terminal) = input_pair(); + let polled = AtomicBool::new(false); + let action = async { + polled.store(true, Ordering::SeqCst); + Ok(Value::Null) + }; + let result = drive(action, command_until, &rec, &mut report, &mut input) + .await + .unwrap(); + assert!(matches!(result, Completion::Stopped("command_deadline"))); + assert!( + !polled.load(Ordering::SeqCst), + "an already-expired ceiling allowed ready gameplay" + ); + } + } + + #[tokio::test] + async fn eof_precedes_expired_budgets_without_polling_ready_action() { + for published in [false, true] { + let rec = Recorder::new(false); + let (output, _consumer) = mpsc::channel(1); + let until = Instant::now(); + let mut report = Reporter::new(output, until); + report.write(json!({"type":"capabilities"})).unwrap(); + let (mut input, _lines, terminal) = input_pair(); + if published { + terminal.send_replace(Some("eof")); + } + drop(terminal); + let polled = AtomicBool::new(false); + let action = async { + polled.store(true, Ordering::SeqCst); + Ok(Value::Null) + }; + let result = drive(action, until, &rec, &mut report, &mut input) + .await + .unwrap(); + assert!(matches!(result, Completion::Stopped("eof"))); + assert!(!polled.load(Ordering::SeqCst)); + } + } + + fn live_recorder() -> Recorder { + let rec = Recorder::incremental_game_to(std::io::sink()); + rec.control_game_ready(true); + rec + } + + #[tokio::test] + async fn delayed_output_acks_do_not_suspend_game_keepalive_or_command_deadline() { + use aaemu_commons::net::FrameCodec; + use aaemu_game::opcodes::{pp, sc}; + use aaemu_testclient::game::GameClient; + use aaemu_testclient::record::{Channel, Dir}; + use futures::StreamExt; + use std::sync::atomic::AtomicUsize; + use tokio_util::codec::FramedRead; + + let rec = live_recorder(); + let (io, peer) = tokio::io::duplex(64 * 1024); + let mut game = GameClient::from_io(io, rec.clone()); + game.account_id = 1; + game.ping_every = Duration::from_millis(20); + let peer = tokio::spawn(async move { + let mut peer = FramedRead::new(peer, FrameCodec); + let mut pings = 0; + while let Some(packet) = peer.next().await { + let packet = packet.unwrap(); + assert_eq!(packet[1], 2); + assert_eq!(u16::from_le_bytes([packet[2], packet[3]]), pp::PingPacket); + pings += 1; + } + pings + }); + let (output, mut consumed) = mpsc::channel::(1); + let acknowledgments = Arc::new(AtomicUsize::new(0)); + let counted = acknowledgments.clone(); + let consumer = tokio::spawn(async move { + while let Some(packet) = consumed.recv().await { + tokio::time::sleep(Duration::from_millis(25)).await; + if packet.ack.send(Ok(())).is_err() { + break; + } + counted.fetch_add(1, Ordering::SeqCst); + } + }); + let until = Instant::now() + Duration::from_millis(300); + let mut report = Reporter::new(output, until + Duration::from_secs(1)); + report.budget = until; + // This batch needs at least 800ms of acknowledgments. The action has 300ms. + for _ in 0..32 { + rec.push( + Channel::Game, + Dir::S2C, + 1, + sc::SCErrorMsgPacket, + "ambient", + &[7, 0], + ); + } + report.events(&rec).unwrap(); + let (mut input, _lines, _terminal) = input_pair(); + let action = async { + loop { + game.recv_within(Duration::from_millis(5)).await?; + } + }; + let done = tokio::time::timeout( + Duration::from_secs(2), + drive(action, until, &rec, &mut report, &mut input), + ) + .await + .unwrap() + .unwrap(); + assert!(matches!(done, Completion::Stopped("command_deadline"))); + assert!(acknowledgments.load(Ordering::SeqCst) >= 2); + assert!(acknowledgments.load(Ordering::SeqCst) < 32); + assert!(report.has_work()); + game.disconnect_hard().await; + let pings = tokio::time::timeout(Duration::from_secs(1), peer) + .await + .unwrap() + .unwrap(); + assert!( + pings >= 2, + "slow output starved the actual GameClient keep-alive path" + ); + consumer.abort(); + let _ = consumer.await; + } + + #[tokio::test] + async fn active_action_plus_pending_rawcs_and_eof_never_sends_queued_gameplay() { + use aaemu_commons::net::FrameCodec; + use aaemu_testclient::game::GameClient; + use futures::StreamExt; + use tokio_util::codec::FramedRead; + + let rec = live_recorder(); + let (io, peer) = tokio::io::duplex(64 * 1024); + let mut game = GameClient::from_io(io, rec.clone()); + game.account_id = 1; + let peer = tokio::spawn(async move { + let mut peer = FramedRead::new(peer, FrameCodec); + let mut packets = Vec::new(); + while let Some(packet) = peer.next().await { + packets.push(packet.unwrap()); + } + packets + }); + let (output, _consumer) = mpsc::channel(1); + let until = Instant::now() + Duration::from_secs(1); + let mut report = Reporter::new(output, until); + let (mut input, lines, terminal) = input_pair(); + let (started, ready) = oneshot::channel(); + let producer = tokio::spawn(async move { + ready.await.unwrap(); + let mut raw = request("rawcs", json!({"opcode":58,"body_hex":"abcd"})); + raw.push(b'\n'); + // The real bounded input worker sees a queued rawcs followed by EOF. + read_input(Cursor::new(raw), lines, terminal); + }); + let action = async { + let _ = started.send(()); + loop { + game.recv_within(Duration::from_millis(10)).await?; + } + }; + let done = drive(action, until, &rec, &mut report, &mut input) + .await + .unwrap(); + assert!(matches!(done, Completion::Stopped("eof"))); + producer.await.unwrap(); + let queued = input.lines.try_recv().unwrap(); + assert!(matches!(parse(&queued), Ok((_, Command::RawCs(58, _))))); + game.disconnect_hard().await; + let packets = tokio::time::timeout(Duration::from_secs(1), peer) + .await + .unwrap() + .unwrap(); + assert!(!packets.is_empty()); + assert!( + packets.iter().all(|packet| packet[1] == 2), + "queued rawcs or CSLeaveWorld escaped after EOF" + ); + } + + #[test] + fn input_queue_overflow_signals_terminal_without_blocking_the_reader() { + let (mut input, lines, terminal) = input_pair(); + read_input( + Cursor::new(b"{}\n".repeat(INPUT_QUEUE + 1)), + lines, + terminal, + ); + assert_eq!(*input.terminal.borrow(), Some("input_queue_limit")); + let mut count = 0; + while input.lines.try_recv().is_ok() { + count += 1; + } + assert_eq!(count, INPUT_QUEUE); + } + + #[tokio::test] + async fn earlier_command_output_budget_applies_even_behind_a_longer_lived_head() { + let rec = live_recorder(); + let (output, _consumer) = mpsc::channel(1); + let until = Instant::now() + CONNECT_TIMEOUT; + let mut report = Reporter::new(output, until); + report.write(json!({"type":"capabilities"})).unwrap(); + report.budget = Instant::now(); + report + .response(Some(RequestId::Number(1)), Ok(Value::Null)) + .unwrap(); + let (mut input, _lines, _terminal) = input_pair(); + let polled = Arc::new(AtomicBool::new(false)); + let observed = polled.clone(); + let action = async move { + observed.store(true, Ordering::SeqCst); + Ok(Value::Null) + }; + let result = drive(action, until, &rec, &mut report, &mut input).await; + assert!(result.is_err()); + assert!( + !polled.load(Ordering::SeqCst), + "expired output budget allowed later gameplay" + ); + } + + #[tokio::test] + async fn expired_output_budget_blocks_ready_action_with_an_ack_in_flight() { + for expired_flight in [false, true] { + let rec = live_recorder(); + let (output, mut consumer) = mpsc::channel(1); + let until = Instant::now() + CONNECT_TIMEOUT; + let mut report = Reporter::new(output, until); + report.write(json!({"type":"capabilities"})).unwrap(); + // Start a real output write, but withhold its acknowledgment. No sleep or + // timer-driver behavior is needed to inject an expired queue/ack budget. + report.progress().await.unwrap(); + let unacknowledged = consumer.try_recv().unwrap(); + assert!(report.flight.is_some()); + if expired_flight { + report.flight.as_mut().unwrap().until = Instant::now(); + } else { + report.budget = Instant::now(); + } + report + .response(Some(RequestId::Number(1)), Ok(Value::Null)) + .unwrap(); + let (mut input, _lines, _terminal) = input_pair(); + let polled = AtomicBool::new(false); + let action = async { + polled.store(true, Ordering::SeqCst); + Ok(Value::Null) + }; + let result = drive(action, until, &rec, &mut report, &mut input).await; + assert!(result.is_err()); + assert!(!polled.load(Ordering::SeqCst)); + // Terminal draining must also honor the earlier queued budget while a + // longer-lived ack is in flight, rather than consuming that ack first. + assert!(report.progress().await.is_err()); + assert!(consumer.try_recv().is_err()); + drop(unacknowledged); + } + } + + #[tokio::test] + async fn serve_checks_expired_budgets_before_consuming_queued_gameplay() { + for (expired_flight, eof) in [(false, false), (true, false), (false, true)] { + let rec = live_recorder(); + let cfg = serde_json::from_value(json!({"login":"127.0.0.1:1","user":"fixture", + "password":"fixture-only","character":"Owner"})) + .unwrap(); + // No sockets: any attempted rawcs would produce a session error. Leaving + // the request queued proves serve stops before parsing or executing it. + let mut controller = Controller { + cfg, + rec, + session: None, + handshaken: true, + character_id: Some(42), + generation: 1, + started: Instant::now(), + clock: 40000, + }; + let until = Instant::now() + CONNECT_TIMEOUT; + let (output, mut consumer) = mpsc::channel(1); + let mut report = Reporter::new(output, until); + report.write(json!({"type":"capabilities"})).unwrap(); + let unacknowledged = if expired_flight { + report.progress().await.unwrap(); + report.flight.as_mut().unwrap().until = Instant::now(); + Some(consumer.try_recv().unwrap()) + } else { + None + }; + report.budget = if expired_flight { + until + } else { + Instant::now() + }; + report + .response(Some(RequestId::Number(1)), Ok(Value::Null)) + .unwrap(); + let (mut input, lines, terminal) = input_pair(); + let rawcs = request("rawcs", json!({"opcode":58,"body_hex":"abcd"})); + lines.try_send(rawcs.clone()).unwrap(); + if eof { + terminal.send_replace(Some("eof")); + } + let queued = report.queue.len(); + let result = serve(&mut controller, &mut report, &mut input).await; + if eof { + assert_eq!(result.unwrap(), "eof"); + } else { + assert!(result.is_err()); + } + assert_eq!(input.lines.try_recv().unwrap(), rawcs); + assert_eq!(report.queue.len(), queued + 1); // Only serve's capabilities. + assert!(consumer.try_recv().is_err()); + assert!(controller.session.is_none()); + drop(unacknowledged); + } + } + + async fn timeout_serve_case(end_with_eof: bool) { + use aaemu_testclient::game::GameClient; + use aaemu_testclient::login::LoginClient; + use aaemu_testclient::stream::StreamClient; + use std::sync::Mutex; + use tokio::io::AsyncReadExt; + use tokio::net::TcpListener; + + // Source-only fixture: ephemeral loopback transports, no emulator/auth/DB. Start + // with an established session so the full serve path executes the real tp method. + let rec = live_recorder(); + let game_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let stream_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let login_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let mut game = GameClient::connect( + &game_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let game_peer = game_listener.accept().await.unwrap().0; + let stream = StreamClient::connect( + &stream_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let stream_peer = stream_listener.accept().await.unwrap().0; + let login = LoginClient::connect( + &login_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let login_peer = login_listener.accept().await.unwrap().0; + game.account_id = 1; + game.state.selected_char = 42; + game.state.self_obj = 77; + game.state.observed_self_pos = Some((1.0, 2.0, 3.0)); + let peers = [game_peer, stream_peer, login_peer].map(|mut peer| { + tokio::spawn(async move { + let mut bytes = Vec::new(); + peer.read_to_end(&mut bytes).await.unwrap(); + bytes + }) + }); + let cfg: BotConfig = serde_json::from_value(json!({"login":"127.0.0.1:1","user":"fixture", + "password":"fixture-only","character":"Owner"})) + .unwrap(); + let started = Instant::now(); + let mut controller = Controller { + cfg, + rec: rec.clone(), + session: Some(ControlSession::new(game, stream, login)), + handshaken: true, + character_id: Some(42), + generation: 1, + started, + clock: 40000, + }; + let until = started + Duration::from_millis(800); + let (output, mut consumed) = mpsc::channel::(1); + let records = Arc::new(Mutex::new(Vec::::new())); + let saved = records.clone(); + let (observed, mut responses) = mpsc::channel::(4); + let consumer = tokio::spawn(async move { + while let Some(frame) = consumed.recv().await { + let value: Value = serde_json::from_slice(&frame.bytes).unwrap(); + saved.lock().unwrap().push(value.clone()); + frame.ack.send(Ok(())).unwrap(); + if value["type"] == "response" { + observed.send(value).await.unwrap(); + } + } + }); + let mut report = Reporter::new(output, until); + let (mut input, lines, terminal) = input_pair(); + let tp = json!({"protocol":PROTOCOL,"id":1,"method":"tp","params":{"x":10,"y":20,"z":30}}); + lines.send(serde_json::to_vec(&tp).unwrap()).await.unwrap(); + let (finished, done) = oneshot::channel(); + let serving = async { + let result = serve(&mut controller, &mut report, &mut input).await; + let _ = finished.send(()); + result + }; + let script = async move { + let timeout = responses.recv().await.unwrap(); + assert_eq!(timeout["id"], 1); + assert_eq!(timeout["ok"], false); + assert_eq!(timeout["error"]["code"], "command_deadline"); + // All three peer read tasks must observe EOF before any follow-up gameplay. + let mut evidence = Vec::new(); + for peer in peers { + evidence.push( + tokio::time::timeout(Duration::from_secs(1), peer) + .await + .unwrap() + .unwrap(), + ); + } + let state = json!({"protocol":PROTOCOL,"id":2,"method":"state","params":{}}); + lines + .send(serde_json::to_vec(&state).unwrap()) + .await + .unwrap(); + let state = responses.recv().await.unwrap(); + assert_eq!(state["id"], 2); + assert_eq!(state["ok"], true); + assert_eq!(state["result"]["connected"], false); + assert_eq!(state["result"]["character_id"], 42); + if end_with_eof { + terminal.send_replace(Some("eof")); + } + // Keep stdin open in the deadline case until serve itself returns. + let keep_input = (lines, terminal); + let _ = done.await; + drop(keep_input); + evidence + }; + let (result, evidence) = tokio::time::timeout(Duration::from_secs(3), async { + tokio::join!(serving, script) + }) + .await + .unwrap(); + assert_eq!( + result.unwrap(), + if end_with_eof { "eof" } else { "deadline" } + ); + assert!(controller.session.is_none()); + report.finish().await.unwrap(); + { + let records = records.lock().unwrap(); + assert_eq!( + records + .iter() + .filter(|r| r["type"] == "response" && r["id"] == 1) + .count(), + 1 + ); + assert_eq!( + records + .iter() + .filter(|r| r["type"] == "lifecycle" + && r["closed"]["reason"] == "command_deadline" + && r["closed"]["game_read_closed"] == true + && r["closed"]["game_write_closed"] == true + && r["closed"]["stream_closed"] == true) + .count(), + 1 + ); + } + assert!(evidence[1].is_empty() && evidence[2].is_empty()); + let mut wire = evidence[0].as_slice(); + let mut chats = 0; + while !wire.is_empty() { + let len = usize::from(u16::from_le_bytes([wire[0], wire[1]])); + let frame = &wire[2..2 + len]; + if frame[1] == 1 { + let opcode = u16::from_le_bytes([frame[4], frame[5]]); + assert_ne!(opcode, aaemu_game::opcodes::cs::CSLeaveWorldPacket); + if opcode == aaemu_game::opcodes::cs::CSSendChatMessagePacket { + chats += 1; + } + } + wire = &wire[2 + len..]; + } + assert_eq!(chats, 1, "tp must be attempted once, never retried"); + consumer.abort(); + let _ = consumer.await; + } + + #[tokio::test] + async fn full_serve_timeout_reports_once_closes_sockets_and_remains_controllable() { + timeout_serve_case(true).await; + timeout_serve_case(false).await; + } +} diff --git a/rust/crates/aaemu-testclient/src/game.rs b/rust/crates/aaemu-testclient/src/game.rs index ab18fcaf4a..0986fd294d 100644 --- a/rust/crates/aaemu-testclient/src/game.rs +++ b/rust/crates/aaemu-testclient/src/game.rs @@ -1,10 +1,10 @@ //! Game server client (C2G / G2C + the proxy channel) for the 1.2 protocol. //! //! Every frame payload is `[0xDD][level]...`: level 1 (game) carries `[hash][count][u16 opcode]`, -//! level 2 (proxy / CryNetwork) just `[u16 opcode]`. 1.2 traffic is neither encrypted nor -//! compressed. +//! level 2 (proxy / CryNetwork) just `[u16 opcode]`. Traffic is unencrypted; native level-4 +//! game batches carry raw DEFLATE. -use std::collections::{HashMap, HashSet}; +use std::collections::{HashMap, HashSet, VecDeque}; use std::time::{Duration, Instant}; use aaemu_commons::net::FrameCodec; @@ -12,7 +12,7 @@ use aaemu_commons::PacketStream; use aaemu_game::opcodes::{cs, name_of, pp, sc}; use anyhow::{anyhow, bail, Context}; use futures::{SinkExt, StreamExt}; -use tokio::net::tcp::OwnedWriteHalf; +use tokio::io::{AsyncRead, AsyncWrite}; use tokio::net::TcpStream; use tokio::sync::mpsc; use tokio_util::codec::{FramedRead, FramedWrite}; @@ -24,6 +24,235 @@ pub const LEVEL_PROXY: u8 = 2; /// `CompressedGamePackets` (`DD04`). pub const LEVEL_COMPRESSED: u8 = 4; +/// The transport has a u16 frame length. Batches may compress at most 1 MiB into that +/// frame and contain at most 4096 entries (enough for the native all-skill cooldown reset). +/// Every expanded entry must also fit a normal level-1 frame. Limits apply before copies +/// and before inflater output growth, not just when events reach the recorder. +pub const MAX_GAME_FRAME: usize = u16::MAX as usize; +pub const MAX_BATCH_BYTES: usize = 1024 * 1024; +pub const MAX_BATCH_PACKETS: usize = 4096; + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub(crate) enum BatchError { + Inflate, + Limit, + Structure, + Unsupported, +} + +impl std::fmt::Display for BatchError { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.write_str(match self { + Self::Inflate => "invalid DD04 compression", + Self::Limit => "DD04 limit exceeded", + Self::Structure => "invalid DD04 structure", + Self::Unsupported => "unsupported DD04 opcode", + }) + } +} +impl std::error::Error for BatchError {} + +/// miniz_oxide 0.8.9 core::decompress writes only into the supplied slice and returns +/// (status, input consumed, output written). Unlike DecompressError, status contains no +/// partial plaintext. A fixed 1 MiB output slice bounds allocation even for a tiny bomb. +/// Requiring all input consumed also rejects trailing or concatenated deflate streams. +fn inflate_batch(input: &[u8]) -> Result, BatchError> { + use miniz_oxide::inflate::core::{decompress, inflate_flags, DecompressorOxide}; + use miniz_oxide::inflate::TINFLStatus; + if input.len() > MAX_GAME_FRAME - 4 { + return Err(BatchError::Limit); + } + let mut output = vec![0; MAX_BATCH_BYTES]; + let mut inflater = Box::::default(); + let (status, used, written) = decompress( + &mut inflater, + input, + &mut output, + 0, + inflate_flags::TINFL_FLAG_USING_NON_WRAPPING_OUTPUT_BUF, + ); + match status { + TINFLStatus::Done if used == input.len() => { + output.truncate(written); + Ok(output) + } + TINFLStatus::HasMoreOutput => Err(BatchError::Limit), + _ => Err(BatchError::Inflate), + } +} + +fn batch_caster(s: &mut PacketStream) -> anyhow::Result<()> { + let kind = s.read_u8()?; + aaemu_game::systems::skills::types::SkillCaster::read(kind, s)?; + Ok(()) +} + +fn batch_cast_action(s: &mut PacketStream) -> anyhow::Result<()> { + // CastAction has a native writer but no reader (types.rs, CastAction.Write). + let len = match s.read_u8()? { + 0 => 6, + 1 => 14, + 2 => 13, + 3 => 11, + 4 => 7, + _ => bail!(BatchError::Structure), + }; + s.read_bytes(len)?; + Ok(()) +} + +fn batch_plot_object(s: &mut PacketStream) -> anyhow::Result<()> { + // PlotObject.Write: Unit = type1+BC; Position = type2+position9+rotation3. + let len = match s.read_u8()? { + 1 => 3, + 2 => 12, + _ => bail!(BatchError::Structure), + }; + s.read_bytes(len)?; + Ok(()) +} + +/// Consume exactly one native body. No boundary scanning or treating remaining bytes as +/// an unknown body: an unsupported opcode rejects the *whole* batch before publication. +/// Covers every current CompressedGamePackets producer: plots, damage/heal and reset_all. +fn batch_body(dir: Dir, opcode: u16, s: &mut PacketStream) -> anyhow::Result<()> { + if dir == Dir::C2S { + if opcode == cs::X2EnterWorldPacket { + s.read_bytes(29)?; + return Ok(()); + } + bail!(BatchError::Unsupported); + } + match opcode { + sc::SCReconnectAuthPacket => { + s.read_u32()?; + } + sc::X2EnterWorldResponsePacket => { + s.read_bytes(17)?; // reason, gm, stream token, port, world time + s.read_bytes_sized()?; // pubKeySize / pubKey (both native u16-sized) + s.read_string()?; + } + sc::SCSkillCooldownResetPacket => { + s.read_bytes(12)?; + } + sc::SCSkillEndedPacket | sc::SCPlotEndedPacket => { + s.read_bytes(2)?; + } + sc::SCErrorMsgPacket => { + s.read_bytes(9)?; + } + sc::SCCastingStoppedPacket => { + s.read_bytes(6)?; + } + sc::SCBuffRemovedPacket | sc::SCBuffLearnedPacket | sc::SCSkillStoppedPacket => { + s.read_bytes(7)?; + } + sc::SCUnitDamagedPacket => { + batch_cast_action(s)?; + batch_caster(s)?; + s.read_bytes(7)?; // casterBC, targetBC, crime + s.read_pisc_w(3)?; + s.read_pisc_w(3)?; + s.read_bytes(5)?; // holdable, hit type, flag, result + } + sc::SCUnitHealedPacket => { + batch_cast_action(s)?; + batch_caster(s)?; + s.read_bytes(14)?; // targetBC, heal/hit, value, zero, result + } + sc::SCPlotEventPacket => { + s.read_bytes(10)?; // tl, event, skill + batch_plot_object(s)?; + batch_plot_object(s)?; + s.read_bytes(18)?; // item, objectBC, casting, zeroBC, zeroi16 + let count = s.read_u8()?; + s.read_bytes(usize::from(count) * 3)?; + let flag = s.read_u8()?; + if flag & 8 != 0 { + s.read_bytes(13 * 4)?; + } + } + sc::SCBuffCreatedPacket => { + batch_caster(s)?; + s.read_bytes(22)?; // caster, ownerBC, index, buff, level, ability, skill + s.read_pisc_w(4)?; + } + sc::SCSkillStartedPacket | sc::SCSkillFiredPacket => { + use aaemu_game::systems::skills::types::{SkillCastTarget, SkillObject}; + s.read_bytes(6)?; // skill and transport ids + batch_caster(s)?; + let kind = s.read_u8()?; + SkillCastTarget::read(kind, s)?; + let flag = s.read_u8()?; + anyhow::ensure!(flag <= 7, "invalid skill object type"); + SkillObject::read(flag, s)?; + if opcode == sc::SCSkillFiredPacket { + s.read_bytes(10)?; + } else { + s.read_bytes(5)?; // real/base cast, synergy + let extra = s.read_u8()?; + anyhow::ensure!(extra & !7 == 0, "invalid skill extra flags"); + if extra & 1 != 0 { + s.read_u8()?; + } + if extra & 2 != 0 { + s.read_u16()?; + } + if extra & 4 != 0 { + s.read_u32()?; + } + } + } + _ => bail!(BatchError::Unsupported), + } + Ok(()) +} + +/// Shared native batch validation for GameClient and Recorder. The input is the already +/// bounded inflated body, whose entries are [u16 zero][u16 opcode][native body]. No nesting +/// exists in this format. Any nonzero header, bad count/trailing bytes, or unknown body is +/// rejected atomically with a fixed error, never with input bytes or an underlying cause. +pub(crate) fn split_game_batch( + dir: Dir, + count: u16, + body: &[u8], +) -> Result, BatchError> { + if body.len() > MAX_BATCH_BYTES || usize::from(count) > MAX_BATCH_PACKETS { + return Err(BatchError::Limit); + } + let mut stream = PacketStream::from_bytes(body.to_vec()); + let mut packets = Vec::with_capacity(usize::from(count)); + for _ in 0..count { + if stream.read_u16().map_err(|_| BatchError::Structure)? != 0 { + return Err(BatchError::Structure); + } + let opcode = stream.read_u16().map_err(|_| BatchError::Structure)?; + let start = stream.pos(); + if let Err(error) = batch_body(dir, opcode, &mut stream) { + return Err( + if error.downcast_ref::() == Some(&BatchError::Unsupported) { + BatchError::Unsupported + } else { + BatchError::Structure + }, + ); + } + let end = stream.pos(); + if end - start > MAX_GAME_FRAME - 6 { + return Err(BatchError::Limit); + } + packets.push(Packet { + level: LEVEL_GAME, + opcode, + body: body[start..end].to_vec(), + }); + } + if stream.remaining() != 0 { + return Err(BatchError::Structure); + } + Ok(packets) +} + /// A received G2C / proxy packet. #[derive(Debug)] pub struct Packet { @@ -64,6 +293,80 @@ pub struct CharInfo { pub name: String, } +/// Consume one complete native `Character.Write` record. The list has no entry lengths; +/// stopping after id/name would parse the next character from equipment or model bytes. +fn read_character(s: &mut PacketStream) -> anyhow::Result { + use aaemu_game::models::container::{equip_slot, EQUIPMENT_CONTAINER_SIZE}; + use aaemu_game::models::item::detail_body_len; + use aaemu_game::models::unit_model::UnitCustomModelParams; + + let id = s.read_u32()?; + let name = s.read_string()?; + s.read_u8()?; // race + s.read_u8()?; // gender + s.read_u8()?; // level + s.read_i32()?; // hp + s.read_i32()?; // mp + s.read_u32()?; // zone + s.read_u32()?; // faction + s.read_string()?; // faction name (variable length) + s.read_u32()?; // expedition + s.read_u32()?; // family + for slot in 0..EQUIPMENT_CONTAINER_SIZE { + let template = s.read_u32()?; + // Native appearance slots use BodyPart.Write (template only), including nonzero ids. + if template == 0 || (equip_slot::FACE..=equip_slot::BEARD).contains(&slot) { + continue; + } + s.read_u64()?; // instance id + s.read_u8()?; // grade + s.read_u8()?; // flags + s.read_i32()?; // count + let detail = s.read_u8()?; + let len = detail_body_len(detail); + anyhow::ensure!(detail == 0 || len != 0, "unknown equipment detail type"); + s.read_bytes(len)?; + s.read_i64()?; // create time + s.read_i32()?; // lifespan + s.read_u32()?; // made unit id + s.read_u8()?; // world id + s.read_i64()?; // unsecure time + s.read_i64()?; // unpack time + } + s.read_bytes(3)?; // abilities + s.read_i64()?; // x + s.read_i64()?; // y + s.read_f32()?; // z + let _: UnitCustomModelParams = s.read()?; + s.read_i16()?; // labor + s.read_i64()?; // labor modified + s.read_i16()?; // dead count + s.read_i64()?; // dead time + s.read_i32()?; // rez wait + s.read_i64()?; // rez time + s.read_i32()?; // rez penalty + s.read_i64()?; // last world leave + s.read_i64()?; // money + s.read_i64()?; // money amount + s.read_i16()?; // crime + s.read_i32()?; // infamy + s.read_i16()?; // trials + s.read_i64()?; // delete request + s.read_i64()?; // transfer request + s.read_i64()?; // delete delay + s.read_i32()?; // consumed labor + s.read_i64()?; // loyalty + s.read_i64()?; // money2 + s.read_i64()?; // money amount + s.read_bool()?; // auto AA point + s.read_i32()?; // prev point + s.read_i32()?; // point + s.read_i32()?; // gift + s.read_i64()?; // updated + s.read_u8()?; // force name change + Ok(CharInfo { id, name }) +} + /// A unit seen in `SCUnitStatePacket`. #[derive(Clone, Debug, PartialEq)] pub struct UnitInfo { @@ -268,6 +571,10 @@ pub struct GameState { pub selected_char: u32, pub self_obj: u32, pub self_pos: (f32, f32, f32), + /// Last position actually received from the server, independent of local movement sends. + pub observed_self_pos: Option<(f32, f32, f32)>, + pub observation_seq: u64, + pub observation_errors: u64, pub units: HashMap, /// Doodads announced by `SCDoodad(s)CreatedPacket` and not removed since. pub doodads: HashMap, @@ -297,6 +604,7 @@ pub struct GameState { impl GameState { /// Updates the state from a packet. pub fn observe(&mut self, p: &Packet) -> anyhow::Result<()> { + self.observation_seq += 1; if let Some(ev) = crate::social::decode(p) { self.social.push(ev); } @@ -312,12 +620,14 @@ impl GameState { } else if p.is_sc(sc::SCCharacterListPacket) { let last = s.read_bool()?; let n = s.read_u8()?; - if n > 0 { - // Only the first entry can be located without decoding a whole Character. - let id = s.read_u32()?; - let name = s.read_string()?; - if !st.characters.iter().any(|c| c.id == id) { - st.characters.push(CharInfo { id, name }); + // Parse atomically: a malformed later entry must not authorize a partial list. + let characters = (0..n) + .map(|_| read_character(&mut s)) + .collect::>>()?; + anyhow::ensure!(s.remaining() == 0, "trailing character-list bytes"); + for character in characters { + if !st.characters.iter().any(|c| c.id == character.id) { + st.characters.push(character); } } st.char_list_done |= last; @@ -357,6 +667,7 @@ impl GameState { if unit_type == 0 && id == st.selected_char && id != 0 { st.self_obj = obj_id; st.self_pos = pos; + st.observed_self_pos = Some(pos); } st.units.insert( obj_id, @@ -380,6 +691,9 @@ impl GameState { s.read_u8()?; } let pos = s.read_position()?; + if obj_id == st.self_obj { + st.observed_self_pos = Some(pos); + } if let Some(u) = st.units.get_mut(&obj_id) { u.pos = pos; } @@ -391,6 +705,7 @@ impl GameState { let pos = s.read_position()?; st.last_teleport = Some(pos); st.self_pos = pos; + st.observed_self_pos = Some(pos); } else if p.is_sc(sc::SCDoodadCreatedPacket) { let d = read_doodad(&mut s)?; st.doodads.insert(d.obj_id, d); @@ -462,8 +777,10 @@ impl GameState { } pub struct GameClient { - writer: FramedWrite, - rx: mpsc::UnboundedReceiver>, + writer: Option, FrameCodec>>, + reader: SocketReader, + rx: mpsc::Receiver>, + expanded: VecDeque, rec: Recorder, count: u8, pub account_id: u32, @@ -475,6 +792,26 @@ pub struct GameClient { started: Instant, } +/// Aborting a client (including a cancelled connection attempt) must release the read half. +struct SocketReader(Option>); + +impl SocketReader { + async fn close(&mut self) { + if let Some(task) = self.0.take() { + task.abort(); + let _ = task.await; + } + } +} + +impl Drop for SocketReader { + fn drop(&mut self) { + if let Some(task) = self.0.take() { + task.abort(); + } + } +} + impl GameClient { pub async fn connect(addr: &str, rec: Recorder) -> anyhow::Result { let sock = TcpStream::connect(addr) @@ -482,18 +819,36 @@ impl GameClient { .with_context(|| format!("connecting to game server {addr}"))?; sock.set_nodelay(true)?; let (rd, wr) = sock.into_split(); - let (tx, rx) = mpsc::unbounded_channel(); - tokio::spawn(async move { + Ok(Self::from_parts(rd, wr, rec)) + } + + /// Use the same packet/state client over an owned async transport (including in-memory + /// deterministic fixtures). Production TCP keeps its native owned socket halves. + pub fn from_io( + io: impl AsyncRead + AsyncWrite + Unpin + Send + 'static, + rec: Recorder, + ) -> Self { + let (rd, wr) = tokio::io::split(io); + Self::from_parts(rd, wr, rec) + } + + fn from_parts( + rd: impl AsyncRead + Unpin + Send + 'static, + wr: impl AsyncWrite + Unpin + Send + 'static, + rec: Recorder, + ) -> Self { + let (tx, rx) = mpsc::channel(256); + let reader = tokio::spawn(async move { let mut reader = FramedRead::new(rd, FrameCodec); loop { match reader.next().await { Some(Ok(frame)) => { - if tx.send(frame).is_err() { + if tx.send(frame).await.is_err() { break; } } - Some(Err(e)) => { - tracing::warn!("game socket read error: {e}"); + Some(Err(_)) => { + tracing::warn!("game socket read failed"); break; } None => { @@ -503,9 +858,11 @@ impl GameClient { } } }); - Ok(Self { - writer: FramedWrite::new(wr, FrameCodec), + Self { + writer: Some(FramedWrite::new(Box::new(wr), FrameCodec)), + reader: SocketReader(Some(reader)), rx, + expanded: VecDeque::new(), rec, count: 0, account_id: 0, @@ -514,13 +871,36 @@ impl GameClient { ping_every: Duration::from_secs(3), last_ping: None, started: Instant::now(), - }) + } } pub fn recorder(&self) -> &Recorder { &self.rec } + /// Close both game socket halves, without sending `CSLeaveWorldPacket`. + /// Awaiting the aborted reader confirms that its socket half was dropped. + pub async fn disconnect_hard(mut self) { + drop(self.writer.take()); + self.reader.close().await; + // Earlier accepted events are already flushed. Drain already-delivered evidence + // in order for a bounded cleanup slice; do not let an inbound backlog consume the + // command's reporting reserve. No socket remains open while this work runs. + let until = Instant::now() + Duration::from_millis(25); + while Instant::now() < until { + if let Some(packet) = self.expanded.pop_front() { + self.accept(packet); + continue; + } + let Ok(frame) = self.rx.try_recv() else { + break; + }; + let _ = self.decode(frame); + } + self.rx.close(); + self.state.disconnected = true; + } + /// Sends a level-1 (`CS*`) packet. pub async fn send_cs(&mut self, opcode: u16, body: &[u8]) -> anyhow::Result<()> { self.rec.push( @@ -536,7 +916,11 @@ impl GameClient { self.count = self.count.wrapping_add(1); p.extend_from_slice(&opcode.to_le_bytes()); p.extend_from_slice(body); - self.writer.send(p).await?; + self.writer + .as_mut() + .context("game writer closed")? + .send(p) + .await?; Ok(()) } @@ -554,37 +938,51 @@ impl GameClient { p.extend_from_slice(&[0xDD, LEVEL_PROXY]); p.extend_from_slice(&opcode.to_le_bytes()); p.extend_from_slice(body); - self.writer.send(p).await?; + self.writer + .as_mut() + .context("game writer closed")? + .send(p) + .await?; Ok(()) } - fn decode(&mut self, frame: Vec) -> anyhow::Result { - if frame.len() < 4 { - bail!("short game frame ({} bytes)", frame.len()); + fn decode(&mut self, frame: Vec) -> anyhow::Result> { + if frame.len() > MAX_GAME_FRAME { + bail!(BatchError::Limit); + } + if frame.len() < 4 || frame[0] != 0xdd { + bail!("invalid game frame"); } let level = frame[1]; if level == LEVEL_COMPRESSED { - // `CompressedGamePackets`: [dd][04][u16 count][raw deflate of - // ([u16 0][u16 typeId][body])*]. The inner packets carry no lengths; the capture - // keeps the inflated batch (C# and Rust compress differently, the content is what - // must match). let count = u16::from_le_bytes([frame[2], frame[3]]); - let body = miniz_oxide::inflate::decompress_to_vec(&frame[4..]) - .map_err(|e| anyhow!("DD04 inflate failed: {e:?}"))?; - let p = Packet { - level, - opcode: count, - body, - }; + if usize::from(count) > MAX_BATCH_PACKETS { + bail!(BatchError::Limit); + } + let body = inflate_batch(&frame[4..])?; + if self.rec.is_incremental() { + // Validate the whole batch before any entry reaches a capture or state. + self.expanded + .extend(split_game_batch(Dir::S2C, count, &body)?); + return Ok(self.expanded.pop_front().map(|packet| self.accept(packet))); + } + // Ordinary scenario captures keep their existing aggregate inflated body. self.rec.push( Channel::Game, Dir::S2C, level, count, "CompressedGamePackets", - &p.body, + &body, ); - return Ok(p); + return Ok(Some(Packet { + level, + opcode: count, + body, + })); + } + if !matches!(level, LEVEL_GAME | LEVEL_PROXY) { + bail!("unsupported game frame level"); } let (opcode, body) = if level == LEVEL_GAME { if frame.len() < 6 { @@ -605,12 +1003,24 @@ impl GameClient { opcode, body, }; - self.rec - .push(Channel::Game, Dir::S2C, level, opcode, p.name(), &p.body); - if let Err(e) = self.observe(&p) { - tracing::debug!("could not parse {}: {e}", p.name()); + Ok(Some(self.accept(p))) + } + + fn accept(&mut self, packet: Packet) -> Packet { + self.rec.push( + Channel::Game, + Dir::S2C, + packet.level, + packet.opcode, + packet.name(), + &packet.body, + ); + if self.observe(&packet).is_err() { + self.state.observation_errors += 1; + // Native/parser errors can retain input; never format their Display/Debug/cause. + tracing::debug!(packet = packet.name(), "could not parse game packet"); } - Ok(p) + packet } /// `PingPacket` (proxy): `tPhy`, `ping` and `local`, like the client's keep-alive. @@ -636,6 +1046,9 @@ impl GameClient { /// Next packet, or `None` after `wait` without one. Sends keep-alive pings as needed. pub async fn recv_within(&mut self, wait: Duration) -> anyhow::Result> { self.keep_alive().await?; + if let Some(packet) = self.expanded.pop_front() { + return Ok(Some(self.accept(packet))); + } let wait = wait.min(self.ping_every); match tokio::time::timeout(wait, self.rx.recv()).await { Err(_) => Ok(None), @@ -643,7 +1056,7 @@ impl GameClient { self.state.disconnected = true; Err(anyhow!("game server closed the connection")) } - Ok(Some(frame)) => Ok(Some(self.decode(frame)?)), + Ok(Some(frame)) => self.decode(frame), } } @@ -1120,6 +1533,76 @@ impl GameClient { } } +#[cfg(test)] +mod socket_reader_tests { + use super::SocketReader; + use tokio::sync::oneshot; + + struct OnDrop(Option>); + + impl Drop for OnDrop { + fn drop(&mut self) { + let _ = self.0.take().unwrap().send(()); + } + } + + async fn reader() -> (SocketReader, oneshot::Receiver<()>) { + let (started, ready) = oneshot::channel(); + let (stopped, done) = oneshot::channel(); + let task = tokio::spawn(async move { + let _resource = OnDrop(Some(stopped)); + let _ = started.send(()); + std::future::pending::<()>().await; + }); + ready.await.unwrap(); + (SocketReader(Some(task)), done) + } + + #[tokio::test] + async fn explicit_close_and_cancelled_owner_release_reader_resources() { + let (mut task, stopped) = reader().await; + task.close().await; + assert!(stopped.await.is_ok()); + task.close().await; + + let (task, stopped) = reader().await; + drop(task); + assert!(stopped.await.is_ok()); + } +} + +#[cfg(test)] +mod observed_position_tests { + use super::*; + + #[test] + fn server_observation_does_not_report_a_locally_predicted_position() { + let mut state = GameState { + self_obj: 42, + self_pos: (900.0, 900.0, 900.0), + ..GameState::default() + }; + assert_eq!(state.observed_self_pos, None); + let mut body = PacketStream::new(); + body.write_bc(42) + .write_u8(1) + .write_u32(123) + .write_u8(0) + .write_position(10.0, 20.0, 30.0); + state + .observe(&Packet { + level: LEVEL_GAME, + opcode: sc::SCOneUnitMovementPacket, + body: body.as_bytes().to_vec(), + }) + .unwrap(); + // The native position codec quantizes the authored Z=30 to 29.9995. + assert_eq!(state.observed_self_pos, Some((10.0, 20.0, 29.9995))); + assert_eq!(state.self_pos, (900.0, 900.0, 900.0)); + assert_eq!(state.observation_seq, 1); + } +} + fn dist2(a: (f32, f32, f32), b: (f32, f32, f32)) -> f32 { let (dx, dy, dz) = (a.0 - b.0, a.1 - b.1, a.2 - b.2); dx * dx + dy * dy + dz * dz @@ -1180,3 +1663,399 @@ mod facing_tests { } } } + +#[cfg(test)] +mod compressed_batch_tests { + use super::*; + use crate::record::Event; + use aaemu_game::net::packet::encode; + use aaemu_game::packets::g2c::{SCReconnectAuthPacket, X2EnterWorldResponsePacket}; + use aaemu_game::systems::skills::packets::*; + use aaemu_game::systems::skills::types::{ + CastAction, HealHitType, HealType, PlotObject, SkillCaster, + }; + use std::io::Write; + use std::sync::{Arc, Mutex}; + + #[derive(Clone, Default)] + struct Bytes(Arc>>); + impl Write for Bytes { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.lock().unwrap().extend_from_slice(bytes); + Ok(bytes.len()) + } + fn flush(&mut self) -> std::io::Result<()> { + Ok(()) + } + } + + fn safe_native_batch() -> CompressedGamePackets { + let mut batch = CompressedGamePackets::new(); + batch.add(&SCSkillCooldownResetPacket { + obj_id: 42, + skill_id: 15307, + tag_id: 0, + gcd: false, + }); + batch.add(&SCPlotEventPacket { + tl: 7, + event_id: 8, + skill_id: 15307, + caster: PlotObject::Unit(42), + target: PlotObject::Position { + x: 1.0, + y: 2.0, + z: 3.0, + roll: 0, + pitch: 0, + yaw: 0, + }, + obj_id: 43, + casting_time: 100, + flag: 8, + item_id: 100, + target_unit_count: 2, + }); + batch.add(&SCUnitDamagedPacket::new( + CastAction::Plot { + plot_id: 1, + tl_id: 7, + event_id: 8, + skill_id: 15307, + }, + SkillCaster::Item { + obj_id: 42, + item_id: 100, + item_template_id: 23398, + type1: 0, + type2: 0, + }, + 42, + 43, + 20000, + 1000, + )); + batch.add(&SCUnitHealedPacket { + cast_action: CastAction::Buff { + buff_id: 1, + owner_obj_id: 42, + index: 2, + }, + skill_caster: SkillCaster::Mount { + obj_id: 42, + mount_skill_template_id: 3, + }, + target_id: 43, + heal_type: HealType::Health, + heal_hit_type: HealHitType::HealHit, + value: 400, + }); + batch.add(&SCBuffCreatedPacket { + skill_caster: SkillCaster::Unit(42), + caster_id: 1, + owner_obj_id: 42, + index: 2, + buff_id: 3, + caster_level: 10, + ab_level: 10, + skill_id: 15307, + charge: 300, + duration: 20000, + tick: 100.0, + }); + batch.add(&SCSkillEndedPacket { tl: 7 }); + batch.add(&SCBuffRemovedPacket { + obj_id: 42, + index: 2, + }); + batch.add(&aaemu_game::packets::world::SCErrorMsgPacket::new( + 7, 0, false, + )); + let mut started = SCSkillStartedPacket::new( + 15307, + 7, + SkillCaster::Unit(42), + aaemu_game::systems::skills::types::SkillCastTarget::Position { + obj_id: 0, + x: 1.0, + y: 2.0, + z: 3.0, + rot: 0.0, + obj_id1: 0, + obj_id2: 0, + }, + aaemu_game::systems::skills::types::SkillObject::Text("safe".into()), + ); + started + .set_skill_result(2) + .set_result_ushort(300) + .set_result_uint(400); + batch.add(&started); + batch.add(&SCSkillFiredPacket { + id: 15307, + tl: 7, + caster: SkillCaster::Unit(42), + target: aaemu_game::systems::skills::types::SkillCastTarget::Doodad(43), + skill_object: aaemu_game::systems::skills::types::SkillObject::None, + computed_delay: 100, + channeling_time: 0, + fire_anim_id: 1, + }); + batch + } + + fn client(rec: Recorder) -> GameClient { + let (io, _peer) = tokio::io::duplex(64 * 1024); + GameClient::from_io(io, rec) + } + + fn control_events(frame: Vec) -> (Vec, Vec) { + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + let mut game = client(rec.clone()); + game.decode(frame).unwrap(); + while let Some(packet) = game.expanded.pop_front() { + game.accept(packet); + } + let output = rec.take_live_events().unwrap(); + let capture = String::from_utf8(sink.0.lock().unwrap().clone()) + .unwrap() + .lines() + .map(|line| serde_json::from_str(line).unwrap()) + .collect(); + (output, capture) + } + + #[tokio::test] + async fn real_repo_encoded_plot_combat_and_cooldown_batches_reach_both_sinks() { + let batch = safe_native_batch(); + let (events, capture) = control_events(encode(&batch)); + assert_eq!(events, capture); + assert_eq!(events.len(), batch.len()); + for (event, (opcode, body)) in events.iter().zip(&batch.packets) { + assert_eq!(event.level, LEVEL_GAME); + assert_eq!(event.opcode, *opcode); + assert_eq!(event.body_bytes(), *body); + } + let mut large = CompressedGamePackets::new(); + for skill in 0..1024 { + large.add(&SCSkillCooldownResetPacket { + obj_id: 42, + skill_id: skill, + tag_id: 0, + gcd: false, + }); + } + assert_eq!(control_events(encode(&large)).0.len(), 1024); + assert!(control_events(encode(&CompressedGamePackets::new())) + .0 + .is_empty()); + } + + #[tokio::test] + async fn mixed_auth_batches_only_publish_the_safe_inner_packets() { + const TOKEN: u32 = u32::from_le_bytes(*b"KEY!"); + let safe = safe_native_batch(); + let mut mixed = CompressedGamePackets::new(); + mixed.add(&SCReconnectAuthPacket { token: TOKEN }); + mixed.packets.extend(safe.packets.clone()); + mixed.add(&X2EnterWorldResponsePacket { + reason: 0, + gm: true, + token: TOKEN, + port: 25250, + world_time: 0, + }); + let (events, capture) = control_events(encode(&mixed)); + assert_eq!(events, capture); + assert_eq!(events.len(), safe.len()); + for event in &events { + assert_eq!(event.level, 1); + assert!(!matches!( + event.opcode, + sc::SCReconnectAuthPacket | sc::X2EnterWorldResponsePacket + )); + assert!(!event.body.contains("4b455921")); + } + // A recorder receiving an already-inflated aggregate uses the identical splitter. + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + rec.push( + Channel::Game, + Dir::S2C, + 4, + mixed.len() as u16, + "CompressedGamePackets", + &mixed.raw_payload(), + ); + let direct = rec.take_live_events().unwrap(); + assert_eq!( + direct + .iter() + .map(|e| (e.opcode, e.body.clone())) + .collect::>(), + events + .iter() + .map(|e| (e.opcode, e.body.clone())) + .collect::>() + ); + assert!(!String::from_utf8_lossy(&sink.0.lock().unwrap()).contains("4b455921")); + // C2S's credential transition is X2EnterWorld (native 29-byte body). + let mut auth = PacketStream::new(); + auth.write_u32(0) + .write_u32(0) + .write_u32(1) + .write_u32(TOKEN) + .write_i32(0) + .write_u8(0) + .write_u64(0); + let mut inbound = CompressedGamePackets::new(); + inbound + .packets + .push((cs::X2EnterWorldPacket, auth.into_bytes())); + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + rec.push( + Channel::Game, + Dir::C2S, + 4, + 1, + "CompressedGamePackets", + &inbound.raw_payload(), + ); + assert!(rec.take_live_events().unwrap().is_empty()); + assert!(sink.0.lock().unwrap().is_empty()); + // Ordinary private scenario captures preserve their existing inflated aggregate. + let ordinary = Recorder::new(true); + let mut game = client(ordinary.clone()); + let packet = game.decode(encode(&mixed)).unwrap().unwrap(); + assert_eq!(packet.level, 4); + assert_eq!(ordinary.events()[0].body_bytes(), mixed.raw_payload()); + assert_eq!(ordinary.events().len(), 1); + } + + fn redacted(error: &anyhow::Error) { + for text in [ + format!("{error}"), + format!("{error:#}"), + format!("{error:?}"), + ] { + for secret in ["KEY!", "4b455921", "75, 69, 89, 33"] { + assert!(!text.contains(secret), "payload in formatted parser error"); + } + } + } + + #[tokio::test] + async fn malformed_compressed_auth_never_reaches_errors_or_debug_logs() { + let mut raw = PacketStream::new(); + raw.write_u16(0) + .write_u16(sc::SCReconnectAuthPacket) + .write_raw(b"KEY!"); + let mut bad = deflate_stored(raw.as_bytes()); + bad[0] = 0; // valid non-final stored block produces the secret before the invalid block + bad.push(7); // final reserved BTYPE=3 + let mut frame = vec![0xdd, 4, 1, 0]; + frame.extend_from_slice(&bad); + let logs = Bytes::default(); + let writer = logs.clone(); + let subscriber = tracing_subscriber::fmt() + .without_time() + .with_ansi(false) + .with_max_level(tracing::Level::DEBUG) + .with_writer(move || writer.clone()) + .finish(); + let _guard = tracing::subscriber::set_default(subscriber); + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + let mut game = client(rec.clone()); + let error = game.decode(frame).unwrap_err(); + assert_eq!( + error.downcast_ref::(), + Some(&BatchError::Inflate) + ); + redacted(&error); + tracing::debug!(debug=?error,display=%error,"sanitized batch error"); + // The observation path also avoids formatting errors with retained native input. + game.decode(aaemu_game::net::packet::encode_raw( + 1, + sc::X2EnterWorldResponsePacket, + b"KEY!", + )) + .unwrap(); + let logs = String::from_utf8(logs.0.lock().unwrap().clone()).unwrap(); + assert!(logs.contains("sanitized batch error")); + for secret in ["KEY!", "4b455921", "75, 69, 89, 33"] { + assert!(!logs.contains(secret)); + } + assert!(rec.take_live_events().unwrap().is_empty()); + assert!(sink.0.lock().unwrap().is_empty()); + } + + #[tokio::test] + async fn count_nested_unknown_truncated_and_trailing_batches_fail_atomically() { + let safe = safe_native_batch(); + let raw = safe.raw_payload(); + let mut nonzero = raw.clone(); + nonzero[0] = 1; + let mut trailing = raw.clone(); + trailing.push(0xff); + let mut inner = CompressedGamePackets::new(); + inner.add(&SCSkillEndedPacket { tl: 7 }); + let mut nested = CompressedGamePackets::new(); + nested.add(&inner); + let cases = [ + (safe.len() as u16, nonzero), + (safe.len() as u16, trailing), + (safe.len() as u16 + 1, raw.clone()), + (safe.len() as u16 - 1, raw.clone()), + (safe.len() as u16, raw[..raw.len() - 1].to_vec()), + (1, vec![0, 0, 0xff, 0xff, b'K', b'E', b'Y', b'!']), + (1, nested.raw_payload()), + (1, encode(&inner)), // nested DD04 level header is not an inner zero/opcode header + ]; + for (count, body) in cases { + let sink = Bytes::default(); + let rec = Recorder::incremental_game_to(sink.clone()); + rec.control_game_ready(true); + let mut game = client(rec.clone()); + let mut frame = vec![0xdd, 4]; + frame.extend_from_slice(&count.to_le_bytes()); + frame.extend_from_slice(&deflate_stored(&body)); + redacted(&game.decode(frame).unwrap_err()); + assert!(rec.take_live_events().unwrap().is_empty()); + assert!(sink.0.lock().unwrap().is_empty()); + } + } + + #[tokio::test] + async fn inflater_refuses_bombs_and_frame_count_limits_before_unbounded_growth() { + // Only cap+1 plaintext bytes are needed to test a bomb; no huge fixture allocation. + let bomb = miniz_oxide::deflate::compress_to_vec(&vec![b'A'; MAX_BATCH_BYTES + 1], 9); + assert!(bomb.len() < MAX_GAME_FRAME - 4); + assert_eq!(inflate_batch(&bomb).unwrap_err(), BatchError::Limit); + let exact = miniz_oxide::deflate::compress_to_vec(&vec![b'A'; MAX_BATCH_BYTES], 9); + assert_eq!(inflate_batch(&exact).unwrap().len(), MAX_BATCH_BYTES); + let mut trailing = exact; + trailing.extend_from_slice(&[0xaa; 64]); + assert_eq!(inflate_batch(&trailing).unwrap_err(), BatchError::Inflate); + let mut game = client(Recorder::new(false)); + let error = game.decode(vec![0; MAX_GAME_FRAME + 1]).unwrap_err(); + redacted(&error); + let mut frame = vec![0xdd, 4]; + frame.extend_from_slice(&((MAX_BATCH_PACKETS + 1) as u16).to_le_bytes()); + frame.extend_from_slice(&deflate_stored(&[])); + assert_eq!( + game.decode(frame).unwrap_err().downcast_ref::(), + Some(&BatchError::Limit) + ); + assert_eq!( + split_game_batch(Dir::S2C, 0, &vec![0; MAX_BATCH_BYTES + 1]).unwrap_err(), + BatchError::Limit + ); + } +} diff --git a/rust/crates/aaemu-testclient/src/main.rs b/rust/crates/aaemu-testclient/src/main.rs index 307014e9ba..a42dd48c31 100644 --- a/rust/crates/aaemu-testclient/src/main.rs +++ b/rust/crates/aaemu-testclient/src/main.rs @@ -14,6 +14,9 @@ //! [--scenario load] //! aaemu-testclient verify --suite file.vtest [--login H:P] [--password P] [--list-bots] //! Run one live verification suite (see Docs/wiki/Verification.md). +//! aaemu-testclient control --describe +//! aaemu-testclient control --config private.json --login H:P --capture game.jsonl +//! [--deadline-ms 570000] //! ``` //! //! Settings come from `--config` (JSON, see `testclient.example.json`), then the flags. Keep @@ -31,6 +34,8 @@ use aaemu_testclient::verify; use anyhow::{bail, Context}; use tracing_subscriber::EnvFilter; +mod control; + struct Args { cmd: String, flags: HashMap, @@ -38,7 +43,7 @@ struct Args { impl Args { fn parse() -> anyhow::Result { - const SWITCHES: &[&str] = &["list-bots"]; + const SWITCHES: &[&str] = &["list-bots", "describe"]; let mut it = std::env::args().skip(1); let cmd = it.next().unwrap_or_else(|| "help".into()); let argv: Vec = it.collect(); @@ -73,10 +78,28 @@ impl Args { } fn bot_config(args: &Args) -> anyhow::Result { + bot_config_with(args, read_config) +} + +fn read_config(path: &str) -> anyhow::Result { + std::fs::read_to_string(path).with_context(|| format!("reading {path}")) +} + +fn control_config( + args: &Args, + read: impl FnOnce(&str) -> anyhow::Result, +) -> anyhow::Result { + // Discard the entire cause chain. Serde errors can quote a value supplied for password + // (e.g. an unquoted number), and main's Result termination uses Debug formatting. + bot_config_with(args, read).map_err(|_| anyhow::anyhow!("invalid control config")) +} + +fn bot_config_with( + args: &Args, + read: impl FnOnce(&str) -> anyhow::Result, +) -> anyhow::Result { let mut v: serde_json::Value = match args.get("config") { - Some(p) => serde_json::from_str( - &std::fs::read_to_string(p).with_context(|| format!("reading {p}"))?, - )?, + Some(p) => serde_json::from_str(&read(p)?)?, None => serde_json::json!({}), }; let obj = v.as_object_mut().context("config must be a JSON object")?; @@ -188,11 +211,24 @@ fn diff_files(a: &Path, b: &Path, cfg: &DiffConfig, la: &str, lb: &str) -> anyho #[tokio::main] async fn main() -> anyhow::Result<()> { tracing_subscriber::fmt() + .with_writer(std::io::stderr) .with_env_filter( EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("warn")), ) .init(); let args = Args::parse()?; + if args.cmd == "control" { + if args.has("describe") { + println!("{}", control::describe()); + return Ok(()); + } + args.get("config") + .context("control requires --config ")?; + let cfg = control_config(&args, read_config)?; + let capture = Path::new(args.get("capture").context("control requires --capture")?); + let deadline_ms = args.get("deadline-ms").unwrap_or("570000").parse()?; + return control::run(cfg, capture, deadline_ms).await; + } let kind: Kind = args.get("scenario").unwrap_or("full").parse()?; match args.cmd.as_str() { "run" => { @@ -286,3 +322,34 @@ async fn main() -> anyhow::Result<()> { } Ok(()) } + +#[cfg(test)] +mod control_config_tests { + use super::*; + + #[test] + fn numeric_password_never_reaches_any_user_visible_error_format() { + const SECRET: &str = "782643915027481"; + let args = Args { + cmd: "control".into(), + flags: HashMap::from([("config".into(), "private.json".into())]), + }; + let text = format!( + r#"{{"login":"127.0.0.1:1","user":"owner","character":"Owner","password":{SECRET}}}"# + ); + let error = control_config(&args, |_| Ok(text)).unwrap_err(); + for visible in [ + format!("{error}"), + format!("{error:#}"), + format!("{error:?}"), + ] { + assert!(visible.contains("invalid control config")); + assert!(!visible.contains(SECRET)); + } + assert_eq!(error.chain().count(), 1); + // File/parse/flag errors are also scrubbed rather than attached as causes. + let error = control_config(&args, |_| anyhow::bail!("private cause {SECRET}")).unwrap_err(); + assert!(!format!("{error:?}").contains(SECRET)); + assert_eq!(error.chain().count(), 1); + } +} diff --git a/rust/crates/aaemu-testclient/src/record.rs b/rust/crates/aaemu-testclient/src/record.rs index 4cd16ed5d3..37ebbfe132 100644 --- a/rust/crates/aaemu-testclient/src/record.rs +++ b/rust/crates/aaemu-testclient/src/record.rs @@ -50,6 +50,44 @@ struct Inner { step: String, events: Vec, enabled: bool, + live: Option, +} + +/// Control mode drains this bounded queue to stdout; ordinary recorders still keep a Vec. +const MAX_PENDING_EVENTS: usize = 8192; +const MAX_PENDING_BYTES: usize = 8 * 1024 * 1024; + +struct LiveCapture { + sink: Box, + pending: Vec, + pending_bytes: usize, + failed: bool, + game_ready: bool, +} + +impl std::fmt::Debug for LiveCapture { + fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { + f.debug_struct("LiveCapture") + .field("pending", &self.pending.len()) + .field("failed", &self.failed) + .finish_non_exhaustive() + } +} + +fn public_game_event(channel: Channel, dir: Dir, level: u8, opcode: u16) -> bool { + use aaemu_game::opcodes::{cs, sc}; + // Credential-bearing game transitions in the 1.2 tables: enter-world cookie (C2S), + // stream token (S2C), and the reconnect token delivered after character selection. + // Login/stream channels are never public, regardless of session readiness. + channel == Channel::Game + && !(level == 1 + && match dir { + Dir::C2S => opcode == cs::X2EnterWorldPacket, + Dir::S2C => matches!( + opcode, + sc::X2EnterWorldResponsePacket | sc::SCReconnectAuthPacket + ), + }) } /// Shared, cheaply cloneable capture buffer. @@ -69,13 +107,78 @@ impl Recorder { step: "connect".into(), events: Vec::new(), enabled, + live: None, }))) } + /// Incremental, game-only capture for control mode. Refuses to overwrite evidence. + /// Login/stream authentication and game cookie/token packets are never retained here. + /// Unlike `new`, this recorder does not retain the entire run in memory. + pub fn incremental_game(path: &Path) -> anyhow::Result { + let file = std::fs::OpenOptions::new() + .write(true) + .create_new(true) + .open(path)?; + Ok(Self::incremental_game_to(std::io::BufWriter::new(file))) + } + + /// The same bounded incremental capture with a caller-owned sink, e.g. an in-memory + /// writer for deterministic transport/loop tests. Authentication policy is identical. + pub fn incremental_game_to(sink: impl Write + Send + 'static) -> Self { + Self::with_live_sink(Box::new(sink)) + } + + fn with_live_sink(sink: Box) -> Self { + let rec = Self::new(true); + rec.inner().live = Some(LiveCapture { + sink, + pending: Vec::new(), + pending_bytes: 0, + failed: false, + game_ready: false, + }); + rec + } + + /// Omit the authentication/lobby burst, including any compressed token-bearing frames. + /// Select/spawn and all subsequent gameplay remain available to the controller. + pub fn control_game_ready(&self, ready: bool) { + if let Some(live) = self.inner().live.as_mut() { + live.game_ready = ready; + } + } + + /// Drain independent game events, after checking for capture/queue failures. + pub fn take_live_events(&self) -> anyhow::Result> { + let mut i = self.inner(); + let live = i + .live + .as_mut() + .ok_or_else(|| anyhow::anyhow!("not a live recorder"))?; + anyhow::ensure!(!live.failed, "incremental capture failed or queue exceeded"); + live.pending_bytes = 0; + Ok(std::mem::take(&mut live.pending)) + } + + pub fn flush_live(&self) -> anyhow::Result<()> { + if let Some(live) = self.inner().live.as_mut() { + anyhow::ensure!(!live.failed, "incremental capture failed or queue exceeded"); + if live.sink.flush().is_err() { + live.failed = true; + anyhow::bail!("incremental capture flush failed"); + } + } + Ok(()) + } + fn inner(&self) -> std::sync::MutexGuard<'_, Inner> { self.0.lock().unwrap_or_else(|e| e.into_inner()) } + pub(crate) fn is_incremental(&self) -> bool { + self.inner().live.is_some() + } + /// Starts a new scenario step; later frames are tagged with it. pub fn step(&self, name: &str) { self.inner().step = name.to_string(); @@ -94,10 +197,59 @@ impl Recorder { name: &str, body: &[u8], ) { + if channel == Channel::Game + && level == crate::game::LEVEL_COMPRESSED + && self.is_incremental() + { + if !self + .inner() + .live + .as_ref() + .is_some_and(|live| live.game_ready) + { + return; + } + // The caller supplies the inflated native body, just as an ordinary aggregate + // capture does. Share GameClient's atomic splitter, then apply the same auth + // policy to each entry. Never publish an outer batch containing a token. + match crate::game::split_game_batch(dir, opcode, body) { + Ok(packets) => { + for packet in packets { + self.push( + channel, + dir, + packet.level, + packet.opcode, + crate::game::packet_name(dir, packet.level, packet.opcode), + &packet.body, + ); + } + } + Err(_) => { + if let Some(live) = self.inner().live.as_mut() { + live.failed = true; + } + } + } + return; + } let mut i = self.inner(); if !i.enabled { return; } + if i.live + .as_ref() + .is_some_and(|live| !live.game_ready || !public_game_event(channel, dir, level, opcode)) + { + return; + } + // Unknown levels have no validated public framing. DD04 is handled above. + if channel == Channel::Game && !matches!(level, 1 | 2) { + if let Some(live) = i.live.as_mut() { + live.failed = true; + return; + } + } let ev = Event { t_ms: i.start.elapsed().as_millis() as u64, channel, @@ -108,7 +260,29 @@ impl Recorder { step: i.step.clone(), body: hex::encode(body), }; - i.events.push(ev); + if let Some(live) = i.live.as_mut() { + if live.failed { + return; + } + let result = (|| -> anyhow::Result<()> { + let mut line = serde_json::to_vec(&ev)?; + line.push(b'\n'); + anyhow::ensure!( + live.pending.len() < MAX_PENDING_EVENTS + && line.len() <= MAX_PENDING_BYTES.saturating_sub(live.pending_bytes), + "live event queue exceeded" + ); + live.sink.write_all(&line)?; + // A hard socket close or process kill must preserve earlier accepted frames. + live.sink.flush()?; + live.pending_bytes += line.len(); + live.pending.push(ev); + Ok(()) + })(); + live.failed = result.is_err(); + } else { + i.events.push(ev); + } } pub fn events(&self) -> Vec { @@ -134,3 +308,181 @@ pub fn load(path: &Path) -> anyhow::Result> { .map(|l| Ok(serde_json::from_str(l)?)) .collect() } + +#[cfg(test)] +mod tests { + use super::*; + use aaemu_game::opcodes::{cs, sc}; + + #[derive(Default)] + struct Written { + bytes: Vec, + flushes: usize, + fail_flush: bool, + } + + #[derive(Clone, Default)] + struct Sink(Arc>); + + impl Write for Sink { + fn write(&mut self, bytes: &[u8]) -> std::io::Result { + self.0.lock().unwrap().bytes.extend_from_slice(bytes); + Ok(bytes.len()) + } + + fn flush(&mut self) -> std::io::Result<()> { + let mut written = self.0.lock().unwrap(); + written.flushes += 1; + if written.fail_flush { + return Err(std::io::Error::other("injected flush failure")); + } + Ok(()) + } + } + + fn push(rec: &Recorder) { + rec.push( + Channel::Game, + Dir::S2C, + 1, + sc::SCErrorMsgPacket, + "SCErrorMsgPacket", + &[7, 0], + ); + } + + #[test] + fn live_capture_flushes_before_drain_and_omits_all_authentication_channels() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.push( + Channel::Game, + Dir::S2C, + 4, + 1, + "CompressedGamePackets", + b"lobby-token", + ); + assert!(sink.0.lock().unwrap().bytes.is_empty()); + rec.control_game_ready(true); + for (channel, dir, opcode) in [ + (Channel::Login, Dir::C2S, 4), + (Channel::Stream, Dir::C2S, 1), + (Channel::Game, Dir::C2S, cs::X2EnterWorldPacket), + (Channel::Game, Dir::S2C, sc::X2EnterWorldResponsePacket), + (Channel::Game, Dir::S2C, sc::SCReconnectAuthPacket), + ] { + rec.push(channel, dir, 1, opcode, "auth", b"private"); + } + push(&rec); + let persisted = sink.0.lock().unwrap(); + assert_eq!(persisted.flushes, 1); + let event: Event = serde_json::from_slice(&persisted.bytes).unwrap(); + assert_eq!(event.body_bytes(), [7, 0]); + assert!(!String::from_utf8_lossy(&persisted.bytes).contains(&hex::encode(b"private"))); + drop(persisted); + assert_eq!(rec.take_live_events().unwrap(), vec![event]); + assert!(rec.take_live_events().unwrap().is_empty()); + assert!( + rec.events().is_empty(), + "control must not retain the whole run" + ); + rec.control_game_ready(false); + push(&rec); + assert_eq!(sink.0.lock().unwrap().flushes, 1); + } + + #[test] + fn reconnect_token_after_readiness_is_absent_from_capture_and_stdout_events() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.control_game_ready(true); + rec.push( + Channel::Game, + Dir::S2C, + 1, + sc::SCReconnectAuthPacket, + "SCReconnectAuthPacket", + &[0x78, 0x56, 0x34, 0x12], + ); + push(&rec); + let stdout_events = rec.take_live_events().unwrap(); + assert_eq!(stdout_events.len(), 1); + assert_eq!(stdout_events[0].opcode, sc::SCErrorMsgPacket); + let persisted = sink.0.lock().unwrap(); + let capture_events: Vec = String::from_utf8_lossy(&persisted.bytes) + .lines() + .map(|line| serde_json::from_str(line).unwrap()) + .collect(); + assert_eq!(capture_events, stdout_events); + assert!(!String::from_utf8_lossy(&persisted.bytes).contains("78563412")); + } + + #[test] + fn auth_only_post_ready_batch_never_retains_outer_or_inner_secret_bytes() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.control_game_ready(true); + push(&rec); + let before = sink.0.lock().unwrap().bytes.clone(); + // A valid native reconnect-only batch must be filtered, not retained as raw DD04. + rec.push( + Channel::Game, + Dir::S2C, + 4, + 1, + "CompressedGamePackets", + &[0, 0, 1, 0, 9, 8, 7, 6], + ); + assert_eq!(sink.0.lock().unwrap().bytes, before); + let events = rec.take_live_events().unwrap(); + assert_eq!(events.len(), 1); + assert_eq!(events[0].opcode, sc::SCErrorMsgPacket); + } + + #[test] + fn malformed_batch_is_rejected_before_any_partial_event_or_secret_is_published() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.control_game_ready(true); + rec.push( + Channel::Game, + Dir::S2C, + 4, + 1, + "CompressedGamePackets", + &[0, 0, 1, 0, 9, 8, 7, 6, 0xff], + ); + assert!(sink.0.lock().unwrap().bytes.is_empty()); + assert!(rec.take_live_events().is_err()); + } + + #[test] + fn queue_or_sink_failure_is_observable_and_never_silently_resumes() { + let sink = Sink::default(); + let rec = Recorder::with_live_sink(Box::new(sink.clone())); + rec.control_game_ready(true); + sink.0.lock().unwrap().fail_flush = true; + push(&rec); + assert!(rec.take_live_events().is_err()); + sink.0.lock().unwrap().fail_flush = false; + assert!(rec.flush_live().is_err()); + + let rec = Recorder::with_live_sink(Box::new(Sink::default())); + rec.control_game_ready(true); + for _ in 0..=MAX_PENDING_EVENTS { + push(&rec); + } + assert!(rec.take_live_events().is_err()); + } + + #[test] + fn ordinary_recorders_still_buffer_every_channel() { + let rec = Recorder::new(true); + rec.push(Channel::Login, Dir::C2S, 0, 4, "auth", b"ticket"); + rec.push(Channel::Stream, Dir::C2S, 0, 1, "join", b"token"); + push(&rec); + assert_eq!(rec.events().len(), 3); + assert_eq!(rec.events()[0].body_bytes(), b"ticket"); + } +} diff --git a/rust/crates/aaemu-testclient/src/scenario.rs b/rust/crates/aaemu-testclient/src/scenario.rs index f30c62ec3f..f0c3b4fba0 100644 --- a/rust/crates/aaemu-testclient/src/scenario.rs +++ b/rust/crates/aaemu-testclient/src/scenario.rs @@ -463,12 +463,12 @@ mod creation_tests { } } -async fn run_inner( +/// Existing login/lobby path shared by scenarios and the stdio controller. +async fn open_lobby( kind: Kind, cfg: &BotConfig, r: &mut Runner<'_>, - script_input: Option<&ScriptInput<'_>>, -) -> anyhow::Result<()> { +) -> anyhow::Result> { // ---- login server ---- let s = r.begin("login.auth"); let mut login = LoginClient::connect(&cfg.login, r.rec.clone()).await?; @@ -503,7 +503,7 @@ async fn run_inner( format!("{}:{} cookie {}", cookie.ip, cookie.port, cookie.cookie), ); if kind == Kind::Login { - return Ok(()); + return Ok(None); } // ---- game server: lobby ---- @@ -557,10 +557,270 @@ async fn run_inner( p.is_sc(sc::SCCharacterListPacket) && p.body.first() == Some(&1) }) .await?; + ensure!( + game.state.char_list_done, + "incomplete character-list metadata" + ); game.drain(Duration::from_millis(300), Duration::from_secs(2)) .await?; r.end(s, format!("{} character(s)", game.state.characters.len())); + Ok(Some((game, stream, login))) +} + +async fn select_and_spawn( + game: &mut GameClient, + character_id: u32, + r: &mut Runner<'_>, +) -> anyhow::Result<()> { + // ---- world ---- + let s = r.begin("game.select"); + game.select_character(character_id).await?; + game.wait_sc(sc::SCCharacterStatePacket).await?; + game.drain(QUIET, Duration::from_secs(10)).await?; + r.end(s, format!("{} bag items seen", game.state.bag_items.len())); + + let s = r.begin("game.spawn"); + game.spawn_character().await?; + game.wait_for("own SCUnitStatePacket", |p| p.is_sc(sc::SCUnitStatePacket)) + .await?; + game.notify_in_game().await?; + game.notify_in_game_completed().await?; + game.drain(QUIET, Duration::from_secs(15)).await?; + ensure!(game.state.self_obj != 0, "own unit state not received"); + r.var("self_obj", game.state.self_obj); + let npcs = game + .state + .units + .values() + .filter(|u| u.unit_type == 1) + .count(); + r.end( + s, + format!( + "obj {} at {:?}, {npcs} npcs visible", + game.state.self_obj, game.state.self_pos + ), + ); + + Ok(()) +} + +/// A control session owns its connections and reuses the scenario login handoff. +pub struct ControlSession { + pub game: GameClient, + pub stream: StreamClient, + // Preserve the ordinary scenario's login-connection lifetime through the handoff. + _login: LoginClient, +} + +impl ControlSession { + /// Own the three connections of an already established session. + pub fn new(game: GameClient, stream: StreamClient, login: LoginClient) -> Self { + Self { + game, + stream, + _login: login, + } + } + + /// Release this session's stream, login, and both game halves without application logout. + pub async fn disconnect_hard(self) { + let Self { + game, + stream, + _login: login, + } = self; + drop(stream); + drop(login); + game.disconnect_hard().await; + } +} + +fn control_character( + characters: &[crate::game::CharInfo], + requested: &str, + character_id: Option, +) -> anyhow::Result { + let mut matches = characters.iter().filter(|c| match character_id { + Some(id) => id != 0 && c.id == id, + None => c.name.eq_ignore_ascii_case(requested), + }); + let ch = matches + .next() + .context("requested existing character not listed")?; + ensure!(matches.next().is_none(), "ambiguous existing character"); + Ok(ch.id) +} + +#[cfg(test)] +mod control_character_tests { + use super::control_character; + use crate::game::CharInfo; + + // Literal SCCharacterList wire body: last=true, count=2. First entry has a full + // equipment item (55-byte detail), nonzero BodyPart ids, faction text, and a Face + // model with a three-byte modifier. Second entry has a Hair model. No server encoder + // or preconstructed CharInfo vector participates in this regression. + const TWO_CHARACTERS: &str = concat!( + "01020a0000000500466972737401020a6f000000de0000004d00000054000000070046616374696f6e04000000050000", + "004f1a0000887766554433221101020100000001000102030405060708090a0b0c0d0e0f101112131415161718191a1b", + "1c1d1e1f202122232425262728292a2b2c2d2e2f303132333435360b000000000000000c0000000d0000000e0f000000", + "000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "000000000000000000000000000000000000000000000000000000000000000000000000fb030000fc030000fd030000", + "fe030000ff0300000004000001040000000000000000000001020300a000000000000000400100000000000000f04103", + "5b0000005c0000005d0000005e0000000000003f0000803f0000803e01000200640000000000003f650000000000003f", + "660000000000003f670000000000003f6e0000006f000000700000000000403f78000000790000007a0000007b000000", + "7c000000030007080964006500000000000000020067000000000000006800000069000000000000006a0000006b0000", + "00000000006c000000000000006d000000000000006e006f000000700071000000000000007200000000000000730000", + "0000000000740000007500000000000000760000000000000077000000000000000178000000790000007a0000007b00", + "000000000000002a00000005004f776e657201020a6f000000de0000004d00000054000000070046616374696f6e0400", + "000005000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", + "00000000000000000000000000000000000000000000000000000000000000000000fb030000fc030000fd030000fe03", + "0000ff0300000004000001040000000000000000000001020300a000000000000000400100000000000000f041015b00", + "000064006500000000000000020067000000000000006800000069000000000000006a0000006b000000000000006c00", + "0000000000006d000000000000006e006f00000070007100000000000000720000000000000073000000000000007400", + "00007500000000000000760000000000000077000000000000000178000000790000007a0000007b0000000000000000", + ); + + #[test] + fn native_two_character_packet_selects_its_second_existing_id() { + use crate::game::{GameState, Packet, LEVEL_GAME}; + use aaemu_game::opcodes::sc; + let body = hex::decode(TWO_CHARACTERS).unwrap(); + let mut state = GameState::default(); + state + .observe(&Packet { + level: LEVEL_GAME, + opcode: sc::SCCharacterListPacket, + body: body.clone(), + }) + .unwrap(); + assert!(state.char_list_done); + assert_eq!( + state.characters.iter().map(|c| c.id).collect::>(), + [10, 42] + ); + assert_eq!( + control_character(&state.characters, "Owner", None).unwrap(), + 42 + ); + assert_eq!( + control_character(&state.characters, "ignored", Some(42)).unwrap(), + 42 + ); + assert_eq!(state.characters[1].name, "Owner"); + let mut truncated = GameState::default(); + assert!(truncated + .observe(&Packet { + level: LEVEL_GAME, + opcode: sc::SCCharacterListPacket, + body: body[..body.len() - 1].to_vec() + }) + .is_err()); + assert!(truncated.characters.is_empty()); + assert!(!truncated.char_list_done); + } + + #[test] + fn control_never_falls_back_to_first_or_creates_a_missing_character() { + let characters = [ + CharInfo { + id: 10, + name: "Unrelated".into(), + }, + CharInfo { + id: 42, + name: "Owner".into(), + }, + ]; + assert_eq!(control_character(&characters, "owner", None).unwrap(), 42); + assert!(control_character(&characters, "missing", None).is_err()); + assert!(control_character(&[], "Owner", None).is_err()); + assert_eq!( + control_character(&characters, "renamed", Some(42)).unwrap(), + 42 + ); + assert!(control_character(&characters, "Owner", Some(43)).is_err()); + assert!(control_character(&characters, "Owner", Some(0)).is_err()); + } +} + +/// Connect once, selecting an existing character only. No creation or retries. +pub async fn connect_control( + cfg: &BotConfig, + rec: &Recorder, + character_id: Option, +) -> anyhow::Result { + ensure!( + !cfg.create_new_character, + "control cannot create characters" + ); + rec.control_game_ready(false); + let mut r = Runner { + rec, + out: Outcome::default(), + }; + let (mut game, stream, login) = open_lobby(Kind::Full, cfg, &mut r) + .await? + .context("game lobby was not opened")?; + let id = control_character(&game.state.characters, &cfg.character, character_id)?; + rec.control_game_ready(true); + select_and_spawn(&mut game, id, &mut r).await?; + Ok(ControlSession::new(game, stream, login)) +} + +/// Use the scenario's GM chat path without printing command text or replies. +pub async fn control_gm(game: &mut GameClient, command: &str) -> anyhow::Result<()> { + questitem::gm_command(game, command).await?; + Ok(()) +} + +/// The script `tp` sequence, using the position returned by the server. +pub async fn control_tp( + game: &mut GameClient, + x: f32, + y: f32, + z: f32, + clock: u32, + until: tokio::time::Instant, +) -> anyhow::Result<()> { + tokio::time::timeout_at(until, async { + game.state.last_teleport = None; + game.chat(0, &format!("/move {x} {y} {z}")).await?; + game.wait_sc(sc::SCTeleportUnitPacket).await?; + let at = game + .state + .last_teleport + .context("teleport position missing")?; + game.teleport_ended(at).await?; + game.move_to(at, clock).await?; + // The completion boundary is the received teleport and the two sent acknowledgments. + // Ambient traffic is not an action acknowledgment and need never become quiet. + // Pump any immediate replies for a small slice of the *remaining* action budget. + let remaining = until.saturating_duration_since(tokio::time::Instant::now()); + let max = remaining + .saturating_sub(Duration::from_millis(20)) + .min(Duration::from_millis(100)); + if !max.is_zero() { + game.drain(Duration::from_millis(10), max).await?; + } + Ok::<_, anyhow::Error>(()) + }) + .await + .context("teleport command deadline")? +} + +async fn run_inner( + kind: Kind, + cfg: &BotConfig, + r: &mut Runner<'_>, + script_input: Option<&ScriptInput<'_>>, +) -> anyhow::Result<()> { + let Some((mut game, stream, _login)) = open_lobby(kind, cfg, r).await? else { + return Ok(()); + }; + let s = r.begin("game.create"); let created = if cfg.create_new_character || game.state.characters.is_empty() { game.create_character(&cfg.character).await?; @@ -597,35 +857,7 @@ async fn run_inner( return Ok(()); } - // ---- world ---- - let s = r.begin("game.select"); - game.select_character(ch.id).await?; - game.wait_sc(sc::SCCharacterStatePacket).await?; - game.drain(QUIET, Duration::from_secs(10)).await?; - r.end(s, format!("{} bag items seen", game.state.bag_items.len())); - - let s = r.begin("game.spawn"); - game.spawn_character().await?; - game.wait_for("own SCUnitStatePacket", |p| p.is_sc(sc::SCUnitStatePacket)) - .await?; - game.notify_in_game().await?; - game.notify_in_game_completed().await?; - game.drain(QUIET, Duration::from_secs(15)).await?; - ensure!(game.state.self_obj != 0, "own unit state not received"); - r.var("self_obj", game.state.self_obj); - let npcs = game - .state - .units - .values() - .filter(|u| u.unit_type == 1) - .count(); - r.end( - s, - format!( - "obj {} at {:?}, {npcs} npcs visible", - game.state.self_obj, game.state.self_pos - ), - ); + select_and_spawn(&mut game, ch.id, r).await?; if kind == Kind::NpcReturn { npc_return(&mut game, cfg, r).await?; @@ -2132,3 +2364,181 @@ mod mate_revive_tests { assert_eq!("cometsboon".parse::().unwrap(), Kind::CometsBoon); } } + +#[cfg(test)] +mod control_session_tests { + use super::*; + use aaemu_commons::net::FrameCodec; + use aaemu_game::opcodes::cs; + use futures::{SinkExt, StreamExt}; + use tokio::io::{AsyncReadExt, AsyncWriteExt}; + use tokio::net::TcpListener; + use tokio_util::codec::Framed; + + fn frame(opcode: u16, body: &[u8]) -> Vec { + let mut frame = vec![0xdd, 1, 0, 0]; + frame.extend_from_slice(&opcode.to_le_bytes()); + frame.extend_from_slice(body); + frame + } + + #[tokio::test] + async fn teleport_completes_under_continuous_ambient_traffic() { + use crate::record::{Channel, Dir}; + + let (io, peer) = tokio::io::duplex(64 * 1024); + let rec = Recorder::new(true); + let mut game = GameClient::from_io(io, rec.clone()); + game.state.self_obj = 42; + let (stop, mut stopped) = tokio::sync::oneshot::channel(); + let peer = tokio::spawn(async move { + let mut peer = Framed::new(peer, FrameCodec); + let chat = peer.next().await.unwrap().unwrap(); + assert_eq!( + u16::from_le_bytes([chat[4], chat[5]]), + cs::CSSendChatMessagePacket + ); + let mut teleport = PacketStream::new(); + teleport + .write_u8(0) + .write_i16(0) + .write_position(10.0, 20.0, 30.0) + .write_f32(30.0); + peer.send(frame(sc::SCTeleportUnitPacket, teleport.as_bytes())) + .await + .unwrap(); + let ambient = frame(sc::SCErrorMsgPacket, &[7, 0]); + let mut sent = 0; + // Guarantee traffic after the teleport without depending on timer resolution. + for _ in 0..2 { + peer.send(ambient.clone()).await.unwrap(); + sent += 1; + } + let (mut writer, mut reader) = peer.split(); + let mut acks = Vec::new(); + let mut stop_requested = false; + { + // Keep a pending send alive across ACKs; backpressure must not block reads/stop. + let sending = async { + loop { + writer.send(ambient.clone()).await.unwrap(); + sent += 1; + tokio::task::yield_now().await; + } + }; + tokio::pin!(sending); + loop { + if stop_requested && acks.len() == 2 { + break; + } + tokio::select! { + biased; + _ = &mut stopped, if !stop_requested => stop_requested = true, + incoming = reader.next() => { + let bytes = incoming.unwrap().unwrap(); + acks.push(u16::from_le_bytes([bytes[4], bytes[5]])); + }, + _ = &mut sending => unreachable!("ambient sender runs until stopped"), + } + } + } + (sent, acks) + }); + let until = tokio::time::Instant::now() + Duration::from_secs(5); + tokio::time::timeout( + Duration::from_secs(1), + control_tp(&mut game, 10.0, 20.0, 30.0, 1500, until), + ) + .await + .unwrap() + .unwrap(); + assert!( + rec.events() + .iter() + .filter(|event| { + event.channel == Channel::Game + && event.dir == Dir::S2C + && event.level == crate::game::LEVEL_GAME + }) + .skip_while(|event| event.opcode != sc::SCTeleportUnitPacket) + .skip(1) + .filter(|event| { + event.opcode == sc::SCErrorMsgPacket && event.body_bytes() == [7, 0] + }) + .count() + >= 2 + ); + // The fixture keeps draining acknowledgments after this stop signal. + let _ = stop.send(()); + let (sent, acks) = tokio::time::timeout(Duration::from_secs(1), peer) + .await + .unwrap() + .unwrap(); + assert!(sent > 1); + assert_eq!(acks, [cs::CSTeleportEndedPacket, cs::CSMoveUnitPacket]); + // Assert the server's decoded position, including native Z quantization. + assert_eq!(game.state.observed_self_pos, Some((10.0, 20.0, 29.9995))); + game.disconnect_hard().await; + } + + #[tokio::test] + async fn hard_close_releases_real_game_reader_writer_and_stream_without_logout() { + // Ephemeral loopback fixtures only: no AAEmu process, login handshake, or database. + let game_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let stream_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let login_listener = TcpListener::bind("127.0.0.1:0").await.unwrap(); + let rec = Recorder::new(true); + let mut game = GameClient::connect( + &game_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let mut game_peer = game_listener.accept().await.unwrap().0; + let stream = StreamClient::connect( + &stream_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let mut stream_peer = stream_listener.accept().await.unwrap().0; + let login = LoginClient::connect( + &login_listener.local_addr().unwrap().to_string(), + rec.clone(), + ) + .await + .unwrap(); + let mut login_peer = login_listener.accept().await.unwrap().0; + let packet = frame(sc::SCErrorMsgPacket, &[7, 0]); + game_peer + .write_all(&(packet.len() as u16).to_le_bytes()) + .await + .unwrap(); + game_peer.write_all(&packet).await.unwrap(); + game.recv_within(Duration::from_secs(1)) + .await + .unwrap() + .unwrap(); + let session = ControlSession { + game, + stream, + _login: login, + }; + tokio::time::timeout(Duration::from_secs(1), session.disconnect_hard()) + .await + .unwrap(); + for peer in [&mut game_peer, &mut stream_peer, &mut login_peer] { + let mut bytes = Vec::new(); + tokio::time::timeout(Duration::from_secs(1), peer.read_to_end(&mut bytes)) + .await + .unwrap() + .unwrap(); + assert!( + bytes.is_empty(), + "close must emit no application logout or other packets" + ); + } + assert_eq!(rec.events().len(), 1); + assert_eq!(rec.events()[0].opcode, sc::SCErrorMsgPacket); + } +} diff --git a/rust/docs/audit-repair-status.json b/rust/docs/audit-repair-status.json new file mode 100644 index 0000000000..47a3debc4c --- /dev/null +++ b/rust/docs/audit-repair-status.json @@ -0,0 +1,619 @@ +{ + "audit": "2026-10-25 missing-feature audit", + "baseline": "37e6f1aec", + "status": "in_progress", + "policy": "A finding closes only with source evidence and appropriate validation; missing native/content evidence stays explicit.", + "sources": [ + "protocol-and-logs", + "opcode-table-gaps", + "items-economy", + "skills-combat-ai", + "quests-social-progression", + "housing-doodads", + "vehicles-pvp-instances", + "character-account-world" + ], + "items": [ + { + "id": "mail-return", + "status": "focused_passed", + "owner": "audit-protocol", + "commit": "305664ae23d7a552f5a6db90677cabec52fe9b3c" + }, + { + "id": "loot-error-width", + "status": "focused_passed", + "owner": "audit-protocol", + "commit": "305664ae23d7a552f5a6db90677cabec52fe9b3c" + }, + { + "id": "merchant-grade", + "status": "focused_passed_full_gate_pending", + "owner": "audit-economy", + "commit": "3de467a85f1c5aeed2efb2071030058ffeb8b29c" + }, + { + "id": "craft-grade-flags", + "status": "focused_passed_full_gate_pending", + "owner": "audit-economy", + "commit": "3de467a85f1c5aeed2efb2071030058ffeb8b29c" + }, + { + "id": "web-api-authentication", + "status": "focused_passed_full_gate_pending", + "owner": "audit-web", + "commit": "24b4699887d5350bc1a9e6f89267f98469fde8eb" + }, + { + "id": "housing-bench-plaque-permissions", + "status": "unit_and_data_passed_full_gate_pending", + "commit": "e2e9744b59d094b2ceb74c63626336664071a59f", + "note": "Construction19 fixtures corrected; full game unit suite and ignored compact plaque-pack checks pass at7ac." + }, + { + "id": "craft-bench-pack-and-required-doodad", + "status": "merged_pending_validation", + "commit": "e2e9744b59d094b2ceb74c63626336664071a59f" + }, + { + "id": "closed-and-unknown-zones", + "status": "focused_passed_full_gate_pending", + "commit": "e9a870b8c71e8e4dbf7509d7e72bbb33bcfef20a", + "note": "Unknown keys remain neutral; no invented safe destination. Parent corrected Doodad transform field after first compile check." + }, + { + "id": "national-tax-rate", + "status": "queued" + }, + { + "id": "vehicle-attachment-data", + "status": "partial_pending_rust_validation", + "commit": "ae83bd8f6609df3dab5943dba2420733b08c5de4", + "parent_native_python_tests_passed": 8, + "transforms_added": 87, + "item_summonable_templates_fixed": 14, + "item_summonable_templates_total": 22, + "open_required_points": 41, + "note": "Missing native assets/prefabs/helpers are explicit; no invented origin points." + }, + { + "id": "ordinary-warning-noise-and-cleanup-cause", + "status": "queued" + }, + { + "id": "slave-owned-doodad-housing-lookup", + "status": "queued" + }, + { + "id": "aoe-diminishing", + "status": "runtime_merged_pending_retest", + "commit": "e6f6920da", + "note": "Plot-scoped first-seen distinct-target ranks/reset/clamp are explicit compatibility policy. Nativeworld-servercounter unavailable.10/11firstflows passed; health fixture corrected." + }, + { + "id": "skill-and-buff-modifiers", + "status": "merged_pending_validation", + "commit": "80303b48a224d83e88c17262ef92493b8b38f79c", + "open_subcases": [ + "Vicious Implosion10710 plot580 radius", + "Crippling Mire10201 plot320 channel duration" + ] + }, + { + "id": "buff-group-rank-and-per-caster-slots", + "status": "queued" + }, + { + "id": "reflection", + "status": "queued" + }, + { + "id": "attack-speed", + "status": "merged_pending_validation", + "commit": "80303b48a224d83e88c17262ef92493b8b38f79c" + }, + { + "id": "buff-breakers", + "status": "runtime_merged_pending_validation", + "commit": "8fe6039ee99476591ec43a5c0f513fd05e25d658", + "note": "Accepted-state compatibility policy. Lifetime identities stop reentrant Started callbacks leaking modifiers; native timing remains unverified." + }, + { + "id": "buff-taunts", + "status": "queued" + }, + { + "id": "casting-hit-delay-and-cancellation", + "status": "queued" + }, + { + "id": "item-procs-and-set-procs", + "status": "queued" + }, + { + "id": "shared-cooldown-tags", + "status": "merged_pending_execution", + "note": "Native separate skill/tag snapshots and GM reset; root af5db95ba additionally isolates controlled-unit UI. Game all-target Clippy passed at af5db95ba; runtime regressions pending.", + "commit": "47217398ade1f50f9957b15a1e6ec1a72428eaa7" + }, + { + "id": "xp-buff-multiplier", + "status": "merged_pending_validation", + "commit": "80303b48a224d83e88c17262ef92493b8b38f79c" + }, + { + "id": "zone-banned-item-and-skill-tags", + "status": "partial_merged_pending_validation", + "commit": "9dd3453085a829513db7bff1e1a80cc55a9963c3", + "note": "324unconditional rules enforced;9period24rules and Library1581missingmembership remain open." + }, + { + "id": "unit-and-primary-stat-limits", + "status": "partial_merged_pending_validation", + "commit": "ed2f7a9f3", + "note": "Native final raw unit caps implemented per server. Permanent pStat contribution ranges are loaded; contribution storage/behavior remain open. No final-primary 10000 cap invented." + }, + { + "id": "prison-and-other-skill-restrictions", + "status": "queued" + }, + { + "id": "damage-threat-percent-health-and-level-interpolation", + "status": "partial_merged_pending_validation", + "commit": "917759c3fb637dec43adbb2d930da37f31b4a71a", + "note": "Authored floatlevel range/threat/HP-percent and numeric guards; percent/HP unit interpretation documented, target_health predicates remain open." + }, + { + "id": "recipe-learning", + "status": "queued" + }, + { + "id": "npc-groups", + "status": "queued" + }, + { + "id": "npc-linked-aggro-and-missing-ai", + "status": "queued" + }, + { + "id": "npc-alert-dead-events-and-friendship", + "status": "queued" + }, + { + "id": "remaining-buff-attributes-and-controller-kinds", + "status": "queued" + }, + { + "id": "stealth-visibility", + "status": "queued" + }, + { + "id": "trade-pack-pricing-config-ratios-and-persistence", + "status": "queued" + }, + { + "id": "premium-and-aa-points", + "status": "queued" + }, + { + "id": "second-password-and-item-security", + "status": "queued" + }, + { + "id": "item-level-gender-pickup-and-use-limits", + "status": "queued" + }, + { + "id": "tempering-and-socket-data-rules", + "status": "queued" + }, + { + "id": "craft-binding-and-required-grade", + "status": "queued" + }, + { + "id": "mail-expiry-throttling-feedback-and-pagination", + "status": "partial_merged_pending_validation", + "commit": "e712343a3211076ddef5db75658e6075aaa47bac", + "note": "Ordinary player-mail 14-day retention/return-once escrow policy implemented. Specialized mail, send throttles/level gates and pagination remain open. New ordinary expiry tests unexecuted." + }, + { + "id": "npc-physical-enchant", + "status": "queued" + }, + { + "id": "auction-filter-limits-and-authority", + "status": "queued" + }, + { + "id": "missing-item-and-quest-feedback-packets", + "status": "queued" + }, + { + "id": "quest-spawn-coverage", + "status": "queued" + }, + { + "id": "nation-and-faction-flows", + "status": "queued" + }, + { + "id": "bounty-board", + "status": "queued" + }, + { + "id": "achievement-producers", + "status": "queued" + }, + { + "id": "quest-and-skill-unit-requirements", + "status": "queued" + }, + { + "id": "trial-jury-expedition-rename-and-quest-edge-fields", + "status": "queued" + }, + { + "id": "doodad-phase-messages", + "status": "queued" + }, + { + "id": "territory-statue-insert-counter", + "status": "queued" + }, + { + "id": "navigation-doodad-expiry", + "status": "queued" + }, + { + "id": "crest-printer-and-ucc", + "status": "queued" + }, + { + "id": "house-repair-and-farm-notifications", + "status": "queued" + }, + { + "id": "doodad-area-trigger-and-evidence-loot", + "status": "queued" + }, + { + "id": "remaining-gathering-funcs", + "status": "queued" + }, + { + "id": "puzzle-machines", + "status": "queued" + }, + { + "id": "doodad-placement-surface-and-bundle-rules", + "status": "queued" + }, + { + "id": "battle-pet-behavior-and-equipment", + "status": "queued" + }, + { + "id": "movement-validation", + "status": "queued" + }, + { + "id": "ship-handling-data", + "status": "queued" + }, + { + "id": "shipyard-salvage", + "status": "queued" + }, + { + "id": "instance-spawn-data", + "status": "queued" + }, + { + "id": "instance-channel-and-client-driven-entry", + "status": "queued" + }, + { + "id": "arena-restrictions-and-mirrored-instance-bugs", + "status": "queued" + }, + { + "id": "siege-calendar-tickets-reinforcement-and-notifications", + "status": "queued" + }, + { + "id": "racing", + "status": "queued" + }, + { + "id": "remaining-geometry-and-physics-data", + "status": "queued" + }, + { + "id": "cooldown-persistence", + "status": "queued" + }, + { + "id": "disconnect-duplicate-login-and-dead-relogin", + "status": "queued" + }, + { + "id": "resurrection-waits-and-server-enforcement", + "status": "queued" + }, + { + "id": "name-chat-filtering-throttle-and-moderation", + "status": "partial_merged_pending_validation", + "note": "Native ASCII block-name rules implemented in7441d62; chat/throttle/moderation remain open." + }, + { + "id": "character-recustomization", + "status": "queued" + }, + { + "id": "character-slots-races-and-deletion-guards", + "status": "partial_merged_pending_validation", + "commit": "7441d62bcd2b85b89f907cf072428edad1ce1553", + "open_subcases": [ + "nation/penalty/bot/transfer deletion policy", + "ownership transfer atomicity", + "delayed expiry guard recheck" + ] + }, + { + "id": "event-schedule-notifications", + "status": "queued" + }, + { + "id": "login-capacity-and-auth-rate-limits", + "status": "queued" + }, + { + "id": "missing-buff-and-skill-controller-static-data", + "status": "queued" + }, + { + "id": "deprecated-empty-or-client-only-data", + "status": "queued", + "note": "Verify before deciding no server implementation is required." + }, + { + "id": "trade-ship-cargo-reference-atomicity", + "status": "ci_selected_checks_and_bounded_live_observation_verified", + "owner": "audit-tradeship", + "note": "At198b7d482 the official lane CI, the game unit suite and the explicit native Merchant all20rack cycle, private MySQL saved-alias and recycled-GUID checks pass. Independent cargo/SQL audit R36 found no P1/P2 for the positive 80-operation rack run; the R37 control audit found no P1 and its single P2 evidence qualification is resolved by explicit wording. The bag-negative and hard-close/reselect controls pass; in the second same-item resummon attempt the skill executed (started, fired, ended) and the subsequent loaded-hull replacement was refused with SCErrorMsg 801 SLAVE_EQUIPMENT_LOADED_ITEM, so it shows loaded-hull preservation; unloaded replacement and 600 s timer completion were not exercised in this live run. Conservative cargo/container retention and reconciliation/GC limits remain.", + "commit": "8c2e977b5ba6b7660e4739964465e0b1e97b9d7b" + }, + { + "id": "trade-ship-live-root-identity-after-reconnect", + "status": "source_reviewed_ci_selected_checks_and_bounded_live_observation", + "owner": "audit-ship-session", + "note": "Three source review rounds clean after item publication, query-error/orphan, callback spawn-lock ordering and stale cargo receipt fixes. At198b7d482 the official lane CI and the selected ship save-fence/query-failure/restart checks pass. One bounded headless hard-close reselect left the same loaded hull registered and visible with a single current root, and in the second same-item summon attempt the skill executed and the subsequent loaded-hull replacement was refused with 801, leaving hull, racks, cargo and phases unchanged; unloaded replacement and 600 s timer completion were not exercised in this live run. Intentional600s retention remains. Guardless/direct-write limitations explicit.", + "commit": "54f98af143f8458175dc76ffe9afad132ec3b680" + }, + { + "id": "lane-allocation-concurrency", + "status": "focused_passed_full_gate_pending", + "owner": "audit-lane-lock", + "note": "15 isolated root Python tests passed; original allocator fails concurrent allocation. Two real concurrent probe lanes received distinct prefixes and were removed. Windows/Linux workflow now runs the suite.", + "commit": "090f515b6" + }, + { + "id": "headless-control-reconnect-test-interface", + "status": "source_reviewed_package_tests_and_lane_ci_passed_bounded_live_use", + "commit": "578a6a7e68a8ea663eafdb5487f5f8d8f2a09180", + "note": "Fourth source review clean after an executed regression exposed expired Tokio timer first-poll behavior. Synchronous guards preserve EOF priority and reject expired command/global/output budgets before action polling. At96a67a5, all57 library and16 control/config tests pass, including real loopback hard-close and timeout flows; both counts are unchanged in the198b7d482 lane CI. The bounded live reconnect control used it without a deadline overrun (see current_live); captures are normalized and filtered." + }, + { + "id": "ship-identity-observational-diagnostics", + "status": "source_reviewed_ci_passed_live_observational", + "commit": "6a406e5da2d319bc61cc073e761d4d3c08a005d9", + "note": "Source review findings closed; the diagnostic, authority and retirement consistency flags all remain false. Supporting observations only, not a globally atomic authority proof; live use at198b7d482 stays observational." + } + ], + "recent_validation": { + "game_check": { + "head": "0cf0f23f500628ca6a0dc0cc6d46ecebc16ac9b8", + "result": "passed_all_targets" + }, + "game_clippy": { + "head": "af5db95ba0687dcc4cfb7b164af77bbd038b28cc", + "result": "passed_all_targets_D_warnings" + }, + "latest_mail_stats_clippy": { + "head": "dbd7cd95251ebc692a913128b650ba25b74ba1d9", + "result": "held_at_memory_reserve_before_completion", + "minimum_free_gib": 5.938747406005859 + }, + "current_full_lane_ci": { + "head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "tree": "6795208a05103b9b090120606b166a59a0c88497", + "result": "passed", + "command": "Scripts/lane.sh check (cargo xtask ci)", + "native_exit": 0, + "elapsed_seconds": 91.10899999999674, + "minimum_free_gib": 12.508186340332031, + "source_unchanged": true, + "testclient_library_passed": 57, + "testclient_binary_passed": 16, + "scope": "Local official lane check; the full source build passed at the same head and tree." + }, + "current_live": { + "status": "bounded_observational_controls_verified_with_loaded_hull_replacement_refused_801", + "executed_source_head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "executed_source_tree": "6795208a05103b9b090120606b166a59a0c88497", + "scope": "Observed only on the executed source head above. Later documentation-only commits and checks do not change what was observed; the final documentation HEAD was not run live.", + "runtime_artifacts": "8 target/runtime EXE/PDB hashes and 4 native GUID/age pairs matched the executed source; no Rust source change since.", + "supporting_external_harness": { + "scope": "External PowerShell/Python driver and offline helper tests; not committed Rust tests and not retail proof.", + "helper_tests_passed": 191, + "helper_tests_skipped": 0, + "helper_test_manifest_sha256": "e9bf4b93b0d478b2c5241482feadc30ce4dd209bbf25fd488b7c5d00a1abbec2", + "helper_test_manifest_scope": "external main 191-test helper manifest", + "grid_preflight_mock_tests_passed": 209, + "grid_preflight_suites": "75+50+84 in three separate unittest processes", + "independent_source_review": "R33 and R34 clear" + }, + "ground_grid_preflight": { + "review": "R35 independent raw/persistence/stop audit clear", + "water_nodes_observed": 20, + "instance": 0, + "pitch_metres": 6, + "min_depth_observed": 58.03979, + "surface_height": 100, + "cached_zone_observed": 180, + "spare_pack_drop_recover_roundtrips": 1, + "same_item_guid_after_recover": true, + "wrapper_elapsed_seconds": 43.703, + "exit": "OS exit 0, STOP0; same spare item back in equipment slot 26; no surviving doodad references.", + "prior_cargo_affected": false, + "scope": "20 sampled water nodes plus one same-GUID spare drop/recover on the headless Rust-server path", + "not_proven": "static objects; open water beyond the sampled nodes; the actual cast zone" + }, + "full_merchant_run": { + "driver_status": "OBSERVATIONAL_SCENARIO_COMPLETE", + "driver_elapsed_seconds": 362.078, + "fresh_owners": 1, + "reported_counts": { + "loads": 40, + "unloads": 40, + "drops": 40, + "pickups": 20, + "negative_cases": 1, + "hard_drops": 1, + "reconnects": 1, + "resummon_attempts": 1 + }, + "reported_counts_note": "resummon_attempts is the raw driver count of one accepted same-item skill attempt: the skill executed, then the subsequent loaded-hull replacement was refused with 801. It is not a successful new hull.", + "run_conditions": "No retries, cap changes, original-item destroy, regrant or cooldown clearing; timing budgets unchanged; control cleanup completed.", + "initial_verifier_correction": "The initial read-only SQL verifier assumed character owner_type 1 instead of 254 and filtered saved racks by owner_id instead of house_id. Corrected source-derived filters returned unchanged common rows plus the 20 saved racks; no runtime or data retry.", + "r36_independent_cargo_sql_audit": { + "result": "CLEAR, no P1/P2 for the positive cargo run", + "positive_rack_operations": 80, + "racks_attached": "all 20 (attachment points 60..79) in 4 passes", + "drops": 40, + "pickups": 20, + "accepted_skill_timelines": 143, + "original_add_payloads_with_identical_immutable_fields": 160, + "unique_original_item_ids_kept_identical": 20, + "final_ground_references": 20, + "final_item_container": "System", + "final_saved_racks_empty": 20, + "glider_retained_in_bag": true, + "summon_item_and_saved_hull_retained": true, + "post_stop_sql_closure_checks_passed": 8, + "destroy_calls": "only recorded filler items (template 6735)", + "labor": "one natural credit of +10, no debit", + "wire_note": "Sanitized, expanded wire summaries; not original compressed or retail captures." + }, + "r37_independent_control_audit": { + "result": "No P1; one P2 evidence qualification, resolved by the explicit resummon wording below (skill executed, subsequent loaded-hull replacement refused with 801). No rerun.", + "scope": "Negative, hard-close reconnect, same-item resummon attempt, root identity, deadlines, logs and cleanup; source and sanitized/normalized captures only, no private configuration or secrets read.", + "bag_negative": "One accepted negative on an attached rack: skill timeline started, fired, then ended with error 207; nothing else in the window. Bag 50/50 (5 existing plus 45 recorded filler items); real glider kept in its equipment cell; all inventory, rack and phase state unchanged; no item-task or phase packets. The 45 destroy calls hit only the recorded fillers (not originals, glider or summon); the glider was legally swapped into the bag.", + "hard_close": "Game and Stream connections both closed without a LeaveWorld; the same character was reselected once (connection 1 to 5); the same hull stayed registered and visible; retirement job generation 1 stayed waiting on its timer, still pending; reconnect leave generation reset to 0.", + "resummon_attempt": "The second same-item skill executed (accepted timeline: started, fired, ended), then SCErrorMsg 801 SLAVE_EQUIPMENT_LOADED_ITEM refused the subsequent loaded-hull replacement: the existing hull (template 75), all 20 racks, cargo and phases were preserved, drift 0, and only the initial SCSlaveCreated appears in the captures. So it shows loaded-hull preservation and a single root after reconnect; unloaded replacement and 600 s timer completion were not exercised in this live run.", + "root_identity": "91 audit chunk groups, all from the observer, with valid FNV checksums and nonces; 90 post-summon samples show a single current root and no other live root; the three consistency flags remain false. These are temporal observations, not global authority.", + "deadlines": "2892 requests, 2892 ok, none past their deadline; 141 operations (all 140 positive at 2.49 s or less, negative 1.58 s); 362.078 s total with 181.567 s reserve and a 537.015 s effective cap inside 540 s; no retries, cooldown clearing or cap changes. Reconnect used 16.9 s of its 20 s budget (3.1 s margin).", + "logs": "138 WARN lines (136 TeleportEnded, 1 slow tick, 1 expected negative Doodad item-reference refusal) and 1 ERROR (Login link, after the forced Login-before-Game STOP); 0 panics; startup excluded. The stop was forced, not a graceful shutdown, and the logs are not warning- or error-free.", + "cleanup": "All 8 runtime artifact hashes match; independent STOP0 with no owned Login/Game/Testclient process and 0 of the 5 lane ports. Authentication entries are omitted by the source and rejected by the adapter.", + "minor_qualifications": "The stage label after the negative was persisted but the rolling deadlines stayed valid. The observer was a living character 2.83 m from node 79, which is not a static-object mask." + } + }, + "full_merchant80_acceptance": "Accepted for this one bounded headless run: 80 positive rack operations, 40 drops, 20 pickups, original-20 identity and final persisted SQL closure, with qualified controls. The same-item skill executed; subsequent loaded-hull replacement was refused with 801 and the existing hull was preserved. This is not a full-scenario pass, retail parity or global proof; the wider audit remains in_progress.", + "final_stop": "Independent STOP0: no owned Login/Game/Testclient process or lane listener (0 of the 5 lane ports); the 8 runtime artifact hashes, the clean source at the executed head and the 26 verified helper pins unchanged; shared MySQL TCP responds only.", + "proof_limits": [ + "One bounded fresh owner on the headless Rust-server path; not retail parity, all world actors, all interleavings or global atomicity.", + "Post-STOP0 SQL proves the persisted end state only, not the exact save time or save order; DB item details are not asserted byte-identical to the wire serializer.", + "The doodad wire carries no item GUID; the native-to-item mapping is correlated and bound by the persisted row after STOP0.", + "The diagnostic, authority and retirement consistency flags remain false; queued, HP, world, phase and sampling exclusions and guardless or direct writes remain.", + "The 600 s offline hull retention and the root-versus-portal rendering distinction remain intentional.", + "The final 20 originals are legal world ground doodads in System, not bag items; backpack type 3 cannot be stowed. The glider is a type 2 bag item.", + "In the same-item resummon attempt the skill executed and the subsequent loaded-hull replacement was refused with 801; unloaded replacement, replacement of a retired hull and 600 s retirement-timer completion were not exercised in this live run.", + "Process stop was forced and the logs contain warnings and one Login-link error; the run is not claimed clean or gracefully shut down.", + "Passing CI closes no unrelated finding; the open wider-audit items are unchanged (9 timed zone bans, pStat contribution storage, 41 missing native attachment points, orphan reconciliation/GC; AoE rank/reset and immediate buff-break timing remain compatibility policy; tester-incident root cause is unattributed)." + ] + }, + "game_unit_tests": { + "head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "passed": 2878, + "failed": 0, + "ignored": 149, + "result": "passed", + "minimum_free_gib": 12.508186340332031, + "source_unchanged": true, + "scope": "Game package inside the official lane check." + }, + "latest_corrected_builds": { + "head": "5dfd7282b71ec84655b44b861b24991502dd5ff2", + "clippy": "held_at_memory_reserve", + "game_tests": "held_at_memory_reserve_before_execution" + }, + "cargo_source_review": { + "head": "8c2e977b5ba6b7660e4739964465e0b1e97b9d7b", + "round": 3, + "result": "no_new_actionable_P1_P2_within_documented_conservative_policy", + "execution": "pending" + }, + "cargo_integrated_game_build": { + "head": "8db0e003df5c329d9ee6522b09a26d0c7158dfc0", + "result": "held_at_memory_reserve_before_tests", + "minimum_free_gib": 7.936, + "native_diagnostics": "none before guard stopped the owned compiler subtree" + }, + "selected_ignored_snapshot_checks": { + "binary_head": "1f53a66bdd0ab289ae2a26abbbaff084cddfcaff", + "binary_sha256": "836cf147a09b999582e302e8dae807cbd6d867e65a99da120abaa3ccc1009230", + "scope": "previously compiled snapshot; not final-head acceptance", + "compact_passed": 9, + "private_mysql_lobby_passed": 3, + "mail_expiry": "fixture signed/unsigned decode mismatch found; fixed da8e370ba, rebuilt execution pending", + "database_scope": "private 3317 lane_audit_final_game; connection-local temporary tables" + }, + "remote_checks": { + "head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "passed": 12, + "failed": 0, + "scope": "Draft PR46 Windows/Linux build/tests/Clippy plus coverage, formatting, packet checks and other configured jobs." + }, + "selected_ignored_current_checks": { + "head": "198b7d4821df6d930c14c8a5d38c64846a43efe1", + "binary_sha256": "51af57b83663b74078c8ab7ac3972f124ba2d291b7319b7d53a2eaa43213dcaa", + "attach_binary_sha256": "b06ba24f7d211585737d536f486114c0ca550ce10c03bc3662680544fecbae22", + "passed": 20, + "failed": 0, + "compact_checks": 12, + "private_mysql_checks": 8, + "environment_skips": 0, + "scope": "Explicit ignored tests run one selector per process; private 3317 lane_audit_final_game uses connection-local temporary tables. Includes Merchant twenty-rack cycles, both cargo persistence/allocator-reuse fixtures, ship query-failure/retry/save-fence/restart, legacy intentional-empty equipment and lobby/mail checks. Only these 20 explicit selectors; the other ignored tests were not run." + }, + "combined_compilation": { + "head": "243953bdab1c077a93e02e71948f24ac03d5744a", + "result": "passed_game_and_testclient_all_targets", + "native_exit": 0, + "minimum_free_gib": 9.208076477050781, + "elapsed_seconds": 133.625 + }, + "combined_clippy": { + "head": "ce4b860e9ea4a5d91ee029a0cda354b14d72bce8", + "result": "passed_game_and_testclient_all_targets_D_warnings", + "native_exit": 0, + "minimum_free_gib": 6.0239105224609375, + "elapsed_seconds": 109.36 + }, + "testclient_package": { + "head": "96a67a5a7a31a90ea66fdf42deecdbd42885fdb0", + "library_passed": 57, + "binary_passed": 16, + "failed": 0, + "native_exit": 0, + "minimum_free_gib": 10.375419616699219, + "source_unchanged": true + }, + "combined_seam_review": { + "head": "243953bdab1c077a93e02e71948f24ac03d5744a", + "tree": "742610fc88eec28566af33df34aae9086870d2c2", + "result": "no_new_concrete_P1_P2_within_declared_source_scope", + "execution": "none" + } + } +} diff --git a/rust/tools/slave_attach_points.provenance.json b/rust/tools/slave_attach_points.provenance.json new file mode 100644 index 0000000000..e7f9033bec --- /dev/null +++ b/rust/tools/slave_attach_points.provenance.json @@ -0,0 +1,4137 @@ +{ + "baseline": "37e6f1aec", + "format": "native 1.2 r208022; see slave_attach_points.py docstring", + "models": [ + { + "model": 2, + "slaves": [ + 2, + 41, + 107 + ], + "item_summonable_slaves": [ + 2 + ], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 66, + "slave": 41, + "owner_type": "Slave" + } + ] + } + }, + "issues": [], + "normal": "prefab://prefabs/siege_weapon.xml/trebuchet_a.trebuchet_a", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/trebuchet_a.chr", + "sha256": "8b66d1799d753c27b9e7b88ec59c43bd16b5efb686ae0cc309cd4497e3c2195b" + }, + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 4, + "slaves": [ + 4, + 42 + ], + "item_summonable_slaves": [ + 4, + 42 + ], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 57, + "slave": 4, + "owner_type": "Slave" + } + ] + } + }, + "issues": [], + "normal": "prefab://Prefabs/siege_weapon.xml/ground.ram", + "inspected_assets": [ + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 5, + "slaves": [ + 5 + ], + "item_summonable_slaves": [ + 5 + ], + "required": [ + 24, + 35, + 81 + ], + "already_present": [], + "points": { + "24": { + "location": { + "X": -1.42433345, + "Y": -6.89326668, + "Z": 0.83646423, + "Roll": 7.89580808, + "Pitch": 0.0, + "Yaw": 179.99999135 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siege_tower_a.chr", + "node": "ladder_left", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 492, + "slave": 5, + "owner_type": "Slave" + } + ] + }, + "35": { + "location": { + "X": -0.39981079, + "Y": 2.3511963, + "Z": 15.238708, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/prefabs/siege_tower.xml", + "node": "$helms", + "parents": [], + "kind": "prefab-helper", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 480, + "slave": 5, + "owner_type": "Slave" + } + ] + }, + "81": { + "location": { + "X": -1.98440182, + "Y": -1.09256768, + "Z": 14.48642063, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siege_tower_a.chr", + "node": "bell", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 478, + "slave": 5, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/siege_tower.xml/siege_tower.siege_tower_normal", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/siege_tower_a.chr", + "sha256": "4b06478c604794cf394e374e8acd3f1fb80822f8af9a5aef0cd17953c91b6ba5" + }, + { + "path": "game/prefabs/siege_tower.xml", + "sha256": "cfacf17dd88de16f2e0cb71208154cc1032928ab67b678cff86bcf2e63fd9c8a" + } + ] + }, + { + "model": 6, + "slaves": [ + 6, + 16, + 18, + 30, + 43 + ], + "item_summonable_slaves": [ + 6, + 43 + ], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 59, + "slave": 6, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "asset absent: game/objects/env/architecture/siege/siegeweapon/ballista_a/ballista_a.chr" + ], + "normal": "prefab://Prefabs/siege_weapon.xml/ground.ballista_a", + "inspected_assets": [ + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 115, + "slaves": [ + 9 + ], + "item_summonable_slaves": [ + 9 + ], + "required": [ + 9, + 10, + 11, + 12, + 18 + ], + "already_present": [], + "points": {}, + "unresolved": { + "9": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon0", + "$cannon0" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 2, + "slave": 9, + "owner_type": "Slave" + } + ] + }, + "10": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon1", + "$cannon1" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 4, + "slave": 9, + "owner_type": "Slave" + } + ] + }, + "11": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon2", + "$cannon2" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 5, + "slave": 9, + "owner_type": "Slave" + } + ] + }, + "12": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon3", + "$cannon3" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 6, + "slave": 9, + "owner_type": "Slave" + } + ] + }, + "18": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$hook", + "$hook" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 3, + "slave": 9, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_body.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_sail1.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_sail2.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/ladder_r.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/ladder_l.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_rudder.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_helms.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_anchor.chr", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_sail1.chr", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_sail2.chr" + ], + "normal": "prefab://Prefabs/ship.xml/caravel.ship_body", + "inspected_assets": [ + { + "path": "game/prefabs/ship.xml", + "sha256": "78a8be4a6ea90707e331c41d31faea95d11026800d1451d74666c10bf003f02d" + } + ] + }, + { + "model": 127, + "slaves": [ + 13 + ], + "item_summonable_slaves": [ + 13 + ], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 10, + "slave": 13, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "'game/objects/env/nuia/props/carriage/carriage_a.cgf'" + ], + "normal": "cgf://objects/Env/nuia/props/carriage/carriage_a.cgf", + "inspected_assets": [] + }, + { + "model": 129, + "slaves": [ + 15, + 55, + 91 + ], + "item_summonable_slaves": [ + 15, + 55, + 91 + ], + "required": [ + 2, + 9, + 10, + 29, + 35, + 36 + ], + "already_present": [ + 1, + 2, + 24, + 25, + 29, + 35, + 36 + ], + "points": {}, + "unresolved": { + "9": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon0", + "$cannon0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 85, + "slave": 55, + "owner_type": "Slave" + } + ] + }, + "10": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon1", + "$cannon1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 87, + "slave": 55, + "owner_type": "Slave" + } + ] + } + }, + "issues": [], + "normal": "prefab://prefabs/smallboat.xml/smallboat.smallboat_a", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/01_ship/smallboat/smallboat_body.cgf", + "sha256": "074c9f9efe0715d9c3b4df92223e83d05d75c1877ffc4b9327871b7353b7f043" + }, + { + "path": "game/prefabs/smallboat.xml", + "sha256": "cd6ea7d7fcad18abc58cc5f4d94113a1ecfab7500ace982646eaa6d7ecb9097d" + } + ] + }, + { + "model": 130, + "slaves": [ + 17 + ], + "item_summonable_slaves": [ + 17 + ], + "required": [ + 9 + ], + "already_present": [], + "points": {}, + "unresolved": { + "9": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon0", + "$cannon0" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 8, + "slave": 17, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "asset absent: game/objects/env/nuia/props/ship/caravel/ray.cgf", + "asset absent: game/objects/env/nuia/props/ship/caravel/caravel_helms.cgf" + ], + "normal": "prefab://Prefabs/ship.xml/ray.ship_body", + "inspected_assets": [ + { + "path": "game/prefabs/ship.xml", + "sha256": "78a8be4a6ea90707e331c41d31faea95d11026800d1451d74666c10bf003f02d" + } + ] + }, + { + "model": 392, + "slaves": [ + 19 + ], + "item_summonable_slaves": [], + "required": [ + 0 + ], + "already_present": [], + "points": {}, + "unresolved": { + "0": { + "reason": "None (0): no named attach transform", + "consumers": [ + { + "table": "slave_bindings", + "row": 11, + "slave": 19, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "model descriptor 392 absent from compact" + ], + "inspected_assets": [] + }, + { + "model": 512, + "slaves": [ + 23 + ], + "item_summonable_slaves": [], + "required": [ + 2, + 3, + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 35, + 36, + 37, + 38, + 39 + ], + "already_present": [], + "points": {}, + "unresolved": { + "2": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "bone_spine_passenger", + "$passenger0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 65, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "3": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "bone_spine_passenger1", + "$passenger1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 66, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "9": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon0", + "$cannon0" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 35, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "10": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon1", + "$cannon1" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 36, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "11": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon2", + "$cannon2" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 37, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "12": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon3", + "$cannon3" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 38, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "13": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon4", + "$cannon4" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 39, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "14": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon5", + "$cannon5" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 40, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "15": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon6", + "$cannon6" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 41, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "16": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$cannon7", + "$cannon7" + ], + "consumers": [ + { + "table": "slave_bindings", + "row": 42, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "19": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$mast0", + "$mast0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 23, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "20": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$mast1", + "$mast1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 24, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "21": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$sail0", + "$sail0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 25, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "22": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$sail1", + "$sail1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 26, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "23": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$anchor", + "$anchor" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 33, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "24": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$ladder_left", + "$ladder_left" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 27, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "25": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$ladder_right", + "$ladder_right" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 28, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "26": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$plank_left", + "$plank_left" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 31, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "27": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$plank_right", + "$plank_right" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 32, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "28": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$lamp_front", + "$lamp_front" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 29, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "29": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$lamp_rear", + "$lamp_rear" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 30, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "35": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$helms", + "$helms" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 47, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "36": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point0", + "$heal_point0" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 10, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "37": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point1", + "$heal_point1" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 11, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "38": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point2", + "$heal_point2" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 12, + "slave": 23, + "owner_type": "Slave" + } + ] + }, + "39": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point3", + "$heal_point3" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 13, + "slave": 23, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "'game/prefabs/galleon02.xml'" + ], + "normal": "prefab://Prefabs/galleon02.xml/galleon02.galleon_step10_normal", + "inspected_assets": [] + }, + { + "model": 857, + "slaves": [ + 36 + ], + "item_summonable_slaves": [ + 36 + ], + "required": [ + 2 + ], + "already_present": [], + "points": {}, + "unresolved": { + "2": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "bone_spine_passenger", + "$passenger0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 55, + "slave": 36, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "'game/objects/env/06_unit/04_siegeweapon/siegetank.chr'" + ], + "normal": "cga://objects/Env/06_unit/04_siegeweapon/siegetank.chr", + "inspected_assets": [] + }, + { + "model": 866, + "slaves": [ + 44 + ], + "item_summonable_slaves": [ + 44 + ], + "required": [ + 35 + ], + "already_present": [], + "points": {}, + "unresolved": { + "35": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$helms", + "$helms" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 57, + "slave": 44, + "owner_type": "Slave" + } + ] + } + }, + "issues": [], + "normal": "prefab://prefabs/galleon.xml/galleon.woodpiece01", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_item03.cgf", + "sha256": "fe7acf71f2d8e87d27caf06e5e4cdd459e511d8dc56bf635b004b67356762883" + }, + { + "path": "game/prefabs/galleon.xml", + "sha256": "7ed7617d4ef68de5c60e336cf7c2a4a21486d4e2f6ae8d77a5820773fd569cda" + } + ] + }, + { + "model": 867, + "slaves": [ + 45 + ], + "item_summonable_slaves": [ + 45 + ], + "required": [ + 35 + ], + "already_present": [], + "points": { + "35": { + "location": { + "X": 0.0, + "Y": -2.2049498, + "Z": 2.60459892, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/speedboat/speedboat_a.cgf", + "node": "$helms", + "parents": [ + "body", + "speedboat_a" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 58, + "slave": 45, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://Prefabs/speedboat.xml/speedboat_a.speedboat_hwang", + "inspected_assets": [ + { + "path": "game/objects/box.cgf", + "sha256": "921141b30889f84f0d8f1867da15aecdc15bd26672e12e666ebe7185406f8858" + }, + { + "path": "game/objects/env/06_unit/01_ship/speedboat/speedboat_a.cgf", + "sha256": "a14e2bd1d3ba67a5fe18cafbf9218a1b4b85465e5b32c3dd8f9814fa07907089" + }, + { + "path": "game/prefabs/speedboat.xml", + "sha256": "1ad4c9a7f32fc58ea29cc8ebbbc2b20e48ed3a1dac610869b4dd0bcca1f3630e" + } + ] + }, + { + "model": 892, + "slaves": [ + 46, + 53, + 84 + ], + "item_summonable_slaves": [ + 46 + ], + "required": [ + 9 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "node": "cannon0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_yaw", + "pocenter", + "bone_rail" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 473, + "slave": 46, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/siege_weapon.xml/siegetank_a.siegetank_a", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "sha256": "47cb57abd0304f91f6b0ebae25f59258547f8eb1f18e44c23bb7883b7e1b4bd7" + }, + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 898, + "slaves": [ + 50, + 136 + ], + "item_summonable_slaves": [ + 50 + ], + "required": [ + 9 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "node": "cannon0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_yaw", + "pocenter", + "bone_rail" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 474, + "slave": 50, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 670, + "slave": 136, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/siege_weapon.xml/siegetank_b.siegetank_b", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "sha256": "47cb57abd0304f91f6b0ebae25f59258547f8eb1f18e44c23bb7883b7e1b4bd7" + }, + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 899, + "slaves": [ + 51, + 137 + ], + "item_summonable_slaves": [ + 51 + ], + "required": [ + 9 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": 0.80468994, + "Y": -2.04911017, + "Z": 2.16120005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "node": "cannon0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_yaw", + "pocenter", + "bone_rail" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 475, + "slave": 51, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 671, + "slave": 137, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/siege_weapon.xml/siegetank_c.siegetank_c", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/04_siegeweapon/siegetank_a.chr", + "sha256": "47cb57abd0304f91f6b0ebae25f59258547f8eb1f18e44c23bb7883b7e1b4bd7" + }, + { + "path": "game/prefabs/siege_weapon.xml", + "sha256": "64f698ff21163b79ef8842abc5553fbb5d97db3e3da0bc45f8f2c375b2552ae6" + } + ] + }, + { + "model": 1024, + "slaves": [ + 61 + ], + "item_summonable_slaves": [ + 61 + ], + "required": [ + 9, + 10, + 11, + 12, + 13, + 14, + 15, + 16, + 17, + 19, + 20, + 21, + 22, + 23, + 24, + 25, + 26, + 27, + 28, + 29, + 35, + 36, + 37, + 38, + 39, + 46, + 58, + 59 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": -4.29276672, + "Y": 2.23506424, + "Z": 4.4205661, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 83.00000122 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon0", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 77, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "10": { + "location": { + "X": -4.4767865, + "Y": 0.2020467, + "Z": 4.48708954, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 83.99995896 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon1", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 78, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "11": { + "location": { + "X": -4.57174072, + "Y": -3.67801453, + "Z": 4.64193115, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 92.00001601 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon2", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 79, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "12": { + "location": { + "X": -4.46449463, + "Y": -5.55405579, + "Z": 4.74579041, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 93.99999888 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon3", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 72, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "13": { + "location": { + "X": 4.30832184, + "Y": 2.23506409, + "Z": 4.4205661, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -82.00000269 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon4", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 73, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "14": { + "location": { + "X": 4.49234192, + "Y": 0.20204668, + "Z": 4.48708954, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -86.00000112 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon5", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 74, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "15": { + "location": { + "X": 4.58729614, + "Y": -3.67801453, + "Z": 4.64193115, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -92.99999467 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon6", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 75, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "16": { + "location": { + "X": 4.48005005, + "Y": -5.5540564, + "Z": 4.74579102, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -93.99998923 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon7", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 76, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "17": { + "location": { + "X": -0.02580078, + "Y": -17.12161865, + "Z": 6.53128357, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon8", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_bindings", + "row": 80, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "19": { + "location": { + "X": -1.91e-06, + "Y": 10.39880371, + "Z": 4.53841064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$mast0", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 105, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "20": { + "location": { + "X": 6.1e-07, + "Y": -2.66621552, + "Z": 4.55662964, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$mast1", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 106, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "21": { + "location": { + "X": -1.34e-06, + "Y": 10.39880371, + "Z": 4.53841064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$sail0", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 107, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "22": { + "location": { + "X": 1.13e-06, + "Y": -2.66621552, + "Z": 4.55662811, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$sail1", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 108, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "23": { + "location": { + "X": 0.0, + "Y": 13.83623413, + "Z": 4.65069, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$anchor", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 114, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "24": { + "location": { + "X": -3.63965759, + "Y": -8.43711731, + "Z": 1.66250549, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 90.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$ladder_left", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 109, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "25": { + "location": { + "X": 3.16607452, + "Y": -8.43917725, + "Z": 1.51600861, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -90.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$ladder_right", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 110, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "26": { + "location": { + "X": -4.9426236, + "Y": 9.73896606, + "Z": 4.52553986, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$plank_left", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 112, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "27": { + "location": { + "X": 4.81819489, + "Y": 9.7243042, + "Z": 4.52553986, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -173.00000315 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$plank_right", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 113, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "28": { + "location": { + "X": -3.58012238, + "Y": -10.39539673, + "Z": 8.99327942, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 21.64487823 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$lamp_front", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 119, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "29": { + "location": { + "X": 3.62164337, + "Y": -10.28855225, + "Z": 8.99328064, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -9.99999827 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$lamp_rear", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 111, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "35": { + "location": { + "X": 0.00038204, + "Y": -13.99029541, + "Z": 6.92423584, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$helms", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 116, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 1.19121086, + "Y": 14.19112061, + "Z": 5.12247559, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$heal_point0", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 22, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "37": { + "location": { + "X": 5.11665863, + "Y": -0.7226757, + "Z": 3.33382629, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$heal_point1", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 23, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "38": { + "location": { + "X": -0.24652342, + "Y": -8.87354675, + "Z": 5.2601709, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$heal_point2", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 24, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "39": { + "location": { + "X": -0.92987915, + "Y": -10.47005615, + "Z": 1.97258972, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$heal_point3", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 25, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "46": { + "location": { + "X": -0.07826172, + "Y": -3.24843933, + "Z": 38.54605469, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$cannon9", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 115, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "58": { + "location": { + "X": -1.04451965, + "Y": -14.86150757, + "Z": -2.14507004, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 179.99998133 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$ladder_rear_left", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 117, + "slave": 61, + "owner_type": "Slave" + } + ] + }, + "59": { + "location": { + "X": 1.04451706, + "Y": -14.86150879, + "Z": -2.145065, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 179.99996403 + }, + "asset": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "node": "$ladder_rear_right", + "parents": [ + "galleon_test_body_1", + "galleon_test_body" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 118, + "slave": 61, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://Prefabs/interaction_c.xml/galleon.galleon_test_body", + "inspected_assets": [ + { + "path": "game/objects/env/01_nuia/001_ndeco/ndeco_cannonball_b.cgf", + "sha256": "474f1e411494ed33b0919064f9bf651783d6b7ea71577273ce54de56a4da1eb3" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/ndeco_cookstore_chair01.cgf", + "sha256": "f9723ac8cbf6d71271ea71e9012430f7e1d227673fde7ee32410f2f08f6a1bdd" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/ndeco_sandbag01.cgf", + "sha256": "6fa036403136b22a98d62dc04c80fda61cc6cce65591f53ca9e59b86d89f98f0" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/barrel_oak_b.cgf", + "sha256": "4b315cd65cc43caf209f73b2555853c453f6c245adcb21d8d14235af83a858c7" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/fisherbarrel.cgf", + "sha256": "7f81847b162fcfa1cf4b4f07a926c109589184c5f4bff849964b83f1f486d6a0" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/rope_a01.cgf", + "sha256": "b05ed1d164801806d23b1522719c5be8bc90dc1339351f293b9c81ec8534942a" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/rope_c01.cgf", + "sha256": "2c88c1427fefebd6613006011b3ac514ebad198c41c44057c99881869dcd6f49" + }, + { + "path": "game/objects/env/01_nuia/001_ndeco/old/rope_c02.cgf", + "sha256": "ce68eb966cbe03f1f1bb3c13421572e9102330cb6e36625c81374348c513d398" + }, + { + "path": "game/objects/env/01_nuia/06_mari/mari_oscar_chainbox.cgf", + "sha256": "bb108934b81c4bcc4c09f1d08710995dfc66426d954d48e5ab48c2662d8eef52" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_cannon.cgf", + "sha256": "561e4b7346f6236c183da8855679ff840a4b4e4d223380a20ea1c69958e11e45" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_flag0.chr", + "sha256": "6614af9b8a1690d74e496c16b4bf16c7cded4bfc1cfb18048e4fd3ca37160931" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_item01.cgf", + "sha256": "7a1c861a6546ba6e165dac47f082063d080587ddc69a18d60346b6b62e6bb516" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_rudder.cgf", + "sha256": "ef89844029a161e86d051e4bbcb4504b024b4da321e2f0ea4f765a227b207a74" + }, + { + "path": "game/objects/env/06_unit/01_ship/galleon/galleon_test_body.cgf", + "sha256": "0cea8fce6a9104c552a150d41d955bbf02b9c417cf301021a508455e44b931e9" + }, + { + "path": "game/objects/item/shield/shield_26_2/shield_26_2.cgf", + "sha256": "c918c903ff5b11af029282880b0bb0ddffa14469689c9e7f48d252f3bfbaa769" + }, + { + "path": "game/prefabs/interaction_c.xml", + "sha256": "0ec3249c055594d0b3e43cd35a19456045b9b546ca8c39bb7397b91251d17e2d" + } + ] + }, + { + "model": 1287, + "slaves": [ + 102 + ], + "item_summonable_slaves": [ + 102 + ], + "required": [ + 2, + 35, + 36 + ], + "already_present": [], + "points": { + "2": { + "location": { + "X": -0.47789001, + "Y": 0.36952, + "Z": 0.9364399, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship.cgf", + "node": "$passenger0", + "parents": [ + "body", + "coupleduckship" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 455, + "slave": 102, + "owner_type": "Slave" + } + ] + }, + "35": { + "location": { + "X": 0.39533997, + "Y": -0.12314003, + "Z": 1.41565994, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship.cgf", + "node": "$helms", + "parents": [ + "body", + "coupleduckship" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 454, + "slave": 102, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.0, + "Y": -1.81697433, + "Z": 1.82779999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship.cgf", + "node": "$heal_point0", + "parents": [ + "body", + "coupleduckship" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 61, + "slave": 102, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/coupleduckship.xml/coupleduckship.coupleduckship_body", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship.cgf", + "sha256": "831f8451ffff1e34979f2105323c4765a09f61b4609979ac49d17436828d7890" + }, + { + "path": "game/objects/env/06_unit/01_ship/coupleduckship/coupleduckship_foot.chr", + "sha256": "f1063d15a25ac0ca61166bc9a5513741de92adbf79c64f9f76c82ac2b53fb141" + }, + { + "path": "game/prefabs/coupleduckship.xml", + "sha256": "6e4407a62dae3a9a33a4bcae46b853b35db3331cbc2f3b6a1ff0c303452f4aab" + } + ] + }, + { + "model": 1323, + "slaves": [ + 106, + 117, + 122 + ], + "item_summonable_slaves": [ + 106, + 122 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 477, + "slave": 106, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 589, + "slave": 117, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 634, + "slave": 122, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 62, + "slave": 106, + "owner_type": "Slave" + }, + { + "table": "slave_healing_point_doodads", + "row": 77, + "slave": 117, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 584, + "slave": 106, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 593, + "slave": 106, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar.xml/speedcar.speedcar_body_r", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "sha256": "88269f91bebd8e72781a65045726ec22729d69ac091cd9afe600063e388d8f00" + }, + { + "path": "game/prefabs/speedcar.xml", + "sha256": "798116faf573a3c33349f1b1c22140bb1555689573dd8934ca87c24841b83a89" + } + ] + }, + { + "model": 1371, + "slaves": [ + 112, + 118 + ], + "item_summonable_slaves": [ + 112 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 587, + "slave": 112, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 590, + "slave": 118, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 76, + "slave": 112, + "owner_type": "Slave" + }, + { + "table": "slave_healing_point_doodads", + "row": 79, + "slave": 118, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 588, + "slave": 112, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 599, + "slave": 112, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar.xml/speedcar.speedcar_body_b", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body.chr", + "sha256": "88269f91bebd8e72781a65045726ec22729d69ac091cd9afe600063e388d8f00" + }, + { + "path": "game/prefabs/speedcar.xml", + "sha256": "798116faf573a3c33349f1b1c22140bb1555689573dd8934ca87c24841b83a89" + } + ] + }, + { + "model": 1385, + "slaves": [ + 101, + 120 + ], + "item_summonable_slaves": [], + "required": [ + 21, + 22, + 24, + 25, + 36, + 37, + 38, + 39, + 58, + 59, + 60, + 61, + 62, + 63, + 64, + 65, + 66, + 67, + 68, + 69, + 70, + 71, + 76 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 15.15861938, + "Z": 1.93809326, + "Roll": -1.6090013, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$sail0", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 517, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 551, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 620, + "slave": 120, + "owner_type": "Slave" + }, + { + "table": "slave_bindings", + "row": 149, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "22": { + "location": { + "X": 0.0, + "Y": 1.55865067, + "Z": 1.32873474, + "Roll": -1.6090013, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$sail1", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 518, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 604, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "24": { + "location": { + "X": -2.40109009, + "Y": 12.69552368, + "Z": -1.10956696, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 71.01340743 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$ladder_left", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 537, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 615, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "25": { + "location": { + "X": 2.44303604, + "Y": 12.69552246, + "Z": -1.10635902, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -63.9865921 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$ladder_right", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 538, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 616, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": -1.60562973, + "Y": -2.22354645, + "Z": 1.34844727, + "Roll": -31.84449881, + "Pitch": 3.04776432, + "Yaw": -147.0619414 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$heal_point0", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 572, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 623, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "37": { + "location": { + "X": 2.99039398, + "Y": -0.53385757, + "Z": 1.22506035, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$heal_point1", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 570, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 621, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "38": { + "location": { + "X": 0.76255249, + "Y": -10.80150879, + "Z": 1.83097321, + "Roll": -17.3346917, + "Pitch": -3.82501679, + "Yaw": -150.04003415 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$heal_point2", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 571, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 622, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "39": { + "location": { + "X": -1.69008774, + "Y": 13.50393433, + "Z": 1.87254852, + "Roll": -66.7200763, + "Pitch": -66.38009821, + "Yaw": 66.34809364 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$heal_point3", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 550, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 619, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "58": { + "location": { + "X": -1.91337097, + "Y": -12.50181641, + "Z": -1.46283188, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -179.99999135 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$ladder_rear_left", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 539, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 617, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "59": { + "location": { + "X": 1.91337036, + "Y": -12.50181641, + "Z": -1.46283188, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": -179.99999135 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$ladder_rear_right", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 540, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 618, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -2.38570313, + "Y": 12.47859131, + "Z": 4.42517761, + "Roll": -5.84543976, + "Pitch": 0.01637078, + "Yaw": 86.80389012 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box0", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 519, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 605, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 3.77372406, + "Y": 11.7718396, + "Z": 5.30033264, + "Roll": 14.61988617, + "Pitch": -3.46511977, + "Yaw": 108.08774205 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box1", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 525, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 607, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "62": { + "location": { + "X": -4.77853394, + "Y": 2.81668457, + "Z": 3.8049884, + "Roll": -17.63500494, + "Pitch": 5.84323429, + "Yaw": 77.92499954 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box2", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 526, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 608, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "63": { + "location": { + "X": 3.68675873, + "Y": 3.93022034, + "Z": 3.87374054, + "Roll": 13.35100355, + "Pitch": -3.18382401, + "Yaw": 86.95435664 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box3", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 527, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 609, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "64": { + "location": { + "X": -3.90936157, + "Y": -4.94448669, + "Z": 5.00377747, + "Roll": -2.59864108, + "Pitch": -1.49955419, + "Yaw": 69.03402673 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box4", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 528, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 610, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "65": { + "location": { + "X": 1.47495453, + "Y": -10.06739441, + "Z": 4.89309875, + "Roll": 10.83311746, + "Pitch": -1.54938953, + "Yaw": 123.05834985 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box5", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 520, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 606, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "66": { + "location": { + "X": -2.29154297, + "Y": 6.43949036, + "Z": -0.64560669, + "Roll": -131.47489857, + "Pitch": 12.30072769, + "Yaw": 70.05732348 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box6", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 529, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 611, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "67": { + "location": { + "X": 2.25987289, + "Y": 8.95768433, + "Z": -0.4294125, + "Roll": 130.59802495, + "Pitch": -14.98278824, + "Yaw": 79.18461482 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box7", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 530, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 612, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "68": { + "location": { + "X": -2.20217819, + "Y": -8.47400269, + "Z": -0.35781158, + "Roll": -131.09412862, + "Pitch": 10.24646171, + "Yaw": 77.10754877 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box8", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 531, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 575, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 613, + "slave": 120, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 624, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "69": { + "location": { + "X": 1.90979797, + "Y": -8.05894348, + "Z": -1.06294098, + "Roll": 133.31709473, + "Pitch": -12.74193914, + "Yaw": 70.72046603 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box9", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 532, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 614, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "70": { + "location": { + "X": -0.58215088, + "Y": 5.17909302, + "Z": 1.28867584, + "Roll": 1.18520879, + "Pitch": -0.6037615, + "Yaw": -0.27913618 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box10", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 583, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 626, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "71": { + "location": { + "X": 0.6358844, + "Y": 5.21191528, + "Z": 1.29706161, + "Roll": 1.15850286, + "Pitch": -0.99305488, + "Yaw": 0.09124448 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box11", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 596, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 635, + "slave": 120, + "owner_type": "Slave" + } + ] + }, + "76": { + "location": { + "X": -0.58215027, + "Y": -2.47363617, + "Z": 1.28406952, + "Roll": -2.97758005, + "Pitch": -0.60376143, + "Yaw": -0.27913616 + }, + "asset": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "node": "$box16", + "parents": [ + "boxship_old_2", + "boxship_old" + ], + "kind": "cgf-local-node", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 576, + "slave": 101, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 625, + "slave": 120, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/boxship_old.xml/boxship_old.boxship_old_normal", + "inspected_assets": [ + { + "path": "game/objects/box.cgf", + "sha256": "921141b30889f84f0d8f1867da15aecdc15bd26672e12e666ebe7185406f8858" + }, + { + "path": "game/objects/env/06_unit/01_ship/boxship/boxship_old.cgf", + "sha256": "837d9a5a00bc63ebc751b432f27cb4239f072a2550f1f802b38017c6574d0bb5" + }, + { + "path": "game/prefabs/boxship_old.xml", + "sha256": "d61a1baa5724f20925d47f7f05373c0f57fc02975f9804ccd81cd4c5ec94a119" + } + ] + }, + { + "model": 1402, + "slaves": [ + 109 + ], + "item_summonable_slaves": [], + "required": [ + 21 + ], + "already_present": [], + "points": {}, + "unresolved": { + "21": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$sail0", + "$sail0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 541, + "slave": 109, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "prefab missing/ambiguous: prefab://prefabs/boxship_old.xml/boxship_old.boxship_old_normal_2f" + ], + "normal": "prefab://prefabs/boxship_old.xml/boxship_old.boxship_old_normal_2f", + "inspected_assets": [ + { + "path": "game/prefabs/boxship_old.xml", + "sha256": "d61a1baa5724f20925d47f7f05373c0f57fc02975f9804ccd81cd4c5ec94a119" + } + ] + }, + { + "model": 1427, + "slaves": [ + 121 + ], + "item_summonable_slaves": [ + 121 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": {}, + "unresolved": { + "21": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$sail0", + "$sail0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 627, + "slave": 121, + "owner_type": "Slave" + } + ] + }, + "36": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$heal_point0", + "$heal_point0" + ], + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 80, + "slave": 121, + "owner_type": "Slave" + } + ] + }, + "60": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$box0", + "$box0" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 628, + "slave": 121, + "owner_type": "Slave" + } + ] + }, + "61": { + "reason": "native asset/helper absent; see issues and inspected sources", + "aliases": [ + "$box1", + "$box1" + ], + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 629, + "slave": 121, + "owner_type": "Slave" + } + ] + } + }, + "issues": [ + "prefab missing/ambiguous: prefab://prefabs/speedcar.xml/speedcar.speedcar_body_redbull" + ], + "normal": "prefab://prefabs/speedcar.xml/speedcar.speedcar_body_redbull", + "inspected_assets": [ + { + "path": "game/prefabs/speedcar.xml", + "sha256": "798116faf573a3c33349f1b1c22140bb1555689573dd8934ca87c24841b83a89" + } + ] + }, + { + "model": 1442, + "slaves": [ + 108, + 123 + ], + "item_summonable_slaves": [], + "required": [ + 9, + 10 + ], + "already_present": [], + "points": { + "9": { + "location": { + "X": 1.31732416, + "Y": -2.06066918, + "Z": 2.79388428, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/transfers_battle_foodtraffic.chr", + "node": "cannon0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "Bone_back00", + "Bone_back01" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 633, + "slave": 108, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 680, + "slave": 123, + "owner_type": "Slave" + } + ] + }, + "10": { + "location": { + "X": -0.12301, + "Y": -3.09071016, + "Z": 3.20470023, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/transfers_battle_foodtraffic.chr", + "node": "cannon1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "Bone_back00", + "Bone_back01" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 601, + "slave": 108, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/vehicle_tractor.xml/transfers_battle_foodtraffic.transfers_battle_foodtraffic_body", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/transfers_battle_foodtraffic.chr", + "sha256": "c8824fa506e450954719d4850d1debbe9a5e2c63e46c7c415f85ae618744ddb1" + }, + { + "path": "game/prefabs/vehicle_tractor.xml", + "sha256": "c5c510acded32ecfae40e797b9c749f91ef77eff39ec41ffe4076593be3e3a17" + } + ] + }, + { + "model": 1444, + "slaves": [ + 124 + ], + "item_summonable_slaves": [ + 124 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 630, + "slave": 124, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 81, + "slave": 124, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 631, + "slave": 124, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 632, + "slave": 124, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar.xml/speedcar.speedcar_body_decal", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "sha256": "f0aa00a7c0f288fc5c2a169a49979091a2bd0acdc8387979f2e82a1d63f5f3ec" + }, + { + "path": "game/prefabs/speedcar.xml", + "sha256": "798116faf573a3c33349f1b1c22140bb1555689573dd8934ca87c24841b83a89" + } + ] + }, + { + "model": 1460, + "slaves": [ + 126, + 135 + ], + "item_summonable_slaves": [ + 126 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 636, + "slave": 126, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 667, + "slave": 135, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 82, + "slave": 126, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 637, + "slave": 126, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 668, + "slave": 135, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 638, + "slave": 126, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 669, + "slave": 135, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar_ucc.xml/speedcar_ucc.speedcar_body_r_ucc", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "sha256": "f0aa00a7c0f288fc5c2a169a49979091a2bd0acdc8387979f2e82a1d63f5f3ec" + }, + { + "path": "game/prefabs/speedcar_ucc.xml", + "sha256": "ee89b93694dd7b0d78a2884d7d0bd40b3ab16a9e5c03390da90511d952abecdb" + } + ] + }, + { + "model": 1461, + "slaves": [ + 127, + 134 + ], + "item_summonable_slaves": [ + 127 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 639, + "slave": 127, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 664, + "slave": 134, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 83, + "slave": 127, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 640, + "slave": 127, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 665, + "slave": 134, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 641, + "slave": 127, + "owner_type": "Slave" + }, + { + "table": "slave_doodad_bindings", + "row": 666, + "slave": 134, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar_ucc.xml/speedcar_ucc.speedcar_body_b_ucc", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "sha256": "f0aa00a7c0f288fc5c2a169a49979091a2bd0acdc8387979f2e82a1d63f5f3ec" + }, + { + "path": "game/prefabs/speedcar_ucc.xml", + "sha256": "ee89b93694dd7b0d78a2884d7d0bd40b3ab16a9e5c03390da90511d952abecdb" + } + ] + }, + { + "model": 1462, + "slaves": [ + 128 + ], + "item_summonable_slaves": [ + 128 + ], + "required": [ + 21, + 36, + 60, + 61 + ], + "already_present": [], + "points": { + "21": { + "location": { + "X": 0.0, + "Y": 0.87057996, + "Z": 1.18104005, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "sail0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 642, + "slave": 128, + "owner_type": "Slave" + } + ] + }, + "36": { + "location": { + "X": 0.69189, + "Y": -0.13275997, + "Z": 1.07907999, + "Roll": 0.0, + "Pitch": 0.0, + "Yaw": 0.0 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "heal_point0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_healing_point_doodads", + "row": 84, + "slave": 128, + "owner_type": "Slave" + } + ] + }, + "60": { + "location": { + "X": -0.52005464, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": -90.00001284, + "Pitch": -54.99995696, + "Yaw": -90.00000934 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box0", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 643, + "slave": 128, + "owner_type": "Slave" + } + ] + }, + "61": { + "location": { + "X": 0.52022153, + "Y": -2.1677649, + "Z": 0.68300521, + "Roll": 89.99998732, + "Pitch": -54.99998354, + "Yaw": -90.00000433 + }, + "asset": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "node": "box1", + "parents": [ + "body", + "Bip01", + "Bip01 Pelvis", + "bone_trick", + "bone_body_base" + ], + "kind": "chr-absolute-bind", + "consumers": [ + { + "table": "slave_doodad_bindings", + "row": 644, + "slave": 128, + "owner_type": "Slave" + } + ] + } + }, + "unresolved": {}, + "issues": [], + "normal": "prefab://prefabs/speedcar_ucc.xml/speedcar_ucc.speedcar_body_y_ucc", + "inspected_assets": [ + { + "path": "game/objects/env/06_unit/05_carriage/speedcar_body_decal.chr", + "sha256": "f0aa00a7c0f288fc5c2a169a49979091a2bd0acdc8387979f2e82a1d63f5f3ec" + }, + { + "path": "game/prefabs/speedcar_ucc.xml", + "sha256": "ee89b93694dd7b0d78a2884d7d0bd40b3ab16a9e5c03390da90511d952abecdb" + } + ] + } + ] +} diff --git a/rust/tools/slave_attach_points.py b/rust/tools/slave_attach_points.py new file mode 100644 index 0000000000..918468306c --- /dev/null +++ b/rust/tools/slave_attach_points.py @@ -0,0 +1,414 @@ +#!/usr/bin/env python3 +"""Audit/generate vehicle attach transforms from the original 1.2 game_pak only. + +Run from any directory (Python 3 + the existing gamepak.py's pycryptodome): + python -I rust/tools/slave_attach_points.py --compact \ + --pak D:/AA1.2/game_pak --report [--write] +Without --write this is a read-only audit. --write adds missing points in the +checked-in JSON, preserving every existing point and all hand-written comments. +It never extracts assets to disk or writes the client/compact. Reports contain +asset SHA-256s, node names, parent chains, exact unresolved indexes and consumers. + +Provenance / conventions (no published CryEngine source was used): +* 2026-10-25 audit F2; baseline 37e6f1aec; earlier 1406 fix a9dc41b8. +* Native 1.2 model_attach_point_strings maps IDs to actor/prefab names; loader + sub_39678930, D:/aa-re/client12/decomp/x2game12.c:1416646. Prefab bindings + use '$name'; CHR compiled joints also use 'name'. Only that explicit alias is + accepted, never a different numbered helper or another model's geometry. +* CGF 0x744/745, Node 0x823: local position +148, XYZW quaternion +160, + scale +176 after the copied 16-byte header. Conjugate authored quaternion, + divide positions by 100, compose parents then prefab object transforms. + Matches the native 1.2-verified collision/cga.rs::nodes/RootAnimation reader. +* CHR CompiledBones 0xACDC0000 v0x801: 48-byte header, 324-byte records, + name +216 (48 bytes), relative parent index +264, absolute bind Matrix34 + +276. These matrices ALREADY contain parents and use metres. Do not compose + the parent a second time. Layout checked in the actual 1.2 CHRs against + sibling CGFs and CDF wheel positions; no 10.x geometry is consulted. +* Prefab XML Pos is metres, Rotate is WXYZ, Scale is XYZ. Direct named prefab + helpers take precedence over embedded geometry helpers. JSON rotations are + degrees, Z-yaw/Y-pitch/X-roll, as vehicles/data.rs::parse_attach_points reads. +* Literal native Clipper/Dinghy/1406 regression samples live in the accompanying + tests. Some old hand-authored JSON rotations are inconsistent (e.g. Clipper + cannon12); they are preserved, not used to invent a rotation convention. +* Point 0 is None, not a helper. Missing assets/helpers remain explicit gaps; + no zero placeholders, neighbouring-model substitutions or compact edits. +""" + +from __future__ import annotations + +import argparse +import hashlib +import importlib.util +import json +import math +import re +import sqlite3 +import struct +from pathlib import Path +import xml.etree.ElementTree as ET + +ROOT = Path(__file__).resolve().parents[2] +DATA = ROOT / "rust/crates/aaemu-game/app/Data/slave_attach_points.json" +AUDIT_MODELS = (2, 4, 5, 6, 115, 127, 129, 130, 392, 512, 857, 866, 867, + 892, 898, 899, 1024, 1287, 1323, 1371, 1385, 1402, 1427, + 1442, 1444, 1460, 1461, 1462) +MAX_ASSET = 32 * 1024 * 1024 +MAX_CHUNKS = 8192 +MAX_NODES = 4096 +IDENTITY = (1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0.) + + +def load_json(path): + # Preserve quoted paths/URIs while stripping the data's // comments. + text = Path(path).read_text(encoding="utf-8") + return json.loads(re.sub(r'"(?:\\.|[^"\\])*"|//[^\n]*', + lambda m: "" if m[0].startswith("//") else m[0], text)) + + +def read_compact(path): + conn = sqlite3.connect(Path(path).resolve().as_uri() + "?mode=ro", uri=True) + conn.row_factory = sqlite3.Row + return conn + + +def compose(a, b): + """Column-vector affine Matrix34: parent * local (including parent scale).""" + return tuple(sum(a[r*4+k] * b[k*4+c] for k in range(3)) + + (a[r*4+3] if c == 3 else 0.) + for r in range(3) for c in range(4)) + + +def prs(position, xyzw, scale=(1., 1., 1.)): + if len(position) != 3 or len(xyzw) != 4 or len(scale) != 3 or not all( + math.isfinite(v) for v in (*position, *xyzw, *scale)): + raise ValueError("invalid/nonfinite PRS") + x, y, z, w = xyzw + norm = math.sqrt(sum(v*v for v in xyzw)) + if not 0.99 <= norm <= 1.01: + raise ValueError("invalid quaternion") + x, y, z, w = (v / norm for v in (x, y, z, w)) + r = (1-2*(y*y+z*z), 2*(x*y-z*w), 2*(x*z+y*w), + 2*(x*y+z*w), 1-2*(x*x+z*z), 2*(y*z-x*w), + 2*(x*z-y*w), 2*(y*z+x*w), 1-2*(x*x+y*y)) + return tuple(position[row] if col == 3 else r[row*3+col] * scale[col] + for row in range(3) for col in range(4)) + + +def location(matrix): + if not all(math.isfinite(v) for v in matrix): + raise ValueError("nonfinite transform") + lengths = [math.sqrt(sum(matrix[r*4+c]**2 for r in range(3))) for c in range(3)] + if min(lengths) < 1e-8: + raise ValueError("singular transform") + r = [matrix[row*4+c] / lengths[c] for row in range(3) for c in range(3)] + if any(abs(sum(r[k*3+a]*r[k*3+b] for k in range(3))) > 1e-4 + for a, b in ((0, 1), (0, 2), (1, 2))): + raise ValueError("sheared transform") + determinant = (r[0]*(r[4]*r[8]-r[5]*r[7]) - r[1]*(r[3]*r[8]-r[5]*r[6]) + + r[2]*(r[3]*r[7]-r[4]*r[6])) + if abs(determinant-1) > 1e-4: + raise ValueError("reflected transform") + pitch = math.asin(max(-1., min(1., -r[6]))) + if abs(math.cos(pitch)) > 1e-6: + roll, yaw = math.atan2(r[7], r[8]), math.atan2(r[3], r[0]) + else: + roll, yaw = 0., math.atan2(-r[1], r[4]) + values = [matrix[3], matrix[7], matrix[11], *map(math.degrees, (roll, pitch, yaw))] + return {k: (0. if abs(v) < (1e-7 if i < 3 else 1e-4) else round(v, 8)) + for i, (k, v) in enumerate(zip(("X", "Y", "Z", "Roll", "Pitch", "Yaw"), values))} + + +def chunks(data): + if len(data) < 24 or len(data) > MAX_ASSET or data[:6] != b"CryTek": + raise ValueError("invalid/bounded CryTek file") + version, table = struct.unpack_from(" len(data)-4: + raise ValueError("unsupported/truncated chunk table") + count = struct.unpack_from(" MAX_CHUNKS or table+4+count*stride > len(data): + raise ValueError("bounded/truncated chunk table") + entries = [struct.unpack_from("<4I" if stride == 16 else "<5I", data, table+4+i*stride) + for i in range(count)] + boundaries = sorted({e[2] for e in entries} | {table, len(data)}) + seen = set() + for e in entries: + kind, ver, offset, cid = e[:4] + size = e[4] if stride == 20 else next((x-offset for x in boundaries if x > offset), 0) + if cid in seen or size < 16 or offset+size > len(data): + raise ValueError("duplicate/truncated chunk") + seen.add(cid) + if kind in (0xCCCC000B, 0xACDC0000): + if struct.unpack_from("<4I", data, offset) != (kind, ver, offset, cid): + raise ValueError("chunk header mismatch") + yield kind, ver, cid, data[offset:offset+size] + + +def hierarchy(nodes, key, trail=()): + if key in trail or len(trail) >= 128 or key not in nodes: + raise ValueError("cyclic/deep/orphan hierarchy") + name, parent, local = nodes[key] + if parent is None: + return local, [name] + matrix, chain = hierarchy(nodes, parent, trail+(key,)) + return compose(matrix, local), chain+[name] + + +def geometry(data): + """Yield (name, native bind matrix, parent chain, record kind).""" + nodes, bones = {}, [] + for kind, version, cid, raw in chunks(data): + if kind == 0xCCCC000B: + if version != 0x823 or len(raw) < 220: + raise ValueError("unsupported/truncated node") + body = raw[16:] + name = body[:64].split(b"\0")[0].decode("ascii") + parent = struct.unpack_from(" MAX_NODES: + raise ValueError("too many bones") + for i in range(count): + b = 48+i*324 + name = raw[b+216:b+264].split(b"\0")[0].decode("ascii") + relative = struct.unpack_from(" MAX_NODES: + raise ValueError("too many nodes") + for cid, (name, _, _) in nodes.items(): + matrix, chain = hierarchy(nodes, cid) + yield name, matrix, chain, "cgf-local-node" + for i, (name, parent, matrix) in enumerate(bones): + # Stored absolute bind matrix, NOT parent-relative. Traverse only for + # provenance/validation; multiplying these matrices doubles the parents. + chain, visited, j = [], set(), i + while j is not None: + if j in visited or not 0 <= j < len(bones) or len(visited) >= 128: + raise ValueError("cyclic/deep/orphan bone hierarchy") + visited.add(j) + chain.insert(0, bones[j][0]) + j = bones[j][1] + yield name, matrix, chain, "chr-absolute-bind" + + +def asset_path(name): + name = name.replace("\\", "/").lower() + return name if name.startswith("game/") else "game/"+name + + +class Extractor: + def __init__(self, pak, strings): + self.pak = pak + self.names = {n.lower(): (n, offset, size) for n, offset, size in pak.entries} + self.strings = strings + self.sources, self.issues = {}, [] + + def read(self, name): + key = asset_path(name) + if key not in self.names: + raise KeyError(key) + actual, offset, size = self.names[key] + if not 0 <= size <= MAX_ASSET or offset < 0 or offset+size > self.pak.length: + raise ValueError("asset exceeds bounds: "+key) + self.pak.f.seek(offset) + data = self.pak.f.read(size) + if len(data) != size: + raise ValueError("truncated asset: "+key) + self.sources[key] = {"path": actual, "sha256": hashlib.sha256(data).hexdigest()} + return data + + def match(self, name, bone=False): + n = name.strip().casefold() + return [point for point, aliases in self.strings.items() + if n in {a.casefold() for a in aliases} + or (bone and n in {a.lstrip("$").casefold() for a in aliases})] + + def mesh(self, path, outer=IDENTITY, chain=()): + key = asset_path(path) + for name, matrix, parents, kind in geometry(self.read(key)): + for point in self.match(name, bone=kind == "chr-absolute-bind"): + yield point, {"location": location(compose(outer, matrix)), "asset": key, + "node": name, "parents": list(chain)+parents[:-1], "kind": kind} + + def model(self, uri): + if not uri.startswith("prefab://"): + result = {} + for point, evidence in self.mesh(uri.split("://", 1)[1]): + if point in result: + raise ValueError(f"ambiguous geometry helper {point} in {uri}") + result[point] = evidence + return result + file, prefab = uri[len("prefab://"):].split(".xml/", 1) + path = asset_path(file+".xml") + root = ET.fromstring(self.read(path)) + choices = [p for p in root.findall("Prefab") if p.get("Name", "").casefold() == prefab.casefold()] + if len(choices) != 1: + raise ValueError("prefab missing/ambiguous: "+uri) + objects = choices[0].findall("Objects/Object") + if len(objects) > 512: + raise ValueError("too many prefab objects") + nodes, direct, result = {}, {}, {} + for i, obj in enumerate(objects): + vec = lambda field, default: tuple(map(float, obj.get(field, default).split(","))) + w, x, y, z = vec("Rotate", "1,0,0,0") + key = obj.get("Id", str(i)) + if key in nodes: + raise ValueError("duplicate prefab object") + nodes[key] = (obj.get("Name", ""), obj.get("Parent"), + prs(vec("Pos", "0,0,0"), (x, y, z, w), vec("Scale", "1,1,1"))) + for i, obj in enumerate(objects): + outer, parents = hierarchy(nodes, obj.get("Id", str(i))) + for point in self.match(obj.get("Name", "")): + if point in direct: + raise ValueError("duplicate direct prefab helper") + direct[point] = {"location": location(outer), "asset": path, + "node": obj.get("Name"), "parents": parents[:-1], "kind": "prefab-helper"} + model = obj.get("Prefab") if obj.get("Type") == "Brush" else None + props = obj.find("Properties") + if props is not None: + model = props.get("object_Model", model) + if not model or not model.lower().endswith((".cgf", ".chr", ".cga")): + continue + try: + for point, evidence in self.mesh(model, outer, parents): + if point in result: + raise ValueError(f"ambiguous geometry helper {point} in {uri}") + result[point] = evidence + except KeyError as e: + self.issues.append("asset absent: "+str(e.args[0])) + result.update(direct) + return result + + +def requirements(conn): + """Actual child/healing/equipment consumers (same owner rules as runtime). + + Doodads/healing are loaded by owner_id. Child slaves additionally filter + owner_type == Slave in finish_create; Housing rows aliasing a slave ID must + not create spurious requirements (e.g. Housing 119 != Timber Coupe 119). + """ + result = {} + for table in ("slave_doodad_bindings", "slave_bindings", "slave_healing_point_doodads", "slave_equip_slots"): + owner = "slave_id" if table == "slave_equip_slots" else "owner_id" + for row in conn.execute(f"SELECT s.model_id, s.id slave_id, b.* FROM {table} b JOIN slaves s ON s.id=b.{owner}"): + if table == "slave_bindings" and row["owner_type"] != "Slave": + continue + point = row["attach_point_id"] + consumer = {"table": table, "row": row["id"], "slave": row["slave_id"]} + if "owner_type" in row.keys(): + consumer["owner_type"] = row["owner_type"] + result.setdefault(row["model_id"], {}).setdefault(point, []).append(consumer) + return result + + +def normal_uri(conn, mid): + row = conn.execute("SELECT sub_type, sub_id FROM models WHERE id=?", (mid,)).fetchone() + if row is None: + raise ValueError(f"model descriptor {mid} absent from compact") + table = {"VehicleModel": "vehicle_models", "ShipModel": "ship_models"}.get(row["sub_type"]) + if table is None: + raise ValueError("unsupported model type: "+row["sub_type"]) + asset = conn.execute(f"SELECT normal FROM {table} WHERE id=?", (row["sub_id"],)).fetchone() + if asset is None: + raise ValueError(f"{table} descriptor {row['sub_id']} absent") + return asset[0] + + +def audit(conn, pak, data, models=AUDIT_MODELS): + strings = {r["id"]: (r["actor"], r["prefab"]) for r in conn.execute("SELECT * FROM model_attach_point_strings")} + required = requirements(conn) + existing = {r["ModelId"]: {int(k) for k in r["AttachPoints"]} for r in data} + summonable = {r[0] for r in conn.execute("SELECT DISTINCT slave_id FROM item_summon_slaves")} + ex, report, additions = Extractor(pak, strings), [], [] + for mid in models: + slaves = [r[0] for r in conn.execute("SELECT id FROM slaves WHERE model_id=? ORDER BY id", (mid,))] + req = required.get(mid, {}) + record = {"model": mid, "slaves": slaves, "item_summonable_slaves": sorted(summonable.intersection(slaves)), + "required": sorted(req), "already_present": sorted(existing.get(mid, set())), + "points": {}, "unresolved": {}, "issues": []} + ex.issues = [] + try: + record["normal"] = normal_uri(conn, mid) + found = ex.model(record["normal"]) + except (KeyError, ValueError) as e: + found = {} + ex.issues.append(str(e)) + record["issues"] = list(ex.issues) + points = {} + for point in sorted(req): + if point in existing.get(mid, set()): + continue + if point == 0: + record["unresolved"][str(point)] = {"reason": "None (0): no named attach transform", "consumers": req[point]} + elif point in found: + evidence = found[point] + points[str(point)] = evidence["location"] + record["points"][str(point)] = {**evidence, "consumers": req[point]} + else: + record["unresolved"][str(point)] = {"reason": "native asset/helper absent; see issues and inspected sources", + "aliases": strings.get(point), "consumers": req[point]} + if points: + additions.append({"Name": "Native 1.2 model "+str(mid), "ModelId": mid, "AttachPoints": points}) + # Includes assets that contain no helpers, making negative findings auditable. + record["inspected_assets"] = [ex.sources[key] for key in sorted(ex.sources)] + report.append(record) + ex.sources = {} + return additions, {"baseline": "37e6f1aec", "format": "native 1.2 r208022; see slave_attach_points.py docstring", "models": report} + + +def write_additions(path, additions): + text = path.read_text(encoding="utf-8") + if not text.rstrip().endswith("]"): + raise ValueError("expected JSON array") + # Audit rejects existing-point replacement. Most additions are entirely new + # models; partial existing models are deliberately left for explicit review. + old = {r["ModelId"] for r in load_json(path)} + if any(r["ModelId"] in old for r in additions): + raise ValueError("partial existing model needs explicit review") + if additions: + encoded = json.dumps(additions, indent=4)[1:-1].strip("\n") + path.write_text(text.rstrip()[:-1].rstrip()+",\n"+encoded+"\n]\n", encoding="utf-8") + + +def open_pak(path): + spec = importlib.util.spec_from_file_location("gamepak", ROOT / "rust/tools/opcode_coverage/gamepak.py") + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + pak = module.Pak(path) + if pak.kind != "A": + pak.f.close() + raise ValueError("requires original 1.2 TypeA pak, not 10.x") + return pak + + +def main(): + ap = argparse.ArgumentParser(description=__doc__) + ap.add_argument("--compact", type=Path, required=True) + ap.add_argument("--pak", type=Path, required=True) + ap.add_argument("--report", type=Path, required=True) + ap.add_argument("--data", type=Path, default=DATA) + ap.add_argument("--write", action="store_true") + args = ap.parse_args() + pak = open_pak(args.pak) + try: + with read_compact(args.compact) as conn: + additions, report = audit(conn, pak, load_json(args.data)) + args.report.write_text(json.dumps(report, indent=2)+"\n", encoding="utf-8") + if args.write: + write_additions(args.data, additions) + print(f"{len(additions)} models, {sum(len(r['AttachPoints']) for r in additions)} missing transforms recovered") + for r in report["models"]: + print(f"model {r['model']}: recovered {','.join(r['points']) or '-'}; unresolved {','.join(r['unresolved']) or '-'}; {'; '.join(r['issues'])}") + finally: + pak.f.close() + + +if __name__ == "__main__": + main() diff --git a/rust/tools/test_slave_attach_points.py b/rust/tools/test_slave_attach_points.py new file mode 100644 index 0000000000..050f562829 --- /dev/null +++ b/rust/tools/test_slave_attach_points.py @@ -0,0 +1,191 @@ +"""Lightweight regressions; native tests use AAEMU_CLIENT_PAK + AAEMU_COMPACT_DB. + + python -I rust/tools/test_slave_attach_points.py + # Set both environment variables to additionally audit the actual 1.2 data. +""" + +import importlib.util +import math +import os +from pathlib import Path +import struct +import unittest + +SPEC = importlib.util.spec_from_file_location("attach", Path(__file__).with_name("slave_attach_points.py")) +attach = importlib.util.module_from_spec(SPEC) +SPEC.loader.exec_module(attach) + +# Exact content gaps, deliberately literal rather than generated by the parser. +# Details / source hashes are in slave_attach_points.provenance.json. +CONTENT_GAPS = { + 115: [9, 10, 11, 12, 18], + 129: [9, 10], + 130: [9], + 512: [2, 3, 9, 10, 11, 12, 13, 14, 15, 16, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 35, 36, 37, 38, 39], + 857: [2], + 866: [35], + 1402: [21], + 1427: [21, 36, 60, 61], +} + + +def file_with_chunks(parts, version=0x745): + stride = 20 if version == 0x745 else 16 + data = bytearray(b"CryTek\0\0"+struct.pack("