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

import com.realtime.crossfire.jxclient.faces.Face;
import com.realtime.crossfire.jxclient.protocol.MagicMap;
import com.realtime.crossfire.jxclient.protocol.Map2;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;

public class CfMap {

    private int minX;

    private int maxX = -1;

    private int minY;

    private int maxY = -1;

    private int minPx;

    private int maxPx = -1;

    private int minPy;

    private int maxPy = -1;

    private int ox;

    private int oy;

    private int patchX;

    private int patchY;

    @Nullable
    private CfMapPatch[][] patch;

    @NotNull
    private final Set<CfMapSquare> dirtyMapSquares = new HashSet<>();

    @NotNull
    private final Map<Integer, Collection<CfMapSquare>> pendingFaceSquares = new HashMap<>();

    public void reset(final int mapWidth, final int mapHeight) {
        minX = 0;
        maxX = -1;
        minY = 0;
        maxY = -1;
        minPx = 0;
        maxPx = -1;
        minPy = 0;
        maxPy = -1;
        patchX = 0;
        patchY = 0;
        patch = null;
        dirtyMapSquares.clear();
        pendingFaceSquares.clear();

        // force dirty flags to be set for the visible map region
        clearSquare(0, 0);
        clearSquare(mapWidth-1, mapHeight-1);
    }

    public void setDarkness(final int x, final int y, final int darkness) {
        assert Thread.holdsLock(this);
        if (expandTo(x, y).setDarkness(ox, oy, darkness)) {
            for (int l = 0; l < Map2.NUM_LAYERS; l++) {
                setFaceInternal(x, y, l, CfMapSquare.DEFAULT_FACE);
            }
        }
    }

    public int getDarkness(final int x, final int y) {
        assert Thread.holdsLock(this);
        final CfMapPatch mapPatch = getMapPatch(x, y);
        return mapPatch == null ? CfMapSquare.DEFAULT_DARKNESS : mapPatch.getDarkness(ox, oy);
    }

    public void setSmooth(final int x, final int y, final int layer, final int smooth) {
        final int result = expandTo(x, y).setSmooth(ox, oy, layer, smooth);
        if ((result&1) != 0) {
            for (int l = 0; l < Map2.NUM_LAYERS; l++) {
                setFaceInternal(x, y, l, CfMapSquare.DEFAULT_FACE);
            }
        }
        if ((result&2) != 0) {
            for (int dx = -1; dx <= +1; dx++) {
                for (int dy = -1; dy <= +1; dy++) {
                    squareModified(getMapSquare(x+dx, y+dy));
                }
            }
        }
    }

    public int getSmooth(final int x, final int y, final int layer) {
        final CfMapPatch mapPatch = getMapPatch(x, y);
        final int result = mapPatch == null ? CfMapSquare.DEFAULT_SMOOTH : mapPatch.getSmooth(ox, oy, layer);
        return result;
    }

    public void setMagicMap(final int x0, final int y0, final byte[][] data) {
        assert Thread.holdsLock(this);
        for (int y = 0; y < data.length; y++) {
            for (int x = 0; x < data[y].length; x++) {
                final int color = data[y][x]&MagicMap.FACE_COLOR_MASK;
                if (expandTo(x0+x, y0+y).setColor(ox, oy, color)) {
                    for (int l = 0; l < Map2.NUM_LAYERS; l++) {
                        setFaceInternal(x, y, l, CfMapSquare.DEFAULT_FACE);
                    }
                }
            }
        }
    }

    public int getColor(final int x, final int y) {
        assert Thread.holdsLock(this);
        final CfMapPatch mapPatch = getMapPatch(x, y);
        return mapPatch == null ? CfMapSquare.DEFAULT_COLOR : mapPatch.getColor(ox, oy);
    }

    public void setFace(final int x, final int y, final int layer, @Nullable final Face face) {
        assert Thread.holdsLock(this);
        if (expandTo(x, y).resetFogOfWar(ox, oy)) {
            setDarkness(x, y, CfMapSquare.DEFAULT_DARKNESS);
            for (int l = 0; l < Map2.NUM_LAYERS; l++) {
                setFaceInternal(x, y, l, l == layer ? face : CfMapSquare.DEFAULT_FACE);
            }
            dirty(x, y);
        } else {
            setFaceInternal(x, y, layer, face);
        }
    }

