Skip to content
Skills Library
Design & UX · Building & coding

generate2dmap

/generate2dmap

Generate production-oriented 2D game maps with `imagine_text_to_image`: RPG/top-down maps, side-scroller parallax stages, tilemaps, layered raster maps, prop packs, collision zones, and walkable areas. Use when building browser games that need real map art (not pure code-drawn tiles), layered props, or map collision metadata. Triggers on "map", "level", "stage", "tilemap", "overworld", "dungeon", "side scroller background", "prop pack", "2D map".

Repository
Cifra ↗
Licence
MIT
Last repository change
09.11.2026

Assessment and security

85/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene10 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
12
Scripts
2
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 09.11.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What to check before installing
  • 2 scripts in this package. Review them before installing, as Claude may execute them.

Scripts: scripts/compose_layered_preview.py, scripts/extract_prop_pack.py

What it does and when to use it

Generate production-oriented 2D game maps with `imagine_text_to_image`: RPG/top-down maps, side-scroller parallax stages, tilemaps, layered raster maps, prop packs, collision zones, and walkable areas. Use when building browser games that need real map art (not pure code-drawn tiles), layered props, or map collision metadata. Triggers on "map", "level", "stage", "tilemap", "overworld", "dungeon", "side scroller background", "prop pack", "2D map".

Triggers from the description

maplevelstagetilemapoverworlddungeonside scroller backgroundprop pack
Original author description

Generate production-oriented 2D game maps with `imagine_text_to_image`: RPG/top-down maps, side-scroller parallax stages, tilemaps, layered raster maps, prop packs, collision zones, and walkable areas. Use when building browser games that need real map art (not pure code-drawn tiles), layered props, or map collision metadata. Triggers on "map", "level", "stage", "tilemap", "overworld", "dungeon", "side scroller background", "prop pack", "2D map".

How it works

  1. App-builder / Grok environment
  2. Decide the pipeline first
  3. Art comes from image generation, and you write the prompts
  4. Keep runtime objects out of the base layer
  5. Reference mockups are checkpoints, not deliverables
  6. Depth for the pipeline you picked — open these before producing assets
Original SKILL.md headings · 108 lines, 949 words
SKILL.md preview
---
name: generate2dmap
description: >
  Generate production-oriented 2D game maps with `imagine_text_to_image`: RPG/top-down maps,
  side-scroller parallax stages, tilemaps, layered raster maps, prop packs,
  collision zones, and walkable areas. Use when building browser games that
  need real map art (not pure code-drawn tiles), layered props, or map
  collision metadata. Triggers on "map", "level", "stage", "tilemap",
  "overworld", "dungeon", "side scroller background", "prop pack", "2D map".
metadata:
  short-description: "2D game maps: layered art, props, collision metadata"
user-invocable: false
---

# Generate2dmap

## App-builder / Grok environment

