Mission Impossible

Krok 1: Welcome to the Real World!

Primárnym cieľom tejto misie je naučiť Ripleyovú pohybovať sa v novom prostredí. Na dosiahnutie tohto cieľa potrebujete pri vytváraní hernej scény načítať mapu reprezentujúcu prostredie Ripleyovej, spolu s okolitými, viac či menej živými, aktérmi.

Aby to bolo možné, potrebujete najskôr vytvoriť factory triedu, pomocou ktorej bude vedieť vaša simulácia nakonfigurovať patričnú situáciu a rozmiestniť aktérov do ich počiatočných pozícií podľa údajov zaznačených v mape. A keďže mapa môže obsahovať aj steny, bude potrebné naučiť Ripleyovú ich rozoznávať a neprechádzať skrze ne.

Výsledná štruktúra súborov v adresári src/main/resources/maps by mala byť nasledovná:

src/main/resources/maps/
├── tilesets/
│  └── tileset01.png
└── mission-impossible.tmx

Cestu k mape zapíšete ako maps/mission-impossible.tmx.

Trieda musí, samozrejme, implementovať rozhranie SceneListener a scenár budete neskôr písať do metódy sceneInitialized().

Táto trieda bude reprezentovať návrhový vzor továrenská metóda (Factory Method) a trieda samotná bude obsahovať len jednu metódu create(String type, String name).

Herná mapa dnešnej misie obsahuje objekty s menami access card, door, ellen, energy, locker, ventilator. Zatiaľ viete poskytnúť inštancie pre Ripleyovú (ellen) a lekárničku (energy). Pre iné mená z metódy create() vráťte zatiaľ hodnotu null.

Vytvorenú inštanciu triedy MissionImpossible.Factory prepojte s inštanciou scény tak, že ju v metóde main() odovzdajte ako tretí argument konštruktora triedy World:

Scene missionImpossible = new World("mission-impossible", "maps/mission-impossible.tmx", new MissionImpossible.Factory());

Keďže je teraz Ripleyová vytváraná cez továreň na základe jej umiestnenia v mape scény, inštanciu Ripleyovej už v scenári nevytvárajte, ale získajte už existujúcu inštanciu zo scény.

Ak ste postupovali správne, po spustení uvidíte scénu s mapou, na ktorej sa už bude nachádzať lekárnička a Ripleyová. Ripleyovú by ste mali vedieť ovládať pomocou klávesnice, a zatiaľ by mala zvládnuť prechádzať aj cez steny.

Nášmu taktickému tímu sa ako najvhodnejšie javí implementovať túto funkcionalitu do triedy akcie, ktorá sa stará o pohyb aktérov.

Gamelib

Zistiť, či je objekt typu Actor v kolízii so stenou, môžete pomocou volania metódy intersectsWithWall(Actor actor) nad objektom mapy. Objekt mapy získate zo scény pomocou metódy getMap().

V mape sú steny definované v rámci vrstvy s názvom walls. Táto vrstva nie je v rámci scény graficky vykreslená, avšak informácie z tejto vrstvy (vyplnené, respektíve prázdne dlaždice) sú použité na vytvorenie stien v miestach vyplnených dlaždíc.

Krok 2: Alohomora!

Pri implementácii triedy MissionImpossible.Factory ste si určite všimli, že ste nemali k dispozícii všetkých potrebných aktérov definovaných v mape. V rámci plnenia tohto kroku misie niekoľko chýbajúcich predmetov vytvoríte. Konkrétne budete vytvárať dvere a prístupovú kartu, pomocou ktorej bude možné zamknuté dvere odomknúť.

Pri plnení tohto kroku misie bude potrebné aj rozšíriť možnosti použiteľných predmetov, aby ste ich mohli používať interaktívne - pomocou klávesnice.

Rozhranie bude rozširovať rozhranie Actor a bude mať nasledovné metódy:

• void open() - otvorenie predmetu (aktéra)
• void close() - zatvorenie predmetu (aktéra)
• boolean isOpen() - vráti true, ak je predmet (aktér) otvorený, v opačnom prípade vráti false

