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

#include "ai_error.hpp"

    10

    11

/**

    12

 * Class that handles all road related functions.

    13

 */

    14

class AIRoad : public AIObject {

    15

public:

    16

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

    17

    18

	enum ErrorMessages {

    19

		/** Base for road building / maintaining errors */

    20

		ERR_ROAD_BASE = AIError::ERR_CAT_ROAD << AIError::ERR_CAT_BIT_SIZE,

    21

    22

		/** Road works are in progress */

    23

		ERR_ROAD_WORKS_IN_PROGRESS,                   // [STR_ROAD_WORKS_IN_PROGRESS]

    24

    25

		/** Drive through is in the wrong direction */

    26

		ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION,       // [STR_DRIVE_THROUGH_ERROR_DIRECTION]

    27

    28

		/** Drive through roads can't be build on town owned roads */

    29

		ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD,           // [STR_DRIVE_THROUGH_ERROR_ON_TOWN_ROAD]

    30

    31

    32

		/** One way roads can't have junctions */

    33

		ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS, // [STR_ERR_ONEWAY_ROADS_CAN_T_HAVE_JUNCTION]

    34

	};

    35

    36

	/**

    37

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

    38

	 *  used to traverse a tile. This excludes road depots and 'normal' road

    39

	 *  stations, but includes drive through stations.

    40

	 * @param tile The tile to check.

    41

	 * @pre AIMap::IsValidTile(tile).

    42

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

    43

	 */

    44

	static bool IsRoadTile(TileIndex tile);

    45

    46

	/**

    47

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

    48

	 * @param tile The tile to check.

    49

	 * @pre AIMap::IsValidTile(tile).

    50

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

    51

	 */

    52

	static bool IsRoadDepotTile(TileIndex tile);

    53

    54

	/**

    55

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

    56

	 * @param tile The tile to check.

    57

	 * @pre AIMap::IsValidTile(tile).

    58

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

    59

	 */

    60

	static bool IsRoadStationTile(TileIndex tile);

    61

    62

	/**

    63

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

    64

	 *  road station.

    65

	 * @param tile The tile to check.

    66

	 * @pre AIMap::IsValidTile(tile).

    67

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

    68

	 */

    69

	static bool IsDriveThroughRoadStationTile(TileIndex tile);

    70

    71

	/**

    72

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

    73

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

    74

	  * center of the second tile.

    75

	 * @param tile_from The source tile.

    76

	 * @param tile_to The destination tile.

    77

	 * @pre AIMap::IsValidTile(tile_from).

    78

	 * @pre AIMap::IsValidTile(tile_to).

    79

	 * @pre 'tile_from' and 'tile_to' are directly neighbouring tiles.

    80

	 * @return True if and only if a road vehicle can go from tile_from to tile_to.

    81

	 */

    82

	static bool AreRoadTilesConnected(TileIndex tile_from, TileIndex tile_to);

    83

    84

	/**

    85

	 * Count how many neighbours are road.

    86

	 * @param tile The tile to check on.

    87

	 * @pre AIMap::IsValidTile(tile).

    88

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

    89

	 */

    90

	static int32 GetNeighbourRoadCount(TileIndex tile);

    91

    92

	/**

    93

	 * Gets the tile in front of a road depot.

    94

	 * @param depot The road depot tile.

    95

	 * @pre IsRoadDepotTile(depot).

    96

	 * @return The tile in front of the depot.

    97

	 */

    98

	static TileIndex GetRoadDepotFrontTile(TileIndex depot);

    99

   100

	/**

   101

	 * Gets the tile in front of a road station.

   102

	 * @param station The road station tile.

   103

	 * @pre IsRoadStationTile(station).

   104

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

   105

	 */

   106

	static TileIndex GetRoadStationFrontTile(TileIndex station);

   107

   108

	/**

   109

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

   110

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

   111

	 *  GetTileInFrontOfStation, the other with this function.

   112

	 * @param station The road station tile.

   113

	 * @pre IsDriveThroughRoadStationTile(station).

   114

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

   115

	 */

   116

	static TileIndex GetDriveThroughBackTile(TileIndex station);

   117

   118

