Snake on 192 LEDs

Making an LED matrix, a library to control it, and a game of snake.

Feb 22, 2023

•

1256 views

•

0 respects

Games

Lights

Components and supplies

Resistor 1k ohm

Orange 3mm LED, 100 PCS

Arduino Nano

wood box

Transistor NPN (BC547 or similar)

General Purpose Transistor PNP

BC337-25 Transistor, NPN

Resistor 4.7k ohm

shift register - SN74HC595N

Resistor 22 Ohm 5% 1/16W 50V 0402 (RC0402JR-22R-Hitano)

Resistor 470 ohm

Resistor 220 ohm

10kOhm potentiometer

Tools and machines

Soldering kit

Multimeter

Wire Stripper

Apps and platforms

Arduino IDE

Project description

Code

Snake

cpp

Code for snake game on LED display

1/*
2 * Snake game, for my LED matrix
3 * 
4 * There are two versions: autopilot and controlled by joystick. These can be
5 * toggled between by commenting out the define statement below or leaving it in.
6 * 
7 * Andrew Brink, Feb 24, 2023
8 * 
9 * This code is in the public domain 
10 */
11
12#include <LedMatrix.h>
13
14#define AUTOPILOT //for switching autopilot off and on
15#define MAX_SIZE 100 //max length of snake
16
17#ifdef AUTOPILOT
18const int millisDelay = 80; //controls speed of snake
19#else
20const int millisDelay = 150;
21#endif
22
23LedMatrix myLeds;
24
25//joystick connections
26const int upDown = A6;
27const int leftRight = A5;
28
29//class declarations
30class Node;
31class Snake;
32
33typedef signed char dir;
34
35class Node { //class to facilitate storage and manipulation of points
36  public:
37  void set(byte xPos, byte yPos) {x = xPos; y=yPos; myLeds.write(x,y,HIGH);}
38  void clear() {myLeds.write(x,y,LOW);}
39  byte x;
40  byte y;
41};
42
43class Snake { //contains information of where the snake is and what it is doing
44  public:
45    void reset();
46    byte growHead();
47    void cutTail();
48//    void printSnake();
49    int nextX() {return snakeNodes[head].x + dx;}
50    int nextY() {return snakeNodes[head].y + dy;}
51    int curX() {return snakeNodes[head].x;}
52    int curY() {return snakeNodes[head].y;}
53  public:
54    dir dx;
55    dir dy;
56    byte head;
57    byte length = 0;
58    Node snakeNodes[MAX_SIZE];
59};
60
61//for autopilot
62class infoNode {
63  public:
64  dir dx;
65  dir dy;
66};
67
68infoNode infoMatrix[26][10];
69
70// function declarations
71void spawnApple();
72void resetGame();
73void getDirection();
74bool unSafe(dir x, dir y);
75
76// variable declarations
77unsigned long lastUpdate = 0;
78bool alive;
79byte counter;
80dir nextdx;
81dir nextdy;
82int score;
83Node apple;
84Snake mySnake;
85
86
87void setup() {
88  Serial.begin(9600); //debugging
89  Serial.println("resetting..");
90  myLeds.begin();
91  randomSeed(analogRead(A1)); //initialize random with noise from A1
92  resetGame();
93
94  //stuff for autopilot
95  for (int i = 1; i<=12; i++) {
96    infoMatrix[i][0].dx = -1;
97    infoMatrix[i][0].dy = 0;
98    infoMatrix[i][9].dx = -1;
99    infoMatrix[i][9].dy = 0;
100  }
101  for (int i = 13; i<=24; i++) {
102    infoMatrix[i][0].dx = 1;
103    infoMatrix[i][0].dy = 0;
104    infoMatrix[i][9].dx = 1;
105    infoMatrix[i][9].dy = 0;
106  }
107  for (int i = 1; i<=4; i++) {
108    infoMatrix[0][i].dx = 0;
109    infoMatrix[0][i].dy = -1;
110    infoMatrix[25][i].dx = 0;
111    infoMatrix[25][i].dy = -1;
112  }
113  for (int i = 5; i<=8; i++) {
114    infoMatrix[0][i].dx = 0;
115    infoMatrix[0][i].dy = 1;
116    infoMatrix[25][i].dx = 0;
117    infoMatrix[25][i].dy = 1;
118  }
119}
120
121void loop() {
122  myLeds.refresh();
123
124  #ifndef AUTOPILOT
125  getDirection(); //putting this here makes sure no user input is missed
126  #endif
127  
128  if (millis() - lastUpdate > millisDelay) {
129    lastUpdate = millis();
130    #ifdef AUTOPILOT
131    getDirection(); //putting this here saves processing when in autopilot
132    #endif
133    if (alive) {
134      mySnake.dx = nextdx;
135      mySnake.dy = nextdy;
136      byte snakeStatus = mySnake.growHead();
137      if(snakeStatus == 2) { //if snake hit wall or self
138        alive = false;
139      }
140      if (snakeStatus == 1) { //if snake got apple
141        score++;
142        spawnApple();
143      } else if (snakeStatus == 0) { //normal case
144        mySnake.cutTail();
145      }
146      myLeds.toggle(apple.x, apple.y); //flash apple
147    } else {
148        counter++;
149        if (counter >= 3) {
150          myLeds.clear();
151          myLeds.writeNumber(score);
152          //print state in which snake died
153//          Serial.println(score);
154//          for (int j =0; j<8; j++) {
155//            for (int i = 0; i<24; i++) {
156//              if (i==apple.x && j==apple.y) {
157//                Serial.print(" * ");
158//              } else if (myLeds.read(i, j)==0 ) {
159//                Serial.print(".  ");
160//              } else if (infoMatrix[i+1][j+1].dx == 1) {
161//                Serial.print("-> ");
162//              } else if (infoMatrix[i+1][j+1].dx == -1) {
163//                Serial.print("<- ");
164//              } else if (infoMatrix[i+1][j+1].dy == 1) {
165//                Serial.print("\\/ ");
166//              } else if (infoMatrix[i+1][j+1].dy == -1) {
167//                Serial.print("/\\ ");
168//              }
169//            }
170//            Serial.println();
171//          }
172        }
173        if (counter >= 20) { //display score for some amount of time before resetting
174          resetGame();
175        }
176    }
177  }
178}
179
180void Snake::reset() {
181  while(length) cutTail();
182  head = 0;
183  length = 1;
184  snakeNodes[head].set(0,0);
185  dx = 1;
186  dy = 0;
187}
188
189byte Snake::growHead() {
190  int newX = nextX();
191  int newY = nextY();
192  byte success = 0;
193  if (apple.x == newX && apple.y == newY) {
194    success = 1;
195  }
196  if (myLeds.read(newX,newY) && !success) {
197    return 2;
198  }
199  if (myLeds.inBounds(newX,newY) ==0) {
200    return 2;
201  }
202  head = (head + 1)%MAX_SIZE;
203  length++;
204  while (length > MAX_SIZE) cutTail();
205  snakeNodes[head].set(newX,newY);
206  infoMatrix[newX+1][newY+1].dx = dx;
207  infoMatrix[newX+1][newY+1].dy = dy;
208  return success;
209}
210
211void Snake::cutTail() {
212  snakeNodes[(head-length+MAX_SIZE+1)%MAX_SIZE].clear();
213  length--;
214}
215
216
217void spawnApple() {
218  byte x, y;
219  while (1) {
220    x = random(0, myLeds.getWidth());
221    y = random(0, myLeds.getHeight());
222    if (myLeds.read(x,y)==0) {
223      apple.set(x,y);
224      return;
225    }
226  }
227}
228
229void resetGame() {
230  myLeds.clear();
231  score = 0;
232  alive = true;
233  mySnake.reset();
234  spawnApple();
235  counter = 0;
236  nextdx = 1;
237  nextdy = 0;
238}
239
240void getDirection() {
241  #ifdef AUTOPILOT
242  dir toAppleX, toAppleY;
243  if (apple.x == mySnake.curX()) toAppleX = 0;
244  if (apple.x > mySnake.curX()) toAppleX = 1;
245  if (apple.x < mySnake.curX()) toAppleX = -1;
246  if (apple.y == mySnake.curY()) toAppleY = 0;
247  if (apple.y > mySnake.curY()) toAppleY = 1;
248  if (apple.y < mySnake.curY()) toAppleY = -1;
249
250  nextdx = mySnake.dx;
251  nextdy = mySnake.dy;
252  dir defaultX = unSafe(mySnake.nextX(), mySnake.nextY()) ? -1*infoMatrix[mySnake.nextX()+1][mySnake.nextY()+1].dx : toAppleX;
253  dir defaultY = unSafe(mySnake.nextX(), mySnake.nextY()) ? -1*infoMatrix[mySnake.nextX()+1][mySnake.nextY()+1].dy : toAppleY;
254  if (defaultX == 0) defaultX = 1;
255  if (defaultY == 0) defaultY = 1;
256
257  if (!unSafe(mySnake.curX() + nextdx, mySnake.curY() + nextdy)) { //if the next square is unsafe, skip all this and go right to the life-saving manuevers.
258  
259  if ((toAppleX == 0 && mySnake.dx) || (toAppleY == 0 && mySnake.dy)) { //turning towards apple
260    nextdx = toAppleX;
261    nextdy = toAppleY;
262  }
263
264  //looking ahead
265  for (byte i = 0; unSafe(mySnake.curX() + 2*nextdx, mySnake.curY() + 2*nextdy) && i<3 && !(mySnake.nextX() == apple.x || mySnake.nextY() == apple.y); i++) {
266    switch (i) {
267      case 0:
268        nextdx = mySnake.dx; //if possible continue in the current direction
269        nextdy = mySnake.dy;
270        break;
271      case 1:
272        nextdx = mySnake.dx ? 0 : (toAppleX ? toAppleX : defaultX) ; //if previously going forward, turn towards apple 
273        nextdy = mySnake.dy ? 0 : (toAppleY ? toAppleY : defaultY);
274        break;
275      case 2:
276        nextdx = -1*nextdx; //otherwise, turn away from apple
277        nextdy = -1*nextdy;
278        break;
279    }
280  }
281  }
282
283  for (byte i = 0; unSafe(mySnake.curX() + nextdx, mySnake.curY() + nextdy) && i<3; i++) {
284    switch (i) {
285      case 0:
286        nextdx = mySnake.dx; //if possible continue in the current direction
287        nextdy = mySnake.dy;
288        break;
289      case 1:
290        nextdx = mySnake.dx ? 0 : defaultX; //turn in direction previously defined
291        nextdy = mySnake.dy ? 0 : defaultY;
292        break;
293      case 2:
294        nextdx = -1*nextdx; //otherwise, turn away from apple
295        nextdy = -1*nextdy;
296        break;
297    }
298  }
299  #else
300  if (analogRead(leftRight) > 823 && mySnake.dy) {
301    nextdx = 1;
302    nextdy = 0;
303  }
304  if (analogRead(leftRight) < 200 && mySnake.dy) {
305    nextdx = -1;
306    nextdy = 0;
307  }
308  if (analogRead(upDown) > 823 && mySnake.dx) {
309    nextdx = 0;
310    nextdy = -1;
311  }
312  if (analogRead(upDown) < 200 && mySnake.dx) {
313    nextdx = 0;
314    nextdy = 1;
315  }
316  #endif
317}
318
319bool unSafe(dir x, dir y) {
320  if (x==apple.x && y==apple.y) return false;
321  return !myLeds.inBounds(x, y) || myLeds.read(x, y);
322}

