Kalospacer/WulaFallenEmpireRW
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

暂存5

Browse Source
This commit is contained in:
ProjectKoi-Kalo\Kalo
2025-08-25 13:49:33 +08:00
parent 9ce8146a3c
commit ca8b713d4b
6 changed files with 290 additions and 295 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
Source/WulaFallenEmpire/WULA_Shuttle/Building_ArmedShuttleWithPocket.cs
View File

@@ -20,9 +20,7 @@ namespace WulaFallenEmpire
{
#region 静态图标定义（使用原版MapPortal的图标）
/// <summary>查看口袋地图图标</summary>
private static readonly Texture2D ViewPocketMapTex = ContentFinder<Texture2D>.Get("UI/Commands/ViewCave");
/// <summary>取消进入图标</summary>
private static readonly Texture2D CancelEnterTex = ContentFinder<Texture2D>.Get("UI/Designators/Cancel");
@@ -797,28 +795,7 @@ namespace WulaFallenEmpire
enterCommand.disabledReason = reason;
yield return enterCommand;
// 查看口袋地图按钮（模仿原版MapPortal）
if (pocketMap != null)
{
yield return new Command_Action
{
defaultLabel = "WULA.PocketSpace.ViewMap".Translate(),
defaultDesc = "WULA.PocketSpace.ViewMapDesc".Translate(),
icon = ViewPocketMapTex,
action = delegate
{
// 模仿原版，跳转到口袋地图并选中退出点
if (exit != null)
{
CameraJumper.TryJumpAndSelect(exit);
}
else
{
SwitchToPocketSpace();
}
}
};
}
}
}

540
Source/WulaFallenEmpire/WULA_Shuttle/CompPocketMapPortal.cs
View File

