---
id: wiki-2026-0508-플랫폼-저항성-platform-resistances
title: 플랫폼 저항성(Platform Resistances)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Platform Resistances, Unit Resistance, Damage Type Resistance]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, combat, balance, rts, tactics]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: csharp
  framework: unity
---

# 플랫폼 저항성(Platform Resistances)

## 매 한 줄
> **"매 platform 의 매 damage type 의 distinct resistance profile 의 가짐"**. 매 RTS / tactics game 의 combined-arms 의 mathematical backbone — 매 unit class (보병, 차륜, 궤도, 항공) 의 vs 매 weapon type (소화기, AP, HE, AT) 의 multiplier matrix 의 의 emergent rock-paper-scissors 의 generate.

## 매 핵심

### 매 resistance matrix 의 anatomy
- **Platform axis**: 매 unit chassis category — Infantry / Wheeled / Tracked / Helo / VTOL / Naval.
- **Damage axis**: 매 weapon damage class — Small Arms / HE / AP / HEAT / Energy.
- **Cell value**: 매 damage multiplier (0.0 = immune, 1.0 = neutral, 2.0+ = vulnerable).
- **Asymmetry**: 매 matrix 의 deliberate non-symmetric — 매 Infantry vs HE 의 4.0× 의 brutal, vs AP 의 0.3× 의 trivial.

### 매 design principle
- **Hard counter**: 매 cell ≥ 3.0 의 rare — 매 specific match-up 의 decisive (e.g. AT missile vs MBT).
- **Soft counter**: 매 1.2-2.0 의 common — 매 player choice 의 reward 의 X dictate.
- **Identity 의 hint**: 매 unit's resistance profile 의 매 role 의 communicate (light scout = high mobility / paper armor).
- **No universal**: 매 every unit 의 매 weakness 의 의 가짐 — combined-arms 의 force.

### 매 응용
1. **Wargame Red Dragon / WARNO** 의 armor-vs-AP-front/side/rear matrix.
2. **StarCraft 2** 의 light/armored/biological/mechanical/massive tag system.
3. **XCOM 2** 의 pierce + shred + armor HP.
4. **Battle Brothers** 의 cut/pierce/blunt vs body/head zone.
5. **AI rebalance loop**: 매 telemetry 의 win-rate per matchup 의 LLM agent 의 propose tweak.

## 💻 패턴

### Resistance matrix data (ScriptableObject)
```csharp
// Unity 6.0 — ResistanceMatrix.asset
[CreateAssetMenu(menuName = "Combat/Resistance Matrix")]
public class ResistanceMatrix : ScriptableObject
{
    public enum Platform { Infantry, Wheeled, Tracked, Helo, VTOL, Naval }
    public enum DamageType { SmallArms, HE, AP, HEAT, Energy }

    [System.Serializable]
    public struct Row { public Platform platform; public float[] multipliers; }

    public Row[] rows; // length = Platform.count, multipliers = DamageType.count

    public float Lookup(Platform p, DamageType d)
        => rows[(int)p].multipliers[(int)d];
}
```

### Damage application
```csharp
public static class DamageResolver
{
    public static float Apply(Unit target, float rawDamage, DamageType type, ResistanceMatrix matrix)
    {
        float mult = matrix.Lookup(target.Platform, type);
        float effective = rawDamage * mult;
        // armor mitigation 의 secondary layer
        effective = Mathf.Max(0, effective - target.ArmorThickness * 0.1f);
        target.HP -= effective;
        return effective;
    }
}
```

### Default matrix (typical RTS values)
```csharp
// Infantry: weak to HE, strong vs AP
//             SmallArms  HE   AP   HEAT  Energy
// Infantry      1.0     4.0  0.3   0.5    1.0
// Wheeled       0.4     1.5  1.0   1.2    0.9
// Tracked       0.1     0.6  1.0   1.8    0.8
// Helo          1.2     0.8  0.5   1.0    1.3
// VTOL          1.0     0.7  0.4   0.9    1.4
// Naval         0.2     1.0  0.8   1.5    0.6
```

