izdelava 2d igre z uporabo ogrodja monogame · microsoftov universal windows platform(uwp),...

Jure Lednik

IZDELAVA 2D IGRE Z UPORABO

OGRODJA MONOGAME

Diplomsko delo

Maribor, julij 2017

IZDELAVA 2D IGRE Z UPORABO

OGRODJA MONOGAME

Diplomsko delo

Študent: Jure Lednik

Študijski program: Univerzitetni študijski program

Računalništvo in informacijske tehnologije

Mentor: Dr. Simon Kolmanič

i

Izdelava 2D igre z uporabo ogrodja MonoGame

Ključne besede: ogrodje MonoGame, UWP, razvoj igre

UDK: 004.388.4(043.2)

Povzetek

V diplomskem delu smo se seznanili z ogrodjem MonoGame in platformo UWP. V začetku

dela smo pregledali delovanje ogrodja MonoGame, za tem pa se poglobimo v platformo

UWP in pri tem posvetimo pozornost delom, ki so namenjeni razvoju iger. Pridobljeno znanje

kasneje uporabimo v praktičnem delu, kjer razvijemo 2D igro, ki smo jo poimenovali Type-

Shooter. Pri tem smo posebno pozornost namenili primerjavi implementacije igre, ko je le-

ta namenjena igranju na osebnem računalniku ali pa na mobilni napravi.

ii

2D game development using MonoGame framework

Key words: MonoGame framework, UWP, game develoment

UDK: 004.388.4(043.2)

Abstract

In this thesis we present MonoGame framework and Universal Windows Platform. At the

beginning of the work we review the operation of MonoGame framework, after which we

concentrated on Universal Windows Platform while paying special attention on parts

dedicated to game development. The knowledge we aquired is later used in the practical

part where we develop a 2D game named Type-Shooter. We paid special attention to the

comparisson of implementation of the game, when it is intended for playing on personal

computer or on a mobile device.

iii

KAZALO

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

2 OGRODJE MONOGAME .............................................................................................................. 2

2.1 Splošno o ogrodju............................................................................................................... 2

2.2 Zgodovina ogrodja .............................................................................................................. 4

2.3 Orodje MonoGame Pipeline Tool ....................................................................................... 5

2.3.1 XNB datotečna končnica ............................................................................................ 6

2.4 Pregled glavnih metod v projektu MonoGame .................................................................. 7

3 PLATFORMA UWP ...................................................................................................................... 8

3.1 Splošno o UWP platformi ................................................................................................... 8

3.2 Lastnosti UWP aplikacij ...................................................................................................... 9

3.2.1 Efektivni piksli in skaliranje ...................................................................................... 10

3.2.2 Univerzalni vnos in pametne interakcije .................................................................. 11

3.2.3 Univerzalne kontrole in stili ..................................................................................... 12

3.2.4 Anatomija UWP aplikacije ........................................................................................ 12

3.3 Družine naprav ................................................................................................................. 14

3.4 Omogočanje načina za razvijanje ..................................................................................... 15

3.5 Windows 10 API-ji ............................................................................................................ 17

3.5.1 3D grafika ................................................................................................................. 18

3.5.2 2D grafika in uporabniški vmesnik ........................................................................... 18

3.5.3 Zvok .......................................................................................................................... 19

3.5.4 Uporabniški vnos ...................................................................................................... 19

3.5.5 Matematika .............................................................................................................. 19

3.5.6 Omrežje .................................................................................................................... 20

4 PREDSTAVITEV IGRE ................................................................................................................. 21

4.1 Zvrst igre ........................................................................................................................... 21

4.2 Igra Type-Shooter ............................................................................................................. 22

4.3 Splošna implementacija ................................................................................................... 26

5 PRIMERJAVA RAZVOJA MED DRUŽINAMA ............................................................................... 33

5.1 Windows 10 ...................................................................................................................... 33

5.2 Windows 10 Mobile ......................................................................................................... 34

6 SKLEP ........................................................................................................................................ 37

7 VIRI ........................................................................................................................................... 38

iv

KAZALO SLIK

Slika 2.1: Igra Transistor, SuperGiant Games, 2014 ........................................................................... 2

Slika 2.2: Igra Axiom Verge, Thomas Happ Games LLC, 2015 ............................................................ 3

Slika 2.3: Igra Bastion, SuperGiant Games, 2011 ............................................................................... 4

Slika 2.4: MonoGame Pipeline Tool ................................................................................................... 6

Slika 3.1: Univerzalne aplikacije na sistemih Windows 10 ................................................................. 8

Slika 3.2: Skaliranje pisave na različnih velikostih zaslonov ............................................................. 10

Slika 3.3: Razredi naprav .................................................................................................................. 11

Slika 3.4: Predlagana anatomija aplikacije [7] .................................................................................. 13

Slika 3.5: Hierarhija družin naprav ................................................................................................... 14

Slika 3.6: Omogočanje načina za razvijalce ...................................................................................... 15

Slika 3.7: Nastavitve za razvijalce; levo – namizni računalnik, desno – mobilna naprava ............... 16

Slika 3.8: API družine za razvoj iger .................................................................................................. 17

Slika 4.1: Igra Farmville .................................................................................................................... 21

Slika 4.2: Začetni ekran na računalniku ............................................................................................ 23

Slika 4.3: Igranje na računalniku ...................................................................................................... 23

Slika 4.4: Končni ekran na računalniku ............................................................................................. 24

Slika 4.5: Izgled na mobilni napravi: a) začetni ekran, b) Igralni ekran, c) končni ekran .................. 24

Slika 4.6: Definicija stanj igre............................................................................................................ 26

Slika 4.7: Definicija razreda Player ................................................................................................... 27

Slika 4.8: Implementacija razreda Bullet .......................................................................................... 28

Slika 4.9: Implementacija razreda Word .......................................................................................... 29

Slika 4.10: Metoda Update ............................................................................................................... 30

Slika 4.11: Metoda za shranjevanje rezultata .................................................................................. 31

Slika 4.12: Metoda za branje rezultata ............................................................................................ 32

Slika 5.1: Računanje faktorja skaliranja na računalniku ................................................................... 33

Slika 5.2: Preverjanje uporabniškega vnosa na računalniku ............................................................ 34

Slika 5.3: Računanje faktorja skaliranja na mobilni napravi, bodite pozorni na zamenjana X in Y v

prvih dveh stavkih v primerjavi s sliko 5.1 ....................................................................................... 34

Slika 5.4: Prikaz navidezne tipkovnice na mobilni napravi ............................................................... 35

Slika 5.5: Preverjanje uporabniškega vnosa na mobilni napravi ...................................................... 36

v

KAZALO TABEL

Tabela 2.1: Podprte datoteke............................................................................................................. 5

Tabela 3.1: Razredi naprav ............................................................................................................... 11


1

1 UVOD

Skozi večino svoje zgodovine so bile računalniške igre namenjene sproščanju v prostem

času. V zadnjih letih pa je njihova popularnost še dodatno narasla, zaradi česar so postale

ena izmed največjih kategorij zabavne industrije. Vzpon mobilne tehnologije, pa nam je

omogočil, da lahko igramo vsepovsod.

Bliskovit razvoj pametnih telefonov, je bil en izmed ključnih faktorjev v povečanju