/*
 * Snake game, for my LED matrix
 * 
 * There are two versions: autopilot and controlled by joystick. These can be
 * toggled between by commenting out the define statement below or leaving it in.
 * 
 * Andrew Brink, Feb 24, 2023
 * 
 * This code is in the public domain 
 */

#include <LedMatrix.h>

#define AUTOPILOT //for switching autopilot off and on
#define MAX_SIZE 100 //max length of snake

#ifdef AUTOPILOT
const int millisDelay = 80; //controls speed of snake
#else
const int millisDelay = 150;
#endif

LedMatrix myLeds;

//joystick connections
const int upDown = A6;
const int leftRight = A5;

//class declarations
class Node;
class Snake;

typedef signed char dir;

class Node { //class to facilitate storage and manipulation of points
  public:
  void set(byte xPos, byte yPos) {x = xPos; y=yPos; myLeds.write(x,y,HIGH);}
  void clear() {myLeds.write(x,y,LOW);}
  byte x;
  byte y;
};

class Snake { //contains information of where the snake is and what it is doing
  public:
    void reset();
    byte growHead();
    void cutTail();
//    void printSnake();
    int nextX() {return snakeNodes[head].x + dx;}
    int nextY() {return snakeNodes[head].y + dy;}
    int curX() {return snakeNodes[head].x;}
    int curY() {return snakeNodes[head].y;}
  public:
    dir dx;
    dir dy;
    byte head;
    byte length = 0;
    Node snakeNodes[MAX_SIZE];
};

