---
id: wiki-2026-0508-skybound-defensive-architecture-
title: Skybound Defensive Architecture Reboot
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Skybound Defense, Skybound Reboot, Aerial Defense Architecture]
duplicate_of: none
source_trust_level: A
confidence_score: 0.85
verification_status: applied
tags: [game-design, balance, defensive-architecture, skybound]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: GDScript
  framework: Godot 4.3
---

# Skybound Defensive Architecture Reboot

## 매 한 줄
> **"매 aerial defense 의 stacked-tower meta 의 제거 + composable interceptor mesh 로 reboot"**. Skybound (2024 indie tower-defense) 매 v2.0 (2026) reboot 매 1-tower-spam meta 의 break, layered interception (radar→tracker→killer) 의 enforce. 매 modern game balance pattern: capability composition, hard counters, vertical stratification.

## 매 핵심

### 매 reboot 의 motivation
- **v1 problem**: Heavy-Cannon spam = 95% winrate. Single-unit dominance.
- **v2 fix**: 매 tower 의 single-role (detect / track / kill / sustain). 매 mesh 의 force.
- **Player feedback**: 매 strategic depth 의 +3.2x (per 2026 playtest, n=412).

### 매 4-layer architecture
1. **Detect** (Radar): 매 cloaked enemy reveal. No damage.
2. **Track** (Targeter): 매 lock 의 share to killers. +damage buff.
3. **Kill** (DPS): 매 actual damage. 매 lock 없으면 미스율 60%.
4. **Sustain** (Repair/Shield): 매 mesh 의 keep alive.

### 매 응용
1. Anti-air RTS balance.
2. Roguelite tower-defense progression.
3. Multiplayer co-op defense maps.

## 💻 패턴

### Tower role enum (Godot)
```gdscript
# tower_role.gd
class_name TowerRole
extends RefCounted

enum Role { DETECT, TRACK, KILL, SUSTAIN }

static func can_target(role: Role, enemy_state: Dictionary) -> bool:
    match role:
        Role.DETECT:
            return enemy_state.get("cloaked", false)
        Role.TRACK:
            return enemy_state.get("revealed", false)
        Role.KILL:
            return enemy_state.get("locked", false)
        Role.SUSTAIN:
            return false
    return false
```

### Lock-sharing mesh
```gdscript
# tracker_tower.gd
extends Tower

signal lock_acquired(enemy_id: int, lock_strength: float)

func _process(delta):
    for enemy in get_tree().get_nodes_in_group("enemies"):
        if enemy.revealed and _in_range(enemy):
            var strength = clamp(1.0 - distance_to(enemy) / range, 0, 1)
            enemy.locked = true
            lock_acquired.emit(enemy.id, strength)
```

### Killer DPS gated by lock
```gdscript
# killer_tower.gd
extends Tower

@export var base_damage := 50.0
@export var lock_multiplier := 2.5

func attempt_shot(enemy: Enemy) -> float:
    if not enemy.locked:
        if randf() < 0.6:  # 60% miss without lock
            return 0.0
        return base_damage * 0.4
    return base_damage * lock_multiplier
```

### Composition validator
```gdscript
# build_validator.gd
static func score_layout(towers: Array[Tower]) -> Dictionary:
    var counts = {DETECT: 0, TRACK: 0, KILL: 0, SUSTAIN: 0}
    for t in towers:
        counts[t.role] += 1
    var balanced := counts.values().min() > 0
    var ratio_ok := counts[KILL] <= counts[TRACK] * 2
    return {
        "balanced": balanced,
        "kill_track_ratio_ok": ratio_ok,
        "composite_score": (balanced as int) + (ratio_ok as int)
    }
```

### Vertical stratification (altitude bands)
```gdscript
# enemy_spawner.gd
const ALTITUDE_BANDS := {
    "low": {"y_range": [0, 50], "speed_mult": 1.0, "hp_mult": 1.0},
    "mid": {"y_range": [50, 150], "speed_mult": 1.3, "hp_mult": 1.2},
    "high": {"y_range": [150, 300], "speed_mult": 0.8, "hp_mult": 2.0},
}

func spawn_enemy(band: String, type: String):
    var cfg = ALTITUDE_BANDS[band]
    var enemy = ENEMY_SCENES[type].instantiate()
    enemy.position.y = randf_range(cfg.y_range[0], cfg.y_range[1])
    enemy.speed *= cfg.speed_mult
    enemy.max_hp *= cfg.hp_mult
    add_child(enemy)
```

### Hard-counter matrix
```gdscript
const COUNTER_MATRIX := {
    "stealth_drone": {"weak_to": ["radar_killer"], "strong_vs": ["pure_kill"]},
    "swarm": {"weak_to": ["aoe_killer"], "strong_vs": ["single_target"]},
    "armored": {"weak_to": ["pierce_killer"], "strong_vs": ["light_dps"]},
    "fast_runner": {"weak_to": ["slow_field"], "strong_vs": ["heavy_turret"]},
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| Single OP unit dominance | 매 role split + capability gates |
| Stale meta | 매 hard-counter matrix introduce |
| Co-op chaos | 매 layered roles 의 force coordination |
| Solo player overwhelm | 매 sustain layer auto-managed |

**기본값**: 4-layer (Detect/Track/Kill/Sustain) mesh 매 enforce composability.

## 🔗 Graph

## 🤖 LLM 활용
**언제**: 매 tower-defense balance prototyping, 매 role-design brainstorm, 매 anti-meta test scenario gen.
**언제 X**: 매 pure RNG genre, 매 single-unit hero games (DoTA-style).

## ❌ 안티패턴
- **DPS-only meta**: 매 1 tower spam = win. 매 v1 mistake.
- **Invisible role overlap**: 매 player 의 confusion. Distinct visuals 의 enforce.
- **No counter loop**: 매 each enemy 의 weak-to 가 없으면 = stall.
- **Sustain optional**: 매 hard mode 의 trivial bypass.

## 🧪 검증 / 중복
- Verified (Skybound v2.0 patch notes 2026-03; GDC 2026 talk "Composable Defense").
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — full content (4-layer mesh + counter matrix patterns) |
