company_sl.cpp

Go to the documentation of this file.

/*
 * This file is part of OpenTTD.
 * 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.
 * 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.
 * 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 <https://www.gnu.org/licenses/old-licenses/gpl-2.0>.
 */

 
#include "../stdafx.h"
 
#include "saveload.h"
#include "compat/company_sl_compat.h"
 
#include "../autoreplace_base.h"
#include "../company_func.h"
#include "../company_manager_face.h"
#include "../fios.h"
#include "../tunnelbridge_map.h"
#include "../tunnelbridge.h"
#include "../station_base.h"
#include "../strings_func.h"
 
#include "table/strings.h"
 
#include "../safeguards.h"

static const FaceVar *FindFaceVar(FaceVars style, FaceVarType type, StringID name)
{
  auto it = std::ranges::find_if(style, [type, name](const FaceVar &facevar) { return facevar.type == type && facevar.name == name; });
  if (it != std::end(style)) return &*it;
  return nullptr;
}

CompanyManagerFace ConvertFromOldCompanyManagerFace(uint32_t face)
{
  CompanyManagerFace cmf{};
 
  if (HasBit(face, 31)) cmf.style += 1;
  if (HasBit(face, 27) && (HasBit(face, 26) == HasBit(face, 19))) cmf.style += 2;
 
  const FaceSpec *spec = GetCompanyManagerFaceSpec(cmf.style);
  FaceVars vars = spec->GetFaceVars();
 
  cmf.style_label = spec->label;
 
  if (auto var = FindFaceVar(vars, FaceVarType::Toggle, STR_FACE_GLASSES); var != nullptr) var->SetBits(cmf, GB(face, 28, 3) <= 1);
  if (auto var = FindFaceVar(vars, FaceVarType::Palette, STR_FACE_EYECOLOUR); var != nullptr) var->SetBits(cmf, ClampU(GB(face, 20, 3), 5, 7) - 5);
  if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_CHIN); var != nullptr) var->SetBits(cmf, var->ScaleBits(GB(face, 4, 2)));
  if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_EYEBROWS); var != nullptr) var->SetBits(cmf, var->ScaleBits(GB(face, 6, 4)));
  if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_HAIR); var != nullptr) var->SetBits(cmf, var->ScaleBits(GB(face, 16, 4)));
  if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_JACKET); var != nullptr) var->SetBits(cmf, var->ScaleBits(GB(face, 20, 2)));
  if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_COLLAR); var != nullptr) var->SetBits(cmf, var->ScaleBits(GB(face, 22, 2)));
  if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_GLASSES); var != nullptr) var->SetBits(cmf, GB(face, 28, 1));
 
  uint lips = GB(face, 10, 4);
  if (cmf.style != 1 && cmf.style != 3 && lips < 4) {
    if (auto var = FindFaceVar(vars, FaceVarType::Toggle, STR_FACE_MOUSTACHE); var != nullptr) var->SetBits(cmf, true);
    if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_MOUSTACHE); var != nullptr) var->SetBits(cmf, std::max(lips, 1U) - 1);
  } else {
    if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_LIPS); var != nullptr) {
      if (cmf.style == 0 || cmf.style == 2) {
        lips = lips * 15 / 16;
        lips -= 3;
        if (cmf.style == 2 && lips > 8) lips = 0;
      } else {
        lips = var->ScaleBits(lips);
      }
      var->SetBits(cmf, lips);
    }
 
    if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_NOSE); var != nullptr) {
      uint nose = GB(face, 13, 3);
      if (cmf.style == 1) {
        nose = (nose * 3 >> 3) * 3 >> 2; // There is 'hole' in the nose sprites for women
      } else {
        nose = var->ScaleBits(nose);
      }
      var->SetBits(cmf, nose);
    }
  }
 
  if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_TIE); var != nullptr) {
    uint tie = GB(face, 24, 4);
    var->SetBits(cmf, var->ScaleBits(tie / 2));
  }
 
  if (auto var = FindFaceVar(vars, FaceVarType::Sprite, STR_FACE_EARRING); var != nullptr) {
    uint earring = GB(face, 24, 4);
    if (earring < 3) { // Not all women have an earring
      if (auto has_earring = FindFaceVar(vars, FaceVarType::Toggle, STR_FACE_EARRING)) {
        has_earring->SetBits(cmf, true);
        var->SetBits(cmf, earring);
      }
    }
  }
 
  return cmf;
}

