Skip to content

Jugador

Vamos a comenzar a definir la clase Jugador, que representará al jugador en el juego. Esta clase se encargará de manejar la posición, el movimiento y la interacción del jugador con los elementos del juego.

Es importante destacar que el jugador será representado por un sprite en pantalla, que es representado por un cubo que recogerá los power-ups y evitará los obstáculos.

Vamos en primer lugar a importar los recursos necesarios para la clase jugador, utilizaremos los assets que hemos descargado anteriormente. Recuerda que los assets son imágenes que representan los elementos del juego, y que se encuentran en la carpeta assets del proyecto.

Info

Recuerda que para convertir las imágenes a un formato compatible con Arduboy, vamos a utilizar la herramienta online de conversión. https://www.bloggingadeadhorse.com/TeamARGImgConverter/.

Una vez convertida la imagen del jugador, vamos a guardarlo en un fichero .h con todos los recursos del juego. Para ello, en nuestro Arduino IDE, vamos a crear un nuevo fichero llamado recources.h y vamos a pegar el código generado por la herramienta de conversión. Este fichero contendrá todos los recursos del juego, incluyendo la imagen del jugador.

Note

Para crear un nuevo fichero en el Arduino IDE, tendras que pulsar en el botón ... que encontrarás en la parte superior derecha del IDE, y seleccionar New Tab (Nueva Pestaña). Luego, le das un nombre al fichero y pulsas OK. A continuación, puedes pegar el código generado por la herramienta de conversión en el nuevo fichero.

#ifndef RESOURCES_H
#define RESOURCES_H

const uint8_t PROGMEM playerSprt[] = {
16, 16,
0x00, 0xf0, 0x88, 0x88, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x88, 0x88, 0xf0, 0x00, 
0x00, 0x1f, 0x3f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x7f, 0x3f, 0x1f, 0x00, 
};

#endif

Clase Jugador

Vamos con la clase jugador; que representará al jugador en el juego. Esta clase se encargará de manejar la posición, el movimiento y la interacción del jugador con los elementos del juego.

Recuerda que Arduino se basa en la utilización de clases y objetos a través del lenguaje de programación C++. Una clase es una plantilla que nos permite crear objetos con propiedades y métodos específicos. En este caso, la clase Jugador tendrá propiedades como la posición del jugador en pantalla, y métodos como el movimiento del jugador y la detección de colisiones con los elementos del juego.

Info

Si quieres aprender a programar en C++ para Arduino, te recomiendo que consultes la documentación oficial de Arduino o algún tutorial específico sobre programación orientada a objetos en C++ o incluso puedes consultar los siguientes apuntes: https://makeclassicgames.dev/cplusplus/.

En C++, una clase se define utilizando un fichero de cabecera .h y un fichero de implementación .cpp. El fichero de cabecera contiene la definición de la clase, incluyendo sus propiedades y métodos, mientras que el fichero de implementación contiene el código que implementa los métodos de la clase.

Vamos a ver la definición de la clase Jugador en el fichero jugador.h:

#ifndef PLAYER_H
#define PLAYER_H
#include <Arduboy2.h>


class Player{
  private:
    // Propiedades de la clase
    byte x,y;
    byte lives;
    int score;
  public:
    // Constructor y Destructor
    Player(byte x, byte y);
    ~Player();
    // Métodos de la clase
    void setPosition(byte x, byte y);
    void setScore(int score);
    void addScore(int addScore);
    void decreasseLive();
    byte getLives();
    int getScore();
    void restart();
    void Update(Arduboy2Base* arduboy);
    void Draw(Arduboy2Base* arduboy, Sprites* sprites);
};

#endif

En este fichero, podemos observar tanto las propiedades de la clase Jugador, como los métodos que nos permitirán interactuar con el jugador en el juego. A continuación, vamos a ver la implementación de la clase Jugador en el fichero jugador.cpp:

#include "player.h"

#include "resources.h"

#define PLAYER_SPEED 2

Player::Player(byte x, byte y){
  this->lives = 3;
  this->score = 0;
  this->x = x;
  this->y = y;
}

Player::~Player() {
}

void Player::setPosition(byte x, byte y) {
  this->x = x;
  this->y = y;
}
void Player::setScore(int score) {
  this->score = score;
}

void Player::decreasseLive() {
  this->lives--;
}
byte Player::getLives() {
  return this->lives;
}

void Player::restart(){
  this->x = 48;
  this->y = 48;
  this->score = 0;
  this->lives = 3;
}

int Player::getScore(){
  return this->score;
}


void Player::addScore(int addScore){
  this->score+=addScore;
}

void Player::Update(Arduboy2Base* arduboy) {
  //TODO: Pa despueh
  if (arduboy->pressed(LEFT_BUTTON) && this->x > 0) {
    this->x -= PLAYER_SPEED;
  }
  if (arduboy->pressed(RIGHT_BUTTON) && this->x < 112) {
    this->x += PLAYER_SPEED;
  }
}
void Player::Draw(Arduboy2Base* arduboy, Sprites* sprites) {
  sprites->drawOverwrite(this->x, this->y, playerSprt, 0);
}

Como podrás ver, en el fichero jugador.cpp se implementan los métodos de la clase Jugador, incluyendo el constructor y destructor, así como los métodos para manejar la posición, el movimiento y la interacción del jugador con los elementos del juego.

Es importante mencionar, que en el método Update() se comprueba si el jugador ha pulsado los botones de dirección izquierda o derecha, y se actualiza la posición del jugador en consecuencia. Además, en el método Draw() se dibuja el sprite del jugador en la pantalla utilizando la clase Sprites de la librería Arduboy2.

Una vez creada la clase, vamos a añadirla a nuestro juego. Para ello, vamos a añadirlo a nuestro fichero ardugame.ino, que es el fichero principal del juego, donde se inicializan los elementos del juego y se maneja la lógica del mismo. A continuación, vamos a ver cómo añadir la clase Jugador al fichero ardugame.ino:

//Añadir variable global

Player player(48, 48); // Creamos un objeto de la clase Player en la posición (48, 48)

En la función de UpdateGamePlay, vamos a llamar al método Update() del objeto player, para actualizar la posición del jugador en función de los botones pulsados por el jugador. A continuación, vamos a ver cómo hacerlo:

void UpdateGameplay() {
    player.Update(&arduboy); // Actualizamos la posición del jugador
}

Por último, en la función de DrawGameplay, vamos a llamar al método Draw() del objeto player, para dibujar el sprite del jugador en la pantalla. A continuación, vamos a ver cómo hacerlo:

void DrawGameplay() {
    player.Draw(&arduboy, &sprites); // Dibujamos el sprite del jugador
}

Ya podemos compilar y subir el juego a nuestra consola Arduboy, para ver cómo se mueve el jugador en pantalla al pulsar los botones de dirección izquierda y derecha.