trianta.dev/src/snake.ts

enum BoardState {
    SNAKE = 0,
    FOOD = 1,
    CHECKED = 2 // For search algorithms
}

// Bit functions for ease
function isBitSet(value: number, bit: number): boolean {
    return ((value >> bit) % 2 != 0)
}

function bitSet(value: number, bit: number): number {
    return value | 1 << bit;
}

function bitClear(value: number, bit: number): number {
    return value & ~(1 << bit);
}

class Point {
    x: number;
    y: number;

    constructor(x = 0, y = 0) {
        this.x = x;
        this.y = y;
    }

    copy(other: Point) {
        this.x = other.x;
        this.y = other.y;
    }

    add(other: Point) {
        var result = new Point;
        result.x = this.x + other.x;
        result.y = this.y + other.y;
        return result;
    }

    subtract(other: Point) {
        var result = new Point;
        result.x = this.x - other.x;
        result.y = this.y - other.y;
        return result;
    }
}

class SnakeCore {
    canvas: HTMLCanvasElement;
    context: CanvasRenderingContext2D;
    grid: number;
    timeout: number;
    width: number;
    height: number;
    board: number[][];
    body: Point[];
    food: Point;
    gameover: boolean;
    foodAte: boolean;

    constructor() {
        this.canvas = document.getElementById('snake') as HTMLCanvasElement;
        this.context = this.canvas.getContext('2d') as CanvasRenderingContext2D;
        this.grid = 25; // size of grid squares
        this.timeout = 32; // speed in ms
        this.width = 25;
        this.height = 15;
        this.board = [];
        for (let i = 0; i < this.height; i++)
            this.board.push(new Array(this.width));
        this.body = [];
        this.food = new Point();
        this.gameover = false;
        this.foodAte = true;
        this.body.push(new Point(12, 8));
        this.board[8][12] = 1;
    }

    get head(): Point {
        return this.body[this.body.length - 1];
    }

    reset() {
        console.debug("[TRACE] Reset was triggered");
        this.gameover = false;
        this.foodAte = true;
        for (let i = 0; i < this.height; i++) {
            for (let j = 0; j < this.width; j++) {
                this.board[i][j] = 0;
            }
        }
        while (this.body.length > 0)
            this.body.pop();
        while (g_snakebot.path.length > 0)
            g_snakebot.path.pop();
        this.startRandom();
        this.foodRegen();
        this.draw();
    }

    startRandom() {
        this.body.push(new Point(Math.floor(Math.random() * this.width), Math.floor(Math.random() * this.height)));
    }

    foodRegen() {
        if (!this.foodAte)
            return;
        console.debug("[TRACE] Food reset was triggered");
        this.foodAte = false;
        while (true) {
            let tmp = new Point(Math.floor(Math.random() * this.width), Math.floor(Math.random() * this.height));
            if (isBitSet(this.board[tmp.y][tmp.x], BoardState.SNAKE))
                continue;
            this.board[tmp.y][tmp.x] = bitSet(this.board[tmp.y][tmp.x], BoardState.FOOD);
            this.food.copy(tmp);
            return;
        }
    }

    // Simulate game logic
    simulate() {
        // Move snake
        let next: Point = new Point;
        next.copy(g_snakebot.nextMove());
        if (next.x < 0 || next.x > g_snake.width || next.y < 0 || next.y > g_snake.height) {
            g_snake.gameover = true;
            return;
        }
        if (isBitSet(g_snake.board[next.y][next.x], BoardState.SNAKE) && (g_snake.body.length > 1)) {
            g_snake.gameover = true; // Game should end (Snake touching snake)
            return;
        }

        g_snake.board[next.y][next.x] = bitSet(g_snake.board[next.y][next.x], BoardState.SNAKE);
        g_snake.body.push(next);
        if (!isBitSet(g_snake.board[next.y][next.x], BoardState.FOOD)) {
            let old: Point = g_snake.body.shift() as Point;
            g_snake.board[old.y][old.x] = bitClear(g_snake.board[old.y][old.x], BoardState.SNAKE);
        } else {
            g_snake.board[next.y][next.x] = bitClear(g_snake.board[next.y][next.x], BoardState.FOOD);
            g_snake.foodAte = true;
            while (g_snakebot.path.length > 0)
                g_snakebot.path.pop();
        }
    }

    // Draw game to canvas
    draw() {
        // Clear the screen
        g_snake.context.clearRect(0, 0, g_snake.canvas.width, g_snake.canvas.height);

        // Draw game
        for (let i = 0; i < g_snake.height; i++) {
            for (let j = 0; j < g_snake.width; j++) {
                if (isBitSet(g_snake.board[i][j], BoardState.SNAKE))
                    g_snake.context.fillStyle = "green";
                else if (isBitSet(g_snake.board[i][j], BoardState.FOOD))
                    g_snake.context.fillStyle = "red";
                else
                    g_snake.context.fillStyle = "black";
                g_snake.context.fillRect(j * g_snake.grid, i * g_snake.grid, g_snake.grid, g_snake.grid);
            }
        }
    }

