Add comprehensive prompts for all 9 stages of Break Escape scenario development:
- Stage 0: Scenario Initialization - Technical challenges and narrative themes
- Stage 1: Narrative Structure - Three-act story arc development
- Stage 2: Storytelling Elements - Characters, atmosphere, dialogue
- Stage 3: Moral Choices - Player agency and ethical decisions
- Stage 4: Player Objectives - Goals and win conditions
- Stage 5: Room Layout - Physical design with technical constraints
- Stage 6: LORE Fragments - Collectible universe-building content
- Stage 7: Ink Scripting - Interactive dialogue and cutscenes
These prompts guide AI agents (or human designers) through a structured
process to create complete, validated Break Escape scenarios that combine
cybersecurity education with compelling narrative gameplay.
Each prompt includes:
- Role definition and responsibilities
- Required inputs from previous stages
- Essential reference documentation
- Process guidelines and templates
- Quality checklists
- Common pitfalls to avoid
- Tips for success
This completes the story development prompt system alongside the previously
committed README.md and Stage 8 (Review) prompt.
Add comprehensive scenario review and validation prompt (Stage 8) plus
README overview for the story development prompt system.
Note: Files for stages 0-7 need to be recreated - they appear to have
not persisted despite Write tool calls during the session.
This commit transforms the single universe bible document into a comprehensive,
organized set of reference materials across 74 files in 10 major sections.
Major Changes:
- Split original universe bible into chapter-based documents
- Expanded all content by 50-100% with additional lore and details
- Created modular directory structure for easy navigation
- Added extensive cross-referencing between documents
New Structure:
01. Universe Overview - Setting, premise, and tone
02. Organisations - SAFETYNET and ENTROPY detailed profiles
03. ENTROPY Cells - All 11 cells with expanded operations
04. Characters - SAFETYNET operatives and ENTROPY antagonists
05. World Building - Rules, technology, society, timeline
06. Locations - Environment types and notable locations
07. Narrative Structures - Mission types, arcs, player agency
08. LORE System - Collectibles, progression, writing guides
09. Scenario Design - Framework, templates, and examples
10. Reference - Quick reference, checklists, glossary, style guide
Content Expansions:
- SAFETYNET: 28 Field Operations Handbook rules (from 3)
- ENTROPY Cells: 8 key members per cell (from 4)
- Characters: 8 additional SAFETYNET agents created
- Locations: 7 environment type guides
- Scenario Templates: 4 complete templates + 3 full examples
- LORE System: 220 fragments mapped across 6 categories
- Reference: Comprehensive glossary, checklists, and CyBOK guide
Benefits:
- Easier to find specific information
- Consistent universe across all scenarios
- Supports continuous discovery as players progress
- Comprehensive reference for scenario designers
- Expanded lore enables richer storytelling
Total Documentation: ~500KB across 74 markdown files
This commit fixes several issues with East/West side doors:
1. **Sprite Flipping**: Changed flip direction - East doors are now flipped
horizontally instead of West doors (opposite direction as requested)
2. **Door Positioning**: Updated E/W door placement from 2 tiles to 3 tiles
from the top corner for better alignment with room layout
3. **Wall Passage Cutout**: Increased wall tile removal area for side doors
from 1 tile to 3 tiles vertically, creating a wider passage (matching the
inset spacing used for N/S doors)
4. **Side Door Animation**:
- Added `isSideDoor` property to doorProperties to track door type
- Created new 'door_side_open' animation using frames 1-4 (frames 2-5
in 1-indexed notation) of door_side_sheet_32 sprite
- Updated animated door creation to use side door sprite and animation
for E/W doors
5. **Sprite Alignment**: Door sprites now properly align with the tile grid
at 3 tiles from corner position
Changes made in:
- js/systems/doors.js: Door placement, sprite creation, and animations
- js/systems/collision.js: Wall tile removal for wider passages
- js/core/game.js: Side door animation definition
Tested with: scenarios/test_horizontal_layout.json
- Modified createSpriteAtRandomPosition() to accept map parameter
- Items now use actual room dimensions based on tilemap (respects room GU)
- Applied correct padding constraints:
* 1 tile (32px) from left and right sides
* 2 tiles (64px) from top and bottom
- Random item placement now works correctly with variable room sizes
- Ensures items stay within playable room bounds
Related to new room layout system (Grid Unit based positioning)
Updated room positioning to verify overlap for EACH connected room
after grid alignment, not just the group as a whole. This fixes
layouts like:
122
00
Where room 1 was previously positioned with no overlap to room 0.
Changes:
- positionNorthMultiple/positionSouthMultiple: After centering and
aligning group, check first and last room overlap. If insufficient,
shift entire group to ensure minimum overlap for each room.
- positionEastMultiple/positionWestMultiple: Same approach for
vertical stacking along east/west edges.
The algorithm now:
1. Centers the group of connecting rooms over parent
2. Aligns starting position to grid
3. Checks if first room has >= 1 GU overlap, adjusts if not
4. Checks if last room has >= 1 GU overlap, adjusts if not
5. Positions all rooms from the adjusted aligned start
This guarantees each connecting room overlaps with the parent room
by at least one Grid Unit, ensuring proper door placement and room
connectivity.
Updated room positioning algorithm to ensure all connecting rooms are
properly aligned to the grid and have at least one Grid Unit overlap
with the connecting edge of the parent room.
Changes:
- positionNorthMultiple/positionSouthMultiple: Position rooms as a group,
align the starting position to grid, then place rooms side-by-side
without individual alignment to prevent gaps
- positionEastMultiple/positionWestMultiple: Similar approach for vertical
stacking of rooms along east/west edges
This ensures:
- All rooms maintain proper grid alignment
- Connected rooms have guaranteed minimum overlap
- No gaps between adjacent rooms in multi-room connections
- Room layouts match the examples in planning notes
Addresses alignment issues described in new_room_layout documentation
where rooms need to be positioned against the connecting edge with
at least one GU overlap.
This commit addresses three critical issues identified during testing:
1. **Fixed mixed room size door alignment (Issue #1)**
- Updated room positioning logic in positionNorthMultiple, positionSouthMultiple,
positionEastMultiple, and positionWestMultiple functions
- Rooms are now positioned centered on their corresponding door positions
- Ensures doors align properly between different-sized rooms (e.g., 1×1 GU closet
connecting to 2×1 GU hallway)
- Uses same door spacing logic as door placement (edgeInset + doorSpacing)
2. **Implemented East/West single-tile doors (Issue #2)**
- Changed door_side_sheet_32 from image to spritesheet (6 frames, 32×32px each)
- Updated door sprite creation to use single tile per room for east/west doors
- West-facing doors (left room) now properly flip horizontally
- Doors positioned 3 tiles down from top (TILE_SIZE * 2) as specified
- Updated wall tile removal and animated door creation to use correct dimensions
- Both sides of east/west connections now use matching door system
3. **Added connection limit validation (Issue #3)**
- Created validateMultipleConnections function to check if connections fit
- Validates that multiple connections won't cause rooms to overhang excessively
- Logs detailed error messages with recommendations when connections don't fit
- Example: 2GU room can't have 3 north connections (not enough width)
- Helps developers identify invalid room layouts during scenario design
Files modified:
- js/core/game.js: Load door_side_sheet_32 as spritesheet
- js/core/rooms.js: Fix positioning, add validation
- js/systems/doors.js: Single-tile east/west doors with flipping
- js/systems/collision.js: Update wall tile removal for single-tile doors
Fixed issue where test scenarios couldn't load rooms:
1. Added new room types to game preload:
- small_room_1x1gu (1×1 GU closet)
- hall_1x2gu (2×1 GU wide hallway)
2. Corrected room type keys in all test scenarios:
- room_reception2 → room_reception
- room_office2 → room_office
- room_ceo2 → room_ceo
- room_servers2 → room_servers
The issue was that scenarios referenced room file names (room_reception2)
instead of the Phaser cache keys (room_reception). The game preloads rooms
with specific keys that map to the JSON files:
this.load.tilemapTiledJSON('room_reception', 'assets/rooms/room_reception2.json')
Scenarios must use the key ('room_reception'), not the filename.
Files updated:
- js/core/game.js: Added preload for new variable-sized rooms
- scenarios/test_vertical_layout.json
- scenarios/test_horizontal_layout.json
- scenarios/test_complex_multidirection.json
- scenarios/test_multiple_connections.json
- scenarios/test_mixed_room_sizes.json
All test scenarios should now load correctly.
Updated test_mixed_room_sizes.json to use the new room files merged from main:
- Changed hall from placeholder to hall_1x2gu.json (2×1 GU - 10×6 tiles)
- Changed closet from placeholder to small_room_1x1gu.json (1×1 GU - 5×6 tiles)
- Updated all scenario text to reflect actual room dimensions
- Corrected layout diagram (hall is 2×1 GU wide hallway, not 1×2 GU vertical)
Updated TEST_SCENARIOS_README.md:
- Marked small_room_1x1gu.json and hall_1x2gu.json as available (✓)
- Updated scenario #5 description with actual rooms used
- Clarified that this scenario now demonstrates real size variety
This scenario now provides a complete test of the grid system with:
- 1×1 GU closet (smallest valid room)
- 2×1 GU wide hallway (horizontal connector)
- 2×2 GU standard rooms (reception, CEO office)
- Proper door alignment between all different sizes
Updated README_scenario_design.md with new grid-based room layout system:
- Documented Grid Unit (GU) system: 5×4 tiles base unit
- Added valid room size specifications (widths: multiples of 5, heights: 2+4N)
- Replaced old north/south-only constraints with four-direction support
- Updated door placement rules for N/S/E/W connections
- Added room positioning algorithm documentation
- Revised scenario design guidelines for grid system flexibility
Created 5 comprehensive test scenarios:
1. test_vertical_layout.json - Traditional N/S stacking
2. test_horizontal_layout.json - E/W connections
3. test_complex_multidirection.json - All four directions
4. test_multiple_connections.json - Multiple doors per direction
5. test_mixed_room_sizes.json - Different room sizes (1×1, 1×2, 2×2 GU)
Added TEST_SCENARIOS_README.md documenting:
- Grid system overview and room size specifications
- Detailed test scenario descriptions with layout diagrams
- Testing procedures and validation checks
- Expected console output examples
- Troubleshooting guide
Note: Scenarios reference hall_1x2gu.json and small_room_1x1gu.json which
need to be created in assets/rooms/. Currently using 2×2 GU placeholders.
All test scenarios include:
- Visual layout diagrams in scenario_brief
- Progressive difficulty with locks and keys
- Documentation of what each scenario tests
- Notes explaining grid system concepts
- Export calculateDoorPositionsForRoom from doors.js for reuse
- Import and use shared function in collision.js
- Remove duplicate door positioning logic (130+ lines)
- Ensures perfect alignment between door sprites and wall tile removal
- Both systems now use identical door placement calculations
This eliminates code duplication and guarantees that wall tiles are
removed at exactly the same positions where door sprites are created.
- Add grid unit constants (5x4 tiles) to constants.js
- Create comprehensive grid conversion helper functions
- Implement 4-direction room positioning (N/S/E/W) with breadth-first algorithm
- Add door placement functions with CRITICAL fixes:
* Negative modulo fix: ((sum % 2) + 2) % 2 for deterministic placement
* Asymmetric alignment fix: single-door rooms align with multi-door rooms
* Consistent grid alignment using Math.floor() for negative coordinates
- Rewrite calculateRoomPositions to support variable room sizes
- Update createDoorSpritesForRoom to use new placement system
- Store room dimensions globally for cross-system access
This implements the comprehensive room layout redesign as specified in
planning_notes/new_room_layout with all critical fixes from review2.
Addresses: Variable room sizes, proper door alignment, and grid-based positioning
- Updated door sprite creation to support lock properties from both doors and connected rooms.
- Added RFID cloner interaction logic to handle minigame initiation from inventory.
- Implemented inventory variable synchronization for NPC conversations, including RFID card details.
- Introduced new scenarios for RFID guards with varying security levels and interactions.
- Revised test scenarios to include comprehensive RFID protocol testing with detailed notes and NPC interactions.
Added three review documents analyzing the completed RFID system:
- POST_IMPLEMENTATION_REVIEW.md: Full technical analysis of implementation
- Reviewed 4 core files, 6 integration points, CSS, and test scenario
- Found 0 critical issues, 2 medium priority improvements (optional)
- Confirmed production-ready status
- Verified correct conversation return pattern
- Validated EM4100 protocol implementation
- ISSUES_SUMMARY.md: Quick reference for identified issues
- 7 total issues (all minor/optional)
- Action items with code examples
- Testing checklist
- README.md: Review overview and quick status
Key findings:
✅ Clean modular architecture following established patterns
✅ Authentic Flipper Zero UI with smooth animations
✅ Robust error handling and validation
✅ Seamless integration with all game systems
✅ Comprehensive test scenario created
Recommended improvements (optional):
- Use hex ID for key_id to prevent collisions
- Add cardToClone validation in clone mode
- Extract timing constants for maintainability
Overall assessment: Production ready with minor improvements recommended
Created proper Ink source file for Security Guard NPC:
Ink Story File:
- Created scenarios/ink/rfid-security-guard.ink (proper Ink format)
- Follows equipment-officer.ink pattern
- Uses # speaker:npc and # speaker:player tags
- Implements hub dialogue structure
- Contains clone_keycard tag: # clone_keycard:Master Keycard|FF4A7B9C21
- Multiple dialogue branches and paths
Story Structure:
- start knot → hub knot
- ask_keycard knot with multiple choices
- cloned knot for post-clone conversation
- Proper conversation flow with END points
Removed:
- Deleted placeholder rfid-security-guard.json (incorrect format)
- JSON must be compiled from .ink source using inklecate or Inky
Updated README:
- Added compilation instructions section
- Option 1: Inky editor (recommended, GUI)
- Option 2: inklecate command line
- Warning that .json needs compilation before use
- Links to download tools
The .ink file is the source of truth and must be compiled to .json
before the scenario will work properly.
Fixed test scenario to match reference format from npc-sprite-test2.json:
JSON Format Changes:
- Changed holdsItems → itemsHeld (correct property name)
- Changed storyJSON → storyPath (points to Ink file)
- Added position: { x, y } for NPC placement
- Changed map → type for room definition
- Added connections object for room linking
- Added readable: true to notes objects
- Added observations field to all items
- Added scenario_brief field
- Removed description field from doors
New Ink Story File:
- Created scenarios/ink/rfid-security-guard.json
- Security Guard conversation with clone_keycard tag
- Multiple dialogue branches
- Proper Ink JSON format with content array
NPC Configuration:
- Security Guard at position {x: 6, y: 4}
- Uses hacker-red sprite with idle animation
- Holds Master Keycard in itemsHeld
- References rfid-security-guard.json story
- Starts at 'start' knot
Test scenario now fully compatible with game's scenario loading system.
Created complete test scenario to demonstrate all RFID functionality:
Test Scenario Features:
- Two rooms: Test Lobby and Secure Room
- RFID-locked door requiring master keycard
- 3 different keycards with different access levels
Items in Test Lobby:
- Employee Badge (physical keycard, wrong access level)
- Flipper Zero (RFID cloner device)
- Security Notice (instructions)
NPC in Test Lobby:
- Security Guard with Master Keycard in holdsItems
- Conversation includes clone_keycard tag
- Can clone their badge during conversation
RFID-Locked Door:
- Requires master_keycard (guard's badge)
- Employee badge won't work (tests wrong card)
- Must clone and emulate guard's badge
Secure Room Contents:
- Success note (congratulations message)
- CEO Keycard (tests inventory click cloning)
Test Coverage:
✓ Pick up physical keycard and cloner
✓ Try wrong keycard (access denied)
✓ Clone card from NPC conversation (with return)
✓ Save cloned card to Flipper Zero
✓ Emulate saved card to unlock door
✓ Clone card by clicking in inventory
✓ Multiple saved cards management
All hex IDs are valid EM4100 format:
- Employee: 01AB34CD56 (facility 1, card 43981)
- Master: FF4A7B9C21 (facility 255, card 18811)
- CEO: FFAA55CC33 (facility 255, card 43597)
Includes detailed README with test procedure and troubleshooting.
Integrated RFID minigame into all game systems:
Chat System Integration:
- Added clone_keycard tag handler to chat-helpers.js
- Format: # clone_keycard:Card Name|HEX_ID
- Uses proven window.pendingConversationReturn pattern
- Automatically returns to conversation after cloning
Inventory Integration:
- Added keycard click handler in interactions.js
- Click keycard with cloner → starts clone mode
- Shows alert if no cloner available
Interaction Indicator:
- Added RFID icon support to getInteractionSpriteKey()
- RFID-locked doors/items show rfid-icon overlay
- Works for both door and item lock types
HTML Integration:
- Added rfid-minigame.css link to index.html
- Loaded alongside other minigame styles
Phaser Asset Integration:
- Added keycard sprites (base + 3 variants)
- Added rfid_cloner sprite
- Added rfid-icon and nfc-waves icons
- Loaded in js/core/game.js preload
All integration follows existing patterns from other minigames.
Ready for testing and asset creation.
Fix NPC interaction and event handling issues
- Added a visual problem-solution summary for debugging NPC event handling.
- Resolved cooldown bug in NPCManager by implementing explicit null/undefined checks.
- Modified PersonChatMinigame to prioritize event parameters over state restoration.
- Updated security guard dialogue in Ink scenarios to improve interaction flow.
- Adjusted vault key parameters in npc-patrol-lockpick.json for consistency.
- Changed inventory stylesheet references to hud.css in test HTML files for better organization.
feat(combat): Integrate chair kicking with punch mechanic
Update chair interaction to use the punch system instead of direct kicking:
**Changes to interactions.js:**
- Modified swivel chair interaction to trigger player punch instead of
directly applying kick velocity
- Simplified chair interaction handler to just call playerCombat.punch()
**Changes to player-combat.js:**
- Extended checkForHits() to detect chairs in punch range and direction
- Added kickChair() method that applies the same velocity calculation:
- Calculates direction from player to chair
- Applies 1200 px/s kick force in that direction
- Triggers spin direction calculation for visual rotation
- Adds visual feedback (flash chair, light screen shake)
- Chairs now respond to punch AOE damage like hostile NPCs
Now clicking a chair or pressing 'E' near it triggers a punch, and if the
chair is in punch range and facing direction, it gets kicked with the
original velocity physics. Multiple chairs can be kicked with one punch.
feat(combat): Implement hostile NPC behavior and final integration (Phase 6-7)
Complete hostile NPC combat system with chase behavior and integration:
**Phase 6: Hostile NPC Behavior**
- Modified npc-behavior.js determineState() to check hostile state from npcHostileSystem
- Implemented updateHostileBehavior() with chase and attack logic:
- NPCs chase player when hostile and in aggro range
- NPCs stop and attack when in attack range
- NPCs use directional movement with proper animations
- Integration with npcCombat system for attack attempts
- Added KO state check to prevent KO'd NPCs from acting
**Phase 7: Final Integration**
- Modified player.js to disable movement when player is KO
- Added visual KO effect (50% alpha) to NPC sprites in npc-hostile.js
- Connected all combat systems end-to-end:
- Ink dialogue → hostile tag → hostile state → chase behavior → combat
- Player interaction → punch → NPC damage → KO → visual feedback
- NPC chase → attack → player damage → HP UI → game over
Full combat loop now functional: hostile NPCs chase and attack player,
player can punch hostile NPCs, complete visual/audio feedback, game over on KO.
feat(combat): Add feedback, UI, and combat mechanics (Phase 2-5)
Implement comprehensive combat feedback, UI, and mechanics:
**Phase 2: Enhanced Feedback Systems**
- damage-numbers.js: Floating damage numbers with object pooling
- screen-effects.js: Screen flash and shake for combat feedback
- sprite-effects.js: Sprite tinting, flashing, and visual effects
- attack-telegraph.js: Visual indicators for incoming NPC attacks
**Phase 3: UI Components**
- health-ui.js: Player health display as hearts (5 hearts, shows when damaged)
- npc-health-bars.js: Health bars above hostile NPCs with color coding
- game-over-screen.js: KO screen with restart/main menu options
**Phase 4-5: Combat Mechanics**
- player-combat.js: Player punch system with AOE directional damage
- npc-combat.js: NPC attack system with telegraph and cooldowns
- Modified interactions.js to trigger punch on hostile NPC interaction
- Integrated all systems into game.js create() and update() loops
Combat now functional with complete visual/audio feedback pipeline.
Player can punch hostile NPCs, NPCs can attack player, health tracking works.
feat(combat): Add hostile NPC system foundation (Phase 0-1)
Implement core hostile NPC combat system infrastructure:
- Add #hostile tag handler to chat-helpers.js for Ink integration
- Fix security-guard.ink to use proper hub pattern with -> hub instead of -> END
- Add #hostile:security_guard tags to hostile conversation paths
- Create combat configuration system (combat-config.js)
- Create combat event constants (combat-events.js)
- Implement player health tracking system with HP and KO state
- Implement NPC hostile state management with HP tracking
- Add combat debug utilities for testing
- Add error handling utilities for validation
- Integrate combat systems into game.js create() method
- Create test-hostile.ink for testing hostile tag system
This establishes the foundation for hostile NPC behavior, allowing NPCs to
become hostile through Ink dialogue and tracking health for both player and NPCs.
docs(npc): Apply codebase-verified corrections to hostile NPC plans
Apply critical corrections based on actual codebase verification:
CORRECTIONS.md (Updated):
- ✅ Confirms #exit_conversation tag ALREADY IMPLEMENTED
* Location: person-chat-minigame.js line 537
* No handler needed in chat-helpers.js
- ❌ Hostile tag still needs implementation in chat-helpers.js
- Provides exact code for hostile tag handler
- Clarifies tag format: #hostile:npcId or #hostile (uses current NPC)
- Updated action items to reflect what's already working
INTEGRATION_UPDATES.md (New):
- Comprehensive correction document
- Issue 1 Corrected: Exit conversation already works
- Issue 6 Corrected: Punch mechanics are interaction-based with AOE
- Details interaction-based punch targeting:
* Player clicks hostile NPC OR presses 'E' nearby
* Punch animation plays in facing direction
* Damage applies to ALL NPCs in range + direction (AOE)
* Can hit multiple enemies if grouped (strategic gameplay)
- Provides complete implementation examples
- Removes complexity of target selection systems
- Uses existing interaction patterns
quick_start.md (Updated):
- Removed exit_conversation handler (already exists)
- Updated hostile tag handler code
- Added punch mechanics design section
- Clarified interaction-based targeting
- Added troubleshooting for exit_conversation
Key Findings:
✅ Exit conversation tag works out of the box
✅ Punch targeting uses existing interaction system (simpler!)
✅ AOE punch adds strategic depth without complexity
❌ Only ONE critical task remains: Add hostile tag to chat-helpers.js
Impact:
- Less work required (don't need exit_conversation handler)
- Simpler implementation (use existing interaction patterns)
- Better gameplay (AOE punches, directional attacks)
- Clear path forward with exact code examples
docs(npc): Add critical corrections and codebase integration review
Add comprehensive review of hostile NPC plans against actual codebase:
CORRECTIONS.md:
- Identifies critical Ink pattern error (-> END vs -> hub)
- Documents correct hub-based conversation pattern
- Provides corrected examples for all Ink files
- Explains why -> hub is required after #exit_conversation
FORMAT_REVIEW.md:
- Validates JSON scenario format against existing scenarios
- Reviews NPC object structure and required fields
- Documents correct Ink hub pattern from helper-npc.ink
- Proposes hostile configuration object for NPC customization
- Provides complete format reference and checklists
review2/integration_review.md:
- Comprehensive codebase analysis by Explore agent
- Identifies 2 critical blockers requiring immediate attention:
* Missing tag handlers for #hostile and #exit_conversation
* Incorrect Ink pattern (-> END) in planning documents
- Documents 4 important integration differences:
* Initialization in game.js not main.js
* Event dispatcher already exists (window.eventDispatcher)
* Room transition behavior needs design decision
* Multi-hostile NPC targeting needs design decision
- Confirms 8 systems are fully compatible with plan
- Provides existing code patterns to follow
- Corrects integration sequence
review2/quick_start.md:
- Step-by-step guide for Phase 0-1 implementation
- Includes complete code examples for critical systems
- Browser console test procedures
- Common issues and solutions
- Success criteria checklist
Key Findings:
✅ 90% compatible with existing codebase
❌ Must add tag handlers to chat-helpers.js before implementation
❌ Must fix all Ink examples to use -> hub not -> END
⚠️ Should follow game.js initialization pattern not main.js
⚠️ Should use existing window.eventDispatcher
⚠️ Need design decisions on room transitions and multi-targeting
All critical issues documented with solutions ready.
Implementation can proceed with high confidence after corrections applied.
docs(npc): Add comprehensive planning documents for hostile NPC system
Add detailed implementation plans for hostile NPC feature including:
- Complete implementation plan with phase-by-phase breakdown
- Architecture overview with system diagrams and data flows
- Detailed TODO list with 200+ actionable tasks
- Phase 0 foundation with design decisions and base components
- Enhanced combat feedback implementation guide
- Implementation roadmap with 6-day schedule
Add comprehensive review documents:
- Implementation review with risk assessment and recommendations
- Technical review analyzing code patterns and best practices
- UX review covering player experience and game feel
Key features planned:
- NPC hostile state triggered via Ink tags
- Player health system with heart-based UI
- NPC health bars and combat mechanics
- Punch combat for both player and NPCs
- Strong visual/audio feedback for combat
- Game over system and KO states
- Attack telegraphing for fairness
- Enhanced NPC chase behavior with LOS
- Debug utilities and error handling
- Comprehensive testing strategy
- Created TITLE_SCREEN_CUSTOMIZATION.md with examples for extending the title screen.
- Added TITLE_SCREEN_DEVELOPER_GUIDE.md for technical guidance on implementation.
- Introduced TITLE_SCREEN_IMPLEMENTATION.md detailing the architecture and features.
- Compiled TITLE_SCREEN_INDEX.md as a documentation index for easy navigation.
- Updated TITLE_SCREEN_OVERLAY_UPDATE.md to reflect changes in title screen display mode.
- Created TITLE_SCREEN_QUICK_START.md for a quick setup guide.
- Developed TITLE_SCREEN_README.md as a comprehensive overview of the title screen system.
- Added title-screen-demo.json scenario to demonstrate title screen functionality.
- Modified existing files to integrate the title screen into the game flow.
- Deleted the `CUTSCENE_IMPROVEMENTS.md` file as it contained outdated information.
- Refactored the game canvas visibility management in `game.js` and `minigame-manager.js` to streamline the handling of cut-scene visibility.
- Updated `PersonChatMinigame` to simplify the handling of the `canEscConversation` parameter.
- Adjusted `NPCManager` to pass relevant parameters for minigame initialization without relying on deprecated settings.
- Added functionality to hide the main game canvas and inventory during minigames based on scenario settings.
- Enhanced the MinigameFramework to track and manage visibility states for the game canvas and inventory.
- Updated PersonChatMinigame to conditionally hide close and cancel buttons based on the new `canEscConversation` parameter.
- Modified NPCManager to pass new parameters for minigame initialization, including visibility and conversation settings.
- Updated scenario configuration to support hiding the game during minigames and disabling escape key functionality.
- Deleted outdated quick reference file and replaced it with a comprehensive LOS visualization guide.
- Updated console commands for enabling/disabling LOS and added detailed explanations for visual elements.
- Improved console output for distance and angle checks during NPC detection.
- Introduced new test functions for graphics rendering and system status checks.
- Enhanced logging during LOS cone drawing to provide detailed graphics object properties and rendering status.
- Created new documentation files for quick commands and debugging improvements.
- Added a structured troubleshooting flow for common issues related to LOS detection and rendering.
