src/saveload/strings_sl.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 strings_sl.cpp Code handling saving and loading of strings */
   9
  10 #include "../stdafx.h"
  11 #include "../core/alloc_func.hpp"
  12 #include "../string_func.h"
  13 #include "../strings_func.h"
  14 #include "saveload_internal.h"
  15 #include <sstream>
  16
  17 #include "table/strings.h"
  18
  19 #include "../safeguards.h"
  20
  21 static const int NUM_OLD_STRINGS     = 512; ///< The number of custom strings stored in old savegames.
  22 static const int LEN_OLD_STRINGS     =  32; ///< The number of characters per string.
  23 static const int LEN_OLD_STRINGS_TTO =  24; ///< The number of characters per string in TTO savegames.
  24
  25 /**
  26  * Remap a string ID from the old format to the new format
  27  * @param s StringID that requires remapping
  28  * @return translated ID
  29  */
  30 StringID RemapOldStringID(StringID s)
  31 {
  32         switch (s) {
  33                 case 0x0006: return STR_SV_EMPTY;
  34                 case 0x7000: return STR_SV_UNNAMED;
  35                 case 0x70E4: return SPECSTR_COMPANY_NAME_START;
  36                 case 0x70E9: return SPECSTR_COMPANY_NAME_START;
  37                 case 0x8864: return STR_SV_TRAIN_NAME;
  38                 case 0x902B: return STR_SV_ROAD_VEHICLE_NAME;
  39                 case 0x9830: return STR_SV_SHIP_NAME;
  40                 case 0xA02F: return STR_SV_AIRCRAFT_NAME;
  41
  42                 default:
  43                         if (IsInsideMM(s, 0x300F, 0x3030)) {
  44                                 return s - 0x300F + STR_SV_STNAME;
  45                         } else {
  46                                 return s;
  47                         }
  48         }
  49 }
  50
  51 /** Location to load the old names to. */
  52 char *_old_name_array = nullptr;
  53
  54 /**
  55  * Copy and convert old custom names to UTF-8.
  56  * They were all stored in a 512 by 32 (200 by 24 for TTO) long string array
  57  * and are now stored with stations, waypoints and other places with names.
  58  * @param id the StringID of the custom name to clone.
  59  * @return the clones custom name.
  60  */
  61 std::string CopyFromOldName(StringID id)
  62 {
  63         /* Is this name an (old) custom name? */
  64         if (GetStringTab(id) != TEXT_TAB_OLD_CUSTOM) return std::string();
  65
  66         if (IsSavegameVersionBefore(SLV_37)) {
  67                 uint offs = _savegame_type == SGT_TTO ? LEN_OLD_STRINGS_TTO * GB(id, 0, 8) : LEN_OLD_STRINGS * GB(id, 0, 9);
  68                 const char *strfrom = &_old_name_array[offs];
  69
  70                 std::ostringstream tmp;
  71                 std::ostreambuf_iterator<char> strto(tmp);
  72                 for (; *strfrom != '\0'; strfrom++) {
  73                         char32_t c = (uint8_t)*strfrom;
  74
  75                         /* Map from non-ISO8859-15 characters to UTF-8. */
  76                         switch (c) {
  77                                 case 0xA4: c = 0x20AC; break; // Euro
  78                                 case 0xA6: c = 0x0160; break; // S with caron
  79                                 case 0xA8: c = 0x0161; break; // s with caron
  80                                 case 0xB4: c = 0x017D; break; // Z with caron
  81                                 case 0xB8: c = 0x017E; break; // z with caron
  82                                 case 0xBC: c = 0x0152; break; // OE ligature
  83                                 case 0xBD: c = 0x0153; break; // oe ligature
  84                                 case 0xBE: c = 0x0178; break; // Y with diaeresis
  85                                 default: break;
  86                         }
  87
  88                         Utf8Encode(strto, c);
  89                 }
  90
  91                 return tmp.str();
  92         } else {
  93                 /* Name will already be in UTF-8. */
  94                 return std::string(&_old_name_array[LEN_OLD_STRINGS * GB(id, 0, 9)]);
  95         }
  96 }
  97
  98 /**
  99  * Free the memory of the old names array.
 100  * Should be called once the old names have all been converted.
 101  */
 102 void ResetOldNames()
 103 {
 104         free(_old_name_array);
 105         _old_name_array = nullptr;
 106 }
 107
 108 /**
 109  * Initialize the old names table memory.
 110  */
 111 void InitializeOldNames()
 112 {
 113         free(_old_name_array);
 114         _old_name_array = CallocT<char>(NUM_OLD_STRINGS * LEN_OLD_STRINGS); // 200 * 24 would be enough for TTO savegames
 115 }
 116
 117 struct NAMEChunkHandler : ChunkHandler {
 118         NAMEChunkHandler() : ChunkHandler('NAME', CH_READONLY) {}
 119
 120         void Load() const override
 121         {
 122                 int index;
 123
 124                 while ((index = SlIterateArray()) != -1) {
 125                         if (index >= NUM_OLD_STRINGS) SlErrorCorrupt("Invalid old name index");
 126                         if (SlGetFieldLength() > (uint)LEN_OLD_STRINGS) SlErrorCorrupt("Invalid old name length");
 127
 128                         SlCopy(&_old_name_array[LEN_OLD_STRINGS * index], SlGetFieldLength(), SLE_UINT8);
 129                         /* Make sure the old name is null terminated */
 130                         _old_name_array[LEN_OLD_STRINGS * index + LEN_OLD_STRINGS - 1] = '\0';
 131                 }
 132         }
 133 };
 134
 135 static const NAMEChunkHandler NAME;
 136 static const ChunkHandlerRef name_chunk_handlers[] = {
 137         NAME,
 138 };
 139
 140 extern const ChunkHandlerTable _name_chunk_handlers(name_chunk_handlers);