TestMapModelHelper.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.mapmodel;
 
import java.awt.Point;
import java.util.regex.Pattern;
import net.sf.gridarta.model.anim.AnimationObjects;
import net.sf.gridarta.model.archetype.DuplicateArchetypeException;
import net.sf.gridarta.model.archetype.TestArchetype;
import net.sf.gridarta.model.archetype.TestDefaultArchetype;
import net.sf.gridarta.model.archetypeset.ArchetypeSet;
import net.sf.gridarta.model.baseobject.BaseObject;
import net.sf.gridarta.model.baseobject.GameObjectContainer;
import net.sf.gridarta.model.face.FaceObjectProviders;
import net.sf.gridarta.model.gameobject.GameObject;
import net.sf.gridarta.model.gameobject.GameObjectFactory;
import net.sf.gridarta.model.gameobject.TestGameObject;
import net.sf.gridarta.model.maparchobject.TestMapArchObject;
import net.sf.gridarta.utils.Size2D;
import net.sf.gridarta.utils.StringUtils;
import org.jetbrains.annotations.NotNull;
import org.junit.Assert;
 
public class TestMapModelHelper {
 
    public static final int EXIT_TYPE = 1;
 
    private static final int FLOOR_TYPE = 2;
 
    private static final int MOB_TYPE = 3;
 
    @NotNull
    private static final String @NotNull [] EMPTY_STRING_ARRAY = new String[0];
 
    @NotNull
    private final InsertionMode topmostInsertionMode;
 
    @NotNull
    private final GameObjectFactory<TestGameObject, TestMapArchObject, TestArchetype> gameObjectFactory;
 
    @NotNull
    private final TestArchetype floorArchetype;
 
    @NotNull
    private final TestArchetype exitArchetype;
 
    @NotNull
    private final TestArchetype mob21Archetype;
 
    public TestMapModelHelper(@NotNull final InsertionMode topmostInsertionMode, @NotNull final GameObjectFactory<TestGameObject, TestMapArchObject, TestArchetype> gameObjectFactory, @NotNull final ArchetypeSet<TestGameObject, TestMapArchObject, TestArchetype> archetypeSet, @NotNull final FaceObjectProviders faceObjectProviders, @NotNull final AnimationObjects animationObjects) throws DuplicateArchetypeException {
        this.topmostInsertionMode = topmostInsertionMode;
        this.gameObjectFactory = gameObjectFactory;
 
        floorArchetype = new TestDefaultArchetype("floor", faceObjectProviders, animationObjects);
        floorArchetype.setAttributeInt(BaseObject.TYPE, FLOOR_TYPE);
        archetypeSet.addArchetype(floorArchetype);
 
        exitArchetype = new TestDefaultArchetype("exit", faceObjectProviders, animationObjects);
        exitArchetype.setAttributeInt(BaseObject.TYPE, EXIT_TYPE);
        archetypeSet.addArchetype(exitArchetype);
 
        mob21Archetype = new TestDefaultArchetype("mob21", faceObjectProviders, animationObjects);
        mob21Archetype.setAttributeInt(BaseObject.TYPE, MOB_TYPE);
        archetypeSet.addArchetype(mob21Archetype);
        final TestArchetype mob21bArchetype = new TestDefaultArchetype("mob21b", faceObjectProviders, animationObjects);
        mob21bArchetype.setMultiX(1);
        mob21Archetype.addTailPart(mob21bArchetype);
        archetypeSet.addArchetype(mob21bArchetype);
    }
 
    @NotNull
    public TestGameObject insertFloor(@NotNull final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel, @NotNull final Point point) {
        return insertArchetype(mapModel, point, floorArchetype, false);
    }
 
    @NotNull
    public TestGameObject insertExit(@NotNull final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel, @NotNull final Point point) {
        return insertArchetype(mapModel, point, exitArchetype, false);
    }
 
    @NotNull
    public TestGameObject insertMob21(@NotNull final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel, @NotNull final Point point) {
        return insertArchetype(mapModel, point, mob21Archetype, false);
    }
 
    @NotNull
    public TestGameObject insertArchetype(@NotNull final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel, final int x, final int y, @NotNull final BaseObject<TestGameObject, TestMapArchObject, TestArchetype, ?> archetype, final boolean join) {
        return insertArchetype(mapModel, new Point(x, y), archetype, join);
    }
 
