tilera/electrodynamics
1
0
Fork 0
Code Issues 1 Pull requests Projects Releases Wiki Activity

Fixed battery energy level and energy use

Browse source
This commit is contained in:
Calclavia 2015-01-20 22:24:06 +08:00
parent 9a9ec410ed
commit 60a7384241
4 changed files with 92 additions and 74 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
src/main/scala/edx/core/ClientProxy.scala
View file

@ -12,6 +12,7 @@ import edx.basic.process.sifting.TileSieve
import edx.basic.process.smelting.firebox.{RenderHotPlate, TileHotPlate}
import edx.basic.process.smelting.{RenderCastingMold, TileCastingMold}
import edx.electrical.ElectricalContent
import edx.electrical.battery.TileBattery
import edx.electrical.multimeter.{GuiMultimeter, PartMultimeter, RenderMultimeter}
import edx.electrical.tesla.{RenderTesla, TileTesla}
import edx.electrical.transformer.RenderTransformer
@ -67,6 +68,7 @@ import resonant.lib.transform.vector.Vector3
ItemRenderHandler.register(ElectricalContent.itemTransformer, RenderTransformer)
ItemRenderHandler.register(ElectricalContent.itemMultimeter, RenderMultimeter)
ItemRenderHandler.register(ElectricalContent.itemQuantumGlyph, RenderQuantumGlyph)
ItemRenderHandler.register(Item.getItemFromBlock(ElectricalContent.blockBattery), new TileBattery)
ClientRegistry.bindTileEntitySpecialRenderer(classOf[TileTesla], new RenderTesla)

4
src/main/scala/edx/electrical/battery/GridBattery.scala
View file

@ -32,7 +32,7 @@ class GridBattery extends Grid[TileBattery]
totalCapacity += connector.energy.getEnergyCapacity
lowestY = Math.min(connector.yCoord, lowestY)
highestY = Math.max(connector.yCoord, highestY)
connector.renderEnergyAmount = 0
//TODO: Update energy render
}
var remainingRenderEnergy: Double = totalEnergy
@ -54,7 +54,7 @@ class GridBattery extends Grid[TileBattery]
for (connector <- connectorsInlevel)
{
val tryInject: Double = Math.min(remainingRenderEnergy / levelSize, connector.energy.getEnergyCapacity)
connector.renderEnergyAmount_$eq(tryInject)
//TODO: Update energy render
used += tryInject
}
remainingRenderEnergy -= used

63
src/main/scala/edx/electrical/battery/ItemBlockBattery.scala
View file

