zondag 20 januari 2013

Bloom en (verlate) update

Bloom, met saturation. Negeer de tekst en de plaatjes, maar niet het menu, want die is mooi.
Na een betrekkelijk lange radiostilte is het ons toch nog gelukt om een redelijke blogpost te schrijven. In de afgelopen we(e)k(en) hebben we redelijk wat veel grond mogen verzetten met het spel. Voornamelijk op grafisch gebied. Het enige nadeel is dat we (of althans ik) graphics "belangrijker" (of om eerlijk te zijn, leuker) vind dan gameplay waardoor er niet zo gek veel gebeurd is aan gameplay (red. door Sander, de rest is (bijna) 24/7 bezig geweest met gameplay). Maar weest niet getreurd, er is als nog veel gebeurd ten opzichte van de vorige keer. Ik zal even proberen een "changelog" te maken, als ik het me nog een beetje kan herinneren

Zoals te zien hebben we lichten, en als je zéér goed kijkt, ook particles. Deze werken allebei zéér goed en zonder een al te grote impact op de framerate (bij mij). Ook bij Yorick (en zijn craptop) draait hij (met particles en lighting) op +- 30fps wat netjes is voor ons. Bij mij draait hij op 191 FPS, maar dat komt omdat alles een beetje vernaggeld is sinds de laatste paar updates. Dit komt omdat het allemaal niet goed lukte met het migreren van lijsten aangezien interactives in één lijst staan en collisionObjecten in een tweede. Hier is op zich niets mis mee, totdat je een object heb waarmee je wil kunnen interacten én collisie mee wil kunnen doen. Hier moeten we nog een geniale oplossing voor vinden. Voor de laatste updates kon ik met gemak 600FPS halen (zonder lighting, particles en bloom welliswaar, met dat alles +- 200fps).

Maargoed, we hebben dus Particles, Lighting, Monsters, Wapens, Drops, Fountains die leven aanvullen, UI, menu, Highscores, en ik vergeet vast nog wat andere dingen. Het begint steeds meer op een spel te lijken...

Wat zal ik opgelucht zijn als we voor maandag een werkend en leuk spel hebben. We hebben nog éven te gaan en we zullen met ons allen alle zeilen bijzetten om tot een leuk resultaat te hebben.

Tot ooit!

zondag 23 december 2012

Over animatie

In het spel van de bro's wordt uitvoerig gebruik gemaakt van geanimeerde objecten zoals monsters en spelers. Het systeem is in eerste instantie door Kevin gemaakt en later door mij nog eens extra bezoedeld.
Eerst moest je namelijk een animatie aanmaken. Deze animatie had de volgende dingen nodig:
Een spritesheet. Bestaande uit een plaatje en de afmetingen van afzonderlijke sprites.
Een startcolumn, endcolumn, startrow en endrow. De precieze hoeveelheid sprites op een sheet. Let op: bij een 4x4 sheet was de startcolumn 0 en de endcolumn 3.
De yorickoffset. De animaties staan vaak in een sheet met meerdere andere richtingen. Deze integer is de hoeveelheid plaatjes die per frame moet worden overgeslagen. Aangezien er voor vier windrichtingen plaatjes zijn in de meeste spritesheets en voor een aantal maar eentje, is dit eigenlijk altijd 1 of 4. Eigenlijk zou het looprichtingen moeten heten, maar het is als een soort running gag maar zo gelaten, aangezien het in het jargon van de Bro's een vaste plek had verdiend. (Mocht degene die ons beoordeelt punten aftrekken vanwege het verzinnen van rare namen voor variabelen, foei, je had dit stukje ook moeten lezen! PS: we houden van je!)
Ook was er een float die de frametime aangaf in seconden. Verder was er nog een bool MovesWithCamera die iets te maken had met de True3D engine en on screen zaken, maar eigenlijk altijd op false stond, en zo snel tot een rudimentair iets was vervallen dat niemand er ooit echt iets van heeft gemerkt.

De moderne versie van de animatie heeft een aantal toevoegingen en een aantal verwijderingen van parameters gekend. Eerst maar eens de weglatingen:

