MapCursorTest.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.mapcursor;

import java.awt.Dimension;
import java.awt.Point;
import junit.framework.JUnit4TestAdapter;
import net.sf.gridarta.model.archetype.TestArchetype;
import net.sf.gridarta.model.direction.Direction;
import net.sf.gridarta.model.gameobject.TestGameObject;
import net.sf.gridarta.model.maparchobject.TestMapArchObject;
import net.sf.gridarta.model.mapgrid.MapGrid;
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.model.mapmodel.TestMapModelCreator;
import net.sf.gridarta.utils.Size2D;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.junit.Assert;
import org.junit.Test;

public class MapCursorTest {

    private static final int ENTER_X = 1;

    private static final int ENTER_Y = 2;

    @NotNull
    private static final Size2D GRID_SIZE = new Size2D(6, 7);

    @NotNull
    private static final TestMapCursorListener LISTENER = new TestMapCursorListener();

    @NotNull
    private static MapCursor<TestGameObject, TestMapArchObject, TestArchetype> createCursor(@NotNull final MapGrid grid) {
        final TestMapModelCreator mapModelCreator = new TestMapModelCreator(false);
        final Size2D gridSize = grid.getSize();
        final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel = mapModelCreator.newMapModel(gridSize.getWidth(), gridSize.getHeight());
        mapModel.getMapArchObject().setEnterX(ENTER_X);
        mapModel.getMapArchObject().setEnterY(ENTER_Y);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = new MapCursor<>(grid, mapModel);
        cursor.addMapCursorListener(LISTENER);
        LISTENER.changedPosCounter = 0;
        LISTENER.changedModeCounter = 0;
        return cursor;
    }

    @Test
    public void setOutside() {
        final MapGrid grid = new MapGrid(GRID_SIZE);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = createCursor(grid);
        final Point p = new Point();
        final int width = GRID_SIZE.getWidth();
        final int height = GRID_SIZE.getHeight();
        for (int i = -2; i < width + 2; i++) {
            p.setLocation(i, -1);
            cursor.setLocation(p);
            testEvents(1, 0);
            Assert.assertEquals(new Point(Math.max(0, Math.min(width - 1, i)), 0), cursor.getLocation());
            testEvents(0, 0);
            p.setLocation(i, height);
            cursor.setLocation(p);
            testEvents(1, 0);
            Assert.assertEquals(new Point(Math.max(0, Math.min(width - 1, i)), height - 1), cursor.getLocation());
            testEvents(0, 0);
        }
        for (int i = -2; i < height + 2; i++) {
            p.setLocation(-1, i);
            cursor.setLocation(p);
            testEvents(1, 0);
            Assert.assertEquals(new Point(0, Math.max(0, Math.min(height - 1, i))), cursor.getLocation());
            testEvents(0, 0);
            p.setLocation(width, i);
            cursor.setLocation(p);
            testEvents(1, 0);
            Assert.assertEquals(new Point(width - 1, Math.max(0, Math.min(height - 1, i))), cursor.getLocation());
            testEvents(0, 0);
        }
    }

    @Test
    public void setInside() {
        final MapGrid grid = new MapGrid(GRID_SIZE);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = createCursor(grid);
        final Point p = new Point();
        for (int j = 0; j < GRID_SIZE.getHeight(); j++) {
            for (int i = 0; i < GRID_SIZE.getWidth(); i++) {
                p.setLocation(i, j);
                cursor.setLocation(p);
                testEvents(1, 0);
                final Point res = cursor.getLocation();
                testEvents(0, 0);
                Assert.assertEquals("getLocation()", p, res);
            }
        }
    }

    @Test
    public void setSameLocation() {
        final MapGrid grid = new MapGrid(GRID_SIZE);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = createCursor(grid);
        cursor.setLocation(new Point(3, 4));
        testEvents(1, 0);
        cursor.setLocation(new Point(3, 4));
        testEvents(0, 0);
        cursor.setLocation(new Point(1, 0));
        testEvents(1, 0);
        cursor.setLocation(new Point(1, -1));
        testEvents(0, 0);
        cursor.setLocation(new Point(-3, -2));
        testEvents(1, 0);
        cursor.setLocation(new Point(-2, -1));
        testEvents(0, 0);
        cursor.setLocation(new Point(0, 0));
        testEvents(0, 0);
    }

