1

/* $Id$ */

     2

     3

/** @file vehicle_func.h Functions related to vehicles. */

     4

     5

#ifndef VEHICLE_FUNC_H

     6

#define VEHICLE_FUNC_H

     7

     8

#include "tile_type.h"

     9

#include "strings_type.h"

    10

#include "gfx_type.h"

    11

#include "direction_type.h"

    12

#include "cargo_type.h"

    13

#include "command_type.h"

    14

#include "vehicle_type.h"

    15

#include "engine_type.h"

    16

#include "transport_type.h"

    17

    18

#define is_custom_sprite(x) (x >= 0xFD)

    19

#define IS_CUSTOM_FIRSTHEAD_SPRITE(x) (x == 0xFD)

    20

#define IS_CUSTOM_SECONDHEAD_SPRITE(x) (x == 0xFE)

    21

    22

typedef void *VehicleFromPosProc(Vehicle *v, void *data);

    23

    24

void VehicleServiceInDepot(Vehicle *v);

    25

void VehiclePositionChanged(Vehicle *v);

    26

Vehicle *GetLastVehicleInChain(Vehicle *v);

    27

const Vehicle *GetLastVehicleInChain(const Vehicle *v);

    28

uint CountVehiclesInChain(const Vehicle *v);

    29

bool IsEngineCountable(const Vehicle *v);

    30

void DeleteVehicleChain(Vehicle *v);

    31

void *VehicleFromPos(TileIndex tile, void *data, VehicleFromPosProc *proc);

    32

void *VehicleFromPosXY(int x, int y, void *data, VehicleFromPosProc *proc);

    33

void CallVehicleTicks();

    34

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z);

    35

uint8 CalcPercentVehicleFilled(const Vehicle *v, StringID *color);

    36

    37

void InitializeTrains();

    38

byte VehicleRandomBits();

    39

void ResetVehiclePosHash();

    40

void ResetVehicleColorMap();

    41

    42

bool CanRefitTo(EngineID engine_type, CargoID cid_to);

    43

CargoID FindFirstRefittableCargo(EngineID engine_type);

    44

CommandCost GetRefitCost(EngineID engine_type);

    45

    46

void ViewportAddVehicles(DrawPixelInfo *dpi);

    47

    48

SpriteID GetRotorImage(const Vehicle *v);

    49

    50

uint32 VehicleEnterTile(Vehicle *v, TileIndex tile, int x, int y);

    51

    52

StringID VehicleInTheWayErrMsg(const Vehicle* v);

    53

Vehicle *FindVehicleBetween(TileIndex from, TileIndex to, byte z, bool without_crashed = false);

    54

Vehicle *GetVehicleTunnelBridge(TileIndex tile, TileIndex endtile);

    55

    56

void DecreaseVehicleValue(Vehicle *v);

    57

void CheckVehicleBreakdown(Vehicle *v);

    58

void AgeVehicle(Vehicle *v);

    59

void VehicleEnteredDepotThisTick(Vehicle *v);

    60

    61

void BeginVehicleMove(const Vehicle *v);

    62

void EndVehicleMove(const Vehicle *v);

    63

void MarkSingleVehicleDirty(const Vehicle *v);

    64

    65

UnitID GetFreeUnitNumber(VehicleType type);

    66

    67

void TrainConsistChanged(Vehicle *v);

    68

void TrainPowerChanged(Vehicle *v);

    69

Money GetTrainRunningCost(const Vehicle *v);

    70

    71

/* Old style list kept for migration */

    72

uint GenerateVehicleSortList(const Vehicle*** sort_list, uint16 *length_of_array, VehicleType type, PlayerID owner, uint32 index, uint16 window_type);

    73

void GenerateVehicleSortList(VehicleList *list, VehicleType type, PlayerID owner, uint32 index, uint16 window_type);

    74

void BuildDepotVehicleList(VehicleType type, TileIndex tile, VehicleList *engine_list, VehicleList *wagon_list);

    75

CommandCost SendAllVehiclesToDepot(VehicleType type, uint32 flags, bool service, PlayerID owner, uint16 vlw_flag, uint32 id);

    76

