AbstractGUIMap.java

Go to the documentation of this file.

/*
 * This file is part of JXClient, the Fullscreen Java Crossfire Client.
 *
 * JXClient 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.
 *
 * JXClient 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 JXClient; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 *
 * Copyright (C) 2005-2008 Yann Chachkoff
 * Copyright (C) 2006-2017,2019-2023 Andreas Kirschbaum
 * Copyright (C) 2010-2012,2014-2018,2020-2023 Nicolas Weeger
 */
 
package com.realtime.crossfire.jxclient.gui.map;
 
import com.realtime.crossfire.jxclient.faces.Face;
import com.realtime.crossfire.jxclient.faces.FacesProvider;
import com.realtime.crossfire.jxclient.gui.gui.AbstractGUIElement;
import com.realtime.crossfire.jxclient.gui.gui.GUIElement;
import com.realtime.crossfire.jxclient.gui.gui.GUIElementListener;
import com.realtime.crossfire.jxclient.gui.gui.TooltipManager;
import com.realtime.crossfire.jxclient.map.CfMap;
import com.realtime.crossfire.jxclient.map.CfMapSquare;
import com.realtime.crossfire.jxclient.map.MapListener;
import com.realtime.crossfire.jxclient.map.MapScrollListener;
import com.realtime.crossfire.jxclient.map.MapSizeListener;
import com.realtime.crossfire.jxclient.map.MapUpdaterState;
import com.realtime.crossfire.jxclient.map.NewmapListener;
import com.realtime.crossfire.jxclient.protocol.Map2;
import com.realtime.crossfire.jxclient.skin.skin.GuiFactory;
import com.realtime.crossfire.jxclient.util.MathUtils;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Image;
import java.awt.Transparency;
import java.awt.image.BufferedImage;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import javax.swing.ImageIcon;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
 
public abstract class AbstractGUIMap extends AbstractGUIElement {
 
    private static final long serialVersionUID = 1;
 
    private final boolean avoidCopyArea;
 
    @NotNull
    private final MapUpdaterState mapUpdaterState;
 
    @NotNull
    private final FacesProvider facesProvider;
 
    @Nullable
    private final SmoothingRenderer smoothingRenderer;
 
    @NotNull
    private final DarknessColors darknessColors;
 
    @NotNull
    private final Object bufferedImageSync = new Object();
 
    @Nullable
    private transient BufferedImage bufferedImage;
 
    private boolean clearMapPending = true;
 
    @NotNull
    private final Deque<Long> scrollMapPending = new ArrayDeque<>();
 
    private int mapWidth;
 
    private int mapHeight;
 
    private final int tileSize;
 
    private int playerX;
 
    private int playerY;
 
    private int offsetX;
 
    private int offsetY;
 
    private int displayMinX;
 
    private int displayMaxX;
 
    private int displayMinY;
 
    private int displayMaxY;
 
    private int displayMinOffsetX;
 
    private int displayMaxOffsetX;
 
    private int displayMinOffsetY;
 
    private int displayMaxOffsetY;
 
    @NotNull
    private final Map<Color, Image> images = new HashMap<>();
 
    @NotNull
    private final MapListener mapListener = new MapListener() {
 
        @Override
        public void mapChanged(@NotNull final CfMap map, @NotNull final Set<CfMapSquare> changedSquares) {
            assert Thread.holdsLock(map);
            synchronized (bufferedImageSync) {
                final int x0 = map.getOffsetX();
                final int y0 = map.getOffsetY();
                final Graphics2D g = createBufferGraphics(map);
                try {
                    for (CfMapSquare mapSquare : changedSquares) {
                        final int x = mapSquare.getX()+x0;
                        if (displayMinX <= x && x < displayMaxX) {
                            final int y = mapSquare.getY()+y0;
                            if (displayMinY <= y && y < displayMaxY) {
                                redrawSquare(g, mapSquare, map, x, y);
                            }
                        }
                    }
                    markPlayer(g, 0, 0);
                } finally {
                    g.dispose();
                }
            }
            setChanged();
        }
 
    };
 
