Razvoj mobilne tretjeosebne strelske igre s pogonom Unreal ... · role playing games). Koda je...

UNIVERZA V MARIBORU

FAKULTETA ZA ELEKTROTEHNIKO,

RAČUNALNIŠTVO IN INFORMATIKO

Rok Pušnik

RAZVOJ MOBILNE TRETJEOSEBNE STRELSKE IGRE S POGONOM UNREAL

ENGINE 4

Diplomsko delo

Maribor, september 2016

RAZVOJ MOBILNE TRETJEOSEBNE STRELSKE IGRE S

POGONOM UNREAL ENGINE 4

Diplomsko delo

Študent: Rok Pušnik

Študijski program: Visokošolski strokovni študijski program

Računalništvo in informacijske tehnologije

Mentor: viš. pred. dr. Simon Kolmanič

i

Zahvala

Zahvaljujem se Valentini za vso podporo in pomoč v času študija. Zahvaljujem se tudi mentorju viš. pred. dr. Simonu Kolmaniču za nasvete in vodenje pri izdelavi diplomskega dela.

ii

Razvoj mobilne tretjeosebne strelske igre s pogonom Unreal Engine 4

Ključne besede: grafični pogoni, računalniška grafika, Android, Unreal Engine

UDK: 004.921(043.2)

Povzetek

V diplomskem delu raziščemo pogon Unreal Engine 4, ki služi kot orodje za izdelovanje iger

na več platformah. Spoznamo osnovno delovanje orodij, ki jih pogon ponuja razvijalcem in

pridobljeno znanje uporabimo na praktičnem primeru mobilne igre. Najprej si ogledamo

razvoj programa skozi različne generacije in stanje aktualne različice. Sledi raziskava

delovanja urejevalnikov stopenj, uporabniških vmesnikov, animacij, zvoka in materialov.

Podrobneje si ogledamo pogonov lasten vizualni skriptni sistem Blueprint. V drugem delu

razvijemo tretjeosebno strelsko igre za ciljno platformo Android.

iii

Mobile third-person shooting game development using Unreal Engine 4

Key words: game engines, computer graphics, Android, Unreal Engine

UDK: 004.921(043.2)

Abstract

This thesis presents Unreal Engine 4, a tool used in the design of multi-platform games. We

look at the engine's history and the development of its features. We examine the tools it

offers for level design, user interface, animation, sound and material editing. Also

presented, is the unique visual scripting system Blueprint. The gained knowledge is then

used in the development of a third-person shooting game deployed for Android devices.

iv

KAZALO

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

2 GRAFIČNI POGON UNREAL ............................................................................................... 3

2.1 Splošno o pogonu ........................................................................................................................... 3

2.2 Zgodovina pogona .......................................................................................................................... 5

3 ORODJA GRAFIČNEGA POGONA UNREAL ENGINE 4 ................................................. 9

3.1 Urejevalnik stopenj ........................................................................................................................ 9

3.2 Urejevalnik UMG .......................................................................................................................... 10

3.3 Urejevalnik animacij ..................................................................................................................... 11

3.4 Zvok ............................................................................................................................................. 14

3.5 Urejevalnik materialov ................................................................................................................. 15

3.6 Vizualni skriptni sistem Blueprint ................................................................................................. 16

4 PREDSTAVITEV IGRE ....................................................................................................... 19

4.1 Zvrst igre ...................................................................................................................................... 19

4.2 Igra Droid Journey ........................................................................................................................ 20

5 IMPLEMENTACIJA IGRE .................................................................................................. 23

5.1 Projektne nastavitve .................................................................................................................... 23

5.2 Junak in sovražniki ....................................................................................................................... 24

5.3 Orožje in projektil......................................................................................................................... 29

5.4 Umetna inteligenca ...................................................................................................................... 30

v

5.5 Animacije ..................................................................................................................................... 33

5.6 Izdelava stopnje ........................................................................................................................... 36

5.6.1 Pokrajina ........................................................................................................................................ 36

5.6.2 Premikajoče platforme .................................................................................................................. 37

5.6.3 Pobiranje predmetov ..................................................................................................................... 38

5.7 Zvok ............................................................................................................................................. 39

5.8 Uporabniški vmesniki ................................................................................................................... 39

5.9 Gradnja za sisteme Android ......................................................................................................... 39

6 SKLEP .................................................................................................................................... 41

7 VIRI ........................................................................................................................................ 42

vi

KAZALO SLIK

SLIKA 2.1: IGRA UNREAL ......................................................................................................................................... 4

SLIKA 2.2: SIMULACIJA PARIŠKEGA APARTMAJA ............................................................................................................ 4

SLIKA 2.3: IGRA GEARS OF WAR ............................................................................................................................... 6

SLIKA 2.4: PRIMER PRIŽIGA LUČI OB PRITISKU NA STIKALO V SISTEMU KISMET ..................................................................... 7

SLIKA 3.1: UPORABNIŠKI VMESNIK UREJEVALNIKA ....................................................................................................... 10

SLIKA 3.2: ZAVIHEK DESIGNER UREJEVALNIKA UMG ................................................................................................... 11

SLIKA 3.3: NAČINI UREJANJA V UREJEVALNIKU PERSONA; A) SKELETNI NAČIN, B) MREŽNI NAČIN, C) ANIMACIJSKI NAČIN, D) NAČIN

GRAFA ....................................................................................................................................................... 14

SLIKA 3.4: SOUND CUE UREJEVALNIK ....................................................................................................................... 15

SLIKA 3.5: PODATKOVNI PRIKLJUČKI ......................................................................................................................... 17

SLIKA 3.6: PRIMER VOZLIŠČA Z VHODI (LEVO) IN IZHODI (DESNO) ................................................................................... 18

SLIKA 4.1: PRIMER IGRE DONKEY KONG ................................................................................................................... 20

SLIKA 4.2: IGRA DROID JOURNEY – PATRULJA SOVRAŽNIKA ........................................................................................... 21

SLIKA 4.3: IGRA DROID JOURNEY – PREHOD ČEZ OAZO ................................................................................................ 22

SLIKA 4.4: IGRA DROID JOURNEY – SPOPAD V VOTLINI ................................................................................................. 22

SLIKA 5.1: PRIMER DELOVANJA KRMILNE PALICE ZA MERJENJE IN STRELJANJE .................................................................... 23

SLIKA 5.2: DEKLARACIJA SPREMENLJIVK IN FUNKCIJ V DATOTEKI GLAVE (.H)...................................................................... 25

SLIKA 5.3: IMPLEMENTACIJE FUNKCIJ V IZVORNI DATOTEKI (.CPP) ................................................................................... 26

SLIKA 5.4: KOMPONENTE RAZREDA MYCHARACTER .................................................................................................... 26

SLIKA 5.5: DOGODEK BEGINPLAY ............................................................................................................................ 27

SLIKA 5.6: POSTOPEK MERJENJA IN STRELJANJA .......................................................................................................... 28

SLIKA 5.7: ZGRADBA RAZREDA WEAPON ................................................................................................................... 29

SLIKA 5.8: VEDENJSKO DREVO SOVRAŽNIKA ............................................................................................................... 31

SLIKA 5.9: VIDNO POLJE ......................................................................................................................................... 32

SLIKA 5.10: SPREMEMBA STANJA ZA BOJ IN NASTAVITEV SPREMENLJIVKE PITCH ................................................................ 33

SLIKA 5.11: PREHODNI PROSTOR GIBANJA ................................................................................................................. 34

SLIKA 5.12: PREHODNI PROSTOR MERJENJA .............................................................................................................. 35

SLIKA 5.13: STROJ STANJ ....................................................................................................................................... 36

SLIKA 5.14: PREMIK PLATFORME, OKNO TRACKS (SPODAJ) IN SCENSKI POGLED S PRIKAZOM PREMIKA (ZGORAJ) ...................... 37

SLIKA 5.15: CEKIN IN ZDRAVILNI PAKET ..................................................................................................................... 38


1

1 UVOD

V današnji družbi igre pridobivajo kulturen pomen in spadajo v eno izmed največjih kategorij

zabavne industrije. Dolga leta so bile videne kot dejavnost, s katero se ljudje sproščamo v

prostem času, danes pa se z veliko hitrostjo širijo tudi na področje tekmovalnih športov.

Tako kot lahko spremljamo prvenstva na področju nogometa, košarke ali drugih popularnih

športov, lahko že nekaj let spremljamo tudi velike pokale iger, kot so Dota 2, League of

Legends in Counter Strike: Go.

K popularnosti iger močno prispeva tudi bliskovit razvoj mobilnih naprav, brez katerih si

danes skoraj ne predstavljamo vsakdanjega življenja. V devetdesetih letih je število

uporabnikov mobilnih naprav hitro narastlo. Veliko povpraševanje je povzročilo tehnološke

inovacije, ki so omogočale nastanek prvih mobilnih iger. Prva med njimi je Tetris (1994) na

napravi Hagenuk MT-2000, z velikim uspehom pa ji sledi Snake (1997). Obe igri sta izšli

kot sestavni del programske opreme telefona, uporabljali sta monokromatično točkovno

matrično grafiko, njune osnovne mehanike pa so tipke telefonske številčnice. Na

Japonskem, na začetku 21. stoletja, nastane kultura mobilnih telefonov, veliko preden ta

doseže Evropo ali ZDA in še danes Japonska velja za dominantno na področju trga mobilnih

iger. Prvi evropski portal za prenašanje mobilnih iger je bil francoski »Les Games« [18]. Do

sodobnih mobilnih iger pa lahko dostopamo preko trgovin z aplikacijami (Google Play, App

Store), kjer nas preseneti širok spekter izbire samih zvrsti iger, kot tudi njihove tehnične

izvedbe. Prenosljivost, zmogljivi procesorji, zasloni visoke ločljivosti in baterije z vedno

daljšo življenjsko dobo so lastnosti mobilnih naprav, ki ustvarjajo idealne pogoje za razcvet

trga iger. Rezultat tega je trg, poplavljen z različnimi izdelki, kjer vrh prepoznavnosti doseže

