1

/* $Id$ */

     2

     3

#include "../../stdafx.h"

     4

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

     5

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

     6

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

     7

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

     8

#include "trolly.h"

     9

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

    10

#include "../../station.h"

    11

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

    12

#include "../../bridge.h"

    13

#include "../../vehicle_func.h"

    14

#include "../../vehicle_base.h"

    15

#include "../../player_base.h"

    16

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

    17

#include "../ai.h"

    20

    21

// Build HQ

    22

//  Params:

    23

//    tile : tile where HQ is going to be build

    24

bool AiNew_Build_CompanyHQ(Player *p, TileIndex tile)

    25

{

    26

	if (CmdFailed(AI_DoCommand(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ)))

    27

		return false;

    28

	AI_DoCommand(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ);

    29

	return true;

    30

}

    31

    32

    33

// Build station

    34

//  Params:

    35

//    type : AI_TRAIN/AI_BUS/AI_TRUCK : indicates the type of station

    36

//    tile : tile where station is going to be build

    37

//    length : in case of AI_TRAIN: length of station

    38

//    numtracks : in case of AI_TRAIN: tracks of station

    39

//    direction : the direction of the station

    40

//    flag : flag passed to DoCommand (normally 0 to get the cost or DC_EXEC to build it)

    41

CommandCost AiNew_Build_Station(Player *p, byte type, TileIndex tile, byte length, byte numtracks, byte direction, byte flag)

    42

{

    43

	if (type == AI_TRAIN)

    44

		return AI_DoCommand(tile, direction + (numtracks << 8) + (length << 16), 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_RAILROAD_STATION);

    45

    46

	if (type == AI_BUS)

    47

		return AI_DoCommand(tile, direction, ROADTYPES_ROAD << 2 | RoadStop::BUS, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP);

    48

    49

	return AI_DoCommand(tile, direction, ROADTYPES_ROAD << 2 | RoadStop::TRUCK, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP);

    50

}

    51

    52

    53

// Builds a brdige. The second best out of the ones available for this player

    54

//  Params:

    55

//   tile_a : starting point

    56

//   tile_b : end point

    57

//   flag : flag passed to DoCommand

    58

CommandCost AiNew_Build_Bridge(Player *p, TileIndex tile_a, TileIndex tile_b, byte flag)

    59

{

    60

	int bridge_type, bridge_len, type, type2;

    61

    62

	// Find a good bridgetype (the best money can buy)

    64

	type = type2 = 0;

    65

	for (bridge_type = MAX_BRIDGES-1; bridge_type >= 0; bridge_type--) {

    66

		if (CheckBridge_Stuff(bridge_type, bridge_len)) {

    67

			type2 = type;

    68

			type = bridge_type;

    69

			// We found two bridges, exit

    70

			if (type2 != 0) break;

    71

		}

    72

	}

    73

	// There is only one bridge that can be built

    74

	if (type2 == 0 && type != 0) type2 = type;

    75

    76

	// Now, simply, build the bridge!

    77

	if (_players_ainew[p->index].tbt == AI_TRAIN) {

    78

		return AI_DoCommand(tile_a, tile_b, (0x00 << 8) + type2, flag | DC_AUTO, CMD_BUILD_BRIDGE);

    79

	} else {

    80

		return AI_DoCommand(tile_a, tile_b, ((0x80 | ROADTYPES_ROAD) << 8) + type2, flag | DC_AUTO, CMD_BUILD_BRIDGE);

    81

	}

    82

}

    83

    84

    85

// Build the route part by part

    86

// Basicly what this function do, is build that amount of parts of the route

    87

//  that go in the same direction. It sets 'part' to the last part of the route builded.

    88

//  The return value is the cost for the builded parts

    89

//

    90

//  Params:

    91

//   PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder

    92

//   part : Which part we need to build

    93

//

    94

// TODO: skip already builded road-pieces (e.g.: cityroad)

    95

CommandCost AiNew_Build_RoutePart(Player *p, Ai_PathFinderInfo *PathFinderInfo, byte flag)

    96

