# Agent Sprite Forge Languages: [English](./README.md) | [繁體中文](./README.zh-TW.md) | [简体中文](./README.zh-CN.md) | [日本語](./README.ja.md) | [한국어](./README.ko.md)

Codex skills for game-ready 2D sprites, layered maps, and engine-ready prototypes.

Ask in natural language. Codex plans the asset pipeline, renders with built-in image generation, then local processors clean, split, validate, and export assets for Godot, Unity, or raw 2D game workflows.

Showcase · Skills · Install · Prompts · Star History

## What Makes It Different Agent Sprite Forge is not just a folder of prompts. It is a Codex-first 2D game asset workflow where the agent decides the plan, image generation creates the raw visuals, and deterministic scripts turn those visuals into reusable game assets.

Sprite sheets
Characters, monsters, props, attacks, spells, projectiles, impacts, idles, walks, and reference-guided variants.

Layered maps
Ground-only bases, dressed references, prop packs, transparent props, y-sort placement, collision, zones, and previews.

Engine handoff
Godot scenes, editable TileMap layers, separated props, encounter grass, collision bodies, exits, and debug players.

Local cleanup
Chroma-key removal, frame extraction, alignment, transparent PNG/GIF export, prop-pack slicing, and QA metadata.

## Showcase ### Engine-Ready Prototypes These examples were assembled with Codex using `agent-sprite-forge` workflows. They are meant to show the full loop: generated assets, structured scene data, and playable prototype wiring.

Summon Survivors — Unity WebGL Generated map art, hero sheets, summons, evolutions, enemies, bosses, pickups, HUD, FX, level-up choices, and WebGL deployment. Play build · Build conversation	Forest Pass Defense — Godot Tower Defense A Godot 4 prototype with map, separated props, tower slots, towers, enemy sheets, boss/flying enemies, waves, HUD, build/upgrade/sell flow, projectiles, and targeting rules.
Editable RPG Map — Godot TileMap Image-generated tileset and prop sheet wired into editable `TileMapLayer`, `Sprite2D` props, encounter grass `Area2D`, `StaticBody2D` collision, exits, metadata, and debug player/camera.	Neon Breach — Cyberpunk Side-Scroller A playable side-scroller prototype built around generated character, attack, map, and gameplay assets.
Sengoku Era — JavaScript Pokémon-like A browser-based RPG prototype with generated characters, starter selection, map flow, and battle UI. Play build	Starter selection and battle loop A compact JavaScript game showcase built from sprite, monster, battle, and map assets generated through the skill workflow.

More Godot tower-defense output

Enemy roster, including flyer and boss units

Tower lineup

HUD and gameplay icons

Godot prototype output includes: - `scenes/ForestPass.tscn` with base map, separated props, enemy paths, tower slots, and HUD nodes. - Six tower families with generated tower art and upgrade stages. - Animated enemy sheets for ground units, flying units, and boss encounters. - Wave, difficulty, tower catalog, collision, route, and tower-slot metadata. - Runtime build, upgrade, sell, projectile, and targeting behavior connected in Godot. ```text image_gen map + separated props + tower sheets + enemy animation sheets + HUD icons + Godot gameplay wiring ```

More Unity survivors-like output

Summon Survivors Unity WebGL gameplay with summons, enemies, pickups, HUD, and objective

Unity WebGL gameplay: summons, enemies, pickups, HUD, and objective flow

Summon Survivors Unity WebGL level-up menu

Level-up choices: summon unlocks, training, stats, and recovery

Unity prototype output includes: - `Assets/Survivors/Scenes/SummonSurvivors.unity` as the playable scene. - `SurvivorContentDatabase.asset` connecting generated hero, summon, enemy, pickup, HUD, and FX sprites. - Starter summon selection, survival objective, XP/coin pickups, level-up choices, summon training, and evolution flow. - Enemy spawning pressure, boss timing, projectile attacks, area damage, health bars, and score tracking. - WebGL build output under `Builds/WebGL` with Vercel deployment config. ```text image_gen map + directional hero sheets + summon/evolution sheets + enemy sheets + FX/HUD icons + Unity runtime + WebGL deploy ```

### Sprite Sheets And FX Use `$generate2dsprite` when you need animated units, playable characters, monsters, props, spell bundles, projectile/impact FX, or reference-guided variants.

