protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDespawnedOrNull(TargetIndex.A); this.FailOn(() => !TargetCanBeBuried()); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnForbidden(TargetIndex.A)); yield return(new Toil() { defaultCompleteMode = ToilCompleteMode.Delay, defaultDuration = Duration }.WithProgressBarToilDelay(TargetIndex.A) .FailOnDespawnedOrNull(TargetIndex.A)); yield return(Toils_General.Do(() => { var holeBuilding = TargetLocA.GetThingList(Map) .FirstOrDefault(t => t is Building_BuriedThing) as Building_BuriedThing; if (holeBuilding == null) { holeBuilding = ThingMaker.MakeThing(ThingDef.Named("Building_BuriedThing"), null) as Building_BuriedThing; GenSpawn.Spawn(holeBuilding, TargetLocA, Map, Rot4.North, WipeMode.Vanish); pawn.Map.edificeGrid?.Register(holeBuilding); } holeBuilding.AddThing((TargetThingA as Corpse)?.InnerPawn?.LabelShort ?? TargetThingA.LabelNoCount); pawn.Map.designationManager?.TryRemoveDesignationOn(TargetThingA, BuryOnTheSpotDefOf.BuryDesignation); TargetThingA.DeSpawn(); })); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { this.EndOnDespawnedOrNull(TargetIndex.A, JobCondition.Incompletable); yield return(Toils_Reserve.Reserve(TargetIndex.A, job.def.joyMaxParticipants)); if (TargetB != null) { yield return(Toils_Reserve.Reserve(TargetIndex.B, 1)); } yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell)); var toil = new Toil(); toil.PlaySustainerOrSound(TargetThingA?.def?.defName == "RimWriter_TableTypewriter" ? DefDatabase <SoundDef> .GetNamed("RimWriter_SoundManualTypewriter") : DefDatabase <SoundDef> .GetNamed( "RimWriter_SoundManualPencil")); toil.tickAction = delegate { pawn.rotationTracker.FaceCell(TargetA.Cell); pawn.GainComfortFromCellIfPossible(); var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor, true); var extraJoyGainFactor = statValue; JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.GoToNextToil, extraJoyGainFactor); }; toil.defaultCompleteMode = ToilCompleteMode.Delay; toil.defaultDuration = job.def.joyDuration; toil.AddFinishAction(delegate { RimWriterUtility.TryGainLibraryThought(pawn); }); yield return(toil); var finishedToil = new Toil { initAction = delegate { if (RimWriterUtility.IsCosmicHorrorsLoaded() || RimWriterUtility.IsCultsLoaded()) { try { if (RimWriterUtility.HasSanityLoss(pawn)) { RimWriterUtility.ApplySanityLoss(pawn, -sanityRestoreRate, 1); Messages.Message(pawn.ToString() + " has restored some sanity using the " + TargetA.Thing.def.label + ".", new TargetInfo(pawn.Position, pawn.Map), MessageTypeDefOf.NeutralEvent);// .Standard); } } catch { Log.Message("Error loading Sanity Hediff."); } } } }; yield return(finishedToil); yield break; }
/// <summary> /// What happens while the game is being played. Make it return true if the player wins. /// </summary> /// <returns></returns> protected virtual bool WatchTickAction() { var extraJoyGainFactor = TargetThingA.GetStatValue(StatDefOf.EntertainmentStrengthFactor); JoyUtility.JoyTickCheckEnd(this.pawn, JoyTickFullJoyAction.None, extraJoyGainFactor); return(false); }
protected override void AffectGate() { MoteMaker.ThrowText(TargetThingA.TrueCenter(), this.Map, "MoteOpen".Translate(), 1f); Building building = (Building)ThingMaker.MakeThing(ThingDef.Named("OpenPortcullis"), TargetThingA.Stuff); building.SetFaction(TargetThingA.Faction); GenSpawn.Spawn(building, TargetThingA.Position, TargetThingA.Map, TargetThingA.Rotation, WipeMode.Vanish); }
protected void ReadTickAction() { pawn.rotationTracker.FaceCell(TargetB.Cell); pawn.GainComfortFromCellIfPossible(); var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor); var pawn1 = pawn; JoyUtility.JoyTickCheckEnd(pawn1, JoyTickFullJoyAction.EndJob, statValue); }
protected Action WaitTickAction() { return(delegate { pawn.rotationTracker.FaceCell(TargetB.Cell); pawn.GainComfortFromCellIfPossible(); var extraJoyGainFactor = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor); JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, extraJoyGainFactor); }); }
public override void Notify_Starting() { base.Notify_Starting(); if (TargetThingA != null) { forbiddenInitially = TargetThingA.IsForbidden(pawn); } else { forbiddenInitially = false; } }
protected virtual void ListenTickAction() { if (!Gramophone.IsOn()) { EndJobWith(JobCondition.Incompletable); return; } pawn.rotationTracker.FaceCell(TargetA.Cell); pawn.GainComfortFromCellIfPossible(); var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor); JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, statValue); }
protected override IEnumerable <Toil> MakeNewToils() { this.EndOnDespawnedOrNull(TargetIndex.A); yield return(Toils_Reserve.Reserve(TargetIndex.A, job.def.joyMaxParticipants)); if (TargetB != null) { yield return(Toils_Reserve.Reserve(TargetIndex.B)); } yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell)); var toil = new Toil(); var soundDef = Find.World.GetComponent <WorldComponent_Tunes>().TuneDefCache .FindAll(x => x.instrumentDefs.Contains(TargetThingA.def)).RandomElement(); toil.PlaySustainerOrSound(soundDef); toil.tickAction = delegate { pawn.rotationTracker.FaceCell(TargetA.Cell); pawn.GainComfortFromCellIfPossible(); var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor); JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, statValue); }; toil.defaultCompleteMode = ToilCompleteMode.Delay; toil.defaultDuration = job.def.joyDuration; toil.AddFinishAction(delegate { if (Utility.IsCosmicHorrorsLoaded()) { try { if (Utility.HasSanityLoss(pawn)) { Utility.ApplySanityLoss(pawn, -sanityRestoreRate); Messages.Message( pawn + " has restored some sanity using the " + TargetA.Thing.def.label + ".", new TargetInfo(pawn.Position, pawn.Map), MessageTypeDefOf.NeutralEvent); // .Standard); } } catch { Log.Message("Error loading Sanity Hediff."); } } JoyUtility.TryGainRecRoomThought(pawn); }); yield return(toil); }
protected void ReadTickAction() { this.pawn.rotationTracker.FaceCell(TargetB.Cell); this.pawn.GainComfortFromCellIfPossible(); var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor, true); Pawn pawn = this.pawn; var extraJoyGainFactor = statValue; if (TargetThingA is GuideBook gBook) { gBook.Teach(pawn); } JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.GoToNextToil, extraJoyGainFactor); }
//[DebuggerHidden] protected override IEnumerable <Toil> MakeNewToils() { ProblemWorker_Hacker pw = GetProblemWorker(); if (pw == null) { yield break; } this.AddEndCondition(() => pw.IsRunning() && !pw.HasHackingStopped() && (TargetThingA.TryGetComp <CompHacked>()?.investigatable ?? false) ? JobCondition.Ongoing : JobCondition.Incompletable); this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Reserve.Reserve(TargetIndex.A, 1)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); Toil doWork = new Toil().FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); doWork.initAction = () => { this.totalWorkNeeded = 300f; this.workLeft = this.totalWorkNeeded; }; doWork.tickAction = () => { this.workLeft -= this.pawn.GetStatValue(StatDefOf.ResearchSpeed, true); this.pawn.skills.GetSkill(SkillDefOf.Intellectual).Learn(5f, false); if (this.workLeft <= 0f) { doWork.actor.jobs.curDriver.ReadyForNextToil(); } }; doWork.defaultCompleteMode = ToilCompleteMode.Never; doWork.WithProgressBar(TargetIndex.A, () => 1f - this.workLeft / this.totalWorkNeeded, false, -0.5f); yield return(doWork); Toil foundEm = new Toil(); foundEm.defaultCompleteMode = ToilCompleteMode.Instant; foundEm.initAction = delegate { ResearchProjectDef current = Find.ResearchManager.currentProj; Find.ResearchManager.currentProj = DefDatabase <ResearchProjectDef> .GetNamed("HackingCountermeasures"); Find.ResearchManager.ResearchPerformed(500 / 0.007f, null); //Constant from inside ResearchManager Find.ResearchManager.currentProj = current; this.pawn.skills.GetSkill(SkillDefOf.Intellectual).Learn(500f, false); TargetThingA.TryGetComp <CompHacked>().investigatable = false; Find.LetterStack.ReceiveLetter("ProblemHackerInvestigateHackingLetterLabel".Translate(), "ProblemHackerInvestigateHackingLetterText".Translate(this.pawn.NameStringShort), LetterDefOf.PositiveEvent); }; yield return(foundEm); }
protected override IEnumerable <Toil> MakeNewToils() { /// //Set fail conditions /// this.FailOnDestroyed(HaulableInd); this.FailOnDestroyed(CarrierInd); //Note we only fail on forbidden if the target doesn't start that way //This helps haul-aside jobs on forbidden items if (!TargetThingA.IsForbidden(pawn.Faction)) { this.FailOnForbidden(HaulableInd); } /// //Define Toil /// Toil toilGoto = null; toilGoto = Toils_Goto.GotoThing(HaulableInd, PathMode.ClosestTouch) .FailOn(() => { Vehicle_Cargo vc = CurJob.GetTarget(CarrierInd).Thing as Vehicle_Cargo; if (!vc.storage.CanAcceptAnyOf(CurJob.GetTarget(HaulableInd).Thing)) { return(true); } return(false); }); /// //Toils Start /// //Reserve thing to be stored and storage cell yield return(Toils_Reserve.Reserve(HaulableInd)); //Collect Target yield return(toilGoto); yield return(ToolsForHaul.Toils_Collect.CollectThing(HaulableInd, CarrierInd)); }
protected override IEnumerable <Toil> MakeNewToils() { Utility.Log($"Making new toils for {pawn} to destroy {TargetThingA.LabelCap}..."); this.FailOnDespawnedNullOrForbidden(TargetIndex.A); this.FailOnThingMissingDesignation(TargetIndex.A, DestroyItemDefOf.Designation_DestroyItem); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); Toil destroyToil = new Toil(); destroyToil.tickAction = () => { if (!TargetThingA.IsHashIntervalTick(GenTicks.TicksPerRealSecond)) { return; } float hpLossAmount = pawn.GetStatValue(StatDefOf.MeleeDPS) * pawn.GetStatValue(StatDefOf.GeneralLaborSpeed) * Settings.destructionSpeed; if (Settings.instantDestruction || hpLossAmount >= TargetThingA.HitPoints) { pawn.records.Increment(DestroyItemDefOf.Record_ItemsDestroyed); if (TargetThingA is Corpse corpse && corpse.InnerPawn.RaceProps.Humanlike) { Utility.Log($"The destroyed item was a humanlike corpse. Adding bad thoughts to {pawn} and other pawns."); if (pawn.needs?.mood?.thoughts != null) { pawn.needs.mood.thoughts.memories.TryGainMemory(DestroyItemDefOf.Thought_DestroyedCorpse); } foreach (Pawn p in pawn.Map.mapPawns.SpawnedPawnsInFaction(pawn.Faction).Where(p => pawn != p && p.needs?.mood?.thoughts != null)) { p.needs.mood.thoughts.memories.TryGainMemory(DestroyItemDefOf.Thought_KnowDestroyedCorpse); } } TargetThingA.HitPoints = 0; TargetThingA.Destroy(); ReadyForNextToil(); } else { TargetThingA.TakeDamage(new DamageInfo(DamageDefOf.Deterioration, hpLossAmount, instigator: pawn)); } }; destroyToil.defaultCompleteMode = ToilCompleteMode.Never; destroyToil.WithProgressBar(TargetIndex.A, () => 1f - (float)job.targetA.Thing.HitPoints / job.targetA.Thing.MaxHitPoints); destroyToil.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); yield return(destroyToil); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { /// //Set fail conditions /// this.FailOnDestroyedOrNull(CartInd); //Note we only fail on forbidden if the target doesn't start that way //This helps haul-aside jobs on forbidden items if (!TargetThingA.IsForbidden(pawn.Faction)) { this.FailOnForbidden(CartInd); } Vehicle_Cart cart = TargetThingA as Vehicle_Cart; /// //Define Toil /// Toil toilGoToCell = Toils_Goto.GotoCell(StoreCellInd, PathEndMode.ClosestTouch); /// //Toils Start /// //Reserve thing to be stored and storage cell yield return(Toils_Reserve.Reserve(CartInd)); yield return(Toils_Reserve.Reserve(StoreCellInd)); //JumpIf already mounted yield return(Toils_Jump.JumpIf(toilGoToCell, () => { return (cart.GetComp <CompMountable>().Driver == pawn) ? true : false; })); //Mount on Target yield return(Toils_Goto.GotoThing(CartInd, PathEndMode.ClosestTouch) .FailOnDestroyedOrNull(CartInd)); yield return(Toils_Cart.MountOn(CartInd)); //Dismount yield return(toilGoToCell); yield return(Toils_Cart.DismountAt(CartInd, StoreCellInd)); }
protected override IEnumerable <Toil> MakeNewToils() { this.EndOnDespawnedOrNull(TargetIndex.A); yield return(Toils_Reserve.Reserve(TargetIndex.A, job.def.joyMaxParticipants)); if (TargetB != null) { yield return(Toils_Reserve.Reserve(TargetIndex.B)); } yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.OnCell)); var toil = new Toil(); toil.PlaySustainerOrSound(DefDatabase <SoundDef> .GetNamed("Estate_SoundManualTypewriter")); toil.tickAction = delegate { pawn.rotationTracker.FaceCell(TargetA.Cell); pawn.GainComfortFromCellIfPossible(); var statValue = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor); JoyUtility.JoyTickCheckEnd(pawn, JoyTickFullJoyAction.EndJob, statValue); }; toil.defaultCompleteMode = ToilCompleteMode.Delay; toil.defaultDuration = job.def.joyDuration; // toil.AddFinishAction(delegate // { // if (Cthulhu.Utility.IsCosmicHorrorsLoaded()) // { // try // { // if (Cthulhu.Utility.HasSanityLoss(this.pawn)) // { // Cthulhu.Utility.ApplySanityLoss(this.pawn, -sanityRestoreRate, 1); // Messages.Message(this.pawn.ToString() + " has restored some sanity using the " + this.TargetA.Thing.def.label + ".", new TargetInfo(this.pawn.Position, this.pawn.Map), MessageTypeDefOf.NeutralEvent);// .Standard); // } // } // catch // { // Log.Message("Error loading Sanity Hediff."); // } // } // // JoyUtility.TryGainRecRoomThought(this.pawn); // }); yield return(toil); }
protected override IEnumerable <Toil> MakeNewToils() { AddFailCondition(JobHasFailed); this.FailOnDestroyedNullOrForbidden(TargetIndex.A); yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch)); yield return(new Toil { initAction = () => { TargetThingA.TrySwitch(); TargetThingA.UpdateSwitchDesignation(); for (int i = 0; i <= 10; i++) { MoteMaker.ThrowDustPuff(TargetThingA.Position, Map, 1); } }, defaultCompleteMode = ToilCompleteMode.Instant }); }
protected override IEnumerable <Toil> MakeNewToils() { /// //Set fail conditions /// //this.FailOnBurningImmobile(MountCellInd); this.FailOnDestroyedOrNull(MountableInd); //Note we only fail on forbidden if the target doesn't start that way //This helps haul-aside jobs on forbidden items if (!TargetThingA.IsForbidden(pawn.Faction)) { this.FailOnForbidden(MountableInd); } /// //Define Toil /// /// //Toils Start /// //Reserve thing to be stored and storage cell //yield return Toils_Reserve.Reserve(MountableInd, ReservationType.Total); //Mount on Target yield return(Toils_Goto.GotoThing(MountableInd, PathEndMode.ClosestTouch)); Toil toilBoardOn = new Toil(); toilBoardOn.initAction = () => { Pawn actor = toilBoardOn.actor; Vehicle_Saddle vehicle = TargetThingA as Vehicle_Saddle; vehicle.BoardOn(actor); }; yield return(toilBoardOn); }
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); }
protected override IEnumerable <Toil> MakeNewToils() { /// //Set fail conditions /// this.FailOnDestroyed(MountableInd); //Note we only fail on forbidden if the target doesn't start that way //This helps haul-aside jobs on forbidden items if (!TargetThingA.IsForbidden(pawn.Faction)) { this.FailOnForbidden(MountableInd); } /// //Define Toil /// /// //Toils Start /// //Reserve thing to be stored and storage cell yield return(Toils_Reserve.Reserve(MountableInd)); //Mount on Target yield return(Toils_Goto.GotoThing(MountableInd, PathEndMode.ClosestTouch)); Toil toilMountOn = new Toil(); toilMountOn.initAction = () => { Pawn actor = toilMountOn.actor; Job curJob = actor.jobs.curJob; TargetThingA.TryGetComp <CompMountable>().MountOn(actor); }; yield return(toilMountOn); }
//[DebuggerHidden] protected override IEnumerable <Toil> MakeNewToils() { ProblemWorker_Hacker pw = GetProblemWorker(); if (pw == null) { yield break; } this.AddEndCondition(() => pw.IsRunning() && !pw.HasHackingStopped() && TargetThingA.TryGetComp <CompHacked>() != null ? JobCondition.Ongoing : JobCondition.Incompletable); this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Reserve.Reserve(TargetIndex.A, 1)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch)); Toil doWork = new Toil().FailOnDestroyedNullOrForbidden(TargetIndex.A).FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); doWork.initAction = () => { this.totalWorkNeeded = 100f; this.workLeft = this.totalWorkNeeded; }; doWork.tickAction = () => { this.workLeft -= this.pawn.GetStatValue(StatDefOf.ResearchSpeed, true); this.pawn.skills.GetSkill(SkillDefOf.Intellectual).Learn(5f, false); if (this.workLeft <= 0f) { doWork.actor.jobs.curDriver.ReadyForNextToil(); } }; doWork.defaultCompleteMode = ToilCompleteMode.Never; doWork.WithProgressBar(TargetIndex.A, () => 1f - this.workLeft / this.totalWorkNeeded, false, -0.5f); yield return(doWork); Toil foundEm = new Toil(); foundEm.defaultCompleteMode = ToilCompleteMode.Instant; foundEm.initAction = delegate { FindExt.DynamicComponentManager.RemoveDynamicThingComp <CompHacked> (TargetThingA as ThingWithComps); }; yield return(foundEm); }
protected void RollForLuck() { var extraLuckFromQuality = TargetThingA.GetStatValue(StatDefOf.JoyGainFactor, true); float extraLuckFromHobbitSmarts = pawn.skills.GetSkill(SkillDefOf.Intellectual).levelInt; var yourLuckyNumber = (1f + extraLuckFromHobbitSmarts) * extraLuckFromQuality / 100; Log.Message("lucky number is: " + yourLuckyNumber.ToString()); if (Rand.Chance(yourLuckyNumber) || DebugSettings.godMode) { Thing reward = ThingMaker.MakeThing(ThingDefOf.Gold); reward.stackCount = Rand.RangeInclusive(10, 50); GenSpawn.Spawn(reward, pawn.Position, pawn.Map); PuzzleBox.Destroy(); Letter letter = LetterMaker.MakeLetter("LotRH_PuzzleSolvedLabel".Translate(), "LotRH_PuzzleSolved".Translate(new object[] { pawn.Label, reward.Label, }), LetterDefOf.PositiveEvent); Find.LetterStack.ReceiveLetter(letter); } }
protected override IEnumerable <Toil> MakeNewToils() { //Set fail conditions this.FailOnDestroyedNullOrForbidden(RobotDestroyedInd); this.FailOnBurningImmobile(RobotDestroyedInd); //Note we only fail on forbidden if the target doesn't start that way //This helps haul-aside jobs on forbidden items if (!TargetThingA.IsForbidden(pawn.Faction)) { this.FailOnForbidden(RobotDestroyedInd); } //Reserve target, if it is a storage yield return(Toils_Reserve.Reserve(RobotDestroyedInd, 1)); if (pawn.jobs.curJob.GetTarget(RechargeStationInd).Thing != null) { //yield return toilGoto; yield return(Toils_Goto.GotoThing(RechargeStationInd, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(RechargeStationInd)); // start work on target yield return(Toils_WaitWithSoundAndEffect(workTime, "Interact_ConstructMetal", "ConstructMetal", RechargeStationInd)); yield return(Toils_TryToDeconstructRechargeStation(pawn, RobotDestroyedInd)); } //yield return toilGoto; yield return(Toils_Goto.GotoThing(RobotDestroyedInd, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(RobotDestroyedInd)); // start work on target yield return(Toils_WaitWithSoundAndEffect(workTime, "Interact_ConstructMetal", "ConstructMetal", RobotDestroyedInd)); yield return(Toils_TryToDeconstructRobot(pawn, RobotDestroyedInd)); }
protected override IEnumerable <Toil> MakeNewToils() { //A: haul thing //B: destination loc //Set fail conditions this.FailOnDestroyed(TargetIndex.A); this.FailOnBurningImmobile(TargetIndex.B); //Note we only fail on forbidden if the target doesn't start that way //This helps haul-aside jobs on forbidden items if (!TargetThingA.IsForbidden()) { this.FailOnForbidden(TargetIndex.A); } //Reserve targets yield return(Toils_Reserve.ReserveTarget(TargetIndex.B, ReservationType.Store)); Toil reserveTargetA = Toils_Reserve.ReserveTarget(TargetIndex.A, ReservationType.Total); yield return(reserveTargetA); Toil toilGoto = null; toilGoto = Toils_Goto.GotoThing(TargetIndex.A, PathMode.ClosestTouch) .FailOn(() => { //Note we don't fail on losing hauling designation //Because that's a special case anyway //If hauling to square storage, ensure storage dest is still valid Pawn actor = toilGoto.actor; Job curJob = actor.jobs.curJob; if (curJob.haulMode == HaulMode.ToSquareStorage) { Thing haulThing = curJob.GetTarget(TargetIndex.A).Thing; IntVec3 destLoc = actor.jobs.curJob.GetTarget(TargetIndex.B).Loc; if (!destLoc.IsValidStorageFor(haulThing)) { return(true); } } return(false); }); yield return(toilGoto); yield return(Toils_Haul.StartCarryThing(TargetIndex.A)); if (CurJob.haulOpportunisticDuplicates) { yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveTargetA)); } Toil carryToSquare = Toils_Haul.CarryHauledThingToSquare(TargetIndex.B); yield return(carryToSquare); yield return(Toils_Haul.PlaceHauledThingInSquare(TargetIndex.B, carryToSquare)); }
protected override IEnumerable <Toil> MakeNewToils() { /// //Set fail conditions /// this.FailOnDestroyedOrNull(CartInd); //Note we only fail on forbidden if the target doesn't start that way //This helps haul-aside jobs on forbidden items if (!TargetThingA.IsForbidden(pawn.Faction)) { this.FailOnForbidden(CartInd); } ThingWithComps cart = TargetThingA as ThingWithComps; if (ToolsForHaulUtility.FindStorageCell(pawn, cart) == IntVec3.Invalid) { JobFailReason.Is(ToolsForHaulUtility.NoEmptyPlaceForCart); } if (cart.TryGetComp <CompMountable>().Driver != null) { this.FailOnSomeonePhysicallyInteracting(CartInd); } /// //Define Toil /// Toil toilGoToCell = Toils_Goto.GotoCell(StoreCellInd, PathEndMode.ClosestTouch); /// //Toils Start /// //Reserve thing to be stored and storage cell yield return(Toils_Reserve.Reserve(CartInd)); yield return(Toils_Reserve.Reserve(StoreCellInd)); //JumpIf already mounted yield return(Toils_Jump.JumpIf(toilGoToCell, () => { return cart.TryGetComp <CompMountable>().Driver == pawn ? true : false; })); //Mount on Target yield return(Toils_Goto.GotoThing(CartInd, PathEndMode.ClosestTouch) .FailOnDestroyedOrNull(CartInd)); yield return(Toils_Cart.MountOn(CartInd)); //Dismount yield return(toilGoToCell); yield return(Toils_Cart.DismountAt(CartInd, StoreCellInd)); }
// Token: 0x0600008F RID: 143 RVA: 0x00005929 File Offset: 0x00003B29 protected override IEnumerable <Toil> MakeNewToils() { var actor = GetActor(); this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Reserve.Reserve(TargetIndex.A)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch) .FailOnDespawnedNullOrForbidden(TargetIndex.A)); var refuel = Toils_General.Wait(180); refuel.FailOnDespawnedNullOrForbidden(TargetIndex.A); refuel.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); refuel.WithProgressBarToilDelay(TargetIndex.A); yield return(refuel); yield return(new Toil { initAction = delegate { if (actor == null || actor.apparel.WornApparelCount <= 0) { EndJobWith(JobCondition.Incompletable); return; } Apparel GhostGear = null; var list = actor.apparel.WornApparel; foreach (var ghostGear in list) { if (ghostGear is not GhostGearApparel) { continue; } GhostGear = ghostGear; break; } if (GhostGear == null) { EndJobWith(JobCondition.Incompletable); return; } var CaltropsHave = (GhostGear as GhostGearApparel).CaltropsUses; var CaltropsMax = (GhostGear as GhostGearApparel).CaltropsMax; if (CaltropsMax - CaltropsHave <= 0) { EndJobWith(JobCondition.Incompletable); return; } var actorlabel = actor.LabelShort.CapitalizeFirst() != null ? actor.LabelShort.CapitalizeFirst() : "Someone"; var gglabel = GhostGear.Label.CapitalizeFirst() != null ? GhostGear.Label.CapitalizeFirst() : "Ghost Gear"; var def = TargetThingA.def; var thinglabel = def?.label.CapitalizeFirst() != null ? TargetThingA.def.label.CapitalizeFirst() : "Caltrops Pod"; if (TargetThingA.stackCount > CaltropsMax - CaltropsHave) { (GhostGear as GhostGearApparel).CaltropsUses = CaltropsMax; TargetThingA.stackCount -= CaltropsMax - CaltropsHave; if (Controller.Settings.ShowAutoRearmMsg) { Messages.Message("GhostGear.FullyRearmed".Translate(actorlabel, gglabel, thinglabel), actor, MessageTypeDefOf.NeutralEvent, false); } EndJobWith(JobCondition.Succeeded); return; } (GhostGear as GhostGearApparel).CaltropsUses = CaltropsHave + TargetThingA.stackCount; if (Controller.Settings.ShowAutoRearmMsg) { Messages.Message( "GhostGear.CaltropsRearmed".Translate(actorlabel, gglabel, TargetThingA.stackCount.ToString(), TargetThingA.stackCount > 1 ? "s" : "", thinglabel), actor, MessageTypeDefOf.NeutralEvent, false); } TargetThingA.Destroy(); EndJobWith(JobCondition.Succeeded); } });
protected override IEnumerable <Toil> MakeNewToils() { //Log.Message("Toil start:" + pawn + " is trying to learn " + project + ", globalFailConditions count:" + globalFailConditions.Count); Dictionary <ResearchProjectDef, float> expertise = pawn.TryGetComp <CompKnowledge>().expertise; AddEndCondition(delegate { if (!desk.Spawned) { return(JobCondition.Incompletable); } return(JobCondition.Ongoing); }); this.FailOnBurningImmobile(TargetIndex.A); this.FailOn(delegate() { IBillGiver billGiver = desk as IBillGiver; if (billGiver != null) { if (job.bill.DeletedOrDereferenced) { return(true); } if (!billGiver.CurrentlyUsableForBills()) { return(true); } if (project == null) { Log.Warning("[HumanResources] " + pawn + " tried to learn a null project."); TryMakePreToilReservations(true); return(true); } bool flag = IsResearch ? project.IsKnownBy(pawn) : !techComp.homework.Contains(project); if (flag) { return(true); } } return(false); }); Toil gotoBillGiver = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell); yield return(gotoBillGiver); Toil acquireKnowledge = new Toil(); acquireKnowledge.initAction = delegate() { Pawn actor = acquireKnowledge.actor; if (!expertise.ContainsKey(project)) { expertise.Add(project, 0f); } }; acquireKnowledge.AddEndCondition(delegate { Pawn actor = acquireKnowledge.actor; if (expertise.ContainsKey(project) && expertise[project] > 1f) { expertise[project] = 1f; if (!IsResearch) { Notify_IterationCompleted(actor, job.bill as Bill_Production); techComp.homework.Remove(project); } techComp.LearnCrops(project); Messages.Message("MessageStudyComplete".Translate(actor, project.LabelCap), desk, MessageTypeDefOf.TaskCompletion, true); project = null; return(JobCondition.Succeeded); } return(JobCondition.Ongoing); }); acquireKnowledge.tickAction = delegate() { Pawn actor = acquireKnowledge.actor; float num = actor.GetStatValue(StatDefOf.ResearchSpeed, true); num *= TargetThingA.GetStatValue(StatDefOf.ResearchSpeedFactor, true); float workAmount = IsResearch ? 1f : job.bill.recipe.workAmount; project.Learned(num, workAmount, actor, job.bill == null); actor.skills.Learn(SkillDefOf.Intellectual, 0.1f, false); actor.GainComfortFromCellIfPossible(true); }; acquireKnowledge.AddFinishAction(delegate { Pawn actor = acquireKnowledge.actor; if (job.bill != null && job.RecipeDef.workSkill != null) { float xp = ticksSpentDoingRecipeWork * 0.1f * job.RecipeDef.workSkillLearnFactor; actor.skills.GetSkill(job.RecipeDef.workSkill).Learn(xp, false); } }); acquireKnowledge.FailOn(() => project == null); //research.FailOn(() => !this.Project.CanBeResearchedAt(this.ResearchBench, false)); //need rework acquireKnowledge.FailOnCannotTouch(TargetIndex.A, PathEndMode.InteractionCell); acquireKnowledge.FailOnDespawnedOrNull(TargetIndex.A); acquireKnowledge.WithEffect(EffecterDefOf.Research, TargetIndex.A); acquireKnowledge.WithProgressBar(TargetIndex.A, delegate { if (project == null) { return(0f); } return(expertise[project]); }, false, -0.5f); acquireKnowledge.defaultCompleteMode = ToilCompleteMode.Delay; acquireKnowledge.defaultDuration = 4000; acquireKnowledge.activeSkill = () => SkillDefOf.Intellectual; yield return(acquireKnowledge); yield return(Toils_General.Wait(2, TargetIndex.None)); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { var upgrade = TargetThingA.FirstUpgradeableComp(); if (upgrade == null) { EndJobWith(JobCondition.Incompletable); yield break; } AddFailCondition(() => { var comp = TargetThingA.FirstUpgradeableComp(); return(comp == null || !comp.parent.Spawned || !comp.WantsWork); }); this.FailOnDestroyedNullOrForbidden(TargetIndex.A); var gotoUpgradeable = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.InteractionCell); var lookForIngredient = new Toil { initAction = () => { var missingIngredient = upgrade.TryGetNextMissingIngredient(); job.count = missingIngredient.Count; if (missingIngredient.Count > 0) { bool SearchPredicate(Thing thing) => !thing.IsForbidden(pawn) && pawn.CanReserve(thing); var t = GenClosest.ClosestThingReachable(pawn.Position, pawn.Map, ThingRequest.ForDef(missingIngredient.ThingDef), PathEndMode.ClosestTouch, TraverseParms.For(pawn), 999, SearchPredicate); if (t == null) { EndJobWith(JobCondition.Incompletable); } else { job.SetTarget(TargetIndex.B, t); } } else { JumpToToil(gotoUpgradeable); } } }; yield return(lookForIngredient); yield return(Toils_Reserve.Reserve(TargetIndex.B, 1, job.count)); yield return(Toils_Goto.GotoCell(TargetIndex.B, PathEndMode.Touch).FailOnDestroyedNullOrForbidden(TargetIndex.B)); yield return(Toils_Haul.StartCarryThing(TargetIndex.B)); yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.InteractionCell)); yield return(new Toil { initAction = () => { if (pawn.carryTracker.CarriedThing != null) { pawn.carryTracker.innerContainer.TryTransferToContainer(pawn.carryTracker.CarriedThing, upgrade.GetDirectlyHeldThings(), pawn.carryTracker.CarriedThing.stackCount); pawn.Map.reservationManager.ReleaseAllForTarget(TargetThingB); job.SetTarget(TargetIndex.B, null); JumpToToil(lookForIngredient); } } }); yield return(gotoUpgradeable); yield return(new Toil { tickAction = () => { upgrade.DoWork(GetActor().GetStatValue(StatDefOf.ConstructionSpeed)); if (upgrade.curComplete) { EndJobWith(JobCondition.Succeeded); } }, defaultCompleteMode = ToilCompleteMode.Never }.WithEffect(EffecterDefOf.ConstructMetal, TargetIndex.A) .WithProgressBar(TargetIndex.A, () => upgrade.WorkProgress)); } }
// Token: 0x0600003C RID: 60 RVA: 0x000038A6 File Offset: 0x00001AA6 protected override IEnumerable <Toil> MakeNewToils() { var actor = GetActor(); this.FailOnDespawnedNullOrForbidden(TargetIndex.A); yield return(Toils_Reserve.Reserve(TargetIndex.A)); yield return(Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.Touch) .FailOnDespawnedNullOrForbidden(TargetIndex.A)); var refuel = Toils_General.Wait(180); refuel.FailOnDespawnedNullOrForbidden(TargetIndex.A); refuel.FailOnCannotTouch(TargetIndex.A, PathEndMode.Touch); refuel.WithProgressBarToilDelay(TargetIndex.A); yield return(refuel); yield return(new Toil { initAction = delegate { var obj = actor; if (obj != null && obj.apparel.WornApparelCount == 0) { //Log.Message("True: obj != null && obj.apparel.WornApparelCount == 0"); EndJobWith(JobCondition.Incompletable); return; } Apparel JetPack = null; var list = actor.apparel.WornApparel; foreach (var jetPack in list) { if (jetPack is not JetPackApparel) { continue; } JetPack = jetPack; break; } if (JetPack == null) { EndJobWith(JobCondition.Incompletable); return; } //Log.Message("True: JetPack is JetPackApparel"); var JPFuel = (JetPack as JetPackApparel).JPFuelAmount; var JPMax = (JetPack as JetPackApparel).JPFuelMax; if (JPMax - JPFuel <= 0) { //Log.Message("True: JPMax - JPFuel <= 0"); EndJobWith(JobCondition.Incompletable); return; } if (TargetThingA.stackCount > JPMax - JPFuel) { //Log.Message("True: this.TargetThingA.stackCount > JPMax - JPFuel"); (JetPack as JetPackApparel).JPFuelAmount = JPMax; TargetThingA.stackCount -= JPMax - JPFuel; Messages.Message("JetPack.FullyRefueled".Translate(actor.LabelShort), actor, MessageTypeDefOf.NeutralEvent, false); EndJobWith(JobCondition.Succeeded); return; } //Log.Message("False"); (JetPack as JetPackApparel).JPFuelAmount = JPFuel + TargetThingA.stackCount; Messages.Message( "JetPack.Refueled".Translate(actor.LabelShort.CapitalizeFirst(), TargetThingA.stackCount.ToString(), TargetThingA.stackCount > 1 ? "s" : ""), actor, MessageTypeDefOf.NeutralEvent, false); TargetThingA.Destroy(); EndJobWith(JobCondition.Succeeded); } });
protected override IEnumerable <Toil> MakeNewToils() { //fail if can't do violence base.AddFailCondition(delegate { return(this.pawn.WorkTagIsDisabled(WorkTags.Violent)); }); this.jobStartTick = Find.TickManager.TicksGame; Func <bool> designationValidator = () => !( // Dummy must have the any designation TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignation) || // Dummy must have the melee designation, and the pawn has a melee weapon held TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignationMeleeOnly) && pawn.equipment.Primary.def.IsMeleeWeapon || // Dummy must have the ranged designation, and the pawn has a ranged weapon held TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignationRangedOnly) && pawn.equipment.Primary.def.IsRangedWeapon || // Dummy must have any designation, and the pawn is unarmed. (TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignation) || TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignationMeleeOnly) || TargetThingA.HasDesignation(CombatTrainingDefOf.TrainCombatDesignationRangedOnly)) && pawn.equipment.Primary == null); //make sure thing has train combat designation if (designationValidator()) { yield break; } // Make sure our dummy isn't already in use this.FailOnSomeonePhysicallyInteracting(TargetIndex.A); //fail if dummy is despawned null or forbidden this.FailOnDespawnedNullOrForbidden(TargetIndex.A); /**** START SWITCH TO TRAINING WEAPON ****/ //Pick up a training weapon if one is nearby. Remember previous weapon ThingWithComps startingEquippedWeapon = this.pawn.equipment.Primary; ThingWithComps trainingWeapon = null; if (startingEquippedWeapon == null || !startingEquippedWeapon.def.IsWithinCategory(CombatTrainingDefOf.TrainingWeapons)) { trainingWeapon = GetNearestTrainingWeapon(startingEquippedWeapon); if (trainingWeapon != null && !trainingWeapon.IsForbidden(pawn)) { //reserve training weapon, goto, and equip if (this.Map.reservationManager.CanReserve(this.pawn, trainingWeapon, 1, -1, null, false)) { this.pawn.Reserve(trainingWeapon, this.job, 1, -1, null, true); this.job.SetTarget(TargetIndex.B, trainingWeapon); yield return(Toils_Goto.GotoThing(TargetIndex.B, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.B)); yield return(CreateEquipToil(TargetIndex.B)); } //reserve previous weapon and set as target c if (this.Map.reservationManager.CanReserve(this.pawn, startingEquippedWeapon, 1, -1, null, false)) { this.pawn.Reserve(startingEquippedWeapon, this.job, 1, -1, null, true); this.job.SetTarget(TargetIndex.C, startingEquippedWeapon); } } } Toil reequipStartingWeaponLabel = Toils_General.Label(); /**** END SWITCH TO TRAINING WEAPON ****/ //set the job's attack verb to melee or shooting - needed to gotoCastPosition or stack overflow occurs yield return(Toils_Combat.TrySetJobToUseAttackVerb(TargetIndex.A)); //based on attack verb, go to cast position Toil gotoCastPos = Toils_Combat.GotoCastPosition(TargetIndex.A, true, 0.95f).EndOnDespawnedOrNull(TargetIndex.A); yield return(gotoCastPos); //try going to new cast position if the target can't be hit from current position yield return(Toils_Jump.JumpIfTargetNotHittable(TargetIndex.A, gotoCastPos)); //training loop - jump if done training -> cast verb -> jump to done training //if done training jumnp to reequipStartingWeaponLabel Toil doneTraining = Toils_Jump.JumpIf(reequipStartingWeaponLabel, delegate { if (LearningSaturated()) { return(true); } else { return(Dummy.Destroyed || Find.TickManager.TicksGame > this.jobStartTick + 5000 || designationValidator()); } }); yield return(doneTraining); Toil castVerb = Toils_Combat.CastVerb(TargetIndex.A, false); castVerb.AddFinishAction(delegate { LearnAttackSkill(); }); yield return(castVerb); yield return(Toils_Jump.Jump(doneTraining)); yield return(reequipStartingWeaponLabel); //gain room buff yield return(Toils_General.Do(delegate { TryGainCombatTrainingRoomThought(); })); //equip strating weapon if (trainingWeapon != null && startingEquippedWeapon != null) { yield return(Toils_Goto.GotoThing(TargetIndex.C, PathEndMode.ClosestTouch).FailOnDespawnedNullOrForbidden(TargetIndex.C)); yield return(CreateEquipToil(TargetIndex.C)); } yield break; }
protected override IEnumerable <Toil> MakeNewToils() { yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null)); yield return(Toils_Goto.GotoCell(TargetIndex.A, PathEndMode.Touch).FailOn(() => GenPlant.AdjacentSowBlocker(job.plantDefToSow, TargetA.Cell, Map) != null).FailOn(() => !job.plantDefToSow.CanEverPlantAt(TargetLocA, Map))); Toil sowToil = new Toil() { initAction = delegate { TargetThingA = GenSpawn.Spawn(job.plantDefToSow, TargetLocA, Map); pawn.Reserve(TargetThingA, job); PlantWithSecondary plant = (PlantWithSecondary)TargetThingA; plant.Growth = 0f; plant.sown = true; }, tickAction = delegate { Pawn actor = GetActor(); if (actor.skills != null) { actor.skills.Learn(SkillDefOf.Growing, 0.11f, false); } float statValue = actor.GetStatValue(StatDefOf.PlantWorkSpeed, true); float num = statValue; PlantWithSecondary plant = Plant; if (plant.LifeStage != PlantLifeStage.Sowing) { Log.Error(this + " getting sowing work while not in Sowing life stage."); } sowWorkDone += num; if (sowWorkDone >= plant.def.plant.sowWork) { plant.Growth = 0.05f; plant.Sec_Growth = 0.05f; Map.mapDrawer.MapMeshDirty(plant.Position, MapMeshFlag.Things); actor.records.Increment(RecordDefOf.PlantsSown); ReadyForNextToil(); return; } }, 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, true, -0.5f); sowToil.PlaySustainerOrSound(() => SoundDefOf.Interact_Sow); sowToil.AddFinishAction(delegate { if (TargetThingA != null) { PlantWithSecondary plant = (PlantWithSecondary)GetActor().CurJob.GetTarget(TargetIndex.A).Thing; if (sowWorkDone < plant.def.plant.sowWork && !TargetThingA.Destroyed) { TargetThingA.Destroy(DestroyMode.Vanish); } } }); yield return(sowToil); if (pawn.story.traits.HasTrait(TraitDefOf.GreenThumb)) { yield return(new Toil { initAction = delegate { pawn.needs.mood.thoughts.memories.TryGainMemory(ThoughtDefOf.GreenThumbHappy, null); } }); } }