@ -9,7 +9,6 @@ import net.minecraft.item.{Item, ItemBlock, ItemStack}
import net.minecraft.nbt.NBTTagCompound
import net.minecraft.world.World
import resonant.api.items.IEnergyItem
import resonant.lib.mod.compat.energy.Compatibility
import resonant.lib.render.EnumColor
import resonant.lib.utility.LanguageUtility
import resonant.lib.utility.science.UnitDisplay
@ -61,7 +60,7 @@ class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem
color = "\u00a76"
}
itemStack.getItemDamageForDisplay
list.add(LanguageUtility.getLocal("tooltip.battery.energy").replace("%0", color).replace("%1", EnumColor.GREY.toString).replace("%v0", new UnitDisplay(UnitDisplay.Unit.JOULES, joules).toString).replace("%v1", new UnitDisplay(UnitDisplay.Unit.JOULES, this.getEnergyCapacity(itemStack), true).toString))
list.add(LanguageUtility.getLocal("tooltip.battery.energy").replace("%0", color).replace("%1", EnumColor.GREY.toString).replace("%v0", new UnitDisplay(UnitDisplay.Unit.JOULES, joules).symbol.toString).replace("%v1", new UnitDisplay(UnitDisplay.Unit.JOULES, this.getEnergyCapacity(itemStack), true).symbol.toString))
}
/**
@ -84,14 +83,25 @@ class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem
return energyToReceive
}
def setEnergy(itemStack: ItemStack, joules: Double)
def discharge(itemStack: ItemStack, energy: Double, doTransfer: Boolean): Double =
{
val energyToExtract: Double = Math.min(Math.min(this.getEnergy(itemStack), energy), getTransferRate(itemStack))
if (doTransfer)
{
setEnergy(itemStack, this.getEnergy(itemStack) - energyToExtract)
}
return energyToExtract
}
def setEnergy(itemStack: ItemStack, joules: Double): ItemStack =
{
if (itemStack.getTagCompound == null)
{
itemStack.setTagCompound(new NBTTagCompound)
}
val electricityStored: Double = Math.max(Math.min(joules, this.getEnergyCapacity(itemStack)), 0)
itemStack.getTagCompound.setDouble("electricity", electricityStored)
val energy: Double = Math.max(Math.min(joules, this.getEnergyCapacity(itemStack)), 0)
itemStack.getTagCompound.setDouble("energy", energy)
return itemStack
}
def getTransferRate(itemStack: ItemStack): Double =
@ -99,29 +109,9 @@ class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem
return this.getEnergyCapacity(itemStack) / 100
}
def discharge(itemStack: ItemStack, energy: Double, doTransfer: Boolean): Double =
def getEnergyCapacity(theItem: ItemStack): Double =
{
val energyToExtract: Double = Math.min(Math.min(this.getEnergy(itemStack), energy), getTransferRate(itemStack))
if (doTransfer)
{
this.setEnergy(itemStack, this.getEnergy(itemStack) - energyToExtract)
}
return energyToExtract
}
def getVoltage(itemStack: ItemStack): Double =
{
return 240
}
def getTransfer(itemStack: ItemStack): Double =
{
return this.getEnergyCapacity(itemStack) - this.getEnergy(itemStack)
}
override def getDisplayDamage(stack: ItemStack): Int =
{
return (100 - (this.getEnergy(stack).asInstanceOf[Double] / getEnergyCapacity(stack).asInstanceOf[Double]) * 100).asInstanceOf[Int]
return TileBattery.getEnergyForTier(ItemBlockBattery.getTier(theItem))
}
/** Gets the energy stored in the item. Energy is stored using item NBT */
@ -131,23 +121,28 @@ class ItemBlockBattery(block: Block) extends ItemBlock(block) with IEnergyItem
{
itemStack.setTagCompound(new NBTTagCompound)
}
val energyStored: Long = itemStack.getTagCompound.getLong("electricity")
val energyStored = itemStack.getTagCompound.getDouble("energy")
return energyStored
}
def getEnergyCapacity(theItem: ItemStack): Double =
def getTransfer(itemStack: ItemStack): Double =
{
return TileBattery.getEnergyForTier(ItemBlockBattery.getTier(theItem))
return this.getEnergyCapacity(itemStack) - this.getEnergy(itemStack)
}
override def getDisplayDamage(stack: ItemStack): Int =
{
return (100 - (getEnergy(stack) / getEnergyCapacity(stack)) * 100).toInt
}
@SuppressWarnings(Array("unchecked"))
override def getSubItems(par1: Item, par2CreativeTabs: CreativeTabs, par3List: List[_])
override def getSubItems(par1: Item, par2CreativeTabs: CreativeTabs, list: List[_])
{
for (tier <- 0 to TileBattery.maxTier)
{
par3List.add(Compatibility.getItemWithCharge(ItemBlockBattery.setTier(new ItemStack(this), tier.asInstanceOf[Byte]), 0))
par3List.add(Compatibility.getItemWithCharge(ItemBlockBattery.setTier(new ItemStack(this), tier.asInstanceOf[Byte]), TileBattery.getEnergyForTier(tier)))
//TODO: Make traits for this
list.add(setEnergy(ItemBlockBattery.setTier(new ItemStack(this), tier), 0))
list.add(setEnergy(ItemBlockBattery.setTier(new ItemStack(this), tier), TileBattery.getEnergyForTier(tier)))
}
}
}

97
src/main/scala/edx/electrical/battery/TileBattery.scala
View file

