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

---
**文件路径 (精确匹配):** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\Building_Bed.txt`

```csharp
public class Building_Bed : Building
{
	private BedOwnerType forOwnerType;

	private bool medicalInt;

	private bool alreadySetDefaultMed;

	private static int lastBedOwnerSetChangeFrame = -1;

	private static List<IntVec3> tmpOrderedInteractionCells = new List<IntVec3>(8);

	private static readonly Color SheetColorNormal = new Color(0.6313726f, 71f / 85f, 0.7058824f);

	private static readonly Color SheetColorRoyal = new Color(57f / 85f, 0.9137255f, 38f / 51f);

	public static readonly Color SheetColorForPrisoner = new Color(1f, 61f / 85f, 11f / 85f);

	private static readonly Color SheetColorMedical = new Color(33f / 85f, 53f / 85f, 0.8862745f);

	private static readonly Color SheetColorMedicalForPrisoner = new Color(0.654902f, 32f / 85f, 13f / 85f);

	private static readonly Color SheetColorForSlave = new Color32(252, 244, 3, byte.MaxValue);

	private static readonly Color SheetColorMedicalForSlave = new Color32(153, 148, 0, byte.MaxValue);

	private static readonly BedInteractionCellSearchPattern defaultBedInteractionCellsOrder = new BedInteractionCellSearchPattern();

	public List<Pawn> OwnersForReading => CompAssignableToPawn.AssignedPawnsForReading;

	public CompAssignableToPawn CompAssignableToPawn => GetComp<CompAssignableToPawn>();

	public bool ForPrisoners
	{
		get
		{
			return forOwnerType == BedOwnerType.Prisoner;
		}
		set
		{
			if (value == ForPrisoners || !def.building.bed_humanlike || ForHumanBabies)
			{
				return;
			}
			if (Current.ProgramState != ProgramState.Playing && Scribe.mode != 0)
			{
				Log.Error("Tried to set ForPrisoners while game mode was " + Current.ProgramState);
				return;
			}
			RemoveAllOwners();
			if (value)
			{
				forOwnerType = BedOwnerType.Prisoner;
			}
			else
			{
				forOwnerType = BedOwnerType.Colonist;
				Log.Error("Bed ForPrisoners=false, but should it be for for colonists or slaves?  Set ForOwnerType instead.");
			}
			Notify_ColorChanged();
			NotifyRoomBedTypeChanged();
		}
	}

	public bool ForSlaves => ForOwnerType == BedOwnerType.Slave;

	public bool ForColonists => ForOwnerType == BedOwnerType.Colonist;

	public bool ForHumanBabies
	{
		get
		{
			if (def.building.bed_humanlike)
			{
				return def.building.bed_maxBodySize < LifeStageDefOf.HumanlikeChild.bodySizeFactor;
			}
			return false;
		}
	}

	public BedOwnerType ForOwnerType
	{
		get
		{
			return forOwnerType;
		}
		set
		{
			if (value != forOwnerType && def.building.bed_humanlike && !ForHumanBabies && (value != BedOwnerType.Slave || ModLister.CheckIdeology("Slavery")))
			{
				RemoveAllOwners();
				forOwnerType = value;
				Notify_ColorChanged();
				NotifyRoomBedTypeChanged();
			}
		}
	}

	public bool Medical
	{
		get
		{
			return medicalInt;
		}
		set
		{
			if (value != medicalInt && (!value || def.building.bed_canBeMedical))
			{
				RemoveAllOwners();
				medicalInt = value;
				Notify_ColorChanged();
				if (base.Spawned)
				{
					base.Map.mapDrawer.MapMeshDirty(base.Position, MapMeshFlagDefOf.Things);
					NotifyRoomBedTypeChanged();
				}
				FacilityChanged();
			}
		}
	}

	public bool AnyUnownedSleepingSlot
	{
		get
		{
			if (Medical)
			{
				Log.Warning("Tried to check for unowned sleeping slot on medical bed " + this);
				return false;
			}
			return CompAssignableToPawn.HasFreeSlot;
		}
	}

	public int TotalSleepingSlots
	{
		get
		{
			if (Medical)
			{
				Log.Warning("Tried to check for total sleeping slots on medical bed " + this);
				return 0;
			}
			return CompAssignableToPawn.TotalSlots;
		}
	}

	public bool AnyUnoccupiedSleepingSlot
	{
		get
		{
			for (int i = 0; i < SleepingSlotsCount; i++)
			{
				if (GetCurOccupant(i) == null)
				{
					return true;
				}
			}
			return false;
		}
	}

