@EventHandler()
 public void Init(FMLInitializationEvent Init) {
   loadProps(CBCMod.config);
   XenBlocks.init(CBCMod.config);
   proxy.init();
   DimensionManager.registerProviderType(
       xenContinentDimensionID, WorldProviderXenContinent.class, true);
   DimensionManager.registerDimension(xenContinentDimensionID, xenContinentDimensionID);
   EntityRegistry.addSpawn(
       EntityHoundeye.class,
       25,
       15,
       15,
       EnumCreatureType.monster,
       MainBiomes.xenHill,
       MainBiomes.xenPlain);
   EntityRegistry.addSpawn(
       EntityHeadcrab.class,
       25,
       15,
       15,
       EnumCreatureType.monster,
       MainBiomes.xenHill,
       MainBiomes.xenPlain);
   EntityRegistry.addSpawn(
       EntityAlienSlave.class, 10, 15, 15, EnumCreatureType.monster, MainBiomes.xenHill);
   EntityRegistry.addSpawn(
       EntityBarnacle.class,
       6,
       15,
       15,
       EnumCreatureType.monster,
       MainBiomes.xenHill,
       MainBiomes.xenPlain);
 }
  /** Registers Entities */
  public void registerEntities() {
    EntityRegistry.registerModEntity(
        EntityParadoxHunter.class, "ParadoxHunter", 1, this, 80, 1, true);
    EntityRegistry.registerModEntity(EntityPlayerPast.class, "PastPlayer", 2, this, 80, 1, true);
    EntityRegistry.addSpawn(
        EntityParadoxHunter.class,
        10,
        2,
        4,
        EnumCreatureType.creature,
        BiomeGenBase.beach,
        BiomeGenBase.extremeHills,
        BiomeGenBase.extremeHillsEdge,
        BiomeGenBase.forest,
        BiomeGenBase.forestHills,
        BiomeGenBase.jungle,
        BiomeGenBase.jungleHills,
        BiomeGenBase.mushroomIsland,
        BiomeGenBase.mushroomIslandShore,
        BiomeGenBase.ocean,
        BiomeGenBase.plains,
        BiomeGenBase.river,
        BiomeGenBase.swampland);
    LanguageRegistry.instance()
        .addStringLocalization("entity.Charsmud_TimeTraveler.ParadoxHunter.name", "Paradox Hunter");

    registerEntityEgg(EntityParadoxHunter.class, 0xffffff, 0x000000);
  }
    public static void addSpawn(String entityName, int weightedProb, int min, int max, EnumCreatureType spawnList, BiomeGenBase... biomes)
    {
        Class <? extends Entity > entityClazz = (Class<? extends Entity>) EntityList.stringToClassMapping.get(entityName);

        if (EntityLiving.class.isAssignableFrom(entityClazz))
        {
            addSpawn((Class <? extends EntityLiving >) entityClazz, weightedProb, min, max, spawnList, biomes);
        }
    }
  public static void createEntity(
      Class entityClass, String entityName, int solidColor, int spotColor) {
    int randomId = EntityRegistry.findGlobalUniqueEntityId();
    EntityRegistry.registerGlobalEntityID(entityClass, entityName, randomId);
    EntityRegistry.registerModEntity(
        entityClass, entityName, randomId, ProjectVelocityCore.instance, 64, 1, true);
    EntityRegistry.addSpawn(entityClass, 2, 0, 1, EnumCreatureType.creature, BiomeGenBase.forest);

    createEgg(randomId, solidColor, spotColor);
  }
 public void addSpawn(
     Class<? extends EntityLiving> entityClass,
     int spawnProb,
     int min,
     int max,
     BiomeGenBase[] biomes) {
   if (spawnProb > 0) {
     EntityRegistry.addSpawn(entityClass, spawnProb, min, max, EnumCreatureType.monster, biomes);
   }
 }
  @EventHandler
  public void Load(FMLPreInitializationEvent Event) {

    // Settings For Our Creative Tab
    hazzachooks_star_wars_addon_tab =
        new CreativeTabs("hazzachooks_star_wars_addon_tab") {
          public ItemStack getIconItemStack() {
            return new ItemStack(darkBlade, 1, 0);
          }
        };
    LanguageRegistry.instance()
        .addStringLocalization(
            "itemGroup.hazzachooks_star_wars_addon_tab",
            "en_US",
            "Hazzachooks Star Wars Addon Tab");

    // Settings For Our Items
    darkBlade =
        new DarkBlade(2000, dark_blade_enum)
            .setUnlocalizedName("dark blade")
            .setCreativeTab(this.hazzachooks_star_wars_addon_tab);

    // Settings For Our Mobs
    EntityRegistry.registerGlobalEntityID(Entity_deathwatch.class, "Deathwatch", 1);
    EntityRegistry.addSpawn(Entity_deathwatch.class, 20, 5, 20, EnumCreatureType.monster);
    EntityRegistry.findGlobalUniqueEntityId();
    registerEntityEgg(Entity_deathwatch.class, 0xF1EDED, 0x0020C2);
    RenderingRegistry.registerEntityRenderingHandler(
        Entity_deathwatch.class, new Renderdeathwatch(new Model_deathwatch(), 0.3F));
    EntityRegistry.registerGlobalEntityID(Entity_pre_vizsla.class, "Pre-Vizsla", 1);
    EntityRegistry.addSpawn(Entity_pre_vizsla.class, 20, 5, 20, EnumCreatureType.monster);
    registerEntityEgg(Entity_pre_vizsla.class, 0xF1EDED, 0x0020C2);
    RenderingRegistry.registerEntityRenderingHandler(
        Entity_pre_vizsla.class, new Renderprevizsla(new Model_pre_vizsla(), 0.3F));

    // Register Our Items
    GameRegistry.registerItem(darkBlade, "darkBlade");
    LanguageRegistry.addName(darkBlade, "Dark Saber");
  }
