public static List <TransferableOneWay> LinkPortablePlatforms(List <TransferableOneWay> transferables)
{
List <Pawn> pawns = TransferableUtility.GetPawnsFromTransferables(transferables);
Predicate <Thing> isChargingPlatform = (Thing t) => t != null && t.GetInnerIfMinified().def == WTH_DefOf.WTH_PortableChargingPlatform;
List <TransferableOneWay> chargingPlatformTows = transferables.FindAll((TransferableOneWay x) => x.CountToTransfer > 0 && x.HasAnyThing && isChargingPlatform(x.AnyThing));
List <Building_PortableChargingPlatform> platforms = new List <Building_PortableChargingPlatform>();
foreach (TransferableOneWay tow in chargingPlatformTows)
{
foreach (Thing t in tow.things)
{
Building_PortableChargingPlatform platform = (Building_PortableChargingPlatform)t.GetInnerIfMinified();
platform.CaravanPawn = null;
}
}
//Find and assign platform for each pawn.
foreach (Pawn pawn in pawns)
{
if (pawn.IsHacked() && !pawn.health.hediffSet.HasHediff(WTH_DefOf.WTH_VanometricModule))
{
bool foundPlatform = false;
for (int j = 0; j < chargingPlatformTows.Count && !foundPlatform; j++)
{
for (int i = 0; i < chargingPlatformTows[j].things.Count && !foundPlatform; i++)
{
Building_PortableChargingPlatform platform = (Building_PortableChargingPlatform)chargingPlatformTows[j].things[i].GetInnerIfMinified();
if (platform != null && platform.CaravanPawn == null)
{
platform.CaravanPawn = pawn;
ExtendedPawnData pawnData = Base.Instance.GetExtendedDataStorage().GetExtendedDataFor(pawn);
pawnData.caravanPlatform = platform;
foundPlatform = true;
}
}
}
}
}
return(transferables);
}
public static float ApproxDaysUntilRotLeftAfterTransfer(List <TransferableOneWay> transferables, int tile, IgnorePawnsInventoryMode ignoreInventory, WorldPath path = null, float nextTileCostLeft = 0f, int caravanTicksPerMove = 3300)
{
DaysUntilRotCalculator.tmpThingCounts.Clear();
for (int i = 0; i < transferables.Count; i++)
{
TransferableOneWay transferableOneWay = transferables[i];
if (transferableOneWay.HasAnyThing)
{
if (transferableOneWay.AnyThing is Pawn)
{
for (int j = transferableOneWay.things.Count - 1; j >= transferableOneWay.CountToTransfer; j--)
{
Pawn pawn = (Pawn)transferableOneWay.things[j];
if (!InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawn, ignoreInventory))
{
ThingOwner <Thing> innerContainer = pawn.inventory.innerContainer;
for (int k = 0; k < innerContainer.Count; k++)
{
DaysUntilRotCalculator.tmpThingCounts.Add(new ThingCount(innerContainer[k], innerContainer[k].stackCount));
}
}
}
}
else if (transferableOneWay.MaxCount - transferableOneWay.CountToTransfer > 0)
{
DaysUntilRotCalculator.thingsInReverse.Clear();
DaysUntilRotCalculator.thingsInReverse.AddRange(transferableOneWay.things);
DaysUntilRotCalculator.thingsInReverse.Reverse();
TransferableUtility.TransferNoSplit(DaysUntilRotCalculator.thingsInReverse, transferableOneWay.MaxCount - transferableOneWay.CountToTransfer, delegate(Thing thing, int count)
{
DaysUntilRotCalculator.tmpThingCounts.Add(new ThingCount(thing, count));
}, false, false);
}
}
}
DaysUntilRotCalculator.thingsInReverse.Clear();
float result = DaysUntilRotCalculator.ApproxDaysUntilRot(DaysUntilRotCalculator.tmpThingCounts, tile, path, nextTileCostLeft, caravanTicksPerMove);
DaysUntilRotCalculator.tmpThingCounts.Clear();
return(result);
}
private bool TrySplitCaravan()
{
List <Pawn> pawns = TransferableUtility.GetPawnsFromTransferables(this.transferables);
if (!this.CheckForErrors(pawns))
{
return(false);
}
for (int i = 0; i < pawns.Count; i++)
{
CaravanInventoryUtility.MoveAllInventoryToSomeoneElse(pawns[i], this.caravan.PawnsListForReading, pawns);
}
Caravan caravan = (Caravan)WorldObjectMaker.MakeWorldObject(WorldObjectDefOf.Caravan);
caravan.Tile = this.caravan.Tile;
caravan.SetFaction(this.caravan.Faction);
caravan.Name = CaravanNameGenerator.GenerateCaravanName(caravan);
Find.WorldObjects.Add(caravan);
for (int j = 0; j < pawns.Count; j++)
{
this.caravan.RemovePawn(pawns[j]);
caravan.AddPawn(pawns[j], true);
}
this.transferables.RemoveAll((TransferableOneWay x) => x.AnyThing is Pawn);
for (int k = 0; k < this.transferables.Count; k++)
{
TransferableUtility.TransferNoSplit(this.transferables[k].things, this.transferables[k].CountToTransfer, delegate(Thing thing, int numToTake)
{
Pawn ownerOf = CaravanInventoryUtility.GetOwnerOf(this.caravan, thing);
if (ownerOf == null)
{
Log.Error("Error while splitting a caravan: Thing " + thing + " has no owner. Where did it come from then?");
}
else
{
CaravanInventoryUtility.MoveInventoryToSomeoneElse(ownerOf, thing, pawns, null, numToTake);
}
}, true, true);
}
return(true);
}
public void AddToTheToLoadList(TransferableOneWay t, int count)
{
if (!t.HasAnyThing || t.CountToTransfer <= 0)
{
return;
}
if (this.leftToLoad == null)
{
this.leftToLoad = new List <TransferableOneWay>();
}
if (TransferableUtility.TransferableMatching <TransferableOneWay>(t.AnyThing, this.leftToLoad, TransferAsOneMode.PodsOrCaravanPacking) != null)
{
Log.Error("Transferable already exists.", false);
return;
}
TransferableOneWay transferableOneWay = new TransferableOneWay();
this.leftToLoad.Add(transferableOneWay);
transferableOneWay.things.AddRange(t.things);
transferableOneWay.AdjustTo(count);
}
private bool DockBoatTransferPawns()
{
DockedBoat dockedBoat = (DockedBoat)WorldObjectMaker.MakeWorldObject(WorldObjectDefOfShips.DockedBoat);
dockedBoat.Tile = caravan.Tile;
float randomInRange = Rand.Range(2f, 4f) + (50 * (1 - caravan.PawnsListForReading.Where(x => HelperMethods.IsShip(x)).Max(x => x.GetComp <CompShips>().Props.visibility)));
dockedBoat.GetComponent <TimeoutComp>().StartTimeout(Mathf.CeilToInt(randomInRange * 60000));
List <Pawn> boats = caravan.PawnsListForReading.Where(x => HelperMethods.IsShip(x)).ToList();
List <Pawn> pawns = caravan.PawnsListForReading.Where(x => !HelperMethods.IsShip(x)).ToList();
if (caravan.PawnsListForReading.Where(x => !HelperMethods.IsShip(x)).Count() <= 0)
{
return(false);
}
foreach (TransferableOneWay t in this.transferables)
{
TransferableUtility.TransferNoSplit(t.things, t.CountToTransfer, delegate(Thing thing, int numToTake)
{
Pawn ownerOf = CaravanInventoryUtility.GetOwnerOf(this.caravan, thing);
if (ownerOf is null)
{
return;
}
CaravanInventoryUtility.MoveInventoryToSomeoneElse(ownerOf, thing, pawns, boats, numToTake);
}, true, true);
}
for (int i = caravan.pawns.Count - 1; i >= 0; i--)
{
Pawn p = caravan.PawnsListForReading[i];
if (HelperMethods.IsShip(p))
{
dockedBoat.dockedBoats.TryAddOrTransfer(p, false);
}
}
Find.WorldObjects.Add(dockedBoat);
return(true);
}
// RimWorld.CollectionsMassCalculator
public static bool CapacityTransferables_PreFix(List <TransferableOneWay> transferables, ref float __result)
{
Cthulhu.Utility.DebugReport("Detour Called: CollectionMassCalc");
//List<ThingCount> tmpThingCounts
bool detour = false;
for (int i = 0; i < transferables.Count; i++)
{
if (transferables[i].HasAnyThing)
{
if (transferables[i].AnyThing.def.defName == "ROM_DarkYoung")
{
detour = true; break;
}
}
}
if (detour)
{
((List <ThingCount>)AccessTools.Field(typeof(CollectionsMassCalculator), "tmpThingCounts").GetValue(null)).Clear();
for (int i = 0; i < transferables.Count; i++)
{
if (transferables[i].HasAnyThing)
{
if (transferables[i].AnyThing is Pawn ||
transferables[i].AnyThing.def.defName == "ROM_DarkYoung")
{
TransferableUtility.TransferNoSplit(transferables[i].things, transferables[i].CountToTransfer, delegate(Thing originalThing, int toTake)
{
((List <ThingCount>)AccessTools.Field(typeof(CollectionsMassCalculator), "tmpThingCounts").GetValue(null)).Add(new ThingCount(originalThing, toTake));
}, false, false);
}
}
}
float result = CollectionsMassCalculator.Capacity(((List <ThingCount>)AccessTools.Field(typeof(CollectionsMassCalculator), "tmpThingCounts").GetValue(null)));
((List <ThingCount>)AccessTools.Field(typeof(CollectionsMassCalculator), "tmpThingCounts").GetValue(null)).Clear();
__result = result;
return(false);
}
return(true);
}
private bool TrySplitCaravan()
{
List <Pawn> pawnsFromTransferables = TransferableUtility.GetPawnsFromTransferables(this.transferables);
bool result;
if (!this.CheckForErrors(pawnsFromTransferables))
{
result = false;
}
else
{
for (int i = 0; i < pawnsFromTransferables.Count; i++)
{
CaravanInventoryUtility.MoveAllInventoryToSomeoneElse(pawnsFromTransferables[i], this.caravan.PawnsListForReading, pawnsFromTransferables);
}
for (int j = 0; j < pawnsFromTransferables.Count; j++)
{
this.caravan.RemovePawn(pawnsFromTransferables[j]);
}
Caravan newCaravan = CaravanMaker.MakeCaravan(pawnsFromTransferables, this.caravan.Faction, this.caravan.Tile, true);
this.transferables.RemoveAll((TransferableOneWay x) => x.AnyThing is Pawn);
for (int k = 0; k < this.transferables.Count; k++)
{
TransferableUtility.TransferNoSplit(this.transferables[k].things, this.transferables[k].CountToTransfer, delegate(Thing thing, int numToTake)
{
Pawn ownerOf = CaravanInventoryUtility.GetOwnerOf(this.caravan, thing);
if (ownerOf == null)
{
Log.Error("Error while splitting a caravan: Thing " + thing + " has no owner. Where did it come from then?", false);
}
else
{
CaravanInventoryUtility.MoveInventoryToSomeoneElse(ownerOf, thing, newCaravan.PawnsListForReading, null, numToTake);
}
}, true, true);
}
result = true;
}
return(result);
}
private bool TryAccept()
{
List <Pawn> pawnsFromTransferables = TransferableUtility.GetPawnsFromTransferables(this.transferables);
if (!this.CheckForErrors(pawnsFromTransferables))
{
return(false);
}
int transportersGroup = this.CreateAndAssignNewTransportersGroup();
this.KickOutFreeloadingPawns();
this.RemoveUnwantedItems();
this.ClearContentsNotLoaded();
this.AssignTransferablesToRandomTransporters();
IEnumerable <Pawn> enumerable = from x in pawnsFromTransferables
where x.IsColonist && !x.Downed
select x;
if (enumerable.Any <Pawn>())
{
foreach (Pawn pawn in enumerable)
{
Lord lord = pawn.GetLord();
if (lord != null)
{
lord.Notify_PawnLost(pawn, PawnLostCondition.ForcedToJoinOtherLord, null);
}
}
LordMaker.MakeNewLord(Faction.OfPlayer, new LordJob_LoadAndEnterTransporters(transportersGroup), this.map, enumerable);
foreach (Pawn pawn2 in enumerable)
{
if (pawn2.Spawned)
{
pawn2.jobs.EndCurrentJob(JobCondition.InterruptForced, true);
}
}
}
Messages.Message("MessageTransportersLoadingProcessStarted".Translate(), this.transporters[0].parent, MessageTypeDefOf.TaskCompletion, false);
return(true);
}
private void CheckReassign(Tradeable tradeable, Transactor side)
{
List <Thing> things = side == Transactor.Colony ? tradeable.thingsColony : tradeable.thingsTrader;
for (int j = things.Count - 1; j >= 1; j--)
{
Thing thing = things[j];
TransferAsOneMode mode = tradeable.TraderWillTrade ? TransferAsOneMode.Normal : TransferAsOneMode.InactiveTradeable;
if (recacheThings.Contains(thing))
{
if (!TransferableUtility.TransferAsOne(tradeable.AnyThing, thing, mode))
{
things.RemoveAt(j);
}
else
{
AddToTradeables(thing, side);
}
}
}
}
private void CacheItems()
{
this.CheckCreateSorters();
this.cachedItems.Clear();
List <Thing> list = CaravanInventoryUtility.AllInventoryItems(base.SelCaravan);
int seed = 0;
for (int i = 0; i < list.Count; i++)
{
TransferableImmutable transferableImmutable = TransferableUtility.TransferableMatching <TransferableImmutable>(list[i], this.cachedItems, TransferAsOneMode.Normal);
if (transferableImmutable == null)
{
transferableImmutable = new TransferableImmutable();
this.cachedItems.Add(transferableImmutable);
}
transferableImmutable.things.Add(list[i]);
seed = Gen.HashCombineInt(seed, list[i].GetHashCode());
}
this.cachedItems = this.cachedItems.OrderBy((TransferableImmutable tr) => tr, this.sorter1.Comparer).ThenBy((TransferableImmutable tr) => tr, this.sorter2.Comparer).ThenBy((TransferableImmutable tr) => TransferableUIUtility.DefaultListOrderPriority(tr)).ToList <TransferableImmutable>();
this.cachedItemsCount = list.Count;
this.cachedItemsHash = seed;
}
public Dictionary <Thing, int> GetSelect()
{
var result = new Dictionary <Thing, int>();
if (IsCancel)
{
return(result);
}
List <ThingStackPart> stackParts = new List <ThingStackPart>();
for (int i = 0; i < transferables.Count; i++)
{
TransferableUtility.TransferNoSplit(transferables[i].things, transferables[i].CountToTransfer, delegate(Thing originalThing, int toTake)
{
stackParts.Add(new ThingStackPart(originalThing, toTake));
}, false, false);
}
float num = 0f;
for (int i = 0; i < stackParts.Count; i++)
{
int count = stackParts[i].Count;
if (count > 0)
{
Thing thing = stackParts[i].Thing;
result.Add(thing, count);
/*
* {
* Thing innerIfMinified = thing.GetInnerIfMinified();
* num += innerIfMinified.GetStatValue(StatDefOf.Mass, true) * (float)count;
*
* }*/
}
}
return(result);
}
private bool TryAccept()
{
ship.compShip.cargoLoadingActive = true;
List <Pawn> pawnsFromTransferables = TransferableUtility.GetPawnsFromTransferables(this.transferables);
if (!this.CheckForErrors(pawnsFromTransferables))
{
return(false);
}
this.AssignTransferablesToShip();
IEnumerable <Pawn> enumerable = from x in pawnsFromTransferables
where x.IsColonist && !x.Downed
select x;
List <Pawn> list = enumerable.ToList();
while (list.Count(x => x.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation)) < this.numOfHaulers)
{
Pawn pawn = map.mapPawns.FreeColonistsSpawned.RandomElement();
if (pawn.health.capacities.CapableOf(PawnCapacityDefOf.Manipulation) && !list.Contains(pawn))
{
list.Add(pawn);
}
}
if (list.Any <Pawn>())
{
LordMaker.MakeNewLord(Faction.OfPlayer, new LordJob_LoadShipCargo(this.ship), this.map, list);
foreach (Pawn current in enumerable)
{
if (current.Spawned)
{
current.jobs.EndCurrentJob(JobCondition.InterruptForced, true);
}
}
}
Messages.Message("MessageShipCargoLoadStarted".Translate(new object[] { ship.ShipNick }), ship, MessageSound.Benefit);
return(true);
}
public static void AddThings(Dialog_FormCaravan dialog, Map map)
{
//Add manifest
if (Mod.settings.caravanSaveManifest && SaveManifest.caravan &&
map == SaveManifest.savedMap && SaveManifest.savedMap != null)
{
Load(dialog.transferables);
}
//Add selection
else if (Mod.settings.caravanLoadSelection)
{
foreach (object obj in Find.Selector.SelectedObjectsListForReading.Where(o => o is Thing))
{
if (obj is Thing thing)
{
Log.Message($"Adding Selected {thing}:{thing.stackCount}");
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(thing, dialog.transferables, TransferAsOneMode.PodsOrCaravanPacking);
transferableOneWay?.AdjustTo(transferableOneWay.ClampAmount(transferableOneWay.CountToTransfer + thing.stackCount));
}
}
}
}
private void SubtractFromToLoadList(Thing t, int count)
{
if (this.leftToLoad == null)
{
return;
}
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(t, this.leftToLoad, TransferAsOneMode.PodsOrCaravanPacking);
if (transferableOneWay == null)
{
return;
}
transferableOneWay.AdjustBy(-count);
if (transferableOneWay.CountToTransfer <= 0)
{
this.leftToLoad.Remove(transferableOneWay);
}
if (!this.AnyInGroupHasAnythingLeftToLoad)
{
Messages.Message("MessageFinishedLoadingTransporters".Translate(), this.parent, MessageTypeDefOf.PositiveEvent);
}
}
public static float ApproxDaysUntilRot(List <TransferableOneWay> transferables, int tile, IgnorePawnsInventoryMode ignoreInventory, WorldPath path = null, float nextTileCostLeft = 0f, int caravanTicksPerMove = 3300)
{
tmpThingCounts.Clear();
for (int i = 0; i < transferables.Count; i++)
{
TransferableOneWay transferableOneWay = transferables[i];
if (!transferableOneWay.HasAnyThing)
{
continue;
}
if (transferableOneWay.AnyThing is Pawn)
{
for (int j = 0; j < transferableOneWay.CountToTransfer; j++)
{
Pawn pawn = (Pawn)transferableOneWay.things[j];
if (!InventoryCalculatorsUtility.ShouldIgnoreInventoryOf(pawn, ignoreInventory))
{
ThingOwner <Thing> innerContainer = pawn.inventory.innerContainer;
for (int k = 0; k < innerContainer.Count; k++)
{
tmpThingCounts.Add(new ThingCount(innerContainer[k], innerContainer[k].stackCount));
}
}
}
}
else if (transferableOneWay.CountToTransfer > 0)
{
TransferableUtility.TransferNoSplit(transferableOneWay.things, transferableOneWay.CountToTransfer, delegate(Thing thing, int count)
{
tmpThingCounts.Add(new ThingCount(thing, count));
}, removeIfTakingEntireThing: false, errorIfNotEnoughThings: false);
}
}
float result = ApproxDaysUntilRot(tmpThingCounts, tile, path, nextTileCostLeft, caravanTicksPerMove);
tmpThingCounts.Clear();
return(result);
}
public void AddToTheToLoadList(TransferableOneWay t, int count)
{
if (!t.HasAnyThing || t.CountToTransfer <= 0)
{
Log.Message("NoThingsToTransfer");
return;
}
if (this.leftToLoad == null)
{
this.leftToLoad = new List <TransferableOneWay>();
}
if (TransferableUtility.TransferableMatching <TransferableOneWay>(t.AnyThing, this.leftToLoad) != null)
{
Log.Error("Transferable already exists.");
return;
}
TransferableOneWay transferableOneWay = new TransferableOneWay();
this.leftToLoad.Add(transferableOneWay);
transferableOneWay.things.AddRange(t.things);
transferableOneWay.countToTransfer = count;
}
internal static float CapacityTransferables(List <TransferableOneWay> transferables)
{
Cthulhu.Utility.DebugReport("Detour Called: CollectionMassCalc");
GetTmpThingStackParts().Clear();
for (int i = 0; i < transferables.Count; i++)
{
if (transferables[i].HasAnyThing)
{
if (transferables[i].AnyThing is Pawn ||
transferables[i].AnyThing.def.defName == "CosmicHorror_DarkYoung")
{
TransferableUtility.TransferNoSplit(transferables[i].things, transferables[i].countToTransfer, delegate(Thing originalThing, int toTake)
{
GetTmpThingStackParts().Add(new ThingStackPart(originalThing, toTake));
}, false, false);
}
}
}
float result = CollectionsMassCalculator.Capacity(GetTmpThingStackParts());
GetTmpThingStackParts().Clear();
return(result);
}
private void SubtractFromToLoadList(Thing t, int count)
{
if (this.leftToLoad == null)
{
return;
}
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatchingDesperate(t, this.leftToLoad, TransferAsOneMode.PodsOrCaravanPacking);
if (transferableOneWay == null)
{
return;
}
transferableOneWay.AdjustBy(-count);
if (transferableOneWay.CountToTransfer <= 0)
{
this.leftToLoad.Remove(transferableOneWay);
}
if (!this.AnyInGroupHasAnythingLeftToLoad)
{
Messages.Message("PD_FinishedLoadingPit".Translate(), this.parent, MessageTypeDefOf.TaskCompletion, true);
prisonerthrowingdone = false;
}
}
private bool TrySplitCaravan()
{
List <Pawn> pawnsFromTransferables = TransferableUtility.GetPawnsFromTransferables(transferables);
if (!CheckForErrors(pawnsFromTransferables))
{
return(false);
}
for (int i = 0; i < pawnsFromTransferables.Count; i++)
{
CaravanInventoryUtility.MoveAllInventoryToSomeoneElse(pawnsFromTransferables[i], caravan.PawnsListForReading, pawnsFromTransferables);
}
for (int j = 0; j < pawnsFromTransferables.Count; j++)
{
caravan.RemovePawn(pawnsFromTransferables[j]);
}
Caravan newCaravan = CaravanMaker.MakeCaravan(pawnsFromTransferables, caravan.Faction, caravan.Tile, addToWorldPawnsIfNotAlready: true);
transferables.RemoveAll((TransferableOneWay x) => x.AnyThing is Pawn);
for (int k = 0; k < transferables.Count; k++)
{
TransferableUtility.TransferNoSplit(transferables[k].things, transferables[k].CountToTransfer, delegate(Thing thing, int numToTake)
{
Pawn ownerOf = CaravanInventoryUtility.GetOwnerOf(caravan, thing);
if (ownerOf == null)
{
Log.Error(string.Concat("Error while splitting a caravan: Thing ", thing, " has no owner. Where did it come from then?"));
}
else
{
CaravanInventoryUtility.MoveInventoryToSomeoneElse(ownerOf, thing, newCaravan.PawnsListForReading, null, numToTake);
}
});
}
return(true);
}
private bool TryAccept()
{
var pawnsFromTransferables = TransferableUtility.GetPawnsFromTransferables(transferables);
if (!CheckForErrors(pawnsFromTransferables))
{
Utility.DebugReport("TryAccept Failed");
return(false);
}
Utility.DebugReport("TryAccept Succeeded");
var transportersGroup = CreateAndAssignNewTransportersGroup();
AssignTransferablesToRandomTransporters();
var enumerable = from x in pawnsFromTransferables
where x.IsColonist && !x.Downed
select x;
if (enumerable.Any())
{
Utility.DebugReport("Pawn List Succeeded");
LordMaker.MakeNewLord(Faction.OfPlayer, new LordJob_LoadAndEnterTransportersPawn(transportersGroup),
map, enumerable);
foreach (var current in enumerable)
{
if (current.Spawned)
{
current.jobs.EndCurrentJob(JobCondition.InterruptForced);
}
}
}
Messages.Message("MessageTransportersLoadingProcessStarted".Translate(), transporters[0].parent,
MessageTypeDefOf.PositiveEvent);
return(true);
}
public static float ApproxDaysWorthOfWaterLeftAfterTradeableTransfer(List <Thing> allCurrentThings, List <Tradeable> tradeables, IgnorePawnsInventoryMode ignoreInventory)
{
TransferableUtility.SimulateTradeableTransfer(allCurrentThings, tradeables, tmpThingStackParts);
tmpPawns.Clear();
tmpThingCounts.Clear();
for (int i = tmpThingStackParts.Count - 1; i >= 0; i--)
{
Pawn pawn = tmpThingStackParts[i].Thing as Pawn;
if (pawn != null)
{
tmpPawns.Add(pawn);
}
else
{
tmpThingCounts.Add(new ThingCount(tmpThingStackParts[i].Thing.def, tmpThingStackParts[i].Count));
}
}
tmpThingStackParts.Clear();
float result = ApproxDaysWorthOfWater(tmpPawns, tmpThingCounts, ignoreInventory);
tmpPawns.Clear();
tmpThingCounts.Clear();
return(result);
}
public static Dictionary <TransferableOneWay, int> GetNeededBedrolls(List <TransferableOneWay> transferables, List <Pawn> pawns = null)
{
Mod.LogMessage("Calculating needed bedrolls");
var neededBedrolls = new Dictionary <TransferableOneWay, int>();
// Pre-calculations
pawns = pawns ?? TransferableUtility.GetPawnsFromTransferables(transferables);
var colonyStuff = transferables
.Where(x => x.HasAnyThing && !(x.AnyThing is Pawn))
.ToList();
var caravanIsBringing = colonyStuff
.Where(x => x.CountToTransfer > 0)
.ToList();
var plannedBedrolls = caravanIsBringing
.Where(x => x.IsBedroll())
.ToList();
var caravanColonists = pawns
.Where(x => !x.AnimalOrWildMan())
.ToList();
var bedrollsNeeded = caravanColonists.Count;
// Are there enough bedrolls already?
Mod.LogMessage($"Planning to bring {plannedBedrolls.Count} bedrolls");
Mod.LogMessage($"Need {bedrollsNeeded} bedrolls");
var bedrollDeficit = bedrollsNeeded - plannedBedrolls.Count;
if (bedrollDeficit <= 0)
{
// Satisfied, continue
return(neededBedrolls);
}
// Look for additional bedrolls
Mod.LogMessage($"Looking for {bedrollDeficit} additional bedrolls");
var availableBedrollList = colonyStuff
.Where(x => x.IsBedroll())
.Where(x => x.CountToTransfer < x.MaxCount)
.ToList();
Mod.LogMessage($"Found {availableBedrollList.Count} unused minified bedroll piles");
if (!availableBedrollList.Any())
{
// Nothing found, nothing to do
return(neededBedrolls);
}
// Take best first
var sortedBedrolls = availableBedrollList.OrderByDescending(x => x.GetBedrollSortValue());
// Add additional bedrolls until satisfied
var updatedBedrollDeficit = bedrollDeficit;
foreach (var availableBedroll in sortedBedrolls)
{
if (updatedBedrollDeficit <= 0)
{
break;
}
var numberAvailable = availableBedroll.MaxCount - availableBedroll.CountToTransfer;
var numberToAdd = numberAvailable > updatedBedrollDeficit
? updatedBedrollDeficit
: numberAvailable;
neededBedrolls.Add(availableBedroll, numberToAdd);
updatedBedrollDeficit -= numberToAdd;
}
var added = bedrollDeficit - updatedBedrollDeficit;
var newTotal = plannedBedrolls.Count + added;
Mod.LogMessage($"Planning to add {added} bedrolls, for a total of {newTotal} out of {bedrollsNeeded} needed");
return(neededBedrolls);
}
/// <summary>
/// Только для своих объетков
/// </summary>
public static WorldObjectEntry GetWorldObjectEntry(WorldObject worldObject
, PlayerGameProgress gameProgress
, Dictionary <Map, List <Pawn> > cacheColonists)
{
var worldObjectEntry = new WorldObjectEntry();
worldObjectEntry.Type = worldObject is Caravan ? WorldObjectEntryType.Caravan : WorldObjectEntryType.Base;
worldObjectEntry.Tile = worldObject.Tile;
worldObjectEntry.Name = worldObject.LabelCap;
worldObjectEntry.LoginOwner = SessionClientController.My.Login;
worldObjectEntry.FreeWeight = 999999;
//определяем цену и вес
var caravan = worldObject as Caravan;
if (caravan != null)
{
//Loger.Log("Client TestBagSD 002");
var transferables = CalculateTransferables(caravan);
//Loger.Log("Client TestBagSD 003");
List <ThingCount> stackParts = new List <ThingCount>();
for (int i = 0; i < transferables.Count; i++)
{
TransferableUtility.TransferNoSplit(transferables[i].things, transferables[i].MaxCount /*CountToTransfer*/, delegate(Thing originalThing, int toTake)
{
stackParts.Add(new ThingCount(originalThing, toTake));
}, false, false);
}
//Loger.Log("Client TestBagSD 004");
worldObjectEntry.FreeWeight = CollectionsMassCalculator.Capacity(stackParts)
- CollectionsMassCalculator.MassUsage(stackParts, IgnorePawnsInventoryMode.Ignore, false, false);
//Loger.Log("Client TestBagSD 005");
worldObjectEntry.MarketValue = 0f;
worldObjectEntry.MarketValuePawn = 0f;
for (int i = 0; i < stackParts.Count; i++)
{
int count = stackParts[i].Count;
if (count > 0)
{
Thing thing = stackParts[i].Thing;
if (thing is Pawn)
{
worldObjectEntry.MarketValuePawn += thing.MarketValue
+ WealthWatcher.GetEquipmentApparelAndInventoryWealth(thing as Pawn);
GameProgressAdd(gameProgress, thing as Pawn);
}
else
{
worldObjectEntry.MarketValue += thing.MarketValue * (float)count;
}
}
}
//Loger.Log("Client TestBagSD 006");
}
else if (worldObject is Settlement)
{
//Loger.Log("Client TestBagSD 007");
var map = (worldObject as Settlement).Map;
if (map != null)
{
//Loger.Log("Client TestBagSD 008");
try
{
DateTime lastForceRecount;
if (!LastForceRecount.TryGetValue(map.uniqueID, out lastForceRecount))
{
LastForceRecount.Add(map.uniqueID, DateTime.UtcNow.AddSeconds(new Random(map.uniqueID * 7).Next(0, 10)));
}
else if ((DateTime.UtcNow - lastForceRecount).TotalSeconds > 30)
{
LastForceRecount[map.uniqueID] = DateTime.UtcNow;
ModBaseData.RunMainThread(() =>
{
map.wealthWatcher.ForceRecount();
});
}
worldObjectEntry.MarketValue = map.wealthWatcher.WealthTotal;
}
catch
{
Thread.Sleep(100);
try
{
worldObjectEntry.MarketValue = map.wealthWatcher.WealthTotal;
}
catch
{
}
}
worldObjectEntry.MarketValuePawn = 0;
//Loger.Log("Client TestBagSD 015");
List <Pawn> ps;
if (!cacheColonists.TryGetValue(map, out ps))
{
var mapPawnsA = new Pawn[map.mapPawns.AllPawnsSpawned.Count];
map.mapPawns.AllPawnsSpawned.CopyTo(mapPawnsA);
ps = mapPawnsA.Where(p => p.Faction == Faction.OfPlayer && p.RaceProps.Humanlike).ToList();
cacheColonists[map] = ps;
}
//Loger.Log("Client TestBagSD 016");
foreach (Pawn current in ps)
{
worldObjectEntry.MarketValuePawn += current.MarketValue;
GameProgressAdd(gameProgress, current);
}
//Loger.Log("Client TestBagSD 017");
//Loger.Log("Map things "+ worldObjectEntry.MarketValue + " pawns " + worldObjectEntry.MarketValuePawn);
}
}
//Loger.Log("Client TestBagSD 018");
WorldObjectEntry storeWO;
if (WorldObjectEntrys.TryGetValue(worldObject.ID, out storeWO))
{
//если серверу приходит объект без данного ServerId, значит это наш новый объект (кроме первого запроса, т.к. не было ещё загрузки)
worldObjectEntry.ServerId = storeWO.ServerId;
}
//Loger.Log("Client TestBagSD 019");
return(worldObjectEntry);
}
public bool MatchesThing(Thing thing)
{
//быстрая проверка
if (thing == null)
{
//Log.Message(" ? thing == null");
return(false);
}
if (DefName != thing.def.defName)
{
//Log.Message(" ? DefName != thing.def.defName" + (DefName ?? "null") + " " + (thing.def.defName ?? "null"));
return(false);
}
var testThing = CreateTrade(thing, 1);
//общая проверка
if (testThing.StuffName != StuffName
)
{
//Log.Message(" ? testThing.StuffName != StuffName " + (StuffName ?? "null") + " " + (testThing.StuffName ?? "null"));
return(false);
}
if (testThing.Quality < Quality
)
{
//Log.Message(" ? testThing.Quality < Quality " + Quality + " " + testThing.Quality);
return(false);
}
if (testThing.WornByCorpse && !WornByCorpse
)
{
//Log.Message(" ? testThing.WornByCorpse && !WornByCorpse " + WornByCorpse + " " + testThing.WornByCorpse);
return(false);
}
//в зависимости от Concrete
int hitPrecent = (testThing.HitPoints + 1) * 100 / testThing.MaxHitPoints;
if (Concrete)
{
if (hitPrecent < HitPoints * 100 / MaxHitPoints)
{
//Log.Message(" ? hitPrecent < HitPoints * 100 / MaxHitPoints");
return(false);
}
}
else
if (hitPrecent < HitPoints)
{
//Log.Message(" ? hitPrecent < HitPoints");
return(false);
}
//Проверка схожести средствами игры, для надёжности и идентификации индивидуальности пешек
if (Concrete)
{
//Log.Message(DataThing.def.defName + " ? " + thing.def.defName + " " + TransferableUtility.TransferAsOne(thing, DataThing).ToString());
return(TransferableUtility.TransferAsOne(thing, DataThing, TransferAsOneMode.Normal));
}
else
{
return(true);
}
}
/// <summary>
/// Только для своих объетков
/// </summary>
public static WorldObjectEntry GetWorldObjectEntry(WorldObject worldObject)
{
var worldObjectEntry = new WorldObjectEntry();
worldObjectEntry.Type = worldObject is Caravan ? WorldObjectEntryType.Caravan : WorldObjectEntryType.Base;
worldObjectEntry.Tile = worldObject.Tile;
worldObjectEntry.Name = worldObject.LabelCap;
worldObjectEntry.LoginOwner = SessionClientController.My.Login;
worldObjectEntry.FreeWeight = 999999;
//определяем цену и вес
var caravan = worldObject as Caravan;
if (caravan != null)
{
var transferables = CalculateTransferables(caravan);
List <ThingCount> stackParts = new List <ThingCount>();
for (int i = 0; i < transferables.Count; i++)
{
TransferableUtility.TransferNoSplit(transferables[i].things, transferables[i].MaxCount /*CountToTransfer*/, delegate(Thing originalThing, int toTake)
{
stackParts.Add(new ThingCount(originalThing, toTake));
}, false, false);
}
worldObjectEntry.FreeWeight = CollectionsMassCalculator.Capacity(stackParts)
- CollectionsMassCalculator.MassUsage(stackParts, IgnorePawnsInventoryMode.Ignore, false, false);
worldObjectEntry.MarketValue = 0f;
worldObjectEntry.MarketValuePawn = 0f;
for (int i = 0; i < stackParts.Count; i++)
{
int count = stackParts[i].Count;
if (count > 0)
{
Thing thing = stackParts[i].Thing;
if (thing is Pawn)
{
worldObjectEntry.MarketValuePawn += thing.MarketValue
+ WealthWatcher.GetEquipmentApparelAndInventoryWealth(thing as Pawn);
}
else
{
worldObjectEntry.MarketValue += thing.MarketValue * (float)count;
}
}
}
}
else if (worldObject is Settlement)
{
var map = (worldObject as Settlement).Map;
if (map != null)
{
worldObjectEntry.MarketValue = map.wealthWatcher.WealthTotal;
worldObjectEntry.MarketValuePawn = 0;
foreach (Pawn current in map.mapPawns.FreeColonists)
{
worldObjectEntry.MarketValuePawn += current.MarketValue;
}
//Loger.Log("Map things "+ worldObjectEntry.MarketValue + " pawns " + worldObjectEntry.MarketValuePawn);
}
}
WorldObjectEntry storeWO;
if (MyWorldObjectEntry.TryGetValue(worldObject.ID, out storeWO))
{
//если серверу приходит объект без данного ServerId, значит это наш новый объект (кроме первого запроса, т.к. не было ещё загрузки)
worldObjectEntry.ServerId = storeWO.ServerId;
}
return(worldObjectEntry);
}
private static int TransferableCountHauledByOthersForPacking(VehiclePawn vehicle, Pawn pawn, TransferableOneWay transferable)
{
List <Pawn> allPawnsSpawned = vehicle.Map.mapPawns.FreeColonistsAndPrisonersSpawned;
int num = 0;
for (int i = 0; i < allPawnsSpawned.Count; i++)
{
Pawn pawn2 = allPawnsSpawned[i];
if (pawn2 != pawn && pawn2.CurJob != null && pawn2.CurJob.def == JobDefOf_Vehicles.CarryItemToVehicle)
{
if (pawn2.jobs.curDriver is JobDriver_GiveToVehicle driver)
{
Thing toHaul = driver.Item;
if (toHaul != null && transferable.things.Contains(toHaul) || TransferableUtility.TransferAsOne(transferable.AnyThing, toHaul, TransferAsOneMode.PodsOrCaravanPacking))
{
num += toHaul.stackCount;
}
}
}
}
return(num);
}
public CaravanInfo(Dialog_FormCaravan formCaravanDialog)
{
this.pawns = TransferableUtility.GetPawnsFromTransferables(formCaravanDialog.transferables);
this.massUsage = formCaravanDialog.MassUsage;
this.massCapacity = formCaravanDialog.MassCapacity;
}
/// <summary>
/// Caravan contains one or more Boats
/// </summary>
/// <param name="c"></param>
public static bool HasBoat(this Caravan caravan)
{
return((caravan is VehicleCaravan vehicleCaravan && vehicleCaravan.pawns.HasBoat()) || (Dialog_FormVehicleCaravan.CurrentFormingCaravan != null &&
TransferableUtility.GetPawnsFromTransferables(Dialog_FormVehicleCaravan.CurrentFormingCaravan.transferables).HasBoat()));
}
public static bool ImpassableModified(World world, int tileID, int startTile, int destTile, Caravan caravan)
{
if (caravan is null && ShipHarmony.currentFormingCaravan is null)
{
if (ShipHarmony.routePlannerActive && world.CoastDirectionAt(startTile).IsValid&& world.CoastDirectionAt(destTile).IsValid)
{
return(ImpassableForBoatPlanner(tileID, destTile) && world.Impassable(tileID)); //Route planner doesn't know if you have boat or not, so check both
}
return(ShipHarmony.routePlannerActive && (WaterCovered(startTile) || Find.World.CoastDirectionAt(startTile).IsValid) && (WaterCovered(destTile) || world.CoastDirectionAt(destTile).IsValid) ?
ImpassableForBoatPlanner(tileID, destTile) : world.Impassable(tileID));
}
bool riverValid = caravan is null && !(ShipHarmony.currentFormingCaravan is null) ? RiverIsValid(tileID, TransferableUtility.GetPawnsFromTransferables(ShipHarmony.currentFormingCaravan.transferables)) :
RiverIsValid(tileID, caravan.PawnsListForReading.Where(x => IsShip(x)).ToList());
bool flag = Find.WorldGrid[tileID].biome == BiomeDefOf.Ocean || Find.WorldGrid[tileID].biome == BiomeDefOf.Lake;
return(HasShip(caravan) ? (!WaterCovered(tileID) && !(Find.World.CoastDirectionAt(tileID).IsValid&& tileID == destTile) &&
!(RimShipMod.mod.settings.riverTravel && riverValid)) : (flag || world.Impassable(tileID)));
}
public static bool HasShip(Caravan c)
{
return((c is null) ? (ShipHarmony.currentFormingCaravan is null) ? false : HasShip(TransferableUtility.GetPawnsFromTransferables(ShipHarmony.currentFormingCaravan.transferables)) : HasShip(c?.PawnsListForReading));
}
