265 lines
11 KiB
JavaScript
265 lines
11 KiB
JavaScript
import assert from "node:assert/strict";
|
|
import fs from "node:fs";
|
|
import os from "node:os";
|
|
import path from "node:path";
|
|
import test from "node:test";
|
|
import {
|
|
auditPriestOriginalManifest,
|
|
packagePriestOriginalEffects,
|
|
priestSpellIdsFromCatalog,
|
|
} from "./package-priest-original.mjs";
|
|
|
|
test("collects every ranked Priest spell id", () => {
|
|
const ids = priestSpellIdsFromCatalog({
|
|
classes: {
|
|
priest: [
|
|
{ ranks: [{ spellId: 2050 }, { spellId: 2052 }] },
|
|
{ ranks: [{ spellId: 2061 }] },
|
|
],
|
|
},
|
|
});
|
|
|
|
assert.equal(ids.has(2050), true);
|
|
assert.equal(ids.has(2052), true);
|
|
assert.equal(ids.has(2061), true);
|
|
assert.equal(ids.has(585), true);
|
|
});
|
|
|
|
test("packages source-backed Priest graphs and attaches only ready assets", () => {
|
|
const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "healer-man-priest-effects-"));
|
|
try {
|
|
const modelRoot = path.join(temporaryRoot, "models");
|
|
const textureRoot = path.join(temporaryRoot, "textures");
|
|
const outputRoot = path.join(temporaryRoot, "public-pack");
|
|
fs.mkdirSync(path.join(modelRoot, "Spells"), { recursive: true });
|
|
fs.mkdirSync(path.join(textureRoot, "Spells"), { recursive: true });
|
|
const modelBuffer = Buffer.alloc(64);
|
|
modelBuffer.writeUInt32LE(0, 60);
|
|
fs.writeFileSync(path.join(modelRoot, "Spells", "Fixture.m2"), modelBuffer);
|
|
fs.writeFileSync(path.join(textureRoot, "Spells", "Fixture.BLP"), Buffer.from("source-texture"));
|
|
|
|
const sourceManifest = {
|
|
schemaVersion: 1,
|
|
coverage: { requested: 1, authentic: 1, fallback: 0 },
|
|
entries: [{
|
|
key: "wow335:2061",
|
|
source: "wow335",
|
|
spellId: 2061,
|
|
phases: { impact: [{ model: "Spells/Fixture.mdx" }] },
|
|
}],
|
|
};
|
|
const decoded = {
|
|
durationMs: 900,
|
|
animations: [{ index: 0, id: 0, variationIndex: 0, durationMs: 900, moveSpeed: 0, flags: 0 }],
|
|
textures: [{ type: 0, flags: 0, filename: "Spells/Fixture.BLP" }],
|
|
ribbons: [],
|
|
particles: [{
|
|
id: 1,
|
|
flags: 0,
|
|
position: [0, 0, 0],
|
|
parentBone: 0,
|
|
textureIndex: 0,
|
|
geometryModel: "",
|
|
recursionModel: "",
|
|
blendMode: 4,
|
|
emitterType: 1,
|
|
particleColorIndex: 0,
|
|
particleType: 0,
|
|
headOrTail: 0,
|
|
textureTileRotation: 0,
|
|
textureRows: 1,
|
|
textureColumns: 1,
|
|
lifespanVariation: 0,
|
|
emissionRateVariation: 0,
|
|
scaleVariation: [0, 0],
|
|
tailLength: 0,
|
|
tracks: Object.fromEntries([
|
|
"emissionSpeed", "speedVariation", "verticalRange", "horizontalRange", "gravity",
|
|
"lifespan", "emissionRate", "emissionAreaLength", "emissionAreaWidth", "zSource", "enabled",
|
|
].map((name) => [name, {
|
|
interpolation: name === "emissionRate" ? 1 : 0,
|
|
globalSequence: -1,
|
|
firstSequence: { samples: name === "enabled" ? [{ timeMs: 0, value: 1 }] : [] },
|
|
}]).concat([
|
|
["headCell", { samples: [] }],
|
|
["tailCell", { samples: [] }],
|
|
])),
|
|
samples: {
|
|
emissionRate: [{ timeMs: 0, value: 12 }],
|
|
lifespan: [{ timeMs: 0, value: 0.8 }],
|
|
emissionSpeed: [{ timeMs: 0, value: 1 }],
|
|
color: [{ normalizedTime: 0, value: [255, 255, 255] }],
|
|
alpha: [{ normalizedTime: 0, value: 32767 }],
|
|
scale: [{ normalizedTime: 0, value: [0.2, 0.2] }],
|
|
},
|
|
}],
|
|
};
|
|
const { manifest, report } = packagePriestOriginalEffects(sourceManifest, {
|
|
catalog: { classes: { priest: [{ ranks: [{ spellId: 2061 }] }] } },
|
|
modelRoots: [modelRoot],
|
|
textureRoots: [textureRoot],
|
|
outputRoot,
|
|
publicPrefix: "/fixture/priest",
|
|
decodeM2: () => decoded,
|
|
convertTexture: (source, output) => fs.copyFileSync(source, output),
|
|
});
|
|
|
|
const asset = manifest.entries[0].phases.impact[0];
|
|
assert.equal(asset.effectKind, "wow-m2-particles");
|
|
assert.match(asset.effectGraphUrl, /^\/fixture\/priest\/graphs\/fixture-/);
|
|
assert.equal(report.packagedModels, 1);
|
|
assert.equal(report.readyParticleEmitters, 1);
|
|
const graphFile = path.join(outputRoot, "graphs", path.posix.basename(asset.effectGraphUrl));
|
|
const graph = JSON.parse(fs.readFileSync(graphFile, "utf8"));
|
|
assert.equal(graph.sourceModel, "Spells/Fixture.mdx");
|
|
assert.equal(graph.textures[0].url.startsWith("/fixture/priest/textures/"), true);
|
|
assert.equal(graph.interpolation, undefined);
|
|
assert.equal(graph.particles[0].interpolation.emissionRate, 1);
|
|
assert.deepEqual(graph.particles[0].samples.enabled, [{ timeMs: 0, value: 1 }]);
|
|
} finally {
|
|
fs.rmSync(temporaryRoot, { recursive: true, force: true });
|
|
}
|
|
});
|
|
|
|
test("packages the Power Word: Shield aura as a three-layer static mesh graph", () => {
|
|
const temporaryRoot = fs.mkdtempSync(path.join(os.tmpdir(), "healer-man-priest-shield-"));
|
|
try {
|
|
const modelRoot = path.join(temporaryRoot, "models");
|
|
const textureRoot = path.join(temporaryRoot, "textures");
|
|
const outputRoot = path.join(temporaryRoot, "public-pack");
|
|
fs.mkdirSync(path.join(modelRoot, "Spells"), { recursive: true });
|
|
fs.mkdirSync(path.join(textureRoot, "Spells"), { recursive: true });
|
|
fs.writeFileSync(
|
|
path.join(modelRoot, "Spells", "HolyDivineShield_State_Base.m2"), Buffer.from("fixture-m2"),
|
|
);
|
|
fs.writeFileSync(
|
|
path.join(modelRoot, "Spells", "HolyDivineShield_State_Base00.skin"), Buffer.from("fixture-skin"),
|
|
);
|
|
for (const texture of ["ShieldA.BLP", "ShieldB.BLP", "ShieldC.BLP"]) {
|
|
fs.writeFileSync(path.join(textureRoot, "Spells", texture), Buffer.from(`source-${texture}`));
|
|
}
|
|
const scalarTrack = (values, interpolation = 1) => ({
|
|
interpolation,
|
|
globalSequence: -1,
|
|
sequences: [{ timestamps: values.map((_, index) => index * 500), values }],
|
|
});
|
|
const colorTrack = (color) => ({
|
|
interpolation: 0,
|
|
globalSequence: -1,
|
|
sequences: [{ timestamps: [0], values: [color] }],
|
|
});
|
|
const sourceManifest = {
|
|
schemaVersion: 1,
|
|
coverage: { requested: 1, authentic: 1, fallback: 0 },
|
|
entries: [{
|
|
key: "wow335:17",
|
|
source: "wow335",
|
|
spellId: 17,
|
|
phases: {
|
|
"aura-start": [{ model: "Spells/HolyDivineShield_State_Base.mdx" }],
|
|
},
|
|
}],
|
|
};
|
|
const decodedMesh = {
|
|
globalSequences: [],
|
|
animations: [
|
|
{ index: 0, id: 0, variationIndex: 0, durationMs: 700, moveSpeed: 0, flags: 33 },
|
|
{ index: 1, id: 158, variationIndex: 0, durationMs: 633, moveSpeed: 0, flags: 32 },
|
|
{ index: 2, id: 159, variationIndex: 0, durationMs: 1_100, moveSpeed: 0, flags: 33 },
|
|
],
|
|
bounds: { minimum: [-1, -1, 0], maximum: [1, 1, 0], radius: 1.5 },
|
|
vertices: [
|
|
{ position: [0, 0, 0], normal: [1, 0, 0], uv: [0, 0] },
|
|
{ position: [0, 1, 0], normal: [1, 0, 0], uv: [1, 0] },
|
|
{ position: [0, 0, 1], normal: [1, 0, 0], uv: [0, 1] },
|
|
],
|
|
indices: [0, 1, 2, 0, 1, 2, 0, 1, 2],
|
|
colors: [0, 1, 2].map((index) => ({
|
|
color: colorTrack([1, 0.9 - index * 0.1, 0.3]),
|
|
alpha: scalarTrack([32_767], 0),
|
|
})),
|
|
textures: ["ShieldA.BLP", "ShieldB.BLP", "ShieldC.BLP"].map((filename) => ({
|
|
type: 0, flags: 0, filename: `Spells/${filename}`,
|
|
})),
|
|
textureWeights: [0, 1, 2].map(() => scalarTrack([0, 6_553])),
|
|
materials: [0, 1, 2].map(() => ({ flags: 19, blendMode: 4 })),
|
|
skin: {
|
|
textureUnits: [0, 1, 2].map((index) => ({
|
|
submeshIndex: index,
|
|
priorityPlane: 0,
|
|
shaderId: 0,
|
|
colorIndex: index,
|
|
materialIndex: index,
|
|
materialLayer: 0,
|
|
textureIndices: [index],
|
|
textureCoordinateIndices: [0],
|
|
textureWeightIndices: [index],
|
|
textureTransformIndices: [-1],
|
|
drawRange: { indexStart: index * 3, indexCount: 3 },
|
|
})),
|
|
},
|
|
};
|
|
const { manifest, report } = packagePriestOriginalEffects(sourceManifest, {
|
|
catalog: { classes: { priest: [{ ranks: [{ spellId: 17 }] }] } },
|
|
modelRoots: [modelRoot],
|
|
textureRoots: [textureRoot],
|
|
outputRoot,
|
|
publicPrefix: "/fixture/priest",
|
|
decodeM2: () => { throw new Error("particle decoder should not handle the static shield"); },
|
|
decodeMesh: () => decodedMesh,
|
|
convertTexture: (source, output) => fs.copyFileSync(source, output),
|
|
});
|
|
|
|
const asset = manifest.entries[0].phases["aura-start"][0];
|
|
assert.equal(asset.effectKind, "wow-m2-static-mesh");
|
|
assert.equal(asset.scale, 0.7);
|
|
assert.match(asset.effectGraphUrl, /^\/fixture\/priest\/graphs\/holydivineshield-state-base-/);
|
|
assert.equal(report.readyStaticMeshes, 1);
|
|
assert.equal(report.readyParticleEmitters, 0);
|
|
const graphFile = path.join(outputRoot, "graphs", path.posix.basename(asset.effectGraphUrl));
|
|
const graph = JSON.parse(fs.readFileSync(graphFile, "utf8"));
|
|
assert.equal(graph.kind, "wow-m2-static-mesh");
|
|
assert.deepEqual(graph.geometry, {
|
|
positions: [0, 0, 0, 0, 1, 0, 0, 0, 1],
|
|
normals: [1, 0, 0, 1, 0, 0, 1, 0, 0],
|
|
uvs: [0, 0, 1, 0, 0, 1],
|
|
indices: [0, 1, 2, 0, 1, 2, 0, 1, 2],
|
|
});
|
|
assert.equal(graph.layers.length, 3);
|
|
assert.deepEqual(graph.animations.map(({ id, durationMs }) => ({ id, durationMs })), [
|
|
{ id: 0, durationMs: 700 },
|
|
{ id: 158, durationMs: 633 },
|
|
{ id: 159, durationMs: 1_100 },
|
|
]);
|
|
assert.equal(graph.colors.length, 3);
|
|
assert.equal(graph.textureWeights.length, 3);
|
|
assert.deepEqual(graph.textureWeights[0], {
|
|
interpolation: 1,
|
|
globalSequence: -1,
|
|
sequences: [{ timestamps: [0, 500], values: [0, 6_553] }],
|
|
});
|
|
assert.deepEqual(graph.layers.map((layer) => ({
|
|
textureIndex: layer.textureIndex,
|
|
blendMode: layer.blendMode,
|
|
drawRange: [layer.indexStart, layer.indexCount],
|
|
})), [
|
|
{ textureIndex: 0, blendMode: 4, drawRange: [0, 3] },
|
|
{ textureIndex: 1, blendMode: 4, drawRange: [3, 3] },
|
|
{ textureIndex: 2, blendMode: 4, drawRange: [6, 3] },
|
|
]);
|
|
assert.ok(graph.textures.every((texture) => texture.url.startsWith("/fixture/priest/textures/")));
|
|
const audit = auditPriestOriginalManifest(manifest, new Set([17]), new Set([17]));
|
|
assert.deepEqual(audit.missingPowerWordShieldAuraStarts, []);
|
|
const missingAudit = auditPriestOriginalManifest({
|
|
...manifest,
|
|
entries: manifest.entries.map((entry) => ({
|
|
...entry,
|
|
phases: { "aura-start": entry.phases["aura-start"].map((item) => ({ ...item, effectKind: "wrong" })) },
|
|
})),
|
|
}, new Set([17]), new Set([17]));
|
|
assert.deepEqual(missingAudit.missingPowerWordShieldAuraStarts, [17]);
|
|
} finally {
|
|
fs.rmSync(temporaryRoot, { recursive: true, force: true });
|
|
}
|
|
});
|