    @NotNull
    private final NewmapListener newmapListener = () -> {
        synchronized (bufferedImageSync) {
            clearMapPending = true;
            scrollMapPending.clear();
        }
        setChanged();
    };
 
    private void clearMap(@NotNull final Graphics2D g) {
        g.setColor(DarknessColors.BLACK_AND_FOG_OF_WAR_COLOR);
        g.fillRect(0, 0, getWidth(), getHeight());
    }
 
    @NotNull
    private final MapScrollListener mapscrollListener = (dx, dy) -> {
        synchronized (bufferedImageSync) {
            scrollMapPending.offerLast(((long)dx<<32)|(dy&0xFFFFFFFFL));
        }
        setChanged();
    };
 
    @NotNull
    private final MapSizeListener mapSizeListener = (mapWidth1, mapHeight1) -> {
        setMapSize(mapWidth1, mapHeight1);
        redrawAll();
    };
 
    protected AbstractGUIMap(final boolean avoidCopyArea, @NotNull final TooltipManager tooltipManager, @NotNull final GUIElementListener elementListener, @NotNull final String name, @NotNull final MapUpdaterState mapUpdaterState, @NotNull final FacesProvider facesProvider, @Nullable final SmoothingRenderer smoothingRenderer, @NotNull final DarknessColors darknessColors, @NotNull final GuiFactory guiFactory) {
        super(tooltipManager, elementListener, name, true, guiFactory);
        this.avoidCopyArea = avoidCopyArea;
        this.smoothingRenderer = smoothingRenderer;
        this.darknessColors = darknessColors;
        tileSize = facesProvider.getSize();
        assert tileSize > 0;
        this.mapUpdaterState = mapUpdaterState;
        this.facesProvider = facesProvider;
        this.mapUpdaterState.addMapSizeListener(mapSizeListener);
        this.mapUpdaterState.addCrossfireMapListener(mapListener);
        this.mapUpdaterState.addCrossfireNewmapListener(newmapListener);
        this.mapUpdaterState.addCrossfireMapScrollListener(mapscrollListener);
        setMapSize(this.mapUpdaterState.getMapWidth(), this.mapUpdaterState.getMapHeight());
    }
 
    @Override
    public void dispose() {
        super.dispose();
        mapUpdaterState.removeMapSizeListener(mapSizeListener);
        mapUpdaterState.removeCrossfireNewmapListener(newmapListener);
        mapUpdaterState.removeCrossfireMapScrollListener(mapscrollListener);
        mapUpdaterState.removeCrossfireMapListener(mapListener);
    }
 
    private void redrawAll() {
        final CfMap map = mapUpdaterState.getMap();
        //noinspection SynchronizationOnLocalVariableOrMethodParameter
        synchronized (map) {
            //noinspection NestedSynchronizedStatement
            synchronized (bufferedImageSync) {
                final Graphics g = createBufferGraphics(map);
                try {
                    redrawTiles(g, map, displayMinX, displayMinY, displayMaxX, displayMaxY);
                    markPlayer(g, 0, 0);
                } finally {
                    g.dispose();
                }
            }
        }
    }
 
    private void redrawAllUnlessDirty(@NotNull final Graphics g, @NotNull final CfMap map) {
        synchronized (bufferedImageSync) {
            redrawTilesUnlessDirty(g, map, displayMinX-offsetX/tileSize, displayMinY-offsetY/tileSize, displayMaxX-offsetX/tileSize, displayMaxY-offsetY/tileSize);
        }
    }
 
