package codechicken.multipart import net.minecraft.tileentity.TileEntity import scala.collection.mutable.ListBuffer import net.minecraft.network.packet.Packet import codechicken.lib.packet.PacketCustom import codechicken.multipart.handler.MultipartCPH import codechicken.lib.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.lib.data.MCDataInputStream import codechicken.lib.data.MCDataOutput import codechicken.lib.data.MCDataOutputStream import net.minecraft.client.multiplayer.NetClientHandler import codechicken.lib.vec.Cuboid6 import scala.collection.mutable.HashSet import codechicken.multipart.handler.MultipartProxy import net.minecraft.block.Block import net.minecraft.item.ItemStack import codechicken.lib.vec.Vector3 import net.minecraft.nbt.NBTTagList import net.minecraft.client.particle.EffectRenderer import net.minecraft.util.MovingObjectPosition import scala.collection.mutable.ArrayBuffer 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.lib.lighting.LazyLightMatrix import net.minecraft.world.ChunkCoordIntPair import net.minecraft.entity.item.EntityItem import net.minecraft.entity.player.EntityPlayer import net.minecraft.entity.Entity import scala.collection.JavaConversions._ import java.util.Collection import codechicken.lib.raytracer.ExtendedMOP import net.minecraft.util.Vec3 import java.lang.Iterable class TileMultipart extends TileEntity { var partList = ArrayBuffer[TMultiPart]() private var doesTick = false private[multipart] def from(that:TileMultipart) { copyFrom(that) loadFrom(that) } /** * This method should be used for copying all the data from the fields in that container tile. * This method will be automatically generated on java tile traits with fields if it is not overridden. */ def copyFrom(that:TileMultipart) { partList = that.partList doesTick = that.doesTick } def loadFrom(that:TileMultipart) { partList.foreach(_.bind(this)) if(doesTick) { doesTick = false setTicking(true) } } /** * Overidden in TSlottedTile when a part that goes in a slot is added */ def partMap(slot:Int):TMultiPart = null def jPartList():List[TMultiPart] = partList override def canUpdate() = doesTick override def updateEntity() { super.updateEntity() TileMultipart.startOperation(this) partList.foreach(_.update()) TileMultipart.finishOperation(this) } override def onChunkUnload() { partList.foreach(_.onChunkUnload()) } def onChunkLoad() { TileMultipart.startOperation(this) partList.foreach(_.onChunkLoad()) TileMultipart.finishOperation(this) } override def validate() { val wasInvalid = isInvalid super.validate() if(wasInvalid) { TileMultipart.startOperation(this) partList.foreach(_.onMoved()) TileMultipart.finishOperation(this) } } private[multipart] def prepareSwap() { super.invalidate() } override def invalidate() { if(!isInvalid) { super.invalidate() if(worldObj != null) partList.foreach(_.onWorldSeparate()) } } /** * Called by parts when they have changed in some form that affects the world. * Notifies neighbor blocks, parts that share this host and recalculates lighting */ def notifyPartChange(part:TMultiPart) { internalPartChange(part) worldObj.notifyBlocksOfNeighborChange(xCoord, yCoord, zCoord, MultipartProxy.block.blockID) worldObj.updateAllLightTypes(xCoord, yCoord, zCoord) } /** * Notifies parts sharing this host of a change */ def internalPartChange(part:TMultiPart) { TileMultipart.startOperation(this) partList.foreach{ p => if(part != p) p.onPartChanged(part) } TileMultipart.finishOperation(this) } /** * Notifies all parts not in the passed collection of a change from all the parts in the collection */ def multiPartChange(parts:Collection[TMultiPart]) { TileMultipart.startOperation(this) partList.foreach{ p => if(!parts.contains(p)) parts.foreach(p.onPartChanged(_)) } TileMultipart.finishOperation(this) } def onNeighborBlockChange() { TileMultipart.startOperation(this) partList.foreach(_.onNeighborChanged()) TileMultipart.finishOperation(this) } /** * Blank implementation, overriden by TTileChangeTile */ def onNeighborTileChange(tileX:Int, tileY:Int, tileZ:Int) {} def getLightValue() = partList.foldLeft(0)((l, p) => Math.max(l, p.getLightValue)) def markDirty() { worldObj.markTileEntityChunkModified(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 def getWriteStream = MultipartSPH.getTileStream(worldObj, new BlockCoord(this)) private[multipart] def addPart_impl(part:TMultiPart) { if(!worldObj.isRemote) writeAddPart(part) addPart_do(part) part.onAdded() partAdded(part) notifyPartChange(part) 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) { assert(partList.size < 250, "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) } /** * Bind this part to an internal cache */ def bindPart(part:TMultiPart){} def partAdded(part:TMultiPart){} def remPart(part:TMultiPart):TileMultipart = { assert(!worldObj.isRemote, "Cannot remove multi parts from a client tile") if(TileMultipart.queueRemoval(this, part)) return null remPart_impl(part) } private[multipart] def remPart_impl(part:TMultiPart):TileMultipart = { remPart_do(part, !worldObj.isRemote) if(!isInvalid) { notifyPartChange(part) markDirty() markRender() return MultipartGenerator.partRemoved(this, part) } return null } private def remPart_do(part:TMultiPart, sendPacket:Boolean):Int = { val r = partList.indexOf(part) if(r < 0) throw new IllegalArgumentException("Tried to remove a non-existant part") partList-=part if(sendPacket) getWriteStream.writeByte(254).writeByte(r) partRemoved(part, r) part.onRemoved() part.tile = null 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(null) } def clearParts() { partList.clear() } def writeDesc(packet:MCDataOutput) { packet.writeByte(partList.size) partList.foreach{part => MultiPartRegistry.writePartID(packet, part) part.writeDesc(packet) } } def rayTraceAll(start:Vec3, end:Vec3):Iterable[ExtendedMOP] = { var list = ListBuffer[ExtendedMOP]() for((p, i) <- partList.view.zipWithIndex) p.collisionRayTrace(start, end) match { case mop:ExtendedMOP => { mop.data = (i, mop.data) list+=mop } case _ => } return list.sorted } def collisionRayTrace(start:Vec3, end:Vec3):ExtendedMOP = rayTraceAll(start, end).headOption.getOrElse(null) def harvestPart(index:Int, drop:Boolean):Boolean = { val part = partList(index) if(part == null) return false if(drop) dropItems(part.getDrops) remPart(part) return partList.isEmpty } def dropItems(items:Iterable[ItemStack]) { val pos = Vector3.fromTileEntityCenter(this) items.foreach(item => TileMultipart.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) { TileMultipart.startOperation(this) partList.foreach(_.onEntityCollision(entity)) TileMultipart.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, MultipartProxy.block.blockID) } } class 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, pass:Int) { partList.foreach(part => part.renderDynamic(pos, frame, pass:Int)) } def randomDisplayTick(random:Random){} override def shouldRenderInPass(pass:Int) = { MultipartRenderer.pass = pass true } } object TileMultipart { 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_impl(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 val operationSync = new OperationSynchroniser def startOperation(tile:TileMultipart) = if(!tile.worldObj.isRemote) operationSync.startOperation(tile) def finishOperation(tile:TileMultipart) = if(!tile.worldObj.isRemote) 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 canPlacePart(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 = { assert(!world.isRemote, "Cannot add multi parts to a client tile.") if(queueAddition(world, pos, part)) return null return MultipartGenerator.addPart(world, pos, part) } def handleDescPacket(world:World, pos:BlockCoord, packet:PacketCustom) { val nparts = packet.readUByte 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.setBlock(pos.x, pos.y, pos.z, MultipartProxy.block.blockID) 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) MultipartGenerator.addPart(world, pos, part) } case 254 => if(tilemp != null) { tilemp.remPart_impl(tilemp.partList(packet.readUByte)) } 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.2 item.motionZ = world.rand.nextGaussian() * 0.05 item.delayBeforeCanPickup = 10 world.spawnEntityInWorld(item) } }