2nd/10_Wiki/Topics/Game_Design/Structural-Dynamics-of-Combat-Ecosystem.md

---
id: wiki-2026-0508-structural-dynamics-of-combat-ec
title: Structural Dynamics of Combat Ecosystem
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Combat Ecosystem Structure, Combat Meta Dynamics]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, balance, combat, meta, systems]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: typescript
  framework: nodejs
---

# Structural Dynamics of Combat Ecosystem

## 매 한 줄
> **"매 combat ecosystem 의 structural feedback loop 의 분석"**. 매 unit roster, counter-graph, build-economy, player skill 의 four-way feedback — 매 stable rotation vs runaway dominance 의 결정 의 lever. 매 RTS/MOBA/MMO/strategy 의 universal frame.

## 매 핵심

### 매 4 layer
1. **Roster layer**: 매 units 의 stat space.
2. **Counter graph**: 매 RPS + soft counter + ability interaction.
3. **Economy layer**: build cost, tech tree, time gate.
4. **Skill layer**: APM, decision quality, micro/macro.

### 매 feedback loop
- Roster → Counter graph (stats determine matchups).
- Counter graph → Skill (which unit micro matters).
- Skill → Economy (resource efficiency).
- Economy → Roster (which units 의 affordable).

### 매 응용
1. Patch design — 매 lever 의 isolation.
2. Telemetry analysis — 매 dominant strategy 의 detect.
3. Esports balance — 매 high-skill vs casual 의 tradeoff.

## 💻 패턴

### Counter graph 의 build
```typescript
type UnitId = string;
interface Counter { from: UnitId; to: UnitId; mult: number; }

export class CounterGraph {
  private edges = new Map<UnitId, Counter[]>();
  add(c: Counter) {
    const arr = this.edges.get(c.from) ?? [];
    arr.push(c); this.edges.set(c.from, arr);
  }
  matchup(a: UnitId, b: UnitId): number {
    return this.edges.get(a)?.find(e => e.to === b)?.mult ?? 1.0;
  }
}
```

### Dominance detector (eigenvalue)
```typescript
import { Matrix, EigenvalueDecomposition } from 'ml-matrix';

export function rosterDominance(matchupMatrix: number[][]): { unitId: number; score: number }[] {
  const m = new Matrix(matchupMatrix);
  const e = new EigenvalueDecomposition(m);
  const principal = e.realEigenvectors.getColumn(0);
  return principal.map((v, i) => ({ unitId: i, score: v }))
    .sort((a, b) => b.score - a.score);
}
```

### Build economy curve
```typescript
interface BuildOption { unit: string; cost: number; tier: number; powerScore: number; }

export function paretoFront(options: BuildOption[]): BuildOption[] {
  return options.filter(a => !options.some(b =>
    b !== a && b.powerScore >= a.powerScore && b.cost <= a.cost && (b.powerScore > a.powerScore || b.cost < a.cost)
  ));
}
```

### Telemetry: pick-rate vs win-rate
```typescript
interface MatchRecord { winner: string; loser: string; winnerComp: string[]; loserComp: string[]; }

export function unitStats(records: MatchRecord[]) {
  const stats = new Map<string, { picks: number; wins: number }>();
  for (const r of records) {
    for (const u of r.winnerComp) {
      const s = stats.get(u) ?? { picks: 0, wins: 0 };
      s.picks++; s.wins++; stats.set(u, s);
    }
    for (const u of r.loserComp) {
      const s = stats.get(u) ?? { picks: 0, wins: 0 };
      s.picks++; stats.set(u, s);
    }
  }
  return [...stats.entries()].map(([u, s]) => ({
    unit: u,
    pickRate: s.picks / records.length,
    winRate: s.wins / s.picks,
  }));
}
```

### Skill ladder elo
```typescript
export function eloUpdate(rA: number, rB: number, scoreA: 0 | 0.5 | 1, k = 32): [number, number] {
  const expA = 1 / (1 + Math.pow(10, (rB - rA) / 400));
  const expB = 1 - expA;
  return [rA + k * (scoreA - expA), rB + k * ((1 - scoreA) - expB)];
}
```

### Patch impact simulation
```typescript
export function simulatePatch(graph: CounterGraph, change: Counter, samples = 10_000) {
  graph.add(change);
  const wins = new Map<string, number>();
  for (let i = 0; i < samples; i++) {
    // randomized 5v5 sim — 생략
  }
  return wins;
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| 매 dominant strategy detected | Nerf the apex — gentle 5-10% adjustment first. |
| 매 stale meta | Buff under-picked tier 3 — add a soft counter edge. |
| 매 economy abuse | Tax the dominant build path — not the unit. |
| 매 skill ceiling 너무 high | Lower micro reward — smooth ability curves. |

**기본값**: 4-layer monitoring + monthly micro-patch + quarterly meta refresh.

## 🔗 Graph
- 부모: [[War-Commander-Combat-Ecosystem]] · [[Player-Experience-Modeling]]
- 변형: [[Structural-Dynamics-and-Tactical-Evolution-of-the-Combat-Ecosystem]] · [[Evolution-of-the-War-Commander-Combat-Ecosystem]]
- 응용: [[Anti-Air-and-Anti-Ground-Combat]] · [[Damage-Resistance-Platforms]]
- Adjacent: [[Power Creep (Content Treadmills)]] · [[Combat_Balance_Buff]]

## 🤖 LLM 활용
**언제**: patch note draft, meta narrative summary, balance hypothesis 의 brainstorm.
**언제 X**: 매 production telemetry pipeline (deterministic).

## ❌ 안티패턴
- **Single-layer fix**: 매 stat-only nerf 의 economy/skill cause 의 무시.
- **Reactive whack-a-mole**: 매 weekly patch 의 player whiplash.
- **Eigen-blind**: 매 spreadsheet matchup 만 — 매 emergent meta 의 miss.

## 🧪 검증 / 중복
- Verified: SC2 balance council 2024 reports, DOTA 2 patch analyses, RTS academic literature (Robertson & Watson 2014).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — 4-layer model + dominance eigen 추가 |