Beispiel #7
0
  @Init
  public void init(FMLInitializationEvent evt) {
    WCLanguage.init(evt);

    GameRegistry.registerTileEntity(TileEntityWarpInfuser.class, "Infuser");

    // Ore Generation
    GameRegistry.registerWorldGenerator(new WorldGeneratorWarpCraft());

    // Register Rendering Information
    proxy.registerRenderInformation();
    proxy.registerEntityInformation();
    // Register Dimension

    EntityRegistry.addSpawn(
        EntityRat.class, 5, 2, 3, EnumCreatureType.monster, WCBiomeGenBase.warp);
    EntityRegistry.addSpawn(
        EntitySquig.class, 2, 1, 2, EnumCreatureType.monster, WCBiomeGenBase.warp);
    // stuff

    TickRegistry.registerTickHandler(new ClientTickHandler(), Side.CLIENT);
  }
  /** Registers the entities in this mod and adds mob spawns. */
  private void registerMobs() {
    DataWatcherHelper.init();

    int id = 0; // Mod-specific mob id

    // Initialize everything needed to make new spawn eggs
    boolean makeSpawnEggs = Properties.getBoolean(Properties.GENERAL, "spawn_eggs");
    Method eggIdClaimer = null;
    int eggId;
    if (makeSpawnEggs) {
      try {
        eggIdClaimer = EntityRegistry.class.getDeclaredMethod("validateAndClaimId", int.class);
        eggIdClaimer.setAccessible(true);
      } catch (Exception ex) {
        _SpecialMobs.console(
            "Error claiming spawn egg ID! Spawn eggs will probably be overwritten.");
        ex.printStackTrace();
      }
    }

    // Advanced Genetics compatibility
    Method advGeneticsAddAbility = null;
    String[][] advGeneticsAbilities = null;
    try {
      Class regHelper = Class.forName("com.advGenetics.API.RegistrationHelper");
      _SpecialMobs.console("Detected Advanced Genetics API, attempting to register mobs to it...");
      try {
        advGeneticsAddAbility =
            regHelper.getDeclaredMethod("addEntityToAbility", String.class, Class.class);
      } catch (Exception ex) {
        _SpecialMobs.console("Error finding Advanced Genetics registry!");
        ex.printStackTrace();
      }
      if (advGeneticsAddAbility != null) {
        advGeneticsAbilities =
            new String[][] {
              // Blaze
              {"fireballs"},
              // CaveSpider
              {"climb", "poison"},
              // Creeper
              {"selfexplode"},
              // Enderman
              {"deathenderchest", "teleport"},
              // Ghast
              {"fireballsexplode"},
              // LavaSlime
              // { "slimy", "lavaswim" },
              // PigZombie
              {"lavaswim"},
              // Silverfish
              {},
              // Skeleton
              {"infinity"},
              // Slime
              {"slimy"},
              // Spider
              {"climb"},
              // Witch
              {"potionthrower"},
              // Zombie
              {"resistance"}
            };
        for (String ability : advGeneticsAbilities[_SpecialMobs.monsterKey("Enderman")]) {
          try {
            advGeneticsAddAbility.invoke(null, ability, EntityEnderCreeper.class);
          } catch (Exception ex) {
            // Do nothing
          }
        }
      }
    } catch (Exception ex) {
      // Do nothing, Advanced Genetics not found
    }

    // Register main mobs
    String name;
    Class entityClass;
    for (int i = 0; i < _SpecialMobs.MONSTER_KEY.length; i++) {
      // Register vanilla replacement
      try {
        entityClass =
            Class.forName(
                "toast.specialMobs.entity."
                    + _SpecialMobs.MONSTER_KEY[i].toLowerCase()
                    + ".Entity_Special"
                    + _SpecialMobs.MONSTER_KEY[i]);
        EntityRegistry.registerModEntity(
            entityClass, "Special" + _SpecialMobs.MONSTER_KEY[i], id++, this, 80, 3, true);

        // Advanced Genetics compatibility
        if (advGeneticsAddAbility != null && advGeneticsAbilities != null) {
          for (String ability : advGeneticsAbilities[i]) {
            try {
              advGeneticsAddAbility.invoke(null, ability, entityClass);
            } catch (Exception ex) {
              // Do nothing
            }
          }
        }
      } catch (ClassNotFoundException ex) {
        _SpecialMobs.debugException("@" + _SpecialMobs.MONSTER_KEY[i] + ": class not found!");
      }

      // Register special variants
      for (int j = 0; j < _SpecialMobs.MONSTER_TYPES[i].length; j++) {
        name = _SpecialMobs.MONSTER_TYPES[i][j] + _SpecialMobs.MONSTER_KEY[i];
        try {
          entityClass =
              Class.forName(
                  "toast.specialMobs.entity."
                      + _SpecialMobs.MONSTER_KEY[i].toLowerCase()
                      + ".Entity"
                      + name);
          EntityRegistry.registerModEntity(entityClass, name, id++, this, 80, 3, true);

          // Add spawn egg by taking a global mob id
          if (makeSpawnEggs) {
            eggId = EntityRegistry.findGlobalUniqueEntityId();
            try {
              if (eggIdClaimer != null) {
                eggId =
                    ((Integer)
                            eggIdClaimer.invoke(EntityRegistry.instance(), Integer.valueOf(eggId)))
                        .intValue();
              }
            } catch (Exception ex) {
              // Do nothing
            }
            EntityList.IDtoClassMapping.put(Integer.valueOf(eggId), entityClass);
            EntityList.entityEggs.put(
                Integer.valueOf(eggId),
                new EntityEggInfo(
                    eggId,
                    _SpecialMobs.MONSTER_KEY_COLORS[i],
                    _SpecialMobs.MONSTER_TYPE_COLORS[i][j]));
          }

          // Advanced Genetics compatibility
          if (advGeneticsAddAbility != null && advGeneticsAbilities != null) {
            for (String ability : advGeneticsAbilities[i]) {
              try {
                advGeneticsAddAbility.invoke(null, ability, entityClass);
              } catch (Exception ex) {
                // Do nothing
              }
            }
          }
        } catch (ClassNotFoundException ex) {
          _SpecialMobs.debugException("@" + name + ": class not found!");
        }
      }
    }

    // Register other entities (like projectiles)
    EntityRegistry.registerModEntity(
        EntitySpecialFishHook.class, "SMFishHook", id++, this, 64, 5, true);
    EntityRegistry.registerModEntity(
        EntitySpecialSpitball.class, "SMSpitball", id++, this, 64, 5, true);

    // EntityRegistry.registerModEntity(EntitySpecialFireball.class, "SMFireball", id++, this, 64,
    // 10, true);

    DataWatcherHelper.verify();

    // Register extra mob spawns
    int spawnWeight;
    spawnWeight = Properties.getInt(Properties.SPAWNING, "end_ender_creeper");
    if (spawnWeight > 0) {
      EntityRegistry.addSpawn(
          EntityEnderCreeper.class, spawnWeight, 1, 1, EnumCreatureType.monster, BiomeGenBase.sky);
    }
    spawnWeight = Properties.getInt(Properties.SPAWNING, "nether_fire_creeper");
    if (spawnWeight > 0) {
      EntityRegistry.addSpawn(
          EntityFireCreeper.class, spawnWeight, 4, 4, EnumCreatureType.monster, BiomeGenBase.hell);
    }
    spawnWeight = Properties.getInt(Properties.SPAWNING, "overworld_ghast_mount");
    if (spawnWeight > 0) {
      EntityRegistry.addSpawn(
          EntityMiniGhast.class,
          spawnWeight,
          1,
          1,
          EnumCreatureType.monster,
          BiomeGenBase.ocean,
          BiomeGenBase.frozenOcean,
          BiomeGenBase.plains,
          BiomeGenBase.desert,
          BiomeGenBase.desertHills,
          BiomeGenBase.extremeHills,
          BiomeGenBase.extremeHillsEdge,
          BiomeGenBase.forest,
          BiomeGenBase.forestHills,
          BiomeGenBase.taiga,
          BiomeGenBase.taigaHills,
          BiomeGenBase.swampland,
          BiomeGenBase.river,
          BiomeGenBase.frozenRiver,
          BiomeGenBase.icePlains,
          BiomeGenBase.iceMountains,
          BiomeGenBase.beach,
          BiomeGenBase.jungle,
          BiomeGenBase.jungleHills);
    }
  }
