Dezvoltarea unei aplicații de tip game 2D folosind motorul GameMaker Studio Coordonator științific Lect.univ.dr.Runceanu Adrian Absolvent Cătălin… [304930]

UNIVERSITATEA „CONSTANTIN BRÂNCUȘI”

FACULTATEA DE INGINERIE

LUCRARE DE LICENȚĂ

Dezvoltarea unei aplicații de tip game 2D folosind motorul GameMaker Studio

Coordonator științific

Lect.univ.dr.Runceanu Adrian

Absolvent: [anonimizat]

2017

UNIVERSITATEA „CONSTANTIN BRÂNCUȘI”

FACULTATEA DE INGINERIE

ENIGMA’S MONSTERS

Coordonator științific

Lect.univ.dr.Runceanu Adrian

Absolvent: [anonimizat]

2017

Îmi propun prin intermediul acestei lucrări implementarea unui joc pentru platforma Windows cu ajutorul motorului grafic GameMaker:Studio. Jocul este de tip RPG ( Role Playing Game) și oferă posibilitatea jucatorului de a-și testa iscusința împotriva varietății de inamici care vor să-l reducă la tacere. Principala atracție este oferirea unei experiențe de joc plăcută și intuitivă.

În Capitolul 1 este prezentată introducerea. Aici vorbim despre ce sunt jocurile video și tipurile acestora.

În Capitolul 2 avem o prezentare a mediului de dezvoltare folosit (GameMaker:Studio).

În Capitolul 3 vorbim despre jocul Enigma’s Monsters și despre funcționalitatea acestuia.

Cuprins

Capitolul 1………………………………………………………………………5

1.1 Introducere…………………………………………………………..5

1.2 Clasificare……………………………………………………………5

Capitolul 2……………………………………………………………………..17

2.1 Prezentarea motorului grafic………………………………………17

2.2 Prezentarea interfeței motorului grafic……………………………22

2.3 Acțiuni existente în programul GameMaker: Studio…………………33

2.4 Evenimente existente în programul GameMaker: Studio…………..34

Capitolul 3…………………………………………………………………………………………….36

3.1 Prezentarea aplicației Enigma’s Monsters……………………………….36

3.2 Codul de bază al jocului Enigma’s Monsters……………………………44

3.3 Concluzii de final…………………………………………………………………….55

Bibliografie…………………………………………………………………………………………..56

CAPITOLUL 1

1.1 Introducere

Jocurile video reprezinta o clasa de aplicații software destinată entertainmentului. [anonimizat], din anii ‘70 [anonimizat]. Primul joc video reprezentând o simulare de rachete1, a fost creat în 1947 de Thomas T. Goldsmith Jr. și de Estle Ray Mann.

[anonimizat]. Orice adult se poate bucura de frumusețea acestora care pe langă distracție ele pot oferii relaxare sau o ieșire din banal.

Acestea pot exista pe calculator (PC,Mac,Linux) , console (PlayStation,Xbox,Wii,Nintento etc.) dar și pe platformele mobile (Android,iOS,[anonimizat].).

1.2 Clasificare

Jocurile video se pot clasifica în mai multe tipuri2:

RTS ([anonimizat]). Într-[anonimizat] ,unitățile de mișcare și structurile aflate sub controlul lor pentru a captura zone din hartă și / sau pentru a distruge structurile adversarilor. [anonimizat], [anonimizat].

Exemple de jocuri RTS foarte cunoscute:

Starcraft 1,2 ;

Warcraft 1,2,3 ;

Age of Empires 1,2,3 ;

Company Of Heroes 1,2 ;

Rise of Nations ;

Command & Conquer 1,2,3 ;

Medieval 2 Total War ;

1. https://ro.wikipedia.org/wiki/Joc_video

2. https://ro.wikipedia.org/wiki/Joc_pentru_calculator

Fig.1 Structura unui joc de tip RTS3

RTT (Real Time Tactics – Tactici în timp real). Este o categorie a jocurilor care simulează războiul și ale tacticii militare. Este diferențiat de RTS prin lipsa unei gestionări clasice a resurselor, a unei baze sau a unei unități de construcție și se bazează pe concentrarea asupra tacticilor complexe ale câmpului de luptă.

Exemple de jocuri RTT foarte cunoscute:

Warhammer 40.000: Dawn of War 1,2 ;

Rome:Total War ;

Medival 2 Total War ;

Ashes of Singularity ;

Total War: Shogun 2 ;

Total War: Attila ;

Shadow Tactics: Blades of the Shogun

Wargame Series ;

Blitzkrieg Collection ;

3. http://pinchinene.blogspot.ro/

Fig.2 Reprezentarea unui joc de tip RTT4

RPG (Role Playing Game). Reprezintă o categorie de jocuri în care jucatorul impersoneaza rolul unui caracter într-o lume fictivă. Jucătorul își asumă responsabilitatea pentru a juca acest rol într-o narațiune, fie prin acționare directă, fie printr-un sistem de decizie structurată.

Exemple de jocuri RPG cunoscute:

The Elder Scrolls Series ;

Fallout Series ;

World Of Warcraft ;

The Witcher Series ;

Dark Souls Series ;

Dragon Age Series ;

Mass Effect Series ;

Diablo Series ;

Borderlands Series ;

4. http://torrentsgames.org/pc/rome-total-war-pc.html

Fig.3 Reprezentarea unui joc de tip RPG5

TBS (Turn Based Strategy). În această categorie jucătorul execută câte un pas în fiecare rundă.Diferența dintre această categorie si RTS o reprezintă faptul că toți jucătorii joacă simultan.

Exemple de jocuri TBS cunoscute :

Civilization Series ;

Heroes Series ;

Fig.4 Structura unui joc de tip TBS6

5. http://www.denofgeek.com/games/dragon-age-inquisition/32947/the-evolution-of-the-rpg

6. https://www.ubisoft.com/en-GB/game/might-and-magic-heroes-7/

FPS (First Person Shooter). Este un gen de jocuri în care acțiunea se petrece din perspectiva umana(ochii jucatorului). Aici jucătorul trebuie să elimine inamicii într-un mod controlat sau liber.

Exemple de jocuri FPS cunoscute:

Counter Strike Series ;

Half-Life 1,2 ;

Call of Duty Series ;

Battlefield Series ;

Team Fortress 1,2 ;

Fallout 3, 4 ;

Bioshock Series ;

Fig.5 Reprezentarea de baza a unui joc de tip FPS7

7. https://www.gamespot.com/articles/bethesda-built-really-good-fps-for-fallout-4/1100-6428329/

Action (Acțiune). Aici jucătorul este supus unor provocări fizice care pun la încercare coordonarea ochi-mână și timpul de reacție al acestuia.

Exemple de jocuri de acțiune cunoscute:

Grand Theft Auto Series ;

Shadow Warrior 2 ;

Tekken Series ;

Mortal Kombat Series;

Need for Speed Series ;

Fig.6 Reprezentare unui joc de tip Action8

TPS (Third Person Shooter). Similar cu genul FPS numai că în această categorie viziunea se petrece deasupra jucătorului.

Exemple de jocuri de tip TPS cunoscute :

Grand Theft Auto Series ;

Dead Space Series ;

Star Wars: Battlefront ;

Fallout 1,2,3,4 ;

Alan Wake ;

8. http://www.apklover.net/2015/01/road-warrior-crazy-armored-mod-apk.html

Fig.7 Diferenta dintre un joc de tip TPS si FPS9

Adventure (Aventură). În această categorie,jocul incearcă sa reproducă participarea jucătorului într-o aventură pe cât mai real posibilă.