Voor zich spreekt dat de MovesWithCamera is verdwenen.
Eveneens moesten de startcolumn en startrow er aan geloven, aangezien alle spritesheets gewoon linksboven begonnen. Het was een handige manier om verschillende animaties in verschillende richtingen in de zelfde sheet op te slaan, maar dit vereist een boel parameters en een boel hardcoden, iets dat je liever wilt vermijden.
Nu komen de toevoegingen:
Een bool isLooping om te kijken of een animatie eenmalig af wordt gespeeld of continue. Ook een nieuwe toevoeging: het aantal frames. Als een animatie met maar 1 richting en 8 frames in een 3 bij 3 sheet staat, is het handig dat het lege negende vakje niet wordt getoond. Random Fact #1280: De slime was degene voor wie dit werd gemaakt, maar ook voor sheets met 4 richtingen kan dit soms handig zijn.
Tot slot is er een directionaloffset. Er worden immers telkens 3 frames overgeslagen omdat die bij een andere richting horen. De directionaloffset houdt bij waar de animatie begint. In Kevin zijn versie lag dit nog vast, maar ik heb het verbeterd. Eerst moest namelijk voor elke richting een aparte animatie worden gemaakt, nu is er nog maar één animatie en wordt deze offset aangepast.

Het enige soort object dat met animaties kan werken is het AnimatedGameObject. Dit is een upgrade van SpriteGameObject.

Dit object heeft een aantal methoden en variabelen om met de eerder behandelde animaties om te springen:

Er zijn twee mogelijkheden om een bruikbare animatie aan te maken:

LoadAnimation: het object heeft een dictionary waarin hij animaties kan bijhouden. Dit is al zo sinds het begin van de animatie in het spel. Met deze functie kan een animatie worden gemaakt en opgeslagen worden in deze dictionary. Vrijwel alle parameters die worden gebruikt in het aanmaken van een animatie komen hier ook aan bod, alleen is de eerder genoemde yorickoffset door een bool vervangen: directional. Zo is er geen verwarring mogelijk omtrent de rare naam. Ook worden er een paar kleine bewerkingen gedaan, namelijk wordt het animatedgameobject de parent van de animatie, en wordt de Origin gedefinieerd. Ook moet er een id in string-vorm worden meegegeven om het object in de dictionary op te kunnen vragen. Random Fact #1281: Vroeger werden er hier automatisch meerdere animaties aangemaakt voor de richtingen van de animatie, die allemaal onder een eigen naam werden opgeslagen in de dictionary.
CreateAnimation: Er zijn hier twee verschillende mogelijkheden. Er kan een animatie worden meegegeven of dezelfde waarden als bij LoadAnimation. Er wordt door deze methode een animatie teruggegeven. Het klinkt misschien raar dat je een animatie mee kunt geven, maar bij het handmatig aanmaken van een animatie worden de bewerkingen aan het eind van LoadAnimation niet uitgevoerd. Mocht iemand een animatie willen maken die exact hetzelfde is als een animatie die in LoadAnimation is gemaakt, dan kan dat hier. Bij een al gemaakte animatie wordt alleen het fine-tunen dat voorheen alleen via LoadAnimation mogelijk was alsnog toegevoegd.

Er zijn tevens twee manieren om een animatie af te spelen, namelijk met de methoden PlayAnimation en FlickAnimation.

Animaties kunnen direct worden meegegeven aan deze methoden of in string vorm, zodat ze uit de dictionary kunnen worden geplukt.
PlayAnimation stelt de huidige animatie van het object in als de gegeven animatie en FlickAnimation speelt de gegeven animatie een keer af om vervolgens terug te keren naar de vorige animatie. Mocht dit worden aangeroepen terwijl er al een Flick bezig is, Wordt naar de laatste normaal ingestelde animatie geretourneerd.
Ook kan de decimaldirection worden meegegeven om de richting van de animatie te bepalen zoals eerder al is uitgelegd.(zie: directionaloffset)
Een functie die Play wel heeft en Flick niet is een animatie stil afspelen door de bool Still die standaard false is. Het eerste frame wordt dan weergegeven en de animatie wordt niet verder afgespeeld. Random Fact #1282: voor FlickAnimation heeft een AnimatedGameObject een aparte variabele om de Animatie in op te slaan waar terug naar gegaan wordt na afloop.

