2nd/10_Wiki/Topics/Other/자원 로지스틱스(Resource Logistics).md

---
id: wiki-2026-0508-자원-로지스틱스-resource-logistics
title: 자원 로지스틱스(Resource Logistics)
category: 10_Wiki/Topics
status: verified
canonical_id: self
aliases: [Resource Logistics, Supply Chain (Game), Resource Flow Design, 자원 흐름]
duplicate_of: none
source_trust_level: A
confidence_score: 0.9
verification_status: applied
tags: [game-design, economy, systems-design, factorio, rts]
raw_sources: []
last_reinforced: 2026-05-10
github_commit: pending
tech_stack:
  language: typescript
  framework: ecs-bevy
---

# 자원 로지스틱스(Resource Logistics)

## 매 한 줄
> **"매 source → transport → buffer → consumer 매 chain 매 game 의 의 backbone"**. 매 *Factorio* (2016 → 2.0 Space Age 2024) 매 belt-bot-train 매 trinity, *Dyson Sphere Program* (2021), *Satisfactory* (1.0 2024) 매 매 매 동일한 design pillar — 매 player 매 logistics 의 의 의 의 의 의 problem 의 의 의 solving.

## 매 핵심

### 매 logistics primitives
1. **Source (생산)**: miner / extractor / spawn point.
2. **Transport (수송)**: belt, pipe, train, drone, teleport.
3. **Buffer (저장)**: chest, tank, warehouse.
4. **Consumer (소비)**: assembler, smelter, ship, player.
5. **Throttle / 제어**: priority splitter, circuit network, request gate.

### 매 transport 매 axis tradeoffs
- **belt**: cheap, infinite, slow, density-bound.
- **pipe**: fluid only, pressure-aware (DSP, Satisfactory 1.0).
- **train**: high-throughput, high-latency, expensive.
- **drone / bot**: flexible routing, energy-intensive.
- **teleport / portal**: 매 endgame, breaks classical logistics tension.

### 매 응용
1. *Factorio* main bus 의 vs city-block layout.
2. *Satisfactory* 의 train network + drone hops.
3. *Dyson Sphere Program* 의 logistics tower 의 interplanetary supply.
4. *Anno 1800* 의 trade route + warehouse.
5. *RimWorld* 의 stockpile priority + pawn hauling AI.

## 💻 패턴

### Belt throughput simulation
```typescript
interface BeltSegment {
  capacity: number;     // items / sec (Factorio yellow=15, red=30, blue=45)
  current: number;
  upstream?: BeltSegment;
}

function tickBelt(seg: BeltSegment, dt: number) {
  const incoming = Math.min(seg.upstream?.current ?? 0, seg.capacity * dt);
  seg.current += incoming;
  if (seg.upstream) seg.upstream.current -= incoming;
  // saturation = bottleneck visible to player
  return { saturation: seg.current / (seg.capacity * dt) };
}
```

### Producer/consumer rate matching
```typescript
function balanceRatio(producerRate: number, consumerRate: number): number {
  return producerRate / consumerRate;
  // ratio = 1.0 → balanced
  // < 1   → consumer starves (add producers)
  // > 1   → buffer overflow (add consumers / storage)
}

// Factorio classic: 1 stone furnace = 0.3125 plate/s
// 1 yellow belt = 15 items/s → needs 48 furnaces to saturate
```

### Train scheduling (priority + fuel)
```typescript
type Station = { id: string; demand: number; supply: number };

function dispatchTrain(stations: Station[]): { from: string; to: string } | null {
  const supplier = stations.filter(s => s.supply > 0)
    .sort((a, b) => b.supply - a.supply)[0];
  const consumer = stations.filter(s => s.demand > 0)
    .sort((a, b) => b.demand - a.demand)[0];
  if (!supplier || !consumer) return null;
  return { from: supplier.id, to: consumer.id };
}
```

### Drone routing (cost-aware)
```typescript
function chooseDrone(drones: Drone[], from: Vec2, to: Vec2): Drone | null {
  return drones
    .filter(d => d.battery > distance(from, to) * d.energyPerTile)
    .sort((a, b) => distance(a.pos, from) - distance(b.pos, from))[0];
}
```

### Stockpile priority (RimWorld-style)
```typescript
interface Stockpile {
  id: string;
  priority: 1 | 2 | 3 | 4 | 5;  // 5 = highest
  acceptedTags: string[];
  capacity: number;
  current: number;
}

function chooseStockpile(piles: Stockpile[], item: Item): Stockpile | null {
  return piles
    .filter(p => p.acceptedTags.includes(item.tag))
    .filter(p => p.current < p.capacity)
    .sort((a, b) => b.priority - a.priority)[0] ?? null;
}
```

### Bottleneck detector (ECS / Bevy-style pseudo)
```rust
// Bevy system that flags saturated belts for player visualization
fn detect_bottlenecks(
    mut belts: Query<(&BeltSegment, &mut MaterialColor)>,
) {
    for (belt, mut color) in &mut belts {
        let sat = belt.current / belt.capacity;
        color.0 = if sat > 0.95 { RED } else if sat > 0.7 { YELLOW } else { GREEN };
    }
}
```

## 매 결정 기준
| 상황 | transport |
|---|---|
| 매 short distance, low rate | belt |
| 매 long distance, high rate | train |
| 매 fluid | pipe |
| 매 sparse / mobile target | drone |
| 매 cross-planet / cross-zone | logistics tower / portal |

**기본값**: 매 early-game belt → mid-game train → late-game drone+train hybrid → endgame logistics network.

## 🔗 Graph
- 부모: [[Game Economy]]
- 응용: [[프리미엄 통화 브릿지(Premium Currency Bridge)]]
- Adjacent: [[Operations Research]]

## 🤖 LLM 활용
**언제**: 매 factory builder / RTS / colony sim 매 design, 매 production-chain balance 의 의 system 의 build 시.
**언제 X**: 매 narrative-only / linear adventure — 매 logistics 매 systems-driven design 의 의 의 매 fit.

## ❌ 안티패턴
- **매 infinite buffer**: 매 buffer 매 size 매 ∞ 시 매 logistics tension 매 의 의 disappears.
- **매 zero friction**: 매 instant teleport 매 baseline → 매 layout 매 의 의 의 의 의 trivial.
- **매 over-coupled**: 매 single bottleneck 매 chain 의 의 의 의 의 cascade — 매 player frustration.
- **매 invisible bottleneck**: 매 saturation visualization 매 X → 매 player 매 의 의 root cause 의 의 의 X.

## 🧪 검증 / 중복
- Verified (Wube Software dev blogs Factorio FFF series, Coffee Stain Studios Satisfactory talks, GDC factory-builder 의 talks 2023-2025).
- 신뢰도 A.

## 🕓 Changelog
| 날짜 | 변경 |
|---|---|
| 2026-05-08 | Phase 1 |
| 2026-05-10 | Manual cleanup — logistics primitives + transport tradeoffs + working belt/train/drone code |