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

#include "../../aircraft.h"

    13

    14

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

    15

{

    16

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

    17

}

    18

    19

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

    20

{

    22

}

    23

    24

EngineID AIVehicle::FindBestVehicle(CargoID cargo, uint8 min_reliability, AIVehicle::VehicleType veh_type, uint max_cost)

    25

{

    26

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

    27

    28

	EngineID best_engine = INVALID_ENGINE;

    29

	EngineID engine_id;

    30

	uint best_cargo = 0;

    31

	uint best_speed = 0;

    32

    33

	FOR_ALL_ENGINEIDS_OF_TYPE(engine_id, veh_type) {

    34

		/* Is the vehicle available for this player */

    35

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

    36

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

    37

			uint cspeed, ccargo;

    38

			/* Can this vehicle handle the cargo requested? */

    39

			switch (veh_type) {

    40

				case VEHICLE_ROAD: {

    41

					const RoadVehicleInfo *vi = RoadVehInfo(engine_id);

    42

					if (vi->cargo_type != cargo && !CanRefitTo(engine_id, cargo)) continue;

    43

					if ((_price.roadveh_base >> 3) * vi->base_cost >> 5 > max_cost) continue;

    44

					ccargo = vi->capacity;

    45

					cspeed = vi->max_speed;

    46

				} break;

    47

    48

				case VEHICLE_RAIL: {

    49

					const RailVehicleInfo *vi = RailVehInfo(engine_id);

    50

					if (vi->cargo_type != cargo && !CanRefitTo(engine_id, cargo)) continue;

    51

					if ((_price.build_railvehicle >> 3) * vi->base_cost >> 5 > max_cost) continue;

    52

					ccargo = vi->capacity;

    53

					cspeed = vi->max_speed;

    54

				} break;

    55

    56

				case VEHICLE_WATER: {

    57

					const ShipVehicleInfo *vi = ShipVehInfo(engine_id);

    58

					if (vi->cargo_type != cargo && !CanRefitTo(engine_id, cargo)) continue;

    59

					if ((_price.ship_base >> 3) * vi->base_cost >> 5 > max_cost) continue;

    60

					ccargo = vi->capacity;

    61

					cspeed = vi->max_speed;

    62

				} break;

    63

    64

				case VEHICLE_AIR: {

    65

					const AircraftVehicleInfo *vi = AircraftVehInfo(engine_id);

    66

					if (CT_PASSENGERS != cargo && CT_MAIL != cargo && !CanRefitTo(engine_id, cargo)) continue;

    67

					if ((_price.aircraft_base >> 3) * vi->base_cost >> 5 > max_cost) continue;

    68

					ccargo = vi->passenger_capacity;

    69

					cspeed = vi->max_speed;

    70

				} break;

    71

    72

				default: NOT_REACHED();

    73

			}

    74

    75

			/* Sort on speed, than on cargo, than on order of engine-array */

    76

			if (best_speed > cspeed) continue;

    77

			if (best_cargo > ccargo) continue;

    78

			best_engine = engine_id;

    79

			best_speed = cspeed;

    80

			best_cargo = ccargo;

    81

		}

    82

	}

    83

    84

	return best_engine;

    85

}

    86

    87

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

    88

{

    89

	return this->FindBestVehicle(cargo, min_reliability, VEHICLE_ROAD, max_cost);

    90

}

    91

    92

EngineID AIVehicle::FindBestAircraftVehicle(CargoID cargo, uint8 min_reliability, uint max_cost)

    93

{

    94

	return this->FindBestVehicle(cargo, min_reliability, VEHICLE_AIR, max_cost);

    95

}

    96

    97

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

    98

{

    99

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

   100

   101

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

   102

	AIObject::SetNewVehicleID(0);

   103

   104

	bool ret;

   105

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

   106

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

   107

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

   108

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

   109

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

   110

		default: NOT_REACHED(); return INVALID_VEHICLE;

   111

	}

   112

   113

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

   114

}

   115

   116

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

   117

{

   118

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

   119

   120

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

   121

	AIObject::SetNewVehicleID(0);

   122

   123

	bool ret = this->DoCommand(depot, vehicle_id, share_orders, CMD_CLONE_VEHICLE);

   124

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

   125

}

   126

   127

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

   128

{

   129

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

   130

   131

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

   132

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

   133

		case VEH_TRAIN: return this->DoCommand(0, vehicle_id, cargo, CMD_REFIT_RAIL_VEHICLE);

   134

		case VEH_SHIP: return this->DoCommand(0, vehicle_id, cargo, CMD_REFIT_SHIP);

   135

		case VEH_AIRCRAFT: return this->DoCommand(0, vehicle_id, cargo, CMD_REFIT_AIRCRAFT);

   136

		default: return false;

   137

	}

   138

}

   139

   140

   141