PS: de decimaldirection kan door objecten in hun gewone methoden gebruikt worden. Zijn nut blijft dus niet beperkt tot het regelen van animatie. De loop/kijk richtingen zijn als volgt gedefinieerd: 0 is naar beneden, 1 is omhoog, 2 is rechts, 3 is links. Dit geld ook voor de directionaloffset. Bij het aanpassen van de decimaldirection wordt de animatie ook automatisch aangepast, tenzij de animatie maar 1 richting heeft.


PPS: Mocht je het nog niet vergeten zijn, er moet nog even gemeld worden waarom ik vandaag een domme jongen was. Ik dacht namelijk een bug op te moeten lossen waardoor de animaties niet loopten, maar alle animaties die ik gebruikte bij het debuggen stonden per ongeluk op niet loopen. Dom, dom, dom...

zondag 16 december 2012

Het begin van het spel concept

Een beetje laat om dit nu pas te bloggen, maar ik vind dat het toch moet gebeuren. In deze blog vertel ik jullie hoe we aan onze spel concept zijn gekomen.

De eerste meeting van ons groep begon gelijk met het brainstormen. Voor de meeting had ik, Vince en Kevin besloten dat het spel Kirby een goede basis is om ons spel op te bouwen. De idee hadden we tijdens de meeting aan Sander en Yorick uitgelegd. Jammer genoeg vonden ze het helemaal niks. Na een tijdje kwamen we er nog steeds niet uit. Gelukkig gaf iemand ons een tip en zei dat we iedereens belangrijkste voorkeur op moest schrijven.

-David : Side Scrolling, Combo fighting, multiplayer
Ik wou heel graag dat het beetje op super smash bros. leek. Met name dat je met een bepaalde toetsen combinatie een skill geactiveerd kan worden. Dit maakt de combat levendig.
-Vince : Real Time
Vince wilt niet dat het spel turn-based wordt. Tijdens een gevecht moeten de monster de player gewoon kunnen aanvallen ook al doet die niks. Dit maakt het spel ook levendiger. Verder wilt hij ook geen level systeem hebben.
-Kevin : Side Scrolling, Brawling
Kevin is het ook met mij eens dat er een combo systeem moet komen voor het gevecht.
-Yorick: RPG
Yorick's voorkeur was een van de simpele voorkeur. Hij wou dat het spel een RPG is.
-Sander: Top Down, Rogue like
Sander wou heeeeel GRAAG dat het spel rogue als basis wordt gebruikt. En ook dat het camera view top down is. Verder wilt sander ook dat de dungeon random gegenereerd wordt.

Met iedereens voorkeur op papier gingen we verder brainstormen met als uitkomst bomberman, tower defence en zelda. Iedereen was er mee eens dat deze spellen potentie hebben om onze basis spel te zijn. Na wat overleg hadden we besloten dat het zelda wordt.

Nadat we besloten hadden dat we zelda ons basis spel wordt, ging ik verder brainstormen tijdens de rit naar huis. Ik had mijn idee aan Vince uitgelegd die samen met mij in de bus zat. Hij vond het een goed idee en de belangrijkste iedereen's voorkeur zat erin. De volgende dag had ik aan de rest van de groep vertel en ook zij vonden het een goed idee.


De Spel Concept dat ik tijdens de bus rit had bedacht:

Een prinses is in een grot beland. De speler moet haar redden en ook nog is leven uit de grot komen.
Bij de uitgang staat een eindbaas die verslagen moet worden. De grotten zijn willekeurig gegenereerd, zodat het spel niet saai wordt. Onderweg naar de prinses en baas/uitgang moet je ook monsters verslaan. Monsters versla je met een van de 6 wapens die je in het begin krijgt. Elk wapen heeft zijn voordeel en nadeel. Neem bijvoorbeeld een zwaard die doet meer schade dan een speer. Maar de speer heeft dan wel hoger bereik dan een zwaard. Verder heeft elk wapen een actief en passief skill. Elk wapen begint met geen skill, dus als wapen lvl 0. Elke x als je een monster verslaat krijg je kans op een powerup die je wapen sterker maakt tot maximaal lvl 3. Maar de gevaar is er ook dat als je schade krijg je powerup kwijt raakt. De skills worden uitgevoerd door middel van een combo systeem. Het is dus niet simpel weg een knop in drukken om de skill te activeren. Als je dood ben dan begint je helemaal opnieuw.

