Better highscore system. Side collisions make the game crash for unknown reasons.

MonochromeLib.h

@@ -28,7 +28,7 @@
 //#define ML_GET_CONTRAST
 
 #define ML_PIXEL
-//#define ML_POINT
+#define ML_POINT
 //#define ML_PIXEL_TEST
 
 #define ML_LINE

draw_states.c

@@ -16,7 +16,9 @@ static void drawChrono(Game_Data *data);
 static int getLevel(Game_Data *data);
 
 static unsigned int length_of_print_string(unsigned char* txt);
+static void drawTopLeftCornerTextOffset(unsigned char* txt, unsigned char isReversed, int y);
 static void drawTopLeftCornerText(unsigned char* txt, unsigned char isReversed);
+static void drawTopRightCornerTextOffset(unsigned char* txt, unsigned char isReversed, int y);
 static void drawTopRightCornerText(unsigned char* txt, unsigned char isReversed);
 static void drawBottomLeftCornerText(unsigned char* txt, unsigned char isReversed);
 static void drawBottomRightCornerText(unsigned char* txt, unsigned char isReversed);
@@ -120,18 +122,26 @@ void draw_title(Game_Data *data)
 
 	drawPolygon(data, data->nb_lines, data->line_transition);
 	drawDiagonals(data, data->nb_lines, data->line_transition);
-	drawBottomLeftCornerText("Press Shift", data->are_colors_reversed);	
-	drawTopRightCornerText("By Eiyeron & Adbook", data->are_colors_reversed);	
+	drawBottomLeftCornerText("Press Shift", data->are_colors_reversed);
+	drawTopRightCornerText("By Eiyeron & Adbook", data->are_colors_reversed);
 }
 void draw_menu(Game_Data *data)
 {
+	char highscore_text[50] = {0};
+	sprintf(highscore_text, "Best time : %.2f", data->entry_highscores[data->current_entry - 1]);
 	fillBackground(data);
 	drawPolygon(data, data->nb_lines, data->line_transition);
 	drawDiagonals(data, data->nb_lines, data->line_transition);
+	drawPlayer(data, (360 - data->cam.angle + 270)%360);
 	drawTopRightCornerText(data->entry_difficulties[data->current_entry - 1], data->are_colors_reversed);
 	if(data->current_entry > 3) {
 		// Hyper Mode
-		drawBottomRightCornerText("Hyper Mode", data->are_colors_reversed);
+		drawTopLeftCornerText("Hyper Mode", data->are_colors_reversed);
+		drawTopLeftCornerTextOffset(highscore_text, data->are_colors_reversed, 8);
+		drawTopLeftCornerTextOffset(step_text[getLevel(data)], data->are_colors_reversed, 16);
+	} else {
+		drawTopRightCornerTextOffset(highscore_text, data->are_colors_reversed, 8);
+		drawTopRightCornerTextOffset(step_text[getLevel(data)], data->are_colors_reversed, 16);
 	}
 }
 void draw_game_over(Game_Data *data)
@@ -184,6 +194,9 @@ void draw_game_over(Game_Data *data)
 	draw_big_num(level_text, level_num_x_position, level_y_position, !data->are_colors_reversed);
 	draw_big_num(int_time_text, x_offset, time_y_position, !data->are_colors_reversed);
 	drawTopLeftCornerText(step_text[getLevel(data)], data->are_colors_reversed);
+	if(data->it_s_a_highscore) {
+		drawTopRightCornerText("New highscore!", data->are_colors_reversed);
+	}
 
 
 	drawBottomRightCornerText("Shift to retry", data->are_colors_reversed);
