1

/* $Id$ */

     2

     3

/** @file ai_bridge.cpp Implementation of AIBridge. */

     4

     5

#include "ai_bridge.hpp"

     6

#include "../../openttd.h"

     7

#include "../../bridge_map.h"

     8

#include "../../strings_func.h"

     9

#include "../../core/alloc_func.hpp"

    10

#include "../../economy_func.h"

    11

#include "../../settings_type.h"

    12

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

    13

#include "table/strings.h"

    14

    15

/* static */ bool AIBridge::IsValidBridge(BridgeID bridge_id)

    16

{

    17

	return bridge_id < MAX_BRIDGES;

    18

}

    19

    20

/* static */ bool AIBridge::IsBridgeTile(TileIndex tile)

    21

{

    22

	return ::IsBridgeTile(tile);

    23

}

    24

    25

/* static */ bool AIBridge::BuildBridge(AIVehicle::VehicleType vehicle_type, BridgeID bridge_id, TileIndex start, TileIndex end)

    26

{

    27

	EnforcePrecondition(false, start != end);

    28

	EnforcePrecondition(false, ::IsValidTile(start) && ::IsValidTile(end));

    29

	EnforcePrecondition(false, TileX(start) == TileX(end) || TileY(start) == TileY(end));

    30

	EnforcePrecondition(false, vehicle_type == AIVehicle::VEHICLE_ROAD || vehicle_type == AIVehicle::VEHICLE_RAIL);

    31

    32

	uint type = 0;

    33

	if (vehicle_type == AIVehicle::VEHICLE_ROAD) {

    34

		type |= (TRANSPORT_ROAD << 15);

    35

		type |= (RoadTypeToRoadTypes((::RoadType)AIObject::GetRoadType()) << 8);

    36

	} else {

    37

		type |= (TRANSPORT_RAIL << 15);

    38

		type |= (RAILTYPES_RAIL << 8);

    39

	}

    40

    41

	if (!AIObject::DoCommand(end, start, type | bridge_id, CMD_BUILD_BRIDGE)) return false;

    42

	if (vehicle_type == AIVehicle::VEHICLE_RAIL) return true;

    43

    44

	/* Build 2 road-pieces at both ends of the bridge */

    45

	DiagDirection dir_1 = (DiagDirection)((::TileX(start) == ::TileX(end)) ? (::TileY(start) < ::TileY(end) ? DIAGDIR_NW : DIAGDIR_SE) : (::TileX(start) < ::TileX(end) ? DIAGDIR_NE : DIAGDIR_SW));

    46

	DiagDirection dir_2 = ::ReverseDiagDir(dir_1);

    47

    48

	AIObject::DoCommand(start + ::TileOffsByDiagDir(dir_1), ::DiagDirToRoadBits(dir_2) | (AIObject::GetRoadType() << 4), 0, CMD_BUILD_ROAD);

    49

	AIObject::DoCommand(end + ::TileOffsByDiagDir(dir_2), ::DiagDirToRoadBits(dir_1) | (AIObject::GetRoadType() << 4), 0, CMD_BUILD_ROAD);

    50

    51

	return true;

    52

}

    53

    54

/* static */ bool AIBridge::RemoveBridge(TileIndex tile)

    55

{

    56

	EnforcePrecondition(false, IsBridgeTile(tile));

    57

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

    58

}

    59

    60

/* static */ char *AIBridge::GetName(BridgeID bridge_id)

    61

{

    62

	if (!IsValidBridge(bridge_id)) return NULL;

    63

    64

	static const int len = 64;

    65

	char *bridge_name = MallocT<char>(len);

    66

    67

	::GetString(bridge_name, ::GetBridgeSpec(bridge_id)->transport_name[0], &bridge_name[len - 1]);

    68

	return bridge_name;

    69

}

    70

    71

/* static */ int32 AIBridge::GetMaxSpeed(BridgeID bridge_id)

    72

{

    73

	if (!IsValidBridge(bridge_id)) return -1;

    74

    75

	return ::GetBridgeSpec(bridge_id)->speed;

    76

}

    77

    78

/* static */ Money AIBridge::GetPrice(BridgeID bridge_id, uint length)

    79

{

    80

	if (!IsValidBridge(bridge_id)) return -1;

    81

    82

	return length * _price.build_bridge * ::GetBridgeSpec(bridge_id)->price >> 8;

    83

}

    84

    85

/* static */ int32 AIBridge::GetMaxLength(BridgeID bridge_id)

    86

{

    87

	if (!IsValidBridge(bridge_id)) return -1;

    88

    89

	uint max = ::GetBridgeSpec(bridge_id)->max_length;

    90

	if (max >= 16 && _settings_game.construction.longbridges) max = 100;

    91

	return max + 2;

    92

}

    93

    94

/* static */ int32 AIBridge::GetMinLength(BridgeID bridge_id)

    95

{

    96

	if (!IsValidBridge(bridge_id)) return -1;

    97

    98

	return ::GetBridgeSpec(bridge_id)->min_length + 2;

    99

}

   100

   101

/* static */ int32 AIBridge::GetYearAvailable(BridgeID bridge_id)

   102

{

   103

	if (!IsValidBridge(bridge_id)) return -1;

   104

   105

	return ::GetBridgeSpec(bridge_id)->avail_year;

   106

}

   107

   108

/* static */ TileIndex AIBridge::GetOtherBridgeEnd(TileIndex tile)

   109

{

   110

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

   111

	if (!IsBridgeTile(tile)) return INVALID_TILE;

   112

   113

	return ::GetOtherBridgeEnd(tile);

   114

}