Brainstorm mode

Over botsingen en samenvoegingen

Botsingen met botsingen.
Collision detection. Je ontkomt er niet aan, elk spel heeft het. Vorige week was het dan ook voor ons zover, de speler mocht ineens niet meer door muren heen lopen. Ik had de taak van collision detection op me genomen, niet omdat ik het zo leuk vond, maar omdat iemand het moest doen.

Zelfs met XNA's handige functies bleek dit ingewikkelder dan verwacht. De speler bleef vaak vast zitten in hoekjes, muren of soms zelfs in het niets. Het is niet zo zeer het vinden van een botsing wat lastig is, maar het uitvinden aan welke kant van de speler deze plaatsvindt. Vooral in het geval van hoeken is dit erg vervelend. En zelfs als je weet waar de collisie zich bevind is het nog best een karwei om ervoor te zorgen dat de speler niet de muur in kan bewegen, maar wel alle andere kanten op.

Na flink wat uren werk zonder gewenst resultaat dacht Sander dat hij mijn 'shit' wel even kon 'fixen'. Maar aan het eind van de middag was de code alleen maar complexer geworden, terwijl het resultaat hetzelfde was gebleven. Daarna heb ik de strijdbijl weer terug genomen, wat nog best een gedoe was aangezien Sander graag af maakt waar hij aan begint. Dat geldt natuurlijk ook voor mij, en na nog een dagje werk was het dan toch gelukt. Collision detection werkt.

Maar hoe?
We kijken eerst welke objecten zich rond de speler bevinden. Van deze objecten maken we een drie-bij-drie grid van booleans waar de speler het midden is en de waarde true betekend dat er een muur is en false dat er geen muur is. Deze 2D-array geven we aan een functie die de afstand en richting geeft tot de muur waar we mee botsen (dit doen we doormiddel van ray intersection met bounding boxes). Dan wordt de speler over de gegeven richting en afstand verplaatst zodat deze tegen de muur aan komt te staan. Vervolgens wordt ervoor gezorgd dat de speler zich niet verder de muur in kan verplaatsen, maar wel alle andere richtingen op. Dit werkt goed voor collisions met zijkanten van muren, maar in de hoeken gaat het fout. Daarom gebruiken we voor hoeken naast de raycollision ook nog eens de coordinaten en grootte van de boundingbox om te berekenen welke kanten de speler wel en niet op kan bewegen.

Botsingen in 3D.
Gisteren was het eindelijk zover, na vele uren was de 3D engine van Vince af. En het was tijd om alles (de 3D engine, dungeon generation, speler animatie, de game management library en collision) samen te voegen zodat we iets moois hebben om te laten zien woensdag. Dit heeft Vince een hele dag werk gekost aangezien ik in de game management library niet heel veel rekening (lees: geen rekening) had gehouden met de implementatie van 3D.

Maar alles werkt nu, we hebben nu een speler die door een random gegenereerde dungeon heen kan wandelen in 3D. David is momenteel bezig met de AI, dus binnenkort hebben we ook nog eens monsters die door de speler in de pan gehakt kunnen worden.

Het menu met de gegenereerde dungeon in de achtergrond.

Het spel zoals het er nu uit ziet.


maandag 3 december 2012

Willekeurige levels en zo

Afgelopen week hebben we behoorlijk wat zaken afgehandeld. Zo hebben we vrijdag besloten dat we vóór aanstaande vrijdag een werkend prototype hebben waar we met z'n allen doorheen kunnen lopen. Lighting is helaas op een laag pitje gezet omdat Marries zei dat het nagenoeg onmogelijk is om +- 30 lichten met schaduwen te hebben, waar ik het ook een beetje mee eens ben, én het wordt niet van ons verwacht voor het komende jaar. Ik heb momenteel wel een ideetje om het te implementeren, maar dan moet de rest het daar ook mee eens zijn. Maargoed, op naar de random dungeon generation algorithm:

Random Dungeon Generation:
Oké, aan de hand van het artikel dat ik heb gelezen (bron) ben ik aan de slag gegaan. Het algoritme is eigenlijk vrij simpel:

  1. Maak een kamer in het midden met een willekeurige grootte
  2. pak een willekeurige muur en plaats daar een deur
  3. ga vanuit die deur een nieuwe kamer maken
  4. pak een willekeurige kamer
  5. pak een willekeurige muur en plaats daar een deur
  6. ga vanuit die deur een nieuwe kamer maken
  7. en ga zo maar door (herhaal stap 4-6 totdat we genoeg kamers hebben)
Dit gaf wel aardige resultaten, maar dit had als nadeel dat alle kamers naast elkaar zaten. Daarom heb ik er nog een paar regeltjes aan toegevoegd, namelijk dat we ook gangen kunnen maken (breedte 3, waarvan er 2 voor de muren zijn). Dus uiteindelijk is het als volgt geworden (r is een willekeurig getal tussen 0 en 1 van het type double (random.NextDouble())):
  1. Maak een kamer in het midden met een willekeurige grootte
  2. pak een willekeurige muur en plaats daar een deur
  3. ga vanuit die deur een:
    1. nieuwe kamer maken als r >= 1
    2. nieuwe gang maken als r < 1
  4. neem een willekeurige gang/kamer
  5. pak een willekeurige muur van die gang/kamer en plaats daar een deur
  6. als de gekozen kamer
    1. een kamer is
      1. maken we een nieuwe kamer als r >= 1
      2. maken we een nieuwe gang als r < 1
    2. een gang is
      1. maken we een nieuwe kamer als r >= 0
      2. maken we een nieuwe gang als r < 0
  7. herhaal stap 4-6 totdat we genoeg kamers hebben
Zoals te zien maken we altijd een kamer als we een gang hebben gekozen en maken we altijd een gang als we een kamer hebben gekozen. Echter, als we de '0' of de '1' aanpassen naar bijvoorbeeld '.25' en '.75' krijgen we geheel andere dungeons. Een paar voorbeelden (bruin is aarde, roodbruin is muur, groen is deur en wit is vloer):
Dit is een gegenereerde kaart met de volgende parameters: breedte: 300, hoogte: 400, aantal kamers: 20, breedte van een kamer: 5-10, hoogte van een kamer: 5-10.

Dit is een gegenereerde kaart met de volgende parameters: breedte: 100, hoogte: 100, aantal kamers: 300, breedte van een kamer: 5-10, hoogte van een kamer: 5-10
Nu rest dan eigenlijk alleen nog het probleem hoe we dit in de True3D engine van Vince toe gaan voegen. Na wat gehannes (wat eigenlijk reuze mee viel) heb ik het voor elkaar gekregen, en het resultaat mag er zijn vind ik. Persoonlijk denk ik dat het mooier is om aan het eind van een gang de kamer te maken in plaats van ergens in het midden en sowieso moet ik nog zorgen dat er tussen kamers een gang kan komen zodat er rondjes ontstaan, maar daar moet ik het nog even met anderen over hebben.

Dit is dus de gegenereerde dungeon, zoals te zien zijn er aardig wat doodlopende gangen. Hier kan misschien iets aan gedaan worden, maar het geeft ook wel iets meer spanning. Het enige nadeel is nu eigenlijk dat we als we in een kamer staan we de kamer ernaast ook kunnen zien. Rechtsonder zie je een geopende kist van Vince. Het resultaat mag er zijn :)
Dus dit was even een korte heads-up. Zoals het er nu naar uitziet kunnen we vrijdag inderdaad al een werkend prototype hebben. En het leuke is, de mogelijkheid tot First Person is er nog steeds, waar dit niet eens de bedoeling was! Dit gaan we hoogst waarschijnlijk niet toevoegen, maar misschien wel leuk om te doen als we een dungeon hebben uitgespeeld, dat we in first person door de dungeon bewegen hetzelfde pad als dat de speler heeft genomen.

