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# --- Configuration ---
4
5@export var grid_width: int = 100
6@export var grid_height: int = 100
7@export var max_rooms: int = 20
8@export var min_room_size: Vector2i = Vector2i(5, 5)
9@export var max_room_size: Vector2i = Vector2i(15, 15)
10@export var max_corridor_attempts: int = 500 # To prevent infinite loops
11
12# Tile types (example)
13const TILE_WALL = 0
14const TILE_FLOOR = 1
15const TILE_CORRIDOR = 2
16
17var map_grid: Array = []
18var rooms: Array = [] # Stores Rect2 for each room
19
20# --- Room Class (for convenience) ---
21
22class Room:
23var rect: Rect2
24
25func _init(r: Rect2):
26rect = r
27
28func intersects(other_room: Room) -> bool:
29return rect.intersects(other_room.rect)
30
31func get_center() -> Vector2:
32return rect.position + rect.size / 2.0
33
34# --- Map Initialization ---
35
36func initialize_map():
37map_grid.resize(grid_height)
38for y in range(grid_height):
39map_grid[y] = Array()
40map_grid[y].resize(grid_width)
41for x in range(grid_width):
42map_grid[y][x] = TILE_WALL # Initialize entire map as walls
43
44# --- Room Placement ---
45
46func place_rooms():
47rooms.clear()
48for i in range(max_rooms):
49var room_w = randi_range(min_room_size.x, max_room_size.x)
50var room_h = randi_range(min_room_size.y, max_room_size.y)
51var room_pos_x = randi_range(1, grid_width - room_w - 1) # Ensure room is within bounds, not touching edges
52var room_pos_y = randi_range(1, grid_height - room_h - 1)
53var new_rect = Rect2(room_pos_x, room_pos_y, room_w, room_h)
54var new_room = Room.new(new_rect)
55
56var overlaps = false
57for existing_room in rooms:
58# Add a buffer around rooms to prevent corridors from touching walls directly
59if new_room.rect.grow(1).intersects(existing_room.rect.grow(1)):
60overlaps = true
61break
62
63if not overlaps:
64rooms.append(new_room)
65carve_room(new_room)
66
67# Carves a room into the map grid
68func carve_room(room: Room):
69var r = room.rect
70for y in range(int(r.position.y), int(r.position.y + r.size.y)):
71for x in range(int(r.position.x), int(r.position.x + r.size.x)):
72# Ensure we don't go out of bounds (should be handled by placement, but good safety)
73if y >= 0 and y < grid_height and x >= 0 and x < grid_width:
74map_grid[y][x] = TILE_FLOOR
75
76# --- Corridor Generation ---
77
78func connect_rooms():
79if rooms.size() < 2:
80return # Need at least two rooms to connect
81
82# Connect each room to the next one in the list sequentially
83# For more complex dungeons, consider connecting to a random room or using MST
84for i in range(rooms.size() - 1):
85var room1 = rooms[i]
86var room2 = rooms[i+1]
87create_corridor(room1.get_center(), room2.get_center())
88
89# Optional: Connect the last room back to the first for a loop, or to a random room
90# create_corridor(rooms.back().get_center(), rooms[0].get_center())
91
92# Creates a corridor between two points using a simple L-shaped path
93func create_corridor(start: Vector2, end: Vector2):
94var current_pos = Vector2i(start.x, start.y)
95var target_pos = Vector2i(end.x, end.y)
96
97var attempts = 0
98while current_pos != target_pos and attempts < max_corridor_attempts:
99var dx = target_pos.x - current_pos.x
100var dy = target_pos.y - current_pos.y
101
102# Decide whether to move horizontally or vertically first
103# Prioritize moving towards the target's axis with the larger difference
104if abs(dx) > abs(dy):
105if dx > 0:
106current_pos.x += 1
107elif dx < 0:
108current_pos.x -= 1
109else:
110if dy > 0:
111current_pos.y += 1
112elif dy < 0:
113current_pos.y -= 1
114
115# Ensure we don't carve out of bounds
116if current_pos.x >= 0 and current_pos.x < grid_width and current_pos.y >= 0 and current_pos.y < grid_height:
117# Only carve if it's not already a floor (avoids overwriting room floors unnecessarily)
118if map_grid[current_pos.y][current_pos.x] == TILE_WALL:
119map_grid[current_pos.y][current_pos.x] = TILE_CORRIDOR
120else:
121# If we hit a boundary, stop this corridor attempt
122printerr("Corridor carving hit boundary. Stopping.")
123break
124attempts += 1
125
126# Ensure the end point is also carved as floor
127if target_pos.x >= 0 and target_pos.x < grid_width and target_pos.y >= 0 and target_pos.y < grid_height:
128map_grid[target_pos.y][target_pos.x] = TILE_FLOOR
129
130# --- Generation Function ---
131
132func generate_dungeon() -> Array:
133initialize_map()
134place_rooms()
135connect_rooms()
136return map_grid
137
138# --- Example Usage ---
139
140func _ready():
141var dungeon_data = generate_dungeon()
142# Now you can use dungeon_data to render your dungeon
143# For example, print a simple text representation:
144print("Generated Dungeon (W: %d, H: %d):" % [grid_width, grid_height])
145for y in range(grid_height):
146var row_str = ""
147for x in range(grid_width):
148match map_grid[y][x]:
149TILE_WALL:
150row_str += "#"
151TILE_FLOOR:
152row_str += "."
153TILE_CORRIDOR:
154row_str += "-"
155print(row_str)

Algorithm description viewbox

GDScript Procedural Dungeon Generator

Algorithm description:

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-shaped corridors. The output is a 2D array representing the map, where each cell is marked as a wall, floor, or corridor. This technique is widely used in roguelike games and other procedural content generation scenarios.

Algorithm 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 from 1 to maxRooms:
    randomly determine room width and height
    randomly determine room position
    create new Room object
    overlaps = false
    for each existingRoom in rooms:
      if newRoom.rect intersects existingRoom.rect (with buffer):
        overlaps = true
        break
    if not overlaps:
      add newRoom to rooms
      carveRoom(newRoom)

function carveRoom(room):
  for each cell in room.rect:
    set cell to FLOOR tile

function connectRooms():
  if number of rooms < 2:
    return
  for i from 0 to number of rooms - 2:
    createCorridor(rooms[i].center, rooms[i+1].center)

function createCorridor(startPoint, endPoint):
  currentPos = startPoint
  while currentPos != endPoint:
    determine next move (horizontal or vertical, towards endPoint)
    move currentPos
    if currentPos is within bounds:
      if mapGrid[currentPos] is WALL:
        set mapGrid[currentPos] to CORRIDOR tile
    else:
      break # Hit boundary
  set mapGrid[endPoint] to FLOOR tile

function generateDungeon():
  initializeMap()
  placeRooms()
  connectRooms()
  return mapGrid

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)