    private void setFaceInternal(final int x, final int y, final int layer, @Nullable final Face face) {
        final CfMapSquare headMapSquare = expandTo(x, y).getSquare(ox, oy);

        final Face oldFace = headMapSquare.getFace(layer);
        if (oldFace != null) {
            expandFace(x, y, layer, oldFace, headMapSquare, null);
        }
        headMapSquare.setFace(layer, face);
        if (face != null) {
            expandFace(x, y, layer, face, headMapSquare, headMapSquare);
        }
    }

    private void expandFace(final int x, final int y, final int layer, @NotNull final Face face, @NotNull final CfMapSquare oldMapSquare, @Nullable final CfMapSquare newMapSquare) {
        final int sx = face.getTileWidth();
        final int sy = face.getTileHeight();
        for (int dx = 0; dx < sx; dx++) {
            for (int dy = 0; dy < sy; dy++) {
                if (dx > 0 || dy > 0) {
                    if (newMapSquare != null) {
                        setHeadMapSquare(x-dx, y-dy, layer, newMapSquare, true);
                    } else if (getHeadMapSquare(x-dx, y-dy, layer) == oldMapSquare) {
                        setHeadMapSquare(x-dx, y-dy, layer, null, true);
                    }
                }
            }
        }
    }

    private void dirtyFace(final int x, final int y, final int layer, @NotNull final Face face) {
        final int sx = face.getTileWidth();
        final int sy = face.getTileHeight();
        for (int dx = 0; dx < sx; dx++) {
            for (int dy = 0; dy < sy; dy++) {
                if (dx > 0 || dy > 0) {
                    if (isFogOfWar(x-dx, y-dy)) {
                        dirty(x-dx, y-dy);
                    } else {
                        setHeadMapSquare(x-dx, y-dy, layer, null, false);
                    }
                }
            }
        }
    }

    @Nullable
    public Face getFace(final int x, final int y, final int layer) {
        assert Thread.holdsLock(this);
        final CfMapPatch mapPatch = getMapPatch(x, y);
        return mapPatch == null ? CfMapSquare.DEFAULT_FACE : mapPatch.getFace(ox, oy, layer);
    }

    private void setHeadMapSquare(final int x, final int y, final int layer, @Nullable final CfMapSquare mapSquare, final boolean setAlways) {
        expandTo(x, y).setHeadMapSquare(ox, oy, layer, mapSquare, setAlways);
    }

    @Nullable
    public CfMapSquare getHeadMapSquare(final int x, final int y, final int layer) {
        assert Thread.holdsLock(this);
        final CfMapPatch mapPatch = getMapPatch(x, y);
        return mapPatch == null ? null : mapPatch.getHeadMapSquare(ox, oy, layer);
    }

    public void clearSquare(final int x, final int y) {
        assert Thread.holdsLock(this);
        final CfMapPatch mapPatch = expandTo(x, y);
        mapPatch.clearSquare(ox, oy);
        for (int layer = 0; layer < Map2.NUM_LAYERS; layer++) {
            final Face face = mapPatch.getFace(ox, oy, layer);
            if (face != null) {
                dirtyFace(x, y, layer, face);
            }
        }
    }

    public void dirty(final int x, final int y) {
        assert Thread.holdsLock(this);
        expandTo(x, y).dirty(ox, oy);
    }

    public boolean isFogOfWar(final int x, final int y) {
        assert Thread.holdsLock(this);
        final CfMapPatch mapPatch = getMapPatch(x, y);
        return mapPatch != null && mapPatch.isFogOfWar(ox, oy);
    }

    @Nullable
    private CfMapPatch getMapPatch(final int x, final int y) {
        if (x < minX || x > maxX || y < minY || y > maxY) {
            return null;
        }

        final int px = ((x-patchX)>>CfMapPatch.SIZE_LOG)-minPx;
        final int py = ((y-patchY)>>CfMapPatch.SIZE_LOG)-minPy;
        assert px >= 0;
        assert py >= 0;
        assert px <= maxPx-minPx;
        assert py <= maxPy-minPy;
        ox = (x-patchX)&(CfMapPatch.SIZE-1);
        oy = (y-patchY)&(CfMapPatch.SIZE-1);
        assert ox >= 0;
        assert oy >= 0;
        assert ox < CfMapPatch.SIZE;
        assert oy < CfMapPatch.SIZE;

        assert patch != null;
        assert patch[px] != null;
        final CfMapPatch mapPatch = patch[px][py];
        if (mapPatch != null) {
            return mapPatch;
        }

        patch[px][py] = new CfMapPatch(this, x-patchX-ox, y-patchY-oy);
        assert patch != null;
        assert patch[px] != null;
        return patch[px][py];
    }

