protected override IEnumerable <Toil> MakeNewToils()
{
ticks_left = (int)(2500.0f * Rand.Range(0.20f, 0.70f));
this.FailOnDespawnedOrNull(ibed);
this.KeepLyingDown(ibed);
yield return(Toils_Bed.ClaimBedIfNonMedical(ibed, TargetIndex.None));
yield return(Toils_Bed.GotoBed(ibed));
Toil do_fappin = Toils_LayDown.LayDown(ibed, true, false, false, false);
do_fappin.AddPreTickAction(delegate
{
--this.ticks_left;
if (this.ticks_left <= 0)
{
this.ReadyForNextToil();
}
else if (pawn.IsHashIntervalTick(ticks_between_hearts))
{
MoteMaker.ThrowMetaIcon(pawn.Position, pawn.Map, ThingDefOf.Mote_Heart);
}
});
do_fappin.AddFinishAction(delegate
{
pawn.mindState.canLovinTick = Find.TickManager.TicksGame + generate_min_ticks_to_next_fappin(pawn);
xxx.satisfy(pawn, null);
});
do_fappin.socialMode = RandomSocialMode.Off;
yield return(do_fappin);
}
protected override IEnumerable <Toil> MakeNewToils()
{
//Check si TargetIndex.A est un Bed si oui alors juste un Toil_Bed.GotoBed suivant d'un LayDownCustomFood
if (this.TargetThingA is Building_Bed)
{
Building_Bed pod = (Building_Bed)this.TargetThingA;
yield return(Toils_Bed.GotoBed(TargetIndex.A));
//yield return Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell);
yield return(Toils_LayDownPower.LayDown(TargetIndex.A, true, false, false, true));
}
else
{
Toil gotoCell = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell);
Toil nothing = new Toil();
yield return(gotoCell);
Toil setSkin = new Toil();
setSkin.initAction = delegate
{
pawn.Rotation = Rot4.South;
};
yield return(setSkin);
yield return(nothing);
yield return(Toils_General.Wait(50));
yield return(Toils_Jump.JumpIf(nothing, () => this.pawn.needs.food.CurLevelPercentage < 1.0f &&
!this.job.targetB.ThingDestroyed && !((Building)this.job.targetB).IsBrokenDown() &&
((Building)this.job.targetB).TryGetComp <CompPowerTrader>().PowerOn));
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
if (TargetThingA is Building_Bed)
{
yield return(Toils_Bed.GotoBed(TargetIndex.A));
yield return(Toils_LayDownPower.LayDown(TargetIndex.A, true, false, false));
}
else
{
var gotoCell = Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell);
var nothing = new Toil();
yield return(gotoCell);
var setSkin = new Toil {
initAction = delegate { pawn.Rotation = Rot4.South; }
};
yield return(setSkin);
yield return(nothing);
yield return(Toils_General.Wait(50));
yield return(Toils_Jump.JumpIf(nothing, () => pawn.needs.food.CurLevelPercentage < 1.0f &&
!job.targetB.ThingDestroyed && !((Building)job.targetB).IsBrokenDown() &&
((Building)job.targetB).TryGetComp <CompPowerTrader>().PowerOn));
}
}
protected override IEnumerable <Toil> MakeNewToils()
{
//Fail Checks
this.EndOnDespawnedOrNull(TargetIndex.A, JobCondition.Incompletable); //If we don't exist, exit.
if (job.targetA.Thing is Building_Radio)
{
report = "Listening to the radio.";
}
//yield return Toils_Reserve.Reserve(TargetIndex.A, base.CurJob.def.joyMaxParticipants); //Can we reserve?
//yield return Toils_Reserve.Reserve(TargetIndex.B, 1); //Reserve
var flag = base.TargetC.HasThing && base.TargetC.Thing is Building_Bed;
Toil toil;
if (flag) //If we have a bed, do something else.
{
this.KeepLyingDown(TargetIndex.C);
yield return(Toils_Reserve.Reserve(TargetIndex.C, ((Building_Bed)base.TargetC.Thing).SleepingSlotsCount));
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.C, TargetIndex.None));
yield return(Toils_Bed.GotoBed(TargetIndex.C));
toil = Toils_LayDown.LayDown(TargetIndex.C, true, false, true, true);
toil.AddFailCondition(() => !pawn.Awake());
}
else
{
if (base.TargetC.HasThing)
{
yield return(Toils_Reserve.Reserve(TargetIndex.C, 1));
}
yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.OnCell));
toil = new Toil();
}
toil.AddPreTickAction(delegate
{
if (job.targetA.Thing is Building_Radio)
{
report = "Listening to the radio.";
}
ListenTickAction();
});
toil.AddFinishAction(delegate
{
JoyUtility.TryGainRecRoomThought(pawn);
});
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = base.job.def.joyDuration * 2;
yield return(toil);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
// Claim bed if possible.
if (this.job.GetTarget(TargetIndex.A).HasThing)
{
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.A, TargetIndex.None));
}
Toil toil = new Toil
{
defaultCompleteMode = ToilCompleteMode.Never,
actor = pawn,
// ...
initAction =
delegate
{
// Check if our pawn is even in the bed.
if (!TargetA.Thing.OccupiedRect().Contains(pawn.Position))
{ // Nope.
base.ReadyForNextToil();
}
// Set our posture to laying in bed so we aren't downed.
pawn.jobs.posture = PawnPosture.LayingInBed;
this.asleep = false;
},
// ...
tickAction =
delegate
{
// If the pawn is in bed spawn a healing mote.
#region Original RW Code
if (pawn.IsHashIntervalTick(100) && !pawn.Position.Fogged(pawn.Map))
{
if (pawn.health.hediffSet.GetNaturallyHealingInjuredParts().Any <BodyPartRecord>())
{
MoteMaker.ThrowMetaIcon(pawn.Position, pawn.Map, ThingDefOf.Mote_HealingCross);
}
}
#endregion Original RW Code
}
};
toil.FailOnBedNoLongerUsable(TargetIndex.A);
yield return(toil);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
//this.AddFinishAction(new Action(delegate { Log.Message("finish action called for job!"); }));
this.FailOnDespawnedOrNull(TargetIndex.A);
if (RestingPlace is Building_BaseMechanoidPlatform)
{
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.A));
yield return(GoToPlatform(TargetIndex.A));
}
//goToPlatform.AddPreInitAction(new Action(delegate { Log.Message("first toil pre-initaction"); }));
Toil toil = new Toil();
toil.defaultCompleteMode = ToilCompleteMode.Never;
toil.initAction = delegate
{
if ((pawn.health.hediffSet.HasNaturallyHealingInjury() || pawn.OnHackingTable()))
{
pawn.jobs.posture = PawnPosture.LayingInBed;
}
this.job.expiryInterval = 50;
this.job.checkOverrideOnExpire = true;
pawn.ClearAllReservations();
pawn.Position = RestingPlace.GetSleepingSlotPos(RestingPlace is Building_HackingTable ? Building_HackingTable.SLOTINDEX : Building_BaseMechanoidPlatform.SLOTINDEX);
};
toil.tickAction = delegate
{
if (RestingPlace is Building_BaseMechanoidPlatform && pawn.ownership.OwnedBed != RestingPlace)
{
ReadyForNextToil();
}
if (RestingPlace.TryGetComp <CompAssignableToPawn_Bed>() is CompAssignableToPawn_Bed compAssignable && compAssignable.AssignedPawns.FirstOrDefault((Pawn p) => p != pawn) is Pawn otherPawn)
{
pawn.ownership.UnclaimBed();
ReadyForNextToil();
}
if (pawn.health.hediffSet.HasNaturallyHealingInjury() || pawn.OnHackingTable())
{
pawn.jobs.posture = PawnPosture.LayingInBed;
}
else
{
pawn.jobs.posture = PawnPosture.Standing;
RotateToSouth();
}
};
yield return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
// Faster fapping when frustrated.
//Rand.PopState();
//Rand.PushState(RJW_Multiplayer.PredictableSeed());
ticks_left = (int)(xxx.need_some_sex(pawn) > 2f ? 2500.0f * Rand.Range(0.2f, 0.7f) : 2500.0f * Rand.Range(0.2f, 0.4f));
this.FailOnDespawnedOrNull(ibed);
this.FailOn(() => pawn.Drafted);
this.KeepLyingDown(ibed);
yield return(Toils_Bed.ClaimBedIfNonMedical(ibed));
yield return(Toils_Bed.GotoBed(ibed));
Toil do_fappin = Toils_LayDown.LayDown(ibed, true, false, false, false);
do_fappin.AddPreTickAction(delegate
{
--ticks_left;
xxx.reduce_rest(pawn, 1);
if (ticks_left <= 0)
{
ReadyForNextToil();
}
else if (pawn.IsHashIntervalTick(ticks_between_hearts))
{
MoteMaker.ThrowMetaIcon(pawn.Position, pawn.Map, ThingDefOf.Mote_Heart);
}
});
do_fappin.AddFinishAction(delegate
{
//Moved satisfy and tick increase to aftersex, since it works with solo acts now.
SexUtility.Aftersex(pawn, xxx.rjwSextype.Masturbation);
if (SexUtility.ConsiderCleaning(pawn))
{
LocalTargetInfo own_cum = pawn.PositionHeld.GetFirstThing <Filth>(pawn.Map);
Job clean = new Job(JobDefOf.Clean);
clean.AddQueuedTarget(TargetIndex.A, own_cum);
pawn.jobs.jobQueue.EnqueueFirst(clean);
}
});
do_fappin.socialMode = RandomSocialMode.Off;
yield return(do_fappin);
}
protected override IEnumerable <Toil> MakeNewToils()
{
var hasBed = job.GetTarget(TargetIndex.A).HasThing;
if (hasBed)
{
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.A));
yield return(Toils_Bed.GotoBed(TargetIndex.A));
}
else
{
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell));
}
yield return(Toils_BrrrLayDown.BrrrLayDown(TargetIndex.A, hasBed));
}
protected override IEnumerable <Toil> MakeNewToils()
{
Toil relax;
if (this.FromBed)
{
this.KeepLyingDown(TargetIndex.A);
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.A, TargetIndex.None));
yield return(Toils_Bed.GotoBed(TargetIndex.A));
relax = Toils_LayDown.LayDown(TargetIndex.A, true, false, true, true);
relax.AddFailCondition(() => !this.pawn.Awake());
}
else
{
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell));
relax = new Toil();
relax.initAction = delegate
{
this.faceDir = ((!this.job.def.faceDir.IsValid) ? Rot4.Random : this.job.def.faceDir);
};
relax.handlingFacing = true;
}
relax.defaultCompleteMode = ToilCompleteMode.Delay;
relax.defaultDuration = this.job.def.joyDuration;
relax.AddPreTickAction(delegate
{
if (this.faceDir.IsValid)
{
this.pawn.rotationTracker.FaceCell(this.pawn.Position + this.faceDir.FacingCell);
}
this.pawn.GainComfortFromCellIfPossible();
JoyUtility.JoyTickCheckEnd(this.pawn, JoyTickFullJoyAction.EndJob, 1f, null);
PrayUtility.TickCheckEnd(pawn);
});
yield return(relax);
this.AddFinishAction(() =>
{
ReligionProperty property = pawn.GetReligionComponent().Religion.GetSettings <ReligionSettings_Prayings>(SettingsTagDefOf.PrayingsTag).Property;
PietyUtility.TryApplyOnPawn(property.Subject, pawn);
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
bool hasBed = this.job.GetTarget(TargetIndex.A).HasThing;
if (hasBed)
{
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.A, TargetIndex.None));
yield return(Toils_Bed.GotoBed(TargetIndex.A));
}
else
{
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell));
}
yield return(Toil_HypothermiaResponse.LayDown(TargetIndex.A, hasBed, false, true, true));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.A);
Toil goToPlatform = Toils_Bed.GotoBed(TargetIndex.A);
yield return(goToPlatform);
Toil layDownToil = Toils_LayDown.LayDown(TargetIndex.A, true, false, false, false);
layDownToil.defaultCompleteMode = ToilCompleteMode.Never;
layDownToil.initAction = new Action(delegate {
pawn.ClearAllReservations();
});
layDownToil.AddPreTickAction(delegate
{
if (!(pawn.health.hediffSet.HasNaturallyHealingInjury() || (pawn.OnHackingTable() && HealthAIUtility.ShouldHaveSurgeryDoneNow(pawn))))
{
ReadyForNextToil();
}
if (pawn.jobs.posture == PawnPosture.Standing)
{
RotateToSouth();
}
});
yield return(layDownToil);
Toil toil = new Toil();
toil.defaultCompleteMode = ToilCompleteMode.Never;
toil.initAction = delegate
{
pawn.jobs.posture = PawnPosture.Standing;
pawn.Position = RestingPlace.GetSleepingSlotPos(RestingPlace is Building_HackingTable ? Building_HackingTable.SLOTINDEX : Building_BaseMechanoidPlatform.SLOTINDEX);
RotateToSouth();
};
yield return(toil);
}
// A: TargetThing
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.A, TargetIndex.None));
yield return(Toils_Bed.GotoBed(TargetIndex.A));
this.goalNeedRest = napRestRate + (1 - napRestRate) * pawn.needs.rest.CurLevelPercentage;
Toil nap = new Toil();
nap.defaultCompleteMode = ToilCompleteMode.Never;
nap.FailOnBedNoLongerUsable(TargetIndex.A);
nap.socialMode = RandomSocialMode.Off;
nap.initAction = () =>
{
pawn.pather.StopDead();
if (!Bed.OccupiedRect().Contains(pawn.Position))
{
Log.Error("Can't start LayDown toil because pawn is not in the bed. pawn=" + pawn, false);
pawn.jobs.EndCurrentJob(JobCondition.Errored, true);
return;
}
pawn.jobs.posture = PawnPosture.LayingInBed;
this.asleep = false;
if (pawn.mindState.applyBedThoughtsTick == 0)
{
pawn.mindState.applyBedThoughtsTick = Find.TickManager.TicksGame + Rand.Range(2500, 10000);
pawn.mindState.applyBedThoughtsOnLeave = false;
}
if (pawn.ownership != null && pawn.CurrentBed() != pawn.ownership.OwnedBed)
{
ThoughtUtility.RemovePositiveBedroomThoughts(pawn);
}
};
nap.tickAction = () =>
{
pawn.GainComfortFromCellIfPossible();
if (!this.asleep)
{
if (pawn.needs.rest != null && pawn.needs.rest.CurLevel < RestUtility.FallAsleepMaxLevel(pawn))
{
this.asleep = true;
}
}
else if (pawn.needs.rest == null || pawn.needs.rest.CurLevelPercentage >= this.goalNeedRest)
{
this.asleep = false;
}
if (this.asleep && pawn.needs.rest != null)
{
float restEffectiveness;
if (Bed != null && Bed.def.statBases.StatListContains(StatDefOf.BedRestEffectiveness))
{
restEffectiveness = Bed.GetStatValue(StatDefOf.BedRestEffectiveness, true);
}
else
{
restEffectiveness = 0.8f;
}
pawn.needs.rest.TickResting(restEffectiveness);
}
if (pawn.mindState.applyBedThoughtsTick != 0 && pawn.mindState.applyBedThoughtsTick <= Find.TickManager.TicksGame)
{
ApplyBedThoughts(pawn);
pawn.mindState.applyBedThoughtsTick += 60000;
pawn.mindState.applyBedThoughtsOnLeave = true;
}
if (pawn.IsHashIntervalTick(100) && !pawn.Position.Fogged(pawn.Map))
{
if (this.asleep)
{
FleckMaker.ThrowMetaIcon(pawn.Position, pawn.Map, FleckDefOf.SleepZ);
}
if (pawn.health.hediffSet.GetNaturallyHealingInjuredParts().Any <BodyPartRecord>())
{
FleckMaker.ThrowMetaIcon(pawn.Position, pawn.Map, FleckDefOf.HealingCross);
}
}
if (pawn.ownership != null && Bed != null && !Bed.Medical && !Bed.OwnersForReading.Contains(pawn))
{
if (pawn.Downed)
{
pawn.Position = CellFinder.RandomClosewalkCellNear(pawn.Position, pawn.Map, 1, null);
}
pawn.jobs.EndCurrentJob(JobCondition.Incompletable, true);
return;
}
if (pawn.IsHashIntervalTick(211))
{
pawn.jobs.CheckForJobOverride();
return;
}
};
nap.AddFinishAction(() =>
{
if (pawn.mindState.applyBedThoughtsOnLeave)
{
ApplyBedThoughts(pawn);
}
this.asleep = false;
});
yield return(nap);
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnAggroMentalStateAndHostile(TargetIndex.A);
this.FailOn(delegate
{
if (job.def.makeTargetPrisoner)
{
if (!DropBed.ForPrisoners)
{
return(true);
}
}
else if (DropBed.ForPrisoners != Takee.IsPrisoner)
{
return(true);
}
return(false);
});
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.B, TargetIndex.A));
base.AddFinishAction(delegate
{
if (job.def.makeTargetPrisoner && Takee.ownership.OwnedBed == DropBed && Takee.Position != RestUtility.GetBedSleepingSlotPosFor(Takee, DropBed))
{
Takee.ownership.UnclaimBed();
}
});
yield return(Toils_Goto.GotoThing(
TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOn(() =>
job.def == JobDefOf.Arrest && Takee.CanBeArrestedBy(pawn)).FailOn(() =>
pawn.CanReach(DropBed, PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn)).FailOn(() => job.def == JobDefOf.Rescue && !Takee.Downed).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(new Toil
{
initAction = delegate
{
if (job.def.makeTargetPrisoner)
{
Pawn pawn = (Pawn)job.targetA.Thing;
Lord lord = pawn.GetLord();
if (lord != null)
{
lord.Notify_PawnAttemptArrested(pawn);
}
GenClamor.DoClamor(pawn, 10f, ClamorDefOf.Harm);
if (job.def == JobDefOf.Arrest && !pawn.CheckAcceptArrest(pawn))
{
pawn.jobs.EndCurrentJob(JobCondition.Incompletable, true);
}
}
}
});
Toil startCarrying = Toils_Haul.StartCarryThing(TargetIndex.A, false, false, false).FailOnNonMedicalBedNotOwned(TargetIndex.B, TargetIndex.A);
startCarrying.AddPreInitAction(new Action(CheckMakeTakeeGuest));
yield return(startCarrying);
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch));
yield return(new Toil
{
initAction = delegate
{
CheckMakeTakeePrisoner();
if (Takee.playerSettings == null)
{
Takee.playerSettings = new Pawn_PlayerSettings(Takee);
}
}
});
yield return(Toils_Reserve.Release(TargetIndex.B));
yield return(new Toil
{
initAction = delegate
{
IntVec3 position = DropBed.Position;
Thing thing;
pawn.carryTracker.TryDropCarriedThing(position, ThingPlaceMode.Direct, out thing, null);
//if (!DropBed.Destroyed && (DropBed.owners.Contains(Takee) || (DropBed.Medical && DropBed.AnyUnoccupiedSleepingSlot) || Takee.ownership == null))
if (!DropBed.Destroyed && (DropBed.OwnersForReading.Contains(Takee) || (DropBed.Medical && DropBed.AnyUnoccupiedSleepingSlot) || Takee.ownership == null))
{
Takee.jobs.Notify_TuckedIntoBed(DropBed);
if (Takee.RaceProps.Humanlike && job.def != JobDefOf.Arrest && !Takee.IsPrisonerOfColony)
{
Takee.relations.Notify_RescuedBy(pawn);
}
Takee.mindState.Notify_TuckedIntoBed();
}
if (Takee.IsPrisonerOfColony)
{
LessonAutoActivator.TeachOpportunity(ConceptDefOf.PrisonerTab, Takee, OpportunityType.GoodToKnow);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
this.FailOnAggroMentalState(TargetIndex.A);
if (base.CurJob.def == JobDefOf.Rescue)
{
this.FailOnNotDowned(TargetIndex.A);
}
this.FailOn(delegate
{
if (this.CurJob.def.makeTargetPrisoner)
{
if (!this.DropBed.ForPrisoners)
{
return(true);
}
}
else if (this.DropBed.ForPrisoners != ((Pawn)((Thing)this.TargetA)).IsPrisoner)
{
return(true);
}
return(false);
});
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Reserve.Reserve(TargetIndex.B, this.DropBed.SleepingSlotsCount));
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.B, TargetIndex.A));
this.globalFinishActions.Add(delegate
{
if (this.CurJob.def.makeTargetPrisoner && this.Takee.ownership.OwnedBed == this.DropBed && this.Takee.Position != RestUtility.GetBedSleepingSlotPosFor(this.Takee, this.DropBed))
{
this.Takee.ownership.UnclaimBed();
}
});
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnDespawnedNullOrForbidden(TargetIndex.B).FailOnNonMedicalBedNotOwned(TargetIndex.B, TargetIndex.A).FailOn(() => this.CurJob.def == JobDefOf.Arrest && !this.Takee.CanBeArrested()).FailOn(() => !this.pawn.CanReach(this.DropBed, PathEndMode.OnCell, Danger.Deadly, false, TraverseMode.ByPawn)).FailOnSomeonePhysicallyInteracting(TargetIndex.A));
yield return(new Toil
{
initAction = delegate
{
if (this.CurJob.def.makeTargetPrisoner)
{
Pawn pawn = (Pawn)this.CurJob.targetA.Thing;
Lord lord = pawn.GetLord();
if (lord != null)
{
lord.Notify_PawnAttemptArrested(pawn);
}
GenClamor.DoClamor(pawn, 10f, ClamorType.Harm);
if (Rand.Value < 0.1f)
{
Messages.Message("MessageRefusedArrest".Translate(new object[]
{
pawn.LabelShort
}), pawn, MessageSound.SeriousAlert);
pawn.mindState.mentalStateHandler.TryStartMentalState(MentalStateDefOf.Berserk, null, false, false, null);
IncidentWorker_Rebellion.removeLeadership(pawn);
pawn.needs.mood.thoughts.memories.TryGainMemory(ThoughtDef.Named("LeaderArrested"));
this.pawn.mindState.mentalStateHandler.CurState.RecoverFromState();
Find.LetterStack.ReceiveLetter("LeaderEndLetter".Translate(), "LeaderEndLetterDesc".Translate(new object[] { pawn.Name.ToStringFull }), LetterDefOf.BadNonUrgent, pawn, null);
this.pawn.jobs.EndCurrentJob(JobCondition.Incompletable, true);
}
}
}
});
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false));
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.Touch));
yield return(new Toil
{
initAction = delegate
{
if (this.CurJob.def.makeTargetPrisoner)
{
this.pawn.mindState.mentalStateHandler.CurState.RecoverFromState();
IncidentWorker_Rebellion.removeLeadership(this.Takee);
this.Takee.needs.mood.thoughts.memories.TryGainMemory(ThoughtDef.Named("LeaderArrested"));
Find.LetterStack.ReceiveLetter("LeaderEndLetterArrested".Translate(), "LeaderEndLetterDescArrested".Translate(new object[] { Takee.Name.ToStringFull }), LetterDefOf.BadNonUrgent, this.pawn, null);
foreach (Pawn p in IncidentWorker_LeaderElection.getAllColonists())
{
if (p != this.Takee)
{
p.needs.mood.thoughts.memories.TryGainMemory(ThoughtDef.Named("LeaderArrestedColonist"), null);
}
}
if (this.Takee.guest.released)
{
this.Takee.guest.released = false;
this.Takee.guest.interactionMode = PrisonerInteractionModeDefOf.NoInteraction;
}
if (!this.Takee.IsPrisonerOfColony)
{
if (this.Takee.Faction != null)
{
this.Takee.Faction.Notify_MemberCaptured(this.Takee, this.pawn.Faction);
}
this.Takee.guest.SetGuestStatus(Faction.OfPlayer, true);
if (this.Takee.guest.IsPrisoner)
{
TaleRecorder.RecordTale(TaleDefOf.Captured, new object[]
{
this.pawn,
this.Takee
});
this.pawn.records.Increment(RecordDefOf.PeopleCaptured);
}
}
}
else if (this.Takee.Faction != Faction.OfPlayer && this.Takee.HostFaction != Faction.OfPlayer && this.Takee.guest != null)
{
this.Takee.guest.SetGuestStatus(Faction.OfPlayer, false);
}
if (this.Takee.playerSettings == null)
{
this.Takee.playerSettings = new Pawn_PlayerSettings(this.Takee);
}
}
});
yield return(Toils_Reserve.Release(TargetIndex.B));
yield return(new Toil
{
initAction = delegate
{
IntVec3 position = this.DropBed.Position;
Thing thing;
this.pawn.carryTracker.TryDropCarriedThing(position, ThingPlaceMode.Direct, out thing, null);
if (!this.DropBed.Destroyed && (this.DropBed.owners.Contains(this.Takee) || (this.DropBed.Medical && this.DropBed.AnyUnoccupiedSleepingSlot) || this.Takee.ownership == null))
{
this.Takee.jobs.Notify_TuckedIntoBed(this.DropBed);
if (this.Takee.RaceProps.Humanlike && this.CurJob.def != JobDefOf.Arrest && !this.Takee.IsPrisonerOfColony)
{
this.Takee.relations.Notify_RescuedBy(this.pawn);
}
}
if (this.Takee.IsPrisonerOfColony)
{
LessonAutoActivator.TeachOpportunity(ConceptDefOf.PrisonerTab, this.Takee, OpportunityType.GoodToKnow);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
#if DEBUG
Verse.Log.Message(string.Format("MakeNewToils, HasChairOrBed={0}, IsInBed={1}", HasChairOrBed, IsInBed));
//Verse.Log.Message(String.Format("pawn.CurJob = {0}", pawn.CurJob == null ? "null" : pawn.CurJob.def.LabelCap ));
//Verse.Log.Message(String.Format("pawn.getPosture = {0}", pawn.GetPosture().ToString()));
//Verse.Log.Message(String.Format("current bed hashcode = {0}, target hashcode = {1}", pawn.CurrentBed() == null ? 0 : pawn.CurrentBed().GetHashCode(), HasChairOrBed ? ChairOrBed.GetHashCode() : 0));
#endif
this.EndOnDespawnedOrNull(MusicSpotParentInd);
//Verse.Log.Message(String.Format("Gather Spot ID = {0}", MusicSpotParent.GetHashCode()));
if (HasChairOrBed)
{
this.EndOnDespawnedOrNull(ChairOrSpotOrBedInd);
}
var listener = pawn;
var venue = MusicSpotParent;
if (!HasChairOrBed)
{
#if DEBUG
Verse.Log.Message("goto cell");
#endif
yield return(Toils_Goto.GotoCell(ChairOrSpotOrBedInd, PathEndMode.OnCell));
}
else if (!IsInBed)
{
#if DEBUG
Verse.Log.Message("goto chair");
#endif
yield return(Toils_Goto.GotoThing(ChairOrSpotOrBedInd, PathEndMode.OnCell));
}
else
{
#if DEBUG
Verse.Log.Message("goto bed");
#endif
yield return(Toils_Bed.ClaimBedIfNonMedical(ChairOrSpotOrBedInd));
yield return(Toils_Bed.GotoBed(ChairOrSpotOrBedInd));
}
// custom toil.
Toil listen;
if (IsInBed)
{
this.KeepLyingDown(ChairOrSpotOrBedInd);
listen = Toils_LayDown.LayDown(ChairOrSpotOrBedInd, true, false);
listen.AddFailCondition(() => !listen.actor.Awake());
}
else
{
listen = new Toil();
}
listen.tickAction = delegate
{
if (!HasChairOrBed)
{
pawn.rotationTracker.FaceCell(ClosestMusicSpotParentCell);
}
JoyUtility.JoyTickCheckEnd(listener, JoyTickFullJoyAction.GoToNextToil,
1f + Math.Abs(pawn.Map.GetComponent <PerformanceManager>().GetPerformanceQuality(venue)));
};
listen.handlingFacing = !HasChairOrBed;
listen.defaultCompleteMode = ToilCompleteMode.Delay;
listen.defaultDuration = job.def.joyDuration;
listen.AddEndCondition(() => pawn.Map.GetComponent <PerformanceManager>().HasPerformance(venue)
? JobCondition.Ongoing
: JobCondition.Incompletable);
listen.AddFinishAction(delegate { JoyUtility.TryGainRecRoomThought(pawn); });
listen.socialMode = RandomSocialMode.Quiet;
yield return(listen);
}
/// <summary>
/// Yields all steps of restraining a person.
/// </summary>
/// <returns></returns>
protected override IEnumerable <Toil> MakeNewToils()
{
Hediff restrainHediff = HediffMaker.MakeHediff(KnockItOffHediffDefOf.Restrain, JobTarget);
Hediff annoyedHediff = HediffMaker.MakeHediff(KnockItOffHediffDefOf.Annoyed, JobTarget);
SkillRecord meleeSkillRecordJT = JobTarget.skills.GetSkill(SkillDefOf.Melee);
SkillRecord meleeSkillRecordPawn = pawn.skills.GetSkill(SkillDefOf.Melee);
bool imprisonCheck = SkillDiffCheck(meleeSkillRecordJT, meleeSkillRecordPawn);
//If JobTarget is not violent, try to just talk him into calming down.
if (!imprisonCheck && !JobTarget.InAggroMentalState)
{
SkillRecord socialSkillRecordJT = JobTarget.skills.GetSkill(SkillDefOf.Social);
SkillRecord socialSkillRecordPawn = pawn.skills.GetSkill(SkillDefOf.Social);
imprisonCheck = SkillDiffCheck(socialSkillRecordJT, socialSkillRecordPawn);
}
// Stop the Job is the Pawn or Bed is destroyed or the Bed is no longer available for Prisoners.
this.FailOnDestroyedOrNull(JobTargetPawnIndex);
this.FailOnDestroyedOrNull(BedIndex);
this.FailOn(delegate
{
if (job.def.makeTargetPrisoner)
{
if (!DropBed.ForPrisoners)
{
return(true);
}
}
return(false);
});
yield return(Toils_Bed.ClaimBedIfNonMedical(BedIndex, JobTargetPawnIndex));
//Un-claim bed once toils are done
AddFinishAction(delegate
{
if (job.def.makeTargetPrisoner &&
JobTarget.Position != RestUtility.GetBedSleepingSlotPosFor(JobTarget, DropBed))
{
JobTarget.ownership.UnclaimBed();
}
});
//Goto berserk pawn
Toil gotoTakee = new Toil
{
initAction = delegate { pawn.pather.StartPath(JobTarget, PathEndMode.Touch); },
defaultCompleteMode = ToilCompleteMode.PatherArrival
};
yield return(gotoTakee);
//Restrain pawn, by removing his ability to move or handle equipment.
//Also makes the pawn annoyed.
Toil toilSleep = new Toil
{
initAction = delegate
{
if (imprisonCheck)
{
Messages.Message($"Successfully restrained {JobTarget.Name}", MessageTypeDefOf.PositiveEvent);
JobTarget.health.AddHediff(restrainHediff, null, null);
JobTarget.health.AddHediff(annoyedHediff);
}
else
{
Messages.Message($"Failed to restrain {JobTarget.Name}", MessageTypeDefOf.NegativeEvent);
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced);
}
}
};
yield return(toilSleep);
//Imprison pawn
Toil toil = new Toil
{
initAction = delegate
{
if (imprisonCheck)
{
CheckedMakePrisoner();
}
}
};
yield return(toil);
//Haul & Carry pawn to prison cell
Toil toil2 = Toils_Haul.StartCarryThing(JobTargetPawnIndex).FailOnNonMedicalBedNotOwned(BedIndex, JobTargetPawnIndex);
yield return(toil2);
yield return(Toils_Goto.GotoThing(BedIndex, PathEndMode.Touch));
//Imprison pawn again (the first one sometimes fails)
Toil toil3 = new Toil
{
initAction = delegate
{
if (imprisonCheck)
{
CheckedMakePrisoner();
if (JobTarget.playerSettings == null)
{
JobTarget.playerSettings = new Pawn_PlayerSettings(JobTarget);
}
}
}
};
yield return(toil3);
yield return(Toils_Reserve.Release(BedIndex));
//Put Prisoner in bed & remove restrained
Toil toil4 = new Toil
{
initAction = delegate
{
if (imprisonCheck)
{
IntVec3 pIntVec3 = DropBed.Position;
pawn.carryTracker.TryDropCarriedThing(pIntVec3, ThingPlaceMode.Direct, out Thing _);
if (!DropBed.Destroyed && (DropBed.OwnersForReading.Contains(JobTarget) ||
DropBed.Medical && DropBed.AnyUnoccupiedSleepingSlot ||
JobTarget.ownership == null))
{
JobTarget.jobs.Notify_TuckedIntoBed(DropBed);
JobTarget.mindState.Notify_TuckedIntoBed();
}
if (JobTarget.IsPrisonerOfColony)
{
LessonAutoActivator.TeachOpportunity(ConceptDefOf.PrisonerTab, JobTarget,
OpportunityType.GoodToKnow);
}
JobTarget.health.RemoveHediff(restrainHediff);
}
},
//What should we do?
protected override IEnumerable <Toil> MakeNewToils()
{
//Check it out. Can we go there?
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
//Wait a minute, is this thing already playing?
if (!Gramophone.IsOn())
{
if (job.targetA.Thing is Building_Radio)
{
report = "playing the radio.";
}
// Toil 1:
// Reserve Target (TargetPack A is selected (It has the info where the target cell is))
yield return(Toils_Reserve.Reserve(TargetIndex.A));
// Toil 2:
// Go to the thing.
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
// Toil 3:
// Wind up the gramophone
var wind = new Toil
{
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = Duration
};
wind.WithProgressBarToilDelay(TargetIndex.A);
wind.PlaySustainerOrSound(job.targetA.Thing is Building_Radio
? DefDatabase <SoundDef> .GetNamed("Estate_RadioSeeking")
: DefDatabase <SoundDef> .GetNamed("Estate_GramophoneWindup"));
wind.initAction = delegate { Gramophone.StopMusic(); };
yield return(wind);
// Toil 4:
// Play music.
var toilPlayMusic = new Toil
{
defaultCompleteMode = ToilCompleteMode.Instant,
initAction = delegate { Gramophone.PlayMusic(pawn); }
};
yield return(toilPlayMusic);
}
Toil toil;
if (TargetC.HasThing && TargetC.Thing is Building_Bed bed) //If we have a bed, lie in bed to listen.
{
this.KeepLyingDown(TargetIndex.C);
yield return(Toils_Reserve.Reserve(TargetIndex.C, bed.SleepingSlotsCount));
yield return(Toils_Bed.ClaimBedIfNonMedical(TargetIndex.C));
yield return(Toils_Bed.GotoBed(TargetIndex.C));
toil = Toils_LayDown.LayDown(TargetIndex.C, true, false);
toil.AddFailCondition(() => !pawn.Awake());
}
else
{
if (TargetC.HasThing)
{
yield return(Toils_Reserve.Reserve(TargetIndex.C));
}
yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.OnCell));
toil = new Toil();
}
toil.AddPreTickAction(delegate
{
ListenTickAction();
if (job.targetA.Thing is Building_Radio)
{
report = "Listening to the radio.";
}
});
toil.AddFinishAction(delegate { JoyUtility.TryGainRecRoomThought(pawn); });
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = job.def.joyDuration;
yield return(toil);
}
