maandag 22 mei 2017

Nieuwe game in center: SkyTrace

De laatste paar weken heb ik gewerkt aan een game waarop we uiteindelijk de input van de toeschouwers gaan toevoegen. Voor deze game ging ik samen werken met Kevin en Mathieu (Voor bepaalde gedeeltes), twee andere stagaires binnen Enversed. Ik heb mij vooral gefocust op het programmeren van de mechanics binnen de game en het ontvangen van de button input.

In onze game wilden we wat nieuwe game mechanics toevoegen die we nog niet in games hebben binnen het center. Metname de mogelijkheid om je vrij te bewegen over de wereld was een belangrijk aspect. Een paar VR-games die ik samen met andere stagairs af en toe in het center speelde hadden al die mechanics en een daarvan combineerde dat met klimmen. (Climbey: http://store.steampowered.com/app/520010/Climbey/) Het leek ons leuk om een soort gelijk spel te maken maar met onze eigen inbreng.

Hierdoor gingen we uiteindelijk kijken naar de mogelijkheden binnen Unreal wat betreft klimmen en hoe wij het spel konden maken binnen de door mijn onderzoek en Enversed zijn gestelde lijnen. Uiteindelijk kwam hieruit dat we het beste een soort race spel konden maken met de klim mechanics, hierdoor hebben de spelers meer vrijheid in de wereld en kunnen ze toch competetief met elkaar strijden.

Eerst was ik in zelf in Unreal Engine gaan experimenteren met klim mechanics echter kwam ik er al snel achter dat de standaard implementatie van de VR pawn flink gelimiteerd is en er nog heel veel moest gebeuren wilde ik een klim mechaniek in de game stoppen. Hierdoor ging ik kijken naar eventuele plugins die al een flinke movement basis voor VR hadden gebouwt. Hier kwam ik er al snel achter dat de VRExpansion plugin al heel veel van de door ons gevraagde mogelijkheden had ingebouwt. Een groot voordeel was dat deze plugin ook opensource was en alleen een Epic Games license had, hierdoor konden wij makkelijk bovenop deze plugin bouwen. (https://forums.unrealengine.com/showthread.php?116782-VR-(OpenVR)-Expansion-Plugin)

In de plugin was al een implementatie gebouwt voor het klimmen echter was deze nogal afgeschermt en moeilijk uit te breidden met name door de colliders. De standaard motioncontrollers worden binnen de plugin procedural gegenereet waardoor er binnen de pawn die ik wilde gebruiken gebruikt werd gemaakt van een grabsphere als collider. Dit is echter niet handig voor als je in de toekomst gebruik wilt maken van een hand collider of iets anders. Hierdoor heb ik de code zo veranderd dat het als collider gewoon checkt voor overlaps i.p.v. de meer geoptimaliseerde spheretrace bovenop een sphere collider. Hierdoor kan ik elke soort collider meegeven om op collision te checken. Hierdoor kan ik het klimmer makkelijker en ook vloeiender maken.

Om makkelijk tussen soort collider te veranderen heb ik ook switch toegevoegd waarmee je makkelijk van hand naar controller kan switchen. Voor een character ziet een hand er echter veel mooier uit.


(Controller mode)


(Hand mode)

Aangezien je eerst volgens de plugin overal kon klimmen heb ik het zo gemaakt dat je alleen maar kan klimmen op objecten die het IClimable interface overerven. Hierdoor kan je als designer makkelijk de keuze geven op welke objecten de speler kan klimmen. Daarnaast kan ik dan later makkelijk bepaalde events op het klimobject uitoefenen die de spelers weer beïnvloedden.

(IClimable interface, dit is nog niet definitief, zo wordt freeze waarschijnlijk weggehaald)

Daarnaast heb ik ook nog een interface voor de klimmer waarin je makkelijk bepaalde dingen op de klimmer kan uitvoeren. Zo moet het interface er ook voor zorgen dat de server makkelijk bepaalde dingen aan een speler kan veranderen zonder precies de pawn te weten, hier kan Enversed dan later nog meer dingen overheen bouwen.

(IClimber interface, dit is het interface dat wordt gebruikt door een klimmer)

Aan het klimmen zelf moest ik binnen de plugin ook nog het een en andere aanpassen, zo werd eerst alleen maar het object van de klimmende hand onthouden. Hierdoor zat je eigenlijk alleen maar te klimmen met een hand, het gevolg hiervan was dat je nogal snel los liet of naar beneden viel als je snel naar boven wilde klimmen. Hierdoor ben ik uiteindelijk de staat van zowel de linker als rechter hand continu gaan bijhouden zodat je ook makkelijk kon switchen tussen beide handen. Het nadeel hiervan was dat wanneer je een hand vast hield en je met een andere hand omhoog tilde en die vervolgens weer flink wat meters van je andere hand losliet je terug geteleporteerd werd naar je vasthoudende hand. Hierdoor had ik uiteindelijk een implementatie gemaakt die er voor zorgde dat de speler zijn handen automatische loslaat wanneer die zijn andere hand 20cm heeft bewogen. Om dit duidelijk te maken aan de speler krijg je ook forcefeedback op de controller wanneer een speler los laat of iets probeert te grijpen.

Dit bleek de beste manier te zijn om het terugzetten te voorkomen, aangezien een lerp nogal moeilijk is om goed toe te passen op de speler. (Doordat dit ook een vreemd gevoel geeft) Daarvoor moet je de speler zijn oude locatie namelijk onthouden en met je andere hand daar naar toe lerpen echter is dit moeilijk om toe te passen aangezien je locatie object relative is van het object wat je vast houd en in de c++ klassen van de plugin worden geregeld, dus als ik een goede implementatie daarvan wilde maken moest ik het een en ander daarin veranderen.


(Klimmen in het de standaard pawn van de plugin)



















(Klimmen in de pawn na mijn modificaties)

Het klimmen zelf teste ik constant in een standaard map op een muur:

Daarnaast hadden wij het ook getweakt in een proefmap om te kijken of het makkelijk is om op bepaalde objecten te klimmen en wat er eventueel nog verbeterd moet worden:



Uiteindelijk had ik het zo getweakt dat het redelijk realistisch aanvoelt en je toch als speler makkelijk van het ene naar het andere object kan jumpen. Uiteindelijk heb ik het klimmen zelf binnen de pawn ook duidelijker gemaakt met behulp van animaties wanneer je iets grijpt en er mee kan interacten/op kan klimmen dan zie je een grijp animatie, anders zie je geen grijp animatie. Dit is om de speler een duidelijk beeld te geven van met welke objecten er iets gedaan kan worden.

Vervolgens zijn wij gaan werken aan een prototype runner game samen met kevin waarin we een map maakte met een startpunt, checkpoint en een finish. (In het level kun je op elk rood(statisch) en groen(Moving) object klimmen)

(Prototype runner level)

Hiervoor heb ik gewerkt aan een startpunt waarin de speler zijn timer aangaat zodat hij/zij zijn huidige tijd kan zien. Zodra men een checkpoint heeft gehaald wordt zijn spawnlocatie naar de checkpointlocatie gezet hierdoor zal de speler automatische op het checkpoint spawnen wanneer hij/zij dood gaat. De speler gaat automatische dood wanneer hij/zij onder een bepaalde z-as terechtkomt. Om de speler niet misselijk te laten worden krijgt hij/zij een langzame fade-out en wanneer die spawn op het checkpoint weer een fade-in. Wanneer de speler op de finish terechtkomt wordt zijn tijd gestopt en wordt die automatische weer naar de start geteleporteerd. Dit was een goed level om er achter te komen welke mechanics de spelers leuk vinden en wat we eventueel nog kunnen verbeteren.

We hadden ook een paar moveable objecten in het level zitten die heen en weer bewogen. Voor de spelers op de server voelden die objecten helemaal top aan echter was het nadeel dat wanneer wij die objecten gingen replicaten naar alle clients dat de objecten dan een rubberbanding effect kregen vanwege de 30 ticks van de server. Dit voelt niet goed aan voor de spelers, wanneer je het echter op de client laat draaien krijg je weer het nadeel dat het niet in sync loopt en voor sommige clients de andere mede spelers dus vliegen. Hierdoor hebben wij besloten om moveable objecten er voor de deployment versie er uit te halen.

Uiteindelijk ben ik ook begonnen aan het maken van een plugin die button input vanuit Jurgen zijn EPOS server kan registreren. Hiervoor had ik een knop van hem gekregen met een raspberry pi welke de button state naar zijn EPOS server stuurde.











Unreal input werkt helaas niet zo makkelijk als in unity aangezien je in een blueprint even maximaal maar 10 miljoen keer kan callen voordat die er uiteindelijk uit knalt moet ik gebruik maken van input events. Hiervoor moet je gebruik maken van keys binnen Unreal. Het eerste wat ik probeerde door via EKeys::AddKey een key toe te voegen werkte helaas niet aangezien de c++ compiler wilt dat je de keys van te voren compiled voordat die het aan de enum voor input in unreal kan toevoegen. Hier kwam ik achter door te kijken naar hoe andere plugins button input registreren:
https://github.com/getnamo/CIMPlugin














Deze plugin heb ik als referentie gebruikt om mijn input uiteindelijk te handlen, zo processed deze plugin ook input via slate. Hierdoor kan ik makkelijk een key indrukken voor een bepaald event.

Om input te ontvangen ben ik uitgegaan van een TCPactor in Jurgen zijn VR hand project deze is volgens mij gebaseerd op een van rama zijn tutorials. Hier heb ik uiteindelijk weer het een en ander overheen gebouwt om de input goed af te handelen en de sockets goed te sluiten. Zo gebruik ik ook mijn json parser om de json te ontvangen.

De plugin moest makkelijk over meerdere soorten projecten gebruikt worden hierdoor ben ik op basis van mijn al gemaakte json parser gaan bouwen. Met name omdat dit het makkelijker voor mij maakt om input en bepaalde variabele er uit te halen en ik andere systemen zoals highscores ook makkelijk gebruik kan laten maken van json.

Input ingame:

Input BP:


Start echte game:

Hierna zijn we aan de slag gegaan met een echt level met een futuristische thema. De bedoeling was dat er in het level 1-4 mensen tegen elkaar konden spelen. Hierdoor hebben we uiteindelijk een start punt gemaakt met 4 pads er op waar de speler op moet staan om de game te starten. Het belangrijke van de pads was dat alles server sided moet werken om alle pads er hetzelde te laten uitzien voor alle clients. Ook de finish moest server sided zijn en het teleporteren naar de finish moet server sided zijn.

Zodra iedere speler op een launchpad staat krijgt hij/zij automatische een unieke kleur zodat je elkaar kan onderscheidden. Daarna krijg je een countdown op basis van het geluid dat wordt afgespeeld. Wanneer het geluid is afgespeeld op de server krijgt iedereen een start trigger via een multicast. Hierdoor zit iedereen ingame en kan je van het startpoint afspringen en moet je het parkour zien te volgen.

(Speler 1 krijgt een rode kleur)

Wanneer iedereen gefinisht is gaat de game automatisch over en kan men overnieuw beginnen. De game wordt automatische na 10 seconden gestopt voor een speler wanneer hij/zij zijn headset op de grond neerlegt, daarnaast wordt de speler ook gefinisht wanneer die het eindpunt van het parkour raakt.

Op het einde krijgt iedereen ook zijn score op het scoreboard te zien, deze zal uiteindelijk ook gesorteerd worden m.b.v. een bubblesort die ik uitvoer op de json objecten. De scores van elke speler worden namelijk op het einde naar een json object verwerkt zodat ze later ook makkelijk naar een REST server gestuurd kunnen worden.


(Hoe het score board er uit ziet)


(Bubble sort algoritme die objecten sorteerd op basis van de waarde van een json value binnen het object.)

(Overzicht van het level van bovenaf)

(Startpunt waarop je de launch pads ziet en daarachter het scoreboard.)

De game werkt op dit moment al vrijwel zonder bugs in multiplayer aangezien wij het zo event based mogelijk hebben geprobeert te bouwen. Zelf via interface calls wordt een server based event uitgevoerd hierdoor schaalt het makkelijk over alle spelers.


(Voorbeeld veranderen van speler zijn kleur server based)

(Finish voorbeeld in startpoint dat wordt aangeroepen wanneer een speler finished, vervolgens kijkt de server naar hoeveel spelers gefinisht zijn en of de game weer geherstart kan worden)

Deze week ga ik verder werken aan input en met behulp van die input kunnen de toeschouwers bepaalde events in game triggeren die invloed hebben over de spelers. (Denk aan abilities, zoals in mariokart echter kunnen die door de toeschouwers worden geselecteerd met de knop) Hier ga ik uiteindelijk naar kijken wat voor invloed dit op de toeschouwers en spelers dit heeft en of het voor wat meer communicatie zorgt. Hier zal ik mijn conclusie voor mijn hoofdonderzoeksvraag op baseren en het een en ander nog verbeteren aan de games zelf. Mijn onderliggende onderzoeksvraag waar ik moet antwoorden op hoe ik die tools in unreal ga maken kan ik al beantwoorden aangezien ik die al af heb gemaakt.

Eind deze week zal ik al vast een concept versie van mijn stage verslag op leveren met een conclusie op mijn deelvraag en over een week hoop ik al antwoord te kunnen geven op mijn hoofdvraag.

Wat ik heb gedaan volgens mijn logboek, per dag sinds de vorige post:

[05-04-2017]
Gezocht naar leuke ideëen voor games die we nog niet in het center hebben en uiteindelijk kwam hieruit dat ze een klim game wel leuk vonden.

[06-04-2017]
Gekeken naar een manieren waarop wij makkelijk het klimmen in unreal konden toepassen.
Uiteindelijk kwam hieruit dat we beter de pawn van de VRExpansionPlugin als basis konden gebruiken aangezien hier al veel soorten movementmodes en manieren van object interactie inzaten.
Metname omdat hier al een paar klim mechanics inzatten leek het mij slim om hier boven op te bouwen.

[07-04-2017]
Begonnen met het experimenteren met/oriënteren op mechanics in de VRExpansionPlugin en welke we het beste kunnen toepassen in onze game.
Daarnaast heb ik de meegeleverde pawn alvast wat uitbreidbaarder gemaakt.

[10-04-2017]
Ik heb vandaag gewerkt aan de colliders waarmee je klimt, zo heb ik het zo abstract mogelijk gemaakt zodat het makkelijk is om te klimmen met zowel een controller mesh (Via grabspehere) als de hand (Via handcollider).

[11-04-2017]
Besproken met Jurgen op welke manier er input moet worden doorgegeven en hoe we dat gaan doen. Uiteindelijk verstuur ik alles naar de game met behulp van een JSON string deze moet ik in de game uitlezen via unreal's button input.

[12-04-2017]
Ik heb de klim mechanieken verbeterd en het project gepusht naar gitlab, daarnaast heb ik meer tweakability toegevoegd aan de plugin. (Zo kan je makkelijk kiezen tussen een controller of een hand om mee te klimmen)

[13-04-2017]
Klim mechanics verbeterd en veel bugs gefixt, zo werd de speler soms geteleporteerd naar de locatie van de andere hand wanneer die met een hand los liet en de andere vast bleef houden.
Daarnaast heb ik force feedback toegevoegd wanneer de speler op een muur klimt, dit zal hij/zij voelen op de controller waarmee die op dat moment aan het klimmen is.

[14-04-2017]
Gewerkt aan interfaces voor zowel de klimmer als het object waar men op kan klimmen en klim mechanics verbeterd.

[17-04-2017]
Vrij vanwege pasen.

[18-04-2017]
Geëxperimenteerd met de raspberry pi en de button en uitgezocht hoe het systeem precies in elkaar zat.
Hand wordt ook automatische gedetached van een klim object wanneer hij er te ver vanaf gaat, dit voorkomt een warp back wat voor misselijkheid zorgt.
Daarnaast heb ik de interfaces voor IClimber en IClimable geüpdate.

[19-04-2017]
Add en Remove Climber functie toegevoegd aan IClimable interface, auto step up functionaliteit van de plugin aangezet en meerdere bugs die tijdens het klimmen voor kwamen gefixt.

[20-04-2017]
Deze dag was het de terugkomst dag en moest ik een presentatie geven over wat ik precies gemaakt had de afgelopen weken. Daarnaast heb ik de spring functionaliteit geïmplementeerd zodat je nu ook in het spel kan springen en dus nog meer bewegingsmogelijkheden hebt.

[21-04-2017]
Ik ben begonnen aan het maken van een klimobject waar spelers aan toegevoegd kunnen worden. Dit moet er voor zorgen dat je makkelijk events op de speler kan uitvoeren vanuit het klimobject.

[24-04-2017]
Ik heb het klim object afgemaakt waaruiteindelijk alle klimobjecten van moeten overerven aangezien hier al functionaliteit in zit voor scaling en het toevoegen en verwijderen van klimmers,
dit moet het makkelijker maken om klimobjecten aan te maken zonder allemaal functionaliteit weer toe te voegen.
Daarnaast scaled de pawn nu ook mee met de speler zijn hoogte.

[25-04-2017]
Vandaag heb ik checkpoint functionaliteit aan de klim game toegevoegd inclusief met een headsupdisplay waar in realtime jou tijd wordt weergeven.
Je hebt nu ook een plek waarvan je een parkour run als het ware start en ook een waar je het eindigt en dus ook terug teleporteerd.

[26-04-2017 tot 01-05-2017]
Vakantie

[02-05-2017]
Klimmen verbeterd aan het spel, zo kan je nu op elkaar klimmen zonder elkaars handen af te pakken.
Daarnaast ben ik alvast wat onderzoek gaan doen naar hoe ik het beste input kan mappen via een plugin in UE4.
Ik had ook al het een en ander geprobeerd om zelfgemaakt keys toe te voegen, echter kon UE4 toen helaas niet meer gecompiled worden.
Hierdoor ben ik gaan kijken naar andere plugins die al input mappen in UE4, toen kwam ik er achter dat het enige wat ik fout deed was de knop niet van te voren mee te compilen.
Ik wilde eerst de input zo dynamische mogelijk maken maar doordat UE4 zijn compiler wil dat je de buttons van te voren mapped is dit helaas niet mogelijk.
Ik kwam hierachter door naar de volgende plugin te kijken:
https://github.com/getnamo/CIMPlugin

Deze plugin gaf mij ook al informatie over hoe ik bepaalde buttons/axises kan afvuren in UE4 met behulp van slate.
Helaas was er vrij weinig over te vinden via UE4 zijn eigen documentatie.


[03-05-207]
Op basis van de plugin die ik gisteren had gevonden ben ik aan de slag gegaan met een voorbeeld project waarin ik mijn eigen plugin maakte op basis van die plugin.
In de plugin heb ik heel veel verschillende soorten input gemapt voor zowel buttons als axises, vervolgens heb ik die ook aan methodes toegevoegd zodat ik die kan processen met behulp van press/release events.
Daarnaast heb ik ook gewerkt aan een tcp receiver waarmee we de button input kunnen ontvangen in het spel.
Hiervoor ben ik uitgegaan van Jurgen zijn project die hij gebruikt voor het ontvangen van json input van zijn VR handschoen in UE4.
De button verstuurd json naar een server welke ik vervolgens dan weer via de server ingame ontvang.
De json moet ik deserializen dus hiervoor ging ik mijn eigen json parser plugin gebruiken waarmee ik json makkelijk kan deserializen en snel bepaalde fields kan opzoeken.
Na het deserializen ging ik vervolgens een button press processen voor press of release voor die specifieke button.

[04-05-2017]
Hierna heb ik alles geöptimaliseerd en in plugin gestopt zodat ik het makkelijk in de klimgame of andere projecten zoals flight kan stoppen.
Nadat ik de plugin had toegevoegd aan de klim game ben ik begonnen met het maken van een spline waarop objecten makkelijk bewegen en de directie waarop ze bewegen makkelijk tweakbaar is.

[05-05-2017]
Button input gemaakt zodat het alleen op de server execute en niet meer op de clients.
Dit moet er voor zorgen dat de game alleen maar beïnvloed kan worden door de server en alle data makkelijker verspreidt kan worden over alle clients voor wanneer er iets met de knop gebeurt.
Daarnaast ben ik begonnen met het werken aan een moveable spline die goed replicate over de clients en waar je makkelijk verschillende actoren over kan laten bewegen.

[08-05-2017]
Een moveable spline gemaakt waarover een object heen kan vliegen, dit kan worden toegepast voor ruimte schepen of dergelijken in de game.
(Een probleem is echter de rubberbanding op de client, ik kan misschien beter timelines hiervoor gebruiken en die replicaten)
Daarnaast ben ik begonnen met het kijken naar mogelijkheden om highscores te sorteren met behulp van mijn c++ json parser.
Zo heb ik ook alvast een basis geïmplementeerd voor het sorteren van arrays, hiervoor heb ik een methode gemaakt waarin je zelf kan kiezen in hoeveel objecten je een json array wilt splitten.

[09-05-2017]
Bubblesort algoritme gemaakt waarmee je makkelijk jsonarrays in json objecten kan sorteren.
Dit zal uiteindelijk voor het score board worden gebruikt in het spel aangezien alle scores in json worden opgeslagen zodat ze in de toekomst makkelijk naar Jurgen zijn REST server kunnen worden gestuurd.
Als sorteer algoritme ben ik uiteindelijk gegaan voor bubble sort aangezien de implementatie daarvan het makkelijkste was om te implementeren boven op mijn json parser, daarnaast waren de snelheids/optimalisatie voordelen van merge sort niet van toepassing op de game zelf.
Met name doordat er zich nooit echt veel data binnen de game zal bevinden.

[10-05-2017]
Serverside playerspawning gemaakt voor climb game met ready up pads.

[11-05-2017]
Meerdere bugs gefixt met de ready up pads. Zo kon een speler die de game joinde wanneer die al bezig was alle pads geactiveerd zien. Nu is dat niet meer mogelijk aangezien de staat van de pads naar alle spelers worden gereplicate waardoor ze allemaal dezelfde staat hebben.

[12-05-2017]
Game gepolisht voor dtw en eerste gedeelte van highscore toegevoegd, daarnaast heb ik functionaliteit toegevoegd waarmee de speler automatische game over is na x aantal seconden dat de headset op de grond ligt.

[15-05-2017]
Nieuwe map voor de game gedeeltelijk geoptimaliseerd met static lightning, moveable climbing objects static gemaakt. Highscores gefixt.

[16-07-2017]
Level doorgelopen en paar dingen die nog gefixt moeten worden aangekaart, 16:9 build gemaakt, deaths op het scoreboard gefixt, wordt nu nog maar een keer getriggered, checkpoints gefixt wordt nu ook maar een keer getriggerd.

[17-07-2017]
Bugs gefixt die er voor zorgde dat je niet juist respawnde wanneer je dood ging op de automatische z death axis. Daarnaast ook een paar bugs gefixt die er nog voor zorgde dat de spelers death meerdere keren werd getriggerd op de death axis door de delay naar de server. Hierdoor heb ik het een fire once statement gemaakt die het probleem lokaal oplost.

[18-07-2017]
Laatste bugs uit de game gehaald, zo kan je nu niet meer op een persoon klimmen die al op een ander persoon aan het klimmen is.
De speler zijn kleur wordt nu server sided gegeven zodat dit altijd consistent is voor alle clients.
Het kwam namelijk nog wel eens voor dat een andere speler voor een speler geen kleur kreeg omdat die eerst op een andere pad ging staan.

[19-07-2017]
Alles up-to-date gemaakt wat betreft documentatie.
Gesprek begeleider 16 juni middag.

[22-07-2017]
Custom button input in project gefixt (Ergens zat een foute referentie waardoor het opeens niet meer werkte), update aan stage blog.

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.

maandag 27 februari 2017

Scoresysteem geïmplementeerd en bugs gefixt

Vandaag heb ik een voorlopige versie van het scoresysteem in de paraglider game geïmplementeerd. Ik houd binnen het score systeem rekening met de tijd, crashes en hoe je de gate hebt geraakt. Aangezien de gates binnen de spline standaard alleen een overlapse trigger als events hebben om het zo efficiënt mogelijk te maken heb ik een algoritme gemaakt om te kijken waar een speler de gate heeft geraakt binnen de poort.

Het algoritme dat ik heb gemaakt gaat er vanuit dat de gate een ellipse is. Om precies te weten waar de speler de gate raakt maak ik gebruik van het vorige algoritme om te bepalen op welke x en z as de speler zich bevind van de gate, vervolgens gebruik ik die waarde om te kijken waar de speler de gate heeft geraakt.

Daarnaast heb ik wat verder gewerkt aan mijn project plan en ben ik van plan om die morgen in te leveren aangezien de opdracht binnen het bedrijf nu voor zowel mij als het bedrijf volledig duidelijk is.

vrijdag 24 februari 2017

Bugfixes Paraglider/Spline + Algoritme detecteren positie paraglider binnengate

Vandaag heb ik flink wat bugs uit de paraglider en spline gehaald, zo roteerde de playerstart niet mee met het object en gaven de gates maar een force in een bepaalde richting. Het force probleem heb ik uiteindelijk opgelost door er mijn rotatie algoritme op toe te passen. Nu worden de forces die je bij een gate krijgt dus bepaalde door de locatie en rotatie van de gate hierdoor zal je force dus altijd richting de volgende gate zijn.

Daarnaast ben ik ook begonnen aan een algoritme om te bekijken of je de binnenste gate raakt of niet. Aangezien de gate rond is kan ik hiervoor de hoogte van een ellipse berekenen op een bepaald punt, hierdoor zal de innergate dus blijven werken met dit algoritme wanneer je het ook een schaal geeft. Ik ben van plan om dit algoritme te gebruiken aangezien het efficiënter is dan een hit event te genereren. In het algoritme zelf heb ik nog een paar bugs zitten dus ik kan nog niet de volledige werking laten zien.

Daarnaast heb ik een gesprek gehad met Tim en Myrthe vanuit Enversed over mijn projectplan, dit zal ik dit weekend uitwerken en opsturen. 

donderdag 23 februari 2017

Rotatie van innergate naar volgende gate toegevoegd aan de spline

Nadat ik maandag nog de laatste bugs uit de visualizer had gehaald ben ik aan de slag gegaan met het laatste stukje code voor de spline. De code die ik moest toevoegen zorgt er voor dat de innergate van een gate op basis van zijn thermal juist naar de volgende gate roteerd. Dit moet de gebruiker in elke situatie een duidelijk beeld geven van welke kant hij op moet vliegen.

Afbeeldingen met de rotatie van de spline zelf op 0, zoals je kan zien worden de innergates geroteerd op basis van de rotatie van de volgende gate.


Zoals je hieronder kan zien gebeurt dit ook wanneer je de spline zelf roteerd, de positie wordt altijd goed aangegeven.

Het algoritme heeft mij uiteindelijk best veel rekenwerk gekocht, de meest simpele manier om dit voor elkaar te kregen was om uiteindelijk de gate zelf als een frame of reference te gebruiken. Wat ik had gedaan was de coördinaten van de volgende gate van de huidige gate afgehaald en die waarde vervolgens in een coördinaten systeem te stoppen met als nulpunt de gate zelf. Om die coördinaten goed te berekenen heb ik gebruik gemaakt van het volgende algoritme: http://keisan.casio.com/exec/system/1223522781

Hierdoor kon ik op basis van de rotatie van de gate zelf de juiste positie van de andere gate berekenen met als nulpunt de huidige gate. Binnen het coördinaten stelsel zelf kon ik de hoek berekenen naar de volgende gate op basis van de acos in graden. Dit gaf altijd een hoek terug tussen de -180 en 180 graden, dat was precies wat ik nodig heb om te weten waar de volgende gate stond.

Door dit toe te passen heb ik er voor kunnen zorgen dat ik altijd de juiste yaw van een euler terug krijg naar de volgende gate. Met de hoek die daar uitkwam heb ik uiteindelijk de innergate rotatie juist kunnen zetten op basis van de thermal en de rotatie naar de andere gate toe. 

Morgen heb ik een afspraak met mijn begleider binnen het bedrijf en ga ik mijn PID/projectplan volledig afronden.


maandag 20 februari 2017

Vorige week had ik vooral getest en bugs gefixt van de game versie daarvoor.
Maandag had ik vooral gewerkt aan de teleportatie van gate naar gate binnen het spel.

Dinsdag en woensdag had ik flink wat teleportatie bugs die in de game voorkwamen gefixt, namelijk de fadeout en fadein werkte niet altijd even goed en onder sommige condities van de paraglider werd je niet geteleporteerd.

Donderdag had gewerkt aan het werkent maken van mijn gate blueprint met die van de artist. Zijn gate models en materials moesten namelijk worden toegevoegd aan mijn gate. Daarnaast had ik gewerkt aan een impulse bug, wanneer je namelijk een game startte kreeg je niet altijd dezelfde kracht op de paraglider door de physics engine. Hier heb ik een manier op proberen te vinden zodat dit consistent is. Ook had ik er voor gezorgt dat de pijlen in de gate de juiste thermal en richting aangeven naar de volgende gate. Dit is nog niet helemaal perfect geïmplementeerd aangezien het maar in een richting werkt op dit moment.



Vrijdag had gewerkt aan de visualizer op de spline, het is namelijk de bedoeling dat de speler kan zien welke kant hij op moet. De artists willen dit met meerdere meshes op de spline laten weergeven, hiervoor moest ik mijn spline blueprint op aanpassen. Daarnaast heb ik een begin gemaakt aan mijn project plan.

Vandaag heb ik de visualizer code afgemaakt zodat je nu verschillende meshes op de spline zelf kan zien. Dit is volledig instelbaar en je kan zelf kiezen in mijn blueprint script wanneer je de mesh wilt builden. Aangezien het namelijk behoorlijk inëfficient is om duizenden meshes in realtime over een mesh in de editor aan te passen.


Ik ben van plan om deze week iedere dag een blogpost te schrijven aangezien ik daar vorige week te weinig tijd aan had besteed.


maandag 13 februari 2017

Begin sprint tweede week.

Het belangrijkste waar ik vandaag aan moest werken is de checkpoint functionaliteit. Zo moet ik er voor zorgen dat de speler zich terug kan teleporteren naar een gate wanneer hij/zij crasht. Wanneer de speler het einde heeft gehaald moet hij/zij natuurlijk ook weer naar het startpunt worden geteleporteerd.

Hiervoor heb ik ook nog wat extra waarden aan de route data array toegevoegd. Je kan nu namelijk instellen hoe de speler precies op de gate spawnt en of de speler er uberhaupt wel mag spawnen.


Daarnaast heb ik een kleine demo map opgesteld waarin ik heb getest of alle functionaliteiten die ik tot nu toe heb toegevoegd het wel goed deden.

Morgen ben ik van plan om een groot gedeelte van mijn testplan af te maken en een start te maken aan het scoresysteem aangezien vrijwel alle benodigde programmeer funcionaliteit aan de game is toegevoegd.

Einde 1ste week

Donderdag en vrijdag had ik gewerkt aan het genereren van een start en eindpunt op de spline.
De grootste uitdaging hierbij was om de gates uiteindelijk tussen het eind en startpunt te zetten op de spline.


Spline met start- en eindpunt.


Spline zonder startpunt.


Spline zonder start- en eindpunt.

Daarnaast heb ik er ook voor gezorgd dat de playerstart met het startpunt meebeweegt in de editor als je het aangeeft. De positie en rotatie van de playerstart kan je zelf ook helemaal instellen, het beste is om het te roteren met de tangents van de spline, dit kan je ook makkelijk via mijn script doen.


Op vrijdagmiddag ging ik meehelepen bij het VR center van Enversed om te kijken hoe klanten bij hun reageren op de spelen. Wat ik heb opgemerkt is dat de klanten het op het begin best wel fijn vinden om een simpel spelletje te spelen zodat ze eerst kennis maken met VR zelf. Wanneer je de klanten een korte uitleg over het spel geeft begrijpen ze het al best snel, echter de tekst in de virtuele wereld zelf zien ze nogal snel over het hoofd.

woensdag 8 februari 2017

Progressie woensdag

Vandaag heb ik de volledige basis van het spline systeem afgemaakt. Op de spline kan je verschillende gates spawnen, per gate heb je ook een bepaalde thermiek welke je kan instellen, daarnaast kan je ook kiezen op welke spline je gates wilt laten spawnen. De spline zelf kan je ook volledig configureren, zo kan je collision op de spline zelf aanzetten, de mesh zelf instellen, instellen of je überhaupt gates op de spline wilt spawnen en of je het een rondje wilt laten lopen.

Spline Data:

Hoe de spline er nu uitziet met gates en zonder loop:
De spline als loop met gates:
De spline als loop zonder gates:

Doordat ik in mijn script iedere gate een thermiek waarde meegeef is het ook makkelijk om die thermiek waardes naar de speler toe te sturen als die met de gate collide(m.b.v. een trigger). 

Morgen ben ik van plan om een demo/whitebox te maken van het spel samen met een andere stagair. Wij zullen ons werk mergen, wat er vrijwel meteen voor zorgt dat we het spel kunnen spelen. Hij heeft namelijk de charactercontroller gemaakt en die wordt beïnvloed door de gates die ik heb gemaakt. Wat er dus gebeurt is dat als de speler collide met de gate, de speler een thermiek waarde van de gate ontvangt en zijn snelheid hierop aanpast.

Hierna ben ik van plan om te beginnen aan het start- en eindpunt van de route. Wanneer je start wil je namelijk eerst de speler kennis laten maken met de controls, en aan het einde wil je de speler zijn score laten zien. Vervolgens wil je de speler weer naar het startpunt laten teleporten, waar hij/zij weer overnieuw kan beginnen.