Geo-Lab v4.1 - Clean deployment

.gitignore

@@ -0,0 +1,31 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.env
+
+# Streamlit
+.streamlit/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db
+
+# Logs
+*.log
+
+# Binary assets (too large for HuggingFace)
+assets/reference/
+*.png
+*.jpg
+*.jpeg

00_Master_Integration_Plan.md

@@ -0,0 +1,138 @@
+# 🌍 [Geo-Lab AI] 통합 아키텍처 설계서 (Master Integration Plan)
+
+**Project Name:** Geo-Lab AI: The Living Earth
+**Version:** Global Build 1.0 (Integration Phase)
+**Scope:** Full-stack Geomorphology Simulation (All Modules)
+**Director:** [User Name]
+
+---
+
+## 0. 통합 개발 철학 (System Philosophy)
+
+**"지형은 고립되어 있지 않다 (No Landform is an Island)."**
+본 통합 시스템은 7개의 독립 모듈(하천, 해안, 카르스트, 화산, 빙하, 건조, 평야)을 **'가이아 엔진(Gaia Engine)'**이라는 하나의 물리 서버 위에서 유기적으로 구동한다. 사용자가 조절하는 기후와 지각 에너지가 나비 효과처럼 전 지구적 지형 변화를 일으키는 **순환 시스템(Feedback Loop)** 구현을 목표로 한다.
+
+---
+
+## 1. 시스템 아키텍처: 가이아 엔진 (The Gaia Engine)
+
+모든 개별 모듈은 아래 3가지 **글로벌 변수(Global Variables)**에 종속되어 작동한다.
+
+### 🎛️ 글로벌 컨트롤러 (Global Controllers)
+1.  **지각 에너지 ($E_{tectonics}$):**
+    * *Role:* 판의 이동 속도 및 마그마 활동성 제어.
+    * *Impact:* $E \uparrow$ $\Rightarrow$ 신기 습곡 산지 융기, 화산 폭발 빈도 증가, 지진 발생.
+2.  **기후 레벨 ($C_{climate}$):**
+    * *Role:* 지구 평균 기온($T_{avg}$) 및 강수량($P_{avg}$) 제어.
+    * *Impact:* $T \downarrow$ $\Rightarrow$ 빙하 확장 (빙기). $T \uparrow$ $\Rightarrow$ 빙하 후퇴 및 해수면 상승 (간빙기).
+3.  **해수면 고도 ($H_{sea}$):**
+    * *Role:* 침식 기준면(Base Level) 설정.
+    * *Impact:* $H \downarrow$ $\Rightarrow$ 하천 하방 침식 강화(감입 곡류). $H \uparrow$ $\Rightarrow$ 하구 퇴적 강화(삼각주, 석호).
+
+---
+
+## 2. 모듈 간 상호작용 로직 (Cross-Module Interaction)
+
+지형 모듈끼리 데이터를 주고받으며 새로운 지형을 생성하는 **인과관계 체인(Chain)**을 정의한다.
+
+### 🔗 Chain A. [산지] $\leftrightarrow$ [건조]: 비그늘 효과 (Rain Shadow)
+* **Logic:** 거대한 습곡 산맥이 융기하여 수증기를 막음.
+* **Process:**
+    1.  **[산지]** 모듈: 해발고도 $H > 3,000m$ 산맥 생성.
+    2.  **[기상]** 엔진: 편서풍이 산맥에 부딪혀 비를 뿌림 (바람받이 사면).
+    3.  **[건조]** 모듈 트리거: 산맥 반대편에 건조 기후 형성 $\rightarrow$ 사막/사구 생성.
+
+### 🔗 Chain B. [빙하] $\leftrightarrow$ [평야]: 융빙수와 범람 (Meltwater Pulse)
+* **Logic:** 빙하기가 끝나고 간빙기가 오면 막대한 물이 평야로 쏟아짐.
+* **Process:**
+    1.  **[빙하]** 모듈: 기온 상승($T \uparrow$)으로 빙하 후퇴.
+    2.  **[수문]** 엔진: 융빙수 유입량($Q_{melt}$) 급증.
+    3.  **[평야]** 모듈 트리거: 하천 유량 폭증 $\rightarrow$ 범람원 확대, 배후습지 형성, 하구 삼각주 성장 가속.
+
+### 🔗 Chain C. [화산] $\leftrightarrow$ [카르스트]: 산성과 염기성 (Chemical Weathering)
+* **Logic:** 화산 활동으로 인한 산성비가 석회암 용식을 가속화.
+* **Process:**
+    1.  **[화산]** 모듈: 화산 폭발로 대기 중 $SO_2, CO_2$ 농도 증가.
+    2.  **[환경]** 엔진: 빗물의 $pH$ 농도 하락 (산성비).
+    3.  **[카르스트]** 모듈 트리거: 기반암이 석회암인 지역의 용식 속도($Rate_{dissolution}$) 2배 가속 $\rightarrow$ 거대 동굴 생성.
+
+### 🔗 Chain D. [빙하] $\leftrightarrow$ [해안]: 피오르의 탄생 (Fjord Formation)
+* **Logic:** 빙하가 깎아낸 U자곡에 바닷물이 들어차 깊고 좁은 만을 형성.
+* **Process:**
+    1.  **[빙하]** 모듈: 빙하기에 해안까지 도달하는 거대 빙하가 U자곡을 깊게 침식.
+    2.  **[기후]** 엔진: 간빙기 도래로 해수면 상승($H_{sea} \uparrow$).
+    3.  **[해안]** 모듈 트리거: 바닷물이 U자곡으로 침투 $\rightarrow$ 피오르(Fjord) 형성.
+
+### 🔗 Chain E. [화산] $\leftrightarrow$ [해안]: 현무암 해안 (Volcanic Coast)
+* **Logic:** 용암이 바다에 닿으며 급격히 냉각되어 독특한 해안 지형 형성.
+* **Process:**
+    1.  **[화산]** 모듈: 해안 인근에서 현무암질 용암 분출.
+    2.  **[냉각]** 엔진: 바닷물과 접촉하며 급랭 $\rightarrow$ 주상절리 형성.
+    3.  **[해안]** 모듈 트리거: 주상절리 해안 절벽 생성 (예: 제주 중문 대포해안).
+
+### 🔗 Chain F. [하천] $\leftrightarrow$ [해안]: 삼각주 vs 삼각강 (Delta vs Estuary)
+* **Logic:** 하구에서 하천 에너지와 해양 에너지의 상대적 크기에 따라 퇴적 또는 침식 발생.
+* **Process:**
+    1.  **[하천]** 모듈: 하구에 퇴적물 공급 (Sediment Load).
+    2.  **[해안]** 엔진: 파랑/조류의 퇴적물 재분배 능력 계산.
+    3.  **결과:** 하천 우세 → 삼각주(Delta), 조류 우세 → 삼각강(Estuary).
+
+---
+
+## 3. 캠페인 시나리오 (Campaign Mode Missions)
+
+학생들이 지형 형성 원���를 게임처럼 익힐 수 있는 미션 목록.
+
+| 시나리오 (Title) | 목표 (Mission Objective) | 필요 모듈 조합 | 난이도 |
+| :--- | :--- | :--- | :--- |
+| **불과 얼음의 노래** | 화산 폭발로 생긴 산 정상에 만년설과 빙하를 형성하라. (아이슬란드, 킬리만자로 형) | **화산 + 빙하** | ⭐⭐⭐ |
+| **사막의 기적** | 건조한 사막에 외래 하천을 흐르게 하여 하구에 거대 삼각주를 건설하라. (이집트 나일강 형) | **건조 + 평야** | ⭐⭐⭐⭐ |
+| **시간의 동굴** | 융기된 산지를 침식시켜 지하수면을 낮추고, 석회동굴을 육상에 노출시켜라. (단양 고수동굴 형) | **산지 + 카르스트** | ⭐⭐ |
+| **대홍수 (The Flood)** | 빙하기를 끝내고 해수면을 100m 상승시켜, U자곡을 피오르로, 하구를 석호로 만들어라. | **빙하 + 평야 + 해안** | ⭐⭐⭐⭐⭐ |
+
+---
+
+## 4. UI/UX: 마스터 대시보드 (Master Dashboard Design)
+
+### 🖥️ Viewport Layout
+1.  **Main Globe (Center):** 3D 지구본 뷰. 휠 스크롤로 우주(위성 사진)에서 지하(단면도)까지 심리스 줌인/아웃.
+2.  **Control Deck (Bottom):** 타임라인 슬라이더. (고생대 $\leftrightarrow$ 현세). 시간을 돌리며 지형 변화 관찰.
+3.  **Mini-Map (Right-Top):** 현재 지형의 형성 원리(작용)를 아이콘으로 표시 (🌊유수, 🌬️바람, 🌋마그마, ❄️빙하).
+
+### 📊 Data Visualization
+* **Cross-Section Overlay:** 지표면 아래 지질 구조(습곡, 단층, 지하수, 마그마 방)를 엑스레이처럼 투시.
+* **Eco-System Status:** 현재 지형에 적합한 농업(벼농사 vs 밭농사 vs 목축) 및 거주 적합도 점수 표시.
+
+---
+
+## 5. 데이터 통신 규격 (JSON Data Structure)
+
+통합 엔진이 처리할 최종 월드 상태 데이터 예시.
+
+```json
+{
+  "World_State": {
+    "Timestamp": "Epoch_Holocene_Early",
+    "Global_Temp": 14.5,
+    "Sea_Level_Base": 0
+  },
+  "Active_Regions": [
+    {
+      "Region_ID": "NE_Asia",
+      "Base_Rock": "Granite",
+      "Landforms": [
+        {"Type": "Mountain", "Age": "Old", "Feature": "Erosion_Dome"},
+        {"Type": "Plain", "Feature": "Alluvial_Fan", "Source": "Mountain_Runoff"}
+      ],
+      "Climate_Effect": "Monsoon"
+    },
+    {
+      "Region_ID": "Pacific_Rim",
+      "Base_Rock": "Basalt",
+      "Landforms": [
+        {"Type": "Volcano", "Shape": "Shield", "Status": "Active"}
+      ],
+      "Tectonic_Activity": "High"
+    }
+  ]
+}

01_River_Landforms_Spec.md

@@ -0,0 +1,70 @@
+# 📘 [Geo-Lab AI] 개발 백서 (Development White Paper)
+
+**Project Name:** Geo-Lab AI
+**Version:** Final Release 1.0
+**Module:** Fluvial Landforms (하천 지형)
+**Target:** High School Geography ~ Undergraduate Geomorphology
+**Director:** [User Name]
+
+---
+
+## 0. 개발 표준 및 제약사항 (Standard Protocols)
+
+### 🎨 1. 비주얼 스타일 가이드 (Visual Style: Schematic Education)
+* **Tone:** Clean, Minimalist, Textbook-style 3D. (군더더기 없는 깔끔한 교과서 삽화 스타일)
+* **Color Palette:**
+    * *Water:* 반투명한 밝은 파랑 (내부 유속 흐름 가시화).
+    * *Sediment:* 입자 크기별 색상 구분 (자갈=회색, 모래=노랑, 점토=갈색).
+    * *Bedrock:* 층리(Layer)가 명확히 보이는 단면 텍스처.
+* **Key Feature:** 모든 지형은 '케이크 자르듯' 단면을 보여주는 **Cutaway View**가 기본 지원되어야 함.
+
+### 🛠️ 2. 기술 스택 (Tech Stack)
+* **Backend:** Python 3.9+ (Libraries: `NumPy`, `SciPy`, `Taichi` for Physics).
+* **Frontend:** WebGL via `Three.js` or `PyVista`.
+* **App Framework:** `Streamlit` (Web-based Interface).
+
+---
+
+## 1. 하천 지형 모듈 세부 명세 (Module Specifications)
+
+### 🌊 Chapter 1. 상류 (Upper Course): 파괴와 개척
+**핵심 로직:** 하방 침식(Vertical Erosion), 두부 침식(Headward Erosion), 사면 붕괴.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **V자곡** | 침식력($E$), 암석 강도($K$), 경사($S$) | 바닥 하방 침식 후 **양옆 사면이 붕괴(Mass Wasting)**되어 V자가 완성되는 과정 강조. | $E = K \cdot A^m \cdot S^n$ (Stream Power Law) |
+| **폭포 & 협곡** | 유량($Q$), 낙차 높이($h$) | 하단부 굴착(Undercutting) → 상단 붕괴 → 폭포가 뒤로 물러나며 **협곡(Gorge)** 형성. | Crosby's Knickpoint Retreat Model |
+| **하천 쟁탈** | 침식 속도 차이($\Delta E$), 거리 | 한쪽 강이 두부 침식으로 다른 강의 옆구리를 터트려 물을 뺏어오고, 뺏긴 강이 말라가는 과정. | Stream Capture Ratio |
+| **돌개구멍** | 와류 강도(Vortex), 자갈 경도 | **[X-ray View]** 강바닥 투시. 자갈이 소용돌이치며 암반을 드릴처럼 뚫는 내부 모습. | Abrasion Rate $\propto$ Kinetic Energy |
+| **감입 곡류 (상류형)** | 암석 저항성, 최단 경로 | 단단한 암반을 피해 굽이치며 흐르는 물길과 깍지 낀 능선(Interlocking Spurs). | - |
+
+### ➰ Chapter 2. 중류 (Middle Course): 운반과 곡류
+**핵심 로직:** 측방 침식(Lateral Erosion), 분급(Sorting), 유속 차이에 의한 퇴적.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **선상지** | 입자 크기($d$), 유속 감소율($-\Delta v$) | 선정(자갈)-선앙(모래)-선단(점토) 분급 및 **복류천(지하수 흐름)** 단면도. | Stokes' Law (Settling Velocity) |
+| **곡류 & 우각호** | 원심력($F_c$), 유로 굴곡도 | 공격사면(절벽) vs 퇴적사면(백사장). 홍수 시 유로 절단(Cutoff) 및 우각호 고립 애니메이션. | Helical Flow Model |
+| **감입 곡류 (융기형)** | 융기 속도($U$), 기존 굴곡도 | **[Comparison Mode]** 자유 곡류(접시형 단면) vs 감입 곡류(밥그릇형 깊은 단면) 비교. | Incision Rate = Erosion - Uplift |
+| **하안단구** | 지반 융기($U$), 기저면 변동 | 융기 이벤트 발생 시 강바닥이 깊어지며 범람원이 계단 모양 언덕(Terrace)으로 남음. | - |
+| **범람원** | 홍수 빈도, 부유 하중 | 홍수 시 제방(두꺼움/모래)과 배후습지(얇음/점토)의 거리별 퇴적 차이. | Overbank Sedimentation |
+
+### ⚓ Chapter 3. 하류 (Lower Course): 바다와의 균형
+**핵심 로직:** 유속 소멸, 파랑/조류 에너지 상호작용.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **삼각주** | 강 에너지 vs 파랑 vs 조류 | **[Triangle Mixer UI]** 3가지 힘 조절 → 조족상(미시시피) ↔ 원호상(나일) 모양 변환. | Galloway's Classification |
+| **삼각강 (Estuary)** | 조차(Tidal Range), 조류 속도 | 강한 조류가 퇴적물을 쓸어가며 하구가 나팔 모양으로 확장되는 과정. | Tidal Scour Equation |
+| **하중도** | 유속 사각지대, 식생 밀도 | 강폭이 넓은 곳에 모래섬 형성 후 식생이 자라며 고정되는 과정. | Vegetation Stabilization |
+
+---
+
+## 2. 정답지 이미지 목록 (Reference Images to Load)
+*AI 학습 시 아래 파일명과 매칭되는 이미지를 함께 업로드할 것.*
+
+1.  `v_shaped_valley_diagram.jpg` (V자곡 및 사면 붕괴 단면)
+2.  `alluvial_fan_structure.jpg` (선상지 평면 및 지하 단면)
+3.  `meander_cross_section.jpg` (공격사면/퇴적사면 비대칭 단면)
+4.  `river_terrace_formation.jpg` (하안단구 형성 단계)
+5.  `delta_classification.jpg` (삼각주 3가지 유형 비교)

02_Coastal_Landforms_Spec.md

@@ -0,0 +1,65 @@
+# 📘 [Geo-Lab AI] 개발 백서 (Development White Paper)
+
+**Project Name:** Geo-Lab AI
+**Version:** Final Release 1.0
+**Module:** Coastal Landforms (해안 지형)
+**Target:** High School Geography ~ Undergraduate Geomorphology
+**Director:** [User Name]
+
+---
+
+## 0. 개발 표준 및 제약사항 (Standard Protocols)
+
+### 🎨 1. 비주얼 스타일 가이드 (Visual Style: Schematic Education)
+* **Tone:** Clean, Minimalist, Textbook-style 3D.
+* **Color Palette:**
+    * *Sea:* 깊이에 따른 파란색 그라데이션 (얕은 곳=하늘색, 깊은 곳=남색).
+    * *Sand:* 밝은 베이지색 (이동 경로가 잘 보여야 함).
+    * *Rocks:* 짙은 회색/갈색 (절벽의 질감 표현).
+* **Key Feature:** 파도의 굴절과 모래의 이동 경로(Vector Arrow)를 시각적으로 표시.
+
+### 🛠️ 2. 기술 스택 (Tech Stack)
+* **Backend:** Python 3.9+ (Libraries: `NumPy`, `SciPy`, `Taichi`).
+* **Frontend:** WebGL via `Three.js` or `PyVista`.
+* **App Framework:** `Streamlit`.
+
+---
+
+## 1. 해안 지형 모듈 세부 명세 (Module Specifications)
+
+### 🌊 Chapter 1. 곶(Headland)과 침식: 파도의 공격
+**핵심 로직:** **파랑의 굴절 (Wave Refraction)**. 파도의 에너지가 튀어나온 땅(곶)으로 집중됨.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **해식애 & 파식대** | 파랑 에너지($P$), 암석 경도 | 파도가 절벽 밑을 때려(Notch) 윗부분이 무너지고, 절벽이 후퇴하며 평평한 바닥(파식대) 노출. | Cliff Retreat Rate $\propto P$ ($P \propto H^2T$) |
+| **시스택 & 아치** | 차별 침식, 시간($t$) | **[Evolution Time-lapse]** 해식동굴 → 아치(구멍) → 시스택(기둥) → 시스텀프(바위) 4단계 변화. | - |
+| **해안단구** | 지반 융기($U$), 해수면 변동 | 파식대가 융기하여 계단 모양의 언덕이 되는 과정 (강의 하안단구와 비교). | Uplift Event Trigger |
+
+### 🏖️ Chapter 2. 만(Bay)과 퇴적: 모래의 여행
+**핵심 로직:** **연안류 (Longshore Drift)**. 파도가 비스듬히 칠 때 모래가 지그재그로 이동.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **사빈 (Beach)** | 파랑 입사각($\theta$), 입자 크기 | 만(Bay) 안쪽으로 에너지가 분산되며 모래가 쌓임. 여름(퇴적) vs 겨울(침식) 해변 비교. | Sediment Transport (CERC Formula) |
+| **사구 (Sand Dune)** | 풍속($V_{wind}$), 식생 밀도 | 사빈의 모래가 바람에 날려 이동. **[Windbreak Effect]** 식생 설치 시 사구 성장 시뮬레이션. | Aeolian Transport Rate |
+| **사취 & 사주** | 연안류 속도, 해안선 굴곡 | 모래가 바다 쪽으로 뻗어 나가며(사취) 만의 입구를 막아버리는(사주) 과정. | - |
+| **석호 (Lagoon)** | 사주 형성 여부, 유입 수량 | 사주가 바다를 막아 호수가 되고, 시간이 지나며 퇴적물로 메워져 늪이 되는 생애주기. | Water Balance Equation |
+
+### 🦀 Chapter 3. 조류와 갯벌: 달의 인력
+**핵심 로직:** **조석 주기 (Tidal Cycle)** & 미립질 퇴적.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **갯벌 (Mudflat)** | 조차(Tidal Range), 미립질 비율 | **[Tidal Simulation]** 밀물/썰물 수위 변화와 갯골(Tidal Channel)의 프랙탈 구조 형성. | Tidal Prism / Hydrodynamics |
+| **간척 사업** | 제방 건설, 시간 경과 | 갯벌에 둑을 쌓은 후(User Action), 퇴적물이 마르고 육지화되며 염분이 빠지는 과정. | Soil Desalination Model |
+
+---
+
+## 2. 정답지 이미지 목록 (Reference Images to Load)
+*AI 학습 시 아래 파일명과 매칭되는 이미지를 함께 업로드할 것.*
+
+1.  `sea_cliff_erosion.jpg` (해식애, 파식대, 노치 구조 단면)
+2.  `sea_stack_formation.jpg` (동굴-아치-시스택 변화 과정)
+3.  `sand_spit_bar_tombolo.jpg` (사취, 사주, 석호 지도형 그림)
+4.  `tidal_flat_zonation.jpg` (갯벌 단면 및 조수 수위)

03_Karst_Landforms_Spec.md

@@ -0,0 +1,71 @@
+# 📘 [Geo-Lab AI] 개발 백서 (Development White Paper)
+
+**Project Name:** Geo-Lab AI
+**Version:** Final Release 1.0
+**Module:** Karst Landforms (카르스트 지형)
+**Target:** High School Geography ~ Undergraduate Geology
+**Director:** [User Name]
+
+---
+
+## 0. 개발 표준 및 제약사항 (Standard Protocols)
+
+### 🎨 1. 비주얼 스타일 가이드 (Visual Style: Subsurface & Texture)
+* **Tone:** Cross-sectional, Chemically Reactive, Hydrological.
+* **Color Palette:**
+    * *Limestone:* 밝은 회백색 (기반암).
+    * *Soil (Terra Rossa):* 붉은 갈색 (산화철 성분 강조).
+    * *Water:* 투명한 청록색 (지하수 위주).
+    * *Vegetation:* 짙은 녹색 (돌리네 내부 식생).
+* **Key Feature:** 지표면(Surface)과 지하(Subsurface)를 동시에 보여주는 **이중 레이어(Dual-Layer) 뷰** 지원. 용식 반응 시 거품(Reaction Bubble) 이펙트 적용.
+
+### 🛠️ 2. 기술 스택 (Tech Stack)
+* **Core Engine:** Chemical Weathering Simulator based on $pH$ & $Temperature$.
+* **Rendering:** Voxel-based Terrain (동굴 형성을 위한 내부 굴착 표현).
+* **Physics:** Fluid Dynamics (지하수 흐름 및 침투).
+
+---
+
+## 1. 카르스트 지형 모듈 세부 명세 (Module Specifications)
+
+### 💧 Chapter 1. 지표 카르스트: 물이 조각한 대지
+**핵심 로직:** **탄산칼슘 용식 작용 (Dissolution)**. 빗물이 석회암을 녹여 지표면이 함몰됨.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **용식 메커니즘** | 빗물 산도($pH$), 탄산가스 농도 | 빗물이 닿는 즉시 암석 표면이 녹아내리는 **[Shader Effect]**. 화학식 오버레이. | $CaCO_3 + H_2O + CO_2 \leftrightarrow Ca(HCO_3)_2$ |
+| **돌리네 (Doline)** | 절리 밀도, 시간($t$) | 지표면에 빗물이 고이다가 배수구처럼 빠지며 원형으로 움푹 꺼지는 애니메이션. | Sinkhole Radius $R(t)$ |
+| **우발라 & 폴리에** | 돌리네 결합 확률, 기반암 깊이 | 인접한 여러 개의 돌리네가 합쳐져 거대 분지(우발라)가 되고, 평평한 들판(폴리에)이 되는 과정. | Merge Function $f(D_1, D_2)$ |
+| **테라로사 (Terra Rossa)** | 불용성 잔류물 비율 | 석회암이 녹고 남은 붉은 흙이 지표면을 덮는 텍스처 매핑 변화 (White → Red). | Residue Accumulation |
+
+### 🦇 Chapter 2. 지하 카르스트: 어둠 속의 예술
+**핵심 로직:** **침전 작용 (Precipitation)**. 녹았던 석회질이 다시 굳어짐.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **석회 동굴** | 지하수 유량, 수위 변화 | **[X-Ray Mode]** 지하수면 아래에서 석회암이 녹아 빈 공간(Cavity)이 확장되는 과정. | Cave Volume Expansion |
+| **종유석 & 석순** | 낙수 속도($V_{drip}$), 증발률 | 천장에서 물방울이 떨어지며 고드름(종유석)이 자라고, 바닥에서 죽순(석순)이 솟아오름. | Growth Rate $\approx mm/year$ |
+| **석주 (Column)** | 성장 속도, 동굴 높이($H$) | 위(종유석)와 아래(석순)가 만나 기둥으로 연결되는 순간 **[Highlight Effect]**. | Connection Event |
+
+### 🏞️ Chapter 3. 탑 카르스트: 열대의 기암괴석 (Bonus)
+**핵심 로직:** **고온 다습 & 차별 침식**.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **탑 카르스트** | 강수량($P_{high}$), 기온($T_{high}$) | 평지에 탑처럼 솟은 봉우리 형성 (베트남 하롱베이, 중국 구이린 스타일). 측면 침식 강조. | Tropical Erosion Rate |
+
+---
+
+## 2. 정답지 이미지 목록 (Reference Images to Load)
+*AI 모델 학습 및 UI 렌더링 시 매칭할 레퍼런스 데이터.*
+
+1.  `chemical_weathering_reaction.png` (탄산칼슘 용식 화학식 및 모식도)
+2.  `doline_uvala_polje_progression.jpg` (돌리네에서 폴리에로 커지는 단계별 지도)
+3.  `cave_interior_structure.jpg` (종유석, 석순, 석주가 있는 동굴 내부 단면도)
+4.  `tower_karst_landscape.jpg` (탑 카르스트의 지형적 특징)
+
+---
+
+**[Director's Note]**
+카르스트 모듈은 **'화학 반응'**이 지형을 어떻게 바꾸는지 보여주는 것이 핵심입니다. $CaCO_3$ 화학식이 시뮬레이션 내에서 트리거로 작동하도록 로직을 점검하십시오.
+승인하시면 다음 **'화산 지형'**으로 넘어가겠습니다.

04_Volcanic_Landforms_Spec.md

@@ -0,0 +1,72 @@
+# 📘 [Geo-Lab AI] 개발 백서 (Development White Paper)
+
+**Project Name:** Geo-Lab AI
+**Version:** Final Release 1.0
+**Module:** Volcanic Landforms (화산 지형)
+**Target:** High School Geography ~ Undergraduate Volcanology
+**Director:** [User Name]
+
+---
+
+## 0. 개발 표준 및 제약사항 (Standard Protocols)
+
+### 🎨 1. 비주얼 스타일 가이드 (Visual Style: Magmatic & Explosive)
+* **Tone:** Dynamic, Thermal-coded, Catastrophic.
+* **Color Palette:**
+    * *Magma/Lava:* 온도에 따른 Black Body Radiation 색상 (White Hot → Yellow → Red → Dark Crust).
+    * *Ash/Rock:* 현무암(검은색) vs 조면암/안산암(회백색) 구분.
+    * *Terrain:* 굳은 용암 위 1차 천이 식생(이끼, 덤불)의 듬성듬성한 녹색.
+* **Key Feature:** 마그마의 **$SiO_2$ 함량(이산화규소)**에 따른 점성 변화를 슬라이더(Slider)로 조절하면 화산의 모양이 실시간으로 변형되는 **[Morphing Terrain]** 구현.
+
+### 🛠️ 2. 기술 스택 (Tech Stack)
+* **Physics Engine:** SPH (Smoothed-Particle Hydrodynamics) for Lava Flow Simulation.
+* **Rendering:** Volumetric Fog (화산재 및 연기 표현).
+* **Algorithm:** Cooling Crystallization Model (용암 냉각 속도에 따른 절리 형성 계산).
+
+---
+
+## 1. 화산 지형 모듈 세부 명세 (Module Specifications)
+
+### 🌋 Chapter 1. 마그마의 성격: 점성(Viscosity)과 화산체
+**핵심 로직:** **$SiO_2$ 함량 $\propto$ 점성 $\propto$ 화산 경사도**.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **순상 화산 (Shield)** | 점성($\mu_{low}$), 온도($T_{high}$), 유동성(High) | 꿀처럼 묽은 용암이 넓게 퍼져나가며 완만한 경사(방패 모양) 형성. (예: 하와이, 제주도 한라산 산록) | Slope Angle $\theta \approx 2^{\circ} \sim 10^{\circ}$ |
+| **종상 화산 (Lava Dome)** | 점성($\mu_{high}$), 온도($T_{low}$), 유동성(Low) | 치약처럼 된 용암이 분화구 위로 솟구쳐 종 모양 형성. (예: 제주도 산방산, 울릉도 나리분지 내 알봉) | Slope Angle $\theta > 30^{\circ}$ |
+| **성층 화산 (Stratovolcano)** | 분출 주기, 폭발성 | 용암 분출(Flow)과 화산재 폭발(Explosion)이 교대로 일어나 층층이 쌓인 원뿔형 구조. (예: 후지산, 필리핀 마욘) | Layering Index |
+| **용암 대지 (Lava Plateau)** | 열하 분출(Fissure), $SiO_2$ < 52% | 지각의 틈에서 묽은 용암이 대량으로 흘러나와 기존 계곡을 메우고 평탄면 형성. (예: 철원, 개마고원) | Area Coverage Rate |
+
+### 💥 Chapter 2. 분화구의 변형: 함몰과 확장
+**핵심 로직:** **질량 결손(Mass Deficit)에 의한 붕괴**.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **화구 (Crater)** | 폭발 에너지($E_{exp}$) | 마그마가 분출된 단순한 구멍. | Diameter $D < 1km$ |
+| **칼데라 (Caldera)** | 마그마 방 공동화 비율, 지반 하중 | **[Collapse Event]** 대폭발 후 지하 마그마 방이 비면서 산정부가 와르르 무너져 내리는 시네마틱 컷. 물이 차면 칼데라 호. (예: 백두산 천지, 나리분지) | Collapse Volume $V_c$ |
+| **이중 화산** | 1차 분출 후 휴지기, 2차 분출 | 칼데라(큰 그릇) 안에 새로운 화산(작은 컵)이 생기는 구조. (예: 울릉도 성인봉-나리분지-알봉) | Nested Structure |
+
+### ❄️ Chapter 3. 냉각의 기하학: 1차 지형
+**핵심 로직:** **수축(Contraction)과 균열**.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **주상절리 (Columnar Jointing)** | 냉각 속도($dT/dt$), 수축 중심점 | 용암이 급격히 식으며 부피가 줄어들 때 형성되는 **육각형(Hexagonal) 기둥** 패턴 생성 알고리즘. | Fracture Spacing $S \propto (dT/dt)^{-1/2}$ |
+| **용암 동굴 (Lava Tube)** | 표면 냉각율 vs 내부 유속 | 용암의 겉부분은 굳고(지붕), 속은 계속 흘러(터널) 빠져나간 뒤 남은 빈 공간. | Tube Formation Logic |
+
+---
+
+## 2. 정답지 이미지 목록 (Reference Images to Load)
+*AI 모델 학습 및 UI 렌더링 시 매칭할 레퍼런스 데이터.*
+
+1.  `volcano_shape_viscosity.png` (순상 vs 성층 vs 종상 화산의 단면 비교도)
+2.  `caldera_formation_steps.gif` (마그마 방 비움 → 붕괴 → 호수 형성 3단계)
+3.  `columnar_jointing_hex.jpg` (주상절리의 육각형 단면 및 측면 기둥 구조)
+4.  `korea_volcanic_map.png` (백두산, 제주도, 울릉도, 철원 용암대지 위치 지도)
+
+---
+
+**[Director's Note]**
+화산 모듈은 **'점성($\mu$)'** 변수 하나가 지형의 모양(순상/종상)을 결정짓는다는 인과관계를 명확히 보여줘야 합니다. 특히 한국 ��리 수험생을 타겟으로 한다면 **철원 용암대지**와 **제주도**의 형성 과정 차이를 시뮬레이션으로 비교하는 기능을 반드시 포함하십시오.
+
+승인하시면 다음은 가장 다이내믹한 **'빙하 지형'**으로 이동하겠습니다.

05_Glacial_Landforms_Spec.md

@@ -0,0 +1,73 @@
+# 📘 [Geo-Lab AI] 개발 백서 (Development White Paper)
+
+**Project Name:** Geo-Lab AI
+**Version:** Final Release 1.0
+**Module:** Glacial Landforms (빙하 지형)
+**Target:** High School Geography ~ Undergraduate Glaciology
+**Director:** [User Name]
+
+---
+
+## 0. 개발 표준 및 제약사항 (Standard Protocols)
+
+### 🎨 1. 비주얼 스타일 가이드 (Visual Style: Cryosphere)
+* **Tone:** Majestic, Cold, High-Contrast.
+* **Color Palette:**
+    * *Ice:* 반투명한 아이스 블루(Ice Blue) ~ 압축된 짙은 파랑 (Deep Azure).
+    * *Bedrock:* 깎여 나간 거친 회색 화강암 질감 (Exposed Granite).
+    * *Water (Fjord):* 깊고 어두운 남색 (Deep Navy).
+* **Key Feature:** 빙하가 흐를 때 바닥을 긁어내는(Scouring) 효과와 녹을 때 흙더미를 쏟아놓는(Dumping) 효과를 물리 엔진으로 구현. **"분급(Sorting) 없음"** 시각화 필수.
+
+### 🛠️ 2. 기술 스택 (Tech Stack)
+* **Physics Engine:** Non-Newtonian Fluid Dynamics (비뉴턴 유체 역학 - 얼음의 느린 흐름 구현).
+* **Rendering:** Subsurface Scattering (얼음 내부의 빛 투과 효과).
+* **Algorithm:** Voxel Carving (빙하 이동 경로에 따른 지형 깎기).
+
+---
+
+## 1. 빙하 지형 모듈 세부 명세 (Module Specifications)
+
+### 🧊 Chapter 1. 빙하 침식: 거대한 불도저 (Erosion)
+**핵심 로직:** **U자형 침식 (U-shaped Profile)** & 굴식 작용(Plucking).
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **U자곡 (U-shaped Valley)** | 빙하 두께($H_{ice}$), 마찰력 | 좁고 깊은 V자곡(하천)이 거대한 빙하에 의해 넓고 둥근 U자 형태로 깎여나가는 **[Cross-section Transition]**. | Erosion Rate $E \propto U_{sliding}^2$ |
+| **권곡 (Cirque)** | 설선 고도(ELA), 굴식 강도 | 산 정상부 오목한 곳에 눈이 쌓여 얼음이 되고, 암석을 뜯어내며(Plucking) 반원형 의자 모양을 만드는 과정. | - |
+| **호른 (Horn)** | 권곡의 개수($N \ge 3$) | 3개 이상의 권곡이 뒤로 후퇴하며 정상을 깎아 만들어진 피라미드형 뾰족 봉우리 (예: 마터호른). | Peak Sharpness Index |
+| **피오르 (Fjord)** | 해수면 상승($\Delta SeaLevel$), 침식 깊이 | 빙기가 끝나고 해수면이 상승하여 U자곡에 바닷물이 들어차는 **[Flooding Animation]**. 내륙 깊숙이 좁고 긴 바다 형성. | Depth Profile $D(x)$ |
+| **현곡 (Hanging Valley)** | 본류 빙하 vs 지류 빙하 깊이 차이 | 본류가 깊게 깎고 지나간 뒤, 얕은 지류 골짜기가 절벽 위에 걸려 폭포가 되는 지형. | Drop Height $H_{drop}$ |
+
+### 🪨 Chapter 2. 빙하 퇴적: 무질서의 미학 (Deposition)
+**핵심 로직:** **분급 불량 (Poor Sorting)**. 크고 작은 자갈과 흙이 뒤섞임.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **빙퇴석 (Moraine)** | 빙하 후퇴 속도, 퇴적량 | 빙하가 녹는 끝부분(Terminus)에서 컨베이어 벨트처럼 암석 부스러기를 쏟아놓아 언덕을 만드는 과정. | Sediment Flux $Q_s$ |
+| **드럼린 (Drumlin)** | 빙하 이동 방향, 기저 하중 | 숟가락을 엎어놓은 듯한 유선형 언덕. **[Direction Indicator]** 완만한 쪽이 빙하가 흘러간 방향임을 화살표로 표시. | Shape Factor (Elongation) |
+| **에스커 (Esker)** | 융빙수 유량($Q_{water}$), 터널 크기 | 빙하 밑을 흐르는 물(융빙수) 터널에 퇴적물이 쌓여, 빙하가 녹은 뒤 구불구불한 제방 모양이 드러남. | Sinuosity Index |
+
+### ❄️ Chapter 3. 주빙하 지형: 얼었다 녹았다 (Periglacial - Bonus)
+**핵심 로직:** **동결 융해 (Freeze-Thaw Cycle)**.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **구조토 (Patterned Ground)** | 토양 입자 크기, 동결 횟수 | 자갈들이 얼음의 쐐기 작용으로 밀려나와 다각형(Polygon) 무늬를 만드는 **[Time-lapse]**. | Convection Cell Model |
+| **솔리플럭션 (Solifluction)** | 경사도, 활동층 융해 | 영구동토층 위 녹은 흙이 흘러내리는 현상. | Creep Velocity |
+
+---
+
+## 2. 정답지 이미지 목록 (Reference Images to Load)
+*AI 모델 학습 및 UI 렌더링 시 매칭할 레퍼런스 데이터.*
+
+1.  `valley_transformation_V_to_U.gif` (V자곡에서 U자곡으로 변형되는 3D 모델)
+2.  `fjord_cross_section.jpg` (바닷물에 잠긴 U자곡 단면도)
+3.  `glacial_till_unsorted.png` (빙퇴석의 뒤섞인 자갈 단면 - 분급 불량 예시)
+4.  `drumlin_ice_flow.jpg` (드럼린의 형태와 빙하 이동 방향 관계도)
+
+---
+
+**[Director's Note]**
+빙하 지형의 킬러 문항 포인트는 **"강물(유수)에 의한 퇴적(분급 양호)"**과 **"빙하에 의한 퇴적(분급 불량)"**을 구분하는 것입니다. 시뮬레이션 내에서 입자 크기 필터(Sorting Filter)가 빙하 모드에서는 작동하지 않는 것을 시각적으로 강조해주세요.
+
+승인하시면 다음은 가장 척박하지만 아름다운 **'건조 지형'**으로 넘어가겠습니다.

06_Arid_Landforms_Spec.md

@@ -0,0 +1,73 @@
+# 📘 [Geo-Lab AI] 개발 백서 (Development White Paper)
+
+**Project Name:** Geo-Lab AI
+**Version:** Final Release 1.0
+**Module:** Arid Landforms (건조 지형)
+**Target:** High School Geography ~ Undergraduate Geomorphology
+**Director:** [User Name]
+
+---
+
+## 0. 개발 표준 및 제약사항 (Standard Protocols)
+
+### 🎨 1. 비주얼 스타일 가이드 (Visual Style: Desert & Erosion)
+* **Tone:** High Contrast, Dusty, Heat-haze.
+* **Color Palette:**
+    * *Sand/Dust:* 오커(Ochre), 번트 시에나(Burnt Sienna) 등 황토색 계열.
+    * *Sky:* 짙은 코발트 블루(건조해서 대기가 깨끗함) 또는 모래폭풍 시 뿌연 황색.
+    * *Salt Lake (Playa):* 눈부신 흰색 (소금 결정 반사).
+* **Key Feature:** 지표면의 아지랑이(Heat Haze) 효과와 바람의 방향을 보여주는 **입자 흐름(Particle Flow)** 시각화.
+
+### 🛠️ 2. 기술 스택 (Tech Stack)
+* **Physics Engine:** Granular Physics (모래 입자 간 마찰 및 안식각 시뮬레이션).
+* **Rendering:** PBR Materials (암석의 거친 질감 vs 소금 사막의 매끄러운 질감).
+* **Algorithm:** Cellular Automata (사구의 이동 및 성장 패턴 계산).
+
+---
+
+## 1. 건조 지형 모듈 세부 명세 (Module Specifications)
+
+### 🌪️ Chapter 1. 바람의 조각: 침식과 퇴적 (Aeolian Process)
+**핵심 로직:** **도약 운동(Saltation)**. 무거운 모래는 지면 가까이서 튀며 이동한다.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **버섯바위 (Mushroom Rock)** | 모래 비산 높이($H_{max} \approx 1m$), 암석 경도 | 바람에 날린 모래알이 바위의 **밑부분만 집중 공격**하여 깎아내는 과정. (윗부분은 침식 안 됨). | Erosion Rate $E(z)$ |
+| **사구 (Sand Dune)** | 풍향 벡터($\vec{V}$), 모래 공급량 | **[Dune Morphing]** 풍향에 따라 바르한(초승달형, 단일풍) $\leftrightarrow$ 성사구(긴 칼형, 양방향풍) 변환. | Bagnold Formula |
+| **삼릉석 (Ventifact)** | 주풍향의 개수 | 자갈이 바람을 받아 깎이면서 3개의 면과 모서리가 생기는 과정. | Facet Formation |
+| **사막 포장 (Desert Pavement)** | 입자 크기별 무게 | 바람이 고운 모래만 날려 보내고(Deflation), 무거운 자갈만 바닥에 남는 **[Sorting Filter]** 효과. | Threshold Friction Velocity |
+
+### 🌧️ Chapter 2. 물의 역설: 유수 지형 (Fluvial in Desert)
+**핵심 로직:** **포상 홍수(Flash Flood)**. 식생이 없어 비가 오면 물이 급격히 불어남.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **선상지 (Alluvial Fan)** | 경사 급변점, 유속 감소율 | 산지에서 평지로 나올 때 유속이 느려지며 부채꼴로 퇴적물이 퍼지는 시뮬레이션. (선정-선앙-선단 구분). | Stream Power Law |
+| **바하다 (Bajada)** | 선상지 결합 수($N$) | 여러 개의 선상지가 옆으로 합쳐져 산기슭을 감싸는 복합 선상지 형성. | Coalescence Factor |
+| **와디 (Wadi)** | 강수 빈도, 침투율 | 평소엔 마른 골짜기(교통로)였다가, 비가 오면 급류가 흐르는 강으로 변하는 **[Event Trigger]**. | Infiltration Capacity |
+| **플라야 (Playa)** | 증발량 >> 강수량 | 물이 고였다가 증발하고 **소금(Salt)**만 하얗게 남는 염호의 형성 과정. | Evaporation Rate |
+
+### 🧱 Chapter 3. 구조 지형: 강한 놈이 살아남는다 (Structural)
+**핵심 로직:** **차별 침식(Differential Erosion)** & 수평 지층.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **메사 (Mesa)** | 상부 암석 강도($S_{hard}$), 하부($S_{soft}$) | 윗부분의 단단한 암석(Cap rock)이 뚜껑처럼 보호해줘서 생긴 탁자 모양의 지형. | Resistance Ratio |
+| **뷰트 (Butte)** | 침식 진행률 | 메사가 깎여서 작아진 탑 모양의 지형. (메사 $\rightarrow$ 뷰트 크기 비교). | Width/Height Ratio |
+
+---
+
+## 2. 정답지 이미지 목록 (Reference Images to Load)
+*AI 모델 학습 및 UI 렌더링 시 매칭할 레퍼런스 데이터.*
+
+1.  `barchan_dune_wind_direction.jpg` (바르한 사구의 형태와 바람 방향 화살표)
+2.  `alluvial_fan_structure.png` (선상지의 선정, 선앙, 선단 단면도 및 입자 크기 분포)
+3.  `mesa_butte_evolution.jpg` (고원 -> 메사 -> 뷰트 -> 스파이어 침식 단계)
+4.  `mushroom_rock_formation.gif` (모래바람에 의한 하단부 침식 애니메이션)
+
+---
+
+**[Director's Note]**
+건조 지형은 **"바람"**이 만든 것 같지만, 실제 거대 지형은 **"일시적인 폭우(물)"**가 만들었다는 오개념을 바로잡는 것이 교육적 목표입니다. 와디(Wadi) 시뮬레이션에서 ���가 올 때 급격히 물이 차오르는 속도를 극적으로 표현해 주십시오.
+
+승인하시면 마지막 대단원, 가장 평온하지만 가장 중요한 **'평야 지형'**으로 넘어가겠습니다.

07_Plain_Landforms_Spec.md

@@ -0,0 +1,79 @@
+# 📘 [Geo-Lab AI] 개발 백서 (Development White Paper)
+
+**Project Name:** Geo-Lab AI
+**Version:** Final Release 1.0
+**Module:** Plain Landforms (평야 지형)
+**Target:** High School Geography ~ Urban Planning Basics
+**Director:** [User Name]
+
+---
+
+## 0. 개발 표준 및 제약사항 (Standard Protocols)
+
+### 🎨 1. 비주얼 스타일 가이드 (Visual Style: Fertile & Sedimentary)
+* **Tone:** Horizontal, Expansive, Saturation-coded (Soil Moisture).
+* **Color Palette:**
+    * *Levee (Dry):* 밝은 황토색 (배수가 잘 됨 → 밭, 취락).
+    * *Backswamp (Wet):* 짙은 진흙색 (배수 불량 → 논, 습지).
+    * *River:* 흙탕물(Turbid) 표현 (상류의 청명함과 대비).
+* **Key Feature:** **단면도(Cross-section) 뷰**를 통해 지표면의 미세한 고도 차이(제방 vs 습지)와 퇴적물의 입자 크기 변화를 직관적으로 표현.
+
+### 🛠️ 2. 기술 스택 (Tech Stack)
+* **Physics Engine:** Navier-Stokes Equations (유체 역학 - 하천의 곡류 및 범람 시뮬레이션).
+* **Rendering:** Height Map Displacement (미세한 고도 차이 표현).
+* **Algorithm:** Sedimentation Sorting (유속 감속에 따른 입자별 퇴적 위치 계산).
+
+---
+
+## 1. 평야 지형 모듈 세부 명세 (Module Specifications)
+
+### 🐍 Chapter 1. 하천 중·하류: 곡류와 범람원 (Floodplains)
+**핵심 로직:** **측방 침식(Lateral Erosion)** & 홍수 시 퇴적.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **자유 곡류 하천** | 하천 굴곡도(Sinuosity), 유속 편차 | 강물이 뱀처럼 휘어지며 흐르는 모습. **[Velocity Map]** 바깥쪽은 빠름(침식/공격사면), 안쪽은 느림(퇴적/포인트바) 색상 구분. | Centrifugal Force $F_c$ |
+| **우각호 (Oxbow Lake)** | 굴곡도 임계값, 시간($t$) | 굽이치던 강이 홍수 때 직선으로 뚫리면서, 남겨진 물길이 소뿔 모양 호수로 고립되는 **[Cut-off Animation]**. | Path Shortening |
+| **자연 제방 (Levee)** | 홍수 수위, 조립질(큰 입자) 비율 | 홍수 시 강 바로 옆에 무거운 모래/자갈이 먼저 쌓여 둑을 형성. 주변보다 약간 높음(High & Dry). | Settling Velocity (Stokes) |
+| **배후 습지 (Backswamp)** | 범람 거리, 미립질(작은 입자) 비율 | 자연제방 뒤쪽으로 고운 진흙이 넘어가 쌓인 낮고 축축한 땅. (자연제방과 배수 조건 비교 필수). | Permeability $k$ |
+
+### 📐 Chapter 2. 하구: 바다와의 만남, 삼각주 (Deltas)
+**핵심 로직:** **유속 소멸(Velocity $\to$ 0)**. 강물이 바다를 만나 짐을 내려놓음.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **삼각주 형성** | 하천 퇴적량 > 조류/파랑 제거량 | 강 하구에서 퇴적물이 부채꼴로 퍼져나가는 과정. (Topset, Foreset, Bottomset 층리 구조 단면). | Sediment Budget $\Delta S$ |
+| **조류 삼각주** | 조차(Tidal Range), 유속 | 밀물/썰물이 강해서 퇴적물이 바다 쪽으로 길게 뻗지 못하고 섬처럼 형성된 삼각주 (예: 낙동강 하구 을숙도). | Tidal Current Power |
+| **형태별 분류** | 파랑 에너지 vs 하천 에너지 | 원호상(나일강), 조족상(미시시피강-새발모양), 첨각상(티베르강) 형태 비교 시뮬레이션. | Energy Ratio |
+
+### ⏳ Chapter 3. 침식 평야: 깎이고 남은 땅 (Erosion Plains)
+**핵심 로직:** **최종 단계(Final Stage)**.
+
+| 지형 (Feature) | 핵심 변수 (Key Parameters) | 시각화 포인트 (Visualization) | 학습용 수식 (Formula Reference) |
+| :--- | :--- | :--- | :--- |
+| **준평원 (Peneplain)** | 침식 시간($t \to \infty$) | 산지가 깎이고 깎여 해수면에 가깝게 평평해진 지형. 데이비스의 지형 윤회설 마지막 단계. | Base Level Approach |
+| **잔구 (Monadnock)** | 암석의 차별 침식 | 준평원 위에 단단한 암석만 침식을 견디고 홀로 남은 낮은 언덕. | Hardness Differential |
+
+---
+
+## 2. 정답지 이미지 목록 (Reference Images to Load)
+*AI 모델 학습 및 UI 렌더링 시 매칭할 레퍼런스 데이터.*
+
+1.  `meandering_river_evolution.gif` (곡류 하천이 우각호로 변하는 4단계 과정)
+2.  `floodplain_cross_section.png` (하도 - 자연제방 - 배후습지 단면도 및 토지 이용)
+3.  `delta_types_satellite.jpg` (나일강, 미시시피강, 갠지스강 삼각주 위성 사진 비교)
+4.  `levee_vs_backswamp_soil.jpg` (자연제방의 모래 vs 배후습지의 점토 입자 비교)
+
+---
+
+**[Director's Note]**
+평야 지형의 핵심은 **"인간의 거주(Settlement)"**와 연결하는 것입니다.
+시뮬레이션 UI에 **[Village Builder]** 모드를 추가하여, 사용자가 **자연제방(홍수 안전/밭농사)**과 **배후습지(홍수 위험/논농사)** 중 어디�� 집을 짓고 농사를 지을지 선택하게 하세요. 잘못된 선택(예: 배후습지에 집 짓기) 시 홍수 이벤트로 페널티를 주면 학습 효과가 극대화됩니다.
+
+---
+
+**[Project Status]**
+🎉 **축하합니다!**
+산지, 카르스트, 화산, 빙하, 건조, 평야 지형까지 **[Geo-Lab AI]의 모든 지형 모듈 설계가 완료되었습니다.**
+
+이제 이 백서들을 바탕으로 전체 프로젝트를 **통합(Integration)**하거나, **출시(Launch)** 단계로 넘어가시겠습니까?

DEPLOY.md

@@ -0,0 +1,78 @@
+# 🌍 Geo-Lab AI: 웹 배포 가이드
+
+## 배포 옵션
+
+### 1. 🚀 Streamlit Community Cloud (추천 - 무료)
+
+**장점:** 무료, GitHub 연동, 자동 배포
+
+#### 단계별 가이드:
+
+1. **GitHub 저장소 생성**
+   ```bash
+   cd c:\Users\HANSOL\Desktop\Geo-lab
+   git init
+   git add .
+   git commit -m "Initial commit: 하천 지형 모듈 프로토타입"
+   git branch -M main
+   git remote add origin https://github.com/YOUR_USERNAME/geo-lab-ai.git
+   git push -u origin main
+   ```
+
+2. **Streamlit Cloud 접속**
+   - https://share.streamlit.io 방문
+   - GitHub 계정으로 로그인
+
+3. **앱 배포**
+   - "New app" 클릭
+   - Repository: `YOUR_USERNAME/geo-lab-ai`
+   - Branch: `main`
+   - Main file path: `app/main.py`
+   - "Deploy!" 클릭
+
+4. **완료!**
+   - URL 예시: `https://geo-lab-ai.streamlit.app`
+
+---
+
+### 2. 🔧 Hugging Face Spaces
+
+**장점:** 무료, 커뮤니티 공유 용이
+
+1. https://huggingface.co/spaces 에서 새 Space 생성
+2. SDK: "Streamlit" 선택
+3. 파일 업로드 또는 GitHub 연동
+
+---
+
+### 3. ☁️ 기타 옵션
+
+| 플랫폼 | 비용 | 특징 |
+|-------|-----|-----|
+| **Render** | 무료 티어 | 자동 슬립, 커스텀 도메인 |
+| **Railway** | 무료 $5/월 | 빠른 배포 |
+| **Heroku** | 유료 | 안정적 |
+
+---
+
+## 로컬 실행
+
+```bash
+# 의존성 설치
+pip install -r requirements.txt
+
+# 앱 실행
+streamlit run app/main.py
+
+# 브라우저에서 열기
+# http://localhost:8501
+```
+
+---
+
+## 현재 앱 상태
+
+✅ **로컬 실행 중**: http://localhost:8501
+
+**외부 접속 URL**: http://211.114.121.192:8501
+(같은 네트워크에서만 접근 가능)

