MapCursor.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.mapcursor;
 
import java.awt.Dimension;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.geom.Rectangle2D;
import java.util.Collection;
import java.util.concurrent.CopyOnWriteArrayList;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.baseobject.BaseObject;
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.mapgrid.MapGrid;
import net.sf.gridarta.model.mapgrid.MapGridEvent;
import net.sf.gridarta.model.mapgrid.MapGridListener;
import net.sf.gridarta.model.mapgrid.SelectionMode;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.utils.Size2D;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public class MapCursor<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> {
 
    @NotNull
    private final Point pos;
 
    @NotNull
    private final Point dragStart = new Point();
 
    @NotNull
    private final Dimension dragOffset = new Dimension();
 
    private boolean dragging;
 
    @NotNull
    private final MapGrid mapGrid;
 
    @NotNull
    private final MapModel<G, A, R> mapModel;
 
    @NotNull
    private final Rectangle mapRec;
 
    @NotNull
    private final Point tmpPoint = new Point();
 
    @Nullable
    private MapSquare<G, A, R> mapSquare;
 
    @Nullable
    private G gameObject;
 
    private int transactionDepth;
 
    @NotNull
    private final Point transactionPos = new Point();
 
    private boolean transactionDragging;
 
    @Nullable
    private MapSquare<G, A, R> transactionMapSquare;
 
    @Nullable
    private G transactionGameObject;
 
    @NotNull
    private final Rectangle2D transactionMapRec = new Rectangle();
 
    @NotNull
    private final Collection<MapCursorListener<G, A, R>> listenerList = new CopyOnWriteArrayList<>();
 
    public MapCursor(@NotNull final MapGrid mapGrid, @NotNull final MapModel<G, A, R> mapModel) {
        this.mapGrid = mapGrid;
        this.mapModel = mapModel;
        final Size2D gridSize = mapGrid.getGridSize();
        mapRec = new Rectangle(0, 0, gridSize.getWidth(), gridSize.getHeight());
        final A mapArchObject = mapModel.getMapArchObject();
        pos = fixPoint(new Point(mapArchObject.getEnterX(), mapArchObject.getEnterY()));
        final MapGridListener mapGridListener = new MapGridListener() {
 
            @Override
            public void mapGridChanged(@NotNull final MapGridEvent e) {
                // We can ignore this event. Normally this MapCursor has caused it.
            }
 
            @Override
            public void mapGridResized(@NotNull final MapGridEvent e) {
                final Size2D newSize = mapGrid.getGridSize();
                final int newWidth = newSize.getWidth();
                final int newHeight = newSize.getHeight();
                beginTransaction();
                try {
                    mapRec.setSize(newWidth, newHeight);
                    // Test if drag start point is outside map -> move inside
                    if (dragging && !mapRec.contains(dragStart)) {
                        dragStart.x = Math.min(dragStart.x, mapRec.width - 1);
                        dragStart.y = Math.min(dragStart.y, mapRec.height - 1);
                    }
                    // Test if cursor position is outside map -> move inside
                    if (!mapRec.contains(pos)) {
                        pos.x = Math.min(pos.x, mapRec.width - 1);
                        pos.y = Math.min(pos.y, mapRec.height - 1);
                        selectMapSquare();
                    }
                } finally {
                    endTransaction();
                }
            }
 
        };
        mapGrid.addMapGridListener(mapGridListener);
        mapGrid.setCursor(pos);
        beginTransaction();
        try {
            selectMapSquare();
        } finally {
            endTransaction();
        }
    }
 
    @NotNull
    public Point getLocation() {
        return new Point(pos);
    }
 
    public void setLocation(@NotNull final Point p) {
        beginTransaction();
        try {
            final Point effectivePoint = fixPoint(p);
            if (!pos.equals(effectivePoint)) {
                pos.setLocation(effectivePoint);
                selectMapSquare();
            }
        } finally {
            endTransaction();
        }
    }
 
    public boolean setLocationSafe(@Nullable final Point p) {
        beginTransaction();
        final boolean hasChanged;
        try {
            if (p != null && mapRec.contains(p)) {
                if (pos.equals(p)) {
                    hasChanged = false;
                } else {
                    pos.setLocation(p);
                    selectMapSquare();
                    hasChanged = true;
                }
            } else {
                hasChanged = false;
            }
        } finally {
            endTransaction();
        }
        return hasChanged;
    }
 
    public void dragStart() {
        if (!dragging) {
            beginTransaction();
            try {
                dragStart.setLocation(pos);
                mapGrid.preSelect(dragStart, pos);
                dragging = true;
                dragOffset.setSize(0, 0);
            } finally {
                endTransaction();
            }
        }
    }
 
    public boolean dragTo(@Nullable final Point p) {
        if (p != null && mapRec.contains(p) && dragging && !pos.equals(p)) {
            beginTransaction();
            try {
                final Point oldPos = new Point(pos);
                pos.setLocation(p);
                selectMapSquare();
                mapGrid.updatePreSelect(dragStart, oldPos, pos);
                dragOffset.setSize(pos.x - dragStart.x, pos.y - dragStart.y);
            } finally {
                endTransaction();
            }
            return true;
        }
        return false;
    }
 
    public void dragRelease() {
        if (dragging) {
            beginTransaction();
            try {
                mapGrid.unPreSelect(dragStart, pos);
                dragging = false;
            } finally {
                endTransaction();
            }
        }
    }
 
    public void dragSelect(@NotNull final SelectionMode selectionMode, final boolean forceSelect) {
        if (dragging) {
            beginTransaction();
            try {
                dragRelease();
                if (forceSelect || !dragStart.equals(pos)) {
                    mapGrid.selectArea(dragStart, pos, selectionMode);
                }
            } finally {
                endTransaction();
            }
        }
    }
 
    public final void deactivate() {
        beginTransaction();
        try {
            dragging = false;
            mapGrid.unSelect();
        } finally {
            endTransaction();
        }
    }
 
    @Nullable
    public Dimension getDragOffset() {
        return dragging ? dragOffset : null;
    }
 
    public boolean isOnGrid(@Nullable final Point p) {
        return p != null && mapRec.contains(p);
    }
 
    public boolean goTo(final boolean performAction, @NotNull final Direction dir) {
        if (dir.getDx() == 0 && dir.getDy() == 0) {
            return false;
        }
        tmpPoint.setLocation(pos.x + dir.getDx(), pos.y + dir.getDy());
        if (!mapRec.contains(tmpPoint)) {
            return false;
        }
        if (performAction) {
            if (dragging) {
                dragTo(tmpPoint);
            } else {
                setLocationSafe(tmpPoint);
            }
        }
        return true;
    }
 
    public boolean isDragging() {
        return dragging;
    }
 
    public void addMapCursorListener(@NotNull final MapCursorListener<G, A, R> listener) {
        listenerList.add(listener);
    }
 
    public void removeMapCursorListener(@NotNull final MapCursorListener<G, A, R> listener) {
        listenerList.remove(listener);
    }
 
    @Nullable
    public G getGameObject() {
        return gameObject;
    }
 
    public void setGameObject(@Nullable final G gameObject) {
        beginTransaction();
        try {
            if (gameObject == null) {
                this.gameObject = null;
            } else {
                final MapSquare<G, A, R> mapSquare = gameObject.getMapSquareOptional();
                if (mapSquare != null && mapSquare.getMapModel() == mapModel) {
                    pos.setLocation(mapSquare.getMapX(), mapSquare.getMapY());
                    this.mapSquare = mapSquare;
                    this.gameObject = gameObject;
                }
            }
        } finally {
            endTransaction();
        }
    }
 
    public void setMapSquare(@Nullable final MapSquare<G, A, R> mapSquare) {
        beginTransaction();
        try {
            if (mapSquare != null && mapSquare.getMapModel() == mapModel) {
                pos.setLocation(mapSquare.getMapX(), mapSquare.getMapY());
                this.mapSquare = mapSquare;
                selectTopmostGameObject();
            }
        } finally {
            endTransaction();
        }
    }
 
    public final void beginTransaction() {
        if (transactionDepth == 0) {
            transactionPos.setLocation(pos);
            transactionDragging = dragging;
            transactionMapSquare = mapSquare;
            transactionGameObject = gameObject;
            transactionMapRec.setRect(mapRec);
        }
        transactionDepth++;
        mapGrid.beginTransaction();
    }
 
    public final void endTransaction() {
        assert transactionDepth > 0;
        transactionDepth--;
 
        if (transactionDepth == 0) {
            final boolean changedPos = !pos.equals(transactionPos) || mapSquare != transactionMapSquare;
            final boolean changedMode = dragging != transactionDragging;
            final boolean changedGameObject = mapSquare != transactionMapSquare || gameObject != transactionGameObject;
            final boolean changedSize = !mapRec.equals(transactionMapRec);
            if (!pos.equals(transactionPos)) {
                mapGrid.unSetCursor(transactionPos);
                mapGrid.setCursor(pos);
            }
            if (changedMode) {
                for (final MapCursorListener<G, A, R> listener : listenerList) {
                    listener.mapCursorChangedMode();
                }
            }
            if (changedPos) {
                for (final MapCursorListener<G, A, R> listener : listenerList) {
                    listener.mapCursorChangedPos(getLocation());
                }
            }
            if (changedGameObject) {
                for (final MapCursorListener<G, A, R> listener : listenerList) {
                    listener.mapCursorChangedGameObject(mapSquare, gameObject);
                }
            }
            if (changedSize) {
                for (final MapCursorListener<G, A, R> listener : listenerList) {
                    listener.mapCursorChangedSize();
                }
            }
        }
 
        mapGrid.endTransaction();
    }
 
    private void selectMapSquare() {
        assert transactionDepth > 0;
        try {
            mapSquare = mapModel.getMapSquare(pos);
        } catch (final IndexOutOfBoundsException ignored) {
            mapSquare = null;
        }
        selectTopmostGameObject();
    }
 
    private void selectTopmostGameObject() {
        assert transactionDepth > 0;
        gameObject = mapSquare == null ? null : mapSquare.getLast();
    }
 
    public boolean selectAbove(final boolean performAction) {
        if (mapSquare == null || gameObject == null) {
            return false;
        }
 
        final G newGameObject = mapSquare.getPrev(gameObject);
        if (newGameObject == null) {
            return false;
        }
 
        if (performAction) {
            beginTransaction();
            try {
                gameObject = newGameObject;
            } finally {
                endTransaction();
            }
        }
        return true;
    }
 
    public boolean selectBelow(final boolean performAction) {
        if (mapSquare == null || gameObject == null) {
            return false;
        }
 
        final G newGameObject = mapSquare.getNext(gameObject);
        if (newGameObject == null) {
            return false;
        }
 
        if (performAction) {
            beginTransaction();
            try {
                gameObject = newGameObject;
            } finally {
                endTransaction();
            }
        }
        return true;
    }
 
    public boolean insertGameObject(final boolean performAction, @NotNull final BaseObject<G, A, R, ?> gameObject, final boolean insertAtEnd, final boolean join) {
        if (performAction) {
            mapModel.beginTransaction("Insert"); // TODO; I18N/L10N
            try {
                final G insertedGameObject = mapModel.insertArchToMap(gameObject, insertAtEnd ? null : this.gameObject, pos, join);
                if (insertedGameObject != null) {
                    beginTransaction();
                    try {
                        this.gameObject = insertedGameObject;
                    } finally {
                        endTransaction();
                    }
                }
            } finally {
                mapModel.endTransaction();
            }
        }
        return true;
    }
 
    public boolean deleteSelectedGameObject(final boolean performAction, final boolean autoJoin) {
        final G gameObject = this.gameObject;
        if (gameObject == null) {
            return false;
        }
 
        final MapSquare<G, A, R> mapSquare = this.mapSquare;
        if (mapSquare == null) {
            return false;
        }
 
        if (performAction) {
            mapModel.beginTransaction("Delete"); // TODO; I18N/L10N
            try {
                G nextGameObject = mapSquare.getNext(gameObject);
                mapModel.removeGameObject(gameObject, autoJoin);
                if (nextGameObject == null) {
                    nextGameObject = mapSquare.getFirst();
                }
                if (nextGameObject != null) {
                    while (true) {
                        final G invGameObject = nextGameObject.getFirst();
                        if (invGameObject == null) {
                            break;
                        }
                        nextGameObject = invGameObject;
                    }
                }
                beginTransaction();
                try {
                    this.gameObject = nextGameObject;
                } finally {
                    endTransaction();
                }
            } finally {
                mapModel.endTransaction();
            }
        }
 
        return true;
    }
 
    @NotNull
    private Point fixPoint(@NotNull final Point p) {
        return mapRec.contains(p) ? p : new Point(Math.max(Math.min(p.x, mapRec.width - 1), 0), Math.max(Math.min(p.y, mapRec.height - 1), 0));
    }
 
}