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 <http://www.gnu.org/licenses/>.
 */
 
#ifndef ENGINE_BASE_H
#define ENGINE_BASE_H
 
#include "engine_type.h"
#include "vehicle_type.h"
#include "core/pool_type.hpp"
#include "newgrf_commons.h"
#include "timer/timer_game_calendar.h"
 
struct WagonOverride {
  std::vector<EngineID> engines;
  CargoID cargo;
  const SpriteGroup *group;
};
 
enum class EngineDisplayFlags : uint8_t {
  None        = 0,         
  HasVariants = (1U << 0), 
  IsFolded    = (1U << 1), 
  Shaded      = (1U << 2), 
};
DECLARE_ENUM_AS_BIT_SET(EngineDisplayFlags)
 
typedef Pool<Engine, EngineID, 64, 64000> EnginePool;
extern EnginePool _engine_pool;
 
struct Engine : EnginePool::PoolItem<&_engine_pool> {
  CompanyMask company_avail;  
  CompanyMask company_hidden; 
  CompanyMask preview_asked;  
 
  std::string name;           
 
  TimerGameCalendar::Date intro_date; 
  int32_t age;                  
 
  uint16_t reliability;         
  uint16_t reliability_spd_dec; 
  uint16_t reliability_start;   
  uint16_t reliability_max;     
  uint16_t reliability_final;   
  uint16_t duration_phase_1;    
  uint16_t duration_phase_2;    
  uint16_t duration_phase_3;    
  uint8_t flags;                 
 
  CompanyID preview_company;  
  uint8_t preview_wait;          
  uint8_t original_image_index; 
  VehicleType type;           
 
  EngineDisplayFlags display_flags; 
  EngineID display_last_variant;    
  EngineInfo info;
 
  union {
    RailVehicleInfo rail;
    RoadVehicleInfo road;
    ShipVehicleInfo ship;
    AircraftVehicleInfo air;
  } u;
 
  uint16_t list_position;
 
  /* NewGRF related data */
  GRFFilePropsBase<NUM_CARGO + 2> grf_prop;
  std::vector<WagonOverride> overrides;
 
  Engine() {}
  Engine(VehicleType type, EngineID base);
  bool IsEnabled() const;
 
  CargoID 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 && HasBit(this->company_hidden, c);
  }
 
  const Engine *GetDisplayVariant() const
  {
    if (this->display_last_variant == this->index || this->display_last_variant == INVALID_ENGINE) return this;
    return Engine::Get(this->display_last_variant);
  }
 
  bool IsVariantHidden(CompanyID c) const;
 
  inline bool IsGroundVehicle() const
  {
    return this->type == VEH_TRAIN || this->type == VEH_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; }
  };
 
  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; 
  uint16_t internal_id; 
  VehicleType type; 
  uint8_t substitute_id; 
  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 size_t operator()(const EngineIDMapping &eid) const { return eid.Key(); }
};
 
struct EngineOverrideManager {
  std::array<std::vector<EngineIDMapping>, VEH_COMPANY_END> 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)->u.rail;
}
 
inline const RoadVehicleInfo *RoadVehInfo(EngineID e)
{
  return &Engine::Get(e)->u.road;
}
 
inline const ShipVehicleInfo *ShipVehInfo(EngineID e)
{
  return &Engine::Get(e)->u.ship;
}
 
inline const AircraftVehicleInfo *AircraftVehInfo(EngineID e)
{
  return &Engine::Get(e)->u.air;
}
 
#endif /* ENGINE_BASE_H */