// BomberFrag - CQFD Corp and NoFrag
// Initial release: 2005/Jan/06
// License: GPL - GNU General Public License, see "raydium/gpl.txt" file.

char *version="version 0.01";

#include "raydium/index.c"
//#include "raydium/reg_api.c"

GLfloat sun[]={1.0,0.9,0.5,1.0};
GLfloat amb[]={1.0,0.0,0.0,1.0};

// tout en vrac ici pour l'instant :

#define MAX_SOFT_WALLS	100
#define MAX_SIDE_SIZE	100
#define MIN_SPAWNS	4

#define STATE_NONE	0
#define STATE_NORMAL	1
#define STATE_EXPLODED	2

#define TYPE_WALL	'#'
#define TYPE_NONE	' '
#define TYPE_SPAWN	'*'
#define TYPE_BLOCK	'.'

typedef struct Block {
GLfloat pos[2];
int state;
} Block;

typedef struct Level {
int state;
char description[RAYDIUM_MAX_NAME_LEN];
int ground_model; // auto generated
int soft_wall_model;
int n_spawns;
GLfloat block_size;
GLfloat spawns[RAYDIUM_NETWORK_MAX_CLIENTS][2];
Block soft_walls[MAX_SOFT_WALLS];
char level[MAX_SIDE_SIZE][MAX_SIDE_SIZE];
int x_size;
int y_size;
} Level;


typedef struct Player {
int x_to;
int y_to;
} Player;

Level level;
Player player;

int object_ground=-1;
int object_blocks=-1;

float offy=-1;
float offz=3;

// fin du vrac de déclaration

char near_(int o1, int o2)
{
if(o1==object_ground && o2==object_blocks) return 0;
if(o2==object_ground && o1==object_blocks) return 0;
return 1;
}

void init_block(Block *block)
{
block->state=STATE_NONE;
block->pos[0]=0;
block->pos[1]=0;
}

void init_level(Level *level)
{
int i;
level->state=STATE_NORMAL;
level->soft_wall_model=-1;
level->description[0]=0;
level->n_spawns=0;
level->block_size=0;

for(i=0;i<MAX_SOFT_WALLS;i++)
    init_block(&level->soft_walls[i]);
}

int find_free_soft_wall(Level *level)
{
int i;

for(i=0;i<MAX_SOFT_WALLS;i++)
    if(level->soft_walls[i].state==STATE_NONE)
	break;
if(i==MAX_SOFT_WALLS) return -1;
return i;
}

void add_object_to_file(int obj, FILE *fp, GLfloat offx, GLfloat offy, GLfloat offz)
{
int i;

// file v0
for(i=raydium_object_start[obj];i<raydium_object_end[obj];i++)
    {
    fprintf(fp,"%f %f %f %f %f %s\n", raydium_vertex_x[i]+offx,
				      raydium_vertex_y[i]+offy,
				      raydium_vertex_z[i]+offz,
				      raydium_vertex_texture_u[i],
				      raydium_vertex_texture_v[i],
				      raydium_texture_name[raydium_vertex_texture[i]]);
    }

}

