2nd/10_Wiki/Topic_General/Game_Design/Base-Layouts-and-Kill-Zones.md

---
id: wiki-2026-0508-base-layouts-and-kill-zones
title: Base Layouts and Kill Zones
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Tower Defense Layouts, Kill Zone Design, Funnel Design]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, level-design, tower-defense, combat]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: design-doc
  framework: tower-defense / shooter
---

# Base Layouts and Kill Zones

## 매 한 줄
> **"매 funnel + overlap = kill zone"**. Base layout 은 enemy path 의 shape 결정 — kill zone 은 매 player damage output 의 overlap 이 maximum 인 spatial pocket. 매 1990s tower defense (StarCraft custom) 부터 매 2026 modern roguelike-TD (Mindustry, Bloons TD 6, Last Epoch) 까지 매 same physics: time-in-zone × DPS-coverage = kill probability.

## 매 핵심

### 매 spatial primitives
- **Funnel**: 매 narrow chokepoint — enemy density ↑.
- **Maze**: 매 path-length amplifier — time-in-zone ↑.
- **Overlap circle**: 매 multiple tower 의 range intersection — DPS-coverage ↑.
- **Kill zone** = funnel ∩ overlap with sustainable supply.

### 매 design dimensions
- **Path topology**: linear / branching / loop / open-field.
- **Damage type matching**: AoE → cluster funnel; single-target → narrow.
- **Failure budget**: leak threshold (lives) → kill zone redundancy 의 driver.

### 매 응용
1. Tower Defense layouts (Bloons, Kingdom Rush, Mindustry).
2. FPS map design — sightline + corner = kill zone.
3. RTS base building — choke at ramp + siege range = kill zone.
4. Roguelike room design — door funnel + ranged enemy stagger.

## 💻 패턴

### Kill zone scoring (designer tool)
```python
def kill_zone_score(tile, towers, path, enemy_speed=1.0):
    """Higher = better kill zone tile."""
    coverage = sum(
        1 for t in towers
        if dist(t.pos, tile) <= t.range
    )
    time_in_zone = path.length_through(tile) / enemy_speed
    return coverage * time_in_zone
```

### Funnel detection on a grid
```python
def is_funnel(grid, x, y, width=1):
    """A tile is a funnel if path width is locally constrained."""
    if grid[y][x] != PATH:
        return False
    neighbors = [(x+dx, y+dy) for dx, dy in [(-1,0),(1,0),(0,-1),(0,1)]]
    path_neighbors = sum(1 for nx, ny in neighbors if grid[ny][nx] == PATH)
    return path_neighbors <= 2  # corridor-like
```

### Overlap heatmap (Unity / Godot pseudocode)
```csharp
float[,] BuildOverlapHeatmap(List<Tower> towers, int w, int h) {
    var hm = new float[w, h];
    foreach (var t in towers)
        for (int y = 0; y < h; y++)
            for (int x = 0; x < w; x++)
                if (Vector2.Distance(t.pos, new(x, y)) <= t.range)
                    hm[x, y] += t.dps;
    return hm;
}
```

### Maze layout generator
```python
def build_maze_path(grid, entry, exit, target_length):
    """Insert obstacles to lengthen path until ≈ target_length."""
    while shortest_path(grid, entry, exit).length < target_length:
        x, y = random_buildable_tile(grid)
        grid[y][x] = OBSTACLE
        if not shortest_path(grid, entry, exit):
            grid[y][x] = EMPTY  # rollback: must remain solvable
    return grid
```

### FPS sightline kill zone (Unreal blueprint sketch)
```cpp
// 매 corner peek + cover position 의 detection
bool IsKillZone(FVector pos, const TArray<FVector>& sightlines) {
    int covering = 0;
    for (const FVector& sl : sightlines)
        if (HasLineOfSight(sl, pos)) covering++;
    return covering >= 2;  // 2+ angles = kill zone
}
```

## 매 결정 기준
| 상황 | Approach |
|---|---|
| AoE-heavy roster | Cluster funnel (long single corridor) |
| Single-target sniper roster | Multiple short overlap pockets |
| Open sandbox (Mindustry, They Are Billions) | Concentric kill zone rings |
| Roguelike room | 1 funnel + 1 elite spawner |
| FPS competitive map | 2-3 contested kill zones — 매 rotational |

**기본값**: 1 primary kill zone (60% kill share) + 1 backup (30%) + leak buffer (10%).

## 🔗 Graph
- 부모: [[Level_Design]]
- 응용: [[Procedural-Level-Geometry]]
- Adjacent: [[Combat_Balance_Buff]]

## 🤖 LLM 활용
**언제**: 매 TD / shooter / RTS 의 layout iteration, 매 telemetry 후 kill-zone 의 hot/cold 의 분석.
**언제 X**: 매 narrative / puzzle level (combat 이 primary 가 아닌 경우).

## ❌ 안티패턴
- **Single chokepoint dominance**: 매 한 kill zone 의 all-eggs-in-one — 매 boss / armored enemy 의 hard counter.
- **No leak path**: 매 perfectly sealed = 매 player decision 의 X — 매 tension 의 X.
- **Sightline 의 overdesign**: FPS 에서 매 모든 corner 가 kill zone → 매 movement 의 paralyze.

## 🧪 검증 / 중복
- Verified (Bloons TD 6 / Mindustry / Kingdom Rush postmortem 2018-2025; Counter-Strike level design GDC 2019).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — funnel × overlap formulation, scoring code, FPS / TD application |