@maka/maka-cli 5.390.0 → 5.392.0

package/bundle/typescript/src/commands/game/sideQuest/utilities/wards.js

@@ -0,0 +1,116 @@
+import { rollPool, formatRoll } from './dice.js';
+import { astralLimit } from './limits.js';
+import { pierces } from './barrier-geometry.js';
+/** Does this room's ward stop this form? Not its creator, and not the
+ *  form holding a pass it just pressed for. */
+export function wardHolds(room, actor) {
+    if (!room?.warded)
+        return false;
+    if (room.wardCreator !== undefined && room.wardCreator === actor.name)
+        return false;
+    return actor.wardPass !== room.name;
+}
+/** The ward an astral form crosses going from one room to another --
+ *  entering `to`'s, or leaving `from`'s -- or undefined. */
+export function wardBetween(from, to, actor) {
+    if (from === to)
+        return undefined;
+    if (wardHolds(to, actor))
+        return to;
+    if (wardHolds(from, actor))
+        return from;
+    return undefined;
+}
+/**
+ * PRESS THROUGH (p.316): Magic + Charisma [Astral] v. Force x 2. Any net
+ * hits and the form is through -- it holds a pass for THIS ward until
+ * the crossing is made. A breach is something the creator knows (p.357).
+ */
+export function pressThroughWard(scene, logger, actor, ward) {
+    const press = rollPool(actor.magic + actor.charisma, astralLimit(actor));
+    const hold = rollPool(ward.wardForce * 2);
+    const meta = `Press through the ward (p.316): Magic + Charisma ${formatRoll(press)} v. Force ${ward.wardForce} x 2 ${formatRoll(hold)}`;
+    if (press.hits - hold.hits <= 0) {
+        actor.performAction('is stopped by a ward', ward.name);
+        return { through: false, meta };
+    }
+    actor.wardPass = ward.name;
+    actor.performAction('presses through a ward', ward.name);
+    alertWard(scene, logger, ward, actor, 'breached');
+    return { through: true, meta };
+}
+/** Spend the pass once the crossing it bought is made. */
+export function spendWardPass(actor) {
+    actor.wardPass = undefined;
+}
+/**
+ * THE CREATOR KNOWS (p.316, p.357): "will know when it has been
+ * breached, attacked, or destroyed and will inform whoever is to be
+ * contacted in the protected organization". The site goes on alert the
+ * way a tripped device puts it there; a creator on site hears it.
+ */
+export function alertWard(scene, logger, ward, actor, how) {
+    scene.raiseAlarm(`the ward over ${ward.name} was ${how}`);
+    scene.addWorldEvent(`The ward over ${ward.name} was ${how} -- whoever raised it knows.`);
+    const creator = ward.wardCreator ? scene.getPlayers().find(p => p.name === ward.wardCreator) : undefined;
+    if (creator && creator !== actor) {
+        logger?.log(`Your ward over ${ward.name} has been ${how}${how === 'attacked' ? ` (${ward.wardDamage}/${ward.wardForce})` : ''} (p.316).`, { actor: creator.name });
+    }
+}
+/**
+ * HITTING A WARD from the astral (p.316, "Getting Around Mana Barriers"):
+ * the same unopposed shape as a mana barrier spell -- the attack's hits
+ * add to the DV, a DV that does not exceed Armor does nothing (p.197),
+ * the rest is resisted with Structure + Armor, both equal to the Force.
+ * Structure filled is a ward torn down, for the rest of the run.
+ */
+export function resolveWardStrike(scene, logger, attacker, ward) {
+    const world = [];
+    const meta = [];
+    const force = ward.wardForce;
+    const profile = attacker.getWeaponProfile();
+    const roll = rollPool(attacker.getAttackPool(), attacker.getAttackLimit(null));
+    meta.push(`Attack on the ward over ${ward.name} (unopposed, p.197): ${formatRoll(roll)}`);
+    attacker.sneaking = false;
+    if (roll.criticalGlitch) {
+        world.push(`${attacker.name} goes for the ward over ${ward.name} -- and it goes catastrophically wrong.`);
+        return { world, meta, destroyed: false };
+    }
+    const dv = profile.damage + roll.hits;
+    const ap = profile.armorPen ?? 0;
+    meta.push(`  DV ${profile.damage} + ${roll.hits} = ${dv} v. Armor ${force} (Force, p.316)`);
+    if (!pierces(dv, force, ap)) {
+        world.push(`${attacker.name} strikes the ward over ${ward.name} -- the lattice drinks it. Too weak to mark it (DV ${dv} against Armor ${force}, p.197).`);
+        alertWard(scene, logger, ward, attacker, 'attacked');
+        return { world, meta, destroyed: false };
+    }
+    const armor = Math.max(0, force + ap);
+    const soak = rollPool(force + armor);
+    const dealt = Math.max(0, dv - soak.hits);
+    meta.push(`  Resist: Structure ${force} + Armor ${armor}: ${formatRoll(soak)} -- ${dealt} box${dealt === 1 ? '' : 'es'} through`);
+    ward.wardDamage += dealt;
+    logger.write(`${attacker.name} dealt ${dealt} boxes to the ward over ${ward.name} (${ward.wardDamage}/${force}).`);
+    if (ward.wardDamage < force) {
+        world.push(`${attacker.name} strikes the ward over ${ward.name} -- ${dealt > 0 ? `${dealt} box${dealt === 1 ? '' : 'es'}` : 'it holds, unmarked'}. (${ward.wardDamage}/${force})`);
+        alertWard(scene, logger, ward, attacker, 'attacked');
+        return { world, meta, destroyed: false };
+    }
+    ward.warded = false;
+    ward.wardDamage = 0;
+    world.push(`${attacker.name} tears the ward over ${ward.name} apart -- the lattice frays to nothing, and the astral there is open ground.`);
+    alertWard(scene, logger, ward, attacker, 'destroyed');
+    scene.addWorldEvent(`${attacker.name} brought down the ward over ${ward.name}.`);
+    return { world, meta, destroyed: true };
+}
+/** End of a Combat Turn: every standing ward is whole again (p.316). */
+export function mendWards(rooms) {
+    const mended = [];
+    for (const r of rooms) {
+        if (!r.warded || r.wardDamage <= 0)
+            continue;
+        r.wardDamage = 0;
+        mended.push(r);
+    }
+    return mended;
+}
+//# sourceMappingURL=wards.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/maka-cli",
-  "version": "5.390.0",
+  "version": "5.392.0",
   "type": "module",
   "summary": "A command line tool for scaffolding Meteor 3.x applications using either React.",
   "description": "A command line tool for scaffolding Meteor 3.x applications using React.",