diff --git a/scenes/main.tscn b/scenes/main.tscn index 0dd37e5..388d562 100644 --- a/scenes/main.tscn +++ b/scenes/main.tscn @@ -32,8 +32,6 @@ texture = ExtResource("13_ahjgs") [node name="Main" type="Node3D"] script = ExtResource("1_xcpe3") -enable_bots = false -turn_based_mode = false [node name="EnhancedGridMap" type="GridMap" parent="."] mesh_library = ExtResource("1_110wo") diff --git a/scenes/player.gd b/scenes/player.gd index dd83115..1276fbe 100644 --- a/scenes/player.gd +++ b/scenes/player.gd @@ -1,19 +1,36 @@ extends Node3D +# Managers +var movement_manager +var race_manager +var input_manager +var playerboard_manager +var action_manager + @export var is_bot: bool = false @export var enhanced_gridmap_path: NodePath = "/root/Main/EnhancedGridMap" var enhanced_gridmap: EnhancedGridMap @export var current_position: Vector2i -var is_player_moving: bool = false +var is_player_moving: bool = false: + get: return movement_manager.is_moving if movement_manager else false + set(value): if movement_manager: movement_manager.is_moving = value + var _verify_timer: float = 0.0 -var can_finish +var can_finish: bool: + get: return race_manager.can_finish if race_manager else false + set(value): if race_manager: race_manager.can_finish = value @export var cell_size: Vector3 = Vector3(2, 2, 2) @export var cell_offset: Vector3 = Vector3(0, 0, 0) -@export var goals: Array[int] = [0,0,0,0,0,0,0,0,0] -@export 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] +@export var goals: Array[int]: + get: return race_manager.goals if race_manager else Array([], TYPE_INT, "", null) as Array[int] + set(value): if race_manager: race_manager.goals = value + +@export var playerboard: Array[int]: + get: return race_manager.playerboard if race_manager else Array([], TYPE_INT, "", null) as Array[int] + set(value): if race_manager: race_manager.playerboard = value # Modifier for Turn based var has_performed_action: bool = false @@ -23,7 +40,6 @@ var targeted_playerboard_slot = -1 var action_points: int = 2 # Modifier for player models -var target_rotation: float = 0.0 var rotation_speed: float = 10.0 var spawn_locations = [ @@ -44,22 +60,8 @@ var spawn_locations = [ ] # Add these as class variables at the top of the file -var finish_locations = [ - Vector2i(13, 0), # (13,0,0) - Vector2i(13, 1), # (13,0,1) - Vector2i(13, 2), # (13,0,2) - Vector2i(13, 3), # (13,0,3) - Vector2i(13, 4), # (13,0,4) - Vector2i(13, 5), # (13,0,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) -] +var finish_locations: Array: + get: return race_manager.finish_locations if race_manager else [] var spawn_point_selected = false @@ -69,12 +71,17 @@ var highlighted_cells = [] var _is_processing_action = false var _is_highlighting = false -@export var movement_range: int = 1 +@export var movement_range: int = 1: + set(value): + movement_range = value + if movement_manager: movement_manager.movement_range = value + @export var use_diagonal_movement: bool = false: set(value): use_diagonal_movement = value if enhanced_gridmap: enhanced_gridmap.set_diagonal_movement(value) + if movement_manager: movement_manager.use_diagonal_movement = value @export var is_my_turn: bool = false: set(value): @@ -85,21 +92,7 @@ var _is_highlighting = false @export var has_moved_this_turn = false # Track, Lap, Position -var current_lap: int = 0 -var first_lap_goals: Array[int] = [] # Current goals (partial 3x3) -var second_lap_goals: Array[int] = [] # Full 3x3 goals -var race_position: int = 0 # Track finish position -static var lap1_finishers: int = 0 # Static to track across all players -static var lap2_finishers: int = 0 - -# Function to get ordinal string (1st, 2nd, 3rd, 4th) -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" +# Delegated to RaceManager func _ready(): # Ensure name is set first @@ -115,17 +108,12 @@ func _ready(): push_error("Main scene not found") return - # Modifier to handle the lap - if is_multiplayer_authority(): - # Generate the first_lap_goals - first_lap_goals = goals.duplicate() - # Generate the second_lap_goals - generate_second_lap_goals() - # Ensure proper initialization order enhanced_gridmap = get_node(enhanced_gridmap_path) if main_scene: enhanced_gridmap = main_scene.get_node("EnhancedGridMap") + + _init_managers() # Early setup for bots if is_bot == true or is_in_group("Bots"): @@ -200,102 +188,50 @@ func _ready(): if is_multiplayer_authority(): rpc("sync_position", current_position) +func _init_managers(): + movement_manager = load("res://scripts/managers/player_movement_manager.gd").new() + movement_manager.name = "MovementManager" + add_child(movement_manager) + movement_manager.initialize(self, enhanced_gridmap) + + race_manager = load("res://scripts/managers/player_race_manager.gd").new() + race_manager.name = "RaceManager" + add_child(race_manager) + race_manager.initialize(self, enhanced_gridmap) + + input_manager = load("res://scripts/managers/player_input_manager.gd").new() + input_manager.name = "InputManager" + add_child(input_manager) + input_manager.initialize(self, movement_manager, race_manager) + + playerboard_manager = load("res://scripts/managers/playerboard_manager.gd").new() + playerboard_manager.name = "PlayerboardManager" + add_child(playerboard_manager) + playerboard_manager.initialize(self, enhanced_gridmap) + + action_manager = load("res://scripts/managers/player_action_manager.gd").new() + action_manager.name = "ActionManager" + add_child(action_manager) + action_manager.initialize(self, enhanced_gridmap) + # Add function to check if position is at finish line func is_at_finish_line() -> bool: - return current_position in finish_locations + return race_manager.is_at_finish_line() # Helper function to check if a 3x3 section matches the goals pattern -func check_3x3_section(board: Array, goals: Array, start_row: int, start_col: int) -> bool: - # First check if any required positions are empty (-1) - for i in range(3): - for j in range(3): - if goals[i][j] != -1: # Only check positions that are required by the goals - var board_value = board[start_row + i][start_col + j] - if board_value == -1: # If required position is empty - return false - - # Then check if the pattern matches - for i in range(3): - for j in range(3): - if goals[i][j] != -1: # Only check positions that are required by the goals - if board[start_row + i][start_col + j] != goals[i][j]: - return false - - return true +# Delegated to RaceManager # Generate full 3x3 goals for second lap -func generate_second_lap_goals(): - second_lap_goals.clear() - # Generate a complete 3x3 pattern (no empty spaces) - for i in range(9): - var val = (randi() % 4) + 7 # Values between 7 and 10 - second_lap_goals.append(val) - - if is_multiplayer_authority(): - rpc("sync_second_lap_goals", second_lap_goals) - -@rpc("any_peer", "reliable") -func sync_second_lap_goals(new_goals: Array): - second_lap_goals = new_goals +# Delegated to RaceManager # Modify finish_race to handle lap completion @rpc("any_peer", "reliable") func finish_race(): - if current_lap == 0: # Finishing first lap - lap1_finishers += 1 - race_position = lap1_finishers - - # Display first lap completion message - var message = "Finish 1st lap on " + get_ordinal_string(race_position) - if is_multiplayer_authority(): - rpc("display_message", message) - - # Start second lap - current_lap += 1 - rpc("start_new_lap") - - elif current_lap == 1: # Finishing second lap - lap2_finishers += 1 - race_position = lap2_finishers - - # Display second lap completion message - var message = "Finish 2nd lap on " + get_ordinal_string(race_position) - if is_multiplayer_authority(): - rpc("display_message", message) + race_manager.finish_race() # Add function to check 3x3 pattern matching anywhere in 5x5 playerboard func check_pattern_match() -> bool: - # Early return if playerboard or goals are not properly sized - if playerboard.size() != 25 or goals.size() != 9: - return false - - var current_goals = goals - - # Convert 1D arrays to 2D for easier pattern matching - var board_2d = [] - var goals_2d = [] - - # Convert playerboard to 2D (5x5) - for i in range(5): - var row = [] - for j in range(5): - row.append(playerboard[i * 5 + j]) - board_2d.append(row) - - # Convert goals to 2D (3x3) - for i in range(3): - var row = [] - for j in range(3): - row.append(goals[i * 3 + j]) - goals_2d.append(row) - - # Check each possible 3x3 section in the 5x5 board - for start_row in range(3): # 5-3+1 possible starting rows - for start_col in range(3): # 5-3+1 possible starting columns - if check_3x3_section(board_2d, goals_2d, start_row, start_col): - return true - - return false + return race_manager.check_pattern_match() ## Add function to handle new lap #@rpc("any_peer", "reliable") @@ -318,68 +254,21 @@ func check_pattern_match() -> bool: # Modify start_new_lap to handle different lap goals and starting positions @rpc("any_peer", "reliable") func start_new_lap(): - if current_lap == 1: # Moving to second lap - # Start from first lap finish line - var valid_finish_pos = find_valid_position_in_finish_line() - if valid_finish_pos != Vector2i(-1, -1): - current_position = valid_finish_pos - update_player_position(current_position) - - # Set new goals (full 3x3) - goals = second_lap_goals.duplicate() - - # Reset playerboard - #playerboard.fill(-1) - - # Reset can_finish flag - can_finish = false - - # Sync with other clients - if is_multiplayer_authority(): - rpc("sync_position", current_position) - rpc("sync_playerboard", playerboard) - rpc("sync_goals", goals) + race_manager.start_new_lap() # Function to find valid position in finish line -func find_valid_position_in_finish_line() -> Vector2i: - for pos in finish_locations: - if not is_position_occupied(pos): - return pos - return Vector2i(-1, -1) +# Delegated to RaceManager # Add function to check if player can reach finish func update_finish_availability(): - can_finish = check_pattern_match() - - # Update visual feedback if needed - if is_multiplayer_authority(): - if can_finish: - highlight_finish_line() - else: - unhighlight_finish_line() + race_manager.update_finish_availability() func unhighlight_finish_line(): - if not is_multiplayer_authority() or 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] - ) + race_manager.unhighlight_finish_line() # Add functions to handle finish line visualization func highlight_finish_line(): - if not is_multiplayer_authority() or 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 - ) + race_manager.highlight_finish_line() func request_spawn_positions_update(): if multiplayer.is_server(): @@ -449,6 +338,10 @@ func _process(delta): if _verify_timer >= 3.0: _verify_timer = 0.0 rpc("ping_existence") + + # Delegate rotation to movement manager + if movement_manager: + movement_manager._process(delta) @rpc("any_peer", "call_local") func ping_existence(): @@ -461,7 +354,7 @@ func _physics_process(delta): rpc("remote_set_position", global_position) # Add continuous finish line check - if current_position in finish_locations and can_finish and not is_player_moving: + if race_manager and current_position in race_manager.finish_locations and can_finish and not is_player_moving: start_new_lap() # -------------------------------------------------------------------- @@ -469,126 +362,17 @@ func _physics_process(delta): # -------------------------------------------------------------------- func _unhandled_input(event): - # Early return if not authorized human player - if not is_multiplayer_authority() or is_bot or is_in_group("Bots"): - set_process_unhandled_input(false) - return - - var main = get_node("/root/Main") - - # --- Real-time Keyboard/Touch Input --- - if not main.turn_based_mode and not is_player_moving: - var target_position = 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"): - grab_item(current_position) # Try to grab from current position [cite: 59] - elif Input.is_action_just_pressed("action_put"): - auto_put_item() - else: - input_handled = false # No relevant key was pressed - - if target_position != current_position: - simple_move_to(target_position) - - if input_handled: - get_viewport().set_input_as_handled() # Consume the event - return # Don't process turn-based or spawn logic - # --- End Real-time Input --- - - # Handle spawn point selection if not yet selected - if not spawn_point_selected and highlighted_spawn_points.size() > 0: - if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT: - var camera = 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 = raycast_to_grid(from, to) - if click_position in highlighted_spawn_points: - if select_spawn_point(click_position): - return # Spawn point selected successfully - - # Use get_node_or_null for safer node access - if not main: - return - - # Turn-based mouse input - if not is_multiplayer_authority() or (main.turn_based_mode and (not is_my_turn or is_player_moving)): - return - - if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT: - if is_bot == true or is_in_group("Bots"): - set_process_unhandled_input(false) - set_process_input(false) - return - var camera = 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 = raycast_to_grid(from, to) - if click_position != Vector2i(-1, -1): - handle_grid_click(click_position) + if input_manager: + input_manager.handle_unhandled_input(event) func _on_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 = get_tree().get_root().get_node_or_null("Main") - - if main.current_action_state == main.ActionState.ARRANGING: - if selected_playerboard_slot == -1: - select_playerboard_slot(slot_index) - return slot_index - else: - if selected_playerboard_slot == slot_index: - deselect_playerboard_slot() - return slot_index - elif can_move_to_target_playerboard_slot(): - target_playerboard_slot(slot_index) - main.emit_signal("can_move_item", true) - return slot_index - else: - return -1 + if input_manager: + return input_manager.handle_slot_gui_input(event, slot_index, slot_ui) return -1 func handle_grid_click(grid_position: Vector2i): - if is_bot == true or is_in_group("Bots"): - return - var main = get_tree().get_root().get_node_or_null("Main") - if not main: - push_error("Main node not found") - return - - match main.current_action_state: - main.ActionState.MOVING: - if grid_position in highlighted_cells: - move_player_to_clicked_position(grid_position) - main.ActionState.GRABBING: - if grid_position in highlighted_cells or grid_position == current_position: - grab_item(grid_position) - #main.ActionState.PUTTING: - #if grid_position in highlighted_cells and selected_playerboard_slot != -1: - #put_item(grid_position) - main.ActionState.RANDOMIZING: - if grid_position in highlighted_cells: - main.randomize_item_at_position(grid_position) - main.ActionState.PLACING_OBSTACLE: - if grid_position in highlighted_cells: - main.place_obstacle(grid_position) + if input_manager: + input_manager.handle_grid_click(grid_position) # Modify is_position_occupied to check for selected spawn points func is_position_occupied(pos: Vector2i) -> bool: @@ -730,119 +514,17 @@ func raycast_to_grid(from: Vector3, to: Vector3) -> Vector2i: return Vector2i(-1, -1) func is_within_movement_range(target_position: Vector2i) -> bool: - var distance: int - if use_diagonal_movement: - distance = max(abs(target_position.x - current_position.x), abs(target_position.y - current_position.y)) - else: - distance = abs(target_position.x - current_position.x) + abs(target_position.y - current_position.y) - return distance <= movement_range + return movement_manager.is_within_movement_range(target_position) # ----------------------------------------------------------------- # Movement # ----------------------------------------------------------------- func simple_move_to(grid_position: Vector2i): - if not is_multiplayer_authority() or is_player_moving: - return - - # Check if target is within 1-tile range - var distance: int - if use_diagonal_movement: - distance = max(abs(grid_position.x - current_position.x), abs(grid_position.y - current_position.y)) - else: - distance = abs(grid_position.x - current_position.x) + abs(grid_position.y - current_position.y) - - if distance != 1: - return # Only single-step moves allowed - - # Check for finish line - if grid_position in finish_locations: - if not can_finish: - can_finish = check_pattern_match() - if not can_finish: - return # Cannot move to finish line - - var is_valid_finish = grid_position in finish_locations if current_lap == 0 else grid_position in spawn_locations - - # 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 is_position_occupied(grid_position): - return - - if enhanced_gridmap.is_blocked_by_obstacle(current_position, grid_position, 3): - return - - # All checks passed, perform move - rotate_towards_target(grid_position) - - var path = [Vector2(current_position.x, current_position.y), Vector2(grid_position.x, grid_position.y)] - path.pop_front() - - # Use the existing RPC to move - rpc("start_movement_along_path", path, not (is_bot or is_in_group("Bots"))) - - # Handle finish line crossing - if is_valid_finish and can_finish: - rpc("finish_race") + movement_manager.simple_move_to(grid_position) func move_player_to_clicked_position(grid_position: Vector2i): - - if not is_multiplayer_authority() or is_player_moving or action_points <= 0: - return - - # Check if trying to move to finish line - if grid_position in finish_locations: - if not can_finish: - can_finish = check_pattern_match() - if not can_finish: - return # Cannot move to finish line if pattern doesn't match - - var is_valid_finish = false - # Make scenario for match checking laps, for handle lap count - if current_lap == 0: # first lap - is_valid_finish = grid_position in finish_locations - else: # second lap - is_valid_finish = grid_position in spawn_locations - - if not is_within_movement_range(grid_position): - return - - - - var main = get_tree().get_root().get_node_or_null("Main") - if not main or main.current_action_state != main.ActionState.MOVING or not grid_position in highlighted_cells: - return - - if not is_within_movement_range(grid_position): - return - - 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 is_position_occupied(grid_position): - return - - # Check if direct movement is blocked by an obstacle - if enhanced_gridmap.is_blocked_by_obstacle(current_position, grid_position, 3): - # Do not allow movement if blocked (this should not happen if highlight logic is correct) - print("Movement blocked by obstacle") - return - - rotate_towards_target(grid_position) - - # Create a direct path rather than using A* for obstacle avoidance - # This ensures the player can only move to directly accessible positions - var path = [Vector2(current_position.x, current_position.y), Vector2(grid_position.x, grid_position.y)] - path.pop_front() - - rpc("start_movement_along_path", path, not (is_bot or is_in_group("Bots"))) - action_points -= 1 - - # Clear highlights after moving - if not (is_bot or is_in_group("Bots")): - clear_highlights() - - # Handle finish line crossing - if is_valid_finish and can_finish: - rpc("finish_race") + movement_manager.move_to_clicked_position(grid_position) @rpc("any_peer", "call_local") func start_movement_along_path(path: Array, clear_visual: bool = true): @@ -870,16 +552,16 @@ func start_movement_along_path(path: Array, clear_visual: bool = true): enhanced_gridmap.clear_path_visualization() # Restore movement range highlights if it was the player's turn - if main and main.current_action_state == main.ActionState.MOVING and is_my_turn: + if main and main.ui_manager.current_action_state == main.ui_manager.ActionState.MOVING and is_my_turn: highlight_movement_range() has_moved_this_turn = path.size() <= movement_range if main: if not (is_bot or is_in_group("Bots")): - main.set_action_state(main.ActionState.NONE) + main.ui_manager.current_action_state = main.ui_manager.ActionState.NONE - if main and main.turn_based_mode: + if TurnManager.turn_based_mode: end_turn() _after_action_completed() ) @@ -944,19 +626,22 @@ func end_turn(): get_tree().get_root().get_node_or_null("Main").request_next_turn() func reset_race(): - current_lap = 0 - race_position = 0 - can_finish = false - goals = first_lap_goals.duplicate() - playerboard.fill(-1) - if is_multiplayer_authority(): - rpc("sync_goals", goals) - rpc("sync_playerboard", playerboard) + if race_manager: + race_manager.current_lap = 0 + race_manager.race_position = 0 + race_manager.can_finish = false + race_manager.goals = race_manager.first_lap_goals.duplicate() + race_manager.playerboard.fill(-1) + if is_multiplayer_authority(): + rpc("sync_goals", race_manager.goals) + rpc("sync_playerboard", race_manager.playerboard) # Add a static reset for new games static func reset_race_stats(): - lap1_finishers = 0 - lap2_finishers = 0 + var race_mgr = load("res://scripts/managers/player_race_manager.gd") + if race_mgr: + race_mgr.lap1_finishers = 0 + race_mgr.lap2_finishers = 0 @rpc("any_peer", "call_local", "unreliable") func remote_set_position(authority_position): @@ -1445,12 +1130,12 @@ func handle_playerboard_slot_selected(slot_index: int): if not main: return - if main.current_action_state == main.ActionState.PUTTING: + if main.ui_manager.current_action_state == main.ui_manager.ActionState.PUTTING: if playerboard[slot_index] != -1: # If slot has an item selected_playerboard_slot = slot_index clear_highlights() highlight_empty_adjacent_cells() # Highlight valid put locations - elif main.current_action_state == main.ActionState.GRABBING: + elif main.ui_manager.current_action_state == main.ui_manager.ActionState.GRABBING: if slot_index in highlighted_cells and playerboard[slot_index] == -1: var cell = Vector3i(selected_gridmap_position.x, 1, selected_gridmap_position.y) var item = enhanced_gridmap.get_cell_item(cell) @@ -1467,13 +1152,13 @@ func handle_playerboard_slot_selected(slot_index: int): clear_highlights() clear_playerboard_highlights() selected_gridmap_position = Vector2i(-1, -1) - main.set_action_state(main.ActionState.NONE) + main.ui_manager.current_action_state = main.ui_manager.ActionState.NONE _after_action_completed() # We also need to add handle_put_slot_selected: func handle_put_slot_selected(slot_index: int): var main = get_tree().get_root().get_node_or_null("Main") - if not main or main.current_action_state != main.ActionState.PUTTING: + if not main or main.ui_manager.current_action_state != main.ui_manager.ActionState.PUTTING: return print("PUT slot selected: ", slot_index, ", item: ", playerboard[slot_index]) @@ -1506,28 +1191,28 @@ func arrange_playerboard_item(slot_index: int): var adjacent_slots = get_adjacent_playerboard_slots(slot_index) var main = get_tree().get_root().get_node_or_null("Main") - if not main or not main.playerboard_ui: + 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.playerboard_ui.get_child(slot_index) + 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 playerboard[adj_slot] == -1: # Only highlight empty adjacent slots - var adj_slot_ui = main.playerboard_ui.get_child(adj_slot) + 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() highlighted_cells.append(adj_slot) # Connect to slot click signals for i in range(playerboard.size()): - var slot = main.playerboard_ui.get_child(i) + var slot = main.ui_manager.playerboard_ui.get_child(i) if not slot.gui_input.is_connected(_on_slot_clicked): slot.gui_input.connect(_on_slot_clicked.bind(i)) @@ -1536,7 +1221,7 @@ func _on_slot_clicked(event: InputEvent, slot_index: int): return var main = get_tree().get_root().get_node_or_null("Main") - if not main or main.current_action_state != main.ActionState.ARRANGING: + 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: @@ -1562,8 +1247,8 @@ func _on_slot_clicked(event: InputEvent, slot_index: int): selected_playerboard_slot = -1 # Update the visual representation - main.update_playerboard_ui() - main.set_action_state(main.ActionState.NONE) + main.ui_manager.update_playerboard_ui() + main.ui_manager.current_action_state = main.ui_manager.ActionState.NONE func is_valid_arrangement_slot(from_slot: int, to_slot: int) -> bool: var from_row = from_slot / 5 @@ -1727,152 +1412,16 @@ func highlight_cells_if_authorized(cells_to_highlight: Array): # Update highlight_movement_range to respect the expanded obstacle blocking func highlight_movement_range(): - if not is_multiplayer_authority() or is_bot or is_in_group("Bots"): - return - - # Prevent recursive highlighting - if _is_highlighting: - return - _is_highlighting = true - - 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, current_position.x - movement_range), - min(enhanced_gridmap.columns, current_position.x + movement_range + 1)): - for z in range(max(0, current_position.y - movement_range), - min(enhanced_gridmap.rows, current_position.y + movement_range + 1)): - var test_pos = Vector2i(x, z) - - # Skip current position - if test_pos == 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 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: - highlight_cells_if_authorized(cells_to_highlight) - _is_highlighting = false + movement_manager.highlight_movement_range() # 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 = [current_position] - var visited = {current_position: true} - var steps = {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 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 is_multiplayer_authority() or is_bot or is_in_group("Bots"): - return - - var cells_to_highlight = [] - - # Add current position if item exists - var current_cell = Vector3i(current_position.x, 1, current_position.y) - if enhanced_gridmap.get_cell_item(current_cell) != -1: - cells_to_highlight.append(current_position) - - # Add valid neighbors - var neighbors = enhanced_gridmap.get_neighbors(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) - - highlight_cells_if_authorized(cells_to_highlight) + movement_manager.highlight_adjacent_cells() func highlight_empty_adjacent_cells(): if is_bot == true or is_in_group("Bots"): @@ -1938,25 +1487,25 @@ func highlight_occupied_playerboard_slots(): return var main = get_tree().get_root().get_node_or_null("Main") - if not main or not main.playerboard_ui: + if not main or not main.ui_manager.playerboard_ui: return # First reset all slots to normal for i in range(playerboard.size()): - var slot = main.playerboard_ui.get_child(i) + 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(playerboard.size()): if playerboard[i] in goals: - var slot = main.playerboard_ui.get_child(i) + 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 highlighted_cells.append(i) # Add to highlighted cells for tracking # Update the UI to reflect changes - main.update_playerboard_ui() + main.ui_manager.update_playerboard_ui() func clear_highlights(): # Never allow bots to clear highlights for human players @@ -1968,7 +1517,7 @@ func clear_highlights(): # Store the current action state before clearing var main = get_tree().get_root().get_node_or_null("Main") - var current_state = main.current_action_state if main else null + var current_state = main.ui_manager.current_action_state if main else null for cell in highlighted_cells: if cell is Vector2i: @@ -1976,14 +1525,14 @@ func clear_highlights(): highlighted_cells.clear() - if main and main.playerboard_ui: - for i in range(main.playerboard_ui.get_child_count()): - var slot = main.playerboard_ui.get_child(i) + 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.ActionState.MOVING and is_my_turn and current_state != main.ActionState.PLACING_OBSTACLE: + if main and current_state == main.ui_manager.ActionState.MOVING and is_my_turn and current_state != main.ui_manager.ActionState.PLACING_OBSTACLE: highlight_movement_range() func clear_playerboard_highlights(): @@ -1995,9 +1544,9 @@ func clear_playerboard_highlights(): return var main = get_tree().get_root().get_node_or_null("Main") - if main and main.playerboard_ui: - for i in range(main.playerboard_ui.get_child_count()): - var slot = main.playerboard_ui.get_child(i) + 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() @@ -2005,14 +1554,7 @@ func clear_playerboard_highlights(): highlighted_cells.clear() func rotate_towards_target(target_pos: Vector2i): - var direction = Vector2(target_pos.x - current_position.x, target_pos.y - current_position.y).normalized() - target_rotation = atan2(direction.x, direction.y) - - if is_multiplayer_authority(): - rpc("sync_rotation", target_rotation) - - var tween = create_tween() - tween.tween_property(self, "rotation:y", target_rotation, 0.2) + movement_manager.rotate_towards_target(target_pos) # We also need to add these supporting functions: func select_playerboard_slot(slot_index: int): @@ -2105,6 +1647,11 @@ func sync_grid_item(x: int, y: int, z: int, item: int): func sync_goals(new_goals: Array): goals = new_goals.duplicate() # Make sure to duplicate the array +@rpc("any_peer", "call_local") +func sync_second_lap_goals(new_goals: Array): + if race_manager: + race_manager.second_lap_goals = new_goals.duplicate() + @rpc("any_peer", "call_local") func sync_playerboard(new_playerboard: Array): playerboard = new_playerboard.duplicate() @@ -2129,13 +1676,13 @@ func _after_action_completed(): var main = get_tree().get_root().get_node_or_null("Main") if main: # Add this condition for bots - if not main.turn_based_mode and (action_points <= 0 or is_bot): + if not TurnManager.turn_based_mode and (action_points <= 0 or is_bot): action_points = 20 # For bots in non-turn-based mode, this will keep refreshing has_performed_action = false has_moved_this_turn = false - main.update_button_states() - main.update_playerboard_ui() + main.ui_manager.update_button_states() + main.ui_manager.update_playerboard_ui() # Add this line to sync all boards main.update_all_players_boards() @@ -2158,14 +1705,14 @@ func consume_action_points(points: int): return # Don't consume points for bots in non-turn-based mode - if is_bot == true and not main.turn_based_mode: + if is_bot == true and not TurnManager.turn_based_mode: _after_action_completed() return action_points -= points if action_points <= 0: - if main.turn_based_mode: + if TurnManager.turn_based_mode: main.request_next_turn() else: action_points = 2 diff --git a/scripts/behaviors/conditions/has_ap.gd b/scripts/behaviors/conditions/has_ap.gd index c950c90..fc92a5e 100644 --- a/scripts/behaviors/conditions/has_ap.gd +++ b/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 diff --git a/scripts/managers/game_state_manager.gd b/scripts/managers/game_state_manager.gd index df9301f..30caa40 100644 --- a/scripts/managers/game_state_manager.gd +++ b/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 = [] diff --git a/scripts/managers/game_state_manager.gd.uid b/scripts/managers/game_state_manager.gd.uid new file mode 100644 index 0000000..6abd97f --- /dev/null +++ b/scripts/managers/game_state_manager.gd.uid @@ -0,0 +1 @@ +uid://qiysnc8g7v8x diff --git a/scripts/managers/goal_manager.gd.uid b/scripts/managers/goal_manager.gd.uid new file mode 100644 index 0000000..eb09019 --- /dev/null +++ b/scripts/managers/goal_manager.gd.uid @@ -0,0 +1 @@ +uid://bfsev0xjqewcm diff --git a/scripts/managers/obstacle_manager.gd.uid b/scripts/managers/obstacle_manager.gd.uid new file mode 100644 index 0000000..12bd26a --- /dev/null +++ b/scripts/managers/obstacle_manager.gd.uid @@ -0,0 +1 @@ +uid://du0i5xyfiwdtq diff --git a/scripts/managers/player_action_manager.gd b/scripts/managers/player_action_manager.gd new file mode 100644 index 0000000..84e92bb --- /dev/null +++ b/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() diff --git a/scripts/managers/player_action_manager.gd.uid b/scripts/managers/player_action_manager.gd.uid new file mode 100644 index 0000000..226df14 --- /dev/null +++ b/scripts/managers/player_action_manager.gd.uid @@ -0,0 +1 @@ +uid://bwsl442pejsov diff --git a/scripts/managers/player_input_manager.gd b/scripts/managers/player_input_manager.gd new file mode 100644 index 0000000..b75dbaf --- /dev/null +++ b/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 diff --git a/scripts/managers/player_input_manager.gd.uid b/scripts/managers/player_input_manager.gd.uid new file mode 100644 index 0000000..9f04521 --- /dev/null +++ b/scripts/managers/player_input_manager.gd.uid @@ -0,0 +1 @@ +uid://da4wamdyr2ckt diff --git a/scripts/managers/player_manager.gd.uid b/scripts/managers/player_manager.gd.uid new file mode 100644 index 0000000..5c3d636 --- /dev/null +++ b/scripts/managers/player_manager.gd.uid @@ -0,0 +1 @@ +uid://bpllaov4k7l50 diff --git a/scripts/managers/player_movement_manager.gd b/scripts/managers/player_movement_manager.gd new file mode 100644 index 0000000..d50f450 --- /dev/null +++ b/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) diff --git a/scripts/managers/player_movement_manager.gd.uid b/scripts/managers/player_movement_manager.gd.uid new file mode 100644 index 0000000..3ac9f90 --- /dev/null +++ b/scripts/managers/player_movement_manager.gd.uid @@ -0,0 +1 @@ +uid://r47t031kgah5 diff --git a/scripts/managers/player_race_manager.gd b/scripts/managers/player_race_manager.gd new file mode 100644 index 0000000..b578be7 --- /dev/null +++ b/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) diff --git a/scripts/managers/player_race_manager.gd.uid b/scripts/managers/player_race_manager.gd.uid new file mode 100644 index 0000000..d9a3089 --- /dev/null +++ b/scripts/managers/player_race_manager.gd.uid @@ -0,0 +1 @@ +uid://dhtm6illlplhf diff --git a/scripts/managers/playerboard_manager.gd b/scripts/managers/playerboard_manager.gd new file mode 100644 index 0000000..cb1262b --- /dev/null +++ b/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() diff --git a/scripts/managers/playerboard_manager.gd.uid b/scripts/managers/playerboard_manager.gd.uid new file mode 100644 index 0000000..7598f94 --- /dev/null +++ b/scripts/managers/playerboard_manager.gd.uid @@ -0,0 +1 @@ +uid://dqia04udk25fu diff --git a/scripts/managers/turn_manager.gd b/scripts/managers/turn_manager.gd index 3fe19f9..dbce0db 100644 --- a/scripts/managers/turn_manager.gd +++ b/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: diff --git a/scripts/managers/turn_manager.gd.uid b/scripts/managers/turn_manager.gd.uid new file mode 100644 index 0000000..499af20 --- /dev/null +++ b/scripts/managers/turn_manager.gd.uid @@ -0,0 +1 @@ +uid://c3xboobyp0ai7 diff --git a/scripts/managers/ui_manager.gd.uid b/scripts/managers/ui_manager.gd.uid new file mode 100644 index 0000000..03c7bfb --- /dev/null +++ b/scripts/managers/ui_manager.gd.uid @@ -0,0 +1 @@ +uid://bsdl8yeaerylw diff --git a/scripts/nakama_manager.gd b/scripts/nakama_manager.gd index 6eca94a..bd2d658 100644 --- a/scripts/nakama_manager.gd +++ b/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 ---