DialogueScriptParser.java

package com.osroyale.content.dialogue.script;
 
import com.osroyale.content.dialogue.Expression;
import com.osroyale.util.MessageColor;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Stream;

 
public class DialogueScriptParser {
    
    private static final Logger logger = LogManager.getLogger(DialogueScriptParser.class);
    private static final Map<Integer, DialogueScript> scripts = new HashMap<>();
    
    private static final Pattern DIALOGUE_PATTERN = Pattern.compile("@dialogue\\s+npc:(.+)");
    private static final Pattern NPC_PATTERN = Pattern.compile("npc\\(\"(.+?)\"(?:,\\s*\"(.+?)\")?\\)");
    private static final Pattern PLAYER_PATTERN = Pattern.compile("player\\(\"(.+?)\"(?:,\\s*\"(.+?)\")?\\)");
    private static final Pattern MESSAGE_PATTERN = Pattern.compile("message\\(\"(.+?)\"\\)");
    private static final Pattern OPTION_PATTERN = Pattern.compile("option\\((.+)\\)");
    
    public static void loadAll() {
        scripts.clear();
        
        try {
            Path scriptDir = Paths.get("./data/dialogue/scripts");
            if (!Files.exists(scriptDir)) {
                Files.createDirectories(scriptDir);
                logger.info("Created dialogue scripts directory");
                return;
            }
            
            try (Stream<Path> paths = Files.walk(scriptDir)) {
                paths.filter(Files::isRegularFile)
                     .filter(path -> path.toString().endsWith(".asc"))
                     .forEach(DialogueScriptParser::loadScript);
            }
            
            logger.info("Loaded {} dialogue scripts", MessageColor.DARK_GREEN, scripts.size());
        } catch (IOException e) {
            logger.error("Error loading dialogue scripts", e);
        }
    }
    
    private static void loadScript(Path path) {
        try (BufferedReader reader = new BufferedReader(new FileReader(path.toFile()))) {
            String line;
            DialogueScript currentScript = null;
            List<String> currentMessages = new ArrayList<>();
            
            while ((line = reader.readLine()) != null) {
                line = line.trim();
                
                if (line.isEmpty() || line.startsWith("#") || line.startsWith("//")) {
                    continue;
                }
                
                Matcher dialogueMatcher = DIALOGUE_PATTERN.matcher(line);
                if (dialogueMatcher.matches()) {
                    if (currentScript != null) {
                        registerScript(currentScript);
                    }
                    
                    String npcIdString = dialogueMatcher.group(1).trim();
                    int[] npcIds = parseNpcIds(npcIdString);
                    currentScript = new DialogueScript(npcIds);
                    continue;
                }
                
                if (currentScript == null) {
                    continue;
                }
                
                Matcher npcMatcher = NPC_PATTERN.matcher(line);
                if (npcMatcher.matches()) {
                    String message1 = npcMatcher.group(1);
                    String message2 = npcMatcher.group(2);
                    
                    String[] messages = message2 != null ? 
                        new String[] { message1, message2 } : 
                        new String[] { message1 };
                    
                    currentScript.addAction(new DialogueScript.NpcDialogueAction(messages, Expression.DEFAULT));
                    continue;
                }
                
                Matcher playerMatcher = PLAYER_PATTERN.matcher(line);
                if (playerMatcher.matches()) {
                    String message1 = playerMatcher.group(1);
                    String message2 = playerMatcher.group(2);
                    
                    String[] messages = message2 != null ? 
                        new String[] { message1, message2 } : 
                        new String[] { message1 };
                    
                    currentScript.addAction(new DialogueScript.PlayerDialogueAction(messages, Expression.DEFAULT));
                    continue;
                }
                
                Matcher messageMatcher = MESSAGE_PATTERN.matcher(line);
                if (messageMatcher.matches()) {
                    String message = messageMatcher.group(1);
                    currentScript.addAction(new DialogueScript.StatementAction(new String[] { message }));
                    continue;
                }
                
                Matcher optionMatcher = OPTION_PATTERN.matcher(line);
                if (optionMatcher.matches()) {
                    String optionsString = optionMatcher.group(1);
                    String[] options = parseOptions(optionsString);
                    
                    currentScript.addAction(new DialogueScript.OptionAction("Select an option", options, new Runnable[options.length]));
                    continue;
                }
            }
            
            if (currentScript != null) {
                registerScript(currentScript);
            }
            
        } catch (IOException e) {
            logger.error("Error loading script: " + path, e);
        }
    }
    
    private static int[] parseNpcIds(String npcIdString) {
        String[] parts = npcIdString.split(",");
        int[] ids = new int[parts.length];
        
        for (int i = 0; i < parts.length; i++) {
            try {
                ids[i] = Integer.parseInt(parts[i].trim());
            } catch (NumberFormatException e) {
                logger.error("Invalid NPC ID: " + parts[i]);
            }
        }
        
        return ids;
    }
    
    private static String[] parseOptions(String optionsString) {
        List<String> options = new ArrayList<>();
        Pattern quotedPattern = Pattern.compile("\"([^\"]+)\"");
        Matcher matcher = quotedPattern.matcher(optionsString);
        
        while (matcher.find()) {
            options.add(matcher.group(1));
        }
        
        return options.toArray(new String[0]);
    }
    
    private static void registerScript(DialogueScript script) {
        for (int npcId : script.getNpcIds()) {
            scripts.put(npcId, script);
        }
    }
    
    public static Optional<DialogueScript> getScript(int npcId) {
        return Optional.ofNullable(scripts.get(npcId));
    }
    
    public static Map<Integer, DialogueScript> getScripts() {
        return Collections.unmodifiableMap(scripts);
    }
}