根据向量相似度分析，与 'BiosculpterPod, ThingDef' 最相关的代码定义如下：

---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\CompProperties_BiosculpterPod_BaseCycle.txt`
**相似度:** 0.7659

```csharp
public abstract class CompProperties_BiosculpterPod_BaseCycle : CompProperties
{
	[NoTranslate]
	public string key;

	[MustTranslate]
	public string label;

	[MustTranslate]
	public string description;

	[NoTranslate]
	public string iconPath;

	public float durationDays;

	public Color operatingColor = new Color(0.5f, 0.7f, 0.5f);

	public ThoughtDef gainThoughtOnCompletion;

	public List<ResearchProjectDef> requiredResearch;

	public List<ThingDefCountClass> extraRequiredIngredients;

	private Texture2D icon;

	public Texture2D Icon
	{
		get
		{
			if (icon == null)
			{
				icon = ContentFinder<Texture2D>.Get(iconPath);
			}
			return icon;
		}
	}

	public string LabelCap => label.CapitalizeFirst();
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\CompBiosculpterPod.txt`
**相似度:** 0.7294

```csharp
public class CompBiosculpterPod : ThingComp, ISuspendableThingHolder, IThingHolder, IThingHolderWithDrawnPawn, IStoreSettingsParent, INotifyHauledTo, ISearchableContents
{
	private const int NoPowerEjectCumulativeTicks = 60000;

	private const int BiotunedDuration = 4800000;

	private const float NutritionRequired = 5f;

	private const float CacheForSecs = 2f;

	private static readonly Texture2D InterruptCycleIcon = ContentFinder<Texture2D>.Get("UI/Designators/Cancel");

	private static readonly Material BackgroundMat = SolidColorMaterials.NewSolidColorMaterial(new Color(0.082f, 0.078f, 0.063f), ShaderDatabase.SolidColorBehind);

	private const float BackgroundRect_YOff = 0.07317074f;

	private const float Pawn_YOff = 0.03658537f;

	private string currentCycleKey;

	private float currentCycleTicksRemaining;

	private int currentCyclePowerCutTicks;

	private ThingOwner innerContainer;

	private Pawn biotunedTo;

	private int biotunedCountdownTicks;

	private StorageSettings allowedNutritionSettings;

	private float liquifiedNutrition;

	public bool autoLoadNutrition = true;

	public bool devFillPodLatch;

	private bool autoAgeReversal;

	private int tickEntered = -99999;

	public Job queuedEnterJob;

	public Pawn queuedPawn;

	private List<ThingCount> chosenExtraItems = new List<ThingCount>();

	private List<FloatMenuOption> cycleEligiblePawnOptions = new List<FloatMenuOption>();

	private Pawn pawnEnteringBiosculpter;

	private Dictionary<CompBiosculpterPod_Cycle, List<IngredientCount>> cachedExtraIngredients = new Dictionary<CompBiosculpterPod_Cycle, List<IngredientCount>>();

	private Dictionary<CompBiosculpterPod_Cycle, CacheAnyPawnEligibleCycle> cachedAnyPawnEligible = new Dictionary<CompBiosculpterPod_Cycle, CacheAnyPawnEligibleCycle>();

	private static Dictionary<Pawn, List<CompBiosculpterPod>> cachedBiotunedPods = new Dictionary<Pawn, List<CompBiosculpterPod>>();

	private Pawn cacheReachIngredientsPawn;

	private CompBiosculpterPod_Cycle cacheReachIngredientsCycle;

	private float cacheReachIngredientsTime = float.MinValue;

	private bool cacheReachIngredientsResult;

	private Effecter progressBarEffecter;

	private Effecter operatingEffecter;

	private Effecter readyEffecter;

	private Texture2D cachedAutoAgeReverseIcon;

	private List<CompBiosculpterPod_Cycle> cachedAvailableCycles;

	private Dictionary<string, CompBiosculpterPod_Cycle> cycleLookup;

	private static string cachedAgeReversalCycleKey = null;

	private List<string> tmpIngredientsStrings = new List<string>();

	private static readonly List<Thing> tmpItems = new List<Thing>();

	private CompPowerTrader powerTraderComp;

	private CompPower powerComp;

	private static List<ThingDef> cachedPodDefs;

	public CompProperties_BiosculpterPod Props => props as CompProperties_BiosculpterPod;

	public ThingOwner SearchableContents => innerContainer;

	public bool IsContentsSuspended => true;

	public float RequiredNutritionRemaining => Mathf.Max(5f - liquifiedNutrition, 0f);

	public bool NutritionLoaded => RequiredNutritionRemaining <= 0f;

	public bool AutoAgeReversal => autoAgeReversal;

	private Texture2D AutoAgeReversalIcon
	{
		get
		{
			if (cachedAutoAgeReverseIcon == null)
			{
				cachedAutoAgeReverseIcon = ContentFinder<Texture2D>.Get("UI/Gizmos/BiosculpterAutoAgeReversal");
			}
			return cachedAutoAgeReverseIcon;
		}
	}

	public BiosculpterPodState State
	{
		get
		{
			if (Occupant != null)
			{
				return BiosculpterPodState.Occupied;
			}
			if (NutritionLoaded)
			{
				return BiosculpterPodState.SelectingCycle;
			}
			return BiosculpterPodState.LoadingNutrition;
		}
	}

	public Pawn Occupant
	{
		get
		{
			if (pawnEnteringBiosculpter != null)
			{
				return pawnEnteringBiosculpter;
			}
			if (currentCycleKey == null)
			{
				return null;
			}
			if (innerContainer.Count != 1)
			{
				return null;
			}
			return innerContainer[0] as Pawn;
		}
	}

	public CompBiosculpterPod_Cycle CurrentCycle
	{
		get
		{
			if (currentCycleKey == null)
			{
				return null;
			}
			foreach (CompBiosculpterPod_Cycle availableCycle in AvailableCycles)
			{
				if (availableCycle.Props.key == currentCycleKey)
				{
					return availableCycle;
				}
			}
			return null;
		}
	}

	public List<CompBiosculpterPod_Cycle> AvailableCycles
	{
		get
		{
			if (cachedAvailableCycles == null)
			{
				SetupCycleCaches();
			}
			return cachedAvailableCycles;
		}
	}

	public string AgeReversalCycleKey
	{
		get
		{
			if (cachedAgeReversalCycleKey == null)
			{
				SetupCycleCaches();
			}
			return cachedAgeReversalCycleKey;
		}
	}

	private float CycleSpeedFactorNoPawn => CleanlinessSpeedFactor * BiotunedSpeedFactor;

	public float CycleSpeedFactor
	{
		get
		{
			if (Occupant == null)
			{
				return Mathf.Max(0.1f, CycleSpeedFactorNoPawn);
			}
			return GetCycleSpeedFactorForPawn(Occupant);
		}
	}

	private float CleanlinessSpeedFactor => parent.GetStatValue(StatDefOf.BiosculpterPodSpeedFactor);

