1

#include "stdafx.h"

     2

#include "ttd.h"

     3

#include "map.h"

     4

#include "command.h"

     5

#include "ai.h"

     6

#include "engine.h"

     7

     8

// Build HQ

     9

//  Params:

    10

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

    11

bool AiNew_Build_CompanyHQ(Player *p, uint tile) {

    12

	if (DoCommandByTile(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ) == CMD_ERROR)

    13

		return false;

    14

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

    15

	return true;

    16

}

    17

    18

// Build station

    19

//  Params:

    20

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

    21

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

    22

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

    23

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

    24

//    direction : the direction of the station

    25

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

    26

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

    27

	if (type == AI_TRAIN)

    28

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

    29

	else if (type == AI_BUS)

    30

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

    31

	else

    32

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

    33

}

    34

    35

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

    36

//  Params:

    37

//   tile_a : starting point

    38

//   tile_b : end point

    39

//   flag : flag passed to DoCommand

    40

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

    41

	int bridge_type, bridge_len, type, type2;

    42

    43

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

    44

	bridge_len = GetBridgeLength(tile_a, tile_b);

    45

	type = type2 = 0;

    46

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

    47

		if (CheckBridge_Stuff(bridge_type, bridge_len)) {

    48

			type2 = type;

    49

			type = bridge_type;

    50

			// We found two bridges, exit

    51

			if (type2 != 0)

    52

				break;

    53

		}

    54

	}

    55

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

    56

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

    57

    58

	// Now, simply, build the bridge!

    59

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

    60

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

    61

	else

    62

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

    63

}

    64

    65

    66

// Build the route part by part

    67

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

    68

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

    69

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

    70

//

    71

//  Params:

    72

//   PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder

    73

//   part : Which part we need to build

    74

//

    75

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

    76

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

    77

    int part = PathFinderInfo->position;

    78

	byte *route_extra = PathFinderInfo->route_extra;

    79

	TileIndex *route = PathFinderInfo->route;

    80

	int dir;

    81

	int old_dir = -1;

    82

	int cost = 0;

    83

	int res;

    84

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

    85

	//  the first pieces and the last piece

    86

	if (part < 1) part = 1;

    87

	// When we are done, stop it

    88

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

    89

    90

    91

	if (PathFinderInfo->rail_or_road) {

    92

		// Tunnel code

    93

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

    94

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

    95

     		PathFinderInfo->position++;

    96

     		// TODO: problems!

    97

     		if (cost == CMD_ERROR) {

    98

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

    99

				return 0;

   100

     		}

   101

     		return cost;

   102

     	}

   103

     	// Bridge code

   104

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

   105

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

   106

     		PathFinderInfo->position++;

   107

     		// TODO: problems!

   108

     		if (cost == CMD_ERROR) {

   109

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

   110

				return 0;

   111

     		}

   112

     		return cost;

   113

     	}

   114

   115

     	// Build normal rail

   116

     	// Keep it doing till we go an other way

   117

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

   118

     		while (route_extra[part] == 0) {

   119

	     		// Get the current direction

   120

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

   121

	     		// Is it the same as the last one?

   122

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

   123

	     		old_dir = dir;

   124

	     		// Build the tile

   125

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

   126

	     		if (res == CMD_ERROR) {

   127

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

   128

	     			p->ainew.state = AI_STATE_NOTHING;

   129

	     			return 0;

   130

	     		}

   131

	     		cost += res;

   132

	     		// Go to the next tile

   133

	     		part++;

   134

	     		// Check if it is still in range..

   135

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

   136

	     	}

   137

	     	part--;

   138

	    }

   139

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

   140

     	PathFinderInfo->position = part;

   141

    } else {

   142

		// Tunnel code

   143

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

   144

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

   145

     		PathFinderInfo->position++;

   146

     		// TODO: problems!

   147

     		if (cost == CMD_ERROR) {

   148

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

   149

				return 0;

   150

     		}

   151

     		return cost;

   152

     	}

   153

     	// Bridge code

   154

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

   155

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

   156

     		PathFinderInfo->position++;

   157

     		// TODO: problems!

   158

     		if (cost == CMD_ERROR) {

   159

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

   160

				return 0;

   161

     		}

   162

     		return cost;

   163

     	}

   164

   165

     	// Build normal road

   166

     	// Keep it doing till we go an other way

   167

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

   168

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

   169

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

   170

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

   171

	     		// Get the current direction

   172

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

   173

	     		// Is it the same as the last one?

   174

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

   175

	     		old_dir = dir;

   176

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

   177

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

   178

	     			// Build the tile

   179

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

   180

	     			// Currently, we ignore CMD_ERRORs!

   181

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

   182

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

   183

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

   184

    	     			p->ainew.state = AI_STATE_NOTHING;

   185

    	     			return 0;

   186

    	     		} else {

   187

    	     			if (res != CMD_ERROR)

   188

    	     				cost += res;

   189

    	     		}

   190

		     	}

   191

	     		// Go to the next tile

   192

	     		part++;

   193

	     		// Check if it is still in range..

   194

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

   195

	     	}

   196

	     	part--;

   197

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

   198

	    }

   199

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

   200

     	PathFinderInfo->position = part;

   201

    }

   202

   203

    return cost;

   204

}

   205

   206

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

   207

// It returns vehicle_id or -1 if not found

   208

int AiNew_PickVehicle(Player *p) {

   209

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

   210

        // Not supported yet

   211

        return -1;

   212

    } else {

   213

        int start, count, i, r = CMD_ERROR;

   214

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

   215

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

   216

   217

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

   218

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

   219

        	// Is it availiable?

   220

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

   221

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

   222

        	// Can we build it?

   223

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

   224

        	if (r != CMD_ERROR) break;

   225

       	}

   226

       	// We did not find a vehicle :(

   227

       	if (r == CMD_ERROR) { return -1; }

   228

       	return i;

   229

    }

   230

}

   231

   232

// Builds the best vehicle possible

   233

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

   234

	int i = AiNew_PickVehicle(p);

   235

	if (i == -1) return CMD_ERROR;

   236

   237

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

   238

		return CMD_ERROR;

   239

	} else {

   240

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

   241

	}

   242

}

   243

   244

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

   245

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

   246

	int r, r2;

   247

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

   248

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

   249

    } else {

   250

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

   251

    	if (r == CMD_ERROR) return r;

   252

    	// Try to build the road from the depot

   253

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

   254

    	// If it fails, ignore it..

   255

    	if (r2 == CMD_ERROR) return r;

   256

    	return r + r2;

   257

    }

   258

}