int main(void)
{
char word[MAX_LEN + 1], category[MAX_LEN + 1], trivia[MAX_TRIVIA_LEN + 1],
again;
int games_played;
game_init(); /* initialize the game with 7 lives */
for (;;) {
get_word(word, category, trivia); /* generated a new word from the dictionary */
games_played = play_game(word, category, trivia); /* play the game */
printf("\nGames played: %d\n", games_played);
printf("Play again? (y/n): ");
again = getchar();
getchar();
if (again == 'n' || again == 'N') {
system(CLEARSCREEN);
break;
}
game_init();
}
return 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;
}
int hole_goto(int h, int p)
{
int i;
if (h < count)
{
if (h >= 0) hole = h;
if (p >= 0) party = p;
if (game_init(hole_v[hole].file))
{
back_init(hole_v[hole].back);
player = (hole - 1) % party + 1;
done = 0;
for (i = 1; i <= party; i++)
{
game_get_pos(ball_p[i], ball_e[i]);
stat_v[i] = 0;
}
game_ball(player);
hole_song();
return 1;
}
}
return 0;
}
void ui_state_title(void)
{
int x = 0, y = 0, dx = 1, dy = 1, w = 20, h = 20, i = 0;
snd_play("sounds/intro-valkyrie.raw");
while (1) {
image_draw(0, 0, img_bg);
image_draw(x, y, img_soldier);
screen_show_buffer();
if (y + h == SCREEN_HEIGHT && dy == 1) dy = -1;
if (y == 0 && dy == -1) dy = 1;
if (x + w == SCREEN_WIDTH && dx == 1) dx = -1;
if (x == 0 && dx == -1) dx = 1;
x += dx; y += dy;
led_setup = (i++ / 10) % 2 ? 0xaa : 0x55;
led_update();
if ((btn_ignore = btn_read()) > 0) {
ui_state = UI_GAME_SOLDIER;
game_init();
return;
}
}
}
/**@brief Application main function.
*/
int main(void)
{
uint32_t err_code;
bool erase_bonds;
// Initialize.
APP_TIMER_INIT(APP_TIMER_PRESCALER, APP_TIMER_OP_QUEUE_SIZE, false);
buttons_leds_init(&erase_bonds);
ble_stack_init();
gap_params_init();
services_init();
advertising_init();
conn_params_init();
gpio_init();
timer_init(); //timer task to refresh RGB LED Board
game_init();
err_code = ble_advertising_start(BLE_ADV_MODE_FAST);
APP_ERROR_CHECK(err_code);
// Enter main loop.
for (;;) {
power_manage();
moveDisc(getInput());
}
}
function main()
{
video_set( 1024, 768, 32, 2 ) ;
level_state = 0 ;
game_init() ;
sceneManager() ;
// MAIN GAME LOOP //
while(1)
{
if( level_state == 0 )
{
// pause the game
freeze_mode = 1 ;
}
else
{
freeze_mode = 0;
}
wait(1);
}
}
int main() {
// init
srand(time(NULL));
if (!glfwInit())
fatal("glfwInit() failed!");
window = glfwCreateWindow(640, 480, "title", NULL, NULL);
if (!window)
fatal("glfwCreateWindow() failed!");
glfwMakeContextCurrent(window);
glewExperimental = true;
if (glewInit() != GLEW_OK)
fatal("glewInit() failed!");
glClearColor(0.0, 0.0, 0.2, 0.0);
glEnable(GL_DEPTH_TEST);
// glEnable(GL_CULL_FACE);
glCullFace(GL_BACK);
game_init();
double lasttime = glfwGetTime();
// gameloop
while (!glfwWindowShouldClose(window)) {
double time = glfwGetTime();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
game_update(time - lasttime);
glfwSwapBuffers(window);
glfwPollEvents();
lasttime = time;
}
// free
glfwDestroyWindow(window);
glfwTerminate();
}
int main(int argc, const char ** argv) {
struct timeval start_time, end_time;
struct timespec tspec = {0, 0};
struct timespec left = {0, 0};
int error;
long long elapsed;
float cam_center_x, cam_center_y;
if (swiftsure_log_init() < 0) {
printf("Bad times, we couldn't open our log file =(\n");
return -1;
}
rendering_init();
if (input_init() < 0) {
printf("Bad times, we couldn't initialize the input subsystem\n");
return -1;
}
action_init();
world.width = WORLD_SIZE;
world.height = WORLD_SIZE;
world_init(&world, 1);
game_init();
swiftsure_log(INFO, "Startin engines\n");
frame = 0;
elapsed = 16666;
while (1) {
gettimeofday(&start_time, NULL);
game_get_avg_pos(&cam_center_x, &cam_center_y);
render_set_camera(-cam_center_x, -cam_center_y, 4);
handle_events();
action_perform();
render_start_frame();
render_world(&world);
game_render_players();
render_end_frame();
++frame;
physics_tick(&world, 10. / elapsed);
//Rate limiting
gettimeofday(&end_time, NULL);
elapsed = (end_time.tv_sec - start_time.tv_sec) * 1000000 + (end_time.tv_usec - start_time.tv_usec);
if (elapsed < 16666) {
tspec.tv_nsec = (16666 - elapsed) * 1000;
error = nanosleep(&tspec, &left);
if (error < 0) {
swiftsure_log(DEBUG, "We had %d seconds and %d nanoseconds left to sleep, errno %d\n", left.tv_sec, left.tv_nsec, errno);
}
}
}
}
void net_game_thread(net_client_descr_t *clients) {
Field *net_field = malloc(sizeof(Field));
char* field_buffer = malloc(512);
game_init(net_field);
for(int i = 0; i < MAX_CONNECTIONS; i++) {
// sending packet 2 (game start)
Packet *p = (Packet*) packet_create(2, 1, "1");
queue_push(clients[i].send, p);
clients[i].field = net_field;
}
while(net_server_status != SHUTDOWN) {
game_update(net_field);
int game_over = 1;
for(int i = 0; i < MAX_CONNECTIONS; i++) {
if (!net_field->players[i].is_dead) game_over = 0;
}
if (game_over) {
Packet* p = (Packet *) packet_create(8, 1, "1");
for(int i = 0; i < MAX_CONNECTIONS; i++) queue_push(clients[i].send, p);
net_server_status = SHUTDOWN;
break;
}
packer_pack_field(field_buffer, net_field);
Packet* p = (Packet*) packet_create(3, strlen(field_buffer), field_buffer);
for(int i = 0; i < MAX_CONNECTIONS; i++) queue_push(clients[i].send, p);
usleep(30000);
}
}
int main(int argc, char *argv[]){
gtk_init(&argc, &argv);
game_init();
layout_init();
gtk_main();
return 0;
}
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
system_init();
if (DxLib_Init() == -1 || SetDrawScreen(DX_SCREEN_BACK) != 0)return -1; // 初期化と裏画面化
game_init();
LogSP log1 = LogSP(new Log("あいうえお"));
LogSP log2 = LogSP(new Log("かきくけこ"));
LogSP log3 = LogSP(new Log("さしすせそ"));
manager.push(log1);
manager.push(log2);
manager.push(log3);
while (ProcessLoop())
{
mso::KeyBoard::SetNowState();
manager.process();
mso::FpsController::Wait();
mso::FpsController::Draw();
ScreenFlip(); // 裏画面反映
mso::KeyBoard::KeepPrevState();
}
DxLib_End();
return 0;
}
void game_start_stop(GtkMenuItem *widget,
gpointer user_data)
{
game_play=!game_play;
gtk_widget_set_sensitive(GTK_WIDGET(widget), FALSE);
if(game_play)
{
gtk_widget_set_sensitive(menu_game_stop,TRUE);
gtk_widget_set_sensitive(menu_game_quick,FALSE);
gtk_widget_set_sensitive(menu_game_start,FALSE);
gtk_widget_set_sensitive(Start_stop_button,TRUE);
gtk_label_set(GTK_LABEL(Start_stop_button_label),start_stop_str[1]);
gtk_widget_set_sensitive(Pause_button,TRUE);
gtk_widget_grab_default(Pause_button);
game_init();
make_noise(options.noise_l,options.noise_h);
from_virtual();
move_block(0,0,0);
current_level = options.level;
update_game_values(0,current_level,0);
timer = gtk_timeout_add(level_speeds[current_level],(GtkFunction)game_loop,NULL);
}
else
game_over_init();
}
int main ( int argc, char** argv )
{
printf("Starting test ... \n");
gamepad_buttons[0] = 0; // all up
gamepad_buttons[1] = 0;
game_init();
printf(" Game init done. \n");
// program main loop
for (int i=0;i<EMU_FRAMES;i++) {
handle_gamepad();
// update game
game_frame();
// update time
vga_frame++;
// one sound buffer per frame
game_snd_buffer(audio,BITBOX_SNDBUF_LEN);
refresh_screen();
} // end main loop
// all is well ;)
printf(" Test OK !\n");
return 0;
}
void eng_newgame(void)
{
// Is this needed?
// Well, should not be to expensive so we can re-set
// when getting position.
game_init(&(eng.game));
}
int menu_proc_play_normal(int i, void * p)
{
al_hide_mouse_cursor(t3f_display);
enemy_spawn_logic = enemy_spawn_logic_normal;
game_init();
return 1;
}
static void
handle_action(game_init_box_t *box, int action)
{
switch (action) {
case ACTION_START_GAME:
game_init();
if (box->game_mission < 0) {
random_state_t rnd = {{ 0x5a5a, time(NULL) >> 16, time(NULL) }};
int main (int argc, char *argv[])
{
GAME *game = game_init ();
game_loop (game);
game_destroy (game);
return EXIT_SUCCESS;
}
cDangerousGame::cDangerousGame( const int screen_width, const int screen_height ){
finished = false;
started = false;
startButton = BUTTON_NOT_PRESSED;
message = NULL;
screen = NULL;
background = NULL;
opponents = NULL;
player = NULL;
font = NULL;
timeMessage = NULL;
playerMessage = NULL;
textColor = { 255, 255, 255 };
bool init = game_init( (int) screen_width, (int) screen_height );
if( !init ) { printf("initialitation failed\n"); }
bool loading = load_files();
if( !loading ) { printf("loading files failed\n"); }
playerDetails = new cPlayer();
clip[ 0 ].x = 0;
clip[ 0 ].y = 0;
clip[ 0 ].w = 40;
clip[ 0 ].h = 40;
clip[ 1 ].x = 40;
clip[ 1 ].y = 0;
clip[ 1 ].w = 40;
clip[ 1 ].h = 40;
clip[ 2 ].x = 0;
clip[ 2 ].y = 40;
clip[ 2 ].w = 40;
clip[ 2 ].h = 40;
clip[ 3 ].x = 40;
clip[ 3 ].y = 40;
clip[ 3 ].w = 40;
clip[ 3 ].h = 40;
srand(time(NULL) + getpid());
ball1 = new cBall( wRand(), hRand(), 10, 10, screen_h, screen_w );
ball2 = new cBall( wRand(), hRand(), 10, -10, screen_h, screen_w );
ball3 = new cBall( wRand(), hRand(), -10, 10, screen_h, screen_w );
ball4 = new cBall( wRand(), hRand(), -10, -10, screen_h, screen_w );
timeGameStarted = 0;//SDL_GetTicks();
timeForOneRound = 120;
lastBlittTime = -1;
playerPoints = 0;
createPlayerPointMessage();
}
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;
}
static void window_load(Window *window) {
Layer *window_layer = window_get_root_layer(window);
GRect bounds = layer_get_bounds(window_layer);
layer = layer_create(bounds);
layer_add_child(window_layer, layer);
game_init();
game_start(layer);
}
int main(){
game g;
game_init( &g );
game_run ( &g );
game_over( &g );
return 0;
}
struct game_t* game_create()
{
struct game_t* g = malloc(sizeof(struct game_t));
if (g)
{
game_init(g);
}
return g;
}
int main(int argc, char *argv[]) {
game_init();
while (!quit_flag) {
game_event(&event);
game_loop();
game_render();
}
game_destroy();
return EXIT_SUCCESS;
}
void modinit_eng(void)
{
eng.iomode = IOMODE_NORMAL;
eng.searchmode = SEARCHMODE_NORMAL;
eng.debug = FALSE;
eng.sig_exit = FALSE;
eng.sig_newgame = FALSE;
eng.sig_stop = FALSE;
game_init(&(eng.game));
}
JNIEXPORT int JNICALL Java_com_fiftyply_mosaic_GameSurfaceView_nativeStep(JNIEnv* env, jobject obj) {
//LOGI("nativeStep");
if(!have_initialized) {
renderer_enqueue_sync(renderer_init, NULL);
game_init();
have_initialized = 1;
}
return loop_once();
}
static void mainproc(void *arg)
{
Dynamic *dynamicp;
Gfx *glistp;
Control cont;
init_dma();
init_task();
init_framebuffer();
read_rom( _staticSegmentStart,
_staticSegmentRomStart, _staticSegmentRomEnd );
read_rom( _dkSegmentStart, _dkSegmentRomStart, _dkSegmentRomEnd );
read_rom( _dk7SegmentStart, _dk7SegmentRomStart, _dk7SegmentRomEnd );
read_rom( _roadSegmentStart, _roadSegmentRomStart,
_roadSegmentRomEnd );
read_rom( _l2_tvSegmentStart, _l2_tvSegmentRomStart,
_l2_tvSegmentRomEnd );
init_controlers( &cont );
game_init();
while (1)
{
read_controler( &cont );
dynamicp = &dynamic;
guOrtho( &dynamicp->projection,
-(float) SCREEN_WD / 2.0F, (float) SCREEN_WD / 2.0F,
-(float) SCREEN_HT / 2.0F, (float) SCREEN_HT / 2.0F,
1.0F, 10.0F, 1.0F );
guRotate( &dynamicp->modeling, 0.0F, 0.0F, 0.0F, 1.0F );
glistp = dynamicp->glist;
/* rcp rdp & color frame buffer initialize */
glistp = init_rcprdp( glistp, (char *)_staticSegmentStart, draw_buffer );
glistp = clear_cfb( glistp );
/* game main */
glistp = game_main( glistp, &cont );
gDPFullSync(glistp++);
gSPEndDisplayList(glistp++);
assert((glistp - dynamicp->glist) < GLIST_LEN);
start_task( glistp, dynamicp );
swap_framebuffer( draw_buffer );
draw_buffer ^= 1;
}
}
int main(int argc, char *argv[])
{
if(argc != 3) {
fprintf(stderr, "Please use client like : client <srv_address> <srv_port>\n");
return -1;
}
int sockfd, len, result, port;
if (sscanf(argv[2],"%i",&port)!=1){
perror("Port invalide.\n");
return -1;
}
struct sockaddr_in address;
sockfd = socket(PF_INET, SOCK_STREAM, 0);
if (sockfd == -1) {
perror("Creation de socket impossible.\n") ;
return -1 ;
}
address.sin_family = AF_INET;
address.sin_addr.s_addr = inet_addr(argv[1]);
address.sin_port = htons(port);
len = sizeof(address);
result = connect(sockfd, (struct sockaddr *)&address, len);
if(result == -1) {
perror("Impossible de se connecter ");
return -1;
}
Game* game = malloc(sizeof(Game));
Params* params = malloc(sizeof(Params));
params->p_screen = malloc(sizeof(Screen));
params->sock = sockfd;
game_init(game);
params->p_game = game;
if (SDL_Init(SDL_INIT_VIDEO) == -1) {
fprintf(stderr, "Erreur d'initialisation de la SDL : %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
params->p_screen->ecran = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE);
SDL_WM_SetCaption("Bataille Navale Royale", NULL);
if(pthread_create(&pth_recv,NULL,cl_recv,params)){
printf("Erreur lors de la creation du thread de lecture.\n");
return -1;
}
if(pthread_create(&pth_display,NULL,cl_display,params)){
printf("Erreur lors de la creation du thread d'affichage.\n");
return -1;
}
if(pthread_join(pth_recv, NULL) && pthread_join(pth_display, NULL)){
printf("Joining error");
return -2;
}
free(params->p_game);
free(params);
close(sockfd);
exit(0);
}
// Engine ----------------------------------------------------------------------
// -----------------------------------------------------------------------------
int engine_create(const int width, const int height, const int scale, const int fps) {
engine = (struct Engine*)malloc(sizeof(struct Engine));
if (!engine_init(width, height, scale, fps)) {
free(engine);
return 1;
}
game_init();
// Main Loop, o'rly?
int render_start = 0, render_diff = 0, render_wait = 0;
int fps_count = 0, fps_time = 0;
while (engine->running) {
render_start = SDL_GetTicks();
engine_events();
if (key_pressed(SDLK_p)) {
engine_pause(!engine->paused);
}
if (!engine->paused) {
game_update();
}
engine_clear_keys();
engine_clear_mouse();
game_render(engine->screen);
SDL_Flip(engine->screen->bg);
// Limit FPS
render_diff = SDL_GetTicks() - render_start;
if (render_diff > 0) {
render_wait = engine->fps_wait - render_diff;
if (render_wait > 0) {
SDL_Delay(render_wait);
}
if (!engine->paused) {
engine->time += SDL_GetTicks() - render_start;
}
}
// Count FPS
if (!engine->paused) {
fps_count++;
if (fps_count >= 10) {
engine->fps_current = 1000 / ((engine->time - fps_time) / fps_count);
fps_count = 0;
fps_time = engine->time;
}
}
}
// Cleanup
game_quit();
engine_cleanup();
return 0;
}
void game_main(void)
{
game_mode();
switch (game.mode) {
case 0:
game_init();
game_p1();
break;
case 1:
game_init();
game_p2();
break;
case 2:
game_conn2();
break;
case 3:
game_conn3();
break;
}
}
int main(int argc, char *argv[]) {
/* Signal handlers */
sigaction_wrapper(SIGINT, sigint_handler);
/* Start the game */
g = game_init();
game_run(g);
game_free(g);
return 0;
}
