武器升级伤害配置

assets/resources/data/enemies.backup.json.meta

@@ -1,11 +0,0 @@
-{
-  "ver": "2.0.1",
-  "importer": "json",
-  "imported": true,
-  "uuid": "64304fa1-4340-409c-965f-4009c2b6be26",
-  "files": [
-    ".json"
-  ],
-  "subMetas": {},
-  "userData": {}
-}

assets/resources/data/enemies.json.backup_20250812_103852.meta

@@ -0,0 +1,12 @@
+{
+  "ver": "1.0.0",
+  "importer": "*",
+  "imported": true,
+  "uuid": "e8f3f59f-da4c-454c-91b8-053ee2cd475c",
+  "files": [
+    ".backup_20250812_103852",
+    ".json"
+  ],
+  "subMetas": {},
+  "userData": {}
+}

assets/resources/data/excel/__pycache__/config_manager.cpython-313.pyc.meta

@@ -0,0 +1,12 @@
+{
+  "ver": "1.0.0",
+  "importer": "*",
+  "imported": true,
+  "uuid": "0452c79a-83ea-4f82-9acd-95471c209a0d",
+  "files": [
+    ".json",
+    ".pyc"
+  ],
+  "subMetas": {},
+  "userData": {}
+}

assets/resources/data/excel/config_manager.py

@@ -1658,17 +1658,36 @@ class ConfigManagerGUI:
                     print(f"处理行 {index}: weapon_id = {weapon_id}")
                     if weapon_id and str(weapon_id).strip():  # 确保武器ID不为空
                         upgrade_levels = {}
-                        # 从第5列开始是等级1-10的费用（E列到N列）
+                        # 从第5列开始是等级1-10的费用（E列到N列），从第15列开始是等级1-10的伤害（O列到X列）
                         for level in range(1, 11):
                             cost_col_index = 4 + (level - 1)  # 等级1费用在第5列(索引4)，等级2在第6列(索引5)，以此类推
+                            damage_col_index = 14 + (level - 1)  # 等级1伤害在第15列(索引14)，等级2在第16列(索引15)，以此类推
+                            
+                            level_config = {}
+                            
+                            # 处理费用
                             if cost_col_index < len(row):
                                 cost = row.iloc[cost_col_index]
                                 if cost and str(cost).strip() and str(cost) != 'nan':
                                     try:
-                                        upgrade_levels[str(level)] = {'cost': int(float(cost))}
+                                        level_config['cost'] = int(float(cost))
                                         print(f"  等级 {level} 费用: {cost}")
                                     except (ValueError, TypeError):
                                         print(f"  等级 {level} 费用解析失败: {cost}")
+                            
+                            # 处理伤害
+                            if damage_col_index < len(row):
+                                damage = row.iloc[damage_col_index]
+                                if damage and str(damage).strip() and str(damage) != 'nan':
+                                    try:
+                                        level_config['damage'] = int(float(damage))
+                                        print(f"  等级 {level} 伤害: {damage}")
+                                    except (ValueError, TypeError):
+                                        print(f"  等级 {level} 伤害解析失败: {damage}")
+                            
+                            # 只有当有费用或伤害数据时才添加等级配置
+                            if level_config:
+                                upgrade_levels[str(level)] = level_config
                         
                         if upgrade_levels:  # 只有当有升级费用数据时才添加
                             upgrade_cost_data.append({

assets/resources/data/excel/generate_enemies.py.meta

@@ -0,0 +1,12 @@
+{
+  "ver": "1.0.0",
+  "importer": "*",
+  "imported": true,
+  "uuid": "136c2cc7-aa05-43cf-a438-ec0cc76ee621",
+  "files": [
+    ".json",
+    ".py"
+  ],
+  "subMetas": {},
+  "userData": {}
+}

assets/resources/data/weapons.json

@@ -65,34 +65,44 @@
         "maxLevel": 10,
         "levels": {
           "1": {
-            "cost": 30
+            "cost": 30,
+            "damage": 10
           },
           "2": {
-            "cost": 100
+            "cost": 100,
+            "damage": 23
           },
           "3": {
-            "cost": 200
+            "cost": 200,
+            "damage": 26
           },
           "4": {
-            "cost": 400
+            "cost": 400,
+            "damage": 29
           },
           "5": {
-            "cost": 800
+            "cost": 800,
+            "damage": 32
           },
           "6": {
-            "cost": 1600
+            "cost": 1600,
+            "damage": 35
           },
           "7": {
-            "cost": 3200
+            "cost": 3200,
+            "damage": 38
           },
           "8": {
-            "cost": 6400
+            "cost": 6400,
+            "damage": 41
           },
           "9": {
-            "cost": 12800
+            "cost": 12800,
+            "damage": 44
           },
           "10": {
-            "cost": 25600
+            "cost": 25600,
+            "damage": 47
           }
         }
       },
@@ -174,34 +184,44 @@
         "maxLevel": 10,
         "levels": {
           "1": {
-            "cost": 60
+            "cost": 60,
+            "damage": 15
           },
           "2": {
-            "cost": 120
+            "cost": 120,
+            "damage": 18
           },
           "3": {
-            "cost": 240
+            "cost": 240,
+            "damage": 21
           },
           "4": {
-            "cost": 480
+            "cost": 480,
+            "damage": 24
           },
           "5": {
-            "cost": 960
+            "cost": 960,
+            "damage": 27
           },
           "6": {
-            "cost": 1920
+            "cost": 1920,
+            "damage": 30
           },
           "7": {
-            "cost": 3840
+            "cost": 3840,
+            "damage": 33
           },
           "8": {
-            "cost": 7680
+            "cost": 7680,
+            "damage": 36
           },
           "9": {
-            "cost": 15360
+            "cost": 15360,
+            "damage": 39
           },
           "10": {
-            "cost": 30720
+            "cost": 30720,
+            "damage": 42
           }
         }
       },