zanimanja za igre. Mobilna tehnologija nam namreč omogoča, da lahko igre vzamemo s

seboj na pot. Kljub temu pa so osebni računalniki in igralne konzole še vedno bolj

priljubljeni, saj so zaenkrat zmogljivejši od mobilnih tehnologij. Zaradi velikega števila

naprav, so se pojavila orodja za univerzalen razvoj aplikacij. En izmed teh je tudi

Microsoftov Universal Windows Platform(UWP), katerega največja prednost je, da združi

razvoj za naprave, na katerih teče operacijski sistem Windows in s tem omogočiti hiter in

učinkovit način razvoja aplikacij.

Zaradi vzpona popularnosti iger, pa so se pojavila orodja, ki olajšajo njihov razvoj. Takšnih

orodji je danes že veliko. Praktično vsak večji programski jezik ima vsaj enega. Sami smo

izbrali ogrodje MonoGame, ki je napisano v programskem jeziku C#. Poleg tega, pa podpira

tudi platformo UWP. Zaradi te sinergije, smo se odločili izdelati igro z uporabo teh dveh

tehnologij.

Diplomsko delo je razdeljeno v sedem poglavij. Najprej v uvodu na kratko predstavimo

temo in vsebino diplomskega dela. V drugem poglavju se spoznamo z delovanjem ogrodja

MonoGame. Nadaljujemo s predstavitvijo platforme UWP. V četrtem poglavju združimo do

sedaj pridobljeno znanje in predstavimo igro, ki smo jo razvili v praktičnem delu. Temu sledi

primerjava razvoja igre za osebne računalnike ter mobilne naprave. Na koncu podamo še

sklep in vire, ki so bili uporabljeni pri pisanju diplomskega dela.


2

2 OGRODJE MONOGAME

2.1 Splošno o ogrodju

MonoGame je odprtokodna implementacija ogrodja Microsoft XNA 4. Glavni cilj je

omogočiti poganjanje iger razvitih za sisteme Windows, na drugih sistemih, z minimalnimi

spremembami kode. Ogrodje poskuša v celoti implementirati XNA 4 API. To doseže z

uporabo knjižnic SharpDX in OpenTK, ter z uporabo platforme Xamarin.

Grafične zmožnosti ogrodja prihajajo iz knjižnic OpenGL, OpenGL ES ali DirectX, odvisno od

ciljne platforme. Od zadnje različice naprej so se razvijalci ogrodja odločili osredotočiti na

zmožnosti OpenGL 2. Pred tem je ogrodje za grafični prikaz uporabljalo OpenGL 1.x. Z

uporabo novejše različice vmesnika OpenGL, je ogrodje dobilo podporo za senčilnike.

Upravljanje vsebine sledi modelu XNA 4 ContentManager, razvijalci pa so ga še razširili in

omogočili integracijo z okoljem Visual Studio [6].

Z ogrodjem MonoGame je bilo razvitih že veliko iger. Najbolj znane med njimi so Transistor

(slika 2.1), Fez, Axiom Verge (slika 2.2), TowerFall in Bastion (slika 2.3).

Slika 2.1: Igra Transistor, SuperGiant Games, 2014


3

Trenutna različica ogrodja MonoGame podpira naslednje vmesnike [6]:

- Windows 8.1 in 10 Store aplikacije (DirectX),

- Windows Phone 8.1 in 10 (DirectX),

- Win32 (DirectX in OpenGL),

- Linux (OpenGL),

- Mac OS X (OpenGL),

- Android in iOS (OpenGL),

- Playstation 4, Vita (OpenGL),

- Xbox (DirectX),

- Nintendo Switch (OpenGL).

Slika 2.2: Igra Axiom Verge, Thomas Happ Games LLC, 2015


4

2.2 Zgodovina ogrodja

Podjetje Microsoft je 24. marca, 2004 na konferenci GDC v San Jose, Kalifornija naznanilo

ogrodje XNA. Prvi javni predogled ogrodja je izšel 14. marca, 2006. Naslednje leto,

decembra je izšel XNA Game Studio 2.0, kateremu je 30 oktobra, leta 2008, sledil XNA Game

Studio 3.0. Dve leti za tem, 16. septembra, 2010, pa je izšel XNA Game Studio 4.0, vključno

z orodji za razvoj iger na platformi Windows Phone. 31. januarja, 2013 je Microsoft razposlal

elektronsko pošto, s katero so uradno prenehali podporo ogrodju XNA [9].

Leta 2009 je José Antonio Leal de Farias, aktivni član skupnosti XNA, začel na odprtokodnem

projektu, ki se je takrat imenoval XNA Touch, s ciljem prenosa enostavnih 2D iger na

mobilne naprave. Decembra 2009 je izdal prvo različico na spletni strani Codeplex, ki pa je

podpirala samo iPhone [4].

Marca 2011 se je projekt preimenoval v MonoGame in se je prestavil na GitHub. V istem

letu se je pojavila podpora za Android, Mac, Linux in OpenGL na sistemih Windows.

V začetku 2012 so razvijalci dodali podporo za DirectX 11 in Windows 8. S tem so predstavili

prvi in trenutno edini način za prenašanje XNA iger v sistem Windows Store. Iz tega se je

nato razvila še podpora za Windows Phone 8 in platformo Universal Window Platform.

Slika 2.3: Igra Bastion, SuperGiant Games, 2011


5

2.3 Orodje MonoGame Pipeline Tool

MonoGame Pipeline Tool je orodje za upravljanje vsebine. Orodje predstavlja okolje za

pretvorbo vsebinskih datotek igre, v datoteke .xnb, ki jih uporabljajo MonoGame aplikacije.

Orodje se namesti ob namestitvi ogrodja MonoGame, Visual Studio pa ga avtomatsko

vključi v novo ustvarjen projekt.

Uporabniški vmesnik orodja za upravljanje vsebine sestoji iz več delov, kot je vidno na sliki

4:

1. Orodna vrstica,

2. datoteke vključene v projekt, ter njihova hierarhija,

3. lastnosti izbrane datoteke in

4. izhodna sporočila po izgradnji projekta.

Ogrodje MonoGame podpira široko paleto datotečnih formatov. V tabeli 2.1 je prikazanih

nekaj podprtih formatov datotek [3]:

Tabela 2.1: Podprte datoteke

Tip vsebine Končnice datotek

3D modeli .x, .fbx, .obj

Slike .bmp, .dds, .dib, .hdr, .jpg, .pfm, .png, .ppm, .tga

Zvok .xap, .wma, .mp3, .wav

Pisave .spritefont

Učinki .fx


6

Slika 2.4: MonoGame Pipeline Tool

2.3.1 XNB datotečna končnica

Datotečna končnica .xnb se uporablja ne glede na datotečni tip začetne datoteke. Z drugimi

besedami, slikovne, audio in kakršnekoli druge datoteke, se pretvorijo v datoteke s

končnico .xnb. Ker se končnica ne more uporabiti za razlikovanje med različnimi tipi

datotek, metode za nalaganje vsebino ogrodja MonoGame, ne pričakujejo datotečne

končnice, pri nalaganju datotek.


7

2.4 Pregled glavnih metod v projektu MonoGame

Ogrodje MonoGame se integrira z okoljem Visual Studio. Ob namestitvi ogrodja, se

