Gamedev

Showing 25 of 37 from the live probe.

• Initialize Godot Project

  Scaffold a new Godot game project with standard directory structure, project.godot config, a main scene, and a basic player script. Args: - name (string): Project name (letters, numbers, underscores, hyphens) - output_dir (string): Parent directory where the project folder will be created - godot_version (string): Godot engine version (default: 4.3) - genre (string): Game genre — determines which starter template to use - window_width (number): Viewport width in pixels (default: 1280

• Get Godot Project Structure

  Scan a Godot project directory and return its structure — scenes, scripts, assets, resources. Args: - project_dir (string): Path to the Godot project root (must contain project.godot) Returns: JSON with categorized file listings and project metadata.

• Manage Game Config

  Read or write JSON configuration files for game settings, balance data, or level metadata. Args: - filepath (string): Path to the config file - action ('read' | 'write' | 'merge'): What to do - data (object, optional): Data to write or merge (required for write/merge) Returns: The current config contents after the operation.

• Generate Godot Entity

  Scaffold a GDScript entity/game-object class with exported properties, signals, and methods. Args: - class_name (string): PascalCase class name (e.g., "Enemy", "Collectible") - base_class (string): Godot node type to extend (e.g., "CharacterBody2D", "Area2D") - properties (array): Exported variables with name, type, default value - signals (array): Signal names to declare - methods (array): Custom method stubs with name, params, return type, body - output_path (string, optional): Fi

• Generate State Machine

  Create a finite state machine in GDScript with states, transitions, and per-state enter/exit/process callbacks. Includes presets for common patterns: - player_platformer: idle, run, jump, fall, wall_slide, dash, hurt, dead - player_topdown: idle, walk, run, attack, hurt, dead, interact - enemy_basic: idle, patrol, chase, attack, hurt, dead - enemy_ranged: idle, patrol, chase, attack, retreat, hurt, dead - game_flow: main_menu, playing, paused, game_over, victory, loading - npc: idle

• Generate Autoload Singleton

  Create a GDScript autoload singleton — useful for game managers, global state, event buses, save/load systems. Args: - class_name (string): PascalCase name - purpose (string): What this singleton manages (used in doc comment) - properties (array): Global variables - methods (array): Global methods - output_path (string, optional): File path to write Returns: Generated GDScript autoload code.

• Generate Reusable Component

  Generate a reusable component script — health system, hitbox, hurtbox, interactable, etc. Args: - template (string): Component template to generate - class_name (string, optional): Override the default class name - output_path (string, optional): File path to write Available templates: - health: Health component with damage/heal/die signals - hitbox: Area2D-based hitbox that deals damage - hurtbox: Area2D-based hurtbox that receives damage - interactable: Proximity-based interact

• Generate Placeholder Sprite

  Create an SVG placeholder sprite with a colored shape. Useful for prototyping before final art is ready. Args: - shape ('rect' | 'circle' | 'triangle' | 'diamond'): Shape type - width (number): Width in pixels (1–512) - height (number): Height in pixels (1–512) - color (string): Fill color (CSS color, e.g., "#ff0000", "blue") - outline_color (string): Stroke color - outline_width (number): Stroke width - label (string, optional): Text label to render inside the shape - output_pa

• Create Spritesheet Metadata

  Generate a spritesheet metadata JSON file that describes frame positions in a spritesheet image. This creates the data file needed for AnimatedSprite2D / SpriteFrames in Godot. You provide the spritesheet dimensions and frame layout, and this tool generates the metadata. Args: - sprite_width (number): Width of each frame - sprite_height (number): Height of each frame - columns (number): Number of columns in the sheet - rows (number): Number of rows in the sheet - frame_count (number)

• Create Tileset Metadata

  Generate a tileset definition JSON that maps tile IDs to positions in a tileset image, with optional properties like collision, navigation, and custom data per tile. Args: - tile_width (number): Width of each tile - tile_height (number): Height of each tile - columns (number): Columns in the tileset image - rows (number): Rows in the tileset image - image_path (string): Relative path to tileset image - tile_properties (array, optional): Per-tile property overrides - output_path (

• List Project Assets

  Scan a directory and catalog all game assets by type (images, audio, fonts, data files). Args: - directory (string): Directory to scan - recursive (boolean): Whether to scan subdirectories (default: true) Returns: JSON with categorized asset listings and totals.

• Create Level Data

  Create a level data file (JSON) from a specification. The format is compatible with Godot TileMap import. Args: - name (string): Level name - width (number): Grid width in tiles - height (number): Grid height in tiles - tile_size (number): Tile size in pixels (default 16) - layers (array): Tile layers, each with a name and 2D data grid - spawns (array): Spawn/marker points - metadata (object): Extra level metadata - output_path (string): Where to save the level JSON Returns: Th

• Validate Level Data

  Check a level JSON file for structural errors, dimension mismatches, missing spawns, unreachable areas, and out-of-bounds tile IDs. Args: - filepath (string): Path to level JSON file - max_tile_id (number): Maximum valid tile ID (default: 6) - require_spawn (boolean): Whether a player spawn is required (default: true) - require_exit (boolean): Whether an exit tile is required (default: true) Returns: Validation results with errors, warnings, and level statistics.

• Generate Procedural Level

  Generate a level using procedural generation algorithms. Available algorithms: - bsp: Binary Space Partitioning — rectangular rooms connected by corridors. Good for dungeons. - cellular: Cellular automata — organic cave-like structures. - drunkard: Drunkard's walk — winding tunnels and open caves. - noise: Perlin noise terrain — smooth heightmap-based terrain. Args: - algorithm ('bsp' | 'cellular' | 'drunkard' | 'noise'): Generation method - width (number): Grid width - height (n

• Create Dialogue Tree

  Build a branching dialogue tree data structure with speakers, choices, conditions, and effects. The output JSON can be loaded by a Godot dialogue system to drive NPC conversations. Args: - id (string): Dialogue tree identifier - title (string): Human-readable title - nodes (array): Dialogue nodes with text, choices, conditions, and effects - start_node (string): ID of the first node - output_path (string, optional): Where to save the JSON Returns: Dialogue tree JSON.

• Create Quest Data

  Define a quest/mission with objectives, rewards, and prerequisites. Args: - id (string): Unique quest ID - name (string): Quest display name - description (string): Quest description shown to player - type (string): Quest type (main, side, bounty, fetch, escort, etc.) - objectives (array): Quest objectives with type, target, and count - rewards (array): Completion rewards - prerequisites (array): Quest IDs that must be completed first - output_path (string, optional): File path

• Define Item Catalog

  Create an item definition catalog with categories, rarity, stacking rules, and custom properties. Args: - items (array): Item definitions - output_path (string, optional): File path to write Returns: Item catalog JSON.

• Create Loot Table

  Define a weighted loot/drop table with rarity tiers, quantity ranges, and conditions. The tool also calculates the normalized drop probability for each entry. Args: - id (string): Loot table ID - name (string): Display name - entries (array): Loot entries with weights and quantities - rolls (number): How many times to roll the table per drop event - guaranteed_drops (array): Item IDs that always drop - output_path (string, optional): File path to write Returns: Loot table JSON wit

• A* Pathfinding

  Run A* pathfinding on a 2D grid. Grid format: 0 = walkable, non-zero = obstacle. Returns the shortest path as a list of (x, y) cells, total cost, and explored count. Args: - grid (number[][]): 2D grid [row][col], 0=walkable - start_x, start_y (number): Start cell - goal_x, goal_y (number): Goal cell - allow_diagonal (boolean): Allow 8-directional movement (default: false) Returns: Path cells, cost, and explored count. Cost = -1 if no path exists.

• Generate Noise Map

  Generate a 2D Perlin noise map, useful for terrain heightmaps, cave generation, vegetation distribution, weather patterns, and other organic data. Values are normalized to [0, 1]. Args: - width (number): Map width - height (number): Map height - scale (number): Frequency scale (higher = more zoomed-out detail) - octaves (number): Layered detail levels (1–8) - persistence (number): How much each octave contributes (0–1) - lacunarity (number): Frequency multiplier per octave - see

• Calculate Balance Stats

  Compute game balance metrics: DPS, effective HP, time-to-kill, and power score. Given attacker and defender stats, calculates combat balance metrics and provides recommendations if values seem out of range. Args: - attacker (object): { damage, attack_speed, health, armor, speed } - defender (object): { damage, attack_speed, health, armor, speed } Returns: Balance metrics and recommendations for both sides.

• Check Collision

  Test collision between two 2D shapes: AABB (rectangle), circle, or convex polygon. Returns whether shapes overlap and the minimum separation vector (MTV). Args: - shape_a (object): First shape { type, x, y, width?, height?, radius?, vertices? } - shape_b (object): Second shape Shape types: - aabb: { type: "aabb", x, y, width, height } - circle: { type: "circle", x, y, radius } - polygon: { type: "polygon", x, y, vertices: [[x,y], ...] } Returns: Collision result with overlap amount

• Generate Pixel Sprite

  Generate pixel art from a named template using a color palette. Outputs SVG + ASCII preview. Templates: humanoid, creature, item_weapon, item_potion, item_card, icon_element, icon_status, chest, coin, heart, shield, skull, gem, orb. Built-in palettes: gameboy, nes, pico8, endesga32, mono_warm, mono_cool, dungeon, cardgame. You can also pass a custom palette as an array of hex colors. Args: - template (string): Sprite template name - palette (string | array): Palette name or arr

• Generate Pixel Animation

  Generate a multi-frame animation spritesheet from a template. Produces individual SVG frames + Godot-compatible SpriteFrames metadata JSON. Animation types: idle (gentle bob), walk (leg movement), attack (forward lean), hurt (flash/shake), flash (color pulse). Args: - template (string): Sprite template - animation (string): Animation type - palette (string | array): Palette name or hex array - frames (number): Frame count (default 4) - size (number): Sprite size (def

• Generate Pixel Tileset

  Procedurally generate pixel art tiles: floor, wall, wall_top, door, pit. Produces individual SVGs and ASCII previews for each tile type. Args: - tile_types (array): Which tile types to generate - palette (string | array): Palette name or hex array - size (number): Tile size in pixels (default 16) - pixel_size (number): SVG scale factor (default 4) Returns: One SVG and ASCII preview per tile type.