Rutas
/
C++
C++
/
Ejercicios
/
El juego de alienígenas de Ellen
El juego de alienígenas de Ellen

El juego de alienígenas de Ellen

Ejercicio de aprendizaje

Introducción

Clases

Es hora de llegar a uno de los paradigmas fundamentales de C++: la programación orientada a objetos (POO). La POO gira en torno a las classes, tipos de datos definidos por el usuario con su propio conjunto de funciones relacionadas. Empezaremos por lo básico y cubriremos temas más avanzados más adelante en el temario.

Miembros

Las clases pueden tener variables miembro y funciones miembro. Se accede a ellas mediante el operador de selección de miembros .. Igual que ocurre con las variables fuera de las classes, es recomendable inicializar las variables miembro con un valor en el momento de declararlas. Ese valor pasará a ser el valor por defecto de los objetos de esta clase que se creen a partir de entonces.

Encapsulación y ocultación de información

Las clases ofrecen la posibilidad de restringir el acceso a sus miembros. Los dos access specifiers básicos son private y public. No se puede acceder a los miembros private desde fuera de la clase. Se puede acceder libremente a los miembros public. Todos los miembros de una class son private por defecto. Solo los miembros marcados explícitamente como public se pueden usar libremente fuera de la clase.

Ejemplo básico

La definición de una class puede verse en el siguiente ejemplo. Fíjate en el ; que va después de la definición:

class Wizard {
  public:               // from here on all members are publicly accessible
    int cast_spell() {  // defines the public member function cast_spell
      return damage;
    }
    std::string name{}; // defines the public member variable `name`
  private:              // from here on all members are private
    int damage{5};      // defines the private member variable `damage`
};

Puedes acceder a todas las variables miembro desde dentro de la clase. Echa un vistazo a damage dentro de la función cast_spell. No puedes leer ni cambiar los miembros private desde fuera de la clase:

Wizard silverhand{};
// calling the `cast_spell` function is okay, it is public:
silverhand.cast_spell();
// => 5

// name is public and can be changed:
silverhand.name = "Laeral";

// damage is private:
silverhand.damage = 500;
 // => Compilation error

Constructores

Los constructores ofrecen la posibilidad de asignar valores a las variables miembro en el momento de crear el objeto. Tienen el mismo nombre que la class y no tienen tipo de retorno. Una clase puede tener varios constructores. Esto es útil si no siempre necesitas establecer todas las variables. A veces puede que quieras dejar todo con los valores por defecto pero cambiar la variable name. En el caso de un mago poderoso, puede que también quieras cambiar el daño, así que necesitarás dos constructors.

class Wizard {
  public:
    Wizard(std::string new_name) {
      name = new_name;
    }
    Wizard(std::string new_name, int new_damage) {
      name = new_name;
      damage = new_damage;
    }
    int cast_spell() {
      return damage;
    }
    std::string name{};
  private:
    int damage{5};
};

Wizard el{"Eleven"};       // deals  5 damage
Wizard vecna{"Vecna", 50}; // deals 50 damage

Los constructores son un tema extenso y tienen muchos matices. Si no defines explícitamente un constructor para tu class, será entonces, y solo entonces, cuando el compilador haga el trabajo por ti. Esto es lo que ha ocurrido en el primer ejemplo de arriba. El objeto silverhand se crea llamando al constructor por defecto, sin pasar ningún argumento. Todas las variables se establecen al valor indicado en la definición de la clase. Si no hubieras dado ningún valor en esa definición, las variables podrían quedar sin inicializar, lo que podría tener consecuencias no deseadas.

Note

Estructuras

