Updated base

draw_states.c

@@ -4,13 +4,12 @@
 void draw_game(Game_Data *data)
 {
 	//draw the player and the lines
-    drawPlayer(&(data->cam), data->player_angle);
-    drawDiagonal(1, data->cam);
-    drawDiagonal(2, data->cam);
-    drawDiagonal(3, data->cam);
-	//showing the walls
+    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));
+        drawWalls(data->list, &(data->cam), data->nb_lines);
+
 	//showing the HUD
 	//drawGameHUD(data);
 }
@@ -59,60 +58,114 @@ void drawGameHUD(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)
+void drawPlayer(Camera *cam, int player_angle, int nb_lines, Line_Transition line_transition)
 {
-    int x[6];
-    int y[6];
-    int i = 0;
-    int angle = 0;
-    for(i = 0; i<6; ++i)
-    {
-        angle = i *60;
-        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;
+
+	float tmp_angle = 0.0;
+	float transition_angle = 0.0;
+	float delta_angle = 0.0;
+
+	if(line_transition.delta_nb_lines == 1)
+		nb_lines ++;
+	if(line_transition.counter_start != 0)
+		transition_angle = (360.0 / (float)nb_lines) * ((float)line_transition.counter / (float)line_transition.counter_start);
+	delta_angle = 360.0/nb_lines;
+
+	do
+	{
+		x[i] = (8. + cam->zoom)*cos(PI * (tmp_angle + cam->angle)/180.) + cam->cX;
+		y[i] = (8. + cam->zoom)*sin(PI * (tmp_angle + cam->angle)/180.) + cam->cY;
+
+		i++;
+		
+		switch(line_transition.delta_nb_lines)
+		{
+			case 0:
+				tmp_angle += delta_angle;
+				break;
+			case 1:
+				if(i < nb_lines)
+					tmp_angle += (360 - (delta_angle - transition_angle)) / (nb_lines - 1);
+				else
+					tmp_angle += delta_angle - transition_angle;
+				break;
+			case -1:
+				if(i < nb_lines)
+					tmp_angle += (360 - transition_angle) / (nb_lines - 1);
+				else
+					tmp_angle = transition_angle;
+				break;
+		}
+	}while(i <= nb_lines);
 
 	//draw the aforementionned circle, depending on the camera's center
-    //ML_filled_circle(cam.cX, cam.cY, 6, BLACK);
-	ML_polygone(x, y, 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 drawDiagonal(int nb, Camera cam)
+void drawDiagonals(Camera cam, int nb_lines, Line_Transition line_transition)
 {
-    int tmp_angle = 0;
-    float coeff = 0;
-    int x1 = 0, y1 = 0, x2 = 0, y2 = 0;
-
-	//defining the angle between the line and the horizontal axis
-    if(nb == 1)
-        tmp_angle = cam.angle + 60;
-    else if(nb == 2)
-        tmp_angle = cam.angle;
-    else if(nb == 3)
-        tmp_angle = 300 + cam.angle;
-    if(tmp_angle >= 360)tmp_angle = tmp_angle - 359;
-
-	//defining the slope coefficient
-    coeff = sin(PI*tmp_angle / 180)/cos(PI * tmp_angle / 180);
-
-	//ML needs four coordinates in order to draw a line
-    x1 = -32/coeff;
-    y1 = -32;
-
-    x2 = 32/coeff;
-    y2 = 32;
-
-    if(abs(x1) > 64){
-        x1 = -64;
-        y1 = -64*coeff;
-
-        x2 = 64;
-        y2 = 64*coeff;
-    }
-	//drawing the line
-        ML_line(x1 + cam.cX, y1 + cam.cY, x2 + cam.cX, y2 + cam.cY, BLACK);
-}
+	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;
+
+	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);
+		x2 = 64.0f * cos(tmp_angle_rad);
+		y2 = 64.0f * sin(tmp_angle_rad);
+		ML_line(x1 + cam.cX, y1 + cam.cY, x2 + cam.cX, y2 + cam.cY, BLACK);
+
+		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,7 +9,7 @@ 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);
-void drawDiagonal(int nb, Camera cam);
+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);
 void drawGameHUD(Game_Data *data);
-#endif
+#endif

init_states.c

@@ -3,6 +3,25 @@
 void init_game(Game_Data *data)
 {
 	data->level = NULL;
+	data->level = malloc(sizeof(Level));
+	if(data->level == NULL)
+		return;
+
+	data->level->id = 1;
+	data->level->nb_patterns = 0;
+
+	data->level->cam_change_interval = 5;
+	data->level->cam_change_precision = 1;
+	data->level->cam_change_probability = 0.75;
+	data->level->cam_max_speed = 5;
+	data->level->cam_min_speed = 1;
+	data->level->fast_spin_probability = 0.1;
+
+	data->level->lc_min_score = 20;
+	data->level->lc_probability = 0.05;
+	data->level->lc_duration = 15;
+
+
 	data->list = NULL;
 	data->start_time = RTC_GetTicks(); //1 tick == 1/128 second
 	data->last_time = 0;
@@ -14,6 +33,11 @@ void init_game(Game_Data *data)
 	data->cam.cY = 32;
 	data->cam.angle = 0;
 	data->cam.speed = 0.0;
+
+	data->nb_lines = 6;
+	data->line_transition.counter = 0;
+	data->line_transition.counter_start = 0;
+	data->line_transition.delta_nb_lines = 0;
 }
 void init_title(Game_Data *data)
 {
@@ -27,4 +51,4 @@ void init_menu(Game_Data *data)
 void init_game_over(Game_Data *data)
 {
 
-}
+}

