context: using System;
  using Server.Mobiles;
  using Server.Engines.Shadowguard;
  
  namespace Server.Items
  {
      public class SlayerGroup
      {
          private static SlayerEntry[] m_TotalEntries;
          private static SlayerGroup[] m_Groups;
          private SlayerGroup[] m_Opposition;
          private SlayerEntry m_Super;
          private SlayerEntry[] m_Entries;
          private Type[] m_FoundOn;
  
          public SlayerGroup()
          {
          }
  
          static SlayerGroup()
          {
              SlayerGroup humanoid = new SlayerGroup();
              SlayerGroup undead = new SlayerGroup();
              SlayerGroup elemental = new SlayerGroup();
              SlayerGroup abyss = new SlayerGroup();
              SlayerGroup arachnid = new SlayerGroup();
              SlayerGroup reptilian = new SlayerGroup();
              SlayerGroup fey = new SlayerGroup();
              SlayerGroup eodon = new SlayerGroup();
              SlayerGroup eodonTribe = new SlayerGroup();
              SlayerGroup dino = new SlayerGroup();
              SlayerGroup myrmidex = new SlayerGroup();
  
              humanoid.Opposition = new SlayerGroup[]
                  {
                      undead
                  };
  
              humanoid.FoundOn = new Type[]
                  {
                      typeof(BoneKnight),     typeof(Lich),
                      typeof(LichLord)
                  };
  
              humanoid.Super = new SlayerEntry
                  (
                      SlayerName.Repond,
  
                      typeof(ClanCA), typeof(ClanCT),
                      typeof(ClanRS), typeof(ClanRC),
                      typeof(ClanSS), typeof(ClanSH),
                      typeof(Barracoon), typeof(MasterTheophilus),
                      typeof(Lurg), typeof(ArcticOgreLord),
                      typeof(Cyclops), typeof(Ettin),
                      typeof(EvilMage), typeof(EvilMageLord),
                      typeof(FrostTroll), typeof(MeerCaptain),
                      typeof(MeerEternal), typeof(MeerMage),
                      typeof(MeerWarrior), typeof(Ogre),
                      typeof(OgreLord), typeof(Orc),
                      typeof(OrcBomber), typeof(OrcBrute),
                      typeof(OrcCaptain), typeof(OrcChopper),
                      typeof(OrcScout), typeof(OrcishLord),
                      typeof(OrcishMage), typeof(Ratman),
                      typeof(RatmanArcher), typeof(RatmanMage),
                      typeof(SavageRider), typeof(SavageShaman),
                      typeof(Savage), typeof(Titan),
                      typeof(Troglodyte), typeof(Troll),
                      typeof(Troglodyte), typeof(MougGuur),
                      typeof(Chiikkaha), typeof(Minotaur),
                      typeof(MinotaurGeneral), typeof(Medusa),
                      typeof(RakktaviRenowned), typeof(TikitaviRenowned),
                      typeof(VitaviRenowned), typeof(EnslavedGoblinScout),
                      typeof(EnslavedGoblinKeeper), typeof(EnslavedGreenGoblin),
                      typeof(EnslavedGreenGoblinAlchemist), typeof(EnslavedGoblinMage),
                      typeof(EnslavedGrayGoblin), typeof(GreenGoblinScout),
                      typeof(GreenGoblinAlchemist), typeof(GreenGoblin),
                      typeof(GrayGoblinMage), typeof(GrayGoblinKeeper),
                      typeof(GrayGoblin), typeof(GreenGoblinAlchemistRenowned),
                      typeof(GrayGoblinMageRenowned), typeof(CorgulTheSoulBinder)
                  );
  
              humanoid.Entries = new SlayerEntry[]
              {
                  new SlayerEntry
                      (
                          SlayerName.OgreTrashing,
  
                          typeof(Ogre),               typeof(OgreLord),
                          typeof(ArcticOgreLord)
                      ),
  
                  new SlayerEntry
                      (
                          SlayerName.OrcSlaying,
  
                          typeof(Orc),            typeof(OrcBomber),
                          typeof(OrcBrute),       typeof(OrcCaptain),
                          typeof(OrcChopper),     typeof(OrcScout),
                          typeof(OrcishLord),     typeof(OrcishMage)
                      ),
  
                  new SlayerEntry
                      (
                          SlayerName.TrollSlaughter,
  
                          typeof(Troll),  typeof(FrostTroll)
                      ),
              };
  
              undead.Opposition = new SlayerGroup[]
                  {
                      humanoid
                  };
  
              undead.Super = new SlayerEntry
                  (
                      SlayerName.Silver,
  
                      typeof(AncientLich), typeof(AncientLichRenowned),
                      typeof(Bogle), typeof(BoneKnight),
                      typeof(BoneMagi), typeof(DarkGuardian),
                      typeof(DarknightCreeper), typeof(FleshGolem),
                      typeof(Ghoul), typeof(GoreFiend),
                      typeof(HellSteed), typeof(LadyOfTheSnow),
                      typeof(Lich), typeof(LichLord),
                      typeof(Mummy), typeof(PestilentBandage),
                      typeof(Revenant), typeof(RevenantLion),
                      typeof(RottingCorpse), typeof(Shade),
                      typeof(ShadowKnight), typeof(SkeletalKnight),
                      typeof(SkeletalMage), typeof(SkeletalMount),
                      typeof(Skeleton), typeof(Spectre),
                      typeof(Wraith), typeof(Zombie),
                      typeof(UnfrozenMummy), typeof(RedDeath),
                      typeof(SirPatrick), typeof(LadyJennifyr),
                      typeof(MasterMikael), typeof(MasterJonath),
                      typeof(LadyMarai), typeof(PrimevalLich),
                      typeof(Niporailem), typeof(DreamWraith),
                      typeof(EffeteUndeadGargoyle), typeof(UndeadGargoyle),
                      typeof(UndeadGuardian), typeof(PutridUndeadGargoyle),
                      typeof(PutridUndeadGuardian), typeof(Juonar)
                  );
  
              undead.Entries = new SlayerEntry[0];
  
              fey.Opposition = new SlayerGroup[]
                  {
                      abyss
                  };
  
              fey.Super = new SlayerEntry
                  (
                      SlayerName.Fey,
  
                      typeof(Centaur), typeof(CuSidhe),
                      typeof(EtherealWarrior), typeof(Kirin),
                      typeof(LordOaks), typeof(Pixie),
                      typeof(PixieRenowned), typeof(Silvani),
                      typeof(Treefellow), typeof(Unicorn),
                      typeof(Wisp), typeof(MLDryad),
                      typeof(Satyr), typeof(Changeling),
                      typeof(InsaneDryad), typeof(CorporealBrume),
                      typeof(CrystalLatticeSeeker), typeof(LadyMelisande),
                      typeof(DreadHorn), typeof(Travesty),
                      typeof(ShimmeringEffusion), typeof(Guile),
                      typeof(Irk), typeof(DarkWisp),
                      typeof(FeralTreefellow)
                  );
  
              fey.Entries = new SlayerEntry[0];
  
              elemental.Opposition = new SlayerGroup[]
                  {
                      abyss
                  };
  
              elemental.FoundOn = new Type[]
                  {
                      typeof(Balron),     typeof(Daemon),
                      typeof(Putrefier),  typeof(FireDaemonRenowned)
                  };
  
              elemental.Super = new SlayerEntry
                  (
                      SlayerName.ElementalBan,
  
                      typeof(LavaElemental), typeof(ToxicElemental),
                      typeof(AcidElemental), typeof(AcidElementalRenowned),
                      typeof(FireElementalRenowned), typeof(AgapiteElemental),
                      typeof(AirElemental), typeof(SummonedAirElemental),
                      typeof(BloodElemental), typeof(BronzeElemental),
                      typeof(CopperElemental), typeof(CrystalElemental),
                      typeof(DullCopperElemental), typeof(EarthElemental),
                      typeof(SummonedEarthElemental), typeof(Efreet),
                      typeof(FireElemental), typeof(SummonedFireElemental),
                      typeof(GoldenElemental), typeof(IceElemental),
                      typeof(KazeKemono), typeof(PoisonElemental),
                      typeof(RaiJu), typeof(SandVortex),
                      typeof(ShadowIronElemental), typeof(SnowElemental),
                      typeof(ValoriteElemental), typeof(VeriteElemental),
                      typeof(WaterElemental), typeof(SummonedWaterElemental),
                      typeof(Flurry), typeof(Mistral),
                      typeof(Tempest), typeof(UnboundEnergyVortex),
                      typeof(ChaosVortex), typeof(WindElemental),
                      typeof(FlameElemental), typeof(QuartzElemental),
                      typeof(VoidManifestation)
                  );
  
              elemental.Entries = new SlayerEntry[]
                  {
                      new SlayerEntry
                          (
                              SlayerName.BloodDrinking,
  
                              typeof(BloodElemental)
                          ),
  
                      new SlayerEntry
                          (
                              SlayerName.EarthShatter,
  
                              typeof(AgapiteElemental),   typeof(BronzeElemental),
                              typeof(CopperElemental),    typeof(DullCopperElemental),
                              typeof(EarthElemental),     typeof(SummonedEarthElemental),
                              typeof(GoldenElemental),    typeof(ShadowIronElemental),
                              typeof(ValoriteElemental),  typeof(VeriteElemental),
                              typeof(QuartzElemental)
                          ),
  
                      new SlayerEntry
                          (
                              SlayerName.ElementalHealth,
  
                              typeof(PoisonElemental)
                          ),
  
                      new SlayerEntry
                          (
                              SlayerName.FlameDousing,
  
                              typeof(FireElemental),  typeof(FireElementalRenowned),
                              typeof(SummonedFireElemental), typeof(FlameElemental)
                          ),
  
                      new SlayerEntry
                          (
                              SlayerName.SummerWind,
  
                              typeof(SnowElemental),  typeof(IceElemental)
                          ),
  
                      new SlayerEntry
                          (
                              SlayerName.Vacuum,
  
                              typeof(AirElemental),   typeof(SummonedAirElemental),
                              typeof(Flurry),         typeof(Mistral),
                              typeof(Tempest),        typeof(UnboundEnergyVortex),
                              typeof(ChaosVortex),    typeof(WindElemental)
                          ),
  
                      new SlayerEntry
                          (
                              SlayerName.WaterDissipation,
  
                              typeof(WaterElemental),     typeof(SummonedWaterElemental)
                          )
                  };
  
              abyss.Opposition = new SlayerGroup[]
                  {
                      elemental,
                      fey
                  };
  
              abyss.FoundOn = new Type[]
                  {
                      typeof(BloodElemental)
                  };
  
              if (Core.AOS)
              {
                  abyss.Super = new SlayerEntry
                      (
                          SlayerName.Exorcism,
  
                          typeof(DevourerRenowned), typeof(FireDaemonRenowned),
                          typeof(AbysmalHorror), typeof(AbyssalInfernal),
                          typeof(ArcaneDaemon), typeof(Balron),
                          typeof(BoneDemon), typeof(ChaosDaemon),
                          typeof(Daemon), typeof(SummonedDaemon),
                          typeof(DemonKnight), typeof(Devourer),
                          typeof(EnslavedGargoyle), typeof(FanDancer),
                          typeof(FireGargoyle), typeof(Gargoyle),
                          typeof(GargoyleDestroyer), typeof(GargoyleEnforcer),
                          typeof(Gibberling), typeof(HordeMinion),
                          typeof(FireDaemon), typeof(IceFiend),
                          typeof(Imp), typeof(Impaler),
                          typeof(Moloch), typeof(Oni),
                          typeof(Ravager), typeof(Semidar),
                          typeof(StoneGargoyle), typeof(Succubus),
                          typeof(PatchworkSkeleton), typeof(TsukiWolf),
                          typeof(Szavetra), typeof(CrystalDaemon),
                          typeof(SlasherOfVeils), typeof(GargoyleShade),
                          typeof(Putrefier), typeof(ChiefParoxysmus),
                          typeof(Anzuanord), typeof(Ballem),
                          typeof(Betballem), typeof(SkeletalLich),
                          typeof(UsagralemBallem), typeof(EffetePutridGargoyle),
                          typeof(EffeteUndeadGargoyle), typeof(PitFiend),
                          typeof(ArchDaemon), typeof(AbyssalAbomination),
                          typeof(Virtuebane)
                      );
  
                  abyss.Entries = new SlayerEntry[]
                  {
                      // Daemon Dismissal & Balron Damnation have been removed and moved up to super slayer on OSI.
                      new SlayerEntry
                          (
                              SlayerName.GargoylesFoe,
  
                              typeof(EnslavedGargoyle),       typeof(FireGargoyle),
                              typeof(Gargoyle),               typeof(GargoyleDestroyer),
                              typeof(GargoyleEnforcer),       typeof(StoneGargoyle),
                              typeof(GargoyleShade),          typeof(EffetePutridGargoyle),
                              typeof(EffeteUndeadGargoyle)
                          ),
                  };
              }
              else
              {
                  abyss.Super = new SlayerEntry
                      (
                          SlayerName.Exorcism,
  
                          typeof(AbysmalHorror), typeof(Balron),
                          typeof(BoneDemon), typeof(ChaosDaemon),
                          typeof(Daemon), typeof(SummonedDaemon),
                          typeof(DemonKnight), typeof(Devourer),
                          typeof(Gargoyle), typeof(FireGargoyle),
                          typeof(Gibberling), typeof(HordeMinion),
                          typeof(IceFiend), typeof(Imp),
                          typeof(Impaler), typeof(Ravager),
                          typeof(StoneGargoyle), typeof(ArcaneDaemon),
                          typeof(EnslavedGargoyle), typeof(GargoyleDestroyer),
                          typeof(GargoyleEnforcer), typeof(Moloch)
                      );
  
                  abyss.Entries = new SlayerEntry[]
                  {
                      new SlayerEntry
                          (
                              SlayerName.DaemonDismissal,
  
                              typeof(Semidar),        typeof(AbyssalInfernal),
                              typeof(AbysmalHorror),  typeof(Balron),
                              typeof(BoneDemon),      typeof(ChaosDaemon),
                              typeof(Daemon),         typeof(SummonedDaemon),
                              typeof(DemonKnight),    typeof(Devourer),
                              typeof(Gibberling),     typeof(HordeMinion),
                              typeof(IceFiend),       typeof(Imp),
                              typeof(Impaler),        typeof(Ravager),
                              typeof(ArcaneDaemon),   typeof(Moloch)
                          ),
  
                      new SlayerEntry
                          (
                              SlayerName.GargoylesFoe,
  
                              typeof(FireGargoyle),       typeof(Gargoyle),
                              typeof(StoneGargoyle),      typeof(EnslavedGargoyle),
                              typeof(GargoyleDestroyer),  typeof(GargoyleEnforcer)
                          ),
  
                      new SlayerEntry
                          (
                              SlayerName.BalronDamnation,
  
                              typeof(Balron)
                          )
                  };
              }
  
              arachnid.Opposition = new SlayerGroup[]
                  {
                      reptilian
                  };
  
              arachnid.FoundOn = new Type[]
                  {
                      typeof(AncientWyrm),    typeof(GreaterDragon),
                      typeof(Dragon),         typeof(OphidianMatriarch),
                      typeof(ShadowWyrm)
                  };
  
              arachnid.Super = new SlayerEntry
                  (
                      SlayerName.ArachnidDoom,
  
                      typeof(DreadSpider), typeof(FrostSpider),
                      typeof(GiantBlackWidow), typeof(GiantSpider),
                      typeof(Mephitis), typeof(Scorpion),
                      typeof(TerathanAvenger), typeof(TerathanDrone),
                      typeof(TerathanMatriarch), typeof(TerathanWarrior),
                      typeof(Miasma), typeof(SpeckledScorpion),
                      typeof(LadyLissith), typeof(LadySabrix),
                      typeof(Virulent), typeof(Silk),
                      typeof(Malefic), typeof(Navrey),
                      typeof(SentinelSpider), typeof(WolfSpider),
                      typeof(TrapdoorSpider), typeof(Anlorzen),
                      typeof(Anlorlem)
                  );
  
              arachnid.Entries = new SlayerEntry[]
              {
                  new SlayerEntry
                      (
                          SlayerName.ScorpionsBane,
  
                          typeof(Scorpion),           typeof(Miasma),
                          typeof(SpeckledScorpion)
                      ),
  
                  new SlayerEntry
                      (
                          SlayerName.SpidersDeath,
  
                          typeof(DreadSpider),        typeof(FrostSpider),
                          typeof(GiantBlackWidow),    typeof(GiantSpider),
                          typeof(Mephitis),           typeof(LadyLissith),
                          typeof(LadySabrix),         typeof(Virulent),
                          typeof(Silk),               typeof(Malefic),
                          typeof(Navrey),             typeof(SentinelSpider),
                          typeof(WolfSpider),         typeof(TrapdoorSpider),
                          typeof(Anlorzen)
                      ),
  
                  new SlayerEntry
                      (
                          SlayerName.Terathan,
  
                          typeof(TerathanAvenger),    typeof(TerathanDrone),
                          typeof(TerathanMatriarch),  typeof(TerathanWarrior),
                          typeof(Anlorlem)
                      )
              };
  
              reptilian.Opposition = new SlayerGroup[]
                  {
                      arachnid
                  };
  
              reptilian.FoundOn = new Type[]
                  {
                      typeof(TerathanAvenger),    typeof(TerathanMatriarch)
                  };
  
              reptilian.Super = new SlayerEntry
                  (
                      SlayerName.ReptilianDeath,
  
                      typeof(Rikktor), typeof(Serado),
                      typeof(SkeletalDragonRenowned), typeof(WyvernRenowned),
                      typeof(AncientWyrm), typeof(DeepSeaSerpent),
                      typeof(GreaterDragon), typeof(Dragon),
                      typeof(Drake), typeof(GiantIceWorm),
                      typeof(IceSerpent), typeof(GiantSerpent),
                      typeof(Hiryu), typeof(IceSnake),
                      typeof(JukaLord), typeof(JukaMage),
                      typeof(JukaWarrior), typeof(LavaSerpent),
                      typeof(LavaSnake), typeof(LesserHiryu),
                      typeof(Lizardman), typeof(OphidianArchmage),
                      typeof(OphidianKnight), typeof(OphidianMage),
                      typeof(OphidianMatriarch), typeof(OphidianWarrior),
                      typeof(Reptalon), typeof(SeaSerpent),
                      typeof(Serado), typeof(SerpentineDragon),
                      typeof(ShadowWyrm), typeof(SilverSerpent),
                      typeof(SkeletalDragon), typeof(Snake),
                      typeof(SwampDragon), typeof(WhiteWyrm),
                      typeof(Wyvern), typeof(Yamandon),
                      typeof(Hydra), typeof(CrystalHydra),
                      typeof(CrystalSeaSerpent), typeof(Rend),
                      typeof(Thrasher), typeof(Abscess),
                      typeof(Grim), typeof(ChickenLizard),
                      typeof(StygianDragon), typeof(FairyDragon),
                      typeof(Skree), typeof(Slith),
                      typeof(StoneSlith), typeof(ToxicSlith),
                      typeof(Raptor), typeof(Kepetch),
                      typeof(KepetchAmbusher), typeof(FrostDragon),
                      typeof(ColdDrake), typeof(Coil),
                      typeof(SkeletalDrake), typeof(CoralSnake)
                  );
  
              reptilian.Entries = new SlayerEntry[]
              {
                  new SlayerEntry
                      (
                          SlayerName.DragonSlaying,
  
                          typeof(Rikktor),            typeof(SkeletalDragonRenowned),
                          typeof(WyvernRenowned),     typeof(AncientWyrm),
                          typeof(GreaterDragon),      typeof(Dragon),
                          typeof(Drake),              typeof(Hiryu),
                          typeof(LesserHiryu),        typeof(Reptalon),
                          typeof(SerpentineDragon),   typeof(ShadowWyrm),
                          typeof(SkeletalDragon),     typeof(SwampDragon),
                          typeof(WhiteWyrm),          typeof(Wyvern),
                          typeof(Hydra),              typeof(CrystalHydra),
                          typeof(Rend),               typeof(Abscess),
                          typeof(Grim),               typeof(StygianDragon),
                          typeof(FairyDragon),        typeof(SkeletalDrake),
                          typeof(ColdDrake)
                      ),
  
                  new SlayerEntry
                      (
                          SlayerName.LizardmanSlaughter,
  
                          typeof(Lizardman)
                      ),
  
                  new SlayerEntry
                      (
                          SlayerName.Ophidian,
  
                          typeof(OphidianArchmage),   typeof(OphidianKnight),
                          typeof(OphidianMage),       typeof(OphidianMatriarch),
                          typeof(OphidianWarrior)
                      ),
  
                  new SlayerEntry
                      (
                          SlayerName.SnakesBane,
  
                          typeof(Serado),         typeof(DeepSeaSerpent),
                          typeof(GiantIceWorm),   typeof(GiantSerpent),
                          typeof(IceSerpent),     typeof(IceSnake),
                          typeof(LavaSerpent),    typeof(LavaSnake),
                          typeof(SeaSerpent),     typeof(Serado),
                          typeof(SilverSerpent),  typeof(Snake),
                          typeof(Yamandon),       typeof(CrystalSeaSerpent),
                          typeof(Coil),           typeof(CoralSnake)
                      )
              };
  
              eodon.Opposition = new SlayerGroup[] { };
              eodon.FoundOn = new Type[] { };
              eodon.Super = 
                  new SlayerEntry(
                      
                      SlayerName.Eodon, 
                      
                      typeof(Dimetrosaur), typeof(Gallusaurus), 
                      typeof(Archaeosaurus), typeof(Najasaurus),
                      typeof(Saurosaurus), typeof(Allosaurus), 
                      typeof(MyrmidexLarvae), typeof(MyrmidexDrone), 
                      typeof(MyrmidexWarrior), typeof(DragonTurtle), 
                      typeof(DragonTurtleHatchling), typeof(DesertScorpion),
                      typeof(TribeWarrior), typeof(TribeShaman), 
                      typeof(TribeChieftan), typeof(WildTiger), 
                      typeof(WildBlackTiger), typeof(WildWhiteTiger), 
                      typeof(SilverbackGorilla));
  
  
gt:             eodon.Entries = new SlayerEntry[] { };