int build_level_from(char *from)
{
FILE *fp;
int i,j;
int ret;
char var[RAYDIUM_MAX_NAME_LEN];
char val_s[MAX_SIDE_SIZE*MAX_SIDE_SIZE+MAX_SIDE_SIZE+1];
GLfloat val_f[4];
int size;
int done;
GLfloat tx,ty,tz,tt;

char level_str[RAYDIUM_MAX_NAME_LEN];
int level_ground_texture=0;
int level_ground_texture_tile=1;
int level_wall_model=-1;

// init
level_str[0]=0;
init_level(&level);


raydium_log("*** Loading level (%s)",from);

// load
fp=raydium_file_fopen(from,"rt");

if(!fp)
    {
    raydium_log("error: cannot open '%s'",from);
    return 0;
    }

while( (ret=raydium_parser_read(var,val_s,val_f,&size,fp))!=RAYDIUM_PARSER_TYPE_EOF)
    {
    done=0;
    if(!strcasecmp(var,"level"))
	{
	if(ret!=RAYDIUM_PARSER_TYPE_RAWDATA)
	    {
	    raydium_log("level is wrong type");
	    continue;
	    }
	strcpy(level_str,val_s);
	done=1;
	}

    if(!strcasecmp(var,"description"))
	{
	if(ret!=RAYDIUM_PARSER_TYPE_STRING)
	    {
	    raydium_log("description is wrong type");
	    continue;
	    }
	strcpy(level.description,val_s);
	done=1;
	}

    if(!strcasecmp(var,"ground_texture"))
	{
	if(ret!=RAYDIUM_PARSER_TYPE_STRING)
	    {
	    raydium_log("ground_texture is wrong type");
	    continue;
	    }
	level_ground_texture=raydium_texture_find_by_name(val_s);
	done=1;
	}

    if(!strcasecmp(var,"ground_texture_tile"))
	{
	if(ret!=RAYDIUM_PARSER_TYPE_FLOAT)
	    {
	    raydium_log("ground_texture_tile is wrong type");
	    continue;
	    }
	level_ground_texture_tile=(int)*val_f;
	done=1;
	}

    if(!strcasecmp(var,"hard_wall_model"))
	{
	if(ret!=RAYDIUM_PARSER_TYPE_STRING)
	    {
	    raydium_log("hard_wall_model is wrong type");
	    continue;
	    }
	level_wall_model=raydium_object_find_load(val_s);
	done=1;
	}

    if(!strcasecmp(var,"soft_wall_model"))
	{
	if(ret!=RAYDIUM_PARSER_TYPE_STRING)
	    {
	    raydium_log("soft_wall_model is wrong type");
	    continue;
	    }
	level.soft_wall_model=raydium_object_find_load(val_s);
	done=1;
	}
    if(!done)
	raydium_log("invalid statement '%s'",var);
    }

fclose(fp);

if(!strlen(level_str))
    {
    raydium_log("error: level statement is needed");
    return 0;
    }

if(level_ground_texture==0)
    {
    raydium_log("error: ground_texture statement is needed");
    return 0;
    }

if(level_wall_model<0)
    {
    raydium_log("error: hard_wall_model statement is needed");
    return 0;
    }

if(level.soft_wall_model<0)
    {
    raydium_log("error: soft_wall_model statement is needed");
    return 0;
    }


raydium_log("*** Building level geometry");
// build level[][]
size=0;
for(i=0;i<strlen(level_str);i++)
    if(level_str[i]=='\n')
	size++;
level.y_size=size;

for(i=0;i<strlen(level_str);i++)
    if(level_str[i]=='\n')
	break;
level.x_size=i;

// - verify all lines len
for(j=0;j<level.y_size;j++)
    if(level_str[j*(level.y_size+1)+level.x_size]!='\n')
	{
	raydium_log("error: level geometry is invalid: line %i",j+1);
	return 0;
	}

// - verify side size limit
if(level.x_size > MAX_SIDE_SIZE || level.y_size > MAX_SIDE_SIZE)
    {
    raydium_log("error: level side limit exceeded : %ix%i, max is %ix%i",level.x_size,level.y_size,MAX_SIDE_SIZE,MAX_SIDE_SIZE);
    return 0;
    }


// building ...

for(j=0;j<level.y_size;j++)
    for(i=0;i<level.x_size;i++)
	{
	char b;
	int fb;
	b=level_str[(level.y_size-j-1)*((level.y_size+1))+i];
	//printf("%c",b);
	if(b==TYPE_BLOCK)
	    {
	    fb=find_free_soft_wall(&level);
	    if(fb<0)
		{
		raydium_log("error: too much soft walls (limit is %i)",MAX_SOFT_WALLS);
		return 0;
		}
	    level.soft_walls[fb].pos[0]=i;
	    level.soft_walls[fb].pos[1]=j;
	    level.soft_walls[fb].state=STATE_NORMAL;	    
	    b=TYPE_NONE;
	    }

	if(b==TYPE_SPAWN)
	    {
	    if(level.n_spawns>=RAYDIUM_NETWORK_MAX_CLIENTS)
		{
		raydium_log("error: too much spawn points (limit is %i)",RAYDIUM_NETWORK_MAX_CLIENTS);
		return 0;
		}
	    level.spawns[level.n_spawns][0]=i;
	    level.spawns[level.n_spawns][1]=j;
	    level.n_spawns++;
	    b=TYPE_NONE;
	    }
	
	level.level[i][j]=b;
	}


if(level.n_spawns < MIN_SPAWNS)
    {
    raydium_log("error: not enough spawn points (min is %i, %i found)",MIN_SPAWNS,level.n_spawns);
    return 0;
    }


raydium_object_find_axes_max(level_wall_model,&tx,&ty,&tz);
level.block_size=raydium_trigo_max(tx,ty);

// print stats
raydium_log("level: %s",level.description);
raydium_log("size: %ix%i",level.x_size,level.y_size);
raydium_log("block size: %f",level.block_size);
raydium_log("%i spawn points",level.n_spawns);

for(i=0,j=0;i<MAX_SOFT_WALLS;i++)
    if(level.soft_walls[i].state!=STATE_NONE)
	j++;
raydium_log("%i soft walls",j);


raydium_log("*** Building level mesh");
// build tri file
tx=(level.block_size*level.x_size)/2.f;
ty=(level.block_size*level.y_size)/2.f;
tt=level_ground_texture_tile/2.f;


fp=fopen("bomberfrag.tri","wt");
fprintf(fp,"0\n"); // header, version 0

// 1 - build ground
fprintf(fp,"%f %f %f %f %f %s\n",-tx,-ty,0.f, -tt,-tt, raydium_texture_name[level_ground_texture]);
fprintf(fp,"%f %f %f %f %f %s\n", tx,-ty,0.f,  tt,-tt, raydium_texture_name[level_ground_texture]);
fprintf(fp,"%f %f %f %f %f %s\n", tx, ty,0.f,  tt, tt, raydium_texture_name[level_ground_texture]);

fprintf(fp,"%f %f %f %f %f %s\n", tx, ty,0.f,  tt, tt, raydium_texture_name[level_ground_texture]);
fprintf(fp,"%f %f %f %f %f %s\n",-tx, ty,0.f, -tt, tt, raydium_texture_name[level_ground_texture]);
fprintf(fp,"%f %f %f %f %f %s\n",-tx,-ty,0.f, -tt,-tt, raydium_texture_name[level_ground_texture]);


// 2 - build walls
for(j=0;j<level.y_size;j++)
    for(i=0;i<level.x_size;i++)
	if(level.level[i][j]==TYPE_WALL)
	{
	ty=j*level.block_size-((level.y_size*level.block_size)/2.f);
	tx=i*level.block_size-((level.x_size*level.block_size)/2.f);
	add_object_to_file( level_wall_model,
			    fp,
			    tx+(level.block_size/2.f),
			    ty+(level.block_size/2.f),
			    (level.block_size/2.f) );
	}

fclose(fp);
raydium_log("*** Level: parsing and building finished");
return 1;
}


