feat(manager): configure per-race character creation

This commit is contained in:
Дмитрий committed 2026-10-27 17:24:50 +05:00
1 parent 925a81f4f2
commit 8ad06fd78a
24 files changed
+2058 -4

No files matched your search

+184
View File
@@ -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()
+59
View File
@@ -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")
+108
View File
@@ -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()
+113
View File
@@ -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()
+157
View File
@@ -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()