AttachTiledMaps.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.actions;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.regex.Matcher;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.direction.Direction;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapcontrol.MapControl;
import net.sf.gridarta.model.mapmanager.MapManager;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapPathUtils;
import net.sf.gridarta.model.mapmodel.UnsavedMapException;
import net.sf.gridarta.model.tiles.MapLink;
import net.sf.gridarta.model.tiles.TileLink;
import net.sf.gridarta.utils.Size2D;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class AttachTiledMaps<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> {

    @NotNull
    private final MapManager<G, A, R> mapManager;

    @NotNull
    private final TileLink[] tileLinks;

    public AttachTiledMaps(@NotNull final MapManager<G, A, R> mapManager, @NotNull final TileLink[] tileLinks) {
        this.mapManager = mapManager;
        this.tileLinks = tileLinks.clone();
    }

    public void attachTiledMaps(@NotNull final MapModel<G, A, R> mapModel, @NotNull final String[] tilePaths, @NotNull final File mapsDirectory, final boolean performAction) throws CannotLoadMapFileException, CannotSaveMapFileException, MapSizeMismatchException, UnsavedMapException {
        if (mapModel.getMapFile() == null) {
            throw new UnsavedMapException(); // cannot update unsaved map
        }

        if (performAction) {
            final List<MapControl<G, A, R>> mapControls = new ArrayList<>(tilePaths.length);
            try {
                // first action: we go around all links and try to load the maps
                loadAdjacentMaps(mapModel, mapControls, tilePaths);

                // We have loaded all direct linked maps around our map.
                // now, lets check free spaces.
                fillAdjacentMaps(mapControls);

                validateMapSizes(mapModel, mapControls);

                // finally... set the links!
                updateTilePaths(mapModel, mapControls, tilePaths, mapsDirectory);

                // all done! now we write all back
                saveAdjacentMaps(mapControls);
            } finally {
                for (final MapControl<G, A, R> mapControl : mapControls) {
                    if (mapControl != null) {
                        mapManager.release(mapControl);
                    }
                }
            }
        }
    }

    private void loadAdjacentMaps(@NotNull final MapModel<G, A, R> mapModel, @NotNull final Collection<MapControl<G, A, R>> mapControls, @NotNull final String[] tilePaths) throws CannotLoadMapFileException {
        for (@Nullable final String tilePath : tilePaths) {
            @Nullable final MapControl<G, A, R> mapControl;
            if (tilePath != null && !tilePath.isEmpty()) {
                try {
                    mapControl = loadMapControl(mapModel, tilePath);
                } catch (final IOException ex) {
                    throw new CannotLoadMapFileException(tilePath, ex);
                }
            } else {
                mapControl = null;
            }
            mapControls.add(mapControl);
        }
    }

    private void saveAdjacentMaps(@NotNull final Iterable<MapControl<G, A, R>> mapControls) throws CannotSaveMapFileException {
        for (final MapControl<G, A, R> mapControl : mapControls) {
            if (mapControl != null) {
                try {
                    if (mapControl.getMapModel().isModified()) {
                        mapControl.save();
                    }
                } catch (final IOException e) {
                    final MapFile mapFile = mapControl.getMapModel().getMapFile();
                    assert mapFile != null;
                    throw new CannotSaveMapFileException(mapFile.getFile(), e);
                }
            }
        }
    }

    private void fillAdjacentMaps(@NotNull final List<MapControl<G, A, R>> mapControls) throws CannotLoadMapFileException {
        boolean repeatFlag = true;
        while (repeatFlag) {
            repeatFlag = false;
            for (int i = 0; i < mapControls.size(); i++) {
                final MapControl<G, A, R> mapControl = mapControls.get(i);
                if (mapControl != null) {
                    final TileLink tileLink = tileLinks[i];
                    final MapLink[] mapLinks = tileLink.getMapLinks();
                    for (final MapLink mapLink : mapLinks) {
                        final Direction direction = mapLink.getMapDirection();
                        if (mapControls.get(direction.ordinal()) == null) {
                            final String tilePath = mapControl.getMapModel().getMapArchObject().getTilePath(mapLink.getLinkDirection());
                            if (!tilePath.isEmpty()) {
                                try {
                                    mapControls.set(direction.ordinal(), loadMapControl(mapControl.getMapModel(), tilePath));
                                    repeatFlag = true;
                                } catch (final IOException ex) {
                                    throw new CannotLoadMapFileException(tilePath, ex);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    private void validateMapSizes(@NotNull final MapModel<G, A, R> mapModel, @NotNull final Iterable<MapControl<G, A, R>> mapControls) throws MapSizeMismatchException {
        final Size2D mapSize = mapModel.getMapArchObject().getMapSize();
        for (final MapControl<G, A, R> mapControl : mapControls) {
            if (mapControl != null) {
                final MapModel<G, A, R> tmpMapModel = mapControl.getMapModel();
                final MapArchObject<A> otherMap = tmpMapModel.getMapArchObject();
                final Size2D otherMapSize = otherMap.getMapSize();
                if (!mapSize.equals(otherMapSize)) {
                    throw new MapSizeMismatchException(tmpMapModel.getMapFile().getFile(), mapSize, otherMapSize);
                }
                for (int ii = 0; ii < 2; ii++) {
                    // TODO: check links
                }
            }
        }
    }

    private void updateTilePaths(@NotNull final MapModel<G, A, R> mapModel, @NotNull final List<MapControl<G, A, R>> mapControls, @NotNull final String[] tilePaths, @NotNull final File mapsDirectory) throws CannotSaveMapFileException {
        for (int i = 0; i < tilePaths.length; i++) {
            final MapControl<G, A, R> mapControl = mapControls.get(i);
            if (mapControl != null) {
                // generate a valid path relative to both map positions
                final String canonicalMapPath2 = mapControl.getMapModel().getMapFile().getFile().getPath();
                final String canonicalMapPath1 = mapModel.getMapFile().getFile().getPath();
                final String link1 = getTilePath(canonicalMapPath1, canonicalMapPath2, mapsDirectory);
                // set the link of our source map to the map around
                tilePaths[i] = link1;
                // generate again a valid path relative to both map positions
                final String link2 = getTilePath(canonicalMapPath2, canonicalMapPath1, mapsDirectory);
                final MapModel<G, A, R> mapModel2 = mapControl.getMapModel();
                mapModel2.beginTransaction("Attach maps");
                try {
                    final MapArchObject<A> mapArchObject2 = mapModel2.getMapArchObject();
                    mapArchObject2.beginTransaction();
                    try {
                        mapArchObject2.setTilePath(tileLinks[i].getRevLink(), link2 == null ? "" : link2);
                    } finally {
                        mapArchObject2.endTransaction();
                    }
                } finally {
                    mapModel2.endTransaction();
                }
            }
        }
    }

    @Nullable
    private MapControl<G, A, R> loadMapControl(@NotNull final MapModel<G, A, R> mapModel, @NotNull final String path) throws IOException {
        final MapFile mapFile = mapModel.getMapFile();
        if (mapFile == null) {
            // unsaved map: should not happen => ignore
            return null;
        }
        return mapManager.openMapFile(new MapFile(mapFile, MapPathUtils.newMapPath(path)), false);
    }

    @Nullable
    private static String getTilePath(@NotNull final String base, @NotNull final String link, @NotNull final File mapsDirectory) throws CannotSaveMapFileException {
        final int pos = getLastSlashIndex(base);
        final int pos2 = getLastSlashIndex(link);
        final CharSequence mapDirectory;
        try {
            mapDirectory = mapsDirectory.getCanonicalPath();
        } catch (final IOException e) {
            throw new CannotSaveMapFileException(mapsDirectory, e);
        }
        final String first = base.substring(mapDirectory.length(), pos).trim();
        final String second = link.substring(mapDirectory.length(), pos2).trim();

        final String sep = Matcher.quoteReplacement(File.separator);

        /* our map is in root - second is higher or same map */
        if (first.isEmpty()) {
            return link.substring(mapDirectory.length()).trim().replaceAll(sep, "/");
        }
        // same folder... we return the name without '/'
        if (first.compareTo(second) == 0) {
            return link.substring(pos2 + 1).trim().replaceAll(sep, "/");
        }
        // second is sub-folder of first
        if (second.startsWith(first)) {
            return link.substring(pos + 1).trim().replaceAll(sep, "/");
        }
        // in any other case we return a absolute path
        return link.substring(mapDirectory.length()).trim().replaceAll(sep, "/");
    }

    private static int getLastSlashIndex(@NotNull final String base) {
        final int slashIndex1 = base.lastIndexOf('/');
        final int separatorIndex1 = base.lastIndexOf(File.separator);
        int pos = slashIndex1;
        if (separatorIndex1 > slashIndex1) {
            pos = separatorIndex1;
        }
        return pos;
    }

}