    private void redrawTiles(@NotNull final Graphics g, @NotNull final CfMap map, final int x0, final int y0, final int x1, final int y1) {
        for (int x = x0; x < x1; x++) {
            for (int y = y0; y < y1; y++) {
                final CfMapSquare mapSquare = map.getMapSquare(x, y);
                redrawSquare(g, mapSquare, map, x, y);
            }
        }
    }
 
    private void redrawTilesUnlessDirty(@NotNull final Graphics g, @NotNull final CfMap map, final int x0, final int y0, final int x1, final int y1) {
        for (int x = x0; x < x1; x++) {
            for (int y = y0; y < y1; y++) {
                redrawSquareUnlessDirty(g, map, x, y);
            }
        }
    }
 
    private void redrawSquareUnlessDirty(@NotNull final Graphics g, @NotNull final CfMap map, final int x, final int y) {
        final CfMapSquare mapSquare = map.getMapSquareUnlessDirty(x, y);
        if (mapSquare != null) {
            redrawSquare(g, mapSquare, map, x, y);
        }
    }
 
    protected void redrawSquare(@NotNull final Graphics g, @NotNull final CfMapSquare mapSquare, @NotNull final CfMap map, final int x, final int y) {
        redrawSquare(g, x, y, mapSquare, map);
        synchronized (bufferedImageSync) {
            if (x < 0 || y < 0 || x >= mapWidth || y >= mapHeight || mapSquare.isFogOfWar()) {
                paintColoredSquare(g, DarknessColors.FOG_OF_WAR_COLOR, offsetX+x*tileSize, offsetY+y*tileSize);
            }
            final int darkness = mapSquare.getDarkness();
            if (darkness < CfMapSquare.DARKNESS_FULL_BRIGHT) {
                paintColoredSquare(g, darknessColors.getDarknessColor(darkness), offsetX+x*tileSize, offsetY+y*tileSize);
            }
        }
    }
 
    private void redrawSquare(@NotNull final Graphics g, final int x, final int y, @NotNull final CfMapSquare mapSquare, @NotNull final CfMap map) {
        final int px;
        final int py;
        synchronized (bufferedImageSync) {
            px = offsetX+x*tileSize;
            py = offsetY+y*tileSize;
        }
        final int mapSquareX = mapSquare.getX();
        final int mapSquareY = mapSquare.getY();
        boolean foundSquare = false;
        for (int layer = 0; layer < Map2.NUM_LAYERS; layer++) {
            final CfMapSquare headMapSquare = mapSquare.getHeadMapSquare(layer);
            if (headMapSquare != null) {
                final Face headFace = headMapSquare.getFace(layer);
                assert headFace != null; // getHeadMapSquare() would have been cleared in this case
                final int dx = headMapSquare.getX()-mapSquareX;
                final int dy = headMapSquare.getY()-mapSquareY;
                assert dx > 0 || dy > 0;
                if (!foundSquare) {
                    foundSquare = true;
                    paintSquareBackground(g, px, py, true, mapSquare);
                }
                paintImage(g, headFace, px, py, tileSize*dx, tileSize*dy);
            }
 
            final Face face = mapSquare.getFace(layer);
            if (face != null) {
                if (!foundSquare) {
                    foundSquare = true;
                    paintSquareBackground(g, px, py, true, mapSquare);
                }
                paintImage(g, face, px, py, 0, 0);
            }
            /* If there is at least one square on a layer, we want to draw smoothing for all layers above it. */
            if (foundSquare && smoothingRenderer != null) {
                smoothingRenderer.paintSmooth(g, x, y, px, py, layer, map, tileSize);
            }
        }
        if (!foundSquare) {
            paintSquareBackground(g, px, py, false, mapSquare);
        }
    }
 
    protected abstract void paintSquareBackground(@NotNull final Graphics g, final int px, final int py, final boolean hasImage, @NotNull final CfMapSquare mapSquare);
 
