void OnEnter(On.EntityStates.ScavMonster.FindItem.orig_OnEnter orig, EntityStates.ScavMonster.FindItem findItem)
            {
                bool valid = false;

                foreach (bool tierValid in tierValidScav.Values)
                {
                    if (tierValid)
                    {
                        valid = true;
                        break;
                    }
                }
                if (valid)
                {
                    List <PickupIndex> tier1Adjusted = monsterDropList.availableTier1DropList;
                    if (!tierValidMonsterTeam[ItemTier.Tier1])
                    {
                        tier1Adjusted = DropList.tier1DropListOriginal;
                    }
                    List <PickupIndex> tier2Adjusted = monsterDropList.availableTier2DropList;
                    if (!tierValidMonsterTeam[ItemTier.Tier2])
                    {
                        tier2Adjusted = DropList.tier2DropListOriginal;
                    }
                    List <PickupIndex> tier3Adjusted = monsterDropList.availableTier3DropList;
                    if (!tierValidScav[ItemTier.Tier3])
                    {
                        tier3Adjusted = DropList.tier3DropListOriginal;
                    }
                    DropList.SetDropLists(tier1Adjusted, tier2Adjusted, tier3Adjusted, DropList.equipmentDropListOriginal);

                    List <float> scavTierChanceBackup = new List <float>();
                    scavTierChanceBackup.Add(EntityStates.ScavMonster.FindItem.tier1Chance);
                    scavTierChanceBackup.Add(EntityStates.ScavMonster.FindItem.tier2Chance);
                    scavTierChanceBackup.Add(EntityStates.ScavMonster.FindItem.tier3Chance);

                    if (!tierValidScav[ItemTier.Tier1])
                    {
                        EntityStates.ScavMonster.FindItem.tier1Chance = 0;
                    }
                    if (!tierValidScav[ItemTier.Tier2])
                    {
                        EntityStates.ScavMonster.FindItem.tier2Chance = 0;
                    }
                    if (!tierValidScav[ItemTier.Tier3])
                    {
                        EntityStates.ScavMonster.FindItem.tier3Chance = 0;
                    }

                    orig(findItem);

                    DropList.RevertDropLists();
                    EntityStates.ScavMonster.FindItem.tier1Chance = scavTierChanceBackup[0];
                    EntityStates.ScavMonster.FindItem.tier2Chance = scavTierChanceBackup[1];
                    EntityStates.ScavMonster.FindItem.tier3Chance = scavTierChanceBackup[2];
                }
            }
            void DropRewards(On.RoR2.BossGroup.orig_DropRewards orig, BossGroup bossGroup)
            {
                System.Reflection.FieldInfo info     = typeof(BossGroup).GetField("bossDrops", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance);
                ICollection        collection        = info.GetValue(bossGroup) as ICollection;
                List <PickupIndex> bossDrops         = new List <PickupIndex>();
                List <PickupIndex> bossDropsAdjusted = new List <PickupIndex>();

                foreach (object bossDrop in collection)
                {
                    PickupIndex pickupIndex = (PickupIndex)bossDrop;
                    bossDrops.Add(pickupIndex);
                    if (PickupCatalog.GetPickupDef(pickupIndex).itemIndex != ItemIndex.None && playerItems.Contains(pickupIndex))
                    {
                        bossDropsAdjusted.Add(pickupIndex);
                    }
                }
                int normalCount = Run.instance.availableTier2DropList.Count;

                if (bossGroup.forceTier3Reward)
                {
                    normalCount = Run.instance.availableTier3DropList.Count;
                }
                if (normalCount != 0 || bossDropsAdjusted.Count != 0)
                {
                    float bossDropChanceOld = bossGroup.bossDropChance;
                    if (normalCount == 0)
                    {
                        DropList.SetDropLists(new List <PickupIndex>(), new List <PickupIndex>(), new List <PickupIndex>(), new List <PickupIndex>());
                        bossGroup.bossDropChance = 1;
                    }
                    else if (bossDropsAdjusted.Count == 0)
                    {
                        bossGroup.bossDropChance = 0;
                    }
                    info.SetValue(bossGroup, bossDropsAdjusted);
                    orig(bossGroup);
                    info.SetValue(bossGroup, bossDrops);
                    bossGroup.bossDropChance = bossDropChanceOld;
                    if (normalCount == 0)
                    {
                        DropList.RevertDropLists();
                    }
                }
            }
            //-------------------------
            //-------------------------


            void GenerateAvailableItemsSet(On.RoR2.Artifacts.MonsterTeamGainsItemsArtifactManager.orig_GenerateAvailableItemsSet orig)
            {
                List <ItemTag> forbiddenTags = new List <ItemTag>();

                System.Type type = typeof(RoR2.Artifacts.MonsterTeamGainsItemsArtifactManager);
                System.Reflection.FieldInfo info = type.GetField("forbiddenTags", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
                ICollection collection           = info.GetValue(null) as ICollection;

                foreach (object itemTag in collection)
                {
                    forbiddenTags.Add((ItemTag)itemTag);
                }

                tierValidScav.Clear();
                tierValidMonsterTeam.Clear();
                List <PickupIndex> tier1Adjusted = monsterDropList.availableTier1DropList;

                tierValidMonsterTeam.Add(ItemTier.Tier1, ListContainsValidItems(forbiddenTags, tier1Adjusted));
                tierValidScav.Add(ItemTier.Tier1, ListContainsValidItems(new List <ItemTag>()
                {
                    ItemTag.AIBlacklist
                }, tier1Adjusted));
                if (!tierValidMonsterTeam[ItemTier.Tier1])
                {
                    tier1Adjusted = DropList.tier1DropListOriginal;
                }
                List <PickupIndex> tier2Adjusted = monsterDropList.availableTier2DropList;

                tierValidMonsterTeam.Add(ItemTier.Tier2, ListContainsValidItems(forbiddenTags, tier2Adjusted));
                tierValidScav.Add(ItemTier.Tier2, ListContainsValidItems(new List <ItemTag>()
                {
                    ItemTag.AIBlacklist
                }, tier2Adjusted));
                if (!tierValidMonsterTeam[ItemTier.Tier2])
                {
                    tier2Adjusted = DropList.tier2DropListOriginal;
                }
                List <PickupIndex> tier3Adjusted = monsterDropList.availableTier3DropList;

                tierValidMonsterTeam.Add(ItemTier.Tier3, ListContainsValidItems(forbiddenTags, tier3Adjusted));
                tierValidScav.Add(ItemTier.Tier3, ListContainsValidItems(new List <ItemTag>()
                {
                    ItemTag.AIBlacklist
                }, tier3Adjusted));
                if (!tierValidMonsterTeam[ItemTier.Tier3])
                {
                    tier3Adjusted = DropList.tier3DropListOriginal;
                }

                DropList.SetDropLists(tier1Adjusted, tier2Adjusted, tier3Adjusted, DropList.equipmentDropListOriginal);
                orig();
                DropList.RevertDropLists();


                info       = type.GetField("pattern", System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static);
                collection = info.GetValue(null) as ICollection;
                List <ItemTier> patternAdjustedList = new List <ItemTier>();
                int             patternIndex        = 0;

                foreach (object itemTier in collection)
                {
                    patternAdjustedList.Add((ItemTier)itemTier);
                    patternIndex += 1;
                }
                if (!tierValidMonsterTeam[ItemTier.Tier1])
                {
                    while (patternAdjustedList.Contains(ItemTier.Tier1))
                    {
                        patternAdjustedList.Remove(ItemTier.Tier1);
                    }
                }
                if (!tierValidMonsterTeam[ItemTier.Tier2])
                {
                    while (patternAdjustedList.Contains(ItemTier.Tier2))
                    {
                        patternAdjustedList.Remove(ItemTier.Tier2);
                    }
                }
                if (!tierValidMonsterTeam[ItemTier.Tier3])
                {
                    while (patternAdjustedList.Contains(ItemTier.Tier3))
                    {
                        patternAdjustedList.Remove(ItemTier.Tier3);
                    }
                }
                patternAdjusted = new ItemTier[patternAdjustedList.Count];
                patternIndex    = 0;
                foreach (ItemTier itemTier in patternAdjustedList)
                {
                    patternAdjusted[patternIndex] = itemTier;
                    patternIndex += 1;
                }
            }
 void AddShrineStack(On.RoR2.ShrineChanceBehavior.orig_AddShrineStack orig, ShrineChanceBehavior shrineChangeBehavior, Interactor interactor)
 {
     DropList.SetDropLists(RoR2.Run.instance.availableTier1DropList, RoR2.Run.instance.availableTier2DropList, RoR2.Run.instance.availableTier3DropList, RoR2.Run.instance.availableEquipmentDropList);
     orig(shrineChangeBehavior, interactor);
     DropList.RevertDropLists();
 }