1

/* $Id$ */

     2

     3

/** @file ai_road.cpp handles the functions of the AIRoad class */

     4

     5

#include "ai_road.hpp"

     6

#include "../../road_map.h"

     7

#include "../../station_map.h"

     8

     9

/* static */ bool AIRoad::IsRoadTile(TileIndex tile)

    10

{

    11

	/* Outside of the map */

    12

	if (tile >= ::MapSize()) return false;

    13

    14

	return (::IsTileType(tile, MP_ROAD) && ::GetRoadTileType(tile) != ROAD_TILE_DEPOT) ||

    15

			IsDriveThroughRoadStationTile(tile);

    16

}

    17

    18

/* static */ bool AIRoad::IsRoadDepotTile(TileIndex tile)

    19

{

    20

	/* Outside of the map */

    21

	if (tile >= ::MapSize()) return false;

    22

    23

	return ::IsTileType(tile, MP_ROAD) && ::GetRoadTileType(tile) == ROAD_TILE_DEPOT;

    24

}

    25

    26

/* static */ bool AIRoad::IsRoadStationTile(TileIndex tile)

    27

{

    28

	/* Outside of the map */

    29

	if (tile >= ::MapSize()) return false;

    30

    31

	return ::IsRoadStopTile(tile);

    32

}

    33

    34

/* static */ bool AIRoad::IsDriveThroughRoadStationTile(TileIndex tile)

    35

{

    36

	/* Outside of the map */

    37

	if (tile >= ::MapSize()) return false;

    38

    39

	return ::IsDriveThroughStopTile(tile);

    40

}

    41

    42

/* static */ bool AIRoad::AreRoadTilesConnected(TileIndex t1, TileIndex t2)

    43

{

    44

	/* Outside of the map */

    45

	if (t1 >= ::MapSize() || t2 >= ::MapSize()) return false;

    46

    47

	/* Tiles not neighbouring */

    48

	if ((abs((int)::TileX(t1) - (int)::TileX(t2)) + abs((int)::TileY(t1) - (int)::TileY(t2))) != 1) return false;

    49

    50

	RoadBits r1 = ::GetAnyRoadBits(t1, ROADTYPE_ROAD);

    51

	RoadBits r2 = ::GetAnyRoadBits(t2, ROADTYPE_ROAD);

    52

    53

	DiagDirection dir_1 = (DiagDirection)((::TileX(t1) == ::TileX(t2)) ? (::TileY(t1) < ::TileY(t2) ? 2 : 0) : (::TileX(t1) < ::TileX(t2) ? 1 : 3));

    54

	DiagDirection dir_2 = ::ReverseDiagDir(dir_1);

    55

    56

	return HasBit(r1, dir_1) && HasBit(r2, dir_2);

    57

}

    58

    59

/* static */ int32 AIRoad::GetNeighbourRoadCount(TileIndex tile)

    60

{

    61

	/* Outside of the map */

    62

	if (tile >= ::MapSize()) return false;

    63

    64

	int32 neighbour = 0;

    65

    66

	if (::IsTileType(tile + ::TileDiffXY(-1, 0), MP_ROAD) && ::GetRoadTileType(tile + ::TileDiffXY(-1, 0)) != ROAD_TILE_DEPOT) neighbour++;

    67

	if (::IsTileType(tile + ::TileDiffXY( 1, 0), MP_ROAD) && ::GetRoadTileType(tile + ::TileDiffXY( 1, 0)) != ROAD_TILE_DEPOT) neighbour++;

    68

	if (::IsTileType(tile + ::TileDiffXY( 0,-1), MP_ROAD) && ::GetRoadTileType(tile + ::TileDiffXY( 0,-1)) != ROAD_TILE_DEPOT) neighbour++;

    69

	if (::IsTileType(tile + ::TileDiffXY( 0, 1), MP_ROAD) && ::GetRoadTileType(tile + ::TileDiffXY( 0, 1)) != ROAD_TILE_DEPOT) neighbour++;

    70

    71

	return neighbour;

    72

}

    73

    74

/* static */ TileIndex AIRoad::GetRoadDepotFrontTile(TileIndex depot)

    75

{

    76

	if (!IsRoadDepotTile(depot)) return INVALID_TILE;

    77

    78

	return depot + ::TileOffsByDiagDir(::GetRoadDepotDirection(depot));

    79

}

    80

    81

/* static */ TileIndex AIRoad::GetRoadStationFrontTile(TileIndex station)

    82

{

    83

	if (!IsRoadStationTile(station)) return INVALID_TILE;

    84

    85

	return station + ::TileOffsByDiagDir(::GetRoadStopDir(station));

    86

}

    87

    88

/* static */ TileIndex AIRoad::GetDriveThroughBackTile(TileIndex station)

    89

{

    90

	if (!IsDriveThroughRoadStationTile(station)) return INVALID_TILE;

    91

    92

	return station + ::TileOffsByDiagDir(::ReverseDiagDir(::GetRoadStopDir(station)));

    93

}

    94

    95

