Add charcoal pile

This commit is contained in:
Nedelosk committed 2016-05-24 15:20:21 +02:00
1 parent 939d35661b
commit c1e414b8f7
64 files changed
+2599 -83

No files matched your search

@@ -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();
@@ -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();
}
@@ -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.
*/
@@ -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<IAll
*/
@Nonnull
String getModID();
IWoodProvider getWoodProvider();
/* MODELS AND OVERRIDES */
@SideOnly(Side.CLIENT)
@Nonnull
@@ -69,6 +70,6 @@ public interface IAlleleTreeSpecies extends IAlleleSpecies, IAlleleProperty<IAll
ModelResourceLocation getGermlingModel(EnumGermlingType type);
@SideOnly(Side.CLIENT)
void registerModels(Item item, IModelManager manager);
void registerModels(Item item, IModelManager manager, EnumGermlingType type);
}
@@ -18,7 +18,7 @@ import forestry.api.core.IModelManager;
* There is no default implementation because every sapling has a unique icon.
*/
public interface IGermlingModelProvider {
void registerModels(Item item, IModelManager manager);
void registerModels(Item item, IModelManager manager, EnumGermlingType type);
@Nonnull
ModelResourceLocation getModel(EnumGermlingType type);
@@ -7,6 +7,8 @@ package forestry.api.arboriculture;
import java.awt.Color;
import javax.annotation.Nonnull;
import forestry.api.genetics.IClassification;
public interface ITreeFactory {
@@ -26,10 +28,11 @@ public interface ITreeFactory {
* @param modelName The model name for this species
* @param leafSpriteProvider The leaf sprite provider for this species
* @param germlingModelProvider The germling model provider for this species
* @param woodProvider The wood texture provider. It is used to get wood textures for the charcoal pile.
* @param generator The tree generator
* @return a new tree species allele.
*/
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);
IAlleleTreeSpeciesBuilder createSpecies(String uid, String unlocalizedName, String authority, String unlocalizedDescription, boolean dominant, IClassification branch, String binomial, String modID, String modelName, ILeafSpriteProvider leafSpriteProvider, IGermlingModelProvider germlingModelProvider, @Nonnull IWoodProvider woodProvider, ITreeGenerator generator);
/** Get one of the built-in Forestry leaf types. Default type is deciduous. */
ILeafSpriteProvider getLeafIconProvider(EnumLeafType enumLeafType, Color color, Color colorPollinated);
@@ -45,6 +45,10 @@ public interface ITreeGenome extends IGenome {
int getMaturationTime();
int getGirth();
int getCombustibility();
int getCarbonization();
IAlleleLeafEffect getEffect();
}
@@ -0,0 +1,33 @@
/*******************************************************************************
* Copyright 2011-2014 SirSengir
*
* This work (the API) is licensed under the "MIT" License, see LICENSE.txt for details.
******************************************************************************/
package forestry.api.arboriculture;
import javax.annotation.Nonnull;
import net.minecraft.client.renderer.texture.TextureAtlasSprite;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
import forestry.api.core.ITextureManager;
public interface IWoodProvider {
@SideOnly(Side.CLIENT)
void registerSprites(Item item, ITextureManager manager);
/**
*
* @return The texture sprite of the wood.
*/
@SideOnly(Side.CLIENT)
@Nonnull
TextureAtlasSprite getSprite(boolean isTop);
/**
* @return A stack of wood from the tree to craft wood pile's or other things.
*/
ItemStack getWoodStack();
}
@@ -0,0 +1,43 @@
/*******************************************************************************
* Copyright 2011-2014 SirSengir
*
* This work (the API) is licensed under the "MIT" License, see LICENSE.txt for details.
******************************************************************************/
package forestry.api.multiblock;
import javax.annotation.Nonnull;
import com.mojang.authlib.GameProfile;
import forestry.api.arboriculture.EnumPileType;
import forestry.api.arboriculture.ITree;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
/**
* Needs to be implemented by TileEntities that want to be part of an charcoal pile.
* The sub-interfaces can be implemented to alter the operation of the charcoal pile.
* They are automatically detected and handled by the charcoal pile when they join its structure.
*/
public interface ICharcoalPileComponent<T extends IMultiblockLogicCharcoalPile> 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();
}
@@ -0,0 +1,9 @@
package forestry.api.multiblock;
public interface ICharcoalPileController extends IMultiblockController{
boolean isActive();
void setActive(boolean active);
}
@@ -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();
}
@@ -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);
}
}
}
}
}
@@ -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;
@@ -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) {
@@ -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;
@@ -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<EnumPilePosition> PILE_POSITION = PropertyEnum.create("position", EnumPilePosition.class);
public static Map<EnumPileType, BlockPile> create() {
Map<EnumPileType, BlockPile> 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<RayTraceResult> list = Lists.<RayTraceResult>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<AxisAlignedBB> collidingBoxes, Entity entityIn){
state = this.getActualState(state, worldIn, pos);
for (AxisAlignedBB axisalignedbb : getCollisionBoxList(state)){
addCollisionBoxToList(pos, entityBox, collidingBoxes, axisalignedbb);
}
}
private static List<AxisAlignedBB> getCollisionBoxList(IBlockState state){
List<AxisAlignedBB> list = Lists.<AxisAlignedBB>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<ICharcoalPileControllerInternal> 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<ItemStack> 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<List<ItemStack>> 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<ItemStack> list = new ArrayList<ItemStack>();
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<ItemStack> getDrops(IBlockAccess world, BlockPos pos, IBlockState state, int fortune) {
List<ItemStack> 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<ItemStack> list = new ArrayList<ItemStack>();
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();
}
@@ -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<BlockDecorativeLeaves> leavesDecorative;
private final Map<String, ItemStack> speciesToLeavesDecorative;
public final Map<String, BlockFruitPod> podsMap;
public final Map<EnumPileType, BlockPile> piles;
public final BlockArboriculture treeChest;
@@ -187,6 +191,11 @@ public class BlockRegistryArboriculture extends BlockRegistry {
}
}
piles = BlockPile.create();
for(Entry<EnumPileType, BlockPile> pile : piles.entrySet()){
registerBlock(pile.getValue(), new ItemBlockPile(pile.getValue()), "pile_" + pile.getKey().name().toLowerCase(Locale.ENGLISH));
}
// Pods
AlleleFruit.createAlleles();
podsMap = new HashMap<>();
@@ -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;
@@ -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);
@@ -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();
@@ -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
@@ -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);
@@ -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);
}
@@ -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);
}
}
@@ -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);
}
}
@@ -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
@@ -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<B extends Block> extends ItemBlockForestry<Block> {
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;
}
}
@@ -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<ItemStack> onItemRightClickPollen(ItemStack itemStackIn, World worldIn, EntityPlayer playerIn, BlockPos pos, ITree tree) {
@@ -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");
}
@@ -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;
}
}
@@ -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;
}
}
@@ -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<ResourceLocation, TextureAtlasSprite> textureGetter = new DefaultTextureGetter();
@SideOnly(Side.CLIENT)
private IModel modelWoodPileItem;
private IModel modelWoodPileBlock;
private static final Map<String, IBakedModel> blockCache = new HashMap<>();
private static final Map<String, IBakedModel> itemCache = new HashMap<>();
@Override
public List<BakedQuad> 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<String, String> textures = ImmutableMap.builder();
IAlleleTreeSpecies treeSpecies = tree.getGenome().getPrimary();
String treeUID = treeSpecies.getUID();
Map<String, IBakedModel> 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);
}
}
}
@@ -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<? extends RectangularMultiblockControllerBase> myClass = this.getClass();
List<BlockPos> 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();
}
}
@@ -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;
}
}
@@ -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);
}
}
@@ -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;
}
}
@@ -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();
}
@@ -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<ICharcoalPileControllerInternal> 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);
}
}
@@ -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
@@ -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<TilePile> {
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<ICharcoalPileControllerInternal> 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);
}
}
@@ -1,4 +1,4 @@
package forestry.arboriculture.models;
package forestry.arboriculture.render;
import java.util.Map;
@@ -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<IBlockState, ModelResourceLocation> 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;
}
}
@@ -1,4 +1,4 @@
package forestry.arboriculture.models;
package forestry.arboriculture.render;
import com.google.common.collect.Maps;
@@ -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<MultiblockLogicCharcoalPile> implements ICharcoalPileComponent<MultiblockLogicCharcoalPile>{
@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;
}
}
@@ -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<Boolean, IAlleleBoolean> booleans = new HashMap<>();
@@ -33,7 +33,7 @@ public abstract class BlankItemModel implements IBakedModel {
}
protected ItemOverrideList createOverrides(){
return new ItemOverrideList(Collections.emptyList());
return ItemOverrideList.NONE;
}
@Override
@@ -59,7 +59,7 @@ import gnu.trove.map.hash.TIntObjectHashMap;
@SideOnly(Side.CLIENT)
public class ModelCrate extends BlankItemModel {
private static final Map<String, IBakedModel> crates = Maps.newHashMap();
private static final Map<String, IBakedModel> 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);
}
}
@@ -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;
}
@@ -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";
@@ -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();
@@ -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;
@@ -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;
@@ -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<ResourceLocation, TextureAtlasSprite> 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<String, String> 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;
}