---
id: wiki-2026-0508-구역-통제-및-동맹-전쟁-sector-control-and
title: 구역 통제 및 동맹 전쟁 (Sector Control and Alliance Wars)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Sector Control, Alliance Wars, Territory Control RTS, Guild Warfare]
duplicate_of: none
source_trust_level: B
confidence_score: 0.85
verification_status: applied
tags: [game-design, rts, mmo, pvp, territory-control, alliance]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: typescript
  framework: game-design
---

# 구역 통제 및 동맹 전쟁 (Sector Control and Alliance Wars)

## 매 한 줄
> **"매 sector control 의 핵심 = 'persistent territorial map 의 alliance 의 collective effort 의 contested resource 의 yield'."**. EVE Online (2003) sovereignty system 의 archetype → Albion Online / Foxhole / New World 의 modern iteration 의 inspire. 매 design 의 essence 의 individual action 의 macro-political consequence 의 mapping.

## 매 핵심

### 매 Core loop
- **Map**: hex / region grid 의 strategic value 의 differentiated (resource yield, choke point, trade route).
- **Capture**: timer-based PvP window (e.g., "vulnerability window") + objective control (capture point, structure).
- **Hold**: tax / upkeep / defense rotation.
- **Lose**: enemy capture or upkeep failure.
- **Reward**: tier-based resource extraction, alliance buffs, cosmetic / political prestige.

### 매 Alliance mechanics
- **Diplomacy tiers**: ally / neutral / NAP (non-aggression pact) / war.
- **Permission structure**: officer / diplomat / member roles.
- **Asset sharing**: alliance bank, shared structures.
- **Coalition / bloc**: meta-alliance of alliances.

### 매 War mechanics
1. **Declaration cost**: gold / influence / cooldown — 매 frivolous war 의 prevent.
2. **Battle scoring**: kills, objective captures, ticks held.
3. **Resolution**: win / lose / draw → territory / reparation 의 transfer.
4. **Time-zone fairness**: 매 prime time clash 의 across regions.

## 💻 패턴

### Pattern 1: Sector data model
```typescript
interface Sector {
  id: string;
  coordinates: [number, number];
  tier: 1 | 2 | 3 | 4 | 5;          // resource yield tier
  controllingAllianceId: string | null;
  vulnerabilityWindow: { start: string; end: string }; // UTC time range
  upkeepDue: Date;
  upkeepCostPerDay: number;
  resourceNodes: ResourceNode[];
  fortLevel: 0 | 1 | 2 | 3;          // defensive structure tier
  contestedBy: string | null;        // attacker alliance ID, if active siege
}

interface Alliance {
  id: string;
  name: string;
  leaderId: string;
  members: GuildId[];                // alliance of guilds
  treasury: number;
  diplomacy: Map<AllianceId, DiplomaticState>;
  controlledSectors: string[];
}
```

### Pattern 2: Vulnerability window scheduler
```typescript
function isVulnerable(sector: Sector, now: Date = new Date()): boolean {
  const utcHour = now.getUTCHours();
  const start = parseInt(sector.vulnerabilityWindow.start.slice(0, 2));
  const end = parseInt(sector.vulnerabilityWindow.end.slice(0, 2));
  return utcHour >= start && utcHour < end;
}

// Defender chooses 4-hour daily window to balance time-zone fairness
function setDefenderWindow(sector: Sector, startHourUTC: number) {
  if (sector.controllingAllianceId === null) throw new Error('No owner');
  sector.vulnerabilityWindow = {
    start: `${String(startHourUTC).padStart(2, '0')}:00`,
    end:   `${String((startHourUTC + 4) % 24).padStart(2, '0')}:00`,
  };
}
```

### Pattern 3: Capture progress (objective control)
```typescript
interface CaptureState {
  attackers: number;    // present units
  defenders: number;
  progress: number;     // 0..100
}

function tickCapture(state: CaptureState, deltaSec: number): CaptureState {
  const ratio = state.attackers / Math.max(1, state.defenders);
  const rate = Math.min(2.0, Math.log2(ratio + 1));   // diminishing returns
  const change = ratio > 1 ? rate * deltaSec : -0.5 * deltaSec;
  return { ...state, progress: Math.max(0, Math.min(100, state.progress + change)) };
}
```

