IGRE Z IGRALNIM POGONOM COCOS2D-X · Cocos2d-x game engine Key words: game engine, game...

Matija Perhoč

RAZVOJ VEČPLATFORMSKE

IGRE Z IGRALNIM POGONOM

COCOS2D-X

Diplomsko delo

Maribor, september 2017

RAZVOJ VEČPLATFORMSKE IGRE Z IGRALNIM

POGONOM COCOS2D-X

Diplomsko delo

Študent: Matija Perhoč

Študijski program: Univerzitetni študijski program

Računalništvo in informacijske tehnologije

Mentor: prof. dr. Janez Brest

Somentor: doc. dr. Borko Bošković

Razvoj večplatformske igre z igralnim pogonom Cocos2d-x

i | S t r a n


ii | S t r a n

Razvoj večplatformske igre z igralnim pogonom

Cocos2d-x

Ključne besede: igralni pogon, razvoj igre, orodje Coosc2d-x

UDK: 004.388.4(043.2)

Povzetek

Zadnje čase postajajo videoigre del vedno večjega števila različnih orodij in platform.

Razvoj videoiger ni enostaven in je časovno zahteven. Zato bomo v diplomskem delu

preučili igralni pogon Cocos2d-x, s katerim je razvoj igre po eni strani olajšan, po drugi

strani pa obenem omogoča tudi razvoj igre za več platform hkrati. Slednje pomeni

zmanjšanje stroškov in skrajšan čas razvoja. Predstavili bomo njegove osnovne funkcije

in to znanje uporabili pri razvoju igre za mobilne in PC-platforme. Opisali bomo postavitev

razvojnega okolja in njegovo uporabo. Preučili bomo delovanje igralnega pogona in opisali

potek razvoja igre.


iii | S t r a n

Development of multi-platform game with the

Cocos2d-x game engine

Key words: game engine, game development, Cocos2d-x

UDK: 004.388.4(043.2)

Abstract

Video games have been recently covering more and more devices and platforms. The

development of video games isn't easy and takes up a lot of time. That's why this thesis

covers the game engine Cocos2d-x. With the engine's help the development is easier and

it allows us to develop for more platforms at once. This cuts our costs and shortens the

development time. We will get to know the engine's basic functions and apply this

knowledge to develop a game for mobile and PC platforms. We will describe the set up of

a development environment and its use. We will examine how the game engine works and

describe the development of the game itself.


iv | S t r a n

KAZALO

1 UVOD ............................................................................................................................. 1

1.1 Cilj diplomskega dela .............................................................................................. 1

1.2 Struktura diplomskega dela .................................................................................... 1

2 RAZVOJ IGRE ............................................................................................................... 3

2.1 Platforme ................................................................................................................. 3

2.2 Računalniške igre ................................................................................................... 5

2.3 Mobilne igre............................................................................................................. 6

3 Igralni pogon ................................................................................................................... 7

3.1 Osnove dela z igralnim pogonom ........................................................................... 7

3.2 Funkcionalnosti igralnega pogona .......................................................................... 7

4 RAZVOJ IGRE ............................................................................................................. 10

4.1 Ideja igre ............................................................................................................... 13

4.2 Izbira igralnega pogona ........................................................................................ 14

4.2.1 Igralni pogon Cocos2d-x ............................................................................... 16

4.3 Orodja za razvoj igre ............................................................................................. 23

5 IMPLEMENTACIJA IGRE ............................................................................................ 27

5.1 Postavke projekta ................................................................................................. 28

5.2 Implementacija scen ............................................................................................. 30

5.3 Implementacija menija .......................................................................................... 32

5.4 Implementacija animacij ....................................................................................... 35

5.5 Implementacija strukture igre ............................................................................... 41

5.6 Logika igre ............................................................................................................. 47

5.7 Cilj igre .................................................................................................................. 54

6 Preizkušanje igre .......................................................................................................... 55


v | S t r a n

6.1 Optimizacija........................................................................................................... 55

6.2 Možne izboljšave .................................................................................................. 57

6.3 Težave................................................................................................................... 58

6.4 Izvoz igre na različne platforme ............................................................................ 59

6.5 Rezultati preizkušanja ........................................................................................... 61

7 ZAKLJUČEK ................................................................................................................. 63

VIRI ...................................................................................................................................... 65


vi | S t r a n

KAZALO SLIK

Slika 2.1 Arkadna platforma igre space invaders. ................................................................ 4

Slika 2.2 Oculus rift platforma za virtualno resničnost. ......................................................... 5

Slika 3.1 Funkcionalnosti igralnega pogona. ........................................................................ 8

Slika 4.1 Primer najosnovnejšega sprejemljivega produkta. .............................................. 11

Slika 4.2: Struktura igralnega pogona Cocos2d-x. Vir: [9] .................................................. 16

Slika 4.3: Koncept ravnatelja. Vir: [12] ................................................................................ 19

Slika 4.4: Algoritem in-order-walk. ...................................................................................... 19

Slika 4.5: Kombinacija spawn in sequence. Vir: [16] .......................................................... 21

Slika 4.6: Easing funkcije. Vir: [16] ...................................................................................... 22

Slika 5.1: Razredni diagram. ............................................................................................... 27

Slika 5.2: Prevzem iz GitHub repozitorija............................................................................ 28

Slika 5.3: Nastavitev lokalnih spremenljivk. ........................................................................ 29

Slika 5.4: Ustvarjanje novega projekta. ............................................................................... 29

Slika 5.5: Osnovne scene v igri. .......................................................................................... 31

Slika 5.6: Sprite sheet ozadje in meni. ................................................................................ 33

Slika 5.7: Logika zamenjave scen. ...................................................................................... 34

Slika 5.8: Učinek paralaks. .................................................................................................. 37

Slika 5.9: Bezierjeva funkcija............................................................................................... 40

Slika 5.10: Virtualno telo, sestavljeno iz več oblik. ............................................................. 51

Slika 6.1: Prikaz statusne vrstice. ....................................................................................... 56

Slika 6.2: Dodajanje razredov v datoteko Android.mk. ....................................................... 60

Slika 6.3: Prevajanje aplikacije za Android. ........................................................................ 60

Slika 6.4: Igra na Android emulatorju in androidni mobilni napravi. ................................... 61

Slika 6.5: Povprečno število slik v sekundi. ........................................................................ 62

Slika 6.6: Preizkušanje porabe spomina in obremenjenosti procesorja . ........................... 62

KAZALO TABEL

Tabela 4.1: Različice igralnega pogona Cocos2d. Vir: [10] ................................................ 17


vii | S t r a n

IZVORNA KODA

Izvirna koda 5.1: Deklaracija začetne scene. ..................................................................... 31

Izvorna koda 5.2: Ustvarjanje začetne scene. .................................................................... 32

Izvorna koda: 5.3 Določanje začetne scene. ...................................................................... 32

Izvorna koda 5.4: Zajemanje datotek SpriteSheet. ............................................................. 33

Izvorna koda 5.5: Dodajanje menija. ................................................................................... 33

Izvorna koda 5.6: Ustvarjanje menija. ................................................................................. 33

Izvorna koda: 5.7 Primer funkcije CC_CALLABACK. ......................................................... 34

Izvorna koda 5.8: Zamenjava scene. .................................................................................. 35

Izvorna koda 5.9: Ustvarjanje ponavljajoče teksture. ......................................................... 35

Izvorna koda 5.10: Definicija hitrosti gibanja ozadja. .......................................................... 36

Izvorna koda 5.11: Nalaganje datotek za eksplozijo. ......................................................... 37

Izvorna koda 5.12: Definicija začetne slike animacije. ....................................................... 38

Izvorna koda 5.13: Primer animacije eksplozije. ................................................................. 38

Izvorna koda 5.14: Ustvarajanje začetne in končne točke gibanja meteorjev. .................. 39

Izvorna koda 5.15: Pozicioniranje meteorjev in aktiviranje akcije. ..................................... 39

Izvorna koda 5.16: Animacija rotacije meteorjev. ............................................................... 39

Izvorna koda 5.17: Dodajanje akcije objektom. .................................................................. 39

Izvorna koda 5.18: Ustvarjanje gibanja nasprotnikov. ........................................................ 40

Izvorna koda: 5.19 Ustvarjanje bezierjeve funkcije. ........................................................... 41

Izvorna koda 5.20: Animacija gibanja po bezierjevi funkciji. .............................................. 41

Izvorna koda: 5.21 Lastnosti osnovnih elementov. ............................................................. 42

Izvorna koda 5.22: Skupni elementi igralca in nasprotnika. ............................................... 42

Izvorna koda 5.23: Ustvarjanje igralca. ............................................................................... 43

Izvorna koda 5.24: Dodajanje poslušalca dogodkov. ......................................................... 43

Izvorna koda 5.25: Igralčevo gibanje glede na dogodek. ................................................... 44

Izvorna koda 5.26: Ustvarjanje različnih vrst meteorjev. .................................................... 45

Izvorna koda 5.27: Razred Bullets. ..................................................................................... 45

Izvorna koda 5.28: Brisanje projektilov izven meja zaslona. .............................................. 46

Izvorna koda 5.29: Primer podrazreda bullets. ................................................................... 47

Izvorna koda 5.30: Razred GameLayer in njegove osnovne funkcije. ............................... 48


viii | S t r a n

Izvorna koda 5.31: Rezervacija mest za predmete. ........................................................... 49

Izvorna koda 5.32: Dodajanje različnih schedule funkcij. ................................................... 50

Izvorna koda 5.33: Pogostost pojavljanja meteorjev. ......................................................... 50

Izvorna koda 5.34: Definicija bitnih mask za zaznavo trka. ................................................ 52

Izvorna koda 5.35: Dodajanje fizičnega telesa nekemu objektu. ....................................... 52

Izvorna koda 5.36: Pridobivanje objektov, ki so trčili. ......................................................... 53

Izvorna koda 5.37: Zaznavanje trka. ................................................................................... 53

Izvorna koda 6.1: Vključitev/izključitev statusne vrstice. .................................................... 56

Izvorna koda 6.2: Uničevanje objektov. .............................................................................. 57


ix | S t r a n

Seznam kratic

2D – dvodimenzionalni prikaz

3D – trodimenzionalni prikaz

VR – virtualna resničnost (ang. Virtual reality)

FMV – video s polnim gibanjem (ang. Full Motion Video)

PC – osebni računalnik (ang. Personal Computer)

AI – umetna inteligenca (ang. Artificial intelligence)

AAA – videoigre z visokim budžetom in veliko promocijo

TTF – vektorski format pisave (ang. True Type Format)

BMFont – rastrski format pisave

SDK – komplet za razvoj aplikacij (ang. Software Development Kit)

MMO – masivna igra za več spletnih igralcev (ang. Massive Multiplayer online)

OpenGL – javna grafična knjižnica

FPS – število slik (okvirjev) na sekundo (ang. Frames Per Seconds)

API – aplikacijski programski vmesnik (ang. Application Programming Interface)


1 | S t r a n

1 UVOD

Igre so v naših življenjih vedno prisotnejše. Danes obstajajo celo prava športna

tekmovanja v igrah. Nekoč so pojem igre povezovali z igralno konzolo, vendar danes,

zahvaljujoč tehnološkemu razvoju, igre obstajajo na skoraj vseh napravah. Znano je, da

so se prav zaradi potreb iger razvile nove tehnologije virtualne resničnosti (VR). S

pojavom igre na več napravah se je povečala tudi njena priljubljenost. Razvoj iger ni

enostaven in zahteva veliko znanja ter časa. Igre lahko razvijajo tako posamezniki kot tudi

razvojni studii – med najbolj znanima sta Ubisoft in Blizzard, za mobilne platforme pa so

spletne trgovine Windows Phone Apps, Google Play in Apple Store.

Vseobsežna prisotnost iger na raznih napravah in platformah je prinesla poleg vse večje

priljubljenosti tudi določene težave razvojnim ekipam – vse želijo pokriti čim večji del trga,

ker pa je razvijanje iger dolgotrajen in drag proces, je razvijanje igre za posamične

platforme in različne naprave nedobičkonosno. Tehnologija, ki razvojnim ekipam pomaga

pri razvoju, je igralni pogon. Slednji omogoča lažji, cenejši in hitrejši razvoj. Ravno tako

nekateri igralni pogoni omogočajo razvoj iger za več platform hkrati.

1.1 Cilj diplomskega dela

Cilj diplomskega dela je razviti igro za več platform. Pravilna izbira igralnega pogona, ki

nam to lahko omogoči, je zato ena izmed najpomembnejših nalog diplomskega dela.

Preučili bomo temeljne zmogljivosti igralnega pogona in se seznanili z njegovim osnovnim

delovanjem. Spoznali bomo samo zamisel igre in preučili njen strukturni razvoj ter

implementacijo.

1.2 Struktura diplomskega dela

Najprej bomo predstavili kratko zgodovino razvoja iger. Omenili bomo prve pomembne

igre, ki so vplivale na industrijo iger. Na kratko bomo preučili prve naprave, na katerih so

se igre izvajale, in omenili posameznike, ki so največ prispevali k razvoju industrije iger.


2 | S t r a n

Potem se bomo osredotočili na platforme, na katerih se igre izvajajo danes. Vsako bomo

na kratko opisali oz. povedali, kaj predstavlja in kakšne značilnosti ima. Zatem bomo

predstavili razvoj računalniških in mobilnih iger. Preučili bomo, kdaj in zakaj so se pričele

računalniške igre razvijati tako hitro. Ravno tako bomo omenili, kaj je pomembno za

mobilne igre in njihovo igralno platformo.

V nadaljevanju bomo preučili igralni pogon. Predstavili bomo, kaj vse natančno predstavlja

in katera je njegova osnovna naloga. Opisali bomo nekatere od pomembnejših lastnosti

igralnega pogona in za vsako navedli, kaj predstavlja in čemu je namenjena.

Zatem bomo predstavili razvoj igre. Opisali bomo, na kaj je treba paziti pri razvoju igre in

katere cilje si je treba zastaviti za uspešno napredovanje. Opisali bomo različne skup ine,

ki razvijajo igre, in navedli najizrazitejše razlike med njimi. Pojasnili bomo, kaj pomeni

najosnovnejši sprejemljivi produkt (NSP) in za kaj ga potrebujemo. Pojasnili bomo tudi,

zakaj je zasnova igre tako zelo pomembna. Preučili bomo tehnike, ki omogočajo, da

pridemo do boljših zamisli. Pregledali bomo različne funkcionalnosti igre in opisali, zakaj

moramo biti nanje pozorni. Pozneje bomo raziskali igralni pogon in pojasnili, zakaj je tako

zelo pomemben pri samem razvoju igre. Po izbiri igralnega pogona bomo na hitro pojasnili

njegovo zgodovino in poglavitne funkcionalnosti. Za razvoj igre je potrebna tudi dodatna

programska oprema, zato bomo opisali vse aplikacije, ki smo jih uporabili pri delu.

Temu sledi praktični del diplomskega dela, sestavljen iz nekaj osnovnih delov, v katerih

bomo pojasnili, kako in zakaj smo se lotili pričujočega dela.

Po sami implementaciji igre bomo tudi preizkusili njeno delovanje. V tem delu bomo

opisali osnovne načine preizkušanja igre in zakaj so ti nujno potrebni. Preučili bomo, zakaj

imajo danes nekatere igre daljše življenjsko dobo od drugih in na kakšen način se to

doseže. Našteli bomo različne načine za izboljšavo naše igre. Razvoj iger prinaša tudi

določene težave, zato bomo omenili, na katere težave smo naleteli in kako smo jih uspeli

premostiti. Po zaključeni izvedbi igre za eno platformo bomo opisali postopek izvoza igre

na druge platforme.


3 | S t r a n

2 RAZVOJ IGRE

Na začetku so igre razvijali v znanstvenih laboratorijih in jih niso predstavili občinstvu, saj

je bila oprema, na kateri so se izvajale, predraga in pretežka. Nekatere med prvimi

razvitimi igrami so: OXO (Tic-Tac-Toe), Tennis for Two in Spacewar [1] [2]. Cena strojev,

na katerih so se igrale, je bila izredno visoka. Ralph Baer je prišel do zamisli, da bi igre

igrali na televiziji, in tako je začel sestavljati svoj prvi prototip. Z izumom konsole

Magnayox Odyssey so se odprla vrata igranju iger prek televizije. Zaradi tega izuma prav

njega smatramo za očeta videoiger. Nolan Bushell in Ted Dabney, ki sta ustanovila

podjetje Atari, pa sta ravno tako ustvarjalca igre Pong [3]. To je prva komercialno uspešna

videoigra, že leta 1974 pa so objavili tudi hišno različico igre Pong [3]. Velika uspešnost te

igre je prepričala mnogo drugih podjetij za razvoj svoje različice igre Pong. Tako se je

začela industrija iger vse bolj razvijati [4] [1].

Ključnega pomena za večji razvoj industrije iger je bila nizka cena strojne opreme [1].

Razvijalci igre so pričeli z lastnim eksperimentiranjem vektorskih prikazov, ki pa so

ustvarjali zelo ostre linije. Nekatere igre so vsebovale tehnologijo Asteroids, Battlezone,

Tempest, Star Trek (Sega), vendar ta tehnologija ni zaživela zaradi dragih popravil

vektorskih prikazov. V istem obdobju so se pojavili tudi eksperimenti, kot so psevdo-3D,

stereoskopski 3D, FMV-igre. Nintendo je leta 1979 predstavil perspektivo tretje osebe z

igro RadarScope. Industrija iger je imela velik vpliv na avdio-digitalno tehnologijo. Space

Invaders pa je prva igra, ki je v ozadju neprekinjeno uporabljala glasbo.

2.1 Platforme

Pričele so se pojavljati tudi različne platforme za videoigre. Pojem platforma se nanaša na

določeno kombinacijo elektronskih komponent, ki skupaj s svojo programsko opremo

omogoča delovanje videoigre [2].

PC-platforma se nanaša na medij, ki igralcu omogoča komunikacijo z osebnim

računalnikom in monitorjem. Osebni računalniki niso namenske igralne platforme, tako da

se lahko pojavijo razlike pri igranju iste igre na različni programski opremi [2].


4 | S t r a n

Konzola je specializirana elektronska oprema, ki jo povežemo na televizijo ali monitor. To

je prilagojena platforma za videoigre, ki jo proizvaja določeno podjetje. Za konzolo se

posebej razvijajo igre, ki običajno vključujejo igralno palico. Danes so najbolj znani

proizvajalci konzol Microsoft, Sony in Nintendo. Novejše konzole omogočajo gledanje

filmov in poslušanje glasbe [2].

Arkadna platforma [5] se nanaša na vse igre, ki se igrajo na določenem tipu elektronske

naprave. Posamezna naprava je zasnovana za igranje izključno ene igre in vgrajena v

posebno veliko omarico z blagajno, vgrajeno pa ima tudi konzolo, igralno palico, zaslon in

zvočnike. Arkadna platforma je del zlate dobe industrije iger. V zadnjem času je vse težje

najti arkadno platformo, saj jo je sodobna tehnologija postavila globoko v ozadje, še

vedno pa se nahajajo v nekaterih kinih in gledališčih, tiste najstarejše pa celo v muzejih

kot razstavni primerki začetka industrije iger.

SLIKA 2.1 ARKADNA PLATFORMA IGRE SPACE INVADERS.

Internetni brskalnik je z razvojem spletne tehnologije postal samostojna platforma.

Omogoča igranje iger, ki so oblikovane za široko paleto strojne opreme in ustrezajo tako

osebnim računalnikom kot pametnim telefonom in tablicam [2].

Mobilna platforma je s pojavom operacijskih sistemov Android in iOS ter z vse večjim

razvojem mobilne tehnologije, postala eden izmed najpomembnejših elementov v industriji

iger. Posledično so se z uporabo mobilnega fotoaparata, GPS-a in drugih mobilnih

tehnologij pojavili novi igralni mehanizmi. K razvoju mobilne tehnologije veliko prispevajo


5 | S t r a n

tudi spletne trgovine, ki ponujajo igre za mobilne platforme. Vse več iger na mobilnih

napravah je brezplačnih, vendar so znotraj igre možne mikrotransakcije, ki omogočajo

zaslužek.

Virtualna resničnost je najnovejša igralna platforma. Čeprav njeni začetki segajo v

prejšnje stoletje, je večjo priljubljenost in razvoj dosegla šele v zadnjih dveh letih s

pojavom naprave Oculus Rift, ki so mu sledili Sony, HTC, Google in Samsung. Platforma

po navadi zahteva, da igralec uporablja posebno enoto na glavi, ki omogoča

stereoskopske zaslone in spremljanje gibanja, ter tako igralca potisne v virtualno okolje.

Nekatere naprave vključujejo tudi dodatne igralne palice, da bi se interakcija z virtualnim

svetom še povečala. VR-naprave po navadi potrebujejo močno strojno opremo v ozadju,

kot so osebni računalnik, konzola ali neka druga naprava za obdelovanje podatkov [2].

SLIKA 2.2 OCULUS RIFT PLATFORMA ZA VIRTUALNO RESNIČNOST.

2.2 Računalniške igre

Računalniške igre so bile prve razvite igre. Najbolj znane med njimi so OXO, EDSAC in

Spacewar. Vse te igre so bile dostopne na velikih in zelo dragih strojih (računalnikih) in

niso bile na voljo širšemu občinstvu. Na začetku so bile računalniške igre tekstualno-

interaktivne oblike, kjer je igralec vnašal ali izbiral ukaze s pomočjo tipkovnice. Z razvojem

računalniške moči in znižanjem cene procesorjev so postali osebni računalniki del

vsakega doma. Atari 400 in Texas Instruments TI-99/4A sta računalnika, na katerih so se

lahko izvajali prvi kloni arkadne platforme. Trg je kmalu postal prenasičen s slabimi


6 | S t r a n

videoigrami za konzole in to je leta 1983 privedlo do odmevnega zloma videoiger. Takrat

je prišlo do preobrata in priljubljenost računalniških iger se je povečala. S pojavom

barvnega računalnika Commodore 64 po dostopni ceni se je povečala vrednost razvojnih

skupin, ki so se ukvarjale z računalniškimi platformami. IBM-ov produkt IBM Personal

Computer (PC), objavljen leta 1981, je znani računalniški časopis BYTE opisal kot odlično

igralno platformo. Ena izmed največjih prednosti računalniške platforme je njena

uporabnost, saj ni namenjena le eni določeni nalogi, temveč se lahko uporablja za

različna opravila – denimo za gledanje filmov ali programiranje [1] [4] [2].

2.3 Mobilne igre

Čeprav so igre na mobilnih napravah obstajale že od samih začetkov, je do njihove večje

priljubljenosti prišlo šele s pojavom operacijskih sistemov za mobilne naprave, kot so

Android, Windows Phone in iOS. Prva med najbolj znanimi igrami se je imenovala Tetris

in se je izvajala na napravi Hagenuk MT-2000 iz leta 1994. Leta 1997 je Nokia predstavila

izredno uspešno igro Snake, katere zasnova je prevzeta iz arkadne igre Blockade. Snake

je bila že vnaprej vgrajena na mobilnih napravah in je tako postala ena izmed najbolj

igranih videoiger. Danes lahko večino iger naložimo prek mobilne trgovine. Z razvojem

mobilnih procesorjev, zaslonov visoke ločljivosti in povečane zmogljivosti baterije se

mobilne igre razvijajo izjemno hitro. Večina mobilnih iger po navadi zavzame zelo malo

prostora in so enostavne v primerjavi z igrami drugih platform. Mobilne igre so omogočile

tudi nove možnosti za ustvarjanje dobička. Eden izmed najbolj znanih poslovnih modelov

se imenuje freemium. Samo nalaganje iger je večinoma brezplačno, dobiček pa se ustvari

s pomočjo manjših nakazil znotraj same igre.


7 | S t r a n

3 IGRALNI POGON

Igralni pogon je programska oprema, zasnovana kot pripomoček pri ustvarjanju in izdelavi

videoiger. Namesto da sami implementiramo funkcije, igralni pogon že vsebuje skupek

osnovnih in naprednih funkcij, ki se najpogosteje uporabljajo pri razvoju. Tako se skrajša

čas razvoja videoiger, saj se razvijalci lahko osredotočijo na ostale naloge, ki so

pomembne za razvoj, osnovne funkcije pa prepustijo igralnemu pogonu. Osnovne

zmogljivosti, ki jih ima vsak igralni pogon, so grafika, zvok in logika. Glede na to, da

postajajo igre vedno naprednejše in zahtevnejše, se vzporedno razvijajo tudi naprednejši

igralni pogoni, ki vsebujejo poleg osnovnih funkcionalnosti tudi zahtevne funkcije, kot so

fizika, umetna inteligenca, povezava z internetnimi omrežji, optimizacija, osvetlitev in

mnoge druge. Igralni pogoni po navadi nudijo tudi platformsko neodvisnost. To pomeni, da

se lahko igra izvaja na različnih platformah z malo ali brez kakršnih koli sprememb v

izvorni kodi igre.

3.1 Osnove dela z igralnim pogonom

Igralni pogon [6] omogoča dostop do funkcij, ki se uporabljajo za ustvarjanje igre. Ponuja

številna orodja, ki se uporabljajo za razvoj igre in so na voljo v integriranem razvojnem

okolju, da bi omogočila poenostavljen in lažji razvoj iger. Igralni pogoni omogočajo

prilagodljivo in večkratno platformo, ki ponuja vse ključne zmogljivosti, pripravljene že

vnaprej, za razvoj nove igre, in sicer z omogočanjem zmanjšanja stroškov, zahtevnosti,

vloženega časa in olajšanja vseh ostalih ključnih dejavnikov pri razvijanju videoiger.

3.2 Funkcionalnosti igralnega pogona

Osnovne in poglavitne funkcionalnosti, ki jih omogoča igralni pogon, so risanje grafike,

fizika, odkrivanje trkov, zvok, skriptiranje, animiranje, umetna inteligenca, omreženje iger,

upravljanje s spominom, lokalizacija, video podpora in mnogo več. Z uporabo igralnega

pogona privarčujemo tako s časom kot z drugimi viri, potrebnimi za razvoj igre.


8 | S t r a n

SLIKA 3.1 FUNKCIONALNOSTI IGRALNEGA POGONA.

Pogon za upodabljanje (Rendering engine) je odgovoren za prevzemanje kode od

programerjev in prevod te kode v predmete znotraj same igre. Pogon za upodabljanje

projektira ta objekt kot sliko na našem zaslonu, odvisno od lastnosti objekta pa objektu

določi mehko ali trdno teksturo, barvo, obliko in velikost. Pogoni za upodabljanje postajajo

vse naprednejši in igre postajajo posledično vedno resničnejše in verodostojnejše.

Sodobni pogoni za upodabljanje nadzirajo tudi osvetlitev iger. Osvetlitev simulira odbijanje

svetlobe od objektov in tako ustvari sence. Osvetlitev se računa približno, saj je takšen

način veliko hitrejši. Če bi želeli izračunati točno odbijanje svetlobe od objektov, bi morali

izkoristiti veliko procesorske moči, ker je ta postopek zelo zahteven.

Fizikalni pogon (Physics engine) nam pove, kako objekti medsebojno komunicirajo.

Odgovoren je izključno za simulacijo določenega fizičnega sistema, kot so dinamika

trdnega telesa, dinamika tekočin in dinamika mehkih teles. Vpliv fizike lahko vidimo na

različnih primerih, kot so avtomobilska nesreča, uničenje okolice, zaustavitev glavnih

likov, padanje papirja, plavanje v vodi in drugi.

Umetna inteligenca (Artificial Intelligence) oponaša človeško inteligenco v liku, ki ga ne

nadzira igralec igre. Slednje vključuje hojo, skrivanje v zaklonišču, ciljanje sovražnika,

prisotnost na tekmovalni stezi in interakcijo z drugimi liki. Brez umetne inteligence bi ti liki

samo stali oz. bili statični brez kakršnega koli gibanja. V igrah obstaja več vrst umetne

inteligence – nekatere so zelo enostavne, kot je na primer hoja od točke A do točke B,


9 | S t r a n

druge so lahko veliko zahtevnejše in potrebujejo več parametrov in se prilagajajo vsem

dejanjem igralca.

Zvok (Sound) je v igrah zelo pomemben. Mnogi igralni pogoni imajo že vgrajene funkcije

za delo z zvokom. Funkcije, ki nam jih omogoča igralni pogon, nam olajšajo delo z

zvočnimi datotekami in učinki. Obdelavo zvoka se izvaja izven igralnega pogona, nato pa

zvok uvozimo v projekt. Različni igralni pogoni imajo različne funkcije za nadzor zvočnih

učinkov. Nekateri igralni pogoni omogočajo 3D-učinek zvoka, tako da lahko med igranjem

igre slišimo, s katere strani prihaja zvok v virtualnem okolju.

Omrežje (Networking) nam omogoča funkcionalnost povezave igranja iger znotraj

omrežja ali prek spleta. Dva oz. več igralcev deli isto izkušnjo prek omrežja, kot da zares

obstajajo v virtualnem svetu. Funkcionalnost, ki nam jo omogoča omrežje, se odraža v

različnih vrstah povezav med več igralci. Nekatere med najbolj znanimi so Peer-to-Peer,

Lockstep, Client/Server, Client-Side Prediction.

Upravljanje s kontrolniki (Controlling managment) pomeni funkcionalnosti, vgrajene v

igralni pogon, ki nam ponujajo različne rešitve pri upravljanju igre. Nekateri igralni pogoni,

ki so namenjeni razvoju na več platformah, ponujajo več možnosti, ker se razvijajo za

večplatformsko uporabo. Igro lahko upravljamo s pomočjo tipkovnice, miške, kontrolnika,

zaslona na dotik, gibov, glasu in številnih drugih tehnik.

Uporabniški vmesnik (User interface) tvorijo vizualni deli igre, ki igralcu pokažejo

njegovo stanje. Meni je samo en del uporabniškega vmesnika, v katerem igralec izbira

možnosti in ostale nastavitve. Ti deli se po navadi prikažejo ločeno, torej izven virtualnega

sveta. Večina sodobnih igralnih pogonov ima že vnaprej določene menije in uporabniške

vmesnike.


10 | S t r a n

4 RAZVOJ IGRE

Prvo pravilo vsakega začetnika razvojnega programerja je, da svojo prvo igro naredi

preprosto, po angleško bi rekli ''Make it simple''. Številni začetni razvijalci iger si izberejo

prezahtevno nalogo, ki je ne morejo dokončati. Posledično se jim zaradi prezahtevne

naloge pojavi nelagodni občutek, da so obtičali in da ne morejo niti naprej niti nazaj.

Takšni projekti so pogosto nedokončani in opuščeni. Zato je pomembno, da so prve igre

enostavne, saj se z vsakim zaključenim projektom znanje o razvoju iger povečuje. Več kot

imamo znanja, zahtevnejšo igro lahko ustvarimo.

Na razvoju igre lahko dela velika skupina programerjev ali pa tudi zelo majhno število

strokovnjakov. Na nekaterih večjih AAA naslovih, kot so Call of Duty, Borderlands in FIFA,

dela več kot 100 ljudi in razvoj igre lahko traja tudi več let. Vsak posameznik znotraj

skupine je zadolžen za določeno področje. Tako v takšnih projektih obstajajo ekipe za

oblikovanje, programiranje, animacijo, marketing, zvok, oblikovanje nivojev itd. Na drugi

strani pa je vedno več znanih samostojnih studijev, ki se imenujejo Inde studiji. Tu dela

manj ljudi, posamezniki pa lahko opravljajo več nalog hkrati. Tako so lahko razvijalci tudi

oblikovalci, drugi člani pa skrbijo za marketing in zvok v igri. Medtem ko imajo AAA studiji

na razpolago budžet, ki lahko presega tudi 10 milijonov ameriških dolarjev, se Inde studiji

običajno financirajo sami in so tako finančno precej omejeni.

Ko izberemo skupino ljudi ali pa se sami odpravimo v pustolovščino razvoja videoigre, se

začne prvo delo. Nenapisano pravilo, katerega bi se morali držati vsi začetniki razvoja

videoiger, je ''Start small and be ready to fail'' ali slovensko ''Začnite enostavno in bodite

pripravljeni na neuspeh''. Najprej moramo imeti v mislih velikost igre. Kajti če začnemo z

velikim projektom, ne bomo vedeli, kje sploh začeti. Obremenjevali se bomo z ma jhnimi

stvarmi, ki ne prinašajo vidnih rezultatov in videti bo, kot da ne napredujemo. Zato je

pomembno še enkrat ponoviti pravilo ''Make it simple''. Druga stvar, na katero moramo biti

kot začetniki nadvse pozorni, je sama zamisel igre. Prva igra ne sme biti zgrajena okoli

neke določene zamisli, ampak se moramo naučiti delati s programom in okoli tega zgraditi

igro. Del razumevanja obsega igre predstavljajo sredstva in v tem primeru je naše znanje

razpoložljivo sredstvo. Če smo zelo dobri umetniki, pa nismo nikoli napisali kode, se


11 | S t r a n

moramo tudi igri v večjem delu posvetiti z umetniškega vidika, ne pa zapravljati čas s

kodiranjem. Ravno tako velja, da če smo slabši v oblikovanju ali animaciji, se je bolje

posvetiti področjem, ki jih obvladamo. Obstajajo igre, ki so zasnovane na minimalni grafiki;

na začetku moramo to nesorazmerje sprejeti kot del našega oblikovanja. Omejevanje nas

prisili, da smo veliko bolj domiselni in ravno domiselnost je najpomembnejša stvar pri

razvoju videoigre.

Preden končamo projekt, se moramo zavedati, da prva igra ne bo takšna, kot smo si

zamislili, ravno tako kot ni bila naša prva risba videti kot umetniško delo. Naučiti se

moramo, kako oblikovati in razvijati igro, za kar je potrebno veliko časa in dela. V razvoju

obstaja termin najosnovnejši sprejemljiv produkt (NSP). Ta produkt ima dovolj lastnosti,

da zadovolji prve kupce, hkrati pa podaja pomembne povratne podatke za nadaljnji razvoj.

Ta proizvod bi moral vsebovati del naše zamisli z glavnimi mehanizmi, zato je nujno

določiti najmanjši nabor skupnih značilnosti, ki ne bodo vplivale na sam razvoj igre. Če

lahko eno izmed teh lastnosti odstranimo in je produkt še vedno uporaben, to pomeni, da

ta lastnost ni del najosnovnejšega sprejemljivega produkta. Za primer lahko vzamemo igro

Super Mario, iz katere lahko odstranimo skoraj vse elemente, kot so želve, goreče rože,

cevi in vodni nivoji. Za to igro je najosnovnejši sprejemljiv produkt en nivo, kjer lik hodi,

skače in pada v luknje, ki se nahajajo na poti. Vse ostale lastnosti lahko dodamo kasneje,

toda če manjka eden izmed osnovnih elementov, igra enostavno ne bo delovala, saj bo

brez glavnega mehanizma.

SLIKA 4.1 PRIMER NAJOSNOVNEJŠEGA SPREJEMLJIVEGA PRODUKTA.

Nasveti za začetne razvijalce videoiger:

– Ne načrtujte projekta, ki bo trajal dlje kot en mesec.


12 | S t r a n

– Projekt bo verjetno trajal dlje kot en mesec, toda ne skrbite, saj so presenečenja

del razvoja iger.

– Ne posvečajte preveč časa dizajnu igre in ne zapravljajte denarja za oblikovanje in

mehanizme, za katere niste prepričani, da jih boste lahko uporabili.

Najpomembnejše je narediti igro karseda hitro. Na začetku je mnogo

pomembnejša izkušnja kot pa končni rezultat.

– Določite si tedenske cilje.

– Cilje razbijte na manjše naloge.

– Zapisujte si delo, ki ste ga opravili prejšnji teden, in tudi naloge, ki jih imate v

načrtu naslednji teden, ter na koncu tedna zapiske primerjajte.

– Igro preverite vsaj enkrat tedensko.

– Ne skrbite o proizvodni vrednosti. Če prva igra ni videti ali ne zveni dobro, se ne

obremenjujte. Če se bo igra dobro obnesla, boste pozneje imeli čas za izboljšave.

Obstaja veliko iger, ki so sestavljene samo iz osnovnih elementov, kot sta kvadrat

in krog, takšni igri sta recimo Ping-Pong ter Križec in krogec.

– Ne izgubljajte več kot eno uro na posamezni težavi, ki jo poskušate rešiti. Verjetno

obstaja veliko nasvetov ali forumov, ki vam lahko pomagajo. Uporabite te vire

podatkov.

– Igro naj poskuša igrati kar največje število ljudi.

Nasvet za nove razvijalce iger je ta, da ne izberejo prevelikega obsega igre in da si

vzamejo čas za razvoj načrta igre po fazah. Tako razdeljeno delo zelo olajša cel proces. V

začetnih fazah razvoja imamo več svobode, lahko smo bolj domiselni, medtem ko je

pozneje pot že začrtana, razvoj igre poteka in je vsaka sprememba nižjih faz igre že lahko

fatalna. Potem ko določimo začetne faze igre, je smiselno narediti seznam dodatnih stvari,

ki jih bomo igri kasneje dodali, da bo izgledala celovito. Po navadi se tukaj posvetimo

dodatni grafiki, animaciji, zvočnim učinkom, napredni osvetljavi, napredni umetni

inteligenci in ostalim stvarem. Zadnji seznam, ki ga je dobro imeti, naj vsebuje dodatke.

To je seznam dodatnih lastnosti, ki jih želimo dodati igri in lahko počakajo do konca

razvoja ali pa jih lahko celo preskočimo, če nam zmanjka časa.

Izdelava prve igre je pomemben korak v karieri razvijalcev. Če je obseg igre znotraj

razumnih meja, njena zahtevnost v okvirjih naše sposobnosti, finančna pričakovanja pa so

realistična, potem ni razloga, da igre ne bi dokončali.


13 | S t r a n

4.1 Ideja igre

Najpomembnejši koncept igre je njena ideja [7]. Ta se prične v naših mislih in nekako jo je

treba izraziti. Navdih za zamisli dobimo iz raznih drugih primerov, nato različne koncepte

kombiniramo iz več primerov v eno in edinstveno idejo. Slednja se lahko porodi kadar koli,

zato moramo biti vedno pripravljeni, da si jo zapišemo ali zapomnimo. Še en način, kako

lahko dodelamo svoje ideje, je, da ustvarjamo igre. Dobra ideja in dobra igra ne bosta

prišli kar sami od sebe. Potrebnih je veliko poizkusov in neuspehov, da končno dobimo

dobro idejo oziroma igro.

Tehnike pridobivanja boljše zamisli so:

– pretok zamisli;

– miselna karta;

– reševanje težav;

– metaforično razmišljanje;

– uporaba različnih oblik medijev;

– asociacije;

– sprememba načina razmišljanja ali lokacije;

– sodelovanje in

– eksperimentiranje.

Velikokrat se nam zgodi, da dobimo več zamisli naenkrat. Vse te zamisli je treba zapisati

in narediti seznam. Na hitro jih preučimo in izberemo od pet do deset najboljših. Slednje

znova preučimo, toda tokrat temeljitejše, in zopet izberemo najboljšo idejo. S pomočjo

takšnega postopka zmanjšamo možnost, da se bomo takoj osredotočili na le eno zamisel,

temveč preučimo vse in šele nato izberemo najboljšo.

Ko je ideja enkrat izbrana, jo je treba podrobno razjasniti. Določiti je treba osnovni

mehaniko igre in ta bo potem jedro igre. Vsi preostali elementi se bodo gradili glede na to

jedro. Najbolje je narediti seznam funkcionalnosti, tako bo mnogo lažje odstraniti tiste

funkcionalnosti, ki zaradi zahtevnosti ali pomanjkljivosti ne sodijo v projekt.

Nadalje je treba določiti videz igre oz. ali bo naše delo potekalo v 2D- ali v 3D-grafiki,

kakšen bo naš dizajn igre – bomo stremeli k realnemu ali bo to popolnoma poseben

dizajn? Treba je sprejeti odločitev, ali bomo ustvarjali sami ali bomo delali po že

narejenem primeru. Odločiti se moramo, ali bomo uporabili napredne zmožnosti, ki jih

omogočajo razni pogoni, ali se bomo raje osredotočili na osnovne. Prav tako je treba


14 | S t r a n

določiti, na kakšen način bomo upravljali z igro; če je namenjena uporabi več platform, je

treba za vsako določiti način upravljanja. Te funkcionalnosti je treba nadalje

implementirati. Nedvomno je treba veliko pozornosti nameniti tudi zvoku. Marsikateri

ustvarjalec v igri zanemari zvok, saj se ne zaveda, kakšen učinek ima na končno kakovost

igre. Treba je vedeti, ali bomo uporabili lastne zvočne učinke ali že narejene. Ena izmed

pomembnejših postavk je tudi izbira programskega jezika, v katerem želimo razvijati.

Najbolje je izbrati tisti jezik, ki ga najbolj obvladamo in s katerim imamo največ izkušenj.

Ravno tako upoštevajmo, da uporabljajo nekatere igre poslovne modele, zato jih je

pomembno že vnaprej določiti. Nekatere igre so financirane z nakupom, druge s pomočjo

mikrotransakcij na dodatkih v igrah, tretje z naročnino. Ključno je tudi določiti tudi dodatno

programsko opremo za razvoj igre. To vse so nujna vprašanja, katerim moramo nameniti

svojo pozornost med razvijanjem igre.

4.2 Izbira igralnega pogona

V današnjem času imamo na voljo veliko izbiro igralnih pogonov. Ne obstaja en igralni

pogon, ki bi bil dober za vse naloge, so pa nekateri primernejši za določene. To pomeni,

da je vsak igralni pogon dober za neko področje. Da bi izbrali pravi igralni pogon, je treba

najprej idejo dodelati in natančno vedeti, kaj bomo razvijali. Ko zamisel dodelamo, se nam

bodo razkrila vsa potrebna merila, s pomočjo katerih bomo lažje izbrali primerni igralni

pogon. Treba je poznati funkcionalnosti, ki nam bodo največ pripomogle pri delu.

Priporočljivo je preizkusiti več pogonov, da bi ugotovili, s katerim najlažje ustvarimo

določeno nalogo. Izdelava prototipa je zelo pomembna, saj s tem najlažje preverimo

prednosti in pomanjkljivosti vsakega igralnega pogona. Pomemben dejavnik pri izbiri

igralnega pogona je znanje programskega jezika. Najbolje je izbrati programski jezik, ki ga

najbolj obvladamo. Danes obstajajo igralni pogoni, za katere je potrebno minimalno

znanje iz programiranja, a so omejeni s funkcionalnostmi. Obstaja možnost izdelave

lastnega igralnega pogona, vendar je za to potrebno zelo dobro poznavanje

programiranja. Sama izdelava lastnega igralnega pogona lahko zahteva veliko več časa

kot celotni razvoj igre v nekem že obstoječem igralnem pogonu. Prednost izdelave

lastnega igralnega pogona je prilagodljivost zahtevam, ki so nam najpomembnejše. Za

začetnike je vsekakor najbolje, da uporabijo že obstoječe igralne pogone, saj je veliko

lažje sestaviti igro kot igralni pogon [8] [6].


15 | S t r a n

Lastnosti, ki nam pomagajo pri izbiri igralnega pogona, so:

Funkcionalnost: moramo se povprašati, katero funkcionalnost bomo uporabljali – ali

potrebujemo zahtevno programsko opremo ali nam je dovolj samo osnovna, v kateri se

bomo lažje znašli; ali je igralni pogon na voljo z menijem, 3D-možnostmi oblikovanja in

napredno fiziko itd.

Izvedba: treba je vedeti, ali bo igra, narejena s tem igralnim pogonom, zahtevna. Nekateri

igralni pogoni so optimizirani za srednje velike igre, ne pa za spletne ali mobilne naprave.

Vprašati se je treba, ali igralni pogon potrebuje veliko sredstev.

Prenos igre: dandanes je možnost prenosa igre na več platform ključna za igralne

pogone. Ugotoviti je treba, katere platforme igralni pogon omogoča, kakšna je cena

prenosa igre na druge platforme, kakšno zahtevnost igre prenese in ali obstajajo kakšne

omejitve za prenos igre na različne platforme.

Ergonomski vidik: pozanimati se je treba, ali je enostavneje pisati in brati kodo v

igralnem pogonu, ali so spletne strani in priročniki dobro strukturirani ter ali je igralni

pogon oblikovan za večje skupine ali za enega uporabnika.

Posodabljanje: pomembno je, da se igralni pogon redno posodablja, hkrati pa moramo

vedeti, ali so napake popravljene in posodobitve uspešne. Potrebujemo podroben seznam

vsake posodobitve, seznam prihajajočih sprememb in dodatnih funkcionalnosti ter in

njihov čas prihoda.

Skupnost je pomemben del vsakega igralnega pogona. V okviru te se pojavijo številna

vprašanja, npr. koliko je aktivnih uporabnikov, ali je to prijateljska skupnost ali je bolj

zaprte narave, ali so znotraj skupnosti začetniki ali profesionalci v razvoju iger itd. Velika

skupnost nam lahko priskoči na pomoč, ko se soočamo s težavami pri razvoju igralnega

pogona. S pravimi vprašanji na njihovih forumih lahko pridemo do enostavne rešitve.

Cena: treba je vedeti, koliko nas bo igralni pogon stal oz. ali imamo sredstva, da si

privoščimo plačljiv igralni pogon (če je predrag, se pozanimajmo za cenejše možnosti).

Izbrskati je treba, kakšen način plačila ima – z mesečnimi obroki ali enkratnim plačilom.

S preučevanjem vseh teh dejavnikov se lahko lažje odločimo pri izbiri igralnega pogona.

Treba je preizkusiti in preveriti njihove zmožnosti, saj lahko tako dobimo boljši občutek

glede tega, kaj nam igralni pogon sploh omogoča, kakšna je njegova enostavnost oziroma

zahtevnost in ali presega naše potrebe. Videli bomo, s kakšno enostavnostjo lahko


16 | S t r a n

naredimo prototip igre, kakšna je njegova dostopnost in ali ima kakšne dodatne začetne

pakete, ki nam lahko olajšajo zahtevnost razvoja igre.

4.2.1 Igralni pogon Cocos2d-x

Cocos2d-x je večplatformski igralni pogon. Ima odprto kodo, je zastonj in namenjen

razvoju 2D-iger, interaktivnih knjig, mobilnih aplikacij in ostalih grafičnih aplikacij. Temelji

na Cocos2d-iphone, le da namesto jezika Objective-C uporablja C++. Poleg tega jezika

podpira tudi jezika Lua in Javascript. Programerji lahko s pomočjo znanja iz C++, Lue in

Javascripta vnesejo aplikacije za več platform, kot so iOS, Android, Windws Phone, Mac

OS X, Windows Desktop in Linux. Na takšen način privarčujemo veliko denarja in časa.

Cocos2d-x je hiter, enostaven za uporabo in ima mnoge druge zmogljivosti. Je primarno

igralni pogon in nam omogoča poenostavljeni aplikacijski vmesnik (API) za razvoj mobilnih

in namiznih iger. Uporabljajo ga tako posamezniki in navdušenci kot tudi večja podjetja, ki

se ukvarjajo z razvojem iger. Razne aplikacije, narejene v Cocos2d-x pogonu, se nahajajo

v Apple in Google Play trgovini. Najbolj je razširjen po državah Azije, čeprav ga vse bolj

srečujemo tudi drugod po svetu. Nekatera znana podjetja, ki ga ravno tako uporabljajo,

so: Zynga, Wooga, IGG, Big Fish Games, Konami, Disney Mobile in mnoga druga.

SLIKA 4.2: STRUKTURA IGRALNEGA POGONA COCOS2D-X. VIR: [9]


17 | S t r a n

Zgodovina

Prvotno ime igralnega pogona Cocos2d-x je bilo Los Cocos. Razvil ga je Argentinec

Ricardo Quesada s svojimi prijatelji v mestu Los Cocos, blizu Cordobe. Mesec dni po

izdelavi prvega izdelka so objavili javno različico igralnega pogona 0.1 in ga poimenovali

Cocos2d.

Po ustanovitvi trgovine App je Apple objavil svoj prvi komplet za razvoj programske

opreme. Ricardo Quesada je na začetku napisal igralni pogon v Objective-C jeziku in ga

objavil pod imenom Cocos2d for iPhone v0.1. Mnogim programerjem je bila všeč

raznolikost aplikacij in iger na platformi iOS in tako se je začela širiti Cocos2d skupnost, ki

se še vedno povečuje.

Prva različica Cocos2d-x-a se je pojavila novembra 2010. Programer s Kitajske, Zhe

Wang, je nadgradil starejšo različico Cocos2d v Cocos2d-x. Cocos2d-x je prav tako

dostopen z odprto kodo pod licenco MIT-a, omogoča nam shranjevanje, gibanje in

premikanje aplikacije na več platformah s samo eno glavno izvorno kodo [10].

Različice Platforma API-jezik

Cocos2d Windows, OS X, Linux Python 2.6, 2.7 ili 3.3,

Objective-C

Cocos2d-x iOS, Android, Tizen, Windows 8, Windows

Phone 8, Linux, Mac OS X

C++, Lua, JavaScript

Cocos2d-objC iOS, Mac OS X, Android Objective-C, Swift

Cocos2d-html5 HTML5-ready browser JavaScript

Cocos2d-xna Windows Phone 7 & 8, Windows 7 & 8,

Xbox 360

C#

TABELA 4.1: RAZLIČICE IGRALNEGA POGONA COCOS2D. VIR: [10]


18 | S t r a n

Glavne lastnosti Cocos2d-x-a

Preden se poglobimo v razvoj igre in programiranje v igralnem pogonu Cocs2d-x, moramo

razumeti nekatere izmed osnovnih konceptov. Samo jedro izbranega igralnega pogona

tvorijo scene, node, sprite, meni in akcijski objekti. Skoraj vsaka igra vsebuje vse te

komponente v takšni ali drugačni obliki [11].

Nekatere ostale funkcionalnosti:

– upravljanje s scenami;

– prehod med scenami;

– učinki, kot so leča, valovi, tekočina;

– akcije:

– Transformation Actions – Move, Rotate, Scale, Fade itd.,

– Ease Actions – Exp, Sin, Cubic itd.,

– Composable actions – Sequence, Spawn, Repeat, Reverse,

– Misc actions – CallFunc, OrbitCamera, Follow, Tween;

– osnovni meni;

– integracija s fizikalnim pogonoma Box2d in Chipmunk;

– sistem delčkov;

– animacije okostnjakov;

– razne pisave;

– paralelno premikanje;

– zvočni pogon (CoocosDenshion);

– jeziki C++, Lua, JavaScript ter

– OpenGL ES 2.0 / OpenGL 2.1.

Igralni pogon Cocos2d-x si lahko predstavljamo kot ravnatelja, programerja pa kot

izvršnega producenta. Ravnatelj nadzira potek dela in daje navodila drugim, mi kot izvršni

producent pa ravnatelju povemo, kaj naj naredi. Ravnatelj je tako samo en (obstaja samo

ena različica tega razreda istočasno). Je objekt, ki ga lahko prikličemo s katerega koli

mesta znotraj naše kode. Ena izmed osnovnih nalog ravnatelja je nadzorovanje scene.


19 | S t r a n

SLIKA 4.3: KONCEPT RAVNATELJA. VIR: [12]

Scene

Skoraj vse igre imajo glavni meni, nekaj nivojev in zaključno sceno. Za organizacijo vseh

teh scen skrbi razred scene. Scene so narejene iz nekaj ločenih delov, ki skupaj tvorijo

celoto. Razredu scene povemo, katero sceno naj nam prikaže oziroma s katero novo

sceno naj zamenja prejšnjo. Cocos2d-x uporablja algoritem in-order-walk, s katerim

izrisuje objekte na zaslonu. Takšen algoritem prične izrisovati z leve strani drevesa proti

desni. Tako bo zadnji element tisti na desni strani, prikazan spredaj na zaslonu. Na

podlagi tega koncepta lahko sceno opazujemo kot zbirko vozlov objekta. Za izdelavo

grafa scene uporabimo ukaz addChild.

SLIKA 4.4: ALGORITEM IN-ORDER-WALK.


20 | S t r a n

Sprite

Sprite [13] je po definiciji slika, ki je lahko animirana ali preoblikovana s spremembo njenih

lastnosti. Sprite so vsi objekti, ki jih premikamo, če pa se objekt ne premika in stoji na

mestu, to predstavlja vozlišče (Node). Obstaja več načinov, kako narediti sprite. Eden

izmed najbolj znanih je kreiranje sprita iz slikovne datoteke. Sprite datoteke so enostavne

za ustvariti, v igri pa določajo lastnosti, kot so položaj, rotacija, skaliranje in barva. Za

ustvarjanje novega sprita se uporablja metoda Sprite::create(). Sprite je središčna

točka predmeta, ki predstavlja osnovna koordinato njegovega položaja. Središčno točko

postavimo z metodom setAnchorPoint(Vec2()) [14].

Načini kreiranja sprita:

– ustvarjanje sprite z Rect;

– ustvarjanje sprite z ImageFile;

– ustvarjanje sprite z Sprite Sheet;

– ustvarjanje sprite z SpriteFrameCache in

– ustvarjanje sprite z SpriteFrame.

Sprite Sheets [15] je način kombiniranja več slikovnih datotek v eno skupno datoteko. Z

ustvarjanjem sprita iz sprite sheeta dosežemo boljše učinkovitost. Sprite Sheets prihranijo

veliko prostora na disku in porabijo manj delovnega spomina. To je ena izmed običajnih

metod, ki se uporabljajo v industriji videoiger za povečanje zmogljivosti igre. Ko

uporabljamo Sprite Sheet, se ta prvo naloži v SpriteFrameCache, to je predpomnilnik, ki

vsebuje SpriteFrame objekte in jih doda za naslednji hitrejši dostop. SpriteFrame je

zapisan samo enkrat in ostane shranjen v SpriteFrameCache.

Actions

Dodajanje sprite predmetov na sceno je samo en del igre. Da bi bila igra celovita, je

potrebno, da se predmeti tudi premikajo. Tukaj nam na pomoč priskoči funkcija actions

(akcije). Akcije so integralni del vsake igre. Omogočajo nam preobrazbo vozlov v

časovnem prostoru. Na katerem koli objektu, kjer je bazni razred node, se lahko ustvari

tudi akcija. S tem lahko spremenimo položaj, rotacijo in skaliranje predmeta [16].

Za izvršitev več akcij se uporabljata funkciji sequences in spawns. Sequence so

zaporedne akcije na predmetu, ki potekajo ena za drugo. Število dejanj ni določeno, kar

pomeni, da je to lahko katero koli število. Možno je ustvariti lastno funkcijo, tako da se

izvaja znotraj zaporedja. Spawn se uporablja ko želimo, da se več dejanj dokonča


21 | S t r a n

istočasno. Število ponavljanj ni omejeno, možno pa je vnesti tudi drugačne

funkcionalnosti. Spawn je enak dejanju več istočasnih runAction funkcij. Kombinacija

funkcij spawn in sequence je zelo pomembna lastnost igralnega pogona Cocos2d-x.

SLIKA 4.5: KOMBINACIJA SPAWN IN SEQUENCE. VIR: [16]

Nekatere osnovne akcije:

– premakni;

– rotiraj in

– skaliraj.

Easing je animacija s posebnim pospeškom gladkega prehoda. Takšne animacije se

vedno končajo na isti način. Easing animacija se pogosto uporablja za simulacijo umetne

fizike v igrah. Če igra vsebuje samo nekoliko enostavnih fizikalnih učinkov in ne želimo

izkoristiti zahtevne fizikalnih funkcionalnosti, ki nam jih ponuja fizikalnih pogon, potem je to

dobra rešitev.


22 | S t r a n

SLIKA 4.6: EASING FUNKCIJE. VIR: [16]

Komponente uporabniškega vmesnika

Cocos2d-x vsebuje paket uporabniškega vmesnika, da bi lahko kar najenostavnejše in

najhitreje ustvarili uporabniški vmesnik. To so vsi elementi, ki se nahajajo na zaslonu in

služijo za interakcijo. Nekateri izmed teh elementov so: labels, buttons, menus, sliders in

views.

Cocos2d-x omogoča tri vrste pisav, in sicer TTF, BMFont ter SystemFont. TTF je vrsta

pisave, s katerim se vse črte ‘‘izčrtavajo’‘. V TTF vrsti pisave ni treba imeti posebne

datoteke za vsako velikost in barvo, ki jo želimo prikazati. BMFont je vrsta pisave, ki

uporablja rastrsko grafiko. Znaki v BMFontu so pisave, narejeni iz točkovne mreže. Ta

pisava ni skalabilen in zahteva poseben pisave za vsako velikost znaka. Vsak znak je


23 | S t r a n

objekt zase, kar pomeni, da ima svoje lastnosti, kot so rotacija, skaliranje in

transformacija. Za ustvarjanje BMFont pisave potrebujemo dve datoteki – .fnt datoteko ter

.png datoteko za prikaz slike vsakega znaka. Tretji tip SystemFont vsebuje osnovne

sistemske pisave in velikost pisave. Ta pisava se uporablja, ko smo mu določili že vse

lastnosti. Nekateri izmed teh vrst pisave podpirajo tudi učinke, kot so senca, obris in sij.

Za ustvarjanje menija uporabimo razred menu. Najpogosteje se ustvari prazen menu

objekt kot kontejner, ki bo vseboval vse potrebne elemente. Cocos2d-x omogoča več

načinov, kako se lahko ustvari menu. Največkrat ga lahko najdemo v dveh oblikah –

običajnem ali izbirnem stanju. Z aktivacijo menija se zažene funkcija callback, ki aktivira

del kode, ki smo jo navedli v funkciji callback.

Cocos2d-x uporablja grafične elemente za lažjo uporabo uporabniškega vmesnika.

Najpogostejši elementi so: Buttons, CheckBox, LadingBar, ScrollView, Slider, TextField,

ImageView.

4.3 Orodja za razvoj igre

Razvoj igre je zahtevna naloga. Za razvoj potrebujemo primerno programsko opremo. V

pričujočem podpoglavju bomo opisali osnovna orodja, ki smo jih uporabili v našem

razvoju. Vsak pripomoček bomo opisali in pojasnili, katera je njegova osnovna naloga v

razvoju.

Microsoft Visual Studio 2015

Microsoft Visual Studio je razvojno okolje podjetja Microsoft. Uporablja se pri razvoju

programske opreme, aplikacije in ostalih dejavnosti, povezanih z razvojem programske

opreme. Vsebuje že vključeno IntelliSense komponento. Slednja nam predloži preostanek

kode za hitrejše pisanje. Ravno tako vključuje program za popravljanje napak, ki nam

služi za lažjo prepoznavo napak in prevod programske kode. Programski jeziki, ki jih

podpira, so C++, VB, NET, C#, F#. Možno je dodati jezikovne servise, ki nam potem

omogočajo tudi dodatne jezike, kot sta Python in Ruby. Na voljo je več različic Microsoft

Visual Studio programa, in sicer Community, Professional, Enterpires in Express. Naše

razvojno okolje je bil Microsoft Visual Studio. V njem smo napisali izvorno kodo naše

videoigre. Ravno tako smo ga uporabili za prevod igralnega pogona Cocos2d-x. Njegova

prilagodljivost, dostopnost in stabilnost so nam pripomogle pri razvoju igre.


24 | S t r a n

Android Studio/Eclipse

Android Studio je razvojno okolje za platformo Android. Razvilo ga je podjetje Google.

Primarno je namenjen razvoju aplikacij za platformu Android. Na voljo so različice za

Windows, Linux, macOS. Prva različica je bila objavljena 5. 5. 2013, a še ni bila dovolj

zanesljiva. Šele januarja 2014 so objavili zanesljivejšo različico. Uporabljali smo ga za

prenos iger na mobilne naprave.

GitHub

GitHub je internetna različica orodja GIT ali hranilnika za upravljanje različic. Ima možnost

internetnega shranjevanja. Ponuja upravljanje z izvorno kodo. Omogoča nadzorni pristop,

spremljanje napak, upravljanje z nalogami in ostale možnosti. Pogosto se uporablja v

projektih odprte kode. Razvoj platforme se je pričel 1. 10. 2007, spletna stran pa je na

voljo od leta 2008. Projektom na GitHubu lahko pristopimo s pomočjo običajnega

vmesnika s pomočjo ukazov v ukazni lupini. Spletna stran GitHuba omogoča funkcije, ki

so znane na družbenih omrežjih. GitHub smo uporabili za shranjevanje našega projekta

na njihovi spletni strani. Tako smo lahko lažje spremljali razvoj igre in preverjali različne

inačice igre. Omogočil nam je, da lahko prevzamemo naš projekt z GitHub repozitorija in

nadaljujemo z delom na projektu na drugem računalniku.

Blender

Blender je programsko orodje za obdelovanje 3D-računalniške grafike. Uporabljajo ga

tako profesionalci kot amaterji. Ima odprto kodo in – kar je še pomembnejše – je

brezplačen. Z njim je možno ustvarjati animacije, vizualne učinke, interaktivne 3D-

aplikacije in videoigre. Blender je zelo močno orodje, ki je iz leta v leto vse naprednejše.

Ima redne posodobitve na letni ravni in intuitivno-grafični vmesnik, ki je zelo všeč

začetnikom, ne manjka mu pa prav nič tudi za izkušenejše programerje. Podpira ga več

platform, kot so Windows, Mac OS in Linux. Mi smo ga uporabili za ustvarjanje 3D-

modelov.

GIMP

GIMP je brezplačna aplikacija za obdelavo rastrske grafike. Podpira veliko število

operacijskih sistemov, in sicer vse od UNIX sistema pa do Windows in OS X. Uporablja se

za retuširanje, risanje, obrezovanje slike, izvoz slike v različne formate, ima pa tudi mnoge

druge funkcije. Mi smo ga uporabili za manipulacijo slikovnih datotek.


25 | S t r a n

ShoeBox

Podpira platformi Windows in OS X. Ponuja nam veliko koristnih orodij, ki nam pomagajo

pri razvoju videoigre. Uporabniški vmesnik je dobro oblikovan in enostaven za uporabo.

Vse deluje po načelu ''potegni in izpusti''. Z njim je možno zapakirati več slik, animiranih

SWF ali GIF v eno datoteko, ki se imenuje texture Atlas. Izvaža pravokotne teksture iz

fotografiji in bere sprite sheet datoteke ter izvaža vsako posamično sliko ločeno. Mi smo

ga največ uporabljali za ustvarjanje sprite sheet in izvoz spritov.

Nekatere funkcionalnosti:

– shranjevanje spritov;

– branje spritov;

– izvoz spritov;

– bitmap pisave in

– dodeljevanje pivotov.

Bulk Rename Utility

Bulk Rename Utility je zelo uporabna programska oprema. Uporablja se za

preimenovanje več datotek naenkrat po nekem zadanem pravilu, ki ga določimo sami.

Uporabniški vmesnik je malo neurejen, vendar nam daje veliko možnosti. Omogoča

pregled imen, ki jih bomo ustvarili v realnem času. Uporabili smo ga za preimenovanje

večjega števila datotek, ki so bile potrebne za oblikovanje sprite sheet datotek.

Bfxr

Bfxr je nadgradnja slavnega Sfxra. Njegova osnovna značilnost je ustvarjanje zvočnih

učinkov. Odlična je za ustvarjanje zvoka za videoigre. Osnovna uporaba temelji na

naključnem ustvarjanju in poslušanju zvoka. Po tem se odločimo, ali nam ustvarjeni zvok

zveni dobro ali ne. Avtor pridobi vse pravice na zvoke, ki jih lahko brezskrbno uporablja v

oglaševalske ali druge namene. Obstaja tako spletna različica programa kot tudi

samostojna različica za Windows in Mac. S pomočjo Bfxra smo ustvarili zvoke, ki smo jih

v igri uporabili za zvoke eksplozije in streljanja projektilov.

Physic Body Editor

Physic Body Editor nam olajša delo s fizikalnim pogonom. Namenjen je ustvarjanju

virtualnega telesa nad objekti, ki se kasneje uporabi za zaznavanje trka. Večina pogonov

podpira le konveksne pogone. Urejevalnik Physic Body Editor nam omogoča bolje določiti


26 | S t r a n

obliko našega telesa. Pretvarja točkovne enote zaslonskega prikaza v večkratne

konveksne poligone. Ravno tako omogoča kombiniranje več objektov in njihovo

povezovanje s sklepi. Tako lahko dobimo vse bolj zahtevne objekte. Uporabili smo ga za

kreacijo virtualnega telesa nad našimi predmeti.

V-Play Particle Editor

V-Play Particle Editor je odlično orodje, ki nam omogoča oblikovanje lastnih učinkov z

delci. Program je zelo enostaven za uporabo in omogoča enostaven izvoz datotek.

Učinke, ki jih lahko naredimo z delci, je možno izvoziti v oblikah .plist in json. Delci se

pogosto uporabijo za simulacijo eksplozije, požara, dima, dežja in ostalih učinkov.

Program omogoča preizkušanje učinkovitosti delcev za boljšo optimizacijo. Z večjim

številom delcev, uporabljenih za določen učinek, raste tudi potrebna procesorska moč za

njihovo izvajanje.


27 | S t r a n

5 IMPLEMENTACIJA IGRE

Praktični del pričujočega diplomskega dela tvori implementacija igre z igralnim pogonom

Cocos2d-x. Osnovni koncept igre smo vzeli iz legendarne arkadne igre Space Invaders. To je

ena izmed najstarejših strelskih iger, katere cilj je premagati valove sovražnikov in pridobiti

največje število točk. Igra je bila predhodnica sodobnih iger in je imela pomemben vpliv na

industrijo videoiger.

SLIKA 5.1: RAZREDNI DIAGRAM.


28 | S t r a n

5.1 Postavke projekta

Za razvoj igre smo uporabili igralni pogon Cocos2d-x [11] [17], za razvojno okolje pa

Visual Studio.

Zahteve, ki jih moramo izpolniti za razvoj v Cocos2d-x igralnem pogonu [18], so:

– Windows 7,+, VS 2013+;

– Python 2.7.5;

– NDK r11+, potreben za Android projekte;

– JRE i JDK 1.6+;

– Android/Eclipse in

– Apache-ant-1.9.7.

Najprej smo morali izbrati igralni pogon. Cocos2d-x se nahaja na Git repozitoriju, na

spletni strani https://github.com/cocos2d/cocos2d-x. Odločili smo se za uporabo platforme

GitHub in zato smo najprej namestili konzolo Git na naš računalnik. To smo storili tako, da

smo pridobili potrebno programsko opremo s spletne strani https://git-scm.com/, ustvarili

mapo in prevzeli igralni pogon Cocos2d-x z repozitorija GitHub (slika 5.2).

SLIKA 5.2: PREVZEM IZ GITHUB REPOZITORIJA.

Potem ko smo prevzeli repozitorij GitHub, je bilo treba zagnati datoteko python

download-deps.py za za prevzem ostalih potrebnih datotek, na koncu pa smo zagnali

ukaz git submodule update –init.

Za razvoj na platformi Android smo potrebovali dodatno programsko podporo. To so

Android ndk11+, Android sdk in Apache-ant. Pri konfiguraciji igralnega pogona Cocos2d-x

je bilo treba namestiti lokalne spremenljivke (slika 5.3).

https://git-scm.com/


29 | S t r a n

SLIKA 5.3: NASTAVITEV LOKALNIH SPREMENLJIVK.

Nov projekt ustvarimo prek ukazne vrstice s pomočjo ukaza new (slika 5.4) [19]. Ta stavek

prejme naslednje parametre.

SLIKA 5.4: USTVARJANJE NOVEGA PROJEKTA.

– MojaIgra: ime našega projekta.

– -p com.MojaIgraK.MojaIgra: ime paketa za Android.

– -l cpp: programski jezik, ki se uporablja v projektu. Vrednosti, ki mu jih lahko damo,

so cpp in lua.

– -d MOJA_IGRA: direktorij, ki bo podpiral projekt.

Prevajanje smo naredili tako, da smo odprli narejeni projekt v programu za prevajanje

(Visual Studio) in ga potem prevajali.

Projekt smo naložili na GitHub. Za to smo potrebovali osnovno znanje iz Gita. Po korakih

bomo opisali potek dodajanja projekta v Git repozitorij:


30 | S t r a n

1. Ustvarimo nov repozitorij na GitHubu.

2. Odpremo Git Bash.

3. Prestavimo se v trenutni delovni direktorij na našem lokalnem projektu.

4. Inicializacija Git direktorija

$ git init

5. Dodamo datoteke v svoj nov lokalni repozitorij.

$ git add.

#Dodamo datoteke znotraj repozitorija in jih propravimo za commit.

6. Predamo datoteke, ki smo jih postavili v naš lokalni direktorij.

$ git commit -m ''First commit''

#Commit spremlja spremembe in jih pripravi za pošiljanje na oddaljeni repozitorij.

7. V ukazno vrstico dodamo URL oddaljenega repozitorija, kamor bomo prestavili naš

lokalni repozitorij.

$ git remote add origin <remote repository URL>

$ git remote -v

8. Posredujemo spremembe iz našega lokalnega direktorija na GitHub.

$ git push origin master

5.2 Implementacija scen

Osnovni element, na katerem se gradi igra v igralnem pogonu Cocos2d-x, je scena. Igra

mora vsebovati vsaj eno sceno, po navadi pa jih ima kar nekaj. Scene so različni deli igre.

Najprej imamo lahko začetno sceno, kjer se nahajajo izbirni meniji, kot so začni igro, izhod

iz igre, nastavitve in drugi. Scena, ki vsebuje vso logiko in idejo igre, je po navadi glavna

scena. Lahko dodamo tudi scene, kot so premor, konec igre, rezultat. Tehnično se vsaka

scena obnaša kot neodvisna enota znotraj aplikacije. Scene lahko obravnavamo kot

podaplikacijo. Pri spremembi scen lahko uporabimo prehodne elemente. Scena je osnovni

element, ker na njo dodamo vse dodatne elemente. Lahko je sestavljena iz več faz, sama

zasnova pa je podobna programom za obdelovanje fotografije. Za našo igro bomo naredili

tri scene: začetno, ki vsebuje meni, sceno igre, ki vsebuje logiko in glavni mehanizem

igre, ter zaključno sceno, ki se pojavi, ko igralec igro izgubi (slika 5.5).


31 | S t r a n

SLIKA 5.5: OSNOVNE SCENE V IGRI.

Najlažji način za ustvarjanje novih scen je podvojitev osnovne scene. To naredimo tako,

da kopiramo že obstoječo sceno, ki nam jo predloži igralni pogon Cocos2d-x, in nato

samo spremenimo potrebne dele.

Refaktoriranje datotek:

1. Spremenimo imeni datotek HelloWorldScene.h in HelloWorldScene.cpp v želeno

ime. Mi smo se odločili za GameScene in GameOverScene.

2. V datoteki s končnico .h spremenimo ukaze na vrhu dokumenta.

3. V datoteki s končnico .h spremenimo ime našega razreda, na primer GameScene

(izvirna koda 5.1).

class GameScene : public cocos2d::Layer { public: static cocos2d::Scene* createScene(); virtual bool init(); // a selector callback void menuCloseCallback(cocos2d::Ref* pSender); // implement the "static create()" method manually CREATE_FUNC(GameScene); };

IZVIRNA KODA 5.1: DEKLARACIJA ZAČETNE SCENE.


32 | S t r a n

4. V datoteki s končnico.cpp na začetku dokumenta vključimo primerno datoteko.

5. V datoteki s končnico.cpp spremenimo primerno ime razreda (izvorna koda 5.2).

Scene* GameScene::createScene() { // 'scene' is an autorelease object auto scene = Scene::create(); // 'layer' is an autorelease object auto layer = GameScene::create(); // add layer as a child to scene scene->addChild(layer); // return the scene return scene; }

IZVORNA KODA 5.2: USTVARJANJE ZAČETNE SCENE.

6. V datoteki s končnico.cpp spremenimo ime bool funkcije v ime našega razreda.

Ta postopek lahko ponovimo za vse nove scene. Zadnji korak je postavljanje začetne

scene [12]. To naredimo tako, da spremenimo del kode v datoteki AppDelegate.cpp.

Slednja je vrsta datoteke, v kateri se nahajajo in določijo vse začetne postavke. Možno je

določiti ločljivost igre, nastaviti število prikaznih slik na sekundo ali vključiti statusno

vrstico. Tu bomo dodali vse datoteke, ki jih bomo uporabljali med igro, kot so slikovne

datoteke, zvočne datoteke in 3D-modeli. Tukaj določimo, katera scena bo začetna, in

sicer tako da spremenimo del kode, ki določa začetno sceno (izvorna koda: 5.3) [12].

// create a scene. it's an autorelease object auto scene = MainMenuScene::createScene(); // run director->runWithScene(scene);

IZVORNA KODA: 5.3 DOLOČANJE ZAČETNE SCENE.

5.3 Implementacija menija

Za premikanje med scenami potrebujemo menije. Menije bomo dodali v dve sceni –

MainMenuScene in GameOverScene. V glavni sceni ne potrebujemo menija, saj se igra

avtomatsko vrne na sceno GameOverScene, ko igralec izgubi. Za začetek izdelave

glavnega menija potrebujemo menije. Naredili smo jih s pomočjo programa GIMP in jih

zapakirali v eno skupno datoteko s pomočjo programa ShoeBox. Z istim programom smo

ravno tako ustvarili datoteko s končnico.plist, ki vsebuje koordinate in dimenzije vsake

slike. Uporabili smo datoteke sprite sheet (slika 5.6), da bi dosegli boljšo optimizacijo in

izkoristek [12] [20].


33 | S t r a n

SLIKA 5.6: SPRITE SHEET OZADJE IN MENI.

Najprej je treba prebrati primerne datoteke. To naredimo tako, da v funkciji

SpriteFrameCache::getInstance()->addSpriteFramesWithFile() dodamo primerno

slikovno in .plist datoteko, ki vsebuje koordinate slike (izvorna koda 5.4).

//Loading spritesheet menu_scene SpriteFrameCache::getInstance()->addSpriteFramesWithFile("menu_scene.plist", "menu_scene.png");

IZVORNA KODA 5.4: ZAJEMANJE DATOTEK SPRITESHEET.

Zatem ustvarimo sprite. Dodamo želeno sliko iz naše datoteke. Sprite dodamo v funkcijo

MenuItemSprites(izvorna koda 5.5). Postavimo ga na želeno mesto na sceni in na

koncu ta predmet dodamo v meni (izvorna koda 5.6).

//************* adds start game button *********** auto start_normal = Sprite::createWithSpriteFrameName("startgame_button.png"); auto start_pressed = Sprite::createWithSpriteFrameName("startgame_button.png"); startgame_item = MenuItemSprite::create(start_normal, start_pressed, CC_CALLBACK_1(MainMenuScene::startgame, this)); startgame_item->setPosition(visibleSize.width / 2 + origin.x, visibleSize.height/2 + origin.y + 100);

IZVORNA KODA 5.5: DODAJANJE MENIJA.

auto menu = Menu::create(startgame_item, credits_item, NULL); menu->setPosition(origin);

IZVORNA KODA 5.6: USTVARJANJE MENIJA.


34 | S t r a n

Menijem smo morali dodeliti tudi funkcionalnost. Cocos2d-x se za upravljanje s scenami

ravna po načelu ''Last-In-First-Out'' (LIFO). Opisali bomo glavne metode, ki se uporabljajo

za premik med scenami.

– Potisk scene: metoda, ki ustavi akcijo trenutne scene, drugo sceno pa potisne na

sklad.

– Vskočna scena: metoda, ki odstrani trenutno zgornjo sceno iz sklada.

– Zamenjava scene: metoda, ki se uporablja za spremembo trenutne scene z novo

sceno.

Sestavili smo logiko za zamenjavo scene. Logika, ki smo ji sledili, vsebuje tri glavne

scene. Iz scene MainMenuScene je možno vstopiti v sceno GameScene. Ko igralec izgubi

v sceni GameScene, se ta zamenja na sceno GameOverScene. Iz scene

GameOverScene je znova mogoče oditi v sceno MainMenuScene ali GameScene (slika

5.7).

SLIKA 5.7: LOGIKA ZAMENJAVE SCEN.

Implementacijo zamenjave scen izvajamo tako, da izkoristimo vse zmogljivosti igralnega

pogona Cocos2d-x. Uporabili bomo funkcijo CC_CALLBACK_X (izvorna koda: 5.7), ki

določa, katera funkcija se bo izvajala naslednja glede na nek dogodek, ki se bo zgodil

predmetu.

CallFunc::create(CC_CALLBACK_0(MainMenuScene::startgame_callback, this)), NULL));

IZVORNA KODA: 5.7 PRIMER FUNKCIJE CC_CALLABACK.


35 | S t r a n

Zamenjavo scene izvedemo tako, da ustvarimo novo sceno in z enim od zgoraj opisanih

načinov sceno zamenjamo (izvorna koda 5.8).

void MainMenuScene::startgame_callback() { //StartGame button - chnage scene auto scene = TransitionZoomFlipX::create(0.2f, HelloWorld::createScene()); Director::getInstance()->replaceScene(scene);

IZVORNA KODA 5.8: ZAMENJAVA SCENE.

5.4 Implementacija animacij

Igra brez animacij je samo navadna slika. Vsaka igra je sestavljena iz nekaj vrst animacij,

ki dajo igri življenje in nove dimenzije. Opisali bomo nekaj osnovnih animacij, ki smo jih

uporabljali, pojasnili, zakaj smo izbrali ravno njih in na kakšen način smo jih implementirali

[21].

Animacija ozadja

Animacija ozadja je prva animacija, ki jo vidimo, ko zaženemo igro. Daje nam privid

umetnega gibanja glavnega igralca. Zato lahko uporabimo tehniko neprekinjenega

premikanja ozadja (ang. Endless scrolling background). Odločili smo se za navpično

premikanje ozadja. Za to smo potrebovali eno ozadje, ki se bo nenehno spreminjalo. Ko

smo izbrali ozadje, smo v brezplačnem programu za obdelovanje slikovnih datotek GIMP

sliko spremenili, tako da sta zgornji in spodnji del slike podobna. Na takšen način je

prehod iz ene slike v drugo manj izrazit. Zatem smo implementirali pomikanje ozadja in

zamenjavo slik. Za to smo uporabili obstoječo funkcionalnost igralnega pogona Cocos2d-

x, in sicer razred Texture2D. Ta razred omogoča kreacijo OpenGL 2D-teksturo iz slike,

besedila ali primarnih podatkov (ang. RAW data). Ustvarili smo ponavljajočo teksturo, ki

se razteza od roba do roba, in jo dodelili našemu ozadju (izvorna koda 5.9) [20] [12].

Texture2D::TexParams texRepeat = { GL_NEAREST, GL_NEAREST, GL_CLAMP_TO_EDGE, GL_REPEAT }; _spr->getTexture()->setTexParameters(texRepeat);

IZVORNA KODA 5.9: USTVARJANJE PONAVLJAJOČE TEKSTURE.


36 | S t r a n

Za simulacijo gibanja ozadja smo uporabili funkcijo update. Simulacijo gibanja smo

naredili tako, da smo v našem ozadju postavili pravokotno teksturo in nato z vsako

iteracijo igre to teksturo premikali po osi y z določeno hitrostjo (izvorna koda 5.10). Tako

smo ustvarili simulacijo premikanja igralcev.

xScroll += xSpeed*dt; _spr->setTextureRect(Rect(0, -((int)xScroll) % (2048), 1024, 2048));

IZVORNA KODA 5.10: DEFINICIJA HITROSTI GIBANJA OZADJA.

Pri animaciji ozadja smo uporabili še en zelo znan učinek v razvoju videoiger – paralaksno

pomikanje (ang. parallax scrolling) (slika 5.8) [22]. Parallax je po definiciji sprememba

položaja opazovanega objekta glede na spremembo položaja opazovalca. Najboljši

primer je vožnja z avtomobilom. Ko opazujemo objekte med vožnjo, objekti, ki so nam

bližje, nekako poletijo mimo nas, za tiste, ki so bolj oddaljeni, pa se zdi, kot da se gibajo

počasneje. V računalniški grafiki je t. i. paralaks učinek enostaven in učinkovit način, da

se ustvari iluzija globine 2D-iger. Ta učinek se doseže tako, da se slike v ozadju premikajo

počasneje od tistih, ki so spredaj. Najpogosteje se uporablja tehnika večplastnosti. Z

deljenjem elementov ozadja v različne plasti je možno nadzorovati hitrost in položaj teh

plasti, tako da se ustvari paralaks učinek. Igralni pogon Cocos2d-x je oblikovan tako, da

ima vsak objekt svojo plast. To nam omogoča, da lahko vsak objekt posamično

nadzorujemo. Paralaksno pomikanje se pogosto uporablja v igrah, ki so oblikovane za

vodoravno usmerjeno igro. Vseeno pa ga lahko učinkovito uporabimo tudi v navpičnih

igrah, kot so vesoljske strelske igre, kjer se sicer največ uporablja navpično paralaksno

gibanje. Najpomembnejša razlika glede na vodoravno os je premikanje ozadja po osi y. Mi

smo to naredili tako, da smo ustvarili več objektov, ki predstavljajo različne plasti v ozadju.

Potem smo vsakemu posebej namestili hitrost gibanja in tako ustvarili učinek paralaks

[23].


37 | S t r a n

SLIKA 5.8: UČINEK PARALAKS.

Animacija eksplozije

Da bi kar najbolje popestrili igro, potrebujemo določene animacije eksplozije. Animacije

eksplozije se lahko ustvarijo na več načinov. Mi smo uporabili naslednja dva načina:

kreiranje animacije iz slikovne datoteke in kreiranje animacije z učinkom delcev (ang.

particle effects).

Izdelava animacije iz slikovne datoteke je sestavljena iz nekoliko korakov. Najprej je bilo

treba poiskati primerno animacijo eksplozije. Vse te animacije smo s pomočjo ShoeBoxa

združili v eno datoteko za boljšo optimizacijo igre. Poleg datoteke, v kateri so vse

eksplozije, smo ustvarili tudi .plist datoteko s koordinatami vsake sličice. Zatem smo

naložili datoteko in prikazali vsako sliko v določenih časovnih razmikih, da bi simulirali

eksplozijo. Za nalaganje datotek smo uporabili funkcionalnost SpriteBatchNode in

SpriteFrameCache (izvorna koda 5.11).

SpriteBatchNode* spritebatch = SpriteBatchNode::create("explosions.png"); SpriteFrameCache* cache = SpriteFrameCache::getInstance(); cache->addSpriteFramesWithFile("explosions.plist");

IZVORNA KODA 5.11: NALAGANJE DATOTEK ZA EKSPLOZIJO.


38 | S t r a n

Zatem smo določili začetno sliko animacije in jo dodali v SpriteBatchNode (izvorna

koda 5.12).

auto Sprite1 = Sprite::createWithSpriteFrameName("explosionsB_1.png"); Sprite1->setPosition(sprite->getPosition()); spritebatch->addChild(Sprite1);

IZVORNA KODA 5.12: DEFINICIJA ZAČETNE SLIKE ANIMACIJE.

Vsako sliko animacije smo dodali v isti sklop. Tu smo uporabili vektor, saj smo vanj dali

vsako sliko, ki naj bi se prikazala pri določeni animaciji. Dostop do slik nam omogoča

funkcionalnost SpriteFrameCache::getSpriteFrameByName(). Imena in koordinate

vsake slike so napisane v .plist datoteki.

Za vsako sliko smo kreirali SpriteFrame in jo dodali v vektor slik. Funkcionalnost

Animation::createWithSpriteFrame nam omogoča, da dodamo zaporedje slik in

ustvarimo animacijo. Na koncu smo samo zagnali akcijo animacije v sekvenci (izvorna

koda 5.13).

Vector<SpriteFrame*> animFrames(0); char str[100] = { 0 }; for (int i = 1; i < 47; i++) { sprintf(str, "explosionsB_%d.png", i); SpriteFrame* frame = cache->getSpriteFrameByName(str); animFrames.insert(i - 1, frame); } auto removeSelf = RemoveSelf::create(); Animation* animation = Animation::createWithSpriteFrames(animFrames, 0.02f); Sprite1->runAction(Sequence::create(Animate::create(animation), removeSelf, nullptr)); layer->addChild(spritebatch, -1);

IZVORNA KODA 5.13: PRIMER ANIMACIJE EKSPLOZIJE.

Animacije padanja meteorjev in gibanje nasprotnikov

Za animacije meteorjev in nasprotnikov smo uporabili osnovne animacije, ki nam jih

ponuja igralni pogon Cocos2d-x. To so funkcionalnosti MoveTo, MoveBy, RotateTo,

RotateBy in ostale. Vse te osnovne animacije gibanja smo kombinirali z malo bolj

naprednimi animacijami, kot sta EaseIn in EaseOut, tako smo ne nazadnje dobili

zapletene animacije.


39 | S t r a n

Za animacije padanja meteorjev smo uporabili dve osnovni animaciji: MoveTo in

RotateBy. MoveTo nam simulira premik na določeno točko, RotateBy pa obračanje.

Najprej smo ustvarili začetno in končno točko (izvorna koda 5.14).

auto posX = RandomHelper::random_int(-300, 300); if (posX + _width / 2 > visibleSize.width) posX = visibleSize.width - _width / 2; auto offX = RandomHelper::random_int(-300, 300); if (offX + _width / 2 > visibleSize.width) offX = visibleSize.width - _width / 2;

IZVORNA KODA 5.14: USTVARAJANJE ZAČETNE IN KONČNE TOČKE GIBANJA METEORJEV.

Zatem smo postavili meteorje na začetno točko, funkciji MoveTo::create() dodelili

hitrost premikanja meteorjev in končno točko, proti kateri se premikajo (izvorna koda

5.15).

sprite->setPosition(Vec2(posX, visibleSize.height / 2 + origin.y + _height)); auto meteorMoveTo = MoveTo::create(speed *visibleSize.height, Vec2(offX + origin.x, -visibleSize.height));

IZVORNA KODA 5.15: POZICIONIRANJE METEORJEV IN AKTIVIRANJE AKCIJE.

Za obračanje meteorjev smo uporabili funkcijo RotateBy::create(), s katero lahko

določimo tudi hitrost obračanja in kot. Nastavili smo kot obračanja na 360° in to dodali

funkciji RepeatForever, ki neskončno ponavlja to akcijo (izvorna koda 5.16).

auto meteorRotateBy = RepeatForever::create(RotateBy::create(speed * visibleSize.height, 360));

IZVORNA KODA 5.16: ANIMACIJA ROTACIJE METEORJEV.

Funkcionalnost, ki objektom doda akcijo, je Sprite::runAction() (izvorna koda 5.17).

sprite->runAction(sequence); sprite->runAction(meteorRotateBy);

IZVORNA KODA 5.17: DODAJANJE AKCIJE OBJEKTOM.


40 | S t r a n

Ustvarili smo več načinov gibanja nasprotnikov. Vsak od teh načinov ima določene

animacije gibanja. Kombinirali smo več animacij in jih združili v zapletene oblike. Način,

kako se bodo pojavili nasprotniki, se ustvari naključno. Za to smo uporabili stavek switch

(izvorna koda 5.18).

void Enemies::movementMode(int tipMove) { switch (tipMove) { //Action move forward case moveType::move1: {

IZVORNA KODA 5.18: USTVARJANJE GIBANJA NASPROTNIKOV.

Potem smo za vsak način ustvarili način gibanja. Tu smo uporabili tudi Bezierjeve krivulje

(slika 5.9), ki so nam pripomogle, da simuliramo sinusno gibanje. Igralni pogon Cocos2d-x

ima funkcijo, ki nam pomaga pri kreiranju Bezierjeve krivulje, in sicer ccBezierConfig.

Bezierjeva krivulja je sestavljena iz dveh kontrolnih točk in ene končne točke.

SLIKA 5.9: BEZIERJEVA FUNKCIJA.

Najprej smo ustvarili dve naključni kontrolni točki, ki sta si med seboj simetrični. Ravno

tako smo ustvarili naključno začetno točko, ki določa, s katere strani se bodo pojavljali

nasprotniki, in končno točko, ki je nasprotna začetni (izvorna koda: 5.19).


41 | S t r a n

int randY = RandomHelper::random_int(-100, 400); int randStartPos = RandomHelper::random_int(-1, 1); if (randStartPos >= 0) { randStartPos = 1; } this->getSpr3D()->setPosition(randStartPos * 400, 400); auto action1 = RotateBy::create(2.5, Vec3(0, randStartPos*25, 0)); auto action2 = RotateBy::create(1.5, Vec3(0, randStartPos*-50, 0)); int randomBezierX = RandomHelper::random_int(0, 300); int randomBezierY = RandomHelper::random_int(0, 460); ccBezierConfig *bezierConfig = new ccBezierConfig(); bezierConfig->controlPoint_1.setPoint(randomBezierX, -randomBezierY); bezierConfig->controlPoint_2.setPoint(-randomBezierX, randomBezierY); bezierConfig->endPosition.setPoint(-(randStartPos )*400, randY);

IZVORNA KODA: 5.19 USTVARJANJE BEZIERJEVE FUNKCIJE.

Uporabili smo funkcijo BezierTo::create() in tako dodelili hitrost trajanja Bezierjeve

krivulje in samo Bezierjevo krivuljo. Vse animacije gibanja smo združili v več sekvenc in

tako ustvarili kompleksnejšo animacijo (izvorna koda 5.20).

auto action3 = BezierTo::create(5.0, *bezierConfig); auto seq1 = Sequence::create(action1, action2, NULL); auto seq2 = Sequence::create(Spawn::create( seq1, action3, NULL), CallFunc::create(CC_CALLBACK_0(Enemies::resetEnemies, this)), NULL); this->getSpr3D()->runAction(seq2);

IZVORNA KODA 5.20: ANIMACIJA GIBANJA PO BEZIERJEVI FUNKCIJI.

5.5 Implementacija strukture igre

Najpomembnejši del pri razvoju iger je njena organizacijska struktura. Slednja nam bo

določila nadaljnji razvoj igre in njeno zahtevnost. Zato je pomembno, da strukturo igre kar

najbolj organiziramo, saj bomo s tem zmanjšali čas in zahtevnost razvoja igre.

Najpomembnejše pri strukturi igre je, da ločimo glavne komponente igre.


42 | S t r a n

Glavne komponente naše igre so:

– igralec;

– nasprotniki;

– meteorji in

– projektili.

Vse posamezne komponente imajo skupne lastnosti. Za lažjo organizacijo smo ustvarili

skupni razred GameEntity glede na te skupne lastnosti (izvorna koda: 5.21), ki smo jih

pozneje uporabili pri kreaciji naših osnovnih komponent igre.

public: CC_SYNTHESIZE(float, _radius, Radius); CC_SYNTHESIZE(Sprite*, _spr, Spr); CC_SYNTHESIZE(Sprite3D*, _spr3D, Spr3D); CC_SYNTHESIZE(ParticleSystemQuad*, _par, Par); CC_SYNTHESIZE(PhysicsBody*, _body, Body);

IZVORNA KODA: 5.21 LASTNOSTI OSNOVNIH ELEMENTOV.

Nekatere od glavnih komponent igre imajo veliko skupnih lastnosti. V našem primeru so to

igralec in nasprotniki. Ti imajo skupne lastnosti, kot so točkovanje, število življenj in

življenja. Zato smo ustvarili poseben razred SpaceShipStats, ki vsebuje vse te lastnosti

(izvorna koda 5.22).

CC_SYNTHESIZE(bool, _alive, Alive); CC_SYNTHESIZE(float, _hp, Hp); CC_SYNTHESIZE(int, _score, Score);

IZVORNA KODA 5.22: SKUPNI ELEMENTI IGRALCA IN NASPROTNIKA.

Igralec

Igralec je najpomembnejša komponenta naše igre. To je objekt, s katerim upravljamo in

nas v igri predstavlja. Brez igralca igra ne bi imela smisla. Za njegovo implementacijo smo

ustvarili poseben razred PPlayer. Najpomembnejša lastnost v razredu PPlayer je njegovo

gibanje. Dodali pa smo tudi nekaj dodatnih značilnosti, kot sta spremljanje točk in grafični

element simulacije vesoljskega pogona.


43 | S t r a n

Objekt je bilo treba inicializirati in kreirati. Inicializacijo opravimo v konstrukcijski funkciji

PPlayer::PPlayer(Layer). Layer določa eno plast, na kateri se bo nahajal igralec. Ker

je naš glavni igralec 3D-model, se njegova kreacija malo razlikuje od kreacije 2D-modela.

Vedno moramo poleg 3D-modela priložiti tudi teksturo modela. Naše 3D-modele smo

pospravili v različne mape. Najprej smo določili specifično pot do naših 3D-modelov, ki se

razlikuje samo po imenu datoteke. Tako lahko dostopamo do vsakega želenega modela

(izvorna koda 5.23) samo s spremembo imena datoteke.

//Models ships int shipIndex = RandomHelper::random_int(1, 5); shipIndex = 5; auto shipStringOBJ = __String::createWithFormat(SPACESHIP_OBJECT, shipIndex, shipIndex)->getCString(); auto shipStringMATERIALS = __String::createWithFormat(SPACESHIP_MATERIALS, shipIndex, shipIndex)->getCString(); _spr3D = Sprite3D::create(shipStringOBJ, shipStringMATERIALS); _spr3D->setScale(PLAYER_SCALE); this->setRadius(PLAYER_RADIUS); this->setAlive(true); this->setHp(100);

IZVORNA KODA 5.23: USTVARJANJE IGRALCA.

Implementacijo gibanja smo ustvarili s pomočjo razreda EventListener. To je namreč

mehanizem, ki je zadolžen za uporabniške vnose. On prepozna trenutek, ko je uporabnik

nekaj naredil, in reagira na ta dogodek. Najprej je bilo treba implementirati razred

EventListener, ki bo prepoznal, kdaj uporabnik pritisne na zaslon. Poleg razreda

EventListener smo dodali nekaj dodatnih funkcij, ki se bodo ravno tako ukvarjale z

možnimi dogodki (izvorna koda 5.24).

//Evnet Listner auto listener_mouse2 = EventListenerTouchOneByOne::create(); listener_mouse2->setSwallowTouches(true); listener_mouse2->onTouchBegan = CC_CALLBACK_2(PPlayer::onTouchBegan, this); listener_mouse2->onTouchMoved = CC_CALLBACK_2(PPlayer::onTouchMoved, this); listener_mouse2->onTouchEnded = CC_CALLBACK_2(PPlayer::onTouchEnded, this); layer->getEventDispatcher()->addEventListenerWithSceneGraphPriority(listener_mouse2,

layer);

IZVORNA KODA 5.24: DODAJANJE POSLUŠALCA DOGODKOV.


44 | S t r a n

Določenim dogodkom smo dodali funkcionalnost. Za nas je bila najpomembnejša

onTouchMoved (izvorna koda 5.25). Z njo smo simulirali igralčevo gibanje.

void PPlayer::onTouchMoved(Touch * touch, Event * event) { Vec2 prev = _spr3D->getPosition(); Vec2 delta = touch->getDelta(); //Roll 3D models setTargetAngle(targetAngle + 2*delta.x* rollSpeed*(rollReturnThreshold - fabsf(targetAngle) / maxRoll)); //Promjena pozicije Vec2 shiftPostion = delta + prev; setPosition(shiftPostion.getClampPoint(Vec2(DESIGN_LEFT_BORDER, DESIGN_BOT_BORDER), Vec2(DESIGN_RIGHT_BORDER, DESIGN_TOP_BORDER))); }

IZVORNA KODA 5.25: IGRALČEVO GIBANJE GLEDE NA DOGODEK.

Nasprotniki

Namen nasprotnika je, da igri dodamo neko težavnost oziroma cilj. Nasprotniki so

naključne vesoljske ladje, ki se pojavljajo. Ustvarili smo štiri formacije pojavljanja

nasprotnikov. Vsaka izmed teh formacij je sestavljena iz zapletenih animacij, ki smo jih

opisali v poglavju Implementacija animacij. Vendar da bi se nasprotniki prikazali, je treba

ustvariti inicializacijo. Naredili smo poseben razred Enemies, ki vsebuje vse ključne

funkcije. Inicializacija se dogaja v funkciji Enemies::Enemise(Layer). Podobna je

inicializaciji igralcev s spremembami, kot so življenjske točke oz. točke, ki jih dobimo, ko

se uniči nasprotnik ali vesoljske ladje. Nasprotniki imajo tudi dve dodatni spremenljivki, ki

sta _moveType in _shootType, ki določata način gibanja in streljanja.

Meteorji

Meteorji so objekti, ki se premikajo po osi y od zgoraj navzdol. Tem objektom se mora

igralec izogniti ali pa jih uničiti. Meteorji postopoma pospešujejo, kar daje igri dodatno

zahtevnost. Za meteorje smo ustvarili razred Meteor. Razred Meteor poleg že omenjene

funkcije inicializacije vsebuje tri dodatne spremenljivke. To so damage, score in type.

Spremenljivka damage določa, kolikšna škoda bo doletela naše ladje, ko se bomo srečali z

meteorji, score je število točk, ki se seštevajo z našim skupnim številom ladij, ko uničimo

meteor, type pa je vrsta meteorja. Naša igra vsebuje tri vrste meteorjev. Vsaki tip se

razlikuje po videzu, škodi, ki jo naredi, in številu točk, ki jih dobimo, ko ga uničimo. V igri

imamo tri vrste meteorjev. Na začetku se pojavlja samo osnovna vrsta, z napredovanjem


45 | S t r a n

v točkah pa se pojavijo tudi novi tipi meteorjev (izvorna koda 5.26), ki naredijo večjo škodo

ali nam prinesejo večje število točk, če jih uničimo.

int meteorIndex = 1; auto helloworldLayer = (HelloWorld*)Director::getInstance()->getRunningScene()->getChildByName("HelloWorld"); if (helloworldLayer != nullptr) { if (helloworldLayer->getScore() >= 500 && helloworldLayer->getScore() < 1500) { meteorIndex = RandomHelper::random_int(1, 8); } else if(helloworldLayer->getScore() >= 1500) { meteorIndex = RandomHelper::random_int(1, 10); } } else { meteorIndex = RandomHelper::random_int(1,5); }

IZVORNA KODA 5.26: USTVARJANJE RAZLIČNIH VRST METEORJEV.

Projektili

Projektili so objekti, ki ob nesreči z drugimi objekti (meteorji, nasprotnik) ta objekt uničijo

ali odvzamejo del točk, ko se zaletijo v igralca. V naši igri imamo dve vrsti projektilov – eni

pripadajo igralcu, drugi nasprotniku. Za njihovo kreacijo smo ustvarili razred Bullets

(izvorna koda 5.27), iz katerega smo izpeljali razreda EnemyBullets in PlayerBullets.

Razred Bullets je osnovni razred, ki vsebuje osnovne funkcije, katere uporabljata druga

dva razreda.

class Bullets : public Node { public: Bullets(); ~Bullets(); CC_SYNTHESIZE(float, _damage, Damage); CC_SYNTHESIZE(Sprite*, _bulletSprite, BullettSprite); CC_SYNTHESIZE(Vector<Sprite*>, _bulletSprites, BulletSprites); CC_SYNTHESIZE(ParticleSystemQuad*, _bulletParticle, BulletParticle); void resetBullet(); float bulletTimeToPoint(Vec2 endPos, Vec2 startPos, float speed); void bulletImpact(Layer *layer); void update(float dt); };

IZVORNA KODA 5.27: RAZRED BULLETS.


46 | S t r a n

Oba razreda uporabljata funkcijo resetBullet(),ki izbriše projektil, ko ta zapusti okvir

igre. To funkcijo potrebujemo zaradi boljše optimizacije. Funkcija bulletImpact() je

animacijska funkcija. Z njo ustvarimo eksplozijo projektila, ko se ta zaleti v druge objekte,

funkcija update() (izvorna koda 5.28) pa preverja položaj vsakega projektila in če se

nahaja izven okvirjev igre, prikliče funkcijo resetBullet(), ki ta projektil izbriše.

void Bullets::update(float dt) { if (_bulletSprite->getPosition().y > 460) { log("Bullet out of screen UP"); this->resetBullet(); } //Ako je dole else if (_bulletSprite->getPosition().y < -460) { log("Bullet out of screen Down"); this->resetBullet(); } //Ako je ljevo else if (_bulletSprite->getPosition().x > 320) { log("Bullet out of screen Left"); this->resetBullet(); } //Ako je desno else if (_bulletSprite->getPosition().x < -320) { log("Bullet out of screen Right"); this->resetBullet(); } }

IZVORNA KODA 5.28: BRISANJE PROJEKTILOV IZVEN MEJA ZASLONA.

Razreda EnemyBullets in PlayerBullets se uporabljata za inicializacijo in streljanje s

projektili. Projektili od igralcev so narejeni s pomočjo učinkov delcev, za nasprotnikove

projektile pa smo uporabili slikovne datoteke.


47 | S t r a n

class PlayerBullet : public Bullets { public: PlayerBullet(); void startBullet(Layer *layer, PPlayer *player, int index); void update(float dt); ~PlayerBullet(); }; class EnemyBullet : public Bullets { public: EnemyBullet(); void startBullet(Layer *layer, Vec2 startPos, Vec2 directionVector, int index); void update(float dt); ~EnemyBullet(); };

IZVORNA KODA 5.29: PRIMER PODRAZREDA BULLETS.

5.6 Logika igre

Logika igre je tista, ki igro poganja. Nadalje določa, na kateri način se ígra igrá in kaj bo

njen cilj. Logiko moramo graditi od samega začetka. Treba je določiti, kako se bodo scene

med seboj izmenjavale in kaj bo vsaka scena vsebovala. Moramo določiti cilj igre in

njegove glavne komponente. Tukaj se bomo osredotočili na logiko igre, ki upravlja z

glavnimi elementi igre.

Za logiko igre, ki upravlja z načinom igranja igre, smo ustvarili razred GameLayer (izvorna

koda 5.30). Gre za razred, ki upravlja pojave nasprotnikov, meteorjev in projektilov.

Zaznava trke različnih objektov (projektil – igralec, projektil – meteor, projektil –

nasprotnik, meteor – igralec). Uravnava zahtevnost igre s pospeševanjem pojavljanja

meteorjev in njihovo hitrostjo.


48 | S t r a n

public: virtual bool init(); CREATE_FUNC(GameLayer); void update(float dt); void shootPlayerBullets(float dt); void shootEnemyBullets(float dt); void playerUpdate(float dt); void spawnMeteor(float dt); void spawnEnemy3(int enemySpawnType); void enemyWave(int type); bool onContactBegin(PhysicsContact &physicContact); void reserveContainer(); void meteorCollision(int index); void bulletCollision(int index); void enemyCollision(int index); void enemyBulletCollision(int index); float timeToPoint(Vec2 endPos, Vec2 startPos, float speed); void scaleDifficulty(); void scaleBGspeed(); void safeRemoveAll();

IZVORNA KODA 5.30: RAZRED GAMELAYER IN NJEGOVE OSNOVNE FUNKCIJE.

Da bi kar najbolje izkoristili vire, ki so nam na voljo, smo naše objekte umestili v

kontejnerje. S funkcijo reserveContainer() smo prihranili mesta meteorjem,

nasprotnikom, projektilom za igralca in nasprotnika. Za meteorje, nasprotnike in projektile

igralcev smo rezervirali 50 mest. Projektilom nasprotnikov smo rezervirali več mest, saj

lahko vsak nasprotnik strelja več projektilov (izvorna koda 5.31).


49 | S t r a n

void GameLayer::reserveContainer() { _meteorContainerIndex = 0; _bulletContainerIndex = 0; _enemyContainerIndex = 0; _enemyBulletContainerIndex = 0; _meteorsContainer.reserve(METEOR_CONTAINER_SIZE); _bulletsContainer.reserve(BULLET_CONTAINER_SIZE); _enemysContainer.reserve(ENEMY_CONTAINER_SIZE); _enemyBulletsContainer.reserve(ENEMYBULLET_CONTAINER_SIZE); for (int i = 0; i < CONTAINER_SIZE; i++) { _meteorsContainer.pushBack(new Meteor()); _bulletsContainer.pushBack(new PlayerBullet()); _enemysContainer.pushBack(new Enemies()); } for (int i = 0; i < 1000; i++) { _enemyBulletsContainer.pushBack(new EnemyBullet()); } }

IZVORNA KODA 5.31: REZERVACIJA MEST ZA PREDMETE.

Funkcijo init() uporabljamo za inicializacijo. Ta funkcija se avtomatsko aktivira, ko

zaženemo GameLayer. Tu se nahajajo različni urniki (ang. schedule), ki določajo, katere

funkcije se bodo zagnale, kolikokrat in v kakšnih intervalih. Tako smo tu določili, da se

funkcije shootPlayerBullets() izvajajo v intervalih 0,4 sekunde, medtem ko se funkcija

playerUpdate, ki je zadolžena za gibanje igralca, izvaja vsako sekundo. Tukaj smo

inicializirali EventListener za fizične objekte. Potrebujemo ga za prepoznavanja trkov

med objekti. Funkcija, ki jo prikličemo ob trku, je onContactBegin. Z ukazom this-

>scheduleUpdate() smo vključili tudi glavno zanko igre. Tako se funkcija update pokliče

vsako sekundo (izvorna koda 5.32) [24].


50 | S t r a n

bool GameLayer::init() { if (!Layer::init()) { return false; } this->reserveContainer(); //Contac collision listener auto contactListener = EventListenerPhysicsContact::create();

contactListener->onContactBegin = CC_CALLBACK_1(GameLayer::onContactBegin, this);

this->getEventDispatcher()-> addEventListenerWithSceneGraphPriority(contactListener, this); //Player init _player = new PPlayer(this); schedule(schedule_selector(GameLayer::playerUpdate)); //Bullet shoot schedule(schedule_selector(GameLayer::shootPlayerBullets), 0.4, -1, 0); schedule(schedule_selector(GameLayer::shootEnemyBullets), 0.1, -1, 0); this->scheduleUpdate(); return true; }

IZVORNA KODA 5.32: DODAJANJE RAZLIČNIH SCHEDULE FUNKCIJ.

Za določanje težavnosti igre uporabljamo funkcijo scaleDificulty(). Tukaj smo določili

pogostost pojavljanja meteorjev in nasprotnikov ter hitrost gibanja meteorjev. Določili smo

tudi maksimalno pogostost pojavljanja in hitrost (izvorna koda 5.33). Tako smo

onemogočili možnost, da se v enem trenutku pojavi več meteorjev, kot jih lahko sprejme

kontejner.

//Meteor frekvency spawn if (_frequencyMeteor <= 0.15) { _frequencyMeteor = 0.15; } else { _frequencyMeteor -= 0.05; } //Enemy frekvency spawn if (_frequencyEnemy <= 4.0) { _frequencyEnemy = 4.0; } else { _frequencyEnemy -= 1.5; } //Meteor speed if (_speedMeteor <= 0.003) { _speedMeteor = 0.003; } else { _speedMeteor -= 0.001; }

IZVORNA KODA 5.33: POGOSTOST POJAVLJANJA METEORJEV.


51 | S t r a n

Zaznavanje trkov

Zaznavanje trkov je pomemben del naše igre. Nanaša se na računalniški problem

odkrivanja trka dveh ali več objektov. Omogoča zaznavo teh trkov in istočasno izvajanje

nekega dejanja. Brez zaznave trkov bi objekti samo šli drug mimo drugega in ne bi bilo

možno ločiti, ali smo zadeli meteorje ali nasprotnike. Za zaznavo trkov nad našimi objekti

moramo dati objektom fizično telo. To telo bo predstavljalo te objekte in tako bomo lahko

prepoznali, kdaj bo prišlo do trka.

Igralni pogon Cocos2d-x vsebuje fizikalni pogon Chipmunk. Z njim lahko ustvarimo

objekte v igri, ki se obnašajo kot pravi objekti – lahko imajo lastnosti gravitacije, odbijanja,

trka in druge. Chipmunk uporablja koncepte telesa in drugih oblik. Chipmunk telo

predstavlja objekt v virtualnem prostoru. To telo je lahko sestavljeno iz ene ali več oblik

(slika 5.10).

SLIKA 5.10: VIRTUALNO TELO, SESTAVLJENO IZ VEČ OBLIK.

Obstajata dve vrsti teles:

– dinamično telo: uporablja se za objekte, ki se premikajo ali imajo animacije;

– statično telo: uporablja se za objekte, ki so statični. Običajno se uporablja za tla ali

ponazoritev drugih nepremičnih elementov, kot so strop, škatla ali hiša.

Chipmunk fizikalni pogon se uporablja po načelu maskiranja bitov (ang. bitmask) za boljšo

organizacijo trkov. Omogoča nam filtriranje trkov med različnimi oblikam i. Obstaja 32


52 | S t r a n

kategorij trkov. To se lahko doseže z maskiranjem bitov. Za filtriranje trkov imamo na voljo

tri osnovne skupine mask.

Bit maske grupe:

– Category – definira teksturo;

– Collision – definira objekt v trku in ustvari fizično reakcijo;

– Contact – definira posledice kontakta.

V naši igri smo uporabili fizikalni pogon Chipmunk. Z njegovo pomočjo smo določili trke in

tako naredili želene akcije nad objekti. Da bi fizikalni pogon deloval, je treba najprej

ustvariti naš svet. Za to nam pride prav funkcija Scene::createWithPhysics(). Scena, v

kateri smo inicializirali svet, je GameScena [19].

Poleg sveta potrebujemo tudi telesa. To so objekti, ki predstavljajo telesa v naši igri, kot

so igralec, projektili, meteorji in nasprotniki. Ustvarili smo osnovne maskirne bite, ki nam

bodo predstavljali vsak objekt (izvorna koda 5.34).

//COLLISION BITMASK #define COLLISION_PLAYER 0x000001 #define COLLISION_METEOR 0x000002 #define COLLISION_BULLET 0x000003 #define COLLISION_ENEMY 0x000004 #define COLLISION_BULLET_ENEMY 0x000005

IZVORNA KODA 5.34: DEFINICIJA BITNIH MASK ZA ZAZNAVO TRKA.

Nadalje je treba določiti fizična telesa nad temi objekti. To smo naredili za vsak objekt

posebej, in sicer v njihovi inicializacijski funkciji. Najprej smo določili fizično telo v obliki

kroga, katerega premer je polovične velikosti objekta. Za boljše filtriranje trkov med objekti

smo postavili CollisionBitmask in ContactBitmask. Na koncu smo samo določenem

objektu postavili fizično telo (izvorna koda 5.35). To smo ponovili za vse objekte (Player,

Meteor, Bullet, Enemy, Bullet_Enemy).

auto _body = PhysicsBody::createCircle(sprite->getContentSize().width / 2); _body->setCollisionBitmask(COLLISION_METEOR); _body->setContactTestBitmask(1); _body->setDynamic(false); _body->setTag(index); sprite->setPhysicsBody(_body);

IZVORNA KODA 5.35: DODAJANJE FIZIČNEGA TELESA NEKEMU OBJEKTU.


53 | S t r a n

Samo zaznavo trkov ustvarimo v funkciji bool onContactBegin(PhysicContact

&physicContact).To je funkcija, ki se izvede v primeru trka dveh objektov. Za

pravočasni priklic funkcije je odgovorna funkcionalnost EventListenerPhysicsContact.

PhysicContact se kreira avtomatsko, ko dva objekta trčita, in se uniči avtomatsko, ko se

ločita. Tako lahko lažje določimo, katera objekta sta trčila. S funkcijama getShapeA() in

getShapeB() dobimo dva objekta, ki predstavljata telesi, ki sta trčili (izvorna koda 5.36).

auto bodyA = physicContact.getShapeA()->getBody(); auto bodyB = physicContact.getShapeB()->getBody(); auto aBodySprite = static_cast<Sprite *>(bodyA->getNode()); auto bBodySprite = static_cast<Sprite *>(bodyB->getNode());

IZVORNA KODA 5.36: PRIDOBIVANJE OBJEKTOV, KI SO TRČILI.

Naslednji korak je preverjanje bitnih mask teh teles. Najenostavnejši način, kako jih lahko

preverimo, s pomočjo stavka if, vendar lahko igra to telo z getShapeA() zazna kot

meteor ali kot projektil, zato je treba preveriti oba primera. Če se bitne maske ujemajo in

so vsi ostali pogoji izpolnjeni, je treba v stavku if dodati želene akcije (izvorna koda

5.37).

//Colision Player->Meteor <-> Meteor->Player if (aBodySprite && bBodySprite && COLLISION_PLAYER == bodyA->getCollisionBitmask() && COLLISION_METEOR == bodyB->getCollisionBitmask()) { meteorCollision(bodyB->getTag()); _player->hurt(_meteorsContainer.at(bodyB->getTag())->damge); } else if (aBodySprite && bBodySprite && COLLISION_METEOR == bodyA->getCollisionBitmask() && COLLISION_PLAYER == bodyB->getCollisionBitmask()) { meteorCollision(bodyA->getTag()); _player->hurt(_meteorsContainer.at(bodyA->getTag())->damge); }

IZVORNA KODA 5.37: ZAZNAVANJE TRKA.


54 | S t r a n

5.7 Cilj igre

Cilj naše igre je, da igralec dobi kar največ možnih točk. Točke se zbirajo z uničevanjem

nasprotnikovih točk in meteorjev. Igralec ima življenje, ki je predstavljeno s pomočjo 100

točk. Ko igralca zadenejo nasprotnikovi projektili ali pa se igralec zaleti v meteor se število

teh toč zmanjša. Različni nasprotniki zmanjšajo različno število točk. Tako na primer

obstajajo tri vrste meteorjev. Vsaka vrsta poveča število doseženih točk v igri, pa tako

vsaka vrsta lahko zmanjša število življenjskih točk, odvisno od trka z igralcem. Obstaja

več vrst pojavljanj nasprotnikovih ladij in streljanja projektilov. Več točk kot zbere igralec,

hitreje poteka igra. Meteorji postajajo vse hitrejši, nasprotnikove ladje se pojavljajo v

krajših časovnih zamikih. Igra se konča takrat, ko igralcu zmanjka življenjskih točk.


55 | S t r a n

6 PREIZKUŠANJE IGRE

Preizkušanje igre je zelo pomembno, saj omogoča, da najdemo in odpravimo napake,

preden končamo zadnjo različico igre. Mnoge igre imajo več različic pred samo končno

različico. Najbolj priljubljeni sta različici Beta in Alpha. Različni uporabniki testirajo igre v

teh različicah in nato podajo svoje mnenje ter obveščajo razvijalce o možnih napakah.

Tako se dobijo mnenja iz prve roke in pa tudi podatki o tem, kaj igralca najbolj zanima.

Nikoli ne smemo pozabiti, da se igre delajo za ciljno publiko in da je njeno mnenje zelo

pomembno.

V našem primeru so alpha in beta preizkušanje naredili prijatelji. V igro smo dodajali

mnoge nove funkcionalnosti, vsako od teh smo posebej preizkusili in preverili, če deluje

po pričakovanjih. Zatem smo to funkcionalnost dodali v igro in jo testirali skupaj z ostalimi.

Tako smo preverili njeno smiselnost.

Pri preizkušanju novih funkcionalnosti nam je prišla prav razvojna platforma Visual Studio.

Slednja vsebuje prevajalnik, ki nam pomaga pri iskanju napak. Če prevajalnik (ang.

compiler) pri prevajanju najde napako, se ustavi in pokaže, kje se ta napaka nahaja. Tako

lahko nastavimo prekinitvene točke v našem programu in preverimo samo določen del

igre, ki nas zanima. S pomočjo prekinitvenih točk lahko ustavimo delovanje igre na

določenih delih in nato spremenimo dele spremenljivkam. Tako lahko preverimo, kako se

bo igra obnašala v primeru nepričakovanih vrednosti spremenljivk.

6.1 Optimizacija

Optimizacijo uporabljamo zato, da izboljšamo igro, da bo ta čim bolj odzivna in da bo

uporabila kar najmanj sredstev, potrebnih za njeno izvajanje. Igra, ki ni optimizirana, hitro

postane nezanimiva, takšne igre pa hitro izgubijo igralce. Dobro optimizirana igra se lahko

igra tudi na slabši strojni opremi. Optimizirana igra ima minimalno število trenutkov brez

reakcije in ustavljanj med igranjem. Vedno je treba imeti v mislih za katero platformo in

strojno opremo je bila igra namenjena. Najbolje bi bilo omejiti število predmetov v igri in

uporabo napredne fizike. Če bi imeli napredno fiziko na vseh predmetih, bi igra postala


56 | S t r a n

zelo zahtevna, saj je za izračunavanje parametrov napredne fizike potrebno veliko

procesorske moči. Različni igralni pogoni imajo različne metode za optimizacijo igre in

zato je treba preučiti dokumentacijo igralnih pogonov in prebrskati forume, kjer so bolj

izkušeni programerji že našli boljše načine za nekatere funkcionalnosti.

Pomemben del optimizacije igre je število slik, s katerimi se prikazuje igra. Najbolje ga je

omejiti na neko realno vrednost. Večje kot je število slik na sekundo, bolj fluidna je igra,

ampak je za to potrebna tudi večja procesorska in grafična moč. Izbrani igralni pogon nam

omogoča, da sami omejimo število slik in odločili smo se za 60 slik na sekundo. Funkcija

setDisplayStats (izvorna koda 6.1) prikazuje statusno vrstico med igranjem, kjer lahko

vidimo število prikazanih slik na sekundo v realnem času (slika 6.1). Tako lažje

optimiziramo igro, saj lahko preverimo, kdaj točno se število slik zmanjša.

// turn on display FPS director->setDisplayStats(true); // set FPS. director->setAnimationInterval(1.0f / 60);

IZVORNA KODA 6.1: VKLJUČITEV/IZKLJUČITEV STATUSNE VRSTICE.

SLIKA 6.1: PRIKAZ STATUSNE VRSTICE.

Nekatere podatke je treba preveriti vsako sekundo, nekatere pa samo ob določenih

dogodkih. Tako je na primer podatke na uporabniškem vmesniku, kot so točke življenj in

število točk, treba preveriti samo ob določenem dogodku. Najbolje je ustvariti funkcijo, ki

bo te podatke posodobila, ko se zgodi ta dogodek. Tako se zmanjša število dogodkov, ki

se izvajajo vsako sekundo, in razbremeni procesorska moč za ostale naloge.

Pomembno je ustvarjanje objektov na zaslonu in njihovo brisanje (izvorna koda 6.2).

Objekte lahko zbrišemo, ko se uničijo ali zapustijo igralno površino. Za naše objekte smo

vnaprej določili prostor. Tako je možno spremljati vsak objekt in ga uničiti, ko je to

potrebno.


57 | S t r a n

void Meteor::resetMeteor() { live = false; this->unscheduleUpdate(); sprite->stopAllActions(); sprite->removeFromParentAndCleanup(true); }

IZVORNA KODA 6.2: UNIČEVANJE OBJEKTOV.

Nasveti in triki za boljšo optimizacijo:

– uporabljati SpriteBatchNode;

– vnesti teksture od najvišjih proti najnižjim;

– sproščanje neuporabljenih virov;

– sproščanje dodatnih virov, ko dobimo opozorilo o pomanjkanju pomnilnika;

– uporaba sekundarnih programov za optimiziranje teksture;

– izogibati se uporabi slik JPG;

– za glasbo v igri uporabljati mp3 ali drugo obliko stisnjenih glasbenih datotek.

6.2 Možne izboljšave

Danes se igre izboljšujejo, dokler obstajajo tisti, ki jih igrajo. Pomembne so redne

posodobitve in dodajanje nove vsebine. Pomembna je tudi komunikacija razvijalcev,

igralcev in igre. Nove vsebine dajo igri svežino in tako podaljšajo njeno življenjsko dobo.

Zato bomo izboljšavo naše igre spremljali z dveh zornih kotov. Prvi je sama igrivost igre,

ki se nanaša na dodajanje novih igralnih mehanik, ki bodo igralcu dale nove možnosti

igranja. Drugi je optimizacija, v okviru katere bomo preučili, kaj bi lahko spremenili, da bi

se igra bolje optimizirala.

Igrivost

Našo igro lahko izboljšamo na več načinov. Z dodajanjem različnih ladij bi jo lahko

popestrili in tako bi imel igralec na voljo izbiro lastnega modela ladje. To pa bi nam hkrati

lahko dodatno otežilo razvoj igre, ker bi bilo treba ustvariti več modelov ladij, kar zahteva

veliko časa.

Različni ‘‘super predmeti’‘, kot so ščit ali več vrst projektilov, bi lahko igri dodali novo

mehaniko, saj bi igralcu dali možnost pridobivanja teh predmetov. Treba bi bilo oblikovati


58 | S t r a n

več vrst projektilov, določiti njihove lastnosti, kot so hitrost, količina škode, način streljanja

in ostalo. Paketi prve pomoči bi lahko igralcu izboljšali trenutno zdravje. Tako bi lahko

igralci z izredno nizkim številom življenjskih točk poskušali pridobiti te pakete prve pomoči.

Implementacija več animacij, kot so razne eksplozije, bi se ravno tako lahko smatrala za

izboljšavo igre, saj se s tem nadgradi vizualni vtis igre. Pomemben del igre je njen

umetniški stil in z uporabo enakega vizualnega stila za vse objekte se izboljša splošni vtis

igre. Mi smo bili omejeni z viri, zato smo jih pridobili z različnih strani, kar je vplivalo na

raznolik stil igre, ki ne deluje popolnoma celovito.

Izboljšava optimizacije

Igro je mogoče izboljšati z boljšo optimizacijo, in sicer z uporabo optimalnih metod in

boljšo organizacijo strukture igre. Ena izmed metoda je uporaba datotek sprite sheet. To

so datoteke, ki vsebujejo več manjših slik, ki jih uporabljamo v igri. Služijo

poenostavljenemu upravljanju z viri in zmanjšujejo število klicev za risanje, saj je treba

prebrati samo eno datoteko. Mi smo uporabili datoteke sprite sheet, toda ne na najbolj

optimalen način, saj smo ustvarili več datotek za različne dele igre. Tako imamo datoteke

sprite sheet za projektile, asteroide, eksplozijo in glavni meni. Za boljšo optimizacijo bi

lahko vse to postavili v eno datoteko in tako zmanjšali porabo virov. Za boljšo optimizacijo

je treba vnaprej naložiti vse datoteke, ki jih bomo uporabljali. Mi smo naložili nekatere

datoteke pri nalaganju igre, nekateri predmeti pa se naložijo med igro. Ravno tako je

možno izboljšati našo strukturo igre in s tem tudi njeno logiko. Boljša organizacija

razredov in njihovih atributov bi nam olajšala razvoj igre.

6.3 Težave

Pri izdelavi praktičnega dela našega zaključnega dela smo naleteli na razne težave.

Nekatere so bile enostavne in smo jih lahko hitro odpravili, za druge pa smo potrebovali

več časa in iskali dodatno pomoč na spletu, da bi jih odstranili. Prva težava, s katero smo

se srečali, je bila nepoznavanje igralnega pogona. Treba je bilo preučiti dokumentacijo in

preizkusiti igralni pogon na nekaj enostavnih primerih. Tudi sama namestitev je bila precej

zahtevna. Nadalje je bilo treba pridobiti vso potrebno programsko opremo, kot so SDK za

Android, Java in Python. Namestitev smo opravili s pomočjo ukazne vrstice, kar bi

mnogim začetnikom predstavljalo težavo. Lokalne spremenljivke smo morali na računalnik

namestiti tako, da je dana ukazna vrstica prepoznala Python ukaze. Po namestitvi smo

naleteli na novo težavo v razvojnem okolju Visual Studio, kajti najprej smo uporabili


59 | S t r a n

starejšo različico VS 2013, ki je imela kar nekaj težav z novejšo različico igralnega pogona

Cocos2d-x. Zato smo na koncu le zamenjali razvojno okolje na VS 2015. Težave smo

imeli z zvočnim delom igralnega pogona Cocos2d-x. Namreč njegov začetni pogon za

zvok SimpleAudioEngine ni deloval, kot smo pričakovali. Pomoč smo poiskal na uradnih

forumih, kjer smo našli rešitev v eksperimentalnem zvočnem pogonu AudioEngine, ki je

zadostoval našim potrebam. Cocos2d-x je nov igralni pogon in se nenehno razvija.

Nekatere funkcije so imele drugo ime v novi različici in vse te spremembe smo morali

ročno spremeniti v izvorni kodi igre. Vse 3D-modele, ki smo jih uporabili pri igri, smo

morali pretvoriti v format, ki ga igralni pogon podpira. Vse 3D-modele smo tako spremenili

v '.c3t' format in vsakemu dodali primerno teksturo.

6.4 Izvoz igre na različne platforme

Cocos2d-x je večplatformski igralni pogon. To pomeni, da nam omogoča razvoj raznih

aplikacij za več platform naenkrat. To je pomembno pri razvoju raznih aplikacij, katerih cilj

je, da se nahajajo na več platformah naenkrat. Igralni pogon Cocos2d-x omogoča, da

napišemo samo eno izvorno kodo aplikacije in s pomočjo enostavnega postopka

aplikacijo izvažamo z ene platformo na drugo.

Mi smo našo igro ustvarili na osebnem računalniku, zatem pa smo jo s pomočjo igralnega

pogona in njegove funkcionalnosti izvozili na ostale platforme. Postopek je zelo

enostaven. Večji del postopka poteka prek ukazne vrstice, saj naš igralni pogon nima

svojega grafičnega vmesnika, kar lahko predstavlja začetniku težave, vendar je zaradi

tega hitrejši in prilagodljivejši.

Med izvozom igre na platformo Android smo najprej namestili okolje za Android. Odločili

smo se za Android Studio. Treba je bilo urediti datoteko android.mk. Tukaj smo dodali

vse razrede in vire, ki smo jih uporabili med izdelavo win32 aplikacije. To smo naredili

tako, da smo pod LOCAL_SRC_FILES := navedli vse razrede in pot do njih. Tukaj se

lahko vključijo vse dodatne knjižnice, ki jih uporabljamo med razvojem igre ali aplikacije.


60 | S t r a n

SLIKA 6.2: DODAJANJE RAZREDOV V DATOTEKO ANDROID.MK.

Ko smo uredili potrebne datoteke, smo morali nastaviti lokalne spremenljivke. Igralni

pogon Cocos2d-x uporablja ukaze, za izvoz na različne platforme. Ukaz za izvoz v

aplikacijo Android je cocos compile -p android. Argument -p nakazuje, za katero

platformo želimo ustvariti aplikacijo.

SLIKA 6.3: PREVAJANJE APLIKACIJE ZA ANDROID.

Igralni pogon ustvari Android .apk datoteko [25], ki jo lahko uvozimo na neko Android

napravo. Datoteka .apk se nahaja v direktoriju proj.android->bin.


61 | S t r a n

SLIKA 6.4: IGRA NA ANDROID EMULATORJU IN ANDROIDNI MOBILNI NAPRAVI.

6.5 Rezultati preizkušanja

Igro smo preizkusili na dveh platformah. Ocenili smo, koliko povprečno slik na sekundo je

bilo, količino uporabljenega spomina in kakšne so bile obremenitve procesorja. Rezultati

so pokazali, da so razlike med dvema platformama zelo majhne. Ko se je istočasno

pojavilo več objektov, je prišlo do krajših zaustavitev igre. To ustavljanje je trajalo okoli 0,2

milisekunde, kar ni veliko, je pa opazno. To se je zgodilo zato, ker igre nismo popolnoma

optimizirali, kar zadeva vire in način, kako jih igra odčitava. V grafu (slika 6.5) so prikazani

rezultati preizkušanja števila sličic na sekundo. Rezultati so pričakovani in med

platformama so se pojavila zelo majhna odstopanja, namreč naša igra ni preveč zahtevna

in ker je danes strojna oprema za mobilne naprave zelo napredna, je na njej možno igrati

vse naprednejše aplikacije in igre.


62 | S t r a n

SLIKA 6.5: POVPREČNO ŠTEVILO SLIK V SEKUNDI.

Preizkušanje spomina in obremenitve procesorja smo opravili v Visual Studiu. Kot je

razvidno (slika 6.6), naša igra v povprečju uporablja okoli 100 MB spomina,

obremenjenost procesorja pa se giblje med 0 in največ 15 %. Procesor se uporablja za

ustvarjanje učinka delcev in izračunavanja trkov med predmeti.

SLIKA 6.6: PREIZKUŠANJE PORABE SPOMINA IN OBREMENJENOSTI PROCESORJA .

59

56

30

32

34

36

38

40

42

44

46

48

50

52

54

56

58

60

Štev

ilo s

lik v

sek

un

di

Povprečno število slik v sekundi

PC Platforma Android Platforma


63 | S t r a n

7 ZAKLJUČEK

Cilj in obenem tudi namen pričujočega diplomskega dela je prikaz razvoja videoigre.

Danes srečujemo na vsakem koraku ogromno število iger, ki so razširjene na več

platform. Zato je bila ključnega pomena izbira igralnega pogona, ki omogoča razvoj igre

na več platformah.

Število igralnih pogonov je zelo veliko in vsak izmed njih ima svojo prednost. Za izbiro

najprimernejšega igralnega pogona si je zato treba vzeti dovolj časa in vse pogone, ki so

na voljo, temeljito preučiti. Pomembno je vedeti, katere so poglavitne funkcionalnosti,

kakšna je njihova zahtevnost in dostopnost. Izbira pravilnega igralnega pogona namreč

zmanjša čas razvoja igre. Zato je pred samim razvojem smiselno preučiti igralni pogon in

– če je le možno – ustvariti enostavni prototip igre. Po izbiri igralnega pogona je zaželeno

preučiti tudi njegovo dokumentacijo in spoznati njegove osnove.

Poleg igralnega pogona je pri razvoju igre pomembna tudi zamisel. To je osnova vsake

igre in dobri temelji nam zagotavljajo enostavnejši razvoj igre. V delu smo navedli

nekatere izmed znanih tehnik ustvarjanja boljše ideje. Preučili smo, kako razdelati

zamisel, kateri so njeni najpomembnejši deli in kako v končni fazi iz zamisli razviti projekt,

ki bo služil nadaljnjemu razvoju v igro.

Kot začetniki v razvoju iger smo se držali pravila ''Make it simple''. Ključno pri razvoju igre

je, da je prvi projekt enostaven, saj bo zagotovo z vsakim končanim projektom naslednji

razvoj veliko lažji. Pomembno je vedeti, da končni izdelek nikoli ne uspe čisto tako, kot

smo si ga zamislili. Za popolno realizacijo zamišljenega proizvoda je potrebno veliko časa

in znanja. To znanje se pridobiva z izkušnjami in ravno zato je vsak zaključen projekt zelo

pomemben. Poseben pomen pri razvoju ima najosnovnejši sprejemljiv produkt (NSP), ki

predstavlja temelje, na katerih lahko nadaljujemo razvoj igre.

Praktični del pričujočega dela predstavlja razvoj igre. Po izbiri igralnega pogona je bilo

treba zastaviti dobre temelje. Delitev igre na enostavne dele je olajšal njen razvoj. Sklenili

smo, da je razvoj igre zapletena naloga, kajti poleg poznavanja programiranja in


64 | S t r a n

programskih jezikov zahteva tudi znanja z drugih področij, kot sta glasba in oblikovanje.

Implementirali smo igro SpaceShooters.

Zamisel in osnovo mehanike smo vzeli iz stare, ampak zelo znane igre Space Invaders.

Za igralni pogon smo izbrali Cocos2d-x. Preden začetkom njegove uporabe smo morali

nastaviti razvojna orodja, kot so Python, Java in ostala.

Končni izdelek, ki smo ga dobili v praktičnem delu diplomskega dela, bi lahko zagotovo še

izboljšali. To bi lahko naredili na področju oblikovanja ali z dodajanjem novih mehanik v

igro, kot na primer več vrst orožij. Igro je možno bolje optimizirati z uporabo optimalnih

funkcij in metod. To bi bilo zelo dobrodošlo, če bi šlo za zahtevnejšo igro, ki bi uporabljala

veliko virov. Naša igra ni toliko zahtevna, zatorej omenjena optimizacija ne bi prinesla

večjih opaznih sprememb.


65 | S t r a n

VIRI

[1] R. Chikhani, ‘‘The History Of Gaming: An Evolving Community,’‘ 10 2015. [Mrežno].

Dosopno na: https://techcrunch.com/2015/10/31/the-history-of-gaming-an-evolving-

community/. [Poskus dostopa 16 8 2017].

[2] ‘‘Video game - Wikipedia,’‘ [Mrežno]. Dostopno na:

https://en.wikipedia.org/wiki/Video_game. [Poskus dostopa 20 8 2017].

[3] D. Winter, ‘‘Pong story,’‘ 1 10 2013. [Mrežno]. Dostopno na: http://www.pong-

story.com/intro.html. [Poskus dostopa 10 9 2017].

[4] J. Rignall, ‘‘A Brief History of Games Journalism,’‘ 31 12 2015. [Mrežno]. Dostopno

na: http://www.usgamer.net/articles/a-brief-history-of-games-journalism. [Poskus

dostopa 9 5 2017].

[5] ‘‘Golden age of arcade video games - Wikipedia,’‘ [Mrežno]. Dosopno na:

https://en.wikipedia.org/wiki/Golden_age_of_arcade_video_games. [Poskus dostopa

16 8 2017].

[6] ‘‘Game engine - Wikipedia,’‘ [Mrežno]. Dostopno na:

https://en.wikipedia.org/wiki/Game_engine. [Poskus dostopa 28 4 2017].

[7] ‘‘Game design - Wikipedia,’‘ 12 10 2016. [Mrežno]. Dostopno na:

http://en.wikipedia.org/wiki/Game_design.

[8] N. Weiss, ‘‘Selecting a Cross-platform Game Engine,’‘ 14 5 2014. [Mrežno]. Dostopno

na: http://www.binpress.com/blog/2014/05/14/selecting-cross-platform-game-engine/.

[9] ‘‘Cocos2d - Wikipedia,’‘ [Mrežno]. Dostopno na: https://en.wikipedia.org/wiki/Cocos2d.

[Poskus dostopa 20 5 2017].

[10] Cocos2d, ‘‘Coco2d-x External Tutorials,’‘ 6 8 2017. [Mrežno]. Dostopno na:

http://www.cocos2d-x.org/wiki/External_Tutorials.

[11] ‘‘Sprite (computer graphics) - Wikipedia,’‘ 13 8 2017. [Mrežno]. Dostopno na:

https://en.wikipedia.org/wiki/Sprite_(computer_graphics).


66 | S t r a n

[12] A. Vigo, ''Sprites in Cocos2d-x,'' [Mrežno]. Dostopno na:

http://vigogames.com/2017/01/26/sprites-in-cocos2d-x/. [Poskus dostopa 21 5 2017].

[13] bunnyhero, ‘‘Bunny meets cocos2d-x,’‘ [Mrežno]. Dostopno na:

http://dev.bunnyhero.org/2013/10/bunny-meets-cocos2d-x-part-1-sprite-sheets-and-

animations/. [Poskus dostopa 4 6 2017].

[14] Chukong Technologies, ‘‘Coco2d-x - Actions,’‘ 2014. [Mrežno]. Dostopno na:

http://cocos2d-x.org/docs/programmers-guide/actions/index.html. [Poskus dostopa 21

5 2017].

[15] R. Engelbert, Cocos2d-X by Example Beginner's Guide, Birmingham: Packt

Publishing Ltd, 2013.

[16] Maxxx, ‘‘Writing Games with C++ for Android on a PC - Setting Up,’‘ [Mrežno].

Dostopno na: https://www.codeproject.com/Articles/802626/Writing-Games-with-

Cplusplus-for-Android-on-a-PC-S. [Poskus dostopa 7 5 2017].

[17] G. Qu, ‘‘Cocos2d-x Tutorial for Beginners,’‘ 30 4 2015. [Mrežno]. Dostopno na:

https://www.raywenderlich.com/95835/cocos2d-x-tutorial-beginners.

[18] F. Hussain, G. Jones i A. Gurung, Create iOS and Android games from scratch using

Cocos2d-x, Birmingham: Packt Publishing Ltd., 2014.

[19] S. Itterheim, ‘‘Learn & Master Cocos2D Game Development,’‘ 12 10 2016. [Mrežno].

Dostopno na: http://www.learn-cocos2d.com/ .

[20] ‘‘Computer animation -Wikipedia,’‘ 13 9 2017. [Mrežno]. Dostopno na:

https://en.wikipedia.org/wiki/Computer_animation. [Poskus dostopa 13 8 2017].

[21] ‘‘Parallax scrolling - Wikipedia,’‘ [Mrežno]. Dostopno na:

https://en.wikipedia.org/wiki/Parallax_scrolling. [Poskus dostopa 29 5 2017].

[22] S. Bone, ‘‘Parallax Scrolling: A Simple, Effective Way to Add Depth to a 2D Game,’‘

[Mrežno]. Dostopno na: https://gamedevelopment.tutsplus.com/tutorials/parallax-

scrolling-a-simple-effective-way-to-add-depth-to-a-2d-game--cms-21510. [Poskus

dostopa 29 5 2017].

[23] ‘‘Coco2d-x Tutorial Series,’‘ GameFromScratch, [Mrežno]. Dostopno na:


67 | S t r a n

http://www.gamefromscratch.com/post/2014/10/11/Cocos2d-x-Tutorial-Series-Game-

loops-Updates-and-Action-Handling.aspx. [Poskus dostopa 5 5 2017].

[24] Android, ‘‘Android development,’‘ 2017 8 11. [Mrežno]. Dostopno na:

https://www.android.com/.

IGRE Z IGRALNIM POGONOM COCOS2D-X · Cocos2d-x game engine Key words: game engine, game...

Documents

Transcript of IGRE Z IGRALNIM POGONOM COCOS2D-X · Cocos2d-x game engine Key words: game engine, game...