Restructured some stuff, now the map is scrolling :), but some optimizations are needed!

CMakeLists.txt

@@ -43,6 +43,7 @@ set(ASSETS
 )
 set(ASSETS_fx
   assets-fx/levels/level0.json
+  assets-fx/demo_player.png
   # ...
 )
 

assets-fx/fxconv-metadata.txt

@@ -1,3 +1,6 @@
 example.png:
   type: bopti-image
   name: img_example
+demo_player.png:
+  type: bopti-image
+  name: demo_player_img

src/main.c

@@ -14,21 +14,16 @@
     #include <gint/gray.h>
 #endif //COLOR2BIT
 
-
-
-
-
 #include <stdint.h>
 #include <stdbool.h>
 
 #include "map.h"
 #include "player.h"
-
+#include "mapdata.h"
-
 
 /* Player data (defined in "player.h")*/
-struct Player MyPlayer = { 10, 5, 100 };
+Player MyPlayer = { 10, 5, 0, 0, 100 };
-
+Map *map_level = &map_level0;
 
 /* some global variables */
 bool exittoOS = false;        // set to true when asked for exit
@@ -36,21 +31,18 @@ bool exittoOS = false;		// set to true when asked for exit
 bool screenshot = false;    // set to true when screenshot is required
 bool record = false;        // set to true when
 
