🇺🇸English

Gameplay Mechanics Implementation

Core Mechanics Framework

┌─────────────────────────────────────────────────────────────┐
│                    ACTION → EFFECT LOOP                      │
├─────────────────────────────────────────────────────────────┤
│  INPUT          PROCESS          OUTPUT          FEEDBACK   │
│  ┌─────┐       ┌─────────┐      ┌─────────┐    ┌─────────┐ │
│  │Press│──────→│Validate │─────→│Update   │───→│Visual   │ │
│  │Button│      │& Execute│      │State    │    │Audio    │ │
│  └─────┘       └─────────┘      └─────────┘    │Haptic   │ │
│                                                 └─────────┘ │
│                                                              │
│  TIMING REQUIREMENTS:                                        │
│  • Input → Response: < 100ms (feels responsive)             │
│  • Animation start: < 50ms (feels instant)                  │
│  • Audio feedback: < 20ms (in sync with action)             │
└─────────────────────────────────────────────────────────────┘

Feedback Loop Design

FEEDBACK TIMING LAYERS:
┌─────────────────────────────────────────────────────────────┐
│  IMMEDIATE (0-100ms):                                        │
│  ├─ Button press sound                                      │
│  ├─ Animation start                                         │
│  ├─ Screen shake                                            │
│  └─ Controller vibration                                    │
│                                                              │
│  SHORT-TERM (100ms-1s):                                      │
│  ├─ Damage numbers appear                                   │
│  ├─ Health bar updates                                      │
│  ├─ Enemy reaction animation                                │
│  └─ Particle effects                                        │
│                                                              │
│  LONG-TERM (1s+):                                            │
│  ├─ XP/Score increase                                       │
│  ├─ Level up notification                                   │
│  ├─ Achievement unlock                                      │
│  └─ Story progression                                       │
└─────────────────────────────────────────────────────────────┘

Combat Mechanics

// ✅ Production-Ready: Combat State Machine
public class CombatStateMachine : MonoBehaviour
{
    public enum CombatState { Idle, Attacking, Blocking, Recovering, Staggered }

    [Header("Combat Parameters")]
    [SerializeField] private float attackDamage = 10f;
    [SerializeField] private float attackRange = 2f;
    [SerializeField] private float attackCooldown = 0.5f;
    [SerializeField] private float blockDamageReduction = 0.7f;
    [SerializeField] private float staggerDuration = 0.3f;

    private CombatState _currentState = CombatState.Idle;
    private float _stateTimer;

    public event Action<CombatState> OnStateChanged;
    public event Action<float> OnDamageDealt;
    public event Action<float> OnDamageTaken;

    public bool TryAttack()
    {
        if (_currentState != CombatState.Idle) return false;

        TransitionTo(CombatState.Attacking);
        StartCoroutine(AttackSequence());
        return true;
    }

    private IEnumerator AttackSequence()
    {
        // Wind-up phase
        yield return new WaitForSeconds(0.1f);

        // Active hit frame
        var hits = Physics.OverlapSphere(transform.position + transform.forward, attackRange);
        foreach (var hit in hits)
        {
            if (hit.TryGetComponent<IDamageable>(out var target))
            {
                target.TakeDamage(attackDamage);
                OnDamageDealt?.Invoke(attackDamage);
            }
        }

        // Recovery phase
        yield return new WaitForSeconds(attackCooldown);
        TransitionTo(CombatState.Idle);
    }

    public float TakeDamage(float damage)
    {
        float finalDamage = _currentState == CombatState.Blocking
            ? damage * (1f - blockDamageReduction)
            : damage;

        OnDamageTaken?.Invoke(finalDamage);

        if (finalDamage > 5f) // Stagger threshold
        {
            TransitionTo(CombatState.Staggered);
            StartCoroutine(RecoverFromStagger());
        }

        return finalDamage;
    }

    private void TransitionTo(CombatState newState)
    {
        _currentState = newState;
        _stateTimer = 0f;
        OnStateChanged?.Invoke(newState);
    }
}

Resource Economy System

