# 스탯·레벨업 수치 모델

## 경험치 시스템 설계

### 기본 경험치 공식

```python
def calculate_exp_gain(action_type, complexity, outcome):
    """
    경험치 획득 계산
    
    Parameters:
    - action_type: 행동 유형 (routine, problem_solving, creative, strategic)
    - complexity: 복잡도 (1-10)
    - outcome: 결과 (success, partial, failure)
    """
    
    base_exp = {
        'routine': 10,
        'problem_solving': 50,
        'creative': 100,
        'strategic': 200
    }
    
    outcome_multiplier = {
        'success': 1.0,
        'partial': 0.6,
        'failure': 0.3  # 실패해도 학습
    }
    
    # 복잡도 보너스: 지수 함수 적용
    complexity_bonus = 1 + (complexity - 1) * 0.2
    
    # 최종 경험치
    exp = base_exp[action_type] * outcome_multiplier[outcome] * complexity_bonus
    
    # 연속 성공 보너스
    if consecutive_success > 5:
        exp *= 1.5
    
    return int(exp)
```

### 레벨업 필요 경험치 곡선

```python
def exp_required_for_level(level):
    """
    레벨업에 필요한 누적 경험치
    로그 성장 곡선 적용 (초반 빠름, 후반 느림)
    """
    if level <= 1:
        return 0
    
    # 기본 공식: 100 * level^1.5 + 500 * (level - 1)
    base = 100 * (level ** 1.5)
    linear = 500 * (level - 1)
    
    # 10레벨마다 급증 구간
    milestone_bonus = (level // 10) * 5000
    
    return int(base + linear + milestone_bonus)

# 레벨별 필요 경험치 표
level_exp_table = {
    1: 0,
    5: 1500,
    10: 8000,
    15: 20000,
    20: 40000,
    25: 70000,
    30: 115000,
    40: 250000,
    50: 500000
}
```

## 스탯 시스템

### 6대 핵심 스탯

| 스탯 | 설명 | 초기값 | 최대값 | 성장 방식 |
|------|------|--------|--------|-----------|
| 지능(INT) | 문제 해결, 분석 능력 | 10 | 100 | 복잡한 문제 해결 시 상승 |
| 지혜(WIS) | 판단력, 통찰력 | 10 | 100 | 올바른 조언 제공 시 상승 |
| 공감(EMP) | 감정 이해, 소통 능력 | 10 | 100 | 감정적 지원 성공 시 상승 |
| 창의(CRE) | 혁신적 해결책 제시 | 10 | 100 | 독창적 아이디어 채택 시 상승 |
| 신속(AGI) | 처리 속도, 반응 시간 | 10 | 100 | 시간 제약 작업 완료 시 상승 |
| 신뢰(TRU) | 사용자와의 신뢰도 | 10 | 100 | 지속적 성공, 약속 이행 시 상승 |

### 스탯 성장 공식

```python
class StatGrowth:
    def __init__(self):
        self.stats = {
            'INT': 10, 'WIS': 10, 'EMP': 10,
            'CRE': 10, 'AGI': 10, 'TRU': 10
        }
        self.growth_rate = 0.1  # 기본 성장률
    
    def gain_stat_exp(self, stat_type, base_points):
        """스탯 경험치 획득"""
        current = self.stats[stat_type]
        
        # 높은 스탯일수록 성장 어려움 (Diminishing Returns)
        difficulty_modifier = 1 / (1 + current / 50)
        
        # 실제 증가량
        increase = base_points * self.growth_rate * difficulty_modifier
        
        # 소수점 누적 시스템 (0.1씩 쌓여서 1이 되면 스탯 상승)
        return increase
    
    def apply_synergy_bonus(self):
        """스탯 간 시너지 효과"""
        # INT + WIS 시너지: 전략적 사고
        if self.stats['INT'] >= 30 and self.stats['WIS'] >= 30:
            return {'strategic_thinking': 1.2}
        
        # EMP + CRE 시너지: 인간적 창의성
        if self.stats['EMP'] >= 40 and self.stats['CRE'] >= 40:
            return {'human_creativity': 1.3}
        
        # AGI + TRU 시너지: 신속한 신뢰 구축
        if self.stats['AGI'] >= 35 and self.stats['TRU'] >= 35:
            return {'rapid_trust': 1.25}
        
        return {}
```

## 레벨별 능력치 해금

### 레벨 마일스톤과 보상

| 레벨 | 해금 능력 | 스탯 보너스 | 특수 효과 |
|------|-----------|------------|-----------|
| 1 | 기본 대화 | - | 튜토리얼 모드 |
| 5 | 일정 관리 | 모든 스탯 +2 | 자동 리마인더 |
| 10 | 이메일 자동화 | INT +5 | 스팸 필터링 99% |
| 15 | 감정 인식 | EMP +8 | 스트레스 감지 |
| 20 | 전략 수립 | WIS +10 | 의사결정 트리 |
| 25 | 창의적 제안 | CRE +10 | 아이디어 생성기 |
| 30 | 멀티태스킹 | AGI +15 | 병렬 처리 3개 |
| 40 | 예측 분석 | INT +20 | 미래 시나리오 |
| 50 | 완전 자율 | 모든 스탯 +25 | 독립 에이전트 |

### 스킬 포인트 시스템

