1

/* $Id$ */

     2

     3

/** @file ai_vehicle.cpp handles the functions of the AIVehicle class */

     4

     5

#include "ai_vehicle.hpp"

     6

#include "ai_cargo.hpp"

     7

#include "../../command.h"

     8

#include "../../vehicle.h"

     9

#include "../../depot.h"

    10

#include "../../engine.h"

    11

#include "../../player.h"

    12

    13

/* static */ bool AIVehicle::IsValidEngine(EngineID engine_id)

    14

{

    15

	return ::IsEngineIndex(engine_id); // TODO: implement 'can I build this engine check'

    16

}

    17

    18

/* static */ bool AIVehicle::IsValidVehicle(VehicleID vehicle_id)

    19

{

    20

	return ::IsValidVehicleID(vehicle_id) && ::GetVehicle(vehicle_id)->owner == _current_player;

    21

}

    22

    23

EngineID AIVehicle::FindBestRoadVehicle(CargoID cargo, uint8 min_reliability)

    24

{

    25

	if (!AICargo::IsValidCargo(cargo) || min_reliability > 100) return INVALID_ENGINE;

    26

    27

	EngineID best_engine = INVALID_ENGINE;

    28

	EngineID engine_id;

    29

    30

	FOR_ALL_ENGINEIDS_OF_TYPE(engine_id, VEH_ROAD) {

    31

		/* Is the vehicle available for this player */

    32

		if (IsEngineBuildable(engine_id, VEH_ROAD, _current_player) &&

    33

				GetEngine(engine_id)->reliability * 100 >= min_reliability << 16 &&

    34

				(RoadVehInfo(engine_id)->cargo_type == cargo || CanRefitTo(engine_id, cargo))) {

    35

			best_engine = engine_id;

    36

		}

    37

	}

    38

    39

	return best_engine;

    40

}

    41

    42

VehicleID AIVehicle::BuildVehicle(TileIndex depot, EngineID engine_id)

    43

{

    44

	if (!this->IsValidEngine(engine_id)) return false;

    45

    46

	/* Reset the internal NewVehicleID in case we are in TestMode */

    47

	AIObject::SetNewVehicleID(0);

    48

    49

	bool ret;

    50

	switch (::GetEngine(engine_id)->type) {

    51

		case VEH_ROAD: ret = this->DoCommand(depot, engine_id, 0, CMD_BUILD_ROAD_VEH); break;

    52

		default: NOT_REACHED(); return INVALID_VEHICLE; // TODO: implement trains, ships and aircraft

    53

	}

    54

    55

	return ret ? AIObject::GetNewVehicleID() : INVALID_VEHICLE;

    56

}

    57

    58

VehicleID AIVehicle::CloneVehicle(TileIndex depot, VehicleID vehicle_id, bool share_orders)

    59

{

    60

	if (!this->IsValidVehicle(vehicle_id)) return false;

    61

    62

	/* Reset the internal NewVehicleID in case we are in TestMode */

    63

	AIObject::SetNewVehicleID(0);

    64

    65

	bool ret;

    66

	switch (::GetVehicle(vehicle_id)->type) {

    67

		case VEH_ROAD: ret = this->DoCommand(depot, vehicle_id, share_orders, CMD_CLONE_VEHICLE); break;

    68

		default: return INVALID_VEHICLE; // TODO: implement trains, ships and aircraft

    69

	}

    70

    71

	return ret ? AIObject::GetNewVehicleID() : INVALID_VEHICLE;

    72

}

    73

    74

bool AIVehicle::RefitVehicle(VehicleID vehicle_id, CargoID cargo)

    75

{

    76

	if (!this->IsValidVehicle(vehicle_id) || !AICargo::IsValidCargo(cargo)) return false;

    77

    78

	switch (::GetVehicle(vehicle_id)->type) {

    79

		case VEH_ROAD: return this->DoCommand(0, vehicle_id, cargo, CMD_REFIT_ROAD_VEH);

    80

		default: return false; // TODO: implement trains, ships and aircraft

    81

	}

    82

}

    83

    84

    85

bool AIVehicle::SellVehicle(VehicleID vehicle_id)

    86

{

    87

	if (!this->IsValidVehicle(vehicle_id)) return false;

    88

    89

	switch (::GetVehicle(vehicle_id)->type) {

    90

		case VEH_ROAD: return this->DoCommand(0, vehicle_id, 0, CMD_SELL_ROAD_VEH);

    91

		default: return false; // TODO: implement trains, ships and aircraft

    92

	}

    93

}

    94

    95

bool AIVehicle::SendVehicleToDepot(VehicleID vehicle_id)

    96

{

    97

	if (!this->IsValidVehicle(vehicle_id)) return false;

    98

    99

	switch (::GetVehicle(vehicle_id)->type) {

   100

		case VEH_ROAD: return this->DoCommand(0, vehicle_id, 0, CMD_SEND_ROADVEH_TO_DEPOT);

   101

		default: return false; // TODO: implement trains, ships and aircraft

   102

	}

   103

}

   104

   105

bool AIVehicle::StartStopVehicle(VehicleID vehicle_id)

   106

{

   107

	if (!this->IsValidVehicle(vehicle_id)) return false;

   108

   109

	switch (::GetVehicle(vehicle_id)->type) {

   110

		case VEH_ROAD: return this->DoCommand(0, vehicle_id, 0, CMD_START_STOP_ROADVEH);

   111

		default: return false; // TODO: implement trains, ships and aircraft

   112

	}

   113

}

   114

   115

bool AIVehicle::SkipVehicleOrder(VehicleID vehicle_id)

   116

{

   117

	if (!this->IsValidVehicle(vehicle_id)) return false;

   118

   119

	return this->DoCommand(0, vehicle_id, 0, CMD_SKIP_TO_ORDER);

   120

}

   121

   123

{

   124

	if (!AIVehicle::IsValidVehicle(vehicle_id)) return INVALID_TILE;

   125

   126

	return ::GetVehicle(vehicle_id)->tile;

   127

}

   128

   130

{

   131

	if (!AIVehicle::IsValidVehicle(vehicle_id)) return INVALID_ENGINE;

   132

   133

	return ::GetVehicle(vehicle_id)->engine_type;

   134

}

   135

   137

{

   138

	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

   139

   140

	return ::GetVehicle(vehicle_id)->unitnumber;

   141

}

   142

   144

{

   145

	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

   146

   147

	return ::GetVehicle(vehicle_id)->age;

   148

}

   149

   151

{

   152

	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

   153

   154

	return ::GetVehicle(vehicle_id)->max_age;

   155

}

   156

   158

{

   159

	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

   160

   161

	return ::GetVehicle(vehicle_id)->max_age - ::GetVehicle(vehicle_id)->age;

   162

}

   163

   165

{

   166

	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

   167

   168

	return ::GetVehicle(vehicle_id)->profit_this_year;

   169

}

   170

   172

{

   173

	if (!AIVehicle::IsValidVehicle(vehicle_id)) return -1;

   174

   175

	return ::GetVehicle(vehicle_id)->profit_last_year;

   176

}