danchie/tekton
3
1
Fork 0
Code Issues 20 Pull Requests Actions Packages Projects 10 Releases 1 Wiki Activity

player.gd refactor progress

Browse Source
This commit is contained in:
adtpdn
2025-12-03 18:16:00 +08:00
parent ead155afed
commit a97a8e68f6
22 changed files with 1461 additions and 596 deletions
Download Patch File Download Diff File Expand all files Collapse all files
scenes/main.tscn
-2
View File
@@ -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")
scenes/player.gd
+136 -589
View File
@@ -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
scripts/behaviors/conditions/has_ap.gd
+1 -1
View File
@@ -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
+1 -1
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
uid://qiysnc8g7v8x
scripts/managers/goal_manager.gd.uid
+1
View File
@@ -0,0 +1 @@
uid://bfsev0xjqewcm
scripts/managers/obstacle_manager.gd.uid
+1
View File
@@ -0,0 +1 @@
uid://du0i5xyfiwdtq
scripts/managers/player_action_manager.gd
+247
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
uid://bwsl442pejsov
scripts/managers/player_input_manager.gd
+126
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
uid://da4wamdyr2ckt
scripts/managers/player_manager.gd.uid
+1
View File
@@ -0,0 +1 @@
uid://bpllaov4k7l50
scripts/managers/player_movement_manager.gd
+245
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
uid://r47t031kgah5
scripts/managers/player_race_manager.gd
+160
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
uid://dhtm6illlplhf
scripts/managers/playerboard_manager.gd
+531
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
uid://dqia04udk25fu
scripts/managers/turn_manager.gd
+1 -1
View File
@@ -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
+1
View File
@@ -0,0 +1 @@
uid://c3xboobyp0ai7
scripts/managers/ui_manager.gd.uid
+1
View File
@@ -0,0 +1 @@
uid://bsdl8yeaerylw
scripts/nakama_manager.gd
+2 -2
View File
@@ -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 ---