namestijo tudi predloge Visual Studia, za različne platforme in tipe aplikacij.

Igralna logika se nahaja v datoteki, ki jo Visual Studio ob generiranju projekta poimenuje,

Game1.cs. Večina kritičnih metod je avtomatsko ustvarjenih v to datoteko ob ustvaritvi

novega projekta. Spodaj so opisane najbolj pomembne metode:

- public Game1() – Konstruktor. Začetnikom te metode ni potrebno spreminjati.

- protected override void Initialize() – v tej metodi inicializiramo vse razredne

spremenljivke, ki jih bo naša aplikacija uporabljala. Metoda je klicana enkrat, ob

začetku igre.

- protected override void LoadContent() – ta metoda naloži vso vsebino (slike, zvok,

pisave), ki jih bo naša igra uporabljala. Kot metoda Initialize(), je tudi ta metoda

klicana le enkrat na začetku.

- protected override void UnloadContent() – ta metoda se uporablja za brisanje

vsebine, ki je ne naložimo s pomočjo ContentManagerja.

- protected override void Update(GameTime gameTime) – ta metoda je klicana

enkrat za vsak cikel glavne zanke. Tukaj posodabljamo stanja objektov in

spremenljivk v igri, kot so pozicija, hitrost ali barva objekta. Znotraj te metode

poskrbimo tudi za upravljanje uporabnikovega vnosa. Na kratko povedano, ta

metoda skrbi za praktično vse dele igralne logike, razen izrisa na ekran.

- protected override void Draw(GameTime gameTime) – v tej metodi poskrbimo za

izris igre na ekran, z uporabo spremenljivk, ki jih posodabljamo v metodi Update.


8

3 PLATFORMA UWP

3.1 Splošno o UWP platformi

Universal Windows Platform je homogena arhitektura, ki jo je Microsoft prvič predstavil v

operacijskem sistemu Windows 10. Namen te platforme je pomoč pri razvoju univerzalnih

aplikacij, na sistemih Windows 10, Windows 10 Mobile, Xbox One in Hololens, brez potrebe

po ponovnem pisanju aplikacije za vsak sistem (slika 3.1). Podpira razvoj Windows aplikacij,

z jeziki C++, C#, VS.NET in XAML [5].

S platformo UWP je lažje podpirati različne resolucije in interakcijske modele od zaslonov

na dotik, miši in tipkovnice, igralne ploščke pa do pisal (slika 3.1). Glavna ideja platforme je

omogočiti uporabnikom isto uporabniško izkušnjo ne glede na družino naprave, ki jo v

nekem trenutku uporabljajo.

Slika 3.1: Univerzalne aplikacije na sistemih Windows 10


9

Nekaj značilnosti, ki ločijo UWP aplikacije od ostalih [7]:

1. Skupni jedrni vmesnik za namensko programiranje(API) na vseh napravah

UWP jedrni API je isti za vse razrede Windows naprav. Če neka aplikacija uporablja

samo jedrne funkcionalnosti platforme, bo delovala na vseh Windows 10 napravah.

2. Razširitveni kompleti za razvoj programske opreme(SDK), omogočajo razvijalcem

da na različnih tipih naprav delajo zanimive stvari

Razširitveni SDK-ji dodajo specializirane API-je za vsak razred naprav. Razvijalci

lahko ob zagonu aplikacije preverijo, na kateri napravi se aplikacija izvaja, in

omogočijo razširitve za ta razred naprav.

3. Aplikacije so zapakirane v format .AppX in dostopne preko Windows trgovine

Vse aplikacije UWP uporabljajo pakiranje AppX. To zagotavlja zanesljiv namestitveni

mehanizem in omogoča nemoteno posodabljanje.

4. Ena trgovina za vse naprave

Razvijalci aplikacij pošljejo svoj produkt na trgovino in določijo, katerim tipom

naprav je aplikacija na voljo.

5. Aplikacije podpirajo prilagodljiv vmesnik in uporabniški vnos

Elementi uporabniškega vmesnika uporabljajo efektivne piksle, da lahko prilagodijo

postavitev glede na število pikslov, ki so na voljo na napravi. Dobro delujejo z več

vrst uporabniškega vnosa, kot so tipkovnica, miška, dotik, pisalo in igralni plošček.

3.2 Lastnosti aplikacij UWP

Aplikacije, ki tečejo na platformi Universal Windows Platform, delujejo na kateri koli

Windows napravi, od telefona, tablice, do osebnega računalnika.

Ker imajo različne družine naprav, med sabo zelo različne velikosti ekranov in metode

vnosa, je razvoj aplikacij, ki delujejo in izgledajo dobro na vseh napravah velik izziv. Na srečo

platforma UWP razvijalcem zagotavlja skupek lastnosti in univerzalnih gradnikov, ki

pomagajo pri doseganju tega cilja.


10

3.2.1 Efektivni piksli in skaliranje

UWP aplikacije samodejno prilagodijo velikost elementov uporabniškega vmesnika, tako,

da so čitljivi na vseh napravah (slika 3.3).

Ko se aplikacija zažene na napravi, sistem uporabi algoritme za normaliziranje načina

prikaza elementov uporabniškega vmesnika. Upošteva razdaljo gledanja in gostost ekrana

da optimizira uporabniško izkušnjo za zaznano velikost, ne pa za fizično velikost. Algoritem

skaliranja zagotavlja, da je pisava velikosti 24 berljiva tako na televiziji oddaljeni 3 metre,

kot na telefonu, oddaljenem 30 cm [7].

Slika 3.2: Skaliranje pisave na različnih velikostih zaslonov

Zaradi načina delovanja algoritma, ki prilagaja velikost elementov, oblikujemo uporabniški

vmesnik glede na efektivne piksle in ne dejanske fizične piksle. Pri tem nas zanima, kako to

vpliva na način oblikovanja aplikacij?

Pri oblikovanju lahko prezremo gostoto pikslov in dejansko velikost ekrana. Namesto tega

oblikujemo en uporabniški vmesnik, platforma UWP pa ga prilagodi glede na velikost

razreda naprave (slika 3.4).

Ko sistem prilagaja uporabniški vmesnik, to naredi v večkratnikih števila 4. Zato je

priporočljivo da elemente zaskočimo na mrežo 4x4 pikslov. Upoštevamo, da pri tekstu to

ne velja in ima lahko kakršno koli velikost in pozicijo.


11

Tabela 3.1 in slika 3.4 opisujeta različne razrede velikosti.

Tabela 3.1: Razredi naprav

Razred velikosti Majhen Srednji Velik

Tipična velikost

ekrana

4 do 6 inčev 7 do 12 inčev, ali TV 13 inčev in več

Tipična naprava Telefon Tablica Računalnik

Pogoste velikosti

ekrana v efektivnih

pikslih

320x569, 360x640,

480x854

960x540, 1024x640 1366x768,

1920x1080

Slika 3.3: Razredi naprav

3.2.2 Univerzalni vnos in pametne interakcije

Ena izmed zmožnosti, vgrajenih v platformo UWP, je univerzalni vnos, omogočen s

pametnimi interakcijami. Razvijalci se lahko odločijo načrtovati aplikacije za specifičen

način vnosa oz. napravo, vendar v to niso prisiljeni. Univerzalne Windows aplikacije se

