AbstractMapArchObject.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.maparchobject;
 
import java.awt.Point;
import java.io.File;
import java.util.Arrays;
import java.util.Collection;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import net.sf.gridarta.model.direction.Direction;
import net.sf.gridarta.model.mapmodel.AbsoluteMapPath;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapPath;
import net.sf.gridarta.utils.Size2D;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class AbstractMapArchObject<A extends MapArchObject<A>> implements MapArchObject<A> {
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    public static final String MAP_NAME_UNNAMED = "<unnamed>";
 
    @NotNull
    private static final String MODIFIED_ATTRIBUTE = "Modified:";
 
    @NotNull
    private static final Pattern MODIFIED_ATTRIBUTE_PATTERN = Pattern.compile("^" + MODIFIED_ATTRIBUTE + " *(.*)$", Pattern.MULTILINE);
 
    @NotNull
    private static final Pattern MAP_FILE_NAME_PATTERN = Pattern.compile("((?:(?!_(?:[\\d-]+))[\\w_])+)_([\\d-]+)_([\\d-]+)(?:_([\\d-]+))?");
 
    @NotNull
    private final StringBuilder msgText = new StringBuilder();
 
    @NotNull
    private Size2D mapSize;
 
    @NotNull
    private String mapName;
 
    private int enterX;
 
    private int enterY;
 
    private boolean outdoor;
 
    private int resetTimeout;
 
    private int swapTime;
 
    private int difficulty;
 
    private boolean fixedReset;
 
    private int darkness;
 
    @NotNull
    private final String @NotNull [] tilePaths;
 
    @NotNull
    private final Collection<MapArchObjectListener> listenerList = new CopyOnWriteArrayList<>();
 
    private int transactionDepth;
 
    @Nullable
    private transient Thread transactionThread;
 
    private boolean attributeHasChanged;
 
    protected AbstractMapArchObject() {
        tilePaths = new String[Direction.values().length];
        Arrays.fill(tilePaths, "");
        mapSize = Size2D.ONE;
        mapName = MAP_NAME_UNNAMED;
    }
 
    protected AbstractMapArchObject(@NotNull final AbstractMapArchObject<A> mapArchObject) {
        msgText.append(mapArchObject.msgText);
        mapSize = mapArchObject.mapSize;
        mapName = mapArchObject.mapName;
        enterX = mapArchObject.enterX;
        enterY = mapArchObject.enterY;
        outdoor = mapArchObject.outdoor;
        resetTimeout = mapArchObject.resetTimeout;
        swapTime = mapArchObject.swapTime;
        difficulty = mapArchObject.difficulty;
        fixedReset = mapArchObject.fixedReset;
        darkness = mapArchObject.darkness;
        tilePaths = mapArchObject.tilePaths.clone();
    }
 
    @NotNull
    @Override
    public Size2D getMapSize() {
        return mapSize;
    }
 
    @Override
    public void setMapSize(@NotNull final Size2D mapSize) {
        if (this.mapSize.equals(mapSize)) {
            return;
        }
 
        this.mapSize = mapSize;
        setModified();
        for (final MapArchObjectListener listener : listenerList) {
            listener.mapSizeChanged(mapSize);
        }
    }
 
    @NotNull
    @Override
    public String getMapName() {
        return mapName;
    }
 
    @Override
    public void setMapName(@NotNull final String name) {
        final String trimmedName = name.trim();
        if (mapName.equals(trimmedName)) {
            return;
        }
 
        mapName = trimmedName;
        setModified();
    }
 
    @Override
    public int getEnterX() {
        return enterX;
    }
 
    @Override
    public void setEnterX(final int enterX) {
        if (this.enterX == enterX) {
            return;
        }
 
        this.enterX = enterX;
        setModified();
    }
 
    @Override
    public int getEnterY() {
        return enterY;
    }
 
    @Override
    public void setEnterY(final int enterY) {
        if (this.enterY == enterY) {
            return;
        }
 
        this.enterY = enterY;
        setModified();
    }
 
    @NotNull
    @Override
    public Point getEnter() {
        return new Point(enterX, enterY);
    }
 
    @Override
    public boolean isOutdoor() {
        return outdoor;
    }
 
    @Override
    public void setOutdoor(final boolean outdoor) {
        if (this.outdoor == outdoor) {
            return;
        }
 
        this.outdoor = outdoor;
        setModified();
    }
 
    @Override
    public int getResetTimeout() {
        return resetTimeout;
    }
 
    @Override
    public void setResetTimeout(final int resetTimeout) {
        if (this.resetTimeout == resetTimeout) {
            return;
        }
 
        this.resetTimeout = resetTimeout;
        setModified();
    }
 
    @Override
    public int getSwapTime() {
        return swapTime;
    }
 
    @Override
    public void setSwapTime(final int swapTime) {
        if (this.swapTime == swapTime) {
            return;
        }
 
        this.swapTime = swapTime;
        setModified();
    }
 
    @Override
    public int getDifficulty() {
        return difficulty;
    }
 
    @Override
    public void setDifficulty(final int difficulty) {
        if (this.difficulty == difficulty) {
            return;
        }
 
        this.difficulty = difficulty;
        setModified();
    }
 
    @Override
    public boolean isFixedReset() {
        return fixedReset;
    }
 
    @Override
    public void setFixedReset(final boolean fixedReset) {
        if (this.fixedReset == fixedReset) {
            return;
        }
 
        this.fixedReset = fixedReset;
        setModified();
    }
 
    @Override
    public int getDarkness() {
        return darkness;
    }
 
    @Override
    public void setDarkness(final int darkness) {
        if (this.darkness == darkness) {
            return;
        }
 
        this.darkness = darkness;
        setModified();
    }
 
    @Override
    public int getTilePaths() {
        return tilePaths.length;
    }
 
    @NotNull
    @Override
    public String getTilePath(@NotNull final Direction direction) {
        return tilePaths[direction.ordinal()];
    }
 
    @Override
    public void setTilePath(@NotNull final Direction direction, @NotNull final String tilePath) {
        if (tilePaths[direction.ordinal()].equals(tilePath)) {
            return;
        }
 
        tilePaths[direction.ordinal()] = tilePath;
        setModified();
    }
 
    @NotNull
    @Override
    public String calculateTilePath(@NotNull final Direction direction, @Nullable final MapFile mapFile) {
        if (mapFile == null) {
            return "";
        }
 
        final MapPath mapPath = mapFile.getMapPath().getRelativeMapPathFrom(mapFile.getMapPath());
        final Matcher m = MAP_FILE_NAME_PATTERN.matcher(mapPath.toString());
        if (!m.matches()) {
            return "";
        }
 
        final int x = Integer.parseInt(m.group(2));
        final int y = Integer.parseInt(m.group(3));
        final int z = m.group(4) == null ? 0 : Integer.parseInt(m.group(4));
 
        final StringBuilder sb = new StringBuilder(m.group(1));
        sb.append(String.format("_%d_%d", x + direction.getDx(), y + direction.getDy()));
        if (z + direction.getDz() != 0) {
            sb.append(String.format("_%d", z + direction.getDz()));
        }
        return sb.toString();
    }
 
    @Override
    public void calculateTilePaths(@Nullable final MapFile mapFile, @NotNull final File mapsDirectory) {
        if (mapFile == null) {
            return;
        }
 
        for (final Direction direction : Direction.values()) {
            if (!tilePaths[direction.ordinal()].isEmpty()) {
                continue;
            }
 
            final String path = calculateTilePath(direction, mapFile);
            if (path.isEmpty()) {
                continue;
            }
 
            final AbsoluteMapPath mapPath = new AbsoluteMapPath(mapFile.getMapPath(), "..");
            final String realPath = mapsDirectory + "/" + mapPath + "/" + path;
            final File file = new File(realPath);
 
            if (file.exists() && file.isFile()) {
                setTilePath(direction, path);
            }
        }
    }
 
    @Override
    public boolean isTilePathAuto(@NotNull final Direction direction, @Nullable final MapFile mapFile) {
        return calculateTilePath(direction, mapFile).equals(getTilePath(direction));
    }
 
    @Override
    public void setState(@NotNull final A mapArchObject) {
        final AbstractMapArchObject<?> abstractMapArchObject = (AbstractMapArchObject<?>) mapArchObject;
        setText(abstractMapArchObject.msgText.toString());
        setMapSize(abstractMapArchObject.mapSize);
        setMapName(abstractMapArchObject.mapName);
        setEnterX(abstractMapArchObject.enterX);
        setEnterY(abstractMapArchObject.enterY);
        setOutdoor(abstractMapArchObject.outdoor);
        setResetTimeout(abstractMapArchObject.resetTimeout);
        setSwapTime(abstractMapArchObject.swapTime);
        setDifficulty(abstractMapArchObject.difficulty);
        setFixedReset(abstractMapArchObject.fixedReset);
        setDarkness(abstractMapArchObject.darkness);
        for (final Direction direction : Direction.values()) {
            setTilePath(direction, abstractMapArchObject.tilePaths[direction.ordinal()]);
        }
    }
 
    @Override
    public boolean equals(@Nullable final Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null || obj.getClass() != getClass()) {
            return false;
        }
        final AbstractMapArchObject<?> mapArchObject = (AbstractMapArchObject<?>) obj;
        return mapArchObject.msgText.toString().equals(msgText.toString()) && mapArchObject.mapSize.equals(mapSize) && mapArchObject.mapName.equals(mapName) && mapArchObject.enterX == enterX && mapArchObject.enterY == enterY && mapArchObject.outdoor == outdoor && mapArchObject.resetTimeout == resetTimeout && mapArchObject.swapTime == swapTime && mapArchObject.difficulty == difficulty && mapArchObject.fixedReset == fixedReset && mapArchObject.darkness == darkness && Arrays.equals(mapArchObject.tilePaths, tilePaths);
    }
 
    @Override
    public int hashCode() {
        return msgText.hashCode() + mapSize.hashCode() + mapName.hashCode() + enterX + enterY + (outdoor ? 2 : 0) + resetTimeout + swapTime + difficulty + (fixedReset ? 1 : 0) + darkness + Arrays.hashCode(tilePaths);
    }
 
    @Override
    public void addMapArchObjectListener(@NotNull final MapArchObjectListener listener) {
        listenerList.add(listener);
    }
 
    @Override
    public void removeMapArchObjectListener(@NotNull final MapArchObjectListener listener) {
        listenerList.remove(listener);
    }
 
    protected void setModified() {
        attributeHasChanged = true;
    }
 
    @Override
    public void beginTransaction() {
        if (transactionDepth == 0) {
            attributeHasChanged = false;
            transactionThread = Thread.currentThread();
        } else {
            // == is okay for threads.
            //noinspection ObjectEquality
            if (transactionThread != Thread.currentThread()) {
                throw new IllegalStateException("A transaction must only be used by one thread.");
            }
        }
        transactionDepth++;
    }
 
    @Override
    public void endTransaction() {
        endTransaction(false);
    }
 
    @Override
    public void endTransaction(final boolean fireEvent) {
        if (transactionDepth <= 0) {
            throw new IllegalStateException("Tried to end a transaction but no transaction was open.");
        }
        transactionDepth--;
        assert transactionDepth >= 0;
        if (transactionDepth == 0) {
            commitTransaction();
        } else if (fireEvent && transactionDepth > 0) {
            if (attributeHasChanged) {
                fireMetaChangedEvent();
            }
        }
    }
 
    private void commitTransaction() {
        transactionDepth = 0;
        transactionThread = null;
        if (attributeHasChanged) {
            fireMetaChangedEvent();
            attributeHasChanged = false;
        }
    }
 
    private void fireMetaChangedEvent() {
        for (final MapArchObjectListener listener : listenerList) {
            listener.mapMetaChanged();
        }
    }
 
    @Override
    public void addText(@NotNull final String text) {
        if (text.isEmpty()) {
            return;
        }
 
        msgText.append(text);
        setModified();
    }
 
    @Override
    public void setText(final String text) {
        if (msgText.toString().equals(text)) {
            return;
        }
 
        msgText.delete(0, msgText.length());
        msgText.append(text);
        setModified();
    }
 
    @NotNull
    @Override
    public String getText() {
        return msgText.toString();
    }
 
    @Override
    public void updateModifiedAttribute(@NotNull final String userName) {
        final String modifiedAttribute = MODIFIED_ATTRIBUTE + " " + String.format("%tF", System.currentTimeMillis()) + " " + userName;
 
        final Matcher matcher = MODIFIED_ATTRIBUTE_PATTERN.matcher(msgText);
        if (!matcher.find()) {
            // attribute does not exist => add a new one
            msgText.append("\n");
            msgText.append(modifiedAttribute);
            setModified();
        } else if (!matcher.group().equals(modifiedAttribute)) {
            // attribute exists => replace it
            msgText.replace(matcher.start(), matcher.end(), modifiedAttribute);
            setModified();
        }
    }
 
    @Override
    public boolean isPointValid(@Nullable final Point pos) {
        return pos != null && pos.x >= 0 && pos.y >= 0 && pos.x < mapSize.getWidth() && pos.y < mapSize.getHeight();
    }
 
}