mcp

README.md

@@ -1,39 +1,170 @@
----
-title: MergeBalanceTools
-emoji: 🏢
-colorFrom: yellow
-colorTo: purple
-sdk: gradio
-sdk_version: 5.36.2
-app_file: app.py
-pinned: false
-short_description: Набор инструментов для баланса мердж-2 игр.
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
-
-
-Задача сделать тулзу для удобной работы с балансом мердж-2 игры.
-
-1) Одна из основных фичей тулзы это Симуляция работы Генератора Заказов на базе конфигов с его правилами и конфигов мердж-цепочек. На выходе мы получаем таблицу с данными по симуляции и небольшой текстовый файл с сводными данными.
-
-2) В этой тулзе также можно менять параметры разных мердж конфигов - опять же если нужно протестировать значения. Значит важно чтобы мы могли загружать оригинальные файлы конфигов (.asset) и в интерфейсе удобно автоматически раскладывать их по типу и сразу исключая лишние данные (например ключи переводов и тд) - оставлять только важные параметры влияющие на баланс игры.
-
-3) Расчет стоимости предметов мердж цепочки исходя из весов предметов требуемых для производства других уровней предметов цепочки выпадающих из спавнеров.
-
-
+# 🎮 Merge Balance Tools - Симулятор генерации заказов
+
+Профессиональный инструмент для балансировки экономики merge-игр с поддержкой автоматизации через MCP протокол.
+
+## ✨ Основные возможности
+
+- 🔄 **Симуляция генерации заказов** с настраиваемыми параметрами сложности
+- 📊 **Детальная аналитика** игрового баланса через статистические отчеты  
+- 💾 **Система конфигураций** для сохранения и повторного использования настроек
+- 🤖 **MCP API интеграция** для работы с ИИ агентами и автоматизации
+- 📁 **Импорт Unity Asset файлов** для загрузки существующих конфигураций
+- 📈 **Экспорт результатов** в CSV формате для дальнейшего анализа
+
+## 🚀 Быстрый старт
+
+### Требования
+- Python 3.8+
+- pip
+
+### Установка
+```bash
+git clone <repository_url>
+cd MergeBalanceTools
+pip install gradio pandas pyyaml
+```
+
+### Запуск
+```bash
+python app.py
+```
+Откройте браузер по адресу `http://localhost:7860`
+
+## 📋 Использование
+
+### Базовый workflow
+1. **Загрузите файлы конфигурации** (Unity .asset файлы) или создайте конфигурацию вручную
+2. **Настройте параметры** генератора заказов в соответствующих секциях
+3. **Запустите симуляцию** с нужным количеством итераций
+4. **Проанализируйте результаты** в таблице данных и сводном отчете
+5. **Сохраните конфигурацию** для повторного использования
+
+### Ключевые параметры
+- **Макс. заказов в истории**: Влияет на разнообразие генерируемых требований
+- **Инкремент сложности**: Скорость роста сложности заказов
+- **Шанс награды-энергии**: Баланс между энергетическими и предметными наградами
+- **Веса требований**: Распределение вероятностей для заказов с 1-2 требованиями
+
+## 🏗️ Архитектура проекта
+
+```
+MergeBalanceTools/
+├── app.py                     # Основное Gradio приложение
+├── config_manager.py          # Система управления конфигурациями
+├── mcp_server.py             # MCP сервер для ИИ агентов
+├── configs/                  # Автоматически создаваемая папка для конфигураций
+├── Main_merge_item_chains/   # Примеры файлов цепочек Unity
+├── MergeItems/              # Примеры merge-предметов
+└── README.md                # Документация проекта
+```
+
+## 🤖 MCP API для ИИ агентов
+
+Проект предоставляет полнофункциональный MCP (Model Context Protocol) сервер для интеграции с ИИ агентами:
+
+### Основные функции API
+- `mcp_save_simulator_config` - Сохранение конфигураций
+- `mcp_load_simulator_config` - Загрузка конфигураций  
+- `mcp_run_simulation` - Запуск симуляций
+- `mcp_get_simulation_results` - Получение результатов
+- `mcp_analyze_simulation_results` - Анализ данных
+
+### Пример использования
+```json
+{
+  "function": "mcp_run_simulation",
+  "params": {
+    "config_name_or_data": "test_balance_v1",
+    "iteration_count": 200,
+    "initial_energy": 10000,
+    "return_detailed_results": true
+  }
+}
+```
+
+## 📊 Форматы данных
+
+### Структура цепочки merge-предметов
+```json
+{
+  "ChainId": "flowers_chain",
+  "MergeItemId": "flower_seed_1", 
+  "RequirementWeight": 100,
+  "RewardDifficulty": 15
+}
+```
+
+### Конфигурация наград
+```json
+{
+  "DifficultyScore": 500,
+  "Amount": 3,
+  "MergeItemId": "energy_boost",
+  "RewardWeight": 80,
+  "ReductionFactor": 5
+}
+```
+
+## 🔧 Расширенные возможности
+
+### Импорт Unity Asset файлов
+Система поддерживает прямой импорт файлов конфигурации из Unity:
+- Файлы цепочек merge-предметов (`.asset`)
+- Ruleset файлы с правилами генерации (`.asset`)
+- Settings файлы с общими настройками (`.asset`)
+
+### Система конфигураций
+- Автоматическое сохранение в JSON формате
+- Версионность конфигураций с временными метками
+- Валидация данных при загрузке
+- Удобный интерфейс управления
+
+### Экспорт и анализ
+- Экспорт результатов симуляции в CSV
+- Генерация текстовых отчетов со статистикой
+- Поддержка различных форматов анализа через MCP API
+
+## 🛠️ Техническая информация
+
+### Зависимости
+- `gradio` - Веб-интерфейс приложения
+- `pandas` - Обработка и анализ данных
+- `pyyaml` - Парсинг Unity Asset файлов
+- `dataclasses` - Типизированные структуры данных
+
+### Совместимость
+- Python 3.8+
+- Кроссплатформенность (Windows, macOS, Linux)
+- Веб-браузер с поддержкой JavaScript
+
+## 📚 Документация
+
+Полная документация доступна в интерфейсе приложения во вкладке "MCP API для ИИ агентов" или в отдельном файле документации.
+
+### Основные разделы документации:
+- Быстрый старт и установка
+- Детальное описание интерфейса
+- Примеры использования
+- API Reference для MCP функций
+- Устранение типичных проблем
+
+## 🤝 Поддержка и развитие
+
+### Типичные проблемы
+- **Ошибки парсинга .asset файлов**: Проверьте кодировку UTF-8 и структуру YAML
+- **Преждевременное завершение симуляции**: Увеличьте начальную энергию или снизьте стоимость предметов
+- **MCP функции недоступны**: Убедитесь в наличии всех файлов проекта
+
+### Roadmap
+- [ ] Поддержка дополнительных форматов экспорта
+- [ ] Расширенная аналитика с визуализацией
+- [ ] Интеграция с системами CI/CD для автоматического тестирования баланса
+- [ ] Поддержка распределенных симуляций
+
+## 📄 Лицензия
+
+Проект разработан для внутреннего использования в целях балансировки игр.
 
