SuperAPI AI Directory
Partner with us中文AI newsFavorites
Skillsmeitu-game-2d-assets

meitu-game-2d-assets

General & other

View repository

Updated 10-16 06:46

About this skill

meitu-game-2d-assets

Overview

Produce asset sketches and semi-finished assets for 2D games that can go directly into subsequent art workflows, with a focus on:

  1. Standalone assets: icons, props, weapons, coins, treasure chests, potions, small UI objects
  2. Character assets: character key art, enemy concept art, NPC half-body or full-body designs
  3. Grid assets: 2x2/3x3 sprite sheets, simple action frames, tileset sketches
  4. Asset organization: transparent-background export, grid splitting, clarity enhancement, local repainting

The goal of this Skill is not to create complete game scene key art, 3D modeling, or complex skeletal animation, but to quickly produce iterable 2D asset base drafts for game designers, artists, and indie developers.

Dependencies

  • tools: meitu-cli
    • text-to-image - Generate standalone assets, character concepts, sprite sheets, or tileset sketches from text
    • image-edit - Make local modifications based on a reference image, continue the style for batch variants, and fix details
    • image-cutout - Cut out generated results into transparent-background assets
    • image-grid-split - Split a sprite sheet / grid image into individual frames
    • image-superres-enhance - Perform super-resolution and sharpening enhancement on low-resolution assets
  • credentials: Meitu AI Open Platform API credentials
    • Environment variables:MEITU_OPENAPI_ACCESS_KEY / MEITU_OPENAPI_SECRET_KEY
    • Or configuration file:~/.meitu/credentials.json
    • Validation:meitu auth verify --json
  • workspace (optional): {OPENCLAW_HOME}/workspace/visual/
    • Not found -> skip all knowledge reads, skill works without it

Path alias: below, $VISUAL = {OPENCLAW_HOME}/workspace/visual/

Core Workflow

Preflight -> [Context] -> Execute -> Refine -> Deliver -> [Record]
             ^ 创意型任务执行                  ^ 项目模式时执行
             ^ 一次性模式跳过 Context         ^ 一次性模式跳过

Preflight

  1. meitu --version -> if not installed, prompt npm install -g meitu-cli
  2. meitu auth verify --json -> if credentials are invalid, guide configuration
  3. Detect mode: cwd has openclaw.yaml -> project mode; else -> one-off can_record = cwd has openclaw.yaml AND $VISUAL exists (false if either is missing)
  4. Resolve output_dir: openclaw.yaml -> ./output/ | else -> $VISUAL/output/meitu-game-2d-assets/ mkdir -p {output_dir}
  5. Parse the minimum asset specifications from the user request:
    • asset_type：icon | prop | character | enemy | tileset | sprite-sheet
    • style：pixel | flat-vector | hand-painted | chibi-cartoon | retro-rpg | custom
    • ratio: if unspecified, automatically fill in the default value based on the asset type

Context (executed in project mode / skipped in one-off mode)

mode = one-off -> skip this step and go directly to Execute. The following applies only to project mode:

  1. Read ./DESIGN.md, extract the worldview, theme, platform, character settings, UI style, and target resolution
  2. If DESIGN.md mentions brand or project assets, read as needed $VISUAL/assets/
  3. Read $VISUAL/rules/quality.yaml -> forbidden list
  4. Read $VISUAL/memory/global.md -> global art preferences
  5. From openclaw.yaml read project.types(array takes priority) or project.type -> for each type, read $VISUAL/memory/scenes/{type}.md

Purpose of context:

  • Unify asset style, color palette, outline thickness, and worldview elements
  • Avoid generating assets that conflict with the existing project's art direction

Execute

First classify the task

Scenario Condition Primary tool path
A - Generate standalone assets from scratch No reference image, generate icons/props/characters text-to-image
B - Modify assets based on a reference image The user provides a reference image or old assets image-edit
C - Generate sprite sheet / frame sequence sketches Explicitly mentions 2x2/3x3/four-grid/action frames text-to-image -> image-grid-split
D - Export with transparent background Needs transparent assets that can be directly placed into an engine/PS image-cutout
E - Improve clarity The result is too blurry, needs to be enlarged, needs high definition image-superres-enhance