README.md

@@ -0,0 +1,44 @@
+---
+title: Geo-Lab AI
+emoji: 🌍
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: 1.28.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🌍 Geo-Lab AI - 이상적 지형 갤러리
+
+**교사를 위한 지형 형성과정 시각화 도구**
+
+## 주요 기능
+
+- 📖 **31종 이상적 지형** - 교과서적 지형 형태의 기하학적 모델
+- 🎬 **형성과정 애니메이션** - 0%→100% 슬라이더로 지형 형성 확인
+- 🗂️ **7개 카테고리** - 하천, 삼각주, 빙하, 화산, 카르스트, 건조, 해안
+- 📊 **2D/3D 시각화** - 평면도 및 입체 지형 모델
+
+## 지원 지형
+
+| 카테고리 | 지형 |
+|----------|------|
+| 🌊 하천 | 선상지, 자유곡류, 감입곡류, V자곡, 망상하천, 폭포 |
+| 🔺 삼각주 | 일반, 조족상, 호상, 첨두상 |
+| ❄️ 빙하 | U자곡, 권곡, 호른, 피오르드, 드럼린, 빙퇴석 |
+| 🌋 화산 | 순상화산, 성층화산, 칼데라, 화구호, 용암대지 |
+| 🦇 카르스트 | 돌리네 |
+| 🏜️ 건조 | 바르한 사구, 메사/뷰트 |
+| 🏖️ 해안 | 해안절벽, 사취+석호, 육계사주, 리아스해안, 해식아치, 해안사구 |
+
+## 제작
+
+**2025 한백고등학교 김한솔T**
+
+## 기술 스택
+
+- Python / Streamlit
+- NumPy / Matplotlib / Plotly
+- 기하학적 지형 생성 알고리즘

app.py

@@ -0,0 +1,14 @@
+# Geo-Lab AI - 이상적 지형 갤러리
+# HuggingFace Spaces Entry Point
+
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Import and run main app
+from app.main import main
+
+if __name__ == "__main__":
+    main()

app/__init__.py

@@ -0,0 +1 @@
+# App Package

app/components/__init__.py

@@ -0,0 +1 @@
+# Components Package

debug_log.txt

@@ -0,0 +1,9 @@
+Testing Sediment Transport...
+Initial Elev Row 4 (Slope Base): 7.0
+Initial Elev Row 7 (Flat Land): 5.0
+Post Elev Row 4: 6.8
+Post Elev Row 7: 5.0
+Sediment Array (Column 0):
+[0.  0.  0.  0.  0.  3.8 0.  0.  0.  0. ]
+Total Sediment on Flat/Sea: 5.0
+Sediment Transport OK

debug_piracy.py

@@ -0,0 +1,55 @@
+
+import numpy as np
+import plotly.graph_objects as go
+
+# Mock functions from main.py
+def simulate_stream_piracy(time_years: int, params: dict, grid_size: int = 100):
+    """하천쟁탈 시뮬레이션 - 교과서적 이상적 모습"""
+    x = np.linspace(0, 1000, grid_size)
+    y = np.linspace(0, 1000, grid_size)
+    X, Y = np.meshgrid(x, y)
+    elevation = 150 - Y * 0.1
+    ridge_x = 500
+    ridge = 20 * np.exp(-((X - ridge_x)**2) / (80**2))
+    elevation += ridge
+    river1_x = 300
+    river1_valley = 30 * np.exp(-((X - river1_x)**2) / (40**2))
+    elevation -= river1_valley
+    river2_x = 700
+    erosion_diff = params.get('erosion_diff', 0.7)
+    river2_depth = 50 * erosion_diff
+    river2_valley = river2_depth * np.exp(-((X - river2_x)**2) / (50**2))
+    elevation -= river2_valley
+    
+    # ... logic ...
+    # Simplified logic for t=5000 (not captured)
+    return {'elevation': elevation, 'captured': False}
+
+def render_terrain_plotly_debug(elevation):
+    print(f"Elevation stats: Min={elevation.min()}, Max={elevation.max()}, NaNs={np.isnan(elevation).sum()}")
+    
+    dy, dx = np.gradient(elevation)
+    print(f"Gradient stats: dx_NaN={np.isnan(dx).sum()}, dy_NaN={np.isnan(dy).sum()}")
+    
+    slope = np.sqrt(dx**2 + dy**2)
+    print(f"Slope stats: Min={slope.min()}, Max={slope.max()}, NaNs={np.isnan(slope).sum()}")
+    
+    biome = np.zeros_like(elevation)
+    biome[:] = 1
+    # ...
+    noise = np.random.normal(0, 0.2, elevation.shape)
+    biome_noisy = np.clip(biome + noise, 0, 3)
+    print(f"Biome Noisy stats: Min={biome_noisy.min()}, Max={biome_noisy.max()}, NaNs={np.isnan(biome_noisy).sum()}")
+    
+    realistic_colorscale = [
+        [0.0, '#E6C288'], [0.25, '#E6C288'], 
+        [0.25, '#2E8B57'], [0.5, '#2E8B57'], 
+        [0.5, '#696969'], [0.75, '#696969'], 
+        [0.75, '#FFFFFF'], [1.0, '#FFFFFF']
+    ]
+    print("Colorscale:", realistic_colorscale)
+
+if __name__ == "__main__":
+    res = simulate_stream_piracy(5000, {'erosion_diff': 0.7})
+    elev = res['elevation']
+    render_terrain_plotly_debug(elev)

engine/__init__.py

@@ -0,0 +1 @@
+# Engine Package

engine/base.py

@@ -0,0 +1,163 @@
+"""
+Geo-Lab AI Engine: 기본 지형 클래스
+"""
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Optional, Tuple
+
+
+@dataclass
+class Terrain:
+    """2D 높이맵 기반 지형 데이터 구조"""
+    
+    width: int = 100          # X 방향 셀 수
+    height: int = 100         # Y 방향 셀 수
+    cell_size: float = 10.0   # 셀당 실제 거리 (m)
+    
+    # 높이맵 (m)
+    elevation: np.ndarray = field(default=None)
+    
+    # 암석 속성
+    rock_hardness: np.ndarray = field(default=None)  # 0-1, 1이 가장 단단함
+    
+    def __post_init__(self):
+        if self.elevation is None:
+            self.elevation = np.zeros((self.height, self.width))
+        if self.rock_hardness is None:
+            self.rock_hardness = np.ones((self.height, self.width)) * 0.5
+    
+    @classmethod
+    def create_slope(cls, width: int, height: int, 
+                     max_elevation: float = 1000.0,
+                     slope_direction: str = 'south') -> 'Terrain':
+        """경사면 지형 생성"""
+        terrain = cls(width=width, height=height)
+        
+        if slope_direction == 'south':
+            # 북쪽이 높고 남쪽이 낮음
+            for y in range(height):
+                terrain.elevation[y, :] = max_elevation * (1 - y / height)
+        elif slope_direction == 'east':
+            for x in range(width):
+                terrain.elevation[:, x] = max_elevation * (1 - x / width)
+        
+        return terrain
+    
+    @classmethod
+    def create_v_valley_initial(cls, width: int = 100, height: int = 100,
+                                 valley_depth: float = 50.0) -> 'Terrain':
+        """V자곡 시뮬레이션 초기 지형"""
+        terrain = cls(width=width, height=height)
+        
+        # 기본 경사 (북→남)
+        for y in range(height):
+            terrain.elevation[y, :] = 500 * (1 - y / height)
+        
+        # 중앙에 초기 하천 채널 (약간의 패임)
+        center = width // 2
+        for x in range(width):
+            dist = abs(x - center)
+            if dist < 5:
+                terrain.elevation[:, x] -= valley_depth * (1 - dist / 5)
+        
+        return terrain
+    
+    def get_slope(self) -> np.ndarray:
+        """각 셀의 경사도 계산 (라디안)"""
+        dy, dx = np.gradient(self.elevation, self.cell_size)
+        return np.arctan(np.sqrt(dx**2 + dy**2))
+    
+    def get_flow_direction(self) -> Tuple[np.ndarray, np.ndarray]:
+        """물 흐름 방향 벡터 (가장 가파른 하강 방향)"""
+        dy, dx = np.gradient(self.elevation, self.cell_size)
+        magnitude = np.sqrt(dx**2 + dy**2) + 1e-10
+        return -dx / magnitude, -dy / magnitude
+
+
+@dataclass 
+class Water:
+    """하천 수문 데이터"""
+    
+    terrain: Terrain
+    
+    # 각 셀의 수량 (m³/s)
+    discharge: np.ndarray = field(default=None)
+    
+    # 유속 (m/s)
+    velocity: np.ndarray = field(default=None)
+    
+    # 흐름 방향 (단위 벡터)
+    flow_x: np.ndarray = field(default=None)
+    flow_y: np.ndarray = field(default=None)
+    
+    def __post_init__(self):
+        shape = (self.terrain.height, self.terrain.width)
+        if self.discharge is None:
+            self.discharge = np.zeros(shape)
+        if self.velocity is None:
+            self.velocity = np.zeros(shape)
+        if self.flow_x is None:
+            self.flow_x, self.flow_y = self.terrain.get_flow_direction()
+    
+    def add_precipitation(self, rate: float = 0.001):
+        """강수 추가 (m/s per cell)"""
+        self.discharge += rate
+    
+    def accumulate_flow(self):
+        """흐름 누적 계산 (간단한 D8 알고리즘)"""
+        h, w = self.terrain.height, self.terrain.width
+        accumulated = self.discharge.copy()
+        
+        # 높은 곳에서 낮은 곳으로 정렬
+        indices = np.argsort(self.terrain.elevation.ravel())[::-1]
+        
+        for idx in indices:
+            y, x = idx // w, idx % w
+            if accumulated[y, x] <= 0:
+                continue
+            
+            # 가장 낮은 이웃 찾기
+            min_elev = self.terrain.elevation[y, x]
+            min_neighbor = None
+            
+            for dy, dx in [(-1,0), (1,0), (0,-1), (0,1)]:
+                ny, nx = y + dy, x + dx
+                if 0 <= ny < h and 0 <= nx < w:
+                    if self.terrain.elevation[ny, nx] < min_elev:
+                        min_elev = self.terrain.elevation[ny, nx]
+                        min_neighbor = (ny, nx)
+            
+            if min_neighbor:
+                accumulated[min_neighbor] += accumulated[y, x]
+        
+        self.discharge = accumulated
+        
+        # 유속 계산 (Manning 방정식 단순화)
+        slope = self.terrain.get_slope() + 0.001  # 0 방지
+        self.velocity = 2.0 * np.sqrt(slope) * np.power(self.discharge + 0.1, 0.4)
+
+
+@dataclass
+class SimulationState:
+    """시뮬레이션 상태 관리"""
+    
+    terrain: Terrain
+    water: Water
+    
+    time_step: float = 1.0  # 시뮬레이션 1스텝 = 1년
+    current_time: float = 0.0
+    
+    # 전역 변수 (Master Plan의 Global Controllers)
+    climate_level: float = 1.0      # 기후 (강수량 계수)
+    sea_level: float = 0.0          # 해수면 (m)
+    tectonic_energy: float = 0.0    # 지각 에너지 (융기율 m/year)
+    
+    def step(self):
+        """1 타임스텝 진행"""
+        self.current_time += self.time_step
+        
+        # 강수 추가
+        self.water.add_precipitation(rate=0.001 * self.climate_level)
+        
+        # 흐름 누적
+        self.water.accumulate_flow()

engine/climate.py

@@ -0,0 +1,140 @@
+"""
+Climate Kernel (기후 커널)
+
+기후 조건에 따른 강수/기온 분포 생성
+- 위도 기반 강수 패턴
+- 고도 기반 지형성 강수
+- 기온에 따른 풍화율 조절
+"""
+
+import numpy as np
+from .grid import WorldGrid
+
+
+class ClimateKernel:
+    """
+    기후 커널
+    
+    강수와 기온 분포를 생성하여 다른 프로세스에 영향.
+    """
+    
+    def __init__(self, grid: WorldGrid,
+                 base_precipitation: float = 1000.0,   # mm/year
+                 base_temperature: float = 15.0,       # °C
+                 lapse_rate: float = 6.5):             # °C/km (고도 감률)
+        self.grid = grid
+        self.base_precipitation = base_precipitation
+        self.base_temperature = base_temperature
+        self.lapse_rate = lapse_rate
+        
+    def generate_precipitation(self, 
+                               orographic_factor: float = 0.5,
+                               latitude_effect: bool = True) -> np.ndarray:
+        """
+        강수 분포 생성
+        
+        Args:
+            orographic_factor: 지형성 강수 강도 (0~1)
+            latitude_effect: 위도 효과 적용 여부
+            
+        Returns:
+            precipitation: 강수량 배열 (mm/year → m/timestep으로 변환 필요)
+        """
+        h, w = self.grid.height, self.grid.width
+        elev = self.grid.elevation
+        
+        # 기본 강수 (균일)
+        precip = np.ones((h, w)) * self.base_precipitation
+        
+        # 1. 위도 효과 (적도 > 극지방)
+        if latitude_effect:
+            # 그리드 Y축을 위도로 근사 (0=적도, h=극)
+            # 열대 = 가장 많음, 아열대 건조, 온대 증가, 극 감소
+            lat_factor = np.zeros(h)
+            for r in range(h):
+                # 정규화된 위도 (0~1)
+                normalized_lat = r / h
+                # 간단한 위도-강수 관계 (삼봉 패턴 근사)
+                lat_factor[r] = 1.0 - 0.3 * abs(normalized_lat - 0.5) * 2
+                
+            precip *= lat_factor[:, np.newaxis]
+            
+        # 2. 지형성 강수 (바람받이 vs 그늘)
+        if orographic_factor > 0:
+            # 동쪽에서 바람이 분다고 가정
+            # 고도 증가 구간 = 강수 증가 (상승 기류)
+            # 고도 감소 구간 = 강수 감소 (하강 기류)
+            
+            # X 방향 경사
+            _, dx = self.grid.get_gradient()
+            
+            # 음의 경사 = 동쪽으로 상승 = 강수 증가
+            orographic = 1.0 + orographic_factor * (-dx) * 0.1
+            orographic = np.clip(orographic, 0.2, 2.0)
+            
+            precip *= orographic
+            
+        # 3. 고도 효과 (일정 고도까지는 증가, 이후 감소)
+        # 최대 강수 고도 (예: 2000m)
+        optimal_elev = 2000.0
+        elev_effect = 1.0 - 0.2 * np.abs(elev - optimal_elev) / optimal_elev
+        elev_effect = np.clip(elev_effect, 0.3, 1.2)
+        
+        precip *= elev_effect
+        
+        return precip
+        
+    def get_temperature(self) -> np.ndarray:
+        """
+        기온 분포 생성
+        
+        Returns:
+            temperature: 기온 배열 (°C)
+        """
+        h, w = self.grid.height, self.grid.width
+        elev = self.grid.elevation
+        
+        # 기본 기온
+        temp = np.ones((h, w)) * self.base_temperature
+        
+        # 1. 위도 효과 (적도 > 극)
+        for r in range(h):
+            normalized_lat = r / h
+            # 적도(0.5) = 기본, 극(0, 1) = -30°C
+            lat_temp_diff = 30.0 * abs(normalized_lat - 0.5) * 2
+            temp[r, :] -= lat_temp_diff
+            
+        # 2. 고도 효과 (체감 온도 감률)
+        # 해수면 기준에서 km당 lapse_rate만큼 감소
+        temp -= (elev / 1000.0) * self.lapse_rate
+        
+        return temp
+        
+    def get_weathering_rate(self, temperature: np.ndarray = None) -> np.ndarray:
+        """
+        기온에 따른 풍화율 계산
+        
+        화학적 풍화: 온난 다습 → 빠름
+        물리적 풍화: 동결-융해 (-10~10°C) → 빠름
+        
+        Args:
+            temperature: 기온 배열 (없으면 생성)
+            
+        Returns:
+            weathering_rate: 상대 풍화율 (0~1)
+        """
+        if temperature is None:
+            temperature = self.get_temperature()
+            
+        h, w = self.grid.height, self.grid.width
+        
+        # 화학적 풍화 (온도 높을수록)
+        chemical = np.clip((temperature + 10) / 40.0, 0, 1)
+        
+        # 물리적 풍화 (동결-융해 범위에서 최대)
+        freeze_thaw = np.exp(-((temperature - 0) ** 2) / (2 * 10 ** 2))
+        
+        # 통합 풍화율
+        weathering = chemical * 0.5 + freeze_thaw * 0.5
+        
+        return weathering

engine/delta_physics.py