    // Update text on page to match game
    updatePageText() {
        document.getElementById("snakeHead").innerHTML = "x: " + this.body[this.body.length - 1].x + " y: " + this.body[this.body.length - 1].y;
        document.getElementById("snakeFood").innerHTML = "x: " + this.food.x + " y: " + this.food.y ;
    }

    // Update width and height from page to match game
    getPageNumbers() {
        let specifiedWidth = parseInt((document.getElementById("snakeWidth") as HTMLInputElement).value);
        let specifiedHeight = parseInt((document.getElementById("snakeHeight") as HTMLInputElement).value);
        if (this.width == specifiedWidth && this.height == specifiedHeight)
            return false;
        this.width = specifiedWidth;
        this.height = specifiedHeight;
        while (this.height > this.board.length)
            this.board.push(new Array(this.width));
        this.canvas.setAttribute("width", String(specifiedWidth * this.grid));
        this.canvas.setAttribute("height", String(specifiedHeight * this.grid));
        return true;
    }
}

class Bot {
    pathUntrimmed: Point[];
    path: Point[];

    constructor() {
        this.pathUntrimmed = [];
        this.path = [];
    }

    bfs() {
        var search: Point[] = [g_snake.head];
        while (search.length !== 0) {
            let current: Point = search.shift() as Point;
            if (isBitSet(g_snake.board[current.y][current.x], BoardState.CHECKED))
                continue;
            this.pathUntrimmed.push(current);
            let locals: Point[] = new Array(4);
            for (var i = 0; i < 4; i++) {
                locals[i] = new Point;
                locals[i].copy(current);
            }
            locals[0].y += 1;
            locals[1].x += 1;
            locals[2].y -= 1;
            locals[3].x -= 1;
            for (const local of locals) {
                if (local.x < 0 || local.x > g_snake.width - 1 || local.y < 0 || local.y > g_snake.height - 1)
                    continue;
                let value = g_snake.board[local.y][local.x];
                if (isBitSet(value, BoardState.FOOD)) {
                    this.pathUntrimmed.push(local);
                    return;
                }
                if (isBitSet(value, BoardState.CHECKED) || isBitSet(value, BoardState.SNAKE))
                    continue;
                search.push(local);
            }
            g_snake.board[current.y][current.x] = bitSet(g_snake.board[current.y][current.x], BoardState.CHECKED);
        }
    }
    
    trim() {
        let reachedSnake = false;
        this.path.push(this.pathUntrimmed.pop() as Point); // Push food location
        while (this.pathUntrimmed.length !== 0) {
            let location: Point = this.pathUntrimmed.pop();
            if (reachedSnake)
                continue;
            if (isBitSet(g_snake.board[location.y][location.x], BoardState.SNAKE)) {
                reachedSnake = true;
                continue;
            }
            var delta = new Point;
            delta = location.subtract(this.path[this.path.length - 1]);
            if ((Math.abs(delta.x) + Math.abs(delta.y)) === 1)
                this.path.push(location);
        }
    }

    unvisit() {
        for (let i = 0; i < g_snake.height; i++) {
            for (let j = 0; j < g_snake.width; j++) {
                g_snake.board[i][j] = bitClear(g_snake.board[i][j], BoardState.CHECKED);
            }
        }
    }

    nextMove() {
        // Get new path to food
        if (this.path.length === 0)
            this.pathRefresh();
        var next: Point = new Point;
        next.copy(this.path.pop());
        var delta = new Point;
        delta = next.subtract(g_snake.head);
        if (delta.x > 1)
            console.log("[ERR] delta.x > 1");
        else if (delta.x < -1)
            console.log("[ERR] delta.x < 1");
        if (delta.y > 1)
            console.log("[ERR] delta.y > 1");
        else if (delta.y < -1)
            console.log("[ERR] delta.y < 1");
        return next;
    }

    pathRefresh() {
        this.bfs();
        this.trim();
        this.unvisit();
    }
}

const g_snake: SnakeCore = new SnakeCore();
const g_snakebot: Bot = new Bot();

// game loop
function snakeloop() {
    // Reset of needed
    if (g_snake.gameover || g_snake.getPageNumbers())
        g_snake.reset();

    // Simulate movement of snake
    g_snake.simulate();

    // Regenerate food if needed
    g_snake.foodRegen();

    g_snake.draw();
    g_snake.updatePageText();
}

// start the game
setInterval(snakeloop, g_snake.timeout);