⚓ MUD Engine

import { World, Room, Actor } from '@mud-engine/core';

const world = new World({ ticksPerSecond: 4 });

world.addRoom(new Room({
  id: 'start', name: 'The Crossroads',
  description: 'Dirt paths lead in all directions.',
  exits: [{ direction: 'north', targetRoomId: 'town' }],
}));

world.addActor(new Actor({
  id: 'hero', name: 'Hero', roomId: 'start',
  stats: { hp: 100, maxHp: 100, mana: 50, maxMana: 50, mv: 100, maxMv: 100,
           str: 15, dex: 12, int: 14, con: 13 },
}));

world.emitter.on('*', (e) => console.log(`[${e.type}]`, e.data));
world.moveActorDirection('hero', 'north');
// → [room.leave] { actorId: 'hero', roomId: 'start' }
// → [room.enter] { actorId: 'hero', fromRoomId: 'start', roomId: 'town' }

import { World, Room, Actor, Item, EventTypes } from '@mud-engine/core';

const world = new World({ ticksPerSecond: 4 });

// Capture events
world.emitter.on(EventTypes.ACTOR_ATTACK, (e) => {
  console.log(`${e.data.attackerId} → ${e.data.targetId} for ${e.data.damage}`);
});

// Build a 3-room dungeon
world.addRoom(new Room({
  id: 'tavern', name: 'The Rusty Anchor',
  description: 'Ale and salt air.',
  exits: [{ direction: 'east', targetRoomId: 'kitchen' }],
}));
world.addRoom(new Room({
  id: 'kitchen', name: 'The Kitchen',
  exits: [{ direction: 'west', targetRoomId: 'tavern' },
          { direction: 'down', targetRoomId: 'cellar' }],
}));
world.addRoom(new Room({
  id: 'cellar', name: 'The Dark Cellar',
  exits: [{ direction: 'up', targetRoomId: 'kitchen' }],
  flags: ['dark'],
}));

// Spawn hero and enemies
const hero = new Actor({
  id: 'hero', name: 'Eileen', roomId: 'tavern',
  stats: { hp: 120, maxHp: 120, mana: 80, maxMana: 80,
           mv: 100, maxMv: 100, str: 14, dex: 12, int: 16, con: 13 },
});
world.addActor(hero);

// Move, fight, pick up items
world.moveActorDirection('hero', 'east');   // tavern → kitchen
const dmg = world.attack('trap', 'hero', 35);
hero.heal(20);

// Serialize / deserialize
const json = world.toJSON();
const restored = World.fromJSON(json);

import { TriggerEngine, TriggerCompiler } from '@mud-engine/triggers';

const compiler = new TriggerCompiler();
const engine = new TriggerEngine();

// Define a combat strategy
const combatSet = compiler.compileStrategy({
  name: 'combat',
  description: 'Aggressive combat',
  triggers: [
    { pattern: 'A (\\w+) is here\\.', command: 'attack $1', priority: 10 },
    { pattern: '(\\w+) hits you for (\\d+) damage',
      command: "cast 'fireball' at $1", priority: 8, cooldownTicks: 3 },
  ],
});

const fleeSet = compiler.compileStrategy({
  name: 'alert',
  description: 'Survival',
  triggers: [
    { pattern: '<(\\d+)hp (\\d+)m (\\d+)mv>', command: 'flee',
      conditions: [{ variable: 'hp', operator: '<', value: 20 }], priority: 20 },
  ],
});

engine.loadTriggers(combatSet);
engine.hotSwap(fleeSet);

// Feed game text — triggers fire automatically
engine.processLine('<120hp 80m 100mv>');
// State updated: hp=120, mana=80, mv=100

engine.processLine('A goblin is here.');
// → attack goblin

engine.processLine('The goblin hits you for 25 damage');
// → cast 'fireball' at goblin
// Same trigger again → blocked by 3-tick cooldown

// Variable interpolation
engine.setState('target', 'dragon');
engine.processLine('You see Gandalf holding Glamdring.');
// → examine Gandalf | Glamdring | target=dragon | gold=500

import { World, Room, Actor } from '@mud-engine/core';
import { TriggerCompiler } from '@mud-engine/triggers';
import { AgentClient } from '@mud-engine/agent-runtime';

const world = new World({ ticksPerSecond: 4 });
world.addRoom(new Room({ id: 'arena', name: 'Arena', description: 'A fighting pit.',
  exits: [{ direction: 'north', targetRoomId: 'safe' }] }));
world.addRoom(new Room({ id: 'safe', name: 'Safe Room', description: 'Rest here.',
  exits: [{ direction: 'south', targetRoomId: 'arena' }], flags: ['safe'] }));

// NPCs
world.addActor(new Actor({ id: 'goblin', name: 'a goblin', roomId: 'arena', isNpc: true,
  stats: { hp: 60, maxHp: 60, mana: 0, maxMana: 0, mv: 50, maxMv: 50, str: 10, dex: 14, int: 5, con: 10 } }));

