public void UnassignClinic()
{
Ownables soleOwner = base.sm.masterTarget.Get(base.smi).GetComponent <MinionIdentity>().GetSoleOwner();
AssignableSlot clinic = Db.Get().AssignableSlots.Clinic;
soleOwner.GetSlot(clinic)?.Unassign(true);
}
public override void Deserialize(IReader reader)
{
string id = reader.ReadKleiString();
equipmentSlot = Db.Get().AssignableSlots.Get(id);
numToEquip = reader.ReadInt32();
}
public void FindAvailableMedicalBed(Navigator navigator)
{
Clinic clinic = null;
AssignableSlot clinic2 = Db.Get().AssignableSlots.Clinic;
Ownables soleOwner = gameObject.GetComponent <MinionIdentity>().GetSoleOwner();
AssignableSlotInstance slot = soleOwner.GetSlot(clinic2);
if ((UnityEngine.Object)slot.assignable == (UnityEngine.Object)null)
{
Assignable assignable = soleOwner.AutoAssignSlot(clinic2);
if ((UnityEngine.Object)assignable != (UnityEngine.Object)null)
{
clinic = assignable.GetComponent <Clinic>();
}
}
else
{
clinic = slot.assignable.GetComponent <Clinic>();
}
if ((UnityEngine.Object)clinic != (UnityEngine.Object)null && navigator.CanReach(clinic))
{
base.smi.sm.clinic.Set(clinic.gameObject, base.smi);
base.smi.GoTo(base.smi.sm.incapacitation_root.rescue.waitingForPickup);
}
}
public void AutoAssignClinic()
{
Ownables soleOwner = base.sm.masterTarget.Get(base.smi).GetComponent <MinionIdentity>().GetSoleOwner();
AssignableSlot clinic = Db.Get().AssignableSlots.Clinic;
AssignableSlotInstance slot = soleOwner.GetSlot(clinic);
if (slot != null && !((Object)slot.assignable != (Object)null))
{
soleOwner.AutoAssignSlot(clinic);
}
}
public static void AutoAssignClinic(WoundMonitor.Instance smi)
{
Ownables component = smi.sm.masterTarget.Get(smi).GetComponent <Ownables>();
AssignableSlot clinic = Db.Get().AssignableSlots.Clinic;
AssignableSlotInstance slot = component.GetSlot(clinic);
if (slot == null || (Object)slot.assignable != (Object)null)
{
return;
}
component.AutoAssignSlot(clinic);
}
public bool IsReachable(AssignableSlot slot)
{
for (int i = 0; i < slots.Length; i++)
{
if (slots[i].slot.slot == slot)
{
return(slots[i].isReachable);
}
}
Debug.LogError("Could not find slot: " + slot);
return(false);
}
public AssignableSlotInstance GetSlot(AssignableSlot slot)
{
Debug.Assert(slots.Count > 0, "GetSlot called with no slots configured");
if (slot == null)
{
return(null);
}
foreach (AssignableSlotInstance slot2 in slots)
{
if (slot2.slot == slot)
{
return(slot2);
}
}
return(null);
}
/// <summary>
/// Checks assigned objects and determines their locations.
/// </summary>
/// <param name="owner">The owner of the objects.</param>
/// <param name="type">The type of object to search.</param>
/// <param name="cells">Valid ownables will have their cell locations placed here.</param>
private static void CheckAssignedCell(Ownables owner, AssignableSlot type,
IList <int> cells)
{
var items = Game.Instance.assignmentManager.GetPreferredAssignables(owner, type);
cells.Clear();
if (items != null)
{
// All usable items are added
foreach (Assignable item in items)
{
if (item.gameObject.IsUsable())
{
cells.Add(Grid.PosToCell(item));
}
}
}
}
public List <Assignable> GetPreferredAssignables(Assignables owner, AssignableSlot slot)
{
PreferredAssignableResults.Clear();
int num = 2147483647;
foreach (Assignable assignable in assignables)
{
if (assignable.slot == slot && assignable.assignee != null)
{
List <Ownables> owners = assignable.assignee.GetOwners();
if (owners.Count > 0)
{
foreach (Ownables item in owners)
{
if ((Object)item.gameObject == (Object)owner.gameObject)
{
if (assignable.assignee is Room && (assignable.assignee as Room).roomType.priority_building_use)
{
PreferredAssignableResults.Clear();
PreferredAssignableResults.Add(assignable);
return(PreferredAssignableResults);
}
if (owners.Count == num)
{
PreferredAssignableResults.Add(assignable);
}
else if (owners.Count < num)
{
num = owners.Count;
PreferredAssignableResults.Clear();
PreferredAssignableResults.Add(assignable);
}
}
}
}
}
}
return(PreferredAssignableResults);
}
public Assignable AutoAssignSlot(AssignableSlot slot)
{
Assignable assignable = GetAssignable(slot);
if ((Object)assignable != (Object)null)
{
return(assignable);
}
MinionAssignablesProxy component = GetComponent <MinionAssignablesProxy>();
GameObject targetGameObject = component.GetTargetGameObject();
if ((Object)targetGameObject == (Object)null)
{
Debug.LogWarning("AutoAssignSlot failed, proxy game object was null.");
return(null);
}
Navigator component2 = targetGameObject.GetComponent <Navigator>();
IAssignableIdentity assignableIdentity = GetAssignableIdentity();
int num = 2147483647;
foreach (Assignable item in Game.Instance.assignmentManager)
{
if (!((Object)item == (Object)null) && !item.IsAssigned() && item.slot == slot && item.CanAutoAssignTo(assignableIdentity))
{
int navigationCost = item.GetNavigationCost(component2);
if (navigationCost != -1 && navigationCost < num)
{
num = navigationCost;
assignable = item;
}
}
}
if ((Object)assignable != (Object)null)
{
assignable.Assign(assignableIdentity);
}
return(assignable);
}
public AssignableSlotInstance(Assignables assignables, AssignableSlot slot)
{
this.slot = slot;
this.assignables = assignables;
}
public Assignable GetAssignable(AssignableSlot slot)
{
return(GetSlot(slot)?.assignable);
}
public EquipNDupes(AssignableSlot equipmentSlot, int numToEquip)
{
this.equipmentSlot = equipmentSlot;
this.numToEquip = numToEquip;
}
public bool IsSlotOccupied(AssignableSlot slot)
{
EquipmentSlotInstance equipmentSlotInstance = GetSlot(slot) as EquipmentSlotInstance;
return(equipmentSlotInstance.IsAssigned() && (equipmentSlotInstance.assignable as Equippable).isEquipped);
}
