PixelWars/generator.c

#include "main.h"

#define MAX_POWER 10
#define MAX_EPICENTER_BY_TYPE 10
#define MAX_RADIUS 75

typedef struct{
	int x;
	int y;
	int type;
	int power;
	int radius;
} t_epicenter;

// variables
t_epicenter* l_epicenters;
int size_epicenters;
int cpt_epicenter = 0;
int width, height;

// functions
int distance_manhattan(int x1,int y1, int x2, int y2);
int absolute(int val);
void set_spawns(t_pixel** map, t_team* teams);
void create_epicenter(int x, int y, int type);
void create_epicenter_random(int type);
int generate(int x, int y);

void create_map(t_pixel** map, t_team* teams, int w, int h){
	int i,j;
	int type;
	
	//epicenter variable
	int nb_rock, nb_tree, nb_berries;
	
	width = w;
	height = h;
	
	//Epicenters generation
	// random choice for numbers of epicenters
	nb_rock    = rand()%MAX_EPICENTER_BY_TYPE;
	nb_tree    = rand()%MAX_EPICENTER_BY_TYPE;
	nb_berries = rand()%MAX_EPICENTER_BY_TYPE;
	
	size_epicenters = nb_rock + nb_tree + nb_berries + NB_TEAMS;
	
	l_epicenters = malloc(sizeof(t_epicenter)*size_epicenters);
	
	// Spawn generations
	set_spawns(map,teams);
	
	for(i=0;i<nb_rock;i++)
		create_epicenter_random(ROCK);
	
	for(i=0;i<nb_tree;i++)
		create_epicenter_random(TREE);
	
	for(i=0;i<nb_berries;i++)
		create_epicenter_random(BERRIES);
	// */
	//génération de la carte
	for (i=0;i<width;i++){
		for(j=0;j<height;j++){
			if (i == 0 || j == 0){
				map[i][j].type = BEDROCK;
			}else{
				type=generate(i,j);
				map[i][j].type = type;
			}
		}
	}
}

void set_spawns(t_pixel** map, t_team* teams){
	int k,l;
	int x_rand,y_rand;
	
	for(k=0;k<NB_TEAMS;k++){
		x_rand= rand()%width;
		y_rand= rand()%height;
		
		int error = 1;
		while(error != 0){
			error = 0;
			for (l=0;l<k;l++){
				t_coord sp = teams[l].spawn;
				if (distance_manhattan(x_rand,y_rand,sp.x,sp.y) < 50)
					error = 1;
			}
		}
		
		map[x_rand][y_rand].type=SPAWN;
		map[x_rand][y_rand].data=malloc(sizeof(int));
		memset(map[x_rand][y_rand].data,ORANGE,sizeof(int));
		create_epicenter(x_rand,y_rand,GRASS);
		teams[k].spawn.x = x_rand;
		teams[k].spawn.y = y_rand;
	}
}

void create_epicenter(int x, int y, int type){
	t_epicenter *epicenter = malloc(sizeof(t_epicenter));
	
	epicenter->x=x;
	epicenter->y=y;
	epicenter->type = type;
	epicenter->power = (rand()%MAX_POWER)+1;
	epicenter->radius = (rand()%100)+1;
	
	l_epicenters[cpt_epicenter++]=*epicenter;
}

void create_epicenter_random(int type){
	create_epicenter(rand()%width,rand()%height,type);
}

int generate(int x, int y){
	int i, ratio, dist_to_epi, sum, val;
	int proba[5];
	t_epicenter epi;
	
	for(i=0;i<5;i++){
		proba[i]=0;
	}
	
	for(i=0;i<size_epicenters;i++){
		epi = l_epicenters[i];
		dist_to_epi = distance_manhattan(x,y,epi.x, epi.y);
		if (dist_to_epi < epi.radius){
			ratio = (int) (epi.radius - dist_to_epi * 100) / epi.radius;
			proba[epi.type-1] = proba[epi.type-1] + epi.power * ratio;
		}
	}
	
	sum=0;
	for (i=0;i<5;i++){
		sum += proba[i];
	}
	
	if (sum!=0){
		val = rand()%sum;
		int seuil = 0;
		for (i=0;i<5;i++){
			seuil += proba[i];
			if(val < seuil)
				return i+2;
		}
	}
	return GRASS;
}

int distance_manhattan(int x1,int y1, int x2, int y2){
	return absolute(x1-x2) + absolute(y1-y2);
}
	
int absolute(int val){
	return val > 0 ? val : -val;
}