AbstractGameObjectParser.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 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.awt.Point;
import java.io.BufferedReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetypeset.ArchetypeSet;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.gameobject.GameObjectFactory;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.utils.StringUtils;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class AbstractGameObjectParser<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements GameObjectParser<G, A, R> {
 
    private static final Category LOG = Logger.getLogger(AbstractGameObjectParser.class);
 
    @NotNull
    private final GameObjectFactory<G, A, R> gameObjectFactory;
 
    @NotNull
    private final ArchetypeSet<G, A, R> archetypeSet;
 
    protected AbstractGameObjectParser(@NotNull final GameObjectFactory<G, A, R> gameObjectFactory, @NotNull final ArchetypeSet<G, A, R> archetypeSet) {
        this.gameObjectFactory = gameObjectFactory;
        this.archetypeSet = archetypeSet;
    }
 
    @Nullable
    @Override
    public G load(@NotNull final BufferedReader reader, @Nullable final Collection<G> objects) throws IOException {
        final String line = reader.readLine();
        return line == null ? null : load(reader, line, objects);
    }
 
    @Nullable
    @Override
    public G load(@NotNull final BufferedReader reader, @NotNull final String firstLine, @Nullable final Collection<G> objects) throws IOException {
        final String archName = readArchName(reader, firstLine);
        if (archName == null) {
            return null;
        }
 
        final R archetype = archetypeSet.getOrCreateArchetype(archName);
        final G gameObject = gameObjectFactory.createGameObject(archetype);
 
        while (true) {
            final String thisLine2 = reader.readLine();
            if (thisLine2 == null) {
                throw new IOException("unexpected end of file while reading 'arch " + archName + "'");
            }
            final String thisLine = thisLine2.trim();
 
            if (thisLine.startsWith("arch ")) {
                final G invItem = load(reader, thisLine, objects);
                assert invItem != null : "invItem must not be null here.";
                gameObject.addLast(invItem);
            } else if (thisLine.equals("end")) {
                if (objects != null) {
                    objects.add(gameObject);
                }
                return gameObject;
            } else if (thisLine.equals("msg")) {
                gameObject.setMsgText("");
                while (true) {
                    final String thisLine3 = reader.readLine();
                    if (thisLine3 == null) {
                        throw new IOException("unexpected end of file while reading 'arch " + archName + "'");
                    }
 
                    if (thisLine3.trim().equals("endmsg")) {
                        break;
                    }
 
                    gameObject.addMsgTextLine(thisLine3);
                }
            } else if (parseLine(thisLine, gameObject)) {
                // ignore
            } else if (thisLine.startsWith("x ")) {
                gameObject.setMapX(Integer.parseInt(thisLine.substring(2)));
            } else if (thisLine.startsWith("y ")) {
                gameObject.setMapY(Integer.parseInt(thisLine.substring(2)));
            } else {
                gameObject.addObjectText(thisLine);
            }
        }
    }
 
    private boolean parseLine(@NotNull final String line, @NotNull final G gameObject) {
        return false;
    }
 
    @Nullable
    private static String readArchName(@NotNull final BufferedReader reader, @NotNull final String firstLine) throws IOException {
        for (String thisLine2 = firstLine; thisLine2 != null; thisLine2 = reader.readLine()) {
            final String thisLine = thisLine2.trim();
            if (thisLine.startsWith("arch ")) {
                return thisLine.substring(5).trim();
            }
            if (!thisLine.isEmpty() && !thisLine.startsWith("#")) {
                throw new IOException("unexpected first line of game object: '" + thisLine + "', expected 'arch ...'");
            }
        }
        return null;
    }
 
    @Override
    public void collectTempList(@NotNull final List<G> objects) {
        final Collection<G> tailList = new ArrayList<>();
 
        for (final G gameObject : objects) {
            if (!gameObject.isInContainer()) {
                expandMulti(gameObject, tailList);
            }
        }
 
        objects.addAll(tailList);
    }
 
    @Override
    public void save(@NotNull final Appendable appendable, @NotNull final G gameObject) throws IOException {
        final Map<String, String> fields = getModifiedFields(gameObject);
 
        appendable.append("arch ");
        appendable.append(gameObject.getArchetype().getArchetypeName());
        appendable.append("\n");
        for (final Entry<String, String> entry : fields.entrySet()) {
            final String key = entry.getKey();
            appendable.append(key);
            if (key.equals("msg")) {
                appendable.append("\n");
                appendable.append(entry.getValue());
                appendable.append("endmsg\n");
            } else {
                appendable.append(" ");
                appendable.append(entry.getValue());
                appendable.append("\n");
            }
        }
 
        for (final G inventoryItem : gameObject) {
            save(appendable, inventoryItem);
        }
 
        appendable.append("end\n");
    }
 
    @Override
    public void addModifiedFields(@NotNull final G gameObject, @NotNull final Map<String, String> fields) {
        final BaseObject<G, A, R, ?> archetype = gameObject.getArchetype();
 
        final String msgText = gameObject.getMsgText(false);
        final String archMsgText = archetype.getMsgText(false);
        if (msgText != null && !msgText.equals(archMsgText == null ? "" : archMsgText)) {
            fields.put("msg", msgText);
        }
 
        final CharSequence objText = gameObject.getObjectText();
        if (objText.length() != 0) {
            for (final String aTmp : StringUtils.PATTERN_END_OF_LINE.split(objText, 0)) {
                final String[] line = StringUtils.PATTERN_SPACES.split(aTmp, 2);
                if (line.length == 2) {
                    fields.put(line[0], line[1]);
                } else {
                    LOG.warn("writeMapArch: ignoring invalid arch line: " + aTmp);
                }
            }
        }
 
        // map coordinates only belong into map arches (not inventory arches)
        if (gameObject.getMapX() != 0) {
            fields.put("x", Integer.toString(gameObject.getMapX()));
        }
        if (gameObject.getMapY() != 0) {
            fields.put("y", Integer.toString(gameObject.getMapY()));
        }
    }
 
    private void expandMulti(@NotNull final G gameObject, @NotNull final Collection<G> objects) {
        final Archetype<G, A, R> archetype = gameObject.getArchetype();
 
        if (!archetype.isMulti() || gameObject.getMultiRefCount() > 1) {
            return;
        }
 
        if (gameObject.isInContainer()) {
            LOG.warn("Multi-part expansion for a GameObject inside a container requested.");
            return;
        }
 
        // do insertion for all non-head parts of the multi
        final Point pos = gameObject.getMapLocation();
        for (R oldPart = archetype.getMultiNext(); oldPart != null; oldPart = oldPart.getMultiNext()) {
            final G tailGameObject = gameObjectFactory.createGameObjectPart(oldPart, gameObject);
            tailGameObject.setMapX(pos.x + oldPart.getMultiX());
            tailGameObject.setMapY(pos.y + oldPart.getMultiY());
            objects.add(tailGameObject);
        }
    }
 
}