Java 类cpw.mods.fml.common.event.FMLLoadCompleteEvent 实例源码

@EventHandler
public void onLoadComplete(FMLLoadCompleteEvent event) {
    if (event.getSide() == Side.CLIENT) {
        try {
            Class clazzGT6API = Class.forName("gregapi.GT_API");
            GTVersion = "GT6";
        } catch (ClassNotFoundException e) {}
        if (GTVersion.equals("GT5")) {
            new GT5OreLayerHelper();
            new GT5OreSmallHelper();
        }
        else { 
            new GT6OreLayerHelper();
            new GT6OreSmallHelper();
            new GT6OreBedrockHelper();
        }
    }
}

@EventHandler
public void loadComplete(FMLLoadCompleteEvent event) {

    // Fetching runtime messages
    try {
        log.info("Fetching runtime IMC messages...");
        IMCHandler.processIMC(FMLInterModComms.fetchRuntimeMessages(this));
        log.info("Fetched runtime IMC messages.");
    } catch (Exception e) {
        log.error("=============================ERROR!=============================");
        log.error("Failed to fetch IMC Runtime messages, printing stacktrace...");
        log.error("Please report this as a bug report with the stacktrace, the minecraft log and a mod list + version to: " + issueURL);
        log.error("=============================ERROR!=============================");
        e.printStackTrace();
    }
}

@EventHandler
public void minus(FMLLoadCompleteEvent event) {
    for(ResearchCategoryList tab : ResearchCategories.researchCategories.values()){
        if(tab != null) {
            for (ResearchItem item : tab.research.values()) {
                if(item != null){
                    item.setAutoUnlock();
                }
            }
        }
    }
    try {
        Field warpMap = ThaumcraftApi.class.getDeclaredField("warpMap");
        warpMap.setAccessible(true);
        HashMap<Object, Integer> warpList = (HashMap<Object, Integer>)warpMap.get(null);
        warpList.clear();
    }
    catch (Exception e){
        e.printStackTrace();
    }
}

@EventHandler
public void loadComplete(FMLLoadCompleteEvent event) {

    // Fetching runtime messages
    try {
        log.info("Fetching runtime IMC messages...");
        IMCHandler.processIMC(FMLInterModComms.fetchRuntimeMessages(this));
        log.info("Fetched runtime IMC messages.");
    } catch (Exception e) {
        log.error("=============================ERROR!=============================");
        log.error("Failed to fetch IMC Runtime messages, printing stacktrace...");
        log.error("Please report this as a bug report with the stacktrace, the minecraft log and a mod list + version to: " + issueURL);
        log.error("=============================ERROR!=============================");
        e.printStackTrace();
    }
}

@Override
public void loadFinished(FMLLoadCompleteEvent event, boolean client) {
    if (!client) {
        for (PhysisToolMaterial mat : PhysisToolMaterial.materials.values()) {
            if (mat.orename.startsWith("ingot")) {
                List<ItemStack> ingots = OreDictionary.getOres(mat.orename);
                if (ingots.size() > 0) {
                    ItemStack ingot = ingots.get(0);

                    ItemStack ringitem = new ItemStack(ring, 1, mat.id);
                    PhysisToolMaterial.writeMaterialToStack(mat, ringitem);

                    GameRegistry.addSmelting(ringitem, ingot.copy(), 1.0F);
                }
            }
        }
    }
}

@Subscribe
public void onAvailable(FMLLoadCompleteEvent evt)
{
    if (shouldSortRecipies)
    {
        RecipeSorter.sortCraftManager();
    }
    FluidRegistry.validateFluidRegistry();
}

@Subscribe
public void loadComplete(FMLLoadCompleteEvent event) {
    log.info("AnnotationRegistry is loaded. Checking states.");
    if (LambdaLib.DEBUG) {
        log.info(RegistrationManager.INSTANCE.profiler.toString());
    }

    RegistrationManager.INSTANCE.checkLoadState();
}

@Subscribe
public void onAvailable(FMLLoadCompleteEvent evt)
{
    if (shouldSortRecipies)
    {
        RecipeSorter.sortCraftManager();
    }
}

@EventHandler
public void complete(FMLLoadCompleteEvent event) {
    if (Util.netIsAvailable()) {
        for (ModContainer mod : Loader.instance().getActiveModList()) {
            if (mod.getMod() instanceof IUpdateable) {
                registerUpdateable((IUpdateable) mod.getMod());
            }
        }
        String[] fetchedNames = new String[updates.size()];
        for (FetchedUpdateable update : updates)
            fetchedNames[fetchedNames.length - 1] = update.name;

        Logger.info("The following mods are out of date: " + StringUtils.join(fetchedNames, ", "));
    }
}

