1

Source/WulaFallenEmpire/GlobalWorkTable/Building_GlobalWorkTable.cs

@@ -76,19 +76,30 @@ namespace WulaFallenEmpire
         public GlobalWorkTableAirdropExtension AirdropExtension => 
             def.GetModExtension<GlobalWorkTableAirdropExtension>();
 
-        // 修改：添加空投命令到技能栏，添加工厂设施检查
+        // 修改：在 GetGizmos 方法中添加白银转移按钮
         public override IEnumerable<Gizmo> GetGizmos()
         {
             foreach (Gizmo g in base.GetGizmos())
             {
                 yield return g;
             }
-
-            // 只有在有输出物品且有工厂设施的飞行器时才显示空投按钮
+            // 白银转移按钮 - 检查输入端是否有白银
             var globalStorage = Find.World.GetComponent<GlobalStorageWorldComponent>();
+            int silverAmount = globalStorage?.GetInputStorageCount(ThingDefOf.Silver) ?? 0;
+            bool hasSilver = silverAmount > 0;
+            if (hasSilver)
+            {
+                yield return new Command_Action
+                {
+                    action = TransferSilverToOutput,
+                    defaultLabel = "WULA_TransferSilver".Translate(),
+                    defaultDesc = "WULA_TransferSilverDesc".Translate(silverAmount),
+                    icon = ContentFinder<Texture2D>.Get("Wula/UI/Commands/WULA_SilverTransfer"),
+                };
+            }
+            // 原有的空投按钮逻辑保持不变
             bool hasOutputItems = globalStorage != null && globalStorage.outputStorage.Any(kvp => kvp.Value > 0);
             bool hasFactoryFlyOver = HasFactoryFacilityFlyOver();
-
             if (hasOutputItems && hasFactoryFlyOver)
             {
                 yield return new Command_Action
@@ -111,6 +122,64 @@ namespace WulaFallenEmpire
             }
         }
 
+        // 新增：将输入端白银转移到输出端的方法
+        private void TransferSilverToOutput()
+        {
+            var globalStorage = Find.World.GetComponent<GlobalStorageWorldComponent>();
+            if (globalStorage == null)
+            {
+                Messages.Message("WULA_NoGlobalStorage".Translate(), MessageTypeDefOf.RejectInput);
+                return;
+            }
+            int silverAmount = globalStorage.GetInputStorageCount(ThingDefOf.Silver);
+
+            if (silverAmount <= 0)
+            {
+                Messages.Message("WULA_NoSilverToTransfer".Translate(), MessageTypeDefOf.RejectInput);
+                return;
+            }
+            // 确认对话框
+            Find.WindowStack.Add(new Dialog_MessageBox(
+                "WULA_ConfirmTransferSilver".Translate(silverAmount),
+                "Confirm".Translate(),
+                () => ExecuteSilverTransfer(globalStorage, silverAmount),
+                "Cancel".Translate(),
+                null,
+                "WULA_TransferSilver".Translate(),
+                false,
+                null,
+                null
+            ));
+        }
+        // 新增：执行白银转移
+        private void ExecuteSilverTransfer(GlobalStorageWorldComponent globalStorage, int silverAmount)
+        {
+            try
+            {
+                // 从输入端移除白银
+                if (globalStorage.RemoveFromInputStorage(ThingDefOf.Silver, silverAmount))
+                {
+                    // 添加到输出端
+                    globalStorage.AddToOutputStorage(ThingDefOf.Silver, silverAmount);
+
+                    // 显示成功消息
+                    Messages.Message("WULA_SilverTransferred".Translate(silverAmount), MessageTypeDefOf.PositiveEvent);
+
+                    Log.Message($"[WULA] Transferred {silverAmount} silver from input to output storage");
+                }
+                else
+                {
+                    Messages.Message("WULA_TransferFailed".Translate(), MessageTypeDefOf.RejectInput);
+                    Log.Error("[WULA] Failed to remove silver from input storage during transfer");
+                }
+            }
+            catch (System.Exception ex)
+            {
+                Messages.Message("WULA_TransferError".Translate(), MessageTypeDefOf.RejectInput);
+                Log.Error($"[WULA] Error during silver transfer: {ex}");
+            }
+        }
+
         // 新增：检查是否有拥有FactoryFacility设施的飞行器
         private bool HasFactoryFacilityFlyOver()
         {
@@ -587,7 +656,7 @@ namespace WulaFallenEmpire
                 }
                 dropPodInfo.innerContainer = container;
                 // 生成空投舱
