Unity Level Design Patterns skill.

v0.1.0

Use when creating Unity game scenes and prototypes, building level designs, or automating Unity Editor workflows for terrain, lighting, environment setup, an...

2· 609·2 current·2 all-time
byyoussef mostafa rabea@cryptorabea

Install

OpenClaw Prompt Flow

Install with OpenClaw

Best for remote or guided setup. Copy the exact prompt, then paste it into OpenClaw for cryptorabea/level-design-patterns.

Previewing Install & Setup.
Prompt PreviewInstall & Setup
Install the skill "Unity Level Design Patterns skill." (cryptorabea/level-design-patterns) from ClawHub.
Skill page: https://clawhub.ai/cryptorabea/level-design-patterns
Keep the work scoped to this skill only.
After install, inspect the skill metadata and help me finish setup.
Use only the metadata you can verify from ClawHub; do not invent missing requirements.
Ask before making any broader environment changes.

Command Line

CLI Commands

Use the direct CLI path if you want to install manually and keep every step visible.

OpenClaw CLI

Bare skill slug

openclaw skills install level-design-patterns

ClawHub CLI

Package manager switcher

npx clawhub@latest install level-design-patterns
Security Scan
VirusTotalVirusTotal
Benign
View report →
OpenClawOpenClaw
Benign
high confidence
Purpose & Capability
The name/description match the included Editor scripts and reference docs: terrain generation, lighting, player controllers and scene automation. One discrepancy: registry metadata claimed this was instruction-only with no code files, but the file manifest includes multiple Unity Editor scripts (C#). The scripts are appropriate for the stated purpose, but the metadata/manifest mismatch is an integrity concern.
Instruction Scope
SKILL.md instructs the agent to use Unity Editor automation for terrain, lighting, environment placement, and player setup. The instructions and example code operate only on Unity scene objects, AssetDatabase, RenderSettings, and local file export (via SaveFilePanel). They do not reference unrelated system paths, network endpoints, or environment variables.
Install Mechanism
There is no install spec or external download—lowest-risk installation model. The package includes script files that would be added to a Unity project; no external URLs, package manager installs, or archive extractions are present.
Credentials
No environment variables, credentials, or config paths are requested. The operations performed (creating/deleting GameObjects, creating assets, writing heightmap PNG via user SaveFilePanel) are proportional to a Unity Editor automation tool.
Persistence & Privilege
The skill does not request always:true and uses normal Editor scripts. However, Editor scripts inherently modify project assets and scenes (AssetDatabase.CreateAsset, Object.DestroyImmediate, Lightmapping operations). This is expected for the tool's purpose but grants it capability to change the user's project—review and backup before running.
Assessment
This package appears to be a coherent Unity Editor level-design toolkit: the C# scripts create and modify terrains, lights, players, and asset files inside your Unity project and export heightmaps to disk. Before installing or running: 1) Verify the source (homepage is missing and the registry owner is unknown); 2) Inspect the scripts yourself (they are included) for anything you disagree with; 3) Backup your project or test in an isolated/new Unity project since the scripts call DestroyImmediate and AssetDatabase.CreateAsset and will modify your scenes/assets; 4) There are no network calls or secret requests, so credentials/exfiltration risk is low, but the metadata/manifest inconsistency (claiming instruction-only while including code) is a mild red flag—ask the publisher for clarification if provenance matters to you.

Like a lobster shell, security has layers — review code before you run it.

latestvk97crqd37v4h8rymk2tmhdx7gd81vtdq
609downloads
2stars
1versions
Updated 2mo ago
v0.1.0
MIT-0

Unity Level Design

Overview

Rapidly prototype Unity game scenes using Editor automation, modern Unity APIs, and best practices for level design. This skill automates terrain generation, lighting setup, environment placement, and player controller creation to get you implementing gameplay ideas quickly.

When to Use

Use this skill when:

  • Creating prototype scenes (post-apocalypse, fantasy, sci-fi, dungeon crawler, etc.)
  • Setting up Unity terrain, meshes, and ground geometry
  • Automating lighting, post-processing, and environment setup
  • Building player controllers and basic gameplay systems
  • Need to go from concept to playable scene rapidly

Core Workflow

Step 1: Research Current APIs

Before implementing, check Unity's latest APIs and best practices:

Modern Unity Systems:

  • Terrain Tools package (GPU-accelerated sculpting)
  • Universal Render Pipeline (URP) or High Definition Render Pipeline (HDRP)
  • DOTS/ECS for performance-critical scenarios
  • Shader Graph for custom materials
  • VFX Graph for particle effects

Key APIs to reference:

  • UnityEngine.Terrain - Terrain manipulation
  • UnityEditor.TerrainTools - Editor terrain tools
  • UnityEngine.Rendering.Universal - URP components
  • UnityEditor.SceneManagement - Scene automation

Step 2: Scene Setup Automation

Use Editor scripts to automate repetitive setup:

// Example: Automated scene initialization
public static class SceneSetupHelper
{
    [MenuItem("Level Design/Create Basic Scene")]
    public static void CreateBasicScene()
    {
        // Setup lighting
        SetupLighting();
        
        // Create terrain
        CreateTerrain();
        
        // Setup post-processing
        SetupPostProcessing();
        
        // Create player
        CreatePlayerController();
    }
}

Step 3: Terrain Generation

Options:

  1. Unity Terrain - Best for natural landscapes
  2. Mesh Generation - Best for stylized/architectural
  3. Procedural Generation - Best for endless/replayable worlds

Step 4: Environment & Props

Automate placement of:

  • Vegetation (trees, grass, rocks)
  • Structures (buildings, ruins, dungeons)
  • Lighting (sun, ambient, point lights)
  • Effects (fog, particles, post-processing)

Step 5: Player & Gameplay

Create basic:

  • Player controller (FPS, third-person, top-down)
  • Camera setup
  • Input handling
  • Basic interactions

Scene Types

Post-Apocalyptic Scene

  • Destroyed urban environment
  • Ruined buildings and debris
  • Overgrown vegetation
  • Atmospheric fog and lighting
  • Scattered resources/props

Fantasy Forest

  • Dense woodland terrain
  • Rivers and lakes
  • Fantasy vegetation
  • Magical lighting effects
  • Pathways and clearings

Dungeon Crawler

  • Procedural room generation
  • Corridor systems
  • Torch/candle lighting
  • Traps and enemy spawners
  • Loot chests

Quick Reference

TaskMethodAPI/Tool
Create TerrainEditor scriptTerrain.CreateTerrainGameObject
Sculpt TerrainNoise/heightmapsTerrainData.SetHeights
Add VegetationTree/Grass paintingTerrainData.treeInstances
Setup LightingURP/HDRPUniversalAdditionalLightData
Post-ProcessingVolume componentsVolume + profiles
Player ControllerCharacter ControllerCharacterController component
Procedural MeshesRuntime generationMesh class

Editor Tools

See scripts/ for automation tools:

  • SceneSetupWizard.cs - One-click scene initialization
  • TerrainGenerator.cs - Procedural terrain creation
  • EnvironmentPainter.cs - Batch environment placement
  • LightingSetup.cs - Automated lighting configuration

References

See references/ for detailed documentation:

  • unity-apis.md - Current Unity API reference
  • terrain-tools.md - Terrain system documentation
  • urp-setup.md - Universal Render Pipeline guide
  • level-design-patterns.md - Best practices and patterns

Common Mistakes

  • Wrong render pipeline: Check if project uses URP, HDRP, or Built-in RP
  • Terrain scale: Unity terrain uses different height/length scales
  • Lighting baking: Realtime GI can be slow; use baked lighting for static geometry
  • Performance: Too many trees/colliders will kill performance
  • Scale consistency: Keep player, environment, and props to consistent scale

Example Usage

// Create a post-apocalyptic scene
[MenuItem("Level Design/Post-Apocalyptic Scene")]
static void CreatePostApocalypticScene()
{
    // 1. Create terrain with noise
    var terrain = TerrainGenerator.CreateRuinedTerrain();
    
    // 2. Setup dramatic lighting
    LightingSetup.CreateDramaticLighting(Color.gray * 0.3f);
    
    // 3. Add fog and post-processing
    PostProcessingSetup.CreateAtmosphericFog();
    
    // 4. Scatter debris and props
    EnvironmentPainter.ScatterDebris(50);
    
    // 5. Create player
    var player = PlayerSetup.CreateFPSPlayer();
    player.transform.position = new Vector3(0, 5, 0);
}

Comments

Loading comments...