Practice Code Typing – SkillsTyping

Choose your language:

ℹ️ Select 'Choose Exercise', or randomize 'Next Random Exercise' in selected language.

Choose Exercise:

Ready

Exercise Algorithm Area

Correct typos to continue.

1extends Node
2
3# --- State Machine Definition ---
4
5# Define states as constants for clarity and to avoid typos
6const STATE_IDLE = "idle"
7const STATE_PATROLLING = "patrolling"
8const STATE_CHASING = "chasing"
9const STATE_ATTACKING = "attacking"
10const STATE_FLEEING = "fleeing"
11const STATE_SEARCHING = "searching"
12
13var current_state = STATE_IDLE
14var previous_state = null
15
16# State-specific data
17var patrol_points: Array = []
18var current_patrol_index = 0
19var target_node: Node = null
20var player_last_known_position: Vector3 = Vector3.ZERO
21var detection_radius: float = 100.0
22var attack_range: float = 20.0
23var flee_threshold: float = 50.0
24var flee_speed_multiplier: float = 1.5
25var patrol_speed: float = 50.0
26var chase_speed: float = 100.0
27var attack_cooldown: float = 1.0
28var time_since_last_attack: float = 0.0
29var search_timer: float = 5.0
30var time_in_search: float = 0.0
31
32# References to other nodes (e.g., player, navigation agent)
33@onready var navigation_agent = $NavigationAgent3D
34@onready var animation_player = $AnimationPlayer
35@onready var health_component = $HealthComponent # Assuming a HealthComponent exists
36
37# --- Signals ---
38
39signal state_changed(new_state: String, old_state: String)
40
41# --- Initialization ---
42
43func _ready():
44# Initialize patrol points if they are set in the inspector
45if patrol_points.is_empty():
46printerr("Patrol points not set for enemy AI.")
47# Potentially set default patrol points or disable patrolling
48
49# Set initial state
50set_state(STATE_IDLE)
51
52# --- State Management ---
53
54func set_state(new_state: String):
55if current_state == new_state:
56return # Already in this state
57
58previous_state = current_state
59current_state = new_state
60print("Enemy AI state changed from %s to %s" % [previous_state, current_state])
61emit_signal("state_changed", new_state, previous_state)
62
63# Reset state-specific variables on transition
64match new_state:
65STATE_IDLE:
66target_node = null
67player_last_known_position = Vector3.ZERO
68time_in_search = 0.0
69STATE_PATROLLING:
70current_patrol_index = 0
71navigation_agent.set_velocity_computed_callback(null)
72animation_player.play("walk") # Assuming 'walk' animation
73STATE_CHASING:
74# Target node should already be set by the transition logic
75pass
76STATE_ATTACKING:
77animation_player.play("attack") # Assuming 'attack' animation
78# Attack logic will be handled in _process
79STATE_FLEEING:
80animation_player.play("run") # Assuming 'run' animation
81# Fleeing logic will be handled in _process
82STATE_SEARCHING:
83time_in_search = search_timer
84animation_player.play("search") # Assuming 'search' animation
85
86# --- Core Logic (Process) ---
87
88func _process(delta):
89# Handle global cooldowns or timers
90if time_since_last_attack < attack_cooldown:
91time_since_last_attack += delta
92
93# State-specific behavior
94match current_state:
95STATE_IDLE:
96handle_idle(delta)
97STATE_PATROLLING:
98handle_patrolling(delta)
99STATE_CHASING:
100handle_chasing(delta)
101STATE_ATTACKING:
102handle_attacking(delta)
103STATE_FLEEING:
104handle_fleeing(delta)
105STATE_SEARCHING:
106handle_searching(delta)
107
108# Check for global state transitions (e.g., player detection)
109check_global_transitions(delta)
110
111# --- State Handler Functions ---
112
113func handle_idle(delta):
114# In idle, wait for something to happen or transition to patrolling
115# For simplicity, let's say it transitions to patrolling after a short delay
116# Or if a player is detected, it will transition via check_global_transitions
117pass # No specific action in idle, relies on global checks
118
119func handle_patrolling(delta):
120if patrol_points.is_empty():
121set_state(STATE_IDLE)
122return
123
124var current_point = patrol_points[current_patrol_index]
125var distance_to_point = global_position.distance_to(current_point)
126
127# Move towards the current patrol point
128navigation_agent.set_target_position(current_point)
129var next_path_position = navigation_agent.get_next_path_position()
130var direction = (next_path_position - global_position).normalized()
131velocity = direction * patrol_speed
132move_and_slide()
133
134# If close enough to the point, move to the next one
135if distance_to_point < 1.0: # Tolerance for reaching the point
136current_patrol_index = (current_patrol_index + 1) % patrol_points.size()
137# If we've completed a full patrol cycle, consider transitioning
138# For now, just continue patrolling
139
140func handle_chasing(delta):
141if target_node == null or not is_instance_valid(target_node):
142set_state(STATE_SEARCHING)
143return
144
145var distance_to_target = global_position.distance_to(target_node.global_position)
146
147# If within attack range, transition to attacking
148if distance_to_target <= attack_range and time_since_last_attack >= attack_cooldown:
149set_state(STATE_ATTACKING)
150return
151
152# If player is too far or health is low, consider fleeing
153if health_component != null and health_component.current_health < health_component.max_health * 0.3:
154set_state(STATE_FLEEING)
155return
156
157# Move towards the target
158navigation_agent.set_target_position(target_node.global_position)
159var next_path_position = navigation_agent.get_next_path_position()
160var direction = (next_path_position - global_position).normalized()
161velocity = direction * chase_speed
162move_and_slide()
163
164func handle_attacking(delta):
165# Attack logic is primarily triggered by the animation or a timer
166# For this example, assume attack animation plays and we transition back after it finishes
167# Or if the target moves out of range
168if animation_player.is_playing() and animation_player.current_animation == "attack":
169# Keep facing the target
170look_at(target_node.global_position)
171# Attack logic would typically happen here, e.g., dealing damage
172# For simplicity, we'll transition back after a short duration or if target is lost
173pass # Attack animation handles duration
174else:
175# If animation finished or was interrupted
176time_since_last_attack = 0.0 # Reset cooldown
177if target_node != null and is_instance_valid(target_node):
178var distance_to_target = global_position.distance_to(target_node.global_position)
179if distance_to_target <= attack_range:
180set_state(STATE_CHASING) # Re-engage if still in range
181else:
182set_state(STATE_CHASING) # Go back to chasing if out of range
183else:
184set_state(STATE_SEARCHING)
185
186func handle_fleeing(delta):
187if target_node == null or not is_instance_valid(target_node):
188set_state(STATE_SEARCHING)
189return
190
191# Flee away from the player
192var flee_direction = (global_position - target_node.global_position).normalized()
193var flee_target_position = global_position + flee_direction * 50.0 # Flee a set distance
194
195navigation_agent.set_target_position(flee_target_position)
196var next_path_position = navigation_agent.get_next_path_position()
197var direction = (next_path_position - global_position).normalized()
198velocity = direction * chase_speed * flee_speed_multiplier
199move_and_slide()
200
201# If player is no longer a threat (e.g., out of range, or health is high)
202var distance_to_target = global_position.distance_to(target_node.global_position)
203if distance_to_target > flee_threshold * 2.0 or (health_component != null and health_component.current_health > health_component.max_health * 0.7):
204set_state(STATE_SEARCHING)
205
206func handle_searching(delta):
207if time_in_search > 0:
208time_in_search -= delta
209# Look around randomly or in a pattern
210# For simplicity, just stay put and look
211pass
212else:
213# Finished searching, decide next action
214if target_node != null and is_instance_valid(target_node):
215# If player was last seen, maybe go to last known position
216set_state(STATE_CHASING) # Or go back to patrolling
217else:
218set_state(STATE_PATROLLING)
219
220# --- Global Transition Checks ---
221
222func check_global_transitions(delta):
223# Check for player detection
224var player = get_tree().get_first_node_in_group("player") # Assuming player is in 'player' group
225if player != null:
226var distance_to_player = global_position.distance_to(player.global_position)
227
228# Player detection logic
229if distance_to_player <= detection_radius:
230if current_state != STATE_CHASING and current_state != STATE_ATTACKING and current_state != STATE_FLEEING:
231target_node = player
232player_last_known_position = player.global_position
233set_state(STATE_CHASING)
234return # Prioritize chasing if detected
235else:
236# Player out of detection range
237if current_state == STATE_CHASING or current_state == STATE_ATTACKING:
238# If player was just in range and is now out, start searching
239player_last_known_position = player.global_position # Update last known position
240set_state(STATE_SEARCHING)
241return
242
243# Check for low health to flee
244if health_component != null and health_component.current_health < health_component.max_health * 0.3:
245if current_state != STATE_FLEEING:
246set_state(STATE_FLEEING)
247return
248
249# If player is lost and we are not actively chasing/attacking/fleeing
250if target_node == null and current_state != STATE_PATROLLING and current_state != STATE_IDLE:
251set_state(STATE_SEARCHING)
252
253# --- Helper Functions ---
254
255func move_and_slide():
256# Placeholder for actual movement logic, e.g., using CharacterBody3D
257# This would typically involve setting velocity and calling move_and_slide()
258# For this example, we'll assume it's handled elsewhere or is a simplified representation.
259pass
260
261func look_at(target_position: Vector3):
262# Placeholder for looking at a target position
263# This would typically involve rotating the node's basis
264pass
265
266func get_velocity() -> Vector3:
267# Placeholder for getting current velocity
268return velocity
269
270func set_velocity(new_velocity: Vector3):
271# Placeholder for setting current velocity
272velocity = new_velocity