le peščica najuspešnejših, večina pa tone v pozabo. Razvijalci se morajo zato še posebej

potruditi, najprej z dobro idejo, potem pa tudi izpeljavo, stabilnostjo in vizualno

izpopolnjenostjo. Tukaj pridejo na pomoč grafični pogoni.

Grafični pogoni so osnova za stvaritev in razvoj iger za mobilne telefone, konzole in osebne

računalnike. Ponujajo temeljne funkcionalnosti, ki so sestavne komponente vsake igre, kot


2

so upodabljanje, fizikalni pogoni, zaznavanje trkov, animacije, umetna inteligenca itd. V

diplomskem delu se bomo na te elemente osredotočili s pogonom Unreal Engine 4 (UE4),

ki velja za enega izmed vodilnih na področju grafične dodelanosti.

V drugem poglavju diplomske naloge si bomo ogledali napredek pogona skozi zgodovino

in značilnosti trenutne generacije. V tretjem poglavju bomo raziskali orodja, ki jih za izdelavo

osnovnih elementov iger ponuja UE4. S pomočjo teh orodij smo izdelali mobilno strelsko

igro Droid Journey, katere bistvo predstavimo v četrtem poglavju. V petem poglavju pa

bomo opisali dejanske postopke, ki smo jih uporabljali ob samem razvoju igre.


3

2 GRAFIČNI POGON UNREAL

2.1 Splošno o pogonu

Unreal Engine je grafični pogon ameriškega podjetja Epic Games iz Severne Karoline,

namenjen razvoju iger. Prvič je bil predstavljen leta 1998 z izidom zelo dobro sprejete

prvoosebne strelske igre Unreal (slika 2.1). Čeprav je bil namenjen predvsem za

prvoosebne igre, se je kmalu izkazalo, da ustreza tudi drugim žanrom, kot so igre s

skrivanjem, igre MMORPG (masovno-več igralsko spletno igranje domišljijskih vlog –

massively multiplayer online role-playing games) in igre tipa RPG (igre z igranjem vlog –

role playing games). Koda je napisana v programskem jeziku C++ kar daje pogonu visoko

stopnjo prenosnosti [19].

Trenutna generacija pogona Unreal 4.12.5 (september 2016) podpira naslednje vmesnike:

DirectX 11 in 12 (za platformi Microsoft Windows in Xbox One),

OpenGL (za OS X, Linux, PlayStation 4, iOS, Android in Ouya platforme),

Vulkan (za Android),

Metal (za iOS) in

JavaScript/WebGL (za spletne brskalnike s HTML5 podporo) [19].


4

Slika 2.1: Igra Unreal

Poleg pogonov Unity, CryEngine, Frostbite in še nekaterih drugih, je Unreal eden izmed

popularnejših grafičnih pogonov za razvijanje iger. Med temi najbolj izstopa pri grafični

zmogljivosti in izjemno odprtem licenčnem modelu. Grafično lahko doseže skoraj foto

realistične simulacije okolja, kot lahko vidimo na primeru simulacije pariškega apartmaja na

sliki 2.2. Uporaba pogona in vseh njegovih funkcionalnosti je za testiranje in izobraževanje

popolnoma brezplačna. Tudi komercialna uporaba je deloma brezplačna, in sicer si Epic

Games pridržujejo pravico do 5 % prihodka na četrtletje, ko igra prvič preseže vrednost

3000 $ [6].

Slika 2.2: Simulacija pariškega apartmaja


5

Nekaj iger, ki je doživelo uspeh skozi različne generacije pogona [17]:

Mass Effect (2007, BioWare),

BioShock (2007, 2K Games),

Tom Clancy's serije iger (2002 - 2013, Ubisoft),

Batman: Arkham Asylum (2009, Rocksteady Studios),

Dishonored (2012, Arkane Studios),

Street Figther V (2016, Capcom).

2.2 Zgodovina pogona

Prva različica Unreal Engine 1 je vključevala upodabljanje (angl. rendering), zaznavanje

trkov (angl. collision detection), umetno inteligenco (angl. artificial intelligence), vidljivost

(angl. visibility), možnost igranja preko mreže, skriptiranje, zvočni pogon, sistem za

animacije [3] in upravljanje datotečnega sistema. Ponujala je napredno programsko

rasterizacijo in strojno pospešeno upodabljanje s pomočjo vmesnika za namensko

programiranje Glide API, namenjenega za grafične procesorje 3dfx. Glide API je bil kasneje

posodobljen za OpenGL in Direct3D, ki sta, skupaj z igranjem preko mreže, z izidom spletne

strelske igre Unreal Tournament doživela velik skok v podpori. Popularnost pogona gre

pripisati njegovi modularni arhitekturi in lastnemu skriptnemu jeziku UnrealScript, ki je

omogočal preprosto izdelovanje modifikacij že obstoječih iger. UnrealScript je ustvaril Tim

Sweeney, ustanovitelj podjetja Epic Games, in je bil zasnovan za preprosto, visokonivojsko

programiranje iger [19]. Je objektno orientiran in predstavlja neke vrste variacijo med Javo

(okolje brez kazalcev s samodejnim čiščenjem pomnilnika, preprosto dedovanje iz enega

razreda, močno tipiziranje) in C++ (prekrivanje operatorjev) [12]. Zaradi velikega števila

razvijalcev iger in modifikacij in njihove zainteresiranosti so Epic Games leta 2001

vzpostavili spletno skupnost Unreal Developer Network, kjer so se zbirali številni vodiči in

vsa posodobljena dokumentacija pogona [1].

Druga različica pogona Unreal Engine 2 je izšla leta 2002 z brezplačno igro America's Army,

razvito s strani ameriške vojske [15]. Jedro kode in pogon upodabljanja sta bila v novi

različici popolnoma prenovljena, dodan je bil urejevalnik stopenj (angl. level editor)

UnrealEd [19], fizikalni pogon Karma, sistem delcev (angl. particle system) in integriran

sistem za ustvarjanje filmskih odsekov (angl. cutscenes) Matinee [1]. Posodobitev Unreal

Engine 2.5 je izboljšala zmogljivost upodabljanja, dodala fizikalni pogon za vozila in


6

implementirala podporo za 64-bitne sisteme. Kasneje je izšla še različica Unreal Engine 2X,

ki je bila posebej optimizirana za platformo Xbox.

Z izidom igre Gears of War (slika 2.3) je leta 2006 izšla tretja različica pogona - Unreal

Engine 3. Ta je že izkoriščal moč popolnoma programabilnih senčilnikov, za razliko od

predhodnih verzij, ki so uporabljale fiksne funkcijske cevovode in je delal izračune na ravni

pikslov, ne več oglišč. Sprva je podpiral platforme Windows, Xbox 360, PlayStation 3,

kasneje še platformi Android, iOS in OS X. Epic Games so, s pomočjo podjetja NVIDIA in

podporo DirectX11, postavili nova merila na področju realistične računalniške grafike.

Slika 2.3: Igra Gears of War

Ena izmed izstopajočih novosti tretje različice pogona je bila gotovo Unreal Kismet (slika

2.4). Kismet je sistem vizualnega skriptiranja, ustvarjen z namenom, da razvijanje iger

omogoči večjemu krogu ljudi, tudi tistim, ki niso tako vešči v programiranju. Omogočal je

snovanje kompleksnih skriptiranih sekvenc na hiter in enostaven način. Kismet je poganjal

vse od najbolj preprostih nalog, kot je odpiranje vrat ob pritisku na pravi gumb, do

zahtevnejših sekvenc dogodkov [1]. Unreal Engine 3 je, poleg razvijanja video iger, svojo

uporabnost razširil na različna področja. Popularna otroška risanka LazyTown ga je

uporabljala za ustvarjanje okolja v realnem času s pomočjo zelenega platna (angl. green

screen), ameriške vladne organizacije, kot so FBI, so pogon uporabljale za treniranje v obliki

simulacij, uporablja pa se tudi pri nekaterih programskih opremah za animacijo [19].


7

Pravice za uporabo pogona so se izdajale z licenčno pogodbo, katere najemniki so bila

večinoma večja podjetja, ki so se posvečala razvoju prvorazrednih iger. Novembra 2009 pa

je, z vsemi funkcionalnostmi tretje generacije, izšel Unreal Development Kit. Ta je bil za

nekomercialne namene brezplačen, vendar ni vključeval izvorne kode C++ [19].

Slika 2.4: Primer prižiga luči ob pritisku na stikalo v sistemu Kismet

Leta 2012 je bila, po devetih letih razvoja, izdana najnovejša generacija pogona - Unreal

Engine 4. Ta različica vsebuje številne funkcionalnosti, ki pospešijo iteracijski čas samega

razvoja iger. Omogoča spreminjanje kode C++ med izvajanjem pogona. Vizualni sistem

skriptiranja Blueprint je naslednik sistema Kismet in omogoča še učinkovitejši razvoj kode

ter razhroščevanje v živo. Razvijalcem omogoča popolnoma samostojen razvoj celotne

igre, brez dejanskega dela na kodi C++. Marca 2014 je podjetje spremenilo svoj licenčni

model, ta je sedaj omogočal uporabo orodja vsem fizičnim osebam za mesečno naročnino

v višini 19 $ in 5 % deležem zaslužka od prodanih iger. Naročniki so dostopali do vseh

orodij, v primeru, da so naročnino prekinili, pa so jih lahko obdržali, vendar niso imeli

dostopa do posodobitev programa. Septembra 2014 se je odprla spletna tržnica UE

Marketplace, ki je naročnikom omogočala kupovanje in prodajo ustvarjenih vsebin.

Vključevala je različne razvojne vire s celotnimi pokrajinami, zvočnimi vsebinami, materiali,

animiranimi modeli, predstavitvenimi projekti itd. V istem mesecu so omogočili brezplačno

uporabo pogona šolam in univerzam, za uporabo študija videoiger, računalništva,

umetnosti, arhitekture in vizualnih komunikacij. Marca 2015 pa je pogon, skupaj z vsemi


8

prihajajočimi posodobitvami in izvorno kodo C++, prešel na zdaj veljaven brezplačni model,