privzeto nanašajo na pametne interakcije. To pomeni, da lahko razvijalec načrtuje dogodek

klika, brez da ve, ali je prišel klik iz miške, ali iz prsta.


12

3.2.3 Univerzalne kontrole in stili

UWP ponuja niz univerzalnih kontrol, za katere je zagotovljeno da delujejo na vseh

Windows napravah. Ta niz univerzalnih kontrol vključuje vse, od preprostih gradnikov, kot

so polja z besedilom, do bolj zapletenih elementov, kot je seznam. Vse te kontrole vedo,

kakšen način vnosa morajo ponuditi, glede na napravo.

Vsaka aplikacija UWP avtomatsko dobi privzet niz stilov, ki ji dajo naslednje lastnosti:

- Niz stilov, ki avtomatsko priredijo aplikaciji svetel ali temen izgled vključno z

uporabnikovimi izbranimi barvami naprave,

- pisavo, ki poskrbi, da besedilo izgleda ostro na vseh napravah,

- avtomatsko podporo za visoko-kontrastni način,

- avtomatsko podporo za različne jezike. Privzeti stili avtomatsko izberejo pravilno

pisavo, za vsak jezik, ki ga sistem Windows podpira,

- vgrajeno podporo za branje iz desne proti levi

Te stile lahko razvijalec prilagodi, ali pa jih popolnoma zamenja s svojimi, da ustvari

edinstveno vizualno izkušnjo.

3.2.4 Anatomija aplikacije UWP

Moderni uporabniški vmesnik je zapletena reč, sestavljena iz besedila, oblik, barv in

animacij. Na začetku načrtovanja uporabniškega vmesnika, je lahko število izbir preveliko.

Da bi bile stvari enostavnejše, je Microsoft definiral grobo anatomijo aplikacije iz

perspektive oblikovanja izgleda.

Vsaka aplikacija je sestavljena iz zaslonov in strani, ki prikazujejo elemente aplikacije. Vsaka

stran ima uporabniški vmesnik, sestavljen iz treh delov:


13

- Navigacijski elementi (Navigation elements)

pomagajo uporabniku izbrati vsebino, ki jo želi videti. Primer navigacijskega

elementa so zavihki in hiperpovezave.

- Vsebinski elementi (Content elements)

Ti elementi prikazujejo vsebino aplikacije.

- Ukazni elementi (Command elements)

Ukazni elementi izvajajo akcije, kot so shranjevanje, deljenje in upravljanje z

vsebino.

Slika 3.4: Predlagana anatomija aplikacije [7]


14

3.3 Družine naprav

Za razumevanje, kako Windows 10 omogoča ciljanje na različne razrede naprav, je dobro

razumeti koncept imenovan družine naprav. Ena družina naprav predstavlja API,

karakteristike sistema in obnašanje, ki ga lahko razvijalci pričakujejo od razreda naprav.

Prav tako določa niz naprav, na katere se lahko neka aplikacija namesti. Družina naprav (z

izjemo Univerzalne družine) je implementirana kot razširitven SDK. Slika 3.5 prikazuje

hierarhije družine naprav:

Slika 3.5: Hierarhija družin naprav

Družina naprav je definirana z nizom API-jev in je temelj operacijskega sistema. Osebni

računalniki in tablice poganjajo namizno, medtem, ko telefoni poganjajo mobilno različico

operacijskega sistema. Vsaka izpeljana družina naprav, doda svojevrstne API-je, tistim ki

jih podeduje od matične družine.

Ena izmed koristi univerzalne družine naprav je, da se lahko aplikacija izvaja na vseh

napravah, ki podpirajo sistem Windows. Prav tako lahko aplikacija uporablja prilagodljivo

kodo, za dinamično zaznavo in uporabo lastnosti naprave, ki je zunaj univerzalne družine.

Odločitev, katere družine naprav ciljati, leži v rokah razvijalcev. Ta odločitev vpliva na

aplikacijo na nekaj pomembnih načinov:

1. Določa funkcionalnosti, za katere lahko aplikacija sklepa, da so na voljo, ko se

zažene,

2. določa funkcionalnosti, ki so varne samo znotraj pogojnih stavkov,

3. določa naprave na katere se lahko aplikacija namesti.


15

Pri odločitvi družine naprav so dve glavni posledici: fiksira se na nabor API-jev, ki jih

aplikacija lahko kliče, ter na število naprav, ki lahko aplikacijo poganjajo. Ta dva faktorja

vključujeta kompromise in sta si obratno sorazmerna. Na primer, aplikacija cilja univerzalno

družino in je posledično na voljo vsem napravam. Takšna aplikacija lahko brezpogojno

uporablja samo API-je univerzalne družine. Ostale API-je mora klicati v pogojnih stavkih.

Prav tako mora imeti zelo prilagodljiv uporabniški vmesnik in obsežen spekter

uporabniškega vnosa, ker se lahko izvaja na raznovrstnih napravah.

3.4 Omogočanje načina za razvijanje

Za razvijanje univerzalnih aplikacij, je potrebno na računalniku, ki se uporablja za razvoj in

na vseh ostalih testnih napravah, ki bodo poganjale aplikacijo, omogočiti način za

razvijalce. Če način za razvijalce ni omogočen in odpremo UWP projekt, bo sistem odprl

stran z nastavitvami za razvijalce ali pa okno, prikazano na sliki 3.6:

Slika 3.6: Omogočanje načina za razvijalce

Ko se pojavi to okno, kliknemo na »settings for developers« kar odpre stran z nastavitvami

za razvijalce (slika 3.7).


16

Na tej strani lahko omogočimo napravi način za razvijanje ali pa samo obstransko

nameščanje aplikacij:

- Windows Store apps – je privzeta nastavitev. Če se naprava ne uporablja za

razvijanje oz. testiranje, izberemo to nastavitev,

- Sideload apps – omogoči namestitev in poganjanje aplikacij, ki niso certificirane za

trgovino Windows,

- Developer mode – omogoči nameščanje neoverjenih aplikacij in poganjanje

aplikacij iz okolja Visual Studio v načinu razhroščevanja.

Slika 3.7: Nastavitve za razvijalce; levo – namizni računalnik, desno – mobilna naprava


17

3.5 Windows 10 API-ji

Windows 10 priskrbi obsežno zbirko API-jev, ki so uporabni za razvoj računalniških iger. API-

ji obstajajo za skoraj vsako področje računalniških iger, vendar vsaka igra nujno ne

uporablja vseh. Nekatere igre uporabljajo izključno 3D grafiko, nekatere samo 2D, medtem

ko tretje uporabljajo oboje. Slika 3.8 prikazuje API-je ki se navezujejo na razvoj iger,

združene po funkcionalnosti.

Slika 3.8: API družine za razvoj iger


18

3.5.1 3D grafika

Windows 10 podpira dva grafična API-ja, Direct3D 11 in Direct3D 12, vendar se mora

razvijalec odločiti, katerega izmed njiju bo uporabljal, saj med seboj nista kompatibilna. Oba

lahko prikažeta tako 2D kot 3D grafiko.

- Direct3D 12 – je najnovejša različica Direct3D grafičnega API-ja. Zasnovana je za

večjo hitrost in učinkovitost kot prejšnje različice. Kompromis za to hitrost in

