353 lines
24 KiB
JavaScript
353 lines
24 KiB
JavaScript
// test/feedback1d-models.test.js — community report D3 after 0.1.0 ("所有特殊源石虫的模型全表现为普通源石虫"): 灼热源石虫 /
|
|
// 炽焰源石虫 (enemy_1305_mhslim / _2, the ELEMENT faction's slugs — up to 10 a round) were drawn with the plain 源石虫
|
|
// skeleton because no community dump carries their models (Ark-Models lists them with an empty assetList), so the
|
|
// asset plan aliased them to enemy_1007_slime. Their official skeletons only exist in the local client
|
|
// (tools/local-extract/extract.py ENEMY_SPINES → public/assets/local/spine/enemy/<id>/, optional and git-ignored), so
|
|
// they are an OVERLAY: data/assets.json keeps the alias as the web model (`spine` + `spineAliasOf`) and adds
|
|
// `spineLocal` (file names in the data/local-assets.json group + the parsed metadata, from the committed
|
|
// tools/assets/local-enemy-spines.json — never from the disk, so the manifest is the same with or without the
|
|
// extraction). The client (assets.js spineEntry) draws the official model when data/local-assets.json lists every one
|
|
// of its files and falls back to the web model when it fails to load (DESIGN §13: local art is optional).
|
|
// Without the extraction the web alias is drawn tinted toward the slug's own colours (render/units.js ALIAS_TINT,
|
|
// research 07 §5.6 "a hue shift" [ASSUMED look]), so source installs still tell them apart from the plain slug.
|
|
// 高能 / 冰爆 / 简饲源石虫 and “庞贝” always had their own models (checked in headless Chrome).
|
|
//
|
|
// Root cause (2026-10-04): Ark-Models *indexes* 1305_mhslim / 1305_mhslim_2 with an EMPTY `assetList` — registered,
|
|
// never uploaded — so `arkModel()` finds nothing and the alias chain drops to enemy_1007_slime, a *different* enemy
|
|
// rather than a variant of it. The mobile build does ship their own model (straight-alpha pages, no `pma: true` line),
|
|
// and it is reachable, but its only public mirror is a community wiki rather than a GitHub dump: adding it would put a
|
|
// non-GitHub host into `sources.mjs` for two models, which the reviewer of this change asked not to do. So the tinted
|
|
// alias stays the web model, the local extraction stays the overlay, and the last block below locks both halves
|
|
// (only these two enemies borrow a different enemy's skeleton; every asset source stays a GitHub dump).
|
|
|
|
import { test, describe, before, after } from 'node:test';
|
|
import assert from 'node:assert/strict';
|
|
import { existsSync, readFileSync, mkdtempSync, mkdirSync, writeFileSync, copyFileSync, rmSync, statSync } from 'node:fs';
|
|
import { spawnSync } from 'node:child_process';
|
|
import { tmpdir } from 'node:os';
|
|
import path from 'node:path';
|
|
import { fileURLToPath } from 'node:url';
|
|
import { buildPlan, ENEMY_SPINE_ALIAS } from '../tools/assets/plan.mjs';
|
|
import { RAW } from '../tools/assets/sources.mjs';
|
|
import { resolveTemplate, collectLeaves } from '../tools/assets/manifest.mjs';
|
|
import { findLocalEnemyModels, localEnemySpineMeta, loadLocalEnemySpines, LOCAL_ENEMY_SPINES_FILE, localEnemySpineGroup } from '../tools/assets/spine.mjs';
|
|
import { indexAudio } from '../tools/assets/audio.mjs';
|
|
import { createAssets, spineEntry, validSpine } from '../public/js/assets.js';
|
|
import { installFakePixi, fakeViewCtx } from './render/fakepixi.js';
|
|
import { presetCamera } from '../public/js/render/projection.js';
|
|
|
|
const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
|
|
const ASSETS = path.join(ROOT, 'public/assets');
|
|
const readJson = (rel) => JSON.parse(readFileSync(path.join(ROOT, rel), 'utf8'));
|
|
const SLUGS = ['enemy_1305_mhslim', 'enemy_1305_mhslim_2'];
|
|
const COMMITTED = readJson(LOCAL_ENEMY_SPINES_FILE).models;
|
|
const MANIFEST = readJson('data/assets.json');
|
|
|
|
/** The real research inputs; Ark-Models carries the plain slug only (its index lists the special ones empty). */
|
|
function plan(localEnemySpines) {
|
|
const modelsData = { data: { '1007_slime': { assetList: { '.skel': 'enemy_1007_slime.skel', '.atlas': 'enemy_1007_slime.atlas', '.png': 'enemy_1007_slime.png' } },
|
|
'1305_mhslim': { assetList: {} }, '1305_mhslim_2': { assetList: {} } } };
|
|
return buildPlan({
|
|
assets07: readJson('docs/research/07-assets.json'), ops03: readJson('docs/research/03-operators.json'),
|
|
enemies05: readJson('docs/research/05-enemies.json'), maps05: readJson('docs/research/05-maps.json'),
|
|
audio: indexAudio({}), modelsData, extraEnemyIds: SLUGS, localEnemySpines,
|
|
});
|
|
}
|
|
|
|
/** A data/local-assets.json listing the extracted files of `ids` (extract.py's group layout). */
|
|
function localManifest(ids, drop = null) {
|
|
const groups = {};
|
|
for (const id of ids) {
|
|
const g = groups[localEnemySpineGroup(id)] = {};
|
|
const m = COMMITTED[id];
|
|
for (const f of [m.skel, m.atlas, ...m.textures]) if (f !== drop) g[f] = { path: `/assets/local/spine/enemy/${id}/${f}`, kind: f.endsWith('.png') ? 'Texture2D' : 'TextAsset' };
|
|
}
|
|
return { version: 1, source: 'local-client', groups };
|
|
}
|
|
|
|
describe('D3: the official slug models are an optional overlay of the web alias', () => {
|
|
test('plan: the web model stays the 源石虫 alias; spineLocal comes from the committed metadata as it is', () => {
|
|
const before = plan(undefined);
|
|
for (const id of SLUGS) {
|
|
assert.equal(before.template.enemies[id].spineAliasOf, 'enemy_1007_slime');
|
|
assert.equal(before.template.enemies[id].spineLocal, undefined, 'no metadata → no overlay');
|
|
}
|
|
const p = plan(COMMITTED);
|
|
const slime = { skel: '/assets/spine/enemy/enemy_1007_slime/enemy_1007_slime.skel', atlas: '/assets/spine/enemy/enemy_1007_slime/enemy_1007_slime.atlas', textures: [], anims: {} };
|
|
const tmp = mkdtempSync(path.join(tmpdir(), 'sp-plan-'));
|
|
try {
|
|
const { value } = resolveTemplate({ enemies: Object.fromEntries(SLUGS.map((id) => [id, p.template.enemies[id]])) },
|
|
{ root: tmp, spine: new Map([['enemy:enemy_1007_slime', slime]]) });
|
|
for (const id of SLUGS) {
|
|
const e = value.enemies[id];
|
|
assert.equal(e.spineAliasOf, 'enemy_1007_slime', `${id}: the web model (works without the local client)`);
|
|
assert.equal(e.spine, slime);
|
|
assert.deepEqual(e.spineLocal, { group: `spine/enemy/${id}`, ...COMMITTED[id] }, `${id}: the overlay, null fields kept`);
|
|
assert.equal(e.spineLocal.anims.attack.begin, null);
|
|
}
|
|
} finally { rmSync(tmp, { recursive: true, force: true }); }
|
|
assert.ok(!collectLeaves(p.template).some((l) => /spineLocal/.test(l.path)), 'the overlay is no file to download');
|
|
assert.ok(p.notes.some((n) => /enemy_1305_mhslim: official Spine from the local client/.test(n)));
|
|
});
|
|
|
|
test('the committed metadata: both ELEMENT slugs, file names of their extract.py group, roles resolved', () => {
|
|
assert.deepEqual(Object.keys(COMMITTED).sort(), SLUGS);
|
|
for (const id of SLUGS) {
|
|
const m = COMMITTED[id];
|
|
assert.equal(m.skel, `${id}.skel`);
|
|
assert.equal(m.atlas, `${id}.atlas`, 'next to the skeleton (pixi-spine finds the atlas by its name)');
|
|
assert.deepEqual(m.textures, [`${id}.png`]);
|
|
assert.equal(m.pma, true, 'premultiplied pages (extract.py merge_alpha)');
|
|
for (const role of ['idle', 'die']) assert.ok(m.anims[role] in m.animations, `${id} ${role}`);
|
|
assert.ok(m.anims.move.loop in m.animations && m.anims.attack.loop in m.animations, `${id} move / attack`);
|
|
assert.ok(m.hits.Attack?.length, `${id}: the OnAttack frame`);
|
|
}
|
|
});
|
|
|
|
test('data/assets.json never depends on the local extraction (no /assets/local/ URL; the web model always there)', () => {
|
|
const urls = [];
|
|
const walk = (n) => { if (typeof n === 'string') { if (n.includes('/assets/local/')) urls.push(n); } else if (n && typeof n === 'object') Object.values(n).forEach(walk); };
|
|
walk(MANIFEST);
|
|
assert.deepEqual(urls, [], 'setup / doctor / the manifest tests count every /assets/ URL as required');
|
|
for (const [id, e] of Object.entries(MANIFEST.enemies)) {
|
|
if (!e.spineLocal) continue;
|
|
assert.ok(SLUGS.includes(id), id);
|
|
assert.deepEqual(e.spineLocal, { group: `spine/enemy/${id}`, ...COMMITTED[id] }, `${id}: the committed metadata`);
|
|
assert.ok(validSpine(spineEntry(MANIFEST, id)), `${id}: a web model without the local client`);
|
|
assert.equal(MANIFEST.enemies[id].spineAliasOf, 'enemy_1007_slime');
|
|
assert.deepEqual(spineEntry(MANIFEST, id), MANIFEST.enemies.enemy_1007_slime.spine, `${id}: the plain 源石虫 on the web`);
|
|
}
|
|
for (const id of SLUGS) assert.ok(MANIFEST.enemies[id].spineLocal, `${id} has its overlay`);
|
|
});
|
|
|
|
test('the committed metadata is what the extracted models parse to', { skip: !SLUGS.every((id) => existsSync(path.join(ASSETS, 'local/spine/enemy', id))) && 'enemy models not extracted (tools/local-extract)' }, async () => {
|
|
const found = await findLocalEnemyModels(ASSETS);
|
|
const { meta, problems } = await localEnemySpineMeta(ASSETS, found);
|
|
assert.deepEqual(problems, []);
|
|
for (const id of SLUGS) assert.deepEqual(meta[id], COMMITTED[id], `${id}: re-run node tools/fetch-assets.mjs --local-spines`);
|
|
});
|
|
|
|
test('localEnemySpineMeta parses an extracted model like the pipeline and writes nothing', { skip: !existsSync(path.join(ASSETS, 'spine/enemy/enemy_1007_slime')) && 'public/assets not downloaded' }, async () => {
|
|
// the plain slug's fetched files stand in for an extraction (same layout: <id>.skel / .atlas / page PNGs)
|
|
const dir = mkdtempSync(path.join(tmpdir(), 'sp-meta-'));
|
|
try {
|
|
const src = path.join(ASSETS, 'spine/enemy/enemy_1007_slime');
|
|
const dst = path.join(dir, 'local/spine/enemy/enemy_9999_slime');
|
|
mkdirSync(dst, { recursive: true });
|
|
for (const f of ['enemy_1007_slime.skel', 'enemy_1007_slime.atlas', 'enemy_1007_slime.png']) copyFileSync(path.join(src, f), path.join(dst, f));
|
|
const atlasBefore = readFileSync(path.join(dst, 'enemy_1007_slime.atlas'));
|
|
const mtime = statSync(path.join(dst, 'enemy_1007_slime.atlas')).mtimeMs;
|
|
const { meta, problems } = await localEnemySpineMeta(dir, await findLocalEnemyModels(dir));
|
|
assert.deepEqual(problems, []);
|
|
const web = MANIFEST.enemies.enemy_1007_slime.spine;
|
|
assert.deepEqual(meta.enemy_9999_slime, {
|
|
skel: 'enemy_1007_slime.skel', atlas: 'enemy_1007_slime.atlas', textures: ['enemy_1007_slime.png'], pma: true,
|
|
anims: web.anims, animations: web.animations, events: web.events, hits: web.hits, bounds: web.bounds,
|
|
});
|
|
assert.ok(readFileSync(path.join(dst, 'enemy_1007_slime.atlas')).equals(atlasBefore), 'read only');
|
|
assert.equal(statSync(path.join(dst, 'enemy_1007_slime.atlas')).mtimeMs, mtime);
|
|
} finally { rmSync(dir, { recursive: true, force: true }); }
|
|
});
|
|
|
|
test('loadLocalEnemySpines: the models of the committed file, {} when it is missing or bad', async () => {
|
|
assert.deepEqual(await loadLocalEnemySpines(path.join(ROOT, LOCAL_ENEMY_SPINES_FILE)), COMMITTED);
|
|
assert.deepEqual(await loadLocalEnemySpines(path.join(ROOT, 'no-such-file.json')), {});
|
|
const dir = mkdtempSync(path.join(tmpdir(), 'sp-lse-'));
|
|
try {
|
|
writeFileSync(path.join(dir, 'a.json'), '{"models":[1]}');
|
|
assert.deepEqual(await loadLocalEnemySpines(path.join(dir, 'a.json')), {});
|
|
} finally { rmSync(dir, { recursive: true, force: true }); }
|
|
});
|
|
|
|
test('findLocalEnemyModels: skeleton + same-stem atlas + page PNGs under local/spine/enemy/<id>/', async () => {
|
|
const dir = mkdtempSync(path.join(tmpdir(), 'sp-local-'));
|
|
try {
|
|
const put = (rel, body = 'x') => { mkdirSync(path.dirname(path.join(dir, rel)), { recursive: true }); writeFileSync(path.join(dir, rel), body); };
|
|
put('local/spine/enemy/enemy_1305_mhslim/enemy_1305_mhslim.skel');
|
|
put('local/spine/enemy/enemy_1305_mhslim/enemy_1305_mhslim.atlas');
|
|
put('local/spine/enemy/enemy_1305_mhslim/enemy_1305_mhslim.png');
|
|
put('local/spine/enemy/enemy_1305_mhslim/enemy_1305_mhslim_2.png');
|
|
put('local/spine/enemy/enemy_x_noatlas/enemy_x_noatlas.skel');
|
|
put('local/spine/enemy/enemy_x_nopng/enemy_x_nopng.skel');
|
|
put('local/spine/enemy/enemy_x_nopng/enemy_x_nopng.atlas');
|
|
put('local/spine/enemy/not-an-enemy/a.skel');
|
|
const found = await findLocalEnemyModels(dir);
|
|
assert.deepEqual(Object.keys(found), ['enemy_1305_mhslim']);
|
|
assert.deepEqual(found.enemy_1305_mhslim, {
|
|
dir: 'local/spine/enemy/enemy_1305_mhslim/', skel: 'local/spine/enemy/enemy_1305_mhslim/enemy_1305_mhslim.skel',
|
|
atlas: 'local/spine/enemy/enemy_1305_mhslim/enemy_1305_mhslim.atlas',
|
|
pngs: ['local/spine/enemy/enemy_1305_mhslim/enemy_1305_mhslim.png', 'local/spine/enemy/enemy_1305_mhslim/enemy_1305_mhslim_2.png'],
|
|
});
|
|
assert.deepEqual(await findLocalEnemyModels(path.join(dir, 'missing')), {});
|
|
} finally { rmSync(dir, { recursive: true, force: true }); }
|
|
});
|
|
});
|
|
|
|
describe('D3 root cause: only the two slugs borrow a different enemy\'s skeleton, and no non-GitHub source is added', () => {
|
|
test('plan: ENEMY_SPINE_ALIAS covers exactly the two slugs (Ark-Models indexes them with an empty assetList)', () => {
|
|
const p = plan(undefined);
|
|
assert.deepEqual(Object.keys(ENEMY_SPINE_ALIAS).sort(), [...SLUGS].sort(), 'exactly the slugs are aliased by hand');
|
|
for (const id of SLUGS) assert.equal(ENEMY_SPINE_ALIAS[id], 'enemy_1007_slime', `${id}: the plain 源石虫`);
|
|
assert.ok(p.notes.some((n) => n.includes('enemy_1305_mhslim') && /aliased/.test(n)),
|
|
'the plan says so in its notes, so a run without the model is explainable');
|
|
});
|
|
|
|
test('data/assets.json: every other spineAliasOf stays inside its own variant family', () => {
|
|
const borrowed = [];
|
|
for (const [id, e] of Object.entries(MANIFEST.enemies)) {
|
|
if (!e.spineAliasOf) continue;
|
|
const base = /^(enemy_\d+_[a-z0-9]+?)_\d+$/i.exec(id); // enemy_2001_duckmi_2 → enemy_2001_duckmi
|
|
if (!SLUGS.includes(id) && (!base || base[1] !== e.spineAliasOf)) borrowed.push(`${id} → ${e.spineAliasOf}`);
|
|
}
|
|
assert.deepEqual(borrowed, [],
|
|
'the six _2 aliases draw the base enemy their own prefab uses; only the two slugs borrow a different enemy');
|
|
});
|
|
|
|
test('every asset source stays a GitHub dump (no third-party mirror for two models)', () => {
|
|
for (const [name, url] of Object.entries(RAW)) {
|
|
assert.match(url, /^https:\/\/raw\.githubusercontent\.com\//, `RAW.${name} is a raw.githubusercontent.com URL`);
|
|
}
|
|
assert.ok(!/prts|torappu/i.test(JSON.stringify(RAW)), 'no community-wiki host among the download sources');
|
|
});
|
|
});
|
|
|
|
describe('D3 client: the official model only when data/local-assets.json lists it', () => {
|
|
const webOf = (id) => MANIFEST.enemies[id].spine; // the plain 源石虫's model (spineAliasOf enemy_1007_slime)
|
|
|
|
test('assets.js spineEntry: every file listed → the official model (web fallback); anything missing → the web alias', () => {
|
|
const local = localManifest(SLUGS);
|
|
for (const id of SLUGS) {
|
|
const web = webOf(id);
|
|
const e = spineEntry(MANIFEST, id, { local });
|
|
assert.equal(e.skel, `/assets/local/spine/enemy/${id}/${id}.skel`);
|
|
assert.equal(e.atlas, `/assets/local/spine/enemy/${id}/${id}.atlas`);
|
|
assert.deepEqual(e.textures, [`/assets/local/spine/enemy/${id}/${id}.png`]);
|
|
assert.equal(e.pma, true);
|
|
assert.deepEqual(e.anims, COMMITTED[id].anims);
|
|
assert.deepEqual(e.hits, COMMITTED[id].hits);
|
|
assert.equal(e.fallback, web, 'the plain 源石虫 if the official model fails to load');
|
|
assert.equal(spineEntry(MANIFEST, id, { local }), e, 'one entry object per manifest pair');
|
|
assert.equal(spineEntry(MANIFEST, id), web, 'no local manifest → the web model');
|
|
assert.equal(spineEntry(MANIFEST, id, { local: localManifest([]) }), web, 'not extracted → the web model');
|
|
assert.equal(spineEntry(MANIFEST, id, { local: localManifest([id], `${id}.png`) }), web, 'a page missing → the web model');
|
|
assert.equal(spineEntry(MANIFEST, id, { local: localManifest([id], `${id}.atlas`) }), web, 'the atlas missing → the web model');
|
|
}
|
|
assert.equal(spineEntry(MANIFEST, 'enemy_1007_slime', { local }), webOf('enemy_1007_slime'), 'other enemies unchanged');
|
|
// the store hands the local manifest over once local() has it
|
|
const store = createAssets({ manifest: MANIFEST, localManifest: local });
|
|
assert.equal(store.spineEntry(SLUGS[0]).skel, `/assets/local/spine/enemy/${SLUGS[0]}/${SLUGS[0]}.skel`);
|
|
assert.equal(createAssets({ manifest: MANIFEST }).spineEntry(SLUGS[0]), webOf(SLUGS[0]), 'before / without local(): the web model');
|
|
});
|
|
|
|
test('render/app.js waits for the local manifest with the asset manifest before building unit views', () => {
|
|
const src = readFileSync(path.join(ROOT, 'public/js/render/app.js'), 'utf8');
|
|
assert.match(src, /await withTimeout\(Promise\.all\(\[assets\.ready \? assets\.ready\(\) : null, assets\.local \? assets\.local\(\) : null\]/);
|
|
});
|
|
|
|
describe('UnitView', () => {
|
|
let fake, UnitView;
|
|
let ALIAS_TINT, UF;
|
|
before(async () => {
|
|
fake = installFakePixi();
|
|
({ UnitView, ALIAS_TINT } = await import('../public/js/render/units.js'));
|
|
({ UF } = await import('../shared/constants.js'));
|
|
});
|
|
after(() => fake.restore());
|
|
const tick = () => new Promise((r) => setImmediate(r));
|
|
const cam = () => presetCamera('normal', { width: 1280, height: 720 });
|
|
const info = (id) => ({ id: 3, side: 'enemy', kind: 'enemy', defId: id, spine: id, tier: 1, x: 6, y: 10, maxHp: 1000 });
|
|
|
|
test('an official model that fails to load falls back to the web model (never the icon diamond)', async () => {
|
|
const local = localManifest(SLUGS);
|
|
const asked = [], released = [];
|
|
const store = (fail) => ({
|
|
picture: () => null, image: async () => null,
|
|
spineEntry: (id) => spineEntry(MANIFEST, id, { local }),
|
|
spine: {
|
|
acquire: async (e) => { asked.push(e.skel); if (fail(e)) throw new Error('404'); return { animations: Object.keys(e.animations).map((name) => ({ name })) }; },
|
|
release: (e) => released.push(e.skel),
|
|
},
|
|
});
|
|
const id = SLUGS[0];
|
|
const web = webOf(id);
|
|
const ok = new UnitView(fakeViewCtx(fake.P, { assets: store(() => false), cam }), info(id));
|
|
await tick(); await tick();
|
|
assert.equal(ok.actor?.entry.skel, `/assets/local/spine/enemy/${id}/${id}.skel`, 'the official model');
|
|
assert.equal(ok.actor.entry.anims.move.loop, 'Move', 'with its own clips');
|
|
asked.length = 0;
|
|
const bad = new UnitView(fakeViewCtx(fake.P, { assets: store((e) => e.local), cam }), info(id));
|
|
await tick(); await tick(); await tick();
|
|
assert.deepEqual(asked, [`/assets/local/spine/enemy/${id}/${id}.skel`, web.skel], 'the official model, then the web one');
|
|
assert.ok(released.includes(`/assets/local/spine/enemy/${id}/${id}.skel`), 'the failed acquire is released');
|
|
assert.equal(bad.actor?.entry, web, 'drawn with the web model');
|
|
assert.equal(bad.entry, web);
|
|
});
|
|
|
|
test('the web alias of a local-only slug is drawn tinted toward its own colours; the official model and the plain 源石虫 are not', async () => {
|
|
const store = (local, fail = () => false) => ({
|
|
picture: () => null, image: async () => null,
|
|
spineEntry: (id) => spineEntry(MANIFEST, id, local ? { local } : undefined),
|
|
spine: { acquire: async (e) => { if (fail(e)) throw new Error('404'); return { animations: Object.keys(e.animations).map((name) => ({ name })) }; }, release() {} },
|
|
});
|
|
const local = localManifest(SLUGS);
|
|
const mk = (id, st) => new UnitView(fakeViewCtx(fake.P, { assets: st, cam }), info(id));
|
|
const web0 = mk(SLUGS[0], store(null)), web1 = mk(SLUGS[1], store(null));
|
|
const official = mk(SLUGS[0], store(local)), failed = mk(SLUGS[1], store(local, (e) => e.local));
|
|
const plain = mk('enemy_1007_slime', store(local));
|
|
for (let i = 0; i < 4; i++) await tick();
|
|
const all = [web0, web1, official, failed, plain];
|
|
for (const v of all) v.update(1 / 60, cam(), 0);
|
|
assert.equal(web0.actor.entry, webOf(SLUGS[0]), 'not extracted: the plain 源石虫 skeleton');
|
|
assert.equal(web0.actor.spine.tint, ALIAS_TINT[SLUGS[0]], '灼热源石虫: orange');
|
|
assert.equal(web1.actor.spine.tint, ALIAS_TINT[SLUGS[1]], '炽焰源石虫: red-orange');
|
|
assert.notEqual(ALIAS_TINT[SLUGS[0]], ALIAS_TINT[SLUGS[1]], 'the two read apart');
|
|
assert.ok(official.actor.entry.local);
|
|
assert.equal(official.actor.spine.tint, 0xffffff, 'the official model as it is');
|
|
assert.equal(failed.actor.entry, webOf(SLUGS[1]));
|
|
assert.equal(failed.actor.spine.tint, ALIAS_TINT[SLUGS[1]], 'the web fallback of a failed official model is tinted too');
|
|
assert.equal(plain.actor.spine.tint, 0xffffff, 'the plain 源石虫 itself');
|
|
web0.flags = UF.FROZEN;
|
|
web0.update(1 / 60, cam(), 1 / 60);
|
|
assert.equal(web0.actor.spine.tint, 0x9fd4ff, 'a status tint wins (frozen)');
|
|
for (const v of all) v.destroy?.();
|
|
});
|
|
});
|
|
});
|
|
|
|
const PY = ['python3', 'python'].find((bin) => spawnSync(bin, ['--version']).status === 0);
|
|
describe('D3: tools/local-extract/extract.py enemy Spine job (no UnityPy needed)', { skip: !PY && 'no python3' }, () => {
|
|
const TOOL = path.join(ROOT, 'tools/local-extract');
|
|
const ENV = { ...process.env, PYTHONDONTWRITEBYTECODE: '1' };
|
|
const py = (body) => {
|
|
const o = spawnSync(PY, ['-c', `import sys, json\nsys.path.insert(0, ${JSON.stringify(TOOL)})\nimport extract as e\n${body}`], { encoding: 'utf8', env: ENV });
|
|
assert.equal(o.status, 0, o.stderr);
|
|
return JSON.parse(o.stdout);
|
|
};
|
|
|
|
test('--print-jobs lists the enemy models; container matching and --only selection', () => {
|
|
const r = spawnSync(PY, [path.join(TOOL, 'extract.py'), '--print-jobs'], { encoding: 'utf8', env: ENV });
|
|
assert.equal(r.status, 0, r.stderr);
|
|
assert.deepEqual(JSON.parse(r.stdout).enemySpines, { bundles: 'refs/arts/enm_art_*.ab', sub: 'spine/enemy', ids: SLUGS });
|
|
const out = py(`W = set(e.ENEMY_SPINES)\n`
|
|
+ `print(json.dumps([e.enemy_spine_id('Assets/Torappu/Arts/Enemies/Spines/enemy_1305_mhslim/2/enemy_1305_mhslim_2_SkeletonData.asset', W),`
|
|
+ ` e.enemy_spine_id('Assets/Torappu/Arts/Enemies/Spines/enemy_1305_mhslim/1/enemy_1305_mhslim_SkeletonData.asset', W),`
|
|
+ ` e.enemy_spine_id('Assets/Torappu/Arts/Enemies/Spines/enemy_1007_slime/enemy_1007_slime_SkeletonData.asset', W),`
|
|
+ ` e.enemy_spine_id('Assets/Torappu/Arts/Enemies/Spines/enemy_1305_mhslim/1/enemy_1305_mhslim_Material.mat', W),`
|
|
+ ` [e.wants_sub(o, 'spine/enemy') for o in ([], ['spine'], ['spine/enemy'], ['spine/enemy/enemy_1305_mhslim'], ['spine/token_x'], ['map'])]]))`);
|
|
assert.deepEqual(out, ['enemy_1305_mhslim_2', 'enemy_1305_mhslim', null, null, [true, true, true, true, false, false]]);
|
|
});
|
|
|
|
test('normalize_atlas: the real page size and pma: true, like the fetched enemy atlases (the client loads it as is)', async () => {
|
|
const { normalizeAtlas } = await import('../tools/assets/atlas.mjs');
|
|
// the client's atlas text of 灼热源石虫 (leading blank line, size, no pma), shortened
|
|
const raw = '\nenemy_1305_mhslim.png\nsize: 256,256\nformat: RGBA8888\nfilter: Linear,Linear\nrepeat: none\nC_Body_1\n rotate: false\n xy: 2, 159\n size: 55, 64\n orig: 55, 64\n offset: 0, 0\n index: -1\n';
|
|
const sized = py(`print(json.dumps(e.normalize_atlas(${JSON.stringify(raw)}, {'enemy_1305_mhslim.png': (256, 256)})))`);
|
|
assert.equal(sized, normalizeAtlas(raw, { pageSize: () => ({ width: 256, height: 256 }), pma: true }).text, 'the same text as tools/assets/atlas.mjs');
|
|
assert.match(sized, /repeat: none\npma: true\nC_Body_1\n {2}rotate: false\n {2}xy: 2, 159\n {2}size: 55, 64/, 'region fields untouched');
|
|
const noSize = raw.replace('size: 256,256\n', '');
|
|
const fixed = py(`print(json.dumps(e.normalize_atlas(${JSON.stringify(noSize)}, {'enemy_1305_mhslim.png': (512, 256)})))`);
|
|
assert.match(fixed, /\nenemy_1305_mhslim\.png\nsize: 512,256\nformat: RGBA8888/);
|
|
assert.equal(py(`print(json.dumps(e.normalize_atlas(${JSON.stringify(sized)}, {'enemy_1305_mhslim.png': (256, 256)})))`), sized, 'idempotent');
|
|
});
|
|
});
|