-
-
 /* Key management */
 
 static void get_inputs( void  )
 {
     key_event_t ev;
-    while((ev = pollevent()).type != KEYEV_NONE)
+    while((ev = pollevent()).type != KEYEV_NONE){
-    {
 
     }
 
     /* Key binding for the Player action */
-	/*************************************/
 
+    /*************************************/
 
     if(keydown(KEY_EXIT)) exittoOS = true;
 
@@ -100,7 +92,6 @@ static void get_inputs( void  )
 void GameLogic( void )
 {
 
-
 }
 
 
@@ -126,7 +117,8 @@ int main(void)
         dclear(C_WHITE);
 
         /* render the map */
-		RenderMap();
+        RenderMap(&MyPlayer, map_level);
+        PlayerDraw();
 
         /* start the logic of the game */
         GameLogic();

src/map.c

@@ -1,38 +1,92 @@
 #include "map.h"
+
 #include <gint/display.h>
 
-extern struct Map map_level0;
+#define T_HEIGHT 8
+#define T_WIDTH  8
 
-struct Map *map_level = &map_level0;
+void RenderMap(Player *player, Map *map_level) {
-
+    /* for all Layer (2 in the current configuration: Background is layer 0 and
-void RenderMap( void )
+     * foreground is layer 1 ) */
-{
+    for (int u = 0; u < map_level->nblayers; u++){
-  /* for all Layer (2 in the current configuration: Background is layer 0 and foreground is layer 1 ) */
+        /* Draws a layer of the map on screen. */
-  for (int u = 0; u < map_level->nblayers; u++)
+        /* x and y will contain the position in the loop. */
-  {
+        int x, y;
-    /* for each colum */
+        /* The positions where we start drawing the tiles will be in tx and
-    for (int i = 0; i < map_level->w; i++)
+         * ty. */
-    {
+        int tx, ty;
-      /* and each line */
+        /* mx and my will contain how many pixels will be hidden on x and on
-      for (int j = 0; j < map_level->h; j++)
+         * y. */
-      {
+        int mx, my;
-        /* compute the index */
+        /* dw and dh contain the amount of tiles that will be drawn on x and on
-        uint16_t index = j * map_level->w + i;
+         * y. */
-        
+        int dw = DWIDTH/T_WIDTH+1, dh = DHEIGHT/T_HEIGHT+1;
-        /* get the tile index from the map*/
+        /* mw and mh will contain the height and the width of the map. */
-        int16_t currentTile = map_level->layers[u][index];
+        int mw = map_level->w*T_WIDTH, mh = map_level->h*T_HEIGHT;
-        
+        /* tile contains the tile to draw. */
-        /* currentTile == -1 means nothing to be draw */
+        short int tile;
-        if (currentTile != -1)
+        /* The position where I start drawing */
-        {
+        int sx, sy;
+        /* Fix sx. */
+        if(player->x<DWIDTH/2){
+            /* If I can't center the player because I'm near the left border of
+             * the map. */
+            player->px = player->x;
+            sx = 0;
+        }else if(player->x+DWIDTH/2>mw){
+            /* If I can't center the player because I'm near the right border of
+             * the map. */
+            sx = mw-DWIDTH;
+            player->px = player->x-sx;
+        }else{
+            /* I can center the player. */
+            player->px = DWIDTH/2;
+            sx = player->x-player->px;
+        }
+        /* Fix sy. */
+        if(player->y<DHEIGHT/2){
+            /* If I can't center the player because I'm near the top border of
+             * the map. */
+            player->py = player->y;
+            sy = 0;
+        }else if(player->y+DHEIGHT/2>mh){
+            /* If I can't center the player because I'm near the bottom border
+             * of the map. */
+            sy = mh-DHEIGHT;
+            player->py = player->y-sy;
+        }else{
+            /* I can center the player. */
+            player->py = DHEIGHT/2;
+            sy = player->y-player->py;
+        }
+        tx = sx/T_WIDTH;
+        ty = sy/T_HEIGHT;
+        mx = sx-tx*T_WIDTH;
+        my = sy-ty*T_HEIGHT;
+        for(y=0;y<dh;y++){
+            for(x=0;x<dw;x++){
+                /* I get the tile number if his position is inside the map. Then
+                 * I draw it. */
+                if(tx+x>=0 && tx+x < map_level->w &&
+                   ty+y>=0 && ty+y < map_level->h){
+                    tile = map_level->layers[u][(y+ty) * map_level->w + tx+x];
+                    /* tile == -1 means nothing to be draw */
+                    if(tile >= 0){
                         /* get x and y position in the tileset image */
-          uint16_t xtile = (currentTile % map_level->tileset_size) * 8;
+                        unsigned short int xtile = (tile %
-          uint16_t ytile = (currentTile / map_level->tileset_size) * 8;
+                                                   map_level->tileset_size) *
-          
+                                                   T_WIDTH;
+                        unsigned short int ytile = (tile /
+                                                   map_level->tileset_size) *
+                                                   T_HEIGHT;
                         /* render */
-          dsubimage(i * 8, j * 8, map_level->tileset, xtile, ytile, 8, 8, DIMAGE_NONE );
+                        dsubimage(x*T_WIDTH-mx, y*T_HEIGHT-my,
+                                  map_level->tileset, xtile, ytile, 8, 8,
+                                  DIMAGE_NONE);
+                    }
                 }
             }
         }
     }
 }
+

src/map.h

@@ -4,11 +4,9 @@
 
 #include <gint/display.h>
 
+#include "player.h"
 
-void RenderMap(void);
+typedef struct {
-
-
-struct Map {
 
     /*width, height and the number of layer of the map*/
     int w, h, nblayers;
@@ -19,8 +17,9 @@ struct Map {
 
     /*list of all the tiles*/
     short *layers[];
-};
+} Map;
-
 
+void RenderMap(Player *player, Map *map_level);
 
 #endif
+

src/mapdata.h

@@ -0,0 +1,7 @@
+#ifndef MAPDATA_H
+#define MAPDATA_H
+
+extern Map map_level0;
+
+#endif
+

src/player.c

@@ -1,27 +1,37 @@
 #include "player.h"
 #include "map.h"
+#include <gint/display.h>
 
-extern struct player;
+#define P_WIDTH 16
+#define P_HEIGHT 16
+
+extern Player MyPlayer;
 extern struct Map *map_level;
+extern bopti_image_t demo_player_img;
+
+void PlayerDraw( void )
+{
+    dimage(MyPlayer.px-P_WIDTH/2, MyPlayer.py-P_HEIGHT/2, &demo_player_img);
+}
 
 void PlayerLeft( void )
 {
-
+    MyPlayer.x--;
 }
 
 void PlayerRight( void )
 {
-
+    MyPlayer.x++;
 }
 
 void PlayerUp( void )
 {
-
+    MyPlayer.y--;
 }
 
 void PlayerDown( void )
 {
-
+    MyPlayer.y++;
 }
 
 void PlayerAction( void )

src/player.h

@@ -5,13 +5,15 @@
 
 
 /* Struct that define player parameters */
-struct Player
+typedef struct {
-{
+    unsigned short int x, y; /* The position of the player */
-    uint16_t x, y;
+    short int px, py; /* The position of the player on screen */
-    uint16_t life;    
+    unsigned short int life; /* How many lives the player still has between 0
-};
+                              * and 100. */
-
+} Player;
 
+/* This function should be called after drawing the map ! */
+void PlayerDraw( void );
 
 void PlayerLeft( void );