Tilt snake on an 8x8 matrix, on an Arduino Uno

// Tilt snake: steer a snake round an 8x8 matrix by tipping the board.
//
//   MAX7219 DIN -> pin 13    CLK -> pin 7    CS -> pin 8
//   MPU-6050 (GY-521) SDA -> A4    SCL -> A5    VCC -> 5V    GND -> GND
//
// The MPU-6050 measures which way gravity pulls. Lie it flat and gravity is
// all on its Z axis; tip it forward or back and some of it moves onto Y, tip
// it left or right and some moves onto X. The sketch reads X and Y straight
// from the chip's registers with Wire, and a large enough lean picks the
// snake's next direction. It cannot turn straight back on itself.
//
// The snake steps once every 400 ms and comes out of the opposite edge when
// it leaves the matrix. Eat the blinking dot to grow; every fourth dot makes
// it a little faster. Run into your own tail and the matrix fills up, then a
// new game starts.
//
// Drag the module's pitch or roll to steer.

#include <Wire.h>
#include <LedControl.h>

const int MPU = 0x68;
const int LEAN = 6000;  // about 20 degrees, out of 16384 for a full 1 g

LedControl lc = LedControl(13, 7, 8, 1);  // DIN, CLK, CS, modules

byte snakeX[64];
byte snakeY[64];
int length = 2;
int dx = 1, dy = 0;
byte foodX, foodY;
int stepMs = 400;
unsigned long lastStep = 0;
bool foodOn = true;
unsigned long lastBlink = 0;

void readTilt(int &ax, int &ay) {
  Wire.beginTransmission(MPU);
  Wire.write(0x3B);  // ACCEL_XOUT_H, then XOUT_L, YOUT_H, YOUT_L
  Wire.endTransmission(false);
  Wire.requestFrom(MPU, 4);
  ax = Wire.read() << 8 | Wire.read();
  ay = Wire.read() << 8 | Wire.read();
}

bool onSnake(byte x, byte y) {
  for (int i = 0; i < length; i++) {
    if (snakeX[i] == x && snakeY[i] == y) return true;
  }
  return false;
}

void placeFood() {
  do {
    foodX = random(8);
    foodY = random(8);
  } while (onSnake(foodX, foodY));
}

void newGame() {
  length = 2;
  snakeX[0] = 1; snakeY[0] = 4;
  snakeX[1] = 0; snakeY[1] = 4;
  dx = 1; dy = 0;
  stepMs = 400;
  placeFood();
  Serial.println("new game");
}

void draw() {
  lc.clearDisplay(0);
  for (int i = 0; i < length; i++) lc.setLed(0, snakeY[i], snakeX[i], true);
  if (foodOn) lc.setLed(0, foodY, foodX, true);
}

void steer() {
  int ax, ay;
  readTilt(ax, ay);
  int ndx = dx, ndy = dy;
  if (abs(ay) > abs(ax) && abs(ay) > LEAN) {
    ndx = 0;
    ndy = ay > 0 ? -1 : 1;
  } else if (abs(ax) > LEAN) {
    ndx = ax > 0 ? -1 : 1;
    ndy = 0;
  }
  if (ndx == -dx && ndy == -dy) return;  // no turning back on yourself
  if (ndx != dx || ndy != dy) {
    dx = ndx;
    dy = ndy;
    Serial.println(dy < 0 ? "turn up" : dy > 0 ? "turn down" : dx < 0 ? "turn left" : "turn right");
  }
}

void gameOver() {
  Serial.print("game over, length ");
  Serial.println(length);
  for (int row = 0; row < 8; row++) {
    for (int col = 0; col < 8; col++) {
      lc.setLed(0, row, col, true);
      delay(15);
    }
  }
  delay(500);
  newGame();
}

void step() {
  int x = (snakeX[0] + dx + 8) % 8;
  int y = (snakeY[0] + dy + 8) % 8;
  bool eats = x == foodX && y == foodY;
  // The tail moves out of the way this step unless the snake grows.
  for (int i = 0; i < length - (eats ? 0 : 1); i++) {
    if (snakeX[i] == x && snakeY[i] == y) {
      gameOver();
      return;
    }
  }
  if (eats && length < 64) length++;
  for (int i = length - 1; i > 0; i--) {
    snakeX[i] = snakeX[i - 1];
    snakeY[i] = snakeY[i - 1];
  }
  snakeX[0] = x;
  snakeY[0] = y;
  if (eats) {
    Serial.print("ate a dot, length ");
    Serial.println(length);
    if (length % 4 == 0 && stepMs > 150) stepMs -= 50;
    if (length < 64) placeFood();
  }
}

void setup() {
  Serial.begin(9600);
  Wire.begin();
  Wire.beginTransmission(MPU);
  Wire.write(0x6B);  // PWR_MGMT_1: wake the chip up
  Wire.write(0);
  Wire.endTransmission();
  lc.shutdown(0, false);
  lc.setIntensity(0, 6);
  lc.clearDisplay(0);
  randomSeed(analogRead(A0));
  Serial.println("Mokxi Uno: tilt snake. Tip the board to steer.");
  newGame();
}

void loop() {
  steer();
  if (millis() - lastBlink >= 150) {
    lastBlink = millis();
    foodOn = !foodOn;
  }
  if (millis() - lastStep >= (unsigned long)stepMs) {
    lastStep = millis();
    step();
  }
  draw();
  delay(20);
}