Beispiel #9
0
  public static void init() {
    EntityRegistry.registerModEntity(
        EntityAssassin.class,
        Names.entityAssassin_unlocalizedName,
        Ids.entityAssassin,
        Allsgard.instance,
        35,
        1,
        true);
    RenderingRegistry.registerEntityRenderingHandler(
        EntityAssassin.class, new EntityAssassinRender(new ModelBiped(), 0.4F));
    EntityRegistry.addSpawn(
        EntityAssassin.class,
        4,
        1,
        1,
        EnumCreatureType.monster,
        BiomeGenBase.beach,
        BiomeGenBase.desert,
        BiomeGenBase.desertHills,
        BiomeGenBase.extremeHills,
        BiomeGenBase.extremeHillsEdge,
        BiomeGenBase.forest,
        BiomeGenBase.forestHills,
        BiomeGenBase.frozenOcean,
        BiomeGenBase.frozenRiver,
        BiomeGenBase.iceMountains,
        BiomeGenBase.icePlains,
        BiomeGenBase.jungle,
        BiomeGenBase.jungleHills,
        BiomeGenBase.mushroomIsland,
        BiomeGenBase.mushroomIslandShore,
        BiomeGenBase.ocean,
        BiomeGenBase.plains,
        BiomeGenBase.river,
        BiomeGenBase.swampland,
        BiomeGenBase.taiga,
        BiomeGenBase.taigaHills);

    EntityRegistry.registerModEntity(
        EntityCitizen.class,
        Names.entityCitizen_unlocalizedName,
        Ids.entityCitizen,
        Allsgard.instance,
        35,
        1,
        true);
    RenderingRegistry.registerEntityRenderingHandler(
        EntityCitizen.class, new EntityCitizenRender(new ModelBiped(), 0.4F));
    EntityRegistry.addSpawn(
        EntityCitizen.class,
        15,
        3,
        8,
        EnumCreatureType.ambient,
        BiomeGenBase.beach,
        BiomeGenBase.desert,
        BiomeGenBase.desertHills,
        BiomeGenBase.extremeHills,
        BiomeGenBase.extremeHillsEdge,
        BiomeGenBase.forest,
        BiomeGenBase.forestHills,
        BiomeGenBase.frozenOcean,
        BiomeGenBase.frozenRiver,
        BiomeGenBase.iceMountains,
        BiomeGenBase.icePlains,
        BiomeGenBase.jungle,
        BiomeGenBase.jungleHills,
        BiomeGenBase.mushroomIsland,
        BiomeGenBase.mushroomIslandShore,
        BiomeGenBase.ocean,
        BiomeGenBase.plains,
        BiomeGenBase.river,
        BiomeGenBase.swampland,
        BiomeGenBase.taiga,
        BiomeGenBase.taigaHills);

    EntityRegistry.registerModEntity(
        EntityGoblin.class,
        Names.entityGoblin_unlocalizedName,
        Ids.entityGoblin,
        Allsgard.instance,
        35,
        1,
        true);
    RenderingRegistry.registerEntityRenderingHandler(
        EntityGoblin.class, new EntityGoblinRender(new ModelGoblin(), 0.4F));
    EntityRegistry.addSpawn(
        EntityGoblin.class,
        7,
        3,
        8,
        EnumCreatureType.monster,
        BiomeGenBase.beach,
        BiomeGenBase.desert,
        BiomeGenBase.desertHills,
        BiomeGenBase.extremeHills,
        BiomeGenBase.extremeHillsEdge,
        BiomeGenBase.forest,
        BiomeGenBase.forestHills,
        BiomeGenBase.frozenOcean,
        BiomeGenBase.frozenRiver,
        BiomeGenBase.iceMountains,
        BiomeGenBase.icePlains,
        BiomeGenBase.jungle,
        BiomeGenBase.jungleHills,
        BiomeGenBase.mushroomIsland,
        BiomeGenBase.mushroomIslandShore,
        BiomeGenBase.ocean,
        BiomeGenBase.plains,
        BiomeGenBase.river,
        BiomeGenBase.swampland,
        BiomeGenBase.taiga,
        BiomeGenBase.taigaHills);

    EntityRegistry.registerModEntity(
        EntityDun.class,
        Names.entityDun_unlocalizedName,
        Ids.entityDun,
        Allsgard.instance,
        35,
        1,
        true);
    RenderingRegistry.registerEntityRenderingHandler(
        EntityDun.class, new EntityDunRender(new ModelDun(), 0.4F));
    EntityRegistry.addSpawn(
        EntityDun.class,
        9,
        1,
        1,
        EnumCreatureType.creature,
        BiomeGenBase.beach,
        BiomeGenBase.desert,
        BiomeGenBase.desertHills,
        BiomeGenBase.extremeHills,
        BiomeGenBase.extremeHillsEdge,
        BiomeGenBase.forest,
        BiomeGenBase.forestHills,
        BiomeGenBase.frozenOcean,
        BiomeGenBase.frozenRiver,
        BiomeGenBase.iceMountains,
        BiomeGenBase.icePlains,
        BiomeGenBase.jungle,
        BiomeGenBase.jungleHills,
        BiomeGenBase.mushroomIsland,
        BiomeGenBase.mushroomIslandShore,
        BiomeGenBase.ocean,
        BiomeGenBase.plains,
        BiomeGenBase.river,
        BiomeGenBase.swampland,
        BiomeGenBase.taiga,
        BiomeGenBase.taigaHills);
  }
