Files
CustomNPC-Plus/src/main/java/noppes/npcs/client/gui/util/GuiNPCInterface.java
T

713 lines
25 KiB
Java

package noppes.npcs.client.gui.util;
import net.minecraft.client.Minecraft;
import net.minecraft.client.entity.EntityClientPlayerMP;
import net.minecraft.client.gui.FontRenderer;
import net.minecraft.client.gui.GuiButton;
import net.minecraft.client.gui.GuiScreen;
import net.minecraft.client.renderer.OpenGlHelper;
import net.minecraft.client.renderer.RenderHelper;
import net.minecraft.client.renderer.entity.RenderManager;
import net.minecraft.entity.EntityLivingBase;
import net.minecraft.util.ResourceLocation;
import net.minecraft.util.StatCollector;
import net.minecraftforge.client.event.GuiScreenEvent;
import net.minecraftforge.common.MinecraftForge;
import noppes.npcs.client.ClientEventHandler;
import noppes.npcs.client.CustomNpcResourceListener;
import noppes.npcs.client.TextBlockClient;
import noppes.npcs.entity.EntityNPCInterface;
import org.lwjgl.input.Keyboard;
import org.lwjgl.input.Mouse;
import org.lwjgl.opengl.GL11;
import org.lwjgl.opengl.GL12;
import java.net.URI;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.function.Consumer;
import java.util.function.Supplier;
public abstract class GuiNPCInterface extends GuiScreen {
public EntityClientPlayerMP player;
public boolean drawDefaultBackground = true;
public EntityNPCInterface npc;
protected HashMap<Integer, GuiNpcButton> buttons = new HashMap<Integer, GuiNpcButton>();
protected HashMap<Integer, GuiMenuTopButton> topbuttons = new HashMap<Integer, GuiMenuTopButton>();
protected HashMap<Integer, GuiMenuSideButton> sidebuttons = new HashMap<Integer, GuiMenuSideButton>();
protected HashMap<Integer, GuiNpcTextField> textfields = new HashMap<Integer, GuiNpcTextField>();
protected HashMap<Integer, GuiNpcLabel> labels = new HashMap<Integer, GuiNpcLabel>();
protected HashMap<Integer, GuiCustomScroll> scrolls = new HashMap<Integer, GuiCustomScroll>();
protected HashMap<Integer, GuiNpcSlider> sliders = new HashMap<Integer, GuiNpcSlider>();
protected HashMap<Integer, GuiScreen> extra = new HashMap<Integer, GuiScreen>();
protected HashMap<Integer, GuiScrollWindow> scrollWindows = new HashMap<>();
protected HashMap<Integer, GuiDiagram> diagrams = new HashMap<>();
public static boolean resizingActive = false;
public String title;
private ResourceLocation background = null;
public boolean closeOnEsc = false;
public Supplier<Boolean> closeOnEscSupplier = null;
public int guiLeft, guiTop, xSize, ySize;
private SubGuiInterface subgui;
private Consumer<SubGuiInterface> pendingSubGuiResult;
public int mouseX, mouseY, mouseScroll;
public float bgScale = 1;
public float bgScaleX = 1;
public float bgScaleY = 1;
public float bgScaleZ = 1;
public int bgTextureHeight = 256; // Actual content height in texture (for bottom border stitching)
public GuiNPCInterface(EntityNPCInterface npc) {
this.player = Minecraft.getMinecraft().thePlayer;
this.npc = npc;
title = "";
xSize = 200;
ySize = 222;
}
public GuiNPCInterface() {
this(null);
}
public void setBackground(String texture) {
background = new ResourceLocation("customnpcs", "textures/gui/" + texture);
}
public void setBackground(String texture, int textureHeight) {
background = new ResourceLocation("customnpcs", "textures/gui/" + texture);
bgTextureHeight = textureHeight;
}
public ResourceLocation getResource(String texture) {
return new ResourceLocation("customnpcs", "textures/gui/" + texture);
}
@Override
public void initGui() {
super.initGui();
GuiNpcTextField.unfocus();
if (subgui != null) {
subgui.setWorldAndResolution(mc, width, height);
subgui.initGui();
}
guiLeft = (width - xSize) / 2;
guiTop = (height - ySize) / 2;
buttonList.clear();
labels.clear();
textfields.clear();
buttons.clear();
sidebuttons.clear();
topbuttons.clear();
scrolls.clear();
sliders.clear();
scrollWindows.clear();
diagrams.clear();
Keyboard.enableRepeatEvents(true);
if (drawRenderButtons) {
zoomIn = new GuiNpcButton(0, guiLeft + xOffsetNpc + xOffsetButton, guiTop + yOffsetNpc + yOffsetButton, 20, 20, "-");
zoomOut = new GuiNpcButton(0, guiLeft + 22 + xOffsetNpc + xOffsetButton, guiTop + yOffsetNpc + yOffsetButton, 20, 20, "+");
rotateLeft = new GuiNpcButton(0, guiLeft + 44 + xOffsetNpc + xOffsetButton, guiTop + yOffsetNpc + yOffsetButton, 20, 20, "<");
rotateRight = new GuiNpcButton(0, guiLeft + 66 + xOffsetNpc + xOffsetButton, guiTop + yOffsetNpc + yOffsetButton, 20, 20, ">");
}
//Important for GuiScriptTextArea
for (GuiNpcTextField tf : textfields.values())
tf.initGui();
}
@Override
public void updateScreen() {
if (subgui != null)
subgui.updateScreen();
else {
for (GuiNpcTextField tf : textfields.values()) {
if (tf.enabled)
tf.updateCursorCounter();
}
super.updateScreen();
}
}
public void addExtra(GuiHoverText gui) {
gui.setWorldAndResolution(mc, 350, 250);
extra.put(gui.id, gui);
}
public void addScrollableGui(int id, GuiScrollWindow gui) {
gui.setWorldAndResolution(mc, width, height);
gui.initGui();
scrollWindows.put(id, gui);
}
/**
* Adds a GuiDiagram to the interface.
* The diagram is initialized with the current resolution and cached.
*/
public void addDiagram(int id, GuiDiagram diagram) {
diagram.invalidateCache();
diagrams.put(id, diagram);
}
public GuiDiagram getDiagram(int id) {
return diagrams.get(id);
}
public void mouseClicked(int i, int j, int k) {
if (subgui != null)
subgui.mouseClicked(i, j, k);
else {
for (GuiNpcTextField tf : new ArrayList<GuiNpcTextField>(textfields.values()))
if (tf.enabled)
tf.mouseClicked(i, j, k);
for (GuiScrollWindow guiScrollableComponent : scrollWindows.values()) {
guiScrollableComponent.mouseClicked(i, j, k);
}
if (k == 0) {
for (GuiCustomScroll scroll : new ArrayList<GuiCustomScroll>(scrolls.values())) {
scroll.mouseClicked(i, j, k);
}
}
// Process diagram mouse clicks
for (GuiDiagram diagram : diagrams.values()) {
if (diagram.isWithin(i, j)) {
if (diagram.mouseClicked(i, j, k))
return;
}
}
mouseEvent(i, j, k);
vanillaMouseClicked(i, j, k);
}
}
protected void vanillaMouseClicked(int mouseX, int mouseY, int mouseButton) {
if (mouseButton == 0 || mouseButton == 1) {
for (int l = 0; l < this.buttonList.size(); ++l) {
GuiButton guibutton = (GuiButton) this.buttonList.get(l);
AtomicBoolean rightClicked = null;
if (mouseButton == 1) {
if (guibutton instanceof GuiNpcButton && ((GuiNpcButton) guibutton).rightClickable) {
rightClicked = ((GuiNpcButton) guibutton).rightClicked;
rightClicked.set(true);
} else
continue;
}
if (guibutton.mousePressed(this.mc, mouseX, mouseY)) {
GuiScreenEvent.ActionPerformedEvent.Pre event = new GuiScreenEvent.ActionPerformedEvent.Pre(this, guibutton, this.buttonList);
if (MinecraftForge.EVENT_BUS.post(event))
break;
this.selectedButton = event.button;
event.button.func_146113_a(this.mc.getSoundHandler());
this.actionPerformed(event.button);
if (this.equals(this.mc.currentScreen))
MinecraftForge.EVENT_BUS.post(new GuiScreenEvent.ActionPerformedEvent.Post(this, event.button, this.buttonList));
}
if (rightClicked != null)
rightClicked.set(false);
}
}
}
@Override
public void mouseClickMove(int mouseX, int mouseY, int clickedMouseButton, long timeSinceLastClick) {
if (subgui != null) {
subgui.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick);
return;
}
super.mouseClickMove(mouseX, mouseY, clickedMouseButton, timeSinceLastClick);
}
@Override
protected void mouseMovedOrUp(int mouseX, int mouseY, int state) {
if (subgui != null) {
subgui.mouseMovedOrUp(mouseX, mouseY, state);
return;
}
super.mouseMovedOrUp(mouseX, mouseY, state);
}
public void mouseEvent(int i, int j, int k) {
}
@Override
protected void actionPerformed(GuiButton guibutton) {
if (subgui != null)
subgui.buttonEvent(guibutton);
else {
buttonEvent(guibutton);
}
}
public void buttonEvent(GuiButton guibutton) {
}
@Override
public void keyTyped(char c, int i) {
/*
Fixes closing sub with escape closes all of its parents.
The outermost GUI (root of all subs) closes the deepest open sub on ESC.
*/
boolean isSub = this instanceof SubGuiInterface;
boolean shouldClose = closeOnEsc;
if (closeOnEscSupplier != null) {
try {
shouldClose = closeOnEscSupplier.get();
} catch (Exception ignored) {
}
}
if (shouldClose && !isSub && (i == 1 || (!GuiNpcTextField.isFieldActive() && isInventoryKey(i)))) {
SubGuiInterface sub = getSubGui();
if (sub != null)
sub.close();
else
close();
}
if (subgui != null)
subgui.keyTyped(c, i);
for (GuiNpcTextField tf : textfields.values())
tf.textboxKeyTyped(c, i);
for (GuiScrollWindow guiScrollableComponent : scrollWindows.values()) {
guiScrollableComponent.keyTyped(c, i);
}
}
public void onGuiClosed() {
GuiNpcTextField.unfocus();
}
public void closeOnEsc(Supplier<Boolean> close) {
this.closeOnEscSupplier = close;
}
public void close() {
if (GuiNpcTextField.activeTextfield != null)
GuiNpcTextField.unfocus();
Keyboard.enableRepeatEvents(false);
displayGuiScreen(null);
mc.setIngameFocus();
save();
}
public void addButton(GuiNpcButton button) {
buttons.put(button.id, button);
buttonList.add(button);
}
public void addTopButton(GuiMenuTopButton button) {
topbuttons.put(button.id, button);
buttonList.add(button);
}
public void addSideButton(GuiMenuSideButton button) {
sidebuttons.put(button.id, button);
buttonList.add(button);
}
public GuiNpcButton getButton(int i) {
return buttons.get(i);
}
public GuiMenuSideButton getSideButton(int i) {
return sidebuttons.get(i);
}
public GuiMenuTopButton getTopButton(int i) {
return topbuttons.get(i);
}
public void addTextField(GuiNpcTextField tf) {
textfields.put(tf.id, tf);
}
public GuiNpcTextField getTextField(int i) {
return textfields.get(i);
}
public void addLabel(GuiNpcLabel label) {
labels.put(label.id, label);
}
public GuiNpcLabel getLabel(int i) {
return labels.get(i);
}
public GuiScrollWindow getScrollableGui(int i) {
return scrollWindows.get(i);
}
public void addSlider(GuiNpcSlider slider) {
sliders.put(slider.id, slider);
buttonList.add(slider);
}
public GuiNpcSlider getSlider(int i) {
return sliders.get(i);
}
public void addScroll(GuiCustomScroll scroll) {
scroll.setWorldAndResolution(mc, 350, 250);
scrolls.put(scroll.id, scroll);
}
public GuiCustomScroll getScroll(int id) {
return scrolls.get(id);
}
public abstract void save();
@Override
public void drawScreen(int i, int j, float f) {
mouseX = i;
mouseY = j;
if (drawDefaultBackground && subgui == null)
drawDefaultBackground();
if (background != null && mc.renderEngine != null) {
drawBackground();
}
boolean subGui = hasSubGui();
drawCenteredString(fontRendererObj, title, width / 2, guiTop + 4, 0xffffff);
for (GuiNpcLabel label : labels.values())
label.drawLabel(this, fontRendererObj);
for (GuiNpcTextField tf : textfields.values()) {
tf.drawTextBox(i, j);
}
for (GuiCustomScroll scroll : scrolls.values()) {
scroll.updateSubGUI(subGui);
scroll.drawScreen(i, j, f, !subGui && scroll.isMouseOver(i, j) ? Mouse.getDWheel() : 0);
}
// Draw scrollable windows.
for (GuiScrollWindow guiScrollableComponent : scrollWindows.values()) {
guiScrollableComponent.drawScreen(i, j, f, !subGui && guiScrollableComponent.isMouseOver(i, j) ? Mouse.getDWheel() : 0);
}
for (GuiDiagram diagram : diagrams.values()) {
diagram.drawDiagram(i, j, subGui);
}
super.drawScreen(i, j, f);
for (GuiCustomScroll scroll : scrolls.values())
if (scroll.hoverableText) {
scroll.drawHover(i, j);
}
for (GuiNpcButton button : buttons.values()) {
button.updateSubGUI(subGui);
if (!button.hoverableText.isEmpty()) {
button.drawHover(i, j, subGui);
}
}
for (GuiNpcTextField textField : textfields.values()) {
if (textField.hasHoverText()) {
textField.drawHover(i, j, subGui);
}
}
for (GuiScreen gui : extra.values())
gui.drawScreen(i, j, f);
if (subgui != null) {
subgui.drawScreen(i, j, f);
}
if (drawNpc)
drawNpcWithExtras(npc, i, j, f);
}
protected void drawBackground() {
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glPushMatrix();
GL11.glTranslatef(guiLeft, guiTop, 0);
GL11.glScalef(bgScale * bgScaleX, bgScale * bgScaleY, bgScale * bgScaleZ);
mc.renderEngine.bindTexture(background);
// Handle Y dimension: if ySize < texture content height, stitch bottom border
int topHeight = ySize;
int bottomHeight = 0;
int bottomTextureV = 0;
if (ySize < bgTextureHeight) {
bottomHeight = -1;
topHeight = ySize - bottomHeight;
bottomTextureV = bgTextureHeight - bottomHeight;
}
if (xSize > 256) {
// GUI wider than texture: draw left portion, then right portion from texture edge
drawTexturedModalRect(0, 0, 0, 0, 250, topHeight);
drawTexturedModalRect(250, 0, 256 - (xSize - 250), 0, xSize - 250, topHeight);
if (bottomHeight > 0) {
drawTexturedModalRect(0, topHeight, 0, bottomTextureV, 250, bottomHeight);
drawTexturedModalRect(250, topHeight, 256 - (xSize - 250), bottomTextureV, xSize - 250, bottomHeight);
}
} else if (xSize < 256) {
// GUI narrower than texture: stitch left and right edges together
int leftWidth = xSize / 2;
int rightWidth = xSize - leftWidth;
// Draw top portion
drawTexturedModalRect(0, 0, 0, 0, leftWidth, topHeight);
drawTexturedModalRect(leftWidth, 0, 256 - rightWidth, 0, rightWidth, topHeight);
// Draw bottom border strip
if (bottomHeight > 0) {
drawTexturedModalRect(0, topHeight, 0, bottomTextureV, leftWidth, bottomHeight);
drawTexturedModalRect(leftWidth, topHeight, 256 - rightWidth, bottomTextureV, rightWidth, bottomHeight);
}
} else {
// GUI exactly 256px wide
drawTexturedModalRect(0, 0, 0, 0, xSize, topHeight);
if (bottomHeight > 0) {
drawTexturedModalRect(0, topHeight, 0, bottomTextureV, xSize, bottomHeight);
}
}
GL11.glPopMatrix();
}
protected void drawTextBlock(String text, int x, int y, int lineWidth) {
TextBlockClient block = new TextBlockClient(StatCollector.translateToLocal(text), lineWidth, true, player);
for (int line = 0; line < block.lines.size(); line++) {
String lineText = block.lines.get(line).getFormattedText();
fontRendererObj.drawString(lineText, x, y + (line * fontRendererObj.FONT_HEIGHT), CustomNpcResourceListener.DefaultTextColor);
}
}
public FontRenderer getFontRenderer() {
return this.fontRendererObj;
}
public void elementClicked() {
if (subgui != null)
subgui.elementClicked();
}
@Override
public boolean doesGuiPauseGame() {
return false;
}
public void doubleClicked() {
}
public boolean isInventoryKey(int i) {
return i == mc.gameSettings.keyBindInventory.getKeyCode(); // inventory key
}
@Override
public void drawDefaultBackground() {
super.drawDefaultBackground();
}
public void displayGuiScreen(GuiScreen gui) {
mc.displayGuiScreen(gui);
}
public void setSubGui(SubGuiInterface gui) {
subgui = gui;
subgui.setWorldAndResolution(mc, width, height);
subgui.parent = this;
initGui();
}
/**
* Open a sub-gui with a result handler that will be called when the sub-gui closes.
* The handler survives initGui() rebuilds since it lives on the parent, not the builder.
*/
public void setSubGuiWithResult(SubGuiInterface gui, Consumer<SubGuiInterface> resultHandler) {
this.pendingSubGuiResult = resultHandler;
setSubGui(gui);
}
public void closeSubGui(SubGuiInterface gui) {
if (pendingSubGuiResult != null) {
Consumer<SubGuiInterface> handler = pendingSubGuiResult;
pendingSubGuiResult = null;
handler.accept(gui);
}
// Only null out subgui if it wasn't replaced by a new one during subGuiClosed
if (subgui == gui) {
subgui = null;
}
initGui();
}
public boolean hasSubGui() {
return subgui != null;
}
/**
* @return The deepest open subgui
*/
public SubGuiInterface getSubGui() {
SubGuiInterface sub = subgui;
if (sub != null)
while (sub.hasSubGui())
sub = sub.getSubGui();
return sub;
}
private GuiNpcButton rotateLeft, rotateRight, zoomOut, zoomIn;
public int xOffsetNpc = 0, xOffsetButton = 0, xMouseRange = 50;
public int yOffsetNpc = 0, yOffsetButton = 0, yMouseRange = 150;
public float defaultZoom = 1, zoom = 1, rotation;
public float minZoom = 1, maxZoom = 2.5f;
public boolean followMouse = true, allowRotate = true, drawNPConSub;
public boolean drawNpc, drawRenderButtons;
public boolean isMouseOverRenderer(int x, int y) {
if (!allowRotate) {
return false;
}
// Center of the entity rendering
int centerX = guiLeft + xOffsetNpc; // Matches l in drawScreen()
int centerY = guiTop + yOffsetNpc; // Matches i1 in drawScreen()
// Range from the center to start considering mouse is over renderer.
int xRange = xMouseRange; // Horizontal range (Left and right of center)
int yRange = yMouseRange; // Vertical range (Up and down of center)
// Check if the mouse is within the range area
return mouseX >= centerX - xRange && mouseX <= centerX + xRange && mouseY >= centerY - yRange && mouseY <= centerY + yRange;
}
public void drawNpcWithExtras(EntityLivingBase entity, int mouseX, int mouseY, float partialTicks) {
drawNpc(entity, mouseX, mouseY, partialTicks);
}
public void drawNpc(EntityLivingBase entity, int mouseX, int mouseY, float partialTicks) {
if (hasSubGui() && !drawNPConSub)
return;
if (drawRenderButtons) {
rotateLeft.drawButton(mc, mouseX, mouseY);
rotateRight.drawButton(mc, mouseX, mouseY);
zoomOut.drawButton(mc, mouseX, mouseY);
zoomIn.drawButton(mc, mouseX, mouseY);
}
if (Mouse.isButtonDown(0) && drawRenderButtons) {
if (this.rotateLeft.mousePressed(this.mc, mouseX, mouseY)) {
rotation += partialTicks * 1.5F;
} else if (this.rotateRight.mousePressed(this.mc, mouseX, mouseY)) {
rotation -= partialTicks * 1.5F;
} else if (this.zoomOut.mousePressed(this.mc, mouseX, mouseY) && zoom < maxZoom) {
zoom += partialTicks * 0.05F;
} else if (this.zoomIn.mousePressed(this.mc, mouseX, mouseY) && zoom > minZoom) {
zoom -= partialTicks * 0.05F;
}
}
if (isMouseOverRenderer(mouseX, mouseY)) {
zoom += Mouse.getDWheel() * 0.001f;
if (Mouse.isButtonDown(0)) {
rotation -= Mouse.getDX() * 0.75f;
} else if (Mouse.isButtonDown(1)) {
rotation = 0;
zoom = defaultZoom;
}
}
if (zoom > maxZoom)
zoom = maxZoom;
if (zoom < minZoom)
zoom = minZoom;
drawNpc(entity, mouseX, mouseY, xOffsetNpc, yOffsetNpc, zoom, rotation, partialTicks);
}
public void drawNpc(EntityLivingBase entity, int mouseX, int mouseY, int x, int y, float zoomed, float rotation, float partialTicks) {
EntityNPCInterface npc = null;
if (entity instanceof EntityNPCInterface)
npc = (EntityNPCInterface) entity;
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
if (npc != null)
npc.isDrawn = true;
GL11.glEnable(GL11.GL_COLOR_MATERIAL);
GL11.glPushMatrix();
GL11.glTranslatef(guiLeft + x, guiTop + y, 90F);
float scale = 1;
if (entity.height > 2.4)
scale = 2 / entity.height;
GL11.glScalef(-30 * scale * zoomed, 30 * scale * zoomed, 30 * scale * zoomed);
GL11.glRotatef(180F, 0.0F, 0.0F, 1.0F);
float f2 = entity.renderYawOffset;
float f3 = entity.rotationYaw;
float f4 = entity.rotationPitch;
float f7 = entity.rotationYawHead;
float f5 = (float) (guiLeft + x) - mouseX;
float f6 = (guiTop + y) - 50 * scale * zoomed - mouseY;
int orientation = 0;
if (npc != null) {
orientation = npc.ais.orientation;
npc.ais.orientation = (int) rotation;
}
GL11.glRotatef(135F, 0.0F, 1.0F, 0.0F);
RenderHelper.enableStandardItemLighting();
GL11.glRotatef(-135F, 0.0F, 1.0F, 0.0F);
GL11.glRotatef(-(float) Math.atan(f6 / 400F) * 20F, 1.0F, 0.0F, 0.0F);
entity.renderYawOffset = rotation;
entity.rotationYaw = followMouse ? (float) Math.atan(f5 / 80F) * 40F + rotation : 0;
entity.rotationPitch = followMouse ? -(float) Math.atan(f6 / 40F) * 20F : 0;
entity.rotationYawHead = entity.rotationYaw;
GL11.glTranslatef(0.0F, entity.yOffset, 0.0F);
RenderManager.instance.playerViewY = 180F;
ClientEventHandler.renderingEntityInGUI = true;
try {
RenderManager.instance.renderEntityWithPosYaw(entity, 0, 0, 0, 0, 1);
} catch (Exception e) {
}
ClientEventHandler.renderingEntityInGUI = false;
entity.prevRenderYawOffset = entity.renderYawOffset = f2;
entity.prevRotationYaw = entity.rotationYaw = f3;
entity.prevRotationPitch = entity.rotationPitch = f4;
entity.prevRotationYawHead = entity.rotationYawHead = f7;
if (npc != null) {
npc.ais.orientation = orientation;
}
GL11.glPopMatrix();
RenderHelper.disableStandardItemLighting();
GL11.glDisable(GL12.GL_RESCALE_NORMAL);
if (npc != null)
npc.isDrawn = false;
OpenGlHelper.setActiveTexture(OpenGlHelper.lightmapTexUnit);
GL11.glDisable(GL11.GL_TEXTURE_2D);
OpenGlHelper.setActiveTexture(OpenGlHelper.defaultTexUnit);
}
public void renderHoveringText(List textLines, int x, int y, FontRenderer font) {
this.drawHoveringText(textLines, x, y, font);
}
public void openLink(String link) {
try {
Class oclass = Class.forName("java.awt.Desktop");
Object object = oclass.getMethod("getDesktop", new Class[0]).invoke(null);
oclass.getMethod("browse", new Class[]{URI.class}).invoke(object, new URI(link));
} catch (Throwable throwable) {
}
}
}