	private float BiotunedSpeedFactor
	{
		get
		{
			if (biotunedTo == null)
			{
				return 1f;
			}
			return Props.biotunedCycleSpeedFactor;
		}
	}

	public bool PowerOn => parent.TryGetComp<CompPowerTrader>().PowerOn;

	public float HeldPawnDrawPos_Y => parent.DrawPos.y - 0.03658537f;

	public float HeldPawnBodyAngle => parent.Rotation.Opposite.AsAngle;

	public PawnPosture HeldPawnPosture => PawnPosture.LayingOnGroundFaceUp;

	public bool StorageTabVisible => true;

	public CompBiosculpterPod()
	{
		innerContainer = new ThingOwner<Thing>(this);
	}

	public override void Initialize(CompProperties props)
	{
		base.Initialize(props);
		allowedNutritionSettings = new StorageSettings(this);
		if (parent.def.building.defaultStorageSettings != null)
		{
			allowedNutritionSettings.CopyFrom(parent.def.building.defaultStorageSettings);
		}
	}

	public override void PostSpawnSetup(bool respawningAfterLoad)
	{
		if (ModLister.CheckIdeology("Biosculpter pod comp"))
		{
			base.PostSpawnSetup(respawningAfterLoad);
		}
	}

	public override void PostExposeData()
	{
		base.PostExposeData();
		Scribe_Deep.Look(ref innerContainer, "innerContainer", this);
		Scribe_Values.Look(ref currentCycleKey, "currentCycleKey");
		Scribe_Values.Look(ref currentCycleTicksRemaining, "currentCycleTicksRemaining", 0f);
		Scribe_Values.Look(ref currentCyclePowerCutTicks, "currentCyclePowerCutTicks", 0);
		Scribe_References.Look(ref biotunedTo, "biotunedTo");
		Scribe_Values.Look(ref biotunedCountdownTicks, "biotunedCountdownTicks", 0);
		Scribe_Deep.Look(ref allowedNutritionSettings, "allowedNutritionSettings");
		Scribe_Values.Look(ref liquifiedNutrition, "liquifiedNutrition", 0f);
		Scribe_Values.Look(ref autoLoadNutrition, "autoLoadNutrition", defaultValue: false);
		Scribe_Values.Look(ref devFillPodLatch, "devFillPodLatch", defaultValue: false);
		Scribe_Values.Look(ref autoAgeReversal, "autoAgeReversal", defaultValue: false);
		Scribe_Values.Look(ref tickEntered, "tickEntered", 0);
		Scribe_References.Look(ref queuedEnterJob, "queuedEnterJob");
		Scribe_References.Look(ref queuedPawn, "queuedPawn");
		if (allowedNutritionSettings == null)
		{
			allowedNutritionSettings = new StorageSettings(this);
			if (parent.def.building.defaultStorageSettings != null)
			{
				allowedNutritionSettings.CopyFrom(parent.def.building.defaultStorageSettings);
			}
		}
		if (Scribe.mode == LoadSaveMode.PostLoadInit)
		{
			if (currentCycleKey == "healing")
			{
				currentCycleKey = "medic";
			}
			if (biotunedTo != null)
			{
				SetBiotuned(biotunedTo);
			}
			LiquifyNutrition();
		}
	}

	public CompBiosculpterPod_Cycle GetCycle(string key)
	{
		if (cycleLookup == null)
		{
			SetupCycleCaches();
		}
		return cycleLookup[key];
	}

	public float GetCycleSpeedFactorForPawn(Pawn p)
	{
		return Mathf.Max(0.1f, CycleSpeedFactorNoPawn * p.GetStatValue(StatDefOf.BiosculpterOccupantSpeed));
	}

	private void SetupCycleCaches()
	{
		cachedAvailableCycles = new List<CompBiosculpterPod_Cycle>();
		cachedAvailableCycles.AddRange(parent.AllComps.OfType<CompBiosculpterPod_Cycle>());
		cycleLookup = new Dictionary<string, CompBiosculpterPod_Cycle>();
		foreach (CompBiosculpterPod_Cycle cachedAvailableCycle in cachedAvailableCycles)
		{
			if (cachedAvailableCycle is CompBiosculpterPod_AgeReversalCycle compBiosculpterPod_AgeReversalCycle)
			{
				cachedAgeReversalCycleKey = compBiosculpterPod_AgeReversalCycle.Props.key;
			}
			cycleLookup[cachedAvailableCycle.Props.key] = cachedAvailableCycle;
		}
	}

	public void SetBiotuned(Pawn newBiotunedTo)
	{
		if (newBiotunedTo != biotunedTo)
		{
			autoAgeReversal = false;
		}
		if (biotunedTo != null && cachedBiotunedPods.ContainsKey(biotunedTo))
		{
			cachedBiotunedPods[biotunedTo].Remove(this);
		}
		if (newBiotunedTo != null && !cachedBiotunedPods.ContainsKey(newBiotunedTo))
		{
			cachedBiotunedPods[newBiotunedTo] = new List<CompBiosculpterPod>();
		}
		if (newBiotunedTo != null && !cachedBiotunedPods[newBiotunedTo].Contains(this))
		{
			cachedBiotunedPods[newBiotunedTo].Add(this);
		}
		if (newBiotunedTo != null && newBiotunedTo != biotunedTo)
		{
			biotunedCountdownTicks = 4800000;
		}
		biotunedTo = newBiotunedTo;
	}

	public override void PostDestroy(DestroyMode mode, Map previousMap)
	{
		SetBiotuned(null);
		if (mode == DestroyMode.Deconstruct || mode == DestroyMode.KillFinalize)
		{
			EjectContents(interrupted: true, playSounds: false, previousMap);
		}
		innerContainer.ClearAndDestroyContents();
		base.PostDestroy(mode, previousMap);
	}

	public override void PostDeSpawn(Map map, DestroyMode mode = DestroyMode.Vanish)
	{
		if (mode != DestroyMode.WillReplace)
		{
			EjectContents(interrupted: true, playSounds: false, map);
			currentCycleKey = null;
		}
		progressBarEffecter?.Cleanup();
		progressBarEffecter = null;
		operatingEffecter?.Cleanup();
		operatingEffecter = null;
		readyEffecter?.Cleanup();
		readyEffecter = null;
	}

	public override void DrawGUIOverlay()
	{
		base.DrawGUIOverlay();
		if (!Find.ScreenshotModeHandler.Active && (biotunedTo != null || Occupant != null))
		{
			GenMapUI.DrawThingLabel(parent, biotunedTo?.LabelShort ?? Occupant.LabelShort, GenMapUI.DefaultThingLabelColor);
		}
	}

