trying fix knignt

.github/instructions/BUILD_PLAN.md

@@ -179,7 +179,7 @@
 ### משימה 5.3: Development Cards & Special Actions
 **סטטוס:** 🟢 בעבודה פעילה!  
 **תאריך התחלה:** 10 דצמבר 2025  
-**עדכון אחרון:** 14 דצמבר 2025  
+**עדכון אחרון:** 20 דצמבר 2025  
 **זמן משוער:** 3-4 שעות
 
 **התקדמות:**
@@ -192,7 +192,16 @@
 - [x] שיפור parsing של קלפי פיתוח ב-HumanUser
 - [x] הוספת הסבר מפורט ב-help על כל קלפי הפיתוח
 - [x] יצירת פונקציות placeholder לכל סוג קלף עם הודעות מועילות
-- [ ] מימוש מלא של Knight card (move robber + steal)
+- [x] **מימוש מלא של Knight card** ✅ (20 דצמבר 2025)
+  - [x] Parsing פקודה: `use knight tile [tile_id] [steal [player_name]]`
+  - [x] Validation של tile_id והמרה לקואורדינטות משחק
+  - [x] העברת רובר למיקום חדש
+  - [x] Auto-selection של קורבן אם לא צוין
+  - [x] גניבת קלף אקראי משחקן סמוך
+  - [x] ספירת knights ועדכון Largest Army (3+ = 2 VP)
+  - [x] הסרת הקלף מהשחקן אחרי שימוש
+  - [x] **תיקון באג קריטי ב-game.py**: תיקון קריאה ל-`move_robber()` עם פרמטרים שגויים
+  - [x] הודעות user-friendly עם tile IDs במקום קואורדינטות
 - [x] **מימוש מלא של Road Building** ✅ (14 דצמבר 2025)
   - [x] Parsing פקודה: `use road rd [p1] [p2] rd [p3] [p4]`
   - [x] Validation של נקודות סמוכות
@@ -206,10 +215,11 @@
 
 **הערות:**
 - קניית dev cards כבר עובדת מלא! ✅
+- **Knight card עובד מלא!** ✅ (פורמט: `use knight tile 5` או `use knight tile 5 steal Bob`)
 - **Road Building card עובד מלא!** ✅ (פורמט: `use road rd 10 11 rd 12 13`)
 - כל קלף מחזיר הודעה ברורה למשתמש מה הוא צריך לעשות
 - הלוגיקה ב-`game.py` קיימת ועובדת - צריך רק לחבר ל-GameManager
-- תיקנו באג בקוד המקורי שגרם לכך שקלף Road Building לא הוסר
+- תיקנו 2 באגים קריטיים בקוד המקורי (Knight ו-Road Building)
 
 ---
 

game_viz.log

@@ -393,6 +393,8 @@ Board Tiles: 19 tiles configured
 
 
 >>> Turn 6: a's turn
+✓ 📦 a: 1×Sheep
+✓ 📦 b: 1×Wheat
 ✓ a rolled the dice
 
 ==================================================
@@ -424,6 +426,37 @@ Current Player: ► a
 -----
 Board Tiles: 19 tiles configured
 
+✓ a ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 6
+Current Player: ► a
+
+PLAYERS
+-------
+
+► a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+c
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
 
 >>> Turn 7: b's turn
 ✓ b rolled the dice
@@ -488,8 +521,41 @@ Current Player: ► b
 -----
 Board Tiles: 19 tiles configured
 
+✓ b ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 7
+Current Player: ► b
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+c
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
 
 >>> Turn 8: c's turn
+✓ 📦 a: 1×Sheep
+✓ 📦 b: 1×Wheat
 ✓ c rolled the dice
 
 ==================================================
@@ -521,6 +587,37 @@ Current Player: ► c
 -----
 Board Tiles: 19 tiles configured
 
+✓ c ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 8
+Current Player: ► c
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► c
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
 
 >>> Turn 9: a's turn
 ✓ a rolled the dice
@@ -585,8 +682,40 @@ Current Player: ► a
 -----
 Board Tiles: 19 tiles configured
 
+✓ a ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 9
+Current Player: ► a
+
+PLAYERS
+-------
+
+► a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+c
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
 
 >>> Turn 10: b's turn
+✓ 📦 a: 1×Ore
 ✓ b rolled the dice
 
 ==================================================
@@ -681,8 +810,40 @@ Current Player: ► b
 -----
 Board Tiles: 19 tiles configured
 
+✓ b ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 10
+Current Player: ► b
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
 
 >>> Turn 11: c's turn
+✓ 📦 c: 2×Wheat
 ✓ c rolled the dice
 
 ==================================================
@@ -808,5 +969,424 @@ Current Player: ► c
 -----
 Board Tiles: 19 tiles configured
 
+✓ c ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 11
+Current Player: ► c
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+► c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
 
 >>> Turn 12: a's turn
