electrodynamics/archive/java/dark/lib/CoreRegistry.java

258 lines
8 KiB
Java
Raw Normal View History

package dark.lib;
import java.io.File;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Set;
import net.minecraft.block.Block;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.Configuration;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidRegistry;
import com.builtbroken.common.Pair;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.Loader;
import cpw.mods.fml.common.registry.GameRegistry;
import dark.lib.IExtraInfo.IExtraBlockInfo;
import dark.lib.IExtraInfo.IExtraItemInfo;
/**
* Handler to make registering all parts of a mod's objects that are loaded into the game by forge
*
* @author DarkGuardsman
*/
public class CoreRegistry
{
public static HashMap<Block, String> registredBlocks = new HashMap<Block, String>();
public static HashMap<Item, String> registredItems = new HashMap<Item, String>();
//@SidedProxy(clientSide = "com.builtbroken.minecraft.ClientRegistryProxy", serverSide = "com.builtbroken.minecraft.RegistryProxy")
public static RegistryProxy prox;
public static RegistryProxy proxy()
{
if (prox == null)
{
if (FMLCommonHandler.instance().getSide().isClient())
{
prox = new ClientRegistryProxy();
}
else
{
prox = new RegistryProxy();
}
}
return prox;
}
public static Configuration masterBlockConfig = new Configuration(new File(Loader.instance().getConfigDir(), "objects/EnabledBlocks.cfg"));
/**
* Generates a block using reflection, and runs it threw config checks
*
* @param name - name to register the block with
* @param modID - mod id to register the block to
* @param blockClass - class to generate the instance from
*/
public static Block createNewBlock(String name, String modID, Class<? extends Block> blockClass)
{
return CoreRegistry.createNewBlock(name, modID, blockClass, true);
}
/**
* Generates a block using reflection, and runs it threw config checks
*
* @param name - name to register the block with
* @param modID - mod id to register the block to
* @param blockClass - class to generate the instance from
* @param canDisable - should we allow the player the option to disable the block
*/
public static Block createNewBlock(String name, String modID, Class<? extends Block> blockClass, boolean canDisable)
{
return CoreRegistry.createNewBlock(name, modID, blockClass, null, canDisable);
}
/**
* Generates a block using reflection, and runs it threw config checks
*
* @param name - name to register the block with
* @param modID - mod id to register the block to
* @param blockClass - class to generate the instance from
* @param itemClass - item block to register with the block
*/
public static Block createNewBlock(String name, String modID, Class<? extends Block> blockClass, Class<? extends ItemBlock> itemClass)
{
return createNewBlock(name, modID, blockClass, itemClass, true);
}
/**
* Generates a block using reflection, and runs it threw config checks
*
* @param name - name to register the block with
* @param modID - mod id to register the block to
* @param blockClass - class to generate the instance from
* @param canDisable - should we allow the player the option to disable the block
* @param itemClass - item block to register with the block
*/
public static Block createNewBlock(String name, String modID, Class<? extends Block> blockClass, Class<? extends ItemBlock> itemClass, boolean canDisable)
{
Block block = null;
if (blockClass != null && (!canDisable || canDisable && masterBlockConfig.get("Enabled_List", "Enabled_" + name, true).getBoolean(true)))
{
// TODO redesign to catch blockID conflict
try
{
block = blockClass.newInstance();
}
catch (IllegalArgumentException e)
{
throw e;
}
catch (Exception e)
{
System.out.println("\n\nWarning: Block [" + name + "] failed to be created\n");
e.printStackTrace();
System.out.println("\n\n");
}
if (block != null)
{
registredBlocks.put(block, name);
proxy().registerBlock(block, itemClass, name, modID);
CoreRegistry.finishCreation(block);
}
}
return block;
}
/** Finishes the creation of the block loading config files and tile entities */
public static void finishCreation(Block block)
{
if (block instanceof IExtraInfo)
{
if (((IExtraInfo) block).hasExtraConfigs())
{
Configuration extraBlockConfig = new Configuration(new File(Loader.instance().getConfigDir(), "objects/blocks/" + block.getUnlocalizedName() + ".cfg"));
extraBlockConfig.load();
((IExtraInfo) block).loadExtraConfigs(extraBlockConfig);
extraBlockConfig.save();
}
if (block instanceof IExtraBlockInfo)
{
((IExtraBlockInfo) block).loadOreNames();
Set<Pair<String, Class<? extends TileEntity>>> tileListNew = new HashSet<Pair<String, Class<? extends TileEntity>>>();
((IExtraBlockInfo) block).getTileEntities(block.blockID, tileListNew);
for (Pair<String, Class<? extends TileEntity>> par : tileListNew)
{
proxy().regiserTileEntity(par.left(), par.right());
}
}
}
}
/**
* Method to get block via name
*
* @param blockName
* @return Block requested
*/
public static Block getBlock(String blockName)
{
for (Entry<Block, String> entry : registredBlocks.entrySet())
{
String name = entry.getKey().getUnlocalizedName().replace("tile.", "");
if (name.equalsIgnoreCase(blockName))
{
return entry.getKey();
}
}
return null;
}
/**
* Creates a new fluid block using the prefab following a few conditions.
*
* @param modDomainPrefix - prefix of the mod, used for texture refrence and block registry
* @param config - config file to pull the blockID from
* @param fluid - fluid to link to this block
*/
public static Block createNewFluidBlock(String modDomainPrefix, Configuration config, Fluid fluid)
{
Block fluidBlock = null;
Fluid fluidActual = null;
if (config != null && fluid != null && config.get("general", "EnableFluid_" + fluid.getName(), true).getBoolean(true) && FluidRegistry.getFluid(fluid.getName()) == null)
{
FluidRegistry.registerFluid(fluid);
fluidActual = FluidRegistry.getFluid(fluid.getName());
if (fluidActual == null)
{
fluidActual = fluid;
}
if (fluidActual.getBlockID() == -1 && masterBlockConfig.get("Enabled_List", "Enabled_" + fluid.getName() + "Block", true).getBoolean(true))
{
fluidBlock = new BlockFluid(modDomainPrefix, fluidActual, config).setUnlocalizedName("tile.Fluid." + fluid.getName());
proxy().registerBlock(fluidBlock, null, "DMBlockFluid" + fluid.getName(), modDomainPrefix);
}
else
{
fluidBlock = Block.blocksList[fluid.getBlockID()];
}
}
return fluidBlock;
}
/**
* Creates a new item using reflection as well runs it threw some check to activate any
* interface methods
*
* @param name - name to register the item with
* @param modid - mods that the item comes from
* @param clazz - item class
* @param canDisable - can a user disable this item
* @return the new item
*/
public static Item createNewItem(String name, String modid, Class<? extends Item> clazz, boolean canDisable)
{
Item item = null;
if (clazz != null && (!canDisable || canDisable && masterBlockConfig.get("Enabled_List", "Enabled_" + name, true).getBoolean(true)))
{
try
{
item = clazz.newInstance();
}
catch (Exception e)
{
e.printStackTrace();
}
if (item != null)
{
registredItems.put(item, name);
GameRegistry.registerItem(item, name, modid);
if (item instanceof IExtraInfo)
{
if (((IExtraInfo) item).hasExtraConfigs())
{
Configuration extraBlockConfig = new Configuration(new File(Loader.instance().getConfigDir(), "objects/items/" + item.getUnlocalizedName() + ".cfg"));
extraBlockConfig.load();
((IExtraInfo) item).loadExtraConfigs(extraBlockConfig);
extraBlockConfig.save();
}
if (item instanceof IExtraItemInfo)
{
((IExtraItemInfo) item).loadOreNames();
}
}
}
}
return item;
}
}