protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell)); Toil research = new Toil(); research.tickAction = delegate { Pawn actor = research.actor; float num = 1.1f * actor.GetStatValue(StatDefOf.ResearchSpeed, true); num *= this.$this.TargetThingA.GetStatValue(StatDefOf.ResearchSpeedFactor, true); Find.ResearchManager.ResearchPerformed(num, actor); actor.skills.Learn(SkillDefOf.Intellectual, 0.11f, false); actor.GainComfortFromCellIfPossible(); }; research.FailOn(() => this.$this.Project == null); research.FailOn(() => !this.$this.Project.CanBeResearchedAt(this.$this.ResearchBench, false)); research.FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell); research.WithEffect(EffecterDefOf.Research, TargetIndex.A); research.WithProgressBar(TargetIndex.A, delegate { ResearchProjectDef project = this.$this.Project; if (project == null) { return(0f); } return(project.ProgressPercent); }, false, -0.5f); research.defaultCompleteMode = ToilCompleteMode.Delay; research.defaultDuration = 4000; yield return(research); yield return(Toils_General.Wait(2)); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); this.FailOnCellMissingDesignation(TargetIndex.A, DesignationDefOf.Mine); yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); var mine = new Toil(); mine.tickAction = delegate { var actor = mine.actor; var mineTarget = MineTarget; if (ticksToPickHit < -100) { ResetTicksToPickHit(); } if (actor.skills != null) { actor.skills.Learn(SkillDefOf.Mining, 0.11f, false); } ticksToPickHit--; if (ticksToPickHit <= 0) { var position = mineTarget.Position; if (effecter == null) { effecter = EffecterDefOf.Mine.Spawn(); } effecter.Trigger(actor, mineTarget); var num = 80; var mineable = mineTarget as Mineable; if (mineable == null || mineTarget.HitPoints > num) { var actor2 = mine.actor; var dinfo = new DamageInfo(DamageDefOf.Mining, num, -1f, actor2, null, null, DamageInfo.SourceCategory.ThingOrUnknown); mineTarget.TakeDamage(dinfo); } else { mineable.DestroyMined(actor); } if (mineTarget.Destroyed) { actor.Map.mineStrikeManager.CheckStruckOre(position, mineTarget.def, actor); actor.records.Increment(RecordDefOf.CellsMined); ReadyForNextToil(); return; } ResetTicksToPickHit(); } }; mine.defaultCompleteMode = ToilCompleteMode.Never; mine.WithProgressBar(TargetIndex.A, () => 1f - (float)MineTarget.HitPoints / (float)MineTarget.MaxHitPoints, false, -0.5f); mine.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); yield return(mine); }
protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch)); Toil clearToil = new Toil(); clearToil.tickAction = delegate { Pawn actor = clearToil.actor; float statValue = actor.GetStatValue(StatDefOf.UnskilledLaborSpeed, true); float num = statValue; this.$this.workDone += num; if (this.$this.workDone >= this.$this.TotalNeededWork) { this.$this.Map.snowGrid.SetDepth(this.$this.TargetLocA, 0f); this.$this.ReadyForNextToil(); return; } }; clearToil.defaultCompleteMode = ToilCompleteMode.Never; clearToil.WithEffect(EffecterDefOf.ClearSnow, TargetIndex.A); clearToil.PlaySustainerOrSound(() => SoundDefOf.Interact_CleanFilth); clearToil.WithProgressBar(TargetIndex.A, () => this.$this.workDone / this.$this.TotalNeededWork, true, -0.5f); clearToil.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); yield return(clearToil); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOn(condition: () => !this.Comp.CanDrillNow()); yield return(Toils_Goto.GotoThing(ind: TargetIndex.A, peMode: PathEndMode.Touch).FailOnDespawnedNullOrForbidden(ind: TargetIndex.A)); Toil mine = new Toil(); mine.WithEffect(effectDef: EffecterDefOf.Drill, ind: TargetIndex.A); mine.WithProgressBar(ind: TargetIndex.A, progressGetter: () => this.Comp.Progress); mine.tickAction = delegate { Pawn minePawn = mine.actor; this.Comp.Drill(miningPoints: minePawn.GetStatValue(stat: StatDefOf.MiningSpeed) / TICKS); minePawn.skills.Learn(sDef: SkillDefOf.Mining, xp: 0.125f); if (!(this.Comp.Progress >= 1)) { return; } this.Comp.DrillWorkDone(driller: minePawn); this.EndJobWith(condition: JobCondition.Succeeded); minePawn.records.Increment(def: RecordDefOf.CellsMined); }; mine.WithEffect(effectDef: this.TargetThingA.def.repairEffect, ind: TargetIndex.A); mine.defaultCompleteMode = ToilCompleteMode.Never; yield return(mine); }
protected override IEnumerable <Toil> MakeNewToils() { Toil doFor = new Toil() { initAction = () => { if (this.age > this.durationTicks) { this.EndJobWith(JobCondition.InterruptForced); } }, tickAction = () => { if (age > durationTicks) { this.EndJobWith(JobCondition.Succeeded); } age++; }, defaultCompleteMode = ToilCompleteMode.Never }; doFor.defaultDuration = this.durationTicks; doFor.WithProgressBar(TargetIndex.A, delegate { if (this.pawn.DestroyedOrNull() || this.pawn.Dead || this.pawn.Downed) { return(1f); } return(1f - ((float)doFor.actor.jobs.curDriver.ticksLeftThisToil / this.durationTicks)); }, false, 0f); yield return(doFor); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedOrNull(TargetIndex.B); yield return(Toils_Goto.Goto(TargetIndex.B, this.PathEndMode)); Toil doWork = new Toil(); doWork.initAction = delegate() { this.workLeft = 65f; }; doWork.tickAction = delegate() { float statValue = doWork.actor.GetStatValue(StatDefOf.ConstructionSpeed, true); this.workLeft -= statValue; if (this.workLeft <= 0f) { this.DoEffect(); this.ReadyForNextToil(); } }; doWork.FailOnCannotTouch(TargetIndex.B, this.PathEndMode); doWork.PlaySoundAtStart(SoundDefOf.Roof_Start); doWork.PlaySoundAtEnd(SoundDefOf.Roof_Finish); doWork.WithEffect(EffecterDefOf.RoofWork, TargetIndex.A); doWork.FailOn(new Func <bool>(this.DoWorkFailOn)); doWork.WithProgressBar(TargetIndex.A, () => 1f - this.workLeft / 65f, false, -0.5f); doWork.defaultCompleteMode = ToilCompleteMode.Never; yield return(doWork); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOn(() => { if (this.Comp.CanDrillNow()) { return(false); } return(true); }); yield return(Toils_Reserve.Reserve(TargetIndex.A).FailOnDespawnedNullOrForbidden(TargetIndex.A)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedNullOrForbidden(TargetIndex.A)); Toil mine = new Toil(); mine.WithEffect(EffecterDefOf.Drill, TargetIndex.A); mine.WithProgressBar(TargetIndex.A, () => this.Comp.Progress); mine.tickAction = delegate { Pawn pawn = mine.actor; this.Comp.Drill(pawn.GetStatValue(StatDefOf.MiningSpeed) / ticks); pawn.skills.Learn(SkillDefOf.Mining, 0.125f); if (this.Comp.Progress >= 1) { this.Comp.DrillWorkDone(pawn); EndJobWith(JobCondition.Succeeded); pawn.records.Increment(RecordDefOf.CellsMined); } }; mine.WithEffect(this.TargetThingA.def.repairEffect, TargetIndex.A); mine.defaultCompleteMode = ToilCompleteMode.Never; yield return(mine); }
private Toil DoWork() { Toil doWork = new Toil() .FailOnDespawnedOrNull(TargetIndex.A) .FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); doWork.initAction = delegate { workLeft = InitialNeededWork; initialNeededWork = workLeft; }; doWork.tickAction = delegate { workLeft -= this.pawn.GetStatValue(StatDefOf.ConstructionSpeed); // do pawn skill increment, or f**k it doesn't matter? if (workLeft <= 0f) { doWork.actor.jobs.curDriver.ReadyForNextToil(); } }; doWork.defaultCompleteMode = ToilCompleteMode.Never; return(doWork.WithProgressBar(TargetIndex.A, () => 1f - workLeft / initialNeededWork)); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOn(() => (!job.ignoreDesignations && base.Map.designationManager.DesignationAt(base.TargetLocA, DesDef) == null) ? true : false); this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch)); Toil doWork = new Toil(); doWork.initAction = delegate { workLeft = BaseWorkAmount; }; doWork.tickAction = delegate { float num = doWork.actor.GetStatValue(StatDefOf.SmoothingSpeed) * 1.7f; workLeft -= num; if (doWork.actor.skills != null) { doWork.actor.skills.Learn(SkillDefOf.Construction, 0.1f); } if (workLeft <= 0f) { DoEffect(); base.Map.designationManager.DesignationAt(base.TargetLocA, DesDef)?.Delete(); ReadyForNextToil(); } }; doWork.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); doWork.WithProgressBar(TargetIndex.A, () => 1f - workLeft / (float)BaseWorkAmount); doWork.defaultCompleteMode = ToilCompleteMode.Never; doWork.activeSkill = () => SkillDefOf.Construction; yield return(doWork); }
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() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell)); Toil research = new Toil(); research.tickAction = delegate { Pawn actor = research.actor; float statValue = actor.GetStatValue(StatDefOf.ResearchSpeed); statValue *= base.TargetThingA.GetStatValue(StatDefOf.ResearchSpeedFactor); Find.ResearchManager.ResearchPerformed(statValue, actor); actor.skills.Learn(SkillDefOf.Intellectual, 0.1f); actor.GainComfortFromCellIfPossible(chairsOnly: true); }; research.FailOn(() => Project == null); research.FailOn(() => !Project.CanBeResearchedAt(ResearchBench, ignoreResearchBenchPowerStatus: false)); research.FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell); research.WithEffect(EffecterDefOf.Research, TargetIndex.A); research.WithProgressBar(TargetIndex.A, () => Project?.ProgressPercent ?? 0f); research.defaultCompleteMode = ToilCompleteMode.Delay; research.defaultDuration = 4000; research.activeSkill = () => SkillDefOf.Intellectual; yield return(research); yield return(Toils_General.Wait(2)); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); this.FailOnDestroyedOrNull(TargetIndex.B); this.FailOnDespawnedOrNull(TargetIndex.C); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); Toil doWork = new Toil(); doWork.initAction = delegate { this.totalWorkNeeded = Shelf.CombineWorkNeeded(TargetC.Thing); this.workPerformed = 0; }; doWork.tickAction = delegate { this.workPerformed += this.pawn.GetStatValue(StatDefOf.WorkSpeedGlobal, true); if (this.workPerformed >= this.totalWorkNeeded) { doWork.actor.jobs.curDriver.ReadyForNextToil(); } }; doWork.defaultCompleteMode = ToilCompleteMode.Never; doWork.WithProgressBar(TargetIndex.A, () => this.workPerformed / this.totalWorkNeeded, false, -0.5f); yield return(doWork); yield return(new Toil { initAction = delegate { Shelf.OverstackThings(TargetThingB, TargetC.Thing); this.pawn.Map.reservationManager.Release(this.job.targetA, this.pawn, this.job); this.pawn.Map.reservationManager.Release(this.job.targetC, this.pawn, this.job); }, defaultCompleteMode = ToilCompleteMode.Instant }); }
protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch).FailOn(() => PlantUtility.AdjacentSowBlocker(this.job.plantDefToSow, this.TargetA.Cell, this.Map) != null).FailOn(() => !this.job.plantDefToSow.CanEverPlantAt(this.TargetLocA, this.Map))); Toil sowToil = new Toil(); sowToil.initAction = delegate() { this.TargetThingA = GenSpawn.Spawn(this.job.plantDefToSow, this.TargetLocA, this.Map, WipeMode.Vanish); this.pawn.Reserve(this.TargetThingA, sowToil.actor.CurJob, 1, -1, null, true); Plant plant = (Plant)this.TargetThingA; plant.Growth = 0f; plant.sown = true; }; sowToil.tickAction = delegate() { Pawn actor = sowToil.actor; if (actor.skills != null) { actor.skills.Learn(SkillDefOf.Plants, 0.085f, false); } float statValue = actor.GetStatValue(StatDefOf.PlantWorkSpeed, true); float num = statValue; Plant plant = this.Plant; if (plant.LifeStage != PlantLifeStage.Sowing) { Log.Error(this.$this + " getting sowing work while not in Sowing life stage.", false); } this.sowWorkDone += num; if (this.sowWorkDone >= plant.def.plant.sowWork) { plant.Growth = 0.05f; this.Map.mapDrawer.MapMeshDirty(plant.Position, MapMeshFlag.Things); actor.records.Increment(RecordDefOf.PlantsSown); this.ReadyForNextToil(); return; } }; sowToil.defaultCompleteMode = ToilCompleteMode.Never; sowToil.FailOnDespawnedNullOrForbidden(TargetIndex.A); sowToil.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); sowToil.WithEffect(EffecterDefOf.Sow, TargetIndex.A); sowToil.WithProgressBar(TargetIndex.A, () => this.sowWorkDone / this.Plant.def.plant.sowWork, true, -0.5f); sowToil.PlaySustainerOrSound(() => SoundDefOf.Interact_Sow); sowToil.AddFinishAction(delegate { if (this.TargetThingA != null) { Plant plant = (Plant)sowToil.actor.CurJob.GetTarget(TargetIndex.A).Thing; if (this.sowWorkDone < plant.def.plant.sowWork && !this.TargetThingA.Destroyed) { this.TargetThingA.Destroy(DestroyMode.Vanish); } } }); sowToil.activeSkill = (() => SkillDefOf.Plants); yield return(sowToil); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch).FailOnDespawnedNullOrForbidden(TargetIndex.A)); startingDurability = Durability; var maintenance = new Toil(); maintenance.tickAction = delegate { Pawn pawn = maintenance.actor; Durability += pawn.GetStatValue(StatDefOf.ConstructionSpeed) / fullRepairTicks; pawn.skills.Learn(SkillDefOf.Construction, 0.125f); if (Durability > .99f) { pawn.records.Increment(RecordDefOf.ThingsRepaired); pawn.jobs.EndCurrentJob(JobCondition.Succeeded); } }; maintenance.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); maintenance.WithEffect(TargetThingA.def.repairEffect, TargetIndex.A); maintenance.WithProgressBar(TargetIndex.A, progress, true); maintenance.defaultCompleteMode = ToilCompleteMode.Never; yield return(maintenance); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedNullOrForbidden(TargetIndex.A); Toil mending = new Toil(); mending.defaultCompleteMode = ToilCompleteMode.Never; mending.socialMode = RandomSocialMode.SuperActive; mending.WithProgressBar(TargetIndex.A, () => workDone / mendingWorks); mending.PlaySustainerOrSound(SoundDefOf.Interact_CleanFilth); mending.tickAction = () => { workDone++; if (workDone >= mendingWorks) { var thing = this.job.targetA.Thing; float repairRateMin = 1f / SkillRecord.MaxLevel * 0.1f; float repairRateMax = Math.Max(1, pawn.skills.GetSkill(SkillDefOf.Crafting).Level) / (float)SkillRecord.MaxLevel * 0.1f; float repairRate = Rand.Range(repairRateMin, repairRateMax); thing.HitPoints = Math.Min(thing.MaxHitPoints, thing.HitPoints + (int)(thing.MaxHitPoints * repairRate)); this.ReadyForNextToil(); } }; yield return(mending); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { Toil wait = new Toil(); wait.tickAction = delegate { Pawn actor = wait.actor; this.gatherProgress += actor.GetStatValue(StatDefOf.AnimalGatherSpeed, true); if (this.gatherProgress >= this.WorkTotal) { Pawn milkedPawn = actor; milkedPawn.TryGetComp <CompMilkableHumanoid>().GatherMilkSelf(); actor.jobs.EndCurrentJob(JobCondition.Succeeded, true); } }; wait.AddEndCondition(delegate { Pawn milkedPawn = wait.actor; if (!milkedPawn.TryGetComp <CompMilkableHumanoid>().ActiveAndCanBeMilked) { return(JobCondition.Incompletable); } return(JobCondition.Ongoing); }); wait.defaultCompleteMode = ToilCompleteMode.Never; wait.WithProgressBar(TargetIndex.A, () => this.gatherProgress / this.WorkTotal, false, -0.5f); yield return(wait); }
protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch)); Toil tillCell = new Toil(); tillCell.initAction = delegate() { this.workdone = 0f; }; tillCell.tickAction = delegate() { Pawn actor = tillCell.actor; float statValue = actor.GetStatValue(StatDefOf.PlantWorkSpeed, true); float num = statValue; this.workdone += num; if (actor.skills != null) { actor.skills.Learn(SkillDefOf.Plants, 0.05f, false); } if (this.workdone >= this.Map.terrainGrid.TerrainAt(this.TargetA.Cell).GetModExtension <TerrainExtension>().tillWorkAmount) { this.Map.terrainGrid.SetTerrain(TargetLocA, this.Map.terrainGrid.TerrainAt(this.TargetA.Cell).GetModExtension <TerrainExtension>().tillsTo); this.ReadyForNextToil(); return; } }; tillCell.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); tillCell.WithProgressBar(TargetIndex.A, () => this.workdone / this.Map.terrainGrid.TerrainAt(this.TargetA.Cell).GetModExtension <TerrainExtension>().tillWorkAmount, false, -0.5f); tillCell.defaultCompleteMode = ToilCompleteMode.Never; tillCell.activeSkill = (() => SkillDefOf.Plants); yield return(tillCell); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedOrNull(TargetIndex.B); yield return(Toils_Goto.Goto(TargetIndex.B, PathEndMode)); Toil doWork = new Toil(); doWork.initAction = delegate { workLeft = 65f; }; doWork.tickAction = delegate { float num = doWork.actor.GetStatValue(StatDefOf.ConstructionSpeed) * 1.7f; workLeft -= num; if (workLeft <= 0f) { DoEffect(); ReadyForNextToil(); } }; doWork.FailOnCannotTouch(TargetIndex.B, PathEndMode); doWork.PlaySoundAtStart(SoundDefOf.Roof_Start); doWork.PlaySoundAtEnd(SoundDefOf.Roof_Finish); doWork.WithEffect(EffecterDefOf.RoofWork, TargetIndex.A); doWork.FailOn(DoWorkFailOn); doWork.WithProgressBar(TargetIndex.A, () => 1f - workLeft / 65f); doWork.defaultCompleteMode = ToilCompleteMode.Never; doWork.activeSkill = () => SkillDefOf.Construction; yield return(doWork); }
// Token: 0x06000010 RID: 16 RVA: 0x00002787 File Offset: 0x00000987 protected override IEnumerable <Toil> MakeNewToils() { var wait = new Toil(); wait.tickAction = delegate { var actor = wait.actor; gatherProgress += actor.GetStatValue(StatDefOf.AnimalGatherSpeed); if (!(gatherProgress >= WorkTotal)) { return; } actor.TryGetComp <CompWidowMilkableHumanoid>().GatherMilkSelf(); actor.jobs.EndCurrentJob(JobCondition.Succeeded); }; wait.AddEndCondition(delegate { var actor = wait.actor; var result = !actor.TryGetComp <CompWidowMilkableHumanoid>().ActiveAndCanBeMilked ? JobCondition.Incompletable : JobCondition.Ongoing; return(result); }); wait.defaultCompleteMode = ToilCompleteMode.Never; wait.WithProgressBar(TargetIndex.A, () => gatherProgress / WorkTotal); yield return(wait); }
public Toil Cultivate() { var targetCell = CurJob.targetA.Cell; var toil = new Toil(); toil.initAction = () => { workTicks = Mathf.RoundToInt(terrainReplacements[targetCell.GetTerrain()].GetStatValueAbstract(StatDefOf.WorkToMake) * pawn.GetStatValue(StatDefOf.PlantWorkSpeed)); pawn.jobs.curDriver.ticksLeftThisToil = workTicks; }; toil.tickAction = () => { if (--pawn.jobs.curDriver.ticksLeftThisToil < 0) { // remove designation var designation = Find.DesignationManager.DesignationAt(targetCell, DefDatabase<DesignationDef>.GetNamed("CultivateLand")); if (designation != null) { Find.DesignationManager.RemoveDesignation(designation); } // replace terrain Find.TerrainGrid.SetTerrain(targetCell, terrainReplacements[targetCell.GetTerrain()]); ReadyForNextToil(); } }; toil.defaultCompleteMode = ToilCompleteMode.Never; toil.FailOnCellMissingDesignation(CellInd, DefDatabase<DesignationDef>.GetNamed("CultivateLand")); toil.WithEffect(() => EffecterDef.Named("CutStone"), CellInd); toil.PlaySustainerOrSound(() => DefDatabase<SoundDef>.GetNamedSilentFail("Recipe_Surgery")); toil.WithProgressBar(CellInd, () => 1f - (float) pawn.jobs.curDriver.ticksLeftThisToil/workTicks); return toil; }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); Toil wait = new Toil(); wait.initAction = delegate() { Pawn actor = wait.actor; actor.pather.StopDead(); }; wait.tickAction = delegate() { Pawn actor = wait.actor; Plant_Nest nest = (Plant_Nest)this.job.targetA.Thing; this.gatherProgress += actor.GetStatValue(StatDefOf.PlantWorkSpeed, true); if (this.gatherProgress >= this.WorkTotal) { actor.jobs.EndCurrentJob(JobCondition.Succeeded, true, true); if (!Rand.Chance(actor.GetStatValue(StatDefOf.PlantHarvestYield, true))) { nest.nectarAmount /= 2; MoteMaker.ThrowText((actor.DrawPos + nest.DrawPos) / 2f, actor.Map, "TextMote_ProductWasted".Translate(), 3.65f); } else { int i = GenMath.RoundRandom((float)1 * (float)nest.nectarAmount); int totalExtracted = 0; while (i > 0) { int num = Mathf.Clamp(i, 1, PurpleIvyDefOf.PI_Nectar.stackLimit); i -= num; totalExtracted += num; Thing thing = ThingMaker.MakeThing(PurpleIvyDefOf.PI_Nectar, null); thing.stackCount = num; GenPlace.TryPlaceThing(thing, actor.Position, actor.Map, ThingPlaceMode.Near, null, null, default(Rot4)); } nest.nectarAmount -= totalExtracted; if (nest.nectarAmount < 0) { nest.nectarAmount = 0; } } } }; wait.FailOnDespawnedOrNull(TargetIndex.A); wait.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); wait.AddEndCondition(delegate { return(JobCondition.Ongoing); }); wait.defaultCompleteMode = ToilCompleteMode.Never; wait.WithProgressBar(TargetIndex.A, () => this.gatherProgress / this.WorkTotal, false, -0.5f); wait.activeSkill = (() => SkillDefOf.Plants); yield return(wait); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { // Go to hairdressing table var gotoToil = Toils_Goto.GotoThing(TableIndex, PathEndMode.InteractionCell); yield return(gotoToil); // Bring up interface yield return(new Toil() { initAction = () => { Find.WindowStack.Add(new Dialog_ChangeHairstyle(this)); }, defaultCompleteMode = ToilCompleteMode.Never }); // Change hairstyle var hairdressToil = new Toil { tickAction = () => { // Work on changing hairstyle restyleTicksDone += pawn.GetStatValue(RimWorld.StatDefOf.GeneralLaborSpeed); if (restyleTicksDone >= ticksToRestyle) { if (AnyChanges) { FilthMaker.TryMakeFilth(pawn.Position, pawn.Map, ThingDefOf.VHE_Filth_Hair, 3); } if (newHairDef != null) { pawn.story.hairDef = newHairDef; } if (newHairColour.HasValue) { pawn.story.hairColor = newHairColour.Value; } if (newBeardDef != null) { this.pawn.style.beardDef = newBeardDef; } pawn.Drawer.renderer.graphics.ResolveAllGraphics(); PortraitsCache.SetDirty(pawn); GlobalTextureAtlasManager.TryMarkPawnFrameSetDirty(pawn); pawn.jobs.EndCurrentJob(JobCondition.Succeeded); } }, defaultCompleteMode = ToilCompleteMode.Never }; hairdressToil.WithProgressBar(TableIndex, () => restyleTicksDone / ticksToRestyle, true); hairdressToil.FailOnCannotTouch(TableIndex, PathEndMode.Touch); hairdressToil.PlaySustainerOrSound(SoundDefOf.Recipe_Tailor); yield return(hairdressToil); }
protected override IEnumerable <Toil> MakeNewToils() { HediffComp_Menstruation Comp = pawn.GetMenstruationComp(); //this.FailOn(delegate //{ // return !(Comp.TotalCumPercent > 0.001); //}); yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch)); Toil excreting = Toils_General.Wait(excretingTime, TargetIndex.None);//duration of excreting.WithProgressBarToilDelay(TargetIndex.A); yield return(excreting); yield return(new Toil() { initAction = delegate() { if (Comp.TotalCumPercent > 0.001) { CumMixture mixture = Comp.MixtureOut(RJWSexperience.VariousDefOf.GatheredCum, 0.5f); float amount = mixture.Volume; if (mixture.ispurecum) { Bucket.AddCum(amount); } else { GatheredCumMixture cummixture = (GatheredCumMixture)ThingMaker.MakeThing(VariousDefOf.GatheredCumMixture); cummixture.InitwithCum(mixture); Bucket.AddCum(amount, cummixture); } } else { ReadyForNextToil(); } if (Comp.TotalCumPercent > 0.001) { JumpToToil(excreting); } } }); Toil cleaning = new Toil(); cleaning.initAction = CleaningInit; cleaning.tickAction = CleaningTick; cleaning.AddFinishAction(Finish); cleaning.defaultCompleteMode = ToilCompleteMode.Never; cleaning.WithProgressBar(TargetIndex.A, () => progress / CleaningTime); yield return(cleaning); //yield return excreting; yield break; }
// Token: 0x06000046 RID: 70 RVA: 0x000040B9 File Offset: 0x000022B9 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; this.gatherProgress += actor.GetStatValue(StatDefOf.AnimalGatherSpeed, true); bool flag = this.gatherProgress >= this.WorkTotal; if (flag) { this.GetComp((Pawn)((Thing)this.job.GetTarget(TargetIndex.A))).Gathered(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; if (flag) { pawn.jobs.EndCurrentJob(JobCondition.InterruptForced, true, true); } }); wait.FailOnDespawnedOrNull(TargetIndex.A); wait.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); wait.AddEndCondition(delegate { bool flag = !this.GetComp((Pawn)((Thing)this.job.GetTarget(TargetIndex.A))).ActiveAndFull; JobCondition result; if (flag) { 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; }
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; }
public static Toil ChewIngestible(Pawn chewer, float durationMultiplier, TargetIndex ingestibleInd, TargetIndex eatSurfaceInd = TargetIndex.None) { Toil toil = new Toil(); toil.initAction = delegate { Pawn actor = toil.actor; Thing thing4 = actor.CurJob.GetTarget(ingestibleInd).Thing; toil.actor.pather.StopDead(); actor.jobs.curDriver.ticksLeftThisToil = Mathf.RoundToInt((float)GetIngestibleProperties(thing4).baseIngestTicks *durationMultiplier); if (thing4.Spawned) { thing4.Map.physicalInteractionReservationManager.Reserve(chewer, actor.CurJob, thing4); } }; toil.tickAction = delegate { if (chewer != toil.actor) { toil.actor.rotationTracker.FaceCell(chewer.Position); } else { Thing thing3 = toil.actor.CurJob.GetTarget(ingestibleInd).Thing; if (thing3 != null && thing3.Spawned) { toil.actor.rotationTracker.FaceCell(thing3.Position); } else if (eatSurfaceInd != 0 && toil.actor.CurJob.GetTarget(eatSurfaceInd).IsValid) { toil.actor.rotationTracker.FaceCell(toil.actor.CurJob.GetTarget(eatSurfaceInd).Cell); } } toil.actor.GainComfortFromCellIfPossible(); }; toil.WithProgressBar(ingestibleInd, delegate { Thing thing2 = toil.actor.CurJob.GetTarget(ingestibleInd).Thing; return((thing2 == null) ? 1f : (1f - (float)toil.actor.jobs.curDriver.ticksLeftThisToil / Mathf.Round((float)thing2.GetIngestibleProperties().baseIngestTicks *durationMultiplier))); }); toil.defaultCompleteMode = ToilCompleteMode.Delay; toil.AddFinishAction(delegate { if (chewer != null && chewer.CurJob != null) { Thing thing = chewer.CurJob.GetTarget(ingestibleInd).Thing; if (thing != null && chewer.Map.physicalInteractionReservationManager.IsReservedBy(chewer, thing)) { chewer.Map.physicalInteractionReservationManager.Release(chewer, toil.actor.CurJob, thing); } } }); toil.handlingFacing = true; AddIngestionEffects(toil, chewer, ingestibleInd, eatSurfaceInd); return(toil); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOn(() => this.Map.zoneManager.ZoneAt(this.TargetLocA) == null || this.Map.zoneManager.ZoneAt(this.TargetLocA).GetType().ToString() != "IceIsNice.Zone_IceMine"); yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, ReservationLayerDefOf.Floor)); yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch)); Toil doWork = new Toil(); doWork.initAction = delegate { this.workLeft = this.BaseWorkAmount; this.ticksToPickHit = this.BaseTicksBetweenPickHits; }; doWork.tickAction = delegate { Pawn actor = this.CurToil.actor; this.ticksToPickHit--; if (this.ticksToPickHit <= 0f) { float num = (this.SpeedStat == null) ? 1f : this.pawn.GetStatValue(this.SpeedStat, true); this.workLeft -= num; this.ticksToPickHit = this.BaseTicksBetweenPickHits; if (this.effecter == null) { this.effecter = EffecterDefOf.Mine.Spawn(); } TargetInfo tar = new TargetInfo(this.TargetLocA, this.Map); this.effecter.Trigger(actor, tar); } if (actor.skills != null) { actor.skills.Learn(SkillDefOf.Mining, 0.11f, false); } if (this.clearSnow) { this.Map.snowGrid.SetDepth(this.TargetLocA, 0f); } if (this.workLeft <= 0f) { this.Map.zoneManager.ZoneAt(this.TargetLocA).RemoveCell(this.TargetLocA); this.Map.terrainGrid.SetTerrain(this.TargetLocA, DefDatabase <TerrainDef> .GetNamed("WaterMovingShallow", true)); actor.records.Increment(RecordDefOf.CellsMined); //GenSpawn.Spawn(DefDatabase<ThingDef>.GetNamed(IceThingDef.Ice, true), this.TargetLocA, this.Map); Thing yield = ThingMaker.MakeThing(DefDatabase <ThingDef> .GetNamed(IceThingDef.Ice, true), null); yield.stackCount = 3; GenPlace.TryPlaceThing(yield, this.TargetLocA, this.Map, ThingPlaceMode.Near, null); this.ReadyForNextToil(); return; } }; doWork.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); doWork.WithProgressBar(TargetIndex.A, () => 1f - this.workLeft / (float)this.BaseWorkAmount, false, -0.5f); doWork.defaultCompleteMode = ToilCompleteMode.Never; yield return(doWork); }
protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch).FailOn(() => PlantUtility.AdjacentSowBlocker(job.plantDefToSow, base.TargetA.Cell, base.Map) != null).FailOn(() => !job.plantDefToSow.CanEverPlantAt_NewTemp(base.TargetLocA, base.Map))); Toil sowToil = new Toil(); sowToil.initAction = delegate { base.TargetThingA = GenSpawn.Spawn(job.plantDefToSow, base.TargetLocA, base.Map); pawn.Reserve(base.TargetThingA, sowToil.actor.CurJob); Plant obj = (Plant)base.TargetThingA; obj.Growth = 0f; obj.sown = true; }; sowToil.tickAction = delegate { Pawn actor = sowToil.actor; if (actor.skills != null) { actor.skills.Learn(SkillDefOf.Plants, 0.085f); } float statValue = actor.GetStatValue(StatDefOf.PlantWorkSpeed); Plant plant2 = Plant; if (plant2.LifeStage != 0) { Log.Error(string.Concat(this, " getting sowing work while not in Sowing life stage.")); } sowWorkDone += statValue; if (sowWorkDone >= plant2.def.plant.sowWork) { plant2.Growth = 0.05f; base.Map.mapDrawer.MapMeshDirty(plant2.Position, MapMeshFlag.Things); actor.records.Increment(RecordDefOf.PlantsSown); ReadyForNextToil(); } }; sowToil.defaultCompleteMode = ToilCompleteMode.Never; sowToil.FailOnDespawnedNullOrForbidden(TargetIndex.A); sowToil.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); sowToil.WithEffect(EffecterDefOf.Sow, TargetIndex.A); sowToil.WithProgressBar(TargetIndex.A, () => sowWorkDone / Plant.def.plant.sowWork, interpolateBetweenActorAndTarget: true); sowToil.PlaySustainerOrSound(() => SoundDefOf.Interact_Sow); sowToil.AddFinishAction(delegate { if (base.TargetThingA != null) { Plant plant = (Plant)sowToil.actor.CurJob.GetTarget(TargetIndex.A).Thing; if (sowWorkDone < plant.def.plant.sowWork && !base.TargetThingA.Destroyed) { base.TargetThingA.Destroy(); } } }); sowToil.activeSkill = () => SkillDefOf.Plants; yield return(sowToil); }
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); }
protected override IEnumerable <Toil> MakeNewToils() { // 移動 yield return(Toils_Goto.GotoCell(GetSnowCellIndex, PathEndMode.Touch)); // 雪を集める var getToil = new Toil(); getToil.tickAction = () => { var actor = getToil.actor; float statValue = actor.GetStatValue(StatDefOf.WorkSpeedGlobal, true); float num = statValue; this.workDone += num; if (this.workDone >= WorkGiver_GetSnow.ConsumeSnowPerOne * 100f) { var snowDepth = this.Map.snowGrid.GetDepth(this.TargetLocA); snowDepth = Math.Max(0f, snowDepth - WorkGiver_GetSnow.ConsumeSnowPerOne); this.Map.snowGrid.SetDepth(this.TargetLocA, snowDepth); this.ReadyForNextToil(); return; } }; getToil.defaultCompleteMode = ToilCompleteMode.Never; getToil.WithEffect(EffecterDefOf.ClearSnow, GetSnowCellIndex); getToil.PlaySustainerOrSound(() => SoundDefOf.Interact_CleanFilth); getToil.WithProgressBar(GetSnowCellIndex, () => this.workDone / this.TotalNeededWork, true, -0.5f); getToil.FailOnCannotTouch(GetSnowCellIndex, PathEndMode.Touch); yield return(getToil); // 雪玉生成 var makeToil = new Toil(); makeToil.initAction = () => { var actor = makeToil.actor; var snowThing = ThingMaker.MakeThing(MizuDef.Thing_Snowball); snowThing.stackCount = 1; if (!GenPlace.TryPlaceThing(snowThing, actor.Position, actor.Map, ThingPlaceMode.Near, null)) { Log.Error(string.Concat(new object[] { actor, " could not drop recipe product ", snowThing, " near ", this.TargetLocA })); } }; makeToil.defaultCompleteMode = ToilCompleteMode.Instant; yield return(makeToil); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TargetIndex.A); this.FailOnDowned(TargetIndex.A); //this.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); Toil waitFor = new Toil() { initAction = () => { if (TargetB != null) { this.waitForPawn = TargetB.Thing as Pawn; if (this.waitForPawn != null && this.waitForPawn.jobs != null && this.waitForPawn.jobs.curJob != null && this.waitForPawn.CurJobDef != null) { this.targetJobDef = this.waitForPawn.CurJobDef; } } this.durationTicks = this.job.expiryInterval; if (this.age > this.durationTicks) { this.EndJobWith(JobCondition.InterruptForced); } }, tickAction = () => { if (this.waitForPawn != null) { if (this.targetJobDef != null && this.waitForPawn.jobs != null && this.waitForPawn.jobs.curJob != null && this.waitForPawn.CurJobDef != this.targetJobDef) { this.EndJobWith(JobCondition.InterruptForced); } } if (age > durationTicks) { this.EndJobWith(JobCondition.Succeeded); } age++; }, defaultCompleteMode = ToilCompleteMode.Never }; waitFor.defaultDuration = this.durationTicks; waitFor.WithProgressBar(TargetIndex.A, delegate { if (this.pawn.DestroyedOrNull() || this.pawn.Dead || this.pawn.Downed) { return(1f); } return(1f - (float)waitFor.actor.jobs.curDriver.ticksLeftThisToil / this.durationTicks); }, false, 0f); yield return(waitFor); }
// added support for fuel burners public static Toil DoRecipeWork() { // research injection. initialized here to check if research project wan't change during work var startedResearch = Find.ResearchManager.currentProj; var toil = new Toil(); toil.initAction = () => { var actor = toil.actor; var curJob = actor.jobs.curJob; var curDriver = actor.jobs.curDriver as JobDriver_DoBill; var unfinishedThing = curJob.GetTarget(TargetIndex.B).Thing as UnfinishedThing; if (unfinishedThing != null && unfinishedThing.Initialized) { curDriver.workLeft = unfinishedThing.workLeft; } else { // research injection var researchComp = toil.actor.jobs.curJob.GetTarget(TargetIndex.A).Thing.TryGetComp<CompResearcher>(); if (researchComp != null) { curDriver.workLeft = startedResearch.CostApparent - startedResearch.ProgressApparent; } else { curDriver.workLeft = curJob.bill.recipe.WorkAmountTotal(unfinishedThing?.Stuff); } if (unfinishedThing != null) { unfinishedThing.workLeft = curDriver.workLeft; } } curDriver.billStartTick = Find.TickManager.TicksGame; curJob.bill.Notify_DoBillStarted(); }; toil.tickAction = () => { var actor = toil.actor; var curJob = actor.jobs.curJob; actor.GainComfortFromCellIfPossible(); // burner support injection var burner = curJob.GetTarget(TargetIndex.A).Thing.TryGetComp<CompFueled>(); if (burner != null && burner.internalTemp < burner.compFueled.Properties.operatingTemp) { return; } var unfinishedThing = curJob.GetTarget(TargetIndex.B).Thing as UnfinishedThing; if (unfinishedThing != null && unfinishedThing.Destroyed) { actor.jobs.EndCurrentJob(JobCondition.Incompletable); return; } curJob.bill.Notify_PawnDidWork(actor); var billGiverWithTickAction = curJob.GetTarget(TargetIndex.A).Thing as IBillGiverWithTickAction; billGiverWithTickAction?.BillTick(); if (curJob.RecipeDef.workSkill != null) { actor.skills.GetSkill(curJob.RecipeDef.workSkill) .Learn(LearnRates.XpPerTickRecipeBase*curJob.RecipeDef.workSkillLearnFactor); } var workProgress = (curJob.RecipeDef.workSpeedStat != null) ? actor.GetStatValue(curJob.RecipeDef.workSpeedStat) : 1f; var curDriver = actor.jobs.curDriver as JobDriver_DoBill; var building_WorkTable = curDriver.BillGiver as Building_WorkTable; var researchComp = curJob.GetTarget(TargetIndex.A).Thing.TryGetComp<CompResearcher>(); if (building_WorkTable != null) { // research injection workProgress *= researchComp == null ? building_WorkTable.GetStatValue(StatDefOf.WorkTableWorkSpeedFactor) : building_WorkTable.GetStatValue(StatDefOf.ResearchSpeedFactor); } if (DebugSettings.fastCrafting) { workProgress *= 30f; } curDriver.workLeft -= workProgress; if (unfinishedThing != null) { unfinishedThing.workLeft = curDriver.workLeft; } // research injection if (researchComp != null) { if (Find.ResearchManager.currentProj != null && Find.ResearchManager.currentProj == startedResearch) { Find.ResearchManager.ResearchPerformed(workProgress, actor); } if (Find.ResearchManager.currentProj != startedResearch) { actor.jobs.EndCurrentJob(JobCondition.Succeeded); // scatter around all ingridients foreach (var cell in building_WorkTable.IngredientStackCells) { var ingridientsOnCell = Find.ThingGrid.ThingsListAtFast(cell)? .Where(thing => thing.def.category == ThingCategory.Item) .ToList(); if (!ingridientsOnCell.NullOrEmpty()) { Thing dummy; // despawn thing to spawn again with TryPlaceThing ingridientsOnCell.FirstOrDefault().DeSpawn(); if ( !GenPlace.TryPlaceThing(ingridientsOnCell.FirstOrDefault(), building_WorkTable.InteractionCell, ThingPlaceMode.Near, out dummy)) { Log.Error("No free spot for " + ingridientsOnCell); } } } } } else if (curDriver.workLeft <= 0f) { curDriver.ReadyForNextToil(); } if (curJob.bill.recipe.UsesUnfinishedThing) { var num2 = Find.TickManager.TicksGame - curDriver.billStartTick; if (num2 >= 3000 && num2%1000 == 0) { actor.jobs.CheckForJobOverride(); } } }; toil.defaultCompleteMode = ToilCompleteMode.Never; toil.WithEffect(() => toil.actor.CurJob.bill.recipe.effectWorking, TargetIndex.A); toil.PlaySustainerOrSound(() => toil.actor.CurJob.bill.recipe.soundWorking); toil.WithProgressBar(TargetIndex.A, () => { var actor = toil.actor; var curJob = actor.CurJob; var unfinishedThing = curJob.GetTarget(TargetIndex.B).Thing as UnfinishedThing; var researchComp = curJob.GetTarget(TargetIndex.A).Thing.TryGetComp<CompResearcher>(); // research injection return researchComp == null ? 1f - ((JobDriver_DoBill) actor.jobs.curDriver).workLeft/ curJob.bill.recipe.WorkAmountTotal(unfinishedThing?.Stuff) : startedResearch.ProgressPercent; }); return toil; }
public Toil CollectClay(int ticksToCollect) { var targetCell = CurJob.targetA.Cell; var toil = new Toil(); toil.initAction = () => { pawn.jobs.curDriver.ticksLeftThisToil = Mathf.RoundToInt(ticksToCollect*pawn.GetStatValue(StatDef.Named("CollectingSpeed"))); totalWork = pawn.jobs.curDriver.ticksLeftThisToil; }; toil.tickAction = () => { if (--pawn.jobs.curDriver.ticksLeftThisToil < 0) { // remove designation var designation = Find.DesignationManager.DesignationAt(targetCell, DefDatabase<DesignationDef>.GetNamed("CollectClay")); if (designation != null) { Find.DesignationManager.RemoveDesignation(designation); } // replace terrain if (Find.TerrainGrid.TerrainAt(targetCell) == TerrainDef.Named("Mud")) Find.TerrainGrid.SetTerrain(targetCell, DefDatabase<TerrainDef>.GetNamed("Soil")); if (Find.TerrainGrid.TerrainAt(targetCell) == TerrainDef.Named("SoilRich")) Find.TerrainGrid.SetTerrain(targetCell, DefDatabase<TerrainDef>.GetNamed("Soil")); if (Find.TerrainGrid.TerrainAt(targetCell) == TerrainDef.Named("WaterShallow")) { Find.TerrainGrid.SetTerrain(targetCell, DefDatabase<TerrainDef>.GetNamed("WaterDeep")); var list = new List<Thing>(Find.ThingGrid.ThingsListAtFast(targetCell) .Where(thing => thing.def.category == ThingCategory.Item || thing.def.category == ThingCategory.Pawn)); foreach (var thing in list) { Thing dummy; // despawn thing to spawn again with TryPlaceThing thing.DeSpawn(); if (!GenPlace.TryPlaceThing(thing, thing.Position, ThingPlaceMode.Near, out dummy)) { Log.Error("No free spot for " + thing); } } } // spawn resources var clayRed = ThingMaker.MakeThing(ThingDef.Named("ClumpClayGray")); clayRed.stackCount = Rand.RangeInclusive(25, 75); GenPlace.TryPlaceThing(clayRed, targetCell, ThingPlaceMode.Near); // Rand.Value = Rand.Range(0, 1) if (Rand.Value < RareResourceSpawnChance) { var clayWhite = ThingMaker.MakeThing(ThingDef.Named("ClumpClayWhite")); clayWhite.stackCount = Rand.RangeInclusive(5, 10); GenPlace.TryPlaceThing(clayWhite, targetCell, ThingPlaceMode.Near); } ReadyForNextToil(); } }; toil.defaultCompleteMode = ToilCompleteMode.Never; toil.FailOnCellMissingDesignation(CellInd, DefDatabase<DesignationDef>.GetNamed("CollectClay")); toil.WithEffect(() => EffecterDef.Named("CutStone"), CellInd); toil.PlaySustainerOrSound(() => DefDatabase<SoundDef>.GetNamedSilentFail("Recipe_Surgery")); toil.WithProgressBar(CellInd, () => 1f - (float) pawn.jobs.curDriver.ticksLeftThisToil/totalWork); return toil; }