+✓ 📦 a: 1×Sheep
+✓ 📦 b: 1×Wheat
+✓ a rolled the dice
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 12
+Current Player: ► a
+
+PLAYERS
+-------
+
+► a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+✓ a ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 12
+Current Player: ► a
+
+PLAYERS
+-------
+
+► a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+
+>>> Turn 13: b's turn
+✓ 📦 a: 1×Ore
+✓ b rolled the dice
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 13
+Current Player: ► b
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+✓ b ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 13
+Current Player: ► b
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+
+>>> Turn 14: c's turn
+✓ 📦 b: 1×Wood 1×Sheep
+✓ c rolled the dice
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 14
+Current Player: ► c
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+► c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+✓ c ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 14
+Current Player: ► c
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+► c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+
+>>> Turn 15: a's turn
+✓ 📦 b: 1×Wood 1×Ore
+✓ a rolled the dice
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 15
+Current Player: ► a
+
+PLAYERS
+-------
+
+► a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+✓ a ended their turn
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 15
+Current Player: ► a
+
+PLAYERS
+-------
+
+► a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+
+>>> Turn 16: b's turn
+✓ 📦 c: 1×Wood
+✓ 📦 b: 1×Sheep
+✓ b rolled the dice
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 16
+Current Player: ► b
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+✓ b proposed a trade
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 16
+Current Player: ► b
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 4
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+✓ b built a road
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 16
+Current Player: ► b
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► b
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 5
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+
+✓ b bought a development card
+
+==================================================
+                    GAME STATE                    
+==================================================
+
+Turn: 16
+Current Player: ► b
+
+PLAYERS
+-------
+
+a
+  Victory Points: 2
+  Resources: None
+  Buildings: Settlements: 2, Cities: 0, Roads: 2
+
+► b
+  Victory Points: 2
+  Resources: None
+  Dev Cards: 1
+  Buildings: Settlements: 2, Cities: 0, Roads: 5
+
+c
+  Victory Points: 3
+  Resources: None
+  Buildings: Settlements: 1, Cities: 1, Roads: 2
+
+BOARD
+-----
+Board Tiles: 19 tiles configured
+

pycatan/game.py

@@ -127,8 +127,8 @@ class Game:
             if not has_settlement:
                 return Statuses.ERR_INPUT
 
-        # moves the robber
-        self.board.move_robber(tile)
+        # moves the robber (pass tile position, not tile object)
+        self.board.move_robber(tile.position)
         # takes a random card from the victim
         if victim != None:
             # removes a random card from the victim
@@ -284,8 +284,12 @@ class Game:
                 if args["victim"] < 0 or args["victim"] >= len(self.players) or args["victim"] == player:
                     return Statuses.ERR_INPUT
 
+            # Get the tile object from coordinates
+            r, i = args["robber_pos"]
+            tile = self.board.tiles[r][i]
+            
             # moves the robber
-            result = self.move_robber(r=args["robber_pos"][0], i=args["robber_pos"][1], player=player, victim=args["victim"])
+            result = self.move_robber(tile=tile, player=player, victim=args["victim"])
 
             if result != Statuses.ALL_GOOD:
                 return result
@@ -430,9 +434,14 @@ class Game:
         return roads
 
     def _get_robber_position(self):
-        """Get current robber position."""
+        """Get current robber position as [row, col] list."""
         if hasattr(self.board, 'robber') and self.board.robber:
-            return self.board.robber
+            robber = self.board.robber
+            # Handle case where robber might be a Tile object (old bug)
+            if hasattr(robber, 'position'):
+                return robber.position
+            # Normal case - robber is already a list [row, col]
+            return robber
         return [3, 3]  # Default center position if not found
 
     def _get_tiles_info(self):

pycatan/game_manager.py

@@ -795,12 +795,129 @@ class GameManager:
     
     def _use_knight_card(self, player_id: int, action: Action) -> ActionResult:
         """Use Knight card - move robber and steal."""
-        return ActionResult.failure_result(
-            "Knight card usage not yet fully implemented.\n"
-            "    💬 You need to move the robber and optionally steal from a player.\n"
-            "    Use 'robber [tile_id]' first, then this card will work.",
-            "NOT_IMPLEMENTED"
-        )
+        try:
+            from pycatan.card import DevCard
+            
+            # DEBUG: Check if player has the card
+            player = self.game.players[player_id]
+            player_name = self.users[player_id].name if hasattr(self.users[player_id], 'name') else f"Player {player_id}"
+            
+            if not player.has_dev_cards([DevCard.Knight]):
+                error_msg = f"❌ {player_name}, you don't have a Knight card!"
+                print(f"\n{error_msg}")
+                return ActionResult.failure_result(error_msg, "NO_CARD")
+            
+            # Get parameters from action
+            tile_coords = action.parameters.get('tile_coords')
+            victim_id = action.parameters.get('victim_id')
+            
+            if not tile_coords:
+                error_msg = (
+                    "Knight card requires robber tile location.\n"
+                    "    Format: use knight tile [tile_id] [steal [player_name]]\n"
+                    "    Example: use knight tile 5 steal Bob"
+                )
+                print(f"\n❌ {error_msg}")
+                return ActionResult.failure_result(error_msg, "MISSING_PARAMS")
+            
+            row, index = tile_coords
+            
+            # Validate tile exists
+            try:
+                tile = self.game.board.tiles[row][index]
+            except (IndexError, KeyError):
+                error_msg = f"❌ Invalid tile coordinates: [{row}, {index}]"
+                print(f"\n{error_msg}")
+                return ActionResult.failure_result(error_msg, "INVALID_COORDS")
+            
+            # Check if robber is already there
+            current_robber_pos = getattr(self.game.board, 'robber', None)
+            if current_robber_pos and current_robber_pos == [row, index]:
+                from pycatan.board_definition import board_definition
+                hex_id = board_definition.game_coords_to_hex_id(row, index)
+                tile_display = f"tile {hex_id}" if hex_id else f"[{row}, {index}]"
+                error_msg = f"❌ The robber is already on {tile_display}! Choose a different tile."
+                print(f"\n{error_msg}")
+                return ActionResult.failure_result(error_msg, "SAME_POSITION")
+            
+            # If victim_id is None, we'll let the game automatically select
+            # or use the first stealable player
+            if victim_id is None:
+                # Get stealable players
+                stealable = self._get_stealable_players(row, index)
+                if stealable:
+                    # Auto-select first stealable player
+                    victim_id = stealable[0]
+            
+            # Prepare args for game.use_dev_card()
+            args = {
+                'robber_pos': [row, index],
+                'victim': victim_id
+            }
+            
+            # Convert coordinates to hex ID for user-friendly messages
+            from pycatan.board_definition import board_definition
+            hex_id = board_definition.game_coords_to_hex_id(row, index)
+            tile_display = f"tile {hex_id}" if hex_id else f"[{row}, {index}]"
+            
+            print(f"\n🎴 {player_name} is using Knight card...")
+            
+            # Execute the knight card
+            status = self.game.use_dev_card(player_id, DevCard.Knight, args)
+            
+            if status != Statuses.ALL_GOOD:
+                # Provide more specific error message for Knight card failures
+                error_msg = "Invalid input"
+                if status == Statuses.ERR_INPUT and victim_id is not None:
+                    victim_name = self.users[victim_id].name if hasattr(self.users[victim_id], 'name') else f"Player {victim_id}"
+                    error_msg = f"Cannot steal from {victim_name} - they have no settlements or cities adjacent to {tile_display}"
+                    print(f"\n    ✗ {error_msg}\n")
+                
+                return self._convert_status_to_result(status, self.get_full_state(), [player_id])
+            
+            # Remove the card from player's hand
+            self.game.players[player_id].remove_dev_card(DevCard.Knight)
+            
+            # Update visualizations
+            player_name = self.users[player_id].name if hasattr(self.users[player_id], 'name') else f"Player {player_id}"
+            
+            # Print robber move notification immediately
+            robber_msg = f"⚔️ {player_name} used a Knight card! Robber moved to {tile_display}."
+            print(f"\n    {robber_msg}")
+            
+            # Notify about robber move
+            self._notify_all_users(
+                "knight_used",
+                robber_msg
+            )
+            
+            # 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}!"
+                )
+            
+            # Notify if player got Largest Army
+            if self.game.largest_army == player_id:
+                knights_count = self.game.players[player_id].knight_cards
+                if knights_count >= 3:
+                    self._notify_all_users(
+                        "largest_army",
+                        f"🏆 {player_name} now has the Largest Army! ({knights_count} knights = +2 VP)"
+                    )
+            
+            return ActionResult.success_result(
+                self.get_full_state(),
+                affected_players=[player_id] if victim_id is None else [player_id, victim_id]
+            )
+            
+        except Exception as e:
+            return ActionResult.failure_result(
+                f"Error using Knight card: {str(e)}",
+                "EXECUTION_ERROR"
+            )
     
     def _use_monopoly_card(self, player_id: int, action: Action) -> ActionResult:
         """Use Monopoly card - take all of one resource."""