	public override string CompInspectStringExtra()
	{
		StringBuilder stringBuilder = new StringBuilder();
		BiosculpterPodState state = State;
		if (parent.Spawned)
		{
			CompBiosculpterPod_Cycle currentCycle = CurrentCycle;
			if (currentCycle != null)
			{
				stringBuilder.AppendLineIfNotEmpty().Append("BiosculpterPodCycleLabel".Translate()).Append(": ")
					.Append(currentCycle.Props.LabelCap);
				if (biotunedTo == null)
				{
					stringBuilder.Append(" " + "BiosculpterPodCycleWillBiotune".Translate());
				}
			}
			else if (state == BiosculpterPodState.SelectingCycle)
			{
				if (PowerOn)
				{
					if (queuedEnterJob != null && !queuedEnterJob.biosculpterCycleKey.NullOrEmpty())
					{
						stringBuilder.Append("BiosculpterPodCycleStandby".Translate(GetCycle(queuedEnterJob.biosculpterCycleKey).Props.label.Named("CYCLE"), queuedPawn.Named("PAWN")));
					}
					else
					{
						stringBuilder.Append("BiosculpterPodCycleSelection".Translate().CapitalizeFirst());
					}
				}
				else
				{
					stringBuilder.Append("BiosculpterPodCycleSelectionNoPower".Translate().CapitalizeFirst());
				}
			}
			if (state == BiosculpterPodState.LoadingNutrition)
			{
				stringBuilder.Append("BiosculpterPodCycleLabelLoading".Translate().CapitalizeFirst());
				stringBuilder.AppendLineIfNotEmpty().Append("Nutrition".Translate()).Append(": ")
					.Append(liquifiedNutrition.ToStringByStyle(ToStringStyle.FloatMaxOne))
					.Append(" / ")
					.Append(5f);
			}
			if (state == BiosculpterPodState.Occupied)
			{
				float num = currentCycleTicksRemaining / CycleSpeedFactor;
				stringBuilder.AppendLineIfNotEmpty().Append("Contains".Translate()).Append(": ")
					.Append(Occupant.NameShortColored.Resolve());
				if (!PowerOn)
				{
					stringBuilder.AppendLine().Append("BiosculpterCycleNoPowerInterrupt".Translate((60000 - currentCyclePowerCutTicks).ToStringTicksToPeriod().Named("TIME")).Colorize(ColorLibrary.RedReadable));
				}
				stringBuilder.AppendLine().Append("BiosculpterCycleTimeRemaining".Translate()).Append(": ")
					.Append(((int)num).ToStringTicksToPeriod().Colorize(ColoredText.DateTimeColor));
				Ideo ideo = Occupant.Ideo;
				if (ideo != null && ideo.HasPrecept(PreceptDefOf.Biosculpting_Accelerated))
				{
					stringBuilder.Append(" (" + "BiosculpterCycleAccelerated".Translate() + ")");
				}
				if (biotunedTo != null)
				{
					stringBuilder.AppendLine().Append("BiosculpterBiotunedSpeedFactor".Translate()).Append(": ")
						.Append(BiotunedSpeedFactor.ToStringPercent());
				}
				stringBuilder.AppendLine().Append("BiosculpterCleanlinessSpeedFactor".Translate()).Append(": ")
					.Append(CleanlinessSpeedFactor.ToStringPercent());
			}
		}
		if (biotunedTo != null && state != BiosculpterPodState.Occupied)
		{
			stringBuilder.AppendLineIfNotEmpty().Append("BiosculpterBiotunedTo".Translate()).Append(": ")
				.Append(biotunedTo.LabelShort)
				.Append(" (")
				.Append(biotunedCountdownTicks.ToStringTicksToPeriod())
				.Append(")");
		}
		if (stringBuilder.Length <= 0)
		{
			return null;
		}
		return stringBuilder.ToString();
	}

	public override IEnumerable<Gizmo> CompGetGizmosExtra()
	{
		BiosculpterPodState state = State;
		string cycleIndependentCannotUseReason = CannotUseNowReason();
		foreach (CompBiosculpterPod_Cycle cycle in AvailableCycles)
		{
			string text = cycleIndependentCannotUseReason ?? CannotUseNowCycleReason(cycle);
			Command_Action command_Action = new Command_Action();
			command_Action.defaultLabel = "BiosculpterPodCycleCommand".Translate(cycle.Props.label) + ((biotunedTo != null) ? (" (" + biotunedTo.LabelShort + ")") : "");
			command_Action.defaultDesc = CycleDescription(cycle);
			command_Action.icon = cycle.Props.Icon;
			command_Action.action = delegate
			{
				SelectPawnsForCycleOptions(cycle, out var options2);
				if (biotunedTo != null && options2.Count > 0)
				{
					options2[0].action();
					if (!(cycle is CompBiosculpterPod_HealingCycle))
					{
						Messages.Message("BiosculpterEnteringMessage".Translate(biotunedTo.Named("PAWN"), cycle.Props.label.Named("CYCLE")).CapitalizeFirst(), parent, MessageTypeDefOf.SilentInput, historical: false);
					}
				}
				else
				{
					Find.WindowStack.Add(new FloatMenu(options2));
				}
			};
			command_Action.activateSound = SoundDefOf.Tick_Tiny;
			command_Action.Disabled = text != null;
			List<FloatMenuOption> options;
			if (text != null)
			{
				command_Action.Disable(text);
			}
			else if (!SelectPawnsForCycleOptions(cycle, out options, shortCircuit: true))
			{
				command_Action.Disable((biotunedTo != null) ? "BiosculpterNoEligiblePawnsBiotuned".Translate(biotunedTo.Named("PAWN")) : "BiosculpterNoEligiblePawns".Translate());
			}
			yield return command_Action;
		}
		if (state == BiosculpterPodState.Occupied)
		{
			Command_Action command_Action2 = new Command_Action();
			command_Action2.defaultLabel = "BiosculpterInteruptCycle".Translate();
			command_Action2.defaultDesc = "BiosculpterInteruptCycleDesc".Translate();
			command_Action2.icon = InterruptCycleIcon;
			command_Action2.action = delegate
			{
				EjectContents(interrupted: true, playSounds: true);
			};
			command_Action2.activateSound = SoundDefOf.Designate_Cancel;
			yield return command_Action2;
		}
		Command_Toggle command_Toggle = new Command_Toggle();
		command_Toggle.defaultLabel = "BiosculpterAutoLoadNutritionLabel".Translate();
		command_Toggle.defaultDesc = "BiosculpterAutoLoadNutritionDescription".Translate();
		command_Toggle.icon = (autoLoadNutrition ? TexCommand.ForbidOff : TexCommand.ForbidOn);
		command_Toggle.isActive = () => autoLoadNutrition;
		command_Toggle.toggleAction = delegate
		{
			autoLoadNutrition = !autoLoadNutrition;
		};
		yield return command_Toggle;
		if ((biotunedTo?.Ideo?.HasPrecept(PreceptDefOf.AgeReversal_Demanded)).GetValueOrDefault())
		{
			Command_Toggle command_Toggle2 = new Command_Toggle();
			command_Toggle2.defaultLabel = "BiosculpterAutoAgeReversalLabel".Translate(biotunedTo.Named("PAWN"));
			TaggedString taggedString = ((biotunedTo.ageTracker.AgeReversalDemandedDeadlineTicks > 0) ? "BiosculpterAutoAgeReversalDescriptionFuture".Translate(biotunedTo.Named("PAWN"), ((int)biotunedTo.ageTracker.AgeReversalDemandedDeadlineTicks).ToStringTicksToPeriodVague().Named("TIME")) : "BiosculpterAutoAgeReversalDescriptionNow".Translate(biotunedTo.Named("PAWN")));
			command_Toggle2.defaultDesc = "BiosculpterAutoAgeReversalDescription".Translate(biotunedTo.Named("PAWN"), taggedString.Named("NEXTTREATMENT"));
			command_Toggle2.icon = AutoAgeReversalIcon;
			command_Toggle2.isActive = () => AutoAgeReversal;
			command_Toggle2.toggleAction = delegate
			{
				autoAgeReversal = !autoAgeReversal;
			};
			if (!CanAgeReverse(biotunedTo))
			{
				command_Toggle2.Disable("UnderMinBiosculpterAgeReversalAge".Translate(biotunedTo.ageTracker.AdultMinAge.Named("ADULTAGE")).CapitalizeFirst());
				autoAgeReversal = false;
			}
			yield return command_Toggle2;
		}
		foreach (Gizmo item in StorageSettingsClipboard.CopyPasteGizmosFor(allowedNutritionSettings))
		{
			yield return item;
		}
		Gizmo gizmo = Building.SelectContainedItemGizmo(parent, Occupant);
		if (gizmo != null)
		{
			yield return gizmo;
		}
		if (DebugSettings.ShowDevGizmos)
		{
			yield return new Command_Action
			{
				defaultLabel = "DEV: complete cycle",
				action = delegate
				{
					currentCycleTicksRemaining = 10f;
				},
				Disabled = (State != BiosculpterPodState.Occupied)
			};
			yield return new Command_Action
			{
				defaultLabel = "DEV: advance cycle +1 day",
				action = delegate
				{
					currentCycleTicksRemaining -= 60000f;
				},
				Disabled = (State != BiosculpterPodState.Occupied)
			};
			yield return new Command_Action
			{
				defaultLabel = "DEV: complete biotune timer",
				action = delegate
				{
					biotunedCountdownTicks = 10;
				},
				Disabled = (biotunedCountdownTicks <= 0)
			};
			yield return new Command_Action
			{
				defaultLabel = "DEV: fill nutrition and cycle ingredients",
				action = delegate
				{
					liquifiedNutrition = 5f;
					devFillPodLatch = true;
				},
				Disabled = (State == BiosculpterPodState.Occupied || (devFillPodLatch && liquifiedNutrition == 5f))
			};
		}
	}