### Frontal vs side/rear armor (Wargame style)
```csharp
public enum HitFacing { Front, Side, Rear, Top }

public class ArmoredUnit : Unit
{
    public float frontArmor, sideArmor, rearArmor, topArmor;

    public float ArmorAt(HitFacing f) => f switch {
        HitFacing.Front => frontArmor,
        HitFacing.Side  => sideArmor,
        HitFacing.Rear  => rearArmor,
        HitFacing.Top   => topArmor,
        _ => frontArmor
    };
}
```

### Penetration roll
```csharp
public static bool Penetrates(float ap, float armor)
{
    // Wargame-style: AP - Armor = success threshold
    int diff = Mathf.RoundToInt(ap - armor);
    if (diff >= 3) return true;       // overmatch
    if (diff <= -3) return false;     // bounces
    float chance = 0.5f + diff * 0.15f;
    return Random.value < chance;
}
```

### Telemetry-driven rebalance
```csharp
public class MatchupTelemetry
{
    Dictionary<(Platform,DamageType), (int kills, int deaths)> stats = new();

    public void Log(Platform attacker, DamageType dmg, Platform victim, bool killed)
    {
        var key = (victim, dmg);
        if (!stats.ContainsKey(key)) stats[key] = (0,0);
        var (k, d) = stats[key];
        stats[key] = (killed ? k+1 : k, d+1);
    }

    public float WinRate(Platform victim, DamageType dmg)
        => stats.TryGetValue((victim, dmg), out var s) && s.deaths > 0
           ? (float)s.kills / s.deaths : 0.5f;
}
```

### Editor matrix UI
```csharp
[CustomEditor(typeof(ResistanceMatrix))]
public class ResistanceMatrixEditor : Editor
{
    public override void OnInspectorGUI()
    {
        var m = (ResistanceMatrix)target;
        EditorGUILayout.LabelField("Platform \\ Damage", EditorStyles.boldLabel);
        // grid editor — 매 cell 의 colored by value (red = vulnerable, green = resistant)
        for (int p = 0; p < m.rows.Length; p++) {
            EditorGUILayout.BeginHorizontal();
            for (int d = 0; d < m.rows[p].multipliers.Length; d++) {
                float v = m.rows[p].multipliers[d];
                GUI.backgroundColor = Color.Lerp(Color.green, Color.red, v / 4f);
                m.rows[p].multipliers[d] = EditorGUILayout.FloatField(v, GUILayout.Width(50));
            }
            EditorGUILayout.EndHorizontal();
        }
        if (GUI.changed) EditorUtility.SetDirty(m);
    }
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Symmetric 1v1 RTS | Light/Armored tag (StarCraft) — 매 simple, fast read |
| Realistic wargame | Platform × Damage × Facing matrix — 매 deep, slower |
| Mobile auto-battler | 3-type RPS (속성) — 매 one-glance readable |
| Tactics RPG | Damage type vs body zone — 매 narrative depth |

**기본값**: 매 6×5 platform×damage matrix + facing modifier — 매 readable + tactical.

## 🔗 Graph
- 부모: [[Combat-System]] · [[Damage-Model]]
- 변형: [[Armor-Penetration]] · [[Damage-Type-System]] · [[Facing-Armor]]
- 응용: [[Combined-Arms]] · [[Unit-Counter]] · [[Mixed-Platoons]]
- Adjacent: [[Balance-Telemetry]] · [[Rock-Paper-Scissors]] · [[Hard-Counter]]

## 🤖 LLM 활용
**언제**: 매 matrix tuning — 매 telemetry CSV 의 LLM 의 feed 의 imbalanced cell 의 propose; 매 tooltip 자동생성 ("light infantry — HE 의 weak").
**언제 X**: 매 core balance decision 의 designer judgment 의 require — LLM 의 raw suggestion 의 final 의 X.

## ❌ 안티패턴
- **Universal counter**: 매 1 unit 의 매 everything 의 beat — 매 RPS 의 collapse.
- **Symmetric matrix**: 매 every cell = 1.0 — 매 platform identity 의 disappear.
- **Hidden multipliers**: 매 player 의 매 matrix 의 의 see 의 X — counter-play 의 impossible.
- **Facing 의 forget**: 매 tank vs AT 의 frontal-only — 매 flanking play 의 dead.

## 🧪 검증 / 중복
- Verified (Wargame: Red Dragon armor-AP table; StarCraft 2 unit data).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — platform×damage matrix + facing armor patterns 추가 |