コード例 #1
0
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDestroyedOrNull(CarryThingIndex);
            this.FailOnDestroyedNullOrForbidden(DestIndex);
            this.FailOn(() => Printer.printerStatus != CrafterStatus.Filling);

            //Reserve
            yield return(Toils_Reserve.Reserve(CarryThingIndex, 1, -1, null));

            yield return(Toils_Reserve.ReserveQueue(CarryThingIndex, 1, -1, null));

            yield return(Toils_Reserve.Reserve(DestIndex, 1, -1, null));

            yield return(Toils_Reserve.ReserveQueue(DestIndex, 1, -1, null));

            //Get to Haul target toil.
            Toil getToHaulTarget = Toils_Goto.GotoThing(CarryThingIndex, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(CarryThingIndex);

            yield return(getToHaulTarget);

            yield return(Toils_Construct.UninstallIfMinifiable(CarryThingIndex).FailOnSomeonePhysicallyInteracting(CarryThingIndex));

            yield return(Toils_Haul.StartCarryThing(CarryThingIndex, false, true));

            yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(getToHaulTarget, CarryThingIndex));

            //Carry to haul Container toil.
            Toil carryToContainer = Toils_Haul.CarryHauledThingToContainer();

            yield return(carryToContainer);
        }
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDestroyedOrNull(TargetIndex.A);
            this.FailOnDestroyedNullOrForbidden(TargetIndex.B);
            yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));

            yield return(Toils_Reserve.ReserveQueue(TargetIndex.A, 1));

            yield return(Toils_Reserve.Reserve(TargetIndex.B, 1));

            yield return(Toils_Reserve.ReserveQueue(TargetIndex.B, 1));

            Toil toil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);

            yield return(toil);

            yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true));

            yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toil, TargetIndex.A));

            Toil toil2 = Toils_Goto.Goto(TargetIndex.B, PathEndMode.ClosestTouch);

            yield return(toil2);

            Toil toil3 = new Toil();

            toil3.defaultCompleteMode = ToilCompleteMode.Delay;
            toil3.defaultDuration     = 500;
            toil3.WithProgressBarToilDelay(TargetIndex.A, false, -0.5f);
            yield return(toil3);

            yield return(new Toil
            {
                initAction = delegate
                {
                    ShipBase ship = (ShipBase)TargetB.Thing;
                    ThingWithComps thing = (ThingWithComps)TargetA.Thing;
                    CompShipWeapon comp = thing.TryGetComp <CompShipWeapon>();

                    Action action = delegate
                    {
                        if (ship.TryInstallTurret(comp.slotToInstall, comp))
                        {
                            this.pawn.carryTracker.GetInnerContainer().Remove(TargetA.Thing);
                            ship.weaponsToInstall.Remove(comp.slotToInstall);
                        }
                    };

                    action();
                },

                defaultCompleteMode = ToilCompleteMode.Instant
            });

            yield break;
        }
コード例 #3
0
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDestroyedOrNull(TargetIndex.A);
            this.FailOnDespawnedOrNull(TargetIndex.B);
            yield return(Toils_Reserve.Reserve(TargetIndex.A, 1, 1, null));

            yield return(Toils_Reserve.ReserveQueue(TargetIndex.A, 1, 1, null));

            //yield return Toils_Reserve.Reserve(TargetIndex.B, 10, 1, null);
            //yield return Toils_Reserve.ReserveQueue(TargetIndex.B, 10, 1, null);
            Toil toil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);

            //toil.AddFailCondition(() => ShipFull(ship));
            toil.tickAction += delegate
            {
                if (this.ShipFull(ship))
                {
                    this.EndJobWith(JobCondition.Incompletable);
                }
            };
            yield return(toil);

            yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));

            Toil toilPickup = Toils_Haul.StartCarryThing(TargetIndex.A, false, true);//.FailOn(() => this.ShipFull(ship));

            yield return(toilPickup);

            yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toil, TargetIndex.A));

            Toil toil2 = Toils_Haul.CarryHauledThingToContainer();

            toil2.tickAction += delegate
            {
                if (this.ShipFull(ship, false))
                {
                    this.EndJobWith(JobCondition.Incompletable);
                }
            };
            yield return(toil2);

            yield return(Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B));

            yield return(Toils_Construct.MakeSolidThingFromBlueprintIfNecessary(TargetIndex.B));

            Toil toil3 = Toils_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.C);

            //toil3.AddFailCondition(() => this.ShipFull(ship));
            yield return(toil3);

            yield return(Toils_Haul.JumpToCarryToNextContainerIfPossible(toil2, TargetIndex.C));

            yield break;
        }
