@Nonnull @Override public Fluid get() { if (!Loader.instance().hasReachedState(LoaderState.INITIALIZATION)) { return defaultValue; } if (defaultFluid == null) { FluidRegistry.getFluid(defaultValueName); } if (value == null || valueGeneration != generation) { if (serverConfig != null && serverConfig.containsKey(keyname)) { value = FluidRegistry.getFluid((String) serverConfig.get(keyname)); } else { value = FluidRegistry.getFluid(config.getString(keyname, section, defaultValueName, text)); if (!inInit && config.hasChanged()) { config.save(); } } valueGeneration = generation; } return NullHelper.first(value, defaultFluid, defaultValue); }
public static boolean isIc2Available() { if (ic2Available != null) return ic2Available; boolean loaded = Loader.isModLoaded("IC2"); if (Loader.instance().hasReachedState(LoaderState.CONSTRUCTING)) { ic2Available = loaded; } return loaded; }
@Load(LoaderState.INITIALIZATION) public void registerRecipe(){ itemSet.forEach(item -> { if (item.getItem() instanceof IRecipeProvider) { // check is a provider IRecipeProvider provider = (IRecipeProvider) item.getItem(); Arrays.stream(provider.createRecipes()).forEach(GameData::register_impl); } else if (item.getItem() instanceof IRecipe){ // check if is a recipe registerRecipe(item.getAnnotation().value(), (IRecipe) item.getItem()); } }); }
private static boolean enqueueStartupMessage(String modTarget, IMCMessage message) { if (Loader.instance().activeModContainer() == null) { return false; } enqueueMessage(Loader.instance().activeModContainer(), modTarget, message); return Loader.isModLoaded(modTarget) && !Loader.instance().hasReachedState(LoaderState.POSTINITIALIZATION); }
/** * Enables the universal bucket in forge. * Has to be called before pre-initialization. * Actually just call it statically in your mod class. */ public static void enableUniversalBucket() { if (Loader.instance().hasReachedState(LoaderState.PREINITIALIZATION)) { FMLLog.getLogger().log(Level.ERROR, "Trying to activate the universal filled bucket too late. Call it statically in your Mods class. Mod: {}", Loader.instance().activeModContainer().getName()); } else { universalBucketEnabled = true; } }
/** * <b>Only use this in PreInit state!</b> */ public static void setPermissionHandler(IPermissionHandler handler) { Preconditions.checkNotNull(handler, "Permission handler can't be null!"); Preconditions.checkState(Loader.instance().getLoaderState().ordinal() <= LoaderState.PREINITIALIZATION.ordinal(), "Can't register after IPermissionHandler PreInit!"); FMLLog.log(Level.WARN, "Replacing " + permissionHandler.getClass().getName() + " with " + handler.getClass().getName()); permissionHandler = handler; }
/** * <b>Only use this after PreInit state!</b> * * @param node Permission node, best if it's lowercase and contains '.' (e.g. <code>"modid.subgroup.permission_id"</code>) * @param level Default permission level for this node. If not isn't registered, it's level is going to be 'NONE' * @param desc Optional description of the node */ public static String registerNode(String node, DefaultPermissionLevel level, String desc) { Preconditions.checkNotNull(node, "Permission node can't be null!"); Preconditions.checkNotNull(level, "Permission level can't be null!"); Preconditions.checkNotNull(desc, "Permission description can't be null!"); Preconditions.checkArgument(!node.isEmpty(), "Permission node can't be empty!"); Preconditions.checkState(Loader.instance().getLoaderState().ordinal() > LoaderState.PREINITIALIZATION.ordinal(), "Can't register permission nodes before Init!"); permissionHandler.registerNode(node, level, desc); return node; }
@SideOnly(Side.CLIENT) public void construct(FMLConstructionEvent event) { super.construct(event); getLoaderManager().invoke(event, LoaderState.CONSTRUCTING, Side.CLIENT); }
@Load(LoaderState.AVAILABLE) public void loadDrinkRecipes() { FruitEnumLoader fruitLoader = FoodCraftReloaded.getProxy().getLoaderManager().getLoader(FruitEnumLoader.class).get(); VegetableEnumLoader vegetableLoader = FoodCraftReloaded.getProxy().getLoaderManager().getLoader(VegetableEnumLoader.class).get(); for (FruitType fruitType : FruitType.values()) { RecipeManager.getInstance().addRecipe(new DrinkRecipe(new ItemStack[]{new ItemStack(fruitLoader.getInstanceMap(ItemFruit.class).get(fruitType))}, new FluidStack(fruitLoader.getFluidJuiceEnumMap().get(fruitType), 1000))); } for (VegetableType vegetableType : VegetableType.values()) { RecipeManager.getInstance().addRecipe(new DrinkRecipe(new ItemStack[]{new ItemStack(vegetableLoader.getInstanceMap(ItemVegetable.class).get(vegetableType))}, new FluidStack(vegetableLoader.getFluidJuiceEnumMap().get(vegetableType), 1000))); } // ForgeRegistries.RECIPES.register(new CakeRecipe().setRegistryName(FoodCraftReloaded.MODID, "cake_recipe")); }
@Load(side = Side.CLIENT, value = LoaderState.POSTINITIALIZATION) @SideOnly(Side.CLIENT) public void loadColors() { try { Field field = ItemColors.class.getDeclaredField("itemColorMap"); field.setAccessible(true); Map<IRegistryDelegate<Item>, IItemColor> itemColorMap = (Map<IRegistryDelegate<Item>, IItemColor>) field.get(Minecraft.getMinecraft().getItemColors()); cachedLiqueurs.forEach(liqueur -> itemColorMap.entrySet().stream().filter(entry -> entry.getKey().get().equals(liqueur)).forEach(entry -> Minecraft.getMinecraft().getItemColors().registerItemColorHandler(entry.getValue(), entry.getKey().get()))); } catch (Exception e) { FoodCraftReloaded.getLogger().error("Cannot get custom mesh definitions", e); } }
@SubscribeEvent public static void tileCompat(AttachCapabilitiesEvent<TileEntity> ace) { if (Loader.instance().hasReachedState(LoaderState.SERVER_ABOUT_TO_START)) { final TileEntity te = ace.getObject(); if (te == null || blacklisted(te)) return; ace.addCapability(COMPAT, new LazyEnergyCapProvider(te)); } }
/** Registers an entity as possible backpack carrier, meaning * they'll get constructed with an IBackpack capability. * Must be called in pre-initialization phase (or before). */ public static void registerEntity(String entityID, RenderOptions renderOptions) { if (entityID == null) throw new NullPointerException("entityID must not be null"); if (getDefaultEntityEntry(entityID) != null) throw new IllegalArgumentException("entityID '" + entityID + "' has already been registered"); if (Loader.instance().getLoaderState().compareTo(LoaderState.PREINITIALIZATION) > 0) throw new IllegalStateException("Must be called during (or before) pre-initialization phase."); _defaultEntities.add(new BackpackEntityEntry(entityID, renderOptions, new ArrayList<>(), true)); }
/** Registers a backpack to randomly spawn on the specified entity. * Must be called after registerEntity, in pre-initialization phase (or before). * * @param entityID The entity to register to spawn with this backpack. * * @param entryID String uniquely identifying this entry for this entity. * For example "wearblebackpacks:default". * @param backpack Backpack item ID to spawn on the entity. * For example "wearablebackpacks:backpack". * @param chance Chance in 1 out of X. For example 100 = 1% and 1000 = 0.1%. * @param lootTable Loot table for the backpack when spawned on this mob (if any). * @param colorRange A range of colors to spawn the backpack with, or null if default. **/ public static void registerBackpack(String entityID, String entryID, String backpack, int chance, String lootTable, ColorRange colorRange) { if (entityID == null) throw new NullPointerException("entityID must not be null"); if (entryID == null) throw new NullPointerException("entryID must not be null"); BackpackEntityEntry entityEntry = getDefaultEntityEntry(entityID); if (entityEntry == null) new IllegalStateException("entityID '" + entityID + "' has not been registered yet"); if (entityEntry._backpackEntries.stream().anyMatch(e -> e.id.equals(entryID))) throw new IllegalArgumentException("entryID '" + entryID + "' has already been used for entityID '" + entityID + "'"); if (Loader.instance().getLoaderState().compareTo(LoaderState.PREINITIALIZATION) > 0) throw new IllegalStateException("Must be called during (or before) pre-initialization phase."); entityEntry._backpackEntries.add(new BackpackEntry(entryID, backpack, chance, lootTable, colorRange, true)); }
@Load(LoaderState.INITIALIZATION) public static void registerMessageHandler(){ PanguCore.getNetwork().registerMessage(Handler.class, Context.class, Network.getNextID(), Side.SERVER); }
@Override public void preInit(FMLPreInitializationEvent event) { super.preInit(event); Proxy.INSTANCE.invoke(event, LoaderState.PREINITIALIZATION, Side.CLIENT); }
@Override public void init(FMLInitializationEvent event) { super.init(event); Proxy.INSTANCE.invoke(event, LoaderState.INITIALIZATION,Side.CLIENT); }
@Override public void postInit(FMLPostInitializationEvent event) { super.postInit(event); Proxy.INSTANCE.invoke(event, LoaderState.POSTINITIALIZATION,Side.CLIENT); }
@Override public void loadComplete(FMLLoadCompleteEvent event) { super.loadComplete(event); Proxy.INSTANCE.invoke(event, LoaderState.AVAILABLE,Side.CLIENT); }
public void preInit(FMLPreInitializationEvent event) { AnnotationInjector.INSTANCE.startSolveInjectors(); Proxy.INSTANCE.invoke(event, LoaderState.PREINITIALIZATION, Side.SERVER); }
public void init(FMLInitializationEvent event) { Proxy.INSTANCE.invoke(event, LoaderState.INITIALIZATION, Side.SERVER); }
public void postInit(FMLPostInitializationEvent event) { Proxy.INSTANCE.invoke(event, LoaderState.POSTINITIALIZATION, Side.SERVER); }
public void loadComplete(FMLLoadCompleteEvent event) { Proxy.INSTANCE.invoke(event, LoaderState.AVAILABLE, Side.SERVER); }
@SideOnly(Side.CLIENT) public void preInit(FMLPreInitializationEvent event) { super.preInit(event); getLoaderManager().invoke(event, LoaderState.PREINITIALIZATION, Side.CLIENT); new GuiHandler(); }
@SideOnly(Side.CLIENT) public void init(FMLInitializationEvent event) { super.init(event); getLoaderManager().invoke(event, LoaderState.INITIALIZATION, Side.CLIENT); }
@SideOnly(Side.CLIENT) public void postInit(FMLPostInitializationEvent event) { super.postInit(event); getLoaderManager().invoke(event, LoaderState.POSTINITIALIZATION, Side.CLIENT); }
@SideOnly(Side.CLIENT) public void loadComplete(FMLLoadCompleteEvent event) { super.loadComplete(event); getLoaderManager().invoke(event, LoaderState.AVAILABLE, Side.CLIENT); }
@Load(value = LoaderState.INITIALIZATION) public void register() { MinecraftForge.EVENT_BUS.register(this); }
@Load(value = LoaderState.INITIALIZATION) public void load() { MinecraftForge.EVENT_BUS.register(this); }
@Load(side = Side.CLIENT, value = LoaderState.POSTINITIALIZATION) public void loadColors() { registerColors(); }
@Load(value = LoaderState.POSTINITIALIZATION, side = Side.CLIENT) public void loadKitchenKnifeColor() { registerColors(); }
public Map<LoaderState, Collection<Method>> getStateLoaderMap() { return stateLoaderMap; }
@OverridingMethodsMustInvokeSuper public void construct(FMLConstructionEvent event) { FluidRegistry.enableUniversalBucket(); loaderManager.invoke(event, LoaderState.CONSTRUCTING, Side.SERVER); }
@OverridingMethodsMustInvokeSuper public void preInit(FMLPreInitializationEvent event) { loaderManager.invoke(event, LoaderState.PREINITIALIZATION, Side.SERVER); }
@OverridingMethodsMustInvokeSuper public void init(FMLInitializationEvent event) { loaderManager.invoke(event, LoaderState.INITIALIZATION, Side.SERVER); }
@OverridingMethodsMustInvokeSuper public void postInit(FMLPostInitializationEvent event) { loaderManager.invoke(event, LoaderState.POSTINITIALIZATION, Side.SERVER); }
@OverridingMethodsMustInvokeSuper public void loadComplete(FMLLoadCompleteEvent event) { loaderManager.invoke(event, LoaderState.AVAILABLE, Side.SERVER); new FruitTreeGenerator(); }
public static void clear() { if (Loader.instance().getLoaderState() == LoaderState.AVAILABLE) cache = null; }
/** * @param state A {@link FMLStateEvent} * @return The {@link LoaderState} referred by that {@link FMLStateEvent}. */ public static LoaderState getState(Class<? extends FMLStateEvent> state) { return states.inverse().get(state); }
/** * @param state A {@link LoaderState} * @return The {@link FMLStateEvent} referred by that {@link LoaderState}. */ public static Class<? extends FMLStateEvent> getState(LoaderState state) { return states.get(state); }
/** * Registers a SubTileEntity, a new special flower. Look in the subtile package of the API. * Call this in preInit, and don't forget to register a model in BotaniaAPIClient. */ public static void registerSubTile(String key, Class<? extends SubTileEntity> subtileClass) { Preconditions.checkArgument(Loader.instance().isInState(LoaderState.PREINITIALIZATION)); subTiles.put(key, subtileClass); subTileMods.put(key, Loader.instance().activeModContainer().getModId()); }