TilePowerBank.scala

package me.jonak.upower.block.tileentities

import me.jonak.upower.traits.{TraitTilePowerAcceptor, TraitTilePowerOutputter}
import net.minecraft.block.state.IBlockState
import net.minecraft.nbt.NBTTagCompound
import net.minecraft.network.NetworkManager
import net.minecraft.network.play.server.SPacketUpdateTileEntity
import net.minecraft.tileentity.TileEntity
import net.minecraft.util.ITickable
import net.minecraft.util.math.BlockPos
import net.minecraft.world.World

/**
  * Created by jonak on 5/11/2016.
  */

object TilePowerBank
{
    def getPercentTen(maxPower: Long, currentPower: Long): Integer = Integer.valueOf(Math.floor(currentPower.asInstanceOf[Double] / maxPower.asInstanceOf[Double] * 10).asInstanceOf[Int])
}

class TilePowerBank(initialPower: Long = 0, maxPowerInit: Long = 0, maxOutputInit: Long = 0)
    extends TileEntity with TraitTilePowerAcceptor with TraitTilePowerOutputter with ITickable
{
    import TilePowerBank._

    def this() {
        this(0,0,0)
    }

    override protected var powerContained = initialPower
    override protected var currentOutput = maxOutputInit
    override protected var maxOutput = maxOutputInit
    override protected var maxPower = maxPowerInit
    //TODO: I/O sides

    /**
      * Simple tick counter for [[me.jonak.upower.block.tileentities.TilePowerBank.update()]]
      */
    private var tick: Int = 0

    override def usePower(powerRequested: Long): Long =
    {
        // Uses a certain amount of power and returns the power given out.
        var powerGiven = powerRequested // Defines the amount of power that actually leaves the bank
        if (powerRequested > maxOutput)
            powerGiven = maxOutput
        if (powerContained - powerRequested < 0)
            powerGiven = powerContained

        powerContained -= powerGiven

        return powerGiven // TODO: Check if power requested is more than maxOutput or powerContained and do something with that.
    }


    override def addPower(powerReceived: Long): Long =
    {
        // Adds a certain amount of power and returns the power taken.
        var powerTaken = powerReceived // Defines the amount of power that the bank actually takes.

        val currentPower = powerContained

        if (powerContained + powerReceived > getMaxPower)
        {
            powerTaken = getMaxPower - powerContained // powerReceived - ((getPowerContained + powerReceived) - getMaxPower)
        }

        powerContained += powerTaken

        markDirty()

        val currentState = worldObj.getBlockState(getPos)

        val currentPercentTen = getPercentTen(maxPower, currentPower)
        val newPercentTen = getPercentTen(maxPower, powerContained)
        if(currentPercentTen.compareTo(newPercentTen) != 0)
        {
            worldObj.notifyBlockUpdate(
                getPos,
                currentState,
                currentState
                    .getBlock
                    .getActualState(
                        currentState,
                        worldObj,
                        getPos
                    ),
                16
            )
            worldObj.setBlockState(
                getPos,
                currentState
                    .getBlock
                    .getActualState(
                        currentState,
                        worldObj,
                        getPos
                    ),
                16
            )
        }

        println("NEW POWER = " + powerContained)

        return powerTaken // TODO: Check if power added exceeds maxPower and deal with that.
    }

    //TODO: Functions invoked by GUI elements for raising/lowering output, etc
    //TODO: Functions for I/O sides

    override def readFromNBT(tag: NBTTagCompound): Unit =
    {
        // Reads data from NBT to the variables.
        super.readFromNBT(tag)
        maxPower = tag.getLong("maxPower")
        maxOutput = tag.getLong("maxOutput")
        powerContained = tag.getLong("currentPower")
        currentOutput = tag.getLong("currentOutput")
    }

    override def writeToNBT(tag: NBTTagCompound): Unit =
    {
        // Reads data from the variables to NBT
        tag.setLong("maxPower", maxPower)
        tag.setLong("maxOutput", maxOutput)
        tag.setDouble("currentPower", powerContained)
        tag.setLong("currentOutput", currentOutput)
        super.writeToNBT(tag)
    }

    override def shouldRefresh(world: World, pos: BlockPos, oldState: IBlockState, newState: IBlockState): Boolean =
    {
        // Checks if the tile should be recreated
        oldState.getBlock != newState.getBlock
    }

    override def getDescriptionPacket: SPacketUpdateTileEntity =
    {
        // Sends an update packet to the client
        val tag: NBTTagCompound = new NBTTagCompound
        writeToNBT(tag)
        println("SERVER -- Data sent")
        new SPacketUpdateTileEntity(pos, 1, tag)
    }

    override def onDataPacket(net: NetworkManager, packet: SPacketUpdateTileEntity): Unit =
    {
        println("CLIENT -- Data recieved")
        readFromNBT(packet.getNbtCompound)
    }

    override def update(): Unit =
    {
        if(!worldObj.isRemote)
        {
            tick += 1
            if (tick > 2)
            {
                addPower(1L) //TODO: Remove this (testing only)
                tick = 0
            }
        }
    }
}