@@ -0,0 +1,282 @@
+"""
+Geo-Lab AI: 삼각주 물리 시뮬레이션
+Galloway 분류 기반 3가지 에너지 균형
+"""
+import numpy as np
+from dataclasses import dataclass, field
+from typing import List, Tuple
+from enum import Enum
+from scipy.ndimage import gaussian_filter
+
+
+class DeltaType(Enum):
+    RIVER_DOMINATED = "조족상 (Bird's Foot)"
+    WAVE_DOMINATED = "원호상 (Arcuate)"
+    TIDE_DOMINATED = "첨각상 (Cuspate)"
+
+
+@dataclass
+class DeltaGrid:
+    """삼각주 2D 그리드"""
+    width: int = 150
+    height: int = 150
+    cell_size: float = 50.0  # m
+    
+    # 지형 (해수면 기준 고도, m)
+    elevation: np.ndarray = field(default=None)
+    # 퇴적물 (m)
+    sediment: np.ndarray = field(default=None)
+    # 수심 (바다 부분)
+    water_depth: np.ndarray = field(default=None)
+    
+    sea_level: float = 0.0
+    
+    def __post_init__(self):
+        if self.elevation is None:
+            self.elevation = np.zeros((self.height, self.width))
+        if self.sediment is None:
+            self.sediment = np.zeros((self.height, self.width))
+        if self.water_depth is None:
+            self.water_depth = np.zeros((self.height, self.width))
+    
+    @classmethod
+    def create_initial(cls, width: int = 150, height: int = 150,
+                       land_fraction: float = 0.3):
+        """초기 지형 - 상류(육지) → 하류(바다)"""
+        grid = cls(width=width, height=height)
+        
+        land_rows = int(height * land_fraction)
+        
+        for y in range(height):
+            if y < land_rows:
+                # 육지: 경사
+                grid.elevation[y, :] = 10 - y * 0.3
+            else:
+                # 바다: 해수면 아래
+                depth = (y - land_rows) * 0.2
+                grid.elevation[y, :] = -depth
+        
+        # 하천 채널
+        center = width // 2
+        for x in range(center - 5, center + 6):
+            if 0 <= x < width:
+                grid.elevation[:land_rows, x] -= 2
+        
+        # 수심 계산
+        grid.water_depth = np.maximum(0, grid.sea_level - grid.elevation)
+        
+        return grid
+
+
+class RiverMouthDeposition:
+    """하구 퇴적 (하천 주도)"""
+    
+    def __init__(self, sediment_flux: float = 1000.0,  # m³/yr
+                 settling_velocity: float = 0.01):  # m/s
+        self.sediment_flux = sediment_flux
+        self.settling_velocity = settling_velocity
+    
+    def deposit(self, grid: DeltaGrid, river_energy: float, 
+                channel_x: int, dt: float = 1.0) -> np.ndarray:
+        """하천 퇴적물 분배"""
+        h, w = grid.height, grid.width
+        deposition = np.zeros((h, w))
+        
+        # 하구 위치
+        estuary_y = np.argmax(grid.elevation[:, channel_x] < grid.sea_level)
+        if estuary_y == 0:
+            estuary_y = h // 2
+        
+        # 하천 우세: 길게 뻗어나가는 패턴 (jet 확산)
+        spread_angle = np.radians(15 + (1 - river_energy) * 30)  # 하천 에너지 높으면 좁게
+        
+        for y in range(estuary_y, h):
+            dy = y - estuary_y + 1
+            spread = int(dy * np.tan(spread_angle))
+            
+            for x in range(channel_x - spread, channel_x + spread + 1):
+                if 0 <= x < w:
+                    # 거리에 따른 감소
+                    dist = np.sqrt((x - channel_x)**2 + dy**2)
+                    dep_rate = self.sediment_flux * river_energy * np.exp(-dist / 50) * 0.001
+                    deposition[y, x] += dep_rate * dt
+        
+        return deposition
+
+
+class WaveRedistribution:
+    """파랑에 의한 재분배"""
+    
+    def __init__(self, wave_power: float = 1.0):
+        self.wave_power = wave_power
+    
+    def redistribute(self, grid: DeltaGrid, wave_energy: float,
+                     dt: float = 1.0) -> np.ndarray:
+        """파랑에 의한 퇴적물 좌우 확산"""
+        # 해안선 부근에서 좌우로 퍼뜨림
+        shoreline = np.abs(grid.elevation - grid.sea_level) < 2
+        
+        # 가우시안 필터로 좌우 확산 (x축 방향)
+        sediment_change = np.zeros_like(grid.sediment)
+        
+        if np.any(shoreline):
+            # 해안선 부근 퇴적물만 확산
+            coastal_sediment = grid.sediment * shoreline.astype(float)
+            smoothed = gaussian_filter(coastal_sediment, sigma=[0.5, 3 * wave_energy])
+            
+            # 변화량
+            sediment_change = (smoothed - coastal_sediment) * wave_energy * dt * 0.1
+        
+        return sediment_change
+
+
+class TidalScouring:
+    """조류에 의한 침식"""
+    
+    def __init__(self, tidal_range: float = 2.0):  # m
+        self.tidal_range = tidal_range
+    
+    def scour(self, grid: DeltaGrid, tidal_energy: float,
+              dt: float = 1.0) -> np.ndarray:
+        """조류에 의한 하구 확대 (세굴)"""
+        h, w = grid.height, grid.width
+        erosion = np.zeros((h, w))
+        
+        # 하구 부근 (해수면 근��)
+        tidal_zone = np.abs(grid.elevation - grid.sea_level) < self.tidal_range
+        
+        # 채널 방향으로 세굴
+        for y in range(1, h):
+            for x in range(1, w-1):
+                if tidal_zone[y, x] and grid.sediment[y, x] > 0:
+                    # 바다 방향으로 퇴적물 이동
+                    erosion[y, x] = grid.sediment[y, x] * tidal_energy * 0.01 * dt
+        
+        return erosion
+
+
+class DeltaSimulation:
+    """삼각주 시뮬레이션"""
+    
+    def __init__(self, width: int = 150, height: int = 150):
+        self.grid = DeltaGrid.create_initial(width=width, height=height)
+        
+        self.river_dep = RiverMouthDeposition()
+        self.wave_redis = WaveRedistribution()
+        self.tidal_scour = TidalScouring()
+        
+        self.river_energy = 0.5
+        self.wave_energy = 0.3
+        self.tidal_energy = 0.2
+        
+        self.history: List[np.ndarray] = []
+        self.time = 0.0
+    
+    def set_energy_balance(self, river: float, wave: float, tidal: float):
+        """에너지 균형 설정 (0-1로 정규화)"""
+        total = river + wave + tidal + 0.01
+        self.river_energy = river / total
+        self.wave_energy = wave / total
+        self.tidal_energy = tidal / total
+    
+    def step(self, dt: float = 1.0):
+        """1 타임스텝"""
+        center_x = self.grid.width // 2
+        
+        # 1. 하천 퇴적
+        river_dep = self.river_dep.deposit(
+            self.grid, self.river_energy, center_x, dt
+        )
+        
+        # 2. 파랑 재분배
+        wave_change = self.wave_redis.redistribute(
+            self.grid, self.wave_energy, dt
+        )
+        
+        # 3. 조류 세굴
+        tidal_erosion = self.tidal_scour.scour(
+            self.grid, self.tidal_energy, dt
+        )
+        
+        # 적용
+        self.grid.sediment += river_dep + wave_change - tidal_erosion
+        self.grid.sediment = np.maximum(0, self.grid.sediment)
+        
+        # 지형 업데이트
+        self.grid.elevation = self.grid.elevation + self.grid.sediment * 0.01
+        self.grid.water_depth = np.maximum(0, self.grid.sea_level - self.grid.elevation)
+        
+        self.time += dt
+    
+    def run(self, total_time: float, save_interval: float = 100.0, dt: float = 1.0):
+        """시뮬레이션 실행"""
+        steps = int(total_time / dt)
+        save_every = max(1, int(save_interval / dt))
+        
+        self.history = [self.grid.elevation.copy()]
+        
+        for i in range(steps):
+            self.step(dt)
+            if (i + 1) % save_every == 0:
+                self.history.append(self.grid.elevation.copy())
+        
+        return self.history
+    
+    def get_delta_type(self) -> DeltaType:
+        """현재 삼각주 유형 판별"""
+        if self.river_energy >= self.wave_energy and self.river_energy >= self.tidal_energy:
+            return DeltaType.RIVER_DOMINATED
+        elif self.wave_energy >= self.tidal_energy:
+            return DeltaType.WAVE_DOMINATED
+        else:
+            return DeltaType.TIDE_DOMINATED
+    
+    def get_delta_area(self) -> float:
+        """삼각주 면적 (해수면 위 새 땅)"""
+        initial_land = self.history[0] > self.grid.sea_level
+        current_land = self.grid.elevation > self.grid.sea_level
+        new_land = current_land & ~initial_land
+        return float(np.sum(new_land)) * self.grid.cell_size**2 / 1e6  # km²
+
+
+# 프리컴퓨팅
+def precompute_delta(max_time: int = 10000,
+                     river_energy: float = 60,
+                     wave_energy: float = 25,
+                     tidal_energy: float = 15,
+                     save_every: int = 100) -> dict:
+    """삼각주 시뮬레이션 프리컴퓨팅"""
+    sim = DeltaSimulation()
+    sim.set_energy_balance(river_energy, wave_energy, tidal_energy)
+    
+    history = sim.run(
+        total_time=max_time,
+        save_interval=save_every,
+        dt=1.0
+    )
+    
+    return {
+        'history': history,
+        'delta_type': sim.get_delta_type().value,
+        'delta_area': sim.get_delta_area()
+    }
+
+
+if __name__ == "__main__":
+    print("삼각주 물리 시뮬레이션 테스트")
+    print("=" * 50)
+    
+    # 시나리오 1: 하천 우세
+    sim1 = DeltaSimulation()
+    sim1.set_energy_balance(80, 10, 10)
+    sim1.run(5000, save_interval=1000)
+    print(f"하천 우세: {sim1.get_delta_type().value}, 면적 {sim1.get_delta_area():.2f} km²")
+    
+    # 시나리오 2: 파랑 우세
+    sim2 = DeltaSimulation()
+    sim2.set_energy_balance(30, 60, 10)
+    sim2.run(5000, save_interval=1000)
+    print(f"파랑 우세: {sim2.get_delta_type().value}, 면적 {sim2.get_delta_area():.2f} km²")
+    
+    print("=" * 50)
+    print("테스트 완료!")

engine/deposition.py

@@ -0,0 +1,174 @@
+"""
+Geo-Lab AI Engine: 퇴적 로직
+유속 감소에 따른 입자별 퇴적 구현
+"""
+import numpy as np
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base import Terrain, Water
+
+
+def settling_deposition(terrain: 'Terrain', water: 'Water',
+                        sediment_load: np.ndarray,
+                        critical_velocity: float = 0.5,
+                        dt: float = 1.0) -> tuple:
+    """
+    유속 감소에 따른 퇴적 (Stokes' Law 기반)
+    유속이 임계값 이하로 떨어지면 퇴적물이 쌓임
+    
+    Parameters:
+    -----------
+    terrain : Terrain
+        지형 객체
+    water : Water
+        수문 객체
+    sediment_load : np.ndarray
+        현재 운반 중인 퇴적물량
+    critical_velocity : float
+        퇴적이 시작되는 임계 유속
+    dt : float
+        시간 단위
+    
+    Returns:
+    --------
+    deposition_amount : np.ndarray
+        퇴적량
+    remaining_sediment : np.ndarray
+        남은 퇴적물량
+    """
+    # 유속이 낮은 곳에서 퇴적
+    velocity_ratio = water.velocity / (critical_velocity + 0.01)
+    deposition_rate = np.maximum(0, 1 - velocity_ratio)
+    
+    deposition_amount = sediment_load * deposition_rate * dt
+    remaining_sediment = sediment_load - deposition_amount
+    
+    return deposition_amount, np.maximum(remaining_sediment, 0)
+
+
+def alluvial_fan_deposition(terrain: 'Terrain', water: 'Water',
+                            sediment_load: np.ndarray,
+                            slope_threshold: float = 0.1,
+                            dt: float = 1.0) -> np.ndarray:
+    """
+    선상지(Alluvial Fan) 퇴적
+    급격한 경사 변화 지점(산지→평지)에서 부채꼴 퇴적
+    
+    Returns:
+    --------
+    deposition_amount : np.ndarray
+    """
+    slope = terrain.get_slope()
+    
+    # 경사 변화율 계산
+    slope_change = np.gradient(slope, axis=0) + np.gradient(slope, axis=1)
+    
+    # 경사가 급격히 줄어드는 곳(음의 변화율)에서 퇴적
+    fan_zone = slope_change < -slope_threshold
+    
+    deposition = np.zeros_like(sediment_load)
+    deposition[fan_zone] = sediment_load[fan_zone] * 0.8 * dt
+    
+    return deposition
+
+
+def levee_backswamp_deposition(terrain: 'Terrain', water: 'Water',
+                                flood_level: float = 1.0,
+                                dt: float = 1.0) -> tuple:
+    """
+    자연제방(Levee) & 배후습지(Backswamp) 퇴적
+    홍수 시 하천 가까이에 굵은 입자, 멀리에 미립 입자 퇴적
+    
+    Returns:
+    --------
+    levee_deposition : np.ndarray
+        자연제방 퇴적량 (모래 - 두꺼움)
+    backswamp_deposition : np.ndarray  
+        배후습지 퇴적량 (점토 - 얇음)
+    """
+    h, w = terrain.height, terrain.width
+    
+    # 하천 위치 (높은 유량)
+    channel_mask = water.discharge > np.percentile(water.discharge, 80)
+    
+    levee = np.zeros((h, w))
+    backswamp = np.zeros((h, w))
+    
+    # 하천으로부터의 거리 계산 (간단한 확산)
+    from scipy.ndimage import distance_transform_edt
+    if np.any(channel_mask):
+        distance = distance_transform_edt(~channel_mask)
+        
+        # 자연제방: 하천 바로 옆 (2-5셀)
+        levee_zone = (distance > 1) & (distance < 5)
+        levee[levee_zone] = flood_level * 0.3 * (5 - distance[levee_zone]) / 4 * dt
+        
+        # 배후습지: 더 먼 곳 (5-15셀)
+        backswamp_zone = (distance >= 5) & (distance < 15)
+        backswamp[backswamp_zone] = flood_level * 0.05 * dt
+    
+    return levee, backswamp
+
+
+def delta_deposition(terrain: 'Terrain', water: 'Water',
+                     river_energy: float = 1.0,
+                     wave_energy: float = 0.5,
+                     tidal_energy: float = 0.3,
+                     sea_level: float = 0.0,
+                     dt: float = 1.0) -> np.ndarray:
+    """
+    삼각주(Delta) 퇴적
+    3가지 에너지(하천/파랑/조류) 균형에 따라 형태 결정
+    
+    - 하천 우세: 조족상(Bird's foot) - 미시시피형
+    - 파랑 우세: 원호상(Arcuate) - 나일형
+    - 조류 우세: 첨각상(Cuspate) - 티베르형
+    
+    Returns:
+    --------
+    deposition_amount : np.ndarray
+    """
+    h, w = terrain.height, terrain.width
+    deposition = np.zeros((h, w))
+    
+    # 해수면 근처 (하구)
+    estuary_zone = (terrain.elevation > sea_level - 5) & (terrain.elevation < sea_level + 10)
+    channel_mask = water.discharge > np.percentile(water.discharge, 70)
+    delta_zone = estuary_zone & channel_mask
+    
+    if not np.any(delta_zone):
+        return deposition
+    
+    # 에너지 비율 정규화
+    total_energy = river_energy + wave_energy + tidal_energy + 0.01
+    r_ratio = river_energy / total_energy
+    w_ratio = wave_energy / total_energy
+    t_ratio = tidal_energy / total_energy
+    
+    # 하천 우세: 길게 뻗어나가는 패턴
+    if r_ratio > 0.5:
+        # 흐름 ���향으로 퇴적물 확장
+        deposition[delta_zone] = water.discharge[delta_zone] * r_ratio * 0.1 * dt
+    
+    # 파랑 우세: 넓게 퍼지는 원호 패턴
+    elif w_ratio > 0.4:
+        # 좌우로 퍼지게
+        from scipy.ndimage import gaussian_filter
+        base = np.zeros((h, w))
+        base[delta_zone] = water.discharge[delta_zone] * 0.1
+        deposition = gaussian_filter(base, sigma=3) * w_ratio * dt
+    
+    # 조류 우세: 작은 섬 형태
+    else:
+        # 좁은 영역에 집중
+        deposition[delta_zone] = water.discharge[delta_zone] * t_ratio * 0.05 * dt
+    
+    return deposition
+
+
+def apply_deposition(terrain: 'Terrain', deposition_amount: np.ndarray):
+    """
+    지형에 퇴적 적용
+    """
+    terrain.elevation += deposition_amount

engine/erosion.py

@@ -0,0 +1,191 @@
+"""
+Geo-Lab AI Engine: 침식 로직
+Stream Power Law 기반 하방/측방 침식 구현
+"""
+import numpy as np
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from .base import Terrain, Water
+
+
+def vertical_erosion(terrain: 'Terrain', water: 'Water', 
+                     k_erosion: float = 0.0001,
+                     m_exponent: float = 0.5,
+                     n_exponent: float = 1.0,
+                     dt: float = 1.0) -> np.ndarray:
+    """
+    하방 침식 (Vertical/Downcutting Erosion)
+    Stream Power Law: E = K * A^m * S^n
+    
+    Parameters:
+    -----------
+    terrain : Terrain
+        지형 객체
+    water : Water
+        수문 객체
+    k_erosion : float
+        침식 계수 (암석 경도의 역수)
+    m_exponent : float
+        유량 지수 (보통 0.4-0.6)
+    n_exponent : float
+        경사 지수 (보통 1.0)
+    dt : float
+        시간 단위 (년)
+    
+    Returns:
+    --------
+    erosion_amount : np.ndarray
+        각 셀의 침식량 (m)
+    """
+    # 경사 계산
+    slope = terrain.get_slope()
+    
+    # Stream Power Law
+    # E = K * Q^m * S^n
+    # 암석 경도로 K 조절 (경도가 높으면 침식이 적음)
+    effective_k = k_erosion * (1 - terrain.rock_hardness * 0.9)
+    
+    erosion_rate = effective_k * np.power(water.discharge + 0.1, m_exponent) * np.power(slope + 0.001, n_exponent)
+    
+    erosion_amount = erosion_rate * dt
+    
+    # 침식량 제한 (너무 급격한 변화 방지)
+    max_erosion = 10.0  # 최대 10m/yr
+    erosion_amount = np.clip(erosion_amount, 0, max_erosion)
+    
+    return erosion_amount
+
+
+def lateral_erosion(terrain: 'Terrain', water: 'Water',
+                    k_lateral: float = 0.00005,
+                    curvature_factor: float = 1.0,
+                    dt: float = 1.0) -> np.ndarray:
+    """
+    측방 침식 (Lateral Erosion)
+    곡류 하천에서 바깥쪽(공격사면)을 깎음
+    
+    Parameters:
+    -----------
+    terrain : Terrain
+        지형 객체
+    water : Water
+        수문 객체
+    k_lateral : float
+        측방 침식 계수
+    curvature_factor : float
+        곡률 강조 계수
+    dt : float
+        시간 단위 (년)
+    
+    Returns:
+    --------
+    erosion_amount : np.ndarray
+        각 셀의 침식량 (m)
+    """
+    h, w = terrain.height, terrain.width
+    erosion = np.zeros((h, w))
+    
+    # 유로 곡률 계산 (흐름 방향의 2차 미분)
+    flow_x, flow_y = water.flow_x, water.flow_y
+    
+    # 곡률 근사: 흐름 방향의 변화율
+    curvature_x = np.gradient(flow_x, axis=1)
+    curvature_y = np.gradient(flow_y, axis=0)
+    curvature = np.sqrt(curvature_x**2 + curvature_y**2)
+    
+    # 측방 침식 = 유량 * 유속 * 곡률
+    # 곡률이 큰 곳(급커브) = 바깥쪽 침식 강함
+    erosion = k_lateral * water.discharge * water.velocity * curvature * curvature_factor * dt
+    
+    # 하천이 있는 곳에서만 침식 (유량 임계값)
+    channel_mask = water.discharge > 0.1
+    erosion = erosion * channel_mask
+    
+    return np.clip(erosion, 0, 5.0)
+
+
+def headward_erosion(terrain: 'Terrain', water: 'Water',
+                     k_headward: float = 0.0002,
+                     dt: float = 1.0) -> np.ndarray:
+    """
+    두부 침식 (Headward Erosion)
+    하천의 상류 끝이 점점 뒤로 물러남
+    폭포, 협곡 형성의 핵심 메커니즘
+    
+    Returns:
+    --------
+    erosion_amount : np.ndarray
+        각 셀의 침식량 (m)
+    """
+    h, w = terrain.height, terrain.width
+    erosion = np.zeros((h, w))
+    
+    # 급경사 지점(Knickpoint) 찾기
+    slope = terrain.get_slope()
+    steep_mask = slope > np.percentile(slope[slope > 0], 90)  # 상위 10% 급경사
+    
+    # 급경사 + 유량이 있는 곳에서 두부 침식 발생
+    channel_mask = water.discharge > 0.5
+    knickpoint_mask = steep_mask & channel_mask
+    
+    # 상류 방향으로 침식 확장
+    erosion[knickpoint_mask] = k_headward * water.discharge[knickpoint_mask] * dt
+    
+    return np.clip(erosion, 0, 2.0)
+
+
+def apply_erosion(terrain: 'Terrain', erosion_amount: np.ndarray,
+                  min_elevation: float = 0.0):
+    """
+    지형에 침식 적용
+    
+    Parameters:
+    -----------
+    terrain : Terrain
+        수정할 지형 객체
+    erosion_amount : np.ndarray
+        침식량 배열
+    min_elevation : float
+        최소 고도 (해수면)
+    """
+    terrain.elevation -= erosion_amount
+    terrain.elevation = np.maximum(terrain.elevation, min_elevation)
+
+
+def mass_wasting(terrain: 'Terrain', 
+                 critical_slope: float = 0.7,  # ~35도
+                 transfer_rate: float = 0.3) -> np.ndarray:
+    """
+    사면 붕괴 (Mass Wasting)
+    V자곡 형성 시 양옆 사면이 무너지는 과정
+    
+    Returns:
+    --------
+    elevation_change : np.ndarray
+        고도 변화량 (높은 곳 -, 낮은 곳 +)
+    """
+    h, w = terrain.height, terrain.width
+    change = np.zeros((h, w))
+    
+    slope = terrain.get_slope()
+    
+    # 임계 경사 초과 지점에서 물질 이동
+    unstable = slope > critical_slope
+    
+    for y in range(1, h-1):
+        for x in range(1, w-1):
+            if unstable[y, x]:
+                # 주변으로 물질 분배
+                elev = terrain.elevation[y, x]
+                neighbors = [
+                    (y-1, x), (y+1, x), (y, x-1), (y, x+1)
+                ]
+                
+                for ny, nx in neighbors:
+                    if terrain.elevation[ny, nx] < elev:
+                        transfer = (elev - terrain.elevation[ny, nx]) * transfer_rate * 0.25
+                        change[y, x] -= transfer
+                        change[ny, nx] += transfer
+    
+    return change

engine/erosion_process.py

@@ -0,0 +1,328 @@
+import numpy as np
+from .grid import WorldGrid
+
+class ErosionProcess:
+    """
+    지형 변경 커널 (Erosion/Deposition Kernel)
+    
+    물리 공식을 적용하여 지형(고도)을 변경합니다.
+    1. Stream Power Law: 하천 침식 (E = K * A^m * S^n)
+    2. Hillslope Diffusion: 사면 붕괴/확산 (dz/dt = D * del^2 z)
+    """
+    
+    def __init__(self, grid: WorldGrid, K: float = 1e-4, m: float = 0.5, n: float = 1.0, D: float = 0.01):
+        self.grid = grid
+        self.K = K  # 침식 계수
+        self.m = m  # 유량 지수
+        self.n = n  # 경사 지수
+        self.D = D  # 확산 계수 (사면)
+        
+    def stream_power_erosion(self, discharge: np.ndarray, dt: float = 1.0) -> np.ndarray:
+        """Stream Power Law 기반 하천 침식"""
+        slope, _ = self.grid.get_gradient()
+        
+        # E = K * Q^m * S^n
+        # (유량 Q를 유역면적 A 대신 사용)
+        erosion_rate = self.K * np.power(discharge, self.m) * np.power(slope, self.n)
+        
+        # 실제 침식량 = rate * time
+        erosion_amount = erosion_rate * dt
+        
+        # 기반암 이하로는 침식 불가 (available sediment first, then bedrock)
+        # 여기서는 단순화를 위해 Topography(elevation)을 바로 깎음.
+        # 단, 해수면 아래는 침식 작용 감소 (물 속에서는 Stream Power가 아님)
+        underwater = self.grid.is_underwater()
+        erosion_amount[underwater] *= 0.1
+        
+        # 지형 업데이트
+        self.grid.elevation -= erosion_amount
+        
+        # 단순화: 깎인 만큼 퇴적물로 변환되어 어딘가로 가야 하지만,
+        # Stream Power Model(SPL)은 보통 Detachment-limited 모델이라 퇴적을 명시적으로 다루지 않음.
+        # 통합 모델을 위해, 침식된 양을 퇴적물 플럭스에 더해줄 수 있음 (구현 예정)
+        
+        return erosion_amount
+
+    def hillslope_diffusion(self, dt: float = 1.0) -> np.ndarray:
+        """사면 확산 프로세스 (Linear Diffusion)"""
+        elev = self.grid.elevation
+        
+        # Laplacian calculation (이산화)
+        # del^2 z = (z_up + z_down + z_left + z_right - 4*z) / dx^2
+        
+        # Numpy roll을 이용한 빠른 계산
+        up = np.roll(elev, -1, axis=0)
+        down = np.roll(elev, 1, axis=0)
+        left = np.roll(elev, -1, axis=1)
+        right = np.roll(elev, 1, axis=1)
+        
+        dx2 = self.grid.cell_size ** 2
+        laplacian = (up + down + left + right - 4 * elev) / dx2
+        
+        # 경계 조건 처리 (가장자리는 계산 제외 or 0)
+        laplacian[0, :] = 0
+        laplacian[-1, :] = 0
+        laplacian[:, 0] = 0
+        laplacian[:, -1] = 0
+        
+        # dz/dt = D * del^2 z
+        change = self.D * laplacian * dt
+        
+        self.grid.elevation += change
+        return change
+
+    def overbank_deposition(self, discharge: np.ndarray, 
+                            bankfull_capacity: float = 100.0,
+                            decay_rate: float = 0.1,
+                            dt: float = 1.0) -> np.ndarray:
+        """
+        범람원 퇴적 (Overbank Deposition)
+        
+        하천 용량 초과 시 범람하여 주변에 세립질 퇴적.
+        하도에서 멀어질수록 퇴적량 감소 (자연제방 형성).
+        
+        Args:
+            discharge: 유량 배열
+            bankfull_capacity: 하도 용량 (초과 시 범람)
+            decay_rate: 거리에 따른 퇴적 감쇠율
+            dt: 시간 간격
+            
+        Returns:
+            deposition: 퇴적량 배열
+        """
+        from scipy.ndimage import distance_transform_edt
+        
+        h, w = self.grid.height, self.grid.width
+        
+        # 1. 범람 지점 식별 (용량 초과)
+        overflow = np.maximum(0, discharge - bankfull_capacity)
+        flood_mask = overflow > 0
+        
+        if not np.any(flood_mask):
+            return np.zeros((h, w))
+        
+        # 2. 하도로부터의 거리 계산
+        # flood_mask가 있는 곳이 하도
+        channel_mask = discharge > bankfull_capacity * 0.5
+        
+        if not np.any(channel_mask):
+            return np.zeros((h, w))
+            
+        # Distance Transform (하도로부터의 거리)
+        distance = distance_transform_edt(~channel_mask) * self.grid.cell_size
+        
+        # 3. 퇴적량 계산 (지수 감쇠)
+        # Deposition = overflow * exp(-k * distance)
+        # 하도 근처(자연제방)에 많이, 멀수록(배후습지) 적게
+        max_overflow = overflow.max()
+        if max_overflow <= 0:
+            return np.zeros((h, w))
+            
+        normalized_overflow = overflow / max_overflow
+        
+        # 범람 영향 범위 (최대 50 셀)
+        max_distance = 50 * self.grid.cell_size
+        influence = np.exp(-decay_rate * distance / self.grid.cell_size)
+        influence[distance > max_distance] = 0
+        
+        # 퇴적���
+        deposition = normalized_overflow.max() * influence * 0.1 * dt
+        
+        # 해수면 아래는 제외
+        underwater = self.grid.is_underwater()
+        deposition[underwater] = 0
+        
+        # 하도 자체는 제외 (하도는 침식이 우세)
+        deposition[channel_mask] = 0
+        
+        # 4. 퇴적층에 추가
+        self.grid.add_sediment(deposition)
+        
+        return deposition
+
+    def transport_and_deposit(self, discharge: np.ndarray, dt: float = 1.0, Kf: float = 0.01) -> np.ndarray:
+        """
+        퇴적물 운반 및 퇴적 (Sediment Transport & Deposition)
+        
+        Transport Capacity Law:
+        Q_cap = Kf * Q^m * S^n
+        
+        - Q_cap > Q_sed: 침식 (Erosion) -> 퇴적물 증가
+        - Q_cap < Q_sed: 퇴적 (Deposition) -> 퇴적물 감소, 지형 상승
+        
+        Args:
+            discharge: 유량
+            dt: 시간 간격
+            Kf: 운반 효율 계수 (Transport Efficiency)
+        """
+        slope, _ = self.grid.get_gradient()
+        # 경사가 0이면 무한 퇴적 방지를 위해 최소값 설정
+        slope = np.maximum(slope, 0.001)
+        
+        # 1. 운반 능력 (Transport Capacity) 계산
+        # 침식 계수 K 대신 운반 계수 Kf 사용 (일반적으로 K보다 큼)
+        capacity = Kf * np.power(discharge, self.m) * np.power(slope, self.n)
+        
+        # 2. 현재 부유사(Suspended Sediment) 가정
+        # 상류에서 들어오는 유사량은 이전 단계의 침식량이나 기유입량에 의존
+        # 여기서는 단순화를 위해 'Local Equilibrium'을 가정하지 않고,
+        # 유량에 비례하는 초기 유사량을 가정하거나, 
+        # 이전 스텝의 침식 결과를 이용해야 함.
+        # 통합 모델을 위해: "Erosion" 함수가 깎아낸 흙을 반환하도록 하고, 
+        # 이를 capacity와 비교하여 재퇴적시키거나 하류로 보냄.
+        
+        # 하지만 D8 알고리즘 상 하류로의 '전달(Routing)'이 필요함.
+        # 여기서는 Simplified Landform Evolution Model (SLEM) 방식 적용:
+        # dZs/dt = U - E + D
+        # D = (Q_cap - Q_sed) / Length_scale (if Q_sed > Q_cap)
+        # E = Stream Power (detachment limited)
+        
+        # Delta 시뮬레이션을 위한 접근:
+        # 퇴적물 플럭스(Flux)를 하류로 밀어내는 로직 추가.
+        
+        h, w = self.grid.height, self.grid.width
+        sediment_flux = np.zeros((h, w))
+        
+        # 유량 순서대로 처리 (Upstream -> Downstream)
+        # discharge가 낮은 곳(상류)에서 높은 곳(하류)으로? 
+        # D8 흐름 방향을 다시 추적해야 정확함.
+        # 여기서는 간단히 'Capacity 초과분 퇴적'만 구현하고, 
+        # Flux Routing은 HydroKernel과 연동되어야 함.
+        
+        # 임시: Capacity based deposition only (Local)
+        # 퇴적량 = (현재 유사량 - 용량) * 비율
+        # 현재 유사량이 없으므로, 침식된 흙(Stream Power 결과)이 
+        # 해당 셀의 Capacity를 넘으면 즉시 퇴적된다고 가정.
+        
+        pass 
+        # TODO: Flux Routing 구현 필요. 현재 구조에서는 어려움.
+        # ErosionProcess를 수정하여 'simulate_transport' 메서드로 통합.
+        
+        return capacity
+
+    def simulate_transport(self, discharge: np.ndarray, dt: float = 1.0, 
+                          sediment_influx_map: np.ndarray = None) -> np.ndarray:
+        """
+        통합 퇴적물 이송 시뮬레이션 (Flux-based)
+        1. 상류에서 퇴적물 유입 (Flux In)
+        2. 로컬 침식/퇴적 (Erosion/Deposition)
+        3. 하류로 배출 (Flux Out)
+        """
+        h, w = self.grid.height, self.grid.width
+        elev = self.grid.elevation
+        
+        # 1. 정렬 (높은 곳 -> 낮은 곳)
+        indices = np.argsort(elev.ravel())[::-1]
+        
+        # 퇴적물 플럭스 초기화 (유입원 반영)
+        flux = np.zeros((h, w))
+        if sediment_influx_map is not None:
+            flux += sediment_influx_map
+            
+        slope, _ = self.grid.get_gradient()
+        slope = np.maximum(slope, 0.001)
+        
+        change = np.zeros((h, w))
+        
+        # D8 Neighbors (Lookup for flow_dir)
+        d8_dr = [-1, -1, -1,  0,  0,  1,  1,  1]
+        d8_dc = [-1,  0,  1, -1,  1, -1,  0,  1]
+        
+        # Check if flow_dir is available
+        use_flow_dir = (self.grid.flow_dir is not None)
+        
+        for idx in indices:
+            r, c = idx // w, idx % w
+            
+
+
+            # 해수면 아래 깊은 곳은 퇴적 위주
+            underwater = self.grid.is_underwater()[r, c]
+            
+            # A. 운반 능력 (Capacity)
+            # 물 속에서는 유속이 급감한다고 가정 -> Capacity 감소
+            # eff_slope calculation fix: slope can be very small on flat land
+            eff_slope = slope[r, c] if not underwater else slope[r, c] * 0.01
+            
+            # Kf (Transportation efficiency) should be high enough
+            # Use 'self.K * 100' or similar
+            qs_cap = self.K * 500 * np.power(discharge[r, c], self.m) * np.power(eff_slope, self.n)
+            
+            # B. 현재 플럭스 (상류에서 들어온 것 + 로컬 침식 잠재량)
+            qs_in = flux[r, c]
+            
+            # C. 침식 vs 퇴적 결정
+            # 기계적 침식 (Stream Power)
+            potential_erosion = self.K * np.power(discharge[r, c], self.m) * np.power(slope[r, c], self.n) * dt
+            
+            # 만약 들어온 흙(qs_in)이 용량(qs_cap)보다 많으면 -> 퇴적
+            if qs_in > qs_cap:
+                # 퇴적량 = 초과분 * 1.0 (일단 100% 퇴적 가정하여 효과 확인)
+                deposition_amount = (qs_in - qs_cap) * 1.0 
+                change[r, c] += deposition_amount
+                qs_out = qs_cap # 나머지는 하류로? 아니, 퇴적 후 남은건 qs_cap임 (Transport-limited)
+            else:
+                # 용량이 남으면 -> 침식하여 흙을 더 싣고감
+                # 실제 침식 = 잠재 침식 (기반암도 침식 가능)
+                erosion_amount = potential_erosion
+                
+                change[r, c] -= erosion_amount
+                qs_out = qs_in + erosion_amount
+
+            # D. 하류로 전달 (Qs Out Routing)
+            # Use pre-calculated flow direction if available
+            target_r, target_c = -1, -1
+            
+            if use_flow_dir:
+                k = self.grid.flow_dir[r, c]
+                # k could be default 0 even if no flow?
+                # Usually sink nodes have special value (e.g. -1 or point to self)
+                # But here we initialized to 0.
+                # Need to check constraints.
+                # If discharge[r,c] > 0, flow_dir should be valid.
+                if discharge[r, c] > 0:
+                     nr = r + d8_dr[k]
+                     nc = c + d8_dc[k]
+                     if 0 <= nr < h and 0 <= nc < w:
+                         target_r, target_c = nr, nc
+            else:
+                # Fallback: Local Seek (Slow)
+                min_z = elev[r, c]
+                for k in range(8):
+                    nr = r + d8_dr[k]
+                    nc = c + d8_dc[k]
+                    if 0 <= nr < h and 0 <= nc < w:
+                        if elev[nr, nc] < min_z:
+                            min_z = elev[nr, nc]
+                            target_r, target_c = nr, nc
+            
+            if target_r != -1:
+                flux[target_r, target_c] += qs_out
+            else:
+                # 갇힌 곳(Sink) -> 그 자리에 퇴적
+                # 침식이 발생했다면 되돌려놓고 퇴적
+                change[r, c] += qs_out
+        
+        # 지형 업데이트
+        # 침식은 elevation 감소, 퇴적은 sediment 증가이지만
+        # 여기서는 통합하여 elevation/sediment 조정
+        
+        # 퇴적분: sediment 층에 추가
+        self.grid.add_sediment(np.maximum(change, 0))
+        
+        # 침식분: elevation 감소 (grid.add_sediment가 음수도 처리하나? 아님)
+        # 침식은 bedrock이나 sediment를 깎아야 함.
+        # erosion_process.py의 역할상 직접 grid 수정을 해도 됨.
+        erosion_mask = change < 0
+        loss = -change[erosion_mask]
+        
+        # 퇴적층 먼저 깎고 기반암 깎기
+        sed_thickness = self.grid.sediment[erosion_mask]
+        sed_loss = np.minimum(loss, sed_thickness)
+        rock_loss = loss - sed_loss
+        
+        self.grid.sediment[erosion_mask] -= sed_loss
+        self.grid.bedrock[erosion_mask] -= rock_loss
+        self.grid.update_elevation()
+        
+        return change

engine/fluids.py