učinkovitost pa je programiranje na nižjem nivoju, kar zahteva od razvijalca več

znanja in pozornosti pri programiranju.

- Direct3D 11 – je prejšnja različica Direct3D API-ja in omogoča prikaz 3D grafike z

višjim nivojem abstrakcije kot Direct3D 12.

3.5.2 2D grafika in uporabniški vmesnik

Skupek API-jev, ki so odgovorni za prikaz besedila, oblik in uporabniškega vmesnika na

zaslon. Vsi API-ji 2D grafike in uporabniškega vmesnika so neobvezni.

- Direct2D – je strojno pospešen API za prikaz 2D grafike, ki je zmožen visoke

zmogljivosti in kvalitete prikaza 2D geometrije, slik in besedila

- DirectWrite – priskrbi dodatne zmogljivosti za delo z besedilom in se lahko uporablja

hkrati z vmesnikoma Direct3D ali Direct2D za prikaz besedila

- DirectComposition – je komponenta ki omogoči visoko zmogljivo sestavo bitnih slik

z uporabo transformacij, učinkov in animacij


19

3.5.3 Zvok

Združuje funkcionalnosti, ki omogočajo predvajanje zvoka in zvočnih učinkov.

- XAudio2 – je nizkonivojski zvočni API, ki postavi temelj za obdelavo in mešanje

signalov,

- Media Foundation – je zasnovan za predvajanje zvočnih in video datotek.

3.5.4 Uporabniški vnos

V to skupino so združeni API-ji, ki skrbijo za uporabniški vnos, iz vseh tipov naprav, ki jih

podpira platforma UWP.

- XInput – omogoči aplikaciji, da sprejema vhode iz igralnega ploščka,

- Windows.Gaming.Input – Zamenja XInput z istimi funkcionalnostmi, doda pa še

nekaj novih,

- Window.UI.Core.CoreWindow – priskrbi dogodke za sledenje premikov in klikov

kazalca ter pritisku gumbov.

3.5.5 Matematika

Zbirka knjižnic in funkcij za poenostavitev pogosto uporabljenih matematičnih operacij.

- DirectXMath – priskrbi tipe Single instruction, multiple data (SIMD) in funkcije za

pogosto uporabljene matematične operacije linearne algebre in računalniške

grafike.


20

3.5.6 Omrežje

Združuje funkcionalnosti, ki skrbijo za komuniciranje z drugimi računalniki in napravami,

bodisi preko Interneta, bodisi preko zasebnega omrežja

- Windows.Networking.Sockets – priskrbi vtičnike TCP in UDP, ki omogočijo zanesljivo

ali nezanesljivo omrežno komunikacijo.

- Windows.Web.HTTP – priskrbi zanesljivo povezavo na strežnike http, ki se

uporabljajo za dostop do spletnih strani.


21

4 PREDSTAVITEV IGRE

4.1 Zvrst igre

Igre, s podobnim načinom igranja, se klasificirajo v neko zvrst. Po navadi zvrsti niso

definirane z dejansko vsebino igre, temveč s podobnimi igralnimi elementi. Zvrsti obsegajo

široko raznolikost iger, kar vodi do še bolj specifične klasifikacije podzvrsti. Nekatere,

predvsem mobilne in igre v brskalniku, so po navadi klasificirane v več zvrsti.

Največ mesečnih uporabnikov imajo arkadne, pustolovske in miselne igre. Igre, za katere

pa igralci porabijo največ časa, pa so miselne, priložnostne in arkadne igre. Če pa

pogledamo stvari iz tržnega vidika, pa daleč največ prihodkov prinesejo strateške igre in

igre igranja vlog [8]. Pri praktičnem delu smo se odločili za izdelavo priložnostne igre, katero

lahko uporabniki zaženejo in končajo kadarkoli, brez večjih posledic znotraj igre.

Priložnostne igre, med katere spada tudi naša, so igre ki ciljajo na priložnostne igralce. Imajo

lahko kakršenkoli način igranja oz. zvrst. Od ostalih iger se po navadi razlikujejo s

preprostimi pravili ter po manjši potrebi vloženega časa in veščin. Za razliko od ostalih jih

najpogosteje igrajo starejši ljudje, bolj pogosto pa tudi ženske, ki predstavljajo več kot 74%

vseh priložnostnih igralcev [8].

Slika 4.1: Igra Farmville


22

Arkadna igra Pac-Man podjetja Namco, ki je izšla leta 1980 velja za prvo priložnostno igro.

Ocenjeno je, da naj bi bila v 20 stoletju igrana več kot deset milijard krat, kar jo uvršča med

najbolj dobičkonosne igre vseh časov. Microsoftova Pasjansa (1990), ki je izšla zastonj ob

sistemu Microsoft Windows, je upoštevana kot prva uspešna priložnostna igra na

računalniku.

Prihod tehnologije Flash, je sprožil razcvet v svetu spletnih iger in je vzpodbujal razvijalce

da ustvarjajo preproste igre, ki se jih je dalo dokončati v enem igranju.

Priložnostne igre so pogosto računalniške simulacije tradicionalnih iger, kot so šah, dama,

fliper, poker, sudoku in pasjansa.

V letu 2008 so na popularnosti začele pridobivati igre na socialnih omrežjih, kot je Happy

Farm na Kitajskem. Ta igra je bila navdih za mnoge druge podobne igre, med drugimi tudi

za najbolj popularno igro na socialnih omrežjih FarmVille (slika 4.1), ki ima več ko 70

milijonov aktivnih uporabnikov po celem svetu [10].

4.2 Igra Type-Shooter

Pri praktičnem delu diplomske naloge smo razvili preprosto 2D igro streljanja besed. Igra je

preprosta za igranje, kar je značilno za izbrano zvrst iger. Glavni cilj igre je naučiti igralce

hitrega tipkanja. Igro smo implementirali za sistema Windows 10 in Windows 10 Mobile. V

tem poglavju bo opisana splošna implementacija igre, medtem ko bomo primerjavo med

platformama opisali v naslednjem poglavju.

Za igro smo oblikovali tri zaslone. Prvi je začetni (slika 4.2, slika 4.5 a), na katerem je izpisano

ime igre, navodila ter najvišji rezultat. Naslednji je igralni zaslon (Slika 4.3, Slika 4.5 b), tretji

pa je zaslon ki se prikaže ob koncu igre (Slika 4.4, Slika 4.5 c).


23

Slika 4.2: Začetni ekran na računalniku

Slika 4.3: Igranje na računalniku


24

Slika 4.4: Končni ekran na računalniku

a) b) c)

Slika 4.5: Izgled na mobilni napravi: a) začetni ekran, b) Igralni ekran, c) končni ekran


25

Vse grafične elemente igre smo oblikovali sami, z zastonjsko programsko opremo. Ker na

ekranu ne prikazujemo veliko objektov naenkrat, nam ni bilo treba biti pozorni na

kompleksnost objektov. Zvočne efekte smo pridobili iz zastonjskih baz zvočnih posnetkov

na internetu. Za seznam besed smo uporabili kar slovar najbolj pogostih angleških besed.

Cilj igre je, da igralec zbere čim večje število točk. Besede se počasi premikajo po ekranu

navzdol. Barva ozadja je zelena, kot šolska tabla, besede pa izgledajo kot, da so na roko

