1

/* $Id$ */

     2

     3

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

    17

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

    18

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

    19

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

    20

    21

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

    22

    23

void VehicleServiceInDepot(Vehicle *v);

    24

void VehiclePositionChanged(Vehicle *v);

    25

Vehicle *GetLastVehicleInChain(Vehicle *v);

    26

uint CountVehiclesInChain(const Vehicle *v);

    27

bool IsEngineCountable(const Vehicle *v);

    28

void DeleteVehicleChain(Vehicle *v);

    29

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

    30

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

    31

void CallVehicleTicks();

    32

Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z);

    33

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

    34

    35

void InitializeTrains();

    36

byte VehicleRandomBits();

    37

void ResetVehiclePosHash();

    38

void ResetVehicleColorMap();

    39

    40

bool CanRefitTo(EngineID engine_type, CargoID cid_to);

    41

CargoID FindFirstRefittableCargo(EngineID engine_type);

    42

CommandCost GetRefitCost(EngineID engine_type);

    43

    44

void ViewportAddVehicles(DrawPixelInfo *dpi);

    45

    46

SpriteID GetRotorImage(const Vehicle *v);

    47

    48

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

    49

    50

StringID VehicleInTheWayErrMsg(const Vehicle* v);

    51

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

    52

Vehicle *GetVehicleTunnelBridge(TileIndex tile, TileIndex endtile);

    53

    54

void DecreaseVehicleValue(Vehicle *v);

    55

void CheckVehicleBreakdown(Vehicle *v);

    56

void AgeVehicle(Vehicle *v);

    57

void VehicleEnteredDepotThisTick(Vehicle *v);

    58

    59

void BeginVehicleMove(const Vehicle *v);

    60

void EndVehicleMove(const Vehicle *v);

    61

void MarkSingleVehicleDirty(const Vehicle *v);

    62

    63

UnitID GetFreeUnitNumber(VehicleType type);

    64

    65

void TrainConsistChanged(Vehicle *v);

    66

void TrainPowerChanged(Vehicle *v);

    67

Money GetTrainRunningCost(const Vehicle *v);

    68

    69

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

    70

void BuildDepotVehicleList(VehicleType type, TileIndex tile, Vehicle ***engine_list, uint16 *engine_list_length, uint16 *engine_count, Vehicle ***wagon_list, uint16 *wagon_list_length, uint16 *wagon_count);

    71

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

    72

void VehicleEnterDepot(Vehicle *v);

    73

    74

CommandCost MaybeReplaceVehicle(Vehicle *v, bool check, bool display_costs);

    75

bool CanBuildVehicleInfrastructure(VehicleType type);

    76

    77

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

    78

    79

    80

struct GetNewVehiclePosResult {

    81

	int x, y;

    82

	TileIndex old_tile;

    83

	TileIndex new_tile;

    84

};

    85

    86

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

    87

GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v);

    88

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

    89

    90

static inline bool IsPlayerBuildableVehicleType(VehicleType type)

    91

{

    92

	switch (type) {

    93

		case VEH_TRAIN:

    94

		case VEH_ROAD:

    95

		case VEH_SHIP:

    96

		case VEH_AIRCRAFT:

    97

			return true;

    98

    99

		default: return false;

   100

	}

   101

}

   102

   103

static inline bool IsPlayerBuildableVehicleType(const BaseVehicle *v)

   104

{

   105

	return IsPlayerBuildableVehicleType(v->type);

   106

}

   107

   108

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

   109

   110

/**

   111

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

   112

 * @param engine_type ID of engine

   113

 * @param player ID of player

   114

 * @return A ready-to-use palette modifier

   115

 */

   116

SpriteID GetEnginePalette(EngineID engine_type, PlayerID player);

   117

   118

/**

   119

 * Get the colour map for a vehicle.

   120

 * @param v Vehicle to get colour map for

   121

 * @return A ready-to-use palette modifier

   122

 */

   123

SpriteID GetVehiclePalette(const Vehicle *v);

   124

   125

extern const uint32 _veh_build_proc_table[];

   126

extern const uint32 _veh_sell_proc_table[];

   127

extern const uint32 _veh_refit_proc_table[];

   128

extern const uint32 _send_to_depot_proc_table[];

   129

   130

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

   131

static inline uint32 GetCmdBuildVeh(VehicleType type)

   132

{

   133

	return _veh_build_proc_table[type];

   134

}

   135

   136

static inline uint32 GetCmdBuildVeh(const BaseVehicle *v)

   137

{

   138

	return GetCmdBuildVeh(v->type);

   139

}

   140

   141

static inline uint32 GetCmdSellVeh(VehicleType type)

   142

{

   143

	return _veh_sell_proc_table[type];

   144

}

   145

   146

static inline uint32 GetCmdSellVeh(const BaseVehicle *v)

   147

{

   148

	return GetCmdSellVeh(v->type);

   149

}

   150

   151

static inline uint32 GetCmdRefitVeh(VehicleType type)

   152

{

   153

	return _veh_refit_proc_table[type];

   154

}

   155

   156

static inline uint32 GetCmdRefitVeh(const BaseVehicle *v)

   157

{

   158

	return GetCmdRefitVeh(v->type);

   159

}

   160

   161

static inline uint32 GetCmdSendToDepot(VehicleType type)

   162

{

   163

	return _send_to_depot_proc_table[type];

   164

}

   165

   166

static inline uint32 GetCmdSendToDepot(const BaseVehicle *v)

   167

{

   168

	return GetCmdSendToDepot(v->type);

   169

}

   170

   171

bool EnsureNoVehicleOnGround(TileIndex tile);

   172

void StopAllVehicles();

   173

   174

Vehicle *CreateEffectVehicle(int x, int y, int z, EffectVehicle type);

   175

Vehicle *CreateEffectVehicleAbove(int x, int y, int z, EffectVehicle type);

   176

Vehicle *CreateEffectVehicleRel(const Vehicle *v, int x, int y, int z, EffectVehicle type);

   177

   178

extern VehicleID _vehicle_id_ctr_day;

   179

extern Vehicle *_place_clicked_vehicle;

   180

extern VehicleID _new_vehicle_id;

   181

extern uint16 _returned_refit_capacity;

   182

   183

#endif /* VEHICLE_H */