Languages: English | 繁體中文 | 简体中文 | 日本語 | 한국어

Agent Sprite Forge banner

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

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.

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.

image_gen map + separated props + tower sheets + enemy animation sheets + HUD icons + Godot gameplay wiring

image_gen map + directional hero sheets + summon/evolution sheets + enemy sheets + FX/HUD icons + Unity runtime + WebGL deploy

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

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.

Layered cyberpunk canal RPG map preview
Flattened layered RPG map preview

layered_raster + y_sorted_props + precise_shapes + trigger_zones + raw_canvas

$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

Godot output includes editable TileMapLayer nodes, independent Sprite2D props, encounter grass Area2D zones, StaticBody2D collision blockers, exit Area2D zones, and a debug player/camera.

image_gen tileset + prop_pack_3x3 + layered_tilemap + separate_props + trigger_zones + Godot_TileMap

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.

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.

$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.

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.

• 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

Clone the repo, install the local processor dependencies, then copy both skills into your Codex skills directory:

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\"

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.

The local post-processor depends on:

• Pillow
• numpy

They are listed in 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.

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

Use $generate2dsprite to create a 3x3 idle for an ultimate earth titan.

Use $generate2dsprite to create a side-view lightning knight attack animation.

Use $generate2dsprite to create a late-Sengoku player_sheet for a wandering fire swordsman.

Use $generate2dsprite to create a wizard spell bundle with cast, projectile, and impact sprites.

Use $generate2dmap to create a small fixed-screen pixel-art battle arena with simple collision.

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.

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.

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.

• 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.

MIT. See LICENSE.