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-2011 Andreas Kirschbaum.
 */

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

    @SuppressWarnings("JavaDoc")
    private int displayMaxOffsetX;

    private int displayMinOffsetY;

    @SuppressWarnings("JavaDoc")
    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 (final 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(Color.BLACK);
        g.fillRect(0, 0, getWidth(), getHeight());
        g.setColor(DarknessColors.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) {
        super(tooltipManager, elementListener, name, Transparency.TRANSLUCENT);
        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) {
        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 int mapSquareX = x-offsetX/tileSize;
                final int mapSquareY = y-offsetY/tileSize;
                final CfMapSquare mapSquare = map.getMapSquare(mapSquareX, mapSquareY);
                redrawSquare(g, mapSquare, map, mapSquareX, mapSquareY);
            }
        }
    }

    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);
        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 = offsetX+x*tileSize;
        final int 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 (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
    public void paintComponent(@NotNull final Graphics g) {
        super.paintComponent(g);
        synchronized (bufferedImageSync) {
            g.drawImage(bufferedImage, 0, 0, null);
        }
    }

    private void setMapSize(final int mapWidth, final int mapHeight) {
        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();
        bufferedImage = graphicsConfiguration.createCompatibleImage(Math.max(1, getWidth()), Math.max(1, getHeight()), Transparency.TRANSLUCENT);
        redrawAll();
    }

    public int getPlayerX() {
        return playerX;
    }

    public int getPlayerY() {
        return playerY;
    }

    public int getOffsetX() {
        return offsetX;
    }

    public int getOffsetY() {
        return offsetY;
    }

    @Override
    public void setBounds(final int x, final int y, final int width, final int height) {
        super.setBounds(x, y, width, height);
        playerX = width/2-tileSize/2;
        playerY = height/2-tileSize/2;
        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 = dx > 0 ? dx : 0;
            final int w = dx > 0 ? -dx : dx;
            final int y = dy > 0 ? 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);

            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() {
        return mapWidth;
    }

    protected int getMapHeight() {
        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
    public Dimension getMinimumSize() {
        return new Dimension(tileSize, tileSize);
    }

}