static void run(void)
{
ALLEGRO_EVENT event;
bool quit = false;
while (!quit) {
while (al_get_next_event(queue, &event)) {
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
quit = true;
else if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE)
quit = true;
else if (event.keyboard.keycode == ALLEGRO_KEY_SPACE) {
bool opp = !(al_get_display_flags(display) & ALLEGRO_FULLSCREEN_WINDOW);
al_set_display_flag(display, ALLEGRO_FULLSCREEN_WINDOW, opp);
redraw();
}
else if (event.keyboard.keycode == ALLEGRO_KEY_ENTER) {
big = !big;
if (big)
al_resize_display(display, 800, 600);
else
al_resize_display(display, 640, 480);
redraw();
}
}
}
/* FIXME: Lazy timing */
al_rest(0.02);
redraw();
}
}
void Window::resize(int width, int height, Window::WindowMode windowMode) {
assert(mDisplay);
if (windowMode == mWindowMode) {
al_resize_display(mDisplay, width, height);
return;
}
al_unregister_event_source(mEventQueue, al_get_display_event_source(mDisplay));
al_destroy_display(mDisplay);
switch (windowMode) {
case Windowed:
al_set_new_display_flags(ALLEGRO_WINDOWED | ALLEGRO_OPENGL); break;
case Resizable:
al_set_new_display_flags(ALLEGRO_RESIZABLE | ALLEGRO_OPENGL); break;
case FullScreen:
al_set_new_display_flags(ALLEGRO_FULLSCREEN | ALLEGRO_OPENGL); break;
}
mDisplay = al_create_display(width, height);
if (mDisplay == 0) {
error(U"Creating a window failed");
sys::closeProgram();
}
al_register_event_source(mEventQueue, al_get_display_event_source(mDisplay));
activate();
}
void diminui_tela(void* ptr){
Jogo* jogo = (Jogo*) ptr;
if (jogo->largura > LARGURA_INICIAL){
jogo->largura -= MEDIDA_RESIZE*4;
jogo->altura -= MEDIDA_RESIZE*3;
al_resize_display(jogo->display, jogo->largura , jogo->altura);
}
}
void aumenta_tela(void* ptr){
Jogo* jogo = (Jogo*) ptr;
if (true){
jogo->largura += MEDIDA_RESIZE*4;
jogo->altura += MEDIDA_RESIZE*3;
al_resize_display(jogo->display, jogo->largura , jogo->altura);
}
}
int main(void)
{
ALLEGRO_DISPLAY *display;
ALLEGRO_EVENT_QUEUE *events;
ALLEGRO_EVENT event;
double last_resize;
int rs = 100;
/* Initialize Allegro and create an event queue. */
if (!al_init()) {
abort_example("Could not init Allegro.\n");
return 1;
}
events = al_create_event_queue();
/* Setup a display driver and register events from it. */
al_set_new_display_flags(ALLEGRO_RESIZABLE);
display = al_create_display(rs, rs);
al_register_event_source(events, al_get_display_event_source(display));
/* Setup a keyboard driver and regsiter events from it. */
al_install_keyboard();
al_register_event_source(events, al_get_keyboard_event_source());
/* Display a pulsating window until a key or the closebutton is pressed. */
redraw();
last_resize = 0;
while (true) {
if (al_get_next_event(events, &event)) {
if (event.type == ALLEGRO_EVENT_DISPLAY_RESIZE) {
ALLEGRO_DISPLAY_EVENT *de = &event.display;
al_acknowledge_resize(de->source);
redraw();
}
if (event.type == ALLEGRO_EVENT_DISPLAY_CLOSE) {
break;
}
if (event.type == ALLEGRO_EVENT_KEY_DOWN) {
break;
}
}
if (al_current_time() - last_resize > 0.1) {
int s;
last_resize = al_current_time();
rs += 10;
if (rs == 300)
rs = 100;
s = rs;
if (s > 200)
s = 400 - s;
al_resize_display(s, s);
}
}
return 0;
}
static SCM
game_resize_display (SCM game_smob, SCM s_width, SCM s_height)
{
Game *game = check_game (game_smob);
int width = scm_to_int (s_width);
int height = scm_to_int (s_height);
al_resize_display (game->display, width, height);
return SCM_UNSPECIFIED;
}
static void main_loop(ALLEGRO_DISPLAY *display, ALLEGRO_BITMAP *picture)
{
ALLEGRO_EVENT_QUEUE *queue;
ALLEGRO_EVENT event;
int new_res;
queue = al_create_event_queue();
al_register_event_source(queue, al_get_keyboard_event_source());
al_register_event_source(queue, al_get_display_event_source(display));
while (1) {
if (al_is_event_queue_empty(queue)) {
redraw(picture);
}
al_wait_for_event(queue, &event);
if (event.type != ALLEGRO_EVENT_KEY_CHAR) {
continue;
}
if (event.keyboard.keycode == ALLEGRO_KEY_ESCAPE) {
break;
}
new_res = cur_res;
if (event.keyboard.unichar == '+' ||
event.keyboard.unichar == ' ' ||
event.keyboard.keycode == ALLEGRO_KEY_ENTER) {
new_res++;
if (new_res >= NUM_RESOLUTIONS)
new_res = 0;
}
else if (event.keyboard.unichar == '-') {
new_res--;
if (new_res < 0)
new_res = NUM_RESOLUTIONS - 1;
}
if (new_res != cur_res) {
cur_res = new_res;
log_printf("Switching to %dx%d... ", res[cur_res].w, res[cur_res].h);
if (al_resize_display(display, res[cur_res].w, res[cur_res].h)) {
log_printf("Succeeded.\n");
}
else {
log_printf("Failed. current resolution: %dx%d\n",
al_get_display_width(display), al_get_display_height(display));
}
}
}
al_destroy_event_queue(queue);
}
bool _al_win_toggle_display_flag(ALLEGRO_DISPLAY *display, int flag, bool onoff)
{
ALLEGRO_DISPLAY_WIN *win_display = (void*)display;
double timeout;
switch(flag) {
case ALLEGRO_NOFRAME:
_al_win_toggle_window_frame(display, win_display->window, display->w, display->h, onoff);
return true;
case ALLEGRO_FULLSCREEN_WINDOW:
if (onoff == ((display->flags & ALLEGRO_FULLSCREEN_WINDOW) != 0))
return true;
_al_win_toggle_display_flag(display, ALLEGRO_NOFRAME, !onoff);
if (onoff) {
ALLEGRO_MONITOR_INFO mi;
int adapter = al_get_current_video_adapter();
if (adapter == -1)
adapter = 0;
al_get_monitor_info(adapter, &mi);
display->flags |= ALLEGRO_FULLSCREEN_WINDOW;
display->w = mi.x2 - mi.x1;
display->h = mi.y2 - mi.y1;
}
else {
display->flags &= ~ALLEGRO_FULLSCREEN_WINDOW;
display->w = win_display->toggle_w;
display->h = win_display->toggle_h;
}
al_resize_display(display->w, display->h);
timeout = al_current_time() + 3; // 3 seconds...
while (al_current_time() < timeout) {
if (win_display->can_acknowledge) {
al_acknowledge_resize(display);
break;
}
}
if (onoff) {
al_set_window_position(display, 0, 0);
// Pop it to the front
// FIXME: HOW?!
}
/* FIXME: else center the window? */
return true;
}
return false;
}
static void xdpy_apply_window_constraints(ALLEGRO_DISPLAY *display,
bool onoff)
{
int posX;
int posY;
ALLEGRO_SYSTEM_XGLX *system = (ALLEGRO_SYSTEM_XGLX *)al_get_system_driver();
_al_mutex_lock(&system->lock);
if (onoff) {
al_get_window_position(display, &posX, &posY);
_al_xwin_set_size_hints(display, posX, posY);
}
else {
_al_xwin_reset_size_hints(display);
}
_al_mutex_unlock(&system->lock);
al_resize_display(display, display->w, display->h);
}
/* Function: al_set_display_menu
*/
bool al_set_display_menu(ALLEGRO_DISPLAY *display, ALLEGRO_MENU *menu)
{
DISPLAY_MENU *dm = NULL;
size_t i;
int menu_height = _al_get_menu_display_height();
bool automatic_menu_display_resize = true;
const char* automatic_menu_display_resize_value =
al_get_config_value(al_get_system_config(), "compatibility", "automatic_menu_display_resize");
if (automatic_menu_display_resize_value && strcmp(automatic_menu_display_resize_value, "false") == 0)
automatic_menu_display_resize = false;
ASSERT(display);
/* Check if this display has a menu associated with it */
for (i = 0; i < _al_vector_size(&display_menus); ++i) {
dm = (DISPLAY_MENU *) _al_vector_ref(&display_menus, i);
if (dm->display == display)
break;
}
/* If no display was found, reset dm to NULL */
if (i == _al_vector_size(&display_menus))
dm = NULL;
if (!menu) {
/* Removing the menu */
if (!dm)
return false;
_al_hide_display_menu(display, dm->menu);
_al_walk_over_menu(dm->menu, set_menu_display_r, NULL);
_al_vector_delete_at(&display_menus, i);
if (automatic_menu_display_resize && menu_height > 0) {
display->extra_resize_height = 0;
al_resize_display(display, al_get_display_width(display), al_get_display_height(display));
}
}
else {
/* Setting the menu. It must not currently be attached to any
* display, and it cannot have a parent menu. */
if (menu->display || menu->parent)
return false;
if (dm) {
/* hide the existing menu */
_al_hide_display_menu(display, dm->menu);
_al_walk_over_menu(dm->menu, set_menu_display_r, NULL);
}
if (!_al_show_display_menu(display, menu)) {
/* Unable to set the new menu, but already have hidden the
* previous one, so delete the display_menus slot. */
if (dm)
_al_vector_delete_at(&display_menus, i);
return false;
}
/* Set the entire menu tree as owned by the display */
_al_walk_over_menu(menu, set_menu_display_r, display);
if (!dm)
dm = _al_vector_alloc_back(&display_menus);
if (automatic_menu_display_resize && menu_height > 0) {
/* Temporarily disable the constraints so we don't send a RESIZE_EVENT. */
bool old_constraints = display->use_constraints;
display->use_constraints = false;
display->extra_resize_height = menu_height;
al_resize_display(display, al_get_display_width(display), al_get_display_height(display));
display->use_constraints = old_constraints;
}
dm->display = display;
dm->menu = menu;
}
return true;
}
bool _al_win_set_display_flag(ALLEGRO_DISPLAY *display, int flag, bool onoff)
{
ALLEGRO_DISPLAY_WIN *win_display = (void*)display;
//double timeout;
ALLEGRO_MONITOR_INFO mi;
memset(&mi, 0, sizeof(mi));
switch (flag) {
case ALLEGRO_FRAMELESS: {
if (onoff) {
display->flags |= ALLEGRO_FRAMELESS;
}
else {
display->flags &= ~ALLEGRO_FRAMELESS;
}
_al_win_set_window_frameless(display, win_display->window,
(display->flags & ALLEGRO_FRAMELESS));
return true;
}
case ALLEGRO_FULLSCREEN_WINDOW:
if ((display->flags & ALLEGRO_FULLSCREEN_WINDOW) && onoff) {
ALLEGRO_DEBUG("Already a fullscreen window\n");
return true;
}
if (!(display->flags & ALLEGRO_FULLSCREEN_WINDOW) && !onoff) {
ALLEGRO_DEBUG("Already a non-fullscreen window\n");
return true;
}
if (onoff) {
/* Switch off frame in fullscreen window mode. */
_al_win_set_window_frameless(display, win_display->window, true);
}
else {
/* Respect display flag in windowed mode. */
_al_win_set_window_frameless(display, win_display->window,
(display->flags & ALLEGRO_FRAMELESS));
}
if (onoff) {
int adapter = win_display->adapter;
al_get_monitor_info(adapter, &mi);
display->flags |= ALLEGRO_FULLSCREEN_WINDOW;
display->w = mi.x2 - mi.x1;
display->h = mi.y2 - mi.y1;
}
else {
display->flags &= ~ALLEGRO_FULLSCREEN_WINDOW;
display->w = win_display->toggle_w;
display->h = win_display->toggle_h;
}
ASSERT(!!(display->flags & ALLEGRO_FULLSCREEN_WINDOW) == onoff);
// Hide the window temporarily
SetWindowPos(win_display->window, 0, 0, 0, 0, 0, SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE);
al_resize_display(display, display->w, display->h);
if (onoff) {
// Re-set the TOPMOST flag and move to position
SetWindowPos(win_display->window, HWND_TOPMOST, mi.x1, mi.y1, 0, 0, SWP_NOSIZE);
// Hide the taskbar if fullscreening on primary monitor
if (win_display->adapter == 0) {
SetWindowPos(
FindWindow("Shell_traywnd", ""),
0,
0, 0,
0, 0,
SWP_HIDEWINDOW | SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE);
}
}
else {
int pos_x = 0;
int pos_y = 0;
WINDOWINFO wi;
int bw, bh;
// Unset the topmost flag
SetWindowPos(win_display->window, HWND_NOTOPMOST, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE);
// Show the taskbar
SetWindowPos(
FindWindow("Shell_traywnd", ""), 0, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE);
// Center the window
_al_win_get_window_center(win_display, display->w, display->h, &pos_x, &pos_y);
GetWindowInfo(win_display->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(
win_display->window, HWND_TOP, 0, 0, display->w+bw, display->h+bh, SWP_NOMOVE
);
SetWindowPos(
win_display->window, HWND_TOP, pos_x-bw/2, pos_y-bh/2, 0, 0, SWP_NOSIZE
);
}
// Show the window again
SetWindowPos(win_display->window, 0, 0, 0, 0, 0, SWP_SHOWWINDOW | SWP_NOSIZE | SWP_NOZORDER | SWP_NOMOVE);
ASSERT(!!(display->flags & ALLEGRO_FULLSCREEN_WINDOW) == onoff);
return true;
}
return false;
}
/*Altera o tamanho da janela
@param
ALLEGRO_DISPLAY *janela - janela onde ira desenhar a imagem
int h - altura da imagem
itn w - largura da imagem
*/
void resize(ALLEGRO_DISPLAY *janela, int h, int w) {
al_resize_display(janela, w, h);
al_clear_to_color(al_map_rgb(255, 255, 255));
al_flip_display();
}
// Handles button events, may be called once every frame
void* buttonhandler(BUTTONPTR button, void* data, int type)
{
typedef enum button_pressed {
NONE,
STARTB,
HOWTOPLAYB,
OPTIONSB,
HIGHSCOREB,
EXITB
} BPRESSED;
GDATAPTR game = (GDATAPTR)data;
ALLEGRO_DISPLAY *display = game->display;
static BPRESSED bpressed = NONE;
if(strcmp(button->blabel, "STARTBUTTON") == 0 && type == BPRESSED_CALL)
{
game_start_init();
execute_on_button_press();
bpressed = STARTB;
}
if(strcmp(button->blabel, "HOWTOPLAYBUTTON") == 0 && type == BPRESSED_CALL)
{
execute_on_button_press();
bpressed = HOWTOPLAYB;
}
if(strcmp(button->blabel, "OPTIONSBUTTON") == 0 && type == BPRESSED_CALL)
{
execute_on_button_press();
bpressed = OPTIONSB;
}
if(strcmp(button->blabel, "HIGHSCOREBUTTON") == 0 && type == BPRESSED_CALL)
{
execute_on_button_press();
bpressed = HIGHSCOREB;
}
if(strcmp(button->blabel, "EXITBUTTON") == 0 && type == BPRESSED_CALL)
{
execute_on_button_press();
bpressed = EXITB;
}
if(strcmp(button->blabel, "FULLSCREEN") == 0 && type == BPRESSED_CALL)
{
(al_get_display_flags(display) & ALLEGRO_FULLSCREEN_WINDOW) ?
al_toggle_display_flag(display, ALLEGRO_FULLSCREEN_WINDOW, false),
al_resize_display(display, 800, 600) :
al_toggle_display_flag(display, ALLEGRO_FULLSCREEN_WINDOW, true);
if(strcmp(button->btext.text, "FULLSCREEN") == 0)
button->btext.text = "WINDOWED";
else
button->btext.text = "FULLSCREEN";
}
if(strcmp(button->blabel, "FPS") == 0 && type == BPRESSED_CALL)
{
set_fps_status(!get_fps_status());
if(strcmp(button->btext.text, "FPS COUNTER: ON") == 0)
button->btext.text = "FPS COUNTER: OFF";
else
button->btext.text = "FPS COUNTER: ON";
}
if(strcmp(button->blabel, "BACK") == 0 && type == BPRESSED_CALL)
{
return_to_main_menu(game);
}
if(strcmp(button->blabel, "RESUME") == 0 && type == BPRESSED_CALL)
{
exit_pause(game);
mpressed = true;
}
if(strcmp(button->blabel, "EXITGAME") == 0 && type == BPRESSED_CALL)
{
game->exit = true;
}
if(strcmp(button->blabel, "QUITTOMENU") == 0 && type == BPRESSED_CALL)
{
return_to_main_menu(game);
}
if(strcmp(button->blabel, "QUITTOMENUGO") == 0 && type == BPRESSED_CALL)
{
return_to_main_menu(game);
}
if(strcmp(button->blabel, "CLEAR") == 0 && type == BPRESSED_CALL)
{
set_bflags_on_button(button, BLRELEASED);
remove_bflags_on_button(button, BLPRESSED);
remove_bflags_on_button(button, BVISIBLE);
clear_highscores();
}
if(type == CBANIMATION_CALL && (game->options || game->howtoplay || game->highscores || game->paused) && mpressed)
{
mpressed = false;
if(game->paused)
{
pause_cleanup();
game->gamestarted = true;
game->paused = false;
}
else
{
execute_on_M_press();
options_cleanup();
howtoplay_cleanup();
highscores_cleanup();
gameover_cleanup();
game->gamestarted = false;
game->exit = false;
game->options = false;
game->highscores = false;
game->howtoplay = false;
}
}
if(type == CBANIMATION_CALL && bpressed != NONE)
{
BUTTONPTR currentptr, firstptr = get_first_element_from_button_list();
currentptr = search_button_list_for_element(&firstptr, "STARTBUTTON");
remove_bflags_on_button(currentptr, BVISIBLE);
currentptr = search_button_list_for_element(&firstptr, "HOWTOPLAYBUTTON");
remove_bflags_on_button(currentptr, BVISIBLE);
currentptr = search_button_list_for_element(&firstptr, "OPTIONSBUTTON");
remove_bflags_on_button(currentptr, BVISIBLE);
currentptr = search_button_list_for_element(&firstptr, "HIGHSCOREBUTTON");
remove_bflags_on_button(currentptr, BVISIBLE);
currentptr = search_button_list_for_element(&firstptr, "EXITBUTTON");
remove_bflags_on_button(currentptr, BVISIBLE);
switch (bpressed)
{
case NONE: break;
case STARTB: game->gamestarted = true; break;
case HOWTOPLAYB: game->howtoplay = true; break;
case OPTIONSB: game->options = true; break;
case HIGHSCOREB: game->highscores = true; break;
case EXITB: game->exit = true; break;
default: bpressed = NONE; break;
}
bpressed = NONE;
}
return NULL;
}
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;
}
