Ik heb in maart
aan flink wat dingen gewerkt, ik heb mij flink wat georiënteerd in c++ en mijn
plan opgesteld.
In de week van 6
maart had ik een gesprek met Jan mijn stagebegeleider vanuit school. Tijdens
dit gesprek had ik mijn progressie laten gezien en een gesprek gehad over wat
er precies in mijn PID-document moet.
Verder had ik mij
die week wat meer in c++ georiënteerd en begon ik te werken aan een json plugin
als oriëntatie die we misschien ook nog voor flight konden gebruiken.
De plugin die ik
eerst had gemaakt werkte op basis van een buffer waarin je jou json string
stopte en vervolgens in blueprints verder kon deserializen.
Het nadeel van
deze code was dat je voor objecten in een json string alles uit de buffer moest
verwijderen. Hierdoor had je niet zoveel controle over de objecten die je had,
je moest ze namelijk de hele tijd overnieuw inladen.
De code die ik
heb gemaakt ondersteund ook launch paramaters, hierdoor kan je wanneer je de
game start in cmd of een andere terminal extra informatie meegeven aan de game.
Dit kan je dan vervolgens ook uitlezen in blueprints en vervolgens in de game
verwerken.
In de week van 13
maart heb ik mijn PID-document volledig afgerond, ik heb mijn project ingeplant
in 5 fases:
1)
Oriëntatiefase
- Hierin ga ik mij nog meer in c++ ga verdiepen en hetgeen wat ik heb gemaakt
ook al in een plugin verwerken.
2)
Ontwerpfase
– In de ontwerpfase maak ik een plan over het product wat ik uiteindelijk aan
het eind van mijn stage wil leveren.
3)
Realisatiefase
– Dit is de grootste fase en hierin ga ik mijn product maken op basis van mijn
ontwerp in de ontwerpfase.
4)
Verslagfase
– In deze fase ga ik het grootste deel van mijn tijd besteden aan het maken van
een verslag.
5)
Afrondingsfase
– Dit is de fase waarin ik alles na kijk en alles probeer te verbeteren.
Voor mijn PID-document
ben ik uitgegaan van de PID-template die te vinden is op de portal, echter heb
ik financiën geschrapt aangezien dat niet van toepassing is op mijn project.
Aan het einde van
die week had ik ook besloten dat ik mijn plugin overnieuw zou maken, aangezien
de buffer het deserializen van json array’s en objecten nogal moeilijk maakte.
Hierdoor was ik van plan om voor mijn oriëntatiefase meer een object-based
deserializer te maken i.p.v. een buffer-based deserializer.
Vanaf Maandag 20
maart was ik dus begonnen aan een nieuwe json plugin als oriëntatie op c++ en
UE4 plugins. Mijn plan was om json objecten in een object-struct te stoppen en
json waardes in een value-struct. Omdat ik niet gebruik hoef te maken van de
UObject klasse en je structs makkelijk in blueprints kan gebruiken kwam ik tot de
conclusie om gebruik te maken van structs i.p.v. klassen.
Dinsdag had ik
nog gewerkt aan het opzetten van de stelling van flight (De parasailer game):
Tot nu toe licht
de ontwikkeling van het flight project tijdelijk stil tot dat de stelling met
de hardware volledig is afgemaakt. Hierna kunnen we de tools die ik voor deze
game heb gemaakt testen en er uiteindelijk een volledige game van maken.
Hieronder zie je
hoe ik een json array maak met verschillende soorten waardes in blueprints met
behulp van mijn plugin.
Ieder json object
heeft een field, dit is de naam van het object. Hieronder zie je hoe ik een
object maak met een integer als waarde.

