test

scenes/player.gd

@@ -18,7 +18,6 @@ var is_player_moving: bool = false
 var has_performed_action: bool = false # Track if grab/put action has been done
 
 # Player Rotation Config
-# Add these variables for rotation
 var target_rotation: float = 0.0
 var rotation_speed: float = 10.0  # Adjust this to control rotation speed
 
@@ -37,6 +36,8 @@ var rotation_speed: float = 10.0  # Adjust this to control rotation speed
 @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)
@@ -58,7 +59,9 @@ func _ready():
 	current_position = find_valid_starting_position()
 	update_player_position(current_position)
 	
-	set_process_unhandled_input(is_multiplayer_authority())
+	# 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()
@@ -67,6 +70,57 @@ func _ready():
 	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()
@@ -96,7 +150,6 @@ func find_random_valid_position_in_range() -> Vector2i:
 		var range_x = min(enhanced_gridmap.columns - 1, movement_range)
 		var range_y = min(enhanced_gridmap.rows - 1, movement_range)
 		
-		# Generate position within movement range of current position
 		var offset_x = rng.randi_range(-range_x, range_x)
 		var offset_y = rng.randi_range(-range_y, range_y)
 		
@@ -105,7 +158,6 @@ func find_random_valid_position_in_range() -> Vector2i:
 			clamp(current_position.y + offset_y, 0, enhanced_gridmap.rows - 1)
 		)
 		
-		# Check if the position is within movement range
 		if not is_within_movement_range(random_position):
 			attempts += 1
 			continue
@@ -119,34 +171,6 @@ func find_random_valid_position_in_range() -> Vector2i:
 	
 	return current_position
 
-func _physics_process(_delta):
-	if is_multiplayer_authority():
-		rpc("remote_set_position", global_position)
-
-# Add this to your _process function if you don't have one
-func _process(delta):
-	if is_multiplayer_authority():
-		if Input.is_action_just_pressed("grab_item"):  # Define this input in project settings
-			if grab_item():
-				rpc("display_message", "Item grabbed!")
-		elif Input.is_action_just_pressed("put_item"):  # Define this input in project settings
-			if put_item():
-				rpc("display_message", "Item placed!")
-
-func _unhandled_input(event):
-	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):
-			move_player_to_clicked_position(click_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)
@@ -176,44 +200,24 @@ func is_within_movement_range(target_position: Vector2i) -> bool:
 				  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
-		#
-	## Check if the movement is within range
-	#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
-	#
-	#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)
-	#else:
-		#print("No valid path found")
-
 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 player has performed grab/put action
-	if not has_performed_action and current_position != grid_position:
-		rpc("display_message", "Must grab or place item before moving!")
+	# 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
@@ -231,6 +235,7 @@ func move_player_to_clicked_position(grid_position: Vector2i):
 	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")
 
@@ -248,15 +253,18 @@ func start_movement_along_path(path: Array):
 	tween.tween_callback(func():
 		current_position = Vector2i(path[-1].x, path[-1].y)
 		is_player_moving = false
-		has_performed_action = false  # Reset the action flag after movement
 		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
@@ -315,6 +323,7 @@ func start_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
@@ -367,8 +376,37 @@ func grab_item() -> bool:
 		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
@@ -397,6 +435,63 @@ func put_item() -> bool:
 		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")
@@ -406,6 +501,7 @@ func sync_goals(new_goals: Array):
 @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(
@@ -418,3 +514,107 @@ func rotate_towards_target(target_pos: Vector2i):
 	# 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