Övningar på att använda structs samt att skapa ny .h-fil:

1. Börja med att skapa en struct för 2D-vektorer som vi kan använda för positioner men även skulle kunna använda för riktnings- och hastighetsvektorer. Det är lämpligt att de två structmedlemmarna x,y är floats. Dels så att positioner och hastigheter inte är begränsade till heltal och dels för att inte avrundningsfel ska ackumuleras, t ex om du senare vill flytta dina objekt efter någon mjuk kurva som bygger på någon flyttalsformel. Kalla därför din struct för vec2f , dvs vektor av två floats, vilket är ett vanligt vedertaget namn för en sådan här struct. Det är vanligt att även behöva ha motsvarande för ints och doubles (dvs vec2i resp. vec2d). Alternativa vanligt vedertagna namn är float2, int2 osv.

     •   Lägg din struct vec2f i en ny källfil som du kallar för vecmath.h.
     •   Använd även så kallade include guards (se nedan).

   
   Se därefter till att du anger typen Header file (.h). Ange namnet vecmath.h.

   Include guards: Vi kommer till include guards först i nästa lektion, men du kan lika gärna lägga till det här och nu... En .h-fil är typiskt omgärdade av följande rader:

   #ifndef VECMATH_H // eller vad din fil heter. Versaler på #define VECMATH_H // filnamnet + "_H" är vanligt. ... resten av innehållet i .h-filen #endif // VECMATH_H -- här är VECMATH_H endast kommentar // för tydlighets skull

   Detta gör att .h-filen inte kommer att inkluderas mer än en gång när en .c-fil kompileras. Om den skulle inkluderas fler än en gång kommer innehållet att finnas med motsvarande antal gånger, vilket kan leda till felet "multiple definitions", t ex av structs. En .h-fil kan lätt råka inkluderas flera gånger om man inkluderar flera .h-filer som i sin tur råkar inkludera samma .h-fil. Detta är inte ovanligt, vilket du förmodligen snart kommer att märka.
         Konstruktionen fungerar enligt följande: #ifndef, #define och #endif är så kallade preprocessor directives: #ifndef betyder "if not defined". Dvs, allt som står mellan #ifndef VECMATH_H och #endif behandlas vid kompileringen (av .c-filen) endast om VECMATH_H inte är definierat. Första gången som preprocessorn ser #include "vecmath.h" och försöker inkludera vecmath.h så är VECMATH_H (naturligtvis) inte definierat och alltså inkluderas innehållet. Första efterföljande rad är just en #define VECMATH_H som alltså ser till att VECMATH_H blir definierat. Om preprocessorn finner på en till #include "vecmath.h" lite senare kommer VECMATH_H alltså redan att vara definierat och innehållet i .h-filen tas inte med någon mer gång. Detta är helt enkelt ett vanligt trick för att lösa ett vanligt problem. Vissa kompilatorer tillåter enklare sätt som t ex "#pragma once" för att lösa samma problem.

   I filen vecmath.h:
   #ifndef VECMATH_H #define VECMATH_H typedef struct { float x, y; } vec2f; #endif // VECMATH_H
