1

/* $Id$ */

     2

     3

/** @file build.cpp Building support for the trolly AI. */

     4

     5

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

     6

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

     7

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

     8

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

     9

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

    10

#include "trolly.h"

    11

#include "../../engine_func.h"

    12

#include "../../engine_base.h"

    13

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

    14

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

    15

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

    16

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

    17

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

    18

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

    19

#include "../ai.h"

    20

#include "../../tunnelbridge.h"

    21

    22

    23

// Build HQ

    24

//  Params:

    25

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

    27

{

    28

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

    29

		return false;

    30

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

    31

	return true;

    32

}

    33

    34

    35

// Build station

    36

//  Params:

    37

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

    38

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

    39

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

    40

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

    41

//    direction : the direction of the station

    42

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

    44

{

    45

	if (type == AI_TRAIN)

    46

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

    47

    48

	if (type == AI_BUS)

    49

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

    50

    51

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

    52

}

    53

    54

    56

//  Params:

    57

//   tile_a : starting point

    58

//   tile_b : end point

    59

//   flag : flag passed to DoCommand

    61

{

    62

	int bridge_type, bridge_len, type, type2;

    63

    64

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

    65

	bridge_len = GetTunnelBridgeLength(tile_a, tile_b);

    66

	type = type2 = 0;

    67

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

    68

		if (CheckBridge_Stuff(bridge_type, bridge_len)) {

    69

			type2 = type;

    70

			type = bridge_type;

    71

			// We found two bridges, exit

    72

			if (type2 != 0) break;

    73

		}

    74

	}

    75

	// There is only one bridge that can be built

    76

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

    77

    78

	// Now, simply, build the bridge!

    80

		return AI_DoCommand(tile_a, tile_b, type2 | RAILTYPE_RAIL  << 8 | TRANSPORT_RAIL << 15, flag | DC_AUTO, CMD_BUILD_BRIDGE);

    81

	} else {

    82

		return AI_DoCommand(tile_a, tile_b, type2 | ROADTYPES_ROAD << 8 | TRANSPORT_ROAD << 15, flag | DC_AUTO, CMD_BUILD_BRIDGE);

    83

	}

    84

}

    85

    86

    87

// Build the route part by part

    88

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

    89

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

    90

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

    91

//

    92

//  Params:

    93

//   PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder

    94

//   part : Which part we need to build

    95

//

    96

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

    98