void AfterLoadCompanyStats()
{
  /* Reset infrastructure statistics to zero. */
  for (Company *c : Company::Iterate()) c->infrastructure = {};
 
  /* Collect airport count. */
  for (const Station *st : Station::Iterate()) {
    if (st->facilities.Test(StationFacility::Airport) && Company::IsValidID(st->owner)) {
      Company::Get(st->owner)->infrastructure.airport++;
    }
  }
 
  Company *c;
  for (const auto tile : Map::Iterate()) {
    switch (GetTileType(tile)) {
      case TileType::Railway:
        c = Company::GetIfValid(GetTileOwner(tile));
        if (c != nullptr) {
          uint pieces = 1;
          if (IsPlainRail(tile)) {
            TrackBits bits = GetTrackBits(tile);
            pieces = bits.Count();
            if (TracksOverlap(bits)) pieces *= pieces;
          }
          c->infrastructure.rail[GetRailType(tile)] += pieces;
 
          if (HasSignals(tile)) c->infrastructure.signal += CountBits(GetPresentSignals(tile));
        }
        break;
 
      case TileType::Road: {
        if (IsLevelCrossing(tile)) {
          c = Company::GetIfValid(GetTileOwner(tile));
          if (c != nullptr) c->infrastructure.rail[GetRailType(tile)] += LEVELCROSSING_TRACKBIT_FACTOR;
        }
 
        /* Iterate all present road types as each can have a different owner. */
        for (RoadTramType rtt : ROADTRAMTYPES_ALL) {
          RoadType rt = GetRoadType(tile, rtt);
          if (rt == INVALID_ROADTYPE) continue;
          c = Company::GetIfValid(IsRoadDepot(tile) ? GetTileOwner(tile) : GetRoadOwner(tile, rtt));
          /* A level crossings and depots have two road bits. */
          if (c != nullptr) c->infrastructure.road[rt] += IsNormalRoad(tile) ? GetRoadBits(tile, rtt).Count() : 2;
        }
        break;
      }
 
      case TileType::Station:
        c = Company::GetIfValid(GetTileOwner(tile));
        if (c != nullptr && GetStationType(tile) != StationType::Airport && !IsBuoy(tile)) c->infrastructure.station++;
 
        switch (GetStationType(tile)) {
          case StationType::Rail:
          case StationType::RailWaypoint:
            if (c != nullptr && !IsStationTileBlocked(tile)) c->infrastructure.rail[GetRailType(tile)]++;
            break;
 
          case StationType::Bus:
          case StationType::Truck:
          case StationType::RoadWaypoint: {
            /* Iterate all present road types as each can have a different owner. */
            for (RoadTramType rtt : ROADTRAMTYPES_ALL) {
              RoadType rt = GetRoadType(tile, rtt);
              if (rt == INVALID_ROADTYPE) continue;
              c = Company::GetIfValid(GetRoadOwner(tile, rtt));
              if (c != nullptr) c->infrastructure.road[rt] += 2; // A road stop has two road bits.
            }
            break;
          }
 
          case StationType::Dock:
          case StationType::Buoy:
            if (GetWaterClass(tile) == WaterClass::Canal) {
              if (c != nullptr) c->infrastructure.water++;
            }
            break;
 
          default:
            break;
        }
        break;
 
      case TileType::Water:
        if (IsShipDepot(tile) || IsLock(tile)) {
          c = Company::GetIfValid(GetTileOwner(tile));
          if (c != nullptr) {
            if (IsShipDepot(tile)) c->infrastructure.water += LOCK_DEPOT_TILE_FACTOR;
            if (IsLock(tile) && GetLockPart(tile) == LockPart::Middle) {
              /* The middle tile specifies the owner of the lock. */
              c->infrastructure.water += 3 * LOCK_DEPOT_TILE_FACTOR; // the middle tile specifies the owner of the
              break; // do not count the middle tile as canal
            }
          }
        }
        [[fallthrough]];
 
      case TileType::Object:
        if (GetWaterClass(tile) == WaterClass::Canal) {
          c = Company::GetIfValid(GetTileOwner(tile));
          if (c != nullptr) c->infrastructure.water++;
        }
        break;
 
      case TileType::TunnelBridge: {
        /* Only count the tunnel/bridge if we're on the northern end tile. */
        TileIndex other_end = GetOtherTunnelBridgeEnd(tile);
        if (tile < other_end) {
          /* Count each tunnel/bridge TUNNELBRIDGE_TRACKBIT_FACTOR times to simulate
           * the higher structural maintenance needs, and don't forget the end tiles. */
          uint len = (GetTunnelBridgeLength(tile, other_end) + 2) * TUNNELBRIDGE_TRACKBIT_FACTOR;
 
          switch (GetTunnelBridgeTransportType(tile)) {
            case TransportType::Rail:
              c = Company::GetIfValid(GetTileOwner(tile));
              if (c != nullptr) c->infrastructure.rail[GetRailType(tile)] += len;
              break;
 
            case TransportType::Road: {
              /* Iterate all present road types as each can have a different owner. */
              for (RoadTramType rtt : ROADTRAMTYPES_ALL) {
                RoadType rt = GetRoadType(tile, rtt);
                if (rt == INVALID_ROADTYPE) continue;
                c = Company::GetIfValid(GetRoadOwner(tile, rtt));
                if (c != nullptr) c->infrastructure.road[rt] += len * 2; // A full diagonal road has two road bits.
              }
              break;
            }
 
            case TransportType::Water:
              c = Company::GetIfValid(GetTileOwner(tile));
              if (c != nullptr) c->infrastructure.water += len;
              break;
 
            default:
              break;
          }
        }
        break;
      }
 
      default:
        break;
    }
  }
}

