暂存

Source/WulaFallenEmpire/CompWulaRitualSpot.cs

@@ -6,16 +6,11 @@ using Verse.AI.Group;
 
 namespace WulaFallenEmpire
 {
-    // NOTE: The PsychicRitualDef_Wula class has been removed as it's no longer needed.
-    // We are now using a DefModExtension for filtering, which is a much cleaner approach.
-
     /// <summary>
-    /// Custom CompProperties for our ritual spot, with a tag.
+    /// Custom CompProperties for our ritual spot. It no longer needs a tag.
     /// </summary>
     public class CompProperties_WulaRitualSpot : CompProperties
     {
-        public string ritualTag;
-
         public CompProperties_WulaRitualSpot()
         {
             this.compClass = typeof(CompWulaRitualSpot);
@@ -24,7 +19,7 @@ namespace WulaFallenEmpire
 
     /// <summary>
     /// The core component for the custom ritual spot. Generates its own gizmos
-    /// by filtering for rituals with a matching tag via a DefModExtension.
+    /// by specifically looking for Defs that inherit from our custom PsychicRitualDef_Wula base class.
     /// </summary>
     public class CompWulaRitualSpot : ThingComp
     {
@@ -37,35 +32,31 @@ namespace WulaFallenEmpire
                 yield return gizmo;
             }
 
-            // Find all rituals that have our custom mod extension and a matching tag
-            foreach (PsychicRitualDef ritualDef in DefDatabase<PsychicRitualDef>.AllDefsListForReading)
+            // Find all rituals that are of our custom base class type.
+            foreach (PsychicRitualDef_Wula ritualDef in DefDatabase<PsychicRitualDef_Wula>.AllDefs)
             {
-                var extension = ritualDef.GetModExtension<RitualTagExtension>();
-                if (extension != null && extension.ritualTag == this.Props.ritualTag)
+                Command_Action command_Action = new Command_Action();
+                command_Action.defaultLabel = ritualDef.LabelCap.Resolve();
+                command_Action.defaultDesc = ritualDef.description;
+                command_Action.icon = ritualDef.uiIcon;
+                command_Action.action = delegate
                 {
-                    Command_Action command_Action = new Command_Action();
-                    command_Action.defaultLabel = ritualDef.LabelCap;
-                    command_Action.defaultDesc = ritualDef.description;
-                    command_Action.icon = ritualDef.uiIcon;
-                    command_Action.action = delegate
-                    {
-                        // Mimic vanilla initialization
-                        TargetInfo target = new TargetInfo(this.parent);
-                        PsychicRitualRoleAssignments assignments = ritualDef.BuildRoleAssignments(target);
-                        PsychicRitualCandidatePool candidatePool = ritualDef.FindCandidatePool();
-                        ritualDef.InitializeCast(this.parent.Map);
-                        Find.WindowStack.Add(new Dialog_BeginPsychicRitual(ritualDef, candidatePool, assignments, this.parent.Map));
-                    };
+                    // Mimic vanilla initialization
+                    TargetInfo target = new TargetInfo(this.parent);
+                    PsychicRitualRoleAssignments assignments = ritualDef.BuildRoleAssignments(target);
+                    PsychicRitualCandidatePool candidatePool = ritualDef.FindCandidatePool();
+                    ritualDef.InitializeCast(this.parent.Map);
+                    Find.WindowStack.Add(new Dialog_BeginPsychicRitual(ritualDef, candidatePool, assignments, this.parent.Map));
+                };
 
-                    // Corrected check for cooldown and other requirements
-                    AcceptanceReport acceptanceReport = Find.PsychicRitualManager.CanInvoke(ritualDef, this.parent.Map);
-                    if (!acceptanceReport.Accepted)
-                    {
-                        command_Action.Disable(acceptanceReport.Reason.CapitalizeFirst());
-                    }
-                    
-                    yield return command_Action;
+                // Corrected check for cooldown and other requirements
+                AcceptanceReport acceptanceReport = Find.PsychicRitualManager.CanInvoke(ritualDef, this.parent.Map);
+                if (!acceptanceReport.Accepted)
+                {
+                    command_Action.Disable(acceptanceReport.Reason.CapitalizeFirst());
                 }
+                
+                yield return command_Action;
             }
         }
     }

Source/WulaFallenEmpire/HarmonyPatches/Patch_JobGiver_GatherOfferingsForPsychicRitual.cs

@@ -0,0 +1,82 @@
+using HarmonyLib;
+using RimWorld;
+using Verse;
+using Verse.AI;
+using Verse.AI.Group;
+using UnityEngine;
+
+namespace WulaFallenEmpire.HarmonyPatches
+{
+    [HarmonyPatch(typeof(JobGiver_GatherOfferingsForPsychicRitual), "TryGiveJob")]
+    public static class Patch_JobGiver_GatherOfferingsForPsychicRitual_TryGiveJob
+    {
+        [HarmonyPrefix]
+        public static bool Prefix(Pawn pawn, ref Job __result)
+        {
+            Lord lord = pawn.GetLord();
+            if (lord == null)
+            {
+                return true; // Continue to original method
+            }
+
+            if (!(lord.CurLordToil is LordToil_PsychicRitual lordToil_PsychicRitual))
+            {
+                return true; // Continue to original method
+            }
+
+            var ritualDef = lordToil_PsychicRitual.RitualData.psychicRitual.def as PsychicRitualDef_WulaBase;
+            if (ritualDef == null)
+            {
+                return true; // Not our custom ritual, continue to original method
+            }
+
+            if (ritualDef.RequiredOffering == null)
+            {
+                __result = null;
+                return false; // Stop original method
+            }
+
+            PsychicRitual psychicRitual = lordToil_PsychicRitual.RitualData.psychicRitual;
+            PsychicRitualRoleDef psychicRitualRoleDef = psychicRitual.assignments.RoleForPawn(pawn);
+            if (psychicRitualRoleDef == null)
+            {
+                __result = null;
+                return false; // Stop original method
+            }
+
+            float num = PsychicRitualToil_GatherOfferings.PawnsOfferingCount(psychicRitual.assignments.AssignedPawns(psychicRitualRoleDef), ritualDef.RequiredOffering);
+            int needed = Mathf.CeilToInt(ritualDef.RequiredOffering.GetBaseCount() - num);
+            if (needed == 0)
+            {
+                __result = null;
+                return false; // Stop original method
+            }
+
+            Thing thing2 = GenClosest.ClosestThingReachable(pawn.PositionHeld, pawn.MapHeld, ThingRequest.ForGroup(ThingRequestGroup.HaulableAlways), PathEndMode.Touch, TraverseParms.For(pawn), 9999f, delegate (Thing thing)
+            {
+                if (!ritualDef.RequiredOffering.filter.Allows(thing))
+                {
+                    return false;
+                }
+                if (thing.IsForbidden(pawn))
+                {
+                    return false;
+                }
+                int stackCount = Mathf.Min(needed, thing.stackCount);
+                return pawn.CanReserve(thing, 10, stackCount);
+            });
+
+            if (thing2 == null)
+            {
+                __result = null;
+                return false; // Stop original method
+            }
+
+            Job job = JobMaker.MakeJob(JobDefOf.TakeCountToInventory, thing2);
+            job.count = Mathf.Min(needed, thing2.stackCount);
+            __result = job;
+            
+            return false; // Stop original method, we've provided the result
+        }
+    }
+}

Source/WulaFallenEmpire/HarmonyPatches/Patch_PsychicRitualGizmo_VisibleRituals.cs

@@ -1,30 +0,0 @@
-using System.Collections.Generic;
-using System.Linq;
-using HarmonyLib;
-using Verse;
-using RimWorld;
-
-namespace WulaFallenEmpire.HarmonyPatches
-{
-    [HarmonyPatch(typeof(PsychicRitualGizmo), "VisibleRituals")]
-    public static class Patch_PsychicRitualGizmo_VisibleRituals
-    {
-        [HarmonyPostfix]
-        public static List<PsychicRitualDef_InvocationCircle> Postfix(List<PsychicRitualDef_InvocationCircle> __result)
-        {
-            if (__result == null || __result.Count == 0)
-            {
-                return __result;
-            }
-
-            // Create a new list containing only the rituals that DO NOT have our custom tag.
-            // This is a more robust way to ensure our custom rituals are filtered out.
-            return __result.Where(ritualDef =>
-            {
-                var extension = ritualDef.GetModExtension<RitualTagExtension>();
-                // Keep the ritual if it has no extension, or if the extension tag is null/empty.
-                return extension == null || string.IsNullOrEmpty(extension.ritualTag);
-            }).ToList();
-        }
-    }
-}

Source/WulaFallenEmpire/PsychicRitualDef_AddHediff.cs

@@ -5,7 +5,7 @@ using RimWorld;
 
 namespace WulaFallenEmpire
 {
-    public class PsychicRitualDef_AddHediff : PsychicRitualDef_InvocationCircle
+    public class PsychicRitualDef_AddHediff : PsychicRitualDef_Wula
     {
         public HediffDef hediff;
 

Source/WulaFallenEmpire/PsychicRitualDef_Wula.cs

@@ -0,0 +1,16 @@
+using RimWorld;
+
+namespace WulaFallenEmpire
+{
+    /// <summary>
+    /// This class serves as a custom base for all Wula rituals.
+    /// It inherits from PsychicRitualDef_InvocationCircle to retain all vanilla functionality,
+    /// but provides a unique type that our custom CompWulaRitualSpot can specifically look for,
+    /// ensuring these rituals only appear on our custom ritual spot.
+    /// </summary>
+    public class PsychicRitualDef_Wula : PsychicRitualDef_WulaBase
+    {
+        // This class can be expanded with Wula-specific ritual properties if needed in the future.
+        // For now, its existence is enough to separate our rituals from the vanilla ones.
+    }
+}

Source/WulaFallenEmpire/PsychicRitualDef_WulaBase.cs

@@ -0,0 +1,372 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using RimWorld;
+using UnityEngine;
+using Verse;
+using Verse.AI.Group;
+using Verse.AI;
+
+namespace WulaFallenEmpire
+{
+    public class PsychicRitualDef_WulaBase : PsychicRitualDef
+    {
+        public enum InvalidTargetReasonEnum
+        {
+            None,
+            AreaNotClear
+        }
+
+        private class RitualQualityOffsetCount
+        {
+            public float offset;
+            public int count;
+
+            public RitualQualityOffsetCount(int count, float offset)
+            {
+                this.count = count;
+                this.offset = offset;
+            }
+        }
+
+        public FloatRange hoursUntilHoraxEffect;
+        public FloatRange hoursUntilOutcome;
+        public float invocationCircleRadius = 3.9f;
+        [MustTranslate]
+        public string outcomeDescription;
+        public float psychicSensitivityPowerFactor = 0.25f;
+        protected PsychicRitualRoleDef invokerRole;
+        protected PsychicRitualRoleDef chanterRole;
+        protected PsychicRitualRoleDef targetRole;
+        protected PsychicRitualRoleDef defenderRole;
+        protected IngredientCount requiredOffering;
+        protected string timeAndOfferingLabelCached;
+
+        public static readonly SimpleCurve PsychicSensitivityToPowerFactor = new SimpleCurve
+        {
+            new CurvePoint(0f, 0f),
+            new CurvePoint(1f, 0.5f),
+            new CurvePoint(2f, 0.9f),
+            new CurvePoint(3f, 1f)
+        };
+
+        protected const int DurationTicksWaitPostEffect = 120;
+        private static Dictionary<PsychicRitualRoleDef, List<IntVec3>> tmpParticipants = new Dictionary<PsychicRitualRoleDef, List<IntVec3>>(8);
+        private List<Pawn> tmpGatheringPawns = new List<Pawn>(8);
+
+        public virtual PsychicRitualRoleDef InvokerRole => invokerRole;
+        public virtual PsychicRitualRoleDef ChanterRole => chanterRole;
+        public virtual PsychicRitualRoleDef TargetRole => targetRole;
+        public virtual PsychicRitualRoleDef DefenderRole => defenderRole;
+        public virtual IngredientCount RequiredOffering => requiredOffering;
+        public TaggedString CooldownLabel => "PsychicRitualCooldownLabel".Translate() + ": " + (cooldownHours * 2500).ToStringTicksToPeriod();
+
+        public override List<PsychicRitualRoleDef> Roles
+        {
+            get
+            {
+                List<PsychicRitualRoleDef> roles = base.Roles;
+                if (InvokerRole != null) roles.Add(InvokerRole);
+                if (TargetRole != null) roles.Add(TargetRole);
+                if (ChanterRole != null) roles.Add(ChanterRole);
+                if (DefenderRole != null) roles.Add(DefenderRole);
+                return roles;
+            }
+        }
+
+        public override void ResolveReferences()
+        {
+            base.ResolveReferences();
+            requiredOffering?.ResolveReferences();
+            invokerRole = invokerRole ?? PsychicRitualRoleDefOf.Invoker;
+            chanterRole = chanterRole ?? PsychicRitualRoleDefOf.Chanter;
+        }
+
+        public override List<PsychicRitualToil> CreateToils(PsychicRitual psychicRitual, PsychicRitualGraph parent)
+        {
+            float randomInRange = hoursUntilOutcome.RandomInRange;
+            IReadOnlyDictionary<PsychicRitualRoleDef, List<IntVec3>> readOnlyDictionary = GenerateRolePositions(psychicRitual.assignments);
+            return new List<PsychicRitualToil>
+            {
+                new PsychicRitualToil_GatherForInvocation_Wula(psychicRitual, this, readOnlyDictionary),
+                new PsychicRitualToil_InvokeHorax(InvokerRole, readOnlyDictionary.TryGetValue(InvokerRole), TargetRole, readOnlyDictionary.TryGetValue(TargetRole), ChanterRole, readOnlyDictionary.TryGetValue(ChanterRole), DefenderRole, readOnlyDictionary.TryGetValue(DefenderRole), RequiredOffering)
+                {
+                    hoursUntilHoraxEffect = hoursUntilHoraxEffect.RandomInRange,
+                    hoursUntilOutcome = randomInRange
+                },
+                new PsychicRitualToil_Wait(120)
+            };
+        }
+
+        public override bool IsValidTarget(TargetInfo target, out AnyEnum reason)
+        {
+            foreach (IntVec3 item in GenRadial.RadialCellsAround(target.Cell, invocationCircleRadius, useCenter: true))
+            {
+                if (!item.Standable(target.Map))
+                {
+                    reason = AnyEnum.FromEnum(InvalidTargetReasonEnum.AreaNotClear);
+                    return false;
+                }
+            }
+            reason = AnyEnum.None;
+            return true;
+        }
+
+        public override TaggedString InvalidTargetReason(AnyEnum reason)
+        {
+            InvalidTargetReasonEnum? invalidTargetReasonEnum = reason.As<InvalidTargetReasonEnum>();
+            if (invalidTargetReasonEnum.HasValue)
+            {
+                InvalidTargetReasonEnum valueOrDefault = invalidTargetReasonEnum.GetValueOrDefault();
+                return valueOrDefault switch
+                {
+                    InvalidTargetReasonEnum.None => TaggedString.Empty,
+                    InvalidTargetReasonEnum.AreaNotClear => "PsychicRitualDef_InvocationCircle_AreaMustBeClear".Translate(),
+                    _ => throw new System.InvalidOperationException($"Unknown reason {valueOrDefault}"),
+                };
+            }
+            return base.InvalidTargetReason(reason);
+        }
+
+        public override TaggedString OutcomeDescription(FloatRange qualityRange, string qualityNumber, PsychicRitualRoleAssignments assignments)
+        {
+            return outcomeDescription.Formatted();
+        }
+
+        public override IEnumerable<TaggedString> OutcomeWarnings(PsychicRitualRoleAssignments assignments)
+        {
+            foreach (Pawn item in assignments.AssignedPawns(TargetRole))
+            {
+                if (item.HomeFaction != null && item.HomeFaction != Faction.OfPlayer && item.HomeFaction.def.humanlikeFaction && !item.HomeFaction.def.PermanentlyHostileTo(FactionDefOf.PlayerColony) && !item.HomeFaction.temporary && !item.HomeFaction.Hidden)
+                {
+                    yield return "PsychicRitualFactionWarning".Translate(item.Named("PAWN"), item.HomeFaction.Named("FACTION")).Colorize(ColoredText.WarningColor);
+                }
+            }
+        }
+
+        public override TaggedString TimeAndOfferingLabel()
+        {
+            if (timeAndOfferingLabelCached != null)
+            {
+                return timeAndOfferingLabelCached;
+            }
+            StringBuilder stringBuilder = new StringBuilder();
+            stringBuilder.AppendLine(DurationLabel());
+            stringBuilder.Append(CooldownLabel);
+            if (!OfferingLabel().NullOrEmpty())
+            {
+                stringBuilder.AppendLine();
+                stringBuilder.Append(OfferingLabel());
+            }
+            timeAndOfferingLabelCached = stringBuilder.ToString();
+            return timeAndOfferingLabelCached;
+        }
+
+        private TaggedString OfferingLabel()
+        {
+            StringBuilder stringBuilder = new StringBuilder();
+            if (RequiredOffering != null)
+            {
+                stringBuilder.Append("PsychicRitualRequiredOffering".Translate().CapitalizeFirst());
+                stringBuilder.Append(": ");
+                stringBuilder.Append(RequiredOffering.SummaryFilterFirst);
+            }
+            return stringBuilder.ToString();
+        }
+
+        public TaggedString DurationLabel()
+        {
+            string value = ((int)(hoursUntilOutcome.Average * 2500f)).ToStringTicksToPeriod();
+            TaggedString taggedString = ((hoursUntilOutcome.min != hoursUntilOutcome.max) ? "ExpectedLordJobDuration".Translate().CapitalizeFirst() : "PsychicRitualExpectedDurationLabel".Translate().CapitalizeFirst());
+            StringBuilder stringBuilder = new StringBuilder();
+            stringBuilder.Append(taggedString);
+            stringBuilder.Append(": ");
+            stringBuilder.Append(value);
+            return stringBuilder.ToString();
+        }
+
+        private IReadOnlyDictionary<PsychicRitualRoleDef, List<IntVec3>> GenerateRolePositions(PsychicRitualRoleAssignments assignments)
+        {
+            tmpParticipants.ClearAndPoolValueLists();
+            foreach (PsychicRitualRoleDef role in Roles)
+            {
+                tmpParticipants[role] = SimplePool<List<IntVec3>>.Get();
+            }
+            int num = assignments.RoleAssignedCount(ChanterRole) + assignments.RoleAssignedCount(InvokerRole);
+            int num2 = 0;
+            foreach (Pawn item in assignments.AssignedPawns(InvokerRole))
+            {
+                _ = item;
+                int num3 = 0;
+                IntVec3 cell;
+                do
+                {
+                    cell = assignments.Target.Cell;
+                    cell += IntVec3.FromPolar(360f * (float)num2++ / (float)num, invocationCircleRadius);
+                }
+                while (!cell.Walkable(assignments.Target.Map) && num3++ <= 10);
+                if (num3 >= 10)
+                {
+                    cell = assignments.Target.Cell;
+                }
+                tmpParticipants[InvokerRole].Add(cell);
+            }
+            foreach (Pawn item2 in assignments.AssignedPawns(ChanterRole))
+            {
+                _ = item2;
+                IntVec3 cell2 = assignments.Target.Cell;
+                cell2 += IntVec3.FromPolar(360f * (float)num2++ / (float)num, invocationCircleRadius);
+                tmpParticipants[ChanterRole].Add(cell2);
+            }
+            foreach (Pawn item3 in assignments.AssignedPawns(TargetRole))
+            {
+                _ = item3;
+                tmpParticipants[TargetRole].Add(assignments.Target.Cell);
+            }
+            if (DefenderRole != null)
+            {
+                num2 = 0;
+                int num4 = assignments.RoleAssignedCount(DefenderRole);
+                bool playerRitual = assignments.AllAssignedPawns.Any((Pawn x) => x.Faction == Faction.OfPlayer);
+                foreach (Pawn item4 in assignments.AssignedPawns(DefenderRole))
+                {
+                    _ = item4;
+                    IntVec3 cell3 = assignments.Target.Cell;
+                    cell3 += IntVec3.FromPolar(360f * (float)num2++ / (float)num4, invocationCircleRadius + 5f);
+                    cell3 = GetBestStandableRolePosition(playerRitual, cell3, assignments.Target.Cell, assignments.Target.Map);
+                    tmpParticipants[DefenderRole].Add(cell3);
+                }
+            }
+            return tmpParticipants;
+        }
+
+        public override IEnumerable<string> BlockingIssues(PsychicRitualRoleAssignments assignments, Map map)
+        {
+            using (new ProfilerBlock("PsychicRitualDef.BlockingIssues"))
+            {
+                tmpGatheringPawns.Clear();
+                foreach (var (psychicRitualRoleDef2, collection) in assignments.RoleAssignments)
+                {
+                    if (psychicRitualRoleDef2.CanHandleOfferings)
+                    {
+                        tmpGatheringPawns.AddRange(collection);
+                    }
+                }
+                tmpGatheringPawns.RemoveAll(map, (Map _map, Pawn _pawn) => _pawn.MapHeld != _map);
+                if (TargetRole != null && InvokerRole != null)
+                {
+                    Pawn pawn = assignments.FirstAssignedPawn(TargetRole);
+                    if (pawn != null)
+                    {
+                        Pawn pawn2 = assignments.FirstAssignedPawn(InvokerRole);
+                        if (pawn2 != null && pawn.IsPrisoner && !map.reachability.CanReach(assignments.Target.Cell, pawn.PositionHeld, PathEndMode.Touch, TraverseParms.For(pawn2)))
+                        {
+                            yield return "PsychicRitualTargetUnreachableByInvoker".Translate(pawn.Named("TARGET"), pawn2.Named("INVOKER"));
+                        }
+                    }
+                }
+                if (RequiredOffering != null && !PsychicRitualDef.OfferingReachable(map, tmpGatheringPawns, RequiredOffering, out var reachableCount))
+                {
+                    yield return "PsychicRitualOfferingsInsufficient".Translate(RequiredOffering.SummaryFilterFirst, reachableCount);
+                }
+            }
+        }
+
+        public override void CalculateMaxPower(PsychicRitualRoleAssignments assignments, List<QualityFactor> powerFactorsOut, out float power)
+        {
+            power = 0f;
+            foreach (Pawn item in assignments.AssignedPawns(InvokerRole))
+            {
+                float statValue = item.GetStatValue(StatDefOf.PsychicSensitivity);
+                float num = PsychicSensitivityToPowerFactor.Evaluate(statValue);
+                num *= psychicSensitivityPowerFactor;
+                powerFactorsOut?.Add(new QualityFactor
+                {
+                    label = "PsychicRitualDef_InvocationCircle_QualityFactor_PsychicSensitivity".Translate(item.Named("PAWN")),
+                    positive = (statValue >= 1f),
+                    count = statValue.ToStringPercent(),
+                    quality = num,
+                    toolTip = "PsychicRitualDef_InvocationCircle_QualityFactor_PsychicSensitivity_Tooltip".Translate(item.Named("PAWN"))
+                });
+                power += num;
+            }
+            base.CalculateMaxPower(assignments, powerFactorsOut, out var power2);
+            power += power2;
+            if (assignments.Target.Thing is Building building)
+            {
+                CalculateFacilityQualityOffset(powerFactorsOut, ref power, building);
+            }
+            power = Mathf.Clamp01(power);
+        }
+
+        private static void CalculateFacilityQualityOffset(List<QualityFactor> powerFactorsOut, ref float power, Building building)
+        {
+            Dictionary<ThingDef, RitualQualityOffsetCount> dictionary = new Dictionary<ThingDef, RitualQualityOffsetCount>();
+            List<Thing> linkedFacilitiesListForReading = building.GetComp<CompAffectedByFacilities>().LinkedFacilitiesListForReading;
+            for (int i = 0; i < linkedFacilitiesListForReading.Count; i++)
+            {
+                Thing thing = linkedFacilitiesListForReading[i];
+                CompFacility compFacility = thing.TryGetComp<CompFacility>();
+                if (compFacility?.StatOffsets == null)
+                {
+                    continue;
+                }
+                for (int j = 0; j < compFacility.StatOffsets.Count; j++)
+                {
+                    StatModifier statModifier = compFacility.StatOffsets[j];
+                    if (statModifier.stat == StatDefOf.PsychicRitualQuality)
+                    {
+                        if (dictionary.TryGetValue(thing.def, out var value))
+                        {
+                            value.count++;
+                            value.offset += statModifier.value;
+                        }
+                        else
+                        {
+                            dictionary.Add(thing.def, new RitualQualityOffsetCount(1, statModifier.value));
+                        }
+                    }
+                }
+            }
+            foreach (KeyValuePair<ThingDef, RitualQualityOffsetCount> item in dictionary)
+            {
+                powerFactorsOut?.Add(new QualityFactor
+                {
+                    label = Find.ActiveLanguageWorker.Pluralize(item.Key.label).CapitalizeFirst(),
+                    positive = true,
+                    count = item.Value.count + " / " + item.Key.GetCompProperties<CompProperties_Facility>().maxSimultaneous,
+                    quality = item.Value.offset,
+                    toolTip = "PsychicRitualDef_InvocationCircle_QualityFactor_Increase_Tooltip".Translate().CapitalizeFirst().EndWithPeriod()
+                });
+                power += item.Value.offset;
+            }
+        }
+
+        public override IEnumerable<StatDrawEntry> SpecialDisplayStats(StatRequest req)
+        {
+            foreach (StatDrawEntry item in base.SpecialDisplayStats(req))
+            {
+                yield return item;
+            }
+            if (requiredOffering != null)
+            {
+                yield return new StatDrawEntry(StatCategoryDefOf.PsychicRituals, "StatsReport_Offering".Translate(), requiredOffering.SummaryFilterFirst, "StatsReport_Offering_Desc".Translate(), 1000);
+            }
+            yield return new StatDrawEntry(StatCategoryDefOf.PsychicRituals, "StatsReport_RitualDuration".Translate(), Mathf.FloorToInt(hoursUntilOutcome.min * 2500f).ToStringTicksToPeriod(), "StatsReport_RitualDuration_Desc".Translate(), 500);
+            yield return new StatDrawEntry(StatCategoryDefOf.PsychicRituals, "StatsReport_RitualCooldown".Translate(), (cooldownHours * 2500).ToStringTicksToPeriod(), "StatsReport_RitualCooldown_Desc".Translate(), 100);
+        }
+
+        public override void CheckPsychicRitualCancelConditions(PsychicRitual psychicRitual)
+        {
+            base.CheckPsychicRitualCancelConditions(psychicRitual);
+            if (!psychicRitual.canceled && invokerRole != null)
+            {
+                Pawn pawn = psychicRitual.assignments.FirstAssignedPawn(InvokerRole);
+                if (pawn != null && pawn.DeadOrDowned)
+                {
+                    psychicRitual.CancelPsychicRitual("PsychicRitualDef_InvocationCircle_InvokerLost".Translate(pawn.Named("PAWN")));
+                }
+            }
+        }
+    }
+}

Source/WulaFallenEmpire/PsychicRitualToil_GatherForInvocation_Wula.cs

@@ -0,0 +1,83 @@
+using System.Collections.Generic;
+using System.Linq;
+using RimWorld;
+using Verse;
+using Verse.AI;
+using Verse.AI.Group;
+
+namespace WulaFallenEmpire
+{
+    public class PsychicRitualToil_GatherForInvocation_Wula : PsychicRitualToil_Multiplex
+    {
+        protected PsychicRitualToil_Goto fallbackToil;
+        protected PsychicRitualGraph invokerToil;
+        protected PsychicRitualToil_Goto invokerFinalToil;
+        private static List<Pawn> blockingPawns = new List<Pawn>(16);
+
+        protected PsychicRitualToil_GatherForInvocation_Wula() { }
+
+        protected PsychicRitualToil_GatherForInvocation_Wula(PsychicRitualDef_WulaBase def, PsychicRitualToil_Goto fallbackToil, PsychicRitualGraph invokerToil)
+            : base(new Dictionary<PsychicRitualRoleDef, PsychicRitualToil> { { def.InvokerRole, invokerToil } }, fallbackToil)
+        {
+            this.fallbackToil = fallbackToil;
+            this.invokerToil = invokerToil;
+            invokerFinalToil = (PsychicRitualToil_Goto)invokerToil.GetToil(invokerToil.ToilCount - 1);
+        }
+
+        public PsychicRitualToil_GatherForInvocation_Wula(PsychicRitual psychicRitual, PsychicRitualDef_WulaBase def, IReadOnlyDictionary<PsychicRitualRoleDef, List<IntVec3>> rolePositions)
+            : this(def, FallbackToil(psychicRitual, def, rolePositions), InvokerToil(def, rolePositions))
+        {
+        }
+
+        public override void ExposeData()
+        {
+            base.ExposeData();
+            Scribe_References.Look(ref fallbackToil, "fallbackToil");
+            Scribe_References.Look(ref invokerToil, "invokerToil");
+            Scribe_References.Look(ref invokerFinalToil, "invokerFinalToil");
+        }
+
+        public override string GetReport(PsychicRitual psychicRitual, PsychicRitualGraph parent)
+        {
+            blockingPawns.Clear();
+            blockingPawns.AddRange(fallbackToil.BlockingPawns);
+            if (invokerToil.CurrentToil == invokerFinalToil)
+            {
+                blockingPawns.AddRange(invokerFinalToil.BlockingPawns);
+            }
+            else
+            {
+                blockingPawns.AddRange(invokerFinalToil.ControlledPawns(psychicRitual));
+            }
+            string text = "PsychicRitualToil_GatherForInvocation_Report".Translate();
+            string text2 = blockingPawns.Select((Pawn pawn) => pawn.LabelShortCap).ToCommaList();
+            return text + ": " + text2;
+        }
+
+        public static PsychicRitualToil_Goto FallbackToil(PsychicRitual psychicRitual, PsychicRitualDef_WulaBase def, IReadOnlyDictionary<PsychicRitualRoleDef, List<IntVec3>> rolePositions)
+        {
+            return new PsychicRitualToil_Goto(rolePositions.Slice(rolePositions.Keys.Except(def.InvokerRole)));
+        }
+
+        public static PsychicRitualGraph InvokerToil(PsychicRitualDef_WulaBase def, IReadOnlyDictionary<PsychicRitualRoleDef, List<IntVec3>> rolePositions)
+        {
+            return new PsychicRitualGraph(InvokerGatherPhaseToils(def, rolePositions))
+            {
+                willAdvancePastLastToil = false
+            };
+        }
+
+        public static IEnumerable<PsychicRitualToil> InvokerGatherPhaseToils(PsychicRitualDef_WulaBase def, IReadOnlyDictionary<PsychicRitualRoleDef, List<IntVec3>> rolePositions)
+        {
+            if (def.RequiredOffering != null)
+            {
+                yield return new PsychicRitualToil_GatherOfferings(def.InvokerRole, def.RequiredOffering);
+            }
+            if (def.TargetRole != null)
+            {
+                yield return new PsychicRitualToil_CarryAndGoto(def.InvokerRole, def.TargetRole, rolePositions);
+            }
+            yield return new PsychicRitualToil_Goto(rolePositions.Slice(def.InvokerRole));
+        }
+    }
+}

Source/WulaFallenEmpire/PsychicRitual_TechOffering.cs

@@ -19,7 +19,7 @@ namespace WulaFallenEmpire
         public QualityCategory quality;
     }
 
-    public class PsychicRitual_TechOffering : PsychicRitualDef_InvocationCircle
+    public class PsychicRitual_TechOffering : PsychicRitualDef_Wula
     {
         // 从XML加载的额外祭品列表
         public List<OfferingItem> extraOfferings = new List<OfferingItem>();

Source/WulaFallenEmpire/WulaFallenEmpire.csproj

@@ -12,6 +12,7 @@
     <TargetFrameworkVersion>v4.7.2</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <Deterministic>true</Deterministic>
+    <LangVersion>8.0</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>false</DebugSymbols>
@@ -91,6 +92,7 @@
     <Compile Include="HarmonyPatches\FloatMenuOptionProvider_Ingest_Patch.cs" />
     <Compile Include="HarmonyPatches\MechanitorUtility_InMechanitorCommandRange_Patch.cs" />
     <Compile Include="HarmonyPatches\Projectile_Launch_Patch.cs" />
+    <Compile Include="HarmonyPatches\Patch_JobGiver_GatherOfferingsForPsychicRitual.cs" />
     <Compile Include="HediffComp_RegenerateBackstory.cs" />
     <Compile Include="HediffComp_WulaCharging.cs" />
     <Compile Include="IngestPatch.cs" />
@@ -110,6 +112,9 @@
     <Compile Include="PsychicRitualDef_AddHediff.cs" />
     <Compile Include="PsychicRitualToil_AddHediff.cs" />
     <Compile Include="RitualTagExtension.cs" />
+    <Compile Include="PsychicRitualDef_Wula.cs" />
+    <Compile Include="PsychicRitualDef_WulaBase.cs" />
+    <Compile Include="PsychicRitualToil_GatherForInvocation_Wula.cs" />
     <Compile Include="Recipe_AdministerWulaMechRepairKit.cs" />
     <Compile Include="SectionLayer_WulaHull.cs" />
     <Compile Include="ThingDefExtension_EnergySource.cs" />