757 lines
34 KiB
JavaScript
757 lines
34 KiB
JavaScript
import { callOllama } from "./ollamaClient.js";
|
|
|
|
// Utility: strip markdown artifacts and clean up extra whitespace
|
|
function cleanText(str) {
|
|
if (!str) return "";
|
|
return str
|
|
.replace(/^#+\s*/gm, "")
|
|
.replace(/\*\*(.*?)\*\*/g, "$1") // Removes bolding
|
|
.replace(/[*_`]/g, "") // Removes other markdown
|
|
.replace(/\s+/g, " ")
|
|
.trim();
|
|
}
|
|
|
|
function parseList(raw) {
|
|
return raw
|
|
.split(/\n?\d+[).]\s+/)
|
|
.map(line => cleanText(line))
|
|
.filter(Boolean);
|
|
}
|
|
|
|
function parseObjects(raw, type = "rooms") {
|
|
const cleanedRaw = raw.replace(/Intermediate Rooms:/i, "").replace(/Climax Room:/i, "").trim();
|
|
const mapper = (entry) => {
|
|
if (type === "encounters") {
|
|
// For encounters, format is "Encounter Name: Location Name: details"
|
|
const parts = entry.split(/:/);
|
|
if (parts.length >= 3) {
|
|
const name = parts[0].trim();
|
|
// Skip placeholder names
|
|
if (name.toLowerCase().includes('location name') || name.toLowerCase().includes('encounter name')) {
|
|
return null;
|
|
}
|
|
return {
|
|
name: name,
|
|
details: parts.slice(1).join(":").trim()
|
|
};
|
|
} else if (parts.length === 2) {
|
|
const name = parts[0].trim();
|
|
if (name.toLowerCase().includes('location name') || name.toLowerCase().includes('encounter name')) {
|
|
return null;
|
|
}
|
|
return {
|
|
name: name,
|
|
details: parts[1].trim()
|
|
};
|
|
}
|
|
return null;
|
|
}
|
|
// For other types, use original logic
|
|
const [name, ...descParts] = entry.split(/[-–—:]/);
|
|
const cleanName = name.trim();
|
|
// Skip placeholder names
|
|
if (cleanName.toLowerCase().includes('location name') ||
|
|
cleanName.toLowerCase().includes('npc name') ||
|
|
cleanName.toLowerCase().includes('treasure name') ||
|
|
cleanName.toLowerCase().includes('actual ')) {
|
|
return null;
|
|
}
|
|
const desc = descParts.join(" ").trim();
|
|
const obj = { name: cleanName };
|
|
if (type === "rooms") return { ...obj, description: desc };
|
|
if (type === "npcs") return { ...obj, trait: desc };
|
|
if (type === "treasure") return { ...obj, description: desc };
|
|
return null;
|
|
};
|
|
return cleanedRaw.split(/\n?\d+[).]\s+/).map(cleanText).filter(Boolean).map(mapper).filter(Boolean);
|
|
}
|
|
|
|
const parseEncounterText = (text, idx) => {
|
|
const match = text.match(/^(\d+)\s+(.+?)(?::\s*(.+))?$/);
|
|
if (match) {
|
|
const [, , name, details] = match;
|
|
return name && details ? { name: name.trim(), details: details.trim() } : null;
|
|
}
|
|
const colonSplit = text.split(/[:]/);
|
|
if (colonSplit.length > 1) {
|
|
return {
|
|
name: colonSplit[0].replace(/^\d+\s+/, "").trim(),
|
|
details: colonSplit.slice(1).join(":").trim()
|
|
};
|
|
}
|
|
const nameMatch = text.match(/^\d+\s+([A-Z][a-z]+(?:\s+[A-Z][a-z]+)*)/);
|
|
if (nameMatch) {
|
|
return {
|
|
name: nameMatch[1],
|
|
details: text.replace(/^\d+\s+[A-Z][a-z]+(?:\s+[A-Z][a-z]+)*\s*/, "").trim()
|
|
};
|
|
}
|
|
return { name: `Encounter ${idx + 1}`, details: text.replace(/^\d+\s+/, "").trim() };
|
|
};
|
|
|
|
const splitCombinedEncounters = (encounters) => {
|
|
const shouldSplit = encounters.length === 1 && (encounters[0].name === "1" || encounters[0].details.match(/\d+\s+[A-Z]/));
|
|
if (!shouldSplit) return encounters;
|
|
console.warn("Encounters appear combined, attempting to split...");
|
|
const combinedText = encounters[0].details || "";
|
|
const split = combinedText.split(/(?=\d+\s+[A-Z][a-z])/).filter(Boolean);
|
|
return (split.length > 1 || (split.length === 1 && combinedText.length > 100))
|
|
? split.map(parseEncounterText).filter(e => e?.name && e?.details?.length > 10)
|
|
: encounters;
|
|
};
|
|
|
|
const splitCombinedNPCs = (npcs) => {
|
|
const shouldSplit = npcs.length === 1 && npcs[0].trait?.length > 80;
|
|
if (!shouldSplit) return npcs;
|
|
console.warn("NPCs appear combined, attempting to split...");
|
|
const split = npcs[0].trait.split(/(?=[A-Z][a-z]+\s+[A-Z][a-z]+\s*:)/).filter(Boolean);
|
|
return split.length > 1
|
|
? split.map(text => {
|
|
const [name, ...traitParts] = text.split(/[:]/);
|
|
return { name: name.trim(), trait: traitParts.join(":").trim() };
|
|
}).filter(n => n.name && n.trait?.length > 10)
|
|
: npcs;
|
|
};
|
|
|
|
const parseTreasureText = (text, idx, splitTreasures) => {
|
|
if (idx === splitTreasures.length - 1 && text.length < 40) {
|
|
return { name: splitTreasures[idx - 1]?.split(/\s+/).slice(-2).join(" ") || `Treasure ${idx}`, description: text };
|
|
}
|
|
const dashSplit = text.split(/[—]/);
|
|
if (dashSplit.length === 2) return { name: dashSplit[0].trim(), description: dashSplit[1].trim() };
|
|
if (text.length < 30 && /^[A-Z]/.test(text)) return { name: text.trim(), description: "" };
|
|
return null;
|
|
};
|
|
|
|
const splitCombinedTreasures = (treasure) => {
|
|
const shouldSplit = treasure.length === 1 && treasure[0].description?.length > 60;
|
|
if (!shouldSplit) return treasure;
|
|
console.warn("Treasures appear combined, attempting to split...");
|
|
const split = treasure[0].description.split(/\s+—\s+/).filter(Boolean);
|
|
if (split.length <= 1) return treasure;
|
|
const parsed = split.map((text, idx) => parseTreasureText(text, idx, split)).filter(t => t?.name && t?.description);
|
|
if (parsed.length > 0) return parsed;
|
|
const nameDescPairs = treasure[0].description.match(/([A-Z][^—]+?)\s+—\s+([^—]+?)(?=\s+[A-Z][^—]+\s+—|$)/g);
|
|
return nameDescPairs
|
|
? nameDescPairs.map(pair => {
|
|
const match = pair.match(/([^—]+)\s+—\s+(.+)/);
|
|
return match ? { name: match[1].trim(), description: match[2].trim() } : null;
|
|
}).filter(t => t)
|
|
: treasure;
|
|
};
|
|
|
|
function extractCanonicalNames(dungeonData) {
|
|
const names = {
|
|
npcs: [],
|
|
rooms: [],
|
|
factions: []
|
|
};
|
|
|
|
// Extract NPC names
|
|
if (dungeonData.npcs) {
|
|
dungeonData.npcs.forEach(npc => {
|
|
if (npc.name) names.npcs.push(npc.name.trim());
|
|
});
|
|
}
|
|
|
|
// Extract room names
|
|
if (dungeonData.rooms) {
|
|
dungeonData.rooms.forEach(room => {
|
|
if (room.name) names.rooms.push(room.name.trim());
|
|
});
|
|
}
|
|
|
|
// Extract faction names from core concepts (if available)
|
|
if (dungeonData.coreConcepts) {
|
|
const factionMatch = dungeonData.coreConcepts.match(/Primary Faction[:\s]+([^.]+)/i);
|
|
if (factionMatch) {
|
|
names.factions.push(factionMatch[1].trim());
|
|
}
|
|
}
|
|
|
|
return names;
|
|
}
|
|
|
|
function validateNameConsistency(dungeonData) {
|
|
const canonicalNames = extractCanonicalNames(dungeonData);
|
|
const fixes = [];
|
|
|
|
// Fix NPC names in all text fields - ensure consistency across all references
|
|
canonicalNames.npcs.forEach(canonicalName => {
|
|
// Check and fix in flavor text
|
|
if (dungeonData.flavor) {
|
|
const original = dungeonData.flavor;
|
|
// Use canonical name as the source of truth
|
|
dungeonData.flavor = dungeonData.flavor.replace(new RegExp(canonicalName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'), canonicalName);
|
|
if (original !== dungeonData.flavor) {
|
|
fixes.push(`Fixed NPC name in flavor text: ${canonicalName}`);
|
|
}
|
|
}
|
|
|
|
// Check and fix in hooks
|
|
if (dungeonData.hooksRumors) {
|
|
dungeonData.hooksRumors = dungeonData.hooksRumors.map(hook => {
|
|
const original = hook;
|
|
const fixed = hook.replace(new RegExp(canonicalName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'), canonicalName);
|
|
if (original !== fixed) {
|
|
fixes.push(`Fixed NPC name in hook: ${canonicalName}`);
|
|
}
|
|
return fixed;
|
|
});
|
|
}
|
|
|
|
// Check and fix in encounters
|
|
if (dungeonData.encounters) {
|
|
dungeonData.encounters.forEach(encounter => {
|
|
if (encounter.details) {
|
|
const original = encounter.details;
|
|
encounter.details = encounter.details.replace(new RegExp(canonicalName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'), canonicalName);
|
|
if (original !== encounter.details) {
|
|
fixes.push(`Fixed NPC name in encounter: ${canonicalName}`);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
// Check and fix in plot resolutions
|
|
if (dungeonData.plotResolutions) {
|
|
dungeonData.plotResolutions = dungeonData.plotResolutions.map(resolution => {
|
|
const original = resolution;
|
|
const fixed = resolution.replace(new RegExp(canonicalName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'), canonicalName);
|
|
if (original !== fixed) {
|
|
fixes.push(`Fixed NPC name in plot resolution: ${canonicalName}`);
|
|
}
|
|
return fixed;
|
|
});
|
|
}
|
|
});
|
|
|
|
// Fix room names in encounters and other text
|
|
canonicalNames.rooms.forEach(canonicalRoom => {
|
|
if (dungeonData.encounters) {
|
|
dungeonData.encounters.forEach(encounter => {
|
|
if (encounter.details) {
|
|
const original = encounter.details;
|
|
encounter.details = encounter.details.replace(new RegExp(canonicalRoom.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'), 'gi'), canonicalRoom);
|
|
if (original !== encounter.details) {
|
|
fixes.push(`Fixed room name in encounter: ${canonicalRoom}`);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
});
|
|
|
|
return fixes;
|
|
}
|
|
|
|
function standardizeEncounterLocations(encounters, rooms) {
|
|
if (!encounters || !rooms) return { encounters, fixes: [] };
|
|
|
|
const roomNames = rooms.map(r => r.name.trim());
|
|
const fixes = [];
|
|
const fixedEncounters = encounters.map(encounter => {
|
|
if (!encounter.details) return encounter;
|
|
|
|
let details = encounter.details.trim();
|
|
const original = details;
|
|
|
|
// Check if details start with a room name
|
|
for (const roomName of roomNames) {
|
|
// Check for room name at start (with or without colon)
|
|
const roomNameRegex = new RegExp(`^${roomName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:?\\s*`, 'i');
|
|
if (roomNameRegex.test(details)) {
|
|
// Already has location, ensure format is "Location: Description"
|
|
if (!details.match(new RegExp(`^${roomName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}:`, 'i'))) {
|
|
details = details.replace(roomNameRegex, `${roomName}: `);
|
|
fixes.push(`Standardized location format for encounter: ${encounter.name}`);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (original !== details) {
|
|
encounter.details = details;
|
|
}
|
|
|
|
return encounter;
|
|
});
|
|
|
|
return { encounters: fixedEncounters, fixes };
|
|
}
|
|
|
|
// Content validation functions
|
|
function validateContentCompleteness(dungeonData) {
|
|
const issues = [];
|
|
const checks = [
|
|
['title', 0, 'Missing title'],
|
|
['flavor', 20, 'Flavor text too short'],
|
|
['hooksRumors', 4, 'Expected at least 4 hooks'],
|
|
['rooms', 5, 'Expected at least 5 rooms'],
|
|
['encounters', 6, 'Expected at least 6 encounters'],
|
|
['npcs', 4, 'Expected at least 4 NPCs'],
|
|
['treasure', 4, 'Expected at least 4 treasures'],
|
|
['randomEvents', 6, 'Expected 6 random events'],
|
|
['plotResolutions', 4, 'Expected at least 4 plot resolutions']
|
|
];
|
|
|
|
checks.forEach(([key, min, msg]) => {
|
|
const val = dungeonData[key];
|
|
if (!val || (Array.isArray(val) ? val.length < min : val.trim().length < min)) {
|
|
issues.push(`${msg}${Array.isArray(val) ? `, got ${val?.length || 0}` : ''}`);
|
|
}
|
|
});
|
|
|
|
// Check descriptions
|
|
dungeonData.rooms?.forEach((r, i) => {
|
|
if (!r.description || r.description.trim().length < 20) {
|
|
issues.push(`Room ${i + 1} (${r.name}) description too short`);
|
|
}
|
|
});
|
|
dungeonData.encounters?.forEach((e, i) => {
|
|
if (!e.details || e.details.trim().length < 30) {
|
|
issues.push(`Encounter ${i + 1} (${e.name}) details too short`);
|
|
}
|
|
});
|
|
dungeonData.npcs?.forEach((n, i) => {
|
|
if (!n.trait || n.trait.trim().length < 30) {
|
|
issues.push(`NPC ${i + 1} (${n.name}) description too short`);
|
|
}
|
|
});
|
|
|
|
return issues;
|
|
}
|
|
|
|
function validateContentQuality(dungeonData) {
|
|
const issues = [];
|
|
const vagueWords = /\b(some|various|several|many|few|things|stuff|items|objects)\b/gi;
|
|
|
|
const checkVague = (text, ctx) => {
|
|
if (!text) return;
|
|
const matches = text.match(vagueWords);
|
|
if (matches?.length > 2) {
|
|
issues.push(`${ctx} contains vague language: "${matches.slice(0, 3).join('", "')}"`);
|
|
}
|
|
};
|
|
|
|
checkVague(dungeonData.flavor, 'Flavor text');
|
|
dungeonData.rooms?.forEach(r => checkVague(r.description, `Room "${r.name}"`));
|
|
dungeonData.encounters?.forEach(e => checkVague(e.details, `Encounter "${e.name}"`));
|
|
dungeonData.npcs?.forEach(n => checkVague(n.trait, `NPC "${n.name}"`));
|
|
dungeonData.rooms?.forEach(r => {
|
|
if (r.description?.length < 50) {
|
|
issues.push(`Room "${r.name}" description too short`);
|
|
}
|
|
});
|
|
|
|
return issues;
|
|
}
|
|
|
|
function validateContentStructure(dungeonData) {
|
|
const issues = [];
|
|
|
|
dungeonData.rooms?.forEach((r, i) => {
|
|
if (!r.name?.trim()) issues.push(`Room ${i + 1} missing name`);
|
|
if (r.name?.split(/\s+/).length > 6) issues.push(`Room "${r.name}" name too long`);
|
|
});
|
|
|
|
dungeonData.encounters?.forEach((e, i) => {
|
|
if (!e.name?.trim()) issues.push(`Encounter ${i + 1} missing name`);
|
|
if (e.name?.split(/\s+/).length > 6) issues.push(`Encounter "${e.name}" name too long`);
|
|
if (e.details && !e.details.match(/^[^:]+:\s/)) {
|
|
issues.push(`Encounter "${e.name}" details missing location prefix`);
|
|
}
|
|
});
|
|
|
|
dungeonData.npcs?.forEach((n, i) => {
|
|
if (!n.name?.trim()) issues.push(`NPC ${i + 1} missing name`);
|
|
if (n.name?.split(/\s+/).length > 4) issues.push(`NPC "${n.name}" name too long`);
|
|
});
|
|
|
|
return issues;
|
|
}
|
|
|
|
function validateNarrativeCoherence(dungeonData) {
|
|
const issues = [];
|
|
const factionMatch = dungeonData.coreConcepts?.match(/Primary Faction[:\s]+([^.]+)/i);
|
|
const factionName = factionMatch?.[1]?.trim();
|
|
|
|
if (dungeonData.encounters && dungeonData.rooms) {
|
|
const roomNames = dungeonData.rooms.map(r => r.name.trim().toLowerCase());
|
|
dungeonData.encounters.forEach(e => {
|
|
const locMatch = e.details?.match(/^([^:]+):/);
|
|
if (locMatch) {
|
|
const locName = locMatch[1].trim().toLowerCase();
|
|
if (!roomNames.some(rn => locName.includes(rn) || rn.includes(locName))) {
|
|
issues.push(`Encounter "${e.name}" references unknown location "${locMatch[1]}"`);
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
if (factionName) {
|
|
const factionLower = factionName.toLowerCase();
|
|
let refs = 0;
|
|
dungeonData.npcs?.forEach(n => {
|
|
if (n.trait?.toLowerCase().includes(factionLower)) refs++;
|
|
});
|
|
dungeonData.encounters?.forEach(e => {
|
|
if (e.details?.toLowerCase().includes(factionLower)) refs++;
|
|
});
|
|
if (refs < 2) {
|
|
issues.push(`Faction "${factionName}" poorly integrated (${refs} references)`);
|
|
}
|
|
}
|
|
|
|
return issues;
|
|
}
|
|
|
|
function validateAndFixContent(dungeonData) {
|
|
const allFixes = [];
|
|
const allIssues = [];
|
|
|
|
// Validate name consistency
|
|
const nameFixes = validateNameConsistency(dungeonData);
|
|
allFixes.push(...nameFixes);
|
|
|
|
// Standardize encounter locations and add missing ones
|
|
if (dungeonData.encounters && dungeonData.rooms) {
|
|
const roomNames = dungeonData.rooms.map(r => r.name.trim());
|
|
dungeonData.encounters.forEach((encounter, idx) => {
|
|
if (!encounter.details) return;
|
|
// If encounter doesn't start with a location, assign one
|
|
if (!encounter.details.match(/^[^:]+:\s/)) {
|
|
// Assign to a random room, or cycle through rooms
|
|
const roomIdx = idx % roomNames.length;
|
|
const roomName = roomNames[roomIdx];
|
|
encounter.details = `${roomName}: ${encounter.details}`;
|
|
allFixes.push(`Added location "${roomName}" to encounter "${encounter.name}"`);
|
|
}
|
|
});
|
|
const locationResult = standardizeEncounterLocations(dungeonData.encounters, dungeonData.rooms);
|
|
dungeonData.encounters = locationResult.encounters;
|
|
allFixes.push(...locationResult.fixes);
|
|
}
|
|
|
|
// Run content validation
|
|
const completenessIssues = validateContentCompleteness(dungeonData);
|
|
const qualityIssues = validateContentQuality(dungeonData);
|
|
const structureIssues = validateContentStructure(dungeonData);
|
|
const coherenceIssues = validateNarrativeCoherence(dungeonData);
|
|
|
|
allIssues.push(...completenessIssues, ...qualityIssues, ...structureIssues, ...coherenceIssues);
|
|
|
|
if (allFixes.length > 0) {
|
|
console.log("\n[Validation] Applied fixes:");
|
|
allFixes.forEach(fix => console.log(` - ${fix}`));
|
|
}
|
|
|
|
if (allIssues.length > 0) {
|
|
console.log("\n[Validation] Content quality issues found:");
|
|
allIssues.forEach(issue => console.warn(` ⚠ ${issue}`));
|
|
} else {
|
|
console.log("\n[Validation] Content quality checks passed");
|
|
}
|
|
|
|
return dungeonData;
|
|
}
|
|
|
|
export async function generateDungeon() {
|
|
// Step 1: Titles
|
|
const generatedTitlesRaw = await callOllama(
|
|
`Generate 50 short, punchy dungeon titles (max 5 words each), numbered as a plain text list.
|
|
Each title should come from a different style or theme. Make the set varied and evocative. For example:
|
|
|
|
- OSR / classic tabletop: gritty, mysterious, old-school
|
|
- Mörk Borg: dark, apocalyptic, foreboding
|
|
- Pulpy fantasy: adventurous, dramatic, larger-than-life
|
|
- Mildly sci-fi: alien, technological, strange
|
|
- Weird fantasy: uncanny, surreal, unsettling
|
|
- Whimsical: fun, quirky, playful
|
|
|
|
CRITICAL: Ensure all spelling is correct. Double-check all words before outputting.
|
|
Avoid repeating materials or adjectives. Absolutely do not use the words "Obsidian" or "Clockwork" in any title. Do not include explanations, markdown, or preambles. Do not include the style or theme in parenthesis. Only the 50 numbered titles.`,
|
|
undefined, 5, "Step 1: Titles"
|
|
);
|
|
const generatedTitles = parseList(generatedTitlesRaw);
|
|
console.log("Generated Titles:", generatedTitles);
|
|
const title = generatedTitles[Math.floor(Math.random() * generatedTitles.length)];
|
|
console.log("Selected title:", title);
|
|
|
|
// Step 2: Core Concepts
|
|
const coreConceptsRaw = await callOllama(
|
|
`For a dungeon titled "${title}", generate three core concepts: a central conflict, a primary faction, and a major environmental hazard or dynamic element.
|
|
Output as a numbered list with bolded headings. Plain text only. Absolutely do not use the word "Obsidian" or "obsidian" anywhere in the output.
|
|
Example:
|
|
1. **Central Conflict:** The dungeon's power source is failing, causing reality to warp.
|
|
2. **Primary Faction:** A group of rival cultists trying to seize control of the power source.
|
|
3. **Dynamic Element:** Zones of temporal distortion that cause random, brief time shifts.`,
|
|
undefined, 5, "Step 2: Core Concepts"
|
|
);
|
|
const coreConcepts = coreConceptsRaw;
|
|
console.log("Core Concepts:", coreConcepts);
|
|
|
|
// Step 3: Flavor Text & Hooks
|
|
const flavorHooksRaw = await callOllama(
|
|
`Based on the title "${title}" and these core concepts:
|
|
${coreConcepts}
|
|
Write a single evocative paragraph describing the location. Maximum 2 sentences. Maximum 100 words. Then, generate 4-5 short adventure hooks or rumors.
|
|
The hooks should reference the central conflict, faction, and dynamic element. Hooks should suggest different approaches (stealth, diplomacy, force, exploration) and create anticipation.
|
|
|
|
EXAMPLE OF GOOD HOOK:
|
|
"A merchant's cart was found abandoned near the entrance, its cargo of rare herbs scattered. The merchant's journal mentions strange lights in the depths and a warning about 'the watchers'."
|
|
|
|
CRITICAL: Hooks must be concise to fit in a single column on a one-page dungeon layout. Each hook must be 25-30 words maximum. Be specific with details, not vague.
|
|
CRITICAL: Ensure all spelling is correct. Double-check all words, especially proper nouns and technical terms.
|
|
Output two sections labeled "Description:" and "Hooks & Rumors:". Use a numbered list for the hooks. Plain text only. Do not use em-dashes (—) anywhere in the output. Absolutely do not use the word "Obsidian" or "obsidian" anywhere in the output.`,
|
|
undefined, 5, "Step 3: Flavor & Hooks"
|
|
);
|
|
const [flavorSection, hooksSection] = flavorHooksRaw.split(/Hooks & Rumors[:\n]/i);
|
|
const flavor = cleanText(flavorSection.replace(/Description[:\n]*/i, ""));
|
|
const hooksRumors = parseList(hooksSection || "");
|
|
console.log("Flavor Text:", flavor);
|
|
console.log("Hooks & Rumors:", hooksRumors);
|
|
|
|
// Step 4: Key Rooms
|
|
const keyRoomsRaw = await callOllama(
|
|
`Based on the title "${title}", description "${flavor}", and these core concepts:
|
|
${coreConcepts}
|
|
Generate two key rooms that define the dungeon's narrative arc.
|
|
CRITICAL: These rooms need rich environmental and tactical details with multiple interaction possibilities.
|
|
|
|
EXAMPLE OF GOOD ROOM DESCRIPTION:
|
|
"Chamber of Echoes: Flickering torchlight casts dancing shadows across moss-covered walls. A constant dripping echoes from stalactites overhead, and the air smells of damp earth and ozone. Three stone pillars provide cover, while a raised dais in the center offers high ground. A rusted lever on the west wall controls a hidden portcullis. The floor is slick with moisture, making movement difficult."
|
|
|
|
1. Entrance Room: Give it a name (max 5 words) and a description (25-35 words) that MUST include:
|
|
- Immediate observable features and environmental details (lighting, sounds, smells, textures, temperature, visibility)
|
|
- Interactable elements that players can use (levers, objects, portals, mechanisms, environmental hazards)
|
|
- Tactical considerations (cover, elevation, movement restrictions, line of sight)
|
|
- Sets the tone and introduces the environmental hazard/dynamic element
|
|
|
|
2. Climax Room: Give it a name (max 5 words) and a description (25-35 words) that MUST include:
|
|
- Connection to the primary faction and the central conflict
|
|
- Rich environmental and tactical details
|
|
- Multiple approach options or solutions
|
|
- Tactical considerations and environmental factors that affect gameplay
|
|
|
|
EXACT FORMAT REQUIRED - each room on its own numbered line:
|
|
1. Room Name: Description text here.
|
|
2. Room Name: Description text here.
|
|
|
|
CRITICAL: Ensure all spelling is correct. Double-check all words before outputting.
|
|
CRITICAL: Be specific and concrete. Avoid vague words like "some", "various", "several" without details.
|
|
Output ONLY the two numbered items, one per line. Use colons (:) to separate room names from descriptions, not em-dashes. Do not use em-dashes (—) anywhere. Do not combine items. Do not use bolded headings. Do not include any intro or other text. Absolutely do not use the word "Obsidian" or "obsidian" anywhere in the output.`,
|
|
undefined, 5, "Step 4: Key Rooms"
|
|
);
|
|
const [entranceSection, climaxSection] = keyRoomsRaw.split(/\n?2[).] /); // Split on "2. " to separate the two rooms
|
|
const entranceRoom = parseObjects(entranceSection, "rooms")[0];
|
|
const climaxRoom = parseObjects(`1. ${climaxSection}`, "rooms")[0]; // Prepend "1. " to make parsing consistent
|
|
|
|
// Fix placeholder names by extracting from description
|
|
const fixRoomName = (room) => {
|
|
if (!room) return room;
|
|
if (room.name && (room.name.toLowerCase().includes('room name') || room.name.toLowerCase() === 'room name')) {
|
|
// Extract room name from description (first 2-4 words before "Description" or similar)
|
|
const desc = room.description || '';
|
|
const nameMatch = desc.match(/^([^:]+?)(?:\s+Description|\s*:)/i) || desc.match(/^([A-Z][^.!?]{5,40}?)(?:\s+is\s|\.)/);
|
|
if (nameMatch) {
|
|
room.name = nameMatch[1].trim().replace(/^(The|A|An)\s+/i, '').trim();
|
|
room.description = desc.replace(new RegExp(`^${nameMatch[1]}\\s*(Description|:)?\\s*`, 'i'), '').trim();
|
|
} else {
|
|
// Fallback: use first few words of description
|
|
const words = desc.split(/\s+/).slice(0, 4).join(' ');
|
|
room.name = words.replace(/^(The|A|An)\s+/i, '').trim();
|
|
}
|
|
}
|
|
return room;
|
|
};
|
|
|
|
if (entranceRoom) fixRoomName(entranceRoom);
|
|
if (climaxRoom) fixRoomName(climaxRoom);
|
|
|
|
console.log("Entrance Room:", entranceRoom);
|
|
console.log("Climax Room:", climaxRoom);
|
|
|
|
// Step 5: Main Content (Locations, Encounters, NPCs, Treasures, Random Events)
|
|
const mainContentRaw = await callOllama(
|
|
`Based on the following dungeon elements and the need for narrative flow:
|
|
Title: "${title}"
|
|
Description: "${flavor}"
|
|
Core Concepts:
|
|
${coreConcepts}
|
|
Entrance Room: ${JSON.stringify(entranceRoom)}
|
|
Climax Room: ${JSON.stringify(climaxRoom)}
|
|
|
|
Generate the rest of the dungeon's content to fill the space between the entrance and the climax. CRITICAL: All content must fit on a single one-page dungeon layout with three columns. Keep descriptions rich and evocative with tactical/environmental details.
|
|
|
|
- **Strictly 3 Locations (EXACTLY 3, no more, no less):** Each with a name (max 6 words) and a description (25-35 words). Each room MUST include:
|
|
- Rich environmental features that affect gameplay (lighting, sounds, smells, textures, temperature, visibility)
|
|
- Interactable elements that players can use (levers, objects, portals, mechanisms, environmental hazards)
|
|
- Multiple approaches or solutions to challenges in the room
|
|
- Tactical considerations (cover, elevation, movement restrictions, line of sight)
|
|
- Hidden aspects discoverable through interaction or investigation
|
|
Format as "Name: description" using colons, NOT em-dashes.
|
|
|
|
EXAMPLE LOCATION:
|
|
"Whispering Gallery: Dim phosphorescent fungi line the walls, casting an eerie green glow. The air hums with a low-frequency vibration that makes conversation difficult. Two collapsed pillars create natural cover, while a narrow ledge 10 feet up offers a sniper position. A hidden pressure plate near the entrance triggers a portcullis trap."
|
|
|
|
- **Strictly 6 Encounters:** Numbered 1-6 (for d6 rolling). Name (max 6 words) and details (2 sentences MAX, approximately 25-40 words). Each encounter MUST:
|
|
- Start with the room/location name followed by a colon, then the details (e.g., "Location Name: Details text")
|
|
- The location name must match one of the actual room names from this dungeon
|
|
- Include environmental hazards/opportunities (cover, elevation, traps, interactable objects, terrain features)
|
|
- Include tactical considerations (positioning, line of sight, escape routes, bottlenecks, high ground)
|
|
- Offer multiple resolution options (combat, negotiation, stealth, puzzle-solving, environmental manipulation, timing-based solutions)
|
|
- Include consequences and outcomes tied to player choices
|
|
- Integrate with the environmental dynamic element from core concepts
|
|
- At least two encounters must be directly tied to the primary faction
|
|
Format as "Name: Location Name: details" using colons, NOT em-dashes. CRITICAL: Always start encounter details with the location name and a colon.
|
|
|
|
EXAMPLE ENCOUNTER:
|
|
"Guardian Golem: Chamber of Echoes: The golem activates when the lever is pulled, blocking the exit. It's vulnerable to water damage from the dripping stalactites. Players can use the pillars for cover or try to disable it by breaking the rune on its back. If defeated peacefully, it reveals a hidden passage."
|
|
|
|
- **Strictly 4-5 NPCs:** Proper name (max 4 words) and a description (50-65 words). Each NPC MUST include:
|
|
- Clear motivation or goal
|
|
- Relationship to primary faction
|
|
- How they can help or hinder the party
|
|
- Quirks or memorable traits
|
|
- Multiple interaction possibilities (negotiation, intimidation, help, betrayal)
|
|
- One NPC should be a key figure tied to the central conflict
|
|
- One should be a member of the primary faction, one should be a potential ally, one should be a rival
|
|
Format as "Name: description" using colons, NOT em-dashes.
|
|
|
|
EXAMPLE NPC:
|
|
"Kaelen the Warden: A former guard who was left behind when the faction retreated. He knows the secret passages but demands the party help him escape. He's paranoid and checks over his shoulder constantly. Can be bribed with food or convinced through shared stories of betrayal. Will turn on the party if he thinks they're working with the faction."
|
|
|
|
- **Strictly 4-5 Treasures:** Name (max 5 words) and a description (30-40 words). Each treasure MUST:
|
|
- Include a clear danger or side-effect
|
|
- Be connected to a specific encounter, NPC, or room
|
|
- Have story significance beyond just value
|
|
- Have potential for creative use beyond obvious purpose
|
|
- Some should be cursed, have activation requirements, or serve dual purposes
|
|
Format as "Name — Description" using em-dash.
|
|
|
|
EXAMPLE TREASURE:
|
|
"Whispering Blade — This dagger amplifies the wielder's voice to a deafening roar when drawn. Found in the Guardian Golem's chamber, it was used to command the construct. The blade is cursed: each use permanently reduces the wielder's hearing. Can be used to shatter glass or stun enemies, but the curse cannot be removed."
|
|
|
|
- **Strictly 1 Random Events Table:** A d6 table (exactly 6 entries) with random events/wandering encounters. Each entry MUST:
|
|
- Provide interesting complications or opportunities (not just combat)
|
|
- Tie to the core concepts and dynamic element
|
|
- Add replayability and surprise
|
|
- Be 15-20 words maximum
|
|
Format as numbered 1-6 list under "Random Events:" label.
|
|
|
|
CRITICAL: Each item must be on its own numbered line. DO NOT combine multiple items into a single numbered entry.
|
|
|
|
EXACT FORMAT REQUIRED (DO NOT use placeholder names like "Location Name", "NPC Name", or "Treasure Name" - use actual creative names):
|
|
Locations:
|
|
1. Actual Room Name: Description text.
|
|
2. Actual Room Name: Description text.
|
|
3. Actual Room Name: Description text.
|
|
|
|
Encounters:
|
|
1. Actual Encounter Name: Actual Room Name: Details text.
|
|
2. Actual Encounter Name: Actual Room Name: Details text.
|
|
3. Actual Encounter Name: Actual Room Name: Details text.
|
|
4. Actual Encounter Name: Actual Room Name: Details text.
|
|
5. Actual Encounter Name: Actual Room Name: Details text.
|
|
6. Actual Encounter Name: Actual Room Name: Details text.
|
|
|
|
NPCs:
|
|
1. Actual Character Name: Description text.
|
|
2. Actual Character Name: Description text.
|
|
3. Actual Character Name: Description text.
|
|
4. Actual Character Name: Description text.
|
|
|
|
Treasures:
|
|
1. Actual Item Name — Description text.
|
|
2. Actual Item Name — Description text.
|
|
3. Actual Item Name — Description text.
|
|
4. Actual Item Name — Description text.
|
|
|
|
Random Events:
|
|
1. Event description.
|
|
2. Event description.
|
|
3. Event description.
|
|
4. Event description.
|
|
5. Event description.
|
|
6. Event description.
|
|
|
|
CRITICAL: Every name must be unique and creative. Never use generic placeholders like "Location Name", "NPC Name", "Encounter Name", or "Treasure Name". Use actual descriptive names that fit the dungeon's theme.
|
|
|
|
CRITICAL: Ensure all spelling is correct. Double-check all words, especially proper nouns, character names, and location names. Verify consistency of names across all sections.
|
|
Output as five separate numbered lists with these exact labels: "Locations:", "Encounters:", "NPCs:", "Treasures:", and "Random Events:". Each item must be on its own line starting with a number. Do not combine items. Do not use any bolding, preambles, or extra text. Do not use em-dashes (—) in encounters or NPCs, only use colons for those sections. Absolutely do not use the word "Obsidian" or "obsidian" anywhere in the output.`,
|
|
undefined, 5, "Step 5: Main Content"
|
|
);
|
|
const [intermediateRoomsSection, encountersSection, npcsSection, treasureSection, randomEventsSection] = mainContentRaw.split(/Encounters:|NPCs:|Treasures?:|Random Events:/i);
|
|
const intermediateRooms = parseObjects(intermediateRoomsSection.replace(/Locations:/i, ""), "rooms");
|
|
// Limit to exactly 3 intermediate rooms to ensure total of 5 rooms (entrance + 3 intermediate + climax)
|
|
const limitedIntermediateRooms = intermediateRooms.slice(0, 3);
|
|
if (intermediateRooms.length > 3) {
|
|
console.warn(`Expected exactly 3 intermediate locations but got ${intermediateRooms.length}, limiting to first 3`);
|
|
}
|
|
const rooms = [entranceRoom, ...limitedIntermediateRooms, climaxRoom];
|
|
const encounters = splitCombinedEncounters(parseObjects(encountersSection || "", "encounters"));
|
|
const npcs = splitCombinedNPCs(parseObjects(npcsSection || "", "npcs"));
|
|
const treasure = splitCombinedTreasures(parseObjects(treasureSection || "", "treasure"));
|
|
const randomEvents = parseList(randomEventsSection || "");
|
|
|
|
[[encounters, 6, 'encounters'], [npcs, 4, 'NPCs'], [treasure, 4, 'treasures'], [randomEvents, 6, 'random events']]
|
|
.filter(([arr, expected]) => arr.length < expected && arr.length > 0)
|
|
.forEach(([arr, expected, name]) => console.warn(`Expected at least ${expected} ${name} but got ${arr.length}`));
|
|
console.log("Rooms:", rooms);
|
|
console.log("Encounters:", encounters);
|
|
console.log("NPCs:", npcs);
|
|
console.log("Treasure:", treasure);
|
|
console.log("Random Events:", randomEvents);
|
|
|
|
// Step 6: Player Choices and Consequences
|
|
const npcNamesList = npcs.map(n => n.name).join(", ");
|
|
const factionName = coreConcepts.match(/Primary Faction[:\s]+([^.]+)/i)?.[1]?.trim() || "the primary faction";
|
|
|
|
const plotResolutionsRaw = await callOllama(
|
|
`Based on all of the following elements, suggest 4-5 possible, non-conflicting story climaxes or plot resolutions for adventurers exploring this location. Each resolution must provide a meaningful choice with a tangible consequence, directly related to the Central Conflict, the Primary Faction, or the NPCs.
|
|
|
|
Dungeon Elements:
|
|
${JSON.stringify({ title, flavor, hooksRumors, rooms, encounters, treasure, npcs, coreConcepts }, null, 2)}
|
|
|
|
CRITICAL: This content must fit in a single column on a one-page dungeon layout. Keep descriptions meaningful but concise.
|
|
Start each item with phrases like "The adventurers could" or "The adventurers might". Do not use "PCs" or "player characters" - always use "adventurers" instead.
|
|
|
|
EXAMPLE PLOT RESOLUTION:
|
|
"The adventurers could ally with the primary faction, gaining access to their resources but becoming enemies of the rival group. This choice unlocks new areas but closes off diplomatic solutions with other NPCs."
|
|
|
|
IMPORTANT: When referencing NPCs, use these exact names with correct spelling: ${npcNamesList}. When referencing the faction, use: ${factionName}. Ensure all names are spelled consistently and correctly.
|
|
CRITICAL: Double-check all spelling before outputting. Verify all proper nouns match exactly as provided above.
|
|
|
|
Each resolution MUST:
|
|
- Offer meaningful choice with clear consequences
|
|
- Integrate NPCs, faction dynamics, and player actions
|
|
- Include failure states or unexpected outcomes as options
|
|
- Reflect different approaches players might take
|
|
Keep each item to 1-2 sentences MAX (approximately 15-25 words). Be extremely concise. Output as a numbered list, plain text only. Do not use em-dashes (—) anywhere in the output. Absolutely do not use the word "Obsidian" or "obsidian" anywhere in the output.`,
|
|
undefined, 5, "Step 6: Plot Resolutions"
|
|
);
|
|
const plotResolutions = parseList(plotResolutionsRaw);
|
|
console.log("Plot Resolutions:", plotResolutions);
|
|
|
|
// Step 7: Validation and Content Fixing
|
|
console.log("\n[Validation] Running content validation and fixes...");
|
|
const dungeonData = {
|
|
title,
|
|
flavor,
|
|
map: "map.png",
|
|
hooksRumors,
|
|
rooms,
|
|
encounters,
|
|
treasure,
|
|
npcs,
|
|
plotResolutions,
|
|
randomEvents,
|
|
coreConcepts
|
|
};
|
|
|
|
const validatedData = validateAndFixContent(dungeonData);
|
|
|
|
console.log("\nDungeon generation complete!");
|
|
return validatedData;
|
|
}
|