# Runtime - 실행 인프라 계층

게임 엔진의 **생명주기 관리**와 **실행 환경**을 제공하는 계층입니다.

## 📦 모듈 구성

### `engine.rs`
- **`Engine`**: 엔진의 최상위 진입점
- 모든 매니저와 시스템의 소유자
- 초기화 → 업데이트 → 렌더링 → 종료 순환 관리

```rust
let mut engine = Engine::new("assets/");
engine.initialize(window).await?;

loop {
    engine.update(delta_time)?;
    engine.render()?;
}

engine.shutdown()?;
```

### `world.rs`
- **`World`**: ECS의 핵심 컨테이너
- 모든 Entity 생성/관리
- SystemScheduler 소유 및 실행

```rust
let entity_id = world.create_entity();
if let Some(entity) = world.get_entity_mut(entity_id) {
    entity.add_component(Sprite::default());
}

world.update(delta_time)?;
```

### `scheduler.rs`
- **`SystemScheduler`**: System들의 실행 관리자
- 등록된 시스템들을 순차 실행
- 프레임 타이밍 추적 (frame_number, total_time)

```rust
scheduler.register_system(MovementSystem)?;
scheduler.initialize()?;
scheduler.update(delta_time, entities)?;
```

### `camera.rs`
- **`Camera`**: 2D 카메라 (월드 → 뷰 좌표 변환)
- WASD 키 입력으로 이동 (200 pixels/second)
- World가 단일 인스턴스로 소유

```rust
// 카메라 접근
world.camera.position = Vec2::new(100.0, 100.0);

// 매 프레임 자동 업데이트 (World::update 내부)
world.camera.update(delta_time, input);

// 월드 좌표 → 뷰 좌표 변환
let view_pos = world.camera.world_to_view(entity_world_pos);
```

## 🎯 설계 철학

### 유일 인스턴스 (Singleton-like)
`runtime/`의 모든 구조체는 Engine이 **단 하나만** 소유합니다.

```
Engine (1개)
├── World (1개)
│   ├── Camera (1개)
│   └── SystemScheduler (1개)
│       └── systems: HashMap<SystemId, Box<dyn System>> (다중)
├── RenderSystem (1개)
└── AssetManager (1개)
```

### 생명주기 관리
모든 서브시스템의 생명주기를 명시적으로 제어합니다.

```rust
// 초기화
engine.initialize(window).await?;

// 실행 순환
loop {
    // 1. 입력 처리
    // 2. 시스템 업데이트 (World)
    // 3. 렌더링
}

// 종료
engine.shutdown()?;
```

### 실행 순서 보장
매 프레임마다 정해진 순서로 작업을 수행합니다.

1. **World.update()** - SystemScheduler를 통해 모든 System 실행
2. **RenderSystem.render()** - 화면 렌더링

## 📊 실행 흐름

### 초기화 단계
```
Engine::initialize()
├── RenderSystem::initialize()  (GPU 초기화)
├── AssetManager::new()         (Device/Queue 전달)
└── World::initialize()         (모든 System 초기화)
    └── SystemScheduler::initialize()
```

### 게임 루프
```
Engine::update(delta_time)
└── World::update(delta_time, input)
    ├── Camera::update(delta_time, input)  (WASD 입력)
    └── SystemScheduler::update(delta_time, entities, input, camera)
        ├── System1::update(context)
        ├── System2::update(context)
        └── ...

Engine::render()
└── RenderSystem::render(&World, &AssetManager)
    └── SpriteBatch::collect_sprites(entities, camera)  (카메라 offset 적용)
```

### 종료 단계
```
Engine::shutdown()
└── World::shutdown()
    └── SystemScheduler::shutdown()
        ├── System1::shutdown()
        ├── System2::shutdown()
        └── ...
```

## 🔗 관련 계층

- **`core/`**: Entity, System, Component trait 제공
- **`managers/`**: AssetManager, SceneManager 제공
- **`render/`**: RenderSystem 제공 (특수 케이스)

## 🚀 사용 예시

### 최소 게임 루프
```rust
use moltrun::runtime::Engine;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let mut engine = Engine::new("assets/");
    
    // Window 생성 (winit 등)
    let window = create_window()?;
    
    engine.initialize(window).await?;
    
    let mut last_time = std::time::Instant::now();
    
    loop {
        let now = std::time::Instant::now();
        let delta_time = (now - last_time).as_secs_f32();
        last_time = now;
        
        engine.update(delta_time)?;
        engine.render()?;
    }
    
    engine.shutdown()?;
    Ok(())
}
```

### System 등록
```rust
let mut engine = Engine::new("assets/");
engine.world.register_system(MyGameSystem::new())?;
```
