1

/* $Id$ */

     2

     3

/** @file ai_station.cpp Implementation of AIStation. */

     4

     5

#include "ai_station.hpp"

     6

#include "ai_cargo.hpp"

     7

#include "ai_map.hpp"

     8

#include "ai_town.hpp"

     9

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

    10

#include "../../command_func.h"

    11

#include "../../debug.h"

    12

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

    13

#include "../../variables.h"

    14

#include "../../string_func.h"

    15

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

    16

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

    17

#include "../../player_func.h"

    18

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

    19

#include "table/strings.h"

    20

    21

/* static */ bool AIStation::IsValidStation(StationID station_id)

    22

{

    23

	return ::IsValidStationID(station_id) && ::GetStation(station_id)->owner == _current_player;

    24

}

    25

    26

/* static */ StationID AIStation::GetStationID(TileIndex tile)

    27

{

    28

	if (!::IsTileType(tile, MP_STATION)) return INVALID_STATION;

    29

	return ::GetStationIndex(tile);

    30

}

    31

    32

/* static */ char *AIStation::GetName(StationID station_id)

    33

{

    34

	if (!IsValidStation(station_id)) return NULL;

    35

    36

	static const int len = 64;

    37

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

    38

    39

	::SetDParam(0, GetStation(station_id)->index);

    40

	::GetString(station_name, STR_STATION, &station_name[len - 1]);

    41

	return station_name;

    42

}

    43

    44

/* static */ bool AIStation::SetName(StationID station_id, const char *name)

    45

{

    46

	EnforcePrecondition(false, IsValidStation(station_id));

    47

	EnforcePrecondition(false, !::StrEmpty(name));

    48

    49

	_cmd_text = name;

    50

	return AIObject::DoCommand(0, 0, station_id, CMD_RENAME_STATION);

    51

}

    52

    53

/* static */ TileIndex AIStation::GetLocation(StationID station_id)

    54

{

    55

	if (!IsValidStation(station_id)) return INVALID_TILE;

    56

    57

	return ::GetStation(station_id)->xy;

    58

}

    59

    60

/* static */ int32 AIStation::GetCargoWaiting(StationID station_id, CargoID cargo_id)

    61

{

    62

	if (!IsValidStation(station_id)) return -1;

    63

	if (!AICargo::IsValidCargo(cargo_id)) return -1;

    64

    65

	return ::GetStation(station_id)->goods[cargo_id].cargo.Count();

    66

}

    67

    68

/* static */ int32 AIStation::GetCargoRating(StationID station_id, CargoID cargo_id)

    69

{

    70

	if (!IsValidStation(station_id)) return -1;

    71

	if (!AICargo::IsValidCargo(cargo_id)) return -1;

    72

    73

	return ::GetStation(station_id)->goods[cargo_id].rating * 101 >> 8;

    74

}

    75

    76

/* static */ int32 AIStation::GetCoverageRadius(AIStation::StationType type)

    77

{

    78

	if (type == STATION_AIRPORT) {

    79

		DEBUG(ai, 0, "GetCoverageRadius(): coverage radius of airports needs to be requested via AIAirport::GetAirportCoverageRadius(), as it requires AirportType");

    80

		return -1;

    81

	}

    82

	if (!_patches.modified_catchment) return CA_UNMODIFIED;

    83

    84

	switch (type) {

    85

		case STATION_TRAIN:      return CA_TRAIN;

    86

		case STATION_TRUCK_STOP: return CA_TRUCK;

    87

		case STATION_BUS_STOP:   return CA_BUS;

    88

		case STATION_DOCK:       return CA_DOCK;

    89

		default:                 return CA_NONE;

    90

	}

    91

}

    92

    93

/* static */ int32 AIStation::GetDistanceManhattanToTile(StationID station_id, TileIndex tile)

    94

{

    95

	return AIMap::DistanceManhattan(tile, GetLocation(station_id));

    96

}

    97

    98

/* static */ int32 AIStation::GetDistanceSquareToTile(StationID station_id, TileIndex tile)

    99

{

   100

	return AIMap::DistanceSquare(tile, GetLocation(station_id));

   101

}

   102

   103

/* static */ bool AIStation::IsWithinTownInfluence(StationID station_id, TownID town_id)

   104

{

   105

	return AITown::IsWithinTownInfluence(town_id, GetLocation(station_id));

   106

}