Added a out of memory state to avoid System Errors

draw_states.c

@@ -202,6 +202,15 @@ void draw_game_over(Game_Data *data)
 	drawBottomRightCornerText("Shift to retry", data->are_colors_reversed);
 }
 
+void draw_oom(Game_Data* data) {
+	fillBackground(data);
+	drawPolygon(data, data->nb_lines, data->line_transition);
+	drawDiagonals(data, data->nb_lines, data->line_transition);
+	drawTopRightCornerText("Oops! Out of Memory", data->are_colors_reversed);
+	drawTopRightCornerTextOffset("Your progress will be saved.", data->are_colors_reversed, 8);
+	drawBottomLeftCornerText("Press EXIT to quit.", data->are_colors_reversed);
+}
+
 static void fillBackground(Game_Data *data) {
 	if(data->are_colors_reversed) {
 		int i, end, *pointer_long, vram;
@@ -441,10 +450,12 @@ static unsigned int length_of_print_string(unsigned char* txt) {
 
 			case '[':
 			case ']':
-			case '.':
+			/*case '.':*/
+			case '\'':
 			current_char_length = 3;
 			break;
 
+
 			default:
 			current_char_length = 4;
 			break;

hexagon.c

@@ -7,6 +7,34 @@
 #include "syscall.h"
 #include "states.h"
 
+void load_difficulty_names(char **str_list)
+{
+    char c_1[] = "Hard";
+    char c_2[] = "Harder";
+    char c_3[] = "Hardest";
+    char c_4[] = "Hardester";
+    char c_5[] = "Hardestest";
+    char c_6[] = "Hardestestest";
+    int i = 0;
+    int j = 0;
+    for(i = 0; i < 6; i++)
+    {
+        str_list[i] = NULL;
+        str_list[i] = malloc(sizeof(char) * 24);
+        if(str_list[i] == NULL)
+            return;
+        for(j = 0; j < 24; str_list[i][j] = 0, j++) {
+
+        }
+    }
+    memcpy(str_list[0], c_1, sizeof(char) * strlen(c_1));
+    memcpy(str_list[1], c_2, sizeof(char) * strlen(c_2));
+    memcpy(str_list[2], c_3, sizeof(char) * strlen(c_3));
+    memcpy(str_list[3], c_4, sizeof(char) * strlen(c_4));
+    memcpy(str_list[4], c_5, sizeof(char) * strlen(c_5));
+    memcpy(str_list[5], c_6, sizeof(char) * strlen(c_6));
+}
+
 int AddIn_main(int isAppli, unsigned short OptionNum)
 {
     const FONTCHARACTER filename[] = {'\\', '\\', 'f', 'l', 's', '0', '\\', 'S', 'H', 'C', '.', 's', 'a', 'v', 0};
@@ -28,13 +56,12 @@ int AddIn_main(int isAppli, unsigned short OptionNum)
     data.entry_highscores = NULL;
     data.entry_highscores = malloc(sizeof(float) * 6);
     if(data.entry_highscores == NULL)
-        return 1;
+        switch_to_state(OUT_OF_MEMORY, &data);
 
 
     data.is_save_feature_enabled = 1;
     data.fileHandle = Bfile_OpenFile(filename, _OPENMODE_READ);
     if(data.fileHandle == IML_FILEERR_ENTRYNOTFOUND) {
-        void;
     } else if(data.fileHandle>= 0) {
         if(Bfile_ReadFile(data.fileHandle, (char*)data.entry_highscores, filesize, -1) < 0)
             data.is_save_feature_enabled = 0;
@@ -86,12 +113,7 @@ int AddIn_main(int isAppli, unsigned short OptionNum)
     if(data.is_save_feature_enabled) {
         Bfile_CreateFile(filename, filesize);
         data.fileHandle = Bfile_OpenFile(filename, _OPENMODE_WRITE);
-        if(Bfile_WriteFile(data.fileHandle, (char*)data.entry_highscores, filesize) < 0) {
-            int why;
-            locate(1,1);
-            Print("POURQUOI");
-            GetKey(&why);
-        }
+        Bfile_WriteFile(data.fileHandle, (char*)data.entry_highscores, filesize);
         Bfile_CloseFile(data.fileHandle);
    }
 

init_states.c

@@ -129,10 +129,11 @@ const unsigned char patternTest7[] = {
 void init_game(Game_Data *data)
 {
 //TODO: init the level depending on the value of data->current_entry
+	int i;
 	data->level = NULL;
 	data->level = malloc(sizeof(Level));
 	if(data->level == NULL) {
-		switch_to_state(data, TITLE);
+		switch_to_state(data, OUT_OF_MEMORY);
 		return;
 	}
 
@@ -141,7 +142,7 @@ void init_game(Game_Data *data)
 	data->level->patterns = malloc(7*sizeof(Pattern));
 	if(data->level->patterns == NULL) {
 		free(data->level);
-		switch_to_state(data, TITLE);
+		switch_to_state(data, OUT_OF_MEMORY);
 		return;
 	}
 	readPattern(&data->level->patterns[0], patternTest1);
@@ -152,6 +153,17 @@ void init_game(Game_Data *data)
 	readPattern(&data->level->patterns[5], patternTest6);
 	readPattern(&data->level->patterns[6], patternTest7);
 	data->level->nb_patterns = 7;
+	for(i = 0; i < data->level->nb_patterns; ++i) {
+		if(&data->level->patterns[i] == NULL) {
+			int j;
+			for(j = 0; j < i; ++j) {
+				free(&data->level->patterns[j]);
+			}
+			free(&data->level);
+			switch_to_state(data, OUT_OF_MEMORY);
+			return;
+		}
+	}
 
 	data->level->player_rotation_speed = 60;
 
@@ -211,32 +223,6 @@ void init_title(Game_Data *data)
 	data->line_transition.delta_nb_lines = 0;
 }
 
-void load_difficulty_names(char **str_list)
-{
-	char c_1[] = "Hard";
-	char c_2[] = "Harder";
-	char c_3[] = "Hardest";
-	char c_4[] = "Hardester";
-	char c_5[] = "Hardestest";
-	char c_6[] = "Hardestestest";
-	int i = 0;
-	int j = 0;
-	for(i = 0; i < 6; i++)
-	{
-		str_list[i] = NULL;
-		str_list[i] = malloc(sizeof(char) * 24);
-		if(str_list[i] == NULL)
-			return;
-		for(j = 0; j < 24; str_list[i][j] = 0, j++);
-	}
-memcpy(str_list[0], c_1, sizeof(char) * strlen(c_1));
-memcpy(str_list[1], c_2, sizeof(char) * strlen(c_2));
-memcpy(str_list[2], c_3, sizeof(char) * strlen(c_3));
-memcpy(str_list[3], c_4, sizeof(char) * strlen(c_4));
-memcpy(str_list[4], c_5, sizeof(char) * strlen(c_5));
-memcpy(str_list[5], c_6, sizeof(char) * strlen(c_6));
-}
-
 void init_menu(Game_Data *data)
 {
 	int i;
@@ -275,3 +261,21 @@ void init_game_over(Game_Data *data)
 		data->entry_highscores[data->current_entry - 1] = data->chrono_time;
 	}
 }
+
+void init_oom(Game_Data *data) {
+	data->cam.cX = 0;
+	data->cam.cY = 0;
+	data->cam.speed = -1;
+	data->cam.zoom = 25;
+
+	data->nb_lines = 6;
+	data->line_transition.counter = 0;
+	data->line_transition.counter_start = 0;
+	data->line_transition.delta_nb_lines = 0;
+
+	if(data->chrono_time > data->entry_highscores[data->current_entry - 1]) {
+		data->it_s_a_highscore = 1;
+		data->entry_highscores[data->current_entry - 1] = data->chrono_time;
+	}
+
+}

states.c

@@ -11,16 +11,19 @@ void switch_to_state(State new_state, Game_Data *data)
 	switch (new_state)
 	{
 		case GAME:
-			init_game(data);
+		init_game(data);
 		break;
 		case TITLE:
-			init_title(data);
+		init_title(data);
 		break;
 		case MENU:
-			init_menu(data);
+		init_menu(data);
 		break;
 		case GAME_OVER:
-			init_game_over(data);
+		init_game_over(data);
+		break;
+		case OUT_OF_MEMORY:
+		init_oom(data);
 		break;
 	}
 	current_state = new_state;
@@ -30,16 +33,19 @@ void update(Game_Data *data)
 	switch(current_state)
 	{
 		case GAME:
-			update_game(data);
+		update_game(data);
 		break;
 		case TITLE:
-			update_title(data);
+		update_title(data);
 		break;
 		case MENU:
-			update_menu(data);
+		update_menu(data);
 		break;
 		case GAME_OVER:
-			update_game_over(data);
+		update_game_over(data);
+		break;
+		case OUT_OF_MEMORY:
+		update_oom(data);
 		break;
 	}
 	key_latch_update(data);
@@ -49,16 +55,19 @@ void draw(Game_Data *data)
 	switch(current_state)
 	{
 		case GAME:
-			draw_game(data);
+		draw_game(data);
 		break;
 		case TITLE:
-			draw_title(data);
+		draw_title(data);
 		break;
 		case MENU:
-			draw_menu(data);
+		draw_menu(data);
 		break;
 		case GAME_OVER:
-			draw_game_over(data);
+		draw_game_over(data);
+		break;
+		case OUT_OF_MEMORY:
+		draw_oom(data);
 		break;
 	}
 }

struct.h

@@ -23,7 +23,7 @@ typedef struct Level Level;
 typedef struct Line_Transition Line_Transition;
 typedef struct Game_Data Game_Data;
 typedef struct Pattern Pattern;
-typedef enum {GAME, MENU, TITLE, GAME_OVER} State;
+typedef enum {GAME, MENU, TITLE, GAME_OVER, OUT_OF_MEMORY} State;
 
 struct Level{
 

update_states.c

@@ -146,6 +146,12 @@ void update_menu(Game_Data *data)
 
 }
 
+void update_oom(Game_Data *data) {
+	data->last_time = data->current_time;
+	data->current_time = RTC_GetTicks();
+	updateCamera(&(data->cam), data->current_time - data->last_time);
+}
+
 void updateCamera(Camera *cam, unsigned int delta_time){
 	cam->angle += (int)(cam->speed * delta_time / 2.);
 	if(cam->angle < 0) cam->angle += 360;
@@ -171,4 +177,5 @@ static void game_over(Game_Data *data) {
 	data->level = NULL;
 
 	switch_to_state(GAME_OVER, data);
-}
+}
+