From 10fec504571bf3f392b0013cfda018699174b04c Mon Sep 17 00:00:00 2001 From: Nedelosk Date: Sun, 14 Jan 2018 17:31:53 +0100 Subject: [PATCH] Improve Farm Logic System and add ring farm layout --- lang | 2 +- .../forestry/api/farming/IFarmHousing.java | 4 + .../forestry/api/farming/IFarmInstance.java | 30 +++++ .../java/forestry/api/farming/IFarmLogic.java | 49 +++++++- .../forestry/api/farming/IFarmRegistry.java | 62 +++++++++- .../api/farming/ISimpleFarmLogic.java | 10 +- src/main/java/forestry/api/farming/ISoil.java | 16 +++ .../java/forestry/core/blocks/BlockBase.java | 5 +- .../core/circuits/CircuitRegistry.java | 6 +- .../java/forestry/core/circuits/Circuits.java | 17 ++- .../java/forestry/core/config/Config.java | 9 ++ .../cultivation/ModuleCultivation.java | 6 + .../cultivation/blocks/BlockPlanter.java | 85 ++++++++++++++ .../blocks/BlockRegistryCultivation.java | 34 ++++-- .../blocks/PlanterStateMapper.java | 43 +++++++ .../cultivation/items/ItemBlockPlanter.java | 19 +++ .../cultivation/items/package-info.java | 10 ++ .../cultivation/tiles/TilePlantation.java | 7 +- .../cultivation/tiles/TilePlanter.java | 44 +++++-- .../forestry/farming/DummyFarmRegistry.java | 40 ++++++- .../java/forestry/farming/FarmRegistry.java | 63 +++++++--- .../java/forestry/farming/ModuleFarming.java | 75 ++++++++---- .../farming/circuits/CircuitFarmLogic.java | 16 ++- .../farming/logic/FakeFarmInstance.java | 54 +++++++++ .../forestry/farming/logic/FarmInstance.java | 80 +++++++++++++ .../forestry/farming/logic/FarmLogic.java | 70 ++++++++---- .../farming/logic/FarmLogicArboreal.java | 26 +++-- .../farming/logic/FarmLogicCocoa.java | 5 + .../farming/logic/FarmLogicCrops.java | 48 ++------ .../forestry/farming/logic/FarmLogicExU.java | 35 +----- .../farming/logic/FarmLogicGourd.java | 32 +----- .../farming/logic/FarmLogicHomogeneous.java | 79 ++++--------- .../farming/logic/FarmLogicInfernal.java | 12 +- .../farming/logic/FarmLogicMushroom.java | 7 +- .../farming/logic/FarmLogicOrchard.java | 13 +-- .../forestry/farming/logic/FarmLogicPeat.java | 16 +-- .../farming/logic/FarmLogicReeds.java | 44 +------ .../farming/logic/FarmLogicRubber.java | 6 +- .../farming/logic/FarmLogicSimple.java | 12 +- .../forestry/farming/logic/FarmLogicSoil.java | 19 +-- .../farming/logic/FarmLogicSucculent.java | 47 ++------ .../farming/logic/FarmLogicWatered.java | 49 +++----- .../java/forestry/farming/logic/Soil.java | 56 ++++----- .../farming/logic/crops/CropBasicIC2Crop.java | 3 + .../farming/logic/crops/CropDestroy.java | 27 +++++ .../logic/farmables/FarmableAgingCrop.java | 2 +- .../logic/farmables/FarmableSapling.java | 108 +++++++++--------- .../forestry/farming/logic/package-info.java | 5 +- .../multiblock/FakeFarmController.java | 4 +- .../farming/multiblock/FarmController.java | 4 +- .../plugins/PluginExtraUtilities.java | 25 ++-- src/main/java/forestry/plugins/PluginIC2.java | 5 +- .../java/forestry/plugins/PluginNatura.java | 8 +- 53 files changed, 1019 insertions(+), 534 deletions(-) create mode 100644 src/main/java/forestry/api/farming/IFarmInstance.java create mode 100644 src/main/java/forestry/api/farming/ISoil.java create mode 100644 src/main/java/forestry/cultivation/blocks/PlanterStateMapper.java create mode 100644 src/main/java/forestry/cultivation/items/ItemBlockPlanter.java create mode 100644 src/main/java/forestry/cultivation/items/package-info.java create mode 100644 src/main/java/forestry/farming/logic/FakeFarmInstance.java create mode 100644 src/main/java/forestry/farming/logic/FarmInstance.java diff --git a/lang b/lang index 7b6f08376..4ee2f885f 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit 7b6f08376464eaade21f3a438981e519e046fa57 +Subproject commit 4ee2f885f8f6af1b3d498667bae4d59dbcd69551 diff --git a/src/main/java/forestry/api/farming/IFarmHousing.java b/src/main/java/forestry/api/farming/IFarmHousing.java index cc19ebd9f..c6a22061e 100644 --- a/src/main/java/forestry/api/farming/IFarmHousing.java +++ b/src/main/java/forestry/api/farming/IFarmHousing.java @@ -61,6 +61,10 @@ public interface IFarmHousing extends IErrorLogicSource { return false; } + default boolean canPlantSoil(boolean manual){ + return true; + } + /* INTERACTION WITH HATCHES */ IFarmInventory getFarmInventory(); diff --git a/src/main/java/forestry/api/farming/IFarmInstance.java b/src/main/java/forestry/api/farming/IFarmInstance.java new file mode 100644 index 000000000..6903e2711 --- /dev/null +++ b/src/main/java/forestry/api/farming/IFarmInstance.java @@ -0,0 +1,30 @@ +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 IFarmInstance { + + default void registerSoil(ItemStack resource, IBlockState soilState){ + registerSoil(resource, soilState, false); + } + + void registerSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData); + + boolean isAcceptedSoil(IBlockState blockState); + + boolean isAcceptedResource(ItemStack itemStack); + + String getIdentifier(); + + Collection getSoils(); + + Collection getFarmables(); + + IFarmLogic getLogic(boolean manuel); +} diff --git a/src/main/java/forestry/api/farming/IFarmLogic.java b/src/main/java/forestry/api/farming/IFarmLogic.java index 873fcc353..640e53661 100644 --- a/src/main/java/forestry/api/farming/IFarmLogic.java +++ b/src/main/java/forestry/api/farming/IFarmLogic.java @@ -8,6 +8,7 @@ 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; @@ -17,10 +18,20 @@ import net.minecraft.world.World; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; +import forestry.api.core.ForestryAPI; + 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(); + /** + * @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); boolean isAcceptedResource(ItemStack itemstack); @@ -33,20 +44,50 @@ public interface IFarmLogic { Collection harvest(World world, BlockPos pos, FarmDirection direction, int extent); - IFarmLogic setManual(boolean manual); + /** + * @deprecated Since Forestry 5.8 logic instances are created at the constructor of the {@link IFarmInstance} and + * have a immutable manual state. TODO Remove this method in 1.13 + */ + @Deprecated + default IFarmLogic setManual(boolean manual){ + return this; + } - void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData); + /** + * @since Forestry 5.8 + * + * @return Returns the {@link IFarmInstance} that created this logic. Returns a fake instance from + * {@link IFarmRegistry#createFakeInstance(IFarmLogic)} if the logic is older that Forestry 5.8. + */ + default IFarmInstance getInstance(){ + return ForestryAPI.farmRegistry.createFakeInstance(this); + } + /** + * Use {@link IFarmRegistry#getFarm(String)} to get the soil container for the farm logic and register the soil + * with {@link IFarmInstance#registerSoil(ItemStack, IBlockState, boolean)}. + */ + @Deprecated + default void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData){ + // + } + + /** + * @return A short localized name for this logic. + */ String getName(); /* GUI ONLY */ /** - * @deprecated TODO remove this method in 1.13 + * @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) - ResourceLocation getTextureMap(); + 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/IFarmRegistry.java b/src/main/java/forestry/api/farming/IFarmRegistry.java index 0b8d8bb9a..760c6ce08 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; @@ -16,9 +17,29 @@ public interface IFarmRegistry { * Registers farming logic in registry under given identifier * @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(IFarmInstance)}. */ - void registerFarmLogic(String identifier, IFarmLogic logic); - + @Deprecated + void registerLogic(String identifier, IFarmLogic logic); + + /** + * Registers farming logic in registry + * @since Forestry 5.8 + */ + IFarmInstance registerLogic(IFarmInstance 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 + */ + IFarmInstance registerLogic(String identifier, BiFunction logicFactory, String... farmablesIdentifiers); + /** * Can be used to add IFarmables to some of the vanilla farm logics. *

@@ -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(IFarmInstance, 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,32 @@ public interface IFarmRegistry { * @return The value of the fertitlizer */ int getFertilizeValue(ItemStack itemStack); + + /** + * Returns a fake {@link IFarmInstance} that returns the given logic at {@link IFarmInstance#getLogic(boolean)}. + * + * @since Forestry 5.8 + * @deprecated Only for backwards comparability. + */ + @Deprecated + IFarmInstance 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(IFarmInstance instance, boolean isManual, ISimpleFarmLogic simpleFarmLogic); + + /** + * + * @param identifier + * @return + * + * @since Forestry 5.8 + */ + @Nullable + IFarmInstance getFarm(String identifier); } 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/core/blocks/BlockBase.java b/src/main/java/forestry/core/blocks/BlockBase.java index 1922d22ca..7c422379b 100755 --- a/src/main/java/forestry/core/blocks/BlockBase.java +++ b/src/main/java/forestry/core/blocks/BlockBase.java @@ -76,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); @@ -88,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); } 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 b45a1b1e3..aeee7dd36 100644 --- a/src/main/java/forestry/core/circuits/Circuits.java +++ b/src/main/java/forestry/core/circuits/Circuits.java @@ -8,29 +8,38 @@ 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 farmCropsManaged; public static ICircuit farmPeatManaged; public static ICircuit farmSucculentManaged; public static ICircuit farmPoaleManaged; - public static ICircuit farmFungal; public static ICircuit farmInfernalManaged; + public static ICircuit farmEnderManaged; + public static ICircuit farmOrchidManaged; public static ICircuit farmGourdManaged; + + + public static ICircuit farmArborealManual; + public static ICircuit farmOrchardManual; public static ICircuit farmShroomManual; 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/config/Config.java b/src/main/java/forestry/core/config/Config.java index 970418c5a..546901e34 100755 --- a/src/main/java/forestry/core/config/Config.java +++ b/src/main/java/forestry/core/config/Config.java @@ -102,6 +102,11 @@ public class Config { private static boolean enableExUtilRedOrchid = true; private static boolean enableMagicalCropsSupport = true; + // Cultivation + public static int planterExtend = 4; + public static boolean ringFarms = false; + public static int ringSize = 4; + // Mail public static boolean mailAlertEnabled = true; public static GuiMailboxInfo.XPosition mailAlertXPosition = GuiMailboxInfo.XPosition.LEFT; @@ -266,6 +271,10 @@ public class Config { 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/cultivation/ModuleCultivation.java b/src/main/java/forestry/cultivation/ModuleCultivation.java index 28c23703f..3e33df0c8 100644 --- a/src/main/java/forestry/cultivation/ModuleCultivation.java +++ b/src/main/java/forestry/cultivation/ModuleCultivation.java @@ -18,6 +18,7 @@ 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; @@ -113,5 +114,10 @@ public class ModuleCultivation extends BlankForestryModule { 'G', OreDictUtil.BLOCK_GLASS, 'W', Items.NETHER_WART, 'A', blocks.arboretum); + + for(BlockPlanter planter : getBlocks().getPlanters()){ + RecipeUtil.addRecipe(planter.blockType.getName() + "_manual_managed", planter.get(true), "# ", " ", " ", '#', planter.get(false)); + RecipeUtil.addRecipe(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 index 5f56462b9..92cdb1623 100644 --- a/src/main/java/forestry/cultivation/blocks/BlockPlanter.java +++ b/src/main/java/forestry/cultivation/blocks/BlockPlanter.java @@ -1,17 +1,102 @@ package forestry.cultivation.blocks; 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.nbt.NBTTagByte; +import net.minecraft.nbt.NBTTagCompound; +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.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); + } + + @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 + @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){ + NBTTagCompound tagCompound = stack.getTagCompound(); + if(tagCompound != null){ + return tagCompound.getBoolean("Manual"); + } + return false; + } + + public ItemStack get(boolean isManual){ + ItemStack stack = new ItemStack(this); + stack.setTagInfo("Manual", new NBTTagByte((byte) (isManual ? 1 : 0))); + return stack; + } } diff --git a/src/main/java/forestry/cultivation/blocks/BlockRegistryCultivation.java b/src/main/java/forestry/cultivation/blocks/BlockRegistryCultivation.java index 07d8f9516..3302b5d56 100644 --- a/src/main/java/forestry/cultivation/blocks/BlockRegistryCultivation.java +++ b/src/main/java/forestry/cultivation/blocks/BlockRegistryCultivation.java @@ -1,9 +1,14 @@ package forestry.cultivation.blocks; +import java.util.HashSet; +import java.util.Set; + import forestry.core.blocks.BlockRegistry; -import forestry.core.items.ItemBlockForestry; +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; @@ -14,18 +19,33 @@ public class BlockRegistryCultivation extends BlockRegistry { public BlockRegistryCultivation() { arboretum = new BlockPlanter(BlockTypePlanter.ARBORETUM); - registerBlock(arboretum, new ItemBlockForestry<>(arboretum), "arboretum"); + registerBlock(arboretum, new ItemBlockPlanter(arboretum), "arboretum"); + planters.add(arboretum); + farmCrops = new BlockPlanter(BlockTypePlanter.FARM_CROPS); - registerBlock(farmCrops, new ItemBlockForestry<>(farmCrops), "farm_crops"); + registerBlock(farmCrops, new ItemBlockPlanter(farmCrops), "farm_crops"); + planters.add(farmCrops); + farmMushroom = new BlockPlanter(BlockTypePlanter.FARM_MUSHROOM); - registerBlock(farmMushroom, new ItemBlockForestry<>(farmMushroom), "farm_mushroom"); + registerBlock(farmMushroom, new ItemBlockPlanter(farmMushroom), "farm_mushroom"); + planters.add(farmMushroom); + farmGourd = new BlockPlanter(BlockTypePlanter.FARM_GOURD); - registerBlock(farmGourd, new ItemBlockForestry<>(farmGourd), "farm_gourd"); + registerBlock(farmGourd, new ItemBlockPlanter(farmGourd), "farm_gourd"); + planters.add(farmGourd); + farmNether = new BlockPlanter(BlockTypePlanter.FARM_NETHER); - registerBlock(farmNether, new ItemBlockForestry<>(farmNether), "farm_nether"); + registerBlock(farmNether, new ItemBlockPlanter(farmNether), "farm_nether"); + planters.add(farmNether); + peatBog = new BlockPlanter(BlockTypePlanter.PEAT_POG); - registerBlock(peatBog, new ItemBlockForestry<>(peatBog), "peat_bog"); + 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/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/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/tiles/TilePlantation.java b/src/main/java/forestry/cultivation/tiles/TilePlantation.java index d0dfc9df1..3e7b7619c 100644 --- a/src/main/java/forestry/cultivation/tiles/TilePlantation.java +++ b/src/main/java/forestry/cultivation/tiles/TilePlantation.java @@ -2,11 +2,10 @@ package forestry.cultivation.tiles; import net.minecraft.item.ItemStack; -import forestry.api.farming.IFarmLogic; - public class TilePlantation extends TilePlanter { - public TilePlantation(IFarmLogic logic) { - super(logic); + + public TilePlantation() { + super("farmRubber"); } @Override diff --git a/src/main/java/forestry/cultivation/tiles/TilePlanter.java b/src/main/java/forestry/cultivation/tiles/TilePlanter.java index 2bede2c47..a1ebb54d4 100644 --- a/src/main/java/forestry/cultivation/tiles/TilePlanter.java +++ b/src/main/java/forestry/cultivation/tiles/TilePlanter.java @@ -33,6 +33,7 @@ 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; @@ -64,12 +65,10 @@ import forestry.farming.multiblock.FarmHydrationManager; public abstract class TilePlanter extends TilePowered implements IFarmHousing, IClimatised, ILiquidTankTile, IOwnedTile, IStreamableGui { - private final static int ALLOWED_EXTENT = 4; - private final Map> targets = new EnumMap<>(FarmDirection.class); private final Stack pendingProduce = new Stack<>(); private final List pendingCrops = new LinkedList<>(); - private final IFarmLogic logic; + private final String identifier; private final FarmHydrationManager hydrationManager; private final FarmFertilizerManager fertilizerManager; @@ -80,19 +79,23 @@ public abstract class TilePlanter extends TilePowered implements IFarmHousing, I private int platformHeight = -1; private Stage stage = Stage.CULTIVATE; + private boolean isManual; + private IFarmLogic logic; @Nullable private Vec3i offset; @Nullable private Vec3i area; - public TilePlanter(String identifier) { - this(FarmRegistry.getInstance().getFarmLogic(identifier)); + public void setManual(boolean manual) { + isManual = manual; + logic = FarmRegistry.getInstance().getFarm(identifier).getLogic(manual); } - protected TilePlanter(IFarmLogic logic) { + protected TilePlanter(String identifier) { super(150, 1500); + this.identifier = identifier; + setManual(false); setInternalInventory(inventory = new InventoryPlanter(this)); - this.logic = logic; this.hydrationManager = new FarmHydrationManager(this); this.fertilizerManager = new FarmFertilizerManager(); @@ -203,6 +206,7 @@ public abstract class TilePlanter extends TilePowered implements IFarmHousing, I tankManager.writeToNBT(data); fertilizerManager.writeToNBT(data); ownerHandler.writeToNBT(data); + data.setBoolean("isManual", isManual); return data; } @@ -213,6 +217,7 @@ public abstract class TilePlanter extends TilePowered implements IFarmHousing, I tankManager.readFromNBT(data); fertilizerManager.readFromNBT(data); ownerHandler.readFromNBT(data); + setManual(data.getBoolean("isManual")); } @Override @@ -231,8 +236,20 @@ public abstract class TilePlanter extends TilePowered implements IFarmHousing, I private void setUpFarmlandTargets() { BlockPos targetStart = getCoords(); + BlockPos minPos = pos; + BlockPos maxPos = pos; + int size = 1; + int extend = Config.planterExtend; - FarmHelper.createTargets(world, this, targets, targetStart, ALLOWED_EXTENT, 1, 1, pos, pos); + 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); } @@ -331,7 +348,11 @@ public abstract class TilePlanter extends TilePowered implements IFarmHousing, I @Override public Vec3i getArea() { if (area == null) { - area = new Vec3i(7 + ALLOWED_EXTENT * 2, 13, 7 + ALLOWED_EXTENT * 2); + int basisArea = 5; + if(Config.ringFarms){ + basisArea = basisArea + 1 + Config.ringSize * 2; + } + area = new Vec3i(basisArea + Config.planterExtend, 13, basisArea + Config.planterExtend); } return area; } @@ -388,6 +409,11 @@ public abstract class TilePlanter extends TilePowered implements IFarmHousing, I return true; } + @Override + public boolean canPlantSoil(boolean manual) { + return !isManual; + } + @Override public IFarmInventory getFarmInventory() { return inventory; diff --git a/src/main/java/forestry/farming/DummyFarmRegistry.java b/src/main/java/forestry/farming/DummyFarmRegistry.java index 9dec62bc0..0a036f5a1 100644 --- a/src/main/java/forestry/farming/DummyFarmRegistry.java +++ b/src/main/java/forestry/farming/DummyFarmRegistry.java @@ -1,42 +1,76 @@ 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.IFarmInstance; import forestry.api.farming.IFarmLogic; import forestry.api.farming.IFarmRegistry; import forestry.api.farming.IFarmable; import forestry.api.farming.ISimpleFarmLogic; +import forestry.farming.logic.FakeFarmInstance; 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 IFarmInstance registerLogic(IFarmInstance farmInstance) { + //Dummy-Implementation return null; } + @Override + public IFarmInstance registerLogic(String identifier, BiFunction logicFactory, String... farmablesIdentifiers) { + //Dummy-Implementation + return null; + } + + @Nullable + @Override + public IFarmLogic createCropLogic(IFarmInstance instance, boolean isManual, ISimpleFarmLogic simpleFarmLogic) { + //Dummy-Implementation + return null; + } + + @Override + public IFarmInstance createFakeInstance(IFarmLogic logic) { + return new FakeFarmInstance(logic); + } + @Override public void registerFertilizer(ItemStack itemStack, int value) { + //Dummy-Implementation } @Override public int getFertilizeValue(ItemStack itemStack) { + //Dummy-Implementation return 0; } + + @Nullable + @Override + public IFarmInstance getFarm(String identifier) { + //Dummy-Implementation + return null; + } } diff --git a/src/main/java/forestry/farming/FarmRegistry.java b/src/main/java/forestry/farming/FarmRegistry.java index 36577befc..4c4833212 100644 --- a/src/main/java/forestry/farming/FarmRegistry.java +++ b/src/main/java/forestry/farming/FarmRegistry.java @@ -3,6 +3,7 @@ package forestry.farming; import com.google.common.collect.HashMultimap; import com.google.common.collect.Multimap; +import javax.annotation.Nullable; import java.util.ArrayList; import java.util.Arrays; import java.util.Collection; @@ -14,12 +15,15 @@ import java.util.List; import java.util.Map; import java.util.Map.Entry; import java.util.Set; +import java.util.function.BiFunction; +import java.util.stream.Collectors; import net.minecraft.item.ItemStack; import net.minecraftforge.common.config.Property; import net.minecraftforge.oredict.OreDictionary; +import forestry.api.farming.IFarmInstance; import forestry.api.farming.IFarmLogic; import forestry.api.farming.IFarmRegistry; import forestry.api.farming.IFarmable; @@ -28,6 +32,8 @@ import forestry.core.config.LocalizedConfiguration; import forestry.core.utils.ItemStackUtil; import forestry.core.utils.Log; import forestry.core.utils.Translator; +import forestry.farming.logic.FakeFarmInstance; +import forestry.farming.logic.FarmInstance; import forestry.farming.logic.FarmLogicSimple; public final class FarmRegistry implements IFarmRegistry { @@ -35,18 +41,17 @@ 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 logics = new HashMap<>(); + private final Map farmInstances = new HashMap<>(); 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) { + logics.put(identifier, 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(IFarmInstance instance, boolean isManual, ISimpleFarmLogic simpleFarmLogic) { + return new FarmLogicSimple(instance, isManual, simpleFarmLogic); + } + + @Override + public IFarmInstance createFakeInstance(IFarmLogic logic) { + return new FakeFarmInstance(logic); } @Override public void registerFertilizer(ItemStack itemStack, int value) { - if(itemStack == null || itemStack.isEmpty()){ + if(itemStack.isEmpty()){ return; } fertilizers.put(itemStack, value); @@ -76,16 +86,36 @@ public final class FarmRegistry implements IFarmRegistry { 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)) { + if (ItemStackUtil.isIdenticalItem(fertilizerStack, itemStack)) { return fertilizer.getValue(); } } return 0; } - - public void loadConfig(LocalizedConfiguration config) { + + @Override + public IFarmInstance registerLogic(IFarmInstance farmInstance) { + farmInstances.put(farmInstance.getIdentifier(), farmInstance); + return farmInstance; + } + + @Override + public IFarmInstance registerLogic(String identifier, BiFunction logicFactory, String... farmablesIdentifiers) { + Set fIdentifiers = new HashSet<>(Arrays.asList(farmablesIdentifiers)); + fIdentifiers.add(identifier); + Collection farmablesSet = fIdentifiers.stream().map(farmables::get).flatMap(Collection::stream).collect(Collectors.toSet()); + IFarmInstance instance = new FarmInstance(identifier, logicFactory, farmablesSet); + farmInstances.put(identifier, instance); + return instance; + } + + @Override + @Nullable + public IFarmInstance getFarm(String identifier) { + return farmInstances.get(identifier); + } + + void loadConfig(LocalizedConfiguration config) { List defaultFertilizers = new ArrayList<>(getItemStrings()); Collections.sort(defaultFertilizers); String[] defaultSortedFertilizers = defaultFertilizers.toArray(new String[defaultFertilizers.size()]); @@ -102,6 +132,9 @@ public final class FarmRegistry implements IFarmRegistry { itemName = "forestry:fertilizer_compound"; } ItemStack fertilizerItem = ItemStackUtil.parseItemStackString(itemName, OreDictionary.WILDCARD_VALUE); + if(fertilizerItem == null){ + continue; + } int fertilizerValue = Integer.parseInt(fertilizers[1]); registerFertilizer(fertilizerItem, fertilizerValue); } catch (Exception e) { diff --git a/src/main/java/forestry/farming/ModuleFarming.java b/src/main/java/forestry/farming/ModuleFarming.java index 352d7c6a5..bdd0470a5 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.IFarmInstance; 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; @@ -181,29 +185,56 @@ 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.farmCropsManaged = new CircuitFarmLogic("managedCrops", new FarmLogicCrops()); - 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.farmCropsManual = new CircuitFarmLogic("manualCrops", new FarmLogicCrops()).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(); + IFarmInstance arborealFarm = registry.registerLogic("farmArboreal", FarmLogicArboreal::new); + IFarmInstance cropsFarm = registry.registerLogic("farmCrops", FarmLogicCrops::new); + IFarmInstance mushroomFarm = registry.registerLogic("farmShroom", FarmLogicMushroom::new); + IFarmInstance succulentFarm = registry.registerLogic("farmSucculent", FarmLogicSucculent::new); + IFarmInstance peatFarm = registry.registerLogic("farmPeat", FarmLogicPeat::new); + IFarmInstance infernalFarm = registry.registerLogic("farmInfernal", FarmLogicInfernal::new); + IFarmInstance poalesFarm = registry.registerLogic("farmPoales", FarmLogicReeds::new); + IFarmInstance orchardFarm = registry.registerLogic("farmOrchard", FarmLogicOrchard::new); + IFarmInstance gourdFarm = registry.registerLogic("farmGourd", FarmLogicGourd::new); + IFarmInstance cocoaFarm = registry.registerLogic("farmCocoa", FarmLogicCocoa::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("farmCrops",((CircuitFarmLogic)Circuits.farmCropsManaged).getFarmLogic()); - FarmRegistry.getInstance().registerFarmLogic("farmInfernal",((CircuitFarmLogic)Circuits.farmInfernalManaged).getFarmLogic()); - FarmRegistry.getInstance().registerFarmLogic("farmGourd", ((CircuitFarmLogic)Circuits.farmGourdManual).getFarmLogic()); - FarmRegistry.getInstance().registerFarmLogic("farmPeat", ((CircuitFarmLogic)Circuits.farmPeatManaged).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.farmSucculentManual = new CircuitFarmLogic("manualSucculent", succulentFarm, true); + succulentFarm.registerSoil(new ItemStack(Blocks.SAND), Blocks.SAND.getDefaultState(),true); + + Circuits.farmPoalesManual = new CircuitFarmLogic("manualPoales", poalesFarm, true).setManual(); + poalesFarm.registerSoil(new ItemStack(Blocks.SAND), Blocks.SAND.getDefaultState(),true); + poalesFarm.registerSoil(new ItemStack(Blocks.DIRT), Blocks.DIRT.getDefaultState(),false); + + Circuits.farmGourdManual = new CircuitFarmLogic("manualGourd", gourdFarm, true).setManual(); + + Circuits.farmCocoaManual = new CircuitFarmLogic("manualCocoa", cocoaFarm, true).setManual(); } @Override @@ -267,6 +298,10 @@ public class ModuleFarming extends BlankForestryModule { ICircuitLayout layoutManaged = ChipsetManager.circuitRegistry.getLayout("forestry.farms.managed"); ICircuitLayout layoutManual = ChipsetManager.circuitRegistry.getLayout("forestry.farms.manual"); + if(layoutManaged == null || layoutManual == null){ + return; + } + 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.farmCropsManaged); diff --git a/src/main/java/forestry/farming/circuits/CircuitFarmLogic.java b/src/main/java/forestry/farming/circuits/CircuitFarmLogic.java index 1e434f54e..ce97c19d6 100755 --- a/src/main/java/forestry/farming/circuits/CircuitFarmLogic.java +++ b/src/main/java/forestry/farming/circuits/CircuitFarmLogic.java @@ -14,6 +14,7 @@ import javax.annotation.Nullable; import forestry.api.farming.FarmDirection; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmInstance; import forestry.api.farming.IFarmLogic; import forestry.core.circuits.Circuit; @@ -22,15 +23,28 @@ public class CircuitFarmLogic extends Circuit { private final IFarmLogic logic; private boolean isManual = false; + public CircuitFarmLogic(String uid, IFarmInstance instance, boolean manual) { + super(uid); + this.logic = instance.getLogic(manual); + } + public CircuitFarmLogic(String uid, IFarmLogic logic) { super(uid); this.logic = logic; } - + + /** + * @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/logic/FakeFarmInstance.java b/src/main/java/forestry/farming/logic/FakeFarmInstance.java new file mode 100644 index 000000000..864b7de8c --- /dev/null +++ b/src/main/java/forestry/farming/logic/FakeFarmInstance.java @@ -0,0 +1,54 @@ +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.IFarmInstance; +import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmable; +import forestry.api.farming.ISoil; + +public class FakeFarmInstance implements IFarmInstance { + private final IFarmLogic logic; + + public FakeFarmInstance(IFarmLogic logic) { + this.logic = logic; + } + + @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 String getIdentifier() { + return "farmFake"; + } + + @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/FarmInstance.java b/src/main/java/forestry/farming/logic/FarmInstance.java new file mode 100644 index 000000000..716862d87 --- /dev/null +++ b/src/main/java/forestry/farming/logic/FarmInstance.java @@ -0,0 +1,80 @@ +package forestry.farming.logic; + +import java.util.Collection; +import java.util.HashSet; +import java.util.Set; +import java.util.function.BiFunction; + +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.item.ItemStack; + +import forestry.api.farming.IFarmInstance; +import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmable; +import forestry.api.farming.ISoil; + +public final class FarmInstance implements IFarmInstance { + private final Set soils = new HashSet<>(); + private final Collection farmables; + private final IFarmLogic manualLogic; + private final IFarmLogic managedLogic; + private final String identifier; + + public FarmInstance(String identifier, BiFunction logicFactory, Collection farmables) { + this.identifier = identifier; + this.farmables = farmables; + this.manualLogic = logicFactory.apply(this, true); + this.managedLogic = logicFactory.apply(this, false); + } + + @Override + public Collection getFarmables() { + 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)); + } + + 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; + } + + @Override + public String getIdentifier() { + return identifier; + } +} diff --git a/src/main/java/forestry/farming/logic/FarmLogic.java b/src/main/java/forestry/farming/logic/FarmLogic.java index 23c3c9931..54810fdbb 100755 --- a/src/main/java/forestry/farming/logic/FarmLogic.java +++ b/src/main/java/forestry/farming/logic/FarmLogic.java @@ -13,48 +13,73 @@ 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.IFarmInstance; import forestry.api.farming.IFarmLogic; +import forestry.api.farming.IFarmable; +import forestry.api.farming.ISoil; import forestry.core.utils.VectUtil; public abstract class FarmLogic implements IFarmLogic { private final EntitySelectorFarm entitySelectorFarm = new EntitySelectorFarm(this); - protected boolean isManual; + protected final IFarmInstance instance; + protected final boolean isManual; + + public FarmLogic(IFarmInstance instance, boolean isManual) { + this.instance = instance; + this.isManual = isManual; + } + + protected Collection getFarmables() { + return instance.getFarmables(); + } + + protected Collection getSoils() { + return instance.getSoils(); + } @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); + if (world.isAirBlock(position)) { + continue; + } + IBlockState blockState = world.getBlockState(position); + for (IFarmable seed : getFarmables()) { + ICrop crop = seed.getCropAt(world, position, blockState); + if (crop != null) { + crops.push(crop); + break; + } + } + } + return crops; } - @Override - public abstract ItemStack getIconItemStack(); - public abstract boolean isAcceptedWindfall(ItemStack stack); protected final boolean isWaterSourceBlock(World world, BlockPos position) { @@ -96,6 +121,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,20 +143,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); } } - - @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - // do nothing as soil is not managed by farm - } - - // 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 29645131e..116511d75 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,17 +31,21 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmInstance; 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); + + private List farmables; + + public FarmLogicArboreal(IFarmInstance instance, boolean isManual) { + super(instance, isManual); + this.farmables = new ArrayList<>(instance.getFarmables()); } - public FarmLogicArboreal() { - super(new ItemStack(Blocks.DIRT), ModuleCore.getBlocks().humus.getDefaultState(), FarmRegistry.getInstance().getFarmables("farmArboreal")); + @Override + public List getFarmables() { + return farmables; } @Override @@ -73,7 +79,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 +98,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 +131,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); @@ -154,7 +162,7 @@ public class FarmLogicArboreal extends FarmLogicHomogeneous { private boolean plantSapling(World world, IFarmHousing farmHousing, BlockPos position, FarmDirection direction) { Collections.shuffle(farmables); - for (IFarmable candidate : farmables) { + for (IFarmable candidate : getFarmables()) { if (farmHousing.plantGermling(candidate, world, position, direction)) { return true; } diff --git a/src/main/java/forestry/farming/logic/FarmLogicCocoa.java b/src/main/java/forestry/farming/logic/FarmLogicCocoa.java index 5e816d77f..5f548c8c5 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicCocoa.java +++ b/src/main/java/forestry/farming/logic/FarmLogicCocoa.java @@ -34,12 +34,17 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmInstance; import forestry.api.farming.IFarmable; import forestry.farming.logic.farmables.FarmableCocoa; public class FarmLogicCocoa extends FarmLogic { private final IFarmable cocoa = new FarmableCocoa(); + public FarmLogicCocoa(IFarmInstance instance, boolean isManual) { + super(instance, isManual); + } + @Override public ItemStack getIconItemStack() { return new ItemStack(Items.DYE, 1, 3); diff --git a/src/main/java/forestry/farming/logic/FarmLogicCrops.java b/src/main/java/forestry/farming/logic/FarmLogicCrops.java index bf0678a9c..a76cf61fa 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicCrops.java +++ b/src/main/java/forestry/farming/logic/FarmLogicCrops.java @@ -10,11 +10,7 @@ ******************************************************************************/ 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; @@ -22,33 +18,20 @@ 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.IFarmInstance; import forestry.api.farming.IFarmable; import forestry.core.utils.BlockUtil; -import forestry.farming.FarmRegistry; public class FarmLogicCrops extends FarmLogicWatered { - private final Iterable seeds; - public FarmLogicCrops() { - this(FarmRegistry.getInstance().getFarmables("farmCrops")); - } - - 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(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } @Override public boolean isAcceptedGermling(ItemStack itemstack) { - for (IFarmable germling : seeds) { + for (IFarmable germling : getFarmables()) { if (germling.isGermling(itemstack)) { return true; } @@ -58,7 +41,7 @@ public class FarmLogicCrops extends FarmLogicWatered { @Override public boolean isAcceptedWindfall(ItemStack itemstack) { - for (IFarmable germling : seeds) { + for (IFarmable germling : getFarmables()) { if (germling.isWindfall(itemstack)) { return true; } @@ -83,7 +66,7 @@ public class FarmLogicCrops extends FarmLogicWatered { } IBlockState groundState = world.getBlockState(position.down()); - if (isAcceptedGround(groundState)) { + if (isAcceptedSoil(groundState)) { return trySetCrop(world, farmHousing, position, direction); } } @@ -92,7 +75,7 @@ public class FarmLogicCrops extends FarmLogicWatered { } private boolean trySetCrop(World world, IFarmHousing farmHousing, BlockPos position, FarmDirection direction) { - for (IFarmable candidate : seeds) { + for (IFarmable candidate : getFarmables()) { if (farmHousing.plantGermling(candidate, world, position, direction)) { return true; } @@ -101,23 +84,6 @@ public class FarmLogicCrops extends FarmLogicWatered { 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 ItemStack getIconItemStack() { return new ItemStack(Items.WHEAT); diff --git a/src/main/java/forestry/farming/logic/FarmLogicExU.java b/src/main/java/forestry/farming/logic/FarmLogicExU.java index 84b0fd1bd..636b911aa 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicExU.java +++ b/src/main/java/forestry/farming/logic/FarmLogicExU.java @@ -10,12 +10,7 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.Collection; -import java.util.Stack; - -import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; -import net.minecraft.init.Blocks; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; @@ -23,22 +18,17 @@ 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.IFarmInstance; import forestry.core.utils.BlockUtil; -import forestry.farming.FarmRegistry; public class FarmLogicExU 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); - } + public FarmLogicExU(IFarmInstance instance, boolean isManual, String name, Item iconItem) { + super(instance, isManual); this.name = name; this.iconItem = iconItem; } @@ -68,25 +58,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++) { diff --git a/src/main/java/forestry/farming/logic/FarmLogicGourd.java b/src/main/java/forestry/farming/logic/FarmLogicGourd.java index ede28bc10..d651aeb43 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.IFarmInstance; 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(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } @Override @@ -79,21 +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; - } } diff --git a/src/main/java/forestry/farming/logic/FarmLogicHomogeneous.java b/src/main/java/forestry/farming/logic/FarmLogicHomogeneous.java index f719d1690..d511fede6 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicHomogeneous.java +++ b/src/main/java/forestry/farming/logic/FarmLogicHomogeneous.java @@ -10,11 +10,6 @@ ******************************************************************************/ package forestry.farming.logic; -import java.util.ArrayList; -import java.util.Collection; -import java.util.List; - -import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; import net.minecraft.util.NonNullList; @@ -23,47 +18,21 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmInstance; import forestry.api.farming.IFarmable; +import forestry.api.farming.ISoil; import forestry.core.utils.BlockUtil; public abstract class FarmLogicHomogeneous extends FarmLogicSoil { - protected final List farmables; - protected NonNullList produce = NonNullList.create(); - protected FarmLogicHomogeneous(ItemStack resource, IBlockState soilState, Collection farmables) { - addSoil(resource, soilState, false); - this.farmables = new ArrayList<>(farmables); - } - - 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(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } @Override public boolean isAcceptedGermling(ItemStack itemstack) { - for (IFarmable germling : farmables) { + for (IFarmable germling : getFarmables()) { if (germling.isGermling(itemstack)) { return true; } @@ -73,7 +42,7 @@ public abstract class FarmLogicHomogeneous extends FarmLogicSoil { @Override public boolean isAcceptedWindfall(ItemStack itemstack) { - for (IFarmable germling : farmables) { + for (IFarmable germling : getFarmables()) { if (germling.isWindfall(itemstack)) { return true; } @@ -81,18 +50,8 @@ public abstract class FarmLogicHomogeneous extends FarmLogicSoil { return false; } - protected boolean trySetCrop(World world, IFarmHousing farmHousing, BlockPos position, FarmDirection direction, boolean shuffle) { - for (IFarmable candidate : farmables) { - if (farmHousing.plantGermling(candidate, world, position, direction)) { - return true; - } - } - - return false; - } - protected boolean trySetCrop(World world, IFarmHousing farmHousing, BlockPos position, FarmDirection direction) { - for (IFarmable candidate : farmables) { + for (IFarmable candidate : getFarmables()) { if (farmHousing.plantGermling(candidate, world, position, direction)) { return true; } @@ -103,37 +62,43 @@ public abstract class FarmLogicHomogeneous extends FarmLogicSoil { @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); + if(isManual){ + + } + 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 (farmHousing.isValidPlatform(world, pos)) { break; } - + if (isAcceptedSoil(soilState)) { continue; } - + BlockPos platformPosition = position.down(); 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 c84476578..97611715e 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,14 +23,14 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmInstance; 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(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } @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); diff --git a/src/main/java/forestry/farming/logic/FarmLogicMushroom.java b/src/main/java/forestry/farming/logic/FarmLogicMushroom.java index 93705fc16..537df6970 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicMushroom.java +++ b/src/main/java/forestry/farming/logic/FarmLogicMushroom.java @@ -15,14 +15,13 @@ 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.IFarmInstance; 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(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } @Override diff --git a/src/main/java/forestry/farming/logic/FarmLogicOrchard.java b/src/main/java/forestry/farming/logic/FarmLogicOrchard.java index cb8501bb1..ad46f954a 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicOrchard.java +++ b/src/main/java/forestry/farming/logic/FarmLogicOrchard.java @@ -28,10 +28,10 @@ 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.IFarmInstance; import forestry.api.farming.IFarmable; import forestry.api.genetics.IFruitBearer; import forestry.core.ModuleCore; @@ -40,12 +40,11 @@ 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(IFarmInstance instance, boolean isManual) { + super(instance, 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)) { @@ -64,8 +63,6 @@ public class FarmLogicOrchard extends FarmLogic { // traversalBlocksBuilder.add(grapeVine); // } // } - - traversalBlocksBuilder.build(); this.traversalBlocks = traversalBlocksBuilder.build(); } @@ -209,7 +206,7 @@ public class FarmLogicOrchard extends FarmLogic { return true; } - for (IFarmable farmable : farmables) { + for (IFarmable farmable : getFarmables()) { if (farmable.isSaplingAt(world, position)) { return true; } @@ -238,7 +235,7 @@ public class FarmLogicOrchard extends FarmLogic { } } else { IBlockState blockState = world.getBlockState(position); - for (IFarmable seed : farmables) { + for (IFarmable seed : getFarmables()) { ICrop crop = seed.getCropAt(world, position, blockState); if (crop != null) { return crop; diff --git a/src/main/java/forestry/farming/logic/FarmLogicPeat.java b/src/main/java/forestry/farming/logic/FarmLogicPeat.java index 85c4bef7a..bfff9ab0f 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicPeat.java +++ b/src/main/java/forestry/farming/logic/FarmLogicPeat.java @@ -21,24 +21,14 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; +import forestry.api.farming.IFarmInstance; 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(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } @Override diff --git a/src/main/java/forestry/farming/logic/FarmLogicReeds.java b/src/main/java/forestry/farming/logic/FarmLogicReeds.java index cc32c662b..847c12c52 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicReeds.java +++ b/src/main/java/forestry/farming/logic/FarmLogicReeds.java @@ -10,11 +10,6 @@ ******************************************************************************/ 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; @@ -22,18 +17,12 @@ 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.IFarmInstance; public class FarmLogicReeds extends FarmLogicSoil { - private final Collection germlings = FarmRegistry.getInstance().getFarmables("farmPoales"); - - - public FarmLogicReeds() { - addSoil(new ItemStack(Blocks.SAND), Blocks.SAND.getDefaultState(),true); - addSoil(new ItemStack(Blocks.DIRT), Blocks.DIRT.getDefaultState(),false); + public FarmLogicReeds(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } @Override @@ -61,18 +50,12 @@ public class FarmLogicReeds extends FarmLogicSoil { } @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); } @@ -100,21 +83,4 @@ public class FarmLogicReeds extends FarmLogicSoil { 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 66da5f732..4e971c7c0 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicRubber.java +++ b/src/main/java/forestry/farming/logic/FarmLogicRubber.java @@ -25,6 +25,7 @@ import net.minecraft.world.World; import forestry.api.farming.FarmDirection; import forestry.api.farming.ICrop; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmInstance; import forestry.core.utils.ItemStackUtil; import forestry.core.utils.Log; import forestry.farming.logic.crops.CropRubber; @@ -34,7 +35,8 @@ public class FarmLogicRubber extends FarmLogic { private boolean active = true; - public FarmLogicRubber() { + public FarmLogicRubber(IFarmInstance instance, boolean isManual) { + super(instance, 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; @@ -131,5 +133,5 @@ public class FarmLogicRubber extends FarmLogic { return crops; } - + } diff --git a/src/main/java/forestry/farming/logic/FarmLogicSimple.java b/src/main/java/forestry/farming/logic/FarmLogicSimple.java index feb2f3a5b..786ab8755 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.IFarmInstance; +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(IFarmInstance 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 index d58e1f53c..cf3e20ab8 100644 --- a/src/main/java/forestry/farming/logic/FarmLogicSoil.java +++ b/src/main/java/forestry/farming/logic/FarmLogicSoil.java @@ -1,20 +1,23 @@ package forestry.farming.logic; -import java.util.HashSet; -import java.util.Set; - import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; -public abstract class FarmLogicSoil extends FarmLogic { - protected final Set soils = new HashSet<>(); +import forestry.api.farming.IFarmInstance; - public FarmLogicSoil() { +public abstract class FarmLogicSoil extends FarmLogic { + + public FarmLogicSoil(IFarmInstance instance, boolean isManual) { + super(instance, isManual); + } + + protected boolean isAcceptedSoil(IBlockState blockState) { + return instance.isAcceptedSoil(blockState); } @Override - public void addSoil(ItemStack resource, IBlockState soilState, boolean hasMetaData) { - soils.add(new Soil(resource,soilState,hasMetaData)); + public boolean isAcceptedResource(ItemStack itemStack) { + return instance.isAcceptedResource(itemStack); } } diff --git a/src/main/java/forestry/farming/logic/FarmLogicSucculent.java b/src/main/java/forestry/farming/logic/FarmLogicSucculent.java index 560162033..201651e10 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicSucculent.java +++ b/src/main/java/forestry/farming/logic/FarmLogicSucculent.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.Blocks; import net.minecraft.init.Items; import net.minecraft.item.ItemStack; @@ -22,19 +18,15 @@ 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.IFarmInstance; import forestry.core.utils.ItemStackUtil; -import forestry.farming.FarmRegistry; public class FarmLogicSucculent extends FarmLogicSoil { - private final Collection germlings = FarmRegistry.getInstance().getFarmables("farmSucculentes"); - - public FarmLogicSucculent() { - addSoil(new ItemStack(Blocks.SAND), Blocks.SAND.getDefaultState(),true); + public FarmLogicSucculent(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } - + @Override public ItemStack getIconItemStack() { return new ItemStack(Items.DYE, 1, 2); @@ -48,7 +40,7 @@ public class FarmLogicSucculent extends FarmLogicSoil { return "Managed Succulent Farm"; } } - + @Override public int getFertilizerConsumption() { return 10; @@ -58,20 +50,14 @@ public class FarmLogicSucculent extends FarmLogicSoil { 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 @@ -98,21 +84,4 @@ public class FarmLogicSucculent extends FarmLogicSoil { 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/FarmLogicWatered.java b/src/main/java/forestry/farming/logic/FarmLogicWatered.java index e7143f186..14cbe29b9 100755 --- a/src/main/java/forestry/farming/logic/FarmLogicWatered.java +++ b/src/main/java/forestry/farming/logic/FarmLogicWatered.java @@ -10,7 +10,6 @@ ******************************************************************************/ package forestry.farming.logic; -import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; import net.minecraft.init.Blocks; import net.minecraft.item.ItemStack; @@ -24,6 +23,8 @@ import net.minecraftforge.fluids.FluidStack; import forestry.api.farming.FarmDirection; import forestry.api.farming.IFarmHousing; +import forestry.api.farming.IFarmInstance; +import forestry.api.farming.ISoil; import forestry.core.utils.BlockUtil; public abstract class FarmLogicWatered extends FarmLogicSoil { @@ -31,8 +32,8 @@ public abstract class FarmLogicWatered extends FarmLogicSoil { protected NonNullList produce = NonNullList.create(); - protected FarmLogicWatered(ItemStack resource, IBlockState ground) { - addSoil(resource,ground,false); + public FarmLogicWatered(IFarmInstance instance, boolean isManual) { + super(instance, isManual); } @Override @@ -45,31 +46,6 @@ public abstract class FarmLogicWatered extends FarmLogicSoil { 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; @@ -79,7 +55,6 @@ public abstract class FarmLogicWatered extends FarmLogicSoil { @Override public boolean cultivate(World world, IFarmHousing farmHousing, BlockPos pos, FarmDirection direction, int extent) { - if (maintainSoil(world, farmHousing, pos, direction, extent)) { return true; } @@ -93,33 +68,37 @@ public abstract class FarmLogicWatered extends FarmLogicSoil { } 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(); 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()); } } 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/crops/CropBasicIC2Crop.java b/src/main/java/forestry/farming/logic/crops/CropBasicIC2Crop.java index ba5444119..6fcbec840 100644 --- a/src/main/java/forestry/farming/logic/crops/CropBasicIC2Crop.java +++ b/src/main/java/forestry/farming/logic/crops/CropBasicIC2Crop.java @@ -34,6 +34,7 @@ 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. */ @@ -44,6 +45,7 @@ public class CropBasicIC2Crop extends Crop { /** * 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. */ @@ -64,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/CropDestroy.java b/src/main/java/forestry/farming/logic/crops/CropDestroy.java index bd9d68263..458eb9da4 100644 --- a/src/main/java/forestry/farming/logic/crops/CropDestroy.java +++ b/src/main/java/forestry/farming/logic/crops/CropDestroy.java @@ -11,6 +11,7 @@ package forestry.farming.logic.crops; import javax.annotation.Nullable; +import java.util.Iterator; import net.minecraft.block.Block; import net.minecraft.block.state.IBlockState; @@ -19,8 +20,11 @@ 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 { @@ -29,10 +33,17 @@ public class CropDestroy extends Crop { @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 @@ -45,6 +56,22 @@ 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; + } + } + } 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/farmables/FarmableAgingCrop.java b/src/main/java/forestry/farming/logic/farmables/FarmableAgingCrop.java index 53f539291..a9f0b9c72 100644 --- a/src/main/java/forestry/farming/logic/farmables/FarmableAgingCrop.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableAgingCrop.java @@ -62,7 +62,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/farmables/FarmableSapling.java b/src/main/java/forestry/farming/logic/farmables/FarmableSapling.java index 95df1a937..7d1b0111c 100644 --- a/src/main/java/forestry/farming/logic/farmables/FarmableSapling.java +++ b/src/main/java/forestry/farming/logic/farmables/FarmableSapling.java @@ -29,66 +29,66 @@ 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; + 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) { + 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; - } + 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 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 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; - } + @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); - } + 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 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; - } + @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/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 db497891c..9090f13a1 100644 --- a/src/main/java/forestry/farming/multiblock/FakeFarmController.java +++ b/src/main/java/forestry/farming/multiblock/FakeFarmController.java @@ -30,8 +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; public class FakeFarmController extends FakeMultiblockController implements IFarmControllerInternal { public static final FakeFarmController instance = new FakeFarmController(); @@ -87,7 +87,7 @@ public class FakeFarmController extends FakeMultiblockController implements IFar @Override public IFarmLogic getFarmLogic(FarmDirection direction) { - return new FarmLogicArboreal(); + return FarmRegistry.getInstance().getFarm("farmArboreal").getLogic(false); } @Override diff --git a/src/main/java/forestry/farming/multiblock/FarmController.java b/src/main/java/forestry/farming/multiblock/FarmController.java index 27dd0941d..57094a766 100755 --- a/src/main/java/forestry/farming/multiblock/FarmController.java +++ b/src/main/java/forestry/farming/multiblock/FarmController.java @@ -74,9 +74,9 @@ 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; @@ -630,7 +630,7 @@ public class FarmController extends RectangularMultiblockControllerBase implemen @Override public void resetFarmLogic(FarmDirection direction) { - setFarmLogic(direction, new FarmLogicArboreal()); + setFarmLogic(direction, FarmRegistry.getInstance().getFarm("farmArboreal").getLogic(false)); } @Override diff --git a/src/main/java/forestry/plugins/PluginExtraUtilities.java b/src/main/java/forestry/plugins/PluginExtraUtilities.java index 625b3c745..9f5ba2029 100644 --- a/src/main/java/forestry/plugins/PluginExtraUtilities.java +++ b/src/main/java/forestry/plugins/PluginExtraUtilities.java @@ -16,6 +16,7 @@ import java.util.function.Consumer; import net.minecraft.block.Block; import net.minecraft.block.properties.IProperty; import net.minecraft.init.Blocks; +import net.minecraft.init.Items; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; @@ -26,6 +27,8 @@ import forestry.api.circuits.ChipsetManager; import forestry.api.circuits.ICircuit; import forestry.api.circuits.ICircuitLayout; import forestry.api.core.ForestryAPI; +import forestry.api.farming.IFarmInstance; +import forestry.api.farming.IFarmRegistry; import forestry.api.modules.ForestryModule; import forestry.core.ModuleCore; import forestry.core.circuits.Circuits; @@ -61,17 +64,19 @@ public class PluginExtraUtilities extends BlankForestryModule { @Override public void doInit() { if (Config.isExUtilRedOrchidEnabled()) { - registerExPlant("Orchid", "redorchid", "Red Orchid", Blocks.REDSTONE_ORE, circuit -> Circuits.farmOrchidManaged = circuit); + registerExPlant("Orchid", "redorchid", "Red Orchid", circuit -> Circuits.farmOrchidManaged = circuit, Blocks.REDSTONE_ORE, Blocks.LIT_REDSTONE_ORE); } if (Config.isExUtilEnderLilyEnabled()) { - registerExPlant("Ender", "enderlilly", "Ender Lily", Blocks.END_STONE, circuit -> Circuits.farmEnderManaged = circuit); + registerExPlant("Ender", "enderlilly", "Ender Lily", circuit -> Circuits.farmEnderManaged = circuit, Blocks.END_STONE); } } @Override public void registerRecipes() { - if (!ForestryAPI.enabledModules.contains(new ResourceLocation(Constants.MOD_ID, ForestryModuleUids.FARMING))) return; + 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); @@ -82,22 +87,28 @@ public class PluginExtraUtilities extends BlankForestryModule { } } - private void registerExPlant(String id, String itemResourceName, String itemName, Block soil, Consumer assignTo) { + private void registerExPlant(String id, String itemResourceName, String itemName, Consumer assignTo, Block... soils) { 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) { + } else if (plantItem == Items.AIR) { Log.error("Could not find {} item.", itemName); } else { IProperty growthProperty = BlockUtil.getProperty(plantBlock, "growth", Integer.class); if (growthProperty == null) { Log.error("Could not find the growth property of {}.", itemName); } else { + IFarmRegistry registry = FarmRegistry.getInstance(); 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))); + registry.registerFarmables(itemName, new FarmableAgingCrop(new ItemStack(plantItem), plantBlock, growthProperty, harvestAge, replantAge)); + + IFarmInstance instance = registry.registerLogic("farm" + id, (i, m) -> new FarmLogicExU(i, m, (m ? "Manual " : "Managed ") + itemName + " Farm", plantItem), itemName); + for(Block soil : soils) { + instance.registerSoil(new ItemStack(soil), soil.getDefaultState()); + } + assignTo.accept(new CircuitFarmLogic("managed" + id, instance, false)); } } } diff --git a/src/main/java/forestry/plugins/PluginIC2.java b/src/main/java/forestry/plugins/PluginIC2.java index 687a629f2..0c16ae550 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.IFarmInstance; import forestry.api.fuels.EngineBronzeFuel; import forestry.api.fuels.FuelManager; import forestry.api.modules.ForestryModule; @@ -116,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()); + IFarmInstance 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/PluginNatura.java b/src/main/java/forestry/plugins/PluginNatura.java index ef1befabc..89c11d2c0 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.IFarmInstance; import forestry.api.fuels.FuelManager; import forestry.api.fuels.MoistenerFuel; import forestry.api.modules.ForestryModule; @@ -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); + IFarmInstance farmArboreal = FarmRegistry.getInstance().getFarm("managedArboreal"); + if(farmArboreal != null) { + farmArboreal.registerSoil(new ItemStack(Blocks.NETHERRACK), Blocks.NETHERRACK.getDefaultState(), false); + } }