1

/* $Id$ */

     2

     3

/** @file ai_road.hpp Everything to query and build roads */

     4

     5

#ifndef AI_ROAD_HPP

     6

#define AI_ROAD_HPP

     7

     8

#include "ai_object.hpp"

     9

    10

/**

    11

 * Class that handles all road related functions.

    12

 *

    13

 * Roads are always build from tile center to tile center.

    14

 * Furthermore stations and depots need to be build on tiles

    15

 * that already have road on them. For depots and non-drive

    16

 * through stations that means that only one roadbit may be

    17

 * built at the location. The advantage of this method is

    18

 * that the AI does not need to think about pointing the

    19

 * exit of the depots and roadstations towards the correct

    20

 * direction. For drive-through roadstops this works about

    21

 * the same, though they have to be built on straight roads.

    22

 */

    23

class AIRoad : public AIObject {

    24

public:

    25

	/**

    26

	 * The name of the class, needed by several sub-processes.

    27

	 */

    28

	static const char *GetClassName() { return "AIRoad"; }

    29

    30

	/**

    31

	 * Checks whether the given tile is actually a tile with road that

    32

	 * can be used to traverse a tile. This excludes road depots and

    33

	 * 'normal' road stations, but includes drive through stations.

    34

	 * @param tile the tile to check.

    35

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

    36

	 * @return true if and only if the tile has road.

    37

	 */

    38

	static bool IsRoadTile(TileIndex tile);

    39

    40

	/**

    41

	 * Checks whether the given tile is actually a tile with a road depot.

    42

	 * @param tile the tile to check.

    43

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

    44

	 * @return true if and only if the tile has a road depot.

    45

	 */

    46

	static bool IsRoadDepotTile(TileIndex tile);

    47

    48

	/**

    49

	 * Checks whether the given tile is actually a tile with a road station.

    50

	 * @param tile the tile to check.

    51

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

    52

	 * @return true if and only if the tile has a road station.

    53

	 */

    54

	static bool IsRoadStationTile(TileIndex tile);

    55

    56

	/**

    57

	 * Checks whether the given tile is actually a tile with a drive through

    58

	 * road station.

    59

	 * @param tile the tile to check.

    60

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

    61

	 * @return true if and only if the tile has a drive through road station.

    62

	 */

    63

	static bool IsDriveThroughRoadStationTile(TileIndex tile);

    64

    65

	/**

    66

	 * Checks whether the given tiles are directly connected, i.e. whether

    67

	 * a road vehicle can travel from the center of the first tile to the

    68

	 * center of the second tile.

    69

	 * @param t1 the source tile.

    70

	 * @param t2 the destination tile.

    71

	 * @pre t1 is always positive and smaller than AIMap::GetMapSize().

    72

	 * @pre t2 is always positive and smaller than AIMap::GetMapSize().

    73

	 * @pre t1 and t2 are directly neighbouring tiles.

    74

	 * @return true if and only if a road vehicle can go from t1 to t2.

    75

	 */

    76

	static bool AreRoadTilesConnected(TileIndex t1, TileIndex t2);

    77

    78

	/**

    79

	 * Count how many neighbours are road.

    80

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

    81

	 * @param tile the tile to check on.

    82

	 * @return 0 means no neighbour road; max value is 4.

    83

	 */

    84

	static int32 GetNeighbourRoadCount(TileIndex tile);

    85

    86

	/**

    87

	 * Gets the tile in front of a road depot.

    88

	 * @param depot the road depot tile.

    89

	 * @pre IsRoadDepotTile(depot).

    90

	 * @return the tile in front of the depot.

    91

	 */

    92

	static TileIndex GetRoadDepotFrontTile(TileIndex depot);

    93

    94

	/**

    95

	 * Gets the tile in front of a road station.

    96

	 * @param station the road station tile.

    97

	 * @pre IsRoadStationTile(station).

    98

	 * @return the tile in front of the road station.

    99

	 */

   100

	static TileIndex GetRoadStationFrontTile(TileIndex station);

   101

   102

	/**

   103

	 * Gets the tile at the back of a drive through road station.

   104

	 * So, one side of the drive through station is retrieved with

   105

	 * GetTileInFrontOfStation, the other with this function.

   106

	 * @param station the road station tile.

   107

	 * @pre IsDriveThroughRoadStationTile(station).

   108

	 * @return the tile at the back of the drive through road station.

   109

	 */

   110

	static TileIndex GetDriveThroughBackTile(TileIndex station);

   111

   112