//for autopilot
class infoNode {
  public:
  dir dx;
  dir dy;
};

infoNode infoMatrix[26][10];

// function declarations
void spawnApple();
void resetGame();
void getDirection();
bool unSafe(dir x, dir y);

// variable declarations
unsigned long lastUpdate = 0;
bool alive;
byte counter;
dir nextdx;
dir nextdy;
int score;
Node apple;
Snake mySnake;


void setup() {
  Serial.begin(9600); //debugging
  Serial.println("resetting..");
  myLeds.begin();
  randomSeed(analogRead(A1)); //initialize random with noise from A1
  resetGame();

  //stuff for autopilot
  for (int i = 1; i<=12; i++) {
    infoMatrix[i][0].dx = -1;
    infoMatrix[i][0].dy = 0;
    infoMatrix[i][9].dx = -1;
    infoMatrix[i][9].dy = 0;
  }
  for (int i = 13; i<=24; i++) {
    infoMatrix[i][0].dx = 1;
    infoMatrix[i][0].dy = 0;
    infoMatrix[i][9].dx = 1;
    infoMatrix[i][9].dy = 0;
  }
  for (int i = 1; i<=4; i++) {
    infoMatrix[0][i].dx = 0;
    infoMatrix[0][i].dy = -1;
    infoMatrix[25][i].dx = 0;
    infoMatrix[25][i].dy = -1;
  }
  for (int i = 5; i<=8; i++) {
    infoMatrix[0][i].dx = 0;
    infoMatrix[0][i].dy = 1;
    infoMatrix[25][i].dx = 0;
    infoMatrix[25][i].dy = 1;
  }
}

