Good morning, afternoon and evening,
Everyone it has been quite a bit of time since an update was done for this project /game. We have scrapped the development using one avenue and are in the process of using what ever means necessary to implement a working game.
We are going to be using cloudflare worker framework for the time being with the eventual plan to deploy a working game as intended back to our webpage. we just want to place this update, yes it is with chatGPT because we are lazy to create our own timelines.
Rest assured though a game will be coming in the not too distant future.
Dragon Keepers
The game has moved from being a basic RPG framework to having a working AI-driven combat loop.
Our current flow is now:
Player
↓
Exploration
↓
Enemy Encounter
↓
Combat
↓
Combat Context
↓
Cloudflare Worker
↓
Combat Engine Validation
↓
Combat Resolution
↓
Rewards
That is a major milestone.
Completed.
We established the development environment:
100%
Completed.
The core game state and systems were established:
100%
Completed.
The initial world structure exists:
TOWN
↓
Ancient Forest
↓
Crystal Cave
100%
Completed.
We established the hierarchy:
Region
↓
Place
↓
Action
We also established the architecture we've agreed not to redesign.
world.js remains the source of truth for world locations and available actions.
100%
Completed.
TOWN now contains:
Town Gate
Town Square
Blacksmith
General Store
Sleeping Dragon Tavern
Village Inn
Notice Board
Each has its own descriptions and actions.
100%
Completed.
The building framework is in place for:
Their underlying gameplay systems are being expanded through the broader game systems rather than redesigning the world architecture.
100%
Completed.
The forest now supports the first proper exploration loop:
Search
↓
Nothing
Loot
Enemy
Quest
Dragon Track
We've also established the six forest locations:
FOREST LOCATIONS
100%
This phase is effectively complete.
We now have:
Enemy encounters create a proper combat state.
Attack
Defend
Item
Run
Damage is calculated by the Combat Engine.
The enemy attacks after the player's turn.
Player and enemy HP are tracked independently during combat.
Combat ends appropriately.
Escape currently uses:
ESCAPE MECHANISM
Victory can award:
We correctly separated loot into:
data/loot.js
with:
forestLoot
enemyLoot
rather than duplicating loot data inside enemies.js.
enemies.js now contains structured enemy information such as:
100%
And this is the most important change since our previous roadmap.
The original intention was always:
The agent actually controls the enemy's tactical decision and narrates the combat.
We now have that architecture working.
Created:
combat.js
This separates agent decisions from the Combat Engine.
Created:
combatContext.js
The agent receives a controlled combat context rather than the entire game state.
The context includes things like:
Player
Enemy
Combat
Last Action
We established the agent decision model.
The important distinction we settled on is:
Reasoning and confidence are internal agent considerations, not part of the player-facing game decision contract.
The Combat Engine validates the agents chosen action.
The agent cannot simply invent a game mechanic and force the engine to execute it.
This preserves:
agent suggests. Engine enforces.
We separated the agent from the combat engine.
The Combat Engine doesn't need to know whether the response comes from:
This is the milestone we just achieved.
We created the real connection:
Game Context
↓
Dragon Keepers Worker
↓
agent
↓
Decision + Narration
This is the point where Dragon Keepers stopped merely having an agent design and actually started using an external agents.
Completed. ✅
The actual game is now calling the Worker rather than only testing the Worker separately.
We changed:
combat.js
to make the real asynchronous request.
So:
Enemy Turn
↓
chooseEnemyAction()
↓
Cloudflare Worker
↓
agent
is now part of actual gameplay.
Completed. ✅
We then propagated the asynchronous agent call through the combat system.
The chain now correctly waits for:
attack()
↓
enemyTurn()
↓
chooseEnemyAction()
↓
Worker
↓
agent
↓
Decision
We also updated the combat UI to wait for the asynchronous result.
Most importantly, we connected:
decision.narration
into the Story output.
So the agents narration is now actually visible to the player.
Completed. ✅
This is where we are right now.
We're essentially at the end of Phase 9.
The remaining job is verification, not redesign.
We need to confirm that the final combat loop consistently handles:
Attack
↓
agent decision
↓
agent narration
↓
Validation
↓
Enemy action
↓
Damage
and that:
Once that verification is complete:
The most useful way to think about it is:
PHASE 1 ✅
PHASE 2 ✅
PHASE 3 ✅
PHASE 4 ✅
PHASE 5 ✅
PHASE 6 ✅
PHASE 7 ✅
PHASE 8 ✅
PHASE 9 �� ← WE ARE HERE
PHASE 9A ⏳
PHASE 10 ⏳
PHASE 11 ⏳
PHASE 12 ⏳
PHASE 13 ⏳
So the next thing we do is finish 9.9, then we move directly into the Inventory System (9A).
Most importantly, the big thing we set out to achieve in Phase 9 is now real:
The enemy in Dragon Keepers is making its tactical decision through an agent, and that agent is narrating what is happening in combat.
That's a pretty significant milestone.