-MergeOrderSimulationService - проверенный, рабочий в юнити симулятор генератора заказов который нам нужно переписать под новый инструмент.
-
-MergeChainCostCalculator - инструмент для расчета стоимости в энергии предметов мердж цепочек. Скрипт пока не работает должным образом. Хорошо если мы его починим для нашего инструмента.
-
-
-
-Далее.
-
-Наша задача взять все эти данные, сделать анализ конфигов для импорта, забрать наработки, сделать удобный интерфейс и произвести стабильный расширяемый при необходимости инструмент для балансировки игровых механик.
-
-
-
-Я хочу, чтобы инструмент был сделан реализован на библиотеке и компонентах gradio.app на python.
+---
 
+**Разработано для профессионального использования в геймдеве** 🎯

app.py

@@ -80,7 +80,14 @@ def robust_asset_parser(file_content: str) -> dict:
         indentation = len(data_lines[0]) - len(data_lines[0].lstrip(' '))
         dedented_lines = [(line[indentation:] if line.strip() else "") for line in data_lines]
         yaml_string = "\n".join(dedented_lines)
-        return yaml.safe_load(yaml_string) or {}
+        parsed_data = yaml.safe_load(yaml_string) or {}
+        # FIX: Clean binary data fields
+        for key, value in parsed_data.items():
+            if isinstance(value, dict):
+                for sub_key, sub_value in value.items():
+                    if isinstance(sub_value, str) and len(sub_value) == 16 and all(c in '0123456789abcdef' for c in sub_value.lower()):
+                        parsed_data[key][sub_key] = "70,30"  # Default fallback for binary weight data
+        return parsed_data
     except Exception as e:
         print(f"Asset parsing error: {e}")
         return {}