void VehicleEnterDepot(Vehicle *v);

    77

    78

CommandCost MaybeReplaceVehicle(Vehicle *v, uint32 flags, bool display_costs);

    79

bool CanBuildVehicleInfrastructure(VehicleType type);

    80

    81

void CcCloneVehicle(bool success, TileIndex tile, uint32 p1, uint32 p2);

    82

    83

    84

struct GetNewVehiclePosResult {

    85

	int x, y;

    86

	TileIndex old_tile;

    87

	TileIndex new_tile;

    88

};

    89

    90

/* returns true if staying in the same tile */

    91

GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v);

    92

Direction GetDirectionTowards(const Vehicle *v, int x, int y);

    93

    94

static inline bool IsPlayerBuildableVehicleType(VehicleType type)

    95

{

    96

	switch (type) {

    97

		case VEH_TRAIN:

    98

		case VEH_ROAD:

    99

		case VEH_SHIP:

   100

		case VEH_AIRCRAFT:

   101

			return true;

   102

   103

		default: return false;

   104

	}

   105

}

   106

   107

static inline bool IsPlayerBuildableVehicleType(const BaseVehicle *v)

   108

{

   109

	return IsPlayerBuildableVehicleType(v->type);

   110

}

   111

   112

const struct Livery *GetEngineLivery(EngineID engine_type, PlayerID player, EngineID parent_engine_type, const Vehicle *v);

   113

   114

/**

   115

 * Get the colour map for an engine. This used for unbuilt engines in the user interface.

   116

 * @param engine_type ID of engine

   117

 * @param player ID of player

   118

 * @return A ready-to-use palette modifier

   119

 */

   120

SpriteID GetEnginePalette(EngineID engine_type, PlayerID player);

   121

   122

/**

   123

 * Get the colour map for a vehicle.

   124

 * @param v Vehicle to get colour map for

   125

 * @return A ready-to-use palette modifier

   126

 */

   127

SpriteID GetVehiclePalette(const Vehicle *v);

   128

   129

extern const uint32 _veh_build_proc_table[];

   130

extern const uint32 _veh_sell_proc_table[];

   131

extern const uint32 _veh_refit_proc_table[];

   132

extern const uint32 _send_to_depot_proc_table[];

   133

   134

/* Functions to find the right command for certain vehicle type */

   135

static inline uint32 GetCmdBuildVeh(VehicleType type)

   136

{

   137

	return _veh_build_proc_table[type];

   138

}

   139

   140

static inline uint32 GetCmdBuildVeh(const BaseVehicle *v)

   141

{

   142

	return GetCmdBuildVeh(v->type);

   143

}

   144

   145

static inline uint32 GetCmdSellVeh(VehicleType type)

   146

{

   147

	return _veh_sell_proc_table[type];

   148

}

   149

   150

static inline uint32 GetCmdSellVeh(const BaseVehicle *v)

   151

{

   152

	return GetCmdSellVeh(v->type);

   153

}

   154

   155

static inline uint32 GetCmdRefitVeh(VehicleType type)

   156

{

   157

	return _veh_refit_proc_table[type];

   158

}

   159

   160

static inline uint32 GetCmdRefitVeh(const BaseVehicle *v)

   161

{

   162

	return GetCmdRefitVeh(v->type);

   163

}

   164

   165

static inline uint32 GetCmdSendToDepot(VehicleType type)

   166

{

   167

	return _send_to_depot_proc_table[type];

   168

}

   169

   170

static inline uint32 GetCmdSendToDepot(const BaseVehicle *v)

   171

{

   172

	return GetCmdSendToDepot(v->type);

   173

}

   174

   175

bool EnsureNoVehicleOnGround(TileIndex tile);

   176

void StopAllVehicles();

   177

   178

extern VehicleID _vehicle_id_ctr_day;

   179

extern const Vehicle *_place_clicked_vehicle;

   180

extern VehicleID _new_vehicle_id;

   181

extern uint16 _returned_refit_capacity;

   182

   183

#endif /* VEHICLE_FUNC_H */