	public IEnumerable<Pawn> CurOccupants
	{
		get
		{
			for (int i = 0; i < SleepingSlotsCount; i++)
			{
				Pawn curOccupant = GetCurOccupant(i);
				if (curOccupant != null)
				{
					yield return curOccupant;
				}
			}
		}
	}

	public bool AnyOccupants
	{
		get
		{
			for (int i = 0; i < SleepingSlotsCount; i++)
			{
				if (GetCurOccupant(i) != null)
				{
					return true;
				}
			}
			return false;
		}
	}

	public override Color DrawColor
	{
		get
		{
			if (def.MadeFromStuff)
			{
				return base.DrawColor;
			}
			return DrawColorTwo;
		}
	}

	public override Color DrawColorTwo
	{
		get
		{
			if (def.building != null && !def.building.bed_UseSheetColor)
			{
				return base.DrawColorTwo;
			}
			bool medical = Medical;
			switch (forOwnerType)
			{
			case BedOwnerType.Prisoner:
				if (!medical)
				{
					return SheetColorForPrisoner;
				}
				return SheetColorMedicalForPrisoner;
			case BedOwnerType.Slave:
				if (!medical)
				{
					return SheetColorForSlave;
				}
				return SheetColorMedicalForSlave;
			default:
				if (medical)
				{
					return SheetColorMedical;
				}
				if (def == ThingDefOf.RoyalBed)
				{
					return SheetColorRoyal;
				}
				return SheetColorNormal;
			}
		}
	}

	public int SleepingSlotsCount => BedUtility.GetSleepingSlotsCount(def.size);

	private bool PlayerCanSeeOwners => CompAssignableToPawn.PlayerCanSeeAssignments;

	public override IntVec3 InteractionCell => FindPreferredInteractionCell(base.Position) ?? base.InteractionCell;

	public override void SpawnSetup(Map map, bool respawningAfterLoad)
	{
		base.SpawnSetup(map, respawningAfterLoad);
		Region validRegionAt_NoRebuild = map.regionGrid.GetValidRegionAt_NoRebuild(base.Position);
		if (validRegionAt_NoRebuild != null && validRegionAt_NoRebuild.Room.IsPrisonCell)
		{
			ForPrisoners = true;
		}
		if (!alreadySetDefaultMed)
		{
			alreadySetDefaultMed = true;
			if (def.building.bed_defaultMedical)
			{
				Medical = true;
			}
		}
		if (!respawningAfterLoad)
		{
			District district = this.GetDistrict();
			if (district != null)
			{
				district.Notify_RoomShapeOrContainedBedsChanged();
				district.Room.Notify_RoomShapeChanged();
			}
		}
	}

	public override void DeSpawn(DestroyMode mode = DestroyMode.Vanish)
	{
		if (mode != DestroyMode.WillReplace)
		{
			if (mode != 0)
			{
				RemoveAllOwners(mode == DestroyMode.KillFinalize);
			}
			else if (InstallBlueprintUtility.ExistingBlueprintFor(this) == null)
			{
				foreach (Pawn item in OwnersForReading)
				{
					Messages.Message("MessageBedLostAssignment".Translate(def, item), new LookTargets(this, item), MessageTypeDefOf.CautionInput, historical: false);
				}
			}
			ForOwnerType = BedOwnerType.Colonist;
			Medical = false;
			alreadySetDefaultMed = false;
		}
		District district = this.GetDistrict();
		base.DeSpawn(mode);
		if (district != null)
		{
			district.Notify_RoomShapeOrContainedBedsChanged();
			district.Room.Notify_RoomShapeChanged();
		}
	}

	public override void ExposeData()
	{
		base.ExposeData();
		Scribe_Values.Look(ref medicalInt, "medical", defaultValue: false);
		Scribe_Values.Look(ref alreadySetDefaultMed, "alreadySetDefaultMed", defaultValue: false);
		Scribe_Values.Look(ref forOwnerType, "forOwnerType", BedOwnerType.Colonist);
		BackCompatibility.PostExposeData(this);
	}

	public override void DrawExtraSelectionOverlays()
	{
		base.DrawExtraSelectionOverlays();
		Room room = this.GetRoom();
		if (room != null && RoomCanBePrisonCell(room))
		{
			room.DrawFieldEdges();
		}
	}

	public static bool RoomCanBePrisonCell(Room r)
	{
		if (r.ProperRoom)
		{
			return !r.IsHuge;
		}
		return false;
	}