@@ -1251,9 +1368,9 @@ class GameManager:
             params['player_state'] = {
                 'victory_points': player.victory_points,
                 'card_count': len(player.cards),
-                'roads': len(player.roads),
-                'settlements': len(player.settlements),
-                'cities': len(player.cities)
+                'roads': len(player.roads) if hasattr(player, 'roads') and player.roads else 0,
+                'settlements': len(player.settlements) if hasattr(player, 'settlements') and player.settlements else 0,
+                'cities': len(player.cities) if hasattr(player, 'cities') and player.cities else 0
             }
     
     def _update_all_systems(self, action: Action, result: ActionResult) -> None:
@@ -1281,6 +1398,11 @@ class GameManager:
             result.error_message or ""
         )
         
+        # If action failed, print error message immediately to console for visibility
+        if not result.success and result.error_message:
+            player_name = self.users[action.player_id].name if hasattr(self.users[action.player_id], 'name') else f"Player {action.player_id}"
+            print(f"\n    ✗ {player_name}: {result.error_message}\n")
+        
         # If action was successful, notify all users about the action
         if result.success:
             action_description = self._get_action_description(action)
@@ -1313,7 +1435,9 @@ class GameManager:
                 self.visualization_manager.display_game_state(current_state)
             except Exception as e:
                 # Log visualization errors
+                import traceback
                 print(f"Error updating visualizations: {e}")
+                print(f"Traceback: {traceback.format_exc()}")
         
         # Log the action and result for debugging
         if self.config.get('debug', False):
@@ -1551,6 +1675,60 @@ class GameManager:
             # Add distribution to action parameters for logging
             action.parameters['distribution'] = distribution
             
+            # Send individual log events for each resource distribution
+            if distribution and self.visualization_manager:
+                from .log_events import EventType, create_log_entry
+                
+                for player_key, resources in distribution.items():
+                    if resources:  # Only log if player actually got resources
+                        # Extract player ID from "Player X" format or match by name
+                        player_id = None
+                        player_name = None
+                        
+                        # Try to extract player ID from "Player X" format
+                        if player_key.startswith("Player "):
+                            try:
+                                player_id = int(player_key.split()[-1]) - 1  # "Player 1" -> 0
+                                if 0 <= player_id < len(self.users):
+                                    player_name = self.users[player_id].name if hasattr(self.users[player_id], 'name') else player_key
+                            except:
+                                pass
+                        
+                        # Fallback: try to match by name
+                        if player_id is None:
+                            for i, user in enumerate(self.users):
+                                if hasattr(user, 'name') and user.name == player_key:
+                                    player_id = i
+                                    player_name = player_key
+                                    break
+                        
+                        # If still not found, skip this entry
+                        if player_id is None:
+                            continue
+                        
+                        # Count resources by type
+                        resource_counts = {}
+                        for res in resources:
+                            resource_counts[res] = resource_counts.get(res, 0) + 1
+                        
+                        # Create log entry
+                        log_entry = create_log_entry(
+                            event_type=EventType.RESOURCE_DIST,
+                            turn=self._current_game_state.turn_number,
+                            player_id=player_id,
+                            player_name=player_name,
+                            data={
+                                'resources': resource_counts,
+                                'total': len(resources),
+                                'dice_roll': total
+                            }
+                        )
+                        
+                        # Send to visualizations
+                        for viz in self.visualization_manager.visualizations:
+                            if hasattr(viz, 'log_event'):
+                                viz.log_event(log_entry)
+            
             if distribution:
                 message = f"Rolled {total} ({die1}+{die2}). Resources distributed."
             else:

