1

Source/WulaFallenEmpire/Stat/StatWorker_Energy.cs

@@ -0,0 +1,180 @@
+// StatWorker_Energy.cs - 处理能量相关的统计量
+using RimWorld;
+using Verse;
+using System.Collections.Generic;
+
+namespace WulaFallenEmpire
+{
+    public class StatWorker_Energy : StatWorker
+    {
+        public override bool ShouldShowFor(StatRequest req)
+        {
+            if (!base.ShouldShowFor(req))
+                return false;
+
+            // 处理 ThingDef 的情况（种族定义）
+            if (req.Def is ThingDef thingDef)
+            {
+                // 检查是否为 WulaSpecies 种族
+                return thingDef.defName == "WulaSpecies";
+            }
+
+            // 检查是否为 Pawn
+            if (req.Thing is Pawn pawn)
+            {
+                // 检查是否有能量需求
+                return HasEnergyNeed(pawn);
+            }
+
+            return false;
+        }
+
+        public override float GetValueUnfinalized(StatRequest req, bool applyPostProcess = true)
+        {
+            // 关键修复：调用基类方法让 RimWorld 的统计系统处理所有修正
+            float baseValue = base.GetValueUnfinalized(req, applyPostProcess);
+            
+            if (req.Thing is Pawn pawn)
+            {
+                return GetStatValueForPawn(stat.defName, pawn, baseValue);
+            }
+            else if (req.Def is ThingDef thingDef && thingDef.defName == "WulaSpecies")
+            {
+                // 对于 WulaSpecies 种族，返回经过修正的值
+                return GetDefaultValueForStat(stat.defName, baseValue);
+            }
+
+            return baseValue;
+        }
+
+        public override string GetExplanationUnfinalized(StatRequest req, ToStringNumberSense numberSense)
+        {
+            var explanation = base.GetExplanationUnfinalized(req, numberSense);
+            
+            // 添加自定义解释
+            if (req.Thing is Pawn pawn)
+            {
+                explanation += "\n\n" + GetEnergyExplanationForPawn(stat.defName, pawn);
+            }
+            else if (req.Def is ThingDef thingDef && thingDef.defName == "WulaSpecies")
+            {
+                explanation += "\n\n" + GetEnergyExplanationForRace(stat.defName);
+            }
+
+            return explanation;
+        }
+
+        private bool HasEnergyNeed(Pawn pawn)
+        {
+            // 使用反射或其他方式检查是否有能量需求，或者直接返回 true 对于 WulaSpecies
+            if (pawn?.def?.defName == "WulaSpecies")
+                return true;
+                
+            // 如果有具体的能量需求类，可以在这里检查
+            // return pawn?.needs?.TryGetNeed<Need_Energy>() != null;
+            return false;
+        }
+
+        private float GetStatValueForPawn(string statDefName, Pawn pawn, float baseValue)
+        {
+            // 对于 WulaSpecies 种族，返回基于其特性的值
+            if (pawn.def.defName == "WulaSpecies")
+            {
+                switch (statDefName)
+                {
+                    case "WulaEnergyMaxLevelOffset":
+                        return CalculateEnergyMaxLevelOffset(pawn, baseValue);
+                        
+                    case "WulaEnergyFallRateFactor":
+                        return CalculateEnergyFallRateFactor(pawn, baseValue);
+                        
+                    default:
+                        return baseValue;
+                }
+            }
+
+            return baseValue;
+        }
+
+        private float GetDefaultValueForStat(string statDefName, float baseValue)
+        {
+            // 关键修复：使用基础值而不是固定值
+            switch (statDefName)
+            {
+                case "WulaEnergyMaxLevelOffset":
+                    return baseValue; // 使用统计系统修正后的值
+                    
+                case "WulaEnergyFallRateFactor":
+                    return baseValue; // 使用统计系统修正后的值
+                    
+                default:
+                    return baseValue;
+            }
+        }
+
+        private float CalculateEnergyMaxLevelOffset(Pawn pawn, float baseValue)
+        {
+            // 计算能量上限偏移量，使用基础值作为起点
+            // 这里可以根据 pawn 的特性计算
+            return baseValue;
+        }
+
+        private float CalculateEnergyFallRateFactor(Pawn pawn, float baseValue)
+        {
+            // 计算能量下降速率因子，使用基础值作为起点
+            // 这里可以根据 pawn 的特性计算
+            return baseValue;
+        }
+
+        private string GetEnergyExplanationForPawn(string statDefName, Pawn pawn)
+        {
+            var explanation = "WULA_Energy_Properties".Translate();
+            
+            switch (statDefName)
+            {
+                case "WulaEnergyMaxLevelOffset":
+                    explanation += "\n" + "WULA_Energy_MaxLevelOffset_PawnExplanation".Translate();
+                    break;
+                    
+                case "WulaEnergyFallRateFactor":
+                    explanation += "\n" + "WULA_Energy_FallRateFactor_PawnExplanation".Translate();
+                    break;
+            }
+
+            return explanation;
+        }
+
+        private string GetEnergyExplanationForRace(string statDefName)
+        {
+            var explanation = "WULA_Energy_RaceProperties".Translate();
+            
+            switch (statDefName)
+            {
+                case "WulaEnergyMaxLevelOffset":
+                    explanation += "\n" + "WULA_Energy_MaxLevelOffset_RaceExplanation".Translate();
+                    break;
+                    
+                case "WulaEnergyFallRateFactor":
+                    explanation += "\n" + "WULA_Energy_FallRateFactor_RaceExplanation".Translate();
+                    break;
+            }
+
+            return explanation;
+        }
+
+        public override IEnumerable<Dialog_InfoCard.Hyperlink> GetInfoCardHyperlinks(StatRequest req)
+        {
+            foreach (var hyperlink in base.GetInfoCardHyperlinks(req))
+            {
+                yield return hyperlink;
+            }
+
+            // 添加能量系统的超链接
+            var energyNeedDef = DefDatabase<NeedDef>.GetNamedSilentFail("WULA_Energy");
+            if (energyNeedDef != null)
+            {
+                yield return new Dialog_InfoCard.Hyperlink(energyNeedDef);
+            }
+        }
+    }
+}