    private void paintImage(@NotNull final Graphics g, @NotNull final Face face, final int px, final int py, final int offsetX, final int offsetY) {
        final ImageIcon imageIcon = facesProvider.getImageIcon(face.getFaceNum(), null);
        final int sx = imageIcon.getIconWidth()-offsetX;
        final int sy = imageIcon.getIconHeight()-offsetY;
        g.drawImage(imageIcon.getImage(), px, py, px+tileSize, py+tileSize, sx-tileSize, sy-tileSize, sx, sy, null);
    }
 
    protected abstract void markPlayer(@NotNull final Graphics g, final int dx, final int dy);
 
    @Override
    @SuppressWarnings("MethodDoesntCallSuperMethod")
    public void paintComponent(@NotNull final Graphics g) {
        synchronized (bufferedImageSync) {
            g.drawImage(bufferedImage, 0, 0, null);
        }
    }
 
    private void setMapSize(final int mapWidth, final int mapHeight) {
        synchronized (bufferedImageSync) {
            this.mapWidth = mapWidth;
            this.mapHeight = mapHeight;
 
            final int nX = MathUtils.divRoundUp(playerX, tileSize);
            displayMinOffsetX = playerX-nX*tileSize;
            assert -tileSize < displayMinOffsetX && displayMinOffsetX <= 0;
            assert (playerX-displayMinOffsetX)%tileSize == 0;
            displayMinX = (mapWidth-1)/2-nX;
            final int tilesX = MathUtils.divRoundUp(getWidth()-displayMinOffsetX, tileSize);
            displayMaxX = displayMinX+tilesX;
            assert (displayMaxX-displayMinX)*tileSize >= getWidth();
            assert (displayMaxX-displayMinX)*tileSize-getWidth() < 2*tileSize;
            displayMaxOffsetX = MathUtils.mod(-displayMinOffsetX-getWidth(), tileSize);
            offsetX = displayMinOffsetX-displayMinX*tileSize;
 
            final int nY = MathUtils.divRoundUp(playerY, tileSize);
            displayMinOffsetY = playerY-nY*tileSize;
            assert -tileSize < displayMinOffsetY && displayMinOffsetY <= 0;
            assert (playerY-displayMinOffsetY)%tileSize == 0;
            displayMinY = (mapHeight-1)/2-nY;
            final int tilesY = MathUtils.divRoundUp(getHeight()-displayMinOffsetY, tileSize);
            displayMaxY = displayMinY+tilesY;
            assert (displayMaxY-displayMinY)*tileSize >= getHeight();
            assert (displayMaxY-displayMinY)*tileSize-getHeight() < 2*tileSize;
            displayMaxOffsetY = MathUtils.mod(-displayMinOffsetY-getHeight(), tileSize);
            offsetY = displayMinOffsetY-displayMinY*tileSize;
        }
 
        final GraphicsEnvironment graphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
        final GraphicsDevice graphicsDevice = graphicsEnvironment.getDefaultScreenDevice();
        final GraphicsConfiguration graphicsConfiguration = graphicsDevice.getDefaultConfiguration();
        synchronized (bufferedImageSync) {
            bufferedImage = graphicsConfiguration.createCompatibleImage(Math.max(1, getWidth()), Math.max(1, getHeight()), Transparency.TRANSLUCENT);
        }
        redrawAll();
    }
 
    public int getPlayerX() {
        synchronized (bufferedImageSync) {
            return playerX;
        }
    }
 
    public int getPlayerY() {
        synchronized (bufferedImageSync) {
            return playerY;
        }
    }
 
    public int getOffsetX() {
        synchronized (bufferedImageSync) {
            return offsetX;
        }
    }
 
    public int getOffsetY() {
        synchronized (bufferedImageSync) {
            return offsetY;
        }
    }
 
    @Override
    public void setBounds(final int x, final int y, final int width, final int height) {
        super.setBounds(x, y, width, height);
        final int mapWidth;
        final int mapHeight;
        synchronized (bufferedImageSync) {
            playerX = width/2-tileSize/2;
            playerY = height/2-tileSize/2;
            mapWidth = this.mapWidth;
            mapHeight = this.mapHeight;
        }
        setMapSize(mapWidth, mapHeight);
        redrawAll();
    }
 
