MapGrid.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.mapgrid;

import java.awt.Point;
import java.awt.Rectangle;
import java.util.ArrayList;
import java.util.List;
import net.sf.gridarta.utils.EventListenerList2;
import net.sf.gridarta.utils.Size2D;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class MapGrid {

    @NotNull
    private int[][] gridFlags;

    @NotNull
    private final Point cornerMin = new Point();

    @NotNull
    private final Point cornerMax = new Point();

    @NotNull
    private Size2D gridSize;

    @NotNull
    private final Rectangle recChange = new Rectangle();

    private boolean cachedSelectedRecValid;

    @Nullable
    private Rectangle cachedSelectedRec;

    @Nullable
    private Point cachedCursorLoc;

    public static final int GRID_FLAG_SELECTION = 1;

    public static final int GRID_FLAG_SELECTING = 1 << 1;

    public static final int GRID_FLAG_INFORMATION = 1 << 2;

    public static final int GRID_FLAG_WARNING = 1 << 3;

    public static final int GRID_FLAG_ERROR = 1 << 4;

    public static final int GRID_FLAG_FATAL = 1 << 5;

    public static final int GRID_FLAG_CONNECTION = 1 << 6;

    public static final int GRID_FLAG_CURSOR = 1 << 7;

    public static final int GRID_FLAG_SELECTION_NORTH = 1 << 8;

    public static final int GRID_FLAG_SELECTION_EAST = 1 << 9;

    public static final int GRID_FLAG_SELECTION_SOUTH = 1 << 10;

    public static final int GRID_FLAG_SELECTION_WEST = 1 << 11;

    @NotNull
    private final EventListenerList2<MapGridListener> listenerList = new EventListenerList2<>(MapGridListener.class);

    private int transactionDepth;

    @Nullable
    private Thread transactionThread;

    public MapGrid(@NotNull final Size2D gridSize) {
        this.gridSize = gridSize;
        gridFlags = new int[gridSize.getWidth()][gridSize.getHeight()];
    }

    public void addMapGridListener(@NotNull final MapGridListener listener) {
        listenerList.add(listener);
    }

    public void removeMapGridListener(@NotNull final MapGridListener listener) {
        listenerList.remove(listener);
    }

    @NotNull
    public Size2D getGridSize() {
        return gridSize;
    }

    public void resize(@NotNull final Size2D newSize) {
        if (gridSize.equals(newSize)) {
            // Nothing to do
            return;
        }
        final int[][] newGridFlags = new int[newSize.getWidth()][newSize.getHeight()];
        final Point pos = new Point();
        final Size2D minSize = new Size2D(Math.min(newSize.getWidth(), gridSize.getWidth()), Math.min(newSize.getHeight(), gridSize.getHeight()));
        if (newSize.getWidth() < gridSize.getWidth()) {
            unsetFlags(newSize.getWidth(), 0, newSize.getWidth(), minSize.getHeight() - 1, GRID_FLAG_SELECTION);
        }
        if (newSize.getHeight() < gridSize.getHeight()) {
            unsetFlags(0, newSize.getHeight(), minSize.getWidth() - 1, newSize.getHeight(), GRID_FLAG_SELECTION);
        }
        for (pos.x = 0; pos.x < minSize.getWidth(); pos.x++) {
            for (pos.y = 0; pos.y < minSize.getHeight(); pos.y++) {
                newGridFlags[pos.x][pos.y] = gridFlags[pos.x][pos.y];
            }
        }
        gridFlags = newGridFlags;
        gridSize = newSize;
        cachedSelectedRecValid = false;
        fireMapGridResizeEvent();
    }

    private void fireMapGridChangedEvent() {
        final MapGridEvent e = new MapGridEvent(this);
        for (final MapGridListener listener : listenerList.getListeners()) {
            listener.mapGridChanged(e);
        }
    }

    private void fireMapGridResizeEvent() {
        final MapGridEvent e = new MapGridEvent(this);
        for (final MapGridListener listener : listenerList.getListeners()) {
            listener.mapGridResized(e);
        }
    }

    public void unSelect() {
        beginTransaction();
        try {
            unsetFlags(0, 0, gridSize.getWidth() - 1, gridSize.getHeight() - 1, GRID_FLAG_SELECTION | GRID_FLAG_SELECTING);
        } finally {
            endTransaction();
        }
    }

    public void unSetCursor(@NotNull final Point pos) {
        beginTransaction();
        try {
            try {
                unsetFlags(pos.x, pos.y, pos.x, pos.y, GRID_FLAG_CURSOR);
            } catch (final ArrayIndexOutOfBoundsException ignored) {
                // happens after map resizes if the map cursor was within the cut off area
            }
            if (cachedCursorLoc != null && cachedCursorLoc.equals(pos)) {
                cachedCursorLoc = null;
            }
        } finally {
            endTransaction();
        }
    }

    public void setCursor(@NotNull final Point pos) {
        beginTransaction();
        try {
            setFlags(pos.x, pos.y, pos.x, pos.y, GRID_FLAG_CURSOR);
            cachedCursorLoc = new Point(pos);
        } finally {
            endTransaction();
        }
    }

    public void preSelect(@NotNull final Point start, @NotNull final Point end) {
        beginTransaction();
        try {
            calculateRec(start, end);
            setFlags(cornerMin.x, cornerMin.y, cornerMax.x, cornerMax.y, GRID_FLAG_SELECTING);
        } finally {
            endTransaction();
        }
    }

    public void updatePreSelect(@NotNull final Point start, @NotNull final Point oldEnd, @NotNull final Point newEnd) {
        final Point old1 = new Point(Math.min(start.x, oldEnd.x), Math.min(start.y, oldEnd.y));
        final Point old2 = new Point(Math.max(start.x, oldEnd.x), Math.max(start.y, oldEnd.y));
        final Point new1 = new Point(Math.min(start.x, newEnd.x), Math.min(start.y, newEnd.y));
        final Point new2 = new Point(Math.max(start.x, newEnd.x), Math.max(start.y, newEnd.y));
        beginTransaction();
        try {
            // delete old selection
            if (old1.x < new1.x) {
                unsetFlags(old1.x, old1.y, new1.x - 1, old2.y, GRID_FLAG_SELECTING);
                old1.x = new1.x;
            }
            if (new2.x < old2.x) {
                unsetFlags(new2.x + 1, old1.y, old2.x, old2.y, GRID_FLAG_SELECTING);
                old2.x = new2.x;
            }
            if (old1.y < new1.y) {
                unsetFlags(old1.x, old1.y, old2.x, new1.y - 1, GRID_FLAG_SELECTING);
                old1.y = new1.y;
            }
            if (new2.y < old2.y) {
                unsetFlags(old1.x, new2.y + 1, old2.x, old2.y, GRID_FLAG_SELECTING);
                old2.y = new2.y;
            }

            // add new selection
            if (new1.x < old1.x) {
                setFlags(new1.x, new1.y, old1.x - 1, new2.y, GRID_FLAG_SELECTING);
                old1.x = new1.x;
            }
            if (old2.x < new2.x) {
                setFlags(old2.x + 1, new1.y, new2.x, new2.y, GRID_FLAG_SELECTING);
                old2.x = new2.x;
            }
            if (new1.y < old1.y) {
                setFlags(new1.x, new1.y, new2.x, old1.y - 1, GRID_FLAG_SELECTING);
                old1.y = new1.y;
            }
            if (old2.y < new2.y) {
                setFlags(new1.x, old2.y + 1, new2.x, new2.y, GRID_FLAG_SELECTING);
                old2.y = new2.y;
            }

            // sanity check
            assert old1.x == new1.x;
            assert old2.x == new2.x;
            assert old1.y == new1.y;
            assert old2.y == new2.y;
        } finally {
            endTransaction();
        }
    }

    public void unPreSelect(@NotNull final Point start, @NotNull final Point end) {
        beginTransaction();
        try {
            calculateRec(start, end);
            unsetFlags(cornerMin.x, cornerMin.y, cornerMax.x, cornerMax.y, GRID_FLAG_SELECTING);
        } finally {
            endTransaction();
        }
    }

    public void select(@NotNull final Point pos, @NotNull final SelectionMode selectionMode) {
        selectArea(pos, pos, selectionMode);
    }

    public void selectArea(@NotNull final Point pos1, @NotNull final Point pos2, @NotNull final SelectionMode selectionMode) {
        beginTransaction();
        try {
            calculateRec(pos1, pos2);
            switch (selectionMode) {
            case ADD:
                setFlags(cornerMin.x, cornerMin.y, cornerMax.x, cornerMax.y, GRID_FLAG_SELECTION);
                break;
            case SUB:
                unsetFlags(cornerMin.x, cornerMin.y, cornerMax.x, cornerMax.y, GRID_FLAG_SELECTION);
                break;
            case FLIP:
                toggleFlags(cornerMin.x, cornerMin.y, cornerMax.x, cornerMax.y, GRID_FLAG_SELECTION);
                break;
            }
        } finally {
            endTransaction();
        }
    }

    private void calculateRec(@NotNull final Point p1, @NotNull final Point p2) {
        if (p1.x > p2.x) {
            cornerMin.x = p2.x;
            cornerMax.x = p1.x;
        } else {
            cornerMin.x = p1.x;
            cornerMax.x = p2.x;
        }
        if (p1.y > p2.y) {
            cornerMin.y = p2.y;
            cornerMax.y = p1.y;
        } else {
            cornerMin.y = p1.y;
            cornerMax.y = p2.y;
        }
    }

    public boolean hasError(@NotNull final Point p) {
        return (gridFlags[p.x][p.y] & GRID_FLAG_ERROR) != 0;
    }

    public int getFlags(final int x, final int y) {
        return gridFlags[x][y];
    }

    public int getFlags(@NotNull final Point p) {
        return gridFlags[p.x][p.y];
    }

    @NotNull
    public Rectangle getRecChange() {
        return new Rectangle(recChange);
    }

    @NotNull
    public Size2D getSize() {
        return gridSize;
    }

    @Nullable
    public Rectangle getSelectedRec() {
        calculateCachedSelectedRec();
        if (cachedSelectedRec != null) {
            return new Rectangle(cachedSelectedRec);
        }
        if (cachedCursorLoc != null) {
            return new Rectangle(cachedCursorLoc.x, cachedCursorLoc.y, 1, 1);
        }
        return null;
    }

    private void calculateCachedSelectedRec() {
        if (cachedSelectedRecValid) {
            return;
        }
        cachedSelectedRecValid = true;

        int x1 = -1;
        for (int x = 0; x < gridSize.getWidth(); x++) {
            for (int y = 0; y < gridSize.getHeight(); y++) {
                if ((gridFlags[x][y] & GRID_FLAG_SELECTION) > 0) {
                    x1 = x;
                    break;
                }
            }
            if (x1 >= 0) {
                break;
            }
        }
        if (x1 < 0) {
            cachedSelectedRec = null;
            return;
        }

        int x2 = -1;
        for (int x = gridSize.getWidth() - 1; x >= x1; x--) {
            for (int y = 0; y < gridSize.getHeight(); y++) {
                if ((gridFlags[x][y] & GRID_FLAG_SELECTION) > 0) {
                    x2 = x;
                    break;
                }
            }
            if (x2 >= 0) {
                break;
            }
        }
        int y1 = -1;
        for (int y = 0; y < gridSize.getHeight(); y++) {
            for (int x = 0; x < gridSize.getWidth(); x++) {
                if ((gridFlags[x][y] & GRID_FLAG_SELECTION) > 0) {
                    y1 = y;
                    break;
                }
            }
            if (y1 >= 0) {
                break;
            }
        }
        int y2 = -1;
        for (int y = gridSize.getHeight() - 1; y >= y1; y--) {
            for (int x = 0; x < gridSize.getWidth(); x++) {
                if ((gridFlags[x][y] & GRID_FLAG_SELECTION) > 0) {
                    y2 = y;
                    break;
                }
            }
            if (y2 >= 0) {
                break;
            }
        }
        cachedSelectedRec = new Rectangle(x1, y1, x2 - x1 + 1, y2 - y1 + 1);
    }

    public void selectAll() {
        beginTransaction();
        try {
            setFlags(0, 0, gridSize.getWidth() - 1, gridSize.getHeight() - 1, GRID_FLAG_SELECTION);
        } finally {
            endTransaction();
        }
    }

    public void invertSelection() {
        beginTransaction();
        try {
            toggleFlags(0, 0, gridSize.getWidth() - 1, gridSize.getHeight() - 1, GRID_FLAG_SELECTION);
        } finally {
            endTransaction();
        }
    }

    public void setError(final int x, final int y) {
        beginTransaction();
        try {
            setFlags(x, y, x, y, GRID_FLAG_ERROR);
        } finally {
            endTransaction();
        }
    }

    public void clearErrors() {
        beginTransaction();
        try {
            unsetFlags(0, 0, gridSize.getWidth() - 1, gridSize.getHeight() - 1, GRID_FLAG_ERROR);
        } finally {
            endTransaction();
        }
    }

    private void beginRecChange() {
        recChange.x = gridSize.getWidth();
        recChange.y = gridSize.getHeight();
        recChange.width = 0;
        recChange.height = 0;
    }

    private void updateRecChange(final int x, final int y) {
        if (recChange.x > x) {
            recChange.x = x;
        }
        if (recChange.y > y) {
            recChange.y = y;
        }
        if (recChange.width < x) {
            recChange.width = x;
        }
        if (recChange.height < y) {
            recChange.height = y;
        }
    }

    private boolean endRecChange() {
        recChange.width = recChange.width - recChange.x + 1;
        recChange.height = recChange.height - recChange.y + 1;
        return recChange.width > 0 && recChange.height > 0;
    }

    private void setFlags(final int minX, final int minY, final int maxX, final int maxY, final int flags) {
        for (int x = minX; x <= maxX; x++) {
            for (int y = minY; y <= maxY; y++) {
                if ((gridFlags[x][y] & flags) != flags) {
                    if ((flags & GRID_FLAG_SELECTION) != 0 && (gridFlags[x][y] & GRID_FLAG_SELECTION) == 0) {
                        updateSelectionFlag(x, y, true);
                    }
                    gridFlags[x][y] |= flags;
                    updateRecChange(x, y);
                    cachedSelectedRecValid = false;
                }
            }
        }
    }

    private void unsetFlags(final int minX, final int minY, final int maxX, final int maxY, final int flags) {
        for (int x = minX; x <= maxX; x++) {
            for (int y = minY; y <= maxY; y++) {
                if ((gridFlags[x][y] & flags) != 0) {
                    if ((flags & GRID_FLAG_SELECTION) != 0 && (gridFlags[x][y] & GRID_FLAG_SELECTION) != 0) {
                        updateSelectionFlag(x, y, false);
                    }
                    gridFlags[x][y] &= ~flags;
                    updateRecChange(x, y);
                    cachedSelectedRecValid = false;
                }
            }
        }
    }

    private void toggleFlags(final int minX, final int minY, final int maxX, final int maxY, final int flags) {
        for (int x = minX; x <= maxX; x++) {
            for (int y = minY; y <= maxY; y++) {
                updateSelectionFlag(x, y, (gridFlags[x][y] & flags) == 0);
                gridFlags[x][y] ^= flags;
            }
        }
        cachedSelectedRecValid = false;
        updateRecChange(minX, minY);
        updateRecChange(maxX, maxY);
    }

    public void beginTransaction() {
        if (transactionDepth == 0) {
            transactionThread = Thread.currentThread();
            beginRecChange();
        } else {
            // == is okay for threads.
            //noinspection ObjectEquality
            if (transactionThread != Thread.currentThread()) {
                throw new IllegalStateException("A transaction must only be used by one thread.");
            }
        }
        transactionDepth++;
    }

    public void endTransaction() {
        if (transactionDepth <= 0) {
            throw new IllegalStateException("Tried to end a transaction but no transaction was open.");
        }
        transactionDepth--;
        assert transactionDepth >= 0;
        if (transactionDepth == 0) {
            transactionDepth = 0;
            transactionThread = null;
            if (endRecChange()) {
                fireMapGridChangedEvent();
            }
        }
    }

    private void updateSelectionFlag(final int x, final int y, final boolean newState) {
        updateSelectionFlag(x, y, newState, x, y - 1, GRID_FLAG_SELECTION_NORTH, GRID_FLAG_SELECTION_SOUTH);
        updateSelectionFlag(x, y, newState, x, y + 1, GRID_FLAG_SELECTION_SOUTH, GRID_FLAG_SELECTION_NORTH);
        updateSelectionFlag(x, y, newState, x - 1, y, GRID_FLAG_SELECTION_WEST, GRID_FLAG_SELECTION_EAST);
        updateSelectionFlag(x, y, newState, x + 1, y, GRID_FLAG_SELECTION_EAST, GRID_FLAG_SELECTION_WEST);
    }

    private void updateSelectionFlag(final int x, final int y, final boolean newState, final int dx, final int dy, final int flag, final int dFlag) {
        final boolean dState = 0 <= dx && dx < gridSize.getWidth() && 0 <= dy && dy < gridSize.getHeight() && (gridFlags[dx][dy] & GRID_FLAG_SELECTION) != 0;
        if (newState) {
            if (dState) {
                gridFlags[dx][dy] &= ~dFlag;
                updateRecChange(dx, dy);
            } else {
                gridFlags[x][y] |= flag;
                updateRecChange(x, y);
            }
        } else {
            if (dState) {
                gridFlags[dx][dy] |= dFlag;
                updateRecChange(dx, dy);
            } else {
                gridFlags[x][y] &= ~flag;
                updateRecChange(x, y);
            }
        }
    }

    @NotNull
    public Point[] getSelection() {
        final List<Point> selection = new ArrayList<>();
        calculateCachedSelectedRec();
        final Rectangle selectedRec = cachedSelectedRec;
        if (selectedRec != null) {
            for (int x = selectedRec.x; x < selectedRec.x + selectedRec.width; x++) {
                for (int y = selectedRec.y; y < selectedRec.y + selectedRec.height; y++) {
                    if ((gridFlags[x][y] & GRID_FLAG_SELECTION) > 0) {
                        selection.add(new Point(x, y));
                    }
                }
            }
        } else if (cachedCursorLoc != null) {
            selection.add(new Point(cachedCursorLoc));
        }
        return selection.toArray(new Point[selection.size()]);
    }

}