@ -6,13 +6,16 @@ import cpw.mods.fml.relauncher.{Side, SideOnly}
import edx.core.Reference
import io.netty.buffer.ByteBuf
import net.minecraft.block.material.Material
import net.minecraft.client.Minecraft
import net.minecraft.entity.EntityLivingBase
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.item.ItemStack
import net.minecraft.nbt.NBTTagCompound
import net.minecraft.util.ResourceLocation
import net.minecraftforge.client.IItemRenderer.ItemRenderType
import net.minecraftforge.client.model.AdvancedModelLoader
import net.minecraftforge.common.util.ForgeDirection
import org.lwjgl.opengl.GL11._
import resonant.api.items.ISimpleItemRenderer
import resonant.lib.content.prefab.{TElectric, TEnergyStorage, TIO}
import resonant.lib.grid.core.TSpatialNodeProvider
import resonant.lib.grid.energy.EnergyStorage
@ -21,6 +24,7 @@ import resonant.lib.network.handle.{TPacketReceiver, TPacketSender}
import resonant.lib.prefab.tile.spatial.SpatialTile
import resonant.lib.render.RenderUtility
import resonant.lib.transform.vector.Vector3
import resonant.lib.utility.science.UnitDisplay
import resonant.lib.wrapper.ByteBufWrapper._
/** A modular battery box that allows shared connections with boxes next to it.
@ -42,12 +46,9 @@ object TileBattery
def getEnergyForTier(tier: Int) = Math.round(Math.pow(500000000, (tier / (maxTier + 0.7f)) + 1) / 500000000) * 500000000
}
class TileBattery extends SpatialTile(Material.iron) with TIO with TElectric with TSpatialNodeProvider with TPacketSender with TPacketReceiver with TEnergyStorage
class TileBattery extends SpatialTile(Material.iron) with TIO with TElectric with TSpatialNodeProvider with TPacketSender with TPacketReceiver with TEnergyStorage with ISimpleItemRenderer
{
var renderEnergyAmount = 0d
var doCharge = false
private var markClientUpdate = false
private var markDistributionUpdate = false
var energyRenderLevel = 0
nodes.add(dcNode)
energy = new EnergyStorage
@ -65,38 +66,52 @@ class TileBattery extends SpatialTile(Material.iron) with TIO with TElectric wit
updateConnectionMask()
}
def updateConnectionMask()
{
dcNode.connectionMask = ForgeDirection.VALID_DIRECTIONS.filter(getIO(_) > 0).map(d => 1 << d.ordinal()).foldLeft(0)(_ | _)
dcNode.positiveTerminals.addAll(getInputDirections())
dcNode.negativeTerminals.addAll(getOutputDirections())
notifyChange()
}
override def update()
{
super.update()
if (!world.isRemote)
{
//TODO: Voltage of battery should decrease over time.
//TODO: Test, remove this
if (doCharge)
dcNode.generateVoltage(500)
if (isIndirectlyPowered)
{
if (energy.getEnergy > 0)
{
//TODO: Voltage of battery should decrease over time.
dcNode.generateVoltage(500)
val dissipatedEnergy = dcNode.power / 20
energy -= dissipatedEnergy
markUpdate()
}
}
/**
* Update packet when energy level changes.
*/
val prevEnergyLevel = energyRenderLevel
energyRenderLevel = Math.round((energy.getEnergy / TileBattery.getEnergyForTier(getBlockMetadata).toDouble) * 8).toInt
if (prevEnergyLevel != energyRenderLevel)
{
markUpdate()
}
}
}
override def write(buf: ByteBuf, id: Int)
{
super.write(buf, id)
buf <<< renderEnergyAmount
buf <<< energy.getEnergy
buf <<< energyRenderLevel.toByte
buf <<< ioMap
}
override def read(buf: ByteBuf, id: Int, packetType: PacketType)
{
super.read(buf, id, packetType)
energy.setCapacity(TileBattery.getEnergyForTier(metadata)).setMaxTransfer(energy.getEnergyCapacity)
energy.setEnergy(buf.readDouble())
energyRenderLevel = buf.readByte()
ioMap = buf.readInt()
}
@ -108,11 +123,19 @@ class TileBattery extends SpatialTile(Material.iron) with TIO with TElectric wit
markUpdate()
}
def updateConnectionMask()
{
dcNode.connectionMask = ForgeDirection.VALID_DIRECTIONS.filter(getIO(_) > 0).map(d => 1 << d.ordinal()).foldLeft(0)(_ | _)
dcNode.positiveTerminals.addAll(getInputDirections())
dcNode.negativeTerminals.addAll(getOutputDirections())
notifyChange()
}
override def onPlaced(entityLiving: EntityLivingBase, itemStack: ItemStack)
{
if (!world.isRemote && itemStack.getItem.isInstanceOf[ItemBlockBattery])
{
energy.setCapacity(TileBattery.getEnergyForTier(ItemBlockBattery.getTier(itemStack)))
energy.setCapacity(TileBattery.getEnergyForTier(ItemBlockBattery.getTier(itemStack))).setMaxTransfer(energy.getEnergyCapacity)
energy.setEnergy(itemStack.getItem.asInstanceOf[ItemBlockBattery].getEnergy(itemStack))
world.setBlockMetadataWithNotify(xi, yi, zi, ItemBlockBattery.getTier(itemStack), 3)
}
@ -130,7 +153,7 @@ class TileBattery extends SpatialTile(Material.iron) with TIO with TElectric wit
}
@SideOnly(Side.CLIENT)
override def renderInventory(itemStack: ItemStack)
override def renderInventoryItem(`type`: ItemRenderType, itemStack: ItemStack, data: AnyRef*)
{
glPushMatrix()
val energyLevel = ((itemStack.getItem.asInstanceOf[ItemBlockBattery].getEnergy(itemStack) / itemStack.getItem.asInstanceOf[ItemBlockBattery].getEnergyCapacity(itemStack)) * 8).toInt
@ -162,8 +185,6 @@ class TileBattery extends SpatialTile(Material.iron) with TIO with TElectric wit
val connectionPartToEnable = Array[Array[String]](null, null, Array[String]("frame1con", "frame2con"), Array[String]("frame3con", "frame4con"), Array[String]("frame4con", "frame1con"), Array[String]("frame2con", "frame3con"))
glPushMatrix()
glTranslated(pos.x + 0.5, pos.y + 0.5, pos.z + 0.5)
val energyLevel = Math.round((energy.getEnergy / TileBattery.getEnergyForTier(getBlockMetadata).asInstanceOf[Double]) * 8).toInt
RenderUtility.bind(Reference.domain, Reference.modelPath + "battery/battery.png")
var disabledParts = Set.empty[String]
@ -214,7 +235,7 @@ class TileBattery extends SpatialTile(Material.iron) with TIO with TElectric wit
{
if (i != 1 || enabledParts.contains("coil1"))
{
if ((8 - i) < energyLevel)
if ((8 - i) < energyRenderLevel)
TileBattery.model.renderOnly("coil" + i + "lit")
else
TileBattery.model.renderOnly("coil" + i)
@ -228,24 +249,24 @@ class TileBattery extends SpatialTile(Material.iron) with TIO with TElectric wit
enabledParts --= Set("coil1", "coil2", "coil3", "coil4", "coil5", "coil6", "coil7", "coil8")
TileBattery.model.renderAllExcept(disabledParts.toList: _*)
TileBattery.model.renderOnly(enabledParts.toList: _*)
/**
* Render energy tooltip
*/
if (isPlayerLooking(Minecraft.getMinecraft.thePlayer))
RenderUtility.renderFloatingText(new UnitDisplay(UnitDisplay.Unit.JOULES, energy.getEnergy).symbol + " / " + new UnitDisplay(UnitDisplay.Unit.JOULES, energy.getEnergyCapacity).symbol, new Vector3(0, 0.9, 0))
glPopMatrix()
}
override def toString: String = "[TileBattery]" + x + "x " + y + "y " + z + "z "
override protected def use(player: EntityPlayer, side: Int, hit: Vector3): Boolean =
override def readFromNBT(nbt: NBTTagCompound)
{
super.use(player, side, hit)
super.readFromNBT(nbt)
energy.readFromNBT(nbt)
}
if (!world.isRemote)
{
if (player.isSneaking)
{
doCharge = !doCharge
println("Charge: " + doCharge)
}
}
return true
override def writeToNBT(nbt: NBTTagCompound)
{
super.writeToNBT(nbt)
energy.writeToNBT(nbt)
}
}