pom.xml

@@ -74,11 +74,6 @@
             <groupId>io.vavr</groupId>
             <artifactId>vavr</artifactId>
         </dependency>
-        <dependency>
-            <groupId>com.google.guava</groupId>
-            <artifactId>guava</artifactId>
-            <version>33.2.1-jre</version>
-        </dependency>
         <dependency>
             <groupId>org.apache.pdfbox</groupId>
             <artifactId>pdfbox</artifactId>

src/main/java/ch/fritteli/maze/generator/algorithm/AbstractMazeGeneratorAlgorithm.java

@@ -1,20 +0,0 @@
-package ch.fritteli.maze.generator.algorithm;
-
-import ch.fritteli.maze.generator.model.Maze;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Random;
-
-public abstract class AbstractMazeGeneratorAlgorithm implements MazeGeneratorAlgorithm {
-    @NotNull
-    protected final Maze maze;
-    @NotNull
-    protected final Random random;
-
-
-    protected AbstractMazeGeneratorAlgorithm(@NotNull final Maze maze, @NotNull final String algorithmName) {
-        this.maze = maze;
-        this.random = new Random(maze.getRandomSeed());
-        this.maze.setAlgorithm(algorithmName);
-    }
-}

src/main/java/ch/fritteli/maze/generator/algorithm/MazeGeneratorAlgorithm.java

@@ -1,5 +0,0 @@
-package ch.fritteli.maze.generator.algorithm;
-
-public interface MazeGeneratorAlgorithm {
-    void run();
-}

src/main/java/ch/fritteli/maze/generator/algorithm/RandomDepthFirst.java

@@ -10,13 +10,20 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.Deque;
 import java.util.LinkedList;
+import java.util.Random;
 
