run-dmcp 0.1.0

package/dist/tools/timers.js

@@ -0,0 +1,215 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase, withTransaction } from "../db/connection.js";
+import { validateGameExists } from "./game.js";
+import { updateResourceValue } from "./resource.js";
+import { safeJsonParse } from "../utils/json.js";
+function parseConsequence(raw) {
+    if (typeof raw !== "string" || raw.length === 0)
+        return null;
+    return safeJsonParse(raw, null);
+}
+export function createTimer(params) {
+    // Validate game exists to prevent orphaned records
+    validateGameExists(params.gameId);
+    const db = getDatabase();
+    const id = uuidv4();
+    const now = new Date().toISOString();
+    const timerType = params.timerType;
+    const direction = params.direction || (timerType === "stopwatch" ? "up" : "down");
+    const maxValue = params.maxValue ?? (timerType === "clock" ? 6 : null);
+    const currentValue = params.currentValue ?? (direction === "down" && maxValue ? maxValue : 0);
+    const triggerAt = params.triggerAt ?? (direction === "down" ? 0 : maxValue);
+    const consequence = params.consequence ?? null;
+    db.prepare(`
+    INSERT INTO timers (id, game_id, name, description, timer_type, current_value, max_value, direction, trigger_at, unit, visible_to_players, created_at, consequence)
+    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+  `).run(id, params.gameId, params.name, params.description || "", timerType, currentValue, maxValue, direction, triggerAt, params.unit || "tick", params.visibleToPlayers !== false ? 1 : 0, now, consequence ? JSON.stringify(consequence) : null);
+    return {
+        id,
+        gameId: params.gameId,
+        name: params.name,
+        description: params.description || "",
+        timerType,
+        currentValue,
+        maxValue,
+        direction,
+        triggerAt,
+        triggered: false,
+        unit: params.unit || "tick",
+        visibleToPlayers: params.visibleToPlayers !== false,
+        createdAt: now,
+        consequence,
+    };
+}
+export function getTimer(id) {
+    const db = getDatabase();
+    const row = db.prepare(`SELECT * FROM timers WHERE id = ?`).get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        description: row.description || "",
+        timerType: row.timer_type,
+        currentValue: row.current_value,
+        maxValue: row.max_value,
+        direction: row.direction,
+        triggerAt: row.trigger_at,
+        triggered: row.triggered === 1,
+        unit: row.unit,
+        visibleToPlayers: row.visible_to_players === 1,
+        createdAt: row.created_at,
+        consequence: parseConsequence(row.consequence),
+    };
+}
+export function updateTimer(id, updates) {
+    const db = getDatabase();
+    const current = getTimer(id);
+    if (!current)
+        return null;
+    const newName = updates.name ?? current.name;
+    const newDescription = updates.description ?? current.description;
+    const newMaxValue = updates.maxValue !== undefined ? updates.maxValue : current.maxValue;
+    const newTriggerAt = updates.triggerAt !== undefined ? updates.triggerAt : current.triggerAt;
+    const newUnit = updates.unit ?? current.unit;
+    const newVisible = updates.visibleToPlayers !== undefined ? updates.visibleToPlayers : current.visibleToPlayers;
+    db.prepare(`
+    UPDATE timers
+    SET name = ?, description = ?, max_value = ?, trigger_at = ?, unit = ?, visible_to_players = ?
+    WHERE id = ?
+  `).run(newName, newDescription, newMaxValue, newTriggerAt, newUnit, newVisible ? 1 : 0, id);
+    return {
+        ...current,
+        name: newName,
+        description: newDescription,
+        maxValue: newMaxValue,
+        triggerAt: newTriggerAt,
+        unit: newUnit,
+        visibleToPlayers: newVisible,
+    };
+}
+export function deleteTimer(id) {
+    const db = getDatabase();
+    const result = db.prepare(`DELETE FROM timers WHERE id = ?`).run(id);
+    return result.changes > 0;
+}
+export function listTimers(gameId, includeTriggered = false) {
+    const db = getDatabase();
+    let query = `SELECT * FROM timers WHERE game_id = ?`;
+    if (!includeTriggered) {
+        query += ` AND triggered = 0`;
+    }
+    query += ` ORDER BY name`;
+    const rows = db.prepare(query).all(gameId);
+    return rows.map(row => ({
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        description: row.description || "",
+        timerType: row.timer_type,
+        currentValue: row.current_value,
+        maxValue: row.max_value,
+        direction: row.direction,
+        triggerAt: row.trigger_at,
+        triggered: row.triggered === 1,
+        unit: row.unit,
+        visibleToPlayers: row.visible_to_players === 1,
+        createdAt: row.created_at,
+        consequence: parseConsequence(row.consequence),
+    }));
+}
+export function tickTimer(id, amount = 1) {
+    const db = getDatabase();
+    const timer = getTimer(id);
+    if (!timer)
+        return null;
+    const previousValue = timer.currentValue;
+    let newValue;
+    if (timer.direction === "up") {
+        newValue = timer.currentValue + amount;
+        if (timer.maxValue !== null) {
+            newValue = Math.min(newValue, timer.maxValue);
+        }
+    }
+    else {
+        newValue = timer.currentValue - amount;
+        newValue = Math.max(newValue, 0);
+    }
+    // Check if triggered
+    let justTriggered = false;
+    if (!timer.triggered && timer.triggerAt !== null) {
+        if (timer.direction === "down" && newValue <= timer.triggerAt) {
+            justTriggered = true;
+        }
+        else if (timer.direction === "up" && newValue >= timer.triggerAt) {
+            justTriggered = true;
+        }
+    }
+    const newTriggeredFlag = justTriggered || timer.triggered;
+    const consequence = timer.consequence;
+    const consequenceApplied = justTriggered && consequence !== null;
+    // The tick itself (current_value + triggered flag) and the consequence
+    // application (when this tick is the one that crosses the trigger) land
+    // in a single transaction. If the consequence fails, NOTHING about this
+    // tick commits -- current_value and triggered stay exactly as they were,
+    // so the row is never left "expired-but-unapplied", and the next call to
+    // tickTimer() will recompute from the same starting point and retry.
+    if (consequenceApplied && consequence) {
+        withTransaction(() => {
+            db.prepare(`UPDATE timers SET current_value = ?, triggered = ? WHERE id = ?`)
+                .run(newValue, newTriggeredFlag ? 1 : 0, id);
+            const applied = updateResourceValue({
+                resourceId: consequence.resourceId,
+                mode: "delta",
+                value: consequence.delta,
+                reason: `Expiry consequence: ${timer.name}`,
+            });
+            if (!applied) {
+                throw new Error(`Resource '${consequence.resourceId}' not found for consequence of timer '${timer.name}' (${id})`);
+            }
+        });
+    }
+    else {
+        db.prepare(`UPDATE timers SET current_value = ?, triggered = ? WHERE id = ?`)
+            .run(newValue, newTriggeredFlag ? 1 : 0, id);
+    }
+    return {
+        timer: { ...timer, currentValue: newValue, triggered: newTriggeredFlag },
+        previousValue,
+        justTriggered,
+        consequenceApplied,
+    };
+}
+export function resetTimer(id) {
+    const db = getDatabase();
+    const timer = getTimer(id);
+    if (!timer)
+        return null;
+    const newValue = timer.direction === "down" && timer.maxValue !== null ? timer.maxValue : 0;
+    db.prepare(`UPDATE timers SET current_value = ?, triggered = 0 WHERE id = ?`)
+        .run(newValue, id);
+    return { ...timer, currentValue: newValue, triggered: false };
+}
+/**
+ * Modify a timer - tick or reset in a single call.
+ * Use mode: "tick" to advance by amount, mode: "reset" to reset to initial state.
+ */
+export function modifyTimerState(id, params) {
+    const timer = getTimer(id);
+    if (!timer)
+        return null;
+    if (params.mode === "reset") {
+        const resetResult = resetTimer(id);
+        if (!resetResult)
+            return null;
+        return {
+            timer: resetResult,
+            previousValue: timer.currentValue,
+            justTriggered: false,
+            consequenceApplied: false,
+        };
+    }
+    // Tick mode
+    return tickTimer(id, params.amount ?? 1);
+}

