AbstractArchetypeParser.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.io;

import java.io.BufferedReader;
import java.io.IOException;
import java.util.List;
import net.sf.gridarta.model.anim.AnimationObjects;
import net.sf.gridarta.model.anim.DuplicateAnimationException;
import net.sf.gridarta.model.anim.IllegalAnimationException;
import net.sf.gridarta.model.archetype.AbstractArchetypeBuilder;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetype.DuplicateArchetypeException;
import net.sf.gridarta.model.archetypeset.ArchetypeSet;
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.maparchobject.MapArchObject;
import net.sf.gridarta.utils.StringUtils;
import net.sf.japi.swing.action.ActionBuilder;
import net.sf.japi.swing.action.ActionBuilderFactory;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public abstract class AbstractArchetypeParser<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>, B extends AbstractArchetypeBuilder<G, A, R>> implements ArchetypeParser<G, A, R> {

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

    @NotNull
    private final B archetypeBuilder;

    @NotNull
    private final AnimationObjects animationObjects;

    @NotNull
    private final ArchetypeSet<G, A, R> archetypeSet;

    protected AbstractArchetypeParser(@NotNull final B archetypeBuilder, @NotNull final AnimationObjects animationObjects, @NotNull final ArchetypeSet<G, A, R> archetypeSet) {
        this.archetypeBuilder = archetypeBuilder;
        this.animationObjects = animationObjects;
        this.archetypeSet = archetypeSet;
    }

    @Override
    public void parseArchetypeFromStream(@NotNull final BufferedReader in, @Nullable final R prototype, @Nullable final String line, @Nullable final String archName, @NotNull final String panelName, @NotNull final String folderName, @NotNull final String archPath, @NotNull final List<G> invObjects, @NotNull final ErrorViewCollector errorViewCollector) throws IOException {
        archetypeBuilder.init(prototype, errorViewCollector);
        final boolean isInternPath;
        // path is needed when we don't read from collection because there is no editor_folder in arc files
        @Nullable final String path;
        if (!archetypeSet.isLoadedFromArchive() && archName == null) {
            final String tmpPath = archPath + "/";
            isInternPath = tmpPath.startsWith("/intern/");
            path = tmpPath;
        } else {
            isInternPath = false;
            path = "";
        }

        String thisLine2;
        if (line == null) {
            thisLine2 = in.readLine();
        } else {
            thisLine2 = line; // pre read "Object" from artifacts file loader
        }

        initParseArchetype();
        @Nullable R firstArch = null;
        boolean archMore = false;
        R lastArch = null;
        boolean reportError = true;

LOOP:
        while (true) {
            while (true) {
                if (thisLine2 == null) {
                    break LOOP;
                }

                final String thisLine = thisLine2.trim();
                if (thisLine.startsWith("#") || thisLine.isEmpty()) {
                    thisLine2 = in.readLine();
                    continue;
                }

                if (thisLine.equals("More")) {
                    if (firstArch == null) {
                        firstArch = lastArch;
                    }
                    archMore = true;
                } else if (isStartLine(thisLine)) {
                    break;
                } else if (!thisLine.isEmpty() && thisLine.charAt(0) != '#') {
                    if (reportError) {
                        reportError = false;
                        errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, "unexpected line: " + thisLine);
                    }
                }

                thisLine2 = in.readLine();
            }

            final String archetypeName = archName != null ? archName : thisLine2.trim().substring(7);
            archetypeBuilder.reInit(archetypeName);
            if (!archMore) {
                if (firstArch != null) {
                    finishParseArchetype(firstArch);
                }
                firstArch = null;
            }

            initParseArchetype();

            @NotNull String editorFolder = archPath.isEmpty() ? "default" : archPath;
            while (true) {
                thisLine2 = in.readLine();
                if (thisLine2 == null) {
                    errorViewCollector.addError(ErrorViewCategory.ARCHETYPE_INVALID, "missing 'end' line");
                    break LOOP;
                }

                final String thisLine = thisLine2.trim();
                if (thisLine.startsWith("#") || thisLine.isEmpty()) {
                    continue;
                }

                if (processLine(in, thisLine, thisLine2, archetypeBuilder, errorViewCollector, invObjects)) {
                    // ignore
                } else if (isStartLine(thisLine)) {
                    errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, ACTION_BUILDER.format("logInventoryInDefArch", thisLine));
                } else if (thisLine.equals("end")) {
                    break;
                } else if (thisLine.equals("msg")) {
                    parseMsg(in, errorViewCollector);
                } else if (thisLine.equals("anim")) {
                    parseAnim(in, errorViewCollector, path);
                } else if (thisLine.startsWith("visibility ")) {
                    errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, "Ignoring obsolete 'visibility' attribute: " + archetypeBuilder.getArchetypeName());
                } else if (thisLine.startsWith("magicmap ")) {
                    errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, "Ignoring obsolete 'magicmap' attribute: " + archetypeBuilder.getArchetypeName());
                } else if (thisLine.startsWith("x ")) {
                    if (!archMore && !archetypeBuilder.getArchetypeName().equals(START_ARCH_NAME)) {
                        errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, ACTION_BUILDER.format("logFoundCoordInDefArchSingleSquareOrHead", "x", archetypeBuilder.getArchetypeName()));
                        archetypeBuilder.addObjectText(thisLine);
                    } else {
                        archetypeBuilder.setMultiX(Integer.parseInt(thisLine.substring(2)));
                    }
                } else if (thisLine.startsWith("y ")) {
                    if (!archMore && !archetypeBuilder.getArchetypeName().equals(START_ARCH_NAME)) {
                        errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, ACTION_BUILDER.format("logFoundCoordInDefArchSingleSquareOrHead", "y", archetypeBuilder.getArchetypeName()));
                        archetypeBuilder.addObjectText(thisLine);
                    } else {
                        archetypeBuilder.setMultiY(Integer.parseInt(thisLine.substring(2)));
                    }
                } else if (thisLine.startsWith("editor_folder ")) {
                    editorFolder = thisLine.substring(14).trim();
                } else {
                    archetypeBuilder.addObjectText(thisLine);
                }
            }

            final R archetype = archetypeBuilder.finish();

            if (firstArch != null) {
                firstArch.addTailPart(archetype);
            } else if (addToPanel(isInternPath, editorFolder, archetype)) {
                final String panel;
                final String folder;
                if (!archetypeSet.isLoadedFromArchive() || archName != null) {
                    panel = panelName;
                    folder = folderName;
                } else {
                    final String[] names = StringUtils.PATTERN_SLASH.split(editorFolder, 3);
                    panel = names[0];
                    folder = names.length >= 2 ? names[1] : names[0];
                }
                archetype.setEditorFolder(panel + "/" + folder);
            } else {
                archetype.setEditorFolder(GameObject.EDITOR_FOLDER_INTERN);
            }
            finishParseArchetypePart(firstArch, archetype, errorViewCollector);
            try {
                archetypeSet.addArchetype(archetype);
            } catch (final DuplicateArchetypeException ex) {
                errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, ex.getMessage());
            }

            archMore = false;

            if (archName != null) {
                archetype.setArtifact();
                if (prototype != null) {
                    archetype.addObjectText(AttributeListUtils.diffArchTextKeys(archetype, prototype));
                }
                break;
            }
            lastArch = archetype;
            reportError = true;

            thisLine2 = in.readLine();
        }

        if (firstArch != null) {
            finishParseArchetype(firstArch);
        }
    }

    private void parseMsg(@NotNull final BufferedReader in, @NotNull final ErrorViewCollector errorViewCollector) throws IOException {
        final StringBuilder msgText = new StringBuilder();

        while (true) {
            final String thisLine2 = in.readLine();
            if (thisLine2 == null) {
                errorViewCollector.addError(ErrorViewCategory.ARCHETYPE_INVALID, "Truncated archetype: msg not terminated by endmsg");
                return;
            }

            final String thisLine3 = thisLine2.trim();
            if (thisLine3.equals("endmsg")) {
                break;
            }

            // keep leading whitespace
            msgText.append(thisLine2).append("\n");
        }

        if (msgText.length() > 0) {
            archetypeBuilder.setMsgText(msgText.toString());
        }
    }

    private void parseAnim(@NotNull final BufferedReader in, @NotNull final ErrorViewCollector errorViewCollector, @NotNull final String path) throws IOException {
        final StringBuilder animText = new StringBuilder();

        while (true) {
            final String thisLine2 = in.readLine();
            if (thisLine2 == null) {
                errorViewCollector.addError(ErrorViewCategory.ARCHETYPE_INVALID, "Truncated animation: anim not terminated by mina");
                return;
            }

            final String thisLine3 = thisLine2.trim();
            if (thisLine3.startsWith("#") || thisLine3.isEmpty()) {
                continue;
            }

            if (thisLine3.equals("mina")) {
                break;
            }

            animText.append(thisLine3).append("\n");
        }

        final String animationName = "_" + archetypeBuilder.getArchetypeName();
        try {
            animationObjects.addAnimationObject(animationName, animText.toString(), path + animationName);
        } catch (final DuplicateAnimationException e) {
            errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, ACTION_BUILDER.format("logDuplicateAnimation", e.getDuplicate().getAnimName()));
        } catch (final IllegalAnimationException ex) {
            errorViewCollector.addWarning(ErrorViewCategory.ARCHETYPE_INVALID, "illegal animation: " + ex.getAnimationObject().getPath());
        }
    }

    protected abstract void initParseArchetype();

    protected abstract boolean isStartLine(@NotNull String line);

    protected abstract boolean processLine(@NotNull BufferedReader in, @NotNull String line, @NotNull String line2, @NotNull B archetypeBuilder, @NotNull ErrorViewCollector errorViewCollector, @NotNull List<G> invObjects) throws IOException;

    protected abstract void finishParseArchetypePart(@Nullable R firstArch, @NotNull R archetype, @NotNull ErrorViewCollector errorViewCollector);

    protected abstract void finishParseArchetype(@NotNull R archetype);

    protected abstract boolean addToPanel(boolean isInternPath, @NotNull String editorFolder, @NotNull R archetype);

}