void loop() {
  myLeds.refresh();

  #ifndef AUTOPILOT
  getDirection(); //putting this here makes sure no user input is missed
  #endif
  
  if (millis() - lastUpdate > millisDelay) {
    lastUpdate = millis();
    #ifdef AUTOPILOT
    getDirection(); //putting this here saves processing when in autopilot
    #endif
    if (alive) {
      mySnake.dx = nextdx;
      mySnake.dy = nextdy;
      byte snakeStatus = mySnake.growHead();
      if(snakeStatus == 2) { //if snake hit wall or self
        alive = false;
      }
      if (snakeStatus == 1) { //if snake got apple
        score++;
        spawnApple();
      } else if (snakeStatus == 0) { //normal case
        mySnake.cutTail();
      }
      myLeds.toggle(apple.x, apple.y); //flash apple
    } else {
        counter++;
        if (counter >= 3) {
          myLeds.clear();
          myLeds.writeNumber(score);
          //print state in which snake died
//          Serial.println(score);
//          for (int j =0; j<8; j++) {
//            for (int i = 0; i<24; i++) {
//              if (i==apple.x && j==apple.y) {
//                Serial.print(" * ");
//              } else if (myLeds.read(i, j)==0 ) {
//                Serial.print(".  ");
//              } else if (infoMatrix[i+1][j+1].dx == 1) {
//                Serial.print("-> ");
//              } else if (infoMatrix[i+1][j+1].dx == -1) {
//                Serial.print("<- ");
//              } else if (infoMatrix[i+1][j+1].dy == 1) {
//                Serial.print("\\/ ");
//              } else if (infoMatrix[i+1][j+1].dy == -1) {
//                Serial.print("/\\ ");
//              }
//            }
//            Serial.println();
//          }
        }
        if (counter >= 20) { //display score for some amount of time before resetting
          resetGame();
        }
    }
  }
}

void Snake::reset() {
  while(length) cutTail();
  head = 0;
  length = 1;
  snakeNodes[head].set(0,0);
  dx = 1;
  dy = 0;
}

byte Snake::growHead() {
  int newX = nextX();
  int newY = nextY();
  byte success = 0;
  if (apple.x == newX && apple.y == newY) {
    success = 1;
  }
  if (myLeds.read(newX,newY) && !success) {
    return 2;
  }
  if (myLeds.inBounds(newX,newY) ==0) {
    return 2;
  }
  head = (head + 1)%MAX_SIZE;
  length++;
  while (length > MAX_SIZE) cutTail();
  snakeNodes[head].set(newX,newY);
  infoMatrix[newX+1][newY+1].dx = dx;
  infoMatrix[newX+1][newY+1].dy = dy;
  return success;
}

