Trilhas
/
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

Chegou a hora de conhecer um dos paradigmas centrais do C++: a programação orientada a objetos (POO). A POO gira em torno de classes, tipos de dados definidos pelo usuário com seu próprio conjunto de funções relacionadas. Vamos começar pelo básico e, mais adiante na árvore do programa de estudos, vamos cobrir tópicos mais avançados.

Membros

As classes podem ter variáveis membro e funções membro. Elas são acessadas pelo operador de seleção de membro .. Assim como as variáveis fora das classes, é recomendável inicializar as variáveis membro com um valor no momento da declaração. Esse valor passa a ser o padrão para os objetos recém-criados dessa classe.

Encapsulamento e ocultação de informação

As classes oferecem a opção de restringir o acesso aos seus membros. Os dois access specifiers básicos são private e public. Membros private não são acessíveis de fora da classe. Membros public podem ser acessados livremente. Todos os membros de uma class são private por padrão. Só os membros marcados explicitamente com public são livremente utilizáveis fora da classe.

Exemplo básico

A definição de uma class pode ser vista no exemplo a seguir. Repare 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`
};

Você pode acessar todas as variáveis membro de dentro da classe. Dê uma olhada em damage dentro da função cast_spell. Você não pode 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 oferecem a possibilidade de atribuir valores às variáveis membro no momento da criação do objeto. Eles têm o mesmo nome da class e não têm tipo de retorno. Uma classe pode ter vários construtores. Isso é útil quando você nem sempre precisa definir todas as variáveis. Às vezes você pode querer manter tudo no padrão, mas mudar a variável name. No caso de um Wizard importante, talvez você queira mudar o dano também, então precisa 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

Construtores são um assunto extenso e cheio de nuances. Se você não definir explicitamente um constructor para a sua class, aí sim o compilador faz o trabalho por você. Foi o que aconteceu no primeiro exemplo acima. O objeto silverhand é criado chamando o construtor padrão, sem passar argumentos. Todas as variáveis recebem o valor declarado na definição da classe. Se você não tivesse dado nenhum valor nessa definição, as variáveis poderiam ficar sem inicialização, o que pode ter consequências indesejadas.

Note

Structs

Os structs vêm das raízes originais da linguagem no C e são tão antigos quanto o próprio C++. Eles são, na prática, a mesma coisa que classes, com uma exceção importante. Por padrão, tudo em uma class é private. Já os structs são public até que se defina o contrário. Por convenção, a palavra-chave struct costuma ser usada para estruturas que só carregam dados. A palavra-chave class é preferida para objetos que precisam garantir certas propriedades. Um desses invariantes poderia ser que o damage da sua class Wizard não possa ficar negativo. A variável damage é privada, e qualquer função que altere o dano garantiria que o invariante fosse preservado.

Instruções

Ellen está fazendo um jogo em que o jogador precisa enfrentar aliens. Ela acabou de aprender sobre Programação Orientada a Objetos (POO) e está ansiosa para aproveitar o que o uso de classes pode oferecer ao seu programa.

Para a alegria de Ellen, você se ofereceu para ajudar, e ela te deu a tarefa de programar os aliens que o jogador precisa enfrentar.

1. Crie a classe Alien

Defina 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. Todo alien também começa com um nível de saúde de 3, então a variável membro health também precisa ser inicializada.

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

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

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

2. A função hit

Ellen gostaria que a class Alien tivesse um método hit que decrementa a saúde de um objeto alien em 1 quando chamado. Assim, ela pode simplesmente chamar some_alien_instance.hit() em vez de ter que alterar manualmente a saúde de um alien. Certifique-se de que os pontos de saúde não caiam abaixo de zero. A função deve retornar true. Ellen quer introduzir escudos mais para frente, que então retornariam 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

Você percebe que, se a saúde continuar diminuindo, em algum momento ela provavelmente vai chegar a 0. Seria uma boa ideia adicionar um método is_alive que Ellen possa chamar rapidamente para verificar se o alien está... bem... vivo. 😉 some_alien_instance.is_alive() deve retornar 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 de Ellen, os aliens podem se teletransportar! Você vai precisar escrever um método teleport que recebe os valores x_new e y_new e muda as coordenadas do alien de acordo. Por enquanto, a função deve retornar true. Ellen quer adicionar bombas que bloqueiam o teletransporte em fases posteriores, que então retornariam false para tentativas de teletransporte malsucedidas.

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 eles precisam ser capazes de detectar quando uma colisão dessas pode acontecer. Ellen precisa saber se dois aliens ocupam as mesmas coordenadas. A função collision_detection() recebe outro objeto alien como argumento e retorna 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 O link abre em uma nova janela ou aba
C++ Exercism

Tudo pronto para começar O jogo alienígena da Ellen?

Crie sua conta no Exercism para aprender e dominar C++ com 19 conceitos100 exercícios e mentoria humana de verdade, tudo de graça.