version 1

app.py

@@ -5,266 +5,384 @@ import io
 import random
 import os
 from collections import deque
+import tempfile
+from dataclasses import dataclass, field
+from typing import List, Dict, Any, Optional
 
-# HELPER FUNCTIONS TO PARSE .asset FILES
-def parse_asset_file(file_content):
-    """Parses a YAML-like .asset file from a string, skipping the initial %YAML and %TAG lines."""
-    if file_content is None:
-        return None
+# ===============================================================
+# 1. DATA CLASSES (полная структура)
+# ===============================================================
+@dataclass
+class MergeChainItemData:
+    MergeItemId: str
+    RequirementWeight: int
+    RewardDifficulty: int
+
+@dataclass
+class MergeChain:
+    Id: str
+    Items: List[MergeChainItemData] = field(default_factory=list)
+
+@dataclass
+class GenerationReward:
+    Amount: int
+    MergeItemId: str = ""
+    Type: str = "Energy"
+    RewardWeight: int = 100
+    ReductionFactor: int = 0
+
+@dataclass
+class GenerationRewardWithDifficulty:
+    DifficultyScore: int
+    Rewards: List[GenerationReward] = field(default_factory=list)
+
+@dataclass
+class RequirementWeight:
+    Weights: List[int] = field(default_factory=lambda: [70, 30])
+
+@dataclass
+class GeneratorSettings:
+    Id: str = "DefaultSettings"
+    DefaultRequirementWeights: RequirementWeight = field(default_factory=RequirementWeight)
+    MaxActiveOrders: int = 4
+    ReductionFactor: int = 3
+    IncreaseFactor: int = 5
+
+@dataclass
+class MergeGeneratorRuleset:
+    Id: str = "DefaultRuleset"
+    MaxHistoryOrders: int = 5
+    IncrementDifficulty: int = 2
+    OverallChanceToDropExpeditionEnergy: int = 90
+    OverrideWeights: Dict[str, int] = field(default_factory=dict)
+    EnergyRewards: List[GenerationRewardWithDifficulty] = field(default_factory=list)
+    ItemRewards: List[GenerationRewardWithDifficulty] = field(default_factory=list)
+    OverrideMaxRequirementOrders: bool = False
+    OverrideMaxOrdersWithWeight: RequirementWeight = field(default_factory=RequirementWeight)
+
+@dataclass
+class SimulatedOrder:
+    Requirements: list = field(default_factory=list)
+    Rewards: list = field(default_factory=list)
+    TotalDifficulty: int = 0
+    MergeEnergyPrice: int = 0
+
+# ===============================================================
+# 2. ADVANCED PARSERS
+# ===============================================================
+def robust_asset_parser(file_content: str) -> dict:
     try:
-        # Find the first '---' which indicates the start of the YAML document
-        yaml_start = file_content.find('---')
-        if yaml_start == -1:
-            raise ValueError("Not a valid Unity .asset file (missing '---')")
-        
-        # Clean up the content for standard YAML parsing
-        yaml_content = file_content[yaml_start:]
-        # Remove the MonoBehaviour header which is not valid YAML
-        lines = yaml_content.split('\n')
-        cleaned_lines = [line for line in lines if not line.strip().startswith('MonoBehaviour:')]
-        cleaned_yaml = '\n'.join(cleaned_lines)
-
-        # The file seems to have a custom serialization format within 'serializationData'.
-        # For now, we will parse the main structure.
-        # A more robust solution might need a dedicated parser for Unity's format.
-        
-        # Let's try to parse the main body first
-        data = yaml.safe_load(io.StringIO(cleaned_yaml))
-        
-        # A simplified approach to extract key-value pairs for now
-        # This will need to be much more robust based on the actual file structure.
-        config_data = {}
-        for line in file_content.split('\n'):
-            if ':' in line:
-                parts = line.split(':', 1)
-                key = parts[0].strip()
-                value = parts[1].strip()
-                if key.startswith('_'):
-                    config_data[key] = value
-
-        return config_data, data
+        lines = file_content.splitlines()
+        mono_behaviour_line_index = next((i for i, line in enumerate(lines) if "MonoBehaviour:" in line), -1)
+        if mono_behaviour_line_index == -1: return {}
+        data_lines = lines[mono_behaviour_line_index + 1:]
+        if not data_lines: return {}
+        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 {}
     except Exception as e:
-        print(f"Error parsing file: {e}")
-        return None, None
-
-# --- SIMULATION LOGIC ---
-def run_simulation_logic(ruleset_file, chain_files, iteration_count, initial_energy):
-    """
-    This function will contain the Python port of the C# MergeOrderSimulationService.
-    For now, it returns placeholder data.
-    """
-    # Placeholder for parsed ruleset
-    ruleset_id = "ruleset_placeholder"
-    
-    # Placeholder for selected chain IDs
-    selected_chain_ids = [f"chain_{i}" for i in range(len(chain_files))]
-    
-    # --- This is where the core simulation logic will go ---
-    # We will replicate the steps from MergeOrderSimulationService.cs:
-    # 1. Get all available items from selected chains.
-    # 2. Apply MergeBoardItemFinder simulation.
-    # 3. Filter by unlock level.
-    # 4. Filter recently used items.
-    # 5. Generate order with proper difficulty.
-    # 6. Update history.
-    # 7. Calculate costs and rewards.
-    # 8. Store data for CSV.
+        print(f"Asset parsing error: {e}")
+        return {}
+
+def load_chain_config(file) -> MergeChain:
+    with open(file.name, 'r', encoding='utf-8') as f: content = f.read()
+    data = robust_asset_parser(content)
+    chain = MergeChain(Id=data.get('_id'))
+    for item_dict in data.get('_mergeChainItemsData', []):
+        chain.Items.append(MergeChainItemData(
+            MergeItemId=item_dict.get('MergeItemId'),
+            RequirementWeight=int(item_dict.get('RequirementWeight', 0)),
+            RewardDifficulty=int(item_dict.get('RewardDifficulty', 0))
+        ))
+    return chain
+
+def parse_rewards_from_data(reward_list_data, reward_type) -> List[GenerationRewardWithDifficulty]:
+    rewards_with_difficulty = []
+    if not isinstance(reward_list_data, list): return rewards_with_difficulty
     
-    # For now, let's generate some dummy data to show in the UI
-    sim_data = []
+    for reward_group in reward_list_data:
+        difficulty = int(reward_group.get('DifficultyScore', 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'))
+        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']
+                        rewards.append(GenerationReward(
+                            Amount=int(reward_info.get('_amount', 1)),
+                            MergeItemId=reward_info.get('_mergeItemId', ''),
+                            Type='Item',
+                            RewardWeight=int(weighted_reward.get('RewardWeight', 100)),
+                            ReductionFactor=int(weighted_reward.get('ReductionFactor', 0))
+                        ))
+        if rewards:
+            rewards_with_difficulty.append(GenerationRewardWithDifficulty(DifficultyScore=difficulty, Rewards=rewards))
+            
+    return rewards_with_difficulty
+
+def load_ruleset_config(file) -> MergeGeneratorRuleset:
+    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}")
+
+    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]
+
+    ruleset = MergeGeneratorRuleset(
+        Id=data.get('_id'),
+        MaxHistoryOrders=int(data.get('_maxHistoryOrders', 5)),
+        IncrementDifficulty=int(data.get('_incrementDifficulty', 2)),
+        OverallChanceToDropExpeditionEnergy=int(data.get('_overallChanceToDropExpeditionEnergy', 90)),
+        OverrideMaxRequirementOrders=bool(int(data.get('_overrideMaxRequirementOrders', 0))),
+        OverrideMaxOrdersWithWeight=RequirementWeight(Weights=weights_list)
+    )
+    ruleset.OverrideWeights = {ow.get('_mergeItemId'): int(ow.get('_weight', 0)) for ow in data.get('_overrideWeights', [])}
+    ruleset.EnergyRewards = parse_rewards_from_data(data.get('_energyRewards', []), "Energy")
+    ruleset.ItemRewards = parse_rewards_from_data(data.get('_itemRewards', []), "Item")
+    print(f"Loaded {len(ruleset.EnergyRewards)} energy reward groups and {len(ruleset.ItemRewards)} item reward groups.")
+    return ruleset
+
+def load_settings_config(file) -> GeneratorSettings:
+    with open(file.name, 'r', encoding='utf-8') as f: content = f.read()
+    data = robust_asset_parser(content)
+    return GeneratorSettings(
+        Id=data.get('m_Name', 'MergeGeneratorSettings'),
+        MaxActiveOrders=int(data.get('_maxActiveOrders', 4)),
+        ReductionFactor=int(data.get('_reductionFactor', 3)),
+        IncreaseFactor=int(data.get('_increaseFactor', 5))
+    )
+
+# ===============================================================
+# 3. SIMULATION LOGIC
+# ===============================================================
+def get_requirement_count(ruleset, settings):
+    weights_source = settings.DefaultRequirementWeights if not ruleset.OverrideMaxRequirementOrders else ruleset.OverrideMaxOrdersWithWeight
+    weights = weights_source.Weights
+    if len(weights) < 2: weights.extend([0] * (2 - len(weights)))
+    return random.choices([1, 2], weights=weights[:2], k=1)[0]
+
+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)]
+        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)]
+        if suitable_reward_groups:
+            chosen_group = max(suitable_reward_groups, key=lambda rg: int(rg.DifficultyScore))
+            if chosen_group.Rewards:
+                rewards, weights = chosen_group.Rewards, [r.RewardWeight for r in chosen_group.Rewards]
+                if sum(weights) > 0: order.Rewards.append(random.choices(rewards, weights=weights, k=1)[0])
+
+def run_simulation_logic(chains, ruleset, settings, iteration_count, initial_energy):
+    order_history = deque(maxlen=ruleset.MaxHistoryOrders)
+    chain_unlock_levels = {chain.Id: 1 for chain in chains}
+    simulation_results = []
     current_energy = initial_energy