    @Test
    public void setLocationSafe() {
        final MapGrid grid = new MapGrid(GRID_SIZE);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = createCursor(grid);
        final Point p = new Point(-1, -1);
        Assert.assertFalse("setLocationSafe(null) should return false", cursor.setLocationSafe(null));
        testEvents(0, 0);
        Assert.assertFalse("setLocationSafe(" + p + ") should return false", cursor.setLocationSafe(p));
        testEvents(0, 0);
        p.setLocation(3, 4);
        Assert.assertTrue("setLocationSafe(" + p + ") should return true", cursor.setLocationSafe(p));
        testEvents(1, 0);
        Assert.assertFalse("setLocationSafe(" + p + ") should return false", cursor.setLocationSafe(p));
        testEvents(0, 0);
        p.setLocation(-1, -1);
        Assert.assertFalse("setLocationSafe(" + p + ") should return false", cursor.setLocationSafe(p));
        testEvents(0, 0);
        Assert.assertFalse("setLocationSafe(null) should return false", cursor.setLocationSafe(null));
        testEvents(0, 0);
    }

    @Test
    public void testIsOnGrid() {
        final MapGrid grid = new MapGrid(GRID_SIZE);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = createCursor(grid);
        final Point p = new Point();
        for (int j = -2; j < GRID_SIZE.getHeight() + 2; j++) {
            for (int i = -2; i < GRID_SIZE.getWidth() + 2; i++) {
                p.setLocation(i, j);
                if (i >= 0 && i < GRID_SIZE.getWidth() && j >= 0 && j < GRID_SIZE.getHeight()) {
                    Assert.assertTrue(p + " should be on the grid.", cursor.isOnGrid(p));
                } else {
                    Assert.assertFalse(p + " should not be on the grid.", cursor.isOnGrid(p));
                }
            }
        }
        Assert.assertFalse("Null should not be on the grid.", cursor.isOnGrid(null));
    }

    @Test
    public void testGoTo() {
        final MapGrid grid = new MapGrid(GRID_SIZE);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = createCursor(grid);
        final Point pStart = new Point(2, 3);
        final Point p = new Point(pStart);
        cursor.setLocation(p);
        testEvents(1, 0);
        for (final Direction dir : Direction.values()) {
            if (dir == Direction.UP || dir == Direction.DOWN) {
                Assert.assertFalse("go(" + dir + ") should return false. (Maybe the grid was too small.)", cursor.goTo(true, dir));
                testEvents(0, 0);
            } else {
                Assert.assertTrue("go(" + dir + ") should return true. (Maybe the grid was too small.)", cursor.goTo(true, dir));
                testEvents(1, 0);
            }
            p.x += dir.getDx();
            p.y += dir.getDy();
            Assert.assertEquals("Moving cursor.", p, cursor.getLocation());
        }
        Assert.assertEquals("Moving in a circle.", pStart, cursor.getLocation());
    }

