protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TargetIndex.A); this.FailOnDestroyedNullOrForbidden(TargetIndex.B); this.FailOn(() => TransporterUtility.WasLoadingCanceled(((_003CMakeNewToils_003Ec__Iterator0) /*Error near IL_0065: stateMachine*/)._0024this.Container)); this.FailOn(delegate { ThingOwner thingOwner = ((_003CMakeNewToils_003Ec__Iterator0) /*Error near IL_007d: stateMachine*/)._0024this.Container.TryGetInnerInteractableThingOwner(); if (thingOwner != null && !thingOwner.CanAcceptAnyOf(((_003CMakeNewToils_003Ec__Iterator0) /*Error near IL_007d: stateMachine*/)._0024this.ThingToCarry)) { return(true); } IHaulDestination haulDestination = ((_003CMakeNewToils_003Ec__Iterator0) /*Error near IL_007d: stateMachine*/)._0024this.Container as IHaulDestination; if (haulDestination != null && !haulDestination.Accepts(((_003CMakeNewToils_003Ec__Iterator0) /*Error near IL_007d: stateMachine*/)._0024this.ThingToCarry)) { return(true); } return(false); }); Toil getToHaulTarget = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A); yield return(getToHaulTarget); /*Error: Unable to find new state assignment for yield return*/; }
public static Toil CarryHauledThingToContainer() { Toil gotoDest = new Toil(); gotoDest.initAction = delegate { gotoDest.actor.pather.StartPath(gotoDest.actor.jobs.curJob.targetB.Thing, PathEndMode.Touch); }; gotoDest.AddFailCondition(delegate { Thing thing = gotoDest.actor.jobs.curJob.targetB.Thing; if (!thing.Destroyed && !thing.IsForbidden(gotoDest.actor)) { ThingOwner thingOwner = thing.TryGetInnerInteractableThingOwner(); if (thingOwner != null && !thingOwner.CanAcceptAnyOf(gotoDest.actor.carryTracker.CarriedThing, true)) { return(true); } return(false); } return(true); }); gotoDest.defaultCompleteMode = ToilCompleteMode.PatherArrival; return(gotoDest); }
public virtual bool Accepts(Thing thing) { if (itemFilterComp == null || itemFilterComp.NotSet || itemFilterComp.AcceptsHowMany(thing) > 0) { return(innerContainer.CanAcceptAnyOf(thing, true)); } return(false); }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TargetIndex.A); this.FailOnDestroyedNullOrForbidden(TargetIndex.B); this.FailOn(() => TransporterUtility.WasLoadingCanceled(this.Container)); this.FailOn(delegate() { ThingOwner thingOwner = this.Container.TryGetInnerInteractableThingOwner(); bool result; if (thingOwner != null && !thingOwner.CanAcceptAnyOf(this.ThingToCarry, true)) { result = true; } else { IHaulDestination haulDestination = this.Container as IHaulDestination; result = (haulDestination != null && !haulDestination.Accepts(this.ThingToCarry)); } return(result); }); Toil getToHaulTarget = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A); yield return(getToHaulTarget); yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, false, true, false)); yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(getToHaulTarget, TargetIndex.A)); Toil carryToContainer = Toils_Haul.CarryHauledThingToContainer(); yield return(carryToContainer); yield return(Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B)); Toil prepare = Toils_General.Wait(this.Duration, TargetIndex.B); prepare.WithProgressBarToilDelay(TargetIndex.B, false, -0.5f); yield return(prepare); 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)); yield break; }
protected override IEnumerable <Toil> MakeNewToils() { this.FailOnDestroyedOrNull(TargetIndex.A); this.FailOnDestroyedNullOrForbidden(TargetIndex.B); this.FailOn(() => TransporterUtility.WasLoadingCanceled(Container)); this.FailOn(delegate { ThingOwner thingOwner = Container.TryGetInnerInteractableThingOwner(); if (thingOwner != null && !thingOwner.CanAcceptAnyOf(ThingToCarry)) { return(true); } IHaulDestination haulDestination = Container as IHaulDestination; return((haulDestination != null && !haulDestination.Accepts(ThingToCarry)) ? true : false); }); Toil getToHaulTarget = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A); yield return(getToHaulTarget); yield return(Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A)); yield return(Toils_Haul.StartCarryThing(TargetIndex.A, putRemainderInQueue: false, subtractNumTakenFromJobCount: true)); yield return(Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(getToHaulTarget, TargetIndex.A)); Toil carryToContainer = Toils_Haul.CarryHauledThingToContainer(); yield return(carryToContainer); yield return(Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B)); Toil toil = Toils_General.Wait(Duration, TargetIndex.B); toil.WithProgressBarToilDelay(TargetIndex.B); yield return(toil); 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)); }
public virtual bool Accepts(Thing thing) { return(innerContainer.CanAcceptAnyOf(thing)); }
public bool MoveNext() { uint num = (uint)this.$PC; this.$PC = -1; switch (num) { case 0u: this.FailOnDestroyedOrNull(TargetIndex.A); this.FailOnDestroyedNullOrForbidden(TargetIndex.B); this.FailOn(() => TransporterUtility.WasLoadingCanceled(base.Container)); this.FailOn(delegate() { ThingOwner thingOwner = base.Container.TryGetInnerInteractableThingOwner(); bool result; if (thingOwner != null && !thingOwner.CanAcceptAnyOf(base.ThingToCarry, true)) { result = true; } else { IHaulDestination haulDestination = base.Container as IHaulDestination; result = (haulDestination != null && !haulDestination.Accepts(base.ThingToCarry)); } return(result); }); getToHaulTarget = Toils_Goto.GotoThing(TargetIndex.A, PathEndMode.ClosestTouch).FailOnSomeonePhysicallyInteracting(TargetIndex.A); this.$current = getToHaulTarget; if (!this.$disposing) { this.$PC = 1; } return(true); case 1u: this.$current = Toils_Construct.UninstallIfMinifiable(TargetIndex.A).FailOnSomeonePhysicallyInteracting(TargetIndex.A); if (!this.$disposing) { this.$PC = 2; } return(true); case 2u: this.$current = Toils_Haul.StartCarryThing(TargetIndex.A, false, true, false); if (!this.$disposing) { this.$PC = 3; } return(true); case 3u: this.$current = Toils_Haul.JumpIfAlsoCollectingNextTargetInQueue(getToHaulTarget, TargetIndex.A); if (!this.$disposing) { this.$PC = 4; } return(true); case 4u: carryToContainer = Toils_Haul.CarryHauledThingToContainer(); this.$current = carryToContainer; if (!this.$disposing) { this.$PC = 5; } return(true); case 5u: this.$current = Toils_Goto.MoveOffTargetBlueprint(TargetIndex.B); if (!this.$disposing) { this.$PC = 6; } return(true); case 6u: prepare = Toils_General.Wait(base.Duration, TargetIndex.B); prepare.WithProgressBarToilDelay(TargetIndex.B, false, -0.5f); this.$current = prepare; if (!this.$disposing) { this.$PC = 7; } return(true); case 7u: this.$current = Toils_Construct.MakeSolidThingFromBlueprintIfNecessary(TargetIndex.B, TargetIndex.C); if (!this.$disposing) { this.$PC = 8; } return(true); case 8u: this.$current = Toils_Haul.DepositHauledThingInContainer(TargetIndex.B, TargetIndex.C); if (!this.$disposing) { this.$PC = 9; } return(true); case 9u: this.$current = Toils_Haul.JumpToCarryToNextContainerIfPossible(carryToContainer, TargetIndex.C); if (!this.$disposing) { this.$PC = 10; } return(true); case 10u: this.$PC = -1; break; } return(false); }
public static bool TryAdd(ThingOwner <Thing> __instance, ref bool __result, Thing item, bool canMergeWithExistingStacks = true) { if (item == null) { Log.Warning("Tried to add null item to ThingOwner.", false); __result = false; return(false); } if (!(item is Thing obj)) { __result = false; return(false); } if (__instance.Contains(item)) { Log.Warning("Tried to add " + item.ToStringSafe <Thing>() + " to ThingOwner but this item is already here.", false); __result = false; return(false); } if (item.holdingOwner != null) { Log.Warning("Tried to add " + item.ToStringSafe <Thing>() + " to ThingOwner but this thing is already in another container. owner=" + __instance.Owner.ToStringSafe <IThingHolder>() + ", current container owner=" + item.holdingOwner.Owner.ToStringSafe <IThingHolder>() + ". Use TryAddOrTransfer, TryTransferToContainer, or remove the item before adding it.", false); __result = false; return(false); } if (!__instance.CanAcceptAnyOf(item, canMergeWithExistingStacks)) { __result = false; return(false); } if (canMergeWithExistingStacks) { for (int index = 0; index < innerList(__instance).Count; ++index) { Thing inner = innerList(__instance)[index]; if (inner.CanStackWith(item)) { int count = Mathf.Min(item.stackCount, inner.def.stackLimit - inner.stackCount); if (count > 0) { Thing other = item.SplitOff(count); int stackCount = inner.stackCount; inner.TryAbsorbStack(other, true); if (inner.stackCount > stackCount) { NotifyAddedAndMergedWith(__instance, (Thing)inner, inner.stackCount - stackCount); } if (item.Destroyed || item.stackCount == 0) { __result = true; return(false); } } } } } if (__instance.Count >= maxStacks(__instance)) { __result = false; return(false); } item.holdingOwner = (ThingOwner)__instance; lock (innerList(__instance)) { innerList(__instance).Add(obj); } NotifyAdded(__instance, (Thing)obj); __result = true; return(false); }