Algorithm description viewbox

GDScript Complex State Machine for Enemy AI

Algorithm description:

This GDScript code defines a sophisticated state machine for an enemy AI in a 3D game. It manages various AI behaviors like idling, patrolling, chasing the player, attacking, fleeing, and searching. The state machine uses signals to notify other systems about state changes and includes logic for transitioning between states based on player proximity, AI health, and timers. This is crucial for creating believable and responsive enemy behaviors in games.

Algorithm explanation:

This state machine implements a finite state automaton (FSA) pattern. The `current_state` variable dictates the AI's current behavior, and transitions occur based on conditions checked in `check_global_transitions` and within individual state handlers. Each state (`STATE_IDLE`, `STATE_PATROLLING`, etc.) has a corresponding `handle_` function that executes its logic. Transitions are managed by `set_state`, which updates `current_state`, `previous_state`, and emits a `state_changed` signal. The `_process` function continuously updates the AI's behavior and checks for global transitions. Time complexity for processing is O(S) where S is the number of states, as each state's handler is called once per frame, and global checks are constant time. Space complexity is O(1) for the state variables, but can increase if states manage complex data structures. Edge cases include null target nodes, empty patrol points, and low health. The correctness relies on ensuring all possible transitions are covered and that state-specific logic correctly updates AI parameters like velocity and target.