void board2world(int bx, int by, float *wx, float *wy)
{
*wx=bx*level.block_size-((level.x_size*level.block_size)/2.f);
*wy=by*level.block_size-((level.y_size*level.block_size)/2.f);

(*wx)+=(level.block_size/2.f);
(*wy)+=(level.block_size/2.f);
}

void world2board(float wx, float wy, int *bx, int *by)
{
wx-=(level.block_size/2.f);
wy-=(level.block_size/2.f);

wx+=((level.x_size*level.block_size)/2.f);
wy+=((level.y_size*level.block_size)/2.f);

*bx=wx/level.block_size;
*by=wy/level.block_size;
}



void spawn_player(void)
{
int a;
dReal *pos;

raydium_ode_object_delete_name("PLAYER");
a=raydium_ode_object_create("PLAYER");
raydium_ode_object_sphere_add("player",a,0.1,0.2f,RAYDIUM_ODE_STANDARD,0,"popestar.tri");
raydium_ode_element_material_name("player",RAYDIUM_ODE_MATERIAL_SOFT2);
raydium_ode_element_player_set_name("player",1);
//raydium_ode_motor_rocket_playermovement_name("player_react",1);
raydium_ode_element_slip_name("ground",RAYDIUM_ODE_SLIP_ICE/2.f);

//raydium_ode_element_OnBlow_name("player",blow_touched);
raydium_ode_element_move_name_3f("player",0,0,3);

pos=raydium_ode_element_pos_get_name("player");
world2board(pos[0],pos[1],&player.x_to,&player.y_to);
}


