Walking the path

Hi friends, I hope you all had a great week and weekend!

This week I’ve made some progress on my Little Red Riding Hood puzzle game, it’s now a fully functioning game, with 2 levels. I still have a lot to do before I can call that a finished product though:

• Turn based actions
• Wolf pathfinding
• Loose condition
• Obstacles
• Door
• Opening the door with Wolf -> Loose as well
• Hunter kills wolf
• Transitions
• Menu
• Options
• Save
• 5 levels
• Win screen
• In game menu
• Better death animation
• Better indication that we need to kill the wolf before escaping
• Sounds
• Music
• Tutorial, Dialogs

Building on Heartbeast A* pathfinding

To implement my wolf pathfinding, I used HeartBeast’s Astar Implementation Script for TileMap Nodes in Godot. The debug is view is really neat, and the script easy to build from. I had to modify it slightly for my use case:

Indexing cells by their grid position

In the original script, all the cells, units and obstacle are indexed using their real world position.
Let’s focus on the cells:

func create_pathfinding_points() -> void:
	astar.clear()
	var used_cell_positions = get_used_cell_global_positions()
	for cell_position in used_cell_positions:
		astar.add_point(get_point(cell_position), cell_position)

func get_used_cell_global_positions() -> Array:
	var cells = get_used_cells()
	var cell_positions := []
	for cell in cells:
		var cell_position := global_position + map_to_world(cell)
		cell_positions.append(cell_position)
	return cell_positions

I’m now indexing only based on the cell position in the grid:

func create_pathfinding_points() -> void:
	astar.clear()
	#var used_cell_positions = get_used_cell_global_positions()
	var used_cell_positions = get_used_cells()
	for cell_position in used_cell_positions:
		var cell_world_position = global_position + map_to_world(cell_position) + cell_size/2
		astar.add_point(get_point(cell_position), cell_world_position)

I also took the opportunity to register the center of the cell directly, as it’s what I found myself needing the most.

Movement

The movement is heavily inspired by this tutorial by GDQuest, but instead of directly checking if the point is walkable, I’m using the paths built with astar:

func _process(delta):
	var input_direction = get_input_direction()
	if not input_direction:
		return
		
	var cell_start = Grid.world_to_map(position)
	var cell_target = cell_start + input_direction
	var path_points = Grid.get_astar_path_avoiding_obstacles(cell_start, cell_target)
	if len(path_points) > 1:
		move_to(path_points[1])
	else:
		bump()

Objects

I also needed to have interactable objects on the grid, so I’m registering them exactly like the obstacles:

func add_object(object: Object) -> void:
	objects[get_point(world_to_map(object.position))] = object
	if not object.is_connected("tree_exiting", self, "remove_object"):
		object.connect("tree_exiting", self, "remove_object", [object])
				
func remove_object(object: Object) -> void:
	objects.erase(object)

And then in the movement script above I’m adding:

	var path_points = Grid.get_astar_path_avoiding_obstacles(cell_start, cell_target)
	if len(path_points) > 1:
		move_to(path_points[1])
		var object = Grid.get_object_on_cell(position)
		if object:
			object.interact()

Some links

Before I let you go, here are some interesting links I came across this week:

• A nice threadorial on customizable transition shader
• A GDC talk on Growing Your Code Library with Each New Project including some advices I definitively plan on implementing as I build my games

All right, that’s all for this week.
It has a bit heavier on the code side than usual, I hope it was your cup of tea!

Thanks for reading and see you next week!