player.gd refactor progress

scripts/behaviors/conditions/has_ap.gd

@@ -6,7 +6,7 @@ func tick(actor: Node, blackboard: Blackboard) -> int:
 		return FAILURE
 		
 	# Always return SUCCESS for bots in non-turn-based mode
-	if actor.is_bot and not main.turn_based_mode:
+	if actor.is_bot and not TurnManager.turn_based_mode:
 		return SUCCESS
 		
 	# Update action points in blackboard

scripts/managers/game_state_manager.gd

@@ -5,7 +5,7 @@ extends Node
 signal game_started()
 signal game_state_changed()
 
-@export var enable_bots: bool = true
+@export var enable_bots: bool = false
 @export var max_players: int = 4
 
 var players: Array = []

scripts/managers/game_state_manager.gd.uid

@@ -0,0 +1 @@
+uid://qiysnc8g7v8x

scripts/managers/goal_manager.gd.uid

@@ -0,0 +1 @@
+uid://bfsev0xjqewcm

scripts/managers/obstacle_manager.gd.uid

@@ -0,0 +1 @@
+uid://du0i5xyfiwdtq

scripts/managers/player_action_manager.gd

@@ -0,0 +1,247 @@
+extends Node
+
+# PlayerActionManager - Handles action points, highlights, and visual feedback
+
+var player: Node3D
+var enhanced_gridmap: Node
+
+func initialize(p_player: Node3D, p_gridmap: Node):
+	player = p_player
+	enhanced_gridmap = p_gridmap
+
+# =============================================================================
+# Action Point Management
+# =============================================================================
+
+func consume_action_points(points: int):
+	if not is_instance_valid(player) or not player.is_multiplayer_authority():
+		return
+		
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	if not main:
+		return
+		
+	# Don't consume points for bots in non-turn-based mode
+	if player.is_bot == true and not TurnManager.turn_based_mode:
+		after_action_completed()
+		return
+		
+	player.action_points -= points
+		
+	if player.action_points <= 0:
+		if TurnManager.turn_based_mode:
+			main.request_next_turn()
+		else:
+			player.action_points = 2
+			player.has_performed_action = false
+			player.has_moved_this_turn = false
+			player.rpc("display_message", "Action Points Reset!")
+			
+	after_action_completed()
+
+func after_action_completed():
+	# Guard against recursive calls
+	if player._is_processing_action:
+		return
+	player._is_processing_action = true
+	
+	if player.is_multiplayer_authority():
+		player.update_finish_availability()
+	
+	# Clear the highlights after placing the tiles. (Quickfix for Clientside)
+	clear_highlights()
+	
+	if multiplayer.get_unique_id() == player.get_multiplayer_authority():
+		var main = player.get_tree().get_root().get_node_or_null("Main")
+		if main:
+			# Add this condition for bots
+			if not TurnManager.turn_based_mode and (player.action_points <= 0 or player.is_bot):
+				player.action_points = 20  # For bots in non-turn-based mode, this will keep refreshing
+				player.has_performed_action = false
+				player.has_moved_this_turn = false
+				
+			main.ui_manager.update_button_states()
+			main.ui_manager.update_playerboard_ui()
+			
+			# Add this line to sync all boards
+			main.update_all_players_boards()
+			
+			# Add sync for playerboard
+			if player.is_multiplayer_authority():
+				main.rpc("sync_playerboard", player.get_multiplayer_authority(), player.playerboard)
+	
+	player._is_processing_action = false
+
+# =============================================================================
+# Highlight Operations
+# =============================================================================
+
+func highlight_cells_if_authorized(cells_to_highlight: Array):
+	if not player.is_multiplayer_authority() or player.is_bot or player.is_in_group("Bots"):
+		return
+		
+	clear_highlights()
+	for cell in cells_to_highlight:
+		player.highlighted_cells.append(cell)
+		enhanced_gridmap.set_cell_item(
+			Vector3i(cell.x, 0, cell.y), 
+			enhanced_gridmap.hover_item
+		)
+
+func highlight_empty_adjacent_cells():
+	if player.is_bot == true or player.is_in_group("Bots"):
+		return
+		
+	# Debug print
+	print("Highlighting empty adjacent cells. Current position: ", player.current_position)
+	
+	# Clear previous highlights
+	clear_highlights()
+	
+	# Highlight current position if empty
+	var current_cell = Vector3i(player.current_position.x, 1, player.current_position.y)
+	if enhanced_gridmap.get_cell_item(current_cell) == -1:
+		player.highlighted_cells.append(player.current_position)
+		enhanced_gridmap.set_cell_item(Vector3i(player.current_position.x, 0, player.current_position.y), 
+			enhanced_gridmap.hover_item)
+		print("Highlighted current position: ", player.current_position)
+	
+	# Highlight empty adjacent cells
+	var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
+	for neighbor in neighbors:
+		if neighbor.is_walkable:
+			var cell_pos = neighbor.position
+			var cell = Vector3i(cell_pos.x, 1, cell_pos.y)
+			if enhanced_gridmap.get_cell_item(cell) == -1:  # Check if cell is empty
+				player.highlighted_cells.append(cell_pos)
+				enhanced_gridmap.set_cell_item(Vector3i(cell_pos.x, 0, cell_pos.y), 
+					enhanced_gridmap.hover_item)
+				print("Highlighted adjacent cell: ", cell_pos)
+
+func highlight_random_valid_cells():
+	if player.is_bot == true or player.is_in_group("Bots") or not player.is_multiplayer_authority():
+		return
+
+	clear_highlights()
+	
+	# First check the current position
+	var current_cell = Vector3i(player.current_position.x, 1, player.current_position.y)
+	var current_item = enhanced_gridmap.get_cell_item(current_cell)
+	if current_item != -1:
+		player.highlighted_cells.append(player.current_position)
+		enhanced_gridmap.set_cell_item(Vector3i(player.current_position.x, 0, player.current_position.y), 
+			enhanced_gridmap.hover_item)
+	
+	# Then check all adjacent cells for items
+	var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
+	for neighbor in neighbors:
+		if neighbor.is_walkable:
+			var cell_pos = neighbor.position
+			var cell = Vector3i(cell_pos.x, 1, cell_pos.y)
+			if enhanced_gridmap.get_cell_item(cell) != -1:  # Only highlight cells with items
+				player.highlighted_cells.append(cell_pos)
+				enhanced_gridmap.set_cell_item(Vector3i(cell_pos.x, 0, cell_pos.y), 
+					enhanced_gridmap.hover_item)
+
+func highlight_occupied_playerboard_slots():
+	if player.is_bot == true or player.is_in_group("Bots") or not player.is_multiplayer_authority():
+		return
+		
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	if not main or not main.ui_manager.playerboard_ui:
+		return
+		
+	# First reset all slots to normal
+	for i in range(player.playerboard.size()):
+		var slot = main.ui_manager.playerboard_ui.get_child(i)
+		for child in slot.get_children():
+			child.hide()
+	
+	# Highlight occupied slots that match goals
+	for i in range(player.playerboard.size()):
+		if player.playerboard[i] in player.goals:
+			var slot = main.ui_manager.playerboard_ui.get_child(i)
+			if slot.get_child_count() > 0:
+				slot.get_child(0).show()  # Show highlight for matching items
+			player.highlighted_cells.append(i)  # Add to highlighted cells for tracking
+
+	# Update the UI to reflect changes
+	main.ui_manager.update_playerboard_ui()
+
+func highlight_valid_obstacle_cells():
+	if not player.is_multiplayer_authority() or player.is_bot or player.is_in_group("Bots"):
+		return
+		
+	clear_highlights()
+	
+	var cells_to_highlight = []
+	
+	# Highlight all empty cells on the grid except those occupied by players or obstacles
+	for x in range(enhanced_gridmap.columns):
+		for z in range(enhanced_gridmap.rows):
+			var pos = Vector2i(x, z)
+			var cell = Vector3i(x, 3, z)  # Check floor 3 for occupancy
+			var occupied_by_player = false
+			var occupied_by_obstacle = false
+			
+			# Check if cell is occupied by any player
+			for p in player.get_tree().get_nodes_in_group("Players"):
+				if p.current_position == pos:
+					occupied_by_player = true
+					break
+			
+			# Check if cell is occupied by an obstacle
+			if enhanced_gridmap.get_cell_item(cell) in enhanced_gridmap.obstacle_items:
+				occupied_by_obstacle = true
+			
+			# Only add to highlights if not occupied by player or obstacle
+			if not occupied_by_player and not occupied_by_obstacle:
+				cells_to_highlight.append(pos)
+	
+	highlight_cells_if_authorized(cells_to_highlight)
+
+func clear_highlights():
+	# Never allow bots to clear highlights for human players
+	if player.is_bot or player.is_in_group("Bots"):
+		return
+		
+	if not enhanced_gridmap or not player.is_multiplayer_authority():
+		return
+
+	# Store the current action state before clearing
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	var current_state = main.ui_manager.current_action_state if main else null
+
+	for cell in player.highlighted_cells:
+		if cell is Vector2i:
+			enhanced_gridmap.set_cell_item(Vector3i(cell.x, 0, cell.y), enhanced_gridmap.normal_items[0])
+	
+	player.highlighted_cells.clear()
+
+	if main and main.ui_manager.playerboard_ui:
+		for i in range(main.ui_manager.playerboard_ui.get_child_count()):
+			var slot = main.ui_manager.playerboard_ui.get_child(i)
+			for child in slot.get_children():
+				child.hide()
+
+	# Restore highlights based on current action state
+	if main and current_state == main.ui_manager.ActionState.MOVING and player.is_my_turn and current_state != main.ui_manager.ActionState.PLACING_OBSTACLE:
+		player.highlight_movement_range()
+
+func clear_playerboard_highlights():
+	# Never allow bots to clear highlights for human players
+	if player.is_bot or player.is_in_group("Bots"):
+		return
+		
+	if not player.is_multiplayer_authority():
+		return
+		
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	if main and main.ui_manager.playerboard_ui:
+		for i in range(main.ui_manager.playerboard_ui.get_child_count()):
+			var slot = main.ui_manager.playerboard_ui.get_child(i)
+			if slot.get_child_count() > 0: slot.get_child(0).hide()
+			if slot.get_child_count() > 1: slot.get_child(1).hide()
+			if slot.get_child_count() > 2: slot.get_child(2).hide()
+
+	player.highlighted_cells.clear()