	private string IngredientsDescription(CompBiosculpterPod_Cycle cycle)
	{
		tmpIngredientsStrings.Clear();
		if (!cycle.Props.extraRequiredIngredients.NullOrEmpty() && !devFillPodLatch)
		{
			for (int i = 0; i < cycle.Props.extraRequiredIngredients.Count; i++)
			{
				tmpIngredientsStrings.Add(cycle.Props.extraRequiredIngredients[i].Summary);
			}
		}
		return tmpIngredientsStrings.ToCommaList(useAnd: true);
	}

	private string CycleDescription(CompBiosculpterPod_Cycle cycle)
	{
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.Append(cycle.Description(biotunedTo));
		float num = cycle.Props.durationDays / CycleSpeedFactor;
		float num2 = num / PreceptDefOf.Biosculpting_Accelerated.biosculpterPodCycleSpeedFactor;
		stringBuilder.AppendLine("\n\n" + "BiosculpterPodCycleDuration".Translate() + ": " + ((int)(num * 60000f)).ToStringTicksToDays());
		if (!Find.IdeoManager.classicMode)
		{
			stringBuilder.Append("BiosculpterPodCycleDurationTranshumanists".Translate() + ": " + ((int)(num2 * 60000f)).ToStringTicksToDays());
		}
		return stringBuilder.ToString();
	}

	public bool PawnCanUseNow(Pawn pawn, CompBiosculpterPod_Cycle cycle)
	{
		return (CannotUseNowReason() ?? CannotUseNowPawnReason(pawn) ?? CannotUseNowCycleReason(cycle) ?? CannotUseNowPawnCycleReason(pawn, cycle)) == null;
	}

	public override IEnumerable<FloatMenuOption> CompFloatMenuOptions(Pawn selPawn)
	{
		if (selPawn.IsQuestLodger())
		{
			yield return new FloatMenuOption("CannotEnter".Translate() + ": " + "CryptosleepCasketGuestsNotAllowed".Translate().CapitalizeFirst(), null);
			yield break;
		}
		string cycleIndependentfailureReason = CannotUseNowReason() ?? CannotUseNowPawnReason(selPawn);
		foreach (CompBiosculpterPod_Cycle cycle in AvailableCycles)
		{
			string text = cycleIndependentfailureReason ?? CannotUseNowCycleReason(cycle) ?? CannotUseNowPawnCycleReason(selPawn, cycle);
			if (text != null)
			{
				yield return new FloatMenuOption(CannotStartText(cycle, text), null);
				continue;
			}
			string label = "EnterBiosculpterPod".Translate(cycle.Props.label, ((int)(cycle.Props.durationDays / GetCycleSpeedFactorForPawn(selPawn) * 60000f)).ToStringTicksToDays());
			yield return FloatMenuUtility.DecoratePrioritizedTask(new FloatMenuOption(label, delegate
			{
				PrepareCycleJob(selPawn, selPawn, cycle, EnterBiosculpterJob());
			}), selPawn, parent);
		}
	}

	public static bool CanAgeReverse(Pawn biosculptee)
	{
		return biosculptee.ageTracker.Adult;
	}

	public static List<CompBiosculpterPod> BiotunedPods(Pawn pawn)
	{
		return cachedBiotunedPods.TryGetValue(pawn);
	}

	public static bool HasBiotunedAutoAgeReversePod(Pawn pawn)
	{
		List<CompBiosculpterPod> list = cachedBiotunedPods.TryGetValue(pawn);
		if (list == null)
		{
			return false;
		}
		foreach (CompBiosculpterPod item in list)
		{
			if (item.AutoAgeReversal)
			{
				return true;
			}
		}
		return false;
	}

	public static string CannotStartText(CompBiosculpterPod_Cycle cycle, string translatedReason)
	{
		return "BiosculpterCannotStartCycle".Translate(cycle.Props.label) + ": " + translatedReason.CapitalizeFirst();
	}

	public string CannotUseNowCycleReason(CompBiosculpterPod_Cycle cycle)
	{
		List<string> list = cycle.MissingResearchLabels();
		if (list.Any())
		{
			return "MissingRequiredResearch".Translate() + " " + list.ToCommaList();
		}
		return null;
	}

