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
| Mechanic | Skill Floor | Skill Ceiling | Feedback Speed |
|---|---|---|---|
| Button Mash | Low | Low | Instant |
| Timing-Based | Medium | High | Instant |
| Resource Management | Medium | High | Delayed |
| Combo System | High | Very High | Instant |
| Strategic | Medium | Very High | Delayed |
Use this skill: When implementing core mechanics, balancing systems, or designing player feedback.