Percursos
/
C++
C++
/
Exercícios
/
O jogo alienígena da Ellen
O jogo alienígena da Ellen

O jogo alienígena da Ellen

Exercício de aprendizagem

Introdução

Classes

Está na altura de abordar um dos paradigmas centrais do C++: a programação orientada a objetos (POO). A POO gira em torno das classes: tipos de dados definidos pelo utilizador, com o seu próprio conjunto de funções relacionadas. Vamos começar pelo básico e abordar tópicos mais avançados mais adiante na árvore do currículo.

Membros

As classes podem ter variáveis membro e funções membro. O acesso faz-se com o operador de seleção de membro .. Tal como acontece com as variáveis fora das classes, é aconselhável inicializar as variáveis membro com um valor na sua declaração. Esse valor passa então a ser o predefinido para os objetos recém-criados desta classe.

Encapsulamento e ocultação de informação

As classes permitem restringir o acesso aos seus membros. Os dois access specifiers básicos são private e public. Os membros private não são acessíveis a partir do exterior da classe. Acede-se livremente aos membros public. Por predefinição, todos os membros de uma class são private. Só os membros marcados explicitamente como public podem ser usados livremente fora da classe.

Exemplo básico

A definição de uma class pode ver-se no exemplo seguinte. Repara no ; depois da definição:

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`
};

Podes aceder a todas as variáveis membro a partir de dentro da classe. Repara em damage dentro da função cast_spell. Não podes ler nem alterar membros private fora da classe:

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

Construtores

Os construtores permitem atribuir valores às variáveis membro no momento da criação do objeto. Têm o mesmo nome que a class e não têm tipo de retorno. Uma classe pode ter vários construtores. Isto é útil quando nem sempre precisas de definir todas as variáveis. Às vezes podes querer manter tudo nos valores predefinidos e mudar apenas a variável name. No caso de um Wizard poderoso, podes querer alterar também o dano, por isso precisas de dois 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

Os construtores são um tema vasto e têm muitas nuances. Se não definires explicitamente um constructor para a tua class, então (e só então) o compilador faz esse trabalho por ti. Foi o que aconteceu no primeiro exemplo acima. O objeto silverhand é criado através da chamada ao construtor predefinido, sem passar argumentos. Todas as variáveis ficam com o valor indicado na definição da classe. Se não tiveres indicado nenhum valor nessa definição, as variáveis podem ficar não inicializadas, o que pode ter consequências indesejadas.

Note

Estruturas

As estruturas vêm das raízes originais da linguagem em C e são tão antigas como o próprio C++. Na prática, são a mesma coisa que as classes, com uma exceção importante. Por predefinição, tudo numa class é private. As estruturas, por outro lado, são public até serem definidas de outra forma. Por convenção, a palavra-chave struct é frequentemente usada para estruturas apenas com dados. A palavra-chave class é preferida para objetos que precisam de garantir certas propriedades. Um desses invariantes pode ser que o valor de damage na tua class Wizard não possa ficar negativo. A variável damage é private e qualquer função que altere o dano garantiria que o invariante se mantém.

Instruções

A Ellen está a fazer um jogo em que o jogador tem de combater aliens. Acabou de aprender Programação Orientada a Objetos (POO) e está ansiosa por tirar partido daquilo que a utilização de classes pode oferecer ao seu programa.

Para alegria da Ellen, ofereceste-te para ajudar e ela deu-te a tarefa de programar os aliens que o jogador tem de combater.

1. Cria a classe Alien

Define a classe Alien com um construtor que aceita dois parâmetros int, x e y, colocando-os nas variáveis membro x_coordinate e y_coordinate. Todos os aliens começam também com um nível de saúde de 3, por isso a variável membro health também deve ser inicializada.

health deve ser uma variável membro privada. Para deixar que outras partes do programa leiam a informação relativa à saúde, a Ellen quer ter um método public get_health() que devolve um int.

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

Agora, cada alien deve conseguir acompanhar internamente a sua própria posição e a sua saúde.

2. A função hit

A Ellen gostaria que a class Alien tivesse um método hit que diminui em 1 a saúde de um objeto alien quando é chamado. Assim, pode simplesmente chamar some_alien_instance.hit() em vez de ter de alterar manualmente a saúde de um alien. Certifica-te de que os pontos de saúde não descem abaixo de zero. A função deve devolver true. A Ellen quer introduzir escudos mais tarde, que então reportariam false se o escudo estiver ativo.

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

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

3. A função is_alive

Percebes que, se a saúde continuar a diminuir, a certo ponto provavelmente chegará a 0. Seria boa ideia acrescentar um método is_alive que a Ellen possa chamar rapidamente para verificar se o alien está... bem... vivo. 😉 some_alien_instance.is_alive() deve devolver um Boolean.

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

4. A função teleport

No jogo da Ellen, os aliens podem teletransportar-se! Vais precisar de escrever um método teleport que recebe os valores x_new e y_new e altera as coordenadas do alien em conformidade. Por agora, a função deve devolver true. A Ellen quer acrescentar bombas que bloqueiam o teletransporte em níveis posteriores, que então reportariam false para tentativas de teletransporte falhadas.

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

5. A função collision_detection

Se os aliens podem ser atingidos por algo, então precisam de conseguir detetar quando tal colisão pode ocorrer. A Ellen precisa de saber se dois aliens ocupam as mesmas coordenadas. A função collision_detection() recebe outro objeto alien como argumento e devolve um bool.

Alien lrrr {3, 6};
Alien ndnd {-2, 12};
lrrr.collision_detection(ndnd);
// => false
ndnd.teleport(3, 6);
ndnd.collision_detection(lrrr);
// => true
Editar via GitHub A ligação abre numa nova janela ou separador
C++ Exercism

Estás pronto para começar O jogo alienígena da Ellen?

Inscreve-te no Exercism para aprenderes e dominares C++ com 19 conceitos100 exercícios, e mentoria humana real, tudo grátis.