コード例 #4
0
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDestroyedOrNull(TargetIndex.A);
            this.FailOnDestroyedNullOrForbidden(TargetIndex.B);
            ShipBase ship = (ShipBase)TargetB;

            yield return(Toils_Reserve.Reserve(TargetIndex.A, 1));

            yield return(Toils_Reserve.ReserveQueue(TargetIndex.A, 1));

            yield return(Toils_Reserve.Reserve(TargetIndex.B, 10));

            yield return(Toils_Reserve.ReserveQueue(TargetIndex.B, 10));

            Toil toil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);

            yield return(toil);

            yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));

            yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true));

            yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toil, TargetIndex.A));

            Toil toil2 = Toils_Haul.CarryHauledThingToContainer();

            yield return(toil2);

            yield return(Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B));

            yield return(Toils_Construct.MakeSolidThingFromBlueprintIfNecessary(TargetIndex.B));

            Toil finalToil = Toils_Haul.DepositHauledThingInContainer(TargetIndex.B);

            finalToil.AddFinishAction(delegate
            {
                ship.compShip.SubtractFromToLoadList(TargetA.Thing);
            });
            yield return(finalToil);

            yield return(Toils_Haul.JumpToCarryToNextContainerIfPossible(toil2));

            yield break;
        }
コード例 #5
0
        protected override IEnumerable <Toil> MakeNewToils()
        {
            this.FailOnDestroyedOrNull(TargetIndex.A);
            this.FailOnDespawnedOrNull(TargetIndex.B);
            Toil toil = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);

            toil.AddFinishAction(delegate { Log.Message("Finished A"); });
            //toil.AddFailCondition(() => ShipFull(ship));
            toil.tickAction += delegate
            {
                if (this.ShipFull(ship))
                {
                    this.EndJobWith(JobCondition.Incompletable);
                }
            };
            yield return(toil);

            yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));

            Toil toilPickup = Toils_Haul.StartCarryThing(TargetIndex.A, false, true);//.FailOn(() => this.ShipFull(ship));

            yield return(toilPickup);

            yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toil, TargetIndex.A));

            Toil toil2 = Toils_Haul.CarryHauledThingToContainer();

            toil2.tickAction += delegate
            {
                if (this.ShipFull(ship, false))
                {
                    this.EndJobWith(JobCondition.Incompletable);
                }
            };
            yield return(toil2);

            Toil toil3 = Toils_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.None);

            //toil3.AddFailCondition(() => this.ShipFull(ship));
            yield return(toil3);

            yield break;
        }
コード例 #6
0
        protected override IEnumerable <Toil> MakeNewToils()
        {
            // This is mostly the same list of toils as HaulToContainer, except without reserving the container,
            // and also added some things from JobDriver_PrepareCaravan_GatherItems that handle coordination between
            // colonists. Many of the toils here seem to be intended for construction jobs and are thus probably not
            // necessary, but I'm leaving them in just in case. Possibly another mod will assume they're there, who knows.
            this.FailOnDestroyedOrNull(TargetIndex.A);
            this.FailOnDestroyedNullOrForbidden(TargetIndex.B);
            this.FailOn(() => TransporterUtility.WasLoadingCanceled(this.Transporter));
            Toil reserve = Toils_Reserve.Reserve(TargetIndex.A, 1, -1, null).FailOnDespawnedOrNull(TargetIndex.A);

            yield return(reserve);

            //yield return Toils_Reserve.ReserveQueue(TargetIndex.A, 1, -1, null);
            Toil getToHaulTarget = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A);

            yield return(getToHaulTarget);

            yield return(DetermineNumToHaul());

            yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));

            yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true));

            yield return(AddCarriedThingToTransferables());

            yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserve, TargetIndex.A, TargetIndex.None, true, (Thing x) => Transferable.things.Contains(x)));

            yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(getToHaulTarget, TargetIndex.A));

            Toil carryToContainer = Toils_Haul.CarryHauledThingToContainer();

            yield return(carryToContainer);

            yield return(Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B));

            yield return(Toils_Construct.MakeSolidThingFromBlueprintIfNecessary(TargetIndex.B, TargetIndex.C));

            yield return(Toils_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.C));

            yield return(Toils_Haul.JumpToCarryToNextContainerIfPossible(carryToContainer, TargetIndex.C));
        }