    @Test
    public void dragging() {
        final MapGrid grid = new MapGrid(GRID_SIZE);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = createCursor(grid);
        Assert.assertFalse("MapCursor should not drag while deactivated.", cursor.isDragging());
        cursor.dragStart();
        testEvents(0, 1);
        Assert.assertEquals(new Dimension(0, 0), cursor.getDragOffset());
        final Point dragStart = new Point(3, 4);
        final Point p = new Point(dragStart);
        final Dimension offset = new Dimension(0, 0);
        cursor.setLocation(dragStart);
        testEvents(1, 0);
        cursor.dragStart();
        testEvents(0, 0);
        Assert.assertTrue("MapCursor should be in drag mode.", cursor.isDragging());
        Assert.assertEquals("Wrong offset", offset, cursor.getDragOffset());
        cursor.deactivate();
        testEvents(0, 1);
        Assert.assertFalse("MapCursor should not drag while deactivated.", cursor.isDragging());
        Assert.assertNull("Drag offset should be null", cursor.getDragOffset());
        cursor.setLocation(dragStart);
        testEvents(0, 0);
        cursor.dragStart();
        testEvents(0, 1);
        Assert.assertEquals("Wrong offset", offset, cursor.getDragOffset());
        dragTo(cursor, grid, Direction.WEST, dragStart, p, offset);
        dragTo(cursor, grid, Direction.EAST, dragStart, p, offset);
        dragTo(cursor, grid, Direction.EAST, dragStart, p, offset);
        dragTo(cursor, grid, Direction.NORTH_WEST, dragStart, p, offset);
        dragTo(cursor, grid, Direction.SOUTH, dragStart, p, offset);
        dragTo(cursor, grid, Direction.SOUTH, dragStart, p, offset);
        dragTo(cursor, grid, Direction.WEST, dragStart, p, offset);
        dragTo(cursor, grid, Direction.NORTH_EAST, dragStart, p, offset);
    }

    private static void dragTo(@NotNull final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor, @NotNull final MapGrid grid, @NotNull final Direction dir, @NotNull final Point start, @NotNull final Point p, @NotNull final Dimension offset) {
        final Point d = new Point(dir.getDx(), dir.getDy());
        p.x += d.x;
        p.y += d.y;
        Assert.assertTrue("dragTo(" + p + ")", cursor.dragTo(p));
        testEvents(1, 0);
        Assert.assertTrue("MapCursor should be in drag mode.", cursor.isDragging());
        Assert.assertEquals("Wrong position", p, cursor.getLocation());
        offset.width = p.x - start.x;
        offset.height = p.y - start.y;
        Assert.assertEquals("Wrong offset", offset, cursor.getDragOffset());
        assertPreSelection(grid, start, p);
    }

    private static void assertPreSelection(@NotNull final MapGrid grid, @NotNull final Point start, @NotNull final Point end) {
        final int minX = Math.min(start.x, end.x);
        final int maxX = Math.max(start.x, end.x);
        final int minY = Math.min(start.y, end.y);
        final int maxY = Math.max(start.y, end.y);
        final int height = GRID_SIZE.getHeight();
        final int width = GRID_SIZE.getWidth();
        for (int j = 0; j < height; j++) {
            for (int i = 0; i < width; i++) {
                if (i < minX || i > maxX || j < minY || j > maxY) {
                    //Not preselected
                    Assert.assertFalse("Pre-selection", (grid.getFlags(i, j) & MapGrid.GRID_FLAG_SELECTING) > 0);
                } else {
                    //Preselected
                    Assert.assertTrue("Pre-selection", (grid.getFlags(i, j) & MapGrid.GRID_FLAG_SELECTING) > 0);
                }
            }

        }
    }

    private static void assertSelection(@NotNull final MapGrid grid, @NotNull final Point start, @NotNull final Point end, final boolean flag) {
        final int minX = Math.min(start.x, end.x);
        final int maxX = Math.max(start.x, end.x);
        final int minY = Math.min(start.y, end.y);
        final int maxY = Math.max(start.y, end.y);
        for (int j = minY; j <= maxY; j++) {
            for (int i = minX; i <= maxX; i++) {
                Assert.assertSame("Selection", flag, (grid.getFlags(i, j) & MapGrid.GRID_FLAG_SELECTION) > 0);
            }
        }
    }