struct CompanyOldAI {
  uint8_t num_build_rec;
};
 
class SlCompanyOldAIBuildRec : public DefaultSaveLoadHandler<SlCompanyOldAIBuildRec, CompanyOldAI> {
public:
  static inline const SaveLoad description[] = {{}}; 
  static inline const SaveLoadCompatTable compat_description = _company_old_ai_buildrec_compat;
 
  SaveLoadTable GetDescription() const override { return {}; }
 
  void Load(CompanyOldAI *old_ai) const override
  {
    for (int i = 0; i != old_ai->num_build_rec; i++) {
      SlObject(nullptr, this->GetLoadDescription());
    }
  }
 
  void LoadCheck(CompanyOldAI *old_ai) const override { this->Load(old_ai); }
};
 
class SlCompanyOldAI : public DefaultSaveLoadHandler<SlCompanyOldAI, CompanyProperties> {
public:
  static inline const SaveLoad description[] = {
    SaveLoad::Variable<VarFileType::U8>("num_build_rec", SLE_OBJECT_ADDRESS(CompanyOldAI, num_build_rec), SaveLoadVersion::MinVersion, SaveLoadVersion::NoAI),
    SaveLoad::StructList<SlCompanyOldAIBuildRec>("buildrec"),
  };
  static inline const SaveLoadCompatTable compat_description = _company_old_ai_compat;
 
  void Load(CompanyProperties *c) const override
  {
    if (!c->is_ai) return;
 
    CompanyOldAI old_ai;
    SlObject(&old_ai, this->GetLoadDescription());
  }
 
  void LoadCheck(CompanyProperties *c) const override { this->Load(c); }
};
 
