engine_base.h

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>.
 */

 
#ifndef ENGINE_BASE_H
#define ENGINE_BASE_H
 
#include "engine_type.h"
#include "vehicle_type.h"
#include "core/enum_type.hpp"
#include "core/pool_type.hpp"
#include "newgrf_commons.h"
#include "timer/timer_game_calendar.h"
 
struct WagonOverride {
  std::vector<EngineID> engines;
  CargoType cargo;
  const SpriteGroup *group;
};

enum class EngineDisplayFlag : uint8_t {
  HasVariants, 
  IsFolded, 
  Shaded, 
};

using EngineDisplayFlags = EnumBitSet<EngineDisplayFlag, uint8_t>;
 
typedef Pool<Engine, EngineID, 64> EnginePool;
extern EnginePool _engine_pool;
 
class Engine : public EnginePool::PoolItem<&_engine_pool> {
public:
  CompanyMask company_avail{}; 
  CompanyMask company_hidden{}; 
  CompanyMask preview_asked{}; 
 
  std::string name{}; 
 
  TimerGameCalendar::Date intro_date{}; 
  int32_t age = 0; 
 
  uint16_t reliability = 0; 
  uint16_t reliability_spd_dec = 0; 
  uint16_t reliability_start = 0; 
  uint16_t reliability_max = 0; 
  uint16_t reliability_final = 0; 
  uint16_t duration_phase_1 = 0; 
  uint16_t duration_phase_2 = 0; 
  uint16_t duration_phase_3 = 0; 
  EngineFlags flags{}; 
 
  CompanyID preview_company = CompanyID::Invalid();  
  uint8_t preview_wait = 0; 
  uint8_t original_image_index = 0; 
  VehicleType type = VehicleType::Invalid; 
 
  EngineDisplayFlags display_flags{}; 
  EngineID display_last_variant = EngineID::Invalid(); 
  EngineInfo info{};
 
  uint16_t list_position = 0;
 
  /* NewGRF related data */
  CargoGRFFileProps grf_prop{}; 
  std::vector<WagonOverride> overrides{};
  std::vector<BadgeID> badges{};
 
private:
  std::variant<std::monostate, RailVehicleInfo, RoadVehicleInfo, ShipVehicleInfo, AircraftVehicleInfo> vehicle_info{};
 
public:
  Engine(EngineID index, VehicleType type, uint16_t local_id);
  bool IsEnabled() const;

  CargoType GetDefaultCargoType() const
  {
    return this->info.cargo_type;
  }
 
  uint DetermineCapacity(const Vehicle *v, uint16_t *mail_capacity = nullptr) const;
 
  bool CanCarryCargo() const;

  uint GetDisplayDefaultCapacity(uint16_t *mail_capacity = nullptr) const
  {
    return this->DetermineCapacity(nullptr, mail_capacity);
  }
 
  Money GetRunningCost() const;
  Money GetCost() const;
  uint GetDisplayMaxSpeed() const;
  uint GetPower() const;
  uint GetDisplayWeight() const;
  uint GetDisplayMaxTractiveEffort() const;
  TimerGameCalendar::Date GetLifeLengthInDays() const;
  uint16_t GetRange() const;
  StringID GetAircraftTypeText() const;

  inline bool IsHidden(CompanyID c) const
  {
    return c < MAX_COMPANIES && this->company_hidden.Test(c);
  }

  const Engine *GetDisplayVariant() const
  {
    if (this->display_last_variant == this->index || this->display_last_variant == EngineID::Invalid()) return this;
    return Engine::Get(this->display_last_variant);
  }
 
  bool IsVariantHidden(CompanyID c) const;

  inline bool IsGroundVehicle() const
  {
    return this->type == VehicleType::Train || this->type == VehicleType::Road;
  }

  const GRFFile *GetGRF() const
  {
    return this->grf_prop.grffile;
  }
 
  uint32_t GetGRFID() const;
 
  struct EngineTypeFilter {
    VehicleType vt;
 
    bool operator() (size_t index) { return Engine::Get(index)->type == this->vt; }
  };
 
  template <typename T>
  inline T &VehInfo()
  {
    return std::get<T>(this->vehicle_info);
  }
 
  template <typename T>
  inline const T &VehInfo() const
  {
    return std::get<T>(this->vehicle_info);
  }

  static Pool::IterateWrapperFiltered<Engine, EngineTypeFilter> IterateType(VehicleType vt, size_t from = 0)
  {
    return Pool::IterateWrapperFiltered<Engine, EngineTypeFilter>(from, EngineTypeFilter{ vt });
  }
};
 
struct EngineIDMapping {
  uint32_t grfid = 0; 
  uint16_t internal_id = 0; 
  VehicleType type{}; 
  uint8_t substitute_id = 0; 
  EngineID engine{};
 
  static inline uint64_t Key(uint32_t grfid, uint16_t internal_id) { return static_cast<uint64_t>(grfid) << 32 | internal_id; }
 
  inline uint64_t Key() const { return Key(this->grfid, this->internal_id); }
 
  EngineIDMapping() {}
  EngineIDMapping(uint32_t grfid, uint16_t internal_id, VehicleType type, uint8_t substitute_id, EngineID engine)
    : grfid(grfid), internal_id(internal_id), type(type), substitute_id(substitute_id), engine(engine) {}
};

struct EngineIDMappingKeyProjection {
  inline uint64_t operator()(const EngineIDMapping &eid) const { return eid.Key(); }
};

struct EngineOverrideManager {
  VehicleTypeIndexArray<std::vector<EngineIDMapping>> mappings;
 
  void ResetToDefaultMapping();
  EngineID GetID(VehicleType type, uint16_t grf_local_id, uint32_t grfid);
  EngineID UseUnreservedID(VehicleType type, uint16_t grf_local_id, uint32_t grfid, bool static_access);
  void SetID(VehicleType type, uint16_t grf_local_id, uint32_t grfid, uint8_t substitute_id, EngineID engine);
 
  static bool ResetToCurrentNewGRFConfig();
};
 
extern EngineOverrideManager _engine_mngr;
 
inline const EngineInfo *EngInfo(EngineID e)
{
  return &Engine::Get(e)->info;
}
 
inline const RailVehicleInfo *RailVehInfo(EngineID e)
{
  return &Engine::Get(e)->VehInfo<RailVehicleInfo>();
}
 
inline const RoadVehicleInfo *RoadVehInfo(EngineID e)
{
  return &Engine::Get(e)->VehInfo<RoadVehicleInfo>();
}
 
inline const ShipVehicleInfo *ShipVehInfo(EngineID e)
{
  return &Engine::Get(e)->VehInfo<ShipVehicleInfo>();
}
 
inline const AircraftVehicleInfo *AircraftVehInfo(EngineID e)
{
  return &Engine::Get(e)->VehInfo<AircraftVehicleInfo>();
}
 
#endif /* ENGINE_BASE_H */