Godot Asset Generator

Godot Asset Generator

Generate game assets using AI image generation APIs and prepare them for use in Godot 4.x. This skill covers the complete art pipeline from concept to Godot-ready sprites.

When to Use This Skill

Use this skill when:

• Generating game sprites, characters, or objects using AI
• Creating tilesets for platformers or top-down games
• Generating UI elements, icons, or menu assets
• Batch-generating animation frames
• Preparing AI-generated assets for Godot import
• Creating consistent asset sets with style guides

Do NOT use this skill when:

• Creating 3D models or textures (2D assets only)
• Manual pixel art or illustration (use art software)
• Complex frame-by-frame animation (use animation tools)
• Working with existing assets (use Godot directly)

Prerequisites

Required:

• Deno runtime installed
• At least one API key:
• OPENAI_API_KEY for DALL-E 3
• REPLICATE_API_TOKEN for Replicate (SDXL, Flux)
• FAL_KEY for fal.ai

Optional:

• ImageMagick for advanced image processing
• Godot 4.x project for import file generation

Quick Start

Generate a Single Image

deno run --allow-env --allow-net --allow-write scripts/generate-image.ts \
  --provider dalle \
  --prompt "pixel art knight character, front view, 16-bit style, transparent background" \
  --output ./assets/knight.png

Batch Generate Animation Frames

deno run --allow-env --allow-net --allow-read --allow-write scripts/batch-generate.ts \
  --spec ./batch-spec.json \
  --output ./generated/

Create Sprite Sheet

deno run --allow-read --allow-write scripts/pack-spritesheet.ts \
  --input ./generated/*.png \
  --output ./sprites/player-sheet.png \
  --columns 4

Core Workflow

Phase 1: Style Definition

Define your art style before generating assets:

1. Choose Art Style: Pixel art, hand-drawn, painterly, or vector
2. Create Style Guide: Document colors, modifiers, and constraints
3. Test Prompts: Generate samples to validate style consistency

{
  "style": "pixel-art",
  "resolution": 64,
  "palette": "limited-16-colors",
  "modifiers": "16-bit, no anti-aliasing, clean pixels"
}

Phase 2: Asset Generation

Generate assets using the appropriate provider:

1. Single Assets: Use generate-image.ts for individual images
2. Batch Assets: Use batch-generate.ts for multiple related assets
3. Iterate: Refine prompts based on results

Phase 3: Post-Processing

Prepare raw AI output for game use:

1. Background Removal: Extract sprites from backgrounds
2. Color Correction: Normalize palette if needed
3. Resize: Scale to exact game resolution
4. Trim/Pad: Remove whitespace, add sprite padding

deno run --allow-read --allow-write scripts/process-sprite.ts \
  --input ./raw/knight.png \
  --output ./processed/knight.png \
  --remove-bg \
  --resize 64x64 \
  --filter nearest

Phase 4: Godot Integration

Prepare assets for Godot import:

1. Pack Sprite Sheets: Combine frames into optimized sheets
2. Generate Import Files: Create .import with optimal settings
3. Configure Animations: Set up SpriteFrames resources

API Provider Selection

DALL-E 3 (OpenAI)

Best for high-quality, consistent results. Excellent prompt following.

--provider dalle --model dall-e-3

• Sizes: 1024x1024, 1792x1024, 1024x1792
• Quality: standard, hd
• Style: vivid, natural

Replicate (SDXL/Flux)

Best for style control and cheaper batch generation.

--provider replicate --model stability-ai/sdxl

• More model options (SDXL, Flux, specialized)
• Negative prompts supported
• ControlNet and img2img available

fal.ai

Best for rapid iteration and testing prompts.

--provider fal --model fal-ai/flux/schnell

• Fastest inference
• Good for prototyping
• Lower cost per image

Prompting by Art Style

Pixel Art

"pixel art [subject], 16-bit style, clean pixels, no anti-aliasing,
limited color palette, retro game sprite, transparent background"

Key modifiers: 16-bit, 8-bit, pixel art, retro, clean pixels, no anti-aliasing

Avoid: realistic, detailed, smooth, gradient

Hand-Drawn / Illustrated

"hand-drawn illustration of [subject], ink lines, watercolor texture,
sketch style, game art, white background"

Key modifiers: hand-drawn, illustration, ink lines, sketch, watercolor

Painterly / Concept Art

"digital painting of [subject], concept art style, painterly brush strokes,
dramatic lighting, game asset"

Key modifiers: digital painting, concept art, painterly, brush strokes

Vector / Flat Design

"flat design [subject], vector art style, clean edges, solid colors,
minimal shading, game icon, transparent background"

Key modifiers: flat design, vector, clean edges, solid colors, minimal

Script Reference

generate-image.ts

Generate a single image from any supported provider.

deno run --allow-env --allow-net --allow-write scripts/generate-image.ts [options]

Options:
  --provider <name>   Provider: dalle, replicate, fal (required)
  --prompt <text>     Generation prompt (required)
  --output <path>     Output file path (required)
  --model <name>      Specific model (optional, provider-dependent)
  --size <WxH>        Image size, e.g., 1024x1024 (default: 1024x1024)
  --style <name>      Style preset: pixel-art, hand-drawn, painterly, vector
  --negative <text>   Negative prompt (Replicate/fal only)
  --quality <level>   Quality: standard, hd (DALL-E only)
  --json              Output metadata as JSON
  -h, --help          Show help

batch-generate.ts

Generate multiple images from a specification file.

deno run --allow-env --allow-net --allow-read --allow-write scripts/batch-generate.ts [options]

Options:
  --spec <path>       Path to batch specification JSON (required)
  --output <dir>      Output directory (required)
  --concurrency <n>   Parallel requests (default: 2)
  --delay <ms>        Delay between requests (default: 1000)
  --resume            Resume from last successful
  --json              Output results as JSON
  -h, --help          Show help

Batch Spec Format:

{
  "provider": "replicate",
  "model": "stability-ai/sdxl",
  "style": "pixel-art",
  "basePrompt": "16-bit pixel art, game sprite, transparent background",
  "assets": [
    { "name": "player-idle", "prompt": "knight standing idle, front view" },
    { "name": "player-walk-1", "prompt": "knight walking, frame 1 of 4" },
    { "name": "player-walk-2", "prompt": "knight walking, frame 2 of 4" }
  ]
}

process-sprite.ts

Post-process generated images for game use.

deno run --allow-read --allow-write scripts/process-sprite.ts [options]

Options:
  --input <path>      Input image path (required)
  --output <path>     Output image path (required)
  --remove-bg         Remove background (make transparent)
  --resize <WxH>      Resize to dimensions
  --filter <type>     Resize filter: nearest, linear (default: nearest)
  --trim              Trim transparent whitespace
  --padding <n>       Add padding pixels
  --color-key <hex>   Color to make transparent (e.g., ff00ff)
  -h, --help          Show help

pack-spritesheet.ts

Pack multiple sprites into a sprite sheet.

deno run --allow-read --allow-write scripts/pack-spritesheet.ts [options]

Options:
  --input <pattern>   Input files (glob pattern, required)
  --output <path>     Output sprite sheet path (required)
  --columns <n>       Number of columns (default: auto)