Arduino Retro Gaming con una pantalla OLED

#incluir
#incluir
#incluir
#incluir

#define SCREEN_WIDTH 128 // ancho de pantalla OLED, en píxeles
#define SCREEN_HEIGHT 64 // Altura de visualización OLED, en píxeles
#define OLED_RESET 4 // Reset pin # (o -1 si comparte el pin de reinicio de Arduino)

Pantalla Adafruit_SSD1306 (SCREEN_WIDTH, SCREEN_HEIGHT y Wire, OLED_RESET); // Declaración para una pantalla SSD1306 conectada a I2C (pines SDA, SCL)

resolución int [2] = {SCREEN_WIDTH, SCREEN_HEIGHT}
, bola [2] = {20, (resolución [1] / 2)};
const int PIXEL_SIZE = 8
, WALL_WIDTH = 4
, PADDLE_WIDTH = 4
, BALL_SIZE = 4
, VELOCIDAD = 3;
int playerScore = 0
, aiScore = 0
, playerPos = 0
, aiPos = 0;
char ballDirectionHori = 'R'
, ballDirectionVerti = 'S';
boolean inProgress = true;

// Prototipo das funcoes
nulo movePlayer ();
nulo moveAi ();
anular drawScore ();
anular eraseScore ();
vacío drawNet ();
void drawPixel (int posX, int posY, int dimensiones);
void erasePixel (int posX, int posY, int dimensiones);

void drawPlayerPaddle (int fila);
nulo erasePlayerPaddle (int fila);
vacío drawAiPaddle (int fila);
nulo eraseAiPaddle (int fila);
void drawBall (int x, int y);
nulo eraseBall (int x, int y);

configuración nula () {
Serial.begin (9600);

// SSD1306_SWITCHCAPVCC = generar voltaje de visualización desde 3.3V internamente
if (! display.begin (SSD1306_SWITCHCAPVCC, 0x3C)) {// Dirección 0x3D para 128x64
Serial.println (F ("Falló la asignación SSD1306"));
para (;;); // No procedas, bucle para siempre
}
display.display ();
retraso (2000); // Pausa por 2 segundos

// Borrar el búfer
display.clearDisplay ();
}

