Kurzusok
/
C++
C++
/
Feladatok
/
Ellen űrlényjátéka
Ellen űrlényjátéka

Ellen űrlényjátéka

Tanulófeladat

Bevezetés

Osztályok

Eljött az idő, hogy megismerkedjünk a C++ egyik alappillérével: az objektumorientált programozással (OOP). Az OOP középpontjában a classes állnak: ezek felhasználó által definiált adattípusok, amelyeknek saját, összetartozó függvényeik vannak. Az alapokkal kezdjük, a haladóbb témákra pedig a tanterv további szintjein térünk majd rá.

Tagok

Az osztályoknak lehetnek tagváltozóik és tagfüggvényeik. Ezeket a . tagkiválasztó operátorral éred el. Ahogy az classes-en kívüli változóknál is szokás, érdemes a tagváltozókat már a deklarációkor értékkel inicializálni. Ez az érték lesz aztán az adott osztály újonnan létrehozott objektumainak az alapértelmezett értéke.

Egységbezárás és információelrejtés

Az osztályok lehetővé teszik, hogy korlátozd a tagjaik elérését. A két alapvető access specifiers a private és a public. A private tagok az osztályon kívülről nem érhetők el. A public tagok szabadon elérhetők. Egy class minden tagja alapértelmezés szerint private. Csak azok a tagok használhatók szabadon az osztályon kívül, amelyeket kifejezetten public-ként jelöltél meg.

Alapvető példa

Az alábbi példában egy class definícióját láthatod. Figyeld meg a definíció után álló ;-t:

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

Az osztályon belülről minden tagváltozóhoz hozzáférsz. Nézd meg a damage-t a cast_spell függvényen belül! Az osztályon kívülről viszont a private tagokat sem olvasni, sem módosítani nem tudod:

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

Konstruktorok

A konstruktorok lehetővé teszik, hogy már az objektum létrehozásakor értéket adj a tagváltozóknak. Nevük megegyezik a class nevével, és nincs visszatérési típusuk. Egy osztálynak több konstruktora is lehet. Ez akkor hasznos, ha nem mindig kell az összes változót beállítanod. Néha lehet, hogy mindent az alapértelmezett értéken szeretnél hagyni, és csak a name változót módosítanád. Egy jelentős varázsló esetében viszont a sebzést is módosítanád, ezért két constructors-ra lesz szükséged.

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

A konstruktorok nagy téma, sok apró részlettel. Ha nem definiálsz kifejezetten constructor-t a class-hez, akkor (és csakis akkor) a fordító elvégzi helyetted a munkát. Ez történt a fenti első példában is. A silverhand objektum az alapértelmezett konstruktor meghívásával jön létre, argumentumok átadása nélkül. Minden változó azt az értéket kapja, amelyet az osztály definíciójában megadtál. Ha a definícióban nem adtál volna meg értékeket, előfordulhat, hogy a változók inicializálatlanok maradnak, aminek nem várt következményei lehetnek.

Note

Struktúrák

A struktúrák a nyelv eredeti, C-ből származó gyökereiből erednek, és ugyanolyan régi, mint maga a C++. Lényegében ugyanazok, mint a classes, egy fontos kivétellel. Egy class-ben alapértelmezés szerint minden private. A struktúrák viszont mindaddig public-ok, amíg másként nem rendelkezel. A megszokás szerint a struct kulcsszót gyakran csak adatot tároló struktúrákra használjuk. A class kulcsszót viszont olyan objektumoknál részesítjük előnyben, amelyeknek bizonyos tulajdonságokat garantálniuk kell. Ilyen invariáns lehet például az, hogy a Wizard class damage értéke nem válhat negatívvá. A damage változó privát, és minden függvény, amely a sebzést módosítja, gondoskodna arról, hogy az invariáns megmaradjon.

Utasítások

Ellen egy játékot készít, amelyben a játékosnak űrlényekkel kell harcolnia. Épp most tanult az objektumorientált programozásról (OOP), és alig várja, hogy kihasználja, mit nyújthat a programjának az classes használata.

Ellen örömére felajánlottad a segítségedet, és ő rád bízta, hogy megprogramozd azokat az űrlényeket, amelyekkel a játékosnak meg kell küzdenie.

1. Az Alien osztály létrehozása

Definiáld az Alien osztályt egy konstruktorral, amely két int paramétert fogad, x-et és y-t, és ezeket az x_coordinate, illetve y_coordinate tagváltozókba teszi. Minden űrlény 3 egészségszinttel is indul, ezért a health tagváltozót is inicializálni kell.

A health legyen privát tagváltozó. Hogy a program más részei is olvashassák az egészségre vonatkozó információt, Ellen szeretne egy public get_health() metódust, amely egy int-et ad vissza.

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

Mostantól minden űrlénynek képesnek kell lennie arra, hogy belsőleg nyomon kövesse a saját pozícióját és egészségét.

2. A hit függvény

Ellen szeretné, hogy az Alien class rendelkezzen egy hit metódussal, amely meghívásakor 1-gyel csökkenti egy űrlény objektum egészségét. Így egyszerűen meghívhatja a some_alien_instance.hit() metódust ahelyett, hogy kézzel kellene módosítania egy űrlény egészségét. Ügyelj arra, hogy az egészségpontok ne csökkenjenek nulla alá. A függvény true értékkel térjen vissza. Ellen később pajzsokat szeretne bevezetni, amelyek akkor false értéket jelentenének, ha a pajzs fel van kapcsolva.

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

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

3. Az is_alive függvény

Rájössz, hogy ha az egészség folyamatosan csökken, az valamikor valószínűleg eléri a 0-t. Jó ötlet lenne hozzáadni egy is_alive metódust, amelyet Ellen gyorsan meghívhat, hogy ellenőrizze, vajon az űrlény... nos... életben van-e. 😉 A some_alien_instance.is_alive() egy Boolean értéket adjon vissza.

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

4. A teleport függvény

Ellen játékában az űrlények teleportálni tudnak! Írnod kell egy teleport metódust, amely x_new és y_new értékeket vesz át, és ennek megfelelően módosítja az űrlény koordinátáit. Egyelőre a függvény true értékkel térjen vissza. Ellen későbbi szinteken teleportálást blokkoló bombákat szeretne hozzáadni, amelyek sikertelen teleportálási kísérletek esetén false értéket jelentenének.

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

5. A collision_detection függvény

Ha az űrlényeket érheti valami találat, akkor képesnek kell lenniük érzékelni, mikor következhet be ilyen ütközés. Ellennek tudnia kell, hogy két űrlény ugyanazokat a koordinátákat foglalja-e el. A collision_detection() függvény egy másik űrlény objektumot vesz át argumentumként, és egy bool értéket ad vissza.

Alien lrrr {3, 6};
Alien ndnd {-2, 12};
lrrr.collision_detection(ndnd);
// => false
ndnd.teleport(3, 6);
ndnd.collision_detection(lrrr);
// => true
Szerkesztés GitHubon A hivatkozás új ablakban vagy lapon nyílik meg
C++ Exercism

Készen állsz elkezdeni a(z) Ellen űrlényjátéka feladatot?

Iratkozz fel az Exercism-re, hogy megtanuld és elsajátítsd a(z) C++ nyelvet 19 fogalom100 feladat segítségével, valódi emberi mentorálással, mindez ingyen.