Pseudocode:

class EnemyAI:
  states = [IDLE, PATROLLING, CHASING, ATTACKING, FLEEING, SEARCHING]
  currentState = IDLE
  previousState = null
  
  function onReady():
    set_state(IDLE)

  function setState(newState):
    if currentState == newState:
      return
    previousState = currentState
    currentState = newState
    emit state_changed signal
    reset state-specific variables

  function onProcess(delta):
    handleGlobalCooldowns()
    switch currentState:
      case IDLE:
        handle_idle(delta)
      case PATROLLING:
        handle_patrolling(delta)
      # ... other states ...
    check_global_transitions(delta)

  function check_global_transitions(delta):
    detect_player()
    check_low_health()
    handle_lost_player()

  # ... handler functions for each state ...
  # ... helper functions for movement, looking, etc. ...

Library

Playable exercises

Choose Exercise

Filter, sort, and preview algorithm before you choose one to play.

Total 7 published items

Pages 1 pages available

Language

Sort by Direction

Browse published coding scenarios with filters, sorting, and pagination.

Published

GDScript GameDev (gdscript)

GDScript: Binary Search Tree Node Insertion

Difficulty: writing: 4; length: 4
Popularity: 0
Created: 2026-01-26 13:59 UTC
Published: 2026-01-26 16:41 UTC
Author: Damian