omenjen v poglavju 2.1 [19].


9

3 ORODJA GRAFIČNEGA POGONA UNREAL ENGINE 4

3.1 Urejevalnik stopenj

Urejevalnik stopenj (angl. Level Editor) je prvo in glavno orodje pogona UE4, s katerim se

sreča nov razvijalec. Z njim opravljamo večino dela za ustvarjanje stopenj, ki po navadi

obsega postavljanje, transformacije in spreminjanje lastnosti različnih akterjev [8]. Akterji

so vsi objekti, ki jih lahko vstavimo v stopnjo (npr. kamera, osvetlitveni moduli, statični

objekti, igrani junak) in podpirajo 3D geometrijske transformacije premestitve (angl.

translation), skaliranja (angl. scaling) in zasuka (angl. rotation).

Uporabniški vmesnik sestoji iz več delov, ustrezno oštevilčenih z razdelki slike 3.1:

1. Osnovna vrstica z menijem in zavihki služi lažji navigaciji med odprtimi objekti.

2. Orodna vrstica za hitri dostop do pogosto uporabljenih ukazov, kot so shranjevanje,

nastavitve, gradnja in prevajanje projekta, zagon in lansiranje na druge platforme.

3. Okno Modes, kjer izbiramo med različnimi načini urejanja stopnje. Na voljo so

naslednji načini: vstavljanje akterjev, določanje barv in tekstur statičnim objektom,

ustvarjanje in urejanje pokrajin, nanašanje rastlinja na pokrajine in geometrijsko

urejanje teles.

4. Brskalnik vsebine, kjer so shranjeni statični objekti, razredi, animacije in vsi ostali

viri potrebni za delovanje projekta. Iz brskalnika lahko akterje s preprostim potegom

vstavimo v prikazovalnik scene.

5. Prikazovalnik scene, kjer vidimo in urejamo dejanski izgled stopenj.

6. Obris sveta prikazuje vse akterje scene v obliki hierarhičnega drevesnega pogleda.

7. V oknu s podrobnostmi lahko manipuliramo s komponentami in nastavitvami

izbranih akterjev.


10

Slika 3.1: Uporabniški vmesnik urejevalnika

3.2 Urejevalnik UMG

Večina iger vsebuje bolj ali manj dodelane uporabniške vmesnike, ki pa lahko s slabo

zasnovo hitro odvrnejo igralce. Pomembni so s tega vidika, da so po navadi prvi igralčev

stik z igro že v obliki glavnega menija, skozi igranje pa poglavitno pripomorejo k igralčevi

interakciji s svetom. Pojavljajo se tudi v obliki vmesnih menijev pri premorih, prikazu

junakovega inventarja, statističnih podatkov objektov znotraj igre in zaslona HUD. Zaslon

HUD je še posebej pomemben element igre, saj igralcu posreduje kritične informacije

(zdravje junaka, število nabojev, razpoložljive posebne sposobnosti ipd.).

Oblikovanju zgoraj navedenih elementov je v pogonu Unreal namenjeno orodje Unreal

Motion Graphics UI Designer (UMG). Pojem Widgets označuje osnovne komponente

oblikovanja. Na izbiro so že vnaprej pripravljene komponente gumbov, okvirjev, slik, vrstic

napredka, drsnikov, tekstovnih vhodov ipd., ustvarimo pa jih lahko tudi po meri. Delo z

grafičnimi vmesniki se opravlja v specializiranem razredu Widget Blueprint, katerega

urejevalnik razdeli na dva dela. V zavihku Designer (slika 3.2) oblikujemo vizualno podobo

vmesnika. Kot ozadje pri oblikovanju služi mreža, obdana z okvirjem zaslona. V mrežo

vlečemo komponente, ki jih lahko preoblikujemo, zasidramo na robove oz. druge


11

komponente in animiramo. V oknu Hierarchy so uporabljene komponente urejene na

hierarhičen način. Drugi del razreda Widget Blueprint je dogodkovni graf. Namenjen je

skriptiranju obnašanja komponent. Primer tega je sprotno prikazovanje življenjskih točk,

dogodki ob klikih na gumbe ipd. [11].

Slika 3.2: Zavihek Designer urejevalnika UMG

3.3 Urejevalnik animacij

Animacijski sistem pogona UE4 deluje na principu skeletne animacije in preoblikovanja

ciljnih točk (obrazne mimike). Za lažje razumevanje animacijskega procesa je potrebno

poznati nekaj osnovnih pojmov, ki jih uporabljamo pri urejanju.

Skelet je hierarhični model okostja animacijskih likov. Vsebuje informacije o kostnih

lokacijah in rotacijah. V UE4 so skeleti ločeni od skeletnih mrež, ki prikazujejo dejanski videz

lika, tako da lahko animacijo apliciramo neposredno na skelete. To omogoča ponovno

uporabo animacij na različnih objektih podobne oblike, z uporabo istega skeleta.

Za specifično animacijo, kot je stoja, počep ali tek, se uporablja pojem animacijska

sekvenca. Vsak okvir (angl. keyframe) vsebuje informacije o položaju, rotaciji in skaliranju


12

kosti, v določenem času. Animacijsko sekvenco dobimo s predvajanjem teh okvirjev.

Kadarkoli se lahko uporabijo kot aditivne ali absolutne in tega tipa ni treba navesti pred

dejansko uporabo, kar omogoča večjo prilagodljivost pri združevanju. Aditivne animacije se

predvajajo vzporedno in ob začetku svojega predvajanja ne prekinejo izvajanja trenutne

animacije, ki je že v teku, torej jih trenutni animaciji dodamo, medtem ko se absolutne

animacije izvajajo posamezno in jih ne moremo združevati z drugimi. Za primer vzemimo

animacijo teka, združeno z merjenjem in animacijo obrazne mimike med govorom. V

urejevalniku lahko okvirjem sekvence določimo animacijske opomnike (angl. notifications).

Ti dajejo možnost vzpostavitve dogodkov, ki se prožijo, ko sekvenca predvaja izbran okvir.

Ob klicih se lahko proži različne procedure igre, recimo ustvarjanje sistema delcev, zvoki

(korakanje), projektili itd.

Animacijske sekvence najdemo tudi v obliki drž na primeru naše igre, podrobneje opisane

v podpoglavju 4.2. Drža po navadi zajema en sam okvir, v katerem so shranjeni podatki o

postavitvi kosti. Združitev več različnih drž (npr. treh drž merjenja) med njimi ustvari prehod

(npr. prehod med merjenjem v zrak, v tla in naravnost). Za ustvarjanje prehodov med držami

animiranega objekta, je na voljo poseben vir imenovan prehodni prostor (angl. blend space).

Poznamo enorazsežne, ki za kontrolo prehoda uporabljajo en nadzorni parameter, in

dvorazsežne, ki uporabljajo dva nadzorna parametra. Z njimi lahko definiramo različne

prehode in so namenjeni poenostavitvi dela v animacijskem razredu Blueprint, saj v njem

ni treba uporabljati posebnih prehodnih vozlišč, ampak vanj preprosto povlečemo prehodni

prostor. Uporabo prehodnih prostorov bomo pokazali na primeru merjenja in hoje.

Cilji preoblikovanja (angl. morph targets) so slike lokacij točk. Za primer vzemimo model

obraza. Zajeti imamo lahko sliki resnega in nasmejanega obraza, med katerimi v

urejevalniku UE4 preprosto ustvarimo prehod. Na ta način pogon izdeluje obrazne mimike.

Animacijski Blueprint je razred, ki z grafi kontrolira animacije. Izvaja se vsak okvir in po

izvedbi skript prikaže končno držo animacijskega objekta. Sestavljen je iz dogodkovnega

grafa, kjer pridobi vse podatke, potrebne za izvajanje posameznih animacij, in

animacijskega grafa, ki preverja in nadzoruje katere animacije je potrebno izvajati v danem

okvirju. Skeletne kontrole omogočajo neposreden dostop do nadzora posamezni kosti v

animacijskem Blueprint razredu. Z njimi lahko med animacijami spreminjamo lege kosti, na

primer pri animaciji hoje, uredimo nožne kosti, da se prilagajajo krivim površinam [4].


13

Vse naštete osnovne komponente animacijskega procesa, v pogonu UE4, urejamo in v

celoto združujemo s pomočjo orodja Persona. Z njim urejamo skelete, skeletne mreže,

animacijske razrede Blueprint in ostale vire, potrebne za animacijo. Ti viri so ustvarjeni v

zunanjih programih za animacijo (Maya, Blender, 3ds Max, Cinema 4D) in v pogon uvoženi

s pomočjo FBX cevovoda [7]. Vključuje štiri različne načine urejanja: skelet, mreža,

animacija in graf. Skeletni način vizualno prikaže animirane like in njihovo hierarhijo kosti in

sklepov. Na kosteh lahko ustvarimo vtičnike (angl. sockets), s katerimi na skelet pripnemo

objekte (npr. orožje ali klobuk). Nastavimo jim relativen položaj in rotacijo. V tem načinu

lahko urejamo tudi razmerja med kostmi in animacijami. Tako lahko animacije, ki niso

popolnoma primerne za dan skelet, popravimo in ponovno uporabimo. Mrežni način

omogoča urejanje skeletne mreže. Nanjo lahko dodajamo materiale, obleke, urejamo

stopnjo podrobnosti (angl. level of detail) in testiramo ciljne točke za transformacije.

Animacijski način ponuja predogled in urejanje animacijskih virov, dodajanje krivulj za ciljne

točke preoblikovanja in ustvarjanje animacijskih opomnikov. V načinu grafa skriptiramo

animacijske razrede Blueprint in stroje stanj (angl. state machine) [10].

Na sliki 3.3 so prikazani vsi štirje načini urejanja v orodju Persona (zgoraj levo skeletni,

zgoraj desno mrežni, spodaj levo animacijski in spodaj desno način grafa).


14

Slika 3.3: Načini urejanja v urejevalniku Persona; a) Skeletni način, b) Mrežni način, c) Animacijski

način, d) Način grafa