// Hero
world.addActor(new Actor({ id: 'hero', name: 'Hero', roomId: 'arena',
  stats: { hp: 100, maxHp: 100, mana: 100, maxMana: 100, mv: 100, maxMv: 100, str: 15, dex: 12, int: 14, con: 13 } }));

// Agent with combat strategy
const compiler = new TriggerCompiler();
const agent = new AgentClient({
  actorId: 'hero', world,
  initialStrategy: {
    name: 'aggressive_v1', version: '1.0.0', description: 'Attack on sight',
    triggerSet: compiler.compileStrategy({
      name: 'aggressive_v1', description: 'Attack',
      triggers: [{ pattern: 'is here\\.', command: 'attack goblin', priority: 8 }],
    }),
  },
});

agent.start();

// Run simulation
for (let i = 1; i <= 20; i++) {
  world.tickManager.doTick();
  if (i % 3 === 0 && goblin.isAlive) world.attack('goblin', 'hero', 5 + Math.floor(Math.random() * 10));
  if (i % 2 === 0 && goblin.isAlive) world.attack('hero', 'goblin', 8 + Math.floor(Math.random() * 15));
}

// Check telemetry
const telemetry = agent.exportTelemetry();
console.log(`Win rate: ${(telemetry.aggregate.winRate * 100).toFixed(1)}%`);

// Hot-swap strategy mid-combat
agent.getAdaptation().receiveStrategyUpdate(
  compiler.compileStrategy({ name: 'defensive_v2', description: 'Defense',
    triggers: [{ pattern: 'is here\\.', command: 'attack hobgoblin', priority: 5 }] }),
  'defensive_v2',
);

agent.stop();

import { StrategyGuild, AbstractionEngine } from '@mud-engine/strategy-guild';
import { TelemetryCollector } from '@mud-engine/agent-runtime';

// Create guild in heuristic mode (no LLM needed)
const guild = new StrategyGuild({ minEncounters: 1, enableCulturalTransmission: true });

guild.onGossip('ooc', (msg) => console.log(`[OOC] ${msg.message}`));
guild.onStrategyUpdate((actorId, set, name) =>
  console.log(`[UPDATE] ${actorId} → ${name}`));

// Build telemetry from a losing agent (0% win rate, low damage)
const tc = new TelemetryCollector();
for (let i = 0; i < 3; i++) {
  tc.startEncounter(`enc_${i}`, 'wizard', i * 10);
  tc.recordDamageDealt(15);
  tc.recordDamageTaken(65);
  tc.recordAction(); tc.recordAction();
  tc.endEncounter('loss', { hp: 0, maxHp: 100, mana: 10, maxMana: 100 }, i * 10 + 8);
}
guild.addRawLogs('wizard', ['You hit the goblin for 12 damage.', 'You have died.']);

// Process — the guild will identify burst_deficiency and generate new triggers
const result = await guild.processTelemetry(tc.buildPacket('wizard', 'aggressive_v1'));

console.log(result.pattern.archetype);        // → burst_deficiency
console.log(result.pattern.conceptualFlaw);   // → Insufficient damage output...
console.log(result.abstraction.newParadigm);  // → Shift to burst windows...
console.log(result.triggerSet.triggers.length);// → 3 new triggers

import { World, Room, Actor } from '@mud-engine/core';
import { DungeonMaster } from '@mud-engine/dm-rotation';

const world = new World({ ticksPerSecond: 4 });
world.addRoom(new Room({ id: 'town', name: 'Town Square', description: 'Hub.',
  exits: [{ direction: 'north', targetRoomId: 'dungeon' }] }));
world.addRoom(new Room({ id: 'dungeon', name: 'Dungeon', description: 'Dark.',
  exits: [{ direction: 'south', targetRoomId: 'town' }] }));

// Register agents
world.addActor(new Actor({ id: 'xenon', name: 'Xenon', roomId: 'town',
  stats: { hp: 100, maxHp: 100, mana: 200, maxMana: 200, mv: 100, maxMv: 100, str: 8, dex: 14, int: 18, con: 10 } }));

// Create DM
const dm = new DungeonMaster({ world, actorId: 'xenon', rotationTicks: 10 });
dm.registerAgent('xenon');
dm.registerAgent('lyra');
dm.registerAgent('balthazar');

// Register player strategies for adversarial analysis
dm.registerPlayerHistory({
  actorId: 'balthazar', strategyName: 'aggressive_melee', archetype: 'overcommit',
  winRate: 0.75, lossRate: 0.25, avgDamageDealt: 90, avgDamageTaken: 70,
  preferredTactics: ['reckless_strike', 'power_attack', 'whirlwind'],
  weaknesses: ['overcommit', 'positional_error'],
  recentEncounters: [/* ... */],
});

// Activate DM
dm.assumeRole();
dm.startRotation();

// DM designs counter-content targeting Balthazar's overcommit weakness
const counter = await dm.designCounterContent('balthazar');
// → counter.counterStrategy: "Damage reflection enemies — punish aggressive overcommit"
// → counter.suggestedZoneType: "slime"
// → counter.enemyModifiers: ["damage_reflection", "thorned_armor"]