	/**

   113

	 * Builds a road from the center of tile start to the

   114

	 * center of tile end.

   115

	 * @param start the start tile of the road.

   116

	 * @param end   the end tile of the road.

   117

	 * @pre start is not equal to end

   118

	 * @pre start is always positive and smaller than AIMap::GetMapSize().

   119

	 * @pre end is always positive and smaller than AIMap::GetMapSize().

   120

	 * @pre start and end are in a straight line, i.e.

   121

	 *  AIMap::GetTileX(start) == AIMap::GetTileX(end) or

   122

	 *  AIMap::GetTileY(start) == AIMap::GetTileY(end).

   123

	 * @return whether the road has been/can be build or not.

   124

	 */

   125

	static bool BuildRoad(TileIndex start, TileIndex end);

   126

   127

	/**

   128

	 * Builds a road from the edge of tile start to the

   129

	 * edge of tile end (both included).

   130

	 * @param start the start tile of the road.

   131

	 * @param end   the end tile of the road.

   132

	 * @pre start is not equal to end

   133

	 * @pre start is always positive and smaller than AIMap::GetMapSize().

   134

	 * @pre end is always positive and smaller than AIMap::GetMapSize().

   135

	 * @pre start and end are in a straight line, i.e.

   136

	 *  AIMap::GetTileX(start) == AIMap::GetTileX(end) or

   137

	 *  AIMap::GetTileY(start) == AIMap::GetTileY(end).

   138

	 * @return whether the road has been/can be build or not.

   139

	 */

   140

	static bool BuildRoadFull(TileIndex start, TileIndex end);

   141

   142

	/**

   143

	 * Builds a road depot.

   144

	 * @param tile  place to build the depot.

   145

	 * @param front the tile exactly in front of the depot

   146

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

   147

	 * @pre front is always positive and smaller than AIMap::GetMapSize().

   148

	 * @pre tile is not equal to front

   149

	 * @return whether the road depot has been/can be build or not.

   150

	 */

   151

	static bool BuildRoadDepot(TileIndex tile, TileIndex front);

   152

   153

	/**

   154

	 * Builds a road bus or truck station.

   155

	 * @param tile  place to build the depot.

   156

	 * @param front the tile exactly in front of the station.

   157

	 *   For drive-through stations either entrance side can be used.

   158

	 * @param truck whether to build a truck (true) or bus (false) station.

   159

	 * @param drive_through whether to make the station drive through or not.

   160

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

   161

	 * @pre front is always positive and smaller than AIMap::GetMapSize().

   162

	 * @pre tile is not equal to front

   163

	 * @return whether the station has been/can be build or not.

   164

	 */

   165

	static bool BuildRoadStation(TileIndex tile, TileIndex front, bool truck, bool drive_through);

   166

   167

	/**

   168

	 * Removes a road from the center of tile start to the

   169

	 * center of tile end.

   170

	 * @param start the start tile of the road.

   171

	 * @param end   the end tile of the road.

   172

	 * @pre start is always positive and smaller than AIMap::GetMapSize().

   173

	 * @pre end is always positive and smaller than AIMap::GetMapSize().

   174

	 * @pre start and end are in a straight line, i.e.

   175

	 *  AIMap::GetTileX(start) == AIMap::GetTileX(end) or

   176

	 *  AIMap::GetTileY(start) == AIMap::GetTileY(end).

   177

	 * @return whether the road has been/can be removed or not.

   178

	 */

   179

	static bool RemoveRoad(TileIndex start, TileIndex end);

   180

   181

	/**

   182

	 * Removes a road from the edge of tile start to the

   183

	 * edge of tile end (both included).

   184

	 * @param start the start tile of the road.

   185

	 * @param end   the end tile of the road.

   186

	 * @pre start is always positive and smaller than AIMap::GetMapSize().

   187

	 * @pre end is always positive and smaller than AIMap::GetMapSize().

   188

	 * @pre start and end are in a straight line, i.e.

   189

	 *  AIMap::GetTileX(start) == AIMap::GetTileX(end) or

   190

	 *  AIMap::GetTileY(start) == AIMap::GetTileY(end).

   191

	 * @return whether the road has been/can be removed or not.

   192

	 */

   193

	static bool RemoveRoadFull(TileIndex start, TileIndex end);

   194

   195

	/**

   196

	 * Removes a road depot.

   197

	 * @param tile place to remove the depot from.

   198

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

   199

	 * @pre tile is a road depot.

   200

	 * @return whether the road depot has been/can be removed or not.

   201

	 */

   202

	static bool RemoveRoadDepot(TileIndex tile);

   203

   204

	/**

   205

	 * Removes a road bus or truck station.

   206

	 * @param tile place to remove the station from.

   207

	 * @pre tile is always positive and smaller than AIMap::GetMapSize().

   208

	 * @pre tile is a road station.

   209

	 * @return whether the station has been/can be removed or not.

   210

	 */

   211

	static bool RemoveRoadStation(TileIndex tile);

   212

};

   213

   214

#endif /* AI_ROAD_HPP */