-    difficulty_history = deque(maxlen=5) # Assuming max history of 5 from ruleset
 
     for i in range(iteration_count):
-        req1 = f"merge_item_wood_branch_{random.randint(1, 3)}"
-        req2 = f"merge_item_stones_stones_{random.randint(1, 2)}" if random.random() > 0.5 else ""
-        energy_cost = random.randint(5, 20)
-        current_energy -= energy_cost
-        total_difficulty = random.randint(500, 2000)
-        difficulty_history.append(total_difficulty)
+        all_available_items = [item for chain in chains for level, item in enumerate(chain.Items, 1) if item.RequirementWeight > 0 and level <= chain_unlock_levels.get(chain.Id, 1)]
+        recently_used_ids = {req.MergeItemId for order in order_history for req in order.Requirements}
+        final_items = [item for item in all_available_items if item.MergeItemId not in recently_used_ids] or all_available_items
+        if not final_items: continue
+
+        req_count = get_requirement_count(ruleset, settings)
+        order = SimulatedOrder()
+        used_items_in_order = []
+
+        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
+            
+            weights = [ruleset.OverrideWeights.get(item.MergeItemId, item.RequirementWeight) for item in selectable_items]
+            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)
         
-        sim_data.append({
-            "Order": i + 1,
-            "MEnergy_Price": energy_cost,
-            "MEnergy_Amount": current_energy,
-            "Requirement_1": req1,
-            "Weight_1": random.randint(50, 150),
-            "ChainId_1": "orders_merge_wood",
-            "Level_1": int(req1.split('_')[-1]),
-            "Requirement_2": req2,
-            "Weight_2": random.randint(75, 125) if req2 else 0,
-            "ChainId_2": "merge_stones" if req2 else "",
-            "Level_2": int(req2.split('_')[-1]) if req2 else 0,
-            "Total_Difficulty": total_difficulty,
-            "Adjusted_Difficulty": total_difficulty + sum(list(difficulty_history)[:-1]),
-        })
-
-    df = pd.DataFrame(sim_data)
-    
-    # Placeholder for statistics report
-    stats_report = f"""
-SIMULATION STATISTICS
-=====================
-Total Orders Generated: {iteration_count}
-Average Difficulty: {df['Total_Difficulty'].mean():.2f}
-
-Item Frequency (Top 5):
-{df['Requirement_1'].value_counts().head(5).to_string()}
-    """
-    
-    return df, stats_report, "simulation_results.csv", "simulation_stats.txt"
+        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)))
+        order.MergeEnergyPrice = total_cost
+        current_energy -= total_cost
+        
+        generate_rewards(order, ruleset)
+        order_history.append(order)
 