void Snake::cutTail() {
  snakeNodes[(head-length+MAX_SIZE+1)%MAX_SIZE].clear();
  length--;
}


void spawnApple() {
  byte x, y;
  while (1) {
    x = random(0, myLeds.getWidth());
    y = random(0, myLeds.getHeight());
    if (myLeds.read(x,y)==0) {
      apple.set(x,y);
      return;
    }
  }
}

void resetGame() {
  myLeds.clear();
  score = 0;
  alive = true;
  mySnake.reset();
  spawnApple();
  counter = 0;
  nextdx = 1;
  nextdy = 0;
}

void getDirection() {
  #ifdef AUTOPILOT
  dir toAppleX, toAppleY;
  if (apple.x == mySnake.curX()) toAppleX = 0;
  if (apple.x > mySnake.curX()) toAppleX = 1;
  if (apple.x < mySnake.curX()) toAppleX = -1;
  if (apple.y == mySnake.curY()) toAppleY = 0;
  if (apple.y > mySnake.curY()) toAppleY = 1;
  if (apple.y < mySnake.curY()) toAppleY = -1;

  nextdx = mySnake.dx;
  nextdy = mySnake.dy;
  dir defaultX = unSafe(mySnake.nextX(), mySnake.nextY()) ? -1*infoMatrix[mySnake.nextX()+1][mySnake.nextY()+1].dx : toAppleX;
  dir defaultY = unSafe(mySnake.nextX(), mySnake.nextY()) ? -1*infoMatrix[mySnake.nextX()+1][mySnake.nextY()+1].dy : toAppleY;
  if (defaultX == 0) defaultX = 1;
  if (defaultY == 0) defaultY = 1;

  if (!unSafe(mySnake.curX() + nextdx, mySnake.curY() + nextdy)) { //if the next square is unsafe, skip all this and go right to the life-saving manuevers.
  
  if ((toAppleX == 0 && mySnake.dx) || (toAppleY == 0 && mySnake.dy)) { //turning towards apple
    nextdx = toAppleX;
    nextdy = toAppleY;
  }

  //looking ahead
  for (byte i = 0; unSafe(mySnake.curX() + 2*nextdx, mySnake.curY() + 2*nextdy) && i<3 && !(mySnake.nextX() == apple.x || mySnake.nextY() == apple.y); i++) {
    switch (i) {
      case 0:
        nextdx = mySnake.dx; //if possible continue in the current direction
        nextdy = mySnake.dy;
        break;
      case 1:
        nextdx = mySnake.dx ? 0 : (toAppleX ? toAppleX : defaultX) ; //if previously going forward, turn towards apple 
        nextdy = mySnake.dy ? 0 : (toAppleY ? toAppleY : defaultY);
        break;
      case 2:
        nextdx = -1*nextdx; //otherwise, turn away from apple
        nextdy = -1*nextdy;
        break;
    }
  }
  }

  for (byte i = 0; unSafe(mySnake.curX() + nextdx, mySnake.curY() + nextdy) && i<3; i++) {
    switch (i) {
      case 0:
        nextdx = mySnake.dx; //if possible continue in the current direction
        nextdy = mySnake.dy;
        break;
      case 1:
        nextdx = mySnake.dx ? 0 : defaultX; //turn in direction previously defined
        nextdy = mySnake.dy ? 0 : defaultY;
        break;
      case 2:
        nextdx = -1*nextdx; //otherwise, turn away from apple
        nextdy = -1*nextdy;
        break;
    }
  }
  #else
  if (analogRead(leftRight) > 823 && mySnake.dy) {
    nextdx = 1;
    nextdy = 0;
  }
  if (analogRead(leftRight) < 200 && mySnake.dy) {
    nextdx = -1;
    nextdy = 0;
  }
  if (analogRead(upDown) > 823 && mySnake.dx) {
    nextdx = 0;
    nextdy = -1;
  }
  if (analogRead(upDown) < 200 && mySnake.dx) {
    nextdx = 0;
    nextdy = 1;
  }
  #endif
}

bool unSafe(dir x, dir y) {
  if (x==apple.x && y==apple.y) return false;
  return !myLeds.inBounds(x, y) || myLeds.read(x, y);
}

Downloadable files

LedMatrix

Library for control of custom LED matrix

LedMatrix.zip

Comments

Only logged in users can leave comments

abrink

0 Followers

•

0 Projects

Intro