-public class RandomDepthFirst extends AbstractMazeGeneratorAlgorithm {
+public class RandomDepthFirst {
+
+    @NotNull
+    private final Maze maze;
+    @NotNull
+    private final Random random;
     @NotNull
     private final Deque<Position> positions = new LinkedList<>();
 
     public RandomDepthFirst(@NotNull final Maze maze) {
-        super(maze, "Random Depth First");
+        this.maze = maze;
+        this.random = new Random(maze.getRandomSeed());
     }
 
     public void run() {

src/main/java/ch/fritteli/maze/generator/algorithm/wilson/MazeSolver.java

@@ -1,62 +0,0 @@
-package ch.fritteli.maze.generator.algorithm.wilson;
-
-import ch.fritteli.maze.generator.model.Direction;
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.model.Position;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.EnumSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Stack;
-import java.util.stream.Collectors;
-
-public class MazeSolver {
-    @NotNull
-    private final Maze maze;
-
-    MazeSolver(@NotNull final Maze maze) {
-        this.maze = maze;
-    }
-
-    void solve() {
-        final Direction directionToOuterWall = Wilson.getDirectionToOuterWall(
-                this.maze.getStart(),
-                this.maze.getWidth(),
-                this.maze.getHeight()
-        );
-
-        final List<Position> solution = this.getSolution(this.maze.getStart(), directionToOuterWall);
-        for (Position position : solution) {
-            this.maze.getTileAt(position).get().setSolution();
-        }
-    }
-
-    private List<Position> getSolution(@NotNull Position position,
-                                       @NotNull Direction forbidden) {
-        record PathElement(@NotNull Position position,
-                           @NotNull EnumSet<Direction> possibleDirections) {
-        }
-        final Stack<PathElement> solution = new Stack<>();
-        final EnumSet<Direction> directions = this.maze.getTileAt(position).get().getOpenDirections();
-        directions.remove(forbidden);
-        PathElement head = new PathElement(position, directions);
-        solution.push(head);
-        while (!head.position.equals(this.maze.getEnd())) {
-            if (head.possibleDirections.isEmpty()) {
-                solution.pop();
-                head = solution.peek();
-            } else {
-                final Iterator<Direction> iterator = head.possibleDirections.iterator();
-                final Direction direction = iterator.next();
-                iterator.remove();
-                final Position next = head.position.move(direction);
-                final EnumSet<Direction> openDirections = this.maze.getTileAt(next).get().getOpenDirections();
-                openDirections.remove(direction.invert());
-                head = new PathElement(next, openDirections);
-                solution.push(head);
-            }
-        }
-        return solution.stream().map(PathElement::position).collect(Collectors.toList());
-    }
-}

src/main/java/ch/fritteli/maze/generator/algorithm/wilson/Path.java

@@ -1,91 +0,0 @@
-package ch.fritteli.maze.generator.algorithm.wilson;
-
-import ch.fritteli.maze.generator.model.Direction;
-import ch.fritteli.maze.generator.model.Position;
-import io.vavr.collection.List;
-import io.vavr.collection.Stream;
-import io.vavr.collection.Traversable;
-import io.vavr.control.Option;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Random;
-
-class Path {
-    private final int width;
-    private final int height;
-    @NotNull
-    private List<Position> positions;
-
-    Path(@NotNull final Position start, int width, int height) {
-        this.positions = List.of(start);
-        this.width = width;
-        this.height = height;
-    }
-
-    @NotNull
-    Position growRandom(@NotNull final Random random) {
-        final Position position = this.nextRandomPosition(random);
-        if (this.contains(position)) {
-            this.removeLoopUpTo(position);
-            return this.growRandom(random);
-        }
-        this.positions = this.positions.prepend(position);
-        return position;
-    }
-
-    @NotNull
-    List<Position> getPositions() {
-        return this.positions;
-    }
-
-    @NotNull
-    Position getStart() {
-        return this.positions.last();
-    }
-
-    @NotNull
-    Traversable<Direction> getMovesFromStart() {
-        return this.positions.reverse().sliding(2)
-                .flatMap(positions1 -> Option.when(
-                        positions1.size() == 2,
-                        // DEV-NOTE: .get() is safe here, because in the context of a path, there MUST be a direction
-                        // from one position to the next.
-                        () -> positions1.head().getDirectionTo(positions1.last()).get()
-                ));
-    }
-
-    @NotNull
-    private Position nextRandomPosition(@NotNull final Random random) {
-        final Direction randomDirection = this.getRandomDirection(random);
-        final Position nextPosition = this.positions.head().move(randomDirection);
-        if (this.isWithinBounds(nextPosition) && !nextPosition.equals(this.positions.head())) {
-            return nextPosition;
-        }
-        return this.nextRandomPosition(random);
-    }
-
-    private boolean isWithinBounds(@NotNull final Position position) {
-        return position.x() >= 0 && position.x() < this.width && position.y() >= 0 && position.y() < this.height;
-    }
-
-    private boolean contains(@NotNull final Position position) {
-        return this.positions.contains(position);
-    }
-
-    private void removeLoopUpTo(@NotNull final Position position) {
-        this.positions = this.positions.dropUntil(position::equals);
-    }
-
-    @NotNull
-    private Direction getRandomDirection(@NotNull final Random random) {
-        final Direction[] array = Direction.values();
-        return array[random.nextInt(array.length)];
-    }
-
-    @Override
-    public String toString() {
-        return Stream.ofAll(this.positions)
-                .map(position -> "(%s,%s)".formatted(position.x(), position.y()))
-                .mkString("Path[", "->", "]");
-    }
-}

src/main/java/ch/fritteli/maze/generator/algorithm/wilson/PathsBuilder.java

@@ -1,131 +0,0 @@
-package ch.fritteli.maze.generator.algorithm.wilson;
-
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.model.Position;
-import com.google.common.collect.HashMultimap;
-import com.google.common.collect.Multimap;
-import io.vavr.Tuple;
-import io.vavr.collection.Stream;
-import io.vavr.collection.Traversable;
-import io.vavr.control.Option;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Random;
-
-/**
- * This class will build paths such that in the end all fields of the maze are covered by exactly one path.
- */
-class PathsBuilder {
-    private final int width;
-    private final int height;
-    @NotNull
-    private final Random random;
-    @NotNull
-    private final Multimap<Integer, Integer> availablePositions;
-
-    PathsBuilder(@NotNull final Maze maze,
-                 @NotNull final Random random) {
-        this.width = maze.getWidth();
-        this.height = maze.getHeight();
-        this.random = random;
-        this.availablePositions = HashMultimap.create(this.width, this.height);
-
-        // Initialize the available positions.
-        for (int x = 0; x < this.width; x++) {
-            for (int y = 0; y < this.height; y++) {
-                this.availablePositions.put(x, y);
-            }
-        }
-    }
-
-    /**
-     * Create all the paths such that the maze will be completely filled and every field of it will be covered by
-     * exactly one path.
-     *
-     * @return A {@link Traversable} of generated {@link Path Paths}.
-     */
-    @NotNull
-    Traversable<Path> buildPaths() {
-        this.initializeWithRandomStartingPosition();
-
-        return Stream.unfoldLeft(
-                this,
-                builder -> builder.buildPath()
-                        .map(path -> {
-                            builder.setPartOfMaze(path);
-                            return Tuple.of(builder, path);
-                        })
-        );
-    }
-
-    private void initializeWithRandomStartingPosition() {
-        this.popRandomPosition();
-    }
-
-    /**
-     * Creates one new path, if possible. If the maze is already filled, {@link io.vavr.control.Option.None} is
-     * returned.
-     *
-     * @return An {@link Option} of a new {@link Path} instance.
-     */
-    @NotNull
-    private Option<Path> buildPath() {
-        return this.initializeNewPath()
-                .map(this::growPath);
-    }
-
-    @NotNull
-    private Option<Path> initializeNewPath() {
-        return this.popRandomPosition()
-                .map(position -> new Path(position, this.width, this.height));
-    }
-
-    /**
-     * Randomly grow the {@code path} until it reaches a field that is part of the maze and return it. The resulting
-     * path will contain no loops.
-     *
-     * @param path The {@link Path} to grow.
-     * @return The final {@link Path} that reaches the maze.
-     */
-    @NotNull
-    private Path growPath(@NotNull final Path path) {
-        Position lastPosition;
-        do {
-            lastPosition = path.growRandom(this.random);
-        } while (this.isNotPartOfMaze(lastPosition));
-        return path;
-    }
-
-    private boolean isNotPartOfMaze(@NotNull final Position position) {
-        return this.availablePositions.containsEntry(position.x(), position.y());
-    }
-
-    private void setPartOfMaze(@NotNull final Position position) {
-        this.availablePositions.remove(position.x(), position.y());
-    }
-
-    private void setPartOfMaze(@NotNull final Path path) {
-        path.getPositions().forEach(this::setPartOfMaze);
-    }
-
-    /**
-     * Finds a random {@link Position}, that is not yet part of the maze, marks it as being part of the maze and returns
-     * it. If no position is available, {@link io.vavr.control.Option.None} is returned.
-     *
-     * @return An available position or {@link io.vavr.control.Option.None}.
-     */
-    @NotNull
-    private Option<Position> popRandomPosition() {
-        if (this.availablePositions.isEmpty()) {
-            return Option.none();
-        }
-
-        final Integer[] keys = this.availablePositions.keySet().toArray(Integer[]::new);
-        final int key = keys[this.random.nextInt(keys.length)];
-        final Integer[] values = this.availablePositions.get(key).toArray(Integer[]::new);
-        final int value = values[this.random.nextInt(values.length)];
-
-        this.availablePositions.remove(key, value);
-        return Option.some(new Position(key, value));
-    }
-}

src/main/java/ch/fritteli/maze/generator/algorithm/wilson/Wilson.java

@@ -1,96 +0,0 @@
-package ch.fritteli.maze.generator.algorithm.wilson;
-
-import ch.fritteli.maze.generator.algorithm.AbstractMazeGeneratorAlgorithm;
-import ch.fritteli.maze.generator.model.Direction;
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.model.Position;
-import ch.fritteli.maze.generator.model.Tile;
-import io.vavr.collection.Traversable;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/**
- * An implementation of <a href="https://en.wikipedia.org/wiki/Maze_generation_algorithm#Wilson's_algorithm">Wilson's Algorithm</a>.
- * In short:
- * <ol>
- *     <li>Pick random location, add to maze</li>
- *     <li>While locations that are not part of the maze exist, loop:
- *     <ol>
- *         <li>Pick random location that's not part of the maze</li>
- *         <li>Randomly walk from this location, until ...
- *         <ul>
- *             <li>... either you hit the current path, forming a loop. Then remove the entire loop and continue
- *             walking.</li>
- *             <li>... or you hit a position that is part of the maze. Then add the path to the maze and start the next
- *             walk.</li>
- *         </ul></li>
- *     </ol></li>
- * </ol>
- */
-public class Wilson extends AbstractMazeGeneratorAlgorithm {
-
-    public Wilson(@NotNull final Maze maze) {
-        super(maze, "Wilson");
-    }
-
-    @Nullable
-    static Direction getDirectionToOuterWall(@NotNull final Position position,
-                                             final int width,
-                                             final int height) {
-        if (position.y() == 0) {
-            return Direction.TOP;
-        }
-        if (position.y() == height - 1) {
-            return Direction.BOTTOM;
-        }
-        if (position.x() == 0) {
-            return Direction.LEFT;
-        }
-        if (position.x() == width - 1) {
-            return Direction.RIGHT;
-        }
-        return null;
-    }
-
-    @Override
-    public void run() {
-        final Traversable<Path> paths = new PathsBuilder(this.maze, this.random)
-                .buildPaths();
-
-        this.applyPathsToMaze(paths);
-    }
-
-    private void applyPathsToMaze(@NotNull final Traversable<Path> paths) {
-        this.openStartAndEndWalls();
-        paths.forEach(path -> path.getMovesFromStart()
-                .foldLeft(
-                        path.getStart(),
-                        (position, direction) -> {
-                            this.maze.getTileAt(position).get()
-                                    .digTo(direction);
-                            final Position next = position.move(direction);
-                            this.maze.getTileAt(next).get()
-                                    .digTo(direction.invert());
-                            return next;
-                        }));
-
-        final MazeSolver solver = new MazeSolver(this.maze);
-        solver.solve();
-    }
-
-    private void openStartAndEndWalls() {
-        this.openWall(this.maze.getStart(), this.maze.getStartTile());
-        this.openWall(this.maze.getEnd(), this.maze.getEndTile());
-    }
-
-    private void openWall(@NotNull final Position position, @NotNull final Tile tile) {
-        final Direction direction = this.getDirectionToOuterWall(position);
-        tile.enableDiggingToOrFrom(direction);
-        tile.digTo(direction);
-    }
-
-    @Nullable
-    private Direction getDirectionToOuterWall(@NotNull final Position position) {
-        return getDirectionToOuterWall(position, this.maze.getWidth(), this.maze.getHeight());
-    }
-}

src/main/java/ch/fritteli/maze/generator/model/Direction.java

@@ -1,14 +1,11 @@
 package ch.fritteli.maze.generator.model;
 
-import org.jetbrains.annotations.NotNull;
-
 public enum Direction {
     TOP,
     RIGHT,
     BOTTOM,
     LEFT;
 
-    @NotNull
     public Direction invert() {
         return switch (this) {
             case TOP -> BOTTOM;

src/main/java/ch/fritteli/maze/generator/model/Maze.java

@@ -3,7 +3,6 @@ package ch.fritteli.maze.generator.model;
 import io.vavr.control.Option;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
-import lombok.Setter;
 import lombok.ToString;
 import org.jetbrains.annotations.NotNull;
 
@@ -22,9 +21,6 @@ public class Maze {
     private final Position start;
     @Getter
     private final Position end;
-    @Getter
-    @Setter
-    private String algorithm;
 
     public Maze(final int width, final int height) {
         this(width, height, System.nanoTime());
@@ -38,11 +34,7 @@ public class Maze {
         this(width, height, randomSeed, new Position(0, 0), new Position(width - 1, height - 1));
     }
 
-    public Maze(final int width,
+    public Maze(final int width, final int height, final long randomSeed, @NotNull final Position start, @NotNull final Position end) {
-                final int height,
-                final long randomSeed,
-                @NotNull final Position start,
-                @NotNull final Position end) {
         if (width <= 1 || height <= 1) {
             throw new IllegalArgumentException("width and height must be >1");
         }
@@ -79,12 +71,7 @@ public class Maze {
     /**
      * INTERNAL API. Exists only for deserialization. Not to be called from user code.
      */
-    private Maze(@NotNull final Tile[][] field,
+    private Maze(@NotNull final Tile[][] field, final int width, final int height, @NotNull final Position start, @NotNull final Position end, final long randomSeed) {
-                 final int width,
-                 final int height,
-                 @NotNull final Position start,
-                 @NotNull final Position end,
-                 final long randomSeed) {
         this.field = field;
         this.width = width;
         this.height = height;
@@ -93,25 +80,6 @@ public class Maze {
         this.end = end;
     }
 
-    /**
-     * INTERNAL API. Exists only for deserialization. Not to be called from user code.
-     */
-    private Maze(@NotNull final Tile[][] field,
-                 final int width,
-                 final int height,
-                 @NotNull final Position start,
-                 @NotNull final Position end,
-                 final long randomSeed,
-                 @NotNull final String algorithm) {
-        this.field = field;
-        this.width = width;
-        this.height = height;
-        this.randomSeed = randomSeed;
-        this.algorithm = algorithm;
-        this.start = start;
-        this.end = end;
-    }
-
     @NotNull
     public Option<Tile> getTileAt(@NotNull final Position position) {
         return this.getTileAt(position.x(), position.y());

src/main/java/ch/fritteli/maze/generator/model/Position.java

@@ -1,12 +1,10 @@
 package ch.fritteli.maze.generator.model;
 
-import io.vavr.control.Option;
 import lombok.With;
 import org.jetbrains.annotations.NotNull;
 
 @With
 public record Position(int x, int y) {
-    @NotNull
     public Position move(@NotNull final Direction direction) {
         return switch (direction) {
             case BOTTOM -> this.withY(this.y + 1);
@@ -15,20 +13,4 @@ public record Position(int x, int y) {
             case TOP -> this.withY(this.y - 1);
         };
     }
-
-    @NotNull
-    public Option<Direction> getDirectionTo(@NotNull final Position position) {
-        final int xDiff = position.x - this.x;
-        final int yDiff = position.y - this.y;
-        return switch (xDiff) {
-            case -1 -> Option.when(yDiff == 0, Direction.LEFT);
-            case 0 -> switch (yDiff) {
-                case -1 -> Option.some(Direction.TOP);
-                case 1 -> Option.some(Direction.BOTTOM);
-                default -> Option.none();
-            };
-            case 1 -> Option.when(yDiff == 0, Direction.RIGHT);
-            default -> Option.none();
-        };
-    }
 }

src/main/java/ch/fritteli/maze/generator/model/Tile.java

@@ -1,6 +1,6 @@
 package ch.fritteli.maze.generator.model;
 
-import io.vavr.collection.Vector;
+import io.vavr.collection.Stream;
 import io.vavr.control.Option;
 import lombok.AccessLevel;
 import lombok.EqualsAndHashCode;
@@ -17,7 +17,6 @@ import java.util.Random;
 @ToString
 public class Tile {
     final Walls walls = new Walls();
-    @EqualsAndHashCode.Exclude
     boolean visited = false;
     @Getter
     boolean solution = false;
@@ -66,23 +65,13 @@ public class Tile {
         this.walls.set(direction);
     }
 
-    @NotNull
-    public EnumSet<Direction> getOpenDirections() {
-        return this.walls.getOpen();
-    }
-
-    @NotNull
     public Option<Direction> getRandomAvailableDirection(@NotNull final Random random) {
-        final EnumSet<Direction> availableDirections = this.walls.getUnsealedSet();
+        final Stream<Direction> availableDirections = this.walls.getUnsealedSet();
         if (availableDirections.isEmpty()) {
             return Option.none();
         }
-        if (availableDirections.size() == 1) {
+        final int index = random.nextInt(availableDirections.length());
-            return Option.some(availableDirections.iterator().next());
+        return Option.of(availableDirections.get(index));
-        }
-        final Vector<Direction> directions = Vector.ofAll(availableDirections);
-        final int index = random.nextInt(directions.size());
-        return Option.of(directions.get(index));
     }
 
     public boolean hasWallAt(@NotNull final Direction direction) {

src/main/java/ch/fritteli/maze/generator/model/Walls.java

@@ -1,17 +1,21 @@
 package ch.fritteli.maze.generator.model;
 
+import io.vavr.collection.Stream;
 import lombok.EqualsAndHashCode;
 import lombok.ToString;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.EnumSet;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.SortedSet;
+import java.util.TreeSet;
 
 @EqualsAndHashCode
 @ToString
 public class Walls {
-    private final EnumSet<Direction> directions = EnumSet.noneOf(Direction.class);
+    private final SortedSet<Direction> directions = new TreeSet<>();
-    @EqualsAndHashCode.Exclude
+    private final Set<Direction> sealed = new HashSet<>();
-    private final EnumSet<Direction> sealed = EnumSet.noneOf(Direction.class);
 
     public void set(@NotNull final Direction direction) {
         this.directions.add(direction);
@@ -32,11 +36,9 @@ public class Walls {
         return this.directions.contains(direction);
     }
 
-    @NotNull
+    public Stream<Direction> getUnsealedSet() {
-    public EnumSet<Direction> getUnsealedSet() {
+        return Stream.ofAll(this.directions)
-        final EnumSet<Direction> result = EnumSet.copyOf(this.directions);
+                .removeAll(this.sealed);
-        result.removeAll(this.sealed);
-        return result;
     }
 
     public void seal(@NotNull final Direction direction) {
@@ -49,9 +51,4 @@ public class Walls {
     public void unseal(@NotNull final Direction direction) {
         this.sealed.remove(direction);
     }
-
-    @NotNull
-    public EnumSet<Direction> getOpen() {
-        return EnumSet.complementOf(this.directions);
-    }
 }

src/main/java/ch/fritteli/maze/generator/renderer/html/HTMLRenderer.java

@@ -6,109 +6,108 @@ import org.jetbrains.annotations.NotNull;
 
 public class HTMLRenderer implements Renderer<String> {
 
-    private static final String POSTAMBLE = """
+    private static final String POSTAMBLE = "<script>"
-            <script>
+            + "let userPath = [];"
-            let userPath = [];
+            + "const DIR_UNDEF = -1;"
-            const DIR_UNDEF = -1;
+            + "const DIR_SAME = 0;"
-            const DIR_SAME = 0;
+            + "const DIR_UP = 1;"
-            const DIR_UP = 1;
+            + "const DIR_RIGHT = 2;"
-            const DIR_RIGHT = 2;
+            + "const DIR_DOWN = 3;"
-            const DIR_DOWN = 3;
+            + "const DIR_LEFT = 4;"
-            const DIR_LEFT = 4;
+            + "function getCoords(cell) {"
-            function getCoords(cell) {
+            + "    return {"
-                return {
+            + "        x: cell.cellIndex,"
-                    x: cell.cellIndex,
+            + "        y: cell.parentElement.rowIndex"
-                    y: cell.parentElement.rowIndex
+            + "    };"
-                };
+            + "}"
-            }
+            + "function distance(prev, next) {"
-            function distance(prev, next) {
+            + "    return Math.abs(prev.x - next.x) + Math.abs(prev.y - next.y);"
-                return Math.abs(prev.x - next.x) + Math.abs(prev.y - next.y);
+            + "}"
-            }
+            + "function direction(prev, next) {"
-            function direction(prev, next) {
+            + "    const dist = distance(prev, next);"
-                const dist = distance(prev, next);
+            + "    if (dist === 0) {"
-                if (dist === 0) {
+            + "        return DIR_SAME;"
-                    return DIR_SAME;
+            + "    }"
-                }
+            + "    if (dist !== 1) {"
-                if (dist !== 1) {
+            + "        return DIR_UNDEF;"
-                    return DIR_UNDEF;
+            + "    }"
-                }
+            + "    if (next.x === prev.x) {"
-                if (next.x === prev.x) {
+            + "        if (next.y === prev.y + 1) {"
-                    if (next.y === prev.y + 1) {
+            + "            return DIR_DOWN;"
-                        return DIR_DOWN;
+            + "        }"
-                    }
+            + "        return DIR_UP;"
-                    return DIR_UP;
+            + "    }"
-                }
+            + "    if (next.x === prev.x + 1) {"
-                if (next.x === prev.x + 1) {
+            + "        return DIR_RIGHT;"
-                    return DIR_RIGHT;
+            + "    }"
-                }
+            + "    return DIR_LEFT;"
-                return DIR_LEFT;
+            + "}"
-            }
+            + "(function () {"
-            (function () {
+            + "    const labyrinthTable = document.getElementById(\"labyrinth\");"
-                const labyrinthTable = document.getElementById("labyrinth");
+            + "    const labyrinthCells = labyrinthTable.getElementsByTagName(\"td\");"
-                const labyrinthCells = labyrinthTable.getElementsByTagName("td");
+            + "    const start = {x: 0, y: 0};"
-                const start = {x: 0, y: 0};
+            + "    const end = {"
-                const end = {
+            + "        x: labyrinthTable.getElementsByTagName(\"tr\")[0].getElementsByTagName(\"td\").length - 1,"
-                    x: labyrinthTable.getElementsByTagName("tr")[0].getElementsByTagName("td").length - 1,
+            + "        y: labyrinthTable.getElementsByTagName(\"tr\").length - 1"
-                    y: labyrinthTable.getElementsByTagName("tr").length - 1
+            + "    };"
-                };
+            + "    for (let i = 0; i < labyrinthCells.length; i++) {"
-                for (let i = 0; i < labyrinthCells.length; i++) {
+            + "        let cell = labyrinthCells.item(i);"
-                    let cell = labyrinthCells.item(i);
+            + "        cell.onclick = (event) => {"
-                    cell.onclick = (event) => {
+            + "            let target = event.target;"
-                        let target = event.target;
+            + "            const coords = getCoords(target);"
-                        const coords = getCoords(target);
+            + "            if (coords.x === end.x && coords.y === end.y) {"
-                        if (coords.x === end.x && coords.y === end.y) {
+            + "                alert(\"HOORAY! You did it! Congratulations!\")"
-                            alert("HOORAY! You did it! Congratulations!")
+            + "            }"
-                        }
+            + "            if (userPath.length === 0) {"
-                        if (userPath.length === 0) {
+            + "                if (coords.x === start.x && coords.y === start.y) {"
-                            if (coords.x === start.x && coords.y === start.y) {
+            + "                    userPath.push(coords);"
-                                userPath.push(coords);
+            + "                    target.classList.toggle(\"user\");"
-                                target.classList.toggle("user");
+            + "                }"
-                            }
+            + "            } else {"
-                        } else {
+            + "                const dir = direction(userPath[userPath.length - 1], coords);"
-                            const dir = direction(userPath[userPath.length - 1], coords);
+            + "                switch (dir) {"
-                            switch (dir) {
+            + "                    case DIR_UNDEF:"
-                                case DIR_UNDEF:
+            + "                        return;"
-                                    return;
+            + "                    case DIR_SAME:"
-                                case DIR_SAME:
+            + "                        userPath.pop();"
-                                    userPath.pop();
+            + "                        target.classList.toggle(\"user\");"
-                                    target.classList.toggle("user");
+            + "                        return;"
-                                    return;
+            + "                    default:"
-                                default:
+            + "                        if (userPath.find(value => value.x === coords.x && value.y === coords.y)) {"
-                                    if (userPath.find(value => value.x === coords.x && value.y === coords.y)) {
+            + "                            return;"
-                                        return;
+            + "                        } else {"
-                                    } else {
+            + "                            switch (dir) {"
-                                        switch (dir) {
+            + "                                case DIR_UP:"
-                                            case DIR_UP:
+            + "                                    if (target.classList.contains(\"bottom\")) {"
-                                                if (target.classList.contains("bottom")) {
+            + "                                        return;"
-                                                    return;
+            + "                                    }"
-                                                }
+            + "                                    break;"
-                                                break;
+            + "                                case DIR_RIGHT:"
-                                            case DIR_RIGHT:
+            + "                                    if (target.classList.contains(\"left\")) {"
-                                                if (target.classList.contains("left")) {
+            + "                                        return;"
-                                                    return;
+            + "                                    }"
-                                                }
+            + "                                    break;"
-                                                break;
+            + "                                case DIR_DOWN:"
-                                            case DIR_DOWN:
+            + "                                    if (target.classList.contains(\"top\")) {"
-                                                if (target.classList.contains("top")) {
+            + "                                        return;"
-                                                    return;
+            + "                                    }"
-                                                }
+            + "                                    break;"
-                                                break;
+            + "                                case DIR_LEFT:"
-                                            case DIR_LEFT:
+            + "                                    if (target.classList.contains(\"right\")) {"
-                                                if (target.classList.contains("right")) {
+            + "                                        return;"
-                                                    return;
+            + "                                    }"
-                                                }
+            + "                                    break;"
-                                                break;
+            + "                            }"
-                                        }
+            + "                            userPath.push(coords);"
-                                        userPath.push(coords);
+            + "                            target.classList.toggle(\"user\");"
-                                        target.classList.toggle("user");
+            + "                            return;"
-                                        return;
+            + "                        }"
-                                    }
+            + "                }"
-                            }
+            + "            }"
-                        }
+            + "        };"
-                    };
+            + "    }"
-                }
+            + "})();"
-            })();
+            + "</script></body></html>";
-            </script></body></html>""";
 
     private HTMLRenderer() {
     }
@@ -136,42 +135,33 @@ public class HTMLRenderer implements Renderer<String> {
     }
 
     private String getPreamble(@NotNull final Maze maze) {
-        return """
+        return "<!DOCTYPE html><html lang=\"en\">" +
-                <!DOCTYPE html>
+                "<head>" +
-                <html lang="en">
+                "<title>Maze " + maze.getWidth() + "x" + maze.getHeight() + ", ID " + maze.getRandomSeed() + "</title>" +
-                    <head>
+                "<meta charset=\"utf-8\">" +
-                        <title>Maze %dx%d, ID %d, Algorithm %s</title>
+                "<style>" +
-                        <meta charset="utf-8">
+                "table{border-collapse:collapse;}" +
-                        <style>
+                "td{border:0 solid black;height:1em;width:1em;cursor:pointer;}" +
-                            table{border-collapse:collapse;}
+                "td.top{border-top-width:1px;}" +
-                            td{border:0 solid black;height:1em;width:1em;cursor:pointer;}
+                "td.right{border-right-width:1px;}" +
-                            td.top{border-top-width:1px;}
+                "td.bottom{border-bottom-width:1px;}" +
-                            td.right{border-right-width:1px;}
+                "td.left{border-left-width:1px;}" +
-                            td.bottom{border-bottom-width:1px;}
+                "td.user{background:hotpink;}" +
-                            td.left{border-left-width:1px;}
+                "</style>" +
-                            td.user{background:hotpink;}
+                "<script>" +
-                        </style>
+                "let solution = false;" +
-                        <script>
+                "function toggleSolution() {" +
-                            let solution = false;
+                "let stylesheet = document.styleSheets[0];" +
-                            function toggleSolution() {
+                "if(solution){" +
-                                let stylesheet = document.styleSheets[0];
+                "stylesheet.deleteRule(0);" +
-                                if (solution) {
+                "}else{" +
-                                    stylesheet.deleteRule(0);
+                "stylesheet.insertRule(\"td.solution{background-color:lightgray;}\", 0);" +
-                                } else {
+                "}" +
-                                    stylesheet.insertRule("td.solution{background-color:lightgray;}", 0);
+                "solution = !solution;" +
-                                }
+                "}" +
-                                solution = !solution;
+                "</script>" +
-                            }
+                "</head>" +
-                        </script>
+                "<body>" +
-                    </head>
+                "<input id=\"solutionbox\" type=\"checkbox\" onclick=\"toggleSolution()\"/><label for=\"solutionbox\">show solution</label>";
-                    <body>
-                        <input id="solutionbox" type="checkbox" onclick="toggleSolution()"/>
-                        <label for="solutionbox">show solution</label>"""
-                .formatted(
-                        maze.getWidth(),
-                        maze.getHeight(),
-                        maze.getRandomSeed(),
-                        maze.getAlgorithm()
-                );
     }
 }

src/main/java/ch/fritteli/maze/generator/renderer/json/Generator.java

@@ -23,7 +23,6 @@ class Generator {
     JsonMaze generate() {
         final JsonMaze result = new JsonMaze();
         result.setId(String.valueOf(this.maze.getRandomSeed()));
-        result.setAlgorithm(this.maze.getAlgorithm());
         result.setWidth(this.maze.getWidth());
         result.setHeight(this.maze.getHeight());
         final List<List<JsonCell>> rows = new ArrayList<>();

src/main/java/ch/fritteli/maze/generator/renderer/pdf/Generator.java

@@ -34,7 +34,7 @@ class Generator {
 
         final PDDocument pdDocument = new PDDocument();
         final PDDocumentInformation info = new PDDocumentInformation();
-        info.setTitle("Maze %sx%s, ID %s (%s)".formatted(this.maze.getWidth(), this.maze.getHeight(), this.maze.getRandomSeed(), this.maze.getAlgorithm()));
+        info.setTitle("Maze %sx%s, ID %s".formatted(this.maze.getWidth(), this.maze.getHeight(), this.maze.getRandomSeed()));
         pdDocument.setDocumentInformation(info);
         final PDPage puzzlePage = new PDPage(new PDRectangle(pageWidth, pageHeight));
         final PDPage solutionPage = new PDPage(new PDRectangle(pageWidth, pageHeight));
@@ -233,7 +233,7 @@ class Generator {
                 if (position.equals(previousPosition)) {
                     continue;
                 }
-                if (tileAtPosition.exists(Tile::isSolution)) {
+                if (tileAtPosition.map(Tile::isSolution).getOrElse(false)) {
                     return position;
                 }
             }

src/main/java/ch/fritteli/maze/generator/serialization/AbstractMazeInputStream.java

@@ -4,7 +4,6 @@ import ch.fritteli.maze.generator.model.Maze;
 import org.jetbrains.annotations.NotNull;
 
 import java.io.ByteArrayInputStream;
-import java.io.IOException;
 
 public abstract class AbstractMazeInputStream extends ByteArrayInputStream {
 
@@ -15,7 +14,7 @@ public abstract class AbstractMazeInputStream extends ByteArrayInputStream {
     public abstract void checkHeader();
 
     @NotNull
-    public abstract Maze readMazeData() throws IOException;
+    public abstract Maze readMazeData();
 
     public byte readByte() {
         final int read = this.read();
@@ -26,10 +25,6 @@ public abstract class AbstractMazeInputStream extends ByteArrayInputStream {
         return (byte) read;
     }
 
-    public int readByteAsInt() {
-        return 0xff & this.readByte();
-    }
-
     public int readInt() {
         int result = 0;
         result |= (0xff & this.readByte()) << 24;

src/main/java/ch/fritteli/maze/generator/serialization/CommonTileHandler.java

@@ -1,100 +0,0 @@
-package ch.fritteli.maze.generator.serialization;
-
-import ch.fritteli.maze.generator.model.Direction;
-import ch.fritteli.maze.generator.model.Tile;
-import lombok.experimental.UtilityClass;
-import org.jetbrains.annotations.NotNull;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.EnumSet;
-
-
-/**
- * Binary format description of a {@link Tile}.<br>
- * A tile is stored in one byte:
- * <ul>
- *     <li>bits 0..2: always 0</li>
- *     <li>bit 3: 1=solution, 0=not solution</li>
- *     <li>bits 4..7: encode walls</li>
- * </ul>
- * The values for bits 4..7 are as follows:
- * <pre>
- * decimal hex bin  border
- *       0   0 0000 no border
- *       1   1 0001 top
- *       2   2 0010 right
- *       3   3 0011 top+right
- *       4   4 0100 bottom
- *       5   5 0101 top+bottom
- *       6   6 0110 right+bottom
- *       7   7 0111 top+right+bottom
- *       8   8 1000 left
- *       9   9 1001 top+left
- *      10   a 1010 right+left
- *      11   b 1011 top+right+left
- *      12   c 1100 bottom+left
- *      13   d 1101 top+bottom+left
- *      14   e 1110 right+bottom+left
- *      15   f 1111 top+right+bottom+left
- * </pre>
- */
-@UtilityClass
-public class CommonTileHandler {
-    private final byte TOP_BIT = 0b0000_0001;
-    private final byte RIGHT_BIT = 0b0000_0010;
-    private final byte BOTTOM_BIT = 0b0000_0100;
-    private final byte LEFT_BIT = 0b0000_1000;
-    private final byte SOLUTION_BIT = 0b0001_0000;
-
-    public byte getBitmaskForTile(@NotNull final Tile tile) {
-        byte bitmask = 0;
-        if (tile.hasWallAt(Direction.TOP)) {
-            bitmask |= TOP_BIT;
-        }
-        if (tile.hasWallAt(Direction.RIGHT)) {
-            bitmask |= RIGHT_BIT;
-        }
-        if (tile.hasWallAt(Direction.BOTTOM)) {
-            bitmask |= BOTTOM_BIT;
-        }
-        if (tile.hasWallAt((Direction.LEFT))) {
-            bitmask |= LEFT_BIT;
-        }
-        if (tile.isSolution()) {
-            bitmask |= SOLUTION_BIT;
-        }
-        return bitmask;
-    }
-
-    @NotNull
-    public Tile getTileForBitmask(final byte bitmask) {
-        final EnumSet<Direction> walls = EnumSet.noneOf(Direction.class);
-        if ((bitmask & TOP_BIT) == TOP_BIT) {
-            walls.add(Direction.TOP);
-        }
-        if ((bitmask & RIGHT_BIT) == RIGHT_BIT) {
-            walls.add(Direction.RIGHT);
-        }
-        if ((bitmask & BOTTOM_BIT) == BOTTOM_BIT) {
-            walls.add(Direction.BOTTOM);
-        }
-        if ((bitmask & LEFT_BIT) == LEFT_BIT) {
-            walls.add(Direction.LEFT);
-        }
-        final boolean solution = (bitmask & SOLUTION_BIT) == SOLUTION_BIT;
-        return createTile(walls, solution);
-    }
-
-    @NotNull
-    private Tile createTile(@NotNull final EnumSet<Direction> walls, boolean solution) {
-        try {
-            final Constructor<Tile> constructor = Tile.class.getDeclaredConstructor(EnumSet.class, Boolean.TYPE);
-            constructor.setAccessible(true);
-            return constructor.newInstance(walls, solution);
-        } catch (@NotNull final NoSuchMethodException | InstantiationException | IllegalAccessException |
-                                InvocationTargetException e) {
-            throw new RuntimeException("Can not deserialize Tile from maze data.", e);
-        }
-    }
-}

src/main/java/ch/fritteli/maze/generator/serialization/MazeConstants.java

@@ -1,9 +0,0 @@
-package ch.fritteli.maze.generator.serialization;
-
-import lombok.experimental.UtilityClass;
-
-@UtilityClass
-public class MazeConstants {
-    public final byte MAGIC_BYTE_1 = 0x1a;
-    public final byte MAGIC_BYTE_2 = (byte) 0xb1;
-}

src/main/java/ch/fritteli/maze/generator/serialization/v1/MazeInputStreamV1.java

@@ -3,8 +3,6 @@ package ch.fritteli.maze.generator.serialization.v1;
 import ch.fritteli.maze.generator.model.Maze;
 import ch.fritteli.maze.generator.model.Tile;
 import ch.fritteli.maze.generator.serialization.AbstractMazeInputStream;
-import ch.fritteli.maze.generator.serialization.CommonTileHandler;
-import ch.fritteli.maze.generator.serialization.MazeConstants;
 import org.jetbrains.annotations.NotNull;
 
 public class MazeInputStreamV1 extends AbstractMazeInputStream {
@@ -15,15 +13,12 @@ public class MazeInputStreamV1 extends AbstractMazeInputStream {
 
     @Override
     public void checkHeader() {
-        // 00 0x1a magic
-        // 01 0xb1 magic
-        // 02 0x01 version
         final byte magic1 = this.readByte();
-        if (magic1 != MazeConstants.MAGIC_BYTE_1) {
+        if (magic1 != SerializerDeserializerV1.MAGIC_BYTE_1) {
             throw new IllegalArgumentException("Invalid maze data.");
         }
         final byte magic2 = this.readByte();
-        if (magic2 != MazeConstants.MAGIC_BYTE_2) {
+        if (magic2 != SerializerDeserializerV1.MAGIC_BYTE_2) {
             throw new IllegalArgumentException("Invalid maze data.");
         }
         final int version = this.readByte();
@@ -35,10 +30,6 @@ public class MazeInputStreamV1 extends AbstractMazeInputStream {
     @NotNull
     @Override
     public Maze readMazeData() {
-        // 03..10  random seed number (long)
-        // 11..14  width (int)
-        // 15..18  height (int)
-        // 19..    tiles
         final long randomSeed = this.readLong();
         final int width = this.readInt();
         final int height = this.readInt();
@@ -51,7 +42,7 @@ public class MazeInputStreamV1 extends AbstractMazeInputStream {
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
                 final byte bitmask = this.readByte();
-                tiles[x][y] = CommonTileHandler.getTileForBitmask(bitmask);
+                tiles[x][y] = SerializerDeserializerV1.getTileForBitmask(bitmask);
             }
         }
 

src/main/java/ch/fritteli/maze/generator/serialization/v1/MazeOutputStreamV1.java

@@ -3,28 +3,19 @@ package ch.fritteli.maze.generator.serialization.v1;
 import ch.fritteli.maze.generator.model.Maze;
 import ch.fritteli.maze.generator.model.Tile;
 import ch.fritteli.maze.generator.serialization.AbstractMazeOutputStream;
-import ch.fritteli.maze.generator.serialization.CommonTileHandler;
-import ch.fritteli.maze.generator.serialization.MazeConstants;
 import org.jetbrains.annotations.NotNull;
 
 public class MazeOutputStreamV1 extends AbstractMazeOutputStream {
 
     @Override
     public void writeHeader() {
-        // 00 0x1a magic
+        this.writeByte(SerializerDeserializerV1.MAGIC_BYTE_1);
-        // 01 0xb1 magic
+        this.writeByte(SerializerDeserializerV1.MAGIC_BYTE_2);
-        // 02 0x02 version
-        this.writeByte(MazeConstants.MAGIC_BYTE_1);
-        this.writeByte(MazeConstants.MAGIC_BYTE_2);
         this.writeByte(SerializerDeserializerV1.VERSION_BYTE);
     }
 
     @Override
     public void writeMazeData(@NotNull final Maze maze) {
-        // 03..10  random seed number (long)
-        // 11..14  width (int)
-        // 15..18  height (int)
-        // 19..    tiles
         final long randomSeed = maze.getRandomSeed();
         final int width = maze.getWidth();
         final int height = maze.getHeight();
@@ -36,7 +27,7 @@ public class MazeOutputStreamV1 extends AbstractMazeOutputStream {
             for (int x = 0; x < width; x++) {
                 // We .get() it, because we want to crash hard if it is not available.
                 final Tile tile = maze.getTileAt(x, y).get();
-                final byte bitmask = CommonTileHandler.getBitmaskForTile(tile);
+                final byte bitmask = SerializerDeserializerV1.getBitmaskForTile(tile);
                 this.writeByte(bitmask);
             }
         }

src/main/java/ch/fritteli/maze/generator/serialization/v1/SerializerDeserializerV1.java

@@ -1,5 +1,6 @@
 package ch.fritteli.maze.generator.serialization.v1;
 
+import ch.fritteli.maze.generator.model.Direction;
 import ch.fritteli.maze.generator.model.Maze;
 import ch.fritteli.maze.generator.model.Tile;
 import lombok.experimental.UtilityClass;
@@ -7,24 +8,53 @@ import org.jetbrains.annotations.NotNull;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
+import java.util.EnumSet;
 
 /**
- * Header bytes are:
+ * <pre>
+ * decimal hex bin  border
+ *       0   0 0000 no border
+ *       1   1 0001 top
+ *       2   2 0010 right
+ *       3   3 0011 top+right
+ *       4   4 0100 bottom
+ *       5   5 0101 top+bottom
+ *       6   6 0110 right+bottom
+ *       7   7 0111 top+right+bottom
+ *       8   8 1000 left
+ *       9   9 1001 top+left
+ *      10   a 1010 right+left
+ *      11   b 1011 top+right+left
+ *      12   c 1100 bottom+left
+ *      13   d 1101 top+bottom+left
+ *      14   e 1110 right+bottom+left
+ *      15   f 1111 top+right+bottom+left
+ * </pre>
+ * ==&gt; bits 0..2: always 0; bit 3: 1=solution, 0=not solution; bits 4..7: encode walls
+ * ==&gt; first bytes are:
  * <pre>
  *   byte  hex meaning
  *     00 0x1a magic
  *     01 0xb1 magic
  *     02 0x01 version (0x00 -> dev, 0x01 -> stable)
- * 03..10      random seed number (long)
+ * 03..06      width (int)
- * 11..14      width (int)
+ * 07..10      height (int)
- * 15..18      height (int)
+ * 11..18      random seed number (long)
  * 19..        tiles
  * </pre>
  * Extraneous space (poss. last nibble) is ignored.
  */
 @UtilityClass
 public class SerializerDeserializerV1 {
-    public final byte VERSION_BYTE = 0x01;
+    final byte MAGIC_BYTE_1 = 0x1a;
+    final byte MAGIC_BYTE_2 = (byte) 0xb1;
+    final byte VERSION_BYTE = 0x01;
+
+    private final byte TOP_BIT = 0b0000_0001;
+    private final byte RIGHT_BIT = 0b0000_0010;
+    private final byte BOTTOM_BIT = 0b0000_0100;
+    private final byte LEFT_BIT = 0b0000_1000;
+    private final byte SOLUTION_BIT = 0b0001_0000;
 
     /**
      * Serializes the {@code maze} into a byte array.
@@ -64,4 +94,55 @@ public class SerializerDeserializerV1 {
             throw new RuntimeException("Can not deserialize Maze from maze data.", e);
         }
     }
+
+    @NotNull
+    private Tile createTile(@NotNull final EnumSet<Direction> walls, boolean solution) {
+        try {
+            final Constructor<Tile> constructor = Tile.class.getDeclaredConstructor(EnumSet.class, Boolean.TYPE);
+            constructor.setAccessible(true);
+            return constructor.newInstance(walls, solution);
+        } catch (@NotNull final NoSuchMethodException | InstantiationException | IllegalAccessException |
+                                InvocationTargetException e) {
+            throw new RuntimeException("Can not deserialize Tile from maze data.", e);
+        }
+    }
+
+    byte getBitmaskForTile(@NotNull final Tile tile) {
+        byte bitmask = 0;
+        if (tile.hasWallAt(Direction.TOP)) {
+            bitmask |= TOP_BIT;
+        }
+        if (tile.hasWallAt(Direction.RIGHT)) {
+            bitmask |= RIGHT_BIT;
+        }
+        if (tile.hasWallAt(Direction.BOTTOM)) {
+            bitmask |= BOTTOM_BIT;
+        }
+        if (tile.hasWallAt((Direction.LEFT))) {
+            bitmask |= LEFT_BIT;
+        }
+        if (tile.isSolution()) {
+            bitmask |= SOLUTION_BIT;
+        }
+        return bitmask;
+    }
+
+    @NotNull
+    Tile getTileForBitmask(final byte bitmask) {
+        final EnumSet<Direction> walls = EnumSet.noneOf(Direction.class);
+        if ((bitmask & TOP_BIT) == TOP_BIT) {
+            walls.add(Direction.TOP);
+        }
+        if ((bitmask & RIGHT_BIT) == RIGHT_BIT) {
+            walls.add(Direction.RIGHT);
+        }
+        if ((bitmask & BOTTOM_BIT) == BOTTOM_BIT) {
+            walls.add(Direction.BOTTOM);
+        }
+        if ((bitmask & LEFT_BIT) == LEFT_BIT) {
+            walls.add(Direction.LEFT);
+        }
+        final boolean solution = (bitmask & SOLUTION_BIT) == SOLUTION_BIT;
+        return createTile(walls, solution);
+    }
 }

src/main/java/ch/fritteli/maze/generator/serialization/v2/MazeInputStreamV2.java

@@ -4,8 +4,6 @@ import ch.fritteli.maze.generator.model.Maze;
 import ch.fritteli.maze.generator.model.Position;
 import ch.fritteli.maze.generator.model.Tile;
 import ch.fritteli.maze.generator.serialization.AbstractMazeInputStream;
-import ch.fritteli.maze.generator.serialization.CommonTileHandler;
-import ch.fritteli.maze.generator.serialization.MazeConstants;
 import org.jetbrains.annotations.NotNull;
 
 public class MazeInputStreamV2 extends AbstractMazeInputStream {
@@ -20,11 +18,11 @@ public class MazeInputStreamV2 extends AbstractMazeInputStream {
         // 01 0xb1 magic
         // 02 0x02 version
         final byte magic1 = this.readByte();
-        if (magic1 != MazeConstants.MAGIC_BYTE_1) {
+        if (magic1 != SerializerDeserializerV2.MAGIC_BYTE_1) {
             throw new IllegalArgumentException("Invalid maze data.");
         }
         final byte magic2 = this.readByte();
-        if (magic2 != MazeConstants.MAGIC_BYTE_2) {
+        if (magic2 != SerializerDeserializerV2.MAGIC_BYTE_2) {
             throw new IllegalArgumentException("Invalid maze data.");
         }
         final int version = this.readByte();
@@ -60,7 +58,7 @@ public class MazeInputStreamV2 extends AbstractMazeInputStream {
         for (int y = 0; y < height; y++) {
             for (int x = 0; x < width; x++) {
                 final byte bitmask = this.readByte();
-                tiles[x][y] = CommonTileHandler.getTileForBitmask(bitmask);
+                tiles[x][y] = SerializerDeserializerV2.getTileForBitmask(bitmask);
             }
         }
 

src/main/java/ch/fritteli/maze/generator/serialization/v2/MazeOutputStreamV2.java

@@ -4,8 +4,6 @@ import ch.fritteli.maze.generator.model.Maze;
 import ch.fritteli.maze.generator.model.Position;
 import ch.fritteli.maze.generator.model.Tile;
 import ch.fritteli.maze.generator.serialization.AbstractMazeOutputStream;
-import ch.fritteli.maze.generator.serialization.CommonTileHandler;
-import ch.fritteli.maze.generator.serialization.MazeConstants;
 import org.jetbrains.annotations.NotNull;
 
 public class MazeOutputStreamV2 extends AbstractMazeOutputStream {
@@ -15,8 +13,8 @@ public class MazeOutputStreamV2 extends AbstractMazeOutputStream {
         // 00 0x1a magic
         // 01 0xb1 magic
         // 02 0x02 version
-        this.writeByte(MazeConstants.MAGIC_BYTE_1);
+        this.writeByte(SerializerDeserializerV2.MAGIC_BYTE_1);
-        this.writeByte(MazeConstants.MAGIC_BYTE_2);
+        this.writeByte(SerializerDeserializerV2.MAGIC_BYTE_2);
         this.writeByte(SerializerDeserializerV2.VERSION_BYTE);
     }
 
@@ -47,7 +45,7 @@ public class MazeOutputStreamV2 extends AbstractMazeOutputStream {
             for (int x = 0; x < width; x++) {
                 // We .get() it, because we want to crash hard if it is not available.
                 final Tile tile = maze.getTileAt(x, y).get();
-                final byte bitmask = CommonTileHandler.getBitmaskForTile(tile);
+                final byte bitmask = SerializerDeserializerV2.getBitmaskForTile(tile);
                 this.writeByte(bitmask);
             }
         }

src/main/java/ch/fritteli/maze/generator/serialization/v2/SerializerDeserializerV2.java

@@ -1,5 +1,6 @@
 package ch.fritteli.maze.generator.serialization.v2;
 
+import ch.fritteli.maze.generator.model.Direction;
 import ch.fritteli.maze.generator.model.Maze;
 import ch.fritteli.maze.generator.model.Position;
 import ch.fritteli.maze.generator.model.Tile;
@@ -8,9 +9,29 @@ import org.jetbrains.annotations.NotNull;
 
 import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
+import java.util.EnumSet;
 
 /**
- * Header bytes are:
+ * <pre>
+ * decimal hex bin  border
+ *       0   0 0000 no border
+ *       1   1 0001 top
+ *       2   2 0010 right
+ *       3   3 0011 top+right
+ *       4   4 0100 bottom
+ *       5   5 0101 top+bottom
+ *       6   6 0110 right+bottom
+ *       7   7 0111 top+right+bottom
+ *       8   8 1000 left
+ *       9   9 1001 top+left
+ *      10   a 1010 right+left
+ *      11   b 1011 top+right+left
+ *      12   c 1100 bottom+left
+ *      13   d 1101 top+bottom+left
+ *      14   e 1110 right+bottom+left
+ *      15   f 1111 top+right+bottom+left
+ * </pre>
+ * ==&gt; bits 0..2: always 0; bit 3: 1=solution, 0=not solution; bits 4..7: encode walls ==&gt; first bytes are:
  * <pre>
  *   byte  hex meaning
  *     00 0x1a magic
@@ -29,7 +50,16 @@ import java.lang.reflect.InvocationTargetException;
  */
 @UtilityClass
 public class SerializerDeserializerV2 {
-    public final byte VERSION_BYTE = 0x02;
+
+    final byte MAGIC_BYTE_1 = 0x1a;
+    final byte MAGIC_BYTE_2 = (byte) 0xb1;
+    final byte VERSION_BYTE = 0x02;
+
+    private final byte TOP_BIT = 0b0000_0001;
+    private final byte RIGHT_BIT = 0b0000_0010;
+    private final byte BOTTOM_BIT = 0b0000_0100;
+    private final byte LEFT_BIT = 0b0000_1000;
+    private final byte SOLUTION_BIT = 0b0001_0000;
 
     /**
      * Serializes the {@code maze} into a byte array.
@@ -69,4 +99,55 @@ public class SerializerDeserializerV2 {
             throw new RuntimeException("Can not deserialize Maze from maze data.", e);
         }
     }
+
+    @NotNull
+    private Tile createTile(@NotNull final EnumSet<Direction> walls, boolean solution) {
+        try {
+            final Constructor<Tile> constructor = Tile.class.getDeclaredConstructor(EnumSet.class, Boolean.TYPE);
+            constructor.setAccessible(true);
+            return constructor.newInstance(walls, solution);
+        } catch (@NotNull final NoSuchMethodException | InstantiationException | IllegalAccessException |
+                                InvocationTargetException e) {
+            throw new RuntimeException("Can not deserialize Tile from maze data.", e);
+        }
+    }
+
+    byte getBitmaskForTile(@NotNull final Tile tile) {
+        byte bitmask = 0;
+        if (tile.hasWallAt(Direction.TOP)) {
+            bitmask |= TOP_BIT;
+        }
+        if (tile.hasWallAt(Direction.RIGHT)) {
+            bitmask |= RIGHT_BIT;
+        }
+        if (tile.hasWallAt(Direction.BOTTOM)) {
+            bitmask |= BOTTOM_BIT;
+        }
+        if (tile.hasWallAt((Direction.LEFT))) {
+            bitmask |= LEFT_BIT;
+        }
+        if (tile.isSolution()) {
+            bitmask |= SOLUTION_BIT;
+        }
+        return bitmask;
+    }
+
+    @NotNull
+    Tile getTileForBitmask(final byte bitmask) {
+        final EnumSet<Direction> walls = EnumSet.noneOf(Direction.class);
+        if ((bitmask & TOP_BIT) == TOP_BIT) {
+            walls.add(Direction.TOP);
+        }
+        if ((bitmask & RIGHT_BIT) == RIGHT_BIT) {
+            walls.add(Direction.RIGHT);
+        }
+        if ((bitmask & BOTTOM_BIT) == BOTTOM_BIT) {
+            walls.add(Direction.BOTTOM);
+        }
+        if ((bitmask & LEFT_BIT) == LEFT_BIT) {
+            walls.add(Direction.LEFT);
+        }
+        final boolean solution = (bitmask & SOLUTION_BIT) == SOLUTION_BIT;
+        return createTile(walls, solution);
+    }
 }

src/main/java/ch/fritteli/maze/generator/serialization/v3/MazeInputStreamV3.java

@@ -1,79 +0,0 @@
-package ch.fritteli.maze.generator.serialization.v3;
-
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.model.Position;
-import ch.fritteli.maze.generator.model.Tile;
-import ch.fritteli.maze.generator.serialization.AbstractMazeInputStream;
-import ch.fritteli.maze.generator.serialization.CommonTileHandler;
-import ch.fritteli.maze.generator.serialization.MazeConstants;
-import org.jetbrains.annotations.NotNull;
-
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-
-public class MazeInputStreamV3 extends AbstractMazeInputStream {
-
-    public MazeInputStreamV3(@NotNull final byte[] buf) {
-        super(buf);
-    }
-
-    @Override
-    public void checkHeader() {
-        // 00 0x1a magic
-        // 01 0xb1 magic
-        // 02 0x03 version
-        final byte magic1 = this.readByte();
-        if (magic1 != MazeConstants.MAGIC_BYTE_1) {
-            throw new IllegalArgumentException("Invalid maze data.");
-        }
-        final byte magic2 = this.readByte();
-        if (magic2 != MazeConstants.MAGIC_BYTE_2) {
-            throw new IllegalArgumentException("Invalid maze data.");
-        }
-        final int version = this.readByte();
-        if (version != SerializerDeserializerV3.VERSION_BYTE) {
-            throw new IllegalArgumentException("Unknown maze data version: " + version);
-        }
-    }
-
-    @NotNull
-    @Override
-    public Maze readMazeData() throws IOException {
-        // 03..06   width (int)
-        // 07..10   height (int)
-        // 11..14   start-x (int)
-        // 15..18   start-y (int)
-        // 19..22   end-x (int)
-        // 23..26   end-y (int)
-        // 27..34   random seed number (long)
-        // 35       length of the algorithm's name (unsigned byte)
-        // 36..+len name (bytes of String)
-        // +len+1.. tiles
-        final int width = this.readInt();
-        final int height = this.readInt();
-        final int startX = this.readInt();
-        final int startY = this.readInt();
-        final int endX = this.readInt();
-        final int endY = this.readInt();
-        final long randomSeed = this.readLong();
-        final int algorithmLength = this.readByteAsInt();
-
-        final String algorithm = new String(this.readNBytes(algorithmLength), StandardCharsets.UTF_8);
-
-        final Tile[][] tiles = new Tile[width][height];
-        for (int x = 0; x < width; x++) {
-            tiles[x] = new Tile[height];
-        }
-
-        for (int y = 0; y < height; y++) {
-            for (int x = 0; x < width; x++) {
-                final byte bitmask = this.readByte();
-                tiles[x][y] = CommonTileHandler.getTileForBitmask(bitmask);
-            }
-        }
-
-        final Position start = new Position(startX, startY);
-        final Position end = new Position(endX, endY);
-        return SerializerDeserializerV3.createMaze(tiles, width, height, start, end, randomSeed, algorithm);
-    }
-}

src/main/java/ch/fritteli/maze/generator/serialization/v3/MazeOutputStreamV3.java

@@ -1,86 +0,0 @@
-package ch.fritteli.maze.generator.serialization.v3;
-
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.model.Position;
-import ch.fritteli.maze.generator.model.Tile;
-import ch.fritteli.maze.generator.serialization.AbstractMazeOutputStream;
-import ch.fritteli.maze.generator.serialization.CommonTileHandler;
-import ch.fritteli.maze.generator.serialization.MazeConstants;
-import org.jetbrains.annotations.NotNull;
-
-import java.nio.charset.StandardCharsets;
-
-public class MazeOutputStreamV3 extends AbstractMazeOutputStream {
-
-    @Override
-    public void writeHeader() {
-        // 00 0x1a magic
-        // 01 0xb1 magic
-        // 02 0x03 version
-        this.writeByte(MazeConstants.MAGIC_BYTE_1);
-        this.writeByte(MazeConstants.MAGIC_BYTE_2);
-        this.writeByte(SerializerDeserializerV3.VERSION_BYTE);
-    }
-
-    @Override
-    public void writeMazeData(@NotNull final Maze maze) {
-        // 03..06   width (int)
-        // 07..10   height (int)
-        // 11..14   start-x (int)
-        // 15..18   start-y (int)
-        // 19..22   end-x (int)
-        // 23..26   end-y (int)
-        // 27..34   random seed number (long)
-        // 35       length of the algorithm's name (unsigned byte)
-        // 36..+len name (bytes of String)
-        // +len+1.. tiles
-        final long randomSeed = maze.getRandomSeed();
-        final AlgorithmWrapper algorithm = this.getAlgorithmWrapper(maze.getAlgorithm());
-        final int width = maze.getWidth();
-        final int height = maze.getHeight();
-        final Position start = maze.getStart();
-        final Position end = maze.getEnd();
-        this.writeInt(width);
-        this.writeInt(height);
-        this.writeInt(start.x());
-        this.writeInt(start.y());
-        this.writeInt(end.x());
-        this.writeInt(end.y());
-        this.writeLong(randomSeed);
-        this.writeByte(algorithm.length());
-        this.writeBytes(algorithm.name());
-
-        for (int y = 0; y < height; y++) {
-            for (int x = 0; x < width; x++) {
-                // We .get() it, because we want to crash hard if it is not available.
-                final Tile tile = maze.getTileAt(x, y).get();
-                final byte bitmask = CommonTileHandler.getBitmaskForTile(tile);
-                this.writeByte(bitmask);
-            }
-        }
-    }
-
-    @NotNull
-    private AlgorithmWrapper getAlgorithmWrapper(@NotNull final String algorithm) {
-        final byte[] bytes = algorithm.getBytes(StandardCharsets.UTF_8);
-        if (bytes.length < 256) {
-            // Phew, that's the easy case!
-            return new AlgorithmWrapper(bytes, (byte) bytes.length);
-        }
-
-        // Let's use a very primitive, brute-force approach
-        int strLen = Math.min(255, algorithm.length());
-        int len;
-        byte[] name;
-        do {
-            name = algorithm.substring(0, strLen).getBytes(StandardCharsets.UTF_8);
-            len = name.length;
-            strLen--;
-        } while (len > 255);
-
-        return new AlgorithmWrapper(name, (byte) len);
-    }
-
-    private record AlgorithmWrapper(@NotNull byte[] name, byte length) {
-    }
-}

src/main/java/ch/fritteli/maze/generator/serialization/v3/SerializerDeserializerV3.java

@@ -1,89 +0,0 @@
-package ch.fritteli.maze.generator.serialization.v3;
-
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.model.Position;
-import ch.fritteli.maze.generator.model.Tile;
-import lombok.experimental.UtilityClass;
-import org.jetbrains.annotations.NotNull;
-
-import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-/**
- * Header bytes are:
- * <pre>
- *   byte     hex    meaning
- *     00     0x1a   magic
- *     01     0xb1   magic
- *     02     0x03   version (0x00 -> dev, 0x01, 0x02 -> deprecated, 0x03 -> stable)
- *     03..06        width (int)
- *     07..10        height (int)
- *     11..14        start-x (int)
- *     15..18        start-y (int)
- *     19..22        end-x (int)
- *     23..26        end-y (int)
- *     27..34        random seed number (long)
- *     35            length of the algorithm's name (number of bytes of the Java String) (unsigned byte)
- *     36..(36+len)  algorithm's name (bytes of the Java String) (byte...)
- *     36+len+1..    tiles
- * </pre>
- * Extraneous space (poss. last nibble) is ignored.
- */
-@UtilityClass
-public class SerializerDeserializerV3 {
-    public final byte VERSION_BYTE = 0x03;
-
-    /**
-     * Serializes the {@code maze} into a byte array.
-     *
-     * @param maze The {@link Maze} to be serialized.
-     * @return The resulting byte array.
-     */
-    @NotNull
-    public byte[] serialize(@NotNull final Maze maze) {
-        final MazeOutputStreamV3 stream = new MazeOutputStreamV3();
-        stream.writeHeader();
-        stream.writeMazeData(maze);
-        return stream.toByteArray();
-    }
-
-    /**
-     * Deserializes the byte array into an instance of {@link Maze}.
-     *
-     * @param bytes The byte array to be deserialized.
-     * @return An instance of {@link Maze}.
-     */
-    @NotNull
-    public Maze deserialize(@NotNull final byte[] bytes) throws IOException {
-        final MazeInputStreamV3 stream = new MazeInputStreamV3(bytes);
-        stream.checkHeader();
-        return stream.readMazeData();
-    }
-
-    @NotNull
-    Maze createMaze(@NotNull final Tile[][] field,
-                    final int width,
-                    final int height,
-                    @NotNull final Position start,
-                    @NotNull final Position end,
-                    final long randomSeed,
-                    @NotNull final String algorithm) {
-        try {
-            final Constructor<Maze> constructor = Maze.class.getDeclaredConstructor(
-                    Tile[][].class,
-                    Integer.TYPE,
-                    Integer.TYPE,
-                    Position.class,
-                    Position.class,
-                    Long.TYPE,
-                    String.class
-            );
-            constructor.setAccessible(true);
-            return constructor.newInstance(field, width, height, start, end, randomSeed, algorithm);
-        } catch (@NotNull final NoSuchMethodException | IllegalAccessException | InstantiationException |
-                                InvocationTargetException e) {
-            throw new RuntimeException("Can not deserialize Maze from maze data.", e);
-        }
-    }
-}

src/main/resources/maze.schema.json

@@ -6,7 +6,6 @@
   "additionalProperties": false,
   "required": [
     "id",
-    "algorithm",
     "width",
     "height",
     "start",
@@ -18,10 +17,6 @@
       "type": "string",
       "description": "64 bit precision signed integer value. Transmitted as string, because ECMAScript (browsers) don't normally handle 64 bit integers well, as the ECMAScript 'number' type is a 64 bit signed double value, leaving only 53 bits for the integer part, thus losing precision."
     },
-    "algorithm": {
-      "type": "string",
-      "description": "The name of the algorithm used to generate the maze."
-    },
     "width": {
       "type": "integer",
       "minimum": 1

src/test/java/ch/fritteli/maze/generator/algorithm/wilson/WilsonTest.java

@@ -1,100 +0,0 @@
-package ch.fritteli.maze.generator.algorithm.wilson;
-
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.renderer.text.TextRenderer;
-import org.junit.jupiter.api.Test;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class WilsonTest {
-    @Test
-    void testTinyGeneration() {
-        // arrange
-        final Maze maze = new Maze(3, 3, 0);
-        final Wilson wilson = new Wilson(maze);
-
-        // act
-        wilson.run();
-
-        // assert
-        final String textRepresentation = TextRenderer.newInstance().render(maze);
-        assertThat(textRepresentation).isEqualTo("""
-                ╷ ╶───┐
-                │     │
-                │ ┌─┐ │
-                │ │ │ │
-                │ ╵ │ │
-                │   │ │
-                └───┘ ╵""");
-    }
-
-    @Test
-    void testSimpleGeneration() {
-        // arrange
-        final Maze maze = new Maze(10, 10, 0);
-        final Wilson wilson = new Wilson(maze);
-
-        // act
-        wilson.run();
-
-        // assert
-        final String textRepresentation = TextRenderer.newInstance().render(maze);
-        assertThat(textRepresentation).isEqualTo("""
-                ╷ ╶─────┬─────┬─────┐
-                │       │     │     │
-                ├─╴ ╷ ╶─┴─┬─╴ ├─┐ ╶─┤
-                │   │     │   │ │   │
-                │ ╷ └─┐ ╶─┘ ┌─┘ ╵ ╷ │
-                │ │   │     │     │ │
-                │ │ ╶─┤ ╶─┐ ╵ ╷ ╶─┤ │
-                │ │   │   │   │   │ │
-                │ ├─┐ ├─╴ └─┐ │ ╶─┼─┤
-                │ │ │ │     │ │   │ │
-                ├─┘ └─┘ ╶─┐ └─┤ ╶─┤ │
-                │         │   │   │ │
-                ├───┐ ╷ ╶─┴───┴─┐ │ │
-                │   │ │         │ │ │
-                ├─╴ └─┼─╴ ╷ ╷ ┌─┴─┘ │
-                │     │   │ │ │     │
-                │ ╷ ╶─┴─┬─┤ ├─┘ ╶─┐ │
-                │ │     │ │ │     │ │
-                │ ├─╴ ╷ ╵ ╵ ╵ ┌─╴ │ │
-                │ │   │       │   │ │
-                └─┴───┴───────┴───┘ ╵""");
-    }
-
-    @Test
-    void testSimpleGenerationWithSolution() {
-        // arrange
-        final Maze maze = new Maze(10, 10, 0);
-        final Wilson wilson = new Wilson(maze);
-
-        // act
-        wilson.run();
-
-        // assert
-        final String textRepresentation = TextRenderer.newInstance().setRenderSolution(true).render(maze);
-        assertThat(textRepresentation).isEqualTo("""
-                ╷│╶─────┬─────┬─────┐
-                │╰───╮  │     │     │
-                ├─╴ ╷│╶─┴─┬─╴ ├─┐ ╶─┤
-                │   │╰─╮  │   │ │   │
-                │ ╷ └─┐│╶─┘ ┌─┘ ╵ ╷ │
-                │ │   ││    │     │ │
-                │ │ ╶─┤│╶─┐ ╵ ╷ ╶─┤ │
-                │ │   │╰─╮│   │   │ │
-                │ ├─┐ ├─╴│└─┐ │ ╶─┼─┤
-                │ │ │ │╭─╯  │ │   │ │
-                ├─┘ └─┘│╶─┐ └─┤ ╶─┤ │
-                │      │  │   │   │ │
-                ├───┐ ╷│╶─┴───┴─┐ │ │
-                │   │ │╰───╮    │ │ │
-                ├─╴ └─┼─╴ ╷│╷ ┌─┴─┘ │
-                │     │   │││ │╭───╮│
-                │ ╷ ╶─┴─┬─┤│├─┘│╶─┐││
-                │ │     │ │││╭─╯  │││
-                │ ├─╴ ╷ ╵ ╵│╵│┌─╴ │││
-                │ │   │    ╰─╯│   │││
-                └─┴───┴───────┴───┘│╵""");
-    }
-}

src/test/java/ch/fritteli/maze/generator/model/WallsTest.java

@@ -3,8 +3,6 @@ package ch.fritteli.maze.generator.model;
 import io.vavr.collection.Stream;
 import org.junit.jupiter.api.Test;
 
-import java.util.EnumSet;
-
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 
@@ -115,7 +113,7 @@ class WallsTest {
         final Walls sut = new Walls();
 
         // act
-        EnumSet<Direction> result = sut.getUnsealedSet();
+        Stream<Direction> result = sut.getUnsealedSet();
 
         // assert
         assertThat(result).isEmpty();

src/test/java/ch/fritteli/maze/generator/serialization/v1/SerializerDeserializerV1Test.java

@@ -13,8 +13,6 @@ class SerializerDeserializerV1Test {
         new RandomDepthFirst(expected).run();
         final byte[] bytes = SerializerDeserializerV1.serialize(expected);
         final Maze result = SerializerDeserializerV1.deserialize(bytes);
-        assertThat(result.getAlgorithm()).isNull();
-        expected.setAlgorithm(null);
         assertThat(result).isEqualTo(expected);
     }
 
@@ -24,8 +22,6 @@ class SerializerDeserializerV1Test {
         new RandomDepthFirst(expected).run();
         final byte[] bytes = SerializerDeserializerV1.serialize(expected);
         final Maze result = SerializerDeserializerV1.deserialize(bytes);
-        assertThat(result.getAlgorithm()).isNull();
-        expected.setAlgorithm(null);
         assertThat(result).isEqualTo(expected);
     }
 
@@ -35,8 +31,6 @@ class SerializerDeserializerV1Test {
         new RandomDepthFirst(expected).run();
         final byte[] bytes = SerializerDeserializerV1.serialize(expected);
         final Maze result = SerializerDeserializerV1.deserialize(bytes);
-        assertThat(result.getAlgorithm()).isNull();
-        expected.setAlgorithm(null);
         assertThat(result).isEqualTo(expected);
     }
 }

src/test/java/ch/fritteli/maze/generator/serialization/v2/SerializerDeserializerV2Test.java

@@ -1,46 +0,0 @@
-package ch.fritteli.maze.generator.serialization.v2;
-
-import ch.fritteli.maze.generator.algorithm.RandomDepthFirst;
-import ch.fritteli.maze.generator.algorithm.wilson.Wilson;
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.model.Position;
-import org.junit.jupiter.api.Test;
-
-import java.io.IOException;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class SerializerDeserializerV2Test {
-    @Test
-    void testSerializeDeserializeTiny() throws IOException {
-        final Maze expected = new Maze(2, 2, 255, new Position(0, 0), new Position(1, 1));
-        new RandomDepthFirst(expected).run();
-        final byte[] bytes = SerializerDeserializerV2.serialize(expected);
-        final Maze result = SerializerDeserializerV2.deserialize(bytes);
-        assertThat(result.getAlgorithm()).isNull();
-        expected.setAlgorithm(null);
-        assertThat(result).isEqualTo(expected);
-    }
-
-    @Test
-    void testSerializeDeserializeMedium() throws IOException {
-        final Maze expected = new Maze(20, 20, -271828182846L);
-        new Wilson(expected).run();
-        final byte[] bytes = SerializerDeserializerV2.serialize(expected);
-        final Maze result = SerializerDeserializerV2.deserialize(bytes);
-        assertThat(result.getAlgorithm()).isNull();
-        expected.setAlgorithm(null);
-        assertThat(result).isEqualTo(expected);
-    }
-
-    @Test
-    void testSerializeDeserializeLarge() throws IOException {
-        final Maze expected = new Maze(200, 320, 3141592653589793238L);
-        new Wilson(expected).run();
-        final byte[] bytes = SerializerDeserializerV2.serialize(expected);
-        final Maze result = SerializerDeserializerV2.deserialize(bytes);
-        assertThat(result.getAlgorithm()).isNull();
-        expected.setAlgorithm(null);
-        assertThat(result).isEqualTo(expected);
-    }
-}

src/test/java/ch/fritteli/maze/generator/serialization/v3/SerializerDeserializerV3Test.java

@@ -1,49 +0,0 @@
-package ch.fritteli.maze.generator.serialization.v3;
-
-import ch.fritteli.maze.generator.algorithm.RandomDepthFirst;
-import ch.fritteli.maze.generator.algorithm.wilson.Wilson;
-import ch.fritteli.maze.generator.model.Maze;
-import ch.fritteli.maze.generator.model.Position;
-import org.junit.jupiter.api.Test;
-
-import java.io.IOException;
-
-import static org.assertj.core.api.Assertions.assertThat;
-
-class SerializerDeserializerV3Test {
-    @Test
-    void testSerializeDeserializeTiny() throws IOException {
-        final Maze expected = new Maze(2, 2, 255, new Position(0, 0), new Position(1, 1));
-        new RandomDepthFirst(expected).run();
-        final byte[] bytes = SerializerDeserializerV3.serialize(expected);
-        final Maze result = SerializerDeserializerV3.deserialize(bytes);
-        assertThat(result).isEqualTo(expected);
-    }
-
-    @Test
-    void testSerializeDeserializeMedium() throws IOException {
-        final Maze expected = new Maze(20, 20, -271828182846L);
-        new Wilson(expected).run();
-        final byte[] bytes = SerializerDeserializerV3.serialize(expected);
-        final Maze result = SerializerDeserializerV3.deserialize(bytes);
-        assertThat(result).isEqualTo(expected);
-    }
-
-    @Test
-    void testSerializeDeserializeLarge() throws IOException {
-        final Maze expected = new Maze(200, 320, 3141592653589793238L);
-        new Wilson(expected).run();
-        final byte[] bytes = SerializerDeserializerV3.serialize(expected);
-        final Maze result = SerializerDeserializerV3.deserialize(bytes);
-        assertThat(result).isEqualTo(expected);
-    }
-
-    @Test
-    void testSerializeDeserializeLargeRandom() throws IOException {
-        final Maze expected = new Maze(200, 320, 3141592653589793238L);
-        new RandomDepthFirst(expected).run();
-        final byte[] bytes = SerializerDeserializerV3.serialize(expected);
-        final Maze result = SerializerDeserializerV3.deserialize(bytes);
-        assertThat(result).isEqualTo(expected);
-    }
-}