From 6c0f5637c34dc64012f4d7c967ebf529e7b8f247 Mon Sep 17 00:00:00 2001 From: Len <40720638+destro174@users.noreply.github.com> Date: Fri, 24 Jul 2026 15:42:09 -0500 Subject: [PATCH] Remove references to AltitudeAPI and import the required files. --- build.gradle.kts | 8 +- .../altitudetag/configuration/Config.java | 2 +- .../alttd/altitudetag/configuration/Lang.java | 4 +- .../altitudetag/utils/CollectionUtils.java | 250 ++++++++++++++++++ .../alttd/altitudetag/utils/MutableValue.java | 60 +++++ .../alttd/altitudetag/utils/StringUtils.java | 154 +++++++++++ 6 files changed, 471 insertions(+), 7 deletions(-) create mode 100644 src/main/java/com/alttd/altitudetag/utils/CollectionUtils.java create mode 100644 src/main/java/com/alttd/altitudetag/utils/MutableValue.java create mode 100644 src/main/java/com/alttd/altitudetag/utils/StringUtils.java diff --git a/build.gradle.kts b/build.gradle.kts index 23321e3..f6cb6b2 100644 --- a/build.gradle.kts +++ b/build.gradle.kts @@ -13,7 +13,7 @@ plugins { dependencies { compileOnly("com.alttd.cosmos:cosmos-api:26.2.build.17-stable") - compileOnly("com.alttd.altitudeapi:AltitudeAPI:0.0.3") +// compileOnly("com.alttd.altitudeapi:AltitudeAPI:0.0.3") compileOnly("com.github.decentsoftware-eu:decentholograms:2.8.9") compileOnly("org.jetbrains:annotations:16.0.2") testImplementation("org.powermock:powermock-module-junit4:1.7.4") @@ -62,17 +62,17 @@ tasks { } runDirectory.set(dir) - val fileName = "/galaxy.jar" + val fileName = "/cosmos.jar" val file = File(dir.path + fileName) if (!file.parentFile.exists()) { file.parentFile.mkdirs() } if (!file.exists()) { - download("https://repo.destro.xyz/private/com/alttd/Galaxy-Server/Galaxy-paperclip-1.20.4-R0.1-SNAPSHOT-reobf.jar", file) + download("https://jenkins.destro.xyz/job/Cosmos/lastSuccessfulBuild/artifact/cosmos-server/build/libs/cosmos-paperclip-26.2.build.17-stable.jar", file) } serverJar(file) - minecraftVersion("1.20.4") + minecraftVersion("26.2") } } diff --git a/src/main/java/com/alttd/altitudetag/configuration/Config.java b/src/main/java/com/alttd/altitudetag/configuration/Config.java index e79f37f..6d425d6 100644 --- a/src/main/java/com/alttd/altitudetag/configuration/Config.java +++ b/src/main/java/com/alttd/altitudetag/configuration/Config.java @@ -2,8 +2,8 @@ package com.alttd.altitudetag.configuration; import java.util.Objects; -import com.alttd.altitudeapi.utils.MutableValue; import com.alttd.altitudetag.AltitudeTag; +import com.alttd.altitudetag.utils.MutableValue; import org.bukkit.ChatColor; import org.bukkit.configuration.file.FileConfiguration; diff --git a/src/main/java/com/alttd/altitudetag/configuration/Lang.java b/src/main/java/com/alttd/altitudetag/configuration/Lang.java index ce0662a..04e4c9f 100644 --- a/src/main/java/com/alttd/altitudetag/configuration/Lang.java +++ b/src/main/java/com/alttd/altitudetag/configuration/Lang.java @@ -3,9 +3,9 @@ package com.alttd.altitudetag.configuration; import java.io.File; import java.util.Arrays; -import com.alttd.altitudeapi.utils.CollectionUtils; -import com.alttd.altitudeapi.utils.StringUtils; import com.alttd.altitudetag.AltitudeTag; +import com.alttd.altitudetag.utils.CollectionUtils; +import com.alttd.altitudetag.utils.StringUtils; import org.apache.commons.lang3.mutable.MutableBoolean; import org.bukkit.command.CommandSender; import org.bukkit.configuration.file.FileConfiguration; diff --git a/src/main/java/com/alttd/altitudetag/utils/CollectionUtils.java b/src/main/java/com/alttd/altitudetag/utils/CollectionUtils.java new file mode 100644 index 0000000..40b1532 --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/utils/CollectionUtils.java @@ -0,0 +1,250 @@ +package com.alttd.altitudetag.utils; + +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Deque; +import java.util.HashMap; +import java.util.Iterator; +import java.util.LinkedList; +import java.util.List; +import java.util.Map; +import java.util.Random; + +public class CollectionUtils +{ + + private final static Map, Method> nameMethods = new HashMap<>(); + + /** + * Retrieves the last value of the given list. If the list is null or it has no elements, this will always return + * null. If the List is also a Deque, this will return the last element using {@link Deque#peekLast()}. + * + * @param list the list to get the last value of. + * @param the type of the list. + * + * @return the last value. + */ + @SuppressWarnings("unchecked") + public static T getLast(List list) + { + if (list == null || list.size() == 0) + { + return null; + } + if (list instanceof Deque) + { + return ((Deque) list).peekLast(); + } + return list.get(list.size() - 1); + } + + /** + * Safely checks if the given collection is immutable. If the collection is mutable, the data will not be affected + * unless the collection in question keeps track of total number of operations. The test is done by calling + * {@link Collection#removeIf(java.util.function.Predicate)} with the predicate of {@code false}. + * + * @param values the collection to check. + * + * @return {@code true} if the collection is immutable. + */ + public static boolean isImmutable(Collection values) + { + try + { + values.removeIf(x -> false); + return true; + } + catch (UnsupportedOperationException ex) + { + return false; + } + } + + /** + * Converts the given values into their string counterpart. This is done by calling {@link Object#toString()} on + * every object. More specific use cases like {@link org.bukkit.entity.Player#getName()} etc are not compatible. + * + * @param values the values to convert. + * @param the type of the collection. + * + * @return the generated list of Strings. + */ + public static List getStringList(Collection values) + { + if (values == null || values.size() == 0) + { + return Collections.emptyList(); + } + List list = new LinkedList<>(); + for (Object o : values) + { + if (o != null) + { + list.add(o.toString()); + } + else + { + list.add(null); + } + } + return list; + } + + /** + * Get the names of every single object passed in the values parameter. This method requires the method "getName()" + * to exist within whatever type is passed. If it does not exist, an empty list is returned. However, in the future + * there is a potential that it will be changed to throwing an {@link IllegalArgumentException}. + * + * @param values the values to get the name of. + * @param type the type of the object. + * @param the type of the list. + * + * @return the list of names. + */ + public static List getNames(Collection values, Class type) + { + if (values == null || values.size() == 0) + { + return Collections.emptyList(); + } + List list = new LinkedList<>(); + + Method method = getNameMethod(type); + + if (method == null) + { + return Collections.emptyList(); + } + + for (Object obj : values) + { + try + { + list.add((String) method.invoke(obj)); + } + catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException ex) + { + // this exception is actually going to be printed as it should never happen. + // the method was set to accessible previously, and it should also never have any arguments. + ex.printStackTrace(); + } + } + return list; + } + + private static Method getNameMethod(Class clazz) + { + Method method = nameMethods.get(clazz); + if (method == null) + { + try + { + method = clazz.getDeclaredMethod("getName"); + method.setAccessible(true); + nameMethods.put(clazz, method); + } + catch (NoSuchMethodException | SecurityException ex) + { + // ignored + } + } + return method; + } + + /** + * Searches through the given values for the first non-null value. + * + * @param values the values to find. + * @param the type of the array. + * + * @return the first non-null value. + */ + @SafeVarargs + public static T firstNonNull(T... values) + { + for (T value : values) + { + if (value != null) + { + return value; + } + } + return null; + } + + /** + * Converts the given String collection into a String array. + * + * @param collection the collection to convert. + * + * @return the newly created array. + */ + public static String[] toArray(Collection collection) + { + return collection.toArray(new String[0]); + } + + /** + * Returns a random value from the collection. If the collection is null or empty, this will return null. + * + * @param collection the collection to poll. + * @param the type of the collection. + * + * @return a random value from the collection. + */ + public static T randomValue(Collection collection) + { + return randomValue(collection, (T) null); + } + + /** + * Returns a random value from the collection. If the collection is null or empty, this will return null. + * + * @param collection the collection to poll. + * @param ignored any values not suitable to be included + * @param the type of the collection. + * + * @return a random value from the collection. + */ + @SafeVarargs + public static T randomValue(Collection collection, T... ignored) + { + // if it's null or empty, we don't care + if (collection == null || collection.size() == 0) + { + return null; + } + // if the ignored values aren't null, we need to make them not an option + if (ignored != null) + { + collection = new ArrayList<>(collection); + collection.removeAll(Arrays.asList(ignored)); + } + Random random = new Random(); + + // the index to get a value from + int index = random.nextInt(collection.size()); + + // if it's a list, we can just get it at that index, no need to iterate + if (collection instanceof List) + { + return ((List) collection).get(index); + } + + // it's not a list, time to iterate + Iterator iterator = collection.iterator(); + for (int i = 0; iterator.hasNext(); i++) + { + if (i == index) + { + return iterator.next(); + } + iterator.next(); + } + return null; + } +} diff --git a/src/main/java/com/alttd/altitudetag/utils/MutableValue.java b/src/main/java/com/alttd/altitudetag/utils/MutableValue.java new file mode 100644 index 0000000..d95dcb4 --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/utils/MutableValue.java @@ -0,0 +1,60 @@ +package com.alttd.altitudetag.utils; + +/** + * Represents a mutable data type for a type that may not normally be mutable, either because it is final, primitive, or sealed. + * + * @param the type of this mutable value. + */ +public class MutableValue +{ + private T value; + + /** + * Constructs a new MutableValue with the given object. + * + * @param t the value to be stored. + */ + public MutableValue(T t) + { + if (t == null) + { + throw new IllegalArgumentException("Value can't be null."); + } + + this.value = t; + } + + /** + * Returns the value that is currently stored. If there is no value, returns null. + * + * @return the value that is currently stored. + */ + public T getValue() + { + return value; + } + + /** + * Sets the value that is currently stored. + * + * @param t the new value to be stored. + */ + public void setValue(T t) + { + if (t == null) + { + throw new IllegalArgumentException("Value can't be null."); + } + this.value = t; + } + + public Class getType() + { + if (value == null) + { + throw new IllegalStateException("Value can't be null."); + } + + return (Class) value.getClass(); + } +} diff --git a/src/main/java/com/alttd/altitudetag/utils/StringUtils.java b/src/main/java/com/alttd/altitudetag/utils/StringUtils.java new file mode 100644 index 0000000..3afb398 --- /dev/null +++ b/src/main/java/com/alttd/altitudetag/utils/StringUtils.java @@ -0,0 +1,154 @@ +package com.alttd.altitudetag.utils; + +import java.text.DecimalFormat; + +public class StringUtils +{ + + public static String implode(String[] strings, int start, int end) + { + StringBuilder sb = new StringBuilder(); + + for (int i = start; i < end; i++) + { + sb.append(strings[i]).append(" "); + } + + return sb.toString().trim(); + } + + public static String[] add(String[] array, String add) + { + String[] values = new String[array.length + 1]; + System.arraycopy(array, 0, values, 0, array.length); + values[array.length] = add; + return values; + } + + public static String compile(String[] strings) + { + return implode(strings, 0, strings.length); + } + + public static String capitalize(final String str) + { + int strLen; + if (str == null || (strLen = str.length()) == 0) + { + return str; + } + + final int firstCodepoint = str.codePointAt(0); + final int newCodePoint = Character.toTitleCase(firstCodepoint); + if (firstCodepoint == newCodePoint) + { + // already capitalized + return str; + } + + final int[] newCodePoints = new int[strLen]; // cannot be longer than + // the char array + int outOffset = 0; + newCodePoints[outOffset++] = newCodePoint; // copy the first codepoint + for (int inOffset = Character.charCount(firstCodepoint); inOffset < strLen; ) + { + final int codepoint = str.codePointAt(inOffset); + newCodePoints[outOffset++] = codepoint; // copy the remaining ones + inOffset += Character.charCount(codepoint); + } + return new String(newCodePoints, 0, outOffset); + } + + public static boolean contains(String[] values, String search) + { + for (String val : values) + { + if (val.equalsIgnoreCase(search)) + { + return true; + } + } + return false; + } + + public static boolean isNullOrEmpty(String str) + { + return str == null || str.length() == 0; + } + + public static boolean isWhitespace(String str) + { + if (str == null) + { + return false; + } + final int sz = str.length(); + for (int i = 0; i < sz; i++) + { + if (!Character.isWhitespace(str.charAt(i))) + { + return false; + } + } + return true; + } + + public static boolean containsAny(String search, String... strings) + { + if (isNullOrEmpty(search)) + { + return false; + } + for (String searchCharSequence : strings) + { + if (indexOf(search, searchCharSequence, 0) >= 0) + { + return true; + } + } + return false; + } + + private static int indexOf(CharSequence cs, CharSequence searchChar, int start) + { + return cs.toString().indexOf(searchChar.toString(), start); + } + + public static String formatNumber(Number number, int decimalPlaces, boolean useCommas) + { + StringBuilder sb = new StringBuilder(); + if (useCommas) + { + sb.append("#,##0"); + } + else + { + sb.append("0"); + } + if (decimalPlaces > 0) + { + sb.append('.'); + for (int i = 0; i < decimalPlaces; i++) + { + sb.append('0'); + } + } + return new DecimalFormat(sb.toString()).format(number); + } + + public static String doubleFormat(double number) + { + String formatted; + + if (number % 1 == 0) + { + formatted = Integer.toString((int) number); + } + else + { + formatted = Double.toString(number); + } + return formatted; + } + +}