+ // if that also fails, set current level number to first available level
+ if (level_number_current == NULL)
+ level_number_current = level_number;
+
+ DrawChooseTree(&level_number_current);
+
+ PlayMenuSoundsAndMusic();
+}
+
+void HandleChooseLevelNr(int mx, int my, int dx, int dy, int button)
+{
+ HandleChooseTree(mx, my, dx, dy, button, &level_number_current);
+}
+
+void DrawHallOfFame(int level_nr)
+{
+ int fade_mask = REDRAW_FIELD;
+
+ if (CheckFadeAll())
+ fade_mask = REDRAW_ALL;
+
+ UnmapAllGadgets();
+ FadeMenuSoundsAndMusic();
+
+ // (this is needed when called from GameEnd() after winning a game)
+ KeyboardAutoRepeatOn();
+
+ // (this is needed when called from GameEnd() after winning a game)
+ SetDrawDeactivationMask(REDRAW_NONE);
+ SetDrawBackgroundMask(REDRAW_FIELD);
+
+ LoadLocalAndServerScore(level_nr, TRUE);
+
+ if (scores.last_added >= 0)
+ SetAnimStatus(GAME_MODE_PSEUDO_SCORESNEW);
+
+ FadeSetEnterScreen();
+
+ FadeOut(fade_mask);
+
+ // needed if different viewport properties defined for scores
+ ChangeViewportPropertiesIfNeeded();
+
+ PlayMenuSoundsAndMusic();
+
+ OpenDoor(GetDoorState() | DOOR_NO_DELAY | DOOR_FORCE_REDRAW);
+
+ HandleHallOfFame(level_nr, 0, 0, 0, MB_MENU_INITIALIZE);
+
+ DrawMaskedBorder(fade_mask);
+
+ FadeIn(fade_mask);
+}
+
+static int getHallOfFameFirstEntry(int first_entry, int step)
+{
+ if (step == 0)
+ first_entry = scores.last_added - (NUM_MENU_ENTRIES_ON_SCREEN + 1) / 2 + 1;
+ else
+ first_entry += step;
+
+ if (first_entry < 0)
+ first_entry = 0;
+ else if (first_entry > MAX_SCORE_ENTRIES - NUM_MENU_ENTRIES_ON_SCREEN)
+ first_entry = MAX(0, MAX_SCORE_ENTRIES - NUM_MENU_ENTRIES_ON_SCREEN);
+
+ return first_entry;
+}
+
+static char *getHallOfFameScoreText(int nr)
+{
+ if (!level.rate_time_over_score)
+ return int2str(scores.entry[nr].score, 5); // show normal score
+
+ if (level.use_step_counter)
+ return int2str(scores.entry[nr].time, 5); // show number of steps
+
+ static char score_text[10];
+ int time_seconds = scores.entry[nr].time / FRAMES_PER_SECOND;
+ int mm = (time_seconds / 60) % 60;
+ int ss = (time_seconds % 60);
+
+ sprintf(score_text, "%02d:%02d", mm, ss); // show playing time
+
+ return score_text;
+}
+
+static void drawHallOfFameList(int level_nr, int first_entry)
+{
+ int i, j;
+
+ SetMainBackgroundImage(IMG_BACKGROUND_SCORES);
+ ClearField();
+
+ DrawTextSCentered(MENU_TITLE1_YPOS, FONT_TITLE_1, "Hall Of Fame");
+ DrawTextFCentered(MENU_TITLE2_YPOS, FONT_TITLE_2,
+ "HighScores of Level %d", level_nr);
+
+ for (i = 0; i < NUM_MENU_ENTRIES_ON_SCREEN; i++)
+ {
+ int entry = first_entry + i;
+ boolean active = (entry == scores.last_added);
+ boolean forced = (scores.force_last_added && active);
+ int font_nr1 = (active ? FONT_TEXT_1_ACTIVE : FONT_TEXT_1);
+ int font_nr2 = (active ? FONT_TEXT_2_ACTIVE : FONT_TEXT_2);
+ int font_nr3 = (active ? FONT_TEXT_3_ACTIVE : FONT_TEXT_3);
+ int font_nr4 = (active ? FONT_TEXT_4_ACTIVE : FONT_TEXT_4);
+ int dxoff = getFontDrawOffsetX(font_nr1);
+ int dx1 = 3 * getFontWidth(font_nr1);
+ int dx2 = dx1 + getFontWidth(font_nr1);
+ int dx3 = SXSIZE - 2 * (mSX - SX + dxoff) - 5 * getFontWidth(font_nr4);
+ int num_dots = (dx3 - dx2) / getFontWidth(font_nr3);
+ int sy = mSY + 64 + i * 32;
+ char *pos_text = (forced ? "???" : int2str(entry + 1, 3));
+
+ DrawText(mSX, sy, pos_text, font_nr1);
+ DrawText(mSX + dx1, sy, ".", font_nr1);
+
+ for (j = 0; j < num_dots; j++)
+ DrawText(mSX + dx2 + j * getFontWidth(font_nr3), sy, ".", font_nr3);
+
+ if (!strEqual(scores.entry[entry].name, EMPTY_PLAYER_NAME))
+ DrawText(mSX + dx2, sy, scores.entry[entry].name, font_nr2);
+
+ DrawText(mSX + dx3, sy, getHallOfFameScoreText(entry), font_nr4);
+ }
+
+ redraw_mask |= REDRAW_FIELD;
+}
+
+void HandleHallOfFame(int mx, int my, int dx, int dy, int button)
+{
+ static int level_nr = 0;
+ static int first_entry = 0;
+ int step = (button == 1 ? 1 : button == 2 ? 5 : 10);
+
+ if (button == MB_MENU_INITIALIZE)
+ {
+ level_nr = mx;
+
+ if (server_scores.updated)
+ {
+ // reload scores, using updated server score cache file
+ LoadLocalAndServerScore(level_nr, FALSE);
+
+ server_scores.updated = FALSE;
+ }
+
+ first_entry = getHallOfFameFirstEntry(0, 0);
+
+ drawHallOfFameList(level_nr, first_entry);
+
+ return;
+ }
+
+ if (ABS(dy) == SCROLL_PAGE) // handle scrolling one page
+ step = NUM_MENU_ENTRIES_ON_SCREEN - 1;
+
+ if (dy < 0)
+ {
+ first_entry = getHallOfFameFirstEntry(first_entry, -step);
+
+ drawHallOfFameList(level_nr, first_entry);
+ }
+ else if (dy > 0)
+ {
+ first_entry = getHallOfFameFirstEntry(first_entry, step);
+
+ drawHallOfFameList(level_nr, first_entry);
+ }
+ else if (button == MB_MENU_LEAVE || button == MB_MENU_CHOICE)
+ {
+ PlaySound(SND_MENU_ITEM_SELECTING);
+
+ FadeSound(SND_BACKGROUND_SCORES);
+
+ if (button == MB_MENU_CHOICE &&
+ game_status_last_screen == GAME_MODE_PLAYING &&
+ setup.auto_play_next_level && setup.increment_levels &&
+ level_nr < leveldir_current->last_level &&
+ !network_playing)
+ {
+ StartGameActions(network.enabled, setup.autorecord, level.random_seed);
+ }
+ else
+ {
+ SetGameStatus(GAME_MODE_MAIN);
+
+ DrawMainMenu();
+ }
+ }
+ else if (server_scores.updated)
+ {
+ // reload scores, using updated server score cache file
+ LoadLocalAndServerScore(level_nr, FALSE);
+
+ server_scores.updated = FALSE;
+
+ first_entry = getHallOfFameFirstEntry(0, 0);
+
+ drawHallOfFameList(level_nr, first_entry);
+ }
+
+ if (game_status == GAME_MODE_SCORES)
+ PlayMenuSoundIfLoop();
+}
+
+
+// ============================================================================
+// setup screen functions
+// ============================================================================
+
+static struct TokenInfo *setup_info;
+static int num_setup_info; // number of setup entries shown on screen
+static int max_setup_info; // total number of setup entries in list
+
+static char *window_size_text;
+static char *scaling_type_text;
+static char *rendering_mode_text;
+static char *vsync_mode_text;
+static char *scroll_delay_text;
+static char *snapshot_mode_text;
+static char *game_speed_text;
+static char *network_server_text;
+static char *graphics_set_name;
+static char *sounds_set_name;
+static char *music_set_name;
+static char *volume_simple_text;
+static char *volume_loops_text;
+static char *volume_music_text;
+static char *touch_controls_text;
+static char *move_distance_text;
+static char *drop_distance_text;
+static char *transparency_text;
+static char *grid_size_text[2][2];
+
+static void execSetupMain(void)
+{
+ setup_mode = SETUP_MODE_MAIN;
+
+ DrawSetupScreen();
+}
+
+static void execSetupGame_setGameSpeeds(boolean update_value)
+{
+ if (setup.game_speed_extended)
+ {
+ game_speeds_list = game_speeds_list_extended;
+ game_speeds = game_speeds_extended;
+ }
+ else
+ {
+ game_speeds_list = game_speeds_list_normal;
+ game_speeds = game_speeds_normal;
+ }
+
+ if (game_speeds == NULL)
+ {
+ int i;
+
+ for (i = 0; game_speeds_list[i].value != -1; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = game_speeds_list[i].value;
+ char *text = game_speeds_list[i].text;
+
+ ti->node_top = &game_speeds;
+ ti->sort_priority = 10000 - value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, STR_SETUP_CHOOSE_GAME_SPEED);
+
+ pushTreeInfo(&game_speeds, ti);
+ }
+
+ // sort game speed values to start with slowest game speed
+ sortTreeInfo(&game_speeds);
+
+ update_value = TRUE;
+ }
+
+ if (update_value)
+ {
+ // set current game speed to configured game speed value
+ game_speed_current =
+ getTreeInfoFromIdentifier(game_speeds, i_to_a(setup.game_frame_delay));
+
+ // if that fails, set current game speed to reliable default value
+ if (game_speed_current == NULL)
+ game_speed_current =
+ getTreeInfoFromIdentifier(game_speeds, i_to_a(GAME_FRAME_DELAY));
+
+ // if that also fails, set current game speed to first available speed
+ if (game_speed_current == NULL)
+ game_speed_current = game_speeds;
+
+ if (setup.game_speed_extended)
+ game_speeds_extended = game_speeds;
+ else
+ game_speeds_normal = game_speeds;
+ }
+
+ setup.game_frame_delay = atoi(game_speed_current->identifier);
+
+ // needed for displaying game speed text instead of identifier
+ game_speed_text = game_speed_current->name;
+}
+
+static void execSetupGame_setScrollDelays(void)
+{
+ if (scroll_delays == NULL)
+ {
+ int i;
+
+ for (i = 0; scroll_delays_list[i].value != -1; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = scroll_delays_list[i].value;
+ char *text = scroll_delays_list[i].text;
+
+ ti->node_top = &scroll_delays;
+ ti->sort_priority = value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, STR_SETUP_CHOOSE_SCROLL_DELAY);
+
+ pushTreeInfo(&scroll_delays, ti);
+ }
+
+ // sort scroll delay values to start with lowest scroll delay value
+ sortTreeInfo(&scroll_delays);
+
+ // set current scroll delay value to configured scroll delay value
+ scroll_delay_current =
+ getTreeInfoFromIdentifier(scroll_delays,i_to_a(setup.scroll_delay_value));
+
+ // if that fails, set current scroll delay to reliable default value
+ if (scroll_delay_current == NULL)
+ scroll_delay_current =
+ getTreeInfoFromIdentifier(scroll_delays, i_to_a(STD_SCROLL_DELAY));
+
+ // if that also fails, set current scroll delay to first available value
+ if (scroll_delay_current == NULL)
+ scroll_delay_current = scroll_delays;
+ }
+
+ setup.scroll_delay_value = atoi(scroll_delay_current->identifier);
+
+ // needed for displaying scroll delay text instead of identifier
+ scroll_delay_text = scroll_delay_current->name;
+}
+
+static void execSetupGame_setSnapshotModes(void)
+{
+ if (snapshot_modes == NULL)
+ {
+ int i;
+
+ for (i = 0; snapshot_modes_list[i].value != NULL; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ char *value = snapshot_modes_list[i].value;
+ char *text = snapshot_modes_list[i].text;
+
+ ti->node_top = &snapshot_modes;
+ ti->sort_priority = i;
+
+ sprintf(identifier, "%s", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, STR_SETUP_CHOOSE_SNAPSHOT_MODE);
+
+ pushTreeInfo(&snapshot_modes, ti);
+ }
+
+ // sort snapshot mode values to start with lowest snapshot mode value
+ sortTreeInfo(&snapshot_modes);
+
+ // set current snapshot mode value to configured snapshot mode value
+ snapshot_mode_current =
+ getTreeInfoFromIdentifier(snapshot_modes, setup.engine_snapshot_mode);
+
+ // if that fails, set current snapshot mode to reliable default value
+ if (snapshot_mode_current == NULL)
+ snapshot_mode_current =
+ getTreeInfoFromIdentifier(snapshot_modes, STR_SNAPSHOT_MODE_DEFAULT);
+
+ // if that also fails, set current snapshot mode to first available value
+ if (snapshot_mode_current == NULL)
+ snapshot_mode_current = snapshot_modes;
+ }
+
+ setup.engine_snapshot_mode = snapshot_mode_current->identifier;
+
+ // needed for displaying snapshot mode text instead of identifier
+ snapshot_mode_text = snapshot_mode_current->name;
+}
+
+static void execSetupGame_setNetworkServerText(void)
+{
+ if (strEqual(setup.network_server_hostname, STR_NETWORK_AUTO_DETECT))
+ {
+ strcpy(network_server_hostname, STR_NETWORK_AUTO_DETECT_SETUP);
+ }
+ else
+ {
+ strncpy(network_server_hostname, setup.network_server_hostname,
+ MAX_SETUP_TEXT_INPUT_LEN);
+ network_server_hostname[MAX_SETUP_TEXT_INPUT_LEN] = '\0';
+ }
+
+ // needed for displaying network server text instead of identifier
+ network_server_text = network_server_hostname;
+}
+
+static void execSetupGame(void)
+{
+ boolean check_vsync_mode = (setup_mode == SETUP_MODE_CHOOSE_GAME_SPEED);
+
+ execSetupGame_setGameSpeeds(FALSE);
+ execSetupGame_setScrollDelays();
+ execSetupGame_setSnapshotModes();
+
+ execSetupGame_setNetworkServerText();
+
+ if (!setup.provide_uploading_tapes)
+ setHideSetupEntry(execOfferUploadTapes);
+
+ setup_mode = SETUP_MODE_GAME;
+
+ DrawSetupScreen();
+
+ // check if vsync needs to be disabled for this game speed to work
+ if (check_vsync_mode)
+ DisableVsyncIfNeeded();
+}
+
+static void execSetupChooseGameSpeed(void)
+{
+ setup_mode = SETUP_MODE_CHOOSE_GAME_SPEED;
+
+ DrawSetupScreen();
+}
+
+static void execSetupChooseScrollDelay(void)
+{
+ setup_mode = SETUP_MODE_CHOOSE_SCROLL_DELAY;
+
+ DrawSetupScreen();
+}
+
+static void execSetupChooseSnapshotMode(void)
+{
+ setup_mode = SETUP_MODE_CHOOSE_SNAPSHOT_MODE;
+
+ DrawSetupScreen();
+}
+
+static void execSetupEngines(void)
+{
+ setup_mode = SETUP_MODE_ENGINES;
+
+ DrawSetupScreen();
+}
+
+static void execSetupEditor(void)
+{
+ setup_mode = SETUP_MODE_EDITOR;
+
+ DrawSetupScreen();
+}
+
+static void execSetupGraphics_setWindowSizes(boolean update_list)
+{
+ if (window_sizes != NULL && update_list)
+ {
+ freeTreeInfo(window_sizes);
+
+ window_sizes = NULL;
+ }
+
+ if (window_sizes == NULL)
+ {
+ boolean current_window_size_found = FALSE;
+ int i;
+
+ for (i = 0; window_sizes_list[i].value != -1; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = window_sizes_list[i].value;
+ char *text = window_sizes_list[i].text;
+
+ ti->node_top = &window_sizes;
+ ti->sort_priority = value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, STR_SETUP_CHOOSE_WINDOW_SIZE);
+
+ pushTreeInfo(&window_sizes, ti);
+
+ if (value == setup.window_scaling_percent)
+ current_window_size_found = TRUE;
+ }
+
+ if (!current_window_size_found)
+ {
+ // add entry for non-preset window scaling value
+
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ int value = setup.window_scaling_percent;
+
+ ti->node_top = &window_sizes;
+ ti->sort_priority = value;
+
+ sprintf(identifier, "%d", value);
+ sprintf(name, "%d %% (Current)", value);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, STR_SETUP_CHOOSE_WINDOW_SIZE);
+
+ pushTreeInfo(&window_sizes, ti);
+ }
+
+ // sort window size values to start with lowest window size value
+ sortTreeInfo(&window_sizes);
+
+ // set current window size value to configured window size value
+ window_size_current =
+ getTreeInfoFromIdentifier(window_sizes,
+ i_to_a(setup.window_scaling_percent));
+
+ // if that fails, set current window size to reliable default value
+ if (window_size_current == NULL)
+ window_size_current =
+ getTreeInfoFromIdentifier(window_sizes,
+ i_to_a(STD_WINDOW_SCALING_PERCENT));
+
+ // if that also fails, set current window size to first available value
+ if (window_size_current == NULL)
+ window_size_current = window_sizes;
+ }
+
+ setup.window_scaling_percent = atoi(window_size_current->identifier);
+
+ // needed for displaying window size text instead of identifier
+ window_size_text = window_size_current->name;
+}
+
+static void execSetupGraphics_setScalingTypes(void)
+{
+ if (scaling_types == NULL)
+ {
+ int i;
+
+ for (i = 0; scaling_types_list[i].value != NULL; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ char *value = scaling_types_list[i].value;
+ char *text = scaling_types_list[i].text;
+
+ ti->node_top = &scaling_types;
+ ti->sort_priority = i;
+
+ sprintf(identifier, "%s", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, STR_SETUP_CHOOSE_SCALING_TYPE);
+
+ pushTreeInfo(&scaling_types, ti);
+ }
+
+ // sort scaling type values to start with lowest scaling type value
+ sortTreeInfo(&scaling_types);
+
+ // set current scaling type value to configured scaling type value
+ scaling_type_current =
+ getTreeInfoFromIdentifier(scaling_types, setup.window_scaling_quality);
+
+ // if that fails, set current scaling type to reliable default value
+ if (scaling_type_current == NULL)
+ scaling_type_current =
+ getTreeInfoFromIdentifier(scaling_types, SCALING_QUALITY_DEFAULT);
+
+ // if that also fails, set current scaling type to first available value
+ if (scaling_type_current == NULL)
+ scaling_type_current = scaling_types;
+ }
+
+ setup.window_scaling_quality = scaling_type_current->identifier;
+
+ // needed for displaying scaling type text instead of identifier
+ scaling_type_text = scaling_type_current->name;
+}
+
+static void execSetupGraphics_setRenderingModes(void)
+{
+ if (rendering_modes == NULL)
+ {
+ int i;
+
+ for (i = 0; rendering_modes_list[i].value != NULL; i++)
+ {
+ TreeInfo *ti = newTreeInfo_setDefaults(TREE_TYPE_UNDEFINED);
+ char identifier[32], name[32];
+ char *value = rendering_modes_list[i].value;
+ char *text = rendering_modes_list[i].text;
+
+ ti->node_top = &rendering_modes;
+ ti->sort_priority = i;
+
+ sprintf(identifier, "%s", value);
+ sprintf(name, "%s", text);
+
+ setString(&ti->identifier, identifier);
+ setString(&ti->name, name);
+ setString(&ti->name_sorting, name);
+ setString(&ti->infotext, STR_SETUP_CHOOSE_RENDERING);
+
+ pushTreeInfo(&rendering_modes, ti);
+ }
+
+ // sort rendering mode values to start with lowest rendering mode value
+ sortTreeInfo(&rendering_modes);