xlib_playground

main.c (8022B)

---

 #include <stdio.h>
 #include <stdlib.h>
 #include <time.h>
 #include <string.h>
 
 #include <X11/Xlib.h>
 
 #include "obj.h"
 
 /* macros */
 #define INIT_WIDTH 800
 #define INIT_HEIGHT 600
 #define FPS 60
 #define BLOCK_COUNT 3
 
 
 /* variables */
 Display     *display;
 Window       window;
 unsigned int win_width = INIT_WIDTH, win_height = INIT_HEIGHT;
 GC           pgc, fgc, bgc;
 Atom         wm_delete_window;
 Obj          *square;
 Obj          *blocks[BLOCK_COUNT];
 int          quit = 0;
 enum Keys {
 	Key_D,
 	Key_S,
 	Key_A,
 	Key_W,
 	Key_Space,
 	Num_Key, //number of keys in this enum
 };
 enum Key_State {
 	Key_Up,
 	Key_Down,
 };
 int key_state[Num_Key];
 enum Next_Menu {
 	Start_Menu,
 	Game_Play,
 	End_Menu,
 	Quit,
 };
 int next_menu = Start_Menu;
 
 
 /* function prototypes */
 void setup(void);
 void start_menu(void);
 void game_init(void);
 void game_play(void);
 void draw_object(Obj *, GC);
 void handle_collision(void);
 void handle_inputs(void);
 void end_menu(void);
 void next_tick(float);
 void cleanup(void);
 
 
 void
 setup(void)
 {
 	if ((display = XOpenDisplay(NULL)) == NULL){
 	    fprintf(stderr, "ERROR: could not open display\n");
 	    exit(1);
 	}
 	window = XCreateSimpleWindow(
 	                    display,
 	                    XDefaultRootWindow(display),
 	                    0, 0,
 	                    win_width, win_height,
 	                    0, 0,
 						0);
 	XStoreName(display, window, "UNKO");
 	pgc = XCreateGC(display, window, 0, NULL);
 	fgc = XCreateGC(display, window, 0, NULL);
 	bgc = XCreateGC(display, window, 0, NULL);
 
 	wm_delete_window = XInternAtom(display, 
 									"WM_DELETE_WINDOW", False);
 	XSetWMProtocols(display, window, &wm_delete_window, 1);
 
 	XSelectInput(display, window,
 				ExposureMask|KeyPressMask|KeyReleaseMask);
 	
 	XSetForeground(display, pgc, 0x00FF00);
 	XSetForeground(display, fgc, 0xFFFFFF);
 	XSetForeground(display, bgc, 0x0000FF);
 	XMapWindow(display, window);
 }
 
 void
 start_menu(void)
 {
 	XEvent event;
 	char *menu_char_q = "press q to quit.";
 	char *menu_char_s = "press <space> to start.";
 
 	XClearArea(display, window, 0, 0, win_width, win_height, False);
 
 	XDrawString(display, window, fgc,
 				win_width/2 - strlen(menu_char_q)/2, win_height/2,
 				menu_char_q, strlen(menu_char_q));
 	XDrawString(display, window, fgc,
 				win_width/2 - strlen(menu_char_s)/2, win_height/2 + 20,
 				menu_char_s, strlen(menu_char_s));
 
 	while (next_menu == Start_Menu) {
 		XNextEvent(display, &event);
 		switch (event.type) {
 		case Expose: {
 			XDrawString(display, window, fgc,
 						win_width/2 - strlen(menu_char_q)/2, win_height/2,
 						menu_char_q, strlen(menu_char_q));
 			XDrawString(display, window, fgc,
 						win_width/2 - strlen(menu_char_s)/2, win_height/2 + 20,
 						menu_char_s, strlen(menu_char_s));
 			
 		} break;
 		case KeyPress: {
 			switch (XLookupKeysym(&event.xkey, 0)) {
 			case 'q':
 				next_menu = Quit;
 				break;
 			case ' ':
 				next_menu = Game_Play;
 				break;
 			default:
 				break;
 			}
 		} break;
 		case ClientMessage: {
 			if ((Atom) event.xclient.data.l[0] == wm_delete_window) {
 				next_menu = Quit;
 			}
 		} break;
 		default:
 			break;
 		}
 	}
 }
 
 void
 game_init(void)
 {
 	if(!square) // not allocated
 		if(!(square = obj_create(100, 100, 0, 0, 0, 0, 400, 20, 20))){
 			fprintf(stderr, "couldn't create object: square");
 			exit(1);
 		}
 	for (int i = 0; i < BLOCK_COUNT; i++){
 		struct timespec t;
 		clock_gettime(CLOCK_REALTIME, &t);
 		srand(t.tv_nsec);
 		if(!blocks[i]) // not allocated
 			if(!(blocks[i] = obj_create((i + 1) * 100,
 										200,
 										0, 0,
 										0, 0, 100, 10, 10))){
 				fprintf(stderr, "couldn't create object: block");
 				exit(1);
 			}
 	}
 	
 	square->px = 100;
 	square->py = 100;
 	square->vx = square->vy = 0;
 	square->ax = square->ay = 0;
 }
 
 void
 game_play(void)
 {
 	long t0, t1, dt;
 	struct timespec ts;
 
 	game_init();
 
 	clock_gettime(CLOCK_MONOTONIC, &ts);
 	t0 = ts.tv_nsec;
 
 	while (next_menu == Game_Play){
 		XWindowAttributes window_attributes_return;
 		XGetWindowAttributes(display, window, &window_attributes_return);
 		win_width = window_attributes_return.width;
 		win_height = window_attributes_return.height;
 
 		clock_gettime(CLOCK_MONOTONIC, &ts);
 		t1 = ts.tv_nsec;
 		dt = t1 - t0 > 0 ? t1 - t0 : t1 - t0 + 1000 * 1000 * 1000;
 		while(dt < 1.0/FPS * 1000 * 1000 * 1000){
 			clock_gettime(CLOCK_MONOTONIC, &ts);
 			t1 = ts.tv_nsec;
 			dt = t1 - t0 > 0 ? t1 - t0 : t1 - t0 + 1000 * 1000 * 1000;
 		}
 
 		//handle_interactions(); //handle interactions between objects
 		handle_inputs();
 		obj_next_tick(square, 1.0/FPS);
 		for (int i = 0; i < BLOCK_COUNT; i++)
 			obj_next_tick(blocks[i], 1.0/FPS);
 		handle_collision();
 
 		clock_gettime(CLOCK_MONOTONIC, &ts);
 		t0 = ts.tv_nsec;
 
 		XClearArea(display, window, 0, 0, win_width, win_height, False);
 		draw_object(square, pgc);
 		for (int i = 0; i < BLOCK_COUNT; i++){
 			XSetForeground(display, bgc, 255 << 8 * i);
 			draw_object(blocks[i], bgc);
 		}
 		//XDrawString(display, window, fgc, square->px, square->py, "player", 6);
 	}
 }
 
 void
 draw_object(Obj *obj, GC gc)
 {
 	XFillRectangle(display, window, gc, obj->px, obj->py, obj->width, obj->height);
 }
 
 void
 end_menu(void)
 {
 	next_menu = Start_Menu;
 }
 
 void
 handle_inputs(void)
 {
 	while (XPending(display) > 0) {
 		XEvent event;
 		XNextEvent(display, &event);
 		switch (event.type) {
 		case KeyPress: {
 			switch (XLookupKeysym(&event.xkey, 0)) {
 			case 'q':
 				next_menu = End_Menu;
 				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 KeyRelease: {
 			switch (XLookupKeysym(&event.xkey, 0)) {
 			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;
 		case ClientMessage: {
 			if ((Atom) event.xclient.data.l[0] == wm_delete_window) {
 				next_menu = Quit;
 			}
 		} break;
 		default:
 			break;
 		}
 	}
 
 	square->vx = 0;
 	if (key_state[Key_D] == Key_Down)
 		square->vx += 100;
 	else
 		square->vx -= 100;
 	if (key_state[Key_A] == Key_Down)
 		square->vx += -100;
 	else
 		square->vx -= -100;
 
 	square->vy = 0;
 	if (key_state[Key_S] == Key_Down)
 		square->vy += 100;
 	else
 		square->vy -= 100;
 	if (key_state[Key_W] == Key_Down)
 		square->vy += -100;
 	else
 		square->vy -= -100;
 }
 
 void
 handle_collision(void)
 {
 	for (int i = 0; i < BLOCK_COUNT; i++){
 		if (blocks[i]->px <= 0){
 			blocks[i]->px = 0;
 			blocks[i]->vx *= -1;
 		}
 		if (win_width <= blocks[i]->px + blocks[i]->width){
 			blocks[i]->px = win_width - blocks[i]->width;
 			blocks[i]->vx *= -1;
 		}
 
 		if (blocks[i]->py <= 0){
 			blocks[i]->py = 0;
 			blocks[i]->vy *= -1;
 		}
 		if (win_height <= blocks[i]->py + blocks[i]->height){
 			blocks[i]->py = win_height - blocks[i]->height;
 			blocks[i]->vy *= -1;
 		}
 	}
 
 	if (square->px <= 0){
 		square->px = 0;
 		square->vx *= -1;
 	}
 	if (win_width <= square->px + square->width){
 		square->px = win_width - square->width;
 		square->vx *= -1;
 	}
 	if (square->py <= 0){
 		square->py = 0;
 		square->vy *= -1;
 	}
 	if (win_height <= square->py + square->height){
 		square->py = win_height - square->height;
 		square->vy *= -1;
 	}
 
 	for (int i = 0; i < BLOCK_COUNT; i++){
 		for (int j = i; j < BLOCK_COUNT; j++){
 			obj_handle_collision(blocks[i], blocks[j]);
 		}
 	}
 	for (int i = 0; i < BLOCK_COUNT; i++){
 		obj_handle_collision(blocks[i], square);
 	}
 }
 
 
 void
 cleanup(void)
 {
 	XCloseDisplay(display);
 }
 
 int
 main(void)
 {
 	setup();
 
 	while (next_menu != Quit){
 		switch (next_menu){
 		case Start_Menu:
 			start_menu();
 			break;
 		case Game_Play:
 			game_play();
 			break;
 		case End_Menu:
 			end_menu();
 			break;
 		default:
 			break;
 		}
 	}
 
 	cleanup();
 	return 0;
 }