Exemple de jocuri de tip Adventure cunoscute:

The Walking Dead Series ;

Life Is Strange ;

Minecraft;

Fig.8 Reprezentarea unui joc de tip Adventure10

9. http://www.oneangrygamer.net/2017/04/fallout-4-mods-add-mgs-third-person-ads-craftable-displays-and-more/29358/

10.https://www.keengamer.com/Game/minecraft/detail

Simulator (Simulare). Scopul acestei categorii de jocuri este să simuleze cât mai real lumea reală.

Exemple de jocuri de tip Simulator cunoscute:

Euro Truck Simulator 2 ;

The Sims 3 ;

Train Simulator ;

Fig.9 Prezentarea unui joc de tip Simulator11

11.http://blog.scssoft.com/2014/11/euro-truck-simulator-2-114-daf-update.html

MMO (Massively Multiplayer Online). Reprezintă o categorie de jocuri care pot fi jucate doar în domeniul online. De obicei acestea sunt RPG-uri, denumite MMORPG.

Exemple de jocuri de tip MMO cunoscute:

World of Warcraft ;

Guild Wars 2;

EVE Online ;

Tera ;

Aion ;

Fig.10 Reprezentarea unui joc de tip MMO12

12.https://mmogames2012.wordpress.com/

Arcade . Acestea sunt jocuri care sunt găsite de obicei la săli de jocuri speciale ,ele putând fi jucate doar după ce jucătorul a introdus o anumită suma de bani în aparat.

Exemple de jocuri de tip Arcade :

Pinball ;

Donkey Kong ;

Pac-Man ;

Galaga ;

Fig.11 Prezentarea unui joc de tip Arcade13

13.http://www.pacxongame.com/donkey-kong.php

Board/Card Games (Jocuri de tablă/cărți). Sunt acea categorie de jocuri care folosesc un anumit set de reguli care trebuiesc urmate pentru terminarea cât mai rapidă a jocului.

Exemple de jocuri de tip Board/Card Games :

Civilization Series ;

Monopoly ;

Risk ;

Hearthstone ;

Magic Duels ;

Gwent ;

Fig.12 Exemplu de joc tip Board/Card Game14

14.http://us.battle.net/hearthstone/en/

15.https://en.wikipedia.org/wiki/GameMaker:_Studio

16.GameMaker:Studio Manual

CAPITOLUL 2

2.1 Prezentarea motorului grafic

Știm cu toții că jocurile pe calculator sunt distractive. Dar aceea cei mai mulți oameni nu-și dau seama că este de fapt mult mai distractiv să-ți proiectezi propriile jocuri pe calculator și să lași alte persoane să le joace! Normal, realizarea de jocuri nu este în mod normal un lucru simplu și jocurile comerciale pe care le cumpărați în zilele noastre durează de obicei doi sau trei ani de dezvoltare cu echipe între 10 și 50 sau chiar mai mult de persoane și bugete care pot ajunge cu ușurință la milioane de dolari. Să nu mai vorbim de faptul că toți acești oameni sunt foarte experimentați: programatori, designeri, tehnicieni de sunet etc.16

GameMaker: Studio15 (denumit inițial Animo și mai târziu Game Maker) este un motor grafic de creare de jocuri făcut de Mark Overmars în limbajul de programare Delphi.

Cu ajutorul motorului grafic GameMaker se pot crea jocuri video pe mai multe platforme și genuri diferite, folosind opțiunea de "drag-and-drop" sau un limbaj de scripting de bază cunoscut sub numele de Game Maker Language, care poate fi folosit pentru a realiza jocuri mai avansate care nu pot fi create doar prin utilizarea opțiunii “drag-and-drop”. GameMaker a fost conceput pentru a permite programatorilor începători să poată crea jocuri pe calculator fără cunoștințe de programare prea complexe.

A fost creat în 1999 și a fost conceput pentru realizarea aplicațiilor 2D. Numele de Animo a fost schimbat în 1991 în GameMaker pentru a evita confuzia cu soft-ul Game-Maker bazat pe MS-DOS care era destinat design-ului de jocuri video.

GameMaker este special conceput pentru realizarea de jocuri 2D dar se pot crea și jocuri de baza 3D. Cu ajutorul acestuia putem realiza aplicații pentru foarte multe platforme cunoscute :

Windows , Mac OS X, Ubuntu, HTML5, Android, iOS, Windows Phone 8, Tizen, Xbox One, și Playstation.

16.GameMaker:Studio Manual

16Înainte de a începe să testăm posibilitățile motorului grafic GameMaker: Studio, este bine să știm ce vrem să realizăm. Jocurile create cu GameMaker: Studio sunt alcătuite din una sau mai multe camere. Aceste camere sunt spații plane bidimensionale, dar ele pot conține și grafică 3D, în funcție de cum doriți să fie jocul. În aceste camere puteți să plasați obiecte, pe care le puteți defini în cadrul programului. Obiectele de obicei pot fi pereți, mingi în mișcare, personajele controlate de jucător, inamici și orice altceva la ce vă puteți gândi din jocurile pe care le-ați m-ai jucat! Unele obiecte, cum ar fi pereții, sunt solide,imobile, în timp ce alte obiecte, precum personajul principal al jucătorului, se mișca și va reacționa la comanda primită de la jucător utilizând tastatura, mouse-ul sau joystick-ul. De exemplu, atunci când principalul personaj întâlnește un inamic, ar putea să moară sau ar putea lupta împotriva acestuia crescând astfel scorul. După cum puteți vedea, obiectele sunt cele mai importante componente ale jocurilor făcute cu GameMaker: Studio, așa că o să vorbim mai mult despre ele.

De obicei majoritatea obiectelor, când sunt puse într-o cameră, au nevoie de o imagine pentru ca să fie vizibile pe ecran. Aceste imagini sunt numite sprites. Un sprite nu este compus tot timpul doar dintr-o singură imagine, ci și dintr-un set de imagini care sunt afișate una după cealaltă pentru a crea o animație și astfel poate ilustra că un caracter se plimbă sau o minge se rotește sau un inamic explodează etc…. În timpul jocului, sprite-ul unei anumite instanțe a oricărui obiect poate fi schimbat, astfel încât un caracter poate să arate diferit atunci când merge spre stânga sau spre dreapta, de exemplu. Putem crea propriile sprite-uri în GameMaker: Studio sau le putem încărca din propiul desktop și le putem utiliza sau le putem edita singuri cu GameMaker: Studio sprite editor. Iată un exemplu despre cum arată un obiect tipic:

Fig.1 Reprezentarea editorului de obiecte al programului GameMaker: Studio

Pentru ca un obiect să facă efectiv ceva, trebuie să-i dăm acțiuni, dar trebuie să-i spunem și când să finalizeze aceste acțiuni. Pentru a face acest lucru vom folosi EVENIMENTELE. Un eveniment este un moment special în care putem să facem anumite acțiuni și să fim siguri că acele acțiuni vor avea loc numai atunci când evenimentul va fi declanșat. Există un număr mare de evenimente diferite care pot avea loc și un număr mare de acțiuni diferite pe care le putem atribui și obiectelor de asemenea. De exemplu, există un eveniment Create care are loc numai atunci când obiectul este creat. De fapt, asta nu e chiar tot timpul adevărat! Obiectele nu sunt create niciodată, ci sunt folosite pentru a crea instanțe … O instanță este o copie a obiectului de bază care are aceleași evenimente și acțiuni ca acesta, și de fapt aceaste instanțe sunt cele folosite în jocul nostru. Gândiți-vă la un obiect ca o schiță, iar instanța este ca o manifestare a acestei schițe. De exemplu, pentru a adăuga o mișcare unui obiect în formă de bilă când creăm o instanță a acestuia într-o cameră,noi îi atribuim o acțiune de mișcare evenimentului de Create al obiectului.

