Finally correctly implemented the transition when changing the number of lines. Currently only for the diagonals, but the changes are coming for the walls and the player.

draw_states.c

@@ -2,11 +2,11 @@
 void draw_game(Game_Data *data)
 {
 	//draw the player and the lines
-    drawPlayer(&(data->cam), data->player_angle, data->nb_lines);
-    drawDiagonals(data->cam, data->nb_lines);
+    drawPlayer(&(data->cam), data->player_angle, data->nb_lines, data->line_transition);
+    drawDiagonals(data->cam, data->nb_lines, data->line_transition);
     	//showing the walls
-    if(data->list != NULL)
-        drawWalls(data->list, &(data->cam), data->nb_lines);
+    //if(data->list != NULL)
+    //    drawWalls(data->list, &(data->cam), data->nb_lines);
 }
 void draw_title(Game_Data *data)
 {
@@ -25,37 +25,51 @@ void draw_game_over(Game_Data *data)
 //at first, was supposed to draw an hexagon in the center, plus a triangle to show the player,
 //but the hexagon was not visible, and it was a pixel mess, so we're showing a circle instead.
 //there is still for code to calculate the vertices of the hexagon, in case we want to change that again
-void drawPlayer(Camera *cam, int player_angle, int nb_lines)
+void drawPlayer(Camera *cam, int player_angle, int nb_lines, Line_Transition line_transition)
 {
-    int x[32];
-    int y[32];
-    int i = 0;
-    int angle = 0;
-    for(i = 0; i < nb_lines; ++i)
-    {
-        angle = i * 360 / nb_lines;
-        x[i] = (8. + cam->zoom)*cos(PI * (angle + cam->angle)/180.) + cam->cX;
-        y[i] = (8. + cam->zoom)*sin(PI * (angle + cam->angle)/180.) + cam->cY;
-    }
+	int x[32];
+	int y[32];
+	int i = 0;
+	int angle = 0;
+	for(i = 0; i < nb_lines; ++i)
+	{
+	angle = i * 360/nb_lines;
+		x[i] = (8. + cam->zoom)*cos(PI * (angle + cam->angle)/180.) + cam->cX;
+        	y[i] = (8. + cam->zoom)*sin(PI * (angle + cam->angle)/180.) + cam->cY;
+	}
 
 	//draw the aforementionned circle, depending on the camera's center
-    //ML_filled_circle(cam.cX, cam.cY, 6, BLACK);
+	//ML_filled_circle(cam.cX, cam.cY, 6, BLACK);
 	ML_polygone(x, y, nb_lines, BLACK);
 	//draw the player. At such a low scale, it was impossible to draw a rotating triangle, so its a radius 1 circle instead.
-    ML_filled_circle((9. + cam->zoom)*cos( PI*(player_angle + cam->angle)/180) + cam->cX, (9. + cam->zoom)*sin( PI*(player_angle+cam->angle)/180) + cam->cY, 1, BLACK);
+	ML_filled_circle((9. + cam->zoom)*cos( PI*(player_angle + cam->angle)/180) + cam->cX, (9. + cam->zoom)*sin( PI*(player_angle+cam->angle)/180) + cam->cY, 1, BLACK);
 
 }
 
 //draws one of the three rotating lines
-void drawDiagonals(Camera cam, int nb_lines)
+void drawDiagonals(Camera cam, int nb_lines, Line_Transition line_transition)
 {
 	int tmp_angle = cam.angle;
 	float tmp_angle_rad = 0.0f;
 	int i = 0;
-	
+
 	float x1 = 0.0f, y1 = 0.0f, x2 = 0.0f, y2 = 0.0f;
 
-	do{	
+	float delta_angle = 0.0;
+
+	float coeff = 0.0;
+	float transition_angle = 0.0;
+	
+	delta_angle = 360.0 / nb_lines;
+
+	if(line_transition.delta_nb_lines == 1)
+		nb_lines ++;
+
+	if(line_transition.counter_start != 0)
+		coeff = (float)line_transition.counter / (float)line_transition.counter_start;
+	transition_angle = delta_angle * coeff;
+
+	do{
 		tmp_angle_rad = tmp_angle * PI / 180.0f;
 		x1 = 9.0f * cos(tmp_angle_rad);
 		y1 = 9.0f * sin(tmp_angle_rad);
@@ -63,8 +77,31 @@ void drawDiagonals(Camera cam, int nb_lines)
 		y2 = 64.0f * sin(tmp_angle_rad);
 		ML_line(x1 + cam.cX, y1 + cam.cY, x2 + cam.cX, y2 + cam.cY, BLACK);
 
-		tmp_angle += (360 / nb_lines);
-		if(tmp_angle >= 360)tmp_angle = tmp_angle - 359;
 		i++;
+
+		switch(line_transition.delta_nb_lines){
+		case 0:
+			tmp_angle += 360/nb_lines;
+			break;
+
+		case 1:
+			if(i < nb_lines - 1)
+			{
+				tmp_angle += (360 - (delta_angle - transition_angle)) / (nb_lines - 1);
+			}else{
+				tmp_angle += delta_angle - transition_angle;
+			}
+			break;
+
+		case -1:
+			if(i < nb_lines - 1)
+			{
+				tmp_angle += (360 - transition_angle) / (nb_lines - 1);
+			}else{
+				tmp_angle += transition_angle;
+			}
+			break;
+		}
+		if(tmp_angle >= 360)tmp_angle = tmp_angle - 359;
 	}while(i < nb_lines);
 }

draw_states.h

@@ -9,6 +9,6 @@ void draw_title(Game_Data *data);
 void draw_menu(Game_Data *data);
 void draw_game_over(Game_Data *data);
 
-void drawPlayer(Camera *cam, int player_angle, int nb_lines);
-void drawDiagonals(Camera cam, int nb_lines);
+void drawPlayer(Camera *cam, int player_angle, int nb_lines, Line_Transition line_transition);
+void drawDiagonals(Camera cam, int nb_lines, Line_Transition line_transition);
 #endif

init_states.c

@@ -16,7 +16,9 @@ void init_game(Game_Data *data)
 	data->cam.speed = 0.0;
 
 	data->nb_lines = 6;
-	data->line_transition_counter = 0;
+	data->line_transition.counter = 0;
+	data->line_transition.counter_start = 0;
+	data->line_transition.delta_nb_lines = 0;
 }
 void init_title(Game_Data *data)
 {

struct.h

@@ -21,6 +21,7 @@ typedef struct Camera Camera;
 typedef struct Wall Wall;
 typedef struct Line Line;
 typedef struct Level Level;
+typedef struct Line_Transition Line_Transition;
 typedef struct Game_Data Game_Data;
 typedef enum {GAME, MENU, TITLE, GAME_OVER} State;
 
@@ -47,7 +48,7 @@ struct Level{
 struct Camera{
     int cX;
     int cY;
-    int angle;
+    unsigned int angle;
     float zoom;
 
     float speed;
@@ -61,13 +62,19 @@ struct Camera{
 //nxt is used by the linked list
 struct Wall{
     float d;
-    int h;
-    int id;
-    int line;
+    unsigned int h;
+    unsigned int id;
+    unsigned int line;
 
     Wall *nxt;
 };
 
+struct Line_Transition{
+	unsigned int counter;
+	unsigned int counter_start;
+	int delta_nb_lines;
+};
+
 struct Game_Data{
 	unsigned int start_time;
 	unsigned int last_time;
@@ -75,7 +82,8 @@ struct Game_Data{
 	unsigned int player_angle;
 
 	unsigned int nb_lines;
-	int line_transition_counter; //neg = removing one line, pos: adding one line
+	Line_Transition line_transition;
+
 	Wall *list;
 
 	Level *level;

update_states.c

@@ -6,38 +6,57 @@ void update_title(Game_Data *data)
 }
 void update_game(Game_Data *data)
 {
-    data->last_time = data->current_time;
-    data->current_time = RTC_GetTicks();
-    if(data->list != NULL){ //if the linked list is not empty
-            updateWalls(data->list, data->current_time - data->last_time); //update the linked list
+	data->last_time = data->current_time;
+	data->current_time = RTC_GetTicks();
+	if(data->list != NULL){ //if the linked list is not empty
+		updateWalls(data->list, data->current_time - data->last_time); //update the linked list
 
-        if(isColliding(data->list, data->player_angle, data->nb_lines) == true){ //if the player and a wall collide
-            PrintMini(50, 0, "TOUCHE", MINI_OVER); //death handling
-    	}
-        data->list = removeWall(data->list, 0); //remove every wall whose distance to the center equals zero
-    }
+	if(isColliding(data->list, data->player_angle, data->nb_lines) == true){ //if the player and a wall collide
+		PrintMini(50, 0, "TOUCHE", MINI_OVER); //death handling
+	}
+	data->list = removeWall(data->list, 0); //remove every wall whose distance to the center equals zero
+	}
 	//level generation
 	//TODO: something else than pure randomness
-    if(rand() % 40 == 1){
-        data->list = addWall(data->list, 128, 8, 1, rand()%6);
-    }else if(rand() % 70 == 1){
-        int emptyRow = rand()%6;
-        int i = 0;
-        for(i = 0; i < 6; i++)
-            if(i != emptyRow)
-                data->list = addWall(data->list, 128, 15, 1, i);
-    }
-    if(KeyDown(K_LEFT)){
-        data->player_angle-=15;
-    }
-    if(KeyDown(K_RIGHT)){
-        data->player_angle+=15;
+	if(rand() % 40 == 1){
+		data->list = addWall(data->list, 128, 8, 1, rand()%6);
+	}else if(rand() % 70 == 1){
+		int emptyRow = rand()%6;
+		int i = 0;
+		for(i = 0; i < 6; i++)
+			if(i != emptyRow)
+				data->list = addWall(data->list, 128, 15, 1, i);
     }
+	if(KeyDown(K_LEFT)){
+		data->player_angle-=15;
+	}
+	if(KeyDown(K_RIGHT)){
+		data->player_angle+=15;
+	}
+
+	if(KeyDown(K_PLUS) && data->line_transition.counter == 0)
+	{
+		data->line_transition.counter = 10;
+		data->line_transition.counter_start = 10;
+		data->line_transition.delta_nb_lines = 1;
+	}else if(KeyDown(K_MINUS) && data->line_transition.counter == 0){
+		data->line_transition.counter = 10;
+		data->line_transition.counter_start = 10;
+		data->line_transition.delta_nb_lines = -1;
+	}
+	if(data->line_transition.counter != 0){
+		data->line_transition.counter --;
+		if(data->line_transition.counter <= 0){
+			data->nb_lines += data->line_transition.delta_nb_lines;
+			data->line_transition.counter_start = 0;
+			data->line_transition.delta_nb_lines = 0;
+		}
+	}
+
+	if(data->player_angle < 0)
+		data->player_angle = 360 + data->player_angle;
+		data->player_angle = data->player_angle % 360;
 
-    //the angle must not be greater than 360
-    if(data->player_angle < 0)
-        data->player_angle = 360 + data->player_angle;
-    data->player_angle = data->player_angle % 360;
 	updateCamera(&(data->cam), data->current_time - data->last_time);
 }
 void update_menu(Game_Data *data)
@@ -50,9 +69,9 @@ void update_game_over(Game_Data *data)
 }
 
 void updateCamera(Camera *cam, unsigned int delta_time){
-    cam->speed = 1; //to change
-    cam->angle += cam->speed * delta_time / 2.;
+	cam->speed = 1; //to change
+	cam->angle += cam->speed * delta_time / 2.;
 
-    if(cam->angle >= 360)
-        cam->angle = cam->angle % 360;
+	if(cam->angle >= 360)
+		cam->angle = cam->angle % 360;
 }