3.4 Zvok

Zvok je eden izmed temeljnih elementov igre. Za veliko igralcev je samoumeven in se ne

zavedajo, kako velik vpliv ima na vživetost v igro. Pojavlja se v obliki glasbe iz ozadja, raznih

posebnih učinkov in v obliki govora. Glasba iz ozadja je velikokrat tudi interaktiven dejavnik,

v smislu, da igralca opozarja na morebitne nevarnosti, daje namige o skritih zakladih itd.

UE4 podpira 16 bitne zvočne datoteke formata WAV na katerikoli frekvenci vzorčenja in

deluje na mono, stereo, 2.1, 4.1, 5.1, 6.1 in 7.1 kanalih. Zvok lahko v brskalnik vsebine

preprosto povlečemo, ali pa ga uvozimo s funkcijo Import, kar ustvari komponento Sound

Wave. To komponento lahko neposredno povlečemo v stopnjo, ali pa ustvarimo Sound

Cue, katerega urejamo znotraj Sound Cue urejevalnika. Tukaj urejamo obnašanje


15

zvočnega predvajanja, zvočne efekte združujemo in jih modificiramo z različnimi zvočnimi

vozlišči (slika 3.4). Pogon ponuja tudi možnost ustvarjanja zvočnih razredov. Ti so zbirka

nastavljenih lastnosti, s katerimi lahko opišemo več objektov hkrati in tako pridobimo

centraliziran način urejanja, iz njih pa ponuja možnost izpeljevanja podrazredov za lažjo

razdelitev. Vredno je še omeniti komponento zvočnega slabljenja (angl. Sound

Attenuation), ki spreminja jakost zvočnega efekta glede na oddaljenost igralca od prostora

predvajanja.

Slika 3.4: Sound Cue urejevalnik

3.5 Urejevalnik materialov

Materiali v UE4 delujejo na podobnem principu kot materiali v resničnem svetu, kjer so

objekti sestavljeni iz lesa, kovin, kamna, stekla itd. Tako moramo tudi v UE4 objektom

določiti videz površine. Narekujejo odziv osvetlitvenega sistema na prikaz objekta, urejamo

pa jih na njihovi fizični osnovi. V urejevalniku materiale konstruiramo s pomočjo vizualnega

skriptiranja. Vsako vozlišče vsebuje del kode visoko-nivojskega senčilnega jezika (HLSL –

High-Level Shading Language), ki deluje po standardu OpenGL [16].


16

Skripta za materiale vsebuje naslednje vhode [9]:

Osnovna barva – določa, kakšne barve bo naš material in sprejme Vector3 vrednost

Kovinskost – Vrednost med 0 in 1, ki pove, koliko je material kovinski

Hrapavost – vrednost med 0 (ogledalo) in 1 (mat površina), ki določa hrapavost

Emisijska barva – določa, kateri deli materiala bodo oddajali svetlobo, kot vhod

prejme teksturo

Prosojnost – vrednost med 0 (popolnoma prosojno) in 1 (neprosojno), nakazuje

prosojnost

Normala – kot vhod prejme reliefno teksturo in površini doda nivo fizične podrobnosti

Predstavljeni so bili najpomembnejši vhodi. Na voljo je še nekaj drugih, s katerimi lahko

materiale bolj prilagodimo svojim potrebam.

Dodajanje materialov na mreže akterjev opravimo v urejevalniku stopenj. Izbranem akterju,

pod zavihkom podrobnosti, pri nastavitvi materiali, določimo želen material. Vsaka mreža

lahko vsebuje več materialov.

3.6 Vizualni skriptni sistem Blueprint

Blueprint je vizualni skriptni sistem, namenjen skriptiranju iger, ki upravlja funkcionalnosti

pri večini elementov igre, opisanih v prejšnjih podpoglavjih. Sestavljen je na podlagi

dogodkovnega grafa in ponuja različna vozlišča, ki so skupaj povezana s tokom izvajanja.

UE4 ob ustvarjanju projekta sicer ponuja možnost izbire med C++ in sistemom Blueprint,

vendar je med razvojem mogoče uporabljati oba, saj sta med sabo združljiva.

Razvijalec ima na voljo vozlišča za pogosto uporabljene ukaze programskih jezikov, kot so

zanke (ForLoop, WhileLoop, ForEachLoop), pogoji (Branch), spremenljivke, primerjalni

operatorji, funkcije itd., in specializirana vozlišča pogona Unreal, ki služijo za nastavitve

posameznih komponent. Do vozlišč dostopamo z desnim klikom na ozadje, pri čemer se

odpre iskalnik s prikazom vseh vozlišč v trenutnem kontekstu.

Vozlišča lahko imajo več priključkov, ki jih z žicami povezujemo med sabo. Priključki na levi

strani predstavljajo vhode za ukaz (parametri), priključki na desni pa izhode (vrednosti, ki

jih vrne). Loči dve glavni vrsti priključkov, in sicer beli, s katerim se določa potek izvajanja


17

skripte in barvni, ki so namenjeni spremenljivkam. Beli priključki imajo obliko puščic in

kažejo smer izvajanja skripte. Med izvajanjem igre se žice med temi priključki obarvajo

rdeče in tako vidno nakažejo stanje izvajanja, kar prispeva k bolj učinkovitemu

razhroščevanju. Barvni priključki predstavljajo spremenljivke, ki nastopajo pri vozlišču in so

ločeni glede na tip spremenljivke, ki ga priključek sprejme (slika 3.5). Če ima ukaz na primer

priključek, ki je struktura, ga lahko tudi razstavimo in tako posamezne elemente strukture

priključimo oziroma nastavimo ločeno. Barvne priključke, ki predstavljajo vrednosti, polja in

objekte lahko »povišamo« v samostojna vozlišča. S tem ustvarimo spremenljivko, katero je

možno nastavljati v samem urejevalniku, kar omogoča večjo preglednost in hitrejši dostop

do pomembnejših vrednosti, ki bi jih med testiranjem igre morda želeli spreminjati. Pri

funkcionalnostih, ki se v skripti pojavijo večkrat, se lahko nastopajoča vozlišča združijo v

funkcije. Te funkcije so obdane s tako imenovanima tunelskima vozliščema, levi prejme vse

vhode, desni pa izhode.

Slika 3.5: Podatkovni priključki

Na sliki 3.6 je prikazan primer vozlišča LineTraceByChannel, ki med dvema akterjema

nariše črto oziroma žarek. Na levi strani, kot vhode, prejme dve lokaciji, na voljo pa ima še

nekaj neobveznih možnosti. Na desni strani je prikazan izhod, ki ga lahko razdelimo na več

komponent in uporabimo tiste, ki jih v dani situaciji potrebujemo.


18

Slika 3.6: Primer vozlišča z vhodi (levo) in izhodi (desno)

Predstavljeni grafi torej dodajajo funkcionalnost različnim akterjem igre. Te skriptirane

akterje shranimo v brskalnik vsebine kot razrede Blueprint. Obnašajo se enako kot vsi ostali

akterji igre, kar pomeni, da tudi njih lahko preprosto povlečemo v stopnjo. Ob kreiranju

novega razreda Blueprint se mu določi nadrazred, od katerega bo podedoval lastnosti.

Nadrazred se izbere glede na tip želenega akterja, najpogosteje pa se uporabljajo naslednji

[5]:

Actor – je navaden objekt in se lahko postavi, oziroma ustvari med izvajanjem igre

Pawn – je Actor, ki je lahko kontroliran

Character – je Pawn, z možnostmi hoje, teka, skokov ipd.

PlayerController – je Actor, ki je zadolžen za kontrolo nad Pawn-om

Game mode – definira igro, njena pravila, točkovanje in podobne nastavitve.


19

4 PREDSTAVITEV IGRE

4.1 Zvrst igre

V današnjem svetu vseprisotnih mobilnih naprav je trg aplikacij v razcvetu. Velik del teh

aplikacij predstavljajo mobilne igre. Statistične raziskave napovedujejo, da bodo v

naslednjih letih celo presegle prodajo konzolnih iger [14]. Za najpopularnejšo zvrst veljajo

arkadne in akcijske igre, sledijo pa jim miselne uganke, simulacije in pustolovke. Gledano

s tržnega vidika, najbolj uspevajo strateške in igre igranja vlog [13]. Zaradi navedenih

razlogov smo se pri praktičnem delu naloge, odločili za razvoj mobilne igre. Za zvrst smo

izbrali akcijsko igro, saj so primarne funkcionalnosti pogona Unreal namenjene prav tej.

Najpogosteje so akcijske igre predstavljene v prvoosebnem pogledu ali tretjeosebnem s

kamero, ki sledi igralcu od zadaj. V teh primerih pride posebej do izraza okolica, v katero je

igralec postavljen. Za izrazito okolico pa je treba nameniti veliko časa, modelirnih virov in

virov same naprave, na kateri igro poganjamo. Ker je bila ciljna platforma igre mobilni

operacijski sistem Android, smo za izvajanje brez zatikanja na čim večjem številu naprav,

morali ubrati drugačen pristop. Pri tem je treba omeniti tudi dejavnik kontroliranja igre. Za

igre s prej omenjenima pogledoma je, zaradi manjših zaslonov in pomanjkanja kontrolnih

enot, kot so miška in igralna palica, na mobilnih napravah zelo težko implementirati

učinkovite uporabniške vhode, s katerimi vodimo igranega junaka. Zato smo se odločili za

igro, ki prikazuje sceno igranja s strani. Pri igrah s stranskim pogledom (angl. sidescroller)

se igrani junak v večini primerov proti cilju premika iz leve proti desni strani. Ena prvih takih

iger je arkadna igra Bomber (1977, Sega), iz sedemdesetih let, ki je vključevala še statično

sceno. Čez leta se je zvrst neprestano razvijala s posodobitvami na pomične scene,

diagonalno streljanje, kooperativno igranje in iz dvodimenzionalnega grafičnega prikaza

prešla na tridimenzionalnega. Zaradi omejitve kamere samo na eno os premikanja se je pri