void create_blocks(void)
{
int i,a;
GLfloat tx,ty;
char name[32];

raydium_ode_object_delete_name("BOXES");
a=raydium_ode_object_create("BOXES");
object_blocks=a;

for(i=0;i<MAX_SOFT_WALLS;i++)
    if(level.soft_walls[i].state==STATE_NORMAL)
	{
	//printf("%f %f\n",level.soft_walls[i].pos[0],level.soft_walls[i].pos[1]);
	tx=level.soft_walls[i].pos[0]*level.block_size-((level.x_size*level.block_size)/2.f);
	ty=level.soft_walls[i].pos[1]*level.block_size-((level.y_size*level.block_size)/2.f);
//	raydium_camera_replace();
//	raydium_object_draw(level.soft_wall_model);

	raydium_ode_name_auto("box",name);    
	raydium_ode_network_next_local_only=1;
	raydium_ode_object_box_add(name,a,1,RAYDIUM_ODE_AUTODETECT,0,0,
				    RAYDIUM_ODE_STATIC,0,
				    raydium_object_name[level.soft_wall_model]);
	raydium_ode_element_move_name_3f(name,
					 tx+(level.block_size/2.f),
		    			 ty+(level.block_size/2.f),
					 (level.block_size/2.f));	
	}
}

void init_game(void)
{
build_level_from("bomber1.lvl");
raydium_ode_ground_set_name("bomberfrag.tri");
object_ground=raydium_ode_object_find("GLOBAL");
create_blocks();
spawn_player();
}



void step(void)
{
dReal vect[3];
dReal speed;
dReal *pos;
int x,y;

vect[0]=0.f;
vect[1]=0.f;
vect[2]=0.f;
speed=0.1;

pos=raydium_ode_element_pos_get_name("player");
world2board(pos[0],pos[1],&x,&y);

vect[0]=(player.x_to-x)*speed;
vect[1]=(player.y_to-y)*speed;

raydium_ode_element_addforce_name("player",vect);
}


void draw_game(void)
{
dReal *pos;
int x,y;

//raydium_joy_key_emul();

if(raydium_key_last==1027)
    exit(0);


pos=raydium_ode_element_pos_get_name("player");
raydium_log("%f %f",pos[0],pos[1]);
world2board(pos[0],pos[1],&x,&y);
if(x==player.x_to && y==player.y_to) // can move to another place
{
if(raydium_key[GLUT_KEY_LEFT]) player.x_to--;
if(raydium_key[GLUT_KEY_RIGHT]) player.x_to++;
if(raydium_key[GLUT_KEY_DOWN]) player.y_to--;
if(raydium_key[GLUT_KEY_UP]) player.x_to++;
}

//raydium_log("%i %i - %i %i",cx,cy,x,y);


//pos[0]=pos[1]=pos[2]=0;
raydium_camera_smooth(pos[0],pos[1]+offy,offz, pos[1],-pos[2],pos[0], 70,0,raydium_frame_time*3);
raydium_ode_draw_all(0);

}


void frame_step(GLfloat step)
{
// update timers here
}


void display(void)
{
//int i;

raydium_background_color_change(sun[0],sun[1],sun[2],sun[3]);
raydium_light_position[0][0]=50;
raydium_light_position[0][1]=150;
raydium_light_position[0][2]=200;
raydium_light_position[0][3]=1.0;

raydium_clear_frame();
glLoadIdentity();

draw_game();

raydium_osd_printf(90,2,20,0.4,"font2.tga","^c%i FPS^f",raydium_render_fps);
//raydium_osd_network_stat_draw(5,5,10);
raydium_osd_logo("logo.tga");
raydium_rendering_finish();
}

int main(int argc, char **argv)
{
raydium_init_args(argc,argv);
raydium_window_create(800,600,RAYDIUM_RENDERING_WINDOW,version);
raydium_texture_filter_change(RAYDIUM_TEXTURE_FILTER_TRILINEAR);
raydium_projection_near=0.05;
raydium_projection_far=1000;
raydium_projection_fov=70;
//raydium_fog_disable();
raydium_light_on(0);
memcpy(raydium_light_color[0],sun,raydium_internal_size_vector_float_4);
raydium_light_intensity[0]=1000000;
raydium_light_update_all(0);

strcpy(raydium_console_config_texture,"logo_console.tga");
raydium_osd_cursor_set("BOXcursor.tga",4,4);
raydium_sky_box_cache();
raydium_register_api();

raydium_timecall_add(frame_step,-1);
raydium_ode_ObjectNearCollide=near_;
raydium_ode_StepCallback=step;
raydium_register_variable(&offy,RAYDIUM_REGISTER_FLOAT,"offy");
raydium_register_variable(&offz,RAYDIUM_REGISTER_FLOAT,"offz");

init_game();

raydium_callback(&display);
return 0;
}