2. Byt ut skeppets x- och y-variabler mot en vec2f pos istället. Dvs:
   //int x = 400, y = 300, speed = 3; <- Byt detta vec2f pos = {400, 300}; // mot detta int speed = 3; // och detta

   Detta medför att du måste modifiera din kod överallt där x och y används. Gör detta. Ett tips är att kompilatorn kommer att klaga där du behöver modifiera. Är du ovan vid structs är detta en mycket nyttig övning.

   Tips: Bl a behöver även inparametrarna för shake() ändras från (int* x, int* y) till (vec2f* pos), och eftersom pos här är pekare behöver du inuti funktionen använda pilnotation:
   void shake(vec2f* pos) { ... pos->x += ... // istället för *x += ... pos->y += ... // istället för *y += ... ...

3. Skapa en struct för alla våra spelobjekt:

   Nu ska vi skapa en gemensam struct för alla våra existerande (dvs skeppet + background) och kommande spelobjekt. Med denna struct kapslar vi in skeppets och bakgrundens variabler med hjälp av en och samma lämpliga struct (som alltså kan användas av båda) och som vi lägger i en ny separat .h-fil. Dvs structen innehåller ett superset av de variabler som skeppet och bakgrunden använder. Vi kallar vår struct för GameObject och lägger implementationen i filen gameobject.h, enligt nedan.
   
   

   Här följer en stegvis beskrivning av vad du ska göra:
   • Skapa struct GameObject i filen gameobject.h enligt ovan.
   • I main.c: byt ut GfxObject ship, background; mot GameObject ship, background;. Dvs:
     ... #include "gameobject.h" GameObject ship, background; ...
   • Anpassa nu din kod så att den fungerar som förut, men alltså använder vår inkapsling av objektens variabler i struct GameObject. Det innebär att du behöver initiera ship och background i main()-funktionen samt modifiera din kod att använda struct-medlemmarna istället för de tidigare olika separata variablerna. Tips är att om du bara gör modifieringen ovan och kompilerar kommer kompilatorn klaga där du behöver ändra.

   När du gör din modifiering så inför inga globala variabler i .h-filen. Det behövs inte och först nästa vecka tar vi upp hur man representerar globala variabler i en .h-fil på ett korrekt sätt (för den nyfikne görs det med extern).

   Gör alltihop så långt som möjligt själv utan att titta i lösningen för det är en mycket nyttig övning om du är ovan vid C och structs. Räkna med att det tar tid. När du fått koden att kompilera, använd debuggern för att rätta eventuella återstående fel. Använd CodeLite's Help-menu och skriv t ex debug eller breakpoint för att få hjälp. Kompilera och testa att allt fungerar som förut.

1. Skapa en funktionspekare som heter print och tar inparametrarna (const char* str, int x, int y) med returtyp void. Skapa även två funktioner:
   

   void printToWindow(char* str, int x, int y) { ... } void printToConsole(char* str, int x, int y) { ... }
   där printToWindow(...) anropar renderText(...) och printToConsole(...) anropar printf(...).

   Inför med hjälp av funktionspekaren så att man kan toggla, med lämplig tangent, så att din utskrift av "Hello World!" (el vad du använt) skrivs ut i consolen eller i fönstret.

   Ändra anropet renderText(strang, 300, 150); (inuti realtidsloopen i main.c) till att använda din funktionspekare: print(strang, 300, 150); och sätt funktionspekaren omväxlande till printToWindow(...) respektive renderText(...) när du trycker på lämplig tangent.

   Skapa och tilldela värde för en funktionspekare kan du t ex göra på följande sätt:
   void (*print) (char* str, int x, int y) = printToWindow;
   respektive
   print = printToConsole;
   

   (För lösning, se nästa uppgift.)
2. Troligen löste du tangentbordschecken med hjälp av state[SDL_SCANCODE_...]. Isåfall märkte du säkert att det är svårt att hålla nere en tangent endast en frame. Här passar det bättre att istället reagera på events som KEY_DOWN för din tangent.

   Dvs här finns en viktig poäng som gäller för all tangentbordsinmatning, inklusive för MD407:an. Ibland vill man kunna känna av en tangents status och utföra logik baserat på om tangenten är nedtryckt eller inte. Ibland vill man kunna reagera just när en tangent trycks ned eller släpps upp. Det första passar t ex realtidsspel där man styr en spelare. Det andra passar t ex ordbehandlare.

   Antag att du vill lyssna på KEY_DOWN för 'c'-tangenten (dvs SDL_SCANCODE_C). Du löser det med SDL på följande sätt:
   
   SDL_Event e; //Event handler while( SDL_PollEvent( &e ) != 0 ) { ... if( (e.type == SDL_KEYDOWN) && (e.key.keysym.scancode == SDL_SCANCODE_C) ) { ... } }
   Utför denna modifiering.

Som du kan se vill vi ha en array, gameObjects[], av alla våra spelobjekt (just nu har vi endast skeppet och bakgrunden men vi ska snart lägga till fler). Vår struct GameObject, som du införde i uppgift 1, skall alltså även innehålla metoderna update() och render().

Att skapa en array av rätt typ är trivialt om alla objekten är av samma typ (dvs samma struct). Vi kan ha en array av objekten eller dess pekare. Men... olika spelobjekt kanske senare behöver fundamentalt olika data lagrade i sina structs. Hur gör man då? Det finns åtminstone två olika lösningar:

1. Vi kan låta vår struct GameObject innehålla ett superset av alla olika medlemmar som olika objekt behöver. Det är inte snyggt, men lätt och helt OK. Nackdelen är att det tar onödigt mycket minne, men för färre än några tusen instansierade objekt har det knappast praktisk betydelse.
2. Eller så kan vi använda mer avancerad objektorientering, men det är överkurs...
   Vi kan lösa problemet objektorienterat genom att låta arrayen vara en array av typen pekare till en bas-struct (dvs basklass) som alla spelobjekt ärver ifrån. T ex:

   typedef struct { GameObject gameObj; int apa; ... } Player;

   typedef struct { GameObject gameObj; float bepa; ... } Background;

   Player player; // skapa en instans Background background; // skapa en instans int nGameObjects = 2; GameObject* gameObjects[] = // lägg adresserna i arrayen {&player.gameObj, &background.gameObj}; player.gameObj.update = updatePlayer; ... gameObjects[0].update(gameObject[0]);

   Men hur gör vi nu för att inuti respektive objekts render()- och update()-funktion få tag på den klassdata som inte tillhör basklassen GameObjekt (dvs apa respektive bepa)? Lösningen är väldigt "C-aktig" - dvs inte så vacker men fungerar:

   i Player.c: void updatePlayer(GameObject* gameobj) { Player *this = (Player*)((void*)gameobj - (void*)&((Player*)0)->gameObj); // Player-medlemmar kan nu accessas med: this->apa ... // dvs: this->medlem }

   Vad vi gör är att skapa en pekare, this, som pekar på starten av vår struct Player. Vi gör detta genom att beräkna this som "adressen till gameobj (som pekar på vår basklass) minus Player-structens offset till basklassen". (Eftersom vi i det här exemplet lagt gameObj som första medlem i Player och Background är offseten = 0, så man hade här kunnat nöja sig med this = (Player*)&gameobj;.)

Vi väljer alternativ 1 då det är lättast. Gör detta. Behöver du hjälp följer här de steg du behöver göra:

• Lägg till metoderna update(...) och render(...) i din struct GameObject.
• För enkelhets skull, lägg din övriga nya kod för stegen nedan direkt i main.c-filen. Vi kommer nästa vecka till hur man lämpligen kan lägga de nya delarna i andra filer (vi behöver använda oss av C:s keyword "extern").
• Skapa en global array gameObjects[] som innehåller adresserna till background och ship. Skapa även en global variabel för arrayens längd, dvs nGameObjects = 2.
• Just nu ligger uppdateringen av dina objekt direkt i realtidsloopen i main(). Flytta ut all uppdatering av skeppets data till en funktion updateShip(...). För att kunna göra detta måste du även flytta din variabel const Uint8 *state och lägga den som en global variabel. Likaså, flytta uppdateringen av datan för background till en funktion updateBackground(...). :
  const Uint8 *state; void updateShip(GameObject* this) { ... } void updateBackground(GameObject* this) { ... }
• Skapa en funktion void render(GameObject* this) som anropar renderGfxObject(...).
• I main() där du initierar ship, lägg även till:
  ship.update = updateShip; ship.render = render;
  Gör motsvarande för background.
• Slutligen, i realtidsloopen där du tidigare uppdaterade och renderade skeppet och background, anropar du nu istället metoderna:
  // Update our object(s) for(int i=0; i < nGameObjects; i++) gameObjects[i]->update(gameObjects[i]); // Render our object(s) - background objects first... for(int i=0; i < nGameObjects; i++) gameObjects[i]->render(gameObjects[i]);