288 lines
10 KiB
TypeScript
288 lines
10 KiB
TypeScript
import { describe, it, expect } from 'bun:test';
|
|
import { World } from '@common/rpg/core/world';
|
|
import { Health, Stat } from '@common/rpg/components/stat';
|
|
import { Effect, EffectTemplate } from '@common/rpg/components/effect';
|
|
import { EffectSystem } from '@common/rpg/systems/effect';
|
|
|
|
function world() {
|
|
const w = new World();
|
|
w.addSystem(new EffectSystem());
|
|
return w;
|
|
}
|
|
|
|
function withStat(value = 10, min?: number, max?: number) {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
e.add(new Stat({ value, min, max }), 'str');
|
|
return { w, e, stat: e.get(Stat, 'str')! };
|
|
}
|
|
|
|
describe('Effect — onAdd / onRemove', () => {
|
|
it('applies delta to stat on add', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 5 }));
|
|
expect(stat.value).toBe(15);
|
|
});
|
|
|
|
it('reverts delta on remove', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 5 }), 'fx');
|
|
e.remove('fx');
|
|
expect(stat.value).toBe(10);
|
|
});
|
|
|
|
it('applies delta to max field', () => {
|
|
const { e } = withStat(10, undefined, 20);
|
|
const s = e.get(Stat, 'str')!;
|
|
e.add(new Effect({ targetKey: 'str', delta: 10, targetField: 'max' }), 'fx');
|
|
expect(s.max).toBe(30);
|
|
e.remove('fx');
|
|
expect(s.max).toBe(20);
|
|
});
|
|
|
|
it('active is true after add', () => {
|
|
const { e } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 1 }), 'fx');
|
|
expect(e.get(Effect, 'fx')!.active).toBeTrue();
|
|
});
|
|
|
|
it('no-op if target stat is missing', () => {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
expect(() => e.add(new Effect({ targetKey: 'str', delta: 5 }))).not.toThrow();
|
|
});
|
|
});
|
|
|
|
describe('Effect — duration', () => {
|
|
it('expires after duration ticks', () => {
|
|
const { w, e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 5, duration: 2 }));
|
|
expect(stat.value).toBe(15);
|
|
|
|
w.update(1);
|
|
expect(e.has(Effect)).toBeTrue();
|
|
|
|
w.update(1);
|
|
expect(e.has(Effect)).toBeFalse();
|
|
expect(stat.value).toBe(10);
|
|
});
|
|
|
|
it('emits expired before removal', () => {
|
|
const { w, e } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 1, duration: 1 }), 'fx');
|
|
const events: string[] = [];
|
|
e.on('Effect(fx).expired', () => events.push('expired'));
|
|
w.update(1);
|
|
expect(events).toEqual(['expired']);
|
|
});
|
|
|
|
it('reset() restarts timer', () => {
|
|
const { w, e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 5, duration: 2 }), 'fx');
|
|
w.update(1.5);
|
|
e.get(Effect, 'fx')!.reset();
|
|
w.update(1.5); // would have expired without reset
|
|
expect(e.has(Effect)).toBeTrue();
|
|
expect(stat.value).toBe(15);
|
|
});
|
|
|
|
it('reset(duration) changes duration', () => {
|
|
const { w, e } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 5, duration: 1 }), 'fx');
|
|
e.get(Effect, 'fx')!.reset(10);
|
|
w.update(5);
|
|
expect(e.has(Effect)).toBeTrue();
|
|
});
|
|
|
|
it('clear() immediately expires effect', () => {
|
|
const { w, e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 5, duration: 100 }), 'fx');
|
|
e.get(Effect, 'fx')!.clear();
|
|
w.update(0.01);
|
|
expect(e.has(Effect)).toBeFalse();
|
|
expect(stat.value).toBe(10);
|
|
});
|
|
});
|
|
|
|
describe('Effect — permanent', () => {
|
|
it('permanent effect is never removed by EffectSystem', () => {
|
|
const { w, e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 5 }));
|
|
w.update(100);
|
|
expect(e.has(Effect)).toBeTrue();
|
|
expect(stat.value).toBe(15);
|
|
});
|
|
});
|
|
|
|
describe('Effect — scope: onHit', () => {
|
|
it('onAdd is a no-op for onHit scope', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new EffectTemplate({ targetKey: 'str', delta: 99 }));
|
|
expect(stat.value).toBe(10);
|
|
});
|
|
|
|
it('onRemove is a no-op for onHit scope', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new EffectTemplate({ targetKey: 'str', delta: 99 }));
|
|
e.remove('fx');
|
|
expect(stat.value).toBe(10);
|
|
});
|
|
|
|
it('EffectSystem does not tick or remove onHit effects', () => {
|
|
const { w, e } = withStat(10);
|
|
e.add(new EffectTemplate({ targetKey: 'str', delta: 5, duration: 1 }));
|
|
w.update(10);
|
|
expect(e.has(EffectTemplate)).toBeTrue();
|
|
});
|
|
});
|
|
|
|
describe('Effect — multiple effects on same stat', () => {
|
|
it('multiple effects stack additively', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 3 }));
|
|
e.add(new Effect({ targetKey: 'str', delta: 7 }));
|
|
expect(stat.value).toBe(20);
|
|
});
|
|
|
|
it('removing one effect reverts only that delta', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 3 }), 'a');
|
|
e.add(new Effect({ targetKey: 'str', delta: 7 }), 'b');
|
|
e.remove('a');
|
|
expect(stat.value).toBe(17);
|
|
});
|
|
});
|
|
|
|
describe('Effect — targetKey resolution', () => {
|
|
it('no targetKey finds a stat added without a key', () => {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
const stat = e.add(new Stat({ value: 10 })); // Symbol key
|
|
e.add(new Effect({ delta: 5 }));
|
|
expect(stat.value).toBe(15);
|
|
});
|
|
|
|
it('no targetKey falls back to a string-keyed stat when no anonymous stat exists', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new Effect({ delta: 5 }));
|
|
expect(stat.value).toBe(15);
|
|
});
|
|
|
|
it('no targetKey prefers the anonymous (symbol-keyed) stat over a named one', () => {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
const named = e.add(new Stat({ value: 10 }), 'str');
|
|
const anon = e.add(new Stat({ value: 10 })); // Symbol key — should win
|
|
e.add(new Effect({ delta: 5 }));
|
|
expect(anon.value).toBe(15);
|
|
expect(named.value).toBe(10);
|
|
});
|
|
|
|
it('targetKey selects the correct stat among multiple', () => {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
const str = e.add(new Stat({ value: 10 }), 'str');
|
|
const int = e.add(new Stat({ value: 5 }), 'int');
|
|
e.add(new Effect({ targetKey: 'int', delta: 3 }));
|
|
expect(int.value).toBe(8);
|
|
expect(str.value).toBe(10);
|
|
});
|
|
|
|
it('wrong targetKey is a no-op and active stays false', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'dex', delta: 5 }), 'fx');
|
|
expect(e.get(Effect, 'fx')!.active).toBeFalse();
|
|
expect(stat.value).toBe(10);
|
|
});
|
|
});
|
|
|
|
describe('Effect — target component class', () => {
|
|
it('target: Health targets a Health component by key', () => {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
const hp = e.add(new Health({ value: 100, min: 0 }), 'hp');
|
|
e.add(new Effect({ target: Health, targetKey: 'hp', delta: 20 }));
|
|
expect(hp.value).toBe(120);
|
|
});
|
|
|
|
it('removing the effect reverts the delta on the Health component', () => {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
const hp = e.add(new Health({ value: 100, min: 0 }), 'hp');
|
|
e.add(new Effect({ target: Health, targetKey: 'hp', delta: -30 }), 'fx');
|
|
expect(hp.value).toBe(70);
|
|
e.remove('fx');
|
|
expect(hp.value).toBe(100);
|
|
});
|
|
|
|
it('target mismatch (wrong class for given key) is a no-op', () => {
|
|
const { e, stat } = withStat(10);
|
|
e.add(new Effect({ target: Health, targetKey: 'str', delta: 5 }), 'fx');
|
|
expect(e.get(Effect, 'fx')!.active).toBeFalse();
|
|
expect(stat.value).toBe(10);
|
|
});
|
|
|
|
it('target: Health without targetKey applies only to Health, not Stat', () => {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
const str = e.add(new Stat({ value: 10 }), 'str');
|
|
const hp = e.add(new Health({ value: 100, min: 0 }), 'hp');
|
|
e.add(new Effect({ target: Health, delta: 20 }));
|
|
expect(hp.value).toBe(120);
|
|
expect(str.value).toBe(10);
|
|
});
|
|
|
|
it('target: Health without targetKey applies to anonymous Health when Stat also present', () => {
|
|
const w = world();
|
|
const e = w.createEntity();
|
|
const str = e.add(new Stat({ value: 10 }), 'str');
|
|
const hp = e.add(new Health({ value: 100, min: 0 })); // Symbol key
|
|
e.add(new Effect({ target: Health, delta: -10 }));
|
|
expect(hp.value).toBe(90);
|
|
expect(str.value).toBe(10);
|
|
});
|
|
});
|
|
|
|
describe('Effect — condition', () => {
|
|
it('condition-based effect persists while condition is true', () => {
|
|
const { w, e, stat } = withStat(10);
|
|
w.globals.buffed = 1;
|
|
e.add(new Effect({ targetKey: 'str', delta: 5, condition: '$.buffed > 0' }));
|
|
w.update(10);
|
|
expect(e.has(Effect)).toBeTrue();
|
|
expect(stat.value).toBe(15);
|
|
});
|
|
|
|
it('condition-based effect is removed when condition becomes false', () => {
|
|
const { w, e, stat } = withStat(10);
|
|
w.globals.buffed = 1;
|
|
e.add(new Effect({ targetKey: 'str', delta: 5, condition: '$.buffed > 0' }));
|
|
w.globals.buffed = 0;
|
|
w.update(0.01);
|
|
expect(e.has(Effect)).toBeFalse();
|
|
expect(stat.value).toBe(10);
|
|
});
|
|
});
|
|
|
|
describe('Effect — clear() event count', () => {
|
|
it('clear() emits expired exactly once even after subsequent update ticks', () => {
|
|
const { w, e } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 1, duration: 100 }), 'fx');
|
|
const count = { n: 0 };
|
|
e.on('Effect(fx).expired', () => count.n++);
|
|
e.get(Effect, 'fx')!.clear();
|
|
w.update(0.01);
|
|
w.update(0.01);
|
|
expect(count.n).toBe(1);
|
|
});
|
|
|
|
it('natural duration expiry emits expired exactly once', () => {
|
|
const { w, e } = withStat(10);
|
|
e.add(new Effect({ targetKey: 'str', delta: 1, duration: 1 }), 'fx');
|
|
const count = { n: 0 };
|
|
e.on('Effect(fx).expired', () => count.n++);
|
|
w.update(2);
|
|
expect(count.n).toBe(1);
|
|
});
|
|
});
|