ECONOMY BALANCE FORMULA:
┌─────────────────────────────────────────────────────────────┐
│  INCOME vs EXPENDITURE:                                      │
│                                                              │
│  Hourly Income = (Enemies/hr × Gold/Enemy) + PassiveIncome  │
│  Hourly Spend  = (Upgrades + Consumables + Deaths)          │
│                                                              │
│  BALANCE RATIO:                                              │
│  • < 0.8: Too scarce (frustrating)                          │
│  • 0.8-1.2: Balanced (meaningful choices)                   │
│  • > 1.2: Too abundant (no tension)                         │
│                                                              │
│  EXAMPLE STAMINA SYSTEM:                                     │
│  ┌───────────────────────────────────────────────────────┐  │
│  │  Max: 100  │  Regen: 20/sec  │  On Hit: +10           │  │
│  ├───────────────────────────────────────────────────────┤  │
│  │  Light Attack: -10  │  Heavy Attack: -25              │  │
│  │  Dodge: -15         │  Block: -5/hit                  │  │
│  │  Sprint: -5/sec     │  Jump: -8                       │  │
│  └───────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

Progression Systems

PROGRESSION CURVE:
┌─────────────────────────────────────────────────────────────┐
│  Power                                                       │
│    ↑                                                         │
│    │                                    ╱───── Late Game     │
│    │                              ╱────╱       (slow, goals) │
│    │                        ╱────╱                           │
│    │                  ╱────╱                                 │
│    │            ╱────╱       Mid Game                        │
│    │      ╱────╱             (steady progress)               │
│    │ ╱───╱                                                   │
│    │╱ Early Game (fast, hook player)                        │
│    └────────────────────────────────────────────────→ Time   │
│                                                              │
│  XP CURVE FORMULA:                                           │
│  XP_needed(level) = base_xp × (level ^ growth_rate)         │
│  • growth_rate 1.5: Gentle curve (casual)                   │
│  • growth_rate 2.0: Standard curve (balanced)               │
│  • growth_rate 2.5: Steep curve (hardcore)                  │
└─────────────────────────────────────────────────────────────┘



// ✅ Production-Ready: Progression Manager
public class ProgressionManager : MonoBehaviour
{
    [Header("Progression Config")]
    [SerializeField] private int baseXP = 100;
    [SerializeField] private float growthRate = 2.0f;
    [SerializeField] private int maxLevel = 50;

    private int _currentLevel = 1;
    private int _currentXP = 0;

    public event Action<int> OnLevelUp;
    public event Action<int, int> OnXPGained; // current, required

    public int XPForLevel(int level)
    {
        return Mathf.RoundToInt(baseXP * Mathf.Pow(level, growthRate));
    }

    public void AddXP(int amount)
    {
        _currentXP += amount;
        int required = XPForLevel(_currentLevel);

        OnXPGained?.Invoke(_currentXP, required);

        while (_currentXP >= required && _currentLevel < maxLevel)
        {
            _currentXP -= required;
            _currentLevel++;
            OnLevelUp?.Invoke(_currentLevel);
            required = XPForLevel(_currentLevel);
        }
    }

    public float GetProgressToNextLevel()
    {
        return (float)_currentXP / XPForLevel(_currentLevel);
    }
}

Movement Mechanics

PLATFORMER FEEL PARAMETERS:
┌─────────────────────────────────────────────────────────────┐
│  MOVEMENT:                                                   │
│  • Walk Speed: 5-8 units/sec                                │
│  • Run Speed: 10-15 units/sec                               │
│  • Acceleration: 20-50 units/sec²                           │
│  • Deceleration: 30-60 units/sec² (snappier = higher)       │
│                                                              │
│  JUMP:                                                       │
│  • Jump Height: 2-4 units                                   │
│  • Jump Duration: 0.3-0.5 sec                               │
│  • Gravity: 20-40 units/sec²                                │
│  • Fall Multiplier: 1.5-2.5x (faster fall = tighter)       │
│                                                              │
│  FEEL ENHANCERS:                                             │
│  • Coyote Time: 0.1-0.15 sec (jump after leaving edge)      │
│  • Jump Buffer: 0.1-0.15 sec (early jump input)             │
│  • Variable Jump: Release = shorter jump                    │
│  • Air Control: 50-80% of ground control                    │
└─────────────────────────────────────────────────────────────┘

