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

	if (!::IsValidTile(tile)) return false;

    12

    13

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

    14

			IsDriveThroughRoadStationTile(tile);

    15

}

    16

    17

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

    18

{

    19

	if (!::IsValidTile(tile)) return false;

    20

    21

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

    22

}

    23

    24

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

    25

{

    26

	if (!::IsValidTile(tile)) return false;

    27

    28

	return ::IsRoadStopTile(tile);

    29

}

    30

    31

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

    32

{

    33

	if (!::IsValidTile(tile)) return false;

    34

    35

	return ::IsDriveThroughStopTile(tile);

    36

}

    37

    38

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

    39

{

    40

	if (!::IsValidTile(t1)) return false;

    41

	if (!::IsValidTile(t2)) return false;

    42

    43

	/* Tiles not neighbouring */

    44

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

    45

    46

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

    47

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

    48

    49

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

    50

	DiagDirection dir_2 = ::ReverseDiagDir(dir_1);

    51

    52

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

    53

}

    54

    55

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

    56

{

    57

	if (!::IsValidTile(tile)) return false;

    58

    59

	int32 neighbour = 0;

    60

    61

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

    62

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

    63

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

    64

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

    65

    66

	return neighbour;

    67

}

    68

    69

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

    70

{

    71

	if (!IsRoadDepotTile(depot)) return INVALID_TILE;

    72

    73

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

    74

}

    75

    76

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

    77

{

    78

	if (!IsRoadStationTile(station)) return INVALID_TILE;

    79

    80

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

    81

}

    82

    83

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

    84

{

    85

	if (!IsDriveThroughRoadStationTile(station)) return INVALID_TILE;

    86

    87

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

    88

}

    89

    90

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

    91

{

    93

	if (!::IsValidTile(start)) return false;

    94

	if (!::IsValidTile(end)) return false;

    95

	/* Not on one line */

    96

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

    97

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

    98

    99

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

   100

}

   101

   102

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

   103

{

   105

	if (!::IsValidTile(start)) return false;

   106

	if (!::IsValidTile(end)) return false;

   107

	/* Not on one line */

   108

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

   109

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

   110

   111

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

   112

}

   113

   114

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

   115

{

   117

	if (!::IsValidTile(tile)) return false;

   118

	if (!::IsValidTile(front)) return false;

   119

   120

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

   121

   122

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

   123

}

   124

   125

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

   126

{

   128

	if (!::IsValidTile(tile)) return false;

   129

	if (!::IsValidTile(front)) return false;

   130

   131

	uint entrance_dir;

   132

	if (drive_through) {

   133

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

   134

	} else {

   135

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

   136

	}

   137

   138

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

   139

}

   140

   141

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

   142

{

   143

	if (!::IsValidTile(start)) return false;

   144

	if (!::IsValidTile(end)) return false;

   145

	/* Not on one line */

   146

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

   147

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

   148

   149

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

   150

}

   151

   152

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

   153

{

   154

	if (!::IsValidTile(start)) return false;

   155

	if (!::IsValidTile(end)) return false;

   156

	/* Not on one line */

   157

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

   158

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

   159

   160

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

   161

}

   162

   163

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

   164

{

   165

	if (!::IsValidTile(tile)) return false;

   166

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

   167

   168

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

   169

}

   170

   171

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

   172

{

   173

	if (!::IsValidTile(tile)) return false;

   174

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

   175

   176

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

   177

}