AbstractIsoMapRenderer.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.gui.map.renderer;

import java.awt.AlphaComposite;
import java.awt.Color;
import java.awt.Composite;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.geom.AffineTransform;
import java.awt.image.BufferedImage;
import java.util.Arrays;
import java.util.Set;
import javax.swing.Icon;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.baseobject.Attributes;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.direction.Direction;
import net.sf.gridarta.model.face.StretchedImageFilter;
import net.sf.gridarta.model.gameobject.DefaultIsoGameObject;
import net.sf.gridarta.model.gameobject.IsoMapSquareInfo;
import net.sf.gridarta.model.gameobject.MultiPositionData;
import net.sf.gridarta.model.io.GameObjectParser;
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.mapmodel.MapFile;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapModelListener;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.model.mapviewsettings.MapViewSettings;
import net.sf.gridarta.model.mapviewsettings.MapViewSettingsListener;
import net.sf.gridarta.model.validation.ErrorCollector;
import net.sf.gridarta.utils.Size2D;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public abstract class AbstractIsoMapRenderer<G extends DefaultIsoGameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends AbstractMapRenderer<G, A, R> {

    private static final long serialVersionUID = 1L;

    @NotNull
    private static final Color BACKGROUND_COLOR = new Color(255, 255, 255, 0);

    private final int spawnPointTypeNo;

    @NotNull
    private final Point borderOffset;

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

    @NotNull
    private final MapModel<G, A, R> mapModel;

    @NotNull
    private Size2D mapSize;

    @NotNull
    private final MapGrid mapGrid;

    @NotNull
    private final Icon unknownSquareIcon;

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

    private final Rectangle tmpRec = new Rectangle();

    @NotNull
    private final MapViewSettings mapViewSettings;

    @NotNull
    private final MultiPositionData multiPositionData;

    @NotNull
    private final IsoMapSquareInfo isoMapSquareInfo;

    @NotNull
    private final GridMapSquarePainter gridMapSquarePainter;

    protected int minYOffset;

    protected int maxYOffset;

    @NotNull
    protected final boolean[] foundSubLayers = new boolean[DefaultIsoGameObject.MAX_SUB_LAYERS];

    @NotNull
    private final MapViewSettingsListener mapViewSettingsListener = new MapViewSettingsListener() {

        @Override
        public void gridVisibleChanged(final boolean gridVisible) {
            forceRepaint();
        }

        @Override
        public void lightVisibleChanged(final boolean lightVisible) {
            forceRepaint();
        }

        @Override
        public void smoothingChanged(final boolean smoothing) {
            // does not render smoothed faces
        }

        @Override
        public void tileStretchingChanged(final boolean tileStretching) {
            resizeFromModel();
            forceRepaint();
        }

        @Override
        public void doubleFacesChanged(final boolean doubleFaces) {
            forceRepaint();
        }

        @Override
        public void alphaTypeChanged(final int alphaType) {
            forceRepaint();
        }

        @Override
        public void editTypeChanged(final int editType) {
            // changed game objects will be rendered
        }

        @Override
        public void autojoinChanged(final boolean autojoin) {
            // ignore
        }

    };

    @NotNull
    private final MapModelListener<G, A, R> mapModelListener = new MapModelListener<G, A, R>() {

        @Override
        public void mapSizeChanged(@NotNull final Size2D newSize) {
            // ignore: will trigger an mapGridChanged() callback
        }

        @Override
        public void mapSquaresChanged(@NotNull final Set<MapSquare<G, A, R>> mapSquares) {
            repaint(); // TODO: only repaint a specific region
        }

        @Override
        public void mapObjectsChanged(@NotNull final Set<G> gameObjects, @NotNull final Set<G> transientGameObjects) {
            if (mapViewSettings.isTileStretching()) {
                boolean resize = false;
                for (final G gameObject : gameObjects) {
                    if (!gameObject.isStretched(true)) {
                        continue;
                    }

                    if (!resize && gameObject.getAttributeInt(DefaultIsoGameObject.LAYER) == 1) {
                        final int yOffset = gameObject.getAttributeInt(DefaultIsoGameObject.Z);

                        if (yOffset > maxYOffset || yOffset < minYOffset) {
                            resize = true;
                        }
                    }

                    final MapSquare<G, A, R> mapSquare = gameObject.getMapSquare();
                    if (mapSquare == null) {
                        continue;
                    }

                    final MapModel<G, A, R> mapModel = mapSquare.getMapModel();
                    final int subLayer = gameObject.getAttributeInt(DefaultIsoGameObject.SUB_LAYER);

                    for (final Direction direction : Direction.values()) {
                        if (direction.getDz() != 0) {
                            continue;
                        }

                        mapSquare.getMapLocation(tmpPoint, direction.getDx(), direction.getDy());
                        final MapSquare<G, A, R> mapSquareAdjacent;
                        try {
                            mapSquareAdjacent = mapModel.getMapSquare(tmpPoint);
                        } catch (final IndexOutOfBoundsException ignored) {
                            continue;
                        }
                        for (final G gameObjectAdjacent : mapSquareAdjacent) {
                            if (!gameObjectAdjacent.isStretched(true)) {
                                continue;
                            }

                            if (gameObjectAdjacent.getAttributeInt(DefaultIsoGameObject.SUB_LAYER) != subLayer) {
                                continue;
                            }

                            gameObjectAdjacent.refreshStretchFactor();
                        }
                    }

                    gameObject.refreshStretchFactor();
                }

                if (resize) {
                    resizeFromModel();
                }
            }

            repaint(); // TODO: only repaint a specific region
        }

        @Override
        public void errorsChanged(@NotNull final ErrorCollector<G, A, R> errors) {
            // ignore
        }

        @Override
        public void mapFileChanged(@Nullable final MapFile oldMapFile) {
            // ignore
        }

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

    };

    @NotNull
    private final MapGridListener mapGridListener = new MapGridListener() {

        @Override
        public void mapGridChanged(@NotNull final MapGridEvent e) {
            repaint();
        }

        @Override
        public void mapGridResized(@NotNull final MapGridEvent e) {
            mapSize = e.getSource().getSize();
            calculateOrigin();
            resizeFromModel();
            repaint();
        }

    };

    protected AbstractIsoMapRenderer(final int spawnPointTypeNo, @NotNull final MapViewSettings mapViewSettings, @NotNull final MapModel<G, A, R> mapModel, @NotNull final MapGrid mapGrid, final int borderOffsetX, final int borderOffsetY, @NotNull final MultiPositionData multiPositionData, @NotNull final IsoMapSquareInfo isoMapSquareInfo, @NotNull final GridMapSquarePainter gridMapSquarePainter, @NotNull final GameObjectParser<G, A, R> gameObjectParser, @NotNull final Icon unknownSquareIcon) {
        super(mapModel, gameObjectParser);
        this.spawnPointTypeNo = spawnPointTypeNo;
        this.mapViewSettings = mapViewSettings;
        this.multiPositionData = multiPositionData;
        this.isoMapSquareInfo = isoMapSquareInfo;
        this.gridMapSquarePainter = gridMapSquarePainter;
        borderOffset = new Point(borderOffsetX, borderOffsetY);
        this.mapModel = mapModel;
        mapSize = this.mapModel.getMapArchObject().getMapSize();
        this.mapGrid = mapGrid;
        this.unknownSquareIcon = unknownSquareIcon;

        mapViewSettings.addMapViewSettingsListener(mapViewSettingsListener);

        setToolTipText("dummy");
        setFocusable(true);
        calculateOrigin();
        resizeFromModel();
        mapModel.addMapModelListener(mapModelListener);
        mapGrid.addMapGridListener(mapGridListener);
    }

    @Override
    public void closeNotify() {
        mapModel.removeMapModelListener(mapModelListener);
        mapGrid.removeMapGridListener(mapGridListener);
        mapViewSettings.removeMapViewSettingsListener(mapViewSettingsListener);
    }

    private void calculateOrigin() {
        origin.setLocation(borderOffset.x + mapSize.getHeight() * isoMapSquareInfo.getXLen2(), borderOffset.y + maxYOffset);
    }

    private void setBorderOffset(final int x, final int y) {
        borderOffset.setLocation(x, y);
        calculateOrigin();
    }

    @NotNull
    @Override
    public BufferedImage getFullImage() {
        // set map dimensions for iso view
        final int mapWidth = mapSize.getWidth();
        final int mapHeight = mapSize.getHeight();
        final int sum = mapWidth + mapHeight;
        final int viewWidth = sum * isoMapSquareInfo.getXLen2();
        final int viewHeight = sum * isoMapSquareInfo.getYLen2();

        // first create a storing place for the image
        final BufferedImage image = new BufferedImage(viewWidth, viewHeight, BufferedImage.TYPE_INT_ARGB);
        final Graphics2D graphics = image.createGraphics();
        graphics.setColor(BACKGROUND_COLOR);
        graphics.fillRect(0, 0, viewWidth, viewHeight);

        // paint the map view into the image
        final Point storeOffset = new Point(borderOffset);
        setBorderOffset(0, 0);

        clearBackground(graphics);
        final Point pos = new Point();
        for (pos.y = 0; pos.y < mapHeight; pos.y++) {
            int xStart = origin.x - (pos.y + 1) * isoMapSquareInfo.getXLen2();
            int yStart = origin.y + pos.y * isoMapSquareInfo.getYLen2();
            for (pos.x = 0; pos.x < mapWidth; pos.x++) {
                paintSquare(graphics, xStart, yStart, mapModel.getMapSquare(pos));
                xStart += isoMapSquareInfo.getXLen2();
                yStart += isoMapSquareInfo.getYLen2();
            }
        }

        paintMapGrid(graphics);
        paintMapSelection(graphics);

        setBorderOffset(storeOffset.x, storeOffset.y);
        return image;
    }

    @Override
    public void paintComponent(@NotNull final Graphics g) {
        paintComponent2((Graphics2D) g);
    }

    @Override
    public void forceRepaint() {
        repaint();
    }

    @NotNull
    @Override
    public Rectangle getSquareBounds(@NotNull final Point p) {
        tmpRec.x = origin.x - (p.y + 1) * isoMapSquareInfo.getXLen2() + p.x * isoMapSquareInfo.getXLen2();
        tmpRec.y = origin.y + p.y * isoMapSquareInfo.getYLen2() + p.x * isoMapSquareInfo.getYLen2();
        tmpRec.width = isoMapSquareInfo.getXLen();
        tmpRec.height = isoMapSquareInfo.getYLen();
        return tmpRec;
    }

    protected abstract void clearBackground(@NotNull Graphics g);

    protected abstract void paintSquare(@NotNull Graphics2D g, int x, int y, @NotNull MapSquare<G, A, R> square);

    private void paintComponent2(@NotNull final Graphics2D g) {
        clearBackground(g);
        final Rectangle rec = getRepaintRec(getVisibleRect());
        final Point pos = new Point();
        final Point endPos = rec.getLocation();
        endPos.translate(rec.width, rec.height);
        for (pos.y = rec.y; pos.y < endPos.y; pos.y++) {
            int xStart = origin.x - (pos.y - rec.x + 1) * isoMapSquareInfo.getXLen2();
            int yStart = origin.y + (pos.y + rec.x) * isoMapSquareInfo.getYLen2();
            for (pos.x = rec.x; pos.x < endPos.x; pos.x++) {
                if (g.hitClip(xStart, yStart - isoMapSquareInfo.getYLen() * 4 - minYOffset, isoMapSquareInfo.getXLen(), isoMapSquareInfo.getYLen() * 5 + maxYOffset)) {
                    paintSquare(g, xStart, yStart, mapModel.getMapSquare(pos));
                }
                xStart += isoMapSquareInfo.getXLen2();
                yStart += isoMapSquareInfo.getYLen2();
            }
        }

        paintMapGrid(g);
        paintMapSelection(g);
    }

    private Rectangle getRepaintRec(@NotNull final Rectangle visibleRectangle) {
        // This Rectangle will be returned
        final Rectangle rec = new Rectangle();
        // Upper left corner of viewport
        final Point posUL = visibleRectangle.getLocation();
        // Dimension of viewport
        final Dimension visDim = visibleRectangle.getSize();
        // Other positions of viewport corners
        final Point posUR = new Point(posUL.x + visDim.width, posUL.y);
        final Point posDL = new Point(posUL.x, posUL.y + visDim.height);
        final Point posDR = new Point(posUR.x, posDL.y);
        // Calculate map positions of corners and from them properties of Rectangle
        rec.x = getSquareLocationAt(posUL, tmpPoint) ? tmpPoint.x : 0;
        rec.y = getSquareLocationAt(posUR, tmpPoint) ? tmpPoint.y : 0;
        rec.height = getSquareLocationAt(posDL, tmpPoint) ? tmpPoint.y - rec.y + 1 : mapSize.getHeight() - rec.y;
        rec.width = getSquareLocationAt(posDR, tmpPoint) ? tmpPoint.x - rec.x + 1 : mapSize.getWidth() - rec.x;
        return rec;
    }

    protected abstract boolean isGameObjectVisible(@NotNull G gameObject);

    protected void paintGameObjectIfVisible(@NotNull final Graphics2D g, final int xStart, final int yStart, @NotNull final G gameObject) {
        final G head = gameObject.getHead();
        if (isGameObjectVisible(head)) {
            paintGameObject(g, xStart, yStart, gameObject, false);
        }
    }

    private void paintGameObject(@NotNull final Graphics2D g, final int xStart, final int yStart, @NotNull final G gameObject, final boolean inSpawnPoint) {
        final G head = gameObject.getHead();
        final Icon icon;
        if ("trans.101".equals(head.getFaceObjName())) {
            icon = unknownSquareIcon;
        } else {
            final boolean drawDouble = head.isDrawDouble(mapViewSettings.isDoubleFaces());
            final boolean isStretched = head.isStretched(mapViewSettings.isTileStretching());
            if (mapViewSettings.isAlphaType(head.getEditType())) {
                if (drawDouble) {
                    icon = head.getTransparentDoubleImage();
                } else {
                    icon = head.getTransparentImage();
                }
            } else {
                final long stretchFactor;
                if (isStretched && (stretchFactor = head.getStretchFactor()) != 0) {
                    icon = head.getStretchedImage(stretchFactor);
                } else if (drawDouble) {
                    icon = head.getDoubleImage();
                } else {
                    icon = head.getNormalImage();
                }
            }
        }
        final int xOffset = head.getAttributeInt(DefaultIsoGameObject.ALIGN);
        final int yOffset = head.getYOffset();
        final int zoom = head.getAttributeInt(DefaultIsoGameObject.ZOOM);
        final double rotate = getRotate(head);
        final int alpha = head.getAttributeInt(DefaultIsoGameObject.ALPHA);
        final int tmpIconWidth;
        final int tmpIconHeight;
        if (zoom == 0 || zoom == 100) {
            tmpIconWidth = icon.getIconWidth();
            tmpIconHeight = icon.getIconHeight();
        } else {
            tmpIconWidth = (icon.getIconWidth() * zoom + 50) / 100;
            tmpIconHeight = (icon.getIconHeight() * zoom + 50) / 100;
        }
        final int iconWidth;
        final int iconHeight;
        if (rotate < 0.001) {
            iconWidth = tmpIconWidth;
            iconHeight = tmpIconHeight;
        } else {
            iconWidth = (int) (Math.abs(Math.cos(rotate) * tmpIconWidth) + 0.5) + (int) (Math.abs(Math.sin(rotate) * tmpIconHeight) + 0.5);
            iconHeight = (int) (Math.abs(Math.sin(rotate) * tmpIconWidth) + 0.5) + (int) (Math.abs(Math.cos(rotate) * tmpIconHeight) + 0.5);
        }
        if (head.getMultiRefCount() > 0) {
            final R archetype = gameObject.getArchetype();
            if (inSpawnPoint || archetype.isLowestPart()) {
                final int headMultiShapeID = head.getArchetype().getMultiShapeID();
                final int multiPartNr = archetype.getMultiPartNr();
                final int x = xStart - multiPositionData.getXOffset(headMultiShapeID, multiPartNr) + multiPositionData.getWidth(headMultiShapeID) / 2 - iconWidth / 2;
                final int y = yStart - multiPositionData.getYOffset(headMultiShapeID, multiPartNr) + isoMapSquareInfo.getYLen() - iconHeight;
                paintScaledIcon(g, icon, x + xOffset, y - yOffset, zoom, alpha, rotate, tmpIconWidth, tmpIconHeight, iconWidth, iconHeight);
            }
        } else {
            final int x;
            if (iconWidth > isoMapSquareInfo.getXLen()) {
                x = xStart + isoMapSquareInfo.getXLen2() - iconWidth / 2;
            } else {
                x = xStart;
            }
            final int y = yStart + isoMapSquareInfo.getYLen() - iconHeight;
            paintScaledIcon(g, icon, x + xOffset, y - yOffset, zoom, alpha, rotate, tmpIconWidth, tmpIconHeight, iconWidth, iconHeight);
        }

        // Paint first object (most likely a mob) in spawn points.
        if (!inSpawnPoint && isSpawnPoint(head)) {
            final G mob = head.getFirst();
            if (mob != null) {
                paintGameObject(g, xStart, yStart, mob, true);
            }
        }
    }

    private static double getRotate(@NotNull final Attributes head) {
        final int rotate = -head.getAttributeInt(DefaultIsoGameObject.ROTATE) % 360;
        return (rotate < 0 ? rotate + 360 : rotate) * 2 * Math.PI / 360;
    }

    private void paintScaledIcon(@NotNull final Graphics2D g, @NotNull final Icon icon, final int x, final int y, final int zoom, final int alpha, final double rotate, final int oldIconWidth, final int oldIconHeight, final int newIconWidth, final int newIconHeight) {
        if (zoom <= 0 || zoom == 100) {
            paintAlphaIcon(g, icon, x, y, alpha, rotate, oldIconWidth, oldIconHeight, newIconWidth, newIconHeight);
        } else {
            final AffineTransform savedTransform = g.getTransform();
            try {
                g.translate(x, y);
                g.scale(zoom / 100.0, zoom / 100.0);
                paintAlphaIcon(g, icon, 0, 0, alpha, rotate, oldIconWidth, oldIconHeight, newIconWidth, newIconHeight);
            } finally {
                g.setTransform(savedTransform);
            }
        }
    }

    private void paintAlphaIcon(@NotNull final Graphics2D g, @NotNull final Icon icon, final int x, final int y, final int alpha, final double rotate, final int oldIconWidth, final int oldIconHeight, final int newIconWidth, final int newIconHeight) {
        if (alpha <= 0 || alpha >= 255) {
            paintRotatedIcon(g, icon, x, y, rotate, oldIconWidth, oldIconHeight, newIconWidth, newIconHeight);
        } else {
            final Composite savedComposite = g.getComposite();
            try {
                g.setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, alpha / 255.0F));
                paintRotatedIcon(g, icon, x, y, rotate, oldIconWidth, oldIconHeight, newIconWidth, newIconHeight);
            } finally {
                g.setComposite(savedComposite);
            }
        }
    }

    private void paintRotatedIcon(@NotNull final Graphics2D g, @NotNull final Icon icon, final int x, final int y, final double rotate, final int oldIconWidth, final int oldIconHeight, final int newIconWidth, final int newIconHeight) {
        if (rotate < 0.001) {
            g.translate(x, y);
            try {
                paintIcon(g, icon);
            } finally {
                g.translate(-x, -y);
            }
        } else {
            final AffineTransform savedTransform = g.getTransform();
            try {
                g.translate(x + newIconWidth / 2, y + newIconHeight / 2);
                g.rotate(rotate);
                g.translate(-oldIconWidth / 2, -oldIconHeight / 2);
                paintIcon(g, icon);
            } finally {
                g.setTransform(savedTransform);
            }
        }
    }

    protected void paintIcon(@NotNull final Graphics2D g, @NotNull final Icon icon) {
        icon.paintIcon(this, g, 0, 0);
    }

    private boolean isSpawnPoint(@NotNull final BaseObject<G, A, R, ?> gameObject) {
        return gameObject.getTypeNo() == spawnPointTypeNo;
    }

    private void paintMapSelection(@NotNull final Graphics g) {
        final boolean lightVisible = isLightVisible() ^ mapViewSettings.isLightVisible();
        final Point point = new Point();
        for (int y = 0; y < mapSize.getHeight(); y++) {
            int xStart = origin.x - (y + 1) * isoMapSquareInfo.getXLen2();
            int yStart = origin.y + y * isoMapSquareInfo.getYLen2();
            point.y = y;
            for (int x = 0; x < mapSize.getWidth(); x++) {
                point.x = x;
                final int[] offsets = tileStretchingOffsets(point, foundSubLayers);

                for (int subLayer = 0; subLayer < offsets.length; subLayer++) {
                    if (!foundSubLayers[subLayer]) {
                        continue;
                    }
                    final int yStart2 = yStart + offsets[subLayer];
                    if (g.hitClip(xStart, yStart2, isoMapSquareInfo.getXLen(), isoMapSquareInfo.getYLen())) {
                        final int gridFlags = mapGrid.getFlags(x, y);
                        final boolean light = lightVisible && mapModel.getMapSquare(point).isLight();
                        gridMapSquarePainter.paint(g, gridFlags, light, xStart, yStart2, this);
                    } else {
                        /* DO NOTHING if outside clip region.
                         * DO NOT use continue. xStart and yStart are recalculated at the end of the loop.
                         */
                    }
                }
                xStart += isoMapSquareInfo.getXLen2();
                yStart += isoMapSquareInfo.getYLen2();
            }
        }
    }

    private void paintMapGrid(@NotNull final Graphics g) {
        if (mapViewSettings.isGridVisible()) {
            // draw iso grid
            g.setColor(Color.black);

            final int mapWidth = mapSize.getWidth();
            final int mapHeight = mapSize.getHeight();
            for (int x = 0; x <= mapWidth; x++) {
                g.drawLine(origin.x + x * isoMapSquareInfo.getXLen2() - 1, origin.y + x * isoMapSquareInfo.getYLen2() - 1, origin.x - (mapHeight - x) * isoMapSquareInfo.getXLen2() - 1, origin.y + (mapHeight + x) * isoMapSquareInfo.getYLen2() - 1);
            }
            for (int y = 0; y <= mapHeight; y++) {
                g.drawLine(origin.x - y * isoMapSquareInfo.getXLen2() - 1, origin.y + y * isoMapSquareInfo.getYLen2() - 1, origin.x + (mapWidth - y) * isoMapSquareInfo.getXLen2() - 1, origin.y + (mapWidth + y) * isoMapSquareInfo.getYLen2() - 1);
            }
        }
    }

    protected int[] tileStretchingOffsets(@NotNull final Point point, final boolean[] foundSubLayers) {
        Arrays.fill(foundSubLayers, false);

        final int[] offsets = new int[DefaultIsoGameObject.MAX_SUB_LAYERS];
        boolean foundAny = false;
        if (mapViewSettings.isTileStretching()) {
            for (final G gameObject : mapModel.getMapSquare(point)) {
                final G head = gameObject.getHead();
                if (head.isStretched(true) && head.getAttributeInt(DefaultIsoGameObject.LAYER) == 1) {
                    final int yOffset = head.getAttributeInt(DefaultIsoGameObject.Z);
                    final int subLayer = head.getAttributeInt(DefaultIsoGameObject.SUB_LAYER);
                    if (yOffset > offsets[subLayer]) {
                        offsets[subLayer] = yOffset;
                    }
                    foundSubLayers[subLayer] = true;
                    foundAny = true;
                }
            }
        }

        if (!foundAny) {
            foundSubLayers[0] = true;
        }

        for (int subLayer = 0; subLayer < offsets.length; subLayer++) {
            offsets[subLayer] = maxYOffset - offsets[subLayer];
        }

        return offsets;
    }

    @Override
    public boolean getSquareLocationAt(@NotNull final Point point, @NotNull final Point retPoint) {
        if (maxYOffset == 0 && minYOffset == 0) {
            final int x0 = point.x - origin.x;
            final int y0 = point.y - origin.y;
            final int yt = (2 * y0 - x0) / 2;
            final int xt = yt + x0;
            final int xm = xt / isoMapSquareInfo.getXLen2();
            final int ym = yt / isoMapSquareInfo.getYLen2() / 2;
            if (xm < 0 || xm >= mapSize.getWidth() || ym < 0 || ym >= mapSize.getHeight()) {
                return false;
            }

            retPoint.setLocation(xm, ym);
            return true;
        }

        assert mapViewSettings.isTileStretching();

        boolean retval = false;
        for (int y = 0; y < mapSize.getHeight(); y++) {
            int xStart = origin.x - (y + 1) * isoMapSquareInfo.getXLen2();
            int yStart = origin.y + y * isoMapSquareInfo.getYLen2();
            for (int x = 0; x < mapSize.getWidth(); x++) {
                tmpPoint.setLocation(x, y);
                final int[] offsets = tileStretchingOffsets(tmpPoint, foundSubLayers);

                for (int subLayer = 0; subLayer < offsets.length; subLayer++) {
                    if (!foundSubLayers[subLayer]) {
                        continue;
                    }
                    final int yPos = yStart + offsets[subLayer];
                    long stretch = 0;

                    for (final G gameObject : mapModel.getMapSquare(tmpPoint)) {
                        final G head = gameObject.getHead();
                        if (head.isStretched(true) && head.getAttributeInt(DefaultIsoGameObject.LAYER) == 1 && head.getAttributeInt(DefaultIsoGameObject.SUB_LAYER) == subLayer) {
                            stretch = head.getStretchFactor();
                            break;
                        }
                    }

                    if (point.x >= xStart && point.x <= xStart + isoMapSquareInfo.getXLen() && point.y >= yPos && point.y <= yPos + isoMapSquareInfo.getYLen() + ((stretch >> 24) & 0xff)) {
                        if (StretchedImageFilter.coordsInTile(stretch, point.x - xStart, point.y - yPos)) {
                            retPoint.setLocation(tmpPoint);
                            retval = true;
                        }
                    }
                }

                xStart += isoMapSquareInfo.getXLen2();
                yStart += isoMapSquareInfo.getYLen2();
            }
        }

        return retval;
    }

    private void resizeFromModel() {
        final Point pos = new Point();
        final int mapWidth = mapSize.getWidth();
        final int mapHeight = mapSize.getHeight();
        minYOffset = 0;
        maxYOffset = 0;
        if (mapViewSettings.isTileStretching()) {
            for (pos.y = 0; pos.y < mapHeight; pos.y++) {
                for (pos.x = 0; pos.x < mapWidth; pos.x++) {
                    for (final G gameObject : mapModel.getMapSquare(pos)) {
                        final G head = gameObject.getHead();
                        if (head.isStretched(true) && head.getAttributeInt(DefaultIsoGameObject.LAYER) == 1) {
                            final int yOffset = head.getAttributeInt(DefaultIsoGameObject.Z);

                            if (yOffset > maxYOffset) {
                                maxYOffset = yOffset;
                            } else if (yOffset < minYOffset) {
                                minYOffset = yOffset;
                            }
                        }
                    }
                }
            }
        }
        // define how much drawing space we need for the map
        final int sum = mapWidth + mapHeight;
        final Dimension forcedSize = new Dimension(2 * borderOffset.x + sum * isoMapSquareInfo.getXLen2(), 2 * borderOffset.y + sum * isoMapSquareInfo.getYLen2() + maxYOffset + Math.abs(minYOffset));
        setPreferredSize(forcedSize);
        setMinimumSize(forcedSize);
        revalidate();
    }

}