@@ -0,0 +1,286 @@
+import numpy as np
+from .grid import WorldGrid
+
+try:
+    from numba import jit
+    HAS_NUMBA = True
+except ImportError:
+    HAS_NUMBA = False
+    # Dummy decorator if numba is missing
+    def jit(*args, **kwargs):
+        def decorator(func):
+            return func
+        return decorator
+
+@jit(nopython=True)
+def _d8_flow_kernel(elev, discharge, flow_dir, underwater, h, w):
+    """
+    Numba-optimized D8 Flow Routing
+    """
+    # Flatten elevation to sort
+    flat_elev = elev.ravel()
+    # Sort indices descending (Source -> Sink)
+    # Note: argsort in numba supports 1D array
+    flat_indices = np.argsort(flat_elev)[::-1]
+    
+    # 8-neighbor offsets
+    # Numba doesn't like list of tuples in loops sometimes, simple arrays are better
+    dr = np.array([-1, -1, -1,  0,  0,  1,  1,  1])
+    dc = np.array([-1,  0,  1, -1,  1, -1,  0,  1])
+    
+    for i in range(len(flat_indices)):
+        idx = flat_indices[i]
+        r = idx // w
+        c = idx % w
+        
+        # Check underwater
+        if underwater[r, c]:
+            continue
+            
+        current_z = elev[r, c]
+        min_z = current_z
+        target_r = -1
+        target_c = -1
+        target_k = -1
+        
+        # Find steepest descent
+        for k in range(8):
+            nr = r + dr[k]
+            nc = c + dc[k]
+            
+            if 0 <= nr < h and 0 <= nc < w:
+                n_elev = elev[nr, nc]
+                if n_elev < min_z:
+                    min_z = n_elev
+                    target_r = nr
+                    target_c = nc
+                    target_k = k
+        
+        # Pass flow to lowest neighbor
+        if target_r != -1:
+            discharge[target_r, target_c] += discharge[r, c]
+            flow_dir[r, c] = target_k # Store direction (0-7)
+
+class HydroKernel:
+    """
+    수력학 커널 (Hydro Kernel)
+    
+    물의 흐름과 분포를 시뮬레이션합니다.
+    - D8 알고리즘: 하천 네트워크 형성 (Numba 가속 적용)
+    - Shallow Water (간소화): 홍수 및 해수면 침수
+    """
+    
+    def __init__(self, grid: WorldGrid):
+        self.grid = grid
+        
+    def route_flow_d8(self, precipitation: float = 0.001) -> np.ndarray:
+        """
+        D8 알고리즘으로 유량(Discharge) 계산 (Numba 가속)
+        """
+        h, w = self.grid.height, self.grid.width
+        elev = self.grid.elevation
+        
+        # 1. 초기 강수 분포
+        discharge = np.full((h, w), precipitation * (self.grid.cell_size ** 2), dtype=np.float64)
+        
+        # 2. 해수면 마스크
+        underwater = self.grid.is_underwater()
+        
+        # 3. Numba Kernel 호출
+        if HAS_NUMBA:
+            _d8_flow_kernel(elev, discharge, self.grid.flow_dir, underwater, h, w)
+        else:
+            # Fallback (Slow Python) if numba somehow fails to import
+            self._route_flow_d8_python(discharge, self.grid.flow_dir, elev, underwater, h, w)
+            
+        return discharge
+
+    def route_flow_mfd(self, precipitation: float = 0.001, p: float = 1.1) -> np.ndarray:
+        """
+        MFD (Multiple Flow Direction) 유량 분배
+        
+        D8과 달리 낮은 모든 이웃에게 경사 비례로 유량 분배.
+        망류(Braided Stream) 및 분기류 표현에 적합.
+        
+        Args:
+            precipitation: 강수량
+            p: 분배 지수 (1.0=선형, >1.0=가파른 곳에 집중)
+            
+        Returns:
+            discharge: 유량 배열
+        """
+        h, w = self.grid.height, self.grid.width
+        elev = self.grid.elevation
+        
+        # 초기 강수
+        discharge = np.full((h, w), precipitation * (self.grid.cell_size ** 2), dtype=np.float64)
+        
+        # 해수면 마스크
+        underwater = self.grid.is_underwater()
+        
+        # D8 방향 벡터
+        dr = np.array([-1, -1, -1,  0,  0,  1,  1,  1])
+        dc = np.array([-1,  0,  1, -1,  1, -1,  0,  1])
+        dist = np.array([1.414, 1.0, 1.414, 1.0, 1.0, 1.414, 1.0, 1.414])  # 대각 거리
+        
+        # 정렬 (높은 곳 -> 낮은 곳)
+        flat_indices = np.argsort(elev.ravel())[::-1]
+        
+        for idx in flat_indices:
+            r, c = idx // w, idx % w
+            
+            if underwater[r, c]:
+                continue
+                
+            current_z = elev[r, c]
+            current_q = discharge[r, c]
+            
+            if current_q <= 0:
+                continue
+            
+            # 낮은 이웃들의 경사 계산
+            slopes = []
+            targets = []
+            
+            for k in range(8):
+                nr, nc = r + dr[k], c + dc[k]
+                if 0 <= nr < h and 0 <= nc < w:
+                    dz = current_z - elev[nr, nc]
+                    if dz > 0:  # 하강하는 방향만
+                        slope = dz / (dist[k] * self.grid.cell_size)
+                        slopes.append(slope ** p)
+                        targets.append((nr, nc))
+            
+            if not slopes:
+                continue
+                
+            # 경사 비례 분배
+            total_slope = sum(slopes)
+            for i, (nr, nc) in enumerate(targets):
+                fraction = slopes[i] / total_slope
+                discharge[nr, nc] += current_q * fraction
+                
+        return discharge
+
+    def _route_flow_d8_python(self, discharge, flow_dir, elev, underwater, h, w):
+        """Legacy Python implementation for fallback"""
+        flat_indices = np.argsort(elev.ravel())[::-1]
+        neighbors = [(-1,-1), (-1,0), (-1,1), (0,-1), (0,1), (1,-1), (1,0), (1,1)]
+        
+        for idx in flat_indices:
+            r, c = idx // w, idx % w
+            if underwater[r, c]: continue
+            
+            min_z = elev[r, c]
+            target = None
+            target_k = -1
+            
+            for k, (dr, dc) in enumerate(neighbors):
+                nr, nc = r + dr, c + dc
+                if 0 <= nr < h and 0 <= nc < w:
+                    if elev[nr, nc] < min_z:
+                        min_z = elev[nr, nc]
+                        target = (nr, nc)
+                        target_k = k
+            
+            if target:
+                tr, tc = target
+                discharge[tr, tc] += discharge[r, c]
+                flow_dir[r, c] = target_k
+
+    def calculate_water_depth(self, discharge: np.ndarray, manning_n: float = 0.03) -> np.ndarray:
+        """
+        Manning 공식을 이용한 하천 수심 추정 (정상 등류 가정)
+        Depth = (Q * n / (Width * S^0.5))^(3/5)
+        
+        * 경사(S)가 0인 경우 최소 경사 적용
+        * 하폭(W)은 유량(Q)의 함수로 가정 (W ~ Q^0.5)
+        """
+        slope, _ = self.grid.get_gradient()
+        slope = np.maximum(slope, 0.001) # 최소 경사 설정
+        
+        # 하폭 추정: W = 5 * Q^0.5 (경험식)
+        # Q가 매우 작으면 W도 작아짐
+        width = 5.0 * np.sqrt(discharge)
+        width = np.maximum(width, 1.0) # 최소 폭 1m
+        
+        # 수심 계산
+        # Q = V * Area = (1/n * R^(2/3) * S^(1/2)) * (W * D)
+        # 직사각형 단면 가정 시 R approx D (넓은 하천)
+        # Q = (1/n) * D^(5/3) * W * S^(1/2)
+        # D = (Q * n / (W * S^0.5)) ^ (3/5)
+        
+        val = (discharge * manning_n) / (width * np.sqrt(slope))
+        depth = np.power(val, 0.6)
+        
+        return depth
+    
+    def simulate_inundation(self):
+        """해수면 상승에 따른 침수 시뮬레이션"""
+        # 해수면보다 낮은 곳은 바다로 간주하고 수심을 채움
+        underwater = self.grid.is_underwater()
+        
+        # 바다 수심 = 해수면 - 지표면고도
+        sea_depth = np.maximum(0, self.grid.sea_level - self.grid.elevation)
+        
+        # 기존 수심(하천)과 바다 수심 중 큰 값 선택
+        # (하천이 바다로 들어가면 바다 수심에 묻힘)
+        self.grid.water_depth = np.where(underwater, sea_depth, self.grid.water_depth)
+
+    def fill_sinks(self, max_iterations: int = 100, tolerance: float = 0.001):
+        """
+        싱크(웅덩이) 채우기 - 호수 형성
+        
+        물이 갇히는 곳을 찾아 채워서 월류(Overflow)가 가능하도록 함.
+        간단한 반복 스무딩 방식 (Priority-Flood 근사)
+        
+        Args:
+            max_iterations: 최대 반복 횟수
+            tolerance: 수렴 허용 오차
+        """
+        h, w = self.grid.height, self.grid.width
+        elev = self.grid.elevation.copy()
+        
+        # 경계는 고정 (물이 빠져나감)
+        # 내부 싱크만 채움
+        
+        dr = [-1, -1, -1,  0,  0,  1,  1,  1]
+        dc = [-1,  0,  1, -1,  1, -1,  0,  1]
+        
+        for iteration in range(max_iterations):
+            changed = False
+            new_elev = elev.copy()
+            
+            for r in range(1, h - 1):
+                for c in range(1, w - 1):
+                    current = elev[r, c]
+                    
+                    # 이웃 중 최소값 찾기
+                    min_neighbor = current
+                    for k in range(8):
+                        nr, nc = r + dr[k], c + dc[k]
+                        if 0 <= nr < h and 0 <= nc < w:
+                            min_neighbor = min(min_neighbor, elev[nr, nc])
+                    
+                    # 모든 이웃보다 낮으면 (싱크) → 최소 이웃 높이로 맞춤
+                    if current < min_neighbor:
+                        # 살짝 높여서 흐름 유도
+                        new_elev[r, c] = min_neighbor + tolerance
+                        changed = True
+                        
+            elev = new_elev
+            
+            if not changed:
+                break
+                
+        # 채워진 양 = 새 고도 - 기존 고도
+        fill_amount = elev - self.grid.elevation
+        
+        # 물로 채워진 것으로 처리 (water_depth 증가)
+        self.grid.water_depth += np.maximum(fill_amount, 0)
+        
+        # bedrock은 그대로, sediment도 그대로 (물만 채움)
+        # 또는 sediment로 채울 수도 있음 (호수 퇴적)
+        
+        return fill_amount
+

engine/glacier.py

