1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "debug.h"

     4

#include "map.h"

     5

#include "tile.h"

     6

#include "command.h"

     7

#include "ai.h"

     8

#include "engine.h"

     9

#include "station.h"

    10

    11

// Build HQ

    12

//  Params:

    13

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

    14

bool AiNew_Build_CompanyHQ(Player *p, uint tile) {

    15

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

    16

		return false;

    17

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

    18

	return true;

    19

}

    20

    21

// Build station

    22

//  Params:

    23

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

    24

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

    25

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

    26

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

    27

//    direction : the direction of the station

    28

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

    29

int AiNew_Build_Station(Player *p, byte type, uint tile, byte length, byte numtracks, byte direction, byte flag) {

    30

	if (type == AI_TRAIN)

    31

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

    32

    33

	if (type == AI_BUS)

    34

		return DoCommandByTile(tile, direction, RS_BUS, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP);

    35

    36

	return DoCommandByTile(tile, direction, RS_TRUCK, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP);

    37

}

    38

    39

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

    40

//  Params:

    41

//   tile_a : starting point

    42

//   tile_b : end point

    43

//   flag : flag passed to DoCommand

    44

int AiNew_Build_Bridge(Player *p, uint tile_a, uint tile_b, byte flag) {

    45

	int bridge_type, bridge_len, type, type2;

    46

    47

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

    48

	bridge_len = GetBridgeLength(tile_a, tile_b);

    49

	type = type2 = 0;

    50

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

    51

		if (CheckBridge_Stuff(bridge_type, bridge_len)) {

    52

			type2 = type;

    53

			type = bridge_type;

    54

			// We found two bridges, exit

    55

			if (type2 != 0)

    56

				break;

    57

		}

    58

	}

    59

	// There is only one bridge that can be build..

    60

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

    61

    62

	// Now, simply, build the bridge!

    63

	if (p->ainew.tbt == AI_TRAIN)

    64

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

    65

    66

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

    67

}

    68

    69

    70

// Build the route part by part

    71

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

    72

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

    73

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

    74

//

    75

//  Params:

    76

//   PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder

    77

//   part : Which part we need to build

    78

//

    79

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

    80

int AiNew_Build_RoutePart(Player *p, Ai_PathFinderInfo *PathFinderInfo, byte flag) {

    81

    int part = PathFinderInfo->position;

    82

	byte *route_extra = PathFinderInfo->route_extra;

    83

	TileIndex *route = PathFinderInfo->route;

    84

	int dir;

    85

	int old_dir = -1;

    86

	int cost = 0;

    87

	int res;

    88

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

    89

	//  the first pieces and the last piece

    90

	if (part < 1) part = 1;

    91

	// When we are done, stop it

    92

	if (part >= PathFinderInfo->route_length - 1) { PathFinderInfo->position = -2; return 0; }

    93

    94

    95

	if (PathFinderInfo->rail_or_road) {

    96

		// Tunnel code

    97

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

    98

     		cost += DoCommandByTile(route[part], 0, 0, flag, CMD_BUILD_TUNNEL);

    99

     		PathFinderInfo->position++;

   100

     		// TODO: problems!

   101

     		if (CmdFailed(cost)) {

   102

     			DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: tunnel could not be build!");

   103

				return 0;

   104

     		}

   105

     		return cost;

   106

     	}

   107

     	// Bridge code

   108

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

   109

     		cost += AiNew_Build_Bridge(p, route[part], route[part-1], flag);

   110

     		PathFinderInfo->position++;

   111

     		// TODO: problems!

   112

     		if (CmdFailed(cost)) {

   113

     			DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: bridge could not be build!");

   114

				return 0;

   115

     		}

   116

     		return cost;

   117

     	}

   118

   119

     	// Build normal rail

   120

     	// Keep it doing till we go an other way

   121

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

   122

     		while (route_extra[part] == 0) {

   123

	     		// Get the current direction

   124

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

   125

	     		// Is it the same as the last one?

   126

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

   127

	     		old_dir = dir;

   128

	     		// Build the tile

   129

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

   130

	     		if (CmdFailed(res)) {

   131

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

   132

	     			p->ainew.state = AI_STATE_NOTHING;

   133

	     			return 0;

   134

	     		}

   135

	     		cost += res;

   136

	     		// Go to the next tile

   137

	     		part++;

   138

	     		// Check if it is still in range..

   139

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

   140

	     	}

   141

	     	part--;

   142

	    }

   143

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

   144

     	PathFinderInfo->position = part;

   145

    } else {

   146

		// Tunnel code

   147

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

   148

     		cost += DoCommandByTile(route[part], 0x200, 0, flag, CMD_BUILD_TUNNEL);

   149

     		PathFinderInfo->position++;

   150

     		// TODO: problems!

   151

     		if (CmdFailed(cost)) {

   152

     			DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: tunnel could not be build!");

   153

				return 0;

   154

     		}

   155

     		return cost;

   156

     	}

   157

     	// Bridge code

   158

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

   159

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

   160

     		PathFinderInfo->position++;

   161

     		// TODO: problems!

   162

     		if (CmdFailed(cost)) {

   163

     			DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: bridge could not be build!");

   164

				return 0;

   165

     		}

   166

     		return cost;

   167

     	}

   168

   169

     	// Build normal road

   170

     	// Keep it doing till we go an other way

   171

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

   172

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

   173

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

   174

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

   175

	     		// Get the current direction

   176

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

   177

	     		// Is it the same as the last one?

   178

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

   179

	     		old_dir = dir;

   180

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

   181

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

   182

	     			// Build the tile

   183

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

   184

	     			// Currently, we ignore CMD_ERRORs!

   185

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

   186

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

   187

							DEBUG(ai,0)("Darn, the route could not be builded.. aborting!");

   188

							p->ainew.state = AI_STATE_NOTHING;

   189

							return 0;

   190

						}

   191

   192

    	     	if (!CmdFailed(res)) cost += res;

   193

		     	}

   194

	     		// Go to the next tile

   195

	     		part++;

   196

	     		// Check if it is still in range..

   197

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

   198

	     	}

   199

	     	part--;

   200

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

   201

	    }

   202

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

   203

     	PathFinderInfo->position = part;

   204

    }

   205

   206

    return cost;

   207

}

   208

   209

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

   210

