void menu_run(const menu_type * menu) {
while (1) {
int cmd;
menu_display(menu);
cmd = menu_read_cmd(menu);
if (strchr(menu->quit_keys , cmd) != NULL) /* We have recieved a quit command - leave the building. */
break;
/*
OK - we start looking through all the available commands to see
which this is. */
{
int item_index = 0;
while (1) {
const menu_item_type * item = vector_iget_const(menu->items , item_index);
if (!item->separator) {
if(!item->helptext) {
if (strchr(item->key_set , cmd) != NULL) {
/* Calling the function ... */
menu_item_call( item );
break;
}
}
}
item_index++;
}
}
}
}
int main(void) {
Menu *mainMenu = menu_create();
int cmd = 1;
bool exit = false;
menu_setTitle(mainMenu, "GalaxY (V0.11.20)");
menu_addButtonText(mainMenu, "Jouer");
menu_addButtonText(mainMenu, "Charger");
menu_addButtonText(mainMenu, "Quitter");
while (!exit) {
menu_display(*mainMenu);
cmd = menu_getcmd(*mainMenu);
switch (cmd) {
case 1:
play();
break;
case 2:
break;
case 3:
exit = true;
break;
default:
break;
}
}
menu_destroy(mainMenu);
return 0;
}
void menu_down(menu_t *menu)
{
if (menu->current > 0) {
(menu->current)--;
menu_display(menu);
}
}
void menu_up(menu_t *menu)
{
if (menu->current < (menu->size - 1)) {
(menu->current)++;
menu_display(menu);
}
}
void menu_init(menu_t *menu, menuItems_t *items, uint8_t size)
{
menu->items = items;
menu->current = 0;
menu->size = size;
menu_display(menu);
}
/*
* Execute function for currently selected menu entry (or if it's a submenu,
* enter the submenu)
*
*/
void menu_select(menu_context_t *context) {
menu_entry_t *entry = &context->menu->entry[context->menu->current_entry];
if (entry->flags & MENU_FLAG_SUBMENU) {
// Submenu -- enter it
menu_enter(context, (menu_t *) entry->value);
} else {
// Regular entry -- execute function
entry->select(entry->value, entry->name);
}
// Re-display menu on return
menu_display(context);
}
int main()
{
// Peripheral initialisation
I2C_init();
LCD_init();
LCD_write("Loading...");
DEBUG_init();
// Function initialisation
WAVE_init();
synth_init();
CAN_init();
menu_display();
while (1)
{
menu_update();
}
// Keypad for synth debugging
/*int down = 0;
int key = -1;
while(1)
{
key = KEYPAD_get_key();
if ((key != -1) && !down)
{
int note = 69+key;
synth_note_on(note_to_freq(note),1.0);
LCD_write_int("%d",note_to_freq(note));
down = 1;
}
if ((key == -1) && down)
{
synth_note_off(1.0);
LCD_clear();
down = 0;
}
}*/
// Loop to allow interupts
while(1);
return(1);
}
/*
* Move up currently highlighted to previous entry, without going out of bounds.
* Also adjust current top entry in display if needed to fit new entry
* on display
*/
void menu_prev_entry(menu_context_t *context) {
menu_t *menu = context->menu;
uint8_t new_entry = menu->current_entry;
#ifndef CONFIG_TINYMENU_COMPACT
while (1) {
if (new_entry-- == 0) // Watch bounds
return;
if (!(menu->entry[new_entry].flags & MENU_FLAG_HIDDEN))
break;
}
#else
if (new_entry-- == 0)
return;
#endif
menu->current_entry = new_entry;
if (menu->current_entry < menu->top_entry)
menu->top_entry = menu->current_entry;
menu_display(context);
}
/*
* Move down currently highlighted to next entry, without going out of bounds.
* Also adjust current top entry in display if needed to fit new entry
* on display
*/
void menu_next_entry(menu_context_t *context) {
menu_t *menu = context->menu;
uint8_t new_entry = menu->current_entry;
#ifndef CONFIG_TINYMENU_COMPACT
while (1) {
if (++new_entry >= menu->num_entries) // watch bounds
return;
if (!(menu->entry[new_entry].flags & MENU_FLAG_HIDDEN))
break;
}
#else
if (++new_entry >= menu->num_entries)
return;
#endif
menu->current_entry = new_entry;
if (menu->current_entry >= menu->top_entry + context->height)
menu->top_entry = menu->current_entry - context->height;
menu_display(context);
}
int main(int argc, char *argv[]) {
struct game* game = game_new();
window_create(SIZE_BLOC * MAP_WIDTH,
SIZE_BLOC * MAP_HEIGHT + BANNER_HEIGHT + LINE_HEIGHT);
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
// to obtain the DEFAULT_GAME_FPS, we have to reach a loop duration of (1000 / DEFAULT_GAME_FPS) ms
int ideal_speed = 1000 / DEFAULT_GAME_FPS;
int timer, execution_speed;
// game loop
// fixed time rate implementation
int done = menu_display(game);
while (!done) {
timer = SDL_GetTicks();
done = game_update(game);
game_display(game);
if ( player_get_dead(game_get_player(game))) { // Reset the game if the player is dead
game_free(game);
game=game_new();
}
if(game_get_win(game) == 1)
done=1;
execution_speed = SDL_GetTicks() - timer;
if (execution_speed < ideal_speed)
SDL_Delay(ideal_speed - execution_speed); // we are ahead of ideal time. let's wait.
}
window_free();
game_free(game);
SDL_Quit();
return EXIT_SUCCESS;
}
void set_seed(void) {
Menu *menu = menu_create();
int cmd = 1;
bool running = true;
unsigned seed = 42;
menu_setTitle(menu, "Seed");
menu_addButtonText(menu, "Generer aleatoirement un seed");
menu_addButtonText(menu, "Entrer un seed");
while (running) {
menu_display(*menu);
cmd = menu_getcmd(*menu);
switch (cmd) {
case 1: {
seed = (unsigned)time(NULL) / clock();
printf("Seed: %u\n", seed);
running = false;
break;
}
case 2:
running = false;
printf("Entrez un seed: ");
scanf("%u", &seed);
purge_stdin();
break;
default:
running = false;
break;
}
srand(seed);
}
}
void game_display(struct game* game) {
assert(game);
int map_w, map_h;
window_clear();
if(game->nb_player == 1) {
map_w = map_get_width(level_get_curr_map(game->curr_level));
map_h = map_get_height(level_get_curr_map(game->curr_level));
for(int i = 0; i < map_w; i++)
for(int j = 0; j < map_h+2; j++)
window_display_image(sprite_get_empty(), i * SIZE_BLOC, j * SIZE_BLOC);
}
level_display(game_get_curr_level(game));
monster_display(level_get_curr_map(game->curr_level));
bomb_display(game, level_get_curr_map(game->curr_level));
game_banner_display(game);
if(game->nb_player == 1) { // Single player
struct player* player = game->players[0];
// Always display
player_display(player);
if(game->game_state == PLAYING) {
player_move(game, player, level_get_curr_map(game->curr_level));
monster_move(game, level_get_curr_map(game->curr_level), player);
player_update(player);
monster_update(level_get_curr_map(game->curr_level));
}
}
else { // Multi player
struct player* players_in_order[game->nb_player];
for(int i=0; i<game->nb_player; i++)
players_in_order[i] = game->players[i];
game_order_players_array(game, players_in_order);
for(int i = 0; i < game->nb_player; i++) {
player_display(players_in_order[i]);
if(game->game_state == PLAYING) {
player_move(game, players_in_order[i], level_get_curr_map(game->curr_level));
player_update(players_in_order[i]);
}
} // end for each player
} // end Multi player
if(game->game_state == PLAYING) {
bomb_update(level_get_curr_map(game->curr_level));
}
else if(game->game_state == PAUSED) {
map_w = map_get_width(level_get_curr_map(game->curr_level));
map_h = map_get_height(level_get_curr_map(game->curr_level));
int mid_w = map_w / 2 * SIZE_BLOC + map_w%2 * SIZE_BLOC / 2;
int mid_h = map_h / 2 * SIZE_BLOC + map_h%2 * SIZE_BLOC / 2;
menu_display(mid_w, mid_h);
}
window_refresh();
}
bool menu_run(Settings *settings) {
assert(settings != NULL);
SDL_EnableKeyRepeat(10000 / WINDOW_FRAMERATE, 10000 / WINDOW_FRAMERATE);
glClearColor(0, 0, 0, 1);
int level_set_index = 0, theme_index = 0;
menu_preload();
// default settings
if(settings->first_run) {
settings->play_with_computer = true;
settings->volume = 100;
strncpy(settings->level_set, s_sets_names[level_set_index], LIM_STR_LEN);
settings->level = 1;
strncpy(settings->theme, s_themes_names[theme_index], LIM_STR_LEN);
settings->ball_speed = BALL_DEFAULT_SPEED;
}
Timer timer = timer_new(WINDOW_FRAMERATE);
const bool* events = NULL;
bool leave = false;
bool vol_updated = false;
while(!leave) {
events = event_poll();
if(events[EVENT_QUIT] || events[EVENT_KEY_ESCAPE]) {
return false;
}
if(events[EVENT_KEY_UP]) {
if(s_focus == 0) {
s_focus = __MENU_LABEL_LAST - 1;
} else {
s_focus--;
}
audio_play(SOUND_TOCK);
}
if(events[EVENT_KEY_DOWN]) {
s_focus++;
audio_play(SOUND_TOCK);
if(s_focus == __MENU_LABEL_LAST) {
s_focus = 0;
}
}
if(events[EVENT_KEY_LEFT]) {
bool action = true;
switch(s_focus) {
case LABEL_SECOND_PLAYER:
settings->play_with_computer = !settings->play_with_computer;
break;
case LABEL_SOUND_VOLUME:
settings->volume -= 10;
if(settings->volume < 0) {
settings->volume = 0;
action = false;
} else {
vol_updated = true;
}
break;
case LABEL_LEVEL_SET:
s_level_set_index--;
if(s_level_set_index < 0) {
s_level_set_index = s_sets_names_length - 1;
}
settings->level = 1;
break;
case LABEL_LEVEL:
(settings->level)--;
if(settings->level <= 0) {
settings->level = s_sets_levels[s_level_set_index];
}
break;
case LABEL_THEME:
s_theme_index--;
if(s_theme_index < 0) {
s_theme_index = s_themes_names_length - 1;
}
break;
case LABEL_BALL_SPEED:
(settings->ball_speed)--;
if(settings->ball_speed < BALL_MIN_SPEED) {
settings->ball_speed = BALL_MAX_SPEED;
}
break;
default:
action = false;
break;
}
if(action) {
audio_play(SOUND_TICK);
}
}
if(events[EVENT_KEY_RIGHT]) {
bool action = true;
switch(s_focus) {
case LABEL_SECOND_PLAYER:
settings->play_with_computer = !settings->play_with_computer;
break;
case LABEL_SOUND_VOLUME:
settings->volume += 10;
if(settings->volume > 100) {
settings->volume = 100;
action = false;
} else {
vol_updated = true;
}
break;
case LABEL_LEVEL_SET:
s_level_set_index++;
if(s_level_set_index >= s_sets_names_length) {
s_level_set_index = 0;
}
settings->level = 1;
break;
case LABEL_LEVEL:
(settings->level)++;
if(settings->level > s_sets_levels[s_level_set_index]) {
settings->level = 1;
}
break;
case LABEL_THEME:
s_theme_index++;
if(s_theme_index >= s_themes_names_length) {
s_theme_index = 0;
}
break;
case LABEL_BALL_SPEED:
(settings->ball_speed)++;
if(settings->ball_speed > BALL_MAX_SPEED) {
settings->ball_speed = BALL_MIN_SPEED;
}
break;
default:
action = false;
break;
}
if(action) {
audio_play(SOUND_TICK);
}
}
if(events[EVENT_KEY_ENTER]) {
if(s_focus == LABEL_QUIT) {
return false;
} else {
leave = true;
}
}
if(vol_updated) {
audio_set_volume(settings->volume);
vol_updated = false;
}
glClear(GL_COLOR_BUFFER_BIT);
menu_display(settings);
SDL_GL_SwapBuffers();
timer_sleep(&timer);
}
strncpy(settings->level_set, s_sets_names[s_level_set_index], LIM_STR_LEN);
strncpy(settings->theme, s_themes_names[s_theme_index], LIM_STR_LEN);
settings->first_run = false;
return true;
}
/*
* Enter a menu -- save current menu in the menu's previous pointer
* so when we exit we can go back, and update the menu context to
* reflect new menu... then display it.
*/
void menu_enter(menu_context_t *context, menu_t *menu) {
menu->previous = context->menu;
context->menu = menu;
menu_display(context);
}
/*
* Exit a menu (go to the previous menu) -- if there is no previous
* menu, don't do anything.
*/
void menu_exit(menu_context_t *context) {
if (context->menu->previous) {
context->menu = context->menu->previous;
menu_display(context);
}
}