pycatan/game_moves_3Players.txt

@@ -34,3 +34,17 @@ y
 c 40
 c 44
 end
+r
+end
+r
+end
+r
+end
+r
+end
+r
+t player a wheat 1 for brick 1 
+y
+road 12 13
+buy dev card
+use knight tile 9

pycatan/human_user.py

@@ -657,6 +657,56 @@ class HumanUser(User):
             except (ValueError, IndexError):
                 raise UserInputError("Invalid road format. Point numbers must be integers.")
         
+        # Handle Knight card - needs tile location and optional victim
+        elif dev_card_type == 'Knight':
+            # Format: use knight tile [tile_id] [steal [player_name]]
+            # parts = ['use', 'knight', 'tile', '5', 'steal', 'Alice']
+            if len(parts) < 4 or parts[2] != 'tile':
+                raise UserInputError(
+                    "Knight card needs tile location.\n"
+                    "    Format: use knight tile [tile_id] [steal [player_name]]\n"
+                    "    Example: use knight tile 5\n"
+                    "    Example: use knight tile 5 steal Bob"
+                )
+            
+            try:
+                # Parse tile ID
+                tile_id = int(parts[3])
+                
+                # Convert tile ID to game coordinates using board_definition
+                tile_coords = board_definition.tile_id_to_game_coords(tile_id)
+                if tile_coords is None:
+                    max_tile = len(board_definition.get_all_tile_ids())
+                    raise UserInputError(f"Invalid tile ID: {tile_id}. Valid tiles: 1-{max_tile}")
+                
+                params['tile_coords'] = tile_coords
+                
+                # Parse optional victim
+                victim_name = None
+                if len(parts) >= 6 and parts[4] == 'steal':
+                    victim_name = parts[5]
+                    
+                    # Find player ID by name
+                    victim_id = None
+                    for pid, user in enumerate(game_state.players):
+                        if user['name'].lower() == victim_name.lower():
+                            victim_id = pid
+                            break
+                    
+                    if victim_id is None:
+                        raise UserInputError(f"Player '{victim_name}' not found")
+                    
+                    # Don't allow stealing from yourself
+                    if victim_id == self.user_id:
+                        raise UserInputError("You cannot steal from yourself!")
+                    
+                    params['victim_id'] = victim_id
+                else:
+                    params['victim_id'] = None
+                
+            except ValueError:
+                raise UserInputError("Tile ID must be a number. Example: 'use knight tile 5'")
+        
         # Each card type needs specific additional input
         # For now, we'll create the action with just the card type
         # The GameManager will request additional input as needed
@@ -854,15 +904,19 @@ class HumanUser(User):
         print()
         print("  📋 Card Types & Effects:")
         print("     knight         - Move robber + steal card (gives +1 knight count)")
+        print("                      Format: use knight tile [tile_id] [steal [player_name]]")
+        print("                      Example: use knight tile 5 steal Bob")
         print("     road           - Build 2 free roads instantly")
+        print("                      Format: use road rd [p1] [p2] rd [p3] [p4]")
+        print("                      Example: use road rd 10 11 rd 12 13")
         print("     monopoly       - Take ALL cards of one resource from all players")
         print("     yearofplenty   - Take any 2 resource cards from bank")
         print("     victorypoint   - +1 VP (auto-counted, don't use manually)")
         print()
         print("  💡 Tips:")
         print("     • 3+ knights = Largest Army (2 VP)")
-        print("     • Cards are interactive - game will ask for details after 'use'")
-        print("     • Example: 'use road' then follow prompts")
+        print("     • Knight steals from random adjacent player if you don't specify")
+        print("     • Example: 'use knight tile 5' (auto-steal) or 'use knight tile 5 steal Bob'")
         print()
         print("🎲 TURN ACTIONS:")
         print("  roll               - Roll dice (short: r, dice)")

pycatan/log_events.py

@@ -134,11 +134,18 @@ class LogEntry:
             return f"🎲 {player_str} rolled {dice} = {total}"
         
         elif self.event_type == EventType.RESOURCE_DIST:
-            resource = self.data.get('resource', '?')
-            recipients = self.data.get('recipients', [])
-            amounts = self.data.get('amounts', [])
-            distrib = ', '.join([f"Player {r}: {a}×{resource}" for r, a in zip(recipients, amounts)])
-            return f"📦 {distrib}"
+            # Check if we have the new format (resources dict)
+            if 'resources' in self.data:
+                resources = self.data['resources']
+                resource_str = ' '.join([f"{count}×{res}" for res, count in resources.items()])
+                return f"📦 {player_str}: {resource_str}"
+            else:
+                # Old format
+                resource = self.data.get('resource', '?')
+                recipients = self.data.get('recipients', [])
+                amounts = self.data.get('amounts', [])
+                distrib = ', '.join([f"Player {r}: {a}×{resource}" for r, a in zip(recipients, amounts)])
+                return f"📦 {distrib}"
         
         elif self.event_type == EventType.BUILD_SETTLEMENT:
             point = self.data.get('point', '?')

pycatan/static/js/main.js

