621 lines
18 KiB
GDScript
621 lines
18 KiB
GDScript
extends Node3D
|
|
|
|
@export var enhanced_gridmap_path: NodePath = "/root/Main/EnhancedGridMap"
|
|
var enhanced_gridmap: EnhancedGridMap
|
|
@export var current_position: Vector2i
|
|
var is_player_moving: bool = false
|
|
|
|
@export var cell_size: Vector3 = Vector3(2, 2, 2)
|
|
@export var cell_offset: Vector3 = Vector3(0, 0, 0)
|
|
|
|
@export var center_x: bool = false
|
|
@export var center_y: bool = false
|
|
@export var center_z: bool = false
|
|
|
|
# Goals & Playerboard Data
|
|
@export var goals: Array[int] = [0,0,0,0,0,0,0,0,0] # 9 length array for goals
|
|
@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] # 25 length array for holding items
|
|
var has_performed_action: bool = false # Track if grab/put action has been done
|
|
|
|
# Player Rotation Config
|
|
var target_rotation: float = 0.0
|
|
var rotation_speed: float = 10.0 # Adjust this to control rotation speed
|
|
|
|
@export var movement_range: int = 1 # How many blocks can be moved at once
|
|
@export var use_diagonal_movement: bool = false: # Allow diagonal movement
|
|
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
|
|
@onready var main_scene = get_tree().current_scene
|
|
|
|
var highlighted_cells = []
|
|
|
|
func _ready():
|
|
name = str(get_multiplayer_authority())
|
|
$Name.text = str(name)
|
|
|
|
enhanced_gridmap = get_node(enhanced_gridmap_path)
|
|
|
|
if main_scene:
|
|
enhanced_gridmap = main_scene.get_node("EnhancedGridMap")
|
|
else:
|
|
push_error("Main scene not found")
|
|
|
|
if not enhanced_gridmap:
|
|
push_error("EnhancedGridMap node not found. Please set the correct path in the inspector.")
|
|
return
|
|
|
|
enhanced_gridmap.initialize_astar()
|
|
enhanced_gridmap.set_diagonal_movement(use_diagonal_movement)
|
|
|
|
current_position = find_valid_starting_position()
|
|
update_player_position(current_position)
|
|
|
|
# Only set up input processing if this is not a bot
|
|
if not is_in_group("Bots"):
|
|
set_process_unhandled_input(is_multiplayer_authority())
|
|
|
|
# Initialize random goals
|
|
initialize_random_goals()
|
|
|
|
# Initialize playerboard with -1 (empty slots)
|
|
playerboard.resize(25)
|
|
playerboard.fill(-1)
|
|
|
|
func _physics_process(_delta):
|
|
if is_multiplayer_authority():
|
|
rpc("remote_set_position", global_position)
|
|
|
|
func _process(_delta):
|
|
# Skip processing for bots
|
|
if is_in_group("Bots"):
|
|
return
|
|
|
|
if is_multiplayer_authority():
|
|
if Input.is_action_just_pressed("grab_item"):
|
|
if grab_item():
|
|
rpc("display_message", "Item grabbed!")
|
|
elif Input.is_action_just_pressed("put_item"):
|
|
if put_item():
|
|
rpc("display_message", "Item placed!")
|
|
|
|
func _unhandled_input(event):
|
|
# First check if this is a bot
|
|
if is_in_group("Bots"):
|
|
return
|
|
|
|
var main = get_node("/root/Main")
|
|
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:
|
|
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 handle_grid_click(grid_position: Vector2i):
|
|
var main = get_node("/root/Main")
|
|
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:
|
|
grab_item_at_position(grid_position)
|
|
main.ActionState.PUTTING:
|
|
if grid_position in highlighted_cells:
|
|
put_item_at_position(grid_position)
|
|
main.ActionState.RANDOMIZING:
|
|
if grid_position in highlighted_cells:
|
|
randomize_item_at_position(grid_position)
|
|
|
|
func find_valid_starting_position() -> Vector2i:
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
|
|
var max_attempts = 100
|
|
var attempts = 0
|
|
|
|
while attempts < max_attempts:
|
|
current_position = Vector2i(0, rng.randi_range(0, 9))
|
|
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(current_position.x, 0, current_position.y))
|
|
|
|
if cell_item not in enhanced_gridmap.non_walkable_items:
|
|
return current_position
|
|
|
|
attempts += 1
|
|
|
|
return Vector2i(0, 0)
|
|
|
|
func find_random_valid_position_in_range() -> Vector2i:
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
|
|
var max_attempts = 100
|
|
var attempts = 0
|
|
|
|
while attempts < max_attempts:
|
|
var range_x = min(enhanced_gridmap.columns - 1, movement_range)
|
|
var range_y = min(enhanced_gridmap.rows - 1, movement_range)
|
|
|
|
var offset_x = rng.randi_range(-range_x, range_x)
|
|
var offset_y = rng.randi_range(-range_y, range_y)
|
|
|
|
var random_position = Vector2i(
|
|
clamp(current_position.x + offset_x, 0, enhanced_gridmap.columns - 1),
|
|
clamp(current_position.y + offset_y, 0, enhanced_gridmap.rows - 1)
|
|
)
|
|
|
|
if not is_within_movement_range(random_position):
|
|
attempts += 1
|
|
continue
|
|
|
|
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(random_position.x, 0, random_position.y))
|
|
|
|
if cell_item not in enhanced_gridmap.non_walkable_items and random_position != current_position:
|
|
return random_position
|
|
|
|
attempts += 1
|
|
|
|
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 = 0
|
|
if use_diagonal_movement:
|
|
# For diagonal movement, use max of x and y differences
|
|
distance = max(abs(target_position.x - current_position.x),
|
|
abs(target_position.y - current_position.y))
|
|
else:
|
|
# For orthogonal movement, use Manhattan distance
|
|
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():
|
|
return
|
|
|
|
if is_player_moving:
|
|
return
|
|
|
|
var main = get_node("/root/Main")
|
|
|
|
# Check if we're in the correct action state
|
|
if main.current_action_state != main.ActionState.MOVING:
|
|
return
|
|
|
|
# Validate the clicked position is highlighted
|
|
if not grid_position in highlighted_cells:
|
|
return
|
|
|
|
# Check if movement is valid
|
|
if not is_within_movement_range(grid_position):
|
|
print("Movement out of range")
|
|
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:
|
|
print("Cannot move to non-walkable cell")
|
|
return
|
|
|
|
rotate_towards_target(grid_position)
|
|
|
|
var path = enhanced_gridmap.find_path(Vector2(current_position), Vector2(grid_position))
|
|
|
|
if path.size() > 1:
|
|
path.pop_front()
|
|
rpc("start_movement_along_path", path)
|
|
clear_highlights() # Clear highlights after movement starts
|
|
else:
|
|
print("No valid path found")
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func start_movement_along_path(path: Array):
|
|
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:
|
|
var target_position = grid_to_world(Vector2i(point.x, point.y))
|
|
tween.tween_property(self, "position", target_position, 0.5)
|
|
|
|
tween.tween_callback(func():
|
|
current_position = Vector2i(path[-1].x, path[-1].y)
|
|
is_player_moving = false
|
|
enhanced_gridmap.clear_path_visualization()
|
|
has_moved_this_turn = true
|
|
var main = get_node("/root/Main")
|
|
|
|
# Reset the action state
|
|
main.set_action_state(main.ActionState.NONE)
|
|
|
|
if main.turn_based_mode:
|
|
end_turn()
|
|
_after_action_completed()
|
|
)
|
|
|
|
func move_bot_along_path(path: Array, bot_id: int):
|
|
if not is_multiplayer_authority():
|
|
return
|
|
|
|
rpc("start_bot_movement_along_path", path, bot_id)
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func start_bot_movement_along_path(path: Array, bot_id: int):
|
|
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:
|
|
var target_position = grid_to_world(Vector2i(point.x, point.y))
|
|
tween.tween_property(self, "position", target_position, 0.5)
|
|
|
|
tween.tween_callback(func():
|
|
current_position = Vector2i(path[-1].x, path[-1].y)
|
|
is_player_moving = false
|
|
enhanced_gridmap.clear_path_visualization()
|
|
has_moved_this_turn = true
|
|
var main = get_node("/root/Main")
|
|
if main.turn_based_mode:
|
|
end_turn()
|
|
# Notify main that bot movement is complete
|
|
if multiplayer.is_server():
|
|
main.bot_movement_completed(bot_id)
|
|
)
|
|
|
|
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.y,
|
|
grid_position.y * cell_size.z
|
|
)
|
|
|
|
world_position.x += cell_size.x * 0.5
|
|
world_position.z += cell_size.z * 0.5
|
|
|
|
if center_x:
|
|
world_position.x += cell_size.x * 0.5
|
|
if center_y:
|
|
world_position.y += cell_size.y * 0.5
|
|
if center_z:
|
|
world_position.z += cell_size.z * 0.5
|
|
|
|
return world_position + cell_offset
|
|
|
|
func start_turn():
|
|
has_moved_this_turn = false
|
|
has_performed_action = false # Reset action flag at start of turn
|
|
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_node("/root/Main").request_next_turn()
|
|
|
|
@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():
|
|
goals.clear()
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
|
|
for i in range(9):
|
|
goals.append(rng.randi_range(7, 10))
|
|
|
|
if is_multiplayer_authority():
|
|
rpc("sync_goals", goals)
|
|
|
|
func grab_item() -> bool:
|
|
if not enhanced_gridmap:
|
|
return false
|
|
|
|
var current_cell = Vector3i(current_position.x, 1, current_position.y)
|
|
var item = enhanced_gridmap.get_cell_item(current_cell)
|
|
|
|
if item == -1: # No item to grab
|
|
return false
|
|
|
|
var empty_slot = playerboard.find(-1)
|
|
if empty_slot == -1: # No empty slots
|
|
return false
|
|
|
|
playerboard[empty_slot] = item
|
|
enhanced_gridmap.set_cell_item(current_cell, -1)
|
|
|
|
if is_multiplayer_authority():
|
|
rpc("sync_playerboard", playerboard)
|
|
|
|
has_performed_action = true # Set action flag
|
|
_after_action_completed()
|
|
return true
|
|
|
|
func grab_item_at_position(grid_position: Vector2i) -> bool:
|
|
var main = get_node("/root/Main")
|
|
if main.current_action_state != main.ActionState.GRABBING:
|
|
return false
|
|
|
|
var cell = Vector3i(grid_position.x, 1, grid_position.y)
|
|
var item = enhanced_gridmap.get_cell_item(cell)
|
|
|
|
if item == -1:
|
|
return false
|
|
|
|
var empty_slot = playerboard.find(-1)
|
|
if empty_slot == -1:
|
|
return false
|
|
|
|
playerboard[empty_slot] = item
|
|
enhanced_gridmap.set_cell_item(cell, -1)
|
|
|
|
if is_multiplayer_authority():
|
|
rpc("sync_playerboard", playerboard)
|
|
|
|
has_performed_action = true
|
|
clear_highlights()
|
|
main.set_action_state(main.ActionState.MOVING) # Automatically switch to movement state
|
|
_after_action_completed()
|
|
return true
|
|
|
|
|
|
func put_item() -> bool:
|
|
if not enhanced_gridmap:
|
|
return false
|
|
|
|
var current_cell = Vector3i(current_position.x, 1, current_position.y)
|
|
if enhanced_gridmap.get_cell_item(current_cell) != -1:
|
|
return false # Cell is occupied
|
|
|
|
var item_to_put = -1
|
|
var item_index = -1
|
|
|
|
for goal in goals:
|
|
var index = playerboard.find(goal)
|
|
if index != -1:
|
|
item_to_put = goal
|
|
item_index = index
|
|
break
|
|
|
|
if item_to_put == -1:
|
|
return false
|
|
|
|
enhanced_gridmap.set_cell_item(current_cell, item_to_put)
|
|
playerboard[item_index] = -1
|
|
|
|
if is_multiplayer_authority():
|
|
rpc("sync_playerboard", playerboard)
|
|
|
|
has_performed_action = true # Set action flag
|
|
_after_action_completed()
|
|
return true
|
|
|
|
func put_item_at_position(grid_position: Vector2i) -> bool:
|
|
var main = get_node("/root/Main")
|
|
if main.current_action_state != main.ActionState.PUTTING:
|
|
return false
|
|
|
|
var cell = Vector3i(grid_position.x, 1, grid_position.y)
|
|
if enhanced_gridmap.get_cell_item(cell) != -1:
|
|
return false
|
|
|
|
var item_to_put = -1
|
|
var item_index = -1
|
|
|
|
for goal in goals:
|
|
var index = playerboard.find(goal)
|
|
if index != -1:
|
|
item_to_put = goal
|
|
item_index = index
|
|
break
|
|
|
|
if item_to_put == -1:
|
|
return false
|
|
|
|
enhanced_gridmap.set_cell_item(cell, item_to_put)
|
|
playerboard[item_index] = -1
|
|
|
|
if is_multiplayer_authority():
|
|
rpc("sync_playerboard", playerboard)
|
|
|
|
has_performed_action = true
|
|
clear_highlights()
|
|
main.set_action_state(main.ActionState.MOVING) # Automatically switch to movement state
|
|
_after_action_completed()
|
|
return true
|
|
|
|
func randomize_item_at_position(grid_position: Vector2i) -> bool:
|
|
var main = get_node("/root/Main")
|
|
if main.current_action_state != main.ActionState.RANDOMIZING:
|
|
return false
|
|
|
|
var cell = Vector3i(grid_position.x, 1, grid_position.y)
|
|
if enhanced_gridmap.get_cell_item(cell) != -1:
|
|
return false
|
|
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
|
|
# Assuming items are numbered 1-10
|
|
var random_item = rng.randi_range(7, 10)
|
|
enhanced_gridmap.set_cell_item(cell, random_item)
|
|
|
|
has_performed_action = true
|
|
clear_highlights()
|
|
main.set_action_state(main.ActionState.MOVING) # Automatically switch to movement state
|
|
_after_action_completed()
|
|
return true
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func sync_goals(new_goals: Array):
|
|
goals = new_goals
|
|
|
|
@rpc("any_peer", "call_local")
|
|
func sync_playerboard(new_playerboard: Array):
|
|
playerboard = new_playerboard
|
|
_after_action_completed()
|
|
|
|
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)
|
|
|
|
# Create a tween for smooth rotation
|
|
var tween = create_tween()
|
|
tween.tween_property(self, "rotation:y", target_rotation, 0.2)
|
|
|
|
func _after_action_completed():
|
|
if multiplayer.get_unique_id() == get_multiplayer_authority():
|
|
var main = get_node("/root/Main")
|
|
main.update_button_states()
|
|
main.update_playerboard_ui()
|
|
|
|
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 highlight_movement_range():
|
|
var cells_to_highlight = []
|
|
for x in range(enhanced_gridmap.columns):
|
|
for z in range(enhanced_gridmap.rows):
|
|
var test_pos = Vector2i(x, z)
|
|
if is_within_movement_range(test_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):
|
|
cells_to_highlight.append(test_pos)
|
|
|
|
for cell in cells_to_highlight:
|
|
highlighted_cells.append(cell)
|
|
# Store original item for restoration
|
|
var original_item = enhanced_gridmap.get_cell_item(Vector3i(cell.x, 0, cell.y))
|
|
enhanced_gridmap.set_cell_item(Vector3i(cell.x, 0, cell.y), enhanced_gridmap.hover_item)
|
|
|
|
func highlight_adjacent_cells():
|
|
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:
|
|
highlighted_cells.append(cell_pos)
|
|
enhanced_gridmap.set_cell_item(Vector3i(cell_pos.x, 0, cell_pos.y), enhanced_gridmap.hover_item)
|
|
|
|
func 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
|
|
if enhanced_gridmap.get_cell_item(Vector3i(cell_pos.x, 1, cell_pos.y)) == -1:
|
|
highlighted_cells.append(cell_pos)
|
|
enhanced_gridmap.set_cell_item(Vector3i(cell_pos.x, 0, cell_pos.y), enhanced_gridmap.hover_item)
|
|
|
|
func highlight_random_valid_cells():
|
|
var valid_cells = []
|
|
for x in range(enhanced_gridmap.columns):
|
|
for z in range(enhanced_gridmap.rows):
|
|
var cell_pos = Vector2i(x, z)
|
|
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):
|
|
valid_cells.append(cell_pos)
|
|
|
|
# Highlight random subset of valid cells
|
|
var rng = RandomNumberGenerator.new()
|
|
rng.randomize()
|
|
for _i in range(min(5, valid_cells.size())):
|
|
var index = rng.randi() % valid_cells.size()
|
|
var cell = valid_cells[index]
|
|
highlighted_cells.append(cell)
|
|
enhanced_gridmap.set_cell_item(Vector3i(cell.x, 0, cell.y), enhanced_gridmap.hover_item)
|
|
valid_cells.remove_at(index)
|
|
|
|
func clear_highlights():
|
|
for cell in highlighted_cells:
|
|
# Reset to normal item
|
|
enhanced_gridmap.set_cell_item(Vector3i(cell.x, 0, cell.y), enhanced_gridmap.normal_items[0])
|
|
highlighted_cells.clear()
|
|
|
|
func arrange_playerboard_item(slot_index: int):
|
|
if playerboard[slot_index] == -1:
|
|
return
|
|
|
|
# Store the selected slot for arrangement
|
|
var temp_item = playerboard[slot_index]
|
|
playerboard[slot_index] = -1
|
|
|
|
# Wait for second click to complete arrangement
|
|
await get_tree().create_timer(0.1).timeout
|
|
|
|
var target_slot = await wait_for_playerboard_click()
|
|
if target_slot != -1:
|
|
var swap_item = playerboard[target_slot]
|
|
playerboard[target_slot] = temp_item
|
|
playerboard[slot_index] = swap_item
|
|
|
|
if multiplayer.is_server():
|
|
rpc("sync_playerboard", playerboard)
|
|
|
|
func wait_for_playerboard_click() -> int:
|
|
var main = get_node("/root/Main")
|
|
while true:
|
|
var event = await main.playerboard_ui.gui_input
|
|
if event is InputEventMouseButton and event.pressed and event.button_index == MOUSE_BUTTON_LEFT:
|
|
var local_pos = main.playerboard_ui.get_local_mouse_position()
|
|
for i in range(25):
|
|
var slot = main.playerboard_ui.get_child(i)
|
|
if slot.get_global_rect().has_point(event.global_position):
|
|
return i
|
|
return -1
|