Fix landform animations: barchan, U-valley, volcanoes, lava plateau; add Lab page, zone overlay

app/components/animation_renderer.py

@@ -0,0 +1,318 @@
+"""
+🎬 Plotly Animation Renderer
+부드러운 3D 지형 애니메이션 (카메라 유지)
+"""
+import numpy as np
+import plotly.graph_objects as go
+from typing import Callable
+
+
+def create_animated_terrain_figure(
+    landform_func: Callable,
+    grid_size: int = 80,
+    num_frames: int = 25,
+    title: str = "지형 형성 과정",
+    landform_type: str = "river"
+) -> go.Figure:
+    """Plotly 네이티브 애니메이션으로 부드러운 3D 지형 애니메이션 생성
+    
+    Args:
+        landform_func: 지형 생성 함수 (grid_size, stage) -> elevation
+        grid_size: 그리드 크기
+        num_frames: 애니메이션 프레임 수 (많을수록 부드러움)
+        title: 그래프 제목
+        landform_type: 지형 유형 (colorscale 결정)
+    
+    Returns:
+        go.Figure: 애니메이션이 포함된 Plotly Figure
+    """
+    h, w = grid_size, grid_size
+    x = np.arange(w)
+    y = np.arange(h)
+    
+    # 컬러스케일 설정
+    colorscale = _get_colorscale(landform_type)
+    
+    # 모든 프레임 미리 생성
+    frames = []
+    all_elevations = []
+    
+    for i in range(num_frames):
+        stage = i / (num_frames - 1)
+        
+        try:
+            # return_metadata 지원 여부 확인
+            result = landform_func(grid_size, stage)
+            if isinstance(result, tuple):
+                elevation = result[0]
+            else:
+                elevation = result
+        except:
+            elevation = landform_func(grid_size, stage)
+        
+        all_elevations.append(elevation)
+        
+        # Biome 계산 (간소화)
+        dy, dx = np.gradient(elevation)
+        slope = np.sqrt(dx**2 + dy**2)
+        biome = np.ones_like(elevation)  # 기본: 풀
+        biome[slope > 1.2] = 2  # 암석
+        biome[elevation < 5] = 0  # 물/모래
+        
+        frames.append(go.Frame(
+            data=[go.Surface(
+                z=elevation,
+                x=x, y=y,
+                surfacecolor=biome,
+                colorscale=colorscale,
+                cmin=0, cmax=3,
+                showscale=False,
+                lighting=dict(ambient=0.4, diffuse=0.5, roughness=0.9, specular=0.1)
+            )],
+            name=f"{int(stage * 100)}%"
+        ))
+    
+    # 초기 프레임 (stage=0)
+    initial_elevation = all_elevations[0]
+    dy, dx = np.gradient(initial_elevation)
+    slope = np.sqrt(dx**2 + dy**2)
+    initial_biome = np.ones_like(initial_elevation)
+    initial_biome[slope > 1.2] = 2
+    initial_biome[initial_elevation < 5] = 0
+    
+    fig = go.Figure(
+        data=[go.Surface(
+            z=initial_elevation,
+            x=x, y=y,
+            surfacecolor=initial_biome,
+            colorscale=colorscale,
+            cmin=0, cmax=3,
+            showscale=False,
+            lighting=dict(ambient=0.4, diffuse=0.5, roughness=0.9, specular=0.1)
+        )],
+        frames=frames
+    )
+    
+    # 슬라이더 (프레임 이동용)
+    sliders = [{
+        'active': 0,
+        'yanchor': 'top',
+        'xanchor': 'left',
+        'currentvalue': {
+            'font': {'size': 14, 'color': 'white'},
+            'prefix': '형성 단계: ',
+            'suffix': '',
+            'visible': True,
+            'xanchor': 'center'
+        },
+        'transition': {'duration': 50, 'easing': 'cubic-in-out'},
+        'pad': {'b': 10, 't': 50},
+        'len': 0.9,
+        'x': 0.05,
+        'y': 0,
+        'steps': [
+            {
+                'args': [[f.name], {'frame': {'duration': 50, 'redraw': True}, 'mode': 'immediate', 'transition': {'duration': 50}}],
+                'label': f.name,
+                'method': 'animate'
+            }
+            for f in frames
+        ]
+    }]
+    
+    # 재생/정지 버튼
+    updatemenus = [{
+        'type': 'buttons',
+        'showactive': False,
+        'y': 1.15,
+        'x': 0.05,
+        'xanchor': 'left',
+        'yanchor': 'top',
+        'pad': {'t': 0, 'r': 10},
+        'buttons': [
+            {
+                'label': '▶️ 재생',
+                'method': 'animate',
+                'args': [
+                    None,
+                    {
+                        'frame': {'duration': 150, 'redraw': True},
+                        'fromcurrent': True,
+                        'transition': {'duration': 100, 'easing': 'quadratic-in-out'}
+                    }
+                ]
+            },
+            {
+                'label': '⏸️ 정지',
+                'method': 'animate',
+                'args': [
+                    [None],
+                    {
+                        'frame': {'duration': 0, 'redraw': False},
+                        'mode': 'immediate',
+                        'transition': {'duration': 0}
+                    }
+                ]
+            },
+            {
+                'label': '⏮️ 처음',
+                'method': 'animate',
+                'args': [
+                    ['0%'],
+                    {
+                        'frame': {'duration': 0, 'redraw': True},
+                        'mode': 'immediate',
+                        'transition': {'duration': 0}
+                    }
+                ]
+            }
+        ]
+    }]
+    # 지형 유형별 최적 카메라 각도
+    camera_settings = _get_optimal_camera(landform_type)
+    
+    # 레이아웃
+    fig.update_layout(
+        title=dict(text=title, font=dict(color='white', size=16)),
+        scene=dict(
+            xaxis=dict(title='X (m)', backgroundcolor='#1a1a2e', gridcolor='#444', color='#cccccc'),
+            yaxis=dict(title='Y (m)', backgroundcolor='#1a1a2e', gridcolor='#444', color='#cccccc'),
+            zaxis=dict(title='Elevation', backgroundcolor='#1a1a2e', gridcolor='#444', color='#cccccc'),
+            bgcolor='#0e1117',
+            camera=camera_settings,
+            aspectmode='manual',
+            aspectratio=dict(x=1, y=1, z=0.4)
+        ),
+        paper_bgcolor='#0e1117',
+        plot_bgcolor='#0e1117',
+        height=700,
+        margin=dict(l=10, r=10, t=80, b=80),
+        updatemenus=updatemenus,
+        sliders=sliders
+    )
+    
+    return fig
+
+
+def _get_colorscale(landform_type: str):
+    """지형 유형에 따른 컬러스케일 반환"""
+    if landform_type == 'glacial':
+        return [
+            [0.0, '#4682B4'], [0.33, '#4682B4'],
+            [0.33, '#556B2F'], [0.66, '#556B2F'],
+            [0.66, '#808080'], [1.0, '#E0FFFF']
+        ]
+    elif landform_type in ['river', 'coastal']:
+        return [
+            [0.0, '#4682B4'], [0.33, '#4682B4'],
+            [0.33, '#556B2F'], [0.66, '#556B2F'],
+            [0.66, '#808080'], [1.0, '#D2B48C']
+        ]
+    elif landform_type == 'arid':
+        return [
+            [0.0, '#EDC9AF'], [0.33, '#EDC9AF'],
+            [0.33, '#CD853F'], [0.66, '#CD853F'],
+            [0.66, '#808080'], [1.0, '#DAA520']
+        ]
+    else:
+        return [
+            [0.0, '#E6C288'], [0.33, '#E6C288'],
+            [0.33, '#556B2F'], [0.66, '#556B2F'],
+            [0.66, '#808080'], [1.0, '#A0522D']
+        ]
+
+
+def _get_optimal_camera(landform_type: str) -> dict:
+    """지형 유형별 최적 카메라 각도 반환
+    
+    각 지형 유형의 형성 과정이 잘 보이는 각도로 설정
+    """
+    if landform_type == 'river':
+        # 하천/선상지: 산쪽(상류)에서 평지(하류) 방향으로 내려다봄
+        # 선상지가 부채꼴로 펼쳐지는 모습이 잘 보이는 각도
+        return dict(
+            eye=dict(x=-0.3, y=-2.2, z=1.8),
+            center=dict(x=0, y=0.2, z=-0.2),
+            up=dict(x=0, y=0, z=1)
+        )
+    elif landform_type == 'glacial':
+        # 빙하: 위에서 내려다보는 각도로 U자곡/권곡 잘 보이게
+        return dict(
+            eye=dict(x=0.8, y=-1.5, z=1.5),
+            center=dict(x=0, y=0, z=-0.2),
+            up=dict(x=0, y=0, z=1)
+        )
+    elif landform_type == 'volcanic':
+        # 화산: 측면에서 봐서 산체 형태 잘 보이게
+        return dict(
+            eye=dict(x=1.8, y=-1.2, z=0.8),
+            center=dict(x=0, y=0, z=0),
+            up=dict(x=0, y=0, z=1)
+        )
+    elif landform_type == 'coastal':
+        # 해안: 바다→육지 방향으로 절벽 잘 보이게
+        return dict(
+            eye=dict(x=0.5, y=2.0, z=0.8),
+            center=dict(x=0, y=0, z=-0.1),
+            up=dict(x=0, y=0, z=1)
+        )
+    elif landform_type == 'arid':
+        # 건조: 사구 형태 잘 보이게 낮은 각도
+        return dict(
+            eye=dict(x=2.0, y=-1.0, z=0.6),
+            center=dict(x=0, y=0, z=-0.1),
+            up=dict(x=0, y=0, z=1)
+        )
+    elif landform_type == 'karst':
+        # 카르스트: 위에서 돌리네/우발라 잘 보이게
+        return dict(
+            eye=dict(x=1.0, y=-1.0, z=1.8),
+            center=dict(x=0, y=0, z=-0.2),
+            up=dict(x=0, y=0, z=1)
+        )
+    else:
+        # 기본값: 대각선 방향
+        return dict(
+            eye=dict(x=1.5, y=-1.5, z=1.0),
+            center=dict(x=0, y=0, z=-0.1),
+            up=dict(x=0, y=0, z=1)
+        )
+
+
+def get_multi_angle_cameras() -> dict:
+    """다중 시점 카메라 프리셋
+    
+    X축(정면), Y축(측면), Z축(평면도), 등각투영 4가지 시점
+    """
+    return {
+        "🎯 등각 (기본)": dict(
+            eye=dict(x=1.5, y=-1.5, z=1.2),
+            center=dict(x=0, y=0, z=-0.1),
+            up=dict(x=0, y=0, z=1)
+        ),
+        "➡️ X축 (측면)": dict(
+            eye=dict(x=2.5, y=0, z=0.3),
+            center=dict(x=0, y=0, z=0),
+            up=dict(x=0, y=0, z=1)
+        ),
+        "⬆️ Y축 (정면)": dict(
+            eye=dict(x=0, y=-2.5, z=0.3),
+            center=dict(x=0, y=0, z=0),
+            up=dict(x=0, y=0, z=1)
+        ),
+        "⬇️ Z축 (평면도)": dict(
+            eye=dict(x=0, y=0, z=2.5),
+            center=dict(x=0, y=0, z=0),
+            up=dict(x=0, y=1, z=0)
+        ),
+        "🔄 대각선 낮음": dict(
+            eye=dict(x=2.0, y=-2.0, z=0.5),
+            center=dict(x=0, y=0, z=-0.1),
+            up=dict(x=0, y=0, z=1)
+        ),
+        "🌄 상류→하류": dict(
+            eye=dict(x=-0.3, y=-2.5, z=1.5),
+            center=dict(x=0, y=0.2, z=-0.2),
+            up=dict(x=0, y=0, z=1)
+        )
+    }