bool AIVehicle::SellVehicle(VehicleID vehicle_id)

   142

{

   143

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

   144

   145

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

   146

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

   147

		case VEH_TRAIN: return this->DoCommand(0, vehicle_id, 0, CMD_SELL_RAIL_WAGON);

   148

		case VEH_SHIP: return this->DoCommand(0, vehicle_id, 0, CMD_SELL_SHIP);

   149

		case VEH_AIRCRAFT: return this->DoCommand(0, vehicle_id, 0, CMD_SELL_AIRCRAFT);

   150

		default: return false;

   151

	}

   152

}

   153

   154

bool AIVehicle::SendVehicleToDepot(VehicleID vehicle_id)

   155

{

   156

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

   157

   158

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

   159

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

   160

		case VEH_TRAIN: return this->DoCommand(0, vehicle_id, 0, CMD_SEND_TRAIN_TO_DEPOT);

   161

		case VEH_SHIP: return this->DoCommand(0, vehicle_id, 0, CMD_SEND_SHIP_TO_DEPOT);

   162

		case VEH_AIRCRAFT: return this->DoCommand(0, vehicle_id, 0, CMD_SEND_AIRCRAFT_TO_HANGAR);

   163

		default: return false;

   164

	}

   165

}

   166

   167

bool AIVehicle::StartStopVehicle(VehicleID vehicle_id)

   168

{

   169

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

   170

   171

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

   172

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

   173

		case VEH_TRAIN: return this->DoCommand(0, vehicle_id, 0, CMD_START_STOP_TRAIN);

   174

		case VEH_SHIP: return this->DoCommand(0, vehicle_id, 0, CMD_START_STOP_SHIP);

   175

		case VEH_AIRCRAFT: return this->DoCommand(0, vehicle_id, 0, CMD_START_STOP_AIRCRAFT);

   176

		default: return false;

   177

	}

   178

}

   179

   180

bool AIVehicle::SkipVehicleOrder(VehicleID vehicle_id)

   181

{

   182

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

   183

   184

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

   185

}

   186

   187

/* static */ TileIndex AIVehicle::GetLocation(VehicleID vehicle_id)

   188

{

   189

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

   190

   191

	return ::GetVehicle(vehicle_id)->tile;

   192

}

   193

   194

/* static */ EngineID AIVehicle::GetEngineType(VehicleID vehicle_id)

   195

{

   196

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

   197

   198

	return ::GetVehicle(vehicle_id)->engine_type;

   199

}

   200

   201

/* static */ int32 AIVehicle::GetUnitNumber(VehicleID vehicle_id)

   202

{

   203

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

   204

   205

	return ::GetVehicle(vehicle_id)->unitnumber;

   206

}

   207

   208

/* static */ int32 AIVehicle::GetAge(VehicleID vehicle_id)

   209

{

   210

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

   211

   212

	return ::GetVehicle(vehicle_id)->age;

   213

}

   214

   215

/* static */ int32 AIVehicle::GetMaxAge(VehicleID vehicle_id)

   216

{

   217

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

   218

   219

	return ::GetVehicle(vehicle_id)->max_age;

   220

}

   221

   222

/* static */ int32 AIVehicle::GetAgeLeft(VehicleID vehicle_id)

   223

{

   224

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

   225

   226

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

   227

}

   228

   229

/* static */ int32 AIVehicle::GetProfitThisYear(VehicleID vehicle_id)

   230

{

   231

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

   232

   233

	return ::GetVehicle(vehicle_id)->profit_this_year;

   234

}

   235

   236

/* static */ int32 AIVehicle::GetProfitLastYear(VehicleID vehicle_id)

   237

{

   238

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

   239

   240

	return ::GetVehicle(vehicle_id)->profit_last_year;

   241

}

   242

   243

/* static */ AIVehicle::VehicleType AIVehicle::GetVehicleType(VehicleID vehicle_id)

   244

{

   245

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

   246

   247

	switch (GetVehicle(vehicle_id)->type) {

   248

		case VEH_ROAD:     return VEHICLE_ROAD;

   249

		case VEH_TRAIN:    return VEHICLE_RAIL;

   250

		case VEH_SHIP:     return VEHICLE_WATER;

   251

		case VEH_AIRCRAFT: return VEHICLE_AIR;

   252

		default:           return VEHICLE_INVALID;

   253

	}

   254

}