/* static */ bool AIRoad::BuildRoad(TileIndex start, TileIndex end)

    96

{

    97

	/* Outside of the map */

    98

	if (start >= ::MapSize() || end >= ::MapSize() || start == end) return false;

    99

	/* Not on one line */

   100

	if (TileX(start) != TileX(end) &&

   101

			TileY(start) != TileY(end)) return false;

   102

   103

	return AIObject::DoCommand(end, start, (TileY(start) != TileY(end) ? 4 : 0) | (start < end ? 1 : 2) | (ROADTYPE_ROAD << 3), CMD_BUILD_LONG_ROAD);

   104

}

   105

   106

/* static */ bool AIRoad::BuildRoadFull(TileIndex start, TileIndex end)

   107

{

   108

	/* Outside of the map */

   109

	if (start >= ::MapSize() || end >= ::MapSize() || start == end) return false;

   110

	/* Not on one line */

   111

	if (TileX(start) != TileX(end) &&

   112

			TileY(start) != TileY(end)) return false;

   113

   114

	return AIObject::DoCommand(end, start, (TileY(start) != TileY(end) ? 4 : 0) | (start < end ? 2 : 1), CMD_BUILD_LONG_ROAD);

   115

}

   116

   117

/* static */ bool AIRoad::BuildRoadDepot(TileIndex tile, TileIndex front)

   118

{

   119

	/* Outside of the map */

   120

	if (tile >= ::MapSize() || tile == front) return false;

   121

   122

	uint entrance_dir = (TileX(tile) == TileX(front)) ? (TileY(tile) < TileY(front) ? 1 : 3) : (TileX(tile) < TileX(front) ? 2 : 0);

   123

   124

	return AIObject::DoCommand(tile, entrance_dir, ROADTYPE_ROAD << 2, CMD_BUILD_ROAD_DEPOT);

   125

}

   126

   127

/* static */ bool AIRoad::BuildRoadStation(TileIndex tile, TileIndex front, bool truck, bool drive_through)

   128

{

   129

	/* Outside of the map */

   130

	if (tile >= ::MapSize() || tile == front) return false;

   131

   132

	uint entrance_dir;

   133

	if (drive_through) {

   134

		entrance_dir = TileY(tile) != TileY(front);

   135

	} else {

   136

		entrance_dir = (TileX(tile) == TileX(front)) ? (TileY(tile) < TileY(front) ? 1 : 3) : (TileX(tile) < TileX(front) ? 2 : 0);

   137

	}

   138

   139

	return AIObject::DoCommand(tile, entrance_dir, (drive_through ? 2 : 0) | (truck ? 1 : 0) | (ROADTYPES_ROAD << 2), CMD_BUILD_ROAD_STOP);

   140

}

   141

   142

/* static */ bool AIRoad::RemoveRoad(TileIndex start, TileIndex end)

   143

{

   144

	/* Outside of the map */

   145

	if (start >= ::MapSize() || end >= ::MapSize()) return false;

   146

	/* Not on one line */

   147

	if (TileX(start) != TileX(end) &&

   148

			TileY(start) != TileY(end)) return false;

   149

   150

	return AIObject::DoCommand(end, start, (TileY(start) != TileY(end) ? 4 : 0) | (start < end ? 1 : 2) | (ROADTYPE_ROAD << 3), CMD_REMOVE_LONG_ROAD);

   151

}

   152

   153

/* static */ bool AIRoad::RemoveRoadFull(TileIndex start, TileIndex end)

   154

{

   155

	/* Outside of the map */

   156

	if (start >= ::MapSize() || end >= ::MapSize()) return false;

   157

	/* Not on one line */

   158

	if (TileX(start) != TileX(end) &&

   159

			TileY(start) != TileY(end)) return false;

   160

   161

	return AIObject::DoCommand(end, start, (TileY(start) != TileY(end) ? 4 : 0) | (start < end ? 2 : 1), CMD_REMOVE_LONG_ROAD);

   162

}

   163

   164

/* static */ bool AIRoad::RemoveRoadDepot(TileIndex tile)

   165

{

   166

	/* Outside of the map */

   167

	if (tile >= ::MapSize()) return false;

   168

   169

	/* Not a road depot tile */

   170

	if (!IsTileType(tile, MP_ROAD) || GetRoadTileType(tile) != ROAD_TILE_DEPOT) return false;

   171

   172

	return AIObject::DoCommand(tile, 0, 0, CMD_LANDSCAPE_CLEAR);

   173

}

   174

   175

/* static */ bool AIRoad::RemoveRoadStation(TileIndex tile)

   176

{

   177

	/* Outside of the map */

   178

	if (tile >= ::MapSize()) return false;

   179

   180

	/* Not a road station tile */

   181

	if (!IsTileType(tile, MP_STATION) || !IsRoadStop(tile)) return false;

   182

   183

	return AIObject::DoCommand(tile, 0, GetRoadStopType(tile), CMD_REMOVE_ROAD_STOP);

   184

}