Add cache parsers and POJOs for DEED and RUNE templates

New engine.parsers package: - cache: DeedParser and RuneParser load COBJECTS/DEED and COBJECTS/RUNE JSON straight from the data dir, keyed by file id. CacheParserUtil holds the shared JSON helpers. - objects: standalone DeedTemplate and RuneTemplate covering every field in the client data, plus shared PowerGrant/UserPowerAction. - wpak: placeholder for upcoming wpak parsers. Not wired into server startup yet. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-15 11:09:41 -04:00
1 parent 777f7ad89d
commit 0d48080e38
@@ -0,0 +1,299 @@
+//  • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
+//  ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
+//  ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
+//  ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
+//  ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
+//      Magicbane Emulator Project © 2013 - 2026
+//                https://www.magicbane.com
+
+package engine.parsers.cache;
+
+import engine.math.Vector3fImmutable;
+import engine.parsers.objects.PowerGrant;
+import engine.parsers.objects.UserPowerAction;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import org.pmw.tinylog.Logger;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.util.ArrayList;
+import java.util.EnumMap;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+
+// Shared JSON helpers for the COBJECTS cache parsers.
+// Only generic reading lives here; each parser owns its own field mapping.
+
+public class CacheParserUtil {
+
+    // Files are named <template id>.json
+
+    public static File[] listJsonFiles(String folderPath) {
+
+        File folder = new File(folderPath);
+        File[] jsonFiles = folder.listFiles((dir, name) -> name.endsWith(".json"));
+
+        if (jsonFiles == null) {
+            Logger.error("Cache folder not found: " + folder.getAbsolutePath());
+            return new File[0];
+        }
+
+        return jsonFiles;
+    }
+
+    public static int templateIdFromFile(File jsonFile) {
+
+        String fileName = jsonFile.getName();
+
+        return Integer.parseInt(fileName.substring(0, fileName.length() - ".json".length()));
+    }
+
+    public static JSONObject readJsonFile(File jsonFile) throws IOException {
+
+        byte[] fileData = Files.readAllBytes(jsonFile.toPath());
+
+        return new JSONObject(new String(fileData, StandardCharsets.UTF_8));
+    }
+
+    // [x, y, z] -> vector. Returns null for an empty array.
+
+    public static Vector3fImmutable readVector3(JSONArray vectorJson) {
+
+        if (vectorJson.length() < 3)
+            return null;
+
+        return new Vector3fImmutable(vectorJson.getFloat(0), vectorJson.getFloat(1), vectorJson.getFloat(2));
+    }
+
+    // Client strings carry spaces, hyphens and commas that enum constants
+    // can't ("Half-Giant", "Battle Magus").
+
+    public static String enumName(String value) {
+
+        String name = value;
+
+        name = name.replaceAll("\\s", "");
+        name = name.replaceAll("-", "");
+        name = name.replaceAll(",", "");
+
+        return name;
+    }
+
+    // Exact match on the cleaned name first, then upper case (ResourceType).
+    // Unknown values are logged and returned as null so one bad value
+    // doesn't drop the whole template.
+
+    public static <E extends Enum<E>> E readEnum(Class<E> enumClass, String value, int templateId, String fieldName) {
+
+        String name = enumName(value);
+
+        try {
+            return Enum.valueOf(enumClass, name);
+        } catch (IllegalArgumentException e) {
+            // fall through to upper case
+        }
+
+        try {
+            return Enum.valueOf(enumClass, name.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            Logger.error(templateId + ": " + fieldName + " has no " + enumClass.getSimpleName() + " for '" + value + "'");
+            return null;
+        }
+    }
+
+    public static <E extends Enum<E>> EnumSet<E> readEnumSet(Class<E> enumClass, JSONArray valuesJson, int templateId, String fieldName) {
+
+        EnumSet<E> enumSet = EnumSet.noneOf(enumClass);
+        E enumValue;
+
+        for (int i = 0; i < valuesJson.length(); i++) {
+            enumValue = readEnum(enumClass, valuesJson.getString(i), templateId, fieldName);
+
+            if (enumValue != null)
+                enumSet.add(enumValue);
+        }
+
+        return enumSet;
+    }
+
+    // [{keyName: "Strength", valueName: 40}, ...] -> enum map
+    // Negative values are stored unsigned in the JSON (-5 is 4294967291),
+    // so values are read as long and wrapped to int.
+
+    public static <E extends Enum<E>> EnumMap<E, Integer> readEnumValueMap(Class<E> enumClass, JSONArray entriesJson,
+                                                                          String keyName, String valueName,
+                                                                          int templateId, String fieldName) {
+
+        EnumMap<E, Integer> enumMap = new EnumMap<>(enumClass);
+        JSONObject entry;
+        E enumValue;
+
+        for (int i = 0; i < entriesJson.length(); i++) {
+            entry = entriesJson.getJSONObject(i);
+            enumValue = readEnum(enumClass, entry.getString(keyName), templateId, fieldName);
+
+            if (enumValue != null)
+                enumMap.put(enumValue, (int) entry.getLong(valueName));
+        }
+
+        return enumMap;
+    }
+
+    // [{keyName: "Sword", valueName: 20}, ...] -> map in file order
+
+    public static LinkedHashMap<String, Integer> readStringValueMap(JSONArray entriesJson, String keyName, String valueName) {
+
+        LinkedHashMap<String, Integer> valueMap = new LinkedHashMap<>();
+        JSONObject entry;
+
+        for (int i = 0; i < entriesJson.length(); i++) {
+            entry = entriesJson.getJSONObject(i);
+            valueMap.put(entry.getString(keyName), (int) entry.getLong(valueName));
+        }
+
+        return valueMap;
+    }
+
+    public static LinkedHashMap<String, Float> readFloatMap(JSONObject mapJson) {
+
+        LinkedHashMap<String, Float> floatMap = new LinkedHashMap<>();
+
+        for (String key : mapJson.keySet())
+            floatMap.put(key, mapJson.getFloat(key));
+
+        return floatMap;
+    }
+
+    // Values are read as long and wrapped to int so unsigned 32-bit hashes survive.
+
+    public static int[] readIntArray(JSONArray valuesJson) {
+
+        int[] values = new int[valuesJson.length()];
+
+        for (int i = 0; i < valuesJson.length(); i++)
+            values[i] = (int) valuesJson.getLong(i);
+
+        return values;
+    }
+
+    public static float[] readFloatArray(JSONArray valuesJson) {
+
+        float[] values = new float[valuesJson.length()];
+
+        for (int i = 0; i < valuesJson.length(); i++)
+            values[i] = valuesJson.getFloat(i);
+
+        return values;
+    }
+
+    public static ArrayList<Integer> readIntList(JSONArray valuesJson) {
+
+        ArrayList<Integer> values = new ArrayList<>();
+
+        for (int i = 0; i < valuesJson.length(); i++)
+            values.add((int) valuesJson.getLong(i));
+
+        return values;
+    }
+
+    // [[a, b], [a, b], ...] -> list of int[]
+
+    public static ArrayList<int[]> readIntArrays(JSONArray arraysJson) {
+
+        ArrayList<int[]> arrays = new ArrayList<>();
+
+        for (int i = 0; i < arraysJson.length(); i++)
+            arrays.add(readIntArray(arraysJson.getJSONArray(i)));
+
+        return arrays;
+    }
+
+    // Sparse data values are mixed bool/int/string; stored as strings.
+
+    public static HashMap<String, String> readSparseData(JSONObject sparseJson) {
+
+        HashMap<String, String> sparseData = new HashMap<>();
+
+        for (String key : sparseJson.keySet())
+            sparseData.put(key, sparseJson.get(key).toString());
+
+        return sparseData;
+    }
+
+    // Some fields are a name when set and the number 0 when not
+    // (obj_sound_table, item_skill_used). The number becomes "".
+
+    public static String readLabel(JSONObject json, String key) {
+
+        Object value = json.get(key);
+
+        if (value instanceof String)
+            return (String) value;
+
+        return "";
+    }
+
+    public static ArrayList<UserPowerAction> readUserPowerActions(JSONArray actionsJson) {
+
+        ArrayList<UserPowerAction> userPowerActions = new ArrayList<>();
+        JSONObject entry;
+
+        for (int i = 0; i < actionsJson.length(); i++) {
+            entry = actionsJson.getJSONObject(i);
+            userPowerActions.add(new UserPowerAction(entry.getString("power"), readIntArray(entry.getJSONArray("arguments"))));
+        }
+
+        return userPowerActions;
+    }
+
+    public static ArrayList<PowerGrant> readPowerGrants(JSONArray grantsJson) {
+
+        ArrayList<PowerGrant> powerGrants = new ArrayList<>();
+        JSONObject entry;
+        PowerGrant powerGrant;
+
+        for (int i = 0; i < grantsJson.length(); i++) {
+            entry = grantsJson.getJSONObject(i);
+            powerGrant = new PowerGrant();
+
+            powerGrant.power_type = entry.getString("power_type");
+            powerGrant.power_value = entry.getInt("power_value");
+            powerGrant.power_granted_attrs = entry.getJSONArray("power_granted_attrs");
+            powerGrant.power_granted_skills.addAll(readIntArrays(entry.getJSONArray("power_granted_skills")));
+            powerGrant.power_granted_powers.addAll(readIntArrays(entry.getJSONArray("power_granted_powers")));
+            powerGrant.power_monster_types = entry.getJSONArray("power_monster_types");
+
+            powerGrants.add(powerGrant);
+        }
+
+        return powerGrants;
+    }
+
+    // [{power_type: "X", power_actions: [{power_arguments: [a, b]}, ...]}, ...]
+    // -> power_type -> list of argument arrays (one per power_actions entry)
+
+    public static LinkedHashMap<String, ArrayList<int[]>> readPowerActions(JSONArray actionsJson) {
+
+        LinkedHashMap<String, ArrayList<int[]>> powerActions = new LinkedHashMap<>();
+        JSONObject entry;
+        JSONArray argumentsJson;
+        ArrayList<int[]> arguments;
+
+        for (int i = 0; i < actionsJson.length(); i++) {
+            entry = actionsJson.getJSONObject(i);
+            argumentsJson = entry.getJSONArray("power_actions");
+            arguments = new ArrayList<>();
+
+            for (int j = 0; j < argumentsJson.length(); j++)
+                arguments.add(readIntArray(argumentsJson.getJSONObject(j).getJSONArray("power_arguments")));
+
+            powerActions.put(entry.getString("power_type"), arguments);
+        }
+
+        return powerActions;
+    }
+}