From 705395472a19a343bdb0dd08c8129c6f42534654 Mon Sep 17 00:00:00 2001 From: Sen Date: Tue, 11 Mar 2025 19:38:49 +0100 Subject: [PATCH] gui cheat overlay new files --- java/src/game/gui/container/GuiBrewing.java | 50 + java/src/game/gui/container/GuiChest.java | 53 + java/src/game/gui/container/GuiContainer.java | 1188 +++++++++++++++++ java/src/game/gui/container/GuiCrafting.java | 42 + java/src/game/gui/container/GuiDispenser.java | 46 + java/src/game/gui/container/GuiEnchant.java | 290 ++++ java/src/game/gui/container/GuiFurnace.java | 71 + java/src/game/gui/container/GuiHopper.java | 49 + java/src/game/gui/container/GuiHorse.java | 79 ++ java/src/game/gui/container/GuiInventory.java | 58 + java/src/game/gui/container/GuiMachine.java | 44 + java/src/game/gui/container/GuiMerchant.java | 286 ++++ java/src/game/gui/container/GuiRepair.java | 218 +++ 13 files changed, 2474 insertions(+) create mode 100755 java/src/game/gui/container/GuiBrewing.java create mode 100755 java/src/game/gui/container/GuiChest.java create mode 100755 java/src/game/gui/container/GuiContainer.java create mode 100755 java/src/game/gui/container/GuiCrafting.java create mode 100755 java/src/game/gui/container/GuiDispenser.java create mode 100755 java/src/game/gui/container/GuiEnchant.java create mode 100755 java/src/game/gui/container/GuiFurnace.java create mode 100755 java/src/game/gui/container/GuiHopper.java create mode 100755 java/src/game/gui/container/GuiHorse.java create mode 100755 java/src/game/gui/container/GuiInventory.java create mode 100755 java/src/game/gui/container/GuiMachine.java create mode 100755 java/src/game/gui/container/GuiMerchant.java create mode 100755 java/src/game/gui/container/GuiRepair.java diff --git a/java/src/game/gui/container/GuiBrewing.java b/java/src/game/gui/container/GuiBrewing.java new file mode 100755 index 0000000..93530ba --- /dev/null +++ b/java/src/game/gui/container/GuiBrewing.java @@ -0,0 +1,50 @@ +package game.gui.container; + +import game.inventory.ContainerBrewingStand; +import game.inventory.IInventory; +import game.inventory.InventoryPlayer; + + +public class GuiBrewing extends GuiContainer +{ +// private static final String brewingStandGuiTextures = "textures/gui/brewing_stand.png"; + + /** The player inventory bound to this GUI. */ + private final InventoryPlayer playerInventory; + private IInventory tileBrewingStand; + + public GuiBrewing(InventoryPlayer playerInv, IInventory p_i45506_2_) + { + super(new ContainerBrewingStand(playerInv, p_i45506_2_)); + this.playerInventory = playerInv; + this.tileBrewingStand = p_i45506_2_; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + String s = this.tileBrewingStand.getCommandName(); + this.drawString(s, 8, 6); + this.drawString(this.playerInventory.getCommandName(), 8, this.ySize - 96 + 2); + } + + /** + * Args : renderPartialTicks, mouseX, mouseY + */ + public void drawGuiContainerBackgroundLayer() + { + int k = this.tileBrewingStand.getField(0); + + if (k > 0) + { + int l = (int)(28.0F * (1.0F - (float)k / 400.0F)); + + if (l > 0) + { + this.rect(97, 16, 9, l, 0xffff20); + } + } + } +} diff --git a/java/src/game/gui/container/GuiChest.java b/java/src/game/gui/container/GuiChest.java new file mode 100755 index 0000000..6adb0d9 --- /dev/null +++ b/java/src/game/gui/container/GuiChest.java @@ -0,0 +1,53 @@ +package game.gui.container; + +import game.Game; +import game.inventory.ContainerChest; +import game.inventory.IInventory; + + +public class GuiChest extends GuiContainer +{ +// /** The ResourceLocation containing the chest GUI texture. */ +// private static final String CHEST_GUI_TEXTURE = "textures/gui/generic_54.png"; + private IInventory upperChestInventory; + private IInventory lowerChestInventory; + + /** + * window height is calculated with these values; the more rows, the heigher + */ + private int inventoryRows; + + public GuiChest(IInventory upperInv, IInventory lowerInv) + { + super(new ContainerChest(upperInv, lowerInv, Game.getGame().thePlayer)); + this.upperChestInventory = upperInv; + this.lowerChestInventory = lowerInv; +// this.allowUserInput = false; + int i = 222; + int j = i - 108; + this.inventoryRows = lowerInv.getSizeInventory() / 9; + this.ySize = j + this.inventoryRows * 18; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + this.drawString(this.lowerChestInventory.getCommandName(), 8, 6); + this.drawString(this.upperChestInventory.getCommandName(), 8, this.ySize - 96 + 2); + } + + /** + * Args : renderPartialTicks, mouseX, mouseY + */ +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(CHEST_GUI_TEXTURE); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +//// this.rect(i, j, 0, 0, this.xSize, this.inventoryRows * 18 + 17); +//// this.rect(i, j + this.inventoryRows * 18 + 17, 0, 126, this.xSize, 96); +// } +} diff --git a/java/src/game/gui/container/GuiContainer.java b/java/src/game/gui/container/GuiContainer.java new file mode 100755 index 0000000..eec09ff --- /dev/null +++ b/java/src/game/gui/container/GuiContainer.java @@ -0,0 +1,1188 @@ +package game.gui.container; + +import java.util.List; +import java.util.Set; + +import game.collect.Lists; +import game.collect.Sets; +import game.color.TextColor; +import game.gui.Gui; +import game.gui.element.InventoryButton; +import game.inventory.Container; +import game.inventory.InventoryPlayer; +import game.inventory.Slot; +import game.item.CheatTab; +import game.item.ItemStack; +import game.packet.CPacketCheat; +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; + } + } + + private static final List ITEM_LIST = Lists.newArrayList(); + + private static CheatTab selectedTab = CheatTab.tabBlocks; +// /** 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 dragSplittingSlots = Sets.newHashSet(); + protected final List drawnOverlays = Lists.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; + + protected int container_x; + protected int container_y; + protected int container_w; + protected int container_h; + + private int hover_x; + private int hover_y; + private String tooltip; + + private float currentScroll; + private boolean isScrolling; + private boolean wasClicking; + + 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(); + if(this.gm.itemCheat) { +// CheatTab i = selectedTab; +// selectedTab = null; + this.setCurrentTab(selectedTab); + } + } + + 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); + } + } + if(this.gm.itemCheat) { + for (int k = 0; k < 9; ++k) + { + for (int l = 0; l < 12; ++l) { + this.button(this.xSize + 2 + 18 * l, k * 18, 18, 18); + } + } + for(CheatTab tab : CheatTab.values()) { + this.button(this.xSize + 2 + 18 * tab.getHorizontal(), 9 * 18 + 4 + 20 * tab.getVertical(), 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; + } + } + + if(this.gm.itemCheat) { + int i = (ITEM_LIST.size() + 12 - 1) / 12 - 9; + int j = (int)((double)(this.currentScroll * (float)i) + 0.5D); + + if (j < 0) + { + j = 0; + } + + for (int k = 0; k < 9; ++k) + { + for (int l = 0; l < 12; ++l) + { + int i1 = l + (k + j) * 12; + + if (i1 >= 0 && i1 < ITEM_LIST.size()) { + + this.itemRender.zLevel = 100.0F; + GlState.enableDepth(); + this.itemRender.renderItemAndEffectIntoGUI(ITEM_LIST.get(i1), this.xSize + 2 + 18 * l + 1, k * 18 + 1); + this.itemRender.zLevel = 0.0F; + if(this.isPointInRegion(this.xSize + 2 + 18 * l + 1, k * 18 + 1, 16, 16, mouseX, mouseY)) + this.renderToolTip(ITEM_LIST.get(i1), mouseX, mouseY); + } + } + } + + for (CheatTab tabs : CheatTab.values()) + { + this.drawTab(tabs); + } + } + } + + 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; + if(this.gm.itemCheat) { + boolean flag = Button.MOUSE_LEFT.isDown(); //TODO: remove? + int x1 = this.xSize + 2 + 12 * 18 + 1; + int y1 = 1; + int x2 = x1 + 10; + int y2 = y1 + 112 + 18 * 4; + + if (!this.wasClicking && flag && mouseX >= x1 && mouseY >= y1 && mouseX < x2 && mouseY < y2) + { + this.isScrolling = this.needsScrollBars(); + } + + if (!flag) + { + this.isScrolling = false; + } + + this.wasClicking = flag; + + if (this.isScrolling) + { + this.currentScroll = ((float)(mouseY - y1) - 7.5F) / ((float)(y2 - y1) - 15.0F); + this.currentScroll = ExtMath.clampf(this.currentScroll, 0.0F, 1.0F); + } + } +// 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(); + + if(this.gm.itemCheat) { + for (CheatTab tab : CheatTab.values()) + { + if (this.renderInventoryHoveringText(tab, mouseX, mouseY)) + { + break; + } + } + + GlState.color(1.0F, 1.0F, 1.0F, 1.0F); + GlState.disableLighting(); + } + } + + /** + * 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 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 draw() { + super.draw(); + if(this.gm.itemCheat) { + int i = this.xSize + 2 + 12 * 18 + 1; + int j = 1; + int k = j + 184; + this.rect(i, j, 8, 182, this.needsScrollBars() ? 0x303030 : 0x202020); + this.rect(i, j + (int)((float)(k - j - 17) * this.currentScroll), 8, 15, this.needsScrollBars() ? 0x808080 : 0x606060); +// CheatTab tab = CheatTab.TABS[selectedTab]; + this.rect(this.xSize + 2 + 18 * selectedTab.getHorizontal(), 9 * 18 + 4 + 20 * selectedTab.getVertical() - 2, 18, 2, 0xffffff); + } + this.drawGuiContainerBackgroundLayer(); + if(this.gm.itemCheat) { +// CheatTab tab = CheatTab.TABS[selectedTab]; + this.drawString(selectedTab.getName(), this.xSize + 2 + 4, -10); + this.drawString("Vorsicht: Schummeln wird mit Keule bestraft", this.xSize + 2 + 4, 18 * (9 + (CheatTab.values().length + 11) / 12) + 10); + this.drawString("(Halte Strg beim Klick für vollen Stapel)", this.xSize + 2 + 4, 18 * (9 + (CheatTab.values().length + 11) / 12) + 20); + } + this.drawGuiContainerForegroundLayer(); + } + + 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; + if(mouseButton == 0) { + if(this.clickSide(mouseX, mouseY, -1)) + return; + if(this.gm.itemCheat && this.gm.thePlayer != null && this.gm.thePlayer.inventory.getItemStack() == null) { + for (CheatTab tab : CheatTab.values()) + { + if (this.isInsideTab(tab, mouseX, mouseY)) + { + this.setCurrentTab(tab); + 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.clickSide((this.gm.mouse_x - this.container_x) / 2, (this.gm.mouse_y - this.container_y) / 2, slot) && 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); + } + + + protected boolean isInsideTab(CheatTab tab, int x, int y) + { + return x >= this.xSize + 2 + 18 * tab.getHorizontal() && x < this.xSize + 2 + 18 * tab.getHorizontal() + 18 && + y >= 9 * 18 + 4 + 20 * tab.getVertical() && y < 9 * 18 + 4 + 20 * tab.getVertical() + 18; + } + + protected boolean renderInventoryHoveringText(CheatTab tab, int x, int z) + { + if (this.isPointInRegion(this.xSize + 2 + 18 * tab.getHorizontal(), 9 * 18 + 4 + 20 * tab.getVertical(), 18, 18, x, z)) + { + this.hover(tab.getName(), x, z); + return true; + } + else + { + return false; + } + } + + protected void drawTab(CheatTab tab) + { + this.itemRender.zLevel = 100.0F; + ItemStack itemstack = tab.getIconItemStack(); + GlState.enableDepth(); + this.itemRender.renderItemAndEffectIntoGUI(itemstack, this.xSize + 2 + 18 * tab.getHorizontal() + 1, 9 * 18 + 4 + 20 * tab.getVertical() + 1); + this.itemRender.zLevel = 0.0F; + } + + public void scroll(int scr_x, int scr_y, int x, int y, boolean ctrl, boolean shift) { + super.scroll(scr_x, scr_y, x, y, ctrl, shift); + if(this.gm.itemCheat && scr_y != 0 && this.needsScrollBars()) { + int len = ITEM_LIST.size() / 12 - 5; + this.currentScroll = (float)((double)this.currentScroll - (double)scr_y / (double)len); + this.currentScroll = ExtMath.clampf(this.currentScroll, 0.0F, 1.0F); + } + } + + private boolean needsScrollBars() + { + return ITEM_LIST.size() > 12 * 9; + } + + private void setCurrentTab(CheatTab tab) + { + selectedTab = tab; + this.dragSplittingSlots.clear(); + ITEM_LIST.clear(); + tab.displayAllReleventItems(ITEM_LIST); + + this.currentScroll = 0.0F; + } + + private boolean clickSide(int mouseX, int mouseY, int slot) { + if(this.gm.itemCheat && this.isPointInRegion(this.xSize + 2, 0, 18 * 12, 18 * 9, mouseX, mouseY) && this.gm.thePlayer != null && this.gm.thePlayer.inventory.getItemStack() == null) { + int i = (ITEM_LIST.size() + 12 - 1) / 12 - 9; + int j = (int)((double)(this.currentScroll * (float)i) + 0.5D); + + if (j < 0) + { + j = 0; + } + + int sx = (mouseX - (this.xSize + 2)) / 18; + int sy = mouseY / 18; + int i1 = sx + (sy + j) * 12; + + if(i1 >= 0 && i1 < ITEM_LIST.size()) { + this.gm.thePlayer.sendQueue.addToSendQueue(new CPacketCheat(ITEM_LIST.get(i1), slot, this.gm.ctrl())); + return true; + } + } + return false; + } +} diff --git a/java/src/game/gui/container/GuiCrafting.java b/java/src/game/gui/container/GuiCrafting.java new file mode 100755 index 0000000..0dbe12c --- /dev/null +++ b/java/src/game/gui/container/GuiCrafting.java @@ -0,0 +1,42 @@ +package game.gui.container; + +import game.inventory.ContainerWorkbench; +import game.inventory.InventoryPlayer; +import game.world.BlockPos; +import game.world.World; + +public class GuiCrafting extends GuiContainer +{ +// private static final String craftingTableGuiTextures = "textures/gui/crafting_table.png"; + + public GuiCrafting(InventoryPlayer playerInv, World worldIn) + { + this(playerInv, worldIn, BlockPos.ORIGIN); + } + + public GuiCrafting(InventoryPlayer playerInv, World worldIn, BlockPos blockPosition) + { + super(new ContainerWorkbench(playerInv, worldIn, blockPosition)); + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + this.drawString("Handwerk", 28, 6); + this.drawString("Inventar", 8, this.ySize - 96 + 2); + } + +// /** +// * Args : renderPartialTicks, mouseX, mouseY +// */ +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(craftingTableGuiTextures); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +//// this.rect(i, j, 0, 0, this.xSize, this.ySize); +// } +} diff --git a/java/src/game/gui/container/GuiDispenser.java b/java/src/game/gui/container/GuiDispenser.java new file mode 100755 index 0000000..c65e983 --- /dev/null +++ b/java/src/game/gui/container/GuiDispenser.java @@ -0,0 +1,46 @@ +package game.gui.container; + +import game.inventory.ContainerDispenser; +import game.inventory.IInventory; +import game.inventory.InventoryPlayer; + + +public class GuiDispenser extends GuiContainer +{ +// private static final String dispenserGuiTextures = "textures/gui/dispenser.png"; + + /** The player inventory bound to this GUI. */ + private final InventoryPlayer playerInventory; + + /** The inventory contained within the corresponding Dispenser. */ + public IInventory dispenserInventory; + + public GuiDispenser(InventoryPlayer playerInv, IInventory dispenserInv) + { + super(new ContainerDispenser(playerInv, dispenserInv)); + this.playerInventory = playerInv; + this.dispenserInventory = dispenserInv; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + String s = this.dispenserInventory.getCommandName(); + this.drawString(s, 8, 6); + this.drawString(this.playerInventory.getCommandName(), 8, this.ySize - 96 + 2); + } + +// /** +// * Args : renderPartialTicks, mouseX, mouseY +// */ +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(dispenserGuiTextures); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +//// this.rect(i, j, 0, 0, this.xSize, this.ySize); +// } +} diff --git a/java/src/game/gui/container/GuiEnchant.java b/java/src/game/gui/container/GuiEnchant.java new file mode 100755 index 0000000..44386de --- /dev/null +++ b/java/src/game/gui/container/GuiEnchant.java @@ -0,0 +1,290 @@ +package game.gui.container; + +import game.color.TextColor; +import game.enchantment.Enchantment; +import game.inventory.ContainerEnchantment; +import game.inventory.InventoryPlayer; +import game.item.ItemStack; +import game.rng.Random; +import game.tileentity.IWorldNameable; +import game.util.ExtMath; +import game.world.World; + +public class GuiEnchant extends GuiContainer +{ + /** The ResourceLocation containing the Enchantment GUI texture location */ +// private static final String ENCHANTMENT_TABLE_GUI_TEXTURE = "textures/gui/enchanting_table.png"; + private static final String[] NAMES = "the elder scrolls klaatu berata niktu xyzzy bless curse light darkness fire air earth water hot dry cold wet ignite snuff embiggen twist shorten stretch fiddle destroy imbue galvanize enchant free limited range of towards inside sphere cube self other ball mental physical grow shrink demon elemental spirit animal creature beast humanoid undead fresh stale ".split(" "); + + /** The player inventory currently bound to this GuiEnchantment instance. */ + private final InventoryPlayer playerInventory; + private final Random nameRand = new Random(); + private final Random random = new Random(); + private final ContainerEnchantment container; + private final IWorldNameable table; + + public int field_147073_u; + public float field_147071_v; + public float field_147069_w; + public float field_147082_x; + public float field_147081_y; + public float field_147080_z; + public float field_147076_A; + ItemStack field_147077_B; + + public GuiEnchant(InventoryPlayer inventory, World worldIn, IWorldNameable table) + { + super(new ContainerEnchantment(inventory, worldIn)); + this.playerInventory = inventory; + this.container = (ContainerEnchantment)this.inventorySlots; + this.table = table; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + this.drawString(this.table.getCommandName(), 12, 5); + this.drawString(this.playerInventory.getCommandName(), 8, this.ySize - 96 + 2); + } + + /** + * Called from the main game loop to update the screen. + */ + public void updateScreen() + { + super.updateScreen(); + this.func_147068_g(); + } + + /** + * Called when the mouse is clicked. Args : mouseX, mouseY, clickedButton + */ + public void mouseClicked(int mouseX, int mouseY, int mouseButton) + { + super.mouseClicked(mouseX, mouseY, mouseButton); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; + + for (int k = 0; k < 3; ++k) + { + int l = mouseX - 60; + int i1 = mouseY - (14 + 19 * k); + + if (l >= 0 && i1 >= 0 && l < 108 && i1 < 19 && this.container.enchantItem(this.gm.thePlayer, k)) + { + this.gm.controller.sendEnchantPacket(this.container.windowId, k); + } + } + } + + public void addButtons() { + super.addButtons(); + this.button(60, 14 + 19 * 0, 108, 19); + this.button(60, 14 + 19 * 1, 108, 19); + this.button(60, 14 + 19 * 2, 108, 19); + } + + /** + * Args : renderPartialTicks, mouseX, mouseY + */ + public void drawGuiContainerBackgroundLayer() + { + this.nameRand.setSeed((long)this.container.xpSeed); + + for (int l = 0; l < 3; ++l) + { + int i1 = 60; + int j1 = i1 + 20; + String s = this.getRandomName(); + int l1 = this.container.enchantLevels[l]; + + if (l1 == 0) + { + this.rect(i1, 14 + 19 * l, 108, 19, 0x404040); + } + else + { + String s1 = "" + l1; + int i2 = 6839882; + + if (/* (k < l + 1 || */ this.gm.thePlayer.experienceLevel < l1) // && !this.gm.thePlayer.creative) + { + this.rect(i1, 14 + 19 * l, 108, 19, 0x400000); + this.rect(i1 + 1, 15 + 19 * l, 16, 16, 0x200000); + this.drawString(s, j1, 16 + 19 * l); // , /*k1,*/ (i2 & 16711422) >> 1); + i2 = 4226832; + } + else + { +// int j2 = SKC.getMouseX() - this.guiLeft - 60; +// int k2 = SKC.getMouseY() - this.guiTop - (14 + 19 * l); + +// if (j2 >= 0 && k2 >= 0 && j2 < 108 && k2 < 19) +// { +// this.rect(i1, 14 + 19 * l, 108, 19, 0x20ff20); +// i2 = 16777088; +// } +// else +// { + this.rect(i1, 14 + 19 * l, 108, 19, 0x20ff20); +// } + + this.rect(i1 + 1, 15 + 19 * l, 16, 16, 0x008000); + this.drawString(s, j1, 16 + 19 * l); + i2 = 8453920; + } + + this.drawString(s1, j1 + 86 - this.getStringWidth(s1), 16 + 19 * l + 7); + } + } + } + + /** + * Draws the screen and all the components in it. Args : mouseX, mouseY, renderPartialTicks + */ + public void drawScreen(int mouseX, int mouseY) + { + super.drawScreen(mouseX, mouseY); +// boolean flag = this.gm.thePlayer.creative; +// int i = this.container.getLapisAmount(); + + for (int j = 0; j < 3; ++j) + { + int k = this.container.enchantLevels[j]; + int l = this.container.enchantmentIds[j]; + int i1 = j + 1; + + if (this.isPointInRegion(60, 14 + 19 * j, 108, 17, mouseX, mouseY) && k > 0 && l >= 0) + { + StringBuilder sb = new StringBuilder(); + + if (l >= 0 && Enchantment.getEnchantmentById(l & 255) != null) + { + String s = Enchantment.getEnchantmentById(l & 255).getFormattedName((l & 65280) >> 8); + sb.append(TextColor.WHITE + s + " . . . ?"); + } + +// if (!flag) +// { +// if (l >= 0 && sb.length() != 0) +// { +// sb.append("\n"); +// } + + if (this.gm.thePlayer.experienceLevel < k) + { + sb.append((sb.length() != 0 ? "\n" : "") + TextColor.RED + String.format("Erfahrungsstufe %d erforderlich", this.container.enchantLevels[j])); + } + else + { + String s1 = ""; + +// if (i1 == 1) +// { +// s1 = I18n.format("container.enchant.lapis.one"); +// } +// else +// { +// s1 = I18n.format("container.enchant.lapis.many", i1); +// } +// +// if (i >= i1) +// { +// list.add(ChatFormat.GRAY.toString() + "" + s1); +// } +// else +// { +// list.add(ChatFormat.RED.toString() + "" + s1); +// } + + if (i1 == 1) + { + s1 = "1 Erfahrungsstufe"; + } + else + { + s1 = String.format("%d Erfahrungsstufen", i1); + } + + sb.append((sb.length() != 0 ? "\n" : "") + TextColor.LGRAY.toString() + "" + s1); + } +// } + + this.hover(sb.toString(), mouseX, mouseY); + break; + } + } + } + + private String getRandomName() + { + int i = this.nameRand.zrange(2) + 3; + String s = ""; + + for (int j = 0; j < i; ++j) + { + if (j > 0) + { + s = s + " "; + } + + String name = NAMES[this.nameRand.zrange(NAMES.length)]; + for(int z = 0; z < name.length(); z++) { + s += (char)(name.charAt(z) - 0x61 + 0x80); + } + } + + return s; + } + + private void func_147068_g() + { + ItemStack itemstack = this.inventorySlots.getSlot(0).getStack(); + + if (!ItemStack.areItemStacksEqual(itemstack, this.field_147077_B)) + { + this.field_147077_B = itemstack; + + while (true) + { + this.field_147082_x += (float)(this.random.zrange(4) - this.random.zrange(4)); + + if (this.field_147071_v > this.field_147082_x + 1.0F || this.field_147071_v < this.field_147082_x - 1.0F) + { + break; + } + } + } + + ++this.field_147073_u; + this.field_147069_w = this.field_147071_v; + this.field_147076_A = this.field_147080_z; + boolean flag = false; + + for (int i = 0; i < 3; ++i) + { + if (this.container.enchantLevels[i] != 0) + { + flag = true; + } + } + + if (flag) + { + this.field_147080_z += 0.2F; + } + else + { + this.field_147080_z -= 0.2F; + } + + this.field_147080_z = ExtMath.clampf(this.field_147080_z, 0.0F, 1.0F); + float f1 = (this.field_147082_x - this.field_147071_v) * 0.4F; + float f = 0.2F; + f1 = ExtMath.clampf(f1, -f, f); + this.field_147081_y += (f1 - this.field_147081_y) * 0.9F; + this.field_147071_v += this.field_147081_y; + } +} diff --git a/java/src/game/gui/container/GuiFurnace.java b/java/src/game/gui/container/GuiFurnace.java new file mode 100755 index 0000000..f8f31a3 --- /dev/null +++ b/java/src/game/gui/container/GuiFurnace.java @@ -0,0 +1,71 @@ +package game.gui.container; + +import game.inventory.ContainerFurnace; +import game.inventory.IInventory; +import game.inventory.InventoryPlayer; +import game.tileentity.TileEntityFurnace; + + +public class GuiFurnace extends GuiContainer +{ +// private static final String furnaceGuiTextures = "textures/gui/furnace.png"; + + /** The player inventory bound to this GUI. */ + private final InventoryPlayer playerInventory; + private IInventory tileFurnace; + + public GuiFurnace(InventoryPlayer playerInv, IInventory furnaceInv) + { + super(new ContainerFurnace(playerInv, furnaceInv)); + this.playerInventory = playerInv; + this.tileFurnace = furnaceInv; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + String s = this.tileFurnace.getCommandName(); + this.drawString(s, 8, 6); + this.drawString(this.playerInventory.getCommandName(), 8, this.ySize - 96 + 2); + } + + /** + * Args : renderPartialTicks, mouseX, mouseY + */ + public void drawGuiContainerBackgroundLayer() + { + this.rect(58, 36, 12, 14, 0x202020); + if (TileEntityFurnace.isBurning(this.tileFurnace)) + { + int k = this.getBurnLeftScaled(13); + k = Math.min(k, 13); + this.rect(58, 36 + 13 - k, 12, k + 1, 0xff7f00); + } + + int l = this.getCookProgressScaled(24); + this.rect(79, 39, 24, 8, 0x606060); + if(l > 0) + this.rect(79, 39, l + 1, 8, 0xffaf00); + } + + private int getCookProgressScaled(int pixels) + { + int i = this.tileFurnace.getField(2); + int j = this.tileFurnace.getField(3); + return j != 0 && i != 0 ? i * pixels / j : 0; + } + + private int getBurnLeftScaled(int pixels) + { + int i = this.tileFurnace.getField(1); + + if (i == 0) + { + i = 200; + } + + return this.tileFurnace.getField(0) * pixels / i; + } +} diff --git a/java/src/game/gui/container/GuiHopper.java b/java/src/game/gui/container/GuiHopper.java new file mode 100755 index 0000000..9923d08 --- /dev/null +++ b/java/src/game/gui/container/GuiHopper.java @@ -0,0 +1,49 @@ +package game.gui.container; + +import game.Game; +import game.inventory.ContainerHopper; +import game.inventory.IInventory; +import game.inventory.InventoryPlayer; + + +public class GuiHopper extends GuiContainer +{ +// /** The ResourceLocation containing the gui texture for the hopper */ +// private static final String HOPPER_GUI_TEXTURE = "textures/gui/hopper.png"; + + /** The player inventory currently bound to this GUI instance */ + private IInventory playerInventory; + + /** The hopper inventory bound to this GUI instance */ + private IInventory hopperInventory; + + public GuiHopper(InventoryPlayer playerInv, IInventory hopperInv) + { + super(new ContainerHopper(playerInv, hopperInv, Game.getGame().thePlayer)); + this.playerInventory = playerInv; + this.hopperInventory = hopperInv; +// this.allowUserInput = false; + this.ySize = 133; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + this.drawString(this.hopperInventory.getCommandName(), 8, 6); + this.drawString(this.playerInventory.getCommandName(), 8, this.ySize - 96 + 2); + } + +// /** +// * Args : renderPartialTicks, mouseX, mouseY +// */ +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(HOPPER_GUI_TEXTURE); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +//// this.rect(i, j, 0, 0, this.xSize, this.ySize); +// } +} diff --git a/java/src/game/gui/container/GuiHorse.java b/java/src/game/gui/container/GuiHorse.java new file mode 100755 index 0000000..6d620b4 --- /dev/null +++ b/java/src/game/gui/container/GuiHorse.java @@ -0,0 +1,79 @@ +package game.gui.container; + +import game.Game; +import game.entity.animal.EntityHorse; +import game.inventory.ContainerHorseInventory; +import game.inventory.IInventory; + + +public class GuiHorse extends GuiContainer +{ +// private static final String horseGuiTextures = "textures/gui/horse.png"; + + /** The player inventory bound to this GUI. */ + private IInventory playerInventory; + + /** The horse inventory bound to this GUI. */ + private IInventory horseInventory; + +// /** The EntityHorse whose inventory is currently being accessed. */ +// private EntityHorse horseEntity; + +// /** The mouse x-position recorded during the last rendered frame. */ +// private float mousePosx; +// +// /** The mouse y-position recorded during the last renderered frame. */ +// private float mousePosY; + + public GuiHorse(IInventory playerInv, IInventory horseInv, EntityHorse horse) + { + super(new ContainerHorseInventory(playerInv, horseInv, horse, Game.getGame().thePlayer)); + this.playerInventory = playerInv; + this.horseInventory = horseInv; +// this.horseEntity = horse; +// this.allowUserInput = false; + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + this.drawString(this.horseInventory.getCommandName(), 8, 6); + this.drawString(this.playerInventory.getCommandName(), 8, this.ySize - 96 + 2); + } + +// /** +// * Args : renderPartialTicks, mouseX, mouseY +// */ +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(horseGuiTextures); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +//// this.rect(i, j, 0, 0, this.xSize, this.ySize); +// +//// if (this.horseEntity.isChested()) +//// { +//// this.rect(i + 79, j + 17, 0, this.ySize, 90, 54); +//// } +// +//// if (this.horseEntity.canWearArmor()) +//// { +//// this.rect(i + 7, j + 35, 0, this.ySize + 54, 18, 18); +//// } +// +//// GuiInventory.drawEntityOnScreen(i + 51, j + 60, 17, (float)(i + 51) - this.mousePosx, (float)(j + 75 - 50) - this.mousePosY, this.horseEntity); +// } + +// /** +// * Draws the screen and all the components in it. Args : mouseX, mouseY, renderPartialTicks +// */ +// public void drawScreen(int mouseX, int mouseY) +// { +// this.mousePosx = (float)mouseX; +// this.mousePosY = (float)mouseY; +// super.drawScreen(mouseX, mouseY); +// } +} diff --git a/java/src/game/gui/container/GuiInventory.java b/java/src/game/gui/container/GuiInventory.java new file mode 100755 index 0000000..71a4473 --- /dev/null +++ b/java/src/game/gui/container/GuiInventory.java @@ -0,0 +1,58 @@ +package game.gui.container; + +import game.entity.npc.EntityNPC; + +public class GuiInventory extends GuiContainer +{ +// private final GuiCheat cheat; +// private float oldMouseX; +// private float oldMouseY; + + public GuiInventory(EntityNPC player) + { + super(player.inventoryContainer); +// this.allowUserInput = true; +// this.cheat = cheat; + } + +// public void updateScreen() +// { +// this.updateActivePotionEffects(); +// } + +// public void initGui() +// { +//// this.buttonList.clear(); +// super.initGui(); +// if(this.cheat != null) +// this.buttonList.add(new Button(1, this.guiLeft + this.xSize - 16, this.guiTop + 4, 12, 12, "X")); +// } + + public void drawGuiContainerForegroundLayer() + { + this.drawString("Handwerk", 86, 16); + } + +// public void drawScreen(int mouseX, int mouseY, float partialTicks) +// { +// super.drawScreen(mouseX, mouseY, partialTicks); +// this.oldMouseX = (float)mouseX; +// this.oldMouseY = (float)mouseY; +// } + +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(inventoryBackground); +// int i = this.guiLeft; +// int j = this.guiTop; +//// this.rect(i, j, 0, 0, this.xSize, this.ySize); +//// drawEntityOnScreen(i + 51, j + 75, 30, (float)(i + 51) - this.oldMouseX, (float)(j + 75 - 50) - this.oldMouseY, this.gm.thePlayer); +// } + +// public void actionPerformed(int button) +// { +// if(button == 1 && this.cheat != null && this.gm.thePlayer.inventory.getItemStack() == null) +// this.gm.displayGuiScreen(this.cheat); +// } +} diff --git a/java/src/game/gui/container/GuiMachine.java b/java/src/game/gui/container/GuiMachine.java new file mode 100755 index 0000000..cca3fda --- /dev/null +++ b/java/src/game/gui/container/GuiMachine.java @@ -0,0 +1,44 @@ +package game.gui.container; + +import game.Game; +import game.inventory.ContainerMachine; +import game.inventory.IInventory; +import game.inventory.InventoryPlayer; +import game.tileentity.TileEntityMachine; + + +public class GuiMachine extends GuiContainer +{ +// private final String texture; + private final IInventory playerInv; + private final IInventory machineInv; + private final TileEntityMachine machine; + + public GuiMachine(InventoryPlayer player, IInventory inv, TileEntityMachine machine) + { + super(new ContainerMachine(player, machine, inv, Game.getGame().thePlayer)); + this.playerInv = player; + this.machineInv = machine; +// this.allowUserInput = false; + this.ySize = 153; +// this.texture = "textures/gui/" + texture + ".png"; + this.machine = machine; + } + + public void drawGuiContainerForegroundLayer() + { + this.drawString(this.machine.getStatus().color + this.machineInv.getCommandName() + " - " + this.machine.getStatus().name, 8, 6); + this.drawString(this.playerInv.getCommandName(), 8, this.ySize - 96 + 2); + this.drawString(String.format("Temperatur: %d °", this.machine.getTemperature()), 8, 18); + this.drawString(this.machine.formatDisplay(), 8, 28); + } + +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(this.texture); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +//// this.rect(i, j, 0, 0, this.xSize, this.ySize); +// } +} diff --git a/java/src/game/gui/container/GuiMerchant.java b/java/src/game/gui/container/GuiMerchant.java new file mode 100755 index 0000000..e8e3f53 --- /dev/null +++ b/java/src/game/gui/container/GuiMerchant.java @@ -0,0 +1,286 @@ +package game.gui.container; + +import game.inventory.ContainerMerchant; +import game.inventory.InventoryPlayer; +import game.item.ItemStack; +import game.packet.CPacketAction; +import game.renderer.GlState; +import game.renderer.ItemRenderer; +import game.village.MerchantRecipe; +import game.village.MerchantRecipeList; +import game.window.WCF; +import game.world.World; + +public class GuiMerchant extends GuiContainer +{ +// private static final String MERCHANT_GUI_TEXTURE = "textures/gui/trading.png"; + + private int selectedMerchantRecipe; + private String chatComponent; + + public GuiMerchant(InventoryPlayer inv, String name, World worldIn) + { + super(new ContainerMerchant(inv, null, worldIn)); + this.chatComponent = name != null ? name : "NSC"; + } + + /** + * 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() +// { +// super.initGui(); +// } + + public void addButtons() { + super.addButtons(); + this.button(120 + 27, 24, 12, 16); + this.button(36 - 19, 24, 12, 16); + this.button(36 - 1, 24 - 1, 18, 18); + this.button(62 - 1, 24 - 1, 18, 18); + this.button(120 - 1, 24 - 1, 18, 18); + } + + public void mouseClicked(int mouseX, int mouseY, int mouseButton) + { + if (mouseButton == 0) + { +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; + if(mouseX >= 147 && mouseX < 147 + 12 && mouseY >= 24 && mouseY < 24 + 16) { + this.switchTrade(true); + return; + } + else if(mouseX >= 17 && mouseX < 17 + 12 && mouseY >= 24 && mouseY < 24 + 16) { + this.switchTrade(false); + return; + } +// this.buttonList.add(new Button(1, i + 120 + 27, j + 24 - 1, 12, 19, ">")); +// this.buttonList.add(new Button(2, i + 36 - 19, j + 24 - 1, 12, 19, "<")); + + } + + super.mouseClicked(mouseX, mouseY, mouseButton); + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { + String s = this.chatComponent; + this.drawString(s, 8, 6); + this.drawString("Inventar", 8, this.ySize - 96 + 2); + } + + public void drawOverlays() { + super.drawOverlays(); + MerchantRecipeList merchantrecipelist = this.getRecipes(); + if (merchantrecipelist != null && !merchantrecipelist.isEmpty()) { + int k = this.selectedMerchantRecipe; + MerchantRecipe merchantrecipe = (MerchantRecipe)merchantrecipelist.get(k); + ItemStack itemstack = merchantrecipe.getItemToBuy(); + ItemStack itemstack1 = merchantrecipe.getSecondItemToBuy(); + ItemStack itemstack2 = merchantrecipe.getItemToSell(); + this.renderItemOverlayIntoGUI(itemstack, 36, 24, null); + if(itemstack1 != null) + this.renderItemOverlayIntoGUI(itemstack1, 62, 24, null); + this.renderItemOverlayIntoGUI(itemstack2, 120, 24, null); + } + } + + /** + * Called by the controls from the buttonList when activated. (Mouse pressed for buttons) + */ + public void switchTrade(boolean forward) + { + boolean flag = false; + + if (forward) + { + ++this.selectedMerchantRecipe; + MerchantRecipeList merchantrecipelist = this.getRecipes(); + + if (merchantrecipelist != null && this.selectedMerchantRecipe >= merchantrecipelist.size()) + { + this.selectedMerchantRecipe = merchantrecipelist.size() - 1; + } + + flag = true; + } + else + { + --this.selectedMerchantRecipe; + + if (this.selectedMerchantRecipe < 0) + { + this.selectedMerchantRecipe = 0; + } + + flag = true; + } + + if (flag) + { + ((ContainerMerchant)this.inventorySlots).setCurrentRecipeIndex(this.selectedMerchantRecipe); +// PacketBuffer packetbuffer = new PacketBuffer(Unpooled.buffer()); +// packetbuffer.writeInt(this.selectedMerchantRecipe); + this.gm.getNetHandler().addToSendQueue(new CPacketAction(CPacketAction.Action.SELECT_TRADE, + this.selectedMerchantRecipe)); + } + } + +// /** +// * Args : renderPartialTicks, mouseX, mouseY +// */ +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(MERCHANT_GUI_TEXTURE); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +//// this.rect(i, j, 0, 0, this.xSize, this.ySize); +//// MerchantRecipeList merchantrecipelist = this.merchant.getRecipes(this.gm.thePlayer); +// +//// if (merchantrecipelist != null && !merchantrecipelist.isEmpty()) +//// { +//// int k = this.selectedMerchantRecipe; +//// +//// if (k < 0 || k >= merchantrecipelist.size()) +//// { +//// return; +//// } +// +//// MerchantRecipe merchantrecipe = (MerchantRecipe)merchantrecipelist.get(k); +// +//// if (merchantrecipe.isRecipeDisabled()) +//// { +//// this.gm.getTextureManager().bindTexture(MERCHANT_GUI_TEXTURE); +//// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +//// GlState.disableLighting(); +//// this.rect(this.guiLeft + 83, this.guiTop + 21, 212, 0, 28, 21); +//// this.rect(this.guiLeft + 83, this.guiTop + 51, 212, 0, 28, 21); +//// } +//// } +// } + + /** + * Draws the screen and all the components in it. Args : mouseX, mouseY, renderPartialTicks + */ + public void drawScreen(int mouseX, int mouseY) + { + super.drawScreen(mouseX, mouseY); + MerchantRecipeList merchantrecipelist = this.getRecipes(); + + if (merchantrecipelist != null && !merchantrecipelist.isEmpty()) + { +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; + int k = this.selectedMerchantRecipe; + MerchantRecipe merchantrecipe = (MerchantRecipe)merchantrecipelist.get(k); + ItemStack itemstack = merchantrecipe.getItemToBuy(); + ItemStack itemstack1 = merchantrecipe.getSecondItemToBuy(); + ItemStack itemstack2 = merchantrecipe.getItemToSell(); + WCF.glPushMatrix(); + ItemRenderer.enableGUIStandardItemLighting(); + GlState.disableLighting(); + GlState.enableRescaleNormal(); + GlState.enableColorMaterial(); + GlState.enableLighting(); + this.itemRender.zLevel = 100.0F; + this.itemRender.renderItemAndEffectIntoGUI(itemstack, 36, 24); +// this.itemRender.renderItemOverlays(itemstack, 36, 24); + + if (itemstack1 != null) + { + this.itemRender.renderItemAndEffectIntoGUI(itemstack1, 62, 24); +// this.itemRender.renderItemOverlays(itemstack1, 62, 24); + } + + this.itemRender.renderItemAndEffectIntoGUI(itemstack2, 120, 24); +// this.itemRender.renderItemOverlays(itemstack2, 120, 24); + this.itemRender.zLevel = 0.0F; + GlState.disableLighting(); + + if (this.isPointInRegion(36, 24, 16, 16, mouseX, mouseY) && itemstack != null) + { + this.renderToolTip(itemstack, mouseX, mouseY); + } + else if (itemstack1 != null && this.isPointInRegion(62, 24, 16, 16, mouseX, mouseY) && itemstack1 != null) + { + this.renderToolTip(itemstack1, mouseX, mouseY); + } + else if (itemstack2 != null && this.isPointInRegion(120, 24, 16, 16, mouseX, mouseY) && itemstack2 != null) + { + this.renderToolTip(itemstack2, mouseX, mouseY); + } +// else if (merchantrecipe.isRecipeDisabled() && (this.isPointInRegion(83, 21, 28, 21, mouseX, mouseY) || this.isPointInRegion(83, 51, 28, 21, mouseX, mouseY))) +// { +// this.drawCreativeTabHoveringText(I18n.format("merchant.deprecated"), mouseX, mouseY); +// } + + WCF.glPopMatrix(); + GlState.enableLighting(); + GlState.enableDepth(); + ItemRenderer.enableStandardItemLighting(); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +// if(mouseX >= i + 147 && mouseX < i + 147 + 12 && mouseY >= j + 23 && mouseX < j + 23 + 19) { +// SKC.highlight(i + 147, j + 23, 12, 19); +// } +// else if(mouseX >= i + 17 && mouseX < i + 17 + 12 && mouseY >= j + 23 && mouseX < j + 23 + 19) { +// SKC.highlight(i + 17, j + 23, 12, 19); +// } + } + } + + public void setRecipes(MerchantRecipeList recipes) + { + ((ContainerMerchant)this.inventorySlots).getMerchantInventory().setRecipes(recipes); + } + + private MerchantRecipeList getRecipes() + { + return ((ContainerMerchant)this.inventorySlots).getMerchantInventory().getRecipes(); + } + +// static class MerchantButton extends Button +// { +// private final boolean next; +// +// public MerchantButton(int buttonID, int x, int y, boolean isNext) +// { +// super(buttonID, x, y, 12, 19, ""); +// this.next = isNext; +// } +// +// public void drawButton(Game gm, int mouseX, int mouseY) +// { +// if (this.visible) +// { +// gm.getTextureManager().bindTexture(GuiMerchant.MERCHANT_GUI_TEXTURE); +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// boolean flag = mouseX >= this.xPosition && mouseY >= this.yPosition && mouseX < this.xPosition + this.width && mouseY < this.yPosition + this.height; +// int i = 0; +// int j = 176; +// +// if (!this.enabled) +// { +// j += this.width * 2; +// } +// else if (flag) +// { +// j += this.width; +// } +// +// if (!this.next) +// { +// i += this.height; +// } +// +// this.rect(this.xPosition, this.yPosition, j, i, this.width, this.height); +// } +// } +// } +} diff --git a/java/src/game/gui/container/GuiRepair.java b/java/src/game/gui/container/GuiRepair.java new file mode 100755 index 0000000..c8e1ba4 --- /dev/null +++ b/java/src/game/gui/container/GuiRepair.java @@ -0,0 +1,218 @@ +package game.gui.container; + +import java.util.List; + +import game.Game; +import game.inventory.Container; +import game.inventory.ContainerRepair; +import game.inventory.ICrafting; +import game.inventory.IInventory; +import game.inventory.InventoryPlayer; +import game.item.ItemStack; +import game.world.World; + +public class GuiRepair extends GuiContainer implements ICrafting +{ +// private static final String anvilResource = "textures/gui/anvil.png"; + + private ContainerRepair anvil; +// private TextField nameField; + private InventoryPlayer playerInventory; + + public GuiRepair(InventoryPlayer inventoryIn, World worldIn) + { + super(new ContainerRepair(inventoryIn, worldIn, Game.getGame().thePlayer)); + this.playerInventory = inventoryIn; + this.anvil = (ContainerRepair)this.inventorySlots; + } + + /** + * 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() + { + super.initGui(); +// Keyboard.enableRepeatEvents(true); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +// this.nameField = new TextField(i + 62, j + 24, 103, 12); +// this.nameField.setTextColor(-1); +// this.nameField.setDisabledTextColour(-1); +// this.nameField.setEnableBackgroundDrawing(false); +// this.nameField.setMaxStringLength(30); + this.inventorySlots.removeCraftingFromCrafters(this); + this.inventorySlots.onCraftGuiOpened(this); + } + + /** + * Called when the screen is unloaded. Used to disable keyboard repeat events + */ + public void onGuiClosed() + { + super.onGuiClosed(); +// Keyboard.enableRepeatEvents(false); + this.inventorySlots.removeCraftingFromCrafters(this); + } + + /** + * Draw the foreground layer for the GuiContainer (everything in front of the items). Args : mouseX, mouseY + */ + public void drawGuiContainerForegroundLayer() + { +// GlState.disableLighting(); +// GlState.disableBlend(); + this.drawString("Amboss", 60, 6); + + if (this.anvil.maximumCost > 0) + { + int i = 8453920; + boolean flag = true; + String s = String.format("Erfahrungskosten: %d", this.anvil.maximumCost); + + if (this.anvil.maximumCost >= 40) // && !this.gm.thePlayer.creative) + { + s = "Zu teuer!"; + i = 16736352; + } + else if (!this.anvil.getSlot(2).getHasStack()) + { + flag = false; + } + else if (!this.anvil.getSlot(2).canTakeStack(this.playerInventory.player)) + { + i = 16736352; + } + + if (flag) + { + int j = -16777216 | (i & 16579836) >> 2 | i & -16777216; + int k = this.xSize - 8 - this.getStringWidth(s); + int l = 67; + +// if (FontRenderer.getUnicodeFlag()) +// { +// drawRect(k - 3, l - 2, this.xSize - 7, l + 10, -16777216); +// drawRect(k - 2, l - 1, this.xSize - 8, l + 9, -12895429); +// } +// else +// { + this.drawString(s, k, l + 1); + this.drawString(s, k + 1, l); + this.drawString(s, k + 1, l + 1); +// } + + this.drawString(s, k, l); + } + } + +// GlState.enableLighting(); + } + + /** + * 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 (this.nameField.textboxKeyTyped(typedChar, keyCode)) +//// { +// this.renameItem(); +//// } +//// else +//// { +//// super.keyTyped(typedChar, keyCode); +//// } +// } +// +// private void renameItem() +// { +// String s = this.nameField.getText(); +// Slot slot = this.anvil.getSlot(0); +// +// if (slot != null && slot.getHasStack() && !slot.getStack().hasDisplayName() && s.equals(slot.getStack().getDisplayName())) +// { +// s = ""; +// } +// +// this.anvil.updateItemName(s); +// this.gm.thePlayer.sendQueue.addToSendQueue(new CPacketMessage(CPacketMessage.Type.ITEM, s)); +// } +// +// /** +// * Called when the mouse is clicked. Args : mouseX, mouseY, clickedButton +// */ +// protected void mouseClicked(int mouseX, int mouseY, int mouseButton) +// { +// super.mouseClicked(mouseX, mouseY, mouseButton); +// this.nameField.mouseClicked(mouseX, mouseY, mouseButton); +// } + + /** + * Draws the screen and all the components in it. Args : mouseX, mouseY, renderPartialTicks + */ +// public void drawScreen(int mouseX, int mouseY, float partialTicks) +// { +// super.drawScreen(mouseX, mouseY, partialTicks); +// GlState.disableLighting(); +// GlState.disableBlend(); +// this.nameField.drawTextBox(); +// } + +// /** +// * Args : renderPartialTicks, mouseX, mouseY +// */ +// protected void drawGuiContainerBackgroundLayer(int mouseX, int mouseY) +// { +// GlState.color(1.0F, 1.0F, 1.0F, 1.0F); +// this.gm.getTextureManager().bindTexture(anvilResource); +// int i = (this.width - this.xSize) / 2; +// int j = (this.height - this.ySize) / 2; +//// this.rect(i, j, 0, 0, this.xSize, this.ySize); +//// this.rect(i + 59, j + 20, 0, this.ySize + (this.anvil.getSlot(0).getHasStack() ? 0 : 16), 110, 16); +// +//// if ((this.anvil.getSlot(0).getHasStack() || this.anvil.getSlot(1).getHasStack()) && !this.anvil.getSlot(2).getHasStack()) +//// { +//// this.rect(i + 99, j + 45, this.xSize, 0, 28, 21); +//// } +// } + + /** + * update the crafting window inventory with the items in the list + */ + public void updateCraftingInventory(Container containerToSend, List itemsList) + { + this.sendSlotContents(containerToSend, 0, containerToSend.getSlot(0).getStack()); + } + + /** + * Sends the contents of an inventory slot to the client-side Container. This doesn't have to match the actual + * contents of that slot. Args: Container, slot number, slot contents + */ + public void sendSlotContents(Container containerToSend, int slotInd, ItemStack stack) + { +// if (slotInd == 0) +// { +// this.nameField.setText(stack == null ? "" : stack.getDisplayName()); +// this.nameField.setEnabled(stack != null); +// +// if (stack != null) +// { +// this.renameItem(); +// } +// } + } + + /** + * Sends two ints to the client-side Container. Used for furnace burning time, smelting progress, brewing progress, + * and enchanting level. Normally the first int identifies which variable to update, and the second contains the new + * value. Both are truncated to shorts in non-local SMP. + */ + public void sendProgressBarUpdate(Container containerIn, int varToUpdate, int newValue) + { + } + + public void sendAllWindowProperties(Container p_175173_1_, IInventory p_175173_2_) + { + } +}