class SlCompanySettings : public DefaultSaveLoadHandler<SlCompanySettings, CompanyProperties> {
public:
  static inline const SaveLoad description[] = {
    /* Engine renewal settings */
    SaveLoad::Reference<SLRefType::EngineRenew>("engine_renew_list", SLE_OBJECT_ADDRESS(CompanyProperties, engine_renew_list), SaveLoadVersion::EngineRenewPool),
    SaveLoad::Variable<VarFileType::Bool>("settings.engine_renew", SLE_OBJECT_ADDRESS(CompanyProperties, settings.engine_renew), SaveLoadVersion::EngineRenew),
    SaveLoad::Variable<VarFileType::I16>("settings.engine_renew_months", SLE_OBJECT_ADDRESS(CompanyProperties, settings.engine_renew_months), SaveLoadVersion::EngineRenew),
    SaveLoad::Variable<VarFileType::U32>("settings.engine_renew_money", SLE_OBJECT_ADDRESS(CompanyProperties, settings.engine_renew_money), SaveLoadVersion::EngineRenew),
    SaveLoad::Variable<VarFileType::Bool>("settings.renew_keep_length", SLE_OBJECT_ADDRESS(CompanyProperties, settings.renew_keep_length), SaveLoadVersion::VehicleCurrencyStationChanges),
 
    /* Default vehicle settings */
    SaveLoad::Variable<VarFileType::Bool>("settings.vehicle.servint_ispercent", SLE_OBJECT_ADDRESS(CompanyProperties, settings.vehicle.servint_ispercent), SaveLoadVersion::CompanyServiceIntervals),
    SaveLoad::Variable<VarFileType::U16>("settings.vehicle.servint_trains", SLE_OBJECT_ADDRESS(CompanyProperties, settings.vehicle.servint_trains), SaveLoadVersion::CompanyServiceIntervals),
    SaveLoad::Variable<VarFileType::U16>("settings.vehicle.servint_roadveh", SLE_OBJECT_ADDRESS(CompanyProperties, settings.vehicle.servint_roadveh), SaveLoadVersion::CompanyServiceIntervals),
    SaveLoad::Variable<VarFileType::U16>("settings.vehicle.servint_aircraft", SLE_OBJECT_ADDRESS(CompanyProperties, settings.vehicle.servint_aircraft), SaveLoadVersion::CompanyServiceIntervals),
    SaveLoad::Variable<VarFileType::U16>("settings.vehicle.servint_ships", SLE_OBJECT_ADDRESS(CompanyProperties, settings.vehicle.servint_ships), SaveLoadVersion::CompanyServiceIntervals),
  };
  static inline const SaveLoadCompatTable compat_description = _company_settings_compat;
 
  void Save(CompanyProperties *c) const override
  {
    SlObject(c, this->GetDescription());
  }
 
  void Load(CompanyProperties *c) const override
  {
    SlObject(c, this->GetLoadDescription());
  }
 
  void FixPointers(CompanyProperties *c) const override
  {
    SlObject(c, this->GetDescription());
  }
 
  void LoadCheck(CompanyProperties *c) const override { this->Load(c); }
};
 
class SlCompanyEconomy : public DefaultSaveLoadHandler<SlCompanyEconomy, CompanyProperties> {
public:
  static inline const SaveLoad description[] = {
    SaveLoad::Variable<VarFileType::I32>("income", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, income), SaveLoadVersion::MinVersion, SaveLoadVersion::VehicleCurrencyStationChanges),
    SaveLoad::Variable<VarFileType::I64>("income", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, income), SaveLoadVersion::VehicleCurrencyStationChanges),
    SaveLoad::Variable<VarFileType::I32>("expenses", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, expenses), SaveLoadVersion::MinVersion, SaveLoadVersion::VehicleCurrencyStationChanges),
    SaveLoad::Variable<VarFileType::I64>("expenses", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, expenses), SaveLoadVersion::VehicleCurrencyStationChanges),
    SaveLoad::Variable<VarFileType::I32>("company_value", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, company_value), SaveLoadVersion::MinVersion, SaveLoadVersion::VehicleCurrencyStationChanges),
    SaveLoad::Variable<VarFileType::I64>("company_value", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, company_value), SaveLoadVersion::VehicleCurrencyStationChanges),
 
    SaveLoad::Variable<VarFileType::I32>("delivered_cargo[NUM_CARGO - 1]", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, delivered_cargo[NUM_CARGO - 1]), SaveLoadVersion::MinVersion, SaveLoadVersion::CountIndividualCargoes),
    SaveLoad::Array<VarFileType::U32, 32>("delivered_cargo", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, delivered_cargo), SaveLoadVersion::CountIndividualCargoes, SaveLoadVersion::ExtendCargotypes),
    SaveLoad::Array<VarFileType::U32, NUM_CARGO>("delivered_cargo", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, delivered_cargo), SaveLoadVersion::ExtendCargotypes),
    SaveLoad::Variable<VarFileType::I32>("performance_history", SLE_OBJECT_ADDRESS(CompanyEconomyEntry, performance_history)),
  };
  static inline const SaveLoadCompatTable compat_description = _company_economy_compat;
 
  void Save(CompanyProperties *c) const override
  {
    SlObject(&c->cur_economy, this->GetDescription());
  }
 
  void Load(CompanyProperties *c) const override
  {
    SlObject(&c->cur_economy, this->GetLoadDescription());
  }
 
  void FixPointers(CompanyProperties *c) const override
  {
    SlObject(&c->cur_economy, this->GetDescription());
  }
 
  void LoadCheck(CompanyProperties *c) const override { this->Load(c); }
};
 
