388 lines
12 KiB
Scala
388 lines
12 KiB
Scala
package edx.basic.fluid.grate
|
|
|
|
import java.util.{Collections, Comparator, HashMap, PriorityQueue}
|
|
|
|
import cpw.mods.fml.relauncher.{Side, SideOnly}
|
|
import edx.basic.fluid.grate.TileGrate._
|
|
import edx.core.Reference
|
|
import edx.core.prefab.node.{NodeFluidPressure, TileFluidProvider}
|
|
import net.minecraft.block.material.Material
|
|
import net.minecraft.client.renderer.texture.IIconRegister
|
|
import net.minecraft.entity.player.EntityPlayer
|
|
import net.minecraft.nbt.NBTTagCompound
|
|
import net.minecraft.util.{ChatComponentText, IIcon}
|
|
import net.minecraft.world.IBlockAccess
|
|
import net.minecraftforge.common.util.ForgeDirection
|
|
import net.minecraftforge.fluids.{Fluid, FluidContainerRegistry, FluidRegistry, FluidStack}
|
|
import resonantengine.lib.mod.config.Config
|
|
import resonantengine.lib.transform.vector.Vector3
|
|
import resonantengine.lib.utility.FluidUtility
|
|
import resonantengine.prefab.block.impl.TRotatable
|
|
|
|
object TileGrate
|
|
{
|
|
@Config(comment = "The multiplier for the influence of the grate. Dependent on pressure.")
|
|
private var grateEffectMultiplier: Double = 5
|
|
|
|
@Config(comment = "The speed in which the grate drains blocks. Dependent on grate block influence.")
|
|
private var grateDrainSpeedMultiplier: Double = 0.01
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
private var iconFront: IIcon = _
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
private var iconSide: IIcon = _
|
|
}
|
|
|
|
class TileGrate extends TileFluidProvider(Material.rock) with TRotatable
|
|
{
|
|
fluidNode = new NodeFluidPressure(this)
|
|
private var gratePath: GratePathfinder = _
|
|
private var fillOver: Boolean = true
|
|
isOpaqueCube = false
|
|
normalRender = true
|
|
|
|
override def getIcon(world: IBlockAccess, side: Int): IIcon =
|
|
{
|
|
if (side == getDirection.ordinal()) iconFront else iconSide
|
|
}
|
|
|
|
override def getIcon(side: Int, metadata: Int): IIcon = if (side == 1) iconFront else iconSide
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
override def registerIcons(iconRegister: IIconRegister)
|
|
{
|
|
iconFront = iconRegister.registerIcon(Reference.prefix + "grate_front")
|
|
iconSide = iconRegister.registerIcon(Reference.prefix + "grate")
|
|
}
|
|
|
|
override def readFromNBT(nbt: NBTTagCompound)
|
|
{
|
|
super.readFromNBT(nbt)
|
|
fillOver = nbt.getBoolean("fillOver")
|
|
}
|
|
|
|
override def writeToNBT(nbt: NBTTagCompound)
|
|
{
|
|
super.writeToNBT(nbt)
|
|
nbt.setBoolean("fillOver", fillOver)
|
|
}
|
|
|
|
override def canFill(from: ForgeDirection, fluid: Fluid): Boolean = getDirection != from
|
|
|
|
override def canDrain(from: ForgeDirection, fluid: Fluid): Boolean = getDirection != from
|
|
|
|
override def update()
|
|
{
|
|
super.update()
|
|
|
|
if (!world.isRemote)
|
|
{
|
|
if (ticks % 10 == 0)
|
|
{
|
|
val pressure = fluidNode.asInstanceOf[NodeFluidPressure].pressure(getDirection)
|
|
val blockEffect = Math.abs(pressure * grateEffectMultiplier).toInt
|
|
fluidNode.getTank.setCapacity(Math.max(blockEffect * FluidContainerRegistry.BUCKET_VOLUME * grateDrainSpeedMultiplier, FluidContainerRegistry.BUCKET_VOLUME).toInt)
|
|
|
|
if (pressure > 0)
|
|
{
|
|
//Output fluid
|
|
if (fluidNode.getFluidAmount >= FluidContainerRegistry.BUCKET_VOLUME)
|
|
{
|
|
if (gratePath == null)
|
|
{
|
|
gratePath = new GratePathfinder(true)
|
|
gratePath.startFill(toVectorWorld, fluidNode.getFluid.getFluid.getID)
|
|
}
|
|
val filledInWorld = gratePath.tryFill(fluidNode.getFluidAmount, blockEffect)
|
|
fluidNode.drain(filledInWorld, true)
|
|
}
|
|
}
|
|
else if (pressure < 0)
|
|
{
|
|
//Input fluid
|
|
val maxDrain = fluidNode.getCapacity - fluidNode.getFluidAmount
|
|
if (maxDrain > 0)
|
|
{
|
|
if (gratePath == null)
|
|
{
|
|
gratePath = new GratePathfinder(false)
|
|
if (!gratePath.startDrain(toVectorWorld))
|
|
{
|
|
resetPath()
|
|
}
|
|
}
|
|
if (gratePath != null && gratePath.tryPopulateDrainMap(blockEffect))
|
|
{
|
|
fluidNode.fill(gratePath.tryDrain(maxDrain, true), true)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def resetPath()
|
|
{
|
|
this.gratePath = null
|
|
}
|
|
|
|
override def fill(from: ForgeDirection, resource: FluidStack, doFill: Boolean): Int = fluidNode.fill(resource, doFill)
|
|
|
|
override def drain(from: ForgeDirection, resource: FluidStack, doDrain: Boolean): FluidStack =
|
|
{
|
|
if (resource != null)
|
|
{
|
|
return drain(from, resource.amount, doDrain)
|
|
}
|
|
null
|
|
}
|
|
|
|
override def drain(from: ForgeDirection, maxDrain: Int, doDrain: Boolean): FluidStack =
|
|
{
|
|
fluidNode.drain(maxDrain, doDrain)
|
|
}
|
|
|
|
protected override def configure(player: EntityPlayer, side: Int, hit: Vector3): Boolean =
|
|
{
|
|
if (!player.isSneaking)
|
|
{
|
|
if (!world.isRemote)
|
|
{
|
|
fillOver = !fillOver
|
|
player.addChatMessage(new ChatComponentText("Grate now set to " + (if (fillOver) "" else "not ") + "fill higher than itself."))
|
|
gratePath = null
|
|
}
|
|
return true
|
|
}
|
|
super.configure(player, side, hit)
|
|
}
|
|
|
|
class GratePathfinder(checkVertical: Boolean)
|
|
{
|
|
var fluidType: Fluid = _
|
|
var start: Vector3 = _
|
|
var navigationMap: HashMap[Vector3, Vector3] = new HashMap[Vector3, Vector3]()
|
|
|
|
var workingNodes: PriorityQueue[ComparableVector] =
|
|
if (checkVertical) new PriorityQueue[ComparableVector]()
|
|
else new PriorityQueue[ComparableVector](1024, new Comparator[ComparableVector]()
|
|
{
|
|
override def compare(a: ComparableVector, b: ComparableVector): Int =
|
|
{
|
|
val wa = a.asInstanceOf[ComparableVector]
|
|
val wb = b.asInstanceOf[ComparableVector]
|
|
wa.iterations - wb.iterations
|
|
}
|
|
})
|
|
|
|
var drainNodes = new PriorityQueue[ComparableVector](1024, Collections.reverseOrder())
|
|
|
|
def startFill(start: Vector3, fluidID: Int)
|
|
{
|
|
this.fluidType = FluidRegistry.getFluid(fluidID)
|
|
this.start = start
|
|
|
|
val check = start + TileGrate.this.getDirection
|
|
navigationMap.put(check, start)
|
|
workingNodes.add(new ComparableVector(check, 0))
|
|
}
|
|
|
|
def tryFill(amount: Int, tries: Int): Int =
|
|
{
|
|
var filled = 0
|
|
if (amount >= FluidContainerRegistry.BUCKET_VOLUME)
|
|
{
|
|
for (i <- 0 until tries)
|
|
{
|
|
val next = workingNodes.poll()
|
|
if (next == null)
|
|
{
|
|
TileGrate.this.resetPath()
|
|
return 0
|
|
}
|
|
if (!isConnected(next.position))
|
|
{
|
|
TileGrate.this.resetPath()
|
|
return 0
|
|
}
|
|
|
|
val didFill = FluidUtility.fillBlock(TileGrate.this.worldObj, next.position, new FluidStack(fluidType, amount), true)
|
|
filled += didFill
|
|
if (FluidUtility.getFluidAmountFromBlock(TileGrate.this.worldObj, next.position) > 0 || didFill > 0)
|
|
{
|
|
addNextFill(next)
|
|
}
|
|
if (filled >= amount)
|
|
{
|
|
return filled
|
|
}
|
|
}
|
|
}
|
|
filled
|
|
}
|
|
|
|
def addNextFill(next: ComparableVector)
|
|
{
|
|
for (i <- 0 until 6)
|
|
{
|
|
val newPosition = next.position.clone().add(ForgeDirection.getOrientation(i))
|
|
if (!this.navigationMap.containsKey(newPosition) && !(!fillOver && newPosition.yi > y))
|
|
{
|
|
this.navigationMap.put(newPosition, next.position)
|
|
this.workingNodes.add(new ComparableVector(newPosition, next.iterations + 1))
|
|
}
|
|
}
|
|
}
|
|
|
|
def startDrain(start: Vector3): Boolean =
|
|
{
|
|
fluidType = null
|
|
this.start = start
|
|
val check = start + TileGrate.this.getDirection
|
|
navigationMap.put(check, start)
|
|
workingNodes.add(new ComparableVector(check, 0))
|
|
fluidType = FluidUtility.getFluidFromBlock(TileGrate.this.worldObj, check)
|
|
|
|
fluidType != null
|
|
}
|
|
|
|
def tryPopulateDrainMap(tries: Int): Boolean =
|
|
{
|
|
for (i <- 0 until tries)
|
|
{
|
|
val check = workingNodes.poll()
|
|
if (check == null)
|
|
{
|
|
return true
|
|
}
|
|
val checkFluid = FluidUtility.getFluidFromBlock(TileGrate.this.worldObj, check.position)
|
|
if (checkFluid != null && fluidType.getID == checkFluid.getID)
|
|
{
|
|
addNextDrain(check)
|
|
val checkAmount = FluidUtility.getFluidAmountFromBlock(TileGrate.this.worldObj, check.position)
|
|
if (checkAmount > 0)
|
|
{
|
|
drainNodes.add(check)
|
|
}
|
|
}
|
|
}
|
|
return drainNodes.size > 0
|
|
}
|
|
|
|
def addNextDrain(next: ComparableVector)
|
|
{
|
|
for (i <- 0 until 6)
|
|
{
|
|
val check = next.position.clone().add(ForgeDirection.getOrientation(i))
|
|
val checkFluid = FluidUtility.getFluidFromBlock(TileGrate.this.worldObj, check)
|
|
if (checkFluid != null && fluidType.getID == checkFluid.getID)
|
|
{
|
|
if (!navigationMap.containsKey(check))
|
|
{
|
|
navigationMap.put(check, next.position)
|
|
workingNodes.add(new ComparableVector(check, next.iterations + 1))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
def tryDrain(targetAmount: Int, doDrain: Boolean): FluidStack =
|
|
{
|
|
var drainedAmount = 0
|
|
var break = false
|
|
|
|
//Check all the potential drain coordinates
|
|
while (!drainNodes.isEmpty && !break)
|
|
{
|
|
val fluidCoord = drainNodes.peek()
|
|
|
|
if (!isConnected(fluidCoord.position))
|
|
{
|
|
//The coordinate is not connected with the starting coordinate, therefore, we will not drain this.
|
|
TileGrate.this.resetPath()
|
|
return new FluidStack(fluidType, drainedAmount)
|
|
}
|
|
|
|
if (FluidUtility.getFluidFromBlock(TileGrate.this.worldObj, fluidCoord.position) == null || this.fluidType.getID != FluidUtility.getFluidFromBlock(TileGrate.this.worldObj, fluidCoord.position).getID)
|
|
{
|
|
drainNodes.poll()
|
|
}
|
|
else
|
|
{
|
|
val checkAmount = FluidUtility.getFluidAmountFromBlock(TileGrate.this.worldObj, fluidCoord.position)
|
|
|
|
if (drainedAmount + checkAmount <= targetAmount)
|
|
{
|
|
if (checkAmount == 0)
|
|
{
|
|
drainNodes.poll()
|
|
}
|
|
else
|
|
{
|
|
val fluidStack = FluidUtility.drainBlock(TileGrate.this.worldObj, fluidCoord.position, doDrain, 2)
|
|
//TODO: Do a delayed block update!
|
|
drainNodes.poll()
|
|
if (fluidStack != null)
|
|
{
|
|
drainedAmount += fluidStack.amount
|
|
if (drainedAmount >= targetAmount)
|
|
{
|
|
break = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
break = true
|
|
}
|
|
}
|
|
}
|
|
TileGrate.this.resetPath()
|
|
if (drainedAmount > 0)
|
|
{
|
|
return new FluidStack(fluidType, drainedAmount)
|
|
}
|
|
null
|
|
}
|
|
|
|
def isConnected(nCheck: Vector3): Boolean =
|
|
{
|
|
var check = nCheck
|
|
|
|
if (check.equals(start))
|
|
return true
|
|
|
|
//Trace back in the navigation map to see if it reaches the starting point
|
|
do
|
|
{
|
|
check = navigationMap.get(check)
|
|
|
|
if (check.equals(null))
|
|
return false
|
|
|
|
if (check.equals(start))
|
|
return true
|
|
}
|
|
while (FluidUtility.getFluidFromBlock(TileGrate.this.worldObj, check) != null && fluidType.getID == FluidUtility.getFluidFromBlock(TileGrate.this.worldObj, check).getID)
|
|
|
|
return false
|
|
}
|
|
}
|
|
|
|
class ComparableVector(var position: Vector3, var iterations: Int) extends Comparable[ComparableVector]
|
|
{
|
|
override def compareTo(obj: ComparableVector): Int =
|
|
{
|
|
val wr = obj.asInstanceOf[ComparableVector]
|
|
if (this.position.y == wr.position.y)
|
|
{
|
|
return this.iterations - wr.iterations
|
|
}
|
|
this.position.yi - wr.position.yi
|
|
}
|
|
}
|
|
|
|
}
|