openttd-ottdgrfs: comparison src/ai/default/default.cpp

equal deleted inserted replaced

-:1ac8aac92385
+:e79cd19772dd
 static EngineID AiChooseTrainToBuild(RailType railtype, int32 money, byte flag, TileIndex tile)
 {
 	EngineID best_veh_index = INVALID_ENGINE;
 	byte best_veh_score = 0;
-	int32 ret;
+	CommandCost ret;
 	EngineID i;
 	for (i = 0; i < NUM_TRAIN_ENGINES; i++) {
 		const RailVehicleInfo *rvi = RailVehInfo(i);
 		const Engine* e = GetEngine(i);
 				e->reliability < 0x8A3D) {
 			continue;
 		}
 		ret = DoCommand(tile, i, 0, 0, CMD_BUILD_RAIL_VEHICLE);
-		if (!CmdFailed(ret) && ret <= money && rvi->ai_rank >= best_veh_score) {
+		if (CmdSucceeded(ret) && ret <= money && rvi->ai_rank >= best_veh_score) {
 			best_veh_score = rvi->ai_rank;
 			best_veh_index = i;
 		}
 	}
 	for (; i != end; i++) {
 		const RoadVehicleInfo *rvi = RoadVehInfo(i);
 		const Engine* e = GetEngine(i);
 		int32 rating;
-		int32 ret;
+		CommandCost ret;
 		if (!HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D) {
 			continue;
 		}
 	int32 best_veh_cost = 0;
 	EngineID i;
 	for (i = AIRCRAFT_ENGINES_INDEX; i != AIRCRAFT_ENGINES_INDEX + NUM_AIRCRAFT_ENGINES; i++) {
 		const Engine* e = GetEngine(i);
-		int32 ret;
+		CommandCost ret;
 		if (!HASBIT(e->player_avail, _current_player) || e->reliability < 0x8A3D) {
 			continue;
 		}
 		if ((AircraftVehInfo(i)->subtype & AIR_CTOL) != flag) continue;
 		ret = DoCommand(0, i, 0, DC_QUERY_COST, CMD_BUILD_AIRCRAFT);
-		if (!CmdFailed(ret) && ret <= money && ret >= best_veh_cost) {
+		if (CmdSucceeded(ret) && ret <= money && ret >= best_veh_cost) {
 			best_veh_cost = ret;
 			best_veh_index = i;
 		}
 	}
 		TileIndex tile;
 		BackupVehicleOrders(v, orderbak);
 		tile = v->tile;
-		if (!CmdFailed(DoCommand(0, v->index, 2, DC_EXEC, CMD_SELL_RAIL_WAGON)) &&
+		if (CmdSucceeded(DoCommand(0, v->index, 2, DC_EXEC, CMD_SELL_RAIL_WAGON)) &&
-				!CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE))) {
+				CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE))) {
 			VehicleID veh = _new_vehicle_id;
 			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);
 			DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_TRAIN);
 			DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
 		TileIndex tile;
 		BackupVehicleOrders(v, orderbak);
 		tile = v->tile;
-		if (!CmdFailed(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH)) &&
+		if (CmdSucceeded(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_ROAD_VEH)) &&
-				!CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH))) {
+				CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_ROAD_VEH))) {
 			VehicleID veh = _new_vehicle_id;
 			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);
 			DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_ROADVEH);
 			DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
 		TileIndex tile;
 		BackupVehicleOrders(v, orderbak);
 		tile = v->tile;