#BST #recursion #data structures #algorithms #GDScript #tree

goal: Implement recursive insertion into a Binary Search Tree. input: A value to insert. output: The Binary Search Tree is modified by inserting the value if it's not a duplicate.

Canonical Algorithm Text

class Node: var value var left = null var right = null func _init(val): value = val class BinarySearchTree: var root = null func insert(value): if root == null: root = Node.new(value) return _insert_recursive(root, value) func _insert_recursive(current_node, value): if value == c...

Description Algorithm

This GDScript code defines a Binary Search Tree (BST) with a recursive insertion method. The BST is a data structure where each node has at most two children, referred to as the left child and the right child. For any gi...

Explanation

The `BinarySearchTree` class uses a `Node` class to represent each element in the tree, storing a `value` and references to its `left` and `right` children. The `insert` method is the public interface, handling the initial case where the tree is empty by creating the root node. For non-empty trees, it delegates the insertion logic to the private recursive helper function `_insert_recursive`. This helper function takes the current node and the value to be inserted. It first checks if the value already exists in the tree; if so, it returns without inserting to prevent duplicates. Otherwise, it compares the value with the current node's value. If the value is smaller, it attempts to insert into the left subtree; if the left child is null, a new node is created there. If the left child exists, the function recursively calls itself on the left child. A similar process occurs for values greater than the current node's value, targeting the right subtree. The recursion naturally handles traversing down the tree until an appropriate null child pointer is found for insertion. The time complexity for insertion in a balanced BST is O(log N), where N is the number of nodes, because the search path is logarithmic. In the worst case (a skewed tree), it degrades to O(N). The space complexity is O(log N) for a balanced tree and O(N) for a skewed tree due to the recursion depth.

Pseudocode

class Node: value left = null right = null function Node(val): initialize node with val class BinarySearchTree: root = null function insert(value): if root is null: set root to new Node(value) return call _insert_recursi...

Published

GDScript GameDev (gdscript)

GDScript: Advanced String Palindrome Checker

Difficulty: writing: 3; length: 3
Popularity: 0
Created: 2026-01-26 13:59 UTC
Published: 2026-01-26 16:41 UTC
Author: Damian

#string #palindrome #algorithms #text processing #GDScript #edge cases

goal: Implement a palindrome checker input: A string `text` output: A boolean, `true` if `text` is a palindrome, `false` otherwise.

Canonical Algorithm Text

func is_palindrome(text: String) -> bool: var cleaned_text = _normalize_and_clean_string(text) var n = cleaned_text.length() if n <= 1: return true var left = 0 var right = n - 1 while left < right: if cleaned_text[left] != cleaned_text[right]: return false left += 1 right -= 1 r...

Description Algorithm

This GDScript function determines if a given string is a palindrome, ignoring case, spaces, and punctuation. A palindrome is a word, phrase, number, or other sequence of characters that reads the same backward as forward...

Explanation