Un alt exemplu de eveniment este cel de Collision(coliziune). Acesta este declanșat când două instanțe de obiecte se ciocnesc în camera de joc. Într-un astfel de caz, putem face instanța să se oprească sau să-și inverseze direcția sau să execute numeroase acțiuni, cum ar fi redarea unui

sunet sau adăugarea punctelor la un scor. Următoarele evenimente includ evenimentul de tastatură (pentru cazul în care jucătorul apasă o cheie), evenimentul mouse-ului pentru a detecta butoanele mouse-ului și evenimentul Draw, unde putem spune fiecărei instanțe de obiect să deseneze orice vrem.

Odată ce am definit obiectele, este timpul să definim camera/camerele în care vor fi plasate. Camerele pot fi folosite pentru niveluri în joc sau pentru a afișa informații sau chiar pentru a ține un meniu de pornire. Există acțiuni pentru a trece de la o cameră la alta, astfel încât putem crea obiecte sub formă de butoane care, atunci când sunt apăsate, vor muta jucătorul dintr-o cameră a jocului în alta. Trebuie de asemenea remarcat faptul că, dacă nu avem nici o cameră în joc, atunci GameMaker: Studio nu va executa jocul. Dar cum creăm o cameră? GameMaker: Studio are un editor complet pentru crearea acestor zone și în editor putem adăuga și schimba multe aspecte ale modului în care camera va arăta. De exemplu, putem adăuga fundaluri în care poate fi o culoare simplă sau o imagine reală. Astfel de imagini de fundal pot fi create în GameMaker: Studio cu propriul editor sau le putem încărca din propiul desktop. Fundalurile pot fi de fapt făcute pentru a face o mulțime de lucruri, dar noi le vom folosi doar ca să infrumusețeze camera de joc. Mai departe putem plasa una (sau mai multe!) instanțe ale obiectelor pe care le-am creat în cameră. De exemplu, daca vrem să avem o zonă cu pereți în joc, trebuie sa definim un obiect ca fiind perete și apoi să amplasăm mai multe instanțe ale acestui obiect în camera noastră pentru a realiza zone făcute din pereți. Același lucru se poate face și pentru obiectele inamicilor! Doar îi atribuim inamicului un obiect și apoi plasăm mai multe instanțe în camera noastră pentru a obține un nivel întreg creat din doar câteva obiecte de bază. Iată un exemplu de modul în care arată editorul camerei:

Fig.2 Reprezentarea editorului de camere al programului GameMaker: Studio

Odată ce am finalizat proiectarea camerelor , suntem gata să rulăm jocul. Prima cameră care va fi afișată este întotdeauna prima cameră din lista principală de camere și va fi rulată la început. Acum instanțele pe care le-am plasat vor lua viață din cauza acțiunilor definite în evenimentele obiectelor și vor începe să reacționeze reciproc datorită acțiunilor plasate în evenimentele de coliziune ale obiectelor. Ele vor reacționa, de asemenea,cu jucătorul utilizând acțiunile plasate în orice eveniment de tip tastatură sau mouse.

Toate acestea fiind spuse acoperă cele mai importante două lucruri în GameMaker: Studio, dar sunt mult mai multe! Împreună sunt numite resurse și bunuri, iar în ecranul principal al GameMaker: Studio le putem găsi pe partea stângă într-un spațiu numit arborele de resurse. Iată o listă a acestora și trebuie să știm că toate vor juca un rol crucial în crearea jocului nostru.:

Fig.3 Reprezentarea arborelui de resurse în programul GameMaker: Studio

Sprites : Imagini(uneori animații) folosite să reprezentăm obiectele.

Sounds : Pot fi prezente în joc sub formă de muzică de fundal sau efecte sonore.

Backgrounds : Imagini care sunt folosite ca fundal în camerele de joc.

Paths : Acestea pot face ca anumite instanțe să urmeze o anumită cale.

Scripts : Un script este o bucată de cod căruia îi atribuim un nume și îl folosim ca o funcție GML.

Shaders : Un shader este o combinație de două “programe” scrise într-un limbaj propiu folosite sa creeze efecte grafice.

Fonts : Fonturile sunt folosite în joc pentru a afișa diferite texte.

Time Lines : Pot fi folosite ca să controlezi anumite perioade de timp în joc.

Objects : Fac parte din compoziția de bază a jocului.

Rooms : Zonele în care poziționăm obiectele.

Included Files : Fișiere pe care le putem adăuga jocului nostru.

Extensions : Cu ajutorul acestora putem dezvolta jocul.

Macros : O listă pre-configurată de constante pe care le vom folosi în joc.

2.2 Prezentarea interfeței motorului grafic

Fig.4 Reprezentarea interfeței programului GameMaker: Studio

Cum adăugăm sprite-uri jocului nostru ?

Sprite-urile sunt, în general, reprezentările vizuale ale obiectelor din jocul nostru. Ca atare, un sprite este o singură imagine sau un set de imagini care, atunci când sunt redate una după alta, devin o animație. De exemplu, următoarele 3 imagini formează un sprite pentru un inamic din joc care se miscă în dreapta :

Fig.5 Reprezentarea unui sprite care formeaza o animație în programul GameMaker: Studio

În mai toate jocurile noi realizăm sprite-urile ca cel de mai sus pentru toate lucrurile din lumea jocului nostru, de la inamici la power-up-uri și de la pereți la meniuri.

Pentru a crea un sprite, alegem elementul Create Sprite din bara de instrumente. Se va deschide următoarea fereastră:

Fig.6 Reprezentarea meniului de creat Sprite-uri în programul GameMaker: Studio

După cum putem vedea, în partea stângă sus a ferestrei există un câmp pentru adăugarea unui nume sprite-ului. Toate sprite-urile (și toate celelalte resurse) trebuie să aibă un nume dat astfel încât să le putem identifica cu ușurință noi dar și programul GameMaker: Studio, deși trebuie să reținem că numele propriu-zis este doar o variabilă care deține un număr care ”ne indrumă” spre resursă, în acest caz un sprite. Cel mai bine este să oferim fiecărui sprite un nume unic, astfel încât să putem identifica dacă o anumită resursă este un sprite sau un obiect sau orice altceva și mulți oameni fac acest lucru prin prefixarea sau sufixarea resurselor cu literele "spr". De exemplu, inamicul de mai sus are putea fi numit spr_monster2_run_right sau monster2_run_right_spr.

Pentru a încărca un sprite, facem clic pe butonul Load Sprite. Se deschide o fereastră de dialog specială în care putem alege sprite-ul pe care dorim să-l importăm în GameMaker: Studio:

Fig.7 Meniul de încărcat sprite-uri personale în programul GameMaker: Studio

Cum adăugăm sunete jocului nostru ?

Pentru a adăuga o resursă de sunet la jocului, utilizăm bara de instrumente sau facem click dreapta pe arborele de resurse și selectăm Create Sound. Oricare dintre acestea va conduce la următoarea fereastră:

Fig.8 Prezentarea meniului de inserare a unui sunet în programul GameMaker: Studio