@@ -291,34 +311,44 @@
         "maxLevel": 10,
         "levels": {
           "1": {
-            "cost": 80
+            "cost": 80,
+            "damage": 25
           },
           "2": {
-            "cost": 160
+            "cost": 160,
+            "damage": 30
           },
           "3": {
-            "cost": 320
+            "cost": 320,
+            "damage": 35
           },
           "4": {
-            "cost": 640
+            "cost": 640,
+            "damage": 40
           },
           "5": {
-            "cost": 1280
+            "cost": 1280,
+            "damage": 45
           },
           "6": {
-            "cost": 2560
+            "cost": 2560,
+            "damage": 50
           },
           "7": {
-            "cost": 5120
+            "cost": 5120,
+            "damage": 55
           },
           "8": {
-            "cost": 10240
+            "cost": 10240,
+            "damage": 60
           },
           "9": {
-            "cost": 20480
+            "cost": 20480,
+            "damage": 65
           },
           "10": {
-            "cost": 40960
+            "cost": 40960,
+            "damage": 70
           }
         }
       },
@@ -400,34 +430,44 @@
         "maxLevel": 10,
         "levels": {
           "1": {
-            "cost": 150
+            "cost": 150,
+            "damage": 35
           },
           "2": {
-            "cost": 300
+            "cost": 300,
+            "damage": 42
           },
           "3": {
-            "cost": 600
+            "cost": 600,
+            "damage": 49
           },
           "4": {
-            "cost": 1200
+            "cost": 1200,
+            "damage": 56
           },
           "5": {
-            "cost": 2400
+            "cost": 2400,
+            "damage": 63
           },
           "6": {
-            "cost": 4800
+            "cost": 4800,
+            "damage": 70
           },
           "7": {
-            "cost": 9600
+            "cost": 9600,
+            "damage": 77
           },
           "8": {
-            "cost": 19200
+            "cost": 19200,
+            "damage": 84
           },
           "9": {
-            "cost": 38400
+            "cost": 38400,
+            "damage": 91
           },
           "10": {
-            "cost": 76800
+            "cost": 76800,
+            "damage": 98
           }
         }
       },
@@ -508,34 +548,44 @@
         "maxLevel": 10,
         "levels": {
           "1": {
-            "cost": 100
+            "cost": 100,
+            "damage": 30
           },
           "2": {
-            "cost": 200
+            "cost": 200,
+            "damage": 36
           },
           "3": {
-            "cost": 400
+            "cost": 400,
+            "damage": 42
           },
           "4": {
-            "cost": 800
+            "cost": 800,
+            "damage": 48
           },
           "5": {
-            "cost": 1600
+            "cost": 1600,
+            "damage": 54
           },
           "6": {
-            "cost": 3200
+            "cost": 3200,
+            "damage": 60
           },
           "7": {
-            "cost": 6400
+            "cost": 6400,
+            "damage": 66
           },
           "8": {
-            "cost": 12800
+            "cost": 12800,
+            "damage": 72
           },
           "9": {
-            "cost": 25600
+            "cost": 25600,
+            "damage": 78
           },
           "10": {
-            "cost": 51200
+            "cost": 51200,
+            "damage": 84
           }
         }
       },