napisane s kredo. Naloga igralca je, da s pisanjem besed na tipkovnico, strelja kaplje vode

in s tem briše črke besed prikazanih na ekranu. Vsaka beseda je vredna toliko, kot ima črk.

Ko igralec uniči besedo se njena vrednost (t.j. število črk v besedi) prišteje k skupnemu

seštevku trenutne igre. Besedam se hitrost padca počasi a konstantno povečuje. S tem igra

prisili igralca, da se navadi hitrega tipkanja, saj je drugače igre konec. Ob pritisku tipke, igra

preveri, če je kakšna beseda že v fokusu. Če je, ustreli proti njej, drugače poišče najbližjo

besedo, ki se začne na pritisnjeno črko, jo fokusira in ustreli proti njej. Igra se konča, ko

katerakoli beseda pride na določeno višino, pod katero se je ne da več ustreliti.


26

4.3 Splošna implementacija

Večino igre smo implementirali hkrati, za sistem Windows 10 in Windows 10 Mobile, saj je

to glavna prednost platforme UWP. Primerjava implementacije med sistemoma bo opisana

v naslednjem poglavju. V tem poglavju pa se bomo osredotočili na dele, ki so isti pri obeh

sistemih.

Poleg datotek, ki jih Visual Studio generira avtomatsko, smo projektu dodali datoteko

Razredi.cs, v kateri so implementirani vsi razredi in strukture, ki smo jih potrebovali za igro.

Definirali smo tri razrede in en števni tip, ki služi za menjavo prikaznih zaslonov.

public enum GameState

{

MainMenu,

Gameplay,

EndGame

}

Slika 4.6: Definicija stanj igre

Slika 4.6 prikazuje števni tip, ki se uporablja za menjavo prikazanih zaslonov. Igra ima eno

instanco tega objekta in ga spreminja glede na dogodke v igri. Ob zagonu se vrednost

objekta postavi na MainMenu.

Objekt, ki predstavlja igralca definiramo s pozicijo, sliko, sliko izstrelka, praznim seznamom

za izstrelke in pisavo. Pozicija in izgled igralca ter izgled izstrelka so skozi celotno izvajanje

igre statični, zato jih nastavimo enkrat ob zagonu igre. Seznam izstrelkov pa polnimo oz.

praznimo glede na število izstrelkov, ki so prisotni na ekranu (slika 4.7).


27

public class Player

{

public Vector2 Position { get; set; } public List<Bullet> bullets = new List<Bullet>();

Texture2D texture;

Texture2D bulletTexture; SpriteFont font;

public Player(Vector2 virtualScreen, Texture2D texture, Texture2D bulletTexture, SpriteFont font, bool desktop)

{

if(desktop) Position = new Vector2(virtualScreen.X / 2 - ((texture.Width / 2) * 0.2f),

1220);

else

Position = new Vector2(virtualScreen.X / 2 - ((texture.Width / 2) * 0.2f), 1340); this.texture = texture;

this.bulletTexture = bulletTexture; this.font = font;

}

public void Shoot(Word word) {

string x = string.Join("", word.Beseda);

Vector2 center = new Vector2(word.Position.X + font.MeasureString(x).X/2,

word.Position.Y);

Vector2 shootDirection = center - Position;

shootDirection.Normalize();

bullets.Add(new Bullet(Position, shootDirection, bulletTexture));

}

public void Update(GameTime gameTime) {

for(int i = 0; i < bullets.Count; i++)

{

bullets[i].Move(gameTime);

}

}

public void Draw(SpriteBatch spriteBatch) {

spriteBatch.Draw(texture, Position, null, Color.White,

0.0f, new Vector2(0, 0), 0.2f, SpriteEffects.None, 0.0f); }

}

Slika 4.7: Definicija razreda Player


28

Definicijo izstrelkov, ki jih igralec hrani v seznamu, prikazuje slika 4.8.

public class Bullet

{

public Vector2 Position { get; set; } public Vector2 Direction { get; set; }

public float Velocity { get; set; }

Rectangle collisionBox; Texture2D texture;

public Bullet(Vector2 position, Vector2 direction, Texture2D texture) {

Position = position;

Direction = direction; this.texture = texture;

Velocity = 2000f;

collisionBox = new Rectangle((int)Position.X, (int)Position.Y, texture.Width,

texture.Height); } public void Move(GameTime gameTime)

{ Position += Direction * Velocity *

(float)gameTime.ElapsedGameTime.TotalSeconds;

collisionBox = new Rectangle((int)Position.X, (int)Position.Y, texture.Width,

texture.Height);

}

public void Draw(SpriteBatch spriteBatch)

{

spriteBatch.Draw(texture, Position, null, Color.White, 0.0f,

new Vector2(0, 0), 0.1f, SpriteEffects.None, 0.0f);

} public bool Collision(Word word)

{

if(collisionBox.Intersects(word.collisionBox))

{

return true;

}

return false;

}

}

Slika 4.8: Implementacija razreda Bullet

Vsak izstrelek ima svojo pozicijo, smer leta, hitrost leta, nevidni kvadrat, ki se uporablja za

testiranje trčenj in sliko. Za razliko od objekta igralca, izstrelki niso statični. Pozicija se

spreminja skozi življenje izstrelka, glede na njegovo hitrost, medtem ko se smer premika

nastavi ob prvi pojavitvi posameznega izstrelka. Izstrelek se uniči, ko pride v kontakt z

besedo, v katero je bil izstreljen.


29

public class Word {

public Vector2 Position { get; set; } public Vector2 Direction { get; set; } public List<char> Beseda { get; set; } public Rectangle collisionBox; public int value; public bool focus = false; float velocity = 25; Texture2D pixel; SpriteFont font; public Word(Vector2 position, Vector2 direction, string beseda, SpriteFont font, GraphicsDevice gd) {

Position = position; Direction = direction; Beseda = beseda.ToList<char>(); value = Beseda.Count; this.font = font; collisionBox = new Rectangle((int)Position.X, (int)Position.Y, (int)font.MeasureString(beseda).X, (int)font.MeasureString(beseda).Y); pixel = new Texture2D(gd, 1, 1, false, SurfaceFormat.Color); pixel.SetData(new[] { Color.White }); }

public void Draw(SpriteBatch spriteBatch) {

int textWidth = (int)font.MeasureString(string.Join("", Beseda)).X; int textX = collisionBox.Width - textWidth; Vector2 textPosition = new Vector2(Position.X + (textX)/2, Position.Y); if(focus) {

spriteBatch.DrawString(font, b, textPosition, Color.DarkRed); spriteBatch.Draw(pixel, new Rectangle(collisionBox.Left, collisionBox.Top, 4, collisionBox.Height), Color.DarkRed); spriteBatch.Draw(pixel, new Rectangle(collisionBox.Right, collisonBox.Top,

4, collisionBox.Height), Color.DarkRed); spriteBatch.Draw(pixel, new Rectangle(collisionBox.Left, collisionBox.Top, collisionBox.Width, 4), Color.DarkRed); spriteBatch.Draw(pixel, new Rectangle(collisionBox.Left, collisionBox.Bottom, collisionBox.Width, 4), Color.DarkRed); }

else {

spriteBatch.DrawString(font, b, textPosition, Color.White); spriteBatch.Draw(pixel, new Rectangle(collisionBox.Left - 10, collisionBox.Top - 10, 4, collisionBox.Height + 20), Color.White); spriteBatch.Draw(pixel, new Rectangle(collisionBox.Right + 10, collisionBox.Top - 10, 4, collisionBox.Height + 20), Color.White); spriteBatch.Draw(pixel, new Rectangle(collisionBox.Left - 10, collisionBox.Top - 10, collisionBox.Width + 20, 4), Color.White); spriteBatch.Draw(pixel, new Rectangle(collisionBox.Left - 10, collisionBox.Bottom + 10, collisionBox.Width + 23, 4), Color.White); }

}

public void Move(GameTime gameTime, int wordCount) { Position += Direction * velocity * gameTime.ElapsedGameTime.TotalSeconds;

collisionBox.X = (int)Position.X; collisionBox.Y = (int)Position.Y; }

}