Pentru a încărca un sunet, apăsăm butonul Load Sound din partea dreaptă a căsuței destinate numelui. Va apărea un dialog de selecție a fișierelor din care putem selecta fișierul de sunet, care poate fi fie un fișier de tip WAVE(*.wav), fie un fișier MP3. În general, fișierele Wave (* .wav) sunt folosite pentru efectele sonore scurte, chiar dacă acestea sunt în general fișiere mai mari care vor funționa instantaneu, datorită faptului că nu au nevoie de niciun fel de decodificare pentru redare. Putem, de asemenea, să avem mai multe fișiere de tip WAVE funționând simultan, de aceea trebuie să le folosim pe aceastea(WAVE) doar ca efecte sonore în joc.

Fișierele MP3 (* .mp3) trebuiesc să fie utilizate doar ca muzică de fundal deoarece GameMaker: Studio ne permite doar să redăm un singur fișier la un moment dat.

Odată ce am încărcat fișierul, putem previzualiza sunetul adăugat folosind butonul de redare care îl va reda în mod continuu.

Cum adăugăm un fundal jocului nostru ?

Fundalurile sunt niște resurse de bază pe care le putem utiliza în GameMaker: Studio. Acestea sunt, de obicei, imagini mari care sunt folosite ca fundaluri (sau prim-planuri) pentru camerele în care are loc jocul, dar ele pot fi și de asemenea imagini mari compuse din mai multe imagini mici numite Tiles, pe care le putem plasa individual în cameră pentru a crea imagini complexe pentru ca să nu îngreunăm jocul cu multe obiecte și sprite-uri.  Pentru a crea o resursă de tip fundal în joc, utilizăm opțiunea Creare Background din arborele de resurse sau utilizând butonul corespunzător din bara de instrumente. Oricare dintre acestea va deschide următoarea fereastră:

Fig.9 Reprezentarea meniului de creare/inserare de fundaluri în programul GameMaker: Studio

Ca și în cazul tuturor resurselor, trebuie să dăm un nume pentru fundalurile noastre pentru a le identifica cu ușurință. Cel mai bine este să dăm fiecărui fundal un nume unic, astfel încât să putem identifica dintr-o privire dacă o anumită resursă este un fundal sau un obiect sau orice altceva și mulți oameni fac acest lucru prin prefixarea sau sufixarea resurselor cu literele "bck". De exemplu, imaginea de mai sus poate fi numită bg_grass_2 sau grass_2_bg.

Cum realizăm un obiect pentru jocul nostru ?

Pentru a crea un obiect în joc, alegem Creare Object din arborele de resurse (sau facem click pe butonul specific din bara de instrumente) și se va deschide următoarea fereastră:

Fig.10 Reprezentarea meniului de creat obiecte din programul GameMaker: Studio

La prima vedere, acest lucru poate părea destul de confuz, dar fereastra este împărțită în secțiuni și vom descoperi ce fac fiecare în parte. Începând din stânga, există câteva informații generale despre obiect, apoi în mijloc se află lista evenimentelor (momente în timp) pentru obiect și fereastra pentru a plasa acțiunile care urmează să fie efectuate în acele evenimente și în final în partea dreaptă sunt acțiunile pe care le putem selecta pentru ca obiectul să fie realizat, grupat sub file diferite pentru a fi ușor de utilizat. Dacă selectăm "Uses Physics", atunci va apărea o noua fereastra de dialog numită Physics Properties.

După cum ne așteptăm, putem (și trebuie întotdeauna) să dăm obiectului cu pricina un nume. Acest lucru nu ar trebui să conțină niciodată spații sau caractere neautorizate și ar trebui să fie scurt, dar subiectiv, astfel încât să putem identifica cu ușurință resursele mai târziu deoarece când vom avea foarte multe va fi greu de identificat, de exemplu, unii oameni folosesc un prefix sau un sufix pentru a identifica diferențele dintre resurse, cum ar fi "obj_tree_2 " sau " tree_2_obj ". Apoi putem alege un sprite pentru obiect dacă dorim să aibă unul. Pentru aceasta facem click cu butonul din stânga al mouse-ului pe caseta de sprite sau pe butonul de meniu de lângă acesta și va apărea o fereastră de dialog cu o listă a tuturor spritelor disponibile din arborele de resurse, apoi selectămm pe cea pe care dorim să o folosim pentru obiect. Putem, de asemenea, să “tragem” un sprite din arborele de resurse și să-l plasăm peste Sprite Properties al obiectului nostru.

Mai jos avem prezentate toate opțiunile explicate:

Visible

Visible indică dacă instanțele acestui obiect sunt vizibile atunci când începe camera. În mod normal, majoritatea situațiilor sunt vizibile, dar uneori este util să avem și instanțe invizibile – de exemplu, le putem folosi ca puncte de control pentru a controla un inamic în mișcare sau pentru a urmării anumite valori și pentru a efectua anumite acțiuni temporizate. Obiectele invizibile vor reacționa în continuare la evenimente și dacă vor avea un sprite sau o mască atribuite acestora, vor reacționa și în cazul în care alte instanțe se vor ciocni cu ele … ele nu pot fi văzute și nu execută evenimentul de Draw.

Solid

Apăsând butonul Solid noi indicăm programului GameMaker: Studio că ar trebui să ia în considerare că instanțele acestui obiect sunt solide (ca un perete). Coliziunile cu instanțe de obiecte solide sunt tratate în mod diferit față de coliziunile cu obiectele non-solide și ca atare este bine să utilizam Solid doar pentru obiectele care nu se mișcă.

Depth

Depth(Adâncimea) controlează dacă instanțele unui obiect se suprapun sau nu peste alte obiecte la alte valori de adâncimi diferite. Atunci când sunt desenate pe ecran, ele sunt desenate în ordinea adâncimii, cu situațiile în care cea mai mare adâncime este afișată mai întâi și cu cea mai mică adâncime afișată ultima dată. Imaginea următoare ilustrează acest lucru:

Fig.11 Reprezentarea efectului de adâncime în programul GameMaker: Studio

Persistent Objects

Sub Depth există opțiunea de a face un obiect persistent. Un obiect persistent este unul care nu dispare atunci când se schimbă camera, ci mai degrabă "persistă" și este transferat în noua cameră. Va dispărea numai când îl distrugem în mod explicit, fie cu o acțiune distructivă, fie cu un cod. Aceasta înseamnă că, dacă plasăm un obiect persistent într-o singură cameră, acesta va fi disponibil în toate încăperile ulterioare și va continua să efectueze orice acțiune atribuită evenimentelor în proprietățile obiectului. Acest lucru este util atunci când avem, de exemplu, un personaj principal care se deplasează din cameră în cameră și dorim să mențineți variabilele pentru acel obiect la fel. Reținem, de asemenea, că un obiect persistent va declanșa evenimentul său de pornire a jocului, sfârșitul jocului, cameră și evenimentul de sfârșit de cameră, totuși dacă repornim jocul (de exemplu, funcția game_restart () ), toate obiectele persistente vor fi eliminate și numai există decât atunci când sunt create din nou de joc. De asemenea, dacă dezactivăm un obiect persistent, acesta nu va mai trece dintr-o cameră la alta decât dacă este reactivat înainte de declanșarea evenimentului Room End.

Parents

Una dintre cele mai puternice opțiuni din proprietățile obiectului este abilitatea de a atribui un părinte. Fiecare obiect din joc poate avea un obiect-părinte, dar ce înseamnă asta? Atunci când un obiect are un părinte, acesta poate “moștenii” codul, acțiunile și evenimentele de la acel părinte. Aceasta se numește "moștenire", iar un obiect care are un părinte este numit "copil". Dar asta nu este tot! De asemenea, putem efectua modificări la codul obiectului părinte care includ automat și obiectele copilului, ceea ce economisește mult timp și energie. O altă modalitate de a utiliza un obiect-părinte este ca o modalitate de a "grupa" obiectele împreună sub aceeași “umbrelă” și de a le face să împărtășească anumite lucruri fără a-și pierde propria identitate. Putem să facem click pe butonul Parent pentru a deschide automat obiectul-copil alocat și putem vedea, de asemenea, o listă de obiecte-copii și daca acestea au ca "părinte" pe altcineva. Dacă facem dublu click pe numele obiectului din această listă, va deschide fereastra proprietăților pentru editare. De asemenea, putem trage un obiect din arborele de resurse în Parents Option sau Child Option și acesta va fi adăugat ca părinte sau copil, după cum este necesar.

Masks

Atunci când un obiect are o sprite, are și o mască. Aceasta este de obicei definită de sprite(și poate fi schimbată în editorul de sprite), dar uneori poate dorim ca un obiect să aibă o mască diferită în formă de sprite sau chiar să nu aibă niciun sprite ci doar o mască. De ce? Ei bine, măștile sunt cele ce guvernează coliziunile în GameMaker: Studio. Atunci când două instanțe se ciocnesc, GameMaker: Studio trebuie să decidă dacă a avut loc o coliziune și pentru aceasta se bazează pe masca obiectului, fie cea definită aici, fie aceea definită în proprietățile sprite. Dacă nu avem nici o mască, atunci nu avem nici o coliziune. De asemenea, trebuie să reținem că, dacă am atribuit un sprite obiectului și apoi îi atribuim o mască, GameMaker: Studio va baza întotdeauna coliziunile pe baza măștii atribuite și NU a sprite-ului.

Information

Butonul de Show Information ne arată un scurt rezumat al tuturor acțiunilor unui obiect care poate fi print-at sau salvat ca un fișier HTML5. Acest lucru este util în special atunci când dorim o imagine de ansamblu a tuturor acțiunilor, codului și evenimentelor sau dacă dorim să depanăm ceva în interiorul obiectului.

Uses Physics

Când bifăm aceast buton, îi spunem programului GameMaker: Studio că acest obiect ar trebui să facă parte dintr-o lume a fizicii. Aceasta va deschide, de asemenea, o altă fereastră unde putem defini proprietățile fizice ale tuturor instanțelor acestui obiect.

Cum realizăm o camera pentru jocul nostru ?

Toate jocurile pe care le facem în GameMaker: Studio necesită cel puțin o cameră pentru a rula (dar poate avea multe,foarte multe!), iar o cameră este doar un spațiu în care plasăm instanțe ale obiectelor care alcătuiesc jocul. Când creăm pentru prima dată o camera apare o fereastră nouă la care putem să edităm proprietățile sale, ceva de genul:

Fig.12 Prezentarea editorului de cameră în programul GameMaker: Studio

După cum putem vedea, majoritatea editorului de cameră este o reprezentare vizuală a camerei în sine, unde plasăm obiectele, dalele(Tiles) și fundalul pentru jocul nostru, dar în jurul marginilor există un număr de butoane,bara de informație si cea de instrumente care ne ajută să realizăm jocul.

Bara de instrumente

În partea de sus a ferestrei există bara de instrumente, care are un număr de butoane care se oferă diferite acțiuni în editorul camerei.

Fig.13 Bara de instrumente din editorul de cameră din programul GameMaker: Studio

-Confirm : Acest buton închide editorul și salvează progresul.

-Undo : Restabilește ultima acțiune care a fost făcută.

-Instance actions : Ne dă posibilitatea să schimbăm anumite propietăți ale unor instanțe.

-Grid Snap : Aceste valori pot fi modificate pentru ca editorul de camera să fie împărțit sub forma de grilă.

-Grid Type : Tipul de grilă care împarte editorul de cameră.

-Visualisation Options : Cu ajutorul acestui buton putem selecta ce poate fi afișat în editorul de cameră ,cum ar fi : intanțe,dale,vederi(views) etc.

-Zoom Control : Poate fi folosit ca să mărim sau micim imaginea din editorul de cameră.

-Instance Order and Shortcuts : Ne dă posibilitatea sa alegem în ce ordine să fie create instanțele în cameră și ne mai arată scurtăturile disponibile prin apăsarea anumitor taste.

Camera în miniatură

După cum ne putem imagina,aceasta este o reprezentare în miniatură a camerei noastre.

Bara de informație

În timp ce plasăm dale și instanțe într-o cameră, adesea avem nevoie de informații suplimentare despre ele la prima vedere. Pentru aceasta avem bara de informație care afișează poziția curentă a mouse-ului în cameră, id-ul și obiectul_index al instanței pe care mouse-ul se află în prezent și alte informații, cum ar fi dacă instanța are cod sau nu în evenimentul de creare al camerei.

Panoul de comandă

În partea stângă vom vedea șase fișiere care deschid subpagini separate în zona din stânga.Fiecare subpagină are câte un set de comenzi aparte:

Fig.13 Prezentarea celor șase fisiere din editorul de camera din programul GameMaker: Studio

2.3 Acțiuni existente în programul GameMaker: Studio

Unul dintre lucrurile care fac GameMaker: Studio atât de unic este ușurința cu care pot fi făcute simple comenzi și funcții pentru a manipula lumea jocurilor folosind acțiuni. Aceste acțiuni vin sub formă de seturi de acțiuni, fiecare set având un număr de pictograme pe care le putem trage și plasa în evenimentul unui obiect pentru a crea comportamente pentru acel obiect (acest lucru este numit în mod obișnuit "DnD",prescurtare de la drag’N'drop). Iată seturile de acțiuni în întregime:

Fig.12 Prezentarea tuturor acțiunilor prezente în programul GameMaker: Studio

Toate acțiunile se găsesc în partea dreaptă a ferestrei de dialog a obiectului și după cum putem vedea, există șapte file pline cu acțiuni pe care să le putem utiliza pentru a crea jocuri.

Pentru a pune o acțiune într-un eveniment, o selectăm din lista de acțiuni din fereastra obiectului așa cum se arată în imaginea de mai jos:

Fig.13 Reprezentarea inserării unei acțiuni în programul GameMaker: Studio

2.4 Evenimente existente în programul GameMaker: Studio

Deci, care sunt evenimentele? Practic, acestea sunt momente în bucla jocului în care lucrurile sunt făcute să se întâmple pe baza programării noastre. Putem vedea cum programul GameMaker: Studio lucrează cu cicluri ale acestor evenimente – din momentul în care o cameră este pornită până în momentul în care este oprită există o buclă de joc în care fiecare pas (un pas este un moment în timpul jocului, guvernat de setarea vitezei camerei ) Se execută o serie de evenimente și putem alege să plasăm acțiuni de cod sau acțiuni DnD în instanțele care răspund la aceste evenimente. Să ne uităm la lista tuturor evenimentelor :

Fig.14 Prezentarea tuturor evenimentelor

prezente în programul GameMaker: Studio

Aceasta este lista tuturor evenimentelor de bază la care un obiect poate răspunde, deși unele dintre aceste evenimente au, de asemenea, sub evenimente, pentru a defini în continuare comportamentele. De exemplu, dacă adăugăm un eveniment Key Press, vom obține apoi o fereastră nouă în care se va afișa evenimentele secundare care ne permit să selectăm ce tastă să răspundă obiectului. După ce am selectat evenimentul, putem adăuga acțiuni de tip DnD sau cod în secțiunea Actions din partea dreaptă a listei de evenimente, ceea ce înseamnă că îi spunem programului GameMaker: Studio că atunci când acest eveniment este declanșat, aceste acțiuni ar trebui efectuate. Aici este o imagine de exemplu pentru a ilustra acest lucru:

Fig.15 Prezentarea evenimentelor și acțiunilor în programul GameMaker: Studio

Capitolul 3

3.1 Prezentarea aplicației Enigma’s Monsters

Această lucrare își propune realizarea jocului 2D de tip RPG(Role Playing Game) cu numele „Enigma’s Monsters” pentru platforma Windows. Îndeplinirea acestui scop este realizată prin simbioza ideilor și conceptelor precizate în capitolele 1 și 2. Jocul este realizat pe baza motorului GameMaker: Studio cu ajutorul căruia sunt combinate toate elementele, atât grafice cât și cele audio într-o manieră adecvată oricărui tip de utilizator.

Enigma’s Monsters este conceput să fie plăcut, ușor de înțeles și jucat,dar reușește să testeze reflexele și timpul de reacție al jucătorului.

Motorul grafic GameMaker: Studio crează cu ajutorul elementelor componente cum ar fi camerele,obiectele,acțiunilor și a sistemului de Physics o simulare cât mai apropiată de realitate.

Sistemul de Physics îi atribuie jocului o nuanță de realism prin prezența forțelor de frecare,coliziuni,prezența gravitației.

Jocul Enigma’s Monsters este inspirat din jocurile anilor ’80 – ’90 ,mai exact era jocurilor pe televizor. Acestea au avut un rol important în copilăria mea. Pe vremea aceea nu conta grafica ,rezoluția sau calitatea audio. Ba din contră, simplitatea acestora le-au făcut să-mi fie așa dragi.

Acesta este de tip RPG ,în care poți progresa în nivel omorând inamici,automat crescând nivelul variabilei HP (viață),Stamina (rezistență) și Damage(putere).

Enigma’s Monsters dispune de 5 camere diferite în care jucătorul v-a întâmpina o varietate de inamici. Dupa ce un inamic a fost doborât acesta lasă pe jos un glob luminos numit experiență. Jucătorul trebuie să le adune pentru a putea progresa. Dar pe lângă experientă,inamici au o șansă de a arunca și o trusă de prim ajutor care are rolul de a reface constanta de viață a jucătorului parțial.

Toate obiectele și fundalurile au o paletă de culori bogată predominând culorile calde,oferind jocului un aspect mai energic,mai animat.

Jocul are un meniu de start animat care oferă jucătorului două opțiuni de alegere: Start Game și Exit Game:

Fig.1 Reprezentarea meniului de start al jocului

După meniul de start,jucătorul este trimis în prima cameră,aceasta fiind considerată o zonă neutră (fără inamici) în care jucătorul poate admira peisajul din jurul casei sale în care,desigur,poate intra. Tot în prima camera jucătorul poate interactiona cu un NPC*.

Fig.2 Prezentarea parțiala a primei camere

NPC = Non-Player Character (Un caracter controlat printr-un algoritm pe baza inteligenței artificiale)

Fig.3 Prezentarea interiorului casei

Fig.4 Reprezentarea interacțiunii cu un NPC*

NPC = Non-Player Character (Un caracter controlat printr-un algoritm pe baza inteligenței artificiale)

Jocul prezintă un meniu de pauză interactiv,în care jucătorul poate selecta o anumită opțiune bazată pe o anumită acțiune prestabilită.Acesta poate fi accesat prin apăsarea tastei Escape oricând jocul este pornit.

Meniul de pauză este animat,oferind următoarele opțiuni:

-Return : Opțiune care ne readuce în joc.

-Save : Ne dă posibilitatea de a salva progresul jucătorului la un anumit moment dat,salvând variabilele(Room,HP,STAMINA,LEVEL,DAMAGE).

-Load : Cu această comandă putem aduce valorile salvate anterior și să le încărcăm în joc.

-Quit : Aceasta ne oferă posibilitatea de a închide jocul.

Fig.5 Reprezentarea vizuală a meniului de pauză

Enigma’s Monsters mai dispune de încă patru camere, trei dintre ele sunt interactive prin prezența inamicilor versatili ,iar ultima este cea de Game Over.

A doua cameră este reprezentată de o pădure de conifere în care jucătorul este întâmpinat de o varietate de inamici,cum ar fi:

-Mâzga vie : Acest inamic se deplasează încet,usor de omorât la început.Prezintă trei puncte

de viață.

-Liliacul : Are o caracteristică unică,foarte agil. Prezintă șase puncte de viață.

-Anomalia : Este destul de rezistentă pentru începutul jocului.Prezintă zece puncte de viață.

Fig.6 Prezentarea parțială camerei cu numărul doi și a celor trei inamici prezenți : Mâzga vie,Liliacul și Anomalia

A treia cameră este reprezentarea minimalistă a unui cimitir. Aici jucătorul descoperă alți inamici ,și anume:

-Fantoma : Aceasta este cea mai rapidă față de ceilalți inamici din această cameră. Are

doisprezece puncte de viață.

-Scheletul : Prezintă cincisprezece puncte de viață.

-Vampirul : Are cel mai mare număr de puncte de viață din această cameră și anume

optsprezece puncte de viață.

Fig.7 Prezentarea parțială a camerei cu numărul trei alături de cei trei inamici prezenți în ea:

Fantoma,Scheletele,Vampirul

Cea de-a patra cameră se desfașoară în deșert ,unde avem o mică reprezentare a unui templu.

Jucătorul descoperă un set nou de inamici :

-Scorpionul : Foarte mobil acesta prezintă douăzeci de puncte de viață.

-Șarpele : Acesta este foarte impunător din cauza dimensiunilor mari ale acestuia.Are douăzeci

și patru de puncte de viață.

-Mumia : Este inamicul cu cele mai multe puncte de viață din tot jocul și anume douăzeci si

opt.

Fig.8 Prezentarea sumară a camerei cu numărul patru și a inamicilor : Scorpionul,Șarpele și Mumia

În cazul în care jucătorul își pierde toate punctele de viață pe ecran va apărea o cameră animată cu textul Game Over,însoțită de un efect sonor caracteristic.După o anumită perioadă de timp,jucătorul va fi redirecționat automat la camera cu meniul de start.

Fig.9 Prezentarea ultimei camere în care este afișat textul Game Over

3.2 Codul de bază al jocului Enigma’s Monsters

Jocul poate fi controlat atât de pe tastatură dar și cu un controller Xbox 360.

Caracterul jucătorului este intuitiv de controlat ,având posibilitatea de mișcare în cele patru direcții generale : sus,jos,dreapta,stânga dar este posibilă și mișcarea în diagonală(combinații de câte două taste cum ar fi dreapta-sus,stânga-sus,dreapta-jos,stânga-jos).

Realizarea mișcarii este realizată prin urma apăsării săgeților de pe tastatură sau cu ajutorul joystick-ului controller-ului de Xbox 360.

Pe lângă mișcare ,jucătorul poate efectua un dash(salt) apăsând tasta “C” de pe tastatură sau prin apăsarea butonului “A” de pe controller.

Jucătorul poate alege să atace cu sabia cu ajutorul butonului “X” de pe tastatură sau de pe controller.

Poate ataca și la distanță cu o bilă de foc prin intermediul butonului “V” de pe tastatură sau de pe butonul “B” de pe controller.

Codul de input al jocului este următorul:

/// scr_get_input

right_key = keyboard_check(vk_right);

up_key = keyboard_check(vk_up);

down_key = keyboard_check(vk_down);

left_key = keyboard_check(vk_left);

dash_key = keyboard_check_pressed(ord('C'));

attack_key = keyboard_check_pressed(ord('X'));

spell_key = keyboard_check_pressed(ord('V'));

pause_key = keyboard_check_pressed(vk_escape);

// Get the axis

xaxis = (right_key – left_key);

yaxis = (down_key – up_key);

// Check for gamepad input

if (gamepad_is_connected(0)) {

gamepad_set_axis_deadzone(0, .35);

xaxis = gamepad_axis_value(0, gp_axislh);

yaxis = gamepad_axis_value(0, gp_axislv);

dash_key = gamepad_button_check_pressed(0, gp_face1);

attack_key = gamepad_button_check_pressed(0, gp_face3);

pause_key = gamepad_button_check_pressed(0, gp_start);

spell_key = gamepad_button_check_pressed(0, gp_face2);

}

Explicația codului:

-scr_get_input este un script. Un script (ca orice funcție încorporată) poate lua variabile de intrare diferite, cu valori reale,tip șir, boolean și speciale,iar aceste variabile de intrare sunt denumite în general argumente, dar mai sunt denumite și parametri. Pentru a executa un script dintr-un obiect sau o linie de timp, putem folosi acțiunea Execute Script, dar putem și să-l apelăm și într-o fereastră de cod folosind numele script-ului respectiv ca și cum ar fi o funcție sau și folosind funcția GML script_execute.

Codul care face posibilă mișcarea caracterului este:

/// scr_move_state

movement = MOVE;

if (obj_input.dash_key) {

var xdir = lengthdir_x(8, face*90);

var ydir = lengthdir_y(8, face*90);

var speaker = instance_place(x+xdir, y+ydir, obj_speaker);

if (speaker != noone) {

// Talk to it

with (speaker) {

if (!instance_exists(dialog)) {

dialog = instance_create(x+xoffset, y+yoffset, obj_dialog);

dialog.text = text;

} else {

dialog.text_page++;

dialog.text_count = 0;

if (dialog.text_page > array_length_1d(dialog.text)-1) {

with (dialog) {

instance_destroy();

}

}

}

}

} else if (obj_player_stats.stamina >= DASH_COST) {

// Dash

audio_play_sound(snd_dash, 11, false);

state = scr_dash_state;

alarm[0] = room_speed/8;

obj_player_stats.stamina -= DASH_COST;

obj_player_stats.alarm[0] = room_speed/0.5;

}

}

if (obj_input.attack_key) {

image_index = 0;

state = scr_attack_state;

}

if (obj_input.spell_key) {

var p = instance_create(x, y, obj_projectile);

var xforce = lengthdir_x(3, face*90);

var yforce = lengthdir_y(3, face*90);

p.creator = id;

with (p) {

physics_apply_impulse(x, y, xforce, yforce);

}

}

// Get direction

dir = point_direction(0, 0, obj_input.xaxis, obj_input.yaxis);

//Get the length

if (obj_input.xaxis == 0 and obj_input.yaxis == 0) {

len = 0;

} else{

len = spd;

scr_get_face(dir);

}

// Get the hspd and vspd

hspd = lengthdir_x(len, dir);

vspd = lengthdir_y(len, dir);

// Move

phy_position_x += hspd;

phy_position_y += vspd;

// Control the sprite

image_speed = .2;

if (len == 0) image_index = 0;

Explicația codului:

-var este o variabilă locală pe care o declarăm prima,o folosim și după o terminăm.

-lengthdir_x returnează componenta orizontală x a vectorului determinată de lungimea și direcția indicate.

-instance_place verifică o anumită coliziune cu obiectul specificat și returnează id-ul ei.

-array_length_1d returnează lungimea primei dimensiuni a unei mulțimi.

-physics_apply_impulse această funcție aplică un impuls către o anumită poziție din camera cu o putere determinate de un vector.

-place_meeting verifică dacă există coliziune între două instanțe într-un anumit loc.

-point_direction returnează valorea direcției ,în grade a unui vector.

-phy_position_x poziția x a unei instanțe în physics world.

Codul care face posibil ca jucătorul să poată ataca

///scr_attack_state

image_speed = .5;

movement = ATTACK;

if (scr_animation_hit_frame(2)) {

var attack_animation = instance_create(x, y, obj_weapon_animation);

attack_animation.dir = face*90;

attack_animation.image_angle = (face*90)+45;

attack_animation.sprite_index = weapon_sprite;

}

if (scr_animation_hit_frame(3)) {

var xx = 0;

var yy = 0;

switch (face) {

case DOWN:

xx = x;

yy = y+12;

break;

case UP:

xx = x;

yy = y-10;

break;

case RIGHT:

xx = x+10;

yy = y+2;

break;

case LEFT:

xx = x-10;

yy = y+2;

break;

}

audio_play_sound(snd_sword_attack, 8, false);

var damage = instance_create(xx, yy, obj_damage);

damage.creator = id;

damage.damage = obj_player_stats.attack;

}

Explicația codului:

-image_speed ne permite să controlăm viteza unei animații.

-switch această funcție ne permite să trecem de la o afirmație if la alta.

Codul care face posibil ca inamicii să se poată mișca,urmării și să stea pe loc

În acest joc inamicii prezintă o mică formă de inteligență artificiala prin faptul că se deplasează în cameră fără a urma o traiectorie,destinație etc. După ce jucătorul începe să fie urmărit de inamic după un anumit moment acesta abandonează urmărirea și revine la starea de mișcare liberă.

///scr_check_for_player()

if (instance_exists(obj_player)) {

var dis = point_distance(x, y, obj_player.x, obj_player.y);

if (dis < sight) {

state = scr_enemy_chase_state;

var dir = point_direction(x, y, obj_player.x, obj_player.y);

xaxis = lengthdir_x(1, dir);

yaxis = lengthdir_y(1, dir);

} else {

scr_enemy_choose_next_state();

}

} else {

scr_enemy_choose_next_state();

}

-În acest cod,inamicul prin mișcarea liberă “caută” jucătorul. Dacă acesta îl găsește ,începe urmarirea.

/// scr_move_axis()

var dir = point_direction(0, 0, xaxis, yaxis);

var hspd = lengthdir_x(spd, dir);

var vspd = lengthdir_y(spd, dir);

if (hspd != 0) {

image_xscale = sign(hspd);

}

scr_get_face(dir);

movement = MOVE;

phy_position_x += hspd;

phy_position_y += vspd;

-În acest cod este setată funcția de mișcare liberă a inamicului.

///scr_enemy_choose_next_state()

if (alarm[0] <= 0) {

state = choose(scr_enemy_wander_state, scr_enemy_idle_state);

alarm[0] = room_speed*irandom_range(2, 4);

if (state == scr_enemy_wander_state) {

xaxis = random_range(-1, 1);

yaxis = random_range(-1, 1);

}

}

-irandom_range returnează un număr întreg între n1 și n2.

-random_range returnează un număr real între n1 și n2.

-Aici se face tranziția dintre starea de mișcare și cea de repaus.

Codul care face posibilă salvarea progresului jocului

/// scr_save_game()

// Make sure the player exists

if (!instance_exists(obj_player_stats)) exit;

// Create the save data structure

var save_data = ds_map_create();

with (obj_player_stats) {

save_data[? "room"] = previous_room;

save_data[? "x"] = player_xstart;

save_data[? "y"] = player_ystart;

save_data[? "hp"] = hp;

save_data[? "maxhp"] = maxhp;

save_data[? "stamina"] = stamina;

save_data[? "maxstamina"] = maxstamina;

save_data[? "expr"] = expr;

save_data[? "maxexpr"] = maxexpr;

save_data[? "level"] = level;

save_data[? "attack"] = attack;

}

var save_string = json_encode(save_data);

ds_map_destroy(save_data);

save_string = base64_encode(save_string);

var file = file_text_open_write(working_directory + "mysavegame.txt");

file_text_write_string(file, save_string);

file_text_close(file);

show_message("Game saved");

-ds_map_create cu această funție se creeaza o nouă cameră în care sunt salvate anumite valori.

-json_encode JSON (JavaScript Object Notation) este un format de schimb de date care este ușor de citit și scris, atât pentru oameni, cât și pentru mașini. Cu ajutorul acestui format,toate valorile specifice caracterului nostru sunt salvate într-un fisier în ordinea cum au fost introduse.

-base64_encode codează un șir pentru a nu putea fi citit. Această cript-are este o masură de siguranță a jocului care împiedică jucătorul să trișeze prin modificarea valorilor aflate în fișierul mysavegame.txt.

Codul care face posibilă încărcarea unei salvări.

// scr_load_game

var file = file_text_open_read(working_directory+"mysavegame.txt");

var save_string = file_text_read_string(file);

file_text_close(file);

save_string = base64_decode(save_string);

var save_data = json_decode(save_string);

var save_room = save_data[? "room"];

if (room != save_room) {

room_goto(save_room);

}

if (instance_exists(obj_player_stats)) {

//with (obj_player_stats) {

obj_player_stats.player_xstart = save_data[? "x"];

obj_player_stats.player_ystart = save_data[? "y"];

if (instance_exists(obj_player)) {

obj_player.x = obj_player_stats.player_xstart;

obj_player.y = obj_player_stats.player_ystart;

obj_player.phy_position_x = obj_player_stats.player_xstart;

obj_player.phy_position_y = obj_player_stats.player_ystart;

} else {

instance_create(player_xstart, player_ystart, obj_player);

obj_player.phy_position_x = obj_player_stats.player_xstart;

obj_player.phy_position_y = obj_player_stats.player_ystart;

}

obj_player_stats.previous_room = save_data[? "room"];

obj_player_stats.hp = save_data[? "hp"];

obj_player_stats.maxhp = save_data[? "maxhp"];

obj_player_stats.stamina = save_data[? "stamina"];

obj_player_stats.maxstamina = save_data[? "maxstamina"];

obj_player_stats.expr = save_data[? "expr"];

obj_player_stats.maxexpr = save_data[? "maxexpr"];

obj_player_stats.level = save_data[? "level"];

obj_player_stats.attack = save_data[? "attack"];

//}

}

ds_map_destroy(save_data);

-Cu ajutorul acestui cod,jucătorul are posibiliatea să reia jocul de unde acesta a salvat. Contrar procesului de salvare în care variabilele jucătorului erau transformate în format JSON și apoi cript-ate cu ajutorul base64,aici procesul este inversat.

Codul existent în evenimentul de creare al obiectului care conține variabilele caracterului jucătorului

/// Initialize the player's stats

hp = 5;

maxhp = hp;

stamina = 10;

maxstamina = stamina;

expr = 1;

maxexpr = 3;

level = 1;

attack = 1;

//Get the player's xstart and ystart

if (instance_exists(obj_player)) {

player_xstart = obj_player.x;

player_ystart = obj_player.y;

} else {

player_xstart = 0;

player_ystart = 0;

}

// Save the previous room

previous_room = room;

room_start_action = NEW_ROOM;

Codul care face posibil saltul caracterului

/// scr_dash_state

movement = MOVE;

if (len == 0) {

dir = face*90;

}

len = spd*4;

if (audio_is_playing(snd_dash) = false) {

audio_play_sound(snd_dash, 11, false);

}

// Get the hspd and vspd

hspd = lengthdir_x(len, dir);

vspd = lengthdir_y(len, dir);

// Move

phy_position_x += hspd;

phy_position_y += vspd;

// Create the dash effect

var dash = instance_create(x, y, obj_dash_effect);

dash.sprite_index = sprite_index;

dash.image_index = image_index;

3.3 Concluzii de final

Aplicația Enigma’s Monsters încearcă să satisfacă preferințele existente în domeniul jocurilor 2D prin simplitatea și diversitatea sa. Aceasta aplicație dorește să-i ofere jucătorului o experiență plăcută,dinamică și un test de reacție și atenție la mediul înconjurător.

Prin fuziunea elementelor vizuale (camere,fundaluri,sprite-uri), audio și prin prezența elementelor de physics am reușit să recreez o lume oarecum reală ,naturală care îi induce jucătorului o senzație de melancolie datorită accentului retro al aplicației.

Implementări dorite pe viitor:

Implementarea modului Co-op în care pot juca doi sau mai mulți jucători;

Adăugarea modului Multiplayer online;

Apariția mai multor camere ,oferind astfel o experiență mai versatilă;

Introducerea mai multor arme/vrăji ,adăugarea de poțiuni și armuri;

Realizarea unui inventar în care jucătorul să poată “strângă” mai multe obiecte;

Mărirea diversității inamicilor;

Adăugarea mai multor NPC-uri cu care jucătorul să poată interacționa;

Implementarea quest-urilor(misiunilor) care oferă jucătorului o experiență plină de aventură,mister;

Realizarea unor magazine în prima hartă de unde jucătorul poate sa cumpere anumite obiecte;

Introducerea unei valute cu ajutorul căreia jucătorul să poată achizitiona diverse obiecte de la magazin;

Crearea unui inamic final cu forme de atac diferite;

Posibilitatea de a avea un companion(animal,monstru etc) care să ajute jucătorul.

Bibliografie

1.https://ro.wikipedia.org/wiki/Joc_video

2.https://ro.wikipedia.org/wiki/Joc_pentru_calculator

3.http://pinchinene.blogspot.ro/

4.http://torrentsgames.org/pc/rome-total-war-pc.html

5.http://www.denofgeek.com/games/dragon-age-inquisition/32947/the-evolution-of-the-rpg

6.https://www.ubisoft.com/en-GB/game/might-and-magic-heroes-7/

7.https://www.gamespot.com/articles/bethesda-built-really-good-fps-for-fallout-4/1100-6428329/

8.http://www.apklover.net/2015/01/road-warrior-crazy-armored-mod-apk.html

9.http://www.oneangrygamer.net/2017/04/fallout-4-mods-add-mgs-third-person-ads-craftable-displays-and-more/29358/

10.https://www.keengamer.com/Game/minecraft/detail

11.http://blog.scssoft.com/2014/11/euro-truck-simulator-2-114-daf-update.html

12.https://mmogames2012.wordpress.com/

13.http://www.pacxongame.com/donkey-kong.php

14.http://us.battle.net/hearthstone/en/

15.https://www.youtube.com/watch?v=7XDcSXVUGsE&list=PLPRT_JORnIuo-DyoWbB7LBrhqlJnsltJq

16.https://www.youtube.com/watch?v=WB2alpO62GM&list=PL9FzW-m48fn2ug_FSNnfozQs3qYlBNyTd

17.https://www.youtube.com/watch?v=hzMNunoPd0o&list=PLPRT_JORnIurFYwHdWhLWR3bLH2nzChsm

18.https://www.yoyogames.com/learn

19.http://gamemakertutorials.com

20.GameMaker: Studio Manual