adtpdn
84413314ef
Introduces a new example scene and player script for the enhanced_gridmap addon, including supporting resources and materials. Updates the mesh library, assets, and main scene to integrate new tile types and visual styles. Adjusts project settings for improved resolution and sets the new main scene as the entry point.
130 lines
4.1 KiB
GDScript
130 lines
4.1 KiB
GDScript
extends Node3D
|
|
|
|
@export var enhanced_gridmap_path: NodePath
|
|
@export var player_path: NodePath
|
|
|
|
var enhanced_gridmap: EnhancedGridMap
|
|
var player: Node3D
|
|
var current_position: Vector2i
|
|
var is_player_moving: bool = false
|
|
|
|
# Customizable cell size and offset
|
|
@export var cell_size: Vector3 = Vector3(2, 2, 2)
|
|
@export var cell_offset: Vector3 = Vector3(0, 0, 0)
|
|
|
|
# Diagonal movement flag
|
|
@export var use_diagonal_movement: bool = false:
|
|
set(value):
|
|
use_diagonal_movement = value
|
|
if enhanced_gridmap:
|
|
enhanced_gridmap.set_diagonal_movement(value)
|
|
|
|
func _ready():
|
|
enhanced_gridmap = get_node(enhanced_gridmap_path)
|
|
player = get_node(player_path)
|
|
|
|
if not enhanced_gridmap or not player:
|
|
push_error("EnhancedGridMap or Player node not found. Please set the correct paths in the inspector.")
|
|
return
|
|
|
|
# Ensure the A* graph is initialized
|
|
enhanced_gridmap.initialize_astar()
|
|
|
|
# Sync diagonal movement setting with the plugin
|
|
enhanced_gridmap.set_diagonal_movement(use_diagonal_movement)
|
|
|
|
# Position the player at a valid starting position
|
|
#current_position = find_valid_starting_position()
|
|
current_position = Vector2i(0,2)
|
|
update_player_position(current_position)
|
|
|
|
func find_valid_starting_position() -> Vector2i:
|
|
for x in range(enhanced_gridmap.columns):
|
|
for z in range(enhanced_gridmap.rows):
|
|
for item in enhanced_gridmap.non_walkable_items.size():
|
|
if enhanced_gridmap.get_cell_item(Vector3i(x, 0, z)) != enhanced_gridmap.non_walkable_items[item]:
|
|
return Vector2i(x, z)
|
|
return Vector2i(0, 0) # Fallback to (0,0) if no valid position found
|
|
|
|
func _unhandled_input(event):
|
|
|
|
if is_player_moving:
|
|
return # Ignore input if the player is already moving
|
|
|
|
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)
|
|
|
|
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 move_player_to_clicked_position(grid_position: Vector2i):
|
|
var cell_item = enhanced_gridmap.get_cell_item(Vector3i(grid_position.x, 0, grid_position.y))
|
|
|
|
for x in enhanced_gridmap.non_walkable_items.size():
|
|
if cell_item == enhanced_gridmap.non_walkable_items[x]:
|
|
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()
|
|
move_player_along_path(path)
|
|
else:
|
|
print("No valid path found")
|
|
|
|
func move_player_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)
|
|
|
|
# Visualize the path using the plugin's function
|
|
#enhanced_gridmap.visualize_path(path)
|
|
|
|
for point in path:
|
|
var target_position = grid_to_world(Vector2i(point.x, point.y))
|
|
tween.tween_property(player, "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()
|
|
)
|
|
|
|
func update_player_position(grid_position: Vector2i):
|
|
player.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, # Place the player on top of the cell
|
|
grid_position.y * cell_size.z
|
|
)
|
|
|
|
# Center the player within the cell
|
|
world_position.x += cell_size.x * 0.5
|
|
world_position.z += cell_size.z * 0.5
|
|
|
|
return world_position + cell_offset
|