diff --git a/ai_animation/CLAUDE.md b/ai_animation/CLAUDE.md
new file mode 100644
index 0000000..c6df903
--- /dev/null
+++ b/ai_animation/CLAUDE.md
@@ -0,0 +1,46 @@
+# AI Diplomacy Animation Project
+
+## Key Information
+- This is a TypeScript project using Three.js for 3D visualization of Diplomacy game states
+- The application shows animated conversations between AI players and unit movements
+- It's built with Vite for fast development
+
+## Common Commands
+- `npm run dev` - Start the development server
+- `npm run build` - Build for production
+- `npm run lint` - Run TypeScript linting
+
+## Project Structure
+- `src/` - Source code
+  - `main.ts` - Main entry point, handles game loop and UI events
+  - `gameState.ts` - Central state management for the application
+  - `config.ts` - Global configuration settings
+  - `domElements/` - DOM manipulation and UI components
+  - `map/` - Map rendering and manipulation
+  - `units/` - Unit creation and animation
+  - `types/` - TypeScript type definitions
+
+## Game Flow
+1. Load game data from JSON
+2. Display initial phase
+3. When Play is clicked:
+   - Show messages sequentially, one word at a time
+   - When all messages are displayed, animate unit movements
+   - When animations complete, show phase summary (if available)
+   - Advance to next phase and repeat
+
+## Known Issues
+- Text-to-speech requires an ElevenLabs API key in `.env` file
+- Unit animations sometimes don't fire properly after messages
+- Debug mode may cause some animations to run too quickly
+
+## Data Format Notes
+- The game data's "orders" field can be either an array or an object in the JSON
+- The schema automatically converts object-format orders to array format for use in the code
+- When debugging order issues, check the format in the original JSON
+
+## Code Style Preferences
+- Use descriptive function and variable names
+- Add JSDoc comments for all exported functions
+- Log important state transitions to console
+- Use TypeScript types for all parameters and return values
\ No newline at end of file
diff --git a/ai_animation/package.json b/ai_animation/package.json
index 431f9d7..d1b4703 100644
--- a/ai_animation/package.json
+++ b/ai_animation/package.json
@@ -17,5 +17,6 @@
     "@types/three": "^0.174.0",
     "three": "^0.174.0",
     "zod": "^3.24.2"
-  }
+  },
+  "packageManager": "pnpm@9.12.2+sha512.22721b3a11f81661ae1ec68ce1a7b879425a1ca5b991c975b074ac220b187ce56c708fe5db69f4c962c989452eee76c82877f4ee80f474cebd61ee13461b6228"
 }
diff --git a/ai_animation/src/config.ts b/ai_animation/src/config.ts
index f102d6f..3ce42cd 100644
--- a/ai_animation/src/config.ts
+++ b/ai_animation/src/config.ts
@@ -1,4 +1,16 @@
+/**
+ * Global configuration settings for the application
+ */
 export const config = {
-  playbackSpeed: 500, // Default speed in ms
-  isDebugMode: true
+  // Default speed in milliseconds for animations and transitions
+  playbackSpeed: 500, 
+  
+  // Whether to enable debug mode (faster animations, more console logging)
+  isDebugMode: true,
+  
+  // Duration of unit movement animation in ms
+  animationDuration: 1500,
+  
+  // How frequently to play sound effects (1 = every message, 3 = every third message)
+  soundEffectFrequency: 3
 }
diff --git a/ai_animation/src/domElements/chatWindows.ts b/ai_animation/src/domElements/chatWindows.ts
index b6ce9c8..2f4711e 100644
--- a/ai_animation/src/domElements/chatWindows.ts
+++ b/ai_animation/src/domElements/chatWindows.ts
@@ -1,6 +1,8 @@
 import * as THREE from "three";
 import { currentPower, gameState } from "../gameState";
 import { config } from "../config";
+import { createTweenAnimations } from "../units/animate";
+import { advanceToNextPhase } from "../phase";
 
 let faceIconCache = {}; // Cache for generated face icons
 