engine/ideal_landforms.py

@@ -722,80 +722,150 @@ def create_meander_animated(grid_size: int, stage: float,
 
 
 def create_u_valley_animated(grid_size: int, stage: float,
-                              valley_depth: float = 100.0, valley_width: float = 0.4) -> np.ndarray:
-    """U자곡 형성과정 (빙하 성장 → 침식 → 빙하 후퇴 → U자곡)
+                              valley_depth: float = 100.0, valley_width: float = 0.4,
+                              return_metadata: bool = False) -> np.ndarray:
+    """U자곡 형성과정 (V자곡 → 빙하 침식 → U자곡 노출)
     
-    Stage 0.0~0.3: 빙하 성장 (V자곡에 빙하 채워짐)
-    Stage 0.3~0.6: 빙하 침식 (U자 형태로 변형)
-    Stage 0.6~1.0: 빙하 후퇴 (빙하 녹으면서 U자곡 드러남)
+    Stage 0~0.2: V자곡 상태 (하천 침식에 의해 형성된 초기 계곡)
+    Stage 0.2~0.5: 빙하 채워짐 + 침식 시작 (플러킹, 마식)
+    Stage 0.5~0.8: U자 형태 발달 (바닥 넓어짐, 벽 급경사)
+    Stage 0.8~1.0: 빙하 후퇴 → U자곡 드러남 + 현수곡 + 빙하호
+    
+    핵심 과정:
+    - 플러킹(Plucking): 암석 파쇄 후 운반
+    - 마식(Abrasion): 빙하 바닥 연마
+    - 현수곡(Hanging Valley): 지류 빙하가 덜 침식
     """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
     center = w // 2
     
-    # 1단계: V자곡 → U자곡 변형 (침식)
-    if stage < 0.6:
-        u_factor = min(stage / 0.6, 1.0)  # 0~1로 정규화
+    # Stage에 따른 U자 변형 정도
+    if stage < 0.2:
+        # V자곡 상태
+        u_transform = 0
+        glacier_visible = False
+    elif stage < 0.5:
+        # 빙하 성장 + 초기 침식
+        u_transform = (stage - 0.2) / 0.3 * 0.5
+        glacier_visible = True
+    elif stage < 0.8:
+        # U자 형태 발달
+        u_transform = 0.5 + (stage - 0.5) / 0.3 * 0.5
+        glacier_visible = True
     else:
-        u_factor = 1.0  # 완전 U자
+        # 빙하 후퇴, U자곡 노출
+        u_transform = 1.0
+        glacier_visible = False
     
-    half_width = int(w * valley_width / 2) * u_factor  # U 바닥 너비
+    # U자 바닥 너비 (점차 넓어짐)
+    floor_width = int(w * valley_width * 0.3 * u_transform)
     
+    # 기본 지형 생성
     for r in range(h):
+        # 상류로 갈수록 기반 높아짐
+        base_height = (h - r) / h * 40.0
+        
         for c in range(w):
             dx = abs(c - center)
             
-            if dx < half_width:
-                # U자 바닥
-                elevation[r, c] = 0
+            # V자곡 → U자곡 단면 변형
+            if dx < floor_width:
+                # U자 바닥 (평탄)
+                valley_floor = 0
             else:
-                # V에서 U로 전환
-                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 - u_factor) + u_height * u_factor
+                # 벽면
+                wall_dist = (dx - floor_width) / max(1, w // 2 - floor_width)
                 
-        # 상류로 갈수록 높아짐
-        elevation[r, :] += (h - r) / h * 30.0
-    
-    # 2단계: 빙하 추가 (stage에 따라 성장/후퇴)
-    # stage 0~0.3: 빙하 성장 (하류로 전진)
-    # stage 0.3~0.6: 최대 범위
-    # stage 0.6~1.0: 빙하 후퇴 (상류로 후퇴)
-    
-    glacier_grid = np.zeros((h, w))
+                # V자 단면 (삼각형)
+                v_profile = valley_depth * wall_dist
+                
+                # U자 단면 (포물선)
+                u_profile = valley_depth * (wall_dist ** 0.5)
+                
+                # 변환 적용
+                valley_floor = v_profile * (1 - u_transform) + u_profile * u_transform
+            
+            elevation[r, c] = base_height + valley_floor
     
-    if stage < 0.3:
-        # 빙하 성장: 상류에서 하류로 전진
-        glacier_extent = int(h * (stage / 0.3) * 0.8)  # 최대 80%까지 전진
-        glacier_start = 0
-        glacier_end = glacier_extent
-    elif stage < 0.6:
-        # 최대 빙하 범위
-        glacier_start = 0
-        glacier_end = int(h * 0.8)
-    else:
-        # 빙하 후퇴
-        retreat_factor = (stage - 0.6) / 0.4
-        glacier_start = int(h * 0.8 * retreat_factor)  # 하류에서 녹음
-        glacier_end = int(h * 0.8 * (1 - retreat_factor * 0.5))  # 상류도 줄어듦
+    # 현수곡 (Hanging Valley) - stage 0.6 이후 시각화
+    if stage > 0.6:
+        hanging_valleys = [
+            (int(h * 0.3), -1),  # 좌측 현수곡
+            (int(h * 0.6), 1),   # 우측 현수곡
+        ]
+        
+        for hy, side in hanging_valleys:
+            hx = center + side * int(w * 0.35)
+            hang_height = 30.0 * u_transform  # 현수 높이
+            
+            for dy in range(-10, 11):
+                for dx in range(-8, 9):
+                    r, c = hy + dy, hx + dx
+                    if 0 <= r < h and 0 <= c < w:
+                        dist = np.sqrt(dy**2 + dx**2)
+                        if dist < 10:
+                            # 현수곡 입구 (높게 매달림)
+                            notch = 10.0 * (1 - dist / 10)
+                            elevation[r, c] = max(elevation[r, c], hang_height + notch)
+    
+    # 빙하 시각화 (채움)
+    if glacier_visible:
+        glacier_progress = min(1.0, (stage - 0.2) / 0.6)
+        glacier_end = int(h * 0.85 * glacier_progress)
+        glacier_thickness = 25.0 * glacier_progress
+        
+        for r in range(glacier_end):
+            for c in range(w):
+                dx = abs(c - center)
+                if dx < floor_width + 10:
+                    # 빙하 볼록 표면
+                    ice_surface = glacier_thickness * (1 - (dx / (floor_width + 10)) ** 2)
+                    if stage < 0.8:
+                        elevation[r, c] += ice_surface
+    
+    # 빙하호(Tarn) - 빙하 후퇴 후
+    if stage > 0.85:
+        tarn_progress = (stage - 0.85) / 0.15
+        tarn_y = int(h * 0.15)
+        tarn_radius = int(w * 0.12 * tarn_progress)
+        
+        for dy in range(-tarn_radius, tarn_radius + 1):
+            for dx in range(-tarn_radius, tarn_radius + 1):
+                r, c = tarn_y + dy, center + dx
+                if 0 <= r < h and 0 <= c < w:
+                    dist = np.sqrt(dy**2 + dx**2)
+                    if dist < tarn_radius:
+                        # 호수 바닥
+                        elevation[r, c] = min(elevation[r, c], -5.0 * (1 - dist / tarn_radius))
     
-    # 빙하 표시 (골짜기 채움)
-    for r in range(glacier_start, min(glacier_end, h)):
-        for c in range(w):
-            dx = abs(c - center)
-            if dx < half_width + 5:  # U자곡 바닥 + 약간 넓게
-                glacier_thickness = 20.0 * (1 - abs(c - center) / (half_width + 5))
-                if stage < 0.6:
-                    elevation[r, c] += glacier_thickness
-                else:
-                    # 후퇴 중: 빙하 높이 감소
-                    retreat_factor = (stage - 0.6) / 0.4
-                    elevation[r, c] += glacier_thickness * (1 - retreat_factor)
+    if return_metadata:
+        return elevation, {
+            'u_transform': u_transform,
+            'glacier_visible': glacier_visible,
+            'floor_width': floor_width,
+            'stage_description': _get_u_valley_stage_desc(stage)
+        }
     
     return elevation
 
 
+def _get_u_valley_stage_desc(stage: float) -> str:
+    """U자곡 단계별 설명"""
+    if stage < 0.15:
+        return "🏞️ V자곡 상태: 하천 침식에 의한 초기 계곡"
+    elif stage < 0.35:
+        return "❄️ 빙하 성장: 계곡에 빙하 채워짐"
+    elif stage < 0.55:
+        return "⛏️ 빙하 침식: 플러킹 + 마식 → 바닥 확장"
+    elif stage < 0.75:
+        return "🗻 U자 형태: 평탄 바닥 + 급경사 벽"
+    elif stage < 0.9:
+        return "🌊 빙하 후퇴: 현수곡(Hanging Valley) 드러남"
+    else:
+        return "💧 빙하호(Tarn): 빙하 융해수 고임"
+
+
 def create_coastal_cliff_animated(grid_size: int, stage: float,
                                    cliff_height: float = 30.0, num_stacks: int = 2) -> np.ndarray:
     """해안 절벽 후퇴 과정"""
@@ -880,15 +950,18 @@ def create_v_valley_animated(grid_size: int, stage: float,
 
 
 def create_barchan_animated(grid_size: int, stage: float,
-                             num_dunes: int = 3) -> np.ndarray:
-    """바르한 사구 이동 애니메이션
-    
-    위에서 볼 때 초승달(🌙) 모양:
-    - 볼록면(convex): 바람 불어오는 쪽 (상단)
-    - 오목면(concave): 바람 가는 쪽 (하단) + 뿔
-    - 뿔(horns): 바람 방향으로 뻗음
-    
-    바람 방향: 위 → 아래
+                             num_dunes: int = 3, return_metadata: bool = False) -> np.ndarray:
+    """바르한 사구 형성 과정 애니메이션
+    
+    Stage 0~0.25: 모래 축적 (작은 원형 언덕 형성)
+    Stage 0.25~0.5: 비대칭 발달 (바람받이 완경사, 바람그늘 급경사)
+    Stage 0.5~0.75: 초승달 형태 발달 (오목면 형성)
+    Stage 0.75~1.0: 뿔(horn) 완성 (바람 방향으로 연장)
+    
+    형성 원리:
+    - 바람이 모래를 바람받이 사면으로 운반
+    - 정상 넘어 바람그늘에 퇴적 (낙사면, slip face)
+    - 가장자리 모래가 더 빨리 이동 → 뿔 형성
     """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
