| package codechicken.multipart |
| |
| import net.minecraft.tileentity.TileEntity |
| import scala.collection.mutable.ListBuffer |
| import codechicken.lib.packet.PacketCustom |
| import codechicken.lib.vec.BlockCoord |
| import net.minecraft.world.World |
| import java.util.List |
| import net.minecraft.nbt.NBTTagCompound |
| import codechicken.lib.data.MCDataOutput |
| 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 java.util.Random |
| import codechicken.multipart.handler.MultipartSPH |
| import codechicken.lib.lighting.LazyLightMatrix |
| 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 |
| import scala.collection.mutable.{Map => MMap} |
| import net.minecraft.util.AxisAlignedBB |
| |
| class TileMultipart extends TileEntity |
| { |
| /** |
| * List of parts in this tile space |
| */ |
| var partList = Seq[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 |
| |
| /** |
| * Implicit java conversion of part list |
| */ |
| def jPartList():List[TMultiPart] = partList |
| |
| override def canUpdate = doesTick |
| |
| def operate(f:(TMultiPart)=>Unit) { |
| val it = partList.iterator |
| while(it.hasNext) { |
| val p = it.next() |
| if(p.tile != null) f(p) |
| } |
| } |
| |
| override def updateEntity() |
| { |
| operate(_.update()) |
| } |
| |
| override def onChunkUnload() |
| { |
| operate(_.onChunkUnload()) |
| } |
| |
| def onChunkLoad() |
| { |
| operate(_.onChunkLoad()) |
| } |
| |
| final def setValid(b:Boolean) |
| { |
| if(b) |
| super.validate() |
| else |
| super.invalidate() |
| } |
| |
| def onMoved() |
| { |
| operate(_.onMoved()) |
| } |
| |
| override def invalidate() |
| { |
| if(!isInvalid) |
| { |
| super.invalidate() |
| if(worldObj != null) { |
| partList.foreach(_.onWorldSeparate()) |
| if(worldObj.isRemote) |
| TileMultipart.putClientCache(this) |
| } |
| } |
| } |
| |
| /** |
| * 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) |
| { |
| operate(p => if(part != p) p.onPartChanged(part)) |
| } |
| |
| /** |
| * Notifies all parts not in the passed collection of a change from all the parts in the collection |
| */ |
| def multiPartChange(parts:Collection[TMultiPart]) |
| { |
| operate(p => if(!parts.contains(p)) parts.foreach(p.onPartChanged)) |
| } |
| |
| /** |
| * Notifies neighboring blocks that this tile has changed |
| */ |
| def notifyTileChange() |
| { |
| worldObj.func_96440_m(xCoord, yCoord, zCoord, 0) |
| } |
| |
| def onNeighborBlockChange() |
| { |
| operate(_.onNeighborChanged()) |
| } |
| |
| /** |
| * Blank implementation, overriden by TTileChangeTile |
| */ |
| def onNeighborTileChange(tileX:Int, tileY:Int, tileZ:Int) {} |
| |
| def getLightValue = partList.view.map(_.getLightValue).max |
| |
| def getExplosionResistance(entity:Entity) = partList.view.map(_.explosionResistance(entity)).max |
| |
| /** |
| * Callback for parts to mark the chunk as needs saving |
| */ |
| def markDirty() |
| { |
| worldObj.markTileEntityChunkModified(xCoord, yCoord, zCoord, this) |
| } |
| |
| /** |
| * Mark this block space for a render update. |
| */ |
| def markRender() |
| { |
| worldObj.markBlockForRenderUpdate(xCoord, yCoord, zCoord) |
| } |
| |
| /** |
| * Helper function for calling a second level notify on a side (eg indirect power from a lever) |
| */ |
| def notifyNeighborChange(side:Int) |
| { |
| val pos = new BlockCoord(this).offset(side) |
| worldObj.notifyBlocksOfNeighborChange(pos.x, pos.y, pos.z, MultipartProxy.block.blockID) |
| } |
| |
| 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 && worldObj.getBlockTileEntity(xCoord, yCoord, zCoord) == this) |
| { |
| if(tick) |
| worldObj.addTileEntity(this) |
| else |
| worldObj.markTileEntityForDespawn(this) |
| } |
| } |
| |
| /** |
| * Returns true if part can be added to this space |
| */ |
| def canAddPart(part:TMultiPart):Boolean = |
| { |
| if(partList.contains(part)) |
| return false |
| |
| return occlusionTest(partList, part) |
| } |
| |
| /** |
| * Returns true if opart can be replaced with npart (note opart and npart may be the exact same object) |
| * |
| * This function should be used for testing if a part can change it's shape (eg. rotation, expansion, cable connection) |
| * For example, to test whether a cable part can connect to it's neighbor: |
| * 1. Set the cable part's bounding boxes as if the connection is established |
| * 2. Call canReplacePart(part, part) |
| * 3. If canReplacePart succeeds, perform connection, else, revert bounding box |
| */ |
| def canReplacePart(opart:TMultiPart, npart:TMultiPart):Boolean = |
| { |
| val olist = partList.filterNot(_ == opart) |
| if(olist.contains(npart)) |
| return false |
| |
| return occlusionTest(olist, npart) |
| } |
| |
| /** |
| * Returns true if parts do not occlude npart |
| */ |
| def occlusionTest(parts:Seq[TMultiPart], npart:TMultiPart):Boolean = |
| { |
| return parts.forall(part => part.occlusionTest(npart) && npart.occlusionTest(part)) |
| } |
| |
| /** |
| * Get the write stream for updates to 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) |
| notifyTileChange() |
| 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 = partList:+part |
| bindPart(part) |
| part.bind(this) |
| |
| if(!doesTick && part.doesTick) |
| setTicking(true) |
| } |
| |
| /** |
| * Bind this part to an internal cache. |
| * Provided for trait overrides, do not call externally. |
| */ |
| def bindPart(part:TMultiPart){} |
| |
| /** |
| * Called when a part is added (placement) |
| * Provided for trait overrides, do not call externally. |
| */ |
| def partAdded(part:TMultiPart) |
| { |
| if(part.isInstanceOf[IRandomUpdateTick]) |
| TickScheduler.loadRandomTick(part) |
| } |
| |
| /** |
| * Removes part from this tile. Note that due to the operation sync, the part may not be removed until the call stack has been passed to all other parts in the space. |
| */ |
| def remPart(part:TMultiPart):TileMultipart = |
| { |
| assert(!worldObj.isRemote, "Cannot remove multi parts from a client tile") |
| remPart_impl(part) |
| } |
| |
| private[multipart] def remPart_impl(part:TMultiPart):TileMultipart = |
| { |
| remPart_do(part, !worldObj.isRemote) |
| |
| if(!isInvalid) |
| { |
| val tile = MultipartGenerator.partRemoved(this, part) |
| notifyPartChange(part) |
| markDirty() |
| markRender() |
| return tile |
| } |
| |
| 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") |
| |
| part.preRemove() |
| partList = partList.filterNot(_ == 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 |
| } |
| |
| /** |
| * Remove this part from internal cache. |
| * Provided for trait overrides, do not call externally. |
| */ |
| def partRemoved(part:TMultiPart, p:Int){} |
| |
| private[multipart] def loadParts(parts:ListBuffer[TMultiPart]) |
| { |
| clearParts() |
| parts.foreach(p => addPart_do(p)) |
| if(worldObj != null) { |
| if(worldObj.isRemote) |
| operate(_.onWorldJoin()) |
| notifyPartChange(null) |
| } |
| } |
| |
| /** |
| * Remove all parts from internal cache |
| * Provided for trait overrides, do not call externally. |
| */ |
| def clearParts() |
| { |
| partList = Seq() |
| } |
| |
| /** |
| * Writes the description of this tile, and all parts composing it, to packet |
| */ |
| def writeDesc(packet:MCDataOutput) |
| { |
| packet.writeByte(partList.size) |
| partList.foreach{part => |
| MultiPartRegistry.writePartID(packet, part) |
| part.writeDesc(packet) |
| } |
| } |
| |
| /** |
| * Perform a raytrace returning all intersecting parts sorted nearest to farthest |
| */ |
| 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 |
| } |
| |
| /** |
| * Perform a raytrace returning the nearest intersecting part |
| */ |
| def collisionRayTrace(start:Vec3, end:Vec3):ExtendedMOP = rayTraceAll(start, end).headOption.getOrElse(null) |
| |
| /** |
| * Drop and remove part at index (internal mining callback) |
| */ |
| def harvestPart(index:Int, hit:ExtendedMOP, player:EntityPlayer) = partList(index) match { |
| case null => |
| case part => part.harvest(hit, player) |
| } |
| |
| /** |
| * Utility function for dropping items around the center of this space |
| */ |
| def dropItems(items:Iterable[ItemStack]) |
| { |
| val pos = Vector3.fromTileEntityCenter(this) |
| items.foreach(item => TileMultipart.dropItem(item, worldObj, pos)) |
| } |
| |
| 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) |
| } |
| |
| /** |
| * Internal callback |
| */ |
| def onEntityCollision(entity:Entity) |
| { |
| operate(_.onEntityCollision(entity)) |
| } |
| |
| /** |
| * Internal callback, overriden in TRedstoneTile |
| */ |
| def strongPowerLevel(side:Int) = 0 |
| |
| /** |
| * Internal callback, overriden in TRedstoneTile |
| */ |
| def weakPowerLevel(side:Int) = 0 |
| |
| /** |
| * Internal callback, overriden in TRedstoneTile |
| */ |
| def canConnectRedstone(side:Int) = false |
| } |
| |
| 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 |
| } |
| |
| override def getRenderBoundingBox = AxisAlignedBB.getAABBPool.getAABB(xCoord, yCoord, zCoord, xCoord + 1, yCoord + 1, zCoord + 1) |
| } |
| |
| /** |
| * Static class with multipart manipulation helper functions |
| */ |
| object TileMultipart |
| { |
| var renderID:Int = -1 |
| |
| /** |
| * Playerinstance will often remove the tile entity instance and set the block to air on the client before the multipart packet handler fires it's updates. |
| * In order to maintain the packet data, and make sure all written data is read, the tile needs to be kept around internally until |
| */ |
| private val clientFlushMap = MMap[BlockCoord, TileMultipart]() |
| |
| private[multipart] def flushClientCache() = clientFlushMap.clear() |
| |
| private[multipart] def putClientCache(t:TileMultipart) = clientFlushMap.put(new BlockCoord(t), t) |
| |
| /** |
| * Gets a multipar ttile instance at pos, converting if necessary. |
| */ |
| def getOrConvertTile(world:World, pos:BlockCoord) = getOrConvertTile2(world, pos)._1 |
| |
| /** |
| * Gets a multipart tile instance at pos, converting if necessary. |
| * Note converted tiles are merely a structure formality, |
| * they do not actually exist in world until they are required to by the addition of another multipart to their space. |
| * @return (The tile or null if there was none, true if the tile is a result of a conversion) |
| */ |
| 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) |
| } |
| |
| /** |
| * Gets the multipart tile instance at pos, or null if it doesn't exist or is not a multipart tile |
| */ |
| def getTile(world:World, pos:BlockCoord) = |
| world.getBlockTileEntity(pos.x, pos.y, pos.z) match { |
| case t:TileMultipart => t |
| case _ => null |
| } |
| |
| /** |
| * Returns whether part can be added to the space at pos. Will do conversions as necessary. |
| * This function is the recommended way to add parts to the world. |
| */ |
| 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 |
| } |
| |
| /** |
| * Returns if the block at pos is replaceable (air, vines etc) |
| */ |
| 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) |
| } |
| |
| /** |
| * Adds a part to a block space. canPlacePart should always be called first. |
| * The addition of parts on the client is handled internally. |
| */ |
| def addPart(world:World, pos:BlockCoord, part:TMultiPart):TileMultipart = |
| { |
| assert(!world.isRemote, "Cannot add multi parts to a client tile.") |
| return MultipartGenerator.addPart(world, pos, part) |
| } |
| |
| /** |
| * Constructs this tile and its parts from a desc packet |
| */ |
| 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) |
| MultipartGenerator.silentAddTile(world, pos, tilemp) |
| } |
| |
| tilemp.loadParts(parts) |
| tilemp.notifyTileChange() |
| tilemp.markRender() |
| } |
| |
| /** |
| * Handles an update packet, addition, removal and otherwise |
| */ |
| def handlePacket(pos:BlockCoord, world:World, i:Int, packet:PacketCustom) |
| { |
| lazy val tilemp = Option(BlockMultipart.getTile(world, pos.x, pos.y, pos.z)).getOrElse(clientFlushMap(pos)) |
| |
| i match |
| { |
| case 253 => |
| val part = MultiPartRegistry.readPart(packet) |
| part.readDesc(packet) |
| MultipartGenerator.addPart(world, pos, part) |
| case 254 => tilemp.remPart_impl(tilemp.partList(packet.readUByte)) |
| case _ => tilemp.partList(i).read(packet) |
| } |
| } |
| |
| /** |
| * Creates this tile from an NBT tag |
| */ |
| def createFromNBT(tag:NBTTagCompound):TileMultipart = |
| { |
| 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 |
| } |
| |
| /** |
| * Drops an item around pos |
| */ |
| 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) |
| } |
| } |