Gros refactoring alors que j'ai oublié de faire un git pull avant, ça va etre sympa...

10 files changed, 166 insertions, 129 deletions

diff --git a/src/gameui.c b/src/gameui.c
new file mode 100644
index 0000000..19d4530
--- /dev/null
+++ b/src/gameui.c
@@ -0,0 +1,10 @@
+#include "gameui.h"
+
+int buildRenderList(gameIni_t *gIni, gameRess_t *gRess, gameState_t *gState) {
+	return -1 //FIXME : Not yet implemented	
+}
+void disposeRenderList(gameState_t *gState) {
+
+}
+
+#endif /*GAMEUI_H*/
diff --git a/src/graphic.c b/src/graphic.c
index 3a64cfa..57f1fba 100644
--- a/src/graphic.c
+++ b/src/graphic.c
@@ -1,7 +1,7 @@
 #include "graphic.h"
 #include "utils.h"
 
-void my_SDL_init_or_die(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint32 win_flags, Uint32 rend_flags, SDL_Window **win, SDL_Renderer **rend, SDL_RendererInfo *rend_info, SDL_Rect *viewport)
+int mySDLInit(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint32 win_flags, Uint32 rend_flags, SDL_Window **win, SDL_Renderer **rend, SDL_RendererInfo *rend_info, SDL_Rect *viewport)
 {
 	int res, i;
 	Uint32 tf;
@@ -9,7 +9,7 @@ void my_SDL_init_or_die(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint3
 	res=SDL_Init(init_flags);
 	MPL_CHECK(
 			res==0,	// Expression to evaluate
-			{exit(1);} , // Code to execute if expression is not true
+			{return 1;} , // Code to execute if expression is not true
 			SDL_LOG_PRIORITY_CRITICAL, // SDL_LogPriority (_CRITICAL, _ERROR, _WARN, _INFO, DEBUG, _VERBOSE)
 			"SDL_Init failed (%i)",res // var args list starting with a fmt string like in printf()
 		 );
@@ -18,7 +18,7 @@ void my_SDL_init_or_die(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint3
 	*win=SDL_CreateWindow(title,win_pos.x,win_pos.y,win_pos.w,win_pos.h,win_flags);
 	MPL_CHECK(
 			*win, // Just put the pointer if you want to check if it's not NULL
-			{SDL_Quit(); exit(2);},
+			{SDL_Quit(); return 2;},
 			SDL_LOG_PRIORITY_CRITICAL,
 			"SDL_CreateWindow failed"
 		 );
@@ -31,7 +31,7 @@ void my_SDL_init_or_die(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint3
 	*rend=SDL_CreateRenderer(*win,-1, rend_flags);
 	MPL_CHECK(
 			*rend,
-			{SDL_DestroyWindow(*win);SDL_Quit(); exit(3);},
+			{SDL_DestroyWindow(*win);SDL_Quit(); return 3;},
 			SDL_LOG_PRIORITY_CRITICAL,
 			"SDL_CreateRenderer(...,SDL_RENDERER_ACCELERATED) failed"
 		 );
@@ -41,7 +41,7 @@ void my_SDL_init_or_die(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint3
 	res=SDL_GetRendererInfo(*rend, rend_info);
 	MPL_CHECK(
 			 res==0,
-			 {SDL_DestroyRenderer(*rend);SDL_DestroyWindow(*win);SDL_Quit(); exit(4);},
+			 {SDL_DestroyRenderer(*rend);SDL_DestroyWindow(*win);SDL_Quit(); return 4;},
 			 SDL_LOG_PRIORITY_CRITICAL,
 			 "res=SDL_GetRendererInfo() failed"
 		 );
@@ -80,11 +80,13 @@ void my_SDL_init_or_die(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint3
 
 	// Remarks : When the window is resized, the current viewport is automatically centered within the new window size.
 	SDL_RenderGetViewport(*rend, viewport);
+
+	return 0;
 }
 
 #define PIXEL32(s,x,y) (((Uint32 *)s->pixels)[y*s->w + x])
 
-int paint_terrain(gameIni_t *gIni, gameRess_t *gRess) {
+int paintTerrain(gameIni_t *gIni, gameRess_t *gRess, gameState_t *gState) {
 	int res, res2, bpp;
 	int i, modifier;
 	int x,y,xmin,xmax,ymin,ymax,y2,xdst,ydst;
@@ -102,11 +104,11 @@ int paint_terrain(gameIni_t *gIni, gameRess_t *gRess) {
 			SDL_LOG_PRIORITY_CRITICAL,
 			"paintTerrain(), SDL_PixelFormatEnumToMasks(SDL_PIXELFORMAT_ARGB8888, ...) failed"
 	);
-	gRess->terrain=SDL_CreateRGBSurface(0, LEVEL_WIDTH, LEVEL_HEIGHT, bpp, rmask, gmask, bmask, amask);
-	gRess->stencil=SDL_CreateRGBSurface(0, LEVEL_WIDTH, LEVEL_HEIGHT, bpp, rmask, gmask, bmask, amask);
+	gState->terrain=SDL_CreateRGBSurface(0, LEVEL_WIDTH, LEVEL_HEIGHT, bpp, rmask, gmask, bmask, amask);
+	gState->stencil=SDL_CreateRGBSurface(0, LEVEL_WIDTH, LEVEL_HEIGHT, bpp, rmask, gmask, bmask, amask);
 	
 	MPL_CHECK(
-		gRess->terrain && gRess->stencil,
+		gState->terrain && gState->stencil,
 		{ return 2; },
 		SDL_LOG_PRIORITY_CRITICAL,
 		"paintTerrain(), SDL_CreateRGBSurface() failed"
@@ -114,8 +116,8 @@ int paint_terrain(gameIni_t *gIni, gameRess_t *gRess) {
 
 
 	/* Fill the entire surfaces with default color */
-	res =SDL_FillRect(gRess->terrain, NULL, gIni->style.bgColor);
-	res2=SDL_FillRect(gRess->stencil, NULL, cc_nothing);
+	res =SDL_FillRect(gState->terrain, NULL, gIni->style.bgColor);
+	res2=SDL_FillRect(gState->stencil, NULL, cc_nothing);
 	MPL_CHECK(
 		res==0 && res2==0,
 		{ return 3; },
@@ -123,8 +125,6 @@ int paint_terrain(gameIni_t *gIni, gameRess_t *gRess) {
 		"paintTerrain(), SDL_FillRect() failed"
 	);
 	
-	/* SDL_LockSurface(gRess->terrain); //XXX Only if RLE encoded. To be removed ?
-	SDL_LockSurface(gRess->stencil); */
 	for(i=0 ; i < gIni->level.terrainCount ; i++) {
 		int tid=gIni->level.terrains[i].id;
 		MPL_CHECK(
@@ -164,11 +164,10 @@ int paint_terrain(gameIni_t *gIni, gameRess_t *gRess) {
 
 		// For each tile pixel, without going outside of the terrain
 		ymin=(gIni->level.terrains[i].ypos>=0)?0:-gIni->level.terrains[i].ypos;
-		ymax=SDL_min(tile->clip_rect.h, gRess->terrain->clip_rect.h - gIni->level.terrains[i].ypos);
+		ymax=SDL_min(tile->clip_rect.h, gState->terrain->clip_rect.h - gIni->level.terrains[i].ypos);
 		xmin=(gIni->level.terrains[i].xpos>=0)?0:-gIni->level.terrains[i].xpos;
-		xmax=SDL_min(tile->clip_rect.w, gRess->terrain->clip_rect.w - gIni->level.terrains[i].xpos);
+		xmax=SDL_min(tile->clip_rect.w, gState->terrain->clip_rect.w - gIni->level.terrains[i].xpos);
 
-		//SDL_LockSurface(tile);
 		for (y=ymin; y<ymax; y++) {
 			for (x=xmin; x<xmax; x++) {
 				// If we have Upside Down modifier, count lines in reverse order
@@ -186,7 +185,7 @@ int paint_terrain(gameIni_t *gIni, gameRess_t *gRess) {
 					// Always paint pixel, except in one case:
 					// If we are in NO_OVERRIDE mode and there is already a terrain on the current (source) pixel
 					if ( !( (modifier & 8) == 8 && 
-						PIXEL32(gRess->stencil, xdst, ydst) == cc_terrain ) ) {
+						PIXEL32(gState->stencil, xdst, ydst) == cc_terrain ) ) {
 						// If we have REMOVE modifier, dstPixel will be rolled back to bgColor, else, it will be identical to the source pixel. We have to update stencil consistenly.
 						if ( (modifier & 2) == 2 ) {
 							dstPixel=gIni->style.bgColor;
@@ -195,26 +194,21 @@ int paint_terrain(gameIni_t *gIni, gameRess_t *gRess) {
 							dstPixel=srcPixel;
 							dstStencil=cc_terrain;
 						}
-						PIXEL32(gRess->terrain,xdst,ydst)=dstPixel;
-						PIXEL32(gRess->stencil,xdst,ydst)=dstStencil;
+						PIXEL32(gState->terrain,xdst,ydst)=dstPixel;
+						PIXEL32(gState->stencil,xdst,ydst)=dstStencil;
 					}
 				}
 			}
 		}
-		SDL_UnlockSurface(tile);
 	}
-/*
-	SDL_UnlockSurface(gRess->stencil);
-	SDL_UnlockSurface(gRess->terrain);
-*/
 	return 0;
 }
 
-int render_terrain(SDL_Renderer *rend, SDL_Surface *terrain, int xPos) {
+int renderTerrain(SDL_Renderer *rend, gameState_t *gState) {
 	int res;
 	SDL_Rect src_rect, dst_rect;
 	SDL_Surface *tmp_surf;
-	SDL_PixelFormat *pf = terrain->format;
+	SDL_PixelFormat *pf = gState->terrain->format;
 	SDL_Texture * tmp_tex;
 
 	tmp_surf = SDL_CreateRGBSurface(0,MPL_WIN_W, LEVEL_HEIGHT, 
@@ -227,7 +221,7 @@ int render_terrain(SDL_Renderer *rend, SDL_Surface *terrain, int xPos) {
 			"Can't SDL_CreateRGBSurface() for converting terrain"
 	);
 
-	src_rect.x=xPos;
+	src_rect.x=gState->cameraX;
 	src_rect.y=0;
 	src_rect.w=MPL_WIN_W;
 	src_rect.h=LEVEL_HEIGHT;
@@ -235,7 +229,7 @@ int render_terrain(SDL_Renderer *rend, SDL_Surface *terrain, int xPos) {
 	dst_rect=src_rect;
 	dst_rect.x=0;
 
-	res = SDL_BlitSurface(terrain, &src_rect, tmp_surf, &dst_rect);
+	res = SDL_BlitSurface(gState->terrain, &src_rect, tmp_surf, &dst_rect);
 	MPL_CHECK(
 			res==0,
 			{ SDL_FreeSurface(tmp_surf); return 2; },
@@ -265,16 +259,17 @@ int render_terrain(SDL_Renderer *rend, SDL_Surface *terrain, int xPos) {
 	return 0;
 }
 
-int render_sprites(SDL_Renderer *rend, render_item_t render_list[], int list_size) {
+int renderSprites(SDL_Renderer *rend, gameState_t *gState) {
 	int i, res;
 	SDL_Rect src,dst;
-
-	for(i=0,res=0;i<list_size && res==0;i++) {
-		src = dst = render_list[i].sprite->size;
-		src.y = src.h * render_list[i].currframe;
-		dst.x = render_list[i].x;
-		dst.y = render_list[i].y;
-		res=SDL_RenderCopy(rend, render_list[i].sprite->t, &src, &dst);
+	renderItem_t *renderList = gState->renderList;
+
+	for(i=0,res=0 ; i < gState->renderListSize && res==0 ; i++) {
+		src = dst = renderList[i].sprite->size;
+		src.y = src.h * renderList[i].currframe;
+		dst.x = renderList[i].x;
+		dst.y = renderList[i].y;
+		res=SDL_RenderCopy(rend, renderList[i].sprite->t, &src, &dst);
 	}
 	return res;
 }
diff --git a/src/include/data_game.h b/src/include/data_game.h
new file mode 100644
index 0000000..d9bd68e
--- /dev/null
+++ b/src/include/data_game.h
@@ -0,0 +1,38 @@
+#ifndef DATA_GAME_H
+#define DATA_GAME_H
+
+#include <SDL.h>
+
+#define MAX_RENDERLIST_SIZE 256
+
+typedef struct {
+	sprite_t *sprite;
+	int currframe;
+	int animate; /* Is currently animating ? */
+	int x,y; /* Level-based coords, not camera-based */
+} renderItem_t;
+
+typedef struct {
+		/* Game frame counter */
+		int tick;
+		/* Current camera position */
+		int cameraX;
+
+		/* terrain & stencil
+			generated by paint_terrain()
+			update by ???()  */
+		SDL_Surface *terrain, *stencil;
+
+		/* streamTerrain : viewable portion of terrain, in texture format
+					updated by render_terrain() */
+		SDL_Texture *terrainStream;
+
+		/* Render list of all in-game sprites (for batch processing)
+			Items are in paint order
+			created by buildRenderList() */
+		int renderListSize;
+		renderItem_t renderList[MAX_RENDERLIST_SIZE];
+} gameState_t;
+
+#endif /*DATA_GAME_H*/
+
diff --git a/src/include/data_ress.h b/src/include/data_ress.h
index 09f1754..4f0ac6b 100644
--- a/src/include/data_ress.h
+++ b/src/include/data_ress.h
@@ -15,18 +15,16 @@ typedef struct {
 		/* Style */
 		SDL_Surface *tiles[MAX_TILES_COUNT];
 		sprite_t objects[MAX_OBJECTS_COUNT];
-		sprite_t objectMasks[MAX_OBJECTS_COUNT];
+		SDL_Surface *objectMasks[MAX_OBJECTS_COUNT];
 		/* Misc */
 		sprite_t lemmingAnims[MAX_LEMMANIM_COUNT];
-		sprite_t lemmingMasks[MAX_LEMMANIM_COUNT];
-		sprite_t lemmingIMasks[MAX_LEMMANIM_COUNT];
+		SDL_Surface *lemmingMasks[MAX_LEMMANIM_COUNT];
+		SDL_Surface *lemmingIMasks[MAX_LEMMANIM_COUNT];
 		sprite_t font1, font2, countdown, cursor;
 		/* Music */
 		Mix_Music *musics[MAX_MUSICS_COUNT];
 		/* Sound */
 		Mix_Chunk *sounds[MAX_SOUNDS_COUNT];
-		/* terrain & stencil : generated by paint_terrain() */
-		SDL_Surface *terrain, *stencil;
 } gameRess_t;
 
-#endif /*DATA_RESS_H*/
+#endif /*DATA_RES_H*/
diff --git a/src/include/gameui.h b/src/include/gameui.h
new file mode 100644
index 0000000..c9f607e
--- /dev/null
+++ b/src/include/gameui.h
@@ -0,0 +1,13 @@
+#ifndef GAMEUI_H
+#define GAMEUI_H
+#include <SDL.h>
+
+#include "data_ini.h"
+#include "data_ress.h"
+#include "data_game.h"
+
+/* Create list of all in-game sprite to render (for batch processing) */
+int buildRenderList(gameIni_t *gIni, gameRess_t *gRess, gameState_t *gState);
+void disposeRenderList(gameState_t *gState);
+
+#endif /*GAMEUI_H*/
diff --git a/src/include/graphic.h b/src/include/graphic.h
index 9876034..92be5a9 100644
--- a/src/include/graphic.h
+++ b/src/include/graphic.h
@@ -7,19 +7,14 @@
 
 #include "data_ini.h"
 #include "data_ress.h"
+#include "data_game.h"
 
-typedef struct {
-	sprite_t *sprite;
-	int currframe;
-	int animate; /* Is currently animating ? */
-	int x,y; /* Level-based coords, not camera-based */
-} render_item_t;
 
-void my_SDL_init_or_die(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint32 win_flags, Uint32 rend_flags, SDL_Window **win, SDL_Renderer **rend, SDL_RendererInfo *rend_info, SDL_Rect *viewport);
+int mySDLInit(char title[], SDL_Rect win_pos, Uint32 init_flags, Uint32 win_flags, Uint32 rend_flags, SDL_Window **win, SDL_Renderer **rend, SDL_RendererInfo *rend_info, SDL_Rect *viewport);
 
-int paint_terrain(gameIni_t *gIni, gameRess_t *gRess);
+int paintTerrain(gameIni_t *gIni, gameRess_t *gRess, gameState_t *gState);
 
-int render_sprites(SDL_Renderer *rend, render_item_t render_list[], int list_size);
-int render_terrain(SDL_Renderer *rend, SDL_Surface *terrain, int xPos);
+int renderTerrain(SDL_Renderer *rend, gameState_t *gState);
+int renderSprites(SDL_Renderer *rend, gameState_t *gState);
 
 #endif /*GRAPHIC_H*/
diff --git a/src/include/loader.h b/src/include/loader.h
index 8759eb6..febd48e 100644
--- a/src/include/loader.h
+++ b/src/include/loader.h
@@ -5,10 +5,11 @@
 #include "data_ini.h"
 #include "data_ress.h"
 
-// Load all textures needed for style from gIni
+/* Load all textures needed for style from gIni */
 int loadStyleRes(SDL_Renderer *rend, gameIni_t *gIni, char data_basepath[], gameRess_t *gRess);
 void unloadStyleRes(gameRess_t *gRess);
-// Load all misc textures (lemmings, fonts, cursor...)
+
+/* Load all misc textures (lemmings, fonts, cursor...) */
 int loadMiscRes(SDL_Renderer *rend, char data_basepath[], gameRess_t *gRess);
 void unloadMiscRes(gameRess_t *gRess);
 
diff --git a/src/include/utils.h b/src/include/utils.h
index 11fdeee..f626b50 100644
--- a/src/include/utils.h
+++ b/src/include/utils.h
@@ -17,3 +17,7 @@ if (t != NULL) { \
 	t=NULL; \
 }
 
+#define DESTROYSURFACE_SAFE(s) \
+	SDL_FreeSurface(s); \
+	s=NULL;
+
diff --git a/src/loader.c b/src/loader.c
index ec34e79..f780ae9 100644
--- a/src/loader.c
+++ b/src/loader.c
@@ -25,7 +25,7 @@ int loadStyleRes(SDL_Renderer *rend, gameIni_t *gIni, char data_basepath[], game
 		/* Some object types needs a mask */
 		if ( gIni->style.type[i] >= 5 && gIni->style.type[i] <= 8 ) {
 			(void) SDL_snprintf(filepath, MAX_PATH_LEN, "%s/style/%s/%som_%d.gif", data_basepath, stylename, stylename, i);
-			res=loadSprite(rend,filepath,1,&gRess->objectMasks[i]);
+			res=loadSurface(rend,filepath,&gRess->objectMasks[i]);
 			if (res != 0) return res;
 		}
 	}
@@ -38,12 +38,11 @@ void unloadStyleRes(gameRess_t *gRess) {
 	
 	/* Nullpointer checked for surface but not for textures in SDL code */
 	for(i=0; i<MAX_TILES_COUNT;i++) {
-		SDL_FreeSurface(gRess->tiles[i]);
-		gRess->tiles[i] = NULL;
+		DESTROYSURFACE_SAFE(gRess->tiles[i]);
 	}
 	for(i=0; i<MAX_OBJECTS_COUNT;i++) {
 		DESTROYTEXTURE_SAFE(gRess->objects[i].t);
-		DESTROYTEXTURE_SAFE(gRess->objectMasks[i].t);
+		DESTROYSURFACE_SAFE(gRess->objectMasks[i]);
 	}
 }
 
@@ -65,14 +64,14 @@ int loadMiscRes(SDL_Renderer *rend, char data_basepath[], gameRess_t *gRess) {
 	for(ii=0; ii<6; ii++) {
 		i=lemmanim_hasmask[ii];
 		(void) SDL_snprintf(filepath, MAX_PATH_LEN, "%s/misc/mask_%d.gif", data_basepath, i);
-		res=loadSprite(rend,filepath,1,&gRess->lemmingMasks[i]);
+		res=loadSurface(rend,filepath,&gRess->lemmingMasks[i]);
 		if (res != 0) return res;
 	}
 
 	for(ii=0; ii<3; ii++) {
 		i=lemmanim_hasimask[ii];
 		(void) SDL_snprintf(filepath, MAX_PATH_LEN, "%s/misc/imask_%d.gif", data_basepath, i);
-		res=loadSprite(rend,filepath,1,&gRess->lemmingIMasks[i]);
+		res=loadSurface(rend,filepath,&gRess->lemmingIMasks[i]);
 		if (res != 0) return res;
 	}
 
@@ -99,8 +98,8 @@ void unloadMiscRes(gameRess_t *gRess) {
 	int i;
 	for(i=0; i<MAX_LEMMANIM_COUNT; i++) {
 		DESTROYTEXTURE_SAFE(gRess->lemmingAnims[i].t);
-		DESTROYTEXTURE_SAFE(gRess->lemmingMasks[i].t);
-		DESTROYTEXTURE_SAFE(gRess->lemmingIMasks[i].t);
+		DESTROYSURFACE_SAFE(gRess->lemmingMasks[i]);
+		DESTROYSURFACE_SAFE(gRess->lemmingIMasks[i]);
 	}
 	DESTROYTEXTURE_SAFE(gRess->cursor.t);
 	DESTROYTEXTURE_SAFE(gRess->countdown.t);
diff --git a/src/test/testrender.c b/src/test/testrender.c
index 6493507..634f16d 100644
--- a/src/test/testrender.c
+++ b/src/test/testrender.c
@@ -1,19 +1,22 @@
+#include "gameui.h"
 #include "graphic.h"
-#include "parser.h"
 #include "loader.h"
+#include "parser.h"
 #include "utils.h"
 
 #define DATA_BASEPATH "./data"
 #define MAX_RENDERLIST_LEN 256
 
-int buildTestRL(gameRess_t *gRess, int rlMaxLen, render_item_t render_list[]);
+int buildTestRL(gameRess_t *gRess, int rlMaxLen, renderItem_t renderList[]);
 
 int main(int argc, char **argv) {
 	int res;
 	char filepath[MAX_PATH_LEN];
 	gameIni_t gIni;
 	gameRess_t gRess;
-	render_item_t render_list[MAX_RENDERLIST_LEN];
+	gameState_t gState;
+
+	//renderItem_t renderList[MAX_RENDERLIST_LEN];
 
 	if (argc != 3) {
 		fprintf(stderr, "Usage %s <levelpack_name> <level_ini_name>\n", argv[0]);
@@ -22,6 +25,8 @@ int main(int argc, char **argv) {
 
 	// Setting default values
 	SDL_memset(&gIni,0,sizeof(gameIni_t));
+	SDL_memset(&gRess,0,sizeof(gameRess_t));
+	SDL_memset(&gState,0,sizeof(gameState_t));
 
 	// Loading levelpack.ini
 	SDL_snprintf(filepath, MAX_PATH_LEN, "%s/level/%s/levelpack.ini", DATA_BASEPATH, argv[1]);
@@ -35,7 +40,7 @@ int main(int argc, char **argv) {
 
 	// Check if we found a "style =" line in level ini file
 	MPL_CHECK(
-			gIni.level.style,
+			gIni.level.style[0] != '\0',
 			{ exit(1); },
 			SDL_LOG_PRIORITY_CRITICAL,
 			"No valid style detected in level ini file"
@@ -52,70 +57,70 @@ int main(int argc, char **argv) {
 	if (res!=0) exit(res);
 	*/
 
-	SDL_Window *sdl_win;
-	SDL_Renderer *sdl_rend;
-	SDL_RendererInfo sdl_rend_info;
-	SDL_Rect sdl_viewport;
-
-	SDL_Event sdl_ev;
-	int rlLen, mainloop_end, tick;
+	SDL_Window *win;
+	SDL_Renderer *rend;
+	SDL_RendererInfo rendInfo;
+	SDL_Rect viewport;
 
-	SDL_Rect win_pos = { .x=SDL_WINDOWPOS_UNDEFINED, .y=SDL_WINDOWPOS_UNDEFINED, .w=MPL_WIN_W, .h=MPL_WIN_H };
-	Uint32 init_flags = SDL_INIT_TIMER|SDL_INIT_VIDEO;
-	Uint32 win_flags = SDL_WINDOW_SHOWN;
-	Uint32 rend_flags = SDL_RENDERER_ACCELERATED; // | SDL_RENDERER_PRESENTVSYNC;
+	SDL_Event uiEvent;
+	int mainLoopEnd;
 
-	my_SDL_init_or_die(__FILE__, win_pos, init_flags, win_flags, rend_flags, &sdl_win, &sdl_rend, &sdl_rend_info, &sdl_viewport);
+	SDL_Rect winPos = { .x=SDL_WINDOWPOS_UNDEFINED, .y=SDL_WINDOWPOS_UNDEFINED, .w=MPL_WIN_W, .h=MPL_WIN_H };
+	Uint32 initFlags = SDL_INIT_TIMER|SDL_INIT_VIDEO;
+	Uint32 winFlags = SDL_WINDOW_SHOWN;
+	Uint32 rendFlags = SDL_RENDERER_ACCELERATED; // | SDL_RENDERER_PRESENTVSYNC;
 
-	// Setting default values
-	SDL_memset(&gRess,0,sizeof(gameRess_t));
+	res=mySDLInit(__FILE__, winPos, initFlags, winFlags, rendFlags, &win, &rend, &rendInfo, &viewport);
+	if (res!=0) exit(res);
 
-	res=loadMiscRes(sdl_rend, DATA_BASEPATH, &gRess);
+	res=loadMiscRes(rend, DATA_BASEPATH, &gRess);
 	if (res!=0) exit(res);
-	res=loadStyleRes(sdl_rend, &gIni, DATA_BASEPATH, &gRess);
+	res=loadStyleRes(rend, &gIni, DATA_BASEPATH, &gRess);
 	if (res!=0) exit(res);
 
-	res=paint_terrain(&gIni, &gRess);
+	res=paintTerrain(&gIni, &gRess, &gState);
 	if (res!=0) exit(res);
 
-	rlLen=buildTestRL(&gRess, MAX_RENDERLIST_LEN, render_list);
+	gState.renderListSize=buildTestRL(&gRess, MAX_RENDERLIST_LEN, gState.renderList);
+
+	gState.cameraX = gIni.level.xPos;
 
 	/* Main render loop */
-	mainloop_end = tick = 0;
-	while (!mainloop_end && tick<16) {
+	mainLoopEnd = 0;
+	while (!mainLoopEnd) {
 		int i;
 
 		/* Check for events */
-		while (SDL_PollEvent(&sdl_ev)) {
-			if (sdl_ev.type == SDL_QUIT) {
-				mainloop_end = 1;
+		while (SDL_PollEvent(&uiEvent)) {
+			if (uiEvent.type == SDL_QUIT) {
+				mainLoopEnd = 1;
 			}
 		}
-		SDL_RenderClear(sdl_rend);
-		(void) render_terrain(sdl_rend, gRess.terrain, gIni.level.xPos);
-		(void) render_sprites(sdl_rend, render_list, rlLen);
-		SDL_RenderPresent(sdl_rend);
+		SDL_RenderClear(rend);
+		(void) renderTerrain(rend, &gState);
+		(void) renderSprites(rend, &gState);
+		SDL_RenderPresent(rend);
 
-		for (i=0;i<rlLen;i++) {
-			render_item_t *it = &render_list[i];
+		for (i=0;i<gState.renderListSize;i++) {
+			renderItem_t *it = &gState.renderList[i];
 			if (it->animate==1) {
 				it->currframe = (it->currframe + 1) % it->sprite->frames;
 			}
 		}
 		SDL_Delay(100);
-//		tick++;
 	}
+	disposeRenderList(&gState);
 	unloadStyleRes(&gRess);
 	unloadMiscRes(&gRess);
 
-	SDL_DestroyRenderer(sdl_rend);
-	SDL_DestroyWindow(sdl_win);
+	SDL_DestroyRenderer(rend);
+	SDL_DestroyWindow(win);
 	SDL_Quit(); 
 
 	return 0;
 }
 
-int addRLitem(render_item_t list[], sprite_t *it, int rlMaxLen) {
+int addRLitem(renderItem_t list[], sprite_t *it, int rlMaxLen) {
 	static int cur=0, curr_x=0, curr_y=0, tmp_h=0;
 
 	if (it == NULL) {
@@ -146,45 +151,24 @@ int addRLitem(render_item_t list[], sprite_t *it, int rlMaxLen) {
 	return cur;
 }
 
-int buildTestRL(gameRess_t *gRess, int rlMaxLen, render_item_t render_list[]) {
+int buildTestRL(gameRess_t *gRess, int rlMaxLen, renderItem_t renderList[]) {
 	int i, rlLen;
 
 	for (i=0; i<MAX_LEMMANIM_COUNT; i++) {
-		rlLen=addRLitem(render_list, &gRess->lemmingAnims[i], rlMaxLen);
-	}
-	rlLen=addRLitem(render_list, NULL, rlMaxLen);
-
-	for (i=0; i<MAX_LEMMANIM_COUNT; i++) {
-		rlLen=addRLitem(render_list, &gRess->lemmingMasks[i], rlMaxLen);
-	}
-	rlLen=addRLitem(render_list, NULL, rlMaxLen);
-
-	for (i=0; i<MAX_LEMMANIM_COUNT; i++) {
-		rlLen=addRLitem(render_list, &gRess->lemmingIMasks[i], rlMaxLen);
+		rlLen=addRLitem(renderList, &gRess->lemmingAnims[i], rlMaxLen);
 	}
-	rlLen=addRLitem(render_list, NULL, rlMaxLen);
+	rlLen=addRLitem(renderList, NULL, rlMaxLen);
 
 	for (i=0; i<MAX_OBJECTS_COUNT; i++) {
-		rlLen=addRLitem(render_list, &gRess->objects[i], rlMaxLen);
+		rlLen=addRLitem(renderList, &gRess->objects[i], rlMaxLen);
 	}
-	rlLen=addRLitem(render_list, NULL, rlMaxLen);
+	rlLen=addRLitem(renderList, NULL, rlMaxLen);
 
-	for (i=0; i<MAX_OBJECTS_COUNT; i++) {
-		rlLen=addRLitem(render_list, &gRess->objectMasks[i], rlMaxLen);
-	}
-	rlLen=addRLitem(render_list, NULL, rlMaxLen);
-
-	rlLen=addRLitem(render_list, &gRess->font1, rlMaxLen);
-	rlLen=addRLitem(render_list, &gRess->font2, rlMaxLen);
-	rlLen=addRLitem(render_list, &gRess->countdown, rlMaxLen);
-	rlLen=addRLitem(render_list, &gRess->cursor, rlMaxLen);
+	rlLen=addRLitem(renderList, &gRess->font1, rlMaxLen);
+	rlLen=addRLitem(renderList, &gRess->font2, rlMaxLen);
+	rlLen=addRLitem(renderList, &gRess->countdown, rlMaxLen);
+	rlLen=addRLitem(renderList, &gRess->cursor, rlMaxLen);
 
-	/* No more textues but surface (for custom one time blitting)
-	for (i=0; i<MAX_TILES_COUNT; i++) {
-		rlLen=addRLitem(render_list, &gRess->tiles[i], rlMaxLen);
-	}
-	rlLen=addRLitem(render_list, NULL, rlMaxLen);
-	*/
 	return rlLen;
 }