Dvere budú použiteľné s akýmkoľvek aktérom, preto ako typový argument typu Usable použite typ Actor. Pre aktuálnu misiu budeme potrebovať vertikálne otočené dvere, preto ako animáciu použite obrázok vdoor.

Vo východzom stave budú dvere zavreté. Pri použití dverí niektorým z aktérov dvere otvorte, ak sú zavreté, a zatvorte ich, ak už sú otvorené.

Nášmu taktickému a strategickému tímu sa ako najlepší spôsob znepriechodnenia zatvorených dverí javí vytvoriť na ich mieste v mape stenu. Pri ich otvorení je zase potrebné stenu zrušiť.

Gamelib

Všetky steny sú v rámci hernej mapy definované vo vrstve walls, ktorú ste videli už na obrázku vyššie. Pri práci s editorom Tiled sú mapy vytvárané pomocou dlaždíc, ktoré sú v našom prípade veľké 16x16 pixelov. Každá vyplnená dlaždica vo vrstve walls reprezentuje stenu.

Aj v rámci objektovej reprezentácie mapy máme k dispozícii dlaždice. Každá dlaždica pokrývajúca mapu má svoju x-ovú a y-ovú súradnicu, ktorá reprezentuje poradie dlaždice v smere osi x a y, pričom počiatok súradnicového systému je v ľavom dolnom rohu mapy. Dlaždica na tomto umiestnení má súradnice [0, 0].

Konkrétnu dlaždicu viete získať pomocou metódy getTile(int tileX, int tileY) nad objektom mapy. Táto dlaždica je typu MapTile a okrem jej pozície a rozmerov z nej viete metódou isWall() zistiť, či daná pozícia v mape je považovaná za stenu. Konečne, metódou setType() viete typ dlaždice zmeniť na jednu z dvoch hodnôt enumerácie MapTile.Type:

• CLEAR - miesto, kde sa dlaždica tohto typu nachádza, je priechodzie,
• WALL - miesto, kde sa dlaždica tohto typu nachádza, je považované za stenu.

V scéne by mali pribudnúť dvere a Ripleyová by sa nemala cez ne vedieť dostať do menšej miestnosti.

V nasledujúcej úlohe budete pridávať podporu pre plánovanie akcie Use pomocou klávesnice. Scenár použitia je napríklad takýto:

1. Ripleyová príde k dverám, ktoré implementujú rozhranie Usable.
2. Stlačením priradenej klávesy hráč signalizuje zámer otvoriť dvere.
3. Akcia Use je naplánovaná tak, aby sa dvere použili s Ripleyovou.

Iný scenár použitia, ktorý budete implementovať neskôr, bude nasledovný:

1. Ripleyová s prístupovou kartou v batohu príde k uzamknutým dverám.
2. Stlačením priradenej klávesy hráč signalizuje zámer použiť predmet na vrchu batoha.
3. Akcia Use je naplánovaná tak, aby sa prístupová karta (predmet z batoha) použila so zamknutými dverami (predmet v scéne v kolízii s Ripleyovou).

Vzhľadom na obmedzenie JVM platformy nie je možné počas behu programu pracovať priamo s typmi reprezentovanými typovými parametrami (tie existujú len počas kompilácie). Preto pridávanou metódou getUsingActorClass() budeme pre každý použiteľný predmet explicitne vracať runtime reprezentáciu triedy aktéra, s ktorým daný použiteľný predmet dokáže pracovať. Táto reprezentácia triedy sa využije v ďalšej úlohe pri hľadaní kompatibilného aktéra (aktéra, ktorý je inštanciou danej triedy), s ktorým môže byť akcia Use naplánovaná.

Nová metóda v rozhraní Usable nech má nasledujúcu signatúru:

Class<T> getUsingActorClass();  // T reprezentuje typovy parameter v triede Usable

V každom použiteľnom aktérovi, ktorý dosadzuje konkrétny typ kompatibilného aktéra do typového argumentu pre Usable, vráťte z tejto metódy referenciu na runtime reprezentáciu triedy kompatibilného aktéra. V prípade kladiva (triedy Hammer), ktoré je použiteľné s reaktorom, bude implementácia tejto metódy teda vyzerať nasledovne:

public Class<Reactor> getUsingActorClass() {
    return Reactor.class;
}

Táto metóda je potrebná v triede akcie Use kvôli tomu, lebo potrebujeme v kontexte, v ktorom typový systém jazyka má k dispozícii typový argument Usable predmetu, nájsť prvého kompatibilného aktéra na scéne v kolízií so sprostredkujúcim aktérom (predovšetkým Ripleyovou). To nám v ďalšej úlohe umožní interaktívne plánovať akciu Use ako reakciu na stlačenie klávesy.

Za predpokladu, že máte funkčnú implementáciu akcie Use, kde členská premenná usable reprezentuje použiteľného aktéra odovzdaného konštruktoru akcie a T reprezentuje typový parameter akcie, je možné túto metódu implementovať nasledovne:

public Disposable scheduleForIntersectingWith(Actor mediatingActor) {
    Scene scene = mediatingActor.getScene();
    if (scene == null) return null;
    Class<T> usingActorClass = usable.getUsingActorClass();  // `usable` je spominana clenska premenna

    for (Actor actor : scene) {
        if (mediatingActor.intersects(actor) && usingActorClass.isInstance(actor)) {
            return this.scheduleFor(usingActorClass.cast(actor));  // naplanovanie akcie v pripade, ze sa nasiel vhodny akter
        }
    }
    return null;
}

public Disposable scheduleForIntersectingWith(Actor mediatingActor) {
    Scene scene = mediatingActor.getScene();
    if (scene == null) return null;
    Class<T> usingActorClass = usable.getUsingActorClass();  // `usable` je spominana clenska premenna
    return scene.getActors().stream()  // ziskame stream aktérov na scene
        .filter(mediatingActor::intersects)  // vyfiltrujeme akterov, ktori su v kolizii so sprostredkovatelom
        .filter(usingActorClass::isInstance) // vyfiltrujeme akterov kompatibilneho typu
        .map(usingActorClass::cast)  // vykoname pretypovanie streamu akterov
        .findFirst()  // vyberieme prveho (ak taky existuje) aktera zo streamu
        .map(this::scheduleFor)  // zavolame metodu `scheduleFor` s najdenym akterom a vratime `Disposable` objekt
        .orElse(null);  // v pripade, ze ziaden vyhovujuci akter nebol najdeny, vratime `null`
}

Pri stlačení klávesy U naplánujte použitie prvého nájdeného použiteľného predmetu v kolízii s ovládaným aktérom. Ovládaný aktér bude následne vystupovať v úlohe sprostredkovateľa pre nájdenie kompatibilného predmetu pomocou pridanej metódy scheduleForIntersectingWith().

(Usable<?>) actor

Ak postupujete správne, Ripleyová by mala vedieť otvoriť dvere, ku ktorým sa priblíži, stlačením klávesy U.

Odstrániť bezpečnostný zámok však bude možné len použitím správnej prístupovej karty, čo budete implementovať v ďalšej úlohe. Po odomknutí dverí ich už bude možné kedykoľvek otvoriť a zatvoriť, tak ako bežné dvere.

V triede implementujte metódy:

• void lock() - zamknutie (a zároveň zatvorenie) dverí,
• void unlock() - odomknutie (a zároveň otvorenie) dverí,
• boolean isLocked() - vráti aktuálny stav dverí - či sú zamknuté alebo nie.

Táto karta bude implementovať rozhrania Collectible a Usable a bude použiteľná práve s uzamknutými dverami LockedDoor. Použitím karty sa uzamknuté dvere odomknú.

Animácia reprezentujúca prístupovú kartu je uložená v súbore key.

Pri stlačení klávesy B naplánujte akciu Use na predmete na vrchu batoha v prípade, že je tento predmet použiteľný. Opäť využite ovládaného aktéra ako sprostredkovateľa na nájdenie kompatibilného aktéra v jeho blízkosti na scéne.

Overte, že použitím klávesy U už nie je možné otvoriť zamknuté dvere a že tieto sa otvoria, ak si Ripleyová vezme do batohu prístupovú kartu a použijete klávesu B po priblížení sa k dverám.

Krok 3: Missing Items

