BlockedSquareChecker.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.model.validation.checks;
 
import java.awt.Point;
import java.util.ArrayList;
import java.util.Collection;
import net.sf.gridarta.model.archetype.Archetype;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.maparchobject.MapArchObject;
import net.sf.gridarta.model.mapmodel.MapModel;
import net.sf.gridarta.model.mapmodel.MapSquare;
import net.sf.gridarta.model.validation.AbstractValidator;
import net.sf.gridarta.model.validation.ErrorCollector;
import net.sf.gridarta.model.validation.MapValidator;
import net.sf.gridarta.model.validation.ValidatorPreferences;
import net.sf.gridarta.model.validation.errors.BlockedSquareError;
import net.sf.gridarta.utils.Size2D;
import org.jetbrains.annotations.NotNull;
 
public class BlockedSquareChecker<G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> extends AbstractValidator<G, A, R> implements MapValidator<G, A, R> {
 
    public BlockedSquareChecker(@NotNull final ValidatorPreferences validatorPreferences) {
        super(validatorPreferences);
    }
 
    @Override
    public void validateMap(@NotNull final MapModel<G, A, R> mapModel, @NotNull final ErrorCollector<G, A, R> errorCollector) {
        for (final MapSquare<G, A, R> completelyBlockedSquare : findCompletelyBlockedSquares(mapModel)) {
            errorCollector.collect(new BlockedSquareError<>(completelyBlockedSquare));
        }
    }
 
    public static <G extends GameObject<G, A, R>, A extends MapArchObject<A>, R extends Archetype<G, A, R>> Iterable<MapSquare<G, A, R>> findCompletelyBlockedSquares(@NotNull final MapModel<G, A, R> mapModel) {
        final Size2D mapSize = mapModel.getMapArchObject().getMapSize();
        final int mapWidth = mapSize.getWidth();
        final int mapHeight = mapSize.getHeight();
        // The blockedMatrix is 1 row larger than the map on each border to ease two things:
        // First, it's not necessary to do a bounds check then.
        // Second, it will cope with the future requirement to perform this check with respect of tiled maps.
        final boolean[][] blockedMatrix = new boolean[mapWidth + 2][mapHeight + 2];
        final Point pos = new Point();
        for (int x = 0; x < mapWidth; x++) {
            pos.x = x;
            for (int y = 0; y < mapHeight; y++) {
                pos.y = y;
                if (isBlocked(mapModel.getMapSquare(pos))) {
                    blockedMatrix[x + 1][y + 1] = true;
                }
            }
        }
        final Collection<MapSquare<G, A, R>> completelyBlockedSquares = new ArrayList<>();
        for (int x = 0; x < mapWidth; x++) {
            pos.x = x;
            for (int y = 0; y < mapHeight; y++) {
                pos.y = y;
                if (and9x9(blockedMatrix, x + 1, y + 1)) {
                    completelyBlockedSquares.add(mapModel.getMapSquare(pos));
                }
            }
        }
        return completelyBlockedSquares;
    }
 
    private static boolean and9x9(final boolean @NotNull [] @NotNull [] matrix, final int x, final int y) {
        return matrix[x - 1][y - 1] && matrix[x - 1][y] && matrix[x - 1][y + 1] && matrix[x][y - 1] && matrix[x][y] && matrix[x][y + 1] && matrix[x + 1][y - 1] && matrix[x + 1][y] && matrix[x + 1][y + 1];
    }
 
    private static boolean isBlocked(@NotNull final Iterable<? extends GameObject<?, ?, ?>> square) {
        boolean noPass = false;
        boolean blocksView = false;
        for (final BaseObject<?, ?, ?, ?> gameObject : square) {
            if (!noPass) {
                noPass = gameObject.getAttributeInt(BaseObject.NO_PASS) == 1;
            }
            if (!blocksView) {
                blocksView = gameObject.getAttributeInt(BaseObject.BLOCKSVIEW) == 1;
            }
            if (noPass && blocksView) {
                return true;
            }
        }
        return false;
    }
 
}