protected override IEnumerable <Toil> MakeNewToils()
{
rotateToFace = Facing;
this.AddEndCondition(delegate
{
if (PreacherPawn.CurJob.def == CultsDefOf.Cults_ReflectOnWorship)
{
return(JobCondition.Succeeded);
}
else if (PreacherPawn.CurJob.def != CultsDefOf.Cults_HoldWorship)
{
return(JobCondition.Incompletable);
}
return(JobCondition.Ongoing);
});
this.EndOnDespawnedOrNull(Spot, JobCondition.Incompletable);
this.EndOnDespawnedOrNull(Build, JobCondition.Incompletable);
yield return(Toils_Reserve.Reserve(Spot, 1, -1));
Toil gotoPreacher;
if (this.TargetC.HasThing)
{
gotoPreacher = Toils_Goto.GotoThing(Spot, PathEndMode.OnCell);
}
else
{
gotoPreacher = Toils_Goto.GotoCell(Spot, PathEndMode.OnCell);
}
yield return(gotoPreacher);
Toil altarToil = new Toil();
altarToil.defaultCompleteMode = ToilCompleteMode.Delay;
altarToil.defaultDuration = CultUtility.ritualDuration;
altarToil.AddPreTickAction(() =>
{
this.pawn.GainComfortFromCellIfPossible();
this.pawn.rotationTracker.FaceCell(TargetB.Cell);
if (PreacherPawn.CurJob.def != CultsDefOf.Cults_HoldWorship)
{
this.ReadyForNextToil();
}
});
yield return(altarToil);
yield return(Toils_Jump.JumpIf(altarToil, () => PreacherPawn.CurJob.def == CultsDefOf.Cults_HoldWorship));
yield return(Toils_Reserve.Release(Spot));
this.AddFinishAction(() =>
{
//When the ritual is finished -- then let's give the thoughts
if (Altar.currentWorshipState == Building_SacrificialAltar.WorshipState.finishing ||
Altar.currentWorshipState == Building_SacrificialAltar.WorshipState.finished)
{
CultUtility.AttendWorshipTickCheckEnd(PreacherPawn, this.pawn);
Cthulhu.Utility.DebugReport("Called end tick check");
}
pawn.ClearAllReservations();
//if (this.TargetC.HasThing && TargetC.Thing is Thing t)
//{
// if (pawn.Res Map.reservationManager.IsReserved(this.job.targetC.Thing, Faction.OfPlayer))
// Map.reservationManager.Release(this.job.targetC.Thing, pawn);
//}
//else
//{
// if (Map.reservationManager.IsReserved(this.job.targetC.Cell, Faction.OfPlayer))
// Map.reservationManager.Release(this.job.targetC.Cell, this.pawn);
//}
});
yield break;
}
public bool MoveNext()
{
uint num = (uint)this.$PC;
this.$PC = -1;
switch (num)
{
case 0u:
if (base.FromBed)
{
this.KeepLyingDown(TargetIndex.A);
this.$current = Toils_Bed.ClaimBedIfNonMedical(TargetIndex.A, TargetIndex.None);
if (!this.$disposing)
{
this.$PC = 1;
}
return(true);
}
this.$current = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell);
if (!this.$disposing)
{
this.$PC = 3;
}
return(true);
case 1u:
this.$current = Toils_Bed.GotoBed(TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 2;
}
return(true);
case 2u:
relax = Toils_LayDown.LayDown(TargetIndex.A, true, false, true, true);
relax.AddFailCondition(() => !this.pawn.Awake());
break;
case 3u:
relax = new Toil();
relax.initAction = delegate()
{
this.faceDir = ((!this.job.def.faceDir.IsValid) ? Rot4.Random : this.job.def.faceDir);
};
relax.handlingFacing = true;
break;
case 4u:
this.$PC = -1;
return(false);
default:
return(false);
}
relax.defaultCompleteMode = ToilCompleteMode.Delay;
relax.defaultDuration = this.job.def.joyDuration;
relax.AddPreTickAction(delegate
{
if (this.faceDir.IsValid)
{
this.pawn.rotationTracker.FaceCell(this.pawn.Position + this.faceDir.FacingCell);
}
this.pawn.GainComfortFromCellIfPossible();
JoyUtility.JoyTickCheckEnd(this.pawn, JoyTickFullJoyAction.EndJob, 1f, null);
});
this.$current = relax;
if (!this.$disposing)
{
this.$PC = 4;
}
return(true);
}
private IEnumerable <Toil> PrepareToIngestToils_NonToolUser()
{
yield return(ReserveFoodIfWillIngestWholeStack());
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
}
public override IEnumerable <Toil> MakeNewToils()
{
var ZTracker = ZUtils.ZTracker;
if (pawn.Map == this.job.targetA.Thing.Map && pawn.Map == ZTracker.jobTracker[pawn].targetDest.Map)
{
ZLogger.Message("pawn map and thing map and dest map are same, yield breaking in JobDriver_HaulThingToDest");
yield break;
}
yield return(new Toil
{
initAction = delegate()
{
this.savedThing = this.job.targetA.Thing;
}
});
Toil reserveItem = Toils_Reserve.Reserve(TargetIndex.A);
ZLogger.Message($"JobDriver HaulThingToDest1 About to call findRouteWithStairs, with pawn {GetActor()}, dest { TargetA.Thing}, instance {this}");
foreach (var toil in Toils_ZLevels.GoToMap(GetActor(), new TargetInfo(TargetA.Thing).Map, this))
{
yield return(toil);
}
yield return(new Toil
{
initAction = delegate()
{
ZLogger.Message("JobDriver_HaulThingToDest 1: " + pawn + " trying to reserve: " + TargetA, true);
}
});
Toil toilGoto = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch);
yield return(reserveItem.FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(new Toil
{
initAction = delegate()
{
ZLogger.Message("JobDriver_HaulThingToDest 1: " + pawn + " reserved: " + TargetA, true);
}
});
yield return(toilGoto);
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, putRemainderInQueue: false, subtractNumTakenFromJobCount: true).FailOnDestroyedNullOrForbidden(TargetIndex.A));
if (job.haulOpportunisticDuplicates)
{
yield return(new Toil
{
initAction = delegate()
{
ZLogger.Message("2: " + pawn + " trying to reserve other things: " + TargetA, true);
}
});
yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveItem, TargetIndex.A, TargetIndex.None, takeFromValidStorage: true));
yield return(new Toil
{
initAction = delegate()
{
ZLogger.Message("2: " + pawn + " reserved other things: " + TargetA, true);
}
});
}
yield return(new Toil
{
initAction = delegate()
{
try
{
if (ZTracker.jobTracker.ContainsKey(pawn))
{
if (ZTracker.jobTracker[pawn].mainJob.targetA.Thing != null &&
ZTracker.jobTracker[pawn].mainJob.targetA.Thing == this.savedThing &&
ZTracker.jobTracker[pawn].mainJob.targetA.Thing != TargetA.Thing)
{
ZTracker.jobTracker[pawn].mainJob.targetA = new LocalTargetInfo(TargetA.Thing);
}
else if (ZTracker.jobTracker[pawn].mainJob.targetB.Thing != null &&
ZTracker.jobTracker[pawn].mainJob.targetB.Thing == this.savedThing &&
ZTracker.jobTracker[pawn].mainJob.targetB.Thing != TargetA.Thing)
{
ZTracker.jobTracker[pawn].mainJob.targetB = new LocalTargetInfo(TargetA.Thing);
}
try
{
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueA.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueA[i];
if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetA.Thing)
{
ZTracker.jobTracker[pawn].mainJob.targetQueueA[i] = new LocalTargetInfo(TargetA.Thing);
}
}
}
catch { }
try
{
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetA.Thing)
{
if (ZTracker.jobTracker[pawn].mainJob.targetQueueB[i].Thing.stackCount == 0)
{
ZTracker.jobTracker[pawn].mainJob.targetQueueB[i] = new LocalTargetInfo(TargetA.Thing);
ZTracker.jobTracker[pawn].mainJob.countQueue[i] = TargetA.Thing.stackCount;
break;
}
else
{
if (ZTracker.jobTracker[pawn].mainJob.targetQueueB
.Where(x => x.Thing == TargetA.Thing).Count() == 0)
{
var newTarget = new LocalTargetInfo(TargetA.Thing);
ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.Add(newTarget);
ZTracker.jobTracker[this.pawn].mainJob.countQueue.Add(newTarget.Thing.stackCount);
int ind = ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.FirstIndexOf(x => x.Thing == this.savedThing);
ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.RemoveAt(ind);
ZTracker.jobTracker[this.pawn].mainJob.countQueue.RemoveAt(ind);
break;
}
}
}
}
}
catch { }
}
}
catch (Exception ex)
{
Log.Error("Z-Tracker produced an error in JobDriver_HaulThingToStairs class. Report about it to devs. Error: " + ex);
}
}
});
ZLogger.Message($"JobDriver HaulThingToDest 2About to call findRouteWithStairs, with pawn {GetActor()}, dest {ZTracker.jobTracker[pawn].targetDest}, instance {this}");
foreach (var toil in Toils_ZLevels.GoToMap(GetActor(), ZTracker.jobTracker[pawn].targetDest.Map, this))
{
yield return(toil);
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedNullOrForbidden(TargetIndex.B);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Reserve.ReserveQueue(TargetIndex.A, 1));
yield return(Toils_Reserve.Reserve(TargetIndex.B, 10, 1));
yield return(Toils_Reserve.ReserveQueue(TargetIndex.B, 1));
Toil toil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
yield return(toil);
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true));
yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toil, TargetIndex.A));
Toil toil2 = Toils_Goto.Goto(TargetIndex.B, PathEndMode.ClosestTouch);
yield return(toil2);
Toil toil3 = new Toil();
toil3.defaultCompleteMode = ToilCompleteMode.Delay;
toil3.defaultDuration = 500;
toil3.WithProgressBarToilDelay(TargetIndex.A, false, -0.5f);
yield return(toil3);
yield return(new Toil
{
initAction = delegate
{
ShipBase ship = (ShipBase)TargetB.Thing;
ThingWithComps thing = (ThingWithComps)TargetA.Thing;
CompShipWeapon comp = thing.TryGetComp <CompShipWeapon>();
Action action = delegate
{
if (comp != null)
{
switch (comp.SProps.weaponSystemType)
{
case WeaponSystemType.LightCaliber:
{
if (ship.TryInstallTurret(comp))
{
this.pawn.carryTracker.GetDirectlyHeldThings().Remove(TargetA.Thing);
ship.weaponsToInstall.Remove(comp.slotToInstall);
}
break;
}
case WeaponSystemType.HeavyCaliber:
{
break;
}
case WeaponSystemType.Bombing:
{
WeaponSystemShipBomb bomb = thing as WeaponSystemShipBomb;
if (ship.TryInstallPayload(bomb, comp))
{
this.pawn.carryTracker.GetDirectlyHeldThings().Remove(TargetA.Thing);
ship.weaponsToInstall.Remove(comp.slotToInstall);
}
break;
}
}
}
};
action();
},
defaultCompleteMode = ToilCompleteMode.Instant
});
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (ZTracker.jobTracker.ContainsKey(pawn))
{
this.savedThing = this.TargetB.Thing;
}
}
});
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnBurningImmobile(TargetIndex.B);
this.FailOnForbidden(TargetIndex.B);
yield return(new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (ZTracker.jobTracker[pawn].mainJob.count != -1)
{
this.pawn.jobs.curJob.count = ZTracker.jobTracker[pawn].mainJob.count;
}
else if (this.pawn.jobs.curJob.count == -1)
{
this.pawn.jobs.curJob.count = Mathf.Min(TargetB.Thing.stackCount, (int)(pawn.GetStatValue(StatDefOf.CarryingCapacity, true) / TargetB.Thing.def.VolumePerUnit));
if (this.pawn.jobs.curJob.count < 0)
{
this.pawn.jobs.curJob.count = TargetB.Thing.stackCount;
}
}
ZLogger.Message(this.pawn + " haul count: " + this.pawn.jobs.curJob.count);
}
});
Toil reserveItem = Toils_Reserve.Reserve(TargetIndex.B);
yield return(reserveItem);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOnSomeonePhysicallyInteracting(TargetIndex.B));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, putRemainderInQueue: false, subtractNumTakenFromJobCount: true).FailOnDestroyedNullOrForbidden(TargetIndex.B));
yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveItem, TargetIndex.B, TargetIndex.None, takeFromValidStorage: true));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell));
//Toil reserveTargetA = Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null);
//yield return reserveTargetA;
//yield return Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch);
//yield return Toils_Haul.StartCarryThing(TargetIndex.B, false, true, false);
//yield return Toils_Haul.CheckForGetOpportunityDuplicate(reserveTargetA, TargetIndex.B, TargetIndex.A,
// false, null);
//Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.A);
//yield return carryToCell;
//yield return Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell);
Toil useStairs = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(useStairs, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(useStairs, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(useStairs, TargetIndex.A, PathEndMode.OnCell);
//yield return new Toil
//{
// initAction = delegate () {
// ZLogger.Message("this.pawn.CanReachImmediate(TargetA.Thing, PathEndMode.OnCell): "
// + this.pawn.CanReachImmediate(TargetA.Thing, PathEndMode.OnCell), true);
// }
//};
yield return(useStairs);
yield return(new Toil
{
initAction = delegate()
{
try
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (ZTracker.jobTracker.ContainsKey(pawn))
{
if (ZTracker.jobTracker[pawn].mainJob.targetA.Thing != null &&
ZTracker.jobTracker[pawn].mainJob.targetA.Thing == this.savedThing &&
ZTracker.jobTracker[pawn].mainJob.targetA.Thing != TargetB.Thing)
{
ZLogger.Message("1 Pawns carried thing not the same: " + ZTracker.jobTracker[pawn].mainJob.targetA.Thing);
ZTracker.jobTracker[pawn].mainJob.targetA = new LocalTargetInfo(TargetB.Thing);
}
else if (ZTracker.jobTracker[pawn].mainJob.targetB.Thing != null &&
ZTracker.jobTracker[pawn].mainJob.targetB.Thing == this.savedThing &&
ZTracker.jobTracker[pawn].mainJob.targetB.Thing != TargetB.Thing)
{
ZLogger.Message("2 Pawns carried thing not the same: " + ZTracker.jobTracker[pawn].mainJob.targetB.Thing);
ZTracker.jobTracker[pawn].mainJob.targetB = new LocalTargetInfo(TargetB.Thing);
}
try
{
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueA.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueA[i];
if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetB.Thing)
{
ZLogger.Message("3 Pawns carried thing not the same: " + target.Thing);
ZTracker.jobTracker[pawn].mainJob.targetQueueA[i] = new LocalTargetInfo(TargetB.Thing);
}
}
}
catch { }
try
{
try
{
ZLogger.Message("--------------------------");
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
ZLogger.Message("JobDriver_HaulThingToStairs BEFORE job.targetQueueB: " + target.Thing);
ZLogger.Message("JobDriver_HaulThingToStairs BEFORE job.targetQueueB.Map: " + target.Thing.Map);
ZLogger.Message("JobDriver_HaulThingToStairs BEFORE job.targetQueueB.stackCount: " + target.Thing.stackCount);
ZLogger.Message("JobDriver_HaulThingToStairs BEFORE job.targetQueueB.countQueue: " + ZTracker.jobTracker[pawn].mainJob.countQueue[i]);
}
}
catch { }
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetB.Thing)
{
ZLogger.Message("4 Pawns carried thing not the same");
ZLogger.Message("4 Pawns target.Thing: " + target.Thing);
ZLogger.Message("4 Pawns target.Thing.Map: " + target.Thing.Map);
ZLogger.Message("4 Pawns this.savedThing: " + this.savedThing);
ZLogger.Message("4 Pawns this.savedThing.Map: " + this.savedThing.Map);
ZLogger.Message("4 Pawns TargetB.Thing: " + TargetB.Thing);
ZLogger.Message("4 Pawns TargetB.Thing.Map: " + TargetB.Thing.Map);
//ZLogger.Message("Replacing " + ZTracker.jobTracker[this.pawn].mainJob.targetQueueB[i] + " by " + TargetB);
//
//ZTracker.jobTracker[pawn].mainJob.targetQueueB[i] = new LocalTargetInfo(TargetB.Thing);
//ZTracker.jobTracker[pawn].mainJob.countQueue[i] = TargetB.Thing.stackCount;
//
if (ZTracker.jobTracker[pawn].mainJob.targetQueueB[i].Thing.stackCount == 0)
{
ZTracker.jobTracker[pawn].mainJob.targetQueueB[i] = new LocalTargetInfo(TargetB.Thing);
ZTracker.jobTracker[pawn].mainJob.countQueue[i] = TargetB.Thing.stackCount;
ZLogger.Message("Altering " + ZTracker.jobTracker[this.pawn].mainJob);
break;
}
else
{
if (ZTracker.jobTracker[pawn].mainJob.targetQueueB
.Where(x => x.Thing == TargetB.Thing).Count() == 0)
{
var newTarget = new LocalTargetInfo(TargetB.Thing);
ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.Add(newTarget);
ZTracker.jobTracker[this.pawn].mainJob.countQueue.Add(newTarget.Thing.stackCount);
ZLogger.Message("2 Adding " + newTarget + " to " + ZTracker.jobTracker[this.pawn].mainJob);
int ind = ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.FirstIndexOf(x => x.Thing == this.savedThing);
ZLogger.Message("2 Removing " + ZTracker.jobTracker[this.pawn].mainJob.targetQueueB[ind] + " from " + ZTracker.jobTracker[this.pawn].mainJob);
ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.RemoveAt(ind);
ZTracker.jobTracker[this.pawn].mainJob.countQueue.RemoveAt(ind);
break;
}
else
{
ZLogger.Message("Cant add " + TargetB.Thing + " to " + ZTracker.jobTracker[this.pawn].mainJob);
}
}
}
}
try
{
ZLogger.Message("--------------------------");
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
ZLogger.Message("JobDriver_HaulThingToStairs AFTER job.targetQueueB: " + target.Thing);
ZLogger.Message("JobDriver_HaulThingToStairs AFTER job.targetQueueB.Map: " + target.Thing.Map);
ZLogger.Message("JobDriver_HaulThingToStairs AFTER job.targetQueueB.stackCount: " + target.Thing.stackCount);
ZLogger.Message("JobDriver_HaulThingToStairs AFTER job.targetQueueB.countQueue: " + ZTracker.jobTracker[pawn].mainJob.countQueue[i]);
}
}
catch { }
}
catch { }
}
}
catch (Exception ex)
{
Log.Error("Z-Tracker produced an error in JobDriver_HaulThingToStairs class. Report about it to devs. Error: " + ex);
}
}
});
yield return(new Toil()
{
initAction = () =>
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
Pawn pawn = GetActor();
if (TargetA.Thing is Building_StairsUp stairsUp)
{
Map map = ZTracker.GetUpperLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateUpperLevel(this.pawn.Map, stairsUp.Position);
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
else
{
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
}
if (TargetA.Thing is Building_StairsDown stairsDown)
{
Map map = ZTracker.GetLowerLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateLowerLevel(this.pawn.Map, stairsDown.Position);
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map);
}
else
{
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map);
}
}
try
{
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
ZLogger.Message("JobDriver_HaulThingToStairs job.targetQueueB: " + target.Thing);
ZLogger.Message("JobDriver_HaulThingToStairs job.targetQueueB.Map: " + target.Thing.Map);
ZLogger.Message("JobDriver_HaulThingToStairs job.targetQueueB.stackCount: " + target.Thing.stackCount);
ZLogger.Message("JobDriver_HaulThingToStairs job.targetQueueB.countQueue: " + ZTracker.jobTracker[pawn].mainJob.countQueue[i]);
}
}
catch { }
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_General.Wait(10, TargetIndex.None));
yield return(new Toil
{
initAction = delegate()
{
Thing MarkedThing = CompUnloadChecker.getFirstMarked(pawn);
if (MarkedThing == null)
{
EndJobWith(JobCondition.Succeeded);
return;
}
//
if (pawn.equipment.Contains(MarkedThing))
{
Equipment = (ThingWithComps)MarkedThing;
Apparel = null;
}
else
{
Apparel = pawn.apparel.Contains(MarkedThing) ? (Apparel)MarkedThing : null;
Equipment = null;
}
ThingCount firstUnloadableThing = MarkedThing == null ? default(ThingCount) : new ThingCount(MarkedThing, MarkedThing.stackCount);
IntVec3 c;
if (!StoreUtility.TryFindStoreCellNearColonyDesperate(firstUnloadableThing.Thing, pawn, out c))
{
Thing thing;
pawn.inventory.innerContainer.TryDrop(firstUnloadableThing.Thing, ThingPlaceMode.Near, firstUnloadableThing.Count, out thing, null, null);
EndJobWith(JobCondition.Succeeded);
return;
}
job.SetTarget(TargetIndex.A, firstUnloadableThing.Thing);
job.SetTarget(TargetIndex.B, c);
countToDrop = firstUnloadableThing.Count;
}
});
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null));
yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.Touch).FailOnDestroyedOrNull(TargetIndex.A).FailOn(delegate() { return !stillUnloadable(pawn.CurJob.GetTarget(TargetIndex.A).Thing); }));
//preintiating unequip-delay
Toil unequip = new Toil
{
initAction = delegate()
{
if (Equipment != null)
{
pawn.equipment.TryTransferEquipmentToContainer(Equipment, pawn.inventory.innerContainer);
}
else if (Apparel != null)
{
ThingOwner <Apparel> a = Traverse.Create(pawn.apparel).Field("wornApparel").GetValue <ThingOwner <Apparel> >();
a.TryTransferToContainer(Apparel, pawn.inventory.innerContainer);
}
}
};
//if equiped, wait unequipping time
Toil wait = new Toil();
wait.initAction = delegate()
{
ticker = 0;
duration = Apparel != null?Apparel.GetStatValue(StatDefOf.EquipDelay, true) * 60f : Equipment != null ? 30 : 0;
pawn.pather.StopDead();
};
wait.tickAction = delegate()
{
if (ticker >= duration)
{
ReadyForNextToil();
}
ticker++;
};
wait.defaultCompleteMode = ToilCompleteMode.Never;
wait.WithProgressBar(TargetIndex.A, () => ticker / duration);
//unequip to inventory
yield return(wait);
yield return(unequip);
//hold in hands
yield return(new Toil
{
initAction = delegate()
{
Thing thing = job.GetTarget(TargetIndex.A).Thing;
CompUnloadChecker c = thing.TryGetComp <CompUnloadChecker>();
if (c == null || !c.ShouldUnload)
{
EndJobWith(JobCondition.Incompletable);
return;
}
if (thing == null || !pawn.inventory.innerContainer.Contains(thing))
{
EndJobWith(JobCondition.Incompletable);
return;
}
if (!pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation) || !thing.def.EverStorable(false))
{
pawn.inventory.innerContainer.TryDrop(thing, ThingPlaceMode.Near, countToDrop, out thing, null, null);
EndJobWith(JobCondition.Succeeded);
}
else
{
pawn.inventory.innerContainer.TryTransferToContainer(thing, pawn.carryTracker.innerContainer, countToDrop, out thing, true);
job.count = countToDrop;
job.SetTarget(TargetIndex.A, thing);
}
thing.SetForbidden(false, false);
}
});
Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B).FailOnDestroyedOrNull(TargetIndex.A).FailOn(delegate() { return(!stillUnloadable(pawn.CurJob.GetTarget(TargetIndex.A).Thing)); });
yield return(carryToCell);
yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true));
if (Sidearms_Utility.Active)
{
yield return new Toil
{
initAction = delegate()
{
Thing thing = job.GetTarget(TargetIndex.A).Thing;
Sidearms_Utility.ForgetSidearm(GetActor(), thing);
}
}
}
;
yield break;
}
public bool MoveNext()
{
uint num = (uint)this.$PC;
this.$PC = -1;
switch (num)
{
case 0u:
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnAggroMentalStateAndHostile(TargetIndex.A);
this.FailOn(delegate()
{
if (this.job.def.makeTargetPrisoner)
{
if (!base.DropBed.ForPrisoners)
{
return(true);
}
}
else if (base.DropBed.ForPrisoners != base.Takee.IsPrisoner)
{
return(true);
}
return(false);
});
this.$current = Toils_Bed.ClaimBedIfNonMedical(TargetIndex.B, TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 1;
}
return(true);
case 1u:
base.AddFinishAction(delegate
{
if (this.job.def.makeTargetPrisoner && base.Takee.ownership.OwnedBed == base.DropBed && base.Takee.Position != RestUtility.GetBedSleepingSlotPosFor(base.Takee, base.DropBed))
{
base.Takee.ownership.UnclaimBed();
}
});
this.$current = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOn(() => this.job.def == JobDefOf.Arrest && !base.Takee.CanBeArrestedBy(this.pawn)).FailOn(() => !this.pawn.CanReach(base.DropBed, PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn)).FailOn(() => this.job.def == JobDefOf.Rescue && !base.Takee.Downed).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 2;
}
return(true);
case 2u:
{
Toil checkArrestResistance = new Toil();
checkArrestResistance.initAction = delegate()
{
if (this.job.def.makeTargetPrisoner)
{
Pawn pawn = (Pawn)this.job.targetA.Thing;
Lord lord = pawn.GetLord();
if (lord != null)
{
lord.Notify_PawnAttemptArrested(pawn);
}
GenClamor.DoClamor(pawn, 10f, ClamorDefOf.Harm);
if (this.job.def == JobDefOf.Arrest && !pawn.CheckAcceptArrest(this.pawn))
{
this.pawn.jobs.EndCurrentJob(JobCondition.Incompletable, true);
}
}
};
this.$current = checkArrestResistance;
if (!this.$disposing)
{
this.$PC = 3;
}
return(true);
}
case 3u:
startCarrying = Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false).FailOnNonMedicalBedNotOwned(TargetIndex.B, TargetIndex.A);
startCarrying.AddPreInitAction(new Action(base.CheckMakeTakeeGuest));
this.$current = startCarrying;
if (!this.$disposing)
{
this.$PC = 4;
}
return(true);
case 4u:
this.$current = Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch);
if (!this.$disposing)
{
this.$PC = 5;
}
return(true);
case 5u:
{
Toil makePrisonerAndInit = new Toil();
makePrisonerAndInit.initAction = delegate()
{
base.CheckMakeTakeePrisoner();
if (base.Takee.playerSettings == null)
{
base.Takee.playerSettings = new Pawn_PlayerSettings(base.Takee);
}
};
this.$current = makePrisonerAndInit;
if (!this.$disposing)
{
this.$PC = 6;
}
return(true);
}
case 6u:
this.$current = Toils_Reserve.Release(TargetIndex.B);
if (!this.$disposing)
{
this.$PC = 7;
}
return(true);
case 7u:
{
Toil tuckIntoBed = new Toil();
tuckIntoBed.initAction = delegate()
{
IntVec3 position = base.DropBed.Position;
Thing thing;
this.pawn.carryTracker.TryDropCarriedThing(position, ThingPlaceMode.Direct, out thing, null);
if (!base.DropBed.Destroyed && (base.DropBed.owners.Contains(base.Takee) || (base.DropBed.Medical && base.DropBed.AnyUnoccupiedSleepingSlot) || base.Takee.ownership == null))
{
base.Takee.jobs.Notify_TuckedIntoBed(base.DropBed);
if (base.Takee.RaceProps.Humanlike && this.job.def != JobDefOf.Arrest && !base.Takee.IsPrisonerOfColony)
{
base.Takee.relations.Notify_RescuedBy(this.pawn);
}
base.Takee.mindState.Notify_TuckedIntoBed();
}
if (base.Takee.IsPrisonerOfColony)
{
LessonAutoActivator.TeachOpportunity(ConceptDefOf.PrisonerTab, base.Takee, OpportunityType.GoodToKnow);
}
};
tuckIntoBed.defaultCompleteMode = ToilCompleteMode.Instant;
this.$current = tuckIntoBed;
if (!this.$disposing)
{
this.$PC = 8;
}
return(true);
}
case 8u:
this.$PC = -1;
break;
}
return(false);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnAggroMentalStateAndHostile(TargetIndex.A);
this.FailOn(delegate()
{
if (this.job.def.makeTargetPrisoner)
{
if (!this.DropBed.ForPrisoners)
{
return(true);
}
}
else if (this.DropBed.ForPrisoners != this.Takee.IsPrisoner)
{
return(true);
}
return(false);
});
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.B, TargetIndex.A));
base.AddFinishAction(delegate
{
if (this.job.def.makeTargetPrisoner && this.Takee.ownership.OwnedBed == this.DropBed && this.Takee.Position != RestUtility.GetBedSleepingSlotPosFor(this.Takee, this.DropBed))
{
this.Takee.ownership.UnclaimBed();
}
});
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOn(() => this.job.def == JobDefOf.Arrest && !this.Takee.CanBeArrestedBy(this.pawn)).FailOn(() => !this.pawn.CanReach(this.DropBed, PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn)).FailOn(() => this.job.def == JobDefOf.Rescue && !this.Takee.Downed).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(new Toil
{
initAction = delegate()
{
if (this.job.def.makeTargetPrisoner)
{
Pawn pawn = (Pawn)this.job.targetA.Thing;
Lord lord = pawn.GetLord();
if (lord != null)
{
lord.Notify_PawnAttemptArrested(pawn);
}
GenClamor.DoClamor(pawn, 10f, ClamorDefOf.Harm);
if (this.job.def == JobDefOf.Arrest && !pawn.CheckAcceptArrest(this.pawn))
{
this.pawn.jobs.EndCurrentJob(JobCondition.Incompletable, true);
}
}
}
});
Toil startCarrying = Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false).FailOnNonMedicalBedNotOwned(TargetIndex.B, TargetIndex.A);
startCarrying.AddPreInitAction(new Action(this.CheckMakeTakeeGuest));
yield return(startCarrying);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch));
yield return(new Toil
{
initAction = delegate()
{
this.CheckMakeTakeePrisoner();
if (this.Takee.playerSettings == null)
{
this.Takee.playerSettings = new Pawn_PlayerSettings(this.Takee);
}
}
});
yield return(Toils_Reserve.Release(TargetIndex.B));
yield return(new Toil
{
initAction = delegate()
{
IntVec3 position = this.DropBed.Position;
Thing thing;
this.pawn.carryTracker.TryDropCarriedThing(position, ThingPlaceMode.Direct, out thing, null);
if (!this.DropBed.Destroyed && (this.DropBed.owners.Contains(this.Takee) || (this.DropBed.Medical && this.DropBed.AnyUnoccupiedSleepingSlot) || this.Takee.ownership == null))
{
this.Takee.jobs.Notify_TuckedIntoBed(this.DropBed);
if (this.Takee.RaceProps.Humanlike && this.job.def != JobDefOf.Arrest && !this.Takee.IsPrisonerOfColony)
{
this.Takee.relations.Notify_RescuedBy(this.pawn);
}
this.Takee.mindState.Notify_TuckedIntoBed();
}
if (this.Takee.IsPrisonerOfColony)
{
LessonAutoActivator.TeachOpportunity(ConceptDefOf.PrisonerTab, this.Takee, OpportunityType.GoodToKnow);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
yield break;
}
public bool MoveNext()
{
uint num = (uint)this.$PC;
this.$PC = -1;
switch (num)
{
case 0u:
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOn(() => !base.Patient.InBed() || !base.Patient.Awake());
if (base.Chair != null)
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.B);
}
if (base.Chair != null)
{
this.$current = Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell);
if (!this.$disposing)
{
this.$PC = 1;
}
return(true);
}
this.$current = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
if (!this.$disposing)
{
this.$PC = 2;
}
return(true);
case 1u:
break;
case 2u:
break;
case 3u:
{
Toil waitAndTalk = new Toil();
waitAndTalk.tickAction = delegate()
{
base.Patient.needs.joy.GainJoy(this.job.def.joyGainRate * 0.000144f, this.job.def.joyKind);
if (this.pawn.IsHashIntervalTick(320))
{
InteractionDef intDef = (Rand.Value >= 0.8f) ? InteractionDefOf.DeepTalk : InteractionDefOf.Chitchat;
this.pawn.interactions.TryInteractWith(base.Patient, intDef);
}
this.pawn.rotationTracker.FaceCell(base.Patient.Position);
this.pawn.GainComfortFromCellIfPossible();
JoyUtility.JoyTickCheckEnd(this.pawn, JoyTickFullJoyAction.None, 1f, null);
if (this.pawn.needs.joy.CurLevelPercentage > 0.9999f && base.Patient.needs.joy.CurLevelPercentage > 0.9999f)
{
this.pawn.jobs.EndCurrentJob(JobCondition.Succeeded, true);
}
};
waitAndTalk.handlingFacing = true;
waitAndTalk.socialMode = RandomSocialMode.Off;
waitAndTalk.defaultCompleteMode = ToilCompleteMode.Delay;
waitAndTalk.defaultDuration = this.job.def.joyDuration;
this.$current = waitAndTalk;
if (!this.$disposing)
{
this.$PC = 4;
}
return(true);
}
case 4u:
this.$PC = -1;
return(false);
default:
return(false);
}
this.$current = Toils_Interpersonal.WaitToBeAbleToInteract(this.pawn);
if (!this.$disposing)
{
this.$PC = 3;
}
return(true);
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Reserve.Reserve(terraformerIndex));
yield return(Toils_Goto.GotoCell(terraformerIndex, PathEndMode.InteractionCell).FailOnDestroyed(terraformerIndex));
yield return(Toils_General.Wait(240).FailOnDestroyed(terraformerIndex));
Toil scytherScoutsArrivalToil = new Toil()
{
initAction = () =>
{
IntVec3 spawningCell;
List <Pawn> scytherScoutsList = new List <Pawn>();
for (int scytherIndex = 0; scytherIndex < 4; scytherIndex++)
{
bool validDropPodCellIsFound = DropCellFinder.TryFindDropSpotNear(this.TargetThingA.InteractionCell, out spawningCell, true, true);
if (validDropPodCellIsFound)
{
Faction faction = Faction.OfMechanoids;
Pawn scytherScout = PawnGenerator.GeneratePawn(PawnKindDef.Named("Scyther"), faction);
scytherScoutsList.Add(scytherScout);
DropPodUtility.MakeDropPodAt(spawningCell, new DropPodInfo
{
SingleContainedThing = scytherScout,
openDelay = 600,
leaveSlag = false
});
}
}
StateGraph stateGraph = GraphMaker.MechanoidsDefendShipGraph(this.TargetThingA, defensiveRadiusAroundTerraformer);
BrainMaker.MakeNewBrain(Faction.OfMechanoids, stateGraph, scytherScoutsList);
},
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(scytherScoutsArrivalToil);
Toil pawnEscapingToil = new Toil()
{
initAction = () =>
{
(this.TargetThingA as Building_MechanoidTerraformer).reverseEngineeringState = Building_MechanoidTerraformer.ReverseEngineeringState.BuildingNotSecured;
ThingRequest thingRequest = new ThingRequest();
thingRequest.singleDef = ThingDefOf.CommsConsole;
Thing commsConsole = GenClosest.ClosestThingReachable(pawn.Position, thingRequest, PathEndMode.InteractionCell, TraverseParms.For(pawn));
if (commsConsole != null)
{
pawn.pather.StartPath(commsConsole, PathEndMode.InteractionCell);
}
else
{
// The player has no comms console. He should move his colonist manually... and fast!
pawn.pather.StartPath(pawn.Position, PathEndMode.OnCell);
}
string herHimOrIt = "it";
string sheHeOrIt = "it";
if (pawn.gender == Gender.Female)
{
herHimOrIt = "her";
sheHeOrIt = "she";
}
else if (pawn.gender == Gender.Male)
{
herHimOrIt = "him";
sheHeOrIt = "he";
}
string eventText = " " + pawn.Name.ToStringShort + " is just arriving near the strange building when " + sheHeOrIt + " hears the loud noise of incoming drop pods.\n\n"
+ "You should better take " + herHimOrIt + " to safety... and fast!\n";
Find.LetterStack.ReceiveLetter("Drop pods", eventText, LetterType.BadUrgent, this.pawn.Position);
},
defaultCompleteMode = ToilCompleteMode.PatherArrival
};
yield return(pawnEscapingToil);
yield return(Toils_Reserve.Release(terraformerIndex));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOnCellMissingDesignation(TargetIndex.A, DesignationDefOf.Mine);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil mine = new Toil();
mine.tickAction = delegate
{
Pawn actor = mine.actor;
Thing mineTarget = this.$this.MineTarget;
if (this.$this.ticksToPickHit < -100)
{
this.$this.ResetTicksToPickHit();
}
if (actor.skills != null && (mineTarget.Faction != actor.Faction || actor.Faction == null))
{
actor.skills.Learn(SkillDefOf.Mining, 0.07f, false);
}
this.$this.ticksToPickHit--;
if (this.$this.ticksToPickHit <= 0)
{
IntVec3 position = mineTarget.Position;
if (this.$this.effecter == null)
{
this.$this.effecter = EffecterDefOf.Mine.Spawn();
}
this.$this.effecter.Trigger(actor, mineTarget);
int num = (!mineTarget.def.building.isNaturalRock) ? 40 : 80;
Mineable mineable = mineTarget as Mineable;
if (mineable == null || mineTarget.HitPoints > num)
{
DamageDef mining = DamageDefOf.Mining;
float amount = (float)num;
Pawn actor2 = mine.actor;
DamageInfo dinfo = new DamageInfo(mining, amount, 0f, -1f, actor2, null, null, DamageInfo.SourceCategory.ThingOrUnknown, null);
mineTarget.TakeDamage(dinfo);
}
else
{
mineable.Notify_TookMiningDamage(mineTarget.HitPoints, mine.actor);
mineable.HitPoints = 0;
mineable.DestroyMined(actor);
}
if (mineTarget.Destroyed)
{
actor.Map.mineStrikeManager.CheckStruckOre(position, mineTarget.def, actor);
actor.records.Increment(RecordDefOf.CellsMined);
if (this.$this.pawn.Faction != Faction.OfPlayer)
{
List <Thing> thingList = position.GetThingList(this.$this.Map);
for (int i = 0; i < thingList.Count; i++)
{
thingList[i].SetForbidden(true, false);
}
}
if (this.$this.pawn.Faction == Faction.OfPlayer && MineStrikeManager.MineableIsVeryValuable(mineTarget.def))
{
TaleRecorder.RecordTale(TaleDefOf.MinedValuable, new object[]
{
this.$this.pawn,
mineTarget.def.building.mineableThing
});
}
if (this.$this.pawn.Faction == Faction.OfPlayer && MineStrikeManager.MineableIsValuable(mineTarget.def) && !this.$this.pawn.Map.IsPlayerHome)
{
TaleRecorder.RecordTale(TaleDefOf.CaravanRemoteMining, new object[]
{
this.$this.pawn,
mineTarget.def.building.mineableThing
});
}
this.$this.ReadyForNextToil();
return;
}
this.$this.ResetTicksToPickHit();
}
};
mine.defaultCompleteMode = ToilCompleteMode.Never;
mine.WithProgressBar(TargetIndex.A, () => 1f - (float)this.$this.MineTarget.HitPoints / (float)this.$this.MineTarget.MaxHitPoints, false, -0.5f);
mine.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
mine.activeSkill = (() => SkillDefOf.Mining);
yield return(mine);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.EndOnDespawnedOrNull(Executioner);
if (CultUtility.AreOccultGrimoiresAvailable(pawn.Map))
{
pawn.Map.GetComponent <MapComponent_LocalCultTracker>().CurrentSeedState = CultSeedState.NeedTable;
}
else
{
//First, let's try and find a typewriter.
//If we find one, let's go to it and start typing.
Thing Typewriter = null;
if (Utility.IsIndustrialAgeLoaded())
{
Utility.DebugReport("Industrial age check");
if (pawn.Map?.listerBuildings != null)
{
foreach (var thing in pawn.Map.listerBuildings.allBuildingsColonist)
{
if (thing.def.defName != "Estate_TableTypewriter")
{
continue;
}
Typewriter = thing;
Utility.DebugReport("Found typewriter");
var gotoDestination =
Toils_Goto.GotoCell(Typewriter.InteractionCell, PathEndMode.OnCell);
atTypeWriter = true;
yield return(gotoDestination);
goto SkipRoom;
}
}
}
//If we don't have a typewriter, then let's go to our personal room or near our bed.
var destinationRoom = pawn.ownership.OwnedRoom;
Building destinationBed = pawn.ownership.OwnedBed;
if (destinationRoom != null)
{
if (destinationRoom.Cells.TryRandomElement(out var destination))
{
if (Utility.IsRandomWalkable8WayAdjacentOf(destination, Map, out var cellInsideRoom))
{
var gotoRoom = Toils_Goto.GotoCell(cellInsideRoom, PathEndMode.OnCell);
yield return(gotoRoom);
}
}
}
else if (destinationBed != null)
{
if (Utility.IsRandomWalkable8WayAdjacentOf(destinationBed.Position, Map, out var cellNearBed))
{
var gotoBedArea = Toils_Goto.GotoCell(cellNearBed, PathEndMode.OnCell);
yield return(gotoBedArea);
}
}
SkipRoom:
var altarToil = new Toil {
defaultCompleteMode = ToilCompleteMode.Delay
};
altarToil.PlaySustainerOrSound(atTypeWriter
? SoundDef.Named("Estate_SoundManualTypewriter")
: SoundDef.Named("PencilWriting"));
altarToil.WithProgressBarToilDelay(TargetIndex.A);
altarToil.defaultDuration = job.def.joyDuration;
altarToil.AddPreTickAction(() =>
{
if (Typewriter == null)
{
return;
}
pawn.rotationTracker.FaceCell(Typewriter.Position);
pawn.GainComfortFromCellIfPossible();
});
altarToil.AddPreInitAction(() => Messages.Message(pawn.LabelCap + "WritingStrangeSymbols".Translate(),
MessageTypeDefOf.NeutralEvent));
yield return(altarToil);
var finishedAction = new Toil
{
defaultCompleteMode = ToilCompleteMode.Instant,
initAction = delegate
{
Map.GetComponent <MapComponent_LocalCultTracker>().CurrentSeedState =
CultSeedState.FinishedWriting;
}
};
yield return(finishedAction);
AddFinishAction(() =>
{
if (Map.GetComponent <MapComponent_LocalCultTracker>().CurrentSeedState ==
CultSeedState.FinishedWriting)
{
CultUtility.FinishedTheBook(pawn);
}
});
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnIncapable(PawnCapacityDefOf.Manipulation);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil toil = Toils_General.Wait(useDuration);
toil.WithProgressBarToilDelay(TargetIndex.A);
toil.FailOnDespawnedNullOrForbidden(TargetIndex.A);
toil.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
yield return(toil);
Toil use = new Toil();
use.initAction = delegate
{
Pawn actor = use.actor;
actor.CurJob.targetA.Thing.TryGetComp <CompHasButton>().DoPress(actor);
};
use.defaultCompleteMode = ToilCompleteMode.Instant;
yield return(use);
yield return(Toils_General.Wait(makeRequestDuration));
Toil request = new Toil();
request.initAction = delegate
{
CompMeeseeksMemory compMeeseeksMemory = pawn.GetComp <CompMeeseeksMemory>();
if (compMeeseeksMemory != null)
{
Pawn newestCreated = null;
if (compMeeseeksMemory.CreatedMeeseeks.Count > 0)
{
newestCreated = compMeeseeksMemory.CreatedMeeseeks[compMeeseeksMemory.CreatedMeeseeks.Count - 1];
}
if (newestCreated != null)
{
CompMeeseeksMemory newCreatedMemory = newestCreated.GetComp <CompMeeseeksMemory>();
if (newCreatedMemory != null)
{
newCreatedMemory.CopyJobDataFrom(compMeeseeksMemory);
if (compMeeseeksMemory.givenTask)
{
newestCreated.jobs.EndCurrentJob(JobCondition.InterruptOptional);
}
else
{
newCreatedMemory.temporarilyBlockTask = false;
}
}
}
}
MentalState_MeeseeksMakeMeeseeks mentalState = pawn.MentalState as MentalState_MeeseeksMakeMeeseeks;
if (mentalState != null && mentalState.doOnce)
{
pawn.MentalState.RecoverFromState();
}
};
request.defaultCompleteMode = ToilCompleteMode.Instant;
yield return(request);
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch).FailOnDespawnedOrNull(TargetIndex.B).FailOnDespawnedOrNull(TargetIndex.A));
/*Error: Unable to find new state assignment for yield return*/;
}
protected override IEnumerable <Toil> MakeNewToils()
{
//Commence fail checks!
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnAggroMentalState(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TakeeIndex));
yield return(Toils_Reserve.Reserve(AltarIndex, Building_SacrificialAltar.LyingSlotsCount));
yield return(new Toil
{
initAction = delegate
{
DropAltar.ChangeState(Building_SacrificialAltar.State.sacrificing,
Building_SacrificialAltar.SacrificeState.gathering);
}
});
//Toil 1: Go to prisoner.
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch)
.FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnDespawnedNullOrForbidden(TargetIndex.B)
.FailOn(() => job.def == JobDefOf.Arrest && !Takee.CanBeArrestedBy(pawn))
.FailOn(() =>
!pawn.CanReach(DropAltar, PathEndMode.OnCell, Danger.Deadly))
.FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(new Toil
{
initAction = delegate
{
if (!job.def.makeTargetPrisoner)
{
return;
}
var targetAThing = (Pawn)job.targetA.Thing;
var lord = targetAThing.GetLord();
lord?.Notify_PawnAttemptArrested(targetAThing);
GenClamor.DoClamor(targetAThing, 10f, ClamorDefOf.Harm);
if (job.def == JobDefOf.Arrest && !targetAThing.CheckAcceptArrest(pawn))
{
pawn.jobs.EndCurrentJob(JobCondition.Incompletable);
}
}
});
//Toil 2: Carry prisoner.
yield return(Toils_Haul.StartCarryThing(TargetIndex.A));
//Toil 3: Go to the altar.
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.InteractionCell));
//Toil 4: Release the prisoner.
yield return(Toils_Reserve.Release(TargetIndex.B));
//Toil 5: Restrain the prisoner.
yield return(new Toil
{
initAction = delegate
{
//In-case this fails...
var position = DropAltar.Position;
pawn.carryTracker.TryDropCarriedThing(position, ThingPlaceMode.Direct, out _);
if (DropAltar.Destroyed || !DropAltar.AnyUnoccupiedLyingSlot)
{
return;
}
Takee.Position = DropAltar.GetLyingSlotPos();
Takee.Notify_Teleported(false);
Takee.stances.CancelBusyStanceHard();
var newJob = new Job(CultsDefOf.Cults_WaitTiedDown, DropAltar);
Takee.jobs.StartJob(newJob);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
//Toil 6: Time to chant ominously
var chantingTime = new Toil
{
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = CultUtility.ritualDuration
};
chantingTime.WithProgressBarToilDelay(TargetIndex.A);
chantingTime.PlaySustainerOrSound(CultsDefOf.RitualChanting);
var deitySymbol = ((CosmicEntityDef)DropAltar.SacrificeData.Entity.def).Symbol;
chantingTime.initAction = delegate
{
if (deitySymbol != null)
{
MoteMaker.MakeInteractionBubble(pawn, null, ThingDefOf.Mote_Speech, deitySymbol);
}
//STATE - SACRIFICING
DropAltar.ChangeState(Building_SacrificialAltar.State.sacrificing,
Building_SacrificialAltar.SacrificeState.sacrificing);
};
yield return(chantingTime);
//Toil 8: Execution of Prisoner
yield return(new Toil
{
initAction = delegate
{
//BodyPartDamageInfo value = new BodyPartDamageInfo(this.Takee.health.hediffSet.GetBrain(), false, quiet);
Takee.TakeDamage(new DamageInfo(DamageDefOf.ExecutionCut, 99999, 0f, -1f, pawn,
Utility.GetHeart(Takee.health.hediffSet)));
if (!Takee.Dead)
{
Takee.Kill(null);
}
//ThoughtUtility.GiveThoughtsForPawnExecuted(this.Takee, PawnExecutionKind.GenericHumane);
TaleRecorder.RecordTale(TaleDefOf.ExecutedPrisoner, pawn, Takee);
CultUtility.SacrificeExecutionComplete(DropAltar);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
AddFinishAction(() =>
{
//It's a day to remember
var taleToAdd = TaleDef.Named("HeldSermon");
if ((pawn.IsColonist || pawn.IsSlaveOfColony || pawn.HostFaction == Faction.OfPlayer) && taleToAdd != null)
{
TaleRecorder.RecordTale(taleToAdd, pawn);
}
//When the ritual is finished -- then let's give the thoughts
/*
* if (DropAltar.currentSacrificeState == Building_SacrificialAltar.SacrificeState.finished)
* {
* if (this.pawn == null) return;
* if (DropAltar.sacrifice != null)
* {
* CultUtility.AttendSacrificeTickCheckEnd(this.pawn, DropAltar.sacrifice, true);
* }
* else
* {
* CultUtility.AttendSacrificeTickCheckEnd(this.pawn, null);
* }
* }
*/
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
//--Log.Message("JobDriver_NymphJoinInBed::MakeNewToils() called");
this.FailOnDespawnedOrNull(ipartner);
this.FailOnDespawnedOrNull(ibed);
this.FailOn(() => !Partner.health.capacities.CanBeAwake);
this.FailOn(() => !xxx.is_laying_down_alone(Partner));
yield return(Toils_Reserve.Reserve(ipartner, comfort_prisoners.max_rapists_per_prisoner, 0));
yield return(Toils_Goto.GotoThing(ipartner, PathEndMode.OnCell));
yield return(new Toil
{
initAction = delegate
{
//--Log.Message("JobDriver_NymphJoinInBed::MakeNewToils() - setting initAction");
ticks_left = (int)(2500.0f * Rand.Range(0.30f, 1.30f));
var gettin_loved = new Job(xxx.gettin_loved, pawn, Bed);
Partner.jobs.StartJob(gettin_loved, JobCondition.InterruptForced, null, false, true, null);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
var do_lovin = new Toil();
do_lovin.defaultCompleteMode = ToilCompleteMode.Never;
do_lovin.FailOn(() => (Partner.CurJob == null) || (Partner.CurJob.def != xxx.gettin_loved));
do_lovin.AddPreTickAction(delegate
{
--ticks_left;
if (ticks_left <= 0)
{
ReadyForNextToil();
}
else if (pawn.IsHashIntervalTick(ticks_between_hearts))
{
MoteMaker.ThrowMetaIcon(pawn.Position, pawn.Map, ThingDefOf.Mote_Heart);
}
});
do_lovin.socialMode = RandomSocialMode.Off;
yield return(do_lovin);
yield return(new Toil
{
initAction = delegate
{
//--Log.Message("JobDriver_NymphJoinInBed::MakeNewToils() - setting pawn.got_some_lovin memory in second initAction");
var sex_mem = (Thought_Memory)ThoughtMaker.MakeThought(ThoughtDefOf.GotSomeLovin);
var pawn_memories = pawn.needs.mood.thoughts.memories as MemoryThoughtHandler;
if (pawn_memories != null)
{
pawn.needs.mood.thoughts.memories.TryGainMemory(sex_mem, Partner);
}
//--Log.Message("JobDriver_NymphJoinInBed::MakeNewToils() - setting Partner.got_some_lovin memory in second initAction");
var sex_mem2 = (Thought_Memory)ThoughtMaker.MakeThought(ThoughtDefOf.GotSomeLovin); // Is this neccessary?
if (Partner.needs != null && Partner.needs.mood != null && Partner.needs.mood.thoughts != null)
{
Partner.needs.mood.thoughts.memories.TryGainMemory(sex_mem2, pawn);
}
//--Log.Message("JobDriver_NymphJoinInBed::MakeNewToils() - calling aftersex in second initAction");
xxx.aftersex(pawn, Partner);
//--Log.Message("JobDriver_NymphJoinInBed::MakeNewToils() - calling aftersex again in second initAction");
//xxx.aftersex (Partner, pawn);
//--Log.Message("JobDriver_NymphJoinInBed::MakeNewToils() - setting mindstate in second initAction");
pawn.mindState.canLovinTick = Find.TickManager.TicksGame + xxx.generate_min_ticks_to_next_lovin(pawn);
//--Log.Message("JobDriver_NymphJoinInBed::MakeNewToils() - setting mindstate again in second initAction");
Partner.mindState.canLovinTick = Find.TickManager.TicksGame + xxx.generate_min_ticks_to_next_lovin(Partner);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1));
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, false));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedNullOrForbidden(TargetIndex.A));
yield return(new Toil
{
initAction = delegate
{
Thing straitjacket = null;
this.pawn.carryTracker.TryDropCarriedThing(pawn.Position, ThingPlaceMode.Near, out straitjacket, null);
Pawn pawnToForceIntoStraitjacket = (Pawn)TargetA.Thing;
if (pawnToForceIntoStraitjacket != null)
{
if (!pawnToForceIntoStraitjacket.InAggroMentalState)
{
GenClamor.DoClamor(pawn, 10f, ClamorType.Harm);
if (!CheckAcceptStraitJacket(pawnToForceIntoStraitjacket, this.pawn))
{
this.pawn.jobs.EndCurrentJob(JobCondition.Incompletable, true);
}
}
}
}, defaultCompleteMode = ToilCompleteMode.Instant
});
Toil toil2 = new Toil();
toil2.defaultCompleteMode = ToilCompleteMode.Delay;
toil2.defaultDuration = 500;
toil2.WithProgressBarToilDelay(TargetIndex.A, false, -0.5f);
toil2.initAction = delegate
{
Pawn pawnToForceIntoStraitjacket = (Pawn)TargetA.Thing;
if (pawnToForceIntoStraitjacket != null)
{
if (!pawnToForceIntoStraitjacket.InAggroMentalState)
{
PawnUtility.ForceWait(pawnToForceIntoStraitjacket, toil2.defaultDuration, this.pawn);
}
}
};
yield return(toil2);
yield return(new Toil
{
initAction = delegate
{
Takee.apparel.Wear(Straitjacket);
Hediff pawnJacketHediff = Takee.health.hediffSet.GetFirstHediffOfDef(StraitjacketDefOf.ROM_RestainedByStraitjacket);
if (pawnJacketHediff == null)
{
pawnJacketHediff = HediffMaker.MakeHediff(StraitjacketDefOf.ROM_RestainedByStraitjacket, Takee);
Takee.health.AddHediff(pawnJacketHediff);
}
}, defaultCompleteMode = ToilCompleteMode.Instant
});
yield break;
}
public static IEnumerable <Toil> Toils_GoToThingMap(Pawn pawn, Thing selectedStairs, Thing thing, JobDriver instance)
{
Toil setStairs = new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
ZLogger.Message("Pawn: " + pawn);
ZLogger.Message("Pawn.map: " + pawn.Map);
ZLogger.Message("thing: " + thing);
ZLogger.Message("thing.Map: " + thing.Map);
ZLogger.Message("pawn.CurJob: " + pawn.jobs.curJob);
if (ZTracker.GetZIndexFor(pawn.Map) > ZTracker.GetZIndexFor(thing.Map))
{
var stairs = ZTracker.stairsDown[pawn.Map];
if (stairs?.Count() > 0)
{
selectedStairs = stairs.MinBy(x => IntVec3Utility.DistanceTo(thing.Position, x.Position));
}
}
else if (ZTracker.GetZIndexFor(pawn.Map) < ZTracker.GetZIndexFor(thing.Map))
{
var stairs = ZTracker.stairsUp[pawn.Map];
if (stairs?.Count() > 0)
{
selectedStairs = stairs.MinBy(x => IntVec3Utility.DistanceTo(thing.Position, x.Position));
}
}
pawn.jobs.curJob.targetC = new LocalTargetInfo(selectedStairs);
}
};
yield return(setStairs);
yield return(Toils_Goto.GotoThing(TargetIndex.C, PathEndMode.OnCell));
Toil useStairs = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(useStairs, TargetIndex.C, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(useStairs, TargetIndex.C);
//ToilFailConditions.FailOnCannotTouch<Toil>(useStairs, TargetIndex.C, PathEndMode.OnCell);
yield return(useStairs);
yield return(new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (selectedStairs is Building_StairsUp stairsUp)
{
Map map = ZTracker.GetUpperLevel(pawn.Map.Tile, pawn.Map);
if (map == null)
{
map = ZTracker.CreateUpperLevel(pawn.Map, stairsUp.Position);
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, false, true);
}
else
{
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
}
else if (selectedStairs is Building_StairsDown stairsDown)
{
Map map = ZTracker.GetLowerLevel(pawn.Map.Tile, pawn.Map);
if (map == null)
{
map = ZTracker.CreateLowerLevel(pawn.Map, stairsDown.Position);
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, true);
}
else
{
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, stairsDown.shouldSpawnStairsBelow);
stairsDown.shouldSpawnStairsBelow = false;
}
}
if (pawn.Map != thing.Map)
{
instance.JumpToToil(setStairs);
}
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell));
Toil useStairs = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(useStairs, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(useStairs, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(useStairs, TargetIndex.A, PathEndMode.OnCell);
yield return(useStairs);
yield return(new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
Pawn pawn = GetActor();
if (TargetA.Thing is Building_StairsUp stairsUp)
{
Map map = ZTracker.GetUpperLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateUpperLevel(this.pawn.Map, stairsUp.Position);
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, false, true);
}
else
{
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
}
else if (TargetA.Thing is Building_StairsDown stairsDown)
{
Map map = ZTracker.GetLowerLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateLowerLevel(this.pawn.Map, stairsDown.Position);
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, true);
}
else
{
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, stairsDown.shouldSpawnStairsBelow);
stairsDown.shouldSpawnStairsBelow = false;
}
}
try
{
ZLogger.Message("5 lastTick");
ZTracker.jobTracker[pawn].lastTickFood = Find.TickManager.TicksGame + 201;
ZTracker.jobTracker[pawn].lastTickJoy = Find.TickManager.TicksGame + 201;
}
catch { };
}
});
public bool MoveNext()
{
uint num = (uint)this.$PC;
this.$PC = -1;
switch (num)
{
case 0u:
this.$current = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch);
if (!this.$disposing)
{
this.$PC = 1;
}
return(true);
case 1u:
this.$current = Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false);
if (!this.$disposing)
{
this.$PC = 2;
}
return(true);
case 2u:
findNearestCarrier = base.FindCarrierToil();
this.$current = findNearestCarrier;
if (!this.$disposing)
{
this.$PC = 3;
}
return(true);
case 3u:
this.$current = Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch).FailOnDespawnedNullOrForbidden(TargetIndex.B).JumpIf(() => !base.CanCarryAtLeastOne(base.Animal), findNearestCarrier);
if (!this.$disposing)
{
this.$PC = 4;
}
return(true);
case 4u:
this.$current = base.GiveToCarrierAsMuchAsPossibleToil();
if (!this.$disposing)
{
this.$PC = 5;
}
return(true);
case 5u:
this.$current = Toils_Jump.JumpIf(findNearestCarrier, () => this.pawn.carryTracker.CarriedThing != null);
if (!this.$disposing)
{
this.$PC = 6;
}
return(true);
case 6u:
this.$PC = -1;
break;
}
return(false);
}
protected override IEnumerable <Toil> MakeNewToils()
{
///
//Set fail conditions
///
this.FailOnDestroyed(MountableInd);
this.FailOnDowned(DriverInd);
//Note we only fail on forbidden if the target doesn't start that way
//This helps haul-aside jobs on forbidden items
if (!TargetThingA.IsForbidden(pawn.Faction))
{
this.FailOnForbidden(MountableInd);
}
///
//Define Toil
///
Toil toilMakeStandby = new Toil();
toilMakeStandby.initAction = () =>
{
Pawn driver = CurJob.GetTarget(DriverInd).Thing as Pawn;
driver.jobs.StartJob(new Job(DefDatabase <JobDef> .GetNamed("Standby"), driver.Position, 2400 + (int)((pawn.Position - driver.Position).LengthHorizontal * 120)), JobCondition.InterruptForced);
};
Toil toilGoto = null;
toilGoto = Toils_Goto.GotoThing(MountableInd, PathEndMode.ClosestTouch)
.FailOn(() =>
{
//Note we don't fail on losing hauling designation
//Because that's a special case anyway
//While hauling to cell storage, ensure storage dest is still valid
Pawn actor = toilGoto.actor;
Job curJob = actor.jobs.curJob;
if (curJob.haulMode == HaulMode.ToCellStorage)
{
Thing haulThing = curJob.GetTarget(MountableInd).Thing;
IntVec3 destLoc = actor.jobs.curJob.GetTarget(TargetIndex.B).Cell;
if (!destLoc.IsValidStorageFor(haulThing))
{
return(true);
}
}
return(false);
});
Toil toilMountOn = new Toil();
toilMountOn.initAction = () =>
{
Pawn driver = TargetB.Thing as Pawn;
if (driver != null && TargetThingA.TryGetComp <CompMountable>() != null)
{
TargetThingA.TryGetComp <CompMountable>().MountOn(driver);
}
else
{
Log.Error(GetActor().LabelCap + ": Try make mount without target B Driver");
EndJobWith(JobCondition.Errored);
}
};
Toil toilEnd = new Toil();
toilEnd.initAction = () =>
{
Vehicle_Cart cart = CurJob.GetTarget(MountableInd).Thing as Vehicle_Cart;
Vehicle_Saddle saddle = CurJob.GetTarget(MountableInd).Thing as Vehicle_Saddle;
if (cart == null || saddle == null)
{
Log.Error(GetActor().LabelCap + ": MakeMount get TargetA not cart or saddle.");
EndJobWith(JobCondition.Errored);
return;
}
if (cart.mountableComp.IsMounted && cart.mountableComp.Driver.CurJob.def == DefDatabase <JobDef> .GetNamed("Standby"))
{
cart.mountableComp.Driver.jobs.curDriver.EndJobWith(JobCondition.Succeeded);
}
EndJobWith(JobCondition.Succeeded);
};
///
//Toils Start
///
//Reserve thing to be stored and storage cell
yield return(Toils_Reserve.Reserve(MountableInd));
yield return(Toils_Reserve.Reserve(DriverInd));
yield return(toilMakeStandby);
yield return(toilGoto);
yield return(Toils_Haul.StartCarryThing(MountableInd));
yield return(Toils_Haul.CarryHauledThingToCell(DriverInd));
yield return(toilMountOn);
yield return(toilEnd);
}
public bool MoveNext()
{
uint num = (uint)this.$PC;
this.$PC = -1;
switch (num)
{
case 0u:
this.FailOnDestroyedOrNull(TargetIndex.A);
this.$current = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 1;
}
return(true);
case 1u:
this.$current = Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 2;
}
return(true);
case 2u:
this.$current = Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false);
if (!this.$disposing)
{
this.$PC = 3;
}
return(true);
case 3u:
gotoCell = Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.OnCell);
gotoCell.AddPreTickAction(delegate
{
if (base.Map.exitMapGrid.IsExitCell(this.pawn.Position))
{
this.pawn.ExitMap(true, CellRect.WholeMap(base.Map).GetClosestEdge(this.pawn.Position));
}
});
this.$current = gotoCell;
if (!this.$disposing)
{
this.$PC = 4;
}
return(true);
case 4u:
{
Toil arrive = new Toil();
arrive.initAction = delegate()
{
if (this.pawn.Position.OnEdge(this.pawn.Map) || this.pawn.Map.exitMapGrid.IsExitCell(this.pawn.Position))
{
this.pawn.ExitMap(true, CellRect.WholeMap(base.Map).GetClosestEdge(this.pawn.Position));
}
};
arrive.defaultCompleteMode = ToilCompleteMode.Instant;
this.$current = arrive;
if (!this.$disposing)
{
this.$PC = 5;
}
return(true);
}
case 5u:
this.$PC = -1;
break;
}
return(false);
}
protected override IEnumerable <Toil> MakeNewToils()
{
Building_OrbitalRelay orbitalRelay = this.TargetThingA as Building_OrbitalRelay;
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.InteractionCell).FailOn(delegate()
{
return (orbitalRelay.canUseConsoleNow == false);
}));
Toil faceConsoleToil = new Toil()
{
initAction = () =>
{
this.GetActor().rotationTracker.FaceCell(orbitalRelay.Position);
}
};
yield return(faceConsoleToil);
Toil callMiningCoToil = new Toil()
{
initAction = () =>
{
DiaNode mainDiaNode = new DiaNode("\"MiningCo. here!\n"
+ "What do you want, partner?\"");
// Cargo supply request option.
DiaOption cargoSupplyDiaOption = GetCargoSupplyDiaOption(orbitalRelay);
mainDiaNode.options.Add(cargoSupplyDiaOption);
// Medical supply request option.
DiaOption medicalSupplyDiaOption = GetMedicalSupplyDiaOption(orbitalRelay);
mainDiaNode.options.Add(medicalSupplyDiaOption);
// Air support request option.
DiaOption airSupportDiaOption = GetAirSupportDiaOption(orbitalRelay, mainDiaNode);
mainDiaNode.options.Add(airSupportDiaOption);
// Partnership and goodwill fee payment option.
if ((Util_Misc.Partnership.globalGoodwillFeeInSilver > 0) ||
(Util_Misc.Partnership.feeInSilver[this.Map] > 0))
{
foreach (DiaOption option in mainDiaNode.options)
{
option.Disable("fee unpaid");
}
DiaOption feePaymentDiaOption = GetFeePaymentDiaOption(orbitalRelay);
mainDiaNode.options.Add(feePaymentDiaOption);
}
// Disconnect option.
DiaOption disconnectDiaOption = new DiaOption("Disconnect");
disconnectDiaOption.resolveTree = true;
mainDiaNode.options.Add(disconnectDiaOption);
Find.WindowStack.Add(new Dialog_NodeTree(mainDiaNode, true, true, "-- Comlink with MiningCo. --"));
},
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(callMiningCoToil);
yield return(Toils_Reserve.Release(orbitalRelayConsoleIndex));
}
public static IEnumerable <Toil> MakeFeedToils(JobDef job, JobDriver thisDriver, Pawn actor, LocalTargetInfo TargetA, ThoughtDef victimThoughtDef, ThoughtDef actorThoughtDef, float workLeft, Action effect, Func <Pawn, Pawn, bool> stopCondition, bool needsGrapple = true, bool cleansWound = true, bool neverGiveUp = false)
{
yield return(Toils_Reserve.Reserve(TargetIndex.A));
Toil gotoToil = actor?.Faction == TargetA.Thing?.Faction && (!actor.InAggroMentalState && !((Pawn)TargetA.Thing).InAggroMentalState) ? Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch) : Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch);
yield return(gotoToil);
Toil grappleToil = new Toil()
{
initAction = delegate
{
MoteMaker.MakeColonistActionOverlay(actor, ThingDefOf.Mote_ColonistAttacking);
workLeft = BaseFeedTime;
Pawn victim = TargetA.Thing as Pawn;
if (victim != null)
{
// if (!AllowFeeding(actor, victim))
// {
// actor.jobs.EndCurrentJob(JobCondition.Incompletable);
// }
if (actor.InAggroMentalState || victim.InAggroMentalState || victim.Faction != actor.Faction)
{
if (needsGrapple)
{
int grappleBonus = actor is PawnTemporary ? 100 : 0;
if (!JecsTools.GrappleUtility.TryGrapple(actor, victim, grappleBonus))
{
thisDriver.EndJobWith(JobCondition.Incompletable);
PawnUtility.ForceWait(actor, (int)(BaseFeedTime * 0.15f));
return;
}
}
}
if (actor.IsVampire())
{
VampireBiteUtility.MakeNew(actor, victim);
}
victim.stances.stunner.StunFor((int)BaseFeedTime, actor);
}
}
};
yield return(grappleToil);
Toil feedToil = new Toil()
{
tickAction = delegate
{
//try
//{
if (TargetA.Thing is Pawn victim && victim.Spawned && !victim.Dead)
{
workLeft--;
VampireWitnessUtility.HandleWitnessesOf(job, actor, victim);
if (victim?.needs?.mood?.thoughts?.memories != null)
{
Thought_Memory victimThought = null;
if (victimThoughtDef != null)
{
victimThought = (Thought_Memory)ThoughtMaker.MakeThought(victimThoughtDef);
}
if (victimThought != null)
{
victim.needs.mood.thoughts.memories.TryGainMemory(victimThought);
}
}
if (actor?.needs?.mood?.thoughts?.memories != null)
{
Thought_Memory actorThought = null;
if (actorThoughtDef != null)
{
actorThought = (Thought_Memory)ThoughtMaker.MakeThought(actorThoughtDef);
}
if (actorThought != null)
{
actor.needs.mood.thoughts.memories.TryGainMemory(actorThought);
}
}
if (workLeft <= 0f)
{
if (actor?.VampComp() is CompVampire v && v.IsVampire && actor.Faction == Faction.OfPlayer)
{
MoteMaker.ThrowText(actor.DrawPos, actor.Map, "XP +" + 15);
v.XP += 15;
workLeft = BaseFeedTime;
MoteMaker.MakeColonistActionOverlay(actor, ThingDefOf.Mote_ColonistAttacking);
}
effect();
if (victim != null && !victim.Dead && needsGrapple)
{
int victimBonus = (victim.VampComp() is CompVampire victimVampComp) ? -victimVampComp.Generation + 14 : 0;
int actorBonus = 0;
if (actor?.VampComp() is CompVampire v2 && v2.IsVampire)
{
actorBonus = -v2.Generation + 14;
}
if (!JecsTools.GrappleUtility.TryGrapple(actor, victim, actorBonus, victimBonus))
{
thisDriver.EndJobWith(JobCondition.Incompletable);
}
}
if (!stopCondition(actor, victim))
{
thisDriver.ReadyForNextToil();
if (actor.IsVampire() && cleansWound)
{
VampireBiteUtility.CleanBite(actor, victim);
}
}
else
{
if (victim != null && !victim.Dead)
{
victim.stances.stunner.StunFor((int)BaseFeedTime, actor);
PawnUtility.ForceWait((Pawn)TargetA.Thing, (int)BaseFeedTime, actor);
}
}
}
}
// Token: 0x0600005E RID: 94 RVA: 0x00003857 File Offset: 0x00001A57
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell));
/*Error: Unable to find new state assignment for yield return*/;
}
// Token: 0x06000022 RID: 34 RVA: 0x00002891 File Offset: 0x00000A91
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null));
this.FailOn(delegate()
{
IBillGiver billGiver = this.job.GetTarget(TargetIndex.A).Thing as IBillGiver;
return(this.BellRef.currentState == Building_Bell.State.rest);
});
base.AddFinishAction(delegate
{
bool flag = this.Takee == this.BellRef.fighter1.p;
if (flag)
{
bool isInFight = this.BellRef.fighter1.isInFight;
if (!isInFight)
{
this.BellRef.TryCancelBrawl("");
}
}
else
{
bool flag2 = this.Takee == this.BellRef.fighter2.p;
if (flag2)
{
bool isInFight2 = this.BellRef.fighter2.isInFight;
if (!isInFight2)
{
this.BellRef.TryCancelBrawl("");
}
}
}
});
yield return(new Toil
{
initAction = delegate()
{
bool flag = this.BellRef.currentState == Building_Bell.State.scheduled;
if (flag)
{
this.BellRef.currentState = Building_Bell.State.preparation;
this.BellRef.startTheShow();
}
}
});
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch));
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false));
yield return(Toils_Goto.GotoCell(TargetIndex.C, PathEndMode.Touch));
yield return(new Toil
{
initAction = delegate()
{
IntVec3 position = this.DropPosition;
Thing thing;
this.pawn.carryTracker.TryDropCarriedThing(position, ThingPlaceMode.Direct, out thing, null);
bool flag = !this.BellRef.Destroyed;
if (flag)
{
this.HaulFinished();
this.BellRef.PrisonerDelievered(this.Takee);
bool flag2 = this.BellRef.currentState != Building_Bell.State.fight;
if (flag2)
{
Job carryPrisonerJob = new Job(JobDefOfArena.HaulingPrisoner, this.BellRef.getPrisonerForHaul(), this.BellRef, this.BellRef.getFighterStandPoint())
{
count = 1
};
this.pawn.jobs.TryTakeOrderedJob(carryPrisonerJob, JobTag.Misc);
}
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
// Error checking/input validation.
if (turret == null)
{
Log.Error(string.Concat(errorBase, "TargetThingA isn't a Building_TurretGunCE"));
yield return(null);
}
if (compReloader == null)
{
Log.Error(string.Concat(errorBase, "TargetThingA (Building_TurretGunCE) is missing its CompAmmoUser."));
yield return(null);
}
if (compReloader.UseAmmo && ammo == null)
{
Log.Error(string.Concat(errorBase, "TargetThingB is either null or not an AmmoThing."));
yield return(null);
}
AddEndCondition(delegate
{
return((pawn.Downed || pawn.Dead || pawn.InMentalState || pawn.IsBurning()) ? JobCondition.Incompletable : JobCondition.Ongoing);
});
this.FailOnIncapable(PawnCapacityDefOf.Manipulation);
// Set fail condition on turret.
if (pawn.Faction != Faction.OfPlayer)
{
this.FailOnDestroyedOrNull(TargetIndex.A);
}
else
{
this.FailOnDestroyedNullOrForbidden(TargetIndex.A);
}
// Perform ammo system specific activities, failure condition and hauling
if (compReloader.UseAmmo)
{
var toilGoToCell = Toils_Goto.GotoCell(ammo.Position, PathEndMode.Touch).FailOnBurningImmobile(TargetIndex.B);
var toilCarryThing = Toils_Haul.StartCarryThing(TargetIndex.B).FailOnBurningImmobile(TargetIndex.B);
if (TargetThingB is AmmoThing)
{
toilGoToCell.AddEndCondition(delegate { return((TargetThingB as AmmoThing).IsCookingOff ? JobCondition.Incompletable : JobCondition.Ongoing); });
toilCarryThing.AddEndCondition(delegate { return((TargetThingB as AmmoThing).IsCookingOff ? JobCondition.Incompletable : JobCondition.Ongoing); });
}
if (pawn.Faction != Faction.OfPlayer)
{
ammo.SetForbidden(true, false);
toilGoToCell.FailOnDestroyedOrNull(TargetIndex.B);
toilCarryThing.FailOnDestroyedOrNull(TargetIndex.B);
}
else
{
toilGoToCell.FailOnDestroyedNullOrForbidden(TargetIndex.B);
toilCarryThing.FailOnDestroyedNullOrForbidden(TargetIndex.B);
}
//yield return Toils_Reserve.Reserve(TargetIndex.B, Mathf.Max(1, TargetThingB.stackCount - job.count), job.count);
yield return(toilGoToCell);
yield return(toilCarryThing);
//yield return Toils_Haul.PlaceHauledThingInCell(TargetIndex.A, null, false);
}
// If ammo system is turned off we just need to go to the turret.
yield return(Toils_Goto.GotoCell(turret.Position, PathEndMode.Touch));
//If pawn fails reloading from this point, reset isReloading
this.AddFinishAction(delegate { turret.isReloading = false; });
// Wait in place
Toil waitToil = new Toil()
{
actor = pawn
};
waitToil.initAction = delegate
{
// Initial relaod process activities.
turret.isReloading = true;
waitToil.actor.pather.StopDead();
if (compReloader.ShouldThrowMote)
{
MoteMaker.ThrowText(turret.Position.ToVector3Shifted(), turret.Map, string.Format("CE_ReloadingTurretMote".Translate(), TargetThingA.LabelCapNoCount));
}
//Thing newAmmo;
//compReloader.TryUnload(out newAmmo);
//if (newAmmo?.CanStackWith(ammo) ?? false)
//{
// pawn.carryTracker.TryStartCarry(newAmmo, Mathf.Min(newAmmo.stackCount, compReloader.Props.magazineSize - ammo.stackCount));
//}
AmmoDef currentAmmo = compReloader.CurrentAmmo;
if (currentAmmo != ammo.def) //Turrets are reloaded without unloading the mag first (if using same ammo type), to support very high capacity magazines
{
compReloader.TryUnload(out Thing newAmmo);
}
};
waitToil.defaultCompleteMode = ToilCompleteMode.Delay;
waitToil.defaultDuration = Mathf.CeilToInt(compReloader.Props.reloadTime.SecondsToTicks() / pawn.GetStatValue(CE_StatDefOf.ReloadSpeed));
yield return(waitToil.WithProgressBarToilDelay(TargetIndex.A));
//Actual reloader
Toil reloadToil = new Toil();
reloadToil.defaultCompleteMode = ToilCompleteMode.Instant;
reloadToil.initAction = delegate
{
compReloader.LoadAmmo(ammo);
turret.isReloading = false;
};
//if (compReloader.useAmmo) reloadToil.EndOnDespawnedOrNull(TargetIndex.B);
yield return(reloadToil);
}
private IEnumerable <Toil> PrepareToIngestToils_Dispenser()
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell).FailOnDespawnedNullOrForbidden(TargetIndex.A));
/*Error: Unable to find new state assignment for yield return*/;
}