bucle vacío () {
if (aiScore> 3 || playerScore> 3) {// verifica el estado del juego
inProgress = falso;

// alguien ha ganado
display.clearDisplay ();
display.setTextSize (4);
display.setTextColor (BLANCO);
display.setCursor (0, 0); // averiguar quién
if (aiScore> playerScore)
display.println ("¡PIERDES!");
más si (playerScore> aiScore)
display.println ("¡GANAS!");
}

if (en progreso) {
eraseScore ();
eraseBall (bola [0], bola [1]);

if (ballDirectionVerti == 'U') // mueve la pelota hacia arriba en diagonal
bola [1] = bola [1] - VELOCIDAD;

if (ballDirectionVerti == 'D') // mueve la pelota hacia abajo en diagonal
bola [1] = bola [1] + VELOCIDAD;

if (bola [1] = resolución [1]) // hacer rebotar la bola desde el fondo
ballDirectionVerti = 'U';

if (ballDirectionHori == 'R') {
bola [0] = bola [0] + VELOCIDAD; // mover la pelota
if (bola [0]> = (resolución [0] - 6)) {// la bola está en el borde AI de la pantalla
if ((aiPos + 12)> = ball [1] && (aiPos - 12) (aiPos + 2)) // desvía la bola hacia abajo
ballDirectionVerti = 'D';
si no (bola [1] ballDirectionVerti = 'U';
sino // desvía la bola recta
ballDirectionVerti = 'S';

ballDirectionHori = 'L'; // cambia la dirección de la pelota
} más {// ¡META!
bola [0] = 6; // mueve la pelota al otro lado de la pantalla
ballDirectionVerti = 'S'; // reiniciar la pelota para viajar en línea recta
bola [1] = resolución [1] / 2; // mueve la pelota al centro de la pantalla
++ playerScore; // aumenta la puntuación del jugador
}
}
}

if (ballDirectionHori == 'L') {
bola [0] = bola [0] - VELOCIDAD; // mover la pelota
if (ball [0] = ball [1] && (playerPos - 12) (playerPos + 2)) // desvía la bola hacia abajo
ballDirectionVerti = 'D';
si no (bola [1] aiPos)
++ aiPos;
si no (bola [1] --aiPos;

drawAiPaddle (aiPos);
}

void drawScore () {// Dibuja AI y puntajes de jugadores
display.setTextSize (2);
display.setTextColor (BLANCO);
display.setCursor (45, 0);
display.println (playerScore);

display.setCursor (75, 0);
display.println (aiScore);
}

void eraseScore () {// Borrar AI y puntajes de jugadores
display.setTextSize (2);
display.setTextColor (NEGRO);
display.setCursor (45, 0);
display.println (playerScore);

display.setCursor (75, 0);
display.println (aiScore);
}

void drawNet () {// Dibujar campo de línea
para (int i = 0; i drawPixel (((resolución [0] / 2) - 1), i * (WALL_WIDTH) + (WALL_WIDTH * i), WALL_WIDTH);
}

void drawPixel (int posX, int posY, int dimensiones) {// Dibujar grupo de píxeles
para (int x = 0; x para (int y = 0; y display.drawPixel ((posX + x), (posY + y), BLANCO);
}

void erasePixel (int posX, int posY, int dimensiones) {// Borrar grupo de píxeles
para (int x = 0; x para (int y = 0; y display.drawPixel ((posX + x), (posY + y), NEGRO);
}

void drawPlayerPaddle (int fila) {
drawPixel (0, fila - (PADDLE_WIDTH * 2), PADDLE_WIDTH);
drawPixel (0, fila - PADDLE_WIDTH, PADDLE_WIDTH);
drawPixel (0, fila, PADDLE_WIDTH);
drawPixel (0, fila + PADDLE_WIDTH, PADDLE_WIDTH);
drawPixel (0, fila + (PADDLE_WIDTH + 2), PADDLE_WIDTH);
}

nulo erasePlayerPaddle (int fila) {
erasePixel (0, fila - (PADDLE_WIDTH * 2), PADDLE_WIDTH);
erasePixel (0, fila - PADDLE_WIDTH, PADDLE_WIDTH);
erasePixel (0, fila, PADDLE_WIDTH);
erasePixel (0, fila + PADDLE_WIDTH, PADDLE_WIDTH);
erasePixel (0, fila + (PADDLE_WIDTH + 2), PADDLE_WIDTH);
}

void drawAiPaddle (int fila) {
columna int = resolución [0] - PADDLE_WIDTH;
drawPixel (columna, fila - (PADDLE_WIDTH * 2), PADDLE_WIDTH);
drawPixel (columna, fila - PADDLE_WIDTH, PADDLE_WIDTH);
drawPixel (columna, fila, PADDLE_WIDTH);
drawPixel (columna, fila + PADDLE_WIDTH, PADDLE_WIDTH);
drawPixel (columna, fila + (PADDLE_WIDTH * 2), PADDLE_WIDTH);
}

void eraseAiPaddle (int fila) {
columna int = resolución [0] - PADDLE_WIDTH;
erasePixel (columna, fila - (PADDLE_WIDTH * 2), PADDLE_WIDTH);
erasePixel (columna, fila - PADDLE_WIDTH, PADDLE_WIDTH);
erasePixel (columna, fila, PADDLE_WIDTH);
erasePixel (columna, fila + PADDLE_WIDTH, PADDLE_WIDTH);
erasePixel (columna, fila + (PADDLE_WIDTH * 2), PADDLE_WIDTH);
}

void drawBall (int x, int y) {
display.drawCircle (x, y, BALL_SIZE, WHITE);
}

void eraseBall (int x, int y) {
display.drawCircle (x, y, BALL_SIZE, BLACK);
}