{

    99

	int part = PathFinderInfo->position;

   100

	byte *route_extra = PathFinderInfo->route_extra;

   101

	TileIndex *route = PathFinderInfo->route;

   102

	int dir;

   103

	int old_dir = -1;

   104

	CommandCost cost;

   105

	CommandCost res;

   106

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

   107

	//  the first pieces and the last piece

   108

	if (part < 1) part = 1;

   109

	// When we are done, stop it

   110

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

   111

		PathFinderInfo->position = -2;

   112

		return CommandCost();

   113

	}

   114

   115

   116

	if (PathFinderInfo->rail_or_road) {

   117

		// Tunnel code

   118

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

   119

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

   120

			PathFinderInfo->position++;

   121

			// TODO: problems!

   122

			if (CmdFailed(cost)) {

   123

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

   124

				return CommandCost();

   125

			}

   126

			return cost;

   127

		}

   128

		// Bridge code

   129

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

   131

			PathFinderInfo->position++;

   132

			// TODO: problems!

   133

			if (CmdFailed(cost)) {

   134

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

   135

				return CommandCost();

   136

			}

   137

			return cost;

   138

		}

   139

   140

		// Build normal rail

   141

		// Keep it doing till we go an other way

   142

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

   143

			while (route_extra[part] == 0) {

   144

				// Get the current direction

   145

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

   146

				// Is it the same as the last one?

   147

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

   148

				old_dir = dir;

   149

				// Build the tile

   150

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

   151

				if (CmdFailed(res)) {

   152

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

   154

					return CommandCost();

   155

				}

   156

				cost.AddCost(res);

   157

				// Go to the next tile

   158

				part++;

   159

				// Check if it is still in range..

   160

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

   161

			}

   162

			part--;

   163

		}

   164

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

   165

		PathFinderInfo->position = part;

   166

	} else {

   167

		// Tunnel code

   168

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

   169

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

   170

			PathFinderInfo->position++;

   171

			// TODO: problems!

   172

			if (CmdFailed(cost)) {

   173

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

   174

				return CommandCost();

   175

			}

   176

			return cost;

   177

		}

   178

		// Bridge code

   179

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

   181

			PathFinderInfo->position++;

   182

			// TODO: problems!

   183

			if (CmdFailed(cost)) {

   184

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

   185

				return CommandCost();

   186

			}

   187

			return cost;

   188

		}

   189

   190

		// Build normal road

   191

		// Keep it doing till we go an other way

   192

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

   193

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

   194

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

   195

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

   196

				// Get the current direction

   197

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

   198

				// Is it the same as the last one?

   199

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

   200

				old_dir = dir;

   201

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

   202

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

   203

					// Build the tile

   204

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

   205

					// Currently, we ignore CMD_ERRORs!

   206

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

   207

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

   208

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

   210

						return CommandCost();

   211

					}

   212

   213

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

   214

				}

   215

				// Go to the next tile

   216

				part++;

   217

				// Check if it is still in range..

   218

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

   219

			}

   220

			part--;

   221

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

   222

		}

   223

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

   224

		PathFinderInfo->position = part;

   225

	}

   226

   227

	return cost;

   228

}

   229

   230

   231

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

   232

// It returns INVALID_ENGINE if not suitable engine is found

   234

{

   236

		// Not supported yet

   237

		return INVALID_ENGINE;

   238

	} else {

   239

		EngineID best_veh_index = INVALID_ENGINE;

   240

		int32 best_veh_rating = 0;

   241

		const Engine *e;

   242

   243

		/* Loop through all road vehicles */

   244

		FOR_ALL_ENGINES_OF_TYPE(e, VEH_ROAD) {

   245

			EngineID i = e->index;

   246

			const RoadVehicleInfo *rvi = &e->u.road;

   247

   248

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

   250

   251

			/* Skip trams */

   252

			if (HasBit(EngInfo(i)->misc_flags, EF_ROAD_TRAM)) continue;

   253

   254

			// Is it availiable?

   255

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

   257

   258

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

   259

			int rating = rvi->max_speed * rvi->capacity;

   260

			if (rating <= best_veh_rating) continue;

   261

   262

			// Can we build it?

   263

			CommandCost ret = AI_DoCommand(0, i, 0, DC_QUERY_COST, CMD_BUILD_ROAD_VEH);

   264

			if (CmdFailed(ret)) continue;

   265

   266

			best_veh_rating = rating;

   267

			best_veh_index = i;

   268

		}

   269

   270

		return best_veh_index;

   271

	}

   272

}

   273

   274

   275

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

   276

{

   278

   279

	if (success) {

   282

   284

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

   286

				/* Refit failed, so sell the vehicle */

   289

			}

   290

		}

   291

	} else {

   292

		/* XXX this should be handled more gracefully */

   294

	}

   295

}

   296

   297

   298

// Builds the best vehicle possible

   300

{

   302

   303

	if (i == INVALID_ENGINE) return CMD_ERROR;

   305

   306

	if (flag & DC_EXEC) {

   307

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

   308

	} else {

   309

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

   310

	}

   311

}

   312

   314

{

   315

	CommandCost ret, ret2;

   317

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

   318

	} else {

   319

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

   320

		if (CmdFailed(ret2)) return ret;

   321

		// Try to build the road from the depot

   322

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

   323

		// If it fails, ignore it..

   324

		if (CmdFailed(ret2)) return ret;

   325

		ret.AddCost(ret2);

   326

		return ret;

   327

	}

   328

}