    private void scroll(final int dx, final int dy) {
        assert Thread.holdsLock(this);
        if (dx == 0 && dy == 0) {
            return;
        }

        minX += dx;
        maxX += dx;
        minY += dy;
        maxY += dy;
        patchX += dx;
        patchY += dy;
    }

    @NotNull
    private CfMapPatch expandTo(final int x, final int y) {
        if (minX > maxX || minY > maxY) {
            // current map is undefined ==> start with 1x1 map
            minX = x;
            maxX = x;
            minY = y;
            maxY = y;
            minPx = (x-patchX)>>CfMapPatch.SIZE_LOG;
            maxPx = minPx;
            minPy = (y-patchY)>>CfMapPatch.SIZE_LOG;
            maxPy = minPy;
            patch = new CfMapPatch[1][1];
            //noinspection AssignmentToNull
            patch[0][0] = null;
        } else {
            if (x < minX) {
                increase(x-minX, 0);
            }
            if (x > maxX) {
                increase(x-maxX, 0);
            }
            if (y < minY) {
                increase(0, y-minY);
            }
            if (y > maxY) {
                increase(0, y-maxY);
            }
        }

        final CfMapPatch result = getMapPatch(x, y);
        assert result != null;
        return result;
    }

    private void increase(final int dx, final int dy) {
        if (dx < 0) {
            final int newMinX = minX+dx;
            final int newMinPx = (newMinX-patchX)>>CfMapPatch.SIZE_LOG;
            final int diffPw = minPx-newMinPx;
            if (diffPw == 0) {
                // new size fits within current patch ==> no change to
                // <code>patch</code>
                minX = newMinX;
            } else {
                // need to add (diffPw) patches to the left

                assert diffPw > 0;

                final int newPw = size(newMinPx, maxPx);
                final int newPh = size(minPy, maxPy);
                assert patch != null;
                final int oldPw = patch.length;
                final int oldPh = patch[0].length;

                // new width must be more than old size
                assert newPw > oldPw;
                assert newPw == oldPw+diffPw;
                assert newPh == oldPh;

                minX = newMinX;
                minPx = newMinPx;
                patch = copyPatches(newPw, newPh, diffPw, 0, oldPw, oldPh);
            }
        } else if (dx > 0) {
            final int newMaxX = maxX+dx;
            final int newMaxPx = (newMaxX-patchX)>>CfMapPatch.SIZE_LOG;
            final int diffPw = newMaxPx-maxPx;
            if (diffPw == 0) {
                // new size fits within current patch ==> no change to
                // <code>patch</code>
                maxX = newMaxX;
            } else {
                // need to add (diffPw) patches to the right

                assert diffPw > 0;

                final int newPw = size(minPx, newMaxPx);
                final int newPh = size(minPy, maxPy);
                assert patch != null;
                final int oldPw = patch.length;
                final int oldPh = patch[0].length;

                // new width must be more than old size
                assert newPw > oldPw;
                assert newPw == oldPw+diffPw;
                assert newPh == oldPh;

                maxX = newMaxX;
                maxPx = newMaxPx;
                patch = copyPatches(newPw, newPh, 0, 0, oldPw, oldPh);
            }
        }

        if (dy < 0) {
            final int newMinY = minY+dy;
            final int newMinPy = (newMinY-patchY)>>CfMapPatch.SIZE_LOG;
            final int diffPh = minPy-newMinPy;
            if (diffPh == 0) {
                // new size fits within current patch ==> no change to
                // <code>patch</code>
                minY = newMinY;
            } else {
                // need to add (diffPh) patches to the top

                assert diffPh > 0;

                final int newPw = size(minPx, maxPx);
                final int newPh = size(newMinPy, maxPy);
                assert patch != null;
                final int oldPw = patch.length;
                final int oldPh = patch[0].length;

                // new height must be more than old size
                assert newPh > oldPh;
                assert newPh == oldPh+diffPh;
                assert newPw == oldPw;

                minY = newMinY;
                minPy = newMinPy;
                patch = copyPatches(newPw, newPh, 0, diffPh, oldPw, oldPh);
            }
        } else if (dy > 0) {
            final int newMaxY = maxY+dy;
            final int newMaxPy = (newMaxY-patchY)>>CfMapPatch.SIZE_LOG;
            final int diffPh = newMaxPy-maxPy;
            if (diffPh == 0) {
                // new size fits within current patch ==> no change to
                // <code>patch</code>
                maxY = newMaxY;
            } else {
                // need to add (diffPh) patches to the bottom

                assert diffPh > 0;

                final int newPw = size(minPx, maxPx);
                final int newPh = size(minPy, newMaxPy);
                assert patch != null;
                final int oldPw = patch.length;
                final int oldPh = patch[0].length;

                // new height must be more than old size
                assert newPh > oldPh;
                assert newPh == oldPh+diffPh;
                assert newPw == oldPw;

                maxY = newMaxY;
                maxPy = newMaxPy;
                patch = copyPatches(newPw, newPh, 0, 0, oldPw, oldPh);
            }
        }
    }

