Game of Life

game_of_life.c

#include <stdio.h>
#include <stdlib.h>
#include <linux/fb.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <sys/ioctl.h>
#include <string.h>
#include <unistd.h>
#include <time.h>


const unsigned char white_dot[] = {0xFF, 0xFF, 0xFF, 0xFF}; 
const unsigned char black_dot[] = {0, 0, 0, 0}; 


typedef struct fbdata_t {
	
	int x_size;
	int y_size;
	int total_size;
	int bpp;
	char * buf1;
	char * buf2;
	char * device;
	
} fbdata_t;

typedef struct matrix_t {
	
	int x_size;
	int y_size;
	char * data;
	char * data_new;
	
} matrix_t;


void show(matrix_t * matrix, fbdata_t * fbdata){
	
	
	for(int i = 0; i < matrix->y_size; i++){
		
		for(int j = 0; j < matrix->x_size; j++){
						
			if(matrix->data[i * matrix->x_size + j] == 1){
				
				memcpy(&fbdata->buf1[(i * fbdata->x_size + j)*4], white_dot, 4);

				
			}else{
				
				memcpy(&fbdata->buf1[(i * fbdata->x_size + j)*4], black_dot, 4);

				
			}
			
		}
				
	}
	
	memcpy(fbdata->device, fbdata->buf1, fbdata->total_size);

}

void seed_points(matrix_t * matrix){
	
	for(int i = (matrix->y_size/2)-150; i < (matrix->y_size/2)+150; i++){
		
		for(int j = (matrix->x_size/2)-150; j < (matrix->x_size/2)+150; j++){
			
			if(rand() % 5 == 0){
					
				matrix->data[i * matrix->x_size + j] = (char) 1;
				
			}
			
		}
		
	}

} 

void noise_points(matrix_t * matrix){
	
	for(int i = 1; i < matrix->y_size; i++){
		
		for(int j = 1; j < matrix->x_size; j++){
			
			if(rand() % 50 == 0){
					
				matrix->data[i * matrix->x_size + j] = (char) 1;
				
			}
			
		}
		
	}

} 

void patern_1(matrix_t * matrix){
	
	matrix->data[100 * matrix->x_size + 100] = (char) 1;
	matrix->data[100 * matrix->x_size + 101] = (char) 0;
	matrix->data[100 * matrix->x_size + 102] = (char) 0;
	
	matrix->data[101 * matrix->x_size + 100] = (char) 0;
	matrix->data[101 * matrix->x_size + 101] = (char) 1;
	matrix->data[101 * matrix->x_size + 102] = (char) 1;
	
	matrix->data[102 * matrix->x_size + 100] = (char) 1;
	matrix->data[102 * matrix->x_size + 101] = (char) 1;
	matrix->data[102 * matrix->x_size + 102] = (char) 0;
	
}

void patern_2(matrix_t * matrix){
	
	matrix->data[10 * matrix->x_size + 10] = (char) 1;
	matrix->data[10 * matrix->x_size + 11] = (char) 1;
	
	matrix->data[11 * matrix->x_size + 10] = (char) 1;
	matrix->data[11 * matrix->x_size + 11] = (char) 1;
	
}
	
	

int init_game(matrix_t * matrix, fbdata_t * fbdata){
	
	struct fb_var_screeninfo vinfo;

	int fbfd = open("/dev/fb0", O_RDWR);

	if(fbfd >= 0) {

		ioctl (fbfd, FBIOGET_VSCREENINFO, &vinfo);

		fbdata->x_size = vinfo.xres;
		fbdata->y_size = vinfo.yres;
		fbdata->bpp = vinfo.bits_per_pixel;		
		fbdata->total_size = fbdata->x_size * fbdata->y_size * (fbdata->bpp / 8);

		printf("Framebuffer info: %dx%d, %d bpp, %d bytes\n", fbdata->x_size, fbdata->y_size, fbdata->bpp, fbdata->total_size);

		fbdata->buf1 = malloc(sizeof(char)*fbdata->total_size);
		fbdata->buf2 = malloc(sizeof(char)*fbdata->total_size);

		fbdata->device = mmap(NULL, fbdata->total_size, PROT_READ | PROT_WRITE, MAP_SHARED, fbfd, 0);
		
		memset(fbdata->device, 255, fbdata->total_size);
		
		matrix->x_size = vinfo.xres;
		matrix->y_size = vinfo.yres;
		
		matrix->data = malloc(sizeof(char)*(matrix->x_size*matrix->y_size));
		
		memset(matrix->data, 0, (matrix->x_size*matrix->y_size));
		
		matrix->data_new = malloc(sizeof(char)*(matrix->x_size*matrix->y_size));
		
		memset(matrix->data_new, 0, (matrix->x_size*matrix->y_size));
		
		return 1;
	
	
	}else{
		
		return 0;
		
		
	}
	
}

void evolve(matrix_t * matrix){
	
	int n, v;

	
	for(int i = 1; i < (matrix->y_size-1); i++){
		
		for(int j = 1; j < (matrix->x_size-1); j++){
				
			v = ((int) matrix->data[i * matrix->x_size + j]);
				
			n = 0;
				
			for(int k = -1; k <= 1; k++){
					
				for(int l = -1; l <= 1; l++){
						
					if(!(k == 0 && l == 0)){
				
						n += ((int) matrix->data[(i+l) * matrix->x_size + (j+k)]);
							
					}
						
				}
					
			}

			
			if(v == 1 && n < 2){
				
				matrix->data_new[i * matrix->x_size + j] = (char) 0;
				
			}
			
			if(v == 1 && n > 3){
					
				matrix->data_new[i * matrix->x_size + j] = (char) 0;
					
			}
				
			if(v == 0 && n == 3){
					
				matrix->data_new[i * matrix->x_size + j] = (char) 1;
					
			}
				
			if(v == 1 && (n == 3 || n == 2)){
					
				matrix->data_new[i * matrix->x_size + j] = (char) 1;
					
			}
			
		}
			
	}
	
	memcpy(matrix->data, matrix->data_new, (matrix->x_size*matrix->y_size));
	
}
	
	


int main(){
	
	srand(time(NULL));
	
	matrix_t * matrix = malloc(sizeof(matrix_t));
	fbdata_t * fbdata = malloc(sizeof(fbdata_t));

	init_game(matrix, fbdata);
	
	noise_points(matrix);
	noise_points(matrix);
	noise_points(matrix);
	
	show(matrix, fbdata);
	
	usleep(1*500000);
	
	
	for(int z = 1; z < 10000000; z++){
		
		evolve(matrix);
		
		show(matrix, fbdata);
		
		if(z % 10000 == 0){
			
			noise_points(matrix);
			
		}	
		
		//usleep(1*500000);
		
	}

}