	public string CannotUseNowPawnCycleReason(Pawn p, CompBiosculpterPod_Cycle cycle, bool checkIngredients = true)
	{
		return CannotUseNowPawnCycleReason(p, p, cycle, checkIngredients);
	}

	private bool CanReachOrHasIngredients(Pawn hauler, Pawn biosculptee, CompBiosculpterPod_Cycle cycle, bool useCache = false)
	{
		if (!PawnCarryingExtraCycleIngredients(biosculptee, cycle) && (biosculptee == hauler || !PawnCarryingExtraCycleIngredients(hauler, cycle)))
		{
			return CanReachRequiredIngredients(hauler, cycle, useCache);
		}
		return true;
	}

	public string CannotUseNowPawnCycleReason(Pawn hauler, Pawn biosculptee, CompBiosculpterPod_Cycle cycle, bool checkIngredients = true)
	{
		if (AgeReversalCycleKey != null && cycle.Props.key == AgeReversalCycleKey && !CanAgeReverse(biosculptee))
		{
			return "UnderMinBiosculpterAgeReversalAge".Translate(biosculptee.ageTracker.AdultMinAge.Named("ADULTAGE")).CapitalizeFirst();
		}
		if (checkIngredients && !CanReachOrHasIngredients(hauler, biosculptee, cycle, useCache: true))
		{
			return "BiosculpterMissingIngredients".Translate(IngredientsDescription(cycle).Named("INGREDIENTS")).CapitalizeFirst();
		}
		return null;
	}

	public string CannotUseNowPawnReason(Pawn p)
	{
		if (biotunedTo != null && biotunedTo != p)
		{
			return "BiosculpterBiotunedToAnother".Translate().CapitalizeFirst();
		}
		if (!p.CanReach(parent, PathEndMode.InteractionCell, Danger.Deadly))
		{
			return "NoPath".Translate().CapitalizeFirst();
		}
		return null;
	}

	public string CannotUseNowReason()
	{
		if (!PowerOn)
		{
			return "NoPower".Translate().CapitalizeFirst();
		}
		if (State == BiosculpterPodState.LoadingNutrition)
		{
			return "BiosculpterNutritionNotLoaded".Translate().CapitalizeFirst();
		}
		if (State == BiosculpterPodState.Occupied)
		{
			return "BiosculpterOccupied".Translate().CapitalizeFirst();
		}
		return null;
	}

	private List<IngredientCount> RequiredIngredients(CompBiosculpterPod_Cycle cycle)
	{
		List<ThingDefCountClass> extraRequiredIngredients = cycle.Props.extraRequiredIngredients;
		if (extraRequiredIngredients == null || devFillPodLatch)
		{
			return null;
		}
		if (!cachedExtraIngredients.ContainsKey(cycle))
		{
			cachedExtraIngredients[cycle] = extraRequiredIngredients.Select((ThingDefCountClass tc) => tc.ToIngredientCount()).ToList();
		}
		return cachedExtraIngredients[cycle];
	}

	private bool CanReachRequiredIngredients(Pawn pawn, CompBiosculpterPod_Cycle cycle, bool useCache = false)
	{
		chosenExtraItems.Clear();
		if (cycle.Props.extraRequiredIngredients == null || devFillPodLatch)
		{
			return true;
		}
		float realtimeSinceStartup = Time.realtimeSinceStartup;
		if (useCache && cacheReachIngredientsPawn == pawn && cacheReachIngredientsCycle == cycle && realtimeSinceStartup < cacheReachIngredientsTime + 2f)
		{
			return cacheReachIngredientsResult;
		}
		cacheReachIngredientsPawn = pawn;
		cacheReachIngredientsCycle = cycle;
		cacheReachIngredientsTime = realtimeSinceStartup;
		cacheReachIngredientsResult = WorkGiver_DoBill.TryFindBestFixedIngredients(RequiredIngredients(cycle), pawn, parent, chosenExtraItems);
		return cacheReachIngredientsResult;
	}

	private bool SelectPawnCycleOption(Pawn pawn, CompBiosculpterPod_Cycle cycle, out FloatMenuOption option)
	{
		string text = CannotUseNowPawnReason(pawn) ?? CannotUseNowPawnCycleReason(pawn, cycle, checkIngredients: false);
		string label = pawn.Label + ((text == null) ? "" : (": " + text));
		Action action = null;
		if (text == null)
		{
			action = delegate
			{
				PrepareCycleJob(pawn, pawn, cycle, EnterBiosculpterJob());
			};
		}
		option = new FloatMenuOption(label, action);
		return text == null;
	}

	private bool SelectPawnsForCycleOptions(CompBiosculpterPod_Cycle cycle, out List<FloatMenuOption> options, bool shortCircuit = false)
	{
		cycleEligiblePawnOptions.Clear();
		options = cycleEligiblePawnOptions;
		if (!cachedAnyPawnEligible.ContainsKey(cycle))
		{
			cachedAnyPawnEligible[cycle] = new CacheAnyPawnEligibleCycle
			{
				gameTime = float.MinValue
			};
		}
		int ticksGame = Find.TickManager.TicksGame;
		if (shortCircuit && (float)ticksGame < cachedAnyPawnEligible[cycle].gameTime + 2f)
		{
			return cachedAnyPawnEligible[cycle].anyEligible;
		}
		cachedAnyPawnEligible[cycle].gameTime = ticksGame;
		if (biotunedTo != null)
		{
			if (biotunedTo.Dead || !biotunedTo.Spawned || biotunedTo.Map != parent.Map)
			{
				cachedAnyPawnEligible[cycle].anyEligible = false;
				return cachedAnyPawnEligible[cycle].anyEligible;
			}
			if (SelectPawnCycleOption(biotunedTo, cycle, out var option) && shortCircuit)
			{
				cachedAnyPawnEligible[cycle].anyEligible = true;
				return cachedAnyPawnEligible[cycle].anyEligible;
			}
			cycleEligiblePawnOptions.Add(option);
		}
		else
		{
			foreach (Pawn item in parent.Map.mapPawns.FreeColonistsSpawned)
			{
				if (SelectPawnCycleOption(item, cycle, out var option2) && shortCircuit)
				{
					cachedAnyPawnEligible[cycle].anyEligible = true;
					return cachedAnyPawnEligible[cycle].anyEligible;
				}
				cycleEligiblePawnOptions.Add(option2);
			}
		}
		cachedAnyPawnEligible[cycle].anyEligible = cycleEligiblePawnOptions.Count > 0;
		return cachedAnyPawnEligible[cycle].anyEligible;
	}

	public Job EnterBiosculpterJob()
	{
		return JobMaker.MakeJob(JobDefOf.EnterBiosculpterPod, parent);
	}

	public Job MakeCarryToBiosculpterJob(Pawn willBeCarried)
	{
		return JobMaker.MakeJob(JobDefOf.CarryToBiosculpterPod, willBeCarried, LocalTargetInfo.Invalid, parent);
	}