    private static int size(final int min, final int max) {
        return max-min+1;
    }

    @NotNull
    public CfMapSquare getMapSquare(final int x, final int y) {
        assert Thread.holdsLock(this);
        return expandTo(x, y).getSquare(ox, oy);
    }

    @Nullable
    public CfMapSquare getMapSquareUnlessDirty(final int x, final int y) {
        assert Thread.holdsLock(this);
        final CfMapSquare mapSquare = getMapSquare(x, y);
        return dirtyMapSquares.contains(mapSquare) ? null : mapSquare;
    }

    public int getOffsetX() {
        assert Thread.holdsLock(this);
        return patchX;
    }

    public int getOffsetY() {
        assert Thread.holdsLock(this);
        return patchY;
    }

    @NotNull
    private CfMapPatch[][] copyPatches(final int newWidth, final int newHeight, final int offsetX, final int offsetY, final int height, final int width) {
        assert patch != null;
        final CfMapPatch[][] newPatch = new CfMapPatch[newWidth][newHeight];
        for (int y = 0; y < width; y++) {
            for (int x = 0; x < height; x++) {
                newPatch[offsetX+x][offsetY+y] = patch[x][y];
            }
        }
        return newPatch;
    }

    public void squareModified(@NotNull final CfMapSquare mapSquare) {
        assert Thread.holdsLock(this);
        dirtyMapSquares.add(mapSquare);
    }

    public void squarePendingFace(final int x, final int y, final int faceNum) {
        assert Thread.holdsLock(this);
        final Integer tmpFaceNum = faceNum;
        Collection<CfMapSquare> mapSquares = pendingFaceSquares.get(tmpFaceNum);
        if (mapSquares == null) {
            mapSquares = new HashSet<>();
            pendingFaceSquares.put(tmpFaceNum, mapSquares);
        }
        mapSquares.add(getMapSquare(x, y));
    }

    @NotNull
    public Set<CfMapSquare> getDirtyMapSquares() {
        assert Thread.holdsLock(this);
        final Set<CfMapSquare> result = new HashSet<>(dirtyMapSquares);
        dirtyMapSquares.clear();
        return result;
    }

    public void updateFace(final int faceNum, final int width, final int height) {
        for (int y = 0; y < height; y++) {
            for (int x = 0; x < width; x++) {
                for (int layer = 0; layer < Map2.NUM_LAYERS; layer++) {
                    final Face face = getFace(x, y, layer);
                    if (face != null && face.getFaceNum() == faceNum) {
                        setFace(x, y, layer, face);
                        dirty(x, y);
                    }
                }
            }
        }

        final Collection<CfMapSquare> mapSquares = pendingFaceSquares.remove(faceNum);
        if (mapSquares != null) {
            dirtyMapSquares.addAll(mapSquares);
        }
    }

    public boolean processMapScroll(final int dx, final int dy, final int width, final int height) {
        if (Math.abs(dx) >= width || Math.abs(dy) >= height) {
            scroll(dx, dy);
            for (int y = 0; y < height; y++) {
                for (int x = 0; x < width; x++) {
                    clearSquare(x, y);
                }
            }

            return true;
        }

        int tx = dx;
        while (tx > 0) {
            scroll(-1, 0);
            for (int y = 0; y < height; y++) {
                clearSquare(-1, y);
                clearSquare(width-1, y);
            }
            tx--;
        }
        while (tx < 0) {
            scroll(+1, 0);
            for (int y = 0; y < height; y++) {
                clearSquare(0, y);
                clearSquare(width, y);
            }
            tx++;
        }

        int ty = dy;
        while (ty > 0) {
            scroll(0, -1);
            for (int x = 0; x < width; x++) {
                clearSquare(x, -1);
                clearSquare(x, height-1);
            }
            ty--;
        }
        while (ty < 0) {
            scroll(0, +1);
            for (int x = 0; x <= width; x++) {
                clearSquare(x, 0);
                clearSquare(x, height);
            }
            ty++;
        }

        return false;
    }

}