From b79c1e28c131a5d237259444324fa3ac0aeb5f5e Mon Sep 17 00:00:00 2001 From: Adubbz Date: Tue, 22 Oct 2013 17:05:01 +1100 Subject: [PATCH] Re-added MFR API --- .../api/FactoryRegistry.java | 498 ++++++++++++++++++ .../api/FertilizerType.java | 23 + .../minefactoryreloaded/api/HarvestType.java | 34 ++ .../api/IDeepStorageUnit.java | 26 + .../api/IFactoryFertilizable.java | 40 ++ .../api/IFactoryFertilizer.java | 33 ++ .../api/IFactoryFruit.java | 69 +++ .../api/IFactoryGrindable.java | 36 ++ .../api/IFactoryHarvestable.java | 71 +++ .../api/IFactoryPlantable.java | 67 +++ .../api/IFactoryRanchable.java | 28 + .../api/ILiquidDrinkHandler.java | 8 + .../api/IMobEggHandler.java | 18 + .../minefactoryreloaded/api/INeedleAmmo.java | 12 + .../api/IRandomMobProvider.java | 11 + .../api/ISafariNetHandler.java | 28 + .../minefactoryreloaded/api/ISyringe.java | 31 ++ .../minefactoryreloaded/api/IToolHammer.java | 9 + .../api/IToolHammerAdvanced.java | 16 + .../minefactoryreloaded/api/MobDrop.java | 21 + .../minefactoryreloaded/api/RanchedItem.java | 68 +++ .../minefactoryreloaded/api/RandomMob.java | 21 + .../api/rednet/IConnectableRedNet.java | 86 +++ .../api/rednet/IRedNetLogicCircuit.java | 19 + .../api/rednet/IRedNetNetworkContainer.java | 31 ++ .../api/rednet/IRedNetNoConnection.java | 6 + .../api/rednet/RedNetConnectionType.java | 64 +++ .../integration/BOPCrossIntegration.java | 13 + .../integration/MFRIntegration.java | 91 ++++ .../minefactoryreloaded/Fertilizable.java | 38 ++ .../minefactoryreloaded/FruitLeaves.java | 62 +++ .../minefactoryreloaded/Harvestable.java | 103 ++++ 32 files changed, 1681 insertions(+) create mode 100644 apis/powercrystals/minefactoryreloaded/api/FactoryRegistry.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/FertilizerType.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/HarvestType.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IDeepStorageUnit.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IFactoryFertilizable.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IFactoryFertilizer.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IFactoryFruit.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IFactoryGrindable.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IFactoryRanchable.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/ILiquidDrinkHandler.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IMobEggHandler.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/INeedleAmmo.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IRandomMobProvider.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/ISafariNetHandler.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/ISyringe.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IToolHammer.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/IToolHammerAdvanced.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/MobDrop.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/RanchedItem.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/RandomMob.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/rednet/IConnectableRedNet.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetLogicCircuit.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetNetworkContainer.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetNoConnection.java create mode 100644 apis/powercrystals/minefactoryreloaded/api/rednet/RedNetConnectionType.java create mode 100644 common/biomesoplenty/integration/MFRIntegration.java create mode 100644 common/biomesoplenty/integration/minefactoryreloaded/Fertilizable.java create mode 100644 common/biomesoplenty/integration/minefactoryreloaded/FruitLeaves.java create mode 100644 common/biomesoplenty/integration/minefactoryreloaded/Harvestable.java diff --git a/apis/powercrystals/minefactoryreloaded/api/FactoryRegistry.java b/apis/powercrystals/minefactoryreloaded/api/FactoryRegistry.java new file mode 100644 index 000000000..5010a3006 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/FactoryRegistry.java @@ -0,0 +1,498 @@ +package powercrystals.minefactoryreloaded.api; + +import powercrystals.minefactoryreloaded.api.rednet.IRedNetLogicCircuit; + +import java.lang.reflect.Method; + +import net.minecraft.item.ItemStack; + +/** + * @author PowerCrystals + * + * Class used to register plants and other farming-related things with MFR. Will do nothing if MFR does not exist, but your mod should be set to load + * after MFR or things may not work properly. + * + * To avoid breaking the API, additional FactoryRegistry##s will appear on major MFR versions that contain API additions. On a Minecraft version change, + * these will be rolled back into this class. + * + */ +public class FactoryRegistry +{ + /** + * Registers a plantable object with the Planter. + * + * @param plantable The thing to plant. + */ + public static void registerPlantable(IFactoryPlantable plantable) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerPlantable", IFactoryPlantable.class); + reg.invoke(registry, plantable); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a harvestable block with the Harvester. + * + * @param harvestable The thing to harvest. + */ + public static void registerHarvestable(IFactoryHarvestable harvestable) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerHarvestable", IFactoryHarvestable.class); + reg.invoke(registry, harvestable); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a fertilizable block with the Fertilizer. + * + * @param fertilizable The thing to fertilize. + */ + public static void registerFertilizable(IFactoryFertilizable fertilizable) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerFertilizable", IFactoryFertilizable.class); + reg.invoke(registry, fertilizable); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a fertilizer item Fertilizer. + * + * @param fertilizable The thing to fertilize with. + */ + public static void registerFertilizer(IFactoryFertilizer fertilizer) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerFertilizer", IFactoryFertilizer.class); + reg.invoke(registry, fertilizer); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a ranchable entity with the Rancher. + * + * @param ranchable The entity to ranch. + */ + public static void registerRanchable(IFactoryRanchable ranchable) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerRanchable", IFactoryRanchable.class); + reg.invoke(registry, ranchable); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a grindable entity with the Grinder using the new grinder interface. This method will be renamed to the standard "registerGrindable" + * on MC 1.6. + * + * @param grindable The entity to grind. + */ + public static void registerGrindable(IFactoryGrindable grindable) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerGrindable", IFactoryGrindable.class); + reg.invoke(registry, grindable); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a grindable entity with the Grinder using the new grinder interface. This method will be renamed to the standard "registerGrindable" + * on MC 1.6. + * + * @param grindable The entity to grind. + */ + public static void registerGrinderBlacklist(Class ...ungrindables) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerGrinderBlacklist", Class[].class); + reg.invoke(registry, (Object[])ungrindables); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a possible output with the sludge boiler. + * + * @param weight Likelihood that this item will be produced. Lower means rarer. + * @param drop The thing being produced by the sludge boiler. + */ + public static void registerSludgeDrop(int weight, ItemStack drop) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerSludgeDrop", int.class, ItemStack.class); + reg.invoke(registry, weight, drop); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers specific food to use in the Breeder (instead of wheat) for a given mob. + * + * @param entityToBreed Entity this food will be used with. + * @param food The item to use when breeding this entity. + */ + public static void registerBreederFood(Class entityToBreed, ItemStack food) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerBreederFood", Class.class, ItemStack.class); + reg.invoke(registry, entityToBreed, food); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Bans an entity class from being collected by Safari Nets + * + * @param blacklistedEntity Class to blacklist + */ + public static void registerSafariNetBlacklist(Class blacklistedEntity) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerSafariNetBlacklist", Class.class); + reg.invoke(registry, blacklistedEntity); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a Safari Net handler to properly serialize a type of mob. + * + * @param handler The Safari Net handler. + */ + public static void registerSafariNetHandler(ISafariNetHandler handler) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerSafariNetHandler", ISafariNetHandler.class); + reg.invoke(registry, handler); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + + /** + * Registers a mob egg handler, which allows the Safari Net to properly change colors. + * + * @param handler The mob egg handler + */ + public static void registerMobEggHandler(IMobEggHandler handler) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerMobEggHandler", IMobEggHandler.class); + reg.invoke(registry, handler); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Allows Rubber Trees to spawn in the specified biome. + * + * @param biome The biome name. + */ + public static void registerRubberTreeBiome(String biome) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerRubberTreeBiome", String.class); + reg.invoke(registry, biome); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers an entity as a possible output from villager random safari nets. Note that the "id" field must be initialized + * (i.e. with Entity.addEntityID()) for it to work correctly. + * + * @param savedMob A serialized mob that will be unloaded by the safari net + * @param weight The weight of this mob in the random selection + */ + public static void registerVillagerTradeMob(IRandomMobProvider mobProvider) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerVillagerTradeMob", IRandomMobProvider.class); + reg.invoke(registry, mobProvider); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a handler for drinking liquids with the straw. + * + * @param liquidId The block ID the handler handles. + * @param liquidDrinkHandler The drink handler instance. + */ + public static void registerLiquidDrinkHandler(int liquidId, ILiquidDrinkHandler liquidDrinkHandler) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerLiquidDrinkHandler", int.class, ILiquidDrinkHandler.class); + reg.invoke(registry, liquidId, liquidDrinkHandler); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a possible output with the laser drill. + * + * @param weight Likelihood that this item will be produced. Lower means rarer. + * @param drop The thing being produced by the laser drill. + */ + public static void registerLaserOre(int weight, ItemStack drop) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerLaserOre", int.class, ItemStack.class); + reg.invoke(registry, weight, drop); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a preferred ore with the laser drill. Focuses with the specified color will make the specified ore more likely. + * Used by MFR itself for vanilla: Black (Coal), Light Blue (Diamond), Lime (Emerald), Yellow (Gold), Brown (Iron), Blue (Lapis), + * Red (Redstone), and White (nether quartz). + * + * This will replace setLaserPreferredOre on MC 1.6. + * + * @param color The color that the preferred ore is being set for. White is 0. + * @param ore The ore that will be preferred by the drill when a focus with the specified color is present. + */ + public static void addLaserPreferredOre(int color, ItemStack ore) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("addLaserPreferredOre", int.class, ItemStack.class); + reg.invoke(registry, color, ore); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a block ID as a fruit tree log. When the Fruit Picker sees this block on the ground, it will + * begin a search in tree mode for any fruit nearby. + * + * @param fruitLogBlockId The block ID to mark as a fruit tree log. + */ + public static void registerFruitLogBlockId(Integer fruitLogBlockId) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerFruitLogBlockId", Integer.class); + reg.invoke(registry, fruitLogBlockId); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers a fruit for the Fruit Picker. + * + * @param fruit The fruit to be picked. + */ + public static void registerFruit(IFactoryFruit fruit) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerFruit", IFactoryFruit.class); + reg.invoke(registry, fruit); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers an entity string as an invalid entry for the autospawner. + * See also: {@link net.minecraft.entity.EntityList}'s classToStringMapping and stringToClassMapping. + * + * @param entityString The entity string to blacklist. + */ + public static void registerAutoSpawnerBlacklist(String entityString) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerAutoSpawnerBlacklist", String.class); + reg.invoke(registry, entityString); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } + + /** + * Registers logic circuit to be usable in the Programmable RedNet Controller. + * + * @param circuit The circuit to be registered. + */ + public static void registerRedNetLogicCircuit(IRedNetLogicCircuit circuit) + { + try + { + Class registry = Class.forName("powercrystals.minefactoryreloaded.MFRRegistry"); + if(registry != null) + { + Method reg = registry.getMethod("registerRedNetLogicCircuit", IRedNetLogicCircuit.class); + reg.invoke(registry, circuit); + } + } + catch(Exception e) + { + e.printStackTrace(); + } + } +} diff --git a/apis/powercrystals/minefactoryreloaded/api/FertilizerType.java b/apis/powercrystals/minefactoryreloaded/api/FertilizerType.java new file mode 100644 index 000000000..2449df872 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/FertilizerType.java @@ -0,0 +1,23 @@ +package powercrystals.minefactoryreloaded.api; + +/** + * @author PowerCrystals + * + * Determines what kind of action a given fertilizer can perform. Your IFactoryFertilizable instances should check this before + * performing any action to maintain future compatibility. + */ +public enum FertilizerType +{ + /** + * The fertilizer will fertilize grass. + */ + Grass, + /** + * The fertilizer will grow a plant. + */ + GrowPlant, + /** + * The fertilizer will grow magical crops. + */ + GrowMagicalCrop, +} \ No newline at end of file diff --git a/apis/powercrystals/minefactoryreloaded/api/HarvestType.java b/apis/powercrystals/minefactoryreloaded/api/HarvestType.java new file mode 100644 index 000000000..1089d0425 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/HarvestType.java @@ -0,0 +1,34 @@ +package powercrystals.minefactoryreloaded.api; + +/** + * @author PowerCrystals + * + * Determines what algorithm the Harvester uses when it encounters this IFactoryHarvestable in the world. + */ +public enum HarvestType +{ + /** + * Just break the single block - no special action needed. Carrots, flowers, etc. + */ + Normal, + /** + * Search for identical blocks above. + */ + Column, + /** + * Search for identical blocks above but leave this bottom one for the future. Cactus and 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, but the tree grows upside-down. + */ + TreeFlipped, + /** + * This block is part of a tree as above, but leaves are cut before tree logs so that leaves do not decay more than necessary. + */ + TreeLeaf +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IDeepStorageUnit.java b/apis/powercrystals/minefactoryreloaded/api/IDeepStorageUnit.java new file mode 100644 index 000000000..cdea9e985 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IDeepStorageUnit.java @@ -0,0 +1,26 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.item.ItemStack; + +public interface IDeepStorageUnit +{ + /** + * @return A populated ItemStack with stackSize for the full amount of materials in the DSU. May have a stackSize > getMaxStackSize(). + */ + ItemStack getStoredItemType(); + + /** + * Sets the total amount of the item currently being stored, or zero if it wants to remove all items. + */ + void setStoredItemCount(int amount); + + /** + * Sets the type of the stored item and initializes the number of stored items to amount. Will overwrite any existing stored items. + */ + void setStoredItemType(ItemStack type, int amount); + + /** + * @return The maximum number of items the DSU can hold. + */ + int getMaxStoredCount(); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IFactoryFertilizable.java b/apis/powercrystals/minefactoryreloaded/api/IFactoryFertilizable.java new file mode 100644 index 000000000..01a49276b --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IFactoryFertilizable.java @@ -0,0 +1,40 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.Random; + +import net.minecraft.world.World; + +/** + * @author PowerCrystals + * + * Defines a fertilizable block, and the process to fertilize it. You can assume that you will never have to check that block ID matches the one returned by + * getFertilizableBlockId(). + */ +public interface IFactoryFertilizable +{ + /** + * @return The block ID this instance is managing. + */ + public int getFertilizableBlockId(); + + /** + * @param world The world this block belongs to. + * @param x The X coordinate of this block. + * @param y The Y coordinate of this block. + * @param z The Z coordinate of this block. + * @param fertilizerType The kind of fertilizer being used. + * @return True if the block at (x,y,z) can be fertilized with the given type of fertilizer. + */ + public boolean canFertilizeBlock(World world, int x, int y, int z, FertilizerType fertilizerType); + + /** + * @param world The world this block belongs to. + * @param rand A Random instance to use when fertilizing, if necessary. + * @param x The X coordinate of this block. + * @param y The Y coordinate of this block. + * @param z The Z coordinate of this block. + * @param fertilizerType The kind of fertilizer being used. + * @return True if fertilization was successful. If false, the Fertilizer will not consume a fertilizer item and will not drain power. + */ + public boolean fertilize(World world, Random rand, int x, int y, int z, FertilizerType fertilizerType); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IFactoryFertilizer.java b/apis/powercrystals/minefactoryreloaded/api/IFactoryFertilizer.java new file mode 100644 index 000000000..5af42f067 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IFactoryFertilizer.java @@ -0,0 +1,33 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.item.ItemStack; + +/** + * @author PowerCrystals + * + * Defines a fertilizer item for use in the Fertilizer. + */ +public interface IFactoryFertilizer +{ + /** + * @return The ID of this fertilizer item. + */ + int getFertilizerId(); + + /** + * @return The metadata of this fertilizer item. + */ + int getFertilizerMeta(); + + /** + * @return The type of fertilizer this is. + */ + FertilizerType getFertilizerType(); + + /** + * Called when a fertilization is successful. If you set the ItemStack size to 0, it will be deleted by the fertilizer. + * + * @param fertilizer The ItemStack used to fertilize. + */ + void consume(ItemStack fertilizer); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IFactoryFruit.java b/apis/powercrystals/minefactoryreloaded/api/IFactoryFruit.java new file mode 100644 index 000000000..92310bf47 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IFactoryFruit.java @@ -0,0 +1,69 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.List; +import java.util.Random; + +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 ID this fruit has in the world. + */ + public int getSourceBlockId(); + + /** + * 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); + + /** + * Called by the Fruit Picker to determine what block to replace the picked block with. Only ID and meta/damage will be used. + * At the time this method is called, the fruit still exists. Do not pass an item ID as the return value. + * @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 ItemStack getReplacementBlock(World world, int x, int y, int z); + + /** + * Called by the Fruit Picker before 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 prePick(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 getDrops(World world, Random rand, 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/apis/powercrystals/minefactoryreloaded/api/IFactoryGrindable.java b/apis/powercrystals/minefactoryreloaded/api/IFactoryGrindable.java new file mode 100644 index 000000000..4fa7ba08a --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IFactoryGrindable.java @@ -0,0 +1,36 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.List; +import java.util.Random; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.world.World; + +/** + * @author PowerCrystals + * + * Defines a grindable entity for the Grinder. + */ +@SuppressWarnings("deprecation") +public interface IFactoryGrindable +{ + /** + * @return The class that this grindable instance is handling. This must be a subtype of EntityLivingBase or the entity will never + * be noticed by the Grinder. + */ + public Class getGrindableEntity(); + + /** + * @param world The world this entity is in. + * @param entity The entity instance being ground. + * @param random A Random instance. + * @return The drops generated when this entity is killed. + */ + public List grind(World world, EntityLivingBase entity, Random random); + + /** + * @param entity The entity instance being ground. + * @return Whether this entity has been fully processed or not. + */ + public boolean processEntity(EntityLivingBase entity); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java b/apis/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java new file mode 100644 index 000000000..9f7c9df22 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IFactoryHarvestable.java @@ -0,0 +1,71 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.List; +import java.util.Map; +import java.util.Random; + +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +/** + * @author PowerCrystals + * + * Defines a harvestable block for the Harvester. + */ +public interface IFactoryHarvestable +{ + /** + * @return The block ID this harvestable instance is managing. + */ + public int getPlantId(); + + /** + * @return The type of harvest the Harvester should perform on this block. + */ + public HarvestType getHarvestType(); + + + /** + * @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(); + + /** + * @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 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.getBlockDropped() is usually sufficient. + */ + public List getDrops(World world, Random rand, Map harvesterSettings, int x, int y, int z); + + /** + * Called before the block is going to be harvested. 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/apis/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java b/apis/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java new file mode 100644 index 000000000..cdcf8cf30 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IFactoryPlantable.java @@ -0,0 +1,67 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +/** + * @author PowerCrystals + * + * Defines a plantable object for use in the Planter. + */ +public interface IFactoryPlantable +{ + /** + * @return The block or item ID this plantable is managing. + */ + public int getSeedId(); + + /** + * @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 ID that will be placed into the world. + */ + public int getPlantedBlockId(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 The block metadata that will be placed into the world. + */ + public int getPlantedBlockMetadata(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/apis/powercrystals/minefactoryreloaded/api/IFactoryRanchable.java b/apis/powercrystals/minefactoryreloaded/api/IFactoryRanchable.java new file mode 100644 index 000000000..9095ccbf2 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IFactoryRanchable.java @@ -0,0 +1,28 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.List; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.inventory.IInventory; +import net.minecraft.world.World; + +/** + * @author PowerCrystals + * + * Defines a ranchable entity for use in the Rancher. + */ +public interface IFactoryRanchable +{ + /** + * @return The entity being ranched. Must be a subtype of EntityLivingBase. + */ + public Class getRanchableEntity(); + + /** + * @param world The world this entity is in. + * @param entity The entity instance being ranched. + * @param rancher The rancher instance doing the ranching. Used to access the Rancher's inventory when milking cows, for example. + * @return A list of drops. + */ + public List ranch(World world, EntityLivingBase entity, IInventory rancher); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/ILiquidDrinkHandler.java b/apis/powercrystals/minefactoryreloaded/api/ILiquidDrinkHandler.java new file mode 100644 index 000000000..61ebb83cf --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/ILiquidDrinkHandler.java @@ -0,0 +1,8 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.entity.player.EntityPlayer; + +public interface ILiquidDrinkHandler +{ + public void onDrink(EntityPlayer player); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IMobEggHandler.java b/apis/powercrystals/minefactoryreloaded/api/IMobEggHandler.java new file mode 100644 index 000000000..7ef0103e6 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IMobEggHandler.java @@ -0,0 +1,18 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.entity.EntityEggInfo; +import net.minecraft.item.ItemStack; + +/** + * @author PowerCrystals + * + * Defines a class that MFR will use to local egg info for a given mob. This is used to color the Safari Net based on the captured mob. + */ +public interface IMobEggHandler +{ + /** + * @param safariNet The Safari Net that is looking for egg info. + * @return An EntityEggInfo, or null if this instance cannot handle this mob. + */ + public EntityEggInfo getEgg(ItemStack safariNet); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/INeedleAmmo.java b/apis/powercrystals/minefactoryreloaded/api/INeedleAmmo.java new file mode 100644 index 000000000..f0cce396b --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/INeedleAmmo.java @@ -0,0 +1,12 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.world.World; + +public interface INeedleAmmo +{ + public boolean onHitEntity(EntityPlayer owner, Entity hit, double distance); + public void onHitBlock(EntityPlayer owner, World world, int x, int y, int z, int side, double distance); + public float getSpread(); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IRandomMobProvider.java b/apis/powercrystals/minefactoryreloaded/api/IRandomMobProvider.java new file mode 100644 index 000000000..57868ef67 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IRandomMobProvider.java @@ -0,0 +1,11 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.List; + +import net.minecraft.world.World; + + +public interface IRandomMobProvider +{ + public List getRandomMobs(World world); +} \ No newline at end of file diff --git a/apis/powercrystals/minefactoryreloaded/api/ISafariNetHandler.java b/apis/powercrystals/minefactoryreloaded/api/ISafariNetHandler.java new file mode 100644 index 000000000..d31aad935 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/ISafariNetHandler.java @@ -0,0 +1,28 @@ +package powercrystals.minefactoryreloaded.api; + +import java.util.List; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; + +/** + * @author PowerCrystals + * + * Defines an object that can display information about a captured mob in a Safari net. + */ +public interface ISafariNetHandler +{ + /** + * @return The class of mob that this handler applies to. + */ + public Class validFor(); + + /** + * @param safariNetStack The Safari Net that is requesting information. + * @param player The player holding the Safari Net. + * @param infoList The current list of information strings. Add yours to this. + * @param advancedTooltips True if the advanced tooltips option is on. + */ + @SuppressWarnings("rawtypes") + public void addInformation(ItemStack safariNetStack, EntityPlayer player, List infoList, boolean advancedTooltips); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/ISyringe.java b/apis/powercrystals/minefactoryreloaded/api/ISyringe.java new file mode 100644 index 000000000..52d138257 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/ISyringe.java @@ -0,0 +1,31 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +/** + * @author PowerCrystals + * + * Defines a syringe for use in the Vet machine. + */ +public interface ISyringe +{ + /** + * Called when the vet is deciding if it should use this syringe. + * @param world The world instance. + * @param entity The entity being injected. + * @param syringe The syringe ItemStack. + * @return True if the entity can be injected by this syringe. + */ + public boolean canInject(World world, EntityLivingBase entity, ItemStack syringe); + + /** + * Called to perform an injection. + * @param world The world instance. + * @param entity The entity being injected. + * @param syringe The syringe ItemStack. + * @return True if injection was successful. + */ + public boolean inject(World world, EntityLivingBase entity, ItemStack syringe); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IToolHammer.java b/apis/powercrystals/minefactoryreloaded/api/IToolHammer.java new file mode 100644 index 000000000..2ef771e57 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IToolHammer.java @@ -0,0 +1,9 @@ +package powercrystals.minefactoryreloaded.api; + +/** + * @author PowerCrystals + * Defines a tool that can rotate MFR machines. Implement on an Item class. Requires no additional work on your part. + */ +public interface IToolHammer +{ +} diff --git a/apis/powercrystals/minefactoryreloaded/api/IToolHammerAdvanced.java b/apis/powercrystals/minefactoryreloaded/api/IToolHammerAdvanced.java new file mode 100644 index 000000000..fe9bdd916 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/IToolHammerAdvanced.java @@ -0,0 +1,16 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.item.ItemStack; + +/** + * @author PowerCrystals + * + * This interface is like IToolHammer, but is for items that change state on a per-stack basis. Implement this + * instead of IToolHammer - not both! + * + * This interface will replace IToolHammer in MC 1.6. + */ +public interface IToolHammerAdvanced +{ + public boolean isActive(ItemStack stack); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/MobDrop.java b/apis/powercrystals/minefactoryreloaded/api/MobDrop.java new file mode 100644 index 000000000..be7b4afba --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/MobDrop.java @@ -0,0 +1,21 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.WeightedRandomItem; + +public class MobDrop extends WeightedRandomItem +{ + private ItemStack _stack; + + public MobDrop(int weight, ItemStack stack) + { + super(weight); + _stack = stack; + } + + public ItemStack getStack() + { + if(_stack == null) return null; + return _stack.copy(); + } +} diff --git a/apis/powercrystals/minefactoryreloaded/api/RanchedItem.java b/apis/powercrystals/minefactoryreloaded/api/RanchedItem.java new file mode 100644 index 000000000..93091506e --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/RanchedItem.java @@ -0,0 +1,68 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.block.Block; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.fluids.FluidStack; + +/** + * @author skyboy026 + * + * Defines an ItemStack or a FluidStack that is the result of an entity being ranched + */ +public final class RanchedItem { + private final ItemStack item; + private final FluidStack fluid; + + public RanchedItem(Block item, int amount, int meta) + { + this(new ItemStack(item, amount, meta)); + } + + public RanchedItem(Block item, int amount) + { + this(new ItemStack(item, amount)); + } + + public RanchedItem(Block item) + { + this(new ItemStack(item)); + } + + public RanchedItem(Item item, int amount, int meta) + { + this(new ItemStack(item, amount, meta)); + } + + public RanchedItem(Item item, int amount) + { + this(new ItemStack(item, amount)); + } + + public RanchedItem(Item item) + { + this(new ItemStack(item)); + } + + public RanchedItem(ItemStack item) + { + this.item = item; + fluid = null; + } + + public RanchedItem(FluidStack fluid) + { + this.fluid = fluid; + item = null; + } + + public boolean hasFluid() + { + return item == null & fluid != null; + } + + public Object getResult() + { + return item == null ? fluid : item; + } +} diff --git a/apis/powercrystals/minefactoryreloaded/api/RandomMob.java b/apis/powercrystals/minefactoryreloaded/api/RandomMob.java new file mode 100644 index 000000000..9fc9cba13 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/RandomMob.java @@ -0,0 +1,21 @@ +package powercrystals.minefactoryreloaded.api; + +import net.minecraft.entity.Entity; +import net.minecraft.util.WeightedRandomItem; + +public class RandomMob extends WeightedRandomItem +{ + private Entity _mob; + + public RandomMob(Entity savedMob, int weight) + { + super(weight); + _mob = savedMob; + } + + public Entity getMob() + { + if(_mob == null) return null; + return _mob; + } +} diff --git a/apis/powercrystals/minefactoryreloaded/api/rednet/IConnectableRedNet.java b/apis/powercrystals/minefactoryreloaded/api/rednet/IConnectableRedNet.java new file mode 100644 index 000000000..9da581f34 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/rednet/IConnectableRedNet.java @@ -0,0 +1,86 @@ +package powercrystals.minefactoryreloaded.api.rednet; + +import net.minecraft.world.World; +import net.minecraftforge.common.ForgeDirection; + +/** + * Defines a Block that can connect to RedNet cables. This must be implemented on your Block class. + * Note that when you implement this, the RedNet network makes several assumptions about your code - + * primarily, it will not clamp values to 0 <= x <= 15. This means you must be able to accept any + * possible integer without crashing, even negatives. It will also assume that calling the onInput(s)Changed() + * methods are sufficient, and will not issue block updates. Finally, it will never call the vanilla redstone + * output methods in All mode, and will only query the methods contained in this interface in that case. In Single + * mode, it will call onInputChanged, and will check for strong power (or weak if in Plate mode) through the vanilla + * method calls. + * + * RedNet cables have their subnets indicated to the user by colored bands on the cable. + * The color of a given subnet is the same as the wool with metadata equal to the subnet number. + * For reference: + * 0:White, 1:Orange, 2:Magenta, 3:LightBlue, 4:Yellow, 5:Lime, 6:Pink, 7:Gray, + * 8:LightGray, 9:Cyan, 10:Purple, 11:Blue, 12:Brown, 13:Green, 14:Red, 15:Black + */ +public interface IConnectableRedNet +{ + /** + * Returns the connection type of this Block. "All" types will cause getOutputValues() and onInputsChanged() to be used, + * whereas "Single" types will onInputChanged() to be called for input changes and the normal redstone power output methods + * to be called for output. If this value must be changed while the block is alive, it must perform a block update on any + * adjacent RedNet wires. + * @param world The world this block is in. + * @param x This block's X coordinate. + * @param y This block's Y coordinate. + * @param z This block's Z coordinate. + * @param side The side that connection information is required for. + * @return The connection type. + */ + public RedNetConnectionType getConnectionType(World world, int x, int y, int z, ForgeDirection side); + + /** + * Returns the output values of this RedNet node. This array must be 16 elements long. Only called if your block is connected in "All" mode. + * @param world The world this block is in. + * @param x This block's X coordinate. + * @param y This block's Y coordinate. + * @param z This block's Z coordinate. + * @param side The side the output values are required for. + * @return The output values. + */ + public int[] getOutputValues(World world, int x, int y, int z, ForgeDirection side); + + /** + * Returns the output value of this RedNet node for a given subnet. Only called if your block is connected in "All" mode. + * @param world The world this block is in. + * @param x This block's X coordinate. + * @param y This block's Y coordinate. + * @param z This block's Z coordinate. + * @param side The side the output value is required for. + * @param subnet The subnet to get the output value for (0-15). + * @return The output value. + */ + public int getOutputValue(World world, int x, int y, int z, ForgeDirection side, int subnet); + + /** + * Called when the input values to this block change. Only called if your block is connected in "All" mode. + * Do not issue a network value update from inside this method call; it will be ignored. Issue your updates + * on the next tick. + * @param world The world this block is in. + * @param x This block's X coordinate. + * @param y This block's Y coordinate. + * @param z This block's Z coordinate. + * @param side The side the input values are being changed on. + * @param inputValues The new set of input values. This array will be 16 elements long. + */ + public void onInputsChanged(World world, int x, int y, int z, ForgeDirection side, int[] inputValues); + + /** + * Called when the input value to this block changes. Only called if your block is connected in "Single" mode. + * Do not issue a network value update from inside this method call; it will be ignored. Issue your updates + * on the next tick. + * @param world The world this block is in. + * @param x This block's X coordinate. + * @param y This block's Y coordinate. + * @param z This block's Z coordinate. + * @param side The side the input values are being changed on. + * @param inputValue The new input value + */ + public void onInputChanged(World world, int x, int y, int z, ForgeDirection side, int inputValue); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetLogicCircuit.java b/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetLogicCircuit.java new file mode 100644 index 000000000..b4457a843 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetLogicCircuit.java @@ -0,0 +1,19 @@ +package powercrystals.minefactoryreloaded.api.rednet; + +import net.minecraft.nbt.NBTTagCompound; + +public interface IRedNetLogicCircuit +{ + public int getInputCount(); + + public int getOutputCount(); + + public int[] recalculateOutputValues(long worldTime, int[] inputValues); + + public String getUnlocalizedName(); + public String getInputPinLabel(int pin); + public String getOutputPinLabel(int pin); + + public void readFromNBT(NBTTagCompound tag); + public void writeToNBT(NBTTagCompound tag); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetNetworkContainer.java b/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetNetworkContainer.java new file mode 100644 index 000000000..f2e6449b6 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetNetworkContainer.java @@ -0,0 +1,31 @@ +package powercrystals.minefactoryreloaded.api.rednet; + +import net.minecraft.world.World; + +/** + * + * You should not implement this yourself. Instead, use this to look for cables to notify from your IConnectableRedNet as this does not + * require a block update. This will be implemented on the cable's Block class. + * + */ +public interface IRedNetNetworkContainer +{ + /** + * Tells the network to recalculate all subnets. + * @param world The world this cable is in. + * @param x The x-coordinate of this cable. + * @param x The y-coordinate of this cable. + * @param x The z-coordinate of this cable. + */ + public void updateNetwork(World world, int x, int y, int z); + + /** + * Tells the network to recalculate a specific subnet. + * @param world The world this cable is in. + * @param x The x-coordinate of this cable. + * @param x The y-coordinate of this cable. + * @param x The z-coordinate of this cable. + * @param subnet The subnet to recalculate. + */ + public void updateNetwork(World world, int x, int y, int z, int subnet); +} diff --git a/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetNoConnection.java b/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetNoConnection.java new file mode 100644 index 000000000..633113fe2 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/rednet/IRedNetNoConnection.java @@ -0,0 +1,6 @@ +package powercrystals.minefactoryreloaded.api.rednet; + +public interface IRedNetNoConnection +{ + +} diff --git a/apis/powercrystals/minefactoryreloaded/api/rednet/RedNetConnectionType.java b/apis/powercrystals/minefactoryreloaded/api/rednet/RedNetConnectionType.java new file mode 100644 index 000000000..7564d03e3 --- /dev/null +++ b/apis/powercrystals/minefactoryreloaded/api/rednet/RedNetConnectionType.java @@ -0,0 +1,64 @@ +package powercrystals.minefactoryreloaded.api.rednet; + +import java.util.HashMap; +import java.util.Map; + +/** + * Defines how RedNet cable connects to a block + * + * None: RedNet will never connect to this block (if this is all you want: use IRedNetNoConnection) + * + * CableSingle: Connections will use the cable renderer with a single band, best used for whole blocks + * PlateSingle: Connections will use the plate renderer with a single band, used for conveyers and rails + * + * CableAll: Connections permit access to all 16 bands + * PlateAll: Connections permit access to all 16 bands + * + * Forced connection modes are best used for decoration blocks: RedNet will not connect normally, but will if the user forces it + * + * ForcedCableSingle: Connections permit access to a single band only when the cable is in forced connection mode + * ForcedPlateSingle: Connections permit access to a single band only when the cable is in forced connection mode + * + * ForcedCableAll: Connections permit access to all 16 bands only when the cable is in forced connection mode + * ForcedPlateAll: Connections permit access to all 16 bands only when the cable is in forced connection mode + */ +public enum RedNetConnectionType +{ + None, // 0 + CableSingle, // 11 + PlateSingle, // 13 + CableAll, // 19 + PlateAll, // 21 + ForcedCableSingle, // 43 + ForcedPlateSingle, // 45 + ForcedCableAll, // 51 + ForcedPlateAll; // 53 + + public final boolean isConnected = this.ordinal() != 0; + public final boolean isSingleSubnet = this.name().endsWith("Single"); + public final boolean isAllSubnets = this.name().endsWith("All"); + public final boolean isConnectionForced = this.name().startsWith("Forced"); + public final boolean isPlate = this.name().contains("Plate"); + public final boolean isCable = this.name().contains("Cable"); + public final short flags = toFlags(isConnected, isCable, isPlate, isSingleSubnet, isAllSubnets, isConnectionForced); + + public static final RedNetConnectionType fromFlags(short flags) + { + return connections.get(flags); + } + + private static final short toFlags(boolean ...flags) + { + short ret = 0; + for (int i = flags.length; i --> 0;) + ret |= (flags[i] ? 1 : 0) << i; + return ret; + } + + private static final Map connections = new HashMap(); + + static { + for (RedNetConnectionType type : RedNetConnectionType.values()) + connections.put(type.flags, type); + } +} diff --git a/common/biomesoplenty/integration/BOPCrossIntegration.java b/common/biomesoplenty/integration/BOPCrossIntegration.java index ef28cdd3d..4e69fe303 100644 --- a/common/biomesoplenty/integration/BOPCrossIntegration.java +++ b/common/biomesoplenty/integration/BOPCrossIntegration.java @@ -89,6 +89,7 @@ public class BOPCrossIntegration { } } +<<<<<<< HEAD if (Loader.isModLoaded("ATG")) { try { @@ -99,5 +100,17 @@ public class BOPCrossIntegration { e.printStackTrace(System.err); } } +======= + if (Loader.isModLoaded("MineFactoryReloaded")) + { + try { +// MFRIntegration.init(); + } + catch (Exception e) { + System.out.println("[BiomesOPlenty] There was an error while integrating MineFactory Reloaded with Biomes O' Plenty!"); + e.printStackTrace(System.err); + } + } +>>>>>>> parent of 3e8fda0... Completely ripped out the MFR API as it is no longer needed (BOP integration is now in MFR itself) } } diff --git a/common/biomesoplenty/integration/MFRIntegration.java b/common/biomesoplenty/integration/MFRIntegration.java new file mode 100644 index 000000000..6e05f3680 --- /dev/null +++ b/common/biomesoplenty/integration/MFRIntegration.java @@ -0,0 +1,91 @@ +package biomesoplenty.integration; + +import biomesoplenty.api.Biomes; +import biomesoplenty.api.BlockReferences; +import biomesoplenty.api.Blocks; +import biomesoplenty.api.Items; +import biomesoplenty.integration.minefactoryreloaded.Fertilizable; +import biomesoplenty.integration.minefactoryreloaded.FruitLeaves; +import biomesoplenty.integration.minefactoryreloaded.Harvestable; +import com.google.common.base.Optional; +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import powercrystals.minefactoryreloaded.api.FarmingRegistry; +import powercrystals.minefactoryreloaded.api.HarvestType; + +public class MFRIntegration +{ + protected static void init() + { + registerRubberTreeBiomes(); + registerFarmables(); + registerSludgeDrops(); + } + + private static void registerRubberTreeBiomes() + { + FarmingRegistry.registerRubberTreeBiome(Biomes.bayou.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.birchForest.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.bog.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.borealForest.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.deciduousForest.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.forestNew.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.grove.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.jungleNew.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.lushSwamp.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.mapleWoods.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.rainforest.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.seasonalForest.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.shield.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.swamplandNew.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.temperateRainforest.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.thicket.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.tropicalRainforest.get().biomeName); + FarmingRegistry.registerRubberTreeBiome(Biomes.woodland.get().biomeName); + } + + @SuppressWarnings({ "rawtypes", "unchecked" }) + private static void registerFarmables() + { + Optional[] bopLeaves = { Blocks.leaves1, Blocks.leaves2, Blocks.leavesColorized, Blocks.treeMoss, Blocks.willow, Blocks.ivy, Blocks.moss }; + Optional[] bopFruitLeaves = { Blocks.leavesFruit }; + Optional[] bopLogs = { Blocks.logs1, Blocks.logs2, Blocks.logs3, Blocks.logs4, Blocks.bamboo }; + Optional[] bopMiscStandardHarvestables = { Blocks.flowers, Blocks.plants, Blocks.foliage, Blocks.mushrooms }; + Optional[] bopSaplings = { Blocks.saplings, Blocks.colorizedSaplings }; + + for(Optional leaves : bopLeaves) + { + FarmingRegistry.registerHarvestable(new Harvestable(leaves.get().blockID, HarvestType.TreeLeaf)); + } + + for(Optional log : bopLogs) + { + FarmingRegistry.registerHarvestable(new Harvestable(log.get().blockID, HarvestType.Tree)); + } + + for(Optional harvestable : bopMiscStandardHarvestables) + { + FarmingRegistry.registerHarvestable(new Harvestable(harvestable.get().blockID, HarvestType.Normal)); + } + + for(Optional sapling : bopSaplings) + { + FarmingRegistry.registerFertilizable(new Fertilizable(sapling.get().blockID)); + } + + for(Optional leaves : bopFruitLeaves) + { + FarmingRegistry.registerHarvestable(new Harvestable(leaves.get().blockID, HarvestType.TreeLeaf)); + FarmingRegistry.registerFruit(new FruitLeaves(leaves.get().blockID)); + } + } + + private static void registerSludgeDrops() + { + FarmingRegistry.registerSludgeDrop(15, BlockReferences.getBlockItemStack("driedDirt")); + FarmingRegistry.registerSludgeDrop(15, BlockReferences.getBlockItemStack("hardSand")); + FarmingRegistry.registerSludgeDrop(15, BlockReferences.getBlockItemStack("hardDirt")); + FarmingRegistry.registerSludgeDrop(15, new ItemStack(Items.miscItems.get(), 4, 1)); + FarmingRegistry.registerSludgeDrop(25, new ItemStack(Items.mudball.get(), 4)); + } +} diff --git a/common/biomesoplenty/integration/minefactoryreloaded/Fertilizable.java b/common/biomesoplenty/integration/minefactoryreloaded/Fertilizable.java new file mode 100644 index 000000000..a618380a2 --- /dev/null +++ b/common/biomesoplenty/integration/minefactoryreloaded/Fertilizable.java @@ -0,0 +1,38 @@ +package biomesoplenty.integration.minefactoryreloaded; + +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockSapling; +import net.minecraft.world.World; +import powercrystals.minefactoryreloaded.api.FertilizerType; +import powercrystals.minefactoryreloaded.api.IFactoryFertilizable; + +public class Fertilizable implements IFactoryFertilizable +{ + private int blockId; + + public Fertilizable(int blockId) + { + this.blockId = blockId; + } + + @Override + public int getFertilizableBlockId() + { + return blockId; + } + + @Override + public boolean canFertilizeBlock(World world, int x, int y, int z, FertilizerType fertilizerType) + { + return fertilizerType == FertilizerType.GrowPlant; + } + + @Override + public boolean fertilize(World world, Random rand, int x, int y, int z, FertilizerType fertilizerType) + { + ((BlockSapling)Block.blocksList[world.getBlockId(x, y, z)]).growTree(world, x, y, z, world.rand); + return world.getBlockId(x, y, z) != blockId; + } +} diff --git a/common/biomesoplenty/integration/minefactoryreloaded/FruitLeaves.java b/common/biomesoplenty/integration/minefactoryreloaded/FruitLeaves.java new file mode 100644 index 000000000..b31481cf8 --- /dev/null +++ b/common/biomesoplenty/integration/minefactoryreloaded/FruitLeaves.java @@ -0,0 +1,62 @@ +package biomesoplenty.integration.minefactoryreloaded; + +import java.util.ArrayList; +import java.util.List; +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.IFactoryFruit; + +public class FruitLeaves implements IFactoryFruit +{ + private int sourceId; + + public FruitLeaves(int sourceId) + { + if(sourceId > Block.blocksList.length) + { + throw new IllegalArgumentException("Passed an Item ID to FactoryHarvestableStandard's source block argument"); + } + this.sourceId = sourceId; + } + + @Override + public int getSourceBlockId() + { + return sourceId; + } + + @Override + public boolean canBePicked(World world, int x, int y, int z) + { + return (world.getBlockMetadata(x, y, z) & 3) == 3; + } + + @Override + public ItemStack getReplacementBlock(World world, int x, int y, int z) + { + return new ItemStack(world.getBlockId(x, y, z), 1, world.getBlockMetadata(x,y,z)); + } + + @Override + public void prePick(World world, int x, int y, int z) + { + } + + @Override + public List getDrops(World world, Random rand, int x, int y, int z) + { + ArrayList result = new ArrayList(); + result.add(new ItemStack(Item.appleRed)); + return result; + } + + @Override + public void postPick(World world, int x, int y, int z) + { + world.setBlockMetadataWithNotify(x, y, z, world.getBlockMetadata(x,y,z) - 3, 2); + } +} diff --git a/common/biomesoplenty/integration/minefactoryreloaded/Harvestable.java b/common/biomesoplenty/integration/minefactoryreloaded/Harvestable.java new file mode 100644 index 000000000..0f4a3f3b7 --- /dev/null +++ b/common/biomesoplenty/integration/minefactoryreloaded/Harvestable.java @@ -0,0 +1,103 @@ +package biomesoplenty.integration.minefactoryreloaded; + +import java.util.ArrayList; +import java.util.List; +import java.util.Map; +import java.util.Random; + +import net.minecraft.block.Block; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import powercrystals.minefactoryreloaded.api.HarvestType; +import powercrystals.minefactoryreloaded.api.IFactoryHarvestable; + +public class Harvestable implements IFactoryHarvestable +{ + private int sourceId; + private HarvestType harvestType; + + public Harvestable(int sourceId, HarvestType harvestType) + { + if(sourceId > Block.blocksList.length) + { + throw new IllegalArgumentException("Passed an Item ID to FactoryHarvestableStandard's source block argument"); + } + this.sourceId = sourceId; + this.harvestType = harvestType; + } + + @Override + public int getPlantId() + { + return sourceId; + } + + @Override + public HarvestType getHarvestType() + { + return harvestType; + } + + @Override + public boolean breakBlock() + { + return true; + } + + @Override + public boolean canBeHarvested(World world, Map harvesterSettings, int x, int y, int z) + { + return true; + } + + @Override + public List getDrops(World world, Random rand, Map harvesterSettings, int x, int y, int z) + { + if(harvesterSettings.get("silkTouch") != null && harvesterSettings.get("silkTouch") && harvestType == HarvestType.TreeLeaf) + { + ArrayList drops = new ArrayList(); + drops.add(new ItemStack(sourceId, 1, world.getBlockMetadata(x, y, z))); + return drops; + } +// else if(getPlantId() == Blocks.leavesFruit.get().blockID) +// { +// ArrayList drops = new ArrayList(); +// +// int meta = world.getBlockMetadata(x, y, z); +// if ((meta & 3) == 3) +// { +// drops.add(new ItemStack(Item.appleRed)); +// } +// else if ((meta & 3) == 2) +// { +// if(rand.nextInt(16) == 0) drops.add(new ItemStack(Item.appleRed)); +// if(rand.nextInt(80) == 0) drops.add(new ItemStack(Block.sapling)); +// } +// else if ((meta & 3) == 1) +// { +// if(rand.nextInt(64) == 0) drops.add(new ItemStack(Item.appleRed)); +// if(rand.nextInt(40) == 0) drops.add(new ItemStack(Block.sapling)); +// } +// else if ((meta & 3) == 0) +// { +// if(rand.nextInt(20) == 0) drops.add(new ItemStack(Block.sapling)); +// } +// +// return drops; +// } + else + { + return Block.blocksList[getPlantId()].getBlockDropped(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) + { + } +}