Nota

Ciao, benvenuto nella community SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasts su Facebook! Approfondisci Raspberry Pi, Arduino ed ESP32 con altri appassionati.

Perché unirsi?

Supporto Esperto: Risolvi problemi post-vendita e sfide tecniche con l’aiuto della nostra community e del nostro team.
Impara & Condividi: Scambia consigli e tutorial per migliorare le tue competenze.
Anteprime Esclusive: Ottieni l’accesso anticipato agli annunci di nuovi prodotti e anteprime esclusive.
Sconti Speciali: Goditi sconti esclusivi sui nostri prodotti più recenti.
Promozioni e Concorsi Festivi: Partecipa a concorsi e promozioni festive.

👉 Pronto a esplorare e creare con noi? Clicca [Qui] e unisciti oggi stesso!

GIOCO - Snake

Questo esempio implementa il classico gioco Snake su una matrice LED 8x12 utilizzando la scheda R4 Wifi. I giocatori controllano la direzione del serpente utilizzando un joystick a doppio asse.

Componenti Necessari

In questo progetto, abbiamo bisogno dei seguenti componenti.

È sicuramente conveniente acquistare un kit completo, ecco il link:

Nome	ELEMENTI IN QUESTO KIT	LINK
Elite Explorer Kit	300+	Elite Explorer Kit

Puoi anche acquistarli separatamente dai link sottostanti.

INTRODUZIONE COMPONENTI	LINK ACQUISTO
Arduino Uno R4 WiFi	-
Cavi Jumper	ACQUISTA
Modulo Joystick	ACQUISTA

Collegamenti

Schema Elettrico

Codice

Nota

Puoi aprire il file 13_snake.ino nel percorso elite-explorer-kit-main\fun_project\13_snake direttamente.
Oppure copia questo codice nell’Arduino IDE.

13_snake.ino

/*
  This code implements a simple Snake game using an Arduino Uno R4 and a 
  Joystick Module. The Snake moves based on joystick input, and the 
  objective is to eat randomly generated food without colliding with 
  the snake's body. The game ends if the snake collides with itself.

  Board: Arduino Uno R4 
  Component: Joystick Module
*/


#include "Arduino_LED_Matrix.h"

ArduinoLEDMatrix matrix;
byte frame[8][12];
byte flatFrame[8 * 12];  // Flattened frame for matrix.loadPixels()

// Snake variables
struct Point {
  byte x;
  byte y;
};

Point snake[100];
int snakeLength = 3;
Point food;
int direction = 0;  // 0=up, 1=right, 2=down, 3=left

void setup() {
  pinMode(A0, INPUT);  // joystick X-axis
  pinMode(A1, INPUT);  // joystick Y-axis

  // Initialize LED matrix
  matrix.begin();

  // Initialize snake at middle of screen
  snake[0] = { 6, 4 };
  snake[1] = { 6, 5 };
  snake[2] = { 6, 6 };

  // Generate initial food
  generateFood();
}

void loop() {
  // Read joystick input
  int x = analogRead(A0);
  int y = analogRead(A1);

  // Determine new direction based on joystick
  if (x > 600 && direction != 3) direction = 1;
  else if (x < 400 && direction != 1) direction = 3;
  else if (y > 600 && direction != 0) direction = 2;
  else if (y < 400 && direction != 2) direction = 0;

  // Move snake
  moveSnake();

  // Check for collision with food
  if (snake[0].x == food.x && snake[0].y == food.y) {
    snake[snakeLength] = snake[snakeLength - 1];  // Initialize the new segment
    snakeLength++;
    generateFood();
  }

  // Check for collision with self
  for (int i = 1; i < snakeLength; i++) {
    if (snake[0].x == snake[i].x && snake[0].y == snake[i].y) {
      // Reset game (or end game)
      snakeLength = 3;
      snake[0] = { 6, 4 };
      snake[1] = { 6, 5 };
      snake[2] = { 6, 6 };
      direction = 0;
      generateFood();
    }
  }

  // Draw to LED matrix
  drawFrame();

  // Delay to control speed
  delay(200);
}