Source/WulaFallenEmpire/Stat/StatWorker_Maintenance.cs

@@ -23,6 +23,9 @@ namespace WulaFallenEmpire
 
         public override float GetValueUnfinalized(StatRequest req, bool applyPostProcess = true)
         {
+            // 关键修复：调用基类方法让 RimWorld 的统计系统处理所有修正
+            float baseValue = base.GetValueUnfinalized(req, applyPostProcess);
+            
             if (req.Thing is Pawn pawn)
             {
                 var maintenanceNeed = GetMaintenanceNeed(pawn);
@@ -30,11 +33,11 @@ namespace WulaFallenEmpire
                 
                 if (maintenanceNeed != null && extension != null)
                 {
-                    return GetStatValueForMaintenance(stat.defName, maintenanceNeed, extension);
+                    return GetStatValueForMaintenance(stat.defName, maintenanceNeed, extension, baseValue);
                 }
             }
 
-            return stat.defaultBaseValue;
+            return baseValue;
         }
 
         public override string GetExplanationUnfinalized(StatRequest req, ToStringNumberSense numberSense)
@@ -71,30 +74,31 @@ namespace WulaFallenEmpire
             return maintenanceNeed?.Extension;
         }
 
-        private float GetStatValueForMaintenance(string statDefName, Need_Maintenance need, MaintenanceNeedExtension extension)
+        private float GetStatValueForMaintenance(string statDefName, Need_Maintenance need, MaintenanceNeedExtension extension, float baseValue)
         {
+            // 关键修复：使用基础值而不是固定值
             switch (statDefName)
             {
                 case "WULA_MaintenanceDegradationFactor":
-                    return CalculateDegradationFactor(need, extension);
+                    return CalculateDegradationFactor(need, extension, baseValue);
                     
                 case "WULA_MaintenanceStatusThresholdFactor":
-                    return CalculateStatusThresholdFactor(need, extension);
+                    return CalculateStatusThresholdFactor(need, extension, baseValue);
                     
                 case "WULA_MaintenanceDamageToMaintenanceFactor":
-                    return CalculateDamageToMaintenanceFactor(need, extension);
+                    return CalculateDamageToMaintenanceFactor(need, extension, baseValue);
                     
                 case "WULA_MaintenanceMinorBreakdownThresholdFactor":
-                    return CalculateMinorBreakdownThresholdFactor(need, extension);
+                    return CalculateMinorBreakdownThresholdFactor(need, extension, baseValue);
                     
                 case "WULA_MaintenanceMajorBreakdownThresholdFactor":
-                    return CalculateMajorBreakdownThresholdFactor(need, extension);
+                    return CalculateMajorBreakdownThresholdFactor(need, extension, baseValue);
                     
                 case "WULA_MaintenanceCriticalFailureThresholdFactor":
-                    return CalculateCriticalFailureThresholdFactor(need, extension);
+                    return CalculateCriticalFailureThresholdFactor(need, extension, baseValue);
                     
                 default:
-                    return stat.defaultBaseValue;
+                    return baseValue;
             }
         }
 
