public static Job JobOnTransporter(Pawn p, CompTransporter transporter)
{
Job job = new Job(JobDefOf.HaulToTransporter, LocalTargetInfo.Invalid, transporter.parent);
job.ignoreForbidden = true;
return(job);
}
protected override Job TryGiveJob(Pawn pawn)
{
int transportersGroup = pawn.mindState.duty.transportersGroup;
List <Pawn> allPawnsSpawned = pawn.Map.mapPawns.AllPawnsSpawned;
for (int i = 0; i < allPawnsSpawned.Count; i++)
{
if (allPawnsSpawned[i] != pawn && allPawnsSpawned[i].CurJobDef == JobDefOf.HaulToTransporter)
{
CompTransporter transporter = ((JobDriver_HaulToTransporter)allPawnsSpawned[i].jobs.curDriver).Transporter;
if (transporter != null && transporter.groupID == transportersGroup)
{
return(null);
}
}
}
TransporterUtility.GetTransportersInGroup(transportersGroup, pawn.Map, tmpTransporters);
CompTransporter compTransporter = FindMyTransporter(tmpTransporters, pawn);
tmpTransporters.Clear();
if (compTransporter == null || !pawn.CanReach(compTransporter.parent, PathEndMode.Touch, Danger.Deadly))
{
return(null);
}
return(JobMaker.MakeJob(JobDefOf.EnterTransporter, compTransporter.parent));
}
public static bool HasJobOnTransporter(Pawn pawn, CompTransporter transporter)
{
if (transporter.parent.IsForbidden(pawn))
{
return(false);
}
if (!transporter.AnythingLeftToLoad)
{
return(false);
}
if (!pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation))
{
return(false);
}
if (!pawn.CanReserveAndReach(transporter.parent, PathEndMode.Touch, pawn.NormalMaxDanger(), 1, -1, null, false))
{
return(false);
}
Thing thing = LoadTransportersJobUtility.FindThingToLoad(pawn, transporter);
if (thing == null)
{
return(false);
}
return(true);
}
private void DoItemsLists(Rect inRect, ref float curY)
{
CompTransporter transporter = this.Transporter;
Rect position = new Rect(0f, curY, (inRect.width - 10f) / 2f, inRect.height);
float a = 0f;
GUI.BeginGroup(position);
Widgets.ListSeparator(ref a, position.width, "ItemsToLoad".Translate());
bool flag = false;
if (transporter.leftToLoad != null)
{
for (int i = 0; i < transporter.leftToLoad.Count; i++)
{
TransferableOneWay t = transporter.leftToLoad[i];
if (t.CountToTransfer > 0 && t.HasAnyThing)
{
flag = true;
this.DoThingRow(t.ThingDef, t.CountToTransfer, t.things, position.width, ref a, delegate(int x)
{
t.ForceTo(t.CountToTransfer - x);
this.EndJobForEveryoneHauling(t);
});
}
}
}
if (!flag)
{
Widgets.NoneLabel(ref a, position.width, null);
}
GUI.EndGroup();
Rect position2 = new Rect((inRect.width + 10f) / 2f, curY, (inRect.width - 10f) / 2f, inRect.height);
float b = 0f;
GUI.BeginGroup(position2);
Widgets.ListSeparator(ref b, position2.width, "LoadedItems".Translate());
bool flag2 = false;
for (int j = 0; j < transporter.innerContainer.Count; j++)
{
Thing t = transporter.innerContainer[j];
flag2 = true;
ITab_TransporterContents.tmpSingleThing.Clear();
ITab_TransporterContents.tmpSingleThing.Add(t);
this.DoThingRow(t.def, t.stackCount, ITab_TransporterContents.tmpSingleThing, position2.width, ref b, delegate(int x)
{
Thing thing;
GenDrop.TryDropSpawn(t.SplitOff(x), this.SelThing.Position, this.SelThing.Map, ThingPlaceMode.Near, out thing, null, null);
});
ITab_TransporterContents.tmpSingleThing.Clear();
}
if (!flag2)
{
Widgets.NoneLabel(ref b, position.width, null);
}
GUI.EndGroup();
curY += Mathf.Max(a, b);
}
public static Job JobOnTransporter(Pawn p, CompTransporter transporter)
{
Thing thing = LoadTransportersJobUtility.FindThingToLoad(p, transporter);
Job job = new Job(JobDefOf.HaulToContainer, thing, transporter.parent);
int countToTransfer = TransferableUtility.TransferableMatchingDesperate(thing, transporter.leftToLoad).CountToTransfer;
job.count = Mathf.Min(countToTransfer, thing.stackCount);
job.ignoreForbidden = true;
return(job);
}
public static bool WasLoadingCanceled(Thing transporter)
{
CompTransporter compTransporter = transporter.TryGetComp <CompTransporter>();
if (compTransporter != null && !compTransporter.LoadingInProgressOrReadyToLaunch)
{
return(true);
}
return(false);
}
private void TryLaunch(GlobalTargetInfo target, PawnsArriveMode arriveMode, bool attackOnArrival)
{
if (!this.parent.Spawned)
{
Log.Error("Tried to launch " + this.parent + ", but it's unspawned.");
return;
}
List <CompTransporter> transportersInGroup = this.TransportersInGroup;
if (transportersInGroup == null)
{
Log.Error("Tried to launch " + this.parent + ", but it's not in any group.");
return;
}
if (!this.LoadingInProgressOrReadyToLaunch || !this.AllInGroupConnectedToFuelingPort || !this.AllFuelingPortSourcesInGroupHaveAnyFuel)
{
return;
}
Map map = this.parent.Map;
int num = Find.WorldGrid.TraversalDistanceBetween(map.Tile, target.Tile);
if (num > this.MaxLaunchDistance)
{
return;
}
this.Transporter.TryRemoveLord(map);
int groupID = this.Transporter.groupID;
float amount = Mathf.Max(CompLaunchable.FuelNeededToLaunchAtDist((float)num), 1f);
for (int i = 0; i < transportersInGroup.Count; i++)
{
CompTransporter compTransporter = transportersInGroup[i];
Building fuelingPortSource = compTransporter.Launchable.FuelingPortSource;
if (fuelingPortSource != null)
{
fuelingPortSource.TryGetComp <CompRefuelable>().ConsumeFuel(amount);
}
ThingOwner directlyHeldThings = compTransporter.GetDirectlyHeldThings();
ActiveDropPod activeDropPod = (ActiveDropPod)ThingMaker.MakeThing(ThingDefOf.ActiveDropPod, null);
activeDropPod.Contents = new ActiveDropPodInfo();
activeDropPod.Contents.innerContainer.TryAddRangeOrTransfer(directlyHeldThings, true, true);
DropPodLeaving dropPodLeaving = (DropPodLeaving)SkyfallerMaker.MakeSkyfaller(ThingDefOf.DropPodLeaving, activeDropPod);
dropPodLeaving.groupID = groupID;
dropPodLeaving.destinationTile = target.Tile;
dropPodLeaving.destinationCell = target.Cell;
dropPodLeaving.arriveMode = arriveMode;
dropPodLeaving.attackOnArrival = attackOnArrival;
compTransporter.CleanUpLoadingVars(map);
compTransporter.parent.Destroy(DestroyMode.Vanish);
GenSpawn.Spawn(dropPodLeaving, compTransporter.parent.Position, map);
}
}
protected override Job TryGiveJob(Pawn pawn)
{
TransporterUtility.GetTransportersInGroup(pawn.mindState.duty.transportersGroup, pawn.Map, tmpTransporters);
for (int i = 0; i < tmpTransporters.Count; i++)
{
CompTransporter transporter = tmpTransporters[i];
if (LoadTransportersJobUtility.HasJobOnTransporter(pawn, transporter))
{
return(LoadTransportersJobUtility.JobOnTransporter(pawn, transporter));
}
}
return(null);
}
protected override Job TryGiveJob(Pawn pawn)
{
int transportersGroup = pawn.mindState.duty.transportersGroup;
TransporterUtility.GetTransportersInGroup(transportersGroup, pawn.Map, JobGiver_EnterTransporter.tmpTransporters);
CompTransporter compTransporter = this.FindMyTransporter(JobGiver_EnterTransporter.tmpTransporters, pawn);
if (compTransporter != null && pawn.CanReserveAndReach(compTransporter.parent, PathEndMode.Touch, Danger.Deadly, 1, -1, null, false))
{
return(new Job(JobDefOf.EnterTransporter, compTransporter.parent));
}
return(null);
}
private void CancelLoadingProcess()
{
List <Thing> list = this.lord.Map.listerThings.ThingsInGroup(ThingRequestGroup.Transporter);
for (int i = 0; i < list.Count; i++)
{
CompTransporter compTransporter = list[i].TryGetComp <CompTransporter>();
if (compTransporter.groupID == this.transportersGroup)
{
compTransporter.CancelLoad();
break;
}
}
}
public void TryLaunch(int destinationTile, TransportPodsArrivalAction arrivalAction)
{
if (!parent.Spawned)
{
Log.Error(string.Concat("Tried to launch ", parent, ", but it's unspawned."));
return;
}
List <CompTransporter> transportersInGroup = TransportersInGroup;
if (transportersInGroup == null)
{
Log.Error(string.Concat("Tried to launch ", parent, ", but it's not in any group."));
}
else
{
if (!LoadingInProgressOrReadyToLaunch || !AllInGroupConnectedToFuelingPort || !AllFuelingPortSourcesInGroupHaveAnyFuel)
{
return;
}
Map map = parent.Map;
int num = Find.WorldGrid.TraversalDistanceBetween(map.Tile, destinationTile);
CompShuttle compShuttle = parent.TryGetComp <CompShuttle>();
if (num <= MaxLaunchDistance || (compShuttle != null && compShuttle.IsMissionShuttle))
{
Transporter.TryRemoveLord(map);
int groupID = Transporter.groupID;
float amount = Mathf.Max(FuelNeededToLaunchAtDist(num), 1f);
compShuttle?.SendLaunchedSignals(transportersInGroup);
for (int i = 0; i < transportersInGroup.Count; i++)
{
CompTransporter compTransporter = transportersInGroup[i];
compTransporter.Launchable.FuelingPortSource?.TryGetComp <CompRefuelable>().ConsumeFuel(amount);
ThingOwner directlyHeldThings = compTransporter.GetDirectlyHeldThings();
ActiveDropPod activeDropPod = (ActiveDropPod)ThingMaker.MakeThing(ThingDefOf.ActiveDropPod);
activeDropPod.Contents = new ActiveDropPodInfo();
activeDropPod.Contents.innerContainer.TryAddRangeOrTransfer(directlyHeldThings, canMergeWithExistingStacks: true, destroyLeftover: true);
DropPodLeaving obj = (DropPodLeaving)SkyfallerMaker.MakeSkyfaller(Props.skyfallerLeaving ?? ThingDefOf.DropPodLeaving, activeDropPod);
obj.groupID = groupID;
obj.destinationTile = destinationTile;
obj.arrivalAction = arrivalAction;
obj.worldObjectDef = ((compShuttle != null) ? WorldObjectDefOf.TravelingShuttle : WorldObjectDefOf.TravelingTransportPods);
compTransporter.CleanUpLoadingVars(map);
compTransporter.parent.Destroy();
GenSpawn.Spawn(obj, compTransporter.parent.Position, map);
}
CameraJumper.TryHideWorld();
}
}
}
public static void GetTransportersInGroup(int transportersGroup, Map map, List <CompTransporter> outTransporters)
{
outTransporters.Clear();
if (transportersGroup >= 0)
{
List <Thing> list = map.listerThings.ThingsInGroup(ThingRequestGroup.Transporter);
for (int i = 0; i < list.Count; i++)
{
CompTransporter compTransporter = list[i].TryGetComp <CompTransporter>();
if (compTransporter.groupID == transportersGroup)
{
outTransporters.Add(compTransporter);
}
}
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TransporterInd);
this.FailOn(() => !Transporter.LoadingInProgressOrReadyToLaunch);
yield return(Toils_Goto.GotoThing(TransporterInd, PathEndMode.Touch));
Toil toil = new Toil();
toil.initAction = delegate
{
CompTransporter transporter = Transporter;
pawn.DeSpawn();
transporter.GetDirectlyHeldThings().TryAdd(pawn);
};
yield return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(this.TransporterInd);
this.FailOn(() => !this.$this.Transporter.LoadingInProgressOrReadyToLaunch);
yield return(Toils_Goto.GotoThing(this.TransporterInd, PathEndMode.Touch));
yield return(new Toil
{
initAction = delegate
{
CompTransporter transporter = this.$this.Transporter;
this.$this.pawn.DeSpawn();
transporter.GetDirectlyHeldThings().TryAdd(this.$this.pawn, true);
}
});
}
public void TryLaunch(int destinationTile, TransportPodsArrivalAction arrivalAction)
{
if (!this.parent.Spawned)
{
Log.Error("Tried to launch " + this.parent + ", but it's unspawned.", false);
}
else
{
List <CompTransporter> transportersInGroup = this.TransportersInGroup;
if (transportersInGroup == null)
{
Log.Error("Tried to launch " + this.parent + ", but it's not in any group.", false);
}
else if (this.LoadingInProgressOrReadyToLaunch && this.AllInGroupConnectedToFuelingPort && this.AllFuelingPortSourcesInGroupHaveAnyFuel)
{
Map map = this.parent.Map;
int num = Find.WorldGrid.TraversalDistanceBetween(map.Tile, destinationTile, true, int.MaxValue);
if (num <= this.MaxLaunchDistance)
{
this.Transporter.TryRemoveLord(map);
int groupID = this.Transporter.groupID;
float amount = Mathf.Max(CompLaunchable.FuelNeededToLaunchAtDist((float)num), 1f);
for (int i = 0; i < transportersInGroup.Count; i++)
{
CompTransporter compTransporter = transportersInGroup[i];
Building fuelingPortSource = compTransporter.Launchable.FuelingPortSource;
if (fuelingPortSource != null)
{
fuelingPortSource.TryGetComp <CompRefuelable>().ConsumeFuel(amount);
}
ThingOwner directlyHeldThings = compTransporter.GetDirectlyHeldThings();
ActiveDropPod activeDropPod = (ActiveDropPod)ThingMaker.MakeThing(ThingDefOf.ActiveDropPod, null);
activeDropPod.Contents = new ActiveDropPodInfo();
activeDropPod.Contents.innerContainer.TryAddRangeOrTransfer(directlyHeldThings, true, true);
DropPodLeaving dropPodLeaving = (DropPodLeaving)SkyfallerMaker.MakeSkyfaller(ThingDefOf.DropPodLeaving, activeDropPod);
dropPodLeaving.groupID = groupID;
dropPodLeaving.destinationTile = destinationTile;
dropPodLeaving.arrivalAction = arrivalAction;
compTransporter.CleanUpLoadingVars(map);
compTransporter.parent.Destroy(DestroyMode.Vanish);
GenSpawn.Spawn(dropPodLeaving, compTransporter.parent.Position, map, WipeMode.Vanish);
}
CameraJumper.TryHideWorld();
}
}
}
}
protected override Job TryGiveJob(Pawn pawn)
{
int transportersGroup = pawn.mindState.duty.transportersGroup;
TransporterUtility.GetTransportersInGroup(transportersGroup, pawn.Map, JobGiver_EnterTransporter.tmpTransporters);
CompTransporter compTransporter = this.FindMyTransporter(JobGiver_EnterTransporter.tmpTransporters, pawn);
Job result;
if (compTransporter == null || !pawn.CanReach(compTransporter.parent, PathEndMode.Touch, Danger.Deadly, false, TraverseMode.ByPawn))
{
result = null;
}
else
{
result = new Job(JobDefOf.EnterTransporter, compTransporter.parent);
}
return(result);
}
protected override void Enable(SignalArgs receivedArgs)
{
base.Enable(receivedArgs);
CompTransporter compTransporter = shuttle.TryGetComp <CompTransporter>();
if (lendColonistsToFaction != null && compTransporter != null)
{
foreach (Thing item in (IEnumerable <Thing>)compTransporter.innerContainer)
{
Pawn pawn;
if ((pawn = (item as Pawn)) != null && pawn.IsFreeColonist)
{
lentColonists.Add(pawn);
}
}
returnColonistsOnTick = GenTicks.TicksGame + returnLentColonistsInTicks;
}
}
private static Thing FindThingToLoad(Pawn p, CompTransporter transporter)
{
LoadTransportersJobUtility.neededThings.Clear();
List <TransferableOneWay> leftToLoad = transporter.leftToLoad;
if (leftToLoad != null)
{
for (int i = 0; i < leftToLoad.Count; i++)
{
TransferableOneWay transferableOneWay = leftToLoad[i];
if (transferableOneWay.CountToTransfer > 0)
{
for (int j = 0; j < transferableOneWay.things.Count; j++)
{
LoadTransportersJobUtility.neededThings.Add(transferableOneWay.things[j]);
}
}
}
}
Thing result;
if (!LoadTransportersJobUtility.neededThings.Any <Thing>())
{
result = null;
}
else
{
Thing thing = GenClosest.ClosestThingReachable(p.Position, p.Map, ThingRequest.ForGroup(ThingRequestGroup.HaulableEver), PathEndMode.Touch, TraverseParms.For(p, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, (Thing x) => LoadTransportersJobUtility.neededThings.Contains(x) && p.CanReserve(x, 1, -1, null, false), null, 0, -1, false, RegionType.Set_Passable, false);
if (thing == null)
{
foreach (Thing thing2 in LoadTransportersJobUtility.neededThings)
{
Pawn pawn = thing2 as Pawn;
if (pawn != null && (!pawn.IsColonist || pawn.Downed) && !pawn.inventory.UnloadEverything && p.CanReserveAndReach(pawn, PathEndMode.Touch, Danger.Deadly, 1, -1, null, false))
{
return(pawn);
}
}
}
LoadTransportersJobUtility.neededThings.Clear();
result = thing;
}
return(result);
}
public bool MoveNext()
{
uint num = (uint)this.$PC;
this.$PC = -1;
switch (num)
{
case 0u:
this.FailOnDespawnedOrNull(this.TransporterInd);
this.FailOn(() => !base.Transporter.LoadingInProgressOrReadyToLaunch);
this.$current = Toils_Goto.GotoThing(this.TransporterInd, PathEndMode.Touch);
if (!this.$disposing)
{
this.$PC = 1;
}
return(true);
case 1u:
{
Toil enter = new Toil();
enter.initAction = delegate()
{
CompTransporter transporter = base.Transporter;
this.pawn.DeSpawn(DestroyMode.Vanish);
transporter.GetDirectlyHeldThings().TryAdd(this.pawn, true);
};
this.$current = enter;
if (!this.$disposing)
{
this.$PC = 2;
}
return(true);
}
case 2u:
this.$PC = -1;
break;
}
return(false);
}
public static void SendAway(Thing shuttle, bool dropEverything)
{
CompShuttle compShuttle = shuttle.TryGetComp <CompShuttle>();
CompTransporter compTransporter = shuttle.TryGetComp <CompTransporter>();
if (shuttle.Spawned)
{
if (dropEverything && compTransporter.LoadingInProgressOrReadyToLaunch)
{
compTransporter.CancelLoad();
}
if (!compTransporter.LoadingInProgressOrReadyToLaunch)
{
TransporterUtility.InitiateLoading(Gen.YieldSingle(compTransporter));
}
compShuttle.Send();
}
else if (shuttle.ParentHolder is Thing && ((Thing)shuttle.ParentHolder).def == ThingDefOf.ShuttleIncoming)
{
compShuttle.leaveASAP = true;
}
}
public override void Notify_QuestSignalReceived(Signal signal)
{
base.Notify_QuestSignalReceived(signal);
if (!(signal.tag == inSignal) || shuttle == null)
{
return;
}
pawns.RemoveAll((Pawn x) => x.Destroyed);
items.RemoveAll((Thing x) => x.Destroyed);
for (int i = 0; i < pawns.Count; i++)
{
if (pawns[i].IsWorldPawn())
{
Find.WorldPawns.RemovePawn(pawns[i]);
}
}
CompTransporter compTransporter = shuttle.TryGetComp <CompTransporter>();
compTransporter.innerContainer.TryAddRangeOrTransfer(pawns);
compTransporter.innerContainer.TryAddRangeOrTransfer(items);
items.Clear();
}
protected override void DoItemsLists(Rect inRect, ref float curY)
{
CompTransporter transporter = Transporter;
Rect position = new Rect(0f, curY, (inRect.width - 10f) / 2f, inRect.height);
Text.Font = GameFont.Small;
bool flag = false;
float curY2 = 0f;
GUI.BeginGroup(position);
Widgets.ListSeparator(ref curY2, position.width, "ItemsToLoad".Translate());
if (transporter.leftToLoad != null)
{
for (int i = 0; i < transporter.leftToLoad.Count; i++)
{
TransferableOneWay t = transporter.leftToLoad[i];
if (t.CountToTransfer > 0 && t.HasAnyThing)
{
flag = true;
DoThingRow(t.ThingDef, t.CountToTransfer, t.things, position.width, ref curY2, delegate(int x)
{
OnDropToLoadThing(t, x);
});
}
}
}
if (!flag)
{
Widgets.NoneLabel(ref curY2, position.width);
}
GUI.EndGroup();
Rect inRect2 = new Rect((inRect.width + 10f) / 2f, curY, (inRect.width - 10f) / 2f, inRect.height);
float curY3 = 0f;
base.DoItemsLists(inRect2, ref curY3);
curY += Mathf.Max(curY2, curY3);
}
public override Job JobOnThing(Pawn pawn, Thing t, bool forced = false)
{
CompTransporter transporter = t.TryGetComp <CompTransporter>();
return(LoadTransportersJobUtility.JobOnTransporter(pawn, transporter));
}
public void Send()
{
if (!ModLister.RoyaltyInstalled)
{
Log.ErrorOnce("Shuttle is a Royalty-specific game system. If you want to use this code please check ModLister.RoyaltyInstalled before calling it. See rules on the Ludeon forum for more info.", 8811221);
}
else
{
if (sending)
{
return;
}
if (!parent.Spawned)
{
Log.Error("Tried to send " + parent + ", but it's unspawned.");
return;
}
List <CompTransporter> transportersInGroup = TransportersInGroup;
if (transportersInGroup == null)
{
Log.Error("Tried to send " + parent + ", but it's not in any group.");
}
else
{
if (!LoadingInProgressOrReadyToLaunch)
{
return;
}
if (!AllRequiredThingsLoaded)
{
if (dropEverythingIfUnsatisfied)
{
Transporter.CancelLoad();
}
else if (dropNonRequiredIfUnsatisfied)
{
for (int i = 0; i < transportersInGroup.Count; i++)
{
for (int num = transportersInGroup[i].innerContainer.Count - 1; num >= 0; num--)
{
Thing thing = transportersInGroup[i].innerContainer[num];
Pawn pawn;
if (!IsRequired(thing) && (requiredColonistCount <= 0 || (pawn = (thing as Pawn)) == null || !pawn.IsColonist))
{
transportersInGroup[i].innerContainer.TryDrop(thing, ThingPlaceMode.Near, out Thing _);
}
}
}
}
}
sending = true;
bool allRequiredThingsLoaded = AllRequiredThingsLoaded;
Map map = parent.Map;
Transporter.TryRemoveLord(map);
string signalPart = allRequiredThingsLoaded ? "SentSatisfied" : "SentUnsatisfied";
for (int j = 0; j < transportersInGroup.Count; j++)
{
QuestUtility.SendQuestTargetSignals(transportersInGroup[j].parent.questTags, signalPart, transportersInGroup[j].parent.Named("SUBJECT"), transportersInGroup[j].innerContainer.ToList().Named("SENT"));
}
List <Pawn> list = new List <Pawn>();
for (int k = 0; k < transportersInGroup.Count; k++)
{
CompTransporter compTransporter = transportersInGroup[k];
for (int num2 = transportersInGroup[k].innerContainer.Count - 1; num2 >= 0; num2--)
{
Pawn pawn2 = transportersInGroup[k].innerContainer[num2] as Pawn;
if (pawn2 != null)
{
if (pawn2.IsColonist && !requiredPawns.Contains(pawn2))
{
list.Add(pawn2);
}
pawn2.ExitMap(allowedToJoinOrCreateCaravan: false, Rot4.Invalid);
}
}
compTransporter.innerContainer.ClearAndDestroyContentsOrPassToWorld();
Thing newThing = ThingMaker.MakeThing(ThingDefOf.ShuttleLeaving);
compTransporter.CleanUpLoadingVars(map);
compTransporter.parent.Destroy(DestroyMode.QuestLogic);
GenSpawn.Spawn(newThing, compTransporter.parent.Position, map);
}
if (list.Count != 0)
{
for (int l = 0; l < transportersInGroup.Count; l++)
{
QuestUtility.SendQuestTargetSignals(transportersInGroup[l].parent.questTags, "SentWithExtraColonists", transportersInGroup[l].parent.Named("SUBJECT"), list.Named("SENTCOLONISTS"));
}
}
sending = false;
}
}
}
public static bool HasJobOnTransporter(Pawn pawn, CompTransporter transporter)
{
return(!transporter.parent.IsForbidden(pawn) && transporter.AnythingLeftToLoad && pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation) && pawn.CanReach(transporter.parent, PathEndMode.Touch, pawn.NormalMaxDanger(), false, TraverseMode.ByPawn) && LoadTransportersJobUtility.FindThingToLoad(pawn, transporter).Thing != null);
}
public static ThingCount FindThingToLoad(Pawn p, CompTransporter transporter)
{
neededThings.Clear();
List <TransferableOneWay> leftToLoad = transporter.leftToLoad;
tmpAlreadyLoading.Clear();
if (leftToLoad != null)
{
List <Pawn> allPawnsSpawned = transporter.Map.mapPawns.AllPawnsSpawned;
for (int i = 0; i < allPawnsSpawned.Count; i++)
{
if (allPawnsSpawned[i] != p && allPawnsSpawned[i].CurJobDef == JobDefOf.HaulToTransporter)
{
JobDriver_HaulToTransporter jobDriver_HaulToTransporter = (JobDriver_HaulToTransporter)allPawnsSpawned[i].jobs.curDriver;
if (jobDriver_HaulToTransporter.Container == transporter.parent)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatchingDesperate(jobDriver_HaulToTransporter.ThingToCarry, leftToLoad, TransferAsOneMode.PodsOrCaravanPacking);
if (transferableOneWay != null)
{
int value = 0;
if (tmpAlreadyLoading.TryGetValue(transferableOneWay, out value))
{
tmpAlreadyLoading[transferableOneWay] = value + jobDriver_HaulToTransporter.initialCount;
}
else
{
tmpAlreadyLoading.Add(transferableOneWay, jobDriver_HaulToTransporter.initialCount);
}
}
}
}
}
for (int j = 0; j < leftToLoad.Count; j++)
{
TransferableOneWay transferableOneWay2 = leftToLoad[j];
if (!tmpAlreadyLoading.TryGetValue(leftToLoad[j], out int value2))
{
value2 = 0;
}
if (transferableOneWay2.CountToTransfer - value2 > 0)
{
for (int k = 0; k < transferableOneWay2.things.Count; k++)
{
neededThings.Add(transferableOneWay2.things[k]);
}
}
}
}
if (!neededThings.Any())
{
tmpAlreadyLoading.Clear();
return(default(ThingCount));
}
Thing thing = GenClosest.ClosestThingReachable(p.Position, p.Map, ThingRequest.ForGroup(ThingRequestGroup.HaulableEver), PathEndMode.Touch, TraverseParms.For(p), 9999f, (Thing x) => neededThings.Contains(x) && p.CanReserve(x));
if (thing == null)
{
foreach (Thing neededThing in neededThings)
{
Pawn pawn = neededThing as Pawn;
if (pawn != null && (!pawn.IsColonist || pawn.Downed) && !pawn.inventory.UnloadEverything && p.CanReserveAndReach(pawn, PathEndMode.Touch, Danger.Deadly))
{
neededThings.Clear();
tmpAlreadyLoading.Clear();
return(new ThingCount(pawn, 1));
}
}
}
neededThings.Clear();
if (thing != null)
{
TransferableOneWay transferableOneWay3 = null;
for (int l = 0; l < leftToLoad.Count; l++)
{
if (leftToLoad[l].things.Contains(thing))
{
transferableOneWay3 = leftToLoad[l];
break;
}
}
if (!tmpAlreadyLoading.TryGetValue(transferableOneWay3, out int value3))
{
value3 = 0;
}
tmpAlreadyLoading.Clear();
return(new ThingCount(thing, Mathf.Min(transferableOneWay3.CountToTransfer - value3, thing.stackCount)));
}
tmpAlreadyLoading.Clear();
return(default(ThingCount));
}