-def run_simulation_interface(ruleset_file, chain_files, iteration_count, initial_energy):
-    if not ruleset_file or not chain_files:
-        raise gr.Error("Пожалуйста, загрузите файл правил и хотя бы один файл цепочки.")
+        for req in order.Requirements:
+            chain_of_item = next((c for c in chains if req in c.Items), None)
+            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}
+        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
+            row[f'Weight_{j+1}'] = ruleset.OverrideWeights.get(req.MergeItemId, req.RequirementWeight)
+            row[f'ChainId_{j+1}'] = chain_of_item.Id if chain_of_item else "N/A"
+            row[f'Level_{j+1}'] = chain_of_item.Items.index(req) + 1 if chain_of_item else 0
+            row[f'RewardDifficulty_{j+1}'] = req.RewardDifficulty
+        
+        row['ExpeditionEnergyReward'] = next((r.Amount for r in order.Rewards if r.Type == 'Energy'), 0)
+        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
     
-    df, stats_report, df_path, report_path = run_simulation_logic(
-        ruleset_file, chain_files, iteration_count, initial_energy
-    )
+    stats_report = f"Total Orders: {len(df)}\nAvg Difficulty: {df['Total_Difficulty'].mean():.2f}\nFinal 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
+):
+    if chain_df is None or chain_df.empty: raise gr.Error("Нет данных о цепочках. Загрузите файлы или заполните таблицу.")
     
-    # Convert DataFrame to a downloadable CSV file
-    csv_buffer = io.StringIO()
-    df.to_csv(csv_buffer, index=False)
-    csv_bytes = csv_buffer.getvalue().encode('utf-8')
-
-    # FIX: Removed the 'name' keyword argument from gr.update for the File component
-    # as it causes a TypeError in recent Gradio versions.
-    return df, stats_report, gr.update(value=csv_bytes, visible=True), gr.update(value=stats_report.encode('utf-8'), visible=True)
-
-# --- COST CALCULATION LOGIC ---
-def run_cost_calculation_logic(chain_files, item_files):
-    """
-    This function will contain the Python port of the C# MergeChainCostCalculator.
-    For now, it returns placeholder data.
-    """
-    # --- This is where the core cost calculation logic will go ---
-    # We will replicate the steps from MergeChainCostCalculator.cs:
-    # 1. Load and parse all merge chain and item configs.
-    # 2. For each chain, find its associated producer (spawner).
-    # 3. For each item in the chain, calculate the expected number of attempts to get it.
-    # 4. Calculate the final energy cost (expected attempts * spawn cost).
-    # 5. Handle dynamic weights (IncWeight).
+    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)
     
-    # Dummy data for now
-    cost_data = []
-    for i, chain_file in enumerate(chain_files):
-        chain_id = f"chain_{i+1}"
-        for level in range(1, 7):
-            cost_data.append({
-                "Chain ID": chain_id,
-                "Item ID": f"{chain_id}_item_{level}",
-                "Level": level,
-                "Producer ID": f"spawner_{i+1}",
-                "Spawn Cost": 5,
-                "Weight": 100 - (level * 10),
-                "Inc Weight": 0,
-                "Expected Attempts": 1.0 + (level * 0.5),
-                "Energy Cost": (1.0 + (level * 0.5)) * 5,
-                "Warning": ""
-            })
-            
-    df = pd.DataFrame(cost_data)
-    return df
-
-def run_cost_calculation_interface(chain_files, item_files):
-    if not chain_files or not item_files:
-        raise gr.Error("Пожалуйста, загрузите файлы цепочек и предметов.")
+    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()]
         
-    df = run_cost_calculation_logic(chain_files, item_files)
-    return df
+    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))
 