// Generate and inject a 6-room counter-zone
const zone = await dm.generateZone('overcommit', 7);
dm.injectZone(zone);

// DM crown rotates after rotationTicks
for (let i = 0; i < 12; i++) dm.tick();
// → xenon passes crown to lyra with insights

import { createBus } from '@mud-engine/event-bus';

// In-process bus (zero latency, dev mode)
const bus = createBus({ transport: 'in-process' });
await bus.connect();

// Wildcard subscription
bus.subscribe('mud.game.*.combat', (event) => {
  console.log('Combat!', event.data);
});

// Queue group — only one member receives each event
bus.queue('strategy-guild', 'mud.agent.*.telemetry', (event) => {
  processTelemetry(event.data);
});

// Publish
await bus.publish('mud.game.bar-rail.combat', {
  source: 'hero', target: 'goblin', damage: 25,
});

// Replay from position
bus.subscribe('mud.agent.flash.*', handler, { replayFrom: 100 });

import { ImmortalInterface } from '@mud-engine/immortal-interface';

// Mount in browser
const ui = new ImmortalInterface({
  wsUrl: 'ws://localhost:8080',
  apiUrl: '/api',
  container: '#god-console',
});

// Feed events programmatically (or via WebSocket)
ui.emit({
  type: 'combat', agentId: 'xenon', timestamp: Date.now(),
  data: { damage: 45, target: 'goblin' },
  raw: '[Xenon] hits Goblin for 45 damage',
});

// Inject a thought into agent context
await ui.nudge({
  targetAgent: 'xenon',
  text: 'A strange premonition tells you the dragon is immune to fire...',
  priority: 'high',
});

// Demo mode (no backend needed)
const demo = new ImmortalInterface({}); // auto-starts demo

import { World, Room, Actor } from '@mud-engine/core';
import { TriggerCompiler } from '@mud-engine/triggers';
import { AgentClient } from '@mud-engine/agent-runtime';
import { StrategyGuild } from '@mud-engine/strategy-guild';
import { DungeonMaster } from '@mud-engine/dm-rotation';
import { createBus } from '@mud-engine/event-bus';

// ── Setup ──────────────────────────────────────────────────────────

const world = new World({ ticksPerSecond: 4 });
const compiler = new TriggerCompiler();
const bus = createBus({ transport: 'in-process' });
await bus.connect();

// Build the world
world.addRoom(new Room({ id: 'town', name: 'Town', description: 'Hub.',
  exits: [{ direction: 'north', targetRoomId: 'dungeon' }] }));
world.addRoom(new Room({ id: 'dungeon', name: 'Dungeon', description: 'Dark.',
  exits: [{ direction: 'south', targetRoomId: 'town' }] }));

// ── Agents ─────────────────────────────────────────────────────────

const agents = ['xenon', 'lyra', 'balthazar'].map((id, i) => {
  const hero = new Actor({ id, name: id, roomId: 'town',
    stats: { hp: 100, maxHp: 100, mana: 100, maxMana: 100, mv: 100, maxMv: 100,
             str: 12+i*2, dex: 12, int: 16-i*2, con: 13 } });
  world.addActor(hero);

  const agent = new AgentClient({
    actorId: id, world,
    initialStrategy: {
      name: 'aggressive_v1', version: '1.0', description: 'Attack',
      triggerSet: compiler.compileStrategy({
        name: 'aggressive', description: 'Attack',
        triggers: [{ pattern: 'is here\\.', command: 'attack goblin', priority: 8 }],
      }),
    },
  });
  agent.start();
  return agent;
});

// ── Strategy Guild ─────────────────────────────────────────────────

const guild = new StrategyGuild({ enableCulturalTransmission: true });

// When guild produces a new strategy, hot-swap into the agent
guild.onStrategyUpdate((actorId, triggerSet, name) => {
  const agent = agents.find(a => a.actorId === actorId);
  if (agent) agent.getAdaptation().receiveStrategyUpdate(triggerSet, name);
});

// Agents export telemetry → guild analyzes
setInterval(() => {
  for (const agent of agents) {
    const packet = agent.exportTelemetry();
    if (packet.aggregate.totalEncounters > 0) {
      guild.processTelemetry(packet);
    }
  }
}, 5000);

// OOC gossip spreads between agents
guild.onGossip('ooc', (msg) => {
  bus.publish('mud.ooc.gossip', msg);
});

// ── DM Rotation ────────────────────────────────────────────────────

const dm = new DungeonMaster({ world, actorId: 'xenon', rotationTicks: 160 });
dm.registerAgent('xenon');
dm.registerAgent('lyra');
dm.registerAgent('balthazar');
dm.assumeRole();
dm.startRotation();

// DM crown rotation
world.tickManager.onTick(() => dm.tick());

dm.onHandoffInsights((insights) => {
  bus.publish('mud.dm.handoff', { insights });
});

// ── Event Bus Bridge ───────────────────────────────────────────────

world.emitter.on('*', (event) => {
  bus.publish(`mud.game.${event.type}`, event);
});

// ── Run ────────────────────────────────────────────────────────────

world.tickManager.start();
console.log('System running. Agents are alive.');