happybell80
14ca47ed6e
- 비전 및 철학: 존재형 AI 에이전트 개념 - 윤리 원칙과 안전 기준 - 사용자 시나리오 및 유즈케이스 - 게임화 요소 (레벨업, 스탯, 스킬) - 기술 아키텍처 (기억 시스템, 감정 모델, DB 설계) - 멀티 에이전트 협업 구조 - DID 기반 신원 체계 - 장기 로드맵 (1년, 3년 비전)
330 lines
9.4 KiB
Markdown
330 lines
9.4 KiB
Markdown
# 스탯·레벨업 수치 모델
|
|
|
|
## 경험치 시스템 설계
|
|
|
|
### 기본 경험치 공식
|
|
|
|
```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]
|
|
``` |