Ejemplo n.º 1
0
int main(int argc, char *argv[]) {
    video_init(0);
    audio_init(argc, argv);
    game_init();

    double last = glfwGetTime();

    while (running) {
        double current = glfwGetTime();
        int delta = (current - last) * 1000;
        if (delta < MIN_DELTA) {
            glfwSleep((MIN_DELTA-delta)/1000.0);
            continue;
        }

        last = current;
        now += delta;
        if (delta > MAX_DELTA)
            continue;

        game_tick(delta);
    }

    audio_shutdown();
    video_shutdown();
    return EXIT_SUCCESS;
}
Ejemplo n.º 2
0
Archivo: main.c Proyecto: tjk/pokelike
int main(void)
{
    // initialize stdlib things
    signal(SIGINT, _finish);
    srand(time(NULL));
    atexit(_exit_cb);

    // initialize ncurses
    initscr();
    keypad(stdscr, true);
    nonl();
    cbreak(); // TODO use raw() and handle CTRL inputs manually (no signal)
    noecho();
    curs_set(false);
    nodelay(stdscr, true);
    // TODO support no color mode (just investigate if attron works)
    if (!has_colors()) {
        FPRINTF(stderr, "ncurses colors not supported\n");
        exit(EXIT_FAILURE);
    }
    start_color();
    init_pair(COLOR__GRASS, COLOR_WHITE, COLOR_GREEN);
    init_pair(COLOR__HP_GOOD, COLOR_GREEN, COLOR_GREEN);
    init_pair(COLOR__HP_WARNING, COLOR_YELLOW, COLOR_YELLOW);
    init_pair(COLOR__HP_DANGER, COLOR_RED, COLOR_RED);

    names_init();

    struct game game;
    audio_init(&game.audio);
    game_init(&game);

    // TODO clean this up
    struct map_chunk chunk;
    map_chunk_init(&chunk);
    game.chunk = &chunk;

    // TODO improve game loop
    // - "rendering" and update tick do not need to have same rate
    // - fix input triggering after letting go, etc.
    for (;;) {
        int c = getch();
        game_handle_input(&game, c);

        game_tick(&game);

        game_render(&game);
        ++game.frame;

        usleep(100000);
    }

    // clean up audio
    audio_destroy(&game.audio);

    return EXIT_SUCCESS;
}
Ejemplo n.º 3
0
int game_thread( void * _parms ) {
  GameThreadParms * parms = (GameThreadParms*)_parms;

  GameState gs;
  SharedRenderState rs;

  game_init( gs, rs );

  gs.zmq_control_socket = zsocket_new( parms->zmq_context, ZMQ_PAIR );
  {
    int ret = zsocket_connect( gs.zmq_control_socket, "inproc://control_game" );
    assert( ret == 0 );
  }
  
  gs.zmq_render_socket = zsocket_new( parms->zmq_context, ZMQ_PAIR );
  zsocket_bind( gs.zmq_render_socket, "inproc://game_render" );

  gs.zmq_input_req = zsocket_new( parms->zmq_context, ZMQ_REQ );
  {
    int ret = zsocket_connect( gs.zmq_input_req, "inproc://input" );
    assert( ret == 0 );
  }

  unsigned int baseline = SDL_GetTicks();
  int framenum = 0;
  while ( true ) {
    unsigned int now = SDL_GetTicks();
    unsigned int target_frame = ( now - baseline ) / GAME_DELAY;
    if ( framenum <= target_frame ) {
      framenum++;
      // NOTE: build the state of the world at t = framenum * GAME_DELAY,
      // under normal conditions that's a time in the future
      // (the exception to that is if we are catching up on ticking game frames)
      game_tick( now, gs, rs );
      // notify the render thread that a new game state is ready.
      // on the next render frame, it will start interpolating between the previous state and this new one
      zstr_sendf( gs.zmq_render_socket, "%d %f %f %f %f %f %f %f %f %f", baseline + framenum * GAME_DELAY, rs.position.x, rs.position.y, rs.orientation.w, rs.orientation.x, rs.orientation.y, rs.orientation.z, rs.smoothed_angular.x, rs.smoothed_angular.y, rs.smoothed_angular.z );
    } else {
      int ahead = framenum * GAME_DELAY - ( now - baseline );
      assert( ahead > 0 );
      printf( "game sleep %d ms\n", ahead );
      SDL_Delay( ahead );
    }
    char * cmd = zstr_recv_nowait( gs.zmq_control_socket );
    if ( cmd != NULL ) {
      assert( strcmp( cmd, "stop" ) == 0 );
      free( cmd );
      break;
    }
  }
  return 0;
}
Ejemplo n.º 4
0
Archivo: pong.c Proyecto: reagent/pong
int main(int argc, char *argv[]) {
    struct timeval start_time;

    gettimeofday(&start_time, NULL);

    Game *game = game_init(start_time);

    while(1) { game_tick(game); }

    game_destroy(game);

    return 0;
}
Ejemplo n.º 5
0
int main()
{
	srvInit();
	aptInit();
	hidInit(NULL);
	irrstInit(NULL);
	gfxInitDefault();

	yeti_init(
		&yeti,
		(framebuffer_t*)gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL),
		(framebuffer_t*)gfxGetFramebuffer(GFX_TOP, GFX_LEFT, NULL, NULL),
		textures, palette, lua
	);

	gfxSet3D(true);

	game_init(&yeti);

	while(aptMainLoop())
	{
		int i;
		for(i=0;i<2;i++)
		{
			yeti.viewport.front = yeti.viewport.back;
			yeti.viewport.back = (framebuffer_t*)gfxGetFramebuffer(GFX_TOP, leftOrRight?GFX_LEFT:GFX_RIGHT, NULL, NULL);

			game_draw(&yeti);

			leftOrRight^=1;
		}

		yetiUpdateKeyboard(&yeti);
		game_tick(&yeti);

		if(hidKeysDown()&KEY_START)break;

		gfxFlushBuffers();
		gfxSwapBuffers();

		gspWaitForEvent(GSPEVENT_VBlank0, true);
	}

	gfxExit();
	irrstExit();
	hidExit();
	aptExit();
	srvExit();
	return 0;
}
Ejemplo n.º 6
0
void update(void) {
    All * a = global_a;
#line 175
    if (land_was_resized()) {
#line 177
        viewport_update(game->viewport, land_display_width(), land_display_height());
        a->resize_in_ticks = 10;
    }
    if (a->resize_in_ticks > 0) {
        a->resize_in_ticks--;
        if (a->resize_in_ticks == 0) {
            reload_fonts();
        }
    }
#line 185
    if (a->load_after_redraw) {
        if (a->load_after_redraw == 2) {
#line 188
            load_level(a->editor || game->record->is_replaying || game->record->is_recording);
            if (a->find_entrance) {
                a->find_entrance = 0;
                if (game->player) {
                    player_find_entrance(& game->player->super);
                }
            }
#line 193
            if (game && game->player) {
#line 195
                record_load(game->record, game->level, game->player->super.x, game->player->super.y, game->player->super.z);
            }
#line 196
            a->load_after_redraw++;
        }
#line 196
        return ;
    }
#line 199
    config_check_controls(a);
#line 201
    if (a->title) {
        title_tick();
    }
#line 202
    else {
#line 204
        game_tick(game);
    }
}
Ejemplo n.º 7
0
int main() {
  SDL_Event event;
  SDL_Window* window;
  t_game* game;
  int cont;

  window = create_window();
  game = game_init(window);
  for (cont = 1; cont;) {
    while (SDL_PollEvent(&event))
      if (event.type == SDL_QUIT)
        cont = 0;
      else if (event.type == SDL_KEYDOWN)
        event_keydown(event, game);
    if (cont)
      game_tick(game);
  }
  game_quit(game);
  return 0;
}
Ejemplo n.º 8
0
void GW_GameEngine_VTech::do_timer(int timerid)
{
#ifdef GW_DEBUG
    GWDBG_FVOUTPUT("GW_GameEngine_VTech::do_timer(timerid %i)\n", timerid);
#endif
    switch (timerid)
    {
    case TMR_GAMESTART:
        data_starttimer(TMR_GAME);
        break;
    case TMR_GAME:
        game_tick();
        break;
    case TMR_REPRISE:
        game_reprise();
        canmove_=true;
        data_starttimer(TMR_GAME);
        break;
    case TMR_GAMEOVER:
        // game is over: play "Game Over" tune, then freeze for 30 seconds, and finally
        // change mode to "Time 1", if no button is pressed
        game_over();


        data_starttimer(TMR_GAMEOVERSOUND);
        data_starttimer(TMR_GAMEOVERWAIT);
        break;
    case TMR_GAMEOVERSOUND:
        gameover_=true;
        break;
    case TMR_GAMEOVERWAIT:
        //gameover_=true;
        SetMode(MODE_TIME1);
        break;
    }
}
Ejemplo n.º 9
0
void play_single_player()
{
  time_stepms = 4;
  time_step = 0.004f;
  spbg = get_image("spbg.png");

  for(;;)
  {
    Uint32 last_tick = SDL_GetTicks();
    first_tick = last_tick;
    last_avalanche = last_tick;

    init_field();

    SDL_BlitSurface(spbg, 0, screen, 0);

    while(state == GS_NEUTRAL)
    {
      SDL_Event event;

      now = SDL_GetTicks();

      while(now >= last_tick + time_stepms)
      {
        /* Skip delays larger than 5s */
        if(now - last_tick > 5000)
          last_tick = now - 5000;

        last_tick += time_stepms;

        game_tick(now - last_tick < time_stepms);
      }

      while(SDL_PollEvent(&event))
      {
        switch(event.type)
        {
        case SDL_QUIT:

          exit(EXIT_SUCCESS);

          break;

        case SDL_JOYBUTTONDOWN:
          if (event.jbutton.button  == 15 || event.jbutton.button == 0)/* Code same as SDLK_SPACE */
             {
               if(state == GS_NEUTRAL)
                 {
                   if(level < sizeof(levels) / sizeof(levels[0]))
                     {
                       bonus += levels[level].shoot_bonus;
                       shoot(&p, random_bubble(&p), (levels[level].mode == GM_INV_GRAVITY) ? 400 : -1);
                     }
                   else
                     shoot(&p, random_bubble(&p), -1);
                 }            
             }
          if (event.jbutton.button  == 13 || event.jbutton.button == 2)/* Code same as SDLK_ESCAPE */
             {
               if(level == 255)
                 level = saved_level;

#if LINUX || DARWIN
               if(getenv("HOME"))
                 {
                   char confpath[4096];
                   strcpy(confpath, getenv("HOME"));
                   strcat(confpath, "/.pengupoprc");
                   int fd = open(confpath, O_WRONLY | O_CREAT, 0600);

                   if(fd != -1)
                     {
                       lseek(fd, 32, SEEK_SET);
                       write(fd, &level, 1);
                       close(fd);
                     }
                 }
#elif defined(WIN32)
                     {
                   HKEY k_config;

                   if(ERROR_SUCCESS == RegCreateKey(HKEY_CURRENT_USER, "Software\\Junoplay.com\\Pengupop\\Config", &k_config))
                     {
                       char str[64];
                       snprintf(str, sizeof(str), "%d", (level ^ 0x7236143));
                       str[63] = 0;
                       RegSetValueEx(k_config, "bananas", 0, REG_SZ, str, strlen(str));
                     }
                     }
#endif
               return;
             }
           break;

        case SDL_JOYAXISMOTION:

          if ((event.jaxis.value > -3200) || (event.jaxis.value < 3200))  
             {
              switch (event.jaxis.axis)
                 {
                  case 0:
                   if (p.right == -1)/* Code same as SDL_KEYUP:SDLK_LEFT */
                      p.right = 0;
                   if (p.right == 1)/* Code same as SDL_KEYUP:SDLK_RIGHT */
                      p.right = 0;
                    break;
                 }
             }

          if ((event.jaxis.value < -3200) || (event.jaxis.value > 3200))  
             {
              switch (event.jaxis.axis)
                 {
                  case 0:
                   if (event.jaxis.value < -22000)/* Code same as SDL_KEYDOWN:SDLK_LEFT */
                      p.right = -1;
                   if (event.jaxis.value > 22000)/* Code same as SDL_KEYDOWN:SDLK_RIGHT */
                      p.right = 1;
                    break;
                 }
             }
          break;

        case SDL_KEYDOWN:

          switch(event.key.keysym.sym)
          { 
          case SDLK_q:
          case SDLK_ESCAPE:

            if(level == 255)
              level = saved_level;

#if LINUX || DARWIN
            if(getenv("HOME"))
            {
              char confpath[4096];

              strcpy(confpath, getenv("HOME"));
              strcat(confpath, "/.pengupoprc");

              int fd = open(confpath, O_WRONLY | O_CREAT, 0600);

              if(fd != -1)
              {
                lseek(fd, 32, SEEK_SET);
                write(fd, &level, 1);

                close(fd);
              }
            }
#elif defined(WIN32)
            {
              HKEY k_config;

              if(ERROR_SUCCESS == RegCreateKey(HKEY_CURRENT_USER, "Software\\Junoplay.com\\Pengupop\\Config", &k_config))
              {
                char str[64];
                snprintf(str, sizeof(str), "%d", (level ^ 0x7236143));
                str[63] = 0;

                RegSetValueEx(k_config, "bananas", 0, REG_SZ, str, strlen(str));
              }
            }
#endif

            return;

          case SDLK_x:
          case SDLK_RETURN:
          case SDLK_SPACE:
          case SDLK_UP:

            if(state == GS_NEUTRAL)
            {
              if(level < sizeof(levels) / sizeof(levels[0]))
              {
                bonus += levels[level].shoot_bonus;

                shoot(&p, random_bubble(&p), (levels[level].mode == GM_INV_GRAVITY) ? 400 : -1);
              }
              else
                shoot(&p, random_bubble(&p), -1);
            }

            break;

          case SDLK_LEFT:

            p.right = -1;

            break;

          case SDLK_RIGHT:

            p.right = 1;

            break;

          case 's':

            sound_enable = !sound_enable;

            break;

          case 'f':

#ifndef WIN32
            SDL_WM_ToggleFullScreen(screen);
#else
            if(fullscreen)
              screen = SDL_SetVideoMode(width, height, 0, SDL_SWSURFACE);
            else
              screen = SDL_SetVideoMode(width, height, 0, SDL_SWSURFACE | SDL_FULLSCREEN);

            SDL_BlitSurface(spbg, 0, screen, 0);

            p.dirty_minx = 0;
            p.dirty_miny = 0;
            p.dirty_maxx = max_field_width * 32;
            p.dirty_maxy = 440;
#endif
            fullscreen = !fullscreen;

            break;

          default:;
          }

          break;

        case SDL_KEYUP:

          switch(event.key.keysym.sym)
          {
          case SDLK_LEFT:

            if(p.right == -1)
              p.right = 0;

            break;

          case SDLK_RIGHT:

            if(p.right == 1)
              p.right = 0;

            break;

          default:;
          }

          break;
        }
      }

      if(p.evil_bubble_count && !next_evil)
      {
        int i = 0;

        while(p.evil_bubble_count && i < sizeof(p.mbubbles) / sizeof(p.mbubbles[0]))
        {
          if(p.mbubbles[i].color != 0 || p.mbubbles[i].lastpaintx != INT_MIN)
          {
            ++i;

            continue;
          }

          float rand = sin(pow(p.evil_bubble_seed++, 4.5)) * 0.5 + 0.5;
          float angle = rand * 60 - 30;

          p.mbubbles[i].falling = 0;
          p.mbubbles[i].velx = sin(angle / 180 * M_PI) * bubble_speed;
          p.mbubbles[i].vely = -cos(angle / 180 * M_PI) * bubble_speed;
          p.mbubbles[i].x = 112.0f;
          p.mbubbles[i].y = 400.0f;
          p.mbubbles[i].color = p.evil_bubbles[0];

          --p.evil_bubble_count;

          memmove(p.evil_bubbles, &p.evil_bubbles[1], p.evil_bubble_count);

          next_evil = 10;

          break;
        }
      }

      if(next_evil)
        --next_evil;

      SDL_UpdateRect(screen, 0, 0, 0, 0);
    }

    Uint32 message_until = now + 2000;
    p.right = 0;

    for(;;)
    {
      now = SDL_GetTicks();

      SDL_Event event;

      while(SDL_PollEvent(&event))
      {
        if(event.type == SDL_KEYDOWN)
        {
          if(event.key.keysym.sym == SDLK_ESCAPE
          || event.key.keysym.sym == SDLK_SPACE
          || event.key.keysym.sym == SDLK_RETURN)
            message_until = now;
        }
      }

      while(now >= last_tick + time_stepms)
      {
        /* Skip delays larger than 5s */
        if(now - last_tick > 5000)
          last_tick = now - 5000;

        last_tick += time_stepms;

        game_tick(now - last_tick < time_stepms);
      }

      if(now > message_until)
        break;

      SDL_UpdateRect(screen, 0, 0, 0, 0);
    }

    if(state == GS_SHINE_GET)
      ++level;

    if(level == sizeof(levels) / sizeof(levels[0]))
    {
      level = 0;

      for(;;)
      {
        SDL_Event event;

        while(SDL_PollEvent(&event))
        {
          if(event.type == SDL_KEYDOWN)
          {
            if(event.key.keysym.sym == SDLK_ESCAPE
            || event.key.keysym.sym == SDLK_SPACE
            || event.key.keysym.sym == SDLK_RETURN)
              return;
          }
        }

        SDL_BlitSurface(logo, 0, screen, 0);

        print_string(0, 320, 250, L"Congratulations!", 1);
        print_string(0, 320, 290, L"That was all", 1);

        SDL_UpdateRect(screen, 0, 0, 0, 0);
      }

      return;
    }
  }
}
Ejemplo n.º 10
0
Archivo: main.c Proyecto: PatzHum/rpg
int main(){

    //setup log file
    fpLog = fopen("log.txt", "w");
    if(fpLog == NULL){
        printf("Failed to open log file\n");
    }
    //seed random
    srand(time(NULL));

    //set up frame limiting
    clock_t s_cycle, e_cycle;
    s_cycle = clock();  //get amount of time to init game

    fprintf(fpLog, "Initializing...\n");    //log
    allegro_init_install(); //allegro inits

    Game game;
    game_init(&game);   //initialize game struct

    TMX_map map;
    load_map(&game, &map);  //load first map

    Sprite player, car;
    player_init(&game, &player, &map);   //initialize player struct
    car_init(&game, &car, &map, 32, 32, 5); //initialize car struct

    gen_npcs(&game, &map);  //generate and initialize npcs

    e_cycle = clock();
    //get length of initialization
    fprintf(fpLog, "Initialization done in %f seconds.\n",
            (double)(e_cycle - s_cycle) / 1000);

    //show instructions on how to play
    display_instructions(&game);

    //set active sprite
    game.active_sprite = &player;

    fprintf(fpLog, "Beginning main loop.\n");
    while(game.running){
        //to limit frames we have a set refresh rate
        //to maintain this refresh rate we subtract the
        //time elapsed over the entire cycle
        //to do this we get the time at the start of the cycle
        //and the end to get the difference
        s_cycle = clock();
        //exit sequence
        exit_sequence(&game);

        //check if we enter the car
        enter_car(&game, &player, &car, &map);

        //toggle debugging
        if(key[KEY_F1] && !game.debug_cd){
            game.debug = !game.debug;
            printf(game.debug ? "DEBUGGING ENABLED\n" : "DEBUGGING DISABLED\n");
            game.debug_cd = 10;
        }else{
            game.debug_cd -= game.debug_cd ? 1 : 0;
        }
        //resets game
        if(key[KEY_F5]){
            game_init(&game);
            load_map(&game, &map);
            player_init(&game, &player, &map);   //initialize player struct
            car_init(&game, &car, &map, 32, 32, 5);
            gen_npcs(&game, &map);
        }

        //toggle music
        if(key[KEY_M]){
            game.music ? stop_sample(game.bgMusic) :
                         play_sample(game.bgMusic, 255, 128, 1000, 1);
        }

        //clear buffer
        clear_to_color(game.buffer, makecol(0, 0, 0));

        //show map
        masked_blit(map.map, game.buffer, game.cam_x, game.cam_y,
                    0, 0, game.screen_w, game.screen_h);

        //pan camera
        pan_camera(&game);

        //do mouse click
        mouse_click(&game, game.active_sprite);
        npc_sequence(&game, &map);

        //display the player if we're not in the car
        if (!game.in_car){
            sprite_sequence(&game, &player, &map, !game.in_car);
            if (key[KEY_SPACE] && !player.bullet_cd){
                sprite_shoot(&game, &player);
                player.bullet_cd = 10;
            }else{
                player.bullet_cd -= player.bullet_cd ? 1 : 0;
            }
        }else{
            free(player.bullets);
            player.bullets = NULL;
            player.bullet_count = 0;
        }

        //show car
        sprite_sequence(&game, &car, &map, game.in_car);

        //display all overlays
        blit_overlays(&game);

        //show hud
        show_hud(&game, &player);

        //display buffer to screen
        stretch_blit(game.buffer, screen, 0, 0, game.buffer->w,
                     game.buffer->h, 0, 0, game.screen_w * STRETCH_FACTOR,
                     game.screen_h * STRETCH_FACTOR);

        //countdown timer
        game_tick(&game, &map);

        e_cycle = clock();

        /*maintain consistent framerate by calculating delay of
        processing, using max because we don't want negative rest*/
        printf("\rIteration took %f%20s", (double)
                (e_cycle - s_cycle), " ");
        rest(max(game.delay - (double) (e_cycle - s_cycle), 0));
    }

    fprintf(fpLog, "Running exit scripts...\n");
    //destroy all bitmaps
    destroy_bitmaps(&game, &player, &map, &car);
    fprintf(fpLog, "Exiting...\n");
    return 0;
}END_OF_MAIN();
Ejemplo n.º 11
0
static void enemy_tag_loop() {
	update_caption = tag_update_caption;
	tag_enemy_current_route = 0;
	tag_enemy_current_shot = 0;
	tag_enemy_spawnline = map_spawn_line;
	tag_enemy_y = 0;
	tag_enemy_upscrolled = 0;
	reset_tag_enemy();
	tag_enemy_id = init_enemy(&tag_enemy);
	
	SDL_Event sdl_event;
	while(1) {
		if(!obj_slot_used[tag_enemy_id]) update_tag_enemy(0);
			//tag_enemy_id = init_enemy(&tag_enemy);
		unsigned need_redraw = 1;
		while (SDL_PollEvent(&sdl_event)) {
			need_redraw = 0;
			int dir = -1;
			switch (sdl_event.type) {
				case SDL_KEYUP:
					switch(sdl_event.key.keysym.sym) {
						case SDLK_e: dump_enemy(); return;
						case SDLK_g: toggle_gun(); break;
						case SDLK_d: enter_direction(); break;
						case SDLK_i: insert_steps(); break;
						case SDLK_s: insert_shot(); break;
						case SDLK_p: do_pause(); break;
						case SDLK_c: clear_screen(); video_update(); need_redraw = 1; break;
						case SDLK_SPACE: update_tag_enemy(1); break;
						case SDLK_PAGEUP: scrollup(); break;
						case SDLK_KP_PLUS:
							dir = 1;
						case SDLK_KP_MINUS:
							if((sdl_event.key.keysym.mod & KMOD_RSHIFT) ||
							   (sdl_event.key.keysym.mod & KMOD_LSHIFT))
								toggle_shape(dir);
							else
							if((sdl_event.key.keysym.mod & KMOD_RALT) ||
							   (sdl_event.key.keysym.mod & KMOD_LALT))
								toggle_route(dir);
							else
							if((sdl_event.key.keysym.mod & KMOD_RCTRL) ||
							   (sdl_event.key.keysym.mod & KMOD_LCTRL))
								toggle_shot(dir);
							else
								toggle_vel(dir);
							break;
						default: break;
					}
				case SDL_KEYDOWN:
					switch(sdl_event.key.keysym.sym) {
						case SDLK_RIGHT: dir = 1;
						case SDLK_LEFT:
							if((sdl_event.key.keysym.mod & KMOD_RSHIFT) ||
							   (sdl_event.key.keysym.mod & KMOD_LSHIFT)) dir *= 4;
							tag_enemy.x += dir;
							update_tag_enemy(1);
							break;
						case SDLK_DOWN:
							dir = 1;
						case SDLK_UP:
							if((sdl_event.key.keysym.mod & KMOD_RSHIFT) ||
							   (sdl_event.key.keysym.mod & KMOD_LSHIFT)) dir *= 4;
							tag_enemy_y += dir;
							update_tag_enemy(1);
							break;
						default: ;
					}
				break;
				default: ;
			}
		}
		game_tick(need_redraw);
	}
}