Ik heb ook een
voorbeeld gemaakt om snel een highscore object te generen in json:
In een for loopje
roep ik een methode aan die een willekeurig highscore object maakt, vervolgens
stop ik dat in een array.
Hierna maak ik
van de array met json waardes een json array. Die stop ik vervolgens in een
object dat ik highscores noem en de wordt daarna geserialized naar een json
string.
Dit is het
resultaat:
Nadat ik dit af
had gemaakt in een UE4 project heb ik het geëxporteerd naar een plugin. Ik heb
het niet meteen als een plugin gemaakt aangezien je de code van een plugin niet
kan hot reloaden en je dus continu je hele project moet rebuilden bij code
changes. Dat kost helaas ontzetten veel tijd, vandaar dat het slim is om eerst
alles in een project te stoppen, want een plugin in UE4 moet bij definitie al
meteen volledig af zijn.
Unreal heeft
alles namelijk opgebouwd in modules, de source waar je normaal gesproken in
werkt wordt geïmplementeerd als de PRIMARY_GAME_MODULE. De plugin die ik maak
zal een gewone MODULE zijn.
ModuleRules van
de plugin:
ModuleRules van
de primary game module:
Hoe de plugin is opgebouwd:
Bij de plugin
zelf moet je ook informatie geven over hoe die in elkaar zit, welke versie de
plugin is, wat de naam van de plugin is etc. Dit doe je in de uplugin file (Dit
is eigenlijk gewoon een json bestand):
Dit zie je
wanneer de plugin is ingeladen in de editor:
In de week van 27
maart heb ik nog een paar fouten uit de plugin gehaald en de laatste paar
dingetjes verbeterd. Zo kon je eerst niet kijken of een json waarde een boolean
was of dat de json waarde null was. Hierdoor heb ik uiteindelijk die
functionaliteit ook toegevoegd.
Vervolgens ben ik
die week gaan experimenteren met UDP-communicatie, hiervoor heb ik een C# UDP-socket
server opgezet op basis van het MSDN-template om berichten van UE4 te
ontvangen. (MSDN: https://msdn.microsoft.com/en-us/library/tst0kwb1(v=vs.110).aspx)
Hier ben ik
vervolgens vanuit unreal mee gaan experimenteren. Ik was in eerste instantie
van plan om alles in een static function library te stoppen aangezien je dan
van elke blueprint de methodes kan aanroepen.
Hierdoor heb ik
als eerste een connection method opgezet waarmee ik met een UDP-server
verbinding kan leggen. Op mijn C# server kon ik gewoon de berichtjes die ik
vanuit unreal verzond ontvangen, echter moest ik nu in Unreal nog een receiver
maken. Ik was van plan om hiervoor gebruikt de maken van de al ingebouwde
UDPSocketReceiver library, echter werkt die library met delegates die alleen
binnen Unreal objecten werken. Daarom heb ik hier uiteindelijk mijn eigen
implementatie van gemaakt met behulp van het observer patroon. Hierdoor kon ik
vanuit mijn UDP-klasse subscriben op de receiver die vervolgens de ontvangen
data weer naar alle observers stuurt.
Om te voorkomen
dat meerdere threads data in de ontvanger kunnen bewerken en ik alles veilig
kan afsluiten heb ik gebruik gemaakt van mutex. (http://en.cppreference.com/w/cpp/thread/mutex)
Dit is de standard c++ library om objecten of gedeeltes van de code threadsafe
te maken. Hierdoor kon objecten locken in de code die soms door meerdere
verschillende threads werden aangeroepen. Dit heeft ervoor gezorgd dat ik code
veilig kon afsluiten zonder dat ik objecten probeerde te verkrijgen die niet
meer bestonden.
Vervolgens wilde
ik de ontvangen data naar blueprints sturen via events echter kwam ik erachter
dat je in blueprints alleen maar events kan krijgen wanneer je van UObject
inherit, hierdoor kon ik helaas niet vanuit een static function library een
event aansturen.
Hierdoor heb ik
uiteindelijk een actor moeten maken die de data als event kan ontvangen in blueprints.
Afgelopen weekend
heb ik ook nog meegeholpen bij de HEX-hackathon in Eindhoven voor Enversed.
Hier heb ik mijn networking code ook nog volledig multithreaded gemaakt
hierdoor werken nu zowel de sender als receiver multithreaded. Hetgeen wat heel
lastig was om te doen was al die threads veilig af te sluiten zonder dat er
sommige waardes een null pointer kregen. Dit is mij echter wel gelukt, en nu
sluiten zowel de sender als receiver zich altijd goed af. Daarnaast kan je nu
ook meerdere UDP-verbindingen aanmaken via blueprints aangezien alle threads in
een lijst worden opgeslagen. Vervolgens kan je die UDP-verbindingen weer
opvragen via blueprints met behulp van een ID. Om het ID altijd juist te houden
maak ik gebruik van de std::Atomic (http://en.cppreference.com/w/cpp/atomic/atomic).
Data ontvangen
vanuit unreal in mijn C# socket server, dit wordt vervolgens weer verstuurd
naar unreal:
Vervolgens
ontvang ik weer een flink aantal berichten in Unreal, om te voorkomen dat ik
bij een hele snelle verbinding in Unreal een memory overload krijg print ik
alleen maar alles per zoveel ticks in het log:
Er zijn nog wel
wat punten waarop ik de server vanuit de Unreal kant kan verbeteren, zo werkt
die niet altijd op 1000 ticks wanneer je berichten verstuurd vanuit Unreal en
is die nogal inconsistent bij het instellen van de tickrate. Daarnaast klapt de
UDP kant er nogal weleens uit wanneer je dingen naar Unreal verzendt, ook al
zie ik dat ik de packets ontvangen heb in Wireshark wil Unreal ze soms niet
verwerken. Mijn code kan wel gebruikt worden voor input maar is nog niet
betrouwbaar genoeg om continu en consistent data te ontvangen.
Deze week heb ik
een afspraak gemaakt met Jurgen waarin ik bespreek aan welke kant van het
framework ga werken en hoe ik uiteindelijk ook mijn game wil gaan maken. Ik wil
uiteindelijk een library maken waarmee je makkelijk externe input in de game kan
ontvangen en daarmee de game ervaring van de speler kan veranderen. Dit moet ervoor
zorgen dat de toeschouwers uiteindelijk ook meer betrokken raken bij het spel.
In het gesprek met Jurgen zal ik het vooral over het technische ontwerp hebben,
vervolgens plan ik nog een gesprek in met Myrthe en Tim over het design
ontwerp. Op basis van die gesprekken maak ik uiteindelijk een ontwerp wat
technische haalbaar is en in de toekomst mogelijk ook voor andere games in het
VR-center gebruikt kan worden. Nu bevind
ik me namelijk in de ontwerpfase en voor 14 arpil moet ik mijn volledig ontwerp
af hebben.















Wow ziet er goed uit Tim! Veel gedaan en veel verschillede onderwerpen aangeraakt C++, UDP, client/server, threading, ...
BeantwoordenVerwijderen