aboutsummaryrefslogtreecommitdiff
path: root/src/main/java/kubatech/api/helpers
diff options
context:
space:
mode:
Diffstat (limited to 'src/main/java/kubatech/api/helpers')
-rw-r--r--src/main/java/kubatech/api/helpers/GTHelper.java99
-rw-r--r--src/main/java/kubatech/api/helpers/ReflectionHelper.java205
-rw-r--r--src/main/java/kubatech/api/helpers/UUIDFinder.java43
3 files changed, 347 insertions, 0 deletions
diff --git a/src/main/java/kubatech/api/helpers/GTHelper.java b/src/main/java/kubatech/api/helpers/GTHelper.java
new file mode 100644
index 0000000000..72bbe8cf77
--- /dev/null
+++ b/src/main/java/kubatech/api/helpers/GTHelper.java
@@ -0,0 +1,99 @@
+/*
+ * spotless:off
+ * KubaTech - Gregtech Addon
+ * Copyright (C) 2022 - 2024 kuba6000
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library. If not, see <https://www.gnu.org/licenses/>.
+ * spotless:on
+ */
+
+package kubatech.api.helpers;
+
+import static kubatech.api.Variables.ln4;
+
+import java.io.IOException;
+import java.util.ArrayList;
+
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.PacketBuffer;
+
+import com.kuba6000.mobsinfo.api.utils.ItemID;
+
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Energy;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_MultiBlockBase;
+import kubatech.api.implementations.KubaTechGTMultiBlockBase;
+
+public class GTHelper {
+
+ public static long getMaxInputEU(GT_MetaTileEntity_MultiBlockBase mte) {
+ if (mte instanceof KubaTechGTMultiBlockBase) return ((KubaTechGTMultiBlockBase<?>) mte).getMaxInputEu();
+ long rEU = 0;
+ for (GT_MetaTileEntity_Hatch_Energy tHatch : mte.mEnergyHatches)
+ if (tHatch.isValid()) rEU += tHatch.maxEUInput() * tHatch.maxAmperesIn();
+ return rEU;
+ }
+
+ public static double getVoltageTierD(long voltage) {
+ return Math.log((double) voltage / 8L) / ln4;
+ }
+
+ public static double getVoltageTierD(GT_MetaTileEntity_MultiBlockBase mte) {
+ return Math.log((double) getMaxInputEU(mte) / 8L) / ln4;
+ }
+
+ public static int getVoltageTier(long voltage) {
+ return (int) getVoltageTierD(voltage);
+ }
+
+ public static int getVoltageTier(GT_MetaTileEntity_MultiBlockBase mte) {
+ return (int) getVoltageTierD(mte);
+ }
+
+ public static class StackableItemSlot {
+
+ public StackableItemSlot(int count, ItemStack stack, ArrayList<Integer> realSlots) {
+ this.count = count;
+ this.stack = stack;
+ this.realSlots = realSlots;
+ }
+
+ public final int count;
+ public final ItemStack stack;
+ public final ArrayList<Integer> realSlots;
+
+ public void write(PacketBuffer buffer) throws IOException {
+ buffer.writeVarIntToBuffer(count);
+ buffer.writeItemStackToBuffer(stack);
+ }
+
+ public static StackableItemSlot read(PacketBuffer buffer) throws IOException {
+ return new StackableItemSlot(
+ buffer.readVarIntFromBuffer(),
+ buffer.readItemStackFromBuffer(),
+ new ArrayList<>());
+ }
+
+ @Override
+ public boolean equals(Object obj) {
+ if (this == obj) return true;
+ if (!(obj instanceof StackableItemSlot)) return false;
+ StackableItemSlot other = (StackableItemSlot) obj;
+ return count == other.count && ItemID.createNoCopy(stack, false)
+ .hashCode()
+ == ItemID.createNoCopy(other.stack, false)
+ .hashCode()
+ && realSlots.equals(other.realSlots);
+ }
+ }
+}
diff --git a/src/main/java/kubatech/api/helpers/ReflectionHelper.java b/src/main/java/kubatech/api/helpers/ReflectionHelper.java
new file mode 100644
index 0000000000..5c5bb1070e
--- /dev/null
+++ b/src/main/java/kubatech/api/helpers/ReflectionHelper.java
@@ -0,0 +1,205 @@
+/*
+ * spotless:off
+ * KubaTech - Gregtech Addon
+ * Copyright (C) 2022 - 2024 kuba6000
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library. If not, see <https://www.gnu.org/licenses/>.
+ * spotless:on
+ */
+
+package kubatech.api.helpers;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.JarURLConnection;
+import java.net.URL;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Objects;
+import java.util.jar.JarFile;
+import java.util.stream.Collectors;
+
+import net.minecraft.launchwrapper.Launch;
+
+import org.objectweb.asm.ClassReader;
+import org.objectweb.asm.tree.ClassNode;
+
+public class ReflectionHelper {
+
+ private static class _FieldsMethods {
+
+ final HashMap<String, Field> fields = new HashMap<>();
+ final HashMap<String, Method> methods = new HashMap<>();
+ }
+
+ private static final HashMap<String, _FieldsMethods> classes = new HashMap<>();
+
+ @SuppressWarnings("unchecked")
+ public static <T> T getField(Object obj, String fieldName, T defaultvalue) {
+ Class<?> cl = obj.getClass();
+ String clName = cl.getName();
+ HashMap<String, Field> classmap = classes.computeIfAbsent(clName, s -> new _FieldsMethods()).fields;
+ try {
+ if (classmap.containsKey(fieldName)) {
+ Field f = classmap.get(fieldName);
+ if (f == null) return defaultvalue;
+ return (T) f.get(obj);
+ }
+ boolean exceptionDetected;
+ Field f = null;
+ do {
+ exceptionDetected = false;
+ try {
+ f = cl.getDeclaredField(fieldName);
+ f.setAccessible(true);
+ } catch (Exception ex) {
+ exceptionDetected = true;
+ cl = cl.getSuperclass();
+ }
+ } while (exceptionDetected && !cl.equals(Object.class));
+ classmap.put(fieldName, f);
+ if (f == null) return defaultvalue;
+ return (T) f.get(obj);
+ } catch (Exception ex) {
+ return defaultvalue;
+ }
+ }
+
+ public static <T> boolean setField(Object obj, String fieldName, T value) {
+ Class<?> cl = obj.getClass();
+ String clName = cl.getName();
+ HashMap<String, Field> classmap = classes.computeIfAbsent(clName, s -> new _FieldsMethods()).fields;
+ try {
+ if (classmap.containsKey(fieldName)) {
+ Field f = classmap.get(fieldName);
+ if (f == null) return false;
+ f.set(obj, value);
+ return true;
+ }
+ boolean exceptionDetected;
+ Field f = null;
+ do {
+ exceptionDetected = false;
+ try {
+ f = cl.getDeclaredField(fieldName);
+ f.setAccessible(true);
+ } catch (Exception ex) {
+ exceptionDetected = true;
+ cl = cl.getSuperclass();
+ }
+ } while (exceptionDetected && !cl.equals(Object.class));
+ classmap.put(fieldName, f);
+ if (f == null) return false;
+ f.set(obj, value);
+ return true;
+ } catch (Exception ex) {
+ return false;
+ }
+ }
+
+ public static <T> T getField(Object obj, String fieldName) {
+ return getField(obj, fieldName, null);
+ }
+
+ @SuppressWarnings("unchecked")
+ public static <T> T callMethod(Object obj, String methodName, T defaultValue, Object... args) {
+ Class<?> cl = obj.getClass();
+ String clName = cl.getName();
+ HashMap<String, Method> classmap = classes.computeIfAbsent(clName, s -> new _FieldsMethods()).methods;
+ StringBuilder builder = new StringBuilder(methodName);
+ Class<?>[] argsTypes = new Class<?>[args.length];
+ for (int i = 0; i < args.length; i++) {
+ Class<?> arg = args[i].getClass();
+ builder.append(";")
+ .append(arg.getSimpleName());
+ argsTypes[i] = arg;
+ }
+ String methodNameUnique = builder.toString();
+ try {
+ if (classmap.containsKey(methodNameUnique)) {
+ Method m = classmap.get(methodNameUnique);
+ if (m == null) return defaultValue;
+ return (T) m.invoke(obj, args);
+ }
+ boolean exceptionDetected;
+ Method m = null;
+ do {
+ exceptionDetected = false;
+ try {
+ m = cl.getDeclaredMethod(methodName, argsTypes);
+ m.setAccessible(true);
+ } catch (Exception ex) {
+ exceptionDetected = true;
+ cl = cl.getSuperclass();
+ }
+ } while (exceptionDetected && !cl.equals(Object.class));
+ classmap.put(methodNameUnique, m);
+ if (m == null) return defaultValue;
+ return (T) m.invoke(obj, args);
+ } catch (Exception ex) {
+ return defaultValue;
+ }
+ }
+
+ /**
+ * Gets all classes in a specific package path, works only for jar files.
+ *
+ * @param packageName The package name
+ * @return The class nodes
+ */
+ public static Collection<ClassNode> getClasses(String packageName) throws IOException {
+ ClassLoader classLoader = Thread.currentThread()
+ .getContextClassLoader();
+ assert classLoader != null;
+ String packagePath = packageName.replace('.', '/');
+ URL resource = classLoader.getResource(packagePath);
+ if (resource == null) throw new FileNotFoundException();
+ if (!resource.getProtocol()
+ .equals("jar")) return Collections.emptySet();
+ try (JarFile jar = ((JarURLConnection) resource.openConnection()).getJarFile()) {
+ return jar.stream()
+ .filter(
+ j -> !j.isDirectory() && j.getName()
+ .startsWith(packagePath)
+ && j.getName()
+ .endsWith(".class"))
+ .map(j -> {
+ try {
+ String name = j.getName();
+ URL jarResource = Launch.classLoader.getResource(name);
+ if (jarResource == null) return null;
+ byte[] bytes;
+ try (InputStream is = jarResource.openStream()) {
+ bytes = new byte[(int) j.getSize()];
+ if (is.read(bytes) != bytes.length) return null;
+ if (is.available() > 0) return null;
+ }
+
+ ClassNode cn = new ClassNode();
+ ClassReader cr = new ClassReader(bytes);
+ cr.accept(cn, 0);
+
+ return cn;
+ } catch (IOException ignored) {}
+ return null;
+ })
+ .filter(Objects::nonNull)
+ .collect(Collectors.toSet());
+ }
+ }
+}
diff --git a/src/main/java/kubatech/api/helpers/UUIDFinder.java b/src/main/java/kubatech/api/helpers/UUIDFinder.java
new file mode 100644
index 0000000000..922904705b
--- /dev/null
+++ b/src/main/java/kubatech/api/helpers/UUIDFinder.java
@@ -0,0 +1,43 @@
+/*
+ * spotless:off
+ * KubaTech - Gregtech Addon
+ * Copyright (C) 2022 - 2024 kuba6000
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 3 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this library. If not, see <https://www.gnu.org/licenses/>.
+ * spotless:on
+ */
+
+package kubatech.api.helpers;
+
+import java.util.HashMap;
+import java.util.UUID;
+
+public class UUIDFinder {
+
+ private static final HashMap<UUID, String> UUIDToUsernameMap = new HashMap<>();
+ private static final HashMap<String, UUID> UsernameToUUIDMap = new HashMap<>();
+
+ public static UUID getUUID(String username) {
+ return UsernameToUUIDMap.get(username);
+ }
+
+ public static String getUsername(UUID player) {
+ return UUIDToUsernameMap.get(player);
+ }
+
+ public static void updateMapping(String username, UUID player) {
+ UUIDToUsernameMap.put(player, username);
+ UsernameToUUIDMap.put(username, player);
+ }
+}
generated by cgit (git 2.46.0) at 2025-05-02 04:12:54 +0000