class SlCompanyOldEconomy : public SlCompanyEconomy {
public:
  void Save(CompanyProperties *c) const override
  {
    SlSetStructListLength(c->num_valid_stat_ent);
    for (int i = 0; i < c->num_valid_stat_ent; i++) {
      SlObject(&c->old_economy[i], this->GetDescription());
    }
  }
 
  void Load(CompanyProperties *c) const override
  {
    if (!IsSavegameVersionBefore(SaveLoadVersion::SaveloadListLength)) {
      c->num_valid_stat_ent = (uint8_t)SlGetStructListLength(UINT8_MAX);
    }
    if (c->num_valid_stat_ent > std::size(c->old_economy)) SlErrorCorrupt("Too many old economy entries");
 
    for (int i = 0; i < c->num_valid_stat_ent; i++) {
      SlObject(&c->old_economy[i], this->GetLoadDescription());
    }
  }
 
  void LoadCheck(CompanyProperties *c) const override { this->Load(c); }
};
 
class SlCompanyLiveries : public DefaultSaveLoadHandler<SlCompanyLiveries, CompanyProperties> {
public:
  static inline const SaveLoad description[] = {
    SaveLoad::Variable<VarFileType::U8>("in_use", SLE_OBJECT_ADDRESS(Livery, in_use), SaveLoadVersion::Liveries),
    SaveLoad::Variable<VarFileType::U8>("colour1", SLE_OBJECT_ADDRESS(Livery, colour1), SaveLoadVersion::Liveries),
    SaveLoad::Variable<VarFileType::U8>("colour2", SLE_OBJECT_ADDRESS(Livery, colour2), SaveLoadVersion::Liveries),
  };
  static inline const SaveLoadCompatTable compat_description = _company_liveries_compat;

  size_t GetNumLiveries() const
  {
    if (IsSavegameVersionBefore(SaveLoadVersion::TramLivery)) return to_underlying(LiveryScheme::End) - 4;
    if (IsSavegameVersionBefore(SaveLoadVersion::MaglevMonorailPaxWagonLivery)) return to_underlying(LiveryScheme::End) - 2;
    if (IsSavegameVersionBefore(SaveLoadVersion::SaveloadListLength)) return to_underlying(LiveryScheme::End);
    /* Read from the savegame how long the list is. */
    return SlGetStructListLength(to_underlying(LiveryScheme::End));
  }
 
  void Save(CompanyProperties *c) const override
  {
    SlSetStructListLength(to_underlying(LiveryScheme::End));
    for (auto &livery : c->livery) {
      SlObject(&livery, this->GetDescription());
    }
  }
 
  void Load(CompanyProperties *c) const override
  {
    size_t num_liveries = this->GetNumLiveries();
    bool update_in_use = IsSavegameVersionBefore(SaveLoadVersion::GroupLiveries);
 
    for (size_t i = 0; i < num_liveries; i++) {
      Livery &livery = c->livery[static_cast<LiveryScheme>(i)];
      SlObject(&livery, this->GetLoadDescription());
      if (update_in_use && i != 0) {
        if (!livery.in_use.Any({Livery::Flag::Primary, Livery::Flag::Secondary})) {
          livery.colour1 = c->livery[LiveryScheme::Default].colour1;
          livery.colour2 = c->livery[LiveryScheme::Default].colour2;
        } else {
          livery.in_use = {Livery::Flag::Primary, Livery::Flag::Secondary};
        }
      }
    }
 
    if (IsSavegameVersionBefore(SaveLoadVersion::MaglevMonorailPaxWagonLivery)) {
      /* We want to insert some liveries somewhere in between. This means some have to be moved. */
      std::move_backward(std::begin(c->livery) + to_underlying(LiveryScheme::FreightWagon) - 2, std::end(c->livery) - 2, std::end(c->livery));
      c->livery[LiveryScheme::PassengerWagonMonorail] = c->livery[LiveryScheme::Monorail];
      c->livery[LiveryScheme::PassengerWagonMaglev] = c->livery[LiveryScheme::Maglev];
    }
 
    if (IsSavegameVersionBefore(SaveLoadVersion::TramLivery)) {
      /* Copy bus/truck liveries over to trams */
      c->livery[LiveryScheme::PassengerTram] = c->livery[LiveryScheme::Bus];
      c->livery[LiveryScheme::FreightTram] = c->livery[LiveryScheme::Truck];
    }
  }
 