The `is_palindrome` function first normalizes the input string by converting it to lowercase and removing non-alphanumeric characters using the `_normalize_and_clean_string` helper. This ensures that comparisons are case-insensitive and unaffected by irrelevant characters. The core logic then uses two pointers, `left` and `right`, initialized at the beginning and end of the cleaned string, respectively. The loop continues as long as `left` is less than `right`. In each iteration, it compares the characters at the `left` and `right` pointers. If they differ, the string is not a palindrome, and the function returns `false`. If the characters match, the pointers are moved inwards (`left` increments, `right` decrements). If the loop completes without finding any mismatches, it means the string is a palindrome, and the function returns `true`. Edge cases such as empty strings or single-character strings are handled by returning `true` immediately, as they are trivially palindromic. The time complexity is O(N), where N is the length of the input string, due to the linear scan for cleaning and the two-pointer comparison. The space complexity is also O(N) in the worst case for storing the cleaned string.

Pseudocode

function is_palindrome(text): cleaned_text = normalize_and_clean(text) n = length of cleaned_text if n is less than or equal to 1: return true left = 0 right = n - 1 while left < right: if character at left in cleaned_te...

Published

GDScript GameDev (gdscript)

GDScript Signal-Driven Event Dispatcher

Difficulty: writing: 8; length: 10
Popularity: 0
Created: 2026-01-26 12:30 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#event system #signals #GDScript #decoupling #observer pattern

goal: Implement a generic event dispatcher. output: Triggers registered listeners.

Canonical Algorithm Text

extends Node # A dictionary to store event listeners. Key: event name (String), Value: Array of callables. var event_listeners: Dictionary = {} # --- Event Registration --- # Registers a callable to listen for a specific event. # Parameters: # event_name: The name of the event to...

Description Algorithm