	public void ConfigureJobForCycle(Job job, CompBiosculpterPod_Cycle cycle, List<ThingCount> extraIngredients)
	{
		if (!extraIngredients.NullOrEmpty())
		{
			job.targetQueueB = new List<LocalTargetInfo>(extraIngredients.Count);
			job.countQueue = new List<int>(extraIngredients.Count);
			foreach (ThingCount extraIngredient in extraIngredients)
			{
				job.targetQueueB.Add(extraIngredient.Thing);
				job.countQueue.Add(extraIngredient.Count);
			}
		}
		job.haulMode = HaulMode.ToCellNonStorage;
		job.biosculpterCycleKey = cycle.Props.key;
	}

	public void PrepareCycleJob(Pawn hauler, Pawn biosculptee, CompBiosculpterPod_Cycle cycle, Job job)
	{
		OrderToPod(cycle, biosculptee, delegate
		{
			chosenExtraItems.Clear();
			if (!CanReachOrHasIngredients(hauler, biosculptee, cycle))
			{
				Messages.Message("BiosculpterMissingIngredients".Translate(IngredientsDescription(cycle).Named("INGREDIENTS")).CapitalizeFirst(), parent, MessageTypeDefOf.NegativeEvent, historical: false);
			}
			else
			{
				ConfigureJobForCycle(job, cycle, chosenExtraItems);
				if (cycle.Props.extraRequiredIngredients != null && !devFillPodLatch)
				{
					if (job.def == JobDefOf.CarryToBiosculpterPod)
					{
						Messages.Message("BiosculpterCarryStartedMessage".Translate(hauler.Named("PAWN"), IngredientsDescription(cycle).Named("INGREDIENTS"), biosculptee.Named("DOWNED"), cycle.Props.label.Named("CYCLE")), parent, MessageTypeDefOf.SilentInput, historical: false);
					}
					else
					{
						Messages.Message("BiosculpterLoadingStartedMessage".Translate(hauler.Named("PAWN"), IngredientsDescription(cycle).Named("INGREDIENTS"), cycle.Props.label.Named("CYCLE")), parent, MessageTypeDefOf.SilentInput, historical: false);
					}
				}
				if (hauler.jobs.TryTakeOrderedJob(job, JobTag.Misc))
				{
					SetQueuedInformation(job, biosculptee);
				}
			}
		});
	}

	public void ClearQueuedInformation()
	{
		SetQueuedInformation(null, null);
	}

	public void SetQueuedInformation(Job job, Pawn biosculptee)
	{
		queuedEnterJob = job;
		queuedPawn = biosculptee;
	}

	public bool CanAcceptNutrition(Thing thing)
	{
		return allowedNutritionSettings.AllowedToAccept(thing);
	}

	public bool CanAcceptOnceCycleChosen(Pawn pawn)
	{
		if (State != BiosculpterPodState.SelectingCycle || !PowerOn)
		{
			return false;
		}
		if (biotunedTo != null && biotunedTo != pawn)
		{
			return false;
		}
		return true;
	}

	public bool PawnCarryingExtraCycleIngredients(Pawn pawn, string cycleKey, bool remove = false)
	{
		return PawnCarryingExtraCycleIngredients(pawn, GetCycle(cycleKey), remove);
	}

	public bool PawnCarryingExtraCycleIngredients(Pawn pawn, CompBiosculpterPod_Cycle cycle, bool remove = false)
	{
		if (cycle.Props.extraRequiredIngredients.NullOrEmpty() || devFillPodLatch)
		{
			return true;
		}
		foreach (ThingDefCountClass extraRequiredIngredient in cycle.Props.extraRequiredIngredients)
		{
			if (pawn.inventory.Count(extraRequiredIngredient.thingDef) < extraRequiredIngredient.count)
			{
				return false;
			}
		}
		if (remove)
		{
			foreach (ThingDefCountClass extraRequiredIngredient2 in cycle.Props.extraRequiredIngredients)
			{
				pawn.inventory.RemoveCount(extraRequiredIngredient2.thingDef, extraRequiredIngredient2.count);
			}
		}
		return true;
	}

	public bool TryAcceptPawn(Pawn pawn, string cycleKey)
	{
		return TryAcceptPawn(pawn, GetCycle(cycleKey));
	}

	public bool TryAcceptPawn(Pawn pawn, CompBiosculpterPod_Cycle cycle)
	{
		if (!CanAcceptOnceCycleChosen(pawn))
		{
			return false;
		}
		if (!PawnCarryingExtraCycleIngredients(pawn, cycle, remove: true))
		{
			return false;
		}
		currentCycleKey = cycle.Props.key;
		innerContainer.ClearAndDestroyContents();
		pawnEnteringBiosculpter = pawn;
		bool num = pawn.DeSpawnOrDeselect();
		if (pawn.holdingOwner != null)
		{
			pawn.holdingOwner.TryTransferToContainer(pawn, innerContainer);
		}
		else
		{
			innerContainer.TryAdd(pawn);
		}
		if (num)
		{
			Find.Selector.Select(pawn, playSound: false, forceDesignatorDeselect: false);
		}
		pawnEnteringBiosculpter = null;
		currentCycleTicksRemaining = cycle.Props.durationDays * 60000f;
		liquifiedNutrition = 0f;
		devFillPodLatch = false;
		ClearQueuedInformation();
		tickEntered = Find.TickManager.TicksGame;
		return true;
	}

	public void EjectContents(bool interrupted, bool playSounds, Map destMap = null)
	{
		if (destMap == null)
		{
			destMap = parent.Map;
		}
		Pawn occupant = Occupant;
		currentCycleKey = null;
		currentCycleTicksRemaining = 0f;
		currentCyclePowerCutTicks = 0;
		liquifiedNutrition = 0f;
		devFillPodLatch = false;
		innerContainer.TryDropAll(parent.InteractionCell, destMap, ThingPlaceMode.Near);
		if (occupant != null)
		{
			FilthMaker.TryMakeFilth(parent.InteractionCell, destMap, ThingDefOf.Filth_PodSlime, new IntRange(3, 6).RandomInRange);
			if (interrupted)
			{
				occupant.needs?.mood.thoughts.memories.TryGainMemory(ThoughtDefOf.SoakingWet);
				occupant.health?.AddHediff(HediffDefOf.BiosculptingSickness);
			}
		}
		if (playSounds)
		{
			Props.exitSound?.PlayOneShot(SoundInfo.InMap(new TargetInfo(parent.Position, parent.Map)));
		}
	}