-# --- CONFIG EDITOR LOGIC ---
-def view_config_file(file):
-    if file is None:
-        return "Загрузите файл для просмотра.", ""
+    df, stats_report = run_simulation_logic(chains, ruleset, settings, iteration_count, initial_energy)
     
-    # The 'file' object from gr.File is a string path to a temporary file
-    with open(file, 'r', encoding='utf-8') as f:
-        raw_content = f.read()
+    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)
+
+# ===============================================================
+# 4. UI UPDATE FUNCTIONS
+# ===============================================================
+def update_ui_from_files(chain_files, ruleset_file, settings_file):
+    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 = [], []
     
-    return raw_content, os.path.basename(file)
+    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))
+        for rg in ruleset.EnergyRewards:
+            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])
+        
+    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
 
-# --- GRADIO UI ---
+# ===============================================================
+# 5. GRADIO UI
+# ===============================================================
 with gr.Blocks(theme=gr.themes.Soft(), title="Инструмент Балансировки Merge-2") as demo:
     gr.Markdown("# Инструмент для Балансировки Игр Merge-2")
-
     with gr.Tabs():
-        # --- SIMULATION TAB ---
         with gr.TabItem("Симуляция генератора заказов"):
-            gr.Markdown("## Симуляция генератора заказов\nЗагрузите конфиги и запустите симуляцию для получения данных по генерации заказов.")
             with gr.Row():
-                with gr.Column(scale=1):
-                    sim_ruleset_upload = gr.File(label="Загрузить Ruleset (.asset)")
-                    sim_chains_upload = gr.File(label="Загрузить файлы цепочек (.asset)", file_count="multiple")
+                with gr.Column(scale=2):
+                    gr.Markdown("### 1. Загрузите файлы (опционально)")
+                    chain_files_upload = gr.File(label="Файлы цепочек (.asset)", file_count="multiple")
+                    ruleset_upload = gr.File(label="Ruleset (.asset)")
+                    settings_upload = gr.File(label="Settings (.asset)")
+                    
+                    with gr.Accordion("Редактор Мердж-цепочек", open=False):
+                        chain_editor_df = gr.DataFrame(headers=['ChainId', 'MergeItemId', 'RequirementWeight', 'RewardDifficulty'], datatype=['str', 'str', 'number', 'number'], label="Состав цепочек", interactive=True, row_count=(10, "dynamic"))
+
+                    with gr.Accordion("Настройки генератора", open=True):
+                        with gr.Row():
+                            max_history_input = gr.Slider(1, 20, value=5, step=1, label="Макс. заказов в истории")
+                            increment_diff_input = gr.Slider(0, 10, value=2, step=1, label="Инкремент сложности")
+                        with gr.Row():
+                            energy_chance_input = gr.Slider(0, 100, value=90, step=5, label="Шанс награды-энергии (%)")
+                            req_weights_input = gr.Textbox(label="Веса требований (1, 2)", value="70, 30")
+                        with gr.Row():
+                             reduction_factor_input = gr.Number(label="Reduction Factor", value=3)
+                             increase_factor_input = gr.Number(label="Increase Factor", value=5)
+                    
+                    with gr.Accordion("Редактор Наград", open=False):
+                        with gr.Row():
+                            energy_rewards_df = gr.DataFrame(headers=['DifficultyScore', 'Amount'], datatype=['number', 'number'], label="Энергетические награды", interactive=True, col_count=(2, "fixed"), row_count=(5, "dynamic"))
+                            item_rewards_df = gr.DataFrame(headers=['DifficultyScore', 'Amount', 'MergeItemId', 'RewardWeight', 'ReductionFactor'], datatype=['number', 'number', 'str', 'number', 'number'], label="Предметные награды", interactive=True, col_count=(5, "fixed"), row_count=(5, "dynamic"))
+
+                    gr.Markdown("### 2. Запустите симуляцию")
                     sim_iterations = gr.Slider(10, 1000, value=100, step=10, label="Количество итераций")
-                    sim_initial_energy = gr.Number(value=10000, label="Начальное количество энергии")
+                    sim_initial_energy_input = gr.Number(value=10000, label="Начальное количество энергии")
                     sim_run_button = gr.Button("Запустить симуляцию", variant="primary")
