Refactor battle simulation instructions to create a basic arena display system and enhance project setup guidelines

Author: DanWahlin

Adventures/Agent/3-Advanced/The-Gridlock-Arena-of-Mythos-Agent.md

@@ -70,159 +70,175 @@ Now let's define the requirements for the arena battle simulation so that you ca
 
 ### Using Agent Mode to Solve the Adventure
 
-#### Step 1: Give Agent Mode a High-Level Task
+#### Step 1: Create Basic Arena and Display System
 
-In the Chat panel with "Agent" mode selected, provide a comprehensive prompt like:
+In the Chat panel with "Agent" mode selected, start with this focused prompt. Replace `[ADD YOUR TARGET LANGUAGE]` in the **Project Setup** section with your preferred programming language.
 
 ```
-Create a complete Gridlock Arena battle simulation system for the mystical land of Mythos. The system should:
-
-1. **Project Setup**:
-   - Create a console application in your preferred language
-   - Single file implementation for simplicity (e.g., `The-Gridlock-Arena-of-Mythos.js`)
-   - Use modern module/import system for your chosen language
-   - Follow current best practices for project structure and dependencies
-
-2. **Grid Arena Implementation**:
-   - 5x5 grid arena using a 2D array
-   - Grid coordinates: [row, column] where [0,0] is top-left
-   - Visual representation using Unicode characters:
-     - ⬜️ for empty cells
-     - Creature icons for occupied positions
-     - 🤺 for battle locations where creatures fought
-
-3. **Creature Data Structure** (exactly as specified):
-   Each creature must have these properties:
-   - **name**: String identifier for the creature
-   - **start**: Starting position as [row, column] coordinates
-   - **moves**: Array of movement directions in sequence
-   - **power**: Integer representing battle strength
-   - **icon**: Unicode emoji for visual representation
-
-   **Required Creatures** (in this exact order):
-   | Name   | Start Position | Move Sequence           | Power | Icon |
-   |--------|---------------|-------------------------|-------|------|
-   | Dragon | [0, 0]        | ["RIGHT", "DOWN", "RIGHT"] | 7     | 🐉   |
-   | Goblin | [0, 2]        | ["LEFT", "DOWN", "LEFT"]   | 3     | 👺   |
-   | Ogre   | [2, 0]        | ["UP", "RIGHT", "DOWN"]    | 5     | 👹   |
-   | Troll  | [2, 2]        | ["UP", "LEFT", "UP"]       | 4     | 👿   |
-   | Wizard | [4, 1]        | ["UP", "UP", "LEFT"]       | 6     | 🧙   |
-
-4. **Movement System** (CRITICAL - Follow This Exact Sequence):
-   - Direction mapping: UP=[-1,0], DOWN=[1,0], LEFT=[0,-1], RIGHT=[0,1]
-   - All creatures move simultaneously each round using their NEXT move in sequence
-   - Move indexing: Move 1 uses index 0, Move 2 uses index 1, Move 3 uses index 2
-   - Boundary checking: creatures cannot move outside the 5x5 grid (clamp to boundaries)
-   - After 3 moves, all creatures complete their movement sequences
-
-5. **Battle Mechanics** (critical implementation details):
-   - When multiple creatures move to the same cell, they battle
-   - Battle resolution: creature with highest power wins
-   - Winner earns points equal to the sum of ALL defeated creatures' power values
-   - ALL defeated creatures are immediately eliminated from the arena
-   - If multiple creatures have the same highest power, ALL battling creatures are eliminated
-   - Multiple separate battles can occur in the same round at different locations
-
-6. **Scoring System**:
-   - Initialize all creatures with 0 points
-   - Winners gain points equal to defeated creatures' power
-   - Defeated creatures remain at 0 points
-   - Score format includes creature icons: "🐉 Dragon: 12"
-
-7. **Game Flow**:
-   - Display "Initial Board" first (shows starting positions)
-   - Then "Move 1", "Move 2", "Move 3" for each subsequent round
-   - Game ends when all moves are completed or no creatures remain
-   - Track active creatures (remove defeated ones from processing)
-
-8. **Required Output Format** (Match This Exactly):
-   ```
-   Initial Board
-   🐉 ⬜️ 👺 ⬜️ ⬜️
-   ⬜️ ⬜️ ⬜️ ⬜️ ⬜️
-   👹 ⬜️ 👿 ⬜️ ⬜️
-   ⬜️ ⬜️ ⬜️ ⬜️ ⬜️
-   ⬜️ 🧙 ⬜️ ⬜️ ⬜️
-   Scores: {
-     '🐉 Dragon': 0,
-     '👺 Goblin': 0,
-     '👹 Ogre': 0,
-     '👿 Troll': 0,
-     '🧙 Wizard': 0
-   }
-   -----
-   ```
-
-9. **Movement Verification** (CRITICAL - Use This to Debug):
-   Verify your movement logic produces these positions:
-   
-   **Move 1**: Dragon: [0,1], Goblin: [0,1], Ogre: [1,0], Troll: [1,2], Wizard: [3,1]
-   - Battle at [0,1]: Dragon (7) defeats Goblin (3) → Dragon gains 3 points
-   
-   **Move 2**: Dragon: [1,1], Ogre: [1,1], Troll: [1,1], Wizard: [2,1]  
-   - Battle at [1,1]: Dragon (7) defeats Ogre (5) and Troll (4) → Dragon gains 9 points (total: 12)
-   
-   **Move 3**: Dragon: [1,2], Wizard: [2,0]
-   - No battles, both creatures survive
-
-10. **Expected Final Results**:
-    - Dragon: 12 points (defeats Goblin for 3 points in Move 1, then defeats Ogre and Troll for 9 points in Move 2)
-    - Wizard: 0 points (survives all battles)
-    - All other creatures: 0 points (defeated)
-    - Final output: { '🐉 Dragon': 12, '👺 Goblin': 0, '👹 Ogre': 0, '👿 Troll': 0, '🧙 Wizard': 0 }
-
-11. **Technical Implementation Requirements**:
-    - Use proper separation between calculation phase (determine new positions) and application phase (resolve battles, update positions)
-    - Clear the grid each round and rebuild it with current creature positions
-    - Group creatures by destination position to detect collisions
-    - Handle multi-creature battles correctly (not just 2-creature battles)
-    - Use modern language features and follow current coding standards
-    - **Algorithm Flow**: Display initial board → For each move: calculate new positions → resolve battles → update grid → display results
-
-12. **Code Quality**:
-    - Include comprehensive error handling and documentation
-    - Create unit tests to ensure 100% test coverage
-    - Make the code efficient and maintainable
-    - Use clear, descriptive function and variable names
-    - Structure code with proper module exports/imports for testability
-    - Include build/run scripts appropriate for your chosen language
-    - Follow modern coding standards and best practices for your language
-
-**Language-Specific Modern Practices** (choose what applies):
-- **JavaScript/Node.js**: Use ES6 modules (import/export), create package.json with "type": "module"
-- **Python**: Use modern Python with proper function definitions and data structures
-- **C#**: Use modern C# features, records, enums, and proper class structure
-- **Other languages**: Apply equivalent modern standards and tooling
-
-**Critical Implementation Notes for All Languages**:
-- Movement timing is crucial: render Initial Board first, then process each move and render results
-- Battle resolution must handle multi-creature collisions correctly
-- Score display should include creature emojis in quoted format
-- Final output should match the expected battle timing exactly
-
-IMPORTANT: If your output doesn't match the expected battle results in section 9, debug your movement logic. The battle timing is critical for the educational value of this adventure.
+Create a basic arena display system for the Gridlock Arena of Mythos. Focus only on the foundational elements:
+
+**Project Setup**:
+- Create a new folder called "The-Gridlock-Arena-of-Mythos" for this project
+- Create a console application using [ADD YOUR TARGET LANGUAGE].
+- Use a single main file implementation for simplicity (example: `The-Gridlock-Arena-of-Mythos.js`, `the_gridlock_arena_of_mythos.py`, `GridlockArenaOfMythos.cs`, etc.)
+- Use modern language features and best practices for your chosen language
+
+**Arena Implementation**:
+- 5x5 grid arena using a 2D array/matrix
+- Grid coordinates: [row, column] where [0,0] is top-left
+- Visual representation: ⬜️ for empty cells, creature icons for occupied positions
+
+**Creature Data Structure** (exactly as specified):
+Each creature should have these properties:
+- **name**: String identifier for the creature
+- **start**: Starting position as [row, column] coordinates  
+- **moves**: Array/list of movement directions in sequence
+- **power**: Integer representing battle strength
+- **icon**: Unicode emoji for visual representation
+
+**Required Creatures Data**:
+| Name   | Start Position | Move Sequence           | Power | Icon |
+|--------|---------------|-------------------------|-------|------|
+| Dragon | [0, 0]        | ["RIGHT", "DOWN", "RIGHT"] | 7     | 🐉   |
+| Goblin | [0, 2]        | ["LEFT", "DOWN", "LEFT"]   | 3     | 👺   |
+| Ogre   | [2, 0]        | ["UP", "RIGHT", "DOWN"]    | 5     | 👹   |
+| Troll  | [2, 2]        | ["UP", "LEFT", "UP"]       | 4     | 👿   |
+| Wizard | [4, 1]        | ["UP", "UP", "LEFT"]       | 6     | 🧙   |
+
+**Required Output**:
+
+Initial Board
+🐉 ⬜️ 👺 ⬜️ ⬜️
+⬜️ ⬜️ ⬜️ ⬜️ ⬜️
+👹 ⬜️ 👿 ⬜️ ⬜️
+⬜️ ⬜️ ⬜️ ⬜️ ⬜️
+⬜️ 🧙 ⬜️ ⬜️ ⬜️
+Scores: {
+  '🐉 Dragon': 0,
+  '👺 Goblin': 0,
+  '👹 Ogre': 0,
+  '👿 Troll': 0,
+  '🧙 Wizard': 0
+}
+-----
+
+**Success Criteria**: The app should run and display the initial arena with creatures in their starting positions and all scores at 0.
+```
+
+#### Step 2: Add Movement System
+
+Once Step 1 works, enhance the application with movement logic by adding this next prompt in Agent Mode:
+
 ```
+Add the movement system to your arena. Build on your existing code:
 
-#### Step 2: Watch Agent Mode Work
+**Movement Implementation**:
+- Direction mapping: UP=[-1,0], DOWN=[1,0], LEFT=[0,-1], RIGHT=[0,1]
+- Boundary checking: creatures cannot move outside the 5x5 grid (clamp to boundaries)
+- All creatures move simultaneously each round using their next move in sequence  
+- Display board state after each move (Move 1, Move 2, Move 3)
 
-Agent Mode will autonomously:
-- 🔍 **Analyze** your workspace and determine what files to create
-- 📁 **Create** the necessary project structure
-- 💻 **Write** the complete application code
-- 🧪 **Test** the application by running it
-- 🔧 **Fix** any issues that arise automatically
+**Movement Logic**:
+- Move 1: All creatures use moves[0], Move 2: moves[1], Move 3: moves[2]
+- Update creature positions but don't worry about battles yet
+- Just show creatures moving to their new positions
 
-You'll see each step in the UI, showing every tool invocation.
+**Expected Positions** (for verification):
+- **Move 1**: Dragon: [0,1], Goblin: [0,1], Ogre: [1,0], Troll: [1,2], Wizard: [3,1]
+- **Move 2**: Dragon: [1,1], Ogre: [1,1], Troll: [1,1], Wizard: [2,1]  
+- **Move 3**: Dragon: [1,2], Wizard: [2,0]
+
+**Success Criteria**: Creatures should move correctly through their sequences, respecting boundaries, and display after each move.
+```
+
+#### Step 3: Implement Battle Mechanics and Scoring
+
+Add the combat system to your working movement code:
+
+```
+Implement the battle system and scoring for your arena. Build on your existing movement code:
+
+**Battle Mechanics**:
+- When multiple creatures move to the same cell, they battle
+- Battle resolution: creature with highest power wins
+- Winner earns points equal to the sum of ALL defeated creatures' power values
+- ALL defeated creatures are immediately eliminated from the arena
+- If multiple creatures have the same highest power, ALL battling creatures are eliminated
+- Multiple separate battles can occur in the same round at different locations
+
+**Battle Visualization**:
+- Show 🤺 icon where battles occur
+- Remove defeated creatures from subsequent moves
+- Update scores immediately after each battle
+
+**Enhanced Output Format** (optional but recommended):
+For each movement round, display creature movements and battle results using this general format:
+
+📍 Creatures that moved this round:
+   🐉 Dragon → [0, 1]
+   👺 Goblin → [0, 1]
+   👹 Ogre → [1, 0]
+   👿 Troll → [1, 2]
+   🧙 Wizard → [3, 1]
+⚔️  BATTLE RESULT at (0, 1):
+   🏆 Winner: 🐉 Dragon (Power: 7) +3 points
+   💀 Defeated:
+      ☠️  👺 Goblin (Power: 3)
+
+**Expected Battle Results**:
+- **Move 1**: Dragon (7) defeats Goblin (3) at [0,1] → Dragon gains 3 points
+- **Move 2**: Dragon (7) defeats Ogre (5) and Troll (4) at [1,1] → Dragon gains 9 more points (total: 12)
+- **Move 3**: Dragon and Wizard survive, no battles
+
+**Final Expected Scores**:
+{
+  '🐉 Dragon': 12,
+  '👺 Goblin': 0,
+  '👹 Ogre': 0,
+  '👿 Troll': 0,
+  '🧙 Wizard': 0
+}
+
+**Success Criteria**: Full battle simulation with correct battle resolution and final scores matching expected results.
+```
+
+#### Step 4: Add Testing and Polish
+
+Enhance your working application with testing and production-ready features. No specific testing library is required, but you can update the prompt to use a language specific testing framework if you'd prefer.
+
+```
+Add comprehensive testing and polish to your completed battle simulation:
+
+**Testing Requirements**:
+- Create unit tests for all major functions (movement, battles, scoring) in a separate test file
+- Test edge cases (boundary conditions, ties, single creatures)
+- Ensure comprehensive test coverage
+- Create a separate test file using your language's testing framework
+
+**Code Quality Improvements**:
+- Add comprehensive error handling and input validation
+- Include documentation/comments for all functions
+- Structure code with proper organization and modularity
+- Add a demo script showing different battle scenarios
+
+**Production Features**:
+- Add the ability to run custom creature battles
+- Include detailed console output and final battle results
+- Handle edge cases gracefully (invalid input, empty battles, etc.)
+- Format final scores display with emojis and proper styling
+
+**Success Criteria**: Complete, tested, production-ready application with comprehensive test suite and clean, maintainable code structure.
+```
 