@@ -226,7 +239,7 @@ static void drawChrono(Game_Data *data) {
 		if(!data->are_colors_reversed) {
 			ML_bmp_8_or(hex_border_top_left, length_of_time_line, 0);
 		} else {
-			ML_bmp_8_and(hex_border_top_left_rev, length_of_time_line, 0);			
+			ML_bmp_8_and(hex_border_top_left_rev, length_of_time_line, 0);
 		}
 	}
 	else {
@@ -323,7 +336,7 @@ static void drawPlayer(Game_Data *data, int player_angle)
 {
 	ML_Color drawing_color = data->are_colors_reversed ? WHITE : BLACK;
 
-	ML_filled_circle((9. + data->cam.zoom)*cos( PI*(player_angle + data->cam.angle)/180) + data->cam.cX, (9. + data->cam.zoom)*sin( PI*(player_angle+data->cam.angle)/180) + data->cam.cY, 1, drawing_color);
+	ML_point((9. + data->cam.zoom)*cos( PI*(player_angle + data->cam.angle)/180) + data->cam.cX, (9. + data->cam.zoom)*sin( PI*(player_angle+data->cam.angle)/180) + data->cam.cY, 3, drawing_color);
 
 }
 
@@ -339,7 +352,7 @@ static void drawDiagonals(Game_Data *data, int nb_lines, Line_Transition line_tr
 
 	fix coeff = 0;
 	fix transition_angle = 0;
-	
+
 	ML_Color drawing_color = data->are_colors_reversed ? WHITE : BLACK;
 
 	delta_angle = fdiv(FIX(360), FIX(nb_lines));
@@ -418,12 +431,17 @@ static unsigned int length_of_print_string(unsigned char* txt) {
 			current_char_length = 6;
 			break;
 
+			case '!':
+			current_char_length = 2;
+			break;
+
 			case '&':
 			current_char_length = 5;
 			break;
 
 			case '[':
 			case ']':
+			case '.':
 			current_char_length = 3;
 			break;
 
@@ -436,34 +454,44 @@ static unsigned int length_of_print_string(unsigned char* txt) {
 	return text_length;
 }
 
-static void drawTopLeftCornerText(unsigned char* txt, unsigned char isReversed) {
+static void drawTopLeftCornerTextOffset(unsigned char* txt, unsigned char isReversed, int y) {
 	ML_Color drawing_color = isReversed ? WHITE : BLACK;
 	unsigned int text_color = isReversed ? MINI_OVER : MINI_REV;
 	unsigned int text_length = length_of_print_string(txt);
 	if(!isReversed) {
-		ML_bmp_8_or(hex_border_top_left, text_length, 0);
+		ML_bmp_8_or(hex_border_top_left, text_length, y);
 	} else {
-		ML_bmp_8_and(hex_border_top_left_rev, text_length, 0);
+		ML_bmp_8_and(hex_border_top_left_rev, text_length, y);
 	}
-	PrintMini(0, 1, txt, text_color);
+	PrintMini(0, y + 1, txt, text_color);
+
+	ML_horizontal_line(7 + y, 0, text_length, drawing_color);
 
-	ML_horizontal_line(7, 0, text_length, drawing_color);
 }
 
-static void drawTopRightCornerText(unsigned char* txt, unsigned char isReversed) {
+static void drawTopLeftCornerText(unsigned char* txt, unsigned char isReversed) {
+	drawTopLeftCornerTextOffset(txt, isReversed, 0);
+}
+
+static void drawTopRightCornerTextOffset(unsigned char* txt, unsigned char isReversed, int y) {
 	ML_Color drawing_color = isReversed ? WHITE : BLACK;
 	unsigned int text_color = isReversed ? MINI_OVER : MINI_REV;
 	int text_length = length_of_print_string(txt);
 	int xPosition = 128 - text_length;
 	if(!isReversed) {
-		ML_bmp_8_or(hex_border_top_right, xPosition - 8, 0);	
+		ML_bmp_8_or(hex_border_top_right, xPosition - 8, y);
 	} else {
-		ML_bmp_8_and(hex_border_top_right_rev, xPosition - 8, 0);	
+		ML_bmp_8_and(hex_border_top_right_rev, xPosition - 8, y);
 
 	}
-	PrintMini(xPosition, 1, txt, text_color);
+	PrintMini(xPosition, y + 1, txt, text_color);
 
-	ML_horizontal_line(7, xPosition, 127, drawing_color);
+	ML_horizontal_line(7 + y, xPosition, 127, drawing_color);
+}
+
+
+static void drawTopRightCornerText(unsigned char* txt, unsigned char isReversed) {
+	drawTopRightCornerTextOffset(txt, isReversed, 0);
 }
 
 static void drawBottomLeftCornerText(unsigned char* txt, unsigned char isReversed) {
@@ -488,7 +516,7 @@ static void drawBottomRightCornerText(unsigned char* txt, unsigned char isRevers
 	if(!isReversed) {
 		ML_bmp_8_or(hex_border_bottom_right, xPosition - 8, 56);
 	} else {
-		ML_bmp_8_and(hex_border_bottom_right_rev, xPosition - 8, 56);		
+		ML_bmp_8_and(hex_border_bottom_right_rev, xPosition - 8, 56);
 	}
 	ML_horizontal_line(63, xPosition, 127, drawing_color);
 	PrintMini(xPosition, 57, txt, text_color);

hexagon.c

@@ -20,7 +20,7 @@ int AddIn_main(int isAppli, unsigned short OptionNum)
     // Key init
     data.shift_latch_value = 0;
     data.alpha_latch_value = 0;
-
+    data.are_entries_loaded = 0;
 
     switch_to_state(TITLE, &data);
 

init_states.c

@@ -130,12 +130,19 @@ void init_game(Game_Data *data)
 //TODO: init the level depending on the value of data->current_entry
 	data->level = NULL;
 	data->level = malloc(sizeof(Level));
-	if(data->level == NULL)
+	if(data->level == NULL) {
+		switch_to_state(data, TITLE);
 		return;
+	}
 
 	data->level->id = 1;
 
 	data->level->patterns = malloc(7*sizeof(Pattern));
+	if(data->level->patterns == NULL) {
+		free(data->level);
+		switch_to_state(data, TITLE);
+		return;
+	}
 	readPattern(&data->level->patterns[0], patternTest1);
 	readPattern(&data->level->patterns[1], patternTest2);
 	readPattern(&data->level->patterns[2], patternTest3);
@@ -181,6 +188,7 @@ void init_game(Game_Data *data)
 	data->line_transition.counter_start = 0;
 	data->line_transition.delta_nb_lines = 0;
 	data->cooldown_timer = 16;
+	data->it_s_a_highscore = 0;
 }
 
 void init_title(Game_Data *data)
@@ -230,6 +238,7 @@ memcpy(str_list[5], c_6, sizeof(char) * strlen(c_6));
 
 void init_menu(Game_Data *data)
 {
+	int i;
 
 	data->cam.cX = 64;
 	data->cam.cY = 70;
@@ -245,11 +254,18 @@ void init_menu(Game_Data *data)
 	data->nb_entries = 6;
 	data->current_entry = 1;
 	data->current_entry_high_score = 0; //to load from a save file
-	data->entry_difficulties = NULL;
-	data->entry_difficulties = malloc(sizeof(char*) * 6);
-	if(data->entry_difficulties == NULL)
-		return;
-	load_difficulty_names(data->entry_difficulties);
+	if(!data->are_entries_loaded) {
+		data->are_entries_loaded = 1;
+		data->entry_difficulties = NULL;
+		data->entry_highscores = NULL;
+		data->entry_difficulties = malloc(sizeof(char*) * 6);
+		data->entry_highscores = malloc(sizeof(float) * 6);
+		if(data->entry_difficulties == NULL || data->entry_highscores == NULL)
+			return;
+		for(i = 0; i < 6; i++)
+			data->entry_highscores[i] = 0.0f;
+		load_difficulty_names(data->entry_difficulties);
+	}
 }
 
 void init_game_over(Game_Data *data)
@@ -265,4 +281,8 @@ void init_game_over(Game_Data *data)
 	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;
+	}
 }

struct.h

@@ -46,7 +46,7 @@ struct Level{
 	float cam_min_speed;
 
 	float fast_spin_probability; // very low, there sometimes is a slightly faster spin for one second, then a normal spin. This is the number that allow us to generate it
-	
+
 	// for the line number changes (lc prefix):
 	int lc_min_score; // minimum score in seconds to reach before any line number change occurs
 	float lc_probability;
@@ -111,7 +111,10 @@ struct Game_Data{
 	unsigned int nb_entries;
 	unsigned int current_entry; //from 1 to 6
 	unsigned int current_entry_high_score;
+	char are_entries_loaded;
 	char **entry_difficulties; //a table of null-terminated strings
+	float *entry_highscores;
+	char it_s_a_highscore; // IT'S A HIGSCORE!
 	unsigned int keypress_delay;
 };
 

update_states.c

@@ -49,10 +49,17 @@ void update_game(Game_Data *data)
 		data->cooldown_timer = pattern.cooldown;
 	}
 
-	if(KeyDown(K_LEFT)) {
+	if(KeyDown(K_LEFT) && !isCollidingSide(data->list, data->player_angle, data->nb_lines)) {
 		data->player_angle = data->player_angle - data->level->player_rotation_speed *  (data->current_time - data->last_time)*FRAME_TIME;
+		// int newAngle = data->player_angle - data->level->player_rotation_speed *  (data->current_time - data->last_time)*FRAME_TIME;
+		//if(isCollidingSide(data->list, newAngle, data->nb_lines))
+		//	data->player_angle = ((newAngle)/data->nb_lines)*data->nb_lines + 1;
+		//else
+		//data->player_angle = newAngle;
 	}
 	if(KeyDown(K_RIGHT)) {
+//		if(isCollidingSide(data->list, data->player_angle, data->nb_lines))
+//			else
 		data->player_angle = data->player_angle + data->level->player_rotation_speed *  (data->current_time - data->last_time)*FRAME_TIME;
 	}
 
@@ -113,6 +120,7 @@ void update_menu(Game_Data *data)
 		else if(KeyDown(K_LEFT))
 		{
 			data->current_entry --;//change the selected id
+			data->chrono_time = data->entry_highscores[data->current_entry - 1];
 			if(data->current_entry == 0)//check for overflows
 				data->current_entry = 6;
 			data->keypress_delay = 15;//init the delay
@@ -123,6 +131,7 @@ void update_menu(Game_Data *data)
 		}else if(KeyDown(K_RIGHT))
 		{
 			data->current_entry ++;
+			data->chrono_time = data->entry_highscores[data->current_entry - 1];
 			if(data->current_entry == 7)
 				data->current_entry = 1;
 			data->keypress_delay = 15;
@@ -166,6 +175,7 @@ static void game_over(Game_Data *data) {
 		freePattern(&data->level->patterns[i]);
 	}
 	free(data->level);
+	data->level = NULL;
 
 	switch_to_state(GAME_OVER, data);
 }