public static TransferableOneWay TransferableMatchingDesperate(Thing thing, List <TransferableOneWay> transferables) { if (thing != null && transferables != null) { for (int i = 0; i < transferables.Count; i++) { TransferableOneWay transferableOneWay = transferables[i]; if (transferableOneWay.HasAnyThing && transferableOneWay.things.Contains(thing)) { return(transferableOneWay); } } for (int j = 0; j < transferables.Count; j++) { TransferableOneWay transferableOneWay2 = transferables[j]; if (transferableOneWay2.HasAnyThing && TransferableUtility.TransferAsOne(thing, transferableOneWay2.AnyThing)) { return(transferableOneWay2); } } for (int k = 0; k < transferables.Count; k++) { TransferableOneWay transferableOneWay3 = transferables[k]; if (transferableOneWay3.HasAnyThing && transferableOneWay3.ThingDef == thing.def) { return(transferableOneWay3); } } return(null); } return(null); }
private static int TransferableCountHauledByOthers(Pawn pawn, TransferableOneWay transferable, Lord lord) { if (!transferable.HasAnyThing) { Log.Warning("Can't determine transferable count hauled by others because transferable has 0 things.", false); return(0); } List <Pawn> allPawnsSpawned = lord.Map.mapPawns.AllPawnsSpawned; int num = 0; for (int i = 0; i < allPawnsSpawned.Count; i++) { Pawn pawn2 = allPawnsSpawned[i]; if (pawn2 != pawn) { if (pawn2.CurJob != null && pawn2.CurJob.def == JobDefOf.PrepareCaravan_GatherItems && pawn2.CurJob.lord == lord) { Thing toHaul = ((JobDriver_PrepareCaravan_GatherItems)pawn2.jobs.curDriver).ToHaul; if (transferable.things.Contains(toHaul) || TransferableUtility.TransferAsOne(transferable.AnyThing, toHaul, TransferAsOneMode.PodsOrCaravanPacking)) { num += toHaul.stackCount; } } } } return(num); }
public static Tradeable TradeableMatching(Thing thing, List <Tradeable> tradeables) { Tradeable result; if (thing == null || tradeables == null) { result = null; } else { for (int i = 0; i < tradeables.Count; i++) { Tradeable tradeable = tradeables[i]; if (tradeable.HasAnyThing) { TransferAsOneMode mode = (!tradeable.TraderWillTrade) ? TransferAsOneMode.InactiveTradeable : TransferAsOneMode.Normal; if (TransferableUtility.TransferAsOne(thing, tradeable.AnyThing, mode)) { return(tradeable); } } } result = null; } return(result); }
public static T TransferableMatching <T>(Thing thing, List <T> transferables, TransferAsOneMode mode) where T : Transferable { T result; if (thing == null || transferables == null) { result = (T)((object)null); } else { for (int i = 0; i < transferables.Count; i++) { T result2 = transferables[i]; if (result2.HasAnyThing) { if (TransferableUtility.TransferAsOne(thing, result2.AnyThing, mode)) { return(result2); } } } result = (T)((object)null); } return(result); }
public static Thing ThingFromStockToMergeWith(ITrader trader, Thing thing) { if (thing is Pawn) { return(null); } foreach (Thing good in trader.Goods) { if (TransferableUtility.TransferAsOne(good, thing, TransferAsOneMode.Normal) && good.CanStackWith(thing) && good.def.stackLimit != 1) { return(good); } } return(null); }
public static Thing ThingFromStockToMergeWith(ITrader trader, Thing thing) { if (thing is Pawn) { return(null); } foreach (Thing current in trader.Goods) { if (TransferableUtility.TransferAsOne(current, thing)) { return(current); } } return(null); }
public static T TransferableMatching <T>(Thing thing, List <T> transferables) where T : Transferable { if (thing != null && transferables != null) { for (int i = 0; i < transferables.Count; i++) { T result = transferables[i]; if (result.HasAnyThing && TransferableUtility.TransferAsOne(thing, result.AnyThing)) { return(result); } } return((T)null); } return((T)null); }
public static TransferableOneWay TransferableMatchingDesperate(Thing thing, List <TransferableOneWay> transferables, TransferAsOneMode mode) { TransferableOneWay result; if (thing == null || transferables == null) { result = null; } else { for (int i = 0; i < transferables.Count; i++) { TransferableOneWay transferableOneWay = transferables[i]; if (transferableOneWay.HasAnyThing) { if (transferableOneWay.things.Contains(thing)) { return(transferableOneWay); } } } for (int j = 0; j < transferables.Count; j++) { TransferableOneWay transferableOneWay2 = transferables[j]; if (transferableOneWay2.HasAnyThing) { if (TransferableUtility.TransferAsOne(thing, transferableOneWay2.AnyThing, mode)) { return(transferableOneWay2); } } } for (int k = 0; k < transferables.Count; k++) { TransferableOneWay transferableOneWay3 = transferables[k]; if (transferableOneWay3.HasAnyThing) { if (transferableOneWay3.ThingDef == thing.def) { return(transferableOneWay3); } } } result = null; } return(result); }
public static T TransferableMatching <T>(Thing thing, List <T> transferables) where T : Transferable { if (thing == null || transferables == null) { return((T)((object)null)); } for (int i = 0; i < transferables.Count; i++) { T result = transferables[i]; if (result.HasAnyThing) { if (TransferableUtility.TransferAsOne(thing, result.AnyThing)) { return(result); } } } return((T)((object)null)); }
public static Thing ThingFromStockToMergeWith(ITrader trader, Thing thing) { Thing result; if (thing is Pawn) { result = null; } else { foreach (Thing thing2 in trader.Goods) { if (TransferableUtility.TransferAsOne(thing2, thing, TransferAsOneMode.Normal) && thing2.CanStackWith(thing) && thing2.def.stackLimit != 1) { return(thing2); } } result = null; } return(result); }
private void AssignTransferablesToRandomTransporters() { tmpLeftToLoadCopy.Clear(); for (int j = 0; j < transporters.Count; j++) { tmpLeftToLoadCopy.Add((transporters[j].leftToLoad != null) ? transporters[j].leftToLoad.ToList() : new List <TransferableOneWay>()); if (transporters[j].leftToLoad != null) { transporters[j].leftToLoad.Clear(); } } tmpLeftCountToTransfer.Clear(); for (int k = 0; k < transferables.Count; k++) { tmpLeftCountToTransfer.Add(transferables[k], transferables[k].CountToTransfer); } if (LoadingInProgressOrReadyToLaunch) { int i; for (i = 0; i < transferables.Count; i++) { if (!transferables[i].HasAnyThing || tmpLeftCountToTransfer[transferables[i]] <= 0) { continue; } for (int l = 0; l < tmpLeftToLoadCopy.Count; l++) { TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching(transferables[i].AnyThing, tmpLeftToLoadCopy[l], TransferAsOneMode.PodsOrCaravanPacking); if (transferableOneWay != null) { int num = Mathf.Min(tmpLeftCountToTransfer[transferables[i]], transferableOneWay.CountToTransfer); if (num > 0) { transporters[l].AddToTheToLoadList(transferables[i], num); tmpLeftCountToTransfer[transferables[i]] -= num; } } Thing thing = transporters[l].innerContainer.FirstOrDefault((Thing x) => TransferableUtility.TransferAsOne(transferables[i].AnyThing, x, TransferAsOneMode.PodsOrCaravanPacking)); if (thing != null) { int num2 = Mathf.Min(tmpLeftCountToTransfer[transferables[i]], thing.stackCount); if (num2 > 0) { transporters[l].AddToTheToLoadList(transferables[i], num2); tmpLeftCountToTransfer[transferables[i]] -= num2; } } } } } tmpLeftToLoadCopy.Clear(); if (transferables.Any()) { TransferableOneWay transferableOneWay2 = transferables.MaxBy((TransferableOneWay x) => tmpLeftCountToTransfer[x]); int num3 = 0; for (int m = 0; m < transferables.Count; m++) { if (transferables[m] != transferableOneWay2 && tmpLeftCountToTransfer[transferables[m]] > 0) { transporters[num3 % transporters.Count].AddToTheToLoadList(transferables[m], tmpLeftCountToTransfer[transferables[m]]); num3++; } } if (num3 < transporters.Count) { int num4 = tmpLeftCountToTransfer[transferableOneWay2]; int num5 = num4 / (transporters.Count - num3); for (int n = num3; n < transporters.Count; n++) { int num6 = (n == transporters.Count - 1) ? num4 : num5; if (num6 > 0) { transporters[n].AddToTheToLoadList(transferableOneWay2, num6); } num4 -= num6; } } else { transporters[num3 % transporters.Count].AddToTheToLoadList(transferableOneWay2, tmpLeftCountToTransfer[transferableOneWay2]); } } tmpLeftCountToTransfer.Clear(); for (int num7 = 0; num7 < transporters.Count; num7++) { for (int num8 = 0; num8 < transporters[num7].innerContainer.Count; num8++) { Thing thing2 = transporters[num7].innerContainer[num8]; int num9 = transporters[num7].SubtractFromToLoadList(thing2, thing2.stackCount, sendMessageOnFinished: false); if (num9 < thing2.stackCount) { transporters[num7].innerContainer.TryDrop(thing2, ThingPlaceMode.Near, thing2.stackCount - num9, out Thing _); } } } }