From c1e414b8f7d36cd5734e8350a4f7242e8501b7b2 Mon Sep 17 00:00:00 2001 From: Nedelosk Date: Tue, 24 May 2016 15:20:21 +0200 Subject: [PATCH] Add charcoal pile --- lang | 2 +- .../api/arboriculture/EnumGermlingType.java | 2 +- .../api/arboriculture/EnumPileType.java | 14 + .../api/arboriculture/EnumTreeChromosome.java | 10 +- .../api/arboriculture/IAlleleTreeSpecies.java | 7 +- .../arboriculture/IGermlingModelProvider.java | 2 +- .../api/arboriculture/ITreeFactory.java | 5 +- .../api/arboriculture/ITreeGenome.java | 4 + .../api/arboriculture/IWoodProvider.java | 33 ++ .../multiblock/ICharcoalPileComponent.java | 43 ++ .../multiblock/ICharcoalPileController.java | 9 + .../IMultiblockLogicCharcoalPile.java | 21 + .../network/packets/PacketActiveUpdate.java | 9 +- .../worldgen/VillageApiaristHouse.java | 1 + .../arboriculture/PluginArboriculture.java | 29 +- .../arboriculture/blocks/BlockFruitPod.java | 2 +- .../arboriculture/blocks/BlockPile.java | 526 ++++++++++++++++++ .../blocks/BlockRegistryArboriculture.java | 11 +- .../arboriculture/blocks/BlockSapling.java | 2 +- .../genetics/TreeBranchDefinition.java | 2 + .../genetics/TreeDefinition.java | 25 +- .../arboriculture/genetics/TreeFactory.java | 5 +- .../arboriculture/genetics/TreeGenome.java | 10 + .../arboriculture/genetics/TreeRoot.java | 5 + .../arboriculture/genetics/WoodProvider.java | 55 ++ .../genetics/WoodProviderVanilla.java | 80 +++ .../genetics/alleles/AlleleTreeSpecies.java | 18 +- .../arboriculture/items/ItemBlockPile.java | 91 +++ .../arboriculture/items/ItemGermlingGE.java | 10 +- .../items/ItemRegistryArboriculture.java | 2 + .../models/ModelProviderGermling.java | 26 +- .../models/ModelProviderGermlingVanilla.java | 58 +- .../arboriculture/models/ModelWoodPile.java | 148 +++++ .../multiblock/CharcoalPileController.java | 431 ++++++++++++++ .../CharcoalPileMultiblockSizeLimits.java | 57 ++ .../multiblock/EnumPilePosition.java | 22 + .../FakeCharcoalPileController.java | 42 ++ .../ICharcoalPileControllerInternal.java | 14 + .../MultiblockLogicCharcoalPile.java | 37 ++ .../proxy/ProxyArboricultureClient.java | 14 +- .../render/CharcoalPileRenderer.java | 292 ++++++++++ .../FruitPodStateMapper.java | 2 +- .../arboriculture/render/PileStateMapper.java | 44 ++ .../SaplingStateMapper.java | 2 +- .../arboriculture/tiles/TilePile.java | 284 ++++++++++ .../core/genetics/alleles/AlleleHelper.java | 9 + .../forestry/core/models/BlankItemModel.java | 2 +- .../java/forestry/core/models/ModelCrate.java | 10 +- .../forestry/core/utils/ItemStackUtil.java | 2 +- .../java/forestry/core/utils/OreDictUtil.java | 1 + .../java/forestry/farming/PluginFarming.java | 8 +- .../java/forestry/farming/gui/FarmLedger.java | 6 - .../greenhouse/gui/ContainerGreenhouse.java | 1 - .../render/ModelButterflyItem.java | 11 +- .../assets/forestry/blockstates/pile.json | 7 + .../assets/forestry/models/block/ashPile.json | 6 + .../forestry/models/block/dirtPile.json | 6 + .../forestry/models/block/woodPile.json | 93 ++++ .../assets/forestry/models/item/ashPile.json | 3 + .../assets/forestry/models/item/charcoal.json | 3 + .../assets/forestry/models/item/dirtPile.json | 3 + .../assets/forestry/models/item/woodPile.json | 3 + .../assets/forestry/textures/blocks/ash.png | Bin 0 -> 545 bytes .../assets/forestry/textures/blocks/loam.png | Bin 0 -> 15375 bytes 64 files changed, 2599 insertions(+), 83 deletions(-) create mode 100644 src/main/java/forestry/api/arboriculture/EnumPileType.java create mode 100644 src/main/java/forestry/api/arboriculture/IWoodProvider.java create mode 100644 src/main/java/forestry/api/multiblock/ICharcoalPileComponent.java create mode 100644 src/main/java/forestry/api/multiblock/ICharcoalPileController.java create mode 100644 src/main/java/forestry/api/multiblock/IMultiblockLogicCharcoalPile.java create mode 100644 src/main/java/forestry/arboriculture/blocks/BlockPile.java create mode 100644 src/main/java/forestry/arboriculture/genetics/WoodProvider.java create mode 100644 src/main/java/forestry/arboriculture/genetics/WoodProviderVanilla.java create mode 100644 src/main/java/forestry/arboriculture/items/ItemBlockPile.java create mode 100644 src/main/java/forestry/arboriculture/models/ModelWoodPile.java create mode 100644 src/main/java/forestry/arboriculture/multiblock/CharcoalPileController.java create mode 100644 src/main/java/forestry/arboriculture/multiblock/CharcoalPileMultiblockSizeLimits.java create mode 100644 src/main/java/forestry/arboriculture/multiblock/EnumPilePosition.java create mode 100644 src/main/java/forestry/arboriculture/multiblock/FakeCharcoalPileController.java create mode 100644 src/main/java/forestry/arboriculture/multiblock/ICharcoalPileControllerInternal.java create mode 100644 src/main/java/forestry/arboriculture/multiblock/MultiblockLogicCharcoalPile.java create mode 100644 src/main/java/forestry/arboriculture/render/CharcoalPileRenderer.java rename src/main/java/forestry/arboriculture/{models => render}/FruitPodStateMapper.java (97%) create mode 100644 src/main/java/forestry/arboriculture/render/PileStateMapper.java rename src/main/java/forestry/arboriculture/{models => render}/SaplingStateMapper.java (97%) create mode 100644 src/main/java/forestry/arboriculture/tiles/TilePile.java create mode 100644 src/main/resources/assets/forestry/blockstates/pile.json create mode 100644 src/main/resources/assets/forestry/models/block/ashPile.json create mode 100644 src/main/resources/assets/forestry/models/block/dirtPile.json create mode 100644 src/main/resources/assets/forestry/models/block/woodPile.json create mode 100644 src/main/resources/assets/forestry/models/item/ashPile.json create mode 100644 src/main/resources/assets/forestry/models/item/charcoal.json create mode 100644 src/main/resources/assets/forestry/models/item/dirtPile.json create mode 100644 src/main/resources/assets/forestry/models/item/woodPile.json create mode 100644 src/main/resources/assets/forestry/textures/blocks/ash.png create mode 100644 src/main/resources/assets/forestry/textures/blocks/loam.png diff --git a/lang b/lang index 46e208965..2963a47a9 160000 --- a/lang +++ b/lang @@ -1 +1 @@ -Subproject commit 46e20896500e20f46ffde78d19486868172302f5 +Subproject commit 2963a47a9b16e5d566729268871a27b0f34bea58 diff --git a/src/main/java/forestry/api/arboriculture/EnumGermlingType.java b/src/main/java/forestry/api/arboriculture/EnumGermlingType.java index 7485657e5..6a97846be 100644 --- a/src/main/java/forestry/api/arboriculture/EnumGermlingType.java +++ b/src/main/java/forestry/api/arboriculture/EnumGermlingType.java @@ -8,7 +8,7 @@ package forestry.api.arboriculture; import forestry.api.genetics.ISpeciesType; public enum EnumGermlingType implements ISpeciesType { - SAPLING("sapling"), POLLEN("pollen"); + SAPLING("sapling"), POLLEN("pollen"), CHARCOAL("charcoal"); public static final EnumGermlingType[] VALUES = values(); diff --git a/src/main/java/forestry/api/arboriculture/EnumPileType.java b/src/main/java/forestry/api/arboriculture/EnumPileType.java new file mode 100644 index 000000000..30353ff1a --- /dev/null +++ b/src/main/java/forestry/api/arboriculture/EnumPileType.java @@ -0,0 +1,14 @@ +/******************************************************************************* + * Copyright 2011-2014 SirSengir + * + * This work (the API) is licensed under the "MIT" License, see LICENSE.txt for details. + ******************************************************************************/ +package forestry.api.arboriculture; + +public enum EnumPileType{ + WOOD, + DIRT, + ASH; + + public static final EnumPileType[] VALUES = values(); +} diff --git a/src/main/java/forestry/api/arboriculture/EnumTreeChromosome.java b/src/main/java/forestry/api/arboriculture/EnumTreeChromosome.java index 6dc7d168d..eac831086 100644 --- a/src/main/java/forestry/api/arboriculture/EnumTreeChromosome.java +++ b/src/main/java/forestry/api/arboriculture/EnumTreeChromosome.java @@ -66,8 +66,16 @@ public enum EnumTreeChromosome implements IChromosomeType { * Amount of random ticks which need to elapse before a sapling will grow into a tree. */ MATURATION(IAlleleInteger.class), - + GIRTH(IAlleleInteger.class), + /** + * The combustibility of the wood, when it burn to charcoal and the combustibility of the charcoal. + */ + COMBUSTIBILITY(IAlleleInteger.class), + /** + * The amount of charcoal that a wood pile ash drop; + */ + CARBONIZATION(IAlleleInteger.class), /** * Determines if the tree can burn. */ diff --git a/src/main/java/forestry/api/arboriculture/IAlleleTreeSpecies.java b/src/main/java/forestry/api/arboriculture/IAlleleTreeSpecies.java index 8eb0e3e14..434bb0e67 100644 --- a/src/main/java/forestry/api/arboriculture/IAlleleTreeSpecies.java +++ b/src/main/java/forestry/api/arboriculture/IAlleleTreeSpecies.java @@ -10,7 +10,6 @@ import java.util.Collection; import net.minecraft.client.renderer.block.model.ModelResourceLocation; import net.minecraft.item.Item; - import net.minecraftforge.common.EnumPlantType; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; @@ -55,7 +54,9 @@ public interface IAlleleTreeSpecies extends IAlleleSpecies, IAlleleProperty extends IMultiblockComponent { + + @Override + T getMultiblockLogic(); + + @Nonnull + ITree getTree(); + + void setTree(@Nonnull ITree tree); + + @Override + @Nonnull + GameProfile getOwner(); + + void setOwner(@Nonnull GameProfile owner); + + EnumPileType getPileType(); + + @SideOnly(Side.CLIENT) + ITree getNextWoodPile(); + +} \ No newline at end of file diff --git a/src/main/java/forestry/api/multiblock/ICharcoalPileController.java b/src/main/java/forestry/api/multiblock/ICharcoalPileController.java new file mode 100644 index 000000000..c957f64ab --- /dev/null +++ b/src/main/java/forestry/api/multiblock/ICharcoalPileController.java @@ -0,0 +1,9 @@ +package forestry.api.multiblock; + +public interface ICharcoalPileController extends IMultiblockController{ + + boolean isActive(); + + void setActive(boolean active); + +} diff --git a/src/main/java/forestry/api/multiblock/IMultiblockLogicCharcoalPile.java b/src/main/java/forestry/api/multiblock/IMultiblockLogicCharcoalPile.java new file mode 100644 index 000000000..186ce8f1a --- /dev/null +++ b/src/main/java/forestry/api/multiblock/IMultiblockLogicCharcoalPile.java @@ -0,0 +1,21 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.api.multiblock; + +public interface IMultiblockLogicCharcoalPile extends IMultiblockLogic { + + /** + * @return the multiblock controller for this logic + */ + @Override + ICharcoalPileController getController(); + +} diff --git a/src/main/java/forestry/apiculture/network/packets/PacketActiveUpdate.java b/src/main/java/forestry/apiculture/network/packets/PacketActiveUpdate.java index 249c024f3..0e4d3c182 100644 --- a/src/main/java/forestry/apiculture/network/packets/PacketActiveUpdate.java +++ b/src/main/java/forestry/apiculture/network/packets/PacketActiveUpdate.java @@ -14,7 +14,7 @@ import java.io.IOException; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.tileentity.TileEntity; - +import forestry.api.multiblock.IMultiblockComponent; import forestry.core.network.DataInputStreamForestry; import forestry.core.network.DataOutputStreamForestry; import forestry.core.network.IForestryPacketClient; @@ -57,6 +57,13 @@ public class PacketActiveUpdate extends PacketCoordinates implements IForestryPa TileEntity tile = getTarget(Proxies.common.getRenderWorld()); if (tile instanceof IActivatable) { ((IActivatable) tile).setActive(active); + }else{ + if(tile instanceof IMultiblockComponent){ + IMultiblockComponent component = (IMultiblockComponent) tile; + if(component.getMultiblockLogic().isConnected() && component.getMultiblockLogic().getController() instanceof IActivatable){ + ((IActivatable)component.getMultiblockLogic().getController()).setActive(active); + } + } } } } diff --git a/src/main/java/forestry/apiculture/worldgen/VillageApiaristHouse.java b/src/main/java/forestry/apiculture/worldgen/VillageApiaristHouse.java index 737eeef59..e60c88ac6 100644 --- a/src/main/java/forestry/apiculture/worldgen/VillageApiaristHouse.java +++ b/src/main/java/forestry/apiculture/worldgen/VillageApiaristHouse.java @@ -21,6 +21,7 @@ import net.minecraft.block.BlockDoor; import net.minecraft.block.BlockFenceGate; import net.minecraft.block.BlockLog; import net.minecraft.block.BlockNewLog; +import net.minecraft.block.BlockOldLeaf; import net.minecraft.block.BlockOldLog; import net.minecraft.block.BlockPlanks; import net.minecraft.block.BlockStairs; diff --git a/src/main/java/forestry/arboriculture/PluginArboriculture.java b/src/main/java/forestry/arboriculture/PluginArboriculture.java index 430c9cc62..fd37fefd3 100644 --- a/src/main/java/forestry/arboriculture/PluginArboriculture.java +++ b/src/main/java/forestry/arboriculture/PluginArboriculture.java @@ -17,6 +17,7 @@ import java.util.List; import java.util.Set; import net.minecraft.block.Block; +import net.minecraft.block.BlockLeaves; import net.minecraft.block.BlockNewLeaf; import net.minecraft.block.BlockOldLeaf; import net.minecraft.block.state.IBlockState; @@ -39,6 +40,7 @@ import net.minecraftforge.fml.relauncher.SideOnly; import net.minecraftforge.oredict.OreDictionary; import forestry.api.arboriculture.EnumGermlingType; +import forestry.api.arboriculture.EnumPileType; import forestry.api.arboriculture.EnumWoodType; import forestry.api.arboriculture.IAlleleFruit; import forestry.api.arboriculture.ITree; @@ -52,6 +54,7 @@ import forestry.api.storage.ICrateRegistry; import forestry.api.storage.StorageManager; import forestry.arboriculture.blocks.BlockArbLog; import forestry.arboriculture.blocks.BlockArbSlab; +import forestry.arboriculture.blocks.BlockPile; import forestry.arboriculture.blocks.BlockRegistryArboriculture; import forestry.arboriculture.commands.CommandTree; import forestry.arboriculture.genetics.TreeBranchDefinition; @@ -63,12 +66,14 @@ import forestry.arboriculture.genetics.TreekeepingMode; import forestry.arboriculture.genetics.alleles.AlleleFruit; import forestry.arboriculture.genetics.alleles.AlleleGrowth; import forestry.arboriculture.genetics.alleles.AlleleLeafEffect; +import forestry.arboriculture.items.ItemGermlingGE; import forestry.arboriculture.items.ItemRegistryArboriculture; import forestry.arboriculture.models.TextureLeaves; import forestry.arboriculture.network.PacketRegistryArboriculture; import forestry.arboriculture.proxy.ProxyArboriculture; import forestry.arboriculture.tiles.TileFruitPod; import forestry.arboriculture.tiles.TileLeaves; +import forestry.arboriculture.tiles.TilePile; import forestry.arboriculture.tiles.TileSapling; import forestry.core.PluginCore; import forestry.core.config.Config; @@ -80,6 +85,7 @@ import forestry.core.network.IPacketRegistry; import forestry.core.recipes.RecipeUtil; import forestry.core.utils.IMCUtil; import forestry.core.utils.ItemStackUtil; +import forestry.core.utils.OreDictUtil; import forestry.core.utils.VillagerTradeLists; import forestry.factory.recipes.FabricatorRecipe; import forestry.plugins.BlankForestryPlugin; @@ -171,6 +177,7 @@ public class PluginArboriculture extends BlankForestryPlugin { GameRegistry.registerTileEntity(TileSapling.class, "forestry.Sapling"); GameRegistry.registerTileEntity(TileLeaves.class, "forestry.Leaves"); GameRegistry.registerTileEntity(TileFruitPod.class, "forestry.Pods"); + GameRegistry.registerTileEntity(TilePile.class, "forestry.Piles"); blocks.treeChest.init(); @@ -243,7 +250,7 @@ public class PluginArboriculture extends BlankForestryPlugin { fireproofPlanks.stackSize = 4; fireproofLogs.stackSize = 1; RecipeUtil.addShapelessRecipe(fireproofPlanks.copy(), fireproofLogs.copy()); - + slabs.stackSize = 6; planks.stackSize = 1; RecipeUtil.addPriorityRecipe(slabs.copy(), @@ -371,6 +378,18 @@ public class PluginArboriculture extends BlankForestryPlugin { '#', "blockGlass", 'X', "treeSapling", 'Y', "chestWood"); + + //Wood Piles + for(ITree tree : TreeManager.treeRoot.getIndividualTemplates()){ + ItemStack log = tree.getGenome().getPrimary().getWoodProvider().getWoodStack().copy(); + log.stackSize = 1; + ItemStack woodPile = BlockPile.createWoodPile(tree); + RecipeUtil.addShapelessRecipe(woodPile, log, log, log, log); + } + + //Dirt Pile Block + RecipeUtil.addShapelessRecipe(new ItemStack(PluginArboriculture.blocks.piles.get(EnumPileType.DIRT)), OreDictUtil.DUST_ASH, Items.CLAY_BALL, OreDictUtil.DUST_ASH, OreDictUtil.DIRT, OreDictUtil.DIRT, OreDictUtil.DIRT, OreDictUtil.TREE_LEAVES, Items.CLAY_BALL, OreDictUtil.TREE_LEAVES); + } private static void createAlleles() { @@ -387,7 +406,7 @@ public class PluginArboriculture extends BlankForestryPlugin { @Nullable @Override public ITree getTreeFromLeaf(IBlockState leafBlockState) { - if (!leafBlockState.getValue(BlockOldLeaf.DECAYABLE)) { + if (!leafBlockState.getValue(BlockLeaves.DECAYABLE)) { return null; } switch (leafBlockState.getValue(BlockOldLeaf.VARIANT)) { @@ -407,7 +426,7 @@ public class PluginArboriculture extends BlankForestryPlugin { @Nullable @Override public ITree getTreeFromLeaf(IBlockState leafBlockState) { - if (!leafBlockState.getValue(BlockNewLeaf.DECAYABLE)) { + if (!leafBlockState.getValue(BlockLeaves.DECAYABLE)) { return null; } switch (leafBlockState.getValue(BlockNewLeaf.VARIANT)) { @@ -483,6 +502,10 @@ public class PluginArboriculture extends BlankForestryPlugin { return 100; } + if(items.charcoal == item){ + return ItemGermlingGE.getBurnTime(fuel); + } + Block block = Block.getBlockFromItem(item); if (block instanceof IWoodTyped) { diff --git a/src/main/java/forestry/arboriculture/blocks/BlockFruitPod.java b/src/main/java/forestry/arboriculture/blocks/BlockFruitPod.java index 8d872cdc5..d4b253f11 100644 --- a/src/main/java/forestry/arboriculture/blocks/BlockFruitPod.java +++ b/src/main/java/forestry/arboriculture/blocks/BlockFruitPod.java @@ -34,7 +34,7 @@ import net.minecraftforge.fml.relauncher.SideOnly; import forestry.api.arboriculture.IAlleleFruit; import forestry.api.core.IStateMapperRegister; import forestry.arboriculture.genetics.alleles.AlleleFruit; -import forestry.arboriculture.models.FruitPodStateMapper; +import forestry.arboriculture.render.FruitPodStateMapper; import forestry.arboriculture.tiles.TileFruitPod; import forestry.core.proxy.Proxies; import forestry.core.tiles.TileUtil; diff --git a/src/main/java/forestry/arboriculture/blocks/BlockPile.java b/src/main/java/forestry/arboriculture/blocks/BlockPile.java new file mode 100644 index 000000000..609da4199 --- /dev/null +++ b/src/main/java/forestry/arboriculture/blocks/BlockPile.java @@ -0,0 +1,526 @@ +package forestry.arboriculture.blocks; + +import java.util.ArrayList; +import java.util.EnumMap; +import java.util.List; +import java.util.Map; +import java.util.Random; + +import com.google.common.collect.Lists; + +import forestry.api.arboriculture.EnumGermlingType; +import forestry.api.arboriculture.EnumPileType; +import forestry.api.arboriculture.IAlleleTreeSpecies; +import forestry.api.arboriculture.ITree; +import forestry.api.arboriculture.TreeManager; +import forestry.api.core.IModelManager; +import forestry.api.core.ISpriteRegister; +import forestry.api.core.IStateMapperRegister; +import forestry.api.core.ITextureManager; +import forestry.api.core.Tabs; +import forestry.api.genetics.AlleleManager; +import forestry.api.genetics.IAllele; +import forestry.api.multiblock.ICharcoalPileComponent; +import forestry.apiculture.blocks.BlockCandle; +import forestry.arboriculture.PluginArboriculture; +import forestry.arboriculture.genetics.Tree; +import forestry.arboriculture.multiblock.EnumPilePosition; +import forestry.arboriculture.multiblock.ICharcoalPileControllerInternal; +import forestry.arboriculture.render.PileStateMapper; +import forestry.arboriculture.tiles.TilePile; +import forestry.core.PluginCore; +import forestry.core.blocks.BlockStructure; +import forestry.core.blocks.propertys.UnlistedBlockAccess; +import forestry.core.blocks.propertys.UnlistedBlockPos; +import forestry.core.multiblock.MultiblockLogic; +import forestry.core.proxy.Proxies; +import forestry.core.tiles.TileUtil; +import forestry.core.utils.ItemStackUtil; +import net.minecraft.block.Block; +import net.minecraft.block.ITileEntityProvider; +import net.minecraft.block.SoundType; +import net.minecraft.block.material.Material; +import net.minecraft.block.properties.IProperty; +import net.minecraft.block.properties.PropertyEnum; +import net.minecraft.block.state.BlockStateContainer; +import net.minecraft.block.state.IBlockState; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.Entity; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.EnumBlockRenderType; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.EnumHand; +import net.minecraft.util.EnumParticleTypes; +import net.minecraft.util.math.AxisAlignedBB; +import net.minecraft.util.math.BlockPos; +import net.minecraft.util.math.RayTraceResult; +import net.minecraft.util.math.Vec3d; +import net.minecraft.util.text.TextComponentString; +import net.minecraft.util.text.TextComponentTranslation; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.property.ExtendedBlockState; +import net.minecraftforge.common.property.IExtendedBlockState; +import net.minecraftforge.common.property.IUnlistedProperty; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +public abstract class BlockPile extends BlockStructure implements ITileEntityProvider, IStateMapperRegister, ISpriteRegister { + + /** + * B: .. T: x. + * B: .. T: x. + */ + protected static final AxisAlignedBB AABB_QTR_TOP_WEST = new AxisAlignedBB(0.0D, 0.5D, 0.0D, 0.5D, 1.0D, 1.0D); + /** + * B: .. T: .x + * B: .. T: .x + */ + protected static final AxisAlignedBB AABB_QTR_TOP_EAST = new AxisAlignedBB(0.5D, 0.5D, 0.0D, 1.0D, 1.0D, 1.0D); + /** + * B: .. T: xx + * B: .. T: .. + */ + protected static final AxisAlignedBB AABB_QTR_TOP_NORTH = new AxisAlignedBB(0.0D, 0.5D, 0.0D, 1.0D, 1.0D, 0.5D); + /** + * B: .. T: .. + * B: .. T: xx + */ + protected static final AxisAlignedBB AABB_QTR_TOP_SOUTH = new AxisAlignedBB(0.0D, 0.5D, 0.5D, 1.0D, 1.0D, 1.0D); + /** + * B: .. T: x. + * B: .. T: .. + */ + protected static final AxisAlignedBB AABB_OCT_TOP_NW = new AxisAlignedBB(0.0D, 0.5D, 0.0D, 0.5D, 1.0D, 0.5D); + /** + * B: .. T: .x + * B: .. T: .. + */ + protected static final AxisAlignedBB AABB_OCT_TOP_NE = new AxisAlignedBB(0.5D, 0.5D, 0.0D, 1.0D, 1.0D, 0.5D); + /** + * B: .. T: .. + * B: .. T: x. + */ + protected static final AxisAlignedBB AABB_OCT_TOP_SW = new AxisAlignedBB(0.0D, 0.5D, 0.5D, 0.5D, 1.0D, 1.0D); + /** + * B: .. T: .. + * B: .. T: .x + */ + protected static final AxisAlignedBB AABB_OCT_TOP_SE = new AxisAlignedBB(0.5D, 0.5D, 0.5D, 1.0D, 1.0D, 1.0D); + /** + * B: xx T: .. + * B: xx T: .. + */ + protected static final AxisAlignedBB AABB_SLAB_BOTTOM = new AxisAlignedBB(0.0D, 0.0D, 0.0D, 1.0D, 0.5D, 1.0D); + + public static final PropertyEnum PILE_POSITION = PropertyEnum.create("position", EnumPilePosition.class); + + public static Map create() { + Map blockMap = new EnumMap<>(EnumPileType.class); + for (final EnumPileType type : EnumPileType.VALUES) { + BlockPile pile = new BlockPile() { + + @Override + public EnumPileType getPileType() { + return type; + } + + @Override + public SoundType getSoundType() { + if(type == EnumPileType.DIRT){ + return Blocks.DIRT.getSoundType(); + }else if(type == EnumPileType.ASH){ + return Blocks.SAND.getSoundType(); + }else if(type == EnumPileType.WOOD){ + return Blocks.LOG.getSoundType(); + } + return super.getSoundType(); + } + }; + blockMap.put(type, pile); + } + return blockMap; + } + + public BlockPile() { + super(Material.GROUND); + setHardness(1.0F); + setUnlocalizedName("charcoal.pile"); + setCreativeTab(Tabs.tabArboriculture); + setHarvestLevel("axe", 0); + setDefaultState(blockState.getBaseState().withProperty(PILE_POSITION, EnumPilePosition.INTERIOR)); + } + + @Override + protected BlockStateContainer createBlockState() { + return new ExtendedBlockState(this, new IProperty[]{PILE_POSITION}, new IUnlistedProperty[]{UnlistedBlockPos.POS, UnlistedBlockAccess.BLOCKACCESS}); + } + + @Override + public IBlockState getExtendedState(IBlockState state, IBlockAccess world, BlockPos pos) { + return ((IExtendedBlockState) super.getExtendedState(state, world, pos)).withProperty(UnlistedBlockPos.POS, pos) + .withProperty(UnlistedBlockAccess.BLOCKACCESS, world); + } + + @Override + public RayTraceResult collisionRayTrace(IBlockState blockState, World worldIn, BlockPos pos, Vec3d start, Vec3d end){ + List list = Lists.newArrayList(); + + for (AxisAlignedBB axisalignedbb : getCollisionBoxList(this.getActualState(blockState, worldIn, pos))) + { + list.add(this.rayTrace(pos, start, end, axisalignedbb)); + } + + RayTraceResult raytraceresult1 = null; + double d1 = 0.0D; + + for (RayTraceResult raytraceresult : list) + { + if (raytraceresult != null) + { + double d0 = raytraceresult.hitVec.squareDistanceTo(end); + + if (d0 > d1) + { + raytraceresult1 = raytraceresult; + d1 = d0; + } + } + } + + return raytraceresult1; + } + + @Override + public void addCollisionBoxToList(IBlockState state, World worldIn, BlockPos pos, AxisAlignedBB entityBox, List collidingBoxes, Entity entityIn){ + state = this.getActualState(state, worldIn, pos); + + for (AxisAlignedBB axisalignedbb : getCollisionBoxList(state)){ + addCollisionBoxToList(pos, entityBox, collidingBoxes, axisalignedbb); + } + } + + private static List getCollisionBoxList(IBlockState state){ + List list = Lists.newArrayList(); + EnumPilePosition position = state.getValue(PILE_POSITION); + + if(position != EnumPilePosition.INTERIOR){ + list.add(AABB_SLAB_BOTTOM); + + switch (position) { + case BACK: + list.add(AABB_QTR_TOP_SOUTH); + break; + case FRONT: + list.add(AABB_QTR_TOP_NORTH); + break; + case SIDE_LEFT: + list.add(AABB_QTR_TOP_EAST); + break; + case SIDE_RIGHT: + list.add(AABB_QTR_TOP_WEST); + break; + case CORNER_BACK_LEFT: + list.add(AABB_OCT_TOP_NE); + break; + case CORNER_BACK_RIGHT: + list.add(AABB_OCT_TOP_NW); + break; + case CORNER_FRONT_LEFT: + list.add(AABB_OCT_TOP_SE); + break; + case CORNER_FRONT_RIGHT: + list.add(AABB_OCT_TOP_SW); + break; + default: + break; + } + }else{ + list.add(Block.FULL_BLOCK_AABB); + } + + return list; + } + + @Override + public int getMetaFromState(IBlockState state) { + return state.getValue(PILE_POSITION).ordinal(); + } + + @Override + public IBlockState getStateFromMeta(int meta) { + return getDefaultState().withProperty(PILE_POSITION, EnumPilePosition.values()[meta]); + } + + @Override + public TileEntity createNewTileEntity(World world, int meta) { + return new TilePile(); + } + + @Override + public int getLightValue(IBlockState state, IBlockAccess world, BlockPos pos) { + TileEntity tile = world.getTileEntity(pos); + if (tile instanceof ICharcoalPileComponent) { + ICharcoalPileComponent kiln = (ICharcoalPileComponent) tile; + if (kiln.getMultiblockLogic().isConnected() && kiln.getMultiblockLogic().getController().isAssembled() && kiln.getMultiblockLogic().getController().isActive()) { + return 10; + } + } + return super.getLightValue(state, world, pos); + } + + @SideOnly(Side.CLIENT) + @Override + public void randomDisplayTick(IBlockState state, World world, BlockPos pos, Random rand) { + TilePile pile = TileUtil.getTile(world, pos, TilePile.class); + if(pile == null){ + return; + } + MultiblockLogic logic = pile.getMultiblockLogic(); + + if (logic.isConnected() && logic.getController().isAssembled() && logic.getController().isActive() && state.getValue(PILE_POSITION) != EnumPilePosition.INTERIOR) { + float f = pos.getX() + 0.5F; + float f1 = pos.getY() + 0.0F + rand.nextFloat() * 6.0F / 16.0F; + float f2 = pos.getZ() + 0.5F; + float f3 = 0.52F; + float f4 = rand.nextFloat() * 0.6F - 0.3F; + world.spawnParticle(EnumParticleTypes.SMOKE_NORMAL, f + f3 - 0.5, f1 + 0.5, f2 + f4, 0.0D, 0.0D, 0.0D, new int[0]); + } + } + + @SideOnly(Side.CLIENT) + @Override + public void getSubBlocks(Item item, CreativeTabs tab, List subItems) { + if(getPileType() == EnumPileType.WOOD){ + List woodPiles = new ArrayList(); + for(ITree tree : TreeManager.treeRoot.getIndividualTemplates()) { + woodPiles.add(createWoodPile(tree)); + } + subItems.addAll(woodPiles); + }else if(getPileType() == EnumPileType.DIRT){ + super.getSubBlocks(item, tab, subItems); + } + } + + private long previousMessageTick = 0; + + @Override + public boolean onBlockActivated(World world, BlockPos pos, IBlockState state, EntityPlayer player, EnumHand hand, ItemStack heldItem, EnumFacing side, float hitX, float hitY, float hitZ) { + if(world.isRemote){ + return false; + } + + if (player.isSneaking()) { + return false; + } + + TilePile pile = TileUtil.getTile(world, pos, TilePile.class); + + if(pile == null) { + return false; + } + + ICharcoalPileControllerInternal controller = pile.getMultiblockLogic().getController(); + + // If the player's hands are empty and they right-click on a multiblock, they get a + // multiblock-debugging message if the machine is not assembled. + if (heldItem == null) { + if (controller != null) { + if (!controller.isAssembled()) { + String validationError = controller.getLastValidationError(); + if (validationError != null) { + long tick = world.getTotalWorldTime(); + if (tick > previousMessageTick + 20) { + player.addChatMessage(new TextComponentString(validationError)); + previousMessageTick = tick; + } + return true; + } + } + } else { + player.addChatMessage(new TextComponentTranslation("for.multiblock.error.notConnected")); + return true; + } + }else if(BlockCandle.lightingItems.contains(heldItem.getItem())) { + if (pile.getMultiblockLogic().isConnected() && controller != null && controller.isAssembled() && !controller.isActive()) { + controller.setActive(true); + return true; + } + } + return false; + } + + /* DROP HANDLING */ + // Hack: When harvesting we need to get the drops in onBlockHarvested, + // because Mojang destroys the block and tile before calling getDrops. + private final ThreadLocal> drop = new ThreadLocal<>(); + + @Override + public void onBlockHarvested(World world, BlockPos pos, IBlockState state, EntityPlayer player) { + if (!world.isRemote) { + TileEntity tile = world.getTileEntity(pos); + if (tile instanceof ICharcoalPileComponent) { + ICharcoalPileComponent pile = (ICharcoalPileComponent) tile; + ArrayList list = new ArrayList(); + if (getPileType() == EnumPileType.ASH) { + if(pile.getTree() != null){ + ItemStack charcoal = TreeManager.treeRoot.getMemberStack(pile.getTree(), EnumGermlingType.CHARCOAL); + charcoal.stackSize = pile.getTree().getGenome().getCarbonization(); + list.add(charcoal); + list.add(new ItemStack(PluginCore.items.ash, 3)); + }else{ + list.add(new ItemStack(Blocks.DIRT, 2)); + list.add(new ItemStack(PluginCore.items.ash, 2)); + } + } else if (getPileType() == EnumPileType.DIRT) { + list.add(new ItemStack(this)); + } else { + list.add(createWoodPile(pile.getTree())); + } + drop.set(list); + } + } + } + + @Override + public List getDrops(IBlockAccess world, BlockPos pos, IBlockState state, int fortune) { + List drops = drop.get(); + drop.remove(); + return drops; + } + + @Override + public void breakBlock(World world, BlockPos pos, IBlockState state) { + if (world.isRemote) { + return; + } + + TileEntity tile = world.getTileEntity(pos); + if (tile instanceof ICharcoalPileComponent) { + ICharcoalPileComponent pile = (ICharcoalPileComponent) tile; + ArrayList list = new ArrayList(); + if (getPileType() == EnumPileType.ASH) { + if(pile.getTree() != null){ + ItemStack charcoal = TreeManager.treeRoot.getMemberStack(pile.getTree(), EnumGermlingType.CHARCOAL); + charcoal.stackSize = pile.getTree().getGenome().getCarbonization(); + list.add(charcoal); + list.add(new ItemStack(PluginCore.items.ash, 3)); + }else{ + list.add(new ItemStack(Blocks.DIRT, 2)); + list.add(new ItemStack(PluginCore.items.ash, 2)); + } + } else if (getPileType() == EnumPileType.DIRT) { + list.add(new ItemStack(this)); + } else { + list.add(createWoodPile(pile.getTree())); + } + for(ItemStack items : list){ + ItemStackUtil.dropItemStackAsEntity(items, world, pos); + } + } + } + + @Override + public boolean isOpaqueCube(IBlockState state) { + if(state.getValue(PILE_POSITION) != EnumPilePosition.INTERIOR){ + return false; + } + return true; + } + + @Override + public int getLightOpacity(IBlockState state) { + if(state.getValue(PILE_POSITION) != EnumPilePosition.INTERIOR){ + return 0; + } + return super.getLightOpacity(state); + } + + @Override + public boolean isFullBlock(IBlockState state) { + if(state.getValue(PILE_POSITION) != EnumPilePosition.INTERIOR){ + return false; + } + return true; + } + + @Override + public boolean isFullCube(IBlockState state) { + if(state.getValue(PILE_POSITION) != EnumPilePosition.INTERIOR){ + return false; + } + return true; + } + + @Override + public EnumBlockRenderType getRenderType(IBlockState state) { + if(state.getValue(PILE_POSITION) != EnumPilePosition.INTERIOR){ + return EnumBlockRenderType.INVISIBLE; + } + return EnumBlockRenderType.MODEL; + } + + @Override + public void registerStateMapper() { + Proxies.render.registerStateMapper(this, new PileStateMapper()); + } + + @Override + public ItemStack getPickBlock(IBlockState state, RayTraceResult target, World world, BlockPos pos, EntityPlayer player) { + TileEntity tile = world.getTileEntity(pos); + if (tile instanceof ICharcoalPileComponent) { + return createWoodPile(((ICharcoalPileComponent) tile).getTree()); + } + return super.getPickBlock(state, target, world, pos, player); + } + + @SideOnly(Side.CLIENT) + @Override + public void registerModel(Item item, IModelManager manager) { + if(getPileType() == EnumPileType.WOOD){ + manager.registerItemModel(item, 0, "woodPile"); + }else if(getPileType() == EnumPileType.DIRT){ + manager.registerItemModel(item, 0, "dirtPile"); + }else if(getPileType() == EnumPileType.ASH){ + manager.registerItemModel(item, 0, "ashPile"); + } + } + + @SideOnly(Side.CLIENT) + @Override + public void registerSprites(ITextureManager manager) { + for(IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()){ + if(allele instanceof IAlleleTreeSpecies){ + IAlleleTreeSpecies treeSpecies = (IAlleleTreeSpecies) allele; + treeSpecies.getWoodProvider().registerSprites(Item.getItemFromBlock(this), manager); + } + } + } + + public static ITree getTree(ItemStack stack){ + if (stack != null) { + return new Tree(stack.getTagCompound().getCompoundTag("ContainedTree")); + } + return null; + } + + public static ItemStack createWoodPile(ITree tree) { + if (tree != null) { + ItemStack stack = new ItemStack(PluginArboriculture.blocks.piles.get(EnumPileType.WOOD)); + NBTTagCompound nbtTag = new NBTTagCompound(); + tree.writeToNBT(nbtTag); + NBTTagCompound nbtItem = new NBTTagCompound(); + nbtItem.setTag("ContainedTree", nbtTag); + stack.setTagCompound(nbtItem); + return stack; + } + return null; + } + + public abstract EnumPileType getPileType(); +} diff --git a/src/main/java/forestry/arboriculture/blocks/BlockRegistryArboriculture.java b/src/main/java/forestry/arboriculture/blocks/BlockRegistryArboriculture.java index fe675737e..78ea38dbd 100644 --- a/src/main/java/forestry/arboriculture/blocks/BlockRegistryArboriculture.java +++ b/src/main/java/forestry/arboriculture/blocks/BlockRegistryArboriculture.java @@ -13,17 +13,20 @@ package forestry.arboriculture.blocks; import java.util.ArrayList; import java.util.HashMap; import java.util.List; +import java.util.Locale; import java.util.Map; +import java.util.Map.Entry; import net.minecraft.block.state.IBlockState; import net.minecraft.item.ItemStack; - +import forestry.api.arboriculture.EnumPileType; import forestry.api.arboriculture.EnumWoodType; import forestry.api.arboriculture.IAlleleFruit; import forestry.arboriculture.genetics.TreeDefinition; import forestry.arboriculture.genetics.alleles.AlleleFruit; import forestry.arboriculture.items.ItemBlockDecorativeLeaves; import forestry.arboriculture.items.ItemBlockLeaves; +import forestry.arboriculture.items.ItemBlockPile; import forestry.arboriculture.items.ItemBlockWood; import forestry.arboriculture.items.ItemBlockWoodDoor; import forestry.arboriculture.items.ItemBlockWoodSlab; @@ -53,6 +56,7 @@ public class BlockRegistryArboriculture extends BlockRegistry { public final List leavesDecorative; private final Map speciesToLeavesDecorative; public final Map podsMap; + public final Map piles; public final BlockArboriculture treeChest; @@ -187,6 +191,11 @@ public class BlockRegistryArboriculture extends BlockRegistry { } } + piles = BlockPile.create(); + for(Entry pile : piles.entrySet()){ + registerBlock(pile.getValue(), new ItemBlockPile(pile.getValue()), "pile_" + pile.getKey().name().toLowerCase(Locale.ENGLISH)); + } + // Pods AlleleFruit.createAlleles(); podsMap = new HashMap<>(); diff --git a/src/main/java/forestry/arboriculture/blocks/BlockSapling.java b/src/main/java/forestry/arboriculture/blocks/BlockSapling.java index 2cb36d855..8f754ade7 100644 --- a/src/main/java/forestry/arboriculture/blocks/BlockSapling.java +++ b/src/main/java/forestry/arboriculture/blocks/BlockSapling.java @@ -42,7 +42,7 @@ import forestry.api.core.IModelManager; import forestry.api.core.IStateMapperRegister; import forestry.arboriculture.blocks.property.PropertyTree; import forestry.arboriculture.genetics.TreeDefinition; -import forestry.arboriculture.models.SaplingStateMapper; +import forestry.arboriculture.render.SaplingStateMapper; import forestry.arboriculture.tiles.TileSapling; import forestry.core.proxy.Proxies; import forestry.core.tiles.TileUtil; diff --git a/src/main/java/forestry/arboriculture/genetics/TreeBranchDefinition.java b/src/main/java/forestry/arboriculture/genetics/TreeBranchDefinition.java index 43ca3e2a1..b4c8ed105 100644 --- a/src/main/java/forestry/arboriculture/genetics/TreeBranchDefinition.java +++ b/src/main/java/forestry/arboriculture/genetics/TreeBranchDefinition.java @@ -96,6 +96,8 @@ public enum TreeBranchDefinition implements IBranchDefinition { AlleleHelper.instance.set(defaultTemplate, EnumTreeChromosome.EFFECT, AlleleLeafEffect.leavesNone); AlleleHelper.instance.set(defaultTemplate, EnumTreeChromosome.MATURATION, EnumAllele.Maturation.AVERAGE); AlleleHelper.instance.set(defaultTemplate, EnumTreeChromosome.GIRTH, 1); + AlleleHelper.instance.set(defaultTemplate, EnumTreeChromosome.COMBUSTIBILITY, 20); + AlleleHelper.instance.set(defaultTemplate, EnumTreeChromosome.CARBONIZATION, 4); AlleleHelper.instance.set(defaultTemplate, EnumTreeChromosome.FIREPROOF, EnumAllele.Fireproof.FALSE); } return Arrays.copyOf(defaultTemplate, defaultTemplate.length); diff --git a/src/main/java/forestry/arboriculture/genetics/TreeDefinition.java b/src/main/java/forestry/arboriculture/genetics/TreeDefinition.java index 0f121956d..c0ecbc7d7 100644 --- a/src/main/java/forestry/arboriculture/genetics/TreeDefinition.java +++ b/src/main/java/forestry/arboriculture/genetics/TreeDefinition.java @@ -43,6 +43,7 @@ import forestry.api.arboriculture.ITree; import forestry.api.arboriculture.ITreeGenerator; import forestry.api.arboriculture.ITreeGenome; import forestry.api.arboriculture.ITreeMutationCustom; +import forestry.api.arboriculture.IWoodProvider; import forestry.api.arboriculture.TreeManager; import forestry.api.core.EnumHumidity; import forestry.api.core.EnumTemperature; @@ -108,6 +109,8 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.FRUITS, AlleleFruit.fruitApple); AlleleHelper.instance.set(alleles, EnumTreeChromosome.FERTILITY, EnumAllele.Saplings.AVERAGE); AlleleHelper.instance.set(alleles, EnumTreeChromosome.MATURATION, EnumAllele.Maturation.FASTER); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.CARBONIZATION, 5); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 20); } @Override @@ -131,6 +134,8 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.FERTILITY, EnumAllele.Saplings.AVERAGE); AlleleHelper.instance.set(alleles, EnumTreeChromosome.MATURATION, EnumAllele.Maturation.FASTER); AlleleHelper.instance.set(alleles, EnumTreeChromosome.GIRTH, 2); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.CARBONIZATION, 5); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 20); } @Override @@ -153,6 +158,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe protected void setAlleles(IAllele[] alleles) { AlleleHelper.instance.set(alleles, EnumTreeChromosome.FERTILITY, EnumAllele.Saplings.AVERAGE); AlleleHelper.instance.set(alleles, EnumTreeChromosome.MATURATION, EnumAllele.Maturation.FASTER); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 19); } @Override @@ -176,6 +182,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.FERTILITY, EnumAllele.Saplings.LOW); AlleleHelper.instance.set(alleles, EnumTreeChromosome.SAPPINESS, EnumAllele.Sappiness.LOWER); AlleleHelper.instance.set(alleles, EnumTreeChromosome.YIELD, EnumAllele.Yield.LOWER); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 19); //Allele.helper.set(alleles, EnumTreeChromosome.EFFECT, Allele.leavesBrimstone); } @@ -212,6 +219,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.SAPPINESS, EnumAllele.Sappiness.LOWER); AlleleHelper.instance.set(alleles, EnumTreeChromosome.HEIGHT, EnumAllele.Height.AVERAGE); AlleleHelper.instance.set(alleles, EnumTreeChromosome.GIRTH, 2); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 21); } @Override @@ -239,6 +247,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.SAPPINESS, EnumAllele.Sappiness.LOWER); AlleleHelper.instance.set(alleles, EnumTreeChromosome.HEIGHT, EnumAllele.Height.LARGE); AlleleHelper.instance.set(alleles, EnumTreeChromosome.GIRTH, 2); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 21); } @Override @@ -341,6 +350,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.FERTILITY, EnumAllele.Saplings.LOW); AlleleHelper.instance.set(alleles, EnumTreeChromosome.SAPPINESS, EnumAllele.Sappiness.LOWER); AlleleHelper.instance.set(alleles, EnumTreeChromosome.HEIGHT, EnumAllele.Height.AVERAGE); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 20); } @Override @@ -364,6 +374,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.FERTILITY, EnumAllele.Saplings.AVERAGE); AlleleHelper.instance.set(alleles, EnumTreeChromosome.HEIGHT, EnumAllele.Height.AVERAGE); AlleleHelper.instance.set(alleles, EnumTreeChromosome.MATURATION, EnumAllele.Maturation.FASTER); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 19); } @Override @@ -387,6 +398,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.FERTILITY, EnumAllele.Saplings.LOW); AlleleHelper.instance.set(alleles, EnumTreeChromosome.SAPPINESS, EnumAllele.Sappiness.LOWER); AlleleHelper.instance.set(alleles, EnumTreeChromosome.HEIGHT, EnumAllele.Height.AVERAGE); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 20); } @Override @@ -460,6 +472,8 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.SAPPINESS, EnumAllele.Sappiness.LOWEST); AlleleHelper.instance.set(alleles, EnumTreeChromosome.MATURATION, EnumAllele.Maturation.SLOWEST); AlleleHelper.instance.set(alleles, EnumTreeChromosome.GIRTH, 4); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.CARBONIZATION, 3); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 18); AlleleHelper.instance.set(alleles, EnumTreeChromosome.FIREPROOF, EnumAllele.Fireproof.TRUE); } @@ -484,6 +498,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.FRUITS, AlleleFruit.fruitCocoa); AlleleHelper.instance.set(alleles, EnumTreeChromosome.HEIGHT, EnumAllele.Height.LARGER); AlleleHelper.instance.set(alleles, EnumTreeChromosome.MATURATION, EnumAllele.Maturation.FAST); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.CARBONIZATION, 5); } @Override @@ -577,6 +592,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe AlleleHelper.instance.set(alleles, EnumTreeChromosome.SAPPINESS, EnumAllele.Sappiness.LOW); AlleleHelper.instance.set(alleles, EnumTreeChromosome.MATURATION, EnumAllele.Maturation.SLOWER); AlleleHelper.instance.set(alleles, EnumTreeChromosome.GIRTH, 3); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 20); } @Override @@ -644,7 +660,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe @Override protected void setAlleles(IAllele[] alleles) { - + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 20); } @Override @@ -667,6 +683,7 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe @Override protected void setAlleles(IAllele[] alleles) { AlleleHelper.instance.set(alleles, EnumTreeChromosome.PLANT, AllelePlantType.plantTypeDesert); + AlleleHelper.instance.set(alleles, EnumTreeChromosome.COMBUSTIBILITY, 20); } @Override @@ -974,8 +991,9 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe ILeafSpriteProvider leafIconProvider = TreeManager.treeFactory.getLeafIconProvider(leafType, primary, secondary); IGermlingModelProvider germlingIconProvider = new ModelProviderGermlingVanilla(vanillaMeta); + IWoodProvider woodProvider = new WoodProviderVanilla(vanillaMeta); - IAlleleTreeSpeciesBuilder speciesBuilder = TreeManager.treeFactory.createSpecies(uid, unlocalizedName, "Sengir", unlocalizedDescription, dominant, branch.getBranch(), binomial, Constants.MOD_ID, modelName, leafIconProvider, germlingIconProvider, this); + IAlleleTreeSpeciesBuilder speciesBuilder = TreeManager.treeFactory.createSpecies(uid, unlocalizedName, "Sengir", unlocalizedDescription, dominant, branch.getBranch(), binomial, Constants.MOD_ID, modelName, leafIconProvider, germlingIconProvider, woodProvider, this); setSpeciesProperties(speciesBuilder); this.species = speciesBuilder.build(); @@ -994,8 +1012,9 @@ public enum TreeDefinition implements ITreeDefinition, ITreeGenerator, IStringSe ILeafSpriteProvider leafIconProvider = TreeManager.treeFactory.getLeafIconProvider(leafType, primary, secondary); IGermlingModelProvider germlingIconProvider = new ModelProviderGermling(uid); + IWoodProvider woodProvider = new WoodProvider(woodType.toString().toLowerCase(Locale.ENGLISH), woodType); - IAlleleTreeSpeciesBuilder speciesBuilder = TreeManager.treeFactory.createSpecies(uid, unlocalizedName, "Sengir", unlocalizedDescription, dominant, branch.getBranch(), binomial, Constants.MOD_ID, modelName, leafIconProvider, germlingIconProvider, this); + IAlleleTreeSpeciesBuilder speciesBuilder = TreeManager.treeFactory.createSpecies(uid, unlocalizedName, "Sengir", unlocalizedDescription, dominant, branch.getBranch(), binomial, Constants.MOD_ID, modelName, leafIconProvider, germlingIconProvider, woodProvider, this); setSpeciesProperties(speciesBuilder); this.species = speciesBuilder.build(); diff --git a/src/main/java/forestry/arboriculture/genetics/TreeFactory.java b/src/main/java/forestry/arboriculture/genetics/TreeFactory.java index aec48738b..0a27eabc4 100644 --- a/src/main/java/forestry/arboriculture/genetics/TreeFactory.java +++ b/src/main/java/forestry/arboriculture/genetics/TreeFactory.java @@ -18,14 +18,15 @@ import forestry.api.arboriculture.IGermlingModelProvider; import forestry.api.arboriculture.ILeafSpriteProvider; import forestry.api.arboriculture.ITreeFactory; import forestry.api.arboriculture.ITreeGenerator; +import forestry.api.arboriculture.IWoodProvider; import forestry.api.genetics.IClassification; import forestry.arboriculture.genetics.alleles.AlleleTreeSpecies; import forestry.arboriculture.models.SpriteProviderLeaves; public class TreeFactory implements ITreeFactory { @Override - public IAlleleTreeSpeciesBuilder createSpecies(String uid, String unlocalizedName, String authority, String unlocalizedDescription, boolean dominant, IClassification branch, String binomial, String modID, String modelName, ILeafSpriteProvider leafSpriteProvider, IGermlingModelProvider germlingModelProvider, ITreeGenerator generator) { - return new AlleleTreeSpecies(uid, unlocalizedName, authority, unlocalizedDescription, dominant, branch, binomial, modID, modelName, leafSpriteProvider, germlingModelProvider, generator); + public IAlleleTreeSpeciesBuilder createSpecies(String uid, String unlocalizedName, String authority, String unlocalizedDescription, boolean dominant, IClassification branch, String binomial, String modID, String modelName, ILeafSpriteProvider leafSpriteProvider, IGermlingModelProvider germlingModelProvider, IWoodProvider woodProvider, ITreeGenerator generator) { + return new AlleleTreeSpecies(uid, unlocalizedName, authority, unlocalizedDescription, dominant, branch, binomial, modID, modelName, leafSpriteProvider, germlingModelProvider, woodProvider, generator); } @Override diff --git a/src/main/java/forestry/arboriculture/genetics/TreeGenome.java b/src/main/java/forestry/arboriculture/genetics/TreeGenome.java index cbcfbc608..8139d68da 100755 --- a/src/main/java/forestry/arboriculture/genetics/TreeGenome.java +++ b/src/main/java/forestry/arboriculture/genetics/TreeGenome.java @@ -115,6 +115,16 @@ public class TreeGenome extends Genome implements ITreeGenome { return ((IAlleleInteger) getActiveAllele(EnumTreeChromosome.GIRTH)).getValue(); } + @Override + public int getCombustibility(){ + return ((IAlleleInteger) getActiveAllele(EnumTreeChromosome.COMBUSTIBILITY)).getValue(); + } + + @Override + public int getCarbonization(){ + return ((IAlleleInteger) getActiveAllele(EnumTreeChromosome.CARBONIZATION)).getValue(); + } + @Override public IAlleleLeafEffect getEffect() { return (IAlleleLeafEffect) getActiveAllele(EnumTreeChromosome.EFFECT); diff --git a/src/main/java/forestry/arboriculture/genetics/TreeRoot.java b/src/main/java/forestry/arboriculture/genetics/TreeRoot.java index 3a06fe1b6..10d2733e4 100644 --- a/src/main/java/forestry/arboriculture/genetics/TreeRoot.java +++ b/src/main/java/forestry/arboriculture/genetics/TreeRoot.java @@ -133,6 +133,8 @@ public class TreeRoot extends SpeciesRoot implements ITreeRoot { return EnumGermlingType.SAPLING; } else if (PluginArboriculture.items.pollenFertile == item) { return EnumGermlingType.POLLEN; + } else if (PluginArboriculture.items.charcoal == item) { + return EnumGermlingType.CHARCOAL; } return null; @@ -193,6 +195,9 @@ public class TreeRoot extends SpeciesRoot implements ITreeRoot { case POLLEN: germlingItem = PluginArboriculture.items.pollenFertile; break; + case CHARCOAL: + germlingItem = PluginArboriculture.items.charcoal; + break; default: throw new RuntimeException("Cannot instantiate a tree of type " + type); } diff --git a/src/main/java/forestry/arboriculture/genetics/WoodProvider.java b/src/main/java/forestry/arboriculture/genetics/WoodProvider.java new file mode 100644 index 000000000..fad82c21a --- /dev/null +++ b/src/main/java/forestry/arboriculture/genetics/WoodProvider.java @@ -0,0 +1,55 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.arboriculture.genetics; + +import forestry.api.arboriculture.EnumWoodType; +import forestry.api.arboriculture.IWoodProvider; +import forestry.api.arboriculture.TreeManager; +import forestry.api.core.ITextureManager; +import forestry.core.render.ForestryResource; +import forestry.core.render.TextureManager; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; + +public class WoodProvider implements IWoodProvider { + + private final String name; + private final EnumWoodType woodType; + private TextureAtlasSprite woodTop; + private TextureAtlasSprite woodBark; + + public WoodProvider(String name, EnumWoodType woodType) { + this.name = name; + this.woodType = woodType; + } + + @Override + public void registerSprites(Item item, ITextureManager manager) { + woodTop = TextureManager.registerSprite(new ForestryResource("blocks/wood/heart." + name)); + woodBark = TextureManager.registerSprite(new ForestryResource("blocks/wood/bark." + name)); + } + + @Override + public TextureAtlasSprite getSprite(boolean isTop) { + if(isTop){ + return woodTop; + }else{ + return woodBark; + } + } + + @Override + public ItemStack getWoodStack() { + return TreeManager.woodAccess.getLog(woodType, false); + } + +} diff --git a/src/main/java/forestry/arboriculture/genetics/WoodProviderVanilla.java b/src/main/java/forestry/arboriculture/genetics/WoodProviderVanilla.java new file mode 100644 index 000000000..26ee4dc3c --- /dev/null +++ b/src/main/java/forestry/arboriculture/genetics/WoodProviderVanilla.java @@ -0,0 +1,80 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.arboriculture.genetics; + +import forestry.api.arboriculture.IWoodProvider; +import forestry.api.core.ITextureManager; +import forestry.core.render.TextureManager; +import net.minecraft.block.Block; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.util.ResourceLocation; + +public class WoodProviderVanilla implements IWoodProvider { + + private final int vanillaMap; + private TextureAtlasSprite woodTop; + private TextureAtlasSprite woodBark; + + public WoodProviderVanilla(int vanillaMap) { + this.vanillaMap = vanillaMap; + } + + @Override + public void registerSprites(Item item, ITextureManager manager) { + String name = ""; + switch (vanillaMap) { + case 0: + name = "oak"; + break; + case 1: + name = "spruce"; + break; + case 2: + name = "birch"; + break; + case 3: + name = "jungle"; + break; + case 4: + name = "acacia"; + break; + case 5: + name = "big_oak"; + break; + } + woodTop = TextureManager.registerSprite(new ResourceLocation("minecraft:blocks/log_" + name + "_top")); + woodBark = TextureManager.registerSprite(new ResourceLocation("minecraft:blocks/log_" + name)); + } + + @Override + public TextureAtlasSprite getSprite(boolean isTop) { + if(isTop){ + return woodTop; + }else{ + return woodBark; + } + } + + @Override + public ItemStack getWoodStack() { + Block block; + if(vanillaMap < 4){ + block = Blocks.LOG; + }else{ + block = Blocks.LOG2; + } + return new ItemStack(block, 1, vanillaMap >= 4? vanillaMap - 4 : vanillaMap); + } + +} diff --git a/src/main/java/forestry/arboriculture/genetics/alleles/AlleleTreeSpecies.java b/src/main/java/forestry/arboriculture/genetics/alleles/AlleleTreeSpecies.java index a65935042..354de52fb 100644 --- a/src/main/java/forestry/arboriculture/genetics/alleles/AlleleTreeSpecies.java +++ b/src/main/java/forestry/arboriculture/genetics/alleles/AlleleTreeSpecies.java @@ -29,6 +29,7 @@ import forestry.api.arboriculture.IGermlingModelProvider; import forestry.api.arboriculture.ILeafSpriteProvider; import forestry.api.arboriculture.ITreeGenerator; import forestry.api.arboriculture.ITreeRoot; +import forestry.api.arboriculture.IWoodProvider; import forestry.api.arboriculture.TreeManager; import forestry.api.core.IModelManager; import forestry.api.genetics.AlleleManager; @@ -40,6 +41,8 @@ public class AlleleTreeSpecies extends AlleleSpecies implements IAlleleTreeSpeci @Nonnull private final ITreeGenerator generator; @Nonnull + private final IWoodProvider woodProvider; + @Nonnull private final IGermlingModelProvider germlingModelProvider; @Nonnull private final ILeafSpriteProvider leafSpriteProvider; @@ -64,11 +67,13 @@ public class AlleleTreeSpecies extends AlleleSpecies implements IAlleleTreeSpeci @Nonnull String modelName, @Nonnull ILeafSpriteProvider leafIconProvider, @Nonnull IGermlingModelProvider germlingModelProvider, + @Nonnull IWoodProvider woodProvider, @Nonnull ITreeGenerator generator) { super(uid, unlocalizedName, authority, unlocalizedDescription, isDominant, branch, binomial); this.generator = generator; this.germlingModelProvider = germlingModelProvider; + this.woodProvider = woodProvider; this.leafSpriteProvider = leafIconProvider; this.modID = modID; @@ -139,15 +144,22 @@ public class AlleleTreeSpecies extends AlleleSpecies implements IAlleleTreeSpeci @Override @SideOnly(Side.CLIENT) public int getGermlingColour(EnumGermlingType type, int renderPass) { - if (type == EnumGermlingType.SAPLING) { + if (type != EnumGermlingType.POLLEN) { return 0xFFFFFF; } return getSpriteColour(renderPass); } + @SideOnly(Side.CLIENT) @Override - public void registerModels(Item item, IModelManager manager) { - germlingModelProvider.registerModels(item, manager); + public void registerModels(Item item, IModelManager manager, EnumGermlingType type) { + germlingModelProvider.registerModels(item, manager, type); + } + + @Override + @Nonnull + public IWoodProvider getWoodProvider() { + return woodProvider; } @Nonnull diff --git a/src/main/java/forestry/arboriculture/items/ItemBlockPile.java b/src/main/java/forestry/arboriculture/items/ItemBlockPile.java new file mode 100644 index 000000000..cf631fa51 --- /dev/null +++ b/src/main/java/forestry/arboriculture/items/ItemBlockPile.java @@ -0,0 +1,91 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.arboriculture.items; + +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import forestry.api.arboriculture.EnumPileType; +import forestry.api.arboriculture.ITree; +import forestry.api.genetics.IAlleleSpecies; +import forestry.arboriculture.PluginArboriculture; +import forestry.arboriculture.blocks.BlockPile; +import forestry.arboriculture.tiles.TilePile; +import forestry.core.items.ItemBlockForestry; +import forestry.core.tiles.TileUtil; +import forestry.core.utils.Translator; + +public class ItemBlockPile extends ItemBlockForestry { + + public ItemBlockPile(Block block) { + super(block); + setMaxDamage(0); + setHasSubtypes(true); + } + + @Override + public B getBlock() { + //noinspection unchecked + return (B) super.getBlock(); + } + + @Override + public int getMetadata(int i) { + return i; + } + + @Override + public String getItemStackDisplayName(ItemStack itemstack) { + if(block == PluginArboriculture.blocks.piles.get(EnumPileType.WOOD)){ + if (!itemstack.hasTagCompound()) { + return "Unknown"; + } + ITree tree = BlockPile.getTree(itemstack); + if (tree == null) { + return "Unknown"; + } + IAlleleSpecies species = tree.getGenome().getPrimary(); + + String customTreeKey = "for.trees.custom.pile." + species.getUnlocalizedName().replace("trees.species.", ""); + if (Translator.canTranslateToLocal(customTreeKey)) { + return Translator.translateToLocal(customTreeKey); + } + String typeString = Translator.translateToLocal("for.trees.grammar.pile.type"); + return Translator.translateToLocal("for.trees.grammar.pile").replaceAll("%SPECIES", species.getName()).replaceAll("%TYPE", typeString); + }else{ + return Translator.translateToLocal("for.trees.pile.dirt"); + } + } + + @Override + public boolean placeBlockAt(ItemStack stack, EntityPlayer player, World world, BlockPos pos, EnumFacing side, float hitX, float hitY, float hitZ, IBlockState newState) { + boolean placed = super.placeBlockAt(stack, player, world, pos, side, hitX, hitY, hitZ, newState); + + if(block == PluginArboriculture.blocks.piles.get(EnumPileType.WOOD)){ + if (block.hasTileEntity(newState)) { + if (stack.hasTagCompound()) { + TilePile tile = TileUtil.getTile(world, pos, TilePile.class); + if (tile != null) { + tile.readFromNBT(stack.getTagCompound()); + tile.setPos(pos); + tile.markDirty(); + } + } + } + } + + return placed; + } +} diff --git a/src/main/java/forestry/arboriculture/items/ItemGermlingGE.java b/src/main/java/forestry/arboriculture/items/ItemGermlingGE.java index 32565f6d8..2698c73cd 100755 --- a/src/main/java/forestry/arboriculture/items/ItemGermlingGE.java +++ b/src/main/java/forestry/arboriculture/items/ItemGermlingGE.java @@ -126,7 +126,7 @@ public class ItemGermlingGE extends ItemGE implements IVariableFermentable, ICol manager.registerItemModel(item, new GermlingMeshDefinition()); for (IAllele allele : AlleleManager.alleleRegistry.getRegisteredAlleles().values()) { if (allele instanceof IAlleleTreeSpecies) { - ((IAlleleTreeSpecies) allele).registerModels(item, manager); + ((IAlleleTreeSpecies) allele).registerModels(item, manager, type); } } } @@ -162,6 +162,14 @@ public class ItemGermlingGE extends ItemGE implements IVariableFermentable, ICol } return new ActionResult<>(EnumActionResult.PASS, itemStackIn); } + + public static int getBurnTime(ItemStack fuel) { + if(TreeManager.treeRoot.isMember(fuel)){ + ITree tree = TreeManager.treeRoot.getMember(fuel); + return tree.getGenome().getCombustibility() * 100; + } + return 0; + } @Nonnull private static ActionResult onItemRightClickPollen(ItemStack itemStackIn, World worldIn, EntityPlayer playerIn, BlockPos pos, ITree tree) { diff --git a/src/main/java/forestry/arboriculture/items/ItemRegistryArboriculture.java b/src/main/java/forestry/arboriculture/items/ItemRegistryArboriculture.java index a5a1d7239..838d067c6 100644 --- a/src/main/java/forestry/arboriculture/items/ItemRegistryArboriculture.java +++ b/src/main/java/forestry/arboriculture/items/ItemRegistryArboriculture.java @@ -19,6 +19,7 @@ import forestry.core.utils.OreDictUtil; public class ItemRegistryArboriculture extends ItemRegistry { public final ItemGermlingGE sapling; public final ItemGermlingGE pollenFertile; + public final ItemGermlingGE charcoal; public final ItemGrafter grafter; public final ItemGrafter grafterProven; @@ -27,6 +28,7 @@ public class ItemRegistryArboriculture extends ItemRegistry { OreDictionary.registerOre(OreDictUtil.TREE_SAPLING, sapling.getWildcard()); pollenFertile = registerItem(new ItemGermlingGE(EnumGermlingType.POLLEN), "pollenFertile"); + charcoal = registerItem(new ItemGermlingGE(EnumGermlingType.CHARCOAL), "charcoal"); grafter = registerItem(new ItemGrafter(4), "grafter"); grafterProven = registerItem(new ItemGrafter(149), "grafterProven"); } diff --git a/src/main/java/forestry/arboriculture/models/ModelProviderGermling.java b/src/main/java/forestry/arboriculture/models/ModelProviderGermling.java index cba9811b9..5f5e660de 100644 --- a/src/main/java/forestry/arboriculture/models/ModelProviderGermling.java +++ b/src/main/java/forestry/arboriculture/models/ModelProviderGermling.java @@ -24,27 +24,37 @@ public class ModelProviderGermling implements IGermlingModelProvider { private final String name; - private ModelResourceLocation model; + private ModelResourceLocation germlingModel; private ModelResourceLocation pollenModel; + private ModelResourceLocation charcoalModel; public ModelProviderGermling(String uid) { this.name = uid.substring("forestry.".length()); } @Override - public void registerModels(Item item, IModelManager manager) { - model = manager.getModelLocation("germlings/sapling." + name); - manager.registerVariant(item, new ResourceLocation("forestry:germlings/sapling." + name)); - pollenModel = manager.getModelLocation("pollen"); - manager.registerVariant(item, new ResourceLocation("forestry:pollen")); + public void registerModels(Item item, IModelManager manager, EnumGermlingType type) { + if(type == EnumGermlingType.SAPLING){ + germlingModel = manager.getModelLocation("germlings/sapling." + name); + manager.registerVariant(item, new ResourceLocation("forestry:germlings/sapling." + name)); + }else if(type == EnumGermlingType.POLLEN){ + pollenModel = manager.getModelLocation("pollen"); + manager.registerVariant(item, new ResourceLocation("forestry:pollen")); + }else if(type == EnumGermlingType.CHARCOAL){ + charcoalModel = manager.getModelLocation("charcoal"); + manager.registerVariant(item, new ResourceLocation("forestry:charcoal")); + } } @Nonnull @Override public ModelResourceLocation getModel(EnumGermlingType type) { - if (type == EnumGermlingType.POLLEN) { + if(type == EnumGermlingType.POLLEN){ return pollenModel; + }else if(type == EnumGermlingType.CHARCOAL){ + return charcoalModel; + }else{ + return germlingModel; } - return model; } } diff --git a/src/main/java/forestry/arboriculture/models/ModelProviderGermlingVanilla.java b/src/main/java/forestry/arboriculture/models/ModelProviderGermlingVanilla.java index 3a56193ce..929f3e58f 100644 --- a/src/main/java/forestry/arboriculture/models/ModelProviderGermlingVanilla.java +++ b/src/main/java/forestry/arboriculture/models/ModelProviderGermlingVanilla.java @@ -14,7 +14,6 @@ import javax.annotation.Nonnull; import net.minecraft.client.renderer.block.model.ModelResourceLocation; import net.minecraft.item.Item; - import forestry.api.arboriculture.EnumGermlingType; import forestry.api.arboriculture.IGermlingModelProvider; import forestry.api.core.IModelManager; @@ -23,44 +22,53 @@ public class ModelProviderGermlingVanilla implements IGermlingModelProvider { private final int vanillaMap; - private ModelResourceLocation model; + private ModelResourceLocation germlingModel; private ModelResourceLocation pollenModel; + private ModelResourceLocation charcoalModel; public ModelProviderGermlingVanilla(int vanillaMap) { this.vanillaMap = vanillaMap; } @Override - public void registerModels(Item item, IModelManager manager) { - switch (vanillaMap) { - case 0: - model = manager.getModelLocation("minecraft", "oak_sapling"); - break; - case 1: - model = manager.getModelLocation("minecraft", "spruce_sapling"); - break; - case 2: - model = manager.getModelLocation("minecraft", "birch_sapling"); - break; - case 3: - model = manager.getModelLocation("minecraft", "jungle_sapling"); - break; - case 4: - model = manager.getModelLocation("minecraft", "acacia_sapling"); - break; - case 5: - model = manager.getModelLocation("minecraft", "dark_oak_sapling"); - break; + public void registerModels(Item item, IModelManager manager, EnumGermlingType type) { + if(type == EnumGermlingType.SAPLING){ + switch (vanillaMap) { + case 0: + germlingModel = manager.getModelLocation("minecraft", "oak_sapling"); + break; + case 1: + germlingModel = manager.getModelLocation("minecraft", "spruce_sapling"); + break; + case 2: + germlingModel = manager.getModelLocation("minecraft", "birch_sapling"); + break; + case 3: + germlingModel = manager.getModelLocation("minecraft", "jungle_sapling"); + break; + case 4: + germlingModel = manager.getModelLocation("minecraft", "acacia_sapling"); + break; + case 5: + germlingModel = manager.getModelLocation("minecraft", "dark_oak_sapling"); + break; + } + }else if(type == EnumGermlingType.POLLEN){ + pollenModel = manager.getModelLocation("pollen"); + }else if(type == EnumGermlingType.CHARCOAL){ + charcoalModel = manager.getModelLocation("minecraft", "charcoal"); } - pollenModel = manager.getModelLocation("pollen"); } @Nonnull @Override public ModelResourceLocation getModel(EnumGermlingType type) { - if (type == EnumGermlingType.POLLEN) { + if(type == EnumGermlingType.POLLEN){ return pollenModel; + }else if(type == EnumGermlingType.CHARCOAL){ + return charcoalModel; + }else{ + return germlingModel; } - return model; } } diff --git a/src/main/java/forestry/arboriculture/models/ModelWoodPile.java b/src/main/java/forestry/arboriculture/models/ModelWoodPile.java new file mode 100644 index 000000000..7c74e2f10 --- /dev/null +++ b/src/main/java/forestry/arboriculture/models/ModelWoodPile.java @@ -0,0 +1,148 @@ +package forestry.arboriculture.models; + +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import com.google.common.base.Function; +import com.google.common.collect.ImmutableMap; + +import forestry.api.arboriculture.IAlleleTreeSpecies; +import forestry.api.arboriculture.ITree; +import forestry.api.arboriculture.TreeManager; +import forestry.arboriculture.genetics.Tree; +import forestry.arboriculture.tiles.TilePile; +import forestry.core.blocks.propertys.UnlistedBlockAccess; +import forestry.core.blocks.propertys.UnlistedBlockPos; +import forestry.core.models.BlankItemModel; +import forestry.core.models.DefaultTextureGetter; +import forestry.core.tiles.TileUtil; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.renderer.block.model.BakedQuad; +import net.minecraft.client.renderer.block.model.IBakedModel; +import net.minecraft.client.renderer.block.model.ItemOverrideList; +import net.minecraft.client.renderer.block.model.ModelRotation; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.vertex.DefaultVertexFormats; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.item.ItemStack; +import net.minecraft.util.EnumFacing; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.client.model.IModel; +import net.minecraftforge.client.model.ModelLoaderRegistry; +import net.minecraftforge.client.model.ModelProcessingHelper; +import net.minecraftforge.common.property.IExtendedBlockState; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +public class ModelWoodPile extends BlankItemModel{ + + private final Function textureGetter = new DefaultTextureGetter(); + @SideOnly(Side.CLIENT) + private IModel modelWoodPileItem; + private IModel modelWoodPileBlock; + private static final Map blockCache = new HashMap<>(); + private static final Map itemCache = new HashMap<>(); + + @Override + public List getQuads(IBlockState state, EnumFacing side, long rand) { + if(state instanceof IExtendedBlockState){ + IExtendedBlockState stateExtended = (IExtendedBlockState) state; + + IBlockAccess world = stateExtended.getValue(UnlistedBlockAccess.BLOCKACCESS); + BlockPos pos = stateExtended.getValue(UnlistedBlockPos.POS); + + TilePile pile = TileUtil.getTile(world, pos, TilePile.class); + + if(pile == null){ + return Collections.emptyList(); + } + ITree tree = pile.getTree(); + if (tree == null) { + tree = TreeManager.treeRoot.templateAsIndividual(TreeManager.treeRoot.getDefaultTemplate()); + } + + if (modelWoodPileBlock == null) { + try { + modelWoodPileBlock = ModelLoaderRegistry.getModel(new ResourceLocation("forestry:block/woodPile")); + } catch (Exception e) { + return Collections.emptyList(); + } + if (modelWoodPileBlock == null) { + return Collections.emptyList(); + } + } + + IBakedModel model = bakeModel(tree, false); + return model.getQuads(state, side, rand); + } + return Collections.emptyList(); + } + + @Override + public boolean isAmbientOcclusion() { + return false; + } + + @Override + public boolean isGui3d() { + return true; + } + + @Override + public TextureAtlasSprite getParticleTexture() { + return null; + } + + @Override + protected ItemOverrideList createOverrides() { + return new PileItemOverrideList(); + } + + private IBakedModel bakeModel(ITree tree, boolean isItem) { + ImmutableMap.Builder textures = ImmutableMap.builder(); + IAlleleTreeSpecies treeSpecies = tree.getGenome().getPrimary(); + String treeUID = treeSpecies.getUID(); + Map map = isItem ? itemCache : blockCache; + if(!map.containsKey(treeUID)){ + textures.put("woodBark", treeSpecies.getWoodProvider().getSprite(false).getIconName()); + textures.put("woodTop", treeSpecies.getWoodProvider().getSprite(true).getIconName()); + IModel retextureWoodPile = ModelProcessingHelper.retexture(isItem ? modelWoodPileItem : modelWoodPileBlock, textures.build()); + map.put(treeUID, retextureWoodPile.bake(ModelRotation.X0_Y0, isItem ? DefaultVertexFormats.ITEM : DefaultVertexFormats.BLOCK, textureGetter)); + } + return map.get(treeUID); + } + + private class PileItemOverrideList extends ItemOverrideList { + public PileItemOverrideList() { + super(Collections.emptyList()); + } + + @Override + public IBakedModel handleItemState(IBakedModel originalModel, ItemStack stack, World world, EntityLivingBase entity) { + if (modelWoodPileItem == null) { + try { + modelWoodPileItem = ModelLoaderRegistry.getModel(new ResourceLocation("forestry:item/woodPile")); + } catch (Exception e) { + return null; + } + if (modelWoodPileItem == null) { + return null; + } + } + ITree tree = null; + if(stack.hasTagCompound()){ + tree = new Tree(stack.getTagCompound().getCompoundTag("ContainedTree")); + } + if (tree == null) { + tree = TreeManager.treeRoot.templateAsIndividual(TreeManager.treeRoot.getDefaultTemplate()); + } + return bakeModel(tree, true); + } + } + +} diff --git a/src/main/java/forestry/arboriculture/multiblock/CharcoalPileController.java b/src/main/java/forestry/arboriculture/multiblock/CharcoalPileController.java new file mode 100644 index 000000000..90c826269 --- /dev/null +++ b/src/main/java/forestry/arboriculture/multiblock/CharcoalPileController.java @@ -0,0 +1,431 @@ +package forestry.arboriculture.multiblock; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import forestry.api.arboriculture.EnumPileType; +import forestry.api.core.EnumHumidity; +import forestry.api.core.EnumTemperature; +import forestry.api.multiblock.ICharcoalPileComponent; +import forestry.api.multiblock.IMultiblockComponent; +import forestry.apiculture.network.packets.PacketActiveUpdate; +import forestry.arboriculture.PluginArboriculture; +import forestry.arboriculture.blocks.BlockPile; +import forestry.core.access.EnumAccess; +import forestry.core.multiblock.IMultiblockControllerInternal; +import forestry.core.multiblock.MultiblockRegistry; +import forestry.core.multiblock.MultiblockValidationException; +import forestry.core.multiblock.RectangularMultiblockControllerBase; +import forestry.core.network.DataInputStreamForestry; +import forestry.core.network.DataOutputStreamForestry; +import forestry.core.proxy.Proxies; +import forestry.core.utils.Log; +import forestry.core.utils.Translator; +import net.minecraft.block.state.IBlockState; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; + +public class CharcoalPileController extends RectangularMultiblockControllerBase implements ICharcoalPileControllerInternal { + + private int burnTime; + private int woodBurnTime; + private boolean active; + + public CharcoalPileController(World world) { + super(world, CharcoalPileMultiblockSizeLimits.instance); + active = false; + burnTime = 0; + } + + @Override + public void setActive(boolean active) { + if (this.active == active) { + return; + } + + this.active = active; + + if (worldObj != null) { + if (worldObj.isRemote) { + worldObj.markBlockRangeForRenderUpdate(getMinimumCoord(), getMaximumCoord()); + } else { + Proxies.net.sendNetworkPacket(new PacketActiveUpdate(this), worldObj); + } + } + } + + @Override + public boolean isActive() { + return active; + } + + public int getBurnTime() { + return burnTime; + } + + @Override + public void onAttachedPartWithMultiblockData(IMultiblockComponent part, NBTTagCompound data) { + readFromNBT(data); + } + + @Override + protected void onBlockAdded(IMultiblockComponent newComponent) { + } + + @Override + protected void onBlockRemoved(IMultiblockComponent oldComponent) { + } + + @Override + protected void onMachineRestored() { + } + + @Override + protected void onMachinePaused() { + } + + @Override + protected void onMachineAssembled() { + } + + @Override + protected void onMachineDisassembled() { + setActive(false); + burnTime = 0; + } + + @Override + protected void onAssimilate(IMultiblockControllerInternal assimilated) { + if (!(assimilated instanceof CharcoalPileController)) { + Log.warning("[%s] Charcoal Kiln @ %s is attempting to assimilate a non-Charcoal Kiln machine! That machine's data will be lost!", + worldObj.isRemote ? "CLIENT" : "SERVER", getReferenceCoord()); + return; + } + } + + @Override + protected boolean updateServer(int tickCount) { + if (!isActive()) { + return false; + } + if(woodBurnTime == 0){ + int comps = 0; + int newBurnTime = 0; + for(IMultiblockComponent part : connectedParts){ + ICharcoalPileComponent comp = (ICharcoalPileComponent) part; + if(comp.getTree() != null){ + comps++; + newBurnTime+= comp.getTree().getGenome().getCombustibility() * 1000; + } + } + woodBurnTime = newBurnTime / comps; + } + if (burnTime >= woodBurnTime) { + for(IMultiblockComponent part : connectedParts) { + BlockPos pos = part.getCoordinates(); + IBlockState state = worldObj.getBlockState(pos); + IBlockState ashPileState = PluginArboriculture.blocks.piles.get(EnumPileType.ASH).getDefaultState().withProperty(BlockPile.PILE_POSITION, state.getValue(BlockPile.PILE_POSITION)); + + worldObj.setBlockState(pos, ashPileState); + } + MultiblockRegistry.addDirtyController(worldObj, this); + } else { + burnTime++; + } + return true; + } + + @Override + public String getUnlocalizedType() { + return "for.multiblock.greenhouse.type"; + } + + @Override + public BlockPos getCoordinates() { + BlockPos coord = getReferenceCoord(); + return new BlockPos(coord); + } + + @Override + protected void updateClient(int tickCount) { + } + + @Override + protected void isMachineWhole() throws MultiblockValidationException { + if (connectedParts.size() < getSizeLimits().getMinimumNumberOfBlocksForAssembledMachine()) { + throw new MultiblockValidationException(Translator.translateToLocal("multiblock.error.small")); + } + BlockPos maximumCoord = getMaximumCoord(); + BlockPos minimumCoord = getMinimumCoord(); + + int deltaX = maximumCoord.getX() - minimumCoord.getX() + 1; + int deltaY = maximumCoord.getY() - minimumCoord.getY() + 1; + int deltaZ = maximumCoord.getZ() - minimumCoord.getZ() + 1; + int maxX = getSizeLimits().getMaximumXSize(); + int maxY = getSizeLimits().getMaximumYSize(); + int maxZ = getSizeLimits().getMaximumZSize(); + int minX = getSizeLimits().getMinimumXSize(); + int minY = getSizeLimits().getMinimumYSize(); + int minZ = getSizeLimits().getMinimumZSize(); + if (maxX > 0 && deltaX > maxX) { + throw new MultiblockValidationException(Translator.translateToLocalFormatted("multiblock.error.large.x", maxX)); + } + if (maxY > 0 && deltaY > maxY) { + throw new MultiblockValidationException(Translator.translateToLocalFormatted("multiblock.error.large.y", maxY)); + } + if (maxZ > 0 && deltaZ > maxZ) { + throw new MultiblockValidationException(Translator.translateToLocalFormatted("multiblock.error.large.z", maxZ)); + } + if (deltaX < minX) { + throw new MultiblockValidationException(Translator.translateToLocalFormatted("multiblock.error.small.x", minX)); + } + if (deltaY < minY) { + throw new MultiblockValidationException(Translator.translateToLocalFormatted("multiblock.error.small.y", minY)); + } + if (deltaZ < minZ) { + throw new MultiblockValidationException(Translator.translateToLocalFormatted("multiblock.error.small.z", minZ)); + } + + TileEntity te; + IMultiblockComponent part; + Class myClass = this.getClass(); + List components = new ArrayList<>(); + for (int y = minimumCoord.getY(); y <= maximumCoord.getY(); y++) { + int partsOnLayer = 0; + int layer = y - getMinimumCoord().getY(); + + BlockPos currentMaximumCoord = maximumCoord.add(-layer, 0, -layer); + BlockPos currentMinimumCoord = minimumCoord.add(layer, 0, layer); + + for (int z = currentMinimumCoord.getZ(); z <= currentMaximumCoord.getZ(); z++) { + for (int x = currentMinimumCoord.getX(); x <= currentMaximumCoord.getX(); x++) { + // Okay, figure out what sort of block this should be. + BlockPos pos = new BlockPos(x, y, z); + te = this.worldObj.getTileEntity(pos); + if (te instanceof IMultiblockComponent) { + part = (IMultiblockComponent) te; + + // Ensure this part should actually be allowed within a cube of this controller's type + if (!myClass.equals(part.getMultiblockLogic().getController().getClass())) { + throw new MultiblockValidationException(Translator.translateToLocalFormatted("for.multiblock.error.invalid.part", Translator.translateToLocal(getUnlocalizedType()))); + } + } else { + // This is permitted so that we can incorporate certain non-multiblock parts inside interiors + part = null; + } + + // Validate block type against both part-level and material-level validators. + int extremes = 0; + + if (x == currentMinimumCoord.getX()) { + extremes++; + } + if (z == currentMinimumCoord.getZ()) { + extremes++; + } + + if (x == currentMaximumCoord.getX()) { + extremes++; + } + if (y == currentMaximumCoord.getY()) { + extremes++; + } + if (z == currentMaximumCoord.getZ()) { + extremes++; + } + + if (extremes >= 1) { + // Side + int exteriorLevel = y - currentMinimumCoord.getY(); + if (part != null) { + isGoodForExteriorLevel(part, exteriorLevel); + } else { + isBlockGoodForExteriorLevel(exteriorLevel, this.worldObj, pos); + } + } else { + if (part != null) { + isGoodForInterior(part); + } else { + isBlockGoodForInterior(this.worldObj, pos); + } + } + components.add(pos); + partsOnLayer++; + } + } + + if (partsOnLayer < 4) { + throw new MultiblockValidationException(Translator.translateToLocal("for.multiblock.error.small")); + } + } + for(IMultiblockComponent comp : connectedParts){ + if(!components.contains(comp.getCoordinates())){ + throw new MultiblockValidationException(Translator.translateToLocal("for.multiblock.error.large" + comp.getCoordinates())); + } + } + } + + /* + public void testPileLayer(World world, int minX, int minY, int minZ, int maxX, int maxY, int maxZ) throws MultiblockValidationException { + int partsOnLayer = 0; + for(IMultiblockComponent component : connectedParts) { + BlockPos componentPos = component.getCoordinates(); + if (componentPos.getY() == minY) { + if (componentPos.getX() < minX || componentPos.getX() > maxX || componentPos.getZ() < minZ || componentPos.getZ() > maxZ) { + throw new MultiblockValidationException(Translator.translateToLocal("for.multiblock.error.large" + componentPos)); + } + int extremes = 0; + + int x = componentPos.getX(); + int y = componentPos.getY(); + int z = componentPos.getZ(); + if (x == minX) { + extremes++; + } + if (y == getMinimumCoord().getY()) { + extremes++; + } + if (z == minZ) { + extremes++; + } + + if (x == maxX) { + extremes++; + } + if (y == getMaximumCoord().getY()) { + extremes++; + } + if (z == maxZ) { + extremes++; + } + + if (extremes >= 1) { + // Side + int exteriorLevel = y - getMinimumCoord().getY(); + if (component != null) { + isGoodForExteriorLevel(component, exteriorLevel); + } + } else { + if (component != null) { + isGoodForInterior(component); + } + } + partsOnLayer++; + } + } + if (partsOnLayer < 4) { + throw new MultiblockValidationException(Translator.translateToLocal("for.multiblock.error.small.top")); + } + for(int posX = minX; posX <= maxX; posX++) { + for(int posZ = minZ; posZ <= maxZ; posZ++) { + BlockPos pos = new BlockPos(posX, minY, posZ); + Block block = world.getBlockState(pos).getBlock(); + if (!(block instanceof BlockPile)) { + throw new MultiblockValidationException(Translator.translateToLocal("for.multiblock.error.small" + pos)); + } + } + } + if (minY != getMaximumCoord().getY()) { + testPileLayer(worldObj, minX + 1, minY + 1, minZ + 1, maxX - 1, maxZ - 1); + } + }*/ + + @Override + public void writeToNBT(NBTTagCompound data) { + super.writeToNBT(data); + data.setInteger("BurnTime", burnTime); + data.setBoolean("IsActive", active); + } + + @Override + public void readFromNBT(NBTTagCompound data) { + super.readFromNBT(data); + burnTime = data.getInteger("BurnTime"); + active = data.getBoolean("IsActive"); + } + + @Override + public void formatDescriptionPacket(NBTTagCompound data) { + writeToNBT(data); + } + + @Override + public void decodeDescriptionPacket(NBTTagCompound data) { + readFromNBT(data); + } + + @Override + public void writeGuiData(DataOutputStreamForestry data) throws IOException { + data.writeInt(burnTime); + data.writeBoolean(active); + } + + @Override + public void readGuiData(DataInputStreamForestry data) throws IOException { + burnTime = data.readInt(); + active = data.readBoolean(); + } + + @Override + public void onSwitchAccess(EnumAccess oldAccess, EnumAccess newAccess) { + } + + @Override + public EnumTemperature getTemperature() { + return null; + } + + @Override + public EnumHumidity getHumidity() { + return null; + } + + @Override + public float getExactTemperature() { + return 0; + } + + @Override + public float getExactHumidity() { + return 0; + } + + @Override + protected void isGoodForExteriorLevel(IMultiblockComponent part, int level) throws MultiblockValidationException { + if(!(part instanceof ICharcoalPileComponent)){ + throw new MultiblockValidationException("for.multiblock.charcoal.pile.error.invalid.exterior"); + } + ICharcoalPileComponent component = (ICharcoalPileComponent) part; + if(component.getPileType() != EnumPileType.DIRT){ + throw new MultiblockValidationException("for.multiblock.charcoal.pile.error.invalid.exterior"); + } + } + + @Override + protected void isGoodForInterior(IMultiblockComponent part) throws MultiblockValidationException { + if(!(part instanceof ICharcoalPileComponent)){ + throw new MultiblockValidationException("for.multiblock.charcoal.pile.error.invalid.interior"); + } + ICharcoalPileComponent component = (ICharcoalPileComponent) part; + if(component.getPileType() != EnumPileType.WOOD){ + throw new MultiblockValidationException("for.multiblock.charcoal.pile.error.invalid.interior"); + } + } + + @Override + public void onAssimilated(IMultiblockControllerInternal assimilator) { + } + + @Override + public BlockPos getMinimumCoord() { + return super.getMinimumCoord(); + } + + @Override + public BlockPos getMaximumCoord() { + return super.getMaximumCoord(); + } +} diff --git a/src/main/java/forestry/arboriculture/multiblock/CharcoalPileMultiblockSizeLimits.java b/src/main/java/forestry/arboriculture/multiblock/CharcoalPileMultiblockSizeLimits.java new file mode 100644 index 000000000..70e41dac3 --- /dev/null +++ b/src/main/java/forestry/arboriculture/multiblock/CharcoalPileMultiblockSizeLimits.java @@ -0,0 +1,57 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.arboriculture.multiblock; + +import forestry.core.multiblock.IMultiblockSizeLimits; + +class CharcoalPileMultiblockSizeLimits implements IMultiblockSizeLimits { + + public static final CharcoalPileMultiblockSizeLimits instance = new CharcoalPileMultiblockSizeLimits(); + + private CharcoalPileMultiblockSizeLimits() { + + } + + @Override + public int getMinimumNumberOfBlocksForAssembledMachine() { + return 20; + } + + @Override + public int getMaximumXSize() { + return 9; + } + + @Override + public int getMaximumYSize() { + return 6; + } + + @Override + public int getMaximumZSize() { + return 9; + } + + @Override + public int getMinimumXSize() { + return 4; + } + + @Override + public int getMinimumYSize() { + return 2; + } + + @Override + public int getMinimumZSize() { + return 4; + } +} diff --git a/src/main/java/forestry/arboriculture/multiblock/EnumPilePosition.java b/src/main/java/forestry/arboriculture/multiblock/EnumPilePosition.java new file mode 100644 index 000000000..830642e94 --- /dev/null +++ b/src/main/java/forestry/arboriculture/multiblock/EnumPilePosition.java @@ -0,0 +1,22 @@ +package forestry.arboriculture.multiblock; + +import java.util.Locale; + +import net.minecraft.util.IStringSerializable; + +public enum EnumPilePosition implements IStringSerializable{ + INTERIOR, + FRONT, + BACK, + SIDE_RIGHT, + SIDE_LEFT, + CORNER_FRONT_LEFT, + CORNER_FRONT_RIGHT, + CORNER_BACK_LEFT, + CORNER_BACK_RIGHT; + + @Override + public String getName() { + return name().toLowerCase(Locale.ENGLISH); + } +} diff --git a/src/main/java/forestry/arboriculture/multiblock/FakeCharcoalPileController.java b/src/main/java/forestry/arboriculture/multiblock/FakeCharcoalPileController.java new file mode 100644 index 000000000..dee4c3eba --- /dev/null +++ b/src/main/java/forestry/arboriculture/multiblock/FakeCharcoalPileController.java @@ -0,0 +1,42 @@ +package forestry.arboriculture.multiblock; + +import forestry.core.multiblock.FakeMultiblockController; +import net.minecraft.util.math.BlockPos; + +public class FakeCharcoalPileController extends FakeMultiblockController implements ICharcoalPileControllerInternal { + + public static final FakeCharcoalPileController instance = new FakeCharcoalPileController(); + + private FakeCharcoalPileController() { + } + + @Override + public String getUnlocalizedType() { + return "for.multiblock.charcoalpile.type"; + } + + @Override + public boolean isActive() { + return false; + } + + @Override + public void setActive(boolean active) { + } + + @Override + public BlockPos getMinimumCoord() { + return null; + } + + @Override + public BlockPos getMaximumCoord() { + return null; + } + + @Override + public BlockPos getCoordinates() { + return null; + } + +} diff --git a/src/main/java/forestry/arboriculture/multiblock/ICharcoalPileControllerInternal.java b/src/main/java/forestry/arboriculture/multiblock/ICharcoalPileControllerInternal.java new file mode 100644 index 000000000..1987d4a63 --- /dev/null +++ b/src/main/java/forestry/arboriculture/multiblock/ICharcoalPileControllerInternal.java @@ -0,0 +1,14 @@ +package forestry.arboriculture.multiblock; + +import forestry.api.multiblock.ICharcoalPileController; +import forestry.core.multiblock.IMultiblockControllerInternal; +import forestry.core.tiles.IActivatable; +import net.minecraft.util.math.BlockPos; + +public interface ICharcoalPileControllerInternal extends IMultiblockControllerInternal, ICharcoalPileController, IActivatable { + + BlockPos getMinimumCoord(); + + BlockPos getMaximumCoord(); + +} diff --git a/src/main/java/forestry/arboriculture/multiblock/MultiblockLogicCharcoalPile.java b/src/main/java/forestry/arboriculture/multiblock/MultiblockLogicCharcoalPile.java new file mode 100644 index 000000000..a0a4bc865 --- /dev/null +++ b/src/main/java/forestry/arboriculture/multiblock/MultiblockLogicCharcoalPile.java @@ -0,0 +1,37 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.arboriculture.multiblock; + +import net.minecraft.world.World; +import forestry.api.multiblock.IMultiblockLogicCharcoalPile; +import forestry.core.multiblock.MultiblockLogic; + +public class MultiblockLogicCharcoalPile extends MultiblockLogic implements IMultiblockLogicCharcoalPile { + + public MultiblockLogicCharcoalPile() { + super(ICharcoalPileControllerInternal.class); + } + + @Override + public ICharcoalPileControllerInternal getController() { + if (super.isConnected()) { + return controller; + } else { + return FakeCharcoalPileController.instance; + } + } + + @Override + public ICharcoalPileControllerInternal createNewController(World world) { + return new CharcoalPileController(world); + } + +} diff --git a/src/main/java/forestry/arboriculture/proxy/ProxyArboricultureClient.java b/src/main/java/forestry/arboriculture/proxy/ProxyArboricultureClient.java index f31bbba4e..1e1222e72 100644 --- a/src/main/java/forestry/arboriculture/proxy/ProxyArboricultureClient.java +++ b/src/main/java/forestry/arboriculture/proxy/ProxyArboricultureClient.java @@ -12,11 +12,15 @@ package forestry.arboriculture.proxy; import net.minecraft.client.renderer.block.model.ModelResourceLocation; import net.minecraft.world.ColorizerFoliage; - +import net.minecraftforge.fml.client.registry.ClientRegistry; +import forestry.api.arboriculture.EnumPileType; import forestry.arboriculture.PluginArboriculture; import forestry.arboriculture.blocks.BlockDecorativeLeaves; import forestry.arboriculture.models.ModelDecorativeLeaves; import forestry.arboriculture.models.ModelLeaves; +import forestry.arboriculture.models.ModelWoodPile; +import forestry.arboriculture.render.CharcoalPileRenderer; +import forestry.arboriculture.tiles.TilePile; import forestry.core.models.BlockModelIndex; import forestry.core.proxy.Proxies; @@ -38,6 +42,14 @@ public class ProxyArboricultureClient extends ProxyArboriculture { BlockModelIndex blockModelIndex = new BlockModelIndex(blockModelLocation, itemModeLocation, new ModelDecorativeLeaves(), leaves); Proxies.render.registerBlockModel(blockModelIndex); } + + { + ModelResourceLocation blockModelLocation = new ModelResourceLocation("forestry:pile", "type=wood"); + ModelResourceLocation itemModelLocation = new ModelResourceLocation("forestry:woodPile", "inventory"); + BlockModelIndex blockModelIndex = new BlockModelIndex(blockModelLocation, itemModelLocation, new ModelWoodPile(), PluginArboriculture.blocks.piles.get(EnumPileType.WOOD)); + Proxies.render.registerBlockModel(blockModelIndex); + } + ClientRegistry.bindTileEntitySpecialRenderer(TilePile.class, new CharcoalPileRenderer()); } @Override diff --git a/src/main/java/forestry/arboriculture/render/CharcoalPileRenderer.java b/src/main/java/forestry/arboriculture/render/CharcoalPileRenderer.java new file mode 100644 index 000000000..f7faa112d --- /dev/null +++ b/src/main/java/forestry/arboriculture/render/CharcoalPileRenderer.java @@ -0,0 +1,292 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.arboriculture.render; + +import static forestry.arboriculture.multiblock.EnumPilePosition.BACK; +import static forestry.arboriculture.multiblock.EnumPilePosition.CORNER_BACK_LEFT; +import static forestry.arboriculture.multiblock.EnumPilePosition.CORNER_BACK_RIGHT; +import static forestry.arboriculture.multiblock.EnumPilePosition.FRONT; +import static forestry.arboriculture.multiblock.EnumPilePosition.CORNER_FRONT_LEFT; +import static forestry.arboriculture.multiblock.EnumPilePosition.CORNER_FRONT_RIGHT; +import static forestry.arboriculture.multiblock.EnumPilePosition.SIDE_LEFT; +import static forestry.arboriculture.multiblock.EnumPilePosition.SIDE_RIGHT; + +import forestry.api.arboriculture.EnumPileType; +import forestry.api.arboriculture.IAlleleTreeSpecies; +import forestry.api.arboriculture.ITree; +import forestry.api.arboriculture.TreeManager; +import forestry.arboriculture.blocks.BlockPile; +import forestry.arboriculture.multiblock.EnumPilePosition; +import forestry.arboriculture.multiblock.ICharcoalPileControllerInternal; +import forestry.arboriculture.tiles.TilePile; +import forestry.core.multiblock.MultiblockLogic; +import forestry.core.proxy.Proxies; +import forestry.core.render.TextureManager; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.renderer.GlStateManager; +import net.minecraft.client.renderer.Tessellator; +import net.minecraft.client.renderer.VertexBuffer; +import net.minecraft.client.renderer.texture.TextureAtlasSprite; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.client.renderer.vertex.DefaultVertexFormats; +import net.minecraft.util.ResourceLocation; + +public class CharcoalPileRenderer extends TileEntitySpecialRenderer { + + public CharcoalPileRenderer() { + } + + @Override + public void renderTileEntityAt(TilePile pile, double x, double y, double z, float p_147500_8_, int destroyStage) { + IBlockState state = pile.getWorld().getBlockState(pile.getPos()); + EnumPilePosition pilePosition = state.getValue(BlockPile.PILE_POSITION); + MultiblockLogic logic = pile.getMultiblockLogic(); + if (pilePosition != EnumPilePosition.INTERIOR && logic.isConnected() && logic.getController() != null) { + GlStateManager.pushMatrix(); + GlStateManager.translate(x + 0.5F, y + 0.5F, z + 0.5F); + GlStateManager.pushMatrix(); + GlStateManager.disableLighting(); + Proxies.common.getClientInstance().renderEngine.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE); + + boolean withWood = pile.getPileType() != EnumPileType.ASH; + boolean isOnTop = logic.getController().getMaximumCoord().getY() == pile.getPos().getY(); + // TODO Add brightness to the textures. + int brightness = state.getPackedLightmapCoords(pile.getWorld(), pile.getPos()); + ITree tree = pile.getNextWoodPile(); + if (tree == null) { + tree = TreeManager.treeRoot.templateAsIndividual(TreeManager.treeRoot.getDefaultTemplate()); + } + IAlleleTreeSpecies treeSpecies = tree.getGenome().getPrimary(); + TextureAtlasSprite dirtSprite; + if(pile.getPileType() == EnumPileType.ASH){ + dirtSprite = TextureManager.registerSprite(new ResourceLocation("forestry:blocks/ash")); + }else{ + dirtSprite = TextureManager.registerSprite(new ResourceLocation("forestry:blocks/loam")); + } + TextureAtlasSprite woodSprite = treeSpecies.getWoodProvider().getSprite(false); + TextureAtlasSprite woodTopSprite = treeSpecies.getWoodProvider().getSprite(true); + if (pilePosition == BACK) { + renderPileSide(withWood, dirtSprite, woodSprite, woodTopSprite, brightness); + } else if (pilePosition == FRONT) { + GlStateManager.rotate(180, 0F, 0F, 1F); + GlStateManager.rotate(180.0F, 1.0F, 0.0F, 0.0F); + + renderPileSide(withWood, dirtSprite, woodSprite, woodTopSprite, brightness); + } else if (pilePosition == SIDE_LEFT) { + GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F); + + renderPileSide(withWood, dirtSprite, woodSprite, woodTopSprite, brightness); + } else if (pilePosition == SIDE_RIGHT) { + GlStateManager.rotate(180, 0F, 1F, 0F); + GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F); + + renderPileSide(withWood, dirtSprite, woodSprite, woodTopSprite, brightness); + } else if (pilePosition == CORNER_BACK_RIGHT) { + GlStateManager.rotate(180, 0F, 1F, 0F); + GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F); + + renderPileCorner(withWood, dirtSprite, woodSprite, woodTopSprite, brightness, isOnTop); + } else if (pilePosition == CORNER_BACK_LEFT) { + GlStateManager.rotate(90, 0F, 1F, 0F); + GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F); + + renderPileCorner(withWood, dirtSprite, woodSprite, woodTopSprite, brightness, isOnTop); + } else if (pilePosition == CORNER_FRONT_LEFT) { + GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F); + + renderPileCorner(withWood, dirtSprite, woodSprite, woodTopSprite, brightness, isOnTop); + } else if (pilePosition == CORNER_FRONT_RIGHT) { + GlStateManager.rotate(270, 0F, 1F, 0F); + GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F); + + renderPileCorner(withWood, dirtSprite, woodSprite, woodTopSprite, brightness, isOnTop); + } + GlStateManager.enableLighting(); + GlStateManager.popMatrix(); + GlStateManager.popMatrix(); + } + } + + public static void renderPileSide(boolean withWood, TextureAtlasSprite dirtSprite, TextureAtlasSprite woodSprite, TextureAtlasSprite woodTopSprite, int brightness) { + Tessellator t = Tessellator.getInstance(); + VertexBuffer buffer = t.getBuffer(); + buffer.begin(7, DefaultVertexFormats.POSITION_TEX); + + buffer.pos(-0.5, -0.5, -0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, -0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, -0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + + buffer.pos(0.5, -0.5, -0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, -0.5, -0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(-0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + + buffer.pos(-0.5, -0.5, -0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(-0.5, -0.5, -0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(-0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + + buffer.pos(0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, -0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(0.5, -0.5, -0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + + if(withWood){ + buffer.pos(0.1, 0.3, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(0.1, -0.5, -0.5).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.1, -0.5, -0.7).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.1, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(0.1, 0.5, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(0.1, -0.5, -0.7).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.1, -0.5, -0.7).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.1, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(-0.1, 0.5, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(-0.1, -0.5, -0.7).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.1, -0.5, -0.5).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.1, 0.3, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(-0.1, -0.5, -0.7).tex(woodTopSprite.getMinU(), woodTopSprite.getMinV()).endVertex(); + buffer.pos(0.1, -0.5, -0.7).tex(woodTopSprite.getMaxU(), woodTopSprite.getMinV()).endVertex(); + buffer.pos(0.1, -0.5, -0.5).tex(woodTopSprite.getMaxU(), woodTopSprite.getMaxV()).endVertex(); + buffer.pos(-0.1, -0.5, -0.5).tex(woodTopSprite.getMinU(), woodTopSprite.getMaxV()).endVertex(); + + buffer.pos(-0.5, 0.3, 0.5).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.5, 0.3, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.3, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(0.5, 0.3, 0.5).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(-0.5, 0.5, 0.5).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.5, 0.5).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.5, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(0.5, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.3, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.5, 0.3, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + } + t.draw(); + } + + public static void renderPileCorner(boolean withWood, TextureAtlasSprite dirtSprite, TextureAtlasSprite woodSprite, TextureAtlasSprite woodTopSprite, int brightness, boolean isTop) { + Tessellator t = Tessellator.getInstance(); + VertexBuffer buffer = t.getBuffer(); + buffer.begin(7, DefaultVertexFormats.POSITION_TEX); + + buffer.pos(-0.5, -0.5, -0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, -0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, -0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + + buffer.pos(0.5, -0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(0.5, -0.5, -0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, -0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, -0.5, -0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + + buffer.pos(-0.5, -0.5, -0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(-0.5, -0.5, -0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(-0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + + buffer.pos(-0.5, 0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(-0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, 0.5).tex(dirtSprite.getMinU(), dirtSprite.getMaxV()).endVertex(); + buffer.pos(0.5, -0.5, 0.5).tex(dirtSprite.getMaxU(), dirtSprite.getMaxV()).endVertex(); + + if (isTop && withWood) { + + buffer.pos(-0.3, 0.3, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(-0.3, -0.5, -0.5).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.3, -0.5, -0.7).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.3, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(-0.3, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.3, -0.5, -0.7).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, -0.5, -0.7).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, 0.5, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + + buffer.pos(-0.5, 0.5, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, -0.5, -0.7).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.5, -0.5, -0.5).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(-0.5, 0.3, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(-0.5, -0.5, -0.7).tex(woodTopSprite.getMinU(), woodTopSprite.getMinV()).endVertex(); + buffer.pos(-0.3, -0.5, -0.7).tex(woodTopSprite.getMaxU(), woodTopSprite.getMinV()).endVertex(); + buffer.pos(-0.3, -0.5, -0.5).tex(woodTopSprite.getMaxU(), woodTopSprite.getMaxV()).endVertex(); + buffer.pos(-0.5, -0.5, -0.5).tex(woodTopSprite.getMinU(), woodTopSprite.getMaxV()).endVertex(); + } + t.draw(); + + GlStateManager.rotate(270.0F, 0.0F, 1.0F, 0.0F); + if(withWood){ + buffer.begin(7, DefaultVertexFormats.POSITION_TEX); + if (isTop) { + + buffer.pos(0.5, 0.3, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(0.5, -0.5, -0.5).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, -0.7).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + // Front + buffer.pos(0.5, 0.5, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(0.5, -0.5, -0.7).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.3, -0.5, -0.7).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.3, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(0.3, 0.5, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(0.3, -0.5, -0.7).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.3, -0.5, -0.5).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.3, 0.3, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(0.3, -0.5, -0.7).tex(woodTopSprite.getMinU(), woodTopSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, -0.7).tex(woodTopSprite.getMaxU(), woodTopSprite.getMinV()).endVertex(); + buffer.pos(0.5, -0.5, -0.5).tex(woodTopSprite.getMaxU(), woodTopSprite.getMaxV()).endVertex(); + buffer.pos(0.3, -0.5, -0.5).tex(woodTopSprite.getMinU(), woodTopSprite.getMaxV()).endVertex(); + } + + buffer.pos(0.3, 0.5, 0.5).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.5, 0.5).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.5, 0.3).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(0.3, 0.5, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(0.3, 0.3, 0.5).tex(woodSprite.getMaxU(), woodSprite.getMaxV()).endVertex(); + buffer.pos(0.3, 0.3, 0.3).tex(woodSprite.getMaxU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.3, 0.3).tex(woodSprite.getMinU(), woodSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.3, 0.5).tex(woodSprite.getMinU(), woodSprite.getMaxV()).endVertex(); + + buffer.pos(0.5, 0.5, 0.3).tex(woodTopSprite.getMinU(), woodTopSprite.getMinV()).endVertex(); + buffer.pos(0.5, 0.3, 0.3).tex(woodTopSprite.getMinU(), woodTopSprite.getMaxV()).endVertex(); + buffer.pos(0.3, 0.3, 0.3).tex(woodTopSprite.getMaxU(), woodTopSprite.getMaxV()).endVertex(); + buffer.pos(0.3, 0.5, 0.3).tex(woodTopSprite.getMaxU(), woodTopSprite.getMinV()).endVertex(); + + buffer.pos(0.3, 0.5, 0.3).tex(woodTopSprite.getMinU(), woodTopSprite.getMinV()).endVertex(); + buffer.pos(0.3, 0.3, 0.3).tex(woodTopSprite.getMinU(), woodTopSprite.getMaxV()).endVertex(); + buffer.pos(0.3, 0.3, 0.5).tex(woodTopSprite.getMaxU(), woodTopSprite.getMaxV()).endVertex(); + buffer.pos(0.3, 0.5, 0.5).tex(woodTopSprite.getMaxU(), woodTopSprite.getMinV()).endVertex(); + t.draw(); + } + + GlStateManager.rotate(90.0F, 0.0F, 1.0F, 0.0F); + } +} diff --git a/src/main/java/forestry/arboriculture/models/FruitPodStateMapper.java b/src/main/java/forestry/arboriculture/render/FruitPodStateMapper.java similarity index 97% rename from src/main/java/forestry/arboriculture/models/FruitPodStateMapper.java rename to src/main/java/forestry/arboriculture/render/FruitPodStateMapper.java index ea8064ab7..9abd8c9b4 100644 --- a/src/main/java/forestry/arboriculture/models/FruitPodStateMapper.java +++ b/src/main/java/forestry/arboriculture/render/FruitPodStateMapper.java @@ -1,4 +1,4 @@ -package forestry.arboriculture.models; +package forestry.arboriculture.render; import java.util.Map; diff --git a/src/main/java/forestry/arboriculture/render/PileStateMapper.java b/src/main/java/forestry/arboriculture/render/PileStateMapper.java new file mode 100644 index 000000000..b71777529 --- /dev/null +++ b/src/main/java/forestry/arboriculture/render/PileStateMapper.java @@ -0,0 +1,44 @@ +/******************************************************************************* + * Copyright (c) 2011-2014 SirSengir. + * All rights reserved. This program and the accompanying materials + * are made available under the terms of the GNU Lesser Public License v3 + * which accompanies this distribution, and is available at + * http://www.gnu.org/licenses/lgpl-3.0.txt + * + * Various Contributors including, but not limited to: + * SirSengir (original work), CovertJaguar, Player, Binnie, MysteriousAges + ******************************************************************************/ +package forestry.arboriculture.render; + +import java.util.Map; + +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.client.renderer.block.model.ModelResourceLocation; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; +import forestry.api.arboriculture.EnumPileType; +import forestry.arboriculture.PluginArboriculture; +import forestry.core.config.Constants; +import forestry.core.render.ForestryStateMapper; + +@SideOnly(Side.CLIENT) +public class PileStateMapper extends ForestryStateMapper { + + @Override + public Map putStateModelLocations(Block block) { + String location = Constants.RESOURCE_ID + ":pile"; + + IBlockState woodPileState = PluginArboriculture.blocks.piles.get(EnumPileType.WOOD).getDefaultState(); + mapStateModelLocations.put(woodPileState, new ModelResourceLocation(location, "type=wood")); + + IBlockState dirtPileState = PluginArboriculture.blocks.piles.get(EnumPileType.DIRT).getDefaultState(); + mapStateModelLocations.put(dirtPileState, new ModelResourceLocation(location, "type=dirt")); + + IBlockState ashPileState = PluginArboriculture.blocks.piles.get(EnumPileType.ASH).getDefaultState(); + mapStateModelLocations.put(ashPileState, new ModelResourceLocation(location, "type=ash")); + + return this.mapStateModelLocations; + } + +} diff --git a/src/main/java/forestry/arboriculture/models/SaplingStateMapper.java b/src/main/java/forestry/arboriculture/render/SaplingStateMapper.java similarity index 97% rename from src/main/java/forestry/arboriculture/models/SaplingStateMapper.java rename to src/main/java/forestry/arboriculture/render/SaplingStateMapper.java index dff420fe6..d542b1f04 100644 --- a/src/main/java/forestry/arboriculture/models/SaplingStateMapper.java +++ b/src/main/java/forestry/arboriculture/render/SaplingStateMapper.java @@ -1,4 +1,4 @@ -package forestry.arboriculture.models; +package forestry.arboriculture.render; import com.google.common.collect.Maps; diff --git a/src/main/java/forestry/arboriculture/tiles/TilePile.java b/src/main/java/forestry/arboriculture/tiles/TilePile.java new file mode 100644 index 000000000..69df46379 --- /dev/null +++ b/src/main/java/forestry/arboriculture/tiles/TilePile.java @@ -0,0 +1,284 @@ +package forestry.arboriculture.tiles; + +import javax.annotation.Nonnull; +import forestry.api.arboriculture.EnumPileType; +import forestry.api.arboriculture.ITree; +import forestry.api.arboriculture.TreeManager; +import forestry.api.genetics.IAllele; +import forestry.api.multiblock.ICharcoalPileComponent; +import forestry.api.multiblock.IMultiblockController; +import forestry.arboriculture.PluginArboriculture; +import forestry.arboriculture.blocks.BlockPile; +import forestry.arboriculture.genetics.Tree; +import forestry.arboriculture.multiblock.EnumPilePosition; +import forestry.arboriculture.multiblock.MultiblockLogicCharcoalPile; +import forestry.core.multiblock.MultiblockTileEntityForestry; +import forestry.core.tiles.TileUtil; +import net.minecraft.block.Block; +import net.minecraft.block.state.IBlockState; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.util.math.BlockPos; +import net.minecraft.world.World; +import net.minecraftforge.fml.relauncher.Side; +import net.minecraftforge.fml.relauncher.SideOnly; + +public class TilePile extends MultiblockTileEntityForestry implements ICharcoalPileComponent{ + + @Nonnull + private ITree containedTree; + @SideOnly(Side.CLIENT) + private BlockPos woodPos; + + public TilePile() { + super(new MultiblockLogicCharcoalPile()); + } + + @Override + public void onMachineAssembled(IMultiblockController multiblockController, BlockPos minCoord, BlockPos maxCoord) { + // Re-render this block on the client + if (worldObj.isRemote) { + this.worldObj.markBlockRangeForRenderUpdate(getPos(), getPos()); + } + worldObj.notifyBlockOfStateChange(getPos(), getBlockType()); + + if(getPileType() != EnumPileType.ASH){ + this.worldObj.setBlockState(getPos(), updateState(), 2); + } + } + + @Override + public boolean shouldRefresh(World world, BlockPos pos, IBlockState oldState, IBlockState newState) { + Block newBlock = newState.getBlock(); + return oldState.getBlock() != newState.getBlock() && newState.getBlock() != PluginArboriculture.blocks.piles.get(EnumPileType.ASH); + } + + @Override + public void onMachineBroken() { + // Re-render this block on the client + if (worldObj.isRemote) { + this.worldObj.markBlockRangeForRenderUpdate(getPos(), getPos()); + woodPos = null; + } + worldObj.notifyBlockOfStateChange(getPos(), getBlockType()); + markDirty(); + if(getPileType() != EnumPileType.ASH){ + this.worldObj.setBlockState(getPos(), updateState(), 2); + } + } + + private IBlockState updateState() { + TilePile pile = TileUtil.getTile(worldObj, pos, TilePile.class); + EnumPilePosition pileType = EnumPilePosition.INTERIOR; + if(pile != null && pile.getMultiblockLogic().isConnected() && pile.getMultiblockLogic().getController().isAssembled()){ + BlockPos maxCoord = pile.getMultiblockLogic().getController().getMaximumCoord(); + BlockPos minCoord = pile.getMultiblockLogic().getController().getMinimumCoord(); + int level = pos.getY() - minCoord.getY(); + + int levelMinX = minCoord.getX() + level; + int levelMinY = minCoord.getY() + level; + int levelMinZ = minCoord.getZ() + level; + int levelMaxX = maxCoord.getX() - level; + int levelMaxY = maxCoord.getY() - level; + int levelMaxZ = maxCoord.getZ() - level; + int facesMatching = 0; + if (levelMaxX == pos.getX() || levelMinX == pos.getX()) { + facesMatching++; + } + if (levelMaxZ == pos.getZ() || levelMinZ == pos.getZ()) { + facesMatching++; + } + + if ( facesMatching > 0 ) { + if (levelMaxX == pos.getX()) { + if (levelMaxZ == pos.getZ()) { + pileType = EnumPilePosition.CORNER_BACK_RIGHT; + } else if (levelMinZ == pos.getZ()) { + pileType = EnumPilePosition.CORNER_FRONT_RIGHT; + } else { + pileType = EnumPilePosition.SIDE_RIGHT; + } + } else if (levelMinX == pos.getX()) { + if (levelMaxZ == pos.getZ()) { + pileType = EnumPilePosition.CORNER_BACK_LEFT; + } else if (levelMinZ == pos.getZ()) { + pileType = EnumPilePosition.CORNER_FRONT_LEFT; + } else { + pileType = EnumPilePosition.SIDE_LEFT; + } + } else if (levelMaxZ == pos.getZ()) { + if (levelMaxX == pos.getX()) { + pileType = EnumPilePosition.CORNER_FRONT_RIGHT; + } else if (levelMinX == pos.getX()) { + pileType = EnumPilePosition.CORNER_FRONT_LEFT; + } else { + pileType = EnumPilePosition.FRONT; + } + } else if (levelMinZ == pos.getZ()) { + if (levelMaxX == pos.getX()) { + pileType = EnumPilePosition.CORNER_BACK_RIGHT; + } else if (levelMinX == pos.getX()) { + pileType = EnumPilePosition.CORNER_BACK_LEFT; + } else { + pileType = EnumPilePosition.BACK; + } + } + } + } + return getBlockType().getDefaultState().withProperty(BlockPile.PILE_POSITION, pileType); + } + + private static ITree getTree(String speciesUID) { + IAllele[] treeTemplate = TreeManager.treeRoot.getTemplate(speciesUID); + if (treeTemplate == null) { + return null; + } + return TreeManager.treeRoot.templateAsIndividual(treeTemplate); + } + + @Override + public void readFromNBT(NBTTagCompound data) { + super.readFromNBT(data); + + if (data.hasKey("ContainedTree")) { + setTree(new Tree(data.getCompoundTag("ContainedTree"))); + } + } + + @Override + public void writeToNBT(NBTTagCompound data) { + super.writeToNBT(data); + + if (containedTree != null) { + NBTTagCompound subcompound = new NBTTagCompound(); + containedTree.writeToNBT(subcompound); + data.setTag("ContainedTree", subcompound); + } + + } + + @Override + protected void encodeDescriptionPacket(NBTTagCompound packetData) { + super.encodeDescriptionPacket(packetData); + if (containedTree != null) { + NBTTagCompound subcompound = new NBTTagCompound(); + containedTree.writeToNBT(subcompound); + packetData.setTag("ContainedTree", subcompound); + } + } + + @Override + protected void decodeDescriptionPacket(NBTTagCompound packetData) { + super.decodeDescriptionPacket(packetData); + if (packetData.hasKey("ContainedTree")) { + setTree(new Tree(packetData.getCompoundTag("ContainedTree"))); + } + } + + /* CLIENT INFORMATION */ + + /* CONTAINED TREE */ + @Override + public void setTree(@Nonnull ITree tree) { + this.containedTree = tree; + if (worldObj != null && worldObj.isRemote) { + worldObj.markBlockRangeForRenderUpdate(getPos(), getPos()); + } + } + + @Override + @Nonnull + public ITree getTree() { + return this.containedTree; + } + + @Override + public EnumPileType getPileType() { + IBlockState state = worldObj.getBlockState(pos); + return ((BlockPile)state.getBlock()).getPileType(); + } + + @Override + @SideOnly(Side.CLIENT) + public ITree getNextWoodPile(){ + if(woodPos == null){ + woodPos = getNextWoodPilePos(); + } + TilePile pile = TileUtil.getTile(worldObj, woodPos, TilePile.class); + if(pile != null){ + return pile.getTree(); + } + return null; + } + + @SideOnly(Side.CLIENT) + private BlockPos getNextWoodPilePos(){ + EnumPilePosition pilePos = worldObj.getBlockState(pos).getValue(BlockPile.PILE_POSITION); + int layer = pos.getY() - getMultiblockLogic().getController().getMinimumCoord().getY(); + IBlockState state; + Block woodPile = PluginArboriculture.blocks.piles.get(EnumPileType.WOOD); + switch (pilePos) { + case BACK: + state = worldObj.getBlockState(pos.add(0, 0, 1)); + if(state.getBlock() != woodPile){ + return pos.add(0, -1, 0); + } + return pos.add(0, 0, 1); + case FRONT: + state = worldObj.getBlockState(pos.add(0, 0, -1)); + if(state.getBlock() != woodPile){ + return pos.add(0, -1, 0); + } + return pos.add(0, 0, -1); + case SIDE_LEFT: + state = worldObj.getBlockState(pos.add(1, 0, 0)); + if(state.getBlock() != woodPile){ + return pos.add(0, -1, 0); + } + return pos.add(1, 0, 0); + case SIDE_RIGHT: + state = worldObj.getBlockState(pos.add(-1, 0, 0)); + if(state.getBlock() != woodPile){ + return pos.add(0, -1, 0); + } + return pos.add(-1, 0, 0); + case CORNER_FRONT_LEFT: + state = worldObj.getBlockState(pos.add(1, 0, 1)); + if(state.getBlock() != woodPile){ + return pos.add(0, -1, 0); + } + return pos.add(1, 0, 1); + case CORNER_FRONT_RIGHT: + state = worldObj.getBlockState(pos.add(-1, 0, 1)); + if(state.getBlock() != woodPile){ + return pos.add(0, -1, 0); + } + return pos.add(-1, 0, 1); + case CORNER_BACK_LEFT: + state = worldObj.getBlockState(pos.add(1, 0, -1)); + if(state.getBlock() != woodPile){ + return pos.add(0, -1, 0); + } + return pos.add(1, 0, -1); + case CORNER_BACK_RIGHT: + state = worldObj.getBlockState(pos.add(-1, 0, -1)); + if(state.getBlock() != woodPile){ + return pos.add(0, -1, 0); + } + return pos.add(-1, 0, -1); + default: + return pos.add(0, -1, 0); + } + + } + + @Override + public Object getGui(EntityPlayer player, int data) { + return null; + } + + @Override + public Object getContainer(EntityPlayer player, int data) { + return null; + } +} diff --git a/src/main/java/forestry/core/genetics/alleles/AlleleHelper.java b/src/main/java/forestry/core/genetics/alleles/AlleleHelper.java index c8e643a48..b6285bfbb 100644 --- a/src/main/java/forestry/core/genetics/alleles/AlleleHelper.java +++ b/src/main/java/forestry/core/genetics/alleles/AlleleHelper.java @@ -91,11 +91,20 @@ public class AlleleHelper implements IAlleleHelper { IAlleleInteger alleleInteger = new AlleleInteger(modId, "i", i + "d", i, true); AlleleManager.alleleRegistry.registerAllele(alleleInteger, EnumTreeChromosome.GIRTH, + EnumTreeChromosome.CARBONIZATION, + EnumTreeChromosome.COMBUSTIBILITY, EnumButterflyChromosome.METABOLISM, EnumButterflyChromosome.FERTILITY ); integers.put(i, alleleInteger); } + for (int i = 11; i <= 25; i++) { + IAlleleInteger alleleInteger = new AlleleInteger(modId, "i", i + "d", i, true); + AlleleManager.alleleRegistry.registerAllele(alleleInteger, + EnumTreeChromosome.COMBUSTIBILITY + ); + integers.put(i, alleleInteger); + } alleleMaps.put(Integer.class, integers); Map booleans = new HashMap<>(); diff --git a/src/main/java/forestry/core/models/BlankItemModel.java b/src/main/java/forestry/core/models/BlankItemModel.java index d0c438248..122092438 100644 --- a/src/main/java/forestry/core/models/BlankItemModel.java +++ b/src/main/java/forestry/core/models/BlankItemModel.java @@ -33,7 +33,7 @@ public abstract class BlankItemModel implements IBakedModel { } protected ItemOverrideList createOverrides(){ - return new ItemOverrideList(Collections.emptyList()); + return ItemOverrideList.NONE; } @Override diff --git a/src/main/java/forestry/core/models/ModelCrate.java b/src/main/java/forestry/core/models/ModelCrate.java index 4395a6852..e5f7077e6 100644 --- a/src/main/java/forestry/core/models/ModelCrate.java +++ b/src/main/java/forestry/core/models/ModelCrate.java @@ -59,7 +59,7 @@ import gnu.trove.map.hash.TIntObjectHashMap; @SideOnly(Side.CLIENT) public class ModelCrate extends BlankItemModel { - private static final Map crates = Maps.newHashMap(); + private static final Map cache = Maps.newHashMap(); private static IModel crateModel; private static ModelBlock MODEL_GENERATED; @@ -76,7 +76,7 @@ public class ModelCrate extends BlankItemModel { } catch (Exception e) { Log.error("Failed to init the crate model.", e); } - ModelCrate.crates.clear(); + ModelCrate.cache.clear(); } /** @@ -211,16 +211,16 @@ public class ModelCrate extends BlankItemModel { public IBakedModel handleItemState(IBakedModel originalModel, ItemStack stack, World world, EntityLivingBase entity) { ItemCrated crated = (ItemCrated) stack.getItem(); String crateUID = ItemStackUtil.getItemNameFromRegistry(crated).getResourcePath(); - if (crates.get(crateUID) == null) { + if (cache.get(crateUID) == null) { IBakedModel baseBaked = getModel(new ItemStack(PluginStorage.items.crate, 1, 1)); //Set the crate color index to 100 for (BakedQuad quad : baseBaked.getQuads(null, null, 0)) { ObfuscationReflectionHelper.setPrivateValue(BakedQuad.class, quad, 100, 1); } - crates.put(crateUID, new IPerspectiveAwareModel.MapWrapper(new CrateBakedModel( bakeModel(crated, baseBaked)), ModelManager.getInstance().DEFAULT_ITEM)); + cache.put(crateUID, new IPerspectiveAwareModel.MapWrapper(new CrateBakedModel( bakeModel(crated, baseBaked)), ModelManager.getInstance().DEFAULT_ITEM)); } - return crates.get(crateUID); + return cache.get(crateUID); } } diff --git a/src/main/java/forestry/core/utils/ItemStackUtil.java b/src/main/java/forestry/core/utils/ItemStackUtil.java index 7026031c1..b470c3e30 100644 --- a/src/main/java/forestry/core/utils/ItemStackUtil.java +++ b/src/main/java/forestry/core/utils/ItemStackUtil.java @@ -416,7 +416,7 @@ public abstract class ItemStackUtil { } public static void dropItemStackAsEntity(ItemStack items, World world, double x, double y, double z, int delayForPickup) { - if (items.stackSize <= 0 || world.isRemote) { + if (items == null || items.stackSize <= 0 || world.isRemote) { return; } diff --git a/src/main/java/forestry/core/utils/OreDictUtil.java b/src/main/java/forestry/core/utils/OreDictUtil.java index 5d87060ef..71a90f47c 100644 --- a/src/main/java/forestry/core/utils/OreDictUtil.java +++ b/src/main/java/forestry/core/utils/OreDictUtil.java @@ -66,6 +66,7 @@ public class OreDictUtil { public static final String INGOT_GOLD = "ingotGold"; public static final String INGOT_IRON = "ingotIron"; public static final String STONE = "stone"; + public static final String DIRT = "dirt"; public static final String BLOCK_GLASS = "blockGlass"; public static final String GEM_QUARTZ = "gemQuartz"; public static final String CHEST_WOOD = "chestWood"; diff --git a/src/main/java/forestry/farming/PluginFarming.java b/src/main/java/forestry/farming/PluginFarming.java index 4399ad0c6..f9f85e09f 100644 --- a/src/main/java/forestry/farming/PluginFarming.java +++ b/src/main/java/forestry/farming/PluginFarming.java @@ -102,8 +102,8 @@ public class PluginFarming extends BlankForestryPlugin { Farmables.farmables.putAll("farmOrchard", Arrays.asList( new FarmableAgingCrop(new ItemStack(Items.WHEAT_SEEDS), Blocks.WHEAT, BlockCrops.AGE, 7), - new FarmableAgingCrop(new ItemStack(Items.POTATO), Blocks.POTATOES, BlockPotato.AGE, 7), - new FarmableAgingCrop(new ItemStack(Items.CARROT), Blocks.CARROTS, BlockCarrot.AGE, 7), + new FarmableAgingCrop(new ItemStack(Items.POTATO), Blocks.POTATOES, BlockCrops.AGE, 7), + new FarmableAgingCrop(new ItemStack(Items.CARROT), Blocks.CARROTS, BlockCrops.AGE, 7), new FarmableAgingCrop(new ItemStack(Items.BEETROOT_SEEDS), Blocks.BEETROOTS, BlockBeetroot.BEETROOT_AGE, 3) )); @@ -124,8 +124,8 @@ public class PluginFarming extends BlankForestryPlugin { Farmables.farmables.put("farmSucculentes", new FarmableStacked(new ItemStack(Blocks.CACTUS), Blocks.CACTUS, 3)); - Farmables.farmables.put("farmVegetables", new FarmableAgingCrop(new ItemStack(Items.POTATO), Blocks.POTATOES, BlockPotato.AGE, 7)); - Farmables.farmables.put("farmVegetables", new FarmableAgingCrop(new ItemStack(Items.CARROT), Blocks.CARROTS, BlockCarrot.AGE, 7)); + Farmables.farmables.put("farmVegetables", new FarmableAgingCrop(new ItemStack(Items.POTATO), Blocks.POTATOES, BlockCrops.AGE, 7)); + Farmables.farmables.put("farmVegetables", new FarmableAgingCrop(new ItemStack(Items.CARROT), Blocks.CARROTS, BlockCrops.AGE, 7)); Farmables.farmables.put("farmVegetables", new FarmableAgingCrop(new ItemStack(Items.BEETROOT_SEEDS), Blocks.BEETROOTS, BlockBeetroot.BEETROOT_AGE, 3)); proxy.initializeModels(); diff --git a/src/main/java/forestry/farming/gui/FarmLedger.java b/src/main/java/forestry/farming/gui/FarmLedger.java index 52847047f..cd1df116d 100644 --- a/src/main/java/forestry/farming/gui/FarmLedger.java +++ b/src/main/java/forestry/farming/gui/FarmLedger.java @@ -11,14 +11,8 @@ package forestry.farming.gui; import net.minecraft.client.Minecraft; -import net.minecraft.client.renderer.ItemModelMesher; -import net.minecraft.client.renderer.RenderItem; -import net.minecraft.client.renderer.block.model.IBakedModel; import net.minecraft.client.renderer.texture.TextureAtlasSprite; import net.minecraft.client.renderer.texture.TextureMap; -import net.minecraft.init.Items; -import net.minecraft.item.ItemStack; - import forestry.core.gui.ledgers.Ledger; import forestry.core.gui.ledgers.LedgerManager; import forestry.core.proxy.Proxies; diff --git a/src/main/java/forestry/greenhouse/gui/ContainerGreenhouse.java b/src/main/java/forestry/greenhouse/gui/ContainerGreenhouse.java index 124fc28ea..7d1f3a556 100644 --- a/src/main/java/forestry/greenhouse/gui/ContainerGreenhouse.java +++ b/src/main/java/forestry/greenhouse/gui/ContainerGreenhouse.java @@ -15,7 +15,6 @@ import net.minecraft.entity.player.InventoryPlayer; import net.minecraftforge.fluids.IFluidTank; import forestry.core.gui.ContainerTile; -import forestry.core.gui.slots.SlotFiltered; import forestry.core.gui.slots.SlotLiquidIn; import forestry.core.network.packets.PacketGuiUpdate; import forestry.greenhouse.tiles.TileGreenhouse; diff --git a/src/main/java/forestry/lepidopterology/render/ModelButterflyItem.java b/src/main/java/forestry/lepidopterology/render/ModelButterflyItem.java index b753a2f75..b2f06c930 100644 --- a/src/main/java/forestry/lepidopterology/render/ModelButterflyItem.java +++ b/src/main/java/forestry/lepidopterology/render/ModelButterflyItem.java @@ -24,8 +24,9 @@ import net.minecraft.entity.EntityLivingBase; import net.minecraft.item.ItemStack; import net.minecraft.util.ResourceLocation; import net.minecraft.world.World; -import net.minecraftforge.client.model.IRetexturableModel; +import net.minecraftforge.client.model.IModel; import net.minecraftforge.client.model.ModelLoaderRegistry; +import net.minecraftforge.client.model.ModelProcessingHelper; import net.minecraftforge.fml.relauncher.Side; import net.minecraftforge.fml.relauncher.SideOnly; @@ -39,7 +40,7 @@ import forestry.core.models.TRSRBakedModel; public class ModelButterflyItem extends BlankItemModel { private final Function textureGetter = new DefaultTextureGetter(); @SideOnly(Side.CLIENT) - private IRetexturableModel modelButterfly; + private IModel modelButterfly; @Override protected ItemOverrideList createOverrides() { @@ -49,8 +50,8 @@ public class ModelButterflyItem extends BlankItemModel { private IBakedModel bakeModel(IButterfly butterfly) { ImmutableMap.Builder textures = ImmutableMap.builder(); textures.put("butterfly", butterfly.getGenome().getSecondary().getItemTexture()); - modelButterfly = (IRetexturableModel) modelButterfly.retexture(textures.build()); - return new TRSRBakedModel(modelButterfly.bake(ModelRotation.X0_Y0, DefaultVertexFormats.ITEM, textureGetter), -0.03125F, 0.0F, -0.03125F, butterfly.getSize() * 1.5F); + IModel retexturedModel = ModelProcessingHelper.retexture(modelButterfly, textures.build()); + return new TRSRBakedModel(retexturedModel.bake(ModelRotation.X0_Y0, DefaultVertexFormats.ITEM, textureGetter), -0.03125F, 0.0F, -0.03125F, butterfly.getSize() * 1.5F); } private class ButterflyItemOverrideList extends ItemOverrideList { @@ -62,7 +63,7 @@ public class ModelButterflyItem extends BlankItemModel { public IBakedModel handleItemState(IBakedModel originalModel, ItemStack stack, World world, EntityLivingBase entity) { if (modelButterfly == null) { try { - modelButterfly = (IRetexturableModel) ModelLoaderRegistry.getModel(new ResourceLocation("forestry:item/butterflyGE")); + modelButterfly = ModelLoaderRegistry.getModel(new ResourceLocation("forestry:item/butterflyGE")); } catch (Exception e) { return null; } diff --git a/src/main/resources/assets/forestry/blockstates/pile.json b/src/main/resources/assets/forestry/blockstates/pile.json new file mode 100644 index 000000000..7b7c97f1f --- /dev/null +++ b/src/main/resources/assets/forestry/blockstates/pile.json @@ -0,0 +1,7 @@ +{ + "variants": { + "type=ash": { "model": "forestry:ashPile" }, + "type=dirt": { "model": "forestry:dirtPile" }, + "type=wood": { "model": "forestry:woodPile" } + } +} diff --git a/src/main/resources/assets/forestry/models/block/ashPile.json b/src/main/resources/assets/forestry/models/block/ashPile.json new file mode 100644 index 000000000..80d1ae7b9 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/ashPile.json @@ -0,0 +1,6 @@ +{ + "parent": "block/cube_all", + "textures": { + "all": "forestry:blocks/ash" + } +} diff --git a/src/main/resources/assets/forestry/models/block/dirtPile.json b/src/main/resources/assets/forestry/models/block/dirtPile.json new file mode 100644 index 000000000..6211c677f --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/dirtPile.json @@ -0,0 +1,6 @@ +{ + "parent": "block/cube_all", + "textures": { + "all": "forestry:blocks/loam" + } +} diff --git a/src/main/resources/assets/forestry/models/block/woodPile.json b/src/main/resources/assets/forestry/models/block/woodPile.json new file mode 100644 index 000000000..9aa7c6fa4 --- /dev/null +++ b/src/main/resources/assets/forestry/models/block/woodPile.json @@ -0,0 +1,93 @@ +{ +"textures": { + "woodTop": "forestry:blocks/wood/heart.larch", + "woodBark": "forestry:blocks/wood/bark.larch" +}, +"elements": [ +{ + "from": [ 0, 0, 0 ], + "to": [ 8, 16, 8 ], + "faces": { + "down": { "uv": [ 16, 16, 0, 0 ], "texture": "#woodTop" }, + "up": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodTop" }, + "north": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "south": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "west": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "east": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" } + } +}, +{ + "from": [ 0, 0, 8 ], + "to": [ 8, 16, 16 ], + "faces": { + "down": { "uv": [ 16, 16, 0, 0 ], "texture": "#woodTop" }, + "up": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodTop" }, + "north": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "south": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "west": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "east": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" } + } +}, +{ + "from": [ 8, 0, 0 ], + "to": [ 16, 16, 8 ], + "faces": { + "down": { "uv": [ 16, 16, 0, 0 ], "texture": "#woodTop" }, + "up": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodTop" }, + "north": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "south": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "west": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "east": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" } + } +}, +{ + "from": [ 8, 0, 8 ], + "to": [ 16, 16, 16 ], + "faces": { + "down": { "uv": [ 16, 16, 0, 0 ], "texture": "#woodTop" }, + "up": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodTop" }, + "north": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "south": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "west": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" }, + "east": { "uv": [ 0, 0, 16, 16 ], "texture": "#woodBark" } + } +} +], +"display": { + "thirdperson_righthand": { + "rotation": [ 75, 45, 0 ], + "translation": [ 0, 2.5, 0 ], + "scale": [ 0.375, 0.375, 0.375 ] + }, + "thirdperson_lefthand": { + "rotation": [ 75, 45, 0 ], + "translation": [ 0, 2.5, 0 ], + "scale": [ 0.375, 0.375, 0.375 ] + }, + "ground": { + "rotation": [ 0, 0, 0 ], + "translation": [ 0, 3, 0 ], + "scale": [ 0.25, 0.25, 0.25 ] + }, + "fixed": { + "rotation": [ 0, 0, 0 ], + "translation": [ 0, 0, 0 ], + "scale": [ 0.5, 0.5, 0.5 ] + }, + "firstperson_righthand": { + "rotation": [ 0, 45, 0 ], + "translation": [ 0, 0, 0 ], + "scale": [ 0.4, 0.4, 0.4 ] + }, + "firstperson_lefthand": { + "rotation": [ 0, 225, 0 ], + "translation": [ 0, 0, 0 ], + "scale": [ 0.4, 0.4, 0.4 ] + }, + "gui": { + "rotation": [ 30, 225, 0 ], + "translation": [ 0, 0, 0 ], + "scale": [ 0.625, 0.625, 0.625 ] + } +} +} \ No newline at end of file diff --git a/src/main/resources/assets/forestry/models/item/ashPile.json b/src/main/resources/assets/forestry/models/item/ashPile.json new file mode 100644 index 000000000..11fe40d47 --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/ashPile.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/ashPile" +} diff --git a/src/main/resources/assets/forestry/models/item/charcoal.json b/src/main/resources/assets/forestry/models/item/charcoal.json new file mode 100644 index 000000000..17eb59918 --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/charcoal.json @@ -0,0 +1,3 @@ +{ + "parent": "item/charcoal" +} diff --git a/src/main/resources/assets/forestry/models/item/dirtPile.json b/src/main/resources/assets/forestry/models/item/dirtPile.json new file mode 100644 index 000000000..96efc2d4f --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/dirtPile.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/dirtPile" +} diff --git a/src/main/resources/assets/forestry/models/item/woodPile.json b/src/main/resources/assets/forestry/models/item/woodPile.json new file mode 100644 index 000000000..e8e282c90 --- /dev/null +++ b/src/main/resources/assets/forestry/models/item/woodPile.json @@ -0,0 +1,3 @@ +{ + "parent": "forestry:block/woodPile" +} diff --git a/src/main/resources/assets/forestry/textures/blocks/ash.png b/src/main/resources/assets/forestry/textures/blocks/ash.png new file mode 100644 index 0000000000000000000000000000000000000000..8ee2698f3785c15034b50af622e27ea9bfeffd9d GIT binary patch literal 545 zcmV++0^a?JP)004R= z004l4008;_004mL004C`008P>0026e000+nl3&F}00009a7bBm000XT000XT0n*)m z`~Uy|7<5HgbW?9;ba!ELWdLwtX>N2bZe?^JG%heMIczh2P5=M_gGod|R5(vX(npR$ zK@0@Yz99?5hMaR6f&h_4kPr*5%==?$#tUP&T~)R}so8A){MvXtUM`n>uh$z6hh8R= ziC{LH32wKW&e3R;rqgMZ*Xwn)TGid{cKiMQX0!3~dc9D<1ah@nrNv^g+wCrw%V03@ z%IgRV7AEd=I=If~b85HS(MlIL8lG%EpQmGnfZ+x!m&-}6;3<66craX8#bA|6#UR$m z6!0m3J|7s}QaWUHV6D|^s!R-)ip3%kBZlI9J~tj>0EYg4zbgsM%#uU_u|6>-XE>cs zY6O*df=F!)mLl11x01ho1n|%2(+t6AP9{#C)O<3V3F1mdQVa7z_@MY#$mMdTYBU<8 z6p-!rdod!K0PpuZg6v9KVOp)0xv6`F5l3*nUI{YFE|lCZ_QOX_!J$f}614#6Lxw&?%@C~^HDF0{KfH529uMor j>R|S!3C4o7Uax-vts_RfhY6+q00000NkvXXu0mjf5Ygjn literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/forestry/textures/blocks/loam.png b/src/main/resources/assets/forestry/textures/blocks/loam.png new file mode 100644 index 0000000000000000000000000000000000000000..68b378b95c1fecd4991344c6c04d11c9c80a545c GIT binary patch literal 15375 zcmeI3e~c968OH|@g)LZq2(6bG)&(Pk&d$v4&fe~1ZxwGj?|_BtaV>Wd)OTmz-5YOr zW}TU1_fClfQx8Zgtws?P)FAa@=rtlC6pVt^(gw9Z#E6wXVK#rmN1yFwD%B=2#oL&$2($E=Au9J|6+- zHa*+iX)??Y=Gvc0%Ss-^q%bkEJ zRcr8EJodcDttt(kbz+>4XB%Oc+T3TrwSBAG<-Tq?taz@Ax*~ZA1;{`PxbvB`W=i=6 zPa&>^e%sBQ$6e@RbvJmH*$Lep@m6=EZa}x_4YINz2=4l@R}e#fpZF8Ej~7Ia4|4*~ z@`5Drl8<+nE>F~jenku=DYeC#O6ic*;OVlgti*A-T+W;Gdvznl3E^;<<9(dZ$D$sr z*{fL~&uZqvVvus27&K)=&04Cix$U?hq4!t~9*>=f(%wWGmy29p=?>+-#-jR@e%~6^fv_ zN{t2tmTt7`dOBL%Wvyj|?#9N#u5vG4r)r9xGnYg-+@-qS)o3sVEEq-mG05^F>+`qs z;lh3lEaiO?&pUz?dtx!-x}qj~YsC;GzvztN=!wTb^`ig_Oel)8uOp5kOG(|x04u6y zKnikMEfwLajgFp`T_rW@Y284>f>D2jtJUoAD(p0=MKdj+$*?6BMGan6Rips$CzJjV z&xY%LGMfklLg-6Ove3`_fKZ=I)Yr=ei1E17eN5<>F8A2gf z53oKyA+mx1gDeOrkcGTY49YzI7At=UoxR0MB*9A3F zc@;wydW|2%)RR^Y7;sq%?U0F7elhB3H#~fVv;Pay>i4h^CfN8bmtjIx^(~jdc|!gF zmZ7?fwm5Pf!T*s$<)cA_byI3@ay#(qJx?FC+fC6clzwj4=?X} zW?H=Ng}UkQxL&%ff5pDllcT4Tvp-yPyj8vPe_vmil>7aQt?Jh2P9OPr{*h1QjJeEpMJ&Iiq{g z(x;nlSasE&ul~BT?u|_^|K{)0Haz}Nc3?Qvv>S~=e})s!KDzVBRX-oNfAfg}*u5yW z=aSH1YVYKAi)Xw(a(KXdZ0Z^`v`tfgx8wQzt2_U(W!Krg4<68V&;4qCyzb!o?f=^J ztAW9<&zw4``up9TnfdP=yeWIvU~4Gzen|hrg7@3**xz~*E-jTh%GcNvRW$?a( z!pyy*v1({||4%Rd)64Jn{qeT*p4r3u?>TS$d7x*`KR0%qn793vL&;S`|2=m8Ghx@c bDa=;!%(*3}4%}