3D igrah s stranskim pogledom uveljavil izraz 2.5D. Danes lahko to zvrst razdelimo na več

podzvrsti: strelske, dirkalne, pretepaške in platformne. Pri diplomski nalogi smo se odločili

za strelsko igro z elementi platformnih.


20

Platformne igre so igre, kjer je ključna osnovna mehanika skakanje. Igralčeva naloga je

uspešno skakanje čez ovire in med različnimi, tudi premikajočimi, platformami. Za dosego

cilja in različnih objektov z bonusi je tako pogosto potrebno spretno manevriranje čez

zapletene poti. Primer platforme igre je Donkey Kong (1981, Nintendo) na sliki 4.1.

Slika 4.1: Primer igre Donkey Kong

4.2 Igra Droid Journey

Pri praktičnem delu diplomske naloge smo razvili igro, pri kateri vključimo in prikažemo

delovanje vseh osnovnih elementov, ki jih po navadi vsebuje izbran žanr. Implementirali

smo sisteme, ki jih lahko z reprodukcijo uporabimo za dopolnjevanje in nadgrajevanje pri

nadaljnjem razvoju igre: animacije in zvočni efekti igranega junaka in sovražnikov, osnovna

umetna inteligenca, implementacija orožja in sistema za streljanje in merjenje, zaznavanje

trkov, poškodbe in smrt, pobiranje objektov z nagradami, zasnova in dinamičnost okolja in

uporabniški vmesniki. Te sisteme podrobneje opišemo v poglavju 5.

Za igro smo oblikovali eno stopnjo, pri kateri smo za okolje določili pokrajino puščave. S

kamni, grmovnicami, palmami in osušenimi drevesi, piramido in še nekaj ostalimi statičnimi

objekti smo stopnji dodali ambient. Za 3D modele teh objektov smo uporabili brezplačne

pakete, ki jih z raznimi demonstracijskimi projekti ponuja že pogon sam. Pri tem smo morali

biti pozorni, da modeli niso bili sestavljeni iz večjega števila poligonov, saj smo pri mobilnih

igrah omejeni z zmogljivostjo naprav. Prav tako smo iz omenjenih projektov uporabili


21

zvočne efekte. Model igranega junaka in sovražnikov je Unreal-ov privzeti model izložbene

lutke, namenjen prototipiranju iger. Lutkam smo za lažje ločevanje spremenili barve.

Cilj igre je, da igralec preživi in uspešno pride do konca stopnje, na poti pa poskusi pridobiti

čim večje število točk. Točke lahko pridobi s pobiranjem cekinov in premagovanjem

sovražnikov, ki ga napadajo z orožji. Za regeneracijo življenjskih točk lahko najde zdravilne

pakete. Stopnji smo dodali oazo z vodo, ki igralca zaradi naelektrenosti poškoduje. Tako je

edina pot skozi oazo premikajoča se platforma. Na koncu poti smo s transformacijo

osnovnih kamnov dodali jamo, v kateri bi se lahko nadaljevala naslednja stopnja. Primeri

igre so prikazani na sliki 4.2, sliki 4.3 in sliki 4.4.

Slika 4.2: Igra Droid Journey – patrulja sovražnika


22

Slika 4.3: Igra Droid Journey – prehod čez oazo

Slika 4.4: Igra Droid Journey – spopad v votlini


23

5 IMPLEMENTACIJA IGRE

5.1 Projektne nastavitve

Projektu je bilo treba predhodno nastaviti vse kontrole, ki jih bomo med igro uporabljali za

izvajanje dejanj. V meniju se pod možnostjo Edit > Project Settings nahajajo projektne

nastavitve.

UE4 kot vgrajeno možnost krmiljenja igranega junaka za mobilne naprave ponuja krmilne

palice (slika 5.1), ki so na zaslonu prikazane v obliki zunanjega in notranjega kroga. Notranji

krog lahko vlečemo po prostoru zunanjega kroga, pri čemer vsaka možna lokacija

notranjega kroga predstavlja neko vrednost na določenem intervalu števil. Privzeti projekt

za platformo Android ponuja samo levo krmilno palico, katero uporabljamo za premikanje.

Zato smo v zavihku Input v možnost Axis Mappings dodali še desno palico, ki je služila

merjenju in streljanju. Za lažjo pretvorbo v funkcionalnosti merjenja, smo izhode te palice

nastavili na interval vrednosti med -90 in 90, kar predstavlja 180 stopinjski kot po osi z.

Slika 5.1: Primer delovanja krmilne palice za merjenje in streljanje


24

V zavihku Maps & Modes smo na privzeto stopnjo in privzeti igralni način nastavili glavni

meni. Igralni način je poseben razred Blueprint, kjer ustvarjene razrede povežemo z

njihovimi funkcionalnostmi. V njem smo nastavili razred igranega junaka, igralčevega

kontrolnika (angl. player controller) in zaslona HUD. V tem razredu smo implementirali tudi

funkcijo za povečanje in shranjevanje števila točk – ImplementScore. Ker v glavnem meniju

nismo želeli nadzorovati nobenih akterjev in implementirati nobenih posebnih

funkcionalnosti, smo zanj ustvarili poseben igralni način s primernimi nastavitvami –

MainMenuMode.

5.2 Junak in sovražniki

Igro smo sicer v celoti razvili z vizualnim skriptnim sistemom Blueprint, želeli pa smo

raziskati, kako deluje integracija med tem sistemom in programiranju v jeziku C++, zato

smo, samo za naslednji del, uporabili pristop s kodo C++. Ustvarili smo nov razred C++, ki

deduje od razreda ACharacter (osnovni razred likov) in ga poimenovali BaseCharacter. V

razvojnem orodju se odpreta datoteka glave (.h) in izvorna datoteka (.cpp) z vsemi

funkcionalnostmi razreda ACharacter. V glavi ustvarjenega razreda (slika 5.2) določimo

lastnost Blueprintable, da lahko služi kot osnova za ustvarjanje razredov Blueprint.

Deklariramo in nastavimo pravice branja in pisanja lastnostim zdravje in smrt. Pomembna

je deklaracija funkcije CalculateHealth z lastnostjo BlueprintCallable, kar pomeni, da lahko

funkcijo kličemo iz izpeljanih razredov Blueprint. Zgolj kot primer smo implementirali še

funkcijo PostEditChangeProperty, ki se kliče ob spremembah lastnosti razreda v

urejevalniku.


25