    @NotNull
    public TestGameObject insertArchetype(@NotNull final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel, @NotNull final Point point, @NotNull final BaseObject<TestGameObject, TestMapArchObject, TestArchetype, ?> archetype, final boolean join) {
        final TestGameObject gameObject = mapModel.insertBaseObject(archetype, point, true, join, topmostInsertionMode);
        if (gameObject == null) {
            throw new IllegalArgumentException("failed to insert archetype");
        }
        return gameObject;
    }
 
    @NotNull
    public TestGameObject insertExit(@NotNull final GameObjectContainer<TestGameObject, TestMapArchObject, TestArchetype> gameObject) {
        return insertArchetype(gameObject, exitArchetype);
    }
 
    @NotNull
    public TestGameObject insertMob21(@NotNull final GameObjectContainer<TestGameObject, TestMapArchObject, TestArchetype> gameObject) {
        return insertArchetype(gameObject, mob21Archetype);
    }
 
    @NotNull
    private TestGameObject insertArchetype(@NotNull final GameObjectContainer<TestGameObject, TestMapArchObject, TestArchetype> gameObject, @NotNull final BaseObject<TestGameObject, TestMapArchObject, TestArchetype, ?> archetype) {
        final TestGameObject newGameObject = archetype.newInstance(gameObjectFactory);
        gameObject.addLast(newGameObject);
        return newGameObject;
    }
 
    public static void checkMapContents(@NotNull final MapModel<TestGameObject, TestMapArchObject, TestArchetype> mapModel, @NotNull final String... lines) {
        final Size2D mapSize = mapModel.getMapArchObject().getMapSize();
        Assert.assertEquals(lines.length, mapSize.getHeight());
        final Pattern pattern1 = Pattern.compile("\\|");
        final Pattern pattern2 = StringUtils.PATTERN_COMMA;
        final Point pos = new Point();
        for (int y = 0; y < lines.length; y++) {
            final CharSequence line = lines[y];
            final String[] square = pattern1.split(line, -1);
            Assert.assertEquals(square.length, mapSize.getWidth());
 
            for (int x = 0; x < square.length; x++) {
                final String square2 = square[x];
                final String[] gameObjects = square2.isEmpty() ? EMPTY_STRING_ARRAY : pattern2.split(square2, -1);
                pos.x = x;
                pos.y = y;
                checkContentsString(mapModel.getMapSquare(pos), gameObjects);
            }
        }
    }
 
    private static void checkContentsString(@NotNull final MapSquare<TestGameObject, TestMapArchObject, TestArchetype> mapSquare, @NotNull final String... gameObjects) {
        int i = 0;
        for (final BaseObject<?, ?, ?, ?> gameObject : mapSquare) {
            final String gameObjectName = gameObject.getBestName();
            if (i >= gameObjects.length) {
                Assert.fail("map square " + mapSquare.getMapX() + "/" + mapSquare.getMapY() + " contains excess game object '" + gameObjectName + "'");
            } else if (!gameObjectName.equals(gameObjects[i])) {
                Assert.fail("map square " + mapSquare.getMapX() + "/" + mapSquare.getMapY() + " contains wrong game object '" + gameObjectName + "' at index " + i + ", expected '" + gameObjects[i] + "'");
            }
            i++;
        }
        if (i < gameObjects.length) {
            Assert.fail("map square " + mapSquare.getMapX() + "/" + mapSquare.getMapY() + " is missing game object '" + gameObjects[i] + "'");
        }
    }
 
    public static void checkContents(@NotNull final Iterable<TestGameObject> mapSquare, @NotNull final BaseObject<?, ?, ?, ?>... gameObjects) {
        int i = 0;
        for (final BaseObject<?, ?, ?, ?> gameObject : mapSquare) {
            final String gameObjectName = gameObject.getBestName();
            if (i >= gameObjects.length) {
                Assert.fail("map square contains excess game object '" + gameObjectName + "'");
            } else if (gameObject != gameObjects[i]) {
                Assert.fail("map square contains wrong game object '" + gameObjectName + "' at index " + i + ", expected '" + gameObjects[i].getBestName() + "'");
            }
            i++;
        }
        if (i < gameObjects.length) {
            Assert.fail("map square is missing game object '" + gameObjects[i].getBestName() + "'");
        }
 
        final boolean inContainer = mapSquare instanceof GameObject;
        for (final GameObject<?, ?, ?> gameObject : mapSquare) {
            Assert.assertEquals(inContainer, gameObject.isInContainer());
            if (inContainer) {
                // game objects within inventories must not contain tail parts
                Assert.assertFalse(gameObject.isMulti());
            } else {
                // game objects on the map must have expanded tail parts
                Assert.assertEquals(gameObject.getArchetype().isMulti(), gameObject.isMulti());
            }
        }
    }
 
}