diff --git a/assets/tinker/lang/en_US.xml b/assets/tinker/lang/en_US.xml index 10c456be..ab91853a 100644 --- a/assets/tinker/lang/en_US.xml +++ b/assets/tinker/lang/en_US.xml @@ -27,6 +27,7 @@ Slimy Mud Graveyard Soil Consecrated Soil + Casting Channel Netherack Slag Cobalt Ore @@ -125,6 +126,30 @@ Golden Head Spawn + Pickaxe + Shovel + Hatchet + Broadsword + Longsword + Rapier + Frying Pan + Battlesign + Dagger + Chisel + Scythe + Lumber Axe + Cleaver + Excavator + Hammer + Battleaxe + Cutlass + Shortbow + Arrow + Potion Launcher + + Blank Pattern + Blank Cast + Paper Stack Slime Crystal Seared Brick @@ -422,6 +447,7 @@ %1$s will be a stepping stone for our revolution! %1$s thought swimming in hot liquids was a good idea +<<<<<<< HEAD:assets/tinker/lang/en_US.xml Wooden Stone Iron @@ -439,6 +465,53 @@ Alumite Steel Slime +======= + Wooden + Stone + Iron + Flint + Cactus + Bone + Obsidian + Slime + Paper + Netherrack + Cobalt + Ardite + Manyullyn + Copper + Bronze + Alumite + Steel + Slime + Thaumium + + Tool Rod + Pickaxe Head + Shovel Head + Axe Head + Binding + Tough Binding + Tough Rod + Large Plate + Sword Blade + Large Guard + Medium Guard + Crossbar + Knife Blade + Full Guard + Pan + Sign Head + Chisel Head + Scythe Head + Broad Axe Head + Excavator Head + Large Sword Blade + Hammer Head + Bowstring + Arrowhead + Fletching +>>>>>>> Light Aggregator:mods/tinker/resources/lang/en_US.xml Molten Iron Molten Gold @@ -465,4 +538,8 @@ Molten Shiny Liquid Ender +<<<<<<< HEAD:assets/tinker/lang/en_US.xml +======= + +>>>>>>> Light Aggregator:mods/tinker/resources/lang/en_US.xml diff --git a/assets/tinker/textures/blocks/machines/aggregator_glowstone_bottom.png b/assets/tinker/textures/blocks/machines/aggregator_glowstone_bottom.png index 59e8b792..2ef1d5ce 100644 Binary files a/assets/tinker/textures/blocks/machines/aggregator_glowstone_bottom.png and b/assets/tinker/textures/blocks/machines/aggregator_glowstone_bottom.png differ diff --git a/assets/tinker/textures/blocks/machines/aggregator_glowstone_side.png b/assets/tinker/textures/blocks/machines/aggregator_glowstone_side.png index 7b118c87..f437de04 100644 Binary files a/assets/tinker/textures/blocks/machines/aggregator_glowstone_side.png and b/assets/tinker/textures/blocks/machines/aggregator_glowstone_side.png differ diff --git a/assets/tinker/textures/blocks/machines/aggregator_glowstone_top.png b/assets/tinker/textures/blocks/machines/aggregator_glowstone_top.png index f2fa885c..a9ed0dee 100644 Binary files a/assets/tinker/textures/blocks/machines/aggregator_glowstone_top.png and b/assets/tinker/textures/blocks/machines/aggregator_glowstone_top.png differ diff --git a/assets/tinker/textures/blocks/machines/aggregator_glowstone_top_inactive.png b/assets/tinker/textures/blocks/machines/aggregator_glowstone_top_inactive.png index e6d017be..995933f4 100644 Binary files a/assets/tinker/textures/blocks/machines/aggregator_glowstone_top_inactive.png and b/assets/tinker/textures/blocks/machines/aggregator_glowstone_top_inactive.png differ diff --git a/mods/tinker/textures/blocks/blank.png b/mods/tinker/textures/blocks/blank.png new file mode 100644 index 00000000..827bd32d Binary files /dev/null and b/mods/tinker/textures/blocks/blank.png differ diff --git a/mods/tinker/textures/blocks/machines/lightstone.png b/mods/tinker/textures/blocks/machines/lightstone.png new file mode 100644 index 00000000..52f33ce2 Binary files /dev/null and b/mods/tinker/textures/blocks/machines/lightstone.png differ diff --git a/tconstruct/blocks/Aggregator.java b/tconstruct/blocks/Aggregator.java index 3f069be5..48cc9559 100644 --- a/tconstruct/blocks/Aggregator.java +++ b/tconstruct/blocks/Aggregator.java @@ -2,13 +2,6 @@ package tconstruct.blocks; import java.util.List; -import tconstruct.TConstruct; -import tconstruct.blocks.logic.GlowstoneAggregator; -import tconstruct.common.TProxyCommon; -import tconstruct.crystal.TheftValueTracker; -import tconstruct.library.TConstructRegistry; -import tconstruct.library.blocks.InventoryBlock; - import net.minecraft.block.material.Material; import net.minecraft.client.renderer.texture.IconRegister; import net.minecraft.creativetab.CreativeTabs; @@ -19,6 +12,12 @@ import net.minecraft.tileentity.TileEntity; import net.minecraft.util.Icon; import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; +import tconstruct.TConstruct; +import tconstruct.blocks.logic.LightAggregator; +import tconstruct.common.TProxyCommon; +import tconstruct.crystal.TheftValueTracker; +import tconstruct.library.TConstructRegistry; +import tconstruct.library.blocks.InventoryBlock; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -32,7 +31,7 @@ public class Aggregator extends InventoryBlock super(id, Material.iron); setHardness(2.0f); this.setCreativeTab(TConstructRegistry.blockTab); - setLightValue(1.0f); + //setLightValue(1.0f); } @Override @@ -58,7 +57,7 @@ public class Aggregator extends InventoryBlock { if (side == 1) { - GlowstoneAggregator logic = (GlowstoneAggregator) iblockaccess.getBlockTileEntity(x, y, z); + LightAggregator logic = (LightAggregator) iblockaccess.getBlockTileEntity(x, y, z); if (logic.getActive()) return icons[0]; else @@ -83,15 +82,47 @@ public class Aggregator extends InventoryBlock public void onBlockPlacedBy (World world, int x, int y, int z, EntityLivingBase entityliving, ItemStack stack) { super.onBlockPlacedBy(world, x, y, z, entityliving, stack); - if (!world.isRemote) - TheftValueTracker.updateCrystallinity(world.provider.dimensionId, x, z, 4); + /*int range = 9; + for (int xPos = -range; xPos <= range; xPos++) + { + for (int yPos = -range; yPos <= range; yPos++) + { + for (int zPos = -range; zPos <= range; zPos++) + { + if (Math.abs(xPos) + Math.abs(yPos) + Math.abs(zPos) <= range) + { + Block block = Block.blocksList[world.getBlockId(x + xPos, y + yPos, z + zPos)]; + if (block == null || block.isAirBlock(world, x + xPos, y + yPos, z + zPos)) + world.setBlock(x + xPos, y + yPos, z + zPos, TContent.darkBlock.blockID, 1, 3); + } + } + } + }*/ + /*if (!world.isRemote) + Crystallinity.updateCrystallinity(world.provider.dimensionId, x, z, 4);*/ } @Override public void breakBlock (World world, int x, int y, int z, int par5, int par6) { super.breakBlock(world, x, y, z, par5, par6); - TheftValueTracker.updateCrystallinity(world.provider.dimensionId, x, z, -4); + /*int range = 20; + for (int xPos = -range; xPos <= range; xPos++) + { + for (int yPos = -range; yPos <= range; yPos++) + { + for (int zPos = -range; zPos <= range; zPos++) + { + if (Math.abs(xPos) + Math.abs(yPos) + Math.abs(zPos) <= range) + { + Block block = Block.blocksList[world.getBlockId(x + xPos, y + yPos, z + zPos)]; + if (block == TContent.darkBlock || block == TContent.lightCrystalBase) + world.setBlock(x + xPos, y + yPos, z + zPos, 0, 0, 3); + } + } + } + }*/ + //Crystallinity.updateCrystallinity(world.provider.dimensionId, x, z, -4); } @Override @@ -107,7 +138,7 @@ public class Aggregator extends InventoryBlock @Override public TileEntity createTileEntity (World world, int metadata) { - return new GlowstoneAggregator(); + return new LightAggregator(); } @Override @@ -128,9 +159,9 @@ public class Aggregator extends InventoryBlock return textureNames; } - public void updateCrystalValue (World world, int x, int y, int z) + /*public void updateCrystalValue (World world, int x, int y, int z) { GlowstoneAggregator logic = (GlowstoneAggregator) world.getBlockTileEntity(x, y, z); logic.updateCrystalValue(); - } + }*/ } diff --git a/tconstruct/blocks/AntiLight.java b/tconstruct/blocks/AntiLight.java new file mode 100644 index 00000000..1e72b356 --- /dev/null +++ b/tconstruct/blocks/AntiLight.java @@ -0,0 +1,74 @@ +package tconstruct.blocks; + +import net.minecraft.block.Block; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.util.AxisAlignedBB; +import net.minecraft.world.Explosion; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +public class AntiLight extends Block +{ + public AntiLight(int id) + { + super(id, Material.air); + float f = 0.0F; + float f1 = 0.0F; + this.setBlockBounds(0.0F + f1, 0.0F + f, 0.0F + f1, 1.0F + f1, 1.0F + f, 1.0F + f1); + } + + @Override + public int getLightOpacity(World world, int x, int y, int z) + { + return world.getBlockMetadata(x, y, z); + } + + @Override + public boolean isAirBlock(World world, int x, int y, int z) + { + return true; + } + + @Override + public boolean renderAsNormalBlock() + { + return false; + } + + @Override + public boolean isOpaqueCube() + { + return false; + } + + @Override + @SideOnly(Side.CLIENT) + public void registerIcons(IconRegister par1IconRegister) + { + this.blockIcon = par1IconRegister.registerIcon("tinker:blank"); + } + + @Override + public AxisAlignedBB getCollisionBoundingBoxFromPool (World world, int x, int y, int z) + { + return null; + } + + public boolean canCollideCheck(int par1, boolean par2) + { + return false; + } + + public boolean shouldSideBeRendered(IBlockAccess par1IBlockAccess, int par2, int par3, int par4, int par5) + { + return false; + } + + public void onBlockExploded(World world, int x, int y, int z, Explosion explosion) + { + + } +} diff --git a/tconstruct/blocks/CrystalBlock.java b/tconstruct/blocks/CrystalBlock.java new file mode 100644 index 00000000..f93f6811 --- /dev/null +++ b/tconstruct/blocks/CrystalBlock.java @@ -0,0 +1,213 @@ +package tconstruct.blocks; + +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.block.BlockContainer; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.Icon; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import tconstruct.blocks.logic.CrystalLogic; +import tconstruct.blocks.logic.LightAggregator; +import tconstruct.client.block.CrystalBlockRender; +import tconstruct.common.TContent; +import tconstruct.crystal.Crystallinity; +import tconstruct.crystal.Crystallinity.CrystalType; +import tconstruct.library.TConstructRegistry; + +public class CrystalBlock extends BlockContainer +{ + String[] textureNames = { "lightstone" }; + Icon[] icons; + + public CrystalBlock(int id) + { + super(id, Material.glass); + this.setCreativeTab(TConstructRegistry.blockTab); + } + + @Override + public Icon getIcon (int side, int meta) + { + return icons[0]; + } + + @Override + public boolean renderAsNormalBlock () + { + return false; + } + + @Override + public boolean isOpaqueCube () + { + return false; + } + + @Override + public int getRenderType () + { + return CrystalBlockRender.model; + } + + @Override + public void getSubBlocks (int id, CreativeTabs tab, List list) + { + for (int iter = 0; iter < 16; iter++) + { + list.add(new ItemStack(id, 1, iter)); + } + } + + @Override + public void registerIcons (IconRegister iconRegister) + { + this.icons = new Icon[textureNames.length]; + + for (int i = 0; i < this.icons.length; ++i) + { + this.icons[i] = iconRegister.registerIcon("tinker:machines/" + textureNames[i]); + } + } + + @Override + public TileEntity createNewTileEntity (World world) + { + return null; + } + + @Override + public TileEntity createTileEntity (World world, int metadata) + { + return new CrystalLogic(); + } + + @Override + public int getLightValue (IBlockAccess world, int x, int y, int z) + { + if (world.getBlockMetadata(x, y, z) == 0) + { + TileEntity logic = world.getBlockTileEntity(x, y, z); + + if (logic != null && logic instanceof CrystalLogic) + { + if (((CrystalLogic) logic).getActive()) + { + return 15; + } + } + } + return super.getLightValue(world, x, y, z); + } + + /*@Override + public void breakBlock (World world, int x, int y, int z, int par5, int meta) + { + if (meta <= 4) + { + TileEntity logic = world.getBlockTileEntity(x, y, z); + + if (logic != null && logic instanceof CrystalLogic) + { + + } + } + }*/ + + public boolean removeBlockByPlayer (World world, EntityPlayer player, int x, int y, int z) + { + player.addExhaustion(0.025F); + int meta = world.getBlockMetadata(x, y, z); + if (meta <= 5) + { + ItemStack stack = new ItemStack(this.blockID, 1, 0); + CrystalLogic logic = (CrystalLogic) world.getBlockTileEntity(x, y, z); + NBTTagCompound tag = new NBTTagCompound(); + int value = logic.getCrystalValue(); + tag.setInteger("Value", value); + Crystallinity.updateTheft(world.provider.dimensionId, x, z, -value, CrystalType.Light); + stack.setTagCompound(tag); + + if (logic.growing()) + { + TileEntity aggregator = world.getBlockTileEntity(x, y - 1, z); + if (aggregator instanceof LightAggregator) + { + ((LightAggregator) aggregator).harvestCrystal(); + } + } + + for (int i = 0; i < getCrystalHeight(value); i++) + world.setBlockToAir(x, y + i, z); + + if (!player.capabilities.isCreativeMode || player.isSneaking()) + dropBlock(world, x, y, z, stack); + } + else + { + Block below = Block.blocksList[world.getBlockId(x, y - 1, z)]; + if (below == TContent.lightCrystalBase) + { + below.removeBlockByPlayer(world, player, x, y - 1, z); + } + else + world.setBlockToAir(x, y, z); + } + + return true;//world.setBlockToAir(x, y, z); + } + + public static int getCrystalHeight (int crystalValue) + { + if (crystalValue > 440) + return 4; + if (crystalValue > 224) + return 3; + if (crystalValue > 80) + return 2; + + return 1; + } + + protected void dropBlock (World world, int x, int y, int z, ItemStack stack) + { + if (!world.isRemote && world.getGameRules().getGameRuleBooleanValue("doTileDrops")) + { + float f = 0.7F; + double d0 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + double d1 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + double d2 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + EntityItem entityitem = new EntityItem(world, (double) x + d0, (double) y + d1, (double) z + d2, stack); + entityitem.delayBeforeCanPickup = 10; + world.spawnEntityInWorld(entityitem); + } + } + + public void harvestBlock (World world, EntityPlayer player, int x, int y, int z, int meta) + { + /*if (meta > 4) + super.harvestBlock(world, player, x, y, z, meta);*/ + } + + @Override + public void onBlockPlacedBy (World world, int x, int y, int z, EntityLivingBase living, ItemStack stack) + { + CrystalLogic logic = (CrystalLogic) world.getBlockTileEntity(x, y, z); + logic.setActive(true); + if (stack.hasTagCompound()) + { + int value = stack.getTagCompound().getInteger("Value"); + Crystallinity.updateTheft(world.provider.dimensionId, x, z, value, CrystalType.Light); + logic.setCrystalValue(value); + } + } +} diff --git a/tconstruct/blocks/LavaTankBlock.java b/tconstruct/blocks/LavaTankBlock.java index 1d5dddd4..8473b7a0 100644 --- a/tconstruct/blocks/LavaTankBlock.java +++ b/tconstruct/blocks/LavaTankBlock.java @@ -248,7 +248,7 @@ public class LavaTankBlock extends BlockContainer } } - public boolean removeBlockByPlayer(World world, EntityPlayer player, int x, int y, int z) + public boolean removeBlockByPlayer (World world, EntityPlayer player, int x, int y, int z) { player.addExhaustion(0.025F); int meta = world.getBlockMetadata(x, y, z); @@ -263,28 +263,29 @@ public class LavaTankBlock extends BlockContainer tag.setCompoundTag("Fluid", liquidTag); stack.setTagCompound(tag); } - dropTankBlock(world, x, y, z, stack); - + if (!player.capabilities.isCreativeMode || player.isSneaking()) + dropTankBlock(world, x, y, z, stack); + return world.setBlockToAir(x, y, z); } - - protected void dropTankBlock(World world, int x, int y, int z, ItemStack stack) + + protected void dropTankBlock (World world, int x, int y, int z, ItemStack stack) { if (!world.isRemote && world.getGameRules().getGameRuleBooleanValue("doTileDrops")) { float f = 0.7F; - double d0 = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D; - double d1 = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D; - double d2 = (double)(world.rand.nextFloat() * f) + (double)(1.0F - f) * 0.5D; - EntityItem entityitem = new EntityItem(world, (double)x + d0, (double)y + d1, (double)z + d2, stack); + double d0 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + double d1 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + double d2 = (double) (world.rand.nextFloat() * f) + (double) (1.0F - f) * 0.5D; + EntityItem entityitem = new EntityItem(world, (double) x + d0, (double) y + d1, (double) z + d2, stack); entityitem.delayBeforeCanPickup = 10; world.spawnEntityInWorld(entityitem); } } - - public void harvestBlock(World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) + + public void harvestBlock (World par1World, EntityPlayer par2EntityPlayer, int par3, int par4, int par5, int par6) { - + } @Override diff --git a/tconstruct/blocks/LightCrystalBase.java b/tconstruct/blocks/LightCrystalBase.java index 10fc7496..9396d42b 100644 --- a/tconstruct/blocks/LightCrystalBase.java +++ b/tconstruct/blocks/LightCrystalBase.java @@ -72,31 +72,4 @@ public class LightCrystalBase extends Block this.icons[i] = iconRegister.registerIcon("tinker:" + textureNames[i]); } } - - @Override - public void breakBlock (World world, int x, int y, int z, int par5, int meta) - { - switch (meta % 5) - { - case 0: - case 4: - TheftValueTracker.updateCrystallinity(world.provider.dimensionId, x, z, -10); - break; - case 1: - TheftValueTracker.updateCrystallinity(world.provider.dimensionId, x, z, -20); - break; - case 2: - TheftValueTracker.updateCrystallinity(world.provider.dimensionId, x, z, -35); - break; - case 3: - TheftValueTracker.updateCrystallinity(world.provider.dimensionId, x, z, -60); - break; - } - - Block block = Block.blocksList[world.getBlockId(x, y - 1, z)]; - if (block == TContent.aggregator) - { - ((Aggregator) block).updateCrystalValue(world, x, y - 1, z); - } - } } diff --git a/tconstruct/blocks/logic/CrystalLogic.java b/tconstruct/blocks/logic/CrystalLogic.java new file mode 100644 index 00000000..62988791 --- /dev/null +++ b/tconstruct/blocks/logic/CrystalLogic.java @@ -0,0 +1,90 @@ +package tconstruct.blocks.logic; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.INetworkManager; +import net.minecraft.network.packet.Packet; +import net.minecraft.network.packet.Packet132TileEntityData; +import net.minecraft.tileentity.TileEntity; +import tconstruct.library.util.IActiveLogic; + +public class CrystalLogic extends TileEntity implements IActiveLogic +{ + boolean active; + boolean growing; + int crystalValue; + + public int getCrystalValue() + { + return crystalValue; + } + + public void setCrystalValue(int value) + { + this.crystalValue = value; + } + + @Override + public boolean getActive () + { + return active; + } + + @Override + public void setActive (boolean flag) + { + System.out.println("Activating"); + active = flag; + } + + public boolean growing() + { + return growing; + } + + public void setGrowth(boolean flag) + { + growing = flag; + } + + @Override + public void readFromNBT (NBTTagCompound tags) + { + super.readFromNBT(tags); + readCustomNBT(tags); + } + + @Override + public void writeToNBT (NBTTagCompound tags) + { + super.writeToNBT(tags); + writeCustomNBT(tags); + } + + public void readCustomNBT (NBTTagCompound tags) + { + active = tags.getBoolean("Active"); + growing = tags.getBoolean("Growing"); + } + + public void writeCustomNBT (NBTTagCompound tags) + { + tags.setBoolean("Active", active); + tags.setBoolean("Growing", growing); + } + + /* Packets */ + @Override + public Packet getDescriptionPacket () + { + NBTTagCompound tag = new NBTTagCompound(); + writeCustomNBT(tag); + return new Packet132TileEntityData(xCoord, yCoord, zCoord, 1, tag); + } + + @Override + public void onDataPacket (INetworkManager net, Packet132TileEntityData packet) + { + readCustomNBT(packet.customParam1); + worldObj.markBlockForRenderUpdate(xCoord, yCoord, zCoord); + } +} diff --git a/tconstruct/blocks/logic/GlowstoneAggregator.java b/tconstruct/blocks/logic/GlowstoneAggregator.java deleted file mode 100644 index 151cef7e..00000000 --- a/tconstruct/blocks/logic/GlowstoneAggregator.java +++ /dev/null @@ -1,197 +0,0 @@ -package tconstruct.blocks.logic; - -import tconstruct.common.TContent; -import tconstruct.crystal.TheftValueTracker; -import tconstruct.inventory.AggregatorContainer; -import tconstruct.library.util.IActiveLogic; -import net.minecraft.block.Block; -import net.minecraft.entity.player.InventoryPlayer; -import net.minecraft.inventory.Container; -import net.minecraft.nbt.NBTTagCompound; -import net.minecraft.network.INetworkManager; -import net.minecraft.network.packet.Packet; -import net.minecraft.network.packet.Packet132TileEntityData; -import net.minecraft.world.EnumSkyBlock; -import net.minecraft.world.World; - -public class GlowstoneAggregator extends AggregatorLogic implements IActiveLogic -{ - short currentTime; - short maxTime = 20 * 60 * 5; - public int currentLightLevel; - public boolean active; - public byte crystalValue; - - public GlowstoneAggregator() - { - super(3); - } - - @Override - public Container getGuiContainer (InventoryPlayer inventoryplayer, World world, int x, int y, int z) - { - return new AggregatorContainer(inventoryplayer, this); - } - - @Override - protected String getDefaultName () - { - return "aggregator.glowstone"; - } - - @Override - public void updateEntity () - { - if (worldObj.isRemote) - return; - - if (worldObj.canBlockSeeTheSky(xCoord, yCoord + 1, zCoord) && crystalValue < 64) - { - Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 1, zCoord)]; - if (block == null || validBlock(block) || block.isAirBlock(worldObj, xCoord, yCoord + 1, zCoord)) - { - currentLightLevel = worldObj.getSavedLightValue(EnumSkyBlock.Sky, xCoord, yCoord, zCoord) - worldObj.skylightSubtracted; - if (currentLightLevel > 12) - { - currentTime++; - if (currentTime >= 180) - { - currentTime = 0; - crystalValue++; - if (block == TContent.lightCrystalBase) - { - int meta = worldObj.getBlockMetadata(xCoord, yCoord + 1, zCoord); - if (crystalValue >= 64) - { - if (meta < 3) - { - worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 1, zCoord, 3, 3); - TheftValueTracker.updateCrystallinity(worldObj.provider.dimensionId, xCoord, zCoord, 25); //Total 60 - } - } - else if (crystalValue >= 28) - { - if (meta < 2) - { - worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 1, zCoord, 2, 3); - TheftValueTracker.updateCrystallinity(worldObj.provider.dimensionId, xCoord, zCoord, 15); //Total 35 - } - } - else if (crystalValue >= 8) - { - if (meta < 1) - { - worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 1, zCoord, 1, 3); - TheftValueTracker.updateCrystallinity(worldObj.provider.dimensionId, xCoord, zCoord, 10); //Total 20 - } - } - } - else - { - worldObj.setBlock(xCoord, yCoord + 1, zCoord, TContent.lightCrystalBase.blockID, 0, 3); - TheftValueTracker.updateCrystallinity(worldObj.provider.dimensionId, xCoord, zCoord, 10); //Total 10 - } - } - if (active == false) - { - active = true; - worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); - } - } - else - { - if (active == true) - { - active = false; - worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); - } - } - } - } - } - - boolean validBlock (Block block) - { - return block == TContent.lightCrystalBase; - } - - @Override - public boolean getActive () - { - return active; - } - - @Override - public void setActive (boolean flag) - { - active = flag; - } - - @Override - public void readFromNBT (NBTTagCompound tags) - { - super.readFromNBT(tags); - tags.setShort("Time", currentTime); - tags.setByte("Value", crystalValue); - readCustomNBT(tags); - } - - @Override - public void writeToNBT (NBTTagCompound tags) - { - super.writeToNBT(tags); - currentTime = tags.getShort("Time"); - crystalValue = tags.getByte("Value"); - writeCustomNBT(tags); - } - - public void readCustomNBT (NBTTagCompound tags) - { - active = tags.getBoolean("Active"); - } - - public void writeCustomNBT (NBTTagCompound tags) - { - tags.setBoolean("Active", active); - } - - /* Packets */ - @Override - public Packet getDescriptionPacket () - { - NBTTagCompound tag = new NBTTagCompound(); - writeCustomNBT(tag); - return new Packet132TileEntityData(xCoord, yCoord, zCoord, 1, tag); - } - - @Override - public void onDataPacket (INetworkManager net, Packet132TileEntityData packet) - { - readCustomNBT(packet.customParam1); - worldObj.markBlockForRenderUpdate(xCoord, yCoord, zCoord); - } - - public void updateCrystalValue () - { - if (crystalValue > 0) - { - Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 1, zCoord)]; - if (block == TContent.lightCrystalBase) - { - int meta = worldObj.getBlockMetadata(xCoord, yCoord + 1, zCoord); - if (meta == 3) - crystalValue = 64; - else if (meta == 2) - crystalValue = 28; - else if (meta == 1) - crystalValue = 8; - else - crystalValue = 1; - } - else - { - crystalValue = 0; - } - } - } -} diff --git a/tconstruct/blocks/logic/LightAggregator.java b/tconstruct/blocks/logic/LightAggregator.java new file mode 100644 index 00000000..f589ada9 --- /dev/null +++ b/tconstruct/blocks/logic/LightAggregator.java @@ -0,0 +1,391 @@ +package tconstruct.blocks.logic; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.InventoryPlayer; +import net.minecraft.inventory.Container; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.INetworkManager; +import net.minecraft.network.packet.Packet; +import net.minecraft.network.packet.Packet132TileEntityData; +import net.minecraft.world.EnumSkyBlock; +import net.minecraft.world.World; +import tconstruct.common.TContent; +import tconstruct.crystal.Crystallinity; +import tconstruct.crystal.Crystallinity.CrystalType; +import tconstruct.inventory.AggregatorContainer; +import tconstruct.library.util.IActiveLogic; + +public class LightAggregator extends AggregatorLogic implements IActiveLogic +{ + short currentTime; + short maxTime = 20 * 60 * 5; + public int currentLightLevel; + public boolean active; + public int crystalValue; + boolean blocked; + + public LightAggregator() + { + super(3); + } + + @Override + public Container getGuiContainer (InventoryPlayer inventoryplayer, World world, int x, int y, int z) + { + return new AggregatorContainer(inventoryplayer, this); + } + + @Override + protected String getDefaultName () + { + return "aggregator.glowstone"; + } + + @Override + public void updateEntity () + { + if (!blocked && crystalValue < 528)// && worldObj.canBlockSeeTheSky(xCoord, yCoord + 1, zCoord)) + { + currentLightLevel = worldObj.getSavedLightValue(EnumSkyBlock.Sky, xCoord, yCoord + heightOfCrystal(), zCoord) - worldObj.skylightSubtracted; + if (currentLightLevel > 3) + { + currentTime += currentLightLevel / 3 + 1; + if (currentTime >= 1) //180 ticks * max light (15) 540 + { + currentTime = 0; + crystalValue++; + //System.out.println(crystalValue + " " + currentLightLevel); + if (!worldObj.isRemote) + growCrystal(); + } + setActive(true); + } + else + { + setActive(false); + } + } + else + { + setActive(false); + } + } + + int heightOfCrystal () + { + if (crystalValue > 440) + return 4; + if (crystalValue > 224) + return 3; + if (crystalValue > 80) + return 2; + + return 1; + } + + void growCrystal () + { + if (crystalValue == 1) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 1, zCoord)]; + if (block == null || block.isAirBlock(worldObj, xCoord, yCoord + 1, zCoord)) + { + worldObj.setBlock(xCoord, yCoord + 1, zCoord, TContent.lightCrystalBase.blockID, 0, 3); + } + else + { + crystalValue--; + blocked = true; + } + } + else if (crystalValue == 8) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 1, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 1, zCoord, 1, 3); + spawnNegativeAir(1, 1); + + int value = 8; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(8); + } + } + else if (crystalValue == 24) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 1, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 1, zCoord, 2, 3); + spawnNegativeAir(2, 1); + + int value = 16; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(24); + } + } + else if (crystalValue == 48) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 1, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 1, zCoord, 3, 3); + spawnNegativeAir(3, 1); + + int value = 24; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(48); + } + } + else if (crystalValue == 80) //Transition + { + Block upperBlock = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 2, zCoord)]; + if (upperBlock == null || upperBlock.isAirBlock(worldObj, xCoord, yCoord + 2, zCoord)) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 1, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 1, zCoord, 4, 3); + worldObj.setBlock(xCoord, yCoord + 2, zCoord, TContent.lightCrystalBase.blockID, 6, 3); + spawnNegativeAir(5, 1); + + int value = 32; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(80); + } + } + else + { + crystalValue--; + blocked = true; + } + } + else if (crystalValue == 120) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 1, zCoord)]; + Block upperBlock = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 2, zCoord)]; + if (validBlock(block) && validBlock(upperBlock)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 1, zCoord, 5, 3); + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 2, zCoord, 7, 3); + spawnNegativeAir(6, 1); + + int value = 40; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(120); + } + } + else if (crystalValue == 168) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 2, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 2, zCoord, 8, 3); + spawnNegativeAir(7, 1); + + int value = 48; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(168); + } + } + else if (crystalValue == 224) //Transition + { + Block upperBlock = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 3, zCoord)]; + if (upperBlock == null || upperBlock.isAirBlock(worldObj, xCoord, yCoord + 3, zCoord)) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 2, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 2, zCoord, 9, 3); + worldObj.setBlock(xCoord, yCoord + 3, zCoord, TContent.lightCrystalBase.blockID, 10, 3); + spawnNegativeAir(9, 1); + + int value = 56; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(224); + } + } + else + { + crystalValue--; + blocked = true; + } + } + else if (crystalValue == 288) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 3, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 3, zCoord, 11, 3); + spawnNegativeAir(10, 1); + + int value = 64; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(288); + } + } + else if (crystalValue == 360) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 3, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 3, zCoord, 12, 3); + spawnNegativeAir(11, 1); + + int value = 72; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(360); + } + } + else if (crystalValue == 440) //Transition + { + Block upperBlock = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 4, zCoord)]; + if (upperBlock == null || upperBlock.isAirBlock(worldObj, xCoord, yCoord + 4, zCoord)) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 3, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 3, zCoord, 13, 3); + worldObj.setBlock(xCoord, yCoord + 4, zCoord, TContent.lightCrystalBase.blockID, 14, 3); + spawnNegativeAir(13, 1); + + int value = 80; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(440); + } + } + else + { + crystalValue--; + blocked = true; + } + } + else if (crystalValue == 528) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord, yCoord + 4, zCoord)]; + if (validBlock(block)) + { + worldObj.setBlockMetadataWithNotify(xCoord, yCoord + 4, zCoord, 15, 3); + spawnNegativeAir(15, 1); + + int value = 88; + Crystallinity.updateTheft(worldObj.provider.dimensionId, xCoord, zCoord, value, CrystalType.Light); + Crystallinity.updateCharge(worldObj.provider.dimensionId, xCoord, zCoord, -value, CrystalType.Light); + CrystalLogic crystal = (CrystalLogic) worldObj.getBlockTileEntity(xCoord, yCoord + 1, zCoord); + crystal.setCrystalValue(528); + } + } + } + + public void spawnNegativeAir (int range, int darkness) + { + for (int xPos = -range; xPos <= range; xPos++) + { + for (int yPos = -range; yPos <= range; yPos++) + { + for (int zPos = -range; zPos <= range; zPos++) + { + if (Math.abs(xPos) + Math.abs(yPos) + Math.abs(zPos) <= range) + { + Block block = Block.blocksList[worldObj.getBlockId(xCoord + xPos, yCoord + yPos, zCoord + zPos)]; + if (block == null || block.isAirBlock(worldObj, xCoord + xPos, yCoord + yPos, zCoord + zPos)) + worldObj.setBlock(xCoord + xPos, yCoord + yPos, zCoord + zPos, TContent.darkBlock.blockID, darkness, 3); + } + } + } + } + } + + boolean validBlock (Block block) + { + return block == TContent.lightCrystalBase; + } + + @Override + public boolean getActive () + { + return active; + } + + @Override + public void setActive (boolean flag) + { + if (active != flag) + { + active = flag; + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + } + + @Override + public void readFromNBT (NBTTagCompound tags) + { + super.readFromNBT(tags); + currentTime = tags.getShort("Time"); + readCustomNBT(tags); + } + + @Override + public void writeToNBT (NBTTagCompound tags) + { + super.writeToNBT(tags); + tags.setShort("Time", currentTime); + writeCustomNBT(tags); + } + + public void readCustomNBT (NBTTagCompound tags) + { + active = tags.getBoolean("Active"); + crystalValue = tags.getInteger("CrystalValue"); + } + + public void writeCustomNBT (NBTTagCompound tags) + { + tags.setBoolean("Active", active); + tags.setInteger("CrystalValue", crystalValue); + } + + /* Packets */ + @Override + public Packet getDescriptionPacket () + { + NBTTagCompound tag = new NBTTagCompound(); + writeCustomNBT(tag); + return new Packet132TileEntityData(xCoord, yCoord, zCoord, 1, tag); + } + + @Override + public void onDataPacket (INetworkManager net, Packet132TileEntityData packet) + { + readCustomNBT(packet.customParam1); + worldObj.markBlockForRenderUpdate(xCoord, yCoord, zCoord); + } + + public int harvestCrystal () + { + int tmp = crystalValue; + //TheftTracker.updateValue(worldObj.provider.dimensionId, xCoord, zCoord, -tmp, CrystalType.Light); + crystalValue = 0; + return tmp; + } +} diff --git a/tconstruct/client/TProxyClient.java b/tconstruct/client/TProxyClient.java index dbf8b0ce..2fdddfef 100644 --- a/tconstruct/client/TProxyClient.java +++ b/tconstruct/client/TProxyClient.java @@ -63,7 +63,7 @@ import tconstruct.blocks.logic.CraftingStationLogic; import tconstruct.blocks.logic.DrawbridgeLogic; import tconstruct.blocks.logic.DryingRackLogic; import tconstruct.blocks.logic.FrypanLogic; -import tconstruct.blocks.logic.GlowstoneAggregator; +import tconstruct.blocks.logic.LightAggregator; import tconstruct.blocks.logic.PartBuilderLogic; import tconstruct.blocks.logic.PatternChestLogic; import tconstruct.blocks.logic.SmelteryLogic; @@ -192,7 +192,7 @@ public class TProxyClient extends TProxyCommon if (ID == toolForgeID) return new ToolForgeGui(player.inventory, (ToolForgeLogic) world.getBlockTileEntity(x, y, z), world, x, y, z); if (ID == glowstoneAggregatorID) - return new GlowstoneAggregatorGui(player.inventory, (GlowstoneAggregator) world.getBlockTileEntity(x, y, z), world, x, y, z); + return new GlowstoneAggregatorGui(player.inventory, (LightAggregator) world.getBlockTileEntity(x, y, z), world, x, y, z); if (ID == drawbridgeID) return new DrawbridgeGui(player.inventory, (DrawbridgeLogic) world.getBlockTileEntity(x, y, z), world, x, y, z); if (ID == landmineID) diff --git a/tconstruct/client/block/CrystalBlockRender.java b/tconstruct/client/block/CrystalBlockRender.java index 2ca400ca..cf247e70 100644 --- a/tconstruct/client/block/CrystalBlockRender.java +++ b/tconstruct/client/block/CrystalBlockRender.java @@ -34,9 +34,9 @@ public class CrystalBlockRender implements ISimpleBlockRenderingHandler { if (modelID == model) { - int metadata = world.getBlockMetadata(x, y, z) % 5; + int metadata = world.getBlockMetadata(x, y, z); - if (metadata != 3) + if (metadata < 3) //Bits { renderer.setRenderBounds(0.0625F, 0.0F, 0.0625F, 0.25F, 0.0625F, 0.375F); renderer.renderStandardBlock(block, x, y, z); @@ -45,6 +45,8 @@ public class CrystalBlockRender implements ISimpleBlockRenderingHandler renderer.setRenderBounds(0.5F, 0.0F, 0.8125F, 0.5625F, 0.0625F, 0.875F); renderer.renderStandardBlock(block, x, y, z); } + + //Base if (metadata == 0) { renderer.setRenderBounds(0.375F, 0.0F, 0.375F, 0.625F, 0.125F, 0.625F); @@ -78,12 +80,13 @@ public class CrystalBlockRender implements ISimpleBlockRenderingHandler } else if (metadata == 3) { - renderer.setRenderBounds(0.25F, 0.0F, 0.25F, 0.75F, 0.75F, 0.75F); - renderer.renderStandardBlock(block, x, y, z); renderer.setRenderBounds(0.3125F, 0.75F, 0.3125F, 0.6875F, 0.875F, 0.6875F); renderer.renderStandardBlock(block, x, y, z); renderer.setRenderBounds(0.375F, 0.875F, 0.375F, 0.625F, 0.9325F, 0.625F); renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.25F, 0.0F, 0.25F, 0.75F, 0.75F, 0.75F); + renderer.renderStandardBlock(block, x, y, z); renderer.setRenderBounds(0.125F, 0.0F, 0.5F, 0.375F, 0.375, 0.875F); renderer.renderStandardBlock(block, x, y, z); @@ -92,22 +95,170 @@ public class CrystalBlockRender implements ISimpleBlockRenderingHandler renderer.setRenderBounds(0.625F, 0.0F, 0.5F, 0.875F, 0.625, 0.875F); renderer.renderStandardBlock(block, x, y, z); } - else if (metadata == 4) + else if (metadata == 4) //Transition { - /*renderer.setRenderBounds(0.25F, 0.0F, 0.25F, 0.75F, 0.75F, 0.75F); + renderer.setRenderBounds(0.25F, 0.0F, 0.25F, 0.75F, 1.0F, 0.75F); renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.125F, 0.0F, 0.5F, 0.375F, 0.5, 0.875F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0.0F, 0.0625, 0.625, 1.0, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625F, 0.0F, 0.5F, 0.875F, 0.75, 0.875F); + renderer.renderStandardBlock(block, x, y, z); + } + + else if (metadata == 5) //Transition + { + renderer.setRenderBounds(0.25F, 0.0F, 0.25F, 0.75F, 1.0F, 0.75F); + renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.125F, 0.0F, 0.5F, 0.375F, 0.75F, 0.875F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0.0F, 0.0625, 0.625, 1.0, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625F, 0.0F, 0.5F, 0.875F, 1.0, 0.875F); + renderer.renderStandardBlock(block, x, y, z); + } + + //2nd Layer + else if (metadata == 6) + { + renderer.setRenderBounds(0.3125F, 0.0F, 0.3125F, 0.6875F, 0.25, 0.6875F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.375F, 0.25, 0.375F, 0.625F, 0.375, 0.625F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.25, 0.0F, 0.5F, 0.375, 0.1875, 0.75F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0.0F, 0.1875, 0.625, 0.125, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.5625F, 0.0F, 0.5F, 0.75, 0.125, 0.75F); + renderer.renderStandardBlock(block, x, y, z); + } + else if (metadata == 7) + { + renderer.setRenderBounds(0.3125F, 0.0F, 0.3125F, 0.6875F, 0.5F, 0.6875F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.375F, 0.5F, 0.375F, 0.625F, 0.625F, 0.625F); + renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.25F, 0.0F, 0.5F, 0.4325F, 0.25F, 0.75F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0.0F, 0.125F, 0.625F, 0.375F, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625F, 0.0F, 0.5F, 0.8125f, 0.375F, 0.75F); + renderer.renderStandardBlock(block, x, y, z); + } + else if (metadata == 8) + { renderer.setRenderBounds(0.3125F, 0.75F, 0.3125F, 0.6875F, 0.875F, 0.6875F); renderer.renderStandardBlock(block, x, y, z); renderer.setRenderBounds(0.375F, 0.875F, 0.375F, 0.625F, 0.9325F, 0.625F); - renderer.renderStandardBlock(block, x, y, z);*/ + renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.25F, 0.0F, 0.25F, 0.75F, 0.75F, 0.75F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0.0F, 0.0625, 0.625, 0.6875F, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625F, 0.0F, 0.5F, 0.8125F, 0.625, 0.8125F); + renderer.renderStandardBlock(block, x, y, z); + } + else if (metadata == 9) //Transition + { + renderer.setRenderBounds(0.3125F, 0.75F, 0.3125F, 0.6875F, 1.0F, 0.6875F); + renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.25F, 0.0F, 0.25F, 0.75F, 0.75F, 0.75F); + renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.4325F, 0.0F, 0.0625, 0.625, 0.75F, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0.75F, 0.125F, 0.625, 1.0F, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.625F, 0.0F, 0.5F, 0.8125F, 0.625, 0.8125F); + renderer.renderStandardBlock(block, x, y, z); + } + + //3rd Layer + else if (metadata == 10) + { + renderer.setRenderBounds(0.375F, 0F, 0.3125F, 0.625F, 0.1875F, 0.625F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0.1875F, 0.4375F, 0.5625F, 0.25F, 0.5625F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0F, 0.1875F, 0.5625F, 0.125F, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + } + else if (metadata == 11) + { + renderer.setRenderBounds(0.375F, 0F, 0.3125F, 0.625F, 0.4325F, 0.625F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0.4325F, 0.375F, 0.5625F, 0.5F, 0.5625F); + renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.4325F, 0F, 0.1875F, 0.625F, 0.3125F, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0F, 0.4325F, 0.6875F, 0.3125, 0.6875); + renderer.renderStandardBlock(block, x, y, z); + } + else if (metadata == 12) + { + renderer.setRenderBounds(0.3125F, 0F, 0.3125F, 0.625F, 0.75F, 0.625F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.375F, 0.75F, 0.375F, 0.5625F, 0.875F, 0.5625F); + renderer.renderStandardBlock(block, x, y, z); + + renderer.setRenderBounds(0.4325F, 0F, 0.1875F, 0.625F, 0.675F, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0F, 0.4325F, 0.6875F, 0.5625F, 0.6875); + renderer.renderStandardBlock(block, x, y, z); + } + else if (metadata == 13)//Transition + { + renderer.setRenderBounds(0.3125F, 0F, 0.3125F, 0.625F, 1.0, 0.625F); + renderer.renderStandardBlock(block, x, y, z); + /*renderer.setRenderBounds(0.375F, 0.75F, 0.375F, 0.5625F, 0.875F, 0.5625F); + renderer.renderStandardBlock(block, x, y, z);*/ + + renderer.setRenderBounds(0.4325F, 0F, 0.1875F, 0.625F, 0.875F, 0.3125F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4325F, 0F, 0.4325F, 0.6875F, 0.75, 0.6875); + renderer.renderStandardBlock(block, x, y, z); + } + + //4th Layer + else if (metadata == 14) + { + renderer.setRenderBounds(0.3125F, 0F, 0.3125F, 0.625F, 0.1875F, 0.625F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4375F, 0.1875F, 0.3125F, 0.625F, 0.3125F, 0.5F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.375F, 0.1875F, 0.375F, 0.5625F, 0.375F, 0.5625F); + renderer.renderStandardBlock(block, x, y, z); + } + else if (metadata == 15) + { + renderer.setRenderBounds(0.3125F, 0F, 0.3125F, 0.625F, 0.25F, 0.625F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4375F, 0.25F, 0.3125F, 0.625F, 0.5F, 0.5F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.375F, 0.1875F, 0.375F, 0.5625F, 0.6875F, 0.5625F); + renderer.renderStandardBlock(block, x, y, z); + renderer.setRenderBounds(0.4375F, 0.6875F, 0.4375F, 0.5625F, 0.75F, 0.5625F); + renderer.renderStandardBlock(block, x, y, z); + } + + //Unused + /*else if (metadata == 4) //Leftover fragments + { renderer.setRenderBounds(0.125F, 0.0F, 0.5F, 0.375F, 0.125F, 0.75F); renderer.renderStandardBlock(block, x, y, z); renderer.setRenderBounds(0.4325F, 0.0F, 0.0625, 0.625, 0.25F, 0.3125F); renderer.renderStandardBlock(block, x, y, z); renderer.setRenderBounds(0.625F, 0.0F, 0.5F, 0.75F, 0.1875F, 0.75F); renderer.renderStandardBlock(block, x, y, z); - } + }*/ } return true; } diff --git a/tconstruct/client/gui/GlowstoneAggregatorGui.java b/tconstruct/client/gui/GlowstoneAggregatorGui.java index e6dd131b..9be4d6b3 100644 --- a/tconstruct/client/gui/GlowstoneAggregatorGui.java +++ b/tconstruct/client/gui/GlowstoneAggregatorGui.java @@ -8,22 +8,23 @@ import net.minecraft.world.World; import org.lwjgl.opengl.GL11; -import tconstruct.blocks.logic.GlowstoneAggregator; +import tconstruct.blocks.logic.LightAggregator; public class GlowstoneAggregatorGui extends GuiContainer { - public GlowstoneAggregator logic; + public LightAggregator logic; - public GlowstoneAggregatorGui(InventoryPlayer inventoryplayer, GlowstoneAggregator frypan, World world, int x, int y, int z) + public GlowstoneAggregatorGui(InventoryPlayer inventoryplayer, LightAggregator aggregator, World world, int x, int y, int z) { - super(frypan.getGuiContainer(inventoryplayer, world, x, y, z)); - logic = frypan; + super(aggregator.getGuiContainer(inventoryplayer, world, x, y, z)); + logic = aggregator; } protected void drawGuiContainerForegroundLayer (int par1, int par2) { //fontRenderer.drawString(StatCollector.translateToLocal("aggregator.glowstone"), 60, 6, 0x404040); - fontRenderer.drawString("Glowstone Aggregator", 8, 6, 0x404040); + fontRenderer.drawString("Lightstone Aggregator", 8, 6, 0x404040); + fontRenderer.drawString("Crystal Value: " + logic.crystalValue, 8, 16, 0x404040); fontRenderer.drawString(StatCollector.translateToLocal("container.inventory"), 8, (ySize - 96) + 2, 0x404040); } diff --git a/tconstruct/common/TContent.java b/tconstruct/common/TContent.java index 92f223fe..dfb3d66a 100644 --- a/tconstruct/common/TContent.java +++ b/tconstruct/common/TContent.java @@ -31,9 +31,11 @@ import net.minecraftforge.oredict.ShapedOreRecipe; import net.minecraftforge.oredict.ShapelessOreRecipe; import tconstruct.TConstruct; import tconstruct.blocks.Aggregator; +import tconstruct.blocks.AntiLight; import tconstruct.blocks.CastingChannelBlock; import tconstruct.blocks.CraftingSlab; import tconstruct.blocks.CraftingStationBlock; +import tconstruct.blocks.CrystalBlock; import tconstruct.blocks.DryingRack; import tconstruct.blocks.EquipBlock; import tconstruct.blocks.EssenceExtractor; @@ -43,7 +45,6 @@ import tconstruct.blocks.GlassPane; import tconstruct.blocks.GlassPaneStained; import tconstruct.blocks.GravelOre; import tconstruct.blocks.LavaTankBlock; -import tconstruct.blocks.LightCrystalBase; import tconstruct.blocks.LiquidMetalFinite; import tconstruct.blocks.MeatBlock; import tconstruct.blocks.MetalOre; @@ -67,14 +68,15 @@ import tconstruct.blocks.logic.CastingBasinLogic; import tconstruct.blocks.logic.CastingChannelLogic; import tconstruct.blocks.logic.CastingTableLogic; import tconstruct.blocks.logic.CraftingStationLogic; +import tconstruct.blocks.logic.CrystalLogic; import tconstruct.blocks.logic.DrawbridgeLogic; import tconstruct.blocks.logic.DryingRackLogic; import tconstruct.blocks.logic.EssenceExtractorLogic; import tconstruct.blocks.logic.FaucetLogic; import tconstruct.blocks.logic.FirestarterLogic; import tconstruct.blocks.logic.FrypanLogic; -import tconstruct.blocks.logic.GlowstoneAggregator; import tconstruct.blocks.logic.LavaTankLogic; +import tconstruct.blocks.logic.LightAggregator; import tconstruct.blocks.logic.MultiServantLogic; import tconstruct.blocks.logic.PartBuilderLogic; import tconstruct.blocks.logic.PatternChestLogic; @@ -344,6 +346,7 @@ public class TContent implements IFuelHandler public static Block lightCrystalBase; public static Block essenceExtractor; public static Item essenceCrystal; + public static Block darkBlock; //Liquids public static Material liquidMetal; @@ -942,15 +945,19 @@ public class TContent implements IFuelHandler stainedGlassClearPane = new GlassPaneStained(PHConstruct.stainedGlassClearPane); GameRegistry.registerBlock(stainedGlassClearPane, StainedGlassClearPaneItem.class, "GlassPaneClearStained"); - + aggregator = new Aggregator(PHConstruct.aggregator).setUnlocalizedName("Aggregator"); aggregator.stepSound = Block.soundMetalFootstep; GameRegistry.registerBlock(aggregator, "Aggregator"); - GameRegistry.registerTileEntity(GlowstoneAggregator.class, "GlowstoneAggregator"); + GameRegistry.registerTileEntity(LightAggregator.class, "LightAggregator"); - lightCrystalBase = new LightCrystalBase(PHConstruct.lightCrystalBase).setUnlocalizedName("LightCrystalBase"); + lightCrystalBase = new CrystalBlock(PHConstruct.lightCrystalBase).setUnlocalizedName("Block.Crystal"); lightCrystalBase.stepSound = Block.soundGlassFootstep; - GameRegistry.registerBlock(lightCrystalBase, LightCrystalItem.class, "LightCrystalBase"); + GameRegistry.registerBlock(lightCrystalBase, LightCrystalItem.class, "Block.Crystal"); + GameRegistry.registerTileEntity(CrystalLogic.class, "CrystalLogic"); + + darkBlock = new AntiLight(PHConstruct.darkBlock).setUnlocalizedName("Antilight"); + GameRegistry.registerBlock(darkBlock, "Antilight"); } void registerItems () @@ -960,7 +967,7 @@ public class TContent implements IFuelHandler blankPattern = new CraftingItem(PHConstruct.blankPattern, blanks, blanks, "materials/").setUnlocalizedName("tconstruct.Pattern"); materials = new MaterialItem(PHConstruct.materials).setUnlocalizedName("tconstruct.Materials"); - toolRod = new ToolPart(PHConstruct.toolRod, "_rod").setUnlocalizedName("tconstruct.ToolRod"); + toolRod = new ToolPart(PHConstruct.toolRod, "_rod", "ToolRod").setUnlocalizedName("tconstruct.ToolRod"); toolShard = new ToolShard(PHConstruct.toolShard, "_chunk").setUnlocalizedName("tconstruct.ToolShard"); woodPattern = new Pattern(PHConstruct.woodPattern, "WoodPattern", "pattern_", "materials/").setUnlocalizedName("tconstruct.Pattern"); metalPattern = new MetalPattern(PHConstruct.metalPattern, "MetalPattern", "cast_", "materials/").setUnlocalizedName("tconstruct.MetalPattern"); @@ -1019,33 +1026,33 @@ public class TContent implements IFuelHandler potionLauncher = new PotionLauncher(PHConstruct.potionLauncher).setUnlocalizedName("tconstruct.PotionLauncher"); - pickaxeHead = new ToolPart(PHConstruct.pickaxeHead, "_pickaxe_head").setUnlocalizedName("tconstruct.PickaxeHead"); - shovelHead = new ToolPart(PHConstruct.shovelHead, "_shovel_head").setUnlocalizedName("tconstruct.ShovelHead"); - hatchetHead = new ToolPart(PHConstruct.axeHead, "_axe_head").setUnlocalizedName("tconstruct.AxeHead"); - binding = new ToolPart(PHConstruct.binding, "_binding").setUnlocalizedName("tconstruct.Binding"); - toughBinding = new ToolPart(PHConstruct.toughBinding, "_toughbind").setUnlocalizedName("tconstruct.ThickBinding"); - toughRod = new ToolPart(PHConstruct.toughRod, "_toughrod").setUnlocalizedName("tconstruct.ThickRod"); - largePlate = new ToolPart(PHConstruct.largePlate, "_largeplate").setUnlocalizedName("tconstruct.LargePlate"); + pickaxeHead = new ToolPart(PHConstruct.pickaxeHead, "_pickaxe_head", "PickHead").setUnlocalizedName("tconstruct.PickaxeHead"); + shovelHead = new ToolPart(PHConstruct.shovelHead, "_shovel_head", "ShovelHead").setUnlocalizedName("tconstruct.ShovelHead"); + hatchetHead = new ToolPart(PHConstruct.axeHead, "_axe_head", "AxeHead").setUnlocalizedName("tconstruct.AxeHead"); + binding = new ToolPart(PHConstruct.binding, "_binding", "Binding").setUnlocalizedName("tconstruct.Binding"); + toughBinding = new ToolPart(PHConstruct.toughBinding, "_toughbind", "ToughBind").setUnlocalizedName("tconstruct.ThickBinding"); + toughRod = new ToolPart(PHConstruct.toughRod, "_toughrod", "ToughRod").setUnlocalizedName("tconstruct.ThickRod"); + largePlate = new ToolPart(PHConstruct.largePlate, "_largeplate", "LargePlate").setUnlocalizedName("tconstruct.LargePlate"); - swordBlade = new ToolPart(PHConstruct.swordBlade, "_sword_blade").setUnlocalizedName("tconstruct.SwordBlade"); - wideGuard = new ToolPart(PHConstruct.largeGuard, "_large_guard").setUnlocalizedName("tconstruct.LargeGuard"); - handGuard = new ToolPart(PHConstruct.medGuard, "_medium_guard").setUnlocalizedName("tconstruct.MediumGuard"); - crossbar = new ToolPart(PHConstruct.crossbar, "_crossbar").setUnlocalizedName("tconstruct.Crossbar"); - knifeBlade = new ToolPart(PHConstruct.knifeBlade, "_knife_blade").setUnlocalizedName("tconstruct.KnifeBlade"); - fullGuard = new ToolPartHidden(PHConstruct.fullGuard, "_full_guard").setUnlocalizedName("tconstruct.FullGuard"); + swordBlade = new ToolPart(PHConstruct.swordBlade, "_sword_blade", "SwordBlade").setUnlocalizedName("tconstruct.SwordBlade"); + wideGuard = new ToolPart(PHConstruct.largeGuard, "_large_guard", "LargeGuard").setUnlocalizedName("tconstruct.LargeGuard"); + handGuard = new ToolPart(PHConstruct.medGuard, "_medium_guard", "MediumGuard").setUnlocalizedName("tconstruct.MediumGuard"); + crossbar = new ToolPart(PHConstruct.crossbar, "_crossbar", "Crossbar").setUnlocalizedName("tconstruct.Crossbar"); + knifeBlade = new ToolPart(PHConstruct.knifeBlade, "_knife_blade", "KnifeBlade").setUnlocalizedName("tconstruct.KnifeBlade"); + fullGuard = new ToolPartHidden(PHConstruct.fullGuard, "_full_guard", "FullGuard").setUnlocalizedName("tconstruct.FullGuard"); - frypanHead = new ToolPart(PHConstruct.frypanHead, "_frypan_head").setUnlocalizedName("tconstruct.FrypanHead"); - signHead = new ToolPart(PHConstruct.signHead, "_battlesign_head").setUnlocalizedName("tconstruct.SignHead"); - chiselHead = new ToolPart(PHConstruct.chiselHead, "_chisel_head").setUnlocalizedName("tconstruct.ChiselHead"); + frypanHead = new ToolPart(PHConstruct.frypanHead, "_frypan_head", "FrypanHead").setUnlocalizedName("tconstruct.FrypanHead"); + signHead = new ToolPart(PHConstruct.signHead, "_battlesign_head", "SignHead").setUnlocalizedName("tconstruct.SignHead"); + chiselHead = new ToolPart(PHConstruct.chiselHead, "_chisel_head", "ChiselHead").setUnlocalizedName("tconstruct.ChiselHead"); - scytheBlade = new ToolPart(PHConstruct.scytheBlade, "_scythe_head").setUnlocalizedName("tconstruct.ScytheBlade"); - broadAxeHead = new ToolPart(PHConstruct.lumberHead, "_lumberaxe_head").setUnlocalizedName("tconstruct.LumberHead"); - excavatorHead = new ToolPart(PHConstruct.excavatorHead, "_excavator_head").setUnlocalizedName("tconstruct.ExcavatorHead"); - largeSwordBlade = new ToolPart(PHConstruct.largeSwordBlade, "_large_sword_blade").setUnlocalizedName("tconstruct.LargeSwordBlade"); - hammerHead = new ToolPart(PHConstruct.hammerHead, "_hammer_head").setUnlocalizedName("tconstruct.HammerHead"); + scytheBlade = new ToolPart(PHConstruct.scytheBlade, "_scythe_head", "ScytheHead").setUnlocalizedName("tconstruct.ScytheBlade"); + broadAxeHead = new ToolPart(PHConstruct.lumberHead, "_lumberaxe_head", "LumberHead").setUnlocalizedName("tconstruct.LumberHead"); + excavatorHead = new ToolPart(PHConstruct.excavatorHead, "_excavator_head", "ExcavatorHead").setUnlocalizedName("tconstruct.ExcavatorHead"); + largeSwordBlade = new ToolPart(PHConstruct.largeSwordBlade, "_large_sword_blade", "LargeSwordBlade").setUnlocalizedName("tconstruct.LargeSwordBlade"); + hammerHead = new ToolPart(PHConstruct.hammerHead, "_hammer_head", "HammerHead").setUnlocalizedName("tconstruct.HammerHead"); bowstring = new Bowstring(PHConstruct.bowstring).setUnlocalizedName("tconstruct.Bowstring"); - arrowhead = new ToolPart(PHConstruct.arrowhead, "_arrowhead").setUnlocalizedName("tconstruct.Arrowhead"); + arrowhead = new ToolPart(PHConstruct.arrowhead, "_arrowhead", "ArrowHead").setUnlocalizedName("tconstruct.Arrowhead"); fletching = new Fletching(PHConstruct.fletching).setUnlocalizedName("tconstruct.Fletching"); Item[] toolParts = { toolRod, toolShard, pickaxeHead, shovelHead, hatchetHead, binding, toughBinding, toughRod, largePlate, swordBlade, wideGuard, handGuard, crossbar, knifeBlade, fullGuard, diff --git a/tconstruct/common/TProxyCommon.java b/tconstruct/common/TProxyCommon.java index 37c42f25..a2b07752 100644 --- a/tconstruct/common/TProxyCommon.java +++ b/tconstruct/common/TProxyCommon.java @@ -127,7 +127,7 @@ public class TProxyCommon implements IGuiHandler } } - for (int mat = 0; mat < materialTypes.length; mat++) + /*for (int mat = 0; mat < materialTypes.length; mat++) { for (int type = 0; type < toolMaterialNames.length; type++) { @@ -135,7 +135,7 @@ public class TProxyCommon implements IGuiHandler String visibleName = new StringBuilder().append(toolMaterialNames[type]).append(materialNames[mat]).toString(); LanguageRegistry.instance().addStringLocalization(internalName, "en_US", visibleName); } - } + }*/ for (int i = 0; i < shardNames.length; i++) { @@ -167,10 +167,8 @@ public class TProxyCommon implements IGuiHandler //LanguageRegistry.instance().addStringLocalization("entity.TConstruct.EdibleSlime.name", "en_US", "Blue Slime"); //LanguageRegistry.instance().addStringLocalization("entity.TConstruct.MetalSlime.name", "en_US", "Metal Slime"); //LanguageRegistry.instance().addStringLocalization("item.tconstruct.diary.diary.name", "en_US", "Tinker's Log"); - LanguageRegistry.instance().addStringLocalization("item.tconstruct.Pattern.blank_pattern.name", "en_US", "Blank Pattern"); - LanguageRegistry.instance().addStringLocalization("item.tconstruct.Pattern.blank_cast.name", "en_US", "Blank Cast"); //LanguageRegistry.addName(TContent.blankPattern, "Blank Pattern"); - LanguageRegistry.addName(TContent.pickaxe, "Pickaxe"); + /*LanguageRegistry.addName(TContent.pickaxe, "Pickaxe"); LanguageRegistry.addName(TContent.shovel, "Shovel"); LanguageRegistry.addName(TContent.hatchet, "Hatchet"); LanguageRegistry.addName(TContent.broadsword, "Broadsword"); @@ -178,9 +176,9 @@ public class TProxyCommon implements IGuiHandler LanguageRegistry.addName(TContent.rapier, "Rapier"); LanguageRegistry.addName(TContent.frypan, "Frying Pan"); LanguageRegistry.addName(TContent.battlesign, "Battlesign"); - LanguageRegistry.addName(TContent.mattock, "Mattock"); + LanguageRegistry.addName(TContent.mattock, "Mattock");*/ LanguageRegistry.addName(TContent.potionLauncher, "Potion Launcher"); - LanguageRegistry.addName(TContent.dagger, "Dagger"); + /*LanguageRegistry.addName(TContent.dagger, "Dagger"); LanguageRegistry.addName(TContent.chisel, "Chisel"); LanguageRegistry.addName(TContent.scythe, "Scythe"); LanguageRegistry.addName(TContent.lumberaxe, "Lumber Axe"); @@ -188,12 +186,13 @@ public class TProxyCommon implements IGuiHandler LanguageRegistry.addName(TContent.excavator, "Excavator"); LanguageRegistry.addName(TContent.hammer, "Hammer"); LanguageRegistry.addName(TContent.battleaxe, "Battleaxe"); - LanguageRegistry.addName(TContent.cutlass, "Cutlass"); - LanguageRegistry.addName(TContent.aggregator, "Glowstone Aggregator"); - LanguageRegistry.addName(TContent.lightCrystalBase, "Lightstone Crystal"); + LanguageRegistry.addName(TContent.cutlass, "Cutlass");*/ + LanguageRegistry.addName(TContent.aggregator, "Light Aggregator"); + LanguageRegistry.addName(TContent.lightCrystalBase, "Light Crystal"); LanguageRegistry.addName(TContent.knapsack, "Knapsack"); - LanguageRegistry.addName(TContent.shortbow, "Shortbow"); - LanguageRegistry.addName(TContent.arrow, "Arrow"); + //LanguageRegistry.addName(TContent.shortbow, "Shortbow"); + //LanguageRegistry.addName(TContent.arrow, "Arrow"); + LanguageRegistry.addName(TContent.meatBlock, "Hambone"); } diff --git a/tconstruct/crystal/CrystalValues.java b/tconstruct/crystal/CrystalValues.java new file mode 100644 index 00000000..24783170 --- /dev/null +++ b/tconstruct/crystal/CrystalValues.java @@ -0,0 +1,92 @@ +package tconstruct.crystal; + +import tconstruct.crystal.Crystallinity.CrystalType; +import net.minecraft.nbt.NBTTagCompound; + +public class CrystalValues +{ + int light; + int time; + int life; + int stone; + int fire; + int water; + + final String valueType; + + public CrystalValues(String type) + { + valueType = type; + } + + public void addValue (int value, CrystalType type) + { + /*light = 0; + time = 0; + life = 0; + stone = 0; + fire = 0; + water = 0;*/ + switch (type) + { + case Light: + light += value; + case Time: + time += value; + case Life: + life += value; + case Stone: + stone += value; + case Fire: + fire += value; + case Water: + water += value; + } + } + + public int getValue (CrystalType type) + { + switch (type) + { + case Light: + return light; + case Time: + return time; + case Life: + return life; + case Stone: + return stone; + case Fire: + return fire; + case Water: + return water; + } + return 0; + } + + protected void setValue(int[] array) + { + light = array[0]; + time = array[1]; + life = array[2]; + stone = array[3]; + fire = array[4]; + water = array[5]; + } + + public CrystalValues loadFromNBT(NBTTagCompound tags) + { + int[] crystalArray = tags.getIntArray("TConstruct.Crystal."+valueType); + if (crystalArray != null && crystalArray.length >= 6) + { + this.setValue(crystalArray); + } + return this; + } + + public void saveToNBT(NBTTagCompound tags) + { + int[] crystalArray = new int[] {light, time, life, stone, fire, water}; + tags.setIntArray("TConstruct.Crystal.", crystalArray); + } +} \ No newline at end of file diff --git a/tconstruct/crystal/Crystallinity.java b/tconstruct/crystal/Crystallinity.java new file mode 100644 index 00000000..8d4ebe07 --- /dev/null +++ b/tconstruct/crystal/Crystallinity.java @@ -0,0 +1,36 @@ +package tconstruct.crystal; + +import java.util.HashMap; + +import tconstruct.library.util.ValueCoordTuple; + +public class Crystallinity +{ + public enum CrystalType + { + Light, Life, Time, Stone, Fire, Water + } + + public static HashMap theftValue = new HashMap(); //Value of materials + public static HashMap charge = new HashMap(); //Balance of crystal + + public static void updateTheft (int dim, int posX, int posZ, int value, CrystalType type) + { + ValueCoordTuple coord = new ValueCoordTuple(dim, (int) Math.floor(posX / 16D), (int) Math.floor(posZ / 16D)); + CrystalValues crystal = theftValue.get(coord); + if (crystal == null) + crystal = new CrystalValues("Theft"); + crystal.addValue(value, type); + theftValue.put(coord, crystal); + } + + public static void updateCharge (int dim, int posX, int posZ, int value, CrystalType type) + { + ValueCoordTuple coord = new ValueCoordTuple(dim, (int) Math.floor(posX / 16D), (int) Math.floor(posZ / 16D)); + CrystalValues crystal = charge.get(coord); + if (crystal == null) + crystal = new CrystalValues("Charge"); + crystal.addValue(value, type); + charge.put(coord, crystal); + } +} diff --git a/tconstruct/inventory/AggregatorContainer.java b/tconstruct/inventory/AggregatorContainer.java index 77d92739..4ae59a81 100644 --- a/tconstruct/inventory/AggregatorContainer.java +++ b/tconstruct/inventory/AggregatorContainer.java @@ -1,20 +1,21 @@ package tconstruct.inventory; -import tconstruct.blocks.logic.GlowstoneAggregator; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.inventory.Container; +import net.minecraft.inventory.ICrafting; import net.minecraft.inventory.Slot; import net.minecraft.item.ItemStack; +import tconstruct.blocks.logic.LightAggregator; public class AggregatorContainer extends Container { - public GlowstoneAggregator logic; + public LightAggregator logic; public int progress = 0; public int fuel = 0; public int fuelGague = 0; - public AggregatorContainer(InventoryPlayer inventoryplayer, GlowstoneAggregator logic) + public AggregatorContainer(InventoryPlayer inventoryplayer, LightAggregator logic) { this.logic = logic; @@ -37,6 +38,12 @@ public class AggregatorContainer extends Container } } + public void addCraftingToCrafters(ICrafting par1ICrafting) + { + super.addCraftingToCrafters(par1ICrafting); + par1ICrafting.sendProgressBarUpdate(this, 0, logic.crystalValue); + } + @Override public boolean canInteractWith (EntityPlayer entityplayer) { diff --git a/tconstruct/items/ToolPart.java b/tconstruct/items/ToolPart.java index c139c8a3..d0a4fd02 100644 --- a/tconstruct/items/ToolPart.java +++ b/tconstruct/items/ToolPart.java @@ -7,14 +7,34 @@ import tconstruct.library.util.IToolPart; import net.minecraft.creativetab.CreativeTabs; import net.minecraft.item.ItemStack; +import net.minecraft.util.StatCollector; public class ToolPart extends CraftingItem implements IToolPart { - public ToolPart(int id, String textureType) + public String partName; + public ToolPart(int id, String textureType, String name) { super(id, toolMaterialNames, buildTextureNames(textureType), "parts/"); this.setHasSubtypes(true); this.setMaxDamage(0); + this.partName = name; + } + + @Override + public String getItemDisplayName (ItemStack par1ItemStack) + { + StringBuilder builder = new StringBuilder(); + builder.append(StatCollector.translateToLocal("parttype."+toolTextureNames[par1ItemStack.getItemDamage()])).append(" ").append(StatCollector.translateToLocal("toolpart."+partName)); + return builder.toString(); + /*String s = ("" + StatCollector.translateToLocal("toolpart."+partName)).trim(); + String s1 = toolMaterialNames[par1ItemStack.getItemDamage()]; + + if (s1 != null) + { + s = s + " " + StatCollector.translateToLocal(s1); + } + + return s;*/ } private static String[] buildTextureNames (String textureType) diff --git a/tconstruct/items/ToolPartHidden.java b/tconstruct/items/ToolPartHidden.java index 2b3352da..6ff3a1eb 100644 --- a/tconstruct/items/ToolPartHidden.java +++ b/tconstruct/items/ToolPartHidden.java @@ -7,9 +7,9 @@ import net.minecraft.creativetab.CreativeTabs; public class ToolPartHidden extends ToolPart { - public ToolPartHidden(int id, String textureType) + public ToolPartHidden(int id, String textureType, String name) { - super(id, textureType); + super(id, textureType, name); } public void getSubItems (int id, CreativeTabs tab, List list) diff --git a/tconstruct/items/ToolShard.java b/tconstruct/items/ToolShard.java index 3b5993ad..ca8b73c5 100644 --- a/tconstruct/items/ToolShard.java +++ b/tconstruct/items/ToolShard.java @@ -16,7 +16,7 @@ public class ToolShard extends ToolPart public ToolShard(int id, String tex) { - super(id, tex); + super(id, tex, "ToolShard"); this.setHasSubtypes(true); this.setMaxDamage(0); } diff --git a/tconstruct/items/blocks/LightCrystalItem.java b/tconstruct/items/blocks/LightCrystalItem.java index 5256bfa5..72b1fe7d 100644 --- a/tconstruct/items/blocks/LightCrystalItem.java +++ b/tconstruct/items/blocks/LightCrystalItem.java @@ -1,28 +1,211 @@ package tconstruct.items.blocks; +import java.util.List; + +import net.minecraft.block.Block; +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; +import tconstruct.blocks.CrystalBlock; public class LightCrystalItem extends ItemBlock { - public static final String blockType[] = { "Crafter", "Parts", "Parts", "Parts", "Parts", "PatternChest", "PatternChest", "PatternChest", "PatternChest", "PatternChest", "PatternShaper", - "PatternShaper", "PatternShaper", "PatternShaper", "CastingTable" }; + private int bID; public LightCrystalItem(int id) { super(id); setMaxDamage(0); - setHasSubtypes(true); + this.bID = id + 256; + //setHasSubtypes(true); } - public int getMetadata (int meta) + public boolean onItemUse (ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ) { - return meta; + int i1 = world.getBlockId(x, y, z); + + if (i1 == Block.snow.blockID && (world.getBlockMetadata(x, y, z) & 7) < 1) + { + side = 1; + } + else if (i1 != Block.vine.blockID && i1 != Block.tallGrass.blockID && i1 != Block.deadBush.blockID + && (Block.blocksList[i1] == null || !Block.blocksList[i1].isBlockReplaceable(world, x, y, z))) + { + if (side == 0) + { + --y; + } + + if (side == 1) + { + ++y; + } + + if (side == 2) + { + --z; + } + + if (side == 3) + { + ++z; + } + + if (side == 4) + { + --x; + } + + if (side == 5) + { + ++x; + } + } + + if (stack.stackSize == 0) + { + return false; + } + else if (!player.canPlayerEdit(x, y, z, side, stack)) + { + return false; + } + else if (y == 255 && Block.blocksList[this.bID].blockMaterial.isSolid()) + { + return false; + } + else if (world.canPlaceEntityOnSide(this.bID, x, y, z, false, side, player, stack)) + { + Block block = Block.blocksList[this.bID]; + + int crystalValue = 0; + if (stack.hasTagCompound()) + { + crystalValue = stack.getTagCompound().getInteger("Value"); + } + + int placeMeta = getBaseMeta(crystalValue); + + if (placeBlockAt(stack, player, world, x, y, z, side, hitX, hitY, hitZ, placeMeta)) + { + world.playSoundEffect((double) ((float) x + 0.5F), (double) ((float) y + 0.5F), (double) ((float) z + 0.5F), block.stepSound.getPlaceSound(), + (block.stepSound.getVolume() + 1.0F) / 2.0F, block.stepSound.getPitch() * 0.8F); + --stack.stackSize; + + int height = CrystalBlock.getCrystalHeight(crystalValue); + if (height > 1) + { + int localID = world.getBlockId(x, y + 1, z); + if (localID != Block.vine.blockID && localID != Block.tallGrass.blockID && localID != Block.deadBush.blockID + && (Block.blocksList[localID] == null || !Block.blocksList[localID].isBlockReplaceable(world, x, y+1, z))) + { + placeBlockAt(stack, player, world, x, y+1, z, side, hitX, hitY, hitZ, secondMeta(crystalValue)); + } + } + if (height > 2) + { + int localID = world.getBlockId(x, y + 2, z); + if (localID != Block.vine.blockID && localID != Block.tallGrass.blockID && localID != Block.deadBush.blockID + && (Block.blocksList[localID] == null || !Block.blocksList[localID].isBlockReplaceable(world, x, y+2, z))) + { + placeBlockAt(stack, player, world, x, y+2, z, side, hitX, hitY, hitZ, thirdMeta(crystalValue)); + } + } + if (height > 3) + { + int localID = world.getBlockId(x, y + 3, z); + if (localID != Block.vine.blockID && localID != Block.tallGrass.blockID && localID != Block.deadBush.blockID + && (Block.blocksList[localID] == null || !Block.blocksList[localID].isBlockReplaceable(world, x, y+3, z))) + { + placeBlockAt(stack, player, world, x, y+3, z, side, hitX, hitY, hitZ, topMeta(crystalValue)); + } + } + } + + return true; + } + else + { + return false; + } } - /*@Override - public String getUnlocalizedName(ItemStack itemstack) + int getBaseMeta (int crystalValue) { - int pos = MathHelper.clamp_int(itemstack.getItemDamage(), 0, blockType.length-1); - return (new StringBuilder()).append("ToolStation.").append(blockType[pos]).toString(); - }*/ + if (crystalValue >= 120) + { + return 5; + } + if (crystalValue >= 48) + { + return 4; + } + if (crystalValue >= 80) + { + return 3; + } + if (crystalValue >= 24) + { + return 2; + } + if (crystalValue >= 8) + { + return 1; + } + + return 0; + } + + int secondMeta (int crystalValue) + { + if (crystalValue >= 224) + { + return 9; + } + if (crystalValue >= 168) + { + return 8; + } + if (crystalValue >= 120) + { + return 7; + } + return 6; + } + + int thirdMeta (int crystalValue) + { + if (crystalValue >= 440) + { + return 13; + } + if (crystalValue >= 360) + { + return 12; + } + if (crystalValue >= 288) + { + return 11; + } + return 10; + } + + public int topMeta (int crystalValue) + { + if (crystalValue >= 528) + { + return 15; + } + return 14; + } + + public void addInformation (ItemStack stack, EntityPlayer player, List list, boolean par4) + { + if (stack.hasTagCompound()) + { + int value = stack.getTagCompound().getInteger("Value"); + list.add("Crystal Value: " + value); + } + } } diff --git a/tconstruct/items/tools/Chisel.java b/tconstruct/items/tools/Chisel.java index 487dc283..e64a348f 100644 --- a/tconstruct/items/tools/Chisel.java +++ b/tconstruct/items/tools/Chisel.java @@ -30,17 +30,18 @@ public class Chisel extends ToolCore @Override public ItemStack getContainerItemStack (ItemStack itemStack) { - //AbilityHelper.damageTool(itemStack, 1, null, false); - - int reinforced = 0; - NBTTagCompound tags = itemStack.getTagCompound(); - - if (tags.getCompoundTag("InfiTool").hasKey("Unbreaking")) - reinforced = tags.getCompoundTag("InfiTool").getInteger("Unbreaking"); - - if (random.nextInt(10) < 10 - reinforced) + if (itemStack.hasTagCompound()) { - AbilityHelper.damageTool(itemStack, 1, null, false); + int reinforced = 0; + NBTTagCompound tags = itemStack.getTagCompound(); + + if (tags.getCompoundTag("InfiTool").hasKey("Unbreaking")) + reinforced = tags.getCompoundTag("InfiTool").getInteger("Unbreaking"); + + if (random.nextInt(10) < 10 - reinforced) + { + AbilityHelper.damageTool(itemStack, 1, null, false); + } } return itemStack; } diff --git a/tconstruct/util/PHConstruct.java b/tconstruct/util/PHConstruct.java index a7d97c9b..835b4f8a 100644 --- a/tconstruct/util/PHConstruct.java +++ b/tconstruct/util/PHConstruct.java @@ -158,6 +158,7 @@ public class PHConstruct woodCrafterSlab = config.getBlock("Crafting Slab", 3243).getInt(3243); woolSlab1 = config.getBlock("Wool Slab 1", 3244).getInt(3244); woolSlab2 = config.getBlock("Wool Slab 2", 3245).getInt(3245); + darkBlock = config.getBlock("Antilight", 3246).getInt(3246); castingChannel = config.getBlock("Casting Channel", 3249).getInt(3249); slimePoolBlue = config.getBlock("Liquid Blue Slime", 3235).getInt(3235); @@ -413,6 +414,7 @@ public class PHConstruct public static int lightCrystalBase; public static int essenceExtractor; public static int essenceCrystal; + public static int darkBlock; //Liquids public static int metalFlowing; diff --git a/tconstruct/util/TEventHandler.java b/tconstruct/util/TEventHandler.java index f566ce9e..ac00f913 100644 --- a/tconstruct/util/TEventHandler.java +++ b/tconstruct/util/TEventHandler.java @@ -14,7 +14,6 @@ import net.minecraft.entity.monster.EntitySpider; import net.minecraft.entity.monster.EntityZombie; import net.minecraft.entity.monster.IMob; import net.minecraft.entity.passive.EntityChicken; -import net.minecraft.entity.passive.EntityCow; import net.minecraft.entity.player.EntityPlayer; import net.minecraft.item.Item; import net.minecraft.item.ItemStack; @@ -24,8 +23,8 @@ import net.minecraft.potion.PotionEffect; import net.minecraft.util.EnumMovingObjectType; import net.minecraft.world.World; import net.minecraft.world.chunk.Chunk; -import net.minecraftforge.event.Event.Result; import net.minecraftforge.event.Event; +import net.minecraftforge.event.Event.Result; import net.minecraftforge.event.ForgeSubscribe; import net.minecraftforge.event.entity.living.LivingDeathEvent; import net.minecraftforge.event.entity.living.LivingDropsEvent; @@ -40,7 +39,8 @@ import net.minecraftforge.oredict.OreDictionary.OreRegisterEvent; import tconstruct.TConstruct; import tconstruct.blocks.LiquidMetalFinite; import tconstruct.common.TContent; -import tconstruct.crystal.TheftValueTracker; +import tconstruct.crystal.CrystalValues; +import tconstruct.crystal.Crystallinity; import tconstruct.library.TConstructRegistry; import tconstruct.library.crafting.PatternBuilder; import tconstruct.library.crafting.Smeltery; @@ -480,7 +480,10 @@ public class TEventHandler Chunk chunk = event.getChunk(); int worldID = chunk.worldObj.provider.dimensionId; ValueCoordTuple coord = new ValueCoordTuple(worldID, chunk.xPosition, chunk.zPosition); - TheftValueTracker.crystallinity.put(coord, event.getData().getInteger("TConstruct.Crystallinity")); + CrystalValues theft = new CrystalValues("Theft"); + Crystallinity.theftValue.put(coord, theft.loadFromNBT(event.getData())); + CrystalValues charge = new CrystalValues("Charge"); + Crystallinity.theftValue.put(coord, charge.loadFromNBT(event.getData())); } @ForgeSubscribe @@ -489,13 +492,23 @@ public class TEventHandler Chunk chunk = event.getChunk(); int worldID = chunk.worldObj.provider.dimensionId; ValueCoordTuple coord = new ValueCoordTuple(worldID, chunk.xPosition, chunk.zPosition); - if (TheftValueTracker.crystallinity.containsKey(coord)) + if (Crystallinity.theftValue.containsKey(coord)) { - int crystal = TheftValueTracker.crystallinity.get(coord); - event.getData().setInteger("TConstruct.Crystallinity", crystal); + CrystalValues crystal = Crystallinity.theftValue.get(coord); + crystal.saveToNBT(event.getData()); if (!event.getChunk().isChunkLoaded) { - TheftValueTracker.crystallinity.remove(worldID); + Crystallinity.theftValue.remove(coord); + } + } + + if (Crystallinity.charge.containsKey(coord)) + { + CrystalValues crystal = Crystallinity.charge.get(coord); + crystal.saveToNBT(event.getData()); + if (!event.getChunk().isChunkLoaded) + { + Crystallinity.charge.remove(coord); } } } diff --git a/tconstruct/worldgen/TBaseWorldGenerator.java b/tconstruct/worldgen/TBaseWorldGenerator.java index 259778a2..e5851b39 100644 --- a/tconstruct/worldgen/TBaseWorldGenerator.java +++ b/tconstruct/worldgen/TBaseWorldGenerator.java @@ -2,17 +2,17 @@ package tconstruct.worldgen; import java.util.Random; -import tconstruct.common.TContent; -import tconstruct.crystal.TheftValueTracker; -import tconstruct.library.util.ValueCoordTuple; -import tconstruct.util.PHConstruct; - import net.minecraft.block.Block; import net.minecraft.block.material.Material; import net.minecraft.world.World; import net.minecraft.world.WorldType; import net.minecraft.world.chunk.IChunkProvider; import net.minecraft.world.gen.feature.WorldGenMinable; +import tconstruct.common.TContent; +import tconstruct.crystal.CrystalValues; +import tconstruct.crystal.Crystallinity; +import tconstruct.library.util.ValueCoordTuple; +import tconstruct.util.PHConstruct; import cpw.mods.fml.common.IWorldGenerator; public class TBaseWorldGenerator implements IWorldGenerator @@ -64,7 +64,8 @@ public class TBaseWorldGenerator implements IWorldGenerator void initializeChunkData (int chunkX, int chunkZ, int worldID) { ValueCoordTuple coord = new ValueCoordTuple(worldID, chunkX, chunkZ); - TheftValueTracker.crystallinity.put(coord, 0); + Crystallinity.theftValue.put(coord, new CrystalValues("Theft")); + Crystallinity.charge.put(coord, new CrystalValues("Charge")); } void generateSurface (Random random, int xChunk, int zChunk, World world)