| Item | Value |
| --- | --- |
| Skill dir / scripts | `.grok/skills/generate2dmap/`, run as `python3 .grok/skills/generate2dmap/scripts/<script>.py …` |
| Image tools | `imagine_text_to_image` / `imagine_image_to_image` (path-based; see **`imagine`**); inspect output with `read_file` on the PNG path (not Codex view_image) |
| Generated image path | `imagine_text_to_image` → sandbox `file_path` → copy into `assets/map/`; Pillow is preinstalled |
| Default `engine_target` | `raw_canvas` or `Phaser` for this TanStack browser sandbox — only use Godot/Unity/Tiled when the user explicitly wants those exports |
| Related skills | **`generate2dsprite`** (character/FX sprites; prop packs still use this skill's extract script), **`building-games`**, **`imagine`** |

## Decide the pipeline first

Build the smallest playable map bundle that satisfies the game: choose a
product-level `map_mode`, then the lower-level axes (`visual_model`,
`runtime_object_model`, `collision_model`, `engine_target`).

- `tile_mode` — editable tile/grid maps: Pokemon-like routes, top-down RPG towns, platformer tilemaps, or any project already on Tiled/LDtk/Godot/Unity/Phaser tilemaps.
- `scene_mode` — foundation base plus separate props: tower defense, survivors-like arenas, cozy top-down showcase maps.
- `side_scroll_mode` — parallax side-scroller stages: Mega Man-like, action platformers, Metroidvania rooms, runners, brawlers.
- `grid_mode` — rule-heavy grids: tactical RPGs, factory/automation, board/card battlers, build grids.
- `room_chunk_mode` — modular rooms/chunks: roguelike dungeons, Metroidvania networks, procedural assembly.
- `baked_scene_mode` — explicitly flat, non-playable scenes only: title/menu screens, battle backdrops, visual-novel scenes, concept art.

Use user-specified parameters when present; otherwise infer the lightest playable
pipeline from the existing game, camera, collision needs, map scale, and editing
needs. When mode and axes disagree, the mode's playable/editable contract wins.
Genre routing, per-mode axis defaults, presets, and the escalation heuristic are in
`references/map-strategies.md` — read it whenever the choice is not obvious.

**A playable map is never one baked image.** For any request implying a playable
map, level, stage, room, prototype, or engine scene, the deliverable must expose
gameplay geometry and objects as separate layers, props, tile/object data,
collision, zones, or engine-native scene nodes. A baked image may be a background,
reference, or preview artifact — never the runtime map — unless the user
explicitly asked for a flat background only.

**Scenes and maps only.** Do not generate character, enemy, boss, NPC, player,
projectile, or animation sprites here; those belong to `$generate2dsprite`. Maps
carry scene hooks (spawn markers, patrol/encounter zones, arena entrances, gates,
exits, camera triggers) as **metadata**, not as drawn art.

## Art comes from image generation, and you write the prompts

- `imagine_text_to_image` is the default art source for base maps, parallax plates,
  references, prop sheets, and tileset art. Default `art_style` is `clean_hd`
  (hand-painted HD, sharp readable shapes, low texture noise, no chunky pixels);
  use `pixel_inspired` or `retro_pixel` only when asked.
- **Write every creative prompt yourself.** Scripts may assemble, slice,
  chroma-key, crop, validate, compose previews, and emit JSON/engine files — never
  write creative prompts or draw final art. Procedural/placeholder art only when
  the user explicitly asks for placeholders, fixtures, debug maps, or scaffolding.
  With a tile engine target, generate the tileset art first, then script only the
  layers, collision, zones, and scene wiring.
- Save each prompt beside its asset as `<asset>.prompt.txt` (or an explicit
  manifest field) whenever the run creates new visual assets.
- **A reference handoff is a file path, not a sentence.** To build on an earlier
  image, pass its sandbox `file_path` to `imagine_image_to_image` (and `read_file`
  it so you can see it), then name the concrete features to preserve: camera
  framing, horizon, road/water shapes, terrain boundaries, entrances/exits,
  landmarks. A filename, "based on the map", or the image merely being visible in
  conversation is **not** a handoff — stop and pass the path.

## Keep runtime objects out of the base layer

The first generated base/background/foundation image may hold only stable, non-interactive
foundation art — ground material, paths, roads, water, cliffs, floor patterns, lane
markings and build pads; for side views sky, far/mid scenery, silhouettes, atmosphere; for
tilemaps tileset art as editable layers. It must **not** contain tall props, buildings,
trees, rocks, crates, signs, doors, gates, pickups, chests, checkpoints, hazards, traps,
turrets, ladders, foreground occluders, destructibles, actors, enemies, NPCs, UI, labels,
or anything needing collision, interaction, reuse, y-sorting, animation, or its own render
order — regenerate a foundation-only base, or demote such an image to a reference
artifact.

## Reference mockups are checkpoints, not deliverables

Dressed references (top-down) and stage references (side-view) plan placement in-world:
natural game-world objects or subtle blockout geometry, at most **9 distinct visible
object candidates** (repeats count once, then recur in placement metadata), **no
annotation graphics** (circles, arrows, outlines, labels, text, callouts, legends,
measurement lines), and no non-visual metadata — spawns, triggers, patrol hints, camera
bounds are written later as scene hooks.

**Having generated one, do not stop there.** Continue through
`references/object-production-gate.md`: re-`read_file` both images, build the object
list, generate the final separate objects, write placement / collision / scene-hook
metadata, compose the QA preview. Reference-only output is an incomplete run unless
the user explicitly asked for a concept image.

## Depth for the pipeline you picked — open these before producing assets

- Layered raster maps → `references/layered-map-contract.md` (layer types, base and
  prop prompt patterns, prop metadata, render order, collision, QA checklist).
- `side_scroll_mode` → `references/side-scroll-stages.md`: the `stage_canvas`
  decision, the named scenery-only parallax layers, and the mandatory in-world
  stage reference before any platform/object work.
- Any prop or scene-object generation → classify each object first, then follow
  `references/prop-pack-contract.md`: only compact props may share a square prop
  pack; platforms, floors, bridges, gates, buildings and anything collision-aligned
  go one-by-one, as a platform strip, a custom wide pack, or tile/object layers.
- Parameters, the step-by-step workflow, and the `extract_prop_pack.py` /
  `compose_layered_preview.py` commands → `references/pipeline.md`.
- Deliverable lists per pipeline and the validation checklist →
  `references/deliverables.md`; run both before calling a map done.
Files in this package (12)
  • LICENSE 1 KB
  • SKILL.md 8 KB
  • SOURCE.md 1 KB
  • references/deliverables.md 7 KB
  • references/layered-map-contract.md 8 KB
  • references/map-strategies.md 26 KB
  • references/object-production-gate.md 3 KB
  • references/pipeline.md 16 KB
  • references/prop-pack-contract.md 9 KB
  • references/side-scroll-stages.md 5 KB
  • scripts/compose_layered_preview.py 5 KB
  • scripts/extract_prop_pack.py 13 KB

Versions

RepositoryScoreLicence
This page · 0x4865696261/Cifra85MIT
0x0funky/agent-sprite-forge100MIT

Database snapshot: 13.11.2026 · package version 7d8e2f0cfe9f (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 100tilemaps
    Use this skill when working with tilemaps in Phaser 4. Covers loading Tiled JSON maps, creating tilemap layers, tile collision, dynamic tiles, tile properties, and tilemap camera culling. Triggers on: Tilemap, Tiled, tilemap layer, tile collision, tile properties.
  • 100tilemap-data-format
    Use when designing the map data format (layers, tiles, objects, metadata) so maps are editable, versionable, and engine-agnostic.
  • 100game-art-director
    Use when the user asks for game art end to end in one request. Examples are "make 40 props for my low-poly dungeon", "build an asset pack for my game", "I need all the art for a cozy farm level", "give my Godot game a prop library" or "be my art department". Orchestrates the…
  • 100scenario-game-assets
    Use when creating game art through Scenario MCP: sprites, sprite sheets, icons, props, loot, tilesets and autotile terrain transitions, seamless tiles, isometric buildings, top-down maps, pixel art, UI buttons and panels, parallax background layers or depth planes for…
  • 100rpg-map-creator
    Expert RPG map creation and generation for tabletop and online games. Specializes in creating visual descriptions and optimized prompts for z-image turbo model in ComfyUI. Covers all map types (world/continent, regional/local, battle/encounter, dungeon/interior) across multiple…
  • 100codeart2d
    Explicit-only last resort. Draws game art from code, with no image model - pixel sprites from a PixelSpec, flat vector props, UI and icons from portable SVG, rigged characters with planted feet, FX with a JS runtime, seam-proven autotiles, playable top-down layouts with…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.