Slika 4.9: Implementacija razreda Word


30

Slika 4.9 predstavlja implementacije besede. Implementacija je podobna izstrelku, saj se

oba tipa objektov premikata po ekrani. Prav tako kot izstrelek ima tudi beseda svojo

pozicijo, ki se spreminja skozi življenje besede, smer, ki je določena ob nastanku besede in

hitrost, s katero se premika po ekranu. Vsaka beseda ima svoj obkrožujoči kvadrat, ki ni

viden in služi za preverjanje trkov z izstrelki. Poleg vsega naštetega ima še seznam znakov,

ki se, ob zadetku, odstranjujejo en po en, vrednost, ki se prišteje skupnemu seštevku, ko se

beseda uniči, spremenljivko, ki določa, ali je beseda fokusirana ali ne in na koncu še pisavo.

Vse to je skupno za oba sistema, na katerih se igra poganja. Spodaj je navedenih še nekaj

skupnih točk iz glavne datoteke Game1.cs.

Znotraj te datoteke sta najbolj pomembni dve metodi Update(GameTime gameTime) in

Draw(GameTime gameTime). Prva skrbi za računanje in posodabljanje vrednosti

spremenljivk, medtem ko druga skrbi za prikaz elementov na ekran [2]. Zgoraj je opisan

števni tip, ki skrbi za prikaz pravilnega zaslona v igri. V obeh metodah smo uporabili stavek

switch, za določanje obnašanja igre v določenem stanju (slika 4.10).

protected override void Update(GameTime gameTime)

{

switch(gameState) {

case GameState.MainMenu:

MainMenuUpdate(gameTime);

break;

case GameState.Gameplay:

GameplayUpdate(gameTime); break;

case GameState.EndGame:

EndGameUpdate(gameTime); break;

}

base.Update(gameTime);

}

Slika 4.10: Metoda Update


31

Platforma UWP za shranjevanje datotek uporablja skupek API-jev znotraj imenskih

prostorov Windows.Storage, Windows.Storage.Streams in Windows.Storage.Pickers za

pisanje in branje datotek in upravljanje z mapami. Le ti nam omogočijo dostop do prostora

na disku, ki je rezerviran za našo aplikacijo ter manipulacijo z datotekami in mapami znotraj

tega prostora.

V naši aplikaciji uporabljamo datoteko za shranjevanje najvišjega doseženega rezultata.

Rezultat najprej pretvorimo v spremenljivko tipa byte, nato pa ga zapišemo v binarno

datoteko [1]. To storimo iz varnostnih razlogov, da igralci ne morejo ročno spreminjati

najvišjega doseženega rezultata. Na sliki 4.11 je prikazana implementirana metoda za

shranjevanje rezultata.

private void SaveHighScore()

{

highScoreFile = IsolatedStorageFile.GetUserStoreForApplication(); IsolatedStorageFileStream isfs = null;

using (isfs = highScoreFile.CreateFile("HighScore"))

{

if(isfs != null)

{

byte[] bytes = System.BitConverter.GetBytes(playerScore);

isfs.Write(bytes, 0, bytes.Length);

}

}

}

Slika 4.11: Metoda za shranjevanje rezultata

Ob vsakem zagonu igre iz datoteke, v katero smo z metodo na sliki 4.11 rezultat shranili, le

tega preberemo, da ga lahko izpisujemo na začetnem in končnem zaslonu. Preberemo ga v

polje byte-ov, saj smo ga prej zapisali v tej obliki. Na sliki 4.12 je prikazana implementacija

metode za pridobivanje shranjenega rezultata iz datoteke.


32

private int LoadHighScore() {

using (highScoreFile = IsolatedStorageFile.GetUserStoreForApplication()) {

if(highScoreFile.FileExists("HighScore")) { using (IsolatedStorageFileStream fileStream =

highScoreFile.OpenFile("highScore", System.IO.FileMode.Open)) { if(fileStream != null) {

byte[] readBytes = new byte[4]; int count = fileStream.Read(readBytes, 0, 4); if(count > 0) {

return System.BitConverter.ToInt32(readBytes, 0); }

}

}

}

}

return 0; }

Slika 4.12: Metoda za branje rezultata


33

5 PRIMERJAVA RAZVOJA MED DRUŽINAMA

Glavni cilj platforme UWP je razvoj aplikacij za več družin naprav hkrati. Iz tega razloga smo

našo aplikacijo razvili hkrati za sistema Windows 10 in Windows 10 Mobile. V tem poglavju

se bomo osredotočili na primerjavo razvoja aplikacije za prej omenjena sistema.

Velika prednost platforme UWP je deljenje kode med družinami naprav, zato je v našem

projektu veliko kode skupne. Večino razlik najdemo pri obravnavanju uporabniškega vnosa,

ter izrisu na ekran.

Ker ne vemo v naprej, na kakšni napravi in s tem tudi na kakšni resoluciji bo aplikacija na

koncu delovala, smo se odločili da nastavimo interno resolucijo, s katero se igra izrisuje, na

2560x1440 za sisteme Windows in 1440x2560 za mobilno različico. Ob zagonu aplikacije

nato pridobimo dejansko resolucijo zaslona naprave in nato izračunamo faktor skaliranja

za izris na zaslon (sliki 5.1 in 5.3).

5.1 Windows 10

Razvijanje za platformo Windows 10 je zelo enostavno. Ker se izmed vseh družin naprav

platforme UWP uporablja najpogosteje, je zanj razvitih in dodelanih največ API-jev.

public Vector2 desktopVirtualScreen = new Vector2(2560, 1440);

widthScale = GraphicsDevice.PresentationParameters.BackBufferWidth / trueVirtualScreen.X;

heightScale = GraphicsDevice.PresentationParameters.BackBufferHeight /

trueVirtualScreen.Y;

scalingFactor = new Vector3(widthScale, heightScale, 1); scalingMatrix = Matrix.CreateScale(scalingFactor);

Slika 5.1: Računanje faktorja skaliranja na računalniku


34

Za preverjanje uporabnikovega vnosa, si ob zagonu pripravimo dve spremenljivki, ki

predstavljata trenutno in prejšnje stanje tipkovnice. Ob vsaki iteraciji glavne zanke,

primerjamo ti dve spremenljivki in iz tega razberemo, katere tipke so bile pritisnjene v

trenutni iteraciji. Na podlagi tega ustvarimo izstrelek in ga pošljemo v pravilno smer glede

