ForgeMultipart/codechicken/multipart/TileMultipart.scala

package codechicken.multipart

import net.minecraft.tileentity.TileEntity
import scala.collection.mutable.ListBuffer
import net.minecraft.network.packet.Packet
import codechicken.core.packet.PacketCustom
import codechicken.multipart.handler.MultipartCPH
import codechicken.core.vec.BlockCoord
import net.minecraft.world.World
import java.util.List
import scala.collection.JavaConverters._
import net.minecraft.nbt.NBTTagCompound
import java.io.ByteArrayOutputStream
import java.io.DataOutputStream
import java.io.DataInputStream
import codechicken.core.data.MCDataInputStream
import codechicken.core.data.MCDataOutput
import codechicken.core.data.MCDataOutputStream
import net.minecraft.client.multiplayer.NetClientHandler
import codechicken.core.vec.Cuboid6
import scala.collection.mutable.HashSet
import codechicken.multipart.handler.MultipartProxy
import net.minecraft.block.Block
import net.minecraft.item.ItemStack
import codechicken.core.vec.Vector3
import net.minecraft.nbt.NBTTagList
import net.minecraft.client.particle.EffectRenderer
import net.minecraft.util.MovingObjectPosition
import scala.collection.mutable.ArrayBuffer
import codechicken.scala.ScalaBridge._
import java.util.Random
import cpw.mods.fml.relauncher.SideOnly
import cpw.mods.fml.relauncher.Side
import scala.collection.mutable.Queue
import codechicken.multipart.handler.MultipartSPH
import codechicken.core.lighting.LazyLightMatrix
import net.minecraft.world.ChunkCoordIntPair
import net.minecraft.entity.item.EntityItem
import net.minecraft.entity.player.EntityPlayer
import net.minecraft.entity.Entity

trait TileMultipart extends TileEntity
{
    var partList = ArrayBuffer[TMultiPart]()
    
    private var doesTick = false
    
    private[multipart] def from(that:TileMultipart)
    {
        copyFrom(that)
        loadFrom(that)
    }
    
    def copyFrom(that:TileMultipart)//Potentially auto gen this
    {
        partList = that.partList
        doesTick = that.doesTick
    }
    
    def loadFrom(that:TileMultipart)
    {
        partList.foreach(_.bind(this))
    }
    
    /**
     * Overidden in TSlottedTile when a part that goes in a slot is added
     */
    def partMap(slot:Int):TMultiPart = null
    
    def jPartList():List[TMultiPart] = partList.asJava
    
    override def canUpdate() = doesTick//TODO: part merging true
    
    override def updateEntity()
    {
        super.updateEntity()
        
        TileMultipartObj.startOperation(this)
        partList.foreach(_.update())
        TileMultipartObj.finishOperation(this)
    }
    
    override def onChunkUnload()
    {
        partList.foreach(_.onChunkUnload())
    }
    
    def onChunkLoad()
    {
        partList.foreach(_.onChunkLoad())
    }
    
    override def validate()
    {
        val wasInvalid = isInvalid()
        super.validate()
        if(wasInvalid)
            partList.foreach(_.onWorldJoin())
    }
    
    override def invalidate()
    {
        super.invalidate()
        if(worldObj != null)
            partList.foreach(_.onWorldSeparate())
    }
    
