dinsdag 4 april 2017

Update van waar ik aan gewerkt heb, klaar met oriëntatie fase.

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.