Criando o Jogo "Jump" no Arduino: Aprendendo Programação e Eletrônica
Criando o Jogo "Jump" no Arduino: Aprendendo Programação e Eletrônica
Introdução
O Arduino é uma plataforma incrível para quem deseja aprender eletrônica e programação de forma prática e divertida. Um projeto interessante para iniciantes é o jogo "Jump", onde o objetivo é controlar um personagem que pula obstáculos.
Materiais Necessários
Para montar o jogo "Jump" no Arduino, você precisará dos seguintes componentes:
Arduino Uno (ou similar)
Display LCD 16x2
Botões (para controle)
Buzzer (para efeitos sonoros)
Resistores e jumpers
Protoboard
Esses materiais são comuns em kits de Arduino e podem ser adquiridos facilmente em lojas de eletrônica.
Montagem do Circuito
O circuito do jogo "Jump" consiste em:
Display LCD: Exibe o personagem e os obstáculos.
Botões: Um para pular e outro para reiniciar o jogo.
Buzzer: Emite sons quando o jogador pula ou perde.
A Programação do Jogo
A lógica do jogo é simples, mas envolve conceitos importantes de programação, como:
1. Lógica do Jogo
O personagem (representado por um caractere no LCD) deve pular quando um botão é pressionado.
Os obstáculos aparecem aleatoriamente e se movem em direção ao personagem.
Se o personagem colidir com um obstáculo, o jogo acaba.
2. Código Básico (Exemplo Simplificado)
#include <LiquidCrystal.h>
#define PIN_BUTTON 2
#define PIN_AUTOPLAY 1
#define PIN_READWRITE 10
#define PIN_CONTRAST 12
#define SPRITE_RUN1 1
#define SPRITE_RUN2 2
#define SPRITE_JUMP 3
#define SPRITE_JUMP_UPPER '.'
#define SPRITE_JUMP_LOWER 4
#define SPRITE_TERRAIN_EMPTY ' '
#define SPRITE_TERRAIN_SOLID 5
#define SPRITE_TERRAIN_SOLID_RIGHT 6
#define SPRITE_TERRAIN_SOLID_LEFT 7
#define HERO_HORIZONTAL_POSITION 1 // Define a posição horizontal do personagem na tela
#define TERRAIN_WIDTH 16
#define TERRAIN_EMPTY 0
#define TERRAIN_LOWER_BLOCK 1
#define TERRAIN_UPPER_BLOCK 2
#define HERO_POSITION_OFF 0 // Torna personagem invisível
#define HERO_POSITION_RUN_LOWER_1 1 // Posição do personagem (pose 1)
#define HERO_POSITION_RUN_LOWER_2 2 // (pose 2)
#define HERO_POSITION_JUMP_1 3 // Inicia o salto
#define HERO_POSITION_JUMP_2 4 // Metade do caminha para cima
#define HERO_POSITION_JUMP_3 5 // Salta para a linha superior
#define HERO_POSITION_JUMP_4 6 // Salta para a linha superior
#define HERO_POSITION_JUMP_5 7 // Salta para a linha superior
#define HERO_POSITION_JUMP_6 8 // Salta para a linha superior
#define HERO_POSITION_JUMP_7 9 // Metade do caminho para baixo
#define HERO_POSITION_JUMP_8 10 // Define local de caminhada
#define HERO_POSITION_RUN_UPPER_1 11 // Personagem executado em linha superior (pose 1)
#define HERO_POSITION_RUN_UPPER_2 12 // (pose 2)
LiquidCrystal lcd(11, 9, 6, 5, 4, 3);
static char terrainUpper[TERRAIN_WIDTH + 1];
static char terrainLower[TERRAIN_WIDTH + 1];
static bool buttonPushed = false;
void initializeGraphics() {
static byte graphics[] = {
// Posição 1
B01100,
B01100,
B00000,
B01110,
B11100,
B01100,
B11010,
B10011,
// Posição 2
B01100,
B01100,
B00000,
B01100,
B01100,
B01100,
B01100,
B01110,
// Salto
B01100,
B01100,
B00000,
B11110,
B01101,
B11111,
B10000,
B00000,
// Salto baixo
B11110,
B01101,
B11111,
B10000,
B00000,
B00000,
B00000,
B00000,
// Chão
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
B11111,
// Chão a direita
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
B00011,
// Chão a esquerda
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
B11000,
};
int i;
// Desenha personagem e campo
for (i = 0; i < 7; ++i) {
lcd.createChar(i + 1, &graphics[i * 8]);
}
for (i = 0; i < TERRAIN_WIDTH; ++i) {
terrainUpper[i] = SPRITE_TERRAIN_EMPTY;
terrainLower[i] = SPRITE_TERRAIN_EMPTY;
}
}
// Desliza o terreno para esquerda
void advanceTerrain(char* terrain, byte newTerrain) {
for (int i = 0; i < TERRAIN_WIDTH; ++i) {
char current = terrain[i];
char next = (i == TERRAIN_WIDTH - 1) ? newTerrain : terrain[i + 1];
switch (current) {
case SPRITE_TERRAIN_EMPTY:
terrain[i] = (next == SPRITE_TERRAIN_SOLID) ? SPRITE_TERRAIN_SOLID_RIGHT : SPRITE_TERRAIN_EMPTY;
break;
case SPRITE_TERRAIN_SOLID:
terrain[i] = (next == SPRITE_TERRAIN_EMPTY) ? SPRITE_TERRAIN_SOLID_LEFT : SPRITE_TERRAIN_SOLID;
break;
case SPRITE_TERRAIN_SOLID_RIGHT:
terrain[i] = SPRITE_TERRAIN_SOLID;
break;
case SPRITE_TERRAIN_SOLID_LEFT:
terrain[i] = SPRITE_TERRAIN_EMPTY;
break;
}
}
}
bool drawHero(byte position, char* terrainUpper, char* terrainLower, unsigned int score) {
bool collide = false;
char upperSave = terrainUpper[HERO_HORIZONTAL_POSITION];
char lowerSave = terrainLower[HERO_HORIZONTAL_POSITION];
byte upper, lower;
switch (position) {
case HERO_POSITION_OFF:
upper = lower = SPRITE_TERRAIN_EMPTY;
break;
case HERO_POSITION_RUN_LOWER_1:
upper = SPRITE_TERRAIN_EMPTY;
lower = SPRITE_RUN1;
break;
case HERO_POSITION_RUN_LOWER_2:
upper = SPRITE_TERRAIN_EMPTY;
lower = SPRITE_RUN2;
break;
case HERO_POSITION_JUMP_1:
case HERO_POSITION_JUMP_8:
upper = SPRITE_TERRAIN_EMPTY;
lower = SPRITE_JUMP;
break;
case HERO_POSITION_JUMP_2:
case HERO_POSITION_JUMP_7:
upper = SPRITE_JUMP_UPPER;
lower = SPRITE_JUMP_LOWER;
break;
case HERO_POSITION_JUMP_3:
case HERO_POSITION_JUMP_4:
case HERO_POSITION_JUMP_5:
case HERO_POSITION_JUMP_6:
upper = SPRITE_JUMP;
lower = SPRITE_TERRAIN_EMPTY;
break;
case HERO_POSITION_RUN_UPPER_1:
upper = SPRITE_RUN1;
lower = SPRITE_TERRAIN_EMPTY;
break;
case HERO_POSITION_RUN_UPPER_2:
upper = SPRITE_RUN2;
lower = SPRITE_TERRAIN_EMPTY;
break;
}
if (upper != ' ') {
terrainUpper[HERO_HORIZONTAL_POSITION] = upper;
collide = (upperSave == SPRITE_TERRAIN_EMPTY) ? false : true;
}
if (lower != ' ') {
terrainLower[HERO_HORIZONTAL_POSITION] = lower;
collide |= (lowerSave == SPRITE_TERRAIN_EMPTY) ? false : true;
}
byte digits = (score > 9999) ? 5 : (score > 999) ? 4 : (score > 99) ? 3 : (score > 9) ? 2 : 1;
// Desenha a cena
terrainUpper[TERRAIN_WIDTH] = '\0';
terrainLower[TERRAIN_WIDTH] = '\0';
char temp = terrainUpper[16 - digits];
terrainUpper[16 - digits] = '\0';
lcd.setCursor(0, 0);
lcd.print(terrainUpper);
terrainUpper[16 - digits] = temp;
lcd.setCursor(0, 1);
lcd.print(terrainLower);
lcd.setCursor(16 - digits, 0);
lcd.print(score);
terrainUpper[HERO_HORIZONTAL_POSITION] = upperSave;
terrainLower[HERO_HORIZONTAL_POSITION] = lowerSave;
return collide;
}
// Considerar o premir do botão como uma interrupção
void buttonPush() {
buttonPushed = true;
}
void setup() {
pinMode(PIN_READWRITE, OUTPUT);
digitalWrite(PIN_READWRITE, LOW);
pinMode(PIN_CONTRAST, OUTPUT);
digitalWrite(PIN_CONTRAST, HIGH);
pinMode(PIN_BUTTON, INPUT);
digitalWrite(PIN_BUTTON, HIGH);
pinMode(PIN_AUTOPLAY, OUTPUT);
digitalWrite(PIN_AUTOPLAY, HIGH);
attachInterrupt(0/*PIN_BUTTON*/, buttonPush, FALLING);
initializeGraphics();
lcd.begin(16, 2);
}
void loop() {
static byte heroPos = HERO_POSITION_RUN_LOWER_1;
static byte newTerrainType = TERRAIN_EMPTY;
static byte newTerrainDuration = 1;
static bool playing = false;
static bool blink = false;
static unsigned int distance = 0;
if (!playing) {
drawHero((blink) ? HERO_POSITION_OFF : heroPos, terrainUpper, terrainLower, distance >> 3);
if (blink) {
lcd.setCursor(1, 0);
lcd.print("");
lcd.setCursor(4, 1);
lcd.print("");
delay(1000);
}
{
lcd.setCursor(1, 0);
lcd.print("Inicie o Jogo");
lcd.setCursor(4, 1);
lcd.print("");
delay(1000);
}
delay(250);
blink = !blink;
if (buttonPushed) {
initializeGraphics();
heroPos = HERO_POSITION_RUN_LOWER_1;
playing = true;
buttonPushed = false;
distance = 0;
}
return;
}
// Desloca o terreno para esquerda
advanceTerrain(terrainLower, newTerrainType == TERRAIN_LOWER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
advanceTerrain(terrainUpper, newTerrainType == TERRAIN_UPPER_BLOCK ? SPRITE_TERRAIN_SOLID : SPRITE_TERRAIN_EMPTY);
// Cria um novo terreno para entrar a direita
if (--newTerrainDuration == 0) {
if (newTerrainType == TERRAIN_EMPTY) {
newTerrainType = (random(3) == 0) ? TERRAIN_UPPER_BLOCK : TERRAIN_LOWER_BLOCK;
newTerrainDuration = 2 + random(10);
} else {
newTerrainType = TERRAIN_EMPTY;
newTerrainDuration = 10 + random(10);
}
}
if (buttonPushed) {
if (heroPos <= HERO_POSITION_RUN_LOWER_2) heroPos = HERO_POSITION_JUMP_1;
buttonPushed = false;
}
if (drawHero(heroPos, terrainUpper, terrainLower, distance >> 3)) {
playing = false; // O personagem colidiu com algo
}
else {
if (heroPos == HERO_POSITION_RUN_LOWER_2 || heroPos == HERO_POSITION_JUMP_8) {
heroPos = HERO_POSITION_RUN_LOWER_1;
} else if ((heroPos >= HERO_POSITION_JUMP_3 && heroPos <= HERO_POSITION_JUMP_5) && terrainLower[HERO_HORIZONTAL_POSITION] != SPRITE_TERRAIN_EMPTY) {
heroPos = HERO_POSITION_RUN_UPPER_1;
} else if (heroPos >= HERO_POSITION_RUN_UPPER_1 && terrainLower[HERO_HORIZONTAL_POSITION] == SPRITE_TERRAIN_EMPTY) {
heroPos = HERO_POSITION_JUMP_5;
} else if (heroPos == HERO_POSITION_RUN_UPPER_2) {
heroPos = HERO_POSITION_RUN_UPPER_1;
} else {
++heroPos;
}
++distance;
digitalWrite(PIN_AUTOPLAY, terrainLower[HERO_HORIZONTAL_POSITION + 2] == SPRITE_TERRAIN_EMPTY ? HIGH : LOW);
}
delay(100);
}
Este é um exemplo simplificado, mas no projeto completo você precisará adicionar obstáculos, pontuação e sons.
A Importância de Entender a Programação por Trás dos Jogos
Criar jogos no Arduino não é apenas divertido, mas também educativo. Aqui estão alguns benefícios:
1. Desenvolvimento do Raciocínio Lógico
Programar jogos ajuda a entender estruturas como loops, condicionais e funções, essenciais para qualquer programador.
2. Aprendizado de Eletrônica
Montar o circuito ensina como componentes como LCDs, botões e buzzers funcionam na prática.
3. Criatividade e Resolução de Problemas
Você pode modificar o jogo, adicionando novos recursos, como inimigos, power-ups ou fases diferentes.
4. Base para Jogos Mais Complexos
Entender a lógica por trás de um jogo simples como o "Jump" é o primeiro passo para desenvolver projetos mais avançados, como jogos em Unity ou Godot.
Conclusão
O jogo "Jump" no Arduino é um excelente projeto para iniciantes, combinando programação e eletrônica de forma interativa. Ao entender como o código controla o hardware, você desenvolve habilidades valiosas para projetos futuros.
Comentários
Postar um comentário