LCD Hill Run v2 – Jogo Runner Interativo para Arduino com Display 16x2 e Buzzer

Componentes e Materiais

Aplicativos e Serviços Online

• Arduino IDE (ou editor web)

Sobre o Projeto

Sou apenas uma criança e um amador no Arduino. Após ler alguns projetos do Project Hub e aprender Arduino, fui inspirado a criar este jogo divertido. Não exigiu muita depuração e ficou muito legal. O código está bem limpo pelos meus padrões. DIVIRTAM-SE!! Por favor, respeitem e comentem.

Lembrem-se de baixar as bibliotecas incluídas neste programa e colocá-las na pasta do diretório. Se houver erro de biblioteca não encontrada, use Sketch > Incluir Biblioteca. Comentem se tiverem problemas.

Bibliotecas em: https://github.com/PunkyMunky64/HillRun2Libraries

Código

Código Hill Run v2 Arduino

O código. Altere DUCK_PIN para 3 se quiser usar um UNO. O código é bastante compacto e limpo, se me permitem dizer.

/* 
 * Copyright (c) 2020 por Miles C. Versão melhorada do hill run com interrupções para melhorar o código. 
 * ATENÇÃO: DUCK_PIN É 18 EM VEZ DE 4 por causa das capacidades de interrupção! 
 * Hill run, um jogo divertido onde você pula colinas e abaixa sob corvos.
 * Ligação:
 * Arduino +5V para barramento de alimentação da protoboard
 * Arduino GND para barramento de terra da protoboard
 * Botão de pulo com pull-down 10k para terra, e para pino digital 2, outro lado no +5V.
 * Botão de abaixar com pull-down 10k para terra, e para pino digital 18, outro lado no +5V.
 * Buzzer passivo com um lado no terra e outro no pino PWM digital 5.
 * LCD 16x2 16 pinos com ligação normal do Arduino, como na lição do LCD:
 * - K para terra
 * - A para +5V
 * - D4 a D7 para pinos 9 a 12
 * - E para pino 8
 * - RW para terra
 * - RS para pino 7
 * - V0 para saída do potenciômetro (brilho), potenciômetro ligado ao +5V e terra
 * - VDD para +5V
 * - VSS para terra
 */
#include <LiquidCrystal.h>
#include "pitches.h"

LiquidCrystal lcd(7, 8, 9, 10, 11, 12);
const int JUMP_PIN = 2;
const int BUZZER_PIN = 5;
const int DUCK_PIN = 18; // mude para 3 se usar UNO
const int JUMP_PITCH = 2700;
const int JUMP_PITCH_DURATION = 50;
const int DUCK_PITCH = 1350;
const int DUCK_PITCH_DURATION = 50;
const int DIE_PITCH = 200;
const int DIE_PITCH_DURATION = 500;
const int TICKSPEED = 90; // ms por tick do jogo, 1 tick por movimento da colina
const int JUMP_LENGTH = 3; // caracteres pulados quando pulo é pressionado

const byte stickStep1[8] = { B01110, B01110, B00101, B11111, B10100, B00110, B11001, B00001 };
const byte stickStep2[8] = { B01110, B01110, B00101, B11111, B10100, B00110, B01011, B01000 };
const byte stickJump[8] = { B01110, B01110, B00100, B11111, B00100, B11111, B10001, B00000 };
const byte stickDuck[8] = { B00000, B00000, B00000, B01110, B01110, B11111, B00100, B11111 };
const byte hill[8] = { B00000, B00100, B01010, B01110, B11101, B10101, B11001, B11111 };
const byte crow1[8] = { B00111, B00100, B00110, B01111, B11111, B01111, B00110, B00111 };
const byte crow2[8] = { B00111, B00110, B01111, B11111, B01111, B00110, B00110, B00111 };

volatile int jumpPhase = JUMP_LENGTH + 1;
int gameTick = 0;
int crowX = 40;
int hillX = 25;
bool playerY = 0;
volatile bool ducking = LOW;
bool loopBreaker = 1;
bool crowGo = 0;
int score = 0;

void setup() {
  pinMode(JUMP_PIN, INPUT);
  pinMode(BUZZER_PIN, OUTPUT);
  lcd.begin(16, 2);
  lcd.createChar(0, hill);
  lcd.createChar(1, stickStep1);
  lcd.createChar(2, stickStep2);
  lcd.createChar(3, stickJump);
  lcd.createChar(4, stickDuck);
  lcd.createChar(5, crow1);
  lcd.createChar(6, crow2);
  attachInterrupt(digitalPinToInterrupt(JUMP_PIN), seeJumping, RISING);
  attachInterrupt(digitalPinToInterrupt(DUCK_PIN), seeDucking, CHANGE);
}

