MapLocation.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.maplocation;

import java.awt.Point;
import java.util.regex.Pattern;
import net.sf.gridarta.model.baseobject.Attributes;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.mapmodel.AbsoluteMapPath;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapPath;
import net.sf.gridarta.model.mapmodel.MapPathUtils;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.utils.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class MapLocation implements Comparable<MapLocation> {

    @NotNull
    private static final Pattern PATTERN_END_OF_LINE = Pattern.compile("[\r\n]+");

    @NotNull
    private final MapPath mapPath;

    @NotNull
    private final Point mapCoordinate;

    private MapLocation(@NotNull final MapPath mapPath, final int mapXCoordinate, final int mapYCoordinate) {
        this.mapPath = mapPath;
        mapCoordinate = new Point(mapXCoordinate, mapYCoordinate);
    }

    public MapLocation(@NotNull final BaseObject<?, ?, ?, ?> gameObject, final boolean allowRandomMapParameters) throws NoExitPathException {
        this(getMapPath(gameObject, allowRandomMapParameters), getMapX(gameObject), getMapY(gameObject));
    }

    @NotNull
    public static MapLocation newAbsoluteMapLocation(@NotNull final GameObject<?, ?, ?> gameObject, final boolean allowRandomMapParameters) throws NoExitPathException {
        final MapPath mapPath = getMapPath(gameObject, allowRandomMapParameters);
        final AbsoluteMapPath baseMapPath;
        final MapSquare<?, ?, ?> mapSquare = gameObject.getMapSquare();
        if (mapSquare == null) {
            baseMapPath = new AbsoluteMapPath();
        } else {
            final MapModel<?, ?, ?> mapModel = mapSquare.getMapModel();
            final MapFile mapFile = mapModel.getMapFile();
            if (mapFile == null) {
                baseMapPath = new AbsoluteMapPath();
            } else {
                baseMapPath = mapFile.getMapPath();
            }
        }
        final AbsoluteMapPath canonicalMapPath = MapPathUtils.append(baseMapPath, mapPath);
        final int mapX = getMapX(gameObject);
        final int mapY = getMapY(gameObject);
        return new MapLocation(canonicalMapPath, mapX, mapY);
    }

    @NotNull
    public MapPath getMapPath() {
        return mapPath;
    }

    @NotNull
    public Point getMapCoordinate() {
        return new Point(mapCoordinate);
    }

    @Override
    public boolean equals(@Nullable final Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj == null || obj.getClass() != getClass()) {
            return false;
        }
        final MapLocation mapLocation = (MapLocation) obj;
        return mapLocation.mapPath.equals(mapPath) && mapLocation.mapCoordinate.equals(mapCoordinate);
    }

    @Override
    public int hashCode() {
        return mapPath.hashCode() ^ mapCoordinate.hashCode();
    }

    private static int getMapY(@NotNull final Attributes gameObject) {
        return gameObject.getAttributeInt(BaseObject.SP);
    }

    private static int getMapX(@NotNull final Attributes gameObject) {
        return gameObject.getAttributeInt(BaseObject.HP);
    }

    @NotNull
    public static MapPath getMapPath(@NotNull final BaseObject<?, ?, ?, ?> gameObject, final boolean allowRandomMapParameters) throws NoExitPathException {
        String path = gameObject.getAttributeString(BaseObject.SLAYING);
        if (path.isEmpty()) {
            throw new NoExitPathException(gameObject);
        }

        if (allowRandomMapParameters && (path.equals("/!") || path.startsWith("/random/"))) {
            // destination is a random map; extract the final non-random map
            path = getRandomMapParameter(gameObject, "final_map");
            if (path == null) {
                throw new NoExitPathException(gameObject);
            }
        }

        return MapPathUtils.newMapPath(path);
    }

    @Nullable
    private static String getRandomMapParameter(@NotNull final BaseObject<?, ?, ?, ?> gameObject, @NotNull final String parameterName) {
        final String msg = gameObject.getMsgText();
        if (msg == null) {
            return null;
        }

        final String[] lines = PATTERN_END_OF_LINE.split(msg);
        for (final String line : lines) {
            final String[] tmp = StringUtils.PATTERN_SPACES.split(line, 2);
            if (tmp.length == 2 && tmp[0].equals(parameterName)) {
                return tmp[1];
            }
        }

        return null;
    }

    @NotNull
    @Override
    public String toString() {
        return mapCoordinate.x + "/" + mapCoordinate.y + "@" + mapPath;
    }

    @Override
    @SuppressWarnings("CompareToUsesNonFinalVariable")
    public int compareTo(@NotNull final MapLocation o) {
        final int cmp = mapPath.toString().compareTo(o.mapPath.toString());
        if (cmp != 0) {
            return cmp;
        }
        if (mapCoordinate.x < o.mapCoordinate.x) {
            return -1;
        }
        if (mapCoordinate.x > o.mapCoordinate.x) {
            return -1;
        }
        if (mapCoordinate.y < o.mapCoordinate.y) {
            return -1;
        }
        if (mapCoordinate.y > o.mapCoordinate.y) {
            return -1;
        }
        return 0;
    }

}