{

    97

	int part = PathFinderInfo->position;

    98

	byte *route_extra = PathFinderInfo->route_extra;

    99

	TileIndex *route = PathFinderInfo->route;

   100

	int dir;

   101

	int old_dir = -1;

   102

	CommandCost cost;

   103

	CommandCost res;

   104

	// We need to calculate the direction with the parent of the parent.. so we skip

   105

	//  the first pieces and the last piece

   106

	if (part < 1) part = 1;

   107

	// When we are done, stop it

   108

	if (part >= PathFinderInfo->route_length - 1) {

   109

		PathFinderInfo->position = -2;

   110

		return CommandCost();

   111

	}

   112

   113

   114

	if (PathFinderInfo->rail_or_road) {

   115

		// Tunnel code

   116

		if ((AI_PATHFINDER_FLAG_TUNNEL & route_extra[part]) != 0) {

   117

			cost.AddCost(AI_DoCommand(route[part], 0, 0, flag, CMD_BUILD_TUNNEL));

   118

			PathFinderInfo->position++;

   119

			// TODO: problems!

   120

			if (CmdFailed(cost)) {

   121

				DEBUG(ai, 0, "[BuildPath] tunnel could not be built (0x%X)", route[part]);

   122

				return CommandCost();

   123

			}

   124

			return cost;

   125

		}

   126

		// Bridge code

   127

		if ((AI_PATHFINDER_FLAG_BRIDGE & route_extra[part]) != 0) {

   128

			cost.AddCost(AiNew_Build_Bridge(p, route[part], route[part - 1], flag));

   129

			PathFinderInfo->position++;

   130

			// TODO: problems!

   131

			if (CmdFailed(cost)) {

   132

				DEBUG(ai, 0, "[BuildPath] bridge could not be built (0x%X, 0x%X)", route[part], route[part - 1]);

   133

				return CommandCost();

   134

			}

   135

			return cost;

   136

		}

   137

   138

		// Build normal rail

   139

		// Keep it doing till we go an other way

   140

		if (route_extra[part - 1] == 0 && route_extra[part] == 0) {

   141

			while (route_extra[part] == 0) {

   142

				// Get the current direction

   143

				dir = AiNew_GetRailDirection(route[part-1], route[part], route[part+1]);

   144

				// Is it the same as the last one?

   145

				if (old_dir != -1 && old_dir != dir) break;

   146

				old_dir = dir;

   147

				// Build the tile

   148

				res = AI_DoCommand(route[part], 0, dir, flag, CMD_BUILD_SINGLE_RAIL);

   149

				if (CmdFailed(res)) {

   150

					// Problem.. let's just abort it all!

   151

					_players_ainew[p->index].state = AI_STATE_NOTHING;

   152

					return CommandCost();

   153

				}

   154

				cost.AddCost(res);

   155

				// Go to the next tile

   156

				part++;

   157

				// Check if it is still in range..

   158

				if (part >= PathFinderInfo->route_length - 1) break;

   159

			}

   160

			part--;

   161

		}

   162

		// We want to return the last position, so we go back one

   163

		PathFinderInfo->position = part;

   164

	} else {

   165

		// Tunnel code

   166

		if ((AI_PATHFINDER_FLAG_TUNNEL & route_extra[part]) != 0) {

   167

			cost.AddCost(AI_DoCommand(route[part], 0x200 | ROADTYPES_ROAD, 0, flag, CMD_BUILD_TUNNEL));

   168

			PathFinderInfo->position++;

   169

			// TODO: problems!

   170

			if (CmdFailed(cost)) {

   171

				DEBUG(ai, 0, "[BuildPath] tunnel could not be built (0x%X)", route[part]);

   172

				return CommandCost();

   173

			}

   174

			return cost;

   175

		}

   176

		// Bridge code

   177

		if ((AI_PATHFINDER_FLAG_BRIDGE & route_extra[part]) != 0) {

   178

			cost.AddCost(AiNew_Build_Bridge(p, route[part], route[part + 1], flag));

   179

			PathFinderInfo->position++;

   180

			// TODO: problems!

   181

			if (CmdFailed(cost)) {

   182

				DEBUG(ai, 0, "[BuildPath] bridge could not be built (0x%X, 0x%X)", route[part], route[part + 1]);

   183

				return CommandCost();

   184

			}

   185

			return cost;

   186

		}

   187

   188

		// Build normal road

   189

		// Keep it doing till we go an other way

   190

		// EnsureNoVehicleOnGround makes sure we don't build on a tile where a vehicle is. This way

   191

		//  it will wait till the vehicle is gone..

   192

		if (route_extra[part-1] == 0 && route_extra[part] == 0 && (flag != DC_EXEC || EnsureNoVehicleOnGround(route[part]))) {

   193

			while (route_extra[part] == 0 && (flag != DC_EXEC || EnsureNoVehicleOnGround(route[part]))) {

   194

				// Get the current direction

   195

				dir = AiNew_GetRoadDirection(route[part-1], route[part], route[part+1]);

   196

				// Is it the same as the last one?

   197

				if (old_dir != -1 && old_dir != dir) break;

   198

				old_dir = dir;

   199

				// There is already some road, and it is a bridge.. don't build!!!

   200

				if (!IsTileType(route[part], MP_TUNNELBRIDGE)) {

   201

					// Build the tile

   202

					res = AI_DoCommand(route[part], dir, 0, flag | DC_NO_WATER, CMD_BUILD_ROAD);

   203

					// Currently, we ignore CMD_ERRORs!

   204

					if (CmdFailed(res) && flag == DC_EXEC && !IsTileType(route[part], MP_ROAD) && !EnsureNoVehicleOnGround(route[part])) {

   205

						// Problem.. let's just abort it all!

   206

						DEBUG(ai, 0, "[BuidPath] route building failed at tile 0x%X, aborting", route[part]);

   207

						_players_ainew[p->index].state = AI_STATE_NOTHING;

   208

						return CommandCost();

   209

					}

   210

   211

					if (CmdSucceeded(res)) cost.AddCost(res);

   212

				}

   213

				// Go to the next tile

   214

				part++;

   215

				// Check if it is still in range..

   216

				if (part >= PathFinderInfo->route_length - 1) break;

   217

			}

   218

			part--;

   219

			// We want to return the last position, so we go back one

   220

		}

   221

		if (!EnsureNoVehicleOnGround(route[part]) && flag == DC_EXEC) part--;

   222

		PathFinderInfo->position = part;

   223

	}

   224

   225

	return cost;

   226

}

   227

   228

   229