-		if (!CmdFailed(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT)) &&
+		if (CmdSucceeded(DoCommand(0, v->index, 0, DC_EXEC, CMD_SELL_AIRCRAFT)) &&
-				!CmdFailed(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT))) {
+				CmdSucceeded(DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_AIRCRAFT))) {
 			VehicleID veh = _new_vehicle_id;
 			AiRestoreVehicleOrders(GetVehicle(veh), orderbak);
 			DoCommand(0, veh, 0, DC_EXEC, CMD_START_STOP_AIRCRAFT);
 			DoCommand(0, veh, _ai_service_interval, DC_EXEC, CMD_CHANGE_SERVICE_INT);
 	 * AI will have chance of randomly rejecting routes further than 37 tiles from their network,
 	 * so there will be some attempt to cluster the network together */
 	/* Random value between 37 and 292. Low values are exponentially more likely
 	 * With 50% chance the value will be under 52 tiles */
-	int min_distance = 36 + 1 << (Random() % 9); // 0..8
+	int min_distance = 36 + (1 << (Random() % 9)); // 0..8
 	/* Make sure distance to closest station is < min_distance tiles. */
 	if (dist != 0xFFFF && dist > min_distance) return false;
 	if (p->ai.route_type_mask != 0 &&
 	}
 	return true;
 }
