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: 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()
{
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_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;
});
}
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 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()
{
////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_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_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));
}
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));
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOn(delegate()
{
if (!this.job.ignoreDesignations)
{
Pawn victim = this.Victim;
if (victim != null && !victim.Dead && base.Map.designationManager.DesignationOn(victim, DesignationDefOf.Hunt) == null)
{
return(true);
}
}
return(false);
});
yield return(new Toil
{
initAction = delegate()
{
this.jobStartTick = Find.TickManager.TicksGame;
}
});
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
Toil startCollectCorpseLabel = Toils_General.Label();
Toil slaughterLabel = Toils_General.Label();
Toil gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, true, 0.95f).JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel).FailOn(() => Find.TickManager.TicksGame > this.jobStartTick + 5000);
yield return(gotoCastPos);
Toil slaughterIfPossible = Toils_Jump.JumpIf(slaughterLabel, delegate
{
Pawn victim = this.Victim;
return((victim.RaceProps.DeathActionWorker == null || !victim.RaceProps.DeathActionWorker.DangerousInMelee) && victim.Downed);
});
yield return(slaughterIfPossible);
yield return(Toils_Jump.JumpIfTargetNotHittable(TargetIndex.A, gotoCastPos));
yield return(Toils_Combat.CastVerb(TargetIndex.A, false).JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel).FailOn(() => Find.TickManager.TicksGame > this.jobStartTick + 5000));
yield return(Toils_Jump.JumpIfTargetDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel));
yield return(Toils_Jump.Jump(slaughterIfPossible));
yield return(slaughterLabel);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnMobile(TargetIndex.A));
yield return(Toils_General.WaitWith(TargetIndex.A, 180, true, false).FailOnMobile(TargetIndex.A));
yield return(Toils_General.Do(delegate
{
if (this.Victim.Dead)
{
return;
}
ExecutionUtility.DoExecutionByCut(this.pawn, this.Victim);
this.pawn.records.Increment(RecordDefOf.AnimalsSlaughtered);
if (this.pawn.InMentalState)
{
this.pawn.MentalState.Notify_SlaughteredAnimal();
}
}));
yield return(Toils_Jump.Jump(startCollectCorpseLabel));
yield return(startCollectCorpseLabel);
yield return(this.StartCollectCorpseToil());
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false));
Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B);
yield return(carryToCell);
yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true));
yield break;
}
public bool MoveNext()
{
uint num = (uint)this.$PC;
this.$PC = -1;
switch (num)
{
case 0u:
{
this.FailOn(delegate()
{
if (!this.job.ignoreDesignations)
{
Pawn victim = base.Victim;
if (victim != null && !victim.Dead && base.Map.designationManager.DesignationOn(victim, DesignationDefOf.Hunt) == null)
{
return(true);
}
}
return(false);
});
Toil init = new Toil();
init.initAction = delegate()
{
this.jobStartTick = Find.TickManager.TicksGame;
};
this.$current = init;
if (!this.$disposing)
{
this.$PC = 1;
}
return(true);
}
case 1u:
this.$current = Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 2;
}
return(true);
case 2u:
startCollectCorpseLabel = Toils_General.Label();
slaughterLabel = Toils_General.Label();
gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, true, 0.95f).JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel).FailOn(() => Find.TickManager.TicksGame > this.jobStartTick + 5000);
this.$current = gotoCastPos;
if (!this.$disposing)
{
this.$PC = 3;
}
return(true);
case 3u:
slaughterIfPossible = Toils_Jump.JumpIf(slaughterLabel, delegate
{
Pawn victim = base.Victim;
return((victim.RaceProps.DeathActionWorker == null || !victim.RaceProps.DeathActionWorker.DangerousInMelee) && victim.Downed);
});
this.$current = slaughterIfPossible;
if (!this.$disposing)
{
this.$PC = 4;
}
return(true);
case 4u:
this.$current = Toils_Jump.JumpIfTargetNotHittable(TargetIndex.A, gotoCastPos);
if (!this.$disposing)
{
this.$PC = 5;
}
return(true);
case 5u:
this.$current = Toils_Combat.CastVerb(TargetIndex.A, false).JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel).FailOn(() => Find.TickManager.TicksGame > this.jobStartTick + 5000);
if (!this.$disposing)
{
this.$PC = 6;
}
return(true);
case 6u:
this.$current = Toils_Jump.JumpIfTargetDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel);
if (!this.$disposing)
{
this.$PC = 7;
}
return(true);
case 7u:
this.$current = Toils_Jump.Jump(slaughterIfPossible);
if (!this.$disposing)
{
this.$PC = 8;
}
return(true);
case 8u:
this.$current = slaughterLabel;
if (!this.$disposing)
{
this.$PC = 9;
}
return(true);
case 9u:
this.$current = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnMobile(TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 10;
}
return(true);
case 10u:
this.$current = Toils_General.WaitWith(TargetIndex.A, 180, true, false).FailOnMobile(TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 11;
}
return(true);
case 11u:
this.$current = Toils_General.Do(delegate
{
if (base.Victim.Dead)
{
return;
}
ExecutionUtility.DoExecutionByCut(this.pawn, base.Victim);
this.pawn.records.Increment(RecordDefOf.AnimalsSlaughtered);
if (this.pawn.InMentalState)
{
this.pawn.MentalState.Notify_SlaughteredAnimal();
}
});
if (!this.$disposing)
{
this.$PC = 12;
}
return(true);
case 12u:
this.$current = Toils_Jump.Jump(startCollectCorpseLabel);
if (!this.$disposing)
{
this.$PC = 13;
}
return(true);
case 13u:
this.$current = startCollectCorpseLabel;
if (!this.$disposing)
{
this.$PC = 14;
}
return(true);
case 14u:
this.$current = base.StartCollectCorpseToil();
if (!this.$disposing)
{
this.$PC = 15;
}
return(true);
case 15u:
this.$current = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
if (!this.$disposing)
{
this.$PC = 16;
}
return(true);
case 16u:
this.$current = Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false);
if (!this.$disposing)
{
this.$PC = 17;
}
return(true);
case 17u:
carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B);
this.$current = carryToCell;
if (!this.$disposing)
{
this.$PC = 18;
}
return(true);
case 18u:
this.$current = Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true);
if (!this.$disposing)
{
this.$PC = 19;
}
return(true);
case 19u:
this.$PC = -1;
break;
}
return(false);
}
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()
{
Toil startJobToil = new Toil();
startJobToil.initAction = delegate
{
jobStartTick = Find.TickManager.TicksGame;
};
yield return(startJobToil);
yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A));
Toil startCollectCorpseLabel = Toils_General.Label();
Toil slaughterLabel = Toils_General.Label();
Toil meleeLabel = Toils_General.Label();
Toil checkTargetToil = new Toil();
checkTargetToil.initAction = delegate
{
targetCheckTick = Find.TickManager.TicksGame;
//if (pawn.equipment.Primary == null || pawn.equipment.Primary.def.IsMeleeWeapon)
// pawn.jobs.curDriver.JumpToToil(meleeLabel);
};
yield return(checkTargetToil);
//Toil gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, true, 0.95f).JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel).FailOn(() => Find.TickManager.TicksGame > jobStartTick + 5000);
Toil gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, true, 4.0f)
.JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel)
.JumpIf(() => Find.TickManager.TicksGame > targetCheckTick + targetCheckInterval, checkTargetToil);
yield return(gotoCastPos);
Toil selectAttack = new Toil();
selectAttack.initAction = delegate
{
if (pawn.CanReachImmediate(TargetA, PathEndMode.Touch))
{
pawn.jobs.curDriver.JumpToToil(meleeLabel);
}
else if (Victim.Downed)
{
if (Victim.AnimalOrWildMan())
{
pawn.jobs.curDriver.JumpToToil(slaughterLabel);
}
else
{
pawn.jobs.curDriver.JumpToToil(meleeLabel);
}
}
};
yield return(selectAttack);
// Ranged attack
yield return(Toils_Jump.JumpIfTargetNotHittable(TargetIndex.A, checkTargetToil));
yield return(Toils_Combat.CastVerb(TargetIndex.A, canHitNonTargetPawns: false).JumpIfDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel).FailOn(() => Find.TickManager.TicksGame > jobStartTick + 5000));
yield return(Toils_Jump.JumpIfTargetDespawnedOrNull(TargetIndex.A, startCollectCorpseLabel));
yield return(Toils_Jump.Jump(selectAttack));
// Melee
yield return(meleeLabel);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).JumpIf(() => Find.TickManager.TicksGame > targetCheckTick + targetCheckInterval, checkTargetToil));
//yield return Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell).JumpIf(() => Find.TickManager.TicksGame > targetCheckTick + targetCheckInterval, checkTargetToil);
Toil meleeAttack = new Toil();
meleeAttack.tickAction = delegate
{
if (Victim == null || !Victim.Spawned || Victim.IsForbidden(pawn) || !pawn.CanReachImmediate(TargetA, PathEndMode.Touch))
{
pawn.jobs.curDriver.JumpToToil(checkTargetToil);
}
else if (Victim.Downed && Victim.AnimalOrWildMan())
{
pawn.jobs.curDriver.JumpToToil(slaughterLabel);
}
pawn.pather.StopDead();
pawn.meleeVerbs.TryMeleeAttack(Victim);
};
meleeAttack.activeSkill = () => SkillDefOf.Melee;
meleeAttack.defaultCompleteMode = ToilCompleteMode.Never;
yield return(meleeAttack);
yield return(Toils_Jump.JumpIfCannotTouch(TargetIndex.A, PathEndMode.Touch, checkTargetToil));
// Slaughter target
yield return(slaughterLabel);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnMobile(TargetIndex.A));
yield return(Toils_General.WaitWith(TargetIndex.A, 180, useProgressBar: true).FailOnMobile(TargetIndex.A));
yield return(Toils_General.Do(delegate
{
if (!Victim.Dead)
{
ExecutionUtility.DoExecutionByCut(pawn, Victim);
pawn.records.Increment(RecordDefOf.AnimalsSlaughtered);
if (pawn.InMentalState)
{
pawn.MentalState.Notify_SlaughteredAnimal();
}
}
}));
yield return(Toils_Jump.Jump(startCollectCorpseLabel));
yield return(startCollectCorpseLabel);
//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);
// }
// else if (pawn.meleeVerbs.TryMeleeAttack(thing, job.verbToUse) && pawn.CurJob != null && pawn.jobs.curDriver == this)
// {
// numMeleeAttacksMade++;
// if (numMeleeAttacksMade >= job.maxNumMeleeAttacks)
// {
// EndJobWith(JobCondition.Succeeded);
// }
// }
//}).FailOnDespawnedOrNull(TargetIndex.A);
}
