Merge branch 'master' of C:\Users\Lorenz\IdeaProjects\SkyHanni with conflicts.

1 files changed, 353 insertions, 0 deletions

diff --git a/src/main/java/at/hannibal2/skyhanni/test/GriffinJavaUtils.java b/src/main/java/at/hannibal2/skyhanni/test/GriffinJavaUtils.java
new file mode 100644
index 000000000..431cfbe6f
--- /dev/null
+++ b/src/main/java/at/hannibal2/skyhanni/test/GriffinJavaUtils.java
@@ -0,0 +1,353 @@
+package at.hannibal2.skyhanni.test;
+
+import at.hannibal2.skyhanni.utils.LorenzVec;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.WorldRenderer;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.AxisAlignedBB;
+import org.lwjgl.opengl.GL11;
+
+import java.awt.*;
+import java.text.DecimalFormat;
+import java.util.*;
+import java.util.List;
+import java.util.function.Function;
+
+public class GriffinJavaUtils {
+    public static <T> void permute(ArrayList<ArrayList<T>> result, T[] a, int k) {
+        if (k == a.length) {
+            ArrayList<T> subResult = new ArrayList<>();
+            result.add(subResult);
+            Collections.addAll(subResult, a);
+        } else {
+            for (int i = k; i < a.length; i++) {
+                T temp = a[k];
+                a[k] = a[i];
+                a[i] = temp;
+
+                permute(result, a, k + 1);
+
+                temp = a[k];
+                a[k] = a[i];
+                a[i] = temp;
+            }
+        }
+    }
+
+//    public static <T> ArrayList<T> sortLocationListC(LorenzVec start, Map<T, LorenzVec> map, boolean brokenMath) {
+//        Map<T, Double> fastestWithout = new HashMap<>();
+//        for (T without : map.keySet()) {
+//
+//            ArrayList<ArrayList<T>> variants = new ArrayList<>();
+//            ArrayList<T> values = new ArrayList<>(map.keySet());
+//
+//            values.remove(without);
+//            T[] array = (T[]) values.toArray();
+//
+//            permute(variants, array, 0);
+//
+//            LinkedHashMap<ArrayList<T>, Double> distances = new LinkedHashMap<>();
+//
+//            for (ArrayList<T> list : variants) {
+//
+//                double distance = 0;
+//                LorenzVec last = start;
+//
+//                for (T t : list) {
+//                    LorenzVec location = map.get(t);
+//                    distance += last.distanceSq(location);
+//                    last = location;
+//                }
+//
+//                distances.put(list, distance);
+//            }
+//
+//            Map<ArrayList<T>, Double> sort;
+//            if (brokenMath) {
+//                sort = sortByValue(distances);
+//            } else {
+//                sort = sortByValueAsc(distances);
+//            }
+//
+//            double fastestDistance = sort.values().iterator().next();
+//            fastestWithout.put(without, fastestDistance);
+//        }
+//
+//        T skip = sortByValueAsc(fastestWithout).keySet().iterator().next();
+//
+//
+//        map.remove(skip);
+//        ArrayList<T> result = sortLocationListB(start, map, brokenMath, false, T -> false, 0);
+//        result.add(skip);
+//
+//        return result;
+//    }
+
+    public static <T> ArrayList<LorenzVec> sortLocationListB(LorenzVec start, Map<T, LorenzVec> map, boolean brokenMath,
+                                                             boolean skipWorst, Function<T, Boolean> shouldAddToHostile, int addToHostileLastValue) {
+
+//        if (skipWorst) {
+//            return sortLocationListC(start, map, brokenMath);
+//        }
+        ArrayList<ArrayList<T>> variants = new ArrayList<>();
+        Set<T> values = map.keySet();
+        T[] array = (T[]) values.toArray();
+
+        permute(variants, array, 0);
+
+        LinkedHashMap<ArrayList<T>, Double> distances = new LinkedHashMap<>();
+
+        int with = 0;
+        int without = 0;
+
+        for (ArrayList<T> list : variants) {
+
+            double distance = 0;
+            LorenzVec last = start;
+            T lastT = null;
+
+            for (T t : list) {
+                LorenzVec location = map.get(t);
+                distance += last.distanceSq(location);
+                last = location;
+                lastT = t;
+            }
+            if (shouldAddToHostile.apply(lastT)) {
+                distance += addToHostileLastValue;
+                with++;
+            } else {
+                without++;
+            }
+
+            distances.put(list, distance);
+        }
+//        LorenzUtils.Companion.chat("with: " + with);
+//        LorenzUtils.Companion.chat("without: " + without);
+
+        Map<ArrayList<T>, Double> sort;
+        if (brokenMath) {
+            sort = sortByValue(distances);
+        } else {
+            sort = sortByValueAsc(distances);
+        }
+        ArrayList<T> result = sort.keySet().iterator().next();
+        ArrayList<LorenzVec> resultList = new ArrayList<>();
+        for (T t : result) {
+            resultList.add(map.get(t));
+        }
+
+        return resultList;
+    }
+
+    //descending
+    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
+        List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
+        list.sort(Map.Entry.comparingByValue());
+        Collections.reverse(list);
+
+        Map<K, V> result = new LinkedHashMap<>();
+        for (Map.Entry<K, V> entry : list) {
+            result.put(entry.getKey(), entry.getValue());
+        }
+
+        return result;
+    }
+
+    //ascending
+    public static <K, V extends Comparable<? super V>> Map<K, V> sortByValueAsc(Map<K, V> map) {
+        List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
+        list.sort(Map.Entry.comparingByValue());
+
+        Map<K, V> result = new LinkedHashMap<>();
+        for (Map.Entry<K, V> entry : list) {
+            result.put(entry.getKey(), entry.getValue());
+        }
+
+        return result;
+    }
+
+    public static String formatInteger(int i) {
+        return new DecimalFormat("#,##0").format(i).replace(',', '.');
+    }
+
+    public static List<ItemStack> getItemsInInventory() {
+        return getItemsInInventory(false);
+    }
+
+    public static List<ItemStack> getItemsInInventory(boolean withCursorItem) {
+        List<ItemStack> list = new ArrayList<>();
+
+//        EntityPlayerSP player = Minecraft.getMinecraft().thePlayer;
+        EntityPlayerSP player = Minecraft.getMinecraft().thePlayer;
+        if (player == null) {
+            System.err.println("loadCurrentInventory: player is null!");
+            return list;
+        }
+
+        InventoryPlayer inventory = player.inventory;
+        ItemStack[] mainInventory = inventory.mainInventory;
+
+        ArrayList<ItemStack> helpList = new ArrayList<>();
+        helpList.addAll(Arrays.asList(mainInventory));
+
+        if (withCursorItem) {
+            helpList.add(inventory.getItemStack());
+        }
+
+        for (ItemStack item : helpList) {
+            if (item == null) continue;
+            String name = item.getDisplayName();
+            if (name.equalsIgnoreCase("air")) continue;
+            if (name.equalsIgnoreCase("luft")) continue;
+            list.add(item);
+        }
+
+        return list;
+    }
+
+    public static void drawWaypoint(LorenzVec pos, float partialTicks, Color color, boolean beacon) {
+        drawWaypoint(pos, partialTicks, color, beacon, false);
+    }
+
+    public static void drawWaypoint(LorenzVec pos, float partialTicks, Color color, boolean beacon, boolean forceBeacon) {
+        Entity viewer = Minecraft.getMinecraft().getRenderViewEntity();
+        double viewerX = viewer.lastTickPosX + (viewer.posX - viewer.lastTickPosX) * partialTicks;
+        double viewerY = viewer.lastTickPosY + (viewer.posY - viewer.lastTickPosY) * partialTicks;
+        double viewerZ = viewer.lastTickPosZ + (viewer.posZ - viewer.lastTickPosZ) * partialTicks;
+
+        double x = pos.getX() - viewerX;
+        double y = pos.getY() - viewerY;
+        double z = pos.getZ() - viewerZ;
+
+
+        GlStateManager.disableDepth();
+        GlStateManager.disableCull();
+        GlStateManager.disableTexture2D();
+        if (beacon) {
+            double distSq = x * x + y * y + z * z;
+            if (distSq > 5 * 5 || forceBeacon) {
+                //TODO add beacon
+//                GriffinUtils.renderBeaconBeam(x, y, z, color.getRGB(), 1.0f, partialTicks);
+            }
+        }
+//        BlockPos a = pos.toBlocPos();
+//        BlockPos b = pos.add(1, 1, 1).toBlocPos();
+//        draw3DBox(new AxisAlignedBB(a, b), color, partialTicks);
+
+        AxisAlignedBB aabb = new AxisAlignedBB(pos.getX(), pos.getY(), pos.getZ(), pos.getX() + 1, pos.getY() + 1, pos.getZ() + 1);
+
+        draw3DBox(aabb, color, partialTicks);
+        GlStateManager.disableLighting();
+        GlStateManager.enableTexture2D();
+        GlStateManager.enableDepth();
+
+    }
+
+    public static void draw3DLine(LorenzVec p1, LorenzVec p2, Color color, int lineWidth, boolean depth, float partialTicks) {
+        GlStateManager.disableDepth();
+        GlStateManager.disableCull();
+
+//        Vec3 pos1 = new Vec3(p1.getX(), p1.getY(), p1.getZ());
+//        Vec3 pos2 = new Vec3(p2.getX(), p2.getY(), p2.getZ());
+
+        Entity render = Minecraft.getMinecraft().getRenderViewEntity();
+        WorldRenderer worldRenderer = Tessellator.getInstance().getWorldRenderer();
+
+        double realX = render.lastTickPosX + (render.posX - render.lastTickPosX) * partialTicks;
+        double realY = render.lastTickPosY + (render.posY - render.lastTickPosY) * partialTicks;
+        double realZ = render.lastTickPosZ + (render.posZ - render.lastTickPosZ) * partialTicks;
+
+        GlStateManager.pushMatrix();
+        GlStateManager.translate(-realX, -realY, -realZ);
+        GlStateManager.disableTexture2D();
+        GlStateManager.enableBlend();
+        GlStateManager.disableAlpha();
+        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
+        GL11.glLineWidth(lineWidth);
+
+
+        if (!depth) {
+            GL11.glDisable(GL11.GL_DEPTH_TEST);
+            GlStateManager.depthMask(false);
+        }
+        GlStateManager.color(color.getRed() / 255f, color.getGreen() / 255f, color.getBlue() / 255f, color.getAlpha() / 255f);
+        worldRenderer.begin(GL11.GL_LINE_STRIP, DefaultVertexFormats.POSITION);
+
+        worldRenderer.pos(p1.getX(), p1.getY(), p1.getZ()).endVertex();
+        worldRenderer.pos(p2.getX(), p2.getY(), p2.getZ()).endVertex();
+        Tessellator.getInstance().draw();
+
+        GlStateManager.translate(realX, realY, realZ);
+        if (!depth) {
+            GL11.glEnable(GL11.GL_DEPTH_TEST);
+            GlStateManager.depthMask(true);
+        }
+
+
+        GlStateManager.disableBlend();
+        GlStateManager.enableAlpha();
+        GlStateManager.enableTexture2D();
+        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
+        GlStateManager.popMatrix();
+
+
+        GlStateManager.disableLighting();
+        GlStateManager.enableDepth();
+    }
+
+    public static void draw3DBox(AxisAlignedBB aabb, Color colour, float partialTicks) {
+        Entity render = Minecraft.getMinecraft().getRenderViewEntity();
+        WorldRenderer worldRenderer = Tessellator.getInstance().getWorldRenderer();
+
+        double realX = render.lastTickPosX + (render.posX - render.lastTickPosX) * partialTicks;
+        double realY = render.lastTickPosY + (render.posY - render.lastTickPosY) * partialTicks;
+        double realZ = render.lastTickPosZ + (render.posZ - render.lastTickPosZ) * partialTicks;
+
+        GlStateManager.pushMatrix();
+        GlStateManager.translate(-realX, -realY, -realZ);
+        GlStateManager.disableTexture2D();
+        GlStateManager.enableBlend();
+        GlStateManager.disableAlpha();
+        GlStateManager.tryBlendFuncSeparate(770, 771, 1, 0);
+        GL11.glLineWidth(2);
+        GlStateManager.color(colour.getRed() / 255f, colour.getGreen() / 255f, colour.getBlue() / 255f, colour.getAlpha() / 255f);
+        worldRenderer.begin(GL11.GL_LINE_STRIP, DefaultVertexFormats.POSITION);
+
+        worldRenderer.pos(aabb.minX, aabb.minY, aabb.minZ).endVertex();
+        worldRenderer.pos(aabb.maxX, aabb.minY, aabb.minZ).endVertex();
+        worldRenderer.pos(aabb.maxX, aabb.minY, aabb.maxZ).endVertex();
+        worldRenderer.pos(aabb.minX, aabb.minY, aabb.maxZ).endVertex();
+        worldRenderer.pos(aabb.minX, aabb.minY, aabb.minZ).endVertex();
+        Tessellator.getInstance().draw();
+        worldRenderer.begin(GL11.GL_LINE_STRIP, DefaultVertexFormats.POSITION);
+        worldRenderer.pos(aabb.minX, aabb.maxY, aabb.minZ).endVertex();
+        worldRenderer.pos(aabb.maxX, aabb.maxY, aabb.minZ).endVertex();
+        worldRenderer.pos(aabb.maxX, aabb.maxY, aabb.maxZ).endVertex();
+        worldRenderer.pos(aabb.minX, aabb.maxY, aabb.maxZ).endVertex();
+        worldRenderer.pos(aabb.minX, aabb.maxY, aabb.minZ).endVertex();
+        Tessellator.getInstance().draw();
+        worldRenderer.begin(GL11.GL_LINE_STRIP, DefaultVertexFormats.POSITION);
+        worldRenderer.pos(aabb.minX, aabb.minY, aabb.minZ).endVertex();
+        worldRenderer.pos(aabb.minX, aabb.maxY, aabb.minZ).endVertex();
+        worldRenderer.pos(aabb.maxX, aabb.minY, aabb.minZ).endVertex();
+        worldRenderer.pos(aabb.maxX, aabb.maxY, aabb.minZ).endVertex();
+        worldRenderer.pos(aabb.maxX, aabb.minY, aabb.maxZ).endVertex();
+        worldRenderer.pos(aabb.maxX, aabb.maxY, aabb.maxZ).endVertex();
+        worldRenderer.pos(aabb.minX, aabb.minY, aabb.maxZ).endVertex();
+        worldRenderer.pos(aabb.minX, aabb.maxY, aabb.maxZ).endVertex();
+        Tessellator.getInstance().draw();
+
+        GlStateManager.translate(realX, realY, realZ);
+        GlStateManager.disableBlend();
+        GlStateManager.enableAlpha();
+        GlStateManager.enableTexture2D();
+        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
+        GlStateManager.popMatrix();
+    }
+}