diff options
31 files changed, 1665 insertions, 72 deletions
diff --git a/src/Java/api/cofh/energy/EnergyStorage.java b/src/Java/cofh/energy/EnergyStorage.java index a6ec363709..e48fc7b8ac 100644 --- a/src/Java/api/cofh/energy/EnergyStorage.java +++ b/src/Java/cofh/energy/EnergyStorage.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; import net.minecraft.nbt.NBTTagCompound; diff --git a/src/Java/api/cofh/energy/IEnergyConnection.java b/src/Java/cofh/energy/IEnergyConnection.java index 6351f7702d..96055c2282 100644 --- a/src/Java/api/cofh/energy/IEnergyConnection.java +++ b/src/Java/cofh/energy/IEnergyConnection.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; import net.minecraftforge.common.util.ForgeDirection; diff --git a/src/Java/api/cofh/energy/IEnergyContainerItem.java b/src/Java/cofh/energy/IEnergyContainerItem.java index 1f2b8c3c52..1cce2619ae 100644 --- a/src/Java/api/cofh/energy/IEnergyContainerItem.java +++ b/src/Java/cofh/energy/IEnergyContainerItem.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; import net.minecraft.item.ItemStack; diff --git a/src/Java/api/cofh/energy/IEnergyHandler.java b/src/Java/cofh/energy/IEnergyHandler.java index 9d3385c4c0..89ea0b4eb7 100644 --- a/src/Java/api/cofh/energy/IEnergyHandler.java +++ b/src/Java/cofh/energy/IEnergyHandler.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; import net.minecraftforge.common.util.ForgeDirection; diff --git a/src/Java/api/cofh/energy/IEnergyProvider.java b/src/Java/cofh/energy/IEnergyProvider.java index ace09db65e..1f92549c53 100644 --- a/src/Java/api/cofh/energy/IEnergyProvider.java +++ b/src/Java/cofh/energy/IEnergyProvider.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; import net.minecraftforge.common.util.ForgeDirection; diff --git a/src/Java/api/cofh/energy/IEnergyReceiver.java b/src/Java/cofh/energy/IEnergyReceiver.java index 68b071b028..537b4679d5 100644 --- a/src/Java/api/cofh/energy/IEnergyReceiver.java +++ b/src/Java/cofh/energy/IEnergyReceiver.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; import net.minecraftforge.common.util.ForgeDirection; diff --git a/src/Java/api/cofh/energy/IEnergyStorage.java b/src/Java/cofh/energy/IEnergyStorage.java index bf999f8670..d105df55c1 100644 --- a/src/Java/api/cofh/energy/IEnergyStorage.java +++ b/src/Java/cofh/energy/IEnergyStorage.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; public abstract interface IEnergyStorage { diff --git a/src/Java/api/cofh/energy/ItemEnergyContainer.java b/src/Java/cofh/energy/ItemEnergyContainer.java index f4da898919..697532abe3 100644 --- a/src/Java/api/cofh/energy/ItemEnergyContainer.java +++ b/src/Java/cofh/energy/ItemEnergyContainer.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; diff --git a/src/Java/api/cofh/energy/TileEnergyHandler.java b/src/Java/cofh/energy/TileEnergyHandler.java index 606b0ba44b..24cd3c0e34 100644 --- a/src/Java/api/cofh/energy/TileEnergyHandler.java +++ b/src/Java/cofh/energy/TileEnergyHandler.java @@ -1,4 +1,4 @@ -package api.cofh.energy; +package cofh.energy; import net.minecraft.nbt.NBTTagCompound; import net.minecraft.tileentity.TileEntity; diff --git a/src/Java/cofh/mod/BaseMod.java b/src/Java/cofh/mod/BaseMod.java new file mode 100644 index 0000000000..7ab858eabd --- /dev/null +++ b/src/Java/cofh/mod/BaseMod.java @@ -0,0 +1,284 @@ +package cofh.mod; + +import cofh.mod.updater.IUpdatableMod; +import cofh.mod.updater.ModRange; +import cofh.mod.updater.ModVersion; +import com.google.common.base.Strings; +import cpw.mods.fml.common.FMLCommonHandler; +import cpw.mods.fml.common.ICrashCallable; +import cpw.mods.fml.common.Mod; +import cpw.mods.fml.common.ModContainer; +import cpw.mods.fml.common.ObfuscationReflectionHelper; +import cpw.mods.fml.common.network.NetworkCheckHandler; +import cpw.mods.fml.common.registry.LanguageRegistry; +import cpw.mods.fml.common.versioning.InvalidVersionSpecificationException; +import cpw.mods.fml.relauncher.FMLLaunchHandler; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +import java.io.BufferedReader; +import java.io.File; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.Properties; +import java.util.jar.JarFile; +import java.util.zip.ZipEntry; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.resources.IReloadableResourceManager; +import net.minecraft.client.resources.IResource; +import net.minecraft.client.resources.IResourceManager; +import net.minecraft.client.resources.IResourceManagerReloadListener; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StringTranslate; + +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; +import org.apache.logging.log4j.core.helpers.Loader; +import org.apache.logging.log4j.spi.AbstractLogger; + +public abstract class BaseMod implements IUpdatableMod { + + protected File _configFolder; + protected final String _modid; + protected final Logger _log; + + protected BaseMod(Logger log) { + + String name = getModId(); + _modid = name.toLowerCase(Locale.US); + _log = log; + init(); + } + + protected BaseMod() { + + String name = getModId(); + _modid = name.toLowerCase(Locale.US); + _log = LogManager.getLogger(name); + init(); + } + + private void init() { + + ModContainer container = cpw.mods.fml.common.Loader.instance().activeModContainer(); + if (container.getSource().isDirectory()) { + FMLCommonHandler.instance().registerCrashCallable(new CrashCallable("Loaded from a directory")); + } else { + try { + JarFile jar = new JarFile(container.getSource()); + ZipEntry file = jar.getEntry("vers.prop"); + if (file != null) { + BufferedReader reader = new BufferedReader(new InputStreamReader(jar.getInputStream(file))); + String data = reader.readLine(); + FMLCommonHandler.instance().registerCrashCallable(new CrashCallable(data)); + } else { + FMLCommonHandler.instance().registerCrashCallable(new CrashCallable("Lacking version information.")); + } + jar.close(); + } catch (IOException e) { + FMLCommonHandler.instance().registerCrashCallable(new CrashCallable("Error reading version information." + e.getMessage())); + } + } + } + + @NetworkCheckHandler + public final boolean networkCheck(Map<String, String> remoteVersions, Side side) throws InvalidVersionSpecificationException { + + if (!requiresRemoteFrom(side)) { + return true; + } + Mod mod = getClass().getAnnotation(Mod.class); + String _modid = mod.modid(); + if (!remoteVersions.containsKey(_modid)) { + return false; + } + String remotes = mod.acceptableRemoteVersions(); + if (!"*".equals(remotes)) { + + String remote = remoteVersions.get(_modid); + if (Strings.isNullOrEmpty(remotes)) { + return getModVersion().equalsIgnoreCase(remote); + } + return ModRange.createFromVersionSpec(_modid, remotes).containsVersion(new ModVersion(_modid, remote)); + } + return true; + } + + protected boolean requiresRemoteFrom(Side side) { + + return true; + } + + protected String getConfigBaseFolder() { + + String base = getClass().getPackage().getName(); + int i = base.indexOf('.'); + if (i >= 0) { + return base.substring(0, i); + } + return ""; + } + + protected void setConfigFolderBase(File folder) { + + _configFolder = new File(folder, getConfigBaseFolder() + "/" + _modid + "/"); + } + + protected File getConfig(String name) { + + return new File(_configFolder, name + ".cfg"); + } + + protected File getClientConfig() { + + return getConfig("client"); + } + + protected File getCommonConfig() { + + return getConfig("common"); + } + + protected String getAssetDir() { + + return _modid; + } + + @Override + public Logger getLogger() { + + return _log; + } + + private void loadLanguageFile(Properties lang, InputStream stream) throws Throwable { + + InputStreamReader is = new InputStreamReader(stream, "UTF-8"); + + Properties langPack = new Properties(); + langPack.load(is); + + lang.putAll(langPack); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + private void loadLanguageFile(String lang, Properties langPack) { + + HashMap<String, String> parsedLangFile = new HashMap<String, String>(); + parsedLangFile.putAll((Map) langPack); // lovely casting hack + + LanguageRegistry.instance().injectLanguage(lang.intern(), parsedLangFile); + } + + @SuppressWarnings({ "unchecked", "rawtypes" }) + protected void loadLang() { + + if (FMLLaunchHandler.side() == Side.CLIENT) { + try { + loadClientLang(); + return; + } catch (Throwable t) { + _log.error(AbstractLogger.CATCHING_MARKER, "???", t); + } + } + + String path = "assets/" + getAssetDir() + "/language/"; + String lang = "en_US"; + try (InputStream is = Loader.getResource(path + lang + ".lang", null).openStream();) { + Properties langPack = new Properties(); + loadLanguageFile(langPack, is); + + StringTranslate i = ObfuscationReflectionHelper.getPrivateValue(StringTranslate.class, null, "instance", "field_74817_a"); + Map m = ObfuscationReflectionHelper.getPrivateValue(StringTranslate.class, i, "field_74816_c", "languageList"); + m.putAll(langPack); + } catch (Throwable t) { + _log.catching(Level.INFO, t); + } + } + + @SideOnly(Side.CLIENT) + private void loadClientLang() { + + IReloadableResourceManager manager = (IReloadableResourceManager) Minecraft.getMinecraft().getResourceManager(); + manager.registerReloadListener(new LangManager(manager)); + } + + @SideOnly(Side.CLIENT) + private class LangManager implements IResourceManagerReloadListener { + + private final String _path; + + public LangManager(IResourceManager manager) { + + _path = getAssetDir() + ":language/"; + onResourceManagerReload(manager); + } + + @Override + public void onResourceManagerReload(IResourceManager manager) { + + String l = null; + try { + l = Minecraft.getMinecraft().getLanguageManager().getCurrentLanguage().getLanguageCode(); + } catch (Throwable t) { + _log.catching(Level.WARN, t); + } + + for (String lang : Arrays.asList("en_US", l)) { + if (lang != null) { + Properties langPack = new Properties(); + try { + List<IResource> files = manager.getAllResources(new ResourceLocation(_path + lang + ".lang")); + for (IResource file : files) { + if (file.getInputStream() == null) { + _log.warn("A resource pack defines an entry for language '" + lang + "' but the InputStream is null."); + continue; + } + try { + loadLanguageFile(langPack, file.getInputStream()); + } catch (Throwable t) { + _log.warn(AbstractLogger.CATCHING_MARKER, "A resource pack has a file for language '" + lang + "' but the file is invalid.", t); + } + } + } catch (Throwable t) { + _log.info(AbstractLogger.CATCHING_MARKER, "No language data for '" + lang + "'", t); + } + loadLanguageFile(lang, langPack); + } + } + + Minecraft.getMinecraft().getLanguageManager().onResourceManagerReload(manager); + } + } + + private class CrashCallable implements ICrashCallable { + + private final String data; + + private CrashCallable(String data) { + + this.data = data; + } + + @Override + public String call() throws Exception { + + return data; + } + + @Override + public String getLabel() { + + return getModId(); + } + + } + +} diff --git a/src/Java/cofh/mod/ChildMod.java b/src/Java/cofh/mod/ChildMod.java new file mode 100644 index 0000000000..b07c35a8a1 --- /dev/null +++ b/src/Java/cofh/mod/ChildMod.java @@ -0,0 +1,17 @@ +package cofh.mod; + +import cpw.mods.fml.common.Mod; + + +public @interface ChildMod { + + /** + * The {@link Mod} instance defining this ChildMod + */ + Mod[] mod(); + + /** + * The parent {@link Mod} + */ + String parent(); +} diff --git a/src/Java/cofh/mod/ChildModContainer.java b/src/Java/cofh/mod/ChildModContainer.java new file mode 100644 index 0000000000..994fde93a8 --- /dev/null +++ b/src/Java/cofh/mod/ChildModContainer.java @@ -0,0 +1,43 @@ +package cofh.mod; + +import java.util.List; +import java.util.Map; + +import com.google.common.eventbus.EventBus; + +import cpw.mods.fml.common.*; +import cpw.mods.fml.common.discovery.ModCandidate; +import cpw.mods.fml.common.versioning.ArtifactVersion; + +public class ChildModContainer extends FMLModContainer { + + private final String parent; + + @SuppressWarnings("unchecked") + public ChildModContainer(String className, ModCandidate container, Map<String, Object> modDescriptor) { + + super(className, container, (Map<String, Object>)((List<Object>)modDescriptor.get("mod")).get(0)); + + parent = (String) modDescriptor.get("parent"); + } + + @Override + public boolean registerBus(EventBus bus, LoadController controller) { + + Map<String, ModContainer> list = Loader.instance().getIndexedModList(); + l: { + if (!list.containsKey(parent)) { + break l; + } + for (ArtifactVersion info : this.getMetadata().dependencies) { + if (!list.containsKey(info.getLabel()) && !ModAPIManager.INSTANCE.hasAPI(info.getLabel())) { + break l; + } + } + return super.registerBus(bus, controller); + } + + return false; + } + +} diff --git a/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java b/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java index 592b41b0e9..146af86302 100644 --- a/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java +++ b/src/Java/gtPlusPlus/core/item/general/RF2EU_Battery.java @@ -8,7 +8,7 @@ import ic2.api.item.*; import java.util.List; -import api.cofh.energy.ItemEnergyContainer; +import cofh.energy.ItemEnergyContainer; import net.minecraft.client.Minecraft; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; diff --git a/src/Java/gtPlusPlus/xmod/forestry/Forestry.java b/src/Java/gtPlusPlus/xmod/forestry/Forestry.java new file mode 100644 index 0000000000..b21d9a154d --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/forestry/Forestry.java @@ -0,0 +1,127 @@ +package gtPlusPlus.xmod.forestry; + +import static cpw.mods.fml.common.registry.GameRegistry.findBlock; +import static cpw.mods.fml.common.registry.GameRegistry.findItem; +import gtPlusPlus.core.lib.CORE; +import gtPlusPlus.core.util.Utils; +import gtPlusPlus.xmod.forestry.trees.ForestryLeaf; +import gtPlusPlus.xmod.forestry.trees.ForestrySapling; +import net.minecraft.block.Block; +import net.minecraft.item.Item; + +import org.apache.logging.log4j.Level; +import org.apache.logging.log4j.LogManager; + +import cofh.mod.ChildMod; +import cpw.mods.fml.common.*; +import cpw.mods.fml.common.Mod.CustomProperty; +import cpw.mods.fml.common.Mod.EventHandler; +import cpw.mods.fml.common.event.FMLInitializationEvent; +import cpw.mods.fml.common.event.FMLPostInitializationEvent; + +@ChildMod(parent = CORE.MODID, mod = @Mod(modid = "Gregtech++|CompatForestry", +name = "GT++ Compat: Forestry", +version = CORE.VERSION, +dependencies = "after:Miscutils;after:Forestry", +customProperties = @CustomProperty(k = "cofhversion", v = "true"))) +public class Forestry { + + private static final String name = "Forestry"; + + @EventHandler + public void load(FMLInitializationEvent e) { + + try { + initForestry(); + } catch (Throwable $) { + ModContainer This = FMLCommonHandler.instance().findContainerFor(this); + LogManager.getLogger(This.getModId()).log(Level.ERROR, "There was a problem loading " + This.getName(), $); + } + } + + private static void initForestry() { + + Item item; + + item = findItem(name, "sapling"); + Block block = findBlock(name, "saplingGE"); + if (item != null && block != null) { + ForestrySapling sapling = new ForestrySapling(item, block); + //MFRRegistry.registerPlantable(sapling); + //MFRRegistry.registerFertilizable(sapling); + } else + //Utils.LOG_WARNING("Forestry sapling/block null!"); + + block = findBlock(name, "soil"); + if (block != null) { + //ForestryBogEarth bog = new ForestryBogEarth(block); + //MFRRegistry.registerPlantable(bog); + //MFRRegistry.registerFertilizable(bog); + //MFRRegistry.registerHarvestable(bog); + //MFRRegistry.registerFruit(bog); + } else + //Utils.LOG_WARNING("Forestry bog earth null!"); + + for (int i = 1; true; ++i) { + block = findBlock(name, "log" + i); + l: if (block == null) { + if (i > 1) + Utils.LOG_WARNING("Forestry logs null at " + i + "."); + else { + block = findBlock(name, "logs"); + if (block != null) { + break l; + } + Utils.LOG_WARNING("Forestry logs null!"); + } + break; + } + //MFRRegistry.registerHarvestable(new HarvestableWood(block)); + //MFRRegistry.registerFruitLogBlock(block); + } + + for (int i = 1; true; ++i) { + block = findBlock(name, "fireproofLog" + i); + l: if (block == null) { + if (i > 1) + Utils.LOG_WARNING("Forestry logs null at " + i + "."); + else { + block = findBlock(name, "logsFireproof"); + if (block != null) { + break l; + } + Utils.LOG_WARNING("Forestry logs null!"); + } + break; + } + //MFRRegistry.registerHarvestable(new HarvestableWood(block)); + //MFRRegistry.registerFruitLogBlock(block); + } + + block = findBlock(name, "leaves"); + if (block != null) { + ForestryLeaf leaf = new ForestryLeaf(block); + //MFRRegistry.registerFertilizable(leaf); + //MFRRegistry.registerHarvestable(leaf); + //MFRRegistry.registerFruit(leaf); + } else + Utils.LOG_WARNING("Forestry leaves null!"); + + block = findBlock(name, "pods"); + item = findItem(name, "grafterProven"); + if (block != null) { + //ForestryPod pod = new ForestryPod(block, item); + //MFRRegistry.registerFertilizable(pod); + //MFRRegistry.registerHarvestable(pod); + //MFRRegistry.registerFruit(pod); + } else + Utils.LOG_WARNING("Forestry pods null!"); + } + + @EventHandler + public static void postInit(FMLPostInitializationEvent e) { + //MFRRegistry.registerLiquidDrinkHandler("bioethanol", new DrinkHandlerBiofuel()); + //TileEntityUnifier.updateUnifierLiquids(); + } + +} diff --git a/src/Java/gtPlusPlus/xmod/forestry/trees/ForestryLeaf.java b/src/Java/gtPlusPlus/xmod/forestry/trees/ForestryLeaf.java new file mode 100644 index 0000000000..e2550f4643 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/forestry/trees/ForestryLeaf.java @@ -0,0 +1,160 @@ +package gtPlusPlus.xmod.forestry.trees; + +import java.util.*; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; +import powercrystals.minefactoryreloaded.api.*; +import powercrystals.minefactoryreloaded.farmables.harvestables.HarvestableTreeLeaves; +import forestry.api.arboriculture.*; +import forestry.api.genetics.*; + + +public class ForestryLeaf extends HarvestableTreeLeaves implements IFactoryFruit +{ + private ITreeRoot root; + private ReplacementBlock repl; + protected Item _item; + + public ForestryLeaf(Block block) + { + super(block); + root = (ITreeRoot)AlleleManager.alleleRegistry.getSpeciesRoot("rootTrees"); + repl = EmptyReplacement.INSTANCE; + _item = Item.getItemFromBlock(block); + } + + @Override + public boolean canBePicked(World world, int x, int y, int z) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IFruitBearer) + { + IFruitBearer fruit = (IFruitBearer)te; + return fruit.getRipeness() >= 0.99f; + } + return false; + } + + public boolean canFertilize(World world, int x, int y, int z) + { + return !canBePicked(world, x, y, z); + } + + public boolean fertilize(World world, Random rand, int x, int y, int z) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IFruitBearer) + { + IFruitBearer fruit = (IFruitBearer)te; + fruit.addRipeness(1f); + return true; + } + return false; + } + + @Override + public ReplacementBlock getReplacementBlock(World world, int x, int y, int z) + { + return repl; + } + + @Override + public void prePick(World world, int x, int y, int z) + { + } + + @Override // HARVESTER + public List<ItemStack> getDrops(World world, Random rand, Map<String, Boolean> settings, int x, int y, int z) + { + ITree tree = getTree(world, x, y, z); + if (tree == null) + return null; + + ArrayList<ItemStack> prod = new ArrayList<ItemStack>(); + + float modifier = 1f; + if (settings.get("silkTouch") == Boolean.TRUE) + { + ItemStack item = new ItemStack(_item); + NBTTagCompound tag = new NBTTagCompound(); + tree.writeToNBT(tag); + item.setTagCompound(tag); + prod.add(item); + } + else + { + boolean hasMate = tree.getMate() != null; + for (ITree s : getSaplings(tree, world, x, y, z, modifier)) + if (s != null) { + if ((hasMate && !s.isGeneticEqual(tree)) || rand.nextInt(32) == 0) + if (rand.nextBoolean()) + prod.add(root.getMemberStack(s, EnumGermlingType.POLLEN.ordinal())); + + prod.add(root.getMemberStack(s, EnumGermlingType.SAPLING.ordinal())); + } + + getFruits(world, x, y, z, tree, prod); + } + + return prod; + } + + + private static ITree[] getSaplings(ITree tree, World world, int x, int y, int z, float modifier) { + return tree.getSaplings(world, null, x, y, z, modifier); + } + + @Override // FRUIT PICKER + public List<ItemStack> getDrops(World world, Random rand, int x, int y, int z) + { + ITree tree = getTree(world, x, y, z); + if (tree == null) + return null; + + ArrayList<ItemStack> prod = new ArrayList<ItemStack>(); + getFruits(world, x, y, z, tree, prod); + return prod; + } + + private ITree getTree(World world, int x, int y, int z) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IPollinatable) { + IIndividual t = ((IPollinatable)te).getPollen(); + if (t instanceof ITree) + return (ITree)t; + } + return null; + } + + private void getFruits(World world, int x, int y, int z, ITree tree, ArrayList<ItemStack> prod) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IFruitBearer) + { + IFruitBearer fruit = (IFruitBearer)te; + if (fruit.hasFruit()) + { + //int period = tree.getGenome().getFruitProvider().getRipeningPeriod(); + //ItemStack[] o = tree.produceStacks(world, x, y, z, (int)(fruit.getRipeness() * period + 0.1f)); + prod.addAll(fruit.pickFruit(null)); + } + } + } + + @Override + public void postPick(World world, int x, int y, int z) + { + TileEntity te = world.getTileEntity(x, y, z); + if (te instanceof IFruitBearer) + { + IFruitBearer fruit = (IFruitBearer)te; + fruit.addRipeness(-fruit.getRipeness()); + } + } +} diff --git a/src/Java/gtPlusPlus/xmod/forestry/trees/ForestrySapling.java b/src/Java/gtPlusPlus/xmod/forestry/trees/ForestrySapling.java new file mode 100644 index 0000000000..7c81ea0928 --- /dev/null +++ b/src/Java/gtPlusPlus/xmod/forestry/trees/ForestrySapling.java @@ -0,0 +1,55 @@ +package gtPlusPlus.xmod.forestry.trees; + +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import powercrystals.minefactoryreloaded.api.ReplacementBlock; +import powercrystals.minefactoryreloaded.farmables.plantables.PlantableStandard; +import forestry.api.arboriculture.ITreeRoot; +import forestry.api.genetics.AlleleManager; + +public class ForestrySapling extends PlantableStandard +{ + private ITreeRoot root; + + public ForestrySapling(Item item, Block block) + { + super(item, block, WILDCARD, null); + root = (ITreeRoot)AlleleManager.alleleRegistry.getSpeciesRoot("rootTrees"); + _plantedBlock = new ReplacementBlock((Block)null) { + @Override + public boolean replaceBlock(World world, int x, int y, int z, ItemStack stack) { + return root.plantSapling(world, root.getMember(stack), null, x, y, z); + } + }; + } + + public Block getPlant() + { + return _block; + } + + @Override + public boolean canBePlantedHere(World world, int x, int y, int z, ItemStack stack) + { + if (!world.isAirBlock(x, y, z)) + return false; + + return root.getMember(stack).canStay(world, x, y, z); + } + + public boolean canFertilize(World world, int x, int y, int z) + { + return true; + } + + public boolean fertilize(World world, Random rand, int x, int y, int z) + { + Block block = world.getBlock(x, y, z); + root.getTree(world, x, y, z).getTreeGenerator(world, x, y, z, true).generate(world, rand, x, y, z); + return world.getBlock(x, y, z) != block; + } +} diff --git a/src/Java/gtPlusPlus/xmod/forestry/trees/TreefarmManager.java b/src/Java/gtPlusPlus/xmod/forestry/trees/TreefarmManager.java index ba8ffd8284..8fe3f62f23 100644 --- a/src/Java/gtPlusPlus/xmod/forestry/trees/TreefarmManager.java +++ b/src/Java/gtPlusPlus/xmod/forestry/trees/TreefarmManager.java @@ -63,7 +63,17 @@ public class TreefarmManager { public static boolean isWoodLog(Block log){ String tTool = log.getHarvestTool(0); - return OrePrefixes.log.contains(new ItemStack(log, 1))&& ((tTool != null) && (tTool.equals("axe"))) || (log.getMaterial() == Material.wood); + + if (log == Blocks.log || log == Blocks.log2){ + return true; + } + + //IC2 Rubber Tree Compat + if (log.getClass().getName().toLowerCase().contains("rubwood")){ + return true; + } + + return OrePrefixes.log.contains(new ItemStack(log, 1))&& ((tTool != null) && (tTool.equals("axe"))) || (log.getMaterial() != Material.wood) ? false : (OrePrefixes.fence.contains(new ItemStack(log, 1)) ? false : true); } public static boolean isLeaves(Block log){ @@ -88,7 +98,7 @@ public class TreefarmManager { } public static boolean isFenceBlock(Block fence){ - return (fence == Blocks.fence ? true : (fence == Blocks.fence_gate ? true : (fence == Blocks.nether_brick_fence ? true : false))); + return (fence == Blocks.fence ? true : (fence == Blocks.fence_gate ? true : (fence == Blocks.nether_brick_fence ? true : (OrePrefixes.fence.contains(new ItemStack(fence, 1)) ? true : false)))); } public static boolean isAirBlock(Block air){ @@ -96,6 +106,12 @@ public class TreefarmManager { if (air.getLocalizedName().toLowerCase().contains("air")){ return true; } + + if (air.getClass().getName().toLowerCase().contains("residual") || air.getClass().getName().toLowerCase().contains("heat")){ + return true; + } + + //Utils.LOG_INFO("Found "+air.getLocalizedName()); return (air == Blocks.air ? true : (air instanceof BlockAir ? true : false)); } diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java index 53865da327..1e88135e94 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java @@ -17,7 +17,7 @@ import ic2.api.energy.tile.IEnergySink; import java.util.ArrayList; import java.util.Arrays; -import api.cofh.energy.IEnergyReceiver; +import cofh.energy.IEnergyReceiver; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; import net.minecraft.tileentity.TileEntity; diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java index 8e7cc778bd..23c1f3e47f 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java @@ -18,7 +18,7 @@ import ic2.api.energy.tile.IEnergySink; import java.util.ArrayList; import java.util.Arrays; -import api.cofh.energy.IEnergyReceiver; +import cofh.energy.IEnergyReceiver; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; import net.minecraft.tileentity.TileEntity; diff --git a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java index 4daa150889..0e7d7f30da 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/api/metatileentity/implementations/base/GregtechMetaPipeEntityBase_Cable.java @@ -22,7 +22,7 @@ import java.lang.reflect.Field; import java.util.ArrayList; import java.util.Arrays; -import api.cofh.energy.IEnergyReceiver; +import cofh.energy.IEnergyReceiver; import net.minecraft.entity.Entity; import net.minecraft.entity.EntityLivingBase; import net.minecraft.item.ItemStack; diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityTreeFarm.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityTreeFarm.java index a03e4c3952..0587c26b85 100644 --- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityTreeFarm.java +++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/GregtechMetaTileEntityTreeFarm.java @@ -11,8 +11,10 @@ import gregtech.api.metatileentity.implementations.*; import gregtech.api.objects.GT_ItemStack; import gregtech.api.objects.GT_RenderedTexture; import gregtech.api.util.GT_Recipe; +import gregtech.api.util.GT_Utility; import gtPlusPlus.core.util.Utils; import gtPlusPlus.core.util.item.ItemUtils; +import gtPlusPlus.core.util.math.MathUtils; import gtPlusPlus.xmod.forestry.trees.TreefarmManager; import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock; @@ -35,6 +37,9 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock public ArrayList<GT_MetaTileEntity_TieredMachineBlock> mCasings = new ArrayList(); /* private */ private int treeCheckTicks = 0; + /* private */ private int plantSaplingTicks = 0; + /* private */ private int cleanupTicks = 0; + /* private */ private boolean canChop = false; public GregtechMetaTileEntityTreeFarm(final int aID, final String aName, final String aNameRegional) { super(aID, aName, aNameRegional); @@ -275,44 +280,83 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock //Tree Manager + private void tickTrees(){ + if (treeCheckTicks > 200){ + treeCheckTicks = 0; + } + else { + treeCheckTicks++; + } + } + + private void tickSaplings(){ + if (plantSaplingTicks > 200){ + plantSaplingTicks = 0; + } + else { + plantSaplingTicks++; + } + } + + private void tickCleanup(){ + if (cleanupTicks > 600){ + cleanupTicks = 0; + } + else { + cleanupTicks++; + } + } + + private void tickHandler(){ + //Count Sapling Timer + tickSaplings(); + //Count Tree Cutting Timer + tickTrees(); + //Tick Cleanup script Timer. + tickCleanup(); + } + + @Override public void onPostTick(final IGregTechTileEntity aBaseMetaTileEntity, final long aTick) { if (aBaseMetaTileEntity.isServerSide()) { - - //Check Inventory slots [1] + //Check Inventory slots [1] - Find a valid Buzzsaw Blade or a Saw try { Utils.LOG_INFO(mInventory[1].getDisplayName()); } catch (NullPointerException t){} - //Update Tick Timer Last - Do Not move up the call stack - if (treeCheckTicks > 100){ - treeCheckTicks = 0; - } - else { - treeCheckTicks++; - } - - //Set Machine State - if (treeCheckTicks == 100){ - mMachine = checkMachine(aBaseMetaTileEntity, mInventory[1]); - - //If Machine can work and it's only one of two times a second this will tick, tick. - if (mMachine){ + //If Machine can work and it's only once every 5 seconds this will tick. + if (mMachine){ + //Set Machine State + if (treeCheckTicks == 200){ + //mMachine = checkMachine(aBaseMetaTileEntity, mInventory[1]); Utils.LOG_INFO("Looking For Trees - Serverside | "+treeCheckTicks); + //Find wood to Cut findLogs(aBaseMetaTileEntity); - - cleanUp(aBaseMetaTileEntity); - + } + } + else { + if (plantSaplingTicks == 100){ + Utils.LOG_INFO("Looking For space to plant saplings - Serverside | "+plantSaplingTicks); + //Plant Some Saplings plantSaplings(aBaseMetaTileEntity); - + } + else if (plantSaplingTicks == 200){ + Utils.LOG_INFO("Looking For Saplings to grow - Serverside | "+plantSaplingTicks); + //Try Grow some Saplings findSaplings(aBaseMetaTileEntity); + //Set can work state + mMachine = true; } - } - - - - + } + //Call Cleanup Task last, before ticking. + if (cleanupTicks == 600){ + Utils.LOG_INFO("Looking For rubbish to cleanup - Serverside | "+cleanupTicks); + cleanUp(aBaseMetaTileEntity); + } + //Tick TE + tickHandler(); } //Client Side - do nothing @@ -377,6 +421,7 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock } } } + mMachine = false; if (logsCut > 0) cleanUp(aBaseMetaTileEntity); //Utils.LOG_INFO("general failure | maybe there is no logs, not an error. | cut:"+logsCut ); @@ -444,60 +489,98 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock for (int j = -7; j <= 7; j++) { int h = 1; - if (TreefarmManager.isAirBlock(aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j))){ - for (ItemStack n : r){ - if (n != null){ - if (OrePrefixes.sapling.contains(n) || n.getDisplayName().toLowerCase().contains("sapling")){ - Utils.LOG_INFO(""+n.getDisplayName()); - - int posX, posY, posZ; - posX = aBaseMetaTileEntity.getXCoord()+xDir+i; - posY = aBaseMetaTileEntity.getYCoord()+h; - posZ = aBaseMetaTileEntity.getZCoord()+zDir+j; - - //Works for everything but forestry saplings - TODO - Block saplingToPlace = Block.getBlockFromItem(n.getItem()); - - //If sapling block is not null - if (saplingToPlace != null){ - //Plant Sapling - world.setBlock(posX, posY, posZ, saplingToPlace); - world.setBlockMetadataWithNotify(posX, posY, posZ, n.getItemDamage(), 4); - //Deplete Input stack - depleteInput(n); + if ((i != -7 && i != 7) && (j != -7 && j != 7)) { + if (TreefarmManager.isAirBlock(aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j))){ + //Utils.LOG_INFO("Found air"); + if (r.size() > 0){ + Utils.LOG_INFO("r was not null. "+r.size()); + for (ItemStack n : r){ + Utils.LOG_INFO("found "+n.getDisplayName()); + if (OrePrefixes.sapling.contains(n) || n.getDisplayName().toLowerCase().contains("sapling")){ + //Utils.LOG_INFO(""+n.getDisplayName()); + + int posX, posY, posZ; + posX = aBaseMetaTileEntity.getXCoord()+xDir+i; + posY = aBaseMetaTileEntity.getYCoord()+h; + posZ = aBaseMetaTileEntity.getZCoord()+zDir+j; + + //Works for everything but forestry saplings - TODO + Block saplingToPlace; + + if (n.getClass().getName().toLowerCase().contains("forestry")){ + Utils.LOG_INFO("It's a forestry sapling, trying magic."); + saplingToPlace = Block.getBlockFromItem(ItemUtils.getItem("Forestry:saplingGE")); + + } + else { + saplingToPlace = Block.getBlockFromItem(n.getItem()); + } + + + //If sapling block is not null + if (saplingToPlace != null){ + Utils.LOG_INFO("Placing Sapling Block."); + //Plant Sapling + world.setBlock(posX, posY, posZ, saplingToPlace); + world.setBlockMetadataWithNotify(posX, posY, posZ, n.getItemDamage(), 4); + //Deplete Input stack + depleteInput(n); + r = getStoredInputs(); + break; + } + Utils.LOG_INFO(n.getDisplayName()+" did not have a valid block."); + } + else { + Utils.LOG_INFO("item was not a sapling"); } } } + else{ + Utils.LOG_INFO("Input stack empty or null"); + } } - } + else { + Utils.LOG_INFO("No space for sapling, no air."); + } + } + } } Utils.LOG_INFO("Tried to grow saplings: | "+saplings ); return true; } - private Block findAirForSaplingToGrow(){ - return null; - } - private boolean cutLog(final World world, final int x, final int y, final int z){ Utils.LOG_INFO("Cutting Log"); try { //Get Log. final Block block = world.getBlock(x, y, z); //Add the stack to the bus. - addOutput(ItemUtils.getSimpleStack(block)); - //Update bus contents. - updateSlots(); - //Remove drop that was added to the bus. - world.setBlockToAir(x, y, z); - return true; + + ItemStack outputStack = ItemUtils.getSimpleStack(block); + if (outputStack != null){ + Utils.LOG_INFO("Adding 1x "+outputStack.getDisplayName()); + addOutput(outputStack); + //Update bus contents. + updateSlots(); + //Remove drop that was added to the bus. + world.setBlockToAir(x, y, z); + return true; + } + } catch (NullPointerException e){} return false; } public static boolean applyBonemeal(World world, int intX, int intY, int intZ){ Block block = world.getBlock(intX, intY, intZ); + int chance = MathUtils.randInt(0, 10); + + //Random Growth + if (chance < 8){ + return false; + } + EntityPlayer player = FakePlayerFactory.getMinecraft((WorldServer)world); if (!world.isRemote){ if (enableTreeFarmerParticles){ @@ -586,4 +669,27 @@ public class GregtechMetaTileEntityTreeFarm extends GT_MetaTileEntity_MultiBlock return getSides(aColor); } + + public boolean depleteInputEx(ItemStack aStack) { + if (GT_Utility.isStackInvalid(aStack)) return false; + + Utils.LOG_INFO("Taking one sapling away from in input bus."); + + for (GT_MetaTileEntity_Hatch_InputBus tHatch : this.mInputBusses) { + tHatch.mRecipeMap = getRecipeMap(); + if (isValidMetaTileEntity(tHatch)) { + for (int i = tHatch.getBaseMetaTileEntity().getSizeInventory() - 1; i >= 0; --i) { + if ((!(GT_Utility.areStacksEqual(aStack, tHatch.getBaseMetaTileEntity().getStackInSlot(i)))) || (tHatch.getBaseMetaTileEntity().getStackInSlot(0).stackSize < aStack.stackSize)){ + continue; + } + tHatch.getBaseMetaTileEntity().decrStackSize(0,1); + return true; + } + } + + } + + return false; + } + }
\ No newline at end of file diff --git a/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java b/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java new file mode 100644 index 0000000000..ef3fd46bb2 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/api/EmptyReplacement.java @@ -0,0 +1,20 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +public class EmptyReplacement extends ReplacementBlock +{ + public static final EmptyReplacement INSTANCE = new EmptyReplacement(); + + public EmptyReplacement() + { + super((Block)null); + } + + @Override + public boolean replaceBlock(World world, int x, int y, int z, ItemStack stack) { + return true; + } +} diff --git a/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java b/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java new file mode 100644 index 0000000000..85ef23835c --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/api/HarvestType.java @@ -0,0 +1,56 @@ +package powercrystals.minefactoryreloaded.api; + +/** + * Determines what algorithm the Harvester uses when it encounters this + * IFactoryHarvestable in the world. + * + * @author PowerCrystals + */ +public enum HarvestType { + + /** + * Just break the single block - no special action needed. e.g. Carrots, + * flowers, wheat. + */ + Normal, + /** + * Search for harvestable blocks adjacent to this block but leave this + * block. e.g. Pumpkin, melon + */ + Gourd, + /** + * Search for identical blocks above. + */ + Column, + /** + * Search for identical blocks above but leave the bottom one for the + * future. e.g. Cactus, sugarcane. + */ + LeaveBottom, + /** + * This block is the base of a tree and the harvester should enter + * tree-cutting mode. + */ + Tree, + /** + * This block is the base of the tree and the harvester should enter + * tree-cutting mode. + * The tree is searched for in the negative y axis instead. + */ + TreeFlipped, + /** + * This block is part of a tree as above, but leaves are cut before logs. + * The tree is searched for in the current mode. + * <p> + * If not in tree-cutting mode, tree-cutting mode will be entered as though + * the type was Tree. + */ + TreeLeaf, + /** + * This block is part of a tree as above, but fruits are cut before logs. + * e.g. cocoa + * The tree is not searched for. + */ + TreeFruit + +} diff --git a/src/Java/powercrystals/minefactoryreloaded/api/IFactoryFruit.java b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryFruit.java new file mode 100644 index 0000000000..3f956422c0 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryFruit.java @@ -0,0 +1,106 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.List; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +/** + * Defines a fruit entry for the Fruit Picker. + * + * @author powercrystals + * + */ +public interface IFactoryFruit { + + /** + * @return The block this fruit has in the world. + */ + public Block getPlant(); + + /** + * Used to determine if this fruit can be picked (is it ripe yet, etc) + * + * @param world + * The world where the fruit is being picked + * @param x + * The x-coordinate of the fruit + * @param y + * The y-coordinate of the fruit + * @param z + * The z-coordinate of the fruit + * + * @return True if the fruit can be picked + */ + public boolean canBePicked(World world, int x, int y, int z); + + /** + * @deprecated This method is no longer called. ReplacementBlock now handles + * interaction. + */ + @Deprecated + public boolean breakBlock(); + + /** + * Called by the Fruit Picker to determine what block to replace the picked + * block with. At the time this method is called, the fruit still exists. + * + * @param world + * The world where the fruit is being picked + * @param x + * The x-coordinate of the fruit + * @param y + * The y-coordinate of the fruit + * @param z + * The z-coordinate of the fruit + * + * @return The block to replace the fruit block with, or null for air. + */ + public ReplacementBlock getReplacementBlock(World world, int x, int y, int z); + + /** + * Called by the Fruit Picker to determine what drops to generate. At the + * time this method is called, the fruit still exists. + * + * @param world + * The world where the fruit is being picked + * @param x + * The x-coordinate of the fruit + * @param y + * The y-coordinate of the fruit + * @param z + * The z-coordinate of the fruit + */ + public List<ItemStack> getDrops(World world, Random rand, int x, int y, int z); + + /** + * Called by the Fruit Picker after getDrops, prior to the block being + * replaced/removed. + * + * @param world + * The world where the fruit is being picked + * @param x + * The x-coordinate of the fruit + * @param y + * The y-coordinate of the fruit + * @param z + * The z-coordinate of the fruit + */ + public void prePick(World world, int x, int y, int z); + + /** + * Called by the Fruit Picker after the fruit is picked. + * + * @param world + * The world where the fruit is being picked + * @param x + * The x-coordinate of the fruit + * @param y + * The y-coordinate of the fruit + * @param z + * The z-coordinate of the fruit + */ + public void postPick(World world, int x, int y, int z); +} diff --git a/src/Java/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java new file mode 100644 index 0000000000..5b6be99f89 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java @@ -0,0 +1,104 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.*; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +/** + * Defines a harvestable block for the Harvester. + * + * @author PowerCrystals + */ +public interface IFactoryHarvestable { + + /** + * @return The block this harvestable instance is managing. + */ + public Block getPlant(); + + /** + * @return The type of harvest the Harvester should perform on this block. + */ + public HarvestType getHarvestType(); + + /** + * Used to determine if the harvester should replace this block with air. + * + * @return Whether or not the Harvester should break the block when + * harvesting. If false, no changes will be performed by the + * Harvester itself. + */ + public boolean breakBlock(); + + /** + * Used to determine if this crop can be harvested (is it at a stage that + * drops crops, etc.) + * + * @param world + * The world this block is in. + * @param harvesterSettings + * The harvester's current settings. Do not modify these. + * @param x + * The X coordinate of the block being harvested. + * @param y + * The Y coordinate of the block being harvested. + * @param z + * The Z coordinate of the block being harvested. + * + * @return True if this block can be harvested. + */ + public boolean canBeHarvested(World world, Map<String, Boolean> harvesterSettings, int x, int y, int z); + + /** + * @param world + * The world this block is in. + * @param rand + * A Random instance to use when generating drops. + * @param harvesterSettings + * The harvester's current settings. Do not modify these. + * @param x + * The X coordinate of the block being harvested. + * @param y + * The Y coordinate of the block being harvested. + * @param z + * The Z coordinate of the block being harvested. + * + * @return The drops generated by breaking this block. For a default + * implementation, calling Block.getDrops() is usually + * sufficient. + */ + public List<ItemStack> getDrops(World world, Random rand, Map<String, Boolean> harvesterSettings, int x, int y, int z); + + /** + * Called before the block is going to be harvested, after getDrops. Usually + * empty. + * + * @param world + * The world this block is in. + * @param x + * The X coordinate of the block being harvested. + * @param y + * The Y coordinate of the block being harvested. + * @param z + * The Z coordinate of the block being harvested. + */ + public void preHarvest(World world, int x, int y, int z); + + /** + * Called after the block is going to be harvested. Used to re-till soil, + * for example. + * + * @param world + * The world this block is in. + * @param x + * The X coordinate of the block being harvested. + * @param y + * The Y coordinate of the block being harvested. + * @param z + * The Z coordinate of the block being harvested. + */ + public void postHarvest(World world, int x, int y, int z); + +} diff --git a/src/Java/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java new file mode 100644 index 0000000000..1d620b37ed --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java @@ -0,0 +1,94 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +/** + * Defines a plantable object for use in the Planter. + * + * @author PowerCrystals + */ +public interface IFactoryPlantable { + + /** + * @return The item this plantable is managing. + */ + public Item getSeed(); + + /** + * @param stack + * The stack being planted. + * @param forFermenting + * True if this stack will be converted to biofuel + * + * @return True if this plantable can be planted (useful for metadata + * items). + */ + public boolean canBePlanted(ItemStack stack, boolean forFermenting); + + /** + * @param world + * The world instance this block or item will be placed into. + * @param x + * The destination X coordinate. + * @param y + * The destination Y coordinate. + * @param z + * The destination Z coordinate. + * @param stack + * The stack being planted. + * + * @return The block that will be placed into the world. + */ + public ReplacementBlock getPlantedBlock(World world, int x, int y, int z, ItemStack stack); + + /** + * @param world + * The world instance this block or item will be placed into. + * @param x + * The destination X coordinate. + * @param y + * The destination Y coordinate. + * @param z + * The destination Z coordinate. + * @param stack + * The stack being planted. + * + * @return True if this plantable can be placed at the provided coordinates. + */ + public boolean canBePlantedHere(World world, int x, int y, int z, ItemStack stack); + + /** + * Called before planting is performed. Used to till soil, for example. + * + * @param world + * The world instance this block or item will be placed into. + * @param x + * The destination X coordinate. + * @param y + * The destination Y coordinate. + * @param z + * The destination Z coordinate. + * @param stack + * The stack being planted. + */ + public void prePlant(World world, int x, int y, int z, ItemStack stack); + + /** + * Called after planting is performed. Usually empty. + * + * @param world + * The world instance this block or item will be placed into. + * @param x + * The destination X coordinate. + * @param y + * The destination Y coordinate. + * @param z + * The destination Z coordinate. + * @param stack + * The stack being planted. + */ + public void postPlant(World world, int x, int y, int z, ItemStack stack); + +} diff --git a/src/Java/powercrystals/minefactoryreloaded/api/ReplacementBlock.java b/src/Java/powercrystals/minefactoryreloaded/api/ReplacementBlock.java new file mode 100644 index 0000000000..c67e8a39a2 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/api/ReplacementBlock.java @@ -0,0 +1,135 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.block.Block; +import net.minecraft.item.*; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.world.World; + +public class ReplacementBlock +{ + protected byte _hasMeta; + protected int _meta; + protected final Block _block; + protected final NBTTagCompound _tileTag; + + /** + * Called to replace a block in the world. + * @param world The world object + * @param x The X coord + * @param y The Y coord + * @param z The Z coord + * @param stack The ItemStack being used to replace the block (may be null) + * @return True if the block was set successfully + */ + public boolean replaceBlock(World world, int x, int y, int z, ItemStack stack) + { + int meta = getMeta(world, x, y, z, stack); + if (world.setBlock(x, y, z, _block, meta, 3)) + { + if (hasTag(stack) && _block.hasTileEntity(meta)) + { + TileEntity tile = world.getTileEntity(x, y, z); + if (tile != null) + tile.readFromNBT(getTag(world, x, y, z, stack)); + } + return true; + } + return false; + } + + /** + * Called to get the metadata of the replacement block in the world. + * @param world The world object + * @param x The X coord + * @param y The Y coord + * @param z The Z coord + * @param stack The ItemStack being used to replace the block (may be null) + * @return The metadata of the block + */ + protected int getMeta(World world, int x, int y, int z, ItemStack stack) + { + int m = 0; + if (_hasMeta > 0) + { + if (_hasMeta > 1) + return _meta; + m = stack.getItemDamage(); + Item item = stack.getItem(); + if (item instanceof ItemBlock) + m = ((ItemBlock)item).getMetadata(m); + } + return m; + } + + /** + * Called to set the metdata of this ReplacementBlock to a fixed value + * @param meta The metadata of the block + * @return This instance + */ + public ReplacementBlock setMeta(int meta) + { + if (meta >= 0) + { + _hasMeta = 2; + _meta = meta; + } + return this; + } + + /** + * Called to set the metdata of this ReplacementBlock to a value read from an ItemStack + * @param meta The metadata of the block + * @return This instance + */ + public ReplacementBlock setMeta(boolean hasMeta) + { + _hasMeta = (byte) (hasMeta ? 1 : 0); + return this; + } + + /** + * Called to get the NBTTagCompound a TileEntity will read its state from + * @param world The world object + * @param x The X coord + * @param y The Y coord + * @param z The Z coord + * @param stack The ItemStack being used to replace the block (may be null) + * @return The NBTTagCompound a TileEntity will read its state from + */ + protected NBTTagCompound getTag(World world, int x, int y, int z, ItemStack stack) + { + return _tileTag; + } + + /** + * Called to see if a TileEntity should have its state set + * @param stack The ItemStack being used to replace the block (may be null) + * @return True if the TileEntity should have its state set + */ + protected boolean hasTag(ItemStack stack) + { + return _tileTag != null; + } + + public ReplacementBlock(Item block) + { + this(Block.getBlockFromItem(block)); + } + + public ReplacementBlock(Item block, NBTTagCompound tag) + { + this(Block.getBlockFromItem(block), tag); + } + + public ReplacementBlock(Block block) + { + this(block, null); + } + + public ReplacementBlock(Block block, NBTTagCompound tag) + { + _block = block; + _tileTag = tag; + } +} diff --git a/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableShearable.java b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableShearable.java new file mode 100644 index 0000000000..1719ae2486 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableShearable.java @@ -0,0 +1,50 @@ +package powercrystals.minefactoryreloaded.farmables.harvestables; + +import java.util.*; + +import net.minecraft.block.Block; +import net.minecraft.init.Items; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.IShearable; +import powercrystals.minefactoryreloaded.api.HarvestType; + +public class HarvestableShearable extends HarvestableStandard +{ + public HarvestableShearable(Block block, HarvestType harvestType) + { + super(block, harvestType); + } + + public HarvestableShearable(Block block) + { + super(block); + } + + @Override + public List<ItemStack> getDrops(World world, Random rand, Map<String, Boolean> settings, int x, int y, int z) + { + Block block = world.getBlock(x, y, z); + if (settings.get("silkTouch") == Boolean.TRUE) + { + if (block instanceof IShearable) + { + ItemStack stack = new ItemStack(Items.shears, 1, 0); + if (((IShearable)block).isShearable(stack, world, x, y, z)) + { + return ((IShearable)block).onSheared(stack, world, x, y, z, 0); + } + } + if (Item.getItemFromBlock(block) != null) + { + ArrayList<ItemStack> drops = new ArrayList<ItemStack>(); + int meta = block.getDamageValue(world, x, y, z); + drops.add(new ItemStack(block, 1, meta)); + return drops; + } + } + + return block.getDrops(world, x, y, z, world.getBlockMetadata(x, y, z), 0); + } +} diff --git a/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableStandard.java b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableStandard.java new file mode 100644 index 0000000000..eeab615ed8 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableStandard.java @@ -0,0 +1,71 @@ +package powercrystals.minefactoryreloaded.farmables.harvestables; + +import java.util.*; + +import net.minecraft.block.Block; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import powercrystals.minefactoryreloaded.api.HarvestType; +import powercrystals.minefactoryreloaded.api.IFactoryHarvestable; + +public class HarvestableStandard implements IFactoryHarvestable +{ + private Block _block; + private HarvestType _harvestType; + + public HarvestableStandard(Block block, HarvestType harvestType) + { + if (block == Blocks.air) + throw new IllegalArgumentException("Passed air FactoryHarvestableStandard"); + + _block = block; + _harvestType = harvestType; + } + + public HarvestableStandard(Block block) + { + this(block, HarvestType.Normal); + } + + @Override + public Block getPlant() + { + return _block; + } + + @Override + public HarvestType getHarvestType() + { + return _harvestType; + } + + @Override + public boolean breakBlock() + { + return true; + } + + @Override + public boolean canBeHarvested(World world, Map<String, Boolean> harvesterSettings, int x, int y, int z) + { + return true; + } + + @Override + public List<ItemStack> getDrops(World world, Random rand, Map<String, Boolean> harvesterSettings, int x, int y, int z) + { + return world.getBlock(x, y, z).getDrops(world, x, y, z, world.getBlockMetadata(x, y, z), 0); + } + + @Override + public void preHarvest(World world, int x, int y, int z) + { + } + + @Override + public void postHarvest(World world, int x, int y, int z) + { + world.notifyBlocksOfNeighborChange(x, y, z, getPlant()); + } +} diff --git a/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableTreeLeaves.java b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableTreeLeaves.java new file mode 100644 index 0000000000..eaa23bd847 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/farmables/harvestables/HarvestableTreeLeaves.java @@ -0,0 +1,33 @@ +package powercrystals.minefactoryreloaded.farmables.harvestables; + +import net.minecraft.block.Block; +import net.minecraft.world.World; +import powercrystals.minefactoryreloaded.api.HarvestType; + +public class HarvestableTreeLeaves extends HarvestableShearable +{ + public HarvestableTreeLeaves(Block block) + { + super(block, HarvestType.TreeLeaf); + } + + @Override + public void postHarvest(World world, int x, int y, int z) + { + Block id = getPlant(); + + notifyBlock(world, x, y - 1, z, id); + notifyBlock(world, x - 1, y, z, id); + notifyBlock(world, x + 1, y, z, id); + notifyBlock(world, x, y, z - 1, id); + notifyBlock(world, x, y, z + 1, id); + notifyBlock(world, x, y + 1, z, id); + } + + protected void notifyBlock(World world, int x, int y, int z, Block id) + { + Block block = world.getBlock(x, y, z); + if (!block.isLeaves(world, x, y, z)) + world.notifyBlockOfNeighborChange(x, y, z, id); + } +} diff --git a/src/Java/powercrystals/minefactoryreloaded/farmables/plantables/PlantableStandard.java b/src/Java/powercrystals/minefactoryreloaded/farmables/plantables/PlantableStandard.java new file mode 100644 index 0000000000..022d947150 --- /dev/null +++ b/src/Java/powercrystals/minefactoryreloaded/farmables/plantables/PlantableStandard.java @@ -0,0 +1,116 @@ +package powercrystals.minefactoryreloaded.farmables.plantables; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import net.minecraftforge.common.IPlantable; +import net.minecraftforge.common.util.ForgeDirection; +import net.minecraftforge.oredict.OreDictionary; +import powercrystals.minefactoryreloaded.api.IFactoryPlantable; +import powercrystals.minefactoryreloaded.api.ReplacementBlock; + +/* + * Used for directly placing blocks (ie saplings) and items (ie sugarcane). Pass in source ID to constructor, + * so one instance per source ID. + */ + +public class PlantableStandard implements IFactoryPlantable +{ + public static final int WILDCARD = OreDictionary.WILDCARD_VALUE; + + protected Item _seed; + protected Block _block; + protected ReplacementBlock _plantedBlock; + protected int _validMeta; + + public PlantableStandard(Block block) + { + this(Item.getItemFromBlock(block), block); + } + + public PlantableStandard(Block block, Block plantedBlock) + { + this(Item.getItemFromBlock(block), plantedBlock); + } + + public PlantableStandard(Item block, Block plantedBlock) + { + this(block, plantedBlock, WILDCARD); + } + + public PlantableStandard(Block block, int meta) + { + this(Item.getItemFromBlock(block), block, meta); + } + + public PlantableStandard(Block block, Block plantedBlock, int meta) + { + this(Item.getItemFromBlock(block), plantedBlock, meta); + } + + public PlantableStandard(Item block, Block plantedBlock, int validMeta) + { + this(block, plantedBlock, validMeta, new ReplacementBlock(plantedBlock)); + } + + public PlantableStandard(Item block, Block plantedBlock, int validMeta, int plantedMeta) + { + this(block, plantedBlock, validMeta, new ReplacementBlock(plantedBlock).setMeta(plantedMeta)); + } + + public PlantableStandard(Item block, Block plantedBlock, int validMeta, boolean useItemMeta) + { + this(block, plantedBlock, validMeta, new ReplacementBlock(plantedBlock).setMeta(useItemMeta)); + } + + public PlantableStandard(Item block, Block plantedBlock, int validMeta, ReplacementBlock repl) + { + _seed = block; + _block = plantedBlock; + _validMeta = validMeta; + _plantedBlock = repl; + } + + @Override + public boolean canBePlanted(ItemStack stack, boolean forFermenting) + { + return _validMeta == WILDCARD || stack.getItemDamage() == _validMeta; + } + + @Override + public boolean canBePlantedHere(World world, int x, int y, int z, ItemStack stack) + { + if (!world.isAirBlock(x, y, z)) + return false; + + Block groundId = world.getBlock(x, y - 1, z); + return (_block.canPlaceBlockAt(world, x, y, z) && _block.canReplace(world, x, y, z, 0, stack)) || + (_block instanceof IPlantable && groundId != null && + groundId.canSustainPlant(world, x, y, z, ForgeDirection.UP, (IPlantable)_block)); + } + + @Override + public void prePlant(World world, int x, int y, int z, ItemStack stack) + { + return; + } + + @Override + public void postPlant(World world, int x, int y, int z, ItemStack stack) + { + return; + } + + @Override + public ReplacementBlock getPlantedBlock(World world, int x, int y, int z, ItemStack stack) + { + return _plantedBlock; + } + + @Override + public Item getSeed() + { + return _seed; + } +} |