Repackage to team.chisel (excepting API)

This commit is contained in:
tterrag1098 committed 2015-08-18 20:40:55 -04:00
1 parent 7555e21144
commit 9574e05c29
132 files changed
+526 -596

No files matched your search

@@ -0,0 +1,76 @@
package team.chisel.block;
import team.chisel.Chisel;
import team.chisel.block.tileentity.TileEntityAutoChisel;
import net.minecraft.block.Block;
import net.minecraft.block.BlockContainer;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.World;
public class BlockAutoChisel extends BlockContainer {
public BlockAutoChisel() {
super(Material.rock);
setHardness(1F);
setBlockBounds(0.125f, 0, 0.125f, 0.875f, 0.8125f, 0.875f);
}
@Override
public int getRenderType() {
return Chisel.renderAutoChiselId;
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public boolean renderAsNormalBlock() {
return false;
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int metadata, float x1, float y1, float z1) {
TileEntity tile = world.getTileEntity(x, y, z);
if (world.isRemote)
return true;
if (tile != null && tile instanceof TileEntityAutoChisel && !player.isSneaking()) {
player.openGui(Chisel.instance, 1, world, x, y, z);
}
return true;
}
@Override
public void breakBlock(World world, int x, int y, int z, Block block, int par6) {
dropItems(world, x, y, z);
super.breakBlock(world, x, y, z, block, par6);
}
private void dropItems(World world, int x, int y, int z) {
TileEntity tileEntity = world.getTileEntity(x, y, z);
if (!(tileEntity instanceof TileEntityAutoChisel)) {
return;
}
TileEntityAutoChisel inventory = (TileEntityAutoChisel) world.getTileEntity(x, y, z);
for (int c = 0; c < inventory.getSizeInventory(); c++) {
ItemStack stack = inventory.getStackInSlot(c);
if (stack != null) {
dropBlockAsItem(world, x, y, z, stack);
}
}
}
@Override
public TileEntity createNewTileEntity(World var1, int var2) {
return new TileEntityAutoChisel();
}
}
@@ -0,0 +1,23 @@
package team.chisel.block;
import net.minecraft.block.material.Material;
import net.minecraft.world.IBlockAccess;
/**
* Created by Pokefenn
*/
public class BlockBeaconBase extends BlockCarvable {
public BlockBeaconBase() {
super();
}
public BlockBeaconBase(Material mat) {
super(mat);
}
@Override
public boolean isBeaconBase(IBlockAccess worldObj, int x, int y, int z, int beaconX, int beaconY, int beaconZ) {
return true;
}
}
@@ -0,0 +1,181 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import com.cricketcraft.chisel.api.rendering.ClientUtils;
import team.chisel.Chisel;
import team.chisel.init.ChiselTabs;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvable extends Block implements ICarvable {
public CarvableHelper carverHelper;
private boolean isAlpha;
public BlockCarvable() {
this(Material.rock);
}
public BlockCarvable(Material m) {
super(m);
if (m == Material.rock || m == Material.iron) {
setHarvestLevel("pickaxe", 0);
}
carverHelper = new CarvableHelper(this);
setResistance(10.0F);
setHardness(2.0F);
setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
}
public BlockCarvable setStained(boolean a) {
this.isAlpha = a;
return this;
}
@Override
@SideOnly(Side.CLIENT)
public int getRenderBlockPass() {
return isAlpha ? 1 : 0;
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
return carverHelper.getIcon(world, x, y, z, side);
}
@Override
public int damageDropped(int i) {
return i;
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons(Chisel.MOD_ID, this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public int getRenderType() {
return ClientUtils.renderCTMId;
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
public static class SoundType extends Block.SoundType {
public final String soundNameStep;
public final String soundNameBreak;
public final String soundNamePlace;
/**
* Creates a SoundType with automatic names for step and break sounds. Sound names dig.soundName and step.soundName must be specified in the sounds.json
*
* @param soundName
* block of the sound. Will automatically be expanded to "mod:dig.soundName" and "mod:step.soundName" respectively)
* @param volume
* default 1.0f
* @param frequency
* default 1.0f
*/
public SoundType(String soundName, float volume, float frequency) {
super(soundName, volume, frequency);
this.soundNameStep = null;
this.soundNameBreak = null;
this.soundNamePlace = null;
}
/**
* Creates a SoundType with manual names for step and break sounds. Sound names must be specified in the sounds.json
*
* @param soundNameBreak
* block break sound
* @param soundNameStep
* block step sound
* @param volume
* default 1.0f
* @param frequency
* default 1.0f
*/
public SoundType(String soundNameBreak, String soundNameStep, float volume, float frequency) {
super(soundNameStep, volume, frequency);
this.soundNameStep = soundNameStep;
this.soundNameBreak = soundNameBreak;
this.soundNamePlace = null;
}
/**
* Creates a SoundType with manual names for step, break and place sounds. Sound names must be specified in the sounds.json
*
* @param soundNameBreak
* block break sound
* @param soundNameStep
* block step sound
* @param soundNamePlace
* block place sound
* @param volume
* default 1.0f
* @param frequency
* default 1.0f
*/
public SoundType(String soundNameBreak, String soundNameStep, String soundNamePlace, float volume, float frequency) {
super(soundNameStep, volume, frequency);
this.soundNameStep = soundNameStep;
this.soundNameBreak = soundNameBreak;
this.soundNamePlace = soundNamePlace;
}
@Override
public String getBreakSound() {
if (soundNameBreak == null)
return Chisel.MOD_ID + ":dig." + this.soundName;
else
return this.soundNameBreak;
}
@Override
public String getStepResourcePath() {
if (soundNameStep == null)
return Chisel.MOD_ID + ":step." + this.soundName;
else
return this.soundNameStep;
}
@Override
public String func_150496_b() {
if (soundNamePlace == null)
return getBreakSound();
else
return this.soundNamePlace;
}
}
}
@@ -0,0 +1,19 @@
package team.chisel.block;
import com.cricketcraft.chisel.api.ICarvable;
import net.minecraft.block.material.Material;
import net.minecraft.entity.EnumCreatureType;
import net.minecraft.world.IBlockAccess;
public class BlockCarvableAntiBlock extends BlockCarvableColor implements ICarvable {
public BlockCarvableAntiBlock() {
super(Material.rock);
}
@Override
public boolean canCreatureSpawn(EnumCreatureType type, IBlockAccess world, int x, int y, int z) {
return false;
}
}
@@ -0,0 +1,74 @@
package team.chisel.block;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import team.chisel.block.tileentity.TileEntityCarvableBeacon;
import team.chisel.init.ChiselTabs;
import net.minecraft.block.BlockBeacon;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
public class BlockCarvableBeacon extends BlockBeacon implements ICarvable {
public static int renderId;
public CarvableHelper carverHelper;
public BlockCarvableBeacon() {
super();
setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
setLightLevel(5.0F);
setBlockTextureName("beacon");
carverHelper = new CarvableHelper(this);
}
@Override
public TileEntity createNewTileEntity(World world, int meta) {
return new TileEntityCarvableBeacon();
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par5, float hitX, float hitY, float hitZ) {
if (world.isRemote) {
return true;
} else {
TileEntityCarvableBeacon tileentitybeacon = (TileEntityCarvableBeacon) world.getTileEntity(x, y, z);
if (tileentitybeacon != null) {
player.func_146104_a(tileentitybeacon);
}
return true;
}
}
@Override
public int getRenderType() {
return renderId;
}
@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack stack) {
super.onBlockPlacedBy(world, x, y, z, player, stack);
if (stack.hasDisplayName()) {
((TileEntityCarvableBeacon) world.getTileEntity(x, y, z)).func_145999_a(stack.getDisplayName());
}
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
}
@@ -0,0 +1,61 @@
package team.chisel.block;
import java.util.Random;
import net.minecraft.block.material.Material;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvableBookshelf extends BlockCarvable {
public BlockCarvableBookshelf() {
super(Material.wood);
setHarvestLevel("axe", 0);
}
@Override
@SideOnly(Side.CLIENT)
public IIcon getIcon(int side, int metadata) {
if (side < 2)
return Blocks.planks.getBlockTextureFromSide(side);
return super.getIcon(side, metadata);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
if (side < 2)
return Blocks.planks.getBlockTextureFromSide(side);
return super.getIcon(world, x, y, z, side);
}
@Override
public int quantityDropped(Random random) {
return 3;
}
@Override
public Item getItemDropped(int ammount, Random random, int meta) {
return Items.book;
}
@Override
public int damageDropped(int damage) {
return 0;
}
@Override
public int getDamageValue(World world, int x, int y, int z) {
return world.getBlockMetadata(x, y, z);
}
@Override
public float getEnchantPowerBonus(World world, int x, int y, int z) {
return 1;
}
}
@@ -0,0 +1,66 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import com.cricketcraft.chisel.api.rendering.ClientUtils;
import net.minecraft.block.BlockCarpet;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
public class BlockCarvableCarpet extends BlockCarpet implements ICarvable {
public CarvableHelper carverHelper;
public BlockCarvableCarpet(Material m) {
carverHelper = new CarvableHelper(this);
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
return carverHelper.getIcon(world, x, y, z, side);
}
@Override
public int damageDropped(int i) {
return i;
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public int getRenderType() {
return ClientUtils.renderCTMId;
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
}
@@ -0,0 +1,26 @@
package team.chisel.block;
import net.minecraft.block.material.Material;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
public class BlockCarvableColor extends BlockCarvable {
public BlockCarvableColor() {
this(Material.rock);
}
public BlockCarvableColor(Material m) {
super(m);
}
@Override
public boolean recolourBlock(World world, int x, int y, int z, ForgeDirection side, int color) {
int newColor = 15 - color;
if (world.getBlockMetadata(x, y, z) != newColor) {
world.setBlockMetadataWithNotify(x, y, z, newColor, 3);
return true;
}
return false;
}
}
@@ -0,0 +1,89 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import com.cricketcraft.chisel.api.rendering.ClientUtils;
import team.chisel.init.ChiselTabs;
import net.minecraft.block.BlockGlass;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvableGlass extends BlockGlass implements ICarvable {
public CarvableHelper carverHelper;
private boolean isAlpha = false;
public BlockCarvableGlass() {
super(Material.glass, false);
carverHelper = new CarvableHelper(this);
setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
}
public BlockCarvableGlass setStained(boolean a) {
this.isAlpha = a;
return this;
}
@Override
public boolean renderAsNormalBlock() {
return false;
}
@Override
public boolean isNormalCube() {
return true;
}
@Override
public int getRenderType() {
return ClientUtils.renderCTMId;
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i) {
return i;
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
@Override
@SideOnly(Side.CLIENT)
public int getRenderBlockPass() {
return isAlpha ? 1 : 0;
}
}
@@ -0,0 +1,58 @@
package team.chisel.block;
import team.chisel.Chisel;
import team.chisel.client.render.SubmapManagerBase;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvableGlow extends BlockCarvableColor {
@SideOnly(Side.CLIENT)
private IIcon glowTexture;
private SubmapManagerBase submapManagerBase;
private String glowTexturePath;
public BlockCarvableGlow(String glowTexture) {
super();
setLightLevel(0.5f);
this.glowTexturePath = glowTexture;
}
public BlockCarvableGlow(Material mat, String glowTexture) {
super(mat);
this.glowTexturePath = glowTexture;
}
public BlockCarvableGlow(Material material, String glowTexture, SubmapManagerBase submapManagerBase) {
super(material);
this.glowTexturePath = glowTexture;
this.submapManagerBase = submapManagerBase;
}
@Override
public void registerBlockIcons(IIconRegister register) {
super.registerBlockIcons(register);
glowTexture = register.registerIcon(Chisel.MOD_ID + ":" + glowTexturePath);
}
public boolean hasSubmapManager() {
return submapManagerBase == null;
}
public SubmapManagerBase getSubmapManager() {
return hasSubmapManager() ? submapManagerBase : null;
}
public IIcon getGlowTexture() {
return glowTexture;
}
@Override
public int getRenderType() {
return Chisel.renderGlowId;
}
}
@@ -0,0 +1,42 @@
package team.chisel.block;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.init.Items;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.World;
public class BlockCarvableGlowstone extends BlockCarvable {
public BlockCarvableGlowstone() {
super(Material.glass);
}
@Override
public int quantityDropped(Random random) {
return Blocks.glowstone.quantityDropped(random);
}
@Override
public Item getItemDropped(int i, Random random, int a) {
return Items.glowstone_dust;
}
@Override
public int damageDropped(int i) {
return 0;
}
@Override
public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z, EntityPlayer player) {
Block glowstone = world.getBlock(x, y, z);
int meta = world.getBlockMetadata(x, y, z);
return new ItemStack(Item.getItemFromBlock(glowstone), 1, meta);
}
}
@@ -0,0 +1,75 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import com.cricketcraft.chisel.api.rendering.ClientUtils;
import net.minecraft.block.Block;
import net.minecraft.block.BlockIce;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.item.Item;
import net.minecraft.stats.StatList;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
public class BlockCarvableIce extends BlockIce implements ICarvable {
public CarvableHelper carverHelper;
public BlockCarvableIce() {
super();
carverHelper = new CarvableHelper(this);
}
@Override
public int getRenderType() {
return ClientUtils.renderCTMId;
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
par2EntityPlayer.addStat(StatList.mineBlockStatArray[Block.getIdFromBlock(this)], 1);
par2EntityPlayer.addExhaustion(0.025F);
/*
* if(this.canSilkHarvest(par1World, par2EntityPlayer, par3, par4, par5, par6) && EnchantmentHelper.getSilkTouchModifier(par2EntityPlayer)) { ItemStack itemstack =
* this.createStackedBlock(par6);
*
* if(itemstack != null) { this.dropBlockAsItem(par1World, par3, par4, par5, itemstack); } }
*/
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
}
@@ -0,0 +1,45 @@
package team.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import team.chisel.init.ChiselBlocks;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.world.World;
public class BlockCarvableIceStairs extends BlockCarvableStairs {
public BlockCarvableIceStairs(Block block, int meta, CarvableHelper helper) {
super(block, meta, helper);
slipperiness = 0.98F;
setTickRandomly(true);
}
@Override
public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
ChiselBlocks.ice.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
}
@Override
public int quantityDropped(Random par1Random) {
return ChiselBlocks.ice.quantityDropped(par1Random);
}
@Override
public int damageDropped(int i) {
return 0;
}
@Override
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
ChiselBlocks.ice.updateTick(par1World, par2, par3, par4, par5Random);
}
@Override
public int getMobilityFlag() {
return 0;
}
}
@@ -0,0 +1,81 @@
package team.chisel.block;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.World;
public class BlockCarvableLamp extends BlockCarvable {
BlockCarvableLamp blockUnpowered;
BlockCarvableLamp blockPowered;
boolean powered;
public BlockCarvableLamp() {
super(Material.redstoneLight);
powered = false;
blockUnpowered = this;
blockPowered = new BlockCarvableLamp(this);
setHardness(0.3F);
}
public BlockCarvableLamp(BlockCarvableLamp unpoweredVersion) {
super(Material.redstoneLight);
carverHelper = unpoweredVersion.carverHelper;
powered = true;
blockUnpowered = unpoweredVersion;
blockPowered = this;
setLightLevel(1.0F);
setHardness(0.3F);
}
public void checkPower(World world, int x, int y, int z) {
if (world.isRemote)
return;
boolean isGettingPower = world.isBlockIndirectlyGettingPowered(x, y, z);
int meta = world.getBlockMetadata(x, y, z);
if (powered && !isGettingPower) {
world.setBlock(x, y, z, blockUnpowered, meta, 2);
} else if (!powered && isGettingPower) {
world.setBlock(x, y, z, blockPowered, meta, 2);
}
}
@Override
public void onBlockAdded(World world, int x, int y, int z) {
checkPower(world, x, y, z);
}
@Override
public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
checkPower(world, x, y, z);
}
/*
* @Override public void updateTick(World world, int x, int y, int z, Random rand){ if (world.isRemote) return;
*
* if(powered && !world.isBlockIndirectlyGettingPowered(x, y, z)){ int meta=world.getBlockMetadata(x, y, z); world.setBlock(x, y, z, Block.redstoneLampIdle.blockID, meta, 2); } }
*/
@Override
public Item getItemDropped(int par1, Random par2Random, int par3) {
return Item.getItemFromBlock(blockUnpowered);
}
@Override
public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
return new ItemStack(blockUnpowered, 1, world.getBlockMetadata(x, y, z));
}
}
@@ -0,0 +1,35 @@
package team.chisel.block;
import team.chisel.Chisel;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvableLayered extends BlockCarvable {
@SideOnly(Side.CLIENT)
private IIcon baseTexture;
private String baseTexLocation;
public BlockCarvableLayered(Material mat, String baseTexLocation) {
super(mat);
this.baseTexLocation = baseTexLocation;
}
@Override
public void registerBlockIcons(IIconRegister register) {
super.registerBlockIcons(register);
baseTexture = register.registerIcon(Chisel.MOD_ID + ":" + baseTexLocation);
}
public IIcon getBaseTex() {
return baseTexture;
}
@Override
public int getRenderType() {
return Chisel.renderLayeredId;
}
}
@@ -0,0 +1,83 @@
package team.chisel.block;
import java.util.List;
import java.util.Random;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import com.cricketcraft.chisel.api.rendering.ClientUtils;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.init.Blocks;
import net.minecraft.item.Item;
import net.minecraft.stats.StatList;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
public class BlockCarvablePackedIce extends Block implements ICarvable {
public CarvableHelper carverHelper;
public BlockCarvablePackedIce() {
super(Material.ice);
carverHelper = new CarvableHelper(this);
this.slipperiness = Blocks.packed_ice.slipperiness;
}
@Override
public int getRenderType() {
return ClientUtils.renderCTMId;
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public int quantityDropped(int meta, int fortune, Random random) {
return 0;
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
super.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
par2EntityPlayer.addStat(StatList.mineBlockStatArray[Block.getIdFromBlock(this)], 1);
par2EntityPlayer.addExhaustion(0.025F);
/*
* if(this.canSilkHarvest(par1World, par2EntityPlayer, par3, par4, par5, par6) && EnchantmentHelper.getSilkTouchModifier(par2EntityPlayer)) { ItemStack itemstack =
* this.createStackedBlock(par6);
*
* if(itemstack != null) { this.dropBlockAsItem(par1World, par3, par4, par5, itemstack); } }
*/
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
}
@@ -0,0 +1,45 @@
package team.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import team.chisel.init.ChiselBlocks;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.world.World;
public class BlockCarvablePackedIceStairs extends BlockCarvableStairs {
public BlockCarvablePackedIceStairs(Block block, int meta, CarvableHelper helper) {
super(block, meta, helper);
slipperiness = 0.98F;
setTickRandomly(true);
}
@Override
public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) {
ChiselBlocks.ice.harvestBlock(par1World, par2EntityPlayer, par3, par4, par5, par6);
}
@Override
public int quantityDropped(Random par1Random) {
return ChiselBlocks.ice.quantityDropped(par1Random);
}
@Override
public int damageDropped(int i) {
return 0;
}
@Override
public void updateTick(World par1World, int par2, int par3, int par4, Random par5Random) {
ChiselBlocks.ice.updateTick(par1World, par2, par3, par4, par5Random);
}
@Override
public int getMobilityFlag() {
return 0;
}
}
@@ -0,0 +1,80 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import team.chisel.client.render.RendererCTMPane;
import team.chisel.init.ChiselTabs;
import net.minecraft.block.BlockPane;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvablePane extends BlockPane implements ICarvable {
public CarvableHelper carverHelper;
public boolean isAlpha;
public BlockCarvablePane(Material material, boolean drops) {
super("", "", material, drops);
carverHelper = new CarvableHelper(this);
setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
}
public BlockCarvablePane setStained(boolean a) {
this.isAlpha = a;
return this;
}
@Override
@SideOnly(Side.CLIENT)
public int getRenderBlockPass() {
return isAlpha ? 1 : 0;
}
@Override
public int getRenderType() {
return RendererCTMPane.id;
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i) {
return i;
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
}
@@ -0,0 +1,29 @@
package team.chisel.block;
import net.minecraft.block.material.Material;
import net.minecraft.world.IBlockAccess;
public class BlockCarvablePowered extends BlockCarvable {
public BlockCarvablePowered(Material m) {
super(m);
}
/**
* Can this block provide power. Only wire currently seems to have this change based on its state.
*/
@Override
public boolean canProvidePower() {
return true;
}
/**
* Returns true if the block is emitting indirect/weak redstone power on the specified side. If isBlockNormalCube returns true, standard redstone propagation rules will apply instead and this will
* not be called. Args: World, X, Y, Z, side. Note that the side is reversed - eg it is 1 (up) when checking the bottom of the block.
*/
@Override
public int isProvidingWeakPower(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) {
return 15;
}
}
@@ -0,0 +1,125 @@
package team.chisel.block;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import team.chisel.Chisel;
import team.chisel.entity.EntityChiselSnowman;
import net.minecraft.block.Block;
import net.minecraft.block.BlockPumpkin;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.entity.monster.EntityIronGolem;
import net.minecraft.init.Blocks;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvablePumpkin extends BlockPumpkin implements ICarvable {
public CarvableHelper carverHelper;
@SideOnly(Side.CLIENT)
private IIcon top, face;
private String faceLocation;
public BlockCarvablePumpkin(boolean isOn) {
super(isOn);
this.setStepSound(Block.soundTypeWood);
if (isOn)
setLightLevel(10.0F);
carverHelper = new CarvableHelper(this);
}
@Override
public void onBlockAdded(World world, int x, int y, int z) {
if (world.getBlock(x, y - 1, z) == Blocks.snow && world.getBlock(x, y - 2, z) == Blocks.snow) {
if (!world.isRemote) {
// Let's grab the pumpkin before we start
ItemStack pumpkin = new ItemStack(world.getBlock(x, y, z), world.getBlockMetadata(x, y, z));
world.setBlock(x, y, z, Blocks.air, 0, 2);
world.setBlock(x, y - 1, z, Blocks.air, 0, 2);
world.setBlock(x, y - 2, z, Blocks.air, 0, 2);
EntityChiselSnowman snowman = new EntityChiselSnowman(world);
snowman.setCurrentItemOrArmor(2, pumpkin);
snowman.setLocationAndAngles(x + 0.5D, y - 1.95D, z + 0.5D, 0.0F, 0.0F);
world.spawnEntityInWorld(snowman);
world.notifyBlockChange(x, y, z, Blocks.air);
world.notifyBlockChange(x, y - 1, z, Blocks.air);
world.notifyBlockChange(x, y - 2, z, Blocks.air);
}
// Spawn some lovely particles
for (int c = 0; c < 120; ++c) {
world.spawnParticle("snowshovel", x + world.rand.nextDouble(), y - 2 + world.rand.nextDouble() * 2.5D, z + world.rand.nextDouble(), 0.0D, 0.0D, 0.0D);
}
} else if (world.getBlock(x, y - 1, z) == Blocks.iron_block || world.getBlock(x, y - 2, z) == Blocks.iron_block) {
boolean flag = world.getBlock(x - 1, y - 1, z) == Blocks.iron_block && world.getBlock(x + 1, y - 1, z) == Blocks.iron_block;
boolean flag1 = world.getBlock(x, y - 1, z - 1) == Blocks.iron_block && world.getBlock(x, y - 1, z + 1) == Blocks.iron_block;
if (flag || flag1) {
world.setBlock(x, y, z, Blocks.air, 0, 2);
world.setBlock(x, y - 1, z, Blocks.air, 0, 2);
world.setBlock(x, y - 2, z, Blocks.air, 0, 2);
if (flag) {
world.setBlock(x - 1, y - 1, z, Blocks.air, 0, 2);
world.setBlock(x + 1, y - 1, z, Blocks.air, 0, 2);
} else {
world.setBlock(x, y - 1, z - 1, Blocks.air, 0, 2);
world.setBlock(x, y - 1, z + 1, Blocks.air, 0, 2);
}
EntityIronGolem ironGolem = new EntityIronGolem(world);
ironGolem.setPlayerCreated(true);
ironGolem.setLocationAndAngles(x + 0.5D, y - 1.95D, z + 0.5D, 0.0F, 0.0F);
world.spawnEntityInWorld(ironGolem);
world.notifyBlockChange(x, y, z, Blocks.air);
world.notifyBlockChange(x, y - 1, z, Blocks.air);
world.notifyBlockChange(x, y - 2, z, Blocks.air);
if (flag) {
world.notifyBlockChange(x - 1, y - 1, z, Blocks.air);
world.notifyBlockChange(x + 1, y - 1, z, Blocks.air);
} else {
world.notifyBlockChange(x, y - 1, z - 1, Blocks.air);
world.notifyBlockChange(x, y - 1, z + 1, Blocks.air);
}
}
}
}
@Override
@SideOnly(Side.CLIENT)
public IIcon getIcon(int side, int meta) {
return side == 1 ? top : (side == 0 ? top : (meta == 2 && side == 2 ? face : (meta == 3 && side == 5 ? face
: (meta == 0 && side == 3 ? face : (meta == 1 && side == 4 ? face : this.blockIcon)))));
}
@Override
public void registerBlockIcons(IIconRegister icon) {
top = icon.registerIcon(Chisel.MOD_ID + ":pumpkin/pumpkin_top");
face = icon.registerIcon(Chisel.MOD_ID + ":" + faceLocation);
this.blockIcon = icon.registerIcon(Chisel.MOD_ID + ":pumpkin/pumpkin_side");
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
public void setInformation(String textureLocation) {
this.faceLocation = textureLocation;
}
}
@@ -0,0 +1,173 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import com.cricketcraft.chisel.api.rendering.ClientUtils;
import team.chisel.Chisel;
import team.chisel.init.ChiselTabs;
import net.minecraft.block.Block;
import net.minecraft.block.BlockSand;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvableSand extends BlockSand implements ICarvable {
public CarvableHelper carverHelper;
private boolean isAlpha;
public BlockCarvableSand() {
super();
carverHelper = new CarvableHelper(this);
setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
}
public BlockCarvableSand setStained(boolean a) {
this.isAlpha = a;
return this;
}
@Override
@SideOnly(Side.CLIENT)
public int getRenderBlockPass() {
return isAlpha ? 1 : 0;
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
return carverHelper.getIcon(world, x, y, z, side);
}
@Override
public int damageDropped(int i) {
return i;
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public int getRenderType() {
return ClientUtils.renderCTMId;
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
public static class SoundType extends Block.SoundType {
public final String soundNameStep;
public final String soundNameBreak;
public final String soundNamePlace;
/**
* Creates a SoundType with automatic names for step and break sounds. Sound names dig.soundName and step.soundName must be specified in the sounds.json
*
* @param soundName
* block of the sound. Will automatically be expanded to "mod:dig.soundName" and "mod:step.soundName" respectively)
* @param volume
* default 1.0f
* @param frequency
* default 1.0f
*/
public SoundType(String soundName, float volume, float frequency) {
super(soundName, volume, frequency);
this.soundNameStep = null;
this.soundNameBreak = null;
this.soundNamePlace = null;
}
/**
* Creates a SoundType with manual names for step and break sounds. Sound names must be specified in the sounds.json
*
* @param soundNameBreak
* block break sound
* @param soundNameStep
* block step sound
* @param volume
* default 1.0f
* @param frequency
* default 1.0f
*/
public SoundType(String soundNameBreak, String soundNameStep, float volume, float frequency) {
super(soundNameStep, volume, frequency);
this.soundNameStep = soundNameStep;
this.soundNameBreak = soundNameBreak;
this.soundNamePlace = null;
}
/**
* Creates a SoundType with manual names for step, break and place sounds. Sound names must be specified in the sounds.json
*
* @param soundNameBreak
* block break sound
* @param soundNameStep
* block step sound
* @param soundNamePlace
* block place sound
* @param volume
* default 1.0f
* @param frequency
* default 1.0f
*/
public SoundType(String soundNameBreak, String soundNameStep, String soundNamePlace, float volume, float frequency) {
super(soundNameStep, volume, frequency);
this.soundNameStep = soundNameStep;
this.soundNameBreak = soundNameBreak;
this.soundNamePlace = soundNamePlace;
}
@Override
public String getBreakSound() {
if (soundNameBreak == null)
return Chisel.MOD_ID + ":dig." + this.soundName;
else
return this.soundNameBreak;
}
@Override
public String getStepResourcePath() {
if (soundNameStep == null)
return Chisel.MOD_ID + ":step." + this.soundName;
else
return this.soundNameStep;
}
@Override
public String func_150496_b() {
if (soundNamePlace == null)
return getBreakSound();
else
return this.soundNamePlace;
}
}
}
@@ -0,0 +1,131 @@
package team.chisel.block;
import java.util.List;
import java.util.Random;
import net.minecraft.block.Block;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.Entity;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.IIcon;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import static net.minecraftforge.common.util.ForgeDirection.UP;
public class BlockCarvableSlab extends BlockCarvable {
public Block master;
public BlockCarvableSlab bottom;
public BlockCarvableSlab top;
public boolean isBottom;
public BlockCarvableSlab(BlockCarvable marble) {
opaque = true;
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
master = marble;
bottom = this;
top = new BlockCarvableSlab(this);
isBottom = true;
}
public BlockCarvableSlab(BlockCarvableSlab bottomBlock) {
super();
setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
master = bottomBlock.master;
bottom = bottomBlock;
top = this;
carverHelper = bottomBlock.carverHelper;
isBottom = false;
}
@Override
public void setBlockBoundsBasedOnState(IBlockAccess par1IBlockAccess, int par2, int par3, int par4) {
if (isBottom) {
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
} else {
setBlockBounds(0.0F, 0.5F, 0.0F, 1.0F, 1.0F, 1.0F);
}
}
@Override
public void setBlockBoundsForItemRender() {
setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.5F, 1.0F);
}
@SuppressWarnings("rawtypes")
@Override
public void addCollisionBoxesToList(World par1World, int par2, int par3, int par4, AxisAlignedBB par5AxisAlignedBB, List par6List, Entity par7Entity) {
setBlockBoundsBasedOnState(par1World, par2, par3, par4);
super.addCollisionBoxesToList(par1World, par2, par3, par4, par5AxisAlignedBB, par6List, par7Entity);
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public int damageDropped(int meta) {
return meta;
}
@Override
public Item getItemDropped(int par1, Random par2Random, int par3) {
return Item.getItemFromBlock(bottom);
}
@Override
public boolean renderAsNormalBlock() {
return false;
}
@Override
@SideOnly(Side.CLIENT)
public ItemStack getPickBlock(MovingObjectPosition mop, World world, int x, int y, int z) {
return new ItemStack(bottom, 1, world.getBlockMetadata(x, y, z));
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
// return master.getIcon(side, metadata);
}
@SuppressWarnings("rawtypes")
@Override
public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
if (isBottom)
super.getSubBlocks(block, tabs, list);
}
/**
* Checks if the block is a solid face on the given side, used by placement logic.
*
* @param world
* The current world
* @param x
* X Position
* @param y
* Y position
* @param z
* Z position
* @param side
* The side to check
* @return True if the block is solid on the specified side.
*/
@Override
public boolean isSideSolid(IBlockAccess world, int x, int y, int z, ForgeDirection side) {
return !isBottom && (side == UP);
}
}
@@ -0,0 +1,93 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import team.chisel.client.render.RendererStairs;
import net.minecraft.block.Block;
import net.minecraft.block.BlockStairs;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraft.util.MathHelper;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
public class BlockCarvableStairs extends BlockStairs implements ICarvable {
CarvableHelper carverHelper;
int blockMeta;
public BlockCarvableStairs(Block block, int meta, CarvableHelper helper) {
super(block, meta);
this.useNeighborBrightness = true;
carverHelper = helper;
blockMeta = meta;
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, blockMeta + metadata / 8);
}
@Override
public int damageDropped(int i) {
return i / 8;
}
@Override
public void registerBlockIcons(IIconRegister register) {
if (blockMeta == 0)
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
list.add(new ItemStack(block, 1, 0));
list.add(new ItemStack(block, 1, 8));
}
@Override
public int getRenderType() {
return RendererStairs.id;
}
@Override
public void onBlockPlacedBy(World par1World, int par2, int par3, int par4, EntityLivingBase par5EntityLiving, ItemStack par6ItemStack) {
int meta = MathHelper.floor_double((par5EntityLiving.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;
// 0->2 2->3 3->0 1->1
meta = meta == 0 ? 2 : meta == 2 ? 3 : meta == 3 ? 0 : 1;
meta += par1World.getBlockMetadata(par2, par3, par4) % 8; // add upside-down-ness
if (par6ItemStack.getItemDamage() >= 8) {
meta += 8;
}
par1World.setBlockMetadataWithNotify(par2, par3, par4, meta, 2);
}
@Override
public int onBlockPlaced(World world, int x, int y, int z, int side, float hx, float hy, float hz, int damage) {
return side != 0 && (side == 1 || hy <= 0.5D) ? damage : damage + 4;
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(blockMeta + (metadata / 8));
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(blockMeta + (meta / 8));
}
}
@@ -0,0 +1,84 @@
package team.chisel.block;
import java.util.Random;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import team.chisel.Chisel;
import team.chisel.init.ChiselTabs;
import net.minecraft.block.BlockTorch;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCarvableTorch extends BlockTorch implements ICarvable {
public CarvableHelper carverHelper;
private String texLocation;
protected boolean emitsParticles = true;
public int idx;
public BlockCarvableTorch(int idx, String tex) {
super();
carverHelper = new CarvableHelper(this);
setCreativeTab(ChiselTabs.tabOtherChiselBlocks);
setLightLevel(0.9375F);
setBlockName("torch");
this.idx = idx;
this.texLocation = tex;
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
@Override
public void registerBlockIcons(IIconRegister icon) {
this.blockIcon = icon.registerIcon(Chisel.MOD_ID + ":torch/" + texLocation);
}
public BlockCarvableTorch disableParticles() {
this.emitsParticles = false;
return this;
}
@Override
@SideOnly(Side.CLIENT)
public void randomDisplayTick(World p_149734_1_, int p_149734_2_, int p_149734_3_, int p_149734_4_, Random p_149734_5_) {
if (emitsParticles) {
int l = p_149734_1_.getBlockMetadata(p_149734_2_, p_149734_3_, p_149734_4_);
double d0 = p_149734_2_ + 0.5F;
double d1 = p_149734_3_ + 0.7F;
double d2 = p_149734_4_ + 0.5F;
double d3 = 0.2199999988079071D;
double d4 = 0.27000001072883606D;
if (l == 1) {
p_149734_1_.spawnParticle("smoke", d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
p_149734_1_.spawnParticle("flame", d0 - d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
} else if (l == 2) {
p_149734_1_.spawnParticle("smoke", d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
p_149734_1_.spawnParticle("flame", d0 + d4, d1 + d3, d2, 0.0D, 0.0D, 0.0D);
} else if (l == 3) {
p_149734_1_.spawnParticle("smoke", d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
p_149734_1_.spawnParticle("flame", d0, d1 + d3, d2 - d4, 0.0D, 0.0D, 0.0D);
} else if (l == 4) {
p_149734_1_.spawnParticle("smoke", d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
p_149734_1_.spawnParticle("flame", d0, d1 + d3, d2 + d4, 0.0D, 0.0D, 0.0D);
} else {
p_149734_1_.spawnParticle("smoke", d0, d1, d2, 0.0D, 0.0D, 0.0D);
p_149734_1_.spawnParticle("flame", d0, d1, d2, 0.0D, 0.0D, 0.0D);
}
}
}
}
@@ -0,0 +1,44 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import net.minecraft.block.Block;
import net.minecraft.block.BlockWall;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
public class BlockCarvableWall extends BlockWall {
CarvableHelper carverHelper;
public BlockCarvableWall(Block block) {
super(block);
carverHelper = new CarvableHelper(this);
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i) {
return i;
}
@Override
public void registerBlockIcons(IIconRegister register) {
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
}
@@ -0,0 +1,74 @@
package team.chisel.block;
import java.util.Random;
import team.chisel.config.Configurations;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.entity.Entity;
import net.minecraft.item.Item;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockCloud extends BlockCarvable {
public BlockCloud() {
super(Material.ice);
useNeighborBrightness = true;
}
@Override
public void onEntityCollidedWithBlock(World world, int i, int j, int k, Entity entity) {
entity.fallDistance = 0.0F;
if (entity.motionY < 0.0D) {
entity.motionY *= 0.0050000000000000001D;
} else if (entity.motionY > 0) {
entity.motionY += 0.0285;
}
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public int getRenderBlockPass() {
return Configurations.ghostCloud ? 1 : 0;
}
@Override
@SideOnly(Side.CLIENT)
public boolean shouldSideBeRendered(IBlockAccess world, int x, int y, int z, int side) {
Block block = world.getBlock(x, y, z);
if (block == this) {
return false;
}
return super.shouldSideBeRendered(world, x, y, z, side);
}
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int i, int j, int k) {
return AxisAlignedBB.getBoundingBox(i + 0.2, j, k + 0.2, i + 0.8, j + 0.2, k + 0.8);
}
@Override
public Item getItemDropped(int par1, Random rand, int par3) {
return Item.getItemFromBlock(this);
}
@Override
public int quantityDropped(Random rand) {
return rand.nextInt(2);
}
@Override
public int damageDropped(int meta) {
return meta;
}
}
@@ -0,0 +1,35 @@
package team.chisel.block;
import team.chisel.client.GeneralChiselClient;
import team.chisel.config.Configurations;
import net.minecraft.entity.Entity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.World;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.relauncher.Side;
public class BlockConcrete extends BlockCarvable {
public BlockConcrete() {
super();
}
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4) {
if (Configurations.fullBlockConcrete)
return AxisAlignedBB.getBoundingBox(par2, par3, par4, (par2 + 1), ((par3 + 1)), (par4 + 1));
else
return AxisAlignedBB.getBoundingBox(par2, par3, par4, (par2 + 1), ((par3 + 1) - 0.125F), (par4 + 1));
}
@Override
public void onEntityCollidedWithBlock(World world, int x, int y, int z, Entity entity) {
if (FMLCommonHandler.instance().getEffectiveSide() != Side.CLIENT)
return;
if (Configurations.concreteVelocity == 0)
return;
GeneralChiselClient.speedupPlayer(world, entity, Configurations.concreteVelocity);
}
}
@@ -0,0 +1,16 @@
package team.chisel.block;
import team.chisel.Chisel;
public class BlockEldritch extends BlockCarvable {
public BlockEldritch() {
super();
}
@Override
public int getRenderType() {
return Chisel.renderEldritchId;
}
}
@@ -0,0 +1,34 @@
package team.chisel.block;
import java.util.Random;
import team.chisel.Chisel;
import team.chisel.client.GeneralChiselClient;
import team.chisel.utils.General;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
public class BlockGrimstone extends BlockCarvable {
public IIcon iconStar;
public BlockGrimstone(Material m) {
super(m);
}
@Override
public void randomDisplayTick(World world, int x, int y, int z, Random random) {
if (General.rand.nextInt(4) == 0 && world.isRemote)
GeneralChiselClient.spawnGrimstoneFX(world, this, x, y, z);
}
@Override
public void registerBlockIcons(IIconRegister register) {
super.registerBlockIcons(register);
iconStar = register.registerIcon(Chisel.MOD_ID + ":grimstone/particles/star");
}
}
@@ -0,0 +1,35 @@
package team.chisel.block;
import java.util.Random;
import team.chisel.client.GeneralChiselClient;
import team.chisel.utils.General;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
public class BlockHolystone extends BlockCarvable {
public IIcon iconStar;
public BlockHolystone(Material m) {
super(m);
this.setLightLevel(0.25F);
}
@Override
public void randomDisplayTick(World world, int x, int y, int z, Random random) {
if (General.rand.nextInt(4) == 0 && world.isRemote)
GeneralChiselClient.spawnHolystoneFX(world, this, x, y, z);
}
@Override
public void registerBlockIcons(IIconRegister register) {
super.registerBlockIcons(register);
iconStar = register.registerIcon("Chisel:holystone/particles/star");
}
}
@@ -0,0 +1,27 @@
package team.chisel.block;
import java.util.Random;
import team.chisel.client.GeneralChiselClient;
import net.minecraft.block.material.Material;
import net.minecraft.world.World;
public class BlockLavastone extends BlockMultiLayer {
public BlockLavastone(Material mat, String baseIcon) {
super(mat, baseIcon);
setLightLevel(1F);
}
@Override
public void randomDisplayTick(World world, int x, int y, int z, Random random) {
if (random.nextInt(8) == 0 && world.isRemote)
GeneralChiselClient.spawnLavastoneFX(world, this, x, y, z);
}
@Override
public boolean renderAsNormalBlock() {
return true;
}
}
@@ -0,0 +1,16 @@
package team.chisel.block;
import net.minecraft.block.material.Material;
import net.minecraft.init.Blocks;
public class BlockLeaf extends BlockCarvable {
public BlockLeaf(Material material) {
super(material);
}
@Override
public boolean isOpaqueCube() {
return Blocks.leaves.isOpaqueCube();
}
}
@@ -0,0 +1,65 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.item.Item;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
public class BlockMultiLayer extends BlockMultiLayerBase implements ICarvable {
public CarvableHelper carverHelper;
public BlockMultiLayer(Material mat, String baseIcon) {
super(mat, baseIcon);
carverHelper = new CarvableHelper(this);
}
public BlockMultiLayer(Material mat, Block block) {
super(mat, block);
carverHelper = new CarvableHelper(this);
}
@Override
public IIcon getIcon(int side, int metadata) {
return carverHelper.getIcon(side, metadata);
}
@Override
public int damageDropped(int i) {
return i;
}
@Override
public void registerBlockIcons(IIconRegister register) {
super.registerBlockIcons(register);
carverHelper.registerBlockIcons("Chisel", this, register);
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item block, CreativeTabs tabs, List list) {
carverHelper.registerSubBlocks(this, tabs, list);
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
}
@@ -0,0 +1,55 @@
package team.chisel.block;
import team.chisel.client.render.RendererMultiLayer;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraftforge.client.ForgeHooksClient;
public abstract class BlockMultiLayerBase extends Block {
public Block base;
public IIcon icon;
String iconFile;
public BlockMultiLayerBase(Material mat, Block base) {
super(mat);
this.base = base;
}
public BlockMultiLayerBase(Material mat, String iconFile) {
super(mat);
this.iconFile = iconFile;
}
@Override
public boolean renderAsNormalBlock() {
return false;
}
@Override
public int getRenderType() {
return RendererMultiLayer.id;
}
@Override
public int getRenderBlockPass() {
return 1;
}
@Override
public boolean canRenderInPass(int pass) {
ForgeHooksClient.setRenderPass(pass);
return pass == 1 || pass == 0;
}
@Override
public void registerBlockIcons(IIconRegister register) {
if (iconFile != null)
icon = register.registerIcon(iconFile);
}
}
@@ -0,0 +1,227 @@
package team.chisel.block;
import java.util.List;
import com.cricketcraft.chisel.api.ICarvable;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import team.chisel.Chisel;
import team.chisel.block.tileentity.TileEntityPresent;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.MathHelper;
import net.minecraft.util.MovingObjectPosition;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockPresent extends Block implements ICarvable {
public CarvableHelper carverHelper;
private float minX, minY, minZ, maxX, maxY, maxZ;
public BlockPresent() {
super(Material.wood);
carverHelper = new CarvableHelper(this);
minX = 0.0625F;
minZ = 0.0625F;
maxX = 0.9375F;
maxY = 0.875F;
maxZ = 0.9375F;
setBlockBounds(minX, minY, minZ, maxX, maxY, maxZ);
}
public String getModelTexture(int type) {
return "textures/blocks/present/presentChest" + type;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tab, List list) {
for (int i = 0; i < 16; i++) {
list.add(new ItemStack(item, 1, i));
}
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public boolean renderAsNormalBlock() {
return false;
}
@Override
public int getRenderType() {
return -1;
}
@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase player, ItemStack stack) {
super.onBlockPlacedBy(world, x, y, z, player, stack);
int heading = MathHelper.floor_double(player.rotationYaw * 4.0F / 360.0F + 0.5D) & 3;
TileEntityPresent te = (TileEntityPresent) world.getTileEntity(x, y, z);
world.setBlockMetadataWithNotify(x, y, z, stack.getItemDamage(), 3);
te.setRotation(heading);
te.findConnections();
if (te.isConnected()) {
TileEntityPresent other = te.getConnection();
other.setRotation(heading);
}
world.markBlockForUpdate(x, y, z);
}
@Override
public void breakBlock(World world, int x, int y, int z, Block present, int meta) {
TileEntityPresent tileEntityPresent = (TileEntityPresent) world.getTileEntity(x, y, z);
if (tileEntityPresent != null) {
for (int c = 0; c < tileEntityPresent.getTrueSizeInventory(); c++) {
ItemStack itemStack = tileEntityPresent.getTrueStackInSlot(c);
if (itemStack != null) {
dropBlockAsItem(world, x, y, z, itemStack);
}
}
world.func_147453_f(x, y, z, this);
}
super.breakBlock(world, x, y, z, this, meta);
}
@Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int hitX, float hitY, float hitZ, float p_149727_9_) {
if (!world.isSideSolid(x, y + 1, z, ForgeDirection.DOWN)) {
player.openGui(Chisel.instance, 2, world, x, y, z);
return true;
}
return false;
}
@Override
public AxisAlignedBB getSelectedBoundingBoxFromPool(World world, int x, int y, int z) {
if (world.getTileEntity(x, y, z) instanceof TileEntityPresent)
return getBoundingBox((TileEntityPresent) world.getTileEntity(x, y, z));
else
return null;
}
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World world, int x, int y, int z) {
if (world.getTileEntity(x, y, z) instanceof TileEntityPresent)
return getBoundingBox((TileEntityPresent) world.getTileEntity(x, y, z));
else
return null;
}
public AxisAlignedBB getBoundingBox(TileEntityPresent me) {
if (me == null) {
return AxisAlignedBB.getBoundingBox(minX, minY, minZ, maxX, maxY, maxZ);
}
int x = me.xCoord, y = me.yCoord, z = me.zCoord;
if (me.isConnected()) {
ForgeDirection dir = me.getConnectionDir();
// warning: magic below! Do not change this conditional
if (dir == ForgeDirection.EAST || (me.isParent() && dir == ForgeDirection.SOUTH) || (!me.isParent() && dir == ForgeDirection.SOUTH)) {
return AxisAlignedBB.getBoundingBox(x + minX, y + minY, z + minZ, x + maxX + dir.offsetX, y + maxY, z + maxZ + dir.offsetZ);
} else {
return AxisAlignedBB.getBoundingBox(x + dir.offsetX + minX, y + minY, z + dir.offsetZ + minZ, x + maxX, y + maxY, z + maxZ);
}
}
return AxisAlignedBB.getBoundingBox(x + minX, y + minY, z + minZ, x + maxX, y + maxY, z + maxZ);
}
@Override
public void setBlockBoundsBasedOnState(IBlockAccess world, int x, int y, int z) {
TileEntityPresent te = (TileEntityPresent) world.getTileEntity(x, y, z);
if (!te.isConnected()) {
setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
} else {
ForgeDirection dir = te.getConnectionDir();
switch (dir) {
case EAST:
setBlockBounds(0.0625F, 0, 0.0625F, 1, 0.875F, 0.9365F);
break;
case NORTH:
setBlockBounds(0.0625F, 0, 0, 0.9375F, 0.875F, 0.9365F);
break;
case SOUTH:
setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 1);
break;
case WEST:
setBlockBounds(0, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
break;
default:
setBlockBounds(0.0625F, 0, 0.0625F, 0.9375F, 0.875F, 0.9365F);
break;
}
}
}
@Override
public boolean hasTileEntity(int metadata) {
return true;
}
@Override
public TileEntity createTileEntity(World world, int metadata) {
return new TileEntityPresent();
}
@Override
public boolean hasComparatorInputOverride() {
return true;
}
@Override
public int getComparatorInputOverride(World world, int x, int y, int z, int strength) {
TileEntity te = world.getTileEntity(x, y, z);
if (te instanceof TileEntityPresent) {
return Container.calcRedstoneFromInventory((TileEntityPresent) te);
}
return 0;
}
@Override
public int damageDropped(int meta) {
return meta;
}
@Override
public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z) {
return new ItemStack(this, 1, world.getBlockMetadata(x, y, z));
}
@Override
@SideOnly(Side.CLIENT)
public void registerBlockIcons(IIconRegister register) {
this.blockIcon = register.registerIcon("planks_oak");
}
@Override
public IVariationInfo getManager(IBlockAccess world, int x, int y, int z, int metadata) {
return carverHelper.getVariation(metadata);
}
@Override
public IVariationInfo getManager(int meta) {
return carverHelper.getVariation(meta);
}
}
@@ -0,0 +1,92 @@
package team.chisel.block;
import team.chisel.Chisel;
import team.chisel.config.Configurations;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.init.Blocks;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.util.IIcon;
import net.minecraft.world.IBlockAccess;
import net.minecraft.world.World;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class BlockRoadLine extends BlockCarvable {
public IIcon aloneIcon[] = new IIcon[4];
public IIcon halfLineIcon[] = new IIcon[4];
public IIcon fullLineIcon[] = new IIcon[4];
public BlockRoadLine() {
super(Material.circuits);
if (Configurations.useRoadLineTool) {
this.setHarvestLevel(Configurations.getRoadLineTool, Configurations.roadLineToolLevel);
}
this.setBlockBounds(0.0f, 0.0f, 0.0f, 1.0f, 0.00390625f, 1.0f);
// this.setBlockBounds(0.0F, 0.0F, 0.0F, 1.0F, 0.0625F, 1.0F);
}
@Override
public AxisAlignedBB getCollisionBoundingBoxFromPool(World par1World, int par2, int par3, int par4) {
return null;
}
@Override
public boolean isOpaqueCube() {
return false;
}
@Override
public boolean renderAsNormalBlock() {
return false;
}
@Override
public int getRenderType() {
return Chisel.roadLineId;
}
@Override
public boolean canPlaceBlockAt(World par1World, int par2, int par3, int par4) {
return World.doesBlockHaveSolidTopSurface(par1World, par2, par3 - 1, par4) || par1World.getBlock(par2, par3 - 1, par4).equals(Blocks.glowstone);
}
@Override
public void onNeighborBlockChange(World par1World, int par2, int par3, int par4, Block block) {
if (par1World.isRemote)
return;
if (!this.canPlaceBlockAt(par1World, par2, par3, par4)) {
this.dropBlockAsItem(par1World, par2, par3, par4, 0, 0);
par1World.setBlockToAir(par2, par3, par4);
}
super.onNeighborBlockChange(par1World, par2, par3, par4, block);
}
@Override
@SideOnly(Side.CLIENT)
public void registerBlockIcons(IIconRegister reg) {
for (int i = 0; i < 4; i++) {
String[] texNames = { "white", "yellow", "double-white", "double-yellow" };
aloneIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-center");
halfLineIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-side");
fullLineIcon[i] = reg.registerIcon("Chisel:line-marking/" + texNames[i] + "-long");
}
}
@Override
@SideOnly(Side.CLIENT)
public IIcon getIcon(int side, int metadata) {
return aloneIcon[metadata % aloneIcon.length];
}
@Override
@SideOnly(Side.CLIENT)
public IIcon getIcon(IBlockAccess world, int x, int y, int z, int side) {
return getIcon(side, world.getBlockMetadata(x, y, z));
}
}
@@ -0,0 +1,546 @@
package team.chisel.block;
import java.util.List;
import team.chisel.client.render.RendererSnakeStone;
import net.minecraft.block.Block;
import net.minecraft.block.material.Material;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.creativetab.CreativeTabs;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.util.IIcon;
import net.minecraft.util.MathHelper;
import net.minecraft.world.World;
public class BlockSnakestone extends Block {
static final int SEC_HEAD = 0;
static final int SEC_DOWN = 4;
static final int SEC_UP = 8;
static final int SEC_HOR = 12;
static final int SIDE_B = 0;
static final int SIDE_T = 1;
static final int SIDE_N = 2;
static final int SIDE_S = 3;
static final int SIDE_W = 4;
static final int SIDE_E = 5;
String iconPrefix;
IIcon iconFaceLeft;
IIcon iconFaceRight;
IIcon iconCross;
IIcon iconFace;
IIcon iconTopTip;
IIcon iconTopSide;
IIcon iconBottom;
IIcon iconBottomSide;
IIcon iconBottomTip;
IIcon iconLeftDown;
IIcon iconRightDown;
IIcon iconLeftUp;
IIcon iconRightUp;
IIcon iconLeftTip;
IIcon iconSide;
IIcon iconRightTip;
IIcon iconTop;
public boolean flipTopTextures;
public BlockSnakestone(String iconPrefix) {
super(Material.rock);
setHardness(1.5F);
setResistance(10.0F);
setStepSound(Block.soundTypeStone);
flipTopTextures = false;
this.iconPrefix = iconPrefix;
}
@Override
public int getRenderType() {
return RendererSnakeStone.id;
}
static final int[] rotRemap = { 0, 3, 1, 2 };
@Override
public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entity, ItemStack stack) {
int meta = world.getBlockMetadata(x, y, z);
if (meta > 3)
return;
if (rotateHead(world, x, y, z) != -1)
return;
int rot = rotRemap[(MathHelper.floor_double(entity.rotationYaw * 4.0 / 360.0 + 0.5)) & 3];
world.setBlockMetadataWithNotify(x, y, z, rot, 3);
}
@Override
public int onBlockPlaced(World world, int x, int y, int z, int side, float hx, float hy, float hz, int meta) {
if (meta <= 3)
return meta;
if (rotateBodyPart(world, x, y, z)) {
return world.getBlockMetadata(x, y, z);
}
if (side == 0 || side == 1)
meta = 14;
if (side == 2 || side == 3)
meta = 13;
if (side == 4 || side == 5)
meta = 12;
world.setBlockMetadataWithNotify(x, y, z, meta, 2);
return meta;
}
@Override
public void onNeighborBlockChange(World world, int x, int y, int z, Block block) {
int kind = world.getBlockMetadata(x, y, z) & 0xC;
if (kind == 0) {
rotateHead(world, x, y, z);
} else {
rotateBodyPart(world, x, y, z);
}
}
public int[] getConnections(World world, int ox, int oy, int oz) {
int index = 0;
int[] res = { -1, -1, -1, -1, -1, -1, -1 };
for (int direction = 0; direction < 6; direction++) {
int x = ox, y = oy, z = oz;
switch (direction) {
case 0:
z--;
break;
case 1:
z++;
break;
case 2:
x--;
break;
case 3:
x++;
break;
case 4:
y--;
break;
case 5:
y++;
break;
}
if (!world.getBlock(x, y, z).equals(this))
continue;
boolean match = false;
int px1 = x, px2 = x;
int py1 = y, py2 = y;
int pz1 = z, pz2 = z;
int meta = world.getBlockMetadata(x, y, z);
if ((meta & 0xc) == 4 || (meta & 0xc) == 8) {
if ((meta & 4) == 4)
py1--;
else
py1++;
switch (meta & 3) {
case 0:
pz2--;
break;
case 1:
pz2++;
break;
case 2:
px2--;
break;
case 3:
px2++;
break;
}
} else if (meta == 12) {
px1--;
px2++;
} else if (meta == 13) {
pz1--;
pz2++;
} else if (meta == 14) {
py1--;
py2++;
} else if (meta == 15) {
match = true;
} else if (meta < 4) {
match = true;
}
if (!match) {
Block b1 = world.getBlock(px1, py1, pz1);
Block b2 = world.getBlock(px2, py2, pz2);
if (b1 != this || b2 != this)
match = true;
if (ox == px1 && oy == py1 && oz == pz1)
match = true;
if (ox == px2 && oy == py2 && oz == pz2)
match = true;
}
if (match)
res[index++] = direction;
}
if (index != 5)
res[index] = -1;
return res;
}
public boolean rotateBodyPart(World world, int x, int y, int z) {
int[] con = getConnections(world, x, y, z);
int blockMeta = world.getBlockMetadata(x, y, z);
if (con[1] == -1)
return false;
if (con[2] != -1)
return false;
int meta = 15;
if (con[0] == 2 && con[1] == 3) {
meta = 12;
} else if (con[0] == 0 && con[1] == 1) {
meta = 13;
} else if (con[0] == 4 && con[1] == 5) {
meta = 14;
} else if (con[1] == 4) {
meta = SEC_DOWN | con[0];
} else if (con[1] == 5) {
meta = SEC_UP | con[0];
}
if (blockMeta != meta)
world.setBlockMetadataWithNotify(x, y, z, meta, 3);
return true;
}
public int rotateHead(World world, int x, int y, int z) {
int[] con = getConnections(world, x, y, z);
if (con[1] >= 0 && con[1] < 4)
return -1;
int meta = -1;
switch (con[0]) {
case 0:
meta = 1;
break;
case 1:
meta = 0;
break;
case 2:
meta = 3;
break;
case 3:
meta = 2;
break;
}
if (meta == -1)
return -1;
world.setBlock(x, y, z, this, meta, 3);
return meta;
}
public boolean connectedTo(World par1World, int x, int y, int z, int direction) {
switch (direction) {
case 0:
return par1World.getBlock(x, y, z - 1).equals(this);
case 1:
return par1World.getBlock(x, y, z + 1).equals(this);
case 2:
return par1World.getBlock(x - 1, y, z).equals(this);
case 3:
return par1World.getBlock(x + 1, y, z).equals(this);
case 4:
return par1World.getBlock(x, y - 1, z).equals(this);
case 5:
return par1World.getBlock(x, y + 1, z).equals(this);
}
return false;
}
@Override
public IIcon getIcon(int side, int meta) {
switch (meta | (side << 4)) {
case (SEC_HOR | 0 | (SIDE_B << 4)):
return iconBottomTip;
case (SEC_HOR | 0 | (SIDE_T << 4)):
return iconTopSide;
case (SEC_HOR | 0 | (SIDE_N << 4)):
return iconSide;
case (SEC_HOR | 0 | (SIDE_S << 4)):
return iconSide;
case (SEC_HOR | 0 | (SIDE_W << 4)):
return iconCross;
case (SEC_HOR | 0 | (SIDE_E << 4)):
return iconCross;
case (SEC_HOR | 1 | (SIDE_B << 4)):
return iconBottomTip;
case (SEC_HOR | 1 | (SIDE_T << 4)):
return iconTopSide;
case (SEC_HOR | 1 | (SIDE_N << 4)):
return iconCross;
case (SEC_HOR | 1 | (SIDE_S << 4)):
return iconCross;
case (SEC_HOR | 1 | (SIDE_W << 4)):
return iconSide;
case (SEC_HOR | 1 | (SIDE_E << 4)):
return iconSide;
case (SEC_HOR | 2 | (SIDE_B << 4)):
return iconCross;
case (SEC_HOR | 2 | (SIDE_T << 4)):
return iconCross;
case (SEC_HOR | 2 | (SIDE_N << 4)):
return iconSide;
case (SEC_HOR | 2 | (SIDE_S << 4)):
return iconSide;
case (SEC_HOR | 2 | (SIDE_W << 4)):
return iconSide;
case (SEC_HOR | 2 | (SIDE_E << 4)):
return iconSide;
case (SEC_HOR | 3 | (SIDE_B << 4)):
return iconBottom;
case (SEC_HOR | 3 | (SIDE_T << 4)):
return iconTop;
case (SEC_HOR | 3 | (SIDE_N << 4)):
return iconSide;
case (SEC_HOR | 3 | (SIDE_S << 4)):
return iconSide;
case (SEC_HOR | 3 | (SIDE_W << 4)):
return iconSide;
case (SEC_HOR | 3 | (SIDE_E << 4)):
return iconSide;
case (SEC_DOWN | 0 | (SIDE_B << 4)):
return iconCross;
case (SEC_DOWN | 0 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_DOWN | 0 | (SIDE_N << 4)):
return iconCross;
case (SEC_DOWN | 0 | (SIDE_S << 4)):
return iconRightTip;
case (SEC_DOWN | 0 | (SIDE_W << 4)):
return iconLeftDown;
case (SEC_DOWN | 0 | (SIDE_E << 4)):
return iconRightDown;
case (SEC_DOWN | 1 | (SIDE_B << 4)):
return iconCross;
case (SEC_DOWN | 1 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_DOWN | 1 | (SIDE_N << 4)):
return iconLeftTip;
case (SEC_DOWN | 1 | (SIDE_S << 4)):
return iconCross;
case (SEC_DOWN | 1 | (SIDE_W << 4)):
return iconRightDown;
case (SEC_DOWN | 1 | (SIDE_E << 4)):
return iconLeftDown;
case (SEC_DOWN | 2 | (SIDE_B << 4)):
return iconCross;
case (SEC_DOWN | 2 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_DOWN | 2 | (SIDE_N << 4)):
return iconRightDown;
case (SEC_DOWN | 2 | (SIDE_S << 4)):
return iconLeftDown;
case (SEC_DOWN | 2 | (SIDE_W << 4)):
return iconCross;
case (SEC_DOWN | 2 | (SIDE_E << 4)):
return iconLeftTip;
case (SEC_DOWN | 3 | (SIDE_B << 4)):
return iconCross;
case (SEC_DOWN | 3 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_DOWN | 3 | (SIDE_N << 4)):
return iconLeftDown;
case (SEC_DOWN | 3 | (SIDE_S << 4)):
return iconRightDown;
case (SEC_DOWN | 3 | (SIDE_W << 4)):
return iconRightTip;
case (SEC_DOWN | 3 | (SIDE_E << 4)):
return iconCross;
case (SEC_UP | 0 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_UP | 0 | (SIDE_T << 4)):
return iconCross;
case (SEC_UP | 0 | (SIDE_N << 4)):
return iconCross;
case (SEC_UP | 0 | (SIDE_S << 4)):
return iconLeftTip;
case (SEC_UP | 0 | (SIDE_W << 4)):
return iconLeftUp;
case (SEC_UP | 0 | (SIDE_E << 4)):
return iconRightUp;
case (SEC_UP | 1 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_UP | 1 | (SIDE_T << 4)):
return iconCross;
case (SEC_UP | 1 | (SIDE_N << 4)):
return iconRightTip;
case (SEC_UP | 1 | (SIDE_S << 4)):
return iconCross;
case (SEC_UP | 1 | (SIDE_W << 4)):
return iconRightUp;
case (SEC_UP | 1 | (SIDE_E << 4)):
return iconLeftUp;
case (SEC_UP | 2 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_UP | 2 | (SIDE_T << 4)):
return iconCross;
case (SEC_UP | 2 | (SIDE_N << 4)):
return iconRightUp;
case (SEC_UP | 2 | (SIDE_S << 4)):
return iconLeftUp;
case (SEC_UP | 2 | (SIDE_W << 4)):
return iconCross;
case (SEC_UP | 2 | (SIDE_E << 4)):
return iconRightTip;
case (SEC_UP | 3 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_UP | 3 | (SIDE_T << 4)):
return iconCross;
case (SEC_UP | 3 | (SIDE_N << 4)):
return iconLeftUp;
case (SEC_UP | 3 | (SIDE_S << 4)):
return iconRightUp;
case (SEC_UP | 3 | (SIDE_W << 4)):
return iconLeftTip;
case (SEC_UP | 3 | (SIDE_E << 4)):
return iconCross;
case (SEC_HEAD | 0 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_HEAD | 0 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_HEAD | 0 | (SIDE_N << 4)):
return iconFace;
case (SEC_HEAD | 0 | (SIDE_S << 4)):
return iconCross;
case (SEC_HEAD | 0 | (SIDE_W << 4)):
return iconFaceLeft;
case (SEC_HEAD | 0 | (SIDE_E << 4)):
return iconFaceRight;
case (SEC_HEAD | 1 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_HEAD | 1 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_HEAD | 1 | (SIDE_N << 4)):
return iconCross;
case (SEC_HEAD | 1 | (SIDE_S << 4)):
return iconFace;
case (SEC_HEAD | 1 | (SIDE_W << 4)):
return iconFaceRight;
case (SEC_HEAD | 1 | (SIDE_E << 4)):
return iconFaceLeft;
case (SEC_HEAD | 2 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_HEAD | 2 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_HEAD | 2 | (SIDE_N << 4)):
return iconFaceRight;
case (SEC_HEAD | 2 | (SIDE_S << 4)):
return iconFaceLeft;
case (SEC_HEAD | 2 | (SIDE_W << 4)):
return iconFace;
case (SEC_HEAD | 2 | (SIDE_E << 4)):
return iconCross;
case (SEC_HEAD | 3 | (SIDE_B << 4)):
return iconBottomSide;
case (SEC_HEAD | 3 | (SIDE_T << 4)):
return iconTopTip;
case (SEC_HEAD | 3 | (SIDE_N << 4)):
return iconFaceLeft;
case (SEC_HEAD | 3 | (SIDE_S << 4)):
return iconFaceRight;
case (SEC_HEAD | 3 | (SIDE_W << 4)):
return iconCross;
case (SEC_HEAD | 3 | (SIDE_E << 4)):
return iconFace;
}
return iconCross;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public void getSubBlocks(Item item, CreativeTabs tabs, List list) {
list.add(new ItemStack(item, 1, 1));
list.add(new ItemStack(item, 1, 13));
}
@Override
public int damageDropped(int meta) {
if (meta < 4) {
return 1;
}
return 13;
}
@Override
public void registerBlockIcons(IIconRegister register) {
iconFaceLeft = register.registerIcon(iconPrefix + "face-left");
iconFaceRight = register.registerIcon(iconPrefix + "face-right");
iconFace = register.registerIcon(iconPrefix + "face");
iconLeftUp = register.registerIcon(iconPrefix + "left-up");
iconLeftDown = register.registerIcon(iconPrefix + "left-down");
iconLeftTip = register.registerIcon(iconPrefix + "left-tip");
iconRightUp = register.registerIcon(iconPrefix + "right-up");
iconRightDown = register.registerIcon(iconPrefix + "right-down");
iconRightTip = register.registerIcon(iconPrefix + "right-tip");
iconTop = register.registerIcon(iconPrefix + "top");
iconTopTip = register.registerIcon(iconPrefix + "top-tip");
iconTopSide = register.registerIcon(iconPrefix + "top-side");
iconBottom = register.registerIcon(iconPrefix + "bot");
iconBottomTip = register.registerIcon(iconPrefix + "bot-tip");
iconBottomSide = register.registerIcon(iconPrefix + "bot-side");
iconCross = register.registerIcon(iconPrefix + "crosssection");
iconSide = register.registerIcon(iconPrefix + "side");
}
}
@@ -0,0 +1,35 @@
package team.chisel.block;
import java.util.Random;
import team.chisel.client.GeneralChiselClient;
import net.minecraft.client.renderer.texture.IIconRegister;
import net.minecraft.util.IIcon;
import net.minecraft.world.World;
public class BlockSnakestoneObsidian extends BlockSnakestone {
public static IIcon[] particles = new IIcon[8];
public BlockSnakestoneObsidian(String iconPrefix) {
super(iconPrefix);
flipTopTextures = true;
}
@Override
public void randomDisplayTick(World world, int x, int y, int z, Random random) {
GeneralChiselClient.spawnSnakestoneObsidianFX(world, this, x, y, z);
}
@Override
public void registerBlockIcons(IIconRegister register) {
super.registerBlockIcons(register);
for (int i = 0; i < particles.length; i++) {
particles[i] = register.registerIcon(iconPrefix + "particles/" + i);
}
}
}
@@ -0,0 +1,15 @@
package team.chisel.block;
import net.minecraft.block.material.Material;
public class BlockWaterstone extends BlockMultiLayer {
public BlockWaterstone(Material mat, String baseIcon) {
super(mat, baseIcon);
}
@Override
public boolean renderAsNormalBlock() {
return true;
}
}
@@ -0,0 +1,45 @@
package team.chisel.block;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import com.cricketcraft.chisel.api.carving.IVariationInfo;
import team.chisel.init.ChiselTabs;
import team.chisel.item.ItemCarvable;
import net.minecraft.block.Block;
import net.minecraft.item.ItemStack;
import cpw.mods.fml.common.registry.GameRegistry;
public class CarvableStairsMaker {
public CarvableHelper carverHelper;
// int idStart;
Block blockBase;
String blockName;
public CarvableStairsMaker(Block base) {
carverHelper = new CarvableHelper(base);
blockBase = base;
}
public void create(String name, Block[] blocks) {
create(null, name, blocks);
}
public void create(IStairsCreator creator, String name, Block[] blocks) {
for (int i = 0; i < blocks.length; i++) {
String n = name + "." + i;
blocks[i] = creator == null ? new BlockCarvableStairs(blockBase, i * 2, carverHelper) : creator.create(blockBase, i * 2, carverHelper);
blocks[i].setBlockName("chisel." + n).setCreativeTab(ChiselTabs.tabStairChiselBlocks);
GameRegistry.registerBlock(blocks[i], ItemCarvable.class, n);
for (int meta = 0; meta < 2 && i * 2 + meta < carverHelper.infoList.size(); meta++) {
IVariationInfo info = carverHelper.infoList.get(i * 2 + meta);
carverHelper.registerVariation(name, info);
GameRegistry.addRecipe(new ItemStack(blocks[i], 4, meta * 8), "* ", "** ", "***", '*', new ItemStack(blockBase, 1, i * 2 + meta));
}
}
}
}
@@ -0,0 +1,10 @@
package team.chisel.block;
import com.cricketcraft.chisel.api.carving.CarvableHelper;
import net.minecraft.block.Block;
public interface IStairsCreator {
public BlockCarvableStairs create(Block block, int meta, CarvableHelper helper);
}
@@ -0,0 +1,29 @@
package team.chisel.block.tileentity;
import net.minecraft.item.ItemStack;
public interface IDoubleChest {
/**
* @return The size of this specific chest's inventory. Does not account for the connection.
*/
int getTrueSizeInventory();
/**
* @param slot
* The true slot index.
* @return The actual stack in this chest's slot. Does not account for the connection.
*/
ItemStack getTrueStackInSlot(int slot);
/**
* Puts a stack in this chest's real slot at the given true index.
*
* @param slot
* The true slot index.
* @param stack
* The ItemStack to place in the slot.
*/
void putStackInTrueSlot(int slot, ItemStack stack);
}
@@ -0,0 +1,450 @@
package team.chisel.block.tileentity;
import java.util.List;
import com.cricketcraft.chisel.api.IChiselItem;
import team.chisel.carving.Carving;
import team.chisel.client.GeneralChiselClient;
import team.chisel.init.ChiselItems;
import team.chisel.network.PacketHandler;
import team.chisel.network.message.MessageAutoChisel;
import team.chisel.network.message.MessageSlotUpdate;
import team.chisel.utils.General;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.StatCollector;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class TileEntityAutoChisel extends TileEntity implements ISidedInventory {
public enum Upgrade {
SPEED,
AUTOMATION,
STACK,
REVERSION;
public String getUnlocalizedName() {
return ChiselItems.upgrade.getUnlocalizedName() + "_" + this.name().toLowerCase();
}
public String getLocalizedName() {
return StatCollector.translateToLocal(getUnlocalizedName() + ".name");
}
}
public static final int BASE = 0, TARGET = 1, OUTPUT = 2, CHISEL = 3, MIN_UPGRADE = 4;
private static final int FAST_SPEED = 1, SLOW_SPEED = 4;
private int progress = 0;
private static EntityItem ghostItem;
boolean equal = false;
private ItemStack[] inventory = new ItemStack[8];
private String name = "autoChisel";
// client animation fields
// used for floating target
public float xRot, yRot, zRot;
// used for chisel item rotation
public static final int maxRot = 60;
public static final int rotAmnt = 15;
public float chiselRot;
public boolean chiseling = false, breakChisel = false;;
public int toChisel = 1;
private ItemStack lastBase;
@Override
public boolean canUpdate() {
return true;
}
@Override
public ItemStack decrStackSize(int slot, int size) {
if (inventory[slot] != null) {
ItemStack is;
if (inventory[slot].stackSize <= size) {
is = inventory[slot];
inventory[slot] = null;
return is;
} else {
is = inventory[slot].splitStack(size);
if (inventory[slot].stackSize == 0)
inventory[slot] = null;
return is;
}
} else
return null;
}
@Override
public void readFromNBT(NBTTagCompound nbt) {
super.readFromNBT(nbt);
NBTTagList tags = nbt.getTagList("Items", 10);
inventory = new ItemStack[getSizeInventory()];
for (int i = 0; i < tags.tagCount(); i++) {
NBTTagCompound data = tags.getCompoundTagAt(i);
int j = data.getByte("Slot") & 255;
if (j >= 0 && j < inventory.length) {
inventory[j] = ItemStack.loadItemStackFromNBT(data);
}
}
if (nbt.hasKey("CustomName", 8)) {
this.name = nbt.getString("CustomName");
}
}
@Override
public void updateEntity() {
ItemStack base = inventory[BASE], target = getTarget(), output = inventory[OUTPUT];
if (!worldObj.isRemote && hasChisel() && base != null && target != null) {
if (canBeMadeFrom(base, target)) {
if (progress >= (hasUpgrade(Upgrade.SPEED) ? FAST_SPEED : SLOW_SPEED)) {
// reset progress
progress = 0;
// the max possible for this craft
int canBeMade = target.getMaxStackSize();
// if there are items in the output, they count towards the max we can make
if (output != null) {
canBeMade -= output.stackSize;
}
// can't make more than we have
canBeMade = Math.min(base.stackSize, canBeMade);
// if we can't make any, forget it
if (canBeMade <= 0) {
return;
}
// result will always be a copy of the target
ItemStack chiseled = target.copy();
// if we have the stack upgrade, boost the stack size to the max possible, otherwise just one
chiseled.stackSize = hasUpgrade(Upgrade.STACK) ? canBeMade : 1;
if (canChisel(chiseled)) {
// if our output is empty, just use the current result
if (output == null) {
setInventorySlotContents(OUTPUT, chiseled);
} else {
// otherwise just add our result to the existing stack
inventory[OUTPUT].stackSize += chiseled.stackSize;
slotChanged(OUTPUT);
}
chiselItem(chiseled.stackSize, target);
// remove what we made from the stack
base.stackSize -= chiseled.stackSize;
if (base.stackSize <= 0) {
setInventorySlotContents(BASE, null); // clear out 0 size itemstacks
}
}
} else if (worldObj.getTotalWorldTime() % 10 == 0) {
progress++;
}
}
} else if (worldObj.isRemote) {
if (chiseling) {
chiselRot += rotAmnt;
if (chiselRot >= maxRot) {
chiselItem(0, getTarget());
}
} else {
chiselRot = Math.max(chiselRot - rotAmnt, 0);
}
}
}
private ItemStack getTarget() {
if (inventory[BASE] != null && hasUpgrade(Upgrade.REVERSION)) {
// if we have a reversion upgrade, use that for the target
List<ItemStack> possible = Carving.chisel.getItemsForChiseling(inventory[BASE]);
return possible.isEmpty() ? null : possible.get(0);
} else {
return inventory[TARGET];
}
}
// lets make sure the user isn't trying to make something from a block that doesn't have this as a valid target
private boolean canBeMadeFrom(ItemStack from, ItemStack to) {
List<ItemStack> results = Carving.chisel.getItemsForChiseling(from);
for (ItemStack s : results) {
if (s.getItem() == to.getItem() && s.getItemDamage() == to.getItemDamage()) {
return true;
}
}
return false;
}
private boolean canChisel(ItemStack toMerge) {
// if the output slot is empty we can merge without checking
if (inventory[OUTPUT] == null) {
return true;
}
// need to check NBT as well as item
if (!toMerge.isItemEqual(inventory[OUTPUT]) || !ItemStack.areItemStackTagsEqual(toMerge, inventory[OUTPUT])) {
return false;
}
// we only care about metadata if the item has subtypes
if (toMerge.getHasSubtypes() && toMerge.getItemDamage() != inventory[OUTPUT].getItemDamage()) {
return false;
}
return ((IChiselItem) inventory[CHISEL].getItem()).canChisel(worldObj, inventory[CHISEL], General.getVariation(getTarget()));
}
private boolean hasChisel() {
return inventory[CHISEL] != null && inventory[CHISEL].getItem() instanceof IChiselItem && inventory[CHISEL].stackSize >= 1;
}
/** Calls IChiselItem#onChisel() and sends the chisel packet for sound/animation */
private void chiselItem(int chiseled, ItemStack target) {
if (!worldObj.isRemote) {
boolean breakChisel = false;
if (((IChiselItem) inventory[CHISEL].getItem()).onChisel(worldObj, inventory[CHISEL], General.getVariation(target))) {
inventory[CHISEL].setItemDamage(inventory[CHISEL].getItemDamage() + 1);
if (inventory[CHISEL].getItemDamage() >= inventory[CHISEL].getMaxDamage()) {
setInventorySlotContents(CHISEL, null);
breakChisel = true;
}
}
PacketHandler.INSTANCE.sendToDimension(new MessageAutoChisel(this, chiseled, true, breakChisel), worldObj.provider.dimensionId);
} else {
if (breakChisel) {
worldObj.playSound(xCoord + 0.5, yCoord + 0.5, zCoord + 0.5, "random.break", 0.8F, 0.8F + worldObj.rand.nextFloat() * 0.4F, false);
}
GeneralChiselClient.spawnAutoChiselFX(this, lastBase != null ? lastBase : inventory[BASE]);
chiseling = false;
if (lastBase != null) {
lastBase.stackSize -= toChisel;
if (lastBase.stackSize <= 0) {
lastBase = null;
}
}
}
}
@Override
public void writeToNBT(NBTTagCompound nbt) {
super.writeToNBT(nbt);
NBTTagList tags = new NBTTagList();
for (int i = 0; i < inventory.length; i++) {
if (inventory[i] != null) {
NBTTagCompound data = new NBTTagCompound();
data.setByte("Slot", (byte) i);
inventory[i].writeToNBT(data);
tags.appendTag(data);
}
}
nbt.setTag("Items", tags);
if (this.hasCustomInventoryName()) {
nbt.setString("CustomName", this.name);
}
}
@Override
public int getSizeInventory() {
return inventory.length;
}
@Override
public ItemStack getStackInSlot(int slot) {
return inventory[slot];
}
@Override
public ItemStack getStackInSlotOnClosing(int slot) {
if (inventory[slot] != null) {
ItemStack is = inventory[slot];
inventory[slot] = null;
return is;
} else
return null;
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack) {
inventory[slot] = stack;
if (stack != null && stack.stackSize > getInventoryStackLimit()) {
stack.stackSize = getInventoryStackLimit();
}
if (worldObj.isRemote && slot == BASE && stack != null) {
lastBase = stack.copy();
}
if (!worldObj.isRemote) {
slotChanged(slot);
}
}
private void slotChanged(int slot) {
PacketHandler.INSTANCE.sendToDimension(new MessageSlotUpdate(this, slot, inventory[slot]), worldObj.provider.dimensionId);
markDirty();
}
@Override
public String getInventoryName() {
return name;
}
@Override
public final boolean isUseableByPlayer(EntityPlayer player) {
return true;
}
@Override
public int getInventoryStackLimit() {
return 64;
}
@Override
public boolean hasCustomInventoryName() {
return false;
}
@Override
public int[] getAccessibleSlotsFromSide(int side) {
return new int[] { BASE, TARGET, OUTPUT, CHISEL };
}
@Override
public boolean isItemValidForSlot(int slot, ItemStack itemStack) {
if (itemStack == null) {
return false;
}
switch (slot) {
case BASE:
case TARGET:
return !Carving.chisel.getItemsForChiseling(itemStack).isEmpty();
case OUTPUT:
return false;
case CHISEL:
return itemStack.getItem() instanceof IChiselItem;
default:
return itemStack.getItem() == ChiselItems.upgrade && Upgrade.values()[slot - MIN_UPGRADE].ordinal() == itemStack.getItemDamage();
}
}
@Override
public boolean canInsertItem(int slot, ItemStack itemStack, int side) {
return hasUpgrade(Upgrade.AUTOMATION) && (slot == BASE || slot == TARGET || slot == CHISEL);
}
@Override
public boolean canExtractItem(int slot, ItemStack itemStack, int side) {
return hasUpgrade(Upgrade.AUTOMATION) && slot == OUTPUT;
}
@Override
public void openInventory() {
;
}
@Override
public void closeInventory() {
;
}
@SideOnly(Side.CLIENT)
public EntityItem getItemForRendering(int slot) {
if (ghostItem == null) {
ghostItem = new EntityItem(worldObj);
ghostItem.hoverStart = 0.0F;
}
if (slot == BASE && lastBase != null) {
ghostItem.setEntityItemStack(lastBase.copy());
return ghostItem;
} else if (slot == TARGET) {
ItemStack target = getTarget();
if (target != null) {
ghostItem.setEntityItemStack(target);
return ghostItem;
}
return null;
} else if (inventory[slot] == null) {
return null;
} else {
ghostItem.setEntityItemStack(inventory[slot].copy());
return ghostItem;
}
}
@Override
public Packet getDescriptionPacket() {
NBTTagCompound tag = new NBTTagCompound();
writeToNBT(tag);
return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag);
}
@Override
public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) {
readFromNBT(packet.func_148857_g());
}
public boolean hasUpgrade(Upgrade upgrade) {
ItemStack stack = inventory[MIN_UPGRADE + upgrade.ordinal()];
if (stack != null) {
return stack.getItem() == ChiselItems.upgrade && stack.getItemDamage() == upgrade.ordinal();
}
return false;
}
public String getSlotTooltipUnloc(int slotNumber) {
String base = "autochisel.slot.%s.tooltip";
String name = null;
if (slotNumber < MIN_UPGRADE) {
if (slotNumber == TARGET) {
name = "target";
} else if (slotNumber == CHISEL) {
name = "chisel";
}
return name == null ? null : String.format(base, name);
} else {
return Upgrade.values()[slotNumber - MIN_UPGRADE].getUnlocalizedName() + ".name";
}
}
public void doChiselAnim(ItemStack lastChiseled, int chiseled, boolean playSound, boolean breakChisel) {
this.lastBase = lastChiseled == null ? null : lastChiseled.copy();
this.toChisel = chiseled;
if (playSound) {
this.chiseling = true;
}
this.breakChisel = breakChisel;
}
public ItemStack getLastBase() {
return lastBase == null ? null : lastBase.copy();
}
}
@@ -0,0 +1,15 @@
package team.chisel.block.tileentity;
import net.minecraft.tileentity.TileEntityBeacon;
import net.minecraft.util.AxisAlignedBB;
import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
public class TileEntityCarvableBeacon extends TileEntityBeacon {
@Override
@SideOnly(Side.CLIENT)
public AxisAlignedBB getRenderBoundingBox() {
return INFINITE_EXTENT_AABB;
}
}
@@ -0,0 +1,365 @@
package team.chisel.block.tileentity;
import team.chisel.init.ChiselBlocks;
import team.chisel.network.PacketHandler;
import team.chisel.network.message.MessagePresentConnect;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.AxisAlignedBB;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
public class TileEntityPresent extends TileEntity implements IInventory, IDoubleChest {
private TileEntityPresent connection = null;
// If cachedDir is non-null, but connection is null, this present must be
// connected to an unloaded present. This is handled appropriately.
private ForgeDirection cachedDir = null;
private boolean isParent;
private final ItemStack[] inventory = new ItemStack[27];
private int rotation;
private boolean autoSearch = true;
@Override
public void updateEntity() {
if (!isConnected() && autoSearch && worldObj != null /* ugh */) {
if (cachedDir != null) {
connectTo(cachedDir);
} else if (!worldObj.isRemote) {
findConnections();
}
autoSearch = false;
}
}
public boolean isConnected() {
return connection != null;
}
private boolean connectTo(TileEntityPresent present, ForgeDirection dir) {
if (present.getBlockMetadata() == getBlockMetadata() && !present.isConnected() && (present.cachedDir == null || present.cachedDir == dir.getOpposite())
&& Math.abs(present.xCoord - xCoord + present.yCoord - yCoord + present.zCoord - zCoord) == 1) {
connection = present;
connection.connection = this;
connection.cachedDir = dir.getOpposite();
connection.markDirty();
cachedDir = dir;
isParent = !present.isParent;
markDirty();
PacketHandler.INSTANCE.sendToDimension(new MessagePresentConnect(this, dir, true), worldObj.provider.dimensionId);
return true;
}
return false;
}
public boolean connectTo(ForgeDirection dir) {
int x = xCoord + dir.offsetX, y = yCoord + dir.offsetY, z = zCoord + dir.offsetZ;
TileEntity te = getTileSafe(x, y, z);
if (te instanceof TileEntityPresent) {
return connectTo((TileEntityPresent) te, dir);
}
return !exists(x, y, z);
}
/**
* @param preserveDir
* If true, this is only a virtual disconnect, meaning the other chest still exists, but is still loaded, so maintain a cachedDir for reconnection upon chunk load.
*/
public void disconnect(boolean preserveDir) {
if (isConnected()) {
if (!preserveDir) {
this.connection.cachedDir = null;
this.cachedDir = null;
}
this.connection.connection = null;
this.connection.markDirty();
this.connection = null;
this.markDirty();
PacketHandler.INSTANCE.sendToDimension(new MessagePresentConnect(this, ForgeDirection.UNKNOWN, false, preserveDir), worldObj.provider.dimensionId);
}
}
public TileEntityPresent getConnection() {
return connection;
}
public ForgeDirection getConnectionDir() {
return cachedDir == null ? ForgeDirection.UNKNOWN : cachedDir;
}
public boolean isParent() {
return isParent || !isConnected();
}
public int getRotation() {
return rotation;
}
public void setRotation(int rot) {
this.rotation = rot;
}
public void findConnections() {
if (!isConnected()) {
if (cachedDir != null) {
if (connectTo(cachedDir)) {
return;
}
}
for (ForgeDirection dir : ForgeDirection.VALID_DIRECTIONS) {
if (dir != ForgeDirection.UP && dir != ForgeDirection.DOWN) {
if (connectTo(dir)) {
return;
}
}
}
}
}
public TileEntityPresent getParent() {
return isParent || connection == null ? this : connection;
}
@Override
public AxisAlignedBB getRenderBoundingBox() {
return ChiselBlocks.present.getBoundingBox(this);
}
@Override
public void writeToNBT(NBTTagCompound tag) {
super.writeToNBT(tag);
NBTTagList nbttaglist = new NBTTagList();
for (int i = 0; i < getTrueSizeInventory(); ++i) {
if (inventory[i] != null) {
NBTTagCompound nbttagcompound1 = new NBTTagCompound();
nbttagcompound1.setByte("Slot", (byte) i);
inventory[i].writeToNBT(nbttagcompound1);
nbttaglist.appendTag(nbttagcompound1);
}
}
tag.setTag("Items", nbttaglist);
tag.setBoolean("isParent", isParent);
tag.setInteger("rotation", rotation);
if (cachedDir != null) {
tag.setInteger("conDir", cachedDir.ordinal());
}
}
@Override
public void readFromNBT(NBTTagCompound tag) {
super.readFromNBT(tag);
NBTTagList nbttaglist = tag.getTagList("Items", 10);
for (int i = 0; i < nbttaglist.tagCount(); ++i) {
NBTTagCompound nbttagcompound1 = nbttaglist.getCompoundTagAt(i);
int j = nbttagcompound1.getByte("Slot") & 255;
if (j >= 0 && j < getTrueSizeInventory()) {
inventory[j] = ItemStack.loadItemStackFromNBT(nbttagcompound1);
}
}
this.isParent = tag.getBoolean("isParent");
this.rotation = tag.getInteger("rotation");
if (tag.hasKey("conDir")) {
cachedDir = ForgeDirection.values()[tag.getInteger("conDir")];
}
autoSearch = true;
}
@Override
public Packet getDescriptionPacket() {
NBTTagCompound tag = new NBTTagCompound();
writeToNBT(tag);
return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag);
}
@Override
public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity packet) {
readFromNBT(packet.func_148857_g());
}
@Override
public boolean shouldRefresh(Block oldBlock, Block newBlock, int oldMeta, int newMeta, World world, int x, int y, int z) {
// prevent losing TE data when in-world chiseling
return oldBlock != newBlock;
}
@Override
public void invalidate() {
super.invalidate();
if (isConnected()) {
disconnect(false);
}
}
@Override
public void onChunkUnload() {
super.onChunkUnload();
if (isConnected()) {
disconnect(true);
}
}
private int getAdjustedSlot(int slot) {
slot %= getSizeInventory();
if (isConnected() && !isParent) {
slot = (slot + getTrueSizeInventory()) % getSizeInventory();
}
return slot;
}
private TileEntity getTileSafe(int x, int y, int z) {
if (exists(x, y, z)) {
return worldObj.getTileEntity(x, y, z);
}
return null;
}
// private Block getBlockSafe(int x, int y, int z) {
// if (exists(x, y, z)) {
// return worldObj.getBlock(x, y, z);
// }
// return null;
// }
//
// private int getMetaSafe(int x, int y, int z) {
// if (exists(x, y, z)) {
// return worldObj.getBlockMetadata(x, y, z);
// }
// return 0;
// }
//
private boolean exists(int x, int y, int z) {
return worldObj.blockExists(x, y, z);
}
/* IInventory */
@Override
public int getSizeInventory() {
return isConnected() ? getTrueSizeInventory() + connection.getTrueSizeInventory() : getTrueSizeInventory();
}
@Override
public ItemStack getStackInSlot(int slot) {
slot = getAdjustedSlot(slot);
if (slot >= getTrueSizeInventory()) {
return isConnected() ? connection.inventory[slot % getTrueSizeInventory()] : null;
} else {
return inventory[slot];
}
}
@Override
public ItemStack decrStackSize(int slot, int amount) {
slot = getAdjustedSlot(slot);
ItemStack[] inv = inventory;
if (isConnected() && slot >= getTrueSizeInventory()) {
inv = connection.inventory;
slot %= getTrueSizeInventory();
connection.markDirty();
}
if (inv[slot] != null) {
ItemStack itemstack;
if (inv[slot].stackSize <= amount) {
itemstack = inv[slot];
inv[slot] = null;
this.markDirty();
return itemstack;
} else {
itemstack = inv[slot].splitStack(amount);
if (inv[slot].stackSize == 0) {
inv[slot] = null;
}
this.markDirty();
return itemstack;
}
} else {
return null;
}
}
@Override
public ItemStack getStackInSlotOnClosing(int slot) {
return getStackInSlot(slot);
}
@Override
public void setInventorySlotContents(int slot, ItemStack stack) {
slot = getAdjustedSlot(slot);
if (slot < getTrueSizeInventory()) {
inventory[slot] = stack;
} else if (isConnected()) {
connection.inventory[slot % getTrueSizeInventory()] = stack;
connection.markDirty();
}
}
@Override
public String getInventoryName() {
return "chisel.present";
}
@Override
public boolean hasCustomInventoryName() {
return false;
}
@Override
public int getInventoryStackLimit() {
return 64;
}
@Override
public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
return true;
}
@Override
public void openInventory() {
;
}
@Override
public void closeInventory() {
;
}
@Override
public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) {
return true;
}
/* IDoubleChest */
@Override
public int getTrueSizeInventory() {
return inventory.length;
}
@Override
public ItemStack getTrueStackInSlot(int slot) {
return inventory[slot % getTrueSizeInventory()];
}
@Override
public void putStackInTrueSlot(int slot, ItemStack stack) {
inventory[slot % getTrueSizeInventory()] = stack;
}
}