// It returns vehicle_id or -1 if not found

   211

int AiNew_PickVehicle(Player *p) {

   212

    if (p->ainew.tbt == AI_TRAIN) {

   213

        // Not supported yet

   214

        return -1;

   215

    } else {

   216

        int start, count, i, ret = CMD_ERROR;

   217

        start = _cargoc.ai_roadveh_start[p->ainew.cargo];

   218

        count = _cargoc.ai_roadveh_count[p->ainew.cargo];

   219

   220

        // Let's check it backwards.. we simply want to best engine available..

   221

        for (i=start+count-1;i>=start;i--) {

   222

        	// Is it availiable?

   223

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

   224

        	if (!HASBIT(_engines[i].player_avail, _current_player) || _engines[i].reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue;

   225

        	// Can we build it?

   226

        	ret = DoCommandByTile(0, i, 0, DC_QUERY_COST, CMD_BUILD_ROAD_VEH);

   227

        	if (!CmdFailed(ret)) break;

   228

       	}

   229

       	// We did not find a vehicle :(

   230

       	if (CmdFailed(ret)) { return -1; }

   231

       	return i;

   232

    }

   233

}

   234

   235

// Builds the best vehicle possible

   236

int AiNew_Build_Vehicle(Player *p, uint tile, byte flag) {

   237

	int i = AiNew_PickVehicle(p);

   238

	if (i == -1) return CMD_ERROR;

   239

   240

	if (p->ainew.tbt == AI_TRAIN)

   241

		return CMD_ERROR;

   242

   243

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

   244

}

   245

   246

int AiNew_Build_Depot(Player *p, uint tile, byte direction, byte flag)

   247

{

   248

	static const byte _roadbits_by_dir[4] = {2,1,8,4};

   249

	int ret, ret2;

   250

    if (p->ainew.tbt == AI_TRAIN)

   251

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

   252

   253

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

   254

		if (CmdFailed(ret)) return ret;

   255

		// Try to build the road from the depot

   256

		ret2 = DoCommandByTile(tile + TileOffsByDir(direction), _roadbits_by_dir[direction], 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);

   257

		// If it fails, ignore it..

   258

		if (CmdFailed(ret2)) return ret;

   259

		return ret + ret2;

   260

}