980 lines
34 KiB
Java
Executable file
980 lines
34 KiB
Java
Executable file
package game.gui;
|
|
|
|
import java.util.List;
|
|
import java.util.Set;
|
|
|
|
import game.collect.Lists;
|
|
import game.collect.Sets;
|
|
import game.color.TextColor;
|
|
import game.gui.element.InventoryButton;
|
|
import game.inventory.Container;
|
|
import game.inventory.InventoryPlayer;
|
|
import game.inventory.Slot;
|
|
import game.item.ItemStack;
|
|
import game.renderer.Drawing;
|
|
import game.renderer.GlState;
|
|
import game.renderer.ItemRenderer;
|
|
import game.renderer.Drawing.Vec2i;
|
|
import game.renderer.entity.RenderItem;
|
|
import game.util.ExtMath;
|
|
import game.window.Button;
|
|
import game.window.WCF;
|
|
|
|
public abstract class GuiContainer extends Gui
|
|
{
|
|
private class Overlay {
|
|
private final ItemStack stack;
|
|
private final int x;
|
|
private final int y;
|
|
private final String alt;
|
|
|
|
private Overlay(ItemStack stack, int x, int y, String alt) {
|
|
this.stack = stack;
|
|
this.x = x;
|
|
this.y = y;
|
|
this.alt = alt;
|
|
}
|
|
}
|
|
// /** The location of the inventory background texture */
|
|
// protected static final String inventoryBackground = "textures/gui/inventory.png";
|
|
|
|
protected RenderItem itemRender;
|
|
// public int width;
|
|
// public int height;
|
|
|
|
/** The X size of the inventory window in pixels. */
|
|
protected int xSize = 176;
|
|
|
|
/** The Y size of the inventory window in pixels. */
|
|
protected int ySize = 166;
|
|
|
|
/** A list of the players inventory slots */
|
|
public Container inventorySlots;
|
|
|
|
// /**
|
|
// * Starting X position for the Gui. Inconsistent use for Gui backgrounds.
|
|
// */
|
|
// protected int guiLeft;
|
|
//
|
|
// /**
|
|
// * Starting Y position for the Gui. Inconsistent use for Gui backgrounds.
|
|
// */
|
|
// protected int guiTop;
|
|
|
|
/** holds the slot currently hovered */
|
|
private Slot theSlot;
|
|
|
|
/** Used when touchscreen is enabled. */
|
|
private Slot clickedSlot;
|
|
|
|
/** Used when touchscreen is enabled. */
|
|
private boolean isRightMouseClick;
|
|
|
|
/** Used when touchscreen is enabled */
|
|
private ItemStack draggedStack;
|
|
private int touchUpX;
|
|
private int touchUpY;
|
|
private Slot returningStackDestSlot;
|
|
private long returningStackTime;
|
|
|
|
/** Used when touchscreen is enabled */
|
|
private ItemStack returningStack;
|
|
private Slot currentDragTargetSlot;
|
|
private long dragItemDropDelay;
|
|
protected final Set<Slot> dragSplittingSlots = Sets.<Slot>newHashSet();
|
|
protected final List<Overlay> drawnOverlays = Lists.<Overlay>newArrayList();
|
|
protected boolean dragSplitting;
|
|
private int dragSplittingLimit;
|
|
private int dragSplittingButton;
|
|
private boolean ignoreMouseUp;
|
|
private int dragSplittingRemnant;
|
|
private long lastClickTime;
|
|
private Slot lastClickSlot;
|
|
private int lastClickButton;
|
|
private boolean doubleClick;
|
|
private ItemStack shiftClickedSlot;
|
|
|
|
private int container_x;
|
|
private int container_y;
|
|
private int container_w;
|
|
private int container_h;
|
|
|
|
private int hover_x;
|
|
private int hover_y;
|
|
private String tooltip;
|
|
|
|
public void drawString(String text, int x, int y) {
|
|
x = x * 2 + this.container_x;
|
|
y = y * 2 + this.container_y;
|
|
Drawing.txt_draw(x, y, x, y, x + 440, y + 260, 0xffffffff, text);
|
|
}
|
|
|
|
public int getStringWidth(String text) {
|
|
Vec2i size = Drawing.txt_size(0, 0, 0, 0, 65536, 65536, text);
|
|
return size.xpos / 2;
|
|
}
|
|
|
|
public void rect(int x, int y, int width, int height, int color) {
|
|
Drawing.drawRectColor(this.container_x + x * 2, this.container_y + y * 2, width * 2, height * 2, 0xff000000 | color);
|
|
}
|
|
|
|
public InventoryButton button(int x, int y, int w, int h) {
|
|
return this.add(new InventoryButton(this.container_x + x * 2, this.container_y + y * 2, w * 2, h * 2));
|
|
}
|
|
|
|
// public void uidims(int w, int h) {
|
|
// }
|
|
|
|
public void mouse(Button btn, int x, int y, boolean ctrl, boolean shift) {
|
|
super.mouse(btn, x, y, ctrl, shift);
|
|
// public void click(Button btn, int x, int y) {
|
|
// if(this.openGui != null) {
|
|
// int x = SKC.getMouseX() * this.openGui.width / this.gm.fb_x;
|
|
// int y = this.openGui.height - SKC.getMouseY() * this.openGui.height / this.gm.fb_y - 1;
|
|
this.mouseClicked((x - this.container_x) / 2, (y - this.container_y) / 2, btn.ordinal()); //TODO: enum
|
|
// }
|
|
}
|
|
|
|
public void mouserel(Button btn, int x, int y) {
|
|
super.mouserel(btn, x, y);
|
|
// if(this.openGui != null) {
|
|
// int x = SKC.getMouseX() * this.openGui.width / this.gm.fb_x;
|
|
// int y = this.openGui.height - SKC.getMouseY() * this.openGui.height / this.gm.fb_y - 1;
|
|
this.mouseReleased((x - this.container_x) / 2, (y - this.container_y) / 2, btn.ordinal()); //TODO: enum
|
|
// }
|
|
}
|
|
|
|
public void drag(int x, int y) {
|
|
super.drag(x, y);
|
|
// if(this.openGui != null) {
|
|
// int x = SKC.getMouseX() * this.openGui.width / this.gm.fb_x;
|
|
// int y = this.openGui.height - SKC.getMouseY() * this.openGui.height / this.gm.fb_y - 1;
|
|
if(Button.MOUSE_LEFT.isDown() || Button.MOUSE_RIGHT.isDown() || Button.MOUSE_MIDDLE.isDown())
|
|
this.mouseDragged((x - this.container_x) / 2, (y - this.container_y) / 2);
|
|
// }
|
|
}
|
|
|
|
public GuiContainer(Container inventorySlotsIn)
|
|
{
|
|
this.inventorySlots = inventorySlotsIn;
|
|
this.ignoreMouseUp = true;
|
|
}
|
|
|
|
public void init(int width, int height) {
|
|
this.itemRender = this.gm.getRenderItem();
|
|
this.tooltip = null;
|
|
// this.width = width;
|
|
// this.height = height;
|
|
// this.initialize(this.gm.getGame());
|
|
// this.container_x = this.container_y = this.container_w = this.container_h = 0;
|
|
this.container_x = (width - (this.container_w = (this.xSize * 2))) / 2;
|
|
this.container_y = (height - (this.container_h = (this.ySize * 2))) / 2;
|
|
this.initGui();
|
|
this.addButtons();
|
|
}
|
|
|
|
public void hover(String text, int x, int y) {
|
|
this.tooltip = text;
|
|
this.hover_x = x * 2 + this.container_x + 16;
|
|
this.hover_y = y * 2 + this.container_y + 16;
|
|
}
|
|
|
|
public String getTitle() {
|
|
return "Inventar";
|
|
}
|
|
|
|
// public int getXSize() {
|
|
// return this.xSize;
|
|
// }
|
|
//
|
|
// public int getYSize() {
|
|
// return this.ySize;
|
|
// }
|
|
|
|
// public final void initialize(Game gm) {
|
|
// }
|
|
|
|
/**
|
|
* Adds the buttons (and other controls) to the screen in question. Called when the GUI is displayed and when the
|
|
* window resizes, the buttonList is cleared beforehand.
|
|
*/
|
|
public void initGui()
|
|
{
|
|
this.gm.thePlayer.openContainer = this.inventorySlots;
|
|
// this.guiLeft = (this.width - this.xSize) / 2;
|
|
// this.guiTop = (this.height - this.ySize) / 2;
|
|
// this.addButtons();
|
|
}
|
|
|
|
public void addButtons() {
|
|
// this.uidims(this.xSize, this.ySize);
|
|
if(this.inventorySlots != null) {
|
|
for (int i1 = 0; i1 < this.inventorySlots.inventorySlots.size(); ++i1) {
|
|
Slot slot = (Slot)this.inventorySlots.inventorySlots.get(i1);
|
|
this.button(slot.xDisplayPosition - 1, slot.yDisplayPosition - 1, 18, 18);
|
|
}
|
|
}
|
|
}
|
|
|
|
protected void drawSlots(int mouseX, int mouseY) {
|
|
for (int i1 = 0; i1 < this.inventorySlots.inventorySlots.size(); ++i1)
|
|
{
|
|
Slot slot = (Slot)this.inventorySlots.inventorySlots.get(i1);
|
|
this.drawSlot(slot);
|
|
|
|
if (this.isMouseOverSlot(slot, mouseX, mouseY) && slot.canBeHovered())
|
|
{
|
|
this.theSlot = slot;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void drawOverlays() {
|
|
for(Overlay overlay : this.drawnOverlays) {
|
|
this.renderItemOverlayIntoGUI(overlay.stack, overlay.x, overlay.y, overlay.alt);
|
|
}
|
|
this.drawnOverlays.clear();
|
|
if(this.tooltip != null)
|
|
Drawing.drawTextbox(this.tooltip, this.hover_x, this.hover_y, 0xaf000000);
|
|
this.tooltip = null;
|
|
}
|
|
|
|
/**
|
|
* Draws the screen and all the components in it. Args : mouseX, mouseY, renderPartialTicks
|
|
*/
|
|
public void drawScreen(int mouseX, int mouseY)
|
|
{
|
|
if(this.gm == null)
|
|
return;
|
|
// this.drawGradientRect(0, 0, this.width, this.height, -1072689136, -804253680);
|
|
// int i = this.guiLeft;
|
|
// int j = this.guiTop;
|
|
// this.drawGuiContainerBackgroundLayer(mouseX, mouseY);
|
|
GlState.disableRescaleNormal();
|
|
ItemRenderer.disableStandardItemLighting();
|
|
GlState.disableLighting();
|
|
GlState.disableDepth();
|
|
// super.drawScreen(mouseX, mouseY, partialTicks);
|
|
ItemRenderer.enableGUIStandardItemLighting();
|
|
// SKC.glPushMatrix();
|
|
// SKC.glTranslatef((float)i, (float)j, 0.0F);
|
|
GlState.color(1.0F, 1.0F, 1.0F, 1.0F);
|
|
GlState.enableRescaleNormal();
|
|
this.theSlot = null;
|
|
int k = 240;
|
|
int l = 240;
|
|
WCF.glMultiTexCoord2f(WCF.GL_TEXTURE1, (float)k / 1.0F, (float)l / 1.0F);
|
|
GlState.color(1.0F, 1.0F, 1.0F, 1.0F);
|
|
|
|
this.drawSlots(mouseX, mouseY);
|
|
|
|
ItemRenderer.disableStandardItemLighting();
|
|
// this.drawGuiContainerForegroundLayer(mouseX, mouseY);
|
|
ItemRenderer.enableGUIStandardItemLighting();
|
|
InventoryPlayer inventoryplayer = this.gm.thePlayer.inventory;
|
|
ItemStack itemstack = this.draggedStack == null ? inventoryplayer.getItemStack() : this.draggedStack;
|
|
|
|
if (itemstack != null)
|
|
{
|
|
int j2 = 8;
|
|
int k2 = this.draggedStack == null ? 8 : 16;
|
|
String s = null;
|
|
|
|
if (this.draggedStack != null && this.isRightMouseClick)
|
|
{
|
|
itemstack = itemstack.copy();
|
|
itemstack.stackSize = ExtMath.ceilf((float)itemstack.stackSize / 2.0F);
|
|
}
|
|
else if (this.dragSplitting && this.dragSplittingSlots.size() > 1)
|
|
{
|
|
itemstack = itemstack.copy();
|
|
itemstack.stackSize = this.dragSplittingRemnant;
|
|
|
|
if (itemstack.stackSize == 0)
|
|
{
|
|
s = "" + TextColor.YELLOW + "0";
|
|
}
|
|
}
|
|
|
|
this.drawItemStack(itemstack, mouseX - j2, mouseY - k2, s);
|
|
}
|
|
|
|
if (this.returningStack != null)
|
|
{
|
|
float f = (float)(System.currentTimeMillis() - this.returningStackTime) / 100.0F;
|
|
|
|
if (f >= 1.0F)
|
|
{
|
|
f = 1.0F;
|
|
this.returningStack = null;
|
|
}
|
|
|
|
int l2 = this.returningStackDestSlot.xDisplayPosition - this.touchUpX;
|
|
int i3 = this.returningStackDestSlot.yDisplayPosition - this.touchUpY;
|
|
int l1 = this.touchUpX + (int)((float)l2 * f);
|
|
int i2 = this.touchUpY + (int)((float)i3 * f);
|
|
this.drawItemStack(this.returningStack, l1, i2, (String)null);
|
|
}
|
|
|
|
// SKC.glPopMatrix();
|
|
|
|
if (inventoryplayer.getItemStack() == null && this.theSlot != null && this.theSlot.getHasStack())
|
|
{
|
|
ItemStack itemstack1 = this.theSlot.getStack();
|
|
this.renderToolTip(itemstack1, mouseX, mouseY);
|
|
}
|
|
|
|
GlState.enableLighting();
|
|
GlState.enableDepth();
|
|
ItemRenderer.enableStandardItemLighting();
|
|
}
|
|
|
|
/**
|
|
* Render an ItemStack. Args : stack, x, y, format
|
|
*/
|
|
private void drawItemStack(ItemStack stack, int x, int y, String altText)
|
|
{
|
|
WCF.glTranslatef(0.0F, 0.0F, 32.0F);
|
|
// this.zLevel = 200.0F;
|
|
this.itemRender.zLevel = 200.0F;
|
|
this.itemRender.renderItemAndEffectIntoGUI(stack, x, y);
|
|
this.drawnOverlays.add(new Overlay(stack, x, y - (this.draggedStack == null ? 0 : 8), altText));
|
|
// this.zLevel = 0.0F;
|
|
this.itemRender.zLevel = 0.0F;
|
|
}
|
|
|
|
protected void renderToolTip(ItemStack stack, int x, int y) {
|
|
List<String> list = stack.getTooltip(this.gm.thePlayer);
|
|
StringBuilder sb = new StringBuilder();
|
|
for(int i = 0; i < list.size(); ++i) {
|
|
if(i != 0)
|
|
sb.append("\n" + TextColor.LGRAY + (String)list.get(i));
|
|
else
|
|
sb.append((String)list.get(i));
|
|
}
|
|
this.hover(sb.toString(), x, y);
|
|
}
|
|
|
|
/**
|
|
* Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY
|
|
*/
|
|
public void drawGuiContainerForegroundLayer()
|
|
{
|
|
}
|
|
|
|
public void drawGuiContainerBackgroundLayer() {
|
|
}
|
|
|
|
public void drawPost() {
|
|
WCF.glPushMatrix();
|
|
WCF.glTranslatef((this.gm.fb_x - this.xSize * 2) / 2, (this.gm.fb_y - this.ySize * 2) / 2, 0.0f);
|
|
// int k1 = SKC.getMouseX();
|
|
// int l1 = this.gm.fb_y - SKC.getMouseY() - 1;
|
|
WCF.glScalef(2.0f, 2.0f, 2.0f);
|
|
this.drawScreen((this.gm.mouse_x - this.container_x) / 2, (this.gm.mouse_y - this.container_y) / 2);
|
|
WCF.glPopMatrix();
|
|
ItemRenderer.disableStandardItemLighting();
|
|
// GlState.color(1.0f, 1.0f, 1.0f, 1.0f);
|
|
}
|
|
|
|
private void drawSlot(Slot slotIn)
|
|
{
|
|
int i = slotIn.xDisplayPosition;
|
|
int j = slotIn.yDisplayPosition;
|
|
ItemStack itemstack = slotIn.getStack();
|
|
boolean flag = false;
|
|
boolean flag1 = slotIn == this.clickedSlot && this.draggedStack != null && !this.isRightMouseClick;
|
|
ItemStack itemstack1 = this.gm.thePlayer.inventory.getItemStack();
|
|
String s = null;
|
|
|
|
if (slotIn == this.clickedSlot && this.draggedStack != null && this.isRightMouseClick && itemstack != null)
|
|
{
|
|
itemstack = itemstack.copy();
|
|
itemstack.stackSize /= 2;
|
|
}
|
|
else if (this.dragSplitting && this.dragSplittingSlots.contains(slotIn) && itemstack1 != null)
|
|
{
|
|
if (this.dragSplittingSlots.size() == 1)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (Container.canAddItemToSlot(slotIn, itemstack1, true) && this.inventorySlots.canDragIntoSlot(slotIn))
|
|
{
|
|
itemstack = itemstack1.copy();
|
|
flag = true;
|
|
Container.computeStackSize(this.dragSplittingSlots, this.dragSplittingLimit, itemstack, slotIn.getStack() == null ? 0 : slotIn.getStack().stackSize);
|
|
|
|
if (itemstack.stackSize > itemstack.getMaxStackSize())
|
|
{
|
|
s = TextColor.YELLOW + ItemStack.formatAmount(itemstack.getMaxStackSize());
|
|
itemstack.stackSize = itemstack.getMaxStackSize();
|
|
}
|
|
|
|
if (itemstack.stackSize > slotIn.getItemStackLimit(itemstack))
|
|
{
|
|
s = TextColor.YELLOW + ItemStack.formatAmount(slotIn.getItemStackLimit(itemstack));
|
|
itemstack.stackSize = slotIn.getItemStackLimit(itemstack);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.dragSplittingSlots.remove(slotIn);
|
|
this.updateDragSplitting();
|
|
}
|
|
}
|
|
|
|
// this.zLevel = 100.0F;
|
|
this.itemRender.zLevel = 100.0F;
|
|
|
|
// if (itemstack == null)
|
|
// {
|
|
// String s1 = slotIn.getSlotTexture();
|
|
//
|
|
// if (s1 != null)
|
|
// {
|
|
// TextureAtlasSprite sprite = this.gm.getTextureMapBlocks().getAtlasSprite(s1);
|
|
// GlState.disableLighting();
|
|
// this.gm.getTextureManager().bindTexture(TextureMap.locationBlocksTexture);
|
|
// this.rectuv(i, j, 16, 16, sprite.getMinU(), sprite.getMinV(), sprite.getMaxU(), sprite.getMaxV());
|
|
// GlState.enableLighting();
|
|
// flag1 = true;
|
|
// }
|
|
// }
|
|
|
|
if (!flag1)
|
|
{
|
|
// if (flag)
|
|
// {
|
|
// drawRect(i, j, i + 16, j + 16, -2130706433);
|
|
// SKC.highlight(i, j, 16, 16);
|
|
// }
|
|
|
|
GlState.enableDepth();
|
|
this.itemRender.renderItemAndEffectIntoGUI(itemstack, i, j);
|
|
this.drawnOverlays.add(new Overlay(itemstack, i, j, s));
|
|
}
|
|
|
|
this.itemRender.zLevel = 0.0F;
|
|
// this.zLevel = 0.0F;
|
|
}
|
|
|
|
private void updateDragSplitting()
|
|
{
|
|
ItemStack itemstack = this.gm.thePlayer.inventory.getItemStack();
|
|
|
|
if (itemstack != null && this.dragSplitting)
|
|
{
|
|
this.dragSplittingRemnant = itemstack.stackSize;
|
|
|
|
for (Slot slot : this.dragSplittingSlots)
|
|
{
|
|
ItemStack itemstack1 = itemstack.copy();
|
|
int i = slot.getStack() == null ? 0 : slot.getStack().stackSize;
|
|
Container.computeStackSize(this.dragSplittingSlots, this.dragSplittingLimit, itemstack1, i);
|
|
|
|
if (itemstack1.stackSize > itemstack1.getMaxStackSize())
|
|
{
|
|
itemstack1.stackSize = itemstack1.getMaxStackSize();
|
|
}
|
|
|
|
if (itemstack1.stackSize > slot.getItemStackLimit(itemstack1))
|
|
{
|
|
itemstack1.stackSize = slot.getItemStackLimit(itemstack1);
|
|
}
|
|
|
|
this.dragSplittingRemnant -= itemstack1.stackSize - i;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the slot at the given coordinates or null if there is none.
|
|
*/
|
|
private Slot getSlotAtPosition(int x, int y)
|
|
{
|
|
for (int i = 0; i < this.inventorySlots.inventorySlots.size(); ++i)
|
|
{
|
|
Slot slot = (Slot)this.inventorySlots.inventorySlots.get(i);
|
|
|
|
if (this.isMouseOverSlot(slot, x, y))
|
|
{
|
|
return slot;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Called when the mouse is clicked. Args : mouseX, mouseY, clickedButton
|
|
*/
|
|
public void mouseClicked(int mouseX, int mouseY, int mouseButton)
|
|
{
|
|
if(this.gm == null)
|
|
return;
|
|
// super.mouseClicked(mouseX, mouseY, mouseButton);
|
|
// boolean flag = mouseButton == this.gm.bindTertiary.getKeyCode() + 100;
|
|
Slot slot = this.getSlotAtPosition(mouseX, mouseY);
|
|
long i = System.currentTimeMillis();
|
|
this.doubleClick = this.lastClickSlot == slot && i - this.lastClickTime < 250L && this.lastClickButton == mouseButton;
|
|
this.ignoreMouseUp = false;
|
|
|
|
if (mouseButton == 0 || mouseButton == 1) // || flag)
|
|
{
|
|
// int j = this.guiLeft;
|
|
// int k = this.guiTop;
|
|
boolean flag1 = mouseX < 0 || mouseY < 0 || mouseX >= this.xSize || mouseY >= this.ySize;
|
|
int l = -1;
|
|
|
|
if (slot != null)
|
|
{
|
|
l = slot.slotNumber;
|
|
}
|
|
|
|
if (flag1)
|
|
{
|
|
l = -999;
|
|
}
|
|
|
|
// if (this.gm.touchscreen && flag1 && this.gm.thePlayer.inventory.getItemStack() == null)
|
|
// {
|
|
// this.gm.displayGuiScreen((GuiScreen)null);
|
|
// return;
|
|
// }
|
|
|
|
if (l != -1)
|
|
{
|
|
// if (this.gm.touchscreen)
|
|
// {
|
|
// if (slot != null && slot.getHasStack())
|
|
// {
|
|
// this.clickedSlot = slot;
|
|
// this.draggedStack = null;
|
|
// this.isRightMouseClick = mouseButton == 1;
|
|
// }
|
|
// else
|
|
// {
|
|
// this.clickedSlot = null;
|
|
// }
|
|
// }
|
|
// else
|
|
if (!this.dragSplitting)
|
|
{
|
|
if (this.gm.thePlayer.inventory.getItemStack() == null)
|
|
{
|
|
// if (mouseButton == this.gm.bindTertiary.getKeyCode() + 100)
|
|
// {
|
|
// this.handleMouseClick(slot, l, mouseButton, 3);
|
|
// }
|
|
// else
|
|
// {
|
|
boolean flag2 = l != -999 && this.gm.shift();
|
|
int i1 = 0;
|
|
|
|
if (flag2)
|
|
{
|
|
this.shiftClickedSlot = slot != null && slot.getHasStack() ? slot.getStack() : null;
|
|
i1 = 1;
|
|
}
|
|
else if (l == -999)
|
|
{
|
|
i1 = 4;
|
|
}
|
|
|
|
this.handleMouseClick(slot, l, mouseButton, i1);
|
|
// }
|
|
|
|
this.ignoreMouseUp = true;
|
|
}
|
|
else
|
|
{
|
|
this.dragSplitting = true;
|
|
this.dragSplittingButton = mouseButton;
|
|
this.dragSplittingSlots.clear();
|
|
|
|
if (mouseButton == 0)
|
|
{
|
|
this.dragSplittingLimit = 0;
|
|
}
|
|
else if (mouseButton == 1)
|
|
{
|
|
this.dragSplittingLimit = 1;
|
|
}
|
|
// else if (mouseButton == this.gm.bindTertiary.getKeyCode() + 100)
|
|
// {
|
|
// this.dragSplittingLimit = 2;
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
this.lastClickSlot = slot;
|
|
this.lastClickTime = i;
|
|
this.lastClickButton = mouseButton;
|
|
}
|
|
|
|
/**
|
|
* Called when a mouse button is pressed and the mouse is moved around. Parameters are : mouseX, mouseY,
|
|
* lastButtonClicked & timeSinceMouseClick.
|
|
*/
|
|
public void mouseDragged(int mouseX, int mouseY)
|
|
{
|
|
if(this.gm == null)
|
|
return;
|
|
Slot slot = this.getSlotAtPosition(mouseX, mouseY);
|
|
ItemStack itemstack = this.gm.thePlayer.inventory.getItemStack();
|
|
|
|
// if (this.clickedSlot != null && this.gm.touchscreen)
|
|
// {
|
|
// if (clickedMouseButton == 0 || clickedMouseButton == 1)
|
|
// {
|
|
// if (this.draggedStack == null)
|
|
// {
|
|
// if (slot != this.clickedSlot && this.clickedSlot.getStack() != null)
|
|
// {
|
|
// this.draggedStack = this.clickedSlot.getStack().copy();
|
|
// }
|
|
// }
|
|
// else if (this.draggedStack.stackSize > 1 && slot != null && Container.canAddItemToSlot(slot, this.draggedStack, false))
|
|
// {
|
|
// long i = this.gm.getSystemTime();
|
|
//
|
|
// if (this.currentDragTargetSlot == slot)
|
|
// {
|
|
// if (i - this.dragItemDropDelay > 500L)
|
|
// {
|
|
// this.handleMouseClick(this.clickedSlot, this.clickedSlot.slotNumber, 0, 0);
|
|
// this.handleMouseClick(slot, slot.slotNumber, 1, 0);
|
|
// this.handleMouseClick(this.clickedSlot, this.clickedSlot.slotNumber, 0, 0);
|
|
// this.dragItemDropDelay = i + 750L;
|
|
// --this.draggedStack.stackSize;
|
|
// }
|
|
// }
|
|
// else
|
|
// {
|
|
// this.currentDragTargetSlot = slot;
|
|
// this.dragItemDropDelay = i;
|
|
// }
|
|
// }
|
|
// }
|
|
// }
|
|
// else
|
|
if (this.dragSplitting && slot != null && itemstack != null && itemstack.stackSize > this.dragSplittingSlots.size() && Container.canAddItemToSlot(slot, itemstack, true) && slot.isItemValid(itemstack) && this.inventorySlots.canDragIntoSlot(slot))
|
|
{
|
|
this.dragSplittingSlots.add(slot);
|
|
this.updateDragSplitting();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Called when a mouse button is released. Args : mouseX, mouseY, releaseButton
|
|
*/
|
|
public void mouseReleased(int mouseX, int mouseY, int state)
|
|
{
|
|
if(this.gm == null)
|
|
return;
|
|
Slot slot = this.getSlotAtPosition(mouseX, mouseY);
|
|
// int i = this.guiLeft;
|
|
// int j = this.guiTop;
|
|
boolean flag = mouseX < 0 || mouseY < 0 || mouseX >= this.xSize || mouseY >= this.ySize;
|
|
int k = -1;
|
|
|
|
if (slot != null)
|
|
{
|
|
k = slot.slotNumber;
|
|
}
|
|
|
|
if (flag)
|
|
{
|
|
k = -999;
|
|
}
|
|
|
|
if (this.doubleClick && slot != null && state == 0 && this.inventorySlots.canMergeSlot((ItemStack)null, slot))
|
|
{
|
|
if (this.gm.shift())
|
|
{
|
|
if (slot != null && slot.inventory != null && this.shiftClickedSlot != null)
|
|
{
|
|
for (Slot slot2 : this.inventorySlots.inventorySlots)
|
|
{
|
|
if (slot2 != null && slot2.canTakeStack(this.gm.thePlayer) && slot2.getHasStack() && slot2.inventory == slot.inventory && Container.canAddItemToSlot(slot2, this.shiftClickedSlot, true))
|
|
{
|
|
this.handleMouseClick(slot2, slot2.slotNumber, state, 1);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.handleMouseClick(slot, k, state, 6);
|
|
}
|
|
|
|
this.doubleClick = false;
|
|
this.lastClickTime = 0L;
|
|
}
|
|
else
|
|
{
|
|
if (this.dragSplitting && this.dragSplittingButton != state)
|
|
{
|
|
this.dragSplitting = false;
|
|
this.dragSplittingSlots.clear();
|
|
this.ignoreMouseUp = true;
|
|
return;
|
|
}
|
|
|
|
if (this.ignoreMouseUp)
|
|
{
|
|
this.ignoreMouseUp = false;
|
|
return;
|
|
}
|
|
|
|
// if (this.clickedSlot != null && this.gm.touchscreen)
|
|
// {
|
|
// if (state == 0 || state == 1)
|
|
// {
|
|
// if (this.draggedStack == null && slot != this.clickedSlot)
|
|
// {
|
|
// this.draggedStack = this.clickedSlot.getStack();
|
|
// }
|
|
//
|
|
// boolean flag2 = Container.canAddItemToSlot(slot, this.draggedStack, false);
|
|
//
|
|
// if (k != -1 && this.draggedStack != null && flag2)
|
|
// {
|
|
// this.handleMouseClick(this.clickedSlot, this.clickedSlot.slotNumber, state, 0);
|
|
// this.handleMouseClick(slot, k, 0, 0);
|
|
//
|
|
// if (this.gm.thePlayer.inventory.getItemStack() != null)
|
|
// {
|
|
// this.handleMouseClick(this.clickedSlot, this.clickedSlot.slotNumber, state, 0);
|
|
// this.touchUpX = mouseX - i;
|
|
// this.touchUpY = mouseY - j;
|
|
// this.returningStackDestSlot = this.clickedSlot;
|
|
// this.returningStack = this.draggedStack;
|
|
// this.returningStackTime = this.gm.getSystemTime();
|
|
// }
|
|
// else
|
|
// {
|
|
// this.returningStack = null;
|
|
// }
|
|
// }
|
|
// else if (this.draggedStack != null)
|
|
// {
|
|
// this.touchUpX = mouseX - i;
|
|
// this.touchUpY = mouseY - j;
|
|
// this.returningStackDestSlot = this.clickedSlot;
|
|
// this.returningStack = this.draggedStack;
|
|
// this.returningStackTime = this.gm.getSystemTime();
|
|
// }
|
|
//
|
|
// this.draggedStack = null;
|
|
// this.clickedSlot = null;
|
|
// }
|
|
// }
|
|
// else
|
|
if (this.dragSplitting && !this.dragSplittingSlots.isEmpty())
|
|
{
|
|
this.handleMouseClick((Slot)null, -999, Container.func_94534_d(0, this.dragSplittingLimit), 5);
|
|
|
|
for (Slot slot1 : this.dragSplittingSlots)
|
|
{
|
|
this.handleMouseClick(slot1, slot1.slotNumber, Container.func_94534_d(1, this.dragSplittingLimit), 5);
|
|
}
|
|
|
|
this.handleMouseClick((Slot)null, -999, Container.func_94534_d(2, this.dragSplittingLimit), 5);
|
|
}
|
|
else if (this.gm.thePlayer.inventory.getItemStack() != null)
|
|
{
|
|
// if (state == this.gm.bindTertiary.getKeyCode() + 100)
|
|
// {
|
|
// this.handleMouseClick(slot, k, state, 3);
|
|
// }
|
|
// else
|
|
// {
|
|
boolean flag1 = k != -999 && this.gm.shift();
|
|
|
|
if (flag1)
|
|
{
|
|
this.shiftClickedSlot = slot != null && slot.getHasStack() ? slot.getStack() : null;
|
|
}
|
|
|
|
this.handleMouseClick(slot, k, state, flag1 ? 1 : 0);
|
|
// }
|
|
}
|
|
}
|
|
|
|
if (this.gm.thePlayer.inventory.getItemStack() == null)
|
|
{
|
|
this.lastClickTime = 0L;
|
|
}
|
|
|
|
this.dragSplitting = false;
|
|
}
|
|
|
|
/**
|
|
* Returns if the passed mouse position is over the specified slot. Args : slot, mouseX, mouseY
|
|
*/
|
|
private boolean isMouseOverSlot(Slot slotIn, int mouseX, int mouseY)
|
|
{
|
|
return this.isPointInRegion(slotIn.xDisplayPosition, slotIn.yDisplayPosition, 16, 16, mouseX, mouseY);
|
|
}
|
|
|
|
/**
|
|
* Test if the 2D point is in a rectangle (relative to the GUI). Args : rectX, rectY, rectWidth, rectHeight, pointX,
|
|
* pointY
|
|
*/
|
|
protected boolean isPointInRegion(int left, int top, int right, int bottom, int pointX, int pointY)
|
|
{
|
|
// int i = this.guiLeft;
|
|
// int j = this.guiTop;
|
|
// pointX = pointX - i;
|
|
// pointY = pointY - j;
|
|
return pointX >= left - 1 && pointX < left + right + 1 && pointY >= top - 1 && pointY < top + bottom + 1;
|
|
}
|
|
|
|
/**
|
|
* Called when the mouse is clicked over a slot or outside the gui.
|
|
*/
|
|
protected void handleMouseClick(Slot slotIn, int slotId, int clickedButton, int clickType)
|
|
{
|
|
if (slotIn != null)
|
|
{
|
|
slotId = slotIn.slotNumber;
|
|
}
|
|
|
|
this.gm.controller.windowClick(this.inventorySlots.windowId, slotId, clickedButton, clickType, this.gm.thePlayer);
|
|
}
|
|
|
|
public void dropItem() {
|
|
if (this.gm != null && this.gm.thePlayer != null && this.theSlot != null && this.theSlot.getHasStack())
|
|
{
|
|
// if (keyCode == this.gm.bindTertiary.getKeyCode())
|
|
// {
|
|
// this.handleMouseClick(this.theSlot, this.theSlot.slotNumber, 0, 3);
|
|
// }
|
|
// else
|
|
// if (keyCode == this.gm.keyBindDrop.getKeyCode())
|
|
// {
|
|
this.handleMouseClick(this.theSlot, this.theSlot.slotNumber, this.gm.ctrl() ? 1 : 0, 4);
|
|
// }
|
|
}
|
|
}
|
|
|
|
// /**
|
|
// * Fired when a key is typed (except F11 which toggles full screen). This is the equivalent of
|
|
// * KeyListener.keyTyped(KeyEvent e). Args : character (character on the key), keyCode (lwjgl Keyboard key code)
|
|
// */
|
|
// protected void keyTyped(char typedChar, int keyCode)
|
|
// {
|
|
//// if (keyCode == 1 || keyCode == this.gm.keyBindInventory.getKeyCode())
|
|
//// {
|
|
//// this.gm.thePlayer.closeScreen();
|
|
//// }
|
|
//
|
|
// this.checkHotbarKeys(keyCode);
|
|
//
|
|
//
|
|
// }
|
|
|
|
/**
|
|
* This function is what controls the hotbar shortcut check when you press a number key when hovering a stack. Args
|
|
* : keyCode, Returns true if a Hotbar key is pressed, else false
|
|
*/
|
|
public void useHotbar(int slot)
|
|
{
|
|
if (this.gm != null && this.gm.thePlayer != null && this.gm.thePlayer.inventory.getItemStack() == null && this.theSlot != null)
|
|
{
|
|
// for (int i = 0; i < 9; ++i)
|
|
// {
|
|
// if (keyCode == this.gm.keyBindsHotbar[i].getKeyCode())
|
|
// {
|
|
this.handleMouseClick(this.theSlot, this.theSlot.slotNumber, slot, 2);
|
|
// return true;
|
|
// }
|
|
// }
|
|
}
|
|
|
|
// return false;
|
|
}
|
|
|
|
/**
|
|
* Called when the screen is unloaded. Used to disable keyboard repeat events
|
|
*/
|
|
public void onGuiClosed()
|
|
{
|
|
if (this.gm != null && this.gm.thePlayer != null)
|
|
{
|
|
this.inventorySlots.onContainerClosed(this.gm.thePlayer);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns true if this GUI should pause the game when it is displayed in single-player
|
|
*/
|
|
// public boolean doesGuiPauseGame()
|
|
// {
|
|
// return false;
|
|
// }
|
|
|
|
/**
|
|
* Called from the main game loop to update the screen.
|
|
*/
|
|
public void updateScreen()
|
|
{
|
|
// super.updateScreen();
|
|
|
|
if (this.gm != null && this.gm.thePlayer != null && (!this.gm.thePlayer.isEntityAlive() || this.gm.thePlayer.dead))
|
|
{
|
|
this.gm.thePlayer.closeScreen();
|
|
}
|
|
}
|
|
|
|
public void renderItemOverlayIntoGUI(ItemStack stack, int xPosition, int yPosition, String text)
|
|
{
|
|
renderItemOverlay(stack, this.container_x + xPosition * 2, this.container_y + yPosition * 2, text);
|
|
}
|
|
|
|
public static void renderItemOverlay(ItemStack stack, int xPosition, int yPosition, String text)
|
|
{
|
|
if (stack != null)
|
|
{
|
|
if (stack.stackSize != 1 || text != null)
|
|
{
|
|
String s = text == null ? ItemStack.formatAmount(stack.stackSize) : text;
|
|
|
|
if (text == null && stack.stackSize < 1)
|
|
{
|
|
s = TextColor.RED + ItemStack.formatAmount(stack.stackSize);
|
|
}
|
|
// this.drawString(s, , );
|
|
Vec2i size = Drawing.txt_size(0, 0, 0, 0, 65536, 65536, s);
|
|
int x = xPosition + 34 - size.xpos; // this.getStringWidth(s);
|
|
int y = yPosition + 17;
|
|
// x = x * 2 + this.container_x;
|
|
// y = y * 2 + this.container_y;
|
|
Drawing.txt_draw(x, y, x, y, x + 440, y + 260, 0xffffffff, s);
|
|
}
|
|
|
|
if (stack.isItemDamaged())
|
|
{
|
|
int j = (int)Math.round(28.0D - (double)stack.getItemDamage() * 28.0D / (double)stack.getMaxDamage());
|
|
int i = (int)Math.round(255.0D - (double)stack.getItemDamage() * 255.0D / (double)stack.getMaxDamage());
|
|
draw(xPosition + 2, yPosition + 26, 28, 4, 0, 0, 0);
|
|
draw(xPosition + 2, yPosition + 26, 26, 2, (255 - i) / 4, 64, 0);
|
|
draw(xPosition + 2, yPosition + 26, j, 2, 255 - i, i, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
private static void draw(int x, int y, int width, int height, int red, int green, int blue)
|
|
{
|
|
// Drawing.gfx_draw_rect_color(this.container_x + x * 2, this.container_y + y * 2, width * 2, height * 2, 0xff000000 | (red << 16) | (green << 8) | blue);
|
|
Drawing.drawRectColor(x, y, width, height, 0xff000000 | (red << 16) | (green << 8) | blue);
|
|
}
|
|
|
|
public void drawBackground() {
|
|
Drawing.drawRect2GradBorder(this.container_x, this.container_y, this.container_w, this.container_h, 0xff3f3f3f, 0xff000000, 0xff7f7f7f, 0xff4f4f4f, 0xff4f4f4f, 0xff1f1f1f);
|
|
}
|
|
}
|