	/**

   119

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

   120

	 * @param start The start tile of the road.

   121

	 * @param end The end tile of the road.

   122

	 * @pre 'start' is not equal to 'end'.

   123

	 * @pre AIMap::IsValidTile(start).

   124

	 * @pre AIMap::IsValidTile(end).

   125

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

   126

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

   127

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

   128

	 * @exception AIError::ERR_ALREADY_BUILT

   129

	 * @exception AIError::ERR_LAND_SLOPED_WRONG

   130

	 * @exception AIError::ERR_AREA_NOT_CLEAR

   131

	 * @exception AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS

   132

	 * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS

   134

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

   135

	 */

   136

	static bool BuildRoad(TileIndex start, TileIndex end);

   137

   138

	/**

   139

	 * Builds a road from the edge of tile start to the edge of tile end (both

   140

	 *  included).

   141

	 * @param start The start tile of the road.

   142

	 * @param end The end tile of the road.

   143

	 * @pre 'start' is not equal to 'end'.

   144

	 * @pre AIMap::IsValidTile(start).

   145

	 * @pre AIMap::IsValidTile(end).

   146

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

   147

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

   148

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

   149

	 * @exception AIError::ERR_ALREADY_BUILT

   150

	 * @exception AIError::ERR_LAND_SLOPED_WRONG

   151

	 * @exception AIError::ERR_AREA_NOT_CLEAR

   152

	 * @exception AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS

   153

	 * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS

   155

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

   156

	 */

   157

	static bool BuildRoadFull(TileIndex start, TileIndex end);

   158

   159

	/**

   160

	 * Builds a road depot.

   161

	 * @param tile Place to build the depot.

   162

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

   163

	 * @pre AIMap::IsValidTile(tile).

   164

	 * @pre AIMap::IsValidTile(front).

   165

	 * @pre Tile is not equal to front.

   166

	 * @exception AIError::ERR_FLAT_LAND_REQUIRED

   167

	 * @exception AIError::ERR_AREA_NOT_CLEAR

   168

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

   169

	 */

   170

	static bool BuildRoadDepot(TileIndex tile, TileIndex front);

   171

   172

	/**

   173

	 * Builds a road bus or truck station.

   174

	 * @param tile Place to build the depot.

   175

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

   176

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

   177

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

   178

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

   179

	 * @pre AIMap::IsValidTile(tile).

   180

	 * @pre AIMap::IsValidTile(front).

   181

	 * @pre 'tile' is not equal to 'front'.

   182

	 * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY

   183

	 * @exception AIError::ERR_AREA_NOT_CLEAR

   184

	 * @exception AIError::ERR_FLAT_LAND_REQUIRED

   185

	 * @exception AIRoad::ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION

   186

	 * @exception AIRoad::ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD

   191

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

   192

	 */

   193

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

   194

   195

	/**

   196

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

   197

	 * @param start The start tile of the road.

   198

	 * @param end The end tile of the road.

   199

	 * @pre AIMap::IsValidTile(start).

   200

	 * @pre AIMap::IsValidTile(end).

   201

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

   202

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

   203

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

   204

	 * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY

   206

	 * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS

   207

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

   208

	 */

   209

	static bool RemoveRoad(TileIndex start, TileIndex end);

   210

   211

	/**

   212

	 * Removes a road from the edge of tile start to the edge of tile end (both

   213

	 *  included).

   214

	 * @param start The start tile of the road.

   215

	 * @param end The end tile of the road.

   216

	 * @pre AIMap::IsValidTile(start).

   217

	 * @pre AIMap::IsValidTile(end).

   218

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

   219

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

   220

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

   221

	 * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY

   223

	 * @exception AIRoad::ERR_ROAD_WORKS_IN_PROGRESS

   224

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

   225

	 */

   226

	static bool RemoveRoadFull(TileIndex start, TileIndex end);

   227

   228

	/**

   229

	 * Removes a road depot.

   230

	 * @param tile Place to remove the depot from.

   231

	 * @pre AIMap::IsValidTile(tile).

   232

	 * @pre Tile is a road depot.

   233

	 * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY

   235

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

   236

	 */

   237

	static bool RemoveRoadDepot(TileIndex tile);

   238

   239

	/**

   240

	 * Removes a road bus or truck station.

   241

	 * @param tile Place to remove the station from.

   242

	 * @pre AIMap::IsValidTile(tile).

   243

	 * @pre Tile is a road station.

   244

	 * @exception AIError::ERR_OWNED_BY_ANOTHER_COMPANY

   246

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

   247

	 */

   248

	static bool RemoveRoadStation(TileIndex tile);

   249

};

   250

   251

#endif /* AI_ROAD_HPP */