@@ -1,106 +1,65 @@
using RimWorld;
using Verse;
using Verse.AI;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using System.Reflection;
namespace WulaFallenEmpire
{
/// <summary>
/// 口袋空间传送门组件 - 将Building_PocketMapExit的功能转换成可挂载的组件
/// 直接挂载在穿梭机上处理进入内部空间的逻辑
/// 口袋空间传送门组件 - 只作为入口功能，附加在穿梭机上处理进入内部空间的逻辑
/// </summary>
public class CompPocketMapPortal : ThingComp
{
/// <summary>目标地图（口袋空间）</summary>
public Map targetMap;
/// <summary>目标位置（在口袋空间中的位置）</summary>
public IntVec3 targetPos;
/// <summary>父穿梭机引用</summary>
public Building_ArmedShuttleWithPocket parentShuttle;
/// <summary>组件属性</summary>
public CompProperties_PocketMapPortal Props => (CompProperties_PocketMapPortal)props;
/// <summary>父建筑（应该是穿梭机）</summary>
public Building_ArmedShuttleWithPocket ParentShuttle
{
get
{
if (parentShuttle == null && parent is Building_ArmedShuttleWithPocket shuttle)
{
parentShuttle = shuttle;
}
return parentShuttle;
}
}
public override void PostExposeData()
{
base.PostExposeData();
Scribe_References.Look(ref targetMap, "targetMap");
Scribe_Values.Look(ref targetPos, "targetPos");
Scribe_References.Look(ref parentShuttle, "parentShuttle");
}
/// <summary>父建筑（必须是穿梭机）</summary>
public Building_ArmedShuttleWithPocket ParentShuttle => parent as Building_ArmedShuttleWithPocket;
/// <summary>MapPortal适配器，用于使用原版Dialog_EnterPortal</summary>
private ShuttlePortalAdapter portalAdapter;
public override void PostSpawnSetup(bool respawningAfterLoad)
{
base.PostSpawnSetup(respawningAfterLoad);
// 确保父穿梭机引用正确
if (parent is Building_ArmedShuttleWithPocket shuttle)
{
parentShuttle = shuttle;
Log.Message($"[WULA] CompPocketMapPortal attached to shuttle: {parent.LabelShort}");
}
else
// 检查父对象是否是穿梭机
if (ParentShuttle == null)
{
Log.Error($"[WULA] CompPocketMapPortal attached to non-shuttle building: {parent?.def?.defName}");
}
}
/// <summary>
/// 设置口袋空间目标（由穿梭机调用）
/// </summary>
public void SetPocketSpaceTarget(Map pocketMap, IntVec3 exitPos)
{
targetMap = pocketMap;
targetPos = exitPos;
Log.Message($"[WULA] CompPocketMapPortal target set to pocket map: {pocketMap?.uniqueID} at {exitPos}");
}
/// <summary>
/// 获取其他地图（口袋空间），模仿原版MapPortal.GetOtherMap
/// </summary>
public Map GetOtherMap()
{
// 如果没有目标地图，尝试从父穿梭机获取
if (targetMap == null && ParentShuttle != null)
else
{
targetMap = ParentShuttle.PocketMap;
// 创建MapPortal适配器，并设置其地图和位置信息
portalAdapter = new ShuttlePortalAdapter(ParentShuttle);
// 使用反射设置适配器的地图和位置，让Dialog_EnterPortal能正确访问
if (portalAdapter != null && ParentShuttle.Spawned)
{
try
{
// 使用反射设置私有字段
var mapField = typeof(Thing).GetField("mapIndexOrState",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
var positionField = typeof(Thing).GetField("positionInt",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (mapField != null && positionField != null)
{
mapField.SetValue(portalAdapter, mapField.GetValue(ParentShuttle));
positionField.SetValue(portalAdapter, positionField.GetValue(ParentShuttle));
}
}
catch (System.Exception ex)
{
Log.Warning($"[WULA] Could not set adapter map/position via reflection: {ex.Message}");
}
}
}
return targetMap;
}
/// <summary>
/// 获取目标位置（在口袋空间中的位置），模仿原版MapPortal.GetDestinationLocation
/// </summary>
public IntVec3 GetDestinationLocation()
{
// 如果没有目标位置，使用口袋地图中心
if (targetPos == IntVec3.Invalid && targetMap != null)
{
targetPos = targetMap.Center;
}
return targetPos;
}
/// <summary>
/// 检查是否可以进入口袋空间，模仿原版MapPortal.IsEnterable
/// 检查穿梭机是否可以进入（仅作为入口功能）
/// </summary>
public bool IsEnterable(out string reason)
{
@@ -122,27 +81,22 @@ namespace WulaFallenEmpire
return false;
}
// 检查父穿梭机的传送状态
if (ParentShuttle != null)
// 检查穿梭机的传送状态
var transportDisabledField = typeof(Building_ArmedShuttleWithPocket).GetField("transportDisabled",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (transportDisabledField != null)
{
// 使用反射获取 transportDisabled 字段值
var transportDisabledField = typeof(Building_ArmedShuttleWithPocket).GetField("transportDisabled",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (transportDisabledField != null)
bool transportDisabled = (bool)transportDisabledField.GetValue(ParentShuttle);
if (transportDisabled)
{
bool transportDisabled = (bool)transportDisabledField.GetValue(ParentShuttle);
if (transportDisabled)
{
reason = "WULA.PocketSpace.TransportDisabled".Translate();
return false;
}
reason = "WULA.PocketSpace.TransportDisabled".Translate();
return false;
}
}
// 检查目标地图是否存在
Map pocketMap = GetOtherMap();
if (pocketMap == null)
// 检查口袋地图是否存在
if (ParentShuttle.PocketMap == null)
{
reason = "WULA.PocketSpace.NoTargetMap".Translate();
return false;
@@ -151,177 +105,80 @@ namespace WulaFallenEmpire
reason = "";
return true;
}
/// <summary>
/// 处理进入事件，将Pawn传送到口袋空间，模仿原版MapPortal.OnEntered
/// 获取组件额外的Gizmo按钮（根据口袋空间初始化状态显示不同按钮）
/// 重写CompGetGizmosExtra方法，这样RimWorld会自动调用并显示按钮
/// </summary>
public void OnEntered(Pawn pawn)
public override IEnumerable<Gizmo> CompGetGizmosExtra()
{
Map pocketMap = GetOtherMap();
if (pocketMap == null || !pawn.Spawned) return;
try
if (ParentShuttle == null) yield break;
// 检查口袋空间是否已初始化
bool pocketMapExists = ParentShuttle.PocketMap != null;
if (!pocketMapExists)
{
// 在口袋地图找一个安全位置
IntVec3 spawnPos = GetDestinationLocation();
if (spawnPos == IntVec3.Invalid)
// 口袋空间未创建，显示初始化按钮
Command_Action initializeCommand = new Command_Action();
initializeCommand.action = delegate
{
spawnPos = pocketMap.Center;
// 创建口袋空间
InitializePocketSpace();
};
initializeCommand.icon = ContentFinder<Texture2D>.Get("UI/Commands/LoadTransporter");
initializeCommand.defaultLabel = "WULA.PocketSpace.Initialize".Translate();
initializeCommand.defaultDesc = "WULA.PocketSpace.InitializeDesc".Translate();
// 检查是否可以初始化
if (!ParentShuttle.Spawned)
{
initializeCommand.Disabled = true;
initializeCommand.disabledReason = "WULA.PocketSpace.NotSpawned".Translate();
}
// 寻找可行走的位置
spawnPos = CellFinder.RandomClosewalkCellNear(spawnPos, pocketMap, 10,
p => p.Standable(pocketMap) && !p.GetThingList(pocketMap).Any(t => t is Pawn));
if (spawnPos.IsValid)
{
// 传送人员到口袋空间
pawn.DeSpawn();
GenPlace.TryPlaceThing(pawn, spawnPos, pocketMap, ThingPlaceMode.Near);
// 通知父穿梭机有物品被添加
if (ParentShuttle != null)
{
ParentShuttle.Notify_ThingAdded(pawn);
}
// 如果是玩家控制的殖民者，切换到口袋地图
if (pawn.IsColonistPlayerControlled)
{
Current.Game.CurrentMap = pocketMap;
Find.CameraDriver.JumpToCurrentMapLoc(spawnPos);
}
Messages.Message("WULA.PocketSpace.TransferSuccess".Translate(1), MessageTypeDefOf.PositiveEvent);
Log.Message($"[WULA] Transferred {pawn.LabelShort} to pocket space at {spawnPos}");
}
else
{
Log.Error($"[WULA] Could not find valid spawn position in pocket space for {pawn.LabelShort}");
}
yield return initializeCommand;
}
catch (System.Exception ex)
else
{
Log.Error($"[WULA] Error entering pocket space: {ex}");
}
}
/// <summary>
/// 处理从口袋空间退出到主地图的逻辑
/// </summary>
public void ExitPocketSpace(Pawn pawn)
{
if (ParentShuttle == null || !ParentShuttle.Spawned || !pawn.Spawned) return;
try
{
// 在主地图找一个安全位置（穿梭机附近）
IntVec3 exitPos = CellFinder.RandomClosewalkCellNear(ParentShuttle.Position, ParentShuttle.Map, 3,
p => p.Standable(ParentShuttle.Map) && !p.GetThingList(ParentShuttle.Map).Any(t => t is Pawn));
// 穿梭机已创建，显示装载按钮（使用原版Dialog_EnterPortal）
Command_Action enterCommand = new Command_Action();
enterCommand.action = delegate
{
// 使用和Building_PocketMapExit一模一样的Dialog_EnterPortal方法
if (portalAdapter != null && portalAdapter.shuttle != null)
{
var dialog = new Dialog_EnterPortal(portalAdapter);
Find.WindowStack.Add(dialog);
}
else
{
Log.Error("[WULA] Portal adapter or shuttle is null, recreating adapter");
// 重新创建适配器
if (ParentShuttle != null)
{
portalAdapter = new ShuttlePortalAdapter(ParentShuttle);
var dialog = new Dialog_EnterPortal(portalAdapter);
Find.WindowStack.Add(dialog);
}
else
{
Messages.Message("内部错误：穿梭机引用丢失", ParentShuttle, MessageTypeDefOf.RejectInput);
}
}
};
enterCommand.icon = ContentFinder<Texture2D>.Get(Props.buttonIconPath);
enterCommand.defaultLabel = Props.enterButtonTextKey.Translate() + "...";
enterCommand.defaultDesc = Props.enterButtonDescKey.Translate();
if (exitPos.IsValid)
{
// 传送人员回主地图
pawn.DeSpawn();
GenPlace.TryPlaceThing(pawn, exitPos, ParentShuttle.Map, ThingPlaceMode.Near);
// 如果是玩家控制的殖民者，切换到主地图
if (pawn.IsColonistPlayerControlled)
{
Current.Game.CurrentMap = ParentShuttle.Map;
Find.CameraDriver.JumpToCurrentMapLoc(exitPos);
}
Messages.Message("WULA.PocketSpace.ExitSuccess".Translate(pawn.LabelShort), MessageTypeDefOf.PositiveEvent);
Log.Message($"[WULA] {pawn.LabelShort} exited pocket space to main map at {exitPos}");
}
else
{
Log.Error($"[WULA] Could not find valid exit position for {pawn.LabelShort}");
}
}
catch (System.Exception ex)
{
Log.Error($"[WULA] Error exiting pocket space: {ex}");
}
}
/// <summary>
/// 获取Gizmo按钮（进入口袋空间按钮）
/// </summary>
public IEnumerable<Gizmo> GetGizmos()
{
if (ParentShuttle == null || !ParentShuttle.AllowDirectAccess) yield break;
// 进入口袋空间按钮
Command_Action enterCommand = new Command_Action();
enterCommand.action = delegate
{
// 使用穿梭机的殖民者选择对话框
if (ParentShuttle != null)
{
// 获取所有可用的殖民者
List<Pawn> availablePawns = ParentShuttle.Map.mapPawns.AllPawnsSpawned
.Where(p => p.IsColonist && !p.Downed && p.CanReach(ParentShuttle, PathEndMode.Touch, Danger.Deadly))
.ToList();
if (availablePawns.Count == 0)
{
Messages.Message("WULA.PocketSpace.NoPawnsAvailable".Translate(), ParentShuttle, MessageTypeDefOf.RejectInput);
return;
}
// 创建选项列表
List<FloatMenuOption> options = new List<FloatMenuOption>();
// 添加单个殖民者选项
foreach (Pawn pawn in availablePawns)
{
FloatMenuOption option = new FloatMenuOption(
$"{pawn.LabelShort}",
delegate
{
OnEntered(pawn);
}
);
options.Add(option);
}
// 添加"全部殖民者"选项
if (availablePawns.Count > 1)
{
FloatMenuOption allOption = new FloatMenuOption(
"WULA.PocketSpace.AllColonists".Translate(availablePawns.Count),
delegate
{
foreach (Pawn pawn in availablePawns)
{
OnEntered(pawn);
}
}
);
options.Add(allOption);
}
// 显示浮动菜单
FloatMenu floatMenu = new FloatMenu(options);
Find.WindowStack.Add(floatMenu);
}
};
enterCommand.icon = ContentFinder<Texture2D>.Get("UI/Commands/LoadTransporter");
enterCommand.defaultLabel = "WULA.PocketSpace.Enter".Translate() + "...";
enterCommand.defaultDesc = "WULA.PocketSpace.EnterDesc".Translate();
// 检查是否可以进入
string reason;
enterCommand.Disabled = !IsEnterable(out reason);
enterCommand.disabledReason = reason;
yield return enterCommand;
// 查看口袋地图按钮
Map pocketMap = GetOtherMap();
if (pocketMap != null)
{
// 检查是否可以进入
string reason;
enterCommand.Disabled = !IsEnterable(out reason);
enterCommand.disabledReason = reason;
yield return enterCommand;
// 查看口袋地图按钮
yield return new Command_Action
{
defaultLabel = "WULA.PocketSpace.SwitchTo".Translate(),
@@ -329,41 +186,55 @@ namespace WulaFallenEmpire
icon = ContentFinder<Texture2D>.Get("UI/Commands/ViewCave"),
action = delegate
{
Current.Game.CurrentMap = pocketMap;
Find.CameraDriver.JumpToCurrentMapLoc(GetDestinationLocation());
Current.Game.CurrentMap = ParentShuttle.PocketMap;
Find.CameraDriver.JumpToCurrentMapLoc(ParentShuttle.PocketMap.Center);
}
};
}
}
/// <summary>
/// 获取检视字符串信息
/// 初始化口袋空间
/// </summary>
public string GetInspectString()
private void InitializePocketSpace()
{
if (ParentShuttle == null) return "";
List<string> info = new List<string>();
// 口袋空间状态
if (targetMap != null)
if (ParentShuttle == null || !ParentShuttle.Spawned)
{
info.Add("WULA.PocketSpace.Status".Translate() + ": " + "WULA.PocketSpace.Ready".Translate());
Messages.Message("WULA.PocketSpace.CannotInitialize".Translate(), ParentShuttle, MessageTypeDefOf.RejectInput);
return;
}
if (ParentShuttle.PocketMap != null)
{
Messages.Message("WULA.PocketSpace.AlreadyInitialized".Translate(), ParentShuttle, MessageTypeDefOf.RejectInput);
return;
}
try
{
Log.Message("[WULA] Starting pocket space initialization via component");
// 显示口袋空间中的人员数量
int pawnCount = targetMap.mapPawns.AllPawnsSpawned.Where(p => p.IsColonist).Count();
if (pawnCount > 0)
// 使用穿梭机的SwitchToPocketSpace方法，它会自动创建口袋空间
ParentShuttle.SwitchToPocketSpace();
if (ParentShuttle.PocketMap != null)
{
info.Add("WULA.PocketSpace.PawnCount".Translate(pawnCount));
Messages.Message("WULA.PocketSpace.InitializeSuccess".Translate(), ParentShuttle, MessageTypeDefOf.PositiveEvent);
Log.Message("[WULA] Pocket space initialization completed successfully");
}
else
{
Messages.Message("WULA.PocketSpace.InitializeFailed".Translate(), ParentShuttle, MessageTypeDefOf.RejectInput);
Log.Error("[WULA] Pocket space initialization failed");
}
}
else
catch (System.Exception ex)
{
info.Add("WULA.PocketSpace.Status".Translate() + ": " + "WULA.PocketSpace.NotGenerated".Translate());
Log.Error($"[WULA] Error during pocket space initialization: {ex}");
Messages.Message("WULA.PocketSpace.InitializeFailed".Translate(), ParentShuttle, MessageTypeDefOf.RejectInput);
}
return string.Join("\n", info);
}
}
/// <summary>
@@ -371,9 +242,138 @@ namespace WulaFallenEmpire
/// </summary>
public class CompProperties_PocketMapPortal : CompProperties
{
/// <summary>进入按钮文本键</summary>
public string enterButtonTextKey = "WULA.PocketSpace.Enter";
/// <summary>进入按钮描述键</summary>
public string enterButtonDescKey = "WULA.PocketSpace.EnterDesc";
/// <summary>按钮图标路径</summary>
public string buttonIconPath = "UI/Commands/LoadTransporter";
public CompProperties_PocketMapPortal()
{
this.compClass = typeof(CompPocketMapPortal);
}
}
/// <summary>
/// MapPortal适配器类，将Building_ArmedShuttleWithPocket适配为MapPortal接口
/// 完全模仿Building_PocketMapExit的实现方式
/// </summary>
public class ShuttlePortalAdapter : MapPortal
{
/// <summary>关联的穿梭机</summary>
public Building_ArmedShuttleWithPocket shuttle;
/// <summary>
/// 默认构造函数（RimWorld组件系统要求）
/// </summary>
public ShuttlePortalAdapter()
{
// 为空，在PostSpawnSetup中初始化
}
public ShuttlePortalAdapter(Building_ArmedShuttleWithPocket shuttle)
{
this.shuttle = shuttle;
}
/// <summary>
/// 重写获取其他地图，返回口袋空间（模仿Building_PocketMapExit.GetOtherMap）
/// </summary>
public override Map GetOtherMap()
{
if (shuttle?.PocketMap == null)
{
// 如果口袋空间还没创建，先创建它
shuttle?.SwitchToPocketSpace();
}
return shuttle?.PocketMap;
}
/// <summary>
/// 重写获取目标位置，返回口袋空间中心（模仿Building_PocketMapExit.GetDestinationLocation）
/// </summary>
public override IntVec3 GetDestinationLocation()
{
return shuttle?.PocketMap?.Center ?? IntVec3.Invalid;
}
/// <summary>
/// 重写是否可进入，检查穿梭机状态（模仿Building_PocketMapExit.IsEnterable）
/// </summary>
public override bool IsEnterable(out string reason)
{
if (shuttle == null || !shuttle.Spawned)
{
reason = "WULA.PocketSpace.NotSpawned".Translate();
return false;
}
if (!shuttle.AllowDirectAccess)
{
reason = "WULA.PocketSpace.AccessDenied".Translate();
return false;
}
// 检查穿梭机的传送状态
var transportDisabledField = typeof(Building_ArmedShuttleWithPocket).GetField("transportDisabled",
System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
if (transportDisabledField != null)
{
bool transportDisabled = (bool)transportDisabledField.GetValue(shuttle);
if (transportDisabled)
{
reason = "WULA.PocketSpace.TransportDisabled".Translate();
return false;
}
}
reason = "";
return true;
}
/// <summary>
/// 重写进入事件，处理进入口袋空间（模仿Building_PocketMapExit.OnEntered）
/// </summary>
public override void OnEntered(Pawn pawn)
{
// 通知穿梭机有物品被添加（用于统计和管理）
shuttle?.Notify_ThingAdded(pawn);
// 播放传送音效（如果存在）
if (Find.CurrentMap == shuttle?.Map)
{
// 可以在这里添加音效播放
// def.portal?.traverseSound?.PlayOneShot(this);
}
}
/// <summary>
/// 重写进入按钮文本
/// </summary>
public override string EnterString => "WULA.PocketSpace.Enter".Translate();
/// <summary>
/// 重写进入按钮图标，使用装载按钮的贴图
/// </summary>
protected override Texture2D EnterTex => ContentFinder<Texture2D>.Get("UI/Commands/LoadTransporter");
/// <summary>
/// 获取地图引用（用于Dialog_EnterPortal）
/// </summary>
public new Map Map => shuttle?.Map;
/// <summary>
/// 获取位置引用（用于Dialog_EnterPortal）
/// </summary>
public new IntVec3 Position => shuttle?.Position ?? IntVec3.Invalid;
/// <summary>
/// 获取定义引用（用于Dialog_EnterPortal）
/// </summary>
public new ThingDef def => shuttle?.def;
}
}