static void Postfix(ResourceCounter __instance)
{
if (countedAmountsFI == null)
{
countedAmountsFI = typeof(ResourceCounter).GetField("countedAmounts", BindingFlags.Instance | BindingFlags.NonPublic);
}
Dictionary <ThingDef, int> countedAmounts = (Dictionary <ThingDef, int>)countedAmountsFI.GetValue(__instance);
foreach (Building_InfiniteStorage ts in WorldComp.GetInfiniteStorages(Find.CurrentMap))
{
foreach (Thing thing in ts.StoredThings)
{
if (thing.def.EverStorable(true) && thing.def.CountAsResource && !thing.IsNotFresh())
{
int count;
if (countedAmounts.TryGetValue(thing.def, out count))
{
count += thing.stackCount;
}
else
{
count = thing.stackCount;
}
countedAmounts[thing.def] = count;
}
}
}
}
static void Postfix(Thing __result, Pawn pawn)
{
bool found = false;
if (pawn != null && __result == null)
{
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(pawn.Map))
{
if (storage.TryRemove(ThingDefOf.ComponentIndustrial, 1, out List <Thing> list))
{
found = true;
foreach (Thing t in list)
{
BuildingUtil.DropThing(t, 1, storage, storage.Map, null);
}
}
}
if (found)
{
__result = GenClosest.ClosestThingReachable(
pawn.Position, pawn.Map, ThingRequest.ForDef(ThingDefOf.ComponentIndustrial), PathEndMode.InteractionCell, TraverseParms.For(pawn, pawn.NormalMaxDanger(),
TraverseMode.ByPawn, false), 9999f, (Thing x) => !x.IsForbidden(pawn) && pawn.CanReserve(x, 1, -1, null, false), null, 0, -1, false, RegionType.Set_Passable, false);
}
}
}
static void Postfix(Lord lord)
{
foreach (Building_InfiniteStorage storage in WorldComp.GetAllInfiniteStorages())
{
storage.Reclaim();
}
}
static void Prefix(Pawn pawn, Building_TurretGun gun)
{
#if DEBUG
Log.Warning("Find Ammo");
#endif
if (pawn.IsColonist && pawn.Map == gun.Map)
{
StorageSettings allowedShellsSettings = gun.gun.TryGetComp <CompChangeableProjectile>().allowedShellsSettings;
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(gun.Map))
{
#if DEBUG
Log.Warning(" Storeage: " + storage.Label);
#endif
List <Thing> l;
if (storage.TryRemove(allowedShellsSettings.filter, out l))
{
foreach (Thing t in l)
{
#if DEBUG
Log.Warning(" Ammo fouynd: " + t.Label);
#endif
List <Thing> dropped = new List <Thing>();
BuildingUtil.DropThing(t, t.stackCount, storage, storage.Map, dropped);
}
}
}
}
}
static void Postfix(ref bool __result, ItemAvailability __instance, ThingCountClass need, Pawn pawn)
{
if (!__result && pawn != null && pawn.Faction == Faction.OfPlayer)
{
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(pawn.Map))
{
if (storage.IsOperational &&
storage.Spawned &&
need != null && need.thing != null)
{
Thing thing;
if (storage.TryGetValue(need.thing.def, out thing))
{
if (thing.stackCount >= need.Count)
{
List <Thing> removed;
int toDrop = (need.Count < thing.def.stackLimit) ? thing.def.stackLimit : need.Count;
if (storage.TryRemove(thing, toDrop, out removed))
{
foreach (Thing t in removed)
{
BuildingUtil.DropThing(t, t.stackCount, storage, storage.Map);
}
__result = true;
((Dictionary <int, bool>)CachedResultsFI.GetValue(__instance))[Gen.HashCombine <Faction>(need.GetHashCode(), pawn.Faction)] = __result;
}
break;
}
}
}
}
}
}
static void Prefix()
{
#if MED_DEBUG
Log.Warning("HealthCardUtility.DrawMedOperationsTab");
#endif
Patch_ListerThings_ThingsInGroup.AvailableMedicalThing.Clear();
Map map = Find.CurrentMap;
if (map != null)
{
#if MED_DEBUG
Log.Warning(" Map is not null: " + (map != null).ToString());
#endif
long now = DateTime.Now.Ticks;
if (cache == null || now - lastUpdate > TimeSpan.TicksPerSecond)
{
cache.Clear();
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(map))
{
#if MED_DEBUG
Log.Warning(" Storage: " + storage.Label);
#endif
if (storage.def.defName.Equals("IS_BodyPartStorage") ||
storage.def.defName.Equals("InfiniteStorage"))
{
cache.AddRange(storage.GetMedicalThings(true, false));
}
}
lastUpdate = now;
}
Patch_ListerThings_ThingsInGroup.AvailableMedicalThing.AddRange(cache);
}
}
internal static void Prefix(Pawn pawn, Thing refuelable)
{
if (WorldComp.HasInfiniteStorages(refuelable.Map))
{
droppedAndStorage = new Dictionary <Thing, Building_InfiniteStorage>();
ThingFilter filter = refuelable.TryGetComp <CompRefuelable>().Props.fuelFilter;
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(refuelable.Map))
{
if (storage.Spawned && storage.Map == pawn.Map && storage.IsOperational)
{
List <Thing> removed;
if (storage.TryRemove(filter, out removed))
{
List <Thing> removedThings = new List <Thing>();
foreach (Thing t in removed)
{
BuildingUtil.DropThing(t, t.def.stackLimit, storage, storage.Map, removedThings);
}
if (removedThings.Count > 0)
{
droppedAndStorage.Add(removedThings[0], storage);
}
}
}
}
}
}
static void Postfix(WealthWatcher __instance)
{
Map map = (Map)__instance.GetType().GetField("map", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance);
//float wealthBuildings = __instance.GetType().GetField("wealthBuildings", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance) as float;
FieldInfo wealthItemsFI = __instance.GetType().GetField("wealthItems", BindingFlags.NonPublic | BindingFlags.Instance);
float wealthItems = (float)wealthItemsFI.GetValue(__instance);
wealthItems = TallyWealth(WorldComp.GetInfiniteStorages(map), wealthItems);
//wealthItems = TallyWealth(WorldComp.GetNonGlobalInfiniteStorages(map), wealthItems);
if (lastItemWealth < 1)
{
lastItemWealth = wealthItems;
}
else if (wealthItems > lastItemWealth * 5)
{
float temp = wealthItems;
wealthItems = lastItemWealth;
lastItemWealth = temp;
}
else
{
lastItemWealth = wealthItems;
}
wealthItemsFI.SetValue(__instance, wealthItems);
}
public override void SpawnSetup(Map map, bool respawningAfterLoad)
{
base.SpawnSetup(map, respawningAfterLoad);
this.CurrentMap = map;
if (settings == null)
{
base.settings = new StorageSettings(this);
base.settings.CopyFrom(this.def.building.defaultStorageSettings);
base.settings.filter.SetDisallowAll();
}
this.includeInWorldLookup = this.GetIncludeInWorldLookup();
WorldComp.Add(map, this);
this.compPowerTrader = this.GetComp <CompPowerTrader>();
if (this.ToDumpOnSpawn != null)
{
foreach (Thing t in this.ToDumpOnSpawn)
{
BuildingUtil.DropThing(t, t.stackCount, this, this.Map);
}
this.ToDumpOnSpawn.Clear();
this.ToDumpOnSpawn = null;
}
}
static void Prefix(List <IngredientCount> ingredients, Pawn pawn, ref List <Pair <Building_InfiniteStorage, List <Thing> > > __state)
{
if (ingredients != null && pawn != null)
{
foreach (var s in WorldComp.GetInfiniteStorages(pawn.Map))
{
List <Thing> d = null;
foreach (var i in ingredients)
{
if (s.TryDropThings(i, out List <Thing> dropped))
{
if (d == null)
{
d = new List <Thing>();
}
d.AddRange(dropped);
}
}
if (d?.Count > 0)
{
if (__state == null)
{
__state = new List <Pair <Building_InfiniteStorage, List <Thing> > >();
}
__state.Add(new Pair <Building_InfiniteStorage, List <Thing> >(s, d));
}
}
}
}
public static void ReclaimThings()
{
foreach (Building_InfiniteStorage storage in WorldComp.GetAllInfiniteStorages())
{
if (storage.Map != null && storage.Spawned)
{
storage.Reclaim();
}
}
}
static void Prefix(Pawn healer, Pawn patient)
{
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(patient.Map))
{
IEnumerable <Thing> removed = storage.GetMedicalThings(false, true);
foreach (Thing r in removed)
{
BuildingUtil.DropThing(r, r.stackCount, storage, storage.Map); //, dropped);
}
}
}
static void Prefix(Map map)
{
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(map))
{
if (storage.TryRemove(ThingDefOf.Silver, out IEnumerable <Thing> silver))
{
foreach (Thing s in silver)
{
BuildingUtil.DropThing(s, s.stackCount, storage, storage.Map, null);
}
}
}
}
public static IEnumerable <Thing> EmptyStorages(Map map)
{
List <Thing> l = new List <Thing>();
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(map))
{
if (storage.Map == map && storage.Spawned && storage.IncludeInTradeDeals)
{
storage.Empty(l);
}
}
return(l);
}
static void Prefix(IEnumerable <Pawn> pawns, Faction faction, int exitFromTile, int directionTile, int destinationTile, bool sendMessage)
{
if (faction == Faction.OfPlayer)
{
List <Pawn> p = new List <Pawn>(pawns);
if (p.Count > 0)
{
foreach (Building_InfiniteStorage storage in WorldComp.GetAllInfiniteStorages())
{
storage.Reclaim();
}
}
}
}
static void Prefix(Window __instance)
{
Type type = __instance.GetType();
if (type == typeof(Dialog_FormCaravan))
{
Map map = __instance.GetType().GetField("map", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(__instance) as Map;
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(map))
{
storage.Empty();
}
}
}
static void Postfix(ref int __result, RecipeWorkerCounter __instance, Bill_Production bill)
{
List <ThingDefCountClass> products = __instance.recipe.products;
if (WorldComp.HasInfiniteStorages(bill.Map) && products != null)
{
foreach (ThingDefCountClass product in products)
{
ThingDef def = product.thingDef;
foreach (Building_InfiniteStorage s in WorldComp.GetInfiniteStorages(bill.Map))
{
__result += s.StoredThingCount(def, bill.ingredientFilter);
}
}
}
}
static void Prefix()
{
try
{
foreach (Building_InfiniteStorage s in WorldComp.GetAllInfiniteStorages())
{
try
{
s.ForceReclaim();
}
catch (Exception e)
{
Log.Warning("Error while reclaiming apparel for infinite storage\n" + e.Message);
}
}
}
catch (Exception e)
{
Log.Warning("Error while reclaiming items\n" + e.Message);
}
}
static void Postfix(ref List <ThingCount> __result, Pawn healer, Pawn patient, ref int totalCount)
{
if (healer.Map != patient.Map)
{
return;
}
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStoragesWithinRadius(healer.Map, patient.Position, 20))
{
IEnumerable <Thing> removed = storage.GetMedicalThings(false, true);
foreach (Thing r in removed)
{
List <Thing> dropped = new List <Thing>();
BuildingUtil.DropThing(r, r.stackCount, storage, storage.Map, dropped);
foreach (Thing t in dropped)
{
__result.Add(new ThingCount(t, t.stackCount));
t.Map.reservationManager.CanReserveStack(healer, t, 1, ReservationLayerDefOf.Floor, true);
}
}
}
}
private void Dispose()
{
try
{
this.AllowAdds = false;
foreach (LinkedList <Thing> l in this.storedThings.Values)
{
foreach (Thing t in l)
{
BuildingUtil.DropThing(t, t.stackCount, this, this.CurrentMap);
}
}
this.storedThings.Clear();
}
catch (Exception e)
{
Log.Error(
this.GetType().Name + ".Dispose\n" +
e.GetType().Name + " " + e.Message + "\n" +
e.StackTrace);
}
WorldComp.Remove(this.CurrentMap, this);
}
static void Postfix(ref bool __result, Pawn pawn, List <IngredientCount> ingredients, List <ThingCount> chosen, ref List <Pair <Building_InfiniteStorage, List <Thing> > > __state)
{
/*
* Log.Warning($"{pawn.Name.ToStringShort} Result: {__result}");
* foreach (var c in chosen)
* Log.Warning($" - Chose: {c.Thing.def.defName} x{c.Count}");
* foreach (var i in ingredients)
* Log.Warning($"- Ing: {i.GetBaseCount()}");
*/
if (__result == false)
{
if (__state != null)
{
foreach (var p in __state)
{
foreach (var t in p.Second)
{
p.First.Add(t);
}
}
}
}
else if (pawn != null && ingredients != null && chosen != null)
{
Dictionary <int, int> chosenLookup = new Dictionary <int, int>();
foreach (var t in chosen)
{
chosenLookup.Add(t.Thing.thingIDNumber, t.Count);
}
foreach (var s in WorldComp.GetInfiniteStorages(pawn.Map))
{
s.ReclaimFaster(true, chosenLookup);
}
}
}
static bool Prefix(Designator_Build __instance, Event ev)
{
if (entDefFI == null)
{
entDefFI = typeof(Designator_Build).GetField("entDef", BindingFlags.NonPublic | BindingFlags.Instance);
stuffDefFI = typeof(Designator_Build).GetField("stuffDef", BindingFlags.NonPublic | BindingFlags.Instance);
writeStuffFI = typeof(Designator_Build).GetField("writeStuff", BindingFlags.NonPublic | BindingFlags.Instance);
}
Map map = Find.CurrentMap;
ThingDef thingDef = entDefFI.GetValue(__instance) as ThingDef;
if (thingDef == null || !thingDef.MadeFromStuff || !WorldComp.HasInfiniteStorages(map))
{
return(true);
}
List <FloatMenuOption> list = new List <FloatMenuOption>();
foreach (ThingDef current in map.resourceCounter.AllCountedAmounts.Keys)
{
if (current.IsStuff && current.stuffProps.CanMake(thingDef) && (DebugSettings.godMode || map.listerThings.ThingsOfDef(current).Count > 0))
{
ThingDef localStuffDef = current;
string labelCap = localStuffDef.LabelCap;
list.Add(new FloatMenuOption(labelCap, delegate
{
__instance.ProcessInput(ev);
Find.DesignatorManager.Select(__instance);
stuffDefFI.SetValue(__instance, current);
writeStuffFI.SetValue(__instance, true);
}, MenuOptionPriority.Default, null, null, 0f, null, null));
}
}
foreach (Building_InfiniteStorage storage in WorldComp.GetInfiniteStorages(map))
{
if (storage.Spawned)
{
foreach (Thing t in storage.StoredThings)
{
ThingDef current = t.def;
if (current.IsStuff &&
current.stuffProps.CanMake(thingDef) &&
(DebugSettings.godMode || t.stackCount > 0))
{
string labelCap = current.LabelCap;
list.Add(new FloatMenuOption(labelCap, delegate
{
__instance.ProcessInput(ev);
Find.DesignatorManager.Select(__instance);
stuffDefFI.SetValue(__instance, current);
writeStuffFI.SetValue(__instance, true);
}, MenuOptionPriority.Default, null, null, 0f, null, null));
}
}
}
}
if (list.Count == 0)
{
Messages.Message("NoStuffsToBuildWith".Translate(), MessageTypeDefOf.RejectInput);
}
else
{
FloatMenu floatMenu = new FloatMenu(list);
floatMenu.vanishIfMouseDistant = true;
Find.WindowStack.Add(floatMenu);
Find.DesignatorManager.Select(__instance);
}
return(false);
}
static void Prefix()
{
WorldComp.ClearAll();
}
static void Prefix(MapParent settlement)
{
WorldComp.Remove(settlement.Map);
}
