mirror of
https://github.com/Corfirean/coa-server-manager.git
synced 2026-11-20 03:25:56 +00:00
feat(manager): configure per-race character creation
This commit is contained in:
1 parent
925a81f4f2
commit
8ad06fd78a
24 files changed
+2058
-4
No files matched your search
@@ -0,0 +1,184 @@
|
||||
"""Offline experiment only; does not install patches or infer client load order."""
|
||||
|
||||
import argparse
|
||||
import ctypes
|
||||
import hashlib
|
||||
import json
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import tempfile
|
||||
|
||||
|
||||
MEMBER = r"DBFilesClient\ChrRaces.dbc"
|
||||
STOCK = {1, 2, 3, 4, 5, 6, 7, 8, 10, 11}
|
||||
LAYOUT = (69, 276)
|
||||
ALGORITHM_VERSION = 1
|
||||
NAME_FIELDS = (*range(14, 30), *range(31, 47), *range(48, 64))
|
||||
|
||||
|
||||
def read_dbc(data):
|
||||
if len(data) < 20:
|
||||
raise ValueError("Truncated DBC header")
|
||||
magic, count, fields, size, strings_size = struct.unpack_from("<4sIIII", data)
|
||||
if magic != b"WDBC" or (fields, size) != LAYOUT or not count:
|
||||
raise ValueError("Unsupported ChrRaces layout")
|
||||
strings_start = 20 + count * size
|
||||
if strings_start + strings_size != len(data) or not strings_size:
|
||||
raise ValueError("Invalid DBC bounds")
|
||||
strings = data[strings_start:]
|
||||
if strings[-1] != 0:
|
||||
raise ValueError("Invalid string block")
|
||||
rows = {}
|
||||
for index in range(count):
|
||||
offset = 20 + index * size
|
||||
race, flags = struct.unpack_from("<II", data, offset)
|
||||
if not 0 < race <= 255 or race in rows:
|
||||
raise ValueError("Invalid or duplicate RaceID")
|
||||
names = {}
|
||||
for field in NAME_FIELDS:
|
||||
name_offset = struct.unpack_from("<I", data, offset + field * 4)[0]
|
||||
if name_offset >= strings_size:
|
||||
raise ValueError("Invalid race name offset")
|
||||
names[field] = strings[name_offset:].split(b"\0", 1)[0].decode("utf-8", errors="strict")
|
||||
name = names[14]
|
||||
rows[race] = {"offset": offset, "flags": flags, "name": name}
|
||||
return rows
|
||||
|
||||
|
||||
def patch_dbc(original, disabled):
|
||||
rows = read_dbc(original)
|
||||
disabled = set(disabled)
|
||||
if disabled & STOCK or not disabled <= rows.keys():
|
||||
raise ValueError("Only known custom RaceIDs can be disabled")
|
||||
result = bytearray(original)
|
||||
for race in disabled:
|
||||
row = rows[race]
|
||||
struct.pack_into("<I", result, row["offset"] + 4, row["flags"] | 1)
|
||||
verified = read_dbc(result)
|
||||
restored = bytearray(result)
|
||||
for race in disabled:
|
||||
row = rows[race]
|
||||
if verified[race]["flags"] != row["flags"] | 1:
|
||||
raise ValueError("Flags verification failed")
|
||||
struct.pack_into("<I", restored, row["offset"] + 4, row["flags"])
|
||||
if restored != original:
|
||||
raise ValueError("Unexpected byte changes")
|
||||
return bytes(result)
|
||||
|
||||
|
||||
def fingerprint(original, disabled, profile):
|
||||
inputs = {"sourceDbcSha256": hashlib.sha256(original).hexdigest(),
|
||||
"disabledRaceIds": sorted(set(disabled)), "algorithmVersion": ALGORITHM_VERSION,
|
||||
"profile": profile}
|
||||
return hashlib.sha256(json.dumps(inputs, sort_keys=True, separators=(",", ":")).encode()).hexdigest()
|
||||
|
||||
|
||||
class Storm:
|
||||
def __init__(self, library):
|
||||
self.api = ctypes.WinDLL(str(library), use_last_error=True)
|
||||
handle = ctypes.c_void_p
|
||||
word = ctypes.c_uint32
|
||||
signatures = {
|
||||
"SFileOpenArchive": [ctypes.c_wchar_p, word, word, ctypes.POINTER(handle)],
|
||||
"SFileCloseArchive": [handle],
|
||||
"SFileExtractFile": [handle, ctypes.c_char_p, ctypes.c_wchar_p, word],
|
||||
"SFileCreateArchive": [ctypes.c_wchar_p, word, word, ctypes.POINTER(handle)],
|
||||
"SFileAddFileEx": [handle, ctypes.c_wchar_p, ctypes.c_char_p, word, word, word],
|
||||
}
|
||||
for name, arguments in signatures.items():
|
||||
function = getattr(self.api, name)
|
||||
function.argtypes = arguments
|
||||
function.restype = ctypes.c_int
|
||||
|
||||
def check(self, name, *args):
|
||||
if not getattr(self.api, name)(*args):
|
||||
raise OSError(ctypes.get_last_error(), name)
|
||||
|
||||
def extract(self, archive, member, destination):
|
||||
handle = ctypes.c_void_p()
|
||||
self.check("SFileOpenArchive", str(archive), 0, 0x100, ctypes.byref(handle))
|
||||
try:
|
||||
self.check("SFileExtractFile", handle, member.encode("ascii"),
|
||||
str(destination), 0)
|
||||
finally:
|
||||
self.check("SFileCloseArchive", handle)
|
||||
|
||||
def create(self, archive, source):
|
||||
handle = ctypes.c_void_p()
|
||||
self.check("SFileCreateArchive", str(archive), 0, 4, ctypes.byref(handle))
|
||||
try:
|
||||
self.check("SFileAddFileEx", handle, str(source), MEMBER.encode("ascii"),
|
||||
0x01000000, 0, 0)
|
||||
finally:
|
||||
self.check("SFileCloseArchive", handle)
|
||||
|
||||
|
||||
def generate_experiment(storm, source_mpq, output, disabled, profile="unverified"):
|
||||
source_mpq = Path(source_mpq).resolve(strict=True)
|
||||
output = Path(output).absolute()
|
||||
if output.exists():
|
||||
raise FileExistsError(output)
|
||||
output.parent.mkdir(parents=True, exist_ok=True)
|
||||
with tempfile.TemporaryDirectory(prefix=".race-experiment-", dir=output.parent) as temp:
|
||||
staging = Path(temp) / "result"
|
||||
staging.mkdir()
|
||||
report = build_experiment(storm, source_mpq, staging, disabled, profile)
|
||||
staging.rename(output)
|
||||
return report
|
||||
|
||||
|
||||
def build_experiment(storm, source_mpq, output, disabled, profile):
|
||||
with source_mpq.open("rb") as source:
|
||||
source_sha = hashlib.file_digest(source, "sha256").hexdigest()
|
||||
original_path = output / "original.dbc"
|
||||
storm.extract(source_mpq, MEMBER, original_path)
|
||||
original = original_path.read_bytes()
|
||||
rows = read_dbc(original)
|
||||
generated = patch_dbc(original, disabled)
|
||||
generated_path = output / "generated.dbc"
|
||||
generated_path.write_bytes(generated)
|
||||
overlay = output / "experiment.MPQ"
|
||||
storm.create(overlay, generated_path)
|
||||
with tempfile.TemporaryDirectory() as temp:
|
||||
extracted = Path(temp) / "roundtrip.dbc"
|
||||
storm.extract(overlay, MEMBER, extracted)
|
||||
if extracted.read_bytes() != generated:
|
||||
raise ValueError("MPQ extraction does not match generated DBC")
|
||||
report = {
|
||||
"sourceMpq": str(source_mpq), "sourceMpqSha256": source_sha,
|
||||
"algorithmVersion": ALGORITHM_VERSION, "profile": profile,
|
||||
"fingerprint": fingerprint(original, disabled, profile),
|
||||
"sourceDbcSha256": hashlib.sha256(original).hexdigest(),
|
||||
"generatedDbcSha256": hashlib.sha256(generated).hexdigest(),
|
||||
"disabled": [{"id": race, "name": rows[race]["name"],
|
||||
"oldFlags": rows[race]["flags"], "newFlags": rows[race]["flags"] | 1}
|
||||
for race in sorted(set(disabled))],
|
||||
"catalog": [{"id": race, "name": row["name"], "flags": row["flags"]}
|
||||
for race, row in sorted(rows.items())],
|
||||
"dbcValidation": "PASS", "onlyRequestedBitChanged": "PASS", "mpqRoundtrip": "PASS",
|
||||
"effectiveSourceInRunningClient": "UNVERIFIED", "overlayPriority": "UNVERIFIED",
|
||||
"creationMenu": "NOT RUN", "otherRaceCreation": "NOT RUN",
|
||||
"existingCharacterLogin": "NOT RUN", "rollbackInGame": "NOT RUN",
|
||||
"verdict": "PARTIAL",
|
||||
}
|
||||
with source_mpq.open("rb") as source:
|
||||
if hashlib.file_digest(source, "sha256").hexdigest() != source_sha:
|
||||
raise ValueError("Source archive changed during the experiment")
|
||||
(output / "report.json").write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")
|
||||
return report
|
||||
|
||||
|
||||
def main():
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument("--storm", type=Path, required=True)
|
||||
parser.add_argument("--source-mpq", type=Path, required=True)
|
||||
parser.add_argument("--output", type=Path, required=True)
|
||||
parser.add_argument("--disable", type=int, nargs="*", required=True)
|
||||
parser.add_argument("--profile", default="unverified", help="Recorded input; not a support declaration")
|
||||
args = parser.parse_args()
|
||||
report = generate_experiment(Storm(args.storm), args.source_mpq, args.output, args.disable, args.profile)
|
||||
print(json.dumps({key: value for key, value in report.items() if key != "catalog"}, indent=2))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
@@ -0,0 +1,59 @@
|
||||
"""Version-pinned offline experiment; never installs files or launches the game."""
|
||||
|
||||
import hashlib
|
||||
|
||||
|
||||
SOURCE_SHA256 = "8816ef9b6839652db60da6de7d2a6d09ceed1f80323ca5c8e55271a4d5aacac3"
|
||||
PROBE_IDS = {82, 83, 97}
|
||||
|
||||
|
||||
def build_probe(source, disabled):
|
||||
if hashlib.sha256(source).hexdigest() != SOURCE_SHA256:
|
||||
raise ValueError("Unsupported CharacterCreate.lua fingerprint")
|
||||
disabled = set(disabled)
|
||||
if not disabled <= PROBE_IDS:
|
||||
raise ValueError("This experiment supports only previously verified probe RaceIDs")
|
||||
text = source.decode("utf-8").replace("\r", "")
|
||||
prefix = "local CoaManagedDisabled = {" + ",".join(f"[{race}]=true" for race in sorted(disabled)) + "}\n"
|
||||
prefix += """local function CoaManagedRaceDisabled(raceId)
|
||||
return raceId ~= nil and CoaManagedDisabled[raceId] == true
|
||||
end
|
||||
local function CoaManagedDisabledLabel()
|
||||
local labels = {
|
||||
enUS = "Disabled by server", enGB = "Disabled by server",
|
||||
ruRU = "Отключено сервером", deDE = "Vom Server deaktiviert",
|
||||
frFR = "Désactivé par le serveur", esES = "Desactivada por el servidor",
|
||||
esMX = "Desactivada por el servidor", zhCN = "服务器已禁用"
|
||||
}
|
||||
return labels[GetLocale and GetLocale() or "enUS"] or labels.enUS
|
||||
end
|
||||
"""
|
||||
replacements = [
|
||||
('local hide = hidden["#"..i] or hidden[name] or hidden[strlower(name or "")]',
|
||||
'local hide = CoaManagedRaceDisabled(button.bonusRaceID) or hidden["#"..i] or hidden[name] or hidden[strlower(name or "")]'),
|
||||
('\t\t\t\tbutton.coaUserHidden = nil\n\t\t\t\tbutton:Show()\n',
|
||||
'\t\t\t\tbutton.coaUserHidden = CoaManagedRaceDisabled(button.bonusRaceID) or nil\n'
|
||||
'\t\t\t\tif not button.coaUserHidden then button:Show() else button:Hide() end\n'),
|
||||
("tinsert(rows, { id = i, raceID = raceID, name = name, faction = (ok and faction) or 'Alliance' })",
|
||||
"tinsert(rows, { id = i, raceID = raceID, policyRaceID = button.bonusRaceID, name = name, faction = (ok and faction) or 'Alliance' })"),
|
||||
('if not f.draft or not self.raceName then',
|
||||
'if self.coaServerDisabled or not f.draft or not self.raceName then'),
|
||||
("\t\t\t\trow.label:SetText((info.faction == 'Horde' and '|cffff2020' or '|cff00a0ff')..info.name..' |cffaaa37a(ID '..info.raceID..')|r')\n"
|
||||
"\t\t\t\tlocal hidden = f.draft and (f.draft['#'..info.id] or f.draft[info.name] or f.draft[strlower(info.name)])\n"
|
||||
"\t\t\t\trow:SetChecked(not hidden)",
|
||||
""" row.coaServerDisabled = CoaManagedRaceDisabled(info.policyRaceID)
|
||||
local hidden = f.draft and (f.draft['#'..info.id] or f.draft[info.name] or f.draft[strlower(info.name)])
|
||||
if row.coaServerDisabled then
|
||||
row.label:SetText('|cff808080'..info.name..' (ID '..info.raceID..') - '..CoaManagedDisabledLabel()..'|r')
|
||||
row:Disable()
|
||||
else
|
||||
row.label:SetText((info.faction == 'Horde' and '|cffff2020' or '|cff00a0ff')..info.name..' |cffaaa37a(ID '..info.raceID..')|r')
|
||||
row:Enable()
|
||||
end
|
||||
row:SetChecked(not row.coaServerDisabled and not hidden)"""),
|
||||
]
|
||||
for old, new in replacements:
|
||||
if text.count(old) != 1:
|
||||
raise ValueError("Expected exactly one known Lua integration point")
|
||||
text = text.replace(old, new)
|
||||
return (prefix + text).encode("utf-8")
|
||||
@@ -0,0 +1,108 @@
|
||||
"""Synthetic MPQ roundtrips using an explicitly selected local Unicode StormLib DLL."""
|
||||
|
||||
import hashlib
|
||||
import os
|
||||
from pathlib import Path
|
||||
import struct
|
||||
import tempfile
|
||||
import unittest
|
||||
from unittest.mock import patch
|
||||
|
||||
from race_availability_poc import Storm, generate_experiment, patch_dbc
|
||||
from test_race_availability_poc import fixture
|
||||
|
||||
|
||||
@unittest.skipUnless(os.environ.get("COA_TEST_STORMLIB"), "Set COA_TEST_STORMLIB to a Unicode StormLib DLL")
|
||||
class MpqExperimentTests(unittest.TestCase):
|
||||
def setUp(self):
|
||||
self.temporary = tempfile.TemporaryDirectory()
|
||||
self.addCleanup(self.temporary.cleanup)
|
||||
self.root = Path(self.temporary.name)
|
||||
self.storm = Storm(Path(os.environ["COA_TEST_STORMLIB"]))
|
||||
self.original = fixture(ids=(1, *range(12, 62)))
|
||||
source_dbc = self.root / "source.dbc"
|
||||
source_dbc.write_bytes(self.original)
|
||||
self.source_mpq = self.root / "source.MPQ"
|
||||
self.storm.create(self.source_mpq, source_dbc)
|
||||
self.source_bytes = self.source_mpq.read_bytes()
|
||||
self.output = self.root / "output"
|
||||
|
||||
def test_one_and_fifty_races_still_one_archive_with_one_game_file(self):
|
||||
for count in [1, 50]:
|
||||
with self.subTest(count=count):
|
||||
output = self.root / f"output-{count}"
|
||||
disabled = list(range(12, 12 + count))
|
||||
report = generate_experiment(self.storm, self.source_mpq, output, disabled)
|
||||
archives = list(output.glob("*.MPQ"))
|
||||
self.assertEqual(len(archives), 1)
|
||||
header = struct.unpack_from("<4sIIHHIIII", archives[0].read_bytes())
|
||||
self.assertEqual(header[0], b"MPQ\x1a")
|
||||
self.assertEqual(header[-1], 2)
|
||||
listfile = self.root / f"listfile-{count}.txt"
|
||||
self.storm.extract(archives[0], "(listfile)", listfile)
|
||||
self.assertEqual(listfile.read_text().splitlines(), [r"DBFilesClient\ChrRaces.dbc"])
|
||||
self.assertEqual((output / "generated.dbc").read_bytes(), patch_dbc(self.original, disabled))
|
||||
self.assertEqual(report["mpqRoundtrip"], "PASS")
|
||||
self.assertEqual(report["creationMenu"], "NOT RUN")
|
||||
self.assertEqual(self.source_mpq.read_bytes(), self.source_bytes)
|
||||
|
||||
def test_regeneration_has_identical_dbc_and_fingerprint(self):
|
||||
first = generate_experiment(self.storm, self.source_mpq, self.output, [12, 15])
|
||||
other = self.root / "other"
|
||||
second = generate_experiment(self.storm, self.source_mpq, other, [15, 12, 12])
|
||||
self.assertEqual(first["fingerprint"], second["fingerprint"])
|
||||
self.assertEqual((self.output / "generated.dbc").read_bytes(), (other / "generated.dbc").read_bytes())
|
||||
|
||||
def test_existing_output_and_user_files_not_overwritten(self):
|
||||
self.output.mkdir()
|
||||
user_file = self.output / "experiment.MPQ"
|
||||
user_file.write_bytes(b"user archive")
|
||||
with self.assertRaises(FileExistsError):
|
||||
generate_experiment(self.storm, self.source_mpq, self.output, [12])
|
||||
self.assertEqual(user_file.read_bytes(), b"user archive")
|
||||
self.assertEqual(self.source_mpq.read_bytes(), self.source_bytes)
|
||||
|
||||
def test_failed_packaging_does_not_publish_output(self):
|
||||
with patch.object(self.storm, "create", side_effect=OSError("synthetic packaging failure")):
|
||||
with self.assertRaises(OSError):
|
||||
generate_experiment(self.storm, self.source_mpq, self.output, [12])
|
||||
self.assertFalse(self.output.exists())
|
||||
self.assertEqual(self.source_mpq.read_bytes(), self.source_bytes)
|
||||
self.assertEqual(list(self.root.glob(".race-experiment-*")), [])
|
||||
|
||||
def test_unreadable_archive_does_not_publish_output(self):
|
||||
broken = self.root / "broken.MPQ"
|
||||
broken.write_bytes(b"not an archive")
|
||||
with self.assertRaises(OSError):
|
||||
generate_experiment(self.storm, broken, self.output, [12])
|
||||
self.assertFalse(self.output.exists())
|
||||
self.assertEqual(broken.read_bytes(), b"not an archive")
|
||||
|
||||
def test_invalid_race_does_not_publish_output(self):
|
||||
with self.assertRaises(ValueError):
|
||||
generate_experiment(self.storm, self.source_mpq, self.output, [255])
|
||||
self.assertFalse(self.output.exists())
|
||||
|
||||
def test_empty_selection_preserves_original_bytes(self):
|
||||
report = generate_experiment(self.storm, self.source_mpq, self.output, [])
|
||||
self.assertEqual((self.output / "generated.dbc").read_bytes(), self.original)
|
||||
self.assertEqual(report["sourceMpqSha256"], hashlib.sha256(self.source_bytes).hexdigest())
|
||||
self.assertEqual(report["disabled"], [])
|
||||
|
||||
def test_failed_roundtrip_does_not_publish_output(self):
|
||||
extract = self.storm.extract
|
||||
|
||||
def corrupt_roundtrip(archive, member, destination):
|
||||
extract(archive, member, destination)
|
||||
if archive.name == "experiment.MPQ":
|
||||
destination.write_bytes(b"incorrect extracted bytes")
|
||||
|
||||
with patch.object(self.storm, "extract", side_effect=corrupt_roundtrip):
|
||||
with self.assertRaisesRegex(ValueError, "MPQ extraction"):
|
||||
generate_experiment(self.storm, self.source_mpq, self.output, [12])
|
||||
self.assertFalse(self.output.exists())
|
||||
self.assertEqual(self.source_mpq.read_bytes(), self.source_bytes)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,113 @@
|
||||
import struct
|
||||
import unittest
|
||||
|
||||
from race_availability_poc import NAME_FIELDS, STOCK, fingerprint, patch_dbc, read_dbc
|
||||
|
||||
|
||||
def fixture(ids=(1, 82, 83, 97), flags=0x8C):
|
||||
rows = bytearray()
|
||||
for race in ids:
|
||||
row = bytearray(276)
|
||||
struct.pack_into("<II", row, 0, race, flags)
|
||||
struct.pack_into("<I", row, 14 * 4, 1)
|
||||
rows.extend(row)
|
||||
strings = b"\0Synthetic race\0"
|
||||
return struct.pack("<4sIIII", b"WDBC", len(ids), 69, 276, len(strings)) + rows + strings
|
||||
|
||||
|
||||
class DbcExperimentTests(unittest.TestCase):
|
||||
def test_only_requested_bit_changes(self):
|
||||
original = fixture()
|
||||
generated = patch_dbc(original, [82, 97])
|
||||
self.assertEqual([i for i, pair in enumerate(zip(original, generated)) if pair[0] != pair[1]],
|
||||
[20 + 276 + 4, 20 + 3 * 276 + 4])
|
||||
self.assertEqual(read_dbc(generated)[82]["flags"], 0x8D)
|
||||
|
||||
def test_empty_set_preserves_original(self):
|
||||
self.assertEqual(patch_dbc(fixture(), []), fixture())
|
||||
|
||||
def test_duplicates_and_order_normalized(self):
|
||||
self.assertEqual(patch_dbc(fixture(), [97, 82, 82]), patch_dbc(fixture(), [82, 97]))
|
||||
|
||||
def test_already_disabled_idempotent(self):
|
||||
original = fixture(flags=0x8D)
|
||||
self.assertEqual(patch_dbc(original, [82]), original)
|
||||
|
||||
def test_each_generation_uses_original(self):
|
||||
original = fixture()
|
||||
patch_dbc(original, [82])
|
||||
self.assertEqual(read_dbc(patch_dbc(original, [97]))[82]["flags"], 0x8C)
|
||||
|
||||
def test_unknown_or_stock_rejected(self):
|
||||
for race in [0, 42, 256, -1, *sorted(STOCK)]:
|
||||
with self.subTest(race=race), self.assertRaises(ValueError):
|
||||
patch_dbc(fixture(), [race])
|
||||
|
||||
def test_bad_headers_rejected(self):
|
||||
for data in [b"", fixture()[:19], b"WDB2" + fixture()[4:], fixture(ids=()),
|
||||
fixture()[:-1], fixture() + b"x", fixture(ids=(82, 82))]:
|
||||
with self.subTest(data=data[:20]), self.assertRaises(ValueError):
|
||||
read_dbc(data)
|
||||
|
||||
def test_unrecognized_layout_rejected(self):
|
||||
for offset, value in [(8, 68), (12, 272), (16, 0), (4, 0xFFFFFFFF)]:
|
||||
data = bytearray(fixture())
|
||||
struct.pack_into("<I", data, offset, value)
|
||||
with self.subTest(offset=offset), self.assertRaises(ValueError):
|
||||
read_dbc(data)
|
||||
|
||||
def test_bad_string_offset_rejected(self):
|
||||
for field in NAME_FIELDS:
|
||||
data = bytearray(fixture())
|
||||
struct.pack_into("<I", data, 20 + field * 4, 99999)
|
||||
with self.subTest(field=field), self.assertRaises(ValueError):
|
||||
read_dbc(data)
|
||||
|
||||
def test_nonempty_first_string_supported(self):
|
||||
data = bytearray(fixture())
|
||||
data[20 + 4 * 276] = ord("x")
|
||||
self.assertEqual(len(read_dbc(data)), 4)
|
||||
|
||||
def test_reenable_restores_original_flags_including_original_bit(self):
|
||||
for flags in [0, 1, 12, 13, 0xFFFFFFFF]:
|
||||
original = fixture(flags=flags)
|
||||
patch_dbc(original, [82])
|
||||
self.assertEqual(patch_dbc(original, []), original)
|
||||
|
||||
def test_one_five_and_fifty_races(self):
|
||||
original = fixture(ids=(1, *range(12, 62)))
|
||||
for count in [1, 5, 50]:
|
||||
disabled = set(range(12, 12 + count))
|
||||
generated = patch_dbc(original, disabled)
|
||||
original_rows, generated_rows = read_dbc(original), read_dbc(generated)
|
||||
self.assertEqual({race for race in original_rows
|
||||
if original_rows[race]["flags"] != generated_rows[race]["flags"]}, disabled)
|
||||
|
||||
def test_invalid_id_in_table(self):
|
||||
for race in [0, 256, 0xFFFFFFFF]:
|
||||
with self.subTest(race=race), self.assertRaises(ValueError):
|
||||
read_dbc(fixture(ids=(race,)))
|
||||
|
||||
def test_string_block_must_terminate(self):
|
||||
with self.assertRaises(ValueError):
|
||||
read_dbc(fixture()[:-1] + b"x")
|
||||
|
||||
def test_invalid_utf8_in_localized_name(self):
|
||||
data = bytearray(fixture())
|
||||
data[20 + 4 * 276 + 1] = 0xFF
|
||||
with self.assertRaises(ValueError):
|
||||
read_dbc(data)
|
||||
|
||||
def test_fingerprint_normalizes_order_and_duplicates(self):
|
||||
self.assertEqual(fingerprint(fixture(), [97, 82, 82], "test"),
|
||||
fingerprint(fixture(), [82, 97], "test"))
|
||||
|
||||
def test_fingerprint_changes_with_every_input(self):
|
||||
baseline = fingerprint(fixture(), [82], "test")
|
||||
self.assertNotEqual(baseline, fingerprint(fixture(flags=0), [82], "test"))
|
||||
self.assertNotEqual(baseline, fingerprint(fixture(), [97], "test"))
|
||||
self.assertNotEqual(baseline, fingerprint(fixture(), [82], "other-profile"))
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
@@ -0,0 +1,157 @@
|
||||
import importlib.util
|
||||
import os
|
||||
from pathlib import Path
|
||||
import unittest
|
||||
|
||||
from race_visibility_lua_poc import build_probe
|
||||
|
||||
|
||||
@unittest.skipUnless(os.environ.get("COA_TEST_CHARACTER_CREATE_LUA") and importlib.util.find_spec("lupa"),
|
||||
"Requires an explicitly selected extracted Lua and installed Lua 5.1 runtime")
|
||||
class ManagedFilterProbeTests(unittest.TestCase):
|
||||
@classmethod
|
||||
def setUpClass(cls):
|
||||
from lupa.lua51 import LuaRuntime
|
||||
cls.runtime_type = LuaRuntime
|
||||
cls.source = Path(os.environ["COA_TEST_CHARACTER_CREATE_LUA"]).read_bytes()
|
||||
cls.generated = build_probe(cls.source, [82, 83, 97]).decode()
|
||||
cls.prefix = cls.generated[:cls.generated.index("CHAR_CREATE_HELP_NEXT_BUTTON")]
|
||||
|
||||
def rows(self, race=82, personal=False, locale="enUS"):
|
||||
lua = self.runtime_type(unpack_returned_tuples=True)
|
||||
lua.execute("""
|
||||
F = {offset=0, entries={}, draft={}, rows={}}
|
||||
strlower = string.lower
|
||||
function makeRow()
|
||||
local row={label={}}
|
||||
row.label.SetText=function(self,value) self.text=value end
|
||||
row.SetChecked=function(self,value) self.checked=value end
|
||||
row.Disable=function(self) self.enabled=false end
|
||||
row.Enable=function(self) self.enabled=true end
|
||||
row.Show=function(self) self.visible=true end
|
||||
row.Hide=function(self) self.visible=false end
|
||||
return row
|
||||
end
|
||||
F.rows[1]=makeRow()
|
||||
""")
|
||||
lua.globals().GetLocale = lambda: locale
|
||||
entry = lua.table_from({"id": 2, "raceID": race, "policyRaceID": race, "name": "Synthetic", "faction": "Alliance"})
|
||||
lua.globals().F.entries[1] = entry
|
||||
if personal:
|
||||
lua.globals().F.draft.Synthetic = True
|
||||
start = self.generated.index("function CharacterCreate_RefreshRaceFilterRows()")
|
||||
end = self.generated.index("function CharacterCreate_ToggleRaceFilter()", start)
|
||||
lua.execute(self.prefix + "\nlocal filter=F; local VISIBLE=1; local UpdateScrollBar=function() end\n"
|
||||
+ self.generated[start:end])
|
||||
lua.globals().CharacterCreate_RefreshRaceFilterRows()
|
||||
return lua
|
||||
|
||||
def test_entire_generated_source_compiles_in_lua51(self):
|
||||
self.runtime_type().execute("assert(loadstring(...))", self.generated)
|
||||
|
||||
def test_disabled_row_unchecked_disabled_and_labelled(self):
|
||||
for race in [82, 83, 97]:
|
||||
with self.subTest(race=race):
|
||||
lua = self.rows(race)
|
||||
row = lua.globals().F.rows[1]
|
||||
self.assertFalse(row.checked)
|
||||
self.assertFalse(row.enabled)
|
||||
self.assertIn("Disabled by server", row.label.text)
|
||||
self.assertTrue(row.label.text.startswith("|cff808080"))
|
||||
|
||||
def test_allowed_row_retains_personal_preference(self):
|
||||
for personal in [False, True]:
|
||||
with self.subTest(personal=personal):
|
||||
row = self.rows(13, personal).globals().F.rows[1]
|
||||
self.assertTrue(row.enabled)
|
||||
self.assertEqual(bool(row.checked), not personal)
|
||||
|
||||
def test_recycled_scroll_row_is_reenabled(self):
|
||||
lua = self.rows()
|
||||
lua.globals().F.entries[1].policyRaceID = 13
|
||||
lua.globals().F.entries[1].raceID = 13
|
||||
lua.globals().CharacterCreate_RefreshRaceFilterRows()
|
||||
self.assertTrue(lua.globals().F.rows[1].enabled)
|
||||
self.assertTrue(lua.globals().F.rows[1].checked)
|
||||
|
||||
def test_unknown_identity_never_treated_as_button_index(self):
|
||||
lua = self.rows()
|
||||
lua.globals().F.entries[1].policyRaceID = None
|
||||
lua.globals().F.entries[1].id = 82
|
||||
lua.globals().CharacterCreate_RefreshRaceFilterRows()
|
||||
self.assertTrue(lua.globals().F.rows[1].enabled)
|
||||
|
||||
def test_check_all_cannot_remove_managed_restriction(self):
|
||||
lua = self.rows(82, True)
|
||||
start = self.generated.index("local function SetAllChecked(checked)")
|
||||
end = self.generated.index("local save = MakeGlueButton", start)
|
||||
check_all = lua.execute(self.prefix + "\nlocal f=F;\n" + self.generated[start:end] + "\nreturn SetAllChecked")
|
||||
check_all(True)
|
||||
self.assertFalse(lua.globals().F.rows[1].checked)
|
||||
self.assertFalse(lua.globals().F.rows[1].enabled)
|
||||
self.assertIsNone(lua.globals().F.draft.Synthetic)
|
||||
|
||||
def test_disabled_click_callback_does_not_mutate_draft(self):
|
||||
lua = self.rows(82, True)
|
||||
start = self.generated.index("row:SetScript('OnClick', function(self)") + len("row:SetScript('OnClick', function(self)")
|
||||
end = self.generated.index("\n\t\t\tend)", start)
|
||||
callback = lua.execute("local f=F; return function(self)" + self.generated[start:end] + "\nend")
|
||||
row = lua.globals().F.rows[1]
|
||||
row.raceName = "Synthetic"
|
||||
callback(row)
|
||||
self.assertTrue(lua.globals().F.draft.Synthetic)
|
||||
|
||||
def test_six_languages(self):
|
||||
for locale, label in [("enUS", "Disabled by server"), ("ruRU", "Отключено сервером"),
|
||||
("deDE", "Vom Server deaktiviert"), ("frFR", "Désactivé par le serveur"),
|
||||
("esES", "Desactivada por el servidor"), ("zhCN", "服务器已禁用")]:
|
||||
with self.subTest(locale=locale):
|
||||
self.assertIn(label, self.rows(locale=locale).globals().F.rows[1].label.text)
|
||||
|
||||
def test_layout_fallback_never_reveals_managed_race(self):
|
||||
lua = self.runtime_type()
|
||||
lua.execute("""
|
||||
strlower=string.lower
|
||||
CharacterCreate_GetHiddenRaceSet=function() return {['#1']=true,['#2']=true} end
|
||||
GetFactionForRace=function() return '', 'Alliance' end
|
||||
function makeButton(i,race)
|
||||
local b={bonusRaceID=race,Text={GetText=function() return 'Synthetic' end}}
|
||||
b.Hide=function(self) self.visible=false end
|
||||
b.Show=function(self) self.visible=true end
|
||||
b.SetScale=function() end; b.ClearAllPoints=function() end
|
||||
b.SetPoint=function() end; b.SetFaction=function() end
|
||||
_G['CharCreateRaceButton'..i]=b
|
||||
end
|
||||
makeButton(1,1); makeButton(2,82)
|
||||
""")
|
||||
start = self.generated.index("function CharacterCreate_LayoutRaceButtons(")
|
||||
end = self.generated.index("MAX_CLASSES_PER_RACE =", start)
|
||||
lua.execute(self.prefix + self.generated[start:end])
|
||||
lua.globals().CharacterCreate_LayoutRaceButtons(2)
|
||||
self.assertTrue(lua.globals().CharCreateRaceButton1.visible)
|
||||
self.assertFalse(lua.globals().CharCreateRaceButton2.visible)
|
||||
|
||||
def test_lifting_restriction_keeps_previous_personal_choice(self):
|
||||
for personal in [False, True]:
|
||||
with self.subTest(personal=personal):
|
||||
lua = self.rows(82, personal)
|
||||
generated = build_probe(self.source, []).decode()
|
||||
prefix = generated[:generated.index("CHAR_CREATE_HELP_NEXT_BUTTON")]
|
||||
start = generated.index("function CharacterCreate_RefreshRaceFilterRows()")
|
||||
end = generated.index("function CharacterCreate_ToggleRaceFilter()", start)
|
||||
lua.execute(prefix + "\nlocal filter=F; local VISIBLE=1; local UpdateScrollBar=function() end\n"
|
||||
+ generated[start:end])
|
||||
lua.globals().CharacterCreate_RefreshRaceFilterRows()
|
||||
row = lua.globals().F.rows[1]
|
||||
self.assertTrue(row.enabled)
|
||||
self.assertEqual(bool(row.checked), not personal)
|
||||
|
||||
def test_unsupported_source_and_ids_fail(self):
|
||||
with self.assertRaises(ValueError):
|
||||
build_probe(b"unknown client source", [82])
|
||||
with self.assertRaises(ValueError):
|
||||
build_probe(self.source, [1])
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
Reference in new issue
Block a user