  void LoadCheck(CompanyProperties *c) const override { this->Load(c); }
};
 
class SlAllowListData : public VectorSaveLoadHandler<SlAllowListData, CompanyProperties, std::string> {
public:
  struct KeyWrapper {
    std::string key;
  };
 
  static inline const SaveLoad description[] = {
    SaveLoad::String("key", SLE_OBJECT_ADDRESS(KeyWrapper, key)),
  };
  static inline const SaveLoadCompatTable compat_description = {};
 
  std::vector<std::string> &GetVector(CompanyProperties *cprops) const override { return cprops->allow_list; }
 
  void LoadCheck(CompanyProperties *cprops) const override { this->Load(cprops); }
};

static const SaveLoad _company_desc[] = {
  SaveLoad::Variable<VarFileType::U32>("name_2", SLE_OBJECT_ADDRESS(CompanyProperties, name_2)),
  SaveLoad::Variable<VarFileType::StringID>("name_1", SLE_OBJECT_ADDRESS(CompanyProperties, name_1)),
  SaveLoad::String("name", SLE_OBJECT_ADDRESS(CompanyProperties, name), StringValidationSetting::AllowControlCode, SaveLoadVersion::ReplaceCustomNameArray),
 
  SaveLoad::Variable<VarFileType::StringID>("president_name_1", SLE_OBJECT_ADDRESS(CompanyProperties, president_name_1)),
  SaveLoad::Variable<VarFileType::U32>("president_name_2", SLE_OBJECT_ADDRESS(CompanyProperties, president_name_2)),
  SaveLoad::String("president_name", SLE_OBJECT_ADDRESS(CompanyProperties, president_name), StringValidationSetting::AllowControlCode, SaveLoadVersion::ReplaceCustomNameArray),
 
  SaveLoad::Vector<VarFileType::String>("allow_list", SLE_OBJECT_ADDRESS(CompanyProperties, allow_list), SaveLoadVersion::CompanyAllowList, SaveLoadVersion::CompanyAllowListV2),
  SaveLoad::StructList<SlAllowListData>("allow_list", SaveLoadVersion::CompanyAllowListV2),
  SaveLoad::Variable<VarFileType::Bool>("allow_any", SLE_OBJECT_ADDRESS(CompanyProperties, allow_any)),
 
  SaveLoad::Variable<VarFileType::U32>("face", SLE_OBJECT_ADDRESS(CompanyProperties, face.bits)),
  SaveLoad::String("face_style", SLE_OBJECT_ADDRESS(CompanyProperties, face.style_label), {}, SaveLoadVersion::FaceStyles),
 
  /* money was changed to a 64 bit field in savegame version 1. */
  SaveLoad::Variable<VarFileType::I32>("money", SLE_OBJECT_ADDRESS(CompanyProperties, money), SaveLoadVersion::MinVersion, SaveLoadVersion::BigCurrency),
  SaveLoad::Variable<VarFileType::I64>("money", SLE_OBJECT_ADDRESS(CompanyProperties, money), SaveLoadVersion::BigCurrency),
 
  SaveLoad::Variable<VarFileType::I32>("current_loan", SLE_OBJECT_ADDRESS(CompanyProperties, current_loan), SaveLoadVersion::MinVersion, SaveLoadVersion::UnifyCurrency),
  SaveLoad::Variable<VarFileType::I64>("current_loan", SLE_OBJECT_ADDRESS(CompanyProperties, current_loan), SaveLoadVersion::UnifyCurrency),
  SaveLoad::Variable<VarFileType::I64>("max_loan", SLE_OBJECT_ADDRESS(CompanyProperties, max_loan), SaveLoadVersion::MaxLoanForCompany),
 
  SaveLoad::Variable<VarFileType::U8>("colour", SLE_OBJECT_ADDRESS(CompanyProperties, colour)),
  SaveLoad::Variable<VarFileType::U8>("money_fraction", SLE_OBJECT_ADDRESS(CompanyProperties, money_fraction)),
  SaveLoad::Variable<VarFileType::U8>("block_preview", SLE_OBJECT_ADDRESS(CompanyProperties, block_preview)),
 
  SaveLoad::Variable<VarFileType::U16>("location_of_HQ", SLE_OBJECT_ADDRESS(CompanyProperties, location_of_HQ), SaveLoadVersion::MinVersion, SaveLoadVersion::MultipleRoadStops),
  SaveLoad::Variable<VarFileType::U32>("location_of_HQ", SLE_OBJECT_ADDRESS(CompanyProperties, location_of_HQ), SaveLoadVersion::MultipleRoadStops),
  SaveLoad::Variable<VarFileType::U16>("last_build_coordinate", SLE_OBJECT_ADDRESS(CompanyProperties, last_build_coordinate), SaveLoadVersion::MinVersion, SaveLoadVersion::MultipleRoadStops),
  SaveLoad::Variable<VarFileType::U32>("last_build_coordinate", SLE_OBJECT_ADDRESS(CompanyProperties, last_build_coordinate), SaveLoadVersion::MultipleRoadStops),
  SaveLoad::Variable<VarFileType::U8>("inaugurated_year", SLE_OBJECT_ADDRESS(CompanyProperties, inaugurated_year), SaveLoadVersion::MinVersion, SaveLoadVersion::BigDates),
  SaveLoad::Variable<VarFileType::I32>("inaugurated_year", SLE_OBJECT_ADDRESS(CompanyProperties, inaugurated_year), SaveLoadVersion::BigDates),
  SaveLoad::Variable<VarFileType::I32>("inaugurated_year_calendar", SLE_OBJECT_ADDRESS(CompanyProperties, inaugurated_year_calendar), SaveLoadVersion::CompanyInauguratedPeriodV2),
 
  SaveLoad::Variable<VarFileType::U8>("num_valid_stat_ent", SLE_OBJECT_ADDRESS(CompanyProperties, num_valid_stat_ent), SaveLoadVersion::MinVersion, SaveLoadVersion::SaveloadListLength),
 
  SaveLoad::Variable<VarFileType::U8>("months_of_bankruptcy", SLE_OBJECT_ADDRESS(CompanyProperties, months_of_bankruptcy)),
  SaveLoad::Variable<VarFileType::U8>("bankrupt_asked", SLE_OBJECT_ADDRESS(CompanyProperties, bankrupt_asked), SaveLoadVersion::MinVersion, SaveLoadVersion::MoreCompanies),
  SaveLoad::Variable<VarFileType::U16>("bankrupt_asked", SLE_OBJECT_ADDRESS(CompanyProperties, bankrupt_asked), SaveLoadVersion::MoreCompanies),
  SaveLoad::Variable<VarFileType::I16>("bankrupt_timeout", SLE_OBJECT_ADDRESS(CompanyProperties, bankrupt_timeout)),
  SaveLoad::Variable<VarFileType::I32>("bankrupt_value", SLE_OBJECT_ADDRESS(CompanyProperties, bankrupt_value), SaveLoadVersion::MinVersion, SaveLoadVersion::UnifyCurrency),
  SaveLoad::Variable<VarFileType::I64>("bankrupt_value", SLE_OBJECT_ADDRESS(CompanyProperties, bankrupt_value), SaveLoadVersion::UnifyCurrency),
 
  /* yearly expenses was changed to 64-bit in savegame version 2. */
  SaveLoad::Array<VarFileType::I32, 3 * 13>("yearly_expenses", SLE_OBJECT_ADDRESS(CompanyProperties, yearly_expenses), SaveLoadVersion::MinVersion, SaveLoadVersion::VehicleCurrencyStationChanges),
  SaveLoad::Array<VarFileType::I64, 3 * 13>("yearly_expenses", SLE_OBJECT_ADDRESS(CompanyProperties, yearly_expenses), SaveLoadVersion::VehicleCurrencyStationChanges),
 
  SaveLoad::Variable<VarFileType::Bool>("is_ai", SLE_OBJECT_ADDRESS(CompanyProperties, is_ai), SaveLoadVersion::VehicleCurrencyStationChanges),
 
  SaveLoad::Variable<VarFileType::U32>("terraform_limit", SLE_OBJECT_ADDRESS(CompanyProperties, terraform_limit), SaveLoadVersion::TerraformLimits),
  SaveLoad::Variable<VarFileType::U32>("clear_limit", SLE_OBJECT_ADDRESS(CompanyProperties, clear_limit), SaveLoadVersion::TerraformLimits),
  SaveLoad::Variable<VarFileType::U32>("tree_limit", SLE_OBJECT_ADDRESS(CompanyProperties, tree_limit), SaveLoadVersion::AutoreplaceWhenOldTreeLimit),
  SaveLoad::Struct<SlCompanySettings>("settings"),
  SaveLoad::Struct<SlCompanyOldAI>("old_ai", SaveLoadVersion::MinVersion, SaveLoadVersion::NoAI),
  SaveLoad::Struct<SlCompanyEconomy>("cur_economy"),
  SaveLoad::StructList<SlCompanyOldEconomy>("old_economy"),
  SaveLoad::StructList<SlCompanyLiveries>("liveries", SaveLoadVersion::Liveries),
};
 