@EventHandler
  public void postInit(FMLLoadCompleteEvent event)
  {
for (int i = 0; i < Importer.importers.size(); i++) {
    Importer.importers.get(i).processImport(recipes);
}
  }

@EventHandler
public void finishModLoading(FMLLoadCompleteEvent event)
{
    for (int i = 0; i < ConfigRegistry.systems.size(); i++) {
        ConfigRegistry.systems.get(i).loadSystem();
    }
}

@Subscribe
public void onAvailable(FMLLoadCompleteEvent evt)
{
    if (shouldSortRecipies)
    {
        RecipeSorter.sortCraftManager();
    }
}

@Subscribe
public void onAvailable(FMLLoadCompleteEvent evt)
{
    if (shouldSortRecipies)
    {
        RecipeSorter.sortCraftManager();
    }
}

@Subscribe
public void onAvailable(FMLLoadCompleteEvent evt)
{
    if (shouldSortRecipies)
    {
        RecipeSorter.sortCraftManager();
    }
}

public void loadFinished(FMLLoadCompleteEvent event) {
    //RecipeHelper.parseRecipes();
    PhysisToolMaterial.buildMaterials();
    ItemTrowel.buildRecipes();

    PhysisIntegration.loadFinished(event, false);
}

@Subscribe
public void onAvalible(FMLLoadCompleteEvent evt)
{
    if (shouldSortRecipies)
    {
        RecipeSorter.sortCraftManager();
    }
}

@Subscribe
public void onAvalible(FMLLoadCompleteEvent evt)
{
    if (shouldSortRecipies)
    {
        RecipeSorter.sortCraftManager();
    }
}

/**
 * The Forge Load Complete Event.
 * Actually , this event is really useless unless you want to 
 * make some mod for Minecraft GUI.
 * 
 * @param event
 */
public void OnForgeLoadFinish(FMLLoadCompleteEvent event)
{
    /*!gen.mod.hook.OnLoadFinish*/
    /**/

    //TODO:Add your own code here
}

@Subscribe
public void onAvalible(FMLLoadCompleteEvent evt)
{
    if (shouldSortRecipies)
    {
        RecipeSorter.sortCraftManager();
    }
}

@Mod.EventHandler
public void loadComplete(final FMLLoadCompleteEvent event) {
    ExtraUtilsMod.extraUtils.loadComplete(event);
}

public void loadComplete(final FMLLoadCompleteEvent event) {
    if (!this.hasSpecialInit) {
        this.hasSpecialInit = true;
        this.specialInit();
    }
}

@EventHandler
public void saveConfig(FMLLoadCompleteEvent evt) {
    config.save();
}

@Subscribe
public void loadComplete(FMLLoadCompleteEvent event) {
    doProgress(State.LOAD_COMPLETE, this);
}

@EventHandler
public void loadComplete(FMLLoadCompleteEvent event) {
  processImc(FMLInterModComms.fetchRuntimeMessages(this)); //Some mods send IMCs during PostInit, so we catch them here.
}

@EventHandler
public void loadComplete(FMLLoadCompleteEvent event)
{
    new IMCHandler().onIMCEvent(FMLInterModComms.fetchRuntimeMessages(this));
}

@Mod.EventHandler
public void loadComplete(FMLLoadCompleteEvent event) {
    proxy.loadComplete();
}

@Subscribe
public void load(FMLLoadCompleteEvent event){
    return;
}

@Subscribe
public void load(FMLLoadCompleteEvent event){
    return;
}

@Mod.EventHandler
public void loadComplete(FMLLoadCompleteEvent event)
{
    DisabledHandler.init();
}

@Mod.EventHandler
public void loadFinished(FMLLoadCompleteEvent event) {
    proxy.loadFinished(event);
}

@Override
public void loadFinished(FMLLoadCompleteEvent event) {
    super.loadFinished(event);

    PhysisIntegration.loadFinished(event, true);
}

public static void loadFinished(FMLLoadCompleteEvent event, boolean client) {
    for (CompatModule module : modules) {
        module.loadFinished(event, client);
    }
}

@Subscribe
public void loadComplete(FMLLoadCompleteEvent complete)
{
    ModLoaderHelper.finishModLoading(this);
}

@Subscribe
public void loadComplete(FMLLoadCompleteEvent complete)
{
    ModLoaderHelper.finishModLoading(this);
}

@Subscribe
public void loadComplete(FMLLoadCompleteEvent complete)
{
    ModLoaderHelper.finishModLoading(this);
}

@Mod.EventHandler
public void loadComplete(FMLLoadCompleteEvent evt) {
    if (ArchitectureChecker.INSTANCE.isEnabled(Constants.ARCH_COMPUTER_CRAFT)) ModuleComputerCraft.registerProvider();
}

public void loadFinished(FMLLoadCompleteEvent event, boolean client) {}