-                DropPodUtility.MakeDropPodAt(dropCell, Map, dropPodInfo);
+                DropPodUtility.MakeDropPodAt(dropCell, Map, dropPodInfo, Faction.OfPlayer);
 
                 Log.Message($"[Airdrop] Successfully created drop pod at {dropCell}");
                 return true;

Source/WulaFallenEmpire/GlobalWorkTable/WULA_Launchable_ToGlobalStorage/CompProperties_GarbageShield.cs

@@ -11,6 +11,9 @@ namespace WulaFallenEmpire
         public bool garbageShieldEnabled = false; // 通过XML配置启用/禁用
         public string garbageShieldUIEventDefName; // 垃圾屏蔽触发时弹出的UI事件defName
         
+        // 新增：配置是否检查不可交易物品
+        public bool checkNonTradableItems = false;
+        
         public CompProperties_GarbageShield()
         {
             this.compClass = typeof(CompGarbageShield);
@@ -30,7 +33,7 @@ namespace WulaFallenEmpire
             if (!GarbageShieldEnabled) return false;
 
             // 检查是否是殖民者
-            if (thing is Pawn pawn && pawn.IsColonist)
+            if (thing is Pawn pawn)
                 return true;
 
             // 检查是否是尸体
@@ -41,6 +44,10 @@ namespace WulaFallenEmpire
             if (IsToxicWaste(thing))
                 return true;
 
+            // 新增：检查不可交易物品（如果配置启用）
+            if (Props.checkNonTradableItems && IsNonTradableItem(thing))
+                return true;
+
             return false;
         }
 
@@ -69,6 +76,13 @@ namespace WulaFallenEmpire
             return thing.def == ThingDefOf.Wastepack;
         }
 