struct.h

@@ -4,7 +4,7 @@
 #include "stdlib.h"
 
 //constants
-#define FPS 60
+#define FPS 20
 #define FRAME_TIME 1/FPS
 #define PI 3.14159265
 #define SIN_60 0.866025404
@@ -21,24 +21,33 @@ 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;
 
 struct Level{
+
+	int id; //1 to 6
+
 	//for the level generation
-	Pattern_Enum available_patterns[32][32];
+	Pattern_Enum available_patterns[32];
 
 	int nb_patterns;
 
 	//for the camera rotation
-	int change_interval; //5 seconds most of the time, but who knows...
-	int change_precision; //to add a bit of randomness to the intervals
-	float change_probability; //sometimes, there can be no change at all
-
-	float max_speed;
-	float min_speed;
+	int cam_change_interval; //5 seconds most of the time, but who knows...
+	int cam_change_precision; //to add a bit of randomness to the intervals
+	float cam_change_probability; //sometimes, there can be no change at all
+	//camera speed
+	float cam_max_speed;
+	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;
+	int lc_duration;
 };
 
 //the camera is defined by its center
@@ -47,7 +56,7 @@ struct Level{
 struct Camera{
     int cX;
     int cY;
-    int angle;
+    unsigned int angle;
     float zoom;
 
     float speed;
@@ -61,19 +70,28 @@ 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;
 	unsigned int current_time;
 	unsigned int player_angle;
 
+	unsigned int nb_lines;
+	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) == 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 -= 359;
-}
+	if(cam->angle >= 360)
+		cam->angle = cam->angle % 360;
+}

wall.c

@@ -76,8 +76,8 @@ void updateWalls(Wall *list, unsigned int delta_time)
 	}while(tmp != NULL);
 }
 
-void drawWalls(Wall *list, Camera *cam)
-{
+void drawWalls(Wall *list, Camera *cam, int nb_lines)
+{//NEEDS A COMPLETE REWRITE TO SUPPORT THE LINE TRANSITIONS !
 	Wall *tmp;
 	tmp = list;
 	do{
@@ -85,12 +85,12 @@ void drawWalls(Wall *list, Camera *cam)
 		{
 			if(tmp->d + tmp->h< 64)
 			{
-
-				const float angle = PI * ((tmp->line)*60 +cam->angle) / 180;
+				const float angle =  ((360 / nb_lines) * tmp->line + cam->angle) * PI / 180;
 				const float cos1 = cos(angle);
-				const float cos2 = cos(angle + PI/3);
+				const float cos2 = cos(angle +  (360.0 / nb_lines) * (PI / 180));
 				const float sin1 = sin(angle);
-				const float sin2 = sin(angle + PI/3);
+				const float sin2 = sin(angle + (360.0 / nb_lines) * (PI / 180));
+
 				int i,j, x, y;
 
 				float dist = tmp->d - tmp->h + cam->zoom;
@@ -106,7 +106,7 @@ void drawWalls(Wall *list, Camera *cam)
 }
 
 //tests every Wall in the list
-bool isColliding(Wall *list, int player_angle)
+bool isColliding(Wall *list, int player_angle, int nb_lines)
 {
 	Wall *tmp;
 	tmp = list;
@@ -116,7 +116,7 @@ bool isColliding(Wall *list, int player_angle)
 		{
 			if(tmp-> d <= 8)//if the wall is close enough from the center of the screen
 			{	//and is on the same line than the player
-				if(tmp->line == (int)(player_angle/60)) //&& tmp->line * 60 + 60 > player_angle)
+				if(tmp->line == (int)(player_angle/ 360 / nb_lines))
 				{	//BOOM
 					return true;
 				}

wall.h

@@ -10,9 +10,9 @@ Wall *addWall(Wall *list, int d, int h, int id, int line);//returns a new pointe
 Wall *removeWall(Wall *list, int d); //returns a new pointer to the first element
 
 //show the ll "list"
-void drawWalls(Wall *list, Camera *cam);
+void drawWalls(Wall *list, Camera *cam, int nb_lines);
 //updates the ll "list"
 void updateWalls(Wall *list, unsigned int delta_time);
 //simple collision test. Returns true if a Wall from the list collides with the player
-bool isColliding(Wall *list, int player_angle);
+bool isColliding(Wall *list, int player_angle, int nb_lines);
 #endif