Patterns are functionnal. There is a little strange quirk but it works

hexagon.g1w

@@ -22,3 +22,4 @@ SourceFile=:ECode.c
 SourceFile=:hexagon.c
 SourceFile=:wall.c
 SourceFile=:fixed.c
+SourceFile=:pattern.c

init_states.c

@@ -1,4 +1,71 @@
 #include "init_states.h"
+#include "pattern.h"
+
+const unsigned char patternTest1[] = {
+	0x05,    0x20,
+	0x01,    0x00, 0x00,    0x00, 0x05,
+	0x02,    0x00, 0x00,    0x00, 0x05,
+	0x03,    0x00, 0x00,    0x00, 0x05,
+	0x04,    0x00, 0x00,    0x00, 0x05,
+	0x05,    0x00, 0x00,    0x00, 0x05,
+
+};
+
+const unsigned char patternTest2[] = {
+	0x0C,    0x40,
+	0x00,    0x00, 0x00,    0x00, 0x03,
+	0x02,    0x00, 0x00,    0x00, 0x03,
+	0x04,    0x00, 0x00,    0x00, 0x03,
+
+	0x00,    0x00, 0x10,    0x00, 0x03,
+	0x02,    0x00, 0x10,    0x00, 0x03,
+	0x04,    0x00, 0x10,    0x00, 0x03,
+
+	0x00,    0x00, 0x20,    0x00, 0x03,
+	0x02,    0x00, 0x20,    0x00, 0x03,
+	0x04,    0x00, 0x20,    0x00, 0x03,
+
+	0x00,    0x00, 0x30,    0x00, 0x03,
+	0x02,    0x00, 0x30,    0x00, 0x03,
+	0x04,    0x00, 0x30,    0x00, 0x03,
+};
+
+const unsigned char patternTest3[] = {
+	0x09,   0x60,
+	0x00,   0x00, 0x00,    0x00, 0x04,
+	0x01,   0x00, 0x00,    0x00, 0x04,
+	0x02,   0x00, 0x00,    0x00, 0x04,
+
+	0x02,   0x00, 0x20,    0x00, 0x04,
+	0x03,   0x00, 0x20,    0x00, 0x04,
+	0x04,   0x00, 0x20,    0x00, 0x04,
+
+	0x04,   0x00, 0x40,    0x00, 0x04,
+	0x05,   0x00, 0x40,    0x00, 0x04,
+	0x00,   0x00, 0x40,    0x00, 0x04,
+};
+
+const unsigned char patternTest4[] = {
+	0x0D,  0xB0,
+	0x00,  0x00, 0x80,    0x00, 0x60,
+	0x03,  0x00, 0x80,    0x00, 0x60,
+
+	0x01,  0x00, 0x10,    0x00, 0x02,
+	0x04,  0x00, 0x10,    0x00, 0x02,
+	0x02,  0x00, 0x20,    0x00, 0x02,
+	0x05,  0x00, 0x20,    0x00, 0x02,
+
+	0x01,  0x00, 0x30,    0x00, 0x02,
+	0x04,  0x00, 0x30,    0x00, 0x02,
+	0x02,  0x00, 0x40,    0x00, 0x02,
+	0x05,  0x00, 0x40,    0x00, 0x02,
+
+	0x01,  0x00, 0x50,    0x00, 0x02,
+	0x04,  0x00, 0x50,    0x00, 0x02,
+	0x02,  0x00, 0x60,    0x00, 0x02,
+	0x05,  0x00, 0x60,    0x00, 0x02
+
+};
 
 void init_game(Game_Data *data)
 {
@@ -8,7 +75,13 @@ void init_game(Game_Data *data)
 		return;
 
 	data->level->id = 1;
-	data->level->nb_patterns = 0;
+
+	data->level->patterns = malloc(4*sizeof(Pattern));
+	readPattern(&data->level->patterns[0], patternTest1);
+	readPattern(&data->level->patterns[1], patternTest2);
+	readPattern(&data->level->patterns[2], patternTest3);
+	readPattern(&data->level->patterns[3], patternTest4);
+	data->level->nb_patterns = 4;
 
 	data->level->cam_change_interval = 5;
 	data->level->cam_change_precision = 1;
@@ -40,6 +113,7 @@ void init_game(Game_Data *data)
 	data->line_transition.counter = 0;
 	data->line_transition.counter_start = 0;
 	data->line_transition.delta_nb_lines = 0;
+	data->cooldown_timer = 16;
 }
 void init_title(Game_Data *data)
 {

pattern.c

@@ -2,44 +2,39 @@
 #include "struct.h"
 #include "wall.h"
 
-static Pattern* allocatePattern(unsigned int pattern_length) {
+static Pattern* allocatePattern(Pattern* pattern, unsigned int pattern_length) {
 	// Freaking free cascade
-	pattern->side = malloc(sizeof(unsigned char) * pattern_length);
-	if(pattern_length->side == NULL) {
-		free(pattern);
+	pattern->side = (unsigned char*) malloc(sizeof(unsigned char) * pattern_length);
+	if(pattern->side == NULL) {
 		return NULL;
 	}
-	pattern->distance = malloc(sizeof(unsigned short) * pattern_length);
-	if(pattern_length->distance == NULL) {
+	pattern->distance = (unsigned short*)malloc(sizeof(unsigned short) * pattern_length);
+	if(pattern->distance == NULL) {
 		free(pattern->side);
-		free(pattern);
 		return NULL;
 	}
-	pattern->wall_length = malloc(sizeof(unsigned short) * pattern_length);
-	if(pattern_length->wall_length == NULL) {
+	pattern->wall_length = (unsigned short*)malloc(sizeof(unsigned short) * pattern_length);
+	if(pattern->wall_length == NULL) {
 		free(pattern->distance);
 		free(pattern->side);
-		free(pattern);
 		return NULL;
 	}
-
+	return pattern;
 }
 
-Pattern* readPattern(unsigned char* data, unsigned int length) {
-	unsigned char* iterator = data+1;
-	unsigned i, pattern_length;
-	Pattern* pattern;
-	pattern_length = data[0];
-	pattern = allocatePattern(pattern_length);
-	if(pattern == NULL) return NULL;
+Pattern* readPattern(Pattern* pattern, unsigned char* data) {
+	unsigned int i;
+	pattern->length = data[0];
+	pattern->cooldown = data[1];
+	allocatePattern(pattern, pattern->length);
+	if(pattern  == NULL) return NULL;
 
-	for(int i = 0; i < pattern_length; i++) {
-		pattern->side[i] = data[iterator];
-		pattern->distance[i] = ((data[iterator]+1)<<8) + (data[iterator]+2);
-		pattern->wall_length[i] = ((data[iterator]+2)<<8) + (data[iterator]+3);
-		iterator+= 5;
+	for(i = 0; i < data[0]; i++) {
+		unsigned int offset = i*5 + 2;
+		pattern->side[i] = data[offset];
+		pattern->distance[i] = (data[offset + 1]<<8) + data[offset + 2];
+		pattern->wall_length[i] = (data[offset + 3]<<8) + data[offset + 4];
 	}
-
 	return pattern;
 }
 
@@ -47,7 +42,7 @@ void addPattern(Game_Data* data, Pattern* pattern, unsigned char offset) {
 	unsigned int i;
 	for(i = 0; i < pattern->length; i++) {
 		// Build wall
-		addWall(data->list, pattern->distance[i], pattern->wall_length, 1, (pattern->side[i] + offset)%data->nb_lines);
+		data->list = addWall(data->list, pattern->distance[i] + 128, pattern->wall_length[i], 1, (pattern->side[i] + offset)%data->nb_lines);
 	}
 }
 
@@ -55,6 +50,5 @@ Pattern* freePattern(Pattern* pattern) {
 	free(pattern->side);
 	free(pattern->distance);
 	free(pattern->wall_length);
-	free(pattern);
 	return NULL;
 }

pattern.h

@@ -23,7 +23,7 @@
  * @param  data Data to read
  * @return      A brand new pattern
  */
-Pattern* readPattern(unsigned char* data, unsigned int length);
+Pattern* readPattern(Pattern* pattern, unsigned char* data);
 
 /**
  * Add the whole patter to the current game.
@@ -32,6 +32,6 @@ Pattern* readPattern(unsigned char* data, unsigned int length);
  */
 void addPattern(Game_Data* data, Pattern* pattern, unsigned char offset);
 
-free* freePattern(Pattern* pattern);
+Pattern* freePattern(Pattern* pattern);
 
 #endif

struct.h

@@ -16,13 +16,13 @@
 //macros
 #define abs(x) x>0 ? x : -x
 
-typedef enum {PATTERN} Pattern_Enum;
 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 struct Pattern Pattern;
 typedef enum {GAME, MENU, TITLE, GAME_OVER} State;
 
 struct Level{
@@ -30,8 +30,7 @@ struct Level{
 	int id; //1 to 6
 
 	//for the level generation
-	Pattern_Enum available_patterns[32];
-
+	Pattern* patterns;
 	int nb_patterns;
 
 	//for the camera rotation
@@ -101,15 +100,17 @@ struct Game_Data{
 
 	unsigned char shift_latch_value;
 	unsigned char alpha_latch_value;
+	unsigned char cooldown_timer;
 };
 
-typedef struct {
+struct Pattern{
 	unsigned char length;
+	unsigned char cooldown;
 	// Should be dynamically allocated
 	unsigned char* side;
 	unsigned short* distance;
 	unsigned short* wall_length;
-} Pattern;
+};
 
 
 #endif

update_states.c

@@ -1,4 +1,5 @@
 #include "update_states.h"
+#include "pattern.h"
 #include "fixed.h"
 
 void update_title(Game_Data *data)
@@ -38,15 +39,10 @@ void update_game(Game_Data *data)
 	}
 	//level generation
 	//TODO: something else than pure randomness
-	if(rand() % 40 == 1) {
-		data->list = addWall(data->list, 128, 5, 1, rand()%data->nb_lines);
-	} else if(rand() % 70 == 1) {
-		int emptyRow = rand()%data->nb_lines;
-		int i = 0;
-		for(i = 0; i < data->nb_lines; i++){
-			if(i != emptyRow)
-				data->list = addWall(data->list, 128, 5, 1, i);
-		}
+	if(!data->cooldown_timer--) {
+		Pattern pattern = data->level->patterns[rand()% data->level->nb_patterns];
+		addPattern(data, &pattern, rand()%6);
+		data->cooldown_timer = pattern.cooldown;
 	}
 	if(KeyDown(K_LEFT)){
 		data->player_angle-=15;

wall.c

@@ -104,7 +104,7 @@ void drawWalls(Wall *list, Camera *cam, int nb_lines, Line_Transition line_trans
 	do{
 		if(tmp != NULL)
 		{
-			if(tmp->d + tmp->h < 128)
+			if(tmp->d - tmp->h < 128)
 			{
 				const fix delta_angle_minus_offset = delta_angle - offset;
 				const fix angle =  fmul(delta_angle_minus_offset, FIX(tmp->line)) + FIX(cam->angle);
@@ -116,6 +116,7 @@ void drawWalls(Wall *list, Camera *cam, int nb_lines, Line_Transition line_trans
 
 				fix dist = ftofix(tmp->d + cam->zoom);
 				for(i = 0; i < tmp->h && dist > FIX(8); ++i) {
+					if(dist < FIX(96))
 					ML_line(64 + fixtof(fmul(dist, cos1)), 32 + fixtof(fmul(dist,sin1)), 64 + fixtof(fmul(dist, cos2)), 32 + fixtof(fmul(dist, sin2)), BLACK);
 					dist -= FIX(1);
 				}