Event-Driven Architecture

EVENT SYSTEM PATTERN:
┌─────────────────────────────────────────────────────────────┐
│  ACTION EXECUTED                                             │
│       │                                                      │
│       ▼                                                      │
│  ┌─────────────────────────────────────────────────────┐    │
│  │              EVENT DISPATCHER                        │    │
│  │  DamageDealt(amount, position, type)                │    │
│  └─────────────────────────────────────────────────────┘    │
│       │                                                      │
│       ├──→ VFX System: Spawn damage numbers                 │
│       ├──→ Audio System: Play hit sound                     │
│       ├──→ UI System: Update health bar                     │
│       ├──→ Camera System: Screen shake                      │
│       ├──→ AI System: Alert nearby enemies                  │
│       └──→ Analytics: Log combat event                      │
│                                                              │
│  BENEFITS:                                                   │
│  • Systems don't need direct references                     │
│  • Easy to add/remove observers                             │
│  • Same event triggers multiple effects                     │
│  • Easy networking (replicate events)                       │
└─────────────────────────────────────────────────────────────┘

Balance Iteration

RAPID BALANCE WORKFLOW:
┌─────────────────────────────────────────────────────────────┐
│  1. PLAYTEST (15-30 min)                                     │
│     → Watch players, note friction points                   │
│                                                              │
│  2. ANALYZE (5-15 min)                                       │
│     → What felt wrong? Too easy/hard?                       │
│     → Check telemetry data                                  │
│                                                              │
│  3. ADJUST (5-10 min)                                        │
│     → Change ONE variable at a time                         │
│     → Document the change                                   │
│                                                              │
│  4. TEST (5 min)                                             │
│     → Verify change has intended effect                     │
│                                                              │
│  5. REPEAT                                                   │
│     → Target: 4-6 iterations per hour                       │
└─────────────────────────────────────────────────────────────┘

BALANCE SPREADSHEET FORMAT:
┌──────────┬────────┬─────────┬─────────┬──────────┐
│ Weapon   │ Damage │ Speed   │ Range   │ DPS      │
├──────────┼────────┼─────────┼─────────┼──────────┤
│ Sword    │ 10     │ 1.0/sec │ 2m      │ 10.0     │
│ Axe      │ 20     │ 0.5/sec │ 1.5m    │ 10.0     │
│ Dagger   │ 5      │ 2.0/sec │ 1m      │ 10.0     │
│ Spear    │ 12     │ 0.8/sec │ 3m      │ 9.6      │
└──────────┴────────┴─────────┴─────────┴──────────┘

🔧 Troubleshooting

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Controls feel unresponsive                         │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Add immediate audio/visual feedback on input              │
│ → Reduce input-to-action delay (< 100ms)                    │
│ → Add input buffering for combo actions                     │
│ → Check for frame rate issues                               │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: One strategy dominates all others                  │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Nerf dominant option OR buff alternatives                 │
│ → Add situational counters                                  │
│ → Create rock-paper-scissors relationships                  │
│ → Add resource costs to powerful options                    │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Players don't understand mechanic                  │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Add clearer visual/audio feedback                         │
│ → Create safe tutorial space                                │
│ → Use consistent visual language                            │
│ → Add UI hints or tooltips                                  │
└─────────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────────┐
│ PROBLEM: Progression feels grindy                           │
├─────────────────────────────────────────────────────────────┤
│ SOLUTIONS:                                                   │
│ → Reduce XP requirements                                    │
│ → Add more XP sources                                       │
│ → Give meaningful rewards more frequently                   │
│ → Add catch-up mechanics for late content                   │
└─────────────────────────────────────────────────────────────┘

Mechanic Comparison

Use this skill : When implementing core mechanics, balancing systems, or designing player feedback.

Weekly Installs

115

Repository

pluginagentmark…eveloper

GitHub Stars

17

First Seen

Jan 24, 2026

Security Audits

Gen Agent Trust HubPassSocketPassSnykPass

Installed on

opencode104

codex103

gemini-cli101

github-copilot92

cursor88

claude-code84