package/dist/tools/world.d.ts

@@ -0,0 +1,78 @@
+import type { Location, LocationProperties, Exit, ImageGeneration } from "../types/index.js";
+export declare function createLocation(params: {
+    gameId: string;
+    name: string;
+    description: string;
+    properties?: Partial<LocationProperties>;
+    imageGen?: ImageGeneration;
+}): Location;
+export declare function getLocation(id: string): Location | null;
+export declare function updateLocation(id: string, updates: {
+    name?: string;
+    description?: string;
+    properties?: Partial<LocationProperties>;
+    imageGen?: ImageGeneration | null;
+}): Location | null;
+export declare function listLocations(gameId: string): Location[];
+export declare function deleteLocation(id: string): boolean;
+export interface ConnectLocationsResult {
+    success: boolean;
+    fromLocation: {
+        id: string;
+        name: string;
+    };
+    toLocation: {
+        id: string;
+        name: string;
+    };
+    exitCreated: Exit;
+    reverseExitCreated: Exit | null;
+    bidirectional: boolean;
+}
+export declare function connectLocations(params: {
+    fromLocationId: string;
+    toLocationId: string;
+    fromDirection: string;
+    toDirection: string;
+    description?: string;
+    bidirectional?: boolean;
+}): ConnectLocationsResult | null;
+export declare function getExits(locationId: string): Exit[];
+/**
+ * Find a location by name (case-insensitive, fuzzy match).
+ * Returns the best match or null if no reasonable match found.
+ */
+export declare function getLocationByName(gameId: string, name: string): Location | null;
+interface MapNode {
+    id: string;
+    name: string;
+    x: number;
+    y: number;
+    exits: Array<{
+        direction: string;
+        toId: string;
+    }>;
+    isCenter: boolean;
+    hasPlayer: boolean;
+}
+interface MapData {
+    nodes: MapNode[];
+    connections: Array<{
+        from: string;
+        to: string;
+        direction: string;
+    }>;
+    bounds: {
+        minX: number;
+        maxX: number;
+        minY: number;
+        maxY: number;
+    };
+}
+export declare function renderMap(gameId: string, options?: {
+    centerId?: string;
+    radius?: number;
+    showPlayerLocation?: boolean;
+    playerLocationId?: string;
+}): MapData | null;
+export {};

