src/highscore.cpp

   1 /*
   2  * This file is part of OpenTTD.
   3  * OpenTTD is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, version 2.
   4  * OpenTTD is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   5  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
   6  */
   7
   8 /** @file highscore.cpp Definition of functions used for highscore handling */
   9
  10 #include "stdafx.h"
  11 #include "highscore.h"
  12 #include "company_base.h"
  13 #include "company_func.h"
  14 #include "cheat_func.h"
  15 #include "fileio_func.h"
  16 #include "string_func.h"
  17 #include "strings_func.h"
  18 #include "table/strings.h"
  19 #include "debug.h"
  20
  21 #include "safeguards.h"
  22
  23 HighScoresTable _highscore_table; ///< Table with all the high scores.
  24 std::string _highscore_file; ///< The file to store the highscore data in.
  25
  26 static const StringID _endgame_perf_titles[] = {
  27         STR_HIGHSCORE_PERFORMANCE_TITLE_BUSINESSMAN,
  28         STR_HIGHSCORE_PERFORMANCE_TITLE_BUSINESSMAN,
  29         STR_HIGHSCORE_PERFORMANCE_TITLE_BUSINESSMAN,
  30         STR_HIGHSCORE_PERFORMANCE_TITLE_BUSINESSMAN,
  31         STR_HIGHSCORE_PERFORMANCE_TITLE_BUSINESSMAN,
  32         STR_HIGHSCORE_PERFORMANCE_TITLE_ENTREPRENEUR,
  33         STR_HIGHSCORE_PERFORMANCE_TITLE_ENTREPRENEUR,
  34         STR_HIGHSCORE_PERFORMANCE_TITLE_INDUSTRIALIST,
  35         STR_HIGHSCORE_PERFORMANCE_TITLE_INDUSTRIALIST,
  36         STR_HIGHSCORE_PERFORMANCE_TITLE_CAPITALIST,
  37         STR_HIGHSCORE_PERFORMANCE_TITLE_CAPITALIST,
  38         STR_HIGHSCORE_PERFORMANCE_TITLE_MAGNATE,
  39         STR_HIGHSCORE_PERFORMANCE_TITLE_MAGNATE,
  40         STR_HIGHSCORE_PERFORMANCE_TITLE_MOGUL,
  41         STR_HIGHSCORE_PERFORMANCE_TITLE_MOGUL,
  42         STR_HIGHSCORE_PERFORMANCE_TITLE_TYCOON_OF_THE_CENTURY
  43 };
  44
  45 StringID EndGameGetPerformanceTitleFromValue(uint value)
  46 {
  47         value = std::min<uint>(value / 64, lengthof(_endgame_perf_titles) - 1);
  48
  49         return _endgame_perf_titles[value];
  50 }
  51
  52 /**
  53  * Save the highscore for the company
  54  * @param c The company to insert.
  55  * @return The index the company got in the high score table, or -1 when it did not end up in the table.
  56  */
  57 int8_t SaveHighScoreValue(const Company *c)
  58 {
  59         /* Exclude cheaters from the honour of being in the highscore table */
  60         if (CheatHasBeenUsed()) return -1;
  61
  62         auto &highscores = _highscore_table[SP_CUSTOM];
  63         uint16_t score = c->old_economy[0].performance_history;
  64
  65         auto it = std::find_if(highscores.begin(), highscores.end(), [&score](auto &highscore) { return highscore.score <= score; });
  66
  67         /* If we cannot find it, our score is not high enough. */
  68         if (it == highscores.end()) return -1;
  69
  70         /* Move all elements one down starting from the replaced one */
  71         std::move_backward(it, highscores.end() - 1, highscores.end());
  72
  73         /* Fill the elements. */
  74         SetDParam(0, c->index);
  75         SetDParam(1, c->index);
  76         it->name = GetString(STR_HIGHSCORE_NAME); // get manager/company name string
  77         it->score = score;
  78         it->title = EndGameGetPerformanceTitleFromValue(score);
  79         return std::distance(highscores.begin(), it);
  80 }
  81
  82 /** Sort all companies given their performance */
  83 static bool HighScoreSorter(const Company * const &a, const Company * const &b)
  84 {
  85         return b->old_economy[0].performance_history < a->old_economy[0].performance_history;
  86 }
  87
  88 /**
  89  * Save the highscores in a network game when it has ended
  90  * @return Position of the local company in the highscore list.
  91  */
  92 int8_t SaveHighScoreValueNetwork()
  93 {
  94         const Company *cl[MAX_COMPANIES];
  95         size_t count = 0;
  96         int8_t local_company_place = -1;
  97
  98         /* Sort all active companies with the highest score first */
  99         for (const Company *c : Company::Iterate()) cl[count++] = c;
 100
 101         std::sort(std::begin(cl), std::begin(cl) + count, HighScoreSorter);
 102
 103         /* Clear the high scores from the previous network game. */
 104         auto &highscores = _highscore_table[SP_MULTIPLAYER];
 105         std::fill(highscores.begin(), highscores.end(), HighScore{});
 106
 107         for (size_t i = 0; i < count && i < highscores.size(); i++) {
 108                 const Company *c = cl[i];
 109                 auto &highscore = highscores[i];
 110                 SetDParam(0, c->index);
 111                 SetDParam(1, c->index);
 112                 highscore.name = GetString(STR_HIGHSCORE_NAME); // get manager/company name string
 113                 highscore.score = c->old_economy[0].performance_history;
 114                 highscore.title = EndGameGetPerformanceTitleFromValue(highscore.score);
 115
 116                 if (c->index == _local_company) local_company_place = static_cast<int8_t>(i);
 117         }
 118
 119         return local_company_place;
 120 }
 121
 122 /** Save HighScore table to file */
 123 void SaveToHighScore()
 124 {
 125         auto ofp = FileHandle::Open(_highscore_file, "wb");
 126         if (!ofp.has_value()) return;
 127         auto &fp = *ofp;
 128
 129         /* Does not iterate through the complete array!. */
 130         for (int i = 0; i < SP_SAVED_HIGHSCORE_END; i++) {
 131                 for (HighScore &hs : _highscore_table[i]) {
 132                         /* This code is weird and old fashioned to keep compatibility with the old high score files. */
 133                         uint8_t name_length = ClampTo<uint8_t>(hs.name.size());
 134                         if (fwrite(&name_length, sizeof(name_length), 1, fp) != 1 || // Write the string length of the name
 135                                         fwrite(hs.name.data(), name_length, 1, fp) > 1 || // Yes... could be 0 bytes too
 136                                         fwrite(&hs.score, sizeof(hs.score), 1, fp) != 1 ||
 137                                         fwrite("  ", 2, 1, fp) != 1) { // Used to be hs.title, not saved anymore; compatibility
 138                                 Debug(misc, 1, "Could not save highscore.");
 139                                 return;
 140                         }
 141                 }
 142         }
 143 }
 144
 145 /** Initialize the highscore table to 0 and if any file exists, load in values */
 146 void LoadFromHighScore()
 147 {
 148         std::fill(_highscore_table.begin(), _highscore_table.end(), HighScores{});
 149
 150         auto ofp = FileHandle::Open(_highscore_file, "rb");
 151         if (!ofp.has_value()) return;
 152         auto &fp = *ofp;
 153
 154         /* Does not iterate through the complete array!. */
 155         for (int i = 0; i < SP_SAVED_HIGHSCORE_END; i++) {
 156                 for (HighScore &hs : _highscore_table[i]) {
 157                         /* This code is weird and old fashioned to keep compatibility with the old high score files. */
 158                         uint8_t name_length;
 159                         char buffer[std::numeric_limits<decltype(name_length)>::max() + 1];
 160
 161                         if (fread(&name_length, sizeof(name_length), 1, fp) !=  1 ||
 162                                         fread(buffer, name_length, 1, fp) > 1 || // Yes... could be 0 bytes too
 163                                         fread(&hs.score, sizeof(hs.score), 1, fp) !=  1 ||
 164                                         fseek(fp, 2, SEEK_CUR) == -1) { // Used to be hs.title, not saved anymore; compatibility
 165                                 Debug(misc, 1, "Highscore corrupted");
 166                                 return;
 167                         }
 168                         hs.name = StrMakeValid(std::string_view(buffer, name_length));
 169                         hs.title = EndGameGetPerformanceTitleFromValue(hs.score);
 170                 }
 171         }
 172 }