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
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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:
Izdelava 2D igre z uporabo ogrodja MonoGame
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]
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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).
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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).
Izdelava 2D igre z uporabo ogrodja MonoGame
23
Slika 4.2: Začetni ekran na računalniku
Slika 4.3: Igranje na računalniku
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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).
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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.
Izdelava 2D igre z uporabo ogrodja MonoGame
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]