Style Identification Decision Table

User Keywords style_id Description
pixel, pixel art, 8bit, 16bit, retro pixel pixel Crisp pixel edges, limited palette, avoid anti-aliasing
flat, vector, mobile game UI, cartoon icons flat-vector Flat vector, clean outlines, easy to re-layout
hand-drawn, thick paint, Japanese style, concept art feel hand-painted Hand-drawn texture feel, better suited for character and enemy design
chibi, cute style, chibi chibi-cartoon Big head, small body, suitable for casual game characters
side-scrolling platformer, RPG, retro adventure retro-rpg Suitable for weapons, monsters, tiles, and small UI objects
other specified style custom Assemble prompt according to user description

Default Ratio Mapping

asset_type Default ratio Description
icon / prop / tileset 1:1 Convenient for slicing and importing
character / enemy 3:4 Suitable for character art and standing poses
sprite-sheet 1:1 Unified grid canvas, later split by grid

Prompt Assembly Rules

From references/prompts.md select:

  1. ## Style Prompts corresponding style section in
  2. ## Asset Templates corresponding asset_type section in
  3. If it is a sprite sheet, append ## Grid Constraints
  4. If the user requests a transparent background or easy cutout, append a solid background or blank space constraint

Scenario A - Generate a single asset from scratch

Applicable: icons, weapons, treasure chests, potions, single characters, enemy sketches

Command:

meitu text-to-image \
  --skill_name skill_meitu-game-2d-assets  \
  --prompt "{ASSET_PROMPT}" \
  --size 2K \
  --ratio {ratio} \
  --json --download-dir {output_dir}

Recommended prompt structure:

{style_prompt} {asset_template} game asset, centered composition, clean silhouette, readable at small size, consistent material rendering

Scenario B - Modify assets based on reference images

Applicable:

  • The user already has old assets and wants to change colors/materials/weapons/clothing
  • Wants to preserve the design language and expand a set of variants
  • Wants to unify the style of multiple assets

Command:

meitu image-edit \
  --skill_name skill_meitu-game-2d-assets  \
  --image_list "{ref_image_url}" \
  --prompt "{EDIT_PROMPT}" \
  --ratio {ratio} \
  --json --download-dir {output_dir}

Prompt constraints:

  • Keep the subject's recognizable silhouette
  • Clearly state what to keep and what to replace
  • If making game icons, must emphasize clean silhouette and small-size readability

Scenario C - Generate sprite sheet / frame sequence sketches

Applicable:

  • Character idle 4 frames
  • Treasure chest opening 4 frames
  • Fire/explosion 4 or 9 frames
  • Simple tileset sketch

First step: generate the grid image first:

meitu text-to-image \
  --skill_name skill_meitu-game-2d-assets  \
  --prompt "{SPRITESHEET_PROMPT}" \
  --size 2K \
  --ratio 1:1 \
  --json --download-dir {output_dir}

Second step: split frames only after the user confirms the grid is reasonable:

meitu image-grid-split \
  --skill_name skill_meitu-game-2d-assets  \
  --image_url "{grid_image_url}" \
  --json --download-dir {output_dir}/split