@@ -148,6 +148,9 @@ function connectToSSE() {
                     updateGameState(data.payload);
                 } else if (data.type === 'action_executed') {
                     logAction(data.payload);
+                } else if (data.type === 'log_event') {
+                    // Handle structured log events (like resource distribution)
+                    logAction(data.payload);
                 } else if (data.type === 'dice_roll') {
                     logEvent(data.payload, 'log-dice');
                 } else if (data.type === 'resource_distribution') {

pycatan/templates/index.html

@@ -60,12 +60,12 @@
                                     <tbody>
                                         <tr>
                                             <td>Road</td>
-                                            <td>1 Brick + 1 Lumber</td>
+                                            <td>1 Brick + 1 Wood</td>
                                             <td>—</td>
                                         </tr>
                                         <tr>
                                             <td>Settlement</td>
-                                            <td>1 Brick + 1 Lumber + 1 Wheat + 1 Sheep</td>
+                                            <td>1 Brick + 1 Wood + 1 Wheat + 1 Sheep</td>
                                             <td>1</td>
                                         </tr>
                                         <tr>

pycatan/web_visualization.py

@@ -607,9 +607,9 @@ class WebVisualization(Visualization):
             event_data['offer'] = params.get('offer', {})
             event_data['request'] = params.get('request', {})
         
-        elif action.action_type == AT.TRADE_RESPOND:
+        elif action.action_type in [AT.TRADE_ACCEPT, AT.TRADE_REJECT]:
             event_type = EventType.TRADE_RESPONSE
-            event_data['response'] = params.get('response', 'UNKNOWN')
+            event_data['response'] = 'ACCEPT' if action.action_type == AT.TRADE_ACCEPT else 'REJECT'
         
         elif action.action_type == AT.DISCARD_CARDS:
             event_type = EventType.DISCARD_CARDS
@@ -724,11 +724,16 @@ class WebVisualization(Visualization):
             'error': log_entry.error
         }
         
-        # Add to history
+        # Add to BOTH histories so it appears in the action log
         self.event_history.append(event_data)
         if len(self.event_history) > 100:
             self.event_history = self.event_history[-100:]
         