@@ -615,34 +665,44 @@
         "maxLevel": 10,
         "levels": {
           "1": {
-            "cost": 140
+            "cost": 140,
+            "damage": 40
           },
           "2": {
-            "cost": 280
+            "cost": 280,
+            "damage": 48
           },
           "3": {
-            "cost": 560
+            "cost": 560,
+            "damage": 56
           },
           "4": {
-            "cost": 1120
+            "cost": 1120,
+            "damage": 64
           },
           "5": {
-            "cost": 2240
+            "cost": 2240,
+            "damage": 72
           },
           "6": {
-            "cost": 4480
+            "cost": 4480,
+            "damage": 80
           },
           "7": {
-            "cost": 8960
+            "cost": 8960,
+            "damage": 88
           },
           "8": {
-            "cost": 17920
+            "cost": 17920,
+            "damage": 96
           },
           "9": {
-            "cost": 35840
+            "cost": 35840,
+            "damage": 104
           },
           "10": {
-            "cost": 71680
+            "cost": 71680,
+            "damage": 112
           }
         }
       },
@@ -723,34 +783,44 @@
         "maxLevel": 10,
         "levels": {
           "1": {
-            "cost": 70
+            "cost": 70,
+            "damage": 12
           },
           "2": {
-            "cost": 140
+            "cost": 140,
+            "damage": 15
           },
           "3": {
-            "cost": 280
+            "cost": 280,
+            "damage": 18
           },
           "4": {
-            "cost": 560
+            "cost": 560,
+            "damage": 21
           },
           "5": {
-            "cost": 1120
+            "cost": 1120,
+            "damage": 24
           },
           "6": {
-            "cost": 2240
+            "cost": 2240,
+            "damage": 27
           },
           "7": {
-            "cost": 4480
+            "cost": 4480,
+            "damage": 30
           },
           "8": {
-            "cost": 8960
+            "cost": 8960,
+            "damage": 33
           },
           "9": {
-            "cost": 17920
+            "cost": 17920,
+            "damage": 36
           },
           "10": {
-            "cost": 35840
+            "cost": 35840,
+            "damage": 39
           }
         }
       },
@@ -832,34 +902,44 @@
         "maxLevel": 10,
         "levels": {
           "1": {
-            "cost": 200
+            "cost": 200,
+            "damage": 70
           },
           "2": {
-            "cost": 400
+            "cost": 400,
+            "damage": 85
           },
           "3": {
-            "cost": 800
+            "cost": 800,
+            "damage": 100
           },
           "4": {
-            "cost": 1600
+            "cost": 1600,
+            "damage": 115
           },
           "5": {
-            "cost": 3200
+            "cost": 3200,
+            "damage": 130
           },
           "6": {
-            "cost": 6400
+            "cost": 6400,
+            "damage": 145
           },
           "7": {
-            "cost": 12800
+            "cost": 12800,
+            "damage": 160
           },
           "8": {
-            "cost": 25600
+            "cost": 25600,
+            "damage": 175
           },
           "9": {
-            "cost": 51200
+            "cost": 51200,
+            "damage": 190
           },
           "10": {
-            "cost": 102400
+            "cost": 102400,
+            "damage": 205
           }
         }
       },

assets/scripts/CombatSystem/EnemyInstance.ts

@@ -113,7 +113,8 @@ export class EnemyInstance extends Component {
         }
         
         // 从数据库中查找敌人配置
