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

id, title, category, status, canonical_id, aliases, duplicate_of, source_trust_level, confidence_score, verification_status, tags, raw_sources, last_reinforced, github_commit, tech_stack

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

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)

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

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

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

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

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 추가