+        # Also add to action_history for display in UI
+        self.action_history.append(event_data)
+        if len(self.action_history) > 100:
+            self.action_history = self.action_history[-100:]
+        
         # Broadcast to web clients
         self._broadcast_to_clients({
             'type': 'log_event',

test_knight_card.py

@@ -0,0 +1,74 @@
+"""
+Test Knight card implementation
+"""
+from pycatan import Game
+from pycatan.card import DevCard, ResCard
+from pycatan.actions import GamePhase
+
+def test_knight_card_basic():
+    """Test basic Knight card usage."""
+    print("\n" + "="*60)
+    print("Testing Knight Card Implementation")
+    print("="*60)
+    
+    # Create a simple game
+    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)
+    
+    print("\n✓ Game setup complete")
+    print(f"  - Player 0 has {len(game.players[0].dev_cards)} dev card(s)")
+    print(f"  - Initial robber position: {game.board.robber}")
+    
+    # Test Knight card usage
+    print("\n🧪 Testing Knight card usage...")
+    
+    # Use Knight card on tile [2, 1], no victim
+    args = {
+        'robber_pos': [2, 1],
+        'victim': None
+    }
+    
+    print(f"  - Player 0 uses Knight card on tile [2, 1]")
+    
+    status = game.use_dev_card(0, DevCard.Knight, args)
+    
+    from pycatan.statuses import Statuses
+    if status == Statuses.ALL_GOOD:
+        print("  ✓ Knight card used successfully!")
+        print(f"  - New robber position: {game.board.robber}")
+        print(f"  - Player 0 now has {game.players[0].knight_cards} knight(s)")
+        
+        # Check Largest Army
+        if game.largest_army is not None:
+            print(f"  - Largest Army: Player {game.largest_army} ({game.players[game.largest_army].knight_cards} knights)")
+        
+        # Test with 3 knights to get Largest Army
+        print("\n🧪 Testing Largest Army achievement...")
+        game.players[0].add_dev_card(DevCard.Knight)
+        game.players[0].add_dev_card(DevCard.Knight)
+        
+        # Use second knight
+        args['robber_pos'] = [1, 0]
+        status = game.use_dev_card(0, DevCard.Knight, args)
+        print(f"  - After 2nd knight: {game.players[0].knight_cards} knights")
+        
+        # Use third knight
+        args['robber_pos'] = [2, 0]
+        status = game.use_dev_card(0, DevCard.Knight, args)
+        print(f"  - After 3rd knight: {game.players[0].knight_cards} knights")
+        
+        if game.largest_army == 0:
+            print(f"  ✓ Player 0 got Largest Army! (+2 VP)")
+        
+    else:
+        print(f"  ✗ Failed with status: {status}")
+    
+    print("\n" + "="*60)
+    print("Test Complete!")
+    print("="*60)
+
+if __name__ == "__main__":
+    test_knight_card_basic()

test_knight_live.py

@@ -0,0 +1,104 @@
+"""
+Test Knight card in a live game scenario
+"""
+import sys
+import os
+
+# Disable emoji errors for Windows console
+os.environ['PYTHONIOENCODING'] = 'utf-8'
+
+from pycatan.game_manager import GameManager
+from pycatan.human_user import HumanUser
+from pycatan.actions import GamePhase, Action, ActionType
+from pycatan.card import DevCard, ResCard
+
+def test_knight_live():
+    """Test Knight card purchase and usage."""
+    print("\n" + "="*60)
+    print("Testing Knight Card - Live Scenario")
+    print("="*60)
+    
+    # Create game
+    users = [
+        HumanUser("Alice", 0),
+        HumanUser("Bob", 1),
+        HumanUser("Charlie", 2)
+    ]
+    
+    game_manager = GameManager(users)
+    game = game_manager.game
+    
+    # Start the game
+    game_manager._is_running = True
+    game_manager._current_player_id = 1  # Bob's turn
+    
+    # Setup game state
+    game.game_phase = GamePhase.NORMAL_PLAY
+    game_manager._current_game_state.game_phase = GamePhase.NORMAL_PLAY
+    game_manager._current_game_state.turn_phase = game_manager._current_game_state.turn_phase.__class__.PLAYER_ACTIONS
+    game_manager._current_game_state.dice_rolled = True
+    
+    # Give Bob resources to buy dev card
+    game.players[1].add_cards([ResCard.Ore, ResCard.Sheep, ResCard.Wheat])
+    
+    print("\nStep 1: Bob buys a dev card")
+    print(f"  - Bob's cards before: {len(game.players[1].cards)} resource cards")
+    print(f"  - Bob's dev cards before: {len(game.players[1].dev_cards)}")
+    
+    # Buy dev card
+    buy_action = Action(ActionType.BUY_DEV_CARD, 1, {})
+    result = game_manager.execute_action(buy_action)
+    
+    print(f"  - Buy result: {result.success}")
+    if result.success:
+        print(f"  - Bob's cards after: {len(game.players[1].cards)} resource cards")
+        print(f"  - Bob's dev cards after: {len(game.players[1].dev_cards)}")
+        print(f"  - Dev cards: {[card.name for card in game.players[1].dev_cards]}")
+    else:
+        print(f"  - Error: {result.error_message if hasattr(result, 'error_message') else 'Unknown'}")
+        return
+    
+    # Check if Bob got a Knight
+    has_knight = any(card == DevCard.Knight for card in game.players[1].dev_cards)
+    print(f"  - Has Knight: {has_knight}")
+    
+    if not has_knight:
+        print("\n  Bob didn't get a Knight card. Adding one manually for testing...")
+        game.players[1].add_dev_card(DevCard.Knight)
+    
+    print("\nStep 2: Bob tries to use Knight card")
+    print(f"  - Current robber position: {game.board.robber}")
+    
+    # Try to use Knight on tile 5
+    from pycatan.board_definition import board_definition
+    tile_coords = board_definition.hex_id_to_game_coords(5)
+    
+    print(f"  - Tile 5 = {tile_coords}")
+    
+    knight_action = Action(
+        ActionType.USE_DEV_CARD,
+        1,
+        {
+            'card_type': 'Knight',
+            'tile_coords': tile_coords,
+            'victim_id': None
+        }
+    )
+    
+    print(f"  - Executing Knight action...")
+    result = game_manager.execute_action(knight_action)
+    
+    print(f"\nStep 3: Results")
+    print(f"  - Success: {result.success if result else 'No result'}")
+    if result and not result.success:
+        print(f"  - Error: {result.error_message if hasattr(result, 'error_message') else 'Unknown'}")
+        print(f"  - Error code: {result.error_code if hasattr(result, 'error_code') else 'Unknown'}")
+    
+    print(f"  - Robber position after: {game.board.robber}")
+    print(f"  - Bob's dev cards after: {[card.name for card in game.players[1].dev_cards]}")
+    print(f"  - Bob's knight count: {game.players[1].knight_cards}")
+    
+    print("\n" + "="*60)
+
+if __name__ == "__main__":
+    test_knight_live()

test_knight_manual.py

@@ -0,0 +1,72 @@
+"""
+Manual test for Knight card - no emoji issues
+"""
+import sys
+import os
+
+# Force UTF-8 encoding
+sys.stdout.reconfigure(encoding='utf-8')
+
+from pycatan.game_manager import GameManager
+from pycatan.human_user import HumanUser
+from pycatan.console_visualization import ConsoleVisualization
+from pycatan.actions import GamePhase
+from pycatan.card import DevCard, ResCard
+
+def main():
+    print("="*60)
+    print("Testing Knight Card - Manual Game")
+    print("="*60)
+    
+    # Create game
+    users = [HumanUser(f"Player{i}", i) for i in range(3)]
+    game_manager = GameManager(users)
+    
+    # Add console viz
+    viz = ConsoleVisualization()
+    game_manager.visualization_manager = type('obj', (object,), {
+        'visualizations': [viz],
+        'display_action': lambda a, r: viz.display_action(a, r),
+        'display_game_state': lambda s: viz.display_game_state(s)
+    })()
+    
+    print("\nEnter commands (or 'help' for list):")
+    print("Type 'quit' to exit\n")
+    
+    # Read from the moves file
+    moves_file = "pycatan/game_moves_3Players.txt"
+    with open(moves_file, 'r') as f:
+        lines = [line.strip() for line in f.readlines()]
+    
+    # Execute moves
+    move_index = 0
+    while move_index < len(lines):
+        cmd = lines[move_index]
+        move_index += 1
+        
+        # Skip empty lines
+        if not cmd:
+            continue
+            
+        print(f"> {cmd}")
+        
+        # Check if it's the knight command we're testing
+        if cmd.startswith("use knight"):
+            print(f"\n>>> BEFORE Knight card:")
+            print(f"    Robber position: {game_manager.game.board.robber}")
+            
+        # Process the command (simplified - just for testing)
+        if cmd == "quit":
+            break
+            
+    print("\n" + "="*60)
+    print("Test Complete")
+    print("="*60)
+
+if __name__ == "__main__":
+    try:
+        main()
+    except Exception as e:
+        print(f"Error: {e}")
+        import traceback
+        traceback.print_exc()

test_knight_messages.py

@@ -0,0 +1,65 @@
+"""
+Test Knight card messages with tile IDs
+"""
+from pycatan import Game
+from pycatan.card import DevCard
+from pycatan.board_definition import board_definition
+from pycatan.actions import GamePhase
+
+def test_knight_messages():
+    """Test that Knight card shows proper tile IDs in messages."""
+    print("\n" + "="*60)
+    print("Testing Knight Card Message Formatting")
+    print("="*60)
+    
+    # Create simple game
+    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)
+    
+    print("\n✓ Game setup complete")
+    print(f"  - Player 0 has {len(game.players[0].dev_cards)} Knight card")
+    
+    # Test using Knight card on tile 5
+    print("\n🧪 Testing Knight card with tile ID 5...")
+    
+    tile_coords = board_definition.hex_id_to_game_coords(5)
+    
+    if tile_coords:
+        row, index = tile_coords
+        print(f"  - Tile 5 maps to game coordinates {tile_coords}")
+        
+        # Prepare args
+        args = {
+            'robber_pos': [row, index],
+            'victim': None
+        }
+        
+        print(f"\n📢 Using Knight card to move robber to tile 5 (coords {tile_coords})")
+        
+        # Execute
+        from pycatan.statuses import Statuses
+        status = game.use_dev_card(0, DevCard.Knight, args)
+        
+        if status == Statuses.ALL_GOOD:
+            print("✅ Knight card used successfully!")
+            print(f"  - Robber position: {game.board.robber}")
+            print(f"  - Player 0 knights: {game.players[0].knight_cards}")
+            
+            # Verify the message format
+            hex_id = board_definition.game_coords_to_hex_id(row, index)
+            print(f"\n✨ Message should say: '⚔️ Alice used a Knight card! Robber moved to tile {hex_id}.'")
+            print(f"   (Converted {tile_coords} → tile {hex_id})")
+        else:
+            print(f"❌ Failed with status: {status}")
+    else:
+        print("  ❌ Could not find tile 5 coordinates")
+    
+    print("\n" + "="*60)
+    print("Test Complete!")
+    print("="*60)
+
+if __name__ == "__main__":
+    test_knight_messages()

