@underpostnet/cyberia 3.3.0 → 3.3.76

package/test/integration/app/cyberia/cyberia-instance-conf-coerce.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect } from 'vitest';
+import { CyberiaInstanceConfModel } from '../../../../src/api/cyberia-instance-conf/cyberia-instance-conf.model.js';
+import { CyberiaInstanceConfService } from '../../../../src/api/cyberia-instance-conf/cyberia-instance-conf.service.js';
+import { CYBERIA_INSTANCE_CONF_DEFAULTS } from '../../../../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
+
+const coerce = (conf) => CyberiaInstanceConfService.coerceToSchema(conf, CyberiaInstanceConfModel);
+
+// A backup written before the chance fields became fractions of one, as the exports on disk are.
+const legacy = { instanceCode: 'LEGACY', lifeRegenChance: 300, maxChance: 10000 };
+
+describe('instance conf import coercion', () => {
+  it('resets a value the schema rejects to its default and says so', async () => {
+    const { conf, resets } = await coerce(legacy);
+    expect(conf.lifeRegenChance).toBe(CYBERIA_INSTANCE_CONF_DEFAULTS.lifeRegenChance);
+    expect(conf.maxChance).toBe(CYBERIA_INSTANCE_CONF_DEFAULTS.maxChance);
+    expect(resets.map(({ path, from }) => [path, from])).toEqual([
+      ['lifeRegenChance', 300],
+      ['maxChance', 10000],
+    ]);
+  });
+
+  it('leaves every valid field exactly as it was', async () => {
+    const { conf, resets } = await coerce({ ...legacy, tickRate: 12, aoiRadius: 7 });
+    expect(conf.tickRate).toBe(12);
+    expect(conf.aoiRadius).toBe(7);
+    expect(conf.instanceCode).toBe('LEGACY');
+    expect(resets).toHaveLength(2);
+  });
+
+  it('is a no-op on a conf that already passes', async () => {
+    const { conf, resets } = await coerce({ instanceCode: 'CLEAN', lifeRegenChance: 0.2 });
+    expect(resets).toEqual([]);
+    expect(conf.lifeRegenChance).toBe(0.2);
+  });
+
+  it('resets a nested field through its dotted path', async () => {
+    const { conf, resets } = await coerce({ instanceCode: 'NESTED', skillRules: { projectileSpawnChance: 42 } });
+    expect(conf.skillRules.projectileSpawnChance).toBe(CYBERIA_INSTANCE_CONF_DEFAULTS.skillRules.projectileSpawnChance);
+    expect(resets[0].path).toBe('skillRules.projectileSpawnChance');
+  });
+
+  it('produces a document the model accepts, so import can never half-fail', async () => {
+    const { conf } = await coerce(legacy);
+    await expect(new CyberiaInstanceConfModel(conf).validate()).resolves.toBeUndefined();
+  });
+
+  it('converges: coercing its own output changes nothing', async () => {
+    const { conf } = await coerce(legacy);
+    const { conf: again, resets } = await coerce(conf);
+    expect(resets).toEqual([]);
+    expect(again).toEqual(conf);
+  });
+});

package/test/{cyberia-instance-conf-defaults.test.js → integration/app/cyberia/cyberia-instance-conf-defaults.test.js}

@@ -4,7 +4,7 @@ import { expect } from 'chai';
 import {
   fillInstanceConfDefaults,
   CYBERIA_INSTANCE_CONF_DEFAULTS,
-} from '../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
+} from '../../../../src/api/cyberia-server-defaults/cyberia-server-defaults.js';
 
 // The CyberiaInstanceConfSchema fields that must always be present after a
 // backfill. Mirrors cyberia-instance-conf.model.js (minus instanceCode, which
