Проверить игровое поле на валидность

public class Position {
    int x;
    int y;
    public Position(int x, int y) {
        this.x = x;
        this.y = y;
    }
    public int getX() {
        return x;
    }
 
    public int getY() {
        return y;
    }
}
 
public class Tile{
 
    Position pos;
    Tiletype type;
 
    public Tile( Position pos, Tiletype type){
        this.pos = pos;
        this.type = type;
     }
}
 
public enum Tiletype{
    WALL,
    ROAD,
        START
}
 
// задание
 
public boolean trackIsValid(Tile [][] track){
……..
}

package test;
 
import java.awt.*;
import java.util.*;
 
public class Main {
    public boolean trackIsValid(Tile[][] track) {
        var struct = new Struct();
        for (var ts : track)
            for (var t : ts)
                struct.put(t);
        return struct.isValid();
    }
 
    public static void main(String[] args) {
 
    }
}
 
class Position extends Point {
}
 
class Tile {
    public enum Type {
        WALL,
        ROAD,
        START
    }
 
    private final Position pos;
    private final Type type;
 
    public Tile(Position pos, Type type) {
        this.pos = pos;
        this.type = type;
    }
 
    public Position getPos() {
        return pos;
    }
 
    public Type getType() {
        return type;
    }
}
 
class Struct {
    private final Map<Point, Node> map;
 
 
    public Struct(Tile... tiles) {
        map = new HashMap<>();
        for (var t : tiles) put(t);
    }
 
    public void put(Tile tile) {
        map.put(tile.getPos(), new Node(false, tile));
    }
 
    private boolean dfs(Direction direction, Node start) {
        Deque<Node> stack = new ArrayDeque<>();
        for (var n : map.entrySet()) n.getValue().isPassed = false;
 
        var noidBuff = start;
        final var pointBuff = new Point(noidBuff.tile.getPos());
 
        start.isPassed = true;
        direction.move(pointBuff);
        noidBuff = map.get(pointBuff);
        if (noidBuff.tile.getType() == Tile.Type.ROAD)
            stack.addFirst(map.get(pointBuff));
        direction.reverse().move(pointBuff);
 
        while (stack.size() != 0) {
            noidBuff = stack.pollFirst();
            pointBuff.setLocation(noidBuff.tile.getPos());
            noidBuff.isPassed = true;
            for (var d : Direction.values()) {
                d.move(pointBuff);
                noidBuff = map.get(pointBuff);
                if (noidBuff.tile.getType() == Tile.Type.ROAD || !noidBuff.isPassed)
                    stack.addFirst(noidBuff);
                if (noidBuff.tile.getType() == Tile.Type.START && direction.reverse() == d)
                    return true;
                d.reverse().move(pointBuff);
            }
        }
        return false;
    }
 
    public boolean isValid() {
        for (var n : map.entrySet()) {
            if (n.getValue().tile.getType() == Tile.Type.START) {
                for (var d : Direction.values()) {
                    if (dfs(d, n.getValue())) {
                        return true;
                    }
                }
            }
        }
        return false;
    }
 
    private static class Node {
        boolean isPassed;
        Tile tile;
 
        public Node(boolean isPassed, Tile tile) {
            this.isPassed = isPassed;
            this.tile = tile;
        }
    }
 
    private enum Direction {
        NORTH(0, 1), SOUTH(0, -1), WEST(-1, 0), EAST(1, 0);
        final int x, y;
 
        Direction(int x, int y) {
            this.x = x;
            this.y = y;
        }
 
        public void move(Point p) {
            p.move(x, y);
        }
 
        public Direction reverse() {
            return switch (this) {
                case SOUTH -> NORTH;
                case NORTH -> SOUTH;
                case WEST -> EAST;
                case EAST -> WEST;
            };
        }
    }
}