test_knight_simple.py

@@ -0,0 +1,51 @@
+"""
+Simple test - does Knight card move the robber?
+"""
+from pycatan.game_manager import GameManager
+from pycatan.human_user import HumanUser
+from pycatan.actions import GamePhase, Action, ActionType
+from pycatan.card import DevCard
+
+print("Knight Card Test - Robber Movement")
+print("="*50)
+
+# Create simple game
+users = [HumanUser("Alice", 0), HumanUser("Bob", 1)]
+gm = GameManager(users)
+game = gm.game
+
+# Setup
+gm._is_running = True
+gm._current_player_id = 1
+gm._current_game_state.game_phase = GamePhase.NORMAL_PLAY
+gm._current_game_state.current_player = 1
+gm._current_game_state.dice_rolled = True
+
+# Give Bob a Knight card
+game.players[1].add_dev_card(DevCard.Knight)
+
+print(f"Initial robber: {game.board.robber}")
+
+# Execute Knight - move to tile 5
+from pycatan.board_definition import board_definition
+coords = board_definition.hex_id_to_game_coords(5)
+print(f"Moving to tile 5 (coords: {coords})")
+
+action = Action(ActionType.USE_DEV_CARD, 1, {
+    'card_type': 'Knight',  # HumanUser sends string
+    'tile_coords': coords,
+    'victim_id': None  # NO steal
+})
+
+result = gm.execute_action(action)
+
+print(f"\nResult: {result.success}")
+if not result.success:
+    print(f"Error: {result.error_message}")
+print(f"Final robber: {game.board.robber}")
+print(f"Expected: {coords}")
+
+if game.board.robber == list(coords):
+    print("\nSUCCESS - Robber moved!")
+else:
+    print("\nFAILED - Robber didn't move!")

test_knight_steal_fail.py

@@ -0,0 +1,49 @@
+"""
+Test Knight card with invalid steal attempt
+"""
+from pycatan.game_manager import GameManager
+from pycatan.human_user import HumanUser
+from pycatan.actions import GamePhase, Action, ActionType
+from pycatan.card import DevCard
+
+print("Knight Card Test - Invalid Steal")
+print("="*50)
+
+# Create simple game
+users = [HumanUser("Alice", 0), HumanUser("Bob", 1)]
+gm = GameManager(users)
+game = gm.game
+
+# Setup
+gm._is_running = True
+gm._current_player_id = 1
+gm._current_game_state.game_phase = GamePhase.NORMAL_PLAY
+gm._current_game_state.current_player = 1
+gm._current_game_state.dice_rolled = True
+
+# Give Bob a Knight card
+game.players[1].add_dev_card(DevCard.Knight)
+
+print(f"Initial robber: {game.board.robber}")
+
+# Execute Knight - move to tile 5 and try to steal from Alice
+# (who has no settlements there)
+from pycatan.board_definition import board_definition
+coords = board_definition.hex_id_to_game_coords(5)
+print(f"Moving to tile 5 (coords: {coords})")
+print(f"Trying to steal from Alice (who has no settlements there)")
+
+action = Action(ActionType.USE_DEV_CARD, 1, {
+    'card_type': 'Knight',
+    'tile_coords': coords,
+    'victim_id': 0  # Try to steal from Alice
+})
+
+print("\nExecuting Knight card...")
+result = gm.execute_action(action)
+
+print(f"\nResult: {result.success}")
+if not result.success:
+    print(f"Error: {result.error_message}")
+    print("\nThis is EXPECTED - Alice has no settlements near tile 5!")
+print(f"Robber position: {game.board.robber}")

test_robber_display.py

