/game-image-generation-rules

name: game-image-generation-rules
description: Plan, generate, inspect, vision-evaluate, refine, and package images and visual assets for game development through a backend-agnostic production loop. Use for PNG or SVG props, icons, characters, environments, tiles, UI, HUD/gameplay screens, VFX, transparent cutouts, concept or worldbuilding boards, sprite sheets, static sprite collections, or animation frames; especially when the task needs batch generation, native prompts or ComfyUI/Stable Diffusion Danbooru tags, reference consistency, background removal, format validation, or iterative quality scoring. This skill orchestrates available image, image-edit, vision, SVG, MCP, local, and host-native tools without requiring a specific generator.

Game Image Generation Rules

Treat image generation as an asset-production pipeline, not a single prompt. Keep the active brief, prompts, and evaluation evidence in the model context while the task runs.

Core loop

Run:

PLAN → GENERATE → NORMALIZE/INSPECT → EVALUATE
     → ACCEPT OR EDIT/REGENERATE → RE-EVALUATE → OUTPUT

Do not generate before defining the deliverable contract and evaluation criteria. Do not deliver an uninspected asset.

1. Plan the asset contract

Maintain a concise working plan in the model context. Do not create plan, manifest, or log files unless the user explicitly asks for persistent records.

Resolve:

• in-game purpose and viewing distance;
• asset family: icon, prop, character, portrait, environment, tile, UI, VFX, sheet, or animation;
• SVG versus raster, canvas size, aspect ratio, color space, alpha or blend-mode requirement, and engine constraints;
• camera/projection, silhouette, pose, scale, lighting, palette, material, and style invariants;
• references and the role of each reference;
• animation timing, loop behavior, frame count, pivot, cell size, and sheet layout when applicable;
• any user-supplied generation limits and the acceptance rubric.

Separate **hard gates** from **quality criteria**. Define both before generation. Read:

• `references/backend-routing.md` to select and preflight generators/editors;
• `references/prompting.md` to compile native prompts or Danbooru tags;
• `references/game-asset-patterns.md` for individual asset, character-sheet, static sprite collection, environment, tile, and panorama patterns;
• `references/game-hud-patterns.md` for complete gameplay-screen and HUD compositions;
• `references/game-gallery-patterns.md` for multi-panel worldbuilding, mixed design, and character-roster boards.

2. Route by artifact type

Choose the simplest production path that preserves the requested properties:

• **SVG**: construct or generate vector-native markup, then validate it through `references/svg-workflow.md`.
• **Raster PNG**: generate at or above delivery size, preserve a clean subject silhouette, then normalize and inspect.
• **Transparent or composited VFX raster**: use native alpha or a removable matte for normal transparency. For emissive-only VFX, black-background additive delivery may replace alpha extraction when the target engine/material supports it. Validate the selected path through `references/raster-and-alpha.md`.
• **Gameplay screen or HUD composition**: use `references/game-hud-patterns.md`; treat the result as a screen concept unless its UI components are separately constructed and validated.
• **Sprite sheet or animation frames**: follow `references/sprite-sheet/sprite-sheets.md` to select one of 3 routes: video-generation, reference-sheet, or direct sheet-generation.

3. Compile prompts from one semantic source

Write one backend-neutral semantic prompt as the source of truth. Derive, do not independently invent:

1. a native-language prompt for instruction-following image models; 2. a positive Danbooru-style tag list for compatible SD/ComfyUI checkpoints; 3. a separate negative prompt only when that backend uses one; 4. edit instructions that state the transformation first and repeat preserved invariants.

Keep format, layout, identity, and content constraints distinct from style modifiers. Keep the current compiled prompts in context and pass them directly to the selected backend.

4. Generate batches

Preflight available capabilities: generate, edit, mask/inpaint, reference images, multi-reference, alpha, seed, batch, SVG, video, and output-size limits. Do not name or require a particular skill/tool unless it is actually available and chosen.

Distinguish two batch modes:

• **Direct asset batch**: each output is a different usable asset. Generate directly into the requested target directory with deterministic final filenames, then validate every asset independently.
• **Variant batch**: multiple attempts compete for one asset slot. Keep their roles clear with short-lived labels, compare them, and deliver only accepted output.

Keep prompts, relevant parameters, comparison reasons, and iteration state in the current model context. Avoid changing every variation axis at once.

5. Normalize and inspect

Before aesthetic judging, apply deterministic checks:

• file is structurally complete, decodes successfully where supported, and format matches the contract;
• exact dimensions/aspect ratio;
• the selected transparency/compositing path is valid: real alpha for alpha assets, or intentional pure black plus a declared blend mode for additive VFX;
• no clipped pixels, edge halos, accidental borders, or unintended/excessive empty padding; preserve the contracted safe margin;
• grid/cell geometry is divisible and consistent;
• animation frames have stable canvas, pivot, scale, identity, and ordering;
• SVG passes objective XML, reference, numeric geometry, path, and transform checks plus text-only shape review; formal SVG additionally passes one render/view, individually or within a readable labeled atlas.

Run `scripts/inspect_image.py` for basic PNG metadata and any relevant optional size, color-type, alpha, border, padding, or sheet-g