    @Test
    public void selecting() {
        final MapGrid grid = new MapGrid(GRID_SIZE);
        final MapCursor<TestGameObject, TestMapArchObject, TestArchetype> cursor = createCursor(grid);
        final Point start = new Point(2, 3);
        final Point end = new Point(4, 5);
        final Point gridMaxIndex = new Point(GRID_SIZE.getWidth() - 1, GRID_SIZE.getHeight() - 1);
        cursor.dragRelease();
        testEvents(0, 0);
        cursor.setLocation(start);
        testEvents(1, 0);
        cursor.dragStart();
        testEvents(0, 1);
        cursor.dragTo(end);
        testEvents(1, 0);
        Assert.assertTrue("MapCursor should be in drag mode.", cursor.isDragging());
        cursor.dragRelease();
        testEvents(0, 1);
        Assert.assertFalse("MapCursor should not be in drag mode.", cursor.isDragging());
        cursor.setLocation(start);
        testEvents(1, 0);
        cursor.dragStart();
        testEvents(0, 1);
        cursor.dragTo(end);
        testEvents(1, 0);
        Assert.assertTrue("MapCursor should be in drag mode.", cursor.isDragging());
        cursor.dragRelease();
        testEvents(0, 1);
        Assert.assertFalse("MapCursor should not be in drag mode.", cursor.isDragging());
        cursor.setLocation(start);
        testEvents(1, 0);
        cursor.dragStart();
        testEvents(0, 1);
        cursor.dragTo(end);
        testEvents(1, 0);
        Assert.assertTrue("MapCursor should be in drag mode.", cursor.isDragging());
        assertSelection(grid, new Point(0, 0), gridMaxIndex, false);
        cursor.dragSelect(SelectionMode.ADD, true);
        testEvents(0, 1);
        assertSelection(grid, start, end, true);
        //Check if nothing is preselected
        assertPreSelection(grid, new Point(-1, -1), new Point(-1, -1));
        cursor.setLocation(start);
        testEvents(1, 0);
        cursor.dragStart();
        testEvents(0, 1);
        cursor.dragTo(end);
        testEvents(1, 0);
        cursor.dragSelect(SelectionMode.SUB, true);
        testEvents(0, 1);
        assertSelection(grid, new Point(0, 0), gridMaxIndex, false);
        cursor.setLocation(start);
        testEvents(1, 0);
        cursor.dragStart();
        testEvents(0, 1);
        cursor.dragTo(end);
        testEvents(1, 0);
        cursor.dragSelect(SelectionMode.FLIP, true);
        testEvents(0, 1);
        assertSelection(grid, start, end, true);
        start.setLocation(3, 4);
        end.setLocation(5, 1);
        cursor.setLocation(start);
        testEvents(1, 0);
        cursor.dragStart();
        testEvents(0, 1);
        cursor.dragTo(end);
        testEvents(1, 0);
        cursor.dragSelect(SelectionMode.FLIP, true);
        testEvents(0, 1);
        assertSelection(grid, start, new Point(4, 4), false);
        assertSelection(grid, new Point(3, 2), end, true);
        assertSelection(grid, new Point(5, 3), new Point(5, 4), true);
        cursor.deactivate();
        testEvents(0, 0);
        assertSelection(grid, new Point(0, 0), gridMaxIndex, false);
    }

    private static void testEvents(final int nPos, final int nMode) {
        Assert.assertEquals("Position change event", nPos, LISTENER.changedPosCounter);
        LISTENER.changedPosCounter = 0;
        Assert.assertEquals("Mode change event", nMode, LISTENER.changedModeCounter);
        LISTENER.changedModeCounter = 0;
    }

    @NotNull
    public static junit.framework.Test suite() {
        return new JUnit4TestAdapter(MapCursorTest.class);
    }

    private static class TestMapCursorListener implements MapCursorListener<TestGameObject, TestMapArchObject, TestArchetype> {

        private int changedPosCounter;

        private int changedModeCounter;

        @Override
        public void mapCursorChangedPos(@NotNull final Point location) {
            changedPosCounter++;
        }

        @Override
        public void mapCursorChangedMode() {
            changedModeCounter++;
        }

        @Override
        public void mapCursorChangedGameObject(@Nullable final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare, @Nullable final TestGameObject gameObject) {
            // ignore
        }

        @Override
        public void mapCursorChangedSize() {
            // ignore
        }

    }

}