    private void updateScrolledMap(@NotNull final Graphics g, @NotNull final CfMap map, final int dx, final int dy) {
        if (avoidCopyArea || Math.abs(dx)*tileSize >= getWidth() || Math.abs(dy)*tileSize >= getHeight()) {
            redrawAllUnlessDirty(g, map);
        } else {
            final int x = Math.max(dx, 0);
            final int w = dx > 0 ? -dx : dx;
            final int y = Math.max(dy, 0);
            final int h = dy > 0 ? -dy : dy;
            g.copyArea(x*tileSize, y*tileSize, getWidth()+w*tileSize, getHeight()+h*tileSize, -dx*tileSize, -dy*tileSize);
 
            synchronized (bufferedImageSync) {
                if (dx > 0) {
                    final int ww = (displayMaxOffsetX == 0 ? 0 : 1)+dx;
                    redrawTilesUnlessDirty(g, map, displayMaxX-ww, displayMinY, displayMaxX, displayMaxY);
                } else if (dx < 0) {
                    final int ww = (displayMinOffsetX == 0 ? 0 : 1)-dx;
                    redrawTilesUnlessDirty(g, map, displayMinX, displayMinY, displayMinX+ww, displayMaxY);
                }
                if (dy > 0) {
                    final int hh = (displayMaxOffsetY == 0 ? 0 : 1)+dy;
                    redrawTilesUnlessDirty(g, map, displayMinX, displayMaxY-hh, displayMaxX, displayMaxY);
                } else if (dy < 0) {
                    final int hh = (displayMinOffsetY == 0 ? 0 : 1)-dy;
                    redrawTilesUnlessDirty(g, map, displayMinX, displayMinY, displayMaxX, displayMinY+hh);
                }
            }
        }
    }
 
    protected void paintColoredSquare(@NotNull final Graphics g, @NotNull final Color color, final int x, final int y) {
        Image image = images.get(color);
        if (image == null) {
            final BufferedImage tmp = new BufferedImage(tileSize, tileSize, color.getTransparency() == Transparency.OPAQUE ? BufferedImage.TYPE_INT_RGB : BufferedImage.TYPE_INT_ARGB);
            final Graphics g2 = tmp.createGraphics();
            try {
                g2.setColor(color);
                g2.fillRect(0, 0, tileSize, tileSize);
            } finally {
                g2.dispose();
            }
            image = tmp;
            images.put(color, image);
        }
        g.drawImage(image, x, y, tileSize, tileSize, null);
    }
 
    protected int getMapWidth() {
        synchronized (bufferedImageSync) {
            return mapWidth;
        }
    }
 
    protected int getMapHeight() {
        synchronized (bufferedImageSync) {
            return mapHeight;
        }
    }
 
    @NotNull
    private Graphics2D createBufferGraphics(@NotNull final CfMap map) {
        assert Thread.holdsLock(bufferedImageSync);
        assert bufferedImage != null;
        final Graphics2D graphics = bufferedImage.createGraphics();
        if (clearMapPending) {
            clearMapPending = false;
            clearMap(graphics);
        }
        while (true) {
            final Long scrollMap = scrollMapPending.pollFirst();
            if (scrollMap == null) {
                break;
            }
            final long tmp = scrollMap;
            final int dx = (int)(tmp>>32);
            final int dy = (int)tmp;
            updateScrolledMap(graphics, map, dx, dy);
            markPlayer(graphics, dx, dy);
        }
        return graphics;
    }
 
    @Nullable
    @Override
    @SuppressWarnings("MethodDoesntCallSuperMethod")
    public Dimension getMinimumSize() {
        return new Dimension(tileSize, tileSize);
    }
 
}