AbstractMapManager.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.mapmanager;
 
import java.io.File;
import java.io.IOException;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.face.FaceObjectProviders;
import net.sf.gridarta.model.face.FaceObjectProvidersListener;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.io.MapReader;
import net.sf.gridarta.model.io.MapReaderFactory;
import net.sf.gridarta.model.io.PathManager;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapcontrol.MapControl;
import net.sf.gridarta.model.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.settings.ProjectSettings;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class AbstractMapManager<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements MapManager<G, A, R> {
 
    private static final int DELETED_OBJECTS_TO_REPORT = 10;
 
    @NotNull
    private FileControl<G, A, R> fileControl;
 
    @NotNull
    private final ProjectSettings projectSettings;
 
    @NotNull
    private final MapReaderFactory<G, A> mapReaderFactory;
 
    @NotNull
    private final PathManager pathManager;
 
    private final List<MapControl<G, A, R>> mapControls = new CopyOnWriteArrayList<>();
 
    private final Collection<MapManagerListener<G, A, R>> listenerList = new CopyOnWriteArrayList<>();
 
    @Nullable
    private MapControl<G, A, R> currentMapControl;
 
    protected AbstractMapManager(@NotNull final MapReaderFactory<G, A> mapReaderFactory, @NotNull final ProjectSettings projectSettings, @NotNull final FaceObjectProviders faceObjectProviders, @NotNull final PathManager pathManager) {
        this.projectSettings = projectSettings;
        this.mapReaderFactory = mapReaderFactory;
        this.pathManager = pathManager;
 
        final FaceObjectProvidersListener faceObjectProvidersListener = new FaceObjectProvidersListener() {
 
            @Override
            public void facesReloaded() {
                for (final MapControl<G, A, R> mapControl : mapControls) {
                    mapControl.getMapModel().facesReloaded();
                }
            }
 
        };
        faceObjectProviders.addFaceObjectProvidersListener(faceObjectProvidersListener);
    }
 
    @Deprecated
    public void setFileControl(@NotNull final FileControl<G, A, R> fileControl) {
        this.fileControl = fileControl;
    }
 
    @NotNull
    @Override
    public MapControl<G, A, R> newMap(@Nullable final List<G> objects, @NotNull final A mapArchObject, @Nullable final MapFile mapFile, final boolean interactive) {
        final MapControl<G, A, R> mapControl = createMapControl(objects, mapArchObject, mapFile);
        mapControls.add(mapControl);
        for (final MapManagerListener<G, A, R> listener : listenerList) {
            listener.mapCreated(mapControl, interactive);
        }
        if (interactive) {
            setCurrentMap(mapControl);
        }
        return mapControl;
    }
 
    @NotNull
    protected abstract MapControl<G, A, R> createMapControl(@Nullable List<G> objects, @NotNull A mapArchObject, @Nullable MapFile mapFile);
 
    @Nullable
    @Override
    public MapControl<G, A, R> getOpenMap() {
        if (currentMapControl != null) {
            return currentMapControl;
        }
 
        return mapControls.isEmpty() ? null : mapControls.get(mapControls.size() - 1);
    }
 
    @Override
    public void closeMap(@NotNull final MapControl<G, A, R> mapControl) {
        for (final MapManagerListener<G, A, R> listener : listenerList) {
            listener.mapClosing(mapControl);
        }
        assert mapControl.getUseCounter() <= 0;
        mapControls.remove(mapControl);
        if (currentMapControl == mapControl) {
            setCurrentMap(mapControls.isEmpty() ? null : mapControls.get(0));
        }
        for (final MapManagerListener<G, A, R> listener : listenerList) {
            listener.mapClosed(mapControl);
        }
        mapControl.getMapModel().mapClosed();
    }
 
    @NotNull
    @Override
    public MapControl<G, A, R> openMapFile(@NotNull final MapFile mapFile, final boolean interactive) throws IOException {
        // First look whether the file isn't already open.
        // If so, return the previously loaded map.
        for (final MapControl<G, A, R> mapControl : mapControls) {
            final MapFile tmpMapFile = mapControl.getMapModel().getMapFile();
            if (tmpMapFile != null && tmpMapFile.equals(mapFile)) {
                mapControl.acquire();
                return mapControl;
            }
        }
 
        final MapReader<G, A> decoder = decodeMapFile(mapFile.getFile(), interactive);
        return newMap(decoder.getGameObjects(), decoder.getMapArchObject(), mapFile, interactive);
    }
 
    @NotNull
    @Override
    public MapControl<G, A, R> openMapFile(@NotNull final File file, final boolean interactive) throws IOException {
        return openMapFile(pathManager.getMapFile(file), interactive);
    }
 
    @NotNull
    private MapReader<G, A> decodeMapFile(@NotNull final File file, final boolean interactive) throws IOException {
        final MapReader<G, A> decoder;
        //noinspection ErrorNotRethrown
        try {
            decoder = mapReaderFactory.newMapReader(file);
        } catch (final OutOfMemoryError ex) {
            throw new IOException("out of memory", ex);
        }
 
        int outOfMapBoundsDeleted = 0;
        final StringBuilder outOfMapBoundsObjects = new StringBuilder();
        final int mapWidth = decoder.getMapArchObject().getMapSize().getWidth();
        final int mapHeight = decoder.getMapArchObject().getMapSize().getHeight();
        final Iterator<G> it = decoder.getGameObjects().iterator();
        while (it.hasNext()) {
            final GameObject<G, A, R> gameObject = it.next();
            if (!gameObject.isInContainer()) {
                final int minX = gameObject.getHead().getMapX() + gameObject.getMinX();
                final int minY = gameObject.getHead().getMapY() + gameObject.getMinY();
                final int maxX = gameObject.getHead().getMapX() + gameObject.getMaxX();
                final int maxY = gameObject.getHead().getMapY() + gameObject.getMaxY();
                if (minX < 0 || minY < 0 || maxX >= mapWidth || maxY >= mapHeight) {
                    it.remove();
                    if (gameObject.isHead()) {
                        outOfMapBoundsDeleted++;
                        if (outOfMapBoundsDeleted <= DELETED_OBJECTS_TO_REPORT) {
                            outOfMapBoundsObjects.append('\n');
                            outOfMapBoundsObjects.append(gameObject.getBestName());
                            outOfMapBoundsObjects.append(" at ");
                            outOfMapBoundsObjects.append(minX).append('/').append(minY);
                            if (minX != maxX || minY != maxY) {
                                outOfMapBoundsObjects.append("..");
                                outOfMapBoundsObjects.append(maxX).append('/').append(maxY);
                            }
                        } else if (outOfMapBoundsDeleted == DELETED_OBJECTS_TO_REPORT + 1) {
                            outOfMapBoundsObjects.append("\n...");
                        }
                    }
                }
            }
        }
        if (interactive && outOfMapBoundsDeleted > 0) {
            fileControl.reportOutOfMapBoundsDeleted(file, outOfMapBoundsDeleted, outOfMapBoundsObjects);
        }
 
        return decoder;
    }
 
    @Override
    public void setCurrentMap(@Nullable final MapControl<G, A, R> mapControl) {
        if (currentMapControl == mapControl) {
            return;
        }
 
        currentMapControl = mapControl;
 
        for (final MapManagerListener<G, A, R> listener : listenerList) {
            listener.currentMapChanged(currentMapControl);
        }
    }
 
    @NotNull
    @Override
    public List<MapControl<G, A, R>> getOpenedMaps() {
        return Collections.unmodifiableList(mapControls);
    }
 
    @Nullable
    @Override
    public MapControl<G, A, R> getCurrentMap() {
        return currentMapControl;
    }
 
    @Override
    public void addMapManagerListener(@NotNull final MapManagerListener<G, A, R> listener) {
        listenerList.add(listener);
    }
 
    @Override
    public void removeMapManagerListener(@NotNull final MapManagerListener<G, A, R> listener) {
        listenerList.remove(listener);
    }
 
    @Override
    public void revert(@NotNull final MapControl<G, A, R> mapControl) throws IOException {
        final MapFile mapFile = mapControl.getMapModel().getMapFile();
        if (mapFile == null) {
            return;
        }
 
        final MapReader<G, A> decoder = decodeMapFile(mapFile.getFile(), false);
        final MapModel<G, A, R> mapModel = mapControl.getMapModel();
        final A mapArchObject = mapModel.getMapArchObject();
        mapModel.beginTransaction("revert");
        try {
            mapArchObject.setMapSize(decoder.getMapArchObject().getMapSize());
            mapArchObject.beginTransaction();
            try {
                mapArchObject.setState(decoder.getMapArchObject());
            } finally {
                mapArchObject.endTransaction();
            }
            mapModel.clearMap();
            mapModel.addObjectListToMap(decoder.getGameObjects());
        } finally {
            mapModel.endTransaction();
        }
        mapModel.resetModified();
    }
 
    @Override
    public File getLocalMapDir() {
        final MapControl<G, A, R> mapControl = currentMapControl;
        if (mapControl == null) {
            return projectSettings.getMapsDirectory();
        }
 
        final MapFile mapFile = mapControl.getMapModel().getMapFile();
        if (mapFile == null) {
            return projectSettings.getMapsDirectory();
        }
 
        return mapFile.getFile().getParentFile();
    }
 
    @Override
    public void release(@NotNull final MapControl<G, A, R> mapControl) {
        mapControl.release();
        if (mapControl.getUseCounter() <= 0) {
            closeMap(mapControl);
        }
    }
 
}