void moveSnake() {
  for (int i = snakeLength - 1; i > 0; i--) {
    snake[i] = snake[i - 1];
  }

  // Move the head of the snake based on the direction
  switch (direction) {
    case 0:
      snake[0].y = (snake[0].y - 1 + 8) % 8;  // Wrap around at the top and bottom edges
      break;
    case 1:
      snake[0].x = (snake[0].x + 1) % 12;  // Wrap around at the right and left edges
      break;
    case 2:
      snake[0].y = (snake[0].y + 1) % 8;  // Wrap around at the bottom and top edges
      break;
    case 3:
      snake[0].x = (snake[0].x - 1 + 12) % 12;  // Wrap around at the left and right edges
      break;
  }
}

void generateFood() {
  Point possibleLocations[8 * 12];
  int idx = 0;

  // Generate all possible locations for the food
  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 12; x++) {
      bool overlap = false;

      // Check for overlap with the snake
      for (int i = 0; i < snakeLength; i++) {
        if (snake[i].x == x && snake[i].y == y) {
          overlap = true;
          break;
        }
      }

      if (!overlap) {
        possibleLocations[idx++] = { x, y };
      }
    }
  }

  // Randomly choose a location for the food from the possible locations
  int choice = random(0, idx);
  food = possibleLocations[choice];
}

void drawFrame() {
  // Clear frame
  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 12; x++) {
      frame[y][x] = 0;
    }
  }

  // Draw snake
  for (int i = 0; i < snakeLength; i++) {
    frame[snake[i].y][snake[i].x] = 1;
  }

  // Draw food
  frame[food.y][food.x] = 1;

  // Flatten frame array and load into LED matrix
  int idx = 0;
  for (int y = 0; y < 8; y++) {
    for (int x = 0; x < 12; x++) {
      flatFrame[idx++] = frame[y][x];
    }
  }
  matrix.loadPixels(flatFrame, 8 * 12);
  matrix.renderFrame(0);
}

Come funziona?

Ecco una spiegazione dettagliata del codice:

Definizione e Inizializzazione delle Variabili

Importa la libreria Arduino_LED_Matrix per le operazioni sulla matrice LED. matrix è un’istanza della matrice LED. frame e flatFrame sono array utilizzati per memorizzare e processare le informazioni dei pixel sullo schermo. Il serpente è rappresentato come un array di strutture Point, dove ogni punto ha una coordinata x e y. food rappresenta la posizione del cibo. direction è la direzione di movimento corrente del serpente.
setup()

Inizializza gli assi X e Y del joystick come input. Avvia la matrice LED. Inizializza la posizione iniziale del serpente al centro dello schermo. Genera casualmente la posizione iniziale del cibo.
loop()

Determina la direzione del serpente in base alle letture del joystick. Muove il serpente. Controlla se la testa del serpente collide con il cibo. Se lo fa, il serpente cresce e viene generato nuovo cibo in una nuova posizione. Controlla se il serpente collide con sé stesso. Se lo fa, resetta il gioco. Disegna lo stato attuale del gioco (posizioni del serpente e del cibo) sulla matrice LED. Aggiunge un ritardo per controllare la velocità del gioco.
moveSnake()

Muove ogni parte del serpente nella posizione della parte precedente, iniziando dalla coda e andando verso la testa. Muove la testa del serpente in base alla sua direzione.
generateFood()

Genera tutte le possibili posizioni del cibo. Controlla se ogni posizione si sovrappone a una parte del serpente. Se non si sovrappone, la posizione è considerata una possibile posizione del cibo. Seleziona casualmente una posizione possibile del cibo.
drawFrame()

Cancella il frame corrente. Disegna il serpente e il cibo sul frame. Appiattisce l’array frame bidimensionale in un array unidimensionale (flatFrame) e lo carica sulla matrice LED.