void loop() {
  playerY = 0;
  if (jumpPhase < JUMP_LENGTH) { playerY = 1; }
  drawSprites();
  loopBreaker = 1;
  if (hillX < 16) {
    if (crowX < hillX) { hillX += 8; loopBreaker = 0; }
    if (loopBreaker) { lcd.setCursor(hillX, 1); lcd.write((byte)0); }
  }
  if (hillX < 1) {
    if (jumpPhase < JUMP_LENGTH) { score++; hillX = 16 + rand() % 8; }
    else { endGame(); }
  }
  if (crowX < 16) {
    lcd.setCursor(crowX, 0);
    if (gameTick % 8 < 4) { lcd.write((byte)5); }
    else { lcd.write((byte)6); }
  }
  if (crowX < 1) {
    if (ducking) { score++; crowX = 24 + rand() % 16; }
    else { endGame(); }
  }
  lcd.setCursor(0, playerY); lcd.print(" ");
  jumpPhase++;
  hillX--;
  crowGo = !crowGo;
  crowX -= crowGo;
  gameTick++;
  delay(TICKSPEED);
}

void endGame() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Score: ");
  lcd.setCursor(7, 0);
  lcd.print(score);
  tone(BUZZER_PIN, DIE_PITCH, DIE_PITCH_DURATION);
  while (!digitalRead(JUMP_PIN)) {
    lcd.setCursor(0, 1);
    if (millis() % 500 < 250) { lcd.print("Pule para Continuar"); }
    else { lcd.print(" "); }
  }
  lcd.clear();
  score = 0;
  hillX = 25;
  crowX = 40;
}

void drawSprites() {
  lcd.setCursor(0, 1 - playerY);
  if (!ducking) {
    if (!playerY) {
      if ((gameTick % 4) < 2) { lcd.write((byte)1); }
      else { lcd.write((byte)2); }
    } else { lcd.write((byte)3); }
  } else { lcd.write((byte)4); }
  lcd.setCursor(1, 1); lcd.print(" ");
  lcd.setCursor(1, 0); lcd.print(" ");
}

void seeJumping() {
  if (jumpPhase > (JUMP_LENGTH + 2) && !ducking) {
    jumpPhase = 0;
    tone(BUZZER_PIN, JUMP_PITCH, JUMP_PITCH_DURATION);
  }
}

void seeDucking() {
  ducking = digitalRead(DUCK_PIN);
  if (ducking) {
    jumpPhase = JUMP_LENGTH;
    tone(BUZZER_PIN, DUCK_PITCH, DUCK_PITCH_DURATION);
  }
}

README Markdown

As informações:

"Aproveite este jogo Hillrun! Pule colinas pressionando o botão de pulo, e abaixe sob corvos segurando o botão de abaixar. NÃO BATA! Se morrer, pressione pulo para continuar. Pontuação = corvos abaixados + colinas puladas. Acesse https://create.arduino.cc/projecthub/PunkyMunky64/lcd-hill-run-v2-runner-game-1b0523 para mais informações. Sou apenas uma criança de 12 anos e amador no Arduino. Após ler projetos do Project Hub e aprender Arduino, fui inspirado a criar este jogo divertido. Não exigiu muita depuração e ficou muito legal. O código está bem limpo pelos meus padrões. DIVIRTAM-SE!! Por favor, respeitem e comentem. Lembrem-se de baixar as bibliotecas incluídas neste programa e colocá-las na pasta do diretório. Se houver erro de biblioteca não encontrada, use Sketch > Incluir Biblioteca. Comentem se tiverem problemas. Bibliotecas em https://github.com/PunkyMunky64/HillRun2Libraries. SE QUISER USAR UM UNO: no código altere const int DUCK_PIN para 3. E refaça a ligação do botão de abaixar do pino 18 para o pino digital 3. Copyright (c) HillRun2.ino por Miles C. 2020 sob Licença Pública Geral GNU. Para esquemático de ligação e peças necessárias, visite a página do Arduino linkada acima."

Esquemáticos

Diagrama Esquemático do Circuito
hillrun2_zp0SI4wns3.fzz
Este é o diagrama esquemático de ligação do HillRun. SE QUISER USAR UM UNO: no código altere const int DUCK_PIN para 3. E refaça a ligação do botão de abaixar do pino 18 para o pino digital 3.