コード例 #7
0
        public override IEnumerable <Toil> MakeNewToils()
        {
            Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - var ZTracker = ZUtils.ZTracker; - 5", true);
            var ZTracker = ZUtils.ZTracker;

            yield return(new Toil
            {
                initAction = delegate()
                {
                    Log.Message("pawn.Map: " + pawn.Map);
                    Log.Message("this.job.targetA.Thing.Map: " + this.job.targetA.Thing?.Map);
                    Log.Message("ZTracker.jobTracker[pawn].targetDest.Map: " + ZTracker.jobTracker[pawn].targetDest.Map);

                    if (pawn.Map == this.job.targetA.Thing?.Map && pawn.Map == ZTracker.jobTracker[pawn].targetDest.Map)
                    {
                        ZLogger.Message("pawn map and thing map and dest map are same, yield breaking in JobDriver_HaulThingToDest");
                        this.EndJobWith(JobCondition.InterruptForced);
                    }
                    this.savedThing = this.job.targetA.Thing;
                }
            });

            Toil reserveItem = Toils_Reserve.Reserve(TargetIndex.A);

            Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (TargetA.Thing?.Map != null) - 12", true);
            if (TargetA.Thing?.Map != null)
            {
                Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - foreach (var toil in Toils_ZLevels.GoToMap(GetActor(), new TargetInfo(TargetA.Thing).Map, this)) - 13", true);
                foreach (var toil in Toils_ZLevels.GoToMap(GetActor(), new TargetInfo(TargetA.Thing).Map, this))
                {
                    yield return(new Toil {
                        initAction = delegate() { Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - yield return toil; - 14", true); }
                    });

                    yield return(toil);
                }
            }

            Toil toilGoto = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch);

            yield return(new Toil {
                initAction = delegate() { Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - yield return reserveItem.FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A); - 16", true); }
            });

            yield return(reserveItem.FailOnDespawnedNullOrForbidden(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A));

            yield return(new Toil {
                initAction = delegate() { Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - yield return toilGoto; - 17", true); }
            });

            yield return(toilGoto);

            yield return(new Toil {
                initAction = delegate() { Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - yield return Toils_Haul.StartCarryThing(TargetIndex.A, putRemainderInQueue: false, subtractNumTakenFromJobCount: true).FailOnDestroyedNullOrForbidden(TargetIndex.A); - 18", true); }
            });

            yield return(Toils_Haul.StartCarryThing(TargetIndex.A, putRemainderInQueue: false, subtractNumTakenFromJobCount: true).FailOnDestroyedNullOrForbidden(TargetIndex.A));

            Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (job.haulOpportunisticDuplicates) - 19", true);
            if (job.haulOpportunisticDuplicates)
            {
                yield return(new Toil {
                    initAction = delegate() { Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - yield return Toils_Haul.CheckForGetOpportunityDuplicate(reserveItem, TargetIndex.A, TargetIndex.None, takeFromValidStorage: true); - 20", true); }
                });

                yield return(Toils_Haul.CheckForGetOpportunityDuplicate(reserveItem, TargetIndex.A, TargetIndex.None, takeFromValidStorage: true));
            }
            yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(toilGoto, TargetIndex.A));

            yield return(new Toil
            {
                initAction = delegate()
                {
                    Log.Message("Pawn: " + pawn);
                    Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (ZTracker.jobTracker.TryGetValue(pawn, out JobTracker jobTracker)) - 23", true);
                    if (ZTracker.jobTracker.TryGetValue(pawn, out JobTracker jobTracker))
                    {
                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (jobTracker.mainJob.targetA.Thing != null && jobTracker.mainJob.targetA.Thing == this.savedThing && jobTracker.mainJob.targetA.Thing != TargetA.Thing) - 24", true);
                        if (jobTracker.mainJob.targetA.Thing != null && jobTracker.mainJob.targetA.Thing == this.savedThing && jobTracker.mainJob.targetA.Thing != TargetA.Thing)
                        {
                            Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.targetA = new LocalTargetInfo(TargetA.Thing); - 25", true);
                            jobTracker.mainJob.targetA = new LocalTargetInfo(TargetA.Thing);
                        }
                        else if (jobTracker.mainJob.targetB.Thing != null && jobTracker.mainJob.targetB.Thing == this.savedThing && jobTracker.mainJob.targetB.Thing != TargetA.Thing)
                        {
                            Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.targetB = new LocalTargetInfo(TargetA.Thing); - 27", true);
                            jobTracker.mainJob.targetB = new LocalTargetInfo(TargetA.Thing);
                        }
                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (jobTracker.mainJob.targetQueueA != null) - 28", true);
                        if (jobTracker.mainJob.targetQueueA != null)
                        {
                            for (int i = jobTracker.mainJob.targetQueueA.Count - 1; i >= 0; i--)
                            {
                                Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - var target = jobTracker.mainJob.targetQueueA[i]; - 29", true);
                                var target = jobTracker.mainJob.targetQueueA[i];
                                Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetA.Thing) - 30", true);
                                if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetA.Thing)
                                {
                                    Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.targetQueueA[i] = new LocalTargetInfo(TargetA.Thing); - 31", true);
                                    jobTracker.mainJob.targetQueueA[i] = new LocalTargetInfo(TargetA.Thing);
                                }
                            }
                        }
                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (jobTracker.mainJob.targetQueueB != null) - 32", true);
                        if (jobTracker.mainJob.targetQueueB != null)
                        {
                            for (int i = jobTracker.mainJob.targetQueueB.Count - 1; i >= 0; i--)
                            {
                                Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - var target = jobTracker.mainJob.targetQueueB[i]; - 33", true);
                                var target = jobTracker.mainJob.targetQueueB[i];
                                Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetA.Thing) - 34", true);
                                if (target.Thing != null && target.Thing == this.savedThing && target.Thing != TargetA.Thing)
                                {
                                    Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - if (jobTracker.mainJob.targetQueueB[i].Thing.stackCount == 0) - 35", true);
                                    if (jobTracker.mainJob.targetQueueB[i].Thing.stackCount == 0)
                                    {
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.targetQueueB[i] = new LocalTargetInfo(TargetA.Thing); - 36", true);
                                        jobTracker.mainJob.targetQueueB[i] = new LocalTargetInfo(TargetA.Thing);
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.countQueue[i] = TargetA.Thing.stackCount; - 37", true);
                                        jobTracker.mainJob.countQueue[i] = TargetA.Thing.stackCount;
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - break; - 38", true);
                                        break;
                                    }
                                    else if (!jobTracker.mainJob.targetQueueB.Any(x => x.Thing == TargetA.Thing))
                                    {
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - var newTarget = new LocalTargetInfo(TargetA.Thing); - 40", true);
                                        var newTarget = new LocalTargetInfo(TargetA.Thing);
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.targetQueueB.Add(newTarget); - 41", true);
                                        jobTracker.mainJob.targetQueueB.Add(newTarget);
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.countQueue.Add(newTarget.Thing.stackCount); - 42", true);
                                        jobTracker.mainJob.countQueue.Add(newTarget.Thing.stackCount);
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - int ind = jobTracker.mainJob.targetQueueB.FirstIndexOf(x => x.Thing == this.savedThing); - 43", true);
                                        int ind = jobTracker.mainJob.targetQueueB.FirstIndexOf(x => x.Thing == this.savedThing);
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.targetQueueB.RemoveAt(ind); - 44", true);
                                        jobTracker.mainJob.targetQueueB.RemoveAt(ind);
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - jobTracker.mainJob.countQueue.RemoveAt(ind); - 45", true);
                                        jobTracker.mainJob.countQueue.RemoveAt(ind);
                                        Log.Message("JobDriver_HaulThingToDest : JobDriver_ZLevels - MakeNewToils - break; - 46", true);
                                        break;
                                    }
                                }
                            }
                        }
                    }
                }
            });