scripts/managers/player_action_manager.gd.uid

@@ -0,0 +1 @@
+uid://bwsl442pejsov

scripts/managers/player_input_manager.gd

@@ -0,0 +1,126 @@
+extends Node
+
+var player: Node3D
+var movement_manager: Node
+var race_manager: Node
+
+func initialize(p_player: Node3D, p_movement_manager: Node, p_race_manager: Node):
+	player = p_player
+	movement_manager = p_movement_manager
+	race_manager = p_race_manager
+
+func handle_unhandled_input(event):
+	# Early return if not authorized human player
+	if not player.is_multiplayer_authority() or player.is_bot or player.is_in_group("Bots"):
+		player.set_process_unhandled_input(false)
+		return
+	
+	var main = player.get_node("/root/Main")
+	if not main:
+		return
+	
+	# --- Real-time Keyboard/Touch Input ---
+	if not TurnManager.turn_based_mode and not movement_manager.is_moving:
+		var target_position = player.current_position
+		var input_handled = true
+
+		if Input.is_action_just_pressed("move_north"):
+			target_position += Vector2i(0, -1)
+		elif Input.is_action_just_pressed("move_northeast"):
+			target_position += Vector2i(1, -1)
+		elif Input.is_action_just_pressed("move_east"):
+			target_position += Vector2i(1, 0)
+		elif Input.is_action_just_pressed("move_southeast"):
+			target_position += Vector2i(1, 1)
+		elif Input.is_action_just_pressed("move_south"):
+			target_position += Vector2i(0, 1)
+		elif Input.is_action_just_pressed("move_southwest"):
+			target_position += Vector2i(-1, 1)
+		elif Input.is_action_just_pressed("move_west"):
+			target_position += Vector2i(-1, 0)
+		elif Input.is_action_just_pressed("move_northwest"):
+			target_position += Vector2i(-1, -1)
+		elif Input.is_action_just_pressed("action_grab"):
+			player.grab_item(player.current_position) 
+		elif Input.is_action_just_pressed("action_put"):
+			player.auto_put_item()
+		else:
+			input_handled = false
+
+		if target_position != player.current_position:
+			movement_manager.simple_move_to(target_position)
+
+		if input_handled:
+			player.get_viewport().set_input_as_handled()
+			return 
+	# --- End Real-time Input ---
+	
+	# Handle spawn point selection if not yet selected
+	if not player.spawn_point_selected and player.highlighted_spawn_points.size() > 0:
+		if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
+			var camera = player.get_viewport().get_camera_3d()
+			var from = camera.project_ray_origin(event.position)
+			var to = from + camera.project_ray_normal(event.position) * 1000
+			
+			var click_position = player.raycast_to_grid(from, to)
+			if click_position in player.highlighted_spawn_points:
+				if player.select_spawn_point(click_position):
+					return 
+	
+	# Turn-based mouse input
+	if not player.is_multiplayer_authority() or (TurnManager.turn_based_mode and (not player.is_my_turn or movement_manager.is_moving)):
+		return
+
+	if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
+		if player.is_bot == true or player.is_in_group("Bots"):
+			player.set_process_unhandled_input(false)
+			player.set_process_input(false)
+			return
+		var camera = player.get_viewport().get_camera_3d()
+		var from = camera.project_ray_origin(event.position)
+		var to = from + camera.project_ray_normal(event.position) * 1000
+		
+		var click_position = player.raycast_to_grid(from, to)
+		if click_position != Vector2i(-1, -1):
+			handle_grid_click(click_position)
+
+func handle_grid_click(grid_position: Vector2i):
+	if player.is_bot == true or player.is_in_group("Bots"):
+		return
+	var main = player.get_node("/root/Main")
+	if not main:
+		return
+		
+	match main.ui_manager.current_action_state:
+		main.ui_manager.ActionState.MOVING:
+			if grid_position in player.highlighted_cells:
+				movement_manager.move_to_clicked_position(grid_position)
+		main.ui_manager.ActionState.GRABBING:
+			if grid_position in player.highlighted_cells or grid_position == player.current_position:
+				player.grab_item(grid_position)
+		main.ui_manager.ActionState.RANDOMIZING:
+			if grid_position in player.highlighted_cells:
+				main.randomize_item_at_position(grid_position)
+		main.ui_manager.ActionState.PLACING_OBSTACLE:
+			if grid_position in player.highlighted_cells:
+				main.place_obstacle(grid_position)
+
+func handle_slot_gui_input(event, slot_index, slot_ui) -> int:
+	if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
+		var main = player.get_tree().get_root().get_node_or_null("Main")
+		
+		if main.ui_manager.current_action_state == main.ui_manager.ActionState.ARRANGING:
+			if player.selected_playerboard_slot == -1:
+				player.select_playerboard_slot(slot_index)
+				return slot_index
+			else:
+				if player.selected_playerboard_slot == slot_index:
+					player.deselect_playerboard_slot()
+					return slot_index
+				elif player.can_move_to_target_playerboard_slot():
+					player.target_playerboard_slot(slot_index)
+					main.emit_signal("can_move_item", true)
+					return slot_index
+				else:
+					return -1
+	return -1