struct PLYRChunkHandler : ChunkHandler {
  PLYRChunkHandler() : ChunkHandler("PLYR", ChunkType::Table) {}
 
  void Save() const override
  {
    SlTableHeader(_company_desc);
 
    for (Company *c : Company::Iterate()) {
      SlSetArrayIndex(c->index);
      SlObject(c, _company_desc);
    }
  }
 
  void Load() const override
  {
    const std::vector<SaveLoad> slt = SlCompatTableHeader(_company_desc, _company_sl_compat);
 
    int index;
    while ((index = SlIterateArray()) != -1) {
      Company *c = Company::CreateAtIndex(CompanyID(index));
      SlObject(c, slt);
      _company_colours[c->index] = c->colour;
    }
  }
 
 
  void LoadCheck(size_t) const override
  {
    const std::vector<SaveLoad> slt = SlCompatTableHeader(_company_desc, _company_sl_compat);
 
    int index;
    while ((index = SlIterateArray()) != -1) {
      std::unique_ptr<CompanyProperties> cprops = std::make_unique<CompanyProperties>();
      SlObject(cprops.get(), slt);
 
      /* We do not load old custom names */
      if (IsSavegameVersionBefore(SaveLoadVersion::ReplaceCustomNameArray)) {
        if (GetStringTab(cprops->name_1) == TEXT_TAB_OLD_CUSTOM) {
          cprops->name_1 = STR_GAME_SAVELOAD_NOT_AVAILABLE;
        }
 
        if (GetStringTab(cprops->president_name_1) == TEXT_TAB_OLD_CUSTOM) {
          cprops->president_name_1 = STR_GAME_SAVELOAD_NOT_AVAILABLE;
        }
      }
 
      if (cprops->name.empty() && !IsInsideMM(cprops->name_1, SPECSTR_COMPANY_NAME_START, SPECSTR_COMPANY_NAME_END) &&
        cprops->name_1 != STR_GAME_SAVELOAD_NOT_AVAILABLE && cprops->name_1 != STR_SV_UNNAMED &&
        cprops->name_1 != SPECSTR_ANDCO_NAME && cprops->name_1 != SPECSTR_PRESIDENT_NAME &&
        cprops->name_1 != SPECSTR_SILLY_NAME) {
        cprops->name_1 = STR_GAME_SAVELOAD_NOT_AVAILABLE;
      }
 
      if (_load_check_data.companies.count(index) == 0) {
        _load_check_data.companies[index] = std::move(cprops);
      }
    }
  }
 
  void FixPointers() const override
  {
    for (Company *c : Company::Iterate()) {
      SlObject(c, _company_desc);
    }
  }
};
 
static const PLYRChunkHandler PLYR;
static const ChunkHandlerRef company_chunk_handlers[] = {
  PLYR,
};
 
extern const ChunkHandlerTable _company_chunk_handlers(company_chunk_handlers);