### Pattern 4: War declaration + reparation
```typescript
async function declareWar(attacker: Alliance, defender: Alliance) {
  const cost = 100_000 + 50_000 * defender.controlledSectors.length;
  if (attacker.treasury < cost) throw new Error('Insufficient treasury');

  attacker.treasury -= cost;
  attacker.diplomacy.set(defender.id, 'WAR');
  defender.diplomacy.set(attacker.id, 'WAR');

  await scheduleEvent({
    type: 'WAR_END_CHECK',
    delay: 7 * 24 * 3600,  // 7-day war
    payload: { attackerId: attacker.id, defenderId: defender.id },
  });
}
```

### Pattern 5: Upkeep tick (lose territory if unpaid)
```typescript
async function dailyUpkeepTick() {
  for (const sector of await db.getOwnedSectors()) {
    const alliance = await db.getAlliance(sector.controllingAllianceId!);
    if (alliance.treasury >= sector.upkeepCostPerDay) {
      alliance.treasury -= sector.upkeepCostPerDay;
    } else {
      sector.controllingAllianceId = null;  // sector goes neutral
      await broadcast(`${sector.id} lost due to upkeep failure`);
    }
  }
}
```

### Pattern 6: Battle outcome scoring
```typescript
function resolveBattle(scoreboard: Scoreboard): 'attacker_win' | 'defender_win' | 'draw' {
  const aScore = scoreboard.attackerKills * 10
               + scoreboard.attackerCaptures * 100
               + scoreboard.attackerTicks;
  const dScore = scoreboard.defenderKills * 10
               + scoreboard.defenderCaptures * 100
               + scoreboard.defenderTicks * 1.2;  // defender bonus
  if (aScore > dScore * 1.1) return 'attacker_win';
  if (dScore > aScore * 1.1) return 'defender_win';
  return 'draw';
}
```

### Pattern 7: Coalition diplomacy graph
```typescript
function isHostile(allianceA: Alliance, allianceB: Alliance, coalitions: Coalition[]): boolean {
  const direct = allianceA.diplomacy.get(allianceB.id);
  if (direct === 'WAR') return true;
  const sharedCoalition = coalitions.find(
    c => c.members.includes(allianceA.id) && c.members.includes(allianceB.id)
  );
  return !sharedCoalition && direct !== 'ALLY' && direct !== 'NAP';
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Hardcore PvP / large-scale | EVE-style sovereignty + fixed windows |
| Casual / shorter session | Albion-style GvG (5v5) + scheduled |
| Persistent war / no respawn | Foxhole-style logistics-driven |
| Hybrid PvE / PvP | New World-style 50v50 invasion |
| Mobile / async | Lords Mobile-style turn-based skirmish |

**기본값**: timer-based vulnerability + objective capture + alliance diplomacy graph + upkeep system.

## 🔗 Graph

## 🤖 LLM 활용
**언제**: balance 의 simulation / war narrative 의 generation / political event 의 GM.
**언제 X**: 매 PvP balance 의 final tuning — 매 player playtesting 의 substitute 의 X.

## ❌ 안티패턴
- **No vulnerability window**: 매 24/7 attack 의 burnout 의 cause.
- **Winner-take-all**: 매 small alliance 의 entry 의 X → server stagnation.
- **Free war declaration**: 매 grief war / harassment 의 enable.
- **No upkeep**: 매 hoarding incentive → 매 territory 의 ossify.
- **Time-zone unfair**: 매 single peak window → off-region 의 永遠 disadvantage.
- **No diplomacy depth**: 매 binary friend/foe → 매 coalition politics 의 stillborn.

## 🧪 검증 / 중복
- Verified: EVE Online sovereignty mechanic docs, Albion Online GvG ruleset, Foxhole design articles, "MMO Architecture" (Bartle, Koster).
- 신뢰도 B (game-design domain, 매 some opinion-driven).

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full sector control / alliance war design |