scripts/managers/player_input_manager.gd.uid

@@ -0,0 +1 @@
+uid://da4wamdyr2ckt

scripts/managers/player_manager.gd.uid

@@ -0,0 +1 @@
+uid://bpllaov4k7l50

scripts/managers/player_movement_manager.gd

@@ -0,0 +1,245 @@
+extends Node
+
+var player: Node3D
+var enhanced_gridmap: Node
+
+# Movement settings
+var movement_range: int = 1
+var use_diagonal_movement: bool = false
+var is_moving: bool = false
+var rotation_speed: float = 10.0
+var target_rotation: float = 0.0
+
+func initialize(p_player: Node3D, p_gridmap: Node):
+	player = p_player
+	enhanced_gridmap = p_gridmap
+	
+	# Initialize settings from player if available
+	if "movement_range" in player:
+		movement_range = player.movement_range
+	if "use_diagonal_movement" in player:
+		use_diagonal_movement = player.use_diagonal_movement
+
+func _process(delta):
+	if player and not is_moving:
+		_handle_rotation(delta)
+
+func _handle_rotation(delta):
+	if player.rotation.y != target_rotation:
+		player.rotation.y = lerp_angle(player.rotation.y, target_rotation, delta * rotation_speed)
+
+func rotate_towards_target(target_pos: Vector2i):
+	var direction = Vector3(target_pos.x - player.current_position.x, 0, target_pos.y - player.current_position.y)
+	if direction != Vector3.ZERO:
+		target_rotation = atan2(direction.x, direction.z)
+
+func simple_move_to(grid_position: Vector2i) -> bool:
+	if not player.is_multiplayer_authority() or is_moving:
+		return false
+
+	# Check if target is within 1-tile range
+	var distance: int
+	if use_diagonal_movement:
+		distance = max(abs(grid_position.x - player.current_position.x), abs(grid_position.y - player.current_position.y))
+	else:
+		distance = abs(grid_position.x - player.current_position.x) + abs(grid_position.y - player.current_position.y)
+	
+	if distance != 1:
+		return false # Only single-step moves allowed
+
+	# Check for finish line logic (delegated back to player or race manager)
+	if player.has_method("can_move_to_finish") and not player.can_move_to_finish(grid_position):
+		return false
+
+	# Check walkability and obstacles
+	var cell_item = enhanced_gridmap.get_cell_item(Vector3i(grid_position.x, 0, grid_position.y))
+	if cell_item in enhanced_gridmap.non_walkable_items or player.is_position_occupied(grid_position): 
+		return false
+	
+	if enhanced_gridmap.is_blocked_by_obstacle(player.current_position, grid_position, 3):
+		return false
+
+	# All checks passed, perform move
+	rotate_towards_target(grid_position)
+
+	var path = [Vector2(player.current_position.x, player.current_position.y), Vector2(grid_position.x, grid_position.y)]
+	path.pop_front()
+	
+	# Use the existing RPC to move (assuming player still has this RPC or we move it here)
+	# For now, we'll call the player's RPC method
+	player.rpc("start_movement_along_path", path, not (player.is_bot or player.is_in_group("Bots")))
+	
+	return true
+
+func move_to_clicked_position(grid_position: Vector2i) -> bool:
+	if not player.is_multiplayer_authority() or is_moving or player.action_points <= 0:
+		return false
+	
+	# Check finish line logic
+	if player.has_method("can_move_to_finish") and not player.can_move_to_finish(grid_position):
+		return false
+		
+	# This function seems to rely on pathfinding or just direct move if adjacent?
+	# The original code for move_player_to_clicked_position called simple_move_to if adjacent?
+	# Actually original code for move_player_to_clicked_position wasn't fully shown in previous view_file.
+	# Let's assume it uses pathfinding if not adjacent, or just validates and moves.
+	
+	# For now, let's just try simple move if it's adjacent
+	return simple_move_to(grid_position)
+
+func is_within_movement_range(target_position: Vector2i) -> bool:
+	var distance: int
+	if use_diagonal_movement:
+		distance = max(abs(target_position.x - player.current_position.x), abs(target_position.y - player.current_position.y))
+	else:
+		distance = abs(target_position.x - player.current_position.x) + abs(target_position.y - player.current_position.y)
+	return distance <= movement_range
+
+# Update highlight_movement_range to respect the expanded obstacle blocking
+func highlight_movement_range():
+	if not player.is_multiplayer_authority() or player.is_bot or player.is_in_group("Bots"):
+		return
+	
+	# Prevent recursive highlighting
+	if player._is_highlighting:
+		return
+	player._is_highlighting = true
+	
+	player.clear_highlights()
+	var cells_to_highlight = []
+	
+	# First, identify all cells that are blocked by obstacles
+	var blocked_cells = []
+	
+	# Check all cells for obstacles and get their blocked cells
+	for x in range(enhanced_gridmap.columns):
+		for z in range(enhanced_gridmap.rows):
+			var cell_pos = Vector2i(x, z)
+			var cell_pos3d = Vector3i(x, 3, z)
+			
+			if enhanced_gridmap.has_obstacle_at(cell_pos3d):
+				var orientation = enhanced_gridmap.get_obstacle_orientation(cell_pos3d)
+				blocked_cells.append_array(enhanced_gridmap.get_cells_blocked_by_obstacle(cell_pos, orientation, 3))
+	
+	# Now highlight all cells within movement range that aren't blocked
+	for x in range(max(0, player.current_position.x - movement_range), 
+				  min(enhanced_gridmap.columns, player.current_position.x + movement_range + 1)):
+		for z in range(max(0, player.current_position.y - movement_range), 
+					  min(enhanced_gridmap.rows, player.current_position.y + movement_range + 1)):
+			var test_pos = Vector2i(x, z)
+			
+			# Skip current position
+			if test_pos == player.current_position:
+				continue
+			
+			# Check if within movement range
+			if is_within_movement_range(test_pos):
+				# Skip if blocked by obstacle
+				if test_pos in blocked_cells:
+					continue
+				
+				# Check basic walkability
+				var cell_item = enhanced_gridmap.get_cell_item(Vector3i(x, 0, z))
+				if cell_item == -1 or cell_item in enhanced_gridmap.non_walkable_items or player.is_position_occupied(test_pos):
+					continue
+				
+				# Check if there's a valid path to this cell
+				if can_reach_cell(test_pos, blocked_cells):
+					cells_to_highlight.append(test_pos)
+	
+	# At the end of the function:
+	player.highlight_cells_if_authorized(cells_to_highlight)
+	player._is_highlighting = false
+
+# Helper function to check if a cell can be reached given the blocked cells
+func can_reach_cell(target_pos: Vector2i, blocked_cells: Array) -> bool:
+	# Simple BFS to find if there's a path
+	var queue = [player.current_position]
+	var visited = {player.current_position: true}
+	var steps = {player.current_position: 0}
+	
+	while not queue.is_empty():
+		var current = queue.pop_front()
+		
+		# If we've found the target, check if it's within movement range
+		if current == target_pos:
+			return steps[current] <= movement_range
+		
+		# If we've used all movement, don't explore further
+		if steps[current] >= movement_range:
+			continue
+		
+		# Try all adjacent cells
+		var directions = [
+			Vector2i(0, -1),  # North
+			Vector2i(1, 0),   # East
+			Vector2i(0, 1),   # South
+			Vector2i(-1, 0),  # West
+		]
+		
+		# Add diagonal directions if enabled
+		if enhanced_gridmap.diagonal_movement:
+			directions.append(Vector2i(-1, -1))  # Northwest
+			directions.append(Vector2i(1, -1))   # Northeast
+			directions.append(Vector2i(-1, 1))   # Southwest
+			directions.append(Vector2i(1, 1))    # Southeast
+		
+		for dir in directions:
+			var next_pos = current + dir
+			
+			# Skip if already visited, blocked, or not valid
+			if visited.has(next_pos) or next_pos in blocked_cells:
+				continue
+				
+			if not enhanced_gridmap.is_position_valid(next_pos) or not enhanced_gridmap.is_cell_walkable(next_pos, 0):
+				continue
+				
+			if player.is_position_occupied(next_pos) and next_pos != target_pos:
+				continue
+			
+			# Check if movement between cells is blocked by an obstacle
+			if not is_diagonal_direction(dir) and enhanced_gridmap.is_movement_blocked(current, next_pos, 3):
+				continue
+				
+			# For diagonal movement, check if both orthogonal paths are blocked
+			if is_diagonal_direction(dir):
+				var mid1 = Vector2i(next_pos.x, current.y)
+				var mid2 = Vector2i(current.x, next_pos.y)
+				
+				var path1_blocked = mid1 in blocked_cells or enhanced_gridmap.is_movement_blocked(current, mid1, 3)
+				var path2_blocked = mid2 in blocked_cells or enhanced_gridmap.is_movement_blocked(current, mid2, 3)
+				
+				if path1_blocked and path2_blocked:
+					continue
+			
+			# Add to queue
+			queue.append(next_pos)
+			visited[next_pos] = true
+			steps[next_pos] = steps[current] + 1
+	
+	return false
+
+# Helper function to check if a direction is diagonal
+func is_diagonal_direction(direction: Vector2i) -> bool:
+	return direction.x != 0 and direction.y != 0
+
+func highlight_adjacent_cells():
+	if not player.is_multiplayer_authority() or player.is_bot or player.is_in_group("Bots"):
+		return
+		
+	var cells_to_highlight = []
+	
+	# Add current position if item exists
+	var current_cell = Vector3i(player.current_position.x, 1, player.current_position.y)
+	if enhanced_gridmap.get_cell_item(current_cell) != -1:
+		cells_to_highlight.append(player.current_position)
+	
+	# Add valid neighbors
+	var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
+	for neighbor in neighbors:
+		if neighbor.is_walkable:
+			var cell_pos = neighbor.position
+			if enhanced_gridmap.get_cell_item(Vector3i(cell_pos.x, 1, cell_pos.y)) != -1:
+				cells_to_highlight.append(cell_pos)
+	
+	player.highlight_cells_if_authorized(cells_to_highlight)