UCLASS(Blueprintable) class MOBILESHOOTER_API ABaseCharacter : public ACharacter { GENERATED_BODY() public: //Zdravje UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "Base Character") float Health = 100; //lastnost isDead UPROPERTY(BlueprintReadOnly, VisibleAnywhere, Category = "Base Character") bool isDead = false; //funkcija preveri smrt virtual void CalculateDead(); //izračunaj življenje UFUNCTION(BlueprintCallable, Category = "Base Character") virtual void CalculateHealth(float delta); #if WITH_EDITOR //funkcija za spreminjanje lastnosti iz urejevalnika Unreal virtual void PostEditChangeProperty(FPropertyChangedEvent& PropertyChangedEvent) override; #endif

Slika 5.2: Deklaracija spremenljivk in funkcij v datoteki glave (.h)

V izvorni datoteki (slika 5.3) sledijo implementacije zgoraj deklariranih funkcij. Funkcija

CalculateHealth trenutni vrednosti spremenljivke Health prišteje vrednost formalnega

parametra Delta. CalculateDeath je funkcija, ki preverja, če je vrednost spremenljivke

Health manjša ali enaka 0 in v tem primeru nastavi vrednost spremenljivke isDead na false.

Tako lahko med izvajanjem igre preverjamo, kdaj moramo junaka oz. sovražnika uničiti. Pri

funkciji PostEditChangeProperty za spremenljivki Health in isDead ni bilo potrebe po

implementaciji posebnih pravil, zato smo njune vrednosti samo nastavili na privzete

vrednosti.


26

//Implementacija CalculateHealth void ABaseCharacter::CalculateHealth(float Delta) { Health += Delta; CalculateDead(); } //Implementacija CalculateDead void ABaseCharacter::CalculateDead() { if (Health <= 0) isDead = true; else isDead = false; } #if WITH_EDITOR //Implementacija PostEditChangeProperty void ABaseCharacter::PostEditChangeProperty( FPropertyChangedEvent& PropertyChangedEvent) { isDead = false; Health = 100; Super::PostEditChangeProperty(PropertyChangedEvent); CalculateDead(); } #endif

Slika 5.3: Implementacije funkcij v izvorni datoteki (.cpp)

V urejevalniku stopenj, na podlagi razreda BaseCharacter, ustvarimo razred Blueprint po

imenu MyCharacter. Ta vsebuje lastnosti zdravja in smrti in ima dostop do ustvarjenih

funkcij. V oknu komponent (zavihek Viewport) smo mreži nastavili privzeto okostje pogona.

Slika 5.4 prikazuje akterjevo zgradbo, ta sestoji iz komponent CapsuleComponent, ki

določa njegove meje in fizikalne lastnosti, ArrowComponent, ki določa usmerjenost, Mesh,

ki predstavlja akterjevo mrežo (izgled) in CharacterMovement, ki nadzira premikanje. Dodali

smo še komponento SpringArm, na katero pritrdimo kamero.

Slika 5.4: Komponente razreda MyCharacter


27

Najosnovnejša funkcionalnost igranega junaka je premikanje in skok. Premikanje

dosežemo z dogodkom InputAxis_MoveRight. Ob igralčevem pritisku na levo krmilno palico

dogodek pošlje trenutno vrednost pritiska funkciji AddMovementInput, ki junaka za to

vrednost premakne. V igri je smer gibanja omejena na os y, zato ostale osi nastavimo na

0, os y pa na -1. Negativno vrednost damo zato, ker je privzeto nastavljeno inverzno

gibanje. Tudi za skok obstaja že vgrajena funkcija, katero prožimo ob pritisku na izbran

vhod – pritisk na zaslon mobilne naprave.

Ob začetku akterjeve igre se proži dogodek Event_BeginPlay, pri katerem se izvedejo dve

proceduri. Najprej smo za junaka ustvarili orožje s funkcijo SpawnActor, katera kot vhod

prejme lokacijo akterjeve mreže in razred Weapon. Izhod funkcije je orožje, katerega z

vozliščem SET shranimo v spremenljivko za kasnejšo uporabo. Orožje je bilo treba pritrditi

na akterja, za kar smo uporabili funkcijo AttachActorToComponent, ki v vhod Target prejme

orožje in vhod InParent junakovo mrežo. Za ime vtičnika izberemo prej ustvarjen vtičnik

GunSocket (opisan v podpoglavju 5.3) pritrjen na desno roko akterjeve mreže. Tako junak,

ne glede na stanje animacije (mirovanje, tek, skok, merjenje), orožje drži v desni roki. Ob

začetku igre smo s pomočjo vozlišča CreateHUDWidget ustvarili še zaslon HUD in ga z

vozliščem AddToViewport dodali čez celoten prikaz slike (slika 5.5).

Slika 5.5: Dogodek BeginPlay

Ob pritisku na desno krmilno palico se proži postopek merjenja in streljanja (slika 5.6).

Vrednost osi y desne krmilne palice pošljemo akterjevemu animacijskemu Blueprint-u in z


28

njo nastavimo spremenljivko Pitch, ki narekuje junakovo vertikalno usmerjenost (merjenje).

Če je vsota osi x in y večja od 0, to pomeni, da igralec pritiska krmilno palico, zato kličemo

funkcijo orožja PullTrigger, v nasprotnem primeru pa funkcijo ReleaseTrigger. Junakova

orientacija je privzeto odvisna od smeri gibanja. Tega ob hkratnem merjenju in premikanju

nismo želeli, zato v primeru merjenja možnost izklopimo z vozliščem SetRotation

ToMovement. Sovražniku smo ustvarili razred EnemyCharacter s podobnimi

funkcionalnostmi.

Slika 5.6: Postopek merjenja in streljanja

Za poškodbo tako našega junaka kot sovražnikov, smo potrebovali način komuniciranja

med razredi Blueprint. To uvedemo s pomočjo vmesnikov (angl. interface). V brskalniku

vsebine smo ustvarili vmesnik IDamagable. Ta vsebuje funkcijo brez implementacije, katero

smo poimenovali AffectHealth in ji, kot parameter, dodali spremenljivko tipa float. Namen

vmesnika je bil ustvarjanje strukture za želeno funkcionalnost (poškodbo), ta funkcionalnost

pa se definira v razredih, ki bodo vmesnik implementirali. V razredih MyCharacter in

EnemyCharacter smo v nastavitvah Class settings, pod možnostjo Implemented interfaces

dodali vmesnik IDamagable. Posledično lahko na dogodkovnem grafu uporabimo dogodek

AffectHealth in iz njega izpeljemo funkcionalnost za poškodbo. Na tem mestu smo uporabili

funkcijo CalculateHeatlh in spremenljivko isDead, definirane v razredu BaseCharacter.

Najprej se kliče funkcija CalculateHealth, s parametrom za število odvzetih življenjskih točk.

S spremenljivko isDead smo preverili primer smrti in poklicali vgrajeno funkcijo


29

DestroyActor. Ker je v primeru smrti potrebno odigrati animacijo, vmes vrinemo vozlišče

Delay s približnim časom animacije 3 sekund. Izklopimo še zaznavanje trkov, da sovražniki

junaka med animacijo smrti ne bi omejevali. Pri sovražniku smo poskrbeli še za povečanje

števila točk, pri junaku pa ob smrti odprli glavni meni.

5.3 Orožje in projektil

Zgradba razreda Blueprint po imenu Weapon (slika 5.7) vsebuje mrežo orožja, ki določa

njegov videz in komponento puščice, SpawnProjectile, ki določa lokacijo in smer pri stvaritvi

projektilov.

Slika 5.7: Zgradba razreda Weapon

V skripti orožja smo ustvarili tri poljubne dogodke PullTrigger, ReleaseTrigger in Fire. Ker

se junakovi InputAxis dogodki, ki PullTrigger kličejo, prožijo neprestano, uporabimo vozlišče

DoOnce. Ta poskrbi, da se vsi nadaljnji ukazi izvedejo samo enkrat. Takoj za tem je

priključen klic na poljuben dogodek Fire, ki preveri, kdo je lastnik orožja in na mestu

SpawnProjectile ustvari lastniku primeren projektil (junaku zelenega, sovražniku rdečega).

Po dogodku Fire je v verigo dodan še funkcijski časovnik (angl. function timer), ki vsake

toliko časa kliče funkcijo Fire. Čas je spremenljivka, s katero se lahko določa število

izstreljenih projektilov na sekundo. Časovniku smo odobrili lastnost looping, da se ponavlja

do klica dogodka ReleaseTrigger. Ob klicu le tega časovnik izključimo in ponastavimo

vozlišče DoOnce, da se lahko celotna funkcionalnost ob ponovnem pritisku na petelin

ponovno sproži. Za pritrditev orožja na akterje smo z orodjem Persona odprli akterjeve

skeletne mreže, poiskali kost, ki predstavlja desno roko, in nanjo dodali vtičnik GunSocket.


30

Skripta za projektil je dokaj preprosta. Uporabimo dogodek ActorBeginOverlap z izhodom

OtherActor. Ta dogodek se sproži, ko sistem trkov projektila zazna trk z drugim akterjem –

izhod OtherActor. Preverimo, če drugi akter implementira vmesnik IDamagable. Če tega ne

implementira, projektil samo uničimo. Ker nismo želeli, da bi lahko junak ustrelil samega

sebe, smo preverili, če drugi akter vsebuje značko Friendly (značke razredom dodamo v

zavihku Class Settings). V primeru, da jo vsebuje, se projektil spet samo uniči. V

nasprotnem primeru ugotovi, da je drugi akter sovražnik in nad njim kliče funkcijo vmesnika

AffectHealth s parametrom odvzetih življenjskih točk.

5.4 Umetna inteligenca

Sovražnikom v igri smo ustvarili preprosto umetno inteligenco. Vsak izmed njih patruljira na

svojem območju. Ko zagleda junaka, proti njemu pospeši, mu začne slediti in nanj strelja.

Če se mu junak skrije za objekte (in s tem uide iz njegovega vidnega polja), spet preide v

stanje patruljiranja. Postopek stvaritve vidnega polja in zaznave junaka v njem je pojasnjen

v nadaljevanju. Za dosego takšnega obnašanja smo si pomagali s pomočjo vedenjskega

drevesa (angl. behavior tree) na sliki 5.8.

Za prehod med patruljiranjem in napadom sta potrebni dve stanji (Idle in Combat). V

brskalniku vsebine z desnim klikom ustvarimo nov Blueprint tipa Enumeration in vanj

dodamo omenjeni stanji. Za shranjevanje spremenljivk vedenjska drevesa uporabljajo tablo

(angl. blackboard) v katero dodamo ustvarjeno spremenljivko stanj. Za lažje reference smo

dodali še dve spremenljivki objektov, ki kažeta na ciljnega akterja (junaka) in akterja

samega sebe (sovražnik, nad katerim se vedenjski vzorec izvaja).

Vedenjsko drevo je vir, ki ga ustvarimo v brskalniku vsebine in povežemo z zgoraj

predstavljeno tablo. Z njim je treba povezati tudi sovražnika. Za to skrbi razred EnemyAI, ki

je ustvarjen kot podrazred že ponujenega razreda AIController, ob začetku igre (dogodek

EventBeginPlay) pa proži vozlišče RunBehaviorTree. To vozlišče skrbi za nadaljnje

izvajanje vedenjskega drevesa, katerega mu določimo kot vir. Pod zavihkom Class

Defaults, razreda EnemyCharacter, se nahaja možnost izbire kontrolnega razreda za

umetno inteligenco (možnost AI Controller Class), kjer vstavimo razred EnemyAI.

V vedenjskem drevesu ustvarimo izbirno vozlišče (angl. selector), ki izbira med svojimi

otroki, z leve strani proti desni, dokler eden od otrok ne zadosti svojemu pogoju. Vanj


31

vstavimo storitev (angl. service) VisionCheck, ki se bo neprestano izvajala. Kot otroke

dodamo vozlišče s pogojem »stanje je patrulja« (State is Idle) zaporednega tipa (sekvenca),

ki vsebuje nalogi »nastavi hitrost hoje« in patruljiranje, in vozlišče s pogojem »stanje je

napad« (State is combat), ki je preprostega vzporednega tipa (dovoljuje istočasno izvajanje

dveh otrok, s pogojem, da je eden izmed njih končna naloga). Tako se sovražnik hkrati

pomika proti junaku (izbirnik Combat Movement) in nanj strelja (naloga Kill player). Combat

movement vsebuje zaporedje Approach, ki nastavi hitrost teka in začne premik proti junaku

z vgrajenim vozliščem Move To. Oblika je takšna z namenom, saj se lahko poleg vozlišča

Approach naknadno doda raznovrstne akcije, za katere želimo, da jih sovražnik izvaja med

bojem (npr. počep, skok, preval, kritje ipd.).

Slika 5.8: Vedenjsko drevo sovražnika

Vedenjske naloge Walk Speed, Run Speed, Kill player so zelo preproste in logiko za njimi

smo opisali že v prejšnjih primerih skript. Naloga Move to random point, z vgrajenim

vozliščem, poišče naključno točko v navigacijski mreži (volumen, ki ga v sceno postavimo

na mesta, kjer želimo omogočiti sovražnikovo gibanje), ki jo sovražnik lahko doseže, in ga

s funkcijo MoveTo pošlje do te točke.


32

Najpomembnejša je storitev VisionCheck. Ta preverja, če se junak nahaja v vidnem polju

sovražnika. Za določitev vidnega polja smo si pomagali s pomočjo vektorjev (slika 5.9), s

katerimi pridobimo kot 𝜑 med junakom in sovražnikom. To storimo z naslednjim postopkom:

Slika 5.9: vidno polje

Z vozliščem GetActorLocation pridobimo krajevna vektorja junaka (𝑟𝑗) in sovražnika (𝑟𝑠). Z

njuno razliko pridobimo vektor �⃑�, kot je prikazano v (5.1).

�⃑� = 𝑟𝑗 − 𝑟𝑠 (5.1)

Z vozliščem GetActorForwardVector dobimo normaliziran (enotski) vektor, ki kaže

sovražnikovo usmerjenost (�̂�). Za učinkovitejše računanje normalizirano še, prej dobljeni,

vektor �⃑� (pridobimo �̂�), saj za računanje kota ne potrebujemo velikosti vektorja, ampak

samo njegovo smer. Tako smo po enačbi (5.2) izračunali iskani kot med junakom in

sovražnikom.

cos 𝜑 = �̂��̂� (5.2)

Kot 𝜑 smo lahko primerjali z želenim kotom vidnega polja (55° v obe smeri prikazano s

sivima črtama na sliki 5.9. Če je kot 𝜑 manjši od želenega kota, se izvede sledenje z žarki

(angl. raycast). Vozlišče LineTraceByChannel med akterjema »izstreli« neviden žarek. Če

žarek zadene junaka, ne da bi vmes zadel kakšne statične objekte, junaka vrne kot izhod.

Žarki so uporabni v več primerih. Z njimi lahko ugotovimo, katere predmete junak gleda.


33

Uporabimo jih lahko tudi namesto projektila pri implementaciji drugih vrst orožja, saj je

postopek, ko se generira projektil in pošlje proti cilju, precej počasen in je kot takšen

neuporaben pri avtomatskem orožju.

Z žarki smo torej poskrbeli, da sovražnik ne začne streljati na junaka, če mu pogled zastira

zemlja, stena ali druge ovire. Ko žarek zadene junaka, se izvede skripta na sliki 5.10.

Sovražniku se za tarčo nastavi junaka (prvo vozlišče SetBlackboardValue), spremeni se

mu stanje iz patruljiranja na napad (drugo vozlišče SetBlackboardValue) in njegovem

animacijskem razredu Blueprint nastavi spremenljivka Pitch, da strelja pod pravilnim kotom.

Slika 5.10: Sprememba stanja za boj in nastavitev spremenljivke Pitch

5.5 Animacije

Za igranega junaka in njegove sovražnike smo uporabili privzeti model pogona Unreal

Engine in z namenom razlikovanja vsakemu dodelili svojo barvo. Osnovne animacije hoje

in skoka so v predlogi že vpeljane, vendar smo morali za svoj primer nekatere stvari prirediti.

Privzeta hoja akterjev je osnovna hoja s spuščenimi rokami. To za našo igro ni bilo

primerno, saj smo potrebovali držo, v kateri bodo lahko v rokah držali orožje. Epic Games

na spletni tržnici ponuja brezplačni paket animacij za uporabljen model. Animacijam je bilo

treba nastaviti novo ciljno okostje; to dosežemo z desnim klikom na animacijo in orodjem

Retarget Anim Assets. Po izbranem okostju se lahko zgodi, da animacija ni popolnoma

primerna, v našem primeru so roke lebdele v zraku. To popravimo v oknu Sketelon Tree,


34

kjer obkljukamo dodatne možnosti in nastavimo Translation Retargeting za vsako kost

posebej. Primerne nastavitve so bile Root na Animation, Pelvis na AnimationScale in vse

ostale kosti na Skeleton.

Privzeto je za animacijo hoje uporabljen enorazsežni prehodni prostor, ki kot nadzorni

parameter uporablja samo hitrost hoje (prehod med počasno hojo in tekom), kar se pri

testiranju ni izkazalo za primerno. Napaka se je pojavila, ko smo v junaka vpeljali merjenje

in je lahko hodil tudi vzvratno. Potrebovali smo dodatno spremenljivko, ki je prehodnemu

prostoru povedala, v katero smer je junak obrnjen, da je lahko začel izvajati animacijo

vzvratne hoje. Za te namene smo ustvarili nov dvorazsežni prehodni prostor s kontrolnima

parametroma hitrost in usmeritev. V oknu BlendSpace se pojavi graf, v katerega povlečemo

animacije (slika 5.11).

Slika 5.11: Prehodni prostor gibanja

Tudi merjenje navzdol in navzgor smo implementirali z uporabo prehodnega prostora. V

paketih pripravljenih animacij so vse smeri merjenja po navadi združene v eni animacijski

sekvenci AimSpace. V teh sekvencah se poiščejo želeni okvirji, v našem primeru okvirja za

merjenje v zrak in merjenje v tla, in vsakega posebej shrani kot svojo animacijo. Tako smo

pridobili obe drži, kateri se združijo v enodimenzionalnem prehodnem prostoru z nadzornim

parametrom Pitch (slika 5.12).


35

Slika 5.12: Prehodni prostor merjenja

Za ustvarjene vire smo uporabili in priredili privzeti animacijski Blueprint. Ustvarili smo

dodatne spremenljivke Pitch, Direction in DeathAnimationSelector. V dogodkovnem grafu

spremenljivko Direction nastavimo s pomočjo vozlišča CalculateDirection, ki iz vektorja

hitrosti in akterjeve rotacije vrne smer v številu tipa float. Za smrt smo uporabili tri različne

animacije, med katerimi eno izberemo naključno. Spremenljivki DeathAnimationSelector

smo določili naključno število med 1 in 3 in jo uporabili za izbiro sekvence. V animacijskem

grafu smo zamenjali privzeti prehodni prostor s prej ustvarjenim prostorom merjenja in vanj

priključili spremenljivko Pitch, ki se nastavi v razredih junaka in sovražnika. Prehodni prostor

ima še en vhod, in sicer Base pose, v katerega vključimo stroj stanj. Ta skrbi za različna

stanja našega akterja in glede na njih izbere primerne animacije. Do prehoda med stanji

pride ob izpolnitvi pogojev, ki so na sliki 5.13 označeni z znakom enakosti. V stroju stanj

smo dodali vozlišče Dead in kot pogoj preverili spremenljivko isDead. V vozlišče vključimo

tri animacije smrti in uporabimo vozlišče Blend Poses by Int, ki s pomočjo spremenljivke

DeathAnimationSelector izbere eno izmed animacij. Popravimo še stanje Idle/Run, v

katerem zamenjamo privzeti enorazsežni prehodni prostor gibanja s prej ustvarjenim

dvorazsežnim in vanj priključimo spremenljivki Direction in Speed kot nadzorna parametra.

Ostala stanja so preprosta in ob izpolnjenih pogojih predvajajo primerno animacijo.


36

Slika 5.13: Stroj stanj

5.6 Izdelava stopnje

5.6.1 Pokrajina

Pokrajino smo ustvarili s pomočjo načina Landscape, ki ga najdemo v urejevalniku pod

zavihkom Modes. Z orodjem Manage/New Landscape smo določili lastnosti, ki definirajo

ustvarjeno pokrajino. Najpomembnejša lastnost je velikost sekcij, ki se meri v kvadratih.

Visoko število kvadratov pomeni visok nivo podrobnosti, kar pa za mobilne naprave ni

primerno, saj sistemske omejitve tega ne bi dovoljevale oziroma bi upočasnile izvajanje

igre. Zato smo izbrali najmanjšo možno nastavitev, ki je 7x7 kvadratov. Izberemo še osnovni

material, s katerim bo pokrajina ustvarjena. Videz puščave smo izbrali zato, ker ne

potrebuje veliko akterjev (npr. trava, gozdovi) in smo tudi tukaj prihranili na procesorskem

času. V scenskem pogledu se nam prikaže velika ravnina z dodanim materialom. V

pokrajinskem načinu imamo na voljo kar nekaj orodij za oblikovanje ravnin. Z orodjem sculpt

smo ustvarili hribe in doline, nad katerimi z orodjem Erosion, za bolj naraven videz,

izvedemo sončno in vodno erozijo. Orodje Retopologize uporabimo na hribovitih področjih.

Ta samodejno popravi oglišča pokrajin, da med sabo niso preveč oddaljena, saj to povzroča

raztegnjen videz tekstur. Na isti način oblikujemo več pokrajin in jih postavimo eno za drugo,

da ustvarimo kontinuitetno stopnjo. Z junakom je bilo treba preveriti možno pot, in ob

kakšnih zatikih, z orodjem Ramp ustvariti klančine.


37

5.6.2 Premikajoče platforme

Za ustvarjanje premikajoče platforme smo uporabili orodje za filmske odseke znotraj igre –

Matinee, do katerega dostopamo preko orodne vrstice na gumbu Cinematics. Na oknu

Tracks ustvarimo novo prazno skupino in vanjo dodamo akterja platforme. V platformo

dodamo še sled premikanja. Na sredini okna je prikaz časa, kjer se določi dolžina animacije

16 sekund. V tem oknu kazalec postavimo v začetni čas in dodamo ključni okvir. Tako

pridobimo izhodišče premika. Kazalec prestavimo na četrto sekundo, prav tako prestavimo

platformo na želeno mesto in spet dodamo ključni okvir. Te okvire smo dodajali vsake 4

sekunde, na scenskem pogledu pa se je izrisala pot, ki jo v premiku naredi platforma (slika

5.14). Ustvarjen proces smo shranili kot Matinee akterja in ga poklicali v posebnem razredu

stopnje. Razred stopnje je unikaten in se lahko uporablja za globalne dogodke in dinamično

ustvarjanje akterjev med igro.

Slika 5.14: Premik platforme, okno Tracks (spodaj) in scenski pogled s prikazom premika (zgoraj)


38

5.6.3 Pobiranje predmetov

Za pobiranje cekinov in paketov je bil proces izdelave skoraj identičen. Za cekine smo

poiskali brezplačno teksturo, jo uvozili v urejevalnik vsebine in iz nje z desnim klikom

avtomatsko naredili material. Nato smo ustvarili razred Blueprint z imenom pickupCoin, vanj

dodali geometrijsko telo valja, ga preoblikovali v primerno obliko in nanj dodali ustvarjen

material. Sistem za zaznavanje trkov nastavimo tako, da nobenih akterjev ne blokira, zazna

pa samo igralca. Ob uspešnem trku smo poklicali metodo IncrementScore (komponente

GameMode) in akterja uničili.

Pri zdravilnih paketih smo poiskali teksture škatle in zelenega križa. V programu Gimp smo

ustvarili tri plasti: črno ozadje, teksturo škatle in teksturo križa. Najprej shranimo teksturo z

vsemi vidnimi plastmi– ta služi kot osnova za ustvarjanje materiala. Nato še posebej

shranimo teksturo zelenega križa na črnem ozadju – s to teksturo bomo materialu povedali,

katere dele naj osvetli. V grafu materiala povežemo prvo teksturo s priključkom Base Color,

drugo pa s priključkom Emissive Color. Teksturo križa smo zmnožili še s skalarnim

parametrom, s katerim se kontrolira jakost svetlobe. Nadaljnji proces je enak kot pri cekinu,

le klic funkcije je zamenjan z junakovim dogodkom AffectHealth. Na sliki 5.15 je prikazan

izgled predmetov.

Slika 5.15: Cekin in zdravilni paket

Za boljši vizualni vtis smo objekta naredili premična. Za rotiranje smo razredoma Blueprint

dodali komponento RotatingMovement. Za učinek lebdenja pa smo v dogodkovnih grafih

ob dogodku Tick klicali vozlišče Timeline. Vozlišče Timeline služi za spreminjanje vrednosti

skozi čas. Tako smo razredoma nastavili spreminjanje lokacije glede na os z. Premikanje

je bilo potrebno še potrditi na akterju z vozliščem AddActorLocalOffset.


39

5.7 Zvok

Glasbo iz ozadja stopnji dodamo ročno, tako da jo v urejevalniku povlečemo na sceno.

Ostale zvočne efekte smo prožili v Blueprint razredih z vozliščem SpawnSoundAttached, in

sicer ob vsakem strelu orožja (funkcija Fire) ob pobiranju cekinov in zdravilnih paketov

(dogodek ActorBeginOverlap) in ob pritisku na gumbe glavnega menija (dogodki

OnClicked).

5.8 Uporabniški vmesniki

Glavni meni smo izdelali v razredu Blueprint tipa Widget in ga uredili v urejevalniku UMG.

Za ozadje smo uporabili komponento Image z zaslonsko sliko igre. Na sredino zaslona smo

pritrdili komponento Vertical Box, ki vsebovane komponente uredi vertikalno, eno za drugo.

Vanjo smo postavili dve komponenti Button in vsaki dodali svojo teksturo gumba. Gumboma

na dogodek OnClicked dodamo vozlišči OpenLevel, ki odpre prvo stopnjo igre, in

QuitGame, ki igro zapre. Za vizualno potrditev pritiska smo teksturam rahlo spremenili

barvno paleto.

Pri zaslonu HUD smo ustvarili prikaz življenjskega stanja in število doseženih točk. Za

življenjsko stanje smo uporabili komponento ProgressBar in jo povezali z junakovo

lastnostjo Health. Za prikaz dobljenih točk smo uporabili tekstovno datoteko in jo povezali s

parametrom Score.

5.9 Gradnja za sisteme Android

Projekt smo zgradili za sisteme Android, naš prvi korak pa je bil čiščenje projektnih map in

virov (za dosego čim manjše velikosti in preprečevanja napak ob nepovezanih virih). Pogoj

za gradnjo na platformi Android je bil nameščen Android SDK.


40

Pri gradnji so na voljo tri vrste konfiguracij [2]:

DebugGame: se uporablja za namene testiranja in vsebuje vse informacije o

razhroščevanju

Development: bolj optimizirano delovanje, saj vsebuje minimalno podporo

razhroščevanja

Shipping: konfiguracija, namenjena za trg

Pri končni gradnji smo s konfiguracijo za trg v meniju File izbrali možnost Package Project

> Android, kjer je na voljo izbira med različnimi tehnikami kompresije tekstur. Po uspešni

gradnji smo dobili namestitveno datoteko apk in podatkovno datoteko obb, kateri smo

namestili na Android mobilne naprave


41

6 SKLEP

V diplomskem delu smo se seznanili z grafičnim pogonom Unreal Engine 4 in pregledali

njegov razvoj skozi čas. V prvem delu smo se posvetili orodjem pogona, s katerimi

oblikujemo različne elemente iger. Raziskana področja smo v drugem delu naloge uporabili

pri razvoju mobilne igre, kjer smo najprej predstavili zvrst, nato pa samo igro. Na koncu smo

prikazali postopke, s katerimi nam je uspelo ustvariti vse bistvene elemente igre, tipične za

predstavljeno zvrst, in jih združiti v celoto. V prihodnosti bi lahko, na podlagi teh elementov,

igro razširili z zanimivimi in dinamičnimi stopnjami, raznovrstnimi sovražniki in mamljivo

zgodbo.

Ugotovili smo, da je Unreal Engine 4 izjemno zmogljiv grafični pogon z odlično podporo

razvijalcev. Uporabnikom so na voljo številni vodiči za uspešno učenje pri razvoju

raznovrstnih iger. Možnost izbire orodij, v primerjavi s pogonom Unity, je bolj obsežna. Na

podlagi pridobljenih izkušenj z delom na obeh pogonih ugotovimo, da naredi Unreal-ov

vizualni skriptni sistem proces razvijanja hitrejši in lažje razumljiv. Tudi grafična izvedba,

vsekakor preseže zmogljivosti pogona Unity. Pri testiranju na napravah Android pa so se

kmalu pojavile težave, saj v nekaterih primerih zmogljivost strojne opreme ni dohajala za

zahtevami razvite igre. To je bil razlog za previdno izbiro uporabljenih 3D modelov,

materialov in tekstur, omejevalo pa nas je tudi pri uporabi posebnih učinkov.

Iz dela lahko sklepamo, da je pogon namenjen razvoju grafično bolj zahtevnih iger, kar

pomeni večjo zahtevo po strojni opremi, ki je mobilne naprave v širši uporabi zaenkrat ne

premorejo. Zadeva se lahko v prihodnosti kmalu spremeni, ko bodo dostopnejši postali

telefoni s podporo grafičnega vmesnika Vulkan, ki ga pogon že podpira. Unreal sicer

omogoča tudi razvoj 2D iger, vendar se nanj ne osredotoča in je posledično podpora na

tem področja slabša.


42

7 VIRI

[1] Busby J., Parrish Z., Wilson J. Mastering Unreal Technology Volume I: Introduction to

Level Design with Unreal Engine 3. Indianapolis: Sams Publishing, 2009

[2] PV S. Unreal Engine 4 Game Development Essentials: Master the basics of Unreal

Engine 4 to build stunning video games. Birmingham: Packt Publishing, 2016

[3] Schultz W. Unreal Engine 4 – First Look. Dostopno na:

http://gameindustry.about.com/od/trends/a/Unreal-Engine-4-First-Look.htm [30. 7. 2016]

[4] Epic Games. Animation System Overview. Dostopno na:

https://docs.unrealengine.com/latest/INT/Engine/Animation/Overview/index.html

[3. 9. 2016]

[5] Epic Games. Blueprint Class. Dostopno na:

https://docs.unrealengine.com/latest/INT/Engine/Blueprints/UserGuide/Types/ClassBluepr

int/index.html [3. 9. 2016]

[6] Epic Games. Frequently asked questions. Dostopno na:

https://www.unrealengine.com/faq [15. 8. 2016]

[7] Epic Games. Importing Animations. Dostopno na:

https://docs.unrealengine.com/latest/INT/Engine/Content/FBX/Animations/#importinganim

ations [15. 8. 2016]

[8] Epic Games. Level Editor. Dostopno na:

https://docs.unrealengine.com/latest/INT/Engine/UI/LevelEditor/index.html [15. 8. 2016]

[9] Epic Games. Material Inputs. Dostopno na:

https://docs.unrealengine.com/latest/INT/Engine/Rendering/Materials/MaterialInputs/index

.html [3. 9. 2016]

[10] Epic Games. Persona Animation Editor Reference. Dostopno na:

https://docs.unrealengine.com/latest/INT/Engine/Animation/Persona/index.html

[3. 9. 2016]

[11] Epic Games. UMG UI Designer. Dostopno na:

https://docs.unrealengine.com/latest/INT/Engine/UMG/index.html [15. 8. 2016]

[12] Epic Games. UnrealScript Languague Reference. Dostopno na:

https://udn.epicgames.com/Three/UnrealScriptReference.html [15. 8. 2016]


43

[13] Sonders M. New mobile game statistics every game publisher should know in 2016,

2016. Dostopno na:

https://www.surveymonkey.com/business/intelligence/mobile-game-statistics/ [23. 8. 2016]

[14] Statista. Games market revenue worldwide in 2015, 2016 and 2016, by segment and

screen (in billion U.S. dollars). Dostopno na:

http://www.statista.com/statistics/278181/video-games-revenue-worldwide-from-2012-to-

2015-by-source/ [23. 8. 2016]

[15] Wikipedia. America's Army Development and release. Dostopno na:

https://en.wikipedia.org/wiki/America%27s_Army#Development_and_release [15. 8. 2016]

[16] Wikipedia, High-Level Shading Language. Dostopno na:

https://en.wikipedia.org/wiki/High-Level_Shading_Language [15. 8. 2016]

[17] Wikipedia, List of Unreal Engine Games. Dostopno na:

https://en.wikipedia.org/wiki/List_of_Unreal_Engine_games [15. 8. 2016]

[18] Wikipedia, Mobile Games. Dostopno na:

https://en.wikipedia.org/wiki/Mobile_game [20. 8. 2016]

[19] Wikipedia. Unreal Engine. Dostopno na:

https://en.wikipedia.org/wiki/Unreal_Engine [3. 9. 2016]

Razvoj mobilne tretjeosebne strelske igre s pogonom Unreal ... · role playing games). Koda je...

Documents

Transcript of Razvoj mobilne tretjeosebne strelske igre s pogonom Unreal ... · role playing games). Koda je...