protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch));
Toil tFuel = new Toil();
tFuel.defaultCompleteMode = ToilCompleteMode.Instant;
tFuel.AddFailCondition(() => this.Casket.GetComp <CompRefuelable>().Fuel < 50f);
tFuel.AddFailCondition(() => !this.Casket.GetComp <CompPowerTrader>().PowerOn);
tFuel.initAction = delegate()
{
this.Casket.GetComp <CompRefuelable>().ConsumeFuel(25f);
};
yield return(tFuel);
Toil t2 = Toils_General.Wait(6000);
t2.AddFailCondition(() => !this.Casket.GetComp <CompPowerTrader>().PowerOn);
t2.initAction = delegate()
{
this.Casket.Map.weatherManager.TransitionTo(WeatherDef.Named("RainyThunderstorm"));
};
t2 = t2.WithProgressBar(TargetIndex.A, () => (6000f - (float)this.ticksLeftThisToil) / 6000f, false, -0.5f);
yield return(t2);
yield return(new Toil
{
defaultCompleteMode = ToilCompleteMode.Instant,
initAction = delegate()
{
GenExplosion.DoExplosion(this.Casket.Position, this.Casket.Map, 50f, DamageDefOf.EMP, this.Casket,
-1, -1f, SoundDefOf.EnergyShield_Broken, null, null, null, null, 0f, 1, false, null, 0f, 1);
this.Casket.GetComp <CompOsiris>().HealContained();
this.Casket.Map.weatherManager.TransitionTo(WeatherDef.Named("Rain"));
IncidentParms incidentParms = StorytellerUtility.DefaultParmsNow(IncidentCategoryDefOf.FactionArrival, this.Casket.Map);
incidentParms.forced = true;
incidentParms.target = this.Casket.Map;
QueuedIncident qi = new QueuedIncident(new FiringIncident(IncidentDef.Named("ShortCircuit"), null, incidentParms), Find.TickManager.TicksGame + 1);
Find.Storyteller.incidentQueue.Add(qi);
}
});
yield return(Toils_Reserve.Release(TargetIndex.A));
yield break;
}
// Token: 0x0600012B RID: 299 RVA: 0x0000C0A4 File Offset: 0x0000A4A4
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Reserve.Reserve((Verse.AI.TargetIndex) 1, 1, -1, null));
yield return(Toils_Reserve.Reserve((Verse.AI.TargetIndex) 2, 1, -1, null));
yield return(Toils_Goto.GotoThing((Verse.AI.TargetIndex) 1, (Verse.AI.PathEndMode) 3));
yield return(Toils_Haul.StartCarryThing((Verse.AI.TargetIndex) 1, false, false));
yield return(Toils_Haul.CarryHauledThingToCell((Verse.AI.TargetIndex) 2));
Toil t2 = Toils_General.Wait(1000);
t2.AddFailCondition(() => !this.Emitter.GetComp <CompPowerTrader>().PowerOn);
t2 = ToilEffects.WithProgressBar(t2, (Verse.AI.TargetIndex) 1, () => (1000f - (float)this.ticksLeftThisToil) / 1000f, false, -0.5f);
yield return(t2);
yield return(new Toil
{
defaultCompleteMode = (Verse.AI.ToilCompleteMode) 1,
initAction = delegate()
{
this.Emitter.GetComp <CompHoloEmitter>().Scan(this.Corpse);
}
});
yield return(Toils_Reserve.Release((Verse.AI.TargetIndex) 2));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.OnCell));
var gaze = new Toil
{
initAction = delegate { pawn.jobs.posture = PawnPosture.LayingOnGroundFaceUp; },
tickAction = delegate { BrrrGlobals.JoyTickOohCheckEnd(pawn); },
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = job.def.joyDuration
};
gaze.FailOn(() => pawn.Position.Roofed(pawn.Map));
gaze.AddFailCondition(delegate
{
var actor = gaze.actor;
var needs = actor.needs;
if (needs?.food == null)
{
return(false);
}
var needs2 = actor.needs;
var num = needs2 != null ? new float?(needs2.food.CurLevelPercentage) : null;
var percentageThreshHungry = actor.needs.food.PercentageThreshHungry;
if ((num.GetValueOrDefault() < percentageThreshHungry) & (num != null))
{
return(true);
}
return(false);
});
yield return(gaze);
}
public Toil TryImproveRelationship(Pawn recruiter, Pawn guest)
{
var toil = new Toil
{
initAction = () => {
if (!recruiter.ShouldImproveRelationship(guest))
{
return;
}
if (!recruiter.CanTalkTo(guest))
{
return;
}
InteractionDef intDef = DefDatabase <InteractionDef> .GetNamed("GuestDiplomacy");
recruiter.interactions.TryInteractWith(guest, intDef);
},
socialMode = RandomSocialMode.Off,
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = 350
};
toil.AddFailCondition(FailCondition);
return(toil);
}
public static Toil GotoPrisoner(Pawn pawn, Pawn talkee, PrisonerInteractionModeDef mode)
{
Toil toil = new Toil();
toil.initAction = delegate
{
pawn.pather.StartPath(talkee, PathEndMode.Touch);
};
toil.AddFailCondition(delegate
{
if (talkee.DestroyedOrNull())
{
return(true);
}
if (mode != PrisonerInteractionModeDefOf.Execution && !talkee.Awake())
{
return(true);
}
if (!talkee.IsPrisonerOfColony)
{
return(true);
}
return((talkee.guest == null || talkee.guest.interactionMode != mode) ? true : false);
});
toil.socialMode = RandomSocialMode.Off;
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Reserve.Reserve(TargetIndex.A, 4, 0, null));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil t2 = Toils_General.Wait(6000);
t2.AddFailCondition(() => this.Building.GetComp <CompWeatherSat>() == null);
t2 = t2.WithEffect(EffecterDefOf.Research, TargetIndex.A);
t2.tickAction = delegate()
{
float num = 0.0002f;
num *= 1f + 0.5f * (float)base.GetActor().story.traits.DegreeOfTrait(TraitDef.Named("PsychicSensitivity"));
CompWeatherSat comp = this.Building.GetComp <CompWeatherSat>();
if (comp != null)
{
comp.mana += num;
if (comp.mana < 0f)
{
comp.mana = 0f;
}
if (comp.mana > 100f)
{
comp.mana = 100f;
}
}
};
yield return(t2);
yield return(Toils_Reserve.Release(TargetIndex.A));
yield break;
}
public Toil TryRecruitGuest(Pawn recruiter, Pawn guest)
{
var toil = new Toil
{
initAction = () => {
if (!recruiter.ShouldRecruit(guest))
{
return;
}
if (!recruiter.CanTalkTo(guest))
{
return;
}
InteractionDef intDef = DefDatabase <InteractionDef> .GetNamed("CharmGuestAttempt");
recruiter.interactions.TryInteractWith(guest, intDef);
var success = guest.CheckRecruitingSuccessful(recruiter);
},
socialMode = RandomSocialMode.Off,
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = 350
};
toil.AddFailCondition(FailCondition);
return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch));
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, false));
yield return(Toils_Haul.CarryHauledThingToCell(TargetIndex.B));
Toil t2 = Toils_General.Wait(1000);
t2.AddFailCondition(() => !this.Emitter.GetComp <CompPowerTrader>().PowerOn);
t2 = t2.WithProgressBar(TargetIndex.A, () => (1000f - (float)this.ticksLeftThisToil) / 1000f, false, -0.5f);
yield return(t2);
yield return(new Toil
{
defaultCompleteMode = ToilCompleteMode.Instant,
initAction = delegate()
{
Pawn simPawn = this.MakeGeniusPawn();
this.Emitter.GetComp <CompHoloEmitter>().SimPawn = simPawn;
this.Emitter.GetComp <CompHoloEmitter>().SetUpPawn();
this.Disk.Destroy(DestroyMode.Vanish);
}
});
yield return(Toils_Reserve.Release(TargetIndex.B));
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
CompScanner scannerComp = job.targetA.Thing.TryGetComp <CompScanner>();
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOnBurningImmobile(TargetIndex.A);
this.FailOn(() => !scannerComp.CanUseNow);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell));
Toil work = new Toil();
work.tickAction = delegate
{
Pawn actor = work.actor;
_ = (Building)actor.CurJob.targetA.Thing;
scannerComp.Used(actor);
actor.skills.Learn(SkillDefOf.Intellectual, 0.035f);
actor.GainComfortFromCellIfPossible(chairsOnly: true);
};
work.PlaySustainerOrSound(scannerComp.Props.soundWorking);
work.AddFailCondition(() => !scannerComp.CanUseNow);
work.defaultCompleteMode = ToilCompleteMode.Never;
work.FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell);
work.activeSkill = () => SkillDefOf.Intellectual;
yield return(work);
}
protected override IEnumerable<Toil> MakeNewToils()
{
Building_DroidChargePad charger = (Building_DroidChargePad)TargetThingA;
Toil goToPad = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.OnCell);
goToPad.AddFailCondition(() => { return !charger.IsAvailable(pawn); });
yield return goToPad;
Droid droid = (Droid)this.pawn;
Toil charge = new Toil();
charge.initAction = () =>
{
if (charger.Position != droid.Position)
{
pawn.jobs.EndCurrentJob(JobCondition.Errored);
}
};
charge.defaultCompleteMode = ToilCompleteMode.Never;
charge.AddFailCondition(() =>
{ return !charger.IsAvailable(pawn); });
charge.AddEndCondition(() =>
{
if (!droid.DesiresCharge())
{
return JobCondition.Succeeded;
}
return JobCondition.Ongoing;
});
yield return charge;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnBurningImmobile(TargetIndex.B);
if (!forbiddenInitially)
{
this.FailOnForbidden(TargetIndex.A);
}
Toil reserveTargetA = Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null);
yield return(reserveTargetA);
Toil toilGoto = null;
toilGoto = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);
toilGoto.AddFailCondition(delegate
{
Pawn actor = toilGoto.actor;
Job curJob = actor.jobs.curJob;
if (curJob.haulMode == HaulMode.ToCellStorage)
{
Thing thing = curJob.GetTarget(TargetIndex.A).Thing;
IntVec3 cell = actor.jobs.curJob.GetTarget(TargetIndex.B).Cell;
if (!cell.IsValidStorageFor(Map, thing))
{
return(true);
}
}
return(false);
});
yield return(toilGoto);
yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true, false));
if (job.haulOpportunisticDuplicates)
{
yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveTargetA, TargetIndex.A, TargetIndex.B, false, null));
}
if (job.expiryInterval != -1)
{
yield return(CheckExpiry());
}
Insect insect = toilGoto.actor as Insect;
if (insect != null && insect.targetColonyFood)
{
yield return(ResetTargetColonyFoodFlag(insect));
}
Toil carryToCell = Toils_Haul.CarryHauledThingToCell(TargetIndex.B);
yield return(carryToCell);
yield return(Toils_Haul.PlaceHauledThingInCell(TargetIndex.B, carryToCell, true));
if (insect != null && insect.stealFood)
{
yield return(ResetStealFoodFlag(insect));
}
}
protected Toil Interact(Pawn talkee, InteractionDef intDef, int duration)
{
var toil = new Toil {
initAction = () => {
PawnUtility.ForceWait(talkee, duration, pawn);
TargetThingB = pawn;
MoteMaker.MakeInteractionBubble(pawn, talkee, intDef.interactionMote, intDef.Symbol);
},
socialMode = RandomSocialMode.Normal,
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = duration
};
toil.AddFailCondition(talkee.interactions.InteractedTooRecentlyToInteract);
toil.AddFailCondition(pawn.interactions.InteractedTooRecentlyToInteract);
return(toil.WithProgressBarToilDelay(TargetIndex.B));
}
public static Toil GotoGuest(Pawn pawn, Pawn talkee, Func<Pawn,bool> condition, bool mayBeSleeping = false)
{
var toil = new Toil
{
initAction = () => pawn.pather.StartPath(talkee, PathEndMode.Touch),
defaultCompleteMode = ToilCompleteMode.PatherArrival
};
toil.AddFailCondition(() => !GuestUtility.ViableGuestTarget(talkee, mayBeSleeping) || !condition(talkee));
return toil;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOn(() => PrisonerFoodReservation.isReserved(TargetA.Thing));
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, -1, null));
if (eatingFromInventory)
{
yield return(Toils_Misc.TakeItemFromInventoryToCarrier(pawn, TargetIndex.A));
}
else if (usingNutrientPasteDispenser)
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell)
.FailOnForbidden(TargetIndex.A));
yield return(Toils_Ingest.TakeMealFromDispenser(TargetIndex.A, pawn));
}
else
{
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch)
.FailOnForbidden(TargetIndex.A));
yield return(Toils_Ingest.PickupIngestible(TargetIndex.A, Deliveree));
}
var toil = new Toil();
toil.initAction = delegate
{
var actor = toil.actor;
var curJob = actor.jobs.curJob;
actor.pather.StartPath(curJob.targetC, PathEndMode.OnCell);
};
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
toil.FailOnDestroyedNullOrForbidden(TargetIndex.B);
toil.AddFailCondition(delegate
{
var pawn = (Pawn)toil.actor.jobs.curJob.targetB.Thing;
return(!pawn.IsPrisonerOfColony || !pawn.guest.CanBeBroughtFood);
});
yield return(toil);
yield return(new Toil
{
initAction = delegate
{
Thing thing;
pawn.carryTracker.TryDropCarriedThing(toil.actor.jobs.curJob.targetC.Cell, ThingPlaceMode.Direct,
out thing, null);
PrisonerFoodReservation.reserve(thing, (Pawn)toil.actor.jobs.curJob.targetB.Thing);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
public static Toil GotoGuest(Pawn pawn, Pawn talkee, bool mayBeSleeping = false)
{
var toil = new Toil
{
initAction = () => pawn.pather.StartPath(talkee, PathEndMode.Touch),
defaultCompleteMode = ToilCompleteMode.PatherArrival
};
toil.AddFailCondition(() => !GuestUtility.ViableGuestTarget(talkee, mayBeSleeping));
return(toil);
}
public static Toil GotoPawn(Pawn pawn, Pawn talkee, PrisonerInteractionMode mode)
{
Toil toil = new Toil();
toil.initAction = delegate
{
pawn.pather.StartPath(talkee, PathEndMode.Touch);
};
toil.AddFailCondition(() => talkee.Destroyed);
toil.socialMode = RandomSocialMode.Off;
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
return(toil);
}
private static Toil ReachTarget(Pawn target)
{
Toil toil = new Toil();
toil.AddFailCondition(() => target == null || target.Destroyed || target.Downed || !target.Spawned || target.Dead);
toil.socialMode = 0;
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
toil.initAction = delegate
{
toil.GetActor().pather.StartPath(target, PathEndMode.Touch);
};
return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.B);
if (eatingFromInventory)
{
yield return(Toils_Misc.TakeItemFromInventoryToCarrier(pawn, TargetIndex.A));
}
else if (usingNutrientPasteDispenser)
{
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell).FailOnForbidden(TargetIndex.A));
yield return(Toils_Ingest.TakeMealFromDispenser(TargetIndex.A, pawn));
}
else
{
yield return(Toils_Ingest.ReserveFoodFromStackForIngesting(TargetIndex.A, Deliveree));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnForbidden(TargetIndex.A));
yield return(Toils_Ingest.PickupIngestible(TargetIndex.A, Deliveree));
}
Toil toil = new Toil();
toil.initAction = delegate
{
Pawn actor = toil.actor;
Job curJob = actor.jobs.curJob;
actor.pather.StartPath(curJob.targetC, PathEndMode.OnCell);
};
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
toil.FailOnDestroyedNullOrForbidden(TargetIndex.B);
toil.AddFailCondition(delegate
{
Pawn pawn = (Pawn)toil.actor.jobs.curJob.targetB.Thing;
if (!pawn.IsPrisonerOfColony)
{
return(true);
}
return((!pawn.guest.CanBeBroughtFood) ? true : false);
});
yield return(toil);
Toil toil2 = new Toil();
toil2.initAction = delegate
{
pawn.carryTracker.TryDropCarriedThing(toil2.actor.jobs.curJob.targetC.Cell, ThingPlaceMode.Direct, out Thing _);
};
toil2.defaultCompleteMode = ToilCompleteMode.Instant;
yield return(toil2);
}
private Toil TalkToAnimal(Pawn animal)
{
Toil toil = new Toil();
toil.AddFailCondition(delegate { return(animal.CurJob.def != GUC_JobDefOf.Mounted); });
toil.initAction = delegate
{
Pawn actor = toil.GetActor();
actor.interactions.TryInteractWith(animal, InteractionDefOf.AnimalChat);
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = 150;
return(toil);
}
public override void DecorateWaitToil(Toil wait)
{
Pawn TargetOfAttention = TargetA.Thing as Pawn;
if (TargetOfAttention == null)
{
throw new Exception("Can't pay attention to a null value");
}
payAttentinoToID = TargetOfAttention.CurJob.GetUniqueLoadID();
base.DecorateWaitToil(wait);
wait.AddFailCondition(
delegate()
{
return(payAttentinoToID == null || payAttentinoToID != (TargetA.Thing as Pawn).CurJob.GetUniqueLoadID());
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedNullOrForbidden(TargetIndex.A);
ICharge chargee = (ICharge)pawn;
CompDroidCharger charger = job.GetTarget(TargetIndex.A).Thing.TryGetComp <CompDroidCharger>();
yield return(Toils_Reserve.Reserve(TargetIndex.A));
Toil goToPad = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
goToPad.AddFailCondition(() => { return(!charger.IsAvailable(chargee)); });
yield return(goToPad);
Toil charge = new Toil();
charge.initAction = () =>
{
if (charger.parent.InteractionCell != chargee.Parent.Position)
{
pawn.jobs.EndCurrentJob(JobCondition.Errored);
}
else
{
charger.BeginCharge(chargee);
chargee.ShouldUsePower = false;
}
};
charge.defaultCompleteMode = ToilCompleteMode.Never;
charge.AddFailCondition(() =>
{ return(!charger.IsAvailable(chargee)); });
charge.AddEndCondition(() =>
{
if (!chargee.DesiresCharge)
{
return(JobCondition.Succeeded);
}
return(JobCondition.Ongoing);
});
charge.AddFinishAction(() =>
{
charger.EndCharge();
chargee.ShouldUsePower = true;
});
yield return(charge);
}
public static Toil TryImproveRelationship(Pawn recruiter, Pawn talkee)
{
var toil = new Toil
{
initAction = () => {
if (!GuestUtility.ViableGuestTarget(talkee)) return;
if (!talkee.ImproveRelationship()) return;
if (talkee.Faction.ColonyGoodwill >= 100) return;
if (!recruiter.CanTalkTo(talkee)) return;
recruiter.talker.TryTalkTo(new SpeechMessage(), talkee);
},
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = 350,
finishActions = new List<Action> {() => { var success = TryGuestImproveRelationship(recruiter, talkee); }}
};
toil.AddFailCondition(() => !GuestUtility.ViableGuestTarget(talkee) || !talkee.ImproveRelationship());
return toil;
}
// Token: 0x06000091 RID: 145 RVA: 0x00005434 File Offset: 0x00003634
private static Toil AbuseTarget(Pawn target)
{
Toil toil = new Toil();
toil.AddFailCondition(() => target == null || target.Destroyed || target.Downed || !target.Spawned || target.Dead);
toil.socialMode = RandomSocialMode.Off;
toil.initAction = delegate()
{
Pawn actor = toil.GetActor();
if (Rand.Value < 0.3f)
{
actor.interactions.TryInteractWith(target, InteractionDefOf.Chitchat);
return;
}
actor.interactions.TryInteractWith(target, InteractionDefOf.DeepTalk);
};
return(toil);
}
private Toil TalkToAnimal(TargetIndex tameeInd)
{
Toil toil = new Toil();
toil.AddFailCondition(delegate { return(Mount.CurJob.def != GUC_JobDefOf.Mounted); });
//toil.AddFailCondition(delegate { return Mount.CurJob.targetA.Thing != pawn; });
toil.initAction = delegate
{
Pawn actor = toil.GetActor();
actor.interactions.TryInteractWith(Mount, InteractionDefOf.AnimalChat);
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = 150;
toil.AddFinishAction(delegate
{
FinishAction();
});
return(toil);
}
private static Toil FlirtWithTarget(Pawn target)
{
Toil toil = new Toil();
toil.AddFailCondition(() => target == null || target.Destroyed || target.Downed || !target.Spawned || target.Dead);
toil.socialMode = 0;
toil.initAction = delegate
{
Pawn actor = toil.GetActor();
if (actor.relations.DirectRelationExists(PawnRelationDefOf.Lover, target))
{
actor.interactions.TryInteractWith(target, InteractionDefOf.MarriageProposal);
}
else
{
actor.interactions.TryInteractWith(target, InteractionDefOf.RomanceAttempt);
}
};
return(toil);
}
private static Toil AbuseTarget(Pawn target)
{
Toil toil = new Toil();
toil.AddFailCondition(() => target == null || target.Destroyed || target.Downed || !target.Spawned || target.Dead);
toil.socialMode = 0;
toil.initAction = delegate
{
Pawn actor = toil.GetActor();
if (Rand.Value < 0.3f)
{
actor.interactions.TryInteractWith(target, InteractionDefOf.Insult);
}
else
{
actor.interactions.TryInteractWith(target, DefDatabase <InteractionDef> .GetNamed("Slight"));
}
};
return(toil);
}
// duplicated to make changes
public Toil CarryHauledThingToCell(TargetIndex squareIndex)
{
Toil toil = new Toil();
toil.initAction = delegate
{
IntVec3 cell = toil.actor.jobs.curJob.GetTarget(squareIndex).Cell;
toil.actor.pather.StartPath(cell, PathEndMode.ClosestTouch);
};
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
toil.AddFailCondition(delegate
{
Pawn actor = toil.actor;
IntVec3 cell = actor.jobs.curJob.GetTarget(squareIndex).Cell;
// call duplicated to make changes
return(actor.jobs.curJob.haulMode == HaulMode.ToCellStorage && !IsValidStorageFor(cell, actor.carrier.CarriedThing));
});
return(toil);
}
protected override IEnumerable<Toil> MakeNewToils()
{
ICharge chargee = (ICharge)this.pawn;
CompDroidCharger charger =TargetThingA.TryGetComp<CompDroidCharger>();
yield return Toils_Reserve.Reserve(TargetIndex.A);
Toil goToPad = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell);
goToPad.AddFailCondition(() => { return !charger.IsAvailable(chargee); });
yield return goToPad;
Toil charge = new Toil();
charge.initAction = () =>
{
if (charger.parent.InteractionCell != chargee.Parent.Position)
{
pawn.jobs.EndCurrentJob(JobCondition.Errored);
}
else
{
charger.BeginCharge(chargee);
chargee.ShouldUsePower = false;
}
};
charge.defaultCompleteMode = ToilCompleteMode.Never;
charge.AddFailCondition(() =>
{ return !charger.IsAvailable(chargee); });
charge.AddEndCondition(() =>
{
if (!chargee.DesiresCharge)
{
return JobCondition.Succeeded;
}
return JobCondition.Ongoing;
});
charge.AddFinishAction(() =>
{
charger.EndCharge();
chargee.ShouldUsePower = true;
});
yield return charge;
}
//Stop a hauling job if haulability gets toggled off
static void Postfix(JobDriver __instance)
{
if (__instance is JobDriver_HaulToCell)
{
List <Toil> toils =
(List <Toil>) typeof(JobDriver).InvokeMember("toils",
BindingFlags.GetField | BindingFlags.Instance | BindingFlags.NonPublic,
null, __instance, null);
Toil toilGoto = toils[1];
if (toilGoto.defaultCompleteMode != ToilCompleteMode.PatherArrival)
{
Log.Error("Trying to add fail condition on JobDriver_HaulToCell but "
+ toilGoto.ToString()
+ " doesn't appear to be a Goto Toil");
return;
}
toilGoto.AddFailCondition(delegate
{
Thing t = __instance.job.targetA.Thing;
return(!__instance.job.ignoreDesignations && !t.IsAHaulableSetToHaulable());
});
}
}
private Toil TalkToAnimal(TargetIndex tameeInd)
{
Toil toil = new Toil();
toil.AddFailCondition(delegate { return(Mount.CurJob.def != BM_JobDefOf.Mounted_BattleMount); });
toil.initAction = delegate
{
Pawn actor = toil.GetActor();
actor.interactions.TryInteractWith(Mount, InteractionDefOf.AnimalChat);
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = 150;
toil.AddFinishAction(delegate {
if (Mount.CurJob != null && Mount.CurJob.def == BM_JobDefOf.Mounted_BattleMount)
{
Pawn actor = toil.GetActor();
ExtendedPawnData pawnData = Base.Instance.GetExtendedDataStorage().GetExtendedDataFor(actor);
pawnData.mount = (Pawn)((Thing)actor.CurJob.GetTarget(tameeInd));
TextureUtility.setDrawOffset(pawnData);
}
});
return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
Building_DroidCharger building = (Building_DroidCharger)TargetThingA;
// Go to the charging pad, but stop trying if it isn't on or is taken.
Toil gotoToil = Toils_Goto.GotoThing(TargetIndex.A, PathMode.OnSquare);
gotoToil.AddFailCondition(() => {
return(!building.IsOnAndAvailable(pawn));
});
yield return(gotoToil);
// Charge until at least 99% full, or the charger is off or taken.
DroidPawn droid = (DroidPawn)this.pawn;
Toil chargeToil = new Toil();
chargeToil.initAction = () => {
if (building.Position != pawn.Position)
{
pawn.jobs.EndCurrentJob(JobCondition.Errored);
}
};
chargeToil.defaultCompleteMode = ToilCompleteMode.Never;
chargeToil.AddFailCondition(() => {
return(!building.IsOnAndAvailable(pawn));
});
chargeToil.AddEndCondition(() => {
if (droid.storedEnergy >= 0.99 * DroidPawn.storedEnergyMax)
{
return(JobCondition.Succeeded);
}
return(JobCondition.Ongoing);
});
yield return(chargeToil);
}
private Toil GotoPrisoner(Pawn pawn, Pawn talkee)
{
Toil toil = new Toil();
toil.initAction = delegate
{
pawn.pather.StartPath(talkee, PathEndMode.Touch);
};
toil.AddFailCondition(delegate
{
if (talkee.DestroyedOrNull())
{
return(true);
}
if (!talkee.IsPrisonerOfColony)
{
return(true);
}
return((talkee.guest == null) ? true : false);
});
toil.socialMode = RandomSocialMode.Off;
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
return(toil);
}
public static Toil TryRecruitGuest(Pawn recruiter, Pawn talkee)
{
var toil = new Toil
{
initAction = () => {
if (!GuestUtility.ViableGuestTarget(talkee)) return;
if (talkee.guest.interactionMode!=PrisonerInteractionMode.AttemptRecruit) return;
if (!recruiter.CanTalkTo(talkee)) return;
recruiter.talker.TryTalkTo(new SpeechMessage(), talkee);
talkee.jobs.StopAll();
},
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = 350,
finishActions = new List<Action> {() => { var success = TryGuestRecruit(recruiter, talkee); }}
};
toil.AddFailCondition(() => !GuestUtility.ViableGuestTarget(talkee) || !talkee.TryRecruit());
return toil;
}
protected override IEnumerable <Toil> MakeNewToils()
{
//Log.Message("[RJW]JobDriver_WhoreIsServingVisitors::MakeNewToils() - making toils");
this.FailOnDespawnedOrNull(PartnerInd);
this.FailOnDespawnedNullOrForbidden(BedInd);
//Log.Message("[RJW]JobDriver_WhoreIsServingVisitors::MakeNewToils() fail conditions check " + (Actor is null) + " " + !xxx.CanUse(Actor, Bed) + " " + !Actor.CanReserve(Partner));
this.FailOn(() => Actor is null || !xxx.CanUse(Actor, Bed) || !Actor.CanReserve(Partner));
this.FailOn(() => pawn.Drafted);
int price = WhoringHelper.PriceOfWhore(Actor);
yield return(Toils_Reserve.Reserve(PartnerInd, 1, 0));
//yield return Toils_Reserve.Reserve(BedInd, Bed.SleepingSlotsCount, 0);
bool partnerHasPenis = Genital_Helper.has_penis(Partner) || Genital_Helper.has_penis_infertile(Partner);
Toil gotoWhoreBed = new Toil
{
initAction = delegate
{
//Log.Message("[RJW]JobDriver_WhoreIsServingVisitors::MakeNewToils() - gotoWhoreBed initAction is called");
Actor.pather.StartPath(WhoreSleepSpot, PathEndMode.OnCell);
Partner.jobs.StopAll();
Partner.pather.StartPath(WhoreSleepSpot, PathEndMode.Touch);
},
tickAction = delegate
{
if (Partner.IsHashIntervalTick(150))
{
Partner.pather.StartPath(Actor, PathEndMode.Touch);
//Log.Message(xxx.get_pawnname(Partner) + ": I'm following the w***e");
}
},
defaultCompleteMode = ToilCompleteMode.PatherArrival
};
gotoWhoreBed.FailOnWhorebedNoLongerUsable(BedInd, Bed);
yield return(gotoWhoreBed);
Toil waitInBed = new Toil
{
initAction = delegate
{
//Rand.PopState();
//Rand.PushState(RJW_Multiplayer.PredictableSeed());
//Log.Message("JobDriver_WhoreIsServingVisitors::MakeNewToils() - waitInBed, initAction is called");
ticksLeftThisToil = 5000;
ticks_left = (int)(2000.0f * Rand.Range(0.30f, 1.30f));
//Actor.pather.StopDead(); //Let's just make w****s standing at the bed
//JobDriver curDriver = Actor.jobs.curDriver;
//curDriver.layingDown = LayingDownState.LayingInBed;
//curDriver.asleep = false;
var gettin_loved = new Job(xxx.gettin_loved, Actor, Bed);
Partner.jobs.StartJob(gettin_loved, JobCondition.InterruptForced);
},
tickAction = delegate
{
Actor.GainComfortFromCellIfPossible();
if (IsInOrByBed(Bed, Partner))
{
//Log.Message("JobDriver_WhoreIsServingVisitors::MakeNewToils() - waitInBed, tickAction pass");
ticksLeftThisToil = 0;
}
},
defaultCompleteMode = ToilCompleteMode.Delay,
};
waitInBed.FailOn(() => pawn.GetRoom() == null);
yield return(waitInBed);
bool canAfford = WhoringHelper.CanAfford(Partner, Actor, price);
if (canAfford)
{
Toil loveToil = new Toil
{
initAction = delegate
{
//Actor.jobs.curDriver.ticksLeftThisToil = 1200;
//Using ticks_left to control the time of sex
//--Log.Message("JobDriver_WhoreIsServingVisitors::MakeNewToils() - loveToil, setting initAction");
/*
* //Hoge: W***e is just work. no feel cheatedOnMe.
* if (xxx.HasNonPolyPartner(Actor))
* {
* Pawn pawn = LovePartnerRelationUtility.ExistingLovePartner(Actor);
* if (((Partner != pawn) && !pawn.Dead) && ((pawn.Map == Actor.Map) || (Rand.Value < 0.15)))
* {
* pawn.needs.mood.thoughts.memories.TryGainMemory(ThoughtDefOf.CheatedOnMe, Actor);
* }
* }
*/
if (xxx.HasNonPolyPartnerOnCurrentMap(Partner))
{
Pawn lover = LovePartnerRelationUtility.ExistingLovePartner(Partner);
//Rand.PopState();
//Rand.PushState(RJW_Multiplayer.PredictableSeed());
// We have to do a few other checks because the pawn might have multiple lovers and ExistingLovePartner() might return the wrong one
if (lover != null && Actor != lover && !lover.Dead && (lover.Map == Partner.Map || Rand.Value < 0.25))
{
lover.needs.mood.thoughts.memories.TryGainMemory(ThoughtDefOf.CheatedOnMe, Partner);
}
}
if (!partnerHasPenis)
{
Actor.rotationTracker.Face(Partner.DrawPos);
}
},
defaultCompleteMode = ToilCompleteMode.Never, //Changed from Delay
};
loveToil.AddPreTickAction(delegate
{
//Actor.Reserve(Partner, 1, 0);
--ticks_left;
xxx.reduce_rest(Partner);
xxx.reduce_rest(Actor, 2);
if (ticks_left <= 0)
{
ReadyForNextToil();
}
else if (pawn.IsHashIntervalTick(ticks_between_hearts))
{
MoteMaker.ThrowMetaIcon(Actor.Position, Actor.Map, ThingDefOf.Mote_Heart);
}
Actor.GainComfortFromCellIfPossible();
Partner.GainComfortFromCellIfPossible();
});
loveToil.AddFinishAction(delegate
{
//Log.Message("[RJW] JobDriver_WhoreIsServingVisitors::MakeNewToils() - finished loveToil");
//// Trying to add some interactions and social logs
//xxx.processAnalSex(Partner, Actor, ref isAnalSex, partnerHasPenis);
});
loveToil.AddFailCondition(() => Partner.Dead || !IsInOrByBed(Bed, Partner));
loveToil.socialMode = RandomSocialMode.Off;
yield return(loveToil);
Toil afterSex = new Toil
{
initAction = delegate
{
// Adding interactions, social logs, etc
SexUtility.ProcessSex(Actor, Partner, false, false, true);
//--Log.Message("JobDriver_WhoreIsServingVisitors::MakeNewToils() - Partner should pay the price now in afterSex.initAction");
int remainPrice = WhoringHelper.PayPriceToWhore(Partner, price, Actor);
/*if (remainPrice <= 0)
* {
* --Log.Message("JobDriver_WhoreIsServingVisitors::MakeNewToils() - Paying price is success");
* }
* else
* {
* --Log.Message("JobDriver_WhoreIsServingVisitors::MakeNewToils() - Paying price failed");
* }*/
xxx.UpdateRecords(Actor, price - remainPrice);
var thought = (Actor.IsPrisoner) ? thought_captive : thought_free;
pawn.needs.mood.thoughts.memories.TryGainMemory(thought);
if (SexUtility.ConsiderCleaning(pawn))
{
LocalTargetInfo cum = pawn.PositionHeld.GetFirstThing <Filth>(pawn.Map);
Job clean = new Job(JobDefOf.Clean);
clean.AddQueuedTarget(TargetIndex.A, cum);
pawn.jobs.jobQueue.EnqueueFirst(clean);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(afterSex);
}
}
protected override IEnumerable<Toil> MakeNewToils()
{
var foodThing = this.TargetThing( FoodInd );
var deliveree = (Pawn) this.TargetThing( DelivereeInd );
var dropCell = this.TargetCell( DeliverToInd );
yield return Toils_Reserve.Reserve( DelivereeInd, 1 );
if( foodThing is Building )
{
yield return Toils_Goto.GotoThing( FoodInd, PathEndMode.InteractionCell ).FailOnForbidden( FoodInd );
if( foodThing is Building_NutrientPasteDispenser )
{
yield return Toils_Ingest.TakeMealFromDispenser( FoodInd, this.pawn );
}
else if( foodThing is Building_AutomatedFactory )
{
yield return Toils_FoodSynthesizer.TakeMealFromSynthesizer( FoodInd, this.pawn );
}
else // Unknown building
{
throw new Exception( "Food target for JobDriver_FoodDeliver is a building but not Building_NutrientPasteDispenser or Building_AutomatedFactory!" );
}
}
else if(
( this.pawn.inventory != null )&&
( this.pawn.inventory.Contains( foodThing ) )
)
{
yield return Toils_Misc.TakeItemFromInventoryToCarrier( this.pawn, FoodInd );
}
else
{
yield return Toils_Reserve.Reserve( FoodInd, 1 );
yield return Toils_Goto.GotoThing( FoodInd, PathEndMode.ClosestTouch );
yield return Toils_Ingest.PickupIngestible( FoodInd, deliveree );
}
var pathToTarget = new Toil();
pathToTarget.defaultCompleteMode = ToilCompleteMode.PatherArrival;
pathToTarget.initAction = new Action( () =>
{
var pawn = this.pawn;
var job = pawn.jobs.curJob;
pawn.pather.StartPath( job.targetC, PathEndMode.OnCell );
}
);
pathToTarget.FailOnDestroyedNullOrForbidden( DelivereeInd );
pathToTarget.AddFailCondition( () =>
{
if( deliveree.Downed )
{
return false;
}
if( deliveree.IsPrisonerOfColony )
{
return !deliveree.guest.ShouldBeBroughtFood;
}
var compPrisoner = deliveree.TryGetComp<CompPrisoner>();
if( compPrisoner != null )
{
return !compPrisoner.wasArrested;
}
return false;
} );
yield return pathToTarget;
var dropFoodAtTarget = new Toil();
dropFoodAtTarget.initAction = new Action( () =>
{
Thing resultingThing;
this.pawn.carrier.TryDropCarriedThing( dropCell, ThingPlaceMode.Direct, out resultingThing );
}
);
dropFoodAtTarget.defaultCompleteMode = ToilCompleteMode.Instant;
yield return dropFoodAtTarget;
}
protected override IEnumerable <Toil> MakeNewToils()
{
setup_ticks();
this.FailOnDespawnedOrNull(iTarget);
this.FailOnDespawnedNullOrForbidden(iBed);
this.FailOn(() => !pawn.CanReserveAndReach(Partner, PathEndMode.Touch, Danger.Deadly));
this.FailOn(() => pawn.Drafted);
this.FailOn(() => Partner.IsFighting());
this.FailOn(() => !Partner.CanReach(pawn, PathEndMode.Touch, Danger.Deadly));
yield return(Toils_Reserve.Reserve(iTarget, 1, 0));
Toil gotoAnimal = Toils_Goto.GotoThing(iTarget, PathEndMode.Touch);
yield return(gotoAnimal);
Toil gotoBed = new Toil();
gotoBed.defaultCompleteMode = ToilCompleteMode.PatherArrival;
gotoBed.FailOnBedNoLongerUsable(iBed);
gotoBed.AddFailCondition(() => Partner.Downed);
gotoBed.initAction = delegate
{
pawn.pather.StartPath(SleepSpot, PathEndMode.OnCell);
Partner.jobs.StopAll();
Job job = JobMaker.MakeJob(JobDefOf.GotoMindControlled, SleepSpot);
Partner.jobs.StartJob(job, JobCondition.InterruptForced);
};
yield return(gotoBed);
Toil waitInBed = new Toil();
waitInBed.FailOn(() => pawn.GetRoom(RegionType.Set_Passable) == null);
waitInBed.defaultCompleteMode = ToilCompleteMode.Delay;
waitInBed.initAction = delegate
{
ticksLeftThisToil = 5000;
};
waitInBed.tickAction = delegate
{
pawn.GainComfortFromCellIfPossible();
if (IsInOrByBed(Bed, Partner) && pawn.PositionHeld == Partner.PositionHeld)
{
ReadyForNextToil();
}
};
yield return(waitInBed);
Toil StartPartnerJob = new Toil();
StartPartnerJob.defaultCompleteMode = ToilCompleteMode.Instant;
StartPartnerJob.socialMode = RandomSocialMode.Off;
StartPartnerJob.initAction = delegate
{
var gettin_loved = JobMaker.MakeJob(xxx.gettin_loved, pawn, Bed);
Partner.jobs.StartJob(gettin_loved, JobCondition.InterruptForced);
};
yield return(StartPartnerJob);
Toil loveToil = new Toil();
loveToil.AddFailCondition(() => Partner.Dead || !IsInOrByBed(Bed, Partner));
loveToil.socialMode = RandomSocialMode.Off;
loveToil.defaultCompleteMode = ToilCompleteMode.Never;
loveToil.handlingFacing = true;
loveToil.initAction = delegate
{
usedCondom = CondomUtility.TryUseCondom(pawn);
Start();
};
loveToil.AddPreTickAction(delegate
{
--ticks_left;
if (pawn.IsHashIntervalTick(ticks_between_hearts))
{
if (xxx.is_zoophile(pawn))
{
ThrowMetaIcon(pawn.Position, pawn.Map, ThingDefOf.Mote_Heart);
}
else
{
ThrowMetaIcon(pawn.Position, pawn.Map, xxx.mote_noheart);
}
}
SexTick(pawn, Partner);
SexUtility.reduce_rest(pawn, 1);
SexUtility.reduce_rest(Partner, 2);
if (ticks_left <= 0)
{
ReadyForNextToil();
}
});
loveToil.AddFinishAction(delegate
{
End();
});
yield return(loveToil);
Toil afterSex = new Toil
{
initAction = delegate
{
//Log.Message("JobDriver_BestialityForFemale::MakeNewToils() - Calling aftersex");
SexUtility.ProcessSex(Partner, pawn, usedCondom: usedCondom, sextype: sexType);
},
defaultCompleteMode = ToilCompleteMode.Instant
};
yield return(afterSex);
}
// duplicated to make changes
public Toil CarryHauledThingToCell(TargetIndex squareIndex)
{
Toil toil = new Toil();
toil.initAction = delegate
{
IntVec3 cell = toil.actor.jobs.curJob.GetTarget(squareIndex).Cell;
toil.actor.pather.StartPath(cell, PathEndMode.ClosestTouch);
};
toil.defaultCompleteMode = ToilCompleteMode.PatherArrival;
toil.AddFailCondition(delegate
{
Pawn actor = toil.actor;
IntVec3 cell = actor.jobs.curJob.GetTarget(squareIndex).Cell;
// call duplicated to make changes
return actor.jobs.curJob.haulMode == HaulMode.ToCellStorage && !IsValidStorageFor(cell, actor.carrier.CarriedThing);
});
return toil;
}
