1

/* $Id$ */

     2

     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

	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

	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

	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

	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

	bool AreRoadTilesConnected(TileIndex t1, TileIndex t2);

    77

    78

	/**

    79

	 * Gets the tile in front of a road depot.

    80

	 * @param depot the road depot tile.

    81

	 * @pre IsRoadDepotTile(depot).

    82

	 * @return the tile in front of the depot.

    83

	 */

    84

	TileIndex GetRoadDepotFrontTile(TileIndex depot);

    85

    86

	/**

    87

	 * Gets the tile in front of a road station.

    88

	 * @param station the road station tile.

    89

	 * @pre IsRoadStationTile(station).

    90

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

    91

	 */

    92

	TileIndex GetRoadStationFrontTile(TileIndex station);

    93

    94

	/**

    95

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

    96

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

    97

	 * GetTileInFrontOfStation, the other with this function.

    98

	 * @param station the road station tile.

    99

	 * @pre IsDriveThroughRoadStationTile(station).

   100

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

   101

	 */

   102

	TileIndex GetDriveThroughBackTile(TileIndex station);

   103

   104

	/**

   105

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

   106

	 * center of tile end.

   107

	 * @param start the start tile of the road.

   108

	 * @param end   the end tile of the road.

   109

	 * @pre start is not equal to end

   110

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

   111

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

   112

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

   113

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

   114

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

   115

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

   116

	 */

   117

	bool BuildRoad(TileIndex start, TileIndex end);

   118

   119

	/**

   120

	 * Builds a road depot.

   121

	 * @param tile  place to build the depot.

   122

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

   123

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

   124

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

   125

	 * @pre tile is not equal to front

   126

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

   127

	 */

   128

	bool BuildRoadDepot(TileIndex tile, TileIndex front);

   129

   130

	/**

   131

	 * Builds a road bus or truck station.

   132

	 * @param tile  place to build the depot.

   133

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

   134

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

   135

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

   136

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

   137

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

   138

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

   139

	 * @pre tile is not equal to front

   140

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

   141

	 */

   142

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

   143

   144

	/**

   145

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

   146

	 * center of tile end.

   147

	 * @param start the start tile of the road.

   148

	 * @param end   the end tile of the road.

   149

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

   150

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

   151

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

   152

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

   153

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

   154

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

   155

	 */

   156

	bool RemoveRoad(TileIndex start, TileIndex end);

   157

   158

	/**

   159

	 * Removes a road depot.

   160

	 * @param tile place to remove the depot from.

   161

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

   162

	 * @pre tile is a road depot.

   163

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

   164

	 */

   165

	bool RemoveRoadDepot(TileIndex tile);

   166

   167

	/**

   168

	 * Removes a road bus or truck station.

   169

	 * @param tile place to remove the station from.

   170

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

   171

	 * @pre tile is a road station.

   172

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

   173

	 */

   174

	bool RemoveRoadStation(TileIndex tile);

   175

};

   176

   177

#ifdef DEFINE_SQUIRREL_CLASS

   178

namespace SQConvert {

   179

	/* Allow AIRoad to be used as Squirrel parameter */

   180

	template <> AIRoad *GetParam(ForceType<AIRoad *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIRoad *)instance; }

   181

	template <> AIRoad &GetParam(ForceType<AIRoad &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRoad *)instance; }

   182

	template <> const AIRoad *GetParam(ForceType<const AIRoad *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIRoad *)instance; }

   183

	template <> const AIRoad &GetParam(ForceType<const AIRoad &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIRoad *)instance; }

   184

}; // namespace SQConvert

   185

   186

void SQAIRoadRegister(Squirrel *engine) {

   187

	DefSQClass <AIRoad> SQAIRoad("AIRoad");

   188

	SQAIRoad.PreRegister(engine);

   189

	SQAIRoad.AddConstructor(engine);

   190

   191

	SQAIRoad.DefSQStaticMethod(engine, &AIRoad::GetClassName, "GetClassName", 1, "x");

   192

   193

	SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadTile,                    "IsRoadTile",                    2, "xi");

   194

	SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadDepotTile,               "IsRoadDepotTile",               2, "xi");

   195

	SQAIRoad.DefSQMethod(engine, &AIRoad::IsRoadStationTile,             "IsRoadStationTile",             2, "xi");

   196

	SQAIRoad.DefSQMethod(engine, &AIRoad::IsDriveThroughRoadStationTile, "IsDriveThroughRoadStationTile", 2, "xi");

   197

	SQAIRoad.DefSQMethod(engine, &AIRoad::AreRoadTilesConnected,         "AreRoadTilesConnected",         3, "xii");

   198

	SQAIRoad.DefSQMethod(engine, &AIRoad::GetRoadDepotFrontTile,         "GetRoadDepotFrontTile",         2, "xi");

   199

	SQAIRoad.DefSQMethod(engine, &AIRoad::GetRoadStationFrontTile,       "GetRoadStationFrontTile",       2, "xi");

   200

	SQAIRoad.DefSQMethod(engine, &AIRoad::GetDriveThroughBackTile,       "GetDriveThroughBackTile",       2, "xi");

   201

	SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoad,                     "BuildRoad",                     3, "xii");

   202

	SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoadDepot,                "BuildRoadDepot",                3, "xii");

   203

	SQAIRoad.DefSQMethod(engine, &AIRoad::BuildRoadStation,              "BuildRoadStation",              5, "xiibb");

   204

	SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoad,                    "RemoveRoad",                    3, "xii");

   205

	SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoadDepot,               "RemoveRoadDepot",               2, "xi");

   206

	SQAIRoad.DefSQMethod(engine, &AIRoad::RemoveRoadStation,             "RemoveRoadStation",             2, "xi");

   207

   208

	SQAIRoad.PostRegister(engine);

   209

}

   210

#endif /* DEFINE_SQUIRREL_CLASS */

   211

   212

#endif /* AI_ROAD_HPP */