vehicle_func.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 VEHICLE_FUNC_H
#define VEHICLE_FUNC_H
 
#include "gfx_type.h"
#include "direction_type.h"
#include "timer/timer_game_economy.h"
#include "command_type.h"
#include "vehicle_type.h"
#include "engine_type.h"
#include "transport_type.h"
#include "newgrf_config.h"
#include "track_type.h"
#include "livery.h"

enum CustomVehicleSpriteNum {
  CUSTOM_VEHICLE_SPRITENUM = 0xFD, 
  CUSTOM_VEHICLE_SPRITENUM_REVERSED = 0xFE, 
};
 
static inline bool IsCustomVehicleSpriteNum(uint8_t spritenum)
{
  return spritenum >= CUSTOM_VEHICLE_SPRITENUM;
}
 
static const TimerGameEconomy::Date VEHICLE_PROFIT_MIN_AGE{CalendarTime::DAYS_IN_YEAR * 2}; 
static const Money VEHICLE_PROFIT_THRESHOLD = 10000;        

template <VehicleType T>
bool IsValidImageIndex(uint8_t image_index);

class VehiclesOnTile {
public:
  class Iterator {
  public:
    using value_type = Vehicle *;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
    using pointer = void;
    using reference = void;
 
    explicit Iterator(TileIndex tile);
 
    bool operator==(const Iterator &rhs) const { return this->current == rhs.current; }
    bool operator==(const std::default_sentinel_t &) const { return this->current == nullptr; }
 
    Vehicle *operator*() const { return this->current; }
 
    Iterator &operator++()
    {
      this->Increment();
      this->SkipFalseMatches();
      return *this;
    }
 
    Iterator operator++(int)
    {
      Iterator result = *this;
      ++*this;
      return result;
    }
  private:
    TileIndex tile;
    Vehicle *current;
 
    void Increment();
    void SkipFalseMatches();
  };
 
  explicit VehiclesOnTile(TileIndex tile) : start(tile) {}
  Iterator begin() const { return this->start; }
  std::default_sentinel_t end() const { return std::default_sentinel_t(); }
private:
  Iterator start;
};

template <class UnaryPred>
bool HasVehicleOnTile(TileIndex tile, UnaryPred &&predicate)
{
  for (const auto *v : VehiclesOnTile(tile)) {
    if (predicate(v)) return true;
  }
  return false;
}

class VehiclesNearTileXY {
public:
  class Iterator {
  public:
    using value_type = Vehicle *;
    using difference_type = std::ptrdiff_t;
    using iterator_category = std::forward_iterator_tag;
    using pointer = void;
    using reference = void;
 
    explicit Iterator(int32_t x, int32_t y, uint max_dist);
 
    bool operator==(const Iterator &rhs) const { return this->current_veh == rhs.current_veh; }
    bool operator==(const std::default_sentinel_t &) const { return this->current_veh == nullptr; }
 
    Vehicle *operator*() const { return this->current_veh; }
 
    Iterator &operator++()
    {
      this->Increment();
      this->SkipFalseMatches();
      return *this;
    }
 
    Iterator operator++(int)
    {
      Iterator result = *this;
      ++*this;
      return result;
    }
  private:
    Rect pos_rect;
    uint hxmin, hxmax, hymin, hymax;
    uint hx, hy;
    Vehicle *current_veh;
 
    void Increment();
    void SkipEmptyBuckets();
    void SkipFalseMatches();
  };
 
  explicit VehiclesNearTileXY(int32_t x, int32_t y, uint max_dist) : start(x, y, max_dist) {}
  Iterator begin() const { return this->start; }
  std::default_sentinel_t end() const { return std::default_sentinel_t(); }
private:
  Iterator start;
};

template <class UnaryPred>
bool HasVehicleNearTileXY(int32_t x, int32_t y, uint max_dist, UnaryPred &&predicate)
{
  for (const auto *v : VehiclesNearTileXY(x, y, max_dist)) {
    if (predicate(v)) return true;
  }
  return false;
}
 
void VehicleServiceInDepot(Vehicle *v);
uint CountVehiclesInChain(const Vehicle *v);
void CallVehicleTicks();
uint8_t CalcPercentVehicleFilled(const Vehicle *v, StringID *colour);
 
void VehicleLengthChanged(const Vehicle *u);
 
void ResetVehicleHash();
void ResetVehicleColourMap();
 
uint8_t GetBestFittingSubType(Vehicle *v_from, Vehicle *v_for, CargoType dest_cargo_type);
 
