private void AddToTransferables(Thing t)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(t, this.transferables, TransferAsOneMode.Normal);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
this.transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(t);
}
public static void Postfix(TransferableOneWay x, ref bool __result)
{
if (!__result && x.AnyThing is Pawn pawn)
{
__result = pawn.def.GetModExtension <MechanoidExtension>()?.isCaravanRiddable ?? false;
if (pawn.guest is null)
{
pawn.guest = new Pawn_GuestTracker(pawn);
}
}
}
private void AddToTransferables(Thing t)
{
TransferableOneWay transferable = TransferableUtility.TransferableMatching(t, transferables, TransferAsOneMode.PodsOrCaravanPacking);
if (transferable is null)
{
transferable = new TransferableOneWay();
transferables.Add(transferable);
}
transferable.things.Add(t);
}
private void AddToTransferables(Thing t)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching(t, this.transferables);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
this.transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(t);
}
private static void AddThingsToTransferables(List <TransferableOneWay> transferables, Thing thing)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(thing, transferables);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(thing);
DropShipUtility.AdjustToOneWayReflection(transferableOneWay, thing.stackCount);
}
private void AddToTransferablesSelected(Thing t)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(t, this.transferables, TransferAsOneMode.PodsOrCaravanPacking);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
this.transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(t);
transferableOneWay.AdjustTo(t.stackCount);
}
private void SelectBedrolls(Dialog_FormCaravan window, List <TransferableOneWay> transferables, List <Pawn> pawnsFromTransferables)
{
IEnumerable <TransferableOneWay> enumerable = transferables.Where((TransferableOneWay x) => x.ThingDef.category != ThingCategory.Pawn && !x.ThingDef.thingCategories.NullOrEmpty() && x.ThingDef.thingCategories.Contains(ThingCategoryDefOf.Medicine));
IEnumerable <TransferableOneWay> enumerable2 = transferables.Where((TransferableOneWay x) => x.ThingDef.IsIngestible && !x.ThingDef.IsDrug && !x.ThingDef.IsCorpse);
tmpBeds.Clear();
for (int i = 0; i < transferables.Count; i++)
{
for (int j = 0; j < transferables[i].things.Count; j++)
{
Thing thing = transferables[i].things[j];
for (int k = 0; k < thing.stackCount; k++)
{
Building_Bed building_Bed;
if ((building_Bed = (thing.GetInnerIfMinified() as Building_Bed)) != null && building_Bed.def.building.bed_caravansCanUse)
{
for (int l = 0; l < building_Bed.SleepingSlotsCount; l++)
{
tmpBeds.Add(transferables[i]);
}
}
}
}
}
tmpBeds.SortByDescending((TransferableOneWay x) => x.AnyThing.GetStatValue(StatDefOf.BedRestEffectiveness));
foreach (TransferableOneWay item in enumerable)
{
item.AdjustTo(0);
}
foreach (TransferableOneWay item2 in enumerable2)
{
item2.AdjustTo(0);
}
foreach (TransferableOneWay tmpBed in tmpBeds)
{
tmpBed.AdjustTo(0);
}
if (pawnsFromTransferables.Any())
{
foreach (Pawn item3 in pawnsFromTransferables)
{
TransferableOneWay transferableOneWay = BestBedFor(item3);
if (transferableOneWay != null)
{
tmpBeds.Remove(transferableOneWay);
if (transferableOneWay.CanAdjustBy(1).Accepted)
{
AddOneIfMassAllows(window, transferableOneWay);
}
}
}
}
}
public static bool HasCoolerInTransferableItems(List <TransferableOneWay> items)
{
for (int i = 0; i < items.Count; ++i)
{
TransferableOneWay item = items[i];
if (item.CountToTransfer > 0 && item.ThingDef == CaravanCoolerDefOf.CaravanCooler)
{
return(true);
}
}
return(false);
}
private static void AddThingsToTransferables(List <TransferableOneWay> transferables, Thing thing)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(thing, transferables);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(thing);
transferableOneWay.countToTransfer = thing.stackCount;
}
private void AddToTransferables(Thing t)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(t, this.transferables);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
this.transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(t);
transferableOneWay.countToTransfer -= ship.GetInnerContainer().ToList().FindAll(x => transferableOneWay.ThingDef == x.def).Count;
}
static bool Prefix(Rect rect, TransferableOneWay trad, int index, float availableMass)
{
if (trad.AnyThing is ThingWithComps twc && twc.TryGetComp <CompMountable>() is CompMountable comp && comp.mountedTo != null)
{
if (comp.parent.Spawned)
{
comp.ToInventory();
}
Traverse.Create(trad).Property("CountToTransfer").SetValue(1);
return(false);
}
return(true);
}
public static void MaxCountTransferablePostFix(TransferableOneWay __instance)
{
Map map = Find.VisibleMap;
List <ShipBase> ships = DropShipUtility.ShipsOnMap(map);
for (int i = 0; i < ships.Count; i++)
{
for (int j = 0; j < ships[i].GetDirectlyHeldThings().Count; j++)
{
__instance.things.RemoveAll(x => ships[i].GetDirectlyHeldThings().Contains(x));
}
}
}
// RimWorld.LoadTransportersJobUtility
private static Thing FindThingToLoad(Pawn p, CompTransporterPawn transporter)
{
LoadTransportersPawnJobUtility.neededThings.Clear();
List <TransferableOneWay> leftToLoad = transporter.leftToLoad;
if (leftToLoad != null)
{
for (int i = 0; i < leftToLoad.Count; i++)
{
TransferableOneWay transferableOneWay = leftToLoad[i];
if (transferableOneWay.CountToTransfer > 0)
{
for (int j = 0; j < transferableOneWay.things.Count; j++)
{
LoadTransportersPawnJobUtility.neededThings.Add(transferableOneWay.things[j]);
}
}
}
}
if (!LoadTransportersPawnJobUtility.neededThings.Any <Thing>())
{
return(null);
}
Predicate <Thing> validator = (Thing x) =>
LoadTransportersPawnJobUtility.neededThings.Contains(x) && p.CanReserve(x, 1);
Thing thing = GenClosest.ClosestThingReachable(p.Position, p.Map,
ThingRequest.ForGroup(ThingRequestGroup.HaulableEver), PathEndMode.Touch,
TraverseParms.For(p, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator);
if (thing == null)
{
foreach (Thing current in LoadTransportersPawnJobUtility.neededThings)
{
Pawn pawn = current as Pawn;
if (pawn != null && (!pawn.IsColonist || pawn.Downed) &&
p.CanReserveAndReach(pawn, PathEndMode.Touch, Danger.Deadly, 1))
{
Cthulhu.Utility.DebugReport("Pawn to load : " + pawn.Label);
return(pawn);
}
}
}
if (thing != null)
{
Cthulhu.Utility.DebugReport("Thing to load : " + thing.Label);
}
LoadTransportersPawnJobUtility.neededThings.Clear();
return(thing);
}
public static void Postfix(Dialog_LoadTransporters __instance, Map ___map)
{
//Add manifest
if (Mod.settings.caravanSaveManifest && !SaveManifest.caravan &&
___map == SaveManifest.savedMap && SaveManifest.savedMap != null)
{
foreach (ThingCountUNLIMITED thingCount in SaveManifest.savedManifest)
{
Log.Message($"Loading {thingCount.thing}:{thingCount.count}");
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(thingCount.thing, __instance.Transferables(), TransferAsOneMode.PodsOrCaravanPacking);
transferableOneWay?.AdjustTo(transferableOneWay.ClampAmount(transferableOneWay.CountToTransfer + thingCount.count));
}
}
//No selection like caravans - you're already selecting pods!
}
private void AddToTransferables(Thing t, bool setToTransferMax = false)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(t, this.transferables, TransferAsOneMode.PodsOrCaravanPacking);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
this.transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(t);
if (setToTransferMax)
{
transferableOneWay.AdjustTo(transferableOneWay.CountToTransfer + t.stackCount);
}
}
private void AddToTransferables(Thing t, bool setToTransferMax = false)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(t, this.transferables);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
this.transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(t);
if (setToTransferMax)
{
transferableOneWay.AdjustTo(transferableOneWay.MaxCount);
}
}
private void AddToTransferables(Thing t, int countAlreadyIn = 0)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(t, this.transferables);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
this.transferables.Add(transferableOneWay);
}
// Dialog_LoadShipCargo.RemoveExistingTransferable(transferableOneWay, null, this.ship);
transferableOneWay.things.Add(t);
transferableOneWay.AdjustBy(-countAlreadyIn);
}
private Toil AddCarriedThingToTransferables()
{
return(new Toil
{
initAction = delegate()
{
TransferableOneWay transferable = Transferable;
if (!transferable.things.Contains(pawn.carryTracker.CarriedThing))
{
transferable.things.Add(pawn.carryTracker.CarriedThing);
}
},
defaultCompleteMode = ToilCompleteMode.Instant,
atomicWithPrevious = true
});
}
public static bool IsBedroll(this TransferableOneWay x)
{
if (x.AnyThing == null)
{
return(false);
}
var minifiedThing = x.AnyThing.GetInnerIfMinified();
if (minifiedThing == null || minifiedThing.def == null || minifiedThing.def.building == null)
{
return(false);
}
return(minifiedThing.def.building.bed_caravansCanUse);
}
/// <summary>
/// Объединяет одинаковые вещи в список внутри одного контейнера TransferableOneWay
/// </summary>
/// <param name=""></param>
/// <returns></returns>
public static List <TransferableOneWay> DistinctThings(IEnumerable <Thing> things)
{
var transferables = new List <TransferableOneWay>();
foreach (var item in things)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching <TransferableOneWay>(item, transferables, TransferAsOneMode.Normal);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
transferables.Add(transferableOneWay);
}
transferableOneWay.things.Add(item);
}
return(transferables);
}
public override void ForceReform(MapParent mapParent)
{
if (Dialog_FormCaravan.AllSendablePawns(mapParent.Map, reform: true).Any((Pawn x) => x.IsColonist))
{
Messages.Message("MessageYouHaveToReformCaravanNow".Translate(), new GlobalTargetInfo(mapParent.Tile), MessageTypeDefOf.NeutralEvent);
Current.Game.CurrentMap = mapParent.Map;
Dialog_FormCaravan window = new Dialog_FormCaravan(mapParent.Map, reform: true, delegate
{
if (RemoveAfterLeave && mapParent.HasMap)
{
Find.WorldObjects.Remove(mapParent);
}
}, mapAboutToBeRemoved: true);
Find.WindowStack.Add(window);
for (int i = window.transferables.Count - 1; i >= 0; i--)
{
TransferableOneWay t = window.transferables[i];
if (t != null)
{
if (t.AnyThing != null)
{
if (t.AnyThing.Faction != null && t.AnyThing.Faction == Faction)
{
window.transferables.Remove(t);
}
}
}
}
return;
}
List <Pawn> tmpPawns = new List <Pawn>();
tmpPawns.Clear();
tmpPawns.AddRange(from x in mapParent.Map.mapPawns.AllPawns
where x.Faction == Faction.OfPlayer || x.HostFaction == Faction.OfPlayer
select x);
if (tmpPawns.Any((Pawn x) => CaravanUtility.IsOwner(x, Faction.OfPlayer)))
{
CaravanExitMapUtility.ExitMapAndCreateCaravan(tmpPawns, Faction.OfPlayer, mapParent.Tile, mapParent.Tile, -1);
}
tmpPawns.Clear();
if (RemoveAfterLeave)
{
Find.WorldObjects.Remove(mapParent);
}
}
public static void DistributeItems(IEnumerable <TransferableOneWay> items, List <CompTransporter> transporters)
{
// code adapted from RimWorld.Dialog_LoadTransporters.AssignTransferablesToRandomTransporters
Dictionary <TransferableOneWay, int> tmpLeftCountToTransfer = new Dictionary <TransferableOneWay, int>();
foreach (var item in items)
{
tmpLeftCountToTransfer.Add(item, item.CountToTransfer);
}
TransferableOneWay biggestTransferable = items.MaxBy(( TransferableOneWay x ) => tmpLeftCountToTransfer[x]);
int transporterIndex = 0;
// load all but the biggest
foreach (var transferable in items)
{
if (transferable != biggestTransferable && tmpLeftCountToTransfer[transferable] > 0)
{
transporters[transporterIndex % transporters.Count].AddToTheToLoadList(transferable, tmpLeftCountToTransfer[transferable]);
transporterIndex++;
}
}
// if there are empty pods distribute the biggest among the remaining
if (transporterIndex < transporters.Count)
{
int amountToDistribute = tmpLeftCountToTransfer[biggestTransferable];
int amountEach = amountToDistribute / (transporters.Count - transporterIndex);
for (int m = transporterIndex; m < transporters.Count; m++)
{
int amountAdded = (m == transporters.Count - 1) ? amountToDistribute : amountEach; // on the last one add all the remaining
if (amountAdded > 0)
{
transporters[m].AddToTheToLoadList(biggestTransferable, amountAdded);
}
amountToDistribute -= amountAdded;
}
}
// else just add it to one
else
{
transporters[transporterIndex % transporters.Count].AddToTheToLoadList(biggestTransferable, tmpLeftCountToTransfer[biggestTransferable]);
}
}
public static void RemoveExistingTransferable(TransferableOneWay transferable, Map map = null, ShipBase ship = null)
{
List <Thing> thingsInCargoToRemov = new List <Thing>();
List <ShipBase> tmpShips = new List <ShipBase>();
if (ship != null)
{
tmpShips.Add(ship);
}
else if (map != null)
{
tmpShips = DropShipUtility.ShipsOnMap(map);
}
else
{
Log.Error("Tried removing transferables with neither ship nor map specified");
}
}
private void AddToTransferables(Thing t)
{
TransferableOneWay transferableOneWay = TransferableUtility.TransferableMatching(t, transferables, TransferAsOneMode.Normal);
if (transferableOneWay == null)
{
transferableOneWay = new TransferableOneWay();
transferables.Add(transferableOneWay);
}
if (transferableOneWay.things.Contains(t))
{
Log.Error("Tried to add the same thing twice to TransferableOneWay: " + t);
}
else
{
transferableOneWay.things.Add(t);
}
}
public static float Visibility(List <TransferableOneWay> transferables, StringBuilder explanation = null)
{
CaravanVisibilityCalculator.tmpPawns.Clear();
for (int i = 0; i < transferables.Count; i++)
{
TransferableOneWay transferableOneWay = transferables[i];
if (transferableOneWay.HasAnyThing && transferableOneWay.AnyThing is Pawn)
{
for (int j = 0; j < transferableOneWay.CountToTransfer; j++)
{
CaravanVisibilityCalculator.tmpPawns.Add((Pawn)transferableOneWay.things[j]);
}
}
}
float result = CaravanVisibilityCalculator.Visibility(CaravanVisibilityCalculator.tmpPawns, true, explanation);
CaravanVisibilityCalculator.tmpPawns.Clear();
return(result);
}
private static Thing FindThingToLoad(Pawn p, ShipBase ship)
{
LoadShipCargoUtility.neededThings.Clear();
List <TransferableOneWay> leftToLoad = ship.compShip.leftToLoad;
if (leftToLoad != null)
{
for (int i = 0; i < leftToLoad.Count; i++)
{
TransferableOneWay transferableOneWay = leftToLoad[i];
if (transferableOneWay.CountToTransfer > 0)
{
for (int j = 0; j < transferableOneWay.things.Count; j++)
{
LoadShipCargoUtility.neededThings.Add(transferableOneWay.things[j]);
}
}
}
}
if (!LoadShipCargoUtility.neededThings.Any <Thing>())
{
return(null);
}
//Predicate<Thing> validator = (Thing x) => LoadShipCargoUtility.neededThings.Contains(x) && p.CanReserve(x, 1) && !p.Map.reservationManager.IsReservedByAnyoneOf(x, p.Faction);
//Thing thing = GenClosest.ClosestThingReachable(p.Position, p.Map, ThingRequest.ForGroup(ThingRequestGroup.HaulableEver), PathEndMode.Touch, TraverseParms.For(p, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, validator, null);
Thing thing = GenClosest.ClosestThingReachable(p.Position, p.Map, ThingRequest.ForGroup(ThingRequestGroup.HaulableEver), PathEndMode.Touch, TraverseParms.For(p, Danger.Deadly, TraverseMode.ByPawn, false), 9999f, (Thing x) => LoadShipCargoUtility.neededThings.Contains(x) && p.CanReserve(x, 1, -1, null, false), null, 0, -1, false, RegionType.Set_Passable, false);
if (thing == null)
{
foreach (Thing current in LoadShipCargoUtility.neededThings)
{
Pawn pawn = current as Pawn;
if (pawn != null && (!pawn.IsColonist || pawn.Downed) && p.CanReserveAndReach(pawn, PathEndMode.Touch, Danger.Deadly, 10))
{
return(pawn);
}
}
return(null);
}
LoadShipCargoUtility.neededThings.Clear();
//Log.Message("Returning Thing: " + thing.ToString());
return(thing);
}
public static Pair <ThingDef, float> ForagedFoodPerDayLeftAfterTransfer(List <TransferableOneWay> transferables, BiomeDef biome, Faction faction, StringBuilder explanation = null)
{
ForagedFoodPerDayCalculator.tmpPawns.Clear();
for (int i = 0; i < transferables.Count; i++)
{
TransferableOneWay transferableOneWay = transferables[i];
if (transferableOneWay.HasAnyThing && transferableOneWay.AnyThing is Pawn)
{
for (int j = transferableOneWay.things.Count - 1; j >= transferableOneWay.CountToTransfer; j--)
{
ForagedFoodPerDayCalculator.tmpPawns.Add((Pawn)transferableOneWay.things[j]);
}
}
}
Pair <ThingDef, float> result = ForagedFoodPerDayCalculator.ForagedFoodPerDay(ForagedFoodPerDayCalculator.tmpPawns, biome, faction, true, false, explanation);
ForagedFoodPerDayCalculator.tmpPawns.Clear();
return(result);
}
public static float VisibilityLeftAfterTransfer(List <TransferableOneWay> transferables, StringBuilder explanation = null)
{
tmpPawns.Clear();
for (int i = 0; i < transferables.Count; i++)
{
TransferableOneWay transferableOneWay = transferables[i];
if (transferableOneWay.HasAnyThing && transferableOneWay.AnyThing is Pawn)
{
for (int num = transferableOneWay.things.Count - 1; num >= transferableOneWay.CountToTransfer; num--)
{
tmpPawns.Add((Pawn)transferableOneWay.things[num]);
}
}
}
float result = Visibility(tmpPawns, caravanMovingNow: true, explanation);
tmpPawns.Clear();
return(result);
}
public static Pair <ThingDef, float> ForagedFoodPerDayLeftAfterTransfer(List <TransferableOneWay> transferables, BiomeDef biome, Faction faction, StringBuilder explanation = null)
{
tmpPawns.Clear();
for (int i = 0; i < transferables.Count; i++)
{
TransferableOneWay transferableOneWay = transferables[i];
if (transferableOneWay.HasAnyThing && transferableOneWay.AnyThing is Pawn)
{
for (int num = transferableOneWay.things.Count - 1; num >= transferableOneWay.CountToTransfer; num--)
{
tmpPawns.Add((Pawn)transferableOneWay.things[num]);
}
}
}
Pair <ThingDef, float> result = ForagedFoodPerDay(tmpPawns, biome, faction, caravanMovingNow: true, caravanNightResting: false, explanation);
tmpPawns.Clear();
return(result);
}
private void DrawItemNutrition(Rect rect, TransferableOneWay trad)
{
if (!trad.HasAnyThing)
{
return;
}
if (!trad.ThingDef.IsNutritionGivingIngestible)
{
return;
}
Widgets.DrawHighlightIfMouseover(rect);
GUI.color = Color.green;
Widgets.Label(rect, trad.ThingDef.GetStatValueAbstract(StatDefOf.Nutrition, null).ToString("0.##"));
GUI.color = Color.white;
if (Mouse.IsOver(rect))
{
TooltipHandler.TipRegion(rect, "ItemNutritionTip".Translate((1.6f * ThingDefOf.Human.race.baseHungerRate).ToString("0.##")));
}
}