I'm looking forward to it, and we're having a blast at it!
-Sander

maandag 26 november 2012

De (niet zo) initiële post

Goedemorgen,

Er is al weer een weekend voorbij gegaan sinds onze laatste update en dit weekend hebben we niet zo veel werk verricht als we zouden willen. Yorick heeft wat plaatjes aangepast voor de inventory en multi-tiled items gemaakt, Kevin heeft wat aanpassingen aan de GameManagement gedaan, Vince is volgens mij begonnen met kisten en ik heb eigenlijk vrij weinig gedaan. Ik ben dan begonnen met de DungeonGenerator, maar dit bleek toch lastiger dan gedacht, dus ik ga er vanochtend in de gamehall weer tegenaan.

Kevin en ik waren nog eens goed de opdracht aan het lezen en toen kwamen we erachter dat onze eerste post niet aan de opdracht voldeed. In de opdracht stond namelijk dat we in de initiële blogpost moesten vermeldden wat we gaan doen en hoe we dat doel willen bereiken. Ik heb uiteindelijk gezegd wat we al hadden gedaan. Nu is de tweede post meer initieel dan de eerste, maar als blijk van mijn verontschuldiging wil ik hieronder alsnog de initiële blogpost doen. Voor meer informatie over ons doel wil ik jullie graag doorverwijzen naar onze analyse van Zelda, waar met meer diepgang wordt overlegd wat we gaan doen.


Gegroet,

Het spel vordert al aardig snel en ik durf te stellen dat we na een kleine week al hebben besloten wat we gaan doen. Ik had eerst al het idee om Rogue te gaan doen met willekeurig gegenereerde dungeons, maar de rest was het er eigenlijk nog niet helemaal mee eens. Daarna kwamen Kevin, Vince en David met het idee "Kirby" gecombineerd met een fighter. Hier waren Yorick en ik het niet mee eens en dus hebben we wat anders besloten.

Diezelfde vrijdagmiddag gingen we in de gamehall zitten om verschillende ideeën uit te werken. Met de goede raad van iemand die daar zat hebben we allemaal 2 dingen genoemd die we graag willen doen, waar David over na is gaan denken. Dit heeft geleid tot een top-down dungeon crawler in de trant van Zelda, maar omdat willekeurig gegenereerde levels al de hele tijd door mijn hoofd spookten wilde ik er ook iets mee. Daarom heeft de rest van Alpha Bros. ook gezegd dat het wel goed is om willekeurige dungeons te hebben, waar ik zeer tevreden mee was.

"Hoe zijn we dan op de naam 'Alpha Bros.' gekomen?", kunt u zich nu afvragen. Dit is allicht wel een interessant verhaal, aangezien wij gewoon op internet zijn gegaan met een willekeurige teamnaam generator. Dit hebben we een paar keer gedaan totdat er een leuke naam uitkwam, maar vreemd genoeg kwam hier nooit 'Alpha Bros.' uit. Wel Alpha en dat is ook zo goed bevallen dat we dit gewoon wilden behouden. Vince kwam toen met de naam Alphablenders, omdat we het leuk vinden om de alphawaarde van kleuren te mengen, maar de rest vond dit niet zo goed. Uiteindelijk hebben we er Alpha Bros. van gemaakt, als een hommage aan Luigi en Mario, van de Super Mario Bros.

Welk pad gaan we bewandelen? Alleen de tijd zal het vertellen, maar ik kan u al wel meedelen dat we er nog niet helemaal over uit zijn of we nu een eindig of een oneindig aantal levels maken. Hierover zijn de meningen nog sterk verdeeld, zo sterk zelfs dat we het beide gaan doen. David en Vince werken het eindige levelsysteem uit, waar Kevin en ik het oneindige levelsysteem uitwerken. En wat doet Yorick? Die houd zich lekker afzijdig van de inwendige problematiek van de Alpha Bros.

