xlib_playground

main.c (8357B)

---

 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <unistd.h>
 #include <string.h>
 
 #include "main.h"
 #include "world_map.h"
 
 /* macros */
 #define FPS (60)
 #define SUB_TICK (4)
 #define NUM_BLOCK (200)
 #define GRAVITY (1000)
 
 /*
 #define COUNT_FPS
 */
 
 enum keys {
 	KEY_D,
 	KEY_S,
 	KEY_A,
 	KEY_W,
 	KEY_Q,
 	KEY_SPACE,
 	NUM_KEY, //number of keys in this enum
 };
 enum key_state {
 	KEY_UP,
 	KEY_DOWN,
 };
 enum next_menu {
 	START_MENU,
 	GAME_PLAY,
 	GAME_OVER,
 	QUIT,
 };
 
 /* variables */
 struct Object *player;
 int            player_is_falling;
 enum next_menu next_menu = START_MENU;
 
 
 /* function prototypes */
 /* menus */
 void start_menu(void);
 void game_play(void);
 void game_over(void);
 /* events */
 void receive_events(enum key_state[]);
 void handle_inputs(enum key_state[]);
 /* sort */
 void sort_ll(struct OL *ol, struct Object *player);
 
 void
 start_menu(void)
 {
 	char *menu_char_q = "press q to quit.";
 	char *menu_char_s = "press <space> to start.";
 
 	x_clear_area();
 	x_draw_string(0x00FFFF,
 				  WORLD_WIDTH * BLOCK_SIZE/2 - 10 * strlen(menu_char_q)/2,
 				  WORLD_HEIGHT * BLOCK_SIZE/2,
 				  menu_char_q, strlen(menu_char_q));
 	x_draw_string(0x00FFFF,
 				  WORLD_WIDTH * BLOCK_SIZE/2 - 10 * strlen(menu_char_s)/2,
 				  WORLD_HEIGHT * BLOCK_SIZE/2 + 20,
 				  menu_char_s, strlen(menu_char_s));
 
 	while (next_menu == START_MENU) {
 		char c;
 		int  event = x_next_event(&c);
 
 		switch (event) {
 		case XEXPOSE:
 			x_draw_string(0x00FFFF,
 						  WORLD_WIDTH * BLOCK_SIZE/2 - 10 * strlen(menu_char_q)/2,
 						  WORLD_HEIGHT * BLOCK_SIZE/2,
 						  menu_char_q, strlen(menu_char_q));
 			x_draw_string(0x00FFFF,
 						  WORLD_WIDTH * BLOCK_SIZE/2 - 10 * strlen(menu_char_s)/2,
 						  WORLD_HEIGHT * BLOCK_SIZE/2 + 20,
 						  menu_char_s, strlen(menu_char_s));
 
 			break;
 		case XWINDEL:
 			next_menu = QUIT;
 			break;
 		case XKEYPRESS:
 			switch (c) {
 			case 'q':
 				next_menu = QUIT;
 				break;
 			case ' ':
 				next_menu = GAME_PLAY;
 				break;
 			default:
 				break;
 			}
 			break;
 		default:
 			break;
 		}
 	}
 }
 
 void
 game_play(void)
 {
 	enum key_state key_state[NUM_KEY];
 	long t0, t1, dt;
 #ifdef COUNT_FPS
 	int fps_count = 0;
 #endif
 	struct timespec ts;
 	struct OH *blh[WORLD_WIDTH]; // block list header
 	struct OL *blc;
 
 	for (int xi = 0; xi < WORLD_WIDTH; xi++)
 		blh[xi] = create_ol();
 
     for (int i = 0; i < WORLD_WIDTH * WORLD_HEIGHT; i++) {
         if (world_map[i] == 'b') {
             int xi = i % WORLD_WIDTH;
             // TODO: don't forget to free these things.
             append_ol(blh[xi], create_object(i % WORLD_WIDTH * BLOCK_SIZE,
 									   i / WORLD_WIDTH * BLOCK_SIZE,
 									   0, 0, 0, 0,
 									   BLOCK_SIZE, BLOCK_SIZE,
 									   BLOCK_SIZE * BLOCK_SIZE));
         } else if (world_map[i] == 'p') {
             player = create_object(i % WORLD_WIDTH * BLOCK_SIZE,
 									   i / WORLD_WIDTH * BLOCK_SIZE,
 									   0, 0, 0, GRAVITY,
 									   BLOCK_SIZE, BLOCK_SIZE,
 									   BLOCK_SIZE * BLOCK_SIZE);
 		}
 	}
 
 	while (next_menu == GAME_PLAY){
 		receive_events(key_state);
 		handle_inputs(key_state);
 
 		clock_gettime(CLOCK_MONOTONIC, &ts);
 		t0 = ts.tv_nsec;
 
 		for (int k = 0; k < SUB_TICK; k++) {
 			next_tick(player, 1e9 / FPS / SUB_TICK);
 
 			// game over when fall out of the world
 			if (player->p.y > WORLD_HEIGHT * BLOCK_SIZE) {
 				next_menu = GAME_OVER;
 				break;
 			}
 			// bind within the world
 			if (player->p.x < 0) {
 				player->p.x = 0;
 			}
 			if (WORLD_WIDTH * BLOCK_SIZE < player->p.x +
 			    player->body.rectangle.w) {
 				player->p.x = WORLD_WIDTH * BLOCK_SIZE -
 				             player->body.rectangle.w;
 			}
 
 			struct OH *collidings;
 			collidings = create_ol();
 
 			player_is_falling = 1;
 			for (int xi = (int) player->p.x / BLOCK_SIZE;
 				xi <= (int) player->p.x / BLOCK_SIZE + 1 && xi < WORLD_WIDTH;
 				xi++) {
 				blc = blh[xi]->first;
 				while (blc != NULL) {
 					if (is_on_floor_before(player, blc->o)) {
 						player_is_falling = 0;
 					}
 					if (test_collision(player, blc->o))
 						append_ol(collidings, blc->o);
 					blc = blc->next;
 				}
 			}
 			if (collidings->first != NULL) {
 				sort_ol(collidings, player);
 				blc = collidings->first;
 				while (blc != NULL) {
 					handle_collision_mf(player, blc->o);
 					blc = blc->next;
 				}
 			}
 			free_ol(collidings);
 		}
 
 		// fix fps
 		// TODO: This method create some strange stripe when
 		// rendered in 60fps on a 60fps monitor.
 		dt = 0;
 		while (dt < 1.0 * 1e9 / FPS){
 			clock_gettime(CLOCK_MONOTONIC, &ts);
 			t1 = ts.tv_nsec;
 			dt = t1 > t0 ? t1 - t0 : t1 - t0 + 1e9;
 		}
 #ifdef COUNT_FPS
 		// count fps.
 		fps_count++;
 		if (t1 < t0){
 			printf("fps: %u\n", fps_count);
 			fps_count = 0;
 		}
 #endif
 
 		x_clear_area();
 		for (int xi = 0; xi < WORLD_WIDTH; xi++) {
 			blc = blh[xi]->first;
 			while (blc != NULL) {
 				x_draw_rectangle(0x00FF00,
 					blc->o->p.x, blc->o->p.y,    // position
 					blc->o->body.rectangle.w,
 				    blc->o->body.rectangle.h);
 				blc = blc->next;
 			}
 		}
 		x_draw_rectangle(0x009FFF,
 					   player->p.x, player->p.y,    // position
 					   player->body.rectangle.w, player->body.rectangle.h);
 		char status_string[128];
 		snprintf(status_string, 128, "falling: %d", player_is_falling);
 		x_draw_string(0x00FFFF,
 		            0, 20,
 		            status_string,
 					strlen(status_string));
 	}
 	for (int xi = 0; xi < WORLD_WIDTH; xi++)
 		free_obj_and_ol(blh[xi]);
 }
 
 void
 game_over(void)
 {
 	char *menu_char = "GAME OVER";
 
 	x_clear_area();
 	x_draw_string(0x00FFFF,
 				WORLD_WIDTH * BLOCK_SIZE/2 - 10 * strlen(menu_char)/2,
 				WORLD_HEIGHT * BLOCK_SIZE/2,
 				menu_char, strlen(menu_char));
 	x_flush();
 
 	sleep(1);
 	while(x_pending() > 0) {
 		x_next_event(NULL);
 	}
 	next_menu = START_MENU;
 }
 
 void
 receive_events(enum key_state key_state[])
 {
 	while (x_pending() > 0) {
 		char c;
 		int event = x_next_event(&c);
 
 		switch (event) {
 		case XWINDEL:
 			next_menu = QUIT;
 			break;
 		case XKEYPRESS:
 			switch (c) {
 			case 'q':
 				key_state[KEY_Q] = KEY_DOWN;
 				break;
 			case 'd':
 				key_state[KEY_D] = KEY_DOWN;
 				break;
 			case 'a':
 				key_state[KEY_A] = KEY_DOWN;
 				break;
 			case 'w':
 				key_state[KEY_W] = KEY_DOWN;
 				break;
 			case 's':
 				key_state[KEY_S] = KEY_DOWN;
 				break;
 			case ' ':
 				key_state[KEY_SPACE] = KEY_DOWN;
 				break;
 			default:
 				break;
 			}
 			break;
 		case XKEYRELEASE:
 			switch (c) {
 			case 'q':
 				key_state[KEY_Q] = KEY_UP;
 				break;
 			case 'd':
 				key_state[KEY_D] = KEY_UP;
 				break;
 			case 'a':
 				key_state[KEY_A] = KEY_UP;
 				break;
 			case 'w':
 				key_state[KEY_W] = KEY_UP;
 				break;
 			case 's':
 				key_state[KEY_S] = KEY_UP;
 				break;
 			case ' ':
 				key_state[KEY_SPACE] = KEY_UP;
 				break;
 			default:
 				break;
 			}
 			break;
 		}
 	}
 }
 
 void
 handle_inputs(enum key_state key_state[])
 {
 	if (key_state[KEY_Q] == KEY_DOWN){
 		next_menu = GAME_OVER;
 		return;
 	}
 	if (key_state[KEY_D] == KEY_DOWN && key_state[KEY_A] != KEY_DOWN) {
 		if (player->v.x > 0) {
 			player->a.x = 500;
 		} else {
 			player->a.x = 1000;
 		}
 	} else if (key_state[KEY_A] == KEY_DOWN && key_state[KEY_D] != KEY_DOWN) {
 		if (player->v.x > 0) {
 			player->a.x = -1000;
 		} else {
 			player->a.x = -500;
 		}
 	} else {
 		if (player_is_falling)
 			player->a.x = -player->v.x;
 		else
 			player->a.x = -3 * player->v.x;
 	}
 
 	if (player->v.x < -200) player->v.x = -200;
 	if (player->v.x > 200) player->v.x = 200;
 	/*
 	if (key_state[KEY_S] == KEY_DOWN)
 		player->v.y += 300;
 	if (key_state[KEY_W] == KEY_DOWN)
 		player->v.y += -300;
 	*/
 	if (!player_is_falling && key_state[KEY_SPACE] == KEY_DOWN) {
 		player->v.y = -450;
 	}
 }
 
 void
 swap_ll(struct OL *oi, struct OL *oj)
 {
 	struct Object *tmp;
 	tmp = oi->o;
 	oi->o = oj->o;
 	oj->o = tmp;
 }
 
 void
 sort_ll(struct OL *ol, struct Object *player)
 {
 	if (ol == NULL)
 		return;
 	struct OL *oi, *oj;
 	for (oi = ol; oi->next != NULL; oi = oi->next) {
 		for (oj = oi->next; oj != NULL; oj = oj->next) {
 			if (object_dist(oj->o, player) < object_dist(oi->o, player))
 				swap_ll(oi, oj);
 		}
 	}
 }
 
 int
 main(void)
 {
 	x_setup_window(0, 0,
 				   WORLD_WIDTH * BLOCK_SIZE, WORLD_HEIGHT * BLOCK_SIZE,
 				   0x000000, "UNKO");
 	while (next_menu != QUIT){
 		switch (next_menu){
 		case START_MENU:
 			start_menu();
 			break;
 		case GAME_PLAY:
 			game_play();
 			break;
 		case GAME_OVER:
 			game_over();
 			break;
 		default:
 			break;
 		}
 	}
 
 	x_clean_up();
 	return 0;
 }