Las estructuras provienen de las raíces originales del lenguaje en C y son tan antiguas como el propio C++. En esencia, son lo mismo que las classes, con una excepción importante. Por defecto, todo lo que hay en una class es private. Las estructuras, en cambio, son public hasta que se defina lo contrario. Por convención, la palabra clave struct se usa a menudo para estructuras que solo contienen datos. Se prefiere la palabra clave class para objetos que necesitan garantizar ciertas propiedades. Una de esas invariantes podría ser que el damage de tu class Wizard no pueda volverse negativo. La variable damage es privada y cualquier función que cambie el daño garantizaría que se preserve la invariante.

Instrucciones

Ellen está creando un juego en el que el jugador tiene que luchar contra alienígenas. Acaba de aprender programación orientada a objetos (POO) y está deseosa de aprovechar lo que el uso de classes podría ofrecer a su programa.

Para alegría de Ellen, te has ofrecido a ayudarla y ella te ha encargado programar los alienígenas contra los que tiene que luchar el jugador.

1. Crea la clase Alien

Define la clase Alien con un constructor que acepte dos parámetros int, x e y, y los guarde en las variables miembro x_coordinate y y_coordinate. Cada alienígena también empezará con un nivel de salud de 3, así que la variable miembro health también debe inicializarse.

health debe ser una variable miembro privada. Para que otras partes del programa puedan leer la información de salud, Ellen quiere tener un método public get_health() que devuelva un int.

Alien alien{2, 0};
alien.x_coordinate;
// => 2
alien.y_coordinate;
// => 0
alien.get_health();
// => 3

Ahora, cada alienígena debe ser capaz de llevar internamente un seguimiento de su propia posición y su propia salud.

2. La función hit

A Ellen le gustaría que la class Alien tuviera un método hit que reduzca en 1 la salud de un objeto alienígena cuando se llame. Así, puede simplemente llamar a some_alien_instance.hit() en lugar de tener que cambiar manualmente la salud de un alienígena. Asegúrate de que los puntos de salud no bajen por debajo de cero. La función debe devolver true. Ellen quiere introducir escudos más adelante, que en ese caso devolverían false si el escudo está activo.

Alien alien {0, 0};
alien.get_health();
// => 3 (Initial health value)

alien.hit(); // Decrements health by 1 point.
alien.get_health();
// => 2

3. La función is_alive

Te das cuenta de que, si la salud sigue disminuyendo, en algún momento probablemente llegará a 0. Sería buena idea añadir un método is_alive al que Ellen pueda llamar rápidamente para comprobar si el alienígena está... bueno... vivo. 😉 some_alien_instance.is_alive() debe devolver un Boolean.

alien.get_health();
// => 1
alien.is_alive();
// => true
alien.hit();
alien.get_health();
// => 0
alien.is_alive();
// => false

4. La función teleport

¡En el juego de Ellen, los alienígenas pueden teletransportarse! Tendrás que escribir un método teleport que reciba los valores x_new y y_new y cambie las coordenadas del alienígena en consecuencia. Por ahora, la función debe devolver true. Ellen quiere añadir bombas que bloqueen el teletransporte en niveles posteriores, que en ese caso devolverían false para los intentos de teletransporte fallidos.

alien.teleport(5, -4);
alien.x_coordinate;
// => 5
alien.y_coordinate;
// => -4

5. La función collision_detection

Si algo puede golpear a los alienígenas, entonces estos tienen que ser capaces de detectar cuándo podría producirse esa colisión. Ellen necesita saber si dos alienígenas ocupan las mismas coordenadas. La función collision_detection() recibe otro objeto alienígena como argumento y devuelve un bool.

Alien lrrr {3, 6};
Alien ndnd {-2, 12};
lrrr.collision_detection(ndnd);
// => false
ndnd.teleport(3, 6);
ndnd.collision_detection(lrrr);
// => true
Editar en GitHub El enlace se abre en una ventana o pestaña nueva
C++ Exercism

¿Listo para empezar El juego de alienígenas de Ellen?

Regístrate en Exercism para aprender y dominar C++ con 19 conceptos100 ejercicios y mentoría humana real, todo gratis.