package/dist/tools/world.js

@@ -0,0 +1,331 @@
+import { v4 as uuidv4 } from "uuid";
+import { getDatabase, withTransaction } from "../db/connection.js";
+import { safeJsonParse } from "../utils/json.js";
+import { gameEvents } from "../events/emitter.js";
+import { validateGameExists } from "./game.js";
+export function createLocation(params) {
+    // Validate game exists to prevent orphaned records
+    validateGameExists(params.gameId);
+    const db = getDatabase();
+    const id = uuidv4();
+    const properties = {
+        exits: [],
+        features: [],
+        atmosphere: "",
+        ...params.properties,
+    };
+    const stmt = db.prepare(`
+    INSERT INTO locations (id, game_id, name, description, properties, image_gen)
+    VALUES (?, ?, ?, ?, ?, ?)
+  `);
+    stmt.run(id, params.gameId, params.name, params.description, JSON.stringify(properties), params.imageGen ? JSON.stringify(params.imageGen) : null);
+    return {
+        id,
+        gameId: params.gameId,
+        name: params.name,
+        description: params.description,
+        properties,
+        imageGen: params.imageGen || null,
+    };
+}
+export function getLocation(id) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT * FROM locations WHERE id = ?`);
+    const row = stmt.get(id);
+    if (!row)
+        return null;
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        description: row.description,
+        properties: safeJsonParse(row.properties, { exits: [], features: [], atmosphere: "" }),
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+    };
+}
+export function updateLocation(id, updates) {
+    const db = getDatabase();
+    const current = getLocation(id);
+    if (!current)
+        return null;
+    const newName = updates.name ?? current.name;
+    const newDescription = updates.description ?? current.description;
+    const newProperties = updates.properties
+        ? { ...current.properties, ...updates.properties }
+        : current.properties;
+    const newImageGen = updates.imageGen !== undefined ? updates.imageGen : current.imageGen;
+    const stmt = db.prepare(`
+    UPDATE locations SET name = ?, description = ?, properties = ?, image_gen = ? WHERE id = ?
+  `);
+    stmt.run(newName, newDescription, JSON.stringify(newProperties), newImageGen ? JSON.stringify(newImageGen) : null, id);
+    const updated = {
+        ...current,
+        name: newName,
+        description: newDescription,
+        properties: newProperties,
+        imageGen: newImageGen,
+    };
+    // Emit realtime event
+    gameEvents.emit({
+        type: "location:updated",
+        gameId: current.gameId,
+        entityId: id,
+        entityType: "location",
+        timestamp: new Date().toISOString(),
+        data: { name: newName },
+    });
+    return updated;
+}
+export function listLocations(gameId) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT * FROM locations WHERE game_id = ?`);
+    const rows = stmt.all(gameId);
+    return rows.map((row) => ({
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        description: row.description,
+        properties: safeJsonParse(row.properties, { exits: [], features: [], atmosphere: "" }),
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+    }));
+}
+export function deleteLocation(id) {
+    const db = getDatabase();
+    const stmt = db.prepare(`DELETE FROM locations WHERE id = ?`);
+    const result = stmt.run(id);
+    return result.changes > 0;
+}
+export function connectLocations(params) {
+    const fromLocation = getLocation(params.fromLocationId);
+    const toLocation = getLocation(params.toLocationId);
+    if (!fromLocation || !toLocation)
+        return null;
+    // Add exit from first location to second
+    const exitFromTo = {
+        direction: params.fromDirection,
+        destinationId: params.toLocationId,
+        description: params.description,
+    };
+    fromLocation.properties.exits = fromLocation.properties.exits.filter((e) => e.direction !== params.fromDirection);
+    fromLocation.properties.exits.push(exitFromTo);
+    let reverseExitCreated = null;
+    const bidirectional = params.bidirectional !== false;
+    // Both updateLocation() calls below (the forward exit, and -- when
+    // bidirectional -- the reverse exit) must either both land or neither
+    // does. Otherwise a mid-operation failure leaves a one-way exit that the
+    // caller never asked for.
+    withTransaction(() => {
+        updateLocation(params.fromLocationId, {
+            properties: fromLocation.properties,
+        });
+        // If bidirectional, add reverse exit
+        if (bidirectional) {
+            const exitToFrom = {
+                direction: params.toDirection,
+                destinationId: params.fromLocationId,
+                description: params.description,
+            };
+            toLocation.properties.exits = toLocation.properties.exits.filter((e) => e.direction !== params.toDirection);
+            toLocation.properties.exits.push(exitToFrom);
+            updateLocation(params.toLocationId, {
+                properties: toLocation.properties,
+            });
+            reverseExitCreated = exitToFrom;
+        }
+    });
+    return {
+        success: true,
+        fromLocation: { id: fromLocation.id, name: fromLocation.name },
+        toLocation: { id: toLocation.id, name: toLocation.name },
+        exitCreated: exitFromTo,
+        reverseExitCreated,
+        bidirectional,
+    };
+}
+export function getExits(locationId) {
+    const location = getLocation(locationId);
+    if (!location)
+        return [];
+    return location.properties.exits;
+}
+/**
+ * Find a location by name (case-insensitive, fuzzy match).
+ * Returns the best match or null if no reasonable match found.
+ */
+export function getLocationByName(gameId, name) {
+    const db = getDatabase();
+    const searchName = name.toLowerCase().trim();
+    // First try exact match (case-insensitive)
+    const exactMatch = db.prepare(`SELECT * FROM locations WHERE game_id = ? AND LOWER(name) = ?`).get(gameId, searchName);
+    if (exactMatch) {
+        return mapRowToLocation(exactMatch);
+    }
+    // Try contains match
+    const containsMatch = db.prepare(`SELECT * FROM locations WHERE game_id = ? AND LOWER(name) LIKE ?`).get(gameId, `%${searchName}%`);
+    if (containsMatch) {
+        return mapRowToLocation(containsMatch);
+    }
+    // Try matching just the last word (e.g., "Square" matches "Village Square")
+    const words = searchName.split(/\s+/);
+    if (words.length > 0) {
+        const lastWord = words[words.length - 1];
+        const lastWordMatch = db.prepare(`SELECT * FROM locations WHERE game_id = ? AND LOWER(name) LIKE ?`).get(gameId, `%${lastWord}%`);
+        if (lastWordMatch) {
+            return mapRowToLocation(lastWordMatch);
+        }
+    }
+    return null;
+}
+// Helper function to map database row to Location
+function mapRowToLocation(row) {
+    return {
+        id: row.id,
+        gameId: row.game_id,
+        name: row.name,
+        description: row.description,
+        properties: safeJsonParse(row.properties, { exits: [], features: [], atmosphere: "" }),
+        imageGen: row.image_gen ? safeJsonParse(row.image_gen, null) : null,
+    };
+}
+// Direction to grid offset mapping
+const DIRECTION_OFFSETS = {
+    north: { dx: 0, dy: -1 },
+    south: { dx: 0, dy: 1 },
+    east: { dx: 1, dy: 0 },
+    west: { dx: -1, dy: 0 },
+    northeast: { dx: 1, dy: -1 },
+    northwest: { dx: -1, dy: -1 },
+    southeast: { dx: 1, dy: 1 },
+    southwest: { dx: -1, dy: 1 },
+    n: { dx: 0, dy: -1 },
+    s: { dx: 0, dy: 1 },
+    e: { dx: 1, dy: 0 },
+    w: { dx: -1, dy: 0 },
+    ne: { dx: 1, dy: -1 },
+    nw: { dx: -1, dy: -1 },
+    se: { dx: 1, dy: 1 },
+    sw: { dx: -1, dy: 1 },
+    up: { dx: 0, dy: -1 },
+    down: { dx: 0, dy: 1 },
+};
+export function renderMap(gameId, options) {
+    const locations = listLocations(gameId);
+    if (locations.length === 0)
+        return null;
+    // Build location lookup
+    const locationMap = new Map(locations.map((l) => [l.id, l]));
+    // Determine center location
+    let centerId = options?.centerId;
+    if (!centerId) {
+        // Default to player location or first location
+        centerId = options?.playerLocationId || locations[0].id;
+    }
+    const centerLocation = locationMap.get(centerId);
+    if (!centerLocation)
+        return null;
+    // BFS to place locations on grid
+    const placed = new Map();
+    const queue = [];
+    const visited = new Set();
+    placed.set(centerId, { x: 0, y: 0 });
+    queue.push({ id: centerId, x: 0, y: 0, depth: 0 });
+    visited.add(centerId);
+    const maxRadius = options?.radius ?? Infinity;
+    while (queue.length > 0) {
+        const current = queue.shift();
+        if (!current)
+            break;
+        const location = locationMap.get(current.id);
+        if (!location)
+            continue;
+        // Don't explore beyond radius
+        if (current.depth >= maxRadius)
+            continue;
+        for (const exit of location.properties.exits) {
+            if (visited.has(exit.destinationId))
+                continue;
+            const offset = getDirectionOffset(exit.direction);
+            const newX = current.x + offset.dx;
+            const newY = current.y + offset.dy;
+            // Check if position is occupied, if so try to find nearby spot
+            let finalX = newX;
+            let finalY = newY;
+            if (isOccupied(placed, newX, newY)) {
+                const spot = findNearbySpot(placed, newX, newY);
+                finalX = spot.x;
+                finalY = spot.y;
+            }
+            placed.set(exit.destinationId, { x: finalX, y: finalY });
+            visited.add(exit.destinationId);
+            queue.push({ id: exit.destinationId, x: finalX, y: finalY, depth: current.depth + 1 });
+        }
+    }
+    // Build nodes and connections
+    const nodes = [];
+    const connections = [];
+    const connectionSet = new Set();
+    for (const [id, pos] of placed) {
+        const location = locationMap.get(id);
+        if (!location)
+            continue;
+        const exits = location.properties.exits
+            .filter((e) => placed.has(e.destinationId))
+            .map((e) => ({ direction: e.direction, toId: e.destinationId }));
+        nodes.push({
+            id,
+            name: location.name,
+            x: pos.x,
+            y: pos.y,
+            exits,
+            isCenter: id === centerId,
+            hasPlayer: id === options?.playerLocationId,
+        });
+        // Add connections (deduplicated)
+        for (const exit of exits) {
+            const key1 = `${id}-${exit.toId}`;
+            const key2 = `${exit.toId}-${id}`;
+            if (!connectionSet.has(key1) && !connectionSet.has(key2)) {
+                connections.push({ from: id, to: exit.toId, direction: exit.direction });
+                connectionSet.add(key1);
+            }
+        }
+    }
+    // Calculate bounds
+    const xs = nodes.map((n) => n.x);
+    const ys = nodes.map((n) => n.y);
+    const bounds = {
+        minX: Math.min(...xs),
+        maxX: Math.max(...xs),
+        minY: Math.min(...ys),
+        maxY: Math.max(...ys),
+    };
+    return { nodes, connections, bounds };
+}
+function getDirectionOffset(direction) {
+    const normalized = direction.toLowerCase().trim();
+    return DIRECTION_OFFSETS[normalized] || { dx: 0, dy: 0 };
+}
+function isOccupied(placed, x, y) {
+    for (const pos of placed.values()) {
+        if (pos.x === x && pos.y === y)
+            return true;
+    }
+    return false;
+}
+function findNearbySpot(placed, x, y) {
+    // Spiral outward to find empty spot
+    const offsets = [
+        [1, 0], [-1, 0], [0, 1], [0, -1],
+        [1, 1], [-1, 1], [1, -1], [-1, -1],
+        [2, 0], [-2, 0], [0, 2], [0, -2],
+    ];
+    for (const [dx, dy] of offsets) {
+        const newX = x + dx;
+        const newY = y + dy;
+        if (!isOccupied(placed, newX, newY)) {
+            return { x: newX, y: newY };
+        }
+    }
+    // Fallback: just offset by a lot
+    return { x: x + 3, y };
+}