2nd/10_Wiki/Topic_Programming/AI_and_ML/구역 통제 및 동맹 전쟁(Sector Control and Alliance Wars).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-구역-통제-및-동맹-전쟁-sector-control-and	구역 통제 및 동맹 전쟁 (Sector Control and Alliance Wars)	10_Wiki/Topics	verified	self	Sector Control Alliance Wars Territory Control RTS Guild Warfare	none	B	0.85	applied	game-design rts mmo pvp territory-control alliance		2026-05-10	pending	language framework typescript 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

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

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)

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

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)

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

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

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