+
                 with gr.Column(scale=3):
                     gr.Markdown("### Результаты симуляции")
-                    sim_results_df = gr.DataFrame(label="Данные по заказам")
+                    sim_results_df = gr.DataFrame(label="Данные по заказам", wrap=True)
                     gr.Markdown("### Сводный отчет")
                     sim_stats_report = gr.Textbox(label="Статистика", lines=10)
                     with gr.Row():
                          sim_download_csv = gr.File(label="Скачать CSV", visible=False, interactive=False)
                          sim_download_report = gr.File(label="Скачать отчет", visible=False, interactive=False)
 
-        # --- COST CALCULATION TAB ---
-        with gr.TabItem("Расчет стоимости цепочек"):
-            gr.Markdown("## Расчет стоимости предметов\nЗагрузите конфиги цепочек и спавнеров для расчета стоимости производства предметов в энергии.")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    cost_chains_upload = gr.File(label="Загрузить файлы цепочек (.asset)", file_count="multiple")
-                    cost_items_upload = gr.File(label="Загрузить файлы спавнеров/предметов (.asset)", file_count="multiple")
-                    cost_run_button = gr.Button("Рассчитать стоимость", variant="primary")
-                with gr.Column(scale=3):
-                    gr.Markdown("### Рассчитанная стоимость")
-                    cost_results_df = gr.DataFrame(label="Стоимость предметов в энергии")
-
-        # --- CONFIG EDITOR TAB ---
-        with gr.TabItem("Редактор конфигов"):
-            gr.Markdown("## Редактор Конфигурационных Файлов\nЗагрузите файл для пр��смотра и редактирования его параметров.")
-            with gr.Row():
-                with gr.Column(scale=1):
-                    config_upload = gr.File(label="Загрузить файл .asset для редактирования")
-                    config_file_name = gr.Label(label="Выбранный файл")
-                with gr.Column(scale=2):
-                    # For now, just a textbox. Could be replaced with dynamic fields.
-                    config_content_viewer = gr.Textbox(label="Содержимое файла", lines=30, interactive=True)
-                    config_save_button = gr.Button("Сохранить изменения (не реализовано)", interactive=False)
-    
     # --- Event Handlers ---
+    files_to_update_ui = [chain_files_upload, ruleset_upload, settings_upload]
+    ui_outputs_to_update = [chain_editor_df, max_history_input, increment_diff_input, energy_chance_input, req_weights_input, reduction_factor_input, increase_factor_input, energy_rewards_df, item_rewards_df]
+    
+    for file_input in files_to_update_ui:
+        file_input.upload(update_ui_from_files, files_to_update_ui, ui_outputs_to_update)
+
     sim_run_button.click(
         fn=run_simulation_interface,
-        inputs=[sim_ruleset_upload, sim_chains_upload, sim_iterations, sim_initial_energy],
+        inputs=[chain_editor_df, energy_rewards_df, item_rewards_df, max_history_input, increment_diff_input, energy_chance_input, req_weights_input, reduction_factor_input, increase_factor_input, sim_iterations, sim_initial_energy_input],
         outputs=[sim_results_df, sim_stats_report, sim_download_csv, sim_download_report]
     )
-    
-    cost_run_button.click(
-        fn=run_cost_calculation_interface,
-        inputs=[cost_chains_upload, cost_items_upload],
-        outputs=[cost_results_df]
-    )
-
-    def get_file_path_and_content(file_obj):
-        if not file_obj:
-            return "", ""
-        with open(file_obj.name, 'r', encoding='utf-8') as f:
-            content = f.read()
-        return file_obj.name, content
-
-    config_upload.upload(
-        fn=lambda file_obj: os.path.basename(file_obj.name) if file_obj else "",
-        inputs=config_upload,
-        outputs=config_file_name
-    )
-    
-    # FIX: The input 'file' is a temporary file object. We need to open and read it.
-    config_upload.upload(
-        fn=lambda file_obj: open(file_obj.name, 'r', encoding='utf-8').read() if file_obj else "",
-        inputs=config_upload,
-        outputs=config_content_viewer
-    )
-
 
 if __name__ == "__main__":
     demo.launch()