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 engine_sl.cpp Code handling saving and loading of engines */
9
10 #include "../stdafx.h"
11
12 #include "saveload.h"
13 #include "compat/engine_sl_compat.h"
14
15 #include "saveload_internal.h"
16 #include "../engine_base.h"
17 #include "../string_func.h"
18 #include <vector>
19
20 #include "../safeguards.h"
21
22 static const SaveLoad _engine_desc[] = {
23 SLE_CONDVAR(Engine, intro_date, SLE_FILE_U16 | SLE_VAR_I32, SL_MIN_VERSION, SLV_31),
24 SLE_CONDVAR(Engine, intro_date, SLE_INT32, SLV_31, SL_MAX_VERSION),
25 SLE_CONDVAR(Engine, age, SLE_FILE_U16 | SLE_VAR_I32, SL_MIN_VERSION, SLV_31),
26 SLE_CONDVAR(Engine, age, SLE_INT32, SLV_31, SL_MAX_VERSION),
27 SLE_VAR(Engine, reliability, SLE_UINT16),
28 SLE_VAR(Engine, reliability_spd_dec, SLE_UINT16),
29 SLE_VAR(Engine, reliability_start, SLE_UINT16),
30 SLE_VAR(Engine, reliability_max, SLE_UINT16),
31 SLE_VAR(Engine, reliability_final, SLE_UINT16),
32 SLE_VAR(Engine, duration_phase_1, SLE_UINT16),
33 SLE_VAR(Engine, duration_phase_2, SLE_UINT16),
34 SLE_VAR(Engine, duration_phase_3, SLE_UINT16),
35 SLE_VAR(Engine, flags, SLE_UINT8),
36 SLE_CONDVAR(Engine, preview_asked, SLE_UINT16, SLV_179, SL_MAX_VERSION),
37 SLE_CONDVAR(Engine, preview_company, SLE_UINT8, SLV_179, SL_MAX_VERSION),
38 SLE_VAR(Engine, preview_wait, SLE_UINT8),
39 SLE_CONDVAR(Engine, company_avail, SLE_FILE_U8 | SLE_VAR_U16, SL_MIN_VERSION, SLV_104),
40 SLE_CONDVAR(Engine, company_avail, SLE_UINT16, SLV_104, SL_MAX_VERSION),
41 SLE_CONDVAR(Engine, company_hidden, SLE_UINT16, SLV_193, SL_MAX_VERSION),
42 SLE_CONDSSTR(Engine, name, SLE_STR, SLV_84, SL_MAX_VERSION),
43 };
44
45 static std::vector<Engine*> _temp_engine;
46
47 /**
48 * Allocate an Engine structure, but not using the pools.
49 * The allocated Engine must be freed using FreeEngine;
50 * @return Allocated engine.
51 */
CallocEngine()52 static Engine* CallocEngine()
53 {
54 uint8 *zero = CallocT<uint8>(sizeof(Engine));
55 Engine *engine = new (zero) Engine();
56 return engine;
57 }
58
59 /**
60 * Deallocate an Engine constructed by CallocEngine.
61 * @param e Engine to free.
62 */
FreeEngine(Engine * e)63 static void FreeEngine(Engine *e)
64 {
65 if (e != nullptr) {
66 e->~Engine();
67 free(e);
68 }
69 }
70
GetTempDataEngine(EngineID index)71 Engine *GetTempDataEngine(EngineID index)
72 {
73 if (index < _temp_engine.size()) {
74 return _temp_engine[index];
75 } else if (index == _temp_engine.size()) {
76 _temp_engine.push_back(CallocEngine());
77 return _temp_engine[index];
78 } else {
79 NOT_REACHED();
80 }
81 }
82
83 struct ENGNChunkHandler : ChunkHandler {
ENGNChunkHandlerENGNChunkHandler84 ENGNChunkHandler() : ChunkHandler('ENGN', CH_TABLE) {}
85
SaveENGNChunkHandler86 void Save() const override
87 {
88 SlTableHeader(_engine_desc);
89
90 for (Engine *e : Engine::Iterate()) {
91 SlSetArrayIndex(e->index);
92 SlObject(e, _engine_desc);
93 }
94 }
95
LoadENGNChunkHandler96 void Load() const override
97 {
98 const std::vector<SaveLoad> slt = SlCompatTableHeader(_engine_desc, _engine_sl_compat);
99
100 /* As engine data is loaded before engines are initialized we need to load
101 * this information into a temporary array. This is then copied into the
102 * engine pool after processing NewGRFs by CopyTempEngineData(). */
103 int index;
104 while ((index = SlIterateArray()) != -1) {
105 Engine *e = GetTempDataEngine(index);
106 SlObject(e, slt);
107
108 if (IsSavegameVersionBefore(SLV_179)) {
109 /* preview_company_rank was replaced with preview_company and preview_asked.
110 * Just cancel any previews. */
111 e->flags &= ~4; // ENGINE_OFFER_WINDOW_OPEN
112 e->preview_company = INVALID_COMPANY;
113 e->preview_asked = (CompanyMask)-1;
114 }
115 }
116 }
117 };
118
119 /**
120 * Copy data from temporary engine array into the real engine pool.
121 */
CopyTempEngineData()122 void CopyTempEngineData()
123 {
124 for (Engine *e : Engine::Iterate()) {
125 if (e->index >= _temp_engine.size()) break;
126
127 const Engine *se = GetTempDataEngine(e->index);
128 e->intro_date = se->intro_date;
129 e->age = se->age;
130 e->reliability = se->reliability;
131 e->reliability_spd_dec = se->reliability_spd_dec;
132 e->reliability_start = se->reliability_start;
133 e->reliability_max = se->reliability_max;
134 e->reliability_final = se->reliability_final;
135 e->duration_phase_1 = se->duration_phase_1;
136 e->duration_phase_2 = se->duration_phase_2;
137 e->duration_phase_3 = se->duration_phase_3;
138 e->flags = se->flags;
139 e->preview_asked = se->preview_asked;
140 e->preview_company = se->preview_company;
141 e->preview_wait = se->preview_wait;
142 e->company_avail = se->company_avail;
143 e->company_hidden = se->company_hidden;
144 e->name = se->name;
145 }
146
147 ResetTempEngineData();
148 }
149
ResetTempEngineData()150 void ResetTempEngineData()
151 {
152 /* Get rid of temporary data */
153 for (std::vector<Engine*>::iterator it = _temp_engine.begin(); it != _temp_engine.end(); ++it) {
154 FreeEngine(*it);
155 }
156 _temp_engine.clear();
157 }
158
159 struct ENGSChunkHandler : ChunkHandler {
ENGSChunkHandlerENGSChunkHandler160 ENGSChunkHandler() : ChunkHandler('ENGS', CH_READONLY) {}
161
LoadENGSChunkHandler162 void Load() const override
163 {
164 /* Load old separate String ID list into a temporary array. This
165 * was always 256 entries. */
166 StringID names[256];
167
168 SlCopy(names, lengthof(names), SLE_STRINGID);
169
170 /* Copy each string into the temporary engine array. */
171 for (EngineID engine = 0; engine < lengthof(names); engine++) {
172 Engine *e = GetTempDataEngine(engine);
173 e->name = CopyFromOldName(names[engine]);
174 }
175 }
176 };
177
178 /** Save and load the mapping between the engine id in the pool, and the grf file it came from. */
179 static const SaveLoad _engine_id_mapping_desc[] = {
180 SLE_VAR(EngineIDMapping, grfid, SLE_UINT32),
181 SLE_VAR(EngineIDMapping, internal_id, SLE_UINT16),
182 SLE_VAR(EngineIDMapping, type, SLE_UINT8),
183 SLE_VAR(EngineIDMapping, substitute_id, SLE_UINT8),
184 };
185
186 struct EIDSChunkHandler : ChunkHandler {
EIDSChunkHandlerEIDSChunkHandler187 EIDSChunkHandler() : ChunkHandler('EIDS', CH_TABLE) {}
188
SaveEIDSChunkHandler189 void Save() const override
190 {
191 SlTableHeader(_engine_id_mapping_desc);
192
193 uint index = 0;
194 for (EngineIDMapping &eid : _engine_mngr) {
195 SlSetArrayIndex(index);
196 SlObject(&eid, _engine_id_mapping_desc);
197 index++;
198 }
199 }
200
LoadEIDSChunkHandler201 void Load() const override
202 {
203 const std::vector<SaveLoad> slt = SlCompatTableHeader(_engine_id_mapping_desc, _engine_id_mapping_sl_compat);
204
205 _engine_mngr.clear();
206
207 while (SlIterateArray() != -1) {
208 EngineIDMapping *eid = &_engine_mngr.emplace_back();
209 SlObject(eid, slt);
210 }
211 }
212 };
213
214 static const EIDSChunkHandler EIDS;
215 static const ENGNChunkHandler ENGN;
216 static const ENGSChunkHandler ENGS;
217 static const ChunkHandlerRef engine_chunk_handlers[] = {
218 EIDS,
219 ENGN,
220 ENGS,
221 };
222
223 extern const ChunkHandlerTable _engine_chunk_handlers(engine_chunk_handlers);
224