game-skill-system-expert
Expert knowledge of Unity-based game skill configuration system. Use when working with skill JSON files, generating/modifying/analyzing game skills, debugging skill configs, or discussing skill mechanics like damage/healing/shields/buffs. Automatically activates for skill-related tasks in game development.
When & Why to Use This Skill
This Claude skill provides expert-level assistance for Unity-based game development, specializing in the creation, analysis, and debugging of skill configuration systems. It streamlines the workflow for game designers and developers by automating JSON generation, calculating balance formulas, and ensuring technical precision in skill mechanics like damage scaling, timing, and status effects. By leveraging deep knowledge of SkillData structures and game design principles, it helps maintain high-quality, balanced, and bug-free game ability systems.
Use Cases
- Generating production-ready JSON configurations for new character abilities (e.g., Fireball, Healing Aura) based on natural language descriptions.
- Analyzing and rebalancing existing skill damage/healing ratios using built-in game design formulas and scaling guidelines.
- Debugging structural or logic errors in complex multi-track skill files, such as timing mismatches or invalid JSON syntax.
- Optimizing gameplay 'feel' by refining action timing, frame-rate alignment, and attribute scaling curves for better responsiveness.
- Batch processing and auditing multiple skill configurations to ensure consistency in naming conventions and resource references.
| name | game-skill-system-expert |
|---|---|
| description | Expert knowledge of Unity-based game skill configuration system. Use when working with skill JSON files, generating/modifying/analyzing game skills, debugging skill configs, or discussing skill mechanics like damage/healing/shields/buffs. Automatically activates for skill-related tasks in game development. |
| allowed-tools | Read, Write, Edit, Grep, Glob, Bash |
Game Skill System Expert
Overview
This Skill provides comprehensive expertise in Unity-based game skill configuration systems. It understands the complete architecture, including SkillData structures, tracks, Actions, timing systems, attribute scaling, and balance principles.
When to Use This Skill
I automatically activate when you:
- Work with skill JSON configuration files
- Generate, create, or modify game skills
- Analyze skill balance or mechanics
- Debug skill configuration issues
- Discuss game mechanics (damage, healing, shields, resources, buffs, debuffs)
- Optimize skill timing or performance
- Batch process multiple skill configurations
- Reference files in the
Assets/Skills/directory
Core Capabilities
1. Skill Generation
Create complete, production-ready skill configurations from natural language descriptions.
Process:
- Gather requirements through targeted questions
- Design appropriate track architecture
- Calculate balanced values using game design formulas
- Generate complete JSON with correct structure
- Validate configuration
- Explain mechanics and provide testing guidance
Key Considerations:
- Appropriate base values for skill type
- Scaling ratios that feel fair
- Timing that feels responsive
- Correct target filtering
- Complete audio/visual configuration
- Unique skill IDs
2. Skill Analysis
Parse and analyze existing configurations to provide insights and recommendations.
Analysis Includes:
- Mechanics breakdown (what the skill does)
- Timing analysis (when Actions occur)
- Balance assessment (damage/heal output at different levels)
- Scaling efficiency (effect of attribute scaling)
- Code quality assessment
- Comparison with similar skills
Outputs:
- Comprehensive documentation
- Timeline visualizations
- Balance calculations
- Improvement recommendations
3. Skill Debugging
Identify and fix issues in skill configurations.
Issue Detection:
- Syntax errors (invalid JSON)
- Structural errors (missing fields, wrong types)
- Logic errors (timing issues, invalid references)
- Balance problems (extreme values)
- Quality issues (poor naming, missing effects)
Debugging Process:
- Validate JSON syntax
- Check required fields and types
- Analyze timing logic
- Verify resource references
- Assess balance
- Categorize issues by severity
- Apply fixes
- Generate debug report
4. Skill Optimization
Improve existing skills for better performance, feel, or maintainability.
Optimization Areas:
- Timing refinement for better responsiveness
- Scaling curve adjustments for smoother progression
- Performance improvements (reduce redundancy)
- Code quality (naming, structure, organization)
- Balance adjustments
Technical Reference
SkillData Structure
{
"$id": 0,
"$type": "0|SkillSystem.Data.SkillData, Assembly-CSharp",
"skillName": "Skill Name",
"skillDescription": "What the skill does",
"totalDuration": 180, // frames
"frameRate": 30, // fps
"tracks": {
"$id": 1,
"$type": "1|System.Collections.Generic.List`1[[SkillSystem.Data.SkillTrack, Assembly-CSharp]], mscorlib",
"$rlength": 3,
"$rcontent": [/* tracks */]
},
"skillId": "Hero-SkillName-001"
}
Track Structure
{
"$id": 2,
"$type": "2|SkillSystem.Data.SkillTrack, Assembly-CSharp",
"trackName": "Track Name",
"enabled": true,
"actions": {
"$id": 3,
"$type": "3|System.Collections.Generic.List`1[[SkillSystem.Actions.ISkillAction, Assembly-CSharp]], mscorlib",
"$rlength": 1,
"$rcontent": [/* actions */]
}
}
Common Action Types
Damage:
AttributeScaledDamageAction- Scales with spell power, attack damage, healthUnitTypeCappedDamageAction- Different damage caps for minions/jungle/champsDamageAction- Simple fixed damage
Healing:
ResourceDependentHealAction- Healing based on resource consumptionHealAction- Simple healing
Shields:
AttributeScaledShieldAction- Attribute-scaled shield with duration
Control:
InputDetectionAction- Detect player input to trigger conditional effects
Animation/Audio:
AnimationAction- Play animation clipsAudioAction- Play sound effects (2D or 3D spatial audio)
Resources:
ResourceAction- Modify resources (mana, rage, energy, etc.)
Action Properties
Each Action has:
$id- Unique numeric ID within the file$type- Full type path with ID prefixframe- Action start time (from 0)duration- Number of frames Action lastsenabled- Whether Action is active
Scaling Formulas
Damage Formula:
Total = (Base + Level * PerLevel) + SpellPower * SpellPowerRatio + AttackDamage * ADRatio + MaxHealth * HealthRatio
Heal Formula:
Total = (Base + Level * PerLevel) + SpellPower * SpellPowerRatio + Resource * PerResource
Shield Formula:
Total = (Base + Level * PerLevel) + SpellPower * SpellPowerRatio + Health * HealthRatio
Balance Guidelines
Damage Skills:
| Type | Base | Spell Power Ratio | Per Level | Description |
|---|---|---|---|---|
| Basic | 60-100 | 0.4-0.6 | 10-15 | Can be cast frequently |
| Main | 100-200 | 0.6-0.9 | 15-25 | Medium cooldown |
| Ultimate | 200-400 | 0.8-1.2 | 25-40 | Long cooldown |
Heal Skills:
| Type | Base | Spell Power Ratio | Per Level |
|---|---|---|---|
| Basic | 40-80 | 0.3-0.5 | 8-12 |
| Main | 80-150 | 0.5-0.8 | 12-20 |
Shield Skills:
| Type | Base | Spell Power Ratio | Health Ratio | Duration |
|---|---|---|---|---|
| Basic | 50-100 | 0.3-0.5 | 0.05-0.10 | 2-4 seconds |
| Main | 100-200 | 0.5-0.8 | 0.08-0.15 | 3-6 seconds |
Timing Guidelines:
| Type | Duration | Frames @ 30fps |
|---|---|---|
| Instant | 0.1-0.3s | 3-9 |
| Quick | 0.25-0.5s | 8-15 |
| Standard | 0.5-1.5s | 15-45 |
| Channel | 2-4s | 60-120 |
Target Filters
0= Self only1= Enemies only2= Allies only3= All units
Damage Types
0= Physical damage1= Magic damage2= True damage (ignores resistances)
Resource Types
0= Mana1= Energy2= Rage3= Shield (temporary health)4= Health
Workflow Examples
Example 1: Generate New Skill
User Request: "Create a fireball skill for a mage"
My Approach:
Ask clarifying questions:
- Damage amount preference? (I'll suggest 80 base, 0.6 spell power ratio)
- Duration? (I'll suggest 1 second cast time)
- Any special mechanics? (AOE, single target, etc.)
Design tracks:
- Damage track (fire damage at frame 20)
- Animation track (cast animation 0-30)
- Audio track (cast sound + hit sound)
Generate JSON with correct structure
Explain mechanics and testing steps
Example 2: Analyze Existing Skill
User Request: "Analyze TryndamereBloodlust.json"
My Approach:
- Use Read tool to load file
- Parse structure and extract all data
- Calculate heal values for levels 1, 6, 11, 16
- Create timeline showing Action sequence
- Assess balance (heal per rage point)
- Check code quality
- Provide recommendations
Example 3: Debug Skill Issue
User Request: "My skill isn't working, damage seems wrong"
My Approach:
- Read skill configuration
- Validate JSON structure
- Check Action timing and frames
- Calculate actual damage values
- Compare with expected values
- Identify issue (e.g., wrong damage type, missing scaling)
- Fix and explain
Best Practices
Structure
- Group related Actions in named tracks
- Use clear, descriptive track names
- Order tracks logically (animation, damage, audio, effects)
Timing
- Align damage/healing with animation apex
- Add sound effects at appropriate moments
- Consider input buffering for better responsiveness
- Frame 0 is skill start, plan timing accordingly
Balance
- Start with guideline values, adjust based on testing
- Ensure scaling feels fair (not too weak early, not too strong late)
- Consider resource cost vs power level
- Test at multiple levels and attribute levels
Quality
- Always include effect colors for visual Actions
- Configure 3D audio properly (minDistance, maxDistance)
- Use unique, descriptive skill IDs
- Add helpful comments in skill descriptions
- Validate before saving
Maintainability
- Follow consistent naming conventions
- Keep related Actions together in tracks
- Use meaningful IDs and names
- Document complex mechanics in descriptions
Quality Checklist
Verify before completing any skill work:
- JSON syntax is valid
- All required fields present (skillName, skillDescription, totalDuration, frameRate, skillId)
- $id and $type declarations match and are sequential
- All frames are within totalDuration
- Duration calculations are correct (frames = seconds * frameRate)
- Balance values are in appropriate ranges
- Effect colors are defined for visual Actions
- Audio configuration is correct (3D when needed)
- Target filters are appropriate
- Naming is consistent and descriptive
- Resource references are valid (animation/audio clip names)
Common Patterns
Instant Damage Skill:
- Animation track: Cast animation (10-20 frames)
- Damage track: Damage at animation apex
- Audio track: Cast sound + hit sound
Channel Skill:
- Animation track: Channel animation (entire duration)
- Damage track: Multiple damage ticks
- Audio track: Channel loop sound
Shield with Explosion:
- Shield track: Apply shield (6 second duration)
- Input detection track: Wait for W key after 3 seconds
- Damage track: Explosion damage when input detected
- Animation track: Shield cast + explosion
- Audio track: Shield application + explosion sounds
Resource-Based Healing:
- Resource track: Consume rage/energy
- Heal track: Healing based on consumed resource
- Animation track: Cast animation
- Audio track: Cast sound + resource consumption sound
Tools I Use
- Read: Load skill JSON files
- Write: Create new skill configurations
- Edit: Modify existing skills
- Grep: Search patterns across multiple skills
- Glob: Find all skill files
- Bash: Validate JSON, run scripts, batch operations
Output Format
I provide:
- Clear, well-formatted JSON configurations
- Detailed explanations with reasoning
- Calculated breakdowns
- Timeline visualizations
- Actionable recommendations
- Testing guidance
Need Help?
Just describe what you need in natural language:
- "Create a healing skill that consumes mana"
- "Analyze all damage skills in Assets/Skills"
- "Debug SionSoulFurnace.json"
- "Why does my skill timing feel off?"
- "Generate 3 variants of a lightning skill"
I'll handle the technical details and guide you through the process!