	private void CycleCompleted()
	{
		Pawn occupant = Occupant;
		CompBiosculpterPod_Cycle currentCycle = CurrentCycle;
		SetBiotuned(occupant);
		currentCycle.CycleCompleted(occupant);
		EjectContents(interrupted: false, playSounds: true);
		if (occupant != null)
		{
			Need_Food need_Food = occupant.needs?.food;
			if (need_Food != null)
			{
				need_Food.CurLevelPercentage = 1f;
			}
			Need_Rest need_Rest = occupant.needs?.rest;
			if (need_Rest != null)
			{
				need_Rest.CurLevelPercentage = 1f;
			}
			if (currentCycle.Props.gainThoughtOnCompletion != null)
			{
				occupant.needs?.mood?.thoughts.memories.TryGainMemory(ThoughtDefOf.AgeReversalReceived);
			}
			Find.HistoryEventsManager.RecordEvent(new HistoryEvent(HistoryEventDefOf.UsedBiosculpterPod, occupant.Named(HistoryEventArgsNames.Doer)));
		}
		if (tickEntered > 0)
		{
			occupant.drugs.Notify_LeftSuspension(Find.TickManager.TicksGame - tickEntered);
		}
	}

	private void LiquifyNutrition()
	{
		tmpItems.AddRange(innerContainer);
		foreach (Thing tmpItem in tmpItems)
		{
			float num = tmpItem.GetStatValue(StatDefOf.Nutrition) * (float)tmpItem.stackCount;
			if (!(num <= 0f) && !(tmpItem is Pawn))
			{
				liquifiedNutrition = Mathf.Min(5f, liquifiedNutrition + num);
				tmpItem.Destroy();
			}
		}
		tmpItems.Clear();
	}

	public override void CompTick()
	{
		if (!ModLister.CheckIdeology("Biosculpting"))
		{
			return;
		}
		base.CompTick();
		if (State != BiosculpterPodState.SelectingCycle || !PowerOn)
		{
			readyEffecter?.Cleanup();
			readyEffecter = null;
		}
		else if (Props.readyEffecter != null)
		{
			if (readyEffecter == null)
			{
				readyEffecter = Props.readyEffecter.Spawn();
				ColorizeEffecter(readyEffecter, Props.selectCycleColor);
				readyEffecter.Trigger(parent, new TargetInfo(parent.InteractionCell, parent.Map));
			}
			readyEffecter.EffectTick(parent, new TargetInfo(parent.InteractionCell, parent.Map));
		}
		if (State != BiosculpterPodState.Occupied)
		{
			progressBarEffecter?.Cleanup();
			progressBarEffecter = null;
			operatingEffecter?.Cleanup();
			operatingEffecter = null;
		}
		else
		{
			Pawn occupant = Occupant;
			biotunedCountdownTicks = 4800000;
			if (PowerOn)
			{
				int num = 1;
				currentCycleTicksRemaining -= (float)num * CycleSpeedFactor;
				if (currentCycleTicksRemaining <= 0f)
				{
					CycleCompleted();
				}
			}
			else
			{
				currentCyclePowerCutTicks++;
				if (currentCyclePowerCutTicks >= 60000)
				{
					EjectContents(interrupted: true, playSounds: true);
					Messages.Message("BiosculpterNoPowerEjectedMessage".Translate(occupant.Named("PAWN")), occupant, MessageTypeDefOf.NegativeEvent, historical: false);
				}
			}
			if (currentCycleTicksRemaining > 0f)
			{
				if (progressBarEffecter == null)
				{
					progressBarEffecter = EffecterDefOf.ProgressBar.Spawn();
				}
				progressBarEffecter.EffectTick(parent, TargetInfo.Invalid);
				MoteProgressBar moteProgressBar = (progressBarEffecter.children[0] as SubEffecter_ProgressBar)?.mote;
				if (moteProgressBar != null)
				{
					float num2 = CurrentCycle.Props.durationDays * 60000f;
					moteProgressBar.progress = 1f - Mathf.Clamp01(currentCycleTicksRemaining / num2);
					int num3 = (parent.RotatedSize.z - 1) / 2;
					moteProgressBar.offsetZ = 0f - ((float)num3 + 0.5f);
				}
				if (Props.operatingEffecter != null)
				{
					if (!PowerOn)
					{
						operatingEffecter?.Cleanup();
						operatingEffecter = null;
					}
					else
					{
						if (operatingEffecter == null)
						{
							operatingEffecter = Props.operatingEffecter.Spawn();
							ColorizeEffecter(operatingEffecter, CurrentCycle.Props.operatingColor);
							operatingEffecter.Trigger(parent, new TargetInfo(parent.InteractionCell, parent.Map));
						}
						operatingEffecter.EffectTick(parent, new TargetInfo(parent.InteractionCell, parent.Map));
					}
				}
			}
		}
		if (PowerOn && biotunedCountdownTicks > 0)
		{
			biotunedCountdownTicks--;
		}
		if (biotunedCountdownTicks <= 0)
		{
			SetBiotuned(null);
		}
		SetPower();
		if (biotunedTo?.Ideo != null && !biotunedTo.Ideo.HasPrecept(PreceptDefOf.AgeReversal_Demanded))
		{
			autoAgeReversal = false;
		}
	}

	private void SetPower()
	{
		if (powerTraderComp == null)
		{
			powerTraderComp = parent.TryGetComp<CompPowerTrader>();
		}
		if (powerComp == null)
		{
			powerComp = parent.TryGetComp<CompPower>();
		}
		if (State == BiosculpterPodState.Occupied)
		{
			powerTraderComp.PowerOutput = 0f - powerComp.Props.PowerConsumption;
		}
		else
		{
			powerTraderComp.PowerOutput = 0f - powerComp.Props.idlePowerDraw;
		}
	}

	private void ColorizeEffecter(Effecter effecter, Color color)
	{
		foreach (SubEffecter child in effecter.children)
		{
			if (child is SubEffecter_Sprayer subEffecter_Sprayer)
			{
				subEffecter_Sprayer.colorOverride = color * child.def.color;
			}
		}
	}

	public override void PostDraw()
	{
		base.PostDraw();
		Rot4 rotation = parent.Rotation;
		Vector3 s = new Vector3(parent.def.graphicData.drawSize.x * 0.8f, 1f, parent.def.graphicData.drawSize.y * 0.8f);
		Vector3 drawPos = parent.DrawPos;
		drawPos.y -= 0.07317074f;
		Graphics.DrawMesh(MeshPool.plane10, Matrix4x4.TRS(drawPos, rotation.AsQuat, s), BackgroundMat, 0);
		if (State == BiosculpterPodState.Occupied)
		{
			Pawn occupant = Occupant;
			Vector3 drawLoc = parent.DrawPos + FloatingOffset(currentCycleTicksRemaining + (float)currentCyclePowerCutTicks);
			Rot4 rotation2 = parent.Rotation;
			if (rotation2 == Rot4.East || rotation2 == Rot4.West)
			{
				drawLoc.z += 0.2f;
			}
			occupant.Drawer.renderer.RenderPawnAt(drawLoc, null, neverAimWeapon: true);
		}
	}

	public static Vector3 FloatingOffset(float tickOffset)
	{
		float num = tickOffset % 500f / 500f;
		float num2 = Mathf.Sin(MathF.PI * num);
		float z = num2 * num2 * 0.04f;
		return new Vector3(0f, 0f, z);
	}

	public void GetChildHolders(List<IThingHolder> outChildren)
	{
		ThingOwnerUtility.AppendThingHoldersFromThings(outChildren, GetDirectlyHeldThings());
	}

