miguel.horta/openttd-cmclient
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
27f5f91eae22689d25080d343b84b4404d2ecf1c
openttd-cmclient/src/citymania/cm_saveload.cpp
dP 27f5f91eae Add more data to savegame
2020-07-09 10:49:39 +03:00

438 lines
15 KiB
C++
Raw Blame History

#include "../stdafx.h"
#include "../company_base.h"
#include "../date_func.h"
#include "../debug.h"
#include "../saveload/saveload.h"
#include "../town.h"
#include "cm_bitstream.hpp"
#include "cm_saveload.hpp"
#include "cm_game.hpp"
#include "cm_main.hpp"
namespace citymania {
static const uint SAVEGAME_DATA_FORMAT_VERSION = 2;
static const uint CITYMANIA_GRFID = 0x534B0501U; // Luukland_Citybuilder grf id actually
// copied form storage_sl.cpp
static const SaveLoad _storage_desc[] = {
SLE_CONDVAR(PersistentStorage, grfid, SLE_UINT32, SLV_6, SL_MAX_VERSION),
SLE_CONDARR(PersistentStorage, storage, SLE_UINT32, 16, SLV_161, SLV_EXTEND_PERSISTENT_STORAGE),
SLE_CONDARR(PersistentStorage, storage, SLE_UINT32, 256, SLV_EXTEND_PERSISTENT_STORAGE, SL_MAX_VERSION),
SLE_END()
};
static void EncodeTowns(BitOStream &bs)
{
for (const Town *t : Town::Iterate()) {
bs.WriteBytes(t->cm.growing_by_chance, 1);
bs.WriteBytes(t->cm.houses_reconstructed_this_month, 2);
bs.WriteBytes(t->cm.houses_reconstructed_last_month, 2);
bs.WriteBytes(t->cm.houses_demolished_this_month, 2);
bs.WriteBytes(t->cm.houses_demolished_last_month, 2);
bs.WriteBytes(t->cm.hs_total, 4);
bs.WriteBytes(t->cm.hs_total_prev, 2);
bs.WriteBytes(t->cm.hs_last_month, 2);
bs.WriteBytes(t->cm.cs_total, 4);
bs.WriteBytes(t->cm.cs_total_prev, 2);
bs.WriteBytes(t->cm.cs_last_month, 2);
bs.WriteBytes(t->cm.hr_total, 4);
bs.WriteBytes(t->cm.hr_total_prev, 2);
bs.WriteBytes(t->cm.hr_last_month, 2);
}
}
static void DecodeTowns(BitIStream &bs)
{
for (Town *t : Town::Iterate()) {
t->cm.growing_by_chance = bs.ReadBytes(1);
t->cm.houses_reconstructed_this_month = bs.ReadBytes(2);
t->cm.houses_reconstructed_last_month = bs.ReadBytes(2);
t->cm.houses_demolished_this_month = bs.ReadBytes(2);
t->cm.houses_demolished_last_month = bs.ReadBytes(2);
t->cm.hs_total = bs.ReadBytes(2);
t->cm.hs_total_prev = bs.ReadBytes(2);
t->cm.hs_last_month = bs.ReadBytes(2);
t->cm.cs_total = bs.ReadBytes(2);
t->cm.cs_total_prev = bs.ReadBytes(2);
t->cm.cs_last_month = bs.ReadBytes(2);
t->cm.hr_total = bs.ReadBytes(2);
t->cm.hr_total_prev = bs.ReadBytes(2);
t->cm.hr_last_month = bs.ReadBytes(2);
}
}
static void EncodeTownsGrowthTiles(BitOStream &bs, Game::TownsGrowthTilesIndex &tiles)
{
bs.WriteBytes(tiles.size(), 4);
for (Game::TownsGrowthTilesIndex::iterator p = tiles.begin();
p != tiles.end(); p++) {
bs.WriteBytes(p->first, 4);
bs.WriteBytes((uint8)p->second, 1);
}
}
static void DecodeTownsGrowthTiles(BitIStream &bs, Game::TownsGrowthTilesIndex &tiles)
{
uint n = bs.ReadBytes(4);
for (uint i = 0; i < n; i++) {
TileIndex tile = bs.ReadBytes(4);
TownGrowthTileState state = (TownGrowthTileState)bs.ReadBytes(1);
tiles[tile] = state;
}
}
static void EncodeCompanies(BitOStream &bs)
{
for (const Company *c : Company::Iterate()) {
bs.WriteBytes(c->cm.is_server, 1);
bs.WriteBytes(c->cm.is_scored, 1);
for (uint i = 0; i < NUM_CARGO; i++)
bs.WriteMoney(c->cur_economy.cm.cargo_income[i]);
for (uint j = 0; j < MAX_HISTORY_QUARTERS; j++)
for (uint i = 0; i < NUM_CARGO; i++)
bs.WriteMoney(c->old_economy[j].cm.cargo_income[i]);
}
}
static void DecodeCompanies(BitIStream &bs)
{
for (Company *c : Company::Iterate()) {
c->cm.is_server = bs.ReadBytes(1);
c->cm.is_scored = bs.ReadBytes(1);
for (uint i = 0; i < NUM_CARGO; i++)
c->cur_economy.cm.cargo_income[i] = bs.ReadMoney();
for (uint j = 0; j < MAX_HISTORY_QUARTERS; j++)
for (uint i = 0; i < NUM_CARGO; i++)
c->old_economy[j].cm.cargo_income[i] = bs.ReadMoney();
}
}
void CBController_saveload_encode(BitOStream &bs) {
bs.WriteBytes(0 /* version */, 2);
// Controller::saveload_encode(bs);
bs.WriteBytes(0, 1);
bs.WriteBytes(_settings_client.gui.cb_distance_check, 1);
bs.WriteBytes(0, 1);
bs.WriteBytes(0, 1);
bs.WriteBytes(0, 1);
bs.WriteBytes(0, 1);
bs.WriteBytes(0, 1);
bs.WriteBytes(0, 1);
std::vector<CargoID> cb_cargos;
for(CargoID cargo = 0; cargo < NUM_CARGO; cargo++) {
if (CB_GetReq(cargo) > 0)
cb_cargos.push_back(cargo);
}
for (auto cargo_id : cb_cargos) {
// bs.WriteBytes(req.cargo_id, 1);
// bs.WriteBytes(req.amount, 4);
// bs.WriteBytes(req.from, 4);
// bs.WriteBytes(req.decay, 1);
bs.WriteBytes(cargo_id, 1);
bs.WriteBytes(CB_GetReq(cargo_id), 4);
bs.WriteBytes(CB_GetFrom(cargo_id), 4);
bs.WriteBytes(CB_GetDecay(cargo_id), 1);
}
// uint16 cb_towns = 0;
// ForEachCBTown([this, &cb_towns](Town *, Company *) { cb_towns++; });
bs.WriteBytes(Town::GetNumItems(), 2);
for (Town *t : Town::Iterate()) {
auto &tcb = t->cb;
bs.WriteBytes(t->index, 2);
bs.WriteBytes(tcb.pax_delivered, 4);
bs.WriteBytes(tcb.mail_delivered, 4);
bs.WriteBytes(tcb.pax_delivered_last_month, 4);
bs.WriteBytes(tcb.mail_delivered_last_month, 4);
bs.WriteBytes((uint8)tcb.growth_state, 1);
bs.WriteBytes(tcb.shrink_effeciency, 1);
bs.WriteBytes(tcb.shrink_rate, 2);
bs.WriteBytes(tcb.shrink_counter, 2);
for (auto cargo_id : cb_cargos) {
bs.WriteBytes(tcb.stored[cargo_id], 4);
bs.WriteBytes(tcb.delivered[cargo_id], 4);
bs.WriteBytes(tcb.required[cargo_id], 4);
bs.WriteBytes(tcb.delivered_last_month[cargo_id], 4);
bs.WriteBytes(tcb.required_last_month[cargo_id], 4);
}
}
}
bool CBController_saveload_decode(BitIStream &bs) {
auto version = bs.ReadBytes(2);
// if (version != 0)
// ConsoleError("Save uses incompatible CB data version {}", version);
// ConsoleError("Server is not supposed to load CB games");
// if (!Controller::saveload_decode(bs))
// return false;
bs.ReadBytes(1); /* _settings_game.citymania.cb.requirements_type */
_settings_client.gui.cb_distance_check = bs.ReadBytes(1); /* _settings_game.citymania.cb.acceptance_range */
bs.ReadBytes(1); /* _settings_game.citymania.cb.storage_size */
bs.ReadBytes(1); /* _settings_game.citymania.cb.town_protection_range */
bs.ReadBytes(2); /* _settings_game.citymania.cb.claim_max_houses */
bs.ReadBytes(1); /* _settings_game.citymania.cb.smooth_growth_rate */
bs.ReadBytes(1); /* _settings_game.citymania.cb.allow_negative_growth */
// _settings_game.citymania.cb.requirements.clear();
auto n_cargos = bs.ReadBytes(1);
std::vector<CargoID> cb_cargos;
for (uint i = 0; i < n_cargos; i++) {
auto cargo_id = (CargoID)bs.ReadBytes(1);
if (cargo_id >= NUM_CARGO) {
DEBUG(sl, 0, "Invalid CargoID in CB towns cargo data (%u)", cargo_id);
// ConsoleError("Invalid CargoID in CB towns cargo data ({})", cargo_id);
return false;
}
cb_cargos.push_back(cargo_id);
auto required = bs.ReadBytes(4);
auto from = bs.ReadBytes(4);
auto decay = bs.ReadBytes(1);
CB_SetRequirements(cargo_id, required, from, decay);
// _settings_game.citymania.cb.requirements.push_back(CBRequirement(cargo_id, from, required, decay, i, ""));
}
auto n_towns = bs.ReadBytes(2);
for (uint i = 0; i < n_towns; i++) {
auto town_id = bs.ReadBytes(2);
auto t = Town::GetIfValid(town_id);
if (!t) {
DEBUG(sl, 0, "Invalid TownID in CB towns cargo data (%u)", town_id);
// ConsoleError("Invalid TownID in CB towns cargo data ({})", town_id);
return false;
}
auto &tcb = t->cb;
tcb.pax_delivered = bs.ReadBytes(4);
tcb.mail_delivered = bs.ReadBytes(4);
tcb.pax_delivered_last_month = bs.ReadBytes(4);
tcb.mail_delivered_last_month = bs.ReadBytes(4);
tcb.growth_state = (TownGrowthState)bs.ReadBytes(1);
tcb.shrink_effeciency = bs.ReadBytes(1);
tcb.shrink_rate = bs.ReadBytes(2);
tcb.shrink_counter = bs.ReadBytes(2);
for (auto cargo_id : cb_cargos) {
tcb.stored[cargo_id] = bs.ReadBytes(4);
tcb.delivered[cargo_id] = bs.ReadBytes(4);
tcb.required[cargo_id] = bs.ReadBytes(4);
tcb.delivered_last_month[cargo_id] = bs.ReadBytes(4);
tcb.required_last_month[cargo_id] = bs.ReadBytes(4);
}
};
return true;
}
uint8 _controller_type = 0;
uint8 _game_type = 0;
uint16 _last_client_version = 1512;
static u8vector EncodeData() {
BitOStream bs;
bs.Reserve(1000);
bs.WriteBytes(SAVEGAME_DATA_FORMAT_VERSION, 2);
bs.WriteBytes(_last_client_version, 2);
bs.WriteBytes(_controller_type, 1);
bs.WriteBytes(_date, 4); // Just in case we'll need to detect that game
bs.WriteBytes(_date_fract, 1); // was saved by unmodified client
bs.WriteBytes(_game_type, 1);
bs.WriteBytes(0, 3); // Reserved
bs.WriteBytes(0, 4); // Reserved
EncodeCompanies(bs);
EncodeTowns(bs);
EncodeTownsGrowthTiles(bs, _game->towns_growth_tiles);
EncodeTownsGrowthTiles(bs, _game->towns_growth_tiles_last_month);
if (_controller_type == 4)
CBController_saveload_encode(bs);
return bs.GetVector();
}
static void DecodeDataV2(BitIStream &bs) {
DecodeCompanies(bs);
DecodeTowns(bs);
DecodeTownsGrowthTiles(bs, _game->towns_growth_tiles);
DecodeTownsGrowthTiles(bs, _game->towns_growth_tiles_last_month);
if (_controller_type == 4) CBController_saveload_decode(bs);
}
static void DecodeTownsCargoV1(BitIStream &bs)
{
CB_SetStorage(bs.ReadBytes(1));
_settings_client.gui.cb_distance_check = bs.ReadBytes(1);
uint n_cb_cargos = bs.ReadBytes(1);
CB_ResetRequirements();
std::vector<CargoID> cb_cargos;
for (uint i = 0; i < n_cb_cargos; i++) {
uint cargo = bs.ReadBytes(1);
if (cargo >= NUM_CARGO) {
DEBUG(sl, 0, "Invalid CargoID in CB towns cargo data (%u)", cargo);
return;
}
cb_cargos.push_back(cargo);
uint req = bs.ReadBytes(4);
uint from = bs.ReadBytes(4);
uint decay = bs.ReadBytes(1);
CB_SetRequirements(cargo, req, from, decay);
}
Town *t;
uint n_affected_towns = bs.ReadBytes(2);
for (uint i = 0; i < n_affected_towns; i++) {
uint town_id = bs.ReadBytes(2);
t = Town::GetIfValid(town_id);
if (!t) {
DEBUG(sl, 0, "Invalid TownID in CB towns cargo data (%u)", town_id);
return;
}
auto &tcb = t->cb;
for (auto cargo_id : cb_cargos) {
tcb.stored[cargo_id] = bs.ReadBytes(4);
tcb.delivered_last_month[cargo_id] = bs.ReadBytes(4);
tcb.delivered[cargo_id] = bs.ReadBytes(4);
bs.ReadBytes(1); /* delivered enough */
tcb.required[cargo_id] = 0;
tcb.required_last_month[cargo_id] = 0;
}
}
}
static void DecodeDataV1(BitIStream &bs) {
if (_controller_type != 0) DecodeTownsCargoV1(bs);
for (Town *t : Town::Iterate()) {
t->cm.growing_by_chance = bs.ReadBytes(1);
t->cm.houses_reconstructed_this_month = bs.ReadBytes(2);
t->cm.houses_reconstructed_last_month = bs.ReadBytes(2);
t->cm.houses_demolished_this_month = bs.ReadBytes(2);
t->cm.houses_demolished_last_month = bs.ReadBytes(2);
}
Town *t;
uint n_affected_towns = bs.ReadBytes(2);
for (uint i = 0; i < n_affected_towns; i++) {
uint town_id = bs.ReadBytes(2);
t = Town::Get(town_id);
if (!t) {
DEBUG(sl, 0, "Invalid TownID in CB towns layout errors (%u)", town_id);
continue;
}
t->cm.hs_total = bs.ReadBytes(2);
t->cm.hs_total_prev = bs.ReadBytes(2);
t->cm.hs_last_month = bs.ReadBytes(2);
t->cm.cs_total = bs.ReadBytes(2);
t->cm.cs_total_prev = bs.ReadBytes(2);
t->cm.cs_last_month = bs.ReadBytes(2);
t->cm.hr_total = bs.ReadBytes(2);
t->cm.hr_total_prev = bs.ReadBytes(2);
t->cm.hr_last_month = bs.ReadBytes(2);
}
DecodeTownsGrowthTiles(bs, _game->towns_growth_tiles);
DecodeTownsGrowthTiles(bs, _game->towns_growth_tiles_last_month);
}
static void DecodeData(u8vector &data) {
if (data.size() == 0) {
DEBUG(sl, 2, "No CityMania save data");
return;
}
DEBUG(sl, 2, "CityMania save data takes %lu bytes", data.size());
BitIStream bs(data);
try {
uint version = bs.ReadBytes(2);
if (version > SAVEGAME_DATA_FORMAT_VERSION) {
DEBUG(sl, 0, "Savegame was made with newer version of client, extra save data was not loaded");
return;
}
DEBUG(sl, 2, "CityMania savegame data version %u", version);
_last_client_version = bs.ReadBytes(2);
_controller_type = bs.ReadBytes(1);
if (version <= 1) _controller_type = (_controller_type ? 4 : 0);
int32 date = bs.ReadBytes(4);
uint32 date_fract = bs.ReadBytes(1);
if (date != _date || date_fract != _date_fract) {
DEBUG(sl, 0, "Savegame was run in unmodified client, extra save data "
"preserved, but may not be accurate");
}
_game_type = bs.ReadBytes(1);
bs.ReadBytes(3); // reserved
bs.ReadBytes(4); // reserved
if (version == 1) DecodeDataV1(bs);
else DecodeDataV2(bs);
}
catch (BitIStreamUnexpectedEnd &e) {
DEBUG(sl, 0, "Invalid CityMania save data");
}
}
void Save_PSAC() {
/* Write the industries */
for (PersistentStorage *ps : PersistentStorage::Iterate()) {
if (ps->grfid == CITYMANIA_GRFID) {
continue;
}
ps->ClearChanges();
SlSetArrayIndex(ps->index);
SlObject(ps, _storage_desc);
}
uint32 grfid = CITYMANIA_GRFID;
u8vector data = EncodeData();
int n_chunks = (data.size() + 1023) / 1024;
data.resize(n_chunks * 1024);
DEBUG(sl, 2, "Citybuilder data takes %u bytes", (uint)data.size());
uint8 *ptr = &data[0];
SaveLoadGlobVarList _desc[] = {
SLEG_CONDVAR(grfid, SLE_UINT32, SLV_6, SL_MAX_VERSION),
SLEG_CONDARR(*ptr, SLE_UINT32, 256, SLV_EXTEND_PERSISTENT_STORAGE, SL_MAX_VERSION),
SLEG_END()
};
uint index = 0;
for (PersistentStorage *ps : PersistentStorage::Iterate()) {
if (ps->grfid != CITYMANIA_GRFID)
index = max(index, ps->index + 1);
}
for (int i = 0; i < n_chunks; i++, ptr += 1024) {
_desc[1].address = (void *)ptr;
SlSetArrayIndex(index + i);
SlGlobList(_desc);
}
}
void Load_PSAC()
{
int index;
/*
CITYMANIA_GRFID is used to hide extra data in persitant storages.
To save a bit of memory we only keep at most one PS with this
grfid and it is later discarded on save.
*/
PersistentStorage *ps = NULL;
u8vector cmdata;
uint chunk_size = IsSavegameVersionBefore(SLV_EXTEND_PERSISTENT_STORAGE) ? 64 : 1024;
while ((index = SlIterateArray()) != -1) {
if (ps == NULL) {
assert(PersistentStorage::CanAllocateItem());
ps = new (index) PersistentStorage(0, 0, 0);
}
SlObject(ps, _storage_desc);
if (ps->grfid == CITYMANIA_GRFID) {
uint8 *data = (uint8 *)(ps->storage);
cmdata.insert(cmdata.end(), data, data + chunk_size);
} else {
ps = NULL;
}
}
DecodeData(cmdata);
}
} // namespace citymania
Reference in New Issue View Git Blame Copy Permalink