    def notifyPartChange()
    {
        TileMultipartObj.startOperation(this)
        partList.foreach(_.onPartChanged())
        TileMultipartObj.finishOperation(this)
        
        worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, getBlockType().blockID)
        worldObj.updateAllLightTypes(xCoord, yCoord, zCoord)
    }
    
    def onNeighborBlockChange(world:World, x:Int, y:Int, z:Int, id:Int)
    {
        TileMultipartObj.startOperation(this)
        partList.foreach(_.onNeighborChanged())
        TileMultipartObj.finishOperation(this)
    }
    
    def getLightValue() = partList.foldLeft(0)((l, p) => Math.max(l, p.getLightValue))
    
    def markDirty()
    {
        worldObj.updateTileEntityChunkAndDoNothing(xCoord, yCoord, zCoord, this)
    }
    
    def isSolid(side:Int):Boolean = 
    {
        val part = partMap(side)
        if(part != null) 
            return part.asInstanceOf[TFacePart].solid(side)
        
        return false
    }
    
    private def setTicking(tick:Boolean)
    {
        if(doesTick == tick)
            return
        
        doesTick = tick
        if(worldObj != null)
        {
            if(tick)
                worldObj.addTileEntity(this)
            else
                worldObj.loadedTileEntityList.remove(this)
        }
    }
    
    def canAddPart(part:TMultiPart):Boolean =
    {
        if(partList.contains(part))
            return false
        
        return occlusionTest(partList, part)
    }
    
    def canReplacePart(opart:TMultiPart, npart:TMultiPart):Boolean = 
    {
        val olist = partList.filterNot(_ == opart)
        if(olist.contains(npart))
            return false
        
        return occlusionTest(olist, npart)
    }
    
    def occlusionTest(parts:Seq[TMultiPart], npart:TMultiPart):Boolean =
    {
        return parts.forall(part => part.occlusionTest(npart) && npart.occlusionTest(part))
    }
    
    def getWriteStream(part:TMultiPart):MCDataOutput = getWriteStream.writeByte(partList.indexOf(part))
    
    private[multipart] def getWriteStream = MultipartSPH.getTileStream(worldObj, new BlockCoord(this))
    
    private[multipart] def addPart(part:TMultiPart)
    {
        if(!worldObj.isRemote)
            writeAddPart(part)
            
        addPart_do(part)
        part.onAdded()
        notifyPartChange()
        markDirty()
        markRender()
    }
    
    private[multipart] def writeAddPart(part:TMultiPart)
    {
        val stream = getWriteStream.writeByte(253)
        MultiPartRegistry.writePartID(stream, part)
        part.writeDesc(stream)
    }
    
    private[multipart] def addPart_do(part:TMultiPart)
    {
        if(partList.size >= 250)
            throw new IllegalArgumentException("Tried to add more than 250 parts to the one tile. You're doing it wrong")
        
        partList+=part
        bindPart(part)
        part.bind(this)
        
        if(!doesTick && part.doesTick)
            setTicking(true)
        
        partAdded(part)
    }
    
    /**
     * Bind this part to an internal cache
     */
    def bindPart(part:TMultiPart){}
    
    def partAdded(part:TMultiPart){}
    
    def remPart(part:TMultiPart):TileMultipart =
    {
        if(TileMultipartObj.queueRemoval(this, part))
            return null
        
        val i = remPart_do(part)
        if(!isInvalid())
        {
            notifyPartChange()
            markDirty()
            markRender()
        }
        
        if(!worldObj.isRemote)
            getWriteStream.writeByte(254).writeByte(i)
        
        if(!isInvalid())
            return MultipartGenerator.partRemoved(this, part)
        
        return null
    }
    
    private def remPart_do(part:TMultiPart):Int =
    {
        val r = partList.indexOf(part)
        if(r < 0)
            throw new IllegalArgumentException("Tried to remove a non-existant part")
        
        partList-=part
        
        partRemoved(part, r)
        part.onRemoved()
        
        if(partList.isEmpty)
        {
            worldObj.setBlockToAir(xCoord, yCoord, zCoord)
        }
        else
        {
            if(part.doesTick && doesTick)
            {
                var ntick = false
                partList.foreach(part => ntick |= part.doesTick)
                if(!ntick)
                    setTicking(false)
            }
        }
        return r
    }
    
    def partRemoved(part:TMultiPart, p:Int){}

    private[multipart] def loadParts(parts:ListBuffer[TMultiPart])
    {
        clearParts()
        parts.foreach(p => addPart_do(p))
        if(worldObj != null)
            notifyPartChange()
    }
    
    def clearParts()
    {
        partList.clear()
    }
    
    def writeDesc(packet:PacketCustom)
    {
        packet.writeByte(partList.size)
        partList.foreach{part =>
            MultiPartRegistry.writePartID(packet, part)
            part.writeDesc(packet)
        }
    }
    
    def harvestPart(index:Int, drop:Boolean):Boolean = 
    {
        val part = partList(index)
        if(part == null)
            return false
        if(drop)
            dropItems(part.getDrops)
        remPart(part)
        return true
    }
    
    def dropItems(items:Seq[ItemStack])
    {
        val pos = Vector3.fromTileEntityCenter(this)
        items.foreach(item => TileMultipartObj.dropItem(item, worldObj, pos))
    }
    
    def markRender()
    {
        worldObj.markBlockForRenderUpdate(xCoord, yCoord, zCoord)
    }
    
    override def writeToNBT(tag:NBTTagCompound)
    {
        super.writeToNBT(tag)
        val taglist = new NBTTagList
        partList.foreach{part => 
            val parttag = new NBTTagCompound
            parttag.setString("id", part.getType)
            part.save(parttag)
            taglist.appendTag(parttag)
    }
        tag.setTag("parts", taglist)
    }
    
    def onEntityCollision(entity:Entity)
    {
        TileMultipartObj.startOperation(this)
        partList.foreach(_.onEntityCollision(entity))
        TileMultipartObj.finishOperation(this)
    }
    
    def strongPowerLevel(side:Int) = 0
    
    def weakPowerLevel(side:Int) = 0
    
    def canConnectRedstone(side:Int) = false
    
    def notifyNeighborChange(side:Int)
    {
        val pos = new BlockCoord(this).offset(side)
        worldObj.notifyBlocksOfNeighborChange(pos.x, pos.y, pos.z, getBlockType().blockID)
    }
}

