231 lines
6.7 KiB
Scala
231 lines
6.7 KiB
Scala
package edx.basic.process.mixing
|
|
|
|
import java.awt.Color
|
|
import java.util.ArrayList
|
|
|
|
import cpw.mods.fml.relauncher.{Side, SideOnly}
|
|
import edx.basic.BasicContent
|
|
import edx.core.Reference
|
|
import edx.core.resource.alloy.{Alloy, AlloyUtility}
|
|
import edx.core.resource.content.{ItemDust, ItemRefinedDust}
|
|
import io.netty.buffer.ByteBuf
|
|
import net.minecraft.block.Block
|
|
import net.minecraft.block.material.Material
|
|
import net.minecraft.entity.player.EntityPlayer
|
|
import net.minecraft.item.ItemStack
|
|
import net.minecraft.nbt.NBTTagCompound
|
|
import net.minecraft.util.ResourceLocation
|
|
import net.minecraftforge.client.IItemRenderer.ItemRenderType
|
|
import net.minecraftforge.client.model.AdvancedModelLoader
|
|
import org.lwjgl.opengl.GL11
|
|
import resonantengine.api.item.ISimpleItemRenderer
|
|
import resonantengine.core.network.discriminator.PacketType
|
|
import resonantengine.lib.factory.resources.ResourceFactory
|
|
import resonantengine.lib.factory.resources.item.TItemResource
|
|
import resonantengine.lib.modcontent.block.ResonantTile
|
|
import resonantengine.lib.render.RenderUtility
|
|
import resonantengine.lib.render.model.ModelCube
|
|
import resonantengine.lib.transform.region.Cuboid
|
|
import resonantengine.lib.transform.vector.{Vector3, VectorWorld}
|
|
import resonantengine.lib.utility.inventory.InventoryUtility
|
|
import resonantengine.lib.utility.nbt.NBTUtility
|
|
import resonantengine.lib.wrapper.ByteBufWrapper._
|
|
import resonantengine.prefab.block.itemblock.ItemBlockSaved
|
|
import resonantengine.prefab.network.{TPacketReceiver, TPacketSender}
|
|
|
|
/**
|
|
* A glass jar for mixing different dusts/refined together.
|
|
* @author Calclavia
|
|
*/
|
|
object TileGlassJar
|
|
{
|
|
val model = AdvancedModelLoader.loadModel(new ResourceLocation(Reference.domain, Reference.modelPath + "glassJar.tcn"))
|
|
val dustMaterialTexture = new ResourceLocation(Reference.domain, Reference.blockTextureDirectory + "material_sand.png")
|
|
}
|
|
|
|
class TileGlassJar extends ResonantTile(Material.wood) with TPacketReceiver with TPacketSender with ISimpleItemRenderer
|
|
{
|
|
var alloy = new Alloy(8)
|
|
var mixed = false
|
|
|
|
setTextureName("glass")
|
|
bounds = new Cuboid(0.2, 0, 0.2, 0.8, 1, 0.8)
|
|
normalRender = false
|
|
isOpaqueCube = false
|
|
itemBlock = classOf[ItemGlassJar]
|
|
|
|
override def canUpdate: Boolean = false
|
|
|
|
/**
|
|
* Override this method
|
|
* Be sure to super this method or manually write the id into the packet when sending
|
|
*/
|
|
override def write(buf: ByteBuf, id: Int)
|
|
{
|
|
super.write(buf, id)
|
|
buf <<<< writeToNBT
|
|
}
|
|
|
|
override def writeToNBT(nbt: NBTTagCompound)
|
|
{
|
|
super.writeToNBT(nbt)
|
|
nbt.setBoolean("mixed", mixed)
|
|
alloy.save(nbt)
|
|
}
|
|
|
|
override def read(buf: ByteBuf, id: Int, packetType: PacketType)
|
|
{
|
|
super.read(buf, id, packetType)
|
|
buf >>>> readFromNBT
|
|
}
|
|
|
|
override def readFromNBT(nbt: NBTTagCompound)
|
|
{
|
|
super.readFromNBT(nbt)
|
|
mixed = nbt.getBoolean("mixed")
|
|
alloy.load(nbt)
|
|
}
|
|
|
|
override def getDrops(metadata: Int, fortune: Int): ArrayList[ItemStack] = new ArrayList[ItemStack]
|
|
|
|
override def onRemove(block: Block, par6: Int)
|
|
{
|
|
val stack: ItemStack = ItemBlockSaved.getItemStackWithNBT(block, world, x.toInt, y.toInt, z.toInt)
|
|
InventoryUtility.dropItemStack(world, center, stack)
|
|
}
|
|
|
|
override def renderInventoryItem(`type`: ItemRenderType, itemStack: ItemStack, data: AnyRef*): Unit =
|
|
{
|
|
renderInventory(itemStack)
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
override def renderInventory(itemStack: ItemStack): Unit =
|
|
{
|
|
GL11.glPushMatrix()
|
|
renderMixture(itemStack)
|
|
GL11.glPopMatrix()
|
|
|
|
GL11.glPushMatrix()
|
|
GL11.glTranslated(0, 0.3, 0)
|
|
renderJar()
|
|
GL11.glPopMatrix()
|
|
}
|
|
|
|
def renderMixture(itemStack: ItemStack = null)
|
|
{
|
|
val alloy: Alloy =
|
|
if (itemStack != null)
|
|
new Alloy(NBTUtility.getNBTTagCompound(itemStack))
|
|
else
|
|
this.alloy
|
|
|
|
val mixed =
|
|
if (itemStack != null)
|
|
NBTUtility.getNBTTagCompound(itemStack).getBoolean("mixed")
|
|
else
|
|
this.mixed
|
|
|
|
if (alloy != null && alloy.size > 0)
|
|
{
|
|
GL11.glPushMatrix()
|
|
RenderUtility.bind(TileGlassJar.dustMaterialTexture)
|
|
|
|
if (mixed)
|
|
{
|
|
val color = new Color(alloy.color).darker.darker.darker
|
|
GL11.glTranslated(0, -0.5 + 0.75f / 2 * alloy.percentage, 0)
|
|
GL11.glScalef(0.4f, 0.75f * alloy.percentage, 0.4f)
|
|
GL11.glColor4f(color.getRed / 255f, color.getGreen / 255f, color.getBlue / 255f, 1)
|
|
ModelCube.INSTNACE.render()
|
|
}
|
|
else
|
|
{
|
|
val size = alloy.size
|
|
val height = 0.72f / 8f
|
|
|
|
//Translate to bottom of the jar
|
|
GL11.glTranslatef(0, -0.45f, 0)
|
|
|
|
alloy.content.foreach
|
|
{
|
|
case (material, materialCount) =>
|
|
{
|
|
val color = new Color(ResourceFactory.getColor(material)).darker.darker.darker
|
|
GL11.glPushMatrix()
|
|
GL11.glTranslated(0, (height * materialCount) / 2, 0)
|
|
GL11.glScalef(0.4f, height * materialCount, 0.4f)
|
|
GL11.glColor4f(color.getRed / 255f, color.getGreen / 255f, color.getBlue / 255f, 1)
|
|
ModelCube.INSTNACE.render()
|
|
GL11.glPopMatrix()
|
|
|
|
//Translate each section of the jar upwards
|
|
GL11.glTranslatef(0, height * materialCount, 0)
|
|
}
|
|
}
|
|
}
|
|
|
|
GL11.glPopMatrix()
|
|
}
|
|
}
|
|
|
|
def renderJar()
|
|
{
|
|
RenderUtility.enableBlending()
|
|
GL11.glScalef(1.6f, 1.6f, 1.6f)
|
|
GL11.glColor4f(1, 1, 1, 1)
|
|
RenderUtility.bind(Reference.domain, Reference.modelPath + "glassJar.png")
|
|
TileGlassJar.model.renderAll()
|
|
RenderUtility.disableBlending()
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
override def renderDynamic(pos: Vector3, frame: Float, pass: Int)
|
|
{
|
|
GL11.glPushMatrix()
|
|
GL11.glTranslated(pos.x + 0.5, pos.y + 0.5, pos.z + 0.5)
|
|
renderMixture()
|
|
GL11.glPopMatrix()
|
|
|
|
GL11.glPushMatrix()
|
|
GL11.glTranslated(pos.x + 0.5, pos.y + 0.8, pos.z + 0.5)
|
|
renderJar()
|
|
GL11.glPopMatrix()
|
|
}
|
|
|
|
@SideOnly(Side.CLIENT)
|
|
override protected def getTextureName: String = textureName
|
|
|
|
override protected def use(player: EntityPlayer, side: Int, hit: Vector3): Boolean =
|
|
{
|
|
if (!world.isRemote)
|
|
{
|
|
if (player.getCurrentEquippedItem != null)
|
|
{
|
|
val item = player.getCurrentEquippedItem.getItem
|
|
|
|
if (item.isInstanceOf[ItemDust] || item.isInstanceOf[ItemRefinedDust])
|
|
{
|
|
if (alloy.mix(item.asInstanceOf[TItemResource].material))
|
|
{
|
|
player.getCurrentEquippedItem.splitStack(1)
|
|
sendDescPacket()
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
else if (mixed)
|
|
{
|
|
//Eject dust
|
|
InventoryUtility.dropItemStack(new VectorWorld(player), AlloyUtility.setAlloy(new ItemStack(BasicContent.itemAlloyDust, alloy.size), alloy))
|
|
alloy = new Alloy(8)
|
|
mixed = false
|
|
sendDescPacket()
|
|
}
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
}
|