Text to sprite
Attack animation from a plain-language request.

Character action
Compact 2D action sheet with transparent export.

Spell cast
Bundle-friendly cast animation.

Projectile
Matching projectile / impact workflows.

Down

Left

Right

Reference	Reference-guided sprite animation
Reference	Reference-guided character action

### Layered RPG Map Pipeline Use `$generate2dmap` when you need maps instead of isolated sprites. For readable layered raster maps, the current workflow prefers a clean hand-painted HD game-map style: ground-only base first, dressed reference second, prop pack third, then transparent prop extraction and layered preview composition.

Ground-only cyberpunk canal RPG base map

Ground-only base

Dressed reference

3x3 prop pack

Layered cyberpunk canal RPG map preview
Flattened layered RPG map preview

```text layered_raster + y_sorted_props + precise_shapes + trigger_zones + raw_canvas ``` ### Godot Editable TileMap Export `$generate2dmap` can also produce an editable Godot map project instead of a single flattened image. This showcase uses an image-generated tileset and 3x3 prop sheet, then wires them into a Godot 4.5 scene.

Generate2DMap Godot editor scene with editable TileMapLayer and nodes
Godot editor scene: editable layers, props, zones, collision, exits, and debug player

Layered map preview	Collision and zone debug overlay
Image-generated tileset atlas	3x3 generated prop pack

Godot output includes editable `TileMapLayer` nodes, independent `Sprite2D` props, encounter grass `Area2D` zones, `StaticBody2D` collision blockers, exit `Area2D` zones, and a debug player/camera. ```text image_gen tileset + prop_pack_3x3 + layered_tilemap + separate_props + trigger_zones + Godot_TileMap ``` ### Playable Game Prompt Examples

Cyberpunk side-scroller prompt

```text use $generate2dsprite to create a 2D side-scrolling game similar to Mega Man. It should include attack mechanics, map elements, and all the essential features. I would like you to design it, and all the necessary assets should be created using this skill. It needs to be an actually playable game, with a cyberpunk story setting. ```

Sengoku Pokémon-like prototype

Link: Play the JavaScript browser build

Starter selection

Battle scene

```text Use $generate2dsprite to create a 2D game similar to Pokemon. You only need to build one scene for now. It must include a starter monster selection mechanic, a battle screen, and all basic gameplay functions. I would like you to design all the elements and the story, and you can also decide which game engine to use. Use this skill to create any assets you need. The story should be set in the Sengoku period. ```