SPRITESHEET_PROMPT must include:

  • Total frame count description (e.g., 2x2 sprite sheet, 4 frames, 3x3 tileset）
  • Spacing between frames
  • Each cell's subject is independent and complete
  • Fixed camera and consistent character proportions

If image-grid-split returns insufficient frames:

  1. Strengthen the spacing requirements in the prompt
  2. Regenerate the grid
  3. If still insufficient, keep the grid image and inform the user that manual-assisted splitting is needed

Scenario D - Export transparent background assets

Applicable:

  • The user wants a PNG with transparent background
  • The generated image needs to go into Unity, Godot, Cocos, PS

Command:

meitu image-cutout \
  --skill_name skill_meitu-game-2d-assets  \
  --image_url "{asset_image_url}" \
  --json --download-dir {output_dir}

For clearly graphic assets such as icons and stamps, append --model_type 2; for characters, pets, or uncertain types, omit this parameter and let the server automatically select the type.

Priority strategy:

  • Single-subject assets with clear rules should prioritize transparent background export
  • If the asset background is complex and cutout fails, first use image-edit to redo a solid-background version, then image-cutout

Scenario E - Clarity Enhancement

Applicable:

  • The user says the result is blurry
  • Needs to export to a higher resolution
  • Pixel-art sketches need clearer edge presentation

Command:

meitu image-superres-enhance \
  --skill_name skill_meitu-game-2d-assets  \
  --image_url "{asset_image_url}" \
  --prompt "{CONTENT_DESC}" \
  --json --download-dir {output_dir}

Notes:

  • Before pixel-art super-resolution, first remind the user: if the goal is to preserve the pixel graininess, prioritize the integer-multiple upscaling approach and avoid excessive smoothing

Refine

Creative scenarios must go through an independent refinement loop, recommended at most 3 rounds:

  1. Show the current result and explain its asset_type, style, and whether it is suitable for further splitting/cutout
  2. Classify feedback into the following categories:
Feedback Type Example Handling Method
Change style "Change to pixel style" "More like a Japanese RPG" Switch style prompt and regenerate
Change subject "The sword is too short" "Change the character to a mage" Modify the asset template or edit prompt
Change readability "Can't see clearly after shrinking" Strengthen silhouette / contrast / simple shape
Change frame animation "The difference between the four frames is not big enough" Strengthen the action description for each frame and regenerate the sprite sheet
Export request "Give me a transparent background" "Split into individual images" Enter the cutout / grid-split path
Satisfied "OK" "This is fine" Enter Deliver
  1. For sprite sheets, you must first confirm the grid composition and frame spacing before performing the split
  2. For character or prop assets, if the user wants to keep the same worldview, subsequent variants should prioritize image-edit

Deliver

The file is already in output_dir, just rename it according to the asset type:

  • Single asset:{YYYY-MM-DD}_{style}_{asset-type}_{slug}.{ext}
  • Split frames:{YYYY-MM-DD}_{style}_{asset-type}_frame-{n}.{ext}
  • Transparent background:{YYYY-MM-DD}_{style}_{asset-type}_cutout.png
  • Super-resolution version:{YYYY-MM-DD}_{style}_{asset-type}_hd.{ext}

Example:

  • 2026-05-19_pixel_prop_health-potion.png
  • 2026-05-19_flat-vector_icon_treasure-chest_cutout.png
  • 2026-05-19_chibi-cartoon_character_knight_frame-3.png

Record (executed in project mode)

can_record = cwd has openclaw.yaml AND $VISUAL exists (if either is missing, it is false) -> skip when false.

Recordable content:

  • The user's long-term preferred style (e.g., pixel-leaning, thick outlines, low saturation)
  • Project-wide constraints (e.g., tiles must be top-down view, characters must be 3/4 view)
  • Asset naming conventions and commonly used ratios

Only write to memory when the user explicitly approves a certain style direction, to avoid mistakenly recording temporary attempts as long-term preferences.

Output

  • 2D game asset sketches or semi-finished images
  • Optional: transparent-background PNG
  • Optional: split individual sprite frames
  • Optional: super-resolution enhanced version

Constraints

  • Does not handle 3D models, skeletal animation, long video animation, or complete scene map design
  • Sprite sheets are only suitable for concept-level or simple action frames, and strict frame-by-frame animation industry standards are not guaranteed
  • If the user requests "completely consistent continuous multi-action animation for a character," it should be clearly stated that this is a highly constrained scenario, and it is recommended to finalize the character first and then generate in batches
  • If the user does not provide a size unit, it will be generated by default based on visual proportion and readability, and no pixel-level engine specifications are guaranteed.