int main(void)
{
ALLEGRO_TIMER *timer;
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_MONITOR_INFO info;
int w = 640, h = 480;
bool done = false;
bool need_redraw = true;
bool background = false;
example.show_help = true;
if (!al_init()) {
abort_example("Failed to init Allegro.\n");
return 1;
}
if (!al_init_image_addon()) {
abort_example("Failed to init IIO addon.\n");
return 1;
}
al_init_font_addon();
al_get_num_video_adapters();
al_get_monitor_info(0, &info);
#ifdef ALLEGRO_IPHONE
al_set_new_display_flags(ALLEGRO_FULLSCREEN_WINDOW);
#endif
al_set_new_display_option(ALLEGRO_SUPPORTED_ORIENTATIONS,
ALLEGRO_DISPLAY_ORIENTATION_ALL, ALLEGRO_SUGGEST);
example.display = al_create_display(w, h);
w = al_get_display_width(example.display);
h = al_get_display_height(example.display);
if (!example.display) {
abort_example("Error creating display.\n");
return 1;
}
if (!al_install_keyboard()) {
abort_example("Error installing keyboard.\n");
return 1;
}
if (!al_install_mouse()) {
abort_example("Error installing mouse.\n");
return 1;
}
example.font = al_load_font("data/fixed_font.tga", 0, 0);
if (!example.font) {
abort_example("Error loading data/fixed_font.tga\n");
return 1;
}
example.mysha = al_load_bitmap("data/mysha256x256.png");
if (!example.mysha) {
abort_example("Error loading data/mysha256x256.png\n");
return 1;
}
example.white = al_map_rgb_f(1, 1, 1);
example.half_white = al_map_rgba_f(1, 1, 1, 0.5);
example.dark = al_map_rgb(15, 15, 15);
example.red = al_map_rgb_f(1, 0.2, 0.1);
change_size(256);
add_sprite();
add_sprite();
timer = al_create_timer(1.0 / FPS);
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_mouse_event_source());
al_register_event_source(queue, al_get_timer_event_source(timer));
if (al_install_touch_input())
al_register_event_source(queue, al_get_touch_input_event_source());
al_register_event_source(queue, al_get_display_event_source(example.display));
al_start_timer(timer);
while (!done) {
float x, y;
ALLEGRO_EVENT event;
w = al_get_display_width(example.display);
h = al_get_display_height(example.display);
if (!background && need_redraw && al_is_event_queue_empty(queue)) {
double t = -al_get_time();
add_time();
al_clear_to_color(al_map_rgb_f(0, 0, 0));
redraw();
t += al_get_time();
example.direct_speed_measure = t;
al_flip_display();
need_redraw = false;
}
al_wait_for_event(queue, &event);
switch (event.type) {
case ALLEGRO_EVENT_KEY_CHAR: /* includes repeats */
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
done = true;
else if (event.keyboard.keycode == ALLEGRO_KEY_UP) {
add_sprites(1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_DOWN) {
remove_sprites(1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_LEFT) {
change_size(example.bitmap_size - 1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_RIGHT) {
change_size(example.bitmap_size + 1);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_F1) {
example.show_help ^= 1;
}
else if (event.keyboard.keycode == ALLEGRO_KEY_SPACE) {
example.use_memory_bitmaps ^= 1;
change_size(example.bitmap_size);
}
else if (event.keyboard.keycode == ALLEGRO_KEY_B) {
example.blending++;
if (example.blending == 4)
example.blending = 0;
}
break;
case ALLEGRO_EVENT_DISPLAY_CLOSE:
done = true;
break;
case ALLEGRO_EVENT_DISPLAY_HALT_DRAWING:
background = true;
al_acknowledge_drawing_halt(event.display.source);
break;
case ALLEGRO_EVENT_DISPLAY_RESUME_DRAWING:
background = false;
break;
case ALLEGRO_EVENT_DISPLAY_RESIZE:
al_acknowledge_resize(event.display.source);
break;
case ALLEGRO_EVENT_TIMER:
update();
need_redraw = true;
break;
case ALLEGRO_EVENT_TOUCH_BEGIN:
x = event.touch.x;
y = event.touch.y;
goto click;
case ALLEGRO_EVENT_MOUSE_BUTTON_UP:
x = event.mouse.x;
y = event.mouse.y;
goto click;
click:
{
int fh = al_get_font_line_height(example.font);
if (x < 80 && y >= h - fh * 10) {
int button = (y - (h - fh * 10)) / (fh * 2);
if (button == 0) {
example.use_memory_bitmaps ^= 1;
change_size(example.bitmap_size);
}
if (button == 1) {
example.blending++;
if (example.blending == 4)
example.blending = 0;
}
if (button == 3) {
if (x < 40)
remove_sprites(example.sprite_count / 2);
else
add_sprites(example.sprite_count);
}
if (button == 2) {
int s = example.bitmap_size * 2;
if (x < 40)
s = example.bitmap_size / 2;
change_size(s);
}
if (button == 4) {
example.show_help ^= 1;
}
}
break;
}
}
}
al_destroy_bitmap(example.bitmap);
return 0;
}
int main(void)
{
ALLEGRO_DISPLAY *displays[2];
ALLEGRO_MONITOR_INFO *info;
int adapter_count;
int x, y;
ALLEGRO_FONT *myfont;
ALLEGRO_EVENT_QUEUE *events;
ALLEGRO_EVENT event;
int i;
srand(time(NULL));
if (!al_init()) {
abort_example("Could not init Allegro.\n");
}
al_install_mouse();
al_init_font_addon();
al_init_image_addon();
adapter_count = al_get_num_video_adapters();
info = malloc(adapter_count * sizeof(ALLEGRO_MONITOR_INFO));
for (i = 0; i < adapter_count; i++) {
al_get_monitor_info(i, &info[i]);
}
x = ((info[0].x2 - info[0].x1) / 3) - (W / 2);
y = ((info[0].y2 - info[0].y1) / 2) - (H / 2);
al_set_new_window_position(x, y);
displays[0] = al_create_display(W, H);
x *= 2;
al_set_new_window_position(x, y);
displays[1] = al_create_display(W, H);
if (!displays[0] || !displays[1]) {
abort_example("Could not create displays.\n");
}
al_set_new_bitmap_flags(ALLEGRO_MEMORY_BITMAP);
myfont = al_load_font("data/fixed_font.tga", 0, 0);
if (!myfont) {
abort_example("Could not load font.\n");
}
events = al_create_event_queue();
al_register_event_source(events, al_get_mouse_event_source());
al_register_event_source(events, al_get_display_event_source(displays[0]));
al_register_event_source(events, al_get_display_event_source(displays[1]));
for (;;) {
for (i = 0; i < 2; i++) {
al_set_target_backbuffer(displays[i]);
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
if (i == 0)
al_clear_to_color(al_map_rgb(255, 0, 255));
else
al_clear_to_color(al_map_rgb(155, 255, 0));
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_INVERSE_ALPHA);
al_draw_textf(myfont, al_map_rgb(0, 0, 0), 50, 50, ALLEGRO_ALIGN_CENTRE, "Click me..");
al_flip_display();
}
if (al_wait_for_event_timed(events, &event, 1)) {
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
else if (event.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN) {
int a = rand() % adapter_count;
int w = info[a].x2 - info[a].x1;
int h = info[a].y2 - info[a].y1;
int margin = 20;
x = margin + info[a].x1 + (rand() % (w - W - margin));
y = margin + info[a].y1 + (rand() % (h - H - margin));
al_set_window_position(event.mouse.display, x, y);
}
}
}
al_destroy_event_queue(events);
al_destroy_display(displays[0]);
al_destroy_display(displays[1]);
free(info);
return 0;
}
HWND _al_win_create_window(ALLEGRO_DISPLAY *display, int width, int height, int flags)
{
HWND my_window;
RECT win_size;
DWORD style;
DWORD ex_style;
int pos_x, pos_y;
bool center = false;
ALLEGRO_MONITOR_INFO info;
ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)display;
WINDOWINFO wi;
int bw, bh;
wi.cbSize = sizeof(WINDOWINFO);
if (!(flags & ALLEGRO_FULLSCREEN)) {
if (flags & ALLEGRO_RESIZABLE) {
style = WS_OVERLAPPEDWINDOW;
ex_style = WS_EX_APPWINDOW|WS_EX_OVERLAPPEDWINDOW;
}
else {
style = WS_SYSMENU | WS_MINIMIZEBOX;
ex_style = WS_EX_APPWINDOW;
}
}
else {
style = WS_POPUP;
ex_style = WS_EX_APPWINDOW;
}
al_get_new_window_position(&pos_x, &pos_y);
if (pos_x == INT_MAX) {
pos_x = pos_y = 0;
if (!(flags & ALLEGRO_FULLSCREEN)) {
center = true;
}
}
if (center) {
//int a = al_get_current_video_adapter();
int a = win_display->adapter;
if (a == -1) {
ALLEGRO_SYSTEM *sys = al_get_system_driver();
unsigned int num;
bool *is_fullscreen;
unsigned int i;
unsigned int fullscreen_found = 0;
num = al_get_num_video_adapters();
is_fullscreen = _AL_MALLOC(sizeof(bool)*num);
memset(is_fullscreen, 0, sizeof(bool)*num);
for (i = 0; i < sys->displays._size; i++) {
ALLEGRO_DISPLAY **dptr = _al_vector_ref(&sys->displays, i);
ALLEGRO_DISPLAY *d = *dptr;
if (d->flags & ALLEGRO_FULLSCREEN) {
ALLEGRO_DISPLAY_WIN *win_display = (ALLEGRO_DISPLAY_WIN *)d;
is_fullscreen[win_display->adapter] = true;
fullscreen_found++;
}
}
if (fullscreen_found && fullscreen_found < num) {
for (i = 0; i < num; i++) {
if (is_fullscreen[i] == false) {
a = i;
break;
}
}
}
else
a = 0;
_AL_FREE(is_fullscreen);
}
al_set_current_video_adapter(a);
al_get_monitor_info(a, &info);
win_size.left = info.x1 + (info.x2 - info.x1 - width) / 2;
win_size.right = win_size.left + width;
win_size.top = info.y1 + (info.y2 - info.y1 - height) / 2;
win_size.bottom = win_size.top + height;
AdjustWindowRectEx(&win_size, style, false, ex_style);
pos_x = win_size.left;
pos_y = win_size.top;
}
my_window = CreateWindowEx(ex_style,
"ALEX", "Allegro", style,
pos_x, pos_y, width, height,
NULL,NULL,window_class.hInstance,0);
GetWindowInfo(my_window, &wi);
bw = (wi.rcClient.left - wi.rcWindow.left) + (wi.rcWindow.right - wi.rcClient.right),
bh = (wi.rcClient.top - wi.rcWindow.top) + (wi.rcWindow.bottom - wi.rcClient.bottom),
SetWindowPos(my_window, 0, pos_x-bw/2, pos_y-bh/2,
width+bw,
height+bh,
SWP_NOMOVE | SWP_NOZORDER);
if (flags & ALLEGRO_NOFRAME) {
SetWindowLong(my_window, GWL_STYLE, WS_VISIBLE);
SetWindowLong(my_window, GWL_EXSTYLE, WS_EX_APPWINDOW);
SetWindowPos(my_window, 0, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER | SWP_FRAMECHANGED);
}
ShowWindow(my_window, SW_SHOW);
if (!(flags & ALLEGRO_RESIZABLE) && !(flags & ALLEGRO_FULLSCREEN)) {
/* Make the window non-resizable */
HMENU menu;
menu = GetSystemMenu(my_window, false);
DeleteMenu(menu, SC_SIZE, MF_BYCOMMAND);
DeleteMenu(menu, SC_MAXIMIZE, MF_BYCOMMAND);
DrawMenuBar(my_window);
}
return my_window;
}
void Gamestate_ProcessEvent(struct Game *game, struct MenuResources* data, ALLEGRO_EVENT *ev) {
if ((data->menustate == MENUSTATE_ABOUT) && (ev->type == ALLEGRO_EVENT_KEY_DOWN)) {
ChangeMenuState(game, data, MENUSTATE_MAIN);
return;
}
if (ev->type != ALLEGRO_EVENT_KEY_DOWN) return;
if (data->starting) return;
if (ev->keyboard.keycode==ALLEGRO_KEY_UP) {
data->selected--;
if ((data->selected == 2) && ((data->menustate==MENUSTATE_VIDEO) || (data->menustate==MENUSTATE_OPTIONS) || (data->menustate==MENUSTATE_AUDIO))) {
data->selected --;
}
if ((data->menustate==MENUSTATE_VIDEO) && (data->selected==1) && (data->options.fullscreen)) data->selected--;
al_play_sample_instance(data->click);
} else if (ev->keyboard.keycode==ALLEGRO_KEY_DOWN) {
data->selected++;
if ((data->menustate==MENUSTATE_VIDEO) && (data->selected==1) && (data->options.fullscreen)) data->selected++;
if ((data->selected == 2) && ((data->menustate==MENUSTATE_VIDEO) || (data->menustate==MENUSTATE_OPTIONS) || (data->menustate==MENUSTATE_AUDIO))) {
data->selected ++;
}
al_play_sample_instance(data->click);
}
if (ev->keyboard.keycode==ALLEGRO_KEY_ENTER) {
char *text;
al_play_sample_instance(data->click);
switch (data->menustate) {
case MENUSTATE_MAIN:
switch (data->selected) {
case 0:
StartGame(game, data);
break;
case 1:
ChangeMenuState(game,data,MENUSTATE_OPTIONS);
break;
case 2:
ChangeMenuState(game,data,MENUSTATE_ABOUT);
break;
case 3:
UnloadGamestate(game, "menu");
break;
}
break;
case MENUSTATE_HIDDEN:
ChangeMenuState(game,data,MENUSTATE_MAIN);
break;
case MENUSTATE_AUDIO:
text = malloc(255*sizeof(char));
switch (data->selected) {
case 0:
game->config.music--;
if (game->config.music<0) game->config.music=10;
snprintf(text, 255, "%d", game->config.music);
SetConfigOption(game, "SuperDerpy", "music", text);
al_set_mixer_gain(game->audio.music, game->config.music/10.0);
break;
case 1:
game->config.fx--;
if (game->config.fx<0) game->config.fx=10;
snprintf(text, 255, "%d", game->config.fx);
SetConfigOption(game, "SuperDerpy", "fx", text);
al_set_mixer_gain(game->audio.fx, game->config.fx/10.0);
break;
case 2:
game->config.voice--;
if (game->config.voice<0) game->config.voice=10;
snprintf(text, 255, "%d", game->config.voice);
SetConfigOption(game, "SuperDerpy", "voice", text);
al_set_mixer_gain(game->audio.voice, game->config.voice/10.0);
break;
case 3:
ChangeMenuState(game,data,MENUSTATE_OPTIONS);
break;
}
free(text);
break;
case MENUSTATE_OPTIONS:
switch (data->selected) {
case 0:
ChangeMenuState(game,data,MENUSTATE_VIDEO);
break;
case 1:
ChangeMenuState(game,data,MENUSTATE_AUDIO);
break;
case 3:
ChangeMenuState(game,data,MENUSTATE_MAIN);
break;
default:
break;
}
break;
case MENUSTATE_VIDEO:
switch (data->selected) {
case 0:
data->options.fullscreen = !data->options.fullscreen;
if (data->options.fullscreen)
SetConfigOption(game, "SuperDerpy", "fullscreen", "1");
else
SetConfigOption(game, "SuperDerpy", "fullscreen", "0");
al_set_display_flag(game->display, ALLEGRO_FULLSCREEN_WINDOW, data->options.fullscreen);
SetupViewport(game);
PrintConsole(game, "Fullscreen toggled");
break;
case 1:
data->options.resolution++;
int max = 0, i = 0;
for (i=0; i < al_get_num_video_adapters(); i++) {
ALLEGRO_MONITOR_INFO aminfo;
al_get_monitor_info(i , &aminfo);
int desktop_width = aminfo.x2 - aminfo.x1 + 1;
int desktop_height = aminfo.y2 - aminfo.y1 + 1;
int localmax = desktop_width / 320;
if (desktop_height / 180 < localmax) localmax = desktop_height / 180;
if (localmax > max) max = localmax;
}
if (data->options.resolution > max) data->options.resolution = 1;
text = malloc(255*sizeof(char));
snprintf(text, 255, "%d", data->options.resolution * 320);
SetConfigOption(game, "SuperDerpy", "width", text);
snprintf(text, 255, "%d", data->options.resolution * 180);
SetConfigOption(game, "SuperDerpy", "height", text);
free(text);
al_resize_display(game->display, data->options.resolution * 320, data->options.resolution * 180);
if ((al_get_display_width(game->display) < (data->options.resolution * 320)) || (al_get_display_height(game->display) < (data->options.resolution * 180))) {
SetConfigOption(game, "SuperDerpy", "width", "320");
SetConfigOption(game, "SuperDerpy", "height", "180");
data->options.resolution = 1;
al_resize_display(game->display, 320, 180);
}
SetupViewport(game);
PrintConsole(game, "Resolution changed");
break;
case 3:
ChangeMenuState(game,data,MENUSTATE_OPTIONS);
break;
default:
break;
}
break;
case MENUSTATE_ABOUT:
break;
default:
UnloadGamestate(game, "menu");
return;
break;
}
} else if (ev->keyboard.keycode==ALLEGRO_KEY_ESCAPE) {
switch (data->menustate) {
case MENUSTATE_OPTIONS:
ChangeMenuState(game,data,MENUSTATE_MAIN);
break;
case MENUSTATE_ABOUT:
ChangeMenuState(game,data,MENUSTATE_MAIN);
break;
case MENUSTATE_HIDDEN:
UnloadGamestate(game, "menu");
break;
case MENUSTATE_VIDEO:
ChangeMenuState(game,data,MENUSTATE_OPTIONS);
break;
case MENUSTATE_AUDIO:
ChangeMenuState(game,data,MENUSTATE_OPTIONS);
break;
default:
ChangeMenuState(game,data,MENUSTATE_HIDDEN);
data->selected = -1;
data->title_pos = 0;
return;
}
}
if (data->selected==-1) data->selected=3;
if (data->selected==4) data->selected=0;
return;
}