scripts/managers/player_movement_manager.gd.uid

@@ -0,0 +1 @@
+uid://r47t031kgah5

scripts/managers/player_race_manager.gd

@@ -0,0 +1,160 @@
+extends Node
+
+var player: Node3D
+var enhanced_gridmap: Node
+
+# Race state
+var current_lap: int = 0
+var first_lap_goals: Array[int] = []
+var second_lap_goals: Array[int] = []
+var race_position: int = 0
+static var lap1_finishers: int = 0
+static var lap2_finishers: int = 0
+
+# Goals and Playerboard
+var goals: Array[int] = [0,0,0,0,0,0,0,0,0]
+var playerboard: Array[int] = [0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
+var can_finish: bool = false
+
+# Finish locations (copied from player.gd)
+var finish_locations = [
+	Vector2i(13, 0), Vector2i(13, 1), Vector2i(13, 2), Vector2i(13, 3),
+	Vector2i(13, 4), Vector2i(13, 5), Vector2i(13, 6), Vector2i(13, 7),
+	Vector2i(13, 8), Vector2i(13, 9), Vector2i(13, 10), Vector2i(13, 11),
+	Vector2i(13, 12), Vector2i(13, 13)
+]
+
+func initialize(p_player: Node3D, p_gridmap: Node):
+	player = p_player
+	enhanced_gridmap = p_gridmap
+	
+	if player.is_multiplayer_authority():
+		first_lap_goals = goals.duplicate()
+		generate_second_lap_goals()
+
+func get_ordinal_string(number: int) -> String:
+	match number:
+		1: return "1st"
+		2: return "2nd"
+		3: return "3rd"
+		4: return "4th"
+		_: return str(number) + "th"
+
+func generate_second_lap_goals():
+	second_lap_goals.clear()
+	for i in range(9):
+		var val = (randi() % 4) + 7
+		second_lap_goals.append(val)
+	
+	if player.is_multiplayer_authority():
+		player.rpc("sync_second_lap_goals", second_lap_goals)
+
+func check_3x3_section(board: Array, goals_pattern: Array, start_row: int, start_col: int) -> bool:
+	for i in range(3):
+		for j in range(3):
+			if goals_pattern[i][j] != -1:
+				var board_value = board[start_row + i][start_col + j]
+				if board_value == -1:
+					return false
+	
+	for i in range(3):
+		for j in range(3):
+			if goals_pattern[i][j] != -1:
+				if board[start_row + i][start_col + j] != goals_pattern[i][j]:
+					return false
+	return true
+
+func check_pattern_match() -> bool:
+	if playerboard.size() != 25 or goals.size() != 9:
+		return false
+	
+	var board_2d = []
+	var goals_2d = []
+	
+	for i in range(5):
+		var row = []
+		for j in range(5):
+			row.append(playerboard[i * 5 + j])
+		board_2d.append(row)
+	
+	for i in range(3):
+		var row = []
+		for j in range(3):
+			row.append(goals[i * 3 + j])
+		goals_2d.append(row)
+	
+	for start_row in range(3):
+		for start_col in range(3):
+			if check_3x3_section(board_2d, goals_2d, start_row, start_col):
+				return true
+	return false
+
+func update_finish_availability():
+	can_finish = check_pattern_match()
+	if player.is_multiplayer_authority():
+		if can_finish:
+			highlight_finish_line()
+		else:
+			unhighlight_finish_line()
+
+func highlight_finish_line():
+	if not player.is_multiplayer_authority() or player.is_bot:
+		return
+	for finish_pos in finish_locations:
+		if enhanced_gridmap:
+			enhanced_gridmap.set_cell_item(
+				Vector3i(finish_pos.x, 0, finish_pos.y),
+				enhanced_gridmap.hover_item
+			)
+
+func unhighlight_finish_line():
+	if not player.is_multiplayer_authority() or player.is_bot:
+		return
+	for finish_pos in finish_locations:
+		if enhanced_gridmap:
+			enhanced_gridmap.set_cell_item(
+				Vector3i(finish_pos.x, 0, finish_pos.y),
+				enhanced_gridmap.normal_items[0]
+			)
+
+func is_at_finish_line() -> bool:
+	return player.current_position in finish_locations
+
+func finish_race():
+	if current_lap == 0:
+		lap1_finishers += 1
+		race_position = lap1_finishers
+		var message = "Finish 1st lap on " + get_ordinal_string(race_position)
+		if player.is_multiplayer_authority():
+			player.rpc("display_message", message)
+		
+		current_lap += 1
+		player.rpc("start_new_lap")
+		
+	elif current_lap == 1:
+		lap2_finishers += 1
+		race_position = lap2_finishers
+		var message = "Finish 2nd lap on " + get_ordinal_string(race_position)
+		if player.is_multiplayer_authority():
+			player.rpc("display_message", message)
+
+func start_new_lap():
+	if current_lap == 1:
+		var valid_finish_pos = find_valid_position_in_finish_line()
+		if valid_finish_pos != Vector2i(-1, -1):
+			player.current_position = valid_finish_pos
+			player.update_player_position(player.current_position)
+		
+		goals = second_lap_goals.duplicate()
+		can_finish = false
+		
+		if player.is_multiplayer_authority():
+			player.rpc("sync_position", player.current_position)
+			player.rpc("sync_playerboard", playerboard)
+			player.rpc("sync_goals", goals)
+
+func find_valid_position_in_finish_line() -> Vector2i:
+	for pos in finish_locations:
+		if not player.is_position_occupied(pos):
+			return pos
+	return Vector2i(-1, -1)

scripts/managers/player_race_manager.gd.uid

@@ -0,0 +1 @@
+uid://dhtm6illlplhf

scripts/managers/playerboard_manager.gd

@@ -0,0 +1,531 @@
+extends Node
+
+# PlayerboardManager - Handles all playerboard operations including grab, put, arrange
+
+var player: Node3D
+var enhanced_gridmap: Node
+
+# Playerboard state
+var selected_gridmap_position = Vector2i(-1, -1)
+var selected_playerboard_slot = -1
+var targeted_playerboard_slot = -1
+
+func initialize(p_player: Node3D, p_gridmap: Node):
+	player = p_player
+	enhanced_gridmap = p_gridmap
+
+# =============================================================================
+# GRAB Operations
+# =============================================================================
+
+func grab_item(grid_position: Vector2i) -> bool:
+	if not enhanced_gridmap or player.action_points <= 0:
+		return false
+
+	var cell = Vector3i(grid_position.x, 1, grid_position.y)
+	var item = enhanced_gridmap.get_cell_item(cell)
+
+	# Validate adjacency (unless it's current position)
+	if grid_position != player.current_position:
+		var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
+		var is_adjacent = false
+		for neighbor in neighbors:
+			if neighbor.position == grid_position:
+				is_adjacent = true
+				break
+		if not is_adjacent:
+			return false
+
+	if item == -1:
+		return false
+
+	# === AUTO-ARRANGE LOGIC (Client-side pre-check) ===
+	var target_slot = find_best_goal_slot_for_item(item)
+	if target_slot == -1:
+		print("Player: No valid slot found for item.")
+		return false  # no space
+
+	if not player.is_multiplayer_authority():
+		return false
+
+	# === Branching Logic: Host vs Client ===
+	if multiplayer.is_server():
+		# HOST/SERVER: Call the logic directly
+		_execute_grab(grid_position, cell, item)
+	else:
+		# CLIENT: Send RPC request to server (peer 1)
+		player.rpc_id(1, "request_server_grab", grid_position, cell.x, cell.y, cell.z, item)
+	
+	return true # Request was sent or processed
+
+func _execute_grab(grid_pos: Vector2i, cell: Vector3i, item_id: int):
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	if not main:
+		push_error("Server: Main node not found.")
+		return false
+
+	var server_gridmap = main.get_node("EnhancedGridMap")
+	if not server_gridmap:
+		push_error("Server: EnhancedGridMap not found.")
+		return false
+
+	# 1. Server-side Validation
+	var server_item = server_gridmap.get_cell_item(cell)
+
+	# Check if item is still there
+	if server_item != item_id:
+		print("Server: Item mismatch or already taken. Server has ", server_item)
+		return false
+	
+	# Check action points
+	if player.action_points <= 0:
+		print("Server: Player has no action points.")
+		return false
+	
+	# Check adjacency
+	if grid_pos != player.current_position:
+		var neighbors = server_gridmap.get_neighbors(player.current_position, 0)
+		if not neighbors.any(func(n): return n.position == grid_pos):
+			print("Server: Player is not adjacent to item.")
+			return false
+
+	# 2. Server-side Auto-Arrange
+	var target_slot = find_best_goal_slot_for_item(item_id)
+	if target_slot == -1:
+		print("Server: Player has no valid slot for item.")
+		return false
+
+	# 3. Server Executes the Action
+	
+	# 3a. Update gridmap (using Main's RPC, which has authority)
+	main.rpc("sync_grid_item", cell.x, cell.y, cell.z, -1)
+	
+	# 3b. Update playerboard state (on this server-side instance)
+	player.playerboard[target_slot] = item_id
+	
+	# 3c. Broadcast the new playerboard state to all clients
+	player.rpc("sync_playerboard", player.playerboard)
+	
+	# 3d. Consume action points
+	player.has_performed_action = true
+	player.consume_action_points(1)
+	
+	# 3e. Reset the UI for the player who acted
+	player.rpc("force_action_state_none")
+	
+	return true
+
+func bot_try_grab_item() -> bool:
+	if not enhanced_gridmap or player.action_points <= 0:
+		return false
+		
+	# First check current position
+	var current_cell = Vector3i(player.current_position.x, 1, player.current_position.y)
+	var item = enhanced_gridmap.get_cell_item(current_cell)
+	
+	if item != -1:
+		var empty_slot = player.playerboard.find(-1)
+		if empty_slot != -1:
+			if player.is_multiplayer_authority():
+				player.playerboard[empty_slot] = item
+				player.rpc("sync_grid_item", current_cell.x, current_cell.y, current_cell.z, -1)
+				player.rpc("sync_playerboard", player.playerboard)
+				player.has_performed_action = true
+				player.action_points -= 1
+				return true
+	
+	# Check adjacent cells if nothing at current position
+	var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
+	for neighbor in neighbors:
+		if neighbor.is_walkable:
+			var cell = Vector3i(neighbor.position.x, 1, neighbor.position.y)
+			item = enhanced_gridmap.get_cell_item(cell)
+			if item != -1:
+				var empty_slot = player.playerboard.find(-1)
+				if empty_slot != -1:
+					if player.is_multiplayer_authority():
+						player.playerboard[empty_slot] = item
+						player.rpc("sync_grid_item", cell.x, cell.y, cell.z, -1)
+						player.rpc("sync_playerboard", player.playerboard)
+						player.has_performed_action = true
+						player.action_points -= 1
+						return true
+	
+	return false
+
+# =============================================================================
+# PUT Operations
+# =============================================================================
+
+func auto_put_item() -> bool:
+	if not enhanced_gridmap or player.action_points <= 0 or player.is_bot or player.is_in_group("Bots"):
+		return false
+
+	# Step 1: Find empty adjacent (or current) grid cells
+	var valid_put_positions = []
+	var current_cell_3d = Vector3i(player.current_position.x, 1, player.current_position.y)
+	if enhanced_gridmap.get_cell_item(current_cell_3d) == -1:
+		valid_put_positions.append(player.current_position)
+
+	var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
+	for neighbor in neighbors:
+		if neighbor.is_walkable:
+			var pos = neighbor.position
+			var cell_3d = Vector3i(pos.x, 1, pos.y)
+			if enhanced_gridmap.get_cell_item(cell_3d) == -1 and not player.is_position_occupied(pos):
+				valid_put_positions.append(pos)
+
+	if valid_put_positions.is_empty():
+		return false
+
+	# Step 2: Find a tile that should NOT be on the board
+	var put_slot = -1
+
+	# Count how many times each goal item appears in central 3x3
+	var goal_counts = {}
+	for i in range(3):
+		for j in range(3):
+			var g = player.goals[i * 3 + j]
+			if g != -1:
+				goal_counts[g] = goal_counts.get(g, 0) + 1
+
+	# Now scan playerboard
+	for i in range(player.playerboard.size()):
+		var item = player.playerboard[i]
+		if item == -1:
+			continue
+
+		# Case 1: Item is not in goals at all → definitely junk
+		if not item in player.goals:
+			put_slot = i
+			break
+
+		# Case 2: Item is in goals, but we already have enough in correct spots
+		var current_count = 0
+		for r in range(1, 4):      # central rows 1-3 (5x5 board)
+			for c in range(1, 4):  # central cols 1-3
+				var idx = r * 5 + c
+				if player.playerboard[idx] == item:
+					current_count += 1
+
+		# If we already have all needed copies in central area, this is extra
+		if current_count >= goal_counts.get(item, 0):
+			put_slot = i
+			break
+
+	# If no junk found, fall back to any non-goal-matching tile outside center
+	if put_slot == -1:
+		for i in range(player.playerboard.size()):
+			var item = player.playerboard[i]
+			if item == -1:
+				continue
+			var row = i / 5
+			var col = i % 5
+			# If it's outside the central 3x3, it shouldn't be there
+			if row < 1 or row > 3 or col < 1 or col > 3:
+				if not item in player.goals or player.playerboard[i] != player.goals[(row - 1) * 3 + (col - 1)]:
+					put_slot = i
+					break
+
+	if put_slot == -1:
+		return false  # Nothing suitable to put
+
+	# Step 3: Perform the put
+	var target_pos = valid_put_positions[0]
+	var item = player.playerboard[put_slot]
+	var cell = Vector3i(target_pos.x, 1, target_pos.y)
+
+	if player.is_multiplayer_authority():
+		player.rpc("sync_grid_item", cell.x, cell.y, cell.z, item)
+		player.playerboard[put_slot] = -1
+		player.rpc("sync_playerboard", player.playerboard)
+		player.has_performed_action = true
+		player.consume_action_points(1)
+
+		var main = player.get_tree().get_root().get_node_or_null("Main")
+		if main:
+			main.set_action_state(main.ActionState.NONE)
+
+	return true
+
+# =============================================================================
+# ARRANGE Operations
+# =============================================================================
+
+func arrange_playerboard_item(slot_index: int):
+	if player.action_points < 2 or player.playerboard[slot_index] == -1:
+		return
+
+	var selected_item = player.playerboard[slot_index]
+	var adjacent_slots = get_adjacent_playerboard_slots(slot_index)
+
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	if not main or not main.ui_manager.playerboard_ui:
+		return
+
+	# Store the selected slot
+	selected_playerboard_slot = slot_index
+
+	# Highlight selected slot
+	var selected_slot_ui = main.ui_manager.playerboard_ui.get_child(slot_index)
+	if selected_slot_ui.get_child_count() > 1:
+		selected_slot_ui.get_child(1).show()
+
+	# Highlight valid adjacent slots
+	for adj_slot in adjacent_slots:
+		if player.playerboard[adj_slot] == -1:  # Only highlight empty adjacent slots
+			var adj_slot_ui = main.ui_manager.playerboard_ui.get_child(adj_slot)
+			if adj_slot_ui.get_child_count() > 2:
+				adj_slot_ui.get_child(2).show()
+			player.highlighted_cells.append(adj_slot)
+
+	# Connect to slot click signals
+	for i in range(player.playerboard.size()):
+		var slot = main.ui_manager.playerboard_ui.get_child(i)
+		if not slot.gui_input.is_connected(player._on_slot_clicked):
+			slot.gui_input.connect(player._on_slot_clicked.bind(i))
+
+func handle_slot_clicked(slot_index: int):
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	if not main or main.ui_manager.current_action_state != main.ui_manager.ActionState.ARRANGING:
+		return
+
+	if selected_playerboard_slot == -1 or slot_index == selected_playerboard_slot:
+		return
+
+	var adjacent_slots = get_adjacent_playerboard_slots(selected_playerboard_slot)
+	if slot_index in adjacent_slots and player.playerboard[slot_index] == -1:
+		# Move item to empty target slot
+		var selected_item = player.playerboard[selected_playerboard_slot]
+		player.playerboard[slot_index] = selected_item
+		player.playerboard[selected_playerboard_slot] = -1
+
+		if player.is_multiplayer_authority():
+			player.rpc("sync_playerboard", player.playerboard)
+			player.consume_action_points(2)
+			player.has_performed_action = true
+
+		# Clear highlights
+			player.clear_highlights()
+			player.clear_playerboard_highlights()
+		
+		# Reset selection
+		selected_playerboard_slot = -1
+
+		# Update the visual representation
+		main.ui_manager.update_playerboard_ui()
+		main.ui_manager.current_action_state = main.ui_manager.ActionState.NONE
+
+# =============================================================================
+# Helper Functions
+# =============================================================================
+
+func find_best_goal_slot_for_item(item: int) -> int:
+	if item == -1:
+		return -1
+
+	# Convert goals to 2D (3x3)
+	var goals_2d = []
+	for i in range(3):
+		var row = []
+		for j in range(3):
+			row.append(player.goals[i * 3 + j])
+		goals_2d.append(row)
+
+	# Search for where this item should go in the central 3x3 (mapped to 5x5 board)
+	for i in range(3):
+		for j in range(3):
+			if goals_2d[i][j] == item:
+				var board_row = i + 1  # offset to center in 5x5
+				var board_col = j + 1
+				var slot_index = board_row * 5 + board_col
+				if player.playerboard[slot_index] == -1:  # only if empty
+					return slot_index
+
+	# No ideal slot? Return any empty slot
+	return player.playerboard.find(-1)
+
+func find_best_put_candidate() -> Dictionary:
+	# Convert goals to 2D (3x3)
+	var goals_2d = []
+	for i in range(3):
+		var row = []
+		for j in range(3):
+			row.append(player.goals[i * 3 + j])
+		goals_2d.append(row)
+
+	# Convert playerboard to 2D (5x5)
+	var board_2d = []
+	for i in range(5):
+		var row = []
+		for j in range(5):
+			row.append(player.playerboard[i * 5 + j])
+		board_2d.append(row)
+
+	# Step 1: Find misplaced or extra goal-matching items
+	var candidate_items = []
+	for board_i in range(5):
+		for board_j in range(5):
+			var item = board_2d[board_i][board_j]
+			if item == -1:
+				continue
+			var board_idx = board_i * 5 + board_j
+
+			# Is this item part of the goals?
+			if item not in player.goals:
+				continue
+
+			# Is it already in the correct central position?
+			var is_in_correct_central_spot = false
+			if board_i in [1,2,3] and board_j in [1,2,3]:
+				var goal_i = board_i - 1
+				var goal_j = board_j - 1
+				if goals_2d[goal_i][goal_j] == item:
+					is_in_correct_central_spot = true
+
+			if not is_in_correct_central_spot:
+				candidate_items.append({
+					"slot": board_idx,
+					"item": item
+				})
+
+	# Step 2: Find valid adjacent empty grid cells
+	var valid_cells = []
+	# Check current position
+	var current_cell_3d = Vector3i(player.current_position.x, 1, player.current_position.y)
+	if enhanced_gridmap.get_cell_item(current_cell_3d) == -1:
+		valid_cells.append(player.current_position)
+	# Check neighbors
+	var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
+	for neighbor in neighbors:
+		if neighbor.is_walkable:
+			var pos = neighbor.position
+			var cell_3d = Vector3i(pos.x, 1, pos.y)
+			if enhanced_gridmap.get_cell_item(cell_3d) == -1 and not player.is_position_occupied(pos):
+				valid_cells.append(pos)
+
+	if valid_cells.is_empty() or candidate_items.is_empty():
+		return {}
+
+	# Step 3: Prefer to put an item that *completes* a missing goal
+	for goal_i in range(3):
+		for goal_j in range(3):
+			var needed_item = goals_2d[goal_i][goal_j]
+			if needed_item == -1:
+				continue
+			# Check if central spot is empty
+			var board_i = goal_i + 1
+			var board_j = goal_j + 1
+			var central_slot = board_i * 5 + board_j
+			if player.playerboard[central_slot] == -1:
+				# Look for this item in candidate_items
+				for cand in candidate_items:
+					if cand.item == needed_item:
+						if not valid_cells.is_empty():
+							return {
+								"slot_index": cand.slot,
+								"grid_position": valid_cells[0]  # pick first valid cell
+							}
+
+	# Fallback: just put any candidate item
+	return {
+		"slot_index": candidate_items[0].slot,
+		"grid_position": valid_cells[0]
+	}
+
+func get_adjacent_playerboard_slots(slot_index) -> Array:
+	var adjacent = []
+	var row = slot_index / 5
+	var col = slot_index % 5
+	
+	if row > 0: adjacent.append(slot_index - 5)
+	if row < 4: adjacent.append(slot_index + 5)
+	if col > 0: adjacent.append(slot_index - 1)
+	if col < 4: adjacent.append(slot_index + 1)
+	
+	return adjacent
+
+func is_valid_arrangement_slot(from_slot: int, to_slot: int) -> bool:
+	var from_row = from_slot / 5
+	var from_col = from_slot % 5
+	var to_row = to_slot / 5
+	var to_col = to_slot % 5
+
+	var row_diff = abs(from_row - to_row)
+	var col_diff = abs(from_col - to_col)
+
+	return (row_diff == 1 and col_diff == 0) or (row_diff == 0 and col_diff == 1)
+
+func has_item_at_current_position() -> bool:
+	var current_cell = Vector3i(player.current_position.x, 1, player.current_position.y)
+	return enhanced_gridmap.get_cell_item(current_cell) != -1
+
+func has_items_in_playerboard() -> bool:
+	return player.playerboard.any(func(item): return item != -1)
+
+func playerboard_is_full() -> bool:
+	return player.playerboard.find(-1) == -1
+
+# Slot selection management
+func select_playerboard_slot(slot_index: int):
+	selected_playerboard_slot = slot_index
+	_update_playerboard_slot_visual(slot_index)
+	_highlight_adjacent_playerboard_slots()
+
+func deselect_playerboard_slot():
+	var old_selected = selected_playerboard_slot
+	selected_playerboard_slot = -1
+	if old_selected != -1:
+		_update_playerboard_slot_visual(old_selected)
+	untarget_playerboard_slot()
+	_highlight_adjacent_playerboard_slots()
+
+func target_playerboard_slot(slot_index: int):
+	if targeted_playerboard_slot != -1:
+		untarget_playerboard_slot()
+	targeted_playerboard_slot = slot_index
+	_update_playerboard_slot_visual(slot_index)
+
+func untarget_playerboard_slot():
+	if targeted_playerboard_slot != -1:
+		var old_targeted = targeted_playerboard_slot
+		targeted_playerboard_slot = -1
+		_update_playerboard_slot_visual(old_targeted)
+
+func can_move_to_target_playerboard_slot() -> bool:
+	if selected_playerboard_slot == -1 or targeted_playerboard_slot == -1 or selected_playerboard_slot == targeted_playerboard_slot:
+		return false
+	
+	var adjacent_slots = get_adjacent_playerboard_slots(selected_playerboard_slot)
+	return adjacent_slots.has(targeted_playerboard_slot)
+
+func _update_playerboard_slot_visual(slot_index: int):
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	if not main or not main.playerboard_ui:
+		return
+
+	var slot = main.playerboard_ui.get_child(slot_index)
+	if slot:
+		if slot.get_child_count() > 0:
+			slot.get_child(0).visible = slot_index == selected_playerboard_slot
+		if slot.get_child_count() > 1:
+			slot.get_child(1).visible = slot_index == targeted_playerboard_slot
+		if slot.get_child_count() > 2:
+			slot.get_child(2).visible = selected_playerboard_slot != -1 and get_adjacent_playerboard_slots(selected_playerboard_slot).has(slot_index)
+
+func _highlight_adjacent_playerboard_slots():
+	var main = player.get_tree().get_root().get_node_or_null("Main")
+	if not main or not main.playerboard_ui:
+		return
+
+	for i in range(25):
+		var slot = main.playerboard_ui.get_child(i)
+		if slot.get_child_count() > 2:
+			slot.get_child(2).hide()
+
+	if selected_playerboard_slot != -1:
+		var adjacent_slots = get_adjacent_playerboard_slots(selected_playerboard_slot)
+		for adj_slot in adjacent_slots:
+			var slot = main.playerboard_ui.get_child(adj_slot)
+			if slot.get_child_count() > 2:
+				slot.get_child(2).show()

scripts/managers/playerboard_manager.gd.uid

@@ -0,0 +1 @@
+uid://dqia04udk25fu

scripts/managers/turn_manager.gd

@@ -6,7 +6,7 @@ signal turn_changed(player_id)
 signal turn_ended()
 
 var current_turn_index: int = 0
-var turn_based_mode: bool = true
+var turn_based_mode: bool = false
 
 func next_turn(players: Array):
 	if turn_based_mode and players.size() > 0:

scripts/managers/turn_manager.gd.uid

@@ -0,0 +1 @@
+uid://c3xboobyp0ai7

scripts/managers/ui_manager.gd.uid

@@ -0,0 +1 @@
+uid://bsdl8yeaerylw

scripts/nakama_manager.gd

@@ -80,7 +80,7 @@ func host_game():
 		return
 	print("Hosting match via Nakama Bridge...")
 	var result = await bridge.create_match()
-	if result.is_exception():
+	if result and result.is_exception():
 		emit_signal("match_join_error", result.get_exception().message)
 
 func join_game(match_id: String):
@@ -89,7 +89,7 @@ func join_game(match_id: String):
 		return
 	print("Joining match: ", match_id)
 	var result = await bridge.join_match(match_id)
-	if result.is_exception():
+	if result and result.is_exception():
 		emit_signal("match_join_error", result.get_exception().message)
 
 # --- Callbacks ---