	public override IEnumerable<Gizmo> GetGizmos()
	{
		foreach (Gizmo gizmo in base.GetGizmos())
		{
			yield return gizmo;
		}
		if (base.Faction != Faction.OfPlayer)
		{
			yield break;
		}
		if (def.building.bed_humanlike && !ForHumanBabies)
		{
			if (ModsConfig.IdeologyActive)
			{
				yield return new Command_SetBedOwnerType(this);
			}
			else
			{
				Command_Toggle command_Toggle = new Command_Toggle();
				command_Toggle.defaultLabel = "CommandBedSetForPrisonersLabel".Translate();
				command_Toggle.defaultDesc = "CommandBedSetForPrisonersDesc".Translate();
				command_Toggle.icon = ContentFinder<Texture2D>.Get("UI/Commands/ForPrisoners");
				command_Toggle.isActive = () => ForPrisoners;
				command_Toggle.toggleAction = delegate
				{
					SetBedOwnerTypeByInterface((!ForPrisoners) ? BedOwnerType.Prisoner : BedOwnerType.Colonist);
				};
				if (!RoomCanBePrisonCell(this.GetRoom()) && !ForPrisoners)
				{
					command_Toggle.Disable("CommandBedSetForPrisonersFailOutdoors".Translate());
				}
				command_Toggle.hotKey = KeyBindingDefOf.Misc3;
				command_Toggle.turnOffSound = null;
				command_Toggle.turnOnSound = null;
				yield return command_Toggle;
			}
		}
		if (def.building.bed_canBeMedical)
		{
			Command_Toggle command_Toggle2 = new Command_Toggle();
			command_Toggle2.defaultLabel = "CommandBedSetAsMedicalLabel".Translate();
			command_Toggle2.defaultDesc = "CommandBedSetAsMedicalDesc".Translate();
			command_Toggle2.icon = ContentFinder<Texture2D>.Get("UI/Commands/AsMedical");
			command_Toggle2.isActive = () => Medical;
			command_Toggle2.toggleAction = delegate
			{
				Medical = !Medical;
			};
			command_Toggle2.hotKey = KeyBindingDefOf.Misc2;
			yield return command_Toggle2;
		}
	}

	public void SetBedOwnerTypeByInterface(BedOwnerType ownerType)
	{
		if (lastBedOwnerSetChangeFrame == Time.frameCount)
		{
			return;
		}
		lastBedOwnerSetChangeFrame = Time.frameCount;
		((ForOwnerType != ownerType) ? SoundDefOf.Checkbox_TurnedOn : SoundDefOf.Checkbox_TurnedOff).PlayOneShotOnCamera();
		List<Building_Bed> bedsToAffect = new List<Building_Bed>();
		foreach (Building_Bed item in Find.Selector.SelectedObjects.OfType<Building_Bed>())
		{
			if (item.ForOwnerType == ownerType)
			{
				continue;
			}
			Room room = item.GetRoom();
			if (room == null && ownerType != BedOwnerType.Prisoner)
			{
				if (!bedsToAffect.Contains(item))
				{
					bedsToAffect.Add(item);
				}
				continue;
			}
			foreach (Building_Bed containedBed in room.ContainedBeds)
			{
				if (containedBed.ForOwnerType != ownerType)
				{
					if (containedBed.ForOwnerType == BedOwnerType.Prisoner && !bedsToAffect.Contains(containedBed))
					{
						bedsToAffect.Add(containedBed);
					}
					else if (ownerType == BedOwnerType.Prisoner && RoomCanBePrisonCell(room) && !bedsToAffect.Contains(containedBed))
					{
						bedsToAffect.Add(containedBed);
					}
					else if (containedBed == item && !bedsToAffect.Contains(containedBed))
					{
						bedsToAffect.Add(containedBed);
					}
				}
			}
		}
		Action action = delegate
		{
			List<District> list = new List<District>();
			List<Room> list2 = new List<Room>();
			foreach (Building_Bed item2 in bedsToAffect)
			{
				District district = item2.GetDistrict();
				Room room2 = district.Room;
				if (ownerType == BedOwnerType.Prisoner && room2.TouchesMapEdge)
				{
					item2.ForOwnerType = BedOwnerType.Colonist;
				}
				else
				{
					item2.ForOwnerType = ownerType;
				}
				if (!room2.TouchesMapEdge)
				{
					if (!list2.Contains(room2))
					{
						list2.Add(room2);
					}
					if (!list.Contains(district))
					{
						list.Add(district);
					}
				}
			}
			foreach (District item3 in list)
			{
				item3.Notify_RoomShapeOrContainedBedsChanged();
			}
			foreach (Room item4 in list2)
			{
				item4.Notify_RoomShapeChanged();
			}
		};
		if (bedsToAffect.Where((Building_Bed b) => b.OwnersForReading.Any((Pawn owner) => owner.RaceProps.Humanlike) && b != this).Count() == 0)
		{
			action();
			return;
		}
		StringBuilder stringBuilder = new StringBuilder();
		if (!ModsConfig.IdeologyActive)
		{
			if (ownerType == BedOwnerType.Prisoner)
			{
				stringBuilder.Append("TurningOnPrisonerBedWarning".Translate());
			}
			else
			{
				stringBuilder.Append("TurningOffPrisonerBedWarning".Translate());
			}
		}
		else
		{
			stringBuilder.Append("ChangingOwnerTypeBedWarning".Translate());
		}
		stringBuilder.AppendLine();
		foreach (Building_Bed item5 in bedsToAffect)
		{
			if (ownerType != item5.ForOwnerType)
			{
				for (int i = 0; i < item5.OwnersForReading.Count; i++)
				{
					stringBuilder.AppendLine();
					stringBuilder.Append(item5.OwnersForReading[i].LabelShort);
				}
			}
		}
		stringBuilder.AppendLine();
		stringBuilder.AppendLine();
		stringBuilder.Append("AreYouSure".Translate());
		Find.WindowStack.Add(Dialog_MessageBox.CreateConfirmation(stringBuilder.ToString(), action));
	}