na trenutno besedo (slika 5.2).

KeyboardState newState, oldState;

newState = Keyboard.GetState();

pressed = CheckInput(newState, oldState);

oldState = newState;

private Keys CheckInput(KeyboardState newState, KeyboardState oldState) {

if (newState.IsKeyDown(Keys.A) && oldState.IsKeyUp(Keys.A))

return Keys.A;

…

if (newState.IsKeyDown(Keys.Z) && oldState.IsKeyUp(Keys.Z))

return Keys.Z;

}

Slika 5.2: Preverjanje uporabniškega vnosa na računalniku

5.2 Windows 10 Mobile

Ker imata zaslon računalnika horizontalno, zaslon mobilne naprave pa vertikalno

orientacijo, je treba izris na mobilnih napravah prilagoditi za vertikalno orientacijo.

public Vector2 mobileVirtualScreen = new Vector2(1440, 2560);

widthScale = GraphicsDevice.PresentationParameters.BackBufferWidth /

trueVirtualScreen.Y;

heightScale = GraphicsDevice.PresentationParameters.BackBufferHeight /

trueVirtualScreen.X;

scalingFactor = new Vector3(widthScale, heightScale, 1); scalingMatrix = Matrix.CreateScale(scalingFactor);

Slika 5.3: Računanje faktorja skaliranja na mobilni napravi, bodite pozorni na zamenjana X

in Y v prvih dveh stavkih v primerjavi s sliko 5.1


35

Večina mobilnih naprav za uporabniški vnos uporablja dotik. Dandanes so mobilne naprave

s fizično tipkovnico redke, zato je treba za vnos besedila uporabiti navidezno tipkovnico. To

zna predstavljati težave, saj se navidezna tipkovnica po navadi pojavi samo kadar uporabnik

pritisne na polje za vnos besedila. Na srečo obstajajo razredi, s katerimi lahko razvijalec

prisili prikaz navidezne tipkovnice kadarkoli v aplikaciji (slika 5.4).

CoreWindow coreWindow;

InputPane ip;

private void ShowKeyboard()

{

coreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>

{

ip = InputPane.GetForCurrentView();

ip.TryShow();

});

}

private void HideKeyboard()

{

coreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.High, () =>

{

ip = InputPane.GetForCurrentView();

ip.TryHide();

});

}

Slika 5.4: Prikaz navidezne tipkovnice na mobilni napravi


36

Keys newMobilePressedKey, oldMobilePressedKey;

private void Dispatcher_AcceleratorKeyActivated(CoreDispatcher sender,

AcceleratorKeyEventArgs args) {

if (args.VirtualKey == VirtualKey.A) newMobilePressedKey = Keys.A;

…

else if (args.VirtualKey == VirtualKey.Z) newMobilePressedKey = Keys.Z; else if(args.VirtualKey == VirtualKey.None) newMobilePressedKey = Keys.None;

}

pressed = CheckInputMobile(newMobilePressedKey, oldMobilePressedKey);

private Keys CheckInputMobile(Keys newPressed, Keys oldPressed)

{

if (newPressed == Keys.A && oldPressed == Keys.None)

return Keys.A;

…

if (newPressed == Keys.Z && oldPressed == Keys.None) return Keys.Z; return Keys.None;

}

Slika 5.5: Preverjanje uporabniškega vnosa na mobilni napravi

Za trenutno pritisnjene tipke, preverjamo podobno kot pri računalniku. Tokrat smo si

namesto stanja celotne tipkovnice pripravili dve spremenljivki, ki predstavljata pritisnjeno

tipko v trenutnem in v prejšnjem ciklu. Virtualni tipkovnici smo pritrdili dogodek, ki se sproži

ob vsakem pritisku tipke (slika 5.5). Ta dogodek nastavlja trenutno pritisnjeno tipko, ki jo

potem primerjamo s tipko v prejšnjem ciklu. Primerjava stanj tipk je vezana na streljanje

kapljic vode za brisanje črk. Če stanj ne preverjamo, igra tipko bere kot pritisnjeno ob vsaki

iteraciji glavne zanke, ter zaradi tega neprestano izstreljuje kapljice. S primerjavo stanj med

iteracijami pa zagotovimo, da je kaplja izstreljena le enkrat.


37

6 SKLEP

V diplomskem delu smo se seznanili z ogrodjem MonoGame in platformo UWP. Naprej smo

si podrobno ogledali ogrodje MonoGame, čemur je sledila platforma UWP. V drugem delu

naloge, pa smo spoznanja prvega dela naloge, uporabili za implementacijo 2D igre za

namizne računalnike in mobilne naprave. Na koncu smo primerjali razlike v razvoju med

družinama naprav. Če bi želeli, bi lahko v prihodnosti igro dodelali z več načini igranja,

možnostjo da uporabnik sam poda besedilo iz katerega aplikacija nato črpa besed, raznimi

bonusi, ki bi igralcu olajšali igranje, ter dodelali grafični izgled igre.

Ugotovili smo, da je s pomočjo platforme UWP razvoj aplikacije za več družin naprav

izjemno preprost, saj lahko različne družine poganjajo isto kodo, brez večjih sprememb.

Največje razlike v kodiranju za različne družine so v obravnavi uporabniškega vnos in v

prikazu na zaslon.

Iz praktičnega dela lahko sklepamo, da se Microsoft zelo trudi razvijalcem olajšati delo.

Platforma UWP je odlično prilagojena za pisanje aplikacij, ki jih poganja več družin naprav,

ogrodje MonoGame pa razvijalcem olajša delo pri razvijanju iger.

Obe orodji se konstantno razvijajo in dograjujejo, tako da bosta v prihodnosti sposobna še

več stvari.


38

7 VIRI

[1] K. Jaegers, (2010), XNA 4.0 Game Development by Example: Beginner's Guide

[2] J. Pavleas, J. K. Chang, K. Sung, R. Zhu, (2013), Learn 2D Game Development with C#: For iOS,

Android, Windows Phone, Playstation Mobile and More

[3] RB Whitaker's Wiki - Monogame Tutorials. Dostopno na:

http://rbwhitaker.wikidot.com/monogame-tutorials [20.07.2017]

[4] Wikipedia. MonoGame. Dostopno na:

https://en.wikipedia.org/wiki/MonoGame [16.07.2017]

[5] Wikipedia. Universal Windows Platform. Dostopno na:

https://en.wikipedia.org/wiki/Universal_Windows_Platform [17.07.2017]

[6] MonoGame Documentation. Dostopno na:

http://www.monogame.net/documentation/?page=main [17.07.2017]

[7] Universal Windows Platform documentation. Dostopno na:

https://docs.microsoft.com/en-us/windows/uwp [17.07.2017]

[8] Mobile game statistics 2016. Dostopno na:

https://medium.com/@sm_app_intel/new-mobile-game-statistics-every-game-publisher-should-

know-in-2016-f1f8eef64f66 [15.08.2017]

[9] Wikipedia. Microsoft XNA. Dostopno na:

https://en.wikipedia.org/wiki/Microsoft_XNA [27.07.2017]

[10] Wikipedia. Casual game. Dostopno na:

https://en.wikipedia.org/wiki/Casual_game [23.07.2017]

izdelava 2d igre z uporabo ogrodja monogame · microsoftov universal windows platform(uwp),...

Documents