2nd/10_Wiki/Topics/Game_Design/Revenge-Cycle-Dynamics.md

---
id: wiki-2026-0508-revenge-cycle-dynamics
title: Revenge Cycle Dynamics
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Revenge Loop, Retaliation Spiral, Counter-Attack Cycle]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, pvp, retention, social-dynamics, war-commander]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: typescript
  framework: live-ops
---

# Revenge Cycle Dynamics

## 매 한 줄
> **"매 attack 은 매 future attack 의 seed 다."**. Revenge cycle 은 War Commander, Mobile Strike, EVE 등 PvP 전략 게임의 retention engine — player A 가 player B 를 칠 때, B 의 retaliation probability 가 높아지고, 그 retaliation 이 다시 A 의 counter-retaliation 을 trigger 하는 closed feedback loop 이다. 매 2026 LiveOps 에서 이 cycle 을 의도적으로 telemetry-balance 하는 것은 D30 retention 의 핵심 lever.

## 매 핵심

### 매 Cycle Anatomy
- **Trigger**: unprovoked attack, base raid, alliance-level aggression
- **Emotional payload**: loss aversion + identity threat (base = avatar extension)
- **Retaliation window**: 24-72h (mobile), 7d (slow strategy)
- **Escalation vector**: solo → alliance war → cross-server war
- **Decay**: 매 cycle 은 자연스럽게 fade — fuel injection (events, leaderboards) 없으면.

### 매 Retention 메커니즘
- 매 active grudge = 매 daily login reason
- 매 revenge planning = 매 in-app currency sink (troop healing, base upgrades)
- 매 alliance bond = social switching cost
- 매 storytelling = personal narrative (UGC potential)

### 매 응용
1. War Commander: kill report + replay → revenge UI button.
2. EVE Online: kill mail system → corp-level vendetta.
3. Mobile Strike: VIP bounty board → paid revenge service.
4. Clash of Clans: revenge cooldown design (one-shot).

## 💻 패턴

### Pattern 1 — Revenge eligibility tracker
```typescript
interface AttackEvent {
  attackerId: string;
  defenderId: string;
  timestamp: number;
  damageDealt: number;
  retaliated: boolean;
}

class RevengeTracker {
  private events = new Map<string, AttackEvent[]>();
  private readonly WINDOW_MS = 72 * 3600 * 1000;

  record(e: AttackEvent) {
    const list = this.events.get(e.defenderId) ?? [];
    list.push(e);
    this.events.set(e.defenderId, list);
  }

  pendingRevenge(playerId: string): AttackEvent[] {
    const now = Date.now();
    return (this.events.get(playerId) ?? [])
      .filter(e => !e.retaliated && now - e.timestamp < this.WINDOW_MS);
  }
}
```

### Pattern 2 — Escalation scoring
```typescript
function escalationScore(history: AttackEvent[]): number {
  // 매 reciprocal exchange = +1, asymmetric = +2 (more inflammatory)
  let score = 0;
  for (let i = 1; i < history.length; i++) {
    const prev = history[i - 1];
    const cur = history[i];
    const reciprocal = prev.attackerId === cur.defenderId;
    score += reciprocal ? 1 : 2;
  }
  return score;
}
```

### Pattern 3 — Cooldown gate (anti-grief)
```typescript
function canAttack(attackerId: string, defenderId: string, history: AttackEvent[]): boolean {
  const recentSameTarget = history.filter(
    e => e.attackerId === attackerId
      && e.defenderId === defenderId
      && Date.now() - e.timestamp < 3600 * 1000,
  ).length;
  return recentSameTarget < 3; // 매 1h 내 3회 제한
}
```

### Pattern 4 — Revenge notification injection
```typescript
async function dispatchRevengePush(victim: Player, event: AttackEvent) {
  await pushService.send(victim.deviceToken, {
    title: `${event.attackerName} attacked your base!`,
    body: `Tap to retaliate. Window closes in ${remainingHours(event)}h.`,
    deepLink: `app://revenge/${event.id}`,
  });
}
```

### Pattern 5 — Asymmetric matchmaking shield
```typescript
function shieldEligibility(attacker: Player, defender: Player): boolean {
  const powerRatio = attacker.power / defender.power;
  // 매 5x power gap → 매 attack blocked (anti-snowball)
  return powerRatio < 5.0;
}
```

### Pattern 6 — Alliance vendetta propagation
```typescript
function propagateVendetta(allianceA: string, allianceB: string, severity: number) {
  if (severity > THRESHOLD_WAR) {
    declareWar(allianceA, allianceB, durationDays: 7);
    grantWarBuffs([allianceA, allianceB]);
  }
}
```

### Pattern 7 — Revenge replay capture
```typescript
function captureReplay(combatLog: CombatTick[]): ReplayBlob {
  return compress({
    seed: combatLog[0].rngSeed,
    inputs: combatLog.map(t => ({ tick: t.tick, action: t.action })),
    version: GAME_VERSION,
  });
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Casual mobile, low-skill players | Soft revenge (one-shot button, easy win) |
| Hardcore PvP (EVE) | Persistent kill mails, no auto-balance |
| New player onboarding | Newbie shield (3-7 days) |
| Whales attacking f2p | Power-ratio shield + bounty system |

**기본값**: 72h retaliation window + power-ratio shield + escalation telemetry alert at score ≥ 10.

## 🔗 Graph
- 부모: [[Live Operations (LiveOps)]] · [[Player-Experience-Modeling]]
- 변형: [[Jailing]] · [[Revenge-Cycle-Dynamics]]
- 응용: [[War-Commander-Combat-Ecosystem]] · [[Mobile Strike]] · [[EVE 온라인]]
- Adjacent: [[Prisoners-Dilemma-Models]] · [[Alliances-and-Sector-Hegemony]]

## 🤖 LLM 활용
**언제**: PvP balance proposal 작성, retention drop 의 revenge-cycle 진단, alliance war event design.
**언제 X**: PvE-only 게임, single-player narrative — revenge loop 적용 X.

## ❌ 안티패턴
- **Whale-stomping unchecked**: power gap shield 없으면 신규 유저 대량 이탈.
- **Infinite loop fuel**: revenge buff stacking → exhaustion + churn.
- **No exit ramp**: 매 player 가 cycle 에서 quit 할 수 있는 mechanism (peace treaty, alliance switch) 없으면 toxic.
- **Hidden retaliation**: 매 attack notification 없으면 cycle 자체가 발생하지 않음.

## 🧪 검증 / 중복
- Verified (Kixeye War Commander postmortems, CCP EVE devblog 2023-2025).
- Cross-ref: Mobile Strike LiveOps GDC talks.
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full revenge-cycle anatomy + 7 patterns + decision matrix |