	public override string GetInspectString()
	{
		StringBuilder stringBuilder = new StringBuilder();
		stringBuilder.Append(base.GetInspectString());
		if (def.building.bed_humanlike && def.building.bed_DisplayOwnerType && base.Faction == Faction.OfPlayer)
		{
			switch (ForOwnerType)
			{
			case BedOwnerType.Prisoner:
				stringBuilder.AppendInNewLine("ForPrisonerUse".Translate());
				break;
			case BedOwnerType.Slave:
				stringBuilder.AppendInNewLine("ForSlaveUse".Translate());
				break;
			case BedOwnerType.Colonist:
				stringBuilder.AppendInNewLine("ForColonistUse".Translate());
				break;
			default:
				Log.Error($"Unknown bed owner type: {ForOwnerType}");
				break;
			}
		}
		if (Medical)
		{
			stringBuilder.AppendInNewLine("MedicalBed".Translate());
			if (base.Spawned)
			{
				stringBuilder.AppendInNewLine("RoomInfectionChanceFactor".Translate() + ": " + this.GetRoom().GetStat(RoomStatDefOf.InfectionChanceFactor).ToStringPercent());
			}
		}
		else if (PlayerCanSeeOwners && def.building.bed_DisplayOwnersInInspectString)
		{
			if (OwnersForReading.Count == 0)
			{
				stringBuilder.AppendInNewLine("Owner".Translate() + ": " + "Nobody".Translate());
			}
			else if (OwnersForReading.Count == 1)
			{
				stringBuilder.AppendInNewLine("Owner".Translate() + ": " + OwnersForReading[0].Label);
			}
			else
			{
				stringBuilder.AppendInNewLine("Owners".Translate() + ": ");
				bool flag = false;
				for (int i = 0; i < OwnersForReading.Count; i++)
				{
					if (flag)
					{
						stringBuilder.Append(", ");
					}
					flag = true;
					stringBuilder.Append(OwnersForReading[i].LabelShort);
				}
			}
			if (OwnersForReading.Count == 1 && ChildcareUtility.CanSuckle(OwnersForReading[0], out var _))
			{
				Pawn p = OwnersForReading[0];
				float ambientTemperature = base.AmbientTemperature;
				if (!p.SafeTemperatureRange().IncludesEpsilon(ambientTemperature))
				{
					stringBuilder.AppendInNewLine("BedUnsafeTemperature".Translate().Colorize(ColoredText.WarningColor));
				}
				else if (!p.ComfortableTemperatureRange().IncludesEpsilon(ambientTemperature))
				{
					stringBuilder.AppendInNewLine("BedUncomfortableTemperature".Translate());
				}
			}
		}
		return stringBuilder.ToString();
	}

	public override IEnumerable<FloatMenuOption> GetFloatMenuOptions(Pawn myPawn)
	{
		FloatMenuOption bedRestFloatMenuOption = GetBedRestFloatMenuOption(myPawn);
		if (bedRestFloatMenuOption != null)
		{
			yield return bedRestFloatMenuOption;
		}
	}

