adding win

game_viz.log

@@ -2402,3 +2402,15 @@ Current Player: ► c
 -----
 Board Tiles: 19 tiles configured
 
+
+============================================================
+✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ 
+
+                 🎉 GAME OVER - WE HAVE A WINNER! 🎉                 
+
+                         🏆 C (Player 2) 🏆                          
+                      with 5 victory points!                       
+
+✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ ✨ 
+============================================================
+

pycatan/console_visualization.py

@@ -700,4 +700,26 @@ class ConsoleVisualization(Visualization):
             return
         
         # Display structured log string
-        self._print(log_entry.to_log_string())
+        self._print(log_entry.to_log_string())
+    
+    def display_winner(self, player_name: str, player_id: int, victory_points: int) -> None:
+        """Display game winner announcement."""
+        if not self.enabled:
+            return
+        
+        # Create a celebratory banner
+        banner_line = "=" * 60
+        stars_line = "✨ " * 30
+        
+        self._print()
+        self._print(f"{self.colors['bold']}{self.colors['yellow']}{banner_line}{self.colors['reset']}")
+        self._print(f"{self.colors['bold']}{self.colors['yellow']}{stars_line}{self.colors['reset']}")
+        self._print()
+        self._print(f"{self.colors['bold']}{self.colors['green']}🎉 GAME OVER - WE HAVE A WINNER! 🎉{self.colors['reset']}".center(80))
+        self._print()
+        self._print(f"{self.colors['bold']}{self.colors['cyan']}🏆 {player_name.upper()} (Player {player_id}) 🏆{self.colors['reset']}".center(80))
+        self._print(f"{self.colors['bold']}{self.colors['white']}with {victory_points} victory points!{self.colors['reset']}".center(80))
+        self._print()
+        self._print(f"{self.colors['bold']}{self.colors['yellow']}{stars_line}{self.colors['reset']}")
+        self._print(f"{self.colors['bold']}{self.colors['yellow']}{banner_line}{self.colors['reset']}")
+        self._print()

pycatan/game_manager.py

@@ -1716,7 +1716,7 @@ class GameManager:
             victory_points = player.get_VP(include_dev=True)
             
             # Check if this player has won (10+ victory points)
-            if victory_points >= 5:
+            if victory_points >= 10:
                 self._announce_winner(player_id, victory_points)
                 return True
         
@@ -1738,6 +1738,10 @@ class GameManager:
             f"🎉 {winner_name} has won the game with {victory_points} victory points! 🎉"
         )
         
+        # Notify all visualizations
+        if self.visualization_manager:
+            self.visualization_manager.display_winner(winner_name, player_id, victory_points)
+        
         # Log the victory for debugging/statistics
         print(f"[GAME END] Player {player_id} ({winner_name}) won with {victory_points} victory points")
     

pycatan/static/js/main.js

@@ -161,6 +161,8 @@ function connectToSSE() {
                     logEvent(data.payload, 'info');
                 } else if (data.type === 'error') {
                     logEvent(data.payload, 'error');
+                } else if (data.type === 'game_winner') {
+                    showWinnerAnnouncement(data.payload);
                 }
             };
             
@@ -394,6 +396,131 @@ function appendToLog(container, element) {
     container.scrollTop = container.scrollHeight;
 }
 
