godot-asset-generator

What this skill does

# 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

```bash
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

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

### Create Sprite Sheet

```bash
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

```json
{
  "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

```bash
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

| Provider | Best For | Quality | Cost | Speed |
|----------|----------|---------|------|-------|
| DALL-E 3 | Consistency, high detail | Excellent | $$$ | Medium |
| Replicate | Style control, variations | Very Good | $$ | Medium |
| fal.ai | Fast iteration, testing | Good | $ | Fast |

### DALL-E 3 (OpenAI)

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

```bash
--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.

```bash
--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.

```bash
--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.

```bash
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.

```bash
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:**
```json
{
  "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.

```bash
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.

```bash
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)
  --padding <n>       Padding b