diff --git a/resources/assets/resonantinduction/languages/en_US.properties b/resources/assets/resonantinduction/languages/en_US.properties index b7706359..cdeeb1a7 100755 --- a/resources/assets/resonantinduction/languages/en_US.properties +++ b/resources/assets/resonantinduction/languages/en_US.properties @@ -6,6 +6,8 @@ itemGroup.resonantinduction=Resonant Induction tile.resonantinduction\:tesla.name=Tesla Coil tile.resonantinduction\:multimeter.name=Multimeter tile.resonantinduction\:contractor.name=Electromagnetic Contractor +tile.resonantinduction\:battery.name=Modular Battery ## Items -item.resonantinduction\:quantumEntangler.name=Quantum Entangler \ No newline at end of file +item.resonantinduction\:quantumEntangler.name=Quantum Entangler +item.resonantinduction\:capacitor.name=Capacitor Cell diff --git a/resources/assets/resonantinduction/textures/gui/gui_multimeter.png b/resources/assets/resonantinduction/textures/gui/gui_multimeter.png new file mode 100644 index 00000000..d7719119 Binary files /dev/null and b/resources/assets/resonantinduction/textures/gui/gui_multimeter.png differ diff --git a/resources/assets/resonantinduction/textures/items/capacitor.png b/resources/assets/resonantinduction/textures/items/capacitor.png new file mode 100644 index 00000000..181019ec Binary files /dev/null and b/resources/assets/resonantinduction/textures/items/capacitor.png differ diff --git a/src/resonantinduction/ClientProxy.java b/src/resonantinduction/ClientProxy.java index 89f25e70..fd342465 100644 --- a/src/resonantinduction/ClientProxy.java +++ b/src/resonantinduction/ClientProxy.java @@ -1,6 +1,3 @@ -/** - * - */ package resonantinduction; import net.minecraft.entity.player.EntityPlayer; @@ -14,6 +11,7 @@ import resonantinduction.multimeter.GuiMultimeter; import resonantinduction.multimeter.TileEntityMultimeter; import resonantinduction.render.BlockRenderingHandler; import resonantinduction.render.RenderEMContractor; +import resonantinduction.render.RenderMultimeter; import resonantinduction.render.RenderTesla; import resonantinduction.tesla.TileEntityTesla; import cpw.mods.fml.client.FMLClientHandler; @@ -37,6 +35,7 @@ public class ClientProxy extends CommonProxy RenderingRegistry.registerBlockHandler(BlockRenderingHandler.INSTANCE); ClientRegistry.bindTileEntitySpecialRenderer(TileEntityTesla.class, new RenderTesla()); + ClientRegistry.bindTileEntitySpecialRenderer(TileEntityMultimeter.class, new RenderMultimeter()); ClientRegistry.bindTileEntitySpecialRenderer(TileEntityEMContractor.class, new RenderEMContractor()); } diff --git a/src/resonantinduction/ResonantInduction.java b/src/resonantinduction/ResonantInduction.java index b6dacc3e..93fae1de 100644 --- a/src/resonantinduction/ResonantInduction.java +++ b/src/resonantinduction/ResonantInduction.java @@ -9,11 +9,15 @@ import net.minecraft.item.Item; import net.minecraft.item.ItemStack; import net.minecraftforge.common.Configuration; import net.minecraftforge.oredict.ShapedOreRecipe; +import resonantinduction.battery.BlockBattery; +import resonantinduction.battery.ItemCapacitor; +import resonantinduction.battery.TileEntityBattery; import resonantinduction.contractor.BlockEMContractor; import resonantinduction.contractor.ItemBlockContractor; import resonantinduction.contractor.TileEntityEMContractor; import resonantinduction.entangler.ItemQuantumEntangler; import resonantinduction.multimeter.BlockMultimeter; +import resonantinduction.multimeter.ItemBlockMultimeter; import resonantinduction.multimeter.TileEntityMultimeter; import resonantinduction.tesla.BlockTesla; import resonantinduction.tesla.TileEntityTesla; @@ -106,24 +110,26 @@ public class ResonantInduction // Items public static Item itemQuantumEntangler; + public static Item itemCapacitor; // Blocks public static Block blockTesla; public static Block blockMultimeter; public static Block blockEMContractor; + public static Block blockBattery; @EventHandler public void preInit(FMLPreInitializationEvent evt) { LOGGER.setParent(FMLLog.getLogger()); - NetworkRegistry.instance().registerGuiHandler(this, this.proxy); + NetworkRegistry.instance().registerGuiHandler(this, ResonantInduction.proxy); CONFIGURATION.load(); // Config POWER_PER_COAL = (float) CONFIGURATION.get(Configuration.CATEGORY_GENERAL, "Coal Wattage", POWER_PER_COAL).getDouble(POWER_PER_COAL); SOUND_FXS = CONFIGURATION.get(Configuration.CATEGORY_GENERAL, "Tesla Sound FXs", SOUND_FXS).getBoolean(SOUND_FXS); - + TileEntityEMContractor.ACCELERATION = CONFIGURATION.get(Configuration.CATEGORY_GENERAL, "Contractor Item Acceleration", TileEntityEMContractor.ACCELERATION).getDouble(TileEntityEMContractor.ACCELERATION); TileEntityEMContractor.MAX_REACH = CONFIGURATION.get(Configuration.CATEGORY_GENERAL, "Contractor Max Item Reach", TileEntityEMContractor.MAX_REACH).getInt(TileEntityEMContractor.MAX_REACH); TileEntityEMContractor.MAX_SPEED = CONFIGURATION.get(Configuration.CATEGORY_GENERAL, "Contractor Max Item Speed", TileEntityEMContractor.MAX_SPEED).getDouble(TileEntityEMContractor.MAX_SPEED); @@ -131,23 +137,29 @@ public class ResonantInduction // Items itemQuantumEntangler = new ItemQuantumEntangler(getNextItemID()); + itemCapacitor = new ItemCapacitor(getNextItemID()); + GameRegistry.registerItem(itemQuantumEntangler, itemQuantumEntangler.getUnlocalizedName()); + GameRegistry.registerItem(itemCapacitor, itemCapacitor.getUnlocalizedName()); // Blocks blockTesla = new BlockTesla(getNextBlockID()); blockMultimeter = new BlockMultimeter(getNextBlockID()); blockEMContractor = new BlockEMContractor(getNextBlockID()); + blockBattery = new BlockBattery(getNextBlockID()); CONFIGURATION.save(); GameRegistry.registerBlock(blockTesla, blockTesla.getUnlocalizedName()); - GameRegistry.registerBlock(blockMultimeter, blockMultimeter.getUnlocalizedName()); + GameRegistry.registerBlock(blockMultimeter, ItemBlockMultimeter.class, blockMultimeter.getUnlocalizedName()); GameRegistry.registerBlock(blockEMContractor, ItemBlockContractor.class, blockEMContractor.getUnlocalizedName()); + GameRegistry.registerBlock(blockBattery, blockBattery.getUnlocalizedName()); // Tiles GameRegistry.registerTileEntity(TileEntityTesla.class, blockTesla.getUnlocalizedName()); GameRegistry.registerTileEntity(TileEntityMultimeter.class, blockMultimeter.getUnlocalizedName()); GameRegistry.registerTileEntity(TileEntityEMContractor.class, blockEMContractor.getUnlocalizedName()); + GameRegistry.registerTileEntity(TileEntityBattery.class, blockBattery.getUnlocalizedName()); ResonantInduction.proxy.registerRenderers(); diff --git a/src/resonantinduction/api/IBattery.java b/src/resonantinduction/api/IBattery.java new file mode 100644 index 00000000..714324f3 --- /dev/null +++ b/src/resonantinduction/api/IBattery.java @@ -0,0 +1,15 @@ +/** + * + */ +package resonantinduction.api; + +/** + * @author Calclavia + * + */ +public interface IBattery +{ + public float getEnergyStored(); + + public float getMaxEnergyStored(); +} diff --git a/src/resonantinduction/base/TileEntityBase.java b/src/resonantinduction/base/TileEntityBase.java index 53d7787e..0a09c75a 100644 --- a/src/resonantinduction/base/TileEntityBase.java +++ b/src/resonantinduction/base/TileEntityBase.java @@ -3,7 +3,13 @@ */ package resonantinduction.base; +import java.util.HashSet; +import java.util.Set; + +import net.minecraft.entity.player.EntityPlayer; import net.minecraft.tileentity.TileEntity; +import cpw.mods.fml.common.network.PacketDispatcher; +import cpw.mods.fml.common.network.Player; /** * @author Calclavia @@ -12,6 +18,7 @@ import net.minecraft.tileentity.TileEntity; public class TileEntityBase extends TileEntity { protected long ticks = 0; + public Set playersUsing = new HashSet(); public void initiate() { @@ -28,5 +35,9 @@ public class TileEntityBase extends TileEntity this.initiate(); } + for (EntityPlayer player : this.playersUsing) + { + PacketDispatcher.sendPacketToPlayer(this.getDescriptionPacket(), (Player) player); + } } } diff --git a/src/resonantinduction/base/Vector3.java b/src/resonantinduction/base/Vector3.java index 956740e9..35c9d434 100644 --- a/src/resonantinduction/base/Vector3.java +++ b/src/resonantinduction/base/Vector3.java @@ -135,7 +135,7 @@ public class Vector3 return new Vector3(this.x + offset.x, this.y + offset.y, this.z + offset.z); } - public Vector3 translate(int offset) + public Vector3 translate(double offset) { return new Vector3(this.x + offset, this.y + offset, this.z + offset); } diff --git a/src/resonantinduction/battery/BatteryController.java b/src/resonantinduction/battery/BatteryController.java new file mode 100644 index 00000000..4eebb9e3 --- /dev/null +++ b/src/resonantinduction/battery/BatteryController.java @@ -0,0 +1,23 @@ +/** + * + */ +package resonantinduction.battery; + +import java.util.HashSet; +import java.util.Set; + +/** + * Multiblock battery controller + * + * @author Calclavia + * + */ +public class BatteryController +{ + public Set connectedBlocks = new HashSet(); + + public void update() + { + + } +} diff --git a/src/resonantinduction/battery/BlockBattery.java b/src/resonantinduction/battery/BlockBattery.java new file mode 100644 index 00000000..2b20ad1c --- /dev/null +++ b/src/resonantinduction/battery/BlockBattery.java @@ -0,0 +1,81 @@ +/** + * + */ +package resonantinduction.battery; + +import net.minecraft.block.ITileEntityProvider; +import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.entity.EntityLivingBase; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.Icon; +import net.minecraft.util.MathHelper; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; +import net.minecraftforge.common.ForgeDirection; +import resonantinduction.ResonantInduction; +import resonantinduction.base.BlockBase; +import resonantinduction.multimeter.TileEntityMultimeter; + +/** + * A block that detects power. + * + * @author Calclavia + * + */ +public class BlockBattery extends BlockBase implements ITileEntityProvider +{ + private Icon machineIcon; + + public BlockBattery(int id) + { + super("battery", id, Material.iron); + } + + @Override + public Icon getIcon(int side, int metadata) + { + if (side == metadata) + { + return this.blockIcon; + } + + return this.machineIcon; + } + + @Override + public void registerIcons(IconRegister iconRegister) + { + super.registerIcons(iconRegister); + this.machineIcon = iconRegister.registerIcon(ResonantInduction.PREFIX + "machine"); + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float par7, float par8, float par9) + { + if (entityPlayer.isSneaking()) + { + world.setBlockMetadataWithNotify(x, y, z, ForgeDirection.ROTATION_MATRIX[world.getBlockMetadata(x, y, z)][side], 3); + } + else + { + + } + + return true; + } + + @Override + public boolean renderAsNormalBlock() + { + return false; + } + + @Override + public TileEntity createNewTileEntity(World world) + { + return new TileEntityBattery(); + } +} diff --git a/src/resonantinduction/battery/ItemCapacitor.java b/src/resonantinduction/battery/ItemCapacitor.java new file mode 100644 index 00000000..04ed4ae0 --- /dev/null +++ b/src/resonantinduction/battery/ItemCapacitor.java @@ -0,0 +1,23 @@ +/** + * + */ +package resonantinduction.battery; + +import resonantinduction.base.ItemBase; + +/** + * Stores power. + * + * @author Calclavia + * + */ +public class ItemCapacitor extends ItemBase +{ + public ItemCapacitor(int id) + { + super("capacitor", id); + this.setMaxStackSize(1); + this.setMaxDamage(1000); + } + +} diff --git a/src/resonantinduction/battery/TileEntityBattery.java b/src/resonantinduction/battery/TileEntityBattery.java new file mode 100644 index 00000000..ef14f874 --- /dev/null +++ b/src/resonantinduction/battery/TileEntityBattery.java @@ -0,0 +1,180 @@ +/** + * + */ +package resonantinduction.battery; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.inventory.IInventory; +import net.minecraft.item.ItemStack; +import resonantinduction.api.IBattery; +import resonantinduction.base.TileEntityBase; + +/** + * A modular battery with no GUI. + * + * @author Calclavia + */ +public class TileEntityBattery extends TileEntityBase implements IInventory +{ + private ItemStack[] inventory = new ItemStack[4 * 4]; + private byte[] sideStatus = new byte[] { 0, 0, 0, 0, 0, 0 }; + + // TODO: Multiblock power storage. + private BatteryController controller; + + @Override + public void updateEntity() + { + + } + + public float getMaxEnergyStored() + { + float max = 0; + + for (int i = 0; i < this.getSizeInventory(); i++) + { + ItemStack itemStack = this.getStackInSlot(i); + + if (itemStack != null) + { + if (itemStack.getItem() instanceof IBattery) + { + max += ((IBattery) itemStack.getItem()).getMaxEnergyStored(); + } + } + } + + return max; + } + + /** + * Returns the number of slots in the inventory. + */ + public int getSizeInventory() + { + return this.inventory.length; + } + + /** + * Returns the stack in slot i + */ + public ItemStack getStackInSlot(int par1) + { + return this.inventory[par1]; + } + + /** + * Removes from an inventory slot (first arg) up to a specified number (second arg) of items and + * returns them in a new stack. + */ + public ItemStack decrStackSize(int par1, int par2) + { + if (this.inventory[par1] != null) + { + ItemStack itemstack; + + if (this.inventory[par1].stackSize <= par2) + { + itemstack = this.inventory[par1]; + this.inventory[par1] = null; + return itemstack; + } + else + { + itemstack = this.inventory[par1].splitStack(par2); + + if (this.inventory[par1].stackSize == 0) + { + this.inventory[par1] = null; + } + + return itemstack; + } + } + else + { + return null; + } + } + + /** + * When some containers are closed they call this on each slot, then drop whatever it returns as + * an EntityItem - like when you close a workbench GUI. + */ + public ItemStack getStackInSlotOnClosing(int par1) + { + if (this.inventory[par1] != null) + { + ItemStack itemstack = this.inventory[par1]; + this.inventory[par1] = null; + return itemstack; + } + else + { + return null; + } + } + + /** + * Sets the given item stack to the specified slot in the inventory (can be crafting or armor + * sections). + */ + public void setInventorySlotContents(int par1, ItemStack par2ItemStack) + { + this.inventory[par1] = par2ItemStack; + + if (par2ItemStack != null && par2ItemStack.stackSize > this.getInventoryStackLimit()) + { + par2ItemStack.stackSize = this.getInventoryStackLimit(); + } + } + + @Override + public String getInvName() + { + return this.getBlockType().getLocalizedName(); + } + + @Override + public boolean isInvNameLocalized() + { + return true; + } + + @Override + public int getInventoryStackLimit() + { + return 0; + } + + @Override + public boolean isUseableByPlayer(EntityPlayer entityplayer) + { + // TODO Auto-generated method stub + return false; + } + + /* + * (non-Javadoc) + * + * @see net.minecraft.inventory.IInventory#openChest() + */ + @Override + public void openChest() + { + + } + + @Override + public void closeChest() + { + + } + + @Override + public boolean isItemValidForSlot(int i, ItemStack itemstack) + { + return false; + } +} diff --git a/src/resonantinduction/fx/FXElectricBolt.java b/src/resonantinduction/fx/FXElectricBolt.java index 7a368689..c8c87146 100644 --- a/src/resonantinduction/fx/FXElectricBolt.java +++ b/src/resonantinduction/fx/FXElectricBolt.java @@ -85,12 +85,12 @@ public class FXElectricBolt extends EntityFX this.segments.add(new BoltSegment(this.start, this.end)); this.recalculate(); double offsetRatio = this.boltLength * this.complexity; - this.split(2, offsetRatio / 8, 0.7f, 0.1f, 20); - this.split(2, offsetRatio / 12, 0.5f, 0.1f, 25); - this.split(2, offsetRatio / 24, 0.5f, 0.1f, 28); - this.split(2, offsetRatio / 32, 0.5f, 0.1f, 30); - this.split(2, offsetRatio / 48, 0, 0, 0); - this.split(2, offsetRatio / 64, 0, 0, 0); + this.split(2, offsetRatio / 10, 0.7f, 0.1f, 20); + this.split(2, offsetRatio / 15, 0.5f, 0.1f, 25); + this.split(2, offsetRatio / 25, 0.5f, 0.1f, 28); + this.split(2, offsetRatio / 38, 0.5f, 0.1f, 30); + this.split(2, offsetRatio / 55, 0, 0, 0); + this.split(2, offsetRatio / 70, 0, 0, 0); this.recalculate(); @@ -154,7 +154,7 @@ public class FXElectricBolt extends EntityFX */ for (int i = 1; i < splitAmount; i++) { - Vector3 newOffset = segment.difference.getPerpendicular().rotate(this.rand.nextFloat() * 180, segment.difference).scale((this.rand.nextFloat() - 0.5F) * offset); + Vector3 newOffset = segment.difference.getPerpendicular().rotate(this.rand.nextFloat() * 360, segment.difference).scale((this.rand.nextFloat() - 0.5F) * offset); Vector3 basePoint = startPoint.clone().translate(subSegment.clone().scale(i)); newPoints[i] = new BoltPoint(basePoint, newOffset); @@ -172,7 +172,7 @@ public class FXElectricBolt extends EntityFX if ((i != 0) && (this.rand.nextFloat() < splitChance)) { - Vector3 splitrot = next.difference.xCrossProduct().rotate(this.rand.nextFloat() * 180, next.difference); + Vector3 splitrot = next.difference.xCrossProduct().rotate(this.rand.nextFloat() * 360, next.difference); Vector3 diff = next.difference.clone().rotate((this.rand.nextFloat() * 0.66F + 0.33F) * splitAngle, splitrot).scale(splitLength); this.maxSplitID += 1; this.parentIDMap.put(this.maxSplitID, next.splitID); diff --git a/src/resonantinduction/model/ModelEMContractor.java b/src/resonantinduction/model/ModelEMContractor.java index 60f5d23a..e5bea4a0 100644 --- a/src/resonantinduction/model/ModelEMContractor.java +++ b/src/resonantinduction/model/ModelEMContractor.java @@ -225,14 +225,14 @@ public class ModelEMContractor extends ModelBase public void render(float f5, boolean rotate) { - if(rotate) + if (rotate) { Coil1.rotateAngleY = (float)Math.toRadians(Math.toDegrees(Coil1.rotateAngleY)+3 < 360 ? Math.toDegrees(Coil1.rotateAngleY)+3 : 0); coil2.rotateAngleY = (float)Math.toRadians(Math.toDegrees(coil2.rotateAngleY)+3 < 360 ? Math.toDegrees(coil2.rotateAngleY)+3 : 0); coil3.rotateAngleY = (float)Math.toRadians(Math.toDegrees(coil3.rotateAngleY)+3 < 360 ? Math.toDegrees(coil3.rotateAngleY)+3 : 0); coil4.rotateAngleY = (float)Math.toRadians(Math.toDegrees(coil4.rotateAngleY)+3 < 360 ? Math.toDegrees(coil4.rotateAngleY)+3 : 0); } - + frame1.render(f5); frame2.render(f5); frame3.render(f5); diff --git a/src/resonantinduction/multimeter/BlockMultimeter.java b/src/resonantinduction/multimeter/BlockMultimeter.java index 51efe8d4..48cb2c6e 100644 --- a/src/resonantinduction/multimeter/BlockMultimeter.java +++ b/src/resonantinduction/multimeter/BlockMultimeter.java @@ -5,9 +5,16 @@ package resonantinduction.multimeter; import net.minecraft.block.ITileEntityProvider; import net.minecraft.block.material.Material; +import net.minecraft.client.renderer.texture.IconRegister; +import net.minecraft.entity.EntityLivingBase; import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemStack; import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.Icon; +import net.minecraft.util.MathHelper; +import net.minecraft.world.IBlockAccess; import net.minecraft.world.World; +import net.minecraftforge.common.ForgeDirection; import resonantinduction.ResonantInduction; import resonantinduction.base.BlockBase; @@ -19,18 +26,104 @@ import resonantinduction.base.BlockBase; */ public class BlockMultimeter extends BlockBase implements ITileEntityProvider { + private Icon machineIcon; + public BlockMultimeter(int id) { super("multimeter", id, Material.iron); } - @Override - public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int par6, float par7, float par8, float par9) + public static int determineOrientation(World par0World, int par1, int par2, int par3, EntityLivingBase par4EntityLivingBase) { - entityPlayer.openGui(ResonantInduction.INSTNACE, 0, world, x, y, z); + if (MathHelper.abs((float) par4EntityLivingBase.posX - par1) < 2.0F && MathHelper.abs((float) par4EntityLivingBase.posZ - par3) < 2.0F) + { + double d0 = par4EntityLivingBase.posY + 1.82D - par4EntityLivingBase.yOffset; + + if (d0 - par2 > 2.0D) + { + return 1; + } + + if (par2 - d0 > 0.0D) + { + return 0; + } + } + + int l = MathHelper.floor_double(par4EntityLivingBase.rotationYaw * 4.0F / 360.0F + 0.5D) & 3; + return l == 0 ? 2 : (l == 1 ? 5 : (l == 2 ? 3 : (l == 3 ? 4 : 0))); + } + + @Override + public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase par5EntityLivingBase, ItemStack par6ItemStack) + { + int l = determineOrientation(world, x, y, z, par5EntityLivingBase); + world.setBlockMetadataWithNotify(x, y, z, l, 2); + } + + @Override + public Icon getIcon(int side, int metadata) + { + if (side == metadata) + { + return this.blockIcon; + } + + return this.machineIcon; + } + + @Override + public void registerIcons(IconRegister iconRegister) + { + super.registerIcons(iconRegister); + this.machineIcon = iconRegister.registerIcon(ResonantInduction.PREFIX + "machine"); + } + + @Override + public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer entityPlayer, int side, float par7, float par8, float par9) + { + if (entityPlayer.isSneaking()) + { + world.setBlockMetadataWithNotify(x, y, z, ForgeDirection.ROTATION_MATRIX[world.getBlockMetadata(x, y, z)][side], 3); + } + else + { + entityPlayer.openGui(ResonantInduction.INSTNACE, 0, world, x, y, z); + } + return true; } + @Override + public int isProvidingStrongPower(IBlockAccess blockAccess, int x, int y, int z, int par5) + { + return this.isProvidingWeakPower(blockAccess, x, y, z, par5); + } + + @Override + public int isProvidingWeakPower(IBlockAccess blockAccess, int x, int y, int z, int par5) + { + TileEntity tile = blockAccess.getBlockTileEntity(x, y, z); + + if (tile instanceof TileEntityMultimeter) + { + return ((TileEntityMultimeter) tile).redstoneOn ? 14 : 0; + } + return 0; + } + + @Override + public boolean canProvidePower() + { + return true; + } + + @Override + public boolean renderAsNormalBlock() + { + return false; + } + @Override public TileEntity createNewTileEntity(World world) { diff --git a/src/resonantinduction/multimeter/ContainerMultimeter.java b/src/resonantinduction/multimeter/ContainerMultimeter.java index df3e66bd..1a24ef17 100644 --- a/src/resonantinduction/multimeter/ContainerMultimeter.java +++ b/src/resonantinduction/multimeter/ContainerMultimeter.java @@ -15,9 +15,11 @@ import net.minecraft.inventory.Slot; public class ContainerMultimeter extends Container { private final int yDisplacement = 51; + private TileEntityMultimeter tileEntity; public ContainerMultimeter(InventoryPlayer inventoryPlayer, TileEntityMultimeter tileEntity) { + this.tileEntity = tileEntity; int i; for (i = 0; i < 3; ++i) @@ -32,6 +34,15 @@ public class ContainerMultimeter extends Container { this.addSlotToContainer(new Slot(inventoryPlayer, i, 8 + i * 18, 142 + yDisplacement)); } + + this.tileEntity.playersUsing.add(inventoryPlayer.player); + } + + @Override + public void onContainerClosed(EntityPlayer entityPlayer) + { + this.tileEntity.playersUsing.remove(entityPlayer); + super.onContainerClosed(entityPlayer); } @Override diff --git a/src/resonantinduction/multimeter/GuiMultimeter.java b/src/resonantinduction/multimeter/GuiMultimeter.java index cd6ae138..1904d9fb 100644 --- a/src/resonantinduction/multimeter/GuiMultimeter.java +++ b/src/resonantinduction/multimeter/GuiMultimeter.java @@ -3,12 +3,15 @@ */ package resonantinduction.multimeter; +import net.minecraft.client.gui.GuiButton; +import net.minecraft.client.gui.GuiTextField; import net.minecraft.client.gui.inventory.GuiContainer; import net.minecraft.entity.player.InventoryPlayer; import net.minecraft.util.ResourceLocation; import org.lwjgl.opengl.GL11; +import resonantinduction.PacketHandler; import resonantinduction.ResonantInduction; import cpw.mods.fml.relauncher.Side; import cpw.mods.fml.relauncher.SideOnly; @@ -22,11 +25,12 @@ import cpw.mods.fml.relauncher.SideOnly; @SideOnly(Side.CLIENT) public class GuiMultimeter extends GuiContainer { - private static final ResourceLocation TEXTURE = new ResourceLocation(ResonantInduction.DOMAIN, ResonantInduction.GUI_DIRECTORY + "gui_base.png"); + private static final ResourceLocation TEXTURE = new ResourceLocation(ResonantInduction.DOMAIN, ResonantInduction.GUI_DIRECTORY + "gui_multimeter.png"); TileEntityMultimeter tileEntity; private int containerWidth; private int containerHeight; + private GuiTextField textFieldLimit; public GuiMultimeter(InventoryPlayer inventoryPlayer, TileEntityMultimeter tileEntity) { @@ -35,12 +39,50 @@ public class GuiMultimeter extends GuiContainer this.ySize = 217; } + @Override + public void initGui() + { + super.initGui(); + this.buttonList.add(new GuiButton(0, this.width / 2 + 20, this.height / 2 - 30, 50, 20, "Toggle")); + this.textFieldLimit = new GuiTextField(fontRenderer, 35, 82, 65, 12); + this.textFieldLimit.setMaxStringLength(8); + this.textFieldLimit.setText("" + this.tileEntity.getLimit()); + } + + @Override + protected void keyTyped(char par1, int par2) + { + super.keyTyped(par1, par2); + this.textFieldLimit.textboxKeyTyped(par1, par2); + + try + { + PacketHandler.sendTileEntityPacketToServer(this.tileEntity, (byte) 3, Float.parseFloat(this.textFieldLimit.getText())); + } + catch (Exception e) + { + } + } + + @Override + protected void mouseClicked(int par1, int par2, int par3) + { + super.mouseClicked(par1, par2, par3); + this.textFieldLimit.mouseClicked(par1 - this.containerWidth, par2 - this.containerHeight, par3); + } + @Override protected void drawGuiContainerForegroundLayer(int par1, int par2) { String s = this.tileEntity.getBlockType().getLocalizedName(); this.fontRenderer.drawString(s, this.xSize / 2 - this.fontRenderer.getStringWidth(s) / 2, 6, 4210752); - this.fontRenderer.drawString("Energy: " + this.tileEntity.getDetectedEnergy(), 9, 15, 4210752); + this.fontRenderer.drawString("Energy: " + Math.round(this.tileEntity.getDetectedEnergy()) + " J", 35, 32, 4210752); + this.fontRenderer.drawString("Average Energy: " + Math.round(this.tileEntity.getAverageDetectedEnergy()) + " J", 35, 20, 4210752); + this.fontRenderer.drawString("Output Redstone If... ", 35, 46, 4210752); + this.fontRenderer.drawString(this.tileEntity.getMode().display, 35, 65, 4210752); + this.fontRenderer.drawString("KiloJoules", 35, 100, 4210752); + + this.textFieldLimit.drawTextBox(); } @Override @@ -52,6 +94,19 @@ public class GuiMultimeter extends GuiContainer this.mc.renderEngine.func_110577_a(TEXTURE); GL11.glColor4f(1, 1, 1, 1); this.drawTexturedModalRect(this.containerWidth, this.containerHeight, 0, 0, this.xSize, this.ySize); + + /* + * if (this.tileEntity.getMode() != DetectMode.NONE) { int length = (int) + * (Math.abs(this.tileEntity.getDetectedEnergy() - this.tileEntity.getLimit()) / + * this.tileEntity.getLimit()) * 110; this.drawTexturedModalRect(this.containerWidth + 13, + * this.containerHeight + 128 - length, 176, 0, 30, length); } + */ + } + + @Override + protected void actionPerformed(GuiButton button) + { + PacketHandler.sendTileEntityPacketToServer(this.tileEntity, (byte) 2); } } diff --git a/src/resonantinduction/multimeter/ItemBlockMultimeter.java b/src/resonantinduction/multimeter/ItemBlockMultimeter.java new file mode 100644 index 00000000..fa76cbef --- /dev/null +++ b/src/resonantinduction/multimeter/ItemBlockMultimeter.java @@ -0,0 +1,37 @@ +/** + * + */ +package resonantinduction.multimeter; + +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.ItemBlock; +import net.minecraft.item.ItemStack; +import net.minecraft.world.World; + +/** + * ItemBlock for the Multimeter + * + * @author Calclavia + * + */ +public class ItemBlockMultimeter extends ItemBlock +{ + public ItemBlockMultimeter(int par1) + { + super(par1); + } + + public boolean onItemUse(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, World world, int x, int y, int z, int par7, float par8, float par9, float par10) + { + if (par2EntityPlayer.isSneaking()) + { + if (!world.isRemote) + { + par2EntityPlayer.addChatMessage("Energy: " + TileEntityMultimeter.getDetectedEnergy(world.getBlockTileEntity(x, y, z)) + " J"); + } + return true; + } + + return super.onItemUse(par1ItemStack, par2EntityPlayer, world, x, y, z, par7, par8, par9, par10); + } +} diff --git a/src/resonantinduction/multimeter/TileEntityMultimeter.java b/src/resonantinduction/multimeter/TileEntityMultimeter.java index 250eccb7..cf9f0ebe 100644 --- a/src/resonantinduction/multimeter/TileEntityMultimeter.java +++ b/src/resonantinduction/multimeter/TileEntityMultimeter.java @@ -3,21 +3,194 @@ */ package resonantinduction.multimeter; +import java.util.ArrayList; + +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.network.packet.Packet; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.ForgeDirection; +import resonantinduction.PacketHandler; +import resonantinduction.ResonantInduction; +import resonantinduction.base.IPacketReceiver; import resonantinduction.base.TileEntityBase; +import resonantinduction.tesla.TileEntityTesla; + +import com.google.common.io.ByteArrayDataInput; /** * @author Calclavia * */ -public class TileEntityMultimeter extends TileEntityBase +public class TileEntityMultimeter extends TileEntityBase implements IPacketReceiver { - public float getDetectedEnergy() + public enum DetectMode { + NONE("None"), LESS_THAN("Less Than"), LESS_THAN_EQUAL("Less Than or Equal"), + EQUAL("Equal"), GREATER_THAN("Greater Than or Equal"), GREATER_THAN_EQUAL("Greater Than"); + + public String display; + + private DetectMode(String display) + { + this.display = display; + } + } + + private DetectMode detectMode = DetectMode.NONE; + private float energyLimit; + private float detectedEnergy; + private float detectedAverageEnergy; + public boolean redstoneOn; + + @Override + public void updateEntity() + { + super.updateEntity(); + + if (this.ticks % 20 == 0) + { + float prevDetectedEnergy = this.detectedEnergy; + this.detectedEnergy = this.doGetDetectedEnergy(); + this.detectedAverageEnergy = (detectedAverageEnergy + this.detectedEnergy) / 2; + + boolean outputRedstone = false; + + switch (detectMode) + { + default: + break; + case EQUAL: + outputRedstone = this.detectedEnergy == this.energyLimit; + break; + case GREATER_THAN: + outputRedstone = this.detectedEnergy > this.energyLimit; + break; + case GREATER_THAN_EQUAL: + outputRedstone = this.detectedEnergy >= this.energyLimit; + break; + case LESS_THAN: + outputRedstone = this.detectedEnergy < this.energyLimit; + break; + case LESS_THAN_EQUAL: + outputRedstone = this.detectedEnergy <= this.energyLimit; + break; + } + + if (outputRedstone != this.redstoneOn) + { + this.redstoneOn = outputRedstone; + this.worldObj.notifyBlocksOfNeighborChange(this.xCoord, this.yCoord, this.zCoord, ResonantInduction.blockMultimeter.blockID); + } + + /* + * if (prevDetectedEnergy != this.detectedEnergy) { + * this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord); } + */ + } + } + + @Override + public Packet getDescriptionPacket() + { + return PacketHandler.getTileEntityPacket(this, (byte) 1, (byte) this.detectMode.ordinal(), this.energyLimit); + } + + @Override + public void handle(ByteArrayDataInput input) + { + try + { + switch (input.readByte()) + { + default: + this.detectMode = DetectMode.values()[input.readByte()]; + this.energyLimit = input.readFloat(); + break; + case 2: + this.toggleMode(); + break; + case 3: + this.energyLimit = input.readFloat(); + break; + } + } + catch (Exception e) + { + e.printStackTrace(); + } + } + + @Override + public ArrayList getNetworkedData(ArrayList data) + { + return null; + } + + public float doGetDetectedEnergy() + { + ForgeDirection direction = ForgeDirection.getOrientation(this.worldObj.getBlockMetadata(this.xCoord, this.yCoord, this.zCoord)); + ForgeDirection opp = direction.getOpposite(); + TileEntity tileEntity = this.worldObj.getBlockTileEntity(this.xCoord + opp.offsetX, this.yCoord + opp.offsetY, this.zCoord + opp.offsetZ); + + return getDetectedEnergy(tileEntity); + } + + public static float getDetectedEnergy(TileEntity tileEntity) + { + // TODO: Universal Compatiblity in the future. + if (tileEntity instanceof TileEntityTesla) + { + return ((TileEntityTesla) tileEntity).getEnergyStored(); + } + return 0; } - public boolean canUpdate() + public float getDetectedEnergy() { - return false; + return this.detectedEnergy; } + + public float getAverageDetectedEnergy() + { + return this.detectedAverageEnergy; + } + + public void toggleMode() + { + this.detectMode = DetectMode.values()[(this.detectMode.ordinal() + 1) % DetectMode.values().length]; + } + + /** + * Reads a tile entity from NBT. + */ + @Override + public void readFromNBT(NBTTagCompound nbt) + { + super.readFromNBT(nbt); + this.detectMode = DetectMode.values()[nbt.getInteger("detectMode")]; + this.energyLimit = nbt.getFloat("energyLimit"); + } + + /** + * Writes a tile entity to NBT. + */ + @Override + public void writeToNBT(NBTTagCompound nbt) + { + super.writeToNBT(nbt); + nbt.setInteger("detectMode", this.detectMode.ordinal()); + nbt.setFloat("energyLimit", this.energyLimit); + } + + public DetectMode getMode() + { + return this.detectMode; + } + + public float getLimit() + { + return this.energyLimit; + } + } diff --git a/src/resonantinduction/render/RenderMultimeter.java b/src/resonantinduction/render/RenderMultimeter.java new file mode 100644 index 00000000..03361a22 --- /dev/null +++ b/src/resonantinduction/render/RenderMultimeter.java @@ -0,0 +1,122 @@ +package resonantinduction.render; + +import net.minecraft.client.gui.FontRenderer; +import net.minecraft.client.renderer.tileentity.TileEntitySpecialRenderer; +import net.minecraft.tileentity.TileEntity; +import net.minecraftforge.common.ForgeDirection; + +import org.lwjgl.opengl.GL11; + +import resonantinduction.multimeter.TileEntityMultimeter; +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; + +/** + * Class used to render text onto the multimeter block. + * + * @author Calclavia + * + */ +@SideOnly(Side.CLIENT) +public class RenderMultimeter extends TileEntitySpecialRenderer +{ + @Override + public void renderTileEntityAt(TileEntity t, double x, double y, double z, float var8) + { + TileEntityMultimeter tileEntity = (TileEntityMultimeter) t; + ForgeDirection direction = ForgeDirection.getOrientation(tileEntity.worldObj.getBlockMetadata(tileEntity.xCoord, tileEntity.yCoord, tileEntity.zCoord)); + + /** + * Render from side 2 to 6. This means render all sides excluding top and bottom. + */ + for (int side = 0; side < 6; side++) + { + if (direction.ordinal() != side) + { + GL11.glPushMatrix(); + GL11.glPolygonOffset(-10, -10); + GL11.glEnable(GL11.GL_POLYGON_OFFSET_FILL); + + float dx = 1F / 16; + float dz = 1F / 16; + float displayWidth = 1 - 2F / 16; + float displayHeight = 1 - 2F / 16; + GL11.glTranslatef((float) x, (float) y, (float) z); + + switch (side) + { + case 1: + break; + case 0: + GL11.glTranslatef(1, 1, 0); + GL11.glRotatef(180, 1, 0, 0); + GL11.glRotatef(180, 0, 1, 0); + + break; + case 3: + GL11.glTranslatef(0, 1, 0); + GL11.glRotatef(0, 0, 1, 0); + GL11.glRotatef(90, 1, 0, 0); + + break; + case 2: + GL11.glTranslatef(1, 1, 1); + GL11.glRotatef(180, 0, 1, 0); + GL11.glRotatef(90, 1, 0, 0); + + break; + case 5: + GL11.glTranslatef(0, 1, 1); + GL11.glRotatef(90, 0, 1, 0); + GL11.glRotatef(90, 1, 0, 0); + + break; + case 4: + GL11.glTranslatef(1, 1, 0); + GL11.glRotatef(-90, 0, 1, 0); + GL11.glRotatef(90, 1, 0, 0); + + break; + } + + GL11.glTranslatef(dx + displayWidth / 2, 1F, dz + displayHeight / 2); + GL11.glRotatef(-90, 1, 0, 0); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + + FontRenderer fontRenderer = this.getFontRenderer(); + + String joules = Math.round(tileEntity.getDetectedEnergy()) + " J"; + + int stringWidth = Math.max(fontRenderer.getStringWidth(joules), 0); + // maxWidth += 8; + int lineHeight = fontRenderer.FONT_HEIGHT + 2; + int requiredHeight = lineHeight * 1; + + /** + * Create an average scale. + */ + float scaleX = displayWidth / stringWidth; + float scaleY = displayHeight / requiredHeight; + float scale = (float) (Math.min(scaleX, scaleY) * 0.8); + GL11.glScalef(scale, -scale, scale); + GL11.glDepthMask(false); + + int realHeight = (int) Math.floor(displayHeight / scale); + int realWidth = (int) Math.floor(displayWidth / scale); + + int offsetY = (realHeight - requiredHeight) / 2; + int offsetX = (realWidth - stringWidth) / 2; + + GL11.glDisable(GL11.GL_LIGHTING); + fontRenderer.drawString(joules, offsetX - realWidth / 2, 1 + offsetY - realHeight / 2 + 0 * lineHeight, 1); + + GL11.glEnable(GL11.GL_LIGHTING); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + GL11.glDepthMask(true); + GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); + GL11.glDisable(GL11.GL_POLYGON_OFFSET_FILL); + GL11.glPopMatrix(); + } + } + } +} \ No newline at end of file diff --git a/src/resonantinduction/tesla/TileEntityTesla.java b/src/resonantinduction/tesla/TileEntityTesla.java index 6572586d..49df6c62 100644 --- a/src/resonantinduction/tesla/TileEntityTesla.java +++ b/src/resonantinduction/tesla/TileEntityTesla.java @@ -339,7 +339,7 @@ public class TileEntityTesla extends TileEntityBase implements ITesla, IPacketRe public int getRange() { - return Math.min(5 * (this.getHeight() - 1), 50); + return Math.min(4 * (this.getHeight() - 1), 50); } public void updatePositionStatus()