@@ -33,7 +35,7 @@ function createChatWindow(power, isGlobal = false) {
   const chatContainer = document.getElementById('chat-container');
   const chatWindow = document.createElement('div');
   chatWindow.className = 'chat-window';
-  chatWindow.id = `chat - ${power} `;
+  chatWindow.id = `chat-${power}`;
   chatWindow.style.position = 'relative'; // Add relative positioning for absolute child positioning
 
   // Create a slimmer header with appropriate styling
@@ -54,7 +56,7 @@ function createChatWindow(power, isGlobal = false) {
     titleElement.style.color = '#ffffff';
     titleElement.textContent = 'GLOBAL';
   } else {
-    titleElement.className = `power - ${power.toLowerCase()} `;
+    titleElement.className = `power-${power.toLowerCase()}`;
     titleElement.textContent = power;
   }
   titleElement.style.fontWeight = 'bold'; // Make text more prominent
@@ -74,7 +76,7 @@ function createChatWindow(power, isGlobal = false) {
   faceHolder.style.boxShadow = '0 2px 5px rgba(0,0,0,0.5)';
   faceHolder.style.border = '2px solid #fff';
   faceHolder.style.zIndex = '10'; // Ensure it's above other elements
-  faceHolder.id = `face - ${power} `;
+  faceHolder.id = `face-${power}`;
 
   // Generate the face icon and add it to the chat window (not header)
   generateFaceIcon(power).then(dataURL => {
@@ -82,9 +84,7 @@ function createChatWindow(power, isGlobal = false) {
     img.src = dataURL;
     img.style.width = '100%';
     img.style.height = '100%';
-    img.id = `face - img - ${power} `; // Add ID for animation targeting
-
-    img.id = `face - img - ${power} `; // Add ID for animation targeting
+    img.id = `face-img-${power}`; // Add ID for animation targeting
 
     // Add subtle idle animation
     setInterval(() => {
@@ -103,7 +103,7 @@ function createChatWindow(power, isGlobal = false) {
   // Create messages container
   const messagesContainer = document.createElement('div');
   messagesContainer.className = 'chat-messages';
-  messagesContainer.id = `messages - ${power} `;
+  messagesContainer.id = `messages-${power}`;
   messagesContainer.style.paddingTop = '8px'; // Add padding to prevent content being hidden under face
 
   // Add toggle functionality
@@ -129,12 +129,20 @@ function createChatWindow(power, isGlobal = false) {
 }
 
 // Modified to accumulate messages instead of resetting and only animate for new messages
-export function updateChatWindows(phase, stepMessages = false) {
+/**
+ * Updates chat windows with messages for the current phase
+ * @param phase The current game phase containing messages
+ * @param stepMessages Whether to animate messages one-by-word (true) or show all at once (false)
+ */
+export function updateChatWindows(phase: any, stepMessages = false) {
+  // Exit early if no messages
   if (!phase.messages || !phase.messages.length) {
+    console.log("No messages to display for this phase");
     gameState.messagesPlaying = false;
     return;
   }
 
+  // Only show messages relevant to the current player (sent by them, to them, or global)
   const relevantMessages = phase.messages.filter(msg => {
     return (
       msg.sender === currentPower ||
@@ -142,56 +150,122 @@ export function updateChatWindows(phase, stepMessages = false) {
       msg.recipient === 'GLOBAL'
     );
   });
+  
+  // Sort messages by time sent
   relevantMessages.sort((a, b) => a.time_sent - b.time_sent);
+  
+  // Log message count but only in debug mode to reduce noise
+  if (config.isDebugMode) {
+    console.log(`Found ${relevantMessages.length} messages for player ${currentPower} in phase ${phase.name}`);
+  }
 
   if (!stepMessages) {
-    // Normal: show all at once
+    // Normal mode: show all messages at once
     relevantMessages.forEach(msg => {
       const isNew = addMessageToChat(msg, phase.name);
       if (isNew) {
         // Increment message counter and play sound on every third message
         messageCounter++;
-        animateHeadNod(msg, (messageCounter % 3 === 0));
+        animateHeadNod(msg, (messageCounter % config.soundEffectFrequency === 0));
       }
     });
     gameState.messagesPlaying = false;
   } else {
-    // Stepwise
+    // Stepwise mode: show one message at a time, animating word-by-word
     gameState.messagesPlaying = true;
     let index = 0;
+    
+    // Store the start time for debugging
+    const messageStartTime = Date.now();
 
-    // Define the showNext function that will be called after each message animation completes
+    // Function to process the next message
     const showNext = () => {
-      if (index >= relevantMessages.length) {
+      // If we're not playing or user has manually advanced, stop message animation
+      if (!gameState.isPlaying && !config.isDebugMode) {
+        console.log("Playback stopped, halting message animations");
         gameState.messagesPlaying = false;
-        if (gameState.isAnimating && gameState.isPlaying && !gameState.isSpeaking) {
-          // Call the async function without awaiting it here
-          gameState.playbackTimer = setTimeout(() => advanceToNextPhase(), config.playbackSpeed);
+        return;
+      }
+
+      // All messages have been displayed
+      if (index >= relevantMessages.length) {
+        if (config.isDebugMode) {
+          console.log(`All messages displayed in ${Date.now() - messageStartTime}ms`);
+        }
+        
+        gameState.messagesPlaying = false;
+        
+        // Only proceed if we're in playback mode and not speaking
+        if (gameState.isPlaying && !gameState.isSpeaking) {
+          if (gameState.gameData && gameState.gameData.phases) {
+            const currentPhase = gameState.gameData.phases[gameState.phaseIndex];
+            
+            if (config.isDebugMode) {
+              console.log(`Processing end of phase ${currentPhase.name}`);
+            }
+
+            // Show summary first if available
+            if (currentPhase.summary?.trim()) {
+              addToNewsBanner(`(${currentPhase.name}) ${currentPhase.summary}`);
+            }
+
+            // Get previous phase for animations
+            const prevIndex = gameState.phaseIndex > 0 ? gameState.phaseIndex - 1 : null;
+            const previousPhase = prevIndex !== null ? gameState.gameData.phases[prevIndex] : null;
+
+            // Show animations for current phase's orders
+            if (previousPhase) {
+              if (config.isDebugMode) {
+                console.log(`Animating orders from ${previousPhase.name} to ${currentPhase.name}`);
+              }
+              createTweenAnimations(currentPhase, previousPhase);
+            }
+
+            // After animations complete, advance to next phase
+            gameState.playbackTimer = setTimeout(() => {
+              if (gameState.isPlaying) {
+                if (config.isDebugMode) {
+                  console.log(`Animations complete, advancing from ${currentPhase.name}`);
+                }
+                advanceToNextPhase();
+              }
+            }, config.playbackSpeed + config.animationDuration); // Wait for both summary and animations
+          }
         }
         return;
       }
 
+      // Get the next message
       const msg = relevantMessages[index];
-      index++; // Increment index before adding message so word animation knows the correct next message
+      
+      // Only log in debug mode to reduce console noise
+      if (config.isDebugMode) {
+        console.log(`Displaying message ${index + 1}/${relevantMessages.length}: ${msg.sender} to ${msg.recipient}`);
+      }
 
-      const isNew = addMessageToChat(msg, phase.name, true, showNext); // Pass showNext as callback
+      // Function to call after message animation completes
+      const onMessageComplete = () => {
+        index++; // Only increment after animation completes
+        
+        // Schedule next message with proper delay
+        setTimeout(showNext, config.playbackSpeed / 2);
+      };
 
-      if (isNew && !config.isDebugMode) {
-        // Increment message counter
+      // Add the message with word animation
+      const isNew = addMessageToChat(msg, phase.name, true, onMessageComplete);
+
+      // Handle non-new messages
+      if (!isNew) {
+        onMessageComplete(); // Skip animation for already seen messages
+      } else if (!config.isDebugMode) {
+        // Animate head and play sound for new messages
         messageCounter++;
-
-        // Only animate head and play sound for every third message
-        animateHeadNod(msg, (messageCounter % 3 === 0));
-      } else if (config.isDebugMode) {
-        // In debug mode, immediately call showNext to skip waiting for animation
-        showNext();
-      } else {
-        setTimeout(showNext, playbackSpeed * 3);
+        animateHeadNod(msg, (messageCounter % config.soundEffectFrequency === 0));
       }
     };
 
-    // Start the message sequence
-    showNext();
+    // Start the message sequence with initial delay
+    setTimeout(showNext, 50);
   }
 }
 
@@ -207,7 +281,7 @@ function addMessageToChat(msg, phaseName, animateWords = false, onComplete = nul
   if (!chatWindows[targetPower]) return false;
 
   // Create a unique ID for this message to avoid duplication
-  const msgId = `${msg.sender} -${msg.recipient} -${msg.time_sent} -${msg.message} `;
+  const msgId = `${msg.sender}-${msg.recipient}-${msg.time_sent}-${msg.message}`;
 
   // Skip if we've already shown this message
   if (chatWindows[targetPower].seenMessages.has(msgId)) {
@@ -287,7 +361,16 @@ function addMessageToChat(msg, phaseName, animateWords = false, onComplete = nul
 }
 
 // New function to animate message words one at a time
-function animateMessageWords(message, contentSpanId, targetPower, messagesContainer, onComplete) {
+/**
+ * Animates message text one word at a time
+ * @param message The full message text to animate
+ * @param contentSpanId The ID of the span element to animate within
+ * @param targetPower The power the message is displayed for
+ * @param messagesContainer The container holding the messages
+ * @param onComplete Callback function to run when animation completes
+ */
+function animateMessageWords(message: string, contentSpanId: string, targetPower: string, 
+                             messagesContainer: HTMLElement, onComplete: (() => void) | null) {
   const words = message.split(/\s+/);
   const contentSpan = document.getElementById(contentSpanId);
   if (!contentSpan) {
@@ -303,8 +386,9 @@ function animateMessageWords(message, contentSpanId, targetPower, messagesContai
   // Function to add the next word
   const addNextWord = () => {
     if (wordIndex >= words.length) {
-      // All words added - keep messagesPlaying true until next message starts
-
+      // All words added - message is complete
+      console.log(`Finished animating message with ${words.length} words in ${targetPower} chat`);
+      
       // Add a slight delay after the last word for readability
       setTimeout(() => {
         if (onComplete) {
@@ -324,8 +408,10 @@ function animateMessageWords(message, contentSpanId, targetPower, messagesContai
     contentSpan.textContent += words[wordIndex];
     wordIndex++;
 
-    // Schedule the next word with a delay based on word length and playback speed
-    const delay = Math.max(30, Math.min(120, config.playbackSpeed / 10 * (words[wordIndex - 1].length / 4)));
+    // Calculate delay based on word length and playback speed
+    // Longer words get slightly longer display time
+    const wordLength = words[wordIndex - 1].length;
+    const delay = Math.max(30, Math.min(120, config.playbackSpeed / 10 * (wordLength / 4)));
     setTimeout(addNextWord, delay);
 
     // Scroll to ensure newest content is visible
@@ -350,7 +436,7 @@ function animateHeadNod(msg, playSoundEffect = true) {
   if (!chatWindow) return;
 
   // Find the face image and animate it
-  const img = chatWindow.querySelector(`#face - img - ${targetPower} `);
+  const img = chatWindow.querySelector(`#face-img-${targetPower}`);
   if (!img) return;
 
   img.dataset.animating = 'true';
@@ -586,7 +672,7 @@ function playRandomSoundEffect() {
   const chosen = soundEffects[Math.floor(Math.random() * soundEffects.length)];
 
   // Create an <audio> and play
-  const audio = new Audio(`assets / sounds / ${chosen} `);
+  const audio = new Audio(`assets/sounds/${chosen}`);
   audio.play().catch(err => {
     // In case of browser auto-play restrictions, you may see warnings in console
     console.warn("Audio play was interrupted:", err);
@@ -597,10 +683,16 @@ function playRandomSoundEffect() {
  * Appends text to the scrolling news banner.
  * If the banner is at its default text or empty, replace it entirely.
  * Otherwise, just append " | " + newText.
+ * @param newText Text to add to the news banner
  */
-function addToNewsBanner(newText) {
+export function addToNewsBanner(newText: string): void {
   const bannerEl = document.getElementById('news-banner-content');
-  if (!bannerEl) return;
+  if (!bannerEl) {
+    console.warn("News banner element not found");
+    return;
+  }
+
+  console.log(`Adding to news banner: "${newText}"`); 
 
   // If the banner only has the default text or is empty, replace it
   if (
@@ -613,4 +705,3 @@ function addToNewsBanner(newText) {
     bannerEl.textContent += '  |  ' + newText;
   }
 }
-
diff --git a/ai_animation/src/gameState.ts b/ai_animation/src/gameState.ts
index 9679c45..5bc71ad 100644
--- a/ai_animation/src/gameState.ts
+++ b/ai_animation/src/gameState.ts
@@ -12,19 +12,24 @@ import * as TWEEN from "@tweenjs/tween.js";
 //FIXME: This whole file is a mess. Need to organize and format
 //
 // NEW: Add a lock for text-to-speech
-export let isSpeaking = false;   // Lock to pause game flow while TTS is active
-export let currentPhaseIndex = 0;
 enum AvailableMaps {
   STANDARD = "standard"
 }
-// Move these definitions BEFORE they're used
-function getRandomPower(): PowerENUM {
-  const values = Object.values(PowerENUM)
 
+/**
+ * Return a random power from the PowerENUM for the player to control
+ */
+function getRandomPower(): PowerENUM {
+  const values = Object.values(PowerENUM);
   const idx = Math.floor(Math.random() * values.length);
   return values[idx];
 }
-export const currentPower = getRandomPower();
+
+// Export these variables to be used throughout the application
+export let isSpeaking = false;   // Lock to pause game flow while TTS is active
+export let currentPhaseIndex = 0; // Track the current phase index
+export const currentPower = getRandomPower(); // Randomly selected power for the player
+export const currentPowerUpper = currentPower.toUpperCase();
 
 
 class GameState {
@@ -54,6 +59,8 @@ class GameState {
 
   //
   playbackTimer: number
+  animationAttempted: boolean
+
   constructor(boardName: AvailableMaps) {
     this.phaseIndex = 0
     this.gameData = null
@@ -63,29 +70,79 @@ class GameState {
     this.isPlaying = false
     this.isAnimating = false
     this.messagesPlaying = false
+    this.animationAttempted = false
 
     this.scene = new THREE.Scene()
     this.unitMeshes = []
     this.unitAnimations = []
   }
 
+  /**
+   * Load game data from a JSON string and initialize the game state
+   * @param gameDataString JSON string containing game data
+   * @returns Promise that resolves when game is initialized or rejects if data is invalid
+   */
   loadGameData = (gameDataString: string): Promise<void> => {
     return new Promise((resolve, reject) => {
-      this.gameData = GameSchema.parse(JSON.parse(gameDataString));
-      logger.log(`Game data loaded: ${this.gameData.phases?.length || 0} phases found.`)
-      this.phaseIndex = 0;
-      if (this.gameData.phases?.length) {
-        prevBtn.disabled = false;
-        nextBtn.disabled = false;
-        playBtn.disabled = false;
-        speedSelector.disabled = false;
+      try {
+        // First parse the raw JSON
+        const rawData = JSON.parse(gameDataString);
+        
+        // Log data structure for debugging
+        console.log("Loading game data with structure:", 
+          `${rawData.phases?.length || 0} phases, ` +
+          `orders format: ${rawData.phases?.[0]?.orders ? (Array.isArray(rawData.phases[0].orders) ? 'array' : 'object') : 'none'}`
+        );
+        
+        // Show a sample of the first phase for diagnostic purposes
+        if (rawData.phases && rawData.phases.length > 0) {
+          console.log("First phase sample:", {
+            name: rawData.phases[0].name,
+            ordersCount: rawData.phases[0].orders ? 
+              (Array.isArray(rawData.phases[0].orders) ? 
+                rawData.phases[0].orders.length : 
+                Object.keys(rawData.phases[0].orders).length) : 0,
+            ordersType: rawData.phases[0].orders ? typeof rawData.phases[0].orders : 'none',
+            unitsCount: rawData.phases[0].units ? rawData.phases[0].units.length : 0
+          });
+        }
+        
+        // Parse the game data using Zod schema
+        this.gameData = GameSchema.parse(rawData);
+        logger.log(`Game data loaded: ${this.gameData.phases?.length || 0} phases found.`)
+        
+        // Reset phase index to beginning
+        this.phaseIndex = 0;
+        
+        if (this.gameData.phases?.length) {
+          // Enable UI controls
+          prevBtn.disabled = false;
+          nextBtn.disabled = false;
+          playBtn.disabled = false;
+          speedSelector.disabled = false;
 
-        // Initialize chat windows
-        createChatWindows();
-        displayInitialPhase()
-        resolve()
-      } else {
-        reject()
+          // Initialize chat windows for all powers
+          createChatWindows();
+          
+          // Display the initial phase
+          displayInitialPhase()
+          resolve()
+        } else {
+          logger.log("Error: No phases found in game data");
+          reject(new Error("No phases found in game data"))
+        }
+      } catch (error) {
+        console.error("Error parsing game data:", error);
+        if (error.errors) {
+          // Format Zod validation errors more clearly
+          const formattedErrors = error.errors.map(err => 
+            `- Path ${err.path.join('.')}: ${err.message} (got ${err.received})`
+          ).join('\n');
+          logger.log(`Game data validation failed:\n${formattedErrors}`);
+        } else {
+          logger.log(`Error parsing game data: ${error.message}`);
+        }
+        reject(error);
       }
     })
   }
diff --git a/ai_animation/src/main.ts b/ai_animation/src/main.ts
index 84a8172..cebd150 100644
--- a/ai_animation/src/main.ts
+++ b/ai_animation/src/main.ts
@@ -7,7 +7,9 @@ import { gameState } from "./gameState";
 import { logger } from "./logger";
 import { loadBtn, prevBtn, nextBtn, speedSelector, fileInput, playBtn, mapView, loadGameBtnFunction } from "./domElements";
 import { updateChatWindows } from "./domElements/chatWindows";
-import { displayPhaseWithAnimation } from "./phase";
+import { displayPhaseWithAnimation, advanceToNextPhase } from "./phase";
+import { speakSummary } from "./speech";
+import { addToNewsBanner } from "./domElements/chatWindows";
 import { config } from "./config";
 
 //TODO: Create a function that finds a suitable unit location within a given polygon, for placing units better 
@@ -57,6 +59,10 @@ function initScene() {
 }
 
 // --- ANIMATION LOOP ---
+/**
+ * Main animation loop that runs continuously
+ * Handles camera movement, animations, and game state transitions
+ */
 function animate() {
   requestAnimationFrame(animate);
 
@@ -72,30 +78,52 @@ function animate() {
     );
 
     // If messages are done playing but we haven't started unit animations yet
-    if (!gameState.messagesPlaying && !gameState.isSpeaking && gameState.unitAnimations.length === 0 && gameState.isPlaying) {
+    if (!gameState.messagesPlaying && !gameState.isSpeaking && 
+        gameState.unitAnimations.length === 0 && gameState.isPlaying &&
+        !gameState.animationAttempted) {
       if (gameState.gameData && gameState.gameData.phases) {
-        const prevIndex = gameState.phaseIndex > 0 ? gameState.phaseIndex - 1 : gameState.gameData.phases.length - 1;
+        // Log that we're transitioning to animations
+        console.log("Messages complete, starting unit animations");
+        
+        // Mark that we've attempted animation for this phase
+        gameState.animationAttempted = true;
+        
+        const prevIndex = gameState.phaseIndex > 0 ? 
+                          gameState.phaseIndex - 1 : null;
+        
+        // Create animations for unit movements based on orders
         createTweenAnimations(
           gameState.gameData.phases[gameState.phaseIndex],
-          gameState.gameData.phases[prevIndex]
+          prevIndex !== null ? gameState.gameData.phases[prevIndex] : null
         );
       }
     }
   } else {
+    // Manual camera controls when not in playback mode
     gameState.camControls.update();
   }
 
   // Process unit movement animations using TWEEN.js update
+  TWEEN.update(); // Add explicit TWEEN update call
 
   // Check if all animations are complete
   if (gameState.unitAnimations.length > 0) {
     // Filter out completed animations
+    const previousCount = gameState.unitAnimations.length;
     gameState.unitAnimations = gameState.unitAnimations.filter(anim => anim.isPlaying());
+    
+    // Log when animations complete
+    if (previousCount > 0 && gameState.unitAnimations.length === 0) {
+      console.log("All unit animations have completed");
+    }
+    
+    // Call update on each active animation
     gameState.unitAnimations.forEach((anim) => anim.update())
 
     // If all animations are complete and we're in playback mode
     if (gameState.unitAnimations.length === 0 && gameState.isPlaying && !gameState.messagesPlaying) {
       // Schedule next phase after a pause delay
+      console.log(`Scheduling next phase in ${config.playbackSpeed}ms`);
       gameState.playbackTimer = setTimeout(() => advanceToNextPhase(), config.playbackSpeed);
     }
   }
@@ -138,22 +166,40 @@ function loadDefaultGameFile() {
   console.log("Loading default game file for debug mode...");
 
   // Path to the default game file
-  const defaultGameFilePath = './assets/default_game.json';
+  const defaultGameFilePath = './assets/test-game.json';
 
   fetch(defaultGameFilePath)
     .then(response => {
       if (!response.ok) {
         throw new Error(`Failed to load default game file: ${response.status}`);
       }
+      
+      // Check content type to avoid HTML errors
+      const contentType = response.headers.get('content-type');
+      if (contentType && contentType.includes('text/html')) {
+        throw new Error('Received HTML instead of JSON. Check the file path.');
+      }
+      
       return response.text();
     })
     .then(data => {
-      gameState.loadGameData(data);
-      console.log("Default game file loaded successfully");
+      // Check for HTML content as a fallback
+      if (data.trim().startsWith('<!DOCTYPE') || data.trim().startsWith('<html')) {
+        throw new Error('Received HTML instead of JSON. Check the file path.');
+      }
+      
+      console.log("Loaded game file, attempting to parse...");
+      return gameState.loadGameData(data);
+    })
+    .then(() => {
+      console.log("Default game file loaded and parsed successfully");
     })
     .catch(error => {
       console.error("Error loading default game file:", error);
-      logger.log(`Error loading default game: ${error.message}`)
+      logger.log(`Error loading default game: ${error.message}`);
+      
+      // Fallback - tell user to drag & drop a file
+      logger.log('Please load a game file using the "Load Game" button.');
     });
 }
 
@@ -171,14 +217,17 @@ function togglePlayback() {
     playBtn.textContent = "⏸ Pause";
     prevBtn.disabled = true;
     nextBtn.disabled = true;
+    logger.log("Starting playback...");
 
     // First, show the messages of the current phase if it's the initial playback
     const phase = gameState.gameData.phases[gameState.phaseIndex];
     if (phase.messages && phase.messages.length) {
       // Show messages with stepwise animation
+      logger.log(`Playing ${phase.messages.length} messages from phase ${gameState.phaseIndex+1}/${gameState.gameData.phases.length}`);
       updateChatWindows(phase, true);
     } else {
       // No messages, go straight to unit animations
+      logger.log("No messages for this phase, proceeding to animations");
       displayPhaseWithAnimation(gameState.phaseIndex);
     }
   } else {
diff --git a/ai_animation/src/map/state.ts b/ai_animation/src/map/state.ts
index f8e74a1..0e0ad22 100644
--- a/ai_animation/src/map/state.ts
+++ b/ai_animation/src/map/state.ts
@@ -96,27 +96,73 @@ export function updateLeaderboard(phase) {
 }
 
 export function updateMapOwnership(currentPhase: GamePhase) {
-  //FIXME: This only works in the forward direction, we currently don't update ownership correctly when going to previous phase
+  // Clear existing ownership to avoid stale data
+  for (const key in gameState.boardState.provinces) {
+    if (gameState.boardState.provinces[key].owner) {
+      gameState.boardState.provinces[key].owner = undefined;
+    }
+  }
 
-  for (const [power, unitArr] of Object.entries(currentPhase.state.units)) {
-    unitArr.forEach(unitStr => {
-      const match = unitStr.match(/^([AF])\s+(.+)$/);
-      if (!match) return;
-      const location = match[2];
+  // Use the units array directly if available
+  if (currentPhase.units && currentPhase.units.length > 0) {
+    // Log for debugging
+    console.log(`Updating map ownership using ${currentPhase.units.length} units from phase ${currentPhase.name}`);
+    
+    currentPhase.units.forEach(unit => {
+      if (!unit.location || !unit.power) {
+        console.warn("Unit missing location or power:", unit);
+        return;
+      }
+      
+      const location = unit.location;
       const normalized = location.toUpperCase().replace('/', '_');
       const base = normalized.split('_')[0];
+      
       if (gameState.boardState.provinces[base] === undefined) {
-        console.log(base)
+        console.warn(`Province not found: ${base}`);
+        return;
       }
-      gameState.boardState.provinces[base].owner = power
-    })
+      
+      gameState.boardState.provinces[base].owner = unit.power;
+    });
+  } 
+  // Fallback to state.units if units array is not available
+  else if (currentPhase.state?.units && Object.keys(currentPhase.state.units).length > 0) {
+    console.log(`Updating map ownership using state.units from phase ${currentPhase.name}`);
+    
+    for (const [power, unitArr] of Object.entries(currentPhase.state.units)) {
+      unitArr.forEach(unitStr => {
+        const match = unitStr.match(/^([AF])\s+(.+)$/);
+        if (!match) {
+          console.warn(`Could not parse unit string: ${unitStr}`);
+          return;
+        }
+        
+        const location = match[2];
+        const normalized = location.toUpperCase().replace('/', '_');
+        const base = normalized.split('_')[0];
+        
+        if (gameState.boardState.provinces[base] === undefined) {
+          console.warn(`Province not found: ${base}`);
+          return;
+        }
+        
+        gameState.boardState.provinces[base].owner = power;
+      });
+    }
+  } else {
+    console.warn(`No unit data found in phase ${currentPhase.name} to update map ownership`);
   }
-  for (const [key, value] of Object.entries(gameState.boardState.provinces)) {
+
+  // Update province colors based on ownership
+  for (const key in gameState.boardState.provinces) {
+    const province = gameState.boardState.provinces[key];
+    
     // Update the color of the provinces if needed
-    if (gameState.boardState.provinces[key].owner && gameState.boardState?.provinces[key].type != ProvTypeENUM.WATER) {
-      let powerColor = getPowerHexColor(gameState.boardState.provinces[key].owner)
+    if (province.owner && province.type != ProvTypeENUM.WATER) {
+      let powerColor = getPowerHexColor(province.owner);
       let powerColorHex = parseInt(powerColor.substring(1), 16);
-      gameState.boardState.provinces[key].mesh?.material.color.setHex(powerColorHex)
+      province.mesh?.material.color.setHex(powerColorHex);
     }
   }
 }
diff --git a/ai_animation/src/phase.ts b/ai_animation/src/phase.ts
index c2ef461..75f6041 100644
--- a/ai_animation/src/phase.ts
+++ b/ai_animation/src/phase.ts
@@ -1,11 +1,15 @@
+import * as THREE from "three";
 import { gameState } from "./gameState";
 import { logger } from "./logger";
 import { phaseDisplay } from "./domElements";
 import { createSupplyCenters } from "./units/create";
 import { createUnitMesh } from "./units/create";
 import { updateSupplyCenterOwnership, updateLeaderboard, updateMapOwnership } from "./map/state";
-import { updateChatWindows } from "./domElements/chatWindows";
+import { updateChatWindows, addToNewsBanner } from "./domElements/chatWindows";
 import { createTweenAnimations } from "./units/animate";
+import { speakSummary } from "./speech";
+import { config } from "./config";
+import { getProvincePosition } from "./map/utils";
 
 // New function to display initial state without messages
 export function displayInitialPhase() {
@@ -65,9 +69,16 @@ export function displayPhaseWithAnimation(index) {
     return;
   }
 
-  const prevIndex = index > 0 ? index - 1 : gameState.gameData.phases.length - 1;
+  // Reset animation attempted flag for the new phase
+  gameState.animationAttempted = false;
+
+  // Handle the special case for the first phase (index 0)
+  const isFirstPhase = index === 0;
   const currentPhase = gameState.gameData.phases[index];
-  const previousPhase = gameState.gameData.phases[prevIndex];
+  
+  // Only get previous phase if not the first phase
+  const prevIndex = isFirstPhase ? null : (index > 0 ? index - 1 : gameState.gameData.phases.length - 1);
+  const previousPhase = isFirstPhase ? null : gameState.gameData.phases[prevIndex];
 
   phaseDisplay.textContent = `Era: ${currentPhase.name || 'Unknown Era'} (${index + 1}/${gameState.gameData.phases.length})`;
 
@@ -77,7 +88,6 @@ export function displayPhaseWithAnimation(index) {
   // First show messages with stepwise animation
   updateChatWindows(currentPhase, true);
 
-
   // Ownership
   if (currentPhase.state?.centers) {
     updateSupplyCenterOwnership(currentPhase.state.centers);
@@ -87,36 +97,88 @@ export function displayPhaseWithAnimation(index) {
   updateLeaderboard(currentPhase);
   updateMapOwnership(currentPhase)
 
-  createTweenAnimations(currentPhase, previousPhase);
+  // Only animate if not the first phase
+  if (!isFirstPhase) {
+    createTweenAnimations(currentPhase, previousPhase);
+  } else {
+    logger.log("First phase - no previous phase to animate from");
+    // Since we're not animating, mark messages as done
+    gameState.messagesPlaying = false;
+  }
+  
   let msg = `Phase: ${currentPhase.name}\nSCs: ${JSON.stringify(currentPhase.state.centers)} \nUnits: ${currentPhase.state?.units ? JSON.stringify(currentPhase.state.units) : 'None'} `
   // Panel
 
   // Add: Update info panel
   logger.updateInfoPanel();
-
 }
 
-async function advanceToNextPhase() {
-  // Only show a summary if we have at least started the first phase
-  // and only if the just-ended phase has a "summary" property.
-  if (gameState.gameData && gameState.gameData.phases && gameState.phaseIndex >= 0) {
-    const justEndedPhase = gameState.gameData.phases[gameState.phaseIndex];
-    if (justEndedPhase.summary && justEndedPhase.summary.trim() !== '') {
-      // UPDATED: First update the news banner with full summary
-      addToNewsBanner(`(${justEndedPhase.name}) ${justEndedPhase.summary}`);
 
-      // Then speak the summary (will be truncated internally)
-      await speakSummary(justEndedPhase.summary);
-    }
+/**
+ * Advances to the next phase in the game sequence
+ * Handles speaking summaries and transitioning to the next phase
+ */
+export function advanceToNextPhase() {
+  if (!gameState.gameData || !gameState.gameData.phases || gameState.phaseIndex < 0) {
+    logger.log("Cannot advance phase: invalid game state");
+    return;
   }
 
-  // If we've reached the end, loop back to the beginning
+  // Get current phase
+  const currentPhase = gameState.gameData.phases[gameState.phaseIndex];
+  
+  if (config.isDebugMode) {
+    console.log(`Processing phase transition for ${currentPhase.name}`);
+  }
+
+  // Reset animation attempted flag for the next phase
+  gameState.animationAttempted = false;
+
+  // First show summary if available
+  if (currentPhase.summary && currentPhase.summary.trim() !== '') {
+    // Update the news banner with full summary
+    addToNewsBanner(`(${currentPhase.name}) ${currentPhase.summary}`);
+
+    // Speak the summary and advance after
+    speakSummary(currentPhase.summary)
+      .then(() => {
+        if (gameState.isPlaying) {
+          moveToNextPhase();
+        }
+      })
+      .catch(() => {
+        if (gameState.isPlaying) {
+          moveToNextPhase();
+        }
+      });
+  } else {
+    // No summary to speak, advance immediately
+    moveToNextPhase();
+  }
+}
+
+/**
+ * Internal helper to handle the actual phase advancement
+ */
+function moveToNextPhase() {
+  // Clear any existing animations to prevent overlap
+  if (gameState.playbackTimer) {
+    clearTimeout(gameState.playbackTimer);
+  }
+  gameState.unitAnimations = [];
+
+  // Advance the phase index
   if (gameState.phaseIndex >= gameState.gameData.phases.length - 1) {
     gameState.phaseIndex = 0;
+    logger.log("Reached end of game, looping back to start");
   } else {
     gameState.phaseIndex++;
   }
 
-  // Display the new phase with animation
+  if (config.isDebugMode) {
+    console.log(`Moving to phase ${gameState.gameData.phases[gameState.phaseIndex].name}`);
+  }
+
+  // Display the next phase and start showing its messages
   displayPhaseWithAnimation(gameState.phaseIndex);
 }
diff --git a/ai_animation/src/speech.ts b/ai_animation/src/speech.ts
index 6017a9e..c8fd5f7 100644
--- a/ai_animation/src/speech.ts
+++ b/ai_animation/src/speech.ts
@@ -1,14 +1,19 @@
 
-// --- NEW: ElevenLabs TTS helper function ---
+import { isSpeaking } from "./gameState";
+
+// --- ElevenLabs Text-to-Speech configuration ---
 const ELEVENLABS_API_KEY = import.meta.env.VITE_ELEVENLABS_API_KEY || "";
 const VOICE_ID = "onwK4e9ZLuTAKqWW03F9";
 const MODEL_ID = "eleven_multilingual_v2";
+
 /**
- * Call ElevenLabs TTS to speak out loud. Returns a promise that
- * resolves only after the audio finishes playing (or fails).
- * Now accepts only the first 100 characters for brevity.
+ * Call ElevenLabs TTS to speak the summary out loud.
+ * Returns a promise that resolves only after the audio finishes playing (or fails).
+ * Truncates text to first 100 characters for brevity and API limitations.
+ * @param summaryText The text to be spoken
+ * @returns Promise that resolves when audio completes or rejects on error
  */
-async function speakSummary(summaryText) {
+export async function speakSummary(summaryText: string): Promise<void> {
   if (!ELEVENLABS_API_KEY) {
     console.warn("No ElevenLabs API key found. Skipping TTS.");
     return;
diff --git a/ai_animation/src/types/gameState.ts b/ai_animation/src/types/gameState.ts
index 0398faf..dd0d5d4 100644
--- a/ai_animation/src/types/gameState.ts
+++ b/ai_animation/src/types/gameState.ts
@@ -3,24 +3,107 @@ import { PowerENUMSchema } from './map';
 import { OrderFromString } from './unitOrders';
 import { ProvinceENUMSchema } from './map';
 
+// Define the unit structure in the JSON
+const UnitSchema = z.object({
+  type: z.string(),
+  power: PowerENUMSchema,
+  location: z.string(),
+  // Add any other possible fields with optional()
+  region: z.string().optional(),
+  coast: z.string().optional(),
+  // Catch-all for any other fields
+}).catchall(z.any());
+
+// Define the order structure in the JSON
+const OrderSchema = z.object({
+  text: z.string(),
+  power: PowerENUMSchema,
+  region: z.string().optional(),
+  // Add any other possible fields with optional()
+  result: z.any().optional(),
+  unit: z.any().optional(),
+  type: z.string().optional(),
+  // Catch-all for any other fields
+}).catchall(z.any());
 
 const PhaseSchema = z.object({
-  messages: z.array(z.any()),
   name: z.string(),
-  orders: z.record(PowerENUMSchema, z.array(OrderFromString).nullable()),
-  results: z.record(z.string(), z.array(z.any())),
-  state: z.object({
-    units: z.record(PowerENUMSchema, z.array(z.string())),
-    centers: z.record(PowerENUMSchema, z.array(ProvinceENUMSchema))
-  }),
   year: z.number().optional(),
+  season: z.string().optional(),
+  type: z.string().optional(),
+  // Make messages optional with default empty array
+  messages: z.array(z.object({
+    sender: PowerENUMSchema,
+    recipient: z.union([PowerENUMSchema, z.literal('GLOBAL')]),
+    time_sent: z.number(),
+    message: z.string()
+  })).optional().default([]),
+  // Units as an array of objects
+  units: z.array(UnitSchema).optional(),
+  // Orders - standardize on array format, with preprocessor to convert from object format
+  orders: z.preprocess(
+    (val) => {
+      // If it's already an array, return it
+      if (Array.isArray(val)) {
+        return val;
+      }
+      
+      // If it's an object with power keys and arrays of order strings
+      if (val && typeof val === 'object') {
+        const orderArray: any[] = [];
+        
+        // Convert from {POWER: [orderText1, orderText2]} to [{text: orderText1, power: POWER}, {text: orderText2, power: POWER}]
+        Object.entries(val).forEach(([power, orders]) => {
+          if (Array.isArray(orders)) {
+            orders.forEach(orderText => {
+              // Extract region from order text if possible
+              let region = '';
+              const match = orderText.match(/^[AF]\s+([A-Z]{3})/);
+              if (match) {
+                region = match[1];
+              }
+              
+              orderArray.push({
+                text: orderText,
+                power: power,
+                region: region
+              });
+            });
+          }
+        });
+        
+        return orderArray;
+      }
+      
+      // Otherwise return empty array
+      return [];
+    },
+    z.array(OrderSchema).optional().default([])
+  ),
+  // Results as an optional record
+  results: z.record(z.string(), z.array(z.any())).optional().default({}),
+  // State as an optional object
+  state: z.object({
+    units: z.record(PowerENUMSchema, z.array(z.string())).optional(),
+    centers: z.record(PowerENUMSchema, z.array(ProvinceENUMSchema)).optional()
+  }).optional().default({}),
+  // Summary for phase completion
+  summary: z.string().optional()
 });
 
 export const GameSchema = z.object({
-  map: z.string(),
-  id: z.string(),
+  map_name: z.string().optional(),
+  map: z.string().optional(),
+  id: z.string().optional(),
+  game_id: z.string().optional(),
   phases: z.array(PhaseSchema),
-});
+  // Add other possible fields
+  powers: z.any().optional(),
+  current_phase: z.any().optional(),
+  status: z.any().optional(),
+  created_at: z.any().optional(),
+  updated_at: z.any().optional(),
+}).catchall(z.any());
 
 export type GamePhase = z.infer<typeof PhaseSchema>;
 export type GameSchemaType = z.infer<typeof GameSchema>;
diff --git a/ai_animation/src/types/map.ts b/ai_animation/src/types/map.ts
index 2dab4f0..4a7a4b9 100644
--- a/ai_animation/src/types/map.ts
+++ b/ai_animation/src/types/map.ts
@@ -8,22 +8,20 @@ export enum ProvTypeENUM {
 }
 
 export enum PowerENUM {
-  ENGLAND = "England",
-  FRANCE = "France",
-  TURKEY = "Turkey",
-  AUSTRIA = "Austria",
-  GERMANY = "Germany",
-  ITALY = "Italy",
-  RUSSIA = "Russia",
+  AUSTRIA = "AUSTRIA",
+  ENGLAND = "ENGLAND",
+  FRANCE = "FRANCE",
+  GERMANY = "GERMANY",
+  ITALY = "ITALY",
+  RUSSIA = "RUSSIA",
+  TURKEY = "TURKEY",
 }
 
-
-
 export const ProvTypeSchema = z.nativeEnum(ProvTypeENUM);
 export const PowerENUMSchema = z.preprocess((arg) => {
   if (typeof arg === "string") {
-    // Normalize the string: "austria" or "AUSTRIA" becomes "Austria"
-    return arg.charAt(0).toUpperCase() + arg.slice(1).toLowerCase();
+    // Convert to uppercase to ensure consistent power representation
+    return arg.toUpperCase();
   }
   return arg;
 }, z.nativeEnum(PowerENUM));
diff --git a/ai_animation/src/units/animate.ts b/ai_animation/src/units/animate.ts
index c19d3f0..dbf0176 100644
--- a/ai_animation/src/units/animate.ts
+++ b/ai_animation/src/units/animate.ts
@@ -6,9 +6,11 @@ import { getProvincePosition } from "../map/utils";
 import * as TWEEN from "@tweenjs/tween.js";
 import { gameState } from "../gameState";
 import type { UnitOrder } from "../types/unitOrders";
+import { OrderFromString } from "../types/unitOrders";
+import { logger } from "../logger";
+import { config } from "../config"; // Assuming config is defined in a separate file
 
 //FIXME: Move this to a file with all the constants
-let animationDuration = 1500; // Duration of unit movement animation in ms
 enum AnimationTypeENUM {
   CREATE,
   MOVE,
@@ -23,49 +25,124 @@ export type UnitAnimation = {
   animationType?: AnimationTypeENUM
 }
 
-function getUnit(unitOrder: UnitOrder) {
-  let posUnits = gameState.unitMeshes.filter((unit) => {
-    return (unit.userData.province === unitOrder.unit.origin && unit.userData.type === unitOrder.unit.type)
-  })
-  // TODO: Need to do something here if we get multiple results
-  return gameState.unitMeshes.indexOf(posUnits[0])
-
+// Helper function to parse order string into UnitOrder object
+function parseOrderString(orderText: string): UnitOrder | null {
+  try {
+    return OrderFromString.parse(orderText);
+  } catch (error) {
+    logger.log(`Failed to parse order: ${orderText}`);
+    return null;
+  }
 }
 
+function getUnit(unitOrder: UnitOrder, power: string) {
+  let posUnits = gameState.unitMeshes.filter((unit) => {
+    return (
+      unit.userData.province === unitOrder.unit.origin && 
+      unit.userData.type === unitOrder.unit.type &&
+      unit.userData.power === power
+    );
+  });
+  
+  if (posUnits.length === 0) {
+    return -1;
+  }
+  
+  // Return the first matching unit
+  return gameState.unitMeshes.indexOf(posUnits[0]);
+}
 
+/**
+ * Creates animations for unit movements based on orders from the previous phase
+ * @param currentPhase The current game phase
+ * @param previousPhase The previous game phase containing orders to process
+ */
 export function createTweenAnimations(currentPhase: GamePhase, previousPhase: GamePhase | null) {
-  for (const [power, orders] of Object.entries(previousPhase.orders)) {
-    for (const order of orders) {
-      let unitIndex = getUnit(order);
-      if (unitIndex === -1) continue; // Skip if unit not found
+  // Safety check - if no previous phase or no orders, return
+  if (!previousPhase) {
+    logger.log("No previous phase to animate");
+    return;
+  }
+
+  // Debug log the phase transition
+  if (config.isDebugMode) {
+    console.log(`Animating transition from ${previousPhase.name} to ${currentPhase.name}`);
+  }
+  
+  // Ensure orders is treated as an array
+  const orders = previousPhase.orders;
+  if (!orders) {
+    logger.log(`Phase ${previousPhase.name}: No orders found`);
+    return;
+  }
+
+  // Convert orders to array if it's an object
+  const ordersArray = Array.isArray(orders) ? orders : Object.values(orders);
+  if (ordersArray.length === 0) {
+    logger.log(`Phase ${previousPhase.name}: No orders to animate`);
+    return;
+  }
+
+  // Clear any existing animations to prevent loops
+  gameState.unitAnimations = [];
+  
+  // Log once with meaningful information
+  logger.log(`Creating animations for ${ordersArray.length} orders from phase ${previousPhase.name}`);
+
+  // Process each order in the array
+  for (const orderObj of ordersArray) {
+    try {
+      // Parse the order text into a structured UnitOrder
+      const order = parseOrderString(orderObj.text);
+      if (!order) {
+        if (config.isDebugMode) {
+          console.log(`Could not parse order: ${orderObj.text}`);
+        }
+        continue;
+      }
+
+      // Find the unit that matches this order's power and origin
+      const unitIndex = getUnit(order, orderObj.power);
+      if (unitIndex === -1) {
+        if (config.isDebugMode) {
+          console.log(`Unit not found for order: ${orderObj.text} (power: ${orderObj.power})`);
+        }
+        continue;
+      }
+
+      if (config.isDebugMode) {
+        console.log(`Processing ${order.type} order for ${orderObj.power}: ${orderObj.text}`);
+      }
 
       switch (order.type) {
         case "move":
           let destinationVector = getProvincePosition(gameState.boardState, order.destination);
-          if (!destinationVector) continue; // Skip if destination not found
-
+          if (!destinationVector) {
+            console.log(`Destination province not found: ${order.destination}`);
+            continue;
+          }
+          
           // Create a tween for smooth movement
           let anim = new TWEEN.Tween(gameState.unitMeshes[unitIndex].position)
             .to({
               x: destinationVector.x,
-              y: 10, // Keep consistent height
+              y: 10,
               z: destinationVector.z
-            }, 1500)
-            .easing(TWEEN.Easing.Quadratic.InOut) // Add easing for smoother motion
+            }, config.animationDuration)
+            .easing(TWEEN.Easing.Quadratic.InOut)
             .onUpdate(() => {
-              // Add a slight bobbing effect during movement
               gameState.unitMeshes[unitIndex].position.y = 10 + Math.sin(Date.now() * 0.05) * 2;
-
-              // For fleets, add a gentle rocking motion
               if (gameState.unitMeshes[unitIndex].userData.type === 'F') {
                 gameState.unitMeshes[unitIndex].rotation.z = Math.sin(Date.now() * 0.03) * 0.1;
                 gameState.unitMeshes[unitIndex].rotation.x = Math.sin(Date.now() * 0.02) * 0.1;
               }
             })
             .onComplete(() => {
-              // Update the unit's province data when animation completes
-
-              // Reset height and rotation
+              gameState.unitMeshes[unitIndex].userData.province = order.destination;
+              if (config.isDebugMode) {
+                console.log(`Unit ${orderObj.power} ${gameState.unitMeshes[unitIndex].userData.type} moved: ${order.unit.origin} -> ${order.destination}`);
+              }
+              
               gameState.unitMeshes[unitIndex].position.y = 10;
               if (gameState.unitMeshes[unitIndex].userData.type === 'F') {
                 gameState.unitMeshes[unitIndex].rotation.z = 0;
@@ -74,21 +151,32 @@ export function createTweenAnimations(currentPhase: GamePhase, previousPhase: Ga
             })
             .start();
 
-          gameState.unitMeshes[unitIndex].userData.province = order.destination;
           gameState.unitAnimations.push(anim);
           break;
 
         case "disband":
+          if (config.isDebugMode) {
+            console.log(`Disbanding unit ${orderObj.power} ${gameState.unitMeshes[unitIndex].userData.type} in ${gameState.unitMeshes[unitIndex].userData.province}`);
+          }
           gameState.scene.remove(gameState.unitMeshes[unitIndex]);
-          // Remove from unitMeshes array
           gameState.unitMeshes.splice(unitIndex, 1);
           break;
-        case "bounce":
+          
+        default:
+          if (config.isDebugMode) {
+            console.log(`Skipping order type: ${order.type} for ${orderObj.text}`);
+          }
           break;
       }
+    } catch (error) {
+      logger.log(`Error processing order: ${error.message}`);
+      if (config.isDebugMode) {
+        console.error("Full error:", error);
+      }
     }
   }
 }
+
 export function createAnimationsForPhaseTransition(unitMeshes: UnitMesh[], currentPhase: GamePhase, previousPhase: GamePhase | null): UnitAnimation[] {
   let unitAnimations: UnitAnimation[] = []
   // Prepare unit position maps
@@ -149,13 +237,14 @@ export function createAnimationsForPhaseTransition(unitMeshes: UnitMesh[], curre
           startPos,
           endPos: currentPos,
           startTime: Date.now(),
-          duration: animationDuration
+          duration: config.animationDuration
         });
       });
     }
   }
   return unitAnimations
 }
+
 // Easing function for smooth animations
 function easeInOutCubic(t) {
   return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;