diff --git a/lang b/lang index 017b0be91..c560d5270 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit 017b0be91381d0f9dbfc1b386702e5f758bc0051 +Subproject commit c560d52707b3976bbe51c4ba7c3d26fdb947ce75 diff --git a/src/main/java/forestry/api/circuits/ICircuit.java b/src/main/java/forestry/api/circuits/ICircuit.java index 900ab84ef..f3e74fac8 100644 --- a/src/main/java/forestry/api/circuits/ICircuit.java +++ b/src/main/java/forestry/api/circuits/ICircuit.java @@ -7,11 +7,17 @@ package forestry.api.circuits; import java.util.List; +import net.minecraft.util.text.translation.I18n; + public interface ICircuit { String getUID(); String getUnlocalizedName(); + default String getLocalizedName(){ + return I18n.translateToLocal(getUnlocalizedName()); + } + boolean isCircuitable(Object tile); void onInsertion(int slot, Object tile); diff --git a/src/main/java/forestry/api/farming/Farmables.java b/src/main/java/forestry/api/farming/Farmables.java index 3595d5061..4cce3f8f7 100644 --- a/src/main/java/forestry/api/farming/Farmables.java +++ b/src/main/java/forestry/api/farming/Farmables.java @@ -5,14 +5,16 @@ ******************************************************************************/ package forestry.api.farming; -import java.util.LinkedHashMap; -import java.util.Map; - import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; +import java.util.LinkedHashMap; +import java.util.Map; + import net.minecraft.item.ItemStack; +//TODO: Remove this class in 1.13 +@Deprecated public class Farmables { /** * Can be used to add IFarmables to some of the vanilla farm logics. diff --git a/src/main/java/forestry/api/farming/IFarmHousing.java b/src/main/java/forestry/api/farming/IFarmHousing.java index ba5708d9e..c6a22061e 100644 --- a/src/main/java/forestry/api/farming/IFarmHousing.java +++ b/src/main/java/forestry/api/farming/IFarmHousing.java @@ -5,12 +5,14 @@ ******************************************************************************/ package forestry.api.farming; -import forestry.api.core.IErrorLogicSource; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3i; import net.minecraft.world.World; + import net.minecraftforge.fluids.FluidStack; +import forestry.api.core.IErrorLogicSource; + public interface IFarmHousing extends IErrorLogicSource { BlockPos getCoords(); @@ -33,10 +35,36 @@ public interface IFarmHousing extends IErrorLogicSource { * Will remove the appropriate germling from the farm's inventory. * It's up to the logic to only call this on a valid location. * + * @deprecated TODO remove this method in 1.13 + * * @return true if planting was successful, false otherwise. */ + @Deprecated boolean plantGermling(IFarmable farmable, World world, BlockPos pos); + /** + * Callback for {@link IFarmLogic}s to plant a sapling, seed, germling, stem. + * Will remove the appropriate germling from the farm's inventory. + * It's up to the logic to only call this on a valid location. + * + * @return true if planting was successful, false otherwise. + */ + default boolean plantGermling(IFarmable farmable, World world, BlockPos pos, FarmDirection direction){ + return plantGermling(farmable, world, pos); + } + + default boolean isValidPlatform(World world, BlockPos pos){ + return false; + } + + default boolean isSquare(){ + return false; + } + + default boolean canPlantSoil(boolean manual){ + return true; + } + /* INTERACTION WITH HATCHES */ IFarmInventory getFarmInventory(); diff --git a/src/main/java/forestry/api/farming/IFarmInventory.java b/src/main/java/forestry/api/farming/IFarmInventory.java index 7f9a793d8..0d08dbc22 100644 --- a/src/main/java/forestry/api/farming/IFarmInventory.java +++ b/src/main/java/forestry/api/farming/IFarmInventory.java @@ -27,4 +27,6 @@ public interface IFarmInventory { IInventory getResourcesInventory(); IInventory getFertilizerInventory(); + + } diff --git a/src/main/java/forestry/api/farming/IFarmLogic.java b/src/main/java/forestry/api/farming/IFarmLogic.java index 03fa75cd8..7db1e3df5 100644 --- a/src/main/java/forestry/api/farming/IFarmLogic.java +++ b/src/main/java/forestry/api/farming/IFarmLogic.java @@ -8,39 +8,136 @@ package forestry.api.farming; import java.util.Collection; import net.minecraft.block.state.IBlockState; +import net.minecraft.client.renderer.texture.TextureMap; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; + import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import forestry.api.core.ForestryAPI; + +/** + * The IFarmLogic is used by farm blocks and multi-blocks to cultivate and harvest crops and plants. + * + * Every farm block has only ony one logic a multi-block farm has four, one for every direction. + */ public interface IFarmLogic { + /** + * @return The amount of fertilizer that the {@link IFarmHousing} automatically removes after this logic cultivated + * a block or harvested a crop. + */ int getFertilizerConsumption(); + /** + * @param hydrationModifier A modifier that depends on the weather and the biome of the farm. + * + * @return The amount of water that the {@link IFarmHousing} automatically removes after this logic cultivated + * a block or harvested a crop. + */ int getWaterConsumption(float hydrationModifier); + /** + * Checks if the given stack is a resource or a soil that this logic uses to grow plants on or to create other + * products like peat. + */ boolean isAcceptedResource(ItemStack itemstack); + /** + * Checks if the given stack is a germling (plantable sapling, seed, etc.) for any {@link IFarmable} of this farm. + */ boolean isAcceptedGermling(ItemStack itemstack); + /** + * Collects all items that are laying on the ground and are in the {@link IFarmHousing#getArea()} of the farm. + * + * @param world The world of the farm. + * @param farmHousing The farm that uses this logic. + * + * @return A collection that contains all items that were collected. + */ NonNullList collect(World world, IFarmHousing farmHousing); + /** + * Tries to cultivate one or more blocks at the given position and with the given extent. + * + * @param world The world of the farm. + * @param farmHousing The farm that uses this logic. + * @param pos The position at that the logic should start to cultivate. + * @param direction The direction of the extension. + * @param extent How many blocks this logic has to cultivate after it cultivated the block at the given position. + * The positions of the next blocks are having a offset in the given direction. + * @return True if the logic has cultivated any block. + */ boolean cultivate(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent); + /** + * Tries to harvest one or more blocks at the given position and with the given extent. + * + * @param world The world of the farm. + * @param pos The position at that the logic should start to harvest. + * @param direction The direction of the extension. + * @param extent How many blocks this logic tries to harvest after it has tried to harvested the block at the given position. + * The positions of the next blocks are having a offset in the given direction. + * @return True if the logic has cultivated any block. + */ Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent); - IFarmLogic setManual(boolean manual); + /** + * Returns the {@link IFarmProperties} that created this logic. + * + * @since Forestry 5.8 + * + * @return Returns the {@link IFarmProperties} that created this logic. Returns a fake instance from + * {@link IFarmRegistry#createFakeInstance(IFarmLogic)} if the logic is older that Forestry 5.8. + * TODO: Remove "default" from this method in 1.13 + */ + default IFarmProperties getProperties(){ + return ForestryAPI.farmRegistry.createFakeInstance(this); + } - void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData); - - @SideOnly(Side.CLIENT) - ResourceLocation getTextureMap(); + /** + * @deprecated Since Forestry 5.8 logic instances are created at the constructor of the {@link IFarmProperties} and + * have a immutable manual state. TODO Remove this method in 1.13 + */ + @Deprecated + default IFarmLogic setManual(boolean manual){ + return this; + } + /** + * Use {@link IFarmRegistry#getProperties(String)} to get the {@link IFarmProperties} for the farm logic and register the soil + * with {@link IFarmProperties#registerSoil(ItemStack, IBlockState, boolean)}. + */ + @Deprecated + default void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData){ + // + } + + default String getUnlocalizedName(){ + return ""; + } + + /** + * @return Localized short, human-readable identifier used in the farm gui and in tooltips. + */ String getName(); + /* GUI ONLY */ + /** + * @deprecated No longer needed because mc always uses the same map for blocks and items. + * TODO remove this method in 1.13 + */ + @Deprecated + @SideOnly(Side.CLIENT) + default ResourceLocation getTextureMap(){ + return TextureMap.LOCATION_BLOCKS_TEXTURE; + } + /** * @return the itemStack that represents this farm logic. Used as an icon for the farm logic. */ diff --git a/src/main/java/forestry/api/farming/IFarmProperties.java b/src/main/java/forestry/api/farming/IFarmProperties.java new file mode 100644 index 000000000..25c751f06 --- /dev/null +++ b/src/main/java/forestry/api/farming/IFarmProperties.java @@ -0,0 +1,48 @@ +package forestry.api.farming; + +import java.util.Collection; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; + +/** + * @since Forestry 5.8 + */ +public interface IFarmProperties { + + /** + * Can be used to register a {@link IBlockState} as a valid soil. + */ + default void registerSoil(ItemStack resource, IBlockState soilState){ + registerSoil(resource, soilState, false); + } + + /** + * Can be used to register a {@link IBlockState} as a valid soil. + */ + void registerSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData); + + /** + * Adds the {@link IFarmable}s that where registered with the given identifier. + */ + void registerFarmables(String identifier); + + /** + * @return true if the given block state is a valid soil state. + */ + boolean isAcceptedSoil(IBlockState blockState); + + /** + * @return true if the given stack is the {@link ItemStack} of a soil. + */ + boolean isAcceptedResource(ItemStack itemStack); + + Collection getSoils(); + + Collection getFarmables(); + + /** + * Returns the instance of the manual or managed {@link IFarmLogic}. + */ + IFarmLogic getLogic(boolean manuel); +} diff --git a/src/main/java/forestry/api/farming/IFarmRegistry.java b/src/main/java/forestry/api/farming/IFarmRegistry.java index 9119a990f..d580b5133 100644 --- a/src/main/java/forestry/api/farming/IFarmRegistry.java +++ b/src/main/java/forestry/api/farming/IFarmRegistry.java @@ -7,6 +7,7 @@ package forestry.api.farming; import javax.annotation.Nullable; import java.util.Collection; +import java.util.function.BiFunction; import net.minecraft.item.ItemStack; @@ -14,15 +15,35 @@ public interface IFarmRegistry { /** * Registers farming logic in registry under given identifier - * @param identifier Valid identifiers: farmArboreal farmWheat farmGourd farmInfernal farmPoales farmSucculentes farmVegetables farmShroom + * @param identifier Valid identifiers: farmArboreal farmCrops farmGourd farmInfernal farmPoales farmSucculentes farmShroom * @param logic corresponding instance of logic + * + * @deprecated Since Forestry 5.8. Use {@link #registerLogic(String, BiFunction, String...)} or + * {@link #registerLogic(String, IFarmProperties)}. */ - void registerFarmLogic(String identifier, IFarmLogic logic); - + @Deprecated + void registerLogic(String identifier, IFarmLogic logic); + + /** + * Registers farming logic in registry + * @since Forestry 5.8 + */ + IFarmProperties registerLogic(String identifier, IFarmProperties farmInstance); + + /** + * Registers farming logic in registry under given identifier + * + * @param identifier Valid identifiers: farmArboreal farmCrops farmGourd farmInfernal farmPoales farmSucculentes farmShroom + * @param logicFactory factory that creates the corresponding instance of logic + * @param farmablesIdentifiers Identifiers: farmArboreal farmCrops farmGourd farmInfernal farmPoales farmSucculentes farmShroom + * @since Forestry 5.8 + */ + IFarmProperties registerLogic(String identifier, BiFunction logicFactory, String... farmablesIdentifiers); + /** * Can be used to add IFarmables to some of the vanilla farm logics. *

- * Identifiers: farmArboreal farmWheat farmGourd farmInfernal farmPoales farmSucculentes farmVegetables farmShroom + * Identifiers: farmArboreal farmCrops farmGourd farmInfernal farmPoales farmSucculentes farmShroom */ void registerFarmables(String identifier, IFarmable... farmable); @@ -32,14 +53,18 @@ public interface IFarmRegistry { * Can be used to create a simple version of a farm logic, like the vanilla vegetable or wheat farm logic. * * @return Null if the farming plugin is not active. + * + * @deprecated Since Forestry 5.8. Use {@link #createCropLogic(IFarmProperties, boolean, ISimpleFarmLogic)} instead. */ @Nullable - IFarmLogic createLogic(ISimpleFarmLogic simpleFarmLogic); + @Deprecated + default IFarmLogic createLogic(ISimpleFarmLogic simpleFarmLogic){ + return null; + } /** - * * @param itemStack - * @param value The value of the fertitlizer.The value of the forestry fertelizer is 500. + * @param value The value of the fertitlizer. The value of the forestry fertelizer is 500. */ void registerFertilizer(ItemStack itemStack, int value); @@ -47,5 +72,28 @@ public interface IFarmRegistry { * @return The value of the fertitlizer */ int getFertilizeValue(ItemStack itemStack); + + /** + * Returns a fake {@link IFarmProperties} that returns the given logic at {@link IFarmProperties#getLogic(boolean)}. + * + * @since Forestry 5.8 + * @deprecated Only for backwards comparability. + */ + @Deprecated + IFarmProperties createFakeInstance(IFarmLogic logic); + + /** + * Can be used to create a simple version of a farm logic, like the vanilla vegetable or wheat farm logic. + * + * @return Null if the farming plugin is not active. + */ + @Nullable + IFarmLogic createCropLogic(IFarmProperties instance, boolean isManual, ISimpleFarmLogic simpleFarmLogic); + + /** + * @since Forestry 5.8 + */ + @Nullable + IFarmProperties getProperties(String identifier); } diff --git a/src/main/java/forestry/api/farming/IFarmable.java b/src/main/java/forestry/api/farming/IFarmable.java index b51eb8ba6..d13f09b47 100644 --- a/src/main/java/forestry/api/farming/IFarmable.java +++ b/src/main/java/forestry/api/farming/IFarmable.java @@ -20,8 +20,19 @@ public interface IFarmable { /** * @return true if the block at the given location is a "sapling" for this type, i.e. a non-harvestable immature version of the crop. + * @deprecated Since Forestry 5.8. Use the version below. TODO Remove this method in 1.13 */ - boolean isSaplingAt(World world, BlockPos pos); + @Deprecated + default boolean isSaplingAt(World world, BlockPos pos){ + return false; + } + + /** + * @return true if the block at the given location is a "sapling" for this type, i.e. a non-harvestable immature version of the crop. + */ + default boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState){ + return isSaplingAt(world, pos); + } /** * @return {@link ICrop} if the block at the given location is a harvestable and mature crop, null otherwise. diff --git a/src/main/java/forestry/api/farming/ISimpleFarmLogic.java b/src/main/java/forestry/api/farming/ISimpleFarmLogic.java index 71728b3a8..8ecc9df54 100644 --- a/src/main/java/forestry/api/farming/ISimpleFarmLogic.java +++ b/src/main/java/forestry/api/farming/ISimpleFarmLogic.java @@ -8,7 +8,9 @@ package forestry.api.farming; import net.minecraft.item.ItemStack; /** - * A simple version of the IFarmLogic. + * A simple version of the IFarmLogic. + * + * @apiNote TODO Remove this in 1.13 */ public interface ISimpleFarmLogic { @@ -16,7 +18,11 @@ public interface ISimpleFarmLogic { * @return the itemStack that represents this farm logic. Used as an icon for the farm logic. */ ItemStack getIconItemStack(); - + + /** + * @deprecated Since 5.8 + */ + @Deprecated Iterable getSeeds(); String getName(); diff --git a/src/main/java/forestry/api/farming/ISoil.java b/src/main/java/forestry/api/farming/ISoil.java new file mode 100644 index 000000000..03d2a08b0 --- /dev/null +++ b/src/main/java/forestry/api/farming/ISoil.java @@ -0,0 +1,16 @@ +package forestry.api.farming; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; + +/** + * @since Forestry 5.8 + */ +public interface ISoil { + + ItemStack getResource(); + + IBlockState getSoilState(); + + boolean hasMetaData(); +} diff --git a/src/main/java/forestry/api/farming/package-info.java b/src/main/java/forestry/api/farming/package-info.java index d599fba86..8a04a7f93 100644 --- a/src/main/java/forestry/api/farming/package-info.java +++ b/src/main/java/forestry/api/farming/package-info.java @@ -5,10 +5,11 @@ ******************************************************************************/ @ParametersAreNonnullByDefault @MethodsReturnNonnullByDefault -@API(apiVersion = "2.2.0", owner = "ForestryAPI|core", provides = "ForestryAPI|farming") +@API(apiVersion = "5.8.0", owner = "ForestryAPI|core", provides = "ForestryAPI|farming") package forestry.api.farming; import javax.annotation.ParametersAreNonnullByDefault; import mcp.MethodsReturnNonnullByDefault; + import net.minecraftforge.fml.common.API; diff --git a/src/main/java/forestry/core/blocks/BlockBase.java b/src/main/java/forestry/core/blocks/BlockBase.java index 366c5fba2..7c422379b 100755 --- a/src/main/java/forestry/core/blocks/BlockBase.java +++ b/src/main/java/forestry/core/blocks/BlockBase.java @@ -20,6 +20,7 @@ import net.minecraft.block.state.IBlockState; import net.minecraft.client.Minecraft; import net.minecraft.client.particle.ParticleManager; import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.inventory.IInventory; import net.minecraft.item.Item; @@ -40,8 +41,11 @@ import net.minecraft.util.math.Vec3d; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; +import com.mojang.authlib.GameProfile; + import net.minecraftforge.client.model.ModelLoader; import net.minecraftforge.fluids.FluidUtil; + import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; @@ -51,6 +55,8 @@ import forestry.api.core.ISpriteRegister; import forestry.api.core.IStateMapperRegister; import forestry.api.core.ITextureManager; import forestry.core.circuits.ISocketable; +import forestry.core.owner.IOwnedTile; +import forestry.core.owner.IOwnerHandler; import forestry.core.render.MachineParticleCallback; import forestry.core.render.MachineStateMapper; import forestry.core.render.ParticleHelper; @@ -70,7 +76,6 @@ public class BlockBase

& IBlockType & IStringSerializable> ext public final P blockType; private final ParticleHelper.Callback particleCallback; - protected final BlockStateContainer blockState; public BlockBase(P blockType, Material material) { super(material); @@ -82,9 +87,7 @@ public class BlockBase

& IBlockType & IStringSerializable> ext this.hasCustom = blockType instanceof IBlockTypeCustom; this.lightOpacity = (!hasTESR && !hasCustom) ? 255 : 0; - this.blockState = this.createBlockState(); - IBlockState state = this.blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH); - this.setDefaultState(state); + this.setDefaultState(blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH)); particleCallback = new MachineParticleCallback<>(this, blockType); } @@ -212,6 +215,22 @@ public class BlockBase

& IBlockType & IStringSerializable> ext super.breakBlock(world, pos, state); } + @Override + public void onBlockPlacedBy(World world, BlockPos pos, IBlockState state, EntityLivingBase placer, ItemStack stack) { + if (world.isRemote) { + return; + } + + if (placer instanceof EntityPlayer) { + TileUtil.actOnTile(world, pos, IOwnedTile.class, tile -> { + IOwnerHandler ownerHandler = tile.getOwnerHandler(); + EntityPlayer player = (EntityPlayer) placer; + GameProfile gameProfile = player.getGameProfile(); + ownerHandler.setOwner(gameProfile); + }); + } + } + public void init() { blockType.getMachineProperties().registerTileEntity(); } diff --git a/src/main/java/forestry/core/circuits/Circuit.java b/src/main/java/forestry/core/circuits/Circuit.java index 88396319b..f1e008ef9 100755 --- a/src/main/java/forestry/core/circuits/Circuit.java +++ b/src/main/java/forestry/core/circuits/Circuit.java @@ -37,7 +37,7 @@ public abstract class Circuit implements ICircuit { @Override public void addTooltip(List list) { - list.add(Translator.translateToLocal(getUnlocalizedName())); + list.add(getLocalizedName()); int i = 1; while (true) { diff --git a/src/main/java/forestry/core/circuits/CircuitRegistry.java b/src/main/java/forestry/core/circuits/CircuitRegistry.java index 28fb56e59..f2c0cc6df 100755 --- a/src/main/java/forestry/core/circuits/CircuitRegistry.java +++ b/src/main/java/forestry/core/circuits/CircuitRegistry.java @@ -77,11 +77,7 @@ public class CircuitRegistry implements ICircuitRegistry { @Override @Nullable public ICircuitLayout getLayout(String uid) { - if (layoutMap.containsKey(uid)) { - return layoutMap.get(uid); - } else { - return null; - } + return layoutMap.getOrDefault(uid, null); } /* CIRCUITS */ diff --git a/src/main/java/forestry/core/circuits/Circuits.java b/src/main/java/forestry/core/circuits/Circuits.java index cecbb5c96..81eb7f390 100644 --- a/src/main/java/forestry/core/circuits/Circuits.java +++ b/src/main/java/forestry/core/circuits/Circuits.java @@ -8,31 +8,39 @@ public class Circuits { public static ICircuit energyElectricEfficiency1; public static ICircuit energyElectricBoost1; public static ICircuit energyElectricBoost2; + public static ICircuit farmArborealManaged; + public static ICircuit farmOrchardManaged; public static ICircuit farmShroomManaged; - public static ICircuit farmCerealManaged; - public static ICircuit farmVegetableManaged; + public static ICircuit farmCropsManaged; public static ICircuit farmPeatManaged; public static ICircuit farmSucculentManaged; - public static ICircuit farmPoaleManaged; - public static ICircuit farmFungal; + public static ICircuit farmPoalesManaged; public static ICircuit farmInfernalManaged; + public static ICircuit farmEnderManaged; + public static ICircuit farmOrchidManaged; public static ICircuit farmGourdManaged; + public static ICircuit farmCocoaManaged; + + + public static ICircuit farmArborealManual; + public static ICircuit farmOrchardManual; public static ICircuit farmShroomManual; - public static ICircuit farmCerealManual; - public static ICircuit farmVegetableManual; + public static ICircuit farmCropsManual; public static ICircuit farmPeatManual; public static ICircuit farmSucculentManual; public static ICircuit farmPoalesManual; + public static ICircuit farmInfernalManual; + public static ICircuit farmEnderManual; + public static ICircuit farmOrchidManual; public static ICircuit farmGourdManual; public static ICircuit farmCocoaManual; - public static ICircuit farmOrchardManual; public static ICircuit farmRubberManual; - public static ICircuit farmEnderManaged; - public static ICircuit farmOrchidManaged; + public static ICircuit machineSpeedUpgrade1; public static ICircuit machineSpeedUpgrade2; public static ICircuit machineEfficiencyUpgrade1; + public static ICircuit climatiserTemperature1; public static ICircuit climatiserTemperature2; public static ICircuit climatiserHumidity1; diff --git a/src/main/java/forestry/core/circuits/GuiSolderingIron.java b/src/main/java/forestry/core/circuits/GuiSolderingIron.java index 049346ef6..ca83e5490 100755 --- a/src/main/java/forestry/core/circuits/GuiSolderingIron.java +++ b/src/main/java/forestry/core/circuits/GuiSolderingIron.java @@ -53,7 +53,7 @@ public class GuiSolderingIron extends GuiForestry { if (recipe == null) { description = "(" + Translator.translateToLocal("for.gui.noeffect") + ")"; } else { - description = Translator.translateToLocal(recipe.getCircuit().getUnlocalizedName()); + description = recipe.getCircuit().getLocalizedName(); } int row = i * 20; diff --git a/src/main/java/forestry/core/config/Config.java b/src/main/java/forestry/core/config/Config.java index d52976ff1..5822d5914 100755 --- a/src/main/java/forestry/core/config/Config.java +++ b/src/main/java/forestry/core/config/Config.java @@ -99,11 +99,17 @@ public class Config { // Farm public static int farmSize = 2; + public static float fertilizerModifier = 1.0F; public static boolean squareFarms = false; private static boolean enableExUtilEnderLily = true; private static boolean enableExUtilRedOrchid = true; private static boolean enableMagicalCropsSupport = true; + // Cultivation + public static int planterExtend = 4; + public static boolean ringFarms = true; + public static int ringSize = 4; + // Mail public static boolean mailAlertEnabled = true; public static GuiMailboxInfo.XPosition mailAlertXPosition = GuiMailboxInfo.XPosition.LEFT; @@ -278,11 +284,16 @@ public class Config { } farmSize = configCommon.getIntLocalized("tweaks.farms", "size", farmSize, 1, 3); + fertilizerModifier = configCommon.getFloatLocalized("tweaks.farms", "fertilizer", fertilizerModifier, 0.1F, 5.0F); squareFarms = configCommon.getBooleanLocalized("tweaks.farms", "square", squareFarms); enableExUtilEnderLily = configCommon.getBooleanLocalized("tweaks.farms", "enderlily", enableExUtilEnderLily); enableExUtilRedOrchid = configCommon.getBooleanLocalized("tweaks.farms", "redorchid", enableExUtilRedOrchid); enableMagicalCropsSupport = configCommon.getBooleanLocalized("tweaks.farms", "magicalcrops", enableMagicalCropsSupport); + planterExtend = configCommon.getIntLocalized("tweaks.cultivation", "extend", planterExtend, 1, 15); + ringFarms = configCommon.getBooleanLocalized("tweaks.cultivation", "ring", ringFarms); + ringSize = configCommon.getIntLocalized("tweaks.cultivation", "ring_size", ringSize, 1, 8); + CapsuleFluidPickup = configCommon.getBooleanLocalized("tweaks", "capsule", CapsuleFluidPickup); climateSourceRange = configCommon.getIntLocalized("tweaks.greenhouse", "range", climateSourceRange, 9, 270); diff --git a/src/main/java/forestry/core/gui/GuiIdRegistry.java b/src/main/java/forestry/core/gui/GuiIdRegistry.java index 56d7e6872..b5aec74d0 100644 --- a/src/main/java/forestry/core/gui/GuiIdRegistry.java +++ b/src/main/java/forestry/core/gui/GuiIdRegistry.java @@ -30,6 +30,7 @@ import forestry.core.items.ItemSolderingIron; import forestry.core.tiles.TileAnalyzer; import forestry.core.tiles.TileEscritoire; import forestry.core.tiles.TileNaturalistChest; +import forestry.cultivation.tiles.TilePlanter; import forestry.database.tiles.TileDatabase; import forestry.energy.tiles.TileEngineBiogas; import forestry.energy.tiles.TileEngineElectric; @@ -101,6 +102,9 @@ public class GuiIdRegistry { //Sorting Module TileGeneticFilter.class, + //Cultivation Module + TilePlanter.class, + //Greenhouse Module TileGreenhouse.class, TileClimatiser.class, diff --git a/src/main/java/forestry/core/items/ItemRegistryCore.java b/src/main/java/forestry/core/items/ItemRegistryCore.java index cfc4381f5..2884fa8a7 100644 --- a/src/main/java/forestry/core/items/ItemRegistryCore.java +++ b/src/main/java/forestry/core/items/ItemRegistryCore.java @@ -55,6 +55,7 @@ public class ItemRegistryCore extends ItemRegistry { public final ItemForestry sturdyCasing; public final ItemForestry hardenedCasing; public final ItemForestry impregnatedCasing; + public final ItemForestry flexibleCasing; public final ItemStack gearBronze; public final ItemStack gearCopper; public final ItemStack gearTin; @@ -110,6 +111,7 @@ public class ItemRegistryCore extends ItemRegistry { sturdyCasing = registerItem(new ItemForestry(), "sturdy_machine"); hardenedCasing = registerItem(new ItemForestry(), "hardened_machine"); impregnatedCasing = registerItem(new ItemForestry(), "impregnated_casing"); + flexibleCasing = registerItem(new ItemForestry(), "flexible_casing"); craftingMaterial = registerItem(new ItemCraftingMaterial(), "crafting_material"); diff --git a/src/main/java/forestry/core/network/packets/PacketGuiUpdate.java b/src/main/java/forestry/core/network/packets/PacketGuiUpdate.java index d29541117..0e84e46ad 100644 --- a/src/main/java/forestry/core/network/packets/PacketGuiUpdate.java +++ b/src/main/java/forestry/core/network/packets/PacketGuiUpdate.java @@ -12,6 +12,12 @@ package forestry.core.network.packets; import java.io.IOException; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.util.math.BlockPos; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + import forestry.api.core.ILocatable; import forestry.core.network.ForestryPacket; import forestry.core.network.IForestryPacketClient; @@ -20,10 +26,6 @@ import forestry.core.network.IStreamableGui; import forestry.core.network.PacketBufferForestry; import forestry.core.network.PacketIdClient; import forestry.core.tiles.TileUtil; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.util.math.BlockPos; -import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.fml.relauncher.SideOnly; public class PacketGuiUpdate extends ForestryPacket implements IForestryPacketClient { private final BlockPos pos; diff --git a/src/main/java/forestry/core/render/ParticleRender.java b/src/main/java/forestry/core/render/ParticleRender.java index b79312fd6..05a92a862 100755 --- a/src/main/java/forestry/core/render/ParticleRender.java +++ b/src/main/java/forestry/core/render/ParticleRender.java @@ -1,6 +1,7 @@ package forestry.core.render; import java.util.List; +import java.util.Random; import net.minecraft.client.Minecraft; import net.minecraft.client.particle.Particle; @@ -157,6 +158,26 @@ public class ParticleRender { effectRenderer.addEffect(particle); } } + + public static void addPortalFx(World world, BlockPos pos, Random rand){ + if (!shouldSpawnParticle(world)) { + return; + } + + int j = rand.nextInt(2) * 2 - 1; + int k = rand.nextInt(2) * 2 - 1; + double xPos = (double)pos.getX() + 0.5D + 0.25D * (double)j; + double yPos = (double)((float)pos.getY() + rand.nextFloat()); + double zPos = (double)pos.getZ() + 0.5D + 0.25D * (double)k; + double xSpeed = (double)(rand.nextFloat() * (float)j); + double ySpeed = ((double)rand.nextFloat() - 0.5D) * 0.125D; + double zSpeed = (double)(rand.nextFloat() * (float)k); + ParticleManager effectRenderer = Minecraft.getMinecraft().effectRenderer; + Particle particle = effectRenderer.spawnEffectParticle(EnumParticleTypes.PORTAL.getParticleID(), xPos, yPos, zPos, xSpeed, ySpeed, zSpeed); + if(particle != null){ + effectRenderer.addEffect(particle); + } + } public static void addEntityBiodustFX(World world, double x, double y, double z){ if (!shouldSpawnParticle(world)) { diff --git a/src/main/java/forestry/core/utils/OreDictUtil.java b/src/main/java/forestry/core/utils/OreDictUtil.java index bda0e0b6d..c427dd11d 100644 --- a/src/main/java/forestry/core/utils/OreDictUtil.java +++ b/src/main/java/forestry/core/utils/OreDictUtil.java @@ -78,4 +78,6 @@ public class OreDictUtil { public static final String DYE_YELLOW = "dyeYellow"; public static final String DYE_BLUE = "dyeBlue"; public static final String DYE_RED = "dyeRed"; + + public static final String SLIMEBALL = "slimeball"; } diff --git a/src/main/java/forestry/core/utils/VectUtil.java b/src/main/java/forestry/core/utils/VectUtil.java index 4b0394fb7..64917ed1d 100644 --- a/src/main/java/forestry/core/utils/VectUtil.java +++ b/src/main/java/forestry/core/utils/VectUtil.java @@ -10,11 +10,12 @@ ******************************************************************************/ package forestry.core.utils; +import com.google.common.collect.AbstractIterator; + import javax.annotation.Nullable; import java.util.Iterator; import java.util.Random; -import com.google.common.collect.AbstractIterator; import net.minecraft.util.EnumFacing; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3i; diff --git a/src/main/java/forestry/cultivation/ModuleCultivation.java b/src/main/java/forestry/cultivation/ModuleCultivation.java new file mode 100644 index 000000000..f1f9b492c --- /dev/null +++ b/src/main/java/forestry/cultivation/ModuleCultivation.java @@ -0,0 +1,132 @@ +package forestry.cultivation; + +import com.google.common.base.Preconditions; +import com.google.common.collect.ImmutableSet; + +import javax.annotation.Nullable; +import java.util.Set; + +import net.minecraft.util.ResourceLocation; + +import forestry.api.modules.ForestryModule; +import forestry.core.ModuleCore; +import forestry.core.circuits.EnumCircuitBoardType; +import forestry.core.config.Constants; +import forestry.core.items.EnumElectronTube; +import forestry.core.items.ItemRegistryCore; +import forestry.core.recipes.RecipeUtil; +import forestry.core.utils.OreDictUtil; +import forestry.cultivation.blocks.BlockPlanter; +import forestry.cultivation.blocks.BlockRegistryCultivation; +import forestry.modules.BlankForestryModule; +import forestry.modules.ForestryModuleUids; + +@ForestryModule(containerID = Constants.MOD_ID, moduleID = ForestryModuleUids.CULTIVATION, name = "Cultivation", author = "Nedelosk", url = Constants.URL, unlocalizedDescription = "for.module.cultivation.description") +public class ModuleCultivation extends BlankForestryModule { + @Nullable + private static BlockRegistryCultivation blocks; + + public static BlockRegistryCultivation getBlocks() { + Preconditions.checkState(blocks != null); + return blocks; + } + + @Override + public void registerItemsAndBlocks() { + blocks = new BlockRegistryCultivation(); + } + + @Override + public Set getDependencyUids() { + return ImmutableSet.of(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.CORE), + new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)); + } + + @Override + public void doInit() { + BlockRegistryCultivation blocks = getBlocks(); + + blocks.arboretum.init(); + blocks.farmCrops.init(); + blocks.farmMushroom.init(); + blocks.farmNether.init(); + blocks.farmGourd.init(); + blocks.farmEnder.init(); + //blocks.plantation.init(); + blocks.peatBog.init(); + } + + @Override + public void registerRecipes() { + BlockRegistryCultivation blocks = getBlocks(); + ItemRegistryCore coreItems = ModuleCore.getItems(); + + RecipeUtil.addRecipe("arboretum", blocks.arboretum, + "GTG", + "TCT", + "GBG", + 'G', OreDictUtil.BLOCK_GLASS, + 'T', coreItems.tubes.get(EnumElectronTube.GOLD, 1), + 'C', coreItems.flexibleCasing, + 'B', coreItems.circuitboards.get(EnumCircuitBoardType.BASIC)); + + RecipeUtil.addRecipe("farm_crops", blocks.farmCrops, + "GTG", + "TCT", + "GBG", + 'G', OreDictUtil.BLOCK_GLASS, + 'T', coreItems.tubes.get(EnumElectronTube.BRONZE, 1), + 'C', coreItems.flexibleCasing, + 'B', coreItems.circuitboards.get(EnumCircuitBoardType.BASIC)); + + RecipeUtil.addRecipe("peat_bog", blocks.peatBog, + "GTG", + "TCT", + "GBG", + 'G', OreDictUtil.BLOCK_GLASS, + 'T', coreItems.tubes.get(EnumElectronTube.OBSIDIAN, 1), + 'C', coreItems.flexibleCasing, + 'B', coreItems.circuitboards.get(EnumCircuitBoardType.BASIC)); + + RecipeUtil.addRecipe("farm_mushroom", blocks.farmMushroom, + "GTG", + "TCT", + "GBG", + 'G', OreDictUtil.BLOCK_GLASS, + 'T', coreItems.tubes.get(EnumElectronTube.APATITE, 1), + 'C', coreItems.flexibleCasing, + 'B', coreItems.circuitboards.get(EnumCircuitBoardType.BASIC)); + + RecipeUtil.addRecipe("farm_gourd", blocks.farmGourd, + "GTG", + "TCT", + "GBG", + 'G', OreDictUtil.BLOCK_GLASS, + 'T', coreItems.tubes.get(EnumElectronTube.LAPIS, 1), + 'C', coreItems.flexibleCasing, + 'B', coreItems.circuitboards.get(EnumCircuitBoardType.BASIC)); + + RecipeUtil.addRecipe("farm_nether", blocks.farmNether, + "GTG", + "TCT", + "GBG", + 'G', OreDictUtil.BLOCK_GLASS, + 'T', coreItems.tubes.get(EnumElectronTube.BLAZE, 1), + 'C', coreItems.flexibleCasing, + 'B', coreItems.circuitboards.get(EnumCircuitBoardType.BASIC)); + + RecipeUtil.addRecipe("farm_ender", blocks.farmEnder, + "GTG", + "TCT", + "GBG", + 'G', OreDictUtil.BLOCK_GLASS, + 'T', coreItems.tubes.get(EnumElectronTube.ENDER, 1), + 'C', coreItems.flexibleCasing, + 'B', coreItems.circuitboards.get(EnumCircuitBoardType.BASIC)); + + for(BlockPlanter planter : getBlocks().getPlanters()){ + RecipeUtil.addShapelessRecipe(planter.blockType.getName() + "_manual_managed", planter.get(true), planter.get(false)); + RecipeUtil.addShapelessRecipe(planter.blockType.getName() + "_managed_manual", planter.get(false), planter.get(true)); + } + } +} diff --git a/src/main/java/forestry/cultivation/blocks/BlockPlanter.java b/src/main/java/forestry/cultivation/blocks/BlockPlanter.java new file mode 100644 index 000000000..d596653ae --- /dev/null +++ b/src/main/java/forestry/cultivation/blocks/BlockPlanter.java @@ -0,0 +1,112 @@ +package forestry.cultivation.blocks; + +import java.util.Random; + +import net.minecraft.block.material.Material; +import net.minecraft.block.properties.PropertyBool; +import net.minecraft.block.state.BlockStateContainer; +import net.minecraft.block.state.IBlockState; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.BlockRenderLayer; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumHand; +import net.minecraft.util.NonNullList; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import net.minecraftforge.client.model.ModelLoader; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.core.blocks.BlockBase; +import forestry.core.render.ParticleRender; +import forestry.cultivation.tiles.TilePlanter; + +public class BlockPlanter extends BlockBase { + public static final PropertyBool MANUAL = PropertyBool.create("manual"); + + public BlockPlanter(BlockTypePlanter blockType) { + super(blockType, Material.WOOD); + this.setDefaultState(blockState.getBaseState().withProperty(FACING, EnumFacing.NORTH).withProperty(MANUAL, false)); + } + + @Override + protected BlockStateContainer createBlockState() { + return new BlockStateContainer(this, FACING, MANUAL); + } + + @SideOnly(Side.CLIENT) + @Override + public void randomDisplayTick(IBlockState stateIn, World worldIn, BlockPos pos, Random rand) { + if(blockType == BlockTypePlanter.FARM_ENDER){ + for (int i = 0; i < 3; ++i) { + ParticleRender.addPortalFx(worldIn, pos, rand); + } + } + } + + @Override + public IBlockState getStateFromMeta(int meta) { + int facing = meta & 7; + return getDefaultState().withProperty(FACING, EnumFacing.fromAngle(facing)).withProperty(MANUAL, (meta & 8) == 8); + } + + @Override + public int getMetaFromState(IBlockState state) { + if(state.getValue(MANUAL)){ + return state.getValue(FACING).ordinal(); + } + return 8 + state.getValue(FACING).ordinal(); + } + + @Override + public TileEntity createTileEntity(World world, IBlockState state) { + TileEntity tile = super.createNewTileEntity(world, 0); + if(tile instanceof TilePlanter){ + TilePlanter planter = (TilePlanter) tile; + planter.setManual(state.getValue(MANUAL)); + } + return tile; + } + + @Override + public int damageDropped(IBlockState state) { + return state.getValue(MANUAL) ? 1 : 0; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerStateMapper() { + ModelLoader.setCustomStateMapper(this, new PlanterStateMapper()); + } + + @Override + public BlockRenderLayer getBlockLayer() { + return BlockRenderLayer.CUTOUT; + } + + @Override + public IBlockState getStateForPlacement(World world, BlockPos pos, EnumFacing facing, float hitX, float hitY, float hitZ, int meta, EntityLivingBase placer, EnumHand hand) { + ItemStack stack = placer.getHeldItem(hand); + return getDefaultState().withProperty(MANUAL, isManual(stack)); + } + + @Override + public void getSubBlocks(CreativeTabs itemIn, NonNullList items) { + for(byte i = 0;i < 2;i++){ + items.add(get(i == 1)); + } + } + + public static boolean isManual(ItemStack stack){ + return stack.getMetadata() == 1; + } + + public ItemStack get(boolean isManual){ + return new ItemStack(this, 1, isManual ? 1 : 0); + } +} diff --git a/src/main/java/forestry/cultivation/blocks/BlockRegistryCultivation.java b/src/main/java/forestry/cultivation/blocks/BlockRegistryCultivation.java new file mode 100644 index 000000000..b67c3c048 --- /dev/null +++ b/src/main/java/forestry/cultivation/blocks/BlockRegistryCultivation.java @@ -0,0 +1,56 @@ +package forestry.cultivation.blocks; + +import java.util.HashSet; +import java.util.Set; + +import forestry.core.blocks.BlockRegistry; +import forestry.cultivation.items.ItemBlockPlanter; + +public class BlockRegistryCultivation extends BlockRegistry { + private Set planters = new HashSet<>(); + + public final BlockPlanter arboretum; + public final BlockPlanter farmCrops; + public final BlockPlanter farmMushroom; + public final BlockPlanter farmGourd; + public final BlockPlanter farmNether; + public final BlockPlanter farmEnder; + public final BlockPlanter peatBog; + /*public final BlockPlanter plantation;*/ + + public BlockRegistryCultivation() { + arboretum = new BlockPlanter(BlockTypePlanter.ARBORETUM); + registerBlock(arboretum, new ItemBlockPlanter(arboretum), "arboretum"); + planters.add(arboretum); + + farmCrops = new BlockPlanter(BlockTypePlanter.FARM_CROPS); + registerBlock(farmCrops, new ItemBlockPlanter(farmCrops), "farm_crops"); + planters.add(farmCrops); + + farmMushroom = new BlockPlanter(BlockTypePlanter.FARM_MUSHROOM); + registerBlock(farmMushroom, new ItemBlockPlanter(farmMushroom), "farm_mushroom"); + planters.add(farmMushroom); + + farmGourd = new BlockPlanter(BlockTypePlanter.FARM_GOURD); + registerBlock(farmGourd, new ItemBlockPlanter(farmGourd), "farm_gourd"); + planters.add(farmGourd); + + farmNether = new BlockPlanter(BlockTypePlanter.FARM_NETHER); + registerBlock(farmNether, new ItemBlockPlanter(farmNether), "farm_nether"); + planters.add(farmNether); + + farmEnder = new BlockPlanter(BlockTypePlanter.FARM_ENDER); + registerBlock(farmEnder, new ItemBlockPlanter(farmEnder), "farm_ender"); + planters.add(farmEnder); + + peatBog = new BlockPlanter(BlockTypePlanter.PEAT_POG); + registerBlock(peatBog, new ItemBlockPlanter(peatBog), "peat_bog"); + planters.add(peatBog); + /* plantation = new BlockPlanter(BlockTypePlanter.PLANTATION); + registerBlock(plantation, new ItemBlockForestry<>(plantation), "plantation");*/ + } + + public Set getPlanters() { + return planters; + } +} diff --git a/src/main/java/forestry/cultivation/blocks/BlockTypePlanter.java b/src/main/java/forestry/cultivation/blocks/BlockTypePlanter.java new file mode 100644 index 000000000..f8542dbf3 --- /dev/null +++ b/src/main/java/forestry/cultivation/blocks/BlockTypePlanter.java @@ -0,0 +1,41 @@ +package forestry.cultivation.blocks; + +import forestry.core.blocks.IBlockTypeCustom; +import forestry.core.blocks.IMachineProperties; +import forestry.cultivation.tiles.TileArboretum; +import forestry.cultivation.tiles.TileBog; +import forestry.cultivation.tiles.TileFarmCrops; +import forestry.cultivation.tiles.TileFarmEnder; +import forestry.cultivation.tiles.TileFarmGourd; +import forestry.cultivation.tiles.TileFarmMushroom; +import forestry.cultivation.tiles.TileFarmNether; +import forestry.cultivation.tiles.TilePlanter; + +public enum BlockTypePlanter implements IBlockTypeCustom { + ARBORETUM(TileArboretum.class, "arboretum"), + FARM_CROPS(TileFarmCrops.class, "farm_crop"), + FARM_MUSHROOM(TileFarmMushroom.class, "farm_mushroom"), + FARM_GOURD(TileFarmGourd.class, "farm_gourd"), + FARM_NETHER(TileFarmNether.class, "farm_nether"), + FARM_ENDER(TileFarmEnder.class, "farm_ender"), + PEAT_POG(TileBog.class, "peat_bog"), + + //TODO Add ic2 integration + /*PLANTATION(TilePlantation.class, "plantation")*/; + + private final IMachineProperties machineProperties; + + BlockTypePlanter(Class teClass, String name) { + this.machineProperties = new PlanterProperties<>(teClass, name); + } + + @Override + public IMachineProperties getMachineProperties() { + return machineProperties; + } + + @Override + public String getName() { + return getMachineProperties().getName(); + } +} diff --git a/src/main/java/forestry/cultivation/blocks/PlanterProperties.java b/src/main/java/forestry/cultivation/blocks/PlanterProperties.java new file mode 100644 index 000000000..4a334f702 --- /dev/null +++ b/src/main/java/forestry/cultivation/blocks/PlanterProperties.java @@ -0,0 +1,27 @@ +package forestry.cultivation.blocks; + +import com.google.common.base.Preconditions; + +import net.minecraft.item.Item; +import net.minecraft.util.ResourceLocation; + +import forestry.api.core.IModelManager; +import forestry.core.blocks.MachineProperties; +import forestry.core.utils.ItemStackUtil; +import forestry.cultivation.tiles.TilePlanter; + +public class PlanterProperties extends MachineProperties { + + PlanterProperties(Class teClass, String name) { + super(teClass, name); + } + + @Override + public void registerModel(Item item, IModelManager manager) { + ResourceLocation itemNameFromRegistry = ItemStackUtil.getItemNameFromRegistry(item); + Preconditions.checkNotNull(itemNameFromRegistry, "No registry name for item"); + String identifier = itemNameFromRegistry.getResourcePath(); + manager.registerItemModel(item, 0, identifier); + manager.registerItemModel(item, 1, identifier); + } +} diff --git a/src/main/java/forestry/cultivation/blocks/PlanterStateMapper.java b/src/main/java/forestry/cultivation/blocks/PlanterStateMapper.java new file mode 100644 index 000000000..ecaca00b4 --- /dev/null +++ b/src/main/java/forestry/cultivation/blocks/PlanterStateMapper.java @@ -0,0 +1,43 @@ +package forestry.cultivation.blocks; + +import com.google.common.collect.Maps; + +import java.util.LinkedHashMap; +import java.util.Map; + +import net.minecraft.block.Block; +import net.minecraft.block.properties.IProperty; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.renderer.block.model.ModelResourceLocation; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.ResourceLocation; + +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +import forestry.core.blocks.BlockBase; +import forestry.core.render.ForestryStateMapper; + +@SideOnly(Side.CLIENT) +public class PlanterStateMapper extends ForestryStateMapper { + + @Override + public Map putStateModelLocations(Block block) { + for (EnumFacing facing : EnumFacing.values()) { + if (facing == EnumFacing.DOWN || facing == EnumFacing.UP) { + continue; + } + for(boolean manual : new boolean[]{false, true}) { + IBlockState state = block.getDefaultState().withProperty(BlockBase.FACING, facing).withProperty(BlockPlanter.MANUAL, manual); + LinkedHashMap, Comparable> properties = Maps.newLinkedHashMap(state.getProperties()); + properties.remove(BlockPlanter.MANUAL); + ResourceLocation blockLocation = Block.REGISTRY.getNameForObject(block); + String s = String.format("%s:%s", blockLocation.getResourceDomain(), blockLocation.getResourcePath()); + mapStateModelLocations.put(state, new ModelResourceLocation(s, getPropertyString(properties))); + } + } + + return this.mapStateModelLocations; + } + +} diff --git a/src/main/java/forestry/cultivation/blocks/package-info.java b/src/main/java/forestry/cultivation/blocks/package-info.java new file mode 100644 index 000000000..b9d177317 --- /dev/null +++ b/src/main/java/forestry/cultivation/blocks/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.cultivation.blocks; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/cultivation/gui/ContainerPlanter.java b/src/main/java/forestry/cultivation/gui/ContainerPlanter.java new file mode 100644 index 000000000..ec66f1eeb --- /dev/null +++ b/src/main/java/forestry/cultivation/gui/ContainerPlanter.java @@ -0,0 +1,50 @@ +package forestry.cultivation.gui; + +import net.minecraft.entity.player.InventoryPlayer; + +import forestry.core.gui.ContainerLiquidTanks; +import forestry.core.gui.slots.SlotFiltered; +import forestry.core.gui.slots.SlotLiquidIn; +import forestry.core.gui.slots.SlotOutput; +import forestry.core.network.packets.PacketGuiUpdate; +import forestry.cultivation.inventory.InventoryPlanter; +import forestry.cultivation.tiles.TilePlanter; + +public class ContainerPlanter extends ContainerLiquidTanks { + public ContainerPlanter(TilePlanter tileForestry, InventoryPlayer playerInventory) { + super(tileForestry, playerInventory, 21, 110); + + // Resources + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + addSlotToContainer(new SlotFiltered(tile.getInternalInventory(), InventoryPlanter.SLOT_RESOURCES_1 + j + i * 2, 11 + j * 18, 65 + i * 18)); + } + } + + // Germlings + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + addSlotToContainer(new SlotFiltered(tile.getInternalInventory(), InventoryPlanter.SLOT_GERMLINGS_1 + j + i * 2, 71 + j * 18, 65 + i * 18)); + } + } + + // Production + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + addSlotToContainer(new SlotOutput(tile.getInternalInventory(), InventoryPlanter.SLOT_PRODUCTION_1 + j + i * 2, 131 + j * 18, 65 + i * 18)); + } + } + + // Fertilizer + addSlotToContainer(new SlotFiltered(tile.getInternalInventory(), InventoryPlanter.SLOT_FERTILIZER, 83, 22)); + // Can Slot + addSlotToContainer(new SlotLiquidIn(tile.getInternalInventory(), InventoryPlanter.SLOT_CAN, 178, 18)); + } + + @Override + public void detectAndSendChanges() { + super.detectAndSendChanges(); + PacketGuiUpdate packet = new PacketGuiUpdate(tile); + sendPacketToListeners(packet); + } +} diff --git a/src/main/java/forestry/cultivation/gui/GuiPlanter.java b/src/main/java/forestry/cultivation/gui/GuiPlanter.java new file mode 100644 index 000000000..4f892bede --- /dev/null +++ b/src/main/java/forestry/cultivation/gui/GuiPlanter.java @@ -0,0 +1,82 @@ +package forestry.cultivation.gui; + +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +import forestry.core.ModuleCore; +import forestry.core.config.Constants; +import forestry.core.gui.GuiForestryTitled; +import forestry.core.gui.widgets.TankWidget; +import forestry.cultivation.gui.widgets.GhostItemStackWidget; +import forestry.cultivation.inventory.InventoryPlanter; +import forestry.cultivation.tiles.TilePlanter; +import forestry.farming.gui.FarmLedger; + +public class GuiPlanter extends GuiForestryTitled { + private final TilePlanter tile; + + public GuiPlanter(TilePlanter tile, InventoryPlayer playerInventory) { + super(Constants.TEXTURE_PATH_GUI + "/planter.png", new ContainerPlanter(tile, playerInventory), tile); + this.tile = tile; + this.xSize = 202; + this.ySize = 192; + + NonNullList resourceStacks = tile.createResourceStacks(); + NonNullList germlingStacks = tile.createGermlingStacks(); + NonNullList productionStacks = tile.createProductionStacks(); + + widgetManager.add(new TankWidget(widgetManager, 178, 44, 0).setOverlayOrigin(xSize, 18)); + + // Resources + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + int index = j + i * 2; + if(resourceStacks.size() == 4) { + widgetManager.add(new GhostItemStackWidget(widgetManager, 11 + j * 18, 65 + i * 18, resourceStacks.get(index), inventorySlots.getSlot(36 + InventoryPlanter.SLOT_RESOURCES_1 + index))); + } + } + } + + // Germlings + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + int index = j + i * 2; + if(germlingStacks.size() == 4){ + widgetManager.add(new GhostItemStackWidget(widgetManager, 71 + j * 18, 65 + i * 18, germlingStacks.get(index), inventorySlots.getSlot(36 + InventoryPlanter.SLOT_GERMLINGS_1 + index))); + } + } + } + + // Production + for (int i = 0; i < 2; i++) { + for (int j = 0; j < 2; j++) { + int index = j + i * 2; + if(productionStacks.size() == 4) { + widgetManager.add(new GhostItemStackWidget(widgetManager, 131 + j * 18, 65 + i * 18, productionStacks.get(index), inventorySlots.getSlot(36 + InventoryPlanter.SLOT_PRODUCTION_1 + j + i * 2))); + } + } + } + + widgetManager.add(new GhostItemStackWidget(widgetManager, 83, 22, new ItemStack(ModuleCore.getItems().fertilizerCompound), inventorySlots.getSlot(36 + InventoryPlanter.SLOT_FERTILIZER))); + } + + @Override + protected void addLedgers() { + addErrorLedger(tile); + addClimateLedger(tile); + ledgerManager.add(new FarmLedger(ledgerManager, tile.getFarmLedgerDelegate())); + addOwnerLedger(tile); + } + + @Override + protected void drawGuiContainerBackgroundLayer(float var1, int mouseX, int mouseY) { + super.drawGuiContainerBackgroundLayer(var1, mouseX, mouseY); + + // Fuel remaining + int fertilizerRemain = tile.getStoredFertilizerScaled(16); + if (fertilizerRemain > 0) { + drawTexturedModalRect(guiLeft + 101, guiTop + 21 + 17 - fertilizerRemain, xSize, 17 - fertilizerRemain, 4, fertilizerRemain); + } + } +} diff --git a/src/main/java/forestry/cultivation/gui/package-info.java b/src/main/java/forestry/cultivation/gui/package-info.java new file mode 100644 index 000000000..a8015890e --- /dev/null +++ b/src/main/java/forestry/cultivation/gui/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.cultivation.gui; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/cultivation/gui/widgets/GhostItemStackWidget.java b/src/main/java/forestry/cultivation/gui/widgets/GhostItemStackWidget.java new file mode 100644 index 000000000..969f9d412 --- /dev/null +++ b/src/main/java/forestry/cultivation/gui/widgets/GhostItemStackWidget.java @@ -0,0 +1,69 @@ +package forestry.cultivation.gui.widgets; + +import javax.annotation.Nullable; +import java.util.Locale; + +import net.minecraft.client.Minecraft; +import net.minecraft.client.gui.FontRenderer; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.inventory.Slot; +import net.minecraft.item.ItemStack; + +import forestry.api.farming.FarmDirection; +import forestry.core.gui.tooltips.ToolTip; +import forestry.core.gui.widgets.ItemStackWidget; +import forestry.core.gui.widgets.WidgetManager; +import forestry.core.render.ColourProperties; +import forestry.core.utils.Translator; +import forestry.cultivation.inventory.InventoryPlanter; + +public class GhostItemStackWidget extends ItemStackWidget { + private final Slot slot; + public GhostItemStackWidget(WidgetManager widgetManager, int xPos, int yPos, ItemStack itemStack, Slot slot) { + super(widgetManager, xPos, yPos, itemStack); + this.slot = slot; + } + + @Override + public void draw(int startX, int startY) { + if (!slot.getHasStack()) { + super.draw(startX, startY); + } + GlStateManager.disableLighting(); + GlStateManager.disableDepth(); + GlStateManager.enableBlend(); + + String directionString = getDirectionString(); + if (!directionString.isEmpty()){ + FontRenderer fontRenderer = manager.minecraft.fontRenderer; + fontRenderer.drawStringWithShadow(getDirectionString(), xPos + startX + 5, yPos + startY + 4, ColourProperties.INSTANCE.get("gui.screen")); + } + + GlStateManager.color(1.0F, 1.0F, 1.0F, 0.5F); + + TextureManager textureManager = Minecraft.getMinecraft().getTextureManager(); + textureManager.bindTexture(manager.gui.textureFile); + manager.gui.drawTexturedModalRect(xPos + startX, yPos + startY, 206, 0, 16, 16); + + GlStateManager.disableBlend(); + GlStateManager.enableDepth(); + GlStateManager.enableLighting(); + } + + private String getDirectionString(){ + if(slot.getSlotIndex() >= InventoryPlanter.SLOT_PRODUCTION_1 || slot.getSlotIndex() < InventoryPlanter.SLOT_RESOURCES_1 + InventoryPlanter.SLOT_RESOURCES_COUNT){ + return ""; + } + int index = slot.getSlotIndex() % 4; + FarmDirection direction = FarmDirection.values()[index]; + String directionString = direction.toString().toLowerCase(Locale.ENGLISH); + return Translator.translateToLocal("for.gui.planter." + directionString); + } + + @Nullable + @Override + public ToolTip getToolTip(int mouseX, int mouseY) { + return null; + } +} diff --git a/src/main/java/forestry/cultivation/gui/widgets/package-info.java b/src/main/java/forestry/cultivation/gui/widgets/package-info.java new file mode 100644 index 000000000..13aec40b2 --- /dev/null +++ b/src/main/java/forestry/cultivation/gui/widgets/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.cultivation.gui.widgets; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/cultivation/inventory/InventoryPlanter.java b/src/main/java/forestry/cultivation/inventory/InventoryPlanter.java new file mode 100644 index 000000000..00feb1680 --- /dev/null +++ b/src/main/java/forestry/cultivation/inventory/InventoryPlanter.java @@ -0,0 +1,219 @@ +package forestry.cultivation.inventory; + +import java.util.Stack; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.NonNullList; +import net.minecraft.util.math.BlockPos; + +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.FluidUtil; + +import forestry.api.core.ForestryAPI; +import forestry.api.farming.FarmDirection; +import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmable; +import forestry.core.fluids.FluidHelper; +import forestry.core.fluids.TankManager; +import forestry.core.inventory.InventoryAdapterRestricted; +import forestry.core.inventory.wrappers.InventoryMapper; +import forestry.core.utils.InventoryUtil; +import forestry.core.utils.SlotUtil; +import forestry.cultivation.tiles.TilePlanter; +import forestry.farming.multiblock.IFarmInventoryInternal; + +public class InventoryPlanter extends InventoryAdapterRestricted implements IFarmInventoryInternal { + public static final int SLOT_RESOURCES_1 = 0; + public static final int SLOT_RESOURCES_COUNT = 4; + public static final int SLOT_GERMLINGS_1 = 4; + public static final int SLOT_GERMLINGS_COUNT = 4; + public static final int SLOT_PRODUCTION_1 = 8; + public static final int SLOT_PRODUCTION_COUNT = 4; + + public static final int SLOT_FERTILIZER = 12; + public static final int SLOT_FERTILIZER_COUNT = 1; + public static final int SLOT_CAN = 13; + public static final int SLOT_CAN_COUNT = 1; + + public static final int SLOT_COUNT = SLOT_RESOURCES_COUNT + SLOT_GERMLINGS_COUNT + SLOT_PRODUCTION_COUNT + SLOT_FERTILIZER_COUNT + SLOT_CAN_COUNT; + + private static final int FERTILIZER_MODIFIER = ForestryAPI.activeMode.getIntegerSetting("farms.fertilizer.modifier"); + + private final TilePlanter housing; + + private final IInventory resourcesInventory; + private final IInventory germlingsInventory; + private final IInventory productInventory; + private final IInventory fertilizerInventory; + + public InventoryPlanter(TilePlanter housing) { + super(SLOT_COUNT, "Items"); + this.housing = housing; + + this.resourcesInventory = new InventoryMapper(this, SLOT_RESOURCES_1, SLOT_RESOURCES_COUNT); + this.germlingsInventory = new InventoryMapper(this, SLOT_GERMLINGS_1, SLOT_GERMLINGS_COUNT); + this.productInventory = new InventoryMapper(this, SLOT_PRODUCTION_1, SLOT_PRODUCTION_COUNT); + this.fertilizerInventory = new InventoryMapper(this, SLOT_FERTILIZER, SLOT_FERTILIZER_COUNT); + } + + @Override + public boolean canSlotAccept(int slotIndex, ItemStack itemStack) { + if (SlotUtil.isSlotInRange(slotIndex, SLOT_FERTILIZER, SLOT_FERTILIZER_COUNT)) { + return acceptsAsFertilizer(itemStack); + } else if (SlotUtil.isSlotInRange(slotIndex, SLOT_GERMLINGS_1, SLOT_GERMLINGS_COUNT)) { + return acceptsAsGermling(itemStack); + } else if (SlotUtil.isSlotInRange(slotIndex, SLOT_RESOURCES_1, SLOT_RESOURCES_COUNT)) { + return acceptsAsResource(itemStack); + } else if (SlotUtil.isSlotInRange(slotIndex, SLOT_CAN, SLOT_CAN_COUNT)) { + FluidStack fluid = FluidUtil.getFluidContained(itemStack); + return fluid != null && housing.getTankManager().canFillFluidType(fluid); + } + return false; + } + + @Override + public boolean canExtractItem(int slotIndex, ItemStack stack, EnumFacing side) { + return SlotUtil.isSlotInRange(slotIndex, SLOT_PRODUCTION_1, SLOT_PRODUCTION_COUNT); + } + + @Override + public boolean hasResources(NonNullList resources) { + return InventoryUtil.contains(resourcesInventory, resources); + } + + @Override + public void removeResources(NonNullList resources) { + InventoryUtil.removeSets(resourcesInventory, 1, resources, null, false, true, false, true); + } + + @Override + public boolean acceptsAsGermling(ItemStack itemstack) { + if (itemstack.isEmpty()) { + return false; + } + + IFarmLogic logic = housing.getFarmLogic(); + return logic.isAcceptedGermling(itemstack); + + } + + @Override + public boolean acceptsAsResource(ItemStack itemstack) { + if (itemstack.isEmpty()) { + return false; + } + + IFarmLogic logic = housing.getFarmLogic(); + return logic.isAcceptedResource(itemstack); + + } + + @Override + public boolean acceptsAsFertilizer(ItemStack itemstack) { + if (itemstack.isEmpty()) { + return false; + } + + return ForestryAPI.farmRegistry.getFertilizeValue(itemstack) > 0; + } + + @Override + public IInventory getProductInventory() { + return productInventory; + } + + @Override + public IInventory getGermlingsInventory() { + return germlingsInventory; + } + + @Override + public IInventory getResourcesInventory() { + return resourcesInventory; + } + + @Override + public IInventory getFertilizerInventory() { + return fertilizerInventory; + } + + public void drainCan(TankManager tankManager) { + FluidHelper.drainContainers(tankManager, this, SLOT_CAN); + } + + public boolean plantGermling(IFarmable germling, EntityPlayer player, BlockPos pos) { + for(FarmDirection direction : FarmDirection.values()){ + if(plantGermling(germling, player, pos, direction)){ + return true; + } + } + return false; + } + + public boolean plantGermling(IFarmable germling, EntityPlayer player, BlockPos pos, FarmDirection direction) { + int index = direction.ordinal(); + ItemStack germlingStack = germlingsInventory.getStackInSlot(index); + if (germlingStack.isEmpty() || !germling.isGermling(germlingStack)) { + return false; + } + + if (germling.plantSaplingAt(player, germlingStack, player.world, pos)) { + germlingsInventory.decrStackSize(index, 1); + return true; + } + return false; + } + + public void addProduce(ItemStack produce) { + int added = InventoryUtil.addStack(productInventory, produce, true); + produce.shrink(added); + } + + public void stowHarvest(Iterable harvested, Stack pendingProduce) { + for (ItemStack harvest : harvested) { + int added = InventoryUtil.addStack(productInventory, harvest, true); + harvest.shrink(added); + if (!harvest.isEmpty()) { + pendingProduce.push(harvest); + } + } + } + + public boolean tryAddPendingProduce(Stack pendingProduce) { + IInventory productInventory = getProductInventory(); + + ItemStack next = pendingProduce.peek(); + boolean added = InventoryUtil.tryAddStack(productInventory, next, true, true); + + if (added) { + pendingProduce.pop(); + } + + return added; + } + + public int getFertilizerValue() { + ItemStack fertilizerStack = getStackInSlot(SLOT_FERTILIZER); + if (fertilizerStack.isEmpty()) { + return 0; + } + + int fertilizerValue = ForestryAPI.farmRegistry.getFertilizeValue(fertilizerStack); + if (fertilizerValue > 0) { + return fertilizerValue * FERTILIZER_MODIFIER; + } + return 0; + } + + public boolean useFertilizer() { + ItemStack fertilizer = getStackInSlot(SLOT_FERTILIZER); + if (acceptsAsFertilizer(fertilizer)) { + decrStackSize(SLOT_FERTILIZER, 1); + return true; + } + return false; + } +} diff --git a/src/main/java/forestry/cultivation/inventory/package-info.java b/src/main/java/forestry/cultivation/inventory/package-info.java new file mode 100644 index 000000000..3c2a1f622 --- /dev/null +++ b/src/main/java/forestry/cultivation/inventory/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.cultivation.inventory; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/cultivation/items/ItemBlockPlanter.java b/src/main/java/forestry/cultivation/items/ItemBlockPlanter.java new file mode 100644 index 000000000..cc8c396d2 --- /dev/null +++ b/src/main/java/forestry/cultivation/items/ItemBlockPlanter.java @@ -0,0 +1,19 @@ +package forestry.cultivation.items; + +import net.minecraft.item.ItemStack; + +import forestry.core.items.ItemBlockForestry; +import forestry.core.utils.Translator; +import forestry.cultivation.blocks.BlockPlanter; + +public class ItemBlockPlanter extends ItemBlockForestry { + + public ItemBlockPlanter(BlockPlanter block) { + super(block); + } + + @Override + public String getItemStackDisplayName(ItemStack stack) { + return Translator.translateToLocalFormatted("tile.for.planter." + (BlockPlanter.isManual(stack) ? "manual" : "managed"), super.getItemStackDisplayName(stack)); + } +} diff --git a/src/main/java/forestry/cultivation/items/package-info.java b/src/main/java/forestry/cultivation/items/package-info.java new file mode 100644 index 000000000..05d9468d4 --- /dev/null +++ b/src/main/java/forestry/cultivation/items/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.cultivation.items; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/cultivation/package-info.java b/src/main/java/forestry/cultivation/package-info.java new file mode 100644 index 000000000..ece106cbb --- /dev/null +++ b/src/main/java/forestry/cultivation/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.cultivation; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/cultivation/tiles/TileArboretum.java b/src/main/java/forestry/cultivation/tiles/TileArboretum.java new file mode 100644 index 000000000..549e53340 --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TileArboretum.java @@ -0,0 +1,42 @@ +package forestry.cultivation.tiles; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +public class TileArboretum extends TilePlanter { + public TileArboretum() { + super("farmArboreal"); + } + + @Override + public NonNullList createGermlingStacks() { + return createList( + new ItemStack(Blocks.SAPLING), + new ItemStack(Blocks.SAPLING, 1, 2), + new ItemStack(Blocks.SAPLING, 1, 2), + new ItemStack(Blocks.SAPLING) + ); + } + + @Override + public NonNullList createResourceStacks() { + return createList( + new ItemStack(Blocks.DIRT), + new ItemStack(Blocks.DIRT), + new ItemStack(Blocks.DIRT), + new ItemStack(Blocks.DIRT) + ); + } + + @Override + public NonNullList createProductionStacks() { + return createList( + new ItemStack(Blocks.LOG), + new ItemStack(Items.APPLE), + new ItemStack(Items.APPLE), + new ItemStack(Blocks.LOG) + ); + } +} diff --git a/src/main/java/forestry/cultivation/tiles/TileBog.java b/src/main/java/forestry/cultivation/tiles/TileBog.java new file mode 100644 index 000000000..12a654363 --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TileBog.java @@ -0,0 +1,37 @@ +package forestry.cultivation.tiles; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +import forestry.core.ModuleCore; + +public class TileBog extends TilePlanter { + public TileBog() { + super("farmPeat"); + } + + @Override + public NonNullList createGermlingStacks() { + return NonNullList.create(); + } + + @Override + public NonNullList createResourceStacks() { + return createList( + new ItemStack(ModuleCore.getBlocks().bogEarth), + new ItemStack(ModuleCore.getBlocks().bogEarth), + new ItemStack(ModuleCore.getBlocks().bogEarth), + new ItemStack(ModuleCore.getBlocks().bogEarth) + ); + } + + @Override + public NonNullList createProductionStacks() { + return createList( + new ItemStack(ModuleCore.getItems().peat), + new ItemStack(ModuleCore.getItems().peat), + new ItemStack(ModuleCore.getItems().peat), + new ItemStack(ModuleCore.getItems().peat) + ); + } +} diff --git a/src/main/java/forestry/cultivation/tiles/TileFarmCrops.java b/src/main/java/forestry/cultivation/tiles/TileFarmCrops.java new file mode 100644 index 000000000..6ef256889 --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TileFarmCrops.java @@ -0,0 +1,42 @@ +package forestry.cultivation.tiles; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +public class TileFarmCrops extends TilePlanter { + public TileFarmCrops() { + super("farmCrops"); + } + + @Override + public NonNullList createGermlingStacks() { + return createList( + new ItemStack(Items.WHEAT_SEEDS), + new ItemStack(Items.POTATO), + new ItemStack(Items.CARROT), + new ItemStack(Items.BEETROOT_SEEDS) + ); + } + + @Override + public NonNullList createResourceStacks() { + return createList( + new ItemStack(Blocks.DIRT), + new ItemStack(Blocks.DIRT), + new ItemStack(Blocks.DIRT), + new ItemStack(Blocks.DIRT) + ); + } + + @Override + public NonNullList createProductionStacks() { + return createList( + new ItemStack(Items.WHEAT), + new ItemStack(Items.POTATO), + new ItemStack(Items.CARROT), + new ItemStack(Items.BEETROOT) + ); + } +} diff --git a/src/main/java/forestry/cultivation/tiles/TileFarmEnder.java b/src/main/java/forestry/cultivation/tiles/TileFarmEnder.java new file mode 100644 index 000000000..1d6916586 --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TileFarmEnder.java @@ -0,0 +1,42 @@ +package forestry.cultivation.tiles; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +public class TileFarmEnder extends TilePlanter { + public TileFarmEnder() { + super("farmEnder"); + } + + @Override + public NonNullList createGermlingStacks() { + return createList( + new ItemStack(Blocks.CHORUS_FLOWER), + new ItemStack(Blocks.CHORUS_FLOWER), + new ItemStack(Blocks.CHORUS_FLOWER), + new ItemStack(Blocks.CHORUS_FLOWER) + ); + } + + @Override + public NonNullList createResourceStacks() { + return createList( + new ItemStack(Blocks.END_STONE), + new ItemStack(Blocks.END_STONE), + new ItemStack(Blocks.END_STONE), + new ItemStack(Blocks.END_STONE) + ); + } + + @Override + public NonNullList createProductionStacks() { + return createList( + new ItemStack(Blocks.CHORUS_FLOWER), + new ItemStack(Items.CHORUS_FRUIT), + new ItemStack(Items.CHORUS_FRUIT), + new ItemStack(Blocks.CHORUS_FLOWER) + ); + } +} diff --git a/src/main/java/forestry/cultivation/tiles/TileFarmGourd.java b/src/main/java/forestry/cultivation/tiles/TileFarmGourd.java new file mode 100644 index 000000000..e99abd04c --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TileFarmGourd.java @@ -0,0 +1,31 @@ +package forestry.cultivation.tiles; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +public class TileFarmGourd extends TilePlanter { + public TileFarmGourd() { + super("farmGourd"); + } + + @Override + public NonNullList createGermlingStacks() { + return NonNullList.create(); + } + + @Override + public NonNullList createResourceStacks() { + return NonNullList.create(); + } + + @Override + public NonNullList createProductionStacks() { + return createList( + new ItemStack(Blocks.MELON_BLOCK), + new ItemStack(Blocks.PUMPKIN), + new ItemStack(Blocks.PUMPKIN), + new ItemStack(Blocks.MELON_BLOCK) + ); + } +} diff --git a/src/main/java/forestry/cultivation/tiles/TileFarmMushroom.java b/src/main/java/forestry/cultivation/tiles/TileFarmMushroom.java new file mode 100644 index 000000000..5ae5f36f7 --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TileFarmMushroom.java @@ -0,0 +1,41 @@ +package forestry.cultivation.tiles; + +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +public class TileFarmMushroom extends TilePlanter { + public TileFarmMushroom() { + super("farmShroom"); + } + + @Override + public NonNullList createGermlingStacks() { + return createList( + new ItemStack(Blocks.RED_MUSHROOM), + new ItemStack(Blocks.BROWN_MUSHROOM), + new ItemStack(Blocks.BROWN_MUSHROOM), + new ItemStack(Blocks.RED_MUSHROOM) + ); + } + + @Override + public NonNullList createResourceStacks() { + return createList( + new ItemStack(Blocks.MYCELIUM), + new ItemStack(Blocks.DIRT, 1, 2), + new ItemStack(Blocks.DIRT, 1, 2), + new ItemStack(Blocks.MYCELIUM) + ); + } + + @Override + public NonNullList createProductionStacks() { + return createList( + new ItemStack(Blocks.RED_MUSHROOM), + new ItemStack(Blocks.BROWN_MUSHROOM), + new ItemStack(Blocks.BROWN_MUSHROOM), + new ItemStack(Blocks.RED_MUSHROOM) + ); + } +} diff --git a/src/main/java/forestry/cultivation/tiles/TileFarmNether.java b/src/main/java/forestry/cultivation/tiles/TileFarmNether.java new file mode 100644 index 000000000..be8c5f29c --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TileFarmNether.java @@ -0,0 +1,42 @@ +package forestry.cultivation.tiles; + +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +public class TileFarmNether extends TilePlanter { + public TileFarmNether() { + super("farmInfernal"); + } + + @Override + public NonNullList createGermlingStacks() { + return createList( + new ItemStack(Items.NETHER_WART), + new ItemStack(Items.NETHER_WART), + new ItemStack(Items.NETHER_WART), + new ItemStack(Items.NETHER_WART) + ); + } + + @Override + public NonNullList createResourceStacks() { + return createList( + new ItemStack(Blocks.SOUL_SAND), + new ItemStack(Blocks.SOUL_SAND), + new ItemStack(Blocks.SOUL_SAND), + new ItemStack(Blocks.SOUL_SAND) + ); + } + + @Override + public NonNullList createProductionStacks() { + return createList( + new ItemStack(Items.NETHER_WART), + new ItemStack(Items.NETHER_WART), + new ItemStack(Items.NETHER_WART), + new ItemStack(Items.NETHER_WART) + ); + } +} diff --git a/src/main/java/forestry/cultivation/tiles/TilePlantation.java b/src/main/java/forestry/cultivation/tiles/TilePlantation.java new file mode 100644 index 000000000..23fb31822 --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TilePlantation.java @@ -0,0 +1,26 @@ +package forestry.cultivation.tiles; + +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; + +public class TilePlantation extends TilePlanter { + + public TilePlantation() { + super("farmRubber"); + } + + @Override + public NonNullList createGermlingStacks() { + return NonNullList.create(); + } + + @Override + public NonNullList createResourceStacks() { + return NonNullList.create(); + } + + @Override + public NonNullList createProductionStacks() { + return NonNullList.create(); + } +} diff --git a/src/main/java/forestry/cultivation/tiles/TilePlanter.java b/src/main/java/forestry/cultivation/tiles/TilePlanter.java new file mode 100644 index 000000000..51131edcc --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/TilePlanter.java @@ -0,0 +1,532 @@ +package forestry.cultivation.tiles; + +import javax.annotation.Nullable; +import java.io.IOException; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.EnumMap; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Stack; + +import net.minecraft.client.gui.inventory.GuiContainer; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.NonNullList; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3i; +import net.minecraft.world.World; + +import net.minecraftforge.common.capabilities.Capability; +import net.minecraftforge.fluids.FluidRegistry; +import net.minecraftforge.fluids.FluidStack; +import net.minecraftforge.fluids.capability.CapabilityFluidHandler; + +import forestry.api.core.EnumHumidity; +import forestry.api.core.EnumTemperature; +import forestry.api.core.IErrorLogic; +import forestry.api.farming.FarmDirection; +import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmInventory; +import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmable; +import forestry.core.config.Config; +import forestry.core.config.Constants; +import forestry.core.errors.EnumErrorCode; +import forestry.core.fluids.FilteredTank; +import forestry.core.fluids.ITankManager; +import forestry.core.fluids.StandardTank; +import forestry.core.fluids.TankManager; +import forestry.core.network.IStreamableGui; +import forestry.core.network.PacketBufferForestry; +import forestry.core.owner.IOwnedTile; +import forestry.core.owner.IOwnerHandler; +import forestry.core.owner.OwnerHandler; +import forestry.core.tiles.IClimatised; +import forestry.core.tiles.ILiquidTankTile; +import forestry.core.tiles.TilePowered; +import forestry.core.utils.ClimateUtil; +import forestry.core.utils.PlayerUtil; +import forestry.core.utils.VectUtil; +import forestry.cultivation.gui.ContainerPlanter; +import forestry.cultivation.gui.GuiPlanter; +import forestry.cultivation.inventory.InventoryPlanter; +import forestry.farming.FarmHelper; +import forestry.farming.FarmHelper.FarmWorkStatus; +import forestry.farming.FarmHelper.Stage; +import forestry.farming.FarmRegistry; +import forestry.farming.FarmTarget; +import forestry.farming.gui.IFarmLedgerDelegate; +import forestry.farming.multiblock.FarmFertilizerManager; +import forestry.farming.multiblock.FarmHydrationManager; + +public abstract class TilePlanter extends TilePowered implements IFarmHousing, IClimatised, ILiquidTankTile, IOwnedTile, IStreamableGui { + + private final Map> targets = new EnumMap<>(FarmDirection.class); + private final Stack pendingProduce = new Stack<>(); + private final List pendingCrops = new LinkedList<>(); + private final String identifier; + + private final FarmHydrationManager hydrationManager; + private final FarmFertilizerManager fertilizerManager; + private final InventoryPlanter inventory; + private final TankManager tankManager; + private final StandardTank resourceTank; + private final OwnerHandler ownerHandler = new OwnerHandler(); + + private int platformHeight = -1; + private Stage stage = Stage.CULTIVATE; + private boolean isManual; + private IFarmLogic logic; + @Nullable + private Vec3i offset; + @Nullable + private Vec3i area; + + public void setManual(boolean manual) { + isManual = manual; + logic = FarmRegistry.getInstance().getProperties(identifier).getLogic(manual); + } + + protected TilePlanter(String identifier) { + super(150, 1500); + this.identifier = identifier; + setManual(false); + setInternalInventory(inventory = new InventoryPlanter(this)); + this.hydrationManager = new FarmHydrationManager(this); + this.fertilizerManager = new FarmFertilizerManager(); + + this.resourceTank = new FilteredTank(Constants.PROCESSOR_TANK_CAPACITY).setFilters(FluidRegistry.WATER); + + this.tankManager = new TankManager(this, resourceTank); + setEnergyPerWorkCycle(10); + setTicksPerWorkCycle(2); + } + + @Override + public void setPos(BlockPos posIn) { + super.setPos(posIn); + this.platformHeight = posIn.getY() - 2; + } + + @Override + public boolean hasWork() { + return true; + } + + @Override + protected void updateServerSide() { + super.updateServerSide(); + hydrationManager.updateServer(world, getCoords()); + + if (updateOnInterval(20)) { + inventory.drainCan(tankManager); + } + } + + @Override + protected boolean workCycle() { + if (targets.isEmpty() || updateOnInterval(10)) { + setUpFarmlandTargets(); + } + IErrorLogic errorLogic = getErrorLogic(); + + boolean hasFertilizer = fertilizerManager.maintainFertilizer(inventory); + if (errorLogic.setCondition(!hasFertilizer, EnumErrorCode.NO_FERTILIZER)) { + return false; + } + + if (!pendingProduce.isEmpty()) { + boolean added = inventory.tryAddPendingProduce(pendingProduce); + errorLogic.setCondition(!added, EnumErrorCode.NO_SPACE_INVENTORY); + return added; + } + + // Cull queued crops. + if (!pendingCrops.isEmpty()) { + ICrop first = pendingCrops.get(0); + if (cullCrop(first)) { + pendingCrops.remove(0); + return true; + } else { + return false; + } + } + + // Cultivation and collection + FarmWorkStatus farmWorkStatus = new FarmWorkStatus(); + + List farmDirections = Arrays.asList(FarmDirection.values()); + Collections.shuffle(farmDirections, world.rand); + for (FarmDirection farmSide : farmDirections) { + IFarmLogic logic = getFarmLogic(farmSide); + + // Always try to collect windfall. + if (collectWindfall()) { + farmWorkStatus.didWork = true; + } + + List farmTargets = targets.get(farmSide); + + if (stage == Stage.HARVEST) { + Collection harvested = FarmHelper.harvestTargets(world, farmTargets, logic, Collections.emptySet()); + farmWorkStatus.didWork = !harvested.isEmpty(); + if (!harvested.isEmpty()) { + pendingCrops.addAll(harvested); + pendingCrops.sort(FarmHelper.TopDownICropComparator.INSTANCE); + } + } else if (stage == Stage.CULTIVATE) { + farmWorkStatus = cultivateTargets(farmWorkStatus, farmTargets, farmSide); + } + + if (farmWorkStatus.didWork) { + break; + } + } + + if (stage == Stage.CULTIVATE) { + errorLogic.setCondition(!farmWorkStatus.hasFarmland, EnumErrorCode.NO_FARMLAND); + errorLogic.setCondition(!farmWorkStatus.hasFertilizer, EnumErrorCode.NO_FERTILIZER); + errorLogic.setCondition(!farmWorkStatus.hasLiquid, EnumErrorCode.NO_LIQUID_FARM); + } + + // alternate between cultivation and harvest. + stage = stage.next(); + + return false; + } + + @Override + public NBTTagCompound writeToNBT(NBTTagCompound data) { + data = super.writeToNBT(data); + hydrationManager.writeToNBT(data); + tankManager.writeToNBT(data); + fertilizerManager.writeToNBT(data); + ownerHandler.writeToNBT(data); + data.setBoolean("isManual", isManual); + return data; + } + + @Override + public void readFromNBT(NBTTagCompound data) { + super.readFromNBT(data); + hydrationManager.readFromNBT(data); + tankManager.readFromNBT(data); + fertilizerManager.readFromNBT(data); + ownerHandler.readFromNBT(data); + setManual(data.getBoolean("isManual")); + } + + @Override + public void writeGuiData(PacketBufferForestry data) { + tankManager.writeData(data); + hydrationManager.writeData(data); + fertilizerManager.writeData(data); + } + + @Override + public void readGuiData(PacketBufferForestry data) throws IOException { + tankManager.readData(data); + hydrationManager.readData(data); + fertilizerManager.readData(data); + } + + private void setUpFarmlandTargets() { + BlockPos targetStart = getCoords(); + BlockPos minPos = pos; + BlockPos maxPos = pos; + int size = 1; + int extend = Config.planterExtend; + + if(Config.ringFarms){ + int ringSize = Config.ringSize; + minPos = pos.add(-ringSize, 0 , -ringSize); + maxPos = pos.add(ringSize, 0, ringSize); + size = 1 + ringSize * 2; + extend--; + } + + FarmHelper.createTargets(world, this, targets, targetStart, extend, size, size, minPos, maxPos); + FarmHelper.setExtents(world, this, targets); + } + + private boolean cullCrop(ICrop crop) { + final int fertilizerConsumption = Math.round(logic.getFertilizerConsumption() * Config.fertilizerModifier * 2); + + IErrorLogic errorLogic = getErrorLogic(); + + // Check fertilizer + Boolean hasFertilizer = fertilizerManager.hasFertilizer(inventory, fertilizerConsumption); + if (errorLogic.setCondition(!hasFertilizer, EnumErrorCode.NO_FERTILIZER)) { + return false; + } + + // Check water + float hydrationModifier = hydrationManager.getHydrationModifier(); + int waterConsumption = logic.getWaterConsumption(hydrationModifier); + FluidStack requiredLiquid = new FluidStack(FluidRegistry.WATER, waterConsumption); + boolean hasLiquid = requiredLiquid.amount == 0 || hasLiquid(requiredLiquid); + + if (errorLogic.setCondition(!hasLiquid, EnumErrorCode.NO_LIQUID_FARM)) { + return false; + } + + NonNullList harvested = crop.harvest(); + if (harvested != null) { + // Remove fertilizer and water + fertilizerManager.removeFertilizer(inventory, fertilizerConsumption); + removeLiquid(requiredLiquid); + + inventory.stowHarvest(harvested, pendingProduce); + } + return true; + } + + private boolean collectWindfall() { + NonNullList collected = logic.collect(world, this); + if (collected.isEmpty()) { + return false; + } + + for (ItemStack produce : collected) { + inventory.addProduce(produce); + pendingProduce.push(produce); + } + + return true; + } + + private FarmWorkStatus cultivateTargets(FarmWorkStatus farmWorkStatus, List farmTargets, FarmDirection farmSide) { + boolean hasFarmland = false; + for (FarmTarget target : farmTargets) { + if (target.getExtent() > 0) { + hasFarmland = true; + farmWorkStatus.hasFarmland = true; + break; + } + } + + if (hasFarmland && !FarmHelper.isCycleCanceledByListeners(logic, farmSide, Collections.emptySet())) { + final float hydrationModifier = hydrationManager.getHydrationModifier(); + final int fertilizerConsumption = Math.round(logic.getFertilizerConsumption() * Config.fertilizerModifier * 2); + final int liquidConsumption = logic.getWaterConsumption(hydrationModifier); + final FluidStack liquid = new FluidStack(FluidRegistry.WATER, liquidConsumption); + + for (FarmTarget target : farmTargets) { + // Check fertilizer and water + if (!fertilizerManager.hasFertilizer(inventory, fertilizerConsumption)) { + farmWorkStatus.hasFertilizer = false; + continue; + } + + if (liquid.amount > 0 && !hasLiquid(liquid)) { + farmWorkStatus.hasLiquid = false; + continue; + } + + if (FarmHelper.cultivateTarget(world, this, target, logic, Collections.emptySet())) { + // Remove fertilizer and water + fertilizerManager.removeFertilizer(inventory, fertilizerConsumption); + removeLiquid(liquid); + + farmWorkStatus.didWork = true; + } + } + } + + return farmWorkStatus; + } + + @Override + public BlockPos getCoords() { + return pos; + } + + @Override + public Vec3i getArea() { + if (area == null) { + int basisArea = 5; + if(Config.ringFarms){ + basisArea = basisArea + 1 + Config.ringSize * 2; + } + area = new Vec3i(basisArea + Config.planterExtend, 13, basisArea + Config.planterExtend); + } + return area; + } + + @Override + public Vec3i getOffset() { + if (offset == null) { + Vec3i area = getArea(); + offset = new Vec3i(-area.getX() / 2, -2, -area.getZ() / 2); + } + return offset; + } + + @Override + public boolean doWork() { + return false; + } + + @Override + public boolean hasLiquid(FluidStack liquid) { + FluidStack drained = resourceTank.drainInternal(liquid, false); + return liquid.isFluidStackIdentical(drained); + } + + @Override + public void removeLiquid(FluidStack liquid) { + resourceTank.drain(liquid.amount, true); + } + + @Override + public boolean plantGermling(IFarmable germling, World world, BlockPos pos) { + EntityPlayer player = PlayerUtil.getFakePlayer(world, getOwnerHandler().getOwner()); + return player != null && inventory.plantGermling(germling, player, pos); + } + + @Override + public IOwnerHandler getOwnerHandler() { + return ownerHandler; + } + + @Override + public boolean plantGermling(IFarmable farmable, World world, BlockPos pos, FarmDirection direction) { + EntityPlayer player = PlayerUtil.getFakePlayer(world, getOwnerHandler().getOwner()); + return player != null && inventory.plantGermling(farmable, player, pos, direction); + } + + @Override + public boolean isValidPlatform(World world, BlockPos pos) { + return pos.getY() == platformHeight; + } + + @Override + public boolean isSquare() { + return true; + } + + @Override + public boolean canPlantSoil(boolean manual) { + return !isManual; + } + + @Override + public IFarmInventory getFarmInventory() { + return inventory; + } + + @Override + public void setFarmLogic(FarmDirection direction, IFarmLogic logic) { + } + + @Override + public void resetFarmLogic(FarmDirection direction) { + } + + @Override + public IFarmLogic getFarmLogic(FarmDirection direction) { + return getFarmLogic(); + } + + public IFarmLogic getFarmLogic() { + return logic; + } + + @Override + public int getStoredFertilizerScaled(int scale) { + return fertilizerManager.getStoredFertilizerScaled(inventory, scale); + } + + @Override + public void invalidate() { + super.invalidate(); + targets.clear(); + } + + @Override + public NBTTagCompound getUpdateTag() { + NBTTagCompound data = super.getUpdateTag(); + hydrationManager.writeToNBT(data); + tankManager.writeToNBT(data); + fertilizerManager.writeToNBT(data); + return data; + } + + protected final BlockPos translateWithOffset(BlockPos pos, FarmDirection farmDirection, int step) { + return VectUtil.scale(farmDirection.getFacing().getDirectionVec(), step).add(pos); + } + + @Override + public GuiContainer getGui(EntityPlayer player, int data) { + return new GuiPlanter(this, player.inventory); + } + + @Override + public Container getContainer(EntityPlayer player, int data) { + return new ContainerPlanter(this, player.inventory); + } + + public IFarmLedgerDelegate getFarmLedgerDelegate() { + return hydrationManager; + } + + @Override + public EnumTemperature getTemperature() { + return EnumTemperature.getFromValue(getExactTemperature()); + } + + @Override + public EnumHumidity getHumidity() { + return EnumHumidity.getFromValue(getExactHumidity()); + } + + @Override + public float getExactTemperature() { + BlockPos coords = getCoordinates(); + return ClimateUtil.getTemperature(getWorldObj(), coords); + } + + @Override + public float getExactHumidity() { + BlockPos coords = getCoordinates(); + return ClimateUtil.getHumidity(getWorldObj(), coords); + } + + @Override + public ITankManager getTankManager() { + return tankManager; + } + + + @Override + public boolean hasCapability(Capability capability, @Nullable EnumFacing facing) { + return capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY || super.hasCapability(capability, facing); + } + + @Override + @Nullable + public T getCapability(Capability capability, @Nullable EnumFacing facing) { + if (capability == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) { + return CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY.cast(getTankManager()); + } + return super.getCapability(capability, facing); + } + + protected NonNullList createList(ItemStack... stacks){ + return NonNullList.from(ItemStack.EMPTY, stacks); + } + + public abstract NonNullList createGermlingStacks(); + + public abstract NonNullList createResourceStacks(); + + public abstract NonNullList createProductionStacks(); + +} diff --git a/src/main/java/forestry/cultivation/tiles/package-info.java b/src/main/java/forestry/cultivation/tiles/package-info.java new file mode 100644 index 000000000..451564e86 --- /dev/null +++ b/src/main/java/forestry/cultivation/tiles/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.cultivation.tiles; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/factory/ModuleFactory.java b/src/main/java/forestry/factory/ModuleFactory.java index 964e40f12..a5c2e25b6 100644 --- a/src/main/java/forestry/factory/ModuleFactory.java +++ b/src/main/java/forestry/factory/ModuleFactory.java @@ -328,7 +328,13 @@ public class ModuleFactory extends BlankForestryModule { "XXX", '#', new ItemStack(Items.REPEATER, 1, 0), 'X', new ItemStack(Blocks.REDSTONE_ORE, 1, 0)}); - + RecipeManagers.fabricatorManager.addRecipe(ItemStack.EMPTY, Fluids.GLASS.getFluid(500), coreItems.flexibleCasing.getItemStack(), new Object[]{ + "#E#", + "B B", + "#E#", + '#', OreDictUtil.INGOT_BRONZE, + 'B', OreDictUtil.SLIMEBALL, + 'E', "gemEmerald"}); String[] dyes = {"dyeBlack", "dyeRed", "dyeGreen", "dyeBrown", "dyeBlue", "dyePurple", "dyeCyan", "dyeLightGray", "dyeGray", "dyePink", "dyeLime", "dyeYellow", "dyeLightBlue", "dyeMagenta", "dyeOrange", "dyeWhite"}; diff --git a/src/main/java/forestry/farming/DummyFarmRegistry.java b/src/main/java/forestry/farming/DummyFarmRegistry.java index 9dec62bc0..faf1f6532 100644 --- a/src/main/java/forestry/farming/DummyFarmRegistry.java +++ b/src/main/java/forestry/farming/DummyFarmRegistry.java @@ -1,42 +1,75 @@ package forestry.farming; +import javax.annotation.Nullable; import java.util.Collection; import java.util.Collections; +import java.util.function.BiFunction; import net.minecraft.item.ItemStack; import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmProperties; import forestry.api.farming.IFarmRegistry; import forestry.api.farming.IFarmable; import forestry.api.farming.ISimpleFarmLogic; +import forestry.farming.logic.FakeFarmProperties; public class DummyFarmRegistry implements IFarmRegistry { @Override - public void registerFarmLogic(String identifier, IFarmLogic logic) { - + public void registerLogic(String identifier, IFarmLogic logic) { + //Dummy-Implementation } @Override public void registerFarmables(String identifier, IFarmable... farmable) { + //Dummy-Implementation } @Override public Collection getFarmables(String identifier) { + //Dummy-Implementation return Collections.emptyList(); } @Override - public IFarmLogic createLogic(ISimpleFarmLogic simpleFarmLogic) { + public IFarmProperties registerLogic(String identifier, IFarmProperties farmInstance) { return null; } + @Override + public IFarmProperties registerLogic(String identifier, BiFunction logicFactory, String... farmablesIdentifiers) { + //Dummy-Implementation + return null; + } + + @Nullable + @Override + public IFarmLogic createCropLogic(IFarmProperties instance, boolean isManual, ISimpleFarmLogic simpleFarmLogic) { + //Dummy-Implementation + return null; + } + + @Override + public IFarmProperties createFakeInstance(IFarmLogic logic) { + return new FakeFarmProperties(logic); + } + @Override public void registerFertilizer(ItemStack itemStack, int value) { + //Dummy-Implementation } @Override public int getFertilizeValue(ItemStack itemStack) { + //Dummy-Implementation return 0; } + + @Nullable + @Override + public IFarmProperties getProperties(String identifier) { + //Dummy-Implementation + return null; + } } diff --git a/src/main/java/forestry/farming/FarmHelper.java b/src/main/java/forestry/farming/FarmHelper.java index c951cff3e..0f69dd92e 100755 --- a/src/main/java/forestry/farming/FarmHelper.java +++ b/src/main/java/forestry/farming/FarmHelper.java @@ -12,15 +12,62 @@ package forestry.farming; import com.google.common.collect.ImmutableSet; +import javax.annotation.Nullable; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.List; +import java.util.Map; + import net.minecraft.block.Block; import net.minecraft.init.Blocks; import net.minecraft.util.EnumFacing; import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; import forestry.api.farming.FarmDirection; +import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmListener; +import forestry.api.farming.IFarmLogic; +import forestry.core.utils.TopDownBlockPosComparator; public class FarmHelper { + public enum Stage { + CULTIVATE, HARVEST; + + public Stage next() { + if (this == CULTIVATE) { + return HARVEST; + } else { + return CULTIVATE; + } + } + } + + public static class FarmWorkStatus { + public boolean didWork = false; + public boolean hasFarmland = false; + public boolean hasFertilizer = true; + public boolean hasLiquid = true; + } + + private static FarmDirection getLayoutDirection(FarmDirection farmSide) { + switch (farmSide) { + case NORTH: + return FarmDirection.WEST; + case WEST: + return FarmDirection.SOUTH; + case SOUTH: + return FarmDirection.EAST; + case EAST: + return FarmDirection.NORTH; + } + return null; + } + public static final ImmutableSet bricks = ImmutableSet.of( Blocks.BRICK_BLOCK, Blocks.STONEBRICK, @@ -38,7 +85,7 @@ public class FarmHelper { /** * @return the corner of the farm for the given side and layout. Returns null if the corner is not in a loaded chunk. */ - public static BlockPos getFarmMultiblockCorner(BlockPos start, FarmDirection farmSide, FarmDirection layoutDirection, BlockPos minFarmCoord, BlockPos maxFarmCoord) { + private static BlockPos getFarmMultiblockCorner(BlockPos start, FarmDirection farmSide, FarmDirection layoutDirection, BlockPos minFarmCoord, BlockPos maxFarmCoord) { BlockPos edge = getFarmMultiblockEdge(start, farmSide, maxFarmCoord, minFarmCoord); return getFarmMultiblockEdge(edge, getOpposite(layoutDirection), maxFarmCoord, minFarmCoord); } @@ -60,4 +107,137 @@ public class FarmHelper { throw new IllegalArgumentException("Invalid farm direction: " + direction); } } + + public static void createTargets(World world, IFarmHousing farmHousing, Map> targets, BlockPos targetStart, final int allowedExtent, final int farmSizeNorthSouth, final int farmSizeEastWest, BlockPos minFarmCoord, BlockPos maxFarmCoord) { + for (FarmDirection farmSide : FarmDirection.values()) { + + final int farmWidth; + if (farmSide == FarmDirection.NORTH || farmSide == FarmDirection.SOUTH) { + farmWidth = farmSizeEastWest; + } else { + farmWidth = farmSizeNorthSouth; + } + + // targets extend sideways in a pinwheel pattern around the farm, so they need to go a little extra distance + final int targetMaxLimit = allowedExtent + farmWidth; + + FarmDirection layoutDirection = getLayoutDirection(farmSide); + + List farmSideTargets = new ArrayList<>(); + targets.put(farmSide, farmSideTargets); + + BlockPos targetLocation = FarmHelper.getFarmMultiblockCorner(targetStart, farmSide, layoutDirection, minFarmCoord, maxFarmCoord); + BlockPos firstLocation = targetLocation.offset(farmSide.getFacing()); + BlockPos firstGroundPosition = getGroundPosition(world, farmHousing, firstLocation); + if (firstGroundPosition != null) { + int groundHeight = firstGroundPosition.getY(); + + for (int i = 0; i < allowedExtent; i++) { + targetLocation = targetLocation.offset(farmSide.getFacing()); + BlockPos groundLocation = new BlockPos(targetLocation.getX(), groundHeight, targetLocation.getZ()); + + if (!world.isBlockLoaded(groundLocation)) { + break; + } + + if (!farmHousing.isValidPlatform(world, groundLocation)) { + break; + } + + int targetLimit = targetMaxLimit; + if (!farmHousing.isSquare()) { + targetLimit = targetMaxLimit - i - 1; + } + + FarmTarget target = new FarmTarget(targetLocation, layoutDirection, targetLimit); + farmSideTargets.add(target); + } + } + } + } + + @Nullable + private static BlockPos getGroundPosition(World world, IFarmHousing farmHousing, BlockPos targetPosition) { + if (!world.isBlockLoaded(targetPosition)) { + return null; + } + + for (int yOffset = 2; yOffset > -4; yOffset--) { + BlockPos position = targetPosition.add(0, yOffset, 0); + if (farmHousing.isValidPlatform(world, position)) { + return position; + } + } + + return null; + } + + public static boolean isCycleCanceledByListeners(IFarmLogic logic, FarmDirection direction, Iterable farmListeners) { + for (IFarmListener listener : farmListeners) { + if (listener.cancelTask(logic, direction)) { + return true; + } + } + return false; + } + + public static void setExtents(World world, IFarmHousing farmHousing, Map> targets) { + for (List targetsList : targets.values()) { + if (!targetsList.isEmpty()) { + BlockPos groundPosition = getGroundPosition(world, farmHousing, targetsList.get(0).getStart()); + + for (FarmTarget target : targetsList) { + target.setExtentAndYOffset(world, groundPosition, farmHousing); + } + } + } + } + + public static boolean cultivateTarget(World world, IFarmHousing farmHousing, FarmTarget target, IFarmLogic logic, Iterable farmListeners) { + BlockPos targetPosition = target.getStart().add(0, target.getYOffset(), 0); + if (logic.cultivate(world, farmHousing, targetPosition, target.getDirection(), target.getExtent())) { + for (IFarmListener listener : farmListeners) { + listener.hasCultivated(logic, targetPosition, target.getDirection(), target.getExtent()); + } + return true; + } + + return false; + } + + public static Collection harvestTargets(World world, List farmTargets, IFarmLogic logic, Iterable farmListeners) { + for (FarmTarget target : farmTargets) { + Collection harvested = harvestTarget(world, target, logic, farmListeners); + if (!harvested.isEmpty()) { + return harvested; + } + } + + return Collections.emptyList(); + } + + public static Collection harvestTarget(World world, FarmTarget target, IFarmLogic logic, Iterable farmListeners) { + BlockPos pos = target.getStart().add(0, target.getYOffset(), 0); + Collection harvested = logic.harvest(world, pos, target.getDirection(), target.getExtent()); + if (!harvested.isEmpty()) { + // Let event handlers know. + for (IFarmListener listener : farmListeners) { + listener.hasScheduledHarvest(harvested, logic, pos, target.getDirection(), target.getExtent()); + } + } + return harvested; + } + + public static class TopDownICropComparator implements Comparator { + public static final TopDownICropComparator INSTANCE = new TopDownICropComparator(); + + private TopDownICropComparator() { + + } + + @Override + public int compare(ICrop o1, ICrop o2) { + return TopDownBlockPosComparator.INSTANCE.compare(o1.getPosition(), o2.getPosition()); + } + } } diff --git a/src/main/java/forestry/farming/FarmRegistry.java b/src/main/java/forestry/farming/FarmRegistry.java index 36577befc..1ccd1245c 100644 --- a/src/main/java/forestry/farming/FarmRegistry.java +++ b/src/main/java/forestry/farming/FarmRegistry.java @@ -1,8 +1,10 @@ package forestry.farming; import com.google.common.collect.HashMultimap; +import com.google.common.collect.ImmutableMap; import com.google.common.collect.Multimap; +import javax.annotation.Nullable; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -14,6 +16,7 @@ import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import java.util.function.BiFunction; import net.minecraft.item.ItemStack; @@ -21,6 +24,7 @@ import net.minecraftforge.common.config.Property; import net.minecraftforge.oredict.OreDictionary; import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmProperties; import forestry.api.farming.IFarmRegistry; import forestry.api.farming.IFarmable; import forestry.api.farming.ISimpleFarmLogic; @@ -28,25 +32,26 @@ import forestry.core.config.LocalizedConfiguration; import forestry.core.utils.ItemStackUtil; import forestry.core.utils.Log; import forestry.core.utils.Translator; +import forestry.farming.logic.FakeFarmProperties; import forestry.farming.logic.FarmLogicSimple; +import forestry.farming.logic.FarmProperties; public final class FarmRegistry implements IFarmRegistry { private static final FarmRegistry INSTANCE = new FarmRegistry(); + private final Multimap farmables = HashMultimap.create(); private final Map fertilizers = new LinkedHashMap<>(); - private final Map logics = new HashMap(); + private final Map farmInstances = new HashMap<>(); + private FertilizerConfig fertilizer = FertilizerConfig.DUMMY; public static FarmRegistry getInstance() { return INSTANCE; } - - public void registerFarmLogic(String identifier, IFarmLogic logic) { - logics.put(identifier, logic); - } - public IFarmLogic getFarmLogic(String identifier) { - return logics.get(identifier); + @Override + @Deprecated + public void registerLogic(String identifier, IFarmLogic logic) { } @Override @@ -60,13 +65,18 @@ public final class FarmRegistry implements IFarmRegistry { } @Override - public IFarmLogic createLogic(ISimpleFarmLogic simpleFarmLogic) { - return new FarmLogicSimple(simpleFarmLogic); + public IFarmLogic createCropLogic(IFarmProperties instance, boolean isManual, ISimpleFarmLogic simpleFarmLogic) { + return new FarmLogicSimple(instance, isManual, simpleFarmLogic); + } + + @Override + public IFarmProperties createFakeInstance(IFarmLogic logic) { + return new FakeFarmProperties(logic); } @Override public void registerFertilizer(ItemStack itemStack, int value) { - if(itemStack == null || itemStack.isEmpty()){ + if(itemStack.isEmpty()){ return; } fertilizers.put(itemStack, value); @@ -74,50 +84,113 @@ public final class FarmRegistry implements IFarmRegistry { @Override public int getFertilizeValue(ItemStack itemStack) { - for (Entry fertilizer : fertilizers.entrySet()) { - ItemStack fertilizerStack = fertilizer.getKey(); - if (itemStack.getItem() == fertilizerStack.getItem() - && (fertilizerStack.getItemDamage() == itemStack.getItemDamage() - || fertilizerStack.getItemDamage() == OreDictionary.WILDCARD_VALUE)) { - return fertilizer.getValue(); - } - } - return 0; + return fertilizer.getFertilizeValue(itemStack); } - - public void loadConfig(LocalizedConfiguration config) { - List defaultFertilizers = new ArrayList<>(getItemStrings()); + + @Override + public IFarmProperties registerLogic(String identifier, IFarmProperties farmInstance) { + farmInstances.put(identifier, farmInstance); + return farmInstance; + } + + @Override + public IFarmProperties registerLogic(String identifier, BiFunction logicFactory, String... farmablesIdentifiers) { + Set identifiers = new HashSet<>(Arrays.asList(farmablesIdentifiers)); + identifiers.add(identifier); + IFarmProperties instance = new FarmProperties(logicFactory, identifiers); + farmInstances.put(identifier, instance); + return instance; + } + + @Override + @Nullable + public IFarmProperties getProperties(String identifier) { + return farmInstances.get(identifier); + } + + void loadConfig(LocalizedConfiguration config) { + Map defaultEntries = getItemStrings(); + List defaultFertilizers = new ArrayList<>(defaultEntries.values()); Collections.sort(defaultFertilizers); String[] defaultSortedFertilizers = defaultFertilizers.toArray(new String[defaultFertilizers.size()]); - Property fertilizerConf = config.get("fertilizers", "items", defaultSortedFertilizers, Translator.translateToLocal("for.config.farm.fertilizers.items")); + Property property = config.get("fertilizers", "items", defaultSortedFertilizers, Translator.translateToLocal("for.config.farm.fertilizers.items")); - fertilizers.clear(); - String[] fertilizerList = fertilizerConf.getStringList(); - for (int i = 0; i < fertilizerList.length; i++) { - try { - String fertilizer = fertilizerList[i]; - String[] fertilizers = fertilizer.split(";"); - String itemName = fertilizers[0]; - if(itemName.equals("forestry:fertilizerCompound")){ - itemName = "forestry:fertilizer_compound"; - } - ItemStack fertilizerItem = ItemStackUtil.parseItemStackString(itemName, OreDictionary.WILDCARD_VALUE); - int fertilizerValue = Integer.parseInt(fertilizers[1]); - registerFertilizer(fertilizerItem, fertilizerValue); - } catch (Exception e) { - Log.error("Forestry failed to parse a fertilizer entry at the farm config, at the position " + i + ".", e); + ImmutableMap fertilizerMap = checkConfig(property, defaultEntries); + fertilizer = new FertilizerConfig(fertilizerMap); + } + + private ImmutableMap checkConfig(Property property, Map defaultEntries){ + String[] fertilizerList = property.getStringList(); + ImmutableMap.Builder fertilizerMap = new ImmutableMap.Builder<>(); + Map configEntries = parseConfig(fertilizerList, fertilizerMap); + + List newEntries = new ArrayList<>(Arrays.asList(fertilizerList)); + for(Entry defaultEntry : defaultEntries.entrySet()){ + if(!configEntries.containsKey(defaultEntry.getKey())){ + newEntries.add(defaultEntry.getValue()); } } + + if(newEntries.size() > fertilizerList.length){ + Collections.sort(newEntries); + property.set(newEntries.toArray(new String[newEntries.size()])); + return checkConfig(property, defaultEntries); + } + + return fertilizerMap.build(); + } + + private Map parseConfig(String[] fertilizerList, ImmutableMap.Builder fertilizerMap){ + Map configEntries = new HashMap<>(); + for(String entry : fertilizerList){ + String[] spited = entry.split(";"); + if(spited.length < 2){ + Log.error("Forestry failed to parse a entry of the fertilizer config."); + continue; + } + String itemName = spited[0]; + ItemStack fertilizerItem = ItemStackUtil.parseItemStackString(itemName, OreDictionary.WILDCARD_VALUE); + if(fertilizerItem == null || fertilizerItem.isEmpty()){ + Log.error("Forestry failed to parse a entry of the fertilizer config, because the item doesn't exists."); + continue; + } + String value = spited[1]; + int fertilizerValue = Integer.parseInt(value); + if(fertilizerValue > 0) { + fertilizerMap.put(fertilizerItem, fertilizerValue); + } + configEntries.put(itemName, value); + } + return configEntries; } - private Set getItemStrings() { - Set itemStrings = new HashSet<>(fertilizers.size()); + private Map getItemStrings() { + Map itemStrings = new HashMap<>(fertilizers.size()); for (Entry itemStack : fertilizers.entrySet()) { String itemString = ItemStackUtil.getStringForItemStack(itemStack.getKey()); - itemString += ";" + itemStack.getValue(); - itemStrings.add(itemString); + itemStrings.put(itemString, itemString + ";" + itemStack.getValue()); } return itemStrings; } + + private static class FertilizerConfig{ + private static final FertilizerConfig DUMMY = new FertilizerConfig(Collections.emptyMap()); + + private final Map fertilizers; + + private FertilizerConfig(Map fertilizers) { + this.fertilizers = fertilizers; + } + + private int getFertilizeValue(ItemStack itemStack) { + for (Entry fertilizer : fertilizers.entrySet()) { + ItemStack fertilizerStack = fertilizer.getKey(); + if (ItemStackUtil.isIdenticalItem(fertilizerStack, itemStack)) { + return fertilizer.getValue(); + } + } + return 0; + } + } } diff --git a/src/main/java/forestry/farming/FarmTarget.java b/src/main/java/forestry/farming/FarmTarget.java index 1b37e3e05..223a2b185 100755 --- a/src/main/java/forestry/farming/FarmTarget.java +++ b/src/main/java/forestry/farming/FarmTarget.java @@ -12,11 +12,11 @@ package forestry.farming; import javax.annotation.Nullable; -import net.minecraft.block.state.IBlockState; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; import forestry.api.farming.FarmDirection; +import forestry.api.farming.IFarmHousing; public class FarmTarget { @@ -49,7 +49,7 @@ public class FarmTarget { return direction; } - public void setExtentAndYOffset(World world, @Nullable BlockPos platformPosition) { + public void setExtentAndYOffset(World world, @Nullable BlockPos platformPosition, IFarmHousing housing) { if (platformPosition == null) { extent = 0; return; @@ -60,8 +60,7 @@ public class FarmTarget { if (!world.isBlockLoaded(position)) { break; } - IBlockState blockState = world.getBlockState(position); - if (!FarmHelper.bricks.contains(blockState.getBlock())) { + if (!housing.isValidPlatform(world, position)) { break; } position.move(getDirection().getFacing()); diff --git a/src/main/java/forestry/farming/ModuleFarming.java b/src/main/java/forestry/farming/ModuleFarming.java index a52f4e4d0..e913ed20f 100644 --- a/src/main/java/forestry/farming/ModuleFarming.java +++ b/src/main/java/forestry/farming/ModuleFarming.java @@ -19,6 +19,7 @@ import java.util.List; import net.minecraft.block.BlockBeetroot; import net.minecraft.block.BlockCrops; +import net.minecraft.block.BlockDirt; import net.minecraft.block.BlockNetherWart; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; @@ -42,9 +43,12 @@ import forestry.api.circuits.ChipsetManager; import forestry.api.circuits.CircuitSocketType; import forestry.api.circuits.ICircuitLayout; import forestry.api.core.ForestryAPI; +import forestry.api.farming.IFarmProperties; import forestry.api.farming.IFarmRegistry; import forestry.api.modules.ForestryModule; import forestry.core.ModuleCore; +import forestry.core.blocks.BlockBogEarth; +import forestry.core.blocks.BlockRegistryCore; import forestry.core.circuits.CircuitLayout; import forestry.core.circuits.Circuits; import forestry.core.config.Config; @@ -59,8 +63,9 @@ import forestry.farming.blocks.BlockRegistryFarming; import forestry.farming.blocks.EnumFarmBlockType; import forestry.farming.circuits.CircuitFarmLogic; import forestry.farming.logic.FarmLogicArboreal; -import forestry.farming.logic.FarmLogicCereal; import forestry.farming.logic.FarmLogicCocoa; +import forestry.farming.logic.FarmLogicCrops; +import forestry.farming.logic.FarmLogicEnder; import forestry.farming.logic.FarmLogicGourd; import forestry.farming.logic.FarmLogicInfernal; import forestry.farming.logic.FarmLogicMushroom; @@ -68,13 +73,13 @@ import forestry.farming.logic.FarmLogicOrchard; import forestry.farming.logic.FarmLogicPeat; import forestry.farming.logic.FarmLogicReeds; import forestry.farming.logic.FarmLogicSucculent; -import forestry.farming.logic.FarmLogicVegetable; -import forestry.farming.logic.FarmableAgingCrop; -import forestry.farming.logic.FarmableGE; -import forestry.farming.logic.FarmableGourd; -import forestry.farming.logic.FarmableStacked; -import forestry.farming.logic.FarmableVanillaMushroom; -import forestry.farming.logic.FarmableVanillaSapling; +import forestry.farming.logic.farmables.FarmableAgingCrop; +import forestry.farming.logic.farmables.FarmableChorus; +import forestry.farming.logic.farmables.FarmableGE; +import forestry.farming.logic.farmables.FarmableGourd; +import forestry.farming.logic.farmables.FarmableStacked; +import forestry.farming.logic.farmables.FarmableVanillaMushroom; +import forestry.farming.logic.farmables.FarmableVanillaSapling; import forestry.farming.models.EnumFarmBlockTexture; import forestry.farming.proxy.ProxyFarming; import forestry.farming.tiles.TileFarmControl; @@ -129,7 +134,7 @@ public class ModuleFarming extends BlankForestryModule { registry.registerFarmables("farmArboreal", new FarmableGE()); } - registry.registerFarmables("farmOrchard", + registry.registerFarmables("farmCrops", new FarmableAgingCrop(new ItemStack(Items.WHEAT_SEEDS), Blocks.WHEAT, BlockCrops.AGE, 7, 0), new FarmableAgingCrop(new ItemStack(Items.POTATO), Blocks.POTATOES, BlockCrops.AGE, 7, 0), new FarmableAgingCrop(new ItemStack(Items.CARROT), Blocks.CARROTS, BlockCrops.AGE, 7, 0), @@ -141,8 +146,6 @@ public class ModuleFarming extends BlankForestryModule { IBlockState plantedRedMushroom = blocks.mushroom.getDefaultState().withProperty(BlockMushroom.VARIANT, BlockMushroom.MushroomType.RED); registry.registerFarmables("farmShroom", new FarmableVanillaMushroom(new ItemStack(Blocks.RED_MUSHROOM), plantedRedMushroom, Blocks.RED_MUSHROOM_BLOCK)); - registry.registerFarmables("farmWheat", new FarmableAgingCrop(new ItemStack(Items.WHEAT_SEEDS), Blocks.WHEAT, BlockCrops.AGE, 7)); - registry.registerFarmables("farmGourd", new FarmableGourd(new ItemStack(Items.PUMPKIN_SEEDS), Blocks.PUMPKIN_STEM, Blocks.PUMPKIN)); registry.registerFarmables("farmGourd", new FarmableGourd(new ItemStack(Items.MELON_SEEDS), Blocks.MELON_STEM, Blocks.MELON_BLOCK)); @@ -152,9 +155,7 @@ public class ModuleFarming extends BlankForestryModule { registry.registerFarmables("farmSucculentes", new FarmableStacked(new ItemStack(Blocks.CACTUS), Blocks.CACTUS, 3)); - registry.registerFarmables("farmVegetables", new FarmableAgingCrop(new ItemStack(Items.POTATO), Blocks.POTATOES, BlockCrops.AGE, 7)); - registry.registerFarmables("farmVegetables", new FarmableAgingCrop(new ItemStack(Items.CARROT), Blocks.CARROTS, BlockCrops.AGE, 7)); - registry.registerFarmables("farmVegetables", new FarmableAgingCrop(new ItemStack(Items.BEETROOT_SEEDS), Blocks.BEETROOTS, BlockBeetroot.BEETROOT_AGE, 3)); + registry.registerFarmables("farmEnder", FarmableChorus.INSTANCE); //Forestry fertilizer registry.registerFertilizer(new ItemStack(coreItems.fertilizerCompound, 1, OreDictionary.WILDCARD_VALUE), 500); @@ -188,30 +189,65 @@ public class ModuleFarming extends BlankForestryModule { GameRegistry.registerTileEntity(TileFarmValve.class, "forestry.FarmValve"); GameRegistry.registerTileEntity(TileFarmControl.class, "forestry.FarmControl"); - Circuits.farmArborealManaged = new CircuitFarmLogic("managedArboreal", new FarmLogicArboreal()); - Circuits.farmShroomManaged = new CircuitFarmLogic("managedShroom", new FarmLogicMushroom()); - Circuits.farmPeatManaged = new CircuitFarmLogic("managedPeat", new FarmLogicPeat()); - Circuits.farmCerealManaged = new CircuitFarmLogic("managedCereal", new FarmLogicCereal()); - Circuits.farmVegetableManaged = new CircuitFarmLogic("managedVegetable", new FarmLogicVegetable()); - Circuits.farmInfernalManaged = new CircuitFarmLogic("managedInfernal", new FarmLogicInfernal()); + IFarmRegistry registry = FarmRegistry.getInstance(); + BlockRegistryCore coreBlocks = ModuleCore.getBlocks(); - Circuits.farmPeatManual = new CircuitFarmLogic("manualPeat", new FarmLogicPeat()).setManual(); - Circuits.farmShroomManual = new CircuitFarmLogic("manualShroom", new FarmLogicMushroom()).setManual(); - Circuits.farmCerealManual = new CircuitFarmLogic("manualCereal", new FarmLogicCereal()).setManual(); - Circuits.farmVegetableManual = new CircuitFarmLogic("manualVegetable", new FarmLogicVegetable()).setManual(); - Circuits.farmSucculentManual = new CircuitFarmLogic("manualSucculent", new FarmLogicSucculent()).setManual(); - Circuits.farmPoalesManual = new CircuitFarmLogic("manualPoales", new FarmLogicReeds()).setManual(); - Circuits.farmGourdManual = new CircuitFarmLogic("manualGourd", new FarmLogicGourd()).setManual(); - Circuits.farmCocoaManual = new CircuitFarmLogic("manualCocoa", new FarmLogicCocoa()).setManual(); + IFarmProperties arborealFarm = registry.registerLogic("farmArboreal", FarmLogicArboreal::new); + IFarmProperties cropsFarm = registry.registerLogic("farmCrops", FarmLogicCrops::new); + IFarmProperties mushroomFarm = registry.registerLogic("farmShroom", FarmLogicMushroom::new); + IFarmProperties succulentFarm = registry.registerLogic("farmSucculent", FarmLogicSucculent::new); + IFarmProperties peatFarm = registry.registerLogic("farmPeat", FarmLogicPeat::new); + IFarmProperties infernalFarm = registry.registerLogic("farmInfernal", FarmLogicInfernal::new); + IFarmProperties poalesFarm = registry.registerLogic("farmPoales", FarmLogicReeds::new); + IFarmProperties orchardFarm = registry.registerLogic("farmOrchard", FarmLogicOrchard::new); + IFarmProperties gourdFarm = registry.registerLogic("farmGourd", FarmLogicGourd::new); + IFarmProperties cocoaFarm = registry.registerLogic("farmCocoa", FarmLogicCocoa::new); + IFarmProperties enderFarm = registry.registerLogic("farmEnder", FarmLogicEnder::new); - Circuits.farmOrchardManual = new CircuitFarmLogic("manualOrchard", new FarmLogicOrchard()); + Circuits.farmArborealManaged = new CircuitFarmLogic("managedArboreal", arborealFarm, false); + Circuits.farmArborealManual = new CircuitFarmLogic("manualArboreal", arborealFarm, true); + arborealFarm.registerSoil(new ItemStack(Blocks.DIRT), coreBlocks.humus.getDefaultState()); + arborealFarm.registerSoil(new ItemStack(coreBlocks.humus), coreBlocks.humus.getDefaultState()); - // Make Forestry farming logics accessible to plugins via FarmRegistry - FarmRegistry.getInstance().registerFarmLogic("farmArboreal",((CircuitFarmLogic)Circuits.farmArborealManaged).getFarmLogic()); - FarmRegistry.getInstance().registerFarmLogic("farmShroom",((CircuitFarmLogic)Circuits.farmShroomManaged).getFarmLogic()); - FarmRegistry.getInstance().registerFarmLogic("farmWheat",((CircuitFarmLogic)Circuits.farmCerealManaged).getFarmLogic()); - FarmRegistry.getInstance().registerFarmLogic("farmVegetables",((CircuitFarmLogic)Circuits.farmVegetableManaged).getFarmLogic()); - FarmRegistry.getInstance().registerFarmLogic("farmInfernal",((CircuitFarmLogic)Circuits.farmInfernalManaged).getFarmLogic()); + Circuits.farmShroomManaged = new CircuitFarmLogic("managedShroom", mushroomFarm, false); + Circuits.farmShroomManual = new CircuitFarmLogic("manualShroom", mushroomFarm, true); + mushroomFarm.registerSoil(new ItemStack(Blocks.MYCELIUM), Blocks.MYCELIUM.getDefaultState()); + mushroomFarm.registerSoil(new ItemStack(Blocks.DIRT, 1, 2), + Blocks.DIRT.getDefaultState().withProperty(BlockDirt.VARIANT, BlockDirt.DirtType.PODZOL), true); + + Circuits.farmPeatManaged = new CircuitFarmLogic("managedPeat", peatFarm, false); + Circuits.farmPeatManual = new CircuitFarmLogic("manualPeat", peatFarm, true); + peatFarm.registerSoil(coreBlocks.bogEarth.get(BlockBogEarth.SoilType.BOG_EARTH, 1), coreBlocks.bogEarth.getDefaultState()); + + Circuits.farmCropsManaged = new CircuitFarmLogic("managedCrops", cropsFarm, false); + Circuits.farmCropsManual = new CircuitFarmLogic("manualCrops", cropsFarm, true); + cropsFarm.registerSoil(new ItemStack(Blocks.DIRT), Blocks.FARMLAND.getDefaultState()); + + Circuits.farmInfernalManaged = new CircuitFarmLogic("managedInfernal", infernalFarm, false); + Circuits.farmInfernalManual = new CircuitFarmLogic("manualInfernal", infernalFarm, true); + infernalFarm.registerSoil(new ItemStack(Blocks.SOUL_SAND), Blocks.SOUL_SAND.getDefaultState()); + + Circuits.farmOrchardManaged = new CircuitFarmLogic("managedOrchard", orchardFarm, false); + Circuits.farmOrchardManual = new CircuitFarmLogic("manualOrchard", orchardFarm, true); + + Circuits.farmSucculentManaged = new CircuitFarmLogic("managedSucculent", succulentFarm, false); + Circuits.farmSucculentManual = new CircuitFarmLogic("manualSucculent", succulentFarm, true); + succulentFarm.registerSoil(new ItemStack(Blocks.SAND), Blocks.SAND.getDefaultState(),true); + + Circuits.farmPoalesManaged = new CircuitFarmLogic("managedPoales", poalesFarm, false); + Circuits.farmPoalesManual = new CircuitFarmLogic("manualPoales", poalesFarm, true); + poalesFarm.registerSoil(new ItemStack(Blocks.SAND), Blocks.SAND.getDefaultState(),true); + poalesFarm.registerSoil(new ItemStack(Blocks.DIRT), Blocks.DIRT.getDefaultState(),false); + + Circuits.farmGourdManaged = new CircuitFarmLogic("managedGourd", gourdFarm, false); + Circuits.farmGourdManual = new CircuitFarmLogic("manualGourd", gourdFarm, true); + + Circuits.farmCocoaManaged = new CircuitFarmLogic("managedCocoa", cocoaFarm, false); + Circuits.farmCocoaManual = new CircuitFarmLogic("manualCocoa", cocoaFarm, true); + + Circuits.farmEnderManaged = new CircuitFarmLogic("managedEnder", enderFarm, false); + Circuits.farmEnderManual = new CircuitFarmLogic("manualEnder", enderFarm, true); + enderFarm.registerSoil(new ItemStack(Blocks.END_STONE), Blocks.END_STONE.getDefaultState()); } @Override @@ -275,22 +311,32 @@ public class ModuleFarming extends BlankForestryModule { ICircuitLayout layoutManaged = ChipsetManager.circuitRegistry.getLayout("forestry.farms.managed"); ICircuitLayout layoutManual = ChipsetManager.circuitRegistry.getLayout("forestry.farms.manual"); - ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.COPPER, 1), Circuits.farmArborealManaged); - ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.TIN, 1), Circuits.farmPeatManaged); - ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.BRONZE, 1), Circuits.farmCerealManaged); - ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.IRON, 1), Circuits.farmVegetableManaged); - ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.BLAZE, 1), Circuits.farmInfernalManaged); - ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.APATITE, 1), Circuits.farmShroomManaged); + if(layoutManaged == null || layoutManual == null){ + return; + } - ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.COPPER, 1), Circuits.farmOrchardManual); - ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.TIN, 1), Circuits.farmPeatManual); - ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.BRONZE, 1), Circuits.farmCerealManual); - ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.IRON, 1), Circuits.farmVegetableManual); - ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.GOLD, 1), Circuits.farmSucculentManual); - ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.DIAMOND, 1), Circuits.farmPoalesManual); - ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.OBSIDIAN, 1), Circuits.farmGourdManual); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.GOLD, 1), Circuits.farmArborealManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.COPPER, 1), Circuits.farmSucculentManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.OBSIDIAN, 1), Circuits.farmPeatManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.BRONZE, 1), Circuits.farmCropsManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.BLAZE, 1), Circuits.farmInfernalManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.TIN, 1), Circuits.farmPoalesManual); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.LAPIS, 1), Circuits.farmGourdManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.APATITE, 1), Circuits.farmShroomManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.DIAMOND, 1), Circuits.farmCocoaManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.EMERALD, 1), Circuits.farmOrchardManaged); + ChipsetManager.solderManager.addRecipe(layoutManaged, coreItems.tubes.get(EnumElectronTube.ENDER, 1), Circuits.farmEnderManaged); + + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.GOLD, 1), Circuits.farmArborealManual); + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.COPPER, 1), Circuits.farmSucculentManual); + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.OBSIDIAN, 1), Circuits.farmPeatManual); + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.BRONZE, 1), Circuits.farmCropsManual); + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.TIN, 1), Circuits.farmPoalesManual); + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.LAPIS, 1), Circuits.farmGourdManual); ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.APATITE, 1), Circuits.farmShroomManual); - ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.LAPIS, 1), Circuits.farmCocoaManual); + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.DIAMOND, 1), Circuits.farmCocoaManual); + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.EMERALD, 1), Circuits.farmOrchardManual); + ChipsetManager.solderManager.addRecipe(layoutManual, coreItems.tubes.get(EnumElectronTube.ENDER, 1), Circuits.farmEnderManual); } @Override diff --git a/src/main/java/forestry/farming/circuits/CircuitFarmLogic.java b/src/main/java/forestry/farming/circuits/CircuitFarmLogic.java index 1e434f54e..fa381ee90 100755 --- a/src/main/java/forestry/farming/circuits/CircuitFarmLogic.java +++ b/src/main/java/forestry/farming/circuits/CircuitFarmLogic.java @@ -15,6 +15,7 @@ import javax.annotation.Nullable; import forestry.api.farming.FarmDirection; import forestry.api.farming.IFarmHousing; import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmProperties; import forestry.core.circuits.Circuit; public class CircuitFarmLogic extends Circuit { @@ -22,15 +23,38 @@ public class CircuitFarmLogic extends Circuit { private final IFarmLogic logic; private boolean isManual = false; + public CircuitFarmLogic(String uid, IFarmProperties instance, boolean manual) { + super(uid); + this.logic = instance.getLogic(manual); + } + public CircuitFarmLogic(String uid, IFarmLogic logic) { super(uid); this.logic = logic; } - + + @Override + public String getUnlocalizedName() { + return logic.getUnlocalizedName(); + } + + @Override + public String getLocalizedName() { + return logic.getName(); + } + + /** + * @deprecated TODO: Remove this method in 1.13 + */ + @Deprecated public IFarmLogic getFarmLogic() { return logic; } + /** + * @deprecated TODO: Remove this method in 1.13 + */ + @Deprecated public CircuitFarmLogic setManual() { isManual = true; return this; diff --git a/src/main/java/forestry/farming/gui/FarmLogicSlot.java b/src/main/java/forestry/farming/gui/FarmLogicSlot.java index 4e17be333..0946a1ffc 100644 --- a/src/main/java/forestry/farming/gui/FarmLogicSlot.java +++ b/src/main/java/forestry/farming/gui/FarmLogicSlot.java @@ -10,17 +10,19 @@ ******************************************************************************/ package forestry.farming.gui; -import forestry.api.farming.FarmDirection; -import forestry.api.farming.IFarmLogic; -import forestry.core.gui.tooltips.ToolTip; -import forestry.core.gui.widgets.Widget; -import forestry.core.gui.widgets.WidgetManager; -import forestry.farming.multiblock.IFarmControllerInternal; import net.minecraft.client.Minecraft; import net.minecraft.client.renderer.RenderItem; import net.minecraft.client.renderer.texture.TextureManager; import net.minecraft.item.ItemStack; +import forestry.api.farming.FarmDirection; +import forestry.api.farming.IFarmLogic; +import forestry.core.config.Config; +import forestry.core.gui.tooltips.ToolTip; +import forestry.core.gui.widgets.Widget; +import forestry.core.gui.widgets.WidgetManager; +import forestry.farming.multiblock.IFarmControllerInternal; + public class FarmLogicSlot extends Widget { private final IFarmControllerInternal farmController; @@ -65,7 +67,7 @@ public class FarmLogicSlot extends Widget { public void refresh() { toolTip.clear(); toolTip.add(getLogic().getName()); - toolTip.add("Fertilizer: " + getLogic().getFertilizerConsumption()); + toolTip.add("Fertilizer: " + Math.round(getLogic().getFertilizerConsumption() * Config.fertilizerModifier)); toolTip.add("Water: " + getLogic().getWaterConsumption(farmController.getFarmLedgerDelegate().getHydrationModifier())); } }; diff --git a/src/main/java/forestry/farming/logic/FakeFarmProperties.java b/src/main/java/forestry/farming/logic/FakeFarmProperties.java new file mode 100644 index 000000000..6cf8aa652 --- /dev/null +++ b/src/main/java/forestry/farming/logic/FakeFarmProperties.java @@ -0,0 +1,53 @@ +package forestry.farming.logic; + +import java.util.Collection; +import java.util.Collections; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; + +import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmProperties; +import forestry.api.farming.IFarmable; +import forestry.api.farming.ISoil; + +public class FakeFarmProperties implements IFarmProperties { + private final IFarmLogic logic; + + public FakeFarmProperties(IFarmLogic logic) { + this.logic = logic; + } + + @Override + public void registerFarmables(String identifier) { + } + + @Override + public void registerSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { + } + + @Override + public boolean isAcceptedSoil(IBlockState blockState) { + return false; + } + + @Override + public boolean isAcceptedResource(ItemStack itemStack) { + return false; + } + + @Override + public Collection getSoils() { + return Collections.emptySet(); + } + + @Override + public Collection getFarmables() { + return Collections.emptySet(); + } + + @Override + public IFarmLogic getLogic(boolean manuel) { + return logic; + } +} diff --git a/src/main/java/forestry/farming/logic/FarmLogic.java b/src/main/java/forestry/farming/logic/FarmLogic.java index b5318b478..0ee747f3b 100755 --- a/src/main/java/forestry/farming/logic/FarmLogic.java +++ b/src/main/java/forestry/farming/logic/FarmLogic.java @@ -13,47 +13,87 @@ package forestry.farming.logic; import com.google.common.base.Predicate; import javax.annotation.Nullable; +import java.util.Collection; import java.util.List; +import java.util.Stack; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; -import net.minecraft.client.renderer.texture.TextureMap; import net.minecraft.entity.item.EntityItem; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; -import net.minecraft.util.ResourceLocation; import net.minecraft.util.math.AxisAlignedBB; import net.minecraft.util.math.BlockPos; import net.minecraft.util.math.Vec3i; import net.minecraft.world.World; -import net.minecraftforge.fml.relauncher.Side; -import net.minecraftforge.fml.relauncher.SideOnly; - import forestry.api.farming.FarmDirection; +import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmProperties; +import forestry.api.farming.IFarmable; +import forestry.api.farming.ISoil; +import forestry.core.utils.Translator; import forestry.core.utils.VectUtil; public abstract class FarmLogic implements IFarmLogic { private final EntitySelectorFarm entitySelectorFarm = new EntitySelectorFarm(this); - protected boolean isManual; + protected final IFarmProperties properties; + protected final boolean isManual; + + public FarmLogic(IFarmProperties properties, boolean isManual) { + this.properties = properties; + this.isManual = isManual; + } + + protected Collection getFarmables() { + return properties.getFarmables(); + } + + protected Collection getSoils() { + return properties.getSoils(); + } + + @Override + public String getName() { + String unformatted = isManual ? "for.farm.grammar.manual" : "for.farm.grammar.managed"; + return Translator.translateToLocalFormatted(unformatted, Translator.translateToLocal(getUnlocalizedName())); + } @Override public FarmLogic setManual(boolean flag) { - isManual = flag; return this; } - @SideOnly(Side.CLIENT) @Override - public ResourceLocation getTextureMap() { - return TextureMap.LOCATION_BLOCKS_TEXTURE; + public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { + Stack crops = new Stack<>(); + for (int i = 0; i < extent; i++) { + BlockPos position = translateWithOffset(pos.up(), direction, i); + ICrop crop = getCrop(world, position); + if (crop != null) { + crops.push(crop); + } + } + return crops; } - @Override - public abstract ItemStack getIconItemStack(); + @Nullable + protected ICrop getCrop(World world, BlockPos position) { + if (world.isAirBlock(position)) { + return null; + } + IBlockState blockState = world.getBlockState(position); + for (IFarmable seed : getFarmables()) { + ICrop crop = seed.getCropAt(world, position, blockState); + if (crop != null) { + return crop; + } + } + return null; + } public abstract boolean isAcceptedWindfall(ItemStack stack); @@ -96,6 +136,12 @@ public abstract class FarmLogic implements IFarmLogic { return stacks; } + // for debugging + @Override + public String toString() { + return getName(); + } + private static class EntitySelectorFarm implements Predicate { private final FarmLogic farmLogic; @@ -112,15 +158,9 @@ public abstract class FarmLogic implements IFarmLogic { if (entity.getEntityData().getBoolean("PreventRemoteMovement")) { return false; } - + ItemStack contained = entity.getItem(); return farmLogic.isAcceptedGermling(contained) || farmLogic.isAcceptedWindfall(contained); } } - - // for debugging - @Override - public String toString() { - return getName(); - } } diff --git a/src/main/java/forestry/farming/logic/FarmLogicArboreal.java b/src/main/java/forestry/farming/logic/FarmLogicArboreal.java index 6d6da69bc..768c061ef 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicArboreal.java +++ b/src/main/java/forestry/farming/logic/FarmLogicArboreal.java @@ -11,10 +11,12 @@ package forestry.farming.logic; import javax.annotation.Nullable; +import java.util.ArrayList; import java.util.Collection; import java.util.Collections; import java.util.HashMap; import java.util.HashSet; +import java.util.List; import java.util.Map; import java.util.Set; import java.util.Stack; @@ -29,22 +31,29 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; import forestry.api.farming.IFarmable; -import forestry.core.ModuleCore; -import forestry.farming.FarmRegistry; public class FarmLogicArboreal extends FarmLogicHomogeneous { - public FarmLogicArboreal(ItemStack resource, IBlockState ground, Collection germlings) { - super(resource, ground, germlings); - } - public FarmLogicArboreal() { - super(new ItemStack(Blocks.DIRT), ModuleCore.getBlocks().humus.getDefaultState(), FarmRegistry.getInstance().getFarmables("farmArboreal")); + @Nullable + private List farmables; + + public FarmLogicArboreal(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override - public String getName() { - return "Managed Arboretum"; + public List getFarmables() { + if (farmables == null) { + this.farmables = new ArrayList<>(properties.getFarmables()); + } + return farmables; + } + + @Override + public String getUnlocalizedName() { + return "for.farm.arboretum"; } @Override @@ -73,7 +82,6 @@ public class FarmLogicArboreal extends FarmLogicHomogeneous { @Override public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { - if (!lastExtentsHarvest.containsKey(pos)) { lastExtentsHarvest.put(pos, 0); } @@ -93,7 +101,7 @@ public class FarmLogicArboreal extends FarmLogicHomogeneous { private Collection harvestBlocks(World world, BlockPos position) { // Determine what type we want to harvest. - IFarmable farmable = getFarmableForBlock(world, position, farmables); + IFarmable farmable = getFarmableForBlock(world, position, getFarmables()); if (farmable == null) { return Collections.emptyList(); } @@ -126,6 +134,9 @@ public class FarmLogicArboreal extends FarmLogicHomogeneous { @Nullable private static IFarmable getFarmableForBlock(World world, BlockPos position, Collection farmables) { + if (world.isAirBlock(position)) { + return null; + } IBlockState blockState = world.getBlockState(position); for (IFarmable farmable : farmables) { ICrop crop = farmable.getCropAt(world, position, blockState); @@ -145,17 +156,17 @@ public class FarmLogicArboreal extends FarmLogicHomogeneous { BlockPos soilPosition = position.down(); IBlockState soilState = world.getBlockState(soilPosition); if (isAcceptedSoil(soilState)) { - return plantSapling(world, farmHousing, position); + return plantSapling(world, farmHousing, position, direction); } } } return false; } - private boolean plantSapling(World world, IFarmHousing farmHousing, BlockPos position) { + private boolean plantSapling(World world, IFarmHousing farmHousing, BlockPos position, FarmDirection direction) { Collections.shuffle(farmables); - for (IFarmable candidate : farmables) { - if (farmHousing.plantGermling(candidate, world, position)) { + for (IFarmable candidate : getFarmables()) { + if (farmHousing.plantGermling(candidate, world, position, direction)) { return true; } } diff --git a/src/main/java/forestry/farming/logic/FarmLogicCereal.java b/src/main/java/forestry/farming/logic/FarmLogicCereal.java deleted file mode 100755 index 3d148d0f3..000000000 --- a/src/main/java/forestry/farming/logic/FarmLogicCereal.java +++ /dev/null @@ -1,37 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2011-2014 SirSengir. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser Public License v3 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl-3.0.txt - * - * Various Contributors including, but not limited to: - * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges - ******************************************************************************/ -package forestry.farming.logic; - -import net.minecraft.init.Items; -import net.minecraft.item.ItemStack; - -import forestry.api.core.ForestryAPI; - -public class FarmLogicCereal extends FarmLogicCrops { - - public FarmLogicCereal() { - super(ForestryAPI.farmRegistry.getFarmables("farmWheat")); - } - - @Override - public String getName() { - if (isManual) { - return "Manual Farm"; - } else { - return "Managed Farm"; - } - } - - @Override - public ItemStack getIconItemStack() { - return new ItemStack(Items.WHEAT); - } -} diff --git a/src/main/java/forestry/farming/logic/FarmLogicCocoa.java b/src/main/java/forestry/farming/logic/FarmLogicCocoa.java index 6d9b743bd..64d5c10ea 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicCocoa.java +++ b/src/main/java/forestry/farming/logic/FarmLogicCocoa.java @@ -34,19 +34,25 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; import forestry.api.farming.IFarmable; +import forestry.farming.logic.farmables.FarmableCocoa; public class FarmLogicCocoa extends FarmLogic { private final IFarmable cocoa = new FarmableCocoa(); + public FarmLogicCocoa(IFarmProperties properties, boolean isManual) { + super(properties, isManual); + } + @Override public ItemStack getIconItemStack() { return new ItemStack(Items.DYE, 1, 3); } @Override - public String getName() { - return "Cocoa Plantation"; + public String getUnlocalizedName() { + return "for.farm.cocoa"; } @Override @@ -73,11 +79,6 @@ public class FarmLogicCocoa extends FarmLogic { public boolean isAcceptedWindfall(ItemStack stack) { return false; } - - @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - // do nothing as soil is not managed by farm - } @Override public NonNullList collect(World world, IFarmHousing farmHousing) { @@ -88,7 +89,6 @@ public class FarmLogicCocoa extends FarmLogic { @Override public boolean cultivate(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { - if (!lastExtentsCultivation.containsKey(pos)) { lastExtentsCultivation.put(pos, 0); } @@ -99,7 +99,7 @@ public class FarmLogicCocoa extends FarmLogic { } BlockPos position = translateWithOffset(pos.up(), direction, lastExtent); - boolean result = tryPlantingCocoa(world, farmHousing, position); + boolean result = tryPlantingCocoa(world, farmHousing, position, direction); lastExtent++; lastExtentsCultivation.put(pos, lastExtent); @@ -128,14 +128,14 @@ public class FarmLogicCocoa extends FarmLogic { return crops; } - private boolean tryPlantingCocoa(World world, IFarmHousing farmHousing, BlockPos position) { + private boolean tryPlantingCocoa(World world, IFarmHousing farmHousing, BlockPos position, FarmDirection farmDirection) { BlockPos.MutableBlockPos current = new BlockPos.MutableBlockPos(position); IBlockState blockState = world.getBlockState(current); while (isJungleTreeTrunk(blockState)) { for (EnumFacing direction : EnumFacing.HORIZONTALS) { BlockPos candidate = new BlockPos(current.getX() + direction.getFrontOffsetX(), current.getY(), current.getZ() + direction.getFrontOffsetZ()); if (world.isAirBlock(candidate)) { - return farmHousing.plantGermling(cocoa, world, candidate); + return farmHousing.plantGermling(cocoa, world, candidate, farmDirection); } } diff --git a/src/main/java/forestry/farming/logic/FarmLogicCrops.java b/src/main/java/forestry/farming/logic/FarmLogicCrops.java index 3e77448cf..3e57ab87d 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicCrops.java +++ b/src/main/java/forestry/farming/logic/FarmLogicCrops.java @@ -10,39 +10,28 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.Collection; -import java.util.Stack; - import net.minecraft.block.state.IBlockState; -import net.minecraft.init.Blocks; +import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; import forestry.api.farming.FarmDirection; -import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; import forestry.api.farming.IFarmable; import forestry.core.utils.BlockUtil; -public abstract class FarmLogicCrops extends FarmLogicWatered { - private final Iterable seeds; +public class FarmLogicCrops extends FarmLogicWatered { - protected FarmLogicCrops(Iterable seeds) { - super(new ItemStack(Blocks.DIRT), Blocks.FARMLAND.getDefaultState()); - - this.seeds = seeds; - } - - @Override - public boolean isAcceptedGround(IBlockState blockState) { - return super.isAcceptedGround(blockState) || blockState.getBlock() == Blocks.FARMLAND; + public FarmLogicCrops(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override public boolean isAcceptedGermling(ItemStack itemstack) { - for (IFarmable germling : seeds) { + for (IFarmable germling : getFarmables()) { if (germling.isGermling(itemstack)) { return true; } @@ -52,7 +41,7 @@ public abstract class FarmLogicCrops extends FarmLogicWatered { @Override public boolean isAcceptedWindfall(ItemStack itemstack) { - for (IFarmable germling : seeds) { + for (IFarmable germling : getFarmables()) { if (germling.isWindfall(itemstack)) { return true; } @@ -77,17 +66,17 @@ public abstract class FarmLogicCrops extends FarmLogicWatered { } IBlockState groundState = world.getBlockState(position.down()); - if (isAcceptedGround(groundState)) { - return trySetCrop(world, farmHousing, position); + if (isAcceptedSoil(groundState)) { + return trySetCrop(world, farmHousing, position, direction); } } return false; } - private boolean trySetCrop(World world, IFarmHousing farmHousing, BlockPos position) { - for (IFarmable candidate : seeds) { - if (farmHousing.plantGermling(candidate, world, position)) { + private boolean trySetCrop(World world, IFarmHousing farmHousing, BlockPos position, FarmDirection direction) { + for (IFarmable candidate : getFarmables()) { + if (farmHousing.plantGermling(candidate, world, position, direction)) { return true; } } @@ -96,20 +85,12 @@ public abstract class FarmLogicCrops extends FarmLogicWatered { } @Override - public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { - Stack crops = new Stack<>(); - for (int i = 0; i < extent; i++) { - BlockPos position = translateWithOffset(pos.up(), direction, i); - IBlockState blockState = world.getBlockState(position); - for (IFarmable seed : seeds) { - ICrop crop = seed.getCropAt(world, position, blockState); - if (crop != null) { - crops.push(crop); - break; - } - } - } - return crops; + public ItemStack getIconItemStack() { + return new ItemStack(Items.WHEAT); } + @Override + public String getUnlocalizedName() { + return "for.farm.crops"; + } } diff --git a/src/main/java/forestry/farming/logic/FarmLogicEnder.java b/src/main/java/forestry/farming/logic/FarmLogicEnder.java new file mode 100644 index 000000000..28968daf4 --- /dev/null +++ b/src/main/java/forestry/farming/logic/FarmLogicEnder.java @@ -0,0 +1,154 @@ +package forestry.farming.logic; + +import com.google.common.collect.ImmutableSet; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import java.util.Stack; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.NonNullList; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import forestry.api.farming.FarmDirection; +import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; +import forestry.api.farming.IFarmable; +import forestry.core.utils.BlockUtil; +import forestry.farming.logic.crops.CropDestroy; +import forestry.farming.logic.farmables.FarmableChorus; + +public class FarmLogicEnder extends FarmLogicHomogeneous { + private static final Set VALID_DIRECTIONS = ImmutableSet.of(EnumFacing.UP, EnumFacing.NORTH, EnumFacing.SOUTH, EnumFacing.WEST, EnumFacing.EAST); + private final IFarmable chorusFarmable; + + public FarmLogicEnder(IFarmProperties properties, boolean isManual) { + super(properties, isManual); + chorusFarmable = FarmableChorus.INSTANCE; + } + + @Override + public String getUnlocalizedName() { + return "for.farm.ender"; + } + + @Override + public ItemStack getIconItemStack() { + return new ItemStack(Items.ENDER_EYE); + } + + @Override + public int getFertilizerConsumption() { + return 20; + } + + @Override + public int getWaterConsumption(float hydrationModifier) { + return 0; + } + + @Override + public NonNullList collect(World world, IFarmHousing farmHousing) { + NonNullList products = produce; + produce = collectEntityItems(world, farmHousing, true); + return products; + } + + private final Map lastExtentsHarvest = new HashMap<>(); + + @Override + public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { + if (!lastExtentsHarvest.containsKey(pos)) { + lastExtentsHarvest.put(pos, 0); + } + + int lastExtent = lastExtentsHarvest.get(pos); + if (lastExtent > extent) { + lastExtent = 0; + } + + BlockPos position = translateWithOffset(pos.up(), direction, lastExtent); + Collection crops = harvestBlocks(world, position); + lastExtent++; + lastExtentsHarvest.put(pos, lastExtent); + + return crops; + } + + private Collection harvestBlocks(World world, BlockPos position) { + if (world.isAirBlock(position)) { + return Collections.emptySet(); + } + + ICrop crop = getCrop(world, position); + if (crop != null) { + return Collections.singleton(crop); + } + + Stack crops = new Stack<>(); + Stack plants = new Stack<>(); + harvestBlock(world, position, EnumFacing.DOWN, plants, crops); + //Remove all flowers before remove all plants + if (!crops.isEmpty()) { + return crops; + } + return plants; + } + + private boolean harvestBlock(World world, BlockPos pos, EnumFacing from, Stack plants, Stack flowers) { + IBlockState blockState = world.getBlockState(pos); + if (blockState.getBlock() == Blocks.CHORUS_FLOWER) { + ICrop crop = chorusFarmable.getCropAt(world, pos, blockState); + if (crop != null) { + flowers.push(crop); + return false; + } + return false; + } else if (blockState.getBlock() == Blocks.CHORUS_PLANT) { + boolean canHarvest = true; + for (EnumFacing facing : VALID_DIRECTIONS) { + if (facing == from) { + continue; + } + canHarvest &= harvestBlock(world, pos.offset(facing), facing.getOpposite(), plants, flowers); + } + if (canHarvest) { + plants.push(new CropDestroy(world, Blocks.CHORUS_PLANT.getDefaultState(), pos, null)); + } + return canHarvest; + } + return true; + } + + @Override + protected boolean maintainGermlings(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { + for (int i = 0; i < extent; i++) { + BlockPos position = translateWithOffset(pos, direction, i); + IBlockState state = world.getBlockState(position); + if (!world.isAirBlock(position) && !BlockUtil.isReplaceableBlock(state, world, position)) { + continue; + } + + BlockPos soilPos = position.down(); + IBlockState blockState = world.getBlockState(soilPos); + if (!isAcceptedSoil(blockState)) { + continue; + } + + if (trySetCrop(world, farmHousing, position, direction)) { + return true; + } + } + + return false; + } +} diff --git a/src/main/java/forestry/farming/logic/FarmLogicGourd.java b/src/main/java/forestry/farming/logic/FarmLogicGourd.java index ce62f72a6..6349294c6 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicGourd.java +++ b/src/main/java/forestry/farming/logic/FarmLogicGourd.java @@ -10,10 +10,6 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.Collection; -import java.util.Stack; - -import net.minecraft.block.state.IBlockState; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; @@ -21,18 +17,13 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; import forestry.api.farming.FarmDirection; -import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; -import forestry.api.farming.IFarmable; -import forestry.farming.FarmRegistry; +import forestry.api.farming.IFarmProperties; public class FarmLogicGourd extends FarmLogic { - private final IFarmable[] seeds; - - public FarmLogicGourd() { - Collection farmables = FarmRegistry.getInstance().getFarmables("farmGourd"); - seeds = farmables.toArray(new IFarmable[farmables.size()]); + public FarmLogicGourd(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override @@ -41,8 +32,8 @@ public class FarmLogicGourd extends FarmLogic { } @Override - public String getName() { - return "Gourd Farm"; + public String getUnlocalizedName() { + return "for.farm.gourd"; } @Override @@ -79,27 +70,4 @@ public class FarmLogicGourd extends FarmLogic { public boolean cultivate(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { return false; } - - @Override - public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { - Stack crops = new Stack<>(); - for (int i = 0; i < extent; i++) { - BlockPos position = translateWithOffset(pos.up(), direction, i); - IBlockState blockState = world.getBlockState(position); - for (IFarmable seed : seeds) { - ICrop crop = seed.getCropAt(world, position, blockState); - if (crop != null) { - crops.push(crop); - break; - } - } - } - return crops; - } - - @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - // do nothing as soil is not managed by farm - - } } diff --git a/src/main/java/forestry/farming/logic/FarmLogicHomogeneous.java b/src/main/java/forestry/farming/logic/FarmLogicHomogeneous.java index 0bee068ea..9cf2a8040 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicHomogeneous.java +++ b/src/main/java/forestry/farming/logic/FarmLogicHomogeneous.java @@ -10,65 +10,29 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; -import forestry.api.farming.FarmDirection; -import forestry.api.farming.IFarmHousing; -import forestry.api.farming.IFarmable; -import forestry.core.utils.BlockUtil; -import forestry.farming.FarmHelper; -import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; -public abstract class FarmLogicHomogeneous extends FarmLogic { - - private final List soils = new ArrayList<>(); - protected final List farmables; +import forestry.api.farming.FarmDirection; +import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; +import forestry.api.farming.IFarmable; +import forestry.api.farming.ISoil; +import forestry.core.utils.BlockUtil; +public abstract class FarmLogicHomogeneous extends FarmLogicSoil { protected NonNullList produce = NonNullList.create(); - protected FarmLogicHomogeneous(ItemStack resource, IBlockState soilState, Collection farmables) { - addSoil(resource, soilState, false); - this.farmables = new ArrayList<>(farmables); - } - - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData){ - soils.add(new Soil(resource, soilState, hasMetaData)); - } - - protected boolean isAcceptedSoil(IBlockState blockState) { - for(Soil soil : soils){ - IBlockState soilState = soil.getSoilState(); - Block soilBlock = soilState.getBlock(); - Block block = blockState.getBlock(); - if(soilState.getBlock() == blockState.getBlock()){ - if(!soil.hasMetaData() || block.getMetaFromState(blockState) == soilBlock.getMetaFromState(soilState)){ - return true; - } - } - } - return false; - } - - @Override - public boolean isAcceptedResource(ItemStack itemstack) { - for(Soil soil : soils){ - ItemStack resource = soil.getResource(); - if(resource.isItemEqual(itemstack)){ - return true; - } - } - return false; + public FarmLogicHomogeneous(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override public boolean isAcceptedGermling(ItemStack itemstack) { - for (IFarmable germling : farmables) { + for (IFarmable germling : getFarmables()) { if (germling.isGermling(itemstack)) { return true; } @@ -78,7 +42,7 @@ public abstract class FarmLogicHomogeneous extends FarmLogic { @Override public boolean isAcceptedWindfall(ItemStack itemstack) { - for (IFarmable germling : farmables) { + for (IFarmable germling : getFarmables()) { if (germling.isWindfall(itemstack)) { return true; } @@ -86,40 +50,52 @@ public abstract class FarmLogicHomogeneous extends FarmLogic { return false; } + protected boolean trySetCrop(World world, IFarmHousing farmHousing, BlockPos position, FarmDirection direction) { + for (IFarmable candidate : getFarmables()) { + if (farmHousing.plantGermling(candidate, world, position, direction)) { + return true; + } + } + + return false; + } + @Override public boolean cultivate(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { - return maintainSoil(world, farmHousing, pos, direction, extent) || - maintainGermlings(world, farmHousing, pos.up(), direction, extent); + return maintainSoil(world, farmHousing, pos, direction, extent) || maintainGermlings(world, farmHousing, pos.up(), direction, extent); } private boolean maintainSoil(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { - for(Soil soil : soils){ + if (!farmHousing.canPlantSoil(isManual)) { + return false; + } + + for (ISoil soil : getSoils()) { NonNullList resources = NonNullList.create(); resources.add(soil.getResource()); if (!farmHousing.getFarmInventory().hasResources(resources)) { continue; } - + for (int i = 0; i < extent; i++) { BlockPos position = translateWithOffset(pos, direction, i); IBlockState soilState = world.getBlockState(position); - - if (FarmHelper.bricks.contains(soilState.getBlock())) { + + if (farmHousing.isValidPlatform(world, pos)) { break; } - + if (isAcceptedSoil(soilState)) { continue; } - + BlockPos platformPosition = position.down(); - IBlockState platformState = world.getBlockState(platformPosition); - if (!FarmHelper.bricks.contains(platformState.getBlock())) { + if (!farmHousing.isValidPlatform(world, platformPosition)) { break; } - + produce.addAll(BlockUtil.getBlockDrops(world, position)); - + BlockUtil.setBlockWithPlaceSound(world, position, soil.getSoilState()); farmHousing.getFarmInventory().removeResources(resources); return true; diff --git a/src/main/java/forestry/farming/logic/FarmLogicInfernal.java b/src/main/java/forestry/farming/logic/FarmLogicInfernal.java index ada4a287f..186e911be 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicInfernal.java +++ b/src/main/java/forestry/farming/logic/FarmLogicInfernal.java @@ -14,7 +14,6 @@ import java.util.Collection; import java.util.Stack; import net.minecraft.block.state.IBlockState; -import net.minecraft.init.Blocks; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; @@ -24,19 +23,19 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; import forestry.api.farming.IFarmable; import forestry.core.utils.BlockUtil; -import forestry.farming.FarmRegistry; public class FarmLogicInfernal extends FarmLogicHomogeneous { - public FarmLogicInfernal() { - super(new ItemStack(Blocks.SOUL_SAND), Blocks.SOUL_SAND.getDefaultState(), FarmRegistry.getInstance().getFarmables("farmInfernal")); + public FarmLogicInfernal(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override - public String getName() { - return "Managed Infernal Farm"; + public String getUnlocalizedName() { + return "for.farm.infernal"; } @Override @@ -64,8 +63,11 @@ public class FarmLogicInfernal extends FarmLogicHomogeneous { Stack crops = new Stack<>(); for (int i = 0; i < extent; i++) { BlockPos position = translateWithOffset(pos.up(), direction, i); + if (world.isAirBlock(pos)) { + continue; + } IBlockState blockState = world.getBlockState(position); - for (IFarmable farmable : farmables) { + for (IFarmable farmable : getFarmables()) { ICrop crop = farmable.getCropAt(world, position, blockState); if (crop != null) { crops.push(crop); @@ -90,17 +92,7 @@ public class FarmLogicInfernal extends FarmLogicHomogeneous { BlockPos soilPosition = position.down(); IBlockState soilState = world.getBlockState(soilPosition); if (isAcceptedSoil(soilState)) { - return trySetCrop(world, farmHousing, position); - } - } - - return false; - } - - private boolean trySetCrop(World world, IFarmHousing farmHousing, BlockPos position) { - for (IFarmable candidate : farmables) { - if (farmHousing.plantGermling(candidate, world, position)) { - return true; + return trySetCrop(world, farmHousing, position, direction); } } diff --git a/src/main/java/forestry/farming/logic/FarmLogicMushroom.java b/src/main/java/forestry/farming/logic/FarmLogicMushroom.java index 93705fc16..ee63c5dde 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicMushroom.java +++ b/src/main/java/forestry/farming/logic/FarmLogicMushroom.java @@ -15,23 +15,17 @@ import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.world.World; -import forestry.api.core.ForestryAPI; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; public class FarmLogicMushroom extends FarmLogicArboreal { - public FarmLogicMushroom() { - super(new ItemStack(Blocks.MYCELIUM), Blocks.MYCELIUM.getDefaultState(), ForestryAPI.farmRegistry.getFarmables("farmShroom")); - addSoil(new ItemStack(Blocks.DIRT, 1, 2), Blocks.DIRT.getStateFromMeta(2), true); + public FarmLogicMushroom(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } - @Override - public String getName() { - if (isManual) { - return "Manual Shroom Farm"; - } else { - return "Managed Shroom Farm"; - } + public String getUnlocalizedName() { + return "for.farm.shroom"; } @Override diff --git a/src/main/java/forestry/farming/logic/FarmLogicOrchard.java b/src/main/java/forestry/farming/logic/FarmLogicOrchard.java index 3d486f326..d81a2585f 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicOrchard.java +++ b/src/main/java/forestry/farming/logic/FarmLogicOrchard.java @@ -28,23 +28,23 @@ import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; -import forestry.api.core.ForestryAPI; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; import forestry.api.farming.IFarmable; import forestry.api.genetics.IFruitBearer; import forestry.core.ModuleCore; import forestry.core.tiles.TileUtil; +import forestry.farming.logic.crops.CropFruit; public class FarmLogicOrchard extends FarmLogic { - private final Collection farmables; private final HashMap lastExtents = new HashMap<>(); private final ImmutableList traversalBlocks; - public FarmLogicOrchard() { - this.farmables = ForestryAPI.farmRegistry.getFarmables("farmOrchard"); + public FarmLogicOrchard(IFarmProperties properties, boolean isManual) { + super(properties, isManual); ImmutableList.Builder traversalBlocksBuilder = ImmutableList.builder(); // if (ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.AGRICRAFT) || ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.INDUSTRIALCRAFT)) { @@ -63,8 +63,6 @@ public class FarmLogicOrchard extends FarmLogic { // traversalBlocksBuilder.add(grapeVine); // } // } - - traversalBlocksBuilder.build(); this.traversalBlocks = traversalBlocksBuilder.build(); } @@ -105,7 +103,6 @@ public class FarmLogicOrchard extends FarmLogic { @Override public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { - if (!lastExtents.containsKey(pos)) { lastExtents.put(pos, 0); } @@ -129,13 +126,8 @@ public class FarmLogicOrchard extends FarmLogic { } @Override - public String getName() { - return "Orchard"; - } - - @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - // do nothing as soil is not managed by farm + public String getUnlocalizedName() { + return "for.farm.orchard"; } private Collection getHarvestBlocks(World world, BlockPos position) { @@ -145,7 +137,7 @@ public class FarmLogicOrchard extends FarmLogic { // Determine what type we want to harvest. IBlockState blockState = world.getBlockState(position); Block block = blockState.getBlock(); - if (!block.isWood(world, position) && !isBlockTraversable(blockState, traversalBlocks) && !isFruitBearer(world, position)) { + if (!block.isWood(world, position) && !isBlockTraversable(blockState, traversalBlocks) && !isFruitBearer(world, position, blockState)) { return crops; } @@ -192,11 +184,11 @@ public class FarmLogicOrchard extends FarmLogic { candidates.add(candidate); seen.add(candidate); } - if (isFruitBearer(world, candidate)) { + if (isFruitBearer(world, candidate, blockState)) { candidates.add(candidate); seen.add(candidate); - ICrop crop = getCrop(world, candidate); + ICrop crop = getCropAt(world, candidate); if (crop != null) { crops.push(crop); } @@ -208,14 +200,14 @@ public class FarmLogicOrchard extends FarmLogic { return candidates; } - private boolean isFruitBearer(World world, BlockPos position) { + private boolean isFruitBearer(World world, BlockPos position, IBlockState blockState) { IFruitBearer tile = TileUtil.getTile(world, position, IFruitBearer.class); if (tile != null) { return true; } - for (IFarmable farmable : farmables) { - if (farmable.isSaplingAt(world, position)) { + for (IFarmable farmable : getFarmables()) { + if (farmable.isSaplingAt(world, position, blockState)) { return true; } } @@ -234,8 +226,7 @@ public class FarmLogicOrchard extends FarmLogic { } @Nullable - private ICrop getCrop(World world, BlockPos position) { - + private ICrop getCropAt(World world, BlockPos position) { IFruitBearer fruitBearer = TileUtil.getTile(world, position, IFruitBearer.class); if (fruitBearer != null) { @@ -243,13 +234,7 @@ public class FarmLogicOrchard extends FarmLogic { return new CropFruit(world, position); } } else { - IBlockState blockState = world.getBlockState(position); - for (IFarmable seed : farmables) { - ICrop crop = seed.getCropAt(world, position, blockState); - if (crop != null) { - return crop; - } - } + return getCrop(world, position); } return null; } diff --git a/src/main/java/forestry/farming/logic/FarmLogicPeat.java b/src/main/java/forestry/farming/logic/FarmLogicPeat.java index 1bf4022eb..53974db9a 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicPeat.java +++ b/src/main/java/forestry/farming/logic/FarmLogicPeat.java @@ -21,23 +21,14 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmProperties; import forestry.core.ModuleCore; import forestry.core.blocks.BlockBogEarth; +import forestry.farming.logic.crops.CropPeat; public class FarmLogicPeat extends FarmLogicWatered { - private static final ItemStack bogEarth = ModuleCore.getBlocks().bogEarth.get(BlockBogEarth.SoilType.BOG_EARTH, 1); - - public FarmLogicPeat() { - super(bogEarth, ModuleCore.getBlocks().bogEarth.getDefaultState()); - } - - @Override - public boolean isAcceptedGround(IBlockState blockState) { - if (super.isAcceptedGround(blockState)) { - return true; - } - - return blockState.getBlock() == ModuleCore.getBlocks().bogEarth; + public FarmLogicPeat(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override @@ -46,12 +37,8 @@ public class FarmLogicPeat extends FarmLogicWatered { } @Override - public String getName() { - if (isManual) { - return "Manual Peat Bog"; - } else { - return "Managed Peat Bog"; - } + public String getUnlocalizedName() { + return "for.farm.peat"; } @Override diff --git a/src/main/java/forestry/farming/logic/FarmLogicExU.java b/src/main/java/forestry/farming/logic/FarmLogicRedOrchid.java similarity index 52% rename from src/main/java/forestry/farming/logic/FarmLogicExU.java rename to src/main/java/forestry/farming/logic/FarmLogicRedOrchid.java index 92cac7a94..1db5bec0c 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicExU.java +++ b/src/main/java/forestry/farming/logic/FarmLogicRedOrchid.java @@ -10,47 +10,32 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.Collection; -import java.util.Stack; - -import forestry.farming.FarmRegistry; -import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; -import net.minecraft.init.Blocks; -import net.minecraft.init.Items; -import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; + import forestry.api.farming.FarmDirection; -import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; -import forestry.api.farming.IFarmable; +import forestry.api.farming.IFarmProperties; import forestry.core.utils.BlockUtil; +import forestry.plugins.PluginExtraUtilities; -public class FarmLogicExU extends FarmLogicHomogeneous { +public class FarmLogicRedOrchid extends FarmLogicHomogeneous { - private final String name; - private final Item iconItem; - - public FarmLogicExU(String name, Item iconItem, Block soil, String farmablesKey) { - super(new ItemStack(soil), soil.getDefaultState(), FarmRegistry.getInstance().getFarmables(farmablesKey)); - if (soil.equals(Blocks.REDSTONE_ORE)) { - super.addSoil(new ItemStack(Blocks.LIT_REDSTONE_ORE), Blocks.LIT_REDSTONE_ORE.getDefaultState(), false); - } - this.name = name; - this.iconItem = iconItem; + public FarmLogicRedOrchid(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override - public String getName() { - return name; + public String getUnlocalizedName() { + return "for.farm.orchid"; } @Override public ItemStack getIconItemStack() { - return new ItemStack(iconItem); + return PluginExtraUtilities.orchidStack; } @Override @@ -68,25 +53,6 @@ public class FarmLogicExU extends FarmLogicHomogeneous { return NonNullList.create(); } - @Override - public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { - Stack crops = new Stack<>(); - for (int i = 0; i < extent; i++) { - BlockPos position = translateWithOffset(pos.up(), direction, i); - IBlockState blockState = world.getBlockState(position); - for (IFarmable farmable : farmables) { - ICrop crop = farmable.getCropAt(world, position, blockState); - if (crop != null) { - crops.push(crop); - break; - } - } - - } - return crops; - - } - @Override protected boolean maintainGermlings(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { for (int i = 0; i < extent; i++) { @@ -102,20 +68,9 @@ public class FarmLogicExU extends FarmLogicHomogeneous { continue; } - return trySetCrop(world, farmHousing, position); + return trySetCrop(world, farmHousing, position, direction); } return false; } - - private boolean trySetCrop(World world, IFarmHousing farmHousing, BlockPos position) { - for (IFarmable candidate : farmables) { - if (farmHousing.plantGermling(candidate, world, position)) { - return true; - } - } - - return false; - } - } diff --git a/src/main/java/forestry/farming/logic/FarmLogicReeds.java b/src/main/java/forestry/farming/logic/FarmLogicReeds.java index 986a72cca..7d87e7ce7 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicReeds.java +++ b/src/main/java/forestry/farming/logic/FarmLogicReeds.java @@ -10,45 +10,19 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Stack; - -import forestry.api.farming.FarmDirection; -import forestry.api.farming.ICrop; -import forestry.api.farming.IFarmHousing; -import forestry.api.farming.IFarmable; -import forestry.core.utils.ItemStackUtil; -import forestry.farming.FarmRegistry; -import net.minecraft.block.state.IBlockState; -import net.minecraft.init.Blocks; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; + import forestry.api.farming.FarmDirection; -import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; -import forestry.api.farming.IFarmable; -import forestry.farming.FarmRegistry; +import forestry.api.farming.IFarmProperties; -import forestry.api.core.ForestryAPI; -import forestry.api.farming.FarmDirection; -import forestry.api.farming.ICrop; -import forestry.api.farming.IFarmHousing; -import forestry.api.farming.IFarmable; -import forestry.core.utils.ItemStackUtil; - -public class FarmLogicReeds extends FarmLogic { - - private final Collection germlings = FarmRegistry.getInstance().getFarmables("farmPoales"); - private ArrayList soils = new ArrayList<>(); - - - public FarmLogicReeds() { - addSoil(new ItemStack(Blocks.SAND), Blocks.SAND.getDefaultState(),true); - addSoil(new ItemStack(Blocks.DIRT), Blocks.DIRT.getDefaultState(),false); +public class FarmLogicReeds extends FarmLogicSoil { + public FarmLogicReeds(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override @@ -57,17 +31,8 @@ public class FarmLogicReeds extends FarmLogic { } @Override - public String getName() { - if (isManual) { - return "Manual Reed Farm"; - } else { - return "Managed Reed Farm"; - } - } - - @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - this.soils.add(new Soil(resource,soilState,hasMetaData)); + public String getUnlocalizedName() { + return "for.farm.reed"; } @Override @@ -81,18 +46,12 @@ public class FarmLogicReeds extends FarmLogic { } @Override - public boolean isAcceptedResource(ItemStack itemstack) { + public boolean isAcceptedResource(ItemStack itemStack) { if (isManual) { return false; } - for(Soil soil : soils){ - ItemStack resource = soil.getResource(); - if(resource.isItemEqual(itemstack)){ - return true; - } - } - return false; + return super.isAcceptedResource(itemStack); } @@ -120,21 +79,4 @@ public class FarmLogicReeds extends FarmLogic { return false; } - @Override - public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { - Stack crops = new Stack<>(); - for (int i = 0; i < extent; i++) { - BlockPos position = translateWithOffset(pos.up(), direction, i); - IBlockState blockState = world.getBlockState(position); - for (IFarmable seed : germlings) { - ICrop crop = seed.getCropAt(world, position, blockState); - if (crop != null) { - crops.push(crop); - break; - } - } - } - return crops; - } - } diff --git a/src/main/java/forestry/farming/logic/FarmLogicRubber.java b/src/main/java/forestry/farming/logic/FarmLogicRubber.java index 3e9cb8df0..efedb5fc9 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicRubber.java +++ b/src/main/java/forestry/farming/logic/FarmLogicRubber.java @@ -25,15 +25,18 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; import forestry.core.utils.ItemStackUtil; import forestry.core.utils.Log; +import forestry.farming.logic.crops.CropRubber; import forestry.plugins.PluginIC2; public class FarmLogicRubber extends FarmLogic { private boolean active = true; - public FarmLogicRubber() { + public FarmLogicRubber(IFarmProperties properties, boolean isManual) { + super(properties, isManual); if (PluginIC2.rubberWood == null || PluginIC2.resin == null) { Log.warning("Failed to init a farm logic {} since IC2 rubber wood or resin were not found", getClass().getName()); active = false; @@ -46,8 +49,8 @@ public class FarmLogicRubber extends FarmLogic { } @Override - public String getName() { - return "Rubber Plantation"; + public String getUnlocalizedName() { + return "for.farm.rubber"; } @Override @@ -131,9 +134,4 @@ public class FarmLogicRubber extends FarmLogic { return crops; } - @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - // do nothing as soil is not managed by farm - } - } diff --git a/src/main/java/forestry/farming/logic/FarmLogicSimple.java b/src/main/java/forestry/farming/logic/FarmLogicSimple.java index feb2f3a5b..44d2d0a99 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicSimple.java +++ b/src/main/java/forestry/farming/logic/FarmLogicSimple.java @@ -1,14 +1,16 @@ package forestry.farming.logic; -import forestry.api.farming.ISimpleFarmLogic; import net.minecraft.item.ItemStack; +import forestry.api.farming.IFarmProperties; +import forestry.api.farming.ISimpleFarmLogic; + public class FarmLogicSimple extends FarmLogicCrops { - protected final ISimpleFarmLogic simpleLogic; - - public FarmLogicSimple(ISimpleFarmLogic simpleLogic) { - super(simpleLogic.getSeeds()); + private final ISimpleFarmLogic simpleLogic; + + public FarmLogicSimple(IFarmProperties instance, boolean isManual, ISimpleFarmLogic simpleLogic) { + super(instance, isManual); this.simpleLogic = simpleLogic; } diff --git a/src/main/java/forestry/farming/logic/FarmLogicSoil.java b/src/main/java/forestry/farming/logic/FarmLogicSoil.java new file mode 100644 index 000000000..5df2eed90 --- /dev/null +++ b/src/main/java/forestry/farming/logic/FarmLogicSoil.java @@ -0,0 +1,23 @@ +package forestry.farming.logic; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; + +import forestry.api.farming.IFarmProperties; + +public abstract class FarmLogicSoil extends FarmLogic { + + public FarmLogicSoil(IFarmProperties properties, boolean isManual) { + super(properties, isManual); + } + + protected boolean isAcceptedSoil(IBlockState blockState) { + return properties.isAcceptedSoil(blockState); + } + + @Override + public boolean isAcceptedResource(ItemStack itemStack) { + return properties.isAcceptedResource(itemStack); + } + +} diff --git a/src/main/java/forestry/farming/logic/FarmLogicSucculent.java b/src/main/java/forestry/farming/logic/FarmLogicSucculent.java index e53b76870..a394b98b1 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicSucculent.java +++ b/src/main/java/forestry/farming/logic/FarmLogicSucculent.java @@ -10,52 +10,33 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Stack; - -import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; -import forestry.api.farming.FarmDirection; -import forestry.api.farming.ICrop; -import forestry.api.farming.IFarmHousing; -import forestry.api.farming.IFarmable; -import forestry.core.utils.ItemStackUtil; -import forestry.farming.FarmRegistry; -public class FarmLogicSucculent extends FarmLogic { - - private final Collection germlings = FarmRegistry.getInstance().getFarmables("farmSucculentes"); - private ArrayList soils = new ArrayList<>(); - - public FarmLogicSucculent() { - addSoil(new ItemStack(Blocks.SAND), Blocks.SAND.getDefaultState(),true); +import forestry.api.farming.FarmDirection; +import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; +import forestry.core.utils.ItemStackUtil; + +public class FarmLogicSucculent extends FarmLogicSoil { + public FarmLogicSucculent(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } - + @Override public ItemStack getIconItemStack() { return new ItemStack(Items.DYE, 1, 2); } @Override - public String getName() { - if (isManual) { - return "Manual Succulent Farm"; - } else { - return "Managed Succulent Farm"; - } + public String getUnlocalizedName() { + return "for.farm.succulent"; } - @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - this.soils.add(new Soil(resource,soilState,hasMetaData)); - } - @Override public int getFertilizerConsumption() { return 10; @@ -65,20 +46,14 @@ public class FarmLogicSucculent extends FarmLogic { public int getWaterConsumption(float hydrationModifier) { return 1; } - + @Override - public boolean isAcceptedResource(ItemStack itemstack) { + public boolean isAcceptedResource(ItemStack itemStack) { if (isManual) { return false; } - for(Soil soil : soils){ - ItemStack resource = soil.getResource(); - if(resource.isItemEqual(itemstack)) { - return true; - } - } - return false; + return super.isAcceptedResource(itemStack); } @Override @@ -105,21 +80,4 @@ public class FarmLogicSucculent extends FarmLogic { return false; } - @Override - public Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent) { - Stack crops = new Stack<>(); - for (int i = 0; i < extent; i++) { - BlockPos position = translateWithOffset(pos.up(), direction, i); - IBlockState blockState = world.getBlockState(position); - for (IFarmable seed : germlings) { - ICrop crop = seed.getCropAt(world, position, blockState); - if (crop != null) { - crops.push(crop); - break; - } - } - } - return crops; - } - } diff --git a/src/main/java/forestry/farming/logic/FarmLogicVegetable.java b/src/main/java/forestry/farming/logic/FarmLogicVegetable.java deleted file mode 100755 index 7a7fda24f..000000000 --- a/src/main/java/forestry/farming/logic/FarmLogicVegetable.java +++ /dev/null @@ -1,38 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2011-2014 SirSengir. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser Public License v3 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl-3.0.txt - * - * Various Contributors including, but not limited to: - * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges - ******************************************************************************/ -package forestry.farming.logic; - -import net.minecraft.init.Items; -import net.minecraft.item.ItemStack; - -import forestry.farming.FarmRegistry; - -public class FarmLogicVegetable extends FarmLogicCrops { - - public FarmLogicVegetable() { - super(FarmRegistry.getInstance().getFarmables("farmVegetables")); - } - - @Override - public ItemStack getIconItemStack() { - return new ItemStack(Items.CARROT); - } - - @Override - public String getName() { - if (isManual) { - return "Manual Vegetable Farm"; - } else { - return "Managed Vegetable Farm"; - } - } - -} diff --git a/src/main/java/forestry/farming/logic/FarmLogicWatered.java b/src/main/java/forestry/farming/logic/FarmLogicWatered.java index 7102a54b0..645e0ff9e 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicWatered.java +++ b/src/main/java/forestry/farming/logic/FarmLogicWatered.java @@ -10,40 +10,30 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.ArrayList; -import java.util.List; - -import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; + import net.minecraftforge.fluids.Fluid; import net.minecraftforge.fluids.FluidRegistry; import net.minecraftforge.fluids.FluidStack; + import forestry.api.farming.FarmDirection; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmProperties; +import forestry.api.farming.ISoil; import forestry.core.utils.BlockUtil; -import forestry.farming.FarmHelper; -public abstract class FarmLogicWatered extends FarmLogic { - - - private final List soils = new ArrayList<>(); - +public abstract class FarmLogicWatered extends FarmLogicSoil { private static final FluidStack STACK_WATER = new FluidStack(FluidRegistry.WATER, Fluid.BUCKET_VOLUME); protected NonNullList produce = NonNullList.create(); - protected FarmLogicWatered(ItemStack resource, IBlockState ground) { - addSoil(resource,ground,false); - } - - @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - soils.add(new Soil(resource,soilState,hasMetaData)); + public FarmLogicWatered(IFarmProperties properties, boolean isManual) { + super(properties, isManual); } @Override @@ -56,31 +46,6 @@ public abstract class FarmLogicWatered extends FarmLogic { return (int) (20 * hydrationModifier); } - protected boolean isAcceptedGround(IBlockState ground) { - for(Soil soil : soils){ - IBlockState soilState = soil.getSoilState(); - Block soilBlock = soilState.getBlock(); - Block block = ground.getBlock(); - if(soilState.getBlock() == ground.getBlock()){ - if(!soil.hasMetaData() || block.getMetaFromState(ground) == soilBlock.getMetaFromState(soilState)){ - return true; - } - } - } - return false; - } - - @Override - public boolean isAcceptedResource(ItemStack itemstack) { - for(Soil soil : soils){ - ItemStack resource = soil.getResource(); - if(resource.isItemEqual(itemstack)){ - return true; - } - } - return false; - } - @Override public NonNullList collect(World world, IFarmHousing farmHousing) { NonNullList products = produce; @@ -90,7 +55,6 @@ public abstract class FarmLogicWatered extends FarmLogic { @Override public boolean cultivate(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { - if (maintainSoil(world, farmHousing, pos, direction, extent)) { return true; } @@ -99,42 +63,42 @@ public abstract class FarmLogicWatered extends FarmLogic { return true; } - if (maintainCrops(world, farmHousing, pos.up(), direction, extent)) { - return true; - } + return maintainCrops(world, farmHousing, pos.up(), direction, extent); - return false; } private boolean maintainSoil(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { - for (Soil soil : soils) { + if (!farmHousing.canPlantSoil(isManual)) { + return false; + } + + for (ISoil soil : getSoils()) { NonNullList resources = NonNullList.create(); resources.add(soil.getResource()); for (int i = 0; i < extent; i++) { BlockPos position = translateWithOffset(pos, direction, i); IBlockState state = world.getBlockState(position); - if (isAcceptedGround(state) || isWaterSourceBlock(world, position) || !farmHousing.getFarmInventory().hasResources(resources)) { + if (isAcceptedSoil(state) || isWaterSourceBlock(world, position) || !farmHousing.getFarmInventory().hasResources(resources)) { continue; } - + BlockPos platformPosition = position.down(); - IBlockState blockState = world.getBlockState(platformPosition); - if (!FarmHelper.bricks.contains(blockState.getBlock())) { + if (!farmHousing.isValidPlatform(world, platformPosition)) { break; } - + if (!BlockUtil.isReplaceableBlock(state, world, position)) { produce.addAll(BlockUtil.getBlockDrops(world, position)); world.setBlockToAir(position); return trySetSoil(world, farmHousing, position, soil.getResource(), soil.getSoilState()); } - + if (!isManual) { if (trySetWater(world, farmHousing, position)) { return true; } - + return trySetSoil(world, farmHousing, position, soil.getResource(), soil.getSoilState()); } } @@ -149,8 +113,7 @@ public abstract class FarmLogicWatered extends FarmLogic { BlockPos position = translateWithOffset(pos, direction, i); BlockPos platformPosition = position.down(); - IBlockState blockState = world.getBlockState(platformPosition); - if (!FarmHelper.bricks.contains(blockState.getBlock())) { + if (!farmHousing.isValidPlatform(world, platformPosition)) { break; } diff --git a/src/main/java/forestry/farming/logic/FarmProperties.java b/src/main/java/forestry/farming/logic/FarmProperties.java new file mode 100644 index 000000000..f83d02774 --- /dev/null +++ b/src/main/java/forestry/farming/logic/FarmProperties.java @@ -0,0 +1,91 @@ +package forestry.farming.logic; + +import javax.annotation.Nullable; +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; +import java.util.function.BiFunction; +import java.util.stream.Collectors; + +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; + +import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmProperties; +import forestry.api.farming.IFarmable; +import forestry.api.farming.ISoil; +import forestry.farming.FarmRegistry; + +public final class FarmProperties implements IFarmProperties { + private final Set soils = new HashSet<>(); + private final Set farmablesIdentifiers; + private final IFarmLogic manualLogic; + private final IFarmLogic managedLogic; + + @Nullable + private Collection farmables; + + public FarmProperties(BiFunction logicFactory, Set farmablesIdentifiers) { + this.farmablesIdentifiers = farmablesIdentifiers; + this.manualLogic = logicFactory.apply(this, true); + this.managedLogic = logicFactory.apply(this, false); + } + + @Override + public void registerFarmables(String identifier) { + farmablesIdentifiers.add(identifier); + } + + @Override + public Collection getFarmables() { + if (farmables == null) { + farmables = farmablesIdentifiers.stream() + .map(FarmRegistry.getInstance()::getFarmables) + .flatMap(Collection::stream) + .collect(Collectors.toSet()); + } + return farmables; + } + + @Override + public IFarmLogic getLogic(boolean manuel) { + return manuel ? manualLogic : managedLogic; + } + + @Override + public void registerSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { + soils.add(new Soil(resource, soilState, hasMetaData)); + } + + @Override + public boolean isAcceptedSoil(IBlockState ground) { + for (ISoil soil : soils) { + IBlockState soilState = soil.getSoilState(); + Block soilBlock = soilState.getBlock(); + Block block = ground.getBlock(); + if (soilState.getBlock() == ground.getBlock()) { + if (!soil.hasMetaData() || block.getMetaFromState(ground) == soilBlock.getMetaFromState(soilState)) { + return true; + } + } + } + return false; + } + + @Override + public boolean isAcceptedResource(ItemStack itemstack) { + for (ISoil soil : soils) { + ItemStack resource = soil.getResource(); + if (resource.isItemEqual(itemstack)) { + return true; + } + } + return false; + } + + @Override + public Collection getSoils() { + return soils; + } +} diff --git a/src/main/java/forestry/farming/logic/FarmableSapling.java b/src/main/java/forestry/farming/logic/FarmableSapling.java deleted file mode 100644 index cd3d2553d..000000000 --- a/src/main/java/forestry/farming/logic/FarmableSapling.java +++ /dev/null @@ -1,93 +0,0 @@ -/******************************************************************************* - * Copyright (c) 2011-2014 SirSengir. - * All rights reserved. This program and the accompanying materials - * are made available under the terms of the GNU Lesser Public License v3 - * which accompanies this distribution, and is available at - * http://www.gnu.org/licenses/lgpl-3.0.txt - * - * Various Contributors including, but not limited to: - * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges - ******************************************************************************/ -package forestry.farming.logic; - -import net.minecraft.block.Block; -import net.minecraft.block.state.IBlockState; -import net.minecraft.entity.player.EntityPlayer; -import net.minecraft.init.Blocks; -import net.minecraft.item.ItemStack; -import net.minecraft.util.EnumActionResult; -import net.minecraft.util.EnumFacing; -import net.minecraft.util.EnumHand; -import net.minecraft.util.math.BlockPos; -import net.minecraft.world.World; - -import forestry.api.farming.ICrop; -import forestry.api.farming.IFarmable; -import forestry.core.network.packets.PacketFXSignal; -import forestry.core.utils.ItemStackUtil; -import forestry.core.utils.NetworkUtil; - -public class FarmableSapling implements IFarmable { - protected final ItemStack germling; - protected final boolean ignoreMetadata; - protected final Block saplingBlock; - protected final ItemStack[] windfall; - - public FarmableSapling(final ItemStack germling, final ItemStack[] windfall) { - this(germling, windfall, true); - } - - public FarmableSapling(final ItemStack germling, final ItemStack[] windfall, boolean addSubItems) { - this.germling = germling; - this.windfall = windfall; - this.saplingBlock = ItemStackUtil.getBlock(germling); - this.ignoreMetadata = addSubItems; - } - - @Override - public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, BlockPos pos) { - ItemStack copy = germling.copy(); - player.setHeldItem(EnumHand.MAIN_HAND, copy); - EnumActionResult actionResult = copy.onItemUse(player, world, pos.down(), EnumHand.MAIN_HAND, EnumFacing.UP, 0, 0, 0); - player.setHeldItem(EnumHand.MAIN_HAND, ItemStack.EMPTY); - if (actionResult == EnumActionResult.SUCCESS) { - PacketFXSignal packet = new PacketFXSignal(PacketFXSignal.SoundFXType.BLOCK_PLACE, pos, Blocks.SAPLING.getDefaultState()); - NetworkUtil.sendNetworkPacket(packet, pos, world); - return true; - } - return false; - } - - @Override - public boolean isSaplingAt(World world, BlockPos pos) { - return world.getBlockState(pos).getBlock() == this.saplingBlock; - } - - @Override - public ICrop getCropAt(World world, BlockPos pos, IBlockState blockState) { - Block block = blockState.getBlock(); - if (!block.isWood(world, pos)) { - return null; - } - - return new CropDestroy(world, blockState, pos, null); - } - - @Override - public boolean isGermling(ItemStack itemstack) { - if (ignoreMetadata) { - return ItemStack.areItemsEqual(germling, new ItemStack((itemstack.getItem()))); - } - return ItemStack.areItemsEqual(germling, itemstack); - } - - @Override - public boolean isWindfall(ItemStack itemstack) { - for (ItemStack drop : windfall) { - if (drop.isItemEqual(itemstack)) { - return true; - } - } - return false; - } -} diff --git a/src/main/java/forestry/farming/logic/Soil.java b/src/main/java/forestry/farming/logic/Soil.java index 19fe7a77d..cb5334e16 100644 --- a/src/main/java/forestry/farming/logic/Soil.java +++ b/src/main/java/forestry/farming/logic/Soil.java @@ -1,28 +1,30 @@ -package forestry.farming.logic; - -import net.minecraft.block.state.IBlockState; -import net.minecraft.item.ItemStack; - -class Soil { - private final ItemStack resource; - private final IBlockState soilState; - private final boolean hasMetaData; - - public Soil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - this.resource = resource; - this.soilState = soilState; - this.hasMetaData = hasMetaData; - } - - public ItemStack getResource() { - return resource; - } - - public IBlockState getSoilState() { - return soilState; - } - - public boolean hasMetaData() { - return this.hasMetaData; - } +package forestry.farming.logic; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; + +import forestry.api.farming.ISoil; + +class Soil implements ISoil { + private final ItemStack resource; + private final IBlockState soilState; + private final boolean hasMetaData; + + public Soil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { + this.resource = resource; + this.soilState = soilState; + this.hasMetaData = hasMetaData; + } + + public ItemStack getResource() { + return resource; + } + + public IBlockState getSoilState() { + return soilState; + } + + public boolean hasMetaData() { + return this.hasMetaData; + } } \ No newline at end of file diff --git a/src/main/java/forestry/farming/logic/Crop.java b/src/main/java/forestry/farming/logic/crops/Crop.java old mode 100755 new mode 100644 similarity index 97% rename from src/main/java/forestry/farming/logic/Crop.java rename to src/main/java/forestry/farming/logic/crops/Crop.java index fc2e1636a..9cb0ba818 --- a/src/main/java/forestry/farming/logic/Crop.java +++ b/src/main/java/forestry/farming/logic/crops/Crop.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.crops; import javax.annotation.Nullable; diff --git a/src/main/java/forestry/farming/logic/CropBasicAgriCraft.java b/src/main/java/forestry/farming/logic/crops/CropBasicAgriCraft.java similarity index 98% rename from src/main/java/forestry/farming/logic/CropBasicAgriCraft.java rename to src/main/java/forestry/farming/logic/crops/CropBasicAgriCraft.java index b17359173..6ec4cf8ef 100644 --- a/src/main/java/forestry/farming/logic/CropBasicAgriCraft.java +++ b/src/main/java/forestry/farming/logic/crops/CropBasicAgriCraft.java @@ -8,9 +8,8 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.crops; -import forestry.core.utils.BlockUtil; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; @@ -18,6 +17,8 @@ import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import forestry.core.utils.BlockUtil; + public class CropBasicAgriCraft extends Crop { private final IBlockState blockState; diff --git a/src/main/java/forestry/farming/logic/CropBasicGrowthCraft.java b/src/main/java/forestry/farming/logic/crops/CropBasicGrowthCraft.java similarity index 98% rename from src/main/java/forestry/farming/logic/CropBasicGrowthCraft.java rename to src/main/java/forestry/farming/logic/crops/CropBasicGrowthCraft.java index 811d54d70..59b2401cc 100644 --- a/src/main/java/forestry/farming/logic/CropBasicGrowthCraft.java +++ b/src/main/java/forestry/farming/logic/crops/CropBasicGrowthCraft.java @@ -8,11 +8,8 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.crops; -import forestry.core.config.Constants; -import forestry.core.network.packets.PacketFXSignal; -import forestry.core.utils.NetworkUtil; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; @@ -20,6 +17,10 @@ import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import forestry.core.config.Constants; +import forestry.core.network.packets.PacketFXSignal; +import forestry.core.utils.NetworkUtil; + public class CropBasicGrowthCraft extends Crop { private final IBlockState blockState; diff --git a/src/main/java/forestry/farming/logic/CropBasicIC2Crop.java b/src/main/java/forestry/farming/logic/crops/CropBasicIC2Crop.java similarity index 95% rename from src/main/java/forestry/farming/logic/CropBasicIC2Crop.java rename to src/main/java/forestry/farming/logic/crops/CropBasicIC2Crop.java index 64cc5315e..6fcbec840 100644 --- a/src/main/java/forestry/farming/logic/CropBasicIC2Crop.java +++ b/src/main/java/forestry/farming/logic/crops/CropBasicIC2Crop.java @@ -1,4 +1,4 @@ -package forestry.farming.logic; +package forestry.farming.logic.crops; import javax.annotation.Nonnull; @@ -12,7 +12,6 @@ import net.minecraft.world.World; import net.minecraftforge.fml.common.Optional; import forestry.plugins.PluginIC2; - import ic2.api.crops.ICropTile; public class CropBasicIC2Crop extends Crop { @@ -35,19 +34,18 @@ public class CropBasicIC2Crop extends Crop { /** * Check if there is an instance of ICropTile. + * * @param tileEntity tile entity to be checked. * @return true if there is an IC2 crop and false otherwise. */ @Optional.Method(modid = PluginIC2.modId) public static boolean isIC2Crop(TileEntity tileEntity) { - if (tileEntity instanceof ICropTile) { - return true; - } - return false; + return tileEntity instanceof ICropTile; } /** * Check if an IC2 crop is ready to be harvested. + * * @param tileEntity tile entity to be checked. * @return true if crop size is optimal for harvest and false otherwise. */ @@ -68,6 +66,7 @@ public class CropBasicIC2Crop extends Crop { /** * This function takes care of everything related to the harvesting of the * crop meaning it will calculate the drops and also do setSizeAfterHarvest(). + * * @param tileEntity tile entity to be checked. * @return list containing the drops. */ diff --git a/src/main/java/forestry/farming/logic/crops/CropChorusFlower.java b/src/main/java/forestry/farming/logic/crops/CropChorusFlower.java new file mode 100644 index 000000000..ff105a7b0 --- /dev/null +++ b/src/main/java/forestry/farming/logic/crops/CropChorusFlower.java @@ -0,0 +1,42 @@ +package forestry.farming.logic.crops; + +import net.minecraft.block.state.IBlockState; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import net.minecraftforge.event.ForgeEventFactory; + +import forestry.core.network.packets.PacketFXSignal; +import forestry.core.utils.NetworkUtil; + +public class CropChorusFlower extends Crop { + private static final IBlockState BLOCK_STATE = Blocks.CHORUS_FLOWER.getDefaultState(); + + public CropChorusFlower(World world, BlockPos position) { + super(world, position); + } + + @Override + protected boolean isCrop(World world, BlockPos pos) { + return world.getBlockState(pos).getBlock() == Blocks.CHORUS_FLOWER; + } + + @Override + protected NonNullList harvestBlock(World world, BlockPos pos) { + NonNullList harvested = NonNullList.create(); + harvested.add(new ItemStack(Blocks.CHORUS_FLOWER)); + float chance = ForgeEventFactory.fireBlockHarvesting(harvested, world, pos, BLOCK_STATE, 0, 1.0F, false, null); + + harvested.removeIf(next -> world.rand.nextFloat() > chance); + + PacketFXSignal packet = new PacketFXSignal(PacketFXSignal.VisualFXType.BLOCK_BREAK, PacketFXSignal.SoundFXType.BLOCK_BREAK, pos, BLOCK_STATE); + NetworkUtil.sendNetworkPacket(packet, pos, world); + + world.setBlockToAir(pos); + + return harvested; + } +} diff --git a/src/main/java/forestry/farming/logic/CropDestroy.java b/src/main/java/forestry/farming/logic/crops/CropDestroy.java similarity index 68% rename from src/main/java/forestry/farming/logic/CropDestroy.java rename to src/main/java/forestry/farming/logic/crops/CropDestroy.java index 96f30285b..c717f13d0 100644 --- a/src/main/java/forestry/farming/logic/CropDestroy.java +++ b/src/main/java/forestry/farming/logic/crops/CropDestroy.java @@ -8,13 +8,11 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.crops; import javax.annotation.Nullable; +import java.util.Iterator; -import forestry.core.config.Constants; -import forestry.core.network.packets.PacketFXSignal; -import forestry.core.utils.NetworkUtil; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; @@ -22,16 +20,30 @@ import net.minecraft.util.NonNullList; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import net.minecraftforge.event.ForgeEventFactory; + +import forestry.core.config.Constants; +import forestry.core.network.packets.PacketFXSignal; +import forestry.core.utils.ItemStackUtil; +import forestry.core.utils.NetworkUtil; + public class CropDestroy extends Crop { protected final IBlockState blockState; @Nullable protected final IBlockState replantState; + protected final ItemStack germling; + public CropDestroy(World world, IBlockState blockState, BlockPos position, @Nullable IBlockState replantState) { + this(world, blockState, position, replantState, ItemStack.EMPTY); + } + + public CropDestroy(World world, IBlockState blockState, BlockPos position, @Nullable IBlockState replantState, ItemStack germling) { super(world, position); this.blockState = blockState; this.replantState = replantState; + this.germling = germling; } @Override @@ -44,6 +56,24 @@ public class CropDestroy extends Crop { Block block = blockState.getBlock(); NonNullList harvested = NonNullList.create(); harvested.addAll(block.getDrops(world, pos, blockState, 0)); + float chance = ForgeEventFactory.fireBlockHarvesting(harvested, world, pos, blockState, 0, 1.0F, false, null); + + boolean removedSeed = germling.isEmpty(); + Iterator dropIterator = harvested.iterator(); + while (dropIterator.hasNext()) { + ItemStack next = dropIterator.next(); + if (world.rand.nextFloat() <= chance) { + if (!removedSeed && ItemStackUtil.isIdenticalItem(next, germling)) { + next.shrink(1); + if (next.isEmpty()) { + dropIterator.remove(); + } + removedSeed = true; + } + } else { + dropIterator.remove(); + } + } PacketFXSignal packet = new PacketFXSignal(PacketFXSignal.VisualFXType.BLOCK_BREAK, PacketFXSignal.SoundFXType.BLOCK_BREAK, pos, blockState); NetworkUtil.sendNetworkPacket(packet, pos, world); diff --git a/src/main/java/forestry/farming/logic/CropDestroyDouble.java b/src/main/java/forestry/farming/logic/crops/CropDestroyDouble.java similarity index 91% rename from src/main/java/forestry/farming/logic/CropDestroyDouble.java rename to src/main/java/forestry/farming/logic/crops/CropDestroyDouble.java index d8a21ff52..fea34f0ae 100644 --- a/src/main/java/forestry/farming/logic/CropDestroyDouble.java +++ b/src/main/java/forestry/farming/logic/crops/CropDestroyDouble.java @@ -1,4 +1,4 @@ -package forestry.farming.logic; +package forestry.farming.logic.crops; import javax.annotation.Nullable; @@ -37,8 +37,8 @@ public class CropDestroyDouble extends Crop { Block block = blockState.getBlock(); Block blockUp = blockStateUp.getBlock(); NonNullList harvested = NonNullList.create(); - harvested.addAll(block.getDrops(world, pos, blockState, 0)); - harvested.addAll(blockUp.getDrops(world, pos.up(), blockStateUp, 0)); + block.getDrops(harvested, world, pos, blockState, 0); + blockUp.getDrops(harvested, world, pos.up(), blockStateUp, 0); PacketFXSignal packet = new PacketFXSignal(PacketFXSignal.VisualFXType.BLOCK_BREAK, PacketFXSignal.SoundFXType.BLOCK_BREAK, pos, blockState); NetworkUtil.sendNetworkPacket(packet, pos, world); diff --git a/src/main/java/forestry/farming/logic/CropFruit.java b/src/main/java/forestry/farming/logic/crops/CropFruit.java old mode 100755 new mode 100644 similarity index 97% rename from src/main/java/forestry/farming/logic/CropFruit.java rename to src/main/java/forestry/farming/logic/crops/CropFruit.java index 880cee929..27304ce1d --- a/src/main/java/forestry/farming/logic/CropFruit.java +++ b/src/main/java/forestry/farming/logic/crops/CropFruit.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.crops; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; diff --git a/src/main/java/forestry/farming/logic/CropPeat.java b/src/main/java/forestry/farming/logic/crops/CropPeat.java old mode 100755 new mode 100644 similarity index 98% rename from src/main/java/forestry/farming/logic/CropPeat.java rename to src/main/java/forestry/farming/logic/crops/CropPeat.java index c92659ede..a0ad615ec --- a/src/main/java/forestry/farming/logic/CropPeat.java +++ b/src/main/java/forestry/farming/logic/crops/CropPeat.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.crops; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; diff --git a/src/main/java/forestry/farming/logic/CropRubber.java b/src/main/java/forestry/farming/logic/crops/CropRubber.java old mode 100755 new mode 100644 similarity index 98% rename from src/main/java/forestry/farming/logic/CropRubber.java rename to src/main/java/forestry/farming/logic/crops/CropRubber.java index dc11ef1e2..47572d1e2 --- a/src/main/java/forestry/farming/logic/CropRubber.java +++ b/src/main/java/forestry/farming/logic/crops/CropRubber.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.crops; import com.google.common.base.Optional; import com.google.common.collect.ImmutableCollection; diff --git a/src/main/java/forestry/farming/logic/crops/package-info.java b/src/main/java/forestry/farming/logic/crops/package-info.java new file mode 100644 index 000000000..479c24953 --- /dev/null +++ b/src/main/java/forestry/farming/logic/crops/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.farming.logic.crops; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/farming/logic/FarmableAgingCrop.java b/src/main/java/forestry/farming/logic/farmables/FarmableAgingCrop.java similarity index 91% rename from src/main/java/forestry/farming/logic/FarmableAgingCrop.java rename to src/main/java/forestry/farming/logic/farmables/FarmableAgingCrop.java index 222dec7a8..ab1af6c98 100644 --- a/src/main/java/forestry/farming/logic/FarmableAgingCrop.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableAgingCrop.java @@ -1,11 +1,9 @@ -package forestry.farming.logic; +package forestry.farming.logic.farmables; + +import com.google.common.base.Preconditions; import javax.annotation.Nullable; -import com.google.common.base.Preconditions; -import forestry.api.farming.ICrop; -import forestry.api.farming.IFarmable; -import forestry.core.utils.BlockUtil; import net.minecraft.block.Block; import net.minecraft.block.properties.IProperty; import net.minecraft.block.state.IBlockState; @@ -14,6 +12,11 @@ import net.minecraft.item.ItemStack; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmable; +import forestry.core.utils.BlockUtil; +import forestry.farming.logic.crops.CropDestroy; + /** * For blocks that are harvestable once they are a certain age. */ @@ -42,8 +45,7 @@ public class FarmableAgingCrop implements IFarmable { } @Override - public boolean isSaplingAt(World world, BlockPos pos) { - IBlockState blockState = world.getBlockState(pos); + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { return blockState.getBlock() == cropBlock && blockState.getValue(ageProperty) <= minHarvestAge; } @@ -59,7 +61,7 @@ public class FarmableAgingCrop implements IFarmable { } IBlockState replantState = getReplantState(blockState); - return new CropDestroy(world, blockState, pos, replantState); + return new CropDestroy(world, blockState, pos, replantState, germling); } @Nullable diff --git a/src/main/java/forestry/farming/logic/FarmableBase.java b/src/main/java/forestry/farming/logic/farmables/FarmableBase.java similarity index 89% rename from src/main/java/forestry/farming/logic/FarmableBase.java rename to src/main/java/forestry/farming/logic/farmables/FarmableBase.java index 01dccc01e..857a34ac5 100644 --- a/src/main/java/forestry/farming/logic/FarmableBase.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableBase.java @@ -1,14 +1,16 @@ -package forestry.farming.logic; +package forestry.farming.logic.farmables; -import forestry.api.farming.ICrop; -import forestry.api.farming.IFarmable; -import forestry.core.utils.BlockUtil; import net.minecraft.block.state.IBlockState; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemStack; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmable; +import forestry.core.utils.BlockUtil; +import forestry.farming.logic.crops.CropDestroy; + public abstract class FarmableBase implements IFarmable { protected final ItemStack germling; protected final IBlockState plantedState; @@ -23,8 +25,7 @@ public abstract class FarmableBase implements IFarmable { } @Override - public boolean isSaplingAt(World world, BlockPos pos) { - IBlockState blockState = world.getBlockState(pos); + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { return blockState.getBlock() == plantedState.getBlock() && blockState != matureState; } diff --git a/src/main/java/forestry/farming/logic/FarmableBasicAgricraft.java b/src/main/java/forestry/farming/logic/farmables/FarmableBasicAgricraft.java similarity index 92% rename from src/main/java/forestry/farming/logic/FarmableBasicAgricraft.java rename to src/main/java/forestry/farming/logic/farmables/FarmableBasicAgricraft.java index a3391c911..a13a4e1ea 100644 --- a/src/main/java/forestry/farming/logic/FarmableBasicAgricraft.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableBasicAgricraft.java @@ -8,14 +8,16 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.farmables; -import forestry.api.farming.ICrop; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import forestry.api.farming.ICrop; +import forestry.farming.logic.crops.CropBasicAgriCraft; + public class FarmableBasicAgricraft extends FarmableBase { public FarmableBasicAgricraft(ItemStack germling, IBlockState plantedState, IBlockState matureState, boolean replant) { super(germling, plantedState, matureState, replant); diff --git a/src/main/java/forestry/farming/logic/FarmableBasicGrowthCraft.java b/src/main/java/forestry/farming/logic/farmables/FarmableBasicGrowthCraft.java similarity index 97% rename from src/main/java/forestry/farming/logic/FarmableBasicGrowthCraft.java rename to src/main/java/forestry/farming/logic/farmables/FarmableBasicGrowthCraft.java index fe5c42420..c3e863f8a 100644 --- a/src/main/java/forestry/farming/logic/FarmableBasicGrowthCraft.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableBasicGrowthCraft.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.farmables; //TODO GrowthCraft for 1.9 public class FarmableBasicGrowthCraft { diff --git a/src/main/java/forestry/farming/logic/FarmableBasicIC2Crop.java b/src/main/java/forestry/farming/logic/farmables/FarmableBasicIC2Crop.java similarity index 95% rename from src/main/java/forestry/farming/logic/FarmableBasicIC2Crop.java rename to src/main/java/forestry/farming/logic/farmables/FarmableBasicIC2Crop.java index 944792619..42627e27c 100644 --- a/src/main/java/forestry/farming/logic/FarmableBasicIC2Crop.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableBasicIC2Crop.java @@ -1,4 +1,4 @@ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import javax.annotation.Nullable; @@ -13,8 +13,8 @@ import net.minecraftforge.fml.common.Optional; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmable; +import forestry.farming.logic.crops.CropBasicIC2Crop; import forestry.plugins.PluginIC2; - import ic2.api.crops.ICropTile; public class FarmableBasicIC2Crop implements IFarmable { diff --git a/src/main/java/forestry/farming/logic/farmables/FarmableChorus.java b/src/main/java/forestry/farming/logic/farmables/FarmableChorus.java new file mode 100644 index 000000000..b68b874f4 --- /dev/null +++ b/src/main/java/forestry/farming/logic/farmables/FarmableChorus.java @@ -0,0 +1,80 @@ +package forestry.farming.logic.farmables; + +import javax.annotation.Nullable; + +import net.minecraft.block.BlockChorusFlower; +import net.minecraft.block.state.IBlockState; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.init.Items; +import net.minecraft.item.ItemStack; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmable; +import forestry.core.utils.BlockUtil; +import forestry.farming.logic.crops.CropChorusFlower; + +public class FarmableChorus implements IFarmable { + public static final IFarmable INSTANCE = new FarmableChorus(); + + private final ItemStack germling; + private final ItemStack fruit; + + private FarmableChorus() { + this.germling = new ItemStack(Blocks.CHORUS_FLOWER); + this.fruit = new ItemStack(Items.CHORUS_FRUIT); + } + + @Override + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { + return blockState.getBlock() == Blocks.CHORUS_FLOWER; + } + + @Nullable + @Override + public ICrop getCropAt(World world, BlockPos pos, IBlockState blockState) { + if (blockState.getBlock() != Blocks.CHORUS_FLOWER) { + return null; + } + + if (blockState.getValue(BlockChorusFlower.AGE) < 5) { + return null; + } + + return new CropChorusFlower(world, pos); + } + + @Override + public boolean isGermling(ItemStack itemstack) { + return ItemStack.areItemsEqual(germling, itemstack); + } + + @Override + public boolean isWindfall(ItemStack itemstack) { + return ItemStack.areItemsEqual(fruit, itemstack); + } + + @Override + public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, BlockPos pos) { + if (!canPlace(world, pos)) { + return false; + } + return BlockUtil.setBlockWithPlaceSound(world, pos, Blocks.CHORUS_FLOWER.getDefaultState()); + } + + private boolean canPlace(World world, BlockPos position) { + for (int x = -1; x <= 1; x++) { + for (int z = -1; z <= 1; z++) { + BlockPos offsetPosition = position.add(x, 0, z); + IBlockState state = world.getBlockState(offsetPosition); + if (state.getBlock() == Blocks.CHORUS_FLOWER || state.getBlock() == Blocks.CHORUS_PLANT) { + return false; + } + } + } + + return true; + } +} diff --git a/src/main/java/forestry/farming/logic/FarmableCocoa.java b/src/main/java/forestry/farming/logic/farmables/FarmableCocoa.java old mode 100755 new mode 100644 similarity index 96% rename from src/main/java/forestry/farming/logic/FarmableCocoa.java rename to src/main/java/forestry/farming/logic/farmables/FarmableCocoa.java index 0f821f020..1c35f2788 --- a/src/main/java/forestry/farming/logic/FarmableCocoa.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableCocoa.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import net.minecraft.block.BlockCocoa; import net.minecraft.entity.player.EntityPlayer; diff --git a/src/main/java/forestry/farming/logic/FarmableDoubleCrop.java b/src/main/java/forestry/farming/logic/farmables/FarmableDoubleCrop.java similarity index 84% rename from src/main/java/forestry/farming/logic/FarmableDoubleCrop.java rename to src/main/java/forestry/farming/logic/farmables/FarmableDoubleCrop.java index d524506ac..392070eb5 100644 --- a/src/main/java/forestry/farming/logic/FarmableDoubleCrop.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableDoubleCrop.java @@ -1,4 +1,4 @@ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; @@ -6,6 +6,7 @@ import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; import forestry.api.farming.ICrop; +import forestry.farming.logic.crops.CropDestroyDouble; public class FarmableDoubleCrop extends FarmableBase { private final IBlockState topMatureState; @@ -16,8 +17,7 @@ public class FarmableDoubleCrop extends FarmableBase { } @Override - public boolean isSaplingAt(World world, BlockPos pos) { - IBlockState blockState = world.getBlockState(pos); + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { return blockState.getBlock() == plantedState.getBlock() && blockState != topMatureState; } diff --git a/src/main/java/forestry/farming/logic/FarmableGE.java b/src/main/java/forestry/farming/logic/farmables/FarmableGE.java old mode 100755 new mode 100644 similarity index 88% rename from src/main/java/forestry/farming/logic/FarmableGE.java rename to src/main/java/forestry/farming/logic/farmables/FarmableGE.java index 208f07e81..5005beb19 --- a/src/main/java/forestry/farming/logic/FarmableGE.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableGE.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; @@ -23,18 +23,13 @@ import forestry.api.arboriculture.TreeManager; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmable; import forestry.arboriculture.ModuleArboriculture; +import forestry.farming.logic.crops.CropDestroy; public class FarmableGE implements IFarmable { @Override - public boolean isSaplingAt(World world, BlockPos pos) { - - if (world.isAirBlock(pos)) { - return false; - } - - Block block = world.getBlockState(pos).getBlock(); - return ModuleArboriculture.getBlocks().saplingGE == block; + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { + return ModuleArboriculture.getBlocks().saplingGE == blockState.getBlock(); } @Override diff --git a/src/main/java/forestry/farming/logic/FarmableGourd.java b/src/main/java/forestry/farming/logic/farmables/FarmableGourd.java old mode 100755 new mode 100644 similarity index 91% rename from src/main/java/forestry/farming/logic/FarmableGourd.java rename to src/main/java/forestry/farming/logic/farmables/FarmableGourd.java index 3c1efe3b2..c77d7a7c9 --- a/src/main/java/forestry/farming/logic/FarmableGourd.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableGourd.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; @@ -20,6 +20,7 @@ import net.minecraft.world.World; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmable; import forestry.core.utils.BlockUtil; +import forestry.farming.logic.crops.CropDestroy; public class FarmableGourd implements IFarmable { @@ -34,8 +35,7 @@ public class FarmableGourd implements IFarmable { } @Override - public boolean isSaplingAt(World world, BlockPos pos) { - IBlockState blockState = world.getBlockState(pos); + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { return blockState.getBlock() == stem; } diff --git a/src/main/java/forestry/farming/logic/FarmableRusticGrape.java b/src/main/java/forestry/farming/logic/farmables/FarmableRusticGrape.java similarity index 90% rename from src/main/java/forestry/farming/logic/FarmableRusticGrape.java rename to src/main/java/forestry/farming/logic/farmables/FarmableRusticGrape.java index 598103d91..35d6dff14 100644 --- a/src/main/java/forestry/farming/logic/FarmableRusticGrape.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableRusticGrape.java @@ -1,4 +1,4 @@ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import com.google.common.base.Preconditions; @@ -14,6 +14,7 @@ import net.minecraft.world.World; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmable; +import forestry.farming.logic.crops.CropDestroy; public class FarmableRusticGrape implements IFarmable { public static final PropertyBool GRAPES = PropertyBool.create("grapes"); @@ -27,8 +28,7 @@ public class FarmableRusticGrape implements IFarmable { } @Override - public boolean isSaplingAt(World world, BlockPos pos) { - IBlockState blockState = world.getBlockState(pos); + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { return blockState.getBlock() == cropBlock; } diff --git a/src/main/java/forestry/farming/logic/FarmableRusticSapling.java b/src/main/java/forestry/farming/logic/farmables/FarmableRusticSapling.java similarity index 89% rename from src/main/java/forestry/farming/logic/FarmableRusticSapling.java rename to src/main/java/forestry/farming/logic/farmables/FarmableRusticSapling.java index 7ca0e7e33..53e3ab2a1 100644 --- a/src/main/java/forestry/farming/logic/FarmableRusticSapling.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableRusticSapling.java @@ -1,4 +1,4 @@ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; @@ -12,6 +12,7 @@ import forestry.api.farming.ICrop; import forestry.api.farming.IFarmable; import forestry.core.network.packets.PacketFXSignal; import forestry.core.utils.NetworkUtil; +import forestry.farming.logic.crops.CropDestroy; public class FarmableRusticSapling implements IFarmable { @@ -36,8 +37,8 @@ public class FarmableRusticSapling implements IFarmable { } @Override - public boolean isSaplingAt(World world, BlockPos pos) { - return world.getBlockState(pos).getBlock() == germlingBlock; + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { + return blockState.getBlock() == germlingBlock; } @Override diff --git a/src/main/java/forestry/farming/logic/farmables/FarmableSapling.java b/src/main/java/forestry/farming/logic/farmables/FarmableSapling.java new file mode 100644 index 000000000..fed60f725 --- /dev/null +++ b/src/main/java/forestry/farming/logic/farmables/FarmableSapling.java @@ -0,0 +1,94 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.farming.logic.farmables; + +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumActionResult; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumHand; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmable; +import forestry.core.network.packets.PacketFXSignal; +import forestry.core.utils.ItemStackUtil; +import forestry.core.utils.NetworkUtil; +import forestry.farming.logic.crops.CropDestroy; + +public class FarmableSapling implements IFarmable { + protected final ItemStack germling; + protected final boolean ignoreMetadata; + protected final Block saplingBlock; + protected final ItemStack[] windfall; + + public FarmableSapling(final ItemStack germling, final ItemStack[] windfall) { + this(germling, windfall, true); + } + + public FarmableSapling(final ItemStack germling, final ItemStack[] windfall, boolean addSubItems) { + this.germling = germling; + this.windfall = windfall; + this.saplingBlock = ItemStackUtil.getBlock(germling); + this.ignoreMetadata = addSubItems; + } + + @Override + public boolean plantSaplingAt(EntityPlayer player, ItemStack germling, World world, BlockPos pos) { + ItemStack copy = germling.copy(); + player.setHeldItem(EnumHand.MAIN_HAND, copy); + EnumActionResult actionResult = copy.onItemUse(player, world, pos.down(), EnumHand.MAIN_HAND, EnumFacing.UP, 0, 0, 0); + player.setHeldItem(EnumHand.MAIN_HAND, ItemStack.EMPTY); + if (actionResult == EnumActionResult.SUCCESS) { + PacketFXSignal packet = new PacketFXSignal(PacketFXSignal.SoundFXType.BLOCK_PLACE, pos, Blocks.SAPLING.getDefaultState()); + NetworkUtil.sendNetworkPacket(packet, pos, world); + return true; + } + return false; + } + + @Override + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { + return blockState.getBlock() == this.saplingBlock; + } + + @Override + public ICrop getCropAt(World world, BlockPos pos, IBlockState blockState) { + Block block = blockState.getBlock(); + if (!block.isWood(world, pos)) { + return null; + } + + return new CropDestroy(world, blockState, pos, null); + } + + @Override + public boolean isGermling(ItemStack itemstack) { + if (ignoreMetadata) { + return ItemStack.areItemsEqual(germling, new ItemStack((itemstack.getItem()))); + } + return ItemStack.areItemsEqual(germling, itemstack); + } + + @Override + public boolean isWindfall(ItemStack itemstack) { + for (ItemStack drop : windfall) { + if (drop.isItemEqual(itemstack)) { + return true; + } + } + return false; + } +} diff --git a/src/main/java/forestry/farming/logic/FarmableStacked.java b/src/main/java/forestry/farming/logic/farmables/FarmableStacked.java old mode 100755 new mode 100644 similarity index 92% rename from src/main/java/forestry/farming/logic/FarmableStacked.java rename to src/main/java/forestry/farming/logic/farmables/FarmableStacked.java index 2bc8bea39..6b0e6d8f6 --- a/src/main/java/forestry/farming/logic/FarmableStacked.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableStacked.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; @@ -20,6 +20,7 @@ import net.minecraft.world.World; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmable; import forestry.core.utils.BlockUtil; +import forestry.farming.logic.crops.CropDestroy; public class FarmableStacked implements IFarmable { protected final ItemStack germling; @@ -33,8 +34,7 @@ public class FarmableStacked implements IFarmable { } @Override - public boolean isSaplingAt(World world, BlockPos pos) { - IBlockState blockState = world.getBlockState(pos); + public boolean isSaplingAt(World world, BlockPos pos, IBlockState blockState) { return blockState.getBlock() == cropBlock; } diff --git a/src/main/java/forestry/farming/logic/FarmableVanillaMushroom.java b/src/main/java/forestry/farming/logic/farmables/FarmableVanillaMushroom.java similarity index 93% rename from src/main/java/forestry/farming/logic/FarmableVanillaMushroom.java rename to src/main/java/forestry/farming/logic/farmables/FarmableVanillaMushroom.java index ab3af235b..57333114b 100644 --- a/src/main/java/forestry/farming/logic/FarmableVanillaMushroom.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableVanillaMushroom.java @@ -8,15 +8,17 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.farmables; -import forestry.api.farming.ICrop; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; import net.minecraft.util.math.BlockPos; import net.minecraft.world.World; +import forestry.api.farming.ICrop; +import forestry.farming.logic.crops.CropDestroy; + public class FarmableVanillaMushroom extends FarmableBase { private final Block hugeMushroomBlock; diff --git a/src/main/java/forestry/farming/logic/FarmableVanillaSapling.java b/src/main/java/forestry/farming/logic/farmables/FarmableVanillaSapling.java old mode 100755 new mode 100644 similarity index 95% rename from src/main/java/forestry/farming/logic/FarmableVanillaSapling.java rename to src/main/java/forestry/farming/logic/farmables/FarmableVanillaSapling.java index c22cc397e..7009613b4 --- a/src/main/java/forestry/farming/logic/FarmableVanillaSapling.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableVanillaSapling.java @@ -8,7 +8,7 @@ * Various Contributors including, but not limited to: * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges ******************************************************************************/ -package forestry.farming.logic; +package forestry.farming.logic.farmables; import net.minecraft.init.Blocks; import net.minecraft.init.Items; diff --git a/src/main/java/forestry/farming/logic/farmables/package-info.java b/src/main/java/forestry/farming/logic/farmables/package-info.java new file mode 100644 index 000000000..661f5e768 --- /dev/null +++ b/src/main/java/forestry/farming/logic/farmables/package-info.java @@ -0,0 +1,10 @@ +@ParametersAreNonnullByDefault +@FieldsAreNonnullByDefault +@MethodsReturnNonnullByDefault +package forestry.farming.logic.farmables; + +import javax.annotation.ParametersAreNonnullByDefault; + +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/farming/logic/package-info.java b/src/main/java/forestry/farming/logic/package-info.java index 4f11ab53c..8f32cf8d6 100644 --- a/src/main/java/forestry/farming/logic/package-info.java +++ b/src/main/java/forestry/farming/logic/package-info.java @@ -5,5 +5,6 @@ package forestry.farming.logic; import javax.annotation.ParametersAreNonnullByDefault; -import forestry.core.utils.FieldsAreNonnullByDefault; -import mcp.MethodsReturnNonnullByDefault; \ No newline at end of file +import mcp.MethodsReturnNonnullByDefault; + +import forestry.core.utils.FieldsAreNonnullByDefault; \ No newline at end of file diff --git a/src/main/java/forestry/farming/multiblock/FakeFarmController.java b/src/main/java/forestry/farming/multiblock/FakeFarmController.java index a9ed92059..34fc79620 100644 --- a/src/main/java/forestry/farming/multiblock/FakeFarmController.java +++ b/src/main/java/forestry/farming/multiblock/FakeFarmController.java @@ -10,6 +10,15 @@ ******************************************************************************/ package forestry.farming.multiblock; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import net.minecraft.util.NonNullList; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.Vec3i; +import net.minecraft.world.World; + +import net.minecraftforge.fluids.FluidStack; + import forestry.api.circuits.CircuitSocketType; import forestry.api.circuits.ICircuitSocketType; import forestry.api.farming.FarmDirection; @@ -21,15 +30,8 @@ import forestry.core.fluids.ITankManager; import forestry.core.inventory.FakeInventoryAdapter; import forestry.core.inventory.IInventoryAdapter; import forestry.core.multiblock.FakeMultiblockController; +import forestry.farming.FarmRegistry; import forestry.farming.gui.IFarmLedgerDelegate; -import forestry.farming.logic.FarmLogicArboreal; -import net.minecraft.inventory.IInventory; -import net.minecraft.item.ItemStack; -import net.minecraft.util.NonNullList; -import net.minecraft.util.math.BlockPos; -import net.minecraft.util.math.Vec3i; -import net.minecraft.world.World; -import net.minecraftforge.fluids.FluidStack; public class FakeFarmController extends FakeMultiblockController implements IFarmControllerInternal { public static final FakeFarmController instance = new FakeFarmController(); @@ -85,7 +87,7 @@ public class FakeFarmController extends FakeMultiblockController implements IFar @Override public IFarmLogic getFarmLogic(FarmDirection direction) { - return new FarmLogicArboreal(); + return FarmRegistry.getInstance().getProperties("farmArboreal").getLogic(false); } @Override @@ -138,6 +140,11 @@ public class FakeFarmController extends FakeMultiblockController implements IFar return "for.multiblock.farm.type"; } + @Override + public boolean isValidPlatform(World world, BlockPos pos) { + return false; + } + private static class FakeFarmInventory implements IFarmInventory { public static final FakeFarmInventory instance = new FakeFarmInventory(); diff --git a/src/main/java/forestry/farming/multiblock/FarmController.java b/src/main/java/forestry/farming/multiblock/FarmController.java index a7a4371d8..e9f899b58 100755 --- a/src/main/java/forestry/farming/multiblock/FarmController.java +++ b/src/main/java/forestry/farming/multiblock/FarmController.java @@ -15,11 +15,9 @@ import com.google.common.base.Preconditions; import javax.annotation.Nullable; import java.io.IOException; -import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; import java.util.Collections; -import java.util.Comparator; import java.util.EnumMap; import java.util.HashMap; import java.util.HashSet; @@ -50,7 +48,6 @@ import forestry.api.core.EnumTemperature; import forestry.api.core.IErrorLogic; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; -import forestry.api.farming.IFarmHousing; import forestry.api.farming.IFarmInventory; import forestry.api.farming.IFarmListener; import forestry.api.farming.IFarmLogic; @@ -73,43 +70,18 @@ import forestry.core.network.PacketBufferForestry; import forestry.core.tiles.ILiquidTankTile; import forestry.core.utils.ClimateUtil; import forestry.core.utils.PlayerUtil; -import forestry.core.utils.TopDownBlockPosComparator; import forestry.core.utils.Translator; import forestry.farming.FarmHelper; +import forestry.farming.FarmHelper.FarmWorkStatus; +import forestry.farming.FarmHelper.Stage; +import forestry.farming.FarmRegistry; import forestry.farming.FarmTarget; import forestry.farming.gui.IFarmLedgerDelegate; -import forestry.farming.logic.FarmLogicArboreal; import forestry.farming.tiles.TileFarmGearbox; import forestry.farming.tiles.TileFarmPlain; public class FarmController extends RectangularMultiblockControllerBase implements IFarmControllerInternal, ILiquidTankTile { - private enum Stage { - CULTIVATE, HARVEST; - - public Stage next() { - if (this == CULTIVATE) { - return HARVEST; - } else { - return CULTIVATE; - } - } - } - - private static FarmDirection getLayoutDirection(FarmDirection farmSide) { - switch (farmSide) { - case NORTH: - return FarmDirection.WEST; - case WEST: - return FarmDirection.SOUTH; - case SOUTH: - return FarmDirection.EAST; - case EAST: - return FarmDirection.NORTH; - } - return null; - } - private final Map> targets = new EnumMap<>(FarmDirection.class); private int allowedExtent = 0; @Nullable @@ -473,11 +445,11 @@ public class FarmController extends RectangularMultiblockControllerBase implemen List farmTargets = targets.get(farmSide); if (stage == Stage.HARVEST) { - Collection harvested = harvestTargets(world, farmTargets, logic, farmListeners); + Collection harvested = FarmHelper.harvestTargets(world, farmTargets, logic, farmListeners); farmWorkStatus.didWork = !harvested.isEmpty(); if (!harvested.isEmpty()) { pendingCrops.addAll(harvested); - pendingCrops.sort(TopDownICropComparator.INSTANCE); + pendingCrops.sort(FarmHelper.TopDownICropComparator.INSTANCE); harvestProvider = logic; } } else if (stage == Stage.CULTIVATE) { @@ -513,102 +485,8 @@ public class FarmController extends RectangularMultiblockControllerBase implemen // Set the maximum allowed extent. allowedExtent = Math.max(sizeNorthSouth, sizeEastWest) * Config.farmSize + 1; - createTargets(world, targets, targetStart, allowedExtent, sizeNorthSouth, sizeEastWest, min, max); - setExtents(world, targets); - } - - private static void createTargets(World world, Map> targets, BlockPos targetStart, final int allowedExtent, final int farmSizeNorthSouth, final int farmSizeEastWest, BlockPos minFarmCoord, BlockPos maxFarmCoord) { - for (FarmDirection farmSide : FarmDirection.values()) { - - final int farmWidth; - if (farmSide == FarmDirection.NORTH || farmSide == FarmDirection.SOUTH) { - farmWidth = farmSizeEastWest; - } else { - farmWidth = farmSizeNorthSouth; - } - - // targets extend sideways in a pinwheel pattern around the farm, so they need to go a little extra distance - final int targetMaxLimit = allowedExtent + farmWidth; - - FarmDirection layoutDirection = getLayoutDirection(farmSide); - - List farmSideTargets = new ArrayList<>(); - targets.put(farmSide, farmSideTargets); - - BlockPos targetLocation = FarmHelper.getFarmMultiblockCorner(targetStart, farmSide, layoutDirection, minFarmCoord, maxFarmCoord); - BlockPos firstLocation = targetLocation.offset(farmSide.getFacing()); - BlockPos firstGroundPosition = getGroundPosition(world, firstLocation); - if (firstGroundPosition != null) { - int groundHeight = firstGroundPosition.getY(); - - for (int i = 0; i < allowedExtent; i++) { - targetLocation = targetLocation.offset(farmSide.getFacing()); - BlockPos groundLocation = new BlockPos(targetLocation.getX(), groundHeight, targetLocation.getZ()); - - if (!world.isBlockLoaded(groundLocation)) { - break; - } - - IBlockState blockState = world.getBlockState(groundLocation); - if (!FarmHelper.bricks.contains(blockState.getBlock())) { - break; - } - - int targetLimit = targetMaxLimit; - if (!Config.squareFarms) { - targetLimit = targetMaxLimit - i - 1; - } - - FarmTarget target = new FarmTarget(targetLocation, layoutDirection, targetLimit); - farmSideTargets.add(target); - } - } - } - } - - @Nullable - private static BlockPos getGroundPosition(World world, BlockPos targetPosition) { - if (!world.isBlockLoaded(targetPosition)) { - return null; - } - - for (int yOffset = 2; yOffset > -4; yOffset--) { - BlockPos position = targetPosition.add(0, yOffset, 0); - IBlockState blockState = world.getBlockState(position); - if (FarmHelper.bricks.contains(blockState.getBlock())) { - return position; - } - } - - return null; - } - - private static boolean isCycleCanceledByListeners(IFarmLogic logic, FarmDirection direction, Iterable farmListeners) { - for (IFarmListener listener : farmListeners) { - if (listener.cancelTask(logic, direction)) { - return true; - } - } - return false; - } - - private static void setExtents(World world, Map> targets) { - for (List targetsList : targets.values()) { - if (!targetsList.isEmpty()) { - BlockPos groundPosition = getGroundPosition(world, targetsList.get(0).getStart()); - - for (FarmTarget target : targetsList) { - target.setExtentAndYOffset(world, groundPosition); - } - } - } - } - - private static class FarmWorkStatus { - public boolean didWork = false; - public boolean hasFarmland = false; - public boolean hasFertilizer = true; - public boolean hasLiquid = true; + FarmHelper.createTargets(world, this, targets, targetStart, allowedExtent, sizeNorthSouth, sizeEastWest, min, max); + FarmHelper.setExtents(world, this, targets); } private FarmWorkStatus cultivateTargets(FarmWorkStatus farmWorkStatus, List farmTargets, IFarmLogic logic, FarmDirection farmSide) { @@ -621,9 +499,9 @@ public class FarmController extends RectangularMultiblockControllerBase implemen } } - if (hasFarmland && !isCycleCanceledByListeners(logic, farmSide, farmListeners)) { + if (hasFarmland && !FarmHelper.isCycleCanceledByListeners(logic, farmSide, farmListeners)) { final float hydrationModifier = hydrationManager.getHydrationModifier(); - final int fertilizerConsumption = logic.getFertilizerConsumption(); + final int fertilizerConsumption = Math.round(logic.getFertilizerConsumption() * Config.fertilizerModifier); final int liquidConsumption = logic.getWaterConsumption(hydrationModifier); final FluidStack liquid = new FluidStack(FluidRegistry.WATER, liquidConsumption); @@ -639,7 +517,7 @@ public class FarmController extends RectangularMultiblockControllerBase implemen continue; } - if (cultivateTarget(world, this, target, logic, farmListeners)) { + if (FarmHelper.cultivateTarget(world, this, target, logic, farmListeners)) { // Remove fertilizer and water fertilizerManager.removeFertilizer(inventory, fertilizerConsumption); removeLiquid(liquid); @@ -652,41 +530,6 @@ public class FarmController extends RectangularMultiblockControllerBase implemen return farmWorkStatus; } - private static boolean cultivateTarget(World world, IFarmHousing farmHousing, FarmTarget target, IFarmLogic logic, Iterable farmListeners) { - BlockPos targetPosition = target.getStart().add(0, target.getYOffset(), 0); - if (logic.cultivate(world, farmHousing, targetPosition, target.getDirection(), target.getExtent())) { - for (IFarmListener listener : farmListeners) { - listener.hasCultivated(logic, targetPosition, target.getDirection(), target.getExtent()); - } - return true; - } - - return false; - } - - private static Collection harvestTargets(World world, List farmTargets, IFarmLogic logic, Iterable farmListeners) { - for (FarmTarget target : farmTargets) { - Collection harvested = harvestTarget(world, target, logic, farmListeners); - if (!harvested.isEmpty()) { - return harvested; - } - } - - return Collections.emptyList(); - } - - private static Collection harvestTarget(World world, FarmTarget target, IFarmLogic logic, Iterable farmListeners) { - BlockPos pos = target.getStart().add(0, target.getYOffset(), 0); - Collection harvested = logic.harvest(world, pos, target.getDirection(), target.getExtent()); - if (!harvested.isEmpty()) { - // Let event handlers know. - for (IFarmListener listener : farmListeners) { - listener.hasScheduledHarvest(harvested, logic, pos, target.getDirection(), target.getExtent()); - } - } - return harvested; - } - private boolean collectWindfall(IFarmLogic logic) { NonNullList collected = logic.collect(world, this); if (collected.isEmpty()) { @@ -715,7 +558,7 @@ public class FarmController extends RectangularMultiblockControllerBase implemen } } - final int fertilizerConsumption = provider.getFertilizerConsumption(); + final int fertilizerConsumption = Math.round(provider.getFertilizerConsumption() * Config.fertilizerModifier); IErrorLogic errorLogic = getErrorLogic(); @@ -787,7 +630,7 @@ public class FarmController extends RectangularMultiblockControllerBase implemen @Override public void resetFarmLogic(FarmDirection direction) { - setFarmLogic(direction, new FarmLogicArboreal()); + setFarmLogic(direction, FarmRegistry.getInstance().getProperties("farmArboreal").getLogic(false)); } @Override @@ -835,22 +678,20 @@ public class FarmController extends RectangularMultiblockControllerBase implemen return CircuitSocketType.FARM; } + @Override + public boolean isValidPlatform(World world, BlockPos pos) { + IBlockState blockState = world.getBlockState(pos); + return FarmHelper.bricks.contains(blockState.getBlock()); + } + + @Override + public boolean isSquare() { + return Config.squareFarms; + } + // for debugging @Override public String toString() { return MoreObjects.toStringHelper(this).add("stage", stage).add("logic", farmLogics.toString()).toString(); } - - private static class TopDownICropComparator implements Comparator { - public static final TopDownICropComparator INSTANCE = new TopDownICropComparator(); - - private TopDownICropComparator() { - - } - - @Override - public int compare(ICrop o1, ICrop o2) { - return TopDownBlockPosComparator.INSTANCE.compare(o1.getPosition(), o2.getPosition()); - } - } } diff --git a/src/main/java/forestry/farming/multiblock/FarmFertilizerManager.java b/src/main/java/forestry/farming/multiblock/FarmFertilizerManager.java index e7e3cb935..99887e966 100644 --- a/src/main/java/forestry/farming/multiblock/FarmFertilizerManager.java +++ b/src/main/java/forestry/farming/multiblock/FarmFertilizerManager.java @@ -12,11 +12,12 @@ package forestry.farming.multiblock; import java.io.IOException; +import net.minecraft.nbt.NBTTagCompound; + import forestry.api.core.INbtReadable; import forestry.api.core.INbtWritable; import forestry.core.network.IStreamable; import forestry.core.network.PacketBufferForestry; -import net.minecraft.nbt.NBTTagCompound; public class FarmFertilizerManager implements INbtWritable, INbtReadable, IStreamable { private static final int BUFFER_FERTILIZER = 200; @@ -26,7 +27,7 @@ public class FarmFertilizerManager implements INbtWritable, INbtReadable, IStrea storedFertilizer = 0; } - public boolean hasFertilizer(InventoryFarm inventory, int amount) { + public boolean hasFertilizer(IFarmInventoryInternal inventory, int amount) { if (inventory.getFertilizerValue() < 0) { return true; } @@ -34,7 +35,7 @@ public class FarmFertilizerManager implements INbtWritable, INbtReadable, IStrea return storedFertilizer >= amount; } - public void removeFertilizer(InventoryFarm inventory, int amount) { + public void removeFertilizer(IFarmInventoryInternal inventory, int amount) { if (inventory.getFertilizerValue() < 0) { return; } @@ -45,7 +46,7 @@ public class FarmFertilizerManager implements INbtWritable, INbtReadable, IStrea } } - public boolean maintainFertilizer(InventoryFarm inventory) { + public boolean maintainFertilizer(IFarmInventoryInternal inventory) { if (storedFertilizer <= BUFFER_FERTILIZER) { int fertilizerValue = inventory.getFertilizerValue(); if (fertilizerValue < 0) { @@ -69,7 +70,7 @@ public class FarmFertilizerManager implements INbtWritable, INbtReadable, IStrea return data; } - public int getStoredFertilizerScaled(InventoryFarm inventory, int scale) { + public int getStoredFertilizerScaled(IFarmInventoryInternal inventory, int scale) { if (storedFertilizer == 0) { return 0; } diff --git a/src/main/java/forestry/farming/multiblock/IFarmInventoryInternal.java b/src/main/java/forestry/farming/multiblock/IFarmInventoryInternal.java new file mode 100644 index 000000000..823c4b6e2 --- /dev/null +++ b/src/main/java/forestry/farming/multiblock/IFarmInventoryInternal.java @@ -0,0 +1,10 @@ +package forestry.farming.multiblock; + +import forestry.api.farming.IFarmInventory; + +public interface IFarmInventoryInternal extends IFarmInventory { + + int getFertilizerValue(); + + boolean useFertilizer(); +} diff --git a/src/main/java/forestry/farming/multiblock/InventoryFarm.java b/src/main/java/forestry/farming/multiblock/InventoryFarm.java index 2703411f3..3d9306e69 100644 --- a/src/main/java/forestry/farming/multiblock/InventoryFarm.java +++ b/src/main/java/forestry/farming/multiblock/InventoryFarm.java @@ -24,7 +24,6 @@ import net.minecraftforge.fluids.FluidUtil; import forestry.api.core.ForestryAPI; import forestry.api.farming.FarmDirection; -import forestry.api.farming.IFarmInventory; import forestry.api.farming.IFarmLogic; import forestry.api.farming.IFarmable; import forestry.core.fluids.FluidHelper; @@ -32,10 +31,9 @@ import forestry.core.fluids.TankManager; import forestry.core.inventory.InventoryAdapterRestricted; import forestry.core.inventory.wrappers.InventoryMapper; import forestry.core.utils.InventoryUtil; -import forestry.core.utils.PlayerUtil; import forestry.core.utils.SlotUtil; -public class InventoryFarm extends InventoryAdapterRestricted implements IFarmInventory { +public class InventoryFarm extends InventoryAdapterRestricted implements IFarmInventoryInternal { public static final int SLOT_RESOURCES_1 = 0; public static final int SLOT_RESOURCES_COUNT = 6; public static final int SLOT_GERMLINGS_1 = 6; diff --git a/src/main/java/forestry/modules/ForestryModuleUids.java b/src/main/java/forestry/modules/ForestryModuleUids.java index c9060f8b2..8ab36bb30 100644 --- a/src/main/java/forestry/modules/ForestryModuleUids.java +++ b/src/main/java/forestry/modules/ForestryModuleUids.java @@ -19,6 +19,7 @@ public class ForestryModuleUids { public static final String BACKPACKS = "backpacks"; public static final String DATABASE = "database"; public static final String SORTING = "sorting"; + public static final String CULTIVATION = "cultivation"; //Mod Plugins public static final String BIOMES_O_PLENTY = "biomes.o.plenty"; diff --git a/src/main/java/forestry/plugins/PluginActuallyAdditions.java b/src/main/java/forestry/plugins/PluginActuallyAdditions.java index ecf152245..0b67e44d4 100644 --- a/src/main/java/forestry/plugins/PluginActuallyAdditions.java +++ b/src/main/java/forestry/plugins/PluginActuallyAdditions.java @@ -17,7 +17,7 @@ import forestry.api.modules.ForestryModule; import forestry.api.recipes.RecipeManagers; import forestry.core.config.Constants; import forestry.core.fluids.Fluids; -import forestry.farming.logic.FarmableAgingCrop; +import forestry.farming.logic.farmables.FarmableAgingCrop; import forestry.modules.ForestryModuleUids; @SuppressWarnings("unused") diff --git a/src/main/java/forestry/plugins/PluginBetterWithMods.java b/src/main/java/forestry/plugins/PluginBetterWithMods.java index 60f1c38c8..91ba8beca 100644 --- a/src/main/java/forestry/plugins/PluginBetterWithMods.java +++ b/src/main/java/forestry/plugins/PluginBetterWithMods.java @@ -13,7 +13,7 @@ import forestry.api.modules.ForestryModule; import forestry.api.recipes.RecipeManagers; import forestry.core.config.Constants; import forestry.core.fluids.Fluids; -import forestry.farming.logic.FarmableDoubleCrop; +import forestry.farming.logic.farmables.FarmableDoubleCrop; import forestry.modules.ForestryModuleUids; @SuppressWarnings("unused") diff --git a/src/main/java/forestry/plugins/PluginExtraUtilities.java b/src/main/java/forestry/plugins/PluginExtraUtilities.java index d19c035d5..78d5f6ac2 100644 --- a/src/main/java/forestry/plugins/PluginExtraUtilities.java +++ b/src/main/java/forestry/plugins/PluginExtraUtilities.java @@ -10,8 +10,10 @@ ******************************************************************************/ package forestry.plugins; +import com.google.common.collect.ImmutableSet; + import java.util.Collections; -import java.util.function.Consumer; +import java.util.Set; import net.minecraft.block.Block; import net.minecraft.block.properties.IProperty; @@ -20,12 +22,10 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; -import net.minecraftforge.fml.common.registry.ForgeRegistries; - import forestry.api.circuits.ChipsetManager; -import forestry.api.circuits.ICircuit; import forestry.api.circuits.ICircuitLayout; -import forestry.api.core.ForestryAPI; +import forestry.api.farming.IFarmProperties; +import forestry.api.farming.IFarmRegistry; import forestry.api.modules.ForestryModule; import forestry.core.ModuleCore; import forestry.core.circuits.Circuits; @@ -34,71 +34,74 @@ import forestry.core.config.Constants; import forestry.core.items.EnumElectronTube; import forestry.core.utils.BlockUtil; import forestry.core.utils.Log; -import forestry.core.utils.ModUtil; import forestry.farming.FarmRegistry; import forestry.farming.circuits.CircuitFarmLogic; -import forestry.farming.logic.FarmLogicExU; -import forestry.farming.logic.FarmableAgingCrop; -import forestry.modules.BlankForestryModule; +import forestry.farming.logic.FarmLogicRedOrchid; +import forestry.farming.logic.farmables.FarmableAgingCrop; import forestry.modules.ForestryModuleUids; -@SuppressWarnings("unused") -@ForestryModule(containerID = ForestryCompatPlugins.ID, moduleID = ForestryModuleUids.EXTRA_UTILITIES, name = "ExtraUtilities", author = "Nirek", url = Constants.URL, unlocalizedDescription = "for.module.extrautilities.description") -public class PluginExtraUtilities extends BlankForestryModule { +@ForestryModule(containerID = ForestryCompatPlugins.ID, moduleID = ForestryModuleUids.EXTRA_UTILITIES, name = "Extra Utilities", author = "Nirek", url = Constants.URL, unlocalizedDescription = "for.module.extrautilities.description") +public class PluginExtraUtilities extends CompatPlugin { - private static final String ExU = "extrautils2"; + public static ItemStack orchidStack = ItemStack.EMPTY; - @Override - public boolean isAvailable() { - return ModUtil.isModLoaded(ExU); - } - - @Override - public String getFailMessage() { - return "ExtraUtilities not found"; + public PluginExtraUtilities() { + super("Extra Utilities", "extrautils2"); } @Override public void doInit() { - if (Config.isExUtilRedOrchidEnabled()) { - registerExPlant("Orchid", "redorchid", "Red Orchid", Blocks.REDSTONE_ORE, circuit -> Circuits.farmOrchidManaged = circuit); + Block redOrchid = getBlock("redorchid"); + Block enderLilly = getBlock("enderlilly"); + + if (Config.isExUtilRedOrchidEnabled() && redOrchid != null) { + Item item = Item.getItemFromBlock(redOrchid); + + registerFarmable(redOrchid, item, "farmOrchid"); + + IFarmProperties orchidFarm = FarmRegistry.getInstance().registerLogic("farmOrchid", FarmLogicRedOrchid::new); + orchidFarm.registerSoil(new ItemStack(Blocks.REDSTONE_ORE), Blocks.REDSTONE_ORE.getDefaultState()); + orchidFarm.registerSoil(new ItemStack(Blocks.LIT_REDSTONE_ORE), Blocks.LIT_REDSTONE_ORE.getDefaultState()); + + Circuits.farmOrchidManaged = new CircuitFarmLogic("managedOrchid", orchidFarm, false); + Circuits.farmOrchidManual = new CircuitFarmLogic("manualOrchid", orchidFarm, true); + + orchidStack = new ItemStack(item); } - if (Config.isExUtilEnderLilyEnabled()) { - registerExPlant("Ender", "enderlilly", "Ender Lily", Blocks.END_STONE, circuit -> Circuits.farmEnderManaged = circuit); + if (Config.isExUtilEnderLilyEnabled() && enderLilly != null) { + Item item = Item.getItemFromBlock(enderLilly); + registerFarmable(enderLilly, item, "farmEnder"); } } + @Override + public Set getDependencyUids() { + return ImmutableSet.of(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)); + } + @Override public void registerRecipes() { - if (!ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING))) return; - if(Circuits.farmEnderManaged != null) { - ICircuitLayout layoutManaged = ChipsetManager.circuitRegistry.getLayout("forestry.farms.managed"); - ChipsetManager.solderManager.addRecipe(layoutManaged, ModuleCore.getItems().tubes.get(EnumElectronTube.ENDER, 1), Circuits.farmEnderManaged); - } if(Circuits.farmOrchidManaged != null) { ICircuitLayout layoutManaged = ChipsetManager.circuitRegistry.getLayout("forestry.farms.managed"); - ChipsetManager.solderManager.addRecipe(layoutManaged, ModuleCore.items.tubes.get(EnumElectronTube.ORCHID, 1), Circuits.farmOrchidManaged); + ICircuitLayout layoutManual = ChipsetManager.circuitRegistry.getLayout("forestry.farms.manual"); + if(layoutManaged == null || layoutManual == null){ + return; + } + ChipsetManager.solderManager.addRecipe(layoutManaged, ModuleCore.getItems().tubes.get(EnumElectronTube.ORCHID, 1), Circuits.farmOrchidManaged); + ChipsetManager.solderManager.addRecipe(layoutManual, ModuleCore.getItems().tubes.get(EnumElectronTube.ORCHID, 1), Circuits.farmOrchidManual); } } - private void registerExPlant(String id, String itemResourceName, String itemName, Block soil, Consumer assignTo) { - Block plantBlock = ForgeRegistries.BLOCKS.getValue(new ResourceLocation(ExU, itemResourceName)); - Item plantItem = Item.getItemFromBlock(plantBlock); - if(plantBlock == Blocks.AIR) { - Log.error("Could not find {} block.", itemName); - } else if (plantItem == null) { - Log.error("Could not find {} item.", itemName); + private void registerFarmable(Block plantBlock, Item plantItem, String identifier){ + IProperty growthProperty = BlockUtil.getProperty(plantBlock, "growth", Integer.class); + if (growthProperty == null) { + Log.error("Could not find the growth property of {}.", plantBlock.getLocalizedName()); } else { - IProperty growthProperty = BlockUtil.getProperty(plantBlock, "growth", Integer.class); - if (growthProperty == null) { - Log.error("Could not find the growth property of {}.", itemName); - } else { - int harvestAge = Collections.max(growthProperty.getAllowedValues()); - int replantAge = plantBlock.getDefaultState().getValue(growthProperty); - FarmRegistry.getInstance().registerFarmables(itemName, new FarmableAgingCrop(new ItemStack(plantItem), plantBlock, growthProperty, harvestAge, replantAge)); - assignTo.accept(new CircuitFarmLogic("managed" + id, new FarmLogicExU("Managed " + itemName + " Farm", plantItem, soil, itemName))); - } + IFarmRegistry registry = FarmRegistry.getInstance(); + int harvestAge = Collections.max(growthProperty.getAllowedValues()); + int replantAge = plantBlock.getDefaultState().getValue(growthProperty); + registry.registerFarmables(identifier, new FarmableAgingCrop(new ItemStack(plantItem), plantBlock, growthProperty, harvestAge, replantAge)); } } } diff --git a/src/main/java/forestry/plugins/PluginHarvestCraft.java b/src/main/java/forestry/plugins/PluginHarvestCraft.java index 71d5c8296..f2329e230 100644 --- a/src/main/java/forestry/plugins/PluginHarvestCraft.java +++ b/src/main/java/forestry/plugins/PluginHarvestCraft.java @@ -30,7 +30,7 @@ import forestry.core.config.Constants; import forestry.core.fluids.Fluids; import forestry.core.items.ItemRegistryCore; import forestry.core.recipes.RecipeUtil; -import forestry.farming.logic.FarmableAgingCrop; +import forestry.farming.logic.farmables.FarmableAgingCrop; import forestry.modules.ForestryModuleUids; @SuppressWarnings("unused") @@ -199,8 +199,7 @@ public class PluginHarvestCraft extends CompatPlugin { RecipeManagers.squeezerManager.addRecipe(10, berrySeed, Fluids.SEED_OIL.getFluid(seedamount)); } if (ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)) && berrySeed != null && berryBlock != null) { - farmRegistry.registerFarmables("farmWheat", new FarmableAgingCrop(berrySeed, berryBlock, plantAGE, 3)); - farmRegistry.registerFarmables("farmOrchard", new FarmableAgingCrop(berrySeed, berryBlock, plantAGE, 3, 0)); + farmRegistry.registerFarmables("farmCrops", new FarmableAgingCrop(berrySeed, berryBlock, plantAGE, 3, 0)); } plants.add(berryName); } @@ -217,8 +216,7 @@ public class PluginHarvestCraft extends CompatPlugin { RecipeManagers.squeezerManager.addRecipe(10, fruitSeed, Fluids.SEED_OIL.getFluid(seedamount)); } if (ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)) && fruitSeed != null && fruitBlock != null) { - farmRegistry.registerFarmables("farmWheat", new FarmableAgingCrop(fruitSeed, fruitBlock, plantAGE, 3)); - farmRegistry.registerFarmables("farmOrchard", new FarmableAgingCrop(fruitSeed, fruitBlock, plantAGE, 3, 0)); + farmRegistry.registerFarmables("farmCrops", new FarmableAgingCrop(fruitSeed, fruitBlock, plantAGE, 3, 0)); } plants.add(fruitName); } @@ -236,8 +234,7 @@ public class PluginHarvestCraft extends CompatPlugin { RecipeManagers.squeezerManager.addRecipe(10, vegetableSeed, Fluids.SEED_OIL.getFluid(seedamount)); } if (ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)) && vegetableSeed != null && vegetableBlock != null) { - farmRegistry.registerFarmables("farmVegetables", new FarmableAgingCrop(vegetableSeed, vegetableBlock, plantAGE, 3)); - farmRegistry.registerFarmables("farmOrchard", new FarmableAgingCrop(vegetableSeed, vegetableBlock, plantAGE, 3, 0)); + farmRegistry.registerFarmables("farmCrops", new FarmableAgingCrop(vegetableSeed, vegetableBlock, plantAGE, 3, 0)); } plants.add(vegetableName); } @@ -256,8 +253,7 @@ public class PluginHarvestCraft extends CompatPlugin { RecipeManagers.moistenerManager.addRecipe(grainSeed, new ItemStack(Blocks.MYCELIUM), 5000); } if (ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)) && grainSeed != null && grainBlock != null) { - farmRegistry.registerFarmables("farmWheat", new FarmableAgingCrop(grainSeed, grainBlock, plantAGE, 3)); - farmRegistry.registerFarmables("farmOrchard", new FarmableAgingCrop(grainSeed, grainBlock, plantAGE, 3, 0)); + farmRegistry.registerFarmables("farmCrops", new FarmableAgingCrop(grainSeed, grainBlock, plantAGE, 3, 0)); } plants.add(grainName); } @@ -303,8 +299,7 @@ public class PluginHarvestCraft extends CompatPlugin { RecipeManagers.squeezerManager.addRecipe(10, genericCropSeed, Fluids.SEED_OIL.getFluid(seedamount)); } if (ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)) && genericCropSeed != null && genericCropBlock != null) { - farmRegistry.registerFarmables("farmWheat", new FarmableAgingCrop(genericCropSeed, genericCropBlock, plantAGE, 3)); - farmRegistry.registerFarmables("farmOrchard", new FarmableAgingCrop(genericCropSeed, genericCropBlock, plantAGE, 3, 0)); + farmRegistry.registerFarmables("farmCrops", new FarmableAgingCrop(genericCropSeed, genericCropBlock, plantAGE, 3, 0)); } plants.add(cropName); } @@ -315,8 +310,7 @@ public class PluginHarvestCraft extends CompatPlugin { RecipeManagers.squeezerManager.addRecipe(10, mustardCropSeed, Fluids.SEED_OIL.getFluid(seedamount)); } if (ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)) && mustardCropSeed != null && mustardCropBlock != null) { - farmRegistry.registerFarmables("farmWheat", new FarmableAgingCrop(mustardCropSeed, mustardCropBlock, plantAGE, 3)); - farmRegistry.registerFarmables("farmOrchard", new FarmableAgingCrop(mustardCropSeed, mustardCropBlock, plantAGE, 3, 0)); + farmRegistry.registerFarmables("farmCrops", new FarmableAgingCrop(mustardCropSeed, mustardCropBlock, plantAGE, 3, 0)); } if (mustardFruit != null) { RecipeUtil.addFermenterRecipes(mustardFruit, ForestryAPI.activeMode.getIntegerSetting("fermenter.yield.wheat"), Fluids.BIOMASS); @@ -337,8 +331,7 @@ public class PluginHarvestCraft extends CompatPlugin { RecipeManagers.squeezerManager.addRecipe(10, cropnutSeed, Fluids.SEED_OIL.getFluid(seedamount)); } if (ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING)) && cropnutSeed != null && cropnutBlock != null) { - farmRegistry.registerFarmables("farmWheat", new FarmableAgingCrop(cropnutSeed, cropnutBlock, plantAGE, 3)); - farmRegistry.registerFarmables("farmOrchard", new FarmableAgingCrop(cropnutSeed, cropnutBlock, plantAGE, 3, 0)); + farmRegistry.registerFarmables("farmCrops", new FarmableAgingCrop(cropnutSeed, cropnutBlock, plantAGE, 3, 0)); } if (cropnut != null) { RecipeManagers.squeezerManager.addRecipe(20, cropnut, Fluids.SEED_OIL.getFluid(12 * seedamount)); diff --git a/src/main/java/forestry/plugins/PluginIC2.java b/src/main/java/forestry/plugins/PluginIC2.java index a143e8435..0c328be5a 100644 --- a/src/main/java/forestry/plugins/PluginIC2.java +++ b/src/main/java/forestry/plugins/PluginIC2.java @@ -31,6 +31,7 @@ import forestry.api.circuits.ChipsetManager; import forestry.api.circuits.CircuitSocketType; import forestry.api.circuits.ICircuitLayout; import forestry.api.core.ForestryAPI; +import forestry.api.farming.IFarmProperties; import forestry.api.fuels.EngineBronzeFuel; import forestry.api.fuels.FuelManager; import forestry.api.modules.ForestryModule; @@ -61,10 +62,9 @@ import forestry.energy.circuits.CircuitElectricEfficiency; import forestry.farming.FarmRegistry; import forestry.farming.circuits.CircuitFarmLogic; import forestry.farming.logic.FarmLogicRubber; -import forestry.farming.logic.FarmableBasicIC2Crop; +import forestry.farming.logic.farmables.FarmableBasicIC2Crop; import forestry.modules.BlankForestryModule; import forestry.modules.ForestryModuleUids; - import ic2.api.item.IC2Items; import ic2.api.recipe.Recipes; @@ -117,7 +117,9 @@ public class PluginIC2 extends BlankForestryModule { rubber = IC2Items.getItem("crafting", "rubber"); fertilizer = IC2Items.getItem("crop_res","fertilizer"); - Circuits.farmRubberManual = new CircuitFarmLogic("manualRubber", new FarmLogicRubber()); + IFarmProperties rubberFarm = FarmRegistry.getInstance().registerLogic("farmRubber", FarmLogicRubber::new); + + Circuits.farmRubberManual = new CircuitFarmLogic("manualRubber", rubberFarm, true); ICircuitLayout layoutEngineTin = new CircuitLayout("engine.tin", CircuitSocketType.ELECTRIC_ENGINE); ChipsetManager.circuitRegistry.registerLayout(layoutEngineTin); diff --git a/src/main/java/forestry/plugins/PluginImmersiveEngineering.java b/src/main/java/forestry/plugins/PluginImmersiveEngineering.java index 37ae523a2..c97bf05fd 100644 --- a/src/main/java/forestry/plugins/PluginImmersiveEngineering.java +++ b/src/main/java/forestry/plugins/PluginImmersiveEngineering.java @@ -22,7 +22,7 @@ import forestry.api.modules.ForestryModule; import forestry.api.recipes.RecipeManagers; import forestry.core.config.Constants; import forestry.core.fluids.Fluids; -import forestry.farming.logic.FarmableDoubleCrop; +import forestry.farming.logic.farmables.FarmableDoubleCrop; import forestry.modules.ForestryModuleUids; @SuppressWarnings("unused") diff --git a/src/main/java/forestry/plugins/PluginMysticalAgriculture.java b/src/main/java/forestry/plugins/PluginMysticalAgriculture.java index a8a192b14..643a56eff 100644 --- a/src/main/java/forestry/plugins/PluginMysticalAgriculture.java +++ b/src/main/java/forestry/plugins/PluginMysticalAgriculture.java @@ -13,7 +13,7 @@ import forestry.api.modules.ForestryModule; import forestry.api.recipes.RecipeManagers; import forestry.core.config.Constants; import forestry.core.fluids.Fluids; -import forestry.farming.logic.FarmableAgingCrop; +import forestry.farming.logic.farmables.FarmableAgingCrop; import forestry.modules.ForestryModuleUids; @SuppressWarnings("unused") diff --git a/src/main/java/forestry/plugins/PluginNatura.java b/src/main/java/forestry/plugins/PluginNatura.java index fee432f6c..f6bd9fc53 100644 --- a/src/main/java/forestry/plugins/PluginNatura.java +++ b/src/main/java/forestry/plugins/PluginNatura.java @@ -33,7 +33,7 @@ import net.minecraftforge.fml.common.eventhandler.SubscribeEvent; import net.minecraftforge.fml.common.registry.ForgeRegistries; import forestry.api.core.ForestryAPI; -import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmProperties; import forestry.api.fuels.FuelManager; import forestry.api.fuels.MoistenerFuel; import forestry.api.modules.ForestryModule; @@ -48,8 +48,8 @@ import forestry.core.utils.ItemStackUtil; import forestry.core.utils.Log; import forestry.core.utils.ModUtil; import forestry.farming.FarmRegistry; -import forestry.farming.logic.FarmableAgingCrop; -import forestry.farming.logic.FarmableSapling; +import forestry.farming.logic.farmables.FarmableAgingCrop; +import forestry.farming.logic.farmables.FarmableSapling; import forestry.modules.BlankForestryModule; import forestry.modules.ForestryModuleUids; @@ -220,7 +220,7 @@ public class PluginNatura extends BlankForestryModule { return; } - FarmRegistry.getInstance().registerFarmables("farmWheat", + FarmRegistry.getInstance().registerFarmables("farmCrops", new FarmableAgingCrop( seedItem, block, @@ -266,8 +266,10 @@ public class PluginNatura extends BlankForestryModule { */ @Override public void postInit() { - IFarmLogic farmArboreal = FarmRegistry.getInstance().getFarmLogic("farmArboreal"); - farmArboreal.addSoil(new ItemStack(Blocks.NETHERRACK), Blocks.NETHERRACK.getDefaultState(), false); + IFarmProperties farmArboreal = FarmRegistry.getInstance().getProperties("managedArboreal"); + if(farmArboreal != null) { + farmArboreal.registerSoil(new ItemStack(Blocks.NETHERRACK), Blocks.NETHERRACK.getDefaultState(), false); + } } diff --git a/src/main/java/forestry/plugins/PluginRoots.java b/src/main/java/forestry/plugins/PluginRoots.java index ebe7f3056..fb077bc21 100644 --- a/src/main/java/forestry/plugins/PluginRoots.java +++ b/src/main/java/forestry/plugins/PluginRoots.java @@ -12,7 +12,7 @@ import forestry.api.modules.ForestryModule; import forestry.api.recipes.RecipeManagers; import forestry.core.config.Constants; import forestry.core.fluids.Fluids; -import forestry.farming.logic.FarmableAgingCrop; +import forestry.farming.logic.farmables.FarmableAgingCrop; import forestry.modules.ForestryModuleUids; @SuppressWarnings("unused") diff --git a/src/main/java/forestry/plugins/PluginRustic.java b/src/main/java/forestry/plugins/PluginRustic.java index e9bc0b304..405825de7 100644 --- a/src/main/java/forestry/plugins/PluginRustic.java +++ b/src/main/java/forestry/plugins/PluginRustic.java @@ -12,9 +12,9 @@ import forestry.api.modules.ForestryModule; import forestry.api.recipes.RecipeManagers; import forestry.core.config.Constants; import forestry.core.fluids.Fluids; -import forestry.farming.logic.FarmableAgingCrop; -import forestry.farming.logic.FarmableRusticGrape; -import forestry.farming.logic.FarmableRusticSapling; +import forestry.farming.logic.farmables.FarmableAgingCrop; +import forestry.farming.logic.farmables.FarmableRusticGrape; +import forestry.farming.logic.farmables.FarmableRusticSapling; import forestry.modules.ForestryModuleUids; @SuppressWarnings("unused") diff --git a/src/main/resources/assets/forestry/blockstates/arboretum.json b/src/main/resources/assets/forestry/blockstates/arboretum.json new file mode 100644 index 000000000..38cfda3d7 --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/arboretum.json @@ -0,0 +1,8 @@ +{ + "variants": { + "facing=north": { "model": "forestry:arboretum" }, + "facing=east": { "model": "forestry:arboretum", "y": 90 }, + "facing=south": { "model": "forestry:arboretum", "y": 180 }, + "facing=west": { "model": "forestry:arboretum", "y": -90 } + } +} diff --git a/src/main/resources/assets/forestry/blockstates/farm_crops.json b/src/main/resources/assets/forestry/blockstates/farm_crops.json new file mode 100644 index 000000000..f5d9956f2 --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/farm_crops.json @@ -0,0 +1,8 @@ +{ + "variants": { + "facing=north": { "model": "forestry:farm_crops" }, + "facing=east": { "model": "forestry:farm_crops", "y": 90 }, + "facing=south": { "model": "forestry:farm_crops", "y": 180 }, + "facing=west": { "model": "forestry:farm_crops", "y": -90 } + } +} diff --git a/src/main/resources/assets/forestry/blockstates/farm_ender.json b/src/main/resources/assets/forestry/blockstates/farm_ender.json new file mode 100644 index 000000000..17ac8dddc --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/farm_ender.json @@ -0,0 +1,8 @@ +{ + "variants": { + "facing=north": { "model": "forestry:farm_ender" }, + "facing=east": { "model": "forestry:farm_ender", "y": 90 }, + "facing=south": { "model": "forestry:farm_ender", "y": 180 }, + "facing=west": { "model": "forestry:farm_ender", "y": -90 } + } +} diff --git a/src/main/resources/assets/forestry/blockstates/farm_gourd.json b/src/main/resources/assets/forestry/blockstates/farm_gourd.json new file mode 100644 index 000000000..3f2e93938 --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/farm_gourd.json @@ -0,0 +1,8 @@ +{ + "variants": { + "facing=north": { "model": "forestry:farm_gourd" }, + "facing=east": { "model": "forestry:farm_gourd", "y": 90 }, + "facing=south": { "model": "forestry:farm_gourd", "y": 180 }, + "facing=west": { "model": "forestry:farm_gourd", "y": -90 } + } +} diff --git a/src/main/resources/assets/forestry/blockstates/farm_mushroom.json b/src/main/resources/assets/forestry/blockstates/farm_mushroom.json new file mode 100644 index 000000000..1fd7c7fa6 --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/farm_mushroom.json @@ -0,0 +1,8 @@ +{ + "variants": { + "facing=north": { "model": "forestry:farm_mushroom" }, + "facing=east": { "model": "forestry:farm_mushroom", "y": 90 }, + "facing=south": { "model": "forestry:farm_mushroom", "y": 180 }, + "facing=west": { "model": "forestry:farm_mushroom", "y": -90 } + } +} diff --git a/src/main/resources/assets/forestry/blockstates/farm_nether.json b/src/main/resources/assets/forestry/blockstates/farm_nether.json new file mode 100644 index 000000000..2affb37af --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/farm_nether.json @@ -0,0 +1,8 @@ +{ + "variants": { + "facing=north": { "model": "forestry:farm_nether" }, + "facing=east": { "model": "forestry:farm_nether", "y": 90 }, + "facing=south": { "model": "forestry:farm_nether", "y": 180 }, + "facing=west": { "model": "forestry:farm_nether", "y": -90 } + } +} diff --git a/src/main/resources/assets/forestry/blockstates/peat_bog.json b/src/main/resources/assets/forestry/blockstates/peat_bog.json new file mode 100644 index 000000000..fbd9a1f1c --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/peat_bog.json @@ -0,0 +1,8 @@ +{ + "variants": { + "facing=north": { "model": "forestry:peat_bog" }, + "facing=east": { "model": "forestry:peat_bog", "y": 90 }, + "facing=south": { "model": "forestry:peat_bog", "y": 180 }, + "facing=west": { "model": "forestry:peat_bog", "y": -90 } + } +} diff --git a/src/main/resources/assets/forestry/blockstates/plantation.json b/src/main/resources/assets/forestry/blockstates/plantation.json new file mode 100644 index 000000000..37abb8efb --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/plantation.json @@ -0,0 +1,8 @@ +{ + "variants": { + "facing=north": { "model": "forestry:plantation" }, + "facing=east": { "model": "forestry:plantation", "y": 90 }, + "facing=south": { "model": "forestry:plantation", "y": 180 }, + "facing=west": { "model": "forestry:plantation", "y": -90 } + } +} diff --git a/src/main/resources/assets/forestry/models/block/arboretum.json b/src/main/resources/assets/forestry/models/block/arboretum.json new file mode 100644 index 000000000..f67ff350c --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/arboretum.json @@ -0,0 +1,57 @@ +{ + "parent": "block/block", + "textures": { + "particle": "forestry:blocks/arboretum_particle", + "texture": "forestry:blocks/arboretum" + }, + "elements": [ + { + "__comment": "base", + "from": [ 0, 0, 0 ], + "to": [ 16, 4, 16 ], + "faces": { + "down": { "uv": [ 4, 4, 8, 8 ], "texture": "#texture", "cullface": "down" }, + "up": { "uv": [ 0, 4, 4, 8 ], "texture": "#texture" }, + "north": { "uv": [ 8, 4, 12, 5 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 6, 12, 7 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 7, 12, 8 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 5, 12, 6 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "ceiling", + "from": [ 0, 12, 0 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 4, 0, 8, 4 ], "texture": "#texture" }, + "up": { "uv": [ 0, 0, 4, 4 ], "texture": "#texture", "cullface": "up" }, + "north": { "uv": [ 8, 0, 12, 1 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 2, 12, 3 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 3, 12, 4 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 1, 12, 2 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "terrarium", + "from": [ 2, 4, 2 ], + "to": [ 14, 12, 14 ], + "faces": { + "north": { "uv": [ 0, 13.5, 3, 15.5 ], "texture": "#texture" }, + "south": { "uv": [ 6, 13.5, 9, 15.5 ], "texture": "#texture" }, + "west": { "uv": [ 9, 13.5, 12, 15.5 ], "texture": "#texture" }, + "east": { "uv": [ 3, 13.5, 6, 15.5 ], "texture": "#texture" } + } + }, + { + "__comment": "showcase", + "from": [ 4, 4, 4 ], + "to": [ 12, 12, 12 ], + "faces": { + "north": { "uv": [ 6, 10, 8, 12 ], "texture": "#texture" }, + "south": { "uv": [ 10, 10, 12, 12 ], "texture": "#texture" }, + "west": { "uv": [ 12, 10, 14, 12 ], "texture": "#texture" }, + "east": { "uv": [ 8, 10, 10, 12 ], "texture": "#texture" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/farm_crops.json b/src/main/resources/assets/forestry/models/block/farm_crops.json new file mode 100644 index 000000000..4665ccd49 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/farm_crops.json @@ -0,0 +1,57 @@ +{ + "parent": "block/block", + "textures": { + "particle": "forestry:blocks/farm_crops_particle", + "texture": "forestry:blocks/farm_crops" + }, + "elements": [ + { + "__comment": "base", + "from": [ 0, 0, 0 ], + "to": [ 16, 4, 16 ], + "faces": { + "down": { "uv": [ 4, 4, 8, 8 ], "texture": "#texture", "cullface": "down" }, + "up": { "uv": [ 0, 4, 4, 8 ], "texture": "#texture" }, + "north": { "uv": [ 8, 4, 12, 5 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 6, 12, 7 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 7, 12, 8 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 5, 12, 6 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "ceiling", + "from": [ 0, 12, 0 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 4, 0, 8, 4 ], "texture": "#texture" }, + "up": { "uv": [ 0, 0, 4, 4 ], "texture": "#texture", "cullface": "up" }, + "north": { "uv": [ 8, 0, 12, 1 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 2, 12, 3 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 3, 12, 4 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 1, 12, 2 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "terrarium", + "from": [ 2, 4, 2 ], + "to": [ 14, 12, 14 ], + "faces": { + "north": { "uv": [ 0, 13.5, 3, 15.5 ], "texture": "#texture" }, + "south": { "uv": [ 6, 13.5, 9, 15.5 ], "texture": "#texture" }, + "west": { "uv": [ 9, 13.5, 12, 15.5 ], "texture": "#texture" }, + "east": { "uv": [ 3, 13.5, 6, 15.5 ], "texture": "#texture" } + } + }, + { + "__comment": "showcase", + "from": [ 4, 4, 4 ], + "to": [ 12, 12, 12 ], + "faces": { + "north": { "uv": [ 6, 10, 8, 12 ], "texture": "#texture" }, + "south": { "uv": [ 10, 10, 12, 12 ], "texture": "#texture" }, + "west": { "uv": [ 12, 10, 14, 12 ], "texture": "#texture" }, + "east": { "uv": [ 8, 10, 10, 12 ], "texture": "#texture" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/farm_ender.json b/src/main/resources/assets/forestry/models/block/farm_ender.json new file mode 100644 index 000000000..6b2fd1f90 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/farm_ender.json @@ -0,0 +1,57 @@ +{ + "parent": "block/block", + "textures": { + "particle": "forestry:blocks/farm_ender_particle", + "texture": "forestry:blocks/farm_ender" + }, + "elements": [ + { + "__comment": "base", + "from": [ 0, 0, 0 ], + "to": [ 16, 4, 16 ], + "faces": { + "down": { "uv": [ 4, 4, 8, 8 ], "texture": "#texture", "cullface": "down" }, + "up": { "uv": [ 0, 4, 4, 8 ], "texture": "#texture" }, + "north": { "uv": [ 8, 4, 12, 5 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 6, 12, 7 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 7, 12, 8 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 5, 12, 6 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "ceiling", + "from": [ 0, 12, 0 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 4, 0, 8, 4 ], "texture": "#texture" }, + "up": { "uv": [ 0, 0, 4, 4 ], "texture": "#texture", "cullface": "up" }, + "north": { "uv": [ 8, 0, 12, 1 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 2, 12, 3 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 3, 12, 4 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 1, 12, 2 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "terrarium", + "from": [ 2, 4, 2 ], + "to": [ 14, 12, 14 ], + "faces": { + "north": { "uv": [ 0, 13.5, 3, 15.5 ], "texture": "#texture" }, + "south": { "uv": [ 6, 13.5, 9, 15.5 ], "texture": "#texture" }, + "west": { "uv": [ 9, 13.5, 12, 15.5 ], "texture": "#texture" }, + "east": { "uv": [ 3, 13.5, 6, 15.5 ], "texture": "#texture" } + } + }, + { + "__comment": "showcase", + "from": [ 4, 4, 4 ], + "to": [ 12, 12, 12 ], + "faces": { + "north": { "uv": [ 6, 10, 8, 12 ], "texture": "#texture" }, + "south": { "uv": [ 10, 10, 12, 12 ], "texture": "#texture" }, + "west": { "uv": [ 12, 10, 14, 12 ], "texture": "#texture" }, + "east": { "uv": [ 8, 10, 10, 12 ], "texture": "#texture" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/farm_gourd.json b/src/main/resources/assets/forestry/models/block/farm_gourd.json new file mode 100644 index 000000000..27486a1e7 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/farm_gourd.json @@ -0,0 +1,57 @@ +{ + "parent": "block/block", + "textures": { + "particle": "forestry:blocks/farm_gourd_particle", + "texture": "forestry:blocks/farm_gourd" + }, + "elements": [ + { + "__comment": "base", + "from": [ 0, 0, 0 ], + "to": [ 16, 4, 16 ], + "faces": { + "down": { "uv": [ 4, 4, 8, 8 ], "texture": "#texture", "cullface": "down" }, + "up": { "uv": [ 0, 4, 4, 8 ], "texture": "#texture" }, + "north": { "uv": [ 8, 4, 12, 5 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 6, 12, 7 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 7, 12, 8 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 5, 12, 6 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "ceiling", + "from": [ 0, 12, 0 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 4, 0, 8, 4 ], "texture": "#texture" }, + "up": { "uv": [ 0, 0, 4, 4 ], "texture": "#texture", "cullface": "up" }, + "north": { "uv": [ 8, 0, 12, 1 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 2, 12, 3 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 3, 12, 4 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 1, 12, 2 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "terrarium", + "from": [ 2, 4, 2 ], + "to": [ 14, 12, 14 ], + "faces": { + "north": { "uv": [ 0, 13.5, 3, 15.5 ], "texture": "#texture" }, + "south": { "uv": [ 6, 13.5, 9, 15.5 ], "texture": "#texture" }, + "west": { "uv": [ 9, 13.5, 12, 15.5 ], "texture": "#texture" }, + "east": { "uv": [ 3, 13.5, 6, 15.5 ], "texture": "#texture" } + } + }, + { + "__comment": "showcase", + "from": [ 4, 4, 4 ], + "to": [ 12, 12, 12 ], + "faces": { + "north": { "uv": [ 6, 10, 8, 12 ], "texture": "#texture" }, + "south": { "uv": [ 10, 10, 12, 12 ], "texture": "#texture" }, + "west": { "uv": [ 12, 10, 14, 12 ], "texture": "#texture" }, + "east": { "uv": [ 8, 10, 10, 12 ], "texture": "#texture" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/farm_mushroom.json b/src/main/resources/assets/forestry/models/block/farm_mushroom.json new file mode 100644 index 000000000..0835f8385 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/farm_mushroom.json @@ -0,0 +1,57 @@ +{ + "parent": "block/block", + "textures": { + "particle": "forestry:blocks/farm_mushroom_particle", + "texture": "forestry:blocks/farm_mushroom" + }, + "elements": [ + { + "__comment": "base", + "from": [ 0, 0, 0 ], + "to": [ 16, 4, 16 ], + "faces": { + "down": { "uv": [ 4, 4, 8, 8 ], "texture": "#texture", "cullface": "down" }, + "up": { "uv": [ 0, 4, 4, 8 ], "texture": "#texture" }, + "north": { "uv": [ 8, 4, 12, 5 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 6, 12, 7 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 7, 12, 8 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 5, 12, 6 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "ceiling", + "from": [ 0, 12, 0 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 4, 0, 8, 4 ], "texture": "#texture" }, + "up": { "uv": [ 0, 0, 4, 4 ], "texture": "#texture", "cullface": "up" }, + "north": { "uv": [ 8, 0, 12, 1 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 2, 12, 3 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 3, 12, 4 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 1, 12, 2 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "terrarium", + "from": [ 2, 4, 2 ], + "to": [ 14, 12, 14 ], + "faces": { + "north": { "uv": [ 0, 13.5, 3, 15.5 ], "texture": "#texture" }, + "south": { "uv": [ 6, 13.5, 9, 15.5 ], "texture": "#texture" }, + "west": { "uv": [ 9, 13.5, 12, 15.5 ], "texture": "#texture" }, + "east": { "uv": [ 3, 13.5, 6, 15.5 ], "texture": "#texture" } + } + }, + { + "__comment": "showcase", + "from": [ 4, 4, 4 ], + "to": [ 12, 12, 12 ], + "faces": { + "north": { "uv": [ 6, 10, 8, 12 ], "texture": "#texture" }, + "south": { "uv": [ 10, 10, 12, 12 ], "texture": "#texture" }, + "west": { "uv": [ 12, 10, 14, 12 ], "texture": "#texture" }, + "east": { "uv": [ 8, 10, 10, 12 ], "texture": "#texture" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/farm_nether.json b/src/main/resources/assets/forestry/models/block/farm_nether.json new file mode 100644 index 000000000..38939afd0 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/farm_nether.json @@ -0,0 +1,57 @@ +{ + "parent": "block/block", + "textures": { + "particle": "forestry:blocks/farm_nether_particle", + "texture": "forestry:blocks/farm_nether" + }, + "elements": [ + { + "__comment": "base", + "from": [ 0, 0, 0 ], + "to": [ 16, 4, 16 ], + "faces": { + "down": { "uv": [ 4, 4, 8, 8 ], "texture": "#texture", "cullface": "down" }, + "up": { "uv": [ 0, 4, 4, 8 ], "texture": "#texture" }, + "north": { "uv": [ 8, 4, 12, 5 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 6, 12, 7 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 7, 12, 8 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 5, 12, 6 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "ceiling", + "from": [ 0, 12, 0 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 4, 0, 8, 4 ], "texture": "#texture" }, + "up": { "uv": [ 0, 0, 4, 4 ], "texture": "#texture", "cullface": "up" }, + "north": { "uv": [ 8, 0, 12, 1 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 2, 12, 3 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 3, 12, 4 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 1, 12, 2 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "terrarium", + "from": [ 2, 4, 2 ], + "to": [ 14, 12, 14 ], + "faces": { + "north": { "uv": [ 0, 13.5, 3, 15.5 ], "texture": "#texture" }, + "south": { "uv": [ 6, 13.5, 9, 15.5 ], "texture": "#texture" }, + "west": { "uv": [ 9, 13.5, 12, 15.5 ], "texture": "#texture" }, + "east": { "uv": [ 3, 13.5, 6, 15.5 ], "texture": "#texture" } + } + }, + { + "__comment": "showcase", + "from": [ 4, 4, 4 ], + "to": [ 12, 12, 12 ], + "faces": { + "north": { "uv": [ 6, 10, 8, 12 ], "texture": "#texture" }, + "south": { "uv": [ 10, 10, 12, 12 ], "texture": "#texture" }, + "west": { "uv": [ 12, 10, 14, 12 ], "texture": "#texture" }, + "east": { "uv": [ 8, 10, 10, 12 ], "texture": "#texture" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/peat_bog.json b/src/main/resources/assets/forestry/models/block/peat_bog.json new file mode 100644 index 000000000..930fd9fa8 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/peat_bog.json @@ -0,0 +1,57 @@ +{ + "parent": "block/block", + "textures": { + "particle": "forestry:blocks/peat_bog_particle", + "texture": "forestry:blocks/peat_bog" + }, + "elements": [ + { + "__comment": "base", + "from": [ 0, 0, 0 ], + "to": [ 16, 4, 16 ], + "faces": { + "down": { "uv": [ 4, 4, 8, 8 ], "texture": "#texture", "cullface": "down" }, + "up": { "uv": [ 0, 4, 4, 8 ], "texture": "#texture" }, + "north": { "uv": [ 8, 4, 12, 5 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 6, 12, 7 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 7, 12, 8 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 5, 12, 6 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "ceiling", + "from": [ 0, 12, 0 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 4, 0, 8, 4 ], "texture": "#texture" }, + "up": { "uv": [ 0, 0, 4, 4 ], "texture": "#texture", "cullface": "up" }, + "north": { "uv": [ 8, 0, 12, 1 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 2, 12, 3 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 3, 12, 4 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 1, 12, 2 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "terrarium", + "from": [ 2, 4, 2 ], + "to": [ 14, 12, 14 ], + "faces": { + "north": { "uv": [ 0, 13.5, 3, 15.5 ], "texture": "#texture" }, + "south": { "uv": [ 6, 13.5, 9, 15.5 ], "texture": "#texture" }, + "west": { "uv": [ 9, 13.5, 12, 15.5 ], "texture": "#texture" }, + "east": { "uv": [ 3, 13.5, 6, 15.5 ], "texture": "#texture" } + } + }, + { + "__comment": "showcase", + "from": [ 4, 4, 4 ], + "to": [ 12, 12, 12 ], + "faces": { + "north": { "uv": [ 6, 10, 8, 12 ], "texture": "#texture" }, + "south": { "uv": [ 10, 10, 12, 12 ], "texture": "#texture" }, + "west": { "uv": [ 12, 10, 14, 12 ], "texture": "#texture" }, + "east": { "uv": [ 8, 10, 10, 12 ], "texture": "#texture" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/block/plantation.json b/src/main/resources/assets/forestry/models/block/plantation.json new file mode 100644 index 000000000..cbd8eb271 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/plantation.json @@ -0,0 +1,57 @@ +{ + "parent": "block/block", + "textures": { + "particle": "forestry:blocks/plantation_particle", + "texture": "forestry:blocks/plantation" + }, + "elements": [ + { + "__comment": "base", + "from": [ 0, 0, 0 ], + "to": [ 16, 4, 16 ], + "faces": { + "down": { "uv": [ 4, 4, 8, 8 ], "texture": "#texture", "cullface": "down" }, + "up": { "uv": [ 0, 4, 4, 8 ], "texture": "#texture" }, + "north": { "uv": [ 8, 4, 12, 5 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 6, 12, 7 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 7, 12, 8 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 5, 12, 6 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "ceiling", + "from": [ 0, 12, 0 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 4, 0, 8, 4 ], "texture": "#texture" }, + "up": { "uv": [ 0, 0, 4, 4 ], "texture": "#texture", "cullface": "up" }, + "north": { "uv": [ 8, 0, 12, 1 ], "texture": "#texture", "cullface": "north" }, + "south": { "uv": [ 8, 2, 12, 3 ], "texture": "#texture", "cullface": "south" }, + "west": { "uv": [ 8, 3, 12, 4 ], "texture": "#texture", "cullface": "west" }, + "east": { "uv": [ 8, 1, 12, 2 ], "texture": "#texture", "cullface": "east" } + } + }, + { + "__comment": "terrarium", + "from": [ 2, 4, 2 ], + "to": [ 14, 12, 14 ], + "faces": { + "north": { "uv": [ 0, 13.5, 3, 15.5 ], "texture": "#texture" }, + "south": { "uv": [ 6, 13.5, 9, 15.5 ], "texture": "#texture" }, + "west": { "uv": [ 9, 13.5, 12, 15.5 ], "texture": "#texture" }, + "east": { "uv": [ 3, 13.5, 6, 15.5 ], "texture": "#texture" } + } + }, + { + "__comment": "showcase", + "from": [ 4, 4, 4 ], + "to": [ 12, 12, 12 ], + "faces": { + "north": { "uv": [ 6, 10, 8, 12 ], "texture": "#texture" }, + "south": { "uv": [ 10, 10, 12, 12 ], "texture": "#texture" }, + "west": { "uv": [ 12, 10, 14, 12 ], "texture": "#texture" }, + "east": { "uv": [ 8, 10, 10, 12 ], "texture": "#texture" } + } + } + ] +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/item/arboretum.json b/src/main/resources/assets/forestry/models/item/arboretum.json new file mode 100644 index 000000000..44bea737c --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/arboretum.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/arboretum" +} diff --git a/src/main/resources/assets/forestry/models/item/farm_crops.json b/src/main/resources/assets/forestry/models/item/farm_crops.json new file mode 100644 index 000000000..62eb2bffe --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/farm_crops.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/farm_crops" +} diff --git a/src/main/resources/assets/forestry/models/item/farm_ender.json b/src/main/resources/assets/forestry/models/item/farm_ender.json new file mode 100644 index 000000000..fd3d60792 --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/farm_ender.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/farm_ender" +} diff --git a/src/main/resources/assets/forestry/models/item/farm_gourd.json b/src/main/resources/assets/forestry/models/item/farm_gourd.json new file mode 100644 index 000000000..da1f79c97 --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/farm_gourd.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/farm_gourd" +} diff --git a/src/main/resources/assets/forestry/models/item/farm_mushroom.json b/src/main/resources/assets/forestry/models/item/farm_mushroom.json new file mode 100644 index 000000000..ef45652eb --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/farm_mushroom.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/farm_mushroom" +} diff --git a/src/main/resources/assets/forestry/models/item/farm_nether.json b/src/main/resources/assets/forestry/models/item/farm_nether.json new file mode 100644 index 000000000..31e2689fe --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/farm_nether.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/farm_nether" +} diff --git a/src/main/resources/assets/forestry/models/item/flexible_casing.json b/src/main/resources/assets/forestry/models/item/flexible_casing.json new file mode 100644 index 000000000..48566c3b0 --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/flexible_casing.json @@ -0,0 +1,6 @@ +{ + "parent": "item/generated", + "textures": { + "layer0": "forestry:items/flexible_casing" + } +} diff --git a/src/main/resources/assets/forestry/models/item/peat_bog.json b/src/main/resources/assets/forestry/models/item/peat_bog.json new file mode 100644 index 000000000..b697de6c8 --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/peat_bog.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/peat_bog" +} diff --git a/src/main/resources/assets/forestry/models/item/plantation.json b/src/main/resources/assets/forestry/models/item/plantation.json new file mode 100644 index 000000000..40309ffdf --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/plantation.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/plantation" +} diff --git a/src/main/resources/assets/forestry/textures/blocks/arboretum.png b/src/main/resources/assets/forestry/textures/blocks/arboretum.png new file mode 100644 index 000000000..10fbf0364 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/arboretum.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/arboretum_particle.png b/src/main/resources/assets/forestry/textures/blocks/arboretum_particle.png new file mode 100644 index 000000000..571cf354d Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/arboretum_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_crops.png b/src/main/resources/assets/forestry/textures/blocks/farm_crops.png new file mode 100644 index 000000000..8825a487a Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_crops.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_crops_particle.png b/src/main/resources/assets/forestry/textures/blocks/farm_crops_particle.png new file mode 100644 index 000000000..aed262599 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_crops_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_ender.png b/src/main/resources/assets/forestry/textures/blocks/farm_ender.png new file mode 100644 index 000000000..f54084ada Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_ender.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_ender_particle.png b/src/main/resources/assets/forestry/textures/blocks/farm_ender_particle.png new file mode 100644 index 000000000..f99ed652d Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_ender_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_gourd.png b/src/main/resources/assets/forestry/textures/blocks/farm_gourd.png new file mode 100644 index 000000000..49fcf74c9 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_gourd.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_gourd_particle.png b/src/main/resources/assets/forestry/textures/blocks/farm_gourd_particle.png new file mode 100644 index 000000000..9d1941586 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_gourd_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_mushroom.png b/src/main/resources/assets/forestry/textures/blocks/farm_mushroom.png new file mode 100644 index 000000000..435a43e5e Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_mushroom.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_mushroom_particle.png b/src/main/resources/assets/forestry/textures/blocks/farm_mushroom_particle.png new file mode 100644 index 000000000..9c651a543 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_mushroom_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_nether.png b/src/main/resources/assets/forestry/textures/blocks/farm_nether.png new file mode 100644 index 000000000..e6efda824 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_nether.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/farm_nether_particle.png b/src/main/resources/assets/forestry/textures/blocks/farm_nether_particle.png new file mode 100644 index 000000000..4c91f68b1 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/farm_nether_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/peat_bog.png b/src/main/resources/assets/forestry/textures/blocks/peat_bog.png new file mode 100644 index 000000000..700845a12 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/peat_bog.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/peat_bog_particle.png b/src/main/resources/assets/forestry/textures/blocks/peat_bog_particle.png new file mode 100644 index 000000000..416d80ed6 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/peat_bog_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/plantation.png b/src/main/resources/assets/forestry/textures/blocks/plantation.png new file mode 100644 index 000000000..0325070fb Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/plantation.png differ diff --git a/src/main/resources/assets/forestry/textures/blocks/plantation_particle.png b/src/main/resources/assets/forestry/textures/blocks/plantation_particle.png new file mode 100644 index 000000000..3ae105a84 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/blocks/plantation_particle.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/buttons.png b/src/main/resources/assets/forestry/textures/gui/buttons.png index dc5ee1fee..c2d3824e4 100755 Binary files a/src/main/resources/assets/forestry/textures/gui/buttons.png and b/src/main/resources/assets/forestry/textures/gui/buttons.png differ diff --git a/src/main/resources/assets/forestry/textures/gui/planter.png b/src/main/resources/assets/forestry/textures/gui/planter.png new file mode 100644 index 000000000..2b71e1ff1 Binary files /dev/null and b/src/main/resources/assets/forestry/textures/gui/planter.png differ diff --git a/src/main/resources/assets/forestry/textures/items/flexible_casing.png b/src/main/resources/assets/forestry/textures/items/flexible_casing.png new file mode 100644 index 000000000..1c0fcb15f Binary files /dev/null and b/src/main/resources/assets/forestry/textures/items/flexible_casing.png differ