Stay tuned for moar!

vrijdag 23 november 2012

De inwendige politiek van de Alpha Bros.

Door onze studio zijn in de eerste week verschillende (hoofdzakelijk later verworpen) engine's gebouwd, namelijk een 2.5D engine (Sander, verworpen), een 3D engine(Vince), een lighting engine(Yorick, verworpen), een GameManagement engine(Kevin) en een inventory engine (Yorick).

Hoewel dit stuk voor stuk interresante zaken zijn, en een kort stukje over de werking op zich niet zou misstaan, zou ik toch graag de strijd tussen de 2.5D engine en de 3D engine uitlichten in plaats van grote lappen technische details op te ratelen.
Het spelconcept is immers om een top-down dungeon crawler te maken, waarbij inspiratie is opgedaan bij de Zelda games. Tijdens het maken van beslissingen over de vormgeving van ons introproject was voor onze gamedevelopers het uiterlijk van de muren van groot belang. (Jullie lezen het goed, het was makkelijker om het over de spelbesturing, gameplayelementen en het speltype eens te worden dan over het uiterlijk van muren.) Het plan was immers eerst om een 2D top-down spel te maken.

De muren kunnen dan op twee manieren getekend worden, namelijk zoals bijvoorbeeld gedaan wordt in Zelda: Minish Cap:

De muren worden in dit geval altijd getekend alsof ze van schuinboven gezien worden, ongeacht van de positie ten opzichte van de camera.

De andere mogelijkheid was zoals het werd gedaan in bijvoorbeeld de pokemon spellen:

De muren zien eruit alsof ze allemaal vanuit de zelfde hoek getekend worden. Het nadeel hiervan is dat je nu een keuze moet maken tussen voorwerpen, vijanden en de speler soms achter de muur te moeten tekenen, waardoor je ze niet goed ziet, of niet rekening te houden met het overschaduwde deel grond achter een muur en de speler daar helemaal niet te laten lopen. Deze manier kost je ruimte in je levels.
Ook kun je zo alleen de muren van de noordkant zien, waardoor je eigenlijk alleen deuren en trappen kunt hebben op deze muren, een beperking die voor een dungeon crawler niet erg praktisch is.

De conclusie was uiteindelijk dat we top down zouden tekenen met een 3D uiterlijk. Voor een geschikt beeld hiervan zou ik graag naar de vorige blogpost willen verwijzen.
Kortom, zowel Sander als Vince gingen aan de slag met hun eigen soort Engine.
Sander bouwde in een paar dagen eventjes een 2.5D engine (doet ie effe in een handomdraai). Deze manier van tekenen kun je alleen in een top-down situatie gebruiken, omdat het niet echt 3D objecten zijn.
Vince pakte het nog drastischer aan en bouwde maar meteen een engine die echte 3D ondersteunde.
Nu zaten we dus met twee engines (de heren hadden immers niet overlegd wie wat ging doen, ze waren gewoon maar begonnen en schreven allebei in 2 dagen een engine waar menig beginnend programmeur jaloers op mag zijn).

Hier ziet men de 3D engine van Vince. Wie wil horen waarom er twee verschillende manieren gebruikt worden om tijdens het debuggen de framerate te berekenen moet daarvoor aankloppen bij Vince dan wel Sander. Ze willen het vast erg graag en uitvoerig uitleggen, en zullen daarbij vooral niet versmaden te benadrukken waarom hun eigen manier beter is dan die van de ander.

Uiteindelijk viel de keuze voor de 3D engine van Vince, onder andere omdat hierin de mogelijkheid van first-person niet direct werd uitgesloten, en ook omdat Vince heel hard en vaak heeft geroepen dat een lighting engine in een 3D omgeving veel makkelijker te maken was dan in een 2.5D omgeving (Mijn 2D lighting engine was onvoldoende bevonden en afgeschreven, maar het idee van lighting is nog niet van tafel geveegd). Misschien was de chaotische code van Sander ook een doorslaggevend element.

Sander moest wel heel hard huilen omdat zijn 2.5D engine niet werd aangenomen. Dat was heel zielig. Einde.

-Yorick