This GDScript code provides a flexible event dispatcher system for Godot Engine projects. It allows different parts of your game to communicate without direct dependencies by using signals. You can register functions (ca...

Explanation

The `EventDispatcher` uses a dictionary (`event_listeners`) to map event names (strings) to arrays of `Callable` objects. The `register_listener` function adds a callable to the appropriate array for a given event name, creating the array if it doesn't exist. It prevents duplicate registrations. `unregister_listener` removes a specific callable from an event's listener list, cleaning up the dictionary entry if no listeners remain. `emit_event` looks up the event name, retrieves its listeners, and iterates through a copy of the listener list (to safely handle listeners unregistering themselves during the emission process) calling each one with provided arguments. This decouples event emitters from listeners, promoting modularity. Time complexity for registration and unregistration is O(L) where L is the number of listeners for a specific event, due to array searching. Emission is O(L) as well, as each listener is called once. Space complexity is O(E * L_avg) where E is the number of unique events and L_avg is the average number of listeners per event, to store the listener mappings.

Pseudocode

class EventDispatcher: listeners = map<string, list<callable>> function registerListener(eventName, listener): if eventName not in listeners: listeners[eventName] = new list if listener not in listeners[eventName]: add l...

Published

GDScript GameDev (gdscript)

GDScript Scene Tree Node Finder

Difficulty: writing: 5; length: 2
Popularity: 0
Created: 2026-01-26 12:30 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#scene tree #recursion #node search #GDScript #DFS

goal: Find a node by name in a scene tree. output: Node or null

Canonical Algorithm Text

func find_node_recursive(root_node: Node, target_name: String) -> Node: # Check if the current node is the target if root_node.name == target_name: return root_node # Iterate through children recursively for child in root_node.get_children(): var found_node = find_node_recursive(...

Description Algorithm

This GDScript code implements a recursive function to search for a specific node within a Godot Engine scene tree by its name. It starts from a given root node and explores its children and their descendants until the ta...

Explanation

The `find_node_recursive` function performs a depth-first search (DFS) on the scene tree. The base case for the recursion is when the current node's name matches the `target_name`, in which case the node is returned. If not, it iterates through the current node's children, recursively calling itself on each child. If a recursive call returns a non-null node, it means the target was found in that subtree, and the function immediately returns it, preventing further unnecessary searching. The `find_node_in_tree` function acts as a public interface, adding initial validation for the root node and target name before initiating the recursive search. This approach ensures that the search terminates as soon as the node is found, optimizing performance. The time complexity is O(N) in the worst case, where N is the total number of nodes in the subtree being searched, as each node might be visited once. The space complexity is O(H) due to the recursion depth, where H is the maximum height of the scene tree.

Pseudocode

function find_node_recursive(currentNode, targetName): if currentNode.name equals targetName: return currentNode for each child in currentNode.children: found = find_node_recursive(child, targetName) if found is not null...

Published

GDScript GameDev (gdscript)

GDScript Procedural Dungeon Generator

Difficulty: writing: 3; length: 10
Popularity: 0
Created: 2026-01-26 12:30 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#procedural generation #dungeon #GDScript #map generation #rooms and corridors

goal: Generate a procedural dungeon map. input: None (uses exported variables for configuration) output: 2D Array representing the map grid.

Canonical Algorithm Text

extends Node # --- Configuration --- @export var grid_width: int = 100 @export var grid_height: int = 100 @export var max_rooms: int = 20 @export var min_room_size: Vector2i = Vector2i(5, 5) @export var max_room_size: Vector2i = Vector2i(15, 15) @export var max_corridor_attempts:...

Description Algorithm

This GDScript code generates a procedural dungeon map. It starts by filling the map with walls, then places a specified number of non-overlapping rooms of random sizes. After rooms are placed, it connects them with L-sha...

Explanation

The dungeon generation process involves several steps. First, `initialize_map` creates a grid filled with walls. `place_rooms` attempts to place `max_rooms` by randomly selecting positions and sizes, ensuring rooms do not overlap using `rect.intersects` and a grow buffer. Overlapping rooms are discarded. `carve_room` then marks the cells within a valid room's rectangle as floor tiles. `connect_rooms` iterates through the placed rooms and calls `create_corridor` to link their centers. `create_corridor` uses a simple L-shaped pathfinding logic: it moves horizontally towards the target's X coordinate, then vertically towards the target's Y coordinate (or vice-versa, prioritizing the axis with the larger distance), carving corridors. This ensures connectivity between all rooms. Time complexity is dominated by room placement and corridor generation. Room placement is roughly O(R^2 * S) where R is max_rooms and S is the average room size for intersection checks. Corridor generation is O(R * C) where C is the average corridor length. Space complexity is O(W * H) for the map grid and O(R) for storing room data.

Pseudocode

class Room: rect center intersects(otherRoom) function initializeMap(width, height): create grid of size width x height fill grid with WALL tiles function placeRooms(maxRooms, minSize, maxSize): rooms = empty list for i...

Published

GDScript GameDev (gdscript)

GDScript Complex State Machine for Enemy AI

Difficulty: writing: 10; length: 10
Popularity: 0
Created: 2026-01-26 12:30 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#state machine #AI behavior #GDScript #game AI #finite state automaton

goal: Implement a complex state machine for enemy AI. output: Updates AI behavior and state.

Canonical Algorithm Text

extends Node # --- State Machine Definition --- # Define states as constants for clarity and to avoid typos const STATE_IDLE = "idle" const STATE_PATROLLING = "patrolling" const STATE_CHASING = "chasing" const STATE_ATTACKING = "attacking" const STATE_FLEEING = "fleeing" const ST...

Description Algorithm

This GDScript code defines a sophisticated state machine for an enemy AI in a 3D game. It manages various AI behaviors like idling, patrolling, chasing the player, attacking, fleeing, and searching. The state machine use...

Explanation

This state machine implements a finite state automaton (FSA) pattern. The `current_state` variable dictates the AI's current behavior, and transitions occur based on conditions checked in `check_global_transitions` and within individual state handlers. Each state (`STATE_IDLE`, `STATE_PATROLLING`, etc.) has a corresponding `handle_` function that executes its logic. Transitions are managed by `set_state`, which updates `current_state`, `previous_state`, and emits a `state_changed` signal. The `_process` function continuously updates the AI's behavior and checks for global transitions. Time complexity for processing is O(S) where S is the number of states, as each state's handler is called once per frame, and global checks are constant time. Space complexity is O(1) for the state variables, but can increase if states manage complex data structures. Edge cases include null target nodes, empty patrol points, and low health. The correctness relies on ensuring all possible transitions are covered and that state-specific logic correctly updates AI parameters like velocity and target.

Pseudocode

class EnemyAI: states = [IDLE, PATROLLING, CHASING, ATTACKING, FLEEING, SEARCHING] currentState = IDLE previousState = null function onReady(): set_state(IDLE) function setState(newState): if currentState == newState: re...

Published

GDScript GameDev (gdscript)

GDScript Grid Pathfinding with A*

Difficulty: writing: 5; length: 10
Popularity: 0
Created: 2026-01-26 12:30 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#pathfinding #A* #grid #GDScript #AI navigation

goal: Implement A* pathfinding on a 2D grid. output: Array of Vector2i representing the path, or empty array if no path.

Canonical Algorithm Text

extends Node # Represents a node in the grid for pathfinding class GridNode: var position: Vector2i var g_cost: float = INF # Cost from start to this node var h_cost: float = 0.0 # Heuristic cost from this node to end var f_cost: float = INF # Total cost (g + h) var parent: GridN...

Description Algorithm

This GDScript code implements the A* pathfinding algorithm for a 2D grid. It defines a `GridNode` class to represent cells, manages open and closed sets to explore potential paths efficiently, and uses a heuristic (Manha...

Explanation

A* is an informed search algorithm that finds the shortest path between two points in a graph or grid. It uses a heuristic function to guide its search, prioritizing nodes that are likely to be on the shortest path. The algorithm maintains two sets: the `open_set` (nodes to be evaluated) and the `closed_set` (nodes already evaluated). It iteratively selects the node with the lowest F-cost (G-cost + H-cost) from the `open_set`, moves it to the `closed_set`, and then examines its neighbors. For each neighbor, it calculates a tentative G-cost and updates the neighbor's costs and parent if a shorter path is found or if the neighbor is new. The heuristic used here is the Manhattan distance, which is admissible and consistent for grid-based movement. The path is reconstructed by backtracking from the goal node using parent pointers. Time complexity is typically O(E log V) or O(E + V log V) depending on the priority queue implementation, where V is the number of vertices (grid cells) and E is the number of edges (connections between cells). In a grid, V = width * height and E is proportional to V. Space complexity is O(V) to store the grid nodes and the open/closed sets. Edge cases include start/end nodes being out of bounds, unwalkable, or identical.

Pseudocode

class GridNode: position gCost = infinity hCost = 0 fCost = infinity parent = null isWalkable = true function heuristicCost(nodeA, nodeB): return abs(nodeA.position.x - nodeB.position.x) + abs(nodeA.position.y - nodeB.po...

Language (required)

Paste your code (required)

Max 20,000 characters. (Dangerous HTML/script fragments will be blocked)

Normalized preview:

I agree to Publish this, after admin approval (queued for review). (Not required) I confirm this submission is anonymous and does not contain personal data. I grant SkillsTyping a free, non-exclusive, worldwide, and irrevocable license to store, modify, adapt, and publish this content after review. I understand that publication is not guaranteed, that I retain no ownership or usage claims over published versions, and that no compensation will be provided. See Privacy Policy

Publish details

Shown only if you opt to submit for review. Required when consent is checked.

Title (required with consent)

Short description / summary (required with consent)

Algorithm explanation (required with consent)

Pseudocode (required with consent)