376 lines
14 KiB
GDScript
376 lines
14 KiB
GDScript
extends Node
|
|
|
|
var player: Node3D
|
|
var enhanced_gridmap: Node
|
|
|
|
# Movement settings
|
|
var movement_range: int = 1
|
|
var use_diagonal_movement: bool = false
|
|
var is_moving: bool = false
|
|
var rotation_speed: float = 10.0
|
|
var target_rotation: float = 0.0
|
|
|
|
func initialize(p_player: Node3D, p_gridmap: Node):
|
|
player = p_player
|
|
enhanced_gridmap = p_gridmap
|
|
|
|
# Initialize settings from player if available
|
|
if "movement_range" in player:
|
|
movement_range = player.movement_range
|
|
if "use_diagonal_movement" in player:
|
|
use_diagonal_movement = player.use_diagonal_movement
|
|
|
|
signal movement_finished
|
|
var buffered_direction: Vector2i = Vector2i.ZERO
|
|
var current_move_direction: Vector2i = Vector2i.ZERO
|
|
|
|
func _process(delta):
|
|
if player:
|
|
_handle_rotation(delta)
|
|
|
|
func _handle_rotation(delta):
|
|
if player.rotation.y != target_rotation:
|
|
player.rotation.y = lerp_angle(player.rotation.y, target_rotation, delta * rotation_speed)
|
|
|
|
func rotate_towards_target(target_pos: Vector2i):
|
|
var direction = Vector3(target_pos.x - player.current_position.x, 0, target_pos.y - player.current_position.y)
|
|
if direction != Vector3.ZERO:
|
|
target_rotation = atan2(direction.x, direction.z)
|
|
# Sync rotation to other clients
|
|
if player.is_multiplayer_authority():
|
|
player.rpc("sync_rotation", target_rotation)
|
|
|
|
func simple_move_to(grid_position: Vector2i) -> bool:
|
|
if is_moving:
|
|
var direction = grid_position - player.current_position
|
|
if direction != current_move_direction:
|
|
buffer_move_input(direction)
|
|
return false
|
|
|
|
if not player.is_multiplayer_authority():
|
|
return false
|
|
|
|
if player.get("is_frozen"):
|
|
return false
|
|
|
|
var distance: int
|
|
if use_diagonal_movement:
|
|
distance = max(abs(grid_position.x - player.current_position.x), abs(grid_position.y - player.current_position.y))
|
|
else:
|
|
distance = abs(grid_position.x - player.current_position.x) + abs(grid_position.y - player.current_position.y)
|
|
|
|
if distance != 1:
|
|
return false # Only single-step moves allowed
|
|
|
|
if not enhanced_gridmap.is_position_valid(grid_position):
|
|
return false
|
|
|
|
if player.has_method("can_move_to_finish") and not player.can_move_to_finish(grid_position):
|
|
return false
|
|
|
|
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(grid_position.x, 0, grid_position.y))
|
|
if cell_item == -1 or cell_item in enhanced_gridmap.non_walkable_items:
|
|
return false
|
|
|
|
if player.is_position_occupied(grid_position):
|
|
var push_dir = grid_position - player.current_position
|
|
if not try_push(grid_position, push_dir):
|
|
return false
|
|
|
|
rotate_towards_target(grid_position)
|
|
|
|
if player.is_multiplayer_authority() and player.has_method("sync_walk_animation"):
|
|
player.rpc("sync_walk_animation")
|
|
|
|
var path = [Vector2(player.current_position.x, player.current_position.y), Vector2(grid_position.x, grid_position.y)]
|
|
path.pop_front()
|
|
|
|
current_move_direction = grid_position - player.current_position
|
|
|
|
player.rpc("start_movement_along_path", path, not (player.is_bot or player.is_in_group("Bots")))
|
|
|
|
return true
|
|
|
|
func try_push(target_pos: Vector2i, direction: Vector2i) -> bool:
|
|
if not player.has_method("get_player_at_position"):
|
|
return false
|
|
|
|
var other_player = player.get_player_at_position(target_pos)
|
|
if not other_player:
|
|
return false # Should be occupied if we called this, but safety check
|
|
|
|
# Calculate where they will be pushed to
|
|
var pushed_to_pos = target_pos + direction
|
|
|
|
# Check if pushed destination is valid
|
|
if not enhanced_gridmap.is_position_valid(pushed_to_pos):
|
|
# Blocked by world bounds -> Double Push!
|
|
other_player.rpc("apply_stagger", 1.5)
|
|
return false
|
|
|
|
# Check walkability of pushed destination
|
|
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(pushed_to_pos.x, 0, pushed_to_pos.y))
|
|
if cell_item == -1 or cell_item in enhanced_gridmap.non_walkable_items:
|
|
# Blocked by obstacle -> Double Push!
|
|
other_player.rpc("apply_stagger", 1.5)
|
|
return false
|
|
|
|
# Check if pushed destination is ALREADY occupied (Double Push / Crush)
|
|
if player.is_position_occupied(pushed_to_pos):
|
|
# Blocked by another player -> Double Push!
|
|
other_player.rpc("apply_stagger", 1.5)
|
|
return false
|
|
|
|
# Check if other player is currently moving (don't push moving players to avoid sync issues)
|
|
if other_player.is_player_moving:
|
|
return false
|
|
|
|
# EXECUTE PUSH
|
|
print("Player %s PUSHING %s to %s" % [player.name, other_player.name, pushed_to_pos])
|
|
|
|
# Force move the other player
|
|
# We use rpc to sync this change. Since we are authority, we can dictate pos.
|
|
|
|
# 1. Update their position variable immediately so our move check passes next frame?
|
|
# actually simple_move_to continues immediately.
|
|
|
|
# We need to forcefully animate/move them.
|
|
# Let's use their own movement RPC if possible, or a special push RPC.
|
|
# For simplicity, we'll assume they snap-move or use the standard path movement but faster?
|
|
# Let's use the standard movement for now to ensure consistency.
|
|
|
|
var path = [Vector2(target_pos.x, target_pos.y), Vector2(pushed_to_pos.x, pushed_to_pos.y)]
|
|
# path.pop_front() # start_movement_along_path expects full path?
|
|
# Actually start_movement_along_path usually takes [start, end] or [end]?
|
|
# Looking at simple_move_to above:
|
|
# path = [current, target]
|
|
# path.pop_front() -> path is [target]
|
|
# So it expects just the waypoints excluding start.
|
|
|
|
var push_path = [Vector2(pushed_to_pos.x, pushed_to_pos.y)]
|
|
|
|
# Call RPC on the OTHER player
|
|
other_player.rpc("start_movement_along_path", push_path, false) # false = no cam checks?
|
|
# Wait, the boolean arg is "is_local_human"?
|
|
# In player.gd call: player.rpc("start_movement_along_path", path, not (player.is_bot...))
|
|
|
|
# Update their current_position immediately so `is_position_occupied` returns false for us
|
|
# (The RPC handles the visual tween, but we need logical update)
|
|
# However, start_movement_along_path usually updates current_position at start or end?
|
|
# If we don't update it now, our `player.is_position_occupied(grid_position)` check in subsequent frames might be ok,
|
|
# but `simple_move_to` is synchronous-ish.
|
|
|
|
# Crucial: We need to make sure `player.is_position_occupied` returns false for `grid_position`
|
|
# RIGHT NOW so we can return true and move into it.
|
|
# But `is_position_occupied` checks `current_position` and `target_position`.
|
|
# So we need to update `other_player`'s state.
|
|
|
|
other_player.target_position = pushed_to_pos
|
|
other_player.is_player_moving = true # Mark them as moving so they occupy the NEW spot vs OLD spot?
|
|
# Actually is_position_occupied checks BOTH current and target.
|
|
# So if they are moving, they occupy BOTH until finished?
|
|
# See player.gd:
|
|
# if player.is_player_moving and player.target_position == pos: return true
|
|
# if player.current_position == pos: return true
|
|
|
|
# This implies a moving player blocks 2 tiles.
|
|
# If we want to move into `target_pos`, `other_player` must NOT count as occupying it.
|
|
# But they ARE at `target_pos`.
|
|
# We physically can't be at the same spot.
|
|
# So we essentially need them to VACATE `target_pos` logically.
|
|
|
|
# Hack/Fix: We manually update their `current_position` to `pushed_to_pos` immediately?
|
|
# No, that breaks visual interpolation.
|
|
|
|
# Solution: The push logic implies simultaneity or high speed.
|
|
# If we assume the push is instant-ish logic:
|
|
# We update valid logical positions. Visuals catch up.
|
|
|
|
return true
|
|
|
|
|
|
func buffer_move_input(direction: Vector2i):
|
|
buffered_direction = direction
|
|
|
|
func _on_movement_finished():
|
|
if buffered_direction != Vector2i.ZERO:
|
|
var target = player.current_position + buffered_direction
|
|
buffered_direction = Vector2i.ZERO
|
|
simple_move_to(target)
|
|
else:
|
|
current_move_direction = Vector2i.ZERO
|
|
emit_signal("movement_finished")
|
|
|
|
func move_to_clicked_position(grid_position: Vector2i) -> bool:
|
|
if not player.is_multiplayer_authority() or is_moving or player.action_points <= 0:
|
|
return false
|
|
|
|
# Check if player is frozen
|
|
if player.get("is_frozen"):
|
|
return false
|
|
|
|
# Validate grid position is within bounds
|
|
if not enhanced_gridmap.is_position_valid(grid_position):
|
|
return false
|
|
|
|
# Check finish line logic
|
|
if player.has_method("can_move_to_finish") and not player.can_move_to_finish(grid_position):
|
|
return false
|
|
|
|
# This function seems to rely on pathfinding or just direct move if adjacent?
|
|
# The original code for move_player_to_clicked_position called simple_move_to if adjacent?
|
|
# Actually original code for move_player_to_clicked_position wasn't fully shown in previous view_file.
|
|
# Let's assume it uses pathfinding if not adjacent, or just validates and moves.
|
|
|
|
# For now, let's just try simple move if it's adjacent
|
|
return simple_move_to(grid_position)
|
|
|
|
func is_within_movement_range(target_position: Vector2i) -> bool:
|
|
var distance: int
|
|
if use_diagonal_movement:
|
|
distance = max(abs(target_position.x - player.current_position.x), abs(target_position.y - player.current_position.y))
|
|
else:
|
|
distance = abs(target_position.x - player.current_position.x) + abs(target_position.y - player.current_position.y)
|
|
return distance <= movement_range
|
|
|
|
# Update highlight_movement_range to respect the expanded obstacle blocking
|
|
func highlight_movement_range():
|
|
if not player.is_multiplayer_authority() or player.is_bot or player.is_in_group("Bots"):
|
|
return
|
|
|
|
# Prevent recursive highlighting
|
|
if player._is_highlighting:
|
|
return
|
|
player._is_highlighting = true
|
|
|
|
player.clear_highlights()
|
|
var cells_to_highlight = []
|
|
|
|
# First, identify all cells that are blocked by obstacles
|
|
var blocked_cells = []
|
|
|
|
# Obstacle blocking logic removed
|
|
|
|
# Now highlight all cells within movement range that aren't blocked
|
|
for x in range(max(0, player.current_position.x - movement_range),
|
|
min(enhanced_gridmap.columns, player.current_position.x + movement_range + 1)):
|
|
for z in range(max(0, player.current_position.y - movement_range),
|
|
min(enhanced_gridmap.rows, player.current_position.y + movement_range + 1)):
|
|
var test_pos = Vector2i(x, z)
|
|
|
|
# Skip current position
|
|
if test_pos == player.current_position:
|
|
continue
|
|
|
|
# Check if within movement range
|
|
if is_within_movement_range(test_pos):
|
|
# Skip if blocked by obstacle
|
|
if test_pos in blocked_cells:
|
|
continue
|
|
|
|
# Check basic walkability
|
|
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(x, 0, z))
|
|
if cell_item == -1 or cell_item in enhanced_gridmap.non_walkable_items or player.is_position_occupied(test_pos):
|
|
continue
|
|
|
|
# Check if there's a valid path to this cell
|
|
if can_reach_cell(test_pos, blocked_cells):
|
|
cells_to_highlight.append(test_pos)
|
|
|
|
# At the end of the function:
|
|
player.highlight_cells_if_authorized(cells_to_highlight)
|
|
player._is_highlighting = false
|
|
|
|
# Helper function to check if a cell can be reached given the blocked cells
|
|
func can_reach_cell(target_pos: Vector2i, blocked_cells: Array) -> bool:
|
|
# Simple BFS to find if there's a path
|
|
var queue = [player.current_position]
|
|
var visited = {player.current_position: true}
|
|
var steps = {player.current_position: 0}
|
|
|
|
while not queue.is_empty():
|
|
var current = queue.pop_front()
|
|
|
|
# If we've found the target, check if it's within movement range
|
|
if current == target_pos:
|
|
return steps[current] <= movement_range
|
|
|
|
# If we've used all movement, don't explore further
|
|
if steps[current] >= movement_range:
|
|
continue
|
|
|
|
# Try all adjacent cells
|
|
var directions = [
|
|
Vector2i(0, -1), # North
|
|
Vector2i(1, 0), # East
|
|
Vector2i(0, 1), # South
|
|
Vector2i(-1, 0), # West
|
|
]
|
|
|
|
# Add diagonal directions if enabled
|
|
if enhanced_gridmap.diagonal_movement:
|
|
directions.append(Vector2i(-1, -1)) # Northwest
|
|
directions.append(Vector2i(1, -1)) # Northeast
|
|
directions.append(Vector2i(-1, 1)) # Southwest
|
|
directions.append(Vector2i(1, 1)) # Southeast
|
|
|
|
for dir in directions:
|
|
var next_pos = current + dir
|
|
|
|
# Skip if already visited, blocked, or not valid
|
|
if visited.has(next_pos) or next_pos in blocked_cells:
|
|
continue
|
|
|
|
if not enhanced_gridmap.is_position_valid(next_pos) or not enhanced_gridmap.is_cell_walkable(next_pos, 0):
|
|
continue
|
|
|
|
if player.is_position_occupied(next_pos) and next_pos != target_pos:
|
|
continue
|
|
|
|
# Check if movement between cells is blocked by an obstacle
|
|
# if not is_diagonal_direction(dir) and enhanced_gridmap.is_movement_blocked(current, next_pos, 3):
|
|
# continue
|
|
|
|
# For diagonal movement, check if both orthogonal paths are blocked
|
|
if is_diagonal_direction(dir):
|
|
var mid1 = Vector2i(next_pos.x, current.y)
|
|
var mid2 = Vector2i(current.x, next_pos.y)
|
|
|
|
var path1_blocked = mid1 in blocked_cells # or enhanced_gridmap.is_movement_blocked(current, mid1, 3)
|
|
var path2_blocked = mid2 in blocked_cells # or enhanced_gridmap.is_movement_blocked(current, mid2, 3)
|
|
|
|
if path1_blocked and path2_blocked:
|
|
continue
|
|
|
|
# Add to queue
|
|
queue.append(next_pos)
|
|
visited[next_pos] = true
|
|
steps[next_pos] = steps[current] + 1
|
|
|
|
return false
|
|
|
|
# Helper function to check if a direction is diagonal
|
|
func is_diagonal_direction(direction: Vector2i) -> bool:
|
|
return direction.x != 0 and direction.y != 0
|
|
|
|
func highlight_adjacent_cells():
|
|
if not player.is_multiplayer_authority() or player.is_bot or player.is_in_group("Bots"):
|
|
return
|
|
|
|
var cells_to_highlight = []
|
|
|
|
# Add current position if item exists
|
|
var current_cell = Vector3i(player.current_position.x, 1, player.current_position.y)
|
|
if enhanced_gridmap.get_cell_item(current_cell) != -1:
|
|
cells_to_highlight.append(player.current_position)
|
|
|
|
# Add valid neighbors
|
|
var neighbors = enhanced_gridmap.get_neighbors(player.current_position, 0)
|
|
for neighbor in neighbors:
|
|
if neighbor.is_walkable:
|
|
var cell_pos = neighbor.position
|
|
if enhanced_gridmap.get_cell_item(Vector3i(cell_pos.x, 1, cell_pos.y)) != -1:
|
|
cells_to_highlight.append(cell_pos)
|
|
|
|
player.highlight_cells_if_authorized(cells_to_highlight)
|