BotRoss/src/SnakeBot.java

import java.util.LinkedList;
import java.util.Queue;

public class SnakeBot extends Bot {
    protected final static String obstacles = "~#X*";
    protected boolean offByOne = true;
    protected int currentStepCount = 0;
    protected int steps = 0;

    public static void main(String[] args) {
        while (true) {
            Bot bot = new SnakeBot(args);
            bot.run();
        }
    }

    protected SnakeBot(String[] args) {
        super(args);
    }

    @Override
    protected char nextMove(View view) {
        System.out.println();
        String data = view.data
                .replace('^', '*')
                .replace('<', '*')
                .replace('>', '*')
                .replace('V', '*');
        char[][] grid = dataToGrid(data, view.width);

        if (data.contains("@")) {
            return breadthFirstSearch(grid);
        } else {
            return walkAround(grid);
        }
    }

    protected char[][] dataToGrid(String data, int size) {
        char[][] grid = new char[size][size];
        for (int i = 0; i < data.length(); i++) {
            grid[i % size][i / size] = data.charAt(i);
        }
        return grid;
    }

    protected char walkAround(char[][] grid) {
        if (steps == 0) {
            currentStepCount++;
            if (offByOne) {
                currentStepCount++;
            }
            offByOne = !offByOne;
            steps = currentStepCount;
            return '>';
        } else {
            steps--;
            return safeMove(grid);
        }
    }

    protected char safeMove(char[][] grid) {
        int size = grid.length;
        if (grid[size / 2][size / 2 - 1] == '*') {
            return safeTurn(grid);
        } else {
            return '^';
        }
    }

    protected char safeTurn(char[][] grid) {
        int size = grid.length;

        int leftStars = 0;
        int rightStars = 0;
        for (int x = 0; x < size / 2; x++) {
            for (int y = 0; y < size; y++) {
                if (grid[x][y] == '*')
                    leftStars++;
                if (grid[size - x - 1][y] == '*')
                    rightStars++;
            }
        }

        if (leftStars > rightStars) {
            return '>';
        } else {
            return '<';
        }
    }

    protected char breadthFirstSearch(char[][] grid) {
        int size = grid.length;
        int start = size / 2;

        boolean[][] visited = new boolean[size][size];
        Queue<Move> queue = new LinkedList<>();

        int[][] directions = {{0, -1}, {0, 1}, {1, 0}, {-1, 0}};
        char[] commands = {'^', '>', '>', '<'};
        for (int i = 0; i < 4; i++) {
            queue.add(new Move(start + directions[i][0], start + directions[i][1], commands[i]));
        }

        queue.add(new Move(start, start - 1, '^'));
        queue.add(new Move(start, start + 1, '>'));
        queue.add(new Move(start + 1, start, '>'));
        queue.add(new Move(start - 1, start, '<'));

        while (!queue.isEmpty()) {
            Move move = queue.poll();
            if (move.x < 0 || move.x >= size || move.y < 0 || move.y >= size || visited[move.x][move.y]) continue;
            visited[move.x][move.y] = true;
            if (obstacles.contains("" + grid[move.x][move.y])) continue;
            if (grid[move.x][move.y] == '@') return move.direction;

            for (int[] direction : directions) {
                queue.add(new Move(move.x + direction[0], move.y + direction[1], move.direction));
            }
        }

        System.err.println("No path found");
        return safeMove(grid);
    }

    protected record Move(int x, int y, char direction) {
    }

}