trait TileMultipartClient extends TileMultipart
{
    def renderStatic(pos:Vector3, olm:LazyLightMatrix, pass:Int)
    {
        partList.foreach(part => part.renderStatic(pos, olm, pass))
    }
    
    def renderDynamic(pos:Vector3, frame:Float)
    {
        partList.foreach(part => part.renderDynamic(pos, frame))
    }
    
    def randomDisplayTick(random:Random){}
}

object TileMultipartObj
{
    var renderID:Int = -1
    
    class TileOperationSet
    {
        var tile:TileMultipart = _
        var depth = 0
        private val removalQueue = Queue[TMultiPart]()
        private val additionQueue = Queue[TMultiPart]()
        
        def start(t:TileMultipart)
        {
            tile = t
            depth = 1
        }
        
        def queueAddition(part:TMultiPart)
        {
            if(!additionQueue.contains(part))
                additionQueue+=part
        }
        
        def queueRemoval(part:TMultiPart)
        {
            if(!removalQueue.contains(part))
                removalQueue+=part
        }
        
        def finish()
        {
            if(removalQueue.isEmpty && additionQueue.isEmpty)
                return
            
            var otile = tile
            val world = tile.worldObj
            val pos = new BlockCoord(tile)
            while(!removalQueue.isEmpty)
                otile = otile.remPart(removalQueue.dequeue)
            
            while(!additionQueue.isEmpty)
                MultipartGenerator.addPart(world, pos, additionQueue.dequeue)
        }
    }
    
    class OperationSynchroniser
    {
        private val operations = ArrayBuffer[TileOperationSet]()
        private var depth = 0
        
        def startOperation(tile:TileMultipart)
        {
            var i = 0
            while(i < depth)
            {
                val op = operations(i)
                if(op.tile == tile)
                {
                    op.depth+=1
                    return
                }
                i+=1
            }
            if(depth == operations.length)
                operations+=new TileOperationSet
            operations(depth).start(tile)
            depth+=1
        }
        
        def finishOperation(tile:TileMultipart)
        {
            var i = depth-1
            while(i >= 0)
            {
                val op = operations(i)
                if(op.tile == tile)
                {
                    op.depth-=1
                    if(op.depth == 0)
                    {
                        if(i != depth-1)
                            throw new IllegalStateException("Tried to finish an operation that was not on top")
                        depth-=1
                        op.finish()
                    }
                    return
                }
                i-=1
            }
            throw new IllegalStateException("Inconsistant Operation stack")
        }
        
        def queueRemoval(tile:TileMultipart, part:TMultiPart):Boolean =
        {
            var i = depth-1
            while(i >= 0)
            {
                val op = operations(i)
                if(op.tile == tile)
                {
                    op.queueRemoval(part)
                    return true
                }
                i-=1
            }
            return false
        }
        
        def queueAddition(world:World, pos:BlockCoord, part:TMultiPart):Boolean = 
        {
            var i = depth-1
            while(i >= 0)
            {
                val op = operations(i)
                val opt = op.tile
                if(opt.worldObj == world && opt.xCoord == pos.x && opt.yCoord == pos.y && opt.zCoord == pos.z)
                {
                    op.queueRemoval(part)
                    return true
                }
                i-=1
            }
            return false
        }
    }
    
    private var operationSync_ = new ThreadLocal[OperationSynchroniser]
    private def operationSync():OperationSynchroniser = 
    {
        var r = operationSync_.get
        if(r == null)
        {
            r = new OperationSynchroniser
            operationSync_.set(r)
        }
        return r
    }
    
    def startOperation(tile:TileMultipart) = operationSync.startOperation(tile)
    
    def finishOperation(tile:TileMultipart) = operationSync.finishOperation(tile)
        
    def queueRemoval(tile:TileMultipart, part:TMultiPart):Boolean = operationSync.queueRemoval(tile, part)
    
    def queueAddition(world:World, pos:BlockCoord, part:TMultiPart):Boolean = operationSync.queueAddition(world, pos, part)
    
    def getOrConvertTile(world:World, pos:BlockCoord) = getOrConvertTile2(world, pos)._1
    
