/**
* The game loop, this function is called periodically to update the game.
*/
void game_loop()
{
static int last_time = -1;
int delta, now;
/* Update the game */
now = GET_CURRENT_TIME();
if( last_time == -1 )
{
last_time = now;
return;
}
// Get the time since the last update (minimum of one millisecond)
delta = 1 + now - last_time; // TODO: remove the 1
update_world(delta);
/* Update the render module */
render_update(delta);
/* Render the game */
render();
last_time = now;
}
static void game_draw(context *ctx)
{
struct game_context *game = (struct game_context *)ctx;
struct config_info *conf = get_config();
struct world *mzx_world = ctx->world;
// No game state change has happened (yet)
mzx_world->change_game_state = CHANGE_STATE_NONE;
if(game->is_title && game->fade_in)
{
// Focus on center
int x, y;
set_screen_coords(640/2, 350/2, &x, &y);
focus_pixel(x, y);
}
if(!mzx_world->active)
{
// There is no MZX_SPEED to derive a framerate from, so use the UI rate.
set_context_framerate_mode(ctx, FRAMERATE_UI);
if(!conf->standalone_mode)
draw_intro_mesg(mzx_world);
m_show();
return;
}
set_context_framerate_mode(ctx, FRAMERATE_MZX_SPEED);
update_world(ctx, game->is_title);
draw_world(ctx, game->is_title);
}
int main(int argc, char** argv) {
uint32_t last_frame_time = 0;
uint32_t width = 640;
uint32_t height = 480;
bool quit = false;
SDL_Window* window = NULL;
SDL_Renderer* ren = NULL;
SDL_Texture* texture = NULL;
static uint32_t* pxbuf = NULL;
static uint8_t* bug_data = NULL;
//Initialize game
pxbuf = new uint32_t[width*height];
bug_data = new uint8_t[width*height];
memset(pxbuf, 0x00, width*height);
memset(bug_data, 0x00, width*height);
if(init_sdl(width, height, &window, &ren, &texture)) {
return 1;
} printf("SDL successfully initialized.\n");
while (!quit) {
last_frame_time = SDL_GetTicks();
if (process_events() == -1) {
quit = true;
}
update_bugs(width, height, bug_data);
update_world(width, height, pxbuf, bug_data, texture);
draw_world(width, height, texture, ren);
printf("FPS: %f \r", 1000./(SDL_GetTicks()-last_frame_time));
}
SDL_Quit();
return 0;
}
void
move_pt(int id, int x, int y, xgobidata *xg) {
int i, k;
if (mpdir_type == horiz || mpdir_type == both)
xg->screen[id].x = x;
if (mpdir_type == vert || mpdir_type == both)
xg->screen[id].y = y;
/* Move the selected point */
screen_to_plane(xg, id, &eps,
(mpdir_type == horiz || mpdir_type == both),
(mpdir_type == vert || mpdir_type == both));
move_pt_pipeline(id, &eps, xg); /*-- eps won't be changed here --*/
/* Move all points with same glyph as the selected point */
if (move_type == 1) {
for (i=0; i<xg->nrows_in_plot; i++) {
k = xg->rows_in_plot[i];
if (k!=id && !xg->erased[k] && SAMEGLYPH(k,id)) {
if (mpdir_type == horiz || mpdir_type == both) { xg->planar[k].x += eps.x; }
if (mpdir_type == vert || mpdir_type == both) { xg->planar[k].y += eps.y; }
move_pt_pipeline(k, &eps, xg);
}}} /* sorry AB */
/* Move ALL points */
if (move_type == 2) {
for (i=0; i<xg->nrows_in_plot; i++) {
k = xg->rows_in_plot[i];
if (k!=id && !xg->erased[k]) {
if (mpdir_type == horiz || mpdir_type == both) { xg->planar[k].x += eps.x; }
if (mpdir_type == vert || mpdir_type == both) { xg->planar[k].y += eps.y; }
move_pt_pipeline(k, &eps, xg);
}}} /* sorry AB */
/* and now forward again, all the way ... */
update_world(xg);
world_to_plane(xg);
plane_to_screen(xg);
if (xg->is_brushing) {
assign_points_to_bins(xg);
if (xg->brush_mode == transient)
reinit_transient_brushing(xg);
}
plot_once(xg);
if (xg->is_cprof_plotting && xg->link_cprof_plotting)
update_cprof_plot(xg);
}
static void test_json_report(CuTest * tc) {
region * r;
faction * f;
unit * u;
cJSON * json;
cleargame(true);
turn = 0;
r = create_region(0, 1, 1, create_terrain("plain"));
f = addplayer(r, 0, 0);
u = r->units;
update_world(0, 0, 1, 1);
json = json_report(f);
CuAssertIntEquals(tc, turn, cJSON_GetObjectItem(json, "turn")->valueint);
free(json);
}
void loop_iter()
{
clock_t time = clock();
double delta = (double)(time - last_time)/(CLOCKS_PER_SEC/1000.0);
last_time = time;
reset_input_state();
update_input();
update_world(delta);
#ifdef __EMSCRIPTEN__
if (done) {
emscripten_cancel_main_loop();
}
#endif
}
void
update_server(server_t *server)
{
struct timeval t1;
gettimeofday(&t1, NULL);
double t0f = (double)server->t.tv_sec +
(double)server->t.tv_usec / 1000 / 1000;
double t1f = (double)t1.tv_sec +
(double)t1.tv_usec / 1000 / 1000;
double dt = t1f - t0f;
if (t0f > 0)
update_world(server->world, dt);
gettimeofday(&server->t, NULL);
}
void update_all(int gno)
{
update_set_lists(gno);
update_world(gno);
update_view(gno);
update_status(gno, cur_statusitem, -1);
update_ticks(gno);
update_autos(gno);
updatelegends(gno);
updatesymbols(gno, -1);
update_label_proc();
update_locator_items(gno);
update_draw();
update_frame_items(gno);
update_graph_items();
update_hotlinks();
}
int main(int argc, char* argv[])
{
char buffer[2048]; /* string buffer for self-control list */
signal(SIGINT, SIG_IGN);
vrConfigure(&argc, argv, NULL);
vrStart();
signal(SIGINT, exit_application);
/* TODO: it would be nice to put these above vrStart(), since */
/* it will block until all input devices are open, and this */
/* way we could be rendering something while waiting. */
/* TODO: actually, we almost *need* to have the init_gfx stuff*/
/* set before vrStart, so the window opening function will */
/* have something to call (other than vrDoNothing()). */
/* In fact, I have no idea how init_gfx() gets called at */
/* all given the current setup. */
vrFunctionSetCallback(VRFUNC_ALL_DISPLAY_INIT, vrCallbackCreate(init_gfx, 0));
vrFunctionSetCallback(VRFUNC_ALL_DISPLAY, vrCallbackCreate(draw_server_world, 0));
vrFunctionSetCallback(VRFUNC_HANDLE_USR2, vrCallbackCreate(vrDbgInfo, 0));
if (vrContext->input->num_input_devices > 0) {
vrDbgPrintfN(SELDOM_DBGLVL+1, "input viewer: input device[0] version = '%s'\n",
vrContext->input->input_devices[0]->version);
} else {
vrDbgPrintfN(SELDOM_DBGLVL+1, "input viewer: No input devices defined.\n");
}
vrSystemSetName("inputs -- FreeVR inputs display application");
vrSystemSetAuthors("Bill Sherman");
list_self_controls(buffer, vrContext->input, sizeof(buffer), verbose);
vrPrintf(buffer);
vrSystemSetExtraInfo(buffer);
vrDbgPrintf("input viewer: looping\n");
while(vrFrame()) {
update_world();
}
exit_application();
exit(0);
}
void EXP_Class::adv ( void ){
//cout << "enter advance" << endl;
if( viewing ) stop_iterations_loop( );
update_sensors( );//here you compute the input vector
update_controllers ( ); //here you update the controllers and you generate a new output vector
if( viewing ) param->eye->view_eye_movement();
update_world(); //Here you call the set eye fucntion to upadte the eye position given the output vector
//manage_collisions ( );
compute_fitness();
iter++;
//cout << "leave advance" << endl;
}
void
reset_plot1d_type(xgobidata *xg)
{
XtVaSetValues(plot1d_type_cmd[DOTPLOT],
XtNstate, plot1d_type == DOTPLOT,
NULL);
setToggleBitmap(plot1d_type_cmd[DOTPLOT], plot1d_type == DOTPLOT);
XtVaSetValues(plot1d_type_cmd[ASH],
XtNstate, plot1d_type == ASH,
NULL);
setToggleBitmap(plot1d_type_cmd[ASH], plot1d_type == ASH);
XtSetSensitive(nASHes_sbar, plot1d_type == ASH);
plot1d_texture_var(xg);
update_world(xg);
world_to_plane(xg);
plane_to_screen(xg);
init_ticks(&xg->plot1d_vars, xg);
plot_once(xg);
}
void update() {
update_world();
for (int i = 0; i < 10; i++) {
update_enemy(i);
}
}
/**
* Starting point for the program.
*
* @param argc The number of command line arguments.
* @param argv The array of command line arguments.
* @return Program exit status.
*/
int main(int argc, char **argv) {
SDL_Window *win = NULL;
SDL_Renderer *rend = NULL;
SDL_Texture *tex_player = NULL;
if(init(&win, &rend, &tex_player)) {
return 1;
}
Game_Data game_data;
game_data.battle_data.state = GAME_BATTLE_MOVE;
game_data.battle_data.num_units = 2;
game_data.battle_data.board.tiles
= malloc(GRID_COLS * GRID_ROWS * sizeof *game_data.battle_data.board.tiles);
game_data.battle_data.turn_order =
malloc(game_data.battle_data.num_units
* sizeof *game_data.battle_data.turn_order);
game_data.battle_data.camera_pos = (Coord_f){0.0, 0.0};
game_data.battle_data.camera_vel = (Coord_f){0.0, 0.0};
game_data.battle_data.board.cols = GRID_COLS;
game_data.battle_data.board.rows = GRID_ROWS;
game_data.battle_data.turn = 0;
for(int i = 0; i < GRID_COLS; i++)
for(int j = 0; j < GRID_ROWS; j++) {
game_data.battle_data.board.tiles[j * GRID_COLS + i].ent = NULL;
}
SDL_Event event;
Battle_Entity *temp;
temp = game_data.battle_data.board.tiles[10 * GRID_ROWS + 5].ent
= malloc(sizeof(Battle_Entity));
temp->img.tex = tex_player;
temp->img.dest_x = 5.0 * WIN_WIDTH / GRID_ROWS;
temp->img.dest_y = 10.0 * WIN_HEIGHT / GRID_COLS;
temp->img.dest_w = WIN_WIDTH / GRID_ROWS;
temp->img.dest_h = WIN_HEIGHT / GRID_COLS;
temp->img.src_x = 0.0;
temp->img.src_y = 0.0;
temp->img.src_w = 0.0;
temp->img.src_h = 0.0;
temp->team = TEAM_SELECTED;
temp->pos = (Coord_f){10.0, 5.0};
temp->vel = (Coord_f){0.0, 0.0};
temp->move_queue.key_size = 0;
temp->move_queue.head = NULL;
game_data.battle_data.turn_order[0] = temp;
temp = game_data.battle_data.board.tiles[19 * GRID_ROWS + 19].ent
= malloc(sizeof(Battle_Entity));
temp->img.tex = tex_player;
temp->img.dest_x = 19.0 * WIN_WIDTH / GRID_ROWS;
temp->img.dest_y = 19.0 * WIN_HEIGHT / GRID_COLS;
temp->img.dest_w = WIN_WIDTH / GRID_ROWS;
temp->img.dest_h = WIN_HEIGHT / GRID_COLS;
temp->img.src_x = 0.0;
temp->img.src_y = 0.0;
temp->img.src_w = 0.0;
temp->img.src_h = 0.0;
temp->team = TEAM_SELECTED;
temp->pos = (Coord_f){19.0, 19.0};
temp->vel = (Coord_f){0.0, 0.0};
temp->move_queue.key_size = 0;
temp->move_queue.head = NULL;
game_data.battle_data.turn_order[1] = temp;
game_data.battle_data.keys = 0;
double time = SDL_GetTicks();
while(game_data.battle_data.state != GAME_STOPPED) {
SDL_RenderClear(rend);
while(SDL_PollEvent(&event)) {
handle_event(&event, &game_data);
}
update_world(&game_data, SDL_GetTicks() - time);
time = SDL_GetTicks();
render(rend, &game_data);
SDL_RenderPresent(rend);
}
free(game_data.battle_data.board.tiles[10 * GRID_ROWS + 5].ent);
free(game_data.battle_data.board.tiles[19 * GRID_ROWS + 19].ent);
SDL_DestroyTexture(tex_player);
SDL_DestroyRenderer(rend);
SDL_DestroyWindow(win);
SDL_Quit();
return 0;
}
static void
tform_response(xgobidata *xg, int *cols, int ncols)
{
int j, n;
/*
Boolean reset_vgroups = false;
*/
/*
* Reset vgroups?
*/
/* gid = xg->vgroup_ids[cols[0]];
for (n=1; n<ncols; n++) {
if (xg->vgroup_ids[cols[n]] != gid) {
reset_vgroups = true;
break;
}
}
if (reset_vgroups) {
gid = numvargroups(xg)+1;
for (n=0; n<ncols; n++) {
xg->vgroup_ids[cols[n]] = gid;
}
resort_vgroup_ids(xg, xg->vgroup_ids);
}*/
if (xg->ncols_used > 2)
update_sphered(xg, cols, ncols);
update_lims(xg);
update_world(xg);
/* if (xg->is_xyplotting) - bug fix di 4/19/2000*/
if (xg->is_plotting1d)
plot1d_texture_var(xg);
world_to_plane(xg);
plane_to_screen(xg);
/*
This bit of init_axes() is needed.
*/
for (n=0; n<ncols; n++) {
j = cols[n];
xg->nicelim[j].min = xg->lim0[j].min;
xg->nicelim[j].max = xg->lim0[j].max;
SetNiceRange(j, xg);
xg->deci[j] = set_deci(xg->tickdelta[j]);
}
if (xg->is_xyplotting) {
init_ticks(&xg->xy_vars, xg);
}
else if (xg->is_plotting1d)
init_ticks(&xg->plot1d_vars, xg);
if (xg->is_brushing) {
assign_points_to_bins(xg);
if (xg->brush_mode == transient)
reinit_transient_brushing(xg);
}
plot_once(xg);
if (xg->is_cprof_plotting)
update_cprof_plot(xg);
}
void
plot1d_on(xgobidata *xg)
/*
* Turn on and off the plot1d mode.
*/
{
int j;
Boolean cycle_on;
extern xgobidata xgobi;
int jvar = (plot1d_vertically) ? xg->plot1d_vars.y : xg->plot1d_vars.x;
/*
* If this mode is currently selected, turn it off.
*/
if (xg->prev_plot_mode == PLOT1D_MODE && xg->plot_mode != PLOT1D_MODE) {
map_plot1d(False);
xg->is_plot1d_cycle = False;
if (cycle_timeout_id)
{
XtRemoveTimeOut(cycle_timeout_id);
cycle_timeout_id = 0L;
}
}
/* Else turn it on */
else if (xg->plot_mode == PLOT1D_MODE &&
xg->prev_plot_mode != PLOT1D_MODE)
{
map_plot1d(True);
if (!xg->is_plotting1d) {
if (xg->is_touring && xg->is_princ_comp) {
set_sph_labs(xg, xg->nsph_vars);
xg->is_touring = False;
/* reset_var_labels(xg, PRINCCOMP_OFF);i think not needed anymore
sphering transformation*/
}
if (xg->carry_vars)
carry_plot1d_vars(xg);
xg->is_xyplotting = xg->is_spinning = xg->is_touring = False;
xg->is_plotting1d = True;
xg->is_corr_touring = False;
plot1d_data = (float *) XtMalloc( (Cardinal)
xg->nrows_in_plot * sizeof(float));
plot1d_texture_var(xg);
update_lims(xg);
update_world(xg);
world_to_plane(xg);
plane_to_screen(xg);
init_ticks(&xg->plot1d_vars, xg);
plot_once(xg);
/*
* Reinitialize the sin and cos variables. Why???
*/
init_trig(xg);
for (j=0; j<xg->ncols; j++) {
if (j == jvar)
xg->varchosen[j] = True;
else
xg->varchosen[j] = False;
}
set_varsel_label(xg);
refresh_vboxes(xg);
}
/*
* If the cycle button is activated, start cycling.
*/
XtVaGetValues(plot1d_cycle_cmd, XtNstate, &cycle_on, NULL);
if (cycle_on) {
xg->is_plot1d_cycle = True;
(void) XtAppAddWorkProc(app_con, RunWorkProcs, (XtPointer) NULL);
}
}
setToggleBitmap(plot1d_cycle_cmd, xg->is_plot1d_cycle);
}
int goSomewhere(struct state *s, char **a, int penalty){
int i,j, is, js, k, wx=0, wy=0, stage=-1;
unsigned int change = 0, end = 0;
struct state *ns;
char * answer;
char move='U';
unsigned int *c = malloc( ((s-> world_w+1) * s->world_h+1) * sizeof( unsigned int ));
if (c == NULL ){}
for(i=0; i<((s-> world_w+1) * s->world_h+1); i++){
c[i]=UINT_MAX;
}
c[point_to_index(s, s->robot_x, s->robot_y)]=0;
put(s, 1, 1, O_EMPTY);
move_robot(s, 1, 1);
ns = copy(s);
do{
free(s);
s = copy(ns);
update_world(ns, s);
change++;
stage++;
end = 0;
for(i=1; i <= s->world_w; i++){
for(j=1; j <= s->world_h; j++){
if(c[point_to_index(s,i,j)]==stage){
if(get(s, i, j) == O_LIFT_OPEN || get(s, i, j) == O_LAMBDA){
wx=i;
wy=j;
end=stage;
break;
}
//consider four cells - (-1, 0), (1, 0), (0, -1), (0, 1)
for(k = 1; k<=4; k++){
if(k==1) {is= 0 ; js=-1;}
if(k==2) {is= 0 ; js= 1;}
if(k==3) {is=-1 ; js= 0;}
if(k==4) {is= 1 ; js= 0;}
if(bounded(s,i+is,j+js) && c[point_to_index(s, i+is, j+js)]==UINT_MAX){
//can we go there?
if( !bounded(s, i+is, j+js+1) || (get(s, i+is, j+js+1) != O_EMPTY || get(ns, i+is, j+js+1) != O_ROCK)){
if(get(s, i+is, j+js)==O_LIFT_OPEN
|| get(s, i+is, j+js)==O_LAMBDA
|| get(s, i+is, j+js)==O_EARTH
|| get(s, i+is, j+js)==O_EMPTY){
if((bounded(s, i+is, j+js+1) && get(s, i+is, j+js+1)==O_ROCK)
|| (bounded(s, i+is+1, j+js+1) && get(s, i+is+1, j+js)==O_ROCK && get(s, i+is+1, j+js+1)==O_ROCK)
|| (bounded(s, i+is-1, j+js+1) && get(s, i+is-1, j+js)==O_ROCK && get(s, i+is-1, j+js+1)==O_ROCK)){
c[point_to_index(s, i+is, j+js)]=stage+penalty;
}else{
c[point_to_index(s, i+is, j+js)]=stage+1;
}
change = 0;
}
}
}
}
}
}
}
}while(change <= penalty && end == 0);
//debug
//dump(s);
if(0){
for(j=s->world_h; j>0; j--){
for(i=1; i<=s->world_w; i++){
if(c[point_to_index(s, i, j)]==UINT_MAX){
printf("X");
}else{
printf("%u", c[point_to_index(s, i, j)]);
}
}
printf("\n");
}
printf("\n");
}
i=0;
if(end>0){
answer = malloc( (end+2)*sizeof( char ));
if (answer == NULL ){}
while(end>0){
for(k=1; k<=4;k++){
if(k==1) {is=-1; js= 0;move='R';}
if(k==2) {is= 1; js= 0;move='L';}
if(k==3) {is= 0; js=-1;move='U';}
if(k==4) {is= 0; js= 1;move='D';}
if( bounded(s, wx+is, wy+js) && c[point_to_index(s, wx+is, wy+js)] < end) {
end = c[point_to_index(s, wx+is, wy+js)];
answer[i++]=move;
wx = wx+is;
wy = wy+js;
break;
}
}
}
answer[i]='\0';
reverse(answer,0,strlen(answer)-1);
}else{
answer = malloc(1*sizeof( char ));
if (answer == NULL ){}
answer[0]='\0';
*a=answer;
free(c);
return 1;
}
*a=answer;
free(c);
return 0;
}
int main(int argc, char* argv[])
{
/* TODO: do I want to ignore interrupts for all of this? or */
/* just during vrStart()? */
//signal(SIGINT, SIG_IGN);
vrShmemInit(30 * 1024 * 1024);
vrConfigure(&argc, argv, NULL);
/* TODO: it would be nice to put these above vrStart(), since */
/* it will block until all input devices are open, and this */
/* way we could be rendering something while waiting. */
/* TODO: actually, we almost *need* to have the init_gfx stuff*/
/* set before vrStart, so the window opening function will */
/* have something to call (other than vrDoNothing()). */
/* In fact, I have no idea how init_gfx() gets called at */
/* all given the current setup. */
/* [5/30/00: I have now moved the function setting routines to*/
/* come before vrStart(). The library needs to be changed */
/* such that the incoming callbacks are stored in a holding */
/* bin, until the render/input/whatever loop is ready to */
/* update them. */
#if 1
/* TODO: unfortunately this shorthand doesn't work when there are extra */
/* arguments but these work okay. */
vrCallbackSet(VRFUNC_DISPLAY_INIT, "init_gfx", init_gfx, 0);
vrCallbackSet(VRFUNC_DISPLAY_FRAME, "gfx_frame", gfx_frame, 0);
vrCallbackSet(VRFUNC_DISPLAY, "draw_world", draw_world, 0);
vrCallbackSet(VRFUNC_DISPLAY_SIM, "my_sim", my_sim, 0);
vrCallbackSet(VRFUNC_HANDLE_USR2, "travel:vrDbgInfo", vrDbgInfo, 0);
#else
# if 1 /* 1/4/2003: test of possible startup race condition */
vrSetFunc(VRFUNC_DISPLAY_INIT, vrCreateNamedCallback("init_gfx", init_gfx, 0));
# endif
vrSetFunc(VRFUNC_DISPLAY, vrCreateNamedCallback("draw_world", draw_world, 0));
# ifdef PERSONAL_SIMULATOR
vrSetFunc(VRFUNC_DISPLAY_SIM, vrCreateNamedCallback("my_sim", my_sim, 0));
# endif
vrSetFunc(VRFUNC_HANDLE_USR2, vrCreateNamedCallback("travel:vrDbgInfo", vrDbgInfo, 0));
#endif
vrStart();
signal(SIGINT, exit_application);
if (vrContext->input->num_input_devices > 0) {
vrDbgPrintfN(SELDOM_DBGLVL+1, "TRAVEL: input device[0] version = '%s'\n",
vrContext->input->input_devices[0]->version);
} else {
vrDbgPrintfN(SELDOM_DBGLVL+1, "TRAVEL: No input devices defined.\n");
}
#if 0
if (vrDbgDo(AALWAYS_DBGLVL+1)) {
vrFprintContext(stdout, vrContext, verbose);
vrFprintConfig(stdout, vrContext->config, verbose);
vrFprintInput(stdout, vrContext->input, verbose);
}
#endif
if(vrContext->input->num_input_devices > 0)
vrDbgPrintf("TRAVEL: input device[0] version = '%s'\n",
vrContext->input->input_devices[0]->version);
#if 0 /* NOTE: this isn't really necessary, so don't use for non-test applications */
update_world();
vrInputWaitForAllInputDevicesToBeOpen();
#endif
vrSystemSetName("travel -- FreeVR test program");
vrSystemSetAuthors("Bill Sherman");
vrSystemSetExtraInfo("A really good program for testing the FreeVR library");
vrSystemSetStatusDescription("Application running fine");
vrInputSet2switchDescription(0, "Terminate the application");
vrInputSet2switchDescription(1, "Reset User Travel");
vrInputSet2switchDescription(2, "Move User 0.1 to the right");
vrInputSet2switchDescription(3, "Move User 0.1 to the left");
vrInputSetValuatorDescription(0, "Rotate User");
vrInputSetValuatorDescription(1, "Move User in direction of Wand");
#if 0 /* for testing */
vrInputSetNswitchDescription(0, "Do something with a switch");
vrInputSetNsensorDescription(0, "Do something with an N-sensor");
vrInputSet6sensorDescription(0, "Move the Head");
vrInputSet6sensorDescription(1, "Move the Wand");
#endif
vrDbgPrintf("TRAVEL: looping\n");
#if 1
while(vrFrame()) {
update_world();
}
#else /* run for two frames and then quit */
vrFrame();
update_world();
vrFrame();
update_world();
#endif
vrPrintf(BOLD_TEXT "TRAVEL: I guess we're all done now.\n" NORM_TEXT);
exit_application();
exit(0);
}
int main(int argc, char **argv)
{
world_t world;
game_t game;
double last_time = 0;
double current_time = 0;
float deltatime = 0;
float sleep_time;
if (config_from_file("anko.cfg", 1) == 2)
return EXIT_FAILURE;
if (config_from_args(argc, argv))
return EXIT_FAILURE;
if (!init())
goto err_init;
if (!new_game(&game, config.board_width, config.board_height, &config.gen_params, config.sim_speed * 1000))
goto err_game;
if (!create_world(&world, &game))
goto err_world;
if ((current_ui = init_ui_game(&world)) == NULL)
goto err_ui;
world_set_active_player(&world, add_player(&game, TEAM_BURNER));
events_link_frame(¤t_ui); // link window event to game ui frame
glClearColor(0, 0, 0, 1);
last_time = 0;
while(!glfwWindowShouldClose(window)) {
current_time = glfwGetTime();
deltatime = current_time - last_time;
update_speed(deltatime);
glfwPollEvents();
// Update
update_ui(current_ui, deltatime);
update_world(&world);
if (update_game(&game, deltatime * 1000))
refresh_world(&world);
if(should_quit)
glfwSetWindowShouldClose(window, GL_TRUE);
// Rendering
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
draw_ui(current_ui);
font_swap_buffers();
glfwSwapBuffers(window);
// Update speed and sleep if necessary
last_time = current_time;
sleep_time = (current_time + MAX_MSPF - glfwGetTime()) * 1000 * 1000;
if(sleep_time > 0)
usleep(sleep_time);
}
destroy_ui(current_ui);
game_over(&game);
end_of_the_world(&world); // Tin tin tin
terminate();
return EXIT_SUCCESS;
err_ui:
end_of_the_world(&world);
err_world:
game_over(&game);
err_game:
terminate();
err_init:
return EXIT_FAILURE;
}
