protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
var verb = pawn.CurJob.verbToUse as Verb_UseAbility;
Find.Targeter.targetingSource = verb;
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
yield return(new Toil
{
initAction = delegate { verb.Ability.PostAbilityAttempt(); },
defaultCompleteMode = ToilCompleteMode.Instant
});
yield return(new Toil
{
initAction = delegate
{
if (verb.UseAbilityProps.isViolent)
{
JobDriver_CastAbilityVerb.CheckForAutoAttack(this.pawn);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
Verb_UseAbility verb = this.pawn.CurJob.verbToUse as Verb_UseAbility;
//Toil getInRangeToil = GotoCastPosition(TargetIndex.A, false);
//yield return getInRangeToil;
Find.Targeter.targetingVerb = verb;
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
this.AddFinishAction(() =>
{
//if (compAbilityUser.IsActive)
//{
//}
//compAbilityUser.IsActive = false;
if (this.CompAbilityUsers is List <CompAbilityUser> users && !users.NullOrEmpty())
{
foreach (CompAbilityUser u in users)
{
u.PostAbilityAttempt(this.pawn, verb.ability.powerdef);
}
}
});
}
// Token: 0x06003B77 RID: 15223 RVA: 0x001BFC0C File Offset: 0x001BE00C
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_General.DoAtomic(delegate
{
Pawn pawn = this.job.targetA.Thing as Pawn;
if (pawn != null && pawn.Downed && this.pawn.mindState.duty != null && this.pawn.mindState.duty.attackDownedIfStarving && this.pawn.Starving())
{
this.job.killIncappedTarget = true;
}
}));
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
yield return(Toils_Combat.FollowAndMeleeAttack(TargetIndex.A, delegate
{
Thing thing = this.job.GetTarget(TargetIndex.A).Thing;
if (this.pawn.meleeVerbs.TryMeleeAttack(thing, this.job.verbToUse, false))
{
if (this.pawn.CurJob == null || this.pawn.jobs.curDriver != this)
{
return;
}
this.numMeleeAttacksMade++;
if (this.numMeleeAttacksMade >= this.job.maxNumMeleeAttacks)
{
base.EndJobWith(JobCondition.Succeeded);
return;
}
}
}).FailOnDespawnedOrNull(TargetIndex.A));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
yield return(Toils_Combat.FollowAndMeleeAttack(TargetIndex.A, delegate
{
Thing thing = this.job.GetTarget(TargetIndex.A).Thing;
if (this.pawn.meleeVerbs.TryMeleeAttack(thing, this.job.verbToUse, false))
{
if (this.pawn.CurJob == null || this.pawn.jobs.curDriver != this)
{
return;
}
this.numMeleeAttacksMade++;
if (thing.GetType() == typeof(Pawn))
{
Pawn targetPawn = thing as Pawn;
targetPawn.health.AddHediff(HediffDef.Named("GR_ChickenRimPox"));
HealthUtility.AdjustSeverity(targetPawn, HediffDef.Named("GR_ChickenRimPox"), 0.3f);
}
if (this.numMeleeAttacksMade >= 1)
{
this.EndJobWith(JobCondition.Succeeded);
pawn.drafter.Drafted = false;
return;
}
}
}).FailOnDespawnedOrNull(TargetIndex.A));
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
Toil getInRangeToil = Toils_Combat.GotoCastPosition(TargetIndex.A, false);
yield return(getInRangeToil);
Verb_CastWarpPower verb = pawn.CurJob.verbToUse as Verb_CastWarpPower;
Find.Targeter.targetingVerb = verb;
yield return(Toils_Combat.CastVerb(TargetIndex.A, false).FailOn(() => !CurToil.actor.Position.InHorDistOf(TargetA.Thing.Position, verb.warpverbprops.range)));
compPsyker.IsActive = true;
this.AddFinishAction(() =>
{
Log.Message("FinishACtion");
if (compPsyker.IsActive)
{
// PsykerUtility.PsykerShockEvents(compPsyker, compPsyker.curPower.PowerLevel);
}
compPsyker.IsActive = false;
compPsyker.ShotFired = true;
});
}
// Token: 0x06000095 RID: 149 RVA: 0x000059E9 File Offset: 0x00003BE9
protected override IEnumerable <Toil> MakeNewToils()
{
var count = 0;
this.FailOn(() => job.GetTarget(TargetIndex.A).Thing.DestroyedOrNull());
this.FailOn(() => !HaywireData.IsHaywired(pawn));
var count1 = count;
this.FailOn(() => count1 > 4);
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
var gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, TargetIndex.None, false, 0.95f);
yield return(gotoCastPos);
var count2 = count;
count = count2 + 1;
if (count > 8)
{
EndJobWith(JobCondition.Incompletable);
}
var jumpIfCannotHit = Toils_Jump.JumpIfTargetNotHittable(TargetIndex.A, gotoCastPos);
yield return(jumpIfCannotHit);
yield return(Toils_Combat.CastVerb(TargetIndex.A));
yield return(Toils_Jump.Jump(jumpIfCannotHit));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.A);
yield return(Toils_Combat.GotoCastPosition(TargetIndex.A, closeIfDowned: false, 0.95f));
yield return(Toils_Combat.CastVerb(TargetIndex.A));
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
Verb_UseAbility curJob = this.pawn.CurJob.verbToUse as Verb_UseAbility;
Find.Targeter.targetingVerb = curJob;
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
Toil toil1 = new Toil()
{
initAction = () => {
if (curJob.UseAbilityProps.isViolent)
{
JobDriver_CastAbilityVerb.CheckForAutoAttack(this.pawn);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(toil1);
Toil toil = new Toil()
{
initAction = () => curJob.Ability.PostAbilityAttempt(),
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_General.DoAtomic(delegate
{
Pawn pawn = job.targetA.Thing as Pawn;
//if (pawn != null && pawn.Downed && base.pawn.mindState.duty != null && base.pawn.mindState.duty.attackDownedIfStarving && base.pawn.Starving())
//{
job.killIncappedTarget = true;
//}
}));
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
yield return(Toils_Combat.FollowAndMeleeAttack(TargetIndex.A, delegate
{
Thing thing = job.GetTarget(TargetIndex.A).Thing;
Pawn p;
//if (job.reactingToMeleeThreat && (p = (thing as Pawn)) != null && !p.Awake())
//{
// EndJobWith(JobCondition.InterruptForced);
//}
InteractionUtility.TryGetRandomVerbForSocialFight(base.pawn, out Verb verb);
if (BeatDecider.shouldStopBeating(base.pawn, base.TargetA.Thing as Pawn))
{
EndJobWith(JobCondition.Succeeded);
}
else
{
pawn.meleeVerbs.TryMeleeAttack(thing, verb);
}
}).FailOnDespawnedOrNull(TargetIndex.A));
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
Verb_UseAbility verb = this.pawn.CurJob.verbToUse as Verb_UseAbility;
if (this.TargetA.HasThing)
{
Toil getInRangeToil = Toils_Combat.GotoCastPosition(TargetIndex.A, false);
yield return(getInRangeToil);
}
Find.Targeter.targetingVerb = verb;
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
//CompAbilityUser.IsActive = true;
this.AddFinishAction(() =>
{
// //Log.Message("FinishACtion");
//if (CompAbilityUser.IsActive)
//{
//PsykerUtility.PsykerShockEvents(CompAbilityUser, CompAbilityUser.curPower.PowerLevel);
//}
if (this.CompAbilityUsers is List <CompAbilityUser> users && !users.NullOrEmpty())
{
foreach (CompAbilityUser u in users)
{
u.PostAbilityAttempt(this.pawn, verb.ability.powerdef);
}
}
//this.CompAbilityUser.ShotFired = true;
});
}
// Token: 0x0600000A RID: 10 RVA: 0x000029D9 File Offset: 0x00000BD9
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOn(delegate
{
if (job.ignoreDesignations)
{
return(false);
}
var victim = Victim;
if (victim != null && !victim.Dead &&
Map.designationManager.DesignationOn(victim, DesignationDefOf.Hunt) == null)
{
return(true);
}
return(false);
});
yield return(new Toil
{
initAction = delegate { jobStartTick = Find.TickManager.TicksGame; }
});
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
var startCollectCorpse = StartCollectCorpseToil();
var gotoCastPos = MarvsGotoCastPosition(TargetIndex.A, true)
.JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpse)
.FailOn(() => Find.TickManager.TicksGame > jobStartTick + 5000);
yield return(gotoCastPos);
var moveIfCannotHit = MarvsJumpIfTargetNotHittable(TargetIndex.A, gotoCastPos);
yield return(moveIfCannotHit);
yield return(MarvsJumpIfTargetDownedDistant(TargetIndex.A, gotoCastPos));
yield return(Toils_Combat.CastVerb(TargetIndex.A, false)
.JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpse)
.FailOn(() => Find.TickManager.TicksGame > jobStartTick + 5000));
yield return(Toils_Jump.JumpIfTargetDespawnedOrNull(TargetIndex.A, startCollectCorpse));
yield return(Toils_Jump.Jump(moveIfCannotHit));
yield return(startCollectCorpse);
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.ClosestTouch)
.FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(Toils_Haul.StartCarryThing(TargetIndex.A));
var carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B);
yield return(carryToCell);
yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true));
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
//Toil getInRangeToil = Toils_Combat.GotoCastPosition(TargetIndex.A, TargetIndex.B);
//yield return getInRangeToil;
//var verb = pawn.CurJob.verbToUse as Verb_Deflected;
//Find.Targeter.targetingVerb = verb;
yield return(Toils_Combat.CastVerb(TargetIndex.A, TargetIndex.B, canHitNonTargetPawns: false));
}
protected override IEnumerable <Toil> MakeNewToils()
{
Toil waitLabel = Toils_General.Label();
Toil endLabel = Toils_General.Label();
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
Toil approach = new Toil();
approach.initAction = delegate
{
Job curJob = pawn.jobs.curJob;
if (pawn == Victim || Victim == null)
{
pawn.pather.StopDead();
ReadyForNextToil();
}
else
{
CastPositionRequest newReq = default(CastPositionRequest);
newReq.caster = pawn;
newReq.target = Victim;
newReq.verb = curJob.verbToUse;
newReq.maxRangeFromTarget = (!Victim.Downed ? Mathf.Max(curJob.verbToUse.verbProps.range * maxRangeFactor, 1.42f) : Mathf.Min(curJob.verbToUse.verbProps.range, Victim.RaceProps.executionRange));
newReq.wantCoverFromTarget = false;
if (CastPositionFinder.TryFindCastPosition(newReq, out var dest))
{
pawn.pather.StartPath(dest, PathEndMode.OnCell);
pawn.Map.pawnDestinationReservationManager.Reserve(pawn, curJob, dest);
}
//else if (pawn.PositionHeld.DistanceTo(Victim.PositionHeld) <= waitRange)
//{
// pawn.pather.StopDead();
// pawn.jobs.curDriver.JumpToToil(waitLabel);
//}
else
{
pawn.pather.StartPath(Victim, PathEndMode.Touch);
}
}
};
approach.FailOnDespawnedOrNull(VictimIndex);
approach.defaultCompleteMode = ToilCompleteMode.Delay;
approach.defaultDuration = 60;
yield return(approach);
yield return(Toils_Jump.Jump(endLabel));
yield return(waitLabel);
yield return(Toils_General.Wait(60));
yield return(endLabel);
}
protected override IEnumerable <Toil> MakeNewToils()
{
////Log.Message("DeflecVErbcalls");
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
//Toil getInRangeToil = Toils_Combat.GotoCastPosition(TargetIndex.A, false);
//yield return getInRangeToil;
var verb = pawn.CurJob.verbToUse as Verb_Deflected;
//Find.Targeter.targetingVerb = verb;
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Reserve.Reserve(TargetIndex.A));
void onHitAction()
{
Pawn prey = Prey;
bool surpriseAttack = firstHit && !prey.IsColonist;
Job tjob = prey.CurJob;
if (pawn.needs.food.CurLevelPercentage < 1 && !prey.Dead && pawn.meleeVerbs.TryMeleeAttack(prey, this.job.verbToUse, surpriseAttack))
{
float new_food = pawn.needs.food.CurLevelPercentage + 0.5f;
if (new_food > 1)
{
new_food = 1;
}
pawn.needs.food.CurLevelPercentage = new_food;
if (prey.Dead)
{
return;
}
prey.stances.stunner.StunFor(700, pawn);
IEnumerable <Hediff> visibleDiffs = prey.health.hediffSet.hediffs;
List <Hediff> toremove = new List <Hediff>();
foreach (Hediff h in visibleDiffs)
{
if ((h.source == pawn.def || (h.def == HediffDefOf.MissingBodyPart && h.ageTicks < 100)) && h.def != HediffDefOf.BloodLoss)
{
toremove.Add(h);
}
}
foreach (Hediff h in toremove)
{
prey.health.RemoveHediff(h);
}
prey.jobs.StartJob(tjob, JobCondition.InterruptForced);
}
else
{
if (Math.Abs(pawn.needs.food.CurLevelPercentage - 1) < float.Epsilon)
{
pawn.jobs.curDriver.ReadyForNextToil();
}
}
firstHit = false;
}
yield return(Toils_Combat.FollowAndMeleeAttack(TargetIndex.A, onHitAction));
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
yield return(Toils_Combat.CastVerb(TargetIndex.A, true));
this.AddFinishAction(() =>
{
compPsyker.IsActive = false;
compPsyker.ShotFired = true;
});
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
ToilFailConditions.FailOnDespawnedOrNull(this, TargetIndex.A);
Pawn prey = this.TargetA.Thing as Pawn;
if (prey.Dead)
{
this.EndJobWith(JobCondition.Succeeded);
}
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
yield return(Toils_Combat.GotoCastPosition(TargetIndex.A, true));
yield return(Toils_Combat.CastVerb(TargetIndex.A));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
yield return(Toils_Combat.CastVerb(TargetIndex.A, true));
compPsyker.IsActive = true;
this.AddFinishAction(() =>
{
if (compPsyker.IsActive)
{
PsykerUtility.PsykerShockEvents(compPsyker, compPsyker.curPower.PowerLevel);
}
compPsyker.IsActive = false;
compPsyker.ShotFired = true;
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Combat.FollowAndMeleeAttack(TargetIndex.A, delegate
{
Thing thing = this.job.GetTarget(TargetIndex.A).Thing;
if (this.pawn.meleeVerbs.TryMeleeAttack(thing, this.job.verbToUse, false))
{
if (this.pawn.CurJob == null || this.pawn.jobs.curDriver != this)
{
return;
}
this.numMeleeAttacksMade++;
if (this.numMeleeAttacksMade >= this.job.maxNumMeleeAttacks)
{
this.EndJobWith(JobCondition.Succeeded);
return;
}
}
}).FailOnDespawnedOrNull(TargetIndex.A));
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
if (TargetA.HasThing)
{
// !GetActor().IsFighting() || - removed from below "If" by xen for melee casting fix - replaced with range check - !pawn.Position.InHorDistOf(TargetA.Cell, pawn.CurJob.verbToUse.verbProps.range)
if (!pawn.Position.InHorDistOf(TargetA.Cell, pawn.CurJob.verbToUse.verbProps.range) ||
!Verb.UseAbilityProps.canCastInMelee)
{
var getInRangeToil = Toils_Combat.GotoCastPosition(TargetIndex.A, false);
yield return(getInRangeToil);
}
}
if (Context == AbilityContext.Player)
{
Find.Targeter.targetingVerb = Verb;
}
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
yield return(new Toil
{
initAction = delegate
{
if (Verb?.UseAbilityProps?.isViolent == true)
{
CheckForAutoAttack(this.pawn);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
yield return(new Toil
{
initAction = delegate { Verb.Ability.PostAbilityAttempt(); },
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
var verb = pawn.CurJob.verbToUse as Verb_UseAbility;
if (TargetA.HasThing)
{
if (!GetActor().IsFighting() || !verb.UseAbilityProps.canCastInMelee)
{
var getInRangeToil = Toils_Combat.GotoCastPosition(TargetIndex.A, false);
yield return(getInRangeToil);
}
}
if (Context == AbilityContext.Player)
{
Find.Targeter.targetingVerb = verb;
}
yield return(new Toil
{
initAction = delegate { verb.Ability.PostAbilityAttempt(); },
defaultCompleteMode = ToilCompleteMode.Instant
});
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
yield return(new Toil
{
initAction = delegate
{
if (verb.UseAbilityProps.isViolent)
{
CheckForAutoAttack(this.pawn);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.EndOnDespawned(VictimInd, ResultOfDespawnedTarget());
yield return(Toils_Reserve.Reserve(VictimInd, ReservationType.Total));
Toil gotoCastPos = Toils_Combat.GotoCastPosition(VictimInd);
yield return(gotoCastPos);
Toil jumpIfCannotHit = Toils_Jump.JumpIfCannotHitTarget(VictimInd, gotoCastPos);
yield return(jumpIfCannotHit);
var verbtoil = Toils_Combat.CastVerb(VictimInd);
var tool = (Tool)CurJob.verbToUse.ownerEquipment;
verbtoil = verbtoil.WithEffect(tool.effecterDef, VictimInd);
yield return(verbtoil);
yield return(Toils_Jump.Jump(jumpIfCannotHit));
}
protected override IEnumerable <Toil> MakeNewToils()
{
Toil addVerb = new Toil();
addVerb.initAction = delegate()
{
pawn.verbTracker.AllVerbs.Add(pawn.CurJob.verbToUse);
};
yield return(addVerb);
yield return(Toils_Combat.CastVerb(TargetIndex.A));
Toil removeVerb = new Toil();
removeVerb.initAction = delegate()
{
pawn.verbTracker.AllVerbs.Remove(pawn.CurJob.verbToUse);
};
yield return(removeVerb);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
bool flag;
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
Verb_UseAbility curJob = this.pawn.CurJob.verbToUse as Verb_UseAbility;
if (base.TargetA.HasThing)
{
flag = (!base.GetActor().IsFighting() ? true : !curJob.UseAbilityProps.canCastInMelee);
if (flag)
{
Toil toil = Toils_Combat.GotoCastPosition(TargetIndex.A, false);
yield return(toil);
toil = null;
}
}
if (this.Context == AbilityContext.Player)
{
Find.Targeter.targetingVerb = curJob;
}
Pawn targetPawn = null;
if (this.TargetThingA != null)
{
targetPawn = TargetThingA as Pawn;
}
if (targetPawn != null)
{
//yield return Toils_Combat.CastVerb(TargetIndex.A, false);
Toil combatToil = new Toil();
combatToil.FailOnDestroyedOrNull(TargetIndex.A);
combatToil.FailOnDespawnedOrNull(TargetIndex.A);
//combatToil.FailOnDowned(TargetIndex.A);
//CompAbilityUserMagic comp = this.pawn.GetComp<CompAbilityUserMagic>();
this.duration = (int)((curJob.verbProps.warmupTime * 60) * this.pawn.GetStatValue(StatDefOf.AimingDelayFactor, false));
//JobDriver curDriver = this.pawn.jobs.curDriver;
combatToil.initAction = delegate
{
Verb arg_45_0 = combatToil.actor.jobs.curJob.verbToUse;
LocalTargetInfo target = combatToil.actor.jobs.curJob.GetTarget(TargetIndex.A);
// bool canFreeIntercept2 = false;
arg_45_0.TryStartCastOn(target, false, false);
};
combatToil.tickAction = delegate
{
this.duration--;
};
combatToil.AddFinishAction(delegate
{
if (this.duration <= 5)
{
curJob.Ability.PostAbilityAttempt();
}
});
//if (combatToil.actor.CurJob != this.job)
//{
// curDriver.ReadyForNextToil();
//}
combatToil.defaultCompleteMode = ToilCompleteMode.FinishedBusy;
yield return(combatToil);
//Toil toil2 = new Toil()
//{
// initAction = () =>
// {
// if (curJob.UseAbilityProps.isViolent)
// {
// JobDriver_CastAbilityVerb.CheckForAutoAttack(this.pawn);
// }
// },
// defaultCompleteMode = ToilCompleteMode.Instant
//};
//yield return toil2;
//Toil toil1 = new Toil()
//{
// initAction = () => curJob.Ability.PostAbilityAttempt(),
// defaultCompleteMode = ToilCompleteMode.Instant
//};
//yield return toil1;
}
else
{
if ((pawn.Position - TargetLocA).LengthHorizontal < curJob.verbProps.range)
{
if (TargetLocA.IsValid && TargetLocA.InBounds(pawn.Map) && !TargetLocA.Fogged(pawn.Map) && TargetLocA.Walkable(pawn.Map))
{
ShootLine shootLine;
bool validTarg = curJob.TryFindShootLineFromTo(pawn.Position, TargetLocA, out shootLine);
if (validTarg)
{
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
//Toil toil2 = new Toil()
//{
// initAction = () =>
// {
// if (curJob.UseAbilityProps.isViolent)
// {
// JobDriver_CastAbilityVerb.CheckForAutoAttack(this.pawn);
// }
// },
// defaultCompleteMode = ToilCompleteMode.Instant
//};
//yield return toil2;
Toil toil1 = new Toil()
{
initAction = () => curJob.Ability.PostAbilityAttempt(),
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(toil1);
}
else
{
//No LoS
if (pawn.IsColonist)
{
Messages.Message("TM_OutOfLOS".Translate(new object[]
{
pawn.LabelShort
}), MessageTypeDefOf.RejectInput);
}
}
}
}
else
{
if (pawn.IsColonist)
{
//out of range
Messages.Message("TM_OutOfRange".Translate(), MessageTypeDefOf.RejectInput);
}
}
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOn(delegate
{
if (!job.ignoreDesignations)
{
Pawn victim = Victim;
if (victim != null && !victim.Dead && Map.designationManager.DesignationOn(victim, DesignationDefOf.Hunt) == null)
{
return(true);
}
}
return(false);
});
yield return(Toils_Reserve.Reserve(VictimInd, 1));
var init = new Toil();
init.initAction = delegate
{
jobStartTick = Find.TickManager.TicksGame;
};
yield return(init);
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
var comp = (pawn.equipment != null && pawn.equipment.Primary != null) ? pawn.equipment.Primary.TryGetComp <CompAmmoUser>() : null;
var startCollectCorpse = StartCollectCorpseToil();
var gotoCastPos = GotoCastPosition(VictimInd, true).JumpIfDespawnedOrNull(VictimInd, startCollectCorpse).FailOn(() => Find.TickManager.TicksGame > jobStartTick + MaxHuntTicks);
yield return(gotoCastPos);
//var moveIfCannotHit = Toils_Jump.JumpIfTargetNotHittable(VictimInd, gotoCastPos);
var moveIfCannotHit = Toils_Jump.JumpIf(gotoCastPos, delegate
{
var verb = pawn.CurJob.verbToUse;
var optimalRange = HuntRangePerBodysize(Victim.RaceProps.baseBodySize, Victim.RaceProps.executionRange, verb.verbProps.range);
if (pawn.Position.DistanceTo(Victim.Position) > optimalRange)
{
return(true);
}
return(!verb.CanHitTarget(Victim));
});
yield return(moveIfCannotHit);
yield return(Toils_Jump.JumpIfTargetDespawnedOrNull(VictimInd, startCollectCorpse));
var startExecuteDowned = Toils_Goto.GotoThing(VictimInd, PathEndMode.Touch).JumpIfDespawnedOrNull(VictimInd, startCollectCorpse);
yield return(Toils_Jump.JumpIf(startExecuteDowned, () => Victim.Downed && Victim.RaceProps.executionRange <= 2));
yield return(Toils_Jump.JumpIfTargetDowned(VictimInd, gotoCastPos));
yield return(Toils_Combat.CastVerb(VictimInd, false).JumpIfDespawnedOrNull(VictimInd, startCollectCorpse)
.FailOn(() =>
{
if (Find.TickManager.TicksGame <= jobStartTick + MaxHuntTicks)
{
if (comp == null || comp.HasAndUsesAmmoOrMagazine)
{
return false;
}
}
return true;
}));
yield return(Toils_Jump.Jump(moveIfCannotHit));
// Execute downed animal - adapted from JobDriver_Slaughter
yield return(startExecuteDowned);
yield return(Toils_General.WaitWith(VictimInd, 180, true).JumpIfDespawnedOrNull(VictimInd, startCollectCorpse));
yield return(new Toil
{
initAction = delegate
{
ExecutionUtility.DoExecutionByCut(pawn, Victim);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
// Haul corpse to stockpile
yield return(startCollectCorpse);
yield return(Toils_Goto.GotoCell(VictimInd, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(VictimInd).FailOnSomeonePhysicallyInteracting(VictimInd));
yield return(Toils_Haul.StartCarryThing(VictimInd));
var carryToCell = Toils_Haul.CarryHauledThingToCell(StoreCellInd);
yield return(carryToCell);
yield return(Toils_Haul.PlaceHauledThingInCell(StoreCellInd, carryToCell, true));
}
//public override bool TryMakePreToilReservations(bool errorOnFailed)
//{
// if(TargetA.Thing != null)
// {
// return true;
// }
// if (pawn.Reserve(TargetA, this.job, 1, 1, null, errorOnFailed))
// {
// return true;
// }
// return false;
//}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
this.verb = this.pawn.CurJob.verbToUse as Verb_UseAbility;
if (base.TargetA.HasThing && base.TargetA.Thing is Pawn && (!pawn.Position.InHorDistOf(base.TargetA.Cell, pawn.CurJob.verbToUse.verbProps.range) || !Verb.UseAbilityProps.canCastInMelee))
{
//if (!base.GetActor().IsFighting() ? true : !verb.UseAbilityProps.canCastInMelee && !this.job.endIfCantShootTargetFromCurPos)
//{
Toil toil = Toils_Combat.GotoCastPosition(TargetIndex.A, false);
yield return(toil);
//toil = null;
//}
}
if (this.Context == AbilityContext.Player)
{
Find.Targeter.targetingSource = this.verb;
}
Pawn targetPawn = null;
if (this.TargetThingA != null)
{
targetPawn = TargetThingA as Pawn;
}
if (targetPawn != null)
{
//yield return Toils_Combat.CastVerb(TargetIndex.A, false);
Toil combatToil = new Toil();
//combatToil.FailOnDestroyedOrNull(TargetIndex.A);
//combatToil.FailOnDespawnedOrNull(TargetIndex.A);
//combatToil.FailOnDowned(TargetIndex.A);
//CompAbilityUserMagic comp = this.pawn.GetComp<CompAbilityUserMagic>();
//JobDriver curDriver = this.pawn.jobs.curDriver;
combatToil.initAction = delegate
{
this.verb = combatToil.actor.jobs.curJob.verbToUse as Verb_UseAbility;
this.duration = (int)((this.verb.verbProps.warmupTime * 60) * this.pawn.GetStatValue(StatDefOf.AimingDelayFactor, false));
if (this.pawn.RaceProps.Humanlike)
{
//if (this.pawn.story.traits.HasTrait(TorannMagicDefOf.Faceless))
//{
// RemoveMimicAbility(verb);
//}
if (this.pawn.story.traits.HasTrait(TorannMagicDefOf.TM_Psionic))
{
PsionicEnergyCost(verb);
}
if (this.pawn.story.traits.HasTrait(TorannMagicDefOf.DeathKnight))
{
HateCost(verb);
}
if (verb.Ability.CooldownTicksLeft != -1)
{
this.EndJobWith(JobCondition.Incompletable);
}
}
LocalTargetInfo target = combatToil.actor.jobs.curJob.GetTarget(TargetIndex.A);
verb.TryStartCastOn(target, false, true);
using (IEnumerator <Hediff> enumerator = this.pawn.health.hediffSet.GetHediffs <Hediff>().GetEnumerator())
{
while (enumerator.MoveNext())
{
Hediff rec = enumerator.Current;
if (rec.def == TorannMagicDefOf.TM_PossessionHD || rec.def == TorannMagicDefOf.TM_DisguiseHD || rec.def == TorannMagicDefOf.TM_DisguiseHD_I || rec.def == TorannMagicDefOf.TM_DisguiseHD_II || rec.def == TorannMagicDefOf.TM_DisguiseHD_III)
{
this.pawn.health.RemoveHediff(rec);
}
}
}
};
combatToil.tickAction = delegate
{
if (this.pawn.Downed)
{
EndJobWith(JobCondition.InterruptForced);
}
if (Find.TickManager.TicksGame % 12 == 0)
{
if (verb.Ability.Def == TorannMagicDefOf.TM_Artifact_TraitThief || verb.Ability.Def == TorannMagicDefOf.TM_Artifact_TraitInfuse)
{
float direction = Rand.Range(0, 360);
TM_MoteMaker.ThrowGenericMote(ThingDef.Named("Mote_Psi_Arcane"), pawn.DrawPos, pawn.Map, Rand.Range(.1f, .4f), 0.2f, .02f, .1f, 0, Rand.Range(8, 10), direction, direction);
}
else
{
TM_MoteMaker.ThrowCastingMote(pawn.DrawPos, pawn.Map, Rand.Range(1.2f, 2f));
}
}
this.duration--;
if (!wildCheck && this.duration <= 6)
{
wildCheck = true;
if (this.pawn.story != null && this.pawn.story.traits != null && this.pawn.story.traits.HasTrait(TorannMagicDefOf.ChaosMage) && Rand.Chance(.1f))
{
verb.Ability.PostAbilityAttempt();
TM_Action.DoWildSurge(this.pawn, this.pawn.GetComp <CompAbilityUserMagic>(), (MagicAbility)verb.Ability, (TMAbilityDef)verb.Ability.Def, TargetA);
EndJobWith(JobCondition.InterruptForced);
}
}
};
combatToil.AddFinishAction(delegate
{
if (this.duration <= 5 && !this.pawn.DestroyedOrNull() && !this.pawn.Dead && !this.pawn.Downed)
{
//ShootLine shootLine;
//bool validTarg = verb.TryFindShootLineFromTo(pawn.Position, TargetLocA, out shootLine);
//bool inRange = (pawn.Position - TargetLocA).LengthHorizontal < verb.verbProps.range;
//if (inRange && validTarg)
//{
verb.Ability.PostAbilityAttempt();
this.pawn.ClearReservationsForJob(this.job);
//}
}
});
//if (combatToil.actor.CurJob != this.job)
//{
// curDriver.ReadyForNextToil();
//}
combatToil.defaultCompleteMode = ToilCompleteMode.FinishedBusy;
this.pawn.ClearReservationsForJob(this.job);
yield return(combatToil);
//Toil toil2 = new Toil()
//{
// initAction = () =>
// {
// if (curJob.UseAbilityProps.isViolent)
// {
// JobDriver_CastAbilityVerb.CheckForAutoAttack(this.pawn);
// }
// },
// defaultCompleteMode = ToilCompleteMode.Instant
//};
//yield return toil2;
//Toil toil1 = new Toil()
//{
// initAction = () => curJob.Ability.PostAbilityAttempt(),
// defaultCompleteMode = ToilCompleteMode.Instant
//};
//yield return toil1;
}
else
{
if ((pawn.Position - TargetLocA).LengthHorizontal < verb.verbProps.range)
{
if (TargetLocA.IsValid && TargetLocA.InBounds(pawn.Map) && !TargetLocA.Fogged(pawn.Map)) //&& TargetLocA.Walkable(pawn.Map)
{
ShootLine shootLine;
bool validTarg = verb.TryFindShootLineFromTo(pawn.Position, TargetLocA, out shootLine);
if (validTarg)
{
//yield return Toils_Combat.CastVerb(TargetIndex.A, false);
//Toil toil2 = new Toil()
//{
// initAction = () =>
// {
// if (curJob.UseAbilityProps.isViolent)
// {
// JobDriver_CastAbilityVerb.CheckForAutoAttack(this.pawn);
// }
// },
// defaultCompleteMode = ToilCompleteMode.Instant
//};
//yield return toil2;
this.duration = (int)((verb.verbProps.warmupTime * 60) * this.pawn.GetStatValue(StatDefOf.AimingDelayFactor, false));
Toil toil = new Toil();
toil.initAction = delegate
{
this.verb = toil.actor.jobs.curJob.verbToUse as Verb_UseAbility;
if (this.pawn.RaceProps.Humanlike)
{
//if (this.pawn.story.traits.HasTrait(TorannMagicDefOf.Faceless))
//{
// RemoveMimicAbility(verb);
//}
if (this.pawn.story.traits.HasTrait(TorannMagicDefOf.TM_Psionic))
{
PsionicEnergyCost(verb);
}
if (verb.Ability.CooldownTicksLeft != -1)
{
this.EndJobWith(JobCondition.Incompletable);
}
}
LocalTargetInfo target = toil.actor.jobs.curJob.GetTarget(TargetIndex.A); //TargetLocA; //
bool canFreeIntercept2 = false;
verb.TryStartCastOn(target, false, canFreeIntercept2);
using (IEnumerator <Hediff> enumerator = this.pawn.health.hediffSet.GetHediffs <Hediff>().GetEnumerator())
{
while (enumerator.MoveNext())
{
Hediff rec = enumerator.Current;
if (rec.def == TorannMagicDefOf.TM_PossessionHD || rec.def == TorannMagicDefOf.TM_DisguiseHD || rec.def == TorannMagicDefOf.TM_DisguiseHD_I || rec.def == TorannMagicDefOf.TM_DisguiseHD_II || rec.def == TorannMagicDefOf.TM_DisguiseHD_III)
{
this.pawn.health.RemoveHediff(rec);
}
}
}
};
toil.tickAction = delegate
{
if (Find.TickManager.TicksGame % 12 == 0)
{
TM_MoteMaker.ThrowCastingMote(pawn.DrawPos, pawn.Map, Rand.Range(1.2f, 2f));
}
this.duration--;
if (!wildCheck && this.duration <= 6)
{
wildCheck = true;
if (this.pawn.story != null && this.pawn.story.traits != null && this.pawn.story.traits.HasTrait(TorannMagicDefOf.ChaosMage) && Rand.Chance(.1f))
{
bool completeJob = TM_Action.DoWildSurge(this.pawn, this.pawn.GetComp <CompAbilityUserMagic>(), (MagicAbility)verb.Ability, (TMAbilityDef)verb.Ability.Def, TargetA);
if (!completeJob)
{
verb.Ability.PostAbilityAttempt();
EndJobWith(JobCondition.InterruptForced);
}
}
}
};
toil.AddFinishAction(delegate
{
if (this.duration <= 5 && !this.pawn.DestroyedOrNull() && !this.pawn.Dead && !this.pawn.Downed)
{
verb.Ability.PostAbilityAttempt();
}
this.pawn.ClearReservationsForJob(this.job);
});
toil.defaultCompleteMode = ToilCompleteMode.FinishedBusy;
yield return(toil);
//Toil toil1 = new Toil()
//{
// initAction = () => curJob.Ability.PostAbilityAttempt(),
// defaultCompleteMode = ToilCompleteMode.Instant
//};
//yield return toil1;
}
else
{
//No LoS
if (pawn.IsColonist)
{
Messages.Message("TM_OutOfLOS".Translate(
pawn.LabelShort
), MessageTypeDefOf.RejectInput);
}
pawn.ClearAllReservations(false);
}
}
else
{
pawn.ClearAllReservations(false);
}
}
else
{
if (pawn.IsColonist)
{
//out of range
Messages.Message("TM_OutOfRange".Translate(), MessageTypeDefOf.RejectInput);
}
}
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
base.AddFinishAction(delegate
{
this.$this.Map.attackTargetsCache.UpdateTarget(this.$this.pawn);
});
Toil prepareToEatCorpse = new Toil();
prepareToEatCorpse.initAction = delegate
{
Pawn actor = prepareToEatCorpse.actor;
Corpse corpse = this.$this.Corpse;
if (corpse == null)
{
Pawn prey = this.$this.Prey;
if (prey == null)
{
actor.jobs.EndCurrentJob(JobCondition.Incompletable, true);
return;
}
corpse = prey.Corpse;
if (corpse == null || !corpse.Spawned)
{
actor.jobs.EndCurrentJob(JobCondition.Incompletable, true);
return;
}
}
if (actor.Faction == Faction.OfPlayer)
{
corpse.SetForbidden(false, false);
}
else
{
corpse.SetForbidden(true, false);
}
actor.CurJob.SetTarget(TargetIndex.A, corpse);
};
yield return(Toils_General.DoAtomic(delegate
{
this.$this.Map.attackTargetsCache.UpdateTarget(this.$this.pawn);
}));
Action onHitAction = delegate
{
Pawn prey = this.$this.Prey;
bool surpriseAttack = this.$this.firstHit && !prey.IsColonist;
if (this.$this.pawn.meleeVerbs.TryMeleeAttack(prey, this.$this.job.verbToUse, surpriseAttack))
{
if (!this.$this.notifiedPlayerAttacked && PawnUtility.ShouldSendNotificationAbout(prey))
{
this.$this.notifiedPlayerAttacked = true;
Messages.Message("MessageAttackedByPredator".Translate(prey.LabelShort, this.$this.pawn.LabelIndefinite(), prey.Named("PREY"), this.$this.pawn.Named("PREDATOR")).CapitalizeFirst(), prey, MessageTypeDefOf.ThreatSmall, true);
}
this.$this.Map.attackTargetsCache.UpdateTarget(this.$this.pawn);
this.$this.firstHit = false;
}
};
Toil followAndAttack = Toils_Combat.FollowAndMeleeAttack(TargetIndex.A, onHitAction).JumpIfDespawnedOrNull(TargetIndex.A, prepareToEatCorpse).JumpIf(() => this.$this.Corpse != null, prepareToEatCorpse).FailOn(() => Find.TickManager.TicksGame > this.$this.startTick + 5000 && (float)(this.$this.job.GetTarget(TargetIndex.A).Cell - this.$this.pawn.Position).LengthHorizontalSquared > 4f);
followAndAttack.AddPreTickAction(new Action(this.CheckWarnPlayer));
yield return(followAndAttack);
yield return(prepareToEatCorpse);
Toil gotoCorpse = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch);
yield return(gotoCorpse);
float durationMultiplier = 1f / this.pawn.GetStatValue(StatDefOf.EatingSpeed, true);
yield return(Toils_Ingest.ChewIngestible(this.pawn, durationMultiplier, TargetIndex.A, TargetIndex.None).FailOnDespawnedOrNull(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch));
yield return(Toils_Ingest.FinalizeIngest(this.pawn, TargetIndex.A));
yield return(Toils_Jump.JumpIf(gotoCorpse, () => this.$this.pawn.needs.food.CurLevelPercentage < 0.9f));
}
protected override IEnumerable <Toil> MakeNewToils()
{
Toil startCollectCorpse = Toils_General.Wait(10);
yield return(Toils_Reserve.ReserveTarget(VictimInd, ReservationType.Total));
yield return(Toils_Combat.SetJobToUseToBestAttackVerb());
Toil gotoCastPos = Toils_Combat.GotoCastPosition(VictimInd)
.JumpIfDespawned(VictimInd, startCollectCorpse);
yield return(gotoCastPos);
Toil jumpIfCannotHit = Toils_Jump.JumpIfCannotHitTarget(VictimInd, gotoCastPos);
yield return(jumpIfCannotHit);
yield return(Toils_General.Wait(2)
.JumpIfDespawned(VictimInd, startCollectCorpse));
yield return(Toils_Combat.CastVerb(VictimInd)
.JumpIfDespawned(VictimInd, startCollectCorpse));
yield return(Toils_Jump.Jump(jumpIfCannotHit));
//================================================
//============= Collect corpse ===================
//================================================
yield return(startCollectCorpse);
//----------------------------------------------------
//Rearrange the job so the bill doer goes and stores the product
//----------------------------------------------------
Toil transformJobForCorpseStore = new Toil();
transformJobForCorpseStore.initAction = () =>
{
Pawn actor = transformJobForCorpseStore.actor;
//Hack way of finding a ref to the corpse
Corpse corpse = null;
Thing targPawn = actor.CurJob.GetTarget(VictimInd).Thing;
foreach (Thing t in targPawn.Position)
{
corpse = t as Corpse;
if (corpse != null && corpse.sourcePawn == targPawn)
{
break;
}
}
corpse.SetForbidden(false);
//Try find a store square
IntVec3 storeSquare;
if (corpse != null &&
StoreUtility.TryFindBestStoreSquareFor(corpse, StoragePriority.Unstored, out storeSquare))
{
actor.CurJob.targetB = storeSquare;
actor.CurJob.SetTarget(CorpseInd, corpse);
actor.CurJob.maxNumToCarry = 1;
actor.CurJob.haulMode = HaulMode.ToSquareStorage;
}
else
{
//No store square? We're done.
actor.jobs.EndCurrentJob(JobCondition.Succeeded);
return;
}
};
yield return(transformJobForCorpseStore);
yield return(Toils_Goto.GotoLoc(CorpseInd, PathMode.ClosestTouch)
.FailOnDespawnedOrForbidden(CorpseInd));
yield return(Toils_Haul.StartCarryThing(CorpseInd));
Toil carryToSquare = Toils_Haul.CarryHauledThingToSquare(TargetIndex.B);
yield return(carryToSquare);
yield return(Toils_Haul.PlaceHauledThingInSquare(TargetIndex.B, carryToSquare));
}
protected override IEnumerable <Toil> MakeNewToils()
{
AddFailCondition(() => pawn.WorkTagIsDisabled(WorkTags.Violent));
this.FailOnSomeonePhysicallyInteracting(TargetIndex.A);
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
jobStartTick = Find.TickManager.TicksGame;
startingEquippedWeapon = pawn.equipment.Primary;
trainingWeapon = null;
if (startingEquippedWeapon == null || !startingEquippedWeapon.def.IsWithinCategory(CombatTrainingDefOf.TrainingWeapons))
{
trainingWeapon = GetNearestTrainingWeapon(startingEquippedWeapon);
if (trainingWeapon != null && !trainingWeapon.IsForbidden(pawn))
{
if (Map.reservationManager.CanReserve(pawn, trainingWeapon))
{
pawn.Reserve(trainingWeapon, job);
job.SetTarget(TargetIndex.B, trainingWeapon);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.B));
yield return(CreateEquipToil(TargetIndex.B));
}
if (Map.reservationManager.CanReserve(pawn, startingEquippedWeapon))
{
pawn.Reserve(startingEquippedWeapon, job);
job.SetTarget(TargetIndex.C, startingEquippedWeapon);
}
}
}
Toil endOfTraining = Toils_General.Label();
Toil gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, closeIfDowned: true, 0.95f).EndOnDespawnedOrNull(TargetIndex.A);
Toil ifTrainingDoneJumpToReequip = Toils_Jump.JumpIf(endOfTraining, HasTrainingEnded);
Toil castVerb = Toils_Combat.CastVerb(TargetIndex.A, canHitNonTargetPawns: false);
castVerb.AddFinishAction(delegate
{
LearnAttackSkill();
});
Toil trainingRoomImpressivenessMoodBoost = Toils_General.Do(delegate
{
TryGainCombatTrainingRoomThought();
});
Toil dropTrainingWeapon = Toils_General.Do(delegate
{
pawn.equipment.TryDropEquipment(pawn.equipment.Primary, out _, pawn.Position, forbid: false);
});
Toil reequipSwappedStartingWeapon = Toils_General.Do(delegate
{
pawn.inventory.innerContainer.Remove(startingEquippedWeapon);
pawn.equipment.AddEquipment(startingEquippedWeapon);
});
Toil jobEndedLabel = Toils_General.Label();
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
yield return(gotoCastPos);
yield return(Toils_Jump.JumpIfTargetNotHittable(TargetIndex.A, gotoCastPos));
yield return(trainingRoomImpressivenessMoodBoost);
yield return(ifTrainingDoneJumpToReequip);
yield return(castVerb);
yield return(Toils_Jump.Jump(ifTrainingDoneJumpToReequip));
yield return(endOfTraining);
if (trainingWeapon != null)
{
yield return(dropTrainingWeapon);
}
yield return(Toils_Jump.JumpIf(reequipSwappedStartingWeapon, () => pawn.inventory.Contains(startingEquippedWeapon)));
yield return(Toils_Goto.GotoThing(TargetIndex.C, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.C));
yield return(CreateEquipToil(TargetIndex.C));
yield return(Toils_Jump.Jump(jobEndedLabel));
yield return(reequipSwappedStartingWeapon);
yield return(jobEndedLabel);
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Misc.ThrowColonistAttackingMote(TargetIndex.A));
yield return(Toils_Combat.CastVerb(TargetIndex.A, false));
}