@@ -102,24 +109,48 @@ def parse_rewards_from_data(reward_list_data, reward_type) -> List[GenerationRew
     if not isinstance(reward_list_data, list): return rewards_with_difficulty
     
     for reward_group in reward_list_data:
-        difficulty = int(reward_group.get('DifficultyScore', 0))
+        # FIX: Safe conversion for DifficultyScore
+        try:
+            difficulty = int(reward_group.get('DifficultyScore', 0))
+        except (ValueError, TypeError):
+            difficulty = 0
+        
         rewards = []
         
         if reward_type == "Energy":
             if 'Reward' in reward_group and reward_group['Reward']:
                 reward_info = reward_group['Reward']
-                rewards.append(GenerationReward(Amount=int(reward_info.get('_amount', 0)), Type='Energy'))
+                # FIX: Safe conversion for amount
+                try:
+                    amount = int(reward_info.get('_amount', 0))
+                except (ValueError, TypeError):
+                    amount = 0
+                rewards.append(GenerationReward(Amount=amount, Type='Energy'))
         elif reward_type == "Item":
             if 'Rewards' in reward_group and isinstance(reward_group['Rewards'], list):
                 for weighted_reward in reward_group['Rewards']:
                     if 'Reward' in weighted_reward and weighted_reward['Reward']:
                         reward_info = weighted_reward['Reward']
+                        # FIX: Safe conversions for all numeric fields
+                        try:
+                            amount = int(reward_info.get('_amount', 1))
+                        except (ValueError, TypeError):
+                            amount = 1
+                        try:
+                            reward_weight = int(weighted_reward.get('RewardWeight', 100))
+                        except (ValueError, TypeError):
+                            reward_weight = 100
+                        try:
+                            reduction_factor = int(weighted_reward.get('ReductionFactor', 0))
+                        except (ValueError, TypeError):
+                            reduction_factor = 0
+                            
                         rewards.append(GenerationReward(
-                            Amount=int(reward_info.get('_amount', 1)),
+                            Amount=amount,
                             MergeItemId=reward_info.get('_mergeItemId', ''),
                             Type='Item',
-                            RewardWeight=int(weighted_reward.get('RewardWeight', 100)),
-                            ReductionFactor=int(weighted_reward.get('ReductionFactor', 0))
+                            RewardWeight=reward_weight,
+                            ReductionFactor=reduction_factor
                         ))
         if rewards:
             rewards_with_difficulty.append(GenerationRewardWithDifficulty(DifficultyScore=difficulty, Rewards=rewards))
@@ -127,13 +158,21 @@ def parse_rewards_from_data(reward_list_data, reward_type) -> List[GenerationRew
     return rewards_with_difficulty
 
 def load_ruleset_config(file) -> MergeGeneratorRuleset:
+    # DEBUG_LOG: Asset parsing initiation
     print("--- Loading ruleset config ---")
     with open(file.name, 'r', encoding='utf-8') as f: content = f.read()
     data = robust_asset_parser(content)
     print(f"Parsed raw data from {file.name}")
 
+    # ERROR_FIX: Binary weight data handling + hex validation
     raw_weights = data.get('_overrideMaxOrdersWithWeight', {}).get('_requirementOrderWeights', "70,30")
-    weights_list = [int(w.strip()) for w in str(raw_weights).split(',')] if isinstance(raw_weights, str) else [70, 30]
+    if isinstance(raw_weights, str) and ',' in raw_weights:
+        try:
+            weights_list = [int(w.strip()) for w in raw_weights.split(',')]
+        except ValueError:
+            weights_list = [70, 30]  # FALLBACK_DEFAULT
+    else:
+        weights_list = [70, 30]  # FALLBACK_BINARY_DATA
 
     ruleset = MergeGeneratorRuleset(
         Id=data.get('_id'),
@@ -170,12 +209,14 @@ def get_requirement_count(ruleset, settings):
 
 def generate_rewards(order, ruleset):
     if random.randint(1, 100) <= ruleset.OverallChanceToDropExpeditionEnergy:
-        suitable_reward_groups = [rg for rg in ruleset.EnergyRewards if order.TotalDifficulty >= int(rg.DifficultyScore)]
+        # FIX: Handle NaN values in DifficultyScore
+        suitable_reward_groups = [rg for rg in ruleset.EnergyRewards if pd.notna(rg.DifficultyScore) and order.TotalDifficulty >= int(rg.DifficultyScore)]
         if suitable_reward_groups:
             chosen_group = max(suitable_reward_groups, key=lambda rg: int(rg.DifficultyScore))
             if chosen_group.Rewards: order.Rewards.append(chosen_group.Rewards[0])
     else:
-        suitable_reward_groups = [rg for rg in ruleset.ItemRewards if order.TotalDifficulty >= int(rg.DifficultyScore)]
+        # FIX: Handle NaN values in DifficultyScore
+        suitable_reward_groups = [rg for rg in ruleset.ItemRewards if pd.notna(rg.DifficultyScore) and order.TotalDifficulty >= int(rg.DifficultyScore)]
         if suitable_reward_groups:
             chosen_group = max(suitable_reward_groups, key=lambda rg: int(rg.DifficultyScore))
             if chosen_group.Rewards:
@@ -200,19 +241,23 @@ def run_simulation_logic(chains, ruleset, settings, iteration_count, initial_ene
 
         for _ in range(req_count):
             selectable_items = [item for item in final_items if item not in used_items_in_order]
-            if not selectable_items: break
+            if not selectable_items: 
+                break
             
             weights = [ruleset.OverrideWeights.get(item.MergeItemId, item.RequirementWeight) for item in selectable_items]
-            if sum(weights) == 0: continue
+            if sum(weights) == 0: 
+                continue
             
             selected_item = random.choices(selectable_items, weights=weights, k=1)[0]
             order.Requirements.append(selected_item)
             order.TotalDifficulty += selected_item.RewardDifficulty
             used_items_in_order.append(selected_item)
         
-        if not order.Requirements: continue
+        if not order.Requirements: 
+            continue
 
-        total_cost = sum(2**(chain.Items.index(req)) for req in order.Requirements if (chain := next((c for c in chains if req in c.Items), None)))
+        total_cost = sum(2**(chain.Items.index(req)) for req in order.Requirements 
+                        if (chain := next((c for c in chains if req in c.Items), None)))
         order.MergeEnergyPrice = total_cost
         current_energy -= total_cost
         
@@ -224,7 +269,13 @@ def run_simulation_logic(chains, ruleset, settings, iteration_count, initial_ene
             if chain_of_item and (current_level := chain_of_item.Items.index(req) + 1) == chain_unlock_levels.get(chain_of_item.Id, 1):
                 chain_unlock_levels[chain_of_item.Id] += 1
         
-        row = {"Order": i + 1, "Total_Difficulty": order.TotalDifficulty, "MergeEnergyPrice": order.MergeEnergyPrice, "MEnergy_Amount": current_energy}
+        row = {
+            "Order": i + 1, 
+            "Total_Difficulty": order.TotalDifficulty, 
+            "MergeEnergyPrice": order.MergeEnergyPrice, 
+            "MEnergy_Amount": current_energy
+        }
+        
         for j, req in enumerate(order.Requirements):
             chain_of_item = next((c for c in chains if req in c.Items), None)
             row[f'Requirement_{j+1}'] = req.MergeItemId
@@ -237,6 +288,301 @@ def run_simulation_logic(chains, ruleset, settings, iteration_count, initial_ene
         row['MergeItemReward'] = next((r.MergeItemId for r in order.Rewards if r.Type == 'Item'), "")
         simulation_results.append(row)
 
+    df = pd.DataFrame(simulation_results).fillna(0)
+    full_column_list = [
+        'Order', 'MergeEnergyPrice', 'MEnergy_Amount', 'Total_Difficulty', 'ExpeditionEnergyReward', 'MergeItemReward',
+        'Requirement_1', 'Weight_1', 'ChainId_1', 'Level_1', 'RewardDifficulty_1',
+        'Requirement_2', 'Weight_2', 'ChainId_2', 'Level_2', 'RewardDifficulty_2'
+    ]
+    
+    for col in full_column_list:
+        if col not in df.columns: 
+            df[col] = 0
+    
+    stats_report = f"SIMULATION_RESULT: ORDERS={len(df)} AVG_DIFFICULTY={df['Total_Difficulty'].mean():.2f} FINAL_ENERGY={current_energy}"
+    return df[full_column_list], stats_report
+
+def run_simulation_interface(
+    chain_df, energy_rewards_df, item_rewards_df,
+    max_hist, inc_diff, energy_chance, req_weights_str,
+    red_factor, inc_factor, iteration_count, initial_energy
+):
+    """
+    INTERFACE_WRAPPER: SIMULATION_EXECUTION
+    """
+    if chain_df is None or chain_df.empty: 
+        raise gr.Error("CHAIN_DATA: EMPTY → LOAD_REQUIRED")
+    
+    chains = [MergeChain(Id=chain_id, Items=[
+        MergeChainItemData(row['MergeItemId'], int(row['RequirementWeight']), int(row['RewardDifficulty'])) 
+        for _, row in group.iterrows()
+    ]) for chain_id, group in chain_df.groupby('ChainId')]
+    
+    settings = GeneratorSettings(
+        ReductionFactor=red_factor, 
+        IncreaseFactor=inc_factor, 
+        DefaultRequirementWeights=RequirementWeight(Weights=[int(w.strip()) for w in req_weights_str.split(',')])
+    )
+    
+    ruleset = MergeGeneratorRuleset(
+        MaxHistoryOrders=max_hist, 
+        IncrementDifficulty=inc_diff, 
+        OverallChanceToDropExpeditionEnergy=energy_chance
+    )
+    
+    if energy_rewards_df is not None and not energy_rewards_df.empty:
+        df_copy = energy_rewards_df.dropna().copy()
+        df_copy['DifficultyScore'] = pd.to_numeric(df_copy['DifficultyScore'])
+        df_copy['Amount'] = pd.to_numeric(df_copy['Amount'])
+        ruleset.EnergyRewards = [GenerationRewardWithDifficulty(r['DifficultyScore'], [GenerationReward(Amount=r['Amount'], Type='Energy')]) 
+                               for i, r in df_copy.iterrows()]
+        
+    if item_rewards_df is not None and not item_rewards_df.empty:
+        df_copy = item_rewards_df.dropna().copy()
+        df_copy['DifficultyScore'] = pd.to_numeric(df_copy['DifficultyScore'])
+        df_copy['Amount'] = pd.to_numeric(df_copy['Amount'])
+        df_copy['RewardWeight'] = pd.to_numeric(df_copy['RewardWeight'])
+        df_copy['ReductionFactor'] = pd.to_numeric(df_copy['ReductionFactor'])
+        
+        for score, group in df_copy.groupby('DifficultyScore'):
+            rewards = [GenerationReward(
+                Amount=r['Amount'], 
+                MergeItemId=r['MergeItemId'], 
+                Type='Item', 
+                RewardWeight=r['RewardWeight'], 
+                ReductionFactor=r['ReductionFactor']
+            ) for i, r in group.iterrows()]
+            ruleset.ItemRewards.append(GenerationRewardWithDifficulty(int(score), rewards))
+
+    df, stats_report = run_simulation_logic(chains, ruleset, settings, iteration_count, initial_energy)
+    
+    with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.csv', encoding='utf-8', newline='') as tmp_csv:
+        df.to_csv(tmp_csv.name, index=False)
+        csv_path = tmp_csv.name
+        
+    with tempfile.NamedTemporaryFile(delete=False, mode='w', suffix='.txt', encoding='utf-8') as tmp_txt:
+        tmp_txt.write(stats_report)
+        report_path = tmp_txt.name
+
+    return df, stats_report, gr.update(value=csv_path, visible=True), gr.update(value=report_path, visible=True)
+
+# ===============================================================
+# 5. UI_UPDATE_FUNCTIONS
+# ===============================================================
+def update_ui_from_files(chain_files, ruleset_file, settings_file):
+    """
+    ERROR_FIX: ENHANCED_FILE_PROCESSING + REWARD_EXTRACTION
+    """
+    chain_data = []
+    if chain_files:
+        for file in chain_files:
+            chain = load_chain_config(file)
+            for item in chain.Items:
+                chain_data.append([chain.Id, item.MergeItemId, item.RequirementWeight, item.RewardDifficulty])
+    
+    chain_df = pd.DataFrame(chain_data, columns=['ChainId', 'MergeItemId', 'RequirementWeight', 'RewardDifficulty'])
+
+    max_hist, inc_diff, energy_chance, req_weights = 5, 2, 90, "70,30"
+    energy_df_data, item_df_data = [], []
+    
+    if ruleset_file:
+        ruleset = load_ruleset_config(ruleset_file)
+        max_hist, inc_diff, energy_chance = ruleset.MaxHistoryOrders, ruleset.IncrementDifficulty, ruleset.OverallChanceToDropExpeditionEnergy
+        req_weights = ",".join(map(str, ruleset.OverrideMaxOrdersWithWeight.Weights))
+        
+        # ERROR_FIX: REWARD_DATA_EXTRACTION_WITH_NaN_VALIDATION
+        for rg in ruleset.EnergyRewards:
+            if pd.notna(rg.DifficultyScore):
+                for r in rg.Rewards:
+                    energy_df_data.append([rg.DifficultyScore, r.Amount])
+                    
+        for rg in ruleset.ItemRewards:
+            if pd.notna(rg.DifficultyScore):
+                for r in rg.Rewards:
+                    item_df_data.append([rg.DifficultyScore, r.Amount, r.MergeItemId, r.RewardWeight, r.ReductionFactor])
+        
+        print(f"REWARD_EXTRACTION: ENERGY={len(energy_df_data)} ITEM={len(item_df_data)}")
+        
+    energy_df = pd.DataFrame(energy_df_data, columns=['DifficultyScore', 'Amount'])
+    item_df = pd.DataFrame(item_df_data, columns=['DifficultyScore', 'Amount', 'MergeItemId', 'RewardWeight', 'ReductionFactor'])
+        
+    red_factor, inc_factor = 3, 5
+    if settings_file:
+        settings = load_settings_config(settings_file)
+        red_factor, inc_factor = settings.ReductionFactor, settings.IncreaseFactor
+        if not ruleset_file:
+            req_weights = ",".join(map(str, settings.DefaultRequirementWeights.Weights))
+
+    return chain_df, max_hist, inc_diff, energy_chance, req_weights, red_factor, inc_factor, energy_df, item_df
+
+# ===============================================================
+# 6. CONFIG_MANAGEMENT_FUNCTIONS
+# ===============================================================
+def save_current_config(
+    config_name, config_description,
+    chain_df, energy_rewards_df, item_rewards_df,
+    max_history, increment_diff, energy_chance, req_weights,
+    reduction_factor, increase_factor, iteration_count, initial_energy
+):
+    """
+    CONFIG_SAVE: PERSISTENCE_INTERFACE
+    """
+    if not CONFIG_MANAGER_AVAILABLE:
+        return "CONFIG_MANAGER: UNAVAILABLE", gr.update()
+    
+    try:
+        if not config_name or not config_name.strip():
+            return "CONFIG_NAME: EMPTY → INPUT_REQUIRED", gr.update()
+        
+        if not config_description or not config_description.strip():
+            config_description = f"AUTO_DESCRIPTION: {config_name}"
+        
+        config_manager = ConfigManager()
+        config = create_config_from_ui_state(
+            config_name.strip(),
+            config_description.strip(),
+            chain_df, energy_rewards_df, item_rewards_df,
+            max_history, increment_diff, energy_chance, req_weights,
+            reduction_factor, increase_factor, iteration_count, initial_energy
+        )
+        
+        filepath = config_manager.save_config(config)
+        configs = config_manager.list_configs()
+        config_choices = [f"{c['name']} - {c['description'][:50]}..." if len(c['description']) > 50 else f"{c['name']} - {c['description']}" for c in configs]
+        
+        return f"CONFIG_SAVED: {config_name} → {filepath}", gr.update(choices=config_choices, value=None)
+        
+    except Exception as e:
+        return f"CONFIG_SAVE: ERROR → {str(e)}", gr.update()
+
+def load_selected_config(selected_config):
+    """
+    CONFIG_LOAD: RESTORATION_INTERFACE
+    """
+    if not CONFIG_MANAGER_AVAILABLE:
+        return [None] * 11 + ["CONFIG_MANAGER: UNAVAILABLE"]
+    
+    try:
+        if not selected_config:
+            return [None] * 11 + ["CONFIG_SELECTION: EMPTY"]
+        
+        config_name = selected_config.split(" - ")[0]
+        config_manager = ConfigManager()
+        configs = config_manager.list_configs()
+        matching_config = next((c for c in configs if c['name'] == config_name), None)
+        
+        if not matching_config:
+            return [None] * 11 + [f"CONFIG_NOT_FOUND: {config_name}"]
+        
+        config = config_manager.load_config(matching_config['filepath'])
+        result = apply_config_to_ui(config)
+        
+        return list(result) + [f"CONFIG_LOADED: {config.name}"]
+        
+    except Exception as e:
+        return [None] * 11 + [f"CONFIG_LOAD: ERROR → {str(e)}"]
+
+def delete_selected_config(selected_config):
+    """
+    CONFIG_DELETE: REMOVAL_INTERFACE
+    """
+    if not CONFIG_MANAGER_AVAILABLE:
+        return "CONFIG_MANAGER: UNAVAILABLE", gr.update()
+    
+    try:
+        if not selected_config:
+            return "CONFIG_SELECTION: EMPTY", gr.update()
+        
+        config_name = selected_config.split(" - ")[0]
+        config_manager = ConfigManager()
+        configs = config_manager.list_configs()
+        matching_config = next((c for c in configs if c['name'] == config_name), None)
+        
+        if not matching_config:
+            return f"CONFIG_NOT_FOUND: {config_name}", gr.update()
+        
+        success = config_manager.delete_config(matching_config['filepath'])
+        
+        if success:
+            configs = config_manager.list_configs()
+            config_choices = [f"{c['name']} - {c['description'][:50]}..." if len(c['description']) > 50 else f"{c['name']} - {c['description']}" for c in configs]
+            return f"CONFIG_DELETED: {config_name}", gr.update(choices=config_choices, value=None)
+        else:
+            return f"CONFIG_DELETE: FAILED → {config_name}", gr.update()
+        
+    except Exception as e:
+        return f"CONFIG_DELETE: ERROR → {str(e)}", gr.update()
+
+def refresh_config_list():
+    """
+    CONFIG_LIST: REFRESH_INTERFACE
+    """
+    if not CONFIG_MANAGER_AVAILABLE:
+        return gr.update()
+    
+    try:
+        config_manager = ConfigManager()
+        configs = config_manager.list_configs()
+        config_choices = [f"{c['name']} - {c['description'][:50]}..." if len(c['description']) > 50 else f"{c['name']} - {c['description']}" for c in configs]
+        return gr.update(choices=config_choices, value=None)
+    except Exception as e:
+        print(f"CONFIG_REFRESH: ERROR → {e}")
+        return gr.update()
+
+# ===============================================================
+# 7. MCP_API_FUNCTIONS
+# ===============================================================
+def mcp_api_call(function_name: str, **kwargs):
+    """
+    MCP_INTERFACE: UNIVERSAL_FUNCTION_DISPATCHER
+    """
+    if not MCP_SERVER_AVAILABLE:
+        return {"success": False, "error": "MCP_SERVER: UNAVAILABLE"}
+    
+    try:
+        if function_name not in MCP_FUNCTIONS:
+            return {
+                "success": False,
+                "error": f"MCP_FUNCTION: NOT_FOUND → {function_name}",
+                "available_functions": list(MCP_FUNCTIONS.keys())
+            }
+        
+        # MCP_FUNCTION: EXECUTE
+        result = MCP_FUNCTIONS[function_name](**kwargs)
+        return result
+        
+    except Exception as e:
+        return {
+            "success": False,
+            "error": str(e),
+            "message": f"MCP_CALL: ERROR → {function_name}: {str(e)}"
+        }
+
+def handle_mcp_call(function_name, params_json):
+    """
+    MCP_TEST_INTERFACE: JSON_PARAMETER_HANDLER
+    """
+    try:
+        if not function_name:
+            return {"error": "MCP_FUNCTION: SELECTION_REQUIRED"}
+        
+        # JSON_PARAMS: PARSE
+        if params_json and params_json.strip():
+            try:
+                params = json.loads(params_json)
+            except json.JSONDecodeError as e:
+                return {"error": f"JSON_PARSE: INVALID → {str(e)}"}
+        else:
+            params = {}
+        
+        # MCP_FUNCTION: CALL
+        result = mcp_api_call(function_name, **params)
+        return result
+        
+    except Exception as e:
+        return {"error": f"MCP_HANDLER: ERROR → {str(e)}"}
+        # This section was duplicated and should be removed as it already exists in the run_simulation_logic function
+
     df = pd.DataFrame(simulation_results).fillna(0)
     full_column_list = ['Order', 'MergeEnergyPrice', 'MEnergy_Amount', 'Total_Difficulty', 'ExpeditionEnergyReward', 'MergeItemReward',
                         'Requirement_1', 'Weight_1', 'ChainId_1', 'Level_1', 'RewardDifficulty_1',
@@ -302,15 +648,23 @@ def update_ui_from_files(chain_files, ruleset_file, settings_file):
     energy_df_data, item_df_data = [], []
     
     if ruleset_file:
+        # ERROR_FIX: Enhanced ruleset parsing with validation
         ruleset = load_ruleset_config(ruleset_file)
         max_hist, inc_diff, energy_chance = ruleset.MaxHistoryOrders, ruleset.IncrementDifficulty, ruleset.OverallChanceToDropExpeditionEnergy
         req_weights = ",".join(map(str, ruleset.OverrideMaxOrdersWithWeight.Weights))
+        
+        # ERROR_FIX: Extract rewards data with NaN validation
         for rg in ruleset.EnergyRewards:
-            for r in rg.Rewards:
-                energy_df_data.append([rg.DifficultyScore, r.Amount])
+            if pd.notna(rg.DifficultyScore):
+                for r in rg.Rewards:
+                    energy_df_data.append([rg.DifficultyScore, r.Amount])
         for rg in ruleset.ItemRewards:
-            for r in rg.Rewards:
-                item_df_data.append([rg.DifficultyScore, r.Amount, r.MergeItemId, r.RewardWeight, r.ReductionFactor])
+            if pd.notna(rg.DifficultyScore):
+                for r in rg.Rewards:
+                    item_df_data.append([rg.DifficultyScore, r.Amount, r.MergeItemId, r.RewardWeight, r.ReductionFactor])
+        
+        # DEBUG_LOG: Reward extraction statistics
+        print(f"LOADED: {len(energy_df_data)} energy_rewards, {len(item_df_data)} item_rewards")
         
     energy_df = pd.DataFrame(energy_df_data, columns=['DifficultyScore', 'Amount'])
     item_df = pd.DataFrame(item_df_data, columns=['DifficultyScore', 'Amount', 'MergeItemId', 'RewardWeight', 'ReductionFactor'])

config_manager.py

@@ -0,0 +1,163 @@
+import json
+import os
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from dataclasses import asdict, dataclass
+import pandas as pd
+
+# ===============================================================
+# CONFIG MANAGEMENT SYSTEM
+# ===============================================================
+
+@dataclass
+class SimulatorConfig:
+    """Конфигурация симулятора для сохранения и загрузки"""
+    name: str
+    description: str
+    created_at: str
+    
+    # Настройки генератора
+    max_history_orders: int = 5
+    increment_difficulty: int = 2
+    energy_chance: int = 90
+    requirement_weights: str = "70,30"
+    reduction_factor: int = 3
+    increase_factor: int = 5
+    
+    # Симуляция
+    iteration_count: int = 100
+    initial_energy: int = 10000
+    
+    # Данные цепочек (JSON сериализованные)
+    chain_data: List[Dict[str, Any]] = None
+    energy_rewards_data: List[Dict[str, Any]] = None
+    item_rewards_data: List[Dict[str, Any]] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        return asdict(self)
+    
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> 'SimulatorConfig':
+        return cls(**data)
+
+class ConfigManager:
+    """Менеджер конфигураций симулятора"""
+    
+    def __init__(self, config_dir: str = "configs"):
+        self.config_dir = config_dir
+        self.ensure_config_dir()
+    
+    def ensure_config_dir(self):
+        """Создает директорию для конфигураций если её нет"""
+        if not os.path.exists(self.config_dir):
+            os.makedirs(self.config_dir)
+    
+    def save_config(self, config: SimulatorConfig) -> str:
+        """Сохраняет конфигурацию в файл"""
+        filename = f"{config.name.replace(' ', '_').lower()}_{datetime.now().strftime('%Y%m%d_%H%M%S')}.json"
+        filepath = os.path.join(self.config_dir, filename)
+        
+        with open(filepath, 'w', encoding='utf-8') as f:
+            json.dump(config.to_dict(), f, indent=2, ensure_ascii=False)
+        
+        return filepath
+    
+    def load_config(self, filepath: str) -> SimulatorConfig:
+        """Загружает конфигурацию из файла"""
+        with open(filepath, 'r', encoding='utf-8') as f:
+            data = json.load(f)
+        
+        return SimulatorConfig.from_dict(data)
+    
+    def list_configs(self) -> List[Dict[str, str]]:
+        """Возвращает список доступных конфигураций"""
+        configs = []
+        
+        if not os.path.exists(self.config_dir):
+            return configs
+        
+        for filename in os.listdir(self.config_dir):
+            if filename.endswith('.json'):
+                filepath = os.path.join(self.config_dir, filename)
+                try:
+                    config = self.load_config(filepath)
+                    configs.append({
+                        'name': config.name,
+                        'description': config.description,
+                        'created_at': config.created_at,
+                        'filepath': filepath
+                    })
+                except Exception as e:
+                    print(f"Error loading config {filename}: {e}")
+        
+        return sorted(configs, key=lambda x: x['created_at'], reverse=True)
+    
+    def delete_config(self, filepath: str) -> bool:
+        """Удаляет конфигурацию"""
+        try:
+            os.remove(filepath)
+            return True
+        except Exception as e:
+            print(f"Error deleting config: {e}")
+            return False
+
+def create_config_from_ui_state(
+    name: str,
+    description: str,
+    chain_df,
+    energy_rewards_df,
+    item_rewards_df,
+    max_history: int,
+    increment_diff: int,
+    energy_chance: int,
+    req_weights: str,
+    reduction_factor: int,
+    increase_factor: int,
+    iteration_count: int,
+    initial_energy: int
+) -> SimulatorConfig:
+    """Создает конфигурацию из состояния UI"""
+    
+    # Преобразуем DataFrames в JSON-сериализуемые структуры
+    chain_data = chain_df.to_dict('records') if chain_df is not None and not chain_df.empty else []
+    energy_rewards_data = energy_rewards_df.to_dict('records') if energy_rewards_df is not None and not energy_rewards_df.empty else []
+    item_rewards_data = item_rewards_df.to_dict('records') if item_rewards_df is not None and not item_rewards_df.empty else []
+    
+    return SimulatorConfig(
+        name=name,
+        description=description,
+        created_at=datetime.now().isoformat(),
+        max_history_orders=max_history,
+        increment_difficulty=increment_diff,
+        energy_chance=energy_chance,
+        requirement_weights=req_weights,
+        reduction_factor=reduction_factor,
+        increase_factor=increase_factor,
+        iteration_count=iteration_count,
+        initial_energy=initial_energy,
+        chain_data=chain_data,
+        energy_rewards_data=energy_rewards_data,
+        item_rewards_data=item_rewards_data
+    )
+
+def apply_config_to_ui(config: SimulatorConfig):
+    """Применяет конфигурацию к состоянию UI"""
+    
+    # Восстанавливаем DataFrames
+    chain_df = pd.DataFrame(config.chain_data) if config.chain_data else pd.DataFrame(columns=['ChainId', 'MergeItemId', 'RequirementWeight', 'RewardDifficulty'])
+    energy_rewards_df = pd.DataFrame(config.energy_rewards_data) if config.energy_rewards_data else pd.DataFrame(columns=['DifficultyScore', 'Amount'])
+    item_rewards_df = pd.DataFrame(config.item_rewards_data) if config.item_rewards_data else pd.DataFrame(columns=['DifficultyScore', 'Amount', 'MergeItemId', 'RewardWeight', 'ReductionFactor'])
+    
+    return (
+        chain_df,
+        config.max_history_orders,
+        config.increment_difficulty,
+        config.energy_chance,
+        config.requirement_weights,
+        config.reduction_factor,
+        config.increase_factor,
+        energy_rewards_df,
+        item_rewards_df,
+        config.iteration_count,
+        config.initial_energy
+    )

mcp_server.py

@@ -0,0 +1,628 @@
+"""
+MCP Server для интеграции симулятора заказов с ИИ агентами
+Предоставляет инструменты для автоматизированной работы с симулятором
+"""
+
+import json
+import pandas as pd
+from typing import Dict, List, Any, Optional, Union
+from dataclasses import asdict
+import tempfile
+import os
+
+from config_manager import ConfigManager, SimulatorConfig, create_config_from_ui_state, apply_config_to_ui
+
+class MergeSimulatorMCPServer:
+    """MCP сервер для симулятора генерации заказов"""
+    
+    def __init__(self):
+        self.config_manager = ConfigManager()
+        self.current_simulation_results = None
+        self.current_stats_report = ""
+    
+    # ===============================================================
+    # CONFIG MANAGEMENT TOOLS
+    # ===============================================================
+    
+    def mcp_save_simulator_config(
+        self,
+        name: str,
+        description: str,
+        chain_data: List[Dict[str, Any]] = None,
+        energy_rewards_data: List[Dict[str, Any]] = None,
+        item_rewards_data: List[Dict[str, Any]] = None,
+        max_history_orders: int = 5,
+        increment_difficulty: int = 2,
+        energy_chance: int = 90,
+        requirement_weights: str = "70,30",
+        reduction_factor: int = 3,
+        increase_factor: int = 5,
+        iteration_count: int = 100,
+        initial_energy: int = 10000
+    ) -> Dict[str, Any]:
+        """
+        Сохраняет конфигурацию симулятора для последующего использования
+        
+        Args:
+            name: Название конфигурации
+            description: Описание конфигурации
+            chain_data: Данные цепочек merge-предметов
+            energy_rewards_data: Данные энергетических наград
+            item_rewards_data: Данные предметных наград
+            max_history_orders: Максимальное количество заказов в истории
+            increment_difficulty: Инкремент сложности
+            energy_chance: Шанс выпадения энергетической награды (%)
+            requirement_weights: Веса требований (строка, например "70,30")
+            reduction_factor: Фактор уменьшения
+            increase_factor: Фактор увеличения
+            iteration_count: Количество итераций симуляции
+            initial_energy: Начальное количество энергии
+            
+        Returns:
+            Словарь с результатом операции и путем к сохраненному файлу
+        """
+        try:
+            config = SimulatorConfig(
+                name=name,
+                description=description,
+                created_at=pd.Timestamp.now().isoformat(),
+                max_history_orders=max_history_orders,
+                increment_difficulty=increment_difficulty,
+                energy_chance=energy_chance,
+                requirement_weights=requirement_weights,
+                reduction_factor=reduction_factor,
+                increase_factor=increase_factor,
+                iteration_count=iteration_count,
+                initial_energy=initial_energy,
+                chain_data=chain_data or [],
+                energy_rewards_data=energy_rewards_data or [],
+                item_rewards_data=item_rewards_data or []
+            )
+            
+            filepath = self.config_manager.save_config(config)
+            
+            return {
+                "success": True,
+                "message": f"Конфигурация '{name}' успешно сохранена",
+                "filepath": filepath,
+                "config_name": name
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Ошибка при сохранении конфигурации: {str(e)}"
+            }
+    
+    def mcp_load_simulator_config(self, config_name_or_path: str) -> Dict[str, Any]:
+        """
+        Загружает конфигурацию симулятора
+        
+        Args:
+            config_name_or_path: Название конфигурации или путь к файлу
+            
+        Returns:
+            Словарь с данными конфигурации
+        """
+        try:
+            # Если передан путь к файлу
+            if config_name_or_path.endswith('.json') and os.path.exists(config_name_or_path):
+                config = self.config_manager.load_config(config_name_or_path)
+            else:
+                # Ищем конфигурацию п�� имени
+                configs = self.config_manager.list_configs()
+                matching_config = next((c for c in configs if c['name'] == config_name_or_path), None)
+                
+                if not matching_config:
+                    return {
+                        "success": False,
+                        "error": f"Конфигурация '{config_name_or_path}' не найдена",
+                        "available_configs": [c['name'] for c in configs]
+                    }
+                
+                config = self.config_manager.load_config(matching_config['filepath'])
+            
+            return {
+                "success": True,
+                "config": config.to_dict(),
+                "message": f"Конфигурация '{config.name}' успешно загружена"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Ошибка при загрузке конфигурации: {str(e)}"
+            }
+    
+    def mcp_list_simulator_configs(self) -> Dict[str, Any]:
+        """
+        Возвращает список доступных конфигураций симулятора
+        
+        Returns:
+            Словарь со списком конфигураций
+        """
+        try:
+            configs = self.config_manager.list_configs()
+            return {
+                "success": True,
+                "configs": configs,
+                "count": len(configs),
+                "message": f"Найдено {len(configs)} конфигураций"
+            }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Ошибка при получении списка конфигураций: {str(e)}"
+            }
+    
+    def mcp_delete_simulator_config(self, config_name_or_path: str) -> Dict[str, Any]:
+        """
+        Удаляет конфигурацию симулятора
+        
+        Args:
+            config_name_or_path: Название конфигурации или путь к файлу
+            
+        Returns:
+            Словарь с результатом операции
+        """
+        try:
+            # Если передан путь к файлу
+            if config_name_or_path.endswith('.json') and os.path.exists(config_name_or_path):
+                filepath = config_name_or_path
+            else:
+                # Ищем конфигурацию по имени
+                configs = self.config_manager.list_configs()
+                matching_config = next((c for c in configs if c['name'] == config_name_or_path), None)
+                
+                if not matching_config:
+                    return {
+                        "success": False,
+                        "error": f"Конфигурация '{config_name_or_path}' не найдена"
+                    }
+                
+                filepath = matching_config['filepath']
+            
+            success = self.config_manager.delete_config(filepath)
+            
+            if success:
+                return {
+                    "success": True,
+                    "message": f"Конфигурация успешно удалена"
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": "Не удалось удалить конфигурацию"
+                }
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Ошибка при удалении конфигурации: {str(e)}"
+            }
+    
+    # ===============================================================
+    # SIMULATION TOOLS
+    # ===============================================================
+    
+    def mcp_run_simulation(
+        self,
+        config_name_or_data: Union[str, Dict[str, Any]] = None,
+        chain_data: List[Dict[str, Any]] = None,
+        energy_rewards_data: List[Dict[str, Any]] = None,
+        item_rewards_data: List[Dict[str, Any]] = None,
+        max_history_orders: int = None,
+        increment_difficulty: int = None,
+        energy_chance: int = None,
+        requirement_weights: str = None,
+        reduction_factor: int = None,
+        increase_factor: int = None,
+        iteration_count: int = None,
+        initial_energy: int = None,
+        return_detailed_results: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Запускает симуляцию генерации заказов
+        
+        Args:
+            config_name_or_data: Название конфигурации или данные конфигурации
+            chain_data: Данные цепочек (переопределяет данные из конфигур��ции)
+            energy_rewards_data: Данные энергетических наград
+            item_rewards_data: Данные предметных наград
+            max_history_orders: Максимальное количество заказов в истории
+            increment_difficulty: Инкремент сложности
+            energy_chance: Шанс выпадения энергетической награды (%)
+            requirement_weights: Веса требований
+            reduction_factor: Фактор уменьшения
+            increase_factor: Фактор увеличения
+            iteration_count: Количество итераций симуляции
+            initial_energy: Начальное количество энергии
+            return_detailed_results: Возвращать ли детальные результаты
+            
+        Returns:
+            Словарь с результатами симуляции
+        """
+        try:
+            # Импортируем функцию симуляции
+            from app import run_simulation_interface
+            
+            # Загружаем конфигурацию если указано имя
+            if isinstance(config_name_or_data, str):
+                config_result = self.mcp_load_simulator_config(config_name_or_data)
+                if not config_result["success"]:
+                    return config_result
+                config_data = config_result["config"]
+            elif isinstance(config_name_or_data, dict):
+                config_data = config_name_or_data
+            else:
+                config_data = {}
+            
+            # Применяем параметры (переданные параметры имеют приоритет над конфигурацией)
+            params = {
+                'max_history': max_history_orders or config_data.get('max_history_orders', 5),
+                'increment_diff': increment_difficulty or config_data.get('increment_difficulty', 2),
+                'energy_chance': energy_chance or config_data.get('energy_chance', 90),
+                'req_weights': requirement_weights or config_data.get('requirement_weights', "70,30"),
+                'reduction_factor': reduction_factor or config_data.get('reduction_factor', 3),
+                'increase_factor': increase_factor or config_data.get('increase_factor', 5),
+                'iteration_count': iteration_count or config_data.get('iteration_count', 100),
+                'initial_energy': initial_energy or config_data.get('initial_energy', 10000)
+            }
+            
+            # Подготавливаем данные
+            chain_df = pd.DataFrame(chain_data or config_data.get('chain_data', []))
+            energy_rewards_df = pd.DataFrame(energy_rewards_data or config_data.get('energy_rewards_data', []))
+            item_rewards_df = pd.DataFrame(item_rewards_data or config_data.get('item_rewards_data', []))
+            
+            # Запускаем симуляцию
+            results_df, stats_report, _, _ = run_simulation_interface(
+                chain_df, energy_rewards_df, item_rewards_df,
+                params['max_history'], params['increment_diff'], params['energy_chance'],
+                params['req_weights'], params['reduction_factor'], params['increase_factor'],
+                params['iteration_count'], params['initial_energy']
+            )
+            
+            # Сохраняем результаты
+            self.current_simulation_results = results_df
+            self.current_stats_report = stats_report
+            
+            response = {
+                "success": True,
+                "message": "Симуляция завершена успешно",
+                "stats_report": stats_report,
+                "total_orders": len(results_df),
+                "simulation_parameters": params
+            }
+            
+            if return_detailed_results:
+                response["detailed_results"] = results_df.to_dict('records')
+            
+            return response
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Ошибка при выполнении симуляции: {str(e)}"
+            }
+    
+    def mcp_get_simulation_results(self, format: str = "summary") -> Dict[str, Any]:
+        """
+        Получает результаты последней симуляции
+        
+        Args:
+            format: Формат результатов ("summary", "detailed", "csv")
+            
+        Returns:
+            Словарь с результатами симуляции
+        """
+        try:
+            if self.current_simulation_results is None:
+                return {
+                    "success": False,
+                    "error": "Нет доступн��х результатов симуляции",
+                    "message": "Сначала запустите симуляцию"
+                }
+            
+            if format == "summary":
+                return {
+                    "success": True,
+                    "stats_report": self.current_stats_report,
+                    "total_orders": len(self.current_simulation_results),
+                    "avg_difficulty": self.current_simulation_results['Total_Difficulty'].mean(),
+                    "final_energy": self.current_simulation_results['MEnergy_Amount'].iloc[-1] if len(self.current_simulation_results) > 0 else 0
+                }
+            elif format == "detailed":
+                return {
+                    "success": True,
+                    "stats_report": self.current_stats_report,
+                    "detailed_results": self.current_simulation_results.to_dict('records')
+                }
+            elif format == "csv":
+                # Создаем временный CSV файл
+                with tempfile.NamedTemporaryFile(mode='w', delete=False, suffix='.csv', encoding='utf-8') as tmp_file:
+                    self.current_simulation_results.to_csv(tmp_file.name, index=False)
+                    csv_path = tmp_file.name
+                
+                return {
+                    "success": True,
+                    "csv_file_path": csv_path,
+                    "stats_report": self.current_stats_report
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"Неизвестный формат: {format}",
+                    "available_formats": ["summary", "detailed", "csv"]
+                }
+                
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Ошибка при получении результатов: {str(e)}"
+            }
+    
+    def mcp_analyze_simulation_results(self, analysis_type: str = "basic") -> Dict[str, Any]:
+        """
+        Анализирует результаты симуляции
+        
+        Args:
+            analysis_type: Тип анализа ("basic", "detailed", "chains", "rewards")
+            
+        Returns:
+            Словарь с результатами анализа
+        """
+        try:
+            if self.current_simulation_results is None:
+                return {
+                    "success": False,
+                    "error": "Нет доступных результатов симуляции",
+                    "message": "Сначала запустите симуляцию"
+                }
+            
+            df = self.current_simulation_results
+            
+            if analysis_type == "basic":
+                return {
+                    "success": True,
+                    "analysis": {
+                        "total_orders": len(df),
+                        "avg_difficulty": float(df['Total_Difficulty'].mean()),
+                        "min_difficulty": int(df['Total_Difficulty'].min()),
+                        "max_difficulty": int(df['Total_Difficulty'].max()),
+                        "avg_energy_cost": float(df['MergeEnergyPrice'].mean()),
+                        "total_energy_spent": int(df['MergeEnergyPrice'].sum()),
+                        "final_energy": int(df['MEnergy_Amount'].iloc[-1]) if len(df) > 0 else 0,
+                        "energy_rewards_count": int((df['ExpeditionEnergyReward'] > 0).sum()),
+                        "item_rewards_count": int((df['MergeItemReward'] != "").sum())
+                    }
+                }
+            elif analysis_type == "chains":
+                # Анализ по цепочкам
+                chain_analysis = {}
+                for col in df.columns:
+                    if col.startswith('ChainId_'):
+                        chain_counts = df[col].value_counts()
+                        chain_analysis.update(chain_counts.to_dict())
+                
+                return {
+                    "success": True,
+                    "chain_usage": chain_analysis,
+                    "most_used_chain": max(chain_analysis.items(), key=lambda x: x[1]) if chain_analysis else None
+                }
+            elif analysis_type == "rewards":
+                # Анализ наград
+                energy_rewards = df[df['ExpeditionEnergyReward'] > 0]
+                item_rewards = df[df['MergeItemReward'] != ""]
+                
+                return {
+                    "success": True,
+                    "rewards_analysis": {
+                        "energy_rewards": {
+                            "count": len(energy_rewards),
+                            "total_amount": int(energy_rewards['ExpeditionEnergyReward'].sum()),
+                            "avg_amount": float(energy_rewards['ExpeditionEnergyReward'].mean()) if len(energy_rewards) > 0 else 0
+                        },
+                        "item_rewards": {
+                            "count": len(item_rewards),
+                            "unique_items": item_rewards['MergeItemReward'].nunique(),
+                            "most_common_item": item_rewards['MergeItemReward'].mode().iloc[0] if len(item_rewards) > 0 else None
+                        }
+                    }
+                }
+            else:
+                return {
+                    "success": False,
+                    "error": f"Неизвестный тип анализа: {analysis_type}",
+                    "available_types": ["basic", "chains", "rewards"]
+                }
+                
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Ошибка при анализе результатов: {str(e)}"
+            }
+    
+    # ===============================================================
+    # UTILITY TOOLS
+    # ===============================================================
+    
+    def mcp_create_chain_data_template(self) -> Dict[str, Any]:
+        """
+        Создает шаблон данных для цепочек merge-предметов
+        
+        Returns:
+            Словарь с шаблоном данных цепочек
+        """
+        template = [
+            {
+                "ChainId": "example_chain",
+                "MergeItemId": "item_level_1",
+                "RequirementWeight": 100,
+                "RewardDifficulty": 10
+            },
+            {
+                "ChainId": "example_chain",
+                "MergeItemId": "item_level_2",
+                "RequirementWeight": 80,
+                "RewardDifficulty": 25
+            },
+            {
+                "ChainId": "example_chain",
+                "MergeItemId": "item_level_3",
+                "RequirementWeight": 60,
+                "RewardDifficulty": 50
+            }
+        ]
+        
+        return {
+            "success": True,
+            "template": template,
+            "description": "Шаблон данных цепочек. ChainId - идентификатор цепочки, MergeItemId - идентификатор предмета, RequirementWeight - вес для генерации требований, RewardDifficulty - сложность для расчета наград"
+        }
+    
+    def mcp_create_rewards_data_template(self) -> Dict[str, Any]:
+        """
+        Создает шаблоны данных для наград
+        
+        Returns:
+            Словарь с шаблонами данных наград
+        """
+        energy_template = [
+            {"DifficultyScore": 100, "Amount": 1},
+            {"DifficultyScore": 500, "Amount": 3},
+            {"DifficultyScore": 1000, "Amount": 5}
+        ]
+        
+        item_template = [
+            {
+                "DifficultyScore": 200,
+                "Amount": 1,
+                "MergeItemId": "energy_1",
+                "RewardWeight": 80,
+                "ReductionFactor": 5
+            },
+            {
+                "DifficultyScore": 500,
+                "Amount": 1,
+                "MergeItemId": "coins_1",
+                "RewardWeight": 20,
+                "ReductionFactor": 0
+            }
+        ]
+        
+        return {
+            "success": True,
+            "energy_rewards_template": energy_template,
+            "item_rewards_template": item_template,
+            "description": "Шаблоны данных наград. DifficultyScore - порог сложности, Amount - количество награды, MergeItemId - ID предмета для предметных наград, RewardWeight - вес награды, ReductionFactor - фактор уменьшения"
+        }
+    
+    def mcp_validate_config_data(self, config_data: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Валидирует данные конфигурации симулятора
+        
+        Args:
+            config_data: Данные конфигурации для валидации
+            
+        Returns:
+            Словарь с результатами валидации
+        """
+        try:
+            errors = []
+            warnings = []
+            
+            # Проверяем обязательные поля
+            required_fields = ['name', 'description']
+            for field in required_fields:
+                if not config_data.get(field):
+                    errors.append(f"Отсутствует обязательное поле: {field}")
+            
+            # Проверяем числовые параметры
+            numeric_params = {
+                'max_history_orders': (1, 20),
+                'increment_difficulty': (0, 10),
+                'energy_chance': (0, 100),
+                'reduction_factor': (0, 100),
+                'increase_factor': (0, 100),
+                'iteration_count': (1, 10000),
+                'initial_energy': (1, 1000000)
+            }
+            
+            for param, (min_val, max_val) in numeric_params.items():
+                value = config_data.get(param)
+                if value is not None:
+                    if not isinstance(value, (int, float)) or value < min_val or value > max_val:
+                        errors.append(f"Параметр {param} должен быть числом от {min_val} до {max_val}")
+            
+            # Проверяем данные цепочек
+            chain_data = config_data.get('chain_data', [])
+            if chain_data:
+                for i, chain_item in enumerate(chain_data):
+                    if not chain_item.get('ChainId'):
+                        errors.append(f"Цепочка {i+1}: отсутствует ChainId")
+                    if not chain_item.get('MergeItemId'):
+                        errors.append(f"Цепочка {i+1}: отсутствует MergeItemId")
+                    if not isinstance(chain_item.get('RequirementWeight', 0), (int, float)):
+                        errors.append(f"Цепочка {i+1}: RequirementWeight должен быть числом")
+                    if not isinstance(chain_item.get('RewardDifficulty', 0), (int, float)):
+                        errors.append(f"Цепочка {i+1}: RewardDifficulty должен быть числом")
+            else:
+                warnings.append("Нет данных о цепочках - симуляция может не работать корректно")
+            
+            # Проверяем веса требований
+            req_weights = config_data.get('requirement_weights', "70,30")
+            try:
+                weights = [int(w.strip()) for w in req_weights.split(',')]
+                if len(weights) != 2:
+                    errors.append("Веса требований должны содержать ровно 2 значения")
+                elif any(w < 0 for w in weights):
+                    errors.append("Веса требований должны быть положительными числами")
+            except:
+                errors.append("Неверный формат весов требований (ожидается 'число,число')")
+            
+            is_valid = len(errors) == 0
+            
+            return {
+                "success": True,
+                "is_valid": is_valid,
+                "errors": errors,
+                "warnings": warnings,
+                "message": "Конфигурация валидна" if is_valid else f"Найдено {len(errors)} ошибок"
+            }
+            
+        except Exception as e:
+            return {
+                "success": False,
+                "error": str(e),
+                "message": f"Ошибка при валидации: {str(e)}"
+            }
+
+# ===============================================================
+# MCP SERVER INSTANCE
+# ===============================================================
+
+# Глобальный экземпляр MCP сервера
+mcp_server = MergeSimulatorMCPServer()
+
+# Экспорт функций для использования в других модулях
+def get_mcp_server() -> MergeSimulatorMCPServer:
+    """Возвращает экземпляр MCP сервера"""
+    return mcp_server
+
+# Список всех доступных MCP функций
+MCP_FUNCTIONS = {
+    "mcp_save_simulator_config": mcp_server.mcp_save_simulator_config,
+    "mcp_load_simulator_config": mcp_server.mcp_load_simulator_config,
+    "mcp_list_simulator_configs": mcp_server.mcp_list_simulator_configs,
+    "mcp_delete_simulator_config": mcp_server.mcp_delete_simulator_config,
+    "mcp_run_simulation": mcp_server.mcp_run_simulation,
+    "mcp_get_simulation_results": mcp_server.mcp_get_simulation_results,
+    "mcp_analyze_simulation_results": mcp_server.mcp_analyze_simulation_results,
+    "mcp_create_chain_data_template": mcp_server.mcp_create_chain_data_template,
+    "mcp_create_rewards_data_template": mcp_server.mcp_create_rewards_data_template,
+    "mcp_validate_config_data": mcp_server.mcp_validate_config_data
+}