private Toil Ignite(Thing target)
{
Toil toil = new Toil();
toil.initAction = delegate
{
Pawn feenix = pawn;
if (target.FlammableNow && !target.IsBurning())
{
if (target.CanEverAttachFire())
{
target.TryAttachFire(1f);
}
else
{
FireUtility.TryStartFireIn(target.Position, target.Map, 1f);
}
PawnUtility.ForceWait(feenix, 250, target);
}
else
{
return;
}
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = 250;
return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.A);
this.FailOnDowned(TargetIndex.A);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil prepare = new Toil();
prepare.initAction = delegate
{
PawnUtility.ForceWait(Victim, hugDuration, Victim);
};
prepare.defaultCompleteMode = ToilCompleteMode.Delay;
prepare.defaultDuration = hugDuration;
yield return(prepare);
yield return(new Toil
{
initAction = delegate
{
pawn.interactions.TryInteractWith(Victim, DefDatabase <InteractionDef> .GetNamed("HugFriend", true));
this.AddEndCondition(() => JobCondition.Succeeded);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.A));
Toil toil2 = new Toil();
toil2.defaultCompleteMode = ToilCompleteMode.Delay;
toil2.defaultDuration = 1000;
toil2.WithProgressBarToilDelay(TargetIndex.A, false, -0.5f);
toil2.initAction = delegate
{
PawnUtility.ForceWait((Pawn)TargetA.Thing, toil2.defaultDuration, this.pawn);
};
yield return(toil2);
yield return(new Toil
{
initAction = delegate
{
Apparel straitjacket = Takee.apparel.WornApparel.FirstOrDefault((Apparel x) => x.def == StraitjacketDefOf.ROM_Straitjacket);
Apparel straitjacketOut;
if (straitjacket != null)
{
Takee.apparel.TryDrop(straitjacket, out straitjacketOut, Takee.Position);
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.A);
this.FailOnDowned(TargetIndex.A);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil prepare = new Toil();
prepare.initAction = delegate
{
PawnUtility.ForceWait(Victim, disciplineDuration, Victim);
};
prepare.defaultCompleteMode = ToilCompleteMode.Delay;
prepare.defaultDuration = disciplineDuration;
yield return(prepare);
yield return(new Toil
{
initAction = delegate
{
int amount = Rand.Range(1, 2);
Victim.TakeDamage(new DamageInfo(DamageDefOf.Blunt, amount, -1f, GetActor(), GetRandomDisciplinePart(Victim), null));
this.AddEndCondition(() => JobCondition.Succeeded);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
public static Toil WaitWith(TargetIndex targetInd, int ticks, bool useProgressBar = false, bool maintainPosture = false)
{
Toil toil = new Toil();
toil.initAction = delegate
{
toil.actor.pather.StopDead();
Pawn pawn = toil.actor.CurJob.GetTarget(targetInd).Thing as Pawn;
if (pawn != null)
{
if (pawn == toil.actor)
{
Log.Warning("Executing WaitWith toil but otherPawn is the same as toil.actor", false);
}
else
{
Pawn pawn2 = pawn;
int ticks2 = ticks;
bool maintainPosture2 = maintainPosture;
PawnUtility.ForceWait(pawn2, ticks2, null, maintainPosture2);
}
}
};
toil.FailOnDespawnedOrNull(targetInd);
toil.FailOnCannotTouch(targetInd, PathEndMode.Touch);
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = ticks;
if (useProgressBar)
{
toil.WithProgressBarToilDelay(targetInd, false, -0.5f);
}
return(toil);
}
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);
PawnUtility.ForceWait(guest, 200, recruiter);
//guest.CheckRecruitingSuccessful(recruiter);
},
socialMode = RandomSocialMode.Off,
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = 350
};
toil.AddFailCondition(FailCondition);
return(toil);
}
//Base: Toils_General.WaitWith
private Toil Toils_WaitWithSoundAndEffect(int duration, string soundDefName, string effecterDefName, TargetIndex targetIndex)
{
Toil toil = new Toil();
toil.initAction = () =>
{
//toil.actor.pather.StopDead();
//toil.actor.Drawer.rotator.FaceCell(toil.actor.CurJob.GetTarget(targetIndex).Cell);
Pawn pawn = toil.actor.CurJob.GetTarget(targetIndex).Thing as Pawn;
if (pawn != null) // If target is a pawn force him to watch me
{
PawnUtility.ForceWait(pawn, duration, null, true);
}
};
toil.handlingFacing = true;
toil.FailOnDespawnedOrNull(targetIndex);
toil.FailOnCannotTouch(targetIndex, PathEndMode.Touch);
toil.defaultCompleteMode = ToilCompleteMode.Delay;
toil.defaultDuration = duration;
toil.WithProgressBarToilDelay(targetIndex, false, -0.5f);
toil.PlaySustainerOrSound(() => SoundDef.Named(soundDefName));
// Throws errors?
//toil.WithEffect(() => EffecterDef.Named(effecterDefName), targetIndex);
return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOnDowned(TargetIndex.A);
this.FailOnNotCasualInterruptible(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)this.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);
this.gatherProgress += actor.GetStatValue(StatDefOf.AnimalGatherSpeed, true);
if (this.gatherProgress >= this.WorkTotal)
{
this.GetSpecificComp((Pawn)((Thing)this.job.GetTarget(TargetIndex.A))).InformGathered(this.pawn);
actor.jobs.EndCurrentJob(JobCondition.Succeeded, true, true);
if (ModLister.HasActiveModWithName("Alpha Animals"))
{
actor.health.AddHediff(HediffDef.Named("AA_GatheredResource"));
}
}
};
wait.AddFinishAction(delegate
{
Pawn pawn = (Pawn)this.job.GetTarget(TargetIndex.A).Thing;
if (pawn != null && pawn.CurJobDef == JobDefOf.Wait_MaintainPosture)
{
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced, true, true);
}
});
wait.FailOnDespawnedOrNull(TargetIndex.A);
wait.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
wait.AddEndCondition(delegate
{
if (!this.GetComp((Pawn)((Thing)this.job.GetTarget(TargetIndex.A))).ActiveAndFull)
{
return(JobCondition.Incompletable);
}
return(JobCondition.Ongoing);
});
wait.defaultCompleteMode = ToilCompleteMode.Never;
wait.WithProgressBar(TargetIndex.A, () => this.gatherProgress / this.WorkTotal, false, -0.5f);
wait.activeSkill = (() => SkillDefOf.Animals);
yield return(wait);
yield break;
}
protected IEnumerable <Toil> MakeNewToils(HediffDef hediffDef)
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
//this.FailOnDowned(TargetIndex.A);
this.FailOnAggroMentalState(TargetIndex.A);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil wait = new Toil();
wait.initAction = delegate
{
Pawn actor2 = wait.actor;
Pawn pawn2 = (Pawn)job.GetTarget(TargetIndex.A).Thing;
actor2.pather.StopDead();
PawnUtility.ForceWait(pawn2, 15000, null, maintainPosture: true);
};
wait.tickAction = delegate
{
ticks++;
};
wait.AddFinishAction(delegate
{
Pawn pawn = (Pawn)job.GetTarget(TargetIndex.A).Thing;
if (pawn != null)
{
Hediff hediff = pawn.health.hediffSet.GetFirstHediffOfDef(hediffDef, false);
if (hediff == null)
{
hediff = HediffMaker.MakeHediff(hediffDef, pawn, null);
pawn.health.AddHediff(hediff, null, null);
}
else
{
pawn.health.hediffSet.hediffs.Remove(hediff);
}
if (pawn.CurJobDef == JobDefOf.Wait_MaintainPosture)
{
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced);
}
}
});
wait.FailOnDespawnedOrNull(TargetIndex.A);
wait.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
wait.AddEndCondition(() =>
{
if (ticks >= BGP.Unchain_Ticks)
{
return(JobCondition.Succeeded);
}
return(JobCondition.Ongoing);
}
);
wait.defaultCompleteMode = ToilCompleteMode.Never;
wait.WithProgressBar(TargetIndex.A, () => ticks / BGP.Unchain_Ticks);
yield return(wait);
}
// Token: 0x06000014 RID: 20 RVA: 0x000027CB File Offset: 0x000009CB
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOnDowned(TargetIndex.A);
this.FailOnNotCasualInterruptible(TargetIndex.A);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
var wait = new Toil();
wait.initAction = delegate
{
var actor = wait.actor;
var thing = (Pawn)wait.actor.CurJob.GetTarget(TargetIndex.A).Thing;
actor.pather.StopDead();
PawnUtility.ForceWait(thing, 15000, null, true);
};
wait.tickAction = delegate
{
var actor = wait.actor;
actor.skills.Learn(SkillDefOf.Social, 0.142999992f);
gatherProgress += actor.GetStatValue(StatDefOf.AnimalGatherSpeed);
if (!(gatherProgress >= WorkTotal))
{
return;
}
var thing = (Pawn)(Thing)job.GetTarget(TargetIndex.A);
thing.TryGetComp <CompWidowMilkableHumanoid>().GatherMilk(pawn);
actor.jobs.EndCurrentJob(JobCondition.Succeeded);
};
wait.AddFinishAction(delegate
{
var thing = (Pawn)wait.actor.CurJob.GetTarget(TargetIndex.A).Thing;
if (thing.jobs.curJob.def == JobDefOf.Wait_MaintainPosture)
{
thing.jobs.EndCurrentJob(JobCondition.InterruptForced);
}
});
wait.FailOnDespawnedOrNull(TargetIndex.A);
wait.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
wait.AddEndCondition(delegate
{
var thing = (Pawn)(Thing)job.GetTarget(TargetIndex.A);
var result = !thing.TryGetComp <CompWidowMilkableHumanoid>().ActiveAndCanBeMilked
? JobCondition.Incompletable
: JobCondition.Ongoing;
return(result);
});
wait.defaultCompleteMode = ToilCompleteMode.Never;
wait.WithProgressBar(TargetIndex.A, () => gatherProgress / WorkTotal);
yield return(wait);
}
/*
* //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()
{
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 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
};
return(toil.WithProgressBarToilDelay(TargetIndex.B));
}
public static void ForcePayAttention(Pawn pawn, int ticks, Thing faceTarget = null, bool maintainPosture = false)
{
if (!Settings.animals_pay_attention)
{
PawnUtility.ForceWait(pawn, ticks, faceTarget, maintainPosture);
return;
}
//
if (pawn.CurJob != null && pawn.CurJob.def == AnimalControlsDefOf.AnimalControls_Wait_PayAttention)
{
return;
}
//
Job job = JobMaker.MakeJob(AnimalControlsDefOf.AnimalControls_Wait_PayAttention, faceTarget);
pawn.jobs.StartJob(job, JobCondition.InterruptForced, null, true, true, null, null, false, false);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.A);
this.FailOnSomeonePhysicallyInteracting(TargetIndex.A);
this.FailOn(delegate {
if (!ChildrenUtility.CanBreastfeed(pawn) || !pawn.CanReserve(TargetA, 1, -1, null, false))
{
return(true);
}
else
{
return(false);
}
});
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil prepare = new Toil();
prepare.initAction = delegate
{
if (Victim.ageTracker.CurLifeStageIndex > AgeStage.Baby)
{
PawnUtility.ForceWait(Victim, breastFeedDuration, Victim);
}
};
prepare.defaultCompleteMode = ToilCompleteMode.Delay;
prepare.defaultDuration = breastFeedDuration;
yield return(prepare);
yield return(new Toil
{
initAction = delegate
{
AddEndCondition(() => JobCondition.Succeeded);
// Baby is full
Victim.needs.food.CurLevelPercentage = 1f;
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
/// <summary>
/// gets the start feed animal toil
/// </summary>
/// <param name="tameeInd">The tamee ind.</param>
/// <returns></returns>
protected virtual Toil StartFeedAnimal(TargetIndex tameeInd)
{
var toil = new Toil();
toil.initAction = delegate
{
Pawn actor = toil.GetActor();
var pawn = (Pawn)(Thing)actor.CurJob.GetTarget(tameeInd);
PawnUtility.ForceWait(pawn, 270, actor);
Thing thing =
FoodUtility.BestFoodInInventory(actor, pawn, FoodPreferability.NeverForNutrition, FoodPreferability.RawTasty);
if (thing == null)
{
actor.jobs.EndCurrentJob(JobCondition.Incompletable);
}
else
{
actor.mindState.lastInventoryRawFoodUseTick = Find.TickManager.TicksGame;
int num = FoodUtility.StackCountForNutrition(feedNutritionLeft, thing.GetStatValue(StatDefOf.Nutrition));
int stackCount = thing.stackCount;
Thing thing2 = actor.inventory.innerContainer.Take(thing, Mathf.Min(num, stackCount));
actor.carryTracker.TryStartCarry(thing2);
actor.CurJob.SetTarget(TargetIndex.B, thing2);
float num2 = thing2.stackCount * thing2.GetStatValue(StatDefOf.Nutrition);
ticksLeftThisToil = Mathf.CeilToInt(FeedDuration * (num2 / RequiredNutritionPerFeed(pawn)));
if (num <= stackCount)
{
feedNutritionLeft = 0f;
}
else
{
feedNutritionLeft -= num2;
if (feedNutritionLeft < 0.001f)
{
feedNutritionLeft = 0f;
}
}
}
};
toil.defaultCompleteMode = ToilCompleteMode.Delay;
return(toil);
}
public Toil TryImproveRelationship(Pawn recruiter, Pawn guest)
{
var toil = new Toil
{
initAction = () => {
if (!recruiter.CanTalkTo(guest))
{
return;
}
InteractionDef intDef = DefDatabase <InteractionDef> .GetNamed("GuestDiplomacy");
recruiter.interactions.TryInteractWith(guest, intDef);
PawnUtility.ForceWait(guest, 200, recruiter);
},
socialMode = RandomSocialMode.Off,
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = 350
};
//toil.AddFailCondition(FailCondition);
return(toil);
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedOrNull(TargetIndex.A);
this.FailOnDowned(TargetIndex.A);
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch));
Toil prepare = new Toil();
prepare.initAction = delegate
{
scoldDuration += Rand.Range(0, 300);
PawnUtility.ForceWait(Victim, scoldDuration, Victim);
};
prepare.tickAction = delegate {
if (pawn.IsHashIntervalTick(150) && (Rand.Value > 0.5f || num_times_scolded <= 0))
{
pawn.interactions.TryInteractWith(Victim, DefDatabase <InteractionDef> .GetNamed("ScoldChild"));
num_times_scolded++;
}
};
prepare.defaultCompleteMode = ToilCompleteMode.Delay;
prepare.defaultDuration = scoldDuration;
prepare.WithProgressBarToilDelay(TargetIndex.A, false, -0.5f);
yield return(prepare);
yield return(new Toil
{
initAction = delegate
{
//Victim.needs.mood.thoughts.memories.TryGainMemoryThought (ThoughtDef.Named ("GotToldOff"), pawn);
pawn.MentalState.RecoverFromState();
AddEndCondition(() => JobCondition.Succeeded);
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDestroyedOrNull(TargetIndex.A);
this.FailOnDestroyedOrNull(TargetIndex.B);
yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));
yield return(Toils_Reserve.Reserve(TargetIndex.B, 1));
yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell));
yield return(Toils_Haul.StartCarryThing(TargetIndex.B, false, false));
yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedNullOrForbidden(TargetIndex.A));
yield return(new Toil
{
initAction = delegate
{
Thing straitjacket = null;
this.pawn.carryTracker.TryDropCarriedThing(pawn.Position, ThingPlaceMode.Near, out straitjacket, null);
Pawn pawnToForceIntoStraitjacket = (Pawn)TargetA.Thing;
if (pawnToForceIntoStraitjacket != null)
{
if (!pawnToForceIntoStraitjacket.InAggroMentalState)
{
GenClamor.DoClamor(pawn, 10f, ClamorType.Harm);
if (!CheckAcceptStraitJacket(pawnToForceIntoStraitjacket, this.pawn))
{
this.pawn.jobs.EndCurrentJob(JobCondition.Incompletable, true);
}
}
}
}, defaultCompleteMode = ToilCompleteMode.Instant
});
Toil toil2 = new Toil();
toil2.defaultCompleteMode = ToilCompleteMode.Delay;
toil2.defaultDuration = 500;
toil2.WithProgressBarToilDelay(TargetIndex.A, false, -0.5f);
toil2.initAction = delegate
{
Pawn pawnToForceIntoStraitjacket = (Pawn)TargetA.Thing;
if (pawnToForceIntoStraitjacket != null)
{
if (!pawnToForceIntoStraitjacket.InAggroMentalState)
{
PawnUtility.ForceWait(pawnToForceIntoStraitjacket, toil2.defaultDuration, this.pawn);
}
}
};
yield return(toil2);
yield return(new Toil
{
initAction = delegate
{
Takee.apparel.Wear(Straitjacket);
Hediff pawnJacketHediff = Takee.health.hediffSet.GetFirstHediffOfDef(StraitjacketDefOf.ROM_RestainedByStraitjacket);
if (pawnJacketHediff == null)
{
pawnJacketHediff = HediffMaker.MakeHediff(StraitjacketDefOf.ROM_RestainedByStraitjacket, Takee);
Takee.health.AddHediff(pawnJacketHediff);
}
}, defaultCompleteMode = ToilCompleteMode.Instant
});
yield break;
}
protected override IEnumerable <Toil> MakeNewToils()
{
//this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOn(delegate
{
return(pawn == Victim);
});
this.FailOn(delegate
{
return(BloodMaster.CurBloodPoints == 0);
});
this.FailOnAggroMentalState(TargetIndex.A);
yield return(Toils_Reserve.Reserve(TargetIndex.A));
var newDomitor = GetActor();
var toil = newDomitor?.Faction == TargetA.Thing?.Faction ? Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch) : Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch);
Toil gotoToil = toil;
yield return(gotoToil);
Toil grappleToil = new Toil()
{
initAction = delegate
{
MoteMaker.MakeColonistActionOverlay(newDomitor, ThingDefOf.Mote_ColonistAttacking);
workLeft = BaseFeedTime;
Pawn victim = TargetA.Thing as Pawn;
if (victim != null)
{
if (newDomitor.InAggroMentalState || victim.InAggroMentalState || victim.Faction != newDomitor.Faction)
{
int grappleBonus = newDomitor is PawnTemporary ? 100 : 0;
if (!JecsTools.GrappleUtility.TryGrapple(newDomitor, victim, grappleBonus))
{
this.EndJobWith(JobCondition.Incompletable);
PawnUtility.ForceWait(newDomitor, (int)(BaseFeedTime * 0.15f));
return;
}
}
if (newDomitor.IsVampire())
{
//VampireBiteUtility.MakeNew(GetActor(), GetActor()); //Actor opens their own wound.
victim.stances.stunner.StunFor((int)BaseFeedTime, newDomitor);
}
}
}
};
yield return(grappleToil);
Toil feedToil = new Toil()
{
tickAction = delegate
{
//try
//{
if (TargetA.Thing is Pawn victim && victim.Spawned && !victim.Dead)
{
workLeft--;
VampireWitnessUtility.HandleWitnessesOf(this.job.def, newDomitor, victim);
// if (victim?.needs?.mood?.thoughts?.memories != null)
// {
// var victimThoughtDef = VampDefOf.ROMV_IDrankVitae;
// Thought_Memory victimThought = null;
// if (victimThoughtDef != null) victimThought = (Thought_Memory)ThoughtMaker.MakeThought(victimThoughtDef);
// if (victimThought != null)
// {
// victim.needs.mood.thoughts.memories.TryGainMemory(victimThought);
// }
// }
if (workLeft <= 0f)
{
if (newDomitor?.VampComp() is CompVampire v && v.IsVampire && newDomitor.Faction == Faction.OfPlayer)
{
MoteMaker.ThrowText(newDomitor.DrawPos, newDomitor.Map, "XP +" + 15);
v.XP += 15;
}
workLeft = BaseFeedTime;
MoteMaker.MakeColonistActionOverlay(newDomitor, ThingDefOf.Mote_ColonistAttacking);
if (!victim.IsGhoul())
{
CompThrall.InitializeGhoul(newDomitor);
}
else
{
CompThrall.ThrallData.TryAdjustBondStage(newDomitor, 1);
}
BloodMaster.TransferBloodTo(1, BloodThrall, true, true);
GhoulUtility.GiveVitaeEffects(victim, newDomitor);
//VampireBiteUtility.CleanBite(GetActor(), GetActor());
this.ReadyForNextToil();
}
}
public static IEnumerable <Toil> MakeFeedToils(JobDef job, JobDriver thisDriver, Pawn actor, LocalTargetInfo TargetA, ThoughtDef victimThoughtDef, ThoughtDef actorThoughtDef, float workLeft, Action effect, Func <Pawn, Pawn, bool> stopCondition, bool needsGrapple = true, bool cleansWound = true, bool neverGiveUp = false)
{
yield return(Toils_Reserve.Reserve(TargetIndex.A));
Toil gotoToil = actor?.Faction == TargetA.Thing?.Faction && (!actor.InAggroMentalState && !((Pawn)TargetA.Thing).InAggroMentalState) ? Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch) : Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch);
yield return(gotoToil);
Toil grappleToil = new Toil()
{
initAction = delegate
{
MoteMaker.MakeColonistActionOverlay(actor, ThingDefOf.Mote_ColonistAttacking);
workLeft = BaseFeedTime;
Pawn victim = TargetA.Thing as Pawn;
if (victim != null)
{
// if (!AllowFeeding(actor, victim))
// {
// actor.jobs.EndCurrentJob(JobCondition.Incompletable);
// }
if (actor.InAggroMentalState || victim.InAggroMentalState || victim.Faction != actor.Faction)
{
if (needsGrapple)
{
int grappleBonus = actor is PawnTemporary ? 100 : 0;
if (!JecsTools.GrappleUtility.TryGrapple(actor, victim, grappleBonus))
{
thisDriver.EndJobWith(JobCondition.Incompletable);
PawnUtility.ForceWait(actor, (int)(BaseFeedTime * 0.15f));
return;
}
}
}
if (actor.IsVampire())
{
VampireBiteUtility.MakeNew(actor, victim);
}
victim.stances.stunner.StunFor((int)BaseFeedTime, actor);
}
}
};
yield return(grappleToil);
Toil feedToil = new Toil()
{
tickAction = delegate
{
//try
//{
if (TargetA.Thing is Pawn victim && victim.Spawned && !victim.Dead)
{
workLeft--;
VampireWitnessUtility.HandleWitnessesOf(job, actor, victim);
if (victim?.needs?.mood?.thoughts?.memories != null)
{
Thought_Memory victimThought = null;
if (victimThoughtDef != null)
{
victimThought = (Thought_Memory)ThoughtMaker.MakeThought(victimThoughtDef);
}
if (victimThought != null)
{
victim.needs.mood.thoughts.memories.TryGainMemory(victimThought);
}
}
if (actor?.needs?.mood?.thoughts?.memories != null)
{
Thought_Memory actorThought = null;
if (actorThoughtDef != null)
{
actorThought = (Thought_Memory)ThoughtMaker.MakeThought(actorThoughtDef);
}
if (actorThought != null)
{
actor.needs.mood.thoughts.memories.TryGainMemory(actorThought);
}
}
if (workLeft <= 0f)
{
if (actor?.VampComp() is CompVampire v && v.IsVampire && actor.Faction == Faction.OfPlayer)
{
MoteMaker.ThrowText(actor.DrawPos, actor.Map, "XP +" + 15);
v.XP += 15;
workLeft = BaseFeedTime;
MoteMaker.MakeColonistActionOverlay(actor, ThingDefOf.Mote_ColonistAttacking);
}
effect();
if (victim != null && !victim.Dead && needsGrapple)
{
int victimBonus = (victim.VampComp() is CompVampire victimVampComp) ? -victimVampComp.Generation + 14 : 0;
int actorBonus = 0;
if (actor?.VampComp() is CompVampire v2 && v2.IsVampire)
{
actorBonus = -v2.Generation + 14;
}
if (!JecsTools.GrappleUtility.TryGrapple(actor, victim, actorBonus, victimBonus))
{
thisDriver.EndJobWith(JobCondition.Incompletable);
}
}
if (!stopCondition(actor, victim))
{
thisDriver.ReadyForNextToil();
if (actor.IsVampire() && cleansWound)
{
VampireBiteUtility.CleanBite(actor, victim);
}
}
else
{
if (victim != null && !victim.Dead)
{
victim.stances.stunner.StunFor((int)BaseFeedTime, actor);
PawnUtility.ForceWait((Pawn)TargetA.Thing, (int)BaseFeedTime, actor);
}
}
}
}
public override void Tick()
{
base.Tick();
if (this.ageTracker.CurLifeStage.defName.ToString().Equals("MareepStage"))
{
float mareepCount = 1;
for (int i = 0; i < 10; i++)
{
IntVec3 intVec = this.Position + GenRadial.RadialPattern [i];
if (intVec.InBounds(base.Map))
{
Thing thing = intVec.GetThingList(base.Map).Find((Thing x) => x is Pawn);
if (thing != null)
{
if (GenSight.LineOfSight(this.Position, intVec, base.Map, false, null, 0, 0))
{
Pawn pDummy = (Pawn)thing;
string d = thing.def.defName.ToString();
if (d.Equals("Pokemon_Mareep") && pDummy.ageTracker.CurLifeStage.defName.ToString().Equals("MareepStage"))
{
++mareepCount;
}
}
}
}
}
this.StoredEnergy += (mareepCount / 40) * Rand.Value;
}
if (this.Faction != null)
{
if (this.StoredEnergy <= this.Def.storedEnergyMaxUtility * 0.05f)
{
this.closestDischarger = null;
this.jobs.ClearQueuedJobs();
}
if (this.StoredEnergy >= this.Def.storedEnergyMaxUtility)
{
if (this.closestDischarger == null)
{
for (int i = 0; i < 1200; i++)
{
IntVec3 intVec = this.Position + GenRadial.RadialPattern [i];
if (intVec.InBounds(base.Map))
{
Thing thing = intVec.GetThingList(base.Map).Find((Thing x) => x is Building);
if (thing != null)
{
if (GenSight.LineOfSight(this.Position, intVec, base.Map, false, null, 0, 0))
{
Building closest = (Building)thing;
string d = closest.def.defName.ToString();
string[] splt = d.Split('_');
//Log.Message (d);
if (splt.Length == 2 && splt [0].Equals("Mareep"))
{
//Log.Message ("Found discharging station");
this.closestDischarger = closest;
this.pather.StartPath(new LocalTargetInfo(this.closestDischarger), Verse.AI.PathEndMode.OnCell);
break;
}
}
}
}
}
}
else
{
Log.Message("No discharging station found");
}
}
if (this.closestDischarger != null)
{
if (this.Position.AdjacentTo8WayOrInside(this.closestDischarger))
{
PawnUtility.ForceWait(this, 5);
List <ThingComp> lt = this.closestDischarger.AllComps;
CompPowerPlantMareep comp = (CompPowerPlantMareep)lt [0];
comp.AddToStoredPower(1f);
this.StoredEnergy -= 1f;
}
}
}
else
{
if (this.StoredEnergy >= this.Def.storedEnergyMaxUtility * 0.1f)
{
this.StoredEnergy -= 0.1f * Rand.Value;
}
}
if (this.StoredEnergy > this.Def.storedEnergyMaxUtility + this.Def.storedEnergyMaxUtility * 0.2f)
{
IntVec3 randomCell = this.OccupiedRect().RandomCell;
float radius = Rand.Range(0.5f, 1f) * 3f;
GenExplosion.DoExplosion(randomCell, base.Map, radius, DamageDefOf.EMP, null, -1, 0f, null, null, null, null, null, 0f, 1, false, null, 0f, 1, 0f, false);
this.StoredEnergy -= 800f;
}
}
public static Toil TakeOrder(TargetIndex patronInd)
{
// Talk to patron
var toil = Toils_Interpersonal.Interact(patronInd, InteractionDefOf.Chitchat);
toil.initAction = InitAction;
toil.socialMode = RandomSocialMode.Off;
toil.defaultDuration = 500;
toil.WithProgressBarToilDelay(patronInd, true);
toil.activeSkill = () => SkillDefOf.Social;
toil.FailOnDownedOrDead(patronInd);
//toil.FailOnMentalState(patronInd);
toil.tickAction = TickAction;
return(toil);
void InitAction()
{
var patron = toil.actor.CurJob.GetTarget(patronInd).Pawn;
if (patron == null)
{
return;
}
if (!(patron.jobs.curDriver is JobDriver_Dine))
{
Log.Error($"{patron.NameShortColored} is not dining!");
toil.actor.jobs.EndCurrentJob(JobCondition.Incompletable);
return;
}
PawnUtility.ForceWait(patron, toil.defaultDuration, toil.actor);
//var order = patron.GetRestaurant().GetOrderFor(patron);
//var icon = order?.consumableDef?.uiIcon;
//if(icon != null) TryCreateBubble(toil.actor, patron, icon);
// TODO: Chance to insult patron
TryCreateBubble(toil.actor, patron, Symbols.symbolTakeOrder);
}
void TickAction()
{
toil.actor.rotationTracker.FaceCell(toil.actor.CurJob.GetTarget(patronInd).Cell);
if (toil.actor.jobs.curDriver.ticksLeftThisToil == 200)
{
CreateOrder();
}
}
void CreateOrder()
{
if (!(toil.GetActor().CurJob.GetTarget(patronInd).Thing is Pawn patron))
{
toil.GetActor().jobs.EndCurrentJob(JobCondition.Errored);
return;
}
var restaurant = patron.GetRestaurant();
var desiredFoodDef = restaurant.Stock.GetRandomMealTypeFor(patron, !patron.IsTeetotaler());
if (desiredFoodDef == null)
{
// Couldn't find anything desired on menu
//Log.Message($"{patron.NameShortColored} couldn't find anything on menu.");
TryCreateBubble(patron, toil.actor, Symbols.symbolNoOrder);
toil.actor.jobs.EndCurrentJob(JobCondition.Incompletable);
patron.jobs.EndCurrentJob(JobCondition.Incompletable);
}
else
{
restaurant.Orders.CreateOrder(patron, desiredFoodDef);
var symbol = desiredFoodDef.uiIcon;
if (symbol != null)
{
TryCreateBubble(patron, toil.actor, symbol);
}
}
}
}
/// <summary>
/// Stuns the target for time
/// </summary>
/// <param name="grappler"></param>
/// <param name="victim"></param>
/// <param name="ticks"></param>
public static void ApplyGrappleEffect(Pawn grappler, Pawn victim, int ticks = 600)
{
victim.stances.stunner.StunFor(ticks);
PawnUtility.ForceWait(victim, ticks, grappler);
}
// Token: 0x06000014 RID: 20 RVA: 0x000027CB File Offset: 0x000009CB
protected override IEnumerable <Toil> MakeNewToils()
{
this.FailOnDespawnedNullOrForbidden(TargetIndex.A);
this.FailOnDowned(TargetIndex.A);
this.FailOnNotCasualInterruptible(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)wait.actor.CurJob.GetTarget(TargetIndex.A).Thing;
actor.pather.StopDead();
PawnUtility.ForceWait(pawn, 15000, null, true);
};
wait.tickAction = delegate()
{
Pawn actor = wait.actor;
actor.skills.Learn(SkillDefOf.Social, 0.142999992f, false);
this.gatherProgress += actor.GetStatValue(StatDefOf.AnimalGatherSpeed, true);
bool flag = this.gatherProgress >= this.WorkTotal;
bool flag2 = flag;
if (flag2)
{
Pawn thing = (Pawn)((Thing)this.job.GetTarget(TargetIndex.A));
thing.TryGetComp <CompWidowMilkableHumanoid>().GatherMilk(this.pawn);
actor.jobs.EndCurrentJob(JobCondition.Succeeded, true, true);
}
};
wait.AddFinishAction(delegate
{
Pawn pawn = (Pawn)wait.actor.CurJob.GetTarget(TargetIndex.A).Thing;
bool flag = pawn.jobs.curJob.def == JobDefOf.Wait_MaintainPosture;
bool flag2 = flag;
if (flag2)
{
pawn.jobs.EndCurrentJob(JobCondition.InterruptForced, true, true);
}
});
wait.FailOnDespawnedOrNull(TargetIndex.A);
wait.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch);
wait.AddEndCondition(delegate
{
Pawn thing = (Pawn)((Thing)this.job.GetTarget(TargetIndex.A));
bool flag = !thing.TryGetComp <CompWidowMilkableHumanoid>().ActiveAndCanBeMilked;
bool flag2 = flag;
JobCondition result;
if (flag2)
{
result = JobCondition.Incompletable;
}
else
{
result = JobCondition.Ongoing;
}
return(result);
});
wait.defaultCompleteMode = ToilCompleteMode.Never;
wait.WithProgressBar(TargetIndex.A, () => this.gatherProgress / this.WorkTotal, false, -0.5f);
yield return(wait);
yield break;
}
public static IEnumerable <Toil> MakeFeedToils(JobDriver thisDriver, Pawn actor, LocalTargetInfo TargetA, float workLeft, Action effect, Func <Pawn, Pawn, bool> stopCondition)
{
yield return(Toils_Reserve.Reserve(TargetIndex.A));
Toil gotoToil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch);
yield return(gotoToil);
Toil grappleToil = new Toil()
{
initAction = delegate
{
MoteMaker.MakeColonistActionOverlay(actor, ThingDefOf.Mote_ColonistAttacking);
workLeft = JobDriver_Feed.BaseFeedTime;
Pawn victim = (Pawn)TargetA.Thing;
if (victim != null)
{
if (victim.InAggroMentalState || victim.Faction != actor.Faction)
{
if (!JecsTools.GrappleUtility.CanGrapple(actor, victim))
{
thisDriver.EndJobWith(JobCondition.Incompletable);
}
}
GenClamor.DoClamor(actor, 10f, ClamorDefOf.Harm);
if (!AllowFeeding(actor, victim))
{
actor.jobs.EndCurrentJob(JobCondition.Incompletable);
}
if (actor?.VampComp()?.Bloodline?.bloodlineHediff?.CompProps <HediffCompProperties_VerbGiver>()?.verbs is List <VerbProperties> verbProps)
{
if (actor?.VerbTracker?.AllVerbs is List <Verb> verbs)
{
if (verbs.Find(x => verbProps.Contains(x.verbProps)) is Verb_MeleeAttack v)
{
victim.TakeDamage(new DamageInfo(v.verbProps.meleeDamageDef, v.verbProps.meleeDamageBaseAmount, 0, -1, actor));
}
}
}
victim.stances.stunner.StunFor((int)BaseFeedTime);
}
}
};
yield return(grappleToil);
Toil feedToil = new Toil()
{
tickAction = delegate
{
Pawn victim = (Pawn)TargetA.Thing;
if (victim == null || !victim.Spawned || victim.Dead)
{
thisDriver.ReadyForNextToil();
}
workLeft--;
if (workLeft <= 0f)
{
if (actor?.VampComp() is CompVampire v && v.IsVampire && actor.Faction == Faction.OfPlayer)
{
MoteMaker.ThrowText(actor.DrawPos, actor.Map, "XP +" + 15);
v.XP += 15;
}
workLeft = BaseFeedTime;
MoteMaker.MakeColonistActionOverlay(actor, ThingDefOf.Mote_ColonistAttacking);
effect();
if ((victim.HostileTo(actor.Faction) || victim.IsPrisoner) && !JecsTools.GrappleUtility.CanGrapple(actor, victim))
{
thisDriver.EndJobWith(JobCondition.Incompletable);
}
if (!stopCondition(actor, victim))
{
thisDriver.ReadyForNextToil();
}
else
{
if (victim != null && !victim.Dead)
{
victim.stances.stunner.StunFor((int)BaseFeedTime);
PawnUtility.ForceWait((Pawn)TargetA.Thing, (int)BaseFeedTime, actor);
}
}
}
},
protected override IEnumerable <Toil> MakeNewToils()
{
if (tar == null)
{
foreach (var toil in base.MakeNewToils())
{
yield return(toil);
}
}
else
{
// Find the pawn to use the item on.
Pawn other;
{
var corpse = tar as Corpse;
other = (corpse == null) ? (Pawn)tar : corpse.InnerPawn;
}
this.FailOnDespawnedNullOrForbidden(itar);
if (!other.Dead)
{
this.FailOnAggroMentalState(itar);
}
yield return(Toils_Reserve.Reserve(itar));
if ((pawn.inventory != null) && pawn.inventory.Contains(item))
{
yield return(Toils_Misc.TakeItemFromInventoryToCarrier(pawn, iitem));
}
else
{
yield return(Toils_Reserve.Reserve(iitem));
yield return(Toils_Goto.GotoThing(iitem, PathEndMode.ClosestTouch).FailOnForbidden(iitem));
yield return(pickup_item(pawn, item));
}
yield return(Toils_Goto.GotoThing(itar, PathEndMode.Touch));
yield return(new Toil
{
initAction = delegate
{
if (!other.Dead)
{
PawnUtility.ForceWait(other, 60);
}
},
defaultCompleteMode = ToilCompleteMode.Delay,
defaultDuration = 60
});
yield return(new Toil
{
initAction = delegate
{
var effective_item = item;
// Drop the item if it's some kind of apparel. This is because ApparelTracker.Wear only works properly
// if the apparel to wear is spawned. (I'm just assuming that DoEffect for apparel wears it, which is
// true for bondage gear)
if ((effective_item as Apparel) != null)
{
Thing dropped_thing;
if (pawn.carryTracker.TryDropCarriedThing(pawn.Position, ThingPlaceMode.Near, out dropped_thing))
{
effective_item = dropped_thing as Apparel;
}
else
{
Log.Error("Unable to drop " + effective_item.Label + " for use on " + other.NameStringShort + " (apparel must be dropped before use)");
effective_item = null;
}
}
if (effective_item != null)
{
var eff = effective_item.TryGetComp <CompUseEffect>();
if (eff != null)
{
eff.DoEffect(other);
}
else
{
Log.Error("Unable to get CompUseEffect for use of " + effective_item.Label + " on " + other.NameStringShort + " by " + pawn.NameStringShort);
}
}
},
defaultCompleteMode = ToilCompleteMode.Instant
});
}
}