	public ThingOwner GetDirectlyHeldThings()
	{
		return innerContainer;
	}

	public StorageSettings GetStoreSettings()
	{
		return allowedNutritionSettings;
	}

	public StorageSettings GetParentStoreSettings()
	{
		return parent.def.building.fixedStorageSettings;
	}

	public void Notify_SettingsChanged()
	{
	}

	private static void OrderToPod(CompBiosculpterPod_Cycle cycle, Pawn pawn, Action giveJobAct)
	{
		if (cycle is CompBiosculpterPod_HealingCycle compBiosculpterPod_HealingCycle)
		{
			string healingDescriptionForPawn = compBiosculpterPod_HealingCycle.GetHealingDescriptionForPawn(pawn);
			string text = (healingDescriptionForPawn.NullOrEmpty() ? "BiosculpterNoCoditionsToHeal".Translate(pawn.Named("PAWN"), compBiosculpterPod_HealingCycle.Props.label.Named("CYCLE")).Resolve() : ("OnCompletionOfCycle".Translate(compBiosculpterPod_HealingCycle.Props.label.Named("CYCLE")).Resolve() + ":\n\n" + healingDescriptionForPawn));
			Find.WindowStack.Add(Dialog_MessageBox.CreateConfirmation(text, giveJobAct, healingDescriptionForPawn.NullOrEmpty()));
		}
		else
		{
			giveJobAct();
		}
	}

	public static Thing FindPodFor(Pawn pawn, Pawn traveller, bool biotuned)
	{
		if (cachedPodDefs.NullOrEmpty())
		{
			cachedPodDefs = DefDatabase<ThingDef>.AllDefs.Where((ThingDef def) => def.GetCompProperties<CompProperties_BiosculpterPod>() != null).ToList();
		}
		foreach (ThingDef cachedPodDef in cachedPodDefs)
		{
			Thing thing = GenClosest.ClosestThingReachable(traveller.Position, pawn.Map, ThingRequest.ForDef(cachedPodDef), PathEndMode.InteractionCell, TraverseParms.For(pawn), 9999f, Validator);
			if (thing != null)
			{
				return thing;
			}
		}
		return null;
		bool Validator(Thing t)
		{
			CompBiosculpterPod compBiosculpterPod = t.TryGetComp<CompBiosculpterPod>();
			if (biotuned && compBiosculpterPod.biotunedTo != traveller)
			{
				return false;
			}
			return compBiosculpterPod.CanAcceptOnceCycleChosen(traveller);
		}
	}

	public static bool WasLoadingCanceled(Thing thing)
	{
		CompBiosculpterPod compBiosculpterPod = thing.TryGetComp<CompBiosculpterPod>();
		if (compBiosculpterPod != null && compBiosculpterPod.State != 0)
		{
			return true;
		}
		return false;
	}

	public void ClearCycle()
	{
		currentCycleKey = null;
	}

	public void Notify_HauledTo(Pawn hauler, Thing thing, int count)
	{
		LiquifyNutrition();
		SoundDefOf.Standard_Drop.PlayOneShot(parent);
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\CompBiosculpterPod_Cycle.txt`
**相似度:** 0.7210

```csharp
public abstract class CompBiosculpterPod_Cycle : ThingComp
{
	private List<string> tmpMissingResearchLabels = new List<string>();

	public CompProperties_BiosculpterPod_BaseCycle Props => (CompProperties_BiosculpterPod_BaseCycle)props;

	public abstract void CycleCompleted(Pawn occupant);

	public virtual string Description(Pawn tunedFor)
	{
		return Props.description;
	}

	public List<string> MissingResearchLabels()
	{
		tmpMissingResearchLabels.Clear();
		if (Props.requiredResearch.NullOrEmpty())
		{
			return tmpMissingResearchLabels;
		}
		foreach (ResearchProjectDef item in Props.requiredResearch)
		{
			if (!item.IsFinished)
			{
				tmpMissingResearchLabels.Add(item.LabelCap);
			}
		}
		return tmpMissingResearchLabels;
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\WorkGiver_HaulToBiosculpterPod.txt`
**相似度:** 0.7198

```csharp
public class WorkGiver_HaulToBiosculpterPod : WorkGiver_Scanner
{
	public override ThingRequest PotentialWorkThingRequest => ThingRequest.ForDef(ThingDefOf.BiosculpterPod);

	public override PathEndMode PathEndMode => PathEndMode.Touch;

	public override bool HasJobOnThing(Pawn pawn, Thing t, bool forced = false)
	{
		if (!ModLister.CheckIdeology("Biosculpting"))
		{
			return false;
		}
		if (!pawn.CanReserve(t, 1, -1, null, forced))
		{
			return false;
		}
		if (pawn.Map.designationManager.DesignationOn(t, DesignationDefOf.Deconstruct) != null)
		{
			return false;
		}
		CompBiosculpterPod compBiosculpterPod = t.TryGetComp<CompBiosculpterPod>();
		if (compBiosculpterPod == null || !compBiosculpterPod.PowerOn || compBiosculpterPod.State != 0 || (!forced && !compBiosculpterPod.autoLoadNutrition))
		{
			return false;
		}
		if (t.IsBurning())
		{
			return false;
		}
		if (compBiosculpterPod.RequiredNutritionRemaining > 0f)
		{
			if (FindNutrition(pawn, compBiosculpterPod).Thing == null)
			{
				JobFailReason.Is("NoFood".Translate());
				return false;
			}
			return true;
		}
		return false;
	}

	public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
	{
		CompBiosculpterPod compBiosculpterPod = t.TryGetComp<CompBiosculpterPod>();
		if (compBiosculpterPod == null)
		{
			return null;
		}
		if (compBiosculpterPod.RequiredNutritionRemaining > 0f)
		{
			ThingCount thingCount = FindNutrition(pawn, compBiosculpterPod);
			if (thingCount.Thing != null)
			{
				Job job = HaulAIUtility.HaulToContainerJob(pawn, thingCount.Thing, t);
				job.count = Mathf.Min(job.count, thingCount.Count);
				return job;
			}
		}
		return null;
	}

	private ThingCount FindNutrition(Pawn pawn, CompBiosculpterPod pod)
	{
		Thing thing = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForGroup(ThingRequestGroup.FoodSourceNotPlantOrTree), PathEndMode.ClosestTouch, TraverseParms.For(pawn), 9999f, Validator);
		if (thing == null)
		{
			return default(ThingCount);
		}
		int b = Mathf.CeilToInt(pod.RequiredNutritionRemaining / thing.GetStatValue(StatDefOf.Nutrition));
		return new ThingCount(thing, Mathf.Min(thing.stackCount, b));
		bool Validator(Thing x)
		{
			if (x.IsForbidden(pawn) || !pawn.CanReserve(x))
			{
				return false;
			}
			if (!pod.CanAcceptNutrition(x))
			{
				return false;
			}
			return true;
		}
	}
}
```