-static int32 AiDoBuildDefaultRailTrack(TileIndex tile, const AiDefaultBlockData* p, RailType railtype, byte flag)
+static CommandCost AiDoBuildDefaultRailTrack(TileIndex tile, const AiDefaultBlockData* p, RailType railtype, byte flag)
 {
-	int32 ret;
+	CommandCost ret;
-	int32 total_cost = 0;
+	CommandCost total_cost = 0;
 	Town *t = NULL;
 	int rating = 0;
 	int i, j, k;
 	for (;;) {
 	return total_cost;
 }
 // Returns rule and cost
-static int AiBuildDefaultRailTrack(TileIndex tile, byte p0, byte p1, byte p2, byte p3, byte dir, byte cargo, RailType railtype, int32* cost)
+static int AiBuildDefaultRailTrack(TileIndex tile, byte p0, byte p1, byte p2, byte p3, byte dir, byte cargo, RailType railtype, CommandCost* cost)
 {
 	int i;
 	const AiDefaultRailBlock *p;
 	for (i = 0; (p = _default_rail_track_data[i]) != NULL; i++) {
 		if (p->p0 == p0 && p->p1 == p1 && p->p2 == p2 && p->p3 == p3 &&
 				(p->dir == 0xFF || p->dir == dir || ((p->dir - 1) & 3) == dir)) {
 			*cost = AiDoBuildDefaultRailTrack(tile, p->data, railtype, DC_NO_TOWN_RATING);
-			if (!CmdFailed(*cost) && AiCheckTrackResources(tile, p->data, cargo))
+			if (CmdSucceeded(*cost) && AiCheckTrackResources(tile, p->data, cargo))
 				return i;
 		}
 	}
 	return -1;
 {
 	uint i;
 	int j;
 	AiBuildRec *aib;
 	int rule;
-	int32 cost;
+	CommandCost cost;
 	// time out?
 	if (++p->ai.timeout_counter == 1388) {
 		p->ai.state = AIS_DELETE_RAIL_BLOCKS;
 		return;
 static inline void AiCheckBuildRailTunnelHere(AiRailFinder *arf, TileIndex tile, const byte *p)
 {
 	uint z;
 	if (GetTileSlope(tile, &z) == _dir_table_2[p[0] & 3] && z != 0) {
-		int32 cost = DoCommand(tile, arf->player->ai.railtype_to_use, 0, DC_AUTO, CMD_BUILD_TUNNEL);
+		CommandCost cost = DoCommand(tile, arf->player->ai.railtype_to_use, 0, DC_AUTO, CMD_BUILD_TUNNEL);
-		if (!CmdFailed(cost) && cost <= (arf->player->player_money >> 4)) {
+		if (CmdSucceeded(cost) && cost <= (arf->player->player_money >> 4)) {
 			AiBuildRailRecursive(arf, _build_tunnel_endtile, p[0] & 3);
 			if (arf->depth == 1) AiCheckRailPathBetter(arf, p);
 		}
 	}
 }
 		p += 6;
 	} else {
 		do {
 			// Make sure the tile is not in the list of banned tiles and that a rail can be built here.
 			if (!AiIsTileBanned(arf->player, tile, p[0]) &&
-					!CmdFailed(DoCommand(tile, arf->player->ai.railtype_to_use, p[0], DC_AUTO | DC_NO_WATER | DC_NO_RAIL_OVERLAP, CMD_BUILD_SINGLE_RAIL))) {
+					CmdSucceeded(DoCommand(tile, arf->player->ai.railtype_to_use, p[0], DC_AUTO | DC_NO_WATER | DC_NO_RAIL_OVERLAP, CMD_BUILD_SINGLE_RAIL))) {
 				AiBuildRailRecursive(arf, tile, p[1]);
 			}
 			// At the bottom depth?
 			if (arf->depth == 1) AiCheckRailPathBetter(arf, p);
 		 * solve a thing
 		 */
 		for (i = MAX_BRIDGES - 1; i != 0; i--) {
 			if (CheckBridge_Stuff(i, bridge_len)) {
 				int32 cost = DoCommand(arf.bridge_end_tile, p->ai.cur_tile_a, i | (p->ai.railtype_to_use << 8), DC_AUTO, CMD_BUILD_BRIDGE);
-				if (!CmdFailed(cost) && cost < (p->player_money >> 5)) break;
+				if (CmdSucceeded(cost) && cost < (p->player_money >> 5)) break;
 			}
 		}
 		// Build it
 		DoCommand(arf.bridge_end_tile, p->ai.cur_tile_a, i | (p->ai.railtype_to_use << 8), DC_AUTO | DC_EXEC, CMD_BUILD_BRIDGE);
 	const AiDefaultBlockData *ptr;
 	TileIndex tile;
 	EngineID veh;
 	int i;
 	CargoID cargo;
-	int32 cost;
+	CommandCost cost;
 	Vehicle *v;
 	VehicleID loco_id;
 	ptr = _default_rail_track_data[p->ai.src.cur_building_rule]->data;
 	while (ptr->mode != 0) ptr++;
 handle_nocash:
 		// after a while, if AI still doesn't have cash, get out of this block by selling the wagons.
 		if (++p->ai.state_counter == 1000) {
 			for (i = 0; p->ai.wagon_list[i] != INVALID_VEHICLE; i++) {
 				cost = DoCommand(tile, p->ai.wagon_list[i], 0, DC_EXEC, CMD_SELL_RAIL_WAGON);
-				assert(!CmdFailed(cost));
+				assert(CmdSucceeded(cost));
 			}
 			p->ai.state = AIS_0;
 		}
 		return;
 	}
 	// Try to build the locomotive
 	cost = DoCommand(tile, veh, 0, DC_EXEC, CMD_BUILD_RAIL_VEHICLE);
-	assert(!CmdFailed(cost));
+	assert(CmdSucceeded(cost));
 	loco_id = _new_vehicle_id;
 	// Sell a vehicle if the train is double headed.
 	v = GetVehicle(loco_id);
 	if (v->next != NULL) {
 		}
 	}
 }
 static bool _want_road_truck_station;
-static int32 AiDoBuildDefaultRoadBlock(TileIndex tile, const AiDefaultBlockData *p, byte flag);
+static CommandCost AiDoBuildDefaultRoadBlock(TileIndex tile, const AiDefaultBlockData *p, byte flag);
 // Returns rule and cost
-static int AiFindBestDefaultRoadBlock(TileIndex tile, byte direction, byte cargo, int32 *cost)
+static int AiFindBestDefaultRoadBlock(TileIndex tile, byte direction, byte cargo, CommandCost *cost)
 {
 	int i;
 	const AiDefaultRoadBlock *p;
 	_want_road_truck_station = (cargo & 0x7F) != CT_PASSENGERS;
 	for (i = 0; (p = _road_default_block_data[i]) != NULL; i++) {
 		if (p->dir == direction) {
 			*cost = AiDoBuildDefaultRoadBlock(tile, p->data, 0);
-			if (!CmdFailed(*cost) && AiCheckRoadResources(tile, p->data, cargo))
+			if (CmdSucceeded(*cost) && AiCheckRoadResources(tile, p->data, cargo))
 				return i;
 		}
 	}
 	return -1;
 }
-static int32 AiDoBuildDefaultRoadBlock(TileIndex tile, const AiDefaultBlockData *p, byte flag)
+static CommandCost AiDoBuildDefaultRoadBlock(TileIndex tile, const AiDefaultBlockData *p, byte flag)
 {
-	int32 ret;
+	CommandCost ret;
-	int32 total_cost = 0;
+	CommandCost total_cost = 0;
 	Town *t = NULL;
 	int rating = 0;
 	int roadflag = 0;
 	for (;p->mode != 4;p++) {
 {
 	uint i;
 	int j;
 	AiBuildRec *aib;
 	int rule;
-	int32 cost;
+	CommandCost cost;
 	// time out?
 	if (++p->ai.timeout_counter == 1388) {
 		p->ai.state = AIS_DELETE_RAIL_BLOCKS;
 		return;
 				if (++p->ai.state_counter >= 1000) {
 					p->ai.state_counter = 0;
 					p->ai.state_mode = -p->ai.state_mode;
 				}
 			} else if (CheckPlayerHasMoney(cost) && AiCheckBlockDistances(p, aib->use_tile)) {
-				int32 r;
+				CommandCost r;
 				// player has money, build it.
 				aib->cur_building_rule = rule;
 				r = AiDoBuildDefaultRoadBlock(
 					aib->use_tile,
 					_road_default_block_data[rule]->data,
 					DC_EXEC | DC_NO_TOWN_RATING
 				);
-				assert(!CmdFailed(r));
+				assert(CmdSucceeded(r));
 			}
 		} while (++aib, --j);
 	}
 	// check if we're done with all of them
 		ROAD_NW | ROAD_NE,
 		ROAD_SW | ROAD_SE,
 		ROAD_NW | ROAD_SW,
 		ROAD_SE | ROAD_NE
 	};
-	return !CmdFailed(DoCommand(tile, _road_bits[type], 0, flags, CMD_BUILD_ROAD));
+	return CmdSucceeded(DoCommand(tile, _road_bits[type], 0, flags, CMD_BUILD_ROAD));
 }
 static inline void AiCheckBuildRoadBridgeHere(AiRoadFinder *arf, TileIndex tile, const byte *p)
 {
 	Slope tileh;
 static inline void AiCheckBuildRoadTunnelHere(AiRoadFinder *arf, TileIndex tile, const byte *p)
 {
 	uint z;
 	if (GetTileSlope(tile, &z) == _dir_table_2[p[0] & 3] && z != 0) {
-		int32 cost = DoCommand(tile, 0x200, 0, DC_AUTO, CMD_BUILD_TUNNEL);
+		CommandCost cost = DoCommand(tile, 0x200, 0, DC_AUTO, CMD_BUILD_TUNNEL);
-		if (!CmdFailed(cost) && cost <= (arf->player->player_money >> 4)) {
+		if (CmdSucceeded(cost) && cost <= (arf->player->player_money >> 4)) {
 			AiBuildRoadRecursive(arf, _build_tunnel_endtile, p[0] & 3);
 			if (arf->depth == 1)  AiCheckRoadPathBetter(arf, p);
 		}
 	}
 }
 		 * unnecessary to check for worse bridge (i=0), since AI will always build that.
 		 *AI is so fucked up that fixing this small thing will probably not solve a thing
 		 */
 		for (i = 10; i != 0; i--) {
 			if (CheckBridge_Stuff(i, bridge_len)) {
-				int32 cost = DoCommand(tile, p->ai.cur_tile_a, i + ((0x80 | ROADTYPES_ROAD) << 8), DC_AUTO, CMD_BUILD_BRIDGE);
+				CommandCost cost = DoCommand(tile, p->ai.cur_tile_a, i + ((0x80 | ROADTYPES_ROAD) << 8), DC_AUTO, CMD_BUILD_BRIDGE);
-				if (!CmdFailed(cost) && cost < (p->player_money >> 5)) break;
+				if (CmdSucceeded(cost) && cost < (p->player_money >> 5)) break;
 			}
 		}
 		// Build it
 		DoCommand(tile, p->ai.cur_tile_a, i + ((0x80 | ROADTYPES_ROAD) << 8), DC_AUTO | DC_EXEC, CMD_BUILD_BRIDGE);
 	p->ai.state = AIS_BUILD_DEFAULT_AIRPORT_BLOCKS;
 	p->ai.state_mode = 255;
 	p->ai.state_counter = 0;
 }
-static int32 AiDoBuildDefaultAirportBlock(TileIndex tile, const AiDefaultBlockData *p, byte flag)
+static CommandCost AiDoBuildDefaultAirportBlock(TileIndex tile, const AiDefaultBlockData *p, byte flag)
 {
 	uint32 avail_airports = GetValidAirports();
-	int32 total_cost = 0, ret;
+	CommandCost total_cost = 0, ret;
 	for (; p->mode == 0; p++) {
 		if (!HASBIT(avail_airports, p->attr)) return CMD_ERROR;
 		ret = DoCommand(TILE_MASK(tile + ToTileIndexDiff(p->tileoffs)), p->attr, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_AIRPORT);
 		if (CmdFailed(ret)) return CMD_ERROR;
 		}
 	}
 	return true;
 }
-static int AiFindBestDefaultAirportBlock(TileIndex tile, byte cargo, byte heli, int32 *cost)
+static int AiFindBestDefaultAirportBlock(TileIndex tile, byte cargo, byte heli, CommandCost *cost)
 {
 	const AiDefaultBlockData *p;
 	uint i;
 	for (i = 0; (p = _airport_default_block_data[i]) != NULL; i++) {
 		// If we are doing a helicopter service, avoid building
 		// airports where they can't land.
 		if (heli && !(GetAirport(p->attr)->flags & AirportFTAClass::HELICOPTERS)) continue;
 		*cost = AiDoBuildDefaultAirportBlock(tile, p, 0);
-		if (!CmdFailed(*cost) && AiCheckAirportResources(tile, p, cargo))
+		if (CmdSucceeded(*cost) && AiCheckAirportResources(tile, p, cargo))
 			return i;
 	}
 	return -1;
 }
 static void AiStateBuildDefaultAirportBlocks(Player *p)
 {
 	int i, j;
 	AiBuildRec *aib;
 	int rule;
-	int32 cost;
+	CommandCost cost;
 	// time out?
 	if (++p->ai.timeout_counter == 1388) {
 		p->ai.state = AIS_0;
 		return;
 					p->ai.state_counter = 0;
 					p->ai.state_mode = -p->ai.state_mode;
 				}
 			} else if (CheckPlayerHasMoney(cost) && AiCheckBlockDistances(p, aib->use_tile)) {
 				// player has money, build it.
-				int32 r;
+				CommandCost r;
 				aib->cur_building_rule = rule;
 				r = AiDoBuildDefaultAirportBlock(
 					aib->use_tile,
 					_airport_default_block_data[rule],
 					DC_EXEC | DC_NO_TOWN_RATING
 				);
-				assert(!CmdFailed(r));
+				assert(CmdSucceeded(r));
 			}
 		} while (++aib, --j);
 	} while (--i);
 	// check if we're done with all of them

branch	gamebalance
changeset 9913	e79cd19772dd
parent 9912	1ac8aac92385