Server/src/engine/wpak/PowersParser.java

// • ▌ ▄ ·.  ▄▄▄·  ▄▄ • ▪   ▄▄· ▄▄▄▄·  ▄▄▄·  ▐▄▄▄  ▄▄▄ .
// ·██ ▐███▪▐█ ▀█ ▐█ ▀ ▪██ ▐█ ▌▪▐█ ▀█▪▐█ ▀█ •█▌ ▐█▐▌·
// ▐█ ▌▐▌▐█·▄█▀▀█ ▄█ ▀█▄▐█·██ ▄▄▐█▀▀█▄▄█▀▀█ ▐█▐ ▐▌▐▀▀▀
// ██ ██▌▐█▌▐█ ▪▐▌▐█▄▪▐█▐█▌▐███▌██▄▪▐█▐█ ▪▐▌██▐ █▌▐█▄▄▌
// ▀▀  █▪▀▀▀ ▀  ▀ ·▀▀▀▀ ▀▀▀·▀▀▀ ·▀▀▀▀  ▀  ▀ ▀▀  █▪ ▀▀▀
//      Magicbane Emulator Project © 2013 - 2024
//                www.magicbane.com

package engine.wpak;

import engine.gameManager.ConfigManager;
import engine.mbEnums;
import engine.wpak.data.EquipmentPreReq;
import engine.wpak.data.PowerAction;
import engine.wpak.data.PowerData;
import engine.wpak.data.PowerEntry;
import org.pmw.tinylog.Logger;

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PowersParser {

    private static String powersPath = ConfigManager.DEFAULT_DATA_DIR + "wpak/Powers.cfg";
    private static final Pattern POWER_REGEX = Pattern.compile("(?<=POWERBEGIN)(.+?)(?=POWEREND)", Pattern.DOTALL);
    private static final Pattern STRSPLIT_REGEX = Pattern.compile("([^\"]\\S*|\"[^\"]*\")\\s*");
    private static final Pattern CONDITION_REGEX = Pattern.compile("(?<=CONDITIONBEGIN)(.+?)(?=CONDITIONEND)", Pattern.DOTALL);

    public static void parseWpakFile() throws IOException {

        // Read .wpak file from disk

        byte[] fileData = Files.readAllBytes(Paths.get(powersPath));
        String fileContents = new String(fileData);

        // Iterate over power entries from .wpak data

        Matcher matcher = POWER_REGEX.matcher(fileContents);

        while (matcher.find()) {

            PowerEntry powerEntry = parsePowerEntry(matcher.group().trim());

        }
    }

    private static PowerEntry parsePowerEntry(String powerData) {

        PowerEntry powerEntry = new PowerEntry();

        try {

            StringBuilder conditionString = new StringBuilder();
            StringBuilder powerString = new StringBuilder();

            int endPos = 0;

            // Separate out any conditions from the power data

            Matcher matcher = CONDITION_REGEX.matcher(powerData);

            while (matcher.find()) {
                conditionString.append(matcher.group().trim());
                powerString.append(powerData, endPos, matcher.start());
                endPos = matcher.end();
            }

            powerString.append(powerData.substring(endPos));

            // Cleanup dangling tags and lines that contain a # and leading/trailing blank lines

            powerString = new StringBuilder(powerString.toString().replaceAll("CONDITIONBEGINCONDITIONEND", "")
                    .replaceAll("(?m)^.*#.*\r?\n?", ""));

            conditionString = new StringBuilder(conditionString.toString().replaceAll("(?m)^.*#.*\r?\n?", ""));

            String[] lineData = powerString.toString().trim().split("\n");
            ArrayList<String> powerHeader = new ArrayList<>();

            // Parse header

            String headerString = lineData[0];
            headerString = headerString.replace("\n", " ");

            matcher = STRSPLIT_REGEX.matcher(headerString);

            while (matcher.find())
                powerHeader.add(matcher.group().trim());

            java.util.Iterator<String> iterator = powerHeader.iterator();

            powerEntry.power_id = iterator.next();
            powerEntry.power = iterator.next().replaceAll("\"", "");

            PowerData power = new PowerData();
            power.power_type = mbEnums.PowerType.valueOf(iterator.next());
            power.icon = Integer.parseInt(iterator.next());
            power.powerBase = iterator.next().replaceAll("\"", "");
            powerEntry.powers.add(power);

            String nextValue = iterator.next();

            // Account for second definition

            if (nextValue.equals("SPELL") || nextValue.equals("SKILL")) {
                power = new PowerData();
                power.power_type = mbEnums.PowerType.valueOf(nextValue);
                power.icon = Integer.parseInt(iterator.next());
                power.powerBase = iterator.next().replaceAll("\"", "");
                powerEntry.powers.add(power);
                powerEntry.target_type = mbEnums.PowerTargetType.valueOf(iterator.next());
            } else
                powerEntry.target_type = mbEnums.PowerTargetType.valueOf(nextValue);

            powerEntry.range = Integer.parseInt(iterator.next());
            powerEntry.areaType = mbEnums.AreaType.valueOf(iterator.next());
            powerEntry.areaRange = Integer.parseInt(iterator.next());
            powerEntry.excludeType = mbEnums.ExcludeType.valueOf(iterator.next());
            powerEntry.costType = mbEnums.CostType.valueOf(iterator.next());
            powerEntry.cost = Float.parseFloat(iterator.next());
            powerEntry.difficulty = Float.parseFloat(iterator.next());
            powerEntry.precision = Float.parseFloat(iterator.next());
            powerEntry.init_time = Float.parseFloat(iterator.next().replaceAll("(\\.0)+$", ""));
            powerEntry.release_time = Float.parseFloat(iterator.next());
            powerEntry.recycle_time = Float.parseFloat(iterator.next());
            powerEntry.hitRollYN = Integer.parseInt(iterator.next());
            powerEntry.castingMode = mbEnums.CastingModeType.valueOf(iterator.next());
            powerEntry.initAmin = Integer.parseInt(iterator.next());
            powerEntry.releaseAnim = Integer.parseInt(iterator.next());
            powerEntry.targetSelect = mbEnums.TargetSelectType.valueOf(iterator.next());

            // Process key value pairs after header

            iterator = Arrays.stream(lineData).iterator();
            iterator.next(); // Ignore header

            while (iterator.hasNext()) {

                String lineValue = iterator.next();
                String[] lineValues = lineValue.split("=");
                String key = lineValues[0].trim();
                PowerAction powerAction;
                String[] arguments;

                switch (key) {
                    case "ACTION":
                        powerAction = new PowerAction();
                        arguments = lineValues[1].trim().split(" ");
                        powerAction.effect_id = arguments[0];
                        powerAction.minTrains = Integer.parseInt(arguments[1]);
                        powerAction.maxTrains = Integer.parseInt(arguments[2]);
                        powerAction.duration = Integer.parseInt(arguments[3]);
                        powerAction.curve = mbEnums.CompoundCurveType.valueOf(arguments[4]);
                        powerAction.stackingCategory = arguments[5];
                        powerAction.stackingPriority = Integer.parseInt(arguments[6]);
                        powerAction.categoryToPower = mbEnums.CategoryToPowerType.valueOf(arguments[7]);
                        powerEntry.actions.add(powerAction);
                        break;
                    case "MaxLevel":
                        powerEntry.maxLevel = Integer.parseInt(lineValues[1].trim());
                        break;
                    case "HateValue":
                        arguments = lineValues[1].trim().split(" ");
                        powerEntry.hateValue = Integer.parseInt(arguments[0]);

                        // Not all entries have a curve.  Defaults to DefaultFlat;

                        if (arguments.length > 1)
                            powerEntry.hateCurve = mbEnums.CompoundCurveType.valueOf(arguments[1]);
                        break;
                    case "LOOPANIMID":
                        powerEntry.loopAnimID = Integer.parseInt(lineValues[1].trim());
                        break;
                    case "GRANTOVERRIDEVAR":
                        powerEntry.grantOverrideVar = lineValues[1].trim();
                        break;
                    case "DESCRIPTION":
                        powerEntry.description.add(lineValues[1].trim());
                        break;
                    case "CATEGORY":
                        powerEntry.category = lineValues[1].trim();
                        break;
                    case "CURVE":
                        arguments = lineValues[1].trim().split(" ");
                        powerEntry.slopeType = arguments[0];
                        powerEntry.curve = mbEnums.CompoundCurveType.valueOf(arguments[1]);
                        break;
                    case "EQPREREQ":
                        EquipmentPreReq equipmentPreReq = new EquipmentPreReq();
                        arguments = lineValues[1].trim().split(" ");

                        equipmentPreReq.slot = mbEnums.EquipSlotType.valueOf(arguments[0]);
                        equipmentPreReq.skill = arguments[1].trim();
                        equipmentPreReq.level = Integer.parseInt(arguments[2].trim());
                        break;
                    case "CANCASTWHILEMOVING":
                        powerEntry.canCastWhileMoving = Boolean.parseBoolean(lineValues[1].trim());
                        break;
                    case "BLADETRAILS":
                        powerEntry.bladeTrails = Boolean.parseBoolean(lineValues[1].trim());
                        break;
                    case "SOUNDS":   // Values not parsed
                    case "APPLYDAMAGECASTER":
                    case "APPLYDAMAGEOTHER":
                    case "APPLYDAMAGETARGET":
                    case "APPLYEFFECTSELF":
                    case "APPLYEFFECTOTHER":
                    case "FIZZLEOTHER":
                    case "FIZZLESELF":
                    case "INITSTRING":
                    case "SUCCESSOTHER":
                    case "SUCCESSSELF":
                    case "WEAROFFEFFECTOTHER":
                    case "WEAROFFEFFECTSELF":
                        break;
                    default:
                        Logger.error("Unhandled variable type:" + key);
                }
            }

        } catch (Exception e) {
            Logger.error(powerEntry.power_id + " " + e);
        }

        return powerEntry;
    }

}