let cols, rows;

let grid;

let cellSize = 20;

​

// Snake Variables

let snake;

let food;

let direction; // Current direction of the snake

let pendingDirection; // Next direction to apply

​

// Cellular Automata Rules

let automatonSpeed = 50; // Frames between automaton updates

let frameCounter = 0;

​

// Game speed

let gameSpeed = 10; // Lower value = faster snake movement

let gameOver = false; // Flag for game over state

let gameOverMessage = ""; // Message to display when game ends

​

function setup() {

  createCanvas(600, 600);

  cols = floor(width / cellSize);

  rows = floor(height / cellSize);

  grid = createEmptyGrid(cols, rows);

  initializeAutomaton(grid);

​

  // Initialize snake and its direction

  snake = new Snake();

  direction = createVector(1, 0); // Start moving to the right

  pendingDirection = direction.copy();

​

  spawnFood();

  frameRate(60); // High frame rate for smooth movement

}

​

function draw() {

  background(30);

​

  // Check if the game is over

  if (gameOver) {

    fill(255, 50, 50);

    textAlign(CENTER, CENTER);

    textSize(32);

    text(gameOverMessage, width / 2, height / 2);

    return; // Stop updating the game

  }

​

  // Update the Cellular Automata obstacles

  if (frameCounter % automatonSpeed === 0) {

    grid = updateAutomaton(grid);

    ensureObstacles(grid); // Maintain some alive cells

  }

  frameCounter++;

​

  // Draw the Cellular Automata grid

  drawAutomaton(grid);

​

  // Update the snake at gameSpeed intervals

  if (frameCount % gameSpeed === 0) {

    if (canChangeDirection(direction, pendingDirection)) {

      direction = pendingDirection.copy();

    }

    snake.update();

    snake.checkCollision();

  }

​

  // Show the snake and food

  snake.show();

  drawFood();

}

​

// Ensure there are always obstacles (alive cells) on the grid

function ensureObstacles(grid) {

  let aliveCount = 0;

  for (let x = 0; x < cols; x++) {

    for (let y = 0; y < rows; y++) {

      if (grid[x][y] === 1) {

        aliveCount++;

      }

    }

  }

​

  // Add alive cells if fewer than the minimum threshold

  let minObstacles = 10;

  while (aliveCount < minObstacles) {

    let x = floor(random(cols));

    let y = floor(random(rows));

    if (grid[x][y] === 0) {

      grid[x][y] = 1;

      aliveCount++;

    }

  }

}

​

// Check if the direction change is valid (no reversing)

function canChangeDirection(current, next) {

  return !(current.x + next.x === 0 && current.y + next.y === 0);

}

​

// Create an empty grid

function createEmptyGrid(cols, rows) {

  let arr = [];

  for (let i = 0; i < cols; i++) {

    arr[i] = [];

    for (let j = 0; j < rows; j++) {

      arr[i][j] = 0;

    }

  }

  return arr;

}

​

// Initialize the Cellular Automata grid with random obstacles

function initializeAutomaton(grid) {

  for (let i = 0; i < cols; i++) {

    for (let j = 0; j < rows; j++) {

      grid[i][j] = random() > 0.95 ? 1 : 0; // 5% chance of alive cells initially

    }

  }

}

​

// Update the Cellular Automata using Conway's Game of Life rules

function updateAutomaton(grid) {

  let next = createEmptyGrid(cols, rows);

  for (let x = 0; x < cols; x++) {

    for (let y = 0; y < rows; y++) {

      let aliveNeighbors = countAliveNeighbors(grid, x, y);

      if (grid[x][y] === 1) {

        next[x][y] = aliveNeighbors === 2 || aliveNeighbors === 3 ? 1 : 0;

      } else {

        next[x][y] = aliveNeighbors === 3 ? 1 : 0;

      }

    }

  }

  return next;

}

​

// Count alive neighbors

function countAliveNeighbors(grid, x, y) {

  let sum = 0;

  for (let i = -1; i <= 1; i++) {

    for (let j = -1; j <= 1; j++) {

      let col = (x + i + cols) % cols;

      let row = (y + j + rows) % rows;

      sum += grid[col][row];

    }

  }

  sum -= grid[x][y];

  return sum;

}

​

// Draw the Cellular Automata grid

function drawAutomaton(grid) {

  for (let x = 0; x < cols; x++) {

    for (let y = 0; y < rows; y++) {

      if (grid[x][y] === 1) {

        fill(200, 50, 50); // Obstacles are red

      } else {

        fill(30);

      }

      stroke(0);

      rect(x * cellSize, y * cellSize, cellSize, cellSize);

    }

  }

}

​

// Snake class

class Snake {

  constructor() {

    this.body = [createVector(floor(cols / 2), floor(rows / 2))];

    this.grow = false;

  }

​

  update() {

    // Get the new head position

    let head = this.body[this.body.length - 1].copy();

    head.add(direction);

​

    // Wrap around edges

    head.x = (head.x + cols) % cols;

    head.y = (head.y + rows) % rows;

​

    // Check if the snake eats food

    if (head.x === food.x && head.y === food.y) {

      this.grow = true;

      spawnFood();

      grid[food.x][food.y] = 0; // Clear the eaten cell

    }

​

    // Remove the tail unless growing

    if (!this.grow) {

      this.body.shift();

    } else {

      this.grow = false;

    }

​

    // Add the new head to the body

    this.body.push(head);

  }

​

  show() {

    fill(255);

    for (let segment of this.body) {

      rect(segment.x * cellSize, segment.y * cellSize, cellSize, cellSize);

    }

  }

​

  checkCollision() {

    let head = this.body[this.body.length - 1];

​

    // Check collision with the body

    for (let i = 0; i < this.body.length - 1; i++) {

      if (this.body[i].equals(head)) {

        gameOver = true;

        gameOverMessage = "Game Over: Collision with self";

        return;

      }

    }

​

    // Check collision with obstacles (alive cells in the automaton)

    if (grid[head.x][head.y] === 1) {

      gameOver = true;

      gameOverMessage = "Game Over: Collision with obstacle";

      return;

    }

  }

}

​

// Spawn food in a random non-obstacle cell

function spawnFood() {

  let emptyCells = [];

  for (let x = 0; x < cols; x++) {

    for (let y = 0; y < rows; y++) {

      if (grid[x][y] === 0) {

        emptyCells.push(createVector(x, y));

      }

    }

  }

​

  if (emptyCells.length > 0) {

    food = random(emptyCells);

  } else {

    gameOver = true;

    gameOverMessage = "No space for food!";

  }

}

​

// Draw the food

function drawFood() {

  fill(50, 200, 50);

  rect(food.x * cellSize, food.y * cellSize, cellSize, cellSize);

}

​

// Handle arrow key inputs

function keyPressed() {

  if (keyCode === UP_ARROW) {

    pendingDirection.set(0, -1); // Move up

  } else if (keyCode === DOWN_ARROW) {

    pendingDirection.set(0, 1); // Move down

  } else if (keyCode === LEFT_ARROW) {

    pendingDirection.set(-1, 0); // Move left

  } else if (keyCode === RIGHT_ARROW) {

    pendingDirection.set(1, 0); // Move right

  }

}

​