-        const enemies = EnemyInstance.enemyDatabase.enemies;
+        // 修复：enemies.json是直接的数组结构，不需要.enemies包装
+        const enemies = EnemyInstance.enemyDatabase;
         this.enemyConfig = enemies.find((enemy: any) => enemy.id === enemyId);
         
         if (!this.enemyConfig) {

assets/scripts/Core/ConfigManager.ts

@@ -424,14 +424,15 @@ export class ConfigManager extends BaseSingleton {
     }
     // 随机获取敌人配置
     public getRandomEnemy(rarity?: string): EnemyConfig | null {
-        if (!this.enemiesConfig || !this.enemiesConfig.enemies || this.enemiesConfig.enemies.length === 0) {
+        // 修复：enemies.json是直接的数组结构，不需要.enemies包装
+        if (!this.enemiesConfig || !Array.isArray(this.enemiesConfig) || this.enemiesConfig.length === 0) {
             console.warn('敌人配置未加载或为空');
             return null;
         }
 
         if (rarity) {
             // 按稀有度筛选
-            const filteredEnemies = this.enemiesConfig.enemies.filter(enemy => enemy.rarity === rarity);
+            const filteredEnemies = this.enemiesConfig.filter(enemy => enemy.rarity === rarity);
             if (filteredEnemies.length === 0) {
                 console.warn(`没有找到稀有度为 ${rarity} 的敌人`);
                 return null;
@@ -441,8 +442,8 @@ export class ConfigManager extends BaseSingleton {
         }
 
         // 直接从敌人列表中随机选择
-        const randomIndex = Math.floor(Math.random() * this.enemiesConfig.enemies.length);
-        return this.enemiesConfig.enemies[randomIndex];
+        const randomIndex = Math.floor(Math.random() * this.enemiesConfig.length);
+        return this.enemiesConfig[randomIndex];
     }
 
     // 根据ID获取武器配置
@@ -453,8 +454,9 @@ export class ConfigManager extends BaseSingleton {
 
     // 根据ID获取敌人配置
     public getEnemyById(id: string): EnemyConfig | null {
-        if (!this.enemiesConfig) return null;
-        return this.enemiesConfig.enemies.find(enemy => enemy.id === id) || null;
+        // 修复：enemies.json是直接的数组结构，不需要.enemies包装
+        if (!this.enemiesConfig || !Array.isArray(this.enemiesConfig)) return null;
+        return this.enemiesConfig.find(enemy => enemy.id === id) || null;
     }
 
     /**
@@ -472,7 +474,8 @@ export class ConfigManager extends BaseSingleton {
 
     // 获取所有敌人配置
     public getAllEnemies(): EnemyConfig[] {
-        return this.enemiesConfig?.enemies || [];
+        // 修复：enemies.json是直接的数组结构，不需要.enemies包装
+        return Array.isArray(this.enemiesConfig) ? this.enemiesConfig : [];
     }
 
     // 根据稀有度获取武器列表
@@ -483,8 +486,9 @@ export class ConfigManager extends BaseSingleton {
 
     // 根据稀有度获取敌人列表
     public getEnemiesByRarity(rarity: string): EnemyConfig[] {
-        if (!this.enemiesConfig) return [];
-        return this.enemiesConfig.enemies.filter(enemy => enemy.rarity === rarity);
+        // 修复：enemies.json是直接的数组结构，不需要.enemies包装
+        if (!this.enemiesConfig || !Array.isArray(this.enemiesConfig)) return [];
+        return this.enemiesConfig.filter(enemy => enemy.rarity === rarity);
     }
 
     // 获取方块尺寸列表（已更新为形状ID）
@@ -519,34 +523,18 @@ export class ConfigManager extends BaseSingleton {
         return this.weaponsConfig.blockSizes;
     }
 
-    // 获取波次进展配置
+    // 获取波次进展配置（已废弃，波次配置现在通过关卡系统管理）
     public getWaveProgression(): any {
-        return this.enemiesConfig?.waveProgression || {};
+        console.warn('[ConfigManager] getWaveProgression已废弃，波次配置现在通过关卡系统管理');
+        return {};
     }
 
-    // 根据波次获取合适的敌人
+    // 根据波次获取合适的敌人（简化版本，直接返回随机敌人）
     public getEnemyForWave(waveNumber: number): EnemyConfig | null {
-        if (!this.enemiesConfig) return null;
-        
-        const progression = this.enemiesConfig.waveProgression;
-        let enemyPool: string[] = [];
-        
-        if (waveNumber <= 5) {
-            enemyPool = progression.earlyWaves || [];
-        } else if (waveNumber <= 15) {
-            enemyPool = [...(progression.earlyWaves || []), ...(progression.midWaves || [])];
-        } else if (waveNumber <= 25) {
-            enemyPool = [...(progression.midWaves || []), ...(progression.lateWaves || [])];
-        } else {
-            enemyPool = [...(progression.lateWaves || []), ...(progression.bossWaves || [])];
-        }
-        
-        if (enemyPool.length === 0) {
-            return this.getRandomEnemy();
-        }
-        
-        const randomId = enemyPool[Math.floor(Math.random() * enemyPool.length)];
-        return this.getEnemyById(randomId);
+        // 修复：波次配置现在通过关卡系统管理，这里简化为返回随机敌人
+        // 具体的波次敌人配置由EnemyController通过关卡配置处理
+        console.log(`[ConfigManager] 为波次 ${waveNumber} 获取随机敌人`);
+        return this.getRandomEnemy();
     }
 
     // 检查配置是否已加载

assets/scripts/FourUI/UpgradeSystem/UpgradeController.ts

@@ -34,6 +34,7 @@ interface WeaponConfig {
         levels: {
             [level: string]: {
                 cost: number;
+                damage?: number;
             };
         };
     };
@@ -625,7 +626,19 @@ export class UpgradeController extends Component {
     private calculateWeaponDamage(baseDamage: number, level: number, weaponId?: string): number {
         if (level === 0) return 0; // 未解锁武器伤害为0
         
-        // 使用基于武器稀有度的伤害增长公式
+        // 优先使用手动配置的伤害值
+        if (weaponId && this.weaponsConfig && this.weaponsConfig.weapons) {
+            const weaponConfig = this.weaponsConfig.weapons.find(w => w.id === weaponId);
+            if (weaponConfig && weaponConfig.upgradeConfig && weaponConfig.upgradeConfig.levels) {
+                const levelConfig = weaponConfig.upgradeConfig.levels[level.toString()];
+                if (levelConfig && levelConfig.damage !== undefined) {
+                    console.log(`[UpgradeController] 使用手动配置伤害 - ${weaponId}: 等级=${level}, 伤害=${levelConfig.damage}`);
+                    return levelConfig.damage;
+                }
+            }
+        }
+        
+        // 如果没有手动配置，使用基于武器稀有度的伤害增长公式作为后备
         if (weaponId && this.weaponsConfig && this.weaponsConfig.weapons) {
             const weaponConfig = this.weaponsConfig.weapons.find(w => w.id === weaponId);
             if (weaponConfig && weaponConfig.stats && weaponConfig.stats.damage) {
@@ -655,13 +668,14 @@ export class UpgradeController extends Component {
                 // 计算总伤害：基础伤害 + (等级-1) * 每级伤害增长
                 const totalDamage = baseDamage + (level - 1) * damagePerLevel;
                 
-                console.log(`[UpgradeController] 武器伤害计算 - ${weaponId}: 基础=${baseDamage}, 等级=${level}, 每级增长=${damagePerLevel}, 总伤害=${totalDamage}`);
+                console.log(`[UpgradeController] 使用自动计算伤害 - ${weaponId}: 基础=${baseDamage}, 等级=${level}, 每级增长=${damagePerLevel}, 总伤害=${totalDamage}`);
                 
                 return totalDamage;
             }
         }
         
         // 如果配置不存在，使用默认公式作为后备
+        console.log(`[UpgradeController] 使用默认伤害计算 - ${weaponId}: 基础=${baseDamage}, 等级=${level}`);
         return baseDamage + (level - 1);
     }
     

test_weapon_damage.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+武器伤害配置测试脚本
+用于验证手动配置的武器伤害值是否正确加载
+"""
+
+import json
+import os
+from pathlib import Path
+
+def test_weapon_damage_config():
+    """测试武器伤害配置"""
+    # 获取weapons.json文件路径
+    weapons_json_path = Path("assets/resources/data/weapons.json")
+    
+    if not weapons_json_path.exists():
+        print(f"错误: 找不到武器配置文件 {weapons_json_path}")
+        return False
+    
+    try:
+        # 读取武器配置
+        with open(weapons_json_path, 'r', encoding='utf-8') as f:
+            weapons_config = json.load(f)
+        
+        print("=== 武器伤害配置测试 ===")
+        print(f"总共加载了 {len(weapons_config['weapons'])} 个武器")
+        print()
+        
+        # 检查每个武器的升级配置
+        for weapon in weapons_config['weapons']:
+            weapon_id = weapon['id']
+            weapon_name = weapon['name']
+            base_damage = weapon['stats']['damage']
+            
+            print(f"武器: {weapon_name} ({weapon_id})")
+            print(f"  基础伤害: {base_damage}")
+            
+            if 'upgradeConfig' in weapon and 'levels' in weapon['upgradeConfig']:
+                levels = weapon['upgradeConfig']['levels']
+                print(f"  升级配置: {len(levels)} 个等级")
+                
+                # 检查每个等级的配置
+                for level_str, level_config in levels.items():
+                    level = int(level_str)
+                    cost = level_config.get('cost', 'N/A')
+                    damage = level_config.get('damage', 'N/A')
+                    
+                    if damage != 'N/A':
+                        print(f"    等级 {level}: 费用={cost}, 伤害={damage}")
+                    else:
+                        print(f"    等级 {level}: 费用={cost}, 伤害=未配置")
+            else:
+                print("  ❌ 没有升级配置")
+            
+            print()
+        
+        # 统计配置完整性
+        weapons_with_damage = 0
+        total_weapons = len(weapons_config['weapons'])
+        
+        for weapon in weapons_config['weapons']:
+            if 'upgradeConfig' in weapon and 'levels' in weapon['upgradeConfig']:
+                levels = weapon['upgradeConfig']['levels']
+                has_damage_config = any('damage' in level_config for level_config in levels.values())
+                if has_damage_config:
+                    weapons_with_damage += 1
+        
+        print("=== 配置统计 ===")
+        print(f"总武器数量: {total_weapons}")
+        print(f"已配置手动伤害的武器: {weapons_with_damage}")
+        print(f"配置完成度: {weapons_with_damage/total_weapons*100:.1f}%")
+        
+        if weapons_with_damage == total_weapons:
+            print("✅ 所有武器都已配置手动伤害值")
+            return True
+        else:
+            print(f"⚠️  还有 {total_weapons - weapons_with_damage} 个武器未配置手动伤害值")
+            return False
+            
+    except Exception as e:
+        print(f"错误: 读取武器配置失败 - {e}")
+        return False
+
+def simulate_damage_calculation():
+    """模拟伤害计算逻辑"""
+    weapons_json_path = Path("assets/resources/data/weapons.json")
+    
+    if not weapons_json_path.exists():
+        print("错误: 找不到武器配置文件")
+        return
+    
+    try:
+        with open(weapons_json_path, 'r', encoding='utf-8') as f:
+            weapons_config = json.load(f)
+        
+        print("\n=== 伤害计算模拟 ===")
+        
+        # 模拟calculateWeaponDamage函数的逻辑
+        for weapon in weapons_config['weapons'][:3]:  # 只测试前3个武器
+            weapon_id = weapon['id']
+            weapon_name = weapon['name']
+            base_damage = weapon['stats']['damage']
+            
+            print(f"\n武器: {weapon_name} ({weapon_id})")
+            print(f"基础伤害: {base_damage}")
+            
+            if 'upgradeConfig' in weapon and 'levels' in weapon['upgradeConfig']:
+                levels = weapon['upgradeConfig']['levels']
+                
+                for level in range(1, 6):  # 测试1-5级
+                    level_str = str(level)
+                    if level_str in levels and 'damage' in levels[level_str]:
+                        # 使用手动配置的伤害值
+                        damage = levels[level_str]['damage']
+                        print(f"  等级 {level}: {damage} (手动配置)")
+                    else:
+                        # 使用自动计算的伤害值（作为对比）
+                        rarity = weapon.get('rarity', 'common')
+                        damage_per_level_map = {
+                            'common': int(base_damage * 0.15),
+                            'uncommon': int(base_damage * 0.18),
+                            'rare': int(base_damage * 0.20),
+                            'epic': int(base_damage * 0.25)
+                        }
+                        damage_per_level = max(1, damage_per_level_map.get(rarity, int(base_damage * 0.15)))
+                        calculated_damage = base_damage + (level - 1) * damage_per_level
+                        print(f"  等级 {level}: {calculated_damage} (自动计算)")
+            
+    except Exception as e:
+        print(f"错误: 模拟计算失败 - {e}")
+
+if __name__ == "__main__":
+    print("武器伤害配置测试工具")
+    print("=" * 50)
+    
+    # 切换到项目根目录
+    os.chdir(Path(__file__).parent)
+    
+    # 运行测试
+    success = test_weapon_damage_config()
+    
+    # 运行模拟计算
+    simulate_damage_calculation()
+    
+    print("\n=== 测试完成 ===")
+    if success:
+        print("✅ 武器伤害配置测试通过")
+    else:
+        print("❌ 武器伤害配置测试失败")