Beispiel #10
0
  @Mod.Init
  public void init(FMLInitializationEvent event) {
    EntityRegistry.registerGlobalEntityID(
        EntityGiantSkeleton.class, "GiantSkeleton", giandSkeletonID, 0xFFFFFF, 0xF0F0F0);
    EntityRegistry.registerModEntity(
        EntityGiantSkeleton.class, "GiantSkeleton", giandSkeletonID, this, 80, 3, true);
    EntityRegistry.addSpawn(
        EntityGiantSkeleton.class,
        5,
        1,
        3,
        EnumCreatureType.monster,
        new BiomeGenBase[] {
          BiomeGenBase.desert,
          BiomeGenBase.desertHills,
          BiomeGenBase.extremeHills,
          BiomeGenBase.extremeHillsEdge,
          BiomeGenBase.forest,
          BiomeGenBase.forestHills,
          BiomeGenBase.iceMountains,
          BiomeGenBase.icePlains,
          BiomeGenBase.jungle,
          BiomeGenBase.jungleHills,
          BiomeGenBase.plains,
          BiomeGenBase.swampland
        });

    EntityRegistry.registerGlobalEntityID(
        EntityGiantSpider.class, "GiantSpider", giantSpiderID, 0x010101, 0x030303);
    EntityRegistry.registerModEntity(
        EntityGiantSpider.class, "GiantSpider", giantSpiderID, this, 80, 3, true);
    EntityRegistry.addSpawn(
        EntityGiantSpider.class,
        5,
        1,
        3,
        EnumCreatureType.monster,
        new BiomeGenBase[] {
          BiomeGenBase.desert,
          BiomeGenBase.desertHills,
          BiomeGenBase.extremeHills,
          BiomeGenBase.extremeHillsEdge,
          BiomeGenBase.forest,
          BiomeGenBase.forestHills,
          BiomeGenBase.iceMountains,
          BiomeGenBase.icePlains,
          BiomeGenBase.jungle,
          BiomeGenBase.jungleHills,
          BiomeGenBase.plains,
          BiomeGenBase.swampland
        });

    EntityRegistry.registerGlobalEntityID(
        EntityGiantEnderman.class, "GiantEnderman", giantEndermanID, 0x000000, 0x020202);
    EntityRegistry.registerModEntity(
        EntityGiantEnderman.class, "GiantEnderman", giantEndermanID, this, 80, 3, true);
    EntityRegistry.addSpawn(
        EntityGiantEnderman.class,
        5,
        1,
        3,
        EnumCreatureType.monster,
        new BiomeGenBase[] {
          BiomeGenBase.desert,
          BiomeGenBase.desertHills,
          BiomeGenBase.extremeHills,
          BiomeGenBase.extremeHillsEdge,
          BiomeGenBase.forest,
          BiomeGenBase.forestHills,
          BiomeGenBase.iceMountains,
          BiomeGenBase.icePlains,
          BiomeGenBase.jungle,
          BiomeGenBase.jungleHills,
          BiomeGenBase.plains,
          BiomeGenBase.swampland
        });

    EntityRegistry.registerGlobalEntityID(
        EntityGiantCreeper.class, "GiantCreeper", this.giantCreeperID, 0x009900, 0xF0F0F0);
    EntityRegistry.registerModEntity(
        EntityGiantCreeper.class, "GiantCreeper", this.giantCreeperID, this, 80, 3, true);
    EntityRegistry.addSpawn(
        EntityGiantCreeper.class,
        5,
        1,
        3,
        EnumCreatureType.monster,
        new BiomeGenBase[] {
          BiomeGenBase.desert,
          BiomeGenBase.desertHills,
          BiomeGenBase.extremeHills,
          BiomeGenBase.extremeHillsEdge,
          BiomeGenBase.forest,
          BiomeGenBase.forestHills,
          BiomeGenBase.iceMountains,
          BiomeGenBase.icePlains,
          BiomeGenBase.jungle,
          BiomeGenBase.jungleHills,
          BiomeGenBase.plains,
          BiomeGenBase.swampland
        });

    EntityRegistry.registerGlobalEntityID(
        EntityGiantZombie.class, "GiantZombie2", giantZombieID, 0x009900, 0x007700);
    EntityRegistry.registerModEntity(
        EntityGiantZombie.class, "GiantZombie2", giantZombieID, this, 80, 3, true);
    EntityRegistry.addSpawn(
        EntityGiantZombie.class,
        5,
        1,
        3,
        EnumCreatureType.monster,
        new BiomeGenBase[] {
          BiomeGenBase.desert,
          BiomeGenBase.desertHills,
          BiomeGenBase.extremeHills,
          BiomeGenBase.extremeHillsEdge,
          BiomeGenBase.forest,
          BiomeGenBase.forestHills,
          BiomeGenBase.iceMountains,
          BiomeGenBase.icePlains,
          BiomeGenBase.jungle,
          BiomeGenBase.jungleHills,
          BiomeGenBase.plains,
          BiomeGenBase.swampland
        });

    proxy.registerRenders();

    LanguageRegistry.instance()
        .addStringLocalization("entity.GiantSkeleton.name", "Giant Skeleton");
    LanguageRegistry.instance().addStringLocalization("entity.GiantSpider.name", "Giant Spider");
    LanguageRegistry.instance()
        .addStringLocalization("entity.GiantEnderman.name", "Giant Enderman");
    LanguageRegistry.instance().addStringLocalization("entity.GiantCreeper.name", "Giant Creeper");
    LanguageRegistry.instance().addStringLocalization("entity.GiantZombie2.name", "Giant Zombie");
  }
  @EventHandler
  public void Load(FMLInitializationEvent event) {
    proxy.RegisterRenderers();
    proxy.registerServerTickHandler();
    // Custom Tabs
    if (idm.ifEnabled("@oreBlock")
        || idm.ifEnabled("@ingotBlock")
        || idm.ifEnabled("@MultiTexture")) {
      tabEMCBlocks =
          new CreativeTabs("tabEMCBlocks") {
            public ItemStack getIconItemStack() {
              return new ItemStack(matManager.oreExperience, 1, 0);
            }
          };
    }
    if (idm.ifEnabled("@itemIngot")
        || idm.ifEnabled("@toolAxe")
        || idm.ifEnabled("@toolHoe")
        || idm.ifEnabled("@toolPick")
        || idm.ifEnabled("@toolShovel")
        || idm.ifEnabled("@toolSword")) {
      tabEMCItems =
          new CreativeTabs("tabEMCItems") {
            public ItemStack getIconItemStack() {
              return new ItemStack(matManager.ingotAluminum, 1, 0);
            }
          };
    }
    if (idm.ifEnabled("@armor")) {
      tabEMCArmor =
          new CreativeTabs("tabEMCArmor") {
            public ItemStack getIconItemStack() {
              return new ItemStack(matManager.chestSilver, 1, 0);
            }
          };
    }
    if (idm.ifEnabled("@food")) {
      tabEMCFood =
          new CreativeTabs("tabEMCFood") {
            public ItemStack getIconItemStack() {
              return new ItemStack(foodManager.foodBacon, 1, 0);
            }
          };
    }
    if (idm.ifEnabled("@Special")) {
      tabEMCSpecial =
          new CreativeTabs("tabEMCSpecial") {
            public ItemStack getIconItemStack() {
              return new ItemStack(matManager.Katana, 1, 0);
            }
          };
    }
    if (idm.ifEnabled("@Snowgate")) {
      tabEMCSnowgate =
          new CreativeTabs("tabEMCSnowgate") {
            public ItemStack getIconItemStack() {
              return new ItemStack(matManager.Freezerite, 1, 0);
            }
          };
    }
    if (idm.ifEnabled("@Volcan")) {
      tabEMCVolcan =
          new CreativeTabs("tabEMCVolcan") {
            public ItemStack getIconItemStack() {
              return new ItemStack(matManager.VolcanGem, 1, 0);
            }
          };
    }
    // Enable FoodDropEvent for @food
    MinecraftForge.EVENT_BUS.register(new emcFoodDropEvent());

    // @Add Stuff
    matManager.addBlocks(idm, tabEMCBlocks);
    matManager.addItems(idm, tabEMCItems);
    matManager.addArmor(idm, tabEMCArmor);
    matManager.addTools(idm, tabEMCItems);
    matManager.addSpecial(idm, tabEMCSpecial);
    matManager.addSnowgate(idm, tabEMCSnowgate);
    matManager.addVolcan(idm, tabEMCVolcan);
    matManager.addRecipes(idm);

    // @Add Food
    foodManager.addFood(idm, tabEMCFood);

    // @Add Biomes
    biomeManager.addBiomes(idm);

    // @IDManager
    idm.saveConf();

    // WorldGenerator if @oreBlocks are enabled
    if (idm.ifEnabled("@oreBlock")) {
      GameRegistry.registerWorldGenerator(new emcWorldGenerator());
    }
    // Mobs
    registerEntity(entityMiner.class, "Miner", 0xeaeae9, 0xc99a03);
    LanguageRegistry.instance().addStringLocalization("entity.Miner.name", "Miner");

    registerEntity(EntityOstrich.class, "Ostrich", 0xd29bf3, 0xeaeae9);
    LanguageRegistry.instance().addStringLocalization("entity.Ostrich.name", "Ostrich");
    EntityRegistry.registerModEntity(EntityOstrich.class, "Ostrich", 20, this, 40, 3, true);
    EntityRegistry.addSpawn(
        EntityOstrich.class, 12, 2, 6, EnumCreatureType.creature, BiomeGenBase.desert);

    registerEntity(EntityThunderRat.class, "ThunderRat", 0xFFEE22, 0xFFFF00);
    LanguageRegistry.instance().addStringLocalization("entity.ThunderRat.name", "Thunder Rat");
    EntityRegistry.registerModEntity(EntityThunderRat.class, "ThunderRat", 21, this, 10, 3, true);
    EntityRegistry.addSpawn(
        EntityThunderRat.class, 10, 1, 4, EnumCreatureType.monster, BiomeGenBase.forest);

    registerEntity(EntityNetherMen.class, "NetherMen", 0xCC1111, 0x4);
    LanguageRegistry.instance().addStringLocalization("entity.NetherMen.name", "Nethermen");
    EntityRegistry.registerModEntity(EntityNetherMen.class, "NetherMen", 22, this, 60, 3, true);
    EntityRegistry.addSpawn(
        EntityNetherMen.class, 10, 4, 9, EnumCreatureType.monster, BiomeGenBase.hell);

    registerEntity(EntityMoltenWolf.class, "MoltenWolf", 0xCC0000, 0xFFEE22);
    LanguageRegistry.instance().addStringLocalization("entity.MoltenWolf.name", "Molten Wolf");
    EntityRegistry.registerModEntity(EntityMoltenWolf.class, "MoltenWolf", 23, this, 20, 3, true);
    EntityRegistry.addSpawn(
        EntityMoltenWolf.class,
        18,
        2,
        6,
        EnumCreatureType.monster,
        BiomeGenBase.hell,
        biomeManager.Volcan);
  }