Pre úplnosť aktérov definovaných v mape ešte chýba skrinka a ventilátor. Tie vytvoríte v tomto kroku. Takisto budeme potrebovať rozšíriť opravovacie schopnosti kladiva (schovávajúceho sa v skrinke) na akékoľvek opraviteľné predmety.

Nezabudnite zmeniť aj triedu získavanú metódou getUsingActorClass(). Rovnako ako triedu Reactor.class môžete vrátiť aj runtime reprezentáciou rozhrania Repairable ako Repairable.class.

Nájdenie kladiva realizujte tým, že kladivo zo skrinky vypadne, akonáhle Ripleyová skrinku preskúma. Skrinka nech je použiteľná len raz, takže Ripleyová preskúmaním jednej skrinky získa len jedno kladivo.

Animácia reprezentujúca skrinku je uložená v súbore locker.

Animácia reprezentujúca ventilátor je uložená v súbore ventilator. Keďže ventilátor začne v scéne vystupovať ako pokazený, zastavte spočiatku prehrávanie jeho animácie. V metóde repair() zas reprezentujte opravenie ventilátora spustením prehrávania animácie.

Krok 4: Entering Contaminated Zone

Vstupujeme do poslednej fázy dnešnej misie. Cieľom je opraviť pokazený vetrák v zamorenej oblasti, čím nebezpečenstvo zamorenia pominie. Pri plnení tohto kroku si ukážeme ako pomocou správ vieme reagovať na vzniknuté udalosti, pričom využijeme návrhový vzor Observer.

Rôzne časti hry (iní aktéri, váš kód v rámci scenára, ...) môžu chcieť reagovať na to, ak sa nejaké dvere otvoria alebo zatvoria. To umožníme vytvorením témy správ s definovaným typom obsahu (typom objektu, ktorý sa bude v danej téme posielať) a publikovaním správy (konkrétneho objektu daného typu) do zbernice správ na scéne. V prípade dverí bude typom správy samozrejme typ Door.

Témy správ vytvoríte pomocou factory metódy Topic.create(), ktorej prvý argument je názov témy a druhý typ objektu posielaný v správach.

Keďže k témam budeme chcieť pristupovať bez potreby mať referenciu na konkrétne dvere, implementujte ich ako statické členské premenné triedy Door. Téma pre otvorenie dverí môže vyzerať takto:

public static final Topic<Door> DOOR_OPENED = Topic.create("door opened", Door.class);

Analogicky vytvoríte aj tému pre zatvorenie dverí.

V metódach open() a close() dverí publikujte správu o tom, ktoré dvere boli práve otvorené, respektíve zatvorené. Využite metódu publish() na objekte zbernice správ scény MessageBus, ktorý zo scény získate metódou getMessageBus().

Zbernica správ MessageBus má metódu subscribe(Topic<M> topic, Consumer<M> listener), ktorou sa vieme prihlásiť k "odberu" správ publikovaných v rámci určitej témy. Prvým argumentom je objekt témy správ a druhým je lambda výraz (resp. objekt typu funkcionálneho rozhrania Consumer) s jedným parametrom - objektom odoslaným v rámci konkrétnej správy.

Prihláste sa k téme správ Door.DOOR_OPENED a zareagujte na otvorenie dverí naplánovaním patričnej akcie na znižovanie energie Ripleyovej.

Po otvorení dverí by mala začať Ripleyovej klesať energia.

Pre animáciu použite režim prehrávania Animation.PlayMode.ONCE. Vytváranú tému správ pomenujte RIPLEY_DIED.

Upravte implementáciu scenára tak, aby ste po prijatí správy o smrti Ripleyovej zrušili listenery pre spomínané ovládače a znemožnili tak ďalšie ovládanie Ripleyovej.

Túto úlohu tiež riešte vytvorením témy správ pre opravenie ventilátora (pomenovanej VENTILATOR_REPAIRED). V reakcii na túto správu v scenári zastavte naplánované znižovanie energie Ripleyovej.

Po oprave ventilátora kladivom by Ripleyovej mala prestať klesať energia. Ak opravu nestihne do času, keď jej energia klesne na 0, nemali by ste vedieť Ripleyovú už ovládať.