@@ -898,75 +971,127 @@ def create_barchan_animated(grid_size: int, stage: float,
     
     np.random.seed(42)
     
-    # 사구 이동
-    move_distance = int(h * 0.5 * stage)
-    
     for i in range(num_dunes):
-        # 위치
-        initial_y = h // 5 + i * (h // (num_dunes + 1))
+        # 사구 위치 (고정)
         cx = w // 4 + (i % 2) * (w // 2)
-        cy = initial_y + move_distance
+        cy = int(h * 0.3) + i * (h // (num_dunes + 1))
         
-        if cy >= h - 20:
+        if cy >= h - 15:
             continue
         
-        # 사구 크기
-        dune_height = 10.0 + i * 2.0
-        outer_r = w // 7  # 바깥 원 반지름
-        inner_r = outer_r * 0.6  # 안쪽 원 반지름
-        inner_offset = outer_r * 0.5  # 안쪽 원 오프셋 (아래로)
+        # Stage에 따른 크기 발달
+        max_height = 12.0 + i * 3.0
+        max_radius = int(w * 0.12)
+        
+        # Stage 0~0.25: 작은 원형 언덕
+        if stage < 0.25:
+            progress = stage / 0.25
+            current_height = max_height * 0.3 * progress
+            current_radius = int(max_radius * 0.4 * progress)
+            asymmetry = 0  # 대칭
+            horn_length = 0
+            
+        # Stage 0.25~0.5: 비대칭 발달
+        elif stage < 0.5:
+            progress = (stage - 0.25) / 0.25
+            current_height = max_height * (0.3 + 0.4 * progress)
+            current_radius = int(max_radius * (0.4 + 0.3 * progress))
+            asymmetry = progress  # 점차 비대칭
+            horn_length = 0
+            
+        # Stage 0.5~0.75: 초승달 형태
+        elif stage < 0.75:
+            progress = (stage - 0.5) / 0.25
+            current_height = max_height * (0.7 + 0.2 * progress)
+            current_radius = int(max_radius * (0.7 + 0.2 * progress))
+            asymmetry = 1.0
+            horn_length = int(max_radius * 0.4 * progress)
+            
+        # Stage 0.75~1.0: 뿔 완성
+        else:
+            progress = (stage - 0.75) / 0.25
+            current_height = max_height * (0.9 + 0.1 * progress)
+            current_radius = max_radius
+            asymmetry = 1.0
+            horn_length = int(max_radius * (0.4 + 0.4 * progress))
+        
+        if current_radius < 2:
+            continue
+            
+        # 초승달 파라미터
+        inner_ratio = 0.5 + 0.2 * asymmetry  # 안쪽 원 비율
+        inner_offset = current_radius * 0.4 * asymmetry  # 오프셋
         
         for r in range(h):
             for c in range(w):
                 dy = r - cy
                 dx = c - cx
                 
-                # 바깥 원 (볼록면 - 상단)
-                dist_outer = np.sqrt(dx**2 + dy**2)
-                
-                # 안쪽 원 (오목면 - 하단으로 오프셋)
-                dist_inner = np.sqrt(dx**2 + (dy - inner_offset)**2)
-                
-                # 초승달 영역: 바깥 원 안 AND 안쪽 원 밖
-                in_crescent = (dist_outer < outer_r) and (dist_inner > inner_r)
+                dist = np.sqrt(dx**2 + dy**2)
                 
-                if in_crescent:
-                    # 높이 계산: 중심에서 멀수록 낮아짐
-                    height_factor = 1 - (dist_outer / outer_r)
+                # 바깥 원 영역
+                if dist < current_radius:
+                    # 안쪽 원 (오목면) - 비대칭일 때만
+                    dist_inner = np.sqrt(dx**2 + (dy - inner_offset)**2)
+                    inner_r = current_radius * inner_ratio
+                    
+                    if asymmetry > 0.5 and dist_inner < inner_r:
+                        # 오목면 안쪽은 낮게
+                        continue
                     
-                    # 바람받이(상단) 완만, 바람그늘(하단) 급
+                    # 높이 계산
+                    radial_factor = 1 - (dist / current_radius) ** 1.5
+                    
+                    # 바람받이(상단) vs 바람그늘(하단) 비대칭
                     if dy < 0:
-                        # 바람받이: 완만한 경사
-                        slope = height_factor * 0.8
+                        # 바람받이: 완만 (5-12° 경사)
+                        slope_factor = 0.6 + 0.4 * (1 - asymmetry)
                     else:
-                        # 바람그늘: 더 높게 (급경사 효과)
-                        slope = height_factor * 1.2
+                        # 바람그늘: 급경사 (30-34° 안식각)
+                        slope_factor = 0.8 + 0.5 * asymmetry
                     
-                    z = dune_height * slope
-                    elevation[r, c] = max(elevation[r, c], 5.0 + z)
-                
-                # 뿔 (horn) - 양쪽으로 바람 방향으로 뻗음
-                horn_width = outer_r * 0.3
-                horn_length = outer_r * 0.8
+                    z = current_height * radial_factor * slope_factor
+                    if z > 0.5:
+                        elevation[r, c] = max(elevation[r, c], 5.0 + z)
                 
-                for side in [-1, 1]:  # 왼쪽, 오른쪽 뿔
-                    horn_cx = cx + side * (outer_r - horn_width)
-                    horn_cy = cy + inner_offset
-                    
-                    dx_horn = c - horn_cx
-                    dy_horn = r - horn_cy
-                    
-                    # 뿔 영역 (바람 방향으로 길쭉)
-                    if abs(dx_horn) < horn_width and 0 < dy_horn < horn_length:
-                        # 뿔 높이: 끝으로 갈수록 낮아짐
-                        horn_factor = 1 - dy_horn / horn_length
-                        width_factor = 1 - abs(dx_horn) / horn_width
-                        z = dune_height * 0.5 * horn_factor * width_factor
+                # 뿔 (horns) - stage 0.5 이후
+                if horn_length > 2:
+                    for side in [-1, 1]:
+                        horn_cx = cx + side * (current_radius * 0.7)
+                        horn_cy = cy + inner_offset
+                        
+                        dx_h = c - horn_cx
+                        dy_h = r - horn_cy
                         
-                        if z > 0.3:
-                            elevation[r, c] = max(elevation[r, c], 5.0 + z)
+                        # 뿔 영역: 바람 방향으로 길쭉
+                        horn_width = max(2, current_radius * 0.25)
+                        if abs(dx_h) < horn_width and 0 < dy_h < horn_length:
+                            horn_factor = (1 - dy_h / horn_length) ** 0.7
+                            width_factor = 1 - (abs(dx_h) / horn_width) ** 2
+                            z = current_height * 0.4 * horn_factor * width_factor
+                            if z > 0.3:
+                                elevation[r, c] = max(elevation[r, c], 5.0 + z)
+    
+    if return_metadata:
+        return elevation, {
+            'stage_description': _get_barchan_stage_desc(stage)
+        }
     
     return elevation
+
+
+def _get_barchan_stage_desc(stage: float) -> str:
+    """바르한 단계별 설명"""
+    if stage < 0.2:
+        return "🏜️ 모래 축적: 장애물 주변 모래 쌓임 시작"
+    elif stage < 0.4:
+        return "⬆️ 언덕 성장: 원형 모래언덕 형성"
+    elif stage < 0.6:
+        return "↗️ 비대칭 발달: 바람받이 완경사, 바람그늘 급경사"
+    elif stage < 0.8:
+        return "🌙 초승달 형태: 오목면 형성, 뿔 발달 시작"
+    else:
+        return "🏜️ 바르한 완성: 뿔이 바람 방향으로 연장"
 # ============================================
 # 확장 지형 (Extended Landforms)
 # ============================================
@@ -1605,88 +1730,318 @@ def _get_horn_stage_desc(stage: float) -> str:
 
 
 def create_shield_volcano(grid_size: int = 100, stage: float = 1.0,
-                          max_height: float = 40.0) -> np.ndarray:
-    """순상화산 (Shield Volcano) - 완만한 경사"""
+                          max_height: float = 40.0, return_metadata: bool = False) -> np.ndarray:
+    """순상화산 (Shield Volcano) - 하와이형
+    
+    Stage 0~0.3: 해저 분출 → 해수면 도달
+    Stage 0.3~0.6: 용암류 반복 → 완만한 순상 형성
+    Stage 0.6~0.8: 정상부 확장 + 중앙 화구 형성
+    Stage 0.8~1.0: 정상 칼데라 + 용암 흐름 흔적
+    
+    특징:
+    - 현무암질 용암 (유동성 높음)
+    - 경사 5-10°
+    - 용암류가 넓게 퍼짐
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
     
     center = (h // 2, w // 2)
-    radius = w // 2
+    max_radius = int(w * 0.45)
+    
+    # Stage에 따른 반경 성장
+    current_radius = int(max_radius * min(1.0, stage * 1.3))
+    current_height = max_height * stage
     
     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
+            if dist < current_radius and current_radius > 0:
+                # 완만한 포물선 형태 (경사 5-10도)  
+                radial_factor = 1 - (dist / current_radius) ** 1.8
+                elevation[r, c] = current_height * radial_factor
+    
+    # 용암류 흔적 (방사상) - stage 0.4 이후
+    if stage > 0.4:
+        np.random.seed(42)
+        num_flows = 6
+        for i in range(num_flows):
+            angle = 2 * np.pi * i / num_flows + np.random.random() * 0.3
+            flow_length = int(current_radius * (0.6 + 0.4 * stage))
+            flow_width = 3 + int(2 * stage)
+            
+            for d in range(10, flow_length):
+                fx = int(center[1] + d * np.cos(angle))
+                fy = int(center[0] + d * np.sin(angle))
                 
+                for dw in range(-flow_width, flow_width + 1):
+                    tx = int(fx + dw * np.sin(angle))
+                    ty = int(fy - dw * np.cos(angle))
+                    
+                    if 0 <= ty < h and 0 <= tx < w:
+                        # 용암류 융기
+                        flow_height = 2.0 * (1 - abs(dw) / flow_width) * (1 - d / flow_length)
+                        elevation[ty, tx] += flow_height
+    
+    # 정상부 화구/칼데라 - stage 0.6 이후
+    if stage > 0.6:
+        caldera_progress = (stage - 0.6) / 0.4
+        crater_radius = int(max_radius * 0.08 * (1 + caldera_progress))
+        crater_depth = 5.0 * caldera_progress
+        
+        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:
+                    # 함몰 칼데라
+                    depression = crater_depth * (1 - (dist / crater_radius) ** 2)
+                    elevation[r, c] = max(elevation[r, c] - depression, current_height * 0.85)
+    
+    if return_metadata:
+        return elevation, {
+            'current_radius': current_radius,
+            'current_height': current_height,
+            'stage_description': _get_shield_stage_desc(stage)
+        }
+    
     return elevation
 
 
+def _get_shield_stage_desc(stage: float) -> str:
+    """순상화산 단계별 설명"""
+    if stage < 0.2:
+        return "🌋 해저 분출: 현무암 용암 분출 시작"
+    elif stage < 0.4:
+        return "🏝️ 해수면 도달: 화산섬 형성"
+    elif stage < 0.6:
+        return "🔥 용암류 확장: 파호이호이 용암 흐름"
+    elif stage < 0.8:
+        return "⛰️ 순상 형성: 완만한 경사 (5-10°)"
+    else:
+        return "🕳️ 정상 칼데라: 마그마 빠짐 → 함몰"
+
+
 def create_stratovolcano(grid_size: int = 100, stage: float = 1.0,
-                         max_height: float = 80.0) -> np.ndarray:
-    """성층화산 (Stratovolcano) - 급한 원뿔형"""
+                         max_height: float = 80.0, return_metadata: bool = False) -> np.ndarray:
+    """성층화산 (Stratovolcano) - 복합화산
+    
+    Stage 0~0.25: 초기 분출 → 원뿔 형성 시작
+    Stage 0.25~0.5: 용암+화쇄물 교대 → 급경사 원뿔
+    Stage 0.5~0.75: 고도 상승 + 분화구 발달
+    Stage 0.75~1.0: 정상 분화구 + 화산쇄설물 사면
+    
+    특징:
+    - 안산암질/유문암질 마그마
+    - 경사 25-35°
+    - 용암류 + 화쇄류 교대층
+    """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
     
     center = (h // 2, w // 2)
-    radius = int(w * 0.4)
+    max_radius = int(w * 0.4)
+    
+    # Stage에 따른 성장
+    current_radius = int(max_radius * min(1.0, stage * 1.2))
+    current_height = max_height * stage
     
     for r in range(h):
         for c in range(w):
             dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
             
-            if dist < radius:
+            if dist < current_radius and current_radius > 0:
                 # 급한 원뿔 (경사 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
-                
+                radial_factor = 1 - (dist / current_radius) ** 0.8
+                elevation[r, c] = current_height * radial_factor
+    
+    # 층리 표현 (작은 요철) - stage 0.3 이후
+    if stage > 0.3:
+        np.random.seed(42)
+        num_layers = int(5 * stage)
+        for layer in range(num_layers):
+            layer_radius = current_radius * (0.3 + 0.7 * layer / max(1, num_layers))
+            layer_height = current_height * (0.2 + 0.6 * layer / max(1, num_layers))
+            
+            for r in range(h):
+                for c in range(w):
+                    dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+                    if abs(dist - layer_radius) < 3:
+                        # 층리 경계에 약간의 요철
+                        bump = 1.5 * np.sin(np.arctan2(r - center[0], c - center[1]) * 8)
+                        elevation[r, c] += bump
+    
+    # 정상부 분화구 - stage 0.5 이후
+    if stage > 0.5:
+        crater_progress = (stage - 0.5) / 0.5
+        crater_radius = int(max_radius * 0.06 * (1 + crater_progress * 0.5))
+        crater_depth = 12.0 * crater_progress
+        
+        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:
+                    # 분화구
+                    if dist < crater_radius * 0.7:
+                        elevation[r, c] = current_height - crater_depth
+                    else:
+                        # 분화구 테두리
+                        rim_factor = (dist - crater_radius * 0.7) / (crater_radius * 0.3)
+                        elevation[r, c] = current_height - crater_depth + crater_depth * rim_factor
+    
+    if return_metadata:
+        return elevation, {
+            'current_height': current_height,
+            'stage_description': _get_strato_stage_desc(stage)
+        }
+    
     return elevation
 
 
+def _get_strato_stage_desc(stage: float) -> str:
+    """성층화산 단계별 설명"""
+    if stage < 0.2:
+        return "🌋 초기 분출: 화산쇄설물 분출"
+    elif stage < 0.4:
+        return "🔥 원뿔 형성: 용암 + 화쇄류 교대"
+    elif stage < 0.6:
+        return "⛰️ 급경사 발달: 성층 구조 형성"
+    elif stage < 0.8:
+        return "🗻 고도 상승: 분화구 발달"
+    else:
+        return "💨 정상 분화구: 분연 활동 가능"
+
+
 def create_caldera(grid_size: int = 100, stage: float = 1.0,
-                   rim_height: float = 50.0) -> np.ndarray:
-    """칼데라 (Caldera) - 화구 함몰"""
+                   rim_height: float = 50.0, return_metadata: bool = False) -> np.ndarray:
+    """칼데라 (Caldera) - 화산 정상부 함몰
+    
+    Stage 0~0.3: 성층화산 성장 (분화 활동)
+    Stage 0.3~0.5: 대분화 → 마그마방 공동화
+    Stage 0.5~0.8: 정상부 함몰 (칼데라 형성)
+    Stage 0.8~1.0: 칼데라 확장 + 호수 형성 (백두산 천지)
+    
+    핵심 과정:
+    - 마그마방 비워짐 → 지지력 상실
+    - 정상부 함몰 → 넓은 원형 분지
+    - 칼데라 직경 수 km ~ 수십 km
+    """
     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)
+    max_outer = int(w * 0.45)
     
-    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
+    if stage < 0.3:
+        # Stage 0~0.3: 성층화산 성장
+        progress = stage / 0.3
+        volcano_height = rim_height * 1.5 * progress
+        volcano_radius = int(max_outer * 0.8 * progress)
+        
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+                if dist < volcano_radius and volcano_radius > 0:
+                    # 성층화산 형태
+                    elevation[r, c] = volcano_height * (1 - (dist / volcano_radius) ** 0.9)
+        
+        # 작은 분화구
+        crater_r = max(2, int(volcano_radius * 0.08))
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+                if dist < crater_r:
+                    elevation[r, c] = volcano_height * 0.85
                     
+    elif stage < 0.5:
+        # Stage 0.3~0.5: 대분화 시작, 함몰 시작
+        progress = (stage - 0.3) / 0.2
+        volcano_height = rim_height * 1.5
+        collapse_depth = rim_height * 0.5 * progress
+        collapse_radius = int(max_outer * 0.15 * (1 + progress))
+        
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+                if dist < max_outer * 0.8:
+                    # 화산체
+                    base = volcano_height * (1 - (dist / (max_outer * 0.8)) ** 0.9)
+                    
+                    if dist < collapse_radius:
+                        # 함몰 시작
+                        elevation[r, c] = base - collapse_depth * (1 - (dist / collapse_radius) ** 2)
+                    else:
+                        elevation[r, c] = base
+                        
+    elif stage < 0.8:
+        # Stage 0.5~0.8: 칼데라 확장
+        progress = (stage - 0.5) / 0.3
+        caldera_radius = int(max_outer * (0.2 + 0.25 * progress))  # 점점 넓어짐
+        collapse_depth = rim_height * (0.5 + 0.4 * progress)
+        
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+                
+                if dist < max_outer:
+                    if dist < caldera_radius:
+                        # 칼데라 바닥 (평탄)
+                        elevation[r, c] = rim_height * 1.5 - collapse_depth
+                    else:
+                        # 칼데라 벽 + 외륜산
+                        wall_progress = (dist - caldera_radius) / (max_outer - caldera_radius)
+                        if wall_progress < 0.3:
+                            # 급경사 벽
+                            elevation[r, c] = (rim_height * 1.5 - collapse_depth) + rim_height * 0.8 * (wall_progress / 0.3)
+                        else:
+                            # 외륜산 사면
+                            elevation[r, c] = rim_height * (1 - (wall_progress - 0.3) / 0.7) * 1.2
+                            
+    else:
+        # Stage 0.8~1.0: 칼데라 완성 + 호수
+        progress = (stage - 0.8) / 0.2
+        caldera_radius = int(max_outer * 0.45)  # 최종 크기
+        
+        for r in range(h):
+            for c in range(w):
+                dist = np.sqrt((r - center[0])**2 + (c - center[1])**2)
+                
+                if dist < max_outer:
+                    if dist < caldera_radius:
+                        # 칼데라 바닥 (호수)
+                        water_level = 5.0
+                        elevation[r, c] = water_level - 3.0 * (1 - (dist / caldera_radius) ** 2)
+                    elif dist < caldera_radius + 8:
+                        # 급경사 벽
+                        wall_t = (dist - caldera_radius) / 8
+                        elevation[r, c] = 5.0 + rim_height * 0.9 * wall_t
+                    else:
+                        # 외륜산
+                        outer_t = (dist - caldera_radius - 8) / (max_outer - caldera_radius - 8)
+                        elevation[r, c] = rim_height * (1 - outer_t ** 0.8) * 0.9
+    
+    if return_metadata:
+        return elevation, {
+            'stage_description': _get_caldera_stage_desc(stage)
+        }
+    
     return elevation
 
 
+def _get_caldera_stage_desc(stage: float) -> str:
+    """칼데라 단계별 설명"""
+    if stage < 0.2:
+        return "🌋 성층화산 성장: 분화 활동으로 산체 형성"
+    elif stage < 0.4:
+        return "💥 대분화: 마그마 대량 분출"
+    elif stage < 0.6:
+        return "🕳️ 함몰 시작: 마그마방 비워짐 → 지지력 상실"
+    elif stage < 0.8:
+        return "⬇️ 칼데라 확장: 정상부 함몰 확대"
+    else:
+        return "💧 칼데라 호수: 융해수 고임 (백두산 천지)"
+
+
 def create_mesa_butte(grid_size: int = 100, stage: float = 1.0,
                       num_mesas: int = 2) -> np.ndarray:
     """메사/뷰트 (Mesa/Butte) - 탁상지"""
@@ -2323,80 +2678,133 @@ def create_crater_lake(grid_size: int = 100, stage: float = 1.0,
     return elevation
 
 
-def create_lava_plateau(grid_size: int = 100, stage: float = 1.0) -> np.ndarray:
-    """용암대지 (Lava Plateau) - 한탄강 형성과정
+def create_lava_plateau(grid_size: int = 100, stage: float = 1.0,
+                        return_metadata: bool = False) -> np.ndarray:
+    """용암대지 (Lava Plateau) - 한탄강/제주도형
     
-    Stage 0.0~0.3: 원래 V자곡 존재
-    Stage 0.3~0.6: 열하분출로 V자곡 메워짐 (용암대지 형성)
-    Stage 0.6~1.0: 하천 재침식으로 새로운 협곡 형성
+    Stage 0~0.25: 원래 V자곡 존재 (하천 흐름)
+    Stage 0.25~0.5: 열하분출 → 용암이 V자곡 메움 (용암류)
+    Stage 0.5~0.75: 용암대지 형성 (평탄화)
+    Stage 0.75~1.0: 하천 재침식 → 새로운 협곡 형성
+    
+    핵심 과정:
+    - 열하분출(fissure eruption): 선상으로 용암 분출
+    - 홍수현무암(flood basalt): 넓은 지역 뒤덮음
+    - 재침식(rejuvenation): 새 하천이 협곡 형성
     """
     h, w = grid_size, grid_size
     elevation = np.zeros((h, w))
+    lava_mask = np.zeros((h, w), dtype=bool)  # 용암 위치 표시
     center = w // 2
     
     # 기반 고원 높이
     plateau_base = 30.0
     
-    if stage < 0.3:
-        # 원래 V자곡 상태
-        v_factor = 1.0
-        lava_fill = 0.0
-        new_valley = 0.0
-    elif stage < 0.6:
-        # 열하분출로 V자곡 메워짐
-        v_factor = 1.0 - ((stage - 0.3) / 0.3)  # V자곡 점점 사라짐
-        lava_fill = (stage - 0.3) / 0.3  # 용암 채워짐
-        new_valley = 0.0
-    else:
-        # 새 협곡 형성
-        v_factor = 0.0  # 원래 V자곡 완전히 덮임
-        lava_fill = 1.0
-        new_valley = (stage - 0.6) / 0.4  # 새 협곡 발달
-    
-    for r in range(h):
-        for c in range(w):
-            dx = abs(c - center)
-            
-            # 기본 고원
-            elevation[r, c] = plateau_base
-            
-            # 원래 V자곡 (열하분출 전)
-            if v_factor > 0:
-                valley_depth = 25.0 * v_factor
-                if dx < 15:
-                    v_shape = valley_depth * (1 - dx / 15)
+    if stage < 0.25:
+        # Stage 0~0.25: 원래 V자곡 (하천 흐름)
+        v_depth = 30.0
+        for r in range(h):
+            for c in range(w):
+                dx = abs(c - center)
+                elevation[r, c] = plateau_base
+                
+                # V자곡
+                if dx < 18:
+                    v_shape = v_depth * (1 - dx / 18) ** 1.2
                     elevation[r, c] -= v_shape
+                    
+    elif stage < 0.5:
+        # Stage 0.25~0.5: 용암 분출 → 골짜기 메움
+        progress = (stage - 0.25) / 0.25
+        v_depth = 30.0 * (1 - progress * 0.9)  # V자곡 점점 메워짐
+        lava_thickness = 25.0 * progress
+        
+        for r in range(h):
+            # 용암 흐름 범위 (상류에서 하류로 진행)
+            flow_reach = int(h * progress)
             
-            # 용암 채움 (평탄화)
-            if lava_fill > 0:
-                # 용암이 V자곡을 메움
-                if dx < 15:
-                    fill_amount = 25.0 * lava_fill * (1 - dx / 15)
-                    elevation[r, c] += fill_amount * 0.8  # 약간 낮게
+            for c in range(w):
+                dx = abs(c - center)
+                elevation[r, c] = plateau_base
+                
+                # 잔여 V자곡
+                if dx < 18:
+                    v_shape = v_depth * (1 - dx / 18) ** 1.2
+                    elevation[r, c] -= v_shape
+                
+                # 용암 채움
+                if r < flow_reach and dx < 20:
+                    lava_fill = lava_thickness * (1 - dx / 20) ** 0.8
+                    elevation[r, c] += lava_fill
+                    lava_mask[r, c] = True
                     
-            # 새로운 협곡 (하천 재침식)
-            if new_valley > 0:
-                # 새 하천이 용암대지를 파고듦
-                new_valley_width = int(8 * new_valley)
-                new_valley_depth = 20.0 * new_valley
+    elif stage < 0.75:
+        # Stage 0.5~0.75: 용암대지 평탄화
+        progress = (stage - 0.5) / 0.25
+        
+        for r in range(h):
+            for c in range(w):
+                dx = abs(c - center)
                 
-                if dx < new_valley_width:
-                    # 더 좁고 깊은 협곡
-                    gorge_shape = new_valley_depth * (1 - dx / max(new_valley_width, 1))
-                    elevation[r, c] -= gorge_shape
+                # 평탄한 용암대지
+                if dx < 25:
+                    elevation[r, c] = plateau_base + 5.0
+                    lava_mask[r, c] = True
+                else:
+                    # 가장자리 경사
+                    edge_t = (dx - 25) / (w // 2 - 25)
+                    elevation[r, c] = (plateau_base + 5.0) * (1 - edge_t ** 0.7)
                     
-    # 가장자리 경사
-    margin = int(w * 0.1)
-    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] = elevation[r, c] * t + 5.0 * (1 - t)
+    else:
+        # Stage 0.75~1.0: 새 협곡 형성
+        progress = (stage - 0.75) / 0.25
+        gorge_width = int(6 + 6 * progress)
+        gorge_depth = 35.0 * progress
+        
+        for r in range(h):
+            for c in range(w):
+                dx = abs(c - center)
+                
+                # 용암대지 기반
+                if dx < 25:
+                    elevation[r, c] = plateau_base + 5.0
+                    lava_mask[r, c] = True
+                else:
+                    edge_t = (dx - 25) / (w // 2 - 25)
+                    elevation[r, c] = (plateau_base + 5.0) * (1 - edge_t ** 0.7)
                 
+                # 새로운 협곡 (하천 재침식)
+                if dx < gorge_width:
+                    gorge_shape = gorge_depth * (1 - (dx / gorge_width) ** 2)
+                    elevation[r, c] -= gorge_shape
+                    
+                    # 수직 절벽 형성 (주상절리 효과)
+                    if dx > gorge_width * 0.7:
+                        elevation[r, c] -= 3.0  # 급경사
+    
+    if return_metadata:
+        return elevation, {
+            'lava_mask': lava_mask,
+            'stage_description': _get_lava_plateau_stage_desc(stage)
+        }
+    
     return elevation
 
 
+def _get_lava_plateau_stage_desc(stage: float) -> str:
+    """용암대지 단계별 설명"""
+    if stage < 0.2:
+        return "🏞️ 원래 V자곡: 하천 침식에 의한 계곡"
+    elif stage < 0.4:
+        return "🌋 열하분출: 용암이 계곡을 따라 흐름"
+    elif stage < 0.6:
+        return "🔥 용암 홍수: 계곡을 완전히 메움"
+    elif stage < 0.8:
+        return "⬛ 용암대지 형성: 평탄한 현무암 대지"
+    else:
+        return "🏞️ 재침식: 새로운 하천이 협곡 형성 (주상절리)"
+
+
 def create_coastal_dune(grid_size: int = 100, stage: float = 1.0,
                         num_dunes: int = 3) -> np.ndarray:
     """해안사구 (Coastal Dune) - 해안가 모래 언덕"""

engine/script_engine.py

@@ -54,7 +54,24 @@ class ScriptExecutor:
             'min': min,
             'abs': abs,
             'pow': pow,
-            'print': print # 디버깅용
+            'print': print,  # 디버깅용
+            'range': range,
+            'len': len,
+            'int': int,
+            'float': float,
+            'round': round,
+            'sum': sum,
+            'enumerate': enumerate,
+            'zip': zip,
+            'list': list,
+            'tuple': tuple,
+            'dict': dict,
+            'set': set,
+            'str': str,
+            'bool': bool,
+            'True': True,
+            'False': False,
+            'None': None,
         }
         
         # 2. 금지된 키워드 체크 (기본적인 보안)

pages/1_📖_Gallery.py

@@ -14,6 +14,7 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspa
 
 from engine.ideal_landforms import IDEAL_LANDFORM_GENERATORS, ANIMATED_LANDFORM_GENERATORS
 from app.components.renderer import render_terrain_plotly
+from app.components.animation_renderer import create_animated_terrain_figure
 
 st.header("📖 이상적 지형 갤러리")
 st.markdown("_교과서적인 지형 형태를 기하학적 모델로 시각화합니다._")
@@ -239,11 +240,44 @@ if landform_key in ANIMATED_LANDFORM_GENERATORS:
             # 단계별 설명 표시
             st.success(metadata.get('stage_description', ''))
             
-            # 선상지 존 정보
+            # 선상지 존 정보 + 색상 하이라이트
             if landform_key == 'alluvial_fan' and 'zone_info' in metadata:
-                with st.expander("📊 세부 구조 보기"):
-                    for zone_id, info in metadata['zone_info'].items():
-                        st.markdown(f"**{info['name']}**: 경사 {info['slope']}, {info['sediment']}")
+                with st.expander("📊 세부 구조 보기", expanded=True):
+                    col_z1, col_z2, col_z3 = st.columns(3)
+                    col_z1.markdown("🔴 **선정(Apex)**<br>경사 5-15°, 역력", unsafe_allow_html=True)
+                    col_z2.markdown("🟡 **선앙(Mid)**<br>경사 2-5°, 사질", unsafe_allow_html=True)
+                    col_z3.markdown("🔵 **선단(Toe)**<br>경사 <2°, 니질", unsafe_allow_html=True)
+                    
+                    show_zones = st.checkbox("🎨 존 색상 오버레이 표시", value=False, key="show_zone_colors")
+                    
+                    if show_zones and 'zone_mask' in metadata:
+                        # 존 마스크를 색상으로 표시
+                        st.info("🔴 선정 | 🟡 선앙 | 🔵 선단")
+                        
+                        import matplotlib.pyplot as plt
+                        from matplotlib.colors import ListedColormap
+                        
+                        zone_mask = metadata['zone_mask']
+                        cmap = ListedColormap(['#4682B4', '#FFD700', '#FF6347', '#228B22'])  # 배경, 선단, 선앙, 선정
+                        
+                        fig_zone, ax = plt.subplots(figsize=(8, 6))
+                        im = ax.imshow(zone_mask, cmap=cmap, origin='lower', alpha=0.8)
+                        ax.contour(stage_elev, levels=10, colors='white', linewidths=0.5, alpha=0.5)
+                        ax.set_title("선상지 존 구분")
+                        ax.set_xlabel("X")
+                        ax.set_ylabel("Y")
+                        
+                        # 범례
+                        from matplotlib.patches import Patch
+                        legend_elements = [
+                            Patch(facecolor='#FF6347', label='선정(Apex)'),
+                            Patch(facecolor='#FFD700', label='선앙(Mid)'),
+                            Patch(facecolor='#4682B4', label='선단(Toe)')
+                        ]
+                        ax.legend(handles=legend_elements, loc='upper right')
+                        
+                        st.pyplot(fig_zone)
+                        plt.close(fig_zone)
             
             # 피오르드 프로세스 정보
             if landform_key == 'fjord' and 'process_info' in metadata:
@@ -309,38 +343,52 @@ if landform_key in ANIMATED_LANDFORM_GENERATORS:
                 if 0 <= c < gallery_grid_size:
                     stage_water[r, c] = 3.0
     
-    # 3D 렌더링
-    fig_stage = render_terrain_plotly(
-        stage_elev,
-        f"{selected_landform} - {int(stage_value*100)}%",
-        add_water=True,
-        water_depth_grid=stage_water,
-        water_level=-999,
-        force_camera=False,  # 카메라 이동 허용
-        landform_type=landform_type
+    # 애니메이션 모드 선택
+    st.markdown("---")
+    animation_mode = st.radio(
+        "애니메이션 모드",
+        ["🎬 부드러운 애니메이션 (추천)", "📊 슬라이더 수동 조작"],
+        horizontal=True,
+        key="anim_mode"
     )
-    st.plotly_chart(fig_stage, use_container_width=True, key="stage_view")
     
-    # 자동 재생 (세션 상태 활용)
-    col_play, col_step = st.columns(2)
-    with col_play:
-        if st.button("▶️ 자동 재생 시작", key="auto_play"):
-            st.session_state['auto_playing'] = True
-            st.session_state['auto_stage'] = 0.0
-    with col_step:
-        if st.button("⏹️ 정지", key="stop_play"):
-            st.session_state['auto_playing'] = False
-    
-    # 자동 재생 중이면 stage 자동 증가
-    if st.session_state.get('auto_playing', False):
-        current_stage = st.session_state.get('auto_stage', 0.0)
-        if current_stage < 1.0:
-            st.session_state['auto_stage'] = current_stage + 0.04
-            import time
-            time.sleep(0.15)
-            st.rerun()
-        else:
-            st.session_state['auto_playing'] = False
-            st.success("✅ 완료!")
+    if animation_mode == "🎬 부드러운 애니메이션 (추천)":
+        # Plotly 네이티브 애니메이션 (카메라 유지!)
+        st.info("▶️ **재생** 버튼을 누르면 애니메이션이 시작됩니다. **카메라를 자유롭게 조작**할 수 있습니다!")
+        
+        try:
+            fig_animated = create_animated_terrain_figure(
+                landform_func=anim_func,
+                grid_size=gallery_grid_size,
+                num_frames=20,
+                title=f"{selected_landform} 형성 과정",
+                landform_type=landform_type
+            )
+            st.plotly_chart(fig_animated, use_container_width=True, key="animated_view")
+        except Exception as e:
+            st.error(f"애니메이션 생성 오류: {e}")
+            # 폴백: 정적 렌더링
+            fig_stage = render_terrain_plotly(
+                stage_elev,
+                f"{selected_landform} - {int(stage_value*100)}%",
+                add_water=True,
+                water_depth_grid=stage_water,
+                water_level=-999,
+                force_camera=False,
+                landform_type=landform_type
+            )
+            st.plotly_chart(fig_stage, use_container_width=True, key="stage_view_fallback")
+    else:
+        # 기존 슬라이더 방식
+        fig_stage = render_terrain_plotly(
+            stage_elev,
+            f"{selected_landform} - {int(stage_value*100)}%",
+            add_water=True,
+            water_depth_grid=stage_water,
+            water_level=-999,
+            force_camera=False,
+            landform_type=landform_type
+        )
+        st.plotly_chart(fig_stage, use_container_width=True, key="stage_view")
     
-    st.caption("💡 **Tip:** 카메라 각도를 먼저 조정한 후 자동 재생하면 유지됩니다.")
+    st.caption("💡 **Tip:** '부드러운 애니메이션' 모드에서는 카메라를 자유롭게 조작하면서 재생할 수 있습니다!")

pages/3_🧪_Lab.py

@@ -0,0 +1,288 @@
+"""
+🧪 Geo-Lab Script: 사용자 코드로 지형 생성
+Python 코드로 직접 지형을 생성하고 조작합니다.
+"""
+import streamlit as st
+import numpy as np
+import sys
+import os
+
+# 상위 디렉토리 경로 추가
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from engine.grid import WorldGrid
+from engine.script_engine import ScriptExecutor
+from app.components.renderer import render_terrain_plotly
+from app.components.animation_renderer import create_animated_terrain_figure
+from engine.ideal_landforms import IDEAL_LANDFORM_GENERATORS
+
+st.set_page_config(page_title="🧪 Lab Script", page_icon="🧪", layout="wide")
+
+st.header("🧪 Geo-Lab Script")
+st.markdown("_Python 코드로 직접 지형을 생성하고 조작합니다._")
+
+# 사이드바 설정
+st.sidebar.subheader("⚙️ 그리드 설정")
+grid_size = st.sidebar.slider("그리드 크기", 50, 200, 100)
+
+# 탭 구성
+tab1, tab2, tab3 = st.tabs(["📝 코드 편집", "📚 예제 코드", "📖 도움말"])
+
+with tab1:
+    st.subheader("📝 코드 편집기")
+    
+    # 기본 코드 템플릿
+    default_code = '''# Geo-Lab Script 예제
+# 사용 가능한 변수: elevation, bedrock, sediment, water_depth, np, math
+
+# 1. 기본 지형 생성 (평탄한 평원)
+h, w = elevation.shape
+elevation[:, :] = 10.0
+
+# 2. 중앙에 원뿔형 산 추가
+center_y, center_x = h // 2, w // 2
+for y in range(h):
+    for x in range(w):
+        dist = np.sqrt((y - center_y)**2 + (x - center_x)**2)
+        if dist < 30:
+            peak_height = 50.0 * (1 - dist / 30)
+            elevation[y, x] += peak_height
+
+# 3. 하천 추가 (왼쪽에서 오른쪽으로)
+for x in range(w):
+    river_y = int(center_y + 10 * np.sin(x * 0.1))
+    for dy in range(-2, 3):
+        if 0 <= river_y + dy < h:
+            elevation[river_y + dy, x] -= 5.0
+            water_depth[river_y + dy, x] = 3.0
+
+print("지형 생성 완료!")
+'''
+    
+    # 세션 상태에 코드 저장
+    if 'user_script' not in st.session_state:
+        st.session_state['user_script'] = default_code
+    
+    # 코드 편집기
+    user_code = st.text_area(
+        "Python 코드",
+        value=st.session_state.get('user_script', default_code),
+        height=400,
+        key="code_editor"
+    )
+    st.session_state['user_script'] = user_code
+    
+    col1, col2 = st.columns(2)
+    
+    with col1:
+        run_button = st.button("▶️ 실행", type="primary", use_container_width=True)
+    with col2:
+        reset_button = st.button("🔄 초기화", use_container_width=True)
+    
+    if reset_button:
+        st.session_state['user_script'] = default_code
+        st.rerun()
+    
+    if run_button:
+        with st.spinner("코드 실행 중..."):
+            try:
+                # 그리드 생성
+                grid = WorldGrid(grid_size, grid_size)
+                executor = ScriptExecutor(grid)
+                
+                # 스크립트 실행
+                success, message = executor.execute(user_code)
+                
+                if success:
+                    st.success(f"✅ {message}")
+                    
+                    # 결과 시각화
+                    st.subheader("📊 결과")
+                    
+                    # 2D / 3D 선택
+                    view_mode = st.radio("뷰 모드", ["3D", "2D"], horizontal=True)
+                    
+                    if view_mode == "3D":
+                        fig = render_terrain_plotly(
+                            grid.elevation,
+                            "스크립트 결과",
+                            add_water=True,
+                            water_depth_grid=grid.water_depth,
+                            water_level=-999,
+                            force_camera=False
+                        )
+                        st.plotly_chart(fig, use_container_width=True)
+                    else:
+                        import matplotlib.pyplot as plt
+                        fig, ax = plt.subplots(figsize=(10, 8))
+                        im = ax.imshow(grid.elevation, cmap='terrain', origin='lower')
+                        plt.colorbar(im, ax=ax, label='Elevation (m)')
+                        ax.set_title("2D 고도 맵")
+                        st.pyplot(fig)
+                    
+                    # 통계
+                    st.markdown("**📈 통계:**")
+                    col_s1, col_s2, col_s3, col_s4 = st.columns(4)
+                    col_s1.metric("최저 고도", f"{grid.elevation.min():.1f}m")
+                    col_s2.metric("최고 고도", f"{grid.elevation.max():.1f}m")
+                    col_s3.metric("평균 고도", f"{grid.elevation.mean():.1f}m")
+                    col_s4.metric("수역 비율", f"{(grid.water_depth > 0).sum() / grid.water_depth.size * 100:.1f}%")
+                    
+                else:
+                    st.error(f"❌ {message}")
+                    
+            except Exception as e:
+                st.error(f"❌ 오류: {str(e)}")
+
+with tab2:
+    st.subheader("📚 검증된 지형 불러오기")
+    st.markdown("_이미 구현된 지형을 불러와서 변형하거나 학습할 수 있습니다._")
+    
+    # 카테고리별 지형 목록
+    landform_categories = {
+        "🌊 하천 지형": ["v_valley", "meander", "free_meander", "alluvial_fan", "incised_meander", "delta", "waterfall"],
+        "🔺 삼각주": ["bird_foot_delta", "arcuate_delta", "cuspate_delta"],
+        "❄️ 빙하 지형": ["u_valley", "cirque", "horn", "arete", "fjord", "drumlin"],
+        "🌋 화산 지형": ["shield_volcano", "stratovolcano", "caldera", "cinder_cone"],
+        "🦇 카르스트": ["karst_doline", "uvala", "tower_karst"],
+        "🏜️ 건조 지형": ["barchan_dune", "mesa", "pedestal_rock", "wadi", "playa"],
+        "🏖️ 해안 지형": ["coastal_cliff", "spit", "lagoon", "tombolo"]
+    }
+    
+    selected_cat = st.selectbox("카테고리 선택", list(landform_categories.keys()))
+    available_landforms = [lf for lf in landform_categories[selected_cat] if lf in IDEAL_LANDFORM_GENERATORS]
+    
+    if available_landforms:
+        selected_landform = st.selectbox("지형 선택", available_landforms)
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            load_size = st.slider("그리드 크기", 50, 150, 100, key="load_size")
+        with col2:
+            load_stage = st.slider("형성 단계", 0.0, 1.0, 1.0, 0.1, key="load_stage")
+        
+        if st.button("🔄 지형 불러오기", type="primary", use_container_width=True):
+            try:
+                # 지형 생성 함수 호출
+                landform_func = IDEAL_LANDFORM_GENERATORS[selected_landform]
+                
+                # stage 파라미터 지원 여부 확인
+                import inspect
+                sig = inspect.signature(landform_func)
+                params = list(sig.parameters.keys())
+                
+                if 'stage' in params:
+                    result = landform_func(load_size, load_stage)
+                else:
+                    result = landform_func(load_size)
+                
+                # 결과 처리 (tuple인 경우 elevation만 추출)
+                if isinstance(result, tuple):
+                    elevation = result[0]
+                else:
+                    elevation = result
+                
+                st.success(f"✅ {selected_landform} 지형 불러오기 완료!")
+                
+                # 3D 시각화
+                fig = render_terrain_plotly(
+                    elevation,
+                    f"{selected_landform} (Stage {int(load_stage*100)}%)",
+                    add_water=True,
+                    water_level=-999,
+                    force_camera=False
+                )
+                st.plotly_chart(fig, use_container_width=True)
+                
+                # 통계
+                col_s1, col_s2, col_s3 = st.columns(3)
+                col_s1.metric("최저 고도", f"{elevation.min():.1f}m")
+                col_s2.metric("최고 고도", f"{elevation.max():.1f}m")
+                col_s3.metric("평균 고도", f"{elevation.mean():.1f}m")
+                
+                # 코드 확인
+                with st.expander("💻 이 지형의 코드 보기"):
+                    st.markdown(f"""
+```python
+from engine.ideal_landforms import IDEAL_LANDFORM_GENERATORS
+
+# 지형 생성
+landform_func = IDEAL_LANDFORM_GENERATORS['{selected_landform}']
+elevation = landform_func(grid_size={load_size}, stage={load_stage})
+
+# 결과: {elevation.shape} 크기의 고도 배열
+# 최저: {elevation.min():.1f}m, 최고: {elevation.max():.1f}m
+```
+
+**함수 소스 위치:** `engine/ideal_landforms.py` → `create_{selected_landform}()`
+                    """)
+                    
+            except Exception as e:
+                st.error(f"❌ 오류: {str(e)}")
+    else:
+        st.warning("이 카테고리에 사용 가능한 지형이 없습니다.")
+    
+    st.markdown("---")
+    st.markdown("""
+    ### 💡 팁: 직접 코드 짜는 법
+    
+    **기본 패턴:**
+    ```python
+    h, w = elevation.shape
+    center_y, center_x = h // 2, w // 2
+    
+    for y in range(h):
+        for x in range(w):
+            dist = np.sqrt((y - center_y)**2 + (x - center_x)**2)
+            # 거리 기반 높이 계산
+            elevation[y, x] = 높이공식(dist)
+    ```
+    
+    **핵심 원칙:**
+    1. `elevation[:, :]`로 전체 초기화
+    2. for 루프로 각 셀 순회
+    3. 거리 기반 높이 공식 적용
+    4. `water_depth`로 물 표시
+    """)
+
+with tab3:
+    st.subheader("📖 도움말")
+    
+    st.markdown("""
+    ### 사용 가능한 변수
+    
+    | 변수 | 타입 | 설명 |
+    |------|------|------|
+    | `elevation` | np.ndarray | 고도 배열 (수정 가능) |
+    | `bedrock` | np.ndarray | 기반암 배열 |
+    | `sediment` | np.ndarray | 퇴적물 배열 |
+    | `water_depth` | np.ndarray | 수심 배열 |
+    | `np` | module | NumPy 모듈 |
+    | `math` | module | math 모듈 |
+    
+    ### 기본 패턴
+    
+    ```python
+    # 그리드 크기 가져오기
+    h, w = elevation.shape
+    
+    # 전체 고도 설정
+    elevation[:, :] = 10.0
+    
+    # 특정 영역 수정
+    elevation[10:20, 30:40] = 50.0
+    
+    # 거리 기반 지형
+    for y in range(h):
+        for x in range(w):
+            dist = np.sqrt((y - center_y)**2 + (x - center_x)**2)
+            elevation[y, x] = some_function(dist)
+    ```
+    
+    ### 주의사항
+    
+    - `import` 문은 사용할 수 없습니다 (보안)
+    - `open()`, `exec()`, `eval()` 사용 불가
+    - 무한 루프 주의 (브라우저가 멈출 수 있음)
+    """)