@@ -0,0 +1,218 @@
+"""
+Glacier Kernel (빙하 커널)
+
+빙하 지형 형성 프로세스
+- 빙하 침식: Plucking (뜯어내기), Abrasion (마식)
+- U자곡 형성
+- 모레인(Moraine) 퇴적
+
+핵심:
+- 빙하 두께에 비례한 침식
+- 측면보다 중앙 침식이 강함 → U자 형태
+"""
+
+import numpy as np
+from .grid import WorldGrid
+
+
+class GlacierKernel:
+    """
+    빙하 커널
+    
+    빙하가 존재하는 지역에서 침식과 퇴적을 시뮬레이션.
+    """
+    
+    def __init__(self, grid: WorldGrid,
+                 ice_threshold_temp: float = 0.0,  # 빙하 형성 기온 (°C)
+                 K_erosion: float = 0.0001,
+                 sliding_velocity: float = 10.0):  # m/year
+        self.grid = grid
+        self.ice_threshold = ice_threshold_temp
+        self.K = K_erosion
+        self.sliding_velocity = sliding_velocity
+        
+        # 빙하 두께 배열
+        self.ice_thickness = np.zeros((grid.height, grid.width))
+        
+    def accumulate_ice(self, temperature: np.ndarray, 
+                       precipitation: np.ndarray,
+                       dt: float = 1.0):
+        """
+        빙하 축적
+        
+        기온 < 임계값인 곳에 눈/빙하 축적
+        
+        Args:
+            temperature: 기온 배열
+            precipitation: 강수량 배열
+            dt: 시간 간격
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        # 빙하 축적 조건: 기온 < 0°C
+        cold_mask = temperature < self.ice_threshold
+        
+        # 축적률 = 강수량 * (기온이 낮을수록 더 많이)
+        accumulation_rate = precipitation * np.clip(-temperature / 10.0, 0, 1) * 0.001
+        
+        # 축적
+        self.ice_thickness[cold_mask] += accumulation_rate[cold_mask] * dt
+        
+        # 빙하 소멸 (기온 > 0°C)
+        warm_mask = temperature > self.ice_threshold
+        melt_rate = temperature * 0.01  # 기온당 융해율
+        self.ice_thickness[warm_mask] -= np.minimum(
+            melt_rate[warm_mask] * dt, 
+            self.ice_thickness[warm_mask]
+        )
+        
+        self.ice_thickness = np.maximum(self.ice_thickness, 0)
+        
+    def flow_ice(self, dt: float = 1.0):
+        """
+        빙하 흐름 (중력에 의한 하강)
+        
+        높은 곳에서 낮은 곳으로 빙하 이동
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        slope, _ = self.grid.get_gradient()
+        
+        # 빙하 흐름 속도 = 기본 속도 * 경사 * 두께
+        flow_speed = self.sliding_velocity * slope * np.sqrt(self.ice_thickness + 0.1)
+        
+        # D8 방향으로 빙하 이동 (간단한 근사)
+        dr = np.array([-1, -1, -1,  0,  0,  1,  1,  1])
+        dc = np.array([-1,  0,  1, -1,  1, -1,  0,  1])
+        
+        new_ice = self.ice_thickness.copy()
+        elev = self.grid.elevation
+        
+        for r in range(1, h - 1):
+            for c in range(1, w - 1):
+                if self.ice_thickness[r, c] <= 0:
+                    continue
+                    
+                # 가장 낮은 이웃 찾기
+                min_z = elev[r, c]
+                target = None
+                
+                for k in range(8):
+                    nr, nc = r + dr[k], c + dc[k]
+                    if 0 <= nr < h and 0 <= nc < w:
+                        if elev[nr, nc] < min_z:
+                            min_z = elev[nr, nc]
+                            target = (nr, nc)
+                            
+                if target:
+                    tr, tc = target
+                    # 이동량 (속도에 비례, 최대 10%)
+                    move = min(self.ice_thickness[r, c] * 0.1 * dt, self.ice_thickness[r, c])
+                    new_ice[r, c] -= move
+                    new_ice[tr, tc] += move
+                    
+        self.ice_thickness = new_ice
+        
+    def erode(self, dt: float = 1.0) -> np.ndarray:
+        """
+        빙하 침식
+        
+        U자곡 형성을 위한 차별 침식
+        - 중앙(빙하 두꺼운 곳): 강한 침식
+        - 측면: 약한 침식
+        
+        Returns:
+            erosion: 침식량 배열
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        # 빙하가 있는 곳만 침식
+        glacier_mask = self.ice_thickness > 0.1
+        
+        erosion = np.zeros((h, w), dtype=np.float64)
+        
+        if not np.any(glacier_mask):
+            return erosion
+            
+        # 침식률 = K * 두께 * 속도 * 경사
+        slope, _ = self.grid.get_gradient()
+        
+        erosion_rate = self.K * self.ice_thickness * self.sliding_velocity * slope
+        erosion[glacier_mask] = erosion_rate[glacier_mask] * dt
+        
+        # 침식 적용
+        self.grid.bedrock -= erosion
+        self.grid.update_elevation()
+        
+        return erosion
+        
+    def deposit_moraine(self, dt: float = 1.0) -> np.ndarray:
+        """
+        모레인 퇴적
+        
+        빙하 말단(thickness 급감 지점)에 퇴적
+        
+        Returns:
+            deposition: 퇴적량 배열
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        deposition = np.zeros((h, w), dtype=np.float64)
+        
+        # 빙하 두께 감소 지점 = 말단
+        # Gradient of ice thickness
+        dy, dx = np.gradient(self.ice_thickness)
+        ice_gradient = np.sqrt(dx**2 + dy**2)
+        
+        # 말단 조건: 빙하 있고, gradient 큼
+        terminal_mask = (self.ice_thickness > 0.1) & (ice_gradient > 0.1)
+        
+        # 퇴적량 = gradient에 비례
+        deposition[terminal_mask] = ice_gradient[terminal_mask] * 0.01 * dt
+        
+        # 퇴적 적용
+        self.grid.add_sediment(deposition)
+        
+        return deposition
+        
+    def step(self, temperature: np.ndarray = None,
+             precipitation: np.ndarray = None,
+             dt: float = 1.0) -> dict:
+        """
+        1단계 빙하 작용 실행
+        
+        Args:
+            temperature: 기온 배열 (없으면 기본값 사용)
+            precipitation: 강수량 배열
+            dt: 시간 간격
+            
+        Returns:
+            result: 빙하 상태 및 변화량
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        # 기본 기온/강수
+        if temperature is None:
+            # 고도 기반 간단한 기온 계산
+            temperature = 15.0 - (self.grid.elevation / 1000.0) * 6.5
+            
+        if precipitation is None:
+            precipitation = np.ones((h, w)) * 1000.0  # mm/year
+            
+        # 1. 빙하 축적/소멸
+        self.accumulate_ice(temperature, precipitation, dt)
+        
+        # 2. 빙하 흐름
+        self.flow_ice(dt)
+        
+        # 3. 침식
+        erosion = self.erode(dt)
+        
+        # 4. 모레인 퇴적
+        moraine = self.deposit_moraine(dt)
+        
+        return {
+            'ice_thickness': self.ice_thickness.copy(),
+            'erosion': erosion,
+            'moraine': moraine
+        }

engine/grid.py

@@ -0,0 +1,88 @@
+import numpy as np
+from dataclasses import dataclass, field
+from typing import Tuple, Optional
+
+@dataclass
+class WorldGrid:
+    """
+    지구 시스템 통합 그리드 (World Grid)
+    
+    모든 물리적 상태(고도, 물, 퇴적물)를 통합 관리하는 중앙 데이터 구조입니다.
+    기존의 개별 시뮬레이션 그리드와 달리, 전지구적 해수면(Sea Level)과 연동됩니다.
+    """
+    width: int = 100
+    height: int = 100
+    cell_size: float = 10.0  # 미터 (m)
+    sea_level: float = 0.0   # 해수면 고도 (m)
+    
+    # --- 상태 레이어 (State Layers) ---
+    # 기반암 고도 (Bedrock Elevation)
+    bedrock: np.ndarray = field(default=None)
+    # 퇴적층 두께 (Sediment Thickness)
+    sediment: np.ndarray = field(default=None)
+    # 수심 (Water Depth) - 표면 유출수
+    water_depth: np.ndarray = field(default=None)
+    # 유량 (Discharge)
+    discharge: np.ndarray = field(default=None)
+    # 유향 (Flow Direction)
+    flow_dir: np.ndarray = field(default=None)
+    
+    # --- 파생 레이어 (Derived Layers) ---
+    # 지표면 고도 (Topography = Bedrock + Sediment)
+    elevation: np.ndarray = field(default=None)
+    
+    def __post_init__(self):
+        """그리드 초기화"""
+        shape = (self.height, self.width)
+        
+        if self.bedrock is None:
+            self.bedrock = np.zeros(shape)
+        if self.sediment is None:
+            self.sediment = np.zeros(shape)
+        if self.water_depth is None:
+            self.water_depth = np.zeros(shape)
+        if self.discharge is None:
+            self.discharge = np.zeros(shape)
+        if self.flow_dir is None:
+            self.flow_dir = np.zeros(shape, dtype=int)
+        if self.elevation is None:
+            self.update_elevation()
+            
+    def update_elevation(self):
+        """지표면 고도 갱신 (기반암 + 퇴적층)"""
+        self.elevation = self.bedrock + self.sediment
+
+    def get_gradient(self) -> Tuple[np.ndarray, np.ndarray]:
+        """
+        경사도(Slope)와 경사향(Aspect) 계산
+        Returns:
+            slope (m/m): 경사도
+            aspect (rad): 경사 방향 (0=East, pi/2=North)
+        """
+        dy, dx = np.gradient(self.elevation, self.cell_size)
+        slope = np.sqrt(dx**2 + dy**2)
+        aspect = np.arctan2(dy, dx)
+        return slope, aspect
+
+    def get_water_surface(self) -> np.ndarray:
+        """수면 고도 반환 (지표면 + 수심)"""
+        return self.elevation + self.water_depth
+
+    def is_underwater(self) -> np.ndarray:
+        """해수면 기준 침수 여부 확인"""
+        # 해수면보다 낮거나, 지표면에 물이 흐르고 있는 경우
+        # 여기서는 간단히 '해수면' 기준과 '담수' 존재 여부를 분리해서 생각할 수 있음.
+        # 일단 해수면(Sea Level) 기준 침수 지역 반환
+        return self.elevation < self.sea_level
+
+    def apply_uplift(self, rate: float, dt: float = 1.0):
+        """지반 융기 적용"""
+        self.bedrock += rate * dt
+        self.update_elevation()
+
+    def add_sediment(self, amount: np.ndarray):
+        """퇴적물 추가/제거"""
+        self.sediment += amount
+        # 퇴적물은 0보다 작을 수 없음 (기반암 침식은 별도 로직)
+        self.sediment = np.maximum(self.sediment, 0)
+        self.update_elevation()

engine/ideal_landforms.py

@@ -0,0 +1,1621 @@
+"""
+Ideal Landform Geometry Models (이상적 지형 기하학 모델)
+
+교과서적인 지형 형태를 기하학적으로 생성.
+물리 시뮬레이션이 아닌, 직접 수학적으로 "이상적 형태"를 그림.
+
+- 삼각주: 부채꼴 (Sector)
+- 선상지: 원뿔 (Cone)
+- 곡류: S자 곡선 (Kinoshita Curve)
+- U자곡: 포물선 단면
+- V자곡: 삼각형 단면
+- 해안 절벽: 계단형 후퇴
+- 사구: 바르한 (Crescent)
+"""
+
+import numpy as np
+from typing import Tuple
+
+
+def create_delta(grid_size: int = 100, 
+                 apex_row: float = 0.2,
+                 spread_angle: float = 120.0,
+                 num_channels: int = 7) -> np.ndarray:
+    """
+    삼각주 (Delta) - 조족상/부채꼴
+    
+    Args:
+        grid_size: 그리드 크기
+        apex_row: 정점(Apex) 위치 (0~1, 상단 기준)
+        spread_angle: 퍼짐 각도 (도)
+        num_channels: 분배 수로 개수
+        
+    Returns:
+        elevation: 고도 배열
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    apex_y = int(h * apex_row)
+    center_x = w // 2
+    
+    # 배경: 바다 (음수)
+    elevation[:, :] = -5.0
+    
+    # 육지 배경 (삼각주 전체)
+    half_angle = np.radians(spread_angle / 2)
+    
+    for r in range(apex_y, h):
+        dist = r - apex_y
+        if dist == 0:
+            continue
+            
+        # 각도 범위 내 육지
+        for c in range(w):
+            dx = c - center_x
+            angle = np.arctan2(dx, dist)  # 정점 기준 각도
+            
+            if abs(angle) < half_angle:
+                # 삼각주 육지
+                # 중심에서 멀수록 낮아짐
+                radial_dist = np.sqrt(dx**2 + dist**2)
+                max_dist = h - apex_y
+                elevation[r, c] = 10.0 * (1 - radial_dist / max_dist)
+                
+    # 분배 수로 (Distributary Channels)
+    for i in range(num_channels):
+        channel_angle = -half_angle + (2 * half_angle) * (i / (num_channels - 1))
+        
+        for r in range(apex_y, h):
+            dist = r - apex_y
+            c = int(center_x + dist * np.tan(channel_angle))
+            
+            if 0 <= c < w:
+                # 수로 파기 (음각)
+                for dc in range(-2, 3):
+                    if 0 <= c + dc < w:
+                        depth = 2.0 * (1 - abs(dc) / 3)
+                        elevation[r, c + dc] -= depth
+                        
+    return elevation
+
+
+def create_alluvial_fan(grid_size: int = 100,
+                         apex_row: float = 0.15,
+                         cone_angle: float = 90.0,
+                         max_height: float = 50.0) -> np.ndarray:
+    """
+    선상지 (Alluvial Fan) - 원뿔형
+    
+    Args:
+        grid_size: 그리드 크기
+        apex_row: 정점 위치
+        cone_angle: 부채꼴 각도
+        max_height: 최대 고도
+        
+    Returns:
+        elevation: 고도 배열
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    apex_y = int(h * apex_row)
+    center_x = w // 2
+    half_angle = np.radians(cone_angle / 2)
+    
+    # 배경 산지 (상단)
+    for r in range(apex_y):
+        elevation[r, :] = max_height + (apex_y - r) * 2.0
+        
+    # 선상지 본체 (원뿔)
+    for r in range(apex_y, h):
+        dist = r - apex_y
+        max_dist = h - apex_y
+        
+        for c in range(w):
+            dx = c - center_x
+            angle = np.arctan2(abs(dx), dist) if dist > 0 else 0
+            
+            if abs(np.arctan2(dx, dist)) < half_angle:
+                # 원뿔 형태: 중심이 높고, 가장자리가 낮음
+                radial = np.sqrt(dx**2 + dist**2)
+                # 정점에서 멀어질수록 낮아짐
+                z = max_height * (1 - radial / (max_dist * 1.5))
+                # 가장자리로 갈수록 더 급격히 낮아짐
+                lateral_decay = 1 - abs(dx) / (w // 2)
+                elevation[r, c] = max(0, z * lateral_decay)
+            else:
+                elevation[r, c] = 0  # 평지
+                
+    # 협곡 (Apex에서 시작)
+    for r in range(0, apex_y + 5):
+        for dc in range(-3, 4):
+            c = center_x + dc
+            if 0 <= c < w:
+                depth = 10.0 * (1 - abs(dc) / 4)
+                elevation[r, c] -= depth
+                
+    return elevation
+
+
+def create_meander(grid_size: int = 100,
+                   amplitude: float = 0.3,
+                   wavelength: float = 0.25,
+                   num_bends: int = 3) -> np.ndarray:
+    """
+    곡류 (Meander) - S자 사행 하천
+    
+    Args:
+        grid_size: 그리드 크기
+        amplitude: 사행 진폭 (그리드 비율)
+        wavelength: 파장 (그리드 비율)
+        num_bends: 굽이 개수
+        
+    Returns:
+        elevation: 고도 배열
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 배경: 범람원 평탄면
+    elevation[:, :] = 10.0
+    
+    center_x = w // 2
+    amp = w * amplitude
+    wl = h / num_bends
+    channel_width = max(3, w // 20)
+    
+    # 사행 하천 경로
+    for r in range(h):
+        # Kinoshita curve (이상화된 곡류)
+        theta = 2 * np.pi * r / wl
+        meander_x = center_x + amp * np.sin(theta)
+        
+        for c in range(w):
+            dist = abs(c - meander_x)
+            
+            if dist < channel_width:
+                # 하도 (낮게)
+                elevation[r, c] = 5.0 - (channel_width - dist) * 0.3
+            elif dist < channel_width * 3:
+                # 자연제방 (약간 높게)
+                elevation[r, c] = 10.5
+                
+    # 우각호 (Oxbow Lake) 추가
+    # 중간쯤에 절단된 곡류 흔적
+    oxbow_y = h // 2
+    oxbow_amp = amp * 1.5
+    
+    for dy in range(-int(wl/4), int(wl/4)):
+        r = oxbow_y + dy
+        if 0 <= r < h:
+            theta = 2 * np.pi * dy / (wl/2)
+            ox_x = center_x + oxbow_amp * np.sin(theta)
+            
+            for dc in range(-channel_width, channel_width + 1):
+                c = int(ox_x + dc)
+                if 0 <= c < w:
+                    elevation[r, c] = 4.0  # 호수 수면
+                    
+    return elevation
+
+
+def create_u_valley(grid_size: int = 100,
+                    valley_depth: float = 100.0,
+                    valley_width: float = 0.4) -> np.ndarray:
+    """
+    U자곡 (U-shaped Valley) - 빙하 침식 지형
+    
+    Args:
+        grid_size: 그리드 크기
+        valley_depth: 곡저 깊이
+        valley_width: 곡저 너비 (비율)
+        
+    Returns:
+        elevation: 고도 배열
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center = w // 2
+    half_width = int(w * valley_width / 2)
+    
+    for r in range(h):
+        for c in range(w):
+            dx = abs(c - center)
+            
+            if dx < half_width:
+                # U자 바닥 (평탄)
+                elevation[r, c] = 0
+            else:
+                # U자 측벽 (급경사 후 완만)
+                # y = (x/a)^4 형태
+                normalized_x = (dx - half_width) / (w // 2 - half_width)
+                elevation[r, c] = valley_depth * (normalized_x ** 2)
+                
+        # 상류로 갈수록 높아짐
+        elevation[r, :] += (h - r) / h * 30.0
+        
+    return elevation
+
+
+def create_v_valley(grid_size: int = 100,
+                    valley_depth: float = 80.0) -> np.ndarray:
+    """
+    V자곡 (V-shaped Valley) - 하천 침식 지형
+    
+    Args:
+        grid_size: 그리드 크기
+        valley_depth: 곡저 깊이
+        
+    Returns:
+        elevation: 고도 배열
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center = w // 2
+    
+    for r in range(h):
+        for c in range(w):
+            dx = abs(c - center)
+            
+            # V자 형태: |x| 에 비례
+            elevation[r, c] = valley_depth * (dx / (w // 2))
+            
+        # 상류로 갈수록 높아짐
+        elevation[r, :] += (h - r) / h * 50.0
+        
+    # 하천 (V자 바닥)
+    for r in range(h):
+        for dc in range(-2, 3):
+            c = center + dc
+            if 0 <= c < w:
+                elevation[r, c] = max(0, elevation[r, c] - 5)
+                
+    return elevation
+
+
+def create_barchan_dune(grid_size: int = 100,
+                         num_dunes: int = 3) -> np.ndarray:
+    """
+    바르한 사구 (Barchan Dune) - 초승달 모양
+    
+    Args:
+        grid_size: 그리드 크기
+        num_dunes: 사구 개수
+        
+    Returns:
+        elevation: 고도 배열
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 사막 기반면
+    elevation[:, :] = 5.0
+    
+    for i in range(num_dunes):
+        # 사구 중심
+        cy = h // 4 + i * (h // (num_dunes + 1))
+        cx = w // 2 + (i - num_dunes // 2) * (w // 5)
+        
+        dune_height = 15.0 + np.random.rand() * 10.0
+        dune_length = w // 5
+        dune_width = w // 8
+        
+        for r in range(h):
+            for c in range(w):
+                dy = r - cy
+                dx = c - cx
+                
+                # 바르한: 바람받이(앞)는 완만, 바람그늘(뒤)는 급경사
+                # 초승달 형태
+                
+                # 거리
+                dist = np.sqrt((dy / dune_length) ** 2 + (dx / dune_width) ** 2)
+                
+                if dist < 1.0:
+                    # 사구 본체
+                    # 앞쪽(바람받이): 완만한 경사
+                    # 뒤쪽: 급경사 (Slip Face)
+                    
+                    if dy < 0:  # 바람받이
+                        z = dune_height * (1 - dist) * (1 - abs(dy) / dune_length)
+                    else:  # 바람그늘
+                        z = dune_height * (1 - dist) * max(0, 1 - dy / (dune_length * 0.5))
+                        
+                    # 초승달 뿔 (Horns)
+                    horn_factor = 1 + 0.5 * abs(dx / dune_width)
+                    
+                    elevation[r, c] = max(elevation[r, c], 5.0 + z * horn_factor)
+                    
+    return elevation
+
+
+def create_coastal_cliff(grid_size: int = 100,
+                          cliff_height: float = 30.0,
+                          num_stacks: int = 2) -> np.ndarray:
+    """
+    해안 절벽 (Coastal Cliff) + 시스택
+    
+    Args:
+        grid_size: 그리드 크기
+        cliff_height: 절벽 높이
+        num_stacks: 시스택 개수
+        
+    Returns:
+        elevation: 고도 배열
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 바다 (하단)
+    sea_line = int(h * 0.6)
+    elevation[sea_line:, :] = -5.0
+    
+    # 육지 + 절벽
+    for r in range(sea_line):
+        cliff_dist = sea_line - r
+        if cliff_dist < 5:
+            # 절벽면
+            elevation[r, :] = cliff_height * (cliff_dist / 5)
+        else:
+            # 평탄한 육지
+            elevation[r, :] = cliff_height
+            
+    # 파식대 (Wave-cut Platform)
+    for r in range(sea_line, sea_line + 10):
+        if r < h:
+            elevation[r, :] = -2.0 + (r - sea_line) * 0.2
+            
+    # 시스택 (Sea Stacks)
+    for i in range(num_stacks):
+        sx = w // 3 + i * (w // 3)
+        sy = sea_line + 5 + i * 3
+        
+        stack_height = cliff_height * 0.7
+        
+        for dr in range(-3, 4):
+            for dc in range(-3, 4):
+                r, c = sy + dr, sx + dc
+                if 0 <= r < h and 0 <= c < w:
+                    dist = np.sqrt(dr**2 + dc**2)
+                    if dist < 3:
+                        elevation[r, c] = stack_height * (1 - dist / 4)
+                        
+    return elevation
+
+
+# ============================================
+# 애니메이션용 형성과정 함수 (Stage-based)
+# stage: 0.0 (시작) ~ 1.0 (완성)
+# ============================================
+
+def create_delta_animated(grid_size: int, stage: float, 
+                           spread_angle: float = 120.0, num_channels: int = 7) -> np.ndarray:
+    """삼각주 형성과정 애니메이션"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    apex_y = int(h * 0.2)
+    center_x = w // 2
+    
+    # 배경: 바다
+    elevation[:, :] = -5.0
+    
+    # 하천 (항상 존재)
+    for r in range(apex_y):
+        for dc in range(-3, 4):
+            c = center_x + dc
+            if 0 <= c < w:
+                elevation[r, c] = 5.0
+                
+    # Stage에 따라 삼각주 성장
+    max_reach = int((h - apex_y) * stage)
+    half_angle = np.radians(spread_angle / 2) * stage  # 각도도 점진적 확대
+    
+    for r in range(apex_y, apex_y + max_reach):
+        dist = r - apex_y
+        if dist == 0:
+            continue
+            
+        for c in range(w):
+            dx = c - center_x
+            angle = np.arctan2(dx, dist)
+            
+            if abs(angle) < half_angle:
+                radial_dist = np.sqrt(dx**2 + dist**2)
+                max_dist = max_reach if max_reach > 0 else 1
+                z = 10.0 * (1 - radial_dist / max_dist) * stage
+                elevation[r, c] = max(elevation[r, c], z)
+                
+    # 분배 수로 (stage 0.3 이후)
+    if stage > 0.3:
+        active_channels = int(num_channels * min(1.0, (stage - 0.3) / 0.7))
+        for i in range(active_channels):
+            channel_angle = -half_angle + (2 * half_angle) * (i / max(active_channels - 1, 1))
+            for r in range(apex_y, apex_y + max_reach):
+                dist = r - apex_y
+                c = int(center_x + dist * np.tan(channel_angle))
+                if 0 <= c < w:
+                    for dc in range(-2, 3):
+                        if 0 <= c + dc < w:
+                            elevation[r, c + dc] -= 1.5
+                            
+    return elevation
+
+
+def create_alluvial_fan_animated(grid_size: int, stage: float,
+                                  cone_angle: float = 90.0, max_height: float = 50.0) -> np.ndarray:
+    """선상지 형성과정 애니메이션"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    apex_y = int(h * 0.15)
+    center_x = w // 2
+    
+    # 배경 산지 (항상 존재)
+    for r in range(apex_y):
+        elevation[r, :] = max_height + (apex_y - r) * 2.0
+        
+    # 협곡
+    for r in range(apex_y + 5):
+        for dc in range(-3, 4):
+            c = center_x + dc
+            if 0 <= c < w:
+                elevation[r, c] -= 10.0 * (1 - abs(dc) / 4)
+                
+    # Stage에 따라 선상지 성장
+    max_reach = int((h - apex_y) * stage)
+    half_angle = np.radians(cone_angle / 2) * (0.5 + 0.5 * stage)
+    
+    for r in range(apex_y, apex_y + max_reach):
+        dist = r - apex_y
+        for c in range(w):
+            dx = c - center_x
+            if abs(np.arctan2(dx, max(dist, 1))) < half_angle:
+                radial = np.sqrt(dx**2 + dist**2)
+                z = max_height * (1 - radial / (max_reach * 1.5)) * stage
+                lateral_decay = 1 - abs(dx) / (w // 2)
+                elevation[r, c] = max(0, z * lateral_decay)
+                
+    return elevation
+
+
+def create_meander_animated(grid_size: int, stage: float,
+                            amplitude: float = 0.3, num_bends: int = 3) -> np.ndarray:
+    """곡류 형성과정 애니메이션 (직선 -> 사행 -> 우각호)"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = 10.0  # 범람원
+    
+    center_x = w // 2
+    channel_width = max(3, w // 20)
+    
+    # Stage에 따른 사행 진폭 변화 (직선 -> 굽음)
+    current_amp = w * amplitude * stage
+    wl = h / num_bends
+    
+    for r in range(h):
+        theta = 2 * np.pi * r / wl
+        meander_x = center_x + current_amp * np.sin(theta)
+        
+        for c in range(w):
+            dist = abs(c - meander_x)
+            if dist < channel_width:
+                elevation[r, c] = 5.0 - (channel_width - dist) * 0.3
+            elif dist < channel_width * 3:
+                elevation[r, c] = 10.5
+                
+    # 우각호 (stage > 0.8)
+    if stage > 0.8:
+        oxbow_intensity = (stage - 0.8) / 0.2
+        oxbow_y = h // 2
+        oxbow_amp = current_amp * 1.5
+        
+        for dy in range(-int(wl/4), int(wl/4)):
+            r = oxbow_y + dy
+            if 0 <= r < h:
+                theta = 2 * np.pi * dy / (wl/2)
+                ox_x = center_x + oxbow_amp * np.sin(theta)
+                for dc in range(-channel_width, channel_width + 1):
+                    c = int(ox_x + dc)
+                    if 0 <= c < w:
+                        elevation[r, c] = 4.0 * oxbow_intensity + elevation[r, c] * (1 - oxbow_intensity)
+                        
+    return elevation
+
+
+def create_u_valley_animated(grid_size: int, stage: float,
+                              valley_depth: float = 100.0, valley_width: float = 0.4) -> np.ndarray:
+    """U자곡 형성과정 (V자 -> U자 변환)"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    center = w // 2
+    
+    # V자에서 U자로 변환
+    # stage 0: 완전 V, stage 1: 완전 U
+    half_width = int(w * valley_width / 2) * stage  # U 바닥 너비
+    
+    for r in range(h):
+        for c in range(w):
+            dx = abs(c - center)
+            
+            if dx < half_width:
+                # U자 바닥
+                elevation[r, c] = 0
+            else:
+                # V에서 U로 전환
+                # V: linear, U: parabolic
+                normalized_x = (dx - half_width) / max(1, w // 2 - half_width)
+                v_height = valley_depth * normalized_x  # V shape
+                u_height = valley_depth * (normalized_x ** 2)  # U shape
+                elevation[r, c] = v_height * (1 - stage) + u_height * stage
+                
+        elevation[r, :] += (h - r) / h * 30.0
+        
+    return elevation
+
+
+def create_coastal_cliff_animated(grid_size: int, stage: float,
+                                   cliff_height: float = 30.0, num_stacks: int = 2) -> np.ndarray:
+    """해안 절벽 후퇴 과정"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # Stage에 따른 해안선 후퇴
+    initial_sea_line = int(h * 0.8)
+    final_sea_line = int(h * 0.5)
+    sea_line = int(initial_sea_line - (initial_sea_line - final_sea_line) * stage)
+    
+    # 바다
+    elevation[sea_line:, :] = -5.0
+    
+    # 육지 + 절벽
+    for r in range(sea_line):
+        cliff_dist = sea_line - r
+        if cliff_dist < 5:
+            elevation[r, :] = cliff_height * (cliff_dist / 5)
+        else:
+            elevation[r, :] = cliff_height
+            
+    # 파식대 (stage > 0.3)
+    if stage > 0.3:
+        platform_width = int(10 * (stage - 0.3) / 0.7)
+        for r in range(sea_line, min(h, sea_line + platform_width)):
+            elevation[r, :] = -2.0 + (r - sea_line) * 0.2
+            
+    # 시스택 (stage > 0.6)
+    if stage > 0.6:
+        stack_stage = (stage - 0.6) / 0.4
+        for i in range(num_stacks):
+            sx = w // 3 + i * (w // 3)
+            sy = sea_line + 5 + i * 3
+            stack_height = cliff_height * 0.7 * stack_stage
+            
+            for dr in range(-3, 4):
+                for dc in range(-3, 4):
+                    r, c = sy + dr, sx + dc
+                    if 0 <= r < h and 0 <= c < w:
+                        dist = np.sqrt(dr**2 + dc**2)
+                        if dist < 3:
+                            elevation[r, c] = stack_height * (1 - dist / 4)
+                            
+    return elevation
+
+
+def create_v_valley_animated(grid_size: int, stage: float,
+                              valley_depth: float = 80.0) -> np.ndarray:
+    """V자곡 형성과정 (평탄면 -> 침식 -> 깊은 V자)"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    center = w // 2
+    
+    # Stage에 따른 침식 깊이 증가
+    current_depth = valley_depth * stage
+    
+    for r in range(h):
+        for c in range(w):
+            dx = abs(c - center)
+            
+            # 초기 고원 상태에서 점진적으로 V자 형성
+            base_height = 50.0  # 초기 고원 높이
+            v_shape = current_depth * (dx / (w // 2))
+            
+            # 침식 진행에 따라 V자 깊어짐
+            elevation[r, c] = base_height - current_depth + v_shape
+            
+        # 상류 경사
+        elevation[r, :] += (h - r) / h * 30.0
+        
+    # 하천 (단계적으로 형성)
+    if stage > 0.2:
+        channel_intensity = min(1.0, (stage - 0.2) / 0.8)
+        for r in range(h):
+            for dc in range(-2, 3):
+                c = center + dc
+                if 0 <= c < w:
+                    elevation[r, c] -= 5 * channel_intensity
+                    
+    return elevation
+
+
+def create_barchan_animated(grid_size: int, stage: float,
+                             num_dunes: int = 3) -> np.ndarray:
+    """바르한 사구 형성과정 (평탄 사막 -> 모래 축적 -> 초승달 형성)"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 사막 기반면
+    elevation[:, :] = 5.0
+    
+    # Stage에 따른 사구 성장
+    np.random.seed(42)  # 일관된 위치
+    
+    for i in range(num_dunes):
+        cy = h // 4 + i * (h // (num_dunes + 1))
+        cx = w // 2 + (i - num_dunes // 2) * (w // 5)
+        
+        # 최종 높이 * stage
+        final_height = 15.0 + (i * 5.0)
+        dune_height = final_height * stage
+        
+        # 사구 크기도 stage에 비례
+        dune_length = int((w // 5) * (0.3 + 0.7 * stage))
+        dune_width = int((w // 8) * (0.3 + 0.7 * stage))
+        
+        if dune_length < 1 or dune_width < 1:
+            continue
+        
+        for r in range(h):
+            for c in range(w):
+                dy = r - cy
+                dx = c - cx
+                
+                dist = np.sqrt((dy / max(dune_length, 1)) ** 2 + (dx / max(dune_width, 1)) ** 2)
+                
+                if dist < 1.0:
+                    if dy < 0:  # 바람받이
+                        z = dune_height * (1 - dist) * (1 - abs(dy) / max(dune_length, 1))
+                    else:  # 바람그늘
+                        z = dune_height * (1 - dist) * max(0, 1 - dy / (dune_length * 0.5))
+                        
+                    horn_factor = 1 + 0.5 * abs(dx / max(dune_width, 1))
+                    elevation[r, c] = max(elevation[r, c], 5.0 + z * horn_factor)
+                    
+    return elevation
+# ============================================
+# 확장 지형 (Extended Landforms)
+# ============================================
+
+def create_incised_meander(grid_size: int = 100, stage: float = 1.0,
+                           valley_depth: float = 80.0, num_terraces: int = 3) -> np.ndarray:
+    """
+    감입곡류 (Incised Meander) + 하안단구 (River Terraces)
+    
+    융기 환경에서 곡류가 암반을 파고 들어가면서 형성
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center_x = w // 2
+    amplitude = w * 0.25 * stage
+    wl = h / 3  # 3 bends
+    channel_width = max(3, w // 25)
+    
+    # 기반 고원
+    elevation[:, :] = valley_depth
+    
+    # 감입 곡류 파기
+    for r in range(h):
+        theta = 2 * np.pi * r / wl
+        meander_x = center_x + amplitude * np.sin(theta)
+        
+        for c in range(w):
+            dist = abs(c - meander_x)
+            
+            if dist < channel_width:
+                # 하도 (가장 깊음)
+                elevation[r, c] = 5.0
+            elif dist < channel_width * 2:
+                # 급경사 측벽
+                t = (dist - channel_width) / channel_width
+                elevation[r, c] = 5.0 + (valley_depth - 5.0) * t
+                
+    # 하안단구 (계단)
+    terrace_heights = [valley_depth * (0.3 + 0.2 * i) for i in range(num_terraces)]
+    
+    for terrace_h in terrace_heights:
+        for r in range(h):
+            theta = 2 * np.pi * r / wl
+            meander_x = center_x + amplitude * np.sin(theta) * 0.8
+            
+            for c in range(w):
+                dist = abs(c - meander_x)
+                if channel_width * 3 < dist < channel_width * 4:
+                    if elevation[r, c] > terrace_h:
+                        elevation[r, c] = terrace_h
+                        
+    return elevation
+
+
+def create_free_meander(grid_size: int = 100, stage: float = 1.0,
+                        num_bends: int = 4) -> np.ndarray:
+    """
+    자유곡류 (Free Meander) + 범람원 (Floodplain) + 자연제방 (Natural Levee)
+    
+    충적 평야 위를 자유롭게 사행
+    """
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 범람원 기반
+    elevation[:, :] = 10.0
+    
+    center_x = w // 2
+    amplitude = w * 0.3 * stage
+    wl = h / num_bends
+    channel_width = max(3, w // 20)
+    
+    for r in range(h):
+        theta = 2 * np.pi * r / wl
+        meander_x = center_x + amplitude * np.sin(theta)
+        
+        for c in range(w):
+            dist = abs(c - meander_x)
+            
+            if dist < channel_width:
+                # 하도
+                elevation[r, c] = 5.0 - (channel_width - dist) * 0.2
+            elif dist < channel_width * 2:
+                # 자연제방 (Levee) - 하도보다 약간 높음
+                elevation[r, c] = 11.0
+            elif dist < channel_width * 4:
+                # 배후습지 (Backswamp) - 약간 낮음
+                elevation[r, c] = 9.5
+                
+    # 우각호 (Oxbow Lake)
+    if stage > 0.7:
+        oxbow_y = h // 2
+        for dy in range(-int(wl/4), int(wl/4)):
+            r = oxbow_y + dy
+            if 0 <= r < h:
+                theta = 2 * np.pi * dy / (wl/2)
+                ox_x = center_x + amplitude * 1.3 * np.sin(theta)
+                for dc in range(-channel_width, channel_width + 1):
+                    c = int(ox_x + dc)
+                    if 0 <= c < w:
+                        elevation[r, c] = 4.5
+                        
+    return elevation
+
+
+def create_bird_foot_delta(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """조족상 삼각주 (Bird-foot Delta) - 미시시피강형"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = -5.0  # 바다
+    
+    apex_y = int(h * 0.15)
+    center_x = w // 2
+    
+    # 가늘고 긴 분배수로들
+    num_fingers = 5
+    max_length = int((h - apex_y) * stage)
+    
+    for i in range(num_fingers):
+        angle = np.radians(-30 + 15 * i)  # -30 to +30 degrees
+        
+        for d in range(max_length):
+            r = apex_y + int(d * np.cos(angle))
+            c = center_x + int(d * np.sin(angle))
+            
+            if 0 <= r < h and 0 <= c < w:
+                # 좁은 finger 형태
+                for dc in range(-3, 4):
+                    for dr in range(-2, 3):
+                        nr, nc = r + dr, c + dc
+                        if 0 <= nr < h and 0 <= nc < w:
+                            dist = np.sqrt(dr**2 + dc**2)
+                            z = 8.0 * (1 - d / max_length) * (1 - dist / 4) * stage
+                            elevation[nr, nc] = max(elevation[nr, nc], z)
+                            
+    # 하천
+    for r in range(apex_y):
+        for dc in range(-3, 4):
+            if 0 <= center_x + dc < w:
+                elevation[r, center_x + dc] = 6.0
+                
+    return elevation
+
+
+def create_arcuate_delta(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """호상 삼각주 (Arcuate Delta) - 나일강형"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = -5.0
+    
+    apex_y = int(h * 0.2)
+    center_x = w // 2
+    
+    # 부드러운 호 형태
+    max_reach = int((h - apex_y) * stage)
+    
+    for r in range(apex_y, apex_y + max_reach):
+        dist = r - apex_y
+        # Arc width increases with distance
+        arc_width = int(dist * 0.8)
+        
+        for c in range(max(0, center_x - arc_width), min(w, center_x + arc_width)):
+            dx = abs(c - center_x)
+            radial = np.sqrt(dx**2 + dist**2)
+            
+            # Smooth arc edge
+            edge_dist = arc_width - dx
+            if edge_dist > 0:
+                z = 10.0 * (1 - radial / (max_reach * 1.2)) * min(1, edge_dist / 10)
+                elevation[r, c] = max(elevation[r, c], z * stage)
+                
+    # 하천
+    for r in range(apex_y):
+        for dc in range(-4, 5):
+            if 0 <= center_x + dc < w:
+                elevation[r, center_x + dc] = 6.0
+                
+    return elevation
+
+
+def create_cuspate_delta(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """첨두상 삼각주 (Cuspate Delta) - 티베르강형"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    elevation[:, :] = -5.0
+    
+    apex_y = int(h * 0.2)
+    center_x = w // 2
+    point_y = int(apex_y + (h - apex_y) * 0.8 * stage)
+    
+    # 뾰족한 삼각형 형태
+    for r in range(apex_y, point_y):
+        dist = r - apex_y
+        total_dist = point_y - apex_y
+        
+        # Width narrows toward point
+        width = int((w // 3) * (1 - dist / total_dist))
+        
+        for c in range(max(0, center_x - width), min(w, center_x + width)):
+            dx = abs(c - center_x)
+            z = 10.0 * (1 - dist / total_dist) * (1 - dx / max(width, 1))
+            elevation[r, c] = max(elevation[r, c], z * stage)
+            
+    # 하천
+    for r in range(apex_y):
+        for dc in range(-3, 4):
+            if 0 <= center_x + dc < w:
+                elevation[r, center_x + dc] = 6.0
+                
+    return elevation
+
+
+def create_cirque(grid_size: int = 100, stage: float = 1.0,
+                  depth: float = 50.0) -> np.ndarray:
+    """권곡 (Cirque) - 빙하 시작점"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 산악 배경
+    elevation[:, :] = depth + 30.0
+    
+    # 권곡 위치 (상단 중앙)
+    cirque_y = int(h * 0.3)
+    cirque_x = w // 2
+    cirque_radius = int(w * 0.25 * (0.5 + 0.5 * stage))
+    
+    for r in range(h):
+        for c in range(w):
+            dy = r - cirque_y
+            dx = c - cirque_x
+            dist = np.sqrt(dy**2 + dx**2)
+            
+            if dist < cirque_radius:
+                # 반원형 움푹한 형태
+                # 바닥은 평탄, 후벽(headwall)은 급경사
+                if dy < 0:  # 후벽
+                    z = depth * (1 - dist / cirque_radius) * 0.3
+                else:  # 바닥
+                    z = depth * 0.1
+                elevation[r, c] = z
+                
+    return elevation
+
+
+def create_horn(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """호른 (Horn) - 피라미드형 봉우리"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center = (h // 2, w // 2)
+    peak_height = 100.0 * stage
+    
+    # 4방향 권곡에 의한 호른 형성
+    num_cirques = 4
+    cirque_radius = int(w * 0.3)
+    
+    for r in range(h):
+        for c in range(w):
+            dy = r - center[0]
+            dx = c - center[1]
+            dist = np.sqrt(dy**2 + dx**2)
+            
+            # 기본 피라미드 형태
+            elevation[r, c] = peak_height * max(0, 1 - dist / (w // 2))
+            
+            # 4방향 권곡 파기
+            for i in range(num_cirques):
+                angle = i * np.pi / 2
+                cx = center[1] + int(cirque_radius * 0.8 * np.cos(angle))
+                cy = center[0] + int(cirque_radius * 0.8 * np.sin(angle))
+                
+                cdist = np.sqrt((r - cy)**2 + (c - cx)**2)
+                if cdist < cirque_radius * 0.6:
+                    # 권곡 파기
+                    elevation[r, c] = min(elevation[r, c], 
+                                         20.0 + 30.0 * (cdist / (cirque_radius * 0.6)))
+                    
+    return elevation
+
+
+def create_shield_volcano(grid_size: int = 100, stage: float = 1.0,
+                          max_height: float = 40.0) -> np.ndarray:
+    """순상화산 (Shield Volcano) - 완만한 경사"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center = (h // 2, w // 2)
+    radius = w // 2
+    
+    for r in range(h):
+        for c in range(w):
+            dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+            
+            if dist < radius:
+                # 완만한 포물선 형태 (경사 5-10도)
+                elevation[r, c] = max_height * (1 - (dist / radius)**2) * stage
+                
+    # 정상부 화구
+    crater_radius = int(radius * 0.1)
+    for r in range(h):
+        for c in range(w):
+            dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+            if dist < crater_radius:
+                elevation[r, c] = max_height * 0.9 * stage
+                
+    return elevation
+
+
+def create_stratovolcano(grid_size: int = 100, stage: float = 1.0,
+                         max_height: float = 80.0) -> np.ndarray:
+    """성층화산 (Stratovolcano) - 급한 원뿔형"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center = (h // 2, w // 2)
+    radius = int(w * 0.4)
+    
+    for r in range(h):
+        for c in range(w):
+            dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+            
+            if dist < radius:
+                # 급한 원뿔 (경사 25-35도)
+                elevation[r, c] = max_height * (1 - dist / radius) * stage
+                
+    # 정상부 화구
+    crater_radius = int(radius * 0.08)
+    crater_depth = 10.0
+    for r in range(h):
+        for c in range(w):
+            dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+            if dist < crater_radius:
+                elevation[r, c] = max_height * stage - crater_depth
+                
+    return elevation
+
+
+def create_caldera(grid_size: int = 100, stage: float = 1.0,
+                   rim_height: float = 50.0) -> np.ndarray:
+    """칼데라 (Caldera) - 화구 함몰"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center = (h // 2, w // 2)
+    outer_radius = int(w * 0.45)
+    caldera_radius = int(w * 0.3)
+    
+    for r in range(h):
+        for c in range(w):
+            dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+            
+            if dist < outer_radius:
+                if dist < caldera_radius:
+                    # 칼데라 바닥 (평탄, 호수 가능)
+                    elevation[r, c] = 5.0
+                else:
+                    # 칼데라 벽 (급경사)
+                    t = (dist - caldera_radius) / (outer_radius - caldera_radius)
+                    elevation[r, c] = 5.0 + rim_height * (1 - t) * stage
+                    
+    return elevation
+
+
+def create_mesa_butte(grid_size: int = 100, stage: float = 1.0,
+                      num_mesas: int = 2) -> np.ndarray:
+    """메사/뷰트 (Mesa/Butte) - 탁상지"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 사막 기반
+    elevation[:, :] = 5.0
+    
+    mesa_height = 40.0 * stage
+    
+    # 메사 배치
+    positions = [(h//3, w//3), (h//2, 2*w//3)]
+    sizes = [(w//4, w//5), (w//6, w//6)]  # 메사, 뷰트
+    
+    for i, ((my, mx), (sw, sh)) in enumerate(zip(positions[:num_mesas], sizes[:num_mesas])):
+        for r in range(h):
+            for c in range(w):
+                if abs(r - my) < sh and abs(c - mx) < sw:
+                    # 평탄한 정상부
+                    elevation[r, c] = mesa_height
+                elif abs(r - my) < sh + 3 and abs(c - mx) < sw + 3:
+                    # 급경사 측벽
+                    edge_dist = min(abs(abs(r - my) - sh), abs(abs(c - mx) - sw))
+                    elevation[r, c] = mesa_height * (1 - edge_dist / 3)
+                    
+    return elevation
+
+
+def create_spit_lagoon(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """사취 (Spit) + 석호 (Lagoon)"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 바다 (오른쪽)
+    sea_line = int(w * 0.6)
+    elevation[:, sea_line:] = -5.0
+    
+    # 육지 (왼쪽)
+    elevation[:, :sea_line] = 10.0
+    
+    # 사취 (연안류 방향으로 길게)
+    spit_start = int(h * 0.3)
+    spit_length = int(h * 0.5 * stage)
+    spit_width = 5
+    
+    for r in range(spit_start, min(h, spit_start + spit_length)):
+        # 사취가 바다 쪽으로 휘어짐
+        curve = int((r - spit_start) / spit_length * (w * 0.15))
+        spit_x = sea_line + curve
+        
+        for dc in range(-spit_width, spit_width + 1):
+            c = spit_x + dc
+            if 0 <= c < w:
+                elevation[r, c] = 3.0 * (1 - abs(dc) / spit_width)
+                
+    # 석호 (사취 안쪽)
+    if stage > 0.5:
+        for r in range(spit_start, spit_start + int(spit_length * 0.8)):
+            curve = int((r - spit_start) / spit_length * (w * 0.1))
+            for c in range(sea_line - 5, sea_line + curve):
+                if 0 <= c < w:
+                    if elevation[r, c] < 3.0:
+                        elevation[r, c] = -2.0  # 얕은 석호
+                        
+    return elevation
+
+
+# ============================================
+# 추가 지형 (Additional Landforms)
+# ============================================
+
+def create_fjord(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """피오르드 (Fjord) - 빙하가 파낸 U자곡에 바다 유입"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 산악 지형
+    elevation[:, :] = 80.0
+    
+    center = w // 2
+    valley_width = int(w * 0.2)
+    
+    # U자곡 + 바다 유입
+    sea_line = int(h * 0.7)
+    
+    for r in range(h):
+        for c in range(w):
+            dx = abs(c - center)
+            
+            if dx < valley_width:
+                # U자 바닥
+                if r < sea_line:
+                    elevation[r, c] = 10.0  # 육지 바닥
+                else:
+                    elevation[r, c] = -30.0 * stage  # 바다
+            elif dx < valley_width + 10:
+                # U자 측벽
+                t = (dx - valley_width) / 10
+                base = -30.0 if r >= sea_line else 10.0
+                elevation[r, c] = base + 70.0 * t
+                
+    return elevation
+
+
+def create_drumlin(grid_size: int = 100, stage: float = 1.0,
+                   num_drumlins: int = 5) -> np.ndarray:
+    """드럼린 (Drumlin) - 빙하 방향 타원형 언덕"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    elevation[:, :] = 5.0  # 빙하 퇴적 평원
+    
+    for i in range(num_drumlins):
+        # 드럼린 위치 (빙하 흐름 방향으로 정렬)
+        cy = int(h * 0.2 + (i % 3) * h * 0.25)
+        cx = int(w * 0.2 + (i // 3) * w * 0.3)
+        
+        # 타원형 (빙하 방향으로 길쭉)
+        length = int(w * 0.15 * stage)
+        width = int(w * 0.06 * stage)
+        height = 15.0 * stage
+        
+        for r in range(h):
+            for c in range(w):
+                dy = (r - cy) / max(length, 1)
+                dx = (c - cx) / max(width, 1)
+                dist = np.sqrt(dy**2 + dx**2)
+                
+                if dist < 1.0:
+                    # 뾰족한 빙하 상류, 완만한 하류
+                    asymmetry = 1.0 if dy < 0 else 0.7
+                    z = height * (1 - dist) * asymmetry
+                    elevation[r, c] = max(elevation[r, c], 5.0 + z)
+                    
+    return elevation
+
+
+def create_moraine(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """빙퇴석 (Moraine) - 측퇴석, 종퇴석"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 빙하 계��� 배경
+    elevation[:, :] = 20.0
+    center = w // 2
+    
+    # 빙하 본체 (과거)
+    glacier_width = int(w * 0.3)
+    for r in range(h):
+        for c in range(w):
+            if abs(c - center) < glacier_width:
+                elevation[r, c] = 5.0  # 빙하 바닥
+                
+    # 측퇴석 (Lateral Moraine)
+    moraine_height = 15.0 * stage
+    for r in range(h):
+        for side in [-1, 1]:
+            moraine_c = center + side * glacier_width
+            for dc in range(-5, 6):
+                c = moraine_c + dc
+                if 0 <= c < w:
+                    z = moraine_height * (1 - abs(dc) / 6)
+                    elevation[r, c] = max(elevation[r, c], z)
+                    
+    # 종퇴석 (Terminal Moraine)
+    terminal_r = int(h * 0.8)
+    for r in range(terminal_r - 5, min(h, terminal_r + 5)):
+        for c in range(center - glacier_width, center + glacier_width):
+            if 0 <= c < w:
+                dr = abs(r - terminal_r)
+                z = moraine_height * 1.2 * (1 - dr / 6)
+                elevation[r, c] = max(elevation[r, c], z)
+                
+    return elevation
+
+
+def create_braided_river(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """망상하천 (Braided River) - 여러 수로"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 넓은 하상
+    elevation[:, :] = 10.0
+    
+    center = w // 2
+    river_width = int(w * 0.5)
+    
+    # 넓고 얕은 하상
+    for c in range(center - river_width // 2, center + river_width // 2):
+        if 0 <= c < w:
+            elevation[:, c] = 5.0
+            
+    # 여러 수로와 사주 (모래섬)
+    num_channels = int(3 + 4 * stage)
+    np.random.seed(42)
+    
+    for r in range(h):
+        # 현재 행의 수로 위치
+        for i in range(num_channels):
+            channel_x = center - river_width // 3 + int((i / num_channels) * river_width * 0.7)
+            channel_x += int(10 * np.sin(r / 10 + i))  # 약간 사행
+            
+            for dc in range(-2, 3):
+                c = channel_x + dc
+                if 0 <= c < w:
+                    elevation[r, c] = 3.0
+                    
+    # 사주 (모래섬)
+    for i in range(int(5 * stage)):
+        bar_r = int(h * 0.2 + i * h * 0.15)
+        bar_c = center + int((i - 2) * w * 0.1)
+        
+        for dr in range(-5, 6):
+            for dc in range(-8, 9):
+                r, c = bar_r + dr, bar_c + dc
+                if 0 <= r < h and 0 <= c < w:
+                    dist = np.sqrt((dr/5)**2 + (dc/8)**2)
+                    if dist < 1.0:
+                        elevation[r, c] = max(elevation[r, c], 6.0 * (1 - dist))
+                        
+    return elevation
+
+
+def create_waterfall(grid_size: int = 100, stage: float = 1.0,
+                     drop_height: float = 50.0) -> np.ndarray:
+    """폭포 (Waterfall) - 차별침식"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center = w // 2
+    fall_r = int(h * 0.4)
+    
+    # 상류 (높은 경암층)
+    for r in range(fall_r):
+        for c in range(w):
+            elevation[r, c] = drop_height + 20.0 + (fall_r - r) * 0.5
+            
+    # 폭포 (급경사)
+    for r in range(fall_r, fall_r + 5):
+        for c in range(w):
+            t = (r - fall_r) / 5
+            elevation[r, c] = drop_height * (1 - t) + 20.0
+            
+    # 하류
+    for r in range(fall_r + 5, h):
+        for c in range(w):
+            elevation[r, c] = 20.0 - (r - fall_r - 5) * 0.2
+            
+    # 하천 수로
+    for r in range(h):
+        for dc in range(-4, 5):
+            c = center + dc
+            if 0 <= c < w:
+                elevation[r, c] -= 5.0
+                
+    # 플런지풀 (폭호)
+    pool_r = fall_r + 5
+    for dr in range(-5, 6):
+        for dc in range(-6, 7):
+            r, c = pool_r + dr, center + dc
+            if 0 <= r < h and 0 <= c < w:
+                dist = np.sqrt(dr**2 + dc**2)
+                if dist < 6:
+                    elevation[r, c] = min(elevation[r, c], 10.0)
+                    
+    return elevation
+
+
+def create_karst_doline(grid_size: int = 100, stage: float = 1.0,
+                        num_dolines: int = 5) -> np.ndarray:
+    """돌리네 (Doline/Sinkhole) - 카르스트 지형"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 석회암 대지
+    elevation[:, :] = 30.0
+    
+    np.random.seed(42)
+    for i in range(num_dolines):
+        dy = int(h * 0.2 + np.random.rand() * h * 0.6)
+        dx = int(w * 0.2 + np.random.rand() * w * 0.6)
+        radius = int(w * 0.08 * (0.5 + np.random.rand() * 0.5))
+        depth = 20.0 * stage * (0.5 + np.random.rand() * 0.5)
+        
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - dy)**2 + (c - dx)**2)
+                if dist < radius:
+                    z = depth * (1 - (dist / radius) ** 2)
+                    elevation[r, c] = max(0, elevation[r, c] - z)
+                    
+    return elevation
+
+
+def create_ria_coast(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """리아스식 해안 (Ria Coast) - 침수된 하곡"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 산지 배경
+    elevation[:, :] = 40.0
+    
+    # 여러 개의 V자곡 (침수됨)
+    num_valleys = 4
+    sea_level = int(h * 0.6)
+    
+    for i in range(num_valleys):
+        valley_x = int(w * 0.15 + i * w * 0.2)
+        
+        for r in range(h):
+            for c in range(w):
+                dx = abs(c - valley_x)
+                
+                if dx < 8:
+                    # V자곡
+                    depth = 30.0 * (1 - dx / 8)
+                    elevation[r, c] -= depth
+                    
+    # 해수면 이하 = 바다
+    for r in range(sea_level, h):
+        for c in range(w):
+            if elevation[r, c] < 10:
+                elevation[r, c] = -5.0 * stage  # 침수
+                
+    return elevation
+
+
+def create_tombolo(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """육계사주 (Tombolo) - 육지와 섬을 연결"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 바다
+    elevation[:, :] = -5.0
+    
+    # 본토 (왼쪽)
+    for c in range(int(w * 0.3)):
+        elevation[:, c] = 15.0
+        
+    # 섬 (오른쪽)
+    island_cy = h // 2
+    island_cx = int(w * 0.75)
+    island_radius = int(w * 0.12)
+    
+    for r in range(h):
+        for c in range(w):
+            dist = np.sqrt((r - island_cy)**2 + (c - island_cx)**2)
+            if dist < island_radius:
+                elevation[r, c] = 20.0 * (1 - dist / island_radius / 1.5)
+                
+    # 육계사주 (연결)
+    tombolo_start = int(w * 0.3)
+    tombolo_end = island_cx - island_radius
+    
+    for c in range(tombolo_start, tombolo_end):
+        t = (c - tombolo_start) / (tombolo_end - tombolo_start)
+        width = int(5 * (1 - abs(t - 0.5) * 2) * stage)
+        
+        for dr in range(-width, width + 1):
+            r = island_cy + dr
+            if 0 <= r < h:
+                elevation[r, c] = 3.0 * (1 - abs(dr) / max(width, 1))
+                
+    return elevation
+
+
+def create_sea_arch(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """해식아치 (Sea Arch) - 동굴이 관통"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 바다 (아래)
+    sea_line = int(h * 0.5)
+    elevation[sea_line:, :] = -5.0
+    
+    # 육지 절벽
+    cliff_height = 30.0
+    for r in range(sea_line):
+        elevation[r, :] = cliff_height
+        
+    # 돌출부 (곶)
+    headland_width = int(w * 0.3)
+    headland_cx = w // 2
+    headland_length = int(h * 0.3)
+    
+    for r in range(sea_line, sea_line + headland_length):
+        for c in range(headland_cx - headland_width // 2, headland_cx + headland_width // 2):
+            if 0 <= c < w:
+                elevation[r, c] = cliff_height * (1 - (r - sea_line) / headland_length * 0.3)
+                
+    # 아치 (관통)
+    arch_r = sea_line + int(headland_length * 0.5)
+    arch_width = int(headland_width * 0.4 * stage)
+    
+    for dr in range(-5, 6):
+        for dc in range(-arch_width // 2, arch_width // 2 + 1):
+            r, c = arch_r + dr, headland_cx + dc
+            if 0 <= r < h and 0 <= c < w:
+                if abs(dr) < 3:  # 아치 높이
+                    elevation[r, c] = -5.0  # 관통
+                    
+    return elevation
+
+
+def create_crater_lake(grid_size: int = 100, stage: float = 1.0,
+                       rim_height: float = 50.0) -> np.ndarray:
+    """화구호 (Crater Lake) - 화구에 물이 고임"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    center = (h // 2, w // 2)
+    outer_radius = int(w * 0.4)
+    crater_radius = int(w * 0.25)
+    
+    for r in range(h):
+        for c in range(w):
+            dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+            
+            if dist > outer_radius:
+                elevation[r, c] = 0
+            elif dist > crater_radius:
+                # 외륜산
+                t = (dist - crater_radius) / (outer_radius - crater_radius)
+                elevation[r, c] = rim_height * (1 - t) * stage
+            else:
+                # 호수 (물)
+                elevation[r, c] = -10.0 * stage
+                
+    return elevation
+
+
+def create_lava_plateau(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
+    """용암대지 (Lava Plateau) - 평탄한 용암"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 기반
+    elevation[:, :] = 5.0
+    
+    # 용암대지 영역
+    plateau_height = 30.0 * stage
+    margin = int(w * 0.15)
+    
+    for r in range(margin, h - margin):
+        for c in range(margin, w - margin):
+            # 거의 평탄하지만 약간의 굴곡
+            noise = np.sin(r * 0.2) * np.cos(c * 0.2) * 2.0
+            elevation[r, c] = plateau_height + noise
+            
+    # 가장자리 절벽
+    for r in range(h):
+        for c in range(w):
+            edge_dist = min(r, h - r - 1, c, w - c - 1)
+            if edge_dist < margin:
+                t = edge_dist / margin
+                elevation[r, c] = 5.0 + (elevation[r, c] - 5.0) * t
+                
+    return elevation
+
+
+def create_coastal_dune(grid_size: int = 100, stage: float = 1.0,
+                        num_dunes: int = 3) -> np.ndarray:
+    """해안사구 (Coastal Dune) - 해안가 모래 언덕"""
+    h, w = grid_size, grid_size
+    elevation = np.zeros((h, w))
+    
+    # 바다 (아래)
+    beach_line = int(h * 0.7)
+    elevation[beach_line:, :] = -3.0
+    
+    # 해빈 (해변)
+    for r in range(beach_line - 5, beach_line):
+        elevation[r, :] = 2.0
+        
+    # 해안사구 (해변 뒤)
+    dune_zone_start = int(h * 0.3)
+    dune_zone_end = beach_line - 5
+    
+    for i in range(num_dunes):
+        dune_r = dune_zone_start + i * (dune_zone_end - dune_zone_start) // (num_dunes + 1)
+        dune_height = 15.0 * stage * (1 - i * 0.2)
+        
+        for r in range(h):
+            for c in range(w):
+                dr = abs(r - dune_r)
+                if dr < 10:
+                    # 사구 형태 (바람받이 완만, 바람그늘 급)
+                    if r < dune_r:
+                        z = dune_height * (1 - dr / 12)
+                    else:
+                        z = dune_height * (1 - dr / 8)
+                    elevation[r, c] = max(elevation[r, c], z)
+                    
+    return elevation
+
+
+# 애니메이션 생성기 매핑
+ANIMATED_LANDFORM_GENERATORS = {
+    'delta': create_delta_animated,
+    'alluvial_fan': create_alluvial_fan_animated,
+    'meander': create_meander_animated,
+    'u_valley': create_u_valley_animated,
+    'v_valley': create_v_valley_animated,
+    'barchan': create_barchan_animated,
+    'coastal_cliff': create_coastal_cliff_animated,
+    # 확장
+    'incised_meander': create_incised_meander,
+    'free_meander': create_free_meander,
+    'bird_foot_delta': create_bird_foot_delta,
+    'arcuate_delta': create_arcuate_delta,
+    'cuspate_delta': create_cuspate_delta,
+    'cirque': create_cirque,
+    'horn': create_horn,
+    'shield_volcano': create_shield_volcano,
+    'stratovolcano': create_stratovolcano,
+    'caldera': create_caldera,
+    'mesa_butte': create_mesa_butte,
+    'spit_lagoon': create_spit_lagoon,
+    # 추가 지형
+    'fjord': create_fjord,
+    'drumlin': create_drumlin,
+    'moraine': create_moraine,
+    'braided_river': create_braided_river,
+    'waterfall': create_waterfall,
+    'karst_doline': create_karst_doline,
+    'ria_coast': create_ria_coast,
+    'tombolo': create_tombolo,
+    'sea_arch': create_sea_arch,
+    'crater_lake': create_crater_lake,
+    'lava_plateau': create_lava_plateau,
+    'coastal_dune': create_coastal_dune,
+}
+
+# 지형 생성 함수 매핑
+IDEAL_LANDFORM_GENERATORS = {
+    'delta': create_delta,
+    'alluvial_fan': create_alluvial_fan,
+    'meander': create_meander,
+    'u_valley': create_u_valley,
+    'v_valley': create_v_valley,
+    'barchan': create_barchan_dune,
+    'coastal_cliff': create_coastal_cliff,
+    # 확장 지형
+    'incised_meander': lambda gs: create_incised_meander(gs, 1.0),
+    'free_meander': lambda gs: create_free_meander(gs, 1.0),
+    'bird_foot_delta': lambda gs: create_bird_foot_delta(gs, 1.0),
+    'arcuate_delta': lambda gs: create_arcuate_delta(gs, 1.0),
+    'cuspate_delta': lambda gs: create_cuspate_delta(gs, 1.0),
+    'cirque': lambda gs: create_cirque(gs, 1.0),
+    'horn': lambda gs: create_horn(gs, 1.0),
+    'shield_volcano': lambda gs: create_shield_volcano(gs, 1.0),
+    'stratovolcano': lambda gs: create_stratovolcano(gs, 1.0),
+    'caldera': lambda gs: create_caldera(gs, 1.0),
+    'mesa_butte': lambda gs: create_mesa_butte(gs, 1.0),
+    'spit_lagoon': lambda gs: create_spit_lagoon(gs, 1.0),
+    # 추가 지형
+    'fjord': lambda gs: create_fjord(gs, 1.0),
+    'drumlin': lambda gs: create_drumlin(gs, 1.0),
+    'moraine': lambda gs: create_moraine(gs, 1.0),
+    'braided_river': lambda gs: create_braided_river(gs, 1.0),
+    'waterfall': lambda gs: create_waterfall(gs, 1.0),
+    'karst_doline': lambda gs: create_karst_doline(gs, 1.0),
+    'ria_coast': lambda gs: create_ria_coast(gs, 1.0),
+    'tombolo': lambda gs: create_tombolo(gs, 1.0),
+    'sea_arch': lambda gs: create_sea_arch(gs, 1.0),
+    'crater_lake': lambda gs: create_crater_lake(gs, 1.0),
+    'lava_plateau': lambda gs: create_lava_plateau(gs, 1.0),
+    'coastal_dune': lambda gs: create_coastal_dune(gs, 1.0),
+}
+

engine/lateral_erosion.py

@@ -0,0 +1,199 @@
+"""
+Lateral Erosion Module (측방 침식)
+
+하천의 곡류(Meander) 형성을 위한 측방 침식 프로세스
+- 곡률 외측: 침식 (Cutbank)
+- 곡률 내측: 퇴적 (Point Bar)
+
+핵심 공식:
+E_lateral = k * τ * (1/R)
+- k: 침식 계수
+- τ: 전단응력 (유량 함수)
+- R: 곡률 반경 (작을수록 급회전 → 침식 증가)
+"""
+
+import numpy as np
+from .grid import WorldGrid
+
+
+def compute_flow_curvature(flow_dir: np.ndarray, elevation: np.ndarray) -> np.ndarray:
+    """
+    유향(Flow Direction)으로부터 곡률(Curvature) 계산
+    
+    Args:
+        flow_dir: D8 유향 배열 (0-7, -1 = sink)
+        elevation: 고도 배열
+        
+    Returns:
+        curvature: 곡률 배열 (양수: 좌회전, 음수: 우회전)
+    """
+    h, w = flow_dir.shape
+    curvature = np.zeros((h, w), dtype=np.float64)
+    
+    # D8 방향 벡터 (index 0-7)
+    # 0: NW, 1: N, 2: NE, 3: W, 4: E, 5: SW, 6: S, 7: SE
+    dir_dy = np.array([-1, -1, -1,  0,  0,  1,  1,  1])
+    dir_dx = np.array([-1,  0,  1, -1,  1, -1,  0,  1])
+    
+    # 방향을 각도로 변환 (라디안)
+    # atan2(dy, dx)
+    dir_angles = np.arctan2(dir_dy, dir_dx)
+    
+    for r in range(1, h - 1):
+        for c in range(1, w - 1):
+            current_dir = int(flow_dir[r, c])
+            if current_dir < 0 or current_dir > 7:
+                continue
+                
+            # 상류 방향 찾기 (나를 향해 흐르는 셀)
+            upstream_dirs = []
+            for k in range(8):
+                nr = r + dir_dy[k]
+                nc = c + dir_dx[k]
+                if 0 <= nr < h and 0 <= nc < w:
+                    neighbor_dir = int(flow_dir[nr, nc])
+                    if neighbor_dir >= 0 and neighbor_dir < 8:
+                        # 이웃이 나를 향해 흐르는가?
+                        target_r = nr + dir_dy[neighbor_dir]
+                        target_c = nc + dir_dx[neighbor_dir]
+                        if target_r == r and target_c == c:
+                            upstream_dirs.append(neighbor_dir)
+            
+            if not upstream_dirs:
+                continue
+                
+            # 상류 방향의 평균 각도
+            upstream_angle = np.mean([dir_angles[d] for d in upstream_dirs])
+            current_angle = dir_angles[current_dir]
+            
+            # 각도 변화 = 곡률 (정규화된 값)
+            angle_diff = current_angle - upstream_angle
+            
+            # -π ~ π 범위로 정규화
+            while angle_diff > np.pi:
+                angle_diff -= 2 * np.pi
+            while angle_diff < -np.pi:
+                angle_diff += 2 * np.pi
+                
+            curvature[r, c] = angle_diff
+            
+    return curvature
+
+
+def apply_lateral_erosion(grid: WorldGrid, 
+                          curvature: np.ndarray, 
+                          discharge: np.ndarray,
+                          k: float = 0.01,
+                          dt: float = 1.0) -> np.ndarray:
+    """
+    측방 침식 적용
+    
+    Args:
+        grid: WorldGrid 객체
+        curvature: 곡률 배열 (양수: 좌회전, 음수: 우회전)
+        discharge: 유량 배열
+        k: 침식 계수
+        dt: 시간 간격
+        
+    Returns:
+        change: 지형 변화량 배열
+    """
+    h, w = grid.height, grid.width
+    change = np.zeros((h, w), dtype=np.float64)
+    
+    # D8 방향 벡터
+    dir_dy = np.array([-1, -1, -1,  0,  0,  1,  1,  1])
+    dir_dx = np.array([-1,  0,  1, -1,  1, -1,  0,  1])
+    
+    # 좌/우측 방향 (상대적)
+    # 현재 방향이 k일 때, 좌측은 (k-2)%8, 우측은 (k+2)%8 (대략적 근사)
+    
+    for r in range(1, h - 1):
+        for c in range(1, w - 1):
+            curv = curvature[r, c]
+            Q = discharge[r, c]
+            
+            if abs(curv) < 0.01 or Q < 1.0:
+                continue
+                
+            # 침식량 = k * sqrt(Q) * |curvature| * dt
+            erosion_amount = k * np.sqrt(Q) * abs(curv) * dt
+            
+            # 현재 유향
+            flow_k = int(grid.flow_dir[r, c])
+            if flow_k < 0 or flow_k > 7:
+                continue
+                
+            # 좌/우측 셀 결정
+            if curv > 0:  # 좌회전 → 우측(외측) 침식, 좌측(내측) 퇴적
+                erode_k = (flow_k + 2) % 8  # 우측
+                deposit_k = (flow_k - 2 + 8) % 8  # 좌측
+            else:  # 우회전 → 좌측(외측) 침식, 우측(내측) 퇴적
+                erode_k = (flow_k - 2 + 8) % 8  # 좌측
+                deposit_k = (flow_k + 2) % 8  # 우측
+                
+            # 침식 셀
+            er = r + dir_dy[erode_k]
+            ec = c + dir_dx[erode_k]
+            
+            # 퇴적 셀
+            dr = r + dir_dy[deposit_k]
+            dc = c + dir_dx[deposit_k]
+            
+            # 경계 체크
+            if 0 <= er < h and 0 <= ec < w:
+                change[er, ec] -= erosion_amount
+                
+            if 0 <= dr < h and 0 <= dc < w:
+                change[dr, dc] += erosion_amount * 0.8  # 일부 손실
+                
+    return change
+
+
+class LateralErosionKernel:
+    """
+    측방 침식 커널
+    
+    EarthSystem에 통합하여 사용
+    """
+    
+    def __init__(self, grid: WorldGrid, k: float = 0.01):
+        self.grid = grid
+        self.k = k
+        
+    def step(self, discharge: np.ndarray, dt: float = 1.0) -> np.ndarray:
+        """
+        1단계 측방 침식 실행
+        
+        Args:
+            discharge: 유량 배열
+            dt: 시간 간격
+            
+        Returns:
+            change: 지형 변화량
+        """
+        # 1. 곡률 계산
+        curvature = compute_flow_curvature(self.grid.flow_dir, self.grid.elevation)
+        
+        # 2. 측방 침식 적용
+        change = apply_lateral_erosion(self.grid, curvature, discharge, self.k, dt)
+        
+        # 3. 지형 업데이트
+        # 침식분: bedrock/sediment에서 제거
+        erosion_mask = change < 0
+        erosion_amount = -change[erosion_mask]
+        
+        # 퇴적층 먼저, 부족하면 기반암
+        sed_loss = np.minimum(erosion_amount, self.grid.sediment[erosion_mask])
+        rock_loss = erosion_amount - sed_loss
+        
+        self.grid.sediment[erosion_mask] -= sed_loss
+        self.grid.bedrock[erosion_mask] -= rock_loss
+        
+        # 퇴적분: sediment에 추가
+        self.grid.sediment += np.maximum(change, 0)
+        
+        # 고도 동기화
+        self.grid.update_elevation()
+        
+        return change

engine/mass_movement.py

@@ -0,0 +1,146 @@
+"""
+Mass Movement Kernel (매스무브먼트)
+
+중력에 의한 사면 이동 프로세스
+- 산사태 (Landslide)
+- 슬럼프 (Slump)
+- 낙석 (Rockfall)
+
+핵심 원리:
+경사(Slope) > 임계 경사(Critical Angle) → 물질 이동
+"""
+
+import numpy as np
+from .grid import WorldGrid
+
+
+class MassMovementKernel:
+    """
+    매스무브먼트 커널
+    
+    경사 안정성을 검사하고, 불안정한 곳에서 물질 이동을 시뮬레이션.
+    """
+    
+    def __init__(self, grid: WorldGrid, 
+                 friction_angle: float = 35.0,  # 내부 마찰각 (도)
+                 cohesion: float = 0.0):        # 점착력 (Pa, 간소화)
+        self.grid = grid
+        self.friction_angle = friction_angle
+        self.cohesion = cohesion
+        
+        # 임계 경사 (탄젠트 값)
+        self.critical_slope = np.tan(np.radians(friction_angle))
+        
+    def check_stability(self) -> np.ndarray:
+        """
+        경사 안정성 검사
+        
+        Returns:
+            unstable_mask: 불안정한 셀 마스크 (True = 불안정)
+        """
+        slope, _ = self.grid.get_gradient()
+        
+        # 경사 > 임계 경사 → 불안정
+        unstable = slope > self.critical_slope
+        
+        return unstable
+        
+    def trigger_landslide(self, unstable_mask: np.ndarray, 
+                          efficiency: float = 0.5) -> np.ndarray:
+        """
+        산사태 발생
+        
+        불안정한 셀에서 물질을 낮은 곳으로 이동.
+        
+        Args:
+            unstable_mask: 불안정 마스크
+            efficiency: 이동 효율 (0.0~1.0, 1.0이면 완전 이동)
+            
+        Returns:
+            change: 지형 변화량
+        """
+        h, w = self.grid.height, self.grid.width
+        change = np.zeros((h, w), dtype=np.float64)
+        
+        if not np.any(unstable_mask):
+            return change
+            
+        # D8 방향
+        dr = np.array([-1, -1, -1,  0,  0,  1,  1,  1])
+        dc = np.array([-1,  0,  1, -1,  1, -1,  0,  1])
+        
+        elev = self.grid.elevation
+        slope, _ = self.grid.get_gradient()
+        
+        # 불안정 셀 좌표
+        unstable_coords = np.argwhere(unstable_mask)
+        
+        for r, c in unstable_coords:
+            # 현재 경사 초과분 계산
+            excess_slope = slope[r, c] - self.critical_slope
+            if excess_slope <= 0:
+                continue
+                
+            # 이동량 = 초과 경사에 비례
+            # 퇴적층 먼저 이동, 부족하면 기반암
+            available = self.grid.sediment[r, c] + self.grid.bedrock[r, c] * 0.1
+            move_amount = min(excess_slope * efficiency * 5.0, available)
+            
+            if move_amount <= 0:
+                continue
+                
+            # 가장 낮은 이웃 찾기
+            min_z = elev[r, c]
+            target = None
+            
+            for k in range(8):
+                nr, nc = r + dr[k], c + dc[k]
+                if 0 <= nr < h and 0 <= nc < w:
+                    if elev[nr, nc] < min_z:
+                        min_z = elev[nr, nc]
+                        target = (nr, nc)
+                        
+            if target is None:
+                continue
+                
+            tr, tc = target
+            
+            # 물질 이동
+            change[r, c] -= move_amount
+            change[tr, tc] += move_amount * 0.9  # 일부 손실 (분산)
+            
+        # 지형 업데이트
+        # 손실분: sediment에서 제거
+        loss_mask = change < 0
+        loss = -change[loss_mask]
+        
+        sed_loss = np.minimum(loss, self.grid.sediment[loss_mask])
+        rock_loss = loss - sed_loss
+        
+        self.grid.sediment[loss_mask] -= sed_loss
+        self.grid.bedrock[loss_mask] -= rock_loss
+        
+        # 퇴적분: sediment에 추가
+        self.grid.sediment += np.maximum(change, 0)
+        
+        self.grid.update_elevation()
+        
+        return change
+        
+    def step(self, dt: float = 1.0) -> np.ndarray:
+        """
+        1단계 매스무브먼트 실행
+        
+        Args:
+            dt: 시간 간격 (사용하지 않지만 인터페이스 일관성)
+            
+        Returns:
+            change: 지형 변화량
+        """
+        # 1. 안정성 검사
+        unstable = self.check_stability()
+        
+        # 2. 불안정 지점에서 산사태 발생
+        change = self.trigger_landslide(unstable)
+        
+        return change

engine/meander_physics.py

@@ -0,0 +1,273 @@
+"""
+Geo-Lab AI: 곡류 하천 물리 시뮬레이션
+Helical Flow 기반 측방 침식/퇴적
+"""
+import numpy as np
+from dataclasses import dataclass, field
+from typing import List, Tuple
+
+
+@dataclass
+class MeanderChannel:
+    """곡류 하천 채널 표현
+    
+    1D 중심선 기반으로 채널을 표현하고,
+    각 지점에서의 곡률, 폭, 깊이를 추적
+    """
+    
+    # 채널 중심선 좌표
+    x: np.ndarray = field(default=None)
+    y: np.ndarray = field(default=None)
+    
+    # 각 지점의 속성
+    width: np.ndarray = field(default=None)   # 채널 폭 (m)
+    depth: np.ndarray = field(default=None)   # 채널 깊이 (m)
+    
+    # 유량 및 유속
+    discharge: float = 100.0  # m³/s
+    velocity: np.ndarray = field(default=None)  # m/s
+    
+    def __post_init__(self):
+        if self.x is not None and self.width is None:
+            n = len(self.x)
+            self.width = np.full(n, 20.0)
+            self.depth = np.full(n, 3.0)
+            self.velocity = np.full(n, 1.5)
+    
+    @classmethod
+    def create_initial(cls, length: float = 1000.0, 
+                       initial_sinuosity: float = 1.2,
+                       n_points: int = 200,
+                       discharge: float = 100.0):
+        """초기 곡류 하천 생성"""
+        s = np.linspace(0, 1, n_points)  # 정규화된 거리
+        
+        # 사인파 기반 초기 곡류
+        amplitude = length * 0.1 * (initial_sinuosity - 1)
+        frequency = 3  # 굽이 수
+        
+        x = s * length
+        y = amplitude * np.sin(2 * np.pi * frequency * s)
+        
+        return cls(x=x, y=y, discharge=discharge)
+    
+    def calculate_curvature(self) -> np.ndarray:
+        """곡률 계산 (1/m)
+        κ = (x'y'' - y'x'') / (x'^2 + y'^2)^(3/2)
+        """
+        dx = np.gradient(self.x)
+        dy = np.gradient(self.y)
+        ddx = np.gradient(dx)
+        ddy = np.gradient(dy)
+        
+        denominator = np.power(dx**2 + dy**2, 1.5) + 1e-10
+        curvature = (dx * ddy - dy * ddx) / denominator
+        
+        return curvature
+    
+    def calculate_sinuosity(self) -> float:
+        """굴곡도 = 하천 길이 / 직선 거리"""
+        # 경로 길이
+        ds = np.sqrt(np.diff(self.x)**2 + np.diff(self.y)**2)
+        path_length = np.sum(ds)
+        
+        # 직선 거리
+        straight_length = np.sqrt(
+            (self.x[-1] - self.x[0])**2 + 
+            (self.y[-1] - self.y[0])**2
+        ) + 1e-10
+        
+        return path_length / straight_length
+
+
+class HelicalFlowErosion:
+    """Helical Flow 기반 곡류 침식/퇴적
+    
+    곡류에서 물은 나선형(helical)으로 흐름:
+    - 표면: 바깥쪽으로 (원심력)
+    - 바닥: 안쪽으로 (압력 구배)
+    
+    결과:
+    - 바깥쪽 (공격사면): 침식
+    - 안쪽 (퇴적사면): 퇴적
+    """
+    
+    def __init__(self, 
+                 bank_erosion_rate: float = 0.5,  # m/yr per unit stress
+                 deposition_rate: float = 0.3):
+        self.bank_erosion_rate = bank_erosion_rate
+        self.deposition_rate = deposition_rate
+    
+    def calculate_bank_migration(self, channel: MeanderChannel, 
+                                  dt: float = 1.0) -> Tuple[np.ndarray, np.ndarray]:
+        """하안 이동 계산
+        
+        곡률이 큰 곳에서 바깥쪽으로 침식 → 채널 이동
+        """
+        curvature = channel.calculate_curvature()
+        
+        # 침식/퇴적 비대칭
+        # 곡률 > 0: 좌측이 바깥 (침식)
+        # 곡률 < 0: 우측이 바깥 (침식)
+        
+        # 이동 벡터 (채널에 수직)
+        dx = np.gradient(channel.x)
+        dy = np.gradient(channel.y)
+        path_length = np.sqrt(dx**2 + dy**2) + 1e-10
+        
+        # 수직 방향 (왼쪽으로 90도 회전)
+        normal_x = -dy / path_length
+        normal_y = dx / path_length
+        
+        # 이동량 = 곡률 × 유량 × erosion rate
+        migration_rate = curvature * channel.discharge * self.bank_erosion_rate * dt
+        
+        # 이동량 제한
+        migration_rate = np.clip(migration_rate, -2.0, 2.0)
+        
+        delta_x = migration_rate * normal_x
+        delta_y = migration_rate * normal_y
+        
+        return delta_x, delta_y
+    
+    def check_cutoff(self, channel: MeanderChannel, 
+                     threshold_distance: float = 30.0) -> List[Tuple[int, int]]:
+        """우각호 형성 조건 체크 (유로 절단)"""
+        n = len(channel.x)
+        cutoffs = []
+        
+        # 가까운 두 점 찾기 (경로상 멀리 떨어졌지만 공간적으로 가까운)
+        for i in range(n):
+            for j in range(i + 30, n):  # 최소 30점 간격
+                dist = np.sqrt(
+                    (channel.x[i] - channel.x[j])**2 +
+                    (channel.y[i] - channel.y[j])**2
+                )
+                
+                if dist < threshold_distance:
+                    cutoffs.append((i, j))
+                    break  # 첫 번째 cutoff만
+        
+        return cutoffs
+
+
+class MeanderSimulation:
+    """곡류 하천 시뮬레이션"""
+    
+    def __init__(self, length: float = 1000.0, initial_sinuosity: float = 1.3):
+        self.channel = MeanderChannel.create_initial(
+            length=length,
+            initial_sinuosity=initial_sinuosity
+        )
+        self.erosion = HelicalFlowErosion()
+        
+        self.history: List[Tuple[np.ndarray, np.ndarray]] = []
+        self.oxbow_lakes: List[Tuple[np.ndarray, np.ndarray]] = []
+        self.time = 0.0
+    
+    def step(self, dt: float = 1.0):
+        """1 타임스텝"""
+        # 1. 하안 이동
+        dx, dy = self.erosion.calculate_bank_migration(self.channel, dt)
+        self.channel.x += dx
+        self.channel.y += dy
+        
+        # 2. 우각호 체크
+        cutoffs = self.erosion.check_cutoff(self.channel)
+        for start, end in cutoffs:
+            # 우각호 저장
+            ox = self.channel.x[start:end+1].copy()
+            oy = self.channel.y[start:end+1].copy()
+            self.oxbow_lakes.append((ox, oy))
+            
+            # 채널 단축
+            self.channel.x = np.concatenate([
+                self.channel.x[:start+1],
+                self.channel.x[end:]
+            ])
+            self.channel.y = np.concatenate([
+                self.channel.y[:start+1],
+                self.channel.y[end:]
+            ])
+            
+            # 속성 배열도 조정
+            n_new = len(self.channel.x)
+            self.channel.width = np.full(n_new, 20.0)
+            self.channel.depth = np.full(n_new, 3.0)
+            self.channel.velocity = np.full(n_new, 1.5)
+        
+        self.time += dt
+    
+    def run(self, total_time: float, save_interval: float = 100.0, dt: float = 1.0):
+        """시뮬레이션 실행"""
+        steps = int(total_time / dt)
+        save_every = max(1, int(save_interval / dt))
+        
+        self.history = [(self.channel.x.copy(), self.channel.y.copy())]
+        
+        for i in range(steps):
+            self.step(dt)
+            if (i + 1) % save_every == 0:
+                self.history.append((self.channel.x.copy(), self.channel.y.copy()))
+        
+        return self.history
+    
+    def get_cross_section(self, position: float = 0.5) -> Tuple[np.ndarray, np.ndarray]:
+        """곡류 단면 (비대칭)
+        
+        position: 곡류 내 위치 (0=직선부, 1=최대 굽이)
+        """
+        curvature = self.channel.calculate_curvature()
+        max_curve = np.abs(curvature).max() + 1e-10
+        asymmetry = np.abs(curvature[int(len(curvature) * 0.5)]) / max_curve
+        asymmetry = min(1.0, asymmetry * position * 2)
+        
+        # 단면 생성
+        x = np.linspace(-30, 30, 100)
+        
+        # 비대칭 곡선
+        left_depth = 5 + asymmetry * 3  # 공격사면 (깊음)
+        right_depth = 3 - asymmetry * 1  # 퇴적사면 (얕음)
+        
+        y = np.where(
+            x < 0,
+            -left_depth * (1 - np.power(x / -30, 2)),
+            -right_depth * (1 - np.power(x / 30, 2))
+        )
+        
+        return x, y
+
+
+# 프리컴퓨팅
+def precompute_meander(max_time: int = 10000,
+                       initial_sinuosity: float = 1.3,
+                       save_every: int = 100) -> dict:
+    """곡류 시뮬레이션 프리컴퓨팅"""
+    sim = MeanderSimulation(initial_sinuosity=initial_sinuosity)
+    
+    history = sim.run(
+        total_time=max_time,
+        save_interval=save_every,
+        dt=1.0
+    )
+    
+    return {
+        'history': history,
+        'oxbow_lakes': sim.oxbow_lakes,
+        'final_sinuosity': sim.channel.calculate_sinuosity()
+    }
+
+
+if __name__ == "__main__":
+    print("곡류 하천 물리 시뮬레이션 테스트")
+    print("=" * 50)
+    
+    sim = MeanderSimulation(initial_sinuosity=1.3)
+    print(f"초기 굴곡도: {sim.channel.calculate_sinuosity():.2f}")
+    
+    sim.run(5000, save_interval=1000)
+    print(f"5000년 후 굴곡도: {sim.channel.calculate_sinuosity():.2f}")
+    print(f"형성된 우각호: {len(sim.oxbow_lakes)}개")
+    
+    print("=" * 50)
+    print("테스트 완료!")

engine/physics_engine.py

@@ -0,0 +1,365 @@
+"""
+Geo-Lab AI: 진짜 물리 시뮬레이션 엔진
+Stream Power Law 기반 실제 침식 시뮬레이션
+"""
+import numpy as np
+from dataclasses import dataclass, field
+from typing import List, Tuple, Optional
+from scipy.ndimage import gaussian_filter, uniform_filter
+
+
+@dataclass
+class TerrainGrid:
+    """2D 지형 그리드"""
+    width: int = 100
+    height: int = 100
+    cell_size: float = 10.0  # 미터
+    
+    elevation: np.ndarray = field(default=None)
+    bedrock: np.ndarray = field(default=None)  # 기반암 (침식 불가 레벨)
+    rock_hardness: np.ndarray = field(default=None)  # 0-1
+    
+    def __post_init__(self):
+        if self.elevation is None:
+            self.elevation = np.zeros((self.height, self.width))
+        if self.bedrock is None:
+            self.bedrock = np.full((self.height, self.width), -100.0)
+        if self.rock_hardness is None:
+            self.rock_hardness = np.full((self.height, self.width), 0.5)
+    
+    def get_slope(self) -> np.ndarray:
+        """경사도 계산 (m/m)"""
+        dy, dx = np.gradient(self.elevation, self.cell_size)
+        return np.sqrt(dx**2 + dy**2)
+    
+    def get_slope_direction(self) -> Tuple[np.ndarray, np.ndarray]:
+        """최대 경사 방향 (단위 벡터)"""
+        dy, dx = np.gradient(self.elevation, self.cell_size)
+        magnitude = np.sqrt(dx**2 + dy**2) + 1e-10
+        return -dx / magnitude, -dy / magnitude
+
+
+@dataclass
+class WaterFlow:
+    """수문 시뮬레이션"""
+    terrain: TerrainGrid
+    
+    # 유량 (m³/s per cell)
+    discharge: np.ndarray = field(default=None)
+    # 유속 (m/s)
+    velocity: np.ndarray = field(default=None)
+    # 수심 (m)
+    depth: np.ndarray = field(default=None)
+    # 전단응력 (Pa)
+    shear_stress: np.ndarray = field(default=None)
+    
+    manning_n: float = 0.03  # Manning 조도계수
+    
+    def __post_init__(self):
+        shape = (self.terrain.height, self.terrain.width)
+        if self.discharge is None:
+            self.discharge = np.zeros(shape)
+        if self.velocity is None:
+            self.velocity = np.zeros(shape)
+        if self.depth is None:
+            self.depth = np.zeros(shape)
+        if self.shear_stress is None:
+            self.shear_stress = np.zeros(shape)
+    
+    def flow_accumulation_d8(self, precipitation: float = 0.001):
+        """D8 알고리즘 기반 유량 누적"""
+        h, w = self.terrain.height, self.terrain.width
+        elev = self.terrain.elevation
+        
+        # 초기 강수
+        acc = np.full((h, w), precipitation)
+        
+        # 높은 곳에서 낮은 곳으로 정렬
+        flat_elev = elev.ravel()
+        sorted_indices = np.argsort(flat_elev)[::-1]
+        
+        # D8 방향 (8방향 이웃)
+        neighbors = [(-1,-1), (-1,0), (-1,1), (0,-1), (0,1), (1,-1), (1,0), (1,1)]
+        
+        for idx in sorted_indices:
+            y, x = idx // w, idx % w
+            current_elev = elev[y, x]
+            
+            # 가장 낮은 이웃 찾기
+            min_elev = current_elev
+            min_neighbor = None
+            
+            for dy, dx in neighbors:
+                ny, nx = y + dy, x + dx
+                if 0 <= ny < h and 0 <= nx < w:
+                    if elev[ny, nx] < min_elev:
+                        min_elev = elev[ny, nx]
+                        min_neighbor = (ny, nx)
+            
+            # 하류로 유량 전달
+            if min_neighbor is not None:
+                acc[min_neighbor] += acc[y, x]
+        
+        self.discharge = acc
+        return acc
+    
+    def calculate_hydraulics(self):
+        """Manning 방정식 기반 수리학 계산"""
+        slope = self.terrain.get_slope() + 0.0001  # 0 방지
+        
+        # 가정: 채널 폭 = 유량의 함수
+        channel_width = 2 * np.power(self.discharge + 0.01, 0.4)
+        
+        # Manning 방정식: V = (1/n) * R^(2/3) * S^(1/2)
+        # 단순화: R ≈ depth
+        # Q = V * A, A = width * depth
+        # depth = (Q * n / (width * S^0.5))^(3/5)
+        
+        self.depth = np.power(
+            self.discharge * self.manning_n / (channel_width * np.sqrt(slope) + 0.01),
+            0.6
+        )
+        self.depth = np.clip(self.depth, 0, 50)
+        
+        # 유속
+        hydraulic_radius = self.depth  # 단순화
+        self.velocity = (1 / self.manning_n) * np.power(hydraulic_radius, 2/3) * np.sqrt(slope)
+        self.velocity = np.clip(self.velocity, 0, 10)
+        
+        # 전단응력 τ = ρgRS
+        rho_water = 1000  # kg/m³
+        g = 9.81
+        self.shear_stress = rho_water * g * self.depth * slope
+
+
+class StreamPowerErosion:
+    """Stream Power Law 기반 침식
+    
+    E = K * A^m * S^n
+    - E: 침식률 (m/yr)
+    - K: 침식 계수 (암석 특성 반영)
+    - A: 유역 면적 (≈ 유량)
+    - S: 경사
+    - m: 면적 지수 (typically 0.3-0.6)
+    - n: 경사 지수 (typically 1.0-2.0)
+    """
+    
+    def __init__(self, K: float = 1e-5, m: float = 0.5, n: float = 1.0):
+        self.K = K
+        self.m = m
+        self.n = n
+    
+    def calculate_erosion(self, terrain: TerrainGrid, water: WaterFlow, dt: float = 1.0) -> np.ndarray:
+        """침식량 계산"""
+        slope = terrain.get_slope()
+        
+        # Stream Power Law
+        # K는 암석 경도에 반비례
+        effective_K = self.K * (1 - terrain.rock_hardness * 0.9)
+        
+        erosion_rate = effective_K * np.power(water.discharge, self.m) * np.power(slope + 0.001, self.n)
+        
+        erosion = erosion_rate * dt
+        
+        # 기반암 이하로 침식 불가
+        max_erosion = terrain.elevation - terrain.bedrock
+        erosion = np.minimum(erosion, np.maximum(max_erosion, 0))
+        
+        return np.clip(erosion, 0, 5.0)  # 연간 최대 5m
+
+
+class HillslopeProcess:
+    """사면 프로세스 (Mass Wasting)
+    
+    V자곡 형성의 핵심 - 하방 침식 후 사면 붕괴
+    """
+    
+    def __init__(self, critical_slope: float = 0.7, diffusion_rate: float = 0.01):
+        self.critical_slope = critical_slope  # 임계 경사 (tan θ)
+        self.diffusion_rate = diffusion_rate  # 확산 계수
+    
+    def mass_wasting(self, terrain: TerrainGrid, dt: float = 1.0) -> np.ndarray:
+        """사면 붕괴 (급경사 → 물질 이동)"""
+        h, w = terrain.height, terrain.width
+        change = np.zeros((h, w))
+        
+        elev = terrain.elevation
+        slope = terrain.get_slope()
+        
+        # 임계 경사 초과 지점
+        unstable = slope > self.critical_slope
+        
+        # 불안정 지점에서 이웃으로 물질 분배
+        for y in range(1, h-1):
+            for x in range(1, w-1):
+                if not unstable[y, x]:
+                    continue
+                
+                current = elev[y, x]
+                excess = (slope[y, x] - self.critical_slope) * terrain.cell_size
+                
+                # 8방향 이웃 중 낮은 곳으로 분배
+                neighbors = [(y-1,x), (y+1,x), (y,x-1), (y,x+1)]
+                lower_neighbors = [(ny, nx) for ny, nx in neighbors 
+                                   if elev[ny, nx] < current]
+                
+                if lower_neighbors:
+                    transfer = excess * 0.2 * dt  # 전달량
+                    change[y, x] -= transfer
+                    per_neighbor = transfer / len(lower_neighbors)
+                    for ny, nx in lower_neighbors:
+                        change[ny, nx] += per_neighbor
+        
+        return change
+    
+    def soil_creep(self, terrain: TerrainGrid, dt: float = 1.0) -> np.ndarray:
+        """토양 크리프 (느린 확산)"""
+        # 라플라시안 확산
+        laplacian = (
+            np.roll(terrain.elevation, 1, axis=0) +
+            np.roll(terrain.elevation, -1, axis=0) +
+            np.roll(terrain.elevation, 1, axis=1) +
+            np.roll(terrain.elevation, -1, axis=1) -
+            4 * terrain.elevation
+        )
+        
+        return self.diffusion_rate * laplacian * dt
+
+
+class VValleySimulation:
+    """V자곡 시뮬레이션 - 실제 물리 기반
+    
+    프로세스:
+    1. 강수 → 유출 (D8 flow accumulation)
+    2. Stream Power Law 침식
+    3. 사면 붕괴 (Mass Wasting)
+    4. 토양 크리프
+    """
+    
+    def __init__(self, width: int = 100, height: int = 100):
+        self.terrain = TerrainGrid(width=width, height=height)
+        self.water = WaterFlow(terrain=self.terrain)
+        self.erosion = StreamPowerErosion()
+        self.hillslope = HillslopeProcess()
+        
+        self.history: List[np.ndarray] = []
+        self.time = 0.0
+    
+    def initialize_terrain(self, max_elevation: float = 500.0, 
+                           initial_channel_depth: float = 10.0,
+                           rock_hardness: float = 0.5):
+        """초기 지형 설정"""
+        h, w = self.terrain.height, self.terrain.width
+        
+        # 북→남 경사
+        for y in range(h):
+            base = max_elevation * (1 - y / h)
+            self.terrain.elevation[y, :] = base
+        
+        # 중앙에 초기 하천 채널
+        center = w // 2
+        for x in range(center - 3, center + 4):
+            if 0 <= x < w:
+                depth = initial_channel_depth * (1 - abs(x - center) / 4)
+                self.terrain.elevation[:, x] -= depth
+        
+        # 암석 경도
+        self.terrain.rock_hardness[:] = rock_hardness
+        
+        # 기반암
+        self.terrain.bedrock[:] = self.terrain.elevation.min() - 200
+        
+        self.history = [self.terrain.elevation.copy()]
+        self.time = 0.0
+    
+    def step(self, dt: float = 1.0, precipitation: float = 0.001):
+        """1 타임스텝 진행"""
+        # 1. 수문 계산
+        self.water.flow_accumulation_d8(precipitation)
+        self.water.calculate_hydraulics()
+        
+        # 2. Stream Power 침식
+        erosion = self.erosion.calculate_erosion(self.terrain, self.water, dt)
+        self.terrain.elevation -= erosion
+        
+        # 3. 사면 붕괴
+        wasting = self.hillslope.mass_wasting(self.terrain, dt)
+        self.terrain.elevation += wasting
+        
+        # 4. 토양 크리프
+        creep = self.hillslope.soil_creep(self.terrain, dt)
+        self.terrain.elevation += creep
+        
+        self.time += dt
+    
+    def run(self, total_time: float, save_interval: float = 100.0, dt: float = 1.0):
+        """시뮬레이션 실행 및 히스토리 저장"""
+        steps = int(total_time / dt)
+        save_every = int(save_interval / dt)
+        
+        for i in range(steps):
+            self.step(dt)
+            if (i + 1) % save_every == 0:
+                self.history.append(self.terrain.elevation.copy())
+        
+        return self.history
+    
+    def get_cross_section(self, y_position: int = None) -> Tuple[np.ndarray, np.ndarray]:
+        """단면 추출"""
+        if y_position is None:
+            y_position = self.terrain.height // 2
+        
+        x = np.arange(self.terrain.width) * self.terrain.cell_size
+        z = self.terrain.elevation[y_position, :]
+        
+        return x, z
+    
+    def measure_valley_depth(self) -> float:
+        """V자곡 깊이 측정"""
+        center = self.terrain.width // 2
+        y_mid = self.terrain.height // 2
+        
+        # 중앙과 양쪽 20셀 떨어진 곳의 고도 차이
+        left = self.terrain.elevation[y_mid, max(0, center-20)]
+        right = self.terrain.elevation[y_mid, min(self.terrain.width-1, center+20)]
+        center_elev = self.terrain.elevation[y_mid, center]
+        
+        return max(0, (left + right) / 2 - center_elev)
+
+
+# 프리컴퓨팅 함수
+def precompute_v_valley(max_time: int = 10000, 
+                        rock_hardness: float = 0.5,
+                        K: float = 1e-5,
+                        precipitation: float = 0.001,
+                        save_every: int = 100) -> List[np.ndarray]:
+    """V자곡 시뮬레이션 프리컴퓨팅"""
+    sim = VValleySimulation(width=100, height=100)
+    sim.erosion.K = K
+    sim.initialize_terrain(rock_hardness=rock_hardness)
+    
+    history = sim.run(
+        total_time=max_time,
+        save_interval=save_every,
+        dt=1.0
+    )
+    
+    return history
+
+
+if __name__ == "__main__":
+    print("V자곡 물리 시뮬레이션 테스트")
+    print("=" * 50)
+    
+    sim = VValleySimulation()
+    sim.initialize_terrain(rock_hardness=0.3)
+    
+    print(f"초기 상태: 깊이 = {sim.measure_valley_depth():.1f}m")
+    
+    for year in [1000, 2000, 5000, 10000]:
+        sim.run(1000, save_interval=1000)
+        depth = sim.measure_valley_depth()
+        print(f"Year {year}: 깊이 = {depth:.1f}m")
+    
+    print("=" * 50)
+    print("테스트 완료!")

engine/precompute.py

@@ -0,0 +1,245 @@
+"""
+Geo-Lab AI: 프리컴퓨팅 + 캐싱 시스템
+시뮬레이션을 미리 돌려놓고 슬라이더로 탐색
+"""
+import numpy as np
+import pickle
+import hashlib
+import os
+from pathlib import Path
+from typing import Dict, Any, Optional, Callable
+import threading
+from concurrent.futures import ThreadPoolExecutor
+
+
+class PrecomputeCache:
+    """프리컴퓨팅 결과 캐시"""
+    
+    def __init__(self, cache_dir: str = None):
+        if cache_dir is None:
+            cache_dir = Path(__file__).parent.parent / "cache"
+        self.cache_dir = Path(cache_dir)
+        self.cache_dir.mkdir(exist_ok=True)
+        
+        # 메모리 캐시
+        self.memory_cache: Dict[str, Any] = {}
+    
+    def _get_key(self, sim_type: str, params: dict) -> str:
+        """파라미터 기반 캐시 키 생성"""
+        param_str = f"{sim_type}_{sorted(params.items())}"
+        return hashlib.md5(param_str.encode()).hexdigest()[:16]
+    
+    def get(self, sim_type: str, params: dict) -> Optional[Any]:
+        """캐시에서 조회"""
+        key = self._get_key(sim_type, params)
+        
+        # 메모리 캐시 확인
+        if key in self.memory_cache:
+            return self.memory_cache[key]
+        
+        # 디스크 캐시 확인
+        cache_file = self.cache_dir / f"{key}.pkl"
+        if cache_file.exists():
+            try:
+                with open(cache_file, 'rb') as f:
+                    data = pickle.load(f)
+                self.memory_cache[key] = data
+                return data
+            except:
+                pass
+        
+        return None
+    
+    def set(self, sim_type: str, params: dict, data: Any):
+        """캐시에 저장"""
+        key = self._get_key(sim_type, params)
+        
+        # 메모리 캐시
+        self.memory_cache[key] = data
+        
+        # 디스크 캐시
+        cache_file = self.cache_dir / f"{key}.pkl"
+        try:
+            with open(cache_file, 'wb') as f:
+                pickle.dump(data, f)
+        except:
+            pass
+    
+    def get_or_compute(self, sim_type: str, params: dict, 
+                       compute_fn: Callable, force_recompute: bool = False) -> Any:
+        """캐시 또는 계산"""
+        if not force_recompute:
+            cached = self.get(sim_type, params)
+            if cached is not None:
+                return cached
+        
+        # 계산
+        result = compute_fn()
+        self.set(sim_type, params, result)
+        return result
+
+
+class SimulationManager:
+    """시뮬레이션 매니저
+    
+    파라미터별 시뮬레이션을 백그라운드에서 프리컴퓨팅하고
+    UI에서는 캐시된 결과를 조회
+    """
+    
+    def __init__(self):
+        self.cache = PrecomputeCache()
+        self.executor = ThreadPoolExecutor(max_workers=2)
+        self.computing: Dict[str, bool] = {}
+    
+    def get_v_valley(self, rock_hardness: float = 0.5, 
+                     K: float = 1e-5,
+                     max_time: int = 10000) -> Dict:
+        """V자곡 시뮬레이션 결과"""
+        from engine.physics_engine import VValleySimulation
+        
+        # 파라미터 양자화 (캐시 효율)
+        rock_hardness = round(rock_hardness, 1)
+        K = round(K, 6)
+        
+        params = {
+            'rock_hardness': rock_hardness,
+            'K': K,
+            'max_time': max_time
+        }
+        
+        def compute():
+            sim = VValleySimulation(width=100, height=100)
+            sim.erosion.K = K
+            sim.initialize_terrain(rock_hardness=rock_hardness)
+            history = sim.run(max_time, save_interval=max_time // 100)
+            
+            # 각 스냅샷의 단면과 깊이 저장
+            cross_sections = []
+            depths = []
+            for elev in history:
+                temp_sim = VValleySimulation()
+                temp_sim.terrain.elevation = elev
+                x, z = temp_sim.get_cross_section()
+                depth = temp_sim.measure_valley_depth()
+                cross_sections.append((x, z))
+                depths.append(depth)
+            
+            return {
+                'history': history,
+                'cross_sections': cross_sections,
+                'depths': depths,
+                'n_frames': len(history)
+            }
+        
+        return self.cache.get_or_compute('v_valley', params, compute)
+    
+    def get_meander(self, initial_sinuosity: float = 1.3,
+                    max_time: int = 10000) -> Dict:
+        """곡류 시뮬레이션 결과"""
+        from engine.meander_physics import MeanderSimulation
+        
+        initial_sinuosity = round(initial_sinuosity, 1)
+        
+        params = {
+            'initial_sinuosity': initial_sinuosity,
+            'max_time': max_time
+        }
+        
+        def compute():
+            sim = MeanderSimulation(initial_sinuosity=initial_sinuosity)
+            history = sim.run(max_time, save_interval=max_time // 100)
+            
+            # 굴곡도 히스토리
+            sinuosities = []
+            for x, y in history:
+                temp_channel = type(sim.channel)(x=x, y=y)
+                sinuosities.append(temp_channel.calculate_sinuosity())
+            
+            return {
+                'history': history,
+                'oxbow_lakes': sim.oxbow_lakes,
+                'sinuosities': sinuosities,
+                'n_frames': len(history)
+            }
+        
+        return self.cache.get_or_compute('meander', params, compute)
+    
+    def get_delta(self, river_energy: float = 60,
+                  wave_energy: float = 25,
+                  tidal_energy: float = 15,
+                  max_time: int = 10000) -> Dict:
+        """삼각주 시뮬레이션 결과"""
+        from engine.delta_physics import DeltaSimulation
+        
+        # 정규화
+        total = river_energy + wave_energy + tidal_energy + 0.01
+        river_energy = round(river_energy / total, 2)
+        wave_energy = round(wave_energy / total, 2)
+        tidal_energy = round(tidal_energy / total, 2)
+        
+        params = {
+            'river_energy': river_energy,
+            'wave_energy': wave_energy,
+            'tidal_energy': tidal_energy,
+            'max_time': max_time
+        }
+        
+        def compute():
+            sim = DeltaSimulation()
+            sim.set_energy_balance(river_energy, wave_energy, tidal_energy)
+            history = sim.run(max_time, save_interval=max_time // 100)
+            
+            return {
+                'history': history,
+                'delta_type': sim.get_delta_type().value,
+                'delta_area': sim.get_delta_area(),
+                'n_frames': len(history)
+            }
+        
+        return self.cache.get_or_compute('delta', params, compute)
+    
+    def precompute_common_scenarios(self):
+        """자주 사용되는 시나리오 미리 계산"""
+        scenarios = [
+            # V자곡
+            {'type': 'v_valley', 'rock_hardness': 0.3, 'K': 1e-5},
+            {'type': 'v_valley', 'rock_hardness': 0.5, 'K': 1e-5},
+            {'type': 'v_valley', 'rock_hardness': 0.7, 'K': 1e-5},
+            # 곡류
+            {'type': 'meander', 'initial_sinuosity': 1.2},
+            {'type': 'meander', 'initial_sinuosity': 1.5},
+            # 삼각주
+            {'type': 'delta', 'river': 0.7, 'wave': 0.2, 'tidal': 0.1},
+            {'type': 'delta', 'river': 0.3, 'wave': 0.5, 'tidal': 0.2},
+            {'type': 'delta', 'river': 0.2, 'wave': 0.2, 'tidal': 0.6},
+        ]
+        
+        for scenario in scenarios:
+            if scenario['type'] == 'v_valley':
+                self.executor.submit(
+                    self.get_v_valley,
+                    rock_hardness=scenario['rock_hardness'],
+                    K=scenario['K']
+                )
+            elif scenario['type'] == 'meander':
+                self.executor.submit(
+                    self.get_meander,
+                    initial_sinuosity=scenario['initial_sinuosity']
+                )
+            elif scenario['type'] == 'delta':
+                self.executor.submit(
+                    self.get_delta,
+                    river_energy=scenario['river'],
+                    wave_energy=scenario['wave'],
+                    tidal_energy=scenario['tidal']
+                )
+
+
+# 글로벌 인스턴스
+_manager = None
+
+def get_simulation_manager() -> SimulationManager:
+    global _manager
+    if _manager is None:
+        _manager = SimulationManager()
+    return _manager

engine/pyvista_render.py

@@ -0,0 +1,254 @@
+"""
+PyVista 기반 고품질 3D 지형 렌더링
+- 진짜 3D 렌더링
+- 텍스처 매핑
+- 조명, 그림자 효과
+"""
+import numpy as np
+
+try:
+    import pyvista as pv
+    PYVISTA_AVAILABLE = True
+except ImportError:
+    PYVISTA_AVAILABLE = False
+
+
+def create_terrain_mesh(elevation: np.ndarray, x_scale: float = 1.0, y_scale: float = 1.0, z_scale: float = 1.0):
+    """고도 배열을 PyVista 메시로 변환"""
+    if not PYVISTA_AVAILABLE:
+        raise ImportError("PyVista is not installed")
+    
+    h, w = elevation.shape
+    x = np.arange(w) * x_scale
+    y = np.arange(h) * y_scale
+    X, Y = np.meshgrid(x, y)
+    Z = elevation * z_scale
+    
+    grid = pv.StructuredGrid(X, Y, Z)
+    grid["elevation"] = Z.flatten(order="F")
+    
+    return grid
+
+
+def create_interactive_plotter(elevation: np.ndarray, title: str = "지형",
+                               x_scale: float = 1.0, y_scale: float = 1.0, z_scale: float = 1.0):
+    """인터랙티브 회전 가능한 PyVista 플로터 생성 (stpyvista용)"""
+    if not PYVISTA_AVAILABLE:
+        return None
+    
+    mesh = create_terrain_mesh(elevation, x_scale, y_scale, z_scale)
+    
+    plotter = pv.Plotter(window_size=[800, 600])
+    plotter.set_background("#1a1a2e")
+    
+    # 단일 색상 (copper)
+    plotter.add_mesh(
+        mesh,
+        scalars="elevation",
+        cmap="copper",
+        lighting=True,
+        smooth_shading=True,
+        show_scalar_bar=True,
+        scalar_bar_args={
+            "title": "고도 (m)",
+            "color": "white"
+        },
+        specular=0.3,
+        specular_power=15
+    )
+    
+    # 조명
+    plotter.remove_all_lights()
+    plotter.add_light(pv.Light(position=(1000, 1000, 2000), intensity=1.2))
+    plotter.add_light(pv.Light(position=(-500, -500, 1000), intensity=0.5))
+    
+    plotter.add_text(title, font_size=14, position="upper_left", color="white")
+    
+    return plotter
+
+
+def render_v_valley_pyvista(elevation: np.ndarray, depth: float):
+    """V자곡 PyVista 렌더링 - 단일 색상 명도 변화"""
+    if not PYVISTA_AVAILABLE:
+        return None
+    
+    # 메시 생성 (수직 과장 2배)
+    mesh = create_terrain_mesh(elevation, x_scale=12.5, y_scale=12.5, z_scale=2.0)
+    
+    # 플로터 설정
+    plotter = pv.Plotter(off_screen=True, window_size=[1200, 900])
+    plotter.set_background("#1a1a2e")  # 어두운 배경
+    
+    # 단일 색상 (갈색 계열 - copper) 명도 변화
+    plotter.add_mesh(
+        mesh,
+        scalars="elevation",
+        cmap="copper",  # 갈색 단일 색상 명도 변화
+        lighting=True,
+        smooth_shading=True,
+        show_scalar_bar=True,
+        scalar_bar_args={
+            "title": "고도 (m)", 
+            "vertical": True,
+            "title_font_size": 14,
+            "label_font_size": 12
+        },
+        specular=0.3,
+        specular_power=15
+    )
+    
+    # 하천 (더 진한 색상)
+    water_level = elevation.min() + 3
+    h, w = elevation.shape
+    x_water = np.arange(w) * 12.5
+    y_water = np.arange(h) * 12.5
+    X_w, Y_w = np.meshgrid(x_water, y_water)
+    Z_w = np.full_like(elevation, water_level, dtype=float)
+    water_mask = elevation < water_level
+    Z_w[~water_mask] = np.nan
+    
+    if np.any(water_mask):
+        water_grid = pv.StructuredGrid(X_w, Y_w, Z_w)
+        plotter.add_mesh(water_grid, color="#2C3E50", opacity=0.9)  # 어두운 물
+    
+    # 드라마틱한 카메라 각도
+    plotter.camera_position = [
+        (w * 12.5 * 1.5, h * 12.5 * 0.2, elevation.max() * 3),
+        (w * 12.5 * 0.5, h * 12.5 * 0.5, elevation.min()),
+        (0, 0, 1)
+    ]
+    
+    # 강한 조명 (그림자 효과)
+    plotter.remove_all_lights()
+    key_light = pv.Light(position=(w*12.5*3, 0, elevation.max()*5), intensity=1.2)
+    fill_light = pv.Light(position=(-w*12.5, h*12.5*2, elevation.max()*2), intensity=0.4)
+    plotter.add_light(key_light)
+    plotter.add_light(fill_light)
+    
+    plotter.add_text(f"V자곡 | 깊이: {depth:.0f}m", font_size=16, 
+                     position="upper_left", color="white")
+    
+    img = plotter.screenshot(return_img=True)
+    plotter.close()
+    
+    return img
+
+
+def render_delta_pyvista(elevation: np.ndarray, delta_type: str, area: float):
+    """삼각주 PyVista 렌더링 - 단일 색상"""
+    if not PYVISTA_AVAILABLE:
+        return None
+    
+    # 메시 생성 (수직 과장)
+    mesh = create_terrain_mesh(elevation, x_scale=50, y_scale=50, z_scale=10.0)
+    
+    plotter = pv.Plotter(off_screen=True, window_size=[1200, 900])
+    plotter.set_background("#0f0f23")  # 어두운 배경
+    
+    # 단일 색상 (bone - 베이지/갈색 명도 변화)
+    plotter.add_mesh(
+        mesh,
+        scalars="elevation",
+        cmap="bone",  # 베이지 단일 색상 명도 변화
+        lighting=True,
+        smooth_shading=True,
+        clim=[elevation.min(), elevation.max()],
+        show_scalar_bar=True,
+        scalar_bar_args={
+            "title": "고도 (m)",
+            "title_font_size": 14,
+            "label_font_size": 12
+        },
+        specular=0.2,
+        specular_power=10
+    )
+    
+    # 해수면 (진한 색상)
+    h, w = elevation.shape
+    x = np.arange(w) * 50
+    y = np.arange(h) * 50
+    X, Y = np.meshgrid(x, y)
+    Z_sea = np.zeros_like(elevation, dtype=float)
+    sea_mask = elevation < 0
+    Z_sea[~sea_mask] = np.nan
+    
+    if np.any(sea_mask):
+        sea_grid = pv.StructuredGrid(X, Y, Z_sea)
+        plotter.add_mesh(sea_grid, color="#1a3a5f", opacity=0.85)
+    
+    # 카메라
+    plotter.camera_position = [
+        (w * 50 * 0.5, -h * 50 * 0.5, elevation.max() * 50),
+        (w * 50 * 0.5, h * 50 * 0.5, 0),
+        (0, 0, 1)
+    ]
+    
+    # 조명
+    plotter.remove_all_lights()
+    plotter.add_light(pv.Light(position=(w*50*2, -h*50, 1000), intensity=1.3))
+    plotter.add_light(pv.Light(position=(-w*50, h*50*2, 500), intensity=0.5))
+    
+    plotter.add_text(f"{delta_type} | 면적: {area:.2f} km²", font_size=16, 
+                     position="upper_left", color="white")
+    
+    img = plotter.screenshot(return_img=True)
+    plotter.close()
+    
+    return img
+
+
+def render_meander_pyvista(x: np.ndarray, y: np.ndarray, sinuosity: float, oxbow_lakes: list):
+    """곡류 하천 PyVista 렌더링 (2.5D)"""
+    if not PYVISTA_AVAILABLE:
+        return None
+    
+    plotter = pv.Plotter(off_screen=True, window_size=[1400, 600])
+    
+    # 범람원 (평면)
+    floodplain = pv.Plane(
+        center=(x.mean(), y.mean(), -1),
+        direction=(0, 0, 1),
+        i_size=x.max() - x.min() + 200,
+        j_size=max(200, (y.max() - y.min()) * 3)
+    )
+    plotter.add_mesh(floodplain, color="#8FBC8F", opacity=0.8)
+    
+    # 하천 (튜브)
+    points = np.column_stack([x, y, np.zeros_like(x)])
+    spline = pv.Spline(points, 500)
+    tube = spline.tube(radius=8)
+    plotter.add_mesh(tube, color="#4169E1", smooth_shading=True)
+    
+    # 우각호
+    for lake_x, lake_y in oxbow_lakes:
+        if len(lake_x) > 3:
+            lake_points = np.column_stack([lake_x, lake_y, np.full_like(lake_x, -0.5)])
+            lake_spline = pv.Spline(lake_points, 100)
+            lake_tube = lake_spline.tube(radius=6)
+            plotter.add_mesh(lake_tube, color="#87CEEB", opacity=0.8)
+    
+    # 카메라 (위에서 약간 기울어진 시점)
+    plotter.camera_position = [
+        (x.mean(), y.mean() - 300, 400),
+        (x.mean(), y.mean(), 0),
+        (0, 0, 1)
+    ]
+    
+    # 조명
+    plotter.add_light(pv.Light(position=(x.mean(), y.mean(), 500), intensity=1.0))
+    
+    plotter.add_text(f"곡류 하천 (굴곡도: {sinuosity:.2f})", font_size=14, position="upper_left")
+    
+    img = plotter.screenshot(return_img=True)
+    plotter.close()
+    
+    return img
+
+
+def save_pyvista_image(img: np.ndarray, filepath: str):
+    """PyVista 렌더링 이미지 저장"""
+    from PIL import Image
+    if img is not None:
+        Image.fromarray(img).save(filepath)
+        return True
+    return False

engine/river/__init__.py

@@ -0,0 +1 @@
+# River Submodule

engine/river/delta.py

@@ -0,0 +1,251 @@
+"""
+Geo-Lab AI: 삼각주 시뮬레이션
+하류에서 3가지 에너지 균형에 따른 삼각주 형태 형성
+"""
+import numpy as np
+from dataclasses import dataclass, field
+from typing import List, Tuple
+from enum import Enum
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from engine.base import Terrain, Water
+from engine.deposition import delta_deposition, apply_deposition
+
+
+class DeltaType(Enum):
+    """삼각주 분류 (Galloway's Classification)"""
+    RIVER_DOMINATED = "조족상 (Bird's Foot)"  # 미시시피형
+    WAVE_DOMINATED = "원호상 (Arcuate)"       # 나일형
+    TIDE_DOMINATED = "첨각상 (Cuspate)"       # 티베르형
+
+
+@dataclass
+class DeltaSimulator:
+    """삼각주 시뮬레이션
+    
+    핵심 원리:
+    하천 에너지 vs 파랑 에너지 vs 조류 에너지의 균형
+    
+    결과:
+    - 하천 우세: 길게 뻗은 조족상 (미시시피강)
+    - 파랑 우세: 넓게 퍼진 원호상 (나일강)
+    - 조류 우세: 뾰족한 첨각상 (티베르강)
+    """
+    
+    # 지형 크기
+    width: int = 120
+    height: int = 100
+    
+    # 에너지 파라미터 (0-100)
+    river_energy: float = 50.0
+    wave_energy: float = 30.0
+    tidal_energy: float = 20.0
+    
+    # 환경
+    sea_level: float = 10.0
+    sediment_supply: float = 1.0  # 퇴적물 공급량 계수
+    
+    # 내부 상태
+    terrain: Terrain = field(default=None)
+    water: Water = field(default=None)
+    delta_mask: np.ndarray = field(default=None)  # 삼각주 영역
+    history: List[np.ndarray] = field(default_factory=list)
+    current_step: int = 0
+    
+    def __post_init__(self):
+        self.reset()
+    
+    def reset(self):
+        """시뮬레이션 초기화"""
+        self.terrain = Terrain(width=self.width, height=self.height)
+        
+        # 지형 설정: 상류(육지) → 하류(바다)
+        for y in range(self.height):
+            if y < self.height * 0.4:
+                # 육지 (경사)
+                elev = 50 - y * 0.5
+            else:
+                # 바다 (해수면 아래)
+                elev = self.sea_level - (y - self.height * 0.4) * 0.3
+            self.terrain.elevation[y, :] = elev
+        
+        # 중앙에 하천 채널
+        center = self.width // 2
+        for y in range(int(self.height * 0.5)):
+            for dx in range(-3, 4):
+                x = center + dx
+                if 0 <= x < self.width:
+                    self.terrain.elevation[y, x] -= 5
+        
+        # 수문 초기화
+        self.water = Water(terrain=self.terrain)
+        self.water.discharge[0, center] = 100  # 상류 유입
+        self.water.accumulate_flow()
+        
+        self.delta_mask = np.zeros((self.height, self.width), dtype=bool)
+        self.history = [self.terrain.elevation.copy()]
+        self.current_step = 0
+    
+    def set_energy_balance(self, river: float, wave: float, tidal: float):
+        """에너지 균형 설정 (0-100)"""
+        self.river_energy = max(0, min(100, river))
+        self.wave_energy = max(0, min(100, wave))
+        self.tidal_energy = max(0, min(100, tidal))
+    
+    def step(self, n_steps: int = 1) -> np.ndarray:
+        """시뮬레이션 n스텝 진행"""
+        for _ in range(n_steps):
+            # 1. 유량 계산
+            self.water.accumulate_flow()
+            
+            # 2. 삼각주 퇴적
+            deposition = self._calculate_delta_deposition()
+            apply_deposition(self.terrain, deposition)
+            
+            # 3. 파랑/조류에 의한 재분배
+            redistribution = self._calculate_redistribution()
+            self.terrain.elevation += redistribution
+            
+            # 4. 삼각주 영역 업데이트
+            self._update_delta_mask()
+            
+            self.current_step += 1
+            
+            if self.current_step % 10 == 0:
+                self.history.append(self.terrain.elevation.copy())
+        
+        return self.terrain.elevation
+    
+    def _calculate_delta_deposition(self) -> np.ndarray:
+        """에너지 균형 기반 삼각주 퇴적 계산"""
+        deposition = delta_deposition(
+            self.terrain, self.water,
+            river_energy=self.river_energy / 50,  # 정규화
+            wave_energy=self.wave_energy / 50,
+            tidal_energy=self.tidal_energy / 50,
+            sea_level=self.sea_level
+        )
+        
+        return deposition * self.sediment_supply
+    
+    def _calculate_redistribution(self) -> np.ndarray:
+        """파랑/조류에 의한 퇴적물 재분배"""
+        redistribution = np.zeros((self.height, self.width))
+        
+        # 하구 영역 (해수면 근처)
+        estuary = (self.terrain.elevation > self.sea_level - 5) & \
+                  (self.terrain.elevation < self.sea_level + 5)
+        
+        if not np.any(estuary):
+            return redistribution
+        
+        # 파랑: 좌우로 퍼���림
+        if self.wave_energy > 20:
+            from scipy.ndimage import uniform_filter1d
+            for y in range(self.height):
+                if np.any(estuary[y, :]):
+                    # 좌우 방향 평활화
+                    row = self.terrain.elevation[y, :].copy()
+                    smoothed = uniform_filter1d(row, size=5)
+                    redistribution[y, :] = (smoothed - row) * (self.wave_energy / 100) * 0.1
+        
+        # 조류: 바다 방향으로 쓸어냄
+        if self.tidal_energy > 20:
+            for y in range(1, self.height):
+                factor = self.tidal_energy / 100 * 0.05
+                if np.any(estuary[y, :]):
+                    # 아래로 이동
+                    redistribution[y, :] += self.terrain.elevation[y-1, :] * factor * 0.1
+                    redistribution[y-1, :] -= self.terrain.elevation[y-1, :] * factor * 0.1
+        
+        return redistribution
+    
+    def _update_delta_mask(self):
+        """삼각주 영역 업데이트"""
+        # 해수면보다 약간 높고 하구 근처인 영역
+        self.delta_mask = (
+            (self.terrain.elevation > self.sea_level) & 
+            (self.terrain.elevation < self.sea_level + 20) &
+            (np.arange(self.height)[:, None] > self.height * 0.4)  # 하류
+        )
+    
+    def get_delta_type(self) -> DeltaType:
+        """현재 삼각주 유형 판별"""
+        total = self.river_energy + self.wave_energy + self.tidal_energy + 0.01
+        
+        r_ratio = self.river_energy / total
+        w_ratio = self.wave_energy / total
+        t_ratio = self.tidal_energy / total
+        
+        if r_ratio >= w_ratio and r_ratio >= t_ratio:
+            return DeltaType.RIVER_DOMINATED
+        elif w_ratio >= t_ratio:
+            return DeltaType.WAVE_DOMINATED
+        else:
+            return DeltaType.TIDE_DOMINATED
+    
+    def get_delta_area(self) -> float:
+        """삼각주 면적 (셀 수)"""
+        return float(np.sum(self.delta_mask))
+    
+    def get_delta_extent(self) -> Tuple[float, float]:
+        """삼각주 가로/세로 범위"""
+        if not np.any(self.delta_mask):
+            return 0, 0
+        
+        cols = np.any(self.delta_mask, axis=0)
+        rows = np.any(self.delta_mask, axis=1)
+        
+        width = np.sum(cols) * self.terrain.cell_size
+        length = np.sum(rows) * self.terrain.cell_size
+        
+        return width, length
+    
+    def get_info(self) -> dict:
+        """현재 상태 정보"""
+        delta_type = self.get_delta_type()
+        width, length = self.get_delta_extent()
+        
+        return {
+            "step": self.current_step,
+            "delta_type": delta_type.value,
+            "delta_area": self.get_delta_area(),
+            "delta_width": width,
+            "delta_length": length,
+            "energy_balance": {
+                "river": self.river_energy,
+                "wave": self.wave_energy,
+                "tidal": self.tidal_energy
+            }
+        }
+
+
+if __name__ == "__main__":
+    # 시나리오 1: 미시시피형 (하천 우세)
+    print("=" * 50)
+    print("시나리오 1: 조족상 삼각주 (미시시피형)")
+    sim1 = DeltaSimulator()
+    sim1.set_energy_balance(river=80, wave=10, tidal=10)
+    
+    for i in range(10):
+        sim1.step(50)
+    info = sim1.get_info()
+    print(f"유형: {info['delta_type']}")
+    print(f"면적: {info['delta_area']:.0f}, 폭: {info['delta_width']:.0f}m, 길이: {info['delta_length']:.0f}m")
+    
+    # 시나리오 2: 나일형 (파랑 우세)
+    print("\n" + "=" * 50)
+    print("시나리오 2: 원호상 삼각주 (나일형)")
+    sim2 = DeltaSimulator()
+    sim2.set_energy_balance(river=30, wave=60, tidal=10)
+    
+    for i in range(10):
+        sim2.step(50)
+    info = sim2.get_info()
+    print(f"유형: {info['delta_type']}")
+    print(f"면적: {info['delta_area']:.0f}, 폭: {info['delta_width']:.0f}m, 길이: {info['delta_length']:.0f}m")
+    
+    print("\n시뮬레이션 완료!")

engine/river/meander.py

@@ -0,0 +1,299 @@
+"""
+Geo-Lab AI: 곡류 & 우각호 시뮬레이션
+중류 하천의 측방 침식으로 굽이치는 하천과 우각호 형성
+"""
+import numpy as np
+from dataclasses import dataclass, field
+from typing import List, Tuple, Optional
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from engine.base import Terrain, Water
+from engine.erosion import lateral_erosion, apply_erosion
+from engine.deposition import apply_deposition
+
+
+@dataclass
+class MeanderSimulator:
+    """곡류 하천 시뮬레이션
+    
+    핵심 원리:
+    1. 측방 침식 (Lateral Erosion) - 바깥쪽(공격사면)
+    2. 측방 퇴적 (Point Bar) - 안쪽(퇴적사면)
+    3. 유로 절단 (Cutoff) - 우각호 형성
+    
+    결과: 굽이치는 하천, 우각호(Oxbow Lake)
+    """
+    
+    # 지형 크기
+    width: int = 150
+    height: int = 150
+    
+    # 시뮬레이션 파라미터
+    initial_sinuosity: float = 1.2  # 초기 굴곡도
+    discharge: float = 50.0  # 유량
+    
+    # 침식/퇴적 계수
+    k_lateral: float = 0.0003
+    k_deposition: float = 0.0002
+    
+    # 우각호 형성 조건
+    cutoff_threshold: float = 10.0  # 유로 간 거리가 이 이하면 절단
+    
+    # 내부 상태
+    terrain: Terrain = field(default=None)
+    water: Water = field(default=None)
+    channel_path: List[Tuple[int, int]] = field(default_factory=list)
+    oxbow_lakes: List[np.ndarray] = field(default_factory=list)
+    history: List[np.ndarray] = field(default_factory=list)
+    current_step: int = 0
+    
+    def __post_init__(self):
+        self.reset()
+    
+    def reset(self):
+        """시뮬레이션 초기화"""
+        self.terrain = Terrain(width=self.width, height=self.height)
+        
+        # 평탄한 범람원 (약간의 경사)
+        for y in range(self.height):
+            self.terrain.elevation[y, :] = 100 - y * 0.2  # 완만한 경사
+        
+        # 초기 곡류 하천 경로 생성
+        self._create_initial_channel()
+        
+        # 수문 초기화
+        self.water = Water(terrain=self.terrain)
+        self._update_water_from_channel()
+        
+        self.oxbow_lakes = []
+        self.history = [self.terrain.elevation.copy()]
+        self.current_step = 0
+    
+    def _create_initial_channel(self):
+        """초기 사인파 형태의 곡류 하천 생성"""
+        self.channel_path = []
+        
+        amplitude = self.width * 0.15 * self.initial_sinuosity
+        frequency = 3  # 굽이 수
+        
+        center = self.width // 2
+        
+        for y in range(self.height):
+            # 사인파 곡선
+            x = int(center + amplitude * np.sin(2 * np.pi * frequency * y / self.height))
+            x = max(5, min(self.width - 5, x))
+            self.channel_path.append((y, x))
+            
+            # 하천 채널 파기 (주변도 약간)
+            for dx in range(-3, 4):
+                nx = x + dx
+                if 0 <= nx < self.width:
+                    depth = 5 * (1 - abs(dx) / 4)
+                    self.terrain.elevation[y, nx] -= depth
+    
+    def _update_water_from_channel(self):
+        """하천 경로를 기반으로 수문 데이터 업데이트"""
+        self.water.discharge[:] = 0
+        self.water.velocity[:] = 0
+        
+        for y, x in self.channel_path:
+            self.water.discharge[y, x] = self.discharge
+            self.water.velocity[y, x] = 2.0  # 기본 유속
+        
+        # 주변으로 확산
+        from scipy.ndimage import gaussian_filter
+        self.water.discharge = gaussian_filter(self.water.discharge, sigma=1)
+        self.water.velocity = gaussian_filter(self.water.velocity, sigma=1)
+    
+    def step(self, n_steps: int = 1) -> np.ndarray:
+        """시뮬레이션 n스텝 진행"""
+        for _ in range(n_steps):
+            # 1. 측방 침식 (바깥쪽)
+            erosion = self._calculate_bank_erosion()
+            apply_erosion(self.terrain, erosion)
+            
+            # 2. Point Bar 퇴적 (안쪽)
+            deposition = self._calculate_point_bar_deposition()
+            apply_deposition(self.terrain, deposition)
+            
+            # 3. 하천 경로 업데이트 (가장 낮은 곳으로 이동)
+            self._update_channel_path()
+            
+            # 4. 우각호 체크
+            self._check_cutoff()
+            
+            # 5. 수문 업데이트
+            self._update_water_from_channel()
+            
+            self.current_step += 1
+            
+            if self.current_step % 10 == 0:
+                self.history.append(self.terrain.elevation.copy())
+        
+        return self.terrain.elevation
+    
+    def _calculate_bank_erosion(self) -> np.ndarray:
+        """공격사면(바깥쪽) 침식 계산"""
+        erosion = np.zeros((self.height, self.width))
+        
+        for i in range(1, len(self.channel_path) - 1):
+            y, x = self.channel_path[i]
+            y_prev, x_prev = self.channel_path[i - 1]
+            y_next, x_next = self.channel_path[i + 1]
+            
+            # 곡률 계산 (방향 변화)
+            dx1, dy1 = x - x_prev, y - y_prev
+            dx2, dy2 = x_next - x, y_next - y
+            
+            # 외적으로 회전 방향 판단
+            cross = dx1 * dy2 - dy1 * dx2
+            
+            # 바깥쪽 결정
+            if cross > 0:  # 오른쪽으로 회전 → 왼쪽이 바깥
+                outer_x = x - 1
+            else:  # 왼쪽으로 회전 → 오른쪽이 바깥
+                outer_x = x + 1
+            
+            if 0 <= outer_x < self.width:
+                curvature = abs(cross) / (np.sqrt(dx1**2+dy1**2+0.1) * np.sqrt(dx2**2+dy2**2+0.1) + 0.1)
+                erosion[y, outer_x] = self.k_lateral * self.discharge * curvature
+        
+        return erosion
+    
+    def _calculate_point_bar_deposition(self) -> np.ndarray:
+        """퇴적사면(안쪽) 퇴적 계산"""
+        deposition = np.zeros((self.height, self.width))
+        
+        for i in range(1, len(self.channel_path) - 1):
+            y, x = self.channel_path[i]
+            y_prev, x_prev = self.channel_path[i - 1]
+            y_next, x_next = self.channel_path[i + 1]
+            
+            dx1, dy1 = x - x_prev, y - y_prev
+            dx2, dy2 = x_next - x, y_next - y
+            cross = dx1 * dy2 - dy1 * dx2
+            
+            # 안쪽 (바깥쪽 반대)
+            if cross > 0:
+                inner_x = x + 1
+            else:
+                inner_x = x - 1
+            
+            if 0 <= inner_x < self.width:
+                curvature = abs(cross) / (np.sqrt(dx1**2+dy1**2+0.1) * np.sqrt(dx2**2+dy2**2+0.1) + 0.1)
+                deposition[y, inner_x] = self.k_deposition * self.discharge * curvature
+        
+        return deposition
+    
+    def _update_channel_path(self):
+        """하천 경로를 가장 낮은 지점으로 이동"""
+        new_path = [self.channel_path[0]]  # 시작점 유지
+        
+        for i in range(1, len(self.channel_path) - 1):
+            y, x = self.channel_path[i]
+            
+            # 주변 중 가장 낮은 곳 탐색
+            min_elev = self.terrain.elevation[y, x]
+            best_x = x
+            
+            for dx in [-1, 0, 1]:
+                nx = x + dx
+                if 0 <= nx < self.width:
+                    if self.terrain.elevation[y, nx] < min_elev:
+                        min_elev = self.terrain.elevation[y, nx]
+                        best_x = nx
+            
+            new_path.append((y, best_x))
+        
+        new_path.append(self.channel_path[-1])  # 끝점 유지
+        self.channel_path = new_path
+    
+    def _check_cutoff(self):
+        """우각호 형성 조건 체크"""
+        # 가까운 두 유로 지점 찾기
+        for i in range(len(self.channel_path)):
+            for j in range(i + 20, len(self.channel_path)):  # 최소 20셀 떨어진 것만
+                y1, x1 = self.channel_path[i]
+                y2, x2 = self.channel_path[j]
+                
+                dist = np.sqrt((x1 - x2)**2 + (y1 - y2)**2)
+                
+                if dist < self.cutoff_threshold:
+                    # Cutoff 발생! 우각호 생성
+                    self._create_oxbow_lake(i, j)
+                    return
+    
+    def _create_oxbow_lake(self, start_idx: int, end_idx: int):
+        """우각호 생성"""
+        # 고립될 구간 추출
+        cutoff_section = self.channel_path[start_idx:end_idx]
+        
+        # 우각호로 저장
+        oxbow = np.zeros((self.height, self.width), dtype=bool)
+        for y, x in cutoff_section:
+            oxbow[y, x] = True
+        self.oxbow_lakes.append(oxbow)
+        
+        # 하천 경로 단축 (직선으로)
+        self.channel_path = (
+            self.channel_path[:start_idx+1] + 
+            self.channel_path[end_idx:]
+        )
+        
+        print(f"🌊 우각호 형성! (Step {self.current_step})")
+    
+    def get_cross_section(self, y_position: int = None) -> Tuple[np.ndarray, np.ndarray]:
+        """특정 위치의 단면도"""
+        if y_position is None:
+            y_position = self.height // 2
+        
+        x = np.arange(self.width) * self.terrain.cell_size
+        z = self.terrain.elevation[y_position, :]
+        
+        return x, z
+    
+    def get_sinuosity(self) -> float:
+        """현재 굴곡도 계산"""
+        if len(self.channel_path) < 2:
+            return 1.0
+        
+        # 실제 경로 길이
+        path_length = 0
+        for i in range(1, len(self.channel_path)):
+            y1, x1 = self.channel_path[i-1]
+            y2, x2 = self.channel_path[i]
+            path_length += np.sqrt((x2-x1)**2 + (y2-y1)**2)
+        
+        # 직선 거리
+        y_start, x_start = self.channel_path[0]
+        y_end, x_end = self.channel_path[-1]
+        straight_length = np.sqrt((x_end-x_start)**2 + (y_end-y_start)**2) + 0.1
+        
+        return path_length / straight_length
+    
+    def get_info(self) -> dict:
+        """현재 상태 정보"""
+        return {
+            "step": self.current_step,
+            "sinuosity": self.get_sinuosity(),
+            "oxbow_lakes": len(self.oxbow_lakes),
+            "channel_length": len(self.channel_path)
+        }
+
+
+if __name__ == "__main__":
+    sim = MeanderSimulator(initial_sinuosity=1.5)
+    
+    print("곡류 하천 시뮬레이션 시작")
+    print(f"초기 굴곡도: {sim.get_sinuosity():.2f}")
+    
+    for i in range(20):
+        sim.step(50)
+        info = sim.get_info()
+        print(f"Step {info['step']}: 굴곡도 {info['sinuosity']:.2f}, "
+              f"우각호 {info['oxbow_lakes']}개")
+    
+    print("시뮬레이션 완료!")

engine/river/v_valley.py

@@ -0,0 +1,161 @@
+"""
+Geo-Lab AI: V자곡 시뮬레이션
+상류 하천의 하방 침식으로 V자 모양 골짜기 형성
+"""
+import numpy as np
+from dataclasses import dataclass, field
+from typing import List, Tuple
+
+import sys
+import os
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
+
+from engine.base import Terrain, Water, SimulationState
+from engine.erosion import vertical_erosion, headward_erosion, mass_wasting, apply_erosion
+
+
+@dataclass
+class VValleySimulator:
+    """V자곡 시뮬레이션
+    
+    핵심 원리:
+    1. 하방 침식 (Stream Power Law)
+    2. 사면 붕괴 (Mass Wasting)
+    
+    결과: V자 형태의 깊은 골짜기
+    """
+    
+    # 지형 크기
+    width: int = 100
+    height: int = 100
+    
+    # 시뮬레이션 파라미터
+    rock_hardness: float = 0.5  # 0=무름, 1=단단함
+    slope_gradient: float = 0.1  # 초기 경사
+    initial_discharge: float = 10.0  # 초기 유량
+    
+    # 침식 계수
+    k_vertical: float = 0.0005  # 하방 침식 계수
+    k_headward: float = 0.0003  # 두부 침식 계수
+    
+    # 내부 상태
+    terrain: Terrain = field(default=None)
+    water: Water = field(default=None)
+    history: List[np.ndarray] = field(default_factory=list)
+    current_step: int = 0
+    
+    def __post_init__(self):
+        self.reset()
+    
+    def reset(self):
+        """시뮬레이션 초기화"""
+        # 초기 지형: 북쪽이 높은 경사면
+        self.terrain = Terrain(width=self.width, height=self.height)
+        
+        # 경사 설정
+        for y in range(self.height):
+            base_elevation = 500 * (1 - y / self.height)
+            self.terrain.elevation[y, :] = base_elevation
+        
+        # 중앙에 초기 하천 채널 (약간 낮게)
+        center = self.width // 2
+        channel_width = 3
+        for x in range(center - channel_width, center + channel_width):
+            if 0 <= x < self.width:
+                self.terrain.elevation[:, x] -= 10
+        
+        # 암석 경도 설정
+        self.terrain.rock_hardness[:] = self.rock_hardness
+        
+        # 수문 초기화
+        self.water = Water(terrain=self.terrain)
+        self.water.discharge[0, center] = self.initial_discharge  # 상류에서 유입
+        self.water.accumulate_flow()
+        
+        self.history = [self.terrain.elevation.copy()]
+        self.current_step = 0
+    
+    def step(self, n_steps: int = 1) -> np.ndarray:
+        """시뮬레이션 n스텝 진행"""
+        for _ in range(n_steps):
+            # 1. 유량 계산
+            self.water.add_precipitation(rate=0.001)
+            self.water.accumulate_flow()
+            
+            # 2. 하방 침식
+            v_erosion = vertical_erosion(
+                self.terrain, self.water,
+                k_erosion=self.k_vertical * (1 - self.rock_hardness)
+            )
+            apply_erosion(self.terrain, v_erosion)
+            
+            # 3. 두부 침식
+            h_erosion = headward_erosion(
+                self.terrain, self.water,
+                k_headward=self.k_headward
+            )
+            apply_erosion(self.terrain, h_erosion)
+            
+            # 4. 사면 붕괴 (V자 형성의 핵심!)
+            mass_change = mass_wasting(self.terrain)
+            self.terrain.elevation += mass_change
+            
+            # 5. 흐름 방향 업데이트
+            self.water.flow_x, self.water.flow_y = self.terrain.get_flow_direction()
+            
+            self.current_step += 1
+            
+            # 히스토리 저장 (매 10스텝)
+            if self.current_step % 10 == 0:
+                self.history.append(self.terrain.elevation.copy())
+        
+        return self.terrain.elevation
+    
+    def get_cross_section(self, y_position: int = None) -> Tuple[np.ndarray, np.ndarray]:
+        """특정 위치의 단면도 반환"""
+        if y_position is None:
+            y_position = self.height // 2
+        
+        x = np.arange(self.width) * self.terrain.cell_size
+        z = self.terrain.elevation[y_position, :]
+        
+        return x, z
+    
+    def get_valley_depth(self) -> float:
+        """현재 V자곡 깊이 측정"""
+        center = self.width // 2
+        y_mid = self.height // 2
+        
+        # 좌우 고도 평균 vs 중앙 고도
+        left_elev = self.terrain.elevation[y_mid, center - 20]
+        right_elev = self.terrain.elevation[y_mid, center + 20]
+        center_elev = self.terrain.elevation[y_mid, center]
+        
+        depth = (left_elev + right_elev) / 2 - center_elev
+        return max(0, depth)
+    
+    def get_info(self) -> dict:
+        """현재 시뮬레이션 상태 정보"""
+        return {
+            "step": self.current_step,
+            "valley_depth": self.get_valley_depth(),
+            "max_elevation": float(self.terrain.elevation.max()),
+            "min_elevation": float(self.terrain.elevation.min()),
+            "total_erosion": float(self.history[0].sum() - self.terrain.elevation.sum())
+        }
+
+
+# 테스트 코드
+if __name__ == "__main__":
+    sim = VValleySimulator(rock_hardness=0.3)
+    
+    print("V자곡 시뮬레이션 시작")
+    print(f"초기 깊이: {sim.get_valley_depth():.1f}m")
+    
+    for i in range(10):
+        sim.step(100)
+        info = sim.get_info()
+        print(f"Step {info['step']}: 깊이 {info['valley_depth']:.1f}m, "
+              f"총 침식량 {info['total_erosion']:.0f}m³")
+    
+    print("시뮬레이션 완료!")

engine/script_engine.py

@@ -0,0 +1,87 @@
+
+import numpy as np
+import math
+from .grid import WorldGrid
+from .fluids import HydroKernel
+from .erosion_process import ErosionProcess
+
+class ScriptExecutor:
+    """
+    사용자 정의 스크립트 실행 엔진
+    보안을 위해 제한된 환경에서 Python 코드를 실행합니다.
+    """
+    def __init__(self, grid: WorldGrid):
+        self.grid = grid
+        self.hydro = HydroKernel(grid)
+        self.erosion = ErosionProcess(grid)
+        
+    def execute(self, script: str, dt: float = 1.0, allowed_modules: list = ['numpy', 'math']):
+        """
+        스크립트 실행
+        
+        Args:
+            script: 실행할 Python 코드 문자열
+            dt: 시간 간격 (Time Step)
+            allowed_modules: 허용할 모듈 리스트 (기본: numpy, math)
+        
+        Available Variables in Context:
+            - grid: WorldGrid 객체
+            - elevation: grid.elevation (Numpy Array)
+            - bedrock: grid.bedrock
+            - sediment: grid.sediment
+            - water_depth: grid.water_depth
+            - dt: Delta Time
+            - np: numpy module
+            - math: math module
+            - hydro: HydroKernel 객체
+            - erosion: ErosionProcess 객체
+        """
+        
+        # 1. 실행 컨텍스트(Namespace) 준비
+        context = {
+            'grid': self.grid,
+            'elevation': self.grid.elevation,
+            'bedrock': self.grid.bedrock,
+            'sediment': self.grid.sediment,
+            'water_depth': self.grid.water_depth,
+            'dt': dt,
+            'np': np,
+            'math': math,
+            'hydro': self.hydro,
+            'erosion': self.erosion,
+            # Helper functions
+            'max': max,
+            'min': min,
+            'abs': abs,
+            'pow': pow,
+            'print': print # 디버깅용
+        }
+        
+        # 2. 금지된 키워드 체크 (기본적인 보안)
+        # 완벽한 샌드박스는 아니지만, 실수 방지용
+        forbidden = ['import os', 'import sys', 'open(', 'exec(', 'eval(', '__import__']
+        for bad in forbidden:
+            if bad in script:
+                raise ValueError(f"보안 경고: 허용되지 않는 키워드 '{bad}'가 포함되어 있습니다.")
+                
+        # 3. 코드 실행
+        try:
+            exec(script, {"__builtins__": {}}, context)
+            
+            # 4. 변경 사항 반영 (Elevation은 derived property지만, 직접 수정했을 수 있으므로)
+            # 사용자가 elevation을 수정했다면 bedrock/sediment 업데이트가 모호해짐.
+            # Grid 클래스의 update_elevation()은 bedrock+sediment -> elevation이므로,
+            # 사용자가 elevation을 수정하면 무시될 수 있음.
+            # 가이드: "bedrock"이나 "sediment"를 수정하세요.
+            # 하지만 편의를 위해 elevation이 바뀌었으면 bedrock에 반영하는 로직 추가
+            
+            # 변경 전 elevation과 비교해야 하나?
+            # 일단 grid.update_elevation()을 호출하여 동기화
+            # (만약 사용자가 bedrock을 바꿨다면 반영됨)
+            self.grid.update_elevation()
+            
+            return True, "실행 성공"
+            
+        except Exception as e:
+            return False, f"실행 오류: {str(e)}"
+

engine/system.py

@@ -0,0 +1,131 @@
+import numpy as np
+from dataclasses import dataclass
+from .grid import WorldGrid
+from .fluids import HydroKernel
+from .erosion_process import ErosionProcess
+from .lateral_erosion import LateralErosionKernel
+from .mass_movement import MassMovementKernel
+from .climate import ClimateKernel
+from .wave import WaveKernel
+from .glacier import GlacierKernel
+from .wind import WindKernel
+
+class EarthSystem:
+    """
+    Project Genesis: Unified Earth System Engine
+    
+    통합 지구 시스템 엔진
+    - 기후(Climate) -> 수문(Hydro) -> 지형(Erosion/Tectonics) 상호작용을
+      단일 루프(step) 내에서 처리합니다.
+    """
+    def __init__(self, grid: WorldGrid):
+        self.grid = grid
+        self.time = 0.0
+        
+        # Core Kernels
+        self.hydro = HydroKernel(self.grid)
+        self.erosion = ErosionProcess(self.grid)
+        self.lateral = LateralErosionKernel(self.grid, k=0.01)
+        self.mass_movement = MassMovementKernel(self.grid, friction_angle=35.0)
+        self.climate = ClimateKernel(self.grid)
+        
+        # Phase 2 Kernels (Optional, enabled via settings)
+        self.wave = WaveKernel(self.grid)
+        self.glacier = GlacierKernel(self.grid)
+        self.wind = WindKernel(self.grid)
+        
+        # State History (Optional for analysis)
+        self.history = []
+
+    def step(self, dt: float = 1.0, settings: dict = None):
+        """
+        시스템 1단계 진행 (Time Step)
+        
+        Process Chain:
+        1. Tectonics (Endogenous): Uplift, subsidence based on scenario settings
+        2. Climate (Exogenous): Generate precipitation
+        3. Hydro (Physics): Route flow, calculate discharge/depth
+        4. Morphodynamics (Response): Erode, transport, deposit
+        """
+        if settings is None:
+            settings = {}
+            
+        # 1. Tectonics (지구조 운동)
+        # Simple vertical uplift logic if provided
+        uplift_rate = settings.get('uplift_rate', 0.0)
+        tile_uplift = settings.get('uplift_mask', None)
+        
+        if uplift_rate > 0:
+            if tile_uplift is not None:
+                self.grid.apply_uplift(tile_uplift * uplift_rate, dt)
+            else:
+                self.grid.apply_uplift(uplift_rate, dt)
+                
+        # 2. Climate (기후)
+        # Generate precipitation map
+        # Default: Uniform rain + randomness
+        base_precip = settings.get('precipitation', 0.01)
+        precip_map = np.ones((self.grid.height, self.grid.width)) * base_precip
+        
+        # Apply rain source if specified (e.g., river mouth)
+        rain_source = settings.get('rain_source', None) # (y, x, radius, amount)
+        if rain_source:
+             y, x, r, amount = rain_source
+             # Simplified box source for speed
+             y_min, y_max = max(0, int(y-r)), min(self.grid.height, int(y+r+1))
+             x_min, x_max = max(0, int(x-r)), min(self.grid.width, int(x+r+1))
+             precip_map[y_min:y_max, x_min:x_max] += amount
+        
+        # 3. Hydro (수문)
+        # Route flow based on current topography + precip
+        discharge = self.hydro.route_flow_d8(precipitation=precip_map)
+        
+        # Update grid state
+        self.grid.discharge = discharge
+        self.grid.water_depth = self.hydro.calculate_water_depth(discharge)
+        
+        # 4. Erosion / Deposition (지형 변화)
+        # Using the ErosionKernel (ErosionProcess wrapper)
+        # Need to update K, m, n parameters dynamically?
+        # For now, use instance defaults or allow overrides
+        
+        # Execute Transport & Deposition
+        sediment_influx_map = None
+        sediment_source = settings.get('sediment_source', None) # (y, x, radius, amount)
+        if sediment_source:
+             y, x, r, amount = sediment_source
+             sediment_influx_map = np.zeros((self.grid.height, self.grid.width))
+             y_min, y_max = max(0, int(y-r)), min(self.grid.height, int(y+r+1))
+             x_min, x_max = max(0, int(x-r)), min(self.grid.width, int(x+r+1))
+             sediment_influx_map[y_min:y_max, x_min:x_max] += amount
+             
+        self.erosion.simulate_transport(discharge, dt=dt, sediment_influx_map=sediment_influx_map)
+        
+        # 5. Lateral Erosion (측방 침식) - 곡류 형성
+        lateral_enabled = settings.get('lateral_erosion', True)
+        if lateral_enabled:
+            self.lateral.step(discharge, dt=dt)
+        
+        # 6. Hillslope Diffusion (사면 안정화)
+        diff_rate = settings.get('diffusion_rate', 0.01)
+        if diff_rate > 0:
+            self.erosion.hillslope_diffusion(dt=dt * diff_rate)
+        
+        # 7. Mass Movement (매스무브먼트) - 산사태
+        mass_movement_enabled = settings.get('mass_movement', True)
+        if mass_movement_enabled:
+            self.mass_movement.step(dt=dt)
+            
+        # Update Time
+        self.time += dt
+        
+    def get_state(self):
+        """현재 시스��� 상태 반환"""
+        self.grid.update_elevation()
+        return {
+            'elevation': self.grid.elevation.copy(),
+            'water_depth': self.grid.water_depth.copy(),
+            'discharge': self.grid.discharge.copy(),
+            'sediment': self.grid.sediment.copy(),
+            'time': self.time
+        }

engine/wave.py

@@ -0,0 +1,236 @@
+"""
+Wave Kernel (파랑 커널)
+
+해안 지형 형성 프로세스
+- 파랑 침식 (Wave Erosion): 해식절벽 후퇴
+- 연안 퇴적 (Coastal Deposition): 사주, 사취 형성
+- 연안류 (Longshore Drift): 측방 퇴적물 이동
+
+핵심 공식:
+침식률 E = K * H^2 * (1/R)
+- H: 파고 (Wave Height)
+- R: 암석 저항력 (Rock Resistance)
+"""
+
+import numpy as np
+from .grid import WorldGrid
+
+
+class WaveKernel:
+    """
+    파랑 커널
+    
+    해안선에서의 파랑 작용을 시뮬레이션.
+    침식과 퇴적을 동시에 처리.
+    """
+    
+    def __init__(self, grid: WorldGrid,
+                 wave_height: float = 2.0,      # m
+                 wave_period: float = 8.0,      # s
+                 wave_direction: float = 0.0,   # degrees from N
+                 K_erosion: float = 0.001):
+        self.grid = grid
+        self.wave_height = wave_height
+        self.wave_period = wave_period
+        self.wave_direction = np.radians(wave_direction)
+        self.K = K_erosion
+        
+    def identify_coastline(self) -> np.ndarray:
+        """
+        해안선 식별
+        
+        육지-바다 경계선을 찾음
+        
+        Returns:
+            coastline_mask: 해안선 셀 마스크
+        """
+        underwater = self.grid.is_underwater()
+        
+        # 해안선 = 육지인데 인접 셀에 바다가 있는 곳
+        h, w = self.grid.height, self.grid.width
+        coastline = np.zeros((h, w), dtype=bool)
+        
+        for r in range(h):
+            for c in range(w):
+                if underwater[r, c]:
+                    continue  # 바다는 해안선 아님
+                    
+                # 인접 셀 확인
+                for dr in [-1, 0, 1]:
+                    for dc in [-1, 0, 1]:
+                        if dr == 0 and dc == 0:
+                            continue
+                        nr, nc = r + dr, c + dc
+                        if 0 <= nr < h and 0 <= nc < w:
+                            if underwater[nr, nc]:
+                                coastline[r, c] = True
+                                break
+                    if coastline[r, c]:
+                        break
+                        
+        return coastline
+        
+    def calculate_wave_energy(self) -> np.ndarray:
+        """
+        파랑 에너지 분포 계산
+        
+        Returns:
+            energy: 각 셀의 파랑 에너지
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        # 기본 에너지 = H^2 (파고 제곱에 비례)
+        base_energy = self.wave_height ** 2
+        
+        # 수심에 따른 감쇠
+        # 깊은 바다: 에너지 유지, 얕은 곳: 에너지 집중 후 쇄파
+        sea_depth = np.maximum(0, self.grid.sea_level - self.grid.elevation)
+        
+        # 천해 효과: 수심 < 파장/2 일 때 에너지 증가
+        wavelength = 1.56 * (self.wave_period ** 2)  # 심해 파장 근사
+        depth_factor = np.ones((h, w))
+        
+        shallow = sea_depth < wavelength / 2
+        depth_factor[shallow] = 1.0 + 0.5 * (1 - sea_depth[shallow] / (wavelength / 2))
+        
+        energy = base_energy * depth_factor
+        
+        # 육지는 에너지 0
+        energy[~self.grid.is_underwater()] = 0
+        
+        return energy
+        
+    def erode_coast(self, coastline: np.ndarray, 
+                    wave_energy: np.ndarray,
+                    rock_resistance: np.ndarray = None,
+                    dt: float = 1.0) -> np.ndarray:
+        """
+        해안 침식
+        
+        Args:
+            coastline: 해안선 마스크
+            wave_energy: 파랑 에너지 배열
+            rock_resistance: 암석 저항력 (0~1, 높을수록 저항)
+            dt: 시간 간격
+            
+        Returns:
+            erosion: 침식량 배열
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        if rock_resistance is None:
+            rock_resistance = np.ones((h, w)) * 0.5
+            
+        erosion = np.zeros((h, w), dtype=np.float64)
+        
+        # 해안선 셀에 대해 침식 계산
+        coast_coords = np.argwhere(coastline)
+        
+        for r, c in coast_coords:
+            # 인접 바다 셀의 평균 에너지
+            adjacent_energy = 0
+            count = 0
+            
+            for dr in [-1, 0, 1]:
+                for dc in [-1, 0, 1]:
+                    if dr == 0 and dc == 0:
+                        continue
+                    nr, nc = r + dr, c + dc
+                    if 0 <= nr < h and 0 <= nc < w:
+                        if self.grid.is_underwater()[nr, nc]:
+                            adjacent_energy += wave_energy[nr, nc]
+                            count += 1
+                            
+            if count > 0:
+                avg_energy = adjacent_energy / count
+                # 침식률 = K * Energy / Resistance
+                resistance = rock_resistance[r, c]
+                erosion[r, c] = self.K * avg_energy * (1 - resistance) * dt
+                
+        return erosion
+        
+    def longshore_drift(self, coastline: np.ndarray,
+                        sediment_available: np.ndarray,
+                        dt: float = 1.0) -> np.ndarray:
+        """
+        연안류에 의한 퇴적물 이동
+        
+        Args:
+            coastline: 해안선 마스크
+            sediment_available: 이동 가능한 퇴적물
+            dt: 시간 간격
+            
+        Returns:
+            change: 퇴적물 변화량
+        """
+        h, w = self.grid.height, self.grid.width
+        change = np.zeros((h, w), dtype=np.float64)
+        
+        # 파랑 방향에 따른 연안류 방향
+        # 0 = N, 90 = E, etc.
+        drift_dx = np.sin(self.wave_direction)
+        drift_dy = -np.cos(self.wave_direction)  # Y축 반전
+        
+        coast_coords = np.argwhere(coastline)
+        
+        for r, c in coast_coords:
+            available = sediment_available[r, c]
+            if available <= 0:
+                continue
+                
+            # 이동량
+            move_amount = min(available * 0.1 * dt, available)
+            
+            # 목표 셀 (연안류 방향)
+            tr = int(r + drift_dy)
+            tc = int(c + drift_dx)
+            
+            if 0 <= tr < h and 0 <= tc < w:
+                if coastline[tr, tc] or self.grid.is_underwater()[tr, tc]:
+                    change[r, c] -= move_amount
+                    change[tr, tc] += move_amount
+                    
+        return change
+        
+    def step(self, dt: float = 1.0, 
+             rock_resistance: np.ndarray = None) -> dict:
+        """
+        1단계 파랑 작용 실행
+        
+        Args:
+            dt: 시간 간격
+            rock_resistance: 암석 저항력 배열
+            
+        Returns:
+            result: 침식/퇴적 결과
+        """
+        # 1. 해안선 식별
+        coastline = self.identify_coastline()
+        
+        if not np.any(coastline):
+            return {'erosion': np.zeros_like(self.grid.elevation),
+                    'drift': np.zeros_like(self.grid.elevation)}
+        
+        # 2. 파랑 에너지 계산
+        wave_energy = self.calculate_wave_energy()
+        
+        # 3. 해안 침식
+        erosion = self.erode_coast(coastline, wave_energy, rock_resistance, dt)
+        
+        # 침식 적용 (bedrock 감소)
+        self.grid.bedrock -= erosion
+        
+        # 침식된 양은 퇴적물로 변환
+        self.grid.sediment += erosion * 0.8  # 일부 유실
+        
+        # 4. 연안류 (Longshore Drift)
+        drift = self.longshore_drift(coastline, self.grid.sediment, dt)
+        self.grid.sediment += drift
+        
+        # 고도 동기화
+        self.grid.update_elevation()
+        
+        return {
+            'erosion': erosion,
+            'drift': drift
+        }

engine/wind.py

@@ -0,0 +1,215 @@
+"""
+Wind Kernel (바람 커널)
+
+풍성 지형 형성 프로세스
+- 풍식 (Deflation): 미세 입자 제거
+- 마식 (Abrasion): 모래 충돌에 의한 침식
+- 풍적 (Aeolian Deposition): 사구 형성
+
+핵심:
+- 바람 속도에 비례한 운반력
+- 입자 크기에 따른 선택적 운반
+"""
+
+import numpy as np
+from .grid import WorldGrid
+
+
+class WindKernel:
+    """
+    바람 커널
+    
+    건조 지역에서의 풍식과 풍적을 시뮬레이션.
+    """
+    
+    def __init__(self, grid: WorldGrid,
+                 wind_speed: float = 10.0,        # m/s
+                 wind_direction: float = 45.0,    # degrees from N
+                 K_erosion: float = 0.0001,
+                 sand_threshold: float = 0.1):    # 사구 형성 임계 퇴적량
+        self.grid = grid
+        self.wind_speed = wind_speed
+        self.wind_direction = np.radians(wind_direction)
+        self.K = K_erosion
+        self.sand_threshold = sand_threshold
+        
+    def get_wind_vector(self) -> tuple:
+        """
+        바람 방향 벡터 반환
+        
+        Returns:
+            (dy, dx): 바람 방향 단위 벡터
+        """
+        dx = np.sin(self.wind_direction)
+        dy = -np.cos(self.wind_direction)  # Y축 반전 (화면 좌표계)
+        return dy, dx
+        
+    def calculate_transport_capacity(self, 
+                                      vegetation_cover: np.ndarray = None) -> np.ndarray:
+        """
+        모래 운반력 계산
+        
+        Args:
+            vegetation_cover: 식생 피복률 (0~1, 높으면 운반력 감소)
+            
+        Returns:
+            capacity: 운반력 배열
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        # 기본 운반력 = 풍속^3 (경험식)
+        base_capacity = (self.wind_speed ** 3) * self.K
+        
+        capacity = np.ones((h, w)) * base_capacity
+        
+        # 식생 효과 (있으면 운반력 감소)
+        if vegetation_cover is not None:
+            capacity *= (1 - vegetation_cover)
+            
+        # 경사 효과 (바람받이 vs 바람그늘)
+        slope, aspect = self.grid.get_gradient()
+        
+        # 바람받이 = 풍향과 반대 경사면 → 감속 → 퇴적
+        # 바람그늘 = 풍향과 같은 경사면 → 가속 → 침식
+        dy, dx = self.get_wind_vector()
+        
+        # 경사면의 노출도 (바람과 경사 방향의 내적)
+        exposure = dx * np.gradient(self.grid.elevation, axis=1) + \
+                   dy * np.gradient(self.grid.elevation, axis=0)
+        
+        # 노출도에 따른 운반력 조정
+        capacity *= (1 + 0.5 * np.clip(exposure, -1, 1))
+        
+        # 해수면 아래는 0
+        capacity[self.grid.is_underwater()] = 0
+        
+        return np.maximum(capacity, 0)
+        
+    def deflation(self, capacity: np.ndarray, dt: float = 1.0) -> np.ndarray:
+        """
+        풍식 (Deflation) - 미세 입자 제거
+        
+        Args:
+            capacity: 운반력 배열
+            dt: 시간 간격
+            
+        Returns:
+            erosion: 침식량 배열
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        # 침식량 = 운반력 * dt (퇴적층에서만)
+        available = self.grid.sediment
+        erosion = np.minimum(capacity * dt, available)
+        
+        # 퇴적층 감소
+        self.grid.sediment -= erosion
+        
+        return erosion
+        
+    def transport_and_deposit(self, 
+                              eroded_material: np.ndarray,
+                              capacity: np.ndarray,
+                              dt: float = 1.0) -> np.ndarray:
+        """
+        풍적 (Aeolian Deposition) - 사구 형성
+        
+        Args:
+            eroded_material: 침식된 물질량
+            capacity: 운반력 배열
+            dt: 시간 간격
+            
+        Returns:
+            deposition: 퇴적량 배열
+        """
+        h, w = self.grid.height, self.grid.width
+        
+        dy, dx = self.get_wind_vector()
+        
+        # 물질 이동
+        deposition = np.zeros((h, w), dtype=np.float64)
+        
+        for r in range(h):
+            for c in range(w):
+                if eroded_material[r, c] <= 0:
+                    continue
+                    
+                # 바람 방향으로 이동
+                tr = int(r + dy * 2)  # 2셀 이동
+                tc = int(c + dx * 2)
+                
+                if not (0 <= tr < h and 0 <= tc < w):
+                    continue
+                    
+                # 목표 지점의 운반력 확인
+                if capacity[tr, tc] < capacity[r, c]:
+                    # 운반력 감소 → 퇴적
+                    deposit_amount = eroded_material[r, c] * (1 - capacity[tr, tc] / capacity[r, c])
+                    deposition[tr, tc] += deposit_amount
+                else:
+                    # 계속 운반 (다음 셀로)
+                    # 간단히 위해 일부만 퇴적
+                    deposition[tr, tc] += eroded_material[r, c] * 0.1
+                    
+        # 퇴적 적용
+        self.grid.add_sediment(deposition)
+        
+        return deposition
+        
+    def form_barchan(self, iteration: int = 5):
+        """
+        바르한 사구 형성 (반복 시뮬레이션)
+        
+        바람받이: 완경사, 바람그늘: 급경사 (Slip Face)
+        
+        Args:
+            iteration: 형태 다듬기 반복 횟수
+        """
+        h, w = self.grid.height, self.grid.width
+        dy, dx = self.get_wind_vector()
+        
+        # 사구 후보 (퇴적물 많은 곳)
+        dune_mask = self.grid.sediment > self.sand_threshold
+        
+        for _ in range(iteration):
+            # 바람받이 쪽 완만하게
+            for r in range(1, h - 1):
+                for c in range(1, w - 1):
+                    if not dune_mask[r, c]:
+                        continue
+                        
+                    # 바람받이 이웃
+                    wr, wc = int(r - dy), int(c - dx)
+                    if 0 <= wr < h and 0 <= wc < w:
+                        # 경사 완화
+                        avg = (self.grid.sediment[r, c] + self.grid.sediment[wr, wc]) / 2
+                        self.grid.sediment[r, c] = self.grid.sediment[r, c] * 0.9 + avg * 0.1
+                        
+        self.grid.update_elevation()
+        
+    def step(self, vegetation_cover: np.ndarray = None,
+             dt: float = 1.0) -> dict:
+        """
+        1단계 바람 작용 실행
+        
+        Args:
+            vegetation_cover: 식생 피복률
+            dt: 시간 간격
+            
+        Returns:
+            result: 침식/퇴적 결과
+        """
+        # 1. 운반력 계산
+        capacity = self.calculate_transport_capacity(vegetation_cover)
+        
+        # 2. 풍식
+        erosion = self.deflation(capacity, dt)
+        
+        # 3. 이동 및 퇴적
+        deposition = self.transport_and_deposit(erosion, capacity, dt)
+        
+        return {
+            'erosion': erosion,
+            'deposition': deposition,
+            'capacity': capacity
+        }

image list.txt

@@ -0,0 +1,160 @@
+🌊 [Chapter 1. 하천 지형 (River Landforms)]
+필수 이미지 (5장)
+
+1. V자곡과 협곡 (V-shaped Valley)
+   Filename: v_shaped_valley_diagram.jpg
+   Point: 강바닥이 깊게 파이고 양옆이 경사진 단면도가 포함된 그림.
+
+2. 선상지 (Alluvial Fan)
+   Filename: alluvial_fan_structure.jpg
+   Point: 부채꼴 모양의 평면도 + 땅속(선정/선앙/선단) 입자 크기가 묘사된 그림.
+
+3. 곡류 하천 단면 (Meander Cross-section)
+   Filename: meander_cross_section.jpg
+   Point: 공격사면(깎임)은 절벽, 퇴적사면(쌓임)은 완만하게 비대칭으로 그려진 단면도. (가장 중요!)
+
+4. 하안단구 (River Terrace)
+   Filename: river_terrace_formation.jpg
+   Point: 강 옆에 계단식으로 평평한 땅이 층층이 있는 그림.
+
+5. 삼각주 유형 (Delta Types)
+   Filename: delta_classification.jpg
+   Point: 새발 모양(미시시피), 부채 모양(나일), 첨각상(티베르) 3가지가 비교된 그림.
+
+---
+
+🏖️ [Chapter 2. 해안 지형 (Coastal Landforms)]
+필수 이미지 (4장)
+
+1. 해식애와 파식대 (Sea Cliff & Wave-cut Platform)
+   Filename: sea_cliff_erosion.jpg
+   Point: 절벽 밑이 파여 있고(Notch), 절벽 앞바다 바닥이 평평한(Platform) 그림.
+
+2. 시스택 형성 과정 (Sea Stack Evolution)
+   Filename: sea_stack_formation.jpg
+   Point: 동굴 → 아치 → 시스택 → 시스텀프 순서가 한 장에 그려진 그림.
+
+3. 해안 퇴적 지형 (Coastal Deposition)
+   Filename: sand_spit_bar_tombolo.jpg
+   Point: 사취(Spit), 사주(Bar), 육계사주(Tombolo), 석호(Lagoon)가 그려진 지도형 그림.
+
+4. 갯벌 단면 (Mudflat Profile)
+   Filename: tidal_flat_zonation.jpg
+   Point: 밀물/썰물 수위 표시(High/Low tide)와 갯벌의 경사가 그려진 단면도.
+
+---
+
+🦇 [Chapter 3. 카르스트 지형 (Karst Landforms)]
+필수 이미지 (4장)
+
+1. 탄산칼슘 용식 반응 (Chemical Weathering Reaction)
+   Filename: chemical_weathering_reaction.png
+   Point: CaCO₃ + H₂O + CO₂ ↔ Ca(HCO₃)₂ 화학식 및 모식도.
+
+2. 돌리네-우발라-폴리에 변화 (Doline Progression)
+   Filename: doline_uvala_polje_progression.jpg
+   Point: 돌리네에서 폴리에로 커지는 단계별 지도.
+
+3. 석회 동굴 내부 구조 (Cave Interior)
+   Filename: cave_interior_structure.jpg
+   Point: 종유석, 석순, 석주가 있는 동굴 내부 단면도.
+
+4. 탑 카르스트 (Tower Karst)
+   Filename: tower_karst_landscape.jpg
+   Point: 탑 카르스트의 지형적 특징 (하롱베이, 구이린 스타일).
+
+---
+
+🌋 [Chapter 4. 화산 지형 (Volcanic Landforms)]
+필수 이미지 (4장)
+
+1. 화산 형태 비교 (Volcano Shape by Viscosity)
+   Filename: volcano_shape_viscosity.png
+   Point: 순상 vs 성층 vs 종상 화산의 단면 비교도.
+
+2. 칼데라 형성 과정 (Caldera Formation)
+   Filename: caldera_formation_steps.gif
+   Point: 마그마 방 비움 → 붕괴 → 호수 형성 3단계.
+
+3. 주상절리 (Columnar Jointing)
+   Filename: columnar_jointing_hex.jpg
+   Point: 주상절리의 육각형 단면 및 측면 기둥 구조.
+
+4. 한국 화산 지형 지도 (Korea Volcanic Map)
+   Filename: korea_volcanic_map.png
+   Point: 백두산, 제주도, 울릉도, 철원 용암대지 위치 지도.
+
+---
+
+❄️ [Chapter 5. 빙하 지형 (Glacial Landforms)]
+필수 이미지 (4장)
+
+1. V자곡에서 U자곡으로 변형 (Valley Transformation)
+   Filename: valley_transformation_V_to_U.gif
+   Point: V자곡에서 U자곡으로 변형되는 3D 모델.
+
+2. 피오르 단면 (Fjord Cross-section)
+   Filename: fjord_cross_section.jpg
+   Point: 바닷물에 잠긴 U자곡 단면도.
+
+3. 빙퇴석 분급 불량 (Glacial Till Unsorted)
+   Filename: glacial_till_unsorted.png
+   Point: 빙퇴석의 뒤섞인 자갈 단면 - 분급 불량 예시.
+
+4. 드럼린과 빙하 이동 방향 (Drumlin Ice Flow)
+   Filename: drumlin_ice_flow.jpg
+   Point: 드럼린의 형태와 빙하 이동 방향 관계도.
+
+---
+
+🏜️ [Chapter 6. 건조 지형 (Arid Landforms)]
+필수 이미지 (4장)
+
+1. 바르한 사구와 바람 방향 (Barchan Dune)
+   Filename: barchan_dune_wind_direction.jpg
+   Point: 바르한 사구의 형태와 바람 방향 화살표.
+
+2. 선상지 구조 (Alluvial Fan in Arid)
+   Filename: alluvial_fan_structure.png
+   Point: 선상지의 선정, 선앙, 선단 단면도 및 입자 크기 분포.
+
+3. 메사-뷰트 침식 단계 (Mesa-Butte Evolution)
+   Filename: mesa_butte_evolution.jpg
+   Point: 고원 → 메사 → 뷰트 → 스파이어 침식 단계.
+
+4. 버섯바위 형성 (Mushroom Rock)
+   Filename: mushroom_rock_formation.gif
+   Point: 모래바람에 의한 하단부 침식 애니메이션.
+
+---
+
+🌾 [Chapter 7. 평야 지형 (Plain Landforms)]
+필수 이미지 (4장)
+
+1. 곡류 하천 진화 (Meandering River Evolution)
+   Filename: meandering_river_evolution.gif
+   Point: 곡류 하천이 우각호로 변하는 4단계 과정.
+
+2. 범람원 단면 (Floodplain Cross-section)
+   Filename: floodplain_cross_section.png
+   Point: 하도 - 자연제방 - 배후습지 단면도 및 토지 이용.
+
+3. 삼각주 유형 위성 사진 (Delta Types Satellite)
+   Filename: delta_types_satellite.jpg
+   Point: 나일강, 미시시피강, 갠지스강 삼각주 위성 사진 비교.
+
+4. 자연제방 vs 배후습지 토양 (Levee vs Backswamp Soil)
+   Filename: levee_vs_backswamp_soil.jpg
+   Point: 자연제방의 모래 vs 배후습지의 점토 입자 비교.
+
+---
+
+📊 [총계]
+- 하천 지형: 5장
+- 해안 지형: 4장
+- 카르스트 지형: 4장
+- 화산 지형: 4장
+- 빙하 지형: 4장
+- 건조 지형: 4장
+- 평야 지형: 4장
+- **총합: 29장**

pyproject.toml

@@ -0,0 +1,9 @@
+[tool.poetry]
+name = "geo-lab-ai"
+version = "1.0.0"
+description = "교육용 지형 시뮬레이션 - 하천 지형 모듈"
+authors = ["Geo-Lab Team"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.9"

requirements.txt

@@ -0,0 +1,6 @@
+streamlit>=1.28.0
+numpy>=1.24.0
+plotly>=5.18.0
+matplotlib>=3.7.0
+scipy>=1.11.0
+Pillow>=10.0.0

test_genesis.py

@@ -0,0 +1,51 @@
+import numpy as np
+from engine.grid import WorldGrid
+from engine.system import EarthSystem
+
+def test_fan_mechanism():
+    print("Testing Project Genesis Alluvial Fan Mechanism...")
+    
+    # 1. Setup Mini Grid (20x20)
+    grid = WorldGrid(width=20, height=20, cell_size=10.0)
+    
+    # Slope N->S
+    for r in range(20):
+        grid.bedrock[r, :] = 20.0 - r * 0.5 # 20m -> 10m
+        
+    grid.update_elevation()
+    
+    # 2. Setup Engine
+    engine = EarthSystem(grid)
+    engine.erosion.K = 0.001 # Low K to force deposition
+    
+    # 3. Step with sediment source
+    # Source at (2, 10)
+    source_y, source_x = 2, 10
+    amount = 100.0
+    
+    settings = {
+        'precipitation': 0.0,
+        'rain_source': (0, 10, 2, 10.0), # Rain at top
+        'sediment_source': (source_y, source_x, 1, amount) # Sediment at source
+    }
+    
+    print(f"Initial Max Sediment: {grid.sediment.max()}")
+    
+    # Run 10 steps
+    np.set_printoptions(precision=4, suppress=True)
+    for i in range(10):
+        engine.step(dt=1.0, settings=settings)
+        print(f"Step {i+1}:")
+        print(f"  Max Sediment: {grid.sediment.max():.6f}")
+        print(f"  Max Discharge: {grid.discharge.max():.6f}")
+        print(f"  Max Elev: {grid.elevation.max():.6f}")
+        
+    if grid.sediment.max() > 0:
+        print("SUCCESS: Sediment is depositing.")
+        print("Sample Sediment Grid (Center):")
+        print(grid.sediment[0:5, 8:13])
+    else:
+        print("FAILURE: No sediment deposited.")
+
+if __name__ == "__main__":
+    test_fan_mechanism()