knight finally finished!

game_viz.log

@@ -1390,6 +1390,8 @@ Current Player: ► b
 -----
 Board Tiles: 19 tiles configured
 
+✓ ✨ b used Knight
+✓ 🦹 b stole Sheep from a
 ✓ b used Knight
 
 ==================================================

pycatan/game_manager.py

@@ -15,6 +15,7 @@ from pycatan.user import User, UserList, validate_user_list, UserInputError
 from pycatan.game import Game
 from pycatan.statuses import Statuses
 from pycatan.card import DevCard
+from pycatan.log_events import EventType, create_log_entry
 
 
 class GameManager:
@@ -878,6 +879,9 @@ class GameManager:
             # Remove the card from player's hand
             self.game.players[player_id].remove_dev_card(DevCard.Knight)
             
+            # Get stolen card info from args (set by game.use_dev_card)
+            stolen_card = args.get('stolen_card')
+            
             # Update visualizations
             player_name = self.users[player_id].name if hasattr(self.users[player_id], 'name') else f"Player {player_id}"
             
@@ -885,6 +889,23 @@ class GameManager:
             robber_msg = f"⚔️ {player_name} used a Knight card! Robber moved to {tile_display}."
             print(f"\n    {robber_msg}")
             
+            # Send Knight card usage log to visualizations
+            knight_log = create_log_entry(
+                event_type=EventType.USE_DEV_CARD,
+                turn=self._current_game_state.turn_number,
+                player_id=player_id,
+                player_name=player_name,
+                data={
+                    'card': 'Knight',
+                    'robber_tile': tile_display,
+                    'message': robber_msg
+                },
+                status="SUCCESS"
+            )
+            
+            if self.visualization_manager:
+                self.visualization_manager.log_event(knight_log)
+            
             # Notify about robber move
             self._notify_all_users(
                 "knight_used",
@@ -894,10 +915,43 @@ class GameManager:
             # Notify about card steal if victim exists
             if victim_id is not None:
                 victim_name = self.users[victim_id].name if hasattr(self.users[victim_id], 'name') else f"Player {victim_id}"
-                self._notify_all_users(
-                    "knight_steal",
-                    f"🎯 {player_name} stole a card from {victim_name}!"
+                
+                # stolen_card was already retrieved from args above
+                if stolen_card:
+                    # Map card type to Hebrew/English name
+                    card_names = {
+                        'wood': 'עץ (Wood)',
+                        'brick': 'לבנה (Brick)', 
+                        'sheep': 'כבשה (Sheep)',
+                        'wheat': 'חיטה (Wheat)',
+                        'ore': 'עפרה (Ore)'
+                    }
+                    card_display = card_names.get(stolen_card.value, stolen_card.value)
+                    steal_msg = f"🎯 {player_name} stole {card_display} from {victim_name}!"
+                else:
+                    steal_msg = f"🎯 {player_name} stole a card from {victim_name}!"
+                
+                print(f"\n    {steal_msg}")
+                
+                # Send steal log to visualizations
+                steal_log = create_log_entry(
+                    event_type=EventType.ROBBER_STEAL,
+                    turn=self._current_game_state.turn_number,
+                    player_id=player_id,
+                    player_name=player_name,
+                    data={
+                        'victim_id': victim_id,
+                        'victim': victim_name,
+                        'card': stolen_card.name if stolen_card else 'unknown',  # Use .name to get 'Wood', 'Brick', etc.
+                        'message': steal_msg
+                    },
+                    status="SUCCESS"
                 )
+                
+                if self.visualization_manager:
+                    self.visualization_manager.log_event(steal_log)
+                
+                self._notify_all_users("knight_steal", steal_msg)
             
             # Notify if player got Largest Army
             if self.game.largest_army == player_id:
@@ -1725,9 +1779,8 @@ class GameManager:
                         )
                         
                         # Send to visualizations
-                        for viz in self.visualization_manager.visualizations:
-                            if hasattr(viz, 'log_event'):
-                                viz.log_event(log_entry)
+                        if self.visualization_manager:
+                            self.visualization_manager.log_event(log_entry)
             
             if distribution:
                 message = f"Rolled {total} ({die1}+{die2}). Resources distributed."

pycatan/log_events.py

@@ -199,6 +199,8 @@ class LogEntry:
         elif self.event_type == EventType.ROBBER_STEAL:
             victim = self.data.get('victim', '?')
             card = self.data.get('card', 'a card')
+            # Card names come from enum.name which is already capitalized (Wood, Brick, etc.)
+            # Just display as-is
             return f"🦹 {player_str} stole {card} from {victim}"
         
         elif self.event_type == EventType.TURN_START:

pycatan/visualization.py

@@ -8,6 +8,7 @@ Different visualization types (console, web, log) inherit from this class.
 from abc import ABC, abstractmethod
 from typing import Dict, Any, List, Optional
 from .actions import Action, ActionResult
+from .log_events import LogEntry
 
 
 class Visualization(ABC):
@@ -200,6 +201,12 @@ class VisualizationManager:
             if viz.is_enabled():
                 viz.display_message(message)
     
+    def log_event(self, log_entry: LogEntry) -> None:
+        """Log a structured event to all enabled visualizations."""
+        for viz in self.visualizations:
+            if viz.is_enabled() and hasattr(viz, 'log_event'):
+                viz.log_event(log_entry)
+    
     def get_visualization_count(self) -> int:
         """Get the number of registered visualizations."""
         return len(self.visualizations)

test_knight_steal.py

@@ -0,0 +1,84 @@
+"""
+Test Knight card with stolen card display
+"""
+from pycatan import Game
+from pycatan.card import DevCard, ResCard
+from pycatan.board_definition import board_definition
+from pycatan.actions import GamePhase
+from pycatan.statuses import Statuses
+
+def test_knight_with_steal():
+    """Test that Knight card shows which card was stolen."""
+    print("\n" + "="*60)
+    print("Testing Knight Card with Card Steal")
+    print("="*60)
+    
+    # Create game with 3 players
+    game = Game(num_of_players=3)
+    game.game_phase = GamePhase.NORMAL_PLAY
+    
+    # Give player 0 a Knight card
+    game.players[0].add_dev_card(DevCard.Knight)
+    
+    # Give player 1 some resource cards
+    game.players[1].add_cards([ResCard.Wheat, ResCard.Wood, ResCard.Brick])
+    
+    # Add a settlement for player 1 at a point adjacent to tile 5
+    # This allows player 0 to steal from player 1
+    # Tile 5 is at game coords (1,1)
+    
+    # Get a point adjacent to tile (1,1)
+    tile = game.board.tiles[1][1]
+    if tile.points:
+        settlement_point = tile.points[0]
+        # Use game.add_settlement instead of player.add_settlement
+        game.add_settlement(player=1, point=settlement_point, is_starting=True)
+        print(f"\n✓ Game setup complete")
+        print(f"  - Player 0: {len(game.players[0].dev_cards)} Knight card")
+        print(f"  - Player 1: {len(game.players[1].cards)} resource cards, 1 settlement")
+        print(f"  - Player 1's cards: {[card.value for card in game.players[1].cards]}")
+        
+        # Test using Knight card on tile 5 and stealing from player 1
+        print(f"\n🧪 Testing Knight card with steal...")
+        
+        args = {
+            'robber_pos': [1, 1],
+            'victim': 1
+        }
+        
+        print(f"📢 Using Knight card to move robber to tile 5 and steal from Player 1")
+        
+        # Record player 1's card count before
+        cards_before = len(game.players[1].cards)
+        
+        # Execute
+        status = game.use_dev_card(0, DevCard.Knight, args)
+        
+        if status == Statuses.ALL_GOOD:
+            cards_after = len(game.players[1].cards)
+            stolen = cards_before - cards_after
+            
+            print(f"\n✅ Knight card used successfully!")
+            print(f"  - Robber moved to tile 5 (coords [1, 1])")
+            print(f"  - Player 1 had {cards_before} cards, now has {cards_after}")
+            print(f"  - {stolen} card was stolen")
+            print(f"  - Player 0 knights: {game.players[0].knight_cards}")
+            
+            # Check if stolen card info is in args
+            if 'stolen_card' in args:
+                card = args['stolen_card']
+                print(f"\n✨ Stolen card: {card.value}")
+                print(f"   Message should show: '🎯 Player 0 stole {card.value} from Player 1!'")
+            else:
+                print(f"\n⚠️ No stolen card info found in args")
+        else:
+            print(f"❌ Failed with status: {status}")
+    else:
+        print("❌ Could not find points on tile")
+    
+    print("\n" + "="*60)
+    print("Test Complete!")
+    print("="*60)
+
+if __name__ == "__main__":
+    test_knight_with_steal()

test_knight_viz.py

@@ -0,0 +1,86 @@
+"""
+Test Knight card with visualization logs
+"""
+from pycatan import Game
+from pycatan.card import DevCard, ResCard
+from pycatan.board_definition import board_definition
+from pycatan.actions import GamePhase
+from pycatan.statuses import Statuses
+from pycatan.game_manager import GameManager
+from pycatan.human_user import HumanUser
+from pycatan.console_visualization import ConsoleVisualization
+
+def test_knight_with_visualizations():
+    """Test that Knight card logs appear in visualizations."""
+    print("\n" + "="*60)
+    print("Testing Knight Card with Visualization Logs")
+    print("="*60)
+    
+    # Create users
+    users = [HumanUser("Alice", 0), HumanUser("Bob", 1), HumanUser("Charlie", 2)]
+    
+    # Create console visualization
+    console_viz = ConsoleVisualization()
+    
+    # Create game manager
+    gm = GameManager(users=users)
+    
+    # Setup visualization manager
+    from pycatan.visualization import VisualizationManager
+    gm.visualization_manager = VisualizationManager()
+    gm.visualization_manager.add_visualization(console_viz)
+    
+    # Setup game manually
+    gm.game.game_phase = GamePhase.NORMAL_PLAY
+    
+    # Give player 0 (Alice) a Knight card
+    gm.game.players[0].add_dev_card(DevCard.Knight)
+    
+    # Give player 1 (Bob) some resource cards
+    gm.game.players[1].add_cards([ResCard.Wheat, ResCard.Wood, ResCard.Brick])
+    
+    # Add a settlement for player 1 at a point adjacent to tile 5
+    tile = gm.game.board.tiles[1][1]  # Tile 5 is at (1,1)
+    if tile.points:
+        settlement_point = tile.points[0]
+        gm.game.add_settlement(player=1, point=settlement_point, is_starting=True)
+        
+        print(f"\n✓ Game setup complete")
+        print(f"  - Alice has {len(gm.game.players[0].dev_cards)} Knight card")
+        print(f"  - Bob has {len(gm.game.players[1].cards)} resource cards")
+        
+        # Create Knight action directly
+        from pycatan.actions import Action, ActionType
+        
+        knight_action = Action(
+            action_type=ActionType.USE_DEV_CARD,
+            player_id=0,
+            parameters={
+                'card_type': DevCard.Knight,
+                'tile_id': 5,
+                'victim_name': 'Bob'
+            }
+        )
+        
+        print(f"\n🧪 Executing Knight card action...")
+        print(f"   This should send logs to the visualization\n")
+        
+        # Execute through GameManager
+        result = gm._use_knight_card(knight_action)
+        
+        if result.success:
+            print(f"\n✅ Knight card executed successfully!")
+            print(f"   Logs should have been displayed above with:")
+            print(f"   1. ⚔️ Knight card used message")
+            print(f"   2. 🎯 Card stolen message (with card type)")
+        else:
+            print(f"❌ Failed: {result.error_message}")
+    else:
+        print("❌ Could not find points on tile")
+    
+    print("\n" + "="*60)
+    print("Test Complete!")
+    print("="*60)
+
+if __name__ == "__main__":
+    test_knight_with_visualizations()