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 

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

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

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

    19 

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

    21 

    22 void VehicleServiceInDepot(Vehicle *v);

    23 void VehiclePositionChanged(Vehicle *v);

    24 Vehicle *GetLastVehicleInChain(Vehicle *v);

    25 uint CountVehiclesInChain(const Vehicle *v);

    26 bool IsEngineCountable(const Vehicle *v);

    27 void DeleteVehicleChain(Vehicle *v);

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

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

    30 void CallVehicleTicks();

    31 Vehicle *FindVehicleOnTileZ(TileIndex tile, byte z);

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

    33 

    34 void InitializeTrains();

    35 byte VehicleRandomBits();

    36 void ResetVehiclePosHash();

    37 void ResetVehicleColorMap();

    38 

    39 bool CanRefitTo(EngineID engine_type, CargoID cid_to);

    40 CargoID FindFirstRefittableCargo(EngineID engine_type);

    41 CommandCost GetRefitCost(EngineID engine_type);

    42 

    43 void ViewportAddVehicles(DrawPixelInfo *dpi);

    44 

    45 SpriteID GetRotorImage(const Vehicle *v);

    46 

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

    48 

    49 StringID VehicleInTheWayErrMsg(const Vehicle* v);

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

    51 Vehicle *GetVehicleTunnelBridge(TileIndex tile, TileIndex endtile);

    52 

    53 bool UpdateSignalsOnSegment(TileIndex tile, DiagDirection direction);

    54 void SetSignalsOnBothDir(TileIndex tile, byte track);

    55 

    56 Vehicle *CheckClickOnVehicle(const ViewPort *vp, int x, int y);

    57 

    58 void DecreaseVehicleValue(Vehicle *v);

    59 void CheckVehicleBreakdown(Vehicle *v);

    60 void AgeVehicle(Vehicle *v);

    61 void VehicleEnteredDepotThisTick(Vehicle *v);

    62 

    63 void BeginVehicleMove(Vehicle *v);

    64 void EndVehicleMove(Vehicle *v);

    65 

    66 UnitID GetFreeUnitNumber(VehicleType type);

    67 

    68 void TrainConsistChanged(Vehicle *v);

    69 void TrainPowerChanged(Vehicle *v);

    70 Money GetTrainRunningCost(const Vehicle *v);

    71 

    72 bool VehicleNeedsService(const Vehicle *v);

    73 

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

    75 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);

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

    77 void VehicleEnterDepot(Vehicle *v);

    78 

    79 void InvalidateAutoreplaceWindow(EngineID e, GroupID id_g);

    80 

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

    82 bool CanBuildVehicleInfrastructure(VehicleType type);

    83 

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

    85 

    86 /* Flags to add to p2 for goto depot commands */

    87 /* Note: bits 8-10 are used for VLW flags */

    88 enum {

    89 	DEPOT_SERVICE       = (1 << 0), // The vehicle will leave the depot right after arrival (serivce only)

    90 	DEPOT_MASS_SEND     = (1 << 1), // Tells that it's a mass send to depot command (type in VLW flag)

    91 	DEPOT_DONT_CANCEL   = (1 << 2), // Don't cancel current goto depot command if any

    92 	DEPOT_LOCATE_HANGAR = (1 << 3), // Find another airport if the target one lacks a hangar

    93 };

    94 

    95 struct GetNewVehiclePosResult {

    96 	int x, y;

    97 	TileIndex old_tile;

    98 	TileIndex new_tile;

    99 };

   100 

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

   102 GetNewVehiclePosResult GetNewVehiclePos(const Vehicle *v);

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

   104 

   105 static inline bool IsPlayerBuildableVehicleType(VehicleType type)

   106 {

   107 	switch (type) {

   108 		case VEH_TRAIN:

   109 		case VEH_ROAD:

   110 		case VEH_SHIP:

   111 		case VEH_AIRCRAFT:

   112 			return true;

   113 

   114 		default: return false;

   115 	}

   116 }

   117 

   118 static inline bool IsPlayerBuildableVehicleType(const BaseVehicle *v)

   119 {

   120 	return IsPlayerBuildableVehicleType(v->type);

   121 }

   122 

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

   124 

   125 /**

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

   127  * @param engine_type ID of engine

   128  * @param player ID of player

   129  * @return A ready-to-use palette modifier

   130  */

   131 SpriteID GetEnginePalette(EngineID engine_type, PlayerID player);

   132 

   133 /**

   134  * Get the colour map for a vehicle.

   135  * @param v Vehicle to get colour map for

   136  * @return A ready-to-use palette modifier

   137  */

   138 SpriteID GetVehiclePalette(const Vehicle *v);

   139 

   140 /* A lot of code calls for the invalidation of the status bar, which is widget 5.

   141  * Best is to have a virtual value for it when it needs to change again */

   142 #define STATUS_BAR 5

   143 

   144 extern const uint32 _veh_build_proc_table[];

   145 extern const uint32 _veh_sell_proc_table[];

   146 extern const uint32 _veh_refit_proc_table[];

   147 extern const uint32 _send_to_depot_proc_table[];

   148 

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

   150 static inline uint32 GetCmdBuildVeh(VehicleType type)

   151 {

   152 	return _veh_build_proc_table[type];

   153 }

   154 

   155 static inline uint32 GetCmdBuildVeh(const BaseVehicle *v)

   156 {

   157 	return GetCmdBuildVeh(v->type);

   158 }

   159 

   160 static inline uint32 GetCmdSellVeh(VehicleType type)

   161 {

   162 	return _veh_sell_proc_table[type];

   163 }

   164 

   165 static inline uint32 GetCmdSellVeh(const BaseVehicle *v)

   166 {

   167 	return GetCmdSellVeh(v->type);

   168 }

   169 

   170 static inline uint32 GetCmdRefitVeh(VehicleType type)

   171 {

   172 	return _veh_refit_proc_table[type];

   173 }

   174 

   175 static inline uint32 GetCmdRefitVeh(const BaseVehicle *v)

   176 {

   177 	return GetCmdRefitVeh(v->type);

   178 }

   179 

   180 static inline uint32 GetCmdSendToDepot(VehicleType type)

   181 {

   182 	return _send_to_depot_proc_table[type];

   183 }

   184 

   185 static inline uint32 GetCmdSendToDepot(const BaseVehicle *v)

   186 {

   187 	return GetCmdSendToDepot(v->type);

   188 }

   189 

   190 bool EnsureNoVehicleOnGround(TileIndex tile);

   191 void StopAllVehicles();

   192 

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

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

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

   196 

   197 extern VehicleID _vehicle_id_ctr_day;

   198 extern Vehicle *_place_clicked_vehicle;

   199 extern VehicleID _new_vehicle_id;

   200 extern uint16 _returned_refit_capacity;

   201 

   202 #endif /* VEHICLE_H */