AbstractFlatMapRenderer.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.var.crossfire.gui.map.renderer;
 
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Point;
import java.awt.Rectangle;
import java.awt.image.BufferedImage;
import java.util.Collection;
import java.util.HashSet;
import java.util.Set;
import net.sf.gridarta.gui.map.renderer.AbstractMapRenderer;
import net.sf.gridarta.gui.map.renderer.GridMapSquarePainter;
import net.sf.gridarta.model.io.GameObjectParser;
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 net.sf.gridarta.var.crossfire.IGUIConstants;
import net.sf.gridarta.var.crossfire.model.archetype.Archetype;
import net.sf.gridarta.var.crossfire.model.gameobject.GameObject;
import net.sf.gridarta.var.crossfire.model.maparchobject.MapArchObject;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class AbstractFlatMapRenderer extends AbstractMapRenderer<GameObject, MapArchObject, Archetype> {
 
    private static final long serialVersionUID = 1L;
 
    @NotNull
    private final Point borderOffset = new Point();
 
    @NotNull
    private final MapModel<GameObject, MapArchObject, Archetype> mapModel;
 
    @NotNull
    private final GridMapSquarePainter gridMapSquarePainter;
 
    @NotNull
    private Size2D mapSize;
 
    @NotNull
    private final MapGrid mapGrid;
 
    @NotNull
    private final Point tmpPoint = new Point();
 
    @NotNull
    private final MapViewSettings mapViewSettings;
 
    @NotNull
    private final Rectangle tmpRec = new Rectangle();
 
    @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) {
            forceRepaint();
        }
 
        @Override
        public void tileStretchingChanged(final boolean tileStretching) {
            // does not render tile-stretching
        }
 
        @Override
        public void doubleFacesChanged(final boolean doubleFaces) {
            // does not render double faces
        }
 
        @Override
        public void alphaTypeChanged(final int alphaType) {
            // does not render alpha types
        }
 
        @Override
        public void editTypeChanged(final int editType) {
            // changed game objects will be rendered
        }
 
        @Override
        public void autojoinChanged(final boolean autojoin) {
            // does not affect rendering
        }
 
    };
 
    @NotNull
    private final MapModelListener<GameObject, MapArchObject, Archetype> mapModelListener = new MapModelListener<GameObject, MapArchObject, Archetype>() {
 
        @Override
        public void mapSizeChanged(@NotNull final Size2D newSize) {
            // ignore: will trigger an mapGridChanged() callback
        }
 
        @Override
        public void mapSquaresChanged(@NotNull final Set<MapSquare<GameObject, MapArchObject, Archetype>> mapSquares) {
            final Collection<MapSquare<GameObject, MapArchObject, Archetype>> toRepaint = new HashSet<>();
            for (final MapSquare<GameObject, MapArchObject, Archetype> mapSquare : mapSquares) {
                getSquaresToRepaint(mapSquare, toRepaint);
            }
            for (final MapSquare<GameObject, MapArchObject, Archetype> mapSquare : toRepaint) {
                paintSquare(mapSquare);
            }
        }
 
        @Override
        public void mapObjectsChanged(@NotNull final Set<GameObject> gameObjects, @NotNull final Set<GameObject> transientGameObjects) {
            final Collection<MapSquare<GameObject, MapArchObject, Archetype>> toRepaint = new HashSet<>();
            addMapSquares(gameObjects, toRepaint);
            addMapSquares(transientGameObjects, toRepaint);
            for (final MapSquare<GameObject, MapArchObject, Archetype> mapSquare : toRepaint) {
                paintSquare(mapSquare);
            }
        }
 
        private void addMapSquares(@NotNull final Iterable<GameObject> gameObjects, @NotNull final Collection<MapSquare<GameObject, MapArchObject, Archetype>> toRepaint) {
            for (final net.sf.gridarta.model.gameobject.GameObject<GameObject, MapArchObject, Archetype> gameObject : gameObjects) {
                if (!gameObject.isInContainer()) {
                    for (net.sf.gridarta.model.gameobject.GameObject<GameObject, MapArchObject, Archetype> gameObjectPart = gameObject; gameObjectPart != null; gameObjectPart = gameObjectPart.getMultiNext()) {
                        final MapSquare<GameObject, MapArchObject, Archetype> square = gameObjectPart.getMapSquareOptional();
                        if (square != null) {
                            getSquaresToRepaint(square, toRepaint);
                        }
                    }
                }
            }
        }
 
        private void getSquaresToRepaint(@NotNull final MapSquare<GameObject, MapArchObject, Archetype> mapSquare, @NotNull final Collection<MapSquare<GameObject, MapArchObject, Archetype>> toRepaint) {
            if (mapViewSettings.isSmoothing()) {
                final MapArchObject mapArchObject = mapModel.getMapArchObject();
                final Point point = new Point();
                for (int dx = -1; dx <= 1; dx++) {
                    for (int dy = -1; dy <= 1; dy++) {
                        mapSquare.getMapLocation(point, dx, dy);
                        if (mapArchObject.isPointValid(point)) {
                            toRepaint.add(mapModel.getMapSquare(point));
                        }
                    }
                }
            } else {
                toRepaint.add(mapSquare);
            }
        }
 
        @Override
        public void errorsChanged(@NotNull final ErrorCollector<GameObject, MapArchObject, Archetype> 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) {
            final Rectangle recChange = mapGrid.getRecChange();
            updateSquares(recChange);
            repaint(0L, borderOffset.x + recChange.x * IGUIConstants.SQUARE_WIDTH, borderOffset.y + recChange.y * IGUIConstants.SQUARE_HEIGHT, recChange.width * IGUIConstants.SQUARE_WIDTH, recChange.height * IGUIConstants.SQUARE_HEIGHT);
        }
 
        @Override
        public void mapGridResized(@NotNull final MapGridEvent e) {
            resizeMapGrid();
        }
 
    };
 
    protected AbstractFlatMapRenderer(@NotNull final MapViewSettings mapViewSettings, @NotNull final MapModel<GameObject, MapArchObject, Archetype> mapModel, @NotNull final MapGrid mapGrid, final int borderSize, @NotNull final GridMapSquarePainter gridMapSquarePainter, @NotNull final GameObjectParser<GameObject, MapArchObject, Archetype> gameObjectParser) {
        super(mapModel, gameObjectParser);
        this.mapViewSettings = mapViewSettings;
        this.mapModel = mapModel;
        this.gridMapSquarePainter = gridMapSquarePainter;
        mapSize = this.mapModel.getMapArchObject().getMapSize();
        this.mapGrid = mapGrid;
 
        mapViewSettings.addMapViewSettingsListener(mapViewSettingsListener);
 
        setToolTipText("dummy");
        setFocusable(true);
        borderOffset.setLocation(borderSize, borderSize);
    }
 
    protected void init() {
        resizeMapGrid();
        mapModel.addMapModelListener(mapModelListener);
        mapGrid.addMapGridListener(mapGridListener);
    }
 
    @Override
    public void closeNotify() {
        mapModel.removeMapModelListener(mapModelListener);
        mapGrid.removeMapGridListener(mapGridListener);
        mapViewSettings.removeMapViewSettingsListener(mapViewSettingsListener);
    }
 
    @NotNull
    @Override
    public Size2D getImageSize() {
        return new Size2D(IGUIConstants.SQUARE_WIDTH * mapSize.getWidth(), IGUIConstants.SQUARE_HEIGHT * mapSize.getHeight());
    }
 
    @NotNull
    @Override
    public BufferedImage getFullImage() {
        final int viewWidth = IGUIConstants.SQUARE_WIDTH * mapSize.getWidth();
        final int viewHeight = IGUIConstants.SQUARE_HEIGHT * mapSize.getHeight();
 
        // first create a storing place for the image
        final BufferedImage bufImage = new BufferedImage(viewWidth, viewHeight, BufferedImage.TYPE_INT_ARGB);
        final Graphics graphics = bufImage.getGraphics();
        try {
            graphics.setColor(Color.white);
            graphics.fillRect(0, 0, viewWidth, viewHeight);
 
            // paint the map view into the image
            final Point storeOffset = new Point(borderOffset);
            try {
                borderOffset.setLocation(0, 0);
                paintComponent(graphics, true, false);
            } finally {
                borderOffset.setLocation(storeOffset);
            }
        } finally {
            graphics.dispose();
        }
        return bufImage;
    }
 
    @Override
    public abstract void paintComponent(@NotNull Graphics g);
 
    @Override
    public void forceRepaint() {
        updateAll();
        repaint();
    }
 
    @NotNull
    @Override
    public Rectangle getSquareBounds(@NotNull final Point p) {
        tmpRec.x = borderOffset.x + p.x * IGUIConstants.SQUARE_WIDTH;
        tmpRec.y = borderOffset.y + p.y * IGUIConstants.SQUARE_HEIGHT;
        tmpRec.width = IGUIConstants.SQUARE_WIDTH;
        tmpRec.height = IGUIConstants.SQUARE_HEIGHT;
        return tmpRec;
    }
 
    private void paintSquare(@NotNull final MapSquare<GameObject, MapArchObject, Archetype> square) {
        final Point pos = square.getMapLocation();
        updateSquare(pos);
        repaint(0L, borderOffset.x + pos.x * IGUIConstants.SQUARE_WIDTH, borderOffset.y + pos.y * IGUIConstants.SQUARE_HEIGHT, IGUIConstants.SQUARE_WIDTH, IGUIConstants.SQUARE_HEIGHT);
    }
 
    protected void paintComponent(@NotNull final Graphics graphics, final boolean isSnapshot, final boolean checkClip) {
        graphics.setColor(getBackground());
        graphics.fillRect(0, 0, getWidth(), getHeight());
        paintMap(graphics, checkClip);
        if (!isSnapshot) {
            paintMapGrid(graphics);
            paintMapSelection(graphics);
        }
    }
 
    protected void paintSquareGrid(@NotNull final Graphics graphics, @NotNull final Point point) {
        if (mapViewSettings.isGridVisible()) {
            graphics.drawLine(borderOffset.x + point.x * IGUIConstants.SQUARE_WIDTH, borderOffset.y + point.y * IGUIConstants.SQUARE_HEIGHT, borderOffset.x + point.x * IGUIConstants.SQUARE_WIDTH, borderOffset.y + point.y * IGUIConstants.SQUARE_HEIGHT + IGUIConstants.SQUARE_HEIGHT);
            graphics.drawLine(borderOffset.x + point.x * IGUIConstants.SQUARE_WIDTH, borderOffset.y + point.y * IGUIConstants.SQUARE_HEIGHT, borderOffset.x + point.x * IGUIConstants.SQUARE_WIDTH + IGUIConstants.SQUARE_WIDTH, borderOffset.y + point.y * IGUIConstants.SQUARE_HEIGHT);
        }
    }
 
    protected void paintSquareSelection(@NotNull final Graphics graphics, @NotNull final Point point) {
        final int gridFlags = mapGrid.getFlags(point.x, point.y);
        final boolean light = (isLightVisible() ^ mapViewSettings.isLightVisible()) && mapModel.getMapSquare(point).isLight();
        gridMapSquarePainter.paint(graphics, gridFlags, light, borderOffset.x + point.x * IGUIConstants.SQUARE_WIDTH, borderOffset.y + point.y * IGUIConstants.SQUARE_HEIGHT, this);
    }
 
    private void paintMap(@NotNull final Graphics graphics, final boolean checkClip) {
        for (tmpPoint.y = 0; tmpPoint.y < mapGrid.getSize().getHeight(); tmpPoint.y++) {
            final int y = borderOffset.y + tmpPoint.y * IGUIConstants.SQUARE_HEIGHT;
            for (tmpPoint.x = 0; tmpPoint.x < mapGrid.getSize().getWidth(); tmpPoint.x++) {
                final int x = borderOffset.x + tmpPoint.x * IGUIConstants.SQUARE_WIDTH;
                if (!checkClip || graphics.hitClip(x, y, IGUIConstants.SQUARE_WIDTH, IGUIConstants.SQUARE_HEIGHT)) {
                    paintSquare(graphics, x, y, mapModel.getMapSquare(tmpPoint));
                }
            }
        }
    }
 
    private void paintMapSelection(@NotNull final Graphics graphics) {
        for (tmpPoint.y = 0; tmpPoint.y < mapSize.getHeight(); tmpPoint.y++) {
            final int y = borderOffset.y + tmpPoint.y * IGUIConstants.SQUARE_HEIGHT;
            for (tmpPoint.x = 0; tmpPoint.x < mapSize.getWidth(); tmpPoint.x++) {
                final int x = borderOffset.x + tmpPoint.x * IGUIConstants.SQUARE_WIDTH;
                if (graphics.hitClip(x, y, IGUIConstants.SQUARE_WIDTH, IGUIConstants.SQUARE_HEIGHT)) {
                    paintSquareSelection(graphics, tmpPoint);
                }
            }
        }
    }
 
    private void paintMapGrid(@NotNull final Graphics graphics) {
        if (mapViewSettings.isGridVisible()) {
            final Size2D tmpMapSize = mapGrid.getSize();
            final int mapWidth = tmpMapSize.getWidth();
            final int mapHeight = tmpMapSize.getHeight();
            for (int x = 0; x <= mapWidth; x++) {
                graphics.drawLine(borderOffset.x + x * IGUIConstants.SQUARE_WIDTH, borderOffset.y, borderOffset.x + x * IGUIConstants.SQUARE_WIDTH, borderOffset.y + mapHeight * IGUIConstants.SQUARE_HEIGHT);
            }
            for (int y = 0; y <= mapHeight; y++) {
                graphics.drawLine(borderOffset.x, borderOffset.y + y * IGUIConstants.SQUARE_HEIGHT, borderOffset.x + mapWidth * IGUIConstants.SQUARE_WIDTH, borderOffset.y + y * IGUIConstants.SQUARE_HEIGHT);
            }
        }
    }
 
    @Override
    public boolean getSquareLocationAt(@NotNull final Point point, @NotNull final Point retPoint) {
        final int x = point.x - borderOffset.x;
        final int y = point.y - borderOffset.y;
        if (x < 0 || y < 0) {
            return false;
        }
        final int xm = x / IGUIConstants.SQUARE_WIDTH;
        final int ym = y / IGUIConstants.SQUARE_HEIGHT;
        if (xm >= mapSize.getWidth() || ym >= mapSize.getHeight()) {
            return false;
        }
 
        retPoint.setLocation(xm, ym);
        return true;
    }
 
    protected abstract void resizeBackBuffer(@NotNull Dimension size);
 
    protected abstract void paintSquare(@NotNull Graphics g, int x, int y, @NotNull MapSquare<GameObject, MapArchObject, Archetype> square);
 
    private void resizeMapGrid() {
        // define how much drawing space we need for the map
        mapSize = mapGrid.getSize();
        final Dimension forcedSize = new Dimension(mapSize.getWidth() * IGUIConstants.SQUARE_WIDTH + 2 * borderOffset.x, mapSize.getHeight() * IGUIConstants.SQUARE_HEIGHT + 2 * borderOffset.y);
        resizeBackBuffer(forcedSize);
        setPreferredSize(forcedSize);
        setMinimumSize(forcedSize);
        revalidate();
        forceRepaint();
    }
 
    protected abstract void updateSquare(@NotNull Point point);
 
    protected abstract void updateSquares(@NotNull Rectangle rectangle);
 
    protected abstract void updateAll();
 
    protected int getBorderOffsetX() {
        return borderOffset.x;
    }
 
    protected int getBorderOffsetY() {
        return borderOffset.y;
    }
 
}