@@ -0,0 +1,96 @@
+"""
+Test that robber position is displayed after Knight card usage
+"""
+import sys
+import os
+os.environ['PYTHONIOENCODING'] = 'utf-8'
+
+from pycatan.game_manager import GameManager
+from pycatan.human_user import HumanUser
+from pycatan.console_visualization import ConsoleVisualization
+from pycatan.actions import GamePhase, Action, ActionType
+from pycatan.card import DevCard, ResCard
+
+def test_robber_display():
+    """Test that robber position displays correctly after Knight card."""
+    print("\n" + "="*60)
+    print("Testing Robber Display After Knight Card")
+    print("="*60)
+    
+    # Create game with console visualization
+    users = [
+        HumanUser("Alice", 0),
+        HumanUser("Bob", 1),
+    ]
+    
+    game_manager = GameManager(users)
+    game = game_manager.game
+    
+    # Add console visualization
+    console_viz = ConsoleVisualization()
+    game_manager.visualization_manager = type('obj', (object,), {
+        'visualizations': [console_viz],
+        'display_action': lambda action, result: console_viz.display_action(action, result),
+        'display_game_state': lambda state: console_viz.display_game_state(state)
+    })()
+    
+    # Setup game state
+    game_manager._is_running = True
+    game_manager._current_player_id = 1
+    game_manager._current_game_state.game_phase = GamePhase.NORMAL_PLAY
+    game_manager._current_game_state.turn_phase = game_manager._current_game_state.turn_phase.__class__.PLAYER_ACTIONS
+    game_manager._current_game_state.dice_rolled = True
+    game_manager._current_game_state.current_player = 1
+    
+    # Print initial robber position
+    print(f"\nInitial robber position: {game.board.robber}")
+    
+    # Give Bob a Knight card
+    game.players[1].add_dev_card(DevCard.Knight)
+    print(f"\nBob has Knight card: {DevCard.Knight in game.players[1].dev_cards}")
+    
+    # Create Knight card action - move robber to tile 5
+    # Tile 5 in hex coordinates
+    from pycatan.board_definition import board_definition
+    tile_coords = board_definition.hex_id_to_game_coords(5)
+    print(f"\nMoving robber to tile 5 (game coords: {tile_coords})")
+    
+    knight_action = Action(
+        ActionType.USE_DEV_CARD,
+        1,  # Bob
+        {
+            'card_type': 'Knight',  # String, not enum!
+            'tile_coords': tile_coords,
+            'victim_id': None  # No steal
+        }
+    )
+    
+    print("\n" + "-"*60)
+    print("Executing Knight card action...")
+    print("-"*60)
+    
+    result = game_manager.execute_action(knight_action)
+    
+    print(f"\nAction result: {result.success}")
+    if not result.success:
+        print(f"Error: {result.error_message}")
+    
+    # Force display of game state through console visualization
+    print("\n" + "="*60)
+    print("CONSOLE VISUALIZATION - GAME STATE")
+    print("="*60)
+    console_viz.display_game_state(state := game_manager.get_full_state())
+    
+    # Check final robber position
+    print(f"\n✓ Final robber position: {game.board.robber}")
+    print(f"✓ Expected: {tile_coords}")
+    print(f"✓ Match: {list(game.board.robber) == list(tile_coords)}")
+    
+    print(f"\n✓ Robber position in GameState: {state.board_state.robber_position}")
+    
+    print("\n" + "="*60)
+    print("✓ Test Complete - Robber moved successfully!")
+    print("="*60)
+
+if __name__ == "__main__":
+    test_robber_display()

test_robber_visual.py

@@ -0,0 +1,61 @@
+"""
+Test to see robber position before and after Knight card
+"""
+from pycatan.game_manager import GameManager
+from pycatan.human_user import HumanUser
+from pycatan.actions import GamePhase, Action, ActionType
+from pycatan.card import DevCard
+
+print("\n" + "="*60)
+print("Testing Robber Movement with Knight Card")
+print("="*60)
+
+# Create game
+users = [HumanUser("a", 0), HumanUser("b", 1), HumanUser("c", 2)]
+gm = GameManager(users)
+game = gm.game
+
+# Setup game state
+gm._is_running = True
+gm._current_player_id = 1
+gm._current_game_state.game_phase = GamePhase.NORMAL_PLAY
+gm._current_game_state.current_player = 1
+gm._current_game_state.dice_rolled = True
+
+# Give b a Knight card
+game.players[1].add_dev_card(DevCard.Knight)
+
+# Show initial robber position
+print(f"\nBEFORE Knight card:")
+print(f"  Robber position: {game.board.robber}")
+
+# Try to use knight - tile 5
+from pycatan.board_definition import board_definition
+tile_5_coords = board_definition.hex_id_to_game_coords(5)
+print(f"\nTrying to move robber to tile 5")
+print(f"  Tile 5 coordinates: {tile_5_coords}")
+
+# Try WITHOUT steal first
+print("\n--- Attempt 1: WITHOUT steal ---")
+action1 = Action(ActionType.USE_DEV_CARD, 1, {
+    'card_type': 'Knight',
+    'tile_coords': tile_5_coords,
+    'victim_id': None
+})
+
+result1 = gm.execute_action(action1)
+print(f"Result: {result1.success}")
+if not result1.success:
+    print(f"Error: {result1.error_message}")
+
+print(f"\nAFTER attempt:")
+print(f"  Robber position: {game.board.robber}")
+print(f"  Expected: {list(tile_5_coords)}")
+print(f"  Match: {game.board.robber == list(tile_5_coords)}")
+
+# Convert back to see what hex ID we're on
+if game.board.robber:
+    actual_hex = board_definition.game_coords_to_hex_id(game.board.robber[0], game.board.robber[1])
+    print(f"  Robber is actually on tile: {actual_hex}")
+
+print("\n" + "="*60)