ArtifactParser.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.model.artifact;
 
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FilenameFilter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetype.UndefinedArchetypeException;
import net.sf.gridarta.model.archetypeset.ArchetypeSet;
import net.sf.gridarta.model.errorview.ErrorView;
import net.sf.gridarta.model.errorview.ErrorViewCategory;
import net.sf.gridarta.model.errorview.ErrorViewCollector;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.io.AbstractArchetypeParser;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.utils.IOUtils;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class ArtifactParser<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> {
 
    @NotNull
    private static final Category LOG = Logger.getLogger(ArtifactParser.class);
 
    @NotNull
    private final ArchetypeSet<G, A, R> archetypeSet;
 
    @NotNull
    private final ErrorView errorView;
 
    @NotNull
    private final AbstractArchetypeParser<G, A, R, ?> archetypeParser;
 
    @NotNull
    private final List<G> invObjects = new ArrayList<>();
 
    @NotNull
    private final FilenameFilter artifactFilenameFilter = new FilenameFilter() {
 
        @Override
        public boolean accept(final File dir, final String name) {
            final File fullPath = new File(dir, name);
            // TODO: Replace this with a proper FileFilter.
            return fullPath.isDirectory() && !name.equalsIgnoreCase("cvs") && !name.equalsIgnoreCase(".xvpics") && !name.equalsIgnoreCase(".svn") || name.toLowerCase().endsWith(".art");
        }
 
    };
 
    public ArtifactParser(@NotNull final ArchetypeSet<G, A, R> archetypeSet, @NotNull final ErrorView errorView, @NotNull final AbstractArchetypeParser<G, A, R, ?> archetypeParser) {
        this.archetypeSet = archetypeSet;
        this.errorView = errorView;
        this.archetypeParser = archetypeParser;
    }
 
    @NotNull
    public Collection<G> getInvObjects() {
        return Collections.unmodifiableCollection(invObjects);
    }
 
    public void loadArchesFromArtifacts(@NotNull final File f, @NotNull final String panelName, @NotNull final String folderName) {
        final int archetypes = archetypeSet.getArchetypeCount();
        loadArchesFromArtifactsRecursive(f, "", panelName, folderName);
        if (LOG.isInfoEnabled()) {
            LOG.info("Loaded " + (archetypeSet.getArchetypeCount() - archetypes) + " artifacts from '" + f + "'.");
        }
    }
 
    private void loadArchesFromArtifactsRecursive(@NotNull final File f, @NotNull final String archPath, @NotNull final String panelName, @NotNull final String folderName) {
        if (f.isDirectory()) {
            final String[] traverse = f.list(artifactFilenameFilter);
            if (traverse != null) {
                Arrays.sort(traverse);
                for (final String entry : traverse) {
                    loadArchesFromArtifactsRecursive(new File(f, entry), archPath + "/" + entry, panelName, folderName);
                }
            }
        } else {
            loadArtifact(new ErrorViewCollector(errorView, f), f, archPath, panelName, folderName);
        }
    }
 
    private void loadArtifact(@NotNull final ErrorViewCollector errorViewCollector, @NotNull final File f, @NotNull final String archPath, @NotNull final String panelName, @NotNull final String folderName) {
        try {
            try (FileInputStream fis = new FileInputStream(f)) {
                try (InputStreamReader isr = new InputStreamReader(fis, IOUtils.MAP_ENCODING)) {
                    try (BufferedReader in = new BufferedReader(isr)) {
                        loadArtifact(in, errorViewCollector, archPath, panelName, folderName);
                    }
                }
            }
        } catch (final IOException ex) {
            errorViewCollector.addWarning(ErrorViewCategory.ARTIFACT_FILE_INVALID, ex.getMessage());
        }
    }
 
    public void loadArtifact(@NotNull final BufferedReader in, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final String archPath, @NotNull final String panelName, @NotNull final String folderName) throws IOException {
        int editorCode = -1;
        @Nullable String name = null;
        @Nullable String defArchName = null;
        int lineCount = 0;
 
        @Nullable String editorPath = null;
        while (true) {
            final String thisLine2 = in.readLine();
            if (thisLine2 == null) {
                break;
            }
            lineCount++;
            final String thisLine = thisLine2.trim();
            // ignore white space lines or '#' comment lines
            if (!thisLine.startsWith("#") && !thisLine.isEmpty()) {
                if (thisLine.startsWith("artifact ")) {
                    name = thisLine.substring(9);
                } else if (thisLine.startsWith("def_arch ")) {
                    defArchName = thisLine.substring(9);
                } else if (thisLine.startsWith("editor ")) {
                    final String editor = thisLine.substring(7);
                    final int tIndex = editor.indexOf(':');
                    if (tIndex == -1) {
                        editorCode = Integer.parseInt(editor);
                    } else {
                        editorPath = editor.substring(tIndex + 1);
                        // TODO: use editorPath for determining the place of this GameObject
                        editorCode = Integer.parseInt(editor.substring(0, tIndex));
                    }
                } else if (thisLine.startsWith("Object")) {
                    if (editorCode == -1) {
                        // TOOD: Warn user
                    }
                    if (editorCode == 0 || editorCode == 2/* || editorCode == -1 */) {
                        // TODO: read until "end"
                    }
                    final String objTitle = thisLine.length() > 7 ? thisLine.substring(7) : "";
                    // TODO: Allow not having a def arch
                    // at this point we MUST have a legal name and def arch
                    if (defArchName == null) {
                        errorViewCollector.addWarning(ErrorViewCategory.ARTIFACT_ENTRY_INVALID, "line " + lineCount + ", Object '" + defArchName + "' / '" + name + "' / '" + objTitle + "' has missing def_arch");
                    } else if (defArchName.isEmpty()) {
                        errorViewCollector.addWarning(ErrorViewCategory.ARTIFACT_ENTRY_INVALID, "line " + lineCount + ", Object '" + defArchName + "' / '" + name + "' / '" + objTitle + "' has empty def_arch");
                    } else if (name == null) {
                        errorViewCollector.addWarning(ErrorViewCategory.ARTIFACT_ENTRY_INVALID, "line " + lineCount + ", Object '" + defArchName + "' / '" + name + "' / '" + objTitle + "' has missing name");
                    } else if (name.isEmpty()) {
                        errorViewCollector.addWarning(ErrorViewCategory.ARTIFACT_ENTRY_INVALID, "line " + lineCount + ", Object '" + defArchName + "' / '" + name + "' / '" + objTitle + "' has empty name");
                    } else {
                        try {
                            final R archetype = archetypeSet.getArchetype(defArchName);
                            if (editorCode != 0 && editorCode != 2) { // the next line of our file is part of a arch parse until a "end" comes
                                // now the editor will do the same as the real server:
                                // get the default arch as base and parse the new values over it
                                // the extended functions of the artifacts file can be ignored here.
                                archetypeParser.parseArchetypeFromStream(in, editorCode == 2 ? null : archetype, thisLine, name, panelName, folderName, archPath, invObjects, errorViewCollector); // XXX: editorCode == 2 looks incorrect due to the enclosing condition editorCode != 2
                                // note: in the parser is a small part where we handle the title setting
                                // and the reverse type setting for type == -1 (unique items marker in artifacts file)
                            } else {
                                while (true) {
                                    final String thisLine3 = in.readLine();
                                    if (thisLine3 == null || thisLine3.equals("end")) {
                                        break;
                                    }
                                }
                            }
                        } catch (final UndefinedArchetypeException ex) {
                            errorViewCollector.addWarning(ErrorViewCategory.ARTIFACT_ENTRY_INVALID, "line " + lineCount + ", Object '" + defArchName + "' / '" + name + "' / '" + objTitle + "' references undefined archetype '" + ex.getMessage() + "'");
                        }
                    }
                    name = null;
                    defArchName = null;
                    editorPath = null;
                    editorCode = -1;
                }
            }
        }
    }
 
}