DefaultMapModel.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.mapmodel;
 
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.CopyOnWriteArrayList;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.archetypechooser.ArchetypeChooserModel;
import net.sf.gridarta.model.autojoin.AutojoinList;
import net.sf.gridarta.model.autojoin.AutojoinLists;
import net.sf.gridarta.model.autojoin.InsertionResult;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.baseobject.GameObjectContainer;
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.model.maparchobject.MapArchObjectListener;
import net.sf.gridarta.model.match.GameObjectMatchers;
import net.sf.gridarta.model.match.NamedGameObjectMatcher;
import net.sf.gridarta.model.validation.DefaultErrorCollector;
import net.sf.gridarta.model.validation.ErrorCollector;
import net.sf.gridarta.utils.Size2D;
import org.apache.log4j.Category;
import org.apache.log4j.Logger;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class DefaultMapModel<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> implements MapModel<G, A, R> {
 
    private static final long serialVersionUID = 1L;
 
    private static final Category LOG = Logger.getLogger(DefaultMapModel.class);
 
    private final transient Object syncLock = new Object();
 
    @NotNull
    private final A mapArchObject;
 
    @NotNull
    private final AutojoinLists<G, A, R> autojoinLists;
 
    @NotNull
    private final ArchetypeChooserModel<G, A, R> archetypeChooserModel;
 
    @NotNull
    private final MapSquareGrid<G, A, R> mapGrid;
 
    @NotNull
    private final List<MapModelListener<G, A, R>> mapModelListeners = new CopyOnWriteArrayList<>();
 
    @NotNull
    private final Collection<MapTransactionListener<G, A, R>> mapTransactionListeners = new CopyOnWriteArrayList<>();
 
    private int transactionDepth;
 
    @Nullable
    private transient Thread transactionThread;
 
    @NotNull
    private final Set<MapSquare<G, A, R>> changedSquares = new HashSet<>();
 
    @NotNull
    private final SavedSquares<G, A, R> savedSquares;
 
    @NotNull
    private final Set<G> changedGameObjects = new HashSet<>();
 
    @NotNull
    private final Set<G> transientChangedGameObjects = new HashSet<>();
 
    @NotNull
    private ErrorCollector<G, A, R> errors = new DefaultErrorCollector<>();
 
    private int activeEditType;
 
    @NotNull
    private final GameObjectFactory<G, A, R> gameObjectFactory;
 
    @NotNull
    private final GameObjectMatchers gameObjectMatchers;
 
    @NotNull
    private final InsertionMode topmostInsertionMode;
 
    @Nullable
    private MapFile mapFile;
 
    private boolean modified;
 
    @NotNull
    private final LightMapModelTracker<G, A, R> lightMapModelTracker = new LightMapModelTracker<>(this);
 
    @NotNull
    private final transient MapArchObjectListener mapArchObjectListener = new MapArchObjectListener() {
 
        @Override
        public void mapMetaChanged() {
            setModified();
        }
 
        @Override
        public void mapSizeChanged(@NotNull final Size2D mapSize) {
            resizeMapInt(mapSize);
        }
 
    };
 
    public DefaultMapModel(@NotNull final AutojoinLists<G, A, R> autojoinLists, @NotNull final A mapArchObject, @NotNull final ArchetypeChooserModel<G, A, R> archetypeChooserModel, @NotNull final GameObjectFactory<G, A, R> gameObjectFactory, @NotNull final GameObjectMatchers gameObjectMatchers, @NotNull final InsertionMode topmostInsertionMode) {
        this.mapArchObject = mapArchObject;
        this.autojoinLists = autojoinLists;
        this.archetypeChooserModel = archetypeChooserModel;
        this.gameObjectFactory = gameObjectFactory;
        this.gameObjectMatchers = gameObjectMatchers;
        this.topmostInsertionMode = topmostInsertionMode;
        savedSquares = new SavedSquares<>(gameObjectFactory, gameObjectMatchers);
        mapArchObject.addMapArchObjectListener(mapArchObjectListener);
        mapGrid = new MapSquareGrid<>(this, mapArchObject.getMapSize());
        modified = false;
    }
 
    @Override
    public void mapClosed() {
        mapArchObject.removeMapArchObjectListener(mapArchObjectListener);
    }
 
    @NotNull
    @Override
    public A getMapArchObject() {
        return mapArchObject;
    }
 
    @Override
    public Iterator<MapSquare<G, A, R>> iterator() {
        return new MapSquareIterator<>(this, null, 1, false);
    }
 
    @NotNull
    @Override
    public MapSquare<G, A, R> getMapSquare(@NotNull final Point pos) {
        return mapGrid.getMapSquare(pos.x, pos.y);
    }
 
    @Override
    public void addObjectListToMap(@NotNull final Iterable<G> objects) {
        for (final G gameObject : objects) {
            if (!gameObject.isInContainer()) { // only map arches....
                addGameObjectToMap(gameObject, new Point(gameObject.getMapX(), gameObject.getMapY()), topmostInsertionMode);
            }
        }
    }
 
    @Override
    public void clearMap() {
        mapGrid.clearMap();
    }
 
    @Override
    public boolean isEmpty() {
        return mapGrid.isEmpty();
    }
 
    private void resizeMapInt(@NotNull final Size2D newSize) {
        final Size2D mapSize = mapGrid.getMapSize();
        if (newSize.equals(mapSize)) {
            return;
        }
 
        // no other thread may access this map model while resizing
        synchronized (syncLock) {
            lightMapModelTracker.mapSizeChanging(newSize, mapSize);
 
            // first delete all arches in the area that will get cut off
            // (this is especially important to remove all multi-part objects
            // reaching into that area)
            final Collection<GameObject<G, A, R>> objectsToDelete = new HashSet<>();
            if (mapSize.getWidth() > newSize.getWidth()) {
                // clear out the right stripe (as far as being cut off)
                mapGrid.collectHeads(newSize.getWidth(), 0, mapSize.getWidth(), mapSize.getHeight(), objectsToDelete);
            }
 
            if (mapSize.getHeight() > newSize.getHeight()) {
                // clear out the bottom stripe (as far as being cut off)
                mapGrid.collectHeads(0, newSize.getHeight(), Math.min(mapSize.getWidth(), newSize.getWidth()), mapSize.getHeight(), objectsToDelete);
            }
 
            for (final GameObject<G, A, R> node : objectsToDelete) {
                node.remove();
            }
 
            mapGrid.resize(newSize);
            discardInvalidMapSquares(changedSquares, newSize);
            discardInvalidGameObjects(changedGameObjects, newSize);
            discardInvalidGameObjects(transientChangedGameObjects, newSize);
 
            fireMapSizeChanged(newSize);
        }
    }
 
    private void discardInvalidMapSquares(@NotNull final Iterable<MapSquare<G, A, R>> mapSquares, @NotNull final Size2D mapSize) {
        final Iterator<MapSquare<G, A, R>> it = mapSquares.iterator();
        while (it.hasNext()) {
            final MapSquare<G, A, R> mapSquare = it.next();
            if (mapSquare.getMapX() >= mapSize.getWidth() || mapSquare.getMapY() >= mapSize.getHeight()) {
                it.remove();
            }
        }
    }
 
    private void discardInvalidGameObjects(@NotNull final Iterable<G> gameObjects, @NotNull final Size2D mapSize) {
        final Iterator<G> it2 = gameObjects.iterator();
        while (it2.hasNext()) {
            final GameObject<G, A, R> gameObject = it2.next();
            final G topGameObject = gameObject.getTopContainer();
            if (topGameObject.getContainer() == null || topGameObject.getMapX() >= mapSize.getWidth() || topGameObject.getMapY() >= mapSize.getHeight()) {
                it2.remove();
            }
        }
    }
 
    @Override
    public void addMapModelListener(@NotNull final MapModelListener<G, A, R> listener) {
        mapModelListeners.add(listener);
    }
 
    @Override
    public void prependMapModelListener(@NotNull final MapModelListener<G, A, R> listener) {
        mapModelListeners.add(0, listener);
    }
 
    @Override
    public void removeMapModelListener(@NotNull final MapModelListener<G, A, R> listener) {
        mapModelListeners.remove(listener);
    }
 
    @Override
    public void addMapTransactionListener(@NotNull final MapTransactionListener<G, A, R> listener) {
        mapTransactionListeners.add(listener);
    }
 
    @Override
    public void removeMapTransactionListener(@NotNull final MapTransactionListener<G, A, R> listener) {
        mapTransactionListeners.remove(listener);
    }
 
    @Override
    public void beginSquareChange(@NotNull final MapSquare<G, A, R> mapSquare) {
        if (transactionDepth == 0) {
            LOG.error("beginSquareChange: square (" + mapSquare + ") is about to change outside a transaction");
            return;
        }
 
        savedSquares.recordMapSquare(mapSquare);
    }
 
    @Override
    public void endSquareChange(@NotNull final MapSquare<G, A, R> mapSquare) {
        if (transactionDepth == 0) {
            LOG.error("endSquareChange: square (" + mapSquare + ") was changed outside a transaction");
            final Set<MapSquare<G, A, R>> mapSquares = new HashSet<>(1);
            mapSquares.add(mapSquare);
            lightMapModelTracker.mapSquaresChanged(Collections.unmodifiableCollection(mapSquares));
            fireMapSquaresChangedEvent(mapSquares);
        } else {
            synchronized (changedSquares) {
                changedSquares.add(mapSquare);
            }
        }
    }
 
    @Override
    public void beginGameObjectChange(@NotNull final G gameObject) {
        final MapSquare<G, A, R> mapSquare = gameObject.getMapSquare();
        if (transactionDepth == 0) {
            LOG.error("beginGameObjectChange: game object (" + gameObject.getBestName() + "@" + mapSquare + ") is about to change outside a transaction");
            return;
        }
 
        savedSquares.recordMapSquare(mapSquare);
    }
 
    @Override
    public void endGameObjectChange(@NotNull final G gameObject) {
        if (transactionDepth == 0) {
            LOG.error("endGameObjectChange: game object (" + gameObject.getBestName() + "@" + gameObject.getMapSquare() + ") was changed outside a transaction");
            final Set<G> gameObjects = new HashSet<>(1);
            gameObjects.add(gameObject);
            fireGameObjectsChangedEvent(gameObjects, Collections.emptySet());
        } else {
            synchronized (changedGameObjects) {
                changedGameObjects.add(gameObject);
            }
        }
    }
 
    @Override
    public void transientGameObjectChange(@NotNull final G gameObject) {
        if (transactionDepth == 0) {
            LOG.error("transientGameObjectChange: game object (" + gameObject.getBestName() + "@" + gameObject.getMapSquare() + ") was changed outside a transaction");
            final Set<G> gameObjects = new HashSet<>(1);
            gameObjects.add(gameObject);
            fireGameObjectsChangedEvent(Collections.emptySet(), gameObjects);
        } else {
            synchronized (transientChangedGameObjects) {
                transientChangedGameObjects.add(gameObject);
            }
        }
    }
 
    @Override
    public void beginTransaction(@NotNull final String name) {
        if (transactionDepth == 0) {
            firePreBeginTransaction();
            transactionThread = Thread.currentThread();
            transactionDepth++;
            fireBeginTransaction(name);
        } else {
            // == is okay for threads.
            //noinspection ObjectEquality
            if (transactionThread != Thread.currentThread()) {
                throw new IllegalStateException("A transaction must only be used by one thread. " + transactionThread + " " + Thread.currentThread());
            }
            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 == 1) {
            fireEvents();
        }
    }
 
    private void fireEvents() {
        // Call lightMapModelTracker first as it might change more game objects
        transactionDepth++; // temporarily increase transaction depth because updating light information causes changes
        try {
            // Create copy to avoid ConcurrentModificationExceptions due to newly changed squares
            final Collection<MapSquare<G, A, R>> mapSquares = new HashSet<>(changedSquares);
            for (final G gameObject : changedGameObjects) {
                final MapSquare<G, A, R> mapSquare = gameObject.getMapSquareOptional();
                if (mapSquare != null) {
                    mapSquares.add(mapSquare);
                }
            }
            lightMapModelTracker.mapSquaresChanged(mapSquares);
        } finally {
            transactionDepth--;
        }
        if (!changedGameObjects.isEmpty() || !transientChangedGameObjects.isEmpty()) {
            transientChangedGameObjects.removeAll(changedGameObjects);
            transactionDepth++; // temporarily increase transaction depth because updating edit types causes transient changes
            try {
                for (final G gameObject : changedGameObjects) {
                    if (gameObject.isHead()) {
                        for (G env = gameObject; env != null; env = env.getContainerGameObject()) {
                            updateEditType(env, activeEditType);
                        }
                    }
                }
            } finally {
                transactionDepth--;
            }
            fireGameObjectsChangedEvent(Collections.unmodifiableSet(changedGameObjects), Collections.unmodifiableSet(transientChangedGameObjects));
            changedGameObjects.clear();
        }
        if (!changedSquares.isEmpty()) {
            fireMapSquaresChangedEvent(Collections.unmodifiableSet(changedSquares));
            changedSquares.clear();
        }
    }
 
    @Override
    public void endAllTransactions() {
        if (transactionDepth > 0) {
            commitTransaction();
        }
    }
 
    private void commitTransaction() {
        transactionDepth = 0;
        transactionThread = null;
        fireEvents();
        fireEndTransaction();
        firePostEndTransaction();
    }
 
    @Override
    public int getTransactionDepth() {
        return transactionDepth;
    }
 
    @Override
    public boolean isAnyTransactionActive() {
        return transactionDepth > 0;
    }
 
    private void fireMapSquaresChangedEvent(final Set<MapSquare<G, A, R>> mapSquares) {
        setModified();
        for (final MapModelListener<G, A, R> listener : mapModelListeners) {
            listener.mapSquaresChanged(mapSquares);
        }
    }
 
    private void fireGameObjectsChangedEvent(@NotNull final Set<G> gameObjects, @NotNull final Set<G> transientGameObjects) {
        if (!gameObjects.isEmpty()) {
            setModified();
        }
        for (final MapModelListener<G, A, R> listener : mapModelListeners) {
            listener.mapObjectsChanged(gameObjects, transientGameObjects);
        }
    }
 
    private void fireMapSizeChanged(@NotNull final Size2D newSize) {
        setModified();
        for (final MapModelListener<G, A, R> listener : mapModelListeners) {
            listener.mapSizeChanged(newSize);
        }
    }
 
    private void firePreBeginTransaction() {
        for (final MapTransactionListener<G, A, R> listener : mapTransactionListeners) {
            listener.preBeginTransaction();
        }
    }
 
    private void fireBeginTransaction(@NotNull final String name) {
        savedSquares.clear();
        for (final MapTransactionListener<G, A, R> listener : mapTransactionListeners) {
            listener.beginTransaction(name);
        }
    }
 
    private void fireEndTransaction() {
        for (final MapTransactionListener<G, A, R> listener : mapTransactionListeners) {
            listener.endTransaction(savedSquares);
        }
        savedSquares.clear();
    }
 
    private void firePostEndTransaction() {
        for (final MapTransactionListener<G, A, R> listener : mapTransactionListeners) {
            listener.postEndTransaction();
        }
    }
 
    private void fireMapFileChanged(@Nullable final MapFile oldMapFile) {
        for (final MapModelListener<G, A, R> listener : mapModelListeners) {
            listener.mapFileChanged(oldMapFile);
        }
    }
 
    private void fireModifiedChanged() {
        for (final MapModelListener<G, A, R> listener : mapModelListeners) {
            listener.modifiedChanged();
        }
    }
 
    @Override
    public void removeGameObject(@NotNull final G gameObject, final boolean join) {
        final MapSquare<?, ?, ?> mapSquare = gameObject.getMapSquare();
        if (gameObject.isInContainer()) {
            gameObject.remove();
        } else {
            gameObject.remove();
 
            if (join) {
                joinDelete(mapSquare.getMapLocation(), gameObject.getArchetype());
            }
        }
    }
 
    @Override
    public boolean isMultiArchFittingToMap(@NotNull final Archetype<G, A, R> archetype, @NotNull final Point pos, final boolean allowDouble) {
        for (Archetype<G, A, R> part = archetype; part != null; part = part.getMultiNext()) {
            final Point point = new Point(part.getMultiX(), part.getMultiY());
            point.translate(pos.x, pos.y);
            // outside map
            if (!mapArchObject.isPointValid(point)) {
                return false;
            }
 
            if (!allowDouble) {
                final String temp = part.getArchetypeName();
                for (final BaseObject<G, A, R, ?> node : mapGrid.getMapSquare(point.x, point.y)) {
                    if (node.getArchetype().getArchetypeName().equals(temp)) {
                        return false;
                    }
                }
            }
        }
 
        return true;
    }
 
    @Override
    public void setErrors(@NotNull final ErrorCollector<G, A, R> errors) {
        this.errors = errors;
        for (final MapModelListener<G, A, R> listener : mapModelListeners) {
            listener.errorsChanged(errors);
        }
    }
 
    @NotNull
    @Override
    public ErrorCollector<G, A, R> getErrors() {
        return errors;
    }
 
    @Nullable
    @Override
    public G insertArchToMap(@NotNull final BaseObject<G, A, R, ?> templateBaseObject, @Nullable final G nextGameObject, @NotNull final Point pos, final boolean join) {
        // map coordinates must be valid
        if (!mapArchObject.isPointValid(pos)) {
            return null;
        }
 
        final G newGameObject;
        final GameObject<G, A, R> nextGameObjectEnv = nextGameObject == null ? null : nextGameObject.getContainerGameObject();
        if (nextGameObject == null || nextGameObjectEnv == null) {
            newGameObject = insertBaseObject(templateBaseObject, pos, true, join, topmostInsertionMode);
            if (newGameObject == null) {
                return null;
            }
 
            int position = 0;
            for (final G gameObject : mapGrid.getMapSquare(pos.x, pos.y).reverse()) {
                // This is okay because nextGameObject is on the desired square.
                //noinspection ObjectEquality
                if (gameObject == nextGameObject) {
                    break;
                }
                position++;
            }
            for (int i = 0; i < position - 1; i++) {
                newGameObject.moveDown();
            }
        } else {
            newGameObject = templateBaseObject.newInstance(gameObjectFactory);
            nextGameObjectEnv.addLast(newGameObject);
            if (templateBaseObject instanceof Archetype) {
                gameObjectFactory.createInventory(newGameObject, templateBaseObject);
            }
        }
 
        return newGameObject;
    }
 
    @Nullable
    @Override
    public G insertBaseObject(@NotNull final BaseObject<G, A, R, ?> baseObject, @NotNull final Point pos, final boolean allowMany, final boolean join, @NotNull final InsertionMode insertionMode) {
        if (!mapArchObject.isPointValid(pos)) {
            return null;
        }
 
        final R realArchetype = baseObject.getArchetype();
        final R effectiveArchetype;
        if (join) {
            final InsertionResult<G, A, R> insertionResult = joinInsert(pos, realArchetype);
            final G gameObject = insertionResult.getGameObject();
            if (gameObject != null) {
                return gameObject;
            }
 
            effectiveArchetype = insertionResult.getArchetype();
            if (effectiveArchetype == null) {
                return null; // only one autojoin type per square allowed
            }
        } else {
            effectiveArchetype = realArchetype;
        }
 
        if (!isMultiArchFittingToMap(effectiveArchetype, pos, allowMany)) {
            return null;
        }
 
        final Integer direction = effectiveArchetype.usesDirection() ? archetypeChooserModel.getDirection() : null;
 
        final List<G> parts = new ArrayList<>();
        for (R archetypePart = effectiveArchetype; archetypePart != null; archetypePart = archetypePart.getMultiNext()) {
            final G part;
            if (archetypePart == effectiveArchetype) {
                part = baseObject.newInstance(gameObjectFactory);
                part.setArchetype(archetypePart);
            } else {
                part = archetypePart.newInstance(gameObjectFactory);
            }
            if (direction != null) {
                part.setAttributeInt(BaseObject.DIRECTION, direction);
            }
            if (!parts.isEmpty()) {
                parts.get(0).addTailPart(part);
            }
            parts.add(part);
        }
 
        for (final G part : parts) {
            final int mapX = pos.x + part.getArchetype().getMultiX();
            final int mapY = pos.y + part.getArchetype().getMultiY();
            insertionMode.insert(part, mapGrid.getMapSquare(mapX, mapY));
        }
 
        final G head = parts.get(0);
        if (baseObject instanceof Archetype) {
            gameObjectFactory.createInventory(head, effectiveArchetype);
        }
 
        return head;
    }
 
    @Override
    public void addGameObjectToMap(@NotNull final G gameObject, @NotNull final Point pos, @NotNull final InsertionMode insertionMode) {
        if (!mapArchObject.isPointValid(pos)) {
            LOG.error("addGameObjectToMap: trying to insert game object out of map bounds at " + pos.x + "/" + pos.y + ", map bounds is " + mapArchObject.getMapSize());
            return;
        }
 
        insertionMode.insert(gameObject, mapGrid.getMapSquare(pos.x, pos.y));
    }
 
    @Override
    public void moveEnv(@NotNull final G gameObject, @NotNull final Point pos, @NotNull final G nextGameObject) {
        if (!nextGameObject.isHead()) {
            throw new IllegalArgumentException("can't move tail part of a multi-part object");
        }
        assert !gameObject.isMulti(); // no tail parts should be present when inside inventory of another game object
        final GameObjectContainer<G, A, R> nextGameObjectContainer;
        if (nextGameObject.isInContainer()) {
            nextGameObjectContainer = nextGameObject.getContainer();
            if (nextGameObjectContainer == null) {
                throw new IllegalArgumentException("can't move into container object");
            }
        } else {
            nextGameObjectContainer = getMapSquare(pos);
        }
        final MapSquare<G, A, R> mapSquare = nextGameObjectContainer.getMapSquare();
        if (mapSquare.getMapModel() != this) {
            throw new IllegalArgumentException("can't move into a game object in another map");
        }
        gameObject.remove();
        nextGameObjectContainer.insertAfter(nextGameObject, gameObject);
 
        // regenerate tail parts when inserted into a map square
        if (!nextGameObject.isInContainer() && gameObject.getArchetype().isMulti()) {
            final Point tmp = new Point();
            for (R archetypeTail = gameObject.getArchetype().getMultiNext(); archetypeTail != null; archetypeTail = archetypeTail.getMultiNext()) {
                final G gameObjectTail = archetypeTail.newInstance(gameObjectFactory);
                gameObject.addTailPart(gameObjectTail);
                tmp.x = pos.x + archetypeTail.getMultiX();
                tmp.y = pos.y + archetypeTail.getMultiY();
                addGameObjectToMap(gameObjectTail, tmp, topmostInsertionMode);
            }
        }
    }
 
    @Override
    public void moveInv(@NotNull final G gameObject, @NotNull final GameObject<G, A, R> prevGameObject) {
        if (!gameObject.isHead() || !prevGameObject.isHead()) {
            throw new IllegalArgumentException("can't move tail part of a multi-part object");
        }
 
        gameObject.remove();
        gameObject.removeTailParts();
        prevGameObject.addFirst(gameObject);
    }
 
    @Override
    public boolean isAreaEmpty(final int left, final int top, final int width, final int height) {
        final Point point = new Point();
        for (int x = left; x < left + width; x++) {
            point.x = x;
            for (int y = top; y < top + height; y++) {
                point.y = y;
                if (!getMapSquare(point).isEmpty()) {
                    return false;
                }
            }
        }
        return true;
    }
 
    @Override
    public void addActiveEditType(final int editType) {
        // calculate only if needed
        if ((activeEditType & editType) != editType) {
            beginTransaction("update edit types");
            try {
                for (final Iterable<G> mapSquare : this) {
                    for (final GameObject<G, A, R> gameObject : mapSquare) {
                        updateEditType(gameObject.getHead(), editType);
                    }
                }
            } finally {
                endTransaction();
            }
            // from now on we have this type, so we don't have to calculate it again
            activeEditType |= editType;
        }
    }
 
    @Override
    public void setMapFile(@Nullable final MapFile mapFile) {
        if (Objects.equals(this.mapFile, mapFile)) {
            return;
        }
 
        final MapFile oldMapFile = this.mapFile;
        this.mapFile = mapFile;
        fireMapFileChanged(oldMapFile);
    }
 
    @Nullable
    @Override
    public MapFile getMapFile() {
        return mapFile;
    }
 
    @NotNull
    @Override
    public MapFile getMapFile(@NotNull final MapPath mapPath) throws SameMapException, UnsavedMapException {
        final MapFile thisMapFile = mapFile;
        if (thisMapFile == null) {
            throw new UnsavedMapException();
        }
        final MapFile newMapFile = new MapFile(thisMapFile, mapPath);
        if (newMapFile.equals(thisMapFile)) {
            throw new SameMapException();
        }
        return newMapFile;
    }
 
    @NotNull
    @Override
    public List<G> getAllGameObjects() {
        final List<G> gameObjects = new ArrayList<>();
        for (final Iterable<G> mapSquare : this) {
            for (final G gameObject : mapSquare) {
                if (gameObject.isHead()) {
                    gameObjects.add(gameObject);
                }
            }
        }
        return gameObjects;
    }
 
    @Override
    public boolean isModified() {
        return modified;
    }
 
    @Override
    public void resetModified() {
        if (!modified) {
            return;
        }
 
        modified = false;
        fireModifiedChanged();
    }
 
    @Override
    public void facesReloaded() {
        beginTransaction("reload faces");
        try {
            for (final Iterable<G> mapSquare : this) {
                for (final G gameObject : mapSquare) {
                    gameObject.facesReloaded();
                }
            }
        } finally {
            endTransaction();
        }
    }
 
    @Override
    public void nextPoint(final Point point, final int direction) {
        final Size2D mapSize = mapArchObject.getMapSize();
        if (direction > 0) {
            point.x++;
            if (point.x >= mapSize.getWidth()) {
                point.x = 0;
                point.y++;
                if (point.y >= mapSize.getHeight()) {
                    point.y = 0;
                }
            }
        } else {
            point.x--;
            if (point.x < 0) {
                point.x = mapSize.getWidth() - 1;
                point.y--;
                if (point.y < 0) {
                    point.y = mapSize.getHeight() - 1;
                }
            }
        }
    }
 
    private void setModified() {
        if (modified) {
            return;
        }
 
        modified = true;
        fireModifiedChanged();
    }
 
    private void updateEditType(@NotNull final GameObject<G, A, R> gameObject, final int checkType) {
        assert gameObject.isHead();
        if (checkType == 0) {
            return;
        }
 
        // all flags from 'checkType' must be unset in this game object because
        // they get recalculated now
        final int editType = gameObject.getEditType();
        final int retainedEditType = editType == BaseObject.EDIT_TYPE_NONE ? 0 : editType & ~checkType;
        final int newEditType = retainedEditType | calculateEditType(gameObject, checkType);
        gameObject.setEditType(newEditType);
    }
 
    private int calculateEditType(@NotNull final GameObject<?, ?, ?> gameObject, final int checkType) {
        int editType = 0;
        for (final NamedGameObjectMatcher matcher : gameObjectMatchers) {
            final int matcherEditType = matcher.getEditType();
            if ((matcherEditType & checkType) != 0 && matcher.isMatching(gameObject)) {
                editType |= matcherEditType;
            }
        }
        return editType;
    }
 
    @NotNull
    private InsertionResult<G, A, R> joinInsert(@NotNull final Point point, @NotNull final R archetype) {
        if (archetype.isMulti()) {
            return new InsertionResult<>(archetype);
        }
 
        final AutojoinList<G, A, R> autojoinList = autojoinLists.getAutojoinList(archetype);
        if (autojoinList == null) {
            return new InsertionResult<>(archetype);
        }
 
        // if there already is an archetype of this list at point -> abort
        final boolean isMainIndex = autojoinList.isMainIndex(archetype);
        final G gameObject = findGameObjectOfAutojoinList(point, autojoinList);
        if (gameObject != null) {
            final R gameObjectArchetype = gameObject.getArchetype();
            final boolean isExistingMainIndex = autojoinList.isMainIndex(gameObjectArchetype);
            if (isMainIndex) {
                // alt/main -> main
                if (isExistingMainIndex) {
                    // ignore main -> main
                    return new InsertionResult<>(); // we don't want same archetypes over each other
                }
                // alt -> main -> update
            } else {
                // alt/main -> alt
                if (isExistingMainIndex) {
                    // main -> alt -> update
                } else {
                    // alt -> alt -> update if different archetype
                    if (gameObjectArchetype == archetype) {
                        return new InsertionResult<>(); // we don't want same archetypes over each other
                    }
                }
            }
        }
 
        // now do the joining in all four directions:
        final int altIndex = isMainIndex ? -1 : autojoinList.getAlternativeIndex(archetype);
        int newIndex = 0;      // return value, see above
        newIndex |= joinInsert(point, autojoinList, 0, -1, AutojoinList.NORTH, AutojoinList.SOUTH, altIndex);
        newIndex |= joinInsert(point, autojoinList, +1, 0, AutojoinList.EAST, AutojoinList.WEST, altIndex);
        newIndex |= joinInsert(point, autojoinList, 0, +1, AutojoinList.SOUTH, AutojoinList.NORTH, altIndex);
        newIndex |= joinInsert(point, autojoinList, -1, 0, AutojoinList.WEST, AutojoinList.EAST, altIndex);
        final R newArchetype = isMainIndex ? autojoinList.getArchetype(newIndex) : archetype;
        if (gameObject != null) {
            gameObject.setArchetype(newArchetype);
            return new InsertionResult<>(gameObject);
        }
        return new InsertionResult<>(newArchetype);
    }
 
    private int joinInsert(@NotNull final Point point, @NotNull final AutojoinList<G, A, R> autojoinList, final int dx, final int dy, final int dir, final int reverseDir, final int altIndex) {
        final Point tmp = new Point(point.x + dx, point.y + dy);
        if (!mapArchObject.isPointValid(tmp)) {
            return 0;
        }
 
        final GameObject<G, A, R> gameObject = findGameObjectOfAutojoinList(tmp, autojoinList);
        if (gameObject == null) {
            return 0;
        }
 
        final R archetype = gameObject.getArchetype();
        final int index = autojoinList.getAlternativeIndex(archetype);
        if (index != -1) {
            return (index & reverseDir) == 0 ? 0 : dir;
        }
 
        final int archetypeIndex = autojoinList.getIndex(archetype);
        final int newIndex;
        if ((altIndex & dir) == 0) {
            newIndex = archetypeIndex & ~reverseDir;
        } else {
            newIndex = archetypeIndex | reverseDir;
        }
        gameObject.setArchetype(autojoinList.getArchetype(newIndex));
        return dir;
    }
 
    private void joinDelete(@NotNull final Point point, @NotNull final R archetype) {
        if (archetype.isMulti()) {
            return;
        }
 
        final AutojoinList<G, A, R> autojoinList = autojoinLists.getAutojoinList(archetype);
        if (autojoinList == null) {
            return;
        }
 
        final boolean isMainIndex = autojoinList.isMainIndex(archetype);
        final int altIndex = isMainIndex ? -1 : autojoinList.getAlternativeIndex(archetype);
 
        joinDelete(point, autojoinList, 0, -1, AutojoinList.NORTH, AutojoinList.SOUTH, altIndex);
        joinDelete(point, autojoinList, +1, 0, AutojoinList.EAST, AutojoinList.WEST, altIndex);
        joinDelete(point, autojoinList, 0, +1, AutojoinList.SOUTH, AutojoinList.NORTH, altIndex);
        joinDelete(point, autojoinList, -1, 0, AutojoinList.WEST, AutojoinList.EAST, altIndex);
    }
 
    private void joinDelete(@NotNull final Point point, @NotNull final AutojoinList<G, A, R> autojoinList, final int dx, final int dy, final int reverseDir, final int dir, final int altIndex) {
        if ((altIndex & reverseDir) == 0) {
            return;
        }
 
        final Point tmp = new Point(point.x + dx, point.y + dy);
        if (!mapArchObject.isPointValid(tmp)) {
            return;
        }
 
        final GameObject<G, A, R> gameObject = findMainGameObjectOfAutojoinList(tmp, autojoinList);
        if (gameObject == null) {
            return;
        }
 
        gameObject.setArchetype(autojoinList.getArchetype(autojoinList.getIndex(gameObject.getArchetype()) & ~dir));
    }
 
    @Nullable
    private G findGameObjectOfAutojoinList(@NotNull final Point point, @NotNull final AutojoinList<G, A, R> autojoinList) {
        for (final G gameObject : getMapSquare(point).reverse()) {
            if (autojoinLists.getAutojoinList(gameObject.getArchetype()) == autojoinList) {
                return gameObject;
            }
        }
 
        return null;
    }
 
    @Nullable
    private GameObject<G, A, R> findMainGameObjectOfAutojoinList(@NotNull final Point point, @NotNull final AutojoinList<G, A, R> autojoinList) {
        for (final GameObject<G, A, R> gameObject : getMapSquare(point).reverse()) {
            final R archetype = gameObject.getArchetype();
            if (autojoinLists.getAutojoinList(archetype) == autojoinList && autojoinList.isMainIndex(archetype)) {
                return gameObject;
            }
        }
 
        return null;
    }
 
}