@@ -132,44 +136,44 @@ namespace WulaFallenEmpire
             return explanation;
         }
 
-        // 计算各种统计值的方法
-        private float CalculateDegradationFactor(Need_Maintenance need, MaintenanceNeedExtension extension)
+        // 计算各种统计值的方法 - 现在接受基础值参数
+        private float CalculateDegradationFactor(Need_Maintenance need, MaintenanceNeedExtension extension, float baseValue)
         {
-            // 基础退化速率乘数
-            return 1.0f; // 默认值，可以根据需要调整
+            // 基础退化速率乘数，使用统计系统修正后的值
+            return baseValue;
         }
 
-        private float CalculateStatusThresholdFactor(Need_Maintenance need, MaintenanceNeedExtension extension)
+        private float CalculateStatusThresholdFactor(Need_Maintenance need, MaintenanceNeedExtension extension, float baseValue)
         {
-            // 状态阈值乘数
-            return 1.0f; // 默认值，可以根据需要调整
+            // 状态阈值乘数，使用统计系统修正后的值
+            return baseValue;
         }
 
-        private float CalculateDamageToMaintenanceFactor(Need_Maintenance need, MaintenanceNeedExtension extension)
+        private float CalculateDamageToMaintenanceFactor(Need_Maintenance need, MaintenanceNeedExtension extension, float baseValue)
         {
-            // 伤害到维护度的转换因子
-            return extension?.damageToMaintenanceFactor ?? 0.01f;
+            // 伤害到维护度的转换因子，使用统计系统修正后的值
+            return baseValue;
         }
 
-        private float CalculateMinorBreakdownThresholdFactor(Need_Maintenance need, MaintenanceNeedExtension extension)
+        private float CalculateMinorBreakdownThresholdFactor(Need_Maintenance need, MaintenanceNeedExtension extension, float baseValue)
         {
-            // 轻微故障阈值乘数
-            return 1.0f; // 默认值
+            // 轻微故障阈值乘数，使用统计系统修正后的值
+            return baseValue;
         }
 
-        private float CalculateMajorBreakdownThresholdFactor(Need_Maintenance need, MaintenanceNeedExtension extension)
+        private float CalculateMajorBreakdownThresholdFactor(Need_Maintenance need, MaintenanceNeedExtension extension, float baseValue)
         {
-            // 严重故障阈值乘数
-            return 1.0f; // 默认值
+            // 严重故障阈值乘数，使用统计系统修正后的值
+            return baseValue;
         }
 
-        private float CalculateCriticalFailureThresholdFactor(Need_Maintenance need, MaintenanceNeedExtension extension)
+        private float CalculateCriticalFailureThresholdFactor(Need_Maintenance need, MaintenanceNeedExtension extension, float baseValue)
         {
-            // 完全故障阈值乘数
-            return 1.0f; // 默认值
+            // 完全故障阈值乘数，使用统计系统修正后的值
+            return baseValue;
         }
 