@@ -25,7 +25,7 @@ const SCHEMA_FIELDS = [
   'playerBaseSpeed',
   'playerBaseLifeRegenMin',
   'playerBaseLifeRegenMax',
-  'sumStatsLimit',
+  'progressionRules',
   'maxActiveLayers',
   'initialLifeFraction',
   'respawnDurationMs',
@@ -35,7 +35,6 @@ const SCHEMA_FIELDS = [
   'maxChance',
   'entityDefaults',
   'statusIcons',
-  'skillConfig',
   'skillRules',
   'equipmentRules',
 ];
@@ -90,33 +89,28 @@ describe('fillInstanceConfDefaults', () => {
   });
 
   it('keeps a present non-empty array and does not merge defaults into it', () => {
-    const custom = [{ entityType: 'player', liveItemIds: ['anon'], deadItemIds: [], dropItemIds: [] }];
+    // entityDefaults holds CyberiaEntityTypeDefault references, never documents.
+    const custom = ['6a9d72430a55742d256c22d6', '6a9d72430a55742d256c22d7'];
     const out = fillInstanceConfDefaults({ entityDefaults: custom });
     expect(out.entityDefaults).to.deep.equal(custom);
   });
 
-  it('populates an empty skillConfig from defaults, normalised to schema shape (no `skills`)', () => {
-    for (const input of [{}, { skillConfig: [] }, { skillConfig: null }]) {
-      const out = fillInstanceConfDefaults(input);
-      expect(out.skillConfig.length, JSON.stringify(input)).to.be.greaterThan(0);
-      for (const entry of out.skillConfig) {
-        expect(entry).to.have.property('triggerItemId');
-        expect(entry).to.have.property('logicEventIds');
-        expect(entry).to.not.have.property('skills');
-      }
+  it('carries no skillConfig, because an instance never stores which skills it runs', () => {
+    // The CyberiaSkill collection owns the definitions; membership is derived from the content an
+    // instance names. A conf from before that still carrying the field has it dropped, so a stale
+    // list cannot reach the wire behind the derived one.
+    for (const input of [{}, { skillConfig: [] }, { skillConfig: [{ triggerItemId: 'hatchet' }] }]) {
+      expect(fillInstanceConfDefaults(input), JSON.stringify(input)).to.not.have.property('skillConfig');
     }
   });
 
-  it('keeps an author-set non-empty skillConfig verbatim', () => {
-    const custom = [{ triggerItemId: 'custom-weapon', logicEventIds: ['projectile'] }];
-    const out = fillInstanceConfDefaults({ skillConfig: custom });
-    expect(out.skillConfig).to.deep.equal(custom);
-  });
-
-  it('fills an empty config array (entityDefaults) from defaults', () => {
-    const out = fillInstanceConfDefaults({ entityDefaults: [] });
-    expect(out.entityDefaults.length).to.be.greaterThan(0);
-    expect(out.entityDefaults).to.deep.equal(CYBERIA_INSTANCE_CONF_DEFAULTS.entityDefaults);
+  it('leaves entityDefaults empty, because referencing none is a complete world', () => {
+    // A conf owns references, not defaults: naming no document means "add nothing to the
+    // canonical ENTITY_TYPE_DEFAULTS", which is what every fresh instance wants.
+    for (const input of [{}, { entityDefaults: [] }, { entityDefaults: null }]) {
+      expect(fillInstanceConfDefaults(input).entityDefaults, JSON.stringify(input)).to.deep.equal([]);
+    }
+    expect(CYBERIA_INSTANCE_CONF_DEFAULTS.entityDefaults).to.deep.equal([]);
   });
 
   it('preserves DB metadata (_id, instanceCode, timestamps)', () => {

package/test/integration/app/cyberia/cyberia-instance-items.test.js

@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'vitest';
+import {
+  collectInstanceItemIds,
+  collectSummonedItemIds,
+  isMaterialItemId,
+  selectInstanceSkills,
+} from '../../../../src/api/cyberia-instance/cyberia-instance-items.js';
+
+const SKILLS = [
+  { triggerItemId: 'atlas_pistol_mk2', skills: [{ summonedEntityItemId: 'atlas_pistol_mk2_bullet' }] },
+  { triggerItemId: 'hatchet', skills: [{ summonedEntityItemId: 'hatchet-skill' }] },
+  { triggerItemId: 'anon', skills: [{ summonedEntityItemId: '$active_skin' }] },
+];
+
+describe('what an instance names', () => {
+  it('reads the four sources and nothing else', () => {
+    const itemIds = collectInstanceItemIds({
+      maps: [{ entities: [{ objectLayerItemIds: ['purple', 'atlas_pistol_mk2'] }] }],
+      entityDefaults: [
+        { liveItemIds: ['wood-1'], deadItemIds: ['wood-extracted-1'], dropItemIds: ['wood-drop-1'], inventoryItemsIds: ['tim-knife'] },
+      ],
+      actions: [
+        {
+          shopItems: [{ itemId: 'hatchet', priceItemId: 'coin' }],
+          craftRecipes: [{ ingredients: [{ itemId: 'wood-1' }], outputItems: [{ itemId: 'plank' }] }],
+        },
+      ],
+      quests: [{ steps: [{ objectives: [{ itemId: 'kishins' }] }], rewards: [{ itemId: 'lain' }] }],
+    });
+    expect([...itemIds].sort()).toEqual([
+      'atlas_pistol_mk2',
+      'coin',
+      'hatchet',
+      'kishins',
+      'lain',
+      'plank',
+      'purple',
+      'tim-knife',
+      'wood-1',
+      'wood-drop-1',
+      'wood-extracted-1',
+    ]);
+  });
+
+  it('is empty for an instance with no content, and survives ragged documents', () => {
+    expect([...collectInstanceItemIds()]).toEqual([]);
+    expect([...collectInstanceItemIds({ maps: [null, {}], entityDefaults: [{}], actions: [{}], quests: [{}] })]).toEqual(
+      [],
+    );
+  });
+
+  it('leaves runtime placeholders out — they name no document', () => {
+    expect(isMaterialItemId('$active_skin')).toBe(false);
+    expect(isMaterialItemId('anon')).toBe(true);
+    expect([...collectInstanceItemIds({ quests: [{ rewards: [{ itemId: '$active_skin' }] }] })]).toEqual([]);
+  });
+});
+
+describe('which skills an instance runs', () => {
+  it('takes a skill whose trigger the world names, wherever it named it', () => {
+    // The reported case: no entity wears a hatchet, a quest asks for one, and the skill belongs.
+    const owned = collectInstanceItemIds({
+      maps: [{ entities: [{ objectLayerItemIds: ['anon'] }] }],
+      quests: [{ steps: [{ objectives: [{ itemId: 'hatchet' }] }] }],
+    });
+    expect(selectInstanceSkills(SKILLS, owned).map((skill) => skill.triggerItemId)).toEqual(['hatchet', 'anon']);
+  });
+
+  it('leaves out a skill nothing in the world triggers', () => {
+    expect(selectInstanceSkills(SKILLS, new Set(['purple']))).toEqual([]);
+    expect(selectInstanceSkills(SKILLS, new Set())).toEqual([]);
+  });
+
+  it('accepts a plain array of ids as well as a set', () => {
+    expect(selectInstanceSkills(SKILLS, ['coin', 'hatchet']).map((skill) => skill.triggerItemId)).toEqual(['hatchet']);
+  });
+
+  it('collects what the selected skills summon, minus the placeholders', () => {
+    // A summoned bullet needs an atlas; '$active_skin' is resolved by the simulation.
+    expect([...collectSummonedItemIds(SKILLS)].sort()).toEqual(['atlas_pistol_mk2_bullet', 'hatchet-skill']);
+    expect([...collectSummonedItemIds([])]).toEqual([]);
+  });
+
+  it('does not let a summoned item make its own skill belong', () => {
+    // Membership is decided before summons are folded in, so a world that merely draws a bullet
+    // does not thereby acquire the weapon skill that fires it.
+    const owned = new Set(['atlas_pistol_mk2_bullet']);
+    expect(selectInstanceSkills(SKILLS, owned)).toEqual([]);
+  });
+});