	public FloatMenuOption GetBedRestFloatMenuOption(Pawn myPawn)
	{
		if (myPawn.RaceProps.Humanlike && !ForPrisoners && Medical && !myPawn.Drafted && base.Faction == Faction.OfPlayer && RestUtility.CanUseBedEver(myPawn, def))
		{
			if (!HealthAIUtility.ShouldSeekMedicalRest(myPawn))
			{
				if (myPawn.health.surgeryBills.AnyShouldDoNow && !WorkGiver_PatientGoToBedTreatment.AnyAvailableDoctorFor(myPawn))
				{
					return new FloatMenuOption("UseMedicalBed".Translate() + " (" + "NoDoctor".Translate() + ")", null);
				}
				return new FloatMenuOption("UseMedicalBed".Translate() + " (" + "NotInjured".Translate() + ")", null);
			}
			if (myPawn.IsSlaveOfColony && !ForSlaves)
			{
				return new FloatMenuOption("UseMedicalBed".Translate() + " (" + "NotForSlaves".Translate() + ")", null);
			}
			Action action = delegate
			{
				if (!ForPrisoners && Medical && myPawn.CanReserveAndReach(this, PathEndMode.ClosestTouch, Danger.Deadly, SleepingSlotsCount, -1, null, ignoreOtherReservations: true))
				{
					if (myPawn.CurJobDef == JobDefOf.LayDown && myPawn.CurJob.GetTarget(TargetIndex.A).Thing == this)
					{
						myPawn.CurJob.restUntilHealed = true;
					}
					else
					{
						Job job = JobMaker.MakeJob(JobDefOf.LayDown, this);
						job.restUntilHealed = true;
						myPawn.jobs.TryTakeOrderedJob(job, JobTag.Misc);
					}
					myPawn.mindState.ResetLastDisturbanceTick();
				}
			};
			return FloatMenuUtility.DecoratePrioritizedTask(new FloatMenuOption("UseMedicalBed".Translate(), action), myPawn, this, (AnyUnoccupiedSleepingSlot ? "ReservedBy" : "SomeoneElseSleeping").CapitalizeFirst());
		}
		return null;
	}

	public override void DrawGUIOverlay()
	{
		if (Medical || Find.CameraDriver.CurrentZoom != 0 || !PlayerCanSeeOwners)
		{
			return;
		}
		Color defaultThingLabelColor = GenMapUI.DefaultThingLabelColor;
		if (!OwnersForReading.Any())
		{
			GenMapUI.DrawThingLabel(this, "Unowned".Translate(), defaultThingLabelColor);
			return;
		}
		if (OwnersForReading.Count == 1)
		{
			Pawn pawn = OwnersForReading[0];
			if ((!pawn.InBed() || pawn.CurrentBed() != this) && (!pawn.RaceProps.Animal || Prefs.AnimalNameMode.ShouldDisplayAnimalName(pawn)))
			{
				GenMapUI.DrawThingLabel(this, pawn.LabelShort, defaultThingLabelColor);
			}
			return;
		}
		for (int i = 0; i < OwnersForReading.Count; i++)
		{
			Pawn pawn2 = OwnersForReading[i];
			if (!pawn2.InBed() || OwnersForReading[i].CurrentBed() != this || !(pawn2.Position == GetSleepingSlotPos(i)))
			{
				if (pawn2.RaceProps.Animal && !Prefs.AnimalNameMode.ShouldDisplayAnimalName(pawn2))
				{
					break;
				}
				GenMapUI.DrawThingLabel(GetMultiOwnersLabelScreenPosFor(i), pawn2.LabelShort, defaultThingLabelColor);
			}
		}
	}

	public Pawn GetCurOccupant(int slotIndex)
	{
		if (!base.Spawned)
		{
			return null;
		}
		IntVec3 sleepingSlotPos = GetSleepingSlotPos(slotIndex);
		List<Thing> list = base.Map.thingGrid.ThingsListAt(sleepingSlotPos);
		for (int i = 0; i < list.Count; i++)
		{
			if (list[i] is Pawn { CurJob: not null } pawn && pawn.GetPosture().InBed())
			{
				return pawn;
			}
		}
		return null;
	}

	public int GetCurOccupantSlotIndex(Pawn curOccupant)
	{
		for (int i = 0; i < SleepingSlotsCount; i++)
		{
			if (GetCurOccupant(i) == curOccupant)
			{
				return i;
			}
		}
		Log.Error("Could not find pawn " + curOccupant?.ToString() + " on any of sleeping slots.");
		return 0;
	}

	public Pawn GetCurOccupantAt(IntVec3 pos)
	{
		for (int i = 0; i < SleepingSlotsCount; i++)
		{
			if (GetSleepingSlotPos(i) == pos)
			{
				return GetCurOccupant(i);
			}
		}
		return null;
	}