+// Show winner announcement overlay
+function showWinnerAnnouncement(winnerData) {
+    console.log('🎉 GAME WINNER:', winnerData);
+    
+    // Log to action log
+    const logDiv = document.getElementById('action-log');
+    if (logDiv) {
+        const winnerEntry = document.createElement('div');
+        winnerEntry.className = 'log-winner';
+        winnerEntry.innerHTML = `
+            <strong>${winnerData.timestamp}</strong> - 
+            🎉 <strong>${winnerData.player_name}</strong> won with ${winnerData.victory_points} victory points! 🎉
+        `;
+        logDiv.insertBefore(winnerEntry, logDiv.firstChild);
+    }
+    
+    // Create fullscreen overlay
+    const overlay = document.createElement('div');
+    overlay.id = 'winner-overlay';
+    overlay.style.cssText = `
+        position: fixed;
+        top: 0;
+        left: 0;
+        width: 100%;
+        height: 100%;
+        background: rgba(0, 0, 0, 0.85);
+        display: flex;
+        justify-content: center;
+        align-items: center;
+        z-index: 9999;
+        animation: fadeIn 0.5s ease-in;
+    `;
+    
+    overlay.innerHTML = `
+        <div style="
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            padding: 60px;
+            border-radius: 20px;
+            text-align: center;
+            box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5);
+            animation: bounceIn 0.8s ease-out;
+            max-width: 600px;
+        ">
+            <div style="font-size: 80px; margin-bottom: 20px;">🎉</div>
+            <h1 style="
+                color: white;
+                font-size: 48px;
+                margin: 20px 0;
+                text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.3);
+            ">GAME OVER!</h1>
+            <div style="
+                background: rgba(255, 255, 255, 0.2);
+                padding: 30px;
+                border-radius: 15px;
+                margin: 30px 0;
+            ">
+                <div style="font-size: 60px; margin-bottom: 15px;">🏆</div>
+                <h2 style="
+                    color: #ffd700;
+                    font-size: 42px;
+                    margin: 10px 0;
+                    text-shadow: 2px 2px 4px rgba(0, 0, 0, 0.5);
+                ">${winnerData.player_name.toUpperCase()}</h2>
+                <p style="
+                    color: white;
+                    font-size: 24px;
+                    margin-top: 15px;
+                ">Victory Points: ${winnerData.victory_points}</p>
+            </div>
+            <button onclick="document.getElementById('winner-overlay').remove()" style="
+                background: white;
+                color: #667eea;
+                border: none;
+                padding: 15px 40px;
+                font-size: 20px;
+                font-weight: bold;
+                border-radius: 10px;
+                cursor: pointer;
+                margin-top: 20px;
+                box-shadow: 0 4px 10px rgba(0, 0, 0, 0.3);
+                transition: transform 0.2s;
+            " onmouseover="this.style.transform='scale(1.05)'" 
+               onmouseout="this.style.transform='scale(1)'">
+                Close
+            </button>
+        </div>
+    `;
+    
+    // Add CSS animations
+    if (!document.getElementById('winner-animations')) {
+        const style = document.createElement('style');
+        style.id = 'winner-animations';
+        style.textContent = `
+            @keyframes fadeIn {
+                from { opacity: 0; }
+                to { opacity: 1; }
+            }
+            @keyframes bounceIn {
+                0% { transform: scale(0.3); opacity: 0; }
+                50% { transform: scale(1.05); }
+                70% { transform: scale(0.9); }
+                100% { transform: scale(1); opacity: 1; }
+            }
+            .log-winner {
+                background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+                color: white;
+                padding: 15px;
+                border-radius: 8px;
+                margin: 10px 0;
+                font-size: 16px;
+                font-weight: bold;
+                text-align: center;
+                animation: slideIn 0.5s ease-out;
+            }
+            @keyframes slideIn {
+                from { transform: translateX(-100%); opacity: 0; }
+                to { transform: translateX(0); opacity: 1; }
+            }
+        `;
+        document.head.appendChild(style);
+    }
+    
+    document.body.appendChild(overlay);
+}
+
 // Game initialization
 document.addEventListener('DOMContentLoaded', async function() {
     console.log('🎲 Starting Catan board with server connection...');

pycatan/visualization.py

@@ -114,6 +114,18 @@ class Visualization(ABC):
         """
         pass
     
+    @abstractmethod
+    def display_winner(self, player_name: str, player_id: int, victory_points: int) -> None:
+        """
+        Display game winner announcement.
+        
+        Args:
+            player_name: Name of the winning player
+            player_id: ID of the winning player
+            victory_points: Number of victory points the winner achieved
+        """
+        pass
+    
     def enable(self) -> None:
         """Enable this visualization."""
         self.enabled = True
@@ -201,6 +213,12 @@ class VisualizationManager:
             if viz.is_enabled():
                 viz.display_message(message)
     
+    def display_winner(self, player_name: str, player_id: int, victory_points: int) -> None:
+        """Update all enabled visualizations with winner announcement."""
+        for viz in self.visualizations:
+            if viz.is_enabled():
+                viz.display_winner(player_name, player_id, victory_points)
+    
     def log_event(self, log_entry: LogEntry) -> None:
         """Log a structured event to all enabled visualizations."""
         for viz in self.visualizations:

pycatan/web_visualization.py

@@ -862,6 +862,53 @@ class WebVisualization(Visualization):
             'payload': message_data
         })
     
+    def display_winner(self, player_name: str, player_id: int, victory_points: int) -> None:
+        """Display game winner announcement."""
+        timestamp = datetime.now().strftime("%H:%M:%S")
+        
+        winner_data = {
+            'timestamp': timestamp,
+            'player_name': player_name,
+            'player_id': player_id,
+            'victory_points': victory_points,
+            'message': f"🎉 {player_name} has won with {victory_points} victory points! 🎉"
+        }
+        
+        # Get turn number safely (handle both dict and GameState object)
+        turn_number = 0
+        if self.current_game_state:
+            if isinstance(self.current_game_state, dict):
+                turn_number = self.current_game_state.get('turn_number', 0)
+            else:
+                turn_number = getattr(self.current_game_state, 'turn_number', 0)
+        
+        # Create structured log entry
+        log_entry = create_log_entry(
+            event_type=EventType.GAME_END,
+            turn=turn_number,
+            player_id=player_id,
+            player_name=player_name,
+            data={
+                'victory_points': victory_points,
+                'winner': player_name
+            },
+            status="SUCCESS"
+        )
+        self.log_entries.append(log_entry)
+        
+        # Add to event history  
+        self.event_history.append({
+            'type': 'game_end',
+            'timestamp': timestamp,
+            'data': winner_data
+        })
+        
+        # Broadcast to web clients
+        self._broadcast_to_clients({
+            'type': 'game_winner',
+            'payload': winner_data
+        })
+    
     def _convert_dict_to_web_format(self, game_state: Dict[str, Any]) -> Dict[str, Any]:
         """Convert dict game state to web format."""
         web_format = {