public Toil BashIt()
{
Toil bashIt = new Toil();
bashIt.tickAction = delegate()
{
Pawn actor = bashIt.actor;
Job curJob = actor.jobs.curJob;
Thing thing = curJob.GetTarget(TargetIndex.B).Thing;
bool flag = actor.meleeVerbs.TryMeleeAttack(thing, null, false);
bool flag2 = flag;
if (flag2)
{
this.numMeleeAttacksMade++;
bool flag3 = this.numMeleeAttacksMade >= curJob.maxNumMeleeAttacks;
bool flag4 = flag3;
if (flag4)
{
this.EndJobWith(JobCondition.Succeeded);
}
}
};
bashIt.defaultCompleteMode = ToilCompleteMode.Never;
ToilFailConditions.EndOnDespawnedOrNull <Toil>(bashIt, TargetIndex.B, JobCondition.Succeeded);
ToilFailConditions.FailOn <Toil>(bashIt, new Func <bool>(this.hunterIsKilled));
return(bashIt);
}
// Token: 0x06000002 RID: 2 RVA: 0x00002072 File Offset: 0x00000272
protected override IEnumerable <Toil> MakeNewToils()
{
ToilFailConditions.FailOnDespawnedOrNull <JobDriver_RearmTrap>(this, TargetIndex.A);
ToilFailConditions.FailOnThingMissingDesignation <JobDriver_RearmTrap>(this, TargetIndex.A, YautjaDefOf.RRY_RearmTrap);
Toil toil = new Toil();
toil.initAction = delegate()
{
this.pawn.pather.StartPath(base.TargetThingA, PathEndMode.Touch);
};
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(toil, TargetIndex.A);
yield return(toil);
yield return(ToilEffects.WithProgressBarToilDelay(Toils_General.Wait(1125, 0), TargetIndex.A, false, -0.5f));
yield return(new Toil
{
initAction = delegate()
{
Thing thing = this.job.targetA.Thing;
Designation designation = base.Map.designationManager.DesignationOn(thing, YautjaDefOf.RRY_RearmTrap);
if (designation != null)
{
designation.Delete();
}
(thing as Building_TrapRearmable).Rearm();
this.pawn.records.Increment(YautjaDefOf.RRY_TrapsRearmed);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell));
Toil exitPocket = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(exitPocket, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(exitPocket, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(exitPocket, TargetIndex.A, PathEndMode.InteractionCell);
yield return(exitPocket);
yield return(new Toil
{
initAction = delegate()
{
Pawn pawn = GetActor();
if (TargetA.Thing is Building_PocketDimensionExit pocketDimensionExit)
{
//PocketDimensionBox box = pocketDimensionExit.GetBox();
//if (box != null)
//{
// pawn.DeSpawn(DestroyMode.Vanish);
// GenSpawn.Spawn(pawn, box.Position, box.Map, WipeMode.Vanish);
//}
}
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
//FAIL CONDITIONS
ToilFailConditions.FailOnDestroyedOrNull <JobDriver_Training>(this, TargetIndex.A);
ToilFailConditions.FailOnDespawnedNullOrForbidden <JobDriver_Training>(this, TargetIndex.A);
this.FailOn(() =>
{
Pawn p = this.pawn;
if (this.IsContinuation(this.job) && this.CurToilIndex > 1)
{
if ((double)p.needs.food.CurLevel < 0.25)
{
Messages.Message(p.LabelCap + " has stopped training due hunger.", (GlobalTargetInfo)p, MessageTypeDefOf.NeutralEvent);
}
else if ((double)p.needs.rest.CurLevel < 0.25)
{
Messages.Message(p.LabelCap + " has stopped training due lack of sleep.", (GlobalTargetInfo)p, MessageTypeDefOf.NeutralEvent);
}
}
return((double)p.needs.food.CurLevel < 0.25 || (double)p.needs.rest.CurLevel < 0.25 || p.Drafted || p.jobs.jobQueue.Any());
});
//SEQUENZA AZIONI PAWN
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.OnCell));
Toil Train = Toils_Training(TargetIndex.B);
yield return(Train);
yield return(Toils_General.Wait(100));
yield return(Toils_Jump.Jump(Train));
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(ToilFailConditions.FailOnDespawnedOrNull <Toil> (this.GotoThing(this.TargetA.Cell, this.Map, PathEndMode.OnCell), TargetIndex.A));
yield return(this.DespawnIntoContainer());
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
if (this.job.targetA.HasThing)
{
// ターゲットがThing=水アイテムを摂取する場合
// 水が使用不可能になったらFail
ToilFailConditions.FailOnDestroyedNullOrForbidden <JobDriver_DrinkWater>(this, WaterIndex);
// 水を取得
if (this.drinkingFromInventory)
{
// 所持品から取り出す
yield return(Toils_Mizu.StartCarryFromInventory(WaterIndex));
}
else
{
// 水の場所まで行く
yield return(Toils_Goto.Goto(WaterIndex, PathEndMode.OnCell));
// 水を拾う
yield return(Toils_Ingest.PickupIngestible(WaterIndex, this.pawn));
}
// 飲む場所を決めてそこへ移動
yield return(Toils_Mizu.StartPathToDrinkSpot(WaterIndex));
// 水を摂取
yield return(Toils_Mizu.Drink(WaterIndex));
// 水の摂取終了(心情、水分、アイテム個数の処理)
yield return(Toils_Mizu.FinishDrink(WaterIndex));
if (this.drinkingFromInventory && !this.TargetA.ThingDestroyed)
{
// 所持品から取り出した＆まだ残っている場合は所持品に戻す
yield return(Toils_Mizu.AddCarriedThingToInventory());
}
}
else
{
// ターゲットがThingではない=水アイテムを摂取しない場合=水地形を利用する場合
// 選んだ水地形が使用不可能or到達不可能になったらFail
ToilFailConditions.FailOn <JobDriver_DrinkWater>(this, () =>
{
return(this.job.targetA.Cell.IsForbidden(pawn) || !pawn.CanReach(this.job.targetA.Cell, PathEndMode.ClosestTouch, Danger.Deadly));
});
// 水地形まで移動
yield return(Toils_Goto.GotoCell(WaterIndex, PathEndMode.OnCell));
// 水地形から水分を摂取
yield return(Toils_Mizu.DrinkTerrain(WaterIndex, BaseDrinkTicksFromTerrain));
// 終了
//yield return Toils_Mizu.FinishDrinkTerrain(WaterIndex);
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
Toil followAndAttack = new Toil();
followAndAttack.tickAction = delegate()
{
Pawn actor = followAndAttack.actor;
Job curJob = actor.jobs.curJob;
Thing thing = curJob.GetTarget(TargetIndex.A).Thing;
Pawn pawn = thing as Pawn;
bool flag = this.pawn.Faction != Faction.OfPlayer;
bool flag2 = flag;
if (flag2)
{
actor.mindState.mentalStateHandler.TryStartMentalState(DefDatabase <MentalStateDef> .GetNamed("MurderousRage", true), null, false, false, null);
}
bool flag3 = thing != actor.pather.Destination.Thing || (!this.pawn.pather.Moving && !GenAdj.AdjacentTo8WayOrInside(this.pawn.Position, thing));
bool flag4 = flag3;
if (flag4)
{
actor.pather.StartPath(thing, PathEndMode.Touch);
}
else
{
bool flag5 = GenAdj.AdjacentTo8WayOrInside(this.pawn.Position, thing);
bool flag6 = flag5;
if (flag6)
{
bool flag7 = thing is Pawn && pawn.Downed && !curJob.killIncappedTarget;
bool flag8 = flag7;
if (flag8)
{
this.EndJobWith(JobCondition.Succeeded);
}
bool flag9 = actor.meleeVerbs.TryMeleeAttack(thing, null, false);
bool flag10 = flag9;
if (flag10)
{
this.numMeleeAttacksLanded += 1;
bool flag11 = this.numMeleeAttacksLanded >= curJob.maxNumMeleeAttacks;
bool flag12 = flag11;
if (flag12)
{
this.EndJobWith(JobCondition.Succeeded);
}
}
}
}
};
followAndAttack.defaultCompleteMode = ToilCompleteMode.Never;
ToilFailConditions.EndOnDespawnedOrNull <Toil>(followAndAttack, TargetIndex.A, JobCondition.Succeeded);
ToilFailConditions.FailOn <Toil>(followAndAttack, new Func <bool>(this.hunterIsKilled));
yield return(followAndAttack);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
Toil toil = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch);
ToilFailConditions.FailOnDestroyedOrNull <Toil>(toil, TargetIndex.B);
yield return(toil);
yield return(this.BashIt());
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
ToilFailConditions.FailOnDespawnedOrNull(this, TargetIndex.A);
ToilFailConditions.FailOnDowned(this, TargetIndex.A);
Pawn target = this.TargetA.Thing as Pawn;
yield return(JobDriver_Abuse.ReachTarget(target));
yield return(JobDriver_Abuse.AbuseTarget(target));
yield break;
}
/*
* //maybe change?
* protected abstract int GatherResourcesIntervalDays
* {
* get;
* }
*
* //add breastsize modifier?
* protected abstract int ResourceAmount
* {
* get;
* }
* //add more milks?
* protected abstract ThingDef ResourceDef
* {
* get;
* }
*/
protected override IEnumerable <Toil> MakeNewToils()
{
ToilFailConditions.FailOnDespawnedNullOrForbidden <JobDriver_GatherHumanBodyResources>(this, TargetIndex.A);
ToilFailConditions.FailOnNotCasualInterruptible <JobDriver_GatherHumanBodyResources>(this, TargetIndex.A);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil wait = new Toil();
wait.initAction = delegate
{
Pawn milker = base.pawn;
LocalTargetInfo target = base.job.GetTarget(TargetIndex.A);
Pawn target2 = (Pawn)target.Thing;
milker.pather.StopDead();
PawnUtility.ForceWait(target2, 15000, null, true);
};
wait.tickAction = delegate
{
Pawn milker = base.pawn;
milker.skills.Learn(SkillDefOf.Animals, 0.13f, false);
gatherProgress += StatExtension.GetStatValue(milker, StatDefOf.AnimalGatherSpeed, true);
if (gatherProgress >= WorkTotal)
{
GetComp((Pawn)base.job.GetTarget(TargetIndex.A)).Gathered(base.pawn);
milker.jobs.EndCurrentJob(JobCondition.Succeeded, true);
}
};
wait.AddFinishAction((Action) delegate
{
Pawn milker = base.pawn;
LocalTargetInfo target = base.job.GetTarget(TargetIndex.A);
Pawn target2 = (Pawn)target.Thing;
if (target2 != null && target2.CurJobDef == JobDefOf.Wait_MaintainPosture)
{
milker.jobs.EndCurrentJob(JobCondition.InterruptForced, true);
}
});
ToilFailConditions.FailOnDespawnedOrNull <Toil>(wait, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(wait, TargetIndex.A, PathEndMode.Touch);
wait.AddEndCondition((Func <JobCondition>) delegate
{
if (GetComp((Pawn)base.job.GetTarget(TargetIndex.A)).ActiveAndFull)
{
return(JobCondition.Ongoing);
}
return(JobCondition.Incompletable);
});
wait.defaultCompleteMode = ToilCompleteMode.Never;
ToilEffects.WithProgressBar(wait, TargetIndex.A, (Func <float>)(() => gatherProgress / WorkTotal), false, -0.5f);
wait.activeSkill = (() => SkillDefOf.Animals);
yield return(wait);
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell));
Toil extractStack = Toils_General.Wait(120, 0);
ToilEffects.WithProgressBarToilDelay(extractStack, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(extractStack, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(extractStack, TargetIndex.A, PathEndMode.OnCell);
yield return(extractStack);
yield return(new Toil
{
initAction = delegate()
{
Corpse corpse = (Corpse)TargetThingA;
Hediff_CorticalStack hediff = corpse.InnerPawn.health.hediffSet.hediffs.FirstOrDefault((Hediff x) =>
x.def.defName == "AC_CorticalStack") as Hediff_CorticalStack;
if (hediff != null)
{
if (hediff.def.spawnThingOnRemoved != null)
{
var corticalStack = ThingMaker.MakeThing(hediff.def.spawnThingOnRemoved) as CorticalStack;
if (hediff.hasPawn)
{
corticalStack.SavePawnFromHediff(hediff);
}
else
{
corticalStack.SavePawnToCorticalStack(corpse.InnerPawn);
}
GenPlace.TryPlaceThing(corticalStack, TargetThingA.Position, GetActor().Map, ThingPlaceMode.Near);
ACUtils.ACTracker.RegisterStack(corticalStack);
ACUtils.ACTracker.RegisterSleeve(corpse.InnerPawn, corticalStack.stackGroupID);
}
var head = corpse.InnerPawn.health.hediffSet.GetNotMissingParts().FirstOrDefault((BodyPartRecord x) => x.def == BodyPartDefOf.Head);
if (head != null)
{
Hediff_MissingPart hediff_MissingPart = (Hediff_MissingPart)HediffMaker.MakeHediff(HediffDefOf.MissingBodyPart, corpse.InnerPawn, head);
hediff_MissingPart.lastInjury = HediffDefOf.SurgicalCut;
hediff_MissingPart.IsFresh = true;
corpse.InnerPawn.health.AddHediff(hediff_MissingPart);
}
corpse.InnerPawn.health.RemoveHediff(hediff);
if (pawn.Map.designationManager.DesignationOn(corpse).def == AlteredCarbonDefOf.AC_ExtractStackDesignation)
{
pawn.Map.designationManager.TryRemoveDesignationOn(corpse, AlteredCarbonDefOf.AC_ExtractStackDesignation);
}
}
}
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
ToilFailConditions.FailOnDestroyedOrNull <JobDriver_Segmentation>(this, TargetIndex.A);
ToilFailConditions.FailOnDespawnedOrNull <JobDriver_Segmentation>(this, TargetIndex.A);
ToilFailConditions.FailOn <JobDriver_Segmentation>(this, new Func <bool>(this.eaterIsKilled));
Toil resCorpse = new Toil();
resCorpse.initAction = delegate()
{
Pawn actor = resCorpse.actor;
Thing thing = resCorpse.actor.CurJob.GetTarget(TargetIndex.A).Thing;
bool flag = !thing.Spawned || !this.Map.reservationManager.CanReserve(actor, thing, 1);
bool flag2 = flag;
if (flag2)
{
actor.jobs.EndCurrentJob(JobCondition.Incompletable, true);
}
else
{
this.Map.reservationManager.Reserve(actor, actor.CurJob, thing, 1);
}
};
resCorpse.defaultCompleteMode = ToilCompleteMode.Instant;
yield return(resCorpse);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
yield return(Toils_General.Wait(400));
Toil toil = new Toil
{
defaultCompleteMode = ToilCompleteMode.Instant
};
toil.initAction = new Action(this.doStripCorpse);
yield return(toil);
yield return(Toils_General.Wait(60));
Toil toil2 = new Toil
{
defaultCompleteMode = ToilCompleteMode.Instant
};
toil2.initAction = new Action(this.doChewCorpse);
ToilEffects.WithEffect(toil2, EffecterDefOf.EatMeat, TargetIndex.A);
ToilFailConditions.EndOnDespawnedOrNull <Toil>(toil2, TargetIndex.A, JobCondition.Incompletable);
yield return(toil2);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
ToilFailConditions.FailOnDespawnedNullOrForbidden(this, TargetIndex.A);
ToilFailConditions.FailOnNotCasualInterruptible(this, TargetIndex.A);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil wait = new Toil();
wait.initAction = delegate()
{
Pawn actor = wait.actor;
Pawn pawn = (Pawn)job.GetTarget(TargetIndex.A).Thing;
actor.pather.StopDead();
PawnUtility.ForceWait(pawn, 15000, null, true);
};
wait.tickAction = delegate()
{
Pawn actor = wait.actor;
actor.skills.Learn(SkillDefOf.Animals, 0.13f, false);
gatherProgress += StatExtension.GetStatValue(actor, StatDefOf.AnimalGatherSpeed, true);
if (gatherProgress >= WorkTotal)
{
GetComp((Pawn)((Thing)job.GetTarget(TargetIndex.A))).Gathered(this.pawn);
actor.jobs.EndCurrentJob(JobCondition.Succeeded, true);
}
};
wait.AddFinishAction(delegate()
{
Pawn pawn = (Pawn)job.GetTarget(TargetIndex.A).Thing;
if (pawn != null && pawn.CurJobDef == JobDefOf.Wait_MaintainPosture)
{
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced, true);
}
});
ToilFailConditions.FailOnDespawnedOrNull <Toil>(wait, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(wait, TargetIndex.A, PathEndMode.Touch);
wait.AddEndCondition(delegate()
{
if (!GetComp((Pawn)((Thing)this.job.GetTarget(TargetIndex.A))).ActiveAndFull)
{
return(JobCondition.Incompletable);
}
return(JobCondition.Ongoing);
});
wait.defaultCompleteMode = ToilCompleteMode.Never;
ToilEffects.WithProgressBar(wait, TargetIndex.A, () => this.gatherProgress / this.WorkTotal, false, -0.5f);
wait.activeSkill = (() => SkillDefOf.Animals);
yield return(wait);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnAggroMentalState(TargetIndex.A);
Toil approachPrisoner = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch);
yield return(approachPrisoner);
Toil collectPrisoner = Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false);
yield return(collectPrisoner);
Toil escortPrisoner = Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.InteractionCell);
//Toil escortPrisoner = Toils_Haul.CarryHauledThingToContainer(.GotoThing(TargetIndex.B, PathEndMode.InteractionCell);
yield return(escortPrisoner);
Toil enterPocket = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(enterPocket, TargetIndex.B, false, -0.5f);
ToilFailConditions.FailOnCannotTouch <Toil>(enterPocket, TargetIndex.B, PathEndMode.InteractionCell);
yield return(enterPocket);
yield return(new Toil
{
initAction = delegate()
{
Thing thing;
pawn.carryTracker.TryDropCarriedThing(TargetB.Thing.Position, ThingPlaceMode.Direct, out thing);
if (TargetA.Thing is Pawn prisoner && TargetB.Thing is Building_PocketDimensionEntranceBase pocketDimensionEntrance)
{
Building_PocketDimensionEntranceBase otherSide = PocketDimensionUtility.GetOtherSide(pocketDimensionEntrance);
if (otherSide != null && otherSide.Map != null)
{
IntVec3 position = otherSide.Position;
Map map = otherSide.Map;
if (position != null && map != null)
{
prisoner.DeSpawn(DestroyMode.Vanish);
GenSpawn.Spawn(prisoner, position, map, WipeMode.Vanish);
}
}
}
}
});
// Token: 0x06000030 RID: 48 RVA: 0x00002C83 File Offset: 0x00000E83
protected override IEnumerable <Toil> MakeNewToils()
{
CompUniversalFermenter comp = ThingCompUtility.TryGetComp <CompUniversalFermenter>(this.Fermenter);
ToilFailConditions.FailOn <JobDriver_TakeProductOutOfUniversalFermenter>(this, () => !comp.Fermented);
ToilFailConditions.FailOnDestroyedNullOrForbidden <JobDriver_TakeProductOutOfUniversalFermenter>(this, (TargetIndex)1);
yield return(Toils_Reserve.Reserve((TargetIndex)1, 1, -1, null));
yield return(Toils_Goto.GotoThing((TargetIndex)1, (PathEndMode)3));
yield return(ToilEffects.WithProgressBarToilDelay(ToilFailConditions.FailOnDestroyedNullOrForbidden <Toil>(Toils_General.Wait(200, 0), (TargetIndex)1), (TargetIndex)1, false, -0.5f));
yield return(new Toil
{
initAction = delegate()
{
Thing thing = comp.TakeOutProduct();
GenPlace.TryPlaceThing(thing, this.pawn.Position, this.Map, (ThingPlaceMode)1, null, null);
StoragePriority storagePriority = StoreUtility.CurrentStoragePriorityOf(thing);
IntVec3 intVec;
if (StoreUtility.TryFindBestBetterStoreCellFor(thing, this.pawn, this.Map, storagePriority, this.pawn.Faction, out intVec, true))
{
this.job.SetTarget((TargetIndex)2, thing);
this.job.count = thing.stackCount;
this.job.SetTarget((TargetIndex)3, intVec);
return;
}
this.EndJobWith((JobCondition)3);
},
defaultCompleteMode = (ToilCompleteMode)1
});
yield return(Toils_Reserve.Reserve((TargetIndex)2, 1, -1, null));
yield return(Toils_Reserve.Reserve((TargetIndex)3, 1, -1, null));
yield return(Toils_Goto.GotoThing((TargetIndex)2, (PathEndMode)3));
yield return(Toils_Haul.StartCarryThing((TargetIndex)2, false, false, false));
Toil carry = Toils_Haul.CarryHauledThingToCell((TargetIndex)3);
yield return(carry);
yield return(Toils_Haul.PlaceHauledThingInCell((TargetIndex)3, carry, 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_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell));
Toil enterPocket = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(enterPocket, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(enterPocket, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(enterPocket, TargetIndex.A, PathEndMode.InteractionCell);
yield return(enterPocket);
yield return(new Toil
{
initAction = delegate()
{
Pawn pawn = GetActor();
if (TargetA.Thing is Building_PocketDimensionEntranceBase pocketDimensionEntrance)
{
Building_PocketDimensionEntranceBase otherSide = PocketDimensionUtility.GetOtherSide(pocketDimensionEntrance);
if (otherSide != null && otherSide.Map != null)
{
IntVec3 position = otherSide.Position;
Map map = otherSide.Map;
// If otherSide is uninstalled...
if (otherSide.Map == null && otherSide.holdingOwner != null && otherSide.holdingOwner.Owner != null && (otherSide.holdingOwner.Owner as MinifiedThing) != null)
{
MinifiedThing miniThing = (otherSide.holdingOwner.Owner as MinifiedThing);
position = miniThing.Position;
map = miniThing.Map;
}
if (position != null && map != null)
{
pawn.ClearAllReservations();
pawn.DeSpawn(DestroyMode.Vanish);
GenSpawn.Spawn(pawn, position, map, WipeMode.Vanish);
}
}
}
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
ToilFailConditions.FailOnMentalState(this, TargetIndex.A);
Toil waitToil = new Toil();
waitToil.initAction = delegate
{
waitToil.actor.pather.StopDead();
};
waitToil.defaultCompleteMode = ToilCompleteMode.Delay;
waitToil.defaultDuration = this.CompReloader.reloaderProp.reloadTick;
yield return(waitToil);
Toil toil = new Toil();
toil.AddFinishAction(new Action(this.CompReloader.FinishReload));
yield return(toil);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell));
Toil extractStack = Toils_General.Wait(120, 0);
ToilEffects.WithProgressBarToilDelay(extractStack, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(extractStack, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(extractStack, TargetIndex.A, PathEndMode.OnCell);
yield return(extractStack);
yield return(new Toil
{
initAction = delegate()
{
Corpse corpse = (Corpse)TargetThingA;
Hediff_CorticalStack hediff = corpse.InnerPawn.health.hediffSet.hediffs.FirstOrDefault((Hediff x) =>
x.def.defName == "AC_CorticalStack") as Hediff_CorticalStack;
if (hediff != null)
{
if (hediff.def.spawnThingOnRemoved != null)
{
var corticalStack = ThingMaker.MakeThing(hediff.def.spawnThingOnRemoved) as CorticalStack;
if (hediff.hasPawn)
{
corticalStack.SavePawnFromHediff(hediff);
}
else
{
corticalStack.SavePawnToCorticalStack(corpse.InnerPawn);
}
GenPlace.TryPlaceThing(corticalStack, TargetThingA.Position, GetActor().Map, ThingPlaceMode.Near);
ACUtils.ACTracker.RegisterStack(corticalStack);
ACUtils.ACTracker.RegisterSleeve(corpse.InnerPawn);
}
corpse.InnerPawn.health.RemoveHediff(hediff);
}
}
});
}
// Token: 0x0600002B RID: 43 RVA: 0x00002C03 File Offset: 0x00000E03
protected override IEnumerable <Toil> MakeNewToils()
{
CompUniversalFermenter comp = ThingCompUtility.TryGetComp <CompUniversalFermenter>(this.Fermenter);
ToilFailConditions.FailOn <JobDriver_FillUniversalFermenter>(this, () => comp.SpaceLeftForIngredient <= 0);
ToilFailConditions.FailOnDestroyedNullOrForbidden <JobDriver_FillUniversalFermenter>(this, (TargetIndex)1);
ToilFailConditions.FailOnDestroyedNullOrForbidden <JobDriver_FillUniversalFermenter>(this, (TargetIndex)2);
Toil ingrToil = Toils_Reserve.Reserve((TargetIndex)2, 1, -1, null);
yield return(ingrToil);
yield return(Toils_Reserve.Reserve((TargetIndex)1, 1, -1, null));
yield return(ToilFailConditions.FailOnDestroyedNullOrForbidden <Toil>(ToilFailConditions.FailOnSomeonePhysicallyInteracting <Toil>(Toils_Goto.GotoThing((TargetIndex)2, (PathEndMode)3), (TargetIndex)2), (TargetIndex)2));
yield return(ToilFailConditions.FailOnDestroyedNullOrForbidden <Toil>(Toils_Haul.StartCarryThing((TargetIndex)2, false, true, false), (TargetIndex)2));
yield return(Toils_Haul.CheckForGetOpportunityDuplicate(ingrToil, (TargetIndex)2, 0, true, null));
yield return(Toils_Haul.CarryHauledThingToCell((TargetIndex)1));
yield return(ToilEffects.WithProgressBarToilDelay(ToilFailConditions.FailOnDestroyedNullOrForbidden <Toil>(Toils_General.Wait(200, 0), (TargetIndex)1), (TargetIndex)1, false, -0.5f));
yield return(new Toil
{
initAction = delegate()
{
if (!comp.AddIngredient(this.Ingredient))
{
this.EndJobWith((JobCondition)3);
Log.Message("JobCondition.Incompletable", false);
}
},
defaultCompleteMode = (ToilCompleteMode)1
});
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
// 水が使用不可能になったらFail
ToilFailConditions.FailOnDestroyedNullOrForbidden <JobDriver_WaterDeliver>(this, WaterIndex);
if (!this.pawn.CanReserveAndReach(this.TargetA, PathEndMode.Touch, Danger.Deadly, 1, this.job.count))
{
// 水を予約できなかったら終了
this.pawn.jobs.EndCurrentJob(JobCondition.Incompletable);
yield break;
}
// 予約する
if (!this.pawn.Map.reservationManager.ReservedBy(this.TargetA.Thing, pawn))
{
yield return(Toils_Reserve.Reserve(WaterIndex, 1, this.job.count, null));
}
if (this.drinkingFromInventory)
{
// 水を持ち物から取り出す
yield return(Toils_Mizu.StartCarryFromInventory(WaterIndex));
}
else
{
// 水の場所まで行く
yield return(Toils_Goto.Goto(WaterIndex, PathEndMode.OnCell));
// 水を拾う
yield return(Toils_Ingest.PickupIngestible(WaterIndex, this.pawn));
}
// スポットまで移動する
yield return(Toils_Goto.GotoCell(this.TargetC.Cell, PathEndMode.OnCell));
// 置いて囚人に予約させる
yield return(Toils_Mizu.DropCarriedThing(PrisonerIndex, DropSpotIndex));
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Reserve.Reserve((TargetIndex)1, 1, -1, null));
yield return(ToilFailConditions.FailOn(Toils_Goto.GotoCell((TargetIndex)1, (PathEndMode)4), delegate(Toil to)
{
Building_SignalFire building_SignalFire = (Building_SignalFire)to.actor.jobs.curJob.GetTarget((TargetIndex)1).Thing;
return !building_SignalFire.CanUseSignalFireNow;
}));
yield return(new Toil
{
initAction = () =>
{
Pawn pawn = this.pawn;
Building_SignalFire building_SignalFire = (Building_SignalFire)pawn.jobs.curJob.GetTarget((TargetIndex)1).Thing;
bool canUseSignalFireNow = building_SignalFire.CanUseSignalFireNow;
if (canUseSignalFireNow)
{
pawn.jobs.curJob.commTarget.TryOpenComms(pawn);
}
}
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (ZTracker.jobTracker.ContainsKey(pawn))
{
this.savedThing = this.TargetB.Thing;
}
}
});
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnBurningImmobile(TargetIndex.B);
this.FailOnForbidden(TargetIndex.B);
Toil reserveTargetA = Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null);
yield return(reserveTargetA);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch));
yield return(new Toil
{
initAction = delegate()
{
if (this.pawn.jobs.curJob.count == -1)
{
this.pawn.jobs.curJob.count = Mathf.Min(TargetB.Thing.stackCount, (int)(pawn.GetStatValue(StatDefOf.CarryingCapacity, true) / TargetB.Thing.def.VolumePerUnit));
if (this.pawn.jobs.curJob.count < 0)
{
this.pawn.jobs.curJob.count = TargetB.Thing.stackCount;
}
}
ZLogger.Message(this.pawn + " haul count: " + this.pawn.jobs.curJob.count);
}
});
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, true, false));
yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveTargetA, TargetIndex.B, TargetIndex.A,
false, null));
Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.A);
yield return(carryToCell);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell));
Toil useStairs = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(useStairs, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(useStairs, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(useStairs, TargetIndex.A, PathEndMode.OnCell);
//yield return new Toil
//{
// initAction = delegate () {
// ZLogger.Message("this.pawn.CanReachImmediate(TargetA.Thing, PathEndMode.OnCell): "
// + this.pawn.CanReachImmediate(TargetA.Thing, PathEndMode.OnCell), true);
// }
//};
yield return(useStairs);
yield return(new Toil
{
initAction = delegate()
{
try
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (ZTracker.jobTracker.ContainsKey(pawn))
{
if (ZTracker.jobTracker[pawn].mainJob.targetA.Thing != null &&
ZTracker.jobTracker[pawn].mainJob.targetA.Thing == this.savedThing &&
ZTracker.jobTracker[pawn].mainJob.targetA.Thing != TargetB.Thing)
{
ZLogger.Message("1 Pawns carried thing not the same: " + ZTracker.jobTracker[pawn].mainJob.targetA.Thing);
ZTracker.jobTracker[pawn].mainJob.targetA = new LocalTargetInfo(TargetB.Thing);
}
else if (ZTracker.jobTracker[pawn].mainJob.targetB.Thing != null &&
ZTracker.jobTracker[pawn].mainJob.targetB.Thing == this.savedThing &&
ZTracker.jobTracker[pawn].mainJob.targetB.Thing != TargetB.Thing)
{
ZLogger.Message("2 Pawns carried thing not the same: " + ZTracker.jobTracker[pawn].mainJob.targetB.Thing);
ZTracker.jobTracker[pawn].mainJob.targetB = new LocalTargetInfo(TargetB.Thing);
}
try
{
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueA.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueA[i];
if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetB.Thing)
{
ZLogger.Message("3 Pawns carried thing not the same: " + target.Thing);
ZTracker.jobTracker[pawn].mainJob.targetQueueA[i] = new LocalTargetInfo(TargetB.Thing);
}
}
}
catch { }
try
{
try
{
ZLogger.Message("--------------------------");
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
ZLogger.Message("JobDriver_HaulThingToStairs BEFORE job.targetQueueB: " + target.Thing);
ZLogger.Message("JobDriver_HaulThingToStairs BEFORE job.targetQueueB.Map: " + target.Thing.Map);
ZLogger.Message("JobDriver_HaulThingToStairs BEFORE job.targetQueueB.stackCount: " + target.Thing.stackCount);
ZLogger.Message("JobDriver_HaulThingToStairs BEFORE job.targetQueueB.countQueue: " + ZTracker.jobTracker[pawn].mainJob.countQueue[i]);
}
}
catch { }
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetB.Thing)
{
ZLogger.Message("4 Pawns carried thing not the same");
ZLogger.Message("4 Pawns target.Thing: " + target.Thing);
ZLogger.Message("4 Pawns target.Thing.Map: " + target.Thing.Map);
ZLogger.Message("4 Pawns this.savedThing: " + this.savedThing);
ZLogger.Message("4 Pawns this.savedThing.Map: " + this.savedThing.Map);
ZLogger.Message("4 Pawns TargetB.Thing: " + TargetB.Thing);
ZLogger.Message("4 Pawns TargetB.Thing.Map: " + TargetB.Thing.Map);
//ZLogger.Message("Replacing " + ZTracker.jobTracker[this.pawn].mainJob.targetQueueB[i] + " by " + TargetB);
//
//ZTracker.jobTracker[pawn].mainJob.targetQueueB[i] = new LocalTargetInfo(TargetB.Thing);
//ZTracker.jobTracker[pawn].mainJob.countQueue[i] = TargetB.Thing.stackCount;
//
if (ZTracker.jobTracker[pawn].mainJob.targetQueueB[i].Thing.stackCount == 0)
{
ZTracker.jobTracker[pawn].mainJob.targetQueueB[i] = new LocalTargetInfo(TargetB.Thing);
ZTracker.jobTracker[pawn].mainJob.countQueue[i] = TargetB.Thing.stackCount;
ZLogger.Message("Altering " + ZTracker.jobTracker[this.pawn].mainJob);
break;
}
else
{
if (ZTracker.jobTracker[pawn].mainJob.targetQueueB
.Where(x => x.Thing == TargetB.Thing).Count() == 0)
{
var newTarget = new LocalTargetInfo(TargetB.Thing);
ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.Add(newTarget);
ZTracker.jobTracker[this.pawn].mainJob.countQueue.Add(newTarget.Thing.stackCount);
ZLogger.Message("2 Adding " + newTarget + " to " + ZTracker.jobTracker[this.pawn].mainJob);
int ind = ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.FirstIndexOf(x => x.Thing == this.savedThing);
ZLogger.Message("2 Removing " + ZTracker.jobTracker[this.pawn].mainJob.targetQueueB[ind] + " from " + ZTracker.jobTracker[this.pawn].mainJob);
ZTracker.jobTracker[this.pawn].mainJob.targetQueueB.RemoveAt(ind);
ZTracker.jobTracker[this.pawn].mainJob.countQueue.RemoveAt(ind);
break;
}
else
{
ZLogger.Message("Cant add " + TargetB.Thing + " to " + ZTracker.jobTracker[this.pawn].mainJob);
}
}
}
}
try
{
ZLogger.Message("--------------------------");
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
ZLogger.Message("JobDriver_HaulThingToStairs AFTER job.targetQueueB: " + target.Thing);
ZLogger.Message("JobDriver_HaulThingToStairs AFTER job.targetQueueB.Map: " + target.Thing.Map);
ZLogger.Message("JobDriver_HaulThingToStairs AFTER job.targetQueueB.stackCount: " + target.Thing.stackCount);
ZLogger.Message("JobDriver_HaulThingToStairs AFTER job.targetQueueB.countQueue: " + ZTracker.jobTracker[pawn].mainJob.countQueue[i]);
}
}
catch { }
}
catch { }
}
}
catch (Exception ex)
{
Log.Error("Z-Tracker produced an error in JobDriver_HaulThingToStairs class. Report about it to devs. Error: " + ex);
}
}
});
yield return(new Toil()
{
initAction = () =>
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
Pawn pawn = GetActor();
if (TargetA.Thing is Building_StairsUp stairsUp)
{
Map map = ZTracker.GetUpperLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateUpperLevel(this.pawn.Map, stairsUp.Position);
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
else
{
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
}
if (TargetA.Thing is Building_StairsDown stairsDown)
{
Map map = ZTracker.GetLowerLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateLowerLevel(this.pawn.Map, stairsDown.Position);
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map);
}
else
{
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map);
}
}
try
{
for (int i = ZTracker.jobTracker[pawn].mainJob.targetQueueB.Count - 1; i >= 0; i--)
{
var target = ZTracker.jobTracker[pawn].mainJob.targetQueueB[i];
ZLogger.Message("JobDriver_HaulThingToStairs job.targetQueueB: " + target.Thing);
ZLogger.Message("JobDriver_HaulThingToStairs job.targetQueueB.Map: " + target.Thing.Map);
ZLogger.Message("JobDriver_HaulThingToStairs job.targetQueueB.stackCount: " + target.Thing.stackCount);
ZLogger.Message("JobDriver_HaulThingToStairs job.targetQueueB.countQueue: " + ZTracker.jobTracker[pawn].mainJob.countQueue[i]);
}
}
catch { }
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell));
Toil useStairs = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(useStairs, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(useStairs, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(useStairs, TargetIndex.A, PathEndMode.OnCell);
yield return(useStairs);
yield return(new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
Pawn pawn = GetActor();
if (TargetA.Thing is Building_StairsUp stairsUp)
{
Map map = ZTracker.GetUpperLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateUpperLevel(this.pawn.Map, stairsUp.Position);
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, false, true);
}
else
{
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
}
else if (TargetA.Thing is Building_StairsDown stairsDown)
{
Map map = ZTracker.GetLowerLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateLowerLevel(this.pawn.Map, stairsDown.Position);
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, true);
}
else
{
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, stairsDown.shouldSpawnStairsBelow);
stairsDown.shouldSpawnStairsBelow = false;
}
}
try
{
ZLogger.Message("5 lastTick");
ZTracker.jobTracker[pawn].lastTickFood = Find.TickManager.TicksGame + 201;
ZTracker.jobTracker[pawn].lastTickJoy = Find.TickManager.TicksGame + 201;
}
catch { };
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
// ターゲットがThing=水アイテムを摂取する場合
// 水(食事)が使用不可能になったらFail
ToilFailConditions.FailOnDestroyedNullOrForbidden(this, WaterIndex);
ToilFailConditions.FailOn(this, () =>
{
if (this.Patient == null)
{
return(true);
}
// 患者がベッドに入ってなかったらFail
if (!this.Patient.InBed())
{
return(true);
}
// 到達不能になっていたらFail
if (!this.pawn.CanReach(this.Patient, PathEndMode.ClosestTouch, Danger.Deadly))
{
return(true);
}
return(false);
});
// 水が予約出来ない状態なら中断
if (!ReservationUtility.CanReserveAndReach(this.pawn, this.TargetA, PathEndMode.Touch, Danger.Deadly, 1, this.job.count, null, false))
{
this.GetActor().jobs.EndCurrentJob(JobCondition.Incompletable);
yield break;
}
// 水を予約する
if (!this.pawn.Map.reservationManager.ReservedBy(this.TargetA.Thing, pawn))
{
yield return(Toils_Reserve.Reserve(WaterIndex, 1, this.job.count, null));
}
if (this.getItemFromInventory)
{
// 水を持ち物から取り出す
yield return(Toils_Mizu.StartCarryFromInventory(WaterIndex));
}
else
{
// 水の場所まで行く
yield return(Toils_Goto.Goto(WaterIndex, PathEndMode.OnCell));
// 水を拾う
yield return(Toils_Ingest.PickupIngestible(WaterIndex, this.pawn));
}
// 患者のもとへ移動
yield return(Toils_Goto.Goto(PatientIndex, PathEndMode.Touch));
// 水を飲ませる
yield return(Toils_Mizu.FeedToPatient(WaterIndex, PatientIndex));
// 水の摂取終了(心情、食事の処理)
yield return(Toils_Mizu.FinishDrinkPatient(WaterIndex, PatientIndex));
if (this.getItemFromInventory && !this.TargetA.ThingDestroyed)
{
// 所持品から取り出した＆まだ残っている場合は所持品に戻す
yield return(Toils_Mizu.AddCarriedThingToInventory());
}
}
// Token: 0x0600003C RID: 60 RVA: 0x000038A6 File Offset: 0x00001AA6
protected override IEnumerable <Toil> MakeNewToils()
{
Pawn actor = base.GetActor();
ToilFailConditions.FailOnDespawnedNullOrForbidden <JobDriver_JPRefuel>(this, TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch), TargetIndex.A));
Toil refuel = Toils_General.Wait(180, 0);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(refuel, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(refuel, TargetIndex.A, PathEndMode.Touch);
ToilEffects.WithProgressBarToilDelay(refuel, TargetIndex.A, false, -0.5f);
yield return(refuel);
yield return(new Toil
{
initAction = delegate()
{
int JPFuel = 0;
int JPMax = 0;
Pawn obj = actor;
if (obj != null && obj.apparel.WornApparelCount == 0)
{
//Log.Message("True: obj != null && obj.apparel.WornApparelCount == 0");
this.EndJobWith(JobCondition.Incompletable);
return;
}
Apparel JetPack = null;
List <Apparel> list = actor.apparel.WornApparel;
for (int i = 0; i < list.Count; i++)
{
if (list[i] is JetPackApparel)
{
JetPack = list[i];
break;
}
}
if (JetPack == null)
{
this.EndJobWith(JobCondition.Incompletable);
return;
}
if (JetPack is JetPackApparel)
{
//Log.Message("True: JetPack is JetPackApparel");
JPFuel = (JetPack as JetPackApparel).JPFuelAmount;
JPMax = (JetPack as JetPackApparel).JPFuelMax;
}
if (JPMax - JPFuel <= 0)
{
//Log.Message("True: JPMax - JPFuel <= 0");
this.EndJobWith(JobCondition.Incompletable);
return;
}
if (this.TargetThingA.stackCount > JPMax - JPFuel)
{
//Log.Message("True: this.TargetThingA.stackCount > JPMax - JPFuel");
(JetPack as JetPackApparel).JPFuelAmount = JPMax;
this.TargetThingA.stackCount -= JPMax - JPFuel;
Messages.Message(TranslatorFormattedStringExtensions.Translate("JetPack.FullyRefueled", actor.LabelShort), actor, MessageTypeDefOf.NeutralEvent, false);
this.EndJobWith(JobCondition.Succeeded);
return;
}
//Log.Message("False");
(JetPack as JetPackApparel).JPFuelAmount = JPFuel + this.TargetThingA.stackCount;
Messages.Message(TranslatorFormattedStringExtensions.Translate("JetPack.Refueled", GenText.CapitalizeFirst(actor.LabelShort), this.TargetThingA.stackCount.ToString(), (this.TargetThingA.stackCount > 1) ? "s" : ""), actor, MessageTypeDefOf.NeutralEvent, false);
this.TargetThingA.Destroy(0);
this.EndJobWith(JobCondition.Succeeded);
}
});
yield break;
}
public override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell));
Toil useStairs = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(useStairs, TargetIndex.A, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(useStairs, TargetIndex.A);
ToilFailConditions.FailOnCannotTouch <Toil>(useStairs, TargetIndex.A, PathEndMode.OnCell);
yield return(useStairs);
yield return(new Toil
{
initAction = delegate()
{
var ZTracker = ZUtils.ZTracker;
Pawn pawn = GetActor();
if (TargetA.Thing is Building_StairsUp stairsUp)
{
Map map = ZTracker.GetUpperLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
map = ZTracker.CreateUpperLevel(this.pawn.Map, stairsUp.Position);
if (!string.IsNullOrEmpty(stairsUp.pathToPreset))
{
var comp = ZUtils.GetMapComponentZLevel(map);
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, false, true);
}
else
{
if (!string.IsNullOrEmpty(stairsUp.pathToPreset))
{
var comp = ZUtils.GetMapComponentZLevel(map);
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
}
else if (TargetA.Thing is Building_StairsDown stairsDown)
{
Map map = ZTracker.GetLowerLevel(this.pawn.Map.Tile, this.pawn.Map);
if (map == null)
{
//ZLogger.Message("CREATING LOWER LEVEL AGAIG", true);
map = ZTracker.CreateLowerLevel(this.pawn.Map, stairsDown.Position);
if (!string.IsNullOrEmpty(stairsDown.pathToPreset))
{
var comp = ZUtils.GetMapComponentZLevel(map);
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, true);
}
else
{
if (!string.IsNullOrEmpty(stairsDown.pathToPreset))
{
var comp = ZUtils.GetMapComponentZLevel(map);
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, stairsDown.shouldSpawnStairsBelow);
stairsDown.shouldSpawnStairsBelow = false;
}
}
}
});
protected override IEnumerable <Toil> MakeNewToils()
{
// Just on the off-chance the rock is on fire...
this.FailOnBurningImmobile(TargetIndex.A);
// Reserve the target
yield return(Toils_Reserve.Reserve(TargetIndex.A));
// Go to the target
Toil toilGoto = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch);
// Fail going to the target if it becomes unreachable
ToilFailConditions.FailOn <Toil>(toilGoto, (Func <bool>)(() =>
{
if (Reachability.CanReach(pawn, (TargetInfo)TargetLocA, PathEndMode.Touch, pawn.NormalMaxDanger()))
{
return(false);
}
return(true);
}));
yield return(toilGoto);
// Now the work toil itself
Toil toilWork = new Toil
{
// Continue until done
defaultCompleteMode = ToilCompleteMode.Never,
// When the job starts...
initAction = new Action(() =>
{
smoothTicks = 0;
}),
// The work tick
tickAction = new Action(() =>
{
if (pawn.skills != null)
{
const float constructionXP = 0.11f / 5f;
const float miningXP = 0.11f / 5f;
const float artisticXP = 0.11f / 5f;
pawn.skills.Learn(SkillDefOf.Construction, constructionXP);
pawn.skills.Learn(SkillDefOf.Mining, miningXP);
pawn.skills.Learn(SkillDefOf.Artistic, artisticXP);
}
smoothTicks += 1;
if (smoothTicks < nextSmoothStrike)
{
return;
}
// Reset counter, damage rock
smoothTicks = 0;
mineable.HitPoints -= DamagePerStrike;
})
};
// When should we stop?
toilWork.endConditions.Add((Func <JobCondition>)(() =>
{
// Go until the rock is fully damaged
if (mineable.HitPoints > 0)
{
return(JobCondition.Ongoing);
}
return(JobCondition.Succeeded);
}));
// Do something when done
toilWork.AddFinishAction(new Action(() =>
{
// If the job failed, abort
if (mineable.HitPoints > 0)
{
return;
}
// Clear the designation at this cell
Common.RemoveDesignationDefOfAt(SmoothWall.designationDef, TargetA.Cell);
// Better have associated stone blocks...
string blocksDef = "Blocks" + mineable.def.defName;
ThingDef stoneBlocks = DefDatabase <ThingDef> .GetNamed(blocksDef, true);
// Replace the rock with a stone wall
var wallThing = ThingMaker.MakeThing(SmoothWall.thingDef, stoneBlocks);
if (wallThing != null)
{
var wall = GenSpawn.Spawn(wallThing, TargetA.Cell);
if (wall != null)
{
wall.SetFaction(Faction.OfColony);
}
}
}));
// Some fun sounds while working
ToilEffects.WithSustainer(toilWork, (Func <SoundDef>)(() =>
{
return(SmoothWall.soundDef);
}));
// Some fun effects while working
ToilEffects.WithEffect(toilWork, "Mine", TargetIndex.A);
yield return(toilWork);
// And we're done.
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
base.AddEndCondition(delegate()
{
var thing = base.GetActor().jobs.curJob.GetTarget(TargetIndex.A).Thing;
if (thing is Building && !thing.Spawned)
{
return(JobCondition.Incompletable);
}
return(JobCondition.Ongoing);
});
this.FailOnBurningImmobile <JobDriver_DoBill>(TargetIndex.A);
this.FailOn <JobDriver_DoBill>(delegate()
{
if (!(this.job.GetTarget(TargetIndex.A).Thing is IBillGiver billGiver))
{
return(false);
}
if (this.job.bill.DeletedOrDereferenced)
{
return(true);
}
if (!billGiver.CurrentlyUsableForBills())
{
return(true);
}
return(false);
});
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell));
var tableThing = this.job.GetTarget(TargetIndex.A).Thing as Building_СontainmentBreach;
CompRefuelable refuelableComp = tableThing.GetComp <CompRefuelable>();
Toil toil = new Toil();
toil.initAction = delegate()
{
this.job.bill.Notify_DoBillStarted(this.pawn);
this.workCycleProgress = this.job.bill.recipe.workAmount;
};
toil.tickAction = delegate()
{
this.workCycleProgress -= StatExtension.GetStatValue(this.pawn, StatDefOf.WorkToMake, true);
tableThing.UsedThisTick();
if (!tableThing.CurrentlyUsableForBills() || (refuelableComp != null && !refuelableComp.HasFuel))
{
this.pawn.jobs.EndCurrentJob(JobCondition.Incompletable, true, true);
}
if (this.workCycleProgress <= 0f)
{
SkillDef workSkill = this.job.bill.recipe.workSkill;
if (workSkill != null)
{
SkillRecord skill = this.pawn.skills.GetSkill(workSkill);
if (skill != null)
{
skill.Learn(0.11f * this.job.bill.recipe.workSkillLearnFactor, false);
}
}
GenSpawn.Spawn(tableThing.GetKorsolianToxin(this.job.bill.recipe),
tableThing.InteractionCell, tableThing.Map, 0);
Toils_Reserve.Release(TargetIndex.A);
PawnUtility.GainComfortFromCellIfPossible(this.pawn, false);
this.job.bill.Notify_IterationCompleted(this.pawn, null);
this.ReadyForNextToil();
}
};
toil.defaultCompleteMode = ToilCompleteMode.Never;
ToilEffects.WithEffect(toil, () => this.job.bill.recipe.effectWorking, TargetIndex.A);
ToilEffects.PlaySustainerOrSound(toil, () => toil.actor.CurJob.bill.recipe.soundWorking);
ToilEffects.WithProgressBar(toil, TargetIndex.A, delegate()
{
return(PurpleIvyUtils.GetPercentageFromPartWhole
(this.job.bill.recipe.workAmount - this.workCycleProgress,
(int)this.job.bill.recipe.workAmount) / 100f);
}, false, 0.5f);
ToilFailConditions.FailOn <Toil>(toil, delegate()
{
IBillGiver billGiver = this.job.GetTarget(TargetIndex.A).Thing as IBillGiver;
return(this.job.bill.suspended || this.job.bill.DeletedOrDereferenced || (billGiver != null && !billGiver.CurrentlyUsableForBills()));
});
yield return(toil);
yield break;
}
public static IEnumerable <Toil> Toils_GoToThingMap(Pawn pawn, Thing selectedStairs, Thing thing, JobDriver instance)
{
Toil setStairs = new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
ZLogger.Message("Pawn: " + pawn);
ZLogger.Message("Pawn.map: " + pawn.Map);
ZLogger.Message("thing: " + thing);
ZLogger.Message("thing.Map: " + thing.Map);
ZLogger.Message("pawn.CurJob: " + pawn.jobs.curJob);
if (ZTracker.GetZIndexFor(pawn.Map) > ZTracker.GetZIndexFor(thing.Map))
{
var stairs = ZTracker.stairsDown[pawn.Map];
if (stairs?.Count() > 0)
{
selectedStairs = stairs.MinBy(x => IntVec3Utility.DistanceTo(thing.Position, x.Position));
}
}
else if (ZTracker.GetZIndexFor(pawn.Map) < ZTracker.GetZIndexFor(thing.Map))
{
var stairs = ZTracker.stairsUp[pawn.Map];
if (stairs?.Count() > 0)
{
selectedStairs = stairs.MinBy(x => IntVec3Utility.DistanceTo(thing.Position, x.Position));
}
}
pawn.jobs.curJob.targetC = new LocalTargetInfo(selectedStairs);
}
};
yield return(setStairs);
yield return(Toils_Goto.GotoThing(TargetIndex.C, PathEndMode.OnCell));
Toil useStairs = Toils_General.Wait(60, 0);
ToilEffects.WithProgressBarToilDelay(useStairs, TargetIndex.C, false, -0.5f);
ToilFailConditions.FailOnDespawnedNullOrForbidden <Toil>(useStairs, TargetIndex.C);
//ToilFailConditions.FailOnCannotTouch<Toil>(useStairs, TargetIndex.C, PathEndMode.OnCell);
yield return(useStairs);
yield return(new Toil
{
initAction = delegate()
{
var ZTracker = Current.Game.GetComponent <ZLevelsManager>();
if (selectedStairs is Building_StairsUp stairsUp)
{
Map map = ZTracker.GetUpperLevel(pawn.Map.Tile, pawn.Map);
if (map == null)
{
map = ZTracker.CreateUpperLevel(pawn.Map, stairsUp.Position);
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, false, true);
}
else
{
if (stairsUp.pathToPreset != null && stairsUp.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsUp.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, false, stairsUp.shouldSpawnStairsUpper);
stairsUp.shouldSpawnStairsUpper = false;
}
}
else if (selectedStairs is Building_StairsDown stairsDown)
{
Map map = ZTracker.GetLowerLevel(pawn.Map.Tile, pawn.Map);
if (map == null)
{
map = ZTracker.CreateLowerLevel(pawn.Map, stairsDown.Position);
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, true, true);
}
else
{
if (stairsDown.pathToPreset != null && stairsDown.pathToPreset.Length > 0)
{
var comp = map.GetComponent <MapComponentZLevel>();
comp.DoGeneration = true;
comp.path = stairsDown.pathToPreset;
}
ZTracker.TeleportPawn(pawn, pawn.Position, map, false, stairsDown.shouldSpawnStairsBelow);
stairsDown.shouldSpawnStairsBelow = false;
}
}
if (pawn.Map != thing.Map)
{
instance.JumpToToil(setStairs);
}
}
});
