summaryrefslogtreecommitdiff
path: root/ai/trolly/build.c
diff options
context:
space:
mode:
Diffstat (limited to 'ai/trolly/build.c')
-rw-r--r--ai/trolly/build.c273
1 files changed, 273 insertions, 0 deletions
diff --git a/ai/trolly/build.c b/ai/trolly/build.c
new file mode 100644
index 000000000..80f0fdf1b
--- /dev/null
+++ b/ai/trolly/build.c
@@ -0,0 +1,273 @@
+/* $Id$ */
+
+#include "../../stdafx.h"
+#include "../../openttd.h"
+#include "../../debug.h"
+#include "../../functions.h"
+#include "../../map.h"
+#include "../../tile.h"
+#include "../../command.h"
+#include "trolly.h"
+#include "../../engine.h"
+#include "../../station.h"
+#include "../../variables.h"
+
+// Build HQ
+// Params:
+// tile : tile where HQ is going to be build
+bool AiNew_Build_CompanyHQ(Player *p, TileIndex tile)
+{
+ if (CmdFailed(DoCommandByTile(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ)))
+ return false;
+ DoCommandByTile(tile, 0, 0, DC_EXEC | DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ);
+ return true;
+}
+
+
+// Build station
+// Params:
+// type : AI_TRAIN/AI_BUS/AI_TRUCK : indicates the type of station
+// tile : tile where station is going to be build
+// length : in case of AI_TRAIN: length of station
+// numtracks : in case of AI_TRAIN: tracks of station
+// direction : the direction of the station
+// flag : flag passed to DoCommand (normally 0 to get the cost or DC_EXEC to build it)
+int AiNew_Build_Station(Player *p, byte type, TileIndex tile, byte length, byte numtracks, byte direction, byte flag)
+{
+ if (type == AI_TRAIN)
+ return DoCommandByTile(tile, direction + (numtracks << 8) + (length << 16), 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_RAILROAD_STATION);
+
+ if (type == AI_BUS)
+ return DoCommandByTile(tile, direction, RS_BUS, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP);
+
+ return DoCommandByTile(tile, direction, RS_TRUCK, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_STOP);
+}
+
+
+// Builds a brdige. The second best out of the ones available for this player
+// Params:
+// tile_a : starting point
+// tile_b : end point
+// flag : flag passed to DoCommand
+int AiNew_Build_Bridge(Player *p, TileIndex tile_a, TileIndex tile_b, byte flag)
+{
+ int bridge_type, bridge_len, type, type2;
+
+ // Find a good bridgetype (the best money can buy)
+ bridge_len = GetBridgeLength(tile_a, tile_b);
+ type = type2 = 0;
+ for (bridge_type = MAX_BRIDGES-1; bridge_type >= 0; bridge_type--) {
+ if (CheckBridge_Stuff(bridge_type, bridge_len)) {
+ type2 = type;
+ type = bridge_type;
+ // We found two bridges, exit
+ if (type2 != 0) break;
+ }
+ }
+ // There is only one bridge that can be build..
+ if (type2 == 0 && type != 0) type2 = type;
+
+ // Now, simply, build the bridge!
+ if (p->ainew.tbt == AI_TRAIN)
+ return DoCommandByTile(tile_a, tile_b, (0<<8) + type2, flag | DC_AUTO, CMD_BUILD_BRIDGE);
+
+ return DoCommandByTile(tile_a, tile_b, (0x80 << 8) + type2, flag | DC_AUTO, CMD_BUILD_BRIDGE);
+}
+
+
+// Build the route part by part
+// Basicly what this function do, is build that amount of parts of the route
+// that go in the same direction. It sets 'part' to the last part of the route builded.
+// The return value is the cost for the builded parts
+//
+// Params:
+// PathFinderInfo : Pointer to the PathFinderInfo used for AiPathFinder
+// part : Which part we need to build
+//
+// TODO: skip already builded road-pieces (e.g.: cityroad)
+int AiNew_Build_RoutePart(Player *p, Ai_PathFinderInfo *PathFinderInfo, byte flag)
+{
+ int part = PathFinderInfo->position;
+ byte *route_extra = PathFinderInfo->route_extra;
+ TileIndex *route = PathFinderInfo->route;
+ int dir;
+ int old_dir = -1;
+ int cost = 0;
+ int res;
+ // We need to calculate the direction with the parent of the parent.. so we skip
+ // the first pieces and the last piece
+ if (part < 1) part = 1;
+ // When we are done, stop it
+ if (part >= PathFinderInfo->route_length - 1) { PathFinderInfo->position = -2; return 0; }
+
+
+ if (PathFinderInfo->rail_or_road) {
+ // Tunnel code
+ if ((AI_PATHFINDER_FLAG_TUNNEL & route_extra[part]) != 0) {
+ cost += DoCommandByTile(route[part], 0, 0, flag, CMD_BUILD_TUNNEL);
+ PathFinderInfo->position++;
+ // TODO: problems!
+ if (CmdFailed(cost)) {
+ DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: tunnel could not be build!");
+ return 0;
+ }
+ return cost;
+ }
+ // Bridge code
+ if ((AI_PATHFINDER_FLAG_BRIDGE & route_extra[part]) != 0) {
+ cost += AiNew_Build_Bridge(p, route[part], route[part-1], flag);
+ PathFinderInfo->position++;
+ // TODO: problems!
+ if (CmdFailed(cost)) {
+ DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: bridge could not be build!");
+ return 0;
+ }
+ return cost;
+ }
+
+ // Build normal rail
+ // Keep it doing till we go an other way
+ if (route_extra[part-1] == 0 && route_extra[part] == 0) {
+ while (route_extra[part] == 0) {
+ // Get the current direction
+ dir = AiNew_GetRailDirection(route[part-1], route[part], route[part+1]);
+ // Is it the same as the last one?
+ if (old_dir != -1 && old_dir != dir) break;
+ old_dir = dir;
+ // Build the tile
+ res = DoCommandByTile(route[part], 0, dir, flag, CMD_BUILD_SINGLE_RAIL);
+ if (CmdFailed(res)) {
+ // Problem.. let's just abort it all!
+ p->ainew.state = AI_STATE_NOTHING;
+ return 0;
+ }
+ cost += res;
+ // Go to the next tile
+ part++;
+ // Check if it is still in range..
+ if (part >= PathFinderInfo->route_length - 1) break;
+ }
+ part--;
+ }
+ // We want to return the last position, so we go back one
+ PathFinderInfo->position = part;
+ } else {
+ // Tunnel code
+ if ((AI_PATHFINDER_FLAG_TUNNEL & route_extra[part]) != 0) {
+ cost += DoCommandByTile(route[part], 0x200, 0, flag, CMD_BUILD_TUNNEL);
+ PathFinderInfo->position++;
+ // TODO: problems!
+ if (CmdFailed(cost)) {
+ DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: tunnel could not be build!");
+ return 0;
+ }
+ return cost;
+ }
+ // Bridge code
+ if ((AI_PATHFINDER_FLAG_BRIDGE & route_extra[part]) != 0) {
+ cost += AiNew_Build_Bridge(p, route[part], route[part+1], flag);
+ PathFinderInfo->position++;
+ // TODO: problems!
+ if (CmdFailed(cost)) {
+ DEBUG(ai,0)("[AiNew - BuildPath] We have a serious problem: bridge could not be build!");
+ return 0;
+ }
+ return cost;
+ }
+
+ // Build normal road
+ // Keep it doing till we go an other way
+ // EnsureNoVehicle makes sure we don't build on a tile where a vehicle is. This way
+ // it will wait till the vehicle is gone..
+ if (route_extra[part-1] == 0 && route_extra[part] == 0 && (flag != DC_EXEC || EnsureNoVehicle(route[part]))) {
+ while (route_extra[part] == 0 && (flag != DC_EXEC || EnsureNoVehicle(route[part]))) {
+ // Get the current direction
+ dir = AiNew_GetRoadDirection(route[part-1], route[part], route[part+1]);
+ // Is it the same as the last one?
+ if (old_dir != -1 && old_dir != dir) break;
+ old_dir = dir;
+ // There is already some road, and it is a bridge.. don't build!!!
+ if (!IsTileType(route[part], MP_TUNNELBRIDGE)) {
+ // Build the tile
+ res = DoCommandByTile(route[part], dir, 0, flag | DC_NO_WATER, CMD_BUILD_ROAD);
+ // Currently, we ignore CMD_ERRORs!
+ if (CmdFailed(res) && flag == DC_EXEC && !IsTileType(route[part], MP_STREET) && !EnsureNoVehicle(route[part])) {
+ // Problem.. let's just abort it all!
+ DEBUG(ai,0)("Darn, the route could not be builded.. aborting!");
+ p->ainew.state = AI_STATE_NOTHING;
+ return 0;
+ }
+
+ if (!CmdFailed(res)) cost += res;
+ }
+ // Go to the next tile
+ part++;
+ // Check if it is still in range..
+ if (part >= PathFinderInfo->route_length - 1) break;
+ }
+ part--;
+ // We want to return the last position, so we go back one
+ }
+ if (!EnsureNoVehicle(route[part]) && flag == DC_EXEC) part--;
+ PathFinderInfo->position = part;
+ }
+
+ return cost;
+}
+
+
+// This functions tries to find the best vehicle for this type of cargo
+// It returns vehicle_id or -1 if not found
+int AiNew_PickVehicle(Player *p)
+{
+ if (p->ainew.tbt == AI_TRAIN) {
+ // Not supported yet
+ return -1;
+ } else {
+ int start, count, i, ret = CMD_ERROR;
+ start = _cargoc.ai_roadveh_start[p->ainew.cargo];
+ count = _cargoc.ai_roadveh_count[p->ainew.cargo];
+
+ // Let's check it backwards.. we simply want to best engine available..
+ for (i=start+count-1;i>=start;i--) {
+ // Is it availiable?
+ // Also, check if the reliability of the vehicle is above the AI_VEHICLE_MIN_RELIABILTY
+ if (!HASBIT(GetEngine(i)->player_avail, _current_player) || GetEngine(i)->reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue;
+ // Can we build it?
+ ret = DoCommandByTile(0, i, 0, DC_QUERY_COST, CMD_BUILD_ROAD_VEH);
+ if (!CmdFailed(ret)) break;
+ }
+ // We did not find a vehicle :(
+ if (CmdFailed(ret)) { return -1; }
+ return i;
+ }
+}
+
+
+// Builds the best vehicle possible
+int AiNew_Build_Vehicle(Player *p, TileIndex tile, byte flag)
+{
+ int i = AiNew_PickVehicle(p);
+ if (i == -1) return CMD_ERROR;
+
+ if (p->ainew.tbt == AI_TRAIN)
+ return CMD_ERROR;
+
+ return DoCommandByTile(tile, i, 0, flag, CMD_BUILD_ROAD_VEH);
+}
+
+int AiNew_Build_Depot(Player *p, TileIndex tile, byte direction, byte flag)
+{
+ static const byte _roadbits_by_dir[4] = {2,1,8,4};
+ int ret, ret2;
+ if (p->ainew.tbt == AI_TRAIN)
+ return DoCommandByTile(tile, 0, direction, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_TRAIN_DEPOT);
+
+ ret = DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_DEPOT);
+ if (CmdFailed(ret)) return ret;
+ // Try to build the road from the depot
+ ret2 = DoCommandByTile(tile + TileOffsByDir(direction), _roadbits_by_dir[direction], 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);
+ // If it fails, ignore it..
+ if (CmdFailed(ret2)) return ret;
+ return ret + ret2;
+}
generated by cgit v1.2.3-70-g09d2 (git 2.47.0) at 2024-11-27 21:44:28 +0000