-        // 解释文本生成方法
+        // 解释文本生成方法（保持不变）
         private string GetDegradationFactorExplanation(Need_Maintenance need, MaintenanceNeedExtension extension)
         {
             return "WULA_Maintenance_DegradationFactor_Explanation".Translate(

Source/WulaFallenEmpire/Stat/StatWorker_NanoRepair.cs

@@ -13,6 +13,18 @@ namespace WulaFallenEmpire
             if (!base.ShouldShowFor(req))
                 return false;
 
+            // 处理 ThingDef 的情况（种族定义）
+            if (req.Def is ThingDef thingDef)
+            {
+                // 检查是否为 WulaSpecies 种族
+                if (thingDef.defName == "WulaSpecies")
+                {
+                    // 对于 WulaSpecies 种族，只在有纳米修复 hediff 时显示
+                    return HasNanoRepairForRace(thingDef);
+                }
+                return false;
+            }
+
             // 检查是否为 Pawn
             if (req.Thing is Pawn pawn)
             {
@@ -24,24 +36,24 @@ namespace WulaFallenEmpire
 
         public override float GetValueUnfinalized(StatRequest req, bool applyPostProcess = true)
         {
+            // 关键修复：调用基类方法让 RimWorld 的统计系统处理所有修正
+            float baseValue = base.GetValueUnfinalized(req, applyPostProcess);
+            
             if (req.Thing is Pawn pawn)
             {
                 var nanoComp = GetNanoRepairComp(pawn);
                 if (nanoComp != null)
                 {
-                    // 根据请求的 StatDef 返回相应的值
-                    if (stat.defName == "WULA_NanoRepairCostPerHP")
-                    {
-                        return nanoComp.Props.repairCostPerHP;
-                    }
-                    else if (stat.defName == "WULA_NanoRepairCooldownAfterDamage")
-                    {
-                        return nanoComp.Props.repairCooldownAfterDamage;
-                    }
+                    return GetStatValueForNanoRepair(stat.defName, nanoComp, baseValue);
                 }
             }
+            else if (req.Def is ThingDef thingDef && thingDef.defName == "WulaSpecies")
+            {
+                // 对于 WulaSpecies 种族，返回经过修正的值
+                return GetDefaultValueForStat(stat.defName, baseValue);
+            }
 
-            return stat.defaultBaseValue;
+            return baseValue;
         }
 
         public override string GetExplanationUnfinalized(StatRequest req, ToStringNumberSense numberSense)
@@ -56,10 +68,21 @@ namespace WulaFallenEmpire
                     explanation += "\n\n" + GetNanoRepairExplanation(nanoComp);
                 }
             }
+            else if (req.Def is ThingDef thingDef && thingDef.defName == "WulaSpecies")
+            {
+                explanation += "\n\n" + GetNanoRepairExplanationForRace();
+            }
 
             return explanation;
         }
 
+        private bool HasNanoRepairForRace(ThingDef raceDef)
+        {
+            // 检查该种族是否有纳米修复 hediff
+            // 这里可以添加更复杂的逻辑来检查种族是否有纳米修复能力
+            return raceDef.defName == "WulaSpecies";
+        }
+
         private bool HasNanoRepairHediff(Pawn pawn)
         {
             if (pawn?.health?.hediffSet?.hediffs == null)
@@ -90,6 +113,40 @@ namespace WulaFallenEmpire
             return null;
         }
 
+        private float GetStatValueForNanoRepair(string statDefName, HediffComp_NanoRepair nanoComp, float baseValue)
+        {
+            // 关键修复：使用基础值而不是固定值
+            var props = nanoComp.Props;
+            
+            switch (statDefName)
+            {
+                case "WULA_NanoRepairCostPerHP":
+                    return baseValue; // 使用统计系统修正后的值
+                    
+                case "WULA_NanoRepairCooldownAfterDamage":
+                    return baseValue; // 使用统计系统修正后的值
+                    
+                default:
+                    return baseValue;
+            }
+        }
+
+        private float GetDefaultValueForStat(string statDefName, float baseValue)
+        {
+            // 关键修复：使用基础值而不是固定值
+            switch (statDefName)
+            {
+                case "WULA_NanoRepairCostPerHP":
+                    return baseValue; // 使用统计系统修正后的值
+                    
+                case "WULA_NanoRepairCooldownAfterDamage":
+                    return baseValue; // 使用统计系统修正后的值
+                    
+                default:
+                    return baseValue;
+            }
+        }
+
         private string GetNanoRepairExplanation(HediffComp_NanoRepair nanoComp)
         {
             var props = nanoComp.Props;
@@ -113,6 +170,24 @@ namespace WulaFallenEmpire
             return explanation;
         }
 
+        private string GetNanoRepairExplanationForRace()
+        {
+            var explanation = "WULA_NanoRepair_RaceProperties".Translate();
+            
+            if (stat.defName == "WULA_NanoRepairCostPerHP")
+            {
+                explanation += "WULA_NanoRepair_CostPerHP_RaceLine".Translate(stat.defaultBaseValue.ToStringPercent());
+            }
+            else if (stat.defName == "WULA_NanoRepairCooldownAfterDamage")
+            {
+                explanation += "WULA_NanoRepair_CooldownAfterDamage_RaceLine".Translate(
+                    stat.defaultBaseValue, 
+                    (stat.defaultBaseValue / 60f).ToString("F1"));
+            }
+
+            return explanation;
+        }
+
         public override IEnumerable<Dialog_InfoCard.Hyperlink> GetInfoCardHyperlinks(StatRequest req)
         {
             foreach (var hyperlink in base.GetInfoCardHyperlinks(req))