protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.A);
this.FailOn(() => !TargetCanBeBuried());
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnForbidden(TargetIndex.A));
yield return(new Toil()
{
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = Duration
}.WithProgressBarToilDelay(TargetIndex.A)
.FailOnDespawnedOrNull(TargetIndex.A));
yield return(Toils_General.Do(() =>
{
var holeBuilding = TargetLocA.GetThingList(Map)
.FirstOrDefault(t => t is Building_BuriedThing) as Building_BuriedThing;
if (holeBuilding == null)
{
holeBuilding = ThingMaker.MakeThing(ThingDef.Named("Building_BuriedThing"), null) as Building_BuriedThing;
GenSpawn.Spawn(holeBuilding, TargetLocA, Map, Rot4.North, WipeMode.Vanish);
pawn.Map.edificeGrid?.Register(holeBuilding);
}
holeBuilding.AddThing((TargetThingA as Corpse)?.InnerPawn?.LabelShort ?? TargetThingA.LabelNoCount);
pawn.Map.designationManager?.TryRemoveDesignationOn(TargetThingA, BuryOnTheSpotDefOf.BuryDesignation);
TargetThingA.DeSpawn();
}));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.EndOnDespawnedOrNull(TargetIndex.A, JobCondition.Incompletable);
yield return(Toils_Reserve.Reserve(TargetIndex.A, job.def.joyMaxParticipants));
if (TargetB != null)
{
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1));
}
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell));
var toil = new Toil();
toil.PlaySustainerOrSound(TargetThingA?.def?.defName == "RimWriter_TableTypewriter"
? DefDatabase <SoundDef> .GetNamed("RimWriter_SoundManualTypewriter") : DefDatabase <SoundDef> .GetNamed(
"RimWriter_SoundManualPencil"));
toil.tickAction = delegate
{
pawn.rotationTracker.FaceCell(TargetA.Cell);
pawn.GainComfortFromCellIfPossible();
var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor, true);
var extraJoyGainFactor = statValue;
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.GoToNextToil, extraJoyGainFactor);
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = job.def.joyDuration;
toil.AddFinishAction(delegate
{
RimWriterUtility.TryGainLibraryThought(pawn);
});
yield return(toil);
var finishedToil = new Toil
{
initAction = delegate
{
if (RimWriterUtility.IsCosmicHorrorsLoaded() || RimWriterUtility.IsCultsLoaded())
{
try
{
if (RimWriterUtility.HasSanityLoss(pawn))
{
RimWriterUtility.ApplySanityLoss(pawn, -sanityRestoreRate, 1);
Messages.Message(pawn.ToString() + " has restored some sanity using the " + TargetA.Thing.def.label + ".", new TargetInfo(pawn.Position, pawn.Map), MessageTypeDefOf.NeutralEvent);// .Standard);
}
}
catch
{
Log.Message("Error loading Sanity Hediff.");
}
}
}
};
yield return(finishedToil);
yield break;
}
/// <summary>
/// What happens while the game is being played. Make it return true if the player wins.
/// </summary>
/// <returns></returns>
protected virtual bool WatchTickAction()
{
var extraJoyGainFactor = TargetThingA.GetStatValue(StatDefOf.EntertainmentStrengthFactor);
JoyUtility.JoyTickCheckEnd(this.pawn, JoyTickFullJoyAction.None, extraJoyGainFactor);
return(false);
}
protected override void AffectGate()
{
MoteMaker.ThrowText(TargetThingA.TrueCenter(), this.Map, "MoteOpen".Translate(), 1f);
Building building = (Building)ThingMaker.MakeThing(ThingDef.Named("OpenPortcullis"), TargetThingA.Stuff);
building.SetFaction(TargetThingA.Faction);
GenSpawn.Spawn(building, TargetThingA.Position, TargetThingA.Map, TargetThingA.Rotation, WipeMode.Vanish);
}
protected void ReadTickAction()
{
pawn.rotationTracker.FaceCell(TargetB.Cell);
pawn.GainComfortFromCellIfPossible();
var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor);
var pawn1 = pawn;
JoyUtility.JoyTickCheckEnd(pawn1, JoyTickFullJoyAction.EndJob, statValue);
}
protected Action WaitTickAction()
{
return(delegate
{
pawn.rotationTracker.FaceCell(TargetB.Cell);
pawn.GainComfortFromCellIfPossible();
var extraJoyGainFactor = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor);
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, extraJoyGainFactor);
});
}
public override void Notify_Starting()
{
base.Notify_Starting();
if (TargetThingA != null)
{
forbiddenInitially = TargetThingA.IsForbidden(pawn);
}
else
{
forbiddenInitially = false;
}
}
protected virtual void ListenTickAction()
{
if (!Gramophone.IsOn())
{
EndJobWith(JobCondition.Incompletable);
return;
}
pawn.rotationTracker.FaceCell(TargetA.Cell);
pawn.GainComfortFromCellIfPossible();
var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor);
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, statValue);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.EndOnDespawnedOrNull(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A, job.def.joyMaxParticipants));
if (TargetB != null)
{
yield return(Toils_Reserve.Reserve(TargetIndex.B));
}
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell));
var toil = new Toil();
var soundDef = Find.World.GetComponent <WorldComponent_Tunes>().TuneDefCache
.FindAll(x => x.instrumentDefs.Contains(TargetThingA.def)).RandomElement();
toil.PlaySustainerOrSound(soundDef);
toil.tickAction = delegate
{
pawn.rotationTracker.FaceCell(TargetA.Cell);
pawn.GainComfortFromCellIfPossible();
var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor);
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, statValue);
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = job.def.joyDuration;
toil.AddFinishAction(delegate
{
if (Utility.IsCosmicHorrorsLoaded())
{
try
{
if (Utility.HasSanityLoss(pawn))
{
Utility.ApplySanityLoss(pawn, -sanityRestoreRate);
Messages.Message(
pawn + " has restored some sanity using the " + TargetA.Thing.def.label + ".",
new TargetInfo(pawn.Position, pawn.Map), MessageTypeDefOf.NeutralEvent); // .Standard);
}
}
catch
{
Log.Message("Error loading Sanity Hediff.");
}
}
JoyUtility.TryGainRecRoomThought(pawn);
});
yield return(toil);
}
protected void ReadTickAction()
{
this.pawn.rotationTracker.FaceCell(TargetB.Cell);
this.pawn.GainComfortFromCellIfPossible();
var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor, true);
Pawn pawn = this.pawn;
var extraJoyGainFactor = statValue;
if (TargetThingA is GuideBook gBook)
{
gBook.Teach(pawn);
}
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.GoToNextToil, extraJoyGainFactor);
}
//[DebuggerHidden]
protected override IEnumerable <Toil> MakeNewToils()
{
ProblemWorker_Hacker pw = GetProblemWorker();
if (pw == null)
{
yield break;
}
this.AddEndCondition(() => pw.IsRunning() && !pw.HasHackingStopped() && (TargetThingA.TryGetComp <CompHacked>()?.investigatable ?? false)
? JobCondition.Ongoing : JobCondition.Incompletable);
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil doWork = new Toil().FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
doWork.initAction = () => {
this.totalWorkNeeded = 300f;
this.workLeft = this.totalWorkNeeded;
};
doWork.tickAction = () => {
this.workLeft -= this.pawn.GetStatValue(StatDefOf.ResearchSpeed, true);
this.pawn.skills.GetSkill(SkillDefOf.Intellectual).Learn(5f, false);
if (this.workLeft <= 0f)
{
doWork.actor.jobs.curDriver.ReadyForNextToil();
}
};
doWork.defaultCompleteMode = ToilCompleteMode.Never;
doWork.WithProgressBar(TargetIndex.A, () => 1f - this.workLeft / this.totalWorkNeeded, false, -0.5f);
yield return(doWork);
Toil foundEm = new Toil();
foundEm.defaultCompleteMode = ToilCompleteMode.Instant;
foundEm.initAction = delegate {
ResearchProjectDef current = Find.ResearchManager.currentProj;
Find.ResearchManager.currentProj = DefDatabase <ResearchProjectDef> .GetNamed("HackingCountermeasures");
Find.ResearchManager.ResearchPerformed(500 / 0.007f, null); //Constant from inside ResearchManager
Find.ResearchManager.currentProj = current;
this.pawn.skills.GetSkill(SkillDefOf.Intellectual).Learn(500f, false);
TargetThingA.TryGetComp <CompHacked>().investigatable = false;
Find.LetterStack.ReceiveLetter("ProblemHackerInvestigateHackingLetterLabel".Translate(),
"ProblemHackerInvestigateHackingLetterText".Translate(this.pawn.NameStringShort), LetterDefOf.PositiveEvent);
};
yield return(foundEm);
}
protected override IEnumerable <Toil> MakeNewToils()
{
///
//Set fail conditions
///
this.FailOnDestroyed(HaulableInd);
this.FailOnDestroyed(CarrierInd);
//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(HaulableInd);
}
///
//Define Toil
///
Toil toilGoto = null;
toilGoto = Toils_Goto.GotoThing(HaulableInd, PathMode.ClosestTouch)
.FailOn(() =>
{
Vehicle_Cargo vc = CurJob.GetTarget(CarrierInd).Thing as Vehicle_Cargo;
if (!vc.storage.CanAcceptAnyOf(CurJob.GetTarget(HaulableInd).Thing))
{
return(true);
}
return(false);
});
///
//Toils Start
///
//Reserve thing to be stored and storage cell
yield return(Toils_Reserve.Reserve(HaulableInd));
//Collect Target
yield return(toilGoto);
yield return(ToolsForHaul.Toils_Collect.CollectThing(HaulableInd, CarrierInd));
}
protected override IEnumerable <Toil> MakeNewToils()
{
Utility.Log($"Making new toils for {pawn} to destroy {TargetThingA.LabelCap}...");
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOnThingMissingDesignation(TargetIndex.A, DestroyItemDefOf.Designation_DestroyItem);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil destroyToil = new Toil();
destroyToil.tickAction = () =>
{
if (!TargetThingA.IsHashIntervalTick(GenTicks.TicksPerRealSecond))
{
return;
}
float hpLossAmount = pawn.GetStatValue(StatDefOf.MeleeDPS) * pawn.GetStatValue(StatDefOf.GeneralLaborSpeed) * Settings.destructionSpeed;
if (Settings.instantDestruction || hpLossAmount >= TargetThingA.HitPoints)
{
pawn.records.Increment(DestroyItemDefOf.Record_ItemsDestroyed);
if (TargetThingA is Corpse corpse && corpse.InnerPawn.RaceProps.Humanlike)
{
Utility.Log($"The destroyed item was a humanlike corpse. Adding bad thoughts to {pawn} and other pawns.");
if (pawn.needs?.mood?.thoughts != null)
{
pawn.needs.mood.thoughts.memories.TryGainMemory(DestroyItemDefOf.Thought_DestroyedCorpse);
}
foreach (Pawn p in pawn.Map.mapPawns.SpawnedPawnsInFaction(pawn.Faction).Where(p => pawn != p && p.needs?.mood?.thoughts != null))
{
p.needs.mood.thoughts.memories.TryGainMemory(DestroyItemDefOf.Thought_KnowDestroyedCorpse);
}
}
TargetThingA.HitPoints = 0;
TargetThingA.Destroy();
ReadyForNextToil();
}
else
{
TargetThingA.TakeDamage(new DamageInfo(DamageDefOf.Deterioration, hpLossAmount, instigator: pawn));
}
};
destroyToil.defaultCompleteMode = ToilCompleteMode.Never;
destroyToil.WithProgressBar(TargetIndex.A, () => 1f - (float)job.targetA.Thing.HitPoints / job.targetA.Thing.MaxHitPoints);
destroyToil.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
yield return(destroyToil);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
///
//Set fail conditions
///
this.FailOnDestroyedOrNull(CartInd);
//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(CartInd);
}
Vehicle_Cart cart = TargetThingA as Vehicle_Cart;
///
//Define Toil
///
Toil toilGoToCell = Toils_Goto.GotoCell(StoreCellInd, PathEndMode.ClosestTouch);
///
//Toils Start
///
//Reserve thing to be stored and storage cell
yield return(Toils_Reserve.Reserve(CartInd));
yield return(Toils_Reserve.Reserve(StoreCellInd));
//JumpIf already mounted
yield return(Toils_Jump.JumpIf(toilGoToCell, () => { return (cart.GetComp <CompMountable>().Driver == pawn) ? true : false; }));
//Mount on Target
yield return(Toils_Goto.GotoThing(CartInd, PathEndMode.ClosestTouch)
.FailOnDestroyedOrNull(CartInd));
yield return(Toils_Cart.MountOn(CartInd));
//Dismount
yield return(toilGoToCell);
yield return(Toils_Cart.DismountAt(CartInd, StoreCellInd));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.EndOnDespawnedOrNull(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A, job.def.joyMaxParticipants));
if (TargetB != null)
{
yield return(Toils_Reserve.Reserve(TargetIndex.B));
}
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell));
var toil = new Toil();
toil.PlaySustainerOrSound(DefDatabase <SoundDef> .GetNamed("Estate_SoundManualTypewriter"));
toil.tickAction = delegate
{
pawn.rotationTracker.FaceCell(TargetA.Cell);
pawn.GainComfortFromCellIfPossible();
var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor);
JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, statValue);
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = job.def.joyDuration;
// toil.AddFinishAction(delegate
// {
// if (Cthulhu.Utility.IsCosmicHorrorsLoaded())
// {
// try
// {
// if (Cthulhu.Utility.HasSanityLoss(this.pawn))
// {
// Cthulhu.Utility.ApplySanityLoss(this.pawn, -sanityRestoreRate, 1);
// Messages.Message(this.pawn.ToString() + " has restored some sanity using the " + this.TargetA.Thing.def.label + ".", new TargetInfo(this.pawn.Position, this.pawn.Map), MessageTypeDefOf.NeutralEvent);// .Standard);
// }
// }
// catch
// {
// Log.Message("Error loading Sanity Hediff.");
// }
// }
//
// JoyUtility.TryGainRecRoomThought(this.pawn);
// });
yield return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
AddFailCondition(JobHasFailed);
this.FailOnDestroyedNullOrForbidden(TargetIndex.A);
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch));
yield return(new Toil {
initAction = () => {
TargetThingA.TrySwitch();
TargetThingA.UpdateSwitchDesignation();
for (int i = 0; i <= 10; i++)
{
MoteMaker.ThrowDustPuff(TargetThingA.Position, Map, 1);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
///
//Set fail conditions
///
//this.FailOnBurningImmobile(MountCellInd);
this.FailOnDestroyedOrNull(MountableInd);
//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
///
///
//Toils Start
///
//Reserve thing to be stored and storage cell
//yield return Toils_Reserve.Reserve(MountableInd, ReservationType.Total);
//Mount on Target
yield return(Toils_Goto.GotoThing(MountableInd, PathEndMode.ClosestTouch));
Toil toilBoardOn = new Toil();
toilBoardOn.initAction = () =>
{
Pawn actor = toilBoardOn.actor;
Vehicle_Saddle vehicle = TargetThingA as Vehicle_Saddle;
vehicle.BoardOn(actor);
};
yield return(toilBoardOn);
}
protected override IEnumerable <Toil> MakeNewToils()
{
ICharge chargee = (ICharge)this.pawn;
CompDroidCharger charger = TargetThingA.TryGetComp <CompDroidCharger>();
yield return(Toils_Reserve.Reserve(TargetIndex.A));
Toil goToPad = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
goToPad.AddFailCondition(() => { return(!charger.IsAvailable(chargee)); });
yield return(goToPad);
Toil charge = new Toil();
charge.initAction = () =>
{
if (charger.parent.InteractionCell != chargee.Parent.Position)
{
pawn.jobs.EndCurrentJob(JobCondition.Errored);
}
else
{
charger.BeginCharge(chargee);
chargee.ShouldUsePower = false;
}
};
charge.defaultCompleteMode = ToilCompleteMode.Never;
charge.AddFailCondition(() =>
{ return(!charger.IsAvailable(chargee)); });
charge.AddEndCondition(() =>
{
if (!chargee.DesiresCharge)
{
return(JobCondition.Succeeded);
}
return(JobCondition.Ongoing);
});
charge.AddFinishAction(() =>
{
charger.EndCharge();
chargee.ShouldUsePower = true;
});
yield return(charge);
}
protected override IEnumerable <Toil> MakeNewToils()
{
///
//Set fail conditions
///
this.FailOnDestroyed(MountableInd);
//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
///
///
//Toils Start
///
//Reserve thing to be stored and storage cell
yield return(Toils_Reserve.Reserve(MountableInd));
//Mount on Target
yield return(Toils_Goto.GotoThing(MountableInd, PathEndMode.ClosestTouch));
Toil toilMountOn = new Toil();
toilMountOn.initAction = () =>
{
Pawn actor = toilMountOn.actor;
Job curJob = actor.jobs.curJob;
TargetThingA.TryGetComp <CompMountable>().MountOn(actor);
};
yield return(toilMountOn);
}
//[DebuggerHidden]
protected override IEnumerable <Toil> MakeNewToils()
{
ProblemWorker_Hacker pw = GetProblemWorker();
if (pw == null)
{
yield break;
}
this.AddEndCondition(() => pw.IsRunning() && !pw.HasHackingStopped() && TargetThingA.TryGetComp <CompHacked>() != null
? JobCondition.Ongoing : JobCondition.Incompletable);
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil doWork = new Toil().FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
doWork.initAction = () => {
this.totalWorkNeeded = 100f;
this.workLeft = this.totalWorkNeeded;
};
doWork.tickAction = () => {
this.workLeft -= this.pawn.GetStatValue(StatDefOf.ResearchSpeed, true);
this.pawn.skills.GetSkill(SkillDefOf.Intellectual).Learn(5f, false);
if (this.workLeft <= 0f)
{
doWork.actor.jobs.curDriver.ReadyForNextToil();
}
};
doWork.defaultCompleteMode = ToilCompleteMode.Never;
doWork.WithProgressBar(TargetIndex.A, () => 1f - this.workLeft / this.totalWorkNeeded, false, -0.5f);
yield return(doWork);
Toil foundEm = new Toil();
foundEm.defaultCompleteMode = ToilCompleteMode.Instant;
foundEm.initAction = delegate {
FindExt.DynamicComponentManager.RemoveDynamicThingComp <CompHacked> (TargetThingA as ThingWithComps);
};
yield return(foundEm);
}
protected void RollForLuck()
{
var extraLuckFromQuality = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor, true);
float extraLuckFromHobbitSmarts = pawn.skills.GetSkill(SkillDefOf.Intellectual).levelInt;
var yourLuckyNumber = (1f + extraLuckFromHobbitSmarts) * extraLuckFromQuality / 100;
Log.Message("lucky number is: " + yourLuckyNumber.ToString());
if (Rand.Chance(yourLuckyNumber) || DebugSettings.godMode)
{
Thing reward = ThingMaker.MakeThing(ThingDefOf.Gold);
reward.stackCount = Rand.RangeInclusive(10, 50);
GenSpawn.Spawn(reward, pawn.Position, pawn.Map);
PuzzleBox.Destroy();
Letter letter = LetterMaker.MakeLetter("LotRH_PuzzleSolvedLabel".Translate(), "LotRH_PuzzleSolved".Translate(new object[] {
pawn.Label,
reward.Label,
}), LetterDefOf.PositiveEvent);
Find.LetterStack.ReceiveLetter(letter);
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
//Set fail conditions
this.FailOnDestroyedNullOrForbidden(RobotDestroyedInd);
this.FailOnBurningImmobile(RobotDestroyedInd);
//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(RobotDestroyedInd);
}
//Reserve target, if it is a storage
yield return(Toils_Reserve.Reserve(RobotDestroyedInd, 1));
if (pawn.jobs.curJob.GetTarget(RechargeStationInd).Thing != null)
{
//yield return toilGoto;
yield return(Toils_Goto.GotoThing(RechargeStationInd, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(RechargeStationInd));
// start work on target
yield return(Toils_WaitWithSoundAndEffect(workTime, "Interact_ConstructMetal", "ConstructMetal", RechargeStationInd));
yield return(Toils_TryToDeconstructRechargeStation(pawn, RobotDestroyedInd));
}
//yield return toilGoto;
yield return(Toils_Goto.GotoThing(RobotDestroyedInd, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(RobotDestroyedInd));
// start work on target
yield return(Toils_WaitWithSoundAndEffect(workTime, "Interact_ConstructMetal", "ConstructMetal", RobotDestroyedInd));
yield return(Toils_TryToDeconstructRobot(pawn, RobotDestroyedInd));
}
protected override IEnumerable <Toil> MakeNewToils()
{
//A: haul thing
//B: destination loc
//Set fail conditions
this.FailOnDestroyed(TargetIndex.A);
this.FailOnBurningImmobile(TargetIndex.B);
//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())
{
this.FailOnForbidden(TargetIndex.A);
}
//Reserve targets
yield return(Toils_Reserve.ReserveTarget(TargetIndex.B, ReservationType.Store));
Toil reserveTargetA = Toils_Reserve.ReserveTarget(TargetIndex.A, ReservationType.Total);
yield return(reserveTargetA);
Toil toilGoto = null;
toilGoto = Toils_Goto.GotoThing(TargetIndex.A, PathMode.ClosestTouch)
.FailOn(() =>
{
//Note we don't fail on losing hauling designation
//Because that's a special case anyway
//If hauling to square storage, ensure storage dest is still valid
Pawn actor = toilGoto.actor;
Job curJob = actor.jobs.curJob;
if (curJob.haulMode == HaulMode.ToSquareStorage)
{
Thing haulThing = curJob.GetTarget(TargetIndex.A).Thing;
IntVec3 destLoc = actor.jobs.curJob.GetTarget(TargetIndex.B).Loc;
if (!destLoc.IsValidStorageFor(haulThing))
{
return(true);
}
}
return(false);
});
yield return(toilGoto);
yield return(Toils_Haul.StartCarryThing(TargetIndex.A));
if (CurJob.haulOpportunisticDuplicates)
{
yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveTargetA));
}
Toil carryToSquare = Toils_Haul.CarryHauledThingToSquare(TargetIndex.B);
yield return(carryToSquare);
yield return(Toils_Haul.PlaceHauledThingInSquare(TargetIndex.B, carryToSquare));
}
protected override IEnumerable <Toil> MakeNewToils()
{
///
//Set fail conditions
///
this.FailOnDestroyedOrNull(CartInd);
//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(CartInd);
}
ThingWithComps cart = TargetThingA as ThingWithComps;
if (ToolsForHaulUtility.FindStorageCell(pawn, cart) == IntVec3.Invalid)
{
JobFailReason.Is(ToolsForHaulUtility.NoEmptyPlaceForCart);
}
if (cart.TryGetComp <CompMountable>().Driver != null)
{
this.FailOnSomeonePhysicallyInteracting(CartInd);
}
///
//Define Toil
///
Toil toilGoToCell = Toils_Goto.GotoCell(StoreCellInd, PathEndMode.ClosestTouch);
///
//Toils Start
///
//Reserve thing to be stored and storage cell
yield return(Toils_Reserve.Reserve(CartInd));
yield return(Toils_Reserve.Reserve(StoreCellInd));
//JumpIf already mounted
yield return(Toils_Jump.JumpIf(toilGoToCell, () =>
{
return cart.TryGetComp <CompMountable>().Driver == pawn ? true : false;
}));
//Mount on Target
yield return(Toils_Goto.GotoThing(CartInd, PathEndMode.ClosestTouch)
.FailOnDestroyedOrNull(CartInd));
yield return(Toils_Cart.MountOn(CartInd));
//Dismount
yield return(toilGoToCell);
yield return(Toils_Cart.DismountAt(CartInd, StoreCellInd));
}
// Token: 0x0600008F RID: 143 RVA: 0x00005929 File Offset: 0x00003B29
protected override IEnumerable <Toil> MakeNewToils()
{
var actor = GetActor();
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)
.FailOnDespawnedNullOrForbidden(TargetIndex.A));
var refuel = Toils_General.Wait(180);
refuel.FailOnDespawnedNullOrForbidden(TargetIndex.A);
refuel.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
refuel.WithProgressBarToilDelay(TargetIndex.A);
yield return(refuel);
yield return(new Toil
{
initAction = delegate
{
if (actor == null || actor.apparel.WornApparelCount <= 0)
{
EndJobWith(JobCondition.Incompletable);
return;
}
Apparel GhostGear = null;
var list = actor.apparel.WornApparel;
foreach (var ghostGear in list)
{
if (ghostGear is not GhostGearApparel)
{
continue;
}
GhostGear = ghostGear;
break;
}
if (GhostGear == null)
{
EndJobWith(JobCondition.Incompletable);
return;
}
var CaltropsHave = (GhostGear as GhostGearApparel).CaltropsUses;
var CaltropsMax = (GhostGear as GhostGearApparel).CaltropsMax;
if (CaltropsMax - CaltropsHave <= 0)
{
EndJobWith(JobCondition.Incompletable);
return;
}
var actorlabel = actor.LabelShort.CapitalizeFirst() != null
? actor.LabelShort.CapitalizeFirst()
: "Someone";
var gglabel = GhostGear.Label.CapitalizeFirst() != null
? GhostGear.Label.CapitalizeFirst()
: "Ghost Gear";
var def = TargetThingA.def;
var thinglabel = def?.label.CapitalizeFirst() != null
? TargetThingA.def.label.CapitalizeFirst()
: "Caltrops Pod";
if (TargetThingA.stackCount > CaltropsMax - CaltropsHave)
{
(GhostGear as GhostGearApparel).CaltropsUses = CaltropsMax;
TargetThingA.stackCount -= CaltropsMax - CaltropsHave;
if (Controller.Settings.ShowAutoRearmMsg)
{
Messages.Message("GhostGear.FullyRearmed".Translate(actorlabel, gglabel, thinglabel), actor,
MessageTypeDefOf.NeutralEvent, false);
}
EndJobWith(JobCondition.Succeeded);
return;
}
(GhostGear as GhostGearApparel).CaltropsUses = CaltropsHave + TargetThingA.stackCount;
if (Controller.Settings.ShowAutoRearmMsg)
{
Messages.Message(
"GhostGear.CaltropsRearmed".Translate(actorlabel, gglabel,
TargetThingA.stackCount.ToString(), TargetThingA.stackCount > 1 ? "s" : "", thinglabel),
actor, MessageTypeDefOf.NeutralEvent, false);
}
TargetThingA.Destroy();
EndJobWith(JobCondition.Succeeded);
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
//Log.Message("Toil start:" + pawn + " is trying to learn " + project + ", globalFailConditions count:" + globalFailConditions.Count);
Dictionary <ResearchProjectDef, float> expertise = pawn.TryGetComp <CompKnowledge>().expertise;
AddEndCondition(delegate
{
if (!desk.Spawned)
{
return(JobCondition.Incompletable);
}
return(JobCondition.Ongoing);
});
this.FailOnBurningImmobile(TargetIndex.A);
this.FailOn(delegate()
{
IBillGiver billGiver = desk as IBillGiver;
if (billGiver != null)
{
if (job.bill.DeletedOrDereferenced)
{
return(true);
}
if (!billGiver.CurrentlyUsableForBills())
{
return(true);
}
if (project == null)
{
Log.Warning("[HumanResources] " + pawn + " tried to learn a null project.");
TryMakePreToilReservations(true);
return(true);
}
bool flag = IsResearch ? project.IsKnownBy(pawn) : !techComp.homework.Contains(project);
if (flag)
{
return(true);
}
}
return(false);
});
Toil gotoBillGiver = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
yield return(gotoBillGiver);
Toil acquireKnowledge = new Toil();
acquireKnowledge.initAction = delegate()
{
Pawn actor = acquireKnowledge.actor;
if (!expertise.ContainsKey(project))
{
expertise.Add(project, 0f);
}
};
acquireKnowledge.AddEndCondition(delegate
{
Pawn actor = acquireKnowledge.actor;
if (expertise.ContainsKey(project) && expertise[project] > 1f)
{
expertise[project] = 1f;
if (!IsResearch)
{
Notify_IterationCompleted(actor, job.bill as Bill_Production);
techComp.homework.Remove(project);
}
techComp.LearnCrops(project);
Messages.Message("MessageStudyComplete".Translate(actor, project.LabelCap), desk, MessageTypeDefOf.TaskCompletion, true);
project = null;
return(JobCondition.Succeeded);
}
return(JobCondition.Ongoing);
});
acquireKnowledge.tickAction = delegate()
{
Pawn actor = acquireKnowledge.actor;
float num = actor.GetStatValue(StatDefOf.ResearchSpeed, true);
num *= TargetThingA.GetStatValue(StatDefOf.ResearchSpeedFactor, true);
float workAmount = IsResearch ? 1f : job.bill.recipe.workAmount;
project.Learned(num, workAmount, actor, job.bill == null);
actor.skills.Learn(SkillDefOf.Intellectual, 0.1f, false);
actor.GainComfortFromCellIfPossible(true);
};
acquireKnowledge.AddFinishAction(delegate
{
Pawn actor = acquireKnowledge.actor;
if (job.bill != null && job.RecipeDef.workSkill != null)
{
float xp = ticksSpentDoingRecipeWork * 0.1f * job.RecipeDef.workSkillLearnFactor;
actor.skills.GetSkill(job.RecipeDef.workSkill).Learn(xp, false);
}
});
acquireKnowledge.FailOn(() => project == null);
//research.FailOn(() => !this.Project.CanBeResearchedAt(this.ResearchBench, false)); //need rework
acquireKnowledge.FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell);
acquireKnowledge.FailOnDespawnedOrNull(TargetIndex.A);
acquireKnowledge.WithEffect(EffecterDefOf.Research, TargetIndex.A);
acquireKnowledge.WithProgressBar(TargetIndex.A, delegate
{
if (project == null)
{
return(0f);
}
return(expertise[project]);
}, false, -0.5f);
acquireKnowledge.defaultCompleteMode = ToilCompleteMode.Delay;
acquireKnowledge.defaultDuration = 4000;
acquireKnowledge.activeSkill = () => SkillDefOf.Intellectual;
yield return(acquireKnowledge);
yield return(Toils_General.Wait(2, TargetIndex.None));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
var upgrade = TargetThingA.FirstUpgradeableComp();
if (upgrade == null)
{
EndJobWith(JobCondition.Incompletable);
yield break;
}
AddFailCondition(() => {
var comp = TargetThingA.FirstUpgradeableComp();
return(comp == null || !comp.parent.Spawned || !comp.WantsWork);
});
this.FailOnDestroyedNullOrForbidden(TargetIndex.A);
var gotoUpgradeable = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
var lookForIngredient = new Toil
{
initAction = () => {
var missingIngredient = upgrade.TryGetNextMissingIngredient();
job.count = missingIngredient.Count;
if (missingIngredient.Count > 0)
{
bool SearchPredicate(Thing thing) => !thing.IsForbidden(pawn) && pawn.CanReserve(thing);
var t = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(missingIngredient.ThingDef), PathEndMode.ClosestTouch, TraverseParms.For(pawn), 999,
SearchPredicate);
if (t == null)
{
EndJobWith(JobCondition.Incompletable);
}
else
{
job.SetTarget(TargetIndex.B, t);
}
}
else
{
JumpToToil(gotoUpgradeable);
}
}
};
yield return(lookForIngredient);
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, job.count));
yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.Touch).FailOnDestroyedNullOrForbidden(TargetIndex.B));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B));
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.InteractionCell));
yield return(new Toil
{
initAction = () => {
if (pawn.carryTracker.CarriedThing != null)
{
pawn.carryTracker.innerContainer.TryTransferToContainer(pawn.carryTracker.CarriedThing, upgrade.GetDirectlyHeldThings(), pawn.carryTracker.CarriedThing.stackCount);
pawn.Map.reservationManager.ReleaseAllForTarget(TargetThingB);
job.SetTarget(TargetIndex.B, null);
JumpToToil(lookForIngredient);
}
}
});
yield return(gotoUpgradeable);
yield return(new Toil
{
tickAction = () => {
upgrade.DoWork(GetActor().GetStatValue(StatDefOf.ConstructionSpeed));
if (upgrade.curComplete)
{
EndJobWith(JobCondition.Succeeded);
}
},
defaultCompleteMode = ToilCompleteMode.Never
}.WithEffect(EffecterDefOf.ConstructMetal, TargetIndex.A)
.WithProgressBar(TargetIndex.A, () => upgrade.WorkProgress));
}
}
// Token: 0x0600003C RID: 60 RVA: 0x000038A6 File Offset: 0x00001AA6
protected override IEnumerable <Toil> MakeNewToils()
{
var actor = GetActor();
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)
.FailOnDespawnedNullOrForbidden(TargetIndex.A));
var refuel = Toils_General.Wait(180);
refuel.FailOnDespawnedNullOrForbidden(TargetIndex.A);
refuel.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
refuel.WithProgressBarToilDelay(TargetIndex.A);
yield return(refuel);
yield return(new Toil
{
initAction = delegate
{
var obj = actor;
if (obj != null && obj.apparel.WornApparelCount == 0)
{
//Log.Message("True: obj != null && obj.apparel.WornApparelCount == 0");
EndJobWith(JobCondition.Incompletable);
return;
}
Apparel JetPack = null;
var list = actor.apparel.WornApparel;
foreach (var jetPack in list)
{
if (jetPack is not JetPackApparel)
{
continue;
}
JetPack = jetPack;
break;
}
if (JetPack == null)
{
EndJobWith(JobCondition.Incompletable);
return;
}
//Log.Message("True: JetPack is JetPackApparel");
var JPFuel = (JetPack as JetPackApparel).JPFuelAmount;
var JPMax = (JetPack as JetPackApparel).JPFuelMax;
if (JPMax - JPFuel <= 0)
{
//Log.Message("True: JPMax - JPFuel <= 0");
EndJobWith(JobCondition.Incompletable);
return;
}
if (TargetThingA.stackCount > JPMax - JPFuel)
{
//Log.Message("True: this.TargetThingA.stackCount > JPMax - JPFuel");
(JetPack as JetPackApparel).JPFuelAmount = JPMax;
TargetThingA.stackCount -= JPMax - JPFuel;
Messages.Message("JetPack.FullyRefueled".Translate(actor.LabelShort), actor,
MessageTypeDefOf.NeutralEvent, false);
EndJobWith(JobCondition.Succeeded);
return;
}
//Log.Message("False");
(JetPack as JetPackApparel).JPFuelAmount = JPFuel + TargetThingA.stackCount;
Messages.Message(
"JetPack.Refueled".Translate(actor.LabelShort.CapitalizeFirst(),
TargetThingA.stackCount.ToString(), TargetThingA.stackCount > 1 ? "s" : ""), actor,
MessageTypeDefOf.NeutralEvent, false);
TargetThingA.Destroy();
EndJobWith(JobCondition.Succeeded);
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
//fail if can't do violence
base.AddFailCondition(delegate
{
return(this.pawn.WorkTagIsDisabled(WorkTags.Violent));
});
this.jobStartTick = Find.TickManager.TicksGame;
Func <bool> designationValidator = () => !(
// Dummy must have the any designation
TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignation)
||
// Dummy must have the melee designation, and the pawn has a melee weapon held
TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignationMeleeOnly) &&
pawn.equipment.Primary.def.IsMeleeWeapon
||
// Dummy must have the ranged designation, and the pawn has a ranged weapon held
TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignationRangedOnly) &&
pawn.equipment.Primary.def.IsRangedWeapon
||
// Dummy must have any designation, and the pawn is unarmed.
(TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignation) ||
TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignationMeleeOnly) ||
TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignationRangedOnly)) &&
pawn.equipment.Primary == null);
//make sure thing has train combat designation
if (designationValidator())
{
yield break;
}
// Make sure our dummy isn't already in use
this.FailOnSomeonePhysicallyInteracting(TargetIndex.A);
//fail if dummy is despawned null or forbidden
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
/**** START SWITCH TO TRAINING WEAPON ****/
//Pick up a training weapon if one is nearby. Remember previous weapon
ThingWithComps startingEquippedWeapon = this.pawn.equipment.Primary;
ThingWithComps trainingWeapon = null;
if (startingEquippedWeapon == null || !startingEquippedWeapon.def.IsWithinCategory(CombatTrainingDefOf.TrainingWeapons))
{
trainingWeapon = GetNearestTrainingWeapon(startingEquippedWeapon);
if (trainingWeapon != null && !trainingWeapon.IsForbidden(pawn))
{
//reserve training weapon, goto, and equip
if (this.Map.reservationManager.CanReserve(this.pawn, trainingWeapon, 1, -1, null, false))
{
this.pawn.Reserve(trainingWeapon, this.job, 1, -1, null, true);
this.job.SetTarget(TargetIndex.B, trainingWeapon);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.B));
yield return(CreateEquipToil(TargetIndex.B));
}
//reserve previous weapon and set as target c
if (this.Map.reservationManager.CanReserve(this.pawn, startingEquippedWeapon, 1, -1, null, false))
{
this.pawn.Reserve(startingEquippedWeapon, this.job, 1, -1, null, true);
this.job.SetTarget(TargetIndex.C, startingEquippedWeapon);
}
}
}
Toil reequipStartingWeaponLabel = Toils_General.Label();
/**** END SWITCH TO TRAINING WEAPON ****/
//set the job's attack verb to melee or shooting - needed to gotoCastPosition or stack overflow occurs
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
//based on attack verb, go to cast position
Toil gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, true, 0.95f).EndOnDespawnedOrNull(TargetIndex.A);
yield return(gotoCastPos);
//try going to new cast position if the target can't be hit from current position
yield return(Toils_Jump.JumpIfTargetNotHittable(TargetIndex.A, gotoCastPos));
//training loop - jump if done training -> cast verb -> jump to done training
//if done training jumnp to reequipStartingWeaponLabel
Toil doneTraining = Toils_Jump.JumpIf(reequipStartingWeaponLabel, delegate
{
if (LearningSaturated())
{
return(true);
}
else
{
return(Dummy.Destroyed || Find.TickManager.TicksGame > this.jobStartTick + 5000 || designationValidator());
}
});
yield return(doneTraining);
Toil castVerb = Toils_Combat.CastVerb(TargetIndex.A, false);
castVerb.AddFinishAction(delegate
{
LearnAttackSkill();
});
yield return(castVerb);
yield return(Toils_Jump.Jump(doneTraining));
yield return(reequipStartingWeaponLabel);
//gain room buff
yield return(Toils_General.Do(delegate
{
TryGainCombatTrainingRoomThought();
}));
//equip strating weapon
if (trainingWeapon != null && startingEquippedWeapon != null)
{
yield return(Toils_Goto.GotoThing(TargetIndex.C, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.C));
yield return(CreateEquipToil(TargetIndex.C));
}
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch).FailOn(() => GenPlant.AdjacentSowBlocker(job.plantDefToSow, TargetA.Cell, Map) != null).FailOn(() => !job.plantDefToSow.CanEverPlantAt(TargetLocA, Map)));
Toil sowToil = new Toil()
{
initAction = delegate {
TargetThingA = GenSpawn.Spawn(job.plantDefToSow, TargetLocA, Map);
pawn.Reserve(TargetThingA, job);
PlantWithSecondary plant = (PlantWithSecondary)TargetThingA;
plant.Growth = 0f;
plant.sown = true;
},
tickAction = delegate {
Pawn actor = GetActor();
if (actor.skills != null)
{
actor.skills.Learn(SkillDefOf.Growing, 0.11f, false);
}
float statValue = actor.GetStatValue(StatDefOf.PlantWorkSpeed, true);
float num = statValue;
PlantWithSecondary plant = Plant;
if (plant.LifeStage != PlantLifeStage.Sowing)
{
Log.Error(this + " getting sowing work while not in Sowing life stage.");
}
sowWorkDone += num;
if (sowWorkDone >= plant.def.plant.sowWork)
{
plant.Growth = 0.05f;
plant.Sec_Growth = 0.05f;
Map.mapDrawer.MapMeshDirty(plant.Position, MapMeshFlag.Things);
actor.records.Increment(RecordDefOf.PlantsSown);
ReadyForNextToil();
return;
}
},
defaultCompleteMode = ToilCompleteMode.Never
};
sowToil.FailOnDespawnedNullOrForbidden(TargetIndex.A);
sowToil.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
sowToil.WithEffect(EffecterDefOf.Sow, TargetIndex.A);
sowToil.WithProgressBar(TargetIndex.A, () => sowWorkDone / Plant.def.plant.sowWork, true, -0.5f);
sowToil.PlaySustainerOrSound(() => SoundDefOf.Interact_Sow);
sowToil.AddFinishAction(delegate {
if (TargetThingA != null)
{
PlantWithSecondary plant = (PlantWithSecondary)GetActor().CurJob.GetTarget(TargetIndex.A).Thing;
if (sowWorkDone < plant.def.plant.sowWork && !TargetThingA.Destroyed)
{
TargetThingA.Destroy(DestroyMode.Vanish);
}
}
});
yield return(sowToil);
if (pawn.story.traits.HasTrait(TraitDefOf.GreenThumb))
{
yield return(new Toil {
initAction = delegate {
pawn.needs.mood.thoughts.memories.TryGainMemory(ThoughtDefOf.GreenThumbHappy, null);
}
});
}
}