-#### Step 3: Interact and Refine
+#### Step 5: Interact and Refine
 
 As Agent Mode works, you can:
 - **Approve or modify** proposed changes
 - **Ask for improvements**: "Can you add special abilities for each creature type?"
 - **Request explanations**: "Explain how the collision detection algorithm works"
 - **Add features**: "Add support for larger grids and more creature types"
 
-#### Step 4: Explore Advanced Features
+#### Step 6: Explore Advanced Features
 
 Once your basic system works, try asking Agent Mode to:
 
@@ -240,7 +256,7 @@ Enhance the Gridlock Arena system with these advanced features:
 
 ### Expected Output
 
-When your Agent Mode implementation is complete, running the application should produce output similar to the following. AI is non-deterministic, so your results may vary slightly, but the structure should be similar.
+When your Agent Mode implementation is complete, running the application should produce output similar to the following. AI is non-deterministic and the code that is generated will depend upon the model used, so your results may vary.
 
 ```
 Initial Board
@@ -326,7 +342,7 @@ The battle has concluded! May the strongest creature be victorious!
 
 #### Leverage Agent Mode's Autonomy
 
-1. **Let it work**: Allow Agent Mode to complete multi-step tasks without interruption
+1. **Let it work**: Allow Agent Mode to complete multi-step tasks without interruption (unless you need to refine)
 2. **Review and approve**: Check the proposed changes before they're applied
 3. **Iterate naturally**: Ask for improvements or modifications as needed
 4. **Learn from the process**: Observe how Agent Mode structures and solves problems