    def getOrConvertTile2(world:World, pos:BlockCoord):(TileMultipart, Boolean) =
    {
        val t = world.getBlockTileEntity(pos.x, pos.y, pos.z)
        if(t.isInstanceOf[TileMultipart])
            return (t.asInstanceOf[TileMultipart], false)
        
        val id = world.getBlockId(pos.x, pos.y, pos.z)
        val p = MultiPartRegistry.convertBlock(world, pos, id)
        if(p != null)
        {
            val t = MultipartGenerator.generateCompositeTile(null, Seq(p), world.isRemote)
            t.xCoord = pos.x
            t.yCoord = pos.y
            t.zCoord = pos.z
            t.setWorldObj(world)
            t.addPart_do(p)
            return (t, true)
        }
        return (null, false)
    }
    
    def getTile(world:World, pos:BlockCoord):TileMultipart =
    {
        val t = world.getBlockTileEntity(pos.x, pos.y, pos.z)
        if(t.isInstanceOf[TileMultipart])
            return t.asInstanceOf[TileMultipart]
        return null
    }
    
    def canAddPart(world:World, pos:BlockCoord, part:TMultiPart):Boolean =
    {
        part.getCollisionBoxes.foreach{b => 
            if(!world.checkNoEntityCollision(b.toAABB().offset(pos.x, pos.y, pos.z)))
                return false
        }
        
        val t = getOrConvertTile(world, pos)
        if(t != null)
            return t.canAddPart(part)
        
        if(!replaceable(world, pos))
            return false
        
        return true
    }
    
    def replaceable(world:World, pos:BlockCoord):Boolean = 
    {
        val block = Block.blocksList(world.getBlockId(pos.x, pos.y, pos.z))
        return block == null || block.isAirBlock(world, pos.x, pos.y, pos.z) || block.isBlockReplaceable(world, pos.x, pos.y, pos.z)
    }
    
    def addPart(world:World, pos:BlockCoord, part:TMultiPart):TileMultipart =
    {
        if(queueAddition(world, pos, part))
            return null
        
        return MultipartGenerator.addPart(world, pos, part)
    }
    
    def handleDescPacket(world:World, pos:BlockCoord, packet:PacketCustom)
    {
        val nparts = packet.readUnsignedByte
        val parts = new ListBuffer[TMultiPart]()
        for(i <- 0 until nparts)
        {
            val part:TMultiPart = MultiPartRegistry.readPart(packet)
            part.readDesc(packet)
            parts+=part
        }
        
        if(parts.size == 0)
            return
        
        val t = world.getBlockTileEntity(pos.x, pos.y, pos.z)
        val tilemp = MultipartGenerator.generateCompositeTile(t, parts, true)
        if(tilemp != t)
            world.setBlockTileEntity(pos.x, pos.y, pos.z, tilemp)
        
        tilemp.loadParts(parts)
        tilemp.markRender()
    }
    
    def handlePacket(pos:BlockCoord, world:World, i:Int, packet:PacketCustom)
    {
        var tilemp = BlockMultipart.getTile(world, pos.x, pos.y, pos.z)
        
        i match
        {
            case 253 => {
                val part = MultiPartRegistry.readPart(packet)
                part.readDesc(packet)
                addPart(world, pos, part)
            }
            case 254 => if(tilemp != null) {
                tilemp.remPart(tilemp.partList(packet.readUnsignedByte()))
            }
            case _ => if(tilemp != null) {
                tilemp.partList(i).read(packet)
            }
        }
    }
    
    def createFromNBT(tag:NBTTagCompound):TileMultipart =
    {
        val superID = tag.getString("superID")
        //val superClass = TileEntity.nameToClassMap.get(superID)
        
        val partList = tag.getTagList("parts")
        val parts = ListBuffer[TMultiPart]()
        
        for(i <- 0 until partList.tagCount)
        {
            val partTag = partList.tagAt(i).asInstanceOf[NBTTagCompound]
            val partID = partTag.getString("id")
            val part = MultiPartRegistry.createPart(partID, false)
            if(part != null)
            {
                part.load(partTag)
                parts+=part
            }
        }
        
        if(parts.size == 0)
            return null
        
        val tmb = MultipartGenerator.generateCompositeTile(null, parts, false)
        tmb.readFromNBT(tag)
        tmb.loadParts(parts)
        return tmb
    }
    
    def dropItem(stack:ItemStack, world:World, pos:Vector3)
    {
        val item = new EntityItem(world, pos.x, pos.y, pos.z, stack);
        item.motionX = world.rand.nextGaussian() * 0.05;
        item.motionY = world.rand.nextGaussian() * 0.05 + 0.2F;
        item.motionZ = world.rand.nextGaussian() * 0.05;
        world.spawnEntityInWorld(item);
    }
}