+        // 新增：判断是否为不可交易物品
+        private bool IsNonTradableItem(Thing thing)
+        {
+            // 检查 tradeability 是否为 None
+            return thing.def.tradeability == Tradeability.None;
+        }
+
         // 处理垃圾屏蔽触发并触发UI事件
         public void ProcessGarbageShieldTrigger(List<Thing> forbiddenItems)
         {

Source/WulaFallenEmpire/GlobalWorkTable/WULA_Launchable_ToGlobalStorage/CompProperties_Launchable_ToGlobalStorage.cs

@@ -11,6 +11,8 @@ namespace WulaFallenEmpire
         // 垃圾屏蔽配置 - 通过XML控制
         public bool garbageShieldEnabled = false;
         public string garbageShieldUIEventDefName = "Wula_UI_Legion_Reply_1";
+        // 新增：明确不检查不可交易物品
+        public bool checkNonTradableItems = false; // Launchable_ToGlobalStorage 不需要检查不可交易物品
 
         public CompProperties_Launchable_ToGlobalStorage()
         {

Source/WulaFallenEmpire/GlobalWorkTable/WULA_ValueConverter/CompProperties_ValueConverter.cs

@@ -3,16 +3,16 @@ using Verse;
 
 namespace WulaFallenEmpire
 {
-    public class CompProperties_ValueConverter : CompProperties
+    public class CompProperties_ValueConverter : CompProperties_Launchable_TransportPod
     {
-        public float conversionRate = 1.0f; // 价值转换倍率
-        public ThingDef outputThingDef = null; // 输出物品定义，默认为白银
-        public bool destroyAfterConversion = true; // 转换后是否销毁建筑
+        public float conversionRatio = 0.5f; // 默认50%的转换比例
+        public ThingDef targetCurrency = ThingDefOf.Silver; // 目标货币，默认为白银
+        
+        // 新增：垃圾屏蔽配置 - 专门为价值转换器配置
+        public bool garbageShieldEnabled = true; // 默认启用垃圾屏蔽
+        public string garbageShieldUIEventDefName = "Wula_UI_Legion_Reply_1"; // 默认UI事件
+        public bool checkNonTradableItems = true; // 专门为价值转换器启用不可交易物品检查
         
-        // 垃圾屏蔽配置
-        public bool garbageShieldEnabled = false;
-        public string garbageShieldUIEventDefName = "Wula_UI_Legion_Reply_1";
-
         public CompProperties_ValueConverter()
         {
             this.compClass = typeof(CompValueConverter);

Source/WulaFallenEmpire/GlobalWorkTable/WULA_ValueConverter/CompValueConverter.cs

@@ -1,157 +1,316 @@
 using RimWorld;
 using System.Collections.Generic;
+using System.Text;
 using UnityEngine;
 using Verse;
 using Verse.Sound;
-using System.Text;
-using System.Linq;
 using RimWorld.Planet;
 
-
 namespace WulaFallenEmpire
 {
     public class CompValueConverter : CompLaunchable_TransportPod
     {
         public new CompProperties_ValueConverter Props => (CompProperties_ValueConverter)this.props;
-        
-        // 获取垃圾屏蔽组件
         public CompGarbageShield GarbageShieldComp => this.parent.GetComp<CompGarbageShield>();
-        
-        // 获取容器组件
-        public new CompTransporter Transporter => this.parent.GetComp<CompTransporter>();
+
+        // 新增：专门为价值转换器检查禁止物品
+        public List<Thing> GetForbiddenItemsForConverter(ThingOwner container)
+        {
+            List<Thing> forbiddenItems = new List<Thing>();
+            
+            // 如果配置了专门的垃圾屏蔽组件，使用它
+            if (GarbageShieldComp != null && GarbageShieldComp.GarbageShieldEnabled)
+            {
+                forbiddenItems.AddRange(GarbageShieldComp.GetForbiddenItems(container));
+            }
+            else
+            {
+                // 否则使用价值转换器自己的配置
+                forbiddenItems.AddRange(GetForbiddenItemsByConverterConfig(container));
+            }
+            
+            return forbiddenItems;
+        }
+
+        // 新增：根据价值转换器配置检查禁止物品
+        private List<Thing> GetForbiddenItemsByConverterConfig(ThingOwner container)
+        {
+            List<Thing> forbiddenItems = new List<Thing>();
+            
+            if (!Props.garbageShieldEnabled) return forbiddenItems;
+            
+            foreach (Thing item in container)
+            {
+                if (IsForbiddenItemByConverterConfig(item))
+                {
+                    forbiddenItems.Add(item);
+                }
+            }
+            
+            return forbiddenItems;
+        }
+
+        // 新增：根据价值转换器配置判断是否为禁止物品
+        private bool IsForbiddenItemByConverterConfig(Thing thing)
+        {
+            // 检查是否是殖民者
+            if (thing is Pawn pawn)
+                return true;
+
+            // 检查是否是尸体
+            if (thing.def.IsCorpse)
+                return true;
+
+            // 检查是否是有毒垃圾
+            if (IsToxicWaste(thing))
+                return true;
+
+            // 检查不可交易物品（价值转换器专用）
+            if (Props.checkNonTradableItems && IsNonTradableItem(thing))
+                return true;
+
+            return false;
+        }
+
+        // 新增：判断是否为有毒垃圾
+        private bool IsToxicWaste(Thing thing)
+        {
+            return thing.def == ThingDefOf.Wastepack;
+        }
+
+        // 新增：判断是否为不可交易物品
+        private bool IsNonTradableItem(Thing thing)
+        {
+            return thing.def.tradeability == Tradeability.None;
+        }
 
         public override IEnumerable<Gizmo> CompGetGizmosExtra()
         {
-            // 首先处理基类的Gizmo，但过滤掉原版的发射按钮
+            // 移除原有的发射按钮，替换为我们自己的价值转换按钮
             foreach (Gizmo gizmo in base.CompGetGizmosExtra())
             {
-                // 跳过原版的发射按钮
                 if (gizmo is Command_Action launchCommand && 
                     (launchCommand.defaultDesc == "CommandLaunchGroupDesc".Translate() || 
                      launchCommand.defaultDesc == "CommandLaunchSingleDesc".Translate()))
                 {
-                    continue;
+                    continue; // 跳过原版的发射按钮
                 }
                 yield return gizmo;
             }
 
-            // 添加我们的转换按钮
-            if (Transporter != null && Transporter.innerContainer.Any)
+            if (this.Transporter.LoadingInProgressOrReadyToLaunch)
             {
                 Command_Action command = new Command_Action();
-                command.defaultLabel = "WULA_ConvertToSilver".Translate();
-                command.defaultDesc = "WULA_ConvertToSilverDesc".Translate(Props.conversionRate.ToStringPercent());
-                command.icon = ContentFinder<Texture2D>.Get("UI/Commands/ConvertToSilver");
+                command.defaultLabel = "WULA_ConvertToCurrency".Translate();
+                command.defaultDesc = GetConversionDescription();
+                command.icon = ContentFinder<Texture2D>.Get("UI/Commands/LaunchShip");
                 command.action = delegate
                 {
-                    this.TryLaunchToSilver();
+                    this.ConvertToCurrency();
                 };
                 
-                // 添加禁用状态检查
-                if (!CanConvert())
+                // 禁用条件检查
+                string disableReason;
+                if (!CanConvert(out disableReason))
                 {
-                    command.Disable("WULA_CannotConvert".Translate());
+                    command.Disable(disableReason);
                 }
-                
+
                 yield return command;
             }
         }
 
         /// <summary>
-        /// 检查是否可以执行转换
+        /// 获取转换描述信息
         /// </summary>
-        private bool CanConvert()
+        private string GetConversionDescription()
         {
-            if (Transporter == null || !Transporter.innerContainer.Any)
-                return false;
-
-            // 检查垃圾屏蔽
-            if (GarbageShieldComp != null && GarbageShieldComp.GarbageShieldEnabled)
+            try
             {
-                List<Thing> forbiddenItems = GarbageShieldComp.GetForbiddenItems(Transporter.innerContainer);
-                if (forbiddenItems.Count > 0)
-                    return false;
+                StringBuilder sb = new StringBuilder();
+                
+                // 安全地获取目标货币标签
+                string targetCurrencyLabel = "Unknown Currency";
+                if (Props?.targetCurrency != null)
+                {
+                    targetCurrencyLabel = Props.targetCurrency.LabelCap;
+                }
+                
+                sb.AppendLine("WULA_ConvertToCurrencyDesc".Translate(targetCurrencyLabel, (Props.conversionRatio * 100f).ToString("F0")));
+                
+                // 显示当前物品总价值和预计转换结果
+                float totalValue = CalculateTotalValue();
+                float convertedValue = totalValue * Props.conversionRatio;
+                
+                // 显示物品列表
+                var items = GetItemList();
+                if (items.Count > 0)
+                {
+                    sb.AppendLine();
+                    sb.AppendLine("WULA_ContainedItems".Translate());
+                    foreach (Thing item in items)
+                    {
+                        sb.AppendLine("  - " + item.LabelCap + " x" + item.stackCount);
+                    }
+                }
+
+                return sb.ToString();
+            }
+            catch (System.Exception ex)
+            {
+                Log.Error($"[WULA ValueConverter] Error in GetConversionDescription: {ex}");
+                return "WULA_ConversionDescriptionError".Translate();
+            }
+        }
+
+        /// <summary>
+        /// 检查是否可以转换
+        /// </summary>
+        private bool CanConvert(out string reason)
+        {
+            reason = null;
+
+            if (!this.parent.Spawned)
+            {
+                reason = "WULA_ConverterNotSpawned".Translate();
+                return false;
+            }
+
+            CompTransporter transporter = this.Transporter;
+            if (transporter == null || !transporter.innerContainer.Any)
+            {
+                reason = "WULA_NoItemsToConvert".Translate();
+                return false;
+            }
+
+            // 检查基类的发射条件（燃料、冷却时间等）
+            var baseResult = base.CanLaunch(null);
+            if (!baseResult.Accepted)
+            {
+                reason = baseResult.Reason;
+                return false;
             }
 
             return true;
         }
 
         /// <summary>
-        /// 将物品价值转换为白银
+        /// 转换为货币
         /// </summary>
-        public void TryLaunchToSilver()
+        public void ConvertToCurrency()
         {
+            CompTransporter transporter = this.Transporter;
+            var globalStorage = Find.World.GetComponent<GlobalStorageWorldComponent>();
+
+            // 检查垃圾屏蔽 - 使用价值转换器专用的检查方法
+            List<Thing> forbiddenItems = GetForbiddenItemsForConverter(transporter.innerContainer);
+            if (forbiddenItems.Count > 0)
+            {
+                // 显示取消发射消息
+                StringBuilder forbiddenList = new StringBuilder();
+                foreach (Thing item in forbiddenItems)
+                {
+                    if (forbiddenList.Length > 0) forbiddenList.Append(", ");
+                    forbiddenList.Append($"{item.LabelCap} x{item.stackCount}");
+                }
+
+                Messages.Message("WULA_LaunchCancelledDueToForbiddenItems".Translate(forbiddenList.ToString()),
+                    this.parent, MessageTypeDefOf.RejectInput);
+
+                // 触发垃圾屏蔽UI事件
+                ProcessGarbageShieldTriggerForConverter(forbiddenItems);
+
+                return; // 取消发射
+            }
+
             if (!this.parent.Spawned)
             {
-                Log.Error("Tried to convert value from " + this.parent + " but it's not spawned.");
+                Log.Error("Tried to convert " + this.parent + " but it's not spawned.");
                 return;
             }
 
-            var globalStorage = Find.World.GetComponent<GlobalStorageWorldComponent>();
-            if (globalStorage == null)
-            {
-                Log.Error("Could not find GlobalStorageWorldComponent.");
-                return;
-            }
-
-            if (Transporter == null || !Transporter.innerContainer.Any)
+            if (transporter == null || !transporter.innerContainer.Any)
             {
                 Messages.Message("WULA_NoItemsToConvert".Translate(), this.parent, MessageTypeDefOf.RejectInput);
                 return;
             }
 
-            // 检查垃圾屏蔽
-            if (GarbageShieldComp != null && GarbageShieldComp.GarbageShieldEnabled)
-            {
-                List<Thing> forbiddenItems = GarbageShieldComp.GetForbiddenItems(Transporter.innerContainer);
-                if (forbiddenItems.Count > 0)
-                {
-                    StringBuilder forbiddenList = new StringBuilder();
-                    foreach (Thing item in forbiddenItems)
-                    {
-                        if (forbiddenList.Length > 0) forbiddenList.Append(", ");
-                        forbiddenList.Append($"{item.LabelCap} x{item.stackCount}");
-                    }
-
-                    Messages.Message("WULA_ConversionCancelledDueToForbiddenItems".Translate(forbiddenList.ToString()),
-                        this.parent, MessageTypeDefOf.RejectInput);
-
-                    GarbageShieldComp.ProcessGarbageShieldTrigger(forbiddenItems);
-                    return;
-                }
-            }
-
-            // 计算总价值
+            // 1. 计算总价值并生成白银
             float totalValue = CalculateTotalValue();
-            if (totalValue <= 0)
-            {
-                Messages.Message("WULA_NoValuableItems".Translate(), this.parent, MessageTypeDefOf.RejectInput);
-                return;
-            }
+            float convertedValue = totalValue * Props.conversionRatio;
+            int silverAmount = Mathf.FloorToInt(convertedValue);
 
-            // 应用转换倍率
-            int silverAmount = CalculateSilverAmount(totalValue);
             if (silverAmount <= 0)
             {
-                Messages.Message("WULA_ConversionValueTooLow".Translate(), this.parent, MessageTypeDefOf.RejectInput);
+                Messages.Message("WULA_ConvertedValueTooLow".Translate(), this.parent, MessageTypeDefOf.RejectInput);
                 return;
             }
 
-            // 执行转换
-            PerformConversion(globalStorage, silverAmount, totalValue);
+            // 2. 将白银添加到全局存储的输入储存器
+            if (globalStorage != null)
+            {
+                globalStorage.AddToInputStorage(Props.targetCurrency, silverAmount);
+            }
+            else
+            {
+                Log.Error("Could not find GlobalStorageWorldComponent.");
+                return;
+            }
 
-            // 调用基类的发射方法，让它处理动画和销毁
-            // 注意：这里我们发射到当前地图的同一个位置，实际上只是利用发射动画
+            // 3. 统计转换的物品信息
+            StringBuilder convertedItems = new StringBuilder();
+            int itemCount = 0;
+            float originalTotalValue = 0f;
+
+            foreach (Thing item in transporter.innerContainer)
+            {
+                itemCount += item.stackCount;
+                originalTotalValue += item.MarketValue * item.stackCount;
+                
+                if (convertedItems.Length > 0) convertedItems.Append(", ");
+                convertedItems.Append($"{item.LabelCap} x{item.stackCount}");
+            }
+
+            // 4. 清空容器
+            transporter.innerContainer.ClearAndDestroyContents();
+
+            // 5. 显示转换结果消息
+            string message = BuildConversionMessage(itemCount, originalTotalValue, silverAmount, convertedItems.ToString());
+            Messages.Message(message, this.parent, MessageTypeDefOf.PositiveEvent);
+
+            // 6. 调用基类的发射方法，处理动画和销毁
+            // 使用当前地图的tile作为目的地，arrivalAction为null
             base.TryLaunch(this.parent.Map.Tile, null);
         }
 
         /// <summary>
-        /// 重写基类的TryLaunch方法，阻止原版发射逻辑
+        /// 新增：价值转换器专用的垃圾屏蔽触发处理
         /// </summary>
-        public new void TryLaunch(PlanetTile destinationTile, TransportersArrivalAction arrivalAction)
+        private void ProcessGarbageShieldTriggerForConverter(List<Thing> forbiddenItems)
         {
-            // 阻止原版发射逻辑，使用我们的转换逻辑
-            TryLaunchToSilver();
+            if (forbiddenItems.Count > 0)
+            {
+                string uiEventDefName = Props.garbageShieldUIEventDefName;
+                
+                // 如果配置了专门的垃圾屏蔽组件，使用它的UI事件配置
+                if (GarbageShieldComp != null && !string.IsNullOrEmpty(GarbageShieldComp.Props.garbageShieldUIEventDefName))
+                {
+                    uiEventDefName = GarbageShieldComp.Props.garbageShieldUIEventDefName;
+                }
+                
+                if (!string.IsNullOrEmpty(uiEventDefName))
+                {
+                    EventDef uiDef = DefDatabase<EventDef>.GetNamed(uiEventDefName, false);
+                    if (uiDef != null)
+                    {
+                        Find.WindowStack.Add(new Dialog_CustomDisplay(uiDef));
+                    }
+                    else
+                    {
+                        Log.Error($"[CompValueConverter] Could not find EventDef named '{uiEventDefName}'.");
+                    }
+                }
+            }
         }
 
         /// <summary>
@@ -160,145 +319,67 @@ namespace WulaFallenEmpire
         private float CalculateTotalValue()
         {
             float totalValue = 0f;
-            
-            foreach (Thing item in Transporter.innerContainer)
+            CompTransporter transporter = this.Transporter;
+
+            if (transporter != null)
             {
-                // 计算单个物品的市场价值
-                float itemValue = item.MarketValue * item.stackCount;
-                totalValue += itemValue;
-                
-                if (Prefs.DevMode)
+                foreach (Thing item in transporter.innerContainer)
                 {
-                    Log.Message($"[ValueConverter] {item.LabelCap} x{item.stackCount}: {item.MarketValue} each, total: {itemValue}");
+                    totalValue += item.MarketValue * item.stackCount;
                 }
             }
-            
-            if (Prefs.DevMode)
-            {
-                Log.Message($"[ValueConverter] Total value before conversion: {totalValue}");
-            }
+
             return totalValue;
         }
 
         /// <summary>
-        /// 计算转换后的白银数量
+        /// 获取物品列表
         /// </summary>
-        private int CalculateSilverAmount(float totalValue)
+        private List<Thing> GetItemList()
         {
-            // 应用转换倍率
-            float convertedValue = totalValue * Props.conversionRate;
-            
-            // 转换为白银（白银的市场价值为1）
-            int silverAmount = Mathf.FloorToInt(convertedValue);
-            
-            if (Prefs.DevMode)
+            List<Thing> items = new List<Thing>();
+            CompTransporter transporter = this.Transporter;
+
+            if (transporter != null)
             {
-                Log.Message($"[ValueConverter] After conversion rate ({Props.conversionRate}): {convertedValue}, Silver amount: {silverAmount}");
+                foreach (Thing item in transporter.innerContainer)
+                {
+                    items.Add(item);
+                }
             }
-            
-            return silverAmount;
+
+            return items;
         }
 
         /// <summary>
-        /// 执行转换操作
+        /// 构建转换消息
         /// </summary>
-        private void PerformConversion(GlobalStorageWorldComponent globalStorage, int silverAmount, float originalValue)
+        private string BuildConversionMessage(int itemCount, float originalValue, int silverAmount, string itemList)
         {
-            // 1. 将白银添加到全局存储器的输入端
-            ThingDef silverDef = Props.outputThingDef ?? ThingDefOf.Silver;
-            globalStorage.AddToInputStorage(silverDef, silverAmount);
-
-            // 2. 显示转换结果消息
-            ShowConversionMessage(silverAmount, originalValue);
-
-            // 4. 清空容器
-            Transporter.innerContainer.ClearAndDestroyContents();
-
-            // 5. 如果配置为转换后销毁，则销毁建筑
-            if (Props.destroyAfterConversion)
+            StringBuilder message = new StringBuilder();
+            
+            message.Append("WULA_ConversionComplete".Translate(itemCount, originalValue.ToString("F2"), silverAmount, Props.targetCurrency?.LabelCap ?? "Unknown Currency"));
+            
+            if (!string.IsNullOrEmpty(itemList))
             {
-                this.parent.Destroy(DestroyMode.Vanish);
+                message.Append("\n\n");
+                message.Append("WULA_ConvertedItems".Translate(itemList));
             }
+            
+            message.Append("\n\n");
+            message.Append("WULA_ConversionRatioApplied".Translate((Props.conversionRatio * 100f).ToString("F0")));
+
+            return message.ToString();
         }
 
         /// <summary>
-        /// 显示转换结果消息
+        /// 重写基类的发射方法，确保使用我们的逻辑
         /// </summary>
-        private void ShowConversionMessage(int silverAmount, float originalValue)
+        public new void TryLaunch(PlanetTile destinationTile, TransportersArrivalAction arrivalAction)
         {
-            string message;
-            
-            if (Props.conversionRate < 1.0f)
-            {
-                message = "WULA_ValueConvertedWithLoss".Translate(
-                    originalValue.ToString("F0"), 
-                    silverAmount, 
-                    Props.conversionRate.ToStringPercent()
-                );
-            }
-            else if (Props.conversionRate > 1.0f)
-            {
-                message = "WULA_ValueConvertedWithBonus".Translate(
-                    originalValue.ToString("F0"), 
-                    silverAmount, 
-                    Props.conversionRate.ToStringPercent()
-                );
-            }
-            else
-            {
-                message = "WULA_ValueConverted".Translate(
-                    originalValue.ToString("F0"), 
-                    silverAmount
-                );
-            }
-            
-            Messages.Message(message, this.parent, MessageTypeDefOf.PositiveEvent);
-        }
-
-        /// <summary>
-        /// 获取转换效率描述（用于界面显示）
-        /// </summary>
-        public string GetConversionEfficiencyDescription()
-        {
-            StringBuilder sb = new StringBuilder();
-            
-            sb.AppendLine("WULA_ConversionEfficiency".Translate(Props.conversionRate.ToStringPercent()));
-            
-            if (Props.conversionRate < 1.0f)
-            {
-                sb.AppendLine("WULA_ConversionEfficiencyLoss".Translate());
-            }
-            else if (Props.conversionRate > 1.0f)
-            {
-                sb.AppendLine("WULA_ConversionEfficiencyBonus".Translate());
-            }
-            else
-            {
-                sb.AppendLine("WULA_ConversionEfficiencyNormal".Translate());
-            }
-            
-            return sb.ToString();
-        }
-
-        /// <summary>
-        /// 在检查器中显示转换信息
-        /// </summary>
-        public override string CompInspectStringExtra()
-        {
-            StringBuilder sb = new StringBuilder();
-            
-            if (Transporter != null && Transporter.innerContainer.Any)
-            {
-                // 显示容器内物品总价值
-                float currentValue = CalculateTotalValue();
-                int potentialSilver = CalculateSilverAmount(currentValue);
-                
-                sb.AppendLine("WULA_CurrentValueInContainer".Translate(currentValue.ToString("F0")));
-                sb.AppendLine("WULA_PotentialSilver".Translate(potentialSilver));
-                sb.AppendLine("WULA_ConversionRate".Translate(Props.conversionRate.ToStringPercent()));
-            }
-            
-            return sb.ToString().TrimEndNewlines();
+            // 这个方法不应该被直接调用，应该使用ConvertToCurrency
+            Log.Warning("CompValueConverter.TryLaunch should not be called directly. Use ConvertToCurrency instead.");
+            ConvertToCurrency();
         }
     }
 }