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> {
  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;                 
  CompanyMask preview_asked;  
  CompanyID preview_company;  
  uint8_t preview_wait;          
  CompanyMask company_avail;  
  CompanyMask company_hidden; 
  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;
 
  /* NewGRF related data */
  GRFFilePropsBase<NUM_CARGO + 2> grf_prop;
  std::vector<WagonOverride> overrides;
  uint16_t list_position;
 
  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;  
};
 
struct EngineOverrideManager : std::vector<EngineIDMapping> {
  static const uint NUM_DEFAULT_ENGINES; 
 
  void ResetToDefaultMapping();
  EngineID GetID(VehicleType type, uint16_t grf_local_id, uint32_t grfid);
 
  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 */