void ViewportAddVehicles(DrawPixelInfo *dpi);
 
void ShowNewGrfVehicleError(EngineID engine, StringID part1, StringID part2, GRFBug bug_type, bool critical);
CommandCost TunnelBridgeIsFree(TileIndex tile, TileIndex endtile, const Vehicle *ignore = nullptr);
 
void DecreaseVehicleValue(Vehicle *v);
void CheckVehicleBreakdown(Vehicle *v);
void EconomyAgeVehicle(Vehicle *v);
void AgeVehicle(Vehicle *v);
void RunVehicleCalendarDayProc();
 
UnitID GetFreeUnitNumber(VehicleType type);
 
void VehicleEnterDepot(Vehicle *v);
 
bool CanBuildVehicleInfrastructure(VehicleType type, uint8_t subtype = 0);

struct GetNewVehiclePosResult {
  int x, y;  
  TileIndex old_tile; 
  TileIndex new_tile; 
};
 
GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v);
Direction GetDirectionTowards(const Vehicle *v, int x, int y);

inline bool IsCompanyBuildableVehicleType(VehicleType type)
{
  return type < VEH_COMPANY_END;
}

inline bool IsCompanyBuildableVehicleType(const BaseVehicle *v)
{
  return IsCompanyBuildableVehicleType(v->type);
}
 
LiveryScheme GetEngineLiveryScheme(EngineID engine_type, EngineID parent_engine_type, const Vehicle *v);
const struct Livery *GetEngineLivery(EngineID engine_type, CompanyID company, EngineID parent_engine_type, const Vehicle *v, uint8_t livery_setting);
 
SpriteID GetEnginePalette(EngineID engine_type, CompanyID company);
SpriteID GetVehiclePalette(const Vehicle *v);
 
extern const StringID _veh_build_msg_table[];
extern const StringID _veh_sell_msg_table[];
extern const StringID _veh_sell_all_msg_table[];
extern const StringID _veh_autoreplace_msg_table[];
extern const StringID _veh_refit_msg_table[];
extern const StringID _send_to_depot_msg_table[];
 
/* Functions to find the right command for certain vehicle type */
inline StringID GetCmdBuildVehMsg(VehicleType type)
{
  return _veh_build_msg_table[type];
}
 
inline StringID GetCmdBuildVehMsg(const BaseVehicle *v)
{
  return GetCmdBuildVehMsg(v->type);
}
 
inline StringID GetCmdSellVehMsg(VehicleType type)
{
  return _veh_sell_msg_table[type];
}
 
inline StringID GetCmdSellVehMsg(const BaseVehicle *v)
{
  return GetCmdSellVehMsg(v->type);
}
 
inline StringID GetCmdSellAllVehMsg(VehicleType type)
{
  return _veh_sell_all_msg_table[type];
}
 
inline StringID GetCmdAutoreplaceVehMsg(VehicleType type)
{
  return _veh_autoreplace_msg_table[type];
}
 
inline StringID GetCmdRefitVehMsg(VehicleType type)
{
  return _veh_refit_msg_table[type];
}
 
inline StringID GetCmdRefitVehMsg(const BaseVehicle *v)
{
  return GetCmdRefitVehMsg(v->type);
}
 
inline StringID GetCmdSendToDepotMsg(VehicleType type)
{
  return _send_to_depot_msg_table[type];
}
 
inline StringID GetCmdSendToDepotMsg(const BaseVehicle *v)
{
  return GetCmdSendToDepotMsg(v->type);
}
 
CommandCost EnsureNoVehicleOnGround(TileIndex tile);
CommandCost EnsureNoTrainOnTrackBits(TileIndex tile, TrackBits track_bits);
 
bool CanVehicleUseStation(EngineID engine_type, const struct Station *st);
bool CanVehicleUseStation(const Vehicle *v, const struct Station *st);
StringID GetVehicleCannotUseStationReason(const Vehicle *v, const Station *st);
 
void ReleaseDisasterVehicle(VehicleID vehicle);
 
typedef std::vector<VehicleID> VehicleSet;
void GetVehicleSet(VehicleSet &set, Vehicle *v, uint8_t num_vehicles);
 
void CheckCargoCapacity(Vehicle *v);
 
bool VehiclesHaveSameEngineList(const Vehicle *v1, const Vehicle *v2);
bool VehiclesHaveSameOrderList(const Vehicle *v1, const Vehicle *v2);
 
bool IsUniqueVehicleName(const std::string &name);
 
#endif /* VEHICLE_FUNC_H */