mirror of
https://github.com/GTNewHorizons/TinkersConstruct.git
synced 2026-11-20 04:09:40 +00:00
Move the old smelterylogic implementation to backup classes for a compatibility config. Change most logic to take actual smeltery size into account.
This commit is contained in:
1 parent
c0ad340460
commit
9818edc0a8
11 files changed
+2218
-509
No files matched your search
@@ -117,6 +117,8 @@ public class SmelteryProxyClient extends SmelteryProxyCommon
|
||||
{
|
||||
if (PHConstruct.newSmeltery)
|
||||
return new AdaptiveSmelteryGui(player.inventory, (AdaptiveSmelteryLogic) world.getTileEntity(x, y, z), world, x, y, z);
|
||||
else if(PHConstruct.oldSmeltery)
|
||||
return new SmelteryGuiOld(player.inventory, (SmelteryLogicOld) world.getTileEntity(x, y, z), world, x, y, z);
|
||||
else
|
||||
return new SmelteryGui(player.inventory, (SmelteryLogic) world.getTileEntity(x, y, z), world, x, y, z);
|
||||
}
|
||||
|
||||
@@ -707,8 +707,8 @@ public class TinkerSmeltery
|
||||
}
|
||||
else
|
||||
{
|
||||
if(PHConstruct.newerSmeltery)
|
||||
GameRegistry.registerTileEntity(FlexibleSmelteryLogic.class, "TConstruct.Smeltery");
|
||||
if(PHConstruct.oldSmeltery)
|
||||
GameRegistry.registerTileEntity(SmelteryLogicOld.class, "TConstruct.Smeltery");
|
||||
else
|
||||
GameRegistry.registerTileEntity(SmelteryLogic.class, "TConstruct.Smeltery");
|
||||
GameRegistry.registerTileEntity(SmelteryDrainLogic.class, "TConstruct.SmelteryDrain");
|
||||
|
||||
@@ -238,9 +238,9 @@ public class SmelteryBlock extends InventoryBlock
|
||||
{
|
||||
case 0:
|
||||
if (PHConstruct.newSmeltery)
|
||||
return new FlexibleSmelteryLogic();
|
||||
else if(PHConstruct.newerSmeltery)
|
||||
return new FlexibleSmelteryLogic();
|
||||
return new AdaptiveSmelteryLogic();
|
||||
else if(PHConstruct.oldSmeltery)
|
||||
return new SmelteryLogicOld();
|
||||
else
|
||||
return new SmelteryLogic();
|
||||
|
||||
|
||||
@@ -0,0 +1,489 @@
|
||||
package tconstruct.smeltery.gui;
|
||||
|
||||
import net.minecraft.client.renderer.RenderHelper;
|
||||
import net.minecraft.client.renderer.Tessellator;
|
||||
import net.minecraft.client.renderer.texture.TextureMap;
|
||||
import net.minecraft.entity.player.InventoryPlayer;
|
||||
import net.minecraft.util.EnumChatFormatting;
|
||||
import net.minecraft.util.IIcon;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraft.util.StatCollector;
|
||||
import net.minecraft.world.World;
|
||||
import net.minecraftforge.fluids.FluidStack;
|
||||
import org.lwjgl.input.Mouse;
|
||||
import org.lwjgl.opengl.GL11;
|
||||
import org.lwjgl.opengl.GL12;
|
||||
import tconstruct.TConstruct;
|
||||
import tconstruct.client.gui.NewContainerGui;
|
||||
import tconstruct.smeltery.inventory.ActiveContainer;
|
||||
import tconstruct.smeltery.inventory.SmelteryContainer;
|
||||
import tconstruct.smeltery.logic.SmelteryLogicOld;
|
||||
import tconstruct.util.network.SmelteryPacket;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
public class SmelteryGuiOld extends NewContainerGui
|
||||
{
|
||||
public SmelteryLogicOld logic;
|
||||
String username;
|
||||
boolean isScrolling = false;
|
||||
boolean wasClicking;
|
||||
float currentScroll = 0.0F;
|
||||
int slotPos = 0;
|
||||
int prevSlotPos = 0;
|
||||
|
||||
public SmelteryGuiOld(InventoryPlayer inventoryplayer, SmelteryLogicOld smeltery, World world, int x, int y, int z)
|
||||
{
|
||||
super((ActiveContainer) smeltery.getGuiContainer(inventoryplayer, world, x, y, z));
|
||||
logic = smeltery;
|
||||
username = inventoryplayer.player.getDisplayName();
|
||||
xSize = 248;
|
||||
smeltery.updateFuelDisplay();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void initGui ()
|
||||
{
|
||||
super.initGui();
|
||||
|
||||
if (logic != null)
|
||||
logic.updateFuelGague();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void drawScreen (int mouseX, int mouseY, float par3)
|
||||
{
|
||||
super.drawScreen(mouseX, mouseY, par3);
|
||||
updateScrollbar(mouseX, mouseY, par3);
|
||||
}
|
||||
|
||||
protected void updateScrollbar (int mouseX, int mouseY, float par3)
|
||||
{
|
||||
if (logic.layers > 2)
|
||||
{
|
||||
boolean mouseDown = Mouse.isButtonDown(0);
|
||||
int lefto = this.guiLeft;
|
||||
int topo = this.guiTop;
|
||||
int xScroll = lefto + 67;
|
||||
int yScroll = topo + 8;
|
||||
int scrollWidth = xScroll + 14;
|
||||
int scrollHeight = yScroll + 144;
|
||||
|
||||
if (!this.wasClicking && mouseDown && mouseX >= xScroll && mouseY >= yScroll && mouseX < scrollWidth && mouseY < scrollHeight)
|
||||
{
|
||||
this.isScrolling = true;
|
||||
}
|
||||
|
||||
if (!mouseDown)
|
||||
{
|
||||
this.isScrolling = false;
|
||||
}
|
||||
|
||||
if (wasClicking && !isScrolling && slotPos != prevSlotPos)
|
||||
{
|
||||
prevSlotPos = slotPos;
|
||||
}
|
||||
|
||||
this.wasClicking = mouseDown;
|
||||
|
||||
if (this.isScrolling)
|
||||
{
|
||||
this.currentScroll = (mouseY - yScroll - 7.5F) / (scrollHeight - yScroll - 15.0F);
|
||||
|
||||
if (this.currentScroll < 0.0F)
|
||||
{
|
||||
this.currentScroll = 0.0F;
|
||||
}
|
||||
|
||||
if (this.currentScroll > 1.0F)
|
||||
{
|
||||
this.currentScroll = 1.0F;
|
||||
}
|
||||
|
||||
int s = ((SmelteryContainer) this.container).scrollTo(this.currentScroll);
|
||||
if (s != -1)
|
||||
slotPos = s;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
protected void drawGuiContainerForegroundLayer (int mouseX, int mouseY)
|
||||
{
|
||||
fontRendererObj.drawString(StatCollector.translateToLocal("crafters.Smeltery"), 86, 5, 0x404040);
|
||||
fontRendererObj.drawString(StatCollector.translateToLocal("container.inventory"), 90, (ySize - 96) + 2, 0x404040);
|
||||
|
||||
int base = 0;
|
||||
int cornerX = (width - xSize) / 2 + 36;
|
||||
int cornerY = (height - ySize) / 2;
|
||||
|
||||
for (FluidStack liquid : logic.moltenMetal)
|
||||
{
|
||||
int basePos = 54;
|
||||
int initialLiquidSize = 0;
|
||||
int liquidSize = 0;// liquid.amount * 52 / liquidLayers;
|
||||
if (logic.getCapacity() > 0)
|
||||
{
|
||||
int total = logic.getTotalLiquid();
|
||||
int liquidLayers = (total / 20000 + 1) * 20000;
|
||||
if (liquidLayers > 0)
|
||||
{
|
||||
liquidSize = liquid.amount * 52 / liquidLayers;
|
||||
if (liquidSize == 0)
|
||||
liquidSize = 1;
|
||||
base += liquidSize;
|
||||
}
|
||||
}
|
||||
|
||||
int leftX = cornerX + basePos;
|
||||
int topY = (cornerY + 68) - base;
|
||||
int sizeX = 52;
|
||||
int sizeY = liquidSize;
|
||||
if (mouseX >= leftX && mouseX <= leftX + sizeX && mouseY >= topY && mouseY < topY + sizeY)
|
||||
{
|
||||
drawFluidStackTooltip(liquid, mouseX - cornerX + 36, mouseY - cornerY);
|
||||
|
||||
}
|
||||
}
|
||||
if (logic.fuelGague > 0)
|
||||
{
|
||||
int leftX = cornerX + 117;
|
||||
int topY = (cornerY + 68) - logic.getScaledFuelGague(52);
|
||||
int sizeX = 12;
|
||||
int sizeY = logic.getScaledFuelGague(52);
|
||||
if (mouseX >= leftX && mouseX <= leftX + sizeX && mouseY >= topY && mouseY < topY + sizeY)
|
||||
{
|
||||
drawFluidStackTooltip(new FluidStack(-37, logic.fuelAmount), mouseX - cornerX + 36, mouseY - cornerY);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static final ResourceLocation background = new ResourceLocation("tinker", "textures/gui/smeltery.png");
|
||||
private static final ResourceLocation backgroundSide = new ResourceLocation("tinker", "textures/gui/smelteryside.png");
|
||||
private static final ResourceLocation terrain = new ResourceLocation("terrain.png");
|
||||
|
||||
@Override
|
||||
protected void drawGuiContainerBackgroundLayer (float f, int mouseX, int mouseY)
|
||||
{
|
||||
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
|
||||
this.mc.getTextureManager().bindTexture(background);
|
||||
int cornerX = (width - xSize) / 2 + 36;
|
||||
int cornerY = (height - ySize) / 2;
|
||||
drawTexturedModalRect(cornerX + 46, cornerY, 0, 0, 176, ySize);
|
||||
|
||||
// Fuel - Lava
|
||||
this.mc.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
|
||||
if (logic.fuelGague > 0)
|
||||
{
|
||||
IIcon lavaIcon = logic.getFuelIcon();
|
||||
int fuel = logic.getScaledFuelGague(52);
|
||||
int count = 0;
|
||||
while (fuel > 0)
|
||||
{
|
||||
int size = fuel >= 16 ? 16 : fuel;
|
||||
fuel -= size;
|
||||
drawLiquidRect(cornerX + 117, (cornerY + 68) - size - 16 * count, lavaIcon, 12, size);
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
// Liquids - molten metal
|
||||
int base = 0;
|
||||
for (FluidStack liquid : logic.moltenMetal)
|
||||
{
|
||||
IIcon renderIndex = liquid.getFluid().getStillIcon();
|
||||
int basePos = 54;
|
||||
if (logic.getCapacity() > 0)
|
||||
{
|
||||
int total = logic.getTotalLiquid();
|
||||
int liquidLayers = (total / 20000 + 1) * 20000;
|
||||
if (liquidLayers > 0)
|
||||
{
|
||||
int liquidSize = liquid.amount * 52 / liquidLayers;
|
||||
if (liquidSize == 0)
|
||||
liquidSize = 1;
|
||||
while (liquidSize > 0)
|
||||
{
|
||||
int size = liquidSize >= 16 ? 16 : liquidSize;
|
||||
if (renderIndex != null)
|
||||
{
|
||||
drawLiquidRect(cornerX + basePos, (cornerY + 68) - size - base, renderIndex, 16, size);
|
||||
drawLiquidRect(cornerX + basePos + 16, (cornerY + 68) - size - base, renderIndex, 16, size);
|
||||
drawLiquidRect(cornerX + basePos + 32, (cornerY + 68) - size - base, renderIndex, 16, size);
|
||||
drawLiquidRect(cornerX + basePos + 48, (cornerY + 68) - size - base, renderIndex, 4, size);
|
||||
}
|
||||
liquidSize -= size;
|
||||
base += size;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Liquid gague
|
||||
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
|
||||
|
||||
this.mc.getTextureManager().bindTexture(background);
|
||||
drawTexturedModalRect(cornerX + 54, cornerY + 16, 176, 76, 52, 52);
|
||||
|
||||
// Side inventory
|
||||
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
|
||||
this.mc.getTextureManager().bindTexture(backgroundSide);
|
||||
if (logic.layers > 0)
|
||||
{
|
||||
if (logic.layers == 1)
|
||||
{
|
||||
drawTexturedModalRect(cornerX - 46, cornerY, 0, 0, 98, 43);
|
||||
drawTexturedModalRect(cornerX - 46, cornerY + 43, 0, 133, 98, 25);
|
||||
}
|
||||
else if (logic.layers == 2)
|
||||
{
|
||||
drawTexturedModalRect(cornerX - 46, cornerY, 0, 0, 98, 61);
|
||||
drawTexturedModalRect(cornerX - 46, cornerY + 61, 0, 97, 98, 61);
|
||||
}
|
||||
else
|
||||
{
|
||||
drawTexturedModalRect(cornerX - 46, cornerY, 0, 0, 98, ySize - 8);
|
||||
}
|
||||
drawTexturedModalRect(cornerX + 32, (int) (cornerY + 8 + 127 * currentScroll), 98, 0, 12, 15);
|
||||
}
|
||||
|
||||
// Temperature
|
||||
int slotSize = logic.layers * 9;
|
||||
if (slotSize > 24)
|
||||
slotSize = 24;
|
||||
for (int iter = 0; iter < slotSize; iter++)
|
||||
{
|
||||
int slotTemp = logic.getTempForSlot(iter + slotPos * 3) - 20;
|
||||
int maxTemp = logic.getMeltingPointForSlot(iter + slotPos * 3) - 20;
|
||||
if (slotTemp > 0 && maxTemp > 0)
|
||||
{
|
||||
int size = 16 * slotTemp / maxTemp + 1;
|
||||
drawTexturedModalRect(cornerX - 38 + (iter % 3 * 22), cornerY + 8 + (iter / 3 * 18) + 16 - size, 98, 15 + 16 - size, 5, size);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
protected void drawFluidStackTooltip (FluidStack par1ItemStack, int par2, int par3)
|
||||
{
|
||||
this.zLevel = 100;
|
||||
List list = getLiquidTooltip(par1ItemStack, this.mc.gameSettings.advancedItemTooltips);
|
||||
|
||||
for (int k = 0; k < list.size(); ++k)
|
||||
{
|
||||
list.set(k, EnumChatFormatting.GRAY + (String) list.get(k));
|
||||
}
|
||||
|
||||
this.drawToolTip(list, par2, par3);
|
||||
this.zLevel = 0;
|
||||
}
|
||||
|
||||
public List getLiquidTooltip (FluidStack liquid, boolean par2)
|
||||
{
|
||||
ArrayList list = new ArrayList();
|
||||
if (liquid.fluidID == -37)
|
||||
{
|
||||
list.add("\u00A7f" + StatCollector.translateToLocal("gui.smeltery.fuel"));
|
||||
list.add("mB: " + liquid.amount);
|
||||
}
|
||||
else
|
||||
{
|
||||
String name = liquid.getFluid().getLocalizedName();
|
||||
list.add("\u00A7f" + name);
|
||||
if (name.equals(StatCollector.translateToLocal("fluid.emerald.liquid")))
|
||||
{
|
||||
list.add(StatCollector.translateToLocal("gui.smeltery.emerald") + liquid.amount / 640f);
|
||||
}
|
||||
else if (name.equals(StatCollector.translateToLocal("fluid.glass.molten")))
|
||||
{
|
||||
int blocks = liquid.amount / 1000;
|
||||
if (blocks > 0)
|
||||
list.add(StatCollector.translateToLocal("gui.smeltery.glass.block") + blocks);
|
||||
int panels = (liquid.amount % 1000) / 250;
|
||||
if (panels > 0)
|
||||
list.add(StatCollector.translateToLocal("gui.smeltery.glass.pannel") + panels);
|
||||
int mB = (liquid.amount % 1000) % 250;
|
||||
if (mB > 0)
|
||||
list.add("mB: " + mB);
|
||||
}
|
||||
else if (name.equals(StatCollector.translateToLocal("fluid.stone.seared")))
|
||||
{
|
||||
int ingots = liquid.amount / TConstruct.ingotLiquidValue;
|
||||
if (ingots > 0)
|
||||
list.add(StatCollector.translateToLocal("gui.smeltery.glass.block") + ingots);
|
||||
int mB = liquid.amount % TConstruct.ingotLiquidValue;
|
||||
if (mB > 0)
|
||||
list.add("mB: " + mB);
|
||||
}
|
||||
else if (isMolten(name))
|
||||
{
|
||||
int ingots = liquid.amount / TConstruct.ingotLiquidValue;
|
||||
if (ingots > 0)
|
||||
list.add(StatCollector.translateToLocal("gui.smeltery.metal.ingot") + ingots);
|
||||
int mB = liquid.amount % TConstruct.ingotLiquidValue;
|
||||
if (mB > 0)
|
||||
{
|
||||
int nuggets = mB / TConstruct.nuggetLiquidValue;
|
||||
int junk = (mB % TConstruct.nuggetLiquidValue);
|
||||
if (nuggets > 0)
|
||||
list.add(StatCollector.translateToLocal("gui.smeltery.metal.nugget") + nuggets);
|
||||
if (junk > 0)
|
||||
list.add("mB: " + junk);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
list.add("mB: " + liquid.amount);
|
||||
}
|
||||
}
|
||||
return list;
|
||||
}
|
||||
|
||||
private boolean isMolten (String fluidName)
|
||||
{
|
||||
boolean molten = false;
|
||||
String[] moltenNames = StatCollector.translateToLocal("gui.smeltery.molten.check").split(",");
|
||||
|
||||
for (int i = 0; i < moltenNames.length; i++)
|
||||
{
|
||||
if (fluidName.contains(moltenNames[i].trim()))
|
||||
{
|
||||
molten = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return molten;
|
||||
}
|
||||
|
||||
protected void drawToolTip (List par1List, int par2, int par3)
|
||||
{
|
||||
if (!par1List.isEmpty())
|
||||
{
|
||||
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
|
||||
RenderHelper.disableStandardItemLighting();
|
||||
GL11.glDisable(GL11.GL_LIGHTING);
|
||||
GL11.glDisable(GL11.GL_DEPTH_TEST);
|
||||
int k = 0;
|
||||
Iterator iterator = par1List.iterator();
|
||||
|
||||
while (iterator.hasNext())
|
||||
{
|
||||
String s = (String) iterator.next();
|
||||
int l = this.fontRendererObj.getStringWidth(s);
|
||||
|
||||
if (l > k)
|
||||
{
|
||||
k = l;
|
||||
}
|
||||
}
|
||||
|
||||
int i1 = par2 + 12;
|
||||
int j1 = par3 - 12;
|
||||
int k1 = 8;
|
||||
|
||||
if (par1List.size() > 1)
|
||||
{
|
||||
k1 += 2 + (par1List.size() - 1) * 10;
|
||||
}
|
||||
|
||||
if (i1 + k > this.width)
|
||||
{
|
||||
i1 -= 28 + k;
|
||||
}
|
||||
|
||||
if (j1 + k1 + 6 > this.height)
|
||||
{
|
||||
j1 = this.height - k1 - 6;
|
||||
}
|
||||
|
||||
this.zLevel = 300.0F;
|
||||
itemRenderer.zLevel = 300.0F;
|
||||
int l1 = -267386864;
|
||||
this.drawGradientRect(i1 - 3, j1 - 4, i1 + k + 3, j1 - 3, l1, l1);
|
||||
this.drawGradientRect(i1 - 3, j1 + k1 + 3, i1 + k + 3, j1 + k1 + 4, l1, l1);
|
||||
this.drawGradientRect(i1 - 3, j1 - 3, i1 + k + 3, j1 + k1 + 3, l1, l1);
|
||||
this.drawGradientRect(i1 - 4, j1 - 3, i1 - 3, j1 + k1 + 3, l1, l1);
|
||||
this.drawGradientRect(i1 + k + 3, j1 - 3, i1 + k + 4, j1 + k1 + 3, l1, l1);
|
||||
int i2 = 1347420415;
|
||||
int j2 = (i2 & 16711422) >> 1 | i2 & -16777216;
|
||||
this.drawGradientRect(i1 - 3, j1 - 3 + 1, i1 - 3 + 1, j1 + k1 + 3 - 1, i2, j2);
|
||||
this.drawGradientRect(i1 + k + 2, j1 - 3 + 1, i1 + k + 3, j1 + k1 + 3 - 1, i2, j2);
|
||||
this.drawGradientRect(i1 - 3, j1 - 3, i1 + k + 3, j1 - 3 + 1, i2, i2);
|
||||
this.drawGradientRect(i1 - 3, j1 + k1 + 2, i1 + k + 3, j1 + k1 + 3, j2, j2);
|
||||
|
||||
for (int k2 = 0; k2 < par1List.size(); ++k2)
|
||||
{
|
||||
String s1 = (String) par1List.get(k2);
|
||||
this.fontRendererObj.drawStringWithShadow(s1, i1, j1, -1);
|
||||
|
||||
if (k2 == 0)
|
||||
{
|
||||
j1 += 2;
|
||||
}
|
||||
|
||||
j1 += 10;
|
||||
}
|
||||
|
||||
this.zLevel = 0.0F;
|
||||
itemRenderer.zLevel = 0.0F;
|
||||
}
|
||||
}
|
||||
|
||||
public void drawLiquidRect (int startU, int startV, IIcon icon, int endU, int endV)
|
||||
{
|
||||
float top = icon.getInterpolatedV(16 - endV);
|
||||
float bottom = icon.getMaxV();
|
||||
float left = icon.getMinU();
|
||||
float right = icon.getInterpolatedU(endU);
|
||||
Tessellator tessellator = Tessellator.instance;
|
||||
tessellator.startDrawingQuads();
|
||||
tessellator.addVertexWithUV(startU + 0, startV + endV, this.zLevel, left, bottom);//Bottom left
|
||||
tessellator.addVertexWithUV(startU + endU, startV + endV, this.zLevel, right, bottom);//Bottom right
|
||||
tessellator.addVertexWithUV(startU + endU, startV + 0, this.zLevel, right, top);//Top right
|
||||
tessellator.addVertexWithUV(startU + 0, startV + 0, this.zLevel, left, top); //Top left
|
||||
tessellator.draw();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void mouseClicked (int mouseX, int mouseY, int mouseButton)
|
||||
{
|
||||
super.mouseClicked(mouseX, mouseY, mouseButton);
|
||||
|
||||
int base = 0;
|
||||
int cornerX = (width - xSize) / 2 + 36;
|
||||
int cornerY = (height - ySize) / 2;
|
||||
int fluidToBeBroughtUp = -1;
|
||||
|
||||
for (FluidStack liquid : logic.moltenMetal)
|
||||
{
|
||||
int basePos = 54;
|
||||
int initialLiquidSize = 0;
|
||||
int liquidSize = 0;// liquid.amount * 52 / liquidLayers;
|
||||
if (logic.getCapacity() > 0)
|
||||
{
|
||||
int total = logic.getTotalLiquid();
|
||||
int liquidLayers = (total / 20000 + 1) * 20000;
|
||||
if (liquidLayers > 0)
|
||||
{
|
||||
liquidSize = liquid.amount * 52 / liquidLayers;
|
||||
if (liquidSize == 0)
|
||||
liquidSize = 1;
|
||||
base += liquidSize;
|
||||
}
|
||||
}
|
||||
|
||||
int leftX = cornerX + basePos;
|
||||
int topY = (cornerY + 68) - base;
|
||||
int sizeX = 52;
|
||||
int sizeY = liquidSize;
|
||||
if (mouseX >= leftX && mouseX <= leftX + sizeX && mouseY >= topY && mouseY < topY + sizeY)
|
||||
{
|
||||
fluidToBeBroughtUp = liquid.fluidID;
|
||||
|
||||
TConstruct.packetPipeline.sendToServer(new SmelteryPacket(logic.getWorldObj().provider.dimensionId, logic.xCoord, logic.yCoord, logic.zCoord, this.isShiftKeyDown(), fluidToBeBroughtUp));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -5,7 +5,6 @@ import net.minecraft.entity.player.*;
|
||||
import net.minecraft.inventory.Slot;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import tconstruct.smeltery.TinkerSmeltery;
|
||||
import tconstruct.smeltery.logic.FlexibleSmelteryLogic;
|
||||
import tconstruct.smeltery.logic.SmelteryLogic;
|
||||
|
||||
public class SmelteryContainer extends ActiveContainer
|
||||
@@ -24,30 +23,15 @@ public class SmelteryContainer extends ActiveContainer
|
||||
/* Smeltery inventory */
|
||||
|
||||
// new rectangular smeltery
|
||||
if(smeltery instanceof FlexibleSmelteryLogic)
|
||||
int totalSlots = smeltery.getBlockCapacity();
|
||||
int y = 0;
|
||||
|
||||
for(int i = 0; i < totalSlots; i++)
|
||||
{
|
||||
FlexibleSmelteryLogic fs = (FlexibleSmelteryLogic) smeltery;
|
||||
int xd = fs.maxPos.x - fs.minPos.x;
|
||||
int zd = fs.maxPos.z - fs.minPos.z;
|
||||
|
||||
int totalSlots = xd*zd*fs.layers;
|
||||
int y = 0;
|
||||
|
||||
for(int i = 0; i < totalSlots; i++)
|
||||
{
|
||||
int x = i%3;
|
||||
this.addDualSlotToContainer(new ActiveSlot(smeltery, x + y * 3, 2 + x * 22, 8 + y * 18, y < 8));
|
||||
if(x == 2)
|
||||
y++;
|
||||
}
|
||||
}
|
||||
// old 3x3 smeltery
|
||||
else {
|
||||
for (int y = 0; y < smeltery.layers * 3; y++) {
|
||||
for (int x = 0; x < 3; x++) {
|
||||
this.addDualSlotToContainer(new ActiveSlot(smeltery, x + y * 3, 2 + x * 22, 8 + y * 18, y < 8));
|
||||
}
|
||||
}
|
||||
int x = i%3;
|
||||
this.addDualSlotToContainer(new ActiveSlot(smeltery, x + y * 3, 2 + x * 22, 8 + y * 18, y < 8));
|
||||
if(x == 2)
|
||||
y++;
|
||||
}
|
||||
|
||||
/* Player inventory */
|
||||
|
||||
@@ -0,0 +1,271 @@
|
||||
package tconstruct.smeltery.inventory;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.entity.player.EntityPlayer;
|
||||
import net.minecraft.entity.player.InventoryPlayer;
|
||||
import net.minecraft.inventory.Slot;
|
||||
import net.minecraft.item.ItemStack;
|
||||
import tconstruct.smeltery.TinkerSmeltery;
|
||||
import tconstruct.smeltery.logic.SmelteryLogicOld;
|
||||
|
||||
public class SmelteryContainerOld extends ActiveContainer
|
||||
{
|
||||
public SmelteryLogicOld logic;
|
||||
public InventoryPlayer playerInv;
|
||||
public int fuel = 0;
|
||||
int slotRow;
|
||||
|
||||
public SmelteryContainerOld(InventoryPlayer inventoryplayer, SmelteryLogicOld smeltery)
|
||||
{
|
||||
logic = smeltery;
|
||||
playerInv = inventoryplayer;
|
||||
slotRow = 0;
|
||||
|
||||
/* Smeltery inventory */
|
||||
for (int y = 0; y < smeltery.layers * 3; y++) {
|
||||
for (int x = 0; x < 3; x++) {
|
||||
this.addDualSlotToContainer(new ActiveSlot(smeltery, x + y * 3, 2 + x * 22, 8 + y * 18, y < 8));
|
||||
}
|
||||
}
|
||||
|
||||
/* Player inventory */
|
||||
for (int column = 0; column < 3; column++)
|
||||
{
|
||||
for (int row = 0; row < 9; row++)
|
||||
{
|
||||
this.addSlotToContainer(new Slot(inventoryplayer, row + column * 9 + 9, 90 + row * 18, 84 + column * 18));
|
||||
}
|
||||
}
|
||||
|
||||
for (int column = 0; column < 9; column++)
|
||||
{
|
||||
this.addSlotToContainer(new Slot(inventoryplayer, column, 90 + column * 18, 142));
|
||||
}
|
||||
}
|
||||
|
||||
public int updateRows (int invRow)
|
||||
{
|
||||
if (invRow != slotRow)
|
||||
{
|
||||
slotRow = invRow;
|
||||
// TConstruct.logger.info(invRow);
|
||||
int basePos = invRow * 3;
|
||||
for (int iter = 0; iter < activeInventorySlots.size(); iter++)
|
||||
{
|
||||
ActiveSlot slot = (ActiveSlot) activeInventorySlots.get(iter);
|
||||
if (slot.activeSlotNumber >= basePos && slot.activeSlotNumber < basePos + 24)
|
||||
{
|
||||
slot.setActive(true);
|
||||
}
|
||||
else
|
||||
{
|
||||
slot.setActive(false);
|
||||
}
|
||||
int xPos = (iter - basePos) % 3;
|
||||
int yPos = (iter - basePos) / 3;
|
||||
slot.xDisplayPosition = 2 + 22 * xPos;
|
||||
slot.yDisplayPosition = 8 + 18 * yPos;
|
||||
}
|
||||
return slotRow;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
public int scrollTo (float scrollPos)
|
||||
{
|
||||
float total = (logic.getSizeInventory() - 24) / 3;
|
||||
int rowPos = (int) (total * scrollPos);
|
||||
return updateRows(rowPos);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void detectAndSendChanges () // TODO: Sync with this
|
||||
{
|
||||
super.detectAndSendChanges();
|
||||
/*
|
||||
* for (int i = 0; i < crafters.size(); i++) { ICrafting icrafting =
|
||||
* (ICrafting)crafters.get(i); if (progress != logic.progress) {
|
||||
* icrafting.sendProgressBarUpdate(this, 0, logic.progress); } if (fuel
|
||||
* != logic.fuel) { icrafting.sendProgressBarUpdate(this, 1,
|
||||
* logic.fuel); } if (fuelGague != logic.fuelGague) {
|
||||
* icrafting.sendProgressBarUpdate(this, 2, logic.fuelGague); } }
|
||||
*
|
||||
* progress = logic.progress; fuel = logic.fuel; fuelGague =
|
||||
* logic.fuelGague;
|
||||
*/
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateProgressBar (int id, int value)
|
||||
{
|
||||
if (id == 0)
|
||||
{
|
||||
logic.fuelGague = value;
|
||||
}
|
||||
/*
|
||||
* if (id == 1) { logic.fuel = value; }
|
||||
*/
|
||||
/*
|
||||
* if (id == 2) { logic.fuelGague = value; }
|
||||
*/
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean canInteractWith (EntityPlayer entityplayer)
|
||||
{
|
||||
Block block = logic.getWorldObj().getBlock(logic.xCoord, logic.yCoord, logic.zCoord);
|
||||
if (block != TinkerSmeltery.smeltery && block != TinkerSmeltery.smelteryNether)
|
||||
return false;
|
||||
return logic.isUseableByPlayer(entityplayer);
|
||||
}
|
||||
|
||||
@Override
|
||||
public ItemStack transferStackInSlot (EntityPlayer player, int slotID)
|
||||
{
|
||||
ItemStack stack = null;
|
||||
Slot slot = (Slot) this.inventorySlots.get(slotID);
|
||||
|
||||
if (slot != null && slot.getHasStack())
|
||||
{
|
||||
ItemStack slotStack = slot.getStack();
|
||||
stack = slotStack.copy();
|
||||
|
||||
if (slotID < logic.getSizeInventory())
|
||||
{
|
||||
if (!this.mergeItemStack(slotStack, logic.getSizeInventory(), this.inventorySlots.size(), true))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
}
|
||||
else if (!this.mergeItemStack(slotStack, 0, logic.getSizeInventory(), false))
|
||||
{
|
||||
return null;
|
||||
}
|
||||
|
||||
if (slotStack.stackSize == 0)
|
||||
{
|
||||
slot.putStack((ItemStack) null);
|
||||
}
|
||||
else
|
||||
{
|
||||
slot.onSlotChanged();
|
||||
}
|
||||
}
|
||||
|
||||
return stack;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected boolean mergeItemStack (ItemStack inputStack, int startSlot, int endSlot, boolean flag)
|
||||
{
|
||||
// TConstruct.logger.info("Merge");
|
||||
boolean merged = false;
|
||||
int slotPos = startSlot;
|
||||
|
||||
if (flag)
|
||||
{
|
||||
slotPos = endSlot - 1;
|
||||
}
|
||||
|
||||
Slot slot;
|
||||
ItemStack slotStack;
|
||||
|
||||
/*
|
||||
* if (inputStack.isStackable() && startSlot >=
|
||||
* logic.getSizeInventory()) { TConstruct.logger.info("Rawr!"); while
|
||||
* (inputStack.stackSize > 0 && (!flag && slotPos < endSlot || flag &&
|
||||
* slotPos >= startSlot)) { slot = (Slot)
|
||||
* this.inventorySlots.get(slotPos); slotStack = slot.getStack();
|
||||
*
|
||||
* if (slotStack != null && ItemStack.areItemStacksEqual(inputStack,
|
||||
* slotStack) && !inputStack.getHasSubtypes()) { int totalSize =
|
||||
* slotStack.stackSize + inputStack.stackSize;
|
||||
*
|
||||
* if (totalSize <= inputStack.getMaxStackSize()) { inputStack.stackSize
|
||||
* = 0; slotStack.stackSize = totalSize; slot.onSlotChanged(); merged =
|
||||
* true; } else if (slotStack.stackSize < inputStack.getMaxStackSize())
|
||||
* { inputStack.stackSize -= inputStack.getMaxStackSize() -
|
||||
* slotStack.stackSize; slotStack.stackSize =
|
||||
* inputStack.getMaxStackSize(); slot.onSlotChanged(); merged = true; }
|
||||
* }
|
||||
*
|
||||
* if (flag) { --slotPos; } else { ++slotPos; } } }
|
||||
*/
|
||||
|
||||
if (inputStack.isStackable() && startSlot >= logic.getSizeInventory())
|
||||
{
|
||||
while (inputStack.stackSize > 0 && (!flag && slotPos < endSlot || flag && slotPos >= startSlot))
|
||||
{
|
||||
slot = (Slot) this.inventorySlots.get(slotPos);
|
||||
slotStack = slot.getStack();
|
||||
|
||||
if (slotStack != null && ItemStack.areItemStacksEqual(slotStack, inputStack))
|
||||
{
|
||||
int l = slotStack.stackSize + inputStack.stackSize;
|
||||
|
||||
if (l <= inputStack.getMaxStackSize())
|
||||
{
|
||||
inputStack.stackSize = 0;
|
||||
slotStack.stackSize = l;
|
||||
slot.onSlotChanged();
|
||||
merged = true;
|
||||
}
|
||||
else if (slotStack.stackSize < inputStack.getMaxStackSize())
|
||||
{
|
||||
inputStack.stackSize -= inputStack.getMaxStackSize() - slotStack.stackSize;
|
||||
slotStack.stackSize = inputStack.getMaxStackSize();
|
||||
slot.onSlotChanged();
|
||||
merged = true;
|
||||
}
|
||||
}
|
||||
|
||||
if (flag)
|
||||
{
|
||||
--slotPos;
|
||||
}
|
||||
else
|
||||
{
|
||||
++slotPos;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (inputStack.stackSize > 0)
|
||||
{
|
||||
if (flag)
|
||||
{
|
||||
slotPos = endSlot - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
slotPos = startSlot;
|
||||
}
|
||||
|
||||
while (!flag && slotPos < endSlot || flag && slotPos >= startSlot)
|
||||
{
|
||||
slot = (Slot) this.inventorySlots.get(slotPos);
|
||||
slotStack = slot.getStack();
|
||||
|
||||
if (slotStack == null)
|
||||
{
|
||||
slot.putStack(inputStack.copy());
|
||||
slot.onSlotChanged();
|
||||
inputStack.stackSize -= 1;
|
||||
merged = true;
|
||||
break;
|
||||
}
|
||||
|
||||
if (flag)
|
||||
{
|
||||
--slotPos;
|
||||
}
|
||||
else
|
||||
{
|
||||
++slotPos;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return merged;
|
||||
}
|
||||
}
|
||||
@@ -1,328 +0,0 @@
|
||||
package tconstruct.smeltery.logic;
|
||||
|
||||
import mantle.blocks.abstracts.MultiServantLogic;
|
||||
import mantle.blocks.iface.IServantLogic;
|
||||
import mantle.world.CoordTuple;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.init.Blocks;
|
||||
import net.minecraft.tileentity.TileEntity;
|
||||
import net.minecraftforge.common.util.ForgeDirection;
|
||||
import net.minecraftforge.fluids.FluidStack;
|
||||
import net.minecraftforge.fluids.IFluidHandler;
|
||||
import tconstruct.library.crafting.Smeltery;
|
||||
import tconstruct.smeltery.TinkerSmeltery;
|
||||
|
||||
public class FlexibleSmelteryLogic extends SmelteryLogic {
|
||||
private static final int MAX_SMELTERY_SIZE = 5;
|
||||
|
||||
public CoordTuple minPos = new CoordTuple(0, 0, 0);
|
||||
public CoordTuple maxPos = new CoordTuple(0, 0, 0);
|
||||
|
||||
/* Multiblock */
|
||||
@Override
|
||||
public void notifyChange (IServantLogic servant, int x, int y, int z)
|
||||
{
|
||||
checkValidPlacement();
|
||||
}
|
||||
|
||||
public void checkValidPlacement ()
|
||||
{
|
||||
switch (getRenderDirection())
|
||||
{
|
||||
case 2: // +z
|
||||
alignInitialPlacement(xCoord, yCoord, zCoord + 1);
|
||||
break;
|
||||
case 3: // -z
|
||||
alignInitialPlacement(xCoord, yCoord, zCoord - 1);
|
||||
break;
|
||||
case 4: // +x
|
||||
alignInitialPlacement(xCoord + 1, yCoord, zCoord);
|
||||
break;
|
||||
case 5: // -x
|
||||
alignInitialPlacement(xCoord - 1, yCoord, zCoord);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// aligns the position given (inside the smeltery) to be the center of the smeltery
|
||||
public void alignInitialPlacement (int x, int y, int z)
|
||||
{
|
||||
// x/y/z = the block behind the controller "inside the smeltery"
|
||||
|
||||
// adjust the x-position of the block until the difference between the outer walls is at most 1
|
||||
// basically this means we center the block inside the smeltery on the x axis.
|
||||
int xd1 = 1, xd2 = 1; // x-difference
|
||||
for(int i = 1; i < MAX_SMELTERY_SIZE; i++) // don't check farther than needed
|
||||
{
|
||||
if(worldObj.getBlock(x - xd1, y, z) == null || worldObj.isAirBlock(x - xd1,y,z))
|
||||
xd1++;
|
||||
if(worldObj.getBlock(x + xd2, y, z) == null || worldObj.isAirBlock(x + xd2,y,z))
|
||||
xd2++;
|
||||
|
||||
// if one side hit a wall and the other didn't we might have to center our x-position again
|
||||
if(xd1-xd2 > 1)
|
||||
{
|
||||
// move x and offsets to the -x
|
||||
xd1--;
|
||||
x--;
|
||||
xd2++;
|
||||
}
|
||||
// or the right
|
||||
if(xd2-xd1 > 1)
|
||||
{
|
||||
xd2--;
|
||||
x++;
|
||||
xd1++;
|
||||
}
|
||||
}
|
||||
// same for z-axis
|
||||
int zd1 = 1, zd2 = 1;
|
||||
for(int i = 1; i < MAX_SMELTERY_SIZE; i++) // don't check farther than needed
|
||||
{
|
||||
if(worldObj.getBlock(x, y, z - zd1) == null || worldObj.isAirBlock(x, y, z - zd1))
|
||||
zd1++;
|
||||
if(worldObj.getBlock(x, y, z + zd2) == null || worldObj.isAirBlock(x, y, z + zd2))
|
||||
zd2++;
|
||||
|
||||
// if one side hit a wall and the other didn't we might have to center our x-position again
|
||||
if(zd1-zd2 > 1)
|
||||
{
|
||||
// move x and offsets to the -x
|
||||
zd1--;
|
||||
z--;
|
||||
zd2++;
|
||||
}
|
||||
// or the right
|
||||
if(zd2-zd1 > 1)
|
||||
{
|
||||
zd2--;
|
||||
z++;
|
||||
zd1++;
|
||||
}
|
||||
}
|
||||
|
||||
// do the check
|
||||
int[] sides = new int[] {xd1, xd2, zd1, zd2};
|
||||
checkValidStructure(x, y, z, sides);
|
||||
}
|
||||
|
||||
/**
|
||||
*
|
||||
* @param x x-center of the smeltery +-1
|
||||
* @param y y-position of the controller block
|
||||
* @param z z-center of the smeltery +-1
|
||||
* @param sides distance between the center point and the wall. [-x,+x,-z,+z]
|
||||
*/
|
||||
public void checkValidStructure (int x, int y, int z, int[] sides)
|
||||
{
|
||||
int checkLayers = 0;
|
||||
//worldObj.setBlock(x,y,z, Blocks.redstone_block);
|
||||
//worldObj.setBlock(x+sides[1]-sides[0],y+1,z+sides[3]-sides[2], Blocks.lapis_block);
|
||||
|
||||
tempValidStructure = false;
|
||||
// this piece of code here does the complete validity check.
|
||||
if (checkSameLevel(x, y, z, sides))
|
||||
{
|
||||
checkLayers++;
|
||||
checkLayers += recurseStructureUp(x, y + 1, z, sides, 0);
|
||||
checkLayers += recurseStructureDown(x, y - 1, z, sides, 0);
|
||||
}
|
||||
|
||||
// maxLiquid = capacity * 20000;
|
||||
|
||||
if (tempValidStructure != validStructure || checkLayers != this.layers)
|
||||
{
|
||||
if (tempValidStructure)
|
||||
{
|
||||
// try to derive temperature from fueltank
|
||||
activeLavaTank = null;
|
||||
for (CoordTuple tank : lavaTanks)
|
||||
{
|
||||
TileEntity tankContainer = worldObj.getTileEntity(tank.x, tank.y, tank.z);
|
||||
if (!(tankContainer instanceof IFluidHandler))
|
||||
continue;
|
||||
|
||||
FluidStack liquid = ((IFluidHandler) tankContainer).getTankInfo(ForgeDirection.DOWN)[0].fluid;
|
||||
if (liquid == null)
|
||||
continue;
|
||||
if (!Smeltery.isSmelteryFuel(liquid.getFluid()))
|
||||
continue;
|
||||
|
||||
internalTemp = Smeltery.getFuelPower(liquid.getFluid());
|
||||
activeLavaTank = tank;
|
||||
break;
|
||||
}
|
||||
|
||||
// no tank with fuel. we reserve the first found one
|
||||
if (activeLavaTank == null)
|
||||
activeLavaTank = lavaTanks.get(0);
|
||||
|
||||
// update other stuff
|
||||
adjustLayers(checkLayers, false);
|
||||
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
|
||||
validStructure = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
internalTemp = 20;
|
||||
validStructure = false;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public boolean checkBricksOnLevel(int x, int y, int z, int[] sides)
|
||||
{
|
||||
int numBricks = 0;
|
||||
Block block;
|
||||
int xMin = x - sides[0];
|
||||
int xMax = x + sides[1];
|
||||
int zMin = z - sides[2];
|
||||
int zMax = z + sides[3];
|
||||
|
||||
// Check inside
|
||||
for (int xPos = xMin + 1; xPos <= xMax - 1; xPos++)
|
||||
{
|
||||
for (int zPos = zMin + 1; zPos <= zMax - 1; zPos++)
|
||||
{
|
||||
block = worldObj.getBlock(xPos, y, zPos);
|
||||
if (block != null && !worldObj.isAirBlock(xPos, y, zPos))
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Check outer layer
|
||||
for (int xPos = xMin + 1; xPos <= xMax - 1; xPos++)
|
||||
{
|
||||
numBricks += checkBricks(xPos, y, zMin);
|
||||
numBricks += checkBricks(xPos, y, zMax);
|
||||
}
|
||||
|
||||
for (int zPos = zMin + 1; zPos <= zMax - 1; zPos++)
|
||||
{
|
||||
numBricks += checkBricks(xMin, y, zPos);
|
||||
numBricks += checkBricks(xMax, y, zPos);
|
||||
}
|
||||
|
||||
int neededBricks = (xMax-xMin)*2 + (zMax-zMin)*2 - 4; // -4 because corners are not needed
|
||||
|
||||
return numBricks == neededBricks;
|
||||
}
|
||||
|
||||
public boolean checkSameLevel(int x, int y, int z, int[] sides)
|
||||
{
|
||||
lavaTanks.clear();
|
||||
|
||||
boolean check = checkBricksOnLevel(x,y,z,sides);
|
||||
|
||||
if (check && lavaTanks.size() > 0)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
public int recurseStructureUp (int x, int y, int z, int[] sides, int count)
|
||||
{
|
||||
boolean check = checkBricksOnLevel(x,y,z,sides);
|
||||
|
||||
if(!check)
|
||||
return count;
|
||||
|
||||
count++;
|
||||
return recurseStructureUp(x, y + 1, z, sides, count);
|
||||
}
|
||||
|
||||
public int recurseStructureDown (int x, int y, int z, int[] sides, int count)
|
||||
{
|
||||
boolean check = checkBricksOnLevel(x,y,z,sides);
|
||||
|
||||
if(!check) {
|
||||
// regular check failed, maybe it's the bottom?
|
||||
Block block = worldObj.getBlock(x,y,z);
|
||||
if (block != null && !worldObj.isAirBlock(x, y, z))
|
||||
if (validBlockID(block))
|
||||
return validateBottom(x, y, z, sides, count);
|
||||
|
||||
return count;
|
||||
}
|
||||
|
||||
count++;
|
||||
return recurseStructureDown(x, y - 1, z, sides, count);
|
||||
}
|
||||
|
||||
public int validateBottom (int x, int y, int z, int[] sides, int count)
|
||||
{
|
||||
int bottomBricks = 0;
|
||||
int xMin = x - sides[0] + 1;
|
||||
int xMax = x + sides[1] - 1;
|
||||
int zMin = z - sides[2] + 1;
|
||||
int zMax = z + sides[3] - 1;
|
||||
|
||||
// Check inside
|
||||
for (int xPos = xMin; xPos <= xMax; xPos++)
|
||||
{
|
||||
for (int zPos = zMin; zPos <= zMax; zPos++)
|
||||
{
|
||||
if (validBlockID(worldObj.getBlock(xPos, y, zPos)) && (worldObj.getBlockMetadata(xPos, y, zPos) >= 2))
|
||||
bottomBricks++;
|
||||
}
|
||||
}
|
||||
|
||||
int neededBricks = (xMax+1-xMin) * (zMax+1-zMin); // +1 because we want inclusive the upper border
|
||||
|
||||
if (bottomBricks == neededBricks)
|
||||
{
|
||||
tempValidStructure = true;
|
||||
minPos = new CoordTuple(xMin, y+1, zMin);
|
||||
maxPos = new CoordTuple(xMax, y+1, zMax);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
||||
/*
|
||||
* Returns whether the brick is a lava tank or not. Increments bricks, sets
|
||||
* them as part of the structure, and adds tanks to the list.
|
||||
*/
|
||||
int checkBricks (int x, int y, int z)
|
||||
{
|
||||
int tempBricks = 0;
|
||||
Block blockID = worldObj.getBlock(x, y, z);
|
||||
if (validBlockID(blockID) || validTankID(blockID))
|
||||
{
|
||||
TileEntity te = worldObj.getTileEntity(x, y, z);
|
||||
if (te == this)
|
||||
{
|
||||
tempBricks++;
|
||||
}
|
||||
else if (te instanceof MultiServantLogic)
|
||||
{
|
||||
MultiServantLogic servant = (MultiServantLogic) te;
|
||||
if (servant.hasValidMaster())
|
||||
{
|
||||
if (servant.verifyMaster(this, worldObj, this.xCoord, this.yCoord, this.zCoord))
|
||||
tempBricks++;
|
||||
}
|
||||
else
|
||||
{
|
||||
servant.overrideMaster(this.xCoord, this.yCoord, this.zCoord);
|
||||
tempBricks++;
|
||||
}
|
||||
|
||||
if (te instanceof LavaTankLogic)
|
||||
{
|
||||
lavaTanks.add(new CoordTuple(x, y, z));
|
||||
}
|
||||
}
|
||||
}
|
||||
return tempBricks;
|
||||
}
|
||||
|
||||
boolean validBlockID (Block blockID)
|
||||
{
|
||||
return blockID == TinkerSmeltery.smeltery || blockID == TinkerSmeltery.smelteryNether;
|
||||
}
|
||||
|
||||
boolean validTankID (Block blockID)
|
||||
{
|
||||
return blockID == TinkerSmeltery.lavaTank || blockID == TinkerSmeltery.lavaTankNether;
|
||||
}
|
||||
}
|
||||
@@ -32,30 +32,33 @@ import tconstruct.util.config.PHConstruct;
|
||||
|
||||
public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFacingLogic, IFluidTank, IMasterLogic
|
||||
{
|
||||
private static final int MAX_SMELTERY_SIZE = 5;
|
||||
|
||||
public boolean validStructure;
|
||||
public boolean tempValidStructure;
|
||||
byte direction;
|
||||
int internalTemp;
|
||||
protected byte direction;
|
||||
|
||||
public CoordTuple minPos = new CoordTuple(0, 0, 0);
|
||||
public CoordTuple maxPos = new CoordTuple(0, 0, 0);
|
||||
public int layers;
|
||||
public int maxBlockCapacity;
|
||||
|
||||
protected int internalTemp;
|
||||
public int useTime;
|
||||
public int fuelGague;
|
||||
public int fuelAmount;
|
||||
boolean inUse;
|
||||
protected boolean inUse;
|
||||
|
||||
ArrayList<CoordTuple> lavaTanks;
|
||||
CoordTuple activeLavaTank;
|
||||
public CoordTuple centerPos = new CoordTuple(0, 0, 0);
|
||||
protected ArrayList<CoordTuple> lavaTanks;
|
||||
protected CoordTuple activeLavaTank;
|
||||
|
||||
public int[] activeTemps; // values are multiplied by 10
|
||||
public int[] meltingTemps; // values are multiplied by 10
|
||||
int tick;
|
||||
private int tick;
|
||||
|
||||
public ArrayList<FluidStack> moltenMetal = new ArrayList<FluidStack>();
|
||||
int maxLiquid;
|
||||
int currentLiquid;
|
||||
public int layers;
|
||||
int slag;
|
||||
|
||||
int numBricks;
|
||||
public int maxLiquid;
|
||||
public int currentLiquid;
|
||||
|
||||
Random rand = new Random();
|
||||
boolean needsUpdate;
|
||||
@@ -68,25 +71,39 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
meltingTemps = new int[0];
|
||||
}
|
||||
|
||||
public int getBlocksPerLayer()
|
||||
{
|
||||
int xd = maxPos.x - minPos.x + 1;
|
||||
int zd = maxPos.z - minPos.z + 1;
|
||||
return xd * zd;
|
||||
}
|
||||
|
||||
public int getBlockCapacity()
|
||||
{
|
||||
return maxBlockCapacity;
|
||||
}
|
||||
|
||||
void adjustLayers (int lay, boolean forceAdjust)
|
||||
{
|
||||
if (lay != layers || forceAdjust)
|
||||
{
|
||||
needsUpdate = true;
|
||||
layers = lay;
|
||||
maxBlockCapacity = getBlocksPerLayer() * layers;
|
||||
|
||||
maxLiquid = 20000 * lay;
|
||||
int[] tempActive = activeTemps;
|
||||
activeTemps = new int[9 * lay];
|
||||
activeTemps = new int[maxBlockCapacity];
|
||||
int activeLength = tempActive.length > activeTemps.length ? activeTemps.length : tempActive.length;
|
||||
System.arraycopy(tempActive, 0, activeTemps, 0, activeLength);
|
||||
|
||||
int[] tempMelting = meltingTemps;
|
||||
meltingTemps = new int[9 * lay];
|
||||
meltingTemps = new int[maxBlockCapacity];
|
||||
int meltingLength = tempMelting.length > meltingTemps.length ? meltingTemps.length : tempMelting.length;
|
||||
System.arraycopy(tempMelting, 0, meltingTemps, 0, meltingLength);
|
||||
|
||||
ItemStack[] tempInv = inventory;
|
||||
inventory = new ItemStack[9 * lay];
|
||||
inventory = new ItemStack[maxBlockCapacity];
|
||||
int invLength = tempInv.length > inventory.length ? inventory.length : tempInv.length;
|
||||
System.arraycopy(tempInv, 0, inventory, 0, invLength);
|
||||
|
||||
@@ -291,6 +308,8 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
|
||||
void detectEntities ()
|
||||
{
|
||||
// todo: fix this with min-max pos instead of center pos
|
||||
/*
|
||||
if (centerPos == null)
|
||||
return;
|
||||
|
||||
@@ -364,6 +383,7 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
handleItemEntity((EntityItem) o);
|
||||
}
|
||||
}
|
||||
*/
|
||||
}
|
||||
|
||||
private void handleItemEntity (EntityItem item)
|
||||
@@ -418,7 +438,7 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
int temperature = this.getInternalTemperature();
|
||||
int speed = temperature / 100;
|
||||
int refTemp = temperature * 10;
|
||||
for (int i = 0; i < 9 * layers; i++)
|
||||
for (int i = 0; i < maxBlockCapacity; i++)
|
||||
{
|
||||
if (meltingTemps[i] > 200 && this.isStackInSlot(i))
|
||||
{
|
||||
@@ -506,7 +526,7 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
private void updateTemperatures ()
|
||||
{
|
||||
inUse = true;
|
||||
for (int i = 0; i < 9 * layers; i++)
|
||||
for (int i = 0; i < maxBlockCapacity; i++)
|
||||
{
|
||||
meltingTemps[i] = Smeltery.getLiquifyTemperature(inventory[i]) * 10; // temperatures are *10 for more progress control
|
||||
}
|
||||
@@ -707,65 +727,103 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
{
|
||||
switch (getRenderDirection())
|
||||
{
|
||||
case 2: // +z
|
||||
alignInitialPlacement(xCoord, yCoord, zCoord + 2);
|
||||
break;
|
||||
case 3: // -z
|
||||
alignInitialPlacement(xCoord, yCoord, zCoord - 2);
|
||||
break;
|
||||
case 4: // +x
|
||||
alignInitialPlacement(xCoord + 2, yCoord, zCoord);
|
||||
break;
|
||||
case 5: // -x
|
||||
alignInitialPlacement(xCoord - 2, yCoord, zCoord);
|
||||
break;
|
||||
case 2: // +z
|
||||
alignInitialPlacement(xCoord, yCoord, zCoord + 1);
|
||||
break;
|
||||
case 3: // -z
|
||||
alignInitialPlacement(xCoord, yCoord, zCoord - 1);
|
||||
break;
|
||||
case 4: // +x
|
||||
alignInitialPlacement(xCoord + 1, yCoord, zCoord);
|
||||
break;
|
||||
case 5: // -x
|
||||
alignInitialPlacement(xCoord - 1, yCoord, zCoord);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// aligns the position given (inside the smeltery) to be the center of the smeltery
|
||||
public void alignInitialPlacement (int x, int y, int z)
|
||||
{
|
||||
Block northBlock = worldObj.getBlock(x, y, z + 1);
|
||||
Block southBlock = worldObj.getBlock(x, y, z - 1);
|
||||
Block eastBlock = worldObj.getBlock(x + 1, y, z);
|
||||
Block westBlock = worldObj.getBlock(x - 1, y, z);
|
||||
// x/y/z = the block behind the controller "inside the smeltery"
|
||||
|
||||
if ((northBlock == null || worldObj.isAirBlock(x, y, z + 1)) && (southBlock == null || worldObj.isAirBlock(x, y, z - 1)) && (eastBlock == null || worldObj.isAirBlock(x + 1, y, z)) && (westBlock == null || worldObj.isAirBlock(x - 1, y, z)))
|
||||
// adjust the x-position of the block until the difference between the outer walls is at most 1
|
||||
// basically this means we center the block inside the smeltery on the x axis.
|
||||
int xd1 = 1, xd2 = 1; // x-difference
|
||||
for(int i = 1; i < MAX_SMELTERY_SIZE; i++) // don't check farther than needed
|
||||
{
|
||||
checkValidStructure(x, y, z);
|
||||
if(worldObj.getBlock(x - xd1, y, z) == null || worldObj.isAirBlock(x - xd1,y,z))
|
||||
xd1++;
|
||||
if(worldObj.getBlock(x + xd2, y, z) == null || worldObj.isAirBlock(x + xd2,y,z))
|
||||
xd2++;
|
||||
|
||||
// if one side hit a wall and the other didn't we might have to center our x-position again
|
||||
if(xd1-xd2 > 1)
|
||||
{
|
||||
// move x and offsets to the -x
|
||||
xd1--;
|
||||
x--;
|
||||
xd2++;
|
||||
}
|
||||
// or the right
|
||||
if(xd2-xd1 > 1)
|
||||
{
|
||||
xd2--;
|
||||
x++;
|
||||
xd1++;
|
||||
}
|
||||
}
|
||||
// same for z-axis
|
||||
int zd1 = 1, zd2 = 1;
|
||||
for(int i = 1; i < MAX_SMELTERY_SIZE; i++) // don't check farther than needed
|
||||
{
|
||||
if(worldObj.getBlock(x, y, z - zd1) == null || worldObj.isAirBlock(x, y, z - zd1))
|
||||
zd1++;
|
||||
if(worldObj.getBlock(x, y, z + zd2) == null || worldObj.isAirBlock(x, y, z + zd2))
|
||||
zd2++;
|
||||
|
||||
// if one side hit a wall and the other didn't we might have to center our x-position again
|
||||
if(zd1-zd2 > 1)
|
||||
{
|
||||
// move x and offsets to the -x
|
||||
zd1--;
|
||||
z--;
|
||||
zd2++;
|
||||
}
|
||||
// or the right
|
||||
if(zd2-zd1 > 1)
|
||||
{
|
||||
zd2--;
|
||||
z++;
|
||||
zd1++;
|
||||
}
|
||||
}
|
||||
|
||||
else if ((northBlock != null && !worldObj.isAirBlock(x, y, z + 1)) && (southBlock == null || worldObj.isAirBlock(x, y, z - 1)) && (eastBlock == null || worldObj.isAirBlock(x + 1, y, z)) && (westBlock == null || worldObj.isAirBlock(x - 1, y, z)))
|
||||
{
|
||||
checkValidStructure(x, y, z - 1);
|
||||
}
|
||||
|
||||
else if ((northBlock == null || worldObj.isAirBlock(x, y, z + 1)) && (southBlock != null && !worldObj.isAirBlock(x, y, z - 1)) && (eastBlock == null || worldObj.isAirBlock(x + 1, y, z)) && (westBlock == null || worldObj.isAirBlock(x - 1, y, z)))
|
||||
{
|
||||
checkValidStructure(x, y, z + 1);
|
||||
}
|
||||
|
||||
else if ((northBlock == null || worldObj.isAirBlock(x, y, z + 1)) && (southBlock == null || worldObj.isAirBlock(x, y, z - 1)) && (eastBlock != null && !worldObj.isAirBlock(x + 1, y, z)) && (westBlock == null || worldObj.isAirBlock(x - 1, y, z)))
|
||||
{
|
||||
checkValidStructure(x - 1, y, z);
|
||||
}
|
||||
|
||||
else if ((northBlock == null || worldObj.isAirBlock(x, y, z + 1)) && (southBlock == null || worldObj.isAirBlock(x, y, z - 1)) && (eastBlock == null || worldObj.isAirBlock(x + 1, y, z)) && (westBlock != null && !worldObj.isAirBlock(x - 1, y, z)))
|
||||
{
|
||||
checkValidStructure(x + 1, y, z);
|
||||
}
|
||||
|
||||
// Not valid, sorry
|
||||
// do the check
|
||||
int[] sides = new int[] {xd1, xd2, zd1, zd2};
|
||||
checkValidStructure(x, y, z, sides);
|
||||
}
|
||||
|
||||
public void checkValidStructure (int x, int y, int z)
|
||||
/**
|
||||
*
|
||||
* @param x x-center of the smeltery +-1
|
||||
* @param y y-position of the controller block
|
||||
* @param z z-center of the smeltery +-1
|
||||
* @param sides distance between the center point and the wall. [-x,+x,-z,+z]
|
||||
*/
|
||||
public void checkValidStructure (int x, int y, int z, int[] sides)
|
||||
{
|
||||
int checkLayers = 0;
|
||||
//worldObj.setBlock(x,y,z, Blocks.redstone_block);
|
||||
//worldObj.setBlock(x+sides[1]-sides[0],y+1,z+sides[3]-sides[2], Blocks.lapis_block);
|
||||
|
||||
tempValidStructure = false;
|
||||
if (checkSameLevel(x, y, z))
|
||||
// this piece of code here does the complete validity check.
|
||||
if (checkSameLevel(x, y, z, sides))
|
||||
{
|
||||
checkLayers++;
|
||||
checkLayers += recurseStructureUp(x, y + 1, z, 0);
|
||||
checkLayers += recurseStructureDown(x, y - 1, z, 0);
|
||||
checkLayers += recurseStructureUp(x, y + 1, z, sides, 0);
|
||||
checkLayers += recurseStructureDown(x, y - 1, z, sides, 0);
|
||||
}
|
||||
|
||||
// maxLiquid = capacity * 20000;
|
||||
@@ -810,16 +868,19 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
}
|
||||
}
|
||||
|
||||
public boolean checkSameLevel (int x, int y, int z)
|
||||
public boolean checkBricksOnLevel(int x, int y, int z, int[] sides)
|
||||
{
|
||||
numBricks = 0;
|
||||
lavaTanks.clear();
|
||||
int numBricks = 0;
|
||||
Block block;
|
||||
int xMin = x - sides[0];
|
||||
int xMax = x + sides[1];
|
||||
int zMin = z - sides[2];
|
||||
int zMax = z + sides[3];
|
||||
|
||||
// Check inside
|
||||
for (int xPos = x - 1; xPos <= x + 1; xPos++)
|
||||
for (int xPos = xMin + 1; xPos <= xMax - 1; xPos++)
|
||||
{
|
||||
for (int zPos = z - 1; zPos <= z + 1; zPos++)
|
||||
for (int zPos = zMin + 1; zPos <= zMax - 1; zPos++)
|
||||
{
|
||||
block = worldObj.getBlock(xPos, y, zPos);
|
||||
if (block != null && !worldObj.isAirBlock(xPos, y, zPos))
|
||||
@@ -828,113 +889,89 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
}
|
||||
|
||||
// Check outer layer
|
||||
for (int xPos = x - 1; xPos <= x + 1; xPos++)
|
||||
for (int xPos = xMin + 1; xPos <= xMax - 1; xPos++)
|
||||
{
|
||||
numBricks += checkBricks(xPos, y, z - 2);
|
||||
numBricks += checkBricks(xPos, y, z + 2);
|
||||
numBricks += checkBricks(xPos, y, zMin);
|
||||
numBricks += checkBricks(xPos, y, zMax);
|
||||
}
|
||||
|
||||
for (int zPos = z - 1; zPos <= z + 1; zPos++)
|
||||
for (int zPos = zMin + 1; zPos <= zMax - 1; zPos++)
|
||||
{
|
||||
numBricks += checkBricks(x - 2, y, zPos);
|
||||
numBricks += checkBricks(x + 2, y, zPos);
|
||||
numBricks += checkBricks(xMin, y, zPos);
|
||||
numBricks += checkBricks(xMax, y, zPos);
|
||||
}
|
||||
|
||||
if (numBricks == 12 && lavaTanks.size() > 0)
|
||||
int neededBricks = (xMax-xMin)*2 + (zMax-zMin)*2 - 4; // -4 because corners are not needed
|
||||
|
||||
return numBricks == neededBricks;
|
||||
}
|
||||
|
||||
public boolean checkSameLevel(int x, int y, int z, int[] sides)
|
||||
{
|
||||
lavaTanks.clear();
|
||||
|
||||
boolean check = checkBricksOnLevel(x,y,z,sides);
|
||||
|
||||
if (check && lavaTanks.size() > 0)
|
||||
return true;
|
||||
else
|
||||
return false;
|
||||
}
|
||||
|
||||
public int recurseStructureUp (int x, int y, int z, int count)
|
||||
public int recurseStructureUp (int x, int y, int z, int[] sides, int count)
|
||||
{
|
||||
numBricks = 0;
|
||||
// Check inside
|
||||
for (int xPos = x - 1; xPos <= x + 1; xPos++)
|
||||
{
|
||||
for (int zPos = z - 1; zPos <= z + 1; zPos++)
|
||||
{
|
||||
Block block = worldObj.getBlock(xPos, y, zPos);
|
||||
if (block != null && !worldObj.isAirBlock(xPos, y, zPos))
|
||||
return count;
|
||||
}
|
||||
}
|
||||
boolean check = checkBricksOnLevel(x,y,z,sides);
|
||||
|
||||
// Check outer layer
|
||||
for (int xPos = x - 1; xPos <= x + 1; xPos++)
|
||||
{
|
||||
numBricks += checkBricks(xPos, y, z - 2);
|
||||
numBricks += checkBricks(xPos, y, z + 2);
|
||||
}
|
||||
|
||||
for (int zPos = z - 1; zPos <= z + 1; zPos++)
|
||||
{
|
||||
numBricks += checkBricks(x - 2, y, zPos);
|
||||
numBricks += checkBricks(x + 2, y, zPos);
|
||||
}
|
||||
|
||||
if (numBricks != 12)
|
||||
if(!check)
|
||||
return count;
|
||||
|
||||
count++;
|
||||
return recurseStructureUp(x, y + 1, z, count);
|
||||
return recurseStructureUp(x, y + 1, z, sides, count);
|
||||
}
|
||||
|
||||
public int recurseStructureDown (int x, int y, int z, int count)
|
||||
public int recurseStructureDown (int x, int y, int z, int[] sides, int count)
|
||||
{
|
||||
numBricks = 0;
|
||||
// Check inside
|
||||
for (int xPos = x - 1; xPos <= x + 1; xPos++)
|
||||
{
|
||||
for (int zPos = z - 1; zPos <= z + 1; zPos++)
|
||||
{
|
||||
Block blockID = worldObj.getBlock(xPos, y, zPos);
|
||||
if (blockID != null && !worldObj.isAirBlock(xPos, y, zPos))
|
||||
{
|
||||
if (validBlockID(blockID))
|
||||
return validateBottom(x, y, z, count);
|
||||
else
|
||||
return count;
|
||||
}
|
||||
}
|
||||
}
|
||||
boolean check = checkBricksOnLevel(x,y,z,sides);
|
||||
|
||||
// Check outer layer
|
||||
for (int xPos = x - 1; xPos <= x + 1; xPos++)
|
||||
{
|
||||
numBricks += checkBricks(xPos, y, z - 2);
|
||||
numBricks += checkBricks(xPos, y, z + 2);
|
||||
}
|
||||
if(!check) {
|
||||
// regular check failed, maybe it's the bottom?
|
||||
Block block = worldObj.getBlock(x,y,z);
|
||||
if (block != null && !worldObj.isAirBlock(x, y, z))
|
||||
if (validBlockID(block))
|
||||
return validateBottom(x, y, z, sides, count);
|
||||
|
||||
for (int zPos = z - 1; zPos <= z + 1; zPos++)
|
||||
{
|
||||
numBricks += checkBricks(x - 2, y, zPos);
|
||||
numBricks += checkBricks(x + 2, y, zPos);
|
||||
}
|
||||
|
||||
if (numBricks != 12)
|
||||
return count;
|
||||
}
|
||||
|
||||
count++;
|
||||
return recurseStructureDown(x, y - 1, z, count);
|
||||
return recurseStructureDown(x, y - 1, z, sides, count);
|
||||
}
|
||||
|
||||
public int validateBottom (int x, int y, int z, int count)
|
||||
public int validateBottom (int x, int y, int z, int[] sides, int count)
|
||||
{
|
||||
int bottomBricks = 0;
|
||||
for (int xPos = x - 1; xPos <= x + 1; xPos++)
|
||||
int xMin = x - sides[0] + 1;
|
||||
int xMax = x + sides[1] - 1;
|
||||
int zMin = z - sides[2] + 1;
|
||||
int zMax = z + sides[3] - 1;
|
||||
|
||||
// Check inside
|
||||
for (int xPos = xMin; xPos <= xMax; xPos++)
|
||||
{
|
||||
for (int zPos = z - 1; zPos <= z + 1; zPos++)
|
||||
for (int zPos = zMin; zPos <= zMax; zPos++)
|
||||
{
|
||||
if (validBlockID(worldObj.getBlock(xPos, y, zPos)) && (worldObj.getBlockMetadata(xPos, y, zPos) >= 2))
|
||||
bottomBricks++;
|
||||
}
|
||||
}
|
||||
|
||||
if (bottomBricks == 9)
|
||||
int neededBricks = (xMax+1-xMin) * (zMax+1-zMin); // +1 because we want inclusive the upper border
|
||||
|
||||
if (bottomBricks == neededBricks)
|
||||
{
|
||||
tempValidStructure = true;
|
||||
centerPos = new CoordTuple(x, y + 1, z);
|
||||
minPos = new CoordTuple(xMin, y+1, zMin);
|
||||
maxPos = new CoordTuple(xMax, y+1, zMax);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
@@ -959,11 +996,12 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
MultiServantLogic servant = (MultiServantLogic) te;
|
||||
if (servant.hasValidMaster())
|
||||
{
|
||||
if (servant.verifyMaster(this, this.xCoord, this.yCoord, this.zCoord))
|
||||
if (servant.verifyMaster(this, worldObj, this.xCoord, this.yCoord, this.zCoord))
|
||||
tempBricks++;
|
||||
}
|
||||
else if (servant.setMaster(this.xCoord, this.yCoord, this.zCoord))
|
||||
else
|
||||
{
|
||||
servant.overrideMaster(this.xCoord, this.yCoord, this.zCoord);
|
||||
tempBricks++;
|
||||
}
|
||||
|
||||
@@ -986,6 +1024,8 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
return blockID == TinkerSmeltery.lavaTank || blockID == TinkerSmeltery.lavaTankNether;
|
||||
}
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
public int getCapacity ()
|
||||
{
|
||||
@@ -1106,19 +1146,26 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
public void readFromNBT (NBTTagCompound tags)
|
||||
{
|
||||
layers = tags.getInteger("Layers");
|
||||
inventory = new ItemStack[layers * 9];
|
||||
int[] pos = tags.getIntArray("MinPos");
|
||||
if (pos.length > 2)
|
||||
minPos = new CoordTuple(pos[0], pos[1], pos[2]);
|
||||
else
|
||||
minPos = new CoordTuple(xCoord, yCoord, zCoord);
|
||||
|
||||
pos = tags.getIntArray("MaxPos");
|
||||
if (pos.length > 2)
|
||||
maxPos = new CoordTuple(pos[0], pos[1], pos[2]);
|
||||
else
|
||||
maxPos = new CoordTuple(xCoord, yCoord, zCoord);
|
||||
|
||||
maxBlockCapacity = getBlocksPerLayer() * layers;
|
||||
inventory = new ItemStack[maxBlockCapacity];
|
||||
super.readFromNBT(tags);
|
||||
|
||||
// validStructure = tags.getBoolean("ValidStructure");
|
||||
internalTemp = tags.getInteger("InternalTemp");
|
||||
inUse = tags.getBoolean("InUse");
|
||||
|
||||
int[] center = tags.getIntArray("CenterPos");
|
||||
if (center.length > 2)
|
||||
centerPos = new CoordTuple(center[0], center[1], center[2]);
|
||||
else
|
||||
centerPos = new CoordTuple(xCoord, yCoord, zCoord);
|
||||
|
||||
direction = tags.getByte("Direction");
|
||||
useTime = tags.getInteger("UseTime");
|
||||
currentLiquid = tags.getInteger("CurrentLiquid");
|
||||
@@ -1149,12 +1196,18 @@ public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFaci
|
||||
tags.setInteger("InternalTemp", internalTemp);
|
||||
tags.setBoolean("InUse", inUse);
|
||||
|
||||
int[] center = new int[3];// { centerPos.x, centerPos.y, centerPos.z };
|
||||
if (centerPos == null)
|
||||
center = new int[] { xCoord, yCoord, zCoord };
|
||||
int[] pos;
|
||||
if (minPos == null)
|
||||
pos = new int[] { xCoord, yCoord, zCoord };
|
||||
else
|
||||
center = new int[] { centerPos.x, centerPos.y, centerPos.z };
|
||||
tags.setIntArray("CenterPos", center);
|
||||
pos = new int[] { minPos.x, minPos.y, minPos.z };
|
||||
tags.setIntArray("MinPos", pos);
|
||||
|
||||
if (maxPos == null)
|
||||
pos = new int[] { xCoord, yCoord, zCoord };
|
||||
else
|
||||
pos = new int[] { maxPos.x, maxPos.y, maxPos.z };
|
||||
tags.setIntArray("MaxPos", pos);
|
||||
|
||||
tags.setByte("Direction", direction);
|
||||
tags.setInteger("UseTime", useTime);
|
||||
|
||||
File diff suppressed because it is too large.
Load diff
@@ -44,7 +44,8 @@ public class SmelteryRender implements ISimpleBlockRenderingHandler
|
||||
SmelteryLogic logic = (SmelteryLogic) world.getTileEntity(x, y, z);
|
||||
if (logic.validStructure)
|
||||
{
|
||||
int posX = logic.centerPos.x - 1, posY = logic.centerPos.y, posZ = logic.centerPos.z - 1;
|
||||
//int posX = logic.centerPos.x - 1, posY = logic.centerPos.y, posZ = logic.centerPos.z - 1;
|
||||
int posX = logic.minPos.x, posY = logic.minPos.y, posZ = logic.minPos.z; // todo: proper rendering
|
||||
//Melting
|
||||
if (logic.getSizeInventory() > 0)
|
||||
{
|
||||
|
||||
@@ -350,7 +350,7 @@ public class PHConstruct
|
||||
// Experimental functionality
|
||||
public static boolean throwableSmeltery;
|
||||
public static boolean newSmeltery;
|
||||
public static boolean newerSmeltery = true;
|
||||
public static boolean oldSmeltery;
|
||||
public static boolean meltableHorses;
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user