	public IntVec3 GetSleepingSlotPos(int index)
	{
		return BedUtility.GetSleepingSlotPos(index, base.Position, base.Rotation, def.size);
	}

	public IntVec3 GetFootSlotPos(int index)
	{
		return BedUtility.GetFeetSlotPos(index, base.Position, base.Rotation, def.size);
	}

	public bool IsOwner(Pawn p)
	{
		int? assignedSleepingSlot;
		return IsOwner(p, out assignedSleepingSlot);
	}

	public bool IsOwner(Pawn p, out int? assignedSleepingSlot)
	{
		int num = GetComp<CompAssignableToPawn>().AssignedPawnsForReading.IndexOf(p);
		if (num >= 0)
		{
			assignedSleepingSlot = num;
			return true;
		}
		assignedSleepingSlot = null;
		return false;
	}

	private void RemoveAllOwners(bool destroyed = false)
	{
		for (int num = OwnersForReading.Count - 1; num >= 0; num--)
		{
			Pawn pawn = OwnersForReading[num];
			pawn.ownership.UnclaimBed();
			string key = "MessageBedLostAssignment";
			if (destroyed)
			{
				key = "MessageBedDestroyed";
			}
			Messages.Message(key.Translate(def, pawn), new LookTargets(this, pawn), MessageTypeDefOf.CautionInput, historical: false);
		}
	}

	private void NotifyRoomBedTypeChanged()
	{
		this.GetRoom()?.Notify_BedTypeChanged();
	}

	public void NotifyRoomAssignedPawnsChanged()
	{
		this.GetRoom()?.Notify_BedTypeChanged();
	}

	private void FacilityChanged()
	{
		CompFacility compFacility = this.TryGetComp<CompFacility>();
		CompAffectedByFacilities compAffectedByFacilities = this.TryGetComp<CompAffectedByFacilities>();
		compFacility?.Notify_ThingChanged();
		compAffectedByFacilities?.Notify_ThingChanged();
	}

	private Vector3 GetMultiOwnersLabelScreenPosFor(int slotIndex)
	{
		IntVec3 sleepingSlotPos = GetSleepingSlotPos(slotIndex);
		Vector3 drawPos = DrawPos;
		if (base.Rotation.IsHorizontal)
		{
			drawPos.z = (float)sleepingSlotPos.z + 0.6f;
		}
		else
		{
			drawPos.x = (float)sleepingSlotPos.x + 0.5f;
			drawPos.z += -0.4f;
		}
		Vector2 vector = drawPos.MapToUIPosition();
		if (!base.Rotation.IsHorizontal && SleepingSlotsCount == 2)
		{
			vector = AdjustOwnerLabelPosToAvoidOverlapping(vector, slotIndex);
		}
		return vector;
	}

	private Vector3 AdjustOwnerLabelPosToAvoidOverlapping(Vector3 screenPos, int slotIndex)
	{
		Text.Font = GameFont.Tiny;
		float num = Text.CalcSize(OwnersForReading[slotIndex].LabelShort).x + 1f;
		Vector2 vector = DrawPos.MapToUIPosition();
		float num2 = Mathf.Abs(screenPos.x - vector.x);
		IntVec3 sleepingSlotPos = GetSleepingSlotPos(slotIndex);
		if (num > num2 * 2f)
		{
			float num3 = 0f;
			num3 = ((slotIndex != 0) ? ((float)GetSleepingSlotPos(0).x) : ((float)GetSleepingSlotPos(1).x));
			if ((float)sleepingSlotPos.x < num3)
			{
				screenPos.x -= (num - num2 * 2f) / 2f;
			}
			else
			{
				screenPos.x += (num - num2 * 2f) / 2f;
			}
		}
		return screenPos;
	}

	private bool RemoveLeastDesirableInteractionCells(List<IntVec3> cells, Map map)
	{
		cells.RemoveAll(map, (Map innerMap, IntVec3 cell) => !cell.Standable(innerMap) || !TouchPathEndModeUtility.IsAdjacentOrInsideAndAllowedToTouch(cell, new LocalTargetInfo(this), map.pathing.Normal));
		if (cells.RemoveAll_IfNotAll(map, delegate(Map innerMap, IntVec3 cell)
		{
			Building building = map.edificeGrid[cell];
			return building == null || building.def?.IsBed != true;
		}))
		{
			return cells.RemoveAll_IfNotAll(map, (Map innerMap, IntVec3 cell) => cell.GetDoor(map) == null);
		}
		return false;
	}

