@jgengine/core 0.8.0 → 0.10.0

package/dist/cartridge/runtime.js

@@ -0,0 +1,556 @@
+import { advanceSpawnDirector, createSpawnDirectorState } from "../ai/spawnDirector.js";
+import { createAbilityKit } from "../combat/abilityKit.js";
+import { setGamePhase } from "../game/gamePhase.js";
+import { leveling } from "../game/progression.js";
+import { createRunDraft } from "../game/runDraft.js";
+import { aimToPoint } from "../input/pointer.js";
+import { seededRng } from "../item/affix.js";
+import { selectAutoTarget } from "../scene/autoTarget.js";
+import { HIT_EFFECT, XP_GEM_BASE_TYPE, leveled, } from "./spec.js";
+function gemRarity(spec, value) {
+    for (const [threshold, rarity] of spec.xpGems.rarityThresholds) {
+        if (value >= threshold)
+            return rarity;
+    }
+    return spec.xpGems.defaultRarity;
+}
+function facing(fromX, fromZ, toX, toZ) {
+    return Math.atan2(toX - fromX, toZ - fromZ);
+}
+function buildKit(spec, levels) {
+    return createAbilityKit(Object.entries(spec.weapons).map(([id, weapon]) => ({
+        id,
+        cooldownMs: leveled(weapon.cooldownMs, levels[id] ?? 1),
+    })));
+}
+function compileEntities(spec) {
+    const out = {
+        [spec.player.kind]: {
+            role: "player",
+            movement: { walkSpeed: spec.player.walkSpeed },
+            stats: {
+                health: { max: spec.player.health, min: 0 },
+                xp: { max: 1, min: 0, current: 0 },
+                level: { max: spec.progression.maxLevel, min: 1, current: 1 },
+            },
+            receive: { hit: { order: ["health"] } },
+        },
+    };
+    for (const [id, enemy] of Object.entries(spec.enemies)) {
+        out[id] = {
+            role: "enemy",
+            movement: { walkSpeed: enemy.walkSpeed },
+            stats: { health: { max: enemy.health, min: 0 } },
+            receive: { hit: { order: ["health"] } },
+        };
+    }
+    return out;
+}
+export function createCartridge(spec) {
+    const track = leveling({ xpForLevel: spec.progression.xp, maxLevel: spec.progression.maxLevel });
+    const entities = compileEntities(spec);
+    const runs = new WeakMap();
+    function initialPhase() {
+        if (spec.flow?.start === "gate")
+            return "start";
+        if ((spec.flow?.countdownSeconds ?? 0) > 0)
+            return "countdown";
+        return "playing";
+    }
+    function seededState() {
+        const seed = spec.seed ?? "cartridge";
+        const weaponLevels = {};
+        for (const id of Object.keys(spec.weapons))
+            weaponLevels[id] = 1;
+        const offers = spec.progression.draft.upgrades.map((upgrade) => ({
+            id: upgrade.id,
+            label: upgrade.label,
+            weight: upgrade.weight,
+            maxStacks: upgrade.maxStacks,
+        }));
+        return {
+            rng: seededRng(seed),
+            spawn: createSpawnDirectorState(spec.spawning.director),
+            weaponLevels,
+            kit: buildKit(spec, weaponLevels),
+            fields: { ...spec.fields },
+            enemyNextHitAt: new Map(),
+            phase: initialPhase(),
+            playingSeconds: 0,
+            countdownRemaining: spec.flow?.countdownSeconds ?? 0,
+            kills: 0,
+            levelUpQueue: 0,
+            draft: createRunDraft({ offers, rng: seededRng(`${seed}-draft`) }),
+            pendingOffers: null,
+            bolts: [],
+            pulses: [],
+            fxCounter: 0,
+        };
+    }
+    function createRun() {
+        const run = {
+            ...seededState(),
+            listeners: new Set(),
+            view: {
+                get phase() {
+                    return run.phase;
+                },
+                get playingSeconds() {
+                    return run.playingSeconds;
+                },
+                get countdownRemaining() {
+                    return run.countdownRemaining;
+                },
+                get kills() {
+                    return run.kills;
+                },
+                weaponLevel: (weaponId) => run.weaponLevels[weaponId] ?? 1,
+                field: (name) => run.fields[name] ?? 0,
+                get pendingOffers() {
+                    if (run.pendingOffers === null)
+                        return null;
+                    return run.pendingOffers.map((offer) => ({ id: offer.id, label: offer.label ?? offer.id }));
+                },
+                get bolts() {
+                    return run.bolts;
+                },
+                get pulses() {
+                    return run.pulses;
+                },
+                subscribe(listener) {
+                    run.listeners.add(listener);
+                    return () => run.listeners.delete(listener);
+                },
+            },
+        };
+        return run;
+    }
+    function getRun(ctx) {
+        let existing = runs.get(ctx);
+        if (existing === undefined) {
+            existing = createRun();
+            runs.set(ctx, existing);
+        }
+        return existing;
+    }
+    function notify(run) {
+        for (const listener of run.listeners)
+            listener();
+    }
+    function syncPhase(ctx, run) {
+        setGamePhase(ctx, run.phase === "playing" ? "playing" : run.phase === "won" || run.phase === "lost" ? "ended" : "menu");
+    }
+    function damageMultiplier(run) {
+        return run.fields["damageMultiplier"] ?? 1;
+    }
+    function spawnPoint(ctx, run) {
+        const placement = spec.spawning.placement;
+        if (placement.kind === "custom")
+            return placement.position(ctx, run.view);
+        const angle = run.rng() * Math.PI * 2;
+        const x = Math.cos(angle) * placement.radius;
+        const z = Math.sin(angle) * placement.radius;
+        return [x, ctx.world.groundHeightAt(x, z), z];
+    }
+    function advanceSpawning(ctx, run, dt) {
+        const alive = ctx.scene.entity.list().filter((entity) => spec.enemies[entity.name] !== undefined).length;
+        const step = advanceSpawnDirector(spec.spawning.director, run.spawn, dt, { alive, players: 1 });
+        run.spawn = step.state;
+        for (const request of step.spawns) {
+            if (spec.enemies[request.entryId] === undefined)
+                continue;
+            ctx.scene.entity.spawn(request.entryId, { position: spawnPoint(ctx, run) });
+        }
+    }
+    function advanceEnemies(ctx, run, dt) {
+        const playerId = ctx.player.userId;
+        const player = ctx.scene.entity.get(playerId);
+        if (player === null)
+            return;
+        const now = ctx.time.now();
+        for (const enemy of ctx.scene.entity.list()) {
+            const def = spec.enemies[enemy.name];
+            if (def === undefined)
+                continue;
+            const next = def.behavior === "none" ? null : ctx.scene.entity.moveToward(enemy.id, playerId, { speed: def.walkSpeed, dt });
+            if (next !== null) {
+                const grounded = [
+                    next[0],
+                    ctx.world.groundHeightAt(next[0], next[2]),
+                    next[2],
+                ];
+                ctx.scene.entity.setPose(enemy.id, {
+                    position: grounded,
+                    rotationY: facing(enemy.position[0], enemy.position[2], player.position[0], player.position[2]),
+                });
+            }
+            const distance = ctx.scene.entity.distance(enemy.id, playerId);
+            if (distance === null || distance > spec.combat.contactRadius)
+                continue;
+            const readyAt = run.enemyNextHitAt.get(enemy.id) ?? 0;
+            if (now < readyAt)
+                continue;
+            run.enemyNextHitAt.set(enemy.id, now + def.contact.intervalSeconds);
+            ctx.scene.entity.effect({ from: enemy.id, to: playerId, effect: HIT_EFFECT, via: { amount: def.contact.damage } });
+        }
+    }
+    function enemyIds(ctx) {
+        return ctx.scene.entity
+            .list()
+            .filter((entity) => spec.enemies[entity.name] !== undefined)
+            .map((entity) => entity.id);
+    }
+    function fireProjectile(ctx, run, weaponId, weapon, playerId, playerPos, enemies) {
+        const targetId = selectAutoTarget("nearest", playerId, {
+            candidates: () => enemies,
+            distance: (from, to) => ctx.scene.entity.distance(from, to),
+        });
+        if (targetId === null)
+            return;
+        const target = ctx.scene.entity.get(targetId);
+        if (target === null)
+            return;
+        const dx = target.position[0] - playerPos[0];
+        const dz = target.position[2] - playerPos[2];
+        const distance = Math.hypot(dx, dz);
+        if (distance > weapon.range)
+            return;
+        run.kit.cast(weaponId);
+        const level = run.weaponLevels[weaponId] ?? 1;
+        const damage = leveled(weapon.damage, level) * damageMultiplier(run);
+        const aim = aimToPoint(playerPos, target.position);
+        const shotId = ctx.scene.entity.fireProjectile({ from: playerId, via: { amount: damage }, aim, effect: HIT_EFFECT });
+        const travelSeconds = Math.min(1.1, Math.max(0.08, distance / weapon.speed));
+        run.fxCounter += 1;
+        run.bolts.push({
+            id: run.fxCounter,
+            weaponId,
+            origin: playerPos,
+            target: target.position,
+            firedAt: ctx.time.now(),
+            travelSeconds,
+        });
+        ctx.time.after(travelSeconds, () => {
+            ctx.scene.entity.settleProjectile(shotId);
+        });
+    }
+    function fireOrbit(ctx, run, weaponId, weapon, playerId, playerPos, enemies) {
+        run.kit.cast(weaponId);
+        const level = run.weaponLevels[weaponId] ?? 1;
+        const damage = leveled(weapon.damage, level) * damageMultiplier(run);
+        const blades = leveled(weapon.blades, level);
+        const radius = leveled(weapon.radius, level);
+        const angle = ctx.time.now() * weapon.angularSpeed;
+        const alreadyHit = new Set();
+        for (let blade = 0; blade < blades; blade += 1) {
+            const theta = angle + (blade * Math.PI * 2) / blades;
+            const bladePos = [
+                playerPos[0] + Math.cos(theta) * radius,
+                playerPos[1],
+                playerPos[2] + Math.sin(theta) * radius,
+            ];
+            for (const instanceId of ctx.scene.entity.inRadius(bladePos, weapon.hitRadius, (id) => enemies.includes(id))) {
+                if (alreadyHit.has(instanceId))
+                    continue;
+                alreadyHit.add(instanceId);
+                ctx.scene.entity.effect({ from: playerId, to: instanceId, effect: HIT_EFFECT, via: { amount: damage } });
+            }
+        }
+    }
+    function firePulse(ctx, run, weaponId, weapon, playerId, playerPos) {
+        run.kit.cast(weaponId);
+        const level = run.weaponLevels[weaponId] ?? 1;
+        const damage = leveled(weapon.damage, level) * damageMultiplier(run);
+        const radius = leveled(weapon.radius, level);
+        ctx.scene.entity.effect({ from: playerId, effect: HIT_EFFECT, via: { amount: damage }, at: playerPos, radius, falloff: "linear" });
+        run.fxCounter += 1;
+        run.pulses.push({
+            id: run.fxCounter,
+            weaponId,
+            at: playerPos,
+            firedAt: ctx.time.now(),
+            durationSeconds: weapon.durationSeconds,
+            maxRadius: radius,
+        });
+    }
+    function fireWeapons(ctx, run, dt) {
+        run.kit.tick(dt);
+        const playerId = ctx.player.userId;
+        const player = ctx.scene.entity.get(playerId);
+        if (player === null)
+            return;
+        const enemies = enemyIds(ctx);
+        for (const [weaponId, weapon] of Object.entries(spec.weapons)) {
+            const state = run.kit.state(weaponId);
+            if (state === null || !state.ready)
+                continue;
+            if (weapon.kind === "projectile") {
+                fireProjectile(ctx, run, weaponId, weapon, playerId, player.position, enemies);
+            }
+            else if (weapon.kind === "orbit") {
+                fireOrbit(ctx, run, weaponId, weapon, playerId, player.position, enemies);
+            }
+            else if (weapon.kind === "pulse") {
+                firePulse(ctx, run, weaponId, weapon, playerId, player.position);
+            }
+            else {
+                run.kit.cast(weaponId);
+                const level = run.weaponLevels[weaponId] ?? 1;
+                weapon.fire(ctx, run.view, {
+                    weaponId,
+                    level,
+                    damage: leveled(weapon.damage, level) * damageMultiplier(run),
+                    playerId,
+                    playerPosition: player.position,
+                    enemyIds: enemies,
+                    dt,
+                });
+            }
+        }
+    }
+    function maybeOpenDraft(ctx, run) {
+        if (run.pendingOffers !== null || run.levelUpQueue <= 0 || run.phase !== "playing")
+            return;
+        run.levelUpQueue -= 1;
+        run.pendingOffers = run.draft.present(spec.progression.draft.choices);
+        ctx.time.pause();
+        notify(run);
+    }
+    function onLevelUp(ctx, run, level) {
+        ctx.game.events.emit("stat.levelUp", { userId: ctx.player.userId, stat: "level", level });
+        run.levelUpQueue += 1;
+        maybeOpenDraft(ctx, run);
+    }
+    function advancePickups(ctx, run, dt) {
+        const playerId = ctx.player.userId;
+        if (ctx.scene.entity.get(playerId) === null)
+            return;
+        const magnetRadius = run.fields["magnetRadius"] ?? 0;
+        for (const record of ctx.scene.worldItem.list()) {
+            if (record.baseType !== XP_GEM_BASE_TYPE)
+                continue;
+            const distance = ctx.scene.entity.distance(record.instanceId, playerId);
+            if (distance === null)
+                continue;
+            if (distance <= spec.xpGems.collectRadius) {
+                ctx.scene.worldItem.consume(record.instanceId);
+                track.grantXp({
+                    get: (userId, statId) => ctx.scene.entity.stats.get(userId, statId),
+                    set: (userId, statId, patch) => ctx.scene.entity.stats.set(userId, statId, patch),
+                }, playerId, record.count, (level) => onLevelUp(ctx, run, level));
+                continue;
+            }
+            if (distance > magnetRadius)
+                continue;
+            const next = ctx.scene.entity.moveToward(record.instanceId, playerId, { speed: spec.xpGems.pullSpeed, dt });
+            if (next !== null) {
+                const grounded = [
+                    next[0],
+                    ctx.world.groundHeightAt(next[0], next[2]),
+                    next[2],
+                ];
+                ctx.scene.entity.setPose(record.instanceId, { position: grounded });
+            }
+        }
+    }
+    function pruneFx(ctx, run) {
+        const now = ctx.time.now();
+        run.bolts = run.bolts.filter((bolt) => now - bolt.firedAt <= bolt.travelSeconds + 0.15);
+        run.pulses = run.pulses.filter((pulse) => now - pulse.firedAt <= pulse.durationSeconds + 0.05);
+    }
+    function applyUpgrade(ctx, run, offerId) {
+        const upgrade = spec.progression.draft.upgrades.find((entry) => entry.id === offerId);
+        if (upgrade === undefined)
+            return;
+        const stacks = run.draft.stack().count(offerId);
+        const effect = upgrade.effect;
+        switch (effect.kind) {
+            case "weaponLevel": {
+                run.weaponLevels[effect.weapon] = 1 + stacks;
+                run.kit = buildKit(spec, run.weaponLevels);
+                return;
+            }
+            case "statBonus": {
+                const current = ctx.scene.entity.stats.get(ctx.player.userId, effect.stat);
+                const max = (current?.max ?? 0) + effect.amount;
+                const value = (current?.current ?? 0) + effect.amount;
+                ctx.scene.entity.stats.set(ctx.player.userId, effect.stat, { max, current: value });
+                return;
+            }
+            case "fieldAdd": {
+                const base = spec.fields?.[effect.field] ?? 0;
+                run.fields[effect.field] = base + effect.amount * stacks;
+                return;
+            }
+            case "fieldMultiply": {
+                const base = spec.fields?.[effect.field] ?? 1;
+                run.fields[effect.field] = base * effect.factor ** stacks;
+                return;
+            }
+            case "custom": {
+                effect.apply(ctx, run.view, stacks);
+                return;
+            }
+        }
+    }
+    function chooseUpgrade(ctx, offerId) {
+        const run = getRun(ctx);
+        if (run.pendingOffers === null)
+            return;
+        if (!run.draft.choose(offerId))
+            return;
+        applyUpgrade(ctx, run, offerId);
+        run.pendingOffers = null;
+        ctx.time.play();
+        notify(run);
+        maybeOpenDraft(ctx, run);
+    }
+    function registerEvents(ctx) {
+        const run = getRun(ctx);
+        syncPhase(ctx, run);
+        if (spec.rules.killLeaderboardStat !== undefined) {
+            ctx.game.leaderboard?.track({ stat: spec.rules.killLeaderboardStat, scope: "profile" });
+        }
+        run.disposeEvents?.();
+        run.disposeEvents = ctx.game.events.on("entity.died", (event) => {
+            if (event.instanceId === ctx.player.userId) {
+                if (spec.rules.lose?.kind === "playerDeath" && run.phase === "playing") {
+                    run.phase = "lost";
+                    syncPhase(ctx, run);
+                    notify(run);
+                }
+                return;
+            }
+            if (event.reason.kind !== "player_kill")
+                return;
+            const def = spec.enemies[event.catalogId];
+            if (def === undefined)
+                return;
+            run.kills += 1;
+            if (spec.rules.killLeaderboardStat !== undefined) {
+                ctx.game.leaderboard?.increment(ctx.player.userId, spec.rules.killLeaderboardStat, { scope: "profile" });
+            }
+            ctx.scene.worldItem.spawn({
+                itemId: XP_GEM_BASE_TYPE,
+                baseType: XP_GEM_BASE_TYPE,
+                position: event.position,
+                count: def.xp,
+                rarity: gemRarity(spec, def.xp),
+            });
+        });
+    }
+    function checkOutcome(ctx, run) {
+        const win = spec.rules.win;
+        if (win !== undefined) {
+            const won = win.kind === "survive" ? run.playingSeconds >= win.seconds : win.check(ctx, run.view);
+            if (won) {
+                run.phase = "won";
+                syncPhase(ctx, run);
+                notify(run);
+                return;
+            }
+        }
+        const lose = spec.rules.lose;
+        if (lose?.kind === "custom" && lose.check(ctx, run.view)) {
+            run.phase = "lost";
+            syncPhase(ctx, run);
+            notify(run);
+        }
+    }
+    function begin(ctx) {
+        const run = getRun(ctx);
+        if (run.phase !== "start")
+            return;
+        run.phase = run.countdownRemaining > 0 ? "countdown" : "playing";
+        syncPhase(ctx, run);
+        notify(run);
+    }
+    function despawnCartridgeEntities(ctx) {
+        for (const entity of ctx.scene.entity.list()) {
+            if (spec.enemies[entity.name] !== undefined)
+                ctx.scene.entity.despawn(entity.id);
+        }
+        for (const record of ctx.scene.worldItem.list()) {
+            if (record.baseType === XP_GEM_BASE_TYPE)
+                ctx.scene.entity.despawn(record.instanceId);
+        }
+    }
+    function reset(ctx) {
+        const run = getRun(ctx);
+        Object.assign(run, seededState());
+        despawnCartridgeEntities(ctx);
+        if (ctx.scene.entity.get(ctx.player.userId) === null) {
+            ctx.scene.entity.spawn(spec.player.kind, {
+                id: ctx.player.userId,
+                position: spec.player.spawnAt ?? [0, 0, 0],
+            });
+        }
+        ctx.scene.entity.stats.set(ctx.player.userId, "health", { max: spec.player.health, current: spec.player.health });
+        ctx.scene.entity.stats.set(ctx.player.userId, "xp", { max: track.xpForLevel(1), current: 0 });
+        ctx.scene.entity.stats.set(ctx.player.userId, "level", { current: 1 });
+        ctx.scene.entity.setPose(ctx.player.userId, { position: spec.player.spawnAt ?? [0, 0, 0] });
+        ctx.time.play();
+        syncPhase(ctx, run);
+        notify(run);
+    }
+    function tick(ctx, dt) {
+        const run = getRun(ctx);
+        if (dt <= 0 || run.pendingOffers !== null)
+            return;
+        if (run.phase === "countdown") {
+            run.countdownRemaining -= dt;
+            if (run.countdownRemaining <= 0) {
+                run.countdownRemaining = 0;
+                run.phase = "playing";
+                syncPhase(ctx, run);
+            }
+            notify(run);
+            return;
+        }
+        if (run.phase !== "playing")
+            return;
+        run.playingSeconds += dt;
+        advanceSpawning(ctx, run, dt);
+        advanceEnemies(ctx, run, dt);
+        fireWeapons(ctx, run, dt);
+        advancePickups(ctx, run, dt);
+        pruneFx(ctx, run);
+        for (const system of spec.systems ?? [])
+            system(ctx, run.view, dt);
+        checkOutcome(ctx, run);
+    }
+    const loop = {
+        onInit(ctx) {
+            registerEvents(ctx);
+            if (spec.flow?.restart === true && !ctx.game.commands.has("restart")) {
+                ctx.game.commands.define("restart", {
+                    apply(state) {
+                        reset(ctx);
+                        return state;
+                    },
+                });
+            }
+        },
+        onNewPlayer(ctx) {
+            ctx.scene.entity.spawn(spec.player.kind, {
+                id: ctx.player.userId,
+                position: spec.player.spawnAt ?? [0, 0, 0],
+            });
+            ctx.scene.entity.stats.set(ctx.player.userId, "xp", { max: track.xpForLevel(1), current: 0 });
+            ctx.scene.entity.stats.set(ctx.player.userId, "level", { current: 1 });
+        },
+        onTick(ctx, dt) {
+            tick(ctx, dt);
+        },
+    };
+    return {
+        content: { entityById: (id) => entities[id] ?? null },
+        loop,
+        run: (ctx) => getRun(ctx).view,
+        weaponKit: (ctx) => getRun(ctx).kit,
+        chooseUpgrade,
+        begin,
+        reset,
+        spec,
+    };
+}