// This functions tries to find the best vehicle for this type of cargo

   230

// It returns INVALID_ENGINE if not suitable engine is found

   231

EngineID AiNew_PickVehicle(Player *p)

   232

{

   233

	if (_players_ainew[p->index].tbt == AI_TRAIN) {

   234

		// Not supported yet

   235

		return INVALID_ENGINE;

   236

	} else {

   237

		EngineID best_veh_index = INVALID_ENGINE;

   238

		int32 best_veh_rating = 0;

   239

		EngineID i;

   240

   241

		/* Loop through all road vehicles */

   243

			const RoadVehicleInfo *rvi = RoadVehInfo(i);

   244

			const Engine* e = GetEngine(i);

   245

   246

			/* Skip vehicles which can't take our cargo type */

   247

			if (rvi->cargo_type != _players_ainew[p->index].cargo && !CanRefitTo(i, _players_ainew[p->index].cargo)) continue;

   248

   252

			// Is it availiable?

   253

			// Also, check if the reliability of the vehicle is above the AI_VEHICLE_MIN_RELIABILTY

   254

			if (!HasBit(e->player_avail, _current_player) || e->reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue;

   255

   256

			/* Rate and compare the engine by speed & capacity */

   258

			if (rating <= best_veh_rating) continue;

   259

   260

			// Can we build it?

   262

			if (CmdFailed(ret)) continue;

   263

   264

			best_veh_rating = rating;

   265

			best_veh_index = i;

   266

		}

   267

   268

		return best_veh_index;

   269

	}

   270

}

   271

   272

   273

void CcAI(bool success, TileIndex tile, uint32 p1, uint32 p2)

   274

{

   275

	Player* p = GetPlayer(_current_player);

   276

   277

	if (success) {

   278

		_players_ainew[p->index].state = AI_STATE_GIVE_ORDERS;

   279

		_players_ainew[p->index].veh_id = _new_vehicle_id;

   280

   281

		if (GetVehicle(_players_ainew[p->index].veh_id)->cargo_type != _players_ainew[p->index].cargo) {

   282

			/* Cargo type doesn't match, so refit it */

   283

			if (CmdFailed(DoCommand(tile, _players_ainew[p->index].veh_id, _players_ainew[p->index].cargo, DC_EXEC, CMD_REFIT_ROAD_VEH))) {

   284

				/* Refit failed, so sell the vehicle */

   285

				DoCommand(tile, _players_ainew[p->index].veh_id, 0, DC_EXEC, CMD_SELL_ROAD_VEH);

   286

				_players_ainew[p->index].state = AI_STATE_NOTHING;

   287

			}

   288

		}

   289

	} else {

   290

		/* XXX this should be handled more gracefully */

   291

		_players_ainew[p->index].state = AI_STATE_NOTHING;

   292

	}

   293

}

   294

   295

   296

// Builds the best vehicle possible

   297

CommandCost AiNew_Build_Vehicle(Player *p, TileIndex tile, byte flag)

   298

{

   299

	EngineID i = AiNew_PickVehicle(p);

   300

   301

	if (i == INVALID_ENGINE) return CMD_ERROR;

   302

	if (_players_ainew[p->index].tbt == AI_TRAIN) return CMD_ERROR;

   303

   304

	if (flag & DC_EXEC) {

   305

		return AI_DoCommandCc(tile, i, 0, flag, CMD_BUILD_ROAD_VEH, CcAI);

   306

	} else {

   307

		return AI_DoCommand(tile, i, 0, flag, CMD_BUILD_ROAD_VEH);

   308

	}

   309

}

   310

   311

CommandCost AiNew_Build_Depot(Player* p, TileIndex tile, DiagDirection direction, byte flag)

   312

{

   313

	CommandCost ret, ret2;

   314

	if (_players_ainew[p->index].tbt == AI_TRAIN) {

   315

		return AI_DoCommand(tile, 0, direction, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_TRAIN_DEPOT);

   316

	} else {

   317

		ret = AI_DoCommand(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_DEPOT);

   318

		if (CmdFailed(ret2)) return ret;

   319

		// Try to build the road from the depot

   320

		ret2 = AI_DoCommand(tile + TileOffsByDiagDir(direction), DiagDirToRoadBits(ReverseDiagDir(direction)), 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);

   321

		// If it fails, ignore it..

   322

		if (CmdFailed(ret2)) return ret;

   323

		ret.AddCost(ret2);

   324

		return ret;

   325

	}

   326

}