From 6e7296792d5ef01a54060f8ac7c9d94a7da63a05 Mon Sep 17 00:00:00 2001 From: LoveHoly Date: Wed, 10 Sep 2014 00:28:15 +0900 Subject: [PATCH] =?UTF-8?q?Automatic=20Sieve=20=EC=B6=94=EA=B0=80?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../ExAstris/Block/BlockSieveAutomatic.java | 158 ++++++ .../ItemBlock/ItemBlockSieveAutomatic.java | 25 + .../Block/Model/ModelSieveAutomatic.java | 114 +++++ .../Render/Item/ItemRenderSieveAutomatic.java | 173 +++++++ .../Block/Render/RenderSieveAutomatic.java | 103 ++++ .../TileEntity/TileEntitySieveAutomatic.java | 458 ++++++++++++++++++ src/main/java/ExAstris/Bridge/Waila.java | 28 ++ src/main/java/ExAstris/Data/BlockData.java | 3 + src/main/java/ExAstris/ExAstris.java | 1 + src/main/java/ExAstris/ExAstrisBlock.java | 6 + src/main/java/ExAstris/ExAstrisItem.java | 7 + src/main/java/ExAstris/ExAstrisRecipe.java | 16 + src/main/java/ExAstris/Proxy/ProxyClient.java | 9 + .../resources/assets/exastris/lang/en_US.lang | 3 +- .../textures/blocks/IconSieveMesh.png | Bin 0 -> 1159 bytes .../textures/blocks/ModelSieveAutomatic.png | Bin 0 -> 4032 bytes 16 files changed, 1103 insertions(+), 1 deletion(-) create mode 100644 src/main/java/ExAstris/Block/BlockSieveAutomatic.java create mode 100644 src/main/java/ExAstris/Block/ItemBlock/ItemBlockSieveAutomatic.java create mode 100644 src/main/java/ExAstris/Block/Model/ModelSieveAutomatic.java create mode 100644 src/main/java/ExAstris/Block/Render/Item/ItemRenderSieveAutomatic.java create mode 100644 src/main/java/ExAstris/Block/Render/RenderSieveAutomatic.java create mode 100644 src/main/java/ExAstris/Block/TileEntity/TileEntitySieveAutomatic.java create mode 100644 src/main/java/ExAstris/ExAstrisRecipe.java create mode 100644 src/main/resources/assets/exastris/textures/blocks/IconSieveMesh.png create mode 100644 src/main/resources/assets/exastris/textures/blocks/ModelSieveAutomatic.png diff --git a/src/main/java/ExAstris/Block/BlockSieveAutomatic.java b/src/main/java/ExAstris/Block/BlockSieveAutomatic.java new file mode 100644 index 0000000..5ac2d58 --- /dev/null +++ b/src/main/java/ExAstris/Block/BlockSieveAutomatic.java @@ -0,0 +1,158 @@ +package ExAstris.Block; + +import java.util.List; + +import cpw.mods.fml.common.registry.GameRegistry; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import exnihilo.registries.SieveRegistry; +import ExAstris.Block.TileEntity.TileEntitySieveAutomatic; +import ExAstris.Block.TileEntity.TileEntitySieveAutomatic.SieveMode; +import ExAstris.Data.BlockData; +import ExAstris.Data.ModData; +import net.minecraft.block.Block; +import net.minecraft.block.BlockContainer; +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.entity.player.EntityPlayerMP; +import net.minecraft.init.Blocks; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; +import net.minecraft.world.World; + +public class BlockSieveAutomatic extends BlockContainer{ + public static IIcon meshIcon; + + public BlockSieveAutomatic() { + super(Material.iron); + setCreativeTab(CreativeTabs.tabDecorations); + setHardness(2.0f); + + setBlockName(ModData.ID + "." + BlockData.SIEVE_AUTOMATIC_KEY); + GameRegistry.registerTileEntity(TileEntitySieveAutomatic.class, ModData.ID + "." + BlockData.SIEVE_AUTOMATIC_KEY); + } + + @Override + public void registerBlockIcons(IIconRegister register) + { + blockIcon = Blocks.planks.getIcon(0,0); + meshIcon = register.registerIcon(ModData.TEXTURE_LOCATION + ":" + "IconSieveMesh"); + } + + @Override + @SuppressWarnings({ "rawtypes", "unchecked" }) + @SideOnly(Side.CLIENT) + public void getSubBlocks(Item item, CreativeTabs tabs, List subItems) { + subItems.add(new ItemStack(item, 1, 0)); + } + + @Override + public int getRenderType() + { + return -1; + } + + @Override + public boolean isOpaqueCube() + { + return false; + } + + @Override + public boolean renderAsNormalBlock() + { + return false; + } + + @Override + public boolean hasTileEntity() + { + return true; + } + + @Override + public int damageDropped (int metadata) { + return metadata; + } + + @Override + public TileEntity createNewTileEntity(World world, int meta) { + return new TileEntitySieveAutomatic(); + } + + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int side, float hitX, float hitY, float hitZ) + { + if (player == null) + { + return false; + } + + + return true; + } + + private boolean isHuman(EntityPlayer player) + { + boolean isHuman = (player instanceof EntityPlayerMP); + + if (player.toString().contains("CoFH")) + { + isHuman = false; + } + + return isHuman; + } + + private void removeCurrentItem(EntityPlayer player) + { + ItemStack item = player.getCurrentEquippedItem(); + + if (!player.capabilities.isCreativeMode) + { + item.stackSize -= 1; + if (item.stackSize == 0) + { + item = null; + } + } + + } +} + + +/* + TileEntitySieveAutomatic sieve = (TileEntitySieveAutomatic) world.getTileEntity(x, y, z); + + if (sieve.mode == SieveMode.EMPTY && player.getCurrentEquippedItem() != null) + { + ItemStack held = player.getCurrentEquippedItem(); + + if (SieveRegistry.Contains(Block.getBlockFromItem(held.getItem()), held.getItemDamage())) + { + sieve.addSievable(Block.getBlockFromItem(held.getItem()), held.getItemDamage()); + removeCurrentItem(player); + } + }else + { + if (world.isRemote) + { + sieve.ProcessContents(false); + }else + { + if (sieve.mode != SieveMode.EMPTY) + { + if(isHuman(player))//ModData.ALLOW_SIEVE_AUTOMATION + { + sieve.ProcessContents(false); + } + } + } + } + */ + diff --git a/src/main/java/ExAstris/Block/ItemBlock/ItemBlockSieveAutomatic.java b/src/main/java/ExAstris/Block/ItemBlock/ItemBlockSieveAutomatic.java new file mode 100644 index 0000000..a6f1c83 --- /dev/null +++ b/src/main/java/ExAstris/Block/ItemBlock/ItemBlockSieveAutomatic.java @@ -0,0 +1,25 @@ +package ExAstris.Block.ItemBlock; + +import ExAstris.Data.BlockData; +import ExAstris.Data.ModData; +import net.minecraft.block.Block; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; + +public class ItemBlockSieveAutomatic extends ItemBlock { + public ItemBlockSieveAutomatic(Block block) { + super(block); + setHasSubtypes(true); + } + + public String getUnlocalizedName(ItemStack itemstack) + { + return ModData.ID + "." + BlockData.SIEVE_AUTOMATIC_UNLOCALIZED_NAME; + } + + @Override + public int getMetadata(int meta) + { + return meta; + } +} diff --git a/src/main/java/ExAstris/Block/Model/ModelSieveAutomatic.java b/src/main/java/ExAstris/Block/Model/ModelSieveAutomatic.java new file mode 100644 index 0000000..a4bc04f --- /dev/null +++ b/src/main/java/ExAstris/Block/Model/ModelSieveAutomatic.java @@ -0,0 +1,114 @@ +package ExAstris.Block.Model; + +import ExAstris.Data.ModData; +import net.minecraft.client.model.ModelBase; +import net.minecraft.client.model.ModelRenderer; +import net.minecraft.entity.Entity; +import net.minecraft.util.ResourceLocation; + +public class ModelSieveAutomatic extends ModelBase{ + //fields + ModelRenderer Leg1; + ModelRenderer Leg2; + ModelRenderer Leg3; + ModelRenderer Leg4; + ModelRenderer BoxSide1; + ModelRenderer BoxSide2; + ModelRenderer BoxSide3; + ModelRenderer BoxSide4; + + public static final ResourceLocation texture = new ResourceLocation(ModData.TEXTURE_LOCATION, "textures/blocks/ModelSieveAutomatic.png"); + + public ModelSieveAutomatic() + { + textureWidth = 128; + textureHeight = 128; + + Leg1 = new ModelRenderer(this, 0, 0); + Leg1.addBox(0F, 0F, 0F, 1, 11, 1); + Leg1.setRotationPoint(-7F, 13F, -7F); + Leg1.setTextureSize(128, 128); + Leg1.mirror = true; + setRotation(Leg1, 0F, 0F, 0F); + Leg2 = new ModelRenderer(this, 0, 0); + Leg2.addBox(0F, 0F, 0F, 1, 11, 1); + Leg2.setRotationPoint(-7F, 13F, 6F); + Leg2.setTextureSize(128, 128); + Leg2.mirror = true; + setRotation(Leg2, 0F, 0F, 0F); + Leg3 = new ModelRenderer(this, 0, 0); + Leg3.addBox(0F, 0F, 0F, 1, 11, 1); + Leg3.setRotationPoint(6F, 13F, 6F); + Leg3.setTextureSize(128, 128); + Leg3.mirror = true; + setRotation(Leg3, 0F, 0F, 0F); + Leg4 = new ModelRenderer(this, 0, 0); + Leg4.addBox(0F, 0F, 0F, 1, 11, 1); + Leg4.setRotationPoint(6F, 13F, -7F); + Leg4.setTextureSize(128, 128); + Leg4.mirror = true; + setRotation(Leg4, 0F, 0F, 0F); + BoxSide1 = new ModelRenderer(this, 6, 0); + BoxSide1.addBox(0F, 0F, 0F, 16, 6, 1); + BoxSide1.setRotationPoint(-8F, 8F, -8F); + BoxSide1.setTextureSize(128, 128); + BoxSide1.mirror = true; + setRotation(BoxSide1, 0F, 0F, 0F); + BoxSide2 = new ModelRenderer(this, 6, 8); + BoxSide2.addBox(0F, 0F, 0F, 16, 6, 1); + BoxSide2.setRotationPoint(-8F, 8F, 7F); + BoxSide2.setTextureSize(128, 128); + BoxSide2.mirror = true; + setRotation(BoxSide2, 0F, 0F, 0F); + BoxSide3 = new ModelRenderer(this, 6, 16); + BoxSide3.addBox(0F, 0F, 0F, 1, 6, 14); + BoxSide3.setRotationPoint(7F, 8F, -7F); + BoxSide3.setTextureSize(128, 128); + BoxSide3.mirror = true; + setRotation(BoxSide3, 0F, 0F, 0F); + BoxSide4 = new ModelRenderer(this, 6, 37); + BoxSide4.addBox(0F, 0F, 0F, 1, 6, 14); + BoxSide4.setRotationPoint(-8F, 8F, -7F); + BoxSide4.setTextureSize(128, 128); + BoxSide4.mirror = true; + setRotation(BoxSide4, 0F, 0F, 0F); + } + + public void render(Entity entity, float f, float f1, float f2, float f3, float f4, float f5) + { + super.render(entity, f, f1, f2, f3, f4, f5); + setRotationAngles(f, f1, f2, f3, f4, f5, entity); + Leg1.render(f5); + Leg2.render(f5); + Leg3.render(f5); + Leg4.render(f5); + BoxSide1.render(f5); + BoxSide2.render(f5); + BoxSide3.render(f5); + BoxSide4.render(f5); + } + + public void simpleRender(float scale) + { + Leg1.render(scale); + Leg2.render(scale); + Leg3.render(scale); + Leg4.render(scale); + BoxSide1.render(scale); + BoxSide2.render(scale); + BoxSide3.render(scale); + BoxSide4.render(scale); + } + + private void setRotation(ModelRenderer model, float x, float y, float z) + { + model.rotateAngleX = x; + model.rotateAngleY = y; + model.rotateAngleZ = z; + } + + public void setRotationAngles(float f, float f1, float f2, float f3, float f4, float f5, Entity entity) + { + super.setRotationAngles(f, f1, f2, f3, f4, f5, entity); + } +} diff --git a/src/main/java/ExAstris/Block/Render/Item/ItemRenderSieveAutomatic.java b/src/main/java/ExAstris/Block/Render/Item/ItemRenderSieveAutomatic.java new file mode 100644 index 0000000..f6132e3 --- /dev/null +++ b/src/main/java/ExAstris/Block/Render/Item/ItemRenderSieveAutomatic.java @@ -0,0 +1,173 @@ +package ExAstris.Block.Render.Item; + +import org.lwjgl.opengl.GL11; + + + +import exnihilo.blocks.models.ModelSieveMesh; +//import exnihilo.blocks.models.ModelSieveMesh; +import ExAstris.Block.BlockSieveAutomatic; +import ExAstris.Block.Model.ModelSieveAutomatic; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.item.ItemStack; +import net.minecraftforge.client.IItemRenderer; + +public class ItemRenderSieveAutomatic implements IItemRenderer{ + private ModelSieveAutomatic model; + private ModelSieveMesh mesh; + + public ItemRenderSieveAutomatic(ModelSieveAutomatic model, ModelSieveMesh mesh) + { + this.model = model; + this.mesh = mesh; + } + + @Override + public boolean handleRenderType(ItemStack item, ItemRenderType type) { + switch (type) + { + case ENTITY: + break; + case EQUIPPED: + break; + case EQUIPPED_FIRST_PERSON: + break; + case FIRST_PERSON_MAP: + return false; + case INVENTORY: + break; + } + return true; + } + + @Override + public boolean shouldUseRenderHelper(ItemRenderType type, ItemStack item, ItemRendererHelper helper) { + switch (type) + { + case ENTITY: + break; + case EQUIPPED: + break; + case EQUIPPED_FIRST_PERSON: + break; + case FIRST_PERSON_MAP: + return false; + case INVENTORY: + break; + } + + switch (helper) + { + case BLOCK_3D: + break; + case ENTITY_BOBBING: + break; + case ENTITY_ROTATION: + break; + case EQUIPPED_BLOCK: + break; + case INVENTORY_BLOCK: + break; + default: + break; + + } + return true; + } + + @Override + public void renderItem(ItemRenderType type, ItemStack item, Object... data) { + renderTable(type, item); + renderMesh(type); + } + + private void renderTable(ItemRenderType type, ItemStack item) + { + GL11.glPushMatrix(); + GL11.glScalef(-1F, -1F, 1F); + + switch (type) + { + case EQUIPPED: + GL11.glTranslatef(-0.5F, -1.5F, 0.5F); + break; + + case EQUIPPED_FIRST_PERSON: + GL11.glTranslatef(0F, -1.6F, 0.6F); + break; + + case ENTITY: + GL11.glTranslatef(0F, -1.0F, 0F); + break; + + case INVENTORY: + GL11.glTranslatef(0F, -1.0F, 0F); + break; + + default: + GL11.glTranslatef(0F, 0F, 0F); + break; + } + + bindTexture(item.getItemDamage()); + model.simpleRender(0.0625F); + + GL11.glPopMatrix(); + } + + private void renderMesh(ItemRenderType type) + { + GL11.glPushMatrix(); + GL11.glScalef(-1F, -1F, 1F); + + switch (type) + { + case EQUIPPED: + GL11.glTranslatef(-0.5F, -0.69F, 0.5F); + break; + + case EQUIPPED_FIRST_PERSON: + GL11.glTranslatef(-0.5F, -0.79F, 0.5F); + break; + + case ENTITY: + GL11.glTranslatef(0F, -0.2F, 0F); + break; + + case INVENTORY: + GL11.glTranslatef(0F, -0.2F, 0F); + break; + + default: + GL11.glTranslatef(0F, -0.2F, 0F); + break; + } + + bindMeshTexture(); + mesh.render(BlockSieveAutomatic.meshIcon); + + GL11.glPopMatrix(); + } + + protected void bindTexture(int meta) + { + TextureManager texturemanager = Minecraft.getMinecraft().getTextureManager(); + + if (texturemanager != null) + { + texturemanager.bindTexture(ModelSieveAutomatic.texture); + } + } + + protected void bindMeshTexture() + { + TextureManager texturemanager = Minecraft.getMinecraft().getTextureManager(); + + if (texturemanager != null) + { + texturemanager.bindTexture(TextureMap.locationBlocksTexture); + } + } +} diff --git a/src/main/java/ExAstris/Block/Render/RenderSieveAutomatic.java b/src/main/java/ExAstris/Block/Render/RenderSieveAutomatic.java new file mode 100644 index 0000000..3fcdb33 --- /dev/null +++ b/src/main/java/ExAstris/Block/Render/RenderSieveAutomatic.java @@ -0,0 +1,103 @@ +package ExAstris.Block.Render; + +import org.lwjgl.opengl.GL11; + +import exnihilo.blocks.models.ModelSieveContents; +import exnihilo.blocks.models.ModelSieveMesh; +import ExAstris.Block.BlockSieveAutomatic; +import ExAstris.Block.Model.ModelSieveAutomatic; +import ExAstris.Block.TileEntity.TileEntitySieveAutomatic; +import ExAstris.Block.TileEntity.TileEntitySieveAutomatic.SieveMode; +//import exnihilo.blocks.BlockSieve; +//import exnihilo.blocks.models.ModelSieveContents; +//import exnihilo.blocks.models.ModelSieveMesh; +import net.minecraft.client.renderer.texture.TextureMap; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.IIcon; + +public class RenderSieveAutomatic extends TileEntitySpecialRenderer { + private ModelSieveAutomatic model; + private ModelSieveMesh mesh; + private ModelSieveContents contents; + + public RenderSieveAutomatic(ModelSieveAutomatic model, ModelSieveMesh mesh) + { + this.model = model; + this.mesh = mesh; + this.contents = new ModelSieveContents(); + } + + @Override + public void renderTileEntityAt(TileEntity tileentity, double x, double y, double z, float f) { + renderTable(tileentity, x, y, z, f); + renderMesh(tileentity, x, y, z, f); + renderContents(tileentity, x, y, z, f); + } + + + private void renderTable(TileEntity tileentity, double x, double y, double z, float f) + { + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F,(float)y + 1.5F,(float)z + 0.5F); + GL11.glScalef(-1F, -1F, 1F); + + bindSieveTexture(tileentity.getBlockMetadata()); + model.simpleRender(0.0625F); + + GL11.glPopMatrix(); + } + + private void renderMesh(TileEntity tileentity, double x, double y, double z, float f) + { + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F,(float)y + 0.69F,(float)z + 0.5F); + //GL11.glScalef(-1F, -1F, 1F); + + bindTexture(TextureMap.locationBlocksTexture); + mesh.render(BlockSieveAutomatic.meshIcon); + + GL11.glPopMatrix(); + } + + private void renderContents(TileEntity tileentity, double x, double y, double z, float f) + { + TileEntitySieveAutomatic sieve = (TileEntitySieveAutomatic)tileentity; + IIcon icon = null; + + switch (sieve.mode) + { + case FILLED: + icon = sieve.content.getIcon(0, sieve.contentMeta); + break; + default: + break; + } + + if (sieve.mode != SieveMode.EMPTY) + { + bindTexture(TextureMap.locationBlocksTexture); + + //TOP! + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F,(float)y + sieve.getAdjustedVolume(),(float)z + 0.5F); + + contents.renderTop(icon); + + GL11.glPopMatrix(); + + //BOTTOM! + GL11.glPushMatrix(); + GL11.glTranslatef((float)x + 0.5F,(float)y + 0.70f,(float)z + 0.5F); + + contents.renderBottom(icon); + + GL11.glPopMatrix(); + } + } + + public void bindSieveTexture(int meta) + { + bindTexture(ModelSieveAutomatic.texture); + } +} diff --git a/src/main/java/ExAstris/Block/TileEntity/TileEntitySieveAutomatic.java b/src/main/java/ExAstris/Block/TileEntity/TileEntitySieveAutomatic.java new file mode 100644 index 0000000..5d6cfb8 --- /dev/null +++ b/src/main/java/ExAstris/Block/TileEntity/TileEntitySieveAutomatic.java @@ -0,0 +1,458 @@ +package ExAstris.Block.TileEntity; + +import java.util.ArrayList; +import java.util.Iterator; + +import cofh.api.energy.EnergyStorage; +import cofh.api.energy.IEnergyHandler; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import exnihilo.particles.ParticleSieve; +import exnihilo.registries.SieveRegistry; +import exnihilo.registries.helpers.SiftReward; +import net.minecraft.block.Block; +import net.minecraft.client.Minecraft; +import net.minecraft.entity.item.EntityItem; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.ISidedInventory; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +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.IIcon; +import net.minecraftforge.common.util.ForgeDirection; + +public class TileEntitySieveAutomatic extends TileEntity implements IEnergyHandler, ISidedInventory { + public EnergyStorage storage = new EnergyStorage(32000); + private static final int energyPerCycle = 100; + private static final float MIN_RENDER_CAPACITY = 0.70f; + private static final float MAX_RENDER_CAPACITY = 0.9f; + private static final float PROCESSING_INTERVAL = 0.075f; + private static final int UPDATE_INTERVAL = 20; + + protected ItemStack[] inventory; + + public Block content; + public int contentMeta = 0; + + private float volume = 0; + public SieveMode mode = SieveMode.EMPTY; + + private int timer = 0; + private boolean update = false; + private boolean particleMode = false; + private int timesClicked = 0; + + public enum SieveMode + {EMPTY(0), FILLED(1); + private SieveMode(int v){this.value = v;} + public int value; + } + + public TileEntitySieveAutomatic() + { + mode = SieveMode.EMPTY; + inventory = new ItemStack[getSizeInventory()]; + } + + public void addSievable(Block block, int blockMeta) + { + this.content = block; + this.contentMeta = blockMeta; + + this.mode = SieveMode.FILLED; + + volume = 1.0f; + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + + @Override + public void updateEntity() + { + if(worldObj.isRemote && particleMode) + { + spawnFX(content, contentMeta); + } + + timer++; + if (timer >= UPDATE_INTERVAL) + { + timesClicked = 0; + + timer = 0; + disableParticles(); + + if (update) + { + update(); + } + } + + + + //addd + if(storage.getEnergyStored() > energyPerCycle) + { + if (mode == SieveMode.EMPTY && inventory[0] != null) + { + ItemStack held = inventory[0]; + if (SieveRegistry.Contains(Block.getBlockFromItem(held.getItem()), held.getItemDamage())) + { + addSievable(Block.getBlockFromItem(held.getItem()), held.getItemDamage()); + decrStackSize(0,1); + storage.extractEnergy(energyPerCycle, false); + } + }else if(mode != SieveMode.EMPTY) + { + ProcessContents(false); + } + } + + //adddend + } + + public void ProcessContents(boolean creative) + { + if (creative) + { + volume = 0; + }else + { + timesClicked++; + if (timesClicked <= 6) + { + volume -= PROCESSING_INTERVAL; + storage.extractEnergy(energyPerCycle, false); + } + } + + if (volume <= 0) + { + mode = SieveMode.EMPTY; + //give rewards! + if (!worldObj.isRemote) + { + ArrayList rewards = SieveRegistry.getRewards(content, contentMeta); + if (rewards.size() > 0) + { + Iterator it = rewards.iterator(); + while(it.hasNext()) + { + SiftReward reward = it.next(); + + int size = getSizeInventory(); + int inventoryIndex = 0; + for(int i = 1; i < size; i++) + { + if(inventory[i] == null) + { + inventoryIndex=i; + break; + }else{ + if( inventory[i].getUnlocalizedName().equals(new ItemStack(reward.item, 1, reward.meta).getUnlocalizedName())) + { + inventoryIndex=i; + break; + } + } + } + + + if(inventoryIndex != 0) + { + if(inventory[inventoryIndex] != null) inventory[inventoryIndex] = new ItemStack(reward.item, (inventory[inventoryIndex].stackSize + 1), reward.meta); + else inventory[inventoryIndex] = new ItemStack(reward.item, 1, reward.meta); + } + else + { + if (worldObj.rand.nextInt(reward.rarity) == 0) + { + EntityItem entityitem = new EntityItem(worldObj, (double)xCoord + 0.5D, (double)yCoord + 1.5D, (double)zCoord + 0.5D, new ItemStack(reward.item, 1, reward.meta)); + + double f3 = 0.05F; + entityitem.motionX = worldObj.rand.nextGaussian() * f3; + entityitem.motionY = (0.2d); + entityitem.motionZ = worldObj.rand.nextGaussian() * f3; + + worldObj.spawnEntityInWorld(entityitem); + + //System.out.println("Spawning: " + reward.id); + } + } + + } + } + } + } + else + { + particleMode = true; + } + + update = true; + } + + @SideOnly(Side.CLIENT) + private void spawnFX(Block block, int blockMeta) + { + if (block != null) + { + IIcon icon = block.getIcon(0, blockMeta); + + for (int x = 0; x < 4; x++) + { + ParticleSieve dust = new ParticleSieve(worldObj, + xCoord + 0.8d * worldObj.rand.nextFloat() + 0.15d, + yCoord + 0.69d, + zCoord + 0.8d * worldObj.rand.nextFloat() + 0.15d, + 0.0d, 0.0d, 0.0d, icon); + + Minecraft.getMinecraft().effectRenderer.addEffect(dust); + } + } + } + + public float getVolume() { + return volume; + } + + public float getAdjustedVolume() + { + float capacity = MAX_RENDER_CAPACITY - MIN_RENDER_CAPACITY; + float adjusted = volume * capacity; + adjusted += MIN_RENDER_CAPACITY; + return adjusted; + } + + private void update() + { + update = false; + worldObj.markBlockForUpdate(xCoord, yCoord, zCoord); + } + + private void disableParticles() + { + particleMode = false; + } + + @Override + public void readFromNBT(NBTTagCompound compound) + { + super.readFromNBT(compound); + + switch (compound.getInteger("mode")) + { + case 0: + mode = SieveMode.EMPTY; + break; + + case 1: + mode = SieveMode.FILLED; + break; + } + if(!compound.getString("content").equals("")) { + content = (Block)Block.blockRegistry.getObject(compound.getString("content")); + }else{ + content = null; + } + contentMeta = compound.getInteger("contentMeta"); + volume = compound.getFloat("volume"); + particleMode = compound.getBoolean("particles"); + storage.readFromNBT(compound); + } + + @Override + public void writeToNBT(NBTTagCompound compound) + { + super.writeToNBT(compound); + compound.setInteger("mode", mode.value); + //Should change later to not be dependent on DV, as Forge can now change them willy-nilly at startup + if(content == null) { + compound.setString("content", ""); + }else{ + compound.setString("content", Block.blockRegistry.getNameForObject(content)); + } + compound.setInteger("contentMeta", contentMeta); + compound.setFloat("volume", volume); + compound.setBoolean("particles", particleMode); + storage.writeToNBT(compound); + } + + @Override + public Packet getDescriptionPacket() + { + NBTTagCompound tag = new NBTTagCompound(); + this.writeToNBT(tag); + + return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, this.blockMetadata, tag); + } + + @Override + public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) + { + NBTTagCompound tag = pkt.func_148857_g(); + this.readFromNBT(tag); + } + // Thermal Expansion !!! + + /* IEnergyHandler */ + @Override + public boolean canConnectEnergy(ForgeDirection from) { + + return true; + } + + @Override + public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) { + + return storage.receiveEnergy(maxReceive, simulate); + } + + @Override + public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate) { + return storage.extractEnergy(maxExtract, simulate); + } + + @Override + public int getEnergyStored(ForgeDirection from) { + + return storage.getEnergyStored(); + } + + @Override + public int getMaxEnergyStored(ForgeDirection from) { + + return storage.getMaxEnergyStored(); + } + + //ISidedInventory! + @Override + public int getSizeInventory() { + return 31; + } + + @Override + public ItemStack getStackInSlot(int slot) { + return inventory[slot]; + } + + @Override + public ItemStack decrStackSize(int slot, int amount) { + if(inventory[slot] != null) + { + if(inventory[slot].stackSize <= amount) + { + ItemStack itemstack = inventory[slot]; + inventory[slot] = null; + //onFactoryInventoryChanged(); + return itemstack; + } + ItemStack itemstack1 = inventory[slot].splitStack(amount); + if(inventory[slot].stackSize == 0) + { + inventory[slot] = null; + } + return itemstack1; + } + else + { + //onFactoryInventoryChanged(); + return null; + } + } + + @Override + public ItemStack getStackInSlotOnClosing(int i) { + return null; + } + + @Override + public void setInventorySlotContents(int slot, ItemStack stack) { + // ADD FROM PIPE + inventory[slot] = stack; + if(stack != null && stack.stackSize > getInventoryStackLimit()) + { + stack.stackSize = getInventoryStackLimit(); + } + + } + + @Override + public String getInventoryName() { + // TODO Auto-generated method stub + return null; + } + + @Override + public boolean hasCustomInventoryName() { + // TODO Auto-generated method stub + return false; + } + + @Override + public int getInventoryStackLimit() { + // TODO Auto-generated method stub + return 64; + } + + @Override + public boolean isUseableByPlayer(EntityPlayer p_70300_1_) { + // TODO Auto-generated method stub + return false; + } + + @Override + public void openInventory() { + // TODO Auto-generated method stub + + } + + @Override + public void closeInventory() { + // TODO Auto-generated method stub + + } + + @Override + public boolean isItemValidForSlot(int slot, ItemStack item) { + //SieveRegistry.Contains(Block.getBlockFromItem(item.getItem()),item.getItemDamage()) && + if (SieveRegistry.Contains(Block.getBlockFromItem(item.getItem()),item.getItemDamage()) && slot == 0) + { + return true; + } + return false; + } + + @Override + public int[] getAccessibleSlotsFromSide(int side) { + // TODO Auto-generated method stub + int size = getSizeInventory(); + int[] slots = new int[size]; + for(int i = 0; i < size; i++) + { + slots[i] = i; + } + return slots; + } + + @Override + public boolean canInsertItem(int slot, ItemStack item, int side) { + //SieveRegistry.Contains(Block.getBlockFromItem(item.getItem()),item.getItemDamage()) && + if (SieveRegistry.Contains(Block.getBlockFromItem(item.getItem()),item.getItemDamage()) && slot == 0) + { + //ExAstris.ExAstris.log.info("IMPORTANT INFO : slot "+slot+" side "+side); + return true; + } + return false; + //return false; + } + + @Override + public boolean canExtractItem(int slot, ItemStack item, int side) { + if (slot >= 1) return true; + return false; + } +} diff --git a/src/main/java/ExAstris/Bridge/Waila.java b/src/main/java/ExAstris/Bridge/Waila.java index 225d4e4..438f322 100644 --- a/src/main/java/ExAstris/Bridge/Waila.java +++ b/src/main/java/ExAstris/Bridge/Waila.java @@ -4,8 +4,11 @@ import java.util.List; import ExAstris.Block.BlockBarrelThaumium; +import ExAstris.Block.BlockSieveAutomatic; import ExAstris.Block.TileEntity.TileEntityBarrelThaumium; import ExAstris.Block.TileEntity.TileEntityBarrelThaumium.BarrelMode; +import ExAstris.Block.TileEntity.TileEntitySieveAutomatic; +import ExAstris.Block.TileEntity.TileEntitySieveAutomatic.SieveMode; import net.minecraft.item.ItemStack; import mcp.mobius.waila.api.IWailaConfigHandler; import mcp.mobius.waila.api.IWailaDataAccessor; @@ -34,12 +37,22 @@ public List getWailaBody(ItemStack stack, List currentTip, .getTileEntity(); currentTip.add(getBarrelDisplay(teBarrel.getMode(), teBarrel)); } + else if (accessor.getBlock() instanceof BlockSieveAutomatic) { + TileEntitySieveAutomatic teSieve = (TileEntitySieveAutomatic) accessor + .getTileEntity(); + currentTip.add(getSieveDisplay(teSieve)); + } return currentTip; } @Override public List getWailaTail(ItemStack stack, List currentTip, IWailaDataAccessor accessor, IWailaConfigHandler config) { + if (accessor.getBlock() instanceof BlockSieveAutomatic) { + TileEntitySieveAutomatic teSieve = (TileEntitySieveAutomatic) accessor + .getTileEntity(); + currentTip.add(getSieveDisplayTail(teSieve)); + } return currentTip; } @@ -107,6 +120,16 @@ public String getBarrelDisplay(BarrelMode mode, TileEntityBarrelThaumium barrel) } } + public String getSieveDisplay(TileEntitySieveAutomatic sieve) { + if (sieve.mode == SieveMode.EMPTY) + return "Empty";// + else + return Math.round(getSieveClicksRemaining(sieve)) + "% left";// + sieve.storage.getEnergyStored() + " / " + sieve.storage.getMaxEnergyStored() + " RF" + } + + public String getSieveDisplayTail(TileEntitySieveAutomatic sieve) { + return sieve.storage.getEnergyStored() + " / " + sieve.storage.getMaxEnergyStored() + " RF"; + } public float getBarrelTimeRemaining(TileEntityBarrelThaumium barrel) { return (barrel.getTimer() / (float) 1000) * 100; } @@ -114,5 +137,10 @@ public float getBarrelTimeRemaining(TileEntityBarrelThaumium barrel) { public static void callbackRegister(IWailaRegistrar registrar) { Waila instance = new Waila(); registrar.registerBodyProvider(instance, BlockBarrelThaumium.class); + registrar.registerBodyProvider(instance, BlockSieveAutomatic.class); + registrar.registerTailProvider(instance, BlockSieveAutomatic.class); + } + public float getSieveClicksRemaining(TileEntitySieveAutomatic sieve) { + return (sieve.getVolume() / 1) * 100; } } diff --git a/src/main/java/ExAstris/Data/BlockData.java b/src/main/java/ExAstris/Data/BlockData.java index 8819351..7fdbecc 100644 --- a/src/main/java/ExAstris/Data/BlockData.java +++ b/src/main/java/ExAstris/Data/BlockData.java @@ -7,4 +7,7 @@ public class BlockData { public static final String BEE_TRAP_INFUSED_KEY = "bee_trap_infused"; public static final String BEE_TRAP_INFUSED_UNLOCALIZED_NAME = "bee_trap_infused"; + + public static final String SIEVE_AUTOMATIC_KEY = "sieve_automatic"; + public static final String SIEVE_AUTOMATIC_UNLOCALIZED_NAME = "sieve_automatic"; } diff --git a/src/main/java/ExAstris/ExAstris.java b/src/main/java/ExAstris/ExAstris.java index 0c44ae4..c75b9ac 100644 --- a/src/main/java/ExAstris/ExAstris.java +++ b/src/main/java/ExAstris/ExAstris.java @@ -45,6 +45,7 @@ public void PreInitialize(FMLPreInitializationEvent event) @EventHandler public void Initialize(FMLInitializationEvent event) { + ExAstrisRecipe.registerCraftingRecipes(); FMLInterModComms.sendMessage("Waila", "register", "ExAstris.Bridge.Waila.callbackRegister"); } @EventHandler diff --git a/src/main/java/ExAstris/ExAstrisBlock.java b/src/main/java/ExAstris/ExAstrisBlock.java index 3c43e25..a39c010 100644 --- a/src/main/java/ExAstris/ExAstrisBlock.java +++ b/src/main/java/ExAstris/ExAstrisBlock.java @@ -2,7 +2,9 @@ import ExAstris.Block.BlockBarrelThaumium; import ExAstris.Block.BlockBeeTrapInfused; +import ExAstris.Block.BlockSieveAutomatic; import ExAstris.Block.ItemBlock.ItemBlockBarrelThaumium; +import ExAstris.Block.ItemBlock.ItemBlockSieveAutomatic; import ExAstris.Data.BlockData; import cpw.mods.fml.common.registry.GameRegistry; import net.minecraft.block.Block; @@ -10,6 +12,7 @@ public class ExAstrisBlock { public static Block BarrelThaumium; public static Block BeeTrapInfused; + public static Block SieveAutomatic; public static void registerBlocks() { BarrelThaumium = new BlockBarrelThaumium(); @@ -17,5 +20,8 @@ public static void registerBlocks() BeeTrapInfused = new BlockBeeTrapInfused(); GameRegistry.registerBlock(BeeTrapInfused, BlockData.BEE_TRAP_INFUSED_KEY); + + SieveAutomatic = new BlockSieveAutomatic(); + GameRegistry.registerBlock(SieveAutomatic, ItemBlockSieveAutomatic.class, BlockData.SIEVE_AUTOMATIC_KEY); } } diff --git a/src/main/java/ExAstris/ExAstrisItem.java b/src/main/java/ExAstris/ExAstrisItem.java index 8bb0fdd..5d9b723 100644 --- a/src/main/java/ExAstris/ExAstrisItem.java +++ b/src/main/java/ExAstris/ExAstrisItem.java @@ -6,12 +6,17 @@ import ExAstris.Item.ItemDollThaumic; import ExAstris.Item.ItemHammerRF; import ExAstris.Item.ItemHammerThaumium; +import net.minecraft.init.Blocks; import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraftforge.oredict.ShapedOreRecipe; +import redstonearsenal.item.RAItems; public class ExAstrisItem { public static Item DollThaumic; public static Item HammerThaumium; public static Item HammerRF; + public static void registerItems() { DollThaumic = new ItemDollThaumic(); @@ -22,5 +27,7 @@ public static void registerItems() HammerRF = new ItemHammerRF(); GameRegistry.registerItem(HammerRF, ItemData.HAMMER_RF_UNLOCALIZED_NAME); + + //GameRegistry.addRecipe(new ShapedOreRecipe(HammerRF, new Object[] { " a ", " ba", "b ", Character.valueOf('a'), RAItems.ingotElectrumFlux, Character.valueOf('b'), RAItems.rodObsidianFlux })); } } diff --git a/src/main/java/ExAstris/ExAstrisRecipe.java b/src/main/java/ExAstris/ExAstrisRecipe.java new file mode 100644 index 0000000..efefe62 --- /dev/null +++ b/src/main/java/ExAstris/ExAstrisRecipe.java @@ -0,0 +1,16 @@ +package ExAstris; + +import net.minecraft.item.ItemStack; +import cpw.mods.fml.common.registry.GameRegistry; + +public class ExAstrisRecipe { + public static void registerCraftingRecipes() + { + GameRegistry.addRecipe(new ItemStack(ExAstrisItem.HammerRF, 1, 0), + " x ", + " yx", + "y ", + 'x', new ItemStack(GameRegistry.findItem("RedstoneArsenal", "material"), 1, 32), + 'y', new ItemStack(GameRegistry.findItem("RedstoneArsenal", "material"), 1, 193)); + } +} diff --git a/src/main/java/ExAstris/Proxy/ProxyClient.java b/src/main/java/ExAstris/Proxy/ProxyClient.java index a1de5d3..bc891c2 100644 --- a/src/main/java/ExAstris/Proxy/ProxyClient.java +++ b/src/main/java/ExAstris/Proxy/ProxyClient.java @@ -3,11 +3,16 @@ import net.minecraft.item.Item; import net.minecraftforge.client.MinecraftForgeClient; import cpw.mods.fml.client.registry.ClientRegistry; +import exnihilo.blocks.models.ModelSieveMesh; import ExAstris.ExAstrisBlock; import ExAstris.Block.Model.ModelBarrelThaumium; +import ExAstris.Block.Model.ModelSieveAutomatic; import ExAstris.Block.Render.RenderBarrelThaumium; +import ExAstris.Block.Render.RenderSieveAutomatic; import ExAstris.Block.Render.Item.ItemRenderBarrelThaumium; +import ExAstris.Block.Render.Item.ItemRenderSieveAutomatic; import ExAstris.Block.TileEntity.TileEntityBarrelThaumium; +import ExAstris.Block.TileEntity.TileEntitySieveAutomatic; public class ProxyClient extends Proxy { public ProxyClient() @@ -20,5 +25,9 @@ public void initializeRenderers() { ClientRegistry.bindTileEntitySpecialRenderer(TileEntityBarrelThaumium.class, new RenderBarrelThaumium(barrel)); MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(ExAstrisBlock.BarrelThaumium), new ItemRenderBarrelThaumium(barrel)); + ModelSieveAutomatic sieve = new ModelSieveAutomatic(); + ModelSieveMesh mesh = new ModelSieveMesh(); + ClientRegistry.bindTileEntitySpecialRenderer(TileEntitySieveAutomatic.class, new RenderSieveAutomatic(sieve, mesh)); + MinecraftForgeClient.registerItemRenderer(Item.getItemFromBlock(ExAstrisBlock.SieveAutomatic), new ItemRenderSieveAutomatic(sieve, mesh)); } } diff --git a/src/main/resources/assets/exastris/lang/en_US.lang b/src/main/resources/assets/exastris/lang/en_US.lang index c20d9bd..f941f59 100644 --- a/src/main/resources/assets/exastris/lang/en_US.lang +++ b/src/main/resources/assets/exastris/lang/en_US.lang @@ -45,4 +45,5 @@ exnihilo.ardite_sand.name=Ardite Ore Sand exnihilo.ardite_dust.name=Ardite Ore Dust exnihilo.cobalt_ingot.name=Cobalt Ingot exnihilo.ardite_ingot.name=Ardite Ingot -exastris.hammer_rf.name=Flux-Infused Hammer \ No newline at end of file +exastris.hammer_rf.name=Flux-Infused Hammer +exastris.sieve_automatic.name=Automatic Sieve \ No newline at end of file diff --git a/src/main/resources/assets/exastris/textures/blocks/IconSieveMesh.png b/src/main/resources/assets/exastris/textures/blocks/IconSieveMesh.png new file mode 100644 index 0000000000000000000000000000000000000000..e03d70101376ea6a56a1b8c83de8c7079c957f5b GIT binary patch literal 1159 zcmbVMe`wTJ9M2H9S`muKpu^7BI7DHW{&#>6q*3+K3wTF5|66QHCEVm2>9m=(l~E@Tu#H^hvn z$sLaMu$l=oh9YTVR+k~nOBxi7yiw2vnX<}))WH`0h*-XjI(A)ZcNMEV7poc}vIq_< z7}q)-Fgk+?j%IKGjBy$4KH&Neu19;4^0cEhQRu#loI;2_(8{msu47-(pd_a?MVH%g z>)8U#%Gy9)5afJ1PknD=o&S?Fo;t%P&GDaR=^W7xOvJU;r<=9mK|Y8)>Pdl!E`^67DJsC;_)y#;sw-aQvC2aR{W z?7y(B=c7w~r~Z0*a^%_W=#Q^Qe)=SxS{|!DId$;HuA?i?*`*V;?dPxe-1&UR`Dc%^ z%RP7O`3L-POPp*>Zhm$9OUrL_%KgXlAAa`q+REGyWA`3j+E`oMs$ZGj^uZ$Cas4-6 zirK)taPG%11{UIj$*-Z9A2u)Qhfn?k D0E2(X literal 0 HcmV?d00001 diff --git a/src/main/resources/assets/exastris/textures/blocks/ModelSieveAutomatic.png b/src/main/resources/assets/exastris/textures/blocks/ModelSieveAutomatic.png new file mode 100644 index 0000000000000000000000000000000000000000..aa4d370b4659b3bccb874686e79535606e63720c GIT binary patch literal 4032 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