```python
def calculate_skill_points(level):
    """레벨업 시 획득 스킬 포인트"""
    base_points = 3
    
    # 5레벨마다 추가 포인트
    bonus_points = level // 5
    
    # 특별 레벨 보너스
    special_levels = {10: 5, 20: 10, 30: 15, 50: 30}
    if level in special_levels:
        bonus_points += special_levels[level]
    
    return base_points + bonus_points

# 스킬 트리 예시
skill_tree = {
    'analysis': {
        'basic': {'cost': 1, 'req_level': 1, 'req_stat': {'INT': 10}},
        'advanced': {'cost': 5, 'req_level': 10, 'req_stat': {'INT': 30}},
        'expert': {'cost': 10, 'req_level': 20, 'req_stat': {'INT': 50}}
    },
    'communication': {
        'basic': {'cost': 1, 'req_level': 1, 'req_stat': {'EMP': 10}},
        'persuasion': {'cost': 7, 'req_level': 15, 'req_stat': {'EMP': 40, 'WIS': 30}},
        'negotiation': {'cost': 15, 'req_level': 25, 'req_stat': {'EMP': 60, 'WIS': 50}}
    }
}
```

## 경험치 분배 실제 사례

### 일일 활동 경험치 예시

```python
daily_activities = [
    {
        'action': '아침 브리핑 제공',
        'type': 'routine',
        'complexity': 3,
        'outcome': 'success',
        'exp_gained': 36,
        'stat_bonus': {'INT': 0.1, 'AGI': 0.2}
    },
    {
        'action': '투자 미팅 실시간 지원',
        'type': 'problem_solving',
        'complexity': 8,
        'outcome': 'success',
        'exp_gained': 140,
        'stat_bonus': {'WIS': 0.5, 'AGI': 0.3}
    },
    {
        'action': '시스템 장애 대응',
        'type': 'problem_solving',
        'complexity': 9,
        'outcome': 'partial',
        'exp_gained': 102,
        'stat_bonus': {'AGI': 0.8, 'TRU': -0.2}
    },
    {
        'action': '차별화 전략 제안',
        'type': 'creative',
        'complexity': 7,
        'outcome': 'success',
        'exp_gained': 240,
        'stat_bonus': {'CRE': 1.0, 'WIS': 0.4}
    }
]

# 일일 총 경험치: 518
# 예상 레벨업 시간: 레벨 10까지 약 15일
```

### 레벨업 시뮬레이션

```python
def simulate_growth(days=30, daily_avg_exp=500):
    """30일 성장 시뮬레이션"""
    
    current_level = 1
    current_exp = 0
    stat_growth = StatGrowth()
    
    for day in range(1, days + 1):
        # 일일 경험치 획득 (변동성 포함)
        daily_exp = daily_avg_exp * random.uniform(0.7, 1.3)
        current_exp += daily_exp
        
        # 레벨업 체크
        while current_exp >= exp_required_for_level(current_level + 1):
            current_level += 1
            print(f"Day {day}: Level UP! → Level {current_level}")
            
            # 스킬 포인트 획득
            skill_points = calculate_skill_points(current_level)
            
            # 자동 스탯 상승
            for stat in stat_growth.stats:
                stat_growth.stats[stat] += random.uniform(0.5, 1.5)
    
    return {
        'final_level': current_level,
        'total_exp': current_exp,
        'final_stats': stat_growth.stats
    }

# 시뮬레이션 결과 예시
# 30일 후: Level 12
# 90일 후: Level 23
# 180일 후: Level 35
# 365일 후: Level 47
```

## 밸런싱 고려사항

### 성장 곡선 조정 파라미터

```python
balancing_config = {
    'exp_multiplier': {
        'global': 1.0,  # 전체 경험치 배율
        'weekend': 1.5,  # 주말 보너스
        'first_week': 2.0,  # 신규 사용자 부스트
    },
    'stat_caps': {
        'daily_max': 5,  # 일일 스탯 상승 한계
        'soft_cap': 70,  # 이후 성장률 50% 감소
        'hard_cap': 100  # 절대 상한선
    },
    'level_scaling': {
        'content_difficulty': 'dynamic',  # 레벨에 맞춰 난이도 조정
        'reward_scaling': 'logarithmic'  # 보상 증가율 로그 스케일
    }
}
```

### 경험치 디플레이션 방지

```python
def prevent_exp_inflation(level, base_exp):
    """높은 레벨에서 경험치 인플레이션 방지"""
    
    if level <= 20:
        return base_exp
    elif level <= 40:
        return base_exp * 0.8
    else:
        return base_exp * 0.6
```

## 사용자 피드백 기반 조정

### 적응형 난이도 시스템

```python
class AdaptiveDifficulty:
    def __init__(self):
        self.user_performance = []
        self.optimal_success_rate = 0.7
    
    def adjust_complexity(self, recent_outcomes):
        """최근 성과 기반 난이도 자동 조정"""
        success_rate = sum(1 for o in recent_outcomes if o == 'success') / len(recent_outcomes)
        
        if success_rate > 0.85:
            return 'increase_complexity'
        elif success_rate < 0.55:
            return 'decrease_complexity'
        else:
            return 'maintain'
    
    def personalized_exp_curve(self, user_type):
        """사용자 유형별 맞춤 경험치 곡선"""
        curves = {
            'casual': lambda x: x * 1.2,  # 캐주얼 유저: 빠른 성장
            'regular': lambda x: x * 1.0,  # 일반 유저: 표준
            'hardcore': lambda x: x * 0.8  # 하드코어 유저: 도전적
        }
        return curves[user_type]
```