Working advanced tracking code
Build / Build source distribution (push) Failing after 13s
Build / Execute unit tests (push) Failing after 8s
Build / Verify generated game data is current (push) Failing after 7s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
Build / Build source distribution (push) Failing after 13s
Build / Execute unit tests (push) Failing after 8s
Build / Verify generated game data is current (push) Failing after 7s
Build / Upload Release Asset (push) Has been skipped
Build / upload_pypi (push) Has been skipped
This commit is contained in:
@@ -0,0 +1,141 @@
|
||||
"""Fetch the large game data dumps that generated tables are built from.
|
||||
|
||||
The app ships small, generated lookup tables (see ``src/static/vendor``). The
|
||||
dumps they are derived from are far too large to version, so they are fetched
|
||||
on demand into a gitignored cache.
|
||||
|
||||
This is a shallow, blobless, sparse clone, so it transfers only the handful of
|
||||
files listed below rather than the repository's full history.
|
||||
|
||||
Usage:
|
||||
python scripts/fetch_gamedata.py [--cache DIR] [--force] [--check]
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import hashlib
|
||||
import json
|
||||
import os
|
||||
import shutil
|
||||
import subprocess
|
||||
import sys
|
||||
|
||||
UPSTREAM_URL = 'https://github.com/ao-data/ao-bin-dumps.git'
|
||||
PINNED_COMMIT = '47e4f5aca4d30b7495afa5a625ce0d5795e32050'
|
||||
|
||||
# Only what the generators actually read. `localization.json` is deliberately
|
||||
# absent: it is 90 MB, and it cannot supply a display name for every mob
|
||||
# anyway (883 of 5479 mob definitions have no namelocatag). Nothing in
|
||||
# attribution depends on it. See src/static/vendor/PROVENANCE.md.
|
||||
REQUIRED_FILES = (
|
||||
'items.json',
|
||||
'spells.json',
|
||||
'mobs.json',
|
||||
'gamedata.json',
|
||||
# Source for the vendored src/static/vendor/item_ids.txt.
|
||||
'formatted/items.txt',
|
||||
)
|
||||
|
||||
# Anchored to the repo root. Without the leading slash gitcone matches the
|
||||
# basename anywhere in the tree, which drags in the redundant 24 MB
|
||||
# formatted/items.json alongside the root one.
|
||||
SPARSE_PATTERNS = tuple('/' + name for name in REQUIRED_FILES)
|
||||
|
||||
DEFAULT_CACHE = os.path.join('.cache', 'gamedata')
|
||||
|
||||
|
||||
def _run(args, cwd=None):
|
||||
result = subprocess.run(
|
||||
args,
|
||||
cwd=cwd,
|
||||
stdout=subprocess.PIPE,
|
||||
stderr=subprocess.STDOUT,
|
||||
)
|
||||
if result.returncode != 0:
|
||||
sys.stderr.write(result.stdout.decode('utf-8', 'replace'))
|
||||
raise SystemExit('command failed: {}'.format(' '.join(args)))
|
||||
return result.stdout.decode('utf-8', 'replace')
|
||||
|
||||
|
||||
def _checksums(directory):
|
||||
"""Map of filename -> sha256 for the required files."""
|
||||
digests = {}
|
||||
for name in REQUIRED_FILES:
|
||||
path = os.path.join(directory, name)
|
||||
digest = hashlib.sha256()
|
||||
with open(path, 'rb') as handle:
|
||||
for chunk in iter(lambda: handle.read(1 << 20), b''):
|
||||
digest.update(chunk)
|
||||
digests[name] = digest.hexdigest()
|
||||
return digests
|
||||
|
||||
|
||||
def is_populated(directory):
|
||||
return all(os.path.exists(os.path.join(directory, name))
|
||||
for name in REQUIRED_FILES)
|
||||
|
||||
|
||||
def fetch(cache_dir, force=False):
|
||||
"""Ensure the dumps are present in ``cache_dir`` and return that path."""
|
||||
if force and os.path.isdir(cache_dir):
|
||||
shutil.rmtree(cache_dir)
|
||||
elif is_populated(cache_dir):
|
||||
return cache_dir
|
||||
|
||||
parent = os.path.dirname(os.path.abspath(cache_dir)) or '.'
|
||||
os.makedirs(parent, exist_ok=True)
|
||||
|
||||
if os.path.isdir(cache_dir):
|
||||
shutil.rmtree(cache_dir)
|
||||
|
||||
# --filter=blob:none avoids the full history; --sparse plus the final
|
||||
# checkout limits us to the files we name.
|
||||
_run([
|
||||
'git', 'clone',
|
||||
'--filter=blob:none',
|
||||
'--no-checkout',
|
||||
'--depth', '1',
|
||||
UPSTREAM_URL,
|
||||
cache_dir,
|
||||
])
|
||||
_run(['git', 'sparse-checkout', 'set', '--no-cone', *SPARSE_PATTERNS],
|
||||
cwd=cache_dir)
|
||||
_run(['git', 'checkout', PINNED_COMMIT], cwd=cache_dir)
|
||||
|
||||
missing = [name for name in REQUIRED_FILES
|
||||
if not os.path.exists(os.path.join(cache_dir, name))]
|
||||
if missing:
|
||||
raise SystemExit('fetch incomplete, missing: {}'.format(missing))
|
||||
|
||||
return cache_dir
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--cache', default=DEFAULT_CACHE,
|
||||
help='cache directory (default: %(default)s)')
|
||||
parser.add_argument('--force', action='store_true',
|
||||
help='re-fetch even if the cache is already populated')
|
||||
parser.add_argument('--check', action='store_true',
|
||||
help='verify the cache matches the pinned commit, '
|
||||
'without fetching')
|
||||
args = parser.parse_args(argv)
|
||||
|
||||
if args.check:
|
||||
if not is_populated(args.cache):
|
||||
print('cache is not populated: {}'.format(args.cache))
|
||||
return 1
|
||||
head = _run(['git', 'rev-parse', 'HEAD'], cwd=args.cache).strip()
|
||||
if head != PINNED_COMMIT:
|
||||
print('cache at {}, expected {}'.format(head, PINNED_COMMIT))
|
||||
return 1
|
||||
print('cache OK at {}'.format(PINNED_COMMIT))
|
||||
print(json.dumps(_checksums(args.cache), indent=2, sort_keys=True))
|
||||
return 0
|
||||
|
||||
fetch(args.cache, force=args.force)
|
||||
print('game data ready in {}'.format(args.cache))
|
||||
return 0
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
raise SystemExit(main())
|
||||
@@ -0,0 +1,466 @@
|
||||
"""Generate the small game-data lookup tables the app actually ships.
|
||||
|
||||
The raw dumps are ~50 MB and are fetched on demand (see fetch_gamedata.py).
|
||||
This reduces them to a handful of compact tables under ``src/static``.
|
||||
|
||||
Everything here is derived mechanically from the dumps. There are no
|
||||
hand-written mappings, and no observed damage is ever used to infer a value --
|
||||
strength comes from item power, which is a property of the item definition.
|
||||
|
||||
Usage:
|
||||
python scripts/gen_gamedata.py [--cache DIR] [--check]
|
||||
"""
|
||||
|
||||
import argparse
|
||||
import json
|
||||
import os
|
||||
import re
|
||||
import sys
|
||||
|
||||
STATIC_DIR = os.path.join('src', 'static')
|
||||
DEFAULT_CACHE = os.path.join('.cache', 'gamedata')
|
||||
|
||||
# Mob template IDs are the enumeration index of the mobs.bin XML, which differs
|
||||
# from the order of mobs.json by a constant. Six independent template IDs seen
|
||||
# in real captures resolve to the correct mob on both name and max HP with this
|
||||
# offset, across ~2300 entries of the file. The rule producing it is not
|
||||
# understood -- the 16 skipped entries are all category=roaming, which is the
|
||||
# signature of a filtered enumeration rather than a statement of the filter.
|
||||
# Accepted as a constant by decision; see .opencode/plans/effective-damage.md.
|
||||
MOB_TEMPLATE_OFFSET = 16
|
||||
|
||||
ARMOR_TYPES = ('physicalarmor', 'magicresistance')
|
||||
|
||||
_ITEM_LINE = re.compile(r'\s*(\d+):\s*(\S+?)\s*(?::|$)')
|
||||
|
||||
|
||||
def _load(cache_dir, name):
|
||||
with open(os.path.join(cache_dir, name), encoding='utf-8') as handle:
|
||||
return json.load(handle)
|
||||
|
||||
|
||||
def _as_list(value):
|
||||
if value is None:
|
||||
return []
|
||||
if isinstance(value, list):
|
||||
return value
|
||||
return [value]
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# item_ids.txt
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def gen_item_ids(cache_dir):
|
||||
"""Rewrite src/static/item_ids.txt in the format the app reads.
|
||||
|
||||
The app's loader expects ``<id>,<uniquename>``. Upstream ships
|
||||
`` <id>: <uniquename> : <display name>``; 846 entries have no display
|
||||
name and end after the unique name.
|
||||
"""
|
||||
out_path = os.path.join(STATIC_DIR, 'item_ids.txt')
|
||||
lines = []
|
||||
src = os.path.join(cache_dir, 'formatted', 'items.txt')
|
||||
with open(src, encoding='utf-8', errors='replace') as handle:
|
||||
for line in handle:
|
||||
match = _ITEM_LINE.match(line)
|
||||
if match:
|
||||
lines.append('{},{}'.format(match.group(1), match.group(2)))
|
||||
lines.sort(key=lambda entry: int(entry.split(',', 1)[0]))
|
||||
_write_text(out_path, '\n'.join(lines) + '\n')
|
||||
return out_path, len(lines)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# item_spells.json
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def _index_items(items_root):
|
||||
"""Unique name -> definition, in document order across all groups."""
|
||||
index = {}
|
||||
for group, value in items_root.items():
|
||||
if group.startswith('@') or group == 'shopcategories':
|
||||
continue
|
||||
for entry in _as_list(value):
|
||||
if isinstance(entry, dict) and entry.get('@uniquename'):
|
||||
index[entry['@uniquename']] = entry
|
||||
return index
|
||||
|
||||
|
||||
def _resolve_spells(item_index, name, depth=0, seen=None):
|
||||
"""Flatten craftingspelllist, following @reference and removespell.
|
||||
|
||||
Most weapons carry no spells of their own -- they inherit a whole ability
|
||||
set from a base item. Resolving that inheritance is what turns 471 weapons
|
||||
with an apparently empty spell list into full coverage.
|
||||
"""
|
||||
seen = seen if seen is not None else set()
|
||||
if name in seen or depth > 12:
|
||||
return []
|
||||
seen.add(name)
|
||||
|
||||
entry = item_index.get(name)
|
||||
if not entry:
|
||||
return []
|
||||
spell_list = entry.get('craftingspelllist')
|
||||
if not spell_list:
|
||||
return []
|
||||
if not isinstance(spell_list, dict):
|
||||
return []
|
||||
|
||||
spells = []
|
||||
reference = spell_list.get('@reference')
|
||||
if reference:
|
||||
spells += _resolve_spells(item_index, reference, depth + 1, seen)
|
||||
|
||||
removed = set()
|
||||
for rem in _as_list(spell_list.get('removespell')):
|
||||
if isinstance(rem, dict) and rem.get('@uniquename'):
|
||||
removed.add(rem['@uniquename'])
|
||||
|
||||
for craft in _as_list(spell_list.get('craftspell')):
|
||||
if isinstance(craft, dict) and craft.get('@uniquename'):
|
||||
spells.append(craft)
|
||||
|
||||
return [s for s in spells if s['@uniquename'] not in removed]
|
||||
|
||||
|
||||
def gen_item_spells(cache_dir):
|
||||
item_index = _index_items(_load(cache_dir, 'items.json')['items'])
|
||||
result = {}
|
||||
for name in item_index:
|
||||
spells = _resolve_spells(item_index, name)
|
||||
if not spells:
|
||||
continue
|
||||
entries = [{'slot': s.get('@slots'), 'spell': s['@uniquename']}
|
||||
for s in spells]
|
||||
result[name] = entries
|
||||
|
||||
# A packet identifies an enchanted item as BASE@LEVEL, but only the
|
||||
# base item exists in the dump. Emit the variants as aliases so a
|
||||
# lookup straight from a packet id finds the abilities, rather than
|
||||
# silently getting nothing.
|
||||
enchantments = item_index[name].get('enchantments')
|
||||
if not enchantments:
|
||||
continue
|
||||
variants = _as_list(
|
||||
enchantments.get('enchantment') if isinstance(enchantments, dict)
|
||||
else enchantments)
|
||||
for variant in variants:
|
||||
if isinstance(variant, dict) and variant.get('@enchantmentlevel'):
|
||||
result['{}@{}'.format(name, variant['@enchantmentlevel'])] = \
|
||||
entries
|
||||
|
||||
out_path = os.path.join(STATIC_DIR, 'item_spells.json')
|
||||
_write_json(out_path, result, sort_keys=True)
|
||||
return out_path, len(result)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# debuff_spells.json
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def _index_spells(spells_root):
|
||||
index = {}
|
||||
for group in ('activespell', 'passivespell', 'togglespell'):
|
||||
for spell in spells_root.get(group) or []:
|
||||
if spell.get('@uniquename'):
|
||||
index[spell['@uniquename']] = spell
|
||||
return index
|
||||
|
||||
|
||||
def _spell_links(spell_index, name):
|
||||
"""Spells one hop downstream of ``name``.
|
||||
|
||||
An ability rarely carries its debuff directly. ARMORPIERCER declares no
|
||||
buffovertime at all: it points at ARMORPIERCER_EFFECT via spelleffectarea,
|
||||
which in turn applies ARMORPIERCER_DEBUFF_EFFECT via applyspell. Only the
|
||||
last link actually holds the armour numbers, so every hop has to be walked.
|
||||
"""
|
||||
spell = spell_index.get(name)
|
||||
if not spell:
|
||||
return []
|
||||
out = []
|
||||
for applied in _as_list(spell.get('applyspell')):
|
||||
if isinstance(applied, dict) and applied.get('@spell'):
|
||||
out.append(applied['@spell'])
|
||||
for area in _as_list(spell.get('spelleffectarea')):
|
||||
if isinstance(area, dict) and area.get('@effect'):
|
||||
out.append(area['@effect'])
|
||||
return out
|
||||
|
||||
|
||||
def _collect_debuffs(spell_index, name, depth=0, seen=None):
|
||||
"""Negative armour/resistance effects reachable from ``name``."""
|
||||
seen = seen if seen is not None else set()
|
||||
if name in seen or depth > 3:
|
||||
return []
|
||||
seen.add(name)
|
||||
|
||||
found = []
|
||||
spell = spell_index.get(name)
|
||||
if spell:
|
||||
for effect in _as_list(spell.get('buffovertime')):
|
||||
if not isinstance(effect, dict):
|
||||
continue
|
||||
if effect.get('@type') not in ARMOR_TYPES:
|
||||
continue
|
||||
try:
|
||||
value = float(effect.get('@value') or 0)
|
||||
except ValueError:
|
||||
continue
|
||||
if value < 0:
|
||||
found.append((name, effect))
|
||||
|
||||
for nxt in _spell_links(spell_index, name):
|
||||
found += _collect_debuffs(spell_index, nxt, depth + 1, seen)
|
||||
return found
|
||||
|
||||
|
||||
def _flatten_effect(effect):
|
||||
flat = {
|
||||
'type': effect.get('@type'),
|
||||
'value': float(effect.get('@value') or 0),
|
||||
'time': float(effect.get('@time') or 0),
|
||||
}
|
||||
# Armour Piercer scales with how many targets the caster hit, so its
|
||||
# magnitude must be read off the observed effect, never assumed.
|
||||
bonus = effect.get('@targetcountvaluebonusfactor')
|
||||
if bonus:
|
||||
flat['targetcountvaluebonusfactor'] = float(bonus)
|
||||
# SUNDERARMOR2 is weaker against players than mobs; pick per victim type.
|
||||
target_type = effect.get('IfTargetType')
|
||||
if isinstance(target_type, dict) and target_type.get('@type'):
|
||||
flat['iftargettype'] = target_type['@type']
|
||||
target = effect.get('@target')
|
||||
if target:
|
||||
flat['target'] = target
|
||||
return flat
|
||||
|
||||
|
||||
def gen_debuff_spells(cache_dir):
|
||||
item_index = _index_items(_load(cache_dir, 'items.json')['items'])
|
||||
spell_index = _index_spells(_load(cache_dir, 'spells.json')['spells'])
|
||||
|
||||
abilities = set()
|
||||
for name in item_index:
|
||||
for spell in _resolve_spells(item_index, name):
|
||||
unique = spell.get('@uniquename')
|
||||
if unique and not unique.startswith('PASSIVE'):
|
||||
abilities.add(unique)
|
||||
|
||||
# effect spell -> abilities that produce it
|
||||
producers = {}
|
||||
for ability in abilities:
|
||||
for effect_name, effect in _collect_debuffs(spell_index, ability):
|
||||
producers.setdefault(effect_name, {}).setdefault(
|
||||
ability, []).append(_flatten_effect(effect))
|
||||
|
||||
result = {}
|
||||
for effect_name, by_ability in sorted(producers.items()):
|
||||
spell = spell_index.get(effect_name, {})
|
||||
result[effect_name] = {
|
||||
'abilities': sorted(by_ability),
|
||||
'category': spell.get('@category'),
|
||||
'uitype': spell.get('@uitype'),
|
||||
'maxstack': _maybe_int(spell.get('@maxstack')),
|
||||
'maxcharges': _maybe_int(spell.get('@maxcharges')),
|
||||
'effects': sorted(
|
||||
{json.dumps(e, sort_keys=True): e
|
||||
for group in by_ability.values() for e in group}.values(),
|
||||
key=lambda e: (e['type'], e['value']),
|
||||
),
|
||||
}
|
||||
|
||||
out_path = os.path.join(STATIC_DIR, 'debuff_spells.json')
|
||||
_write_json(out_path, result, sort_keys=True)
|
||||
return out_path, len(result)
|
||||
|
||||
|
||||
def _maybe_int(value):
|
||||
if value in (None, ''):
|
||||
return None
|
||||
try:
|
||||
return int(value)
|
||||
except (TypeError, ValueError):
|
||||
return None
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# progression.json
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def gen_progression(cache_dir):
|
||||
"""Item-power progression constants for armour and damage.
|
||||
|
||||
Albion scales a character's stats from item power, so attacker strength is
|
||||
a property of the equipped item and not of any observed hit. This keeps the
|
||||
arithmetic correct as players level their gear.
|
||||
"""
|
||||
game = _load(cache_dir, 'gamedata.json')['AO-GameData']
|
||||
source = game['Items']['ItemPowerProgression']
|
||||
|
||||
result = {'slots': {}, 'shares': {}}
|
||||
for key, value in source.items():
|
||||
if key in ('armorshare', 'ccrshare', 'hitpointsshare', 'energyshare',
|
||||
'trackingtime'):
|
||||
result['shares'][key] = value
|
||||
elif isinstance(value, dict) and '@armorbase' in value:
|
||||
result['slots'][key] = {
|
||||
'armorbase': float(value['@armorbase']),
|
||||
'armorprogression': float(value['@armorprogression']),
|
||||
'attackdamageprogression': float(
|
||||
value.get('@attackdamageprogression') or 0),
|
||||
'hitpointsprogression': float(
|
||||
value.get('@hitpointsprogression') or 0),
|
||||
}
|
||||
|
||||
out_path = os.path.join(STATIC_DIR, 'progression.json')
|
||||
_write_json(out_path, result, sort_keys=True)
|
||||
return out_path, len(result['slots'])
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# mob_armor.json
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def gen_mob_armor(cache_dir):
|
||||
mobs = _load(cache_dir, 'mobs.json')['Mobs']['Mob']
|
||||
result = {}
|
||||
for position, mob in enumerate(mobs):
|
||||
template_id = position + MOB_TEMPLATE_OFFSET
|
||||
result[str(template_id)] = {
|
||||
'name': mob.get('@uniquename'),
|
||||
'tier': _maybe_int(mob.get('@tier')),
|
||||
'armor': _maybe_int(mob.get('@physicalarmor')),
|
||||
'resistance': _maybe_int(mob.get('@magicresistance')),
|
||||
'hitpointsmax': _maybe_int(mob.get('@hitpointsmax')),
|
||||
'category': mob.get('@category'),
|
||||
}
|
||||
out_path = os.path.join(STATIC_DIR, 'mob_armor.json')
|
||||
_write_json(out_path, result, sort_keys=True)
|
||||
return out_path, len(result)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
# item_power.json
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def gen_item_power(cache_dir):
|
||||
"""Item power per unique name, including enchantment variants.
|
||||
|
||||
A packet carries the enchanted variant as part of the item id
|
||||
(``T5_MAIN_HOLYSTAFF_AVALON@1``), and item power scales with the
|
||||
enchantment level, so both are needed.
|
||||
"""
|
||||
item_index = _index_items(_load(cache_dir, 'items.json')['items'])
|
||||
result = {}
|
||||
for name, entry in item_index.items():
|
||||
base = _maybe_int(entry.get('@itempower'))
|
||||
if base is not None:
|
||||
result[name] = base
|
||||
enchantments = entry.get('enchantments')
|
||||
if not enchantments:
|
||||
continue
|
||||
for variant in _as_list(enchantments.get('enchantment')
|
||||
if isinstance(enchantments, dict)
|
||||
else enchantments):
|
||||
if not isinstance(variant, dict):
|
||||
continue
|
||||
level = variant.get('@enchantmentlevel')
|
||||
power = _maybe_int(variant.get('@itempower'))
|
||||
if level is None or power is None:
|
||||
continue
|
||||
result['{}@{}'.format(name, level)] = power
|
||||
|
||||
out_path = os.path.join(STATIC_DIR, 'item_power.json')
|
||||
_write_json(out_path, result, sort_keys=True)
|
||||
return out_path, len(result)
|
||||
|
||||
|
||||
# --------------------------------------------------------------------------
|
||||
|
||||
def _write_json(path, data, sort_keys=True):
|
||||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||||
with open(path, 'w', encoding='utf-8') as handle:
|
||||
json.dump(data, handle, indent=1, sort_keys=sort_keys)
|
||||
handle.write('\n')
|
||||
|
||||
|
||||
def _write_text(path, text):
|
||||
os.makedirs(os.path.dirname(path), exist_ok=True)
|
||||
with open(path, 'w', encoding='utf-8') as handle:
|
||||
handle.write(text)
|
||||
|
||||
|
||||
GENERATORS = (
|
||||
('item_ids.txt', gen_item_ids),
|
||||
('item_spells.json', gen_item_spells),
|
||||
('debuff_spells.json', gen_debuff_spells),
|
||||
('progression.json', gen_progression),
|
||||
('mob_armor.json', gen_mob_armor),
|
||||
('item_power.json', gen_item_power),
|
||||
)
|
||||
|
||||
|
||||
def main(argv=None):
|
||||
parser = argparse.ArgumentParser(description=__doc__)
|
||||
parser.add_argument('--cache', default=DEFAULT_CACHE)
|
||||
parser.add_argument('--check', action='store_true',
|
||||
help='regenerate into a temp dir and report drift '
|
||||
'instead of overwriting the committed tables')
|
||||
args = parser.parse_args(argv)
|
||||
|
||||
if not os.path.isdir(args.cache):
|
||||
raise SystemExit(
|
||||
'no game data at {}; run scripts/fetch_gamedata.py first'.format(
|
||||
args.cache))
|
||||
|
||||
if args.check:
|
||||
return _check(args.cache)
|
||||
|
||||
for label, generator in GENERATORS:
|
||||
path, count = generator(args.cache)
|
||||
print('{:24s} {:>7d} entries {}'.format(
|
||||
label, count, os.path.relpath(path)))
|
||||
return 0
|
||||
|
||||
|
||||
def _check(cache_dir):
|
||||
import tempfile
|
||||
import shutil
|
||||
|
||||
global STATIC_DIR
|
||||
original = STATIC_DIR
|
||||
drifted = []
|
||||
tmp = tempfile.mkdtemp(prefix='gamedata-check-')
|
||||
try:
|
||||
STATIC_DIR = tmp
|
||||
for label, generator in GENERATORS:
|
||||
generated, _ = generator(cache_dir)
|
||||
committed = os.path.join(original, label)
|
||||
if not os.path.exists(committed):
|
||||
drifted.append('{}: missing from src/static'.format(label))
|
||||
elif _read(generated) != _read(committed):
|
||||
drifted.append('{}: committed copy is stale'.format(label))
|
||||
finally:
|
||||
STATIC_DIR = original
|
||||
shutil.rmtree(tmp, ignore_errors=True)
|
||||
|
||||
if drifted:
|
||||
print('game data is out of date:')
|
||||
for line in drifted:
|
||||
print(' - {}'.format(line))
|
||||
print('\nrun: make gamedata')
|
||||
return 1
|
||||
print('game data tables are up to date')
|
||||
return 0
|
||||
|
||||
|
||||
def _read(path):
|
||||
with open(path, encoding='utf-8') as handle:
|
||||
return handle.read()
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
sys.exit(main())
|
||||
Reference in New Issue
Block a user