1828 lines
57 KiB
GDScript
1828 lines
57 KiB
GDScript
extends Node3D
|
|
|
|
@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 _verify_timer: float = 0.0
|
|
var can_finish
|
|
|
|
@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]
|
|
|
|
# Modifier for Turn based
|
|
var has_performed_action: bool = false
|
|
var selected_gridmap_position = Vector2i(-1, -1)
|
|
var selected_playerboard_slot = -1
|
|
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 = [
|
|
Vector2i(0, 0), # (0,1,0)
|
|
Vector2i(0, 1), # (0,1,1)
|
|
Vector2i(0, 2), # (0,1,2)
|
|
Vector2i(0, 3), # (0,1,3)
|
|
Vector2i(0, 4), # (0,1,4)
|
|
Vector2i(0, 5) # (0,1,5)
|
|
]
|
|
|
|
# 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)
|
|
]
|
|
|
|
var spawn_point_selected = false
|
|
|
|
# Action for hilighter
|
|
var highlighted_spawn_points = []
|
|
var highlighted_cells = []
|
|
var _is_processing_action = false
|
|
var _is_highlighting = false
|
|
|
|
@export var movement_range: int = 1
|
|
@export var use_diagonal_movement: bool = false:
|
|
set(value):
|
|
use_diagonal_movement = value
|
|
if enhanced_gridmap:
|
|
enhanced_gridmap.set_diagonal_movement(value)
|
|
|
|
@export var is_my_turn: bool = false:
|
|
set(value):
|
|
is_my_turn = value
|
|
if is_my_turn and is_multiplayer_authority():
|
|
rpc("display_message", "It's your turn!")
|
|
|
|
@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"
|
|
|
|
func _ready():
|
|
# Ensure name is set first
|
|
name = str(get_multiplayer_authority())
|
|
$Name.text = str(name)
|
|
|
|
# Wait briefly to ensure proper scene setup
|
|
await get_tree().create_timer(0.1).timeout
|
|
|
|
# More robust way to get the main scene
|
|
var main_scene = get_tree().get_root().get_node_or_null("Main")
|
|
if not main_scene:
|
|
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")
|
|
|
|
# Early setup for bots
|
|
if is_bot == true or is_in_group("Bots"):
|
|
# Initialize behavior tree for bots
|
|
var behavior_tree = $BehaviorTree
|
|
# Disable all input processing for bots immediately
|
|
set_process_input(false)
|
|
set_process_unhandled_input(false)
|
|
set_process(false)
|
|
set_physics_process(false)
|
|
|
|
# Disable visual highlights for bots
|
|
highlighted_cells.clear()
|
|
|
|
if behavior_tree:
|
|
behavior_tree.enabled = is_multiplayer_authority()
|
|
behavior_tree.actor = self
|
|
|
|
rpc("sync_bot_status", true)
|
|
|
|
## Initialize bot-specific components
|
|
#if enhanced_gridmap:
|
|
#current_position = find_valid_starting_position()
|
|
#update_player_position(current_position)
|
|
|
|
# Spawn point handler
|
|
if enhanced_gridmap:
|
|
current_position = _find_random_spawn_position()
|
|
update_player_position(current_position)
|
|
spawn_point_selected = true
|
|
# Notify others about bot spawn position
|
|
rpc("notify_spawn_selected", current_position)
|
|
|
|
else:
|
|
# Human player initialization
|
|
if enhanced_gridmap:
|
|
enhanced_gridmap.initialize_astar()
|
|
enhanced_gridmap.set_diagonal_movement(use_diagonal_movement)
|
|
|
|
# Request current spawn positions before highlighting
|
|
request_spawn_positions_update()
|
|
|
|
highlight_available_spawn_points()
|
|
# Remove this line as goals are now managed by the host
|
|
#append_random_goals()
|
|
|
|
playerboard.resize(25)
|
|
playerboard.fill(-1)
|
|
return
|
|
|
|
# Disable Beehave tree if this is not a bot
|
|
if not is_bot and has_node("BehaviorTree"):
|
|
$BehaviorTree.enabled = false
|
|
|
|
# Rest of initialization (only for human players)
|
|
if enhanced_gridmap:
|
|
enhanced_gridmap.initialize_astar()
|
|
enhanced_gridmap.set_diagonal_movement(use_diagonal_movement)
|
|
current_position = find_valid_starting_position()
|
|
update_player_position(current_position)
|
|
|
|
#append_random_goals()
|
|
playerboard.resize(25)
|
|
playerboard.fill(-1)
|
|
|
|
# Ensure proper initial positioning
|
|
global_position = Vector3(
|
|
current_position.x * cell_size.x + cell_size.x * 0.5,
|
|
1.0,
|
|
current_position.y * cell_size.z + cell_size.z * 0.5
|
|
)
|
|
if is_multiplayer_authority():
|
|
rpc("sync_position", current_position)
|
|
|
|
|
|
|
|
# Add function to check if position is at finish line
|
|
func is_at_finish_line() -> bool:
|
|
return current_position in finish_locations
|
|
|
|
# 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
|
|
|
|
# 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
|
|
|
|
# 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)
|
|
|
|
# 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
|
|
|
|
## Add function to handle new lap
|
|
#@rpc("any_peer", "reliable")
|
|
#func start_new_lap():
|
|
## Reset position to start
|
|
#current_position = find_valid_starting_position()
|
|
#update_player_position(current_position)
|
|
#
|
|
## Reset playerboard but keep the goals
|
|
#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)
|
|
|
|
# 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)
|
|
|
|
# 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)
|
|
|
|
# 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()
|
|
|
|
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]
|
|
)
|
|
|
|
# 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
|
|
)
|
|
|
|
func request_spawn_positions_update():
|
|
if multiplayer.is_server():
|
|
# Server can directly highlight available positions
|
|
highlight_available_spawn_points()
|
|
else:
|
|
# Clients request an update from the server
|
|
rpc_id(1, "server_update_spawn_positions")
|
|
|
|
# Add server-side spawn position update handler
|
|
@rpc("any_peer", "reliable")
|
|
func server_update_spawn_positions():
|
|
if not multiplayer.is_server():
|
|
return
|
|
|
|
var sender_id = multiplayer.get_remote_sender_id()
|
|
var occupied = get_occupied_positions()
|
|
|
|
# Send the occupied positions back to the requesting client
|
|
rpc_id(sender_id, "receive_spawn_positions_update", occupied)
|
|
|
|
# Add client-side spawn position update receiver
|
|
@rpc("authority", "reliable")
|
|
func receive_spawn_positions_update(occupied_positions: Array):
|
|
# Update local highlight state based on received occupied positions
|
|
for pos in highlighted_spawn_points:
|
|
if pos in occupied_positions:
|
|
highlighted_spawn_points.erase(pos)
|
|
if enhanced_gridmap:
|
|
enhanced_gridmap.set_cell_item(
|
|
Vector3i(pos.x, 0, pos.y),
|
|
enhanced_gridmap.normal_items[0]
|
|
)
|
|
|
|
# Now highlight available positions
|
|
highlight_available_spawn_points()
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func sync_bot_status(is_bot_status: bool):
|
|
is_bot = is_bot_status
|
|
if is_bot:
|
|
add_to_group("Bots", true)
|
|
set_process_input(false)
|
|
set_process_unhandled_input(false)
|
|
|
|
# Clear any existing highlights
|
|
highlighted_cells.clear()
|
|
#clear_highlights()
|
|
#clear_playerboard_highlights()
|
|
|
|
var behavior_tree = get_node_or_null("BehaviorTree")
|
|
if behavior_tree:
|
|
behavior_tree.enabled = is_multiplayer_authority()
|
|
behavior_tree.actor = self
|
|
if not is_multiplayer_authority():
|
|
behavior_tree.set_physics_process(false)
|
|
behavior_tree.set_process(false)
|
|
|
|
func _process(delta):
|
|
if is_multiplayer_authority():
|
|
|
|
# Visual debugging - show connection status in name label
|
|
$Name.text = str(name) + "\n(Auth: " + str(get_multiplayer_authority()) + ")"
|
|
|
|
# Periodically verify our existence to others
|
|
_verify_timer += delta
|
|
if _verify_timer >= 3.0:
|
|
_verify_timer = 0.0
|
|
rpc("ping_existence")
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func ping_existence():
|
|
# This just lets other clients know this player exists
|
|
# They can check if they have this node
|
|
pass
|
|
|
|
func _physics_process(delta):
|
|
if is_multiplayer_authority():
|
|
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:
|
|
start_new_lap()
|
|
|
|
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
|
|
|
|
# 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
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
if not main:
|
|
return
|
|
|
|
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)
|
|
|
|
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
|
|
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)
|
|
|
|
# Modify is_position_occupied to check for selected spawn points
|
|
func is_position_occupied(pos: Vector2i) -> bool:
|
|
for player in get_tree().get_nodes_in_group("Players"):
|
|
if player != self and player.spawn_point_selected and player.current_position == pos:
|
|
return true
|
|
return false
|
|
|
|
func find_valid_starting_position() -> Vector2i:
|
|
if is_bot:
|
|
return _find_random_spawn_position()
|
|
else:
|
|
highlight_available_spawn_points()
|
|
# Return temporary position, will be updated when player selects spawn point
|
|
return Vector2i(-1, -1)
|
|
|
|
func highlight_available_spawn_points():
|
|
if not is_multiplayer_authority() or is_bot or spawn_point_selected:
|
|
return
|
|
|
|
# Clear any existing highlights
|
|
clear_highlights()
|
|
highlighted_spawn_points.clear()
|
|
|
|
# Get all currently occupied positions
|
|
var occupied_positions = get_occupied_positions()
|
|
|
|
# Check each spawn location
|
|
for spawn_pos in spawn_locations:
|
|
if not is_position_occupied(spawn_pos):
|
|
highlighted_spawn_points.append(spawn_pos)
|
|
if enhanced_gridmap:
|
|
# Highlight the cell at y=0 (ground level)
|
|
enhanced_gridmap.set_cell_item(
|
|
Vector3i(spawn_pos.x, 0, spawn_pos.y),
|
|
enhanced_gridmap.hover_item
|
|
)
|
|
|
|
# Add function to get all occupied positions
|
|
func get_occupied_positions() -> Array:
|
|
var occupied = []
|
|
for player in get_tree().get_nodes_in_group("Players"):
|
|
if player.spawn_point_selected: # Only count players who have selected a spawn point
|
|
occupied.append(player.current_position)
|
|
return occupied
|
|
|
|
# Modify the select_spawn_point function to notify other clients
|
|
func select_spawn_point(spawn_pos: Vector2i) -> bool:
|
|
if not is_multiplayer_authority() or is_bot or spawn_point_selected:
|
|
return false
|
|
|
|
if spawn_pos in highlighted_spawn_points and not is_position_occupied(spawn_pos):
|
|
current_position = spawn_pos
|
|
spawn_point_selected = true
|
|
|
|
# Update position in the world
|
|
position = grid_to_world(spawn_pos)
|
|
|
|
# Notify all clients about the spawn selection
|
|
rpc("notify_spawn_selected", spawn_pos)
|
|
|
|
# Clear highlights locally
|
|
clear_spawn_highlights()
|
|
|
|
# Sync position with other clients
|
|
if is_multiplayer_authority():
|
|
rpc("sync_position", current_position)
|
|
|
|
return true
|
|
return false
|
|
|
|
func clear_spawn_highlights():
|
|
# Clear the highlighted spawn points array
|
|
for spawn_pos in highlighted_spawn_points:
|
|
if enhanced_gridmap:
|
|
# Reset the cell to its original state
|
|
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(spawn_pos.x, 1, spawn_pos.y))
|
|
enhanced_gridmap.set_cell_item(
|
|
Vector3i(spawn_pos.x, 0, spawn_pos.y),
|
|
enhanced_gridmap.normal_items[0] if cell_item != -1 else -1
|
|
)
|
|
|
|
# Clear the array
|
|
highlighted_spawn_points.clear()
|
|
|
|
# Force an update of the grid visualization
|
|
if enhanced_gridmap:
|
|
enhanced_gridmap._update_cell_option_buttons()
|
|
|
|
func _find_random_spawn_position() -> Vector2i:
|
|
var available_positions = []
|
|
|
|
for spawn_pos in spawn_locations:
|
|
if not is_position_occupied(spawn_pos):
|
|
available_positions.append(spawn_pos)
|
|
|
|
if available_positions.size() > 0:
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
return available_positions[rng.randi() % available_positions.size()]
|
|
|
|
return Vector2i.ZERO
|
|
|
|
func find_random_valid_position_in_range() -> Vector2i:
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
|
|
var valid_positions = []
|
|
|
|
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 pos = Vector2i(x, z)
|
|
if pos != current_position and is_within_movement_range(pos):
|
|
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(x, 0, z))
|
|
if cell_item != -1 and not (cell_item in enhanced_gridmap.non_walkable_items) and not is_position_occupied(pos):
|
|
valid_positions.append(pos)
|
|
|
|
if valid_positions.size() > 0:
|
|
return valid_positions[rng.randi() % valid_positions.size()]
|
|
return current_position
|
|
|
|
func raycast_to_grid(from: Vector3, to: Vector3) -> Vector2i:
|
|
var plane = Plane(Vector3.UP, cell_offset.y)
|
|
var intersection = plane.intersects_ray(from, to - from)
|
|
|
|
if intersection:
|
|
var adjusted_intersection = intersection - cell_offset
|
|
var grid_position = Vector2i(
|
|
floor(adjusted_intersection.x / cell_size.x),
|
|
floor(adjusted_intersection.z / cell_size.z)
|
|
)
|
|
|
|
if grid_position.x >= 0 and grid_position.x < enhanced_gridmap.columns and \
|
|
grid_position.y >= 0 and grid_position.y < enhanced_gridmap.rows:
|
|
return grid_position
|
|
|
|
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
|
|
|
|
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")
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func start_movement_along_path(path: Array, clear_visual: bool = true):
|
|
is_player_moving = true
|
|
var tween = create_tween()
|
|
tween.set_trans(Tween.TRANS_CUBIC)
|
|
tween.set_ease(Tween.EASE_IN_OUT)
|
|
|
|
for point in path:
|
|
tween.tween_property(self, "position", grid_to_world(Vector2i(point.x, point.y)), 0.5)
|
|
|
|
tween.tween_callback(func():
|
|
current_position = Vector2i(path[-1].x, path[-1].y)
|
|
is_player_moving = false
|
|
|
|
# Check if we've reached the finish line
|
|
if current_position in finish_locations and can_finish:
|
|
finish_race()
|
|
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
|
|
# Only clear visuals if this is a human player
|
|
if not (is_bot or is_in_group("Bots")):
|
|
if clear_visual:
|
|
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:
|
|
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)
|
|
|
|
if main and main.turn_based_mode:
|
|
end_turn()
|
|
_after_action_completed()
|
|
)
|
|
|
|
#func trigger_finish_line():
|
|
#if not is_multiplayer_authority():
|
|
#return
|
|
#
|
|
#if current_lap == 0: # 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)
|
|
#rpc("display_message", message)
|
|
#print("DEBUG: Triggered first lap finish. Position: ", race_position)
|
|
#
|
|
## Start second lap
|
|
#current_lap += 1
|
|
#rpc("start_new_lap")
|
|
#
|
|
#elif current_lap == 1: # 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)
|
|
#rpc("display_message", message)
|
|
#print("DEBUG: Triggered second lap finish. Position: ", race_position)
|
|
#
|
|
##func debug_finish_state():
|
|
##print("DEBUG: Current Position: ", current_position)
|
|
##print("DEBUG: Can Finish: ", can_finish)
|
|
##print("DEBUG: Current Lap: ", current_lap)
|
|
##print("DEBUG: Pattern Match: ", check_pattern_match())
|
|
##print("DEBUG: Is at finish: ", current_position in finish_locations)
|
|
|
|
func update_player_position(grid_position: Vector2i):
|
|
position = grid_to_world(grid_position)
|
|
|
|
func grid_to_world(grid_position: Vector2i) -> Vector3:
|
|
var world_position = Vector3(
|
|
grid_position.x * cell_size.x + cell_size.x * 0.5,
|
|
cell_size.y,
|
|
grid_position.y * cell_size.z + cell_size.z * 0.5
|
|
) + cell_offset
|
|
return world_position
|
|
|
|
func start_turn():
|
|
action_points = 2
|
|
has_moved_this_turn = false
|
|
has_performed_action = false
|
|
is_my_turn = true
|
|
if is_multiplayer_authority():
|
|
rpc("display_message", "It's your turn!")
|
|
_after_action_completed()
|
|
|
|
func end_turn():
|
|
is_my_turn = false
|
|
has_moved_this_turn = false
|
|
if is_multiplayer_authority():
|
|
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)
|
|
|
|
# Add a static reset for new games
|
|
static func reset_race_stats():
|
|
lap1_finishers = 0
|
|
lap2_finishers = 0
|
|
|
|
@rpc("any_peer", "call_local", "unreliable")
|
|
func remote_set_position(authority_position):
|
|
global_position = authority_position
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func display_message(message):
|
|
$Bubble.show()
|
|
$Bubble/Message.show()
|
|
$Bubble/Message.text = str(message)
|
|
await get_tree().create_timer(3).timeout
|
|
$Bubble.hide()
|
|
$Bubble/Message.hide()
|
|
|
|
func initialize_random_goals(_size:int, min_value:int, max_value:int, null_count:float) -> Array[int]:
|
|
goals.clear()
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
|
|
var result : Array[int] = []
|
|
var null_val = 0
|
|
var max_nulls = 3
|
|
|
|
const SPECIAL_VALUES = {1: 7, 2: 8, 3: 9, 4: 10}
|
|
|
|
for i in range(_size):
|
|
if null_val < max_nulls and rng.randf() < null_count:
|
|
result.append(-1)
|
|
null_val += 1
|
|
else:
|
|
var val = rng.randi_range(min_value, max_value)
|
|
result.append(val if not val in SPECIAL_VALUES else SPECIAL_VALUES[val])
|
|
|
|
return result
|
|
|
|
# Remove this since goals are now set by main.gd
|
|
func append_random_goals():
|
|
goals.append_array(initialize_random_goals(9, 7, 10, 1.0))
|
|
|
|
if is_multiplayer_authority():
|
|
rpc("sync_goals", goals)
|
|
|
|
func bot_try_grab_item() -> bool:
|
|
if not enhanced_gridmap or action_points <= 0:
|
|
return false
|
|
|
|
# First check current position
|
|
var current_cell = Vector3i(current_position.x, 1, current_position.y)
|
|
var item = enhanced_gridmap.get_cell_item(current_cell)
|
|
|
|
if item != -1:
|
|
var empty_slot = playerboard.find(-1)
|
|
if empty_slot != -1:
|
|
if is_multiplayer_authority():
|
|
playerboard[empty_slot] = item
|
|
rpc("sync_grid_item", current_cell.x, current_cell.y, current_cell.z, -1)
|
|
rpc("sync_playerboard", playerboard)
|
|
has_performed_action = true
|
|
action_points -= 1
|
|
return true
|
|
|
|
# Check adjacent cells if nothing at current position
|
|
var neighbors = enhanced_gridmap.get_neighbors(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 = playerboard.find(-1)
|
|
if empty_slot != -1:
|
|
if is_multiplayer_authority():
|
|
playerboard[empty_slot] = item
|
|
rpc("sync_grid_item", cell.x, cell.y, cell.z, -1)
|
|
rpc("sync_playerboard", playerboard)
|
|
has_performed_action = true
|
|
action_points -= 1
|
|
return true
|
|
|
|
return false
|
|
|
|
func grab_item(grid_position: Vector2i = current_position) -> bool:
|
|
if is_bot:
|
|
return bot_try_grab_item()
|
|
|
|
if not enhanced_gridmap or action_points <= 0:
|
|
return false
|
|
|
|
var cell = Vector3i(grid_position.x, 1, grid_position.y)
|
|
var item = enhanced_gridmap.get_cell_item(cell)
|
|
|
|
if grid_position != current_position:
|
|
var neighbors = enhanced_gridmap.get_neighbors(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
|
|
|
|
# Bot-specific grab logic moved to bot_grab_item RPC
|
|
if is_in_group("Bots") or is_bot:
|
|
var empty_slot = playerboard.find(-1)
|
|
if empty_slot == -1:
|
|
return false
|
|
|
|
if is_multiplayer_authority():
|
|
rpc("bot_grab_item", grid_position, empty_slot, cell.x, cell.y, cell.z)
|
|
return true
|
|
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
selected_gridmap_position = grid_position
|
|
clear_highlights()
|
|
clear_playerboard_highlights()
|
|
|
|
for i in range(playerboard.size()):
|
|
if playerboard[i] == -1:
|
|
var slot = main.playerboard_ui.get_child(i)
|
|
if slot.get_child_count() > 0:
|
|
slot.get_child(0).show()
|
|
highlighted_cells.append(i)
|
|
return true
|
|
|
|
return false
|
|
|
|
func put_item(grid_position: Vector2i = current_position) -> bool:
|
|
if not enhanced_gridmap or action_points <= 0 or selected_playerboard_slot == -1:
|
|
return false
|
|
|
|
var cell = Vector3i(grid_position.x, 1, grid_position.y)
|
|
if enhanced_gridmap.get_cell_item(cell) != -1:
|
|
return false
|
|
|
|
# Check if position is adjacent or current position
|
|
if grid_position != current_position:
|
|
var is_adjacent = false
|
|
var neighbors = enhanced_gridmap.get_neighbors(current_position, 0)
|
|
for neighbor in neighbors:
|
|
if neighbor.position == grid_position:
|
|
is_adjacent = true
|
|
break
|
|
if not is_adjacent:
|
|
return false
|
|
|
|
# Get the item to place first
|
|
var item = playerboard[selected_playerboard_slot]
|
|
|
|
# For clients, we need to RPC to the server first, then let the server RPC back
|
|
if is_multiplayer_authority() and not multiplayer.is_server():
|
|
# Client requests server to perform the put operation
|
|
rpc_id(1, "request_server_put", grid_position, selected_playerboard_slot, cell.x, cell.y, cell.z, item)
|
|
|
|
# We'll return true and let the server handle the actual operation
|
|
# The server will RPC back to update our state if successful
|
|
return true
|
|
elif is_multiplayer_authority() and multiplayer.is_server():
|
|
# Server directly implements the change
|
|
rpc("sync_grid_item", cell.x, cell.y, cell.z, item)
|
|
playerboard[selected_playerboard_slot] = -1
|
|
rpc("sync_playerboard", playerboard)
|
|
|
|
has_performed_action = true
|
|
consume_action_points(1)
|
|
if not is_bot == true:
|
|
clear_highlights()
|
|
clear_playerboard_highlights()
|
|
selected_playerboard_slot = -1
|
|
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
main.set_action_state(main.ActionState.NONE)
|
|
_after_action_completed()
|
|
return true
|
|
|
|
return false
|
|
|
|
@rpc("any_peer", "reliable")
|
|
func request_server_put(grid_position: Vector2i, slot_index: int, x: int, y: int, z: int, item: int):
|
|
# This RPC should only be processed by the server
|
|
if not multiplayer.is_server():
|
|
return
|
|
|
|
# Verify that this request came from the authority of this player
|
|
if multiplayer.get_remote_sender_id() != get_multiplayer_authority():
|
|
push_error("Security: Non-authority tried to put item!")
|
|
return
|
|
|
|
# Server-side validation
|
|
var cell = Vector3i(x, y, z)
|
|
if enhanced_gridmap.get_cell_item(cell) != -1:
|
|
return # Cell not empty
|
|
|
|
# Check if position is adjacent or current position
|
|
if grid_position != current_position:
|
|
var is_adjacent = false
|
|
var neighbors = enhanced_gridmap.get_neighbors(current_position, 0)
|
|
for neighbor in neighbors:
|
|
if neighbor.position == grid_position:
|
|
is_adjacent = true
|
|
break
|
|
if not is_adjacent:
|
|
return # Not adjacent
|
|
|
|
# Verify player has the item
|
|
if playerboard[slot_index] != item:
|
|
push_error("Item mismatch! Player doesn't have claimed item")
|
|
return
|
|
|
|
# Perform the put operation as the server
|
|
rpc("sync_grid_item", x, y, z, item)
|
|
playerboard[slot_index] = -1
|
|
rpc("sync_playerboard", playerboard)
|
|
|
|
# Update player state
|
|
has_performed_action = true
|
|
action_points -= 1
|
|
selected_playerboard_slot = -1
|
|
|
|
# Notify about action completion
|
|
_after_action_completed()
|
|
|
|
# Add new RPC function to notify others about spawn selection
|
|
@rpc("any_peer", "reliable")
|
|
func notify_spawn_selected(spawn_pos: Vector2i):
|
|
# Update local highlight state for all clients
|
|
if spawn_pos in highlighted_spawn_points:
|
|
highlighted_spawn_points.erase(spawn_pos)
|
|
|
|
# Clear highlight for the selected position
|
|
if enhanced_gridmap:
|
|
enhanced_gridmap.set_cell_item(
|
|
Vector3i(spawn_pos.x, 0, spawn_pos.y),
|
|
enhanced_gridmap.normal_items[0]
|
|
)
|
|
|
|
|
|
|
|
func handle_put_action():
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
if not main or action_points < 1:
|
|
return
|
|
|
|
if not is_bot == true:
|
|
clear_highlights()
|
|
clear_playerboard_highlights()
|
|
|
|
# Highlight non-empty slots in playerboard
|
|
for i in range(playerboard.size()):
|
|
if playerboard[i] != -1: # Highlight occupied slots
|
|
var slot = main.playerboard_ui.get_child(i)
|
|
if slot.get_child_count() > 0:
|
|
slot.get_child(0).show() # Show highlight for occupied slots
|
|
highlighted_cells.append(i)
|
|
|
|
func handle_playerboard_slot_selected(slot_index: int):
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
if not main:
|
|
return
|
|
|
|
if main.current_action_state == main.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:
|
|
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)
|
|
|
|
if item != -1:
|
|
if is_multiplayer_authority():
|
|
playerboard[slot_index] = item
|
|
rpc("sync_grid_item", cell.x, cell.y, cell.z, -1)
|
|
rpc("sync_playerboard", playerboard)
|
|
|
|
has_performed_action = true
|
|
consume_action_points(1)
|
|
if not is_bot == true:
|
|
clear_highlights()
|
|
clear_playerboard_highlights()
|
|
selected_gridmap_position = Vector2i(-1, -1)
|
|
main.set_action_state(main.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:
|
|
return
|
|
|
|
print("PUT slot selected: ", slot_index, ", item: ", playerboard[slot_index])
|
|
|
|
if slot_index in highlighted_cells and playerboard[slot_index] in goals:
|
|
selected_playerboard_slot = slot_index
|
|
clear_highlights()
|
|
if not is_bot == true:
|
|
highlight_empty_adjacent_cells()
|
|
|
|
if playerboard[slot_index] != -1: # If slot has an item
|
|
selected_playerboard_slot = slot_index
|
|
|
|
# Visual feedback of selection
|
|
clear_highlights()
|
|
|
|
# Highlight valid put locations
|
|
highlight_empty_adjacent_cells()
|
|
|
|
# Print debug info
|
|
print("Selected slot ", slot_index, " for PUT with item ", playerboard[slot_index])
|
|
print("Highlighted cells: ", highlighted_cells)
|
|
|
|
|
|
func arrange_playerboard_item(slot_index: int):
|
|
if action_points < 2 or playerboard[slot_index] == -1:
|
|
return
|
|
|
|
var selected_item = playerboard[slot_index]
|
|
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:
|
|
return
|
|
|
|
# Store the selected slot
|
|
selected_playerboard_slot = slot_index
|
|
|
|
# Highlight selected slot
|
|
var selected_slot_ui = main.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)
|
|
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)
|
|
if not slot.gui_input.is_connected(_on_slot_clicked):
|
|
slot.gui_input.connect(_on_slot_clicked.bind(i))
|
|
|
|
func _on_slot_clicked(event: InputEvent, slot_index: int):
|
|
if not event is InputEventMouseButton or is_bot == true or not event.pressed or event.button_index != MOUSE_BUTTON_LEFT:
|
|
return
|
|
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
if not main or main.current_action_state != main.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 playerboard[slot_index] == -1:
|
|
# Move item to empty target slot
|
|
var selected_item = playerboard[selected_playerboard_slot]
|
|
playerboard[slot_index] = selected_item
|
|
playerboard[selected_playerboard_slot] = -1
|
|
|
|
if is_multiplayer_authority():
|
|
rpc("sync_playerboard", playerboard)
|
|
consume_action_points(2)
|
|
has_performed_action = true
|
|
|
|
# Clear highlights
|
|
clear_highlights()
|
|
clear_playerboard_highlights()
|
|
|
|
# Reset selection
|
|
selected_playerboard_slot = -1
|
|
|
|
# Update the visual representation
|
|
main.update_playerboard_ui()
|
|
main.set_action_state(main.ActionState.NONE)
|
|
|
|
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 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 has_item_at_current_position() -> bool:
|
|
var current_cell = Vector3i(current_position.x, 1, current_position.y)
|
|
return enhanced_gridmap.get_cell_item(current_cell) != -1
|
|
|
|
func has_items_in_playerboard() -> bool:
|
|
return playerboard.any(func(item): return item != -1)
|
|
|
|
func playerboard_is_full() -> bool:
|
|
return playerboard.find(-1) == -1
|
|
|
|
func highlight_cells_if_authorized(cells_to_highlight: Array):
|
|
if not is_multiplayer_authority() or is_bot or is_in_group("Bots"):
|
|
return
|
|
|
|
clear_highlights()
|
|
for cell in cells_to_highlight:
|
|
highlighted_cells.append(cell)
|
|
enhanced_gridmap.set_cell_item(
|
|
Vector3i(cell.x, 0, cell.y),
|
|
enhanced_gridmap.hover_item
|
|
)
|
|
|
|
# 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
|
|
|
|
# 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)
|
|
|
|
func highlight_empty_adjacent_cells():
|
|
if is_bot == true or is_in_group("Bots"):
|
|
return
|
|
|
|
# Debug print
|
|
print("Highlighting empty adjacent cells. Current position: ", current_position)
|
|
|
|
# Clear previous highlights
|
|
clear_highlights()
|
|
|
|
# Highlight current position if empty
|
|
var current_cell = Vector3i(current_position.x, 1, current_position.y)
|
|
if enhanced_gridmap.get_cell_item(current_cell) == -1:
|
|
highlighted_cells.append(current_position)
|
|
enhanced_gridmap.set_cell_item(Vector3i(current_position.x, 0, current_position.y),
|
|
enhanced_gridmap.hover_item)
|
|
print("Highlighted current position: ", current_position)
|
|
|
|
# Highlight empty adjacent cells
|
|
var neighbors = enhanced_gridmap.get_neighbors(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
|
|
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)
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func sync_action_points(points: int):
|
|
action_points = points
|
|
|
|
func highlight_random_valid_cells():
|
|
if is_bot == true or is_in_group("Bots") or not is_multiplayer_authority():
|
|
return
|
|
|
|
clear_highlights()
|
|
|
|
# First check the current position
|
|
var current_cell = Vector3i(current_position.x, 1, current_position.y)
|
|
var current_item = enhanced_gridmap.get_cell_item(current_cell)
|
|
if current_item != -1:
|
|
highlighted_cells.append(current_position)
|
|
enhanced_gridmap.set_cell_item(Vector3i(current_position.x, 0, current_position.y),
|
|
enhanced_gridmap.hover_item)
|
|
|
|
# Then check all adjacent cells for items
|
|
var neighbors = enhanced_gridmap.get_neighbors(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
|
|
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 is_bot == true or is_in_group("Bots") or not is_multiplayer_authority():
|
|
return
|
|
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
if not main or not main.playerboard_ui:
|
|
return
|
|
|
|
# First reset all slots to normal
|
|
for i in range(playerboard.size()):
|
|
var slot = main.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)
|
|
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()
|
|
|
|
func clear_highlights():
|
|
# Never allow bots to clear highlights for human players
|
|
if is_bot or is_in_group("Bots"):
|
|
return
|
|
|
|
if not enhanced_gridmap or not is_multiplayer_authority():
|
|
return
|
|
|
|
# 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
|
|
|
|
for cell in highlighted_cells:
|
|
if cell is Vector2i:
|
|
enhanced_gridmap.set_cell_item(Vector3i(cell.x, 0, cell.y), enhanced_gridmap.normal_items[0])
|
|
|
|
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)
|
|
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:
|
|
highlight_movement_range()
|
|
|
|
func clear_playerboard_highlights():
|
|
# Never allow bots to clear highlights for human players
|
|
if is_bot or is_in_group("Bots"):
|
|
return
|
|
|
|
if not is_multiplayer_authority():
|
|
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 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()
|
|
|
|
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)
|
|
|
|
# We also need to add these supporting functions:
|
|
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 = 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 = 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()
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func sync_rotation(new_rotation: float):
|
|
if not is_multiplayer_authority():
|
|
rotation.y = new_rotation
|
|
|
|
@rpc("any_peer", "call_local", "reliable")
|
|
func sync_grid_item(x: int, y: int, z: int, item: int):
|
|
if enhanced_gridmap:
|
|
var cell = Vector3i(x, y, z)
|
|
|
|
# Log the change for debugging
|
|
print("Setting grid item at ", cell, " to ", item, " (called by ", multiplayer.get_remote_sender_id(), ")")
|
|
|
|
# Make sure we set the cell reliably
|
|
enhanced_gridmap.set_cell_item(cell, item)
|
|
|
|
# Double-check the cell was set
|
|
var check_value = enhanced_gridmap.get_cell_item(cell)
|
|
if check_value != item:
|
|
push_warning("Cell item didn't update correctly! Expected " + str(item) + " but got " + str(check_value))
|
|
# Try once more
|
|
enhanced_gridmap.set_cell_item(cell, item)
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func sync_goals(new_goals: Array):
|
|
goals = new_goals.duplicate() # Make sure to duplicate the array
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func sync_playerboard(new_playerboard: Array):
|
|
playerboard = new_playerboard.duplicate()
|
|
var main = get_tree().get_root().get_node_or_null("Main")
|
|
if main:
|
|
main.rpc("sync_playerboard", get_multiplayer_authority(), playerboard)
|
|
_after_action_completed()
|
|
|
|
func _after_action_completed():
|
|
# Guard against recursive calls
|
|
if _is_processing_action:
|
|
return
|
|
_is_processing_action = true
|
|
|
|
if is_multiplayer_authority():
|
|
update_finish_availability()
|
|
|
|
# Clear the highlights after placing the tiles. (Quickfix for Clientside)
|
|
clear_highlights()
|
|
|
|
if multiplayer.get_unique_id() == get_multiplayer_authority():
|
|
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):
|
|
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()
|
|
|
|
# Add this line to sync all boards
|
|
main.update_all_players_boards()
|
|
|
|
# Add sync for playerboard
|
|
if is_multiplayer_authority():
|
|
main.rpc("sync_playerboard", get_multiplayer_authority(), playerboard)
|
|
|
|
_is_processing_action = false
|
|
|
|
func is_finish_position(pos: Vector2i) -> bool:
|
|
return pos in finish_locations
|
|
|
|
func consume_action_points(points: int):
|
|
if not is_instance_valid(self) or not is_multiplayer_authority():
|
|
return
|
|
|
|
var main = 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 is_bot == true and not main.turn_based_mode:
|
|
_after_action_completed()
|
|
return
|
|
|
|
action_points -= points
|
|
|
|
if action_points <= 0:
|
|
if main.turn_based_mode:
|
|
main.request_next_turn()
|
|
else:
|
|
action_points = 2
|
|
has_performed_action = false
|
|
has_moved_this_turn = false
|
|
rpc("display_message", "Action Points Reset!")
|
|
|
|
_after_action_completed()
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func bot_grab_item(pos: Vector2i, slot: int, x: int, y: int, z: int):
|
|
if not (is_bot or is_in_group("Bots")):
|
|
return
|
|
|
|
var cell = Vector3i(x, y, z)
|
|
var item = enhanced_gridmap.get_cell_item(cell)
|
|
|
|
if item != -1:
|
|
playerboard[slot] = item
|
|
enhanced_gridmap.set_cell_item(cell, -1)
|
|
has_performed_action = true
|
|
action_points -= 1
|
|
_after_action_completed()
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func bot_put_item(pos: Vector2i, slot: int, x: int, y: int, z: int):
|
|
if not (is_bot or is_in_group("Bots")):
|
|
return
|
|
|
|
var cell = Vector3i(x, y, z)
|
|
var item = playerboard[slot]
|
|
|
|
if enhanced_gridmap.get_cell_item(cell) == -1:
|
|
enhanced_gridmap.set_cell_item(cell, item)
|
|
playerboard[slot] = -1
|
|
has_performed_action = true
|
|
action_points -= 1
|
|
_after_action_completed()
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func bot_arrange_item(from_slot: int, to_slot: int):
|
|
if not (is_bot or is_in_group("Bots")) or action_points < 2:
|
|
return
|
|
|
|
if playerboard[from_slot] != -1 and playerboard[to_slot] == -1:
|
|
var temp = playerboard[from_slot]
|
|
playerboard[from_slot] = -1
|
|
playerboard[to_slot] = temp
|
|
has_performed_action = true
|
|
action_points -= 2
|
|
_after_action_completed()
|
|
|
|
func update_visual_position():
|
|
# Ensure proper grid-aligned positioning
|
|
global_position = Vector3(
|
|
current_position.x * cell_size.x + cell_size.x * 0.5,
|
|
1.0,
|
|
current_position.y * cell_size.z + cell_size.z * 0.5
|
|
)
|
|
if is_multiplayer_authority():
|
|
rpc("sync_position", current_position)
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func sync_position(pos: Vector2i):
|
|
current_position = pos
|
|
# Always update the visual position after position sync
|
|
global_position = Vector3(
|
|
current_position.x * cell_size.x + cell_size.x * 0.5,
|
|
cell_size.y,
|
|
current_position.y * cell_size.z + cell_size.z * 0.5
|
|
) + cell_offset
|
|
|
|
func highlight_valid_obstacle_cells():
|
|
if not is_multiplayer_authority() or is_bot or 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 player in get_tree().get_nodes_in_group("Players"):
|
|
if player.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)
|