	public IntVec3? FindPreferredInteractionCell(IntVec3 occupantLocation, CellSearchPattern customSearchPattern = null)
	{
		CellRect cellRect = this.OccupiedRect();
		if (!cellRect.Contains(occupantLocation))
		{
			Log.Error($"interiorLocation {occupantLocation} is not within the bounds of this bed {cellRect}.");
			return null;
		}
		tmpOrderedInteractionCells.Clear();
		(customSearchPattern ?? defaultBedInteractionCellsOrder).AddCellsToList(tmpOrderedInteractionCells, this, cellRect, occupantLocation, base.Rotation);
		RemoveLeastDesirableInteractionCells(tmpOrderedInteractionCells, base.Map);
		if (tmpOrderedInteractionCells.Count == 0)
		{
			return null;
		}
		return tmpOrderedInteractionCells[0];
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\RoomRoleWorker_Bedroom.txt`
**相似度:** 0.5705

```csharp
public class RoomRoleWorker_Bedroom : RoomRoleWorker
{
	private static List<Building_Bed> tmpBeds = new List<Building_Bed>();

	private static List<Pawn> children = new List<Pawn>();

	private static List<Pawn> adults = new List<Pawn>();

	public override float GetScore(Room room)
	{
		tmpBeds.Clear();
		List<Thing> containedAndAdjacentThings = room.ContainedAndAdjacentThings;
		int num = 0;
		for (int i = 0; i < containedAndAdjacentThings.Count; i++)
		{
			if (containedAndAdjacentThings[i] is Building_Bed building_Bed && building_Bed.def.building.bed_humanlike && building_Bed.def.building.bed_countsForBedroomOrBarracks)
			{
				if (building_Bed.Medical || building_Bed.ForPrisoners)
				{
					tmpBeds.Clear();
					return 0f;
				}
				num++;
				tmpBeds.Add(building_Bed);
			}
		}
		if (num == 0)
		{
			tmpBeds.Clear();
			return 0f;
		}
		bool num2 = IsBedroom(tmpBeds);
		tmpBeds.Clear();
		if (!num2)
		{
			return 0f;
		}
		return 100000f;
	}

	public static bool IsBedroom(List<Building_Bed> beds)
	{
		children.Clear();
		adults.Clear();
		bool result = IsBedroomHelper(beds);
		children.Clear();
		adults.Clear();
		return result;
	}

	private static bool IsBedroomHelper(List<Building_Bed> beds)
	{
		List<Pawn> list = null;
		int num = 0;
		int num2 = 0;
		int num3 = 0;
		foreach (Building_Bed bed in beds)
		{
			List<Pawn> ownersForReading = bed.OwnersForReading;
			if (ownersForReading.NullOrEmpty() && bed.def.building.bed_emptyCountsForBarracks)
			{
				num++;
				continue;
			}
			if (ownersForReading.Count > 0)
			{
				num2++;
			}
			bool flag = false;
			foreach (Pawn item in ownersForReading)
			{
				if (item.DevelopmentalStage.Juvenile())
				{
					children.Add(item);
					continue;
				}
				adults.Add(item);
				if (list == null)
				{
					list = item.GetLoveCluster();
				}
				if (!list.Contains(item))
				{
					flag = true;
				}
			}
			if (flag)
			{
				num3++;
			}
		}
		if (num == 1 && num2 == 0)
		{
			return true;
		}
		if (num == 0 && num2 == 1)
		{
			return true;
		}
		if (num > 0)
		{
			return false;
		}
		if (adults.NullOrEmpty())
		{
			return true;
		}
		if (num3 > 0)
		{
			return false;
		}
		foreach (Pawn child in children)
		{
			Pawn mother = child.GetMother();
			Pawn father = child.GetFather();
			if (!adults.Any((Pawn adult) => adult == mother || adult == father))
			{
				return false;
			}
		}
		return true;
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\RoomRoleWorker_Barracks.txt`
**相似度:** 0.5548

```csharp
public class RoomRoleWorker_Barracks : RoomRoleWorker
{
	private static List<Building_Bed> tmpBeds = new List<Building_Bed>();

	public override float GetScore(Room room)
	{
		tmpBeds.Clear();
		int num = 0;
		List<Thing> containedAndAdjacentThings = room.ContainedAndAdjacentThings;
		for (int i = 0; i < containedAndAdjacentThings.Count; i++)
		{
			if (containedAndAdjacentThings[i] is Building_Bed building_Bed && building_Bed.def.building.bed_humanlike && building_Bed.def.building.bed_countsForBedroomOrBarracks)
			{
				if (building_Bed.ForPrisoners)
				{
					tmpBeds.Clear();
					return 0f;
				}
				tmpBeds.Add(building_Bed);
				if (!building_Bed.Medical)
				{
					num++;
				}
			}
		}
		bool num2 = RoomRoleWorker_Bedroom.IsBedroom(tmpBeds);
		tmpBeds.Clear();
		if (num2)
		{
			return 0f;
		}
		return (float)num * 100100f;
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld.BaseGen\SymbolResolver_PrisonerBed.txt`
**相似度:** 0.5535

```csharp
public class SymbolResolver_PrisonerBed : SymbolResolver
{
	public override void Resolve(ResolveParams rp)
	{
		ResolveParams resolveParams = rp;
		Action<Thing> prevPostThingSpawn = resolveParams.postThingSpawn;
		resolveParams.postThingSpawn = delegate(Thing x)
		{
			if (prevPostThingSpawn != null)
			{
				prevPostThingSpawn(x);
			}
			if (x is Building_Bed building_Bed)
			{
				building_Bed.ForPrisoners = true;
			}
		};
		BaseGen.symbolStack.Push("bed", resolveParams);
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\WorkGiver_TakeToBed.txt`
**相似度:** 0.5270

```csharp
public abstract class WorkGiver_TakeToBed : WorkGiver_Scanner
{
	protected Building_Bed FindBed(Pawn pawn, Pawn patient)
	{
		return RestUtility.FindBedFor(patient, pawn, checkSocialProperness: false, ignoreOtherReservations: false, patient.GuestStatus);
	}
}
```
---
**文件路径:** `C:\Steam\steamapps\common\RimWorld\Data\dll1.6\RimWorld\CompAssignableToPawn_DeathrestCasket.txt`
**相似度:** 0.5238

```csharp
public class CompAssignableToPawn_DeathrestCasket : CompAssignableToPawn_Bed
{
	public override string CompInspectStringExtra()
	{
		return null;
	}

	public override bool AssignedAnything(Pawn pawn)
	{
		return pawn.ownership.AssignedDeathrestCasket != null;
	}

	public override void TryAssignPawn(Pawn pawn)
	{
		Building_Bed building_Bed = (Building_Bed)parent;
		pawn.ownership.ClaimDeathrestCasket(building_Bed);
		building_Bed.NotifyRoomAssignedPawnsChanged();
	}

	public override void TryUnassignPawn(Pawn pawn, bool sort = true, bool uninstall = false)
	{
		Building_Bed ownedBed = pawn.ownership.OwnedBed;
		pawn.ownership.UnclaimDeathrestCasket();
		ownedBed?.NotifyRoomAssignedPawnsChanged();
	}

	public override AcceptanceReport CanAssignTo(Pawn pawn)
	{
		Building_Bed building_Bed = (Building_Bed)parent;
		if (pawn.BodySize > building_Bed.def.building.bed_maxBodySize)
		{
			return "TooLargeForBed".Translate();
		}
		if (building_Bed.ForSlaves && !pawn.IsSlave)
		{
			return "CannotAssignBedToColonist".Translate();
		}
		if (building_Bed.ForColonists && pawn.IsSlave)
		{
			return "CannotAssignBedToSlave".Translate();
		}
		CompDeathrestBindable compDeathrestBindable = parent.TryGetComp<CompDeathrestBindable>();
		if (compDeathrestBindable != null && compDeathrestBindable.BoundPawn != null && compDeathrestBindable.BoundPawn != pawn)
		{
			return "CannotAssignAlreadyBound".Translate(compDeathrestBindable.BoundPawn);
		}
		Gene_Deathrest gene_Deathrest = pawn.genes?.GetFirstGeneOfType<Gene_Deathrest>();
		if (gene_Deathrest == null)
		{
			return "CannotAssignBedCannotDeathrest".Translate();
		}
		if (compDeathrestBindable != null && gene_Deathrest.BindingWillExceedStackLimit(compDeathrestBindable))
		{
			return "CannotAssignBedCannotBindToMoreBuildings".Translate(NamedArgumentUtility.Named(parent.def, "BUILDING"));
		}
		return AcceptanceReport.WasAccepted;
	}

	protected override void PostPostExposeData()
	{
		if (Scribe.mode == LoadSaveMode.PostLoadInit && ModsConfig.BiotechActive && assignedPawns.RemoveAll((Pawn x) => x.ownership.AssignedDeathrestCasket != parent) > 0)
		{
			Log.Warning(parent.ToStringSafe() + " had pawns assigned that don't have it as an assigned bed. Removing.");
		}
	}
}
```