Add tests around CollisionManager functionality

Adds tests for the CollisionManager which makes sure that collision matrices are correctly built for the following object types: * Interactables * Walls * Corners Missing from these tests are tests for blocked / bridged tiles, and large corner walls, which can be added later. Additionally, the test cases include ASCII illustrations of the collision grid and how it is built / checked for a particular object or movement.
2026-07-03 00:38:21 +00:00 · 2016-12-31 05:19:49 +00:00
parent 6188c2e751
commit 916f6c547d
1 changed files with 242 additions and 0 deletions
@@ -0,0 +1,242 @@
+package org.apollo.game.model.area.collision;
+
+import org.apollo.cache.def.ObjectDefinition;
+import org.apollo.cache.map.MapObject;
+import org.apollo.game.model.Direction;
+import org.apollo.game.model.Position;
+import org.apollo.game.model.World;
+import org.apollo.game.model.area.Region;
+import org.apollo.game.model.area.RegionRepository;
+import org.apollo.game.model.entity.EntityType;
+import org.apollo.game.model.entity.obj.ObjectType;
+import org.apollo.game.model.entity.obj.StaticGameObject;
+import org.junit.Assert;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+
+/**
+ * Tests for the {@link CollisionManager}.
+ */
+public final class CollisionManagerTests {
+
+	/**
+	 * The id of a simple wall object.
+	 */
+	private static final int WALL = 0;
+
+	/**
+	 * The id of a square 2x2 solid object.
+	 */
+	private static final int SQUARE_OBJECT = 1;
+
+	/**
+	 * Setup some simple object definitions to use in collision tests.
+	 */
+	@BeforeClass
+	public static void setupObjectDefinitions() {
+		ObjectDefinition wall = new ObjectDefinition(WALL);
+
+		ObjectDefinition squareObject = new ObjectDefinition(SQUARE_OBJECT);
+		squareObject.setLength(2);
+		squareObject.setWidth(2);
+
+		ObjectDefinition.init(new ObjectDefinition[]{
+			wall, squareObject
+		});
+	}
+
+	/**
+	 * Tests that a wall is untraversable from the front and back, for the facing direction and opposite facing direction
+	 * respectively. For a simple grid, with a wall on 0,1 we end up with a collision matrix looking like:
+	 * <pre>
+	 * (0,2) |---------|
+	 *       |         |
+	 *       |         |
+	 *       |   xxx   |
+	 * (0,1) |---------|
+	 *       |   xxx   |
+	 *       |         |
+	 *       |         |
+	 * (0,0) |---------|
+	 *       |         |
+	 *       |         |
+	 *       |         |
+	 *       |---------|
+	 * </pre>
+	 * <p>
+	 * Where {@code xxx} denotes that you cannot walk into that tile from that direction (in this case you south on
+	 * (0,2) and north on (0,1)). For the grid above you can't walk north into {@code (0, 2)} because {@code (0, 2)} is
+	 * untraversable from the south, and as expectred you can't walk south into {@code (0,1)} because ({@code (0, 1)} is
+	 * untraversable from the north.
+	 */
+	@Test
+	public void wall() {
+		Position front = new Position(0, 1, 0);
+		Position back = front.step(1, Direction.NORTH);
+
+		CollisionManager collisionManager = createCollisionManager(
+			createMapObject(WALL, front, ObjectType.LENGTHWISE_WALL, Direction.NORTH)
+		);
+
+		assertUntraversable(collisionManager, front, Direction.NORTH);
+		assertUntraversable(collisionManager, back, Direction.SOUTH);
+		assertUntraversable(collisionManager, front, Direction.NORTH_EAST);
+		assertUntraversable(collisionManager, back, Direction.SOUTH_EAST);
+	}
+
+	/**
+	 * Tests that a corner wall is untraversable from the sides that it blocks.  Corners are much like walls, with
+	 * the only difference being their orientation.  Instead of {@link Direction#WNES}, they have diagonal directions.
+	 * With a corner wall at (0, 1) facing to the north-east we end up with a grid looking like this:
+	 * <p>
+	 * <pre>
+	 * (0,2) |---------|---------|
+	 *       |         |         |
+	 *       |         |         |
+	 *       |         |xxx      |
+	 * (0,1) |---------|---------|
+	 *       |      xxx|         |
+	 *       |         |         |
+	 *       |         |         |
+	 * (0,0) |---------|---------|
+	 * 	   (1,0)     (2,0)     (3,0)
+	 * </pre>
+	 * <p>
+	 * Where you can walk north and east through the tile the corner occupies, as well as south and west through the
+	 * adjacent tile, but not north-east or south-west.
+	 */
+	@Test
+	public void cornerWall() {
+		Position front = new Position(0, 1, 0);
+		Position back = front.step(1, Direction.NORTH_EAST);
+
+		CollisionManager collisionManager = createCollisionManager(
+			createMapObject(WALL, front, ObjectType.TRIANGULAR_CORNER, Direction.NORTH_EAST)
+		);
+
+		assertTraversable(collisionManager, front, Direction.NORTH, Direction.EAST);
+		assertUntraversable(collisionManager, front, Direction.NORTH_EAST);
+		assertTraversable(collisionManager, back, Direction.SOUTH, Direction.WEST);
+		assertUntraversable(collisionManager, back, Direction.SOUTH_WEST);
+	}
+
+	/**
+	 * Tests that the tiles occupied by a 2x2 square object are not traversable.  When an interactable object is added
+	 * to a collision update, all tiles spanning its with and length from its origin position will be marked as completely
+	 * blocked off, which with a 2x2 object at (1,1) produces a grid like this:
+	 * <pre>
+	 * (0,3) |---------|---------|---------|---------|
+	 *       |         |xxxxxxxxx|xxxxxxxxx|         |
+	 *       |         |x       x|x       x|         |
+	 *       |         |xxxxxxxxx|xxxxxxxxx|         |
+	 * (0,2) |---------|---------|---------|---------|
+	 *       |         |xxxxxxxxx|xxxxxxxxx|         |
+	 *       |         |x       x|x       x|         |
+	 *       |         |xxxxxxxxx|xxxxxxxxx|         |
+	 * (0,1) |---------|---------|---------|---------|
+	 *       |         |         |         |         |
+	 *       |         |         |         |         |
+	 *       |         |         |         |         |
+	 * (0,0) |---------|---------|---------|---------|
+	 * 	   (0,0)     (1,0)     (2,0)     (3,0)     (4,0)
+	 * </pre>
+	 * <p>
+	 * Where every tile that is occupied by the object is untraversable in every direction.
+	 */
+	@Test
+	public void object() {
+		Position origin = new Position(1, 1, 0);
+
+		CollisionManager collisionManager = createCollisionManager(
+			createMapObject(SQUARE_OBJECT, origin, ObjectType.INTERACTABLE, Direction.NORTH)
+		);
+
+		Position west = origin.step(1, Direction.WEST);
+		Position east = origin.step(2, Direction.EAST);
+		Position northEast = origin.step(2, Direction.NORTH).step(1, Direction.EAST);
+		Position southEast = origin.step(1, Direction.SOUTH_EAST);
+
+		assertUntraversable(collisionManager, west, Direction.EAST);
+		assertUntraversable(collisionManager, east, Direction.WEST);
+		assertUntraversable(collisionManager, northEast, Direction.SOUTH_EAST, Direction.SOUTH_WEST);
+		assertUntraversable(collisionManager, southEast, Direction.NORTH_EAST, Direction.NORTH_WEST);
+	}
+
+	/**
+	 * Helper function for creating {@code org.apollo.cache} {@link MapObject}s using data structures from
+	 * {@code org.apollo.game}.
+	 *
+	 * @param id The id of the object.  Must be one of the {@link ObjectDefinition}s defined above.
+	 * @param position The position of the object.
+	 * @param type The object type.
+	 * @param direction The orientation of the object.
+	 * @return A new {@link MapObject}.
+	 */
+	private static MapObject createMapObject(int id, Position position, ObjectType type, Direction direction) {
+		return new MapObject(id, position.getX(), position.getY(), position.getHeight(), type.getValue(),
+			direction.toOrientationInteger());
+	}
+
+	/**
+	 * Sets up dependencies for and creates a stub {@link CollisionManager}, then builds the collision matrices
+	 * using the {@code objects} given.
+	 *
+	 * @param objects The objects to build collision matrices from.
+	 * @return A new {@link CollisionManager} with a valid {@link RegionRepository} and every {@link CollisionMatrix}
+	 * built.
+	 */
+	private static CollisionManager createCollisionManager(MapObject... objects) {
+		World world = new World();
+		RegionRepository regions = world.getRegionRepository();
+		CollisionManager collisionManager = world.getCollisionManager();
+
+		for (MapObject object : objects) {
+			// treat local coordinates as absolute for simplicity
+			int x = object.getLocalX(), y = object.getLocalY();
+			int height = object.getHeight();
+
+			Position position = new Position(x, y, height);
+			Region region = regions.fromPosition(position);
+			region.addEntity(new StaticGameObject(world, object.getId(), position, object.getType(),
+				object.getOrientation()), false);
+		}
+
+		collisionManager.build(false);
+		return collisionManager;
+	}
+
+	/**
+	 * Helper test assertion that a position is untraversable in a given direction.
+	 *
+	 * @param collisionManager The {@link CollisionManager} to check.
+	 * @param position The {@link Position}.
+	 * @param directions The {@link Direction}s to assert.
+	 */
+	private static void assertUntraversable(CollisionManager collisionManager, Position position, Direction... directions) {
+		for (Direction direction : directions) {
+			boolean traversable = collisionManager.traversable(position, EntityType.NPC, direction);
+			String message = String.format("Can walk %s from tile at (%d,%d), should not be able to",
+				direction.toString(), position.getX(), position.getY());
+
+			Assert.assertFalse(message, traversable);
+		}
+	}
+
+	/**
+	 * Helper test assertion that a position is traversable in a given direction.
+	 *
+	 * @param collisionManager The {@link CollisionManager} to check.
+	 * @param position The {@link Position}.
+	 * @param directions The {@link Direction}s to assert.
+	 */
+	private static void assertTraversable(CollisionManager collisionManager, Position position, Direction... directions) {
+		for (Direction direction : directions) {
+			boolean traversable = collisionManager.traversable(position, EntityType.NPC, direction);
+			String message = String.format("Cannot walk %s from tile at (%d,%d), should be able to",
+				direction.toString(), position.getX(), position.getY());
+
+			Assert.assertTrue(message, traversable);
+		}
+	}
+}