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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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)
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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].
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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,
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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].
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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]
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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]
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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).
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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:
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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).
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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].
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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].
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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).
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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).
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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].
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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.
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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).
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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:
Razvoj večplatformske igre z igralnim pogonom Cocos2d-x
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/.