public static bool Remove(ListerThings __instance, Thing t)
{
if (!ListerThings.EverListable(t.def, __instance.use))
{
return(false);
}
List <Thing> ld = listsByDef(__instance)[t.def];
lock (ld) //ADDED
{
ld.Remove(t);
}
ThingRequestGroup[] allGroups = ThingListGroupHelper.AllGroups;
for (int index = 0; index < allGroups.Length; ++index)
{
ThingRequestGroup group = allGroups[index];
if ((__instance.use != ListerThingsUse.Region || group.StoreInRegion()) && group.Includes(t.def))
{
List <Thing> tl = listsByGroup(__instance)[index];
lock (tl) //ADDED
{
int li = tl.LastIndexOf(t);
if (li > -1)
{
tl.RemoveAt(li);
}
}
}
}
return(false);
}
public static bool RegisterInRegions(Thing thing, Map map)
{
if (!ListerThings.EverListable(thing.def, ListerThingsUse.Region))
{
return(false);
}
int tID = Thread.CurrentThread.ManagedThreadId;
if (!tmpRegionsLists.TryGetValue(tID, out List <Region> tmpRegions))
{
tmpRegions = new List <Region>();
tmpRegionsLists[tID] = tmpRegions;
}
else
{
tmpRegions.Clear();
}
RegionListersUpdater.GetTouchableRegions(thing, map, tmpRegions, false);
for (int i = 0; i < tmpRegions.Count; i++)
{
ListerThings listerThings = tmpRegions[i].ListerThings;
lock (listerThings)
{
if (!listerThings.Contains(thing))
{
listerThings.Add(thing);
}
}
}
return(false);
}
protected override int CountMatch()
{
int count = 0;
if (Def.roomRole != null)
{
List <Room> rooms = pawn.Map.regionGrid.allRooms.FindAll(room => room.Role == Def.roomRole && (!Def.shoulBeRoomOwner || room.Owners.Contains(pawn)));
for (int i = 0; i < rooms.Count; i++)
{
for (int j = 0; j < ThingsWanted.Count; j++)
{
count += AdjustForSpecifiedCount(ThingMatching(rooms[i].ContainedThings(ThingsWanted[j].def).ToList(), ThingsWanted[j]), ThingsWanted[j].needAmount);
}
}
return(count);
}
else
{
ListerThings lister = pawn.Map.listerThings;
for (int i = 0; i < ThingsWanted.Count; i++)
{
count += AdjustForSpecifiedCount(ThingMatching(lister.ThingsOfDef(GetThingDef(ThingsWanted[i])), ThingsWanted[i]), ThingsWanted[i].needAmount);
}
}
return(count);
}
public static bool Add(ListerThings __instance, Thing t)
{
if (!ListerThings.EverListable(t.def, __instance.use))
{
return(false);
}
List <Thing> thingList1;
if (!listsByDef(__instance).TryGetValue(t.def, out thingList1))
{
thingList1 = new List <Thing>();
listsByDef(__instance).Add(t.def, thingList1);
}
lock (thingList1)
{
thingList1.Add(t);
}
foreach (ThingRequestGroup allGroup in ThingListGroupHelper.AllGroups)
{
if ((__instance.use != ListerThingsUse.Region || allGroup.StoreInRegion()) && allGroup.Includes(t.def))
{
List <Thing> thingList2 = listsByGroup(__instance)[(int)allGroup];
if (thingList2 == null)
{
thingList2 = new List <Thing>();
listsByGroup(__instance)[(int)allGroup] = thingList2;
}
lock (thingList2)
{
thingList2.Add(t);
}
}
}
return(false);
}
public static bool Remove(ListerThings __instance, Thing t)
{
ThingDef thingDef = t.def;
if (!ListerThings.EverListable(thingDef, __instance.use))
{
return(false);
}
lock (__instance)
{
List <Thing> newListsByDef = new List <Thing>(listsByDef(__instance)[thingDef]);
newListsByDef.Remove(t);
listsByDef(__instance)[thingDef] = newListsByDef;
}
ThingRequestGroup[] allGroups = ThingListGroupHelper.AllGroups;
for (int i = 0; i < allGroups.Length; i++)
{
ThingRequestGroup group = allGroups[i];
if ((__instance.use != ListerThingsUse.Region || group.StoreInRegion()) && group.Includes(thingDef))
{
lock (__instance)
{
List <Thing> newListsByGroup = new List <Thing>(listsByGroup(__instance)[i]);
newListsByGroup.Remove(t);
listsByGroup(__instance)[i] = newListsByGroup;
}
}
}
return(false);
}
public static List <Thing> ThingsMatching(ListerThings __instance, ThingRequest req)
{
if (req.singleDef != null)
{
List <Thing> result;
if (!listsByDef(__instance).TryGetValue(req.singleDef, out result))
{
return(EmptyList);
}
return(result);
}
else
{
if (req.group == ThingRequestGroup.Undefined)
{
throw new InvalidOperationException("Invalid ThingRequest " + req);
}
if (__instance.use == ListerThingsUse.Region && !req.group.StoreInRegion())
{
Log.ErrorOnce("Tried to get things in group " + req.group + " in a region, but this group is never stored in regions. Most likely a global query should have been used.", 1968735132, false);
return(EmptyList);
}
return(listsByGroup(__instance)[(int)req.group] ?? EmptyList);
}
}
public static bool ThingsOfDef(ListerThings __instance, ref List <Thing> __result, ThingDef def)
{
__result = EmptyList;
if (def != null)
{
__result = __instance.ThingsMatching(ThingRequest.ForDef(def));
}
return(false);
}
static void Postfix(ListerThings __instance, Thing t)
{
if (Multiplayer.Client == null)
{
return;
}
if (t.def.category == ThingCategory.Item && ListerThings.EverListable(t.def, __instance.use))
{
Multiplayer.WorldComp.DirtyColonyTradeForMap(t.Map);
}
}
public static void RegisterInRegions(Thing thing, Map map)
{
ThingDef def = thing.def;
if (!ListerThings.EverListable(def, ListerThingsUse.Region))
{
return;
}
newRegionListersUpdater.GetTouchableRegions(thing, map, newRegionListersUpdater.tmpRegions, false);
for (int i = 0; i < newRegionListersUpdater.tmpRegions.Count; i++)
{
ListerThings listerThings = newRegionListersUpdater.tmpRegions[i].ListerThings;
if (!listerThings.Contains(thing))
{
listerThings.Add(thing);
}
}
}
public static void DeregisterInRegions(Thing thing, Map map)
{
ThingDef def = thing.def;
if (!ListerThings.EverListable(def, ListerThingsUse.Region))
{
return;
}
GetTouchableRegions(thing, map, tmpRegions, true);
for (int i = 0; i < tmpRegions.Count; i++)
{
ListerThings listerThings = tmpRegions[i].ListerThings;
if (listerThings.Contains(thing))
{
listerThings.Remove(thing);
}
}
tmpRegions.Clear();
}
public static void Listener(ListerThings __instance, ThingRequest req, ref List <Thing> __result)
{
List <Thing> ret = null;
if (Utils.QEE_LOADED && req.singleDef != null && req.singleDef.defName == "QE_GenomeSequencerFilled")
{
foreach (var el in __instance.AllThings)
{
if (el.def.defName == "QE_GenomeSequencerFilled" || Utils.ExceptionQEEGS.Contains(el.def.defName))
{
if (ret == null)
{
ret = new List <Thing>();
}
ret.Add(el);
}
}
__result = ret;
}
}
public static bool DeregisterInRegions(Thing thing, Map map)
{
if (!ListerThings.EverListable(thing.def, ListerThingsUse.Region))
{
return(false);
}
List <Region> tmpRegions = new List <Region>();
RegionListersUpdater.GetTouchableRegions(thing, map, tmpRegions, true);
for (int i = 0; i < tmpRegions.Count; i++)
{
ListerThings listerThings = tmpRegions[i].ListerThings;
lock (listerThings)
{
if (listerThings.Contains(thing))
{
listerThings.Remove(thing);
}
}
}
return(false);
}
public static bool Add(ListerThings __instance, Thing t)
{
ThingDef thingDef = t.def;
if (!ListerThings.EverListable(thingDef, __instance.use))
{
return(false);
}
lock (__instance)
{
if (!listsByDef(__instance).TryGetValue(thingDef, out List <Thing> value))
{
value = new List <Thing>();
listsByDef(__instance).Add(t.def, value);
}
value.Add(t);
}
ThingRequestGroup[] allGroups = ThingListGroupHelper.AllGroups;
foreach (ThingRequestGroup thingRequestGroup in allGroups)
{
if ((__instance.use != ListerThingsUse.Region || thingRequestGroup.StoreInRegion()) && thingRequestGroup.Includes(thingDef))
{
lock (__instance)
{
List <Thing> list = listsByGroup(__instance)[(uint)thingRequestGroup];
if (list == null)
{
list = new List <Thing>();
listsByGroup(__instance)[(uint)thingRequestGroup] = list;
}
list.Add(t);
}
}
}
return(false);
}