## Included Skills | Skill | Use it for | Output | | --- | --- | --- | | [`generate2dsprite`](./skills/generate2dsprite) | Sprites, animation sheets, props, spell bundles, FX, reference variants, optional layout guides for fixed-frame sheets | Raw sheet, cleaned transparent sheet, frames, GIFs, metadata | | [`generate2dmap`](./skills/generate2dmap) | Baked maps, layered raster maps, clean HD RPG maps, prop packs, collision/zones, Godot-editable scenes | Base map, dressed reference, prop pack, extracted props, preview, scene metadata | `$generate2dmap` only uses `$generate2dsprite` when the selected map pipeline needs reusable transparent props. Small environmental props can be batched into `2x2`, `3x3`, or `4x4` prop packs, then extracted into individual transparent props. Simple maps can stay as a single baked image. When a visual reference is involved, both skills follow the same wrapper rule: make the image visible in the conversation first. Attached images and freshly generated images are already visible; local files should be opened with `view_image` before asking built-in image generation to preserve identity, style, map layout, or sprite lineage. ## How It Works 1. The user asks Codex for a sprite, prop pack, map, or engine-ready prototype. 2. The agent chooses the asset type, action, bundle shape, sheet layout, frame count, style, and alignment strategy. 3. Built-in image generation creates the raw visual asset. 4. Local scripts run deterministic post-processing: chroma-key cleanup, despill, frame extraction, alignment, prop-pack slicing, GIF/PNG export, and validation metadata. 5. For maps and prototypes, Codex can also assemble placement metadata, collision, trigger zones, Godot scenes, or Unity project wiring. The script is not the creative brain. The agent makes the visual and pipeline decisions; the Python tools only perform repeatable pixel and export operations. ## What It Can Generate - Creatures, characters, players, NPCs, props, and monsters - Spell casts, projectiles, impacts, explosions, and FX sheets - Small bundles such as `unit_bundle`, `spell_bundle`, and `combat_bundle` - Reference-guided sprite variants, animation sheets, and evolution lines - Single baked maps, clean HD layered maps, prop-pack maps, and flattened previews - Collision and zone metadata for playable maps - Godot-ready editable maps with `TileMapLayer`, separate props, encounter grass, collision, exits, and debug player scenes - Prototype-scale Godot and Unity scenes when the user asks Codex to wire assets into an engine project ## Install ### Option 1: Windows PowerShell Clone the repo, install the local processor dependencies, then copy both skills into your Codex skills directory: ```powershell git clone https://github.com/0x0funky/agent-sprite-forge.git cd .\agent-sprite-forge python -m pip install -r .\requirements.txt New-Item -ItemType Directory -Force -Path "$env:USERPROFILE\.codex\skills" | Out-Null Copy-Item -Recurse -Force ` ".\skills\*" ` "$env:USERPROFILE\.codex\skills\" ``` ### Option 2: macOS / Linux ```bash git clone https://github.com/0x0funky/agent-sprite-forge.git cd ./agent-sprite-forge python3 -m pip install -r ./requirements.txt mkdir -p ~/.codex/skills cp -R ./skills/* ~/.codex/skills/ ``` Start a new Codex session after installation so the skills are loaded cleanly. ## Python Requirements The local post-processor depends on: - `Pillow` - `numpy` They are listed in [`requirements.txt`](./requirements.txt). Codex handles image generation itself, but these Python packages are still needed for magenta background removal, frame splitting, bounding-box extraction, alignment/rescaling, transparent GIF/PNG export, and prop-pack slicing. ## Repository Layout ```text agent-sprite-forge/ README.md README.zh-TW.md README.zh-CN.md README.ja.md README.ko.md requirements.txt src/ skills/ generate2dmap/ SKILL.md agents/ openai.yaml references/ layered-map-contract.md map-strategies.md prop-pack-contract.md scripts/ compose_layered_preview.py extract_prop_pack.py generate2dsprite/ SKILL.md agents/ openai.yaml references/ modes.md prompt-rules.md scripts/ generate2dsprite.py make_layout_guide.py ``` ## Suggested Prompts ### Sprite ```text Use $generate2dsprite to create a 3x3 idle for an ultimate earth titan. ``` ```text Use $generate2dsprite to create a side-view lightning knight attack animation. ``` ```text Use $generate2dsprite to create a late-Sengoku player_sheet for a wandering fire swordsman. ``` ```text Use $generate2dsprite to create a wizard spell bundle with cast, projectile, and impact sprites. ``` ### Map ```text Use $generate2dmap to create a small fixed-screen pixel-art battle arena with simple collision. ``` ```text Use $generate2dmap to create a top-down RPG forest shrine map. Use a layered raster pipeline, a 3x3 prop pack for small environmental props, precise collision, encounter grass zones, a rest point, and actors that can walk in front of and behind tall props. ``` ```text Use $generate2dmap to create a Godot-editable RPG map with separated props, encounter grass Area2D zones, collision StaticBody2D blockers, exit zones, and a debug player scene. ``` ## What You Get For a typical sprite sheet output: - `raw-sheet.png` - `raw-sheet-clean.png` - `sheet-transparent.png` - Frame PNGs - `animation.gif` - `prompt-used.txt` - `pipeline-meta.json` For player walk sheets, you also get direction strips and per-direction GIFs. For a map output, the result depends on the chosen pipeline: - Single baked map: complete map image, optional prompt file, and optional collision metadata. - Layered raster map: base map, dressed reference, prop folders or prop-pack extraction manifest, prop placement metadata, collision/zones metadata, and flattened layered preview. - Godot editable map: tileset/prop assets, scene files, layer metadata, collision/zones, exits, and debug player setup. ## Notes - Best results come from prompts that clearly specify view, action, and desired motion style. - Large creatures often work better as `3x3 idle`. - Small spells and projectiles often work better as `1x4`, `2x2`, or `2x3`. - Layout guides are useful for fixed-frame action sheets and prop packs, but they are not always better for compact attack sheets. - For commercial projects, prefer original characters or IP that you control. ## Star History

## License MIT. See [LICENSE](./LICENSE).