SpellsUtils.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2015 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

package net.sf.gridarta.gui.spells;

import java.awt.Component;
import java.io.BufferedReader;
import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.io.Reader;
import java.nio.charset.StandardCharsets;
import java.util.Date;
import java.util.Map;
import java.util.TreeMap;
import javax.swing.JFileChooser;
import javax.swing.filechooser.FileFilter;
import net.sf.gridarta.utils.FileChooserUtils;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import net.sf.japi.util.filter.file.FilenameFileFilter;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class SpellsUtils {

    private static final long READ_MAX = 10000L;

    @NotNull
    private static final Category LOG = Logger.getLogger(SpellsUtils.class);

    @NotNull
    private static final ActionBuilder ACTION_BUILDER = ActionBuilderFactory.getInstance().getActionBuilder("net.sf.gridarta");

    @NotNull
    private static final FileFilter SPELL_LIST_H_FILE_FILTER = new FilenameFileFilter(true, "spellist.h", "spellist.h");

    @NotNull
    private final String spellFile;

    public SpellsUtils(@NotNull final String spellFile) {
        this.spellFile = spellFile;
    }

    public void importSpells(@NotNull final File dir, @NotNull final Component parent) {
        // open a file chooser window
        final JFileChooser fileChooser = new JFileChooser();
        fileChooser.setDialogTitle("Open CF Spell List File");
        fileChooser.setFileSelectionMode(JFileChooser.FILES_ONLY);
        fileChooser.setMultiSelectionEnabled(false);
        fileChooser.setFileFilter(SPELL_LIST_H_FILE_FILTER);  // apply file filter
        final File cd = new File(System.getProperty("user.dir"));
        final File sd = new File(cd, "../server/src/include");
        FileChooserUtils.setCurrentDirectory(fileChooser, sd.exists() ? sd : cd);

        final int returnVal = fileChooser.showOpenDialog(parent);

        if (returnVal == JFileChooser.APPROVE_OPTION) {
            // now import spells from selected file
            final File tmpSpellFile = fileChooser.getSelectedFile();
            final int spNum = importSpells(tmpSpellFile, dir);
            if (spNum > 0) {
                // yeah it worked
                ACTION_BUILDER.showMessageDialog(parent, "importSpellsSuccess", spNum);
            } else {
                // spell collect failed
                ACTION_BUILDER.showMessageDialog(parent, "importSpellsFailed");
            }
        }
    }

    private int importSpells(final File spellFile, @NotNull final File dir) {
        final Map<String, String> spells = new TreeMap<>();
        if (spellFile.getName().equalsIgnoreCase("spellist.h")) {
            try {
                try (InputStream fis = new FileInputStream(spellFile.getAbsolutePath())) {
                    try (Reader isr = new InputStreamReader(fis)) {
                        try (Reader in = new BufferedReader(isr)) {
                            readUntil(in, "spell spells", null);
                            readUntil(in, "{", null);

                            int counter = 0;
                            while (true) {
                                try {
                                    readUntil(in, "{", "}");
                                } catch (final EOFException ignored) {
                                    // Eventually expected exception, don't handle.
                                    break;
                                }
                                readUntil(in, "\"", null);
                                final String name = readUntil(in, "\"").trim();
                                readUntil(in, "}", null);

                                spells.put(name, Integer.toString(counter++));
                            }
                        }
                    }
                }
            } catch (final FileNotFoundException ignored) {
                LOG.error("File '" + spellFile.getAbsolutePath() + "' not found!");
            } catch (final IOException ex) {
                LOG.error("Cannot read file '" + spellFile.getAbsolutePath() + "': " + ex.getMessage());
            }
        }

        // --------- now write the "spells.def" file ---------
        if (!spells.isEmpty()) {
            // FIXME: This should use DOM for writing the file.
            // create new file for writing (replaces old one if existent)
            if (!dir.exists() || !dir.isDirectory()) { // FIXME What if dir exists and is not a directory? mkdirs will fail then!
                // create the config dir
                dir.mkdirs();
            }
            final File dirFile = new File(dir, this.spellFile);

            try {
                try (PrintWriter out = new PrintWriter(new OutputStreamWriter(new FileOutputStream(dirFile), StandardCharsets.UTF_8))) {
                    // header:
                    out.println("<?xml version=\"1.0\" encoding=\"UTF-8\" ?>");
                    out.println("<!DOCTYPE spells SYSTEM \"spells.dtd\">");
                    out.println("<!--");
                    out.println("  - ##########################################################");
                    out.println("  - #   You may add new spells to this file, but there's no  #");
                    out.println("  - #  need to do it because the file can be auto-generated. #");
                    out.println("  - # In the editor, select menu \"Resources->Collect Spells\" #");
                    out.println("  - #        to generate a new version of this file.         #");
                    out.println("  - ##########################################################");
                    out.println("  -->");
                    out.println("<!-- Generated on: " + new Date() + " -->");
                    out.println("<spells>");

                    final String[] spaces = { "  ", " ", "" };
                    for (final Map.Entry<String, String> entry : spells.entrySet()) {
                        final String id = entry.getValue();
                        out.println("  <spell id=\"" + id + '\"' + spaces[id.length() - 1] + " name=\"" + entry.getKey() + "\" />");
                    }
                    out.println("</spells>");
                }
            } catch (final IOException ex) {
                LOG.error("Cannot write file '" + dirFile.getAbsolutePath() + "': " + ex.getMessage());
            }
        }
        return spells.size();
    }

    private static void readUntil(@NotNull final Reader stream, @NotNull final CharSequence tag, @Nullable final CharSequence abort) throws IOException {
        int c; // character value, read from the stream
        int t = 0; // tag index
        int a = 0; // abort index

        if (abort != null) {
            // look both for 'tag' and 'abort'
            do {
                c = stream.read();
                if (c == tag.charAt(t)) {
                    t++;
                } else {
                    t = 0;
                }
                if (c == abort.charAt(a)) {
                    a++;
                } else {
                    a = 0;
                }
            } while (t < tag.length() && a < abort.length() && c != -1);
        } else {
            // look only for 'tag'
            do {
                c = stream.read();
                if (c == tag.charAt(t)) {
                    t++;
                } else {
                    t = 0;
                }
            } while (t < tag.length() && c != -1);
        }

        // if we did not find the tag, an EOFException is thrown
        if (c == -1) {
            throw new EOFException();
        }

        // if we found the string 'abort', throw EOFException as well
        if (abort != null && a == abort.length()) {
            throw new EOFException();
        }
    }

    private static String readUntil(@NotNull final Reader stream, @NotNull final CharSequence tag) throws IOException {
        final StringBuilder sb = new StringBuilder();
        int c; // character value, read from the stream
        int t = 0; // index

        long count = 0L; // counter (to realize when shooting past EOF)
        final long maxCount = READ_MAX; // bail out when counter exceeds this value

        do {
            c = stream.read(); // read one character
            sb.append((char) c);
            if (c == tag.charAt(t)) {
                t++;
            } else {
                t = 0;
            }
        } while (t < tag.length() && c != -1 && count++ < maxCount);

        // if we did not find the tag, an EOFException is thrown
        if (c == -1 || count >= maxCount) {
            throw new EOFException();
        }
        // cut 'tag' off, at the end of the string
        return sb.substring(0, sb.length() - tag.length());
    }

}