cpp/openttd-patchpack/source Changeset - r110:53d6b3381b04

Changeset - r110:53d6b3381b04

Parent rev.

Child rev.

[Not reviewed]

master

0 9 0

truelight - 20 years ago 2004-08-22 15:56:56
truelight@openttd.org

(svn r111) -Fix: converted all linebreaks to UNIX-linebreak (\n)

9 files changed with 2746 insertions and 2746 deletions:

ai.h

243

ai_build.c

257

ai_new.c

1221

ai_pathfinder.c

457

ai_shared.c

aystar.c

271

industry_cmd.c

network.c

queue.h

203

0 comments (0 inline, 0 general)

ai.h

➞

Show inline comments

 #ifndef AI_H
 #define AI_H
 #include "aystar.h"
 /*
  * These defines can be altered to change the behavoir of the AI
+ *
  * WARNING:
  *   This can also alter the AI in a negative way. I will never claim these settings
  *   are perfect, but don't change them if you don't know what the effect is.
  */
 // How many times it the H multiplied. The higher, the more it will go straight to the
 //   end point. The lower, how more it will find the route with the lowest cost.
 //   also: the lower, the longer it takes before route is calculated..
 #define AI_PATHFINDER_H_MULTIPLER 100
 // How many loops may AyStar do before it stops
 //   0 = infinite
 #define AI_PATHFINDER_LOOPS_PER_TICK 5
 // How long may the AI search for one route?
 //   0 = infinite
 // This number is the number of tiles tested.
 //  It takes (AI_PATHFINDER_MAX_SEARCH_NODES / AI_PATHFINDER_LOOPS_PER_TICK) ticks
 //  to get here.. with 5000 / 10 = 500. 500 / 74 (one day) = 8 days till it aborts
 //   (that is: if the AI is on VERY FAST! :p
 #define AI_PATHFINDER_MAX_SEARCH_NODES 5000
 // If you enable this, the AI is not allowed to make 90degree turns
 #define AI_PATHFINDER_NO_90DEGREES_TURN
 // Below are defines for the g-calculation
 // Standard penalty given to a tile
 #define AI_PATHFINDER_PENALTY 150
 // The penalty given to a tile that is going up
 #define AI_PATHFINDER_TILE_GOES_UP_PENALTY 450
 // Changing direction is a penalty, to prevent curved ways (with that: slow ways)
 #define AI_PATHFINDER_DIRECTION_CHANGE_PENALTY 200
 // Same penalty, only for when road already exists
 #define AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY 50
 // A diagonal track cost the same as a straigh, but a diagonal is faster... so give
 //  a bonus for using diagonal track
 #ifdef AI_PATHFINDER_NO_90DEGREES_TURN
 #define AI_PATHFINDER_DIAGONAL_BONUS 95
 #else
 #define AI_PATHFINDER_DIAGONAL_BONUS 75
 #endif
 // If a roadblock already exists, it gets a bonus
 #define AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS 140
 // To prevent 3 direction changes in 3 tiles, this penalty is given in such situation
 #define AI_PATHFINDER_CURVE_PENALTY 200
 // Penalty a bridge gets per length
 #define AI_PATHFINDER_BRIDGE_PENALTY 180
 // The penalty for a bridge going up
 #define AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY 1000
 // Tunnels are expensive...
 //  Because of that, every tile the cost is increased with 1/8th of his value
 //  This is also true if you are building a tunnel yourself
 #define AI_PATHFINDER_TUNNEL_PENALTY 350
 /*
  * Ai_New defines
  */
 // How long may we search cities and industry for a new route?
 #define AI_LOCATE_ROUTE_MAX_COUNTER 200
 // How many days must there be between building the first station and the second station
 //  within one city. This number is in days and should be more then 4 months.
 #define AI_CHECKCITY_DATE_BETWEEN 180
 // How many cargo is needed for one station in a city?
 #define AI_CHECKCITY_CARGO_PER_STATION 60
 // How much cargo must there not be used in a city before we can build a new station?
 #define AI_CHECKCITY_NEEDED_CARGO 50
 // When there is already a station which takes the same good and the rating of that
 //  city is higher then this numer, we are not going to attempt to build anything
 //  there
 #define AI_CHECKCITY_CARGO_RATING 50
 // But, there is a chance of 1 out of this number, that we do ;)
 #define AI_CHECKCITY_CARGO_RATING_CHANCE 5
 // If a city is too small to contain a station, there is a small chance
 //  that we still do so.. just to make the city bigger!
 #define AI_CHECKCITY_CITY_CHANCE 5
 // This number indicates for every unit of cargo, how many tiles two stations maybe be away
 //  from eachother. In other words: if we have 120 units of cargo in one station, and 120 units
 //  of the cargo in the other station, both stations can be 96 units away from eachother, if the
 //  next number is 0.4.
 #define AI_LOCATEROUTE_BUS_CARGO_DISTANCE 0.4
 #define AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE 0.7
 // In whole tiles, the minimum distance for a truck route
 #define AI_LOCATEROUTE_TRUCK_MIN_DISTANCE 30
 // The amount of tiles in a square from -X to +X that is scanned for a station spot
 //  (so if this number is 10, 20x20 = 400 tiles are scanned for _the_ perfect spot
 // Safe values are between 15 and 5
 #define AI_FINDSTATION_TILE_RANGE 10
 // Building on normal speed goes very fast. Idle this amount of ticks between every
 //  building part. It is calculated like this: (4 - competitor_speed) * num + 1
 //  where competitor_speed is between 0 (very slow) to 4 (very fast)
 #define AI_BUILDPATH_PAUSE 10
 // Minimum % of reliabilty a vehicle has to have before the AI buys it
 #define AI_VEHICLE_MIN_RELIABILTY 60
 // The minimum amount of money a player should always have
 #define AI_MINIMUM_MONEY 15000
 // If the most cheap route is build, how much is it going to cost..
 // This is to prevent the AI from trying to build a route which can not be paid for
 #define AI_MINIMUM_BUS_ROUTE_MONEY 25000
 #define AI_MINIMUM_TRUCK_ROUTE_MONEY 35000
 // The minimum amount of money before we are going to repay any money
 #define AI_MINIMUM_LOAN_REPAY_MONEY 40000
 // How many repays do we do if we have enough money to do so?
 //  Every repay is 10000
 #define AI_LOAN_REPAY 2
 // How much income must we have before paying back a loan? Month-based (and looked at the last month)
 #define AI_MINIMUM_INCOME_FOR_LOAN 7000
 // If there is <num> time as much cargo in the station then the vehicle can handle
 //  reuse the station instead of building a new one!
 #define AI_STATION_REUSE_MULTIPLER 2
 // No more then this amount of vehicles per station..
 #define AI_CHECK_MAX_VEHICLE_PER_STATION 10
 // How many thick between building 2 vehicles
 #define AI_BUILD_VEHICLE_TIME_BETWEEN 74
 /*
  * End of defines
  */
 // This stops 90degrees curves
 static const byte _illegal_curves[6] = {
 , 255, // Horz and vert, don't have the effect
 , // upleft and upright are not valid
 , // downright and downleft are not valid
 , // downleft and upleft are not valid
 , // upright and downright are not valid
 };
 static const TileIndexDiff _tiles_around[4] = {
     TILE_XY(-1,0),
     TILE_XY(0,1),
     TILE_XY(1,0),
     TILE_XY(0,-1),
 };
 enum {
     AI_STATE_STARTUP = 0,
     AI_STATE_FIRST_TIME,
     AI_STATE_NOTHING,
     AI_STATE_WAKE_UP,
     AI_STATE_LOCATE_ROUTE,
     AI_STATE_FIND_STATION,
     AI_STATE_FIND_PATH,
     AI_STATE_FIND_DEPOT,
     AI_STATE_VERIFY_ROUTE,
     AI_STATE_BUILD_STATION,
     AI_STATE_BUILD_PATH,
     AI_STATE_BUILD_DEPOT,
     AI_STATE_BUILD_VEHICLE,
     AI_STATE_GIVE_ORDERS,
     AI_STATE_START_VEHICLE,
     AI_STATE_REPAY_MONEY,
     AI_STATE_ACTION_DONE,
     AI_STATE_STOP, // Temporary function to stop the AI
 };
 // Used for tbt (train/bus/truck)
 enum {
 	AI_TRAIN = 0,
 	AI_BUS,
 	AI_TRUCK,
 };
 enum {
 	AI_ACTION_NONE = 0,
 	AI_ACTION_BUS_ROUTE,
 	AI_ACTION_TRUCK_ROUTE,
 	AI_ACTION_REPAY_LOAN,
 };
 // Used for from_type/to_type
 enum {
     AI_NO_TYPE = 0,
 	AI_CITY,
 	AI_INDUSTRY,
 };
 #define AI_NO_CARGO 0xFF // Means that there is no cargo defined yet (used for industry)
 #define AI_NEED_CARGO 0xFE // Used when the AI needs to find out a cargo for the route
 #define AI_STATION_RANGE TILE_XY(TILE_X_MAX, TILE_Y_MAX)
 #define AI_PATHFINDER_NO_DIRECTION (byte)-1
 // Flags used in user_data
 #define AI_PATHFINDER_FLAG_BRIDGE 1
 #define AI_PATHFINDER_FLAG_TUNNEL 2
 // A macro for mp_street, where 0x20 is depot
 //   mp_tunnelbridge, where 0xf0 is a bridge, and 0x4/0x2 means: roadtunnel/bridge
 #define AI_PATHFINDER_IS_ROAD(tile) ((IS_TILETYPE(tile, MP_STREET) && !(_map5[tile] & 0x20)) || \
 (IS_TILETYPE(tile, MP_TUNNELBRIDGE) && \
 	(((_map5[tile] & 0x80) == 0 && (_map5[tile] & 0x4) == 0x4) || \
 	 ((_map5[tile] & 0x80) != 0 && (_map5[tile] & 0x2) == 0x2))))
 typedef void AiNew_StateFunction(Player *p);
 // ai_new.c
 void AiNewDoGameLoop(Player *p);
 // ai_pathfinder.c
 AyStar *new_AyStar_AiPathFinder(int max_tiles_around, Ai_PathFinderInfo *PathFinderInfo);
 void clean_AyStar_AiPathFinder(AyStar *aystar, Ai_PathFinderInfo *PathFinderInfo);
 // ai_shared.c
 int AiNew_GetRailDirection(uint tile_a, uint tile_b, uint tile_c);
 int AiNew_GetRoadDirection(uint tile_a, uint tile_b, uint tile_c);
 int AiNew_GetDirection(uint tile_a, uint tile_b);
 // ai_build.c
 bool AiNew_Build_CompanyHQ(Player *p, uint tile);
 int AiNew_Build_Station(Player *p, byte type, uint tile, byte length, byte numtracks, byte direction, byte flag);
 int AiNew_Build_Bridge(Player *p, uint tile_a, uint tile_b, byte flag);
 int AiNew_Build_RoutePart(Player *p, Ai_PathFinderInfo *PathFinderInfo, byte flag);
 int AiNew_PickVehicle(Player *p);
 int AiNew_Build_Vehicle(Player *p, uint tile, byte flag);
 int AiNew_Build_Depot(Player *p, uint tile, byte direction, byte flag);
 #endif
 #ifndef AI_H
 #define AI_H
 #include "aystar.h"
 /*
  * These defines can be altered to change the behavoir of the AI
+ *
  * WARNING:
  *   This can also alter the AI in a negative way. I will never claim these settings
  *   are perfect, but don't change them if you don't know what the effect is.
  */
 // How many times it the H multiplied. The higher, the more it will go straight to the
 //   end point. The lower, how more it will find the route with the lowest cost.
 //   also: the lower, the longer it takes before route is calculated..
 #define AI_PATHFINDER_H_MULTIPLER 100
 // How many loops may AyStar do before it stops
 //   0 = infinite
 #define AI_PATHFINDER_LOOPS_PER_TICK 5
 // How long may the AI search for one route?
 //   0 = infinite
 // This number is the number of tiles tested.
 //  It takes (AI_PATHFINDER_MAX_SEARCH_NODES / AI_PATHFINDER_LOOPS_PER_TICK) ticks
 //  to get here.. with 5000 / 10 = 500. 500 / 74 (one day) = 8 days till it aborts
 //   (that is: if the AI is on VERY FAST! :p
 #define AI_PATHFINDER_MAX_SEARCH_NODES 5000
 // If you enable this, the AI is not allowed to make 90degree turns
 #define AI_PATHFINDER_NO_90DEGREES_TURN
 // Below are defines for the g-calculation
 // Standard penalty given to a tile
 #define AI_PATHFINDER_PENALTY 150
 // The penalty given to a tile that is going up
 #define AI_PATHFINDER_TILE_GOES_UP_PENALTY 450
 // Changing direction is a penalty, to prevent curved ways (with that: slow ways)
 #define AI_PATHFINDER_DIRECTION_CHANGE_PENALTY 200
 // Same penalty, only for when road already exists
 #define AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY 50
 // A diagonal track cost the same as a straigh, but a diagonal is faster... so give
 //  a bonus for using diagonal track
 #ifdef AI_PATHFINDER_NO_90DEGREES_TURN
 #define AI_PATHFINDER_DIAGONAL_BONUS 95
 #else
 #define AI_PATHFINDER_DIAGONAL_BONUS 75
 #endif
 // If a roadblock already exists, it gets a bonus
 #define AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS 140
 // To prevent 3 direction changes in 3 tiles, this penalty is given in such situation
 #define AI_PATHFINDER_CURVE_PENALTY 200
 // Penalty a bridge gets per length
 #define AI_PATHFINDER_BRIDGE_PENALTY 180
 // The penalty for a bridge going up
 #define AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY 1000
 // Tunnels are expensive...
 //  Because of that, every tile the cost is increased with 1/8th of his value
 //  This is also true if you are building a tunnel yourself
 #define AI_PATHFINDER_TUNNEL_PENALTY 350
 /*
  * Ai_New defines
  */
 // How long may we search cities and industry for a new route?
 #define AI_LOCATE_ROUTE_MAX_COUNTER 200
 // How many days must there be between building the first station and the second station
 //  within one city. This number is in days and should be more then 4 months.
 #define AI_CHECKCITY_DATE_BETWEEN 180
 // How many cargo is needed for one station in a city?
 #define AI_CHECKCITY_CARGO_PER_STATION 60
 // How much cargo must there not be used in a city before we can build a new station?
 #define AI_CHECKCITY_NEEDED_CARGO 50
 // When there is already a station which takes the same good and the rating of that
 //  city is higher then this numer, we are not going to attempt to build anything
 //  there
 #define AI_CHECKCITY_CARGO_RATING 50
 // But, there is a chance of 1 out of this number, that we do ;)
 #define AI_CHECKCITY_CARGO_RATING_CHANCE 5
 // If a city is too small to contain a station, there is a small chance
 //  that we still do so.. just to make the city bigger!
 #define AI_CHECKCITY_CITY_CHANCE 5
 // This number indicates for every unit of cargo, how many tiles two stations maybe be away
 //  from eachother. In other words: if we have 120 units of cargo in one station, and 120 units
 //  of the cargo in the other station, both stations can be 96 units away from eachother, if the
 //  next number is 0.4.
 #define AI_LOCATEROUTE_BUS_CARGO_DISTANCE 0.4
 #define AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE 0.7
 // In whole tiles, the minimum distance for a truck route
 #define AI_LOCATEROUTE_TRUCK_MIN_DISTANCE 30
 // The amount of tiles in a square from -X to +X that is scanned for a station spot
 //  (so if this number is 10, 20x20 = 400 tiles are scanned for _the_ perfect spot
 // Safe values are between 15 and 5
 #define AI_FINDSTATION_TILE_RANGE 10
 // Building on normal speed goes very fast. Idle this amount of ticks between every
 //  building part. It is calculated like this: (4 - competitor_speed) * num + 1
 //  where competitor_speed is between 0 (very slow) to 4 (very fast)
 #define AI_BUILDPATH_PAUSE 10
 // Minimum % of reliabilty a vehicle has to have before the AI buys it
 #define AI_VEHICLE_MIN_RELIABILTY 60
 // The minimum amount of money a player should always have
 #define AI_MINIMUM_MONEY 15000
 // If the most cheap route is build, how much is it going to cost..
 // This is to prevent the AI from trying to build a route which can not be paid for
 #define AI_MINIMUM_BUS_ROUTE_MONEY 25000
 #define AI_MINIMUM_TRUCK_ROUTE_MONEY 35000
 // The minimum amount of money before we are going to repay any money
 #define AI_MINIMUM_LOAN_REPAY_MONEY 40000
 // How many repays do we do if we have enough money to do so?
 //  Every repay is 10000
 #define AI_LOAN_REPAY 2
 // How much income must we have before paying back a loan? Month-based (and looked at the last month)
 #define AI_MINIMUM_INCOME_FOR_LOAN 7000
 // If there is <num> time as much cargo in the station then the vehicle can handle
 //  reuse the station instead of building a new one!
 #define AI_STATION_REUSE_MULTIPLER 2
 // No more then this amount of vehicles per station..
 #define AI_CHECK_MAX_VEHICLE_PER_STATION 10
 // How many thick between building 2 vehicles
 #define AI_BUILD_VEHICLE_TIME_BETWEEN 74
 /*
  * End of defines
  */
 // This stops 90degrees curves
 static const byte _illegal_curves[6] = {
 , 255, // Horz and vert, don't have the effect
 , // upleft and upright are not valid
 , // downright and downleft are not valid
 , // downleft and upleft are not valid
 , // upright and downright are not valid
 };
 static const TileIndexDiff _tiles_around[4] = {
     TILE_XY(-1,0),
     TILE_XY(0,1),
     TILE_XY(1,0),
     TILE_XY(0,-1),
 };
 enum {
     AI_STATE_STARTUP = 0,
     AI_STATE_FIRST_TIME,
     AI_STATE_NOTHING,
     AI_STATE_WAKE_UP,
     AI_STATE_LOCATE_ROUTE,
     AI_STATE_FIND_STATION,
     AI_STATE_FIND_PATH,
     AI_STATE_FIND_DEPOT,
     AI_STATE_VERIFY_ROUTE,
     AI_STATE_BUILD_STATION,
     AI_STATE_BUILD_PATH,
     AI_STATE_BUILD_DEPOT,
     AI_STATE_BUILD_VEHICLE,
     AI_STATE_GIVE_ORDERS,
     AI_STATE_START_VEHICLE,
     AI_STATE_REPAY_MONEY,
     AI_STATE_ACTION_DONE,
     AI_STATE_STOP, // Temporary function to stop the AI
 };
 // Used for tbt (train/bus/truck)
 enum {
 	AI_TRAIN = 0,
 	AI_BUS,
 	AI_TRUCK,
 };
 enum {
 	AI_ACTION_NONE = 0,
 	AI_ACTION_BUS_ROUTE,
 	AI_ACTION_TRUCK_ROUTE,
 	AI_ACTION_REPAY_LOAN,
 };
 // Used for from_type/to_type
 enum {
     AI_NO_TYPE = 0,
 	AI_CITY,
 	AI_INDUSTRY,
 };
 #define AI_NO_CARGO 0xFF // Means that there is no cargo defined yet (used for industry)
 #define AI_NEED_CARGO 0xFE // Used when the AI needs to find out a cargo for the route
 #define AI_STATION_RANGE TILE_XY(TILE_X_MAX, TILE_Y_MAX)
 #define AI_PATHFINDER_NO_DIRECTION (byte)-1
 // Flags used in user_data
 #define AI_PATHFINDER_FLAG_BRIDGE 1
 #define AI_PATHFINDER_FLAG_TUNNEL 2
 // A macro for mp_street, where 0x20 is depot
 //   mp_tunnelbridge, where 0xf0 is a bridge, and 0x4/0x2 means: roadtunnel/bridge
 #define AI_PATHFINDER_IS_ROAD(tile) ((IS_TILETYPE(tile, MP_STREET) && !(_map5[tile] & 0x20)) || \
 (IS_TILETYPE(tile, MP_TUNNELBRIDGE) && \
 	(((_map5[tile] & 0x80) == 0 && (_map5[tile] & 0x4) == 0x4) || \
 	 ((_map5[tile] & 0x80) != 0 && (_map5[tile] & 0x2) == 0x2))))
 typedef void AiNew_StateFunction(Player *p);
 // ai_new.c
 void AiNewDoGameLoop(Player *p);
 // ai_pathfinder.c
 AyStar *new_AyStar_AiPathFinder(int max_tiles_around, Ai_PathFinderInfo *PathFinderInfo);
 void clean_AyStar_AiPathFinder(AyStar *aystar, Ai_PathFinderInfo *PathFinderInfo);
 // ai_shared.c
 int AiNew_GetRailDirection(uint tile_a, uint tile_b, uint tile_c);
 int AiNew_GetRoadDirection(uint tile_a, uint tile_b, uint tile_c);
 int AiNew_GetDirection(uint tile_a, uint tile_b);
 // ai_build.c
 bool AiNew_Build_CompanyHQ(Player *p, uint tile);
 int AiNew_Build_Station(Player *p, byte type, uint tile, byte length, byte numtracks, byte direction, byte flag);
 int AiNew_Build_Bridge(Player *p, uint tile_a, uint tile_b, byte flag);
 int AiNew_Build_RoutePart(Player *p, Ai_PathFinderInfo *PathFinderInfo, byte flag);
 int AiNew_PickVehicle(Player *p);
 int AiNew_Build_Vehicle(Player *p, uint tile, byte flag);
 int AiNew_Build_Depot(Player *p, uint tile, byte direction, byte flag);
 #endif

ai_build.c

➞

Show inline comments

 #include "stdafx.h"
 #include "ttd.h"
 #include "command.h"
 #include "ai.h"
 #include "engine.h"
 // Build HQ
 //  Params:
 //    tile : tile where HQ is going to be build
 bool AiNew_Build_CompanyHQ(Player *p, uint tile) {
 	if (DoCommandByTile(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ) == CMD_ERROR)
 		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, uint 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);
 	else if (type == AI_BUS)
 		return DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_BUS_STATION);
 	else
 		return DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_TRUCK_STATION);
+}
 // 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, uint tile_a, uint 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);
 	else
 		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 (cost == CMD_ERROR) {
      			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 (cost == CMD_ERROR) {
      			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 (res == CMD_ERROR) {
 	     			// 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 (cost == CMD_ERROR) {
      			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 (cost == CMD_ERROR) {
      			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 (!IS_TILETYPE(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 (res == CMD_ERROR && !IS_TILETYPE(route[part], MP_STREET) && (flag == DC_EXEC && !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;
     	     		} else {
     	     			if (res != CMD_ERROR)
     	     				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, r = 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(_engines[i].player_avail, _current_player) || _engines[i].reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue;
         	// Can we build it?
         	r = DoCommandByTile(0, i, 0, DC_QUERY_COST, CMD_BUILD_ROAD_VEH);
         	if (r != CMD_ERROR) break;
+       	}
        	// We did not find a vehicle :(
        	if (r == CMD_ERROR) { return -1; }
        	return i;
+    }
+}
 // Builds the best vehicle possible
 int AiNew_Build_Vehicle(Player *p, uint tile, byte flag) {
 	int i = AiNew_PickVehicle(p);
 	if (i == -1) return CMD_ERROR;
 	if (p->ainew.tbt == AI_TRAIN) {
 		return CMD_ERROR;
 	} else {
 		return DoCommandByTile(tile, i, 0, flag, CMD_BUILD_ROAD_VEH);
+	}
+}
 int AiNew_Build_Depot(Player *p, uint tile, byte direction, byte flag) {
 	static const byte _roadbits_by_dir[4] = {2,1,8,4};
 	int r, r2;
     if (p->ainew.tbt == AI_TRAIN) {
     	return DoCommandByTile(tile, 0, direction, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_TRAIN_DEPOT);
     } else {
     	r = DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_DEPOT);
     	if (r == CMD_ERROR) return r;
     	// Try to build the road from the depot
     	r2 = DoCommandByTile(tile + _tileoffs_by_dir[direction], _roadbits_by_dir[direction], 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);
     	// If it fails, ignore it..
     	if (r2 == CMD_ERROR) return r;
     	return r + r2;
+    }
+}
 #include "stdafx.h"
 #include "ttd.h"
 #include "command.h"
 #include "ai.h"
 #include "engine.h"
 // Build HQ
 //  Params:
 //    tile : tile where HQ is going to be build
 bool AiNew_Build_CompanyHQ(Player *p, uint tile) {
 	if (DoCommandByTile(tile, 0, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_COMPANY_HQ) == CMD_ERROR)
 		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, uint 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);
 	else if (type == AI_BUS)
 		return DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_BUS_STATION);
 	else
 		return DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_TRUCK_STATION);
+}
 // 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, uint tile_a, uint 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);
 	else
 		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 (cost == CMD_ERROR) {
      			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 (cost == CMD_ERROR) {
      			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 (res == CMD_ERROR) {
 	     			// 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 (cost == CMD_ERROR) {
      			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 (cost == CMD_ERROR) {
      			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 (!IS_TILETYPE(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 (res == CMD_ERROR && !IS_TILETYPE(route[part], MP_STREET) && (flag == DC_EXEC && !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;
     	     		} else {
     	     			if (res != CMD_ERROR)
     	     				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, r = 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(_engines[i].player_avail, _current_player) || _engines[i].reliability * 100 < AI_VEHICLE_MIN_RELIABILTY << 16) continue;
         	// Can we build it?
         	r = DoCommandByTile(0, i, 0, DC_QUERY_COST, CMD_BUILD_ROAD_VEH);
         	if (r != CMD_ERROR) break;
+       	}
        	// We did not find a vehicle :(
        	if (r == CMD_ERROR) { return -1; }
        	return i;
+    }
+}
 // Builds the best vehicle possible
 int AiNew_Build_Vehicle(Player *p, uint tile, byte flag) {
 	int i = AiNew_PickVehicle(p);
 	if (i == -1) return CMD_ERROR;
 	if (p->ainew.tbt == AI_TRAIN) {
 		return CMD_ERROR;
 	} else {
 		return DoCommandByTile(tile, i, 0, flag, CMD_BUILD_ROAD_VEH);
+	}
+}
 int AiNew_Build_Depot(Player *p, uint tile, byte direction, byte flag) {
 	static const byte _roadbits_by_dir[4] = {2,1,8,4};
 	int r, r2;
     if (p->ainew.tbt == AI_TRAIN) {
     	return DoCommandByTile(tile, 0, direction, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_TRAIN_DEPOT);
     } else {
     	r = DoCommandByTile(tile, direction, 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD_DEPOT);
     	if (r == CMD_ERROR) return r;
     	// Try to build the road from the depot
     	r2 = DoCommandByTile(tile + _tileoffs_by_dir[direction], _roadbits_by_dir[direction], 0, flag | DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);
     	// If it fails, ignore it..
     	if (r2 == CMD_ERROR) return r;
     	return r + r2;
+    }
+}

ai_new.c

➞

Show inline comments

 /*
  * Next part is in Dutch, and only here for me, TrueLight, the maker of this new AI
  */
 // TODO: als iemand een vehicle stil zet op een weg waar de AI wil bouwen
 //         doet de AI helemaal niets meer
 // TODO: depot rondjes rijden stom iets dingus
 // TODO: jezelf afvragen of competitor_intelligence op niveau 2 wel meer geld moet opleverne...
 // TODO: als er iets in path komt, bouwt AI gewoon verder :(
 // TODO: mail routes
 /*
  * End of Dutch part
  */
 #include "stdafx.h"
 #include "ttd.h"
 #include "command.h"
 #include "ai.h"
 #include "town.h"
 #include "industry.h"
 #include "station.h"
 #include "engine.h"
 #include "gui.h"
 // This function is called after StartUp. It is the init of an AI
 static void AiNew_State_FirstTime(Player *p) {
     // This assert is used to protect those function from misuse
     //   You have quickly a small mistake in the state-array
     //   With that, everything would go wrong. Finding that, is almost impossible
     //   With this assert, that problem can never happen.
     assert(p->ainew.state == AI_STATE_FIRST_TIME);
 	// We first have to init some things
 	if (_current_player == 1) {
 		ShowErrorMessage(-1, TEMP_AI_IN_PROGRESS, 0, 0);
+	}
 	// The PathFinder (AyStar)
 	// TODO: Maybe when an AI goes bankrupt, this is de-init
 	//  or when coming from a savegame.. should be checked out!
     p->ainew.path_info.start_tile_tl = 0;
     p->ainew.path_info.start_tile_br = 0;
     p->ainew.path_info.end_tile_tl = 0;
     p->ainew.path_info.end_tile_br = 0;
 	p->ainew.pathfinder = new_AyStar_AiPathFinder(12, &p->ainew.path_info);
 	p->ainew.idle = 0;
 	// We ALWAYS start with a bus route.. just some basic money ;)
 	p->ainew.action = AI_ACTION_BUS_ROUTE;
 	// Let's popup the news, and after that, start building..
 	p->ainew.state = AI_STATE_WAKE_UP;
+}
 // This function just waste some time
 //  It keeps it more real. The AI can build on such tempo no normal user
 //  can ever keep up with that. The competitor_speed already delays a bit
 //  but after the AI finished a track it really needs to go to sleep.
 //
 // Let's say, we sleep between one and three days if the AI is put on Very Fast.
 //  This means that on Very Slow it will be between 16 and 48 days.. slow enough?
 static void AiNew_State_Nothing(Player *p) {
     assert(p->ainew.state == AI_STATE_NOTHING);
     // If we are done idling, start over again
     // There go 74 ticks in a day
 	if (p->ainew.idle == 0) p->ainew.idle = RandomRange(74 * 2) + 74;
 	if (--p->ainew.idle == 0) {
 		// We are done idling.. what you say? Let's do something!
 		// I mean.. the next tick ;)
 		p->ainew.state = AI_STATE_WAKE_UP;
+	}
+}
 // This function picks out a task we are going to do.
 //  Currently supported:
 //    - Make new route
 //    - Check route
 //    - Build HQ
 static void AiNew_State_WakeUp(Player *p) {
     int32 money;
     int c;
     assert(p->ainew.state == AI_STATE_WAKE_UP);
 	// First, check if we have a HQ
 	if (p->location_of_house == 0) {
 		// We have no HQ yet, build one on a random place
 		// Random till we found a place for it!
 		// TODO: this should not be on a random place..
 		while (!AiNew_Build_CompanyHQ(p, (Random()&0xFFFF))) { }
 		// Enough for now, but we want to come back here the next time
 		//  so we do not change any status
 		return;
+	}
 	money = p->player_money - AI_MINIMUM_MONEY;
 	// Let's pick an action!
 	if (p->ainew.action == AI_ACTION_NONE) {
 		c = Random() & 0xFF;
 		if (p->current_loan > 0 && p->old_economy[1].income > AI_MINIMUM_INCOME_FOR_LOAN &&
   			c < 10) {
   			p->ainew.action = AI_ACTION_REPAY_LOAN;
 		} else if (c < 100 && !_patches.ai_disable_veh_roadveh) {
 			// Do we have any spots for road-vehicles left open?
 			if (GetFreeUnitNumber(VEH_Road) <= _patches.max_roadveh) {
 				if (c < 65) p->ainew.action = AI_ACTION_TRUCK_ROUTE;
 				else p->ainew.action = AI_ACTION_BUS_ROUTE;
+			}
 		}/* else if (c < 200 && !_patches.ai_disable_veh_train) {
 			if (GetFreeUnitNumber(VEH_Train) <= _patches.max_trains) {
 				p->ainew.action = AI_ACTION_TRAIN_ROUTE;
+			}
 		}*/
+	}
 	if (_patches.ai_disable_veh_roadveh && (
 		p->ainew.action == AI_ACTION_BUS_ROUTE || p->ainew.action == AI_ACTION_TRUCK_ROUTE)) {
 		p->ainew.action = AI_ACTION_NONE;
 		return;
+	}
 	if (_patches.ai_disable_veh_roadveh && (
 		p->ainew.action == AI_ACTION_BUS_ROUTE || p->ainew.action == AI_ACTION_TRUCK_ROUTE)) {
 		p->ainew.action = AI_ACTION_NONE;
 		return;
+	}
 	if (p->ainew.action == AI_ACTION_REPAY_LOAN && money > AI_MINIMUM_LOAN_REPAY_MONEY) {
 		// We start repaying some money..
 		p->ainew.state = AI_STATE_REPAY_MONEY;
 		return;
+	}
 	// It is useless to start finding a route if we don't have enough money
 	//  to build the route anyway..
 	if (p->ainew.action == AI_ACTION_BUS_ROUTE && money > AI_MINIMUM_BUS_ROUTE_MONEY) {
 		if (GetFreeUnitNumber(VEH_Road) > _patches.max_roadveh) {
 			p->ainew.action = AI_ACTION_NONE;
 			return;
+		}
 		p->ainew.cargo = AI_NEED_CARGO;
 		p->ainew.state = AI_STATE_LOCATE_ROUTE;
 		p->ainew.tbt = AI_BUS; // Bus-route
 		return;
+	}
 	if (p->ainew.action == AI_ACTION_TRUCK_ROUTE && money > AI_MINIMUM_TRUCK_ROUTE_MONEY) {
 		if (GetFreeUnitNumber(VEH_Road) > _patches.max_roadveh) {
 			p->ainew.action = AI_ACTION_NONE;
 			return;
+		}
 		p->ainew.cargo = AI_NEED_CARGO;
 		p->ainew.last_id = 0;
 		p->ainew.state = AI_STATE_LOCATE_ROUTE;
 		p->ainew.tbt = AI_TRUCK;
 		return;
+	}
 	p->ainew.state = AI_STATE_NOTHING;
+}
 static void AiNew_State_ActionDone(Player *p) {
     p->ainew.action = AI_ACTION_NONE;
     p->ainew.state = AI_STATE_NOTHING;
+}
 // Check if a city or industry is good enough to start a route there
 static bool AiNew_Check_City_or_Industry(Player *p, int ic, byte type) {
 	if (type == AI_CITY) {
 		Town *t = DEREF_TOWN(ic);
 		Station *st;
 		int count = 0;
 		int j = 0;
 		// We don't like roadconstructions, don't even true such a city
 		if (t->road_build_months != 0) return false;
 		// Check if the rating in a city is high enough
 		//  If not, take a chance if we want to continue
 		if (t->ratings[_current_player] < 0 && CHANCE16(1,4)) return false;
 		if (t->max_pass - t->act_pass < AI_CHECKCITY_NEEDED_CARGO && !CHANCE16(1,AI_CHECKCITY_CITY_CHANCE)) return false;
 		// Check if we have build a station in this town the last 6 months
 		//  else we don't do it. This is done, because stat updates can be slow
 		//  and sometimes it takes up to 4 months before the stats are corectly.
 		//  This way we don't get 12 busstations in one city of 100 population ;)
 		FOR_ALL_STATIONS(st) {
 			// Is it an active station
 			if (st->xy == 0) continue;
 			// Do we own it?
 			if (st->owner == _current_player) {
 				// Are we talking busses?
 				if (p->ainew.tbt == AI_BUS && (FACIL_BUS_STOP & st->facilities) != FACIL_BUS_STOP) continue;
 				// Is it the same city as we are in now?
 				if (st->town != t) continue;
 				// When was this station build?
 				if (_date - st->build_date < AI_CHECKCITY_DATE_BETWEEN) return false;
 				// Cound the amount of stations in this city that we own
 				count++;
 			} else {
 				// We do not own it, request some info about the station
 				//  we want to know if this station gets the same good. If so,
 				//  we want to know its rating. If it is too high, we are not going
 				//  to build there
 				if (!st->goods[CT_PASSENGERS].last_speed) continue;
 				// Is it around our city
 				if (GetTileDist(st->xy, t->xy) > 10) continue;
 				// It does take this cargo.. what is his rating?
 				if (st->goods[CT_PASSENGERS].rating < AI_CHECKCITY_CARGO_RATING) continue;
 				j++;
 				// When this is the first station, we build a second with no problem ;)
 				if (j == 1) continue;
 				// The rating is high.. second station...
 				//  a little chance that we still continue
 				//  But if there are 3 stations of this size, we never go on...
 				if (j == 2 && CHANCE16(1, AI_CHECKCITY_CARGO_RATING_CHANCE)) continue;
 				// We don't like this station :(
 				return false;
+			}
+		}
 		// We are about to add one...
 		count++;
 		// Check if we the city can provide enough cargo for this amount of stations..
 		if (count * AI_CHECKCITY_CARGO_PER_STATION > t->max_pass) return false;
 		// All check are okay, so we can build here!
 		return true;
+	}
 	if (type == AI_INDUSTRY) {
 		Industry *i = DEREF_INDUSTRY(ic);
 		Station *st;
 		int count = 0;
 		int j = 0;
 		if (i->town != NULL && i->town->ratings[_current_player] < 0 && CHANCE16(1,4)) return false;
 		// No limits on delevering stations!
 		//  Or for industry that does not give anything yet
 		if (i->produced_cargo[0] == 0xFF || i->total_production[0] == 0) return true;
 		if (i->total_production[0] - i->total_transported[0] < AI_CHECKCITY_NEEDED_CARGO) return false;
 		// Check if we have build a station in this town the last 6 months
 		//  else we don't do it. This is done, because stat updates can be slow
 		//  and sometimes it takes up to 4 months before the stats are corectly.
 		FOR_ALL_STATIONS(st) {
 			// Is it an active station
 			if (st->xy == 0) continue;
 			// Do we own it?
 			if (st->owner == _current_player) {
 				// Are we talking trucks?
 				if (p->ainew.tbt == AI_TRUCK && (FACIL_TRUCK_STOP & st->facilities) != FACIL_TRUCK_STOP) continue;
 				// Is it the same city as we are in now?
 				if (st->town != i->town) continue;
 				// When was this station build?
 				if (_date - st->build_date < AI_CHECKCITY_DATE_BETWEEN) return false;
 				// Cound the amount of stations in this city that we own
 				count++;
 			} else {
 				// We do not own it, request some info about the station
 				//  we want to know if this station gets the same good. If so,
 				//  we want to know its rating. If it is too high, we are not going
 				//  to build there
 				if (i->produced_cargo[0] == 0xFF) continue;
 				// It does not take this cargo
 				if (!st->goods[i->produced_cargo[0]].last_speed) continue;
 				// Is it around our industry
 				if (GetTileDist(st->xy, i->xy) > 5) continue;
 				// It does take this cargo.. what is his rating?
 				if (st->goods[i->produced_cargo[0]].rating < AI_CHECKCITY_CARGO_RATING) continue;
 				j++;
 				// The rating is high.. a little chance that we still continue
 				//  But if there are 2 stations of this size, we never go on...
 				if (j == 1 && CHANCE16(1, AI_CHECKCITY_CARGO_RATING_CHANCE)) continue;
 				// We don't like this station :(
 				return false;
+			}
+		}
 		// We are about to add one...
 		count++;
 		// Check if we the city can provide enough cargo for this amount of stations..
 		if (count * AI_CHECKCITY_CARGO_PER_STATION > i->total_production[0]) return false;
 		// All check are okay, so we can build here!
 		return true;
+	}
 	return true;
+}
 // This functions tries to locate a good route
 static void AiNew_State_LocateRoute(Player *p) {
     assert(p->ainew.state == AI_STATE_LOCATE_ROUTE);
     // For now, we only support PASSENGERS, CITY and BUSSES
     // We don't have a route yet
     if (p->ainew.cargo == AI_NEED_CARGO) {
     	p->ainew.new_cost = 0; // No cost yet
     	p->ainew.temp = -1;
     	// Reset the counter
     	p->ainew.counter = 0;
     	p->ainew.from_ic = -1;
     	p->ainew.to_ic = -1;
    	    if (p->ainew.tbt == AI_BUS) {
    	    	// For now we only have a passenger route
    	    	p->ainew.cargo = CT_PASSENGERS;
 	    	// Find a route to cities
 	    	p->ainew.from_type = AI_CITY;
 	    	p->ainew.to_type = AI_CITY;
 		} else if (p->ainew.tbt == AI_TRUCK) {
    	    	p->ainew.cargo = AI_NO_CARGO;
 	    	p->ainew.from_type = AI_INDUSTRY;
 	    	p->ainew.to_type = AI_INDUSTRY;
+		}
     	// Now we are doing initing, we wait one tick
     	return;
+    }
     // Increase the counter and abort if it is taking too long!
     p->ainew.counter++;
     if (p->ainew.counter > AI_LOCATE_ROUTE_MAX_COUNTER) {
         // Switch back to doing nothing!
     	p->ainew.state = AI_STATE_NOTHING;
     	return;
+    }
     // We are going to locate a city from where we are going to connect
     if (p->ainew.from_ic == -1) {
         if (p->ainew.temp == -1) {
         	// First, we pick a random spot to search from
         	if (p->ainew.from_type == AI_CITY)
         		p->ainew.temp = RandomRange(_total_towns);
        		else
         		p->ainew.temp = RandomRange(_total_industries);
+        }
     	if (!AiNew_Check_City_or_Industry(p, p->ainew.temp, p->ainew.from_type)) {
     		// It was not a valid city
     		//  increase the temp with one, and return. We will come back later here
     		//  to try again
     		p->ainew.temp++;
         	if (p->ainew.from_type == AI_CITY) {
         		if (p->ainew.temp >= _total_towns) p->ainew.temp = 0;
         	} else {
         		if (p->ainew.temp >= _total_industries) p->ainew.temp = 0;
+        	}
         	// Don't do an attempt if we are trying the same id as the last time...
         	if (p->ainew.last_id == p->ainew.temp) return;
         	p->ainew.last_id = p->ainew.temp;
     		return;
+    	}
     	// We found a good city/industry, save the data of it
     	p->ainew.from_ic = p->ainew.temp;
     	// Start the next tick with finding a to-city
     	p->ainew.temp = -1;
     	return;
+    }
     // Find a to-city
     if (p->ainew.temp == -1) {
        	// First, we pick a random spot to search to
        	if (p->ainew.to_type == AI_CITY)
        		p->ainew.temp = RandomRange(_total_towns);
        	else
        		p->ainew.temp = RandomRange(_total_industries);
+	}
 	// The same city is not allowed
 	// Also check if the city is valid
    	if (p->ainew.temp != p->ainew.from_ic && AiNew_Check_City_or_Industry(p, p->ainew.temp, p->ainew.to_type)) {
    		// Maybe it is valid..
    		// We need to know if they are not to far apart from eachother..
    		// We do that by checking how much cargo we have to move and how long the route
    		//   is.
    		if (p->ainew.from_type == AI_CITY && p->ainew.tbt == AI_BUS) {
    			int max_cargo = DEREF_TOWN(p->ainew.from_ic)->max_pass + DEREF_TOWN(p->ainew.temp)->max_pass;
    			max_cargo -= DEREF_TOWN(p->ainew.from_ic)->act_pass + DEREF_TOWN(p->ainew.temp)->act_pass;
    			// max_cargo is now the amount of cargo we can move between the two cities
    			// If it is more then the distance, we allow it
    			if (GetTileDist(DEREF_TOWN(p->ainew.from_ic)->xy, DEREF_TOWN(p->ainew.temp)->xy) <= max_cargo * AI_LOCATEROUTE_BUS_CARGO_DISTANCE) {
    				// We found a good city/industry, save the data of it
    				p->ainew.to_ic = p->ainew.temp;
    				p->ainew.state = AI_STATE_FIND_STATION;
    				DEBUG(ai,1)("[AiNew - LocateRoute] Found bus-route of %d tiles long (from %d to %d)",GetTileDist(DEREF_TOWN(p->ainew.from_ic)->xy, DEREF_TOWN(p->ainew.temp)->xy), p->ainew.from_ic, p->ainew.temp);
    				p->ainew.from_tile = 0;
    				p->ainew.to_tile = 0;
    				return;
+   			}
    		} else if (p->ainew.tbt == AI_TRUCK) {
          	bool found = false;
          	int max_cargo = 0;
          	int i;
          	// TODO: in max_cargo, also check other cargo (beside [0])
          	// First we check if the from_ic produces cargo that this ic accepts
          	if (DEREF_INDUSTRY(p->ainew.from_ic)->produced_cargo[0] != 0xFF && DEREF_INDUSTRY(p->ainew.from_ic)->total_production[0] != 0) {
 	         	for (i=0;i<3;i++) {
 	         		if (DEREF_INDUSTRY(p->ainew.temp)->accepts_cargo[i] == 0xFF) break;
 					if (DEREF_INDUSTRY(p->ainew.from_ic)->produced_cargo[0] == DEREF_INDUSTRY(p->ainew.temp)->accepts_cargo[i]) {
 						// Found a compatbiel industry
 						max_cargo = DEREF_INDUSTRY(p->ainew.from_ic)->total_production[0] - DEREF_INDUSTRY(p->ainew.from_ic)->total_transported[0];
 						found = true;
 	   					p->ainew.from_deliver = true;
 	   					p->ainew.to_deliver = false;
 	       				break;
+	       			}
+	       		}
+   			}
    			if (!found && DEREF_INDUSTRY(p->ainew.temp)->produced_cargo[0] != 0xFF && DEREF_INDUSTRY(p->ainew.temp)->total_production[0] != 0) {
    				// If not check if the current ic produces cargo that the from_ic accepts
 	         	for (i=0;i<3;i++) {
 	         		if (DEREF_INDUSTRY(p->ainew.from_ic)->accepts_cargo[i] == 0xFF) break;
 					if (DEREF_INDUSTRY(p->ainew.temp)->produced_cargo[0] == DEREF_INDUSTRY(p->ainew.from_ic)->accepts_cargo[i]) {
 						// Found a compatbiel industry
 						found = true;
 						max_cargo = DEREF_INDUSTRY(p->ainew.temp)->total_production[0] - DEREF_INDUSTRY(p->ainew.from_ic)->total_transported[0];
 	   					p->ainew.from_deliver = false;
 	   					p->ainew.to_deliver = true;
 	       				break;
+	       			}
+	   			}
+   			}
    			if (found) {
    				// Yeah, they are compatible!!!
    				// Check the length against the amount of goods
    				if (GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy) > AI_LOCATEROUTE_TRUCK_MIN_DISTANCE &&
        				GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy) <= max_cargo * AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE) {
 	   				p->ainew.to_ic = p->ainew.temp;
 	   				if (p->ainew.from_deliver) {
 	   					p->ainew.cargo = DEREF_INDUSTRY(p->ainew.from_ic)->produced_cargo[0];
 	   				} else {
    						p->ainew.cargo = DEREF_INDUSTRY(p->ainew.temp)->produced_cargo[0];
+   					}
 	   				p->ainew.state = AI_STATE_FIND_STATION;
 	   				DEBUG(ai,1)("[AiNew - LocateRoute] Found truck-route of %d tiles long (from %d to %d)",GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy), p->ainew.from_ic, p->ainew.temp);
 	   				p->ainew.from_tile = 0;
 	   				p->ainew.to_tile = 0;
 	   				return;
+	   			}
+   			}
+   		}
+   	}
     // It was not a valid city
    	//  increase the temp with one, and return. We will come back later here
    	//  to try again
    	p->ainew.temp++;
     if (p->ainew.to_type == AI_CITY) {
     	if (p->ainew.temp >= _total_towns) p->ainew.temp = 0;
     } else {
     	if (p->ainew.temp >= _total_industries) p->ainew.temp = 0;
+    }
    	// Don't do an attempt if we are trying the same id as the last time...
    	if (p->ainew.last_id == p->ainew.temp) return;
    	p->ainew.last_id = p->ainew.temp;
+}
 // Check if there are not more then a certain amount of vehicles pointed to a certain
 //  station. This to prevent 10 busses going to one station, which gives... problems ;)
 static bool AiNew_CheckVehicleStation(Player *p, Station *st) {
 	int count = 0;
 	Vehicle *v;
 	uint16 *sched;
 	uint16 ord;
 	// Also check if we don't have already a lot of busses to this city...
 	FOR_ALL_VEHICLES(v) {
 		if (v->owner == _current_player) {
 			sched = v->schedule_ptr;
 			while (sched != NULL && (ord=*sched++) != 0) {
 				if ((ord & OT_MASK) == OT_GOTO_STATION && DEREF_STATION(ord >> 8) == st) {
 					// This vehicle has this city in his list
 					count++;
+				}
+			}
+		}
+	}
 	if (count > AI_CHECK_MAX_VEHICLE_PER_STATION) return false;
 	return true;
+}
 extern const byte _roadveh_speed[88];
 extern const byte _roadveh_capacity[88];
 // This function finds a good spot for a station
 static void AiNew_State_FindStation(Player *p) {
     TileIndex tile;
     Station *st;
     int i, count = 0;
     TileIndex new_tile = 0;
     byte direction = 0;
     Town *town = NULL;
     Industry *industry = NULL;
     assert(p->ainew.state == AI_STATE_FIND_STATION);
     if (p->ainew.from_tile == 0) {
         // First we scan for a station in the from-city
         if (p->ainew.from_type == AI_CITY) {
         	town = DEREF_TOWN(p->ainew.from_ic);
         	tile = town->xy;
         } else {
         	industry = DEREF_INDUSTRY(p->ainew.from_ic);
         	tile = industry->xy;
+        }
     } else if (p->ainew.to_tile == 0) {
     	// Second we scan for a station in the to-city
         if (p->ainew.to_type == AI_CITY) {
         	town = DEREF_TOWN(p->ainew.to_ic);
         	tile = town->xy;
         } else {
         	industry = DEREF_INDUSTRY(p->ainew.to_ic);
         	tile = industry->xy;
+        }
     } else {
     	// Unsupported request
     	// Go to FIND_PATH
         p->ainew.temp = -1;
         p->ainew.state = AI_STATE_FIND_PATH;
     	return;
+    }
     // First, we are going to look at the stations that already exist inside the city
     //  If there is enough cargo left in the station, we take that station
     //  If that is not possible, and there are more then 2 stations in the city, abort
 	i = AiNew_PickVehicle(p);
 	// Euhmz, this should not happen _EVER_
 	// Quit finding a route...
 	if (i == -1) { p->ainew.state = AI_STATE_NOTHING; return; }
 	FOR_ALL_STATIONS(st) {
 		if (st->xy != 0) {
 			if (st->owner == _current_player) {
 				if (p->ainew.tbt == AI_BUS && (FACIL_BUS_STOP & st->facilities) == FACIL_BUS_STOP) {
 					if (st->town == town) {
 						// Check how much cargo there is left in the station
 						if ((st->goods[p->ainew.cargo].waiting_acceptance & 0xFFF) > _roadveh_capacity[i-ROAD_ENGINES_INDEX] * AI_STATION_REUSE_MULTIPLER) {
 							if (AiNew_CheckVehicleStation(p, st)) {
 								// We did found a station that was good enough!
 								new_tile = st->xy;
 								// Cheap way to get the direction of the station...
 								//  Bus stations save it as 0x47 .. 0x4A, so decrease it with 0x47, and tada!
 								direction = _map5[st->xy] - 0x47;
 								break;
+							}
+						}
 						count++;
+					}
+				}
+			}
+		}
+	}
 	// We are going to add a new station...
 	if (new_tile == 0) count++;
 	// No more then 2 stations allowed in a city
 	//  This is because only the best 2 stations of one cargo do get any cargo
 	if (count > 2) {
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+	}
     if (new_tile == 0 && p->ainew.tbt == AI_BUS) {
 	    uint x, y, i = 0;
 	    int r;
 	    uint best;
 	    uint accepts[NUM_CARGO];
 	    TileIndex found_spot[AI_FINDSTATION_TILE_RANGE*AI_FINDSTATION_TILE_RANGE*4];
 	    uint found_best[AI_FINDSTATION_TILE_RANGE*AI_FINDSTATION_TILE_RANGE*4];
 	    // To find a good spot we scan a range from the center, a get the point
 	    //  where we get the most cargo and where it is buildable.
 	    // TODO: also check for station of myself and make sure we are not
 	    //   taking eachothers passangers away (bad result when it does not)
 	    for (x = GET_TILE_X(tile) - AI_FINDSTATION_TILE_RANGE; x <= GET_TILE_X(tile) + AI_FINDSTATION_TILE_RANGE; x++) {
 	    	for (y = GET_TILE_Y(tile) - AI_FINDSTATION_TILE_RANGE; y <= GET_TILE_Y(tile) + AI_FINDSTATION_TILE_RANGE; y++) {
 	    		new_tile = TILE_XY(x,y);
 	    		if (IS_TILETYPE(new_tile, MP_CLEAR) || IS_TILETYPE(new_tile, MP_TREES)) {
 	    			// This tile we can build on!
 	    			// Check acceptance
 	    			GetAcceptanceAroundTiles(accepts, new_tile, 1, 1);
 	    			// >> 3 == 0 means no cargo
 	    			if (accepts[p->ainew.cargo] >> 3 == 0) continue;
 	    			// See if we can build the station
    	    			r = AiNew_Build_Station(p, p->ainew.tbt, new_tile, 0, 0, 0, DC_QUERY_COST);
    	    			if (r == CMD_ERROR) continue;
 	    			// We can build it, so add it to found_spot
 	    			found_spot[i] = new_tile;
 	    			found_best[i++] = accepts[p->ainew.cargo];
+	    		}
+	    	}
+	    }
 	    // If i is still zero, we did not found anything :(
 	    if (i == 0) {
 	    	p->ainew.state = AI_STATE_NOTHING;
 	    	return;
+	    }
 	    // Go through all the found_best and check which has the highest value
 	    best = 0;
 	    new_tile = 0;
 	    for (x=0;x<i;x++) {
 	    	if (found_best[x] > best ||
 	     		(found_best[x] == best && GetTileDist(tile, new_tile) > GetTileDist(tile, found_spot[x]))) {
 	     		new_tile = found_spot[x];
 	     		best = found_best[x];
+	    	}
+	    }
 		// See how much it is going to cost us...
 		r = AiNew_Build_Station(p, p->ainew.tbt, new_tile, 0, 0, 0, DC_QUERY_COST);
 		p->ainew.new_cost += r;
 		direction = AI_PATHFINDER_NO_DIRECTION;
 	} else if (new_tile == 0 && p->ainew.tbt == AI_TRUCK) {
 		// Truck station locater works differently.. a station can be on any place
 		//  as long as it is in range. So we give back code AI_STATION_RANGE
 		//  so the pathfinder routine can work it out!
 		new_tile = AI_STATION_RANGE;
 		direction = AI_PATHFINDER_NO_DIRECTION;
+	}
 	if (p->ainew.from_tile == 0) {
 	   	p->ainew.from_tile = new_tile;
 	   	p->ainew.from_direction = direction;
 	   	// Now we found thisone, go in for to_tile
 	   	return;
 	} else if (p->ainew.to_tile == 0) {
         p->ainew.to_tile = new_tile;
         p->ainew.to_direction = direction;
         // K, done placing stations!
         p->ainew.temp = -1;
         p->ainew.state = AI_STATE_FIND_PATH;
         return;
+    }
+}
 // We try to find a path between 2 points
 static void AiNew_State_FindPath(Player *p) {
     int r;
     assert(p->ainew.state == AI_STATE_FIND_PATH);
     // First time, init some data
     if (p->ainew.temp == -1) {
     	// Init path_info
     	if (p->ainew.from_tile == AI_STATION_RANGE) {
     		// For truck routes we take a range around the industry
 	    	p->ainew.path_info.start_tile_tl = DEREF_INDUSTRY(p->ainew.from_ic)->xy - TILE_XY(1,1);
 	    	p->ainew.path_info.start_tile_br = DEREF_INDUSTRY(p->ainew.from_ic)->xy + TILE_XY(DEREF_INDUSTRY(p->ainew.from_ic)->width, DEREF_INDUSTRY(p->ainew.from_ic)->height) + TILE_XY(1,1);
 	    	p->ainew.path_info.start_direction = p->ainew.from_direction;
 	    } else {
 	    	p->ainew.path_info.start_tile_tl = p->ainew.from_tile;
 	    	p->ainew.path_info.start_tile_br = p->ainew.from_tile;
 	    	p->ainew.path_info.start_direction = p->ainew.from_direction;
+	    }
 	    if (p->ainew.to_tile == AI_STATION_RANGE) {
 	    	p->ainew.path_info.end_tile_tl = DEREF_INDUSTRY(p->ainew.to_ic)->xy - TILE_XY(1,1);
 	    	p->ainew.path_info.end_tile_br = DEREF_INDUSTRY(p->ainew.to_ic)->xy + TILE_XY(DEREF_INDUSTRY(p->ainew.to_ic)->width, DEREF_INDUSTRY(p->ainew.to_ic)->height) + TILE_XY(1,1);
 	   	    p->ainew.path_info.end_direction = p->ainew.to_direction;
     	} else {
 	   	    p->ainew.path_info.end_tile_tl = p->ainew.to_tile;
 	   	    p->ainew.path_info.end_tile_br = p->ainew.to_tile;
 	   	    p->ainew.path_info.end_direction = p->ainew.to_direction;
+	   	}
 		if (p->ainew.tbt == AI_TRAIN)
 			p->ainew.path_info.rail_or_road = true;
 	   	else
    			p->ainew.path_info.rail_or_road = false;
 		// First, clean the pathfinder with our new begin and endpoints
         clean_AyStar_AiPathFinder(p->ainew.pathfinder, &p->ainew.path_info);
    		p->ainew.temp = 0;
+	}
     // Start the pathfinder
 	r = p->ainew.pathfinder->main(p->ainew.pathfinder);
 	// If it return: no match, stop it...
 	if (r == AYSTAR_NO_PATH) {
 		DEBUG(ai,1)("[AiNew] PathFinder found no route!");
 		// Start all over again...
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+	}
 	if (r == AYSTAR_FOUND_END_NODE) {
 		// We found the end-point
 		p->ainew.temp = -1;
 		p->ainew.state = AI_STATE_FIND_DEPOT;
 		return;
+	}
 	// In any other case, we are still busy finding the route...
+}
 // This function tries to locate a good place for a depot!
 static void AiNew_State_FindDepot(Player *p) {
     // To place the depot, we walk through the route, and if we find a lovely spot (MP_CLEAR, MP_TREES), we place it there..
     // Simple, easy, works!
     // To make the depot stand in the middle of the route, we start from the center..
     // But first we walk through the route see if we can find a depot that is ours
     //  this keeps things nice ;)
 	int g, i, j, r;
 	TileIndex tile;
 	assert(p->ainew.state == AI_STATE_FIND_DEPOT);
 	p->ainew.depot_tile = 0;
 	for (i=2;i<p->ainew.path_info.route_length-2;i++) {
 		tile = p->ainew.path_info.route[i];
 		for (j=0;j<lengthof(_tileoffs_by_dir);j++) {
 			if (IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_STREET)) {
 				// Its a street, test if it is a depot
 				if (_map5[tile + _tileoffs_by_dir[j]] & 0x20) {
 					// We found a depot, is it ours? (TELL ME!!!)
 					if (_map_owner[tile + _tileoffs_by_dir[j]] == _current_player) {
 						// Now, is it pointing to the right direction.........
 						if ((_map5[tile + _tileoffs_by_dir[j]] & 3) == (j ^ 2)) {
 							// Yeah!!!
 							p->ainew.depot_tile = tile + _tileoffs_by_dir[j];
 							p->ainew.depot_direction = j ^ 2; // Reverse direction
 							p->ainew.state = AI_STATE_VERIFY_ROUTE;
 							return;
+						}
+					}
+				}
+			}
+		}
+	}
 	// This routine let depot finding start in the middle, and work his way to the stations
 	// It makes depot placing nicer :)
 	i = p->ainew.path_info.route_length / 2;
 	g = 1;
 	while (i > 1 && i < p->ainew.path_info.route_length - 2) {
 		i += g;
 		g *= -1;
 		(g < 0?g--:g++);
 		if (p->ainew.path_info.route_extra[i] != 0 || p->ainew.path_info.route_extra[i+1] != 0) {
 			// Bridge or tunnel.. we can't place a depot there
 			continue;
+		}
 		tile = p->ainew.path_info.route[i];
 		for (j=0;j<lengthof(_tileoffs_by_dir);j++) {
 			// It may not be placed on the road/rail itself
 			// And because it is not build yet, we can't see it on the tile..
 			// So check the surrounding tiles :)
 			if (tile + _tileoffs_by_dir[j] == p->ainew.path_info.route[i-1] ||
 				tile + _tileoffs_by_dir[j] == p->ainew.path_info.route[i+1]) continue;
 			// Not around a bridge?
 			if (p->ainew.path_info.route_extra[i] != 0) continue;
 			if (IS_TILETYPE(tile, MP_TUNNELBRIDGE)) continue;
 			// Is the terrain clear?
 			if (IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_CLEAR) ||
 				IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_TREES)) {
 				TileInfo ti;
 				FindLandscapeHeightByTile(&ti, tile);
 				// If the current tile is on a slope (tileh != 0) then we do not allow this
 				if (ti.tileh != 0) continue;
 				// Check if everything went okay..
 				r = AiNew_Build_Depot(p, tile + _tileoffs_by_dir[j], j ^ 2, 0);
 				if (r == CMD_ERROR) continue;
 				// Found a spot!
 				p->ainew.new_cost += r;
 				p->ainew.depot_tile = tile + _tileoffs_by_dir[j];
 				p->ainew.depot_direction = j ^ 2; // Reverse direction
 				p->ainew.state = AI_STATE_VERIFY_ROUTE;
 				return;
+			}
+		}
+	}
 	// Failed to find a depot?
 	p->ainew.state = AI_STATE_NOTHING;
+}
 // This function calculates how many vehicles there are needed on this
 //  traject.
 // It works pretty simple: get the length, see how much we move around
 //  and hussle that, and you know how many vehicles there are needed.
 // It returns the cost for the vehicles
 static int AiNew_HowManyVehicles(Player *p) {
 	if (p->ainew.tbt == AI_BUS) {
      	// For bus-routes we look at the time before we are back in the station
 		int i, length, tiles_a_day;
 		int amount;
 		i = AiNew_PickVehicle(p);
 		if (i == -1) return 0;
     	// Passenger run.. how long is the route?
     	length = p->ainew.path_info.route_length;
     	// Calculating tiles a day a vehicle moves is not easy.. this is how it must be done!
     	// ROAD_ENGINES_INDEX is because the first roadveh engine is ROAD_ENGINES_INDEX, and _roadveh_speed starts from 0
     	tiles_a_day = _roadveh_speed[i-ROAD_ENGINES_INDEX] * 74 / 256 / 16;
     	// We want a vehicle in a station once a month at least, so, calculate it!
     	// (the * 2 is because we have 2 stations ;))
     	amount = ((int)(((float)length / (float)tiles_a_day / 30 * 2))) * 2;
     	if (amount == 0) amount = 1;
    		return amount;
 	} else if (p->ainew.tbt == AI_TRUCK) {
      	// For truck-routes we look at the cargo
 		int i, length, amount, tiles_a_day;
 		int max_cargo;
 		i = AiNew_PickVehicle(p);
 		if (i == -1) return 0;
     	// Passenger run.. how long is the route?
     	length = p->ainew.path_info.route_length;
     	// Calculating tiles a day a vehicle moves is not easy.. this is how it must be done!
     	// ROAD_ENGINES_INDEX is because the first roadveh engine is ROAD_ENGINES_INDEX, and _roadveh_speed starts from 0
     	tiles_a_day = _roadveh_speed[i-ROAD_ENGINES_INDEX] * 74 / 256 / 16;
     	if (p->ainew.from_deliver)
     		max_cargo = DEREF_INDUSTRY(p->ainew.from_ic)->total_production[0];
     	else
     		max_cargo = DEREF_INDUSTRY(p->ainew.to_ic)->total_production[0];
     	// This is because moving 60% is more then we can dream of!
     	max_cargo *= 0.6;
     	// We want all the cargo to be gone in a month.. so, we know the cargo it delivers
     	//  we know what the vehicle takes with him, and we know the time it takes him
     	//  to get back here.. now let's do some math!
     	amount = (int)(((float)length / (float)tiles_a_day / 30 * 2) * ((float)max_cargo / (float)_roadveh_capacity[i-ROAD_ENGINES_INDEX]));
     	amount += 1;
     	return amount;
 	} else {
 		// Currently not supported
 		return 0;
+	}
+}
 // This function checks:
 //   - If the route went okay
 //   - Calculates the amount of money needed to build the route
 //   - Calculates how much vehicles needed for the route
 static void AiNew_State_VerifyRoute(Player *p) {
     int res, i;
     assert(p->ainew.state == AI_STATE_VERIFY_ROUTE);
     // Let's calculate the cost of the path..
     //  new_cost already contains the cost of the stations
     p->ainew.path_info.position = -1;
     do {
 	    p->ainew.path_info.position++;
 	    p->ainew.new_cost += AiNew_Build_RoutePart(p, &p->ainew.path_info, DC_QUERY_COST);
 	} while (p->ainew.path_info.position != -2);
 	// Now we know the price of build station + path. Now check how many vehicles
 	//  we need and what the price for that will be
 	res = AiNew_HowManyVehicles(p);
 	// If res == 0, no vehicle was found, or an other problem did occour
 	if (res == 0) {
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+	}
 	p->ainew.amount_veh = res;
 	p->ainew.cur_veh = 0;
 	// Check how much it it going to cost us..
 	for (i=0;i<res;i++) {
 		p->ainew.new_cost += AiNew_Build_Vehicle(p, 0, DC_QUERY_COST);
+	}
 	// Now we know how much the route is going to cost us
 	//  Check if we have enough money for it!
 	if (p->ainew.new_cost > p->player_money - AI_MINIMUM_MONEY) {
 		// Too bad..
 		DEBUG(ai,1)("[AiNew] Can't pay for this route (%d)", p->ainew.new_cost);
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+	}
 	// Now we can build the route, check the direction of the stations!
 	if (p->ainew.from_direction == AI_PATHFINDER_NO_DIRECTION) {
 		p->ainew.from_direction = AiNew_GetDirection(p->ainew.path_info.route[p->ainew.path_info.route_length-1], p->ainew.path_info.route[p->ainew.path_info.route_length-2]);
+	}
 	if (p->ainew.to_direction == AI_PATHFINDER_NO_DIRECTION) {
 		p->ainew.to_direction = AiNew_GetDirection(p->ainew.path_info.route[0], p->ainew.path_info.route[1]);
+	}
 	if (p->ainew.from_tile == AI_STATION_RANGE)
 		p->ainew.from_tile = p->ainew.path_info.route[p->ainew.path_info.route_length-1];
 	if (p->ainew.to_tile == AI_STATION_RANGE)
 		p->ainew.to_tile = p->ainew.path_info.route[0];
 	p->ainew.state = AI_STATE_BUILD_STATION;
 	p->ainew.temp = 0;
 	DEBUG(ai,1)("[AiNew] The route is set and buildable.. going to build it!");
+}
 // Build the stations
 static void AiNew_State_BuildStation(Player *p) {
 	int res = 0;
     assert(p->ainew.state == AI_STATE_BUILD_STATION);
     if (p->ainew.temp == 0) {
     	if (!IS_TILETYPE(p->ainew.from_tile, MP_STATION))
     		res = AiNew_Build_Station(p, p->ainew.tbt, p->ainew.from_tile, 0, 0, p->ainew.from_direction, DC_EXEC);
+   	}
     else {
        	if (!IS_TILETYPE(p->ainew.to_tile, MP_STATION))
        	   	res = AiNew_Build_Station(p, p->ainew.tbt, p->ainew.to_tile, 0, 0, p->ainew.to_direction, DC_EXEC);
     	p->ainew.state = AI_STATE_BUILD_PATH;
+    }
     if (res == CMD_ERROR) {
 		DEBUG(ai,0)("[AiNew - BuildStation] Strange but true... station can not be build!");
 		p->ainew.state = AI_STATE_NOTHING;
 		// If the first station _was_ build, destroy it
 		if (p->ainew.temp != 0)
 			DoCommandByTile(p->ainew.from_tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
 		return;
+    }
     p->ainew.temp++;
+}
 // Build the path
 static void AiNew_State_BuildPath(Player *p) {
 	assert(p->ainew.state == AI_STATE_BUILD_PATH);
 	// p->ainew.temp is set to -1 when this function is called for the first time
 	if (p->ainew.temp == -1) {
 		DEBUG(ai,1)("[AiNew] Starting to build the path..");
 		// Init the counter
 		p->ainew.counter = (4 - _opt.diff.competitor_speed) * AI_BUILDPATH_PAUSE + 1;
 		// Set the position to the startingplace (-1 because in a minute we do ++)
 		p->ainew.path_info.position = -1;
 		// And don't do this again
 		p->ainew.temp = 0;
+	}
 	// Building goes very fast on normal rate, so we are going to slow it down..
 	//  By let the counter count from AI_BUILDPATH_PAUSE to 0, we have a nice way :)
 	if (--p->ainew.counter != 0) return;
 	p->ainew.counter = (4 - _opt.diff.competitor_speed) * AI_BUILDPATH_PAUSE + 1;
 	// Increase the building position
 	p->ainew.path_info.position++;
 	// Build route
 	AiNew_Build_RoutePart(p, &p->ainew.path_info, DC_EXEC);
 	if (p->ainew.path_info.position == -2) {
 		// This means we are done building!
 		if (p->ainew.tbt == AI_TRUCK && !_patches.roadveh_queue) {
 			static const byte _roadbits_by_dir[4] = {2,1,8,4};
         	// If they not queue, they have to go up and down to try again at a station...
         	// We don't want that, so try building some road left or right of the station
         	short dir1, dir2, dir3;
         	TileIndex tile;
         	int i, r;
         	for (i=0;i<2;i++) {
             	if (i == 0) {
             		tile = p->ainew.from_tile + _tileoffs_by_dir[p->ainew.from_direction];
             		dir1 = p->ainew.from_direction - 1;
             		if (dir1 < 0) dir1 = 3;
             		dir2 = p->ainew.from_direction + 1;
             		if (dir2 > 3) dir2 = 0;
             		dir3 = p->ainew.from_direction;
             	} else {
             		tile = p->ainew.to_tile + _tileoffs_by_dir[p->ainew.to_direction];
             		dir1 = p->ainew.to_direction - 1;
             		if (dir1 < 0) dir1 = 3;
             		dir2 = p->ainew.to_direction + 1;
             		if (dir2 > 3) dir2 = 0;
             		dir3 = p->ainew.to_direction;
+            	}
             	DoCommandByTile(tile, _roadbits_by_dir[dir1], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
             	DoCommandByTile(tile, _roadbits_by_dir[dir2], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
             	DoCommandByTile(tile, _roadbits_by_dir[dir3^2], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
             	dir1 = _tileoffs_by_dir[dir1];
             	dir2 = _tileoffs_by_dir[dir2];
             	dir3 = _tileoffs_by_dir[dir3];
             	r = CMD_ERROR;
            		if (IS_TILETYPE(tile+dir1, MP_CLEAR) || IS_TILETYPE(tile+dir1, MP_TREES))
            			r = DoCommandByTile(tile+dir1, AiNew_GetRoadDirection(tile, tile+dir1, tile+dir1+dir1), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
            		if (r != CMD_ERROR)
              		if (IS_TILETYPE(tile+dir1+dir1, MP_CLEAR) || IS_TILETYPE(tile+dir1+dir1, MP_TREES))
              			DoCommandByTile(tile+dir1+dir1, AiNew_GetRoadDirection(tile+dir1, tile+dir1+dir1, tile+dir1+dir1+dir1), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
              	r = CMD_ERROR;
            		if (IS_TILETYPE(tile+dir2, MP_CLEAR) || IS_TILETYPE(tile+dir2, MP_TREES))
            			DoCommandByTile(tile+dir2, AiNew_GetRoadDirection(tile, tile+dir2, tile+dir2+dir2), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
            		if (r != CMD_ERROR)
            			if (IS_TILETYPE(tile+dir2+dir2, MP_CLEAR) || IS_TILETYPE(tile+dir2+dir2, MP_TREES))
            				DoCommandByTile(tile+dir2+dir2, AiNew_GetRoadDirection(tile+dir2, tile+dir2+dir2, tile+dir2+dir2+dir2), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
            		r = CMD_ERROR;
            		if (IS_TILETYPE(tile+dir3, MP_CLEAR) || IS_TILETYPE(tile+dir3, MP_TREES))
            			DoCommandByTile(tile+dir3, AiNew_GetRoadDirection(tile, tile+dir3, tile+dir3+dir3), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
            		if (r != CMD_ERROR)
            			if (IS_TILETYPE(tile+dir3+dir3, MP_CLEAR) || IS_TILETYPE(tile+dir3+dir3, MP_TREES))
            				DoCommandByTile(tile+dir3+dir3, AiNew_GetRoadDirection(tile+dir3, tile+dir3+dir3, tile+dir3+dir3+dir3), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
+            }
+        }
 		DEBUG(ai,1)("[AiNew] Done building the path (cost: %d)", p->ainew.new_cost);
 		p->ainew.state = AI_STATE_BUILD_DEPOT;
+	}
+}
 // Builds the depot
 static void AiNew_State_BuildDepot(Player *p) {
 	int res = 0;
 	assert(p->ainew.state == AI_STATE_BUILD_DEPOT);
 	if (IS_TILETYPE(p->ainew.depot_tile, MP_STREET) && _map5[p->ainew.depot_tile] & 0x20) {
 		if (_map_owner[p->ainew.depot_tile] == _current_player) {
 			// The depot is already builded!
 			p->ainew.state = AI_STATE_BUILD_VEHICLE;
 			return;
 		} else {
 			// There is a depot, but not of our team! :(
 			p->ainew.state = AI_STATE_NOTHING;
 			return;
+		}
+	}
 	// There is a bus on the tile we want to build road on... idle till he is gone! (BAD PERSON! :p)
 	if (!EnsureNoVehicle(p->ainew.depot_tile + _tileoffs_by_dir[p->ainew.depot_direction]))
 		return;
 	res = AiNew_Build_Depot(p, p->ainew.depot_tile, p->ainew.depot_direction, DC_EXEC);
     if (res == CMD_ERROR) {
 		DEBUG(ai,0)("[AiNew - BuildDepot] Strange but true... depot can not be build!");
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+    }
 	p->ainew.state = AI_STATE_BUILD_VEHICLE;
 	p->ainew.idle = 1;
 	p->ainew.veh_main_id = (VehicleID)-1;
+}
 // Build vehicles
 static void AiNew_State_BuildVehicle(Player *p) {
 	int res;
     assert(p->ainew.state == AI_STATE_BUILD_VEHICLE);
     // Check if we need to build a vehicle
     if (p->ainew.amount_veh == 0) {
         // Nope, we are done!
         // This means: we are all done! The route is open.. go back to NOTHING
         //  He will idle some time and it will all start over again.. :)
     	p->ainew.state = AI_STATE_ACTION_DONE;
     	return;
+    }
     if (--p->ainew.idle != 0) return;
     // It is realistic that the AI can only build 1 vehicle a day..
     // This makes sure of that!
     p->ainew.idle = AI_BUILD_VEHICLE_TIME_BETWEEN;
     // Build the vehicle
     res = AiNew_Build_Vehicle(p, p->ainew.depot_tile, DC_EXEC);
     if (res == CMD_ERROR) {
     	// This happens when the AI can't build any more vehicles!
     	p->ainew.state = AI_STATE_NOTHING;
     	return;
+    }
     // Increase the current counter
     p->ainew.cur_veh++;
     // Decrease the total counter
     p->ainew.amount_veh--;
     // Get the new ID
     if (p->ainew.tbt == AI_TRAIN) {
     } else {
         p->ainew.veh_id = _new_roadveh_id;
+    }
     // Go give some orders!
    	p->ainew.state = AI_STATE_GIVE_ORDERS;
+}
 // Put the stations in the order list
 static void AiNew_State_GiveOrders(Player *p) {
     int order, flags;
     assert(p->ainew.state == AI_STATE_GIVE_ORDERS);
     if (p->ainew.veh_main_id != (VehicleID)-1) {
         DoCommandByTile(0, p->ainew.veh_id + (p->ainew.veh_main_id << 16), 0, DC_EXEC, CMD_CLONE_ORDER);
         // Skip the first order if it is a second vehicle
         //  This to make vehicles go different ways..
         if (p->ainew.veh_id & 1)
             DoCommandByTile(0, p->ainew.veh_id, 0, DC_EXEC, CMD_SKIP_ORDER);
         p->ainew.state = AI_STATE_START_VEHICLE;
         return;
     } else {
         p->ainew.veh_main_id = p->ainew.veh_id;
+    }
     // When more then 1 vehicle, we send them to different directions
     order = 0;
     flags = (_map2[p->ainew.from_tile] << 8) | OT_GOTO_STATION;
     if (p->ainew.tbt == AI_TRUCK && p->ainew.from_deliver)
     	flags |= OF_FULL_LOAD;
     DoCommandByTile(0, p->ainew.veh_id + (order << 16), flags, DC_EXEC, CMD_INSERT_ORDER);
     order = 1;
     flags = (_map2[p->ainew.to_tile] << 8) | OT_GOTO_STATION;
     if (p->ainew.tbt == AI_TRUCK && p->ainew.to_deliver)
     	flags |= OF_FULL_LOAD;
     DoCommandByTile(0, p->ainew.veh_id + (order << 16), flags, DC_EXEC, CMD_INSERT_ORDER);
 	// Very handy for AI, goto depot.. but yeah, it needs to be activated ;)
     if (_patches.gotodepot) {
     	order = 2;
 	    flags = (GetDepotByTile(p->ainew.depot_tile) << 8) | OT_GOTO_DEPOT | OF_UNLOAD;
 	    DoCommandByTile(0, p->ainew.veh_id + (order << 16), flags, DC_EXEC, CMD_INSERT_ORDER);
+	}
     // Start the engines!
 	p->ainew.state = AI_STATE_START_VEHICLE;
+}
 // Start the vehicle
 static void AiNew_State_StartVehicle(Player *p) {
 	assert(p->ainew.state == AI_STATE_START_VEHICLE);
 	// 3, 2, 1... go! (give START_STOP command ;))
 	DoCommandByTile(0, p->ainew.veh_id, 0, DC_EXEC, CMD_START_STOP_ROADVEH);
 	// Try to build an other vehicle (that function will stop building when needed)
 	p->ainew.state = AI_STATE_BUILD_VEHICLE;
+}
 // Repays money
 static void AiNew_State_RepayMoney(Player *p) {
     int i;
     for (i=0;i<AI_LOAN_REPAY;i++)
     	DoCommandByTile(0, _current_player, 0, DC_EXEC, CMD_DECREASE_LOAN);
     p->ainew.state = AI_STATE_ACTION_DONE;
+}
 // Using the technique simular to the original AI
 //   Keeps things logical
 // It really should be in the same order as the AI_STATE's are!
 static AiNew_StateFunction* const _ainew_state[] = {
     NULL,
     AiNew_State_FirstTime,
     AiNew_State_Nothing,
     AiNew_State_WakeUp,
     AiNew_State_LocateRoute,
     AiNew_State_FindStation,
     AiNew_State_FindPath,
     AiNew_State_FindDepot,
     AiNew_State_VerifyRoute,
     AiNew_State_BuildStation,
     AiNew_State_BuildPath,
     AiNew_State_BuildDepot,
     AiNew_State_BuildVehicle,
     AiNew_State_GiveOrders,
     AiNew_State_StartVehicle,
     AiNew_State_RepayMoney,
     AiNew_State_ActionDone,
     NULL,
 };
 static void AiNew_OnTick(Player *p) {
     if (_ainew_state[p->ainew.state] != NULL)
 	    _ainew_state[p->ainew.state](p);
+}
 void AiNewDoGameLoop(Player *p) {
     // If it is a human player, it is not an AI, so bubye!
 	if (IS_HUMAN_PLAYER(_current_player))
 		return;
 	if (p->ainew.state == AI_STATE_STARTUP) {
 		// The AI just got alive!
 		p->ainew.state = AI_STATE_FIRST_TIME;
 		p->ainew.tick = 0;
 		// Only startup the AI
 		return;
+	}
 	// We keep a ticker. We use it for competitor_speed
 	p->ainew.tick++;
 	// See what the speed is
 	switch (_opt.diff.competitor_speed) {
 		case 0: // Very slow
 			if (!(p->ainew.tick&8)) return;
 			break;
 		case 1: // Slow
 			if (!(p->ainew.tick&4)) return;
 			break;
 		case 2:
 			if (!(p->ainew.tick&2)) return;
 			break;
 		case 3:
 			if (!(p->ainew.tick&1)) return;
 			break;
 		case 4: // Very fast
 		default: // Cool, a new speed setting.. ;) VERY fast ;)
 			break;
+	}
 	// If we come here, we can do a tick.. do so!
 	AiNew_OnTick(p);
+}
 /*
  * Next part is in Dutch, and only here for me, TrueLight, the maker of this new AI
  */
 // TODO: als iemand een vehicle stil zet op een weg waar de AI wil bouwen
 //         doet de AI helemaal niets meer
 // TODO: depot rondjes rijden stom iets dingus
 // TODO: jezelf afvragen of competitor_intelligence op niveau 2 wel meer geld moet opleverne...
 // TODO: als er iets in path komt, bouwt AI gewoon verder :(
 // TODO: mail routes
 /*
  * End of Dutch part
  */
 #include "stdafx.h"
 #include "ttd.h"
 #include "command.h"
 #include "ai.h"
 #include "town.h"
 #include "industry.h"
 #include "station.h"
 #include "engine.h"
 #include "gui.h"
 // This function is called after StartUp. It is the init of an AI
 static void AiNew_State_FirstTime(Player *p) {
     // This assert is used to protect those function from misuse
     //   You have quickly a small mistake in the state-array
     //   With that, everything would go wrong. Finding that, is almost impossible
     //   With this assert, that problem can never happen.
     assert(p->ainew.state == AI_STATE_FIRST_TIME);
 	// We first have to init some things
 	if (_current_player == 1) {
 		ShowErrorMessage(-1, TEMP_AI_IN_PROGRESS, 0, 0);
+	}
 	// The PathFinder (AyStar)
 	// TODO: Maybe when an AI goes bankrupt, this is de-init
 	//  or when coming from a savegame.. should be checked out!
     p->ainew.path_info.start_tile_tl = 0;
     p->ainew.path_info.start_tile_br = 0;
     p->ainew.path_info.end_tile_tl = 0;
     p->ainew.path_info.end_tile_br = 0;
 	p->ainew.pathfinder = new_AyStar_AiPathFinder(12, &p->ainew.path_info);
 	p->ainew.idle = 0;
 	// We ALWAYS start with a bus route.. just some basic money ;)
 	p->ainew.action = AI_ACTION_BUS_ROUTE;
 	// Let's popup the news, and after that, start building..
 	p->ainew.state = AI_STATE_WAKE_UP;
+}
 // This function just waste some time
 //  It keeps it more real. The AI can build on such tempo no normal user
 //  can ever keep up with that. The competitor_speed already delays a bit
 //  but after the AI finished a track it really needs to go to sleep.
 //
 // Let's say, we sleep between one and three days if the AI is put on Very Fast.
 //  This means that on Very Slow it will be between 16 and 48 days.. slow enough?
 static void AiNew_State_Nothing(Player *p) {
     assert(p->ainew.state == AI_STATE_NOTHING);
     // If we are done idling, start over again
     // There go 74 ticks in a day
 	if (p->ainew.idle == 0) p->ainew.idle = RandomRange(74 * 2) + 74;
 	if (--p->ainew.idle == 0) {
 		// We are done idling.. what you say? Let's do something!
 		// I mean.. the next tick ;)
 		p->ainew.state = AI_STATE_WAKE_UP;
+	}
+}
 // This function picks out a task we are going to do.
 //  Currently supported:
 //    - Make new route
 //    - Check route
 //    - Build HQ
 static void AiNew_State_WakeUp(Player *p) {
     int32 money;
     int c;
     assert(p->ainew.state == AI_STATE_WAKE_UP);
 	// First, check if we have a HQ
 	if (p->location_of_house == 0) {
 		// We have no HQ yet, build one on a random place
 		// Random till we found a place for it!
 		// TODO: this should not be on a random place..
 		while (!AiNew_Build_CompanyHQ(p, (Random()&0xFFFF))) { }
 		// Enough for now, but we want to come back here the next time
 		//  so we do not change any status
 		return;
+	}
 	money = p->player_money - AI_MINIMUM_MONEY;
 	// Let's pick an action!
 	if (p->ainew.action == AI_ACTION_NONE) {
 		c = Random() & 0xFF;
 		if (p->current_loan > 0 && p->old_economy[1].income > AI_MINIMUM_INCOME_FOR_LOAN &&
   			c < 10) {
   			p->ainew.action = AI_ACTION_REPAY_LOAN;
 		} else if (c < 100 && !_patches.ai_disable_veh_roadveh) {
 			// Do we have any spots for road-vehicles left open?
 			if (GetFreeUnitNumber(VEH_Road) <= _patches.max_roadveh) {
 				if (c < 65) p->ainew.action = AI_ACTION_TRUCK_ROUTE;
 				else p->ainew.action = AI_ACTION_BUS_ROUTE;
+			}
 		}/* else if (c < 200 && !_patches.ai_disable_veh_train) {
 			if (GetFreeUnitNumber(VEH_Train) <= _patches.max_trains) {
 				p->ainew.action = AI_ACTION_TRAIN_ROUTE;
+			}
 		}*/
+	}
 	if (_patches.ai_disable_veh_roadveh && (
 		p->ainew.action == AI_ACTION_BUS_ROUTE || p->ainew.action == AI_ACTION_TRUCK_ROUTE)) {
 		p->ainew.action = AI_ACTION_NONE;
 		return;
+	}
 	if (_patches.ai_disable_veh_roadveh && (
 		p->ainew.action == AI_ACTION_BUS_ROUTE || p->ainew.action == AI_ACTION_TRUCK_ROUTE)) {
 		p->ainew.action = AI_ACTION_NONE;
 		return;
+	}
 	if (p->ainew.action == AI_ACTION_REPAY_LOAN && money > AI_MINIMUM_LOAN_REPAY_MONEY) {
 		// We start repaying some money..
 		p->ainew.state = AI_STATE_REPAY_MONEY;
 		return;
+	}
 	// It is useless to start finding a route if we don't have enough money
 	//  to build the route anyway..
 	if (p->ainew.action == AI_ACTION_BUS_ROUTE && money > AI_MINIMUM_BUS_ROUTE_MONEY) {
 		if (GetFreeUnitNumber(VEH_Road) > _patches.max_roadveh) {
 			p->ainew.action = AI_ACTION_NONE;
 			return;
+		}
 		p->ainew.cargo = AI_NEED_CARGO;
 		p->ainew.state = AI_STATE_LOCATE_ROUTE;
 		p->ainew.tbt = AI_BUS; // Bus-route
 		return;
+	}
 	if (p->ainew.action == AI_ACTION_TRUCK_ROUTE && money > AI_MINIMUM_TRUCK_ROUTE_MONEY) {
 		if (GetFreeUnitNumber(VEH_Road) > _patches.max_roadveh) {
 			p->ainew.action = AI_ACTION_NONE;
 			return;
+		}
 		p->ainew.cargo = AI_NEED_CARGO;
 		p->ainew.last_id = 0;
 		p->ainew.state = AI_STATE_LOCATE_ROUTE;
 		p->ainew.tbt = AI_TRUCK;
 		return;
+	}
 	p->ainew.state = AI_STATE_NOTHING;
+}
 static void AiNew_State_ActionDone(Player *p) {
     p->ainew.action = AI_ACTION_NONE;
     p->ainew.state = AI_STATE_NOTHING;
+}
 // Check if a city or industry is good enough to start a route there
 static bool AiNew_Check_City_or_Industry(Player *p, int ic, byte type) {
 	if (type == AI_CITY) {
 		Town *t = DEREF_TOWN(ic);
 		Station *st;
 		int count = 0;
 		int j = 0;
 		// We don't like roadconstructions, don't even true such a city
 		if (t->road_build_months != 0) return false;
 		// Check if the rating in a city is high enough
 		//  If not, take a chance if we want to continue
 		if (t->ratings[_current_player] < 0 && CHANCE16(1,4)) return false;
 		if (t->max_pass - t->act_pass < AI_CHECKCITY_NEEDED_CARGO && !CHANCE16(1,AI_CHECKCITY_CITY_CHANCE)) return false;
 		// Check if we have build a station in this town the last 6 months
 		//  else we don't do it. This is done, because stat updates can be slow
 		//  and sometimes it takes up to 4 months before the stats are corectly.
 		//  This way we don't get 12 busstations in one city of 100 population ;)
 		FOR_ALL_STATIONS(st) {
 			// Is it an active station
 			if (st->xy == 0) continue;
 			// Do we own it?
 			if (st->owner == _current_player) {
 				// Are we talking busses?
 				if (p->ainew.tbt == AI_BUS && (FACIL_BUS_STOP & st->facilities) != FACIL_BUS_STOP) continue;
 				// Is it the same city as we are in now?
 				if (st->town != t) continue;
 				// When was this station build?
 				if (_date - st->build_date < AI_CHECKCITY_DATE_BETWEEN) return false;
 				// Cound the amount of stations in this city that we own
 				count++;
 			} else {
 				// We do not own it, request some info about the station
 				//  we want to know if this station gets the same good. If so,
 				//  we want to know its rating. If it is too high, we are not going
 				//  to build there
 				if (!st->goods[CT_PASSENGERS].last_speed) continue;
 				// Is it around our city
 				if (GetTileDist(st->xy, t->xy) > 10) continue;
 				// It does take this cargo.. what is his rating?
 				if (st->goods[CT_PASSENGERS].rating < AI_CHECKCITY_CARGO_RATING) continue;
 				j++;
 				// When this is the first station, we build a second with no problem ;)
 				if (j == 1) continue;
 				// The rating is high.. second station...
 				//  a little chance that we still continue
 				//  But if there are 3 stations of this size, we never go on...
 				if (j == 2 && CHANCE16(1, AI_CHECKCITY_CARGO_RATING_CHANCE)) continue;
 				// We don't like this station :(
 				return false;
+			}
+		}
 		// We are about to add one...
 		count++;
 		// Check if we the city can provide enough cargo for this amount of stations..
 		if (count * AI_CHECKCITY_CARGO_PER_STATION > t->max_pass) return false;
 		// All check are okay, so we can build here!
 		return true;
+	}
 	if (type == AI_INDUSTRY) {
 		Industry *i = DEREF_INDUSTRY(ic);
 		Station *st;
 		int count = 0;
 		int j = 0;
 		if (i->town != NULL && i->town->ratings[_current_player] < 0 && CHANCE16(1,4)) return false;
 		// No limits on delevering stations!
 		//  Or for industry that does not give anything yet
 		if (i->produced_cargo[0] == 0xFF || i->total_production[0] == 0) return true;
 		if (i->total_production[0] - i->total_transported[0] < AI_CHECKCITY_NEEDED_CARGO) return false;
 		// Check if we have build a station in this town the last 6 months
 		//  else we don't do it. This is done, because stat updates can be slow
 		//  and sometimes it takes up to 4 months before the stats are corectly.
 		FOR_ALL_STATIONS(st) {
 			// Is it an active station
 			if (st->xy == 0) continue;
 			// Do we own it?
 			if (st->owner == _current_player) {
 				// Are we talking trucks?
 				if (p->ainew.tbt == AI_TRUCK && (FACIL_TRUCK_STOP & st->facilities) != FACIL_TRUCK_STOP) continue;
 				// Is it the same city as we are in now?
 				if (st->town != i->town) continue;
 				// When was this station build?
 				if (_date - st->build_date < AI_CHECKCITY_DATE_BETWEEN) return false;
 				// Cound the amount of stations in this city that we own
 				count++;
 			} else {
 				// We do not own it, request some info about the station
 				//  we want to know if this station gets the same good. If so,
 				//  we want to know its rating. If it is too high, we are not going
 				//  to build there
 				if (i->produced_cargo[0] == 0xFF) continue;
 				// It does not take this cargo
 				if (!st->goods[i->produced_cargo[0]].last_speed) continue;
 				// Is it around our industry
 				if (GetTileDist(st->xy, i->xy) > 5) continue;
 				// It does take this cargo.. what is his rating?
 				if (st->goods[i->produced_cargo[0]].rating < AI_CHECKCITY_CARGO_RATING) continue;
 				j++;
 				// The rating is high.. a little chance that we still continue
 				//  But if there are 2 stations of this size, we never go on...
 				if (j == 1 && CHANCE16(1, AI_CHECKCITY_CARGO_RATING_CHANCE)) continue;
 				// We don't like this station :(
 				return false;
+			}
+		}
 		// We are about to add one...
 		count++;
 		// Check if we the city can provide enough cargo for this amount of stations..
 		if (count * AI_CHECKCITY_CARGO_PER_STATION > i->total_production[0]) return false;
 		// All check are okay, so we can build here!
 		return true;
+	}
 	return true;
+}
 // This functions tries to locate a good route
 static void AiNew_State_LocateRoute(Player *p) {
     assert(p->ainew.state == AI_STATE_LOCATE_ROUTE);
     // For now, we only support PASSENGERS, CITY and BUSSES
     // We don't have a route yet
     if (p->ainew.cargo == AI_NEED_CARGO) {
     	p->ainew.new_cost = 0; // No cost yet
     	p->ainew.temp = -1;
     	// Reset the counter
     	p->ainew.counter = 0;
     	p->ainew.from_ic = -1;
     	p->ainew.to_ic = -1;
    	    if (p->ainew.tbt == AI_BUS) {
    	    	// For now we only have a passenger route
    	    	p->ainew.cargo = CT_PASSENGERS;
 	    	// Find a route to cities
 	    	p->ainew.from_type = AI_CITY;
 	    	p->ainew.to_type = AI_CITY;
 		} else if (p->ainew.tbt == AI_TRUCK) {
    	    	p->ainew.cargo = AI_NO_CARGO;
 	    	p->ainew.from_type = AI_INDUSTRY;
 	    	p->ainew.to_type = AI_INDUSTRY;
+		}
     	// Now we are doing initing, we wait one tick
     	return;
+    }
     // Increase the counter and abort if it is taking too long!
     p->ainew.counter++;
     if (p->ainew.counter > AI_LOCATE_ROUTE_MAX_COUNTER) {
         // Switch back to doing nothing!
     	p->ainew.state = AI_STATE_NOTHING;
     	return;
+    }
     // We are going to locate a city from where we are going to connect
     if (p->ainew.from_ic == -1) {
         if (p->ainew.temp == -1) {
         	// First, we pick a random spot to search from
         	if (p->ainew.from_type == AI_CITY)
         		p->ainew.temp = RandomRange(_total_towns);
        		else
         		p->ainew.temp = RandomRange(_total_industries);
+        }
     	if (!AiNew_Check_City_or_Industry(p, p->ainew.temp, p->ainew.from_type)) {
     		// It was not a valid city
     		//  increase the temp with one, and return. We will come back later here
     		//  to try again
     		p->ainew.temp++;
         	if (p->ainew.from_type == AI_CITY) {
         		if (p->ainew.temp >= _total_towns) p->ainew.temp = 0;
         	} else {
         		if (p->ainew.temp >= _total_industries) p->ainew.temp = 0;
+        	}
         	// Don't do an attempt if we are trying the same id as the last time...
         	if (p->ainew.last_id == p->ainew.temp) return;
         	p->ainew.last_id = p->ainew.temp;
     		return;
+    	}
     	// We found a good city/industry, save the data of it
     	p->ainew.from_ic = p->ainew.temp;
     	// Start the next tick with finding a to-city
     	p->ainew.temp = -1;
     	return;
+    }
     // Find a to-city
     if (p->ainew.temp == -1) {
        	// First, we pick a random spot to search to
        	if (p->ainew.to_type == AI_CITY)
        		p->ainew.temp = RandomRange(_total_towns);
        	else
        		p->ainew.temp = RandomRange(_total_industries);
+	}
 	// The same city is not allowed
 	// Also check if the city is valid
    	if (p->ainew.temp != p->ainew.from_ic && AiNew_Check_City_or_Industry(p, p->ainew.temp, p->ainew.to_type)) {
    		// Maybe it is valid..
    		// We need to know if they are not to far apart from eachother..
    		// We do that by checking how much cargo we have to move and how long the route
    		//   is.
    		if (p->ainew.from_type == AI_CITY && p->ainew.tbt == AI_BUS) {
    			int max_cargo = DEREF_TOWN(p->ainew.from_ic)->max_pass + DEREF_TOWN(p->ainew.temp)->max_pass;
    			max_cargo -= DEREF_TOWN(p->ainew.from_ic)->act_pass + DEREF_TOWN(p->ainew.temp)->act_pass;
    			// max_cargo is now the amount of cargo we can move between the two cities
    			// If it is more then the distance, we allow it
    			if (GetTileDist(DEREF_TOWN(p->ainew.from_ic)->xy, DEREF_TOWN(p->ainew.temp)->xy) <= max_cargo * AI_LOCATEROUTE_BUS_CARGO_DISTANCE) {
    				// We found a good city/industry, save the data of it
    				p->ainew.to_ic = p->ainew.temp;
    				p->ainew.state = AI_STATE_FIND_STATION;
    				DEBUG(ai,1)("[AiNew - LocateRoute] Found bus-route of %d tiles long (from %d to %d)",GetTileDist(DEREF_TOWN(p->ainew.from_ic)->xy, DEREF_TOWN(p->ainew.temp)->xy), p->ainew.from_ic, p->ainew.temp);
    				p->ainew.from_tile = 0;
    				p->ainew.to_tile = 0;
    				return;
+   			}
    		} else if (p->ainew.tbt == AI_TRUCK) {
          	bool found = false;
          	int max_cargo = 0;
          	int i;
          	// TODO: in max_cargo, also check other cargo (beside [0])
          	// First we check if the from_ic produces cargo that this ic accepts
          	if (DEREF_INDUSTRY(p->ainew.from_ic)->produced_cargo[0] != 0xFF && DEREF_INDUSTRY(p->ainew.from_ic)->total_production[0] != 0) {
 	         	for (i=0;i<3;i++) {
 	         		if (DEREF_INDUSTRY(p->ainew.temp)->accepts_cargo[i] == 0xFF) break;
 					if (DEREF_INDUSTRY(p->ainew.from_ic)->produced_cargo[0] == DEREF_INDUSTRY(p->ainew.temp)->accepts_cargo[i]) {
 						// Found a compatbiel industry
 						max_cargo = DEREF_INDUSTRY(p->ainew.from_ic)->total_production[0] - DEREF_INDUSTRY(p->ainew.from_ic)->total_transported[0];
 						found = true;
 	   					p->ainew.from_deliver = true;
 	   					p->ainew.to_deliver = false;
 	       				break;
+	       			}
+	       		}
+   			}
    			if (!found && DEREF_INDUSTRY(p->ainew.temp)->produced_cargo[0] != 0xFF && DEREF_INDUSTRY(p->ainew.temp)->total_production[0] != 0) {
    				// If not check if the current ic produces cargo that the from_ic accepts
 	         	for (i=0;i<3;i++) {
 	         		if (DEREF_INDUSTRY(p->ainew.from_ic)->accepts_cargo[i] == 0xFF) break;
 					if (DEREF_INDUSTRY(p->ainew.temp)->produced_cargo[0] == DEREF_INDUSTRY(p->ainew.from_ic)->accepts_cargo[i]) {
 						// Found a compatbiel industry
 						found = true;
 						max_cargo = DEREF_INDUSTRY(p->ainew.temp)->total_production[0] - DEREF_INDUSTRY(p->ainew.from_ic)->total_transported[0];
 	   					p->ainew.from_deliver = false;
 	   					p->ainew.to_deliver = true;
 	       				break;
+	       			}
+	   			}
+   			}
    			if (found) {
    				// Yeah, they are compatible!!!
    				// Check the length against the amount of goods
    				if (GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy) > AI_LOCATEROUTE_TRUCK_MIN_DISTANCE &&
        				GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy) <= max_cargo * AI_LOCATEROUTE_TRUCK_CARGO_DISTANCE) {
 	   				p->ainew.to_ic = p->ainew.temp;
 	   				if (p->ainew.from_deliver) {
 	   					p->ainew.cargo = DEREF_INDUSTRY(p->ainew.from_ic)->produced_cargo[0];
 	   				} else {
    						p->ainew.cargo = DEREF_INDUSTRY(p->ainew.temp)->produced_cargo[0];
+   					}
 	   				p->ainew.state = AI_STATE_FIND_STATION;
 	   				DEBUG(ai,1)("[AiNew - LocateRoute] Found truck-route of %d tiles long (from %d to %d)",GetTileDist(DEREF_INDUSTRY(p->ainew.from_ic)->xy, DEREF_INDUSTRY(p->ainew.temp)->xy), p->ainew.from_ic, p->ainew.temp);
 	   				p->ainew.from_tile = 0;
 	   				p->ainew.to_tile = 0;
 	   				return;
+	   			}
+   			}
+   		}
+   	}
     // It was not a valid city
    	//  increase the temp with one, and return. We will come back later here
    	//  to try again
    	p->ainew.temp++;
     if (p->ainew.to_type == AI_CITY) {
     	if (p->ainew.temp >= _total_towns) p->ainew.temp = 0;
     } else {
     	if (p->ainew.temp >= _total_industries) p->ainew.temp = 0;
+    }
    	// Don't do an attempt if we are trying the same id as the last time...
    	if (p->ainew.last_id == p->ainew.temp) return;
    	p->ainew.last_id = p->ainew.temp;
+}
 // Check if there are not more then a certain amount of vehicles pointed to a certain
 //  station. This to prevent 10 busses going to one station, which gives... problems ;)
 static bool AiNew_CheckVehicleStation(Player *p, Station *st) {
 	int count = 0;
 	Vehicle *v;
 	uint16 *sched;
 	uint16 ord;
 	// Also check if we don't have already a lot of busses to this city...
 	FOR_ALL_VEHICLES(v) {
 		if (v->owner == _current_player) {
 			sched = v->schedule_ptr;
 			while (sched != NULL && (ord=*sched++) != 0) {
 				if ((ord & OT_MASK) == OT_GOTO_STATION && DEREF_STATION(ord >> 8) == st) {
 					// This vehicle has this city in his list
 					count++;
+				}
+			}
+		}
+	}
 	if (count > AI_CHECK_MAX_VEHICLE_PER_STATION) return false;
 	return true;
+}
 extern const byte _roadveh_speed[88];
 extern const byte _roadveh_capacity[88];
 // This function finds a good spot for a station
 static void AiNew_State_FindStation(Player *p) {
     TileIndex tile;
     Station *st;
     int i, count = 0;
     TileIndex new_tile = 0;
     byte direction = 0;
     Town *town = NULL;
     Industry *industry = NULL;
     assert(p->ainew.state == AI_STATE_FIND_STATION);
     if (p->ainew.from_tile == 0) {
         // First we scan for a station in the from-city
         if (p->ainew.from_type == AI_CITY) {
         	town = DEREF_TOWN(p->ainew.from_ic);
         	tile = town->xy;
         } else {
         	industry = DEREF_INDUSTRY(p->ainew.from_ic);
         	tile = industry->xy;
+        }
     } else if (p->ainew.to_tile == 0) {
     	// Second we scan for a station in the to-city
         if (p->ainew.to_type == AI_CITY) {
         	town = DEREF_TOWN(p->ainew.to_ic);
         	tile = town->xy;
         } else {
         	industry = DEREF_INDUSTRY(p->ainew.to_ic);
         	tile = industry->xy;
+        }
     } else {
     	// Unsupported request
     	// Go to FIND_PATH
         p->ainew.temp = -1;
         p->ainew.state = AI_STATE_FIND_PATH;
     	return;
+    }
     // First, we are going to look at the stations that already exist inside the city
     //  If there is enough cargo left in the station, we take that station
     //  If that is not possible, and there are more then 2 stations in the city, abort
 	i = AiNew_PickVehicle(p);
 	// Euhmz, this should not happen _EVER_
 	// Quit finding a route...
 	if (i == -1) { p->ainew.state = AI_STATE_NOTHING; return; }
 	FOR_ALL_STATIONS(st) {
 		if (st->xy != 0) {
 			if (st->owner == _current_player) {
 				if (p->ainew.tbt == AI_BUS && (FACIL_BUS_STOP & st->facilities) == FACIL_BUS_STOP) {
 					if (st->town == town) {
 						// Check how much cargo there is left in the station
 						if ((st->goods[p->ainew.cargo].waiting_acceptance & 0xFFF) > _roadveh_capacity[i-ROAD_ENGINES_INDEX] * AI_STATION_REUSE_MULTIPLER) {
 							if (AiNew_CheckVehicleStation(p, st)) {
 								// We did found a station that was good enough!
 								new_tile = st->xy;
 								// Cheap way to get the direction of the station...
 								//  Bus stations save it as 0x47 .. 0x4A, so decrease it with 0x47, and tada!
 								direction = _map5[st->xy] - 0x47;
 								break;
+							}
+						}
 						count++;
+					}
+				}
+			}
+		}
+	}
 	// We are going to add a new station...
 	if (new_tile == 0) count++;
 	// No more then 2 stations allowed in a city
 	//  This is because only the best 2 stations of one cargo do get any cargo
 	if (count > 2) {
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+	}
     if (new_tile == 0 && p->ainew.tbt == AI_BUS) {
 	    uint x, y, i = 0;
 	    int r;
 	    uint best;
 	    uint accepts[NUM_CARGO];
 	    TileIndex found_spot[AI_FINDSTATION_TILE_RANGE*AI_FINDSTATION_TILE_RANGE*4];
 	    uint found_best[AI_FINDSTATION_TILE_RANGE*AI_FINDSTATION_TILE_RANGE*4];
 	    // To find a good spot we scan a range from the center, a get the point
 	    //  where we get the most cargo and where it is buildable.
 	    // TODO: also check for station of myself and make sure we are not
 	    //   taking eachothers passangers away (bad result when it does not)
 	    for (x = GET_TILE_X(tile) - AI_FINDSTATION_TILE_RANGE; x <= GET_TILE_X(tile) + AI_FINDSTATION_TILE_RANGE; x++) {
 	    	for (y = GET_TILE_Y(tile) - AI_FINDSTATION_TILE_RANGE; y <= GET_TILE_Y(tile) + AI_FINDSTATION_TILE_RANGE; y++) {
 	    		new_tile = TILE_XY(x,y);
 	    		if (IS_TILETYPE(new_tile, MP_CLEAR) || IS_TILETYPE(new_tile, MP_TREES)) {
 	    			// This tile we can build on!
 	    			// Check acceptance
 	    			GetAcceptanceAroundTiles(accepts, new_tile, 1, 1);
 	    			// >> 3 == 0 means no cargo
 	    			if (accepts[p->ainew.cargo] >> 3 == 0) continue;
 	    			// See if we can build the station
    	    			r = AiNew_Build_Station(p, p->ainew.tbt, new_tile, 0, 0, 0, DC_QUERY_COST);
    	    			if (r == CMD_ERROR) continue;
 	    			// We can build it, so add it to found_spot
 	    			found_spot[i] = new_tile;
 	    			found_best[i++] = accepts[p->ainew.cargo];
+	    		}
+	    	}
+	    }
 	    // If i is still zero, we did not found anything :(
 	    if (i == 0) {
 	    	p->ainew.state = AI_STATE_NOTHING;
 	    	return;
+	    }
 	    // Go through all the found_best and check which has the highest value
 	    best = 0;
 	    new_tile = 0;
 	    for (x=0;x<i;x++) {
 	    	if (found_best[x] > best ||
 	     		(found_best[x] == best && GetTileDist(tile, new_tile) > GetTileDist(tile, found_spot[x]))) {
 	     		new_tile = found_spot[x];
 	     		best = found_best[x];
+	    	}
+	    }
 		// See how much it is going to cost us...
 		r = AiNew_Build_Station(p, p->ainew.tbt, new_tile, 0, 0, 0, DC_QUERY_COST);
 		p->ainew.new_cost += r;
 		direction = AI_PATHFINDER_NO_DIRECTION;
 	} else if (new_tile == 0 && p->ainew.tbt == AI_TRUCK) {
 		// Truck station locater works differently.. a station can be on any place
 		//  as long as it is in range. So we give back code AI_STATION_RANGE
 		//  so the pathfinder routine can work it out!
 		new_tile = AI_STATION_RANGE;
 		direction = AI_PATHFINDER_NO_DIRECTION;
+	}
 	if (p->ainew.from_tile == 0) {
 	   	p->ainew.from_tile = new_tile;
 	   	p->ainew.from_direction = direction;
 	   	// Now we found thisone, go in for to_tile
 	   	return;
 	} else if (p->ainew.to_tile == 0) {
         p->ainew.to_tile = new_tile;
         p->ainew.to_direction = direction;
         // K, done placing stations!
         p->ainew.temp = -1;
         p->ainew.state = AI_STATE_FIND_PATH;
         return;
+    }
+}
 // We try to find a path between 2 points
 static void AiNew_State_FindPath(Player *p) {
     int r;
     assert(p->ainew.state == AI_STATE_FIND_PATH);
     // First time, init some data
     if (p->ainew.temp == -1) {
     	// Init path_info
     	if (p->ainew.from_tile == AI_STATION_RANGE) {
     		// For truck routes we take a range around the industry
 	    	p->ainew.path_info.start_tile_tl = DEREF_INDUSTRY(p->ainew.from_ic)->xy - TILE_XY(1,1);
 	    	p->ainew.path_info.start_tile_br = DEREF_INDUSTRY(p->ainew.from_ic)->xy + TILE_XY(DEREF_INDUSTRY(p->ainew.from_ic)->width, DEREF_INDUSTRY(p->ainew.from_ic)->height) + TILE_XY(1,1);
 	    	p->ainew.path_info.start_direction = p->ainew.from_direction;
 	    } else {
 	    	p->ainew.path_info.start_tile_tl = p->ainew.from_tile;
 	    	p->ainew.path_info.start_tile_br = p->ainew.from_tile;
 	    	p->ainew.path_info.start_direction = p->ainew.from_direction;
+	    }
 	    if (p->ainew.to_tile == AI_STATION_RANGE) {
 	    	p->ainew.path_info.end_tile_tl = DEREF_INDUSTRY(p->ainew.to_ic)->xy - TILE_XY(1,1);
 	    	p->ainew.path_info.end_tile_br = DEREF_INDUSTRY(p->ainew.to_ic)->xy + TILE_XY(DEREF_INDUSTRY(p->ainew.to_ic)->width, DEREF_INDUSTRY(p->ainew.to_ic)->height) + TILE_XY(1,1);
 	   	    p->ainew.path_info.end_direction = p->ainew.to_direction;
     	} else {
 	   	    p->ainew.path_info.end_tile_tl = p->ainew.to_tile;
 	   	    p->ainew.path_info.end_tile_br = p->ainew.to_tile;
 	   	    p->ainew.path_info.end_direction = p->ainew.to_direction;
+	   	}
 		if (p->ainew.tbt == AI_TRAIN)
 			p->ainew.path_info.rail_or_road = true;
 	   	else
    			p->ainew.path_info.rail_or_road = false;
 		// First, clean the pathfinder with our new begin and endpoints
         clean_AyStar_AiPathFinder(p->ainew.pathfinder, &p->ainew.path_info);
    		p->ainew.temp = 0;
+	}
     // Start the pathfinder
 	r = p->ainew.pathfinder->main(p->ainew.pathfinder);
 	// If it return: no match, stop it...
 	if (r == AYSTAR_NO_PATH) {
 		DEBUG(ai,1)("[AiNew] PathFinder found no route!");
 		// Start all over again...
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+	}
 	if (r == AYSTAR_FOUND_END_NODE) {
 		// We found the end-point
 		p->ainew.temp = -1;
 		p->ainew.state = AI_STATE_FIND_DEPOT;
 		return;
+	}
 	// In any other case, we are still busy finding the route...
+}
 // This function tries to locate a good place for a depot!
 static void AiNew_State_FindDepot(Player *p) {
     // To place the depot, we walk through the route, and if we find a lovely spot (MP_CLEAR, MP_TREES), we place it there..
     // Simple, easy, works!
     // To make the depot stand in the middle of the route, we start from the center..
     // But first we walk through the route see if we can find a depot that is ours
     //  this keeps things nice ;)
 	int g, i, j, r;
 	TileIndex tile;
 	assert(p->ainew.state == AI_STATE_FIND_DEPOT);
 	p->ainew.depot_tile = 0;
 	for (i=2;i<p->ainew.path_info.route_length-2;i++) {
 		tile = p->ainew.path_info.route[i];
 		for (j=0;j<lengthof(_tileoffs_by_dir);j++) {
 			if (IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_STREET)) {
 				// Its a street, test if it is a depot
 				if (_map5[tile + _tileoffs_by_dir[j]] & 0x20) {
 					// We found a depot, is it ours? (TELL ME!!!)
 					if (_map_owner[tile + _tileoffs_by_dir[j]] == _current_player) {
 						// Now, is it pointing to the right direction.........
 						if ((_map5[tile + _tileoffs_by_dir[j]] & 3) == (j ^ 2)) {
 							// Yeah!!!
 							p->ainew.depot_tile = tile + _tileoffs_by_dir[j];
 							p->ainew.depot_direction = j ^ 2; // Reverse direction
 							p->ainew.state = AI_STATE_VERIFY_ROUTE;
 							return;
+						}
+					}
+				}
+			}
+		}
+	}
 	// This routine let depot finding start in the middle, and work his way to the stations
 	// It makes depot placing nicer :)
 	i = p->ainew.path_info.route_length / 2;
 	g = 1;
 	while (i > 1 && i < p->ainew.path_info.route_length - 2) {
 		i += g;
 		g *= -1;
 		(g < 0?g--:g++);
 		if (p->ainew.path_info.route_extra[i] != 0 || p->ainew.path_info.route_extra[i+1] != 0) {
 			// Bridge or tunnel.. we can't place a depot there
 			continue;
+		}
 		tile = p->ainew.path_info.route[i];
 		for (j=0;j<lengthof(_tileoffs_by_dir);j++) {
 			// It may not be placed on the road/rail itself
 			// And because it is not build yet, we can't see it on the tile..
 			// So check the surrounding tiles :)
 			if (tile + _tileoffs_by_dir[j] == p->ainew.path_info.route[i-1] ||
 				tile + _tileoffs_by_dir[j] == p->ainew.path_info.route[i+1]) continue;
 			// Not around a bridge?
 			if (p->ainew.path_info.route_extra[i] != 0) continue;
 			if (IS_TILETYPE(tile, MP_TUNNELBRIDGE)) continue;
 			// Is the terrain clear?
 			if (IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_CLEAR) ||
 				IS_TILETYPE(tile + _tileoffs_by_dir[j], MP_TREES)) {
 				TileInfo ti;
 				FindLandscapeHeightByTile(&ti, tile);
 				// If the current tile is on a slope (tileh != 0) then we do not allow this
 				if (ti.tileh != 0) continue;
 				// Check if everything went okay..
 				r = AiNew_Build_Depot(p, tile + _tileoffs_by_dir[j], j ^ 2, 0);
 				if (r == CMD_ERROR) continue;
 				// Found a spot!
 				p->ainew.new_cost += r;
 				p->ainew.depot_tile = tile + _tileoffs_by_dir[j];
 				p->ainew.depot_direction = j ^ 2; // Reverse direction
 				p->ainew.state = AI_STATE_VERIFY_ROUTE;
 				return;
+			}
+		}
+	}
 	// Failed to find a depot?
 	p->ainew.state = AI_STATE_NOTHING;
+}
 // This function calculates how many vehicles there are needed on this
 //  traject.
 // It works pretty simple: get the length, see how much we move around
 //  and hussle that, and you know how many vehicles there are needed.
 // It returns the cost for the vehicles
 static int AiNew_HowManyVehicles(Player *p) {
 	if (p->ainew.tbt == AI_BUS) {
      	// For bus-routes we look at the time before we are back in the station
 		int i, length, tiles_a_day;
 		int amount;
 		i = AiNew_PickVehicle(p);
 		if (i == -1) return 0;
     	// Passenger run.. how long is the route?
     	length = p->ainew.path_info.route_length;
     	// Calculating tiles a day a vehicle moves is not easy.. this is how it must be done!
     	// ROAD_ENGINES_INDEX is because the first roadveh engine is ROAD_ENGINES_INDEX, and _roadveh_speed starts from 0
     	tiles_a_day = _roadveh_speed[i-ROAD_ENGINES_INDEX] * 74 / 256 / 16;
     	// We want a vehicle in a station once a month at least, so, calculate it!
     	// (the * 2 is because we have 2 stations ;))
     	amount = ((int)(((float)length / (float)tiles_a_day / 30 * 2))) * 2;
     	if (amount == 0) amount = 1;
    		return amount;
 	} else if (p->ainew.tbt == AI_TRUCK) {
      	// For truck-routes we look at the cargo
 		int i, length, amount, tiles_a_day;
 		int max_cargo;
 		i = AiNew_PickVehicle(p);
 		if (i == -1) return 0;
     	// Passenger run.. how long is the route?
     	length = p->ainew.path_info.route_length;
     	// Calculating tiles a day a vehicle moves is not easy.. this is how it must be done!
     	// ROAD_ENGINES_INDEX is because the first roadveh engine is ROAD_ENGINES_INDEX, and _roadveh_speed starts from 0
     	tiles_a_day = _roadveh_speed[i-ROAD_ENGINES_INDEX] * 74 / 256 / 16;
     	if (p->ainew.from_deliver)
     		max_cargo = DEREF_INDUSTRY(p->ainew.from_ic)->total_production[0];
     	else
     		max_cargo = DEREF_INDUSTRY(p->ainew.to_ic)->total_production[0];
     	// This is because moving 60% is more then we can dream of!
     	max_cargo *= 0.6;
     	// We want all the cargo to be gone in a month.. so, we know the cargo it delivers
     	//  we know what the vehicle takes with him, and we know the time it takes him
     	//  to get back here.. now let's do some math!
     	amount = (int)(((float)length / (float)tiles_a_day / 30 * 2) * ((float)max_cargo / (float)_roadveh_capacity[i-ROAD_ENGINES_INDEX]));
     	amount += 1;
     	return amount;
 	} else {
 		// Currently not supported
 		return 0;
+	}
+}
 // This function checks:
 //   - If the route went okay
 //   - Calculates the amount of money needed to build the route
 //   - Calculates how much vehicles needed for the route
 static void AiNew_State_VerifyRoute(Player *p) {
     int res, i;
     assert(p->ainew.state == AI_STATE_VERIFY_ROUTE);
     // Let's calculate the cost of the path..
     //  new_cost already contains the cost of the stations
     p->ainew.path_info.position = -1;
     do {
 	    p->ainew.path_info.position++;
 	    p->ainew.new_cost += AiNew_Build_RoutePart(p, &p->ainew.path_info, DC_QUERY_COST);
 	} while (p->ainew.path_info.position != -2);
 	// Now we know the price of build station + path. Now check how many vehicles
 	//  we need and what the price for that will be
 	res = AiNew_HowManyVehicles(p);
 	// If res == 0, no vehicle was found, or an other problem did occour
 	if (res == 0) {
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+	}
 	p->ainew.amount_veh = res;
 	p->ainew.cur_veh = 0;
 	// Check how much it it going to cost us..
 	for (i=0;i<res;i++) {
 		p->ainew.new_cost += AiNew_Build_Vehicle(p, 0, DC_QUERY_COST);
+	}
 	// Now we know how much the route is going to cost us
 	//  Check if we have enough money for it!
 	if (p->ainew.new_cost > p->player_money - AI_MINIMUM_MONEY) {
 		// Too bad..
 		DEBUG(ai,1)("[AiNew] Can't pay for this route (%d)", p->ainew.new_cost);
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+	}
 	// Now we can build the route, check the direction of the stations!
 	if (p->ainew.from_direction == AI_PATHFINDER_NO_DIRECTION) {
 		p->ainew.from_direction = AiNew_GetDirection(p->ainew.path_info.route[p->ainew.path_info.route_length-1], p->ainew.path_info.route[p->ainew.path_info.route_length-2]);
+	}
 	if (p->ainew.to_direction == AI_PATHFINDER_NO_DIRECTION) {
 		p->ainew.to_direction = AiNew_GetDirection(p->ainew.path_info.route[0], p->ainew.path_info.route[1]);
+	}
 	if (p->ainew.from_tile == AI_STATION_RANGE)
 		p->ainew.from_tile = p->ainew.path_info.route[p->ainew.path_info.route_length-1];
 	if (p->ainew.to_tile == AI_STATION_RANGE)
 		p->ainew.to_tile = p->ainew.path_info.route[0];
 	p->ainew.state = AI_STATE_BUILD_STATION;
 	p->ainew.temp = 0;
 	DEBUG(ai,1)("[AiNew] The route is set and buildable.. going to build it!");
+}
 // Build the stations
 static void AiNew_State_BuildStation(Player *p) {
 	int res = 0;
     assert(p->ainew.state == AI_STATE_BUILD_STATION);
     if (p->ainew.temp == 0) {
     	if (!IS_TILETYPE(p->ainew.from_tile, MP_STATION))
     		res = AiNew_Build_Station(p, p->ainew.tbt, p->ainew.from_tile, 0, 0, p->ainew.from_direction, DC_EXEC);
+   	}
     else {
        	if (!IS_TILETYPE(p->ainew.to_tile, MP_STATION))
        	   	res = AiNew_Build_Station(p, p->ainew.tbt, p->ainew.to_tile, 0, 0, p->ainew.to_direction, DC_EXEC);
     	p->ainew.state = AI_STATE_BUILD_PATH;
+    }
     if (res == CMD_ERROR) {
 		DEBUG(ai,0)("[AiNew - BuildStation] Strange but true... station can not be build!");
 		p->ainew.state = AI_STATE_NOTHING;
 		// If the first station _was_ build, destroy it
 		if (p->ainew.temp != 0)
 			DoCommandByTile(p->ainew.from_tile, 0, 0, DC_EXEC, CMD_LANDSCAPE_CLEAR);
 		return;
+    }
     p->ainew.temp++;
+}
 // Build the path
 static void AiNew_State_BuildPath(Player *p) {
 	assert(p->ainew.state == AI_STATE_BUILD_PATH);
 	// p->ainew.temp is set to -1 when this function is called for the first time
 	if (p->ainew.temp == -1) {
 		DEBUG(ai,1)("[AiNew] Starting to build the path..");
 		// Init the counter
 		p->ainew.counter = (4 - _opt.diff.competitor_speed) * AI_BUILDPATH_PAUSE + 1;
 		// Set the position to the startingplace (-1 because in a minute we do ++)
 		p->ainew.path_info.position = -1;
 		// And don't do this again
 		p->ainew.temp = 0;
+	}
 	// Building goes very fast on normal rate, so we are going to slow it down..
 	//  By let the counter count from AI_BUILDPATH_PAUSE to 0, we have a nice way :)
 	if (--p->ainew.counter != 0) return;
 	p->ainew.counter = (4 - _opt.diff.competitor_speed) * AI_BUILDPATH_PAUSE + 1;
 	// Increase the building position
 	p->ainew.path_info.position++;
 	// Build route
 	AiNew_Build_RoutePart(p, &p->ainew.path_info, DC_EXEC);
 	if (p->ainew.path_info.position == -2) {
 		// This means we are done building!
 		if (p->ainew.tbt == AI_TRUCK && !_patches.roadveh_queue) {
 			static const byte _roadbits_by_dir[4] = {2,1,8,4};
         	// If they not queue, they have to go up and down to try again at a station...
         	// We don't want that, so try building some road left or right of the station
         	short dir1, dir2, dir3;
         	TileIndex tile;
         	int i, r;
         	for (i=0;i<2;i++) {
             	if (i == 0) {
             		tile = p->ainew.from_tile + _tileoffs_by_dir[p->ainew.from_direction];
             		dir1 = p->ainew.from_direction - 1;
             		if (dir1 < 0) dir1 = 3;
             		dir2 = p->ainew.from_direction + 1;
             		if (dir2 > 3) dir2 = 0;
             		dir3 = p->ainew.from_direction;
             	} else {
             		tile = p->ainew.to_tile + _tileoffs_by_dir[p->ainew.to_direction];
             		dir1 = p->ainew.to_direction - 1;
             		if (dir1 < 0) dir1 = 3;
             		dir2 = p->ainew.to_direction + 1;
             		if (dir2 > 3) dir2 = 0;
             		dir3 = p->ainew.to_direction;
+            	}
             	DoCommandByTile(tile, _roadbits_by_dir[dir1], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
             	DoCommandByTile(tile, _roadbits_by_dir[dir2], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
             	DoCommandByTile(tile, _roadbits_by_dir[dir3^2], 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
             	dir1 = _tileoffs_by_dir[dir1];
             	dir2 = _tileoffs_by_dir[dir2];
             	dir3 = _tileoffs_by_dir[dir3];
             	r = CMD_ERROR;
            		if (IS_TILETYPE(tile+dir1, MP_CLEAR) || IS_TILETYPE(tile+dir1, MP_TREES))
            			r = DoCommandByTile(tile+dir1, AiNew_GetRoadDirection(tile, tile+dir1, tile+dir1+dir1), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
            		if (r != CMD_ERROR)
              		if (IS_TILETYPE(tile+dir1+dir1, MP_CLEAR) || IS_TILETYPE(tile+dir1+dir1, MP_TREES))
              			DoCommandByTile(tile+dir1+dir1, AiNew_GetRoadDirection(tile+dir1, tile+dir1+dir1, tile+dir1+dir1+dir1), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
              	r = CMD_ERROR;
            		if (IS_TILETYPE(tile+dir2, MP_CLEAR) || IS_TILETYPE(tile+dir2, MP_TREES))
            			DoCommandByTile(tile+dir2, AiNew_GetRoadDirection(tile, tile+dir2, tile+dir2+dir2), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
            		if (r != CMD_ERROR)
            			if (IS_TILETYPE(tile+dir2+dir2, MP_CLEAR) || IS_TILETYPE(tile+dir2+dir2, MP_TREES))
            				DoCommandByTile(tile+dir2+dir2, AiNew_GetRoadDirection(tile+dir2, tile+dir2+dir2, tile+dir2+dir2+dir2), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
            		r = CMD_ERROR;
            		if (IS_TILETYPE(tile+dir3, MP_CLEAR) || IS_TILETYPE(tile+dir3, MP_TREES))
            			DoCommandByTile(tile+dir3, AiNew_GetRoadDirection(tile, tile+dir3, tile+dir3+dir3), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
            		if (r != CMD_ERROR)
            			if (IS_TILETYPE(tile+dir3+dir3, MP_CLEAR) || IS_TILETYPE(tile+dir3+dir3, MP_TREES))
            				DoCommandByTile(tile+dir3+dir3, AiNew_GetRoadDirection(tile+dir3, tile+dir3+dir3, tile+dir3+dir3+dir3), 0, DC_EXEC | DC_NO_WATER, CMD_BUILD_ROAD);
+            }
+        }
 		DEBUG(ai,1)("[AiNew] Done building the path (cost: %d)", p->ainew.new_cost);
 		p->ainew.state = AI_STATE_BUILD_DEPOT;
+	}
+}
 // Builds the depot
 static void AiNew_State_BuildDepot(Player *p) {
 	int res = 0;
 	assert(p->ainew.state == AI_STATE_BUILD_DEPOT);
 	if (IS_TILETYPE(p->ainew.depot_tile, MP_STREET) && _map5[p->ainew.depot_tile] & 0x20) {
 		if (_map_owner[p->ainew.depot_tile] == _current_player) {
 			// The depot is already builded!
 			p->ainew.state = AI_STATE_BUILD_VEHICLE;
 			return;
 		} else {
 			// There is a depot, but not of our team! :(
 			p->ainew.state = AI_STATE_NOTHING;
 			return;
+		}
+	}
 	// There is a bus on the tile we want to build road on... idle till he is gone! (BAD PERSON! :p)
 	if (!EnsureNoVehicle(p->ainew.depot_tile + _tileoffs_by_dir[p->ainew.depot_direction]))
 		return;
 	res = AiNew_Build_Depot(p, p->ainew.depot_tile, p->ainew.depot_direction, DC_EXEC);
     if (res == CMD_ERROR) {
 		DEBUG(ai,0)("[AiNew - BuildDepot] Strange but true... depot can not be build!");
 		p->ainew.state = AI_STATE_NOTHING;
 		return;
+    }
 	p->ainew.state = AI_STATE_BUILD_VEHICLE;
 	p->ainew.idle = 1;
 	p->ainew.veh_main_id = (VehicleID)-1;
+}
 // Build vehicles
 static void AiNew_State_BuildVehicle(Player *p) {
 	int res;
     assert(p->ainew.state == AI_STATE_BUILD_VEHICLE);
     // Check if we need to build a vehicle
     if (p->ainew.amount_veh == 0) {
         // Nope, we are done!
         // This means: we are all done! The route is open.. go back to NOTHING
         //  He will idle some time and it will all start over again.. :)
     	p->ainew.state = AI_STATE_ACTION_DONE;
     	return;
+    }
     if (--p->ainew.idle != 0) return;
     // It is realistic that the AI can only build 1 vehicle a day..
     // This makes sure of that!
     p->ainew.idle = AI_BUILD_VEHICLE_TIME_BETWEEN;
     // Build the vehicle
     res = AiNew_Build_Vehicle(p, p->ainew.depot_tile, DC_EXEC);
     if (res == CMD_ERROR) {
     	// This happens when the AI can't build any more vehicles!
     	p->ainew.state = AI_STATE_NOTHING;
     	return;
+    }
     // Increase the current counter
     p->ainew.cur_veh++;
     // Decrease the total counter
     p->ainew.amount_veh--;
     // Get the new ID
     if (p->ainew.tbt == AI_TRAIN) {
     } else {
         p->ainew.veh_id = _new_roadveh_id;
+    }
     // Go give some orders!
    	p->ainew.state = AI_STATE_GIVE_ORDERS;
+}
 // Put the stations in the order list
 static void AiNew_State_GiveOrders(Player *p) {
     int order, flags;
     assert(p->ainew.state == AI_STATE_GIVE_ORDERS);
     if (p->ainew.veh_main_id != (VehicleID)-1) {
         DoCommandByTile(0, p->ainew.veh_id + (p->ainew.veh_main_id << 16), 0, DC_EXEC, CMD_CLONE_ORDER);
         // Skip the first order if it is a second vehicle
         //  This to make vehicles go different ways..
         if (p->ainew.veh_id & 1)
             DoCommandByTile(0, p->ainew.veh_id, 0, DC_EXEC, CMD_SKIP_ORDER);
         p->ainew.state = AI_STATE_START_VEHICLE;
         return;
     } else {
         p->ainew.veh_main_id = p->ainew.veh_id;
+    }
     // When more then 1 vehicle, we send them to different directions
     order = 0;
     flags = (_map2[p->ainew.from_tile] << 8) | OT_GOTO_STATION;
     if (p->ainew.tbt == AI_TRUCK && p->ainew.from_deliver)
     	flags |= OF_FULL_LOAD;
     DoCommandByTile(0, p->ainew.veh_id + (order << 16), flags, DC_EXEC, CMD_INSERT_ORDER);
     order = 1;
     flags = (_map2[p->ainew.to_tile] << 8) | OT_GOTO_STATION;
     if (p->ainew.tbt == AI_TRUCK && p->ainew.to_deliver)
     	flags |= OF_FULL_LOAD;
     DoCommandByTile(0, p->ainew.veh_id + (order << 16), flags, DC_EXEC, CMD_INSERT_ORDER);
 	// Very handy for AI, goto depot.. but yeah, it needs to be activated ;)
     if (_patches.gotodepot) {
     	order = 2;
 	    flags = (GetDepotByTile(p->ainew.depot_tile) << 8) | OT_GOTO_DEPOT | OF_UNLOAD;
 	    DoCommandByTile(0, p->ainew.veh_id + (order << 16), flags, DC_EXEC, CMD_INSERT_ORDER);
+	}
     // Start the engines!
 	p->ainew.state = AI_STATE_START_VEHICLE;
+}
 // Start the vehicle
 static void AiNew_State_StartVehicle(Player *p) {
 	assert(p->ainew.state == AI_STATE_START_VEHICLE);
 	// 3, 2, 1... go! (give START_STOP command ;))
 	DoCommandByTile(0, p->ainew.veh_id, 0, DC_EXEC, CMD_START_STOP_ROADVEH);
 	// Try to build an other vehicle (that function will stop building when needed)
 	p->ainew.state = AI_STATE_BUILD_VEHICLE;
+}
 // Repays money
 static void AiNew_State_RepayMoney(Player *p) {
     int i;
     for (i=0;i<AI_LOAN_REPAY;i++)
     	DoCommandByTile(0, _current_player, 0, DC_EXEC, CMD_DECREASE_LOAN);
     p->ainew.state = AI_STATE_ACTION_DONE;
+}
 // Using the technique simular to the original AI
 //   Keeps things logical
 // It really should be in the same order as the AI_STATE's are!
 static AiNew_StateFunction* const _ainew_state[] = {
     NULL,
     AiNew_State_FirstTime,
     AiNew_State_Nothing,
     AiNew_State_WakeUp,
     AiNew_State_LocateRoute,
     AiNew_State_FindStation,
     AiNew_State_FindPath,
     AiNew_State_FindDepot,
     AiNew_State_VerifyRoute,
     AiNew_State_BuildStation,
     AiNew_State_BuildPath,
     AiNew_State_BuildDepot,
     AiNew_State_BuildVehicle,
     AiNew_State_GiveOrders,
     AiNew_State_StartVehicle,
     AiNew_State_RepayMoney,
     AiNew_State_ActionDone,
     NULL,
 };
 static void AiNew_OnTick(Player *p) {
     if (_ainew_state[p->ainew.state] != NULL)
 	    _ainew_state[p->ainew.state](p);
+}
 void AiNewDoGameLoop(Player *p) {
     // If it is a human player, it is not an AI, so bubye!
 	if (IS_HUMAN_PLAYER(_current_player))
 		return;
 	if (p->ainew.state == AI_STATE_STARTUP) {
 		// The AI just got alive!
 		p->ainew.state = AI_STATE_FIRST_TIME;
 		p->ainew.tick = 0;
 		// Only startup the AI
 		return;
+	}
 	// We keep a ticker. We use it for competitor_speed
 	p->ainew.tick++;
 	// See what the speed is
 	switch (_opt.diff.competitor_speed) {
 		case 0: // Very slow
 			if (!(p->ainew.tick&8)) return;
 			break;
 		case 1: // Slow
 			if (!(p->ainew.tick&4)) return;
 			break;
 		case 2:
 			if (!(p->ainew.tick&2)) return;
 			break;
 		case 3:
 			if (!(p->ainew.tick&1)) return;
 			break;
 		case 4: // Very fast
 		default: // Cool, a new speed setting.. ;) VERY fast ;)
 			break;
+	}
 	// If we come here, we can do a tick.. do so!
 	AiNew_OnTick(p);
+}

ai_pathfinder.c

➞

Show inline comments

 #include "stdafx.h"
 #include "ttd.h"
 #include "command.h"
 #include "ai.h"
 #define TEST_STATION_NO_DIR 0xFF
 // Tests if a station can be build on the given spot
 // TODO: make it train compatible
 bool TestCanBuildStationHere(uint tile, byte dir) {
     Player *p = DEREF_PLAYER(_current_player);
     if (dir == TEST_STATION_NO_DIR) {
         // TODO: currently we only allow spots that can be access from al 4 directions...
         //  should be fixed!!!
         for (dir=0;dir<4;dir++) {
         	int res = AiNew_Build_Station(p, p->ainew.tbt, tile, 1, 1, dir, DC_QUERY_COST);
             if (res != CMD_ERROR)
             	return true;
+        }
         return false;
     } else {
        	int res = AiNew_Build_Station(p, p->ainew.tbt, tile, 1, 1, dir, DC_QUERY_COST);
         if (res == CMD_ERROR)
         	return false;
+    }
     return true;
+}
 // Checks if a tile 'a' is between the tiles 'b' and 'c'
 #define TILES_BETWEEN(a,b,c) (GET_TILE_X(a) >= GET_TILE_X(b) && GET_TILE_X(a) <= GET_TILE_X(c) && GET_TILE_Y(a) >= GET_TILE_Y(b) && GET_TILE_Y(a) <= GET_TILE_Y(c))
 // Check if the current tile is in our end-area
 int32 AyStar_AiPathFinder_EndNodeCheck(AyStar *aystar, OpenListNode *current) {
 	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
 	// It is not allowed to have a station on the end of a bridge or tunnel ;)
 	if (current->path.node.user_data[0] != 0) return AYSTAR_DONE;
 	if (TILES_BETWEEN(current->path.node.tile, PathFinderInfo->end_tile_tl, PathFinderInfo->end_tile_br))
 		if (IS_TILETYPE(current->path.node.tile, MP_CLEAR) || IS_TILETYPE(current->path.node.tile, MP_TREES))
 			if (current->path.parent == NULL || TestCanBuildStationHere(current->path.node.tile,AiNew_GetDirection(current->path.parent->node.tile, current->path.node.tile)))
     			return AYSTAR_FOUND_END_NODE;
 	return AYSTAR_DONE;
+}
 // Calculates the hash
 //   Currently it is a 10 bit hash, so the hash array has a max depth of 6 bits (so 64)
 uint AiPathFinder_Hash(uint key1, uint key2) {
 	return (GET_TILE_X(key1) & 0x1F) + ((GET_TILE_Y(key1) & 0x1F) << 5);
+}
 // Clear the memory of all the things
 void AyStar_AiPathFinder_Free(AyStar *aystar) {
 	AyStarMain_Free(aystar);
 	free(aystar);
+}
 static int32 AyStar_AiPathFinder_CalculateG(AyStar *aystar, AyStarNode *current, OpenListNode *parent);
 static int32 AyStar_AiPathFinder_CalculateH(AyStar *aystar, AyStarNode *current, OpenListNode *parent);
 static void AyStar_AiPathFinder_FoundEndNode(AyStar *aystar, OpenListNode *current);
 static void AyStar_AiPathFinder_GetNeighbours(AyStar *aystar, OpenListNode *current);
 // This creates the AiPathFinder
 AyStar *new_AyStar_AiPathFinder(int max_tiles_around, Ai_PathFinderInfo *PathFinderInfo) {
 	PathNode start_node;
 	uint x,y;
 	// Create AyStar
 	AyStar *result = malloc(sizeof(AyStar));
 	init_AyStar(result, AiPathFinder_Hash, 1 << 10);
 	// Set the function pointers
 	result->CalculateG = AyStar_AiPathFinder_CalculateG;
 	result->CalculateH = AyStar_AiPathFinder_CalculateH;
 	result->EndNodeCheck = AyStar_AiPathFinder_EndNodeCheck;
 	result->FoundEndNode = AyStar_AiPathFinder_FoundEndNode;
 	result->GetNeighbours = AyStar_AiPathFinder_GetNeighbours;
 	result->free = AyStar_AiPathFinder_Free;
 	// Set some information
 	result->loops_per_tick = AI_PATHFINDER_LOOPS_PER_TICK;
 	result->max_path_cost = 0;
 	result->max_search_nodes = AI_PATHFINDER_MAX_SEARCH_NODES;
 	// Set the user_data to the PathFinderInfo
 	result->user_target = PathFinderInfo;
 	// Set the start node
 	start_node.parent = NULL;
 	start_node.node.direction = 0;
 	start_node.node.user_data[0] = 0;
 	// Now we add all the starting tiles
 	for (x=GET_TILE_X(PathFinderInfo->start_tile_tl);x<=GET_TILE_X(PathFinderInfo->start_tile_br);x++) {
 		for (y=GET_TILE_Y(PathFinderInfo->start_tile_tl);y<=GET_TILE_Y(PathFinderInfo->start_tile_br);y++) {
 			start_node.node.tile = TILE_XY(x,y);
 			result->addstart(result, &start_node.node);
+		}
+	}
 	return result;
+}
 // To reuse AyStar we sometimes have to clean all the memory
 void clean_AyStar_AiPathFinder(AyStar *aystar, Ai_PathFinderInfo *PathFinderInfo) {
 	PathNode start_node;
 	uint x,y;
 	aystar->clear(aystar);
 	// Set the user_data to the PathFinderInfo
 	aystar->user_target = PathFinderInfo;
 	// Set the start node
 	start_node.parent = NULL;
 	start_node.node.direction = 0;
 	start_node.node.user_data[0] = 0;
 	start_node.node.tile = PathFinderInfo->start_tile_tl;
 	// Now we add all the starting tiles
 	for (x=GET_TILE_X(PathFinderInfo->start_tile_tl);x<=GET_TILE_X(PathFinderInfo->start_tile_br);x++) {
 		for (y=GET_TILE_Y(PathFinderInfo->start_tile_tl);y<=GET_TILE_Y(PathFinderInfo->start_tile_br);y++) {
 			if (!(IS_TILETYPE(TILE_XY(x,y), MP_CLEAR) || IS_TILETYPE(TILE_XY(x,y), MP_TREES))) continue;
 			if (!TestCanBuildStationHere(TILE_XY(x,y),TEST_STATION_NO_DIR)) continue;
 			start_node.node.tile = TILE_XY(x,y);
 			aystar->addstart(aystar, &start_node.node);
+		}
+	}
+}
 // The h-value, simple calculation
 static int32 AyStar_AiPathFinder_CalculateH(AyStar *aystar, AyStarNode *current, OpenListNode *parent) {
 	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
 	int r, r2;
 	if (PathFinderInfo->end_direction != AI_PATHFINDER_NO_DIRECTION) {
 		// The station is pointing to a direction, add a tile towards that direction, so the H-value is more accurate
 		r = GetTileDist(current->tile, PathFinderInfo->end_tile_tl + _tiles_around[PathFinderInfo->end_direction]);
 		r2 = GetTileDist(current->tile, PathFinderInfo->end_tile_br + _tiles_around[PathFinderInfo->end_direction]);
 	} else {
 		// No direction, so just get the fastest route to the station
 		r = GetTileDist(current->tile, PathFinderInfo->end_tile_tl);
 		r2 = GetTileDist(current->tile, PathFinderInfo->end_tile_br);
+	}
 	// See if the bottomright is faster then the topleft..
 	if (r2 < r) r = r2;
 	return r * AI_PATHFINDER_H_MULTIPLER;
+}
 // We found the end.. let's get the route back and put it in an array
 static void AyStar_AiPathFinder_FoundEndNode(AyStar *aystar, OpenListNode *current) {
 	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
 	int i = 0;
 	PathNode *parent = &current->path;
 	do {
      	PathFinderInfo->route_extra[i] = parent->node.user_data[0];
 		PathFinderInfo->route[i++] = parent->node.tile;
 		if (i > lengthof(PathFinderInfo->route)) {
 			// We ran out of space for the PathFinder
 			DEBUG(ai,0)("[AiPathFinder] Ran out of spacein the route[] array!!!");
 			PathFinderInfo->route_length = -1; // -1 indicates out of space
 			return;
+		}
 		parent = parent->parent;
 	} while (parent != NULL);
 	PathFinderInfo->route_length = i;
 	DEBUG(ai,1)("[Ai-PathFinding] Found route of %d nodes long in %d nodes of searching",i,Hash_Size(&aystar->ClosedListHash));
+}
 // What tiles are around us.
 static void AyStar_AiPathFinder_GetNeighbours(AyStar *aystar, OpenListNode *current) {
     int i, r, dir;
    	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
     aystar->num_neighbours = 0;
   	// Go through all surrounding tiles and check if they are within the limits
    	for (i=0;i<4;i++) {
    		if (GET_TILE_X(_tiles_around[i] + current->path.node.tile) > 1 && GET_TILE_X(_tiles_around[i] + current->path.node.tile) < TILE_X_MAX - 1 &&
        		GET_TILE_Y(_tiles_around[i] + current->path.node.tile) > 1 && GET_TILE_Y(_tiles_around[i] + current->path.node.tile) < TILE_Y_MAX - 1) {
        		// We also directly test if the current tile can connect to this tile..
        		//  We do this simply by just building the tile!
        		// If the next step is a bridge, we have to enter it the right way
        		if (!PathFinderInfo->rail_or_road && AI_PATHFINDER_IS_ROAD(current->path.node.tile + _tiles_around[i])) {
        			if (IS_TILETYPE(current->path.node.tile + _tiles_around[i], MP_TUNNELBRIDGE)) {
        				// An existing bridge... let's test the direction ;)
        				if ((_map5[current->path.node.tile + _tiles_around[i]] & 1) != (i & 1)) continue;
    					// This problem only is valid for tunnels:
        				// When the last tile was not yet a tunnel, check if we enter from the right side..
        				if (!IS_TILETYPE(current->path.node.tile, MP_TUNNELBRIDGE) && (_map5[current->path.node.tile + _tiles_around[i]] & 0x80) == 0) {
        					if ((i^2) != (_map5[current->path.node.tile + _tiles_around[i]] & 3)) continue;
+       				}
+       			}
+       		}
        		// But also if we are on a bridge, we can only move a certain direction
        		if (!PathFinderInfo->rail_or_road && AI_PATHFINDER_IS_ROAD(current->path.node.tile)) {
        			if (IS_TILETYPE(current->path.node.tile, MP_TUNNELBRIDGE)) {
        				// An existing bridge/tunnel... let's test the direction ;)
        				if ((_map5[current->path.node.tile] & 1) != (i & 1)) continue;
+       			}
+       		}
        		if ((AI_PATHFINDER_FLAG_BRIDGE & current->path.node.user_data[0]) != 0 ||
        			(AI_PATHFINDER_FLAG_TUNNEL & current->path.node.user_data[0]) != 0) {
        			// We are a bridge/tunnel, how cool!!
        			//  This means we can only point forward.. get the direction from the user_data
        			if (i != (current->path.node.user_data[0] >> 8)) continue;
+       		}
        		dir = 0;
        		// First, check if we have a parent
        		if (current->path.parent == NULL && current->path.node.user_data[0] == 0) {
        			// If not, this means we are at the starting station
        			if (PathFinderInfo->start_direction != AI_PATHFINDER_NO_DIRECTION) {
 		       		// We do need a direction?
 		       		if (AiNew_GetDirection(current->path.node.tile, current->path.node.tile + _tiles_around[i]) != PathFinderInfo->start_direction)
 		       			// We are not pointing the right way, invalid tile
 		       			continue;
+		       	}
        		} else if (current->path.node.user_data[0] == 0) {
        			if (PathFinderInfo->rail_or_road) {
        				// Rail check
        				dir = AiNew_GetRailDirection(current->path.parent->node.tile, current->path.node.tile, current->path.node.tile + _tiles_around[i]);
        				r = DoCommandByTile(current->path.node.tile, 0, dir, DC_AUTO | DC_NO_WATER, CMD_BUILD_SINGLE_RAIL);
        				if (r == CMD_ERROR) continue;
 #ifdef AI_PATHFINDER_NO_90DEGREES_TURN
        				if (current->path.parent->parent != NULL) {
        					// Check if we don't make a 90degree curve
        					int dir1 = AiNew_GetRailDirection(current->path.parent->parent->node.tile, current->path.parent->node.tile, current->path.node.tile);
        					if (_illegal_curves[dir1] == dir || _illegal_curves[dir] == dir1) {
        						continue;
+       					}
+       				}
 #endif
        			} else {
        				// Road check
        				dir = AiNew_GetRoadDirection(current->path.parent->node.tile, current->path.node.tile, current->path.node.tile + _tiles_around[i]);
        				if (AI_PATHFINDER_IS_ROAD(current->path.node.tile)) {
        					if (IS_TILETYPE(current->path.node.tile, MP_TUNNELBRIDGE)) {
        						// We have a bridge, how nicely! We should mark it...
        						dir = 0;
        					} else {
 	       					// It already has road.. check if we miss any bits!
 	       					if ((_map5[current->path.node.tile] & dir) != dir) {
 	       						// We do miss some pieces :(
 	       						dir &= ~_map5[current->path.node.tile];
 	       					} else {
 	       						dir = 0;
+    	   					}
+    	   				}
+       				}
        				// Only destruct things if it is MP_CLEAR of MP_TREES
        				if (dir != 0) {
        					r = DoCommandByTile(current->path.node.tile, dir, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);
        					if (r == CMD_ERROR) continue;
+       				}
+       			}
+       		}
 			// The tile can be connected
    			aystar->neighbours[aystar->num_neighbours].tile = _tiles_around[i] + current->path.node.tile;
    			aystar->neighbours[aystar->num_neighbours].user_data[0] = 0;
    			aystar->neighbours[aystar->num_neighbours++].direction = 0;
+       	}
+    }
     // Next step, check for bridges and tunnels
     if (current->path.parent != NULL && current->path.node.user_data[0] == 0) {
         TileInfo ti;
         // First we get the dir from this tile and his parent
     	int dir = AiNew_GetDirection(current->path.parent->node.tile, current->path.node.tile);
     	// It means we can only walk with the track, so the bridge has to be in the same direction
     	TileIndex tile = current->path.node.tile;
     	TileIndex new_tile = tile;
     	FindLandscapeHeightByTile(&ti, tile);
    		// Bridges can only be build on land that is not flat
    		//  And if there is a road or rail blocking
    		if (ti.tileh != 0 ||
      		(PathFinderInfo->rail_or_road && IS_TILETYPE(tile + _tiles_around[dir], MP_STREET)) ||
        		(!PathFinderInfo->rail_or_road && IS_TILETYPE(tile + _tiles_around[dir], MP_RAILWAY))) {
     		for (;;) {
     			new_tile += _tiles_around[dir];
     	    	// Precheck, is the length allowed?
     	    	if (!CheckBridge_Stuff(0,GetBridgeLength(tile, new_tile))) break;
     	    	// Check if we hit the station-tile.. we don't like that!
     	    	if (TILES_BETWEEN(new_tile,PathFinderInfo->end_tile_tl,PathFinderInfo->end_tile_br)) break;
     	    	// Try building the bridge..
     	    	r = DoCommandByTile(tile, new_tile, (0<<8) + (MAX_BRIDGES / 2), DC_AUTO, CMD_BUILD_BRIDGE);
 	    	   	if (r == CMD_ERROR) continue;
     		   	// We can build a bridge here.. add him to the neighbours
    				aystar->neighbours[aystar->num_neighbours].tile = new_tile;
 	   			aystar->neighbours[aystar->num_neighbours].user_data[0] = AI_PATHFINDER_FLAG_BRIDGE + (dir << 8);
 	   			aystar->neighbours[aystar->num_neighbours++].direction = 0;
 				// We can only have 12 neighbours, and we need 1 left for tunnels
 				if (aystar->num_neighbours == 11) break;
+			}
+    	}
     	// Next, check for tunnels!
     	// Tunnels can only be build with tileh of 3, 6, 9 or 12, depending on the direction
     	//  For now, we check both sides for this tile.. terraforming gives fuzzy result
     	if ((dir == 0 && ti.tileh == 12) ||
     		(dir == 1 && ti.tileh == 6) ||
     		(dir == 2 && ti.tileh == 3) ||
     		(dir == 3 && ti.tileh == 9)) {
     		// Now simply check if a tunnel can be build
     		r = DoCommandByTile(tile, (PathFinderInfo->rail_or_road?0:0x200), 0, DC_AUTO, CMD_BUILD_TUNNEL);
     		FindLandscapeHeightByTile(&ti, _build_tunnel_endtile);
     		if (r != CMD_ERROR && (ti.tileh == 3 || ti.tileh == 6 || ti.tileh == 9 || ti.tileh == 12)) {
     			aystar->neighbours[aystar->num_neighbours].tile = _build_tunnel_endtile;
 	   			aystar->neighbours[aystar->num_neighbours].user_data[0] = AI_PATHFINDER_FLAG_TUNNEL + (dir << 8);
 	   			aystar->neighbours[aystar->num_neighbours++].direction = 0;
+    		}
+    	}
+  	}
+}
 extern uint GetRailFoundation(uint tileh, uint bits);
 extern uint GetRoadFoundation(uint tileh, uint bits);
 extern uint GetBridgeFoundation(uint tileh, byte direction);
 enum {
     BRIDGE_NO_FOUNDATION = 1 << 0 | 1 << 3 | 1 << 6 | 1 << 9 | 1 << 12,
 };
 // The most important function: it calculates the g-value
 static int32 AyStar_AiPathFinder_CalculateG(AyStar *aystar, AyStarNode *current, OpenListNode *parent) {
 	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
 	int r, res = 0;
 	TileInfo ti, parent_ti;
 	// Gather some information about the tile..
 	FindLandscapeHeightByTile(&ti, current->tile);
 	FindLandscapeHeightByTile(&parent_ti, parent->path.node.tile);
 	// Check if we hit the end-tile
 	if (TILES_BETWEEN(current->tile,PathFinderInfo->end_tile_tl,PathFinderInfo->end_tile_br)) {
 		// We are at the end-tile, check if we had a direction or something...
 		if (PathFinderInfo->end_direction != AI_PATHFINDER_NO_DIRECTION && AiNew_GetDirection(current->tile, parent->path.node.tile) != PathFinderInfo->end_direction)
 			// We are not pointing the right way, invalid tile
 			return AYSTAR_INVALID_NODE;
 		// If it was valid, drop out.. we don't build on the endtile
 		return 0;
+	}
 	// Give everything a small penalty
 	res += AI_PATHFINDER_PENALTY;
 	if (!PathFinderInfo->rail_or_road) {
 		// Road has the lovely advantage it can use other road... check if
 		//  the current tile is road, and if so, give a good bonus
 		if (AI_PATHFINDER_IS_ROAD(current->tile)) {
 			res -= AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS;
+		}
+	}
 	// We should give a penalty when the tile is going up or down.. this is one way to do so!
 	//  Too bad we have to count it from the parent.. but that is not so bad
 	if (parent_ti.tileh != 0 && parent->path.parent != NULL) {
 		// Skip if the tile was from a bridge or tunnel
 		if (parent->path.node.user_data[0] == 0 && current->user_data[0] == 0) {
 			if (PathFinderInfo->rail_or_road) {
 				r = GetRailFoundation(parent_ti.tileh, 1 << AiNew_GetRailDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile));
 				// Maybe is BRIDGE_NO_FOUNDATION a bit strange here, but it contains just the right information..
 				if (r >= 15 || (r == 0 && (BRIDGE_NO_FOUNDATION & (1 << ti.tileh)))) {
 					res += AI_PATHFINDER_TILE_GOES_UP_PENALTY;
+				}
 			} else {
 				if (!(AI_PATHFINDER_IS_ROAD(parent->path.node.tile) && IS_TILETYPE(parent->path.node.tile, MP_TUNNELBRIDGE))) {
 					r = GetRoadFoundation(parent_ti.tileh, AiNew_GetRoadDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile));
 					if (r >= 15 || r == 0)
 						res += AI_PATHFINDER_TILE_GOES_UP_PENALTY;
+				}
+			}
+		}
+	}
 	// Are we part of a tunnel?
 	if ((AI_PATHFINDER_FLAG_TUNNEL & current->user_data[0]) != 0) {
 		// Tunnels are very expensive when build on long routes..
 		// Ironicly, we are using BridgeCode here ;)
 		r = AI_PATHFINDER_TUNNEL_PENALTY * GetBridgeLength(current->tile, parent->path.node.tile);
 		res += r + (r >> 8);
+	}
 	// Are we part of a bridge?
 	if ((AI_PATHFINDER_FLAG_BRIDGE & current->user_data[0]) != 0) {
 		// That means for every length a penalty
 		res += AI_PATHFINDER_BRIDGE_PENALTY * GetBridgeLength(current->tile, parent->path.node.tile);
 		// Check if we are going up or down, first for the starting point
 		// In user_data[0] is at the 8th bit the direction
 		if (!(BRIDGE_NO_FOUNDATION & (1 << parent_ti.tileh))) {
 			if (GetBridgeFoundation(parent_ti.tileh, (current->user_data[0] >> 8) & 1) < 15)
 				res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY;
+		}
 		// Second for the end point
 		if (!(BRIDGE_NO_FOUNDATION & (1 << ti.tileh))) {
 			if (GetBridgeFoundation(ti.tileh, (current->user_data[0] >> 8) & 1) < 15)
 				res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY;
+		}
 		if (parent_ti.tileh == 0)
 			res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY;
 		if (ti.tileh == 0)
 			res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY;
+	}
 	//  To prevent the AI from taking the fastest way in tiles, but not the fastest way
 	//    in speed, we have to give a good penalty to direction changing
 	//  This way, we get almost the fastest way in tiles, and a very good speed on the track
 	if (!PathFinderInfo->rail_or_road) {
 		if (parent->path.parent != NULL &&
 			AiNew_GetDirection(current->tile, parent->path.node.tile) != AiNew_GetDirection(parent->path.node.tile, parent->path.parent->node.tile)) {
 			// When road exists, we don't like turning, but its free, so don't be to piggy about it
 			if (AI_PATHFINDER_IS_ROAD(parent->path.node.tile))
 				res += AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY;
 			else
 				res += AI_PATHFINDER_DIRECTION_CHANGE_PENALTY;
+		}
 	} else {
 		// For rail we have 1 exeption: diagonal rail..
 		// So we fetch 2 raildirection. That of the current one, and of the one before that
 		if (parent->path.parent != NULL && parent->path.parent->parent != NULL) {
 			int dir1 = AiNew_GetRailDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile);
 			int dir2 = AiNew_GetRailDirection(parent->path.parent->parent->node.tile, parent->path.parent->node.tile, parent->path.node.tile);
 			// First, see if we are on diagonal path, that is better then straight path
 			if (dir1 > 1) { res -= AI_PATHFINDER_DIAGONAL_BONUS; }
 			// First see if they are different
 			if (dir1 != dir2) {
 				// dir 2 and 3 are 1 diagonal track, and 4 and 5.
 				if (!(((dir1 == 2 || dir1 == 3) && (dir2 == 2 || dir2 == 3)) || ((dir1 == 4 || dir1 == 5) && (dir2 == 4 || dir2 == 5)))) {
 					// It is not, so we changed of direction
 					res += AI_PATHFINDER_DIRECTION_CHANGE_PENALTY;
+				}
 				if (parent->path.parent->parent->parent != NULL) {
 					int dir3 = AiNew_GetRailDirection(parent->path.parent->parent->parent->node.tile, parent->path.parent->parent->node.tile, parent->path.parent->node.tile);
 					// Check if we changed 3 tiles of direction in 3 tiles.. bad!!!
 					if ((dir1 == 0 || dir1 == 1) && dir2 > 1 && (dir3 == 0 || dir3 == 1)) {
 						res += AI_PATHFINDER_CURVE_PENALTY;
+					}
+				}
+			}
+		}
+	}
 	// Res should never be below zero.. if so, make it zero!
 	if (res < 0) { res = 0; }
 	// Return our value
 	return res;
+}
 #include "stdafx.h"
 #include "ttd.h"
 #include "command.h"
 #include "ai.h"
 #define TEST_STATION_NO_DIR 0xFF
 // Tests if a station can be build on the given spot
 // TODO: make it train compatible
 bool TestCanBuildStationHere(uint tile, byte dir) {
     Player *p = DEREF_PLAYER(_current_player);
     if (dir == TEST_STATION_NO_DIR) {
         // TODO: currently we only allow spots that can be access from al 4 directions...
         //  should be fixed!!!
         for (dir=0;dir<4;dir++) {
         	int res = AiNew_Build_Station(p, p->ainew.tbt, tile, 1, 1, dir, DC_QUERY_COST);
             if (res != CMD_ERROR)
             	return true;
+        }
         return false;
     } else {
        	int res = AiNew_Build_Station(p, p->ainew.tbt, tile, 1, 1, dir, DC_QUERY_COST);
         if (res == CMD_ERROR)
         	return false;
+    }
     return true;
+}
 // Checks if a tile 'a' is between the tiles 'b' and 'c'
 #define TILES_BETWEEN(a,b,c) (GET_TILE_X(a) >= GET_TILE_X(b) && GET_TILE_X(a) <= GET_TILE_X(c) && GET_TILE_Y(a) >= GET_TILE_Y(b) && GET_TILE_Y(a) <= GET_TILE_Y(c))
 // Check if the current tile is in our end-area
 int32 AyStar_AiPathFinder_EndNodeCheck(AyStar *aystar, OpenListNode *current) {
 	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
 	// It is not allowed to have a station on the end of a bridge or tunnel ;)
 	if (current->path.node.user_data[0] != 0) return AYSTAR_DONE;
 	if (TILES_BETWEEN(current->path.node.tile, PathFinderInfo->end_tile_tl, PathFinderInfo->end_tile_br))
 		if (IS_TILETYPE(current->path.node.tile, MP_CLEAR) || IS_TILETYPE(current->path.node.tile, MP_TREES))
 			if (current->path.parent == NULL || TestCanBuildStationHere(current->path.node.tile,AiNew_GetDirection(current->path.parent->node.tile, current->path.node.tile)))
     			return AYSTAR_FOUND_END_NODE;
 	return AYSTAR_DONE;
+}
 // Calculates the hash
 //   Currently it is a 10 bit hash, so the hash array has a max depth of 6 bits (so 64)
 uint AiPathFinder_Hash(uint key1, uint key2) {
 	return (GET_TILE_X(key1) & 0x1F) + ((GET_TILE_Y(key1) & 0x1F) << 5);
+}
 // Clear the memory of all the things
 void AyStar_AiPathFinder_Free(AyStar *aystar) {
 	AyStarMain_Free(aystar);
 	free(aystar);
+}
 static int32 AyStar_AiPathFinder_CalculateG(AyStar *aystar, AyStarNode *current, OpenListNode *parent);
 static int32 AyStar_AiPathFinder_CalculateH(AyStar *aystar, AyStarNode *current, OpenListNode *parent);
 static void AyStar_AiPathFinder_FoundEndNode(AyStar *aystar, OpenListNode *current);
 static void AyStar_AiPathFinder_GetNeighbours(AyStar *aystar, OpenListNode *current);
 // This creates the AiPathFinder
 AyStar *new_AyStar_AiPathFinder(int max_tiles_around, Ai_PathFinderInfo *PathFinderInfo) {
 	PathNode start_node;
 	uint x,y;
 	// Create AyStar
 	AyStar *result = malloc(sizeof(AyStar));
 	init_AyStar(result, AiPathFinder_Hash, 1 << 10);
 	// Set the function pointers
 	result->CalculateG = AyStar_AiPathFinder_CalculateG;
 	result->CalculateH = AyStar_AiPathFinder_CalculateH;
 	result->EndNodeCheck = AyStar_AiPathFinder_EndNodeCheck;
 	result->FoundEndNode = AyStar_AiPathFinder_FoundEndNode;
 	result->GetNeighbours = AyStar_AiPathFinder_GetNeighbours;
 	result->free = AyStar_AiPathFinder_Free;
 	// Set some information
 	result->loops_per_tick = AI_PATHFINDER_LOOPS_PER_TICK;
 	result->max_path_cost = 0;
 	result->max_search_nodes = AI_PATHFINDER_MAX_SEARCH_NODES;
 	// Set the user_data to the PathFinderInfo
 	result->user_target = PathFinderInfo;
 	// Set the start node
 	start_node.parent = NULL;
 	start_node.node.direction = 0;
 	start_node.node.user_data[0] = 0;
 	// Now we add all the starting tiles
 	for (x=GET_TILE_X(PathFinderInfo->start_tile_tl);x<=GET_TILE_X(PathFinderInfo->start_tile_br);x++) {
 		for (y=GET_TILE_Y(PathFinderInfo->start_tile_tl);y<=GET_TILE_Y(PathFinderInfo->start_tile_br);y++) {
 			start_node.node.tile = TILE_XY(x,y);
 			result->addstart(result, &start_node.node);
+		}
+	}
 	return result;
+}
 // To reuse AyStar we sometimes have to clean all the memory
 void clean_AyStar_AiPathFinder(AyStar *aystar, Ai_PathFinderInfo *PathFinderInfo) {
 	PathNode start_node;
 	uint x,y;
 	aystar->clear(aystar);
 	// Set the user_data to the PathFinderInfo
 	aystar->user_target = PathFinderInfo;
 	// Set the start node
 	start_node.parent = NULL;
 	start_node.node.direction = 0;
 	start_node.node.user_data[0] = 0;
 	start_node.node.tile = PathFinderInfo->start_tile_tl;
 	// Now we add all the starting tiles
 	for (x=GET_TILE_X(PathFinderInfo->start_tile_tl);x<=GET_TILE_X(PathFinderInfo->start_tile_br);x++) {
 		for (y=GET_TILE_Y(PathFinderInfo->start_tile_tl);y<=GET_TILE_Y(PathFinderInfo->start_tile_br);y++) {
 			if (!(IS_TILETYPE(TILE_XY(x,y), MP_CLEAR) || IS_TILETYPE(TILE_XY(x,y), MP_TREES))) continue;
 			if (!TestCanBuildStationHere(TILE_XY(x,y),TEST_STATION_NO_DIR)) continue;
 			start_node.node.tile = TILE_XY(x,y);
 			aystar->addstart(aystar, &start_node.node);
+		}
+	}
+}
 // The h-value, simple calculation
 static int32 AyStar_AiPathFinder_CalculateH(AyStar *aystar, AyStarNode *current, OpenListNode *parent) {
 	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
 	int r, r2;
 	if (PathFinderInfo->end_direction != AI_PATHFINDER_NO_DIRECTION) {
 		// The station is pointing to a direction, add a tile towards that direction, so the H-value is more accurate
 		r = GetTileDist(current->tile, PathFinderInfo->end_tile_tl + _tiles_around[PathFinderInfo->end_direction]);
 		r2 = GetTileDist(current->tile, PathFinderInfo->end_tile_br + _tiles_around[PathFinderInfo->end_direction]);
 	} else {
 		// No direction, so just get the fastest route to the station
 		r = GetTileDist(current->tile, PathFinderInfo->end_tile_tl);
 		r2 = GetTileDist(current->tile, PathFinderInfo->end_tile_br);
+	}
 	// See if the bottomright is faster then the topleft..
 	if (r2 < r) r = r2;
 	return r * AI_PATHFINDER_H_MULTIPLER;
+}
 // We found the end.. let's get the route back and put it in an array
 static void AyStar_AiPathFinder_FoundEndNode(AyStar *aystar, OpenListNode *current) {
 	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
 	int i = 0;
 	PathNode *parent = &current->path;
 	do {
      	PathFinderInfo->route_extra[i] = parent->node.user_data[0];
 		PathFinderInfo->route[i++] = parent->node.tile;
 		if (i > lengthof(PathFinderInfo->route)) {
 			// We ran out of space for the PathFinder
 			DEBUG(ai,0)("[AiPathFinder] Ran out of spacein the route[] array!!!");
 			PathFinderInfo->route_length = -1; // -1 indicates out of space
 			return;
+		}
 		parent = parent->parent;
 	} while (parent != NULL);
 	PathFinderInfo->route_length = i;
 	DEBUG(ai,1)("[Ai-PathFinding] Found route of %d nodes long in %d nodes of searching",i,Hash_Size(&aystar->ClosedListHash));
+}
 // What tiles are around us.
 static void AyStar_AiPathFinder_GetNeighbours(AyStar *aystar, OpenListNode *current) {
     int i, r, dir;
    	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
     aystar->num_neighbours = 0;
   	// Go through all surrounding tiles and check if they are within the limits
    	for (i=0;i<4;i++) {
    		if (GET_TILE_X(_tiles_around[i] + current->path.node.tile) > 1 && GET_TILE_X(_tiles_around[i] + current->path.node.tile) < TILE_X_MAX - 1 &&
        		GET_TILE_Y(_tiles_around[i] + current->path.node.tile) > 1 && GET_TILE_Y(_tiles_around[i] + current->path.node.tile) < TILE_Y_MAX - 1) {
        		// We also directly test if the current tile can connect to this tile..
        		//  We do this simply by just building the tile!
        		// If the next step is a bridge, we have to enter it the right way
        		if (!PathFinderInfo->rail_or_road && AI_PATHFINDER_IS_ROAD(current->path.node.tile + _tiles_around[i])) {
        			if (IS_TILETYPE(current->path.node.tile + _tiles_around[i], MP_TUNNELBRIDGE)) {
        				// An existing bridge... let's test the direction ;)
        				if ((_map5[current->path.node.tile + _tiles_around[i]] & 1) != (i & 1)) continue;
    					// This problem only is valid for tunnels:
        				// When the last tile was not yet a tunnel, check if we enter from the right side..
        				if (!IS_TILETYPE(current->path.node.tile, MP_TUNNELBRIDGE) && (_map5[current->path.node.tile + _tiles_around[i]] & 0x80) == 0) {
        					if ((i^2) != (_map5[current->path.node.tile + _tiles_around[i]] & 3)) continue;
+       				}
+       			}
+       		}
        		// But also if we are on a bridge, we can only move a certain direction
        		if (!PathFinderInfo->rail_or_road && AI_PATHFINDER_IS_ROAD(current->path.node.tile)) {
        			if (IS_TILETYPE(current->path.node.tile, MP_TUNNELBRIDGE)) {
        				// An existing bridge/tunnel... let's test the direction ;)
        				if ((_map5[current->path.node.tile] & 1) != (i & 1)) continue;
+       			}
+       		}
        		if ((AI_PATHFINDER_FLAG_BRIDGE & current->path.node.user_data[0]) != 0 ||
        			(AI_PATHFINDER_FLAG_TUNNEL & current->path.node.user_data[0]) != 0) {
        			// We are a bridge/tunnel, how cool!!
        			//  This means we can only point forward.. get the direction from the user_data
        			if (i != (current->path.node.user_data[0] >> 8)) continue;
+       		}
        		dir = 0;
        		// First, check if we have a parent
        		if (current->path.parent == NULL && current->path.node.user_data[0] == 0) {
        			// If not, this means we are at the starting station
        			if (PathFinderInfo->start_direction != AI_PATHFINDER_NO_DIRECTION) {
 		       		// We do need a direction?
 		       		if (AiNew_GetDirection(current->path.node.tile, current->path.node.tile + _tiles_around[i]) != PathFinderInfo->start_direction)
 		       			// We are not pointing the right way, invalid tile
 		       			continue;
+		       	}
        		} else if (current->path.node.user_data[0] == 0) {
        			if (PathFinderInfo->rail_or_road) {
        				// Rail check
        				dir = AiNew_GetRailDirection(current->path.parent->node.tile, current->path.node.tile, current->path.node.tile + _tiles_around[i]);
        				r = DoCommandByTile(current->path.node.tile, 0, dir, DC_AUTO | DC_NO_WATER, CMD_BUILD_SINGLE_RAIL);
        				if (r == CMD_ERROR) continue;
 #ifdef AI_PATHFINDER_NO_90DEGREES_TURN
        				if (current->path.parent->parent != NULL) {
        					// Check if we don't make a 90degree curve
        					int dir1 = AiNew_GetRailDirection(current->path.parent->parent->node.tile, current->path.parent->node.tile, current->path.node.tile);
        					if (_illegal_curves[dir1] == dir || _illegal_curves[dir] == dir1) {
        						continue;
+       					}
+       				}
 #endif
        			} else {
        				// Road check
        				dir = AiNew_GetRoadDirection(current->path.parent->node.tile, current->path.node.tile, current->path.node.tile + _tiles_around[i]);
        				if (AI_PATHFINDER_IS_ROAD(current->path.node.tile)) {
        					if (IS_TILETYPE(current->path.node.tile, MP_TUNNELBRIDGE)) {
        						// We have a bridge, how nicely! We should mark it...
        						dir = 0;
        					} else {
 	       					// It already has road.. check if we miss any bits!
 	       					if ((_map5[current->path.node.tile] & dir) != dir) {
 	       						// We do miss some pieces :(
 	       						dir &= ~_map5[current->path.node.tile];
 	       					} else {
 	       						dir = 0;
+    	   					}
+    	   				}
+       				}
        				// Only destruct things if it is MP_CLEAR of MP_TREES
        				if (dir != 0) {
        					r = DoCommandByTile(current->path.node.tile, dir, 0, DC_AUTO | DC_NO_WATER, CMD_BUILD_ROAD);
        					if (r == CMD_ERROR) continue;
+       				}
+       			}
+       		}
 			// The tile can be connected
    			aystar->neighbours[aystar->num_neighbours].tile = _tiles_around[i] + current->path.node.tile;
    			aystar->neighbours[aystar->num_neighbours].user_data[0] = 0;
    			aystar->neighbours[aystar->num_neighbours++].direction = 0;
+       	}
+    }
     // Next step, check for bridges and tunnels
     if (current->path.parent != NULL && current->path.node.user_data[0] == 0) {
         TileInfo ti;
         // First we get the dir from this tile and his parent
     	int dir = AiNew_GetDirection(current->path.parent->node.tile, current->path.node.tile);
     	// It means we can only walk with the track, so the bridge has to be in the same direction
     	TileIndex tile = current->path.node.tile;
     	TileIndex new_tile = tile;
     	FindLandscapeHeightByTile(&ti, tile);
    		// Bridges can only be build on land that is not flat
    		//  And if there is a road or rail blocking
    		if (ti.tileh != 0 ||
      		(PathFinderInfo->rail_or_road && IS_TILETYPE(tile + _tiles_around[dir], MP_STREET)) ||
        		(!PathFinderInfo->rail_or_road && IS_TILETYPE(tile + _tiles_around[dir], MP_RAILWAY))) {
     		for (;;) {
     			new_tile += _tiles_around[dir];
     	    	// Precheck, is the length allowed?
     	    	if (!CheckBridge_Stuff(0,GetBridgeLength(tile, new_tile))) break;
     	    	// Check if we hit the station-tile.. we don't like that!
     	    	if (TILES_BETWEEN(new_tile,PathFinderInfo->end_tile_tl,PathFinderInfo->end_tile_br)) break;
     	    	// Try building the bridge..
     	    	r = DoCommandByTile(tile, new_tile, (0<<8) + (MAX_BRIDGES / 2), DC_AUTO, CMD_BUILD_BRIDGE);
 	    	   	if (r == CMD_ERROR) continue;
     		   	// We can build a bridge here.. add him to the neighbours
    				aystar->neighbours[aystar->num_neighbours].tile = new_tile;
 	   			aystar->neighbours[aystar->num_neighbours].user_data[0] = AI_PATHFINDER_FLAG_BRIDGE + (dir << 8);
 	   			aystar->neighbours[aystar->num_neighbours++].direction = 0;
 				// We can only have 12 neighbours, and we need 1 left for tunnels
 				if (aystar->num_neighbours == 11) break;
+			}
+    	}
     	// Next, check for tunnels!
     	// Tunnels can only be build with tileh of 3, 6, 9 or 12, depending on the direction
     	//  For now, we check both sides for this tile.. terraforming gives fuzzy result
     	if ((dir == 0 && ti.tileh == 12) ||
     		(dir == 1 && ti.tileh == 6) ||
     		(dir == 2 && ti.tileh == 3) ||
     		(dir == 3 && ti.tileh == 9)) {
     		// Now simply check if a tunnel can be build
     		r = DoCommandByTile(tile, (PathFinderInfo->rail_or_road?0:0x200), 0, DC_AUTO, CMD_BUILD_TUNNEL);
     		FindLandscapeHeightByTile(&ti, _build_tunnel_endtile);
     		if (r != CMD_ERROR && (ti.tileh == 3 || ti.tileh == 6 || ti.tileh == 9 || ti.tileh == 12)) {
     			aystar->neighbours[aystar->num_neighbours].tile = _build_tunnel_endtile;
 	   			aystar->neighbours[aystar->num_neighbours].user_data[0] = AI_PATHFINDER_FLAG_TUNNEL + (dir << 8);
 	   			aystar->neighbours[aystar->num_neighbours++].direction = 0;
+    		}
+    	}
+  	}
+}
 extern uint GetRailFoundation(uint tileh, uint bits);
 extern uint GetRoadFoundation(uint tileh, uint bits);
 extern uint GetBridgeFoundation(uint tileh, byte direction);
 enum {
     BRIDGE_NO_FOUNDATION = 1 << 0 | 1 << 3 | 1 << 6 | 1 << 9 | 1 << 12,
 };
 // The most important function: it calculates the g-value
 static int32 AyStar_AiPathFinder_CalculateG(AyStar *aystar, AyStarNode *current, OpenListNode *parent) {
 	Ai_PathFinderInfo *PathFinderInfo = (Ai_PathFinderInfo*)aystar->user_target;
 	int r, res = 0;
 	TileInfo ti, parent_ti;
 	// Gather some information about the tile..
 	FindLandscapeHeightByTile(&ti, current->tile);
 	FindLandscapeHeightByTile(&parent_ti, parent->path.node.tile);
 	// Check if we hit the end-tile
 	if (TILES_BETWEEN(current->tile,PathFinderInfo->end_tile_tl,PathFinderInfo->end_tile_br)) {
 		// We are at the end-tile, check if we had a direction or something...
 		if (PathFinderInfo->end_direction != AI_PATHFINDER_NO_DIRECTION && AiNew_GetDirection(current->tile, parent->path.node.tile) != PathFinderInfo->end_direction)
 			// We are not pointing the right way, invalid tile
 			return AYSTAR_INVALID_NODE;
 		// If it was valid, drop out.. we don't build on the endtile
 		return 0;
+	}
 	// Give everything a small penalty
 	res += AI_PATHFINDER_PENALTY;
 	if (!PathFinderInfo->rail_or_road) {
 		// Road has the lovely advantage it can use other road... check if
 		//  the current tile is road, and if so, give a good bonus
 		if (AI_PATHFINDER_IS_ROAD(current->tile)) {
 			res -= AI_PATHFINDER_ROAD_ALREADY_EXISTS_BONUS;
+		}
+	}
 	// We should give a penalty when the tile is going up or down.. this is one way to do so!
 	//  Too bad we have to count it from the parent.. but that is not so bad
 	if (parent_ti.tileh != 0 && parent->path.parent != NULL) {
 		// Skip if the tile was from a bridge or tunnel
 		if (parent->path.node.user_data[0] == 0 && current->user_data[0] == 0) {
 			if (PathFinderInfo->rail_or_road) {
 				r = GetRailFoundation(parent_ti.tileh, 1 << AiNew_GetRailDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile));
 				// Maybe is BRIDGE_NO_FOUNDATION a bit strange here, but it contains just the right information..
 				if (r >= 15 || (r == 0 && (BRIDGE_NO_FOUNDATION & (1 << ti.tileh)))) {
 					res += AI_PATHFINDER_TILE_GOES_UP_PENALTY;
+				}
 			} else {
 				if (!(AI_PATHFINDER_IS_ROAD(parent->path.node.tile) && IS_TILETYPE(parent->path.node.tile, MP_TUNNELBRIDGE))) {
 					r = GetRoadFoundation(parent_ti.tileh, AiNew_GetRoadDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile));
 					if (r >= 15 || r == 0)
 						res += AI_PATHFINDER_TILE_GOES_UP_PENALTY;
+				}
+			}
+		}
+	}
 	// Are we part of a tunnel?
 	if ((AI_PATHFINDER_FLAG_TUNNEL & current->user_data[0]) != 0) {
 		// Tunnels are very expensive when build on long routes..
 		// Ironicly, we are using BridgeCode here ;)
 		r = AI_PATHFINDER_TUNNEL_PENALTY * GetBridgeLength(current->tile, parent->path.node.tile);
 		res += r + (r >> 8);
+	}
 	// Are we part of a bridge?
 	if ((AI_PATHFINDER_FLAG_BRIDGE & current->user_data[0]) != 0) {
 		// That means for every length a penalty
 		res += AI_PATHFINDER_BRIDGE_PENALTY * GetBridgeLength(current->tile, parent->path.node.tile);
 		// Check if we are going up or down, first for the starting point
 		// In user_data[0] is at the 8th bit the direction
 		if (!(BRIDGE_NO_FOUNDATION & (1 << parent_ti.tileh))) {
 			if (GetBridgeFoundation(parent_ti.tileh, (current->user_data[0] >> 8) & 1) < 15)
 				res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY;
+		}
 		// Second for the end point
 		if (!(BRIDGE_NO_FOUNDATION & (1 << ti.tileh))) {
 			if (GetBridgeFoundation(ti.tileh, (current->user_data[0] >> 8) & 1) < 15)
 				res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY;
+		}
 		if (parent_ti.tileh == 0)
 			res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY;
 		if (ti.tileh == 0)
 			res += AI_PATHFINDER_BRIDGE_GOES_UP_PENALTY;
+	}
 	//  To prevent the AI from taking the fastest way in tiles, but not the fastest way
 	//    in speed, we have to give a good penalty to direction changing
 	//  This way, we get almost the fastest way in tiles, and a very good speed on the track
 	if (!PathFinderInfo->rail_or_road) {
 		if (parent->path.parent != NULL &&
 			AiNew_GetDirection(current->tile, parent->path.node.tile) != AiNew_GetDirection(parent->path.node.tile, parent->path.parent->node.tile)) {
 			// When road exists, we don't like turning, but its free, so don't be to piggy about it
 			if (AI_PATHFINDER_IS_ROAD(parent->path.node.tile))
 				res += AI_PATHFINDER_DIRECTION_CHANGE_ON_EXISTING_ROAD_PENALTY;
 			else
 				res += AI_PATHFINDER_DIRECTION_CHANGE_PENALTY;
+		}
 	} else {
 		// For rail we have 1 exeption: diagonal rail..
 		// So we fetch 2 raildirection. That of the current one, and of the one before that
 		if (parent->path.parent != NULL && parent->path.parent->parent != NULL) {
 			int dir1 = AiNew_GetRailDirection(parent->path.parent->node.tile, parent->path.node.tile, current->tile);
 			int dir2 = AiNew_GetRailDirection(parent->path.parent->parent->node.tile, parent->path.parent->node.tile, parent->path.node.tile);
 			// First, see if we are on diagonal path, that is better then straight path
 			if (dir1 > 1) { res -= AI_PATHFINDER_DIAGONAL_BONUS; }
 			// First see if they are different
 			if (dir1 != dir2) {
 				// dir 2 and 3 are 1 diagonal track, and 4 and 5.
 				if (!(((dir1 == 2 || dir1 == 3) && (dir2 == 2 || dir2 == 3)) || ((dir1 == 4 || dir1 == 5) && (dir2 == 4 || dir2 == 5)))) {
 					// It is not, so we changed of direction
 					res += AI_PATHFINDER_DIRECTION_CHANGE_PENALTY;
+				}
 				if (parent->path.parent->parent->parent != NULL) {
 					int dir3 = AiNew_GetRailDirection(parent->path.parent->parent->parent->node.tile, parent->path.parent->parent->node.tile, parent->path.parent->node.tile);
 					// Check if we changed 3 tiles of direction in 3 tiles.. bad!!!
 					if ((dir1 == 0 || dir1 == 1) && dir2 > 1 && (dir3 == 0 || dir3 == 1)) {
 						res += AI_PATHFINDER_CURVE_PENALTY;
+					}
+				}
+			}
+		}
+	}
 	// Res should never be below zero.. if so, make it zero!
 	if (res < 0) { res = 0; }
 	// Return our value
 	return res;
+}

ai_shared.c

➞

Show inline comments

 #include "stdafx.h"
 #include "ttd.h"
 #include "player.h"
 #include "ai.h"
 int AiNew_GetRailDirection(uint tile_a, uint tile_b, uint tile_c) {
 	// 0 = vert
 	// 1 = horz
 	// 2 = dig up-left
 	// 3 = dig down-right
 	// 4 = dig down-left
 	// 5 = dig up-right
 	int x1, x2, x3;
 	int y1, y2, y3;
 	x1 = GET_TILE_X(tile_a);
 	x2 = GET_TILE_X(tile_b);
 	x3 = GET_TILE_X(tile_c);
 	y1 = GET_TILE_Y(tile_a);
 	y2 = GET_TILE_Y(tile_b);
 	y3 = GET_TILE_Y(tile_c);
 	if (y1 == y2 && y2 == y3) return 0;
 	if (x1 == x2 && x2 == x3) return 1;
 	if (y2 > y1) {
 		if (x2 > x3) return 2;
 		else return 4;
+	}
 	if (x2 > x1) {
 		if (y2 > y3) return 2;
 		else return 5;
+	}
 	if (y1 > y2) {
 		if (x2 > x3) return 5;
 		else return 3;
+	}
 	if (x1 > x2) {
 		if (y2 > y3) return 4;
 		else return 3;
+	}
 	return 0;
+}
 int AiNew_GetRoadDirection(uint tile_a, uint tile_b, uint tile_c) {
 	int x1, x2, x3;
 	int y1, y2, y3;
 	int r;
 	x1 = GET_TILE_X(tile_a);
 	x2 = GET_TILE_X(tile_b);
 	x3 = GET_TILE_X(tile_c);
 	y1 = GET_TILE_Y(tile_a);
 	y2 = GET_TILE_Y(tile_b);
 	y3 = GET_TILE_Y(tile_c);
 	r = 0;
 	if (x1 < x2) r += 8;
 	if (y1 < y2) r += 1;
 	if (x1 > x2) r += 2;
 	if (y1 > y2) r += 4;
 	if (x2 < x3) r += 2;
 	if (y2 < y3) r += 4;
 	if (x2 > x3) r += 8;
 	if (y2 > y3) r += 1;
 	return r;
+}
 // Get's the direction between 2 tiles seen from tile_a
 int AiNew_GetDirection(uint tile_a, uint tile_b) {
 	if (GET_TILE_Y(tile_a) < GET_TILE_Y(tile_b)) return 1;
 	if (GET_TILE_Y(tile_a) > GET_TILE_Y(tile_b)) return 3;
 	if (GET_TILE_X(tile_a) < GET_TILE_X(tile_b)) return 2;
 	return 0;
+}
 #include "stdafx.h"
 #include "ttd.h"
 #include "player.h"
 #include "ai.h"
 int AiNew_GetRailDirection(uint tile_a, uint tile_b, uint tile_c) {
 	// 0 = vert
 	// 1 = horz
 	// 2 = dig up-left
 	// 3 = dig down-right
 	// 4 = dig down-left
 	// 5 = dig up-right
 	int x1, x2, x3;
 	int y1, y2, y3;
 	x1 = GET_TILE_X(tile_a);
 	x2 = GET_TILE_X(tile_b);
 	x3 = GET_TILE_X(tile_c);
 	y1 = GET_TILE_Y(tile_a);
 	y2 = GET_TILE_Y(tile_b);
 	y3 = GET_TILE_Y(tile_c);
 	if (y1 == y2 && y2 == y3) return 0;
 	if (x1 == x2 && x2 == x3) return 1;
 	if (y2 > y1) {
 		if (x2 > x3) return 2;
 		else return 4;
+	}
 	if (x2 > x1) {
 		if (y2 > y3) return 2;
 		else return 5;
+	}
 	if (y1 > y2) {
 		if (x2 > x3) return 5;
 		else return 3;
+	}
 	if (x1 > x2) {
 		if (y2 > y3) return 4;
 		else return 3;
+	}
 	return 0;
+}
 int AiNew_GetRoadDirection(uint tile_a, uint tile_b, uint tile_c) {
 	int x1, x2, x3;
 	int y1, y2, y3;
 	int r;
 	x1 = GET_TILE_X(tile_a);
 	x2 = GET_TILE_X(tile_b);
 	x3 = GET_TILE_X(tile_c);
 	y1 = GET_TILE_Y(tile_a);
 	y2 = GET_TILE_Y(tile_b);
 	y3 = GET_TILE_Y(tile_c);
 	r = 0;
 	if (x1 < x2) r += 8;
 	if (y1 < y2) r += 1;
 	if (x1 > x2) r += 2;
 	if (y1 > y2) r += 4;
 	if (x2 < x3) r += 2;
 	if (y2 < y3) r += 4;
 	if (x2 > x3) r += 8;
 	if (y2 > y3) r += 1;
 	return r;
+}
 // Get's the direction between 2 tiles seen from tile_a
 int AiNew_GetDirection(uint tile_a, uint tile_b) {
 	if (GET_TILE_Y(tile_a) < GET_TILE_Y(tile_b)) return 1;
 	if (GET_TILE_Y(tile_a) > GET_TILE_Y(tile_b)) return 3;
 	if (GET_TILE_X(tile_a) < GET_TILE_X(tile_b)) return 2;
 	return 0;
+}

aystar.c

➞

Show inline comments

 /*
  * This file has the core function for AyStar
  *  AyStar is a fast pathfinding routine and is used for things like
  *  AI_pathfinding and Train_pathfinding.
  *  For more information about AyStar (A* Algorithm), you can look at
  *    http://en.wikipedia.org/wiki/A-star_search_algorithm
  */
 /*
  * Friendly reminder:
  *  Call (AyStar).free() when you are done with Aystar. It reserves a lot of memory
  *  And when not free'd, it can cause system-crashes.
  * Also remember that when you stop an algorithm before it is finished, your
  * should call clear() yourself!
  */
 #include "stdafx.h"
 #include "ttd.h"
 #include "aystar.h"
 // This looks in the Hash if a node exists in ClosedList
 //  If so, it returns the PathNode, else NULL
 PathNode *AyStarMain_ClosedList_IsInList(AyStar *aystar, AyStarNode *node) {
 	return (PathNode*)Hash_Get(&aystar->ClosedListHash, node->tile, node->direction);
+}
 // This adds a node to the ClosedList
 //  It makes a copy of the data
 void AyStarMain_ClosedList_Add(AyStar *aystar, PathNode *node) {
 	// Add a node to the ClosedList
 	PathNode *new_node = malloc(sizeof(PathNode));
 	*new_node = *node;
 	Hash_Set(&aystar->ClosedListHash, node->node.tile, node->node.direction, new_node);
+}
 // Checks if a node is in the OpenList
 //   If so, it returns the OpenListNode, else NULL
 OpenListNode *AyStarMain_OpenList_IsInList(AyStar *aystar, AyStarNode *node) {
 	return (OpenListNode*)Hash_Get(&aystar->OpenListHash, node->tile, node->direction);
+}
 // Gets the best node from OpenList
 //  returns the best node, or NULL of none is found
 // Also it deletes the node from the OpenList
 OpenListNode *AyStarMain_OpenList_Pop(AyStar *aystar) {
 	// Return the item the Queue returns.. the best next OpenList item.
 	OpenListNode* res = (OpenListNode*)aystar->OpenListQueue.pop(&aystar->OpenListQueue);
 	if (res != NULL)
 		Hash_Delete(&aystar->OpenListHash, res->path.node.tile, res->path.node.direction);
 	return res;
+}
 // Adds a node to the OpenList
 //  It makes a copy of node, and puts the pointer of parent in the struct
 void AyStarMain_OpenList_Add(AyStar *aystar, PathNode *parent, AyStarNode *node, int f, int g, int userdata) {
 	// Add a new Node to the OpenList
 	OpenListNode* new_node = malloc(sizeof(OpenListNode));
 	new_node->g = g;
 	new_node->path.parent = parent;
 	new_node->path.node = *node;
 	Hash_Set(&aystar->OpenListHash, node->tile, node->direction, new_node);
 	// Add it to the queue
 	aystar->OpenListQueue.push(&aystar->OpenListQueue, new_node, f);
+}
 /*
  * Checks one tile and calculate his f-value
  *  return values:
  *	AYSTAR_DONE : indicates we are done
  */
 int AyStarMain_CheckTile(AyStar *aystar, AyStarNode *current, OpenListNode *parent) {
 	int new_f, new_g, new_h;
 	PathNode *closedlist_parent;
 	OpenListNode *check;
 	// Check the new node against the ClosedList
 	if (AyStarMain_ClosedList_IsInList(aystar, current) != NULL) return AYSTAR_DONE;
 	// Calculate the G-value for this node
 	new_g = aystar->CalculateG(aystar, current, parent);
 	// If the value was INVALID_NODE, we don't do anything with this node
 	if (new_g == AYSTAR_INVALID_NODE) return AYSTAR_DONE;
 	// There should not be given any other error-code..
 	assert(new_g >= 0);
 	// Add the parent g-value to the new g-value
 	new_g += parent->g;
 	if (aystar->max_path_cost != 0 && (uint)new_g > aystar->max_path_cost) return AYSTAR_DONE;
 	// Calculate the h-value
 	new_h = aystar->CalculateH(aystar, current, parent);
 	// There should not be given any error-code..
 	assert(new_h >= 0);
 	// The f-value if g + h
 	new_f = new_g + new_h;
 	// Get the pointer to the parent in the ClosedList (the currentone is to a copy of the one in the OpenList)
 	closedlist_parent = AyStarMain_ClosedList_IsInList(aystar, &parent->path.node);
 	// Check if this item is already in the OpenList
 	if ((check = AyStarMain_OpenList_IsInList(aystar, current)) != NULL) {
 		int i;
 		// Yes, check if this g value is lower..
 		if (new_g > check->g) return AYSTAR_DONE;
 		aystar->OpenListQueue.del(&aystar->OpenListQueue, check, 0);
 		// It is lower, so change it to this item
 		check->g = new_g;
 		check->path.parent = closedlist_parent;
 		/* Copy user data, will probably have changed */
 		for (i=0;i<lengthof(current->user_data);i++)
 			check->path.node.user_data[i] = current->user_data[i];
 		// Readd him in the OpenListQueue
 		aystar->OpenListQueue.push(&aystar->OpenListQueue, check, new_f);
 	} else {
 		// A new node, add him to the OpenList
 		AyStarMain_OpenList_Add(aystar, closedlist_parent, current, new_f, new_g, 0);
+	}
 	return AYSTAR_DONE;
+}
 /*
  * This function is the core of AyStar. It handles one item and checks
  *  his neighbour items. If they are valid, they are added to be checked too.
  *  return values:
  *	AYSTAR_EMPTY_OPENLIST : indicates all items are tested, and no path
  *	has been found.
  *	AYSTAR_LIMIT_REACHED : Indicates that the max_nodes limit has been
  *	reached.
  *	AYSTAR_FOUND_END_NODE : indicates we found the end. Path_found now is true, and in path is the path found.
  *	AYSTAR_STILL_BUSY : indicates we have done this tile, did not found the path yet, and have items left to try.
  */
 int AyStarMain_Loop(AyStar *aystar) {
 	int i, r;
 	// Get the best node from OpenList
 	OpenListNode *current = AyStarMain_OpenList_Pop(aystar);
 	// If empty, drop an error
 	if (current == NULL) return AYSTAR_EMPTY_OPENLIST;
 	// Check for end node and if found, return that code
 	if (aystar->EndNodeCheck(aystar, current) == AYSTAR_FOUND_END_NODE) {
 		if (aystar->FoundEndNode != NULL)
 			aystar->FoundEndNode(aystar, current);
 		free(current);
 		return AYSTAR_FOUND_END_NODE;
+	}
 	// Add the node to the ClosedList
 	AyStarMain_ClosedList_Add(aystar, &current->path);
 	// Load the neighbours
 	aystar->GetNeighbours(aystar, current);
 	// Go through all neighbours
 	for (i=0;i<aystar->num_neighbours;i++) {
 		// Check and add them to the OpenList if needed
 		r = aystar->checktile(aystar, &aystar->neighbours[i], current);
+	}
 	// Free the node
 	free(current);
 	if (aystar->max_search_nodes != 0 && Hash_Size(&aystar->ClosedListHash) >= aystar->max_search_nodes)
 		/* We've expanded enough nodes */
 		return AYSTAR_LIMIT_REACHED;
 	else
 		// Return that we are still busy
 		return AYSTAR_STILL_BUSY;
+}
 /*
  * This function frees the memory it allocated
  */
 void AyStarMain_Free(AyStar *aystar) {
 	aystar->OpenListQueue.free(&aystar->OpenListQueue, false);
 	/* 2nd argument above is false, below is true, to free the values only
 	 * once */
 	delete_Hash(&aystar->OpenListHash, true);
 	delete_Hash(&aystar->ClosedListHash, true);
 #ifdef AYSTAR_DEBUG
 	printf("[AyStar] Memory free'd\n");
 #endif
+}
 /*
  * This function make the memory go back to zero
  *  This function should be called when you are using the same instance again.
  */
 void AyStarMain_Clear(AyStar *aystar) {
 	// Clean the Queue, but not the elements within. That will be done by
 	// the hash.
 	aystar->OpenListQueue.clear(&aystar->OpenListQueue, false);
 	// Clean the hashes
 	clear_Hash(&aystar->OpenListHash, true);
 	clear_Hash(&aystar->ClosedListHash, true);
 #ifdef AYSTAR_DEBUG
 	printf("[AyStar] Cleared AyStar\n");
 #endif
+}
 /*
  * This is the function you call to run AyStar.
  *  return values:
  *	AYSTAR_FOUND_END_NODE : indicates we found an end node.
  *	AYSTAR_NO_PATH : indicates that there was no path found.
  *	AYSTAR_STILL_BUSY : indicates we have done some checked, that we did not found the path yet, and that we still have items left to try.
  * When the algorithm is done (when the return value is not AYSTAR_STILL_BUSY)
  * aystar->clear() is called. Note that when you stop the algorithm halfway,
  * you should still call clear() yourself!
  */
 int AyStarMain_Main(AyStar *aystar) {
 	int r, i = 0;
 	// Loop through the OpenList
 	//  Quit if result is no AYSTAR_STILL_BUSY or is more then loops_per_tick
 	while ((r = aystar->loop(aystar)) == AYSTAR_STILL_BUSY && (aystar->loops_per_tick == 0 || ++i < aystar->loops_per_tick)) { }
 #ifdef AYSTAR_DEBUG
 	if (r == AYSTAR_FOUND_END_NODE)
 		printf("[AyStar] Found path!\n");
 	else if (r == AYSTAR_EMPTY_OPENLIST)
 		printf("[AyStar] OpenList run dry, no path found\n");
 	else if (r == AYSTAR_LIMIT_REACHED)
 		printf("[AyStar] Exceeded search_nodes, no path found\n");
 #endif
 	if (r != AYSTAR_STILL_BUSY)
 		/* We're done, clean up */
 		aystar->clear(aystar);
 	// Check result-value
 	if (r == AYSTAR_FOUND_END_NODE) return AYSTAR_FOUND_END_NODE;
 	// Check if we have some left in the OpenList
 	if (r == AYSTAR_EMPTY_OPENLIST || r == AYSTAR_LIMIT_REACHED) return AYSTAR_NO_PATH;
 	// Return we are still busy
 	return AYSTAR_STILL_BUSY;
+}
 /*
  * Adds a node from where to start an algorithm. Multiple nodes can be added
  * if wanted. You should make sure that clear() is called before adding nodes
  * if the AyStar has been used before (though the normal main loop calls
  * clear() automatically when the algorithm finishes
  */
 void AyStarMain_AddStartNode(AyStar *aystar, AyStarNode *start_node) {
 #ifdef AYSTAR_DEBUG
 	printf("[AyStar] Starting A* Algorithm from node (%d, %d, %d)\n", GET_TILE_X(start_node->tile), GET_TILE_Y(start_node->tile), start_node->direction);
 #endif
 	AyStarMain_OpenList_Add(aystar, NULL, start_node, 0, 0, 0);
+}
 void init_AyStar(AyStar* aystar, Hash_HashProc hash, uint num_buckets) {
 	// Allocated the Hash for the OpenList and ClosedList
 	init_Hash(&aystar->OpenListHash, hash, num_buckets);
 	init_Hash(&aystar->ClosedListHash, hash, num_buckets);
 	// Set up our sorting queue
 	//  BinaryHeap allocates a block of 1024 nodes
 	//  When thatone gets full it reserves an otherone, till this number
 	//  That is why it can stay this high
 	init_BinaryHeap(&aystar->OpenListQueue, 102400);
 	aystar->addstart	= AyStarMain_AddStartNode;
 	aystar->main		= AyStarMain_Main;
 	aystar->loop		= AyStarMain_Loop;
 	aystar->free		= AyStarMain_Free;
 	aystar->clear		= AyStarMain_Clear;
 	aystar->checktile	= AyStarMain_CheckTile;
+}
 /*
  * This file has the core function for AyStar
  *  AyStar is a fast pathfinding routine and is used for things like
  *  AI_pathfinding and Train_pathfinding.
  *  For more information about AyStar (A* Algorithm), you can look at
  *    http://en.wikipedia.org/wiki/A-star_search_algorithm
  */
 /*
  * Friendly reminder:
  *  Call (AyStar).free() when you are done with Aystar. It reserves a lot of memory
  *  And when not free'd, it can cause system-crashes.
  * Also remember that when you stop an algorithm before it is finished, your
  * should call clear() yourself!
  */
 #include "stdafx.h"
 #include "ttd.h"
 #include "aystar.h"
 // This looks in the Hash if a node exists in ClosedList
 //  If so, it returns the PathNode, else NULL
 PathNode *AyStarMain_ClosedList_IsInList(AyStar *aystar, AyStarNode *node) {
 	return (PathNode*)Hash_Get(&aystar->ClosedListHash, node->tile, node->direction);
+}
 // This adds a node to the ClosedList
 //  It makes a copy of the data
 void AyStarMain_ClosedList_Add(AyStar *aystar, PathNode *node) {
 	// Add a node to the ClosedList
 	PathNode *new_node = malloc(sizeof(PathNode));
 	*new_node = *node;
 	Hash_Set(&aystar->ClosedListHash, node->node.tile, node->node.direction, new_node);
+}
 // Checks if a node is in the OpenList
 //   If so, it returns the OpenListNode, else NULL
 OpenListNode *AyStarMain_OpenList_IsInList(AyStar *aystar, AyStarNode *node) {
 	return (OpenListNode*)Hash_Get(&aystar->OpenListHash, node->tile, node->direction);
+}
 // Gets the best node from OpenList
 //  returns the best node, or NULL of none is found
 // Also it deletes the node from the OpenList
 OpenListNode *AyStarMain_OpenList_Pop(AyStar *aystar) {
 	// Return the item the Queue returns.. the best next OpenList item.
 	OpenListNode* res = (OpenListNode*)aystar->OpenListQueue.pop(&aystar->OpenListQueue);
 	if (res != NULL)
 		Hash_Delete(&aystar->OpenListHash, res->path.node.tile, res->path.node.direction);
 	return res;
+}
 // Adds a node to the OpenList
 //  It makes a copy of node, and puts the pointer of parent in the struct
 void AyStarMain_OpenList_Add(AyStar *aystar, PathNode *parent, AyStarNode *node, int f, int g, int userdata) {
 	// Add a new Node to the OpenList
 	OpenListNode* new_node = malloc(sizeof(OpenListNode));
 	new_node->g = g;
 	new_node->path.parent = parent;
 	new_node->path.node = *node;
 	Hash_Set(&aystar->OpenListHash, node->tile, node->direction, new_node);
 	// Add it to the queue
 	aystar->OpenListQueue.push(&aystar->OpenListQueue, new_node, f);
+}
 /*
  * Checks one tile and calculate his f-value
  *  return values:
  *	AYSTAR_DONE : indicates we are done
  */
 int AyStarMain_CheckTile(AyStar *aystar, AyStarNode *current, OpenListNode *parent) {
 	int new_f, new_g, new_h;
 	PathNode *closedlist_parent;
 	OpenListNode *check;
 	// Check the new node against the ClosedList
 	if (AyStarMain_ClosedList_IsInList(aystar, current) != NULL) return AYSTAR_DONE;
 	// Calculate the G-value for this node
 	new_g = aystar->CalculateG(aystar, current, parent);
 	// If the value was INVALID_NODE, we don't do anything with this node
 	if (new_g == AYSTAR_INVALID_NODE) return AYSTAR_DONE;
 	// There should not be given any other error-code..
 	assert(new_g >= 0);
 	// Add the parent g-value to the new g-value
 	new_g += parent->g;
 	if (aystar->max_path_cost != 0 && (uint)new_g > aystar->max_path_cost) return AYSTAR_DONE;
 	// Calculate the h-value
 	new_h = aystar->CalculateH(aystar, current, parent);
 	// There should not be given any error-code..
 	assert(new_h >= 0);
 	// The f-value if g + h
 	new_f = new_g + new_h;
 	// Get the pointer to the parent in the ClosedList (the currentone is to a copy of the one in the OpenList)
 	closedlist_parent = AyStarMain_ClosedList_IsInList(aystar, &parent->path.node);
 	// Check if this item is already in the OpenList
 	if ((check = AyStarMain_OpenList_IsInList(aystar, current)) != NULL) {
 		int i;
 		// Yes, check if this g value is lower..
 		if (new_g > check->g) return AYSTAR_DONE;
 		aystar->OpenListQueue.del(&aystar->OpenListQueue, check, 0);
 		// It is lower, so change it to this item
 		check->g = new_g;
 		check->path.parent = closedlist_parent;
 		/* Copy user data, will probably have changed */
 		for (i=0;i<lengthof(current->user_data);i++)
 			check->path.node.user_data[i] = current->user_data[i];
 		// Readd him in the OpenListQueue
 		aystar->OpenListQueue.push(&aystar->OpenListQueue, check, new_f);
 	} else {
 		// A new node, add him to the OpenList
 		AyStarMain_OpenList_Add(aystar, closedlist_parent, current, new_f, new_g, 0);
+	}
 	return AYSTAR_DONE;
+}
 /*
  * This function is the core of AyStar. It handles one item and checks
  *  his neighbour items. If they are valid, they are added to be checked too.
  *  return values:
  *	AYSTAR_EMPTY_OPENLIST : indicates all items are tested, and no path
  *	has been found.
  *	AYSTAR_LIMIT_REACHED : Indicates that the max_nodes limit has been
  *	reached.
  *	AYSTAR_FOUND_END_NODE : indicates we found the end. Path_found now is true, and in path is the path found.
  *	AYSTAR_STILL_BUSY : indicates we have done this tile, did not found the path yet, and have items left to try.
  */
 int AyStarMain_Loop(AyStar *aystar) {
 	int i, r;
 	// Get the best node from OpenList
 	OpenListNode *current = AyStarMain_OpenList_Pop(aystar);
 	// If empty, drop an error
 	if (current == NULL) return AYSTAR_EMPTY_OPENLIST;
 	// Check for end node and if found, return that code
 	if (aystar->EndNodeCheck(aystar, current) == AYSTAR_FOUND_END_NODE) {
 		if (aystar->FoundEndNode != NULL)
 			aystar->FoundEndNode(aystar, current);
 		free(current);
 		return AYSTAR_FOUND_END_NODE;
+	}
 	// Add the node to the ClosedList
 	AyStarMain_ClosedList_Add(aystar, &current->path);
 	// Load the neighbours
 	aystar->GetNeighbours(aystar, current);
 	// Go through all neighbours
 	for (i=0;i<aystar->num_neighbours;i++) {
 		// Check and add them to the OpenList if needed
 		r = aystar->checktile(aystar, &aystar->neighbours[i], current);
+	}
 	// Free the node
 	free(current);
 	if (aystar->max_search_nodes != 0 && Hash_Size(&aystar->ClosedListHash) >= aystar->max_search_nodes)
 		/* We've expanded enough nodes */
 		return AYSTAR_LIMIT_REACHED;
 	else
 		// Return that we are still busy
 		return AYSTAR_STILL_BUSY;
+}
 /*
  * This function frees the memory it allocated
  */
 void AyStarMain_Free(AyStar *aystar) {
 	aystar->OpenListQueue.free(&aystar->OpenListQueue, false);
 	/* 2nd argument above is false, below is true, to free the values only
 	 * once */
 	delete_Hash(&aystar->OpenListHash, true);
 	delete_Hash(&aystar->ClosedListHash, true);
 #ifdef AYSTAR_DEBUG
 	printf("[AyStar] Memory free'd\n");
 #endif
+}
 /*
  * This function make the memory go back to zero
  *  This function should be called when you are using the same instance again.
  */
 void AyStarMain_Clear(AyStar *aystar) {
 	// Clean the Queue, but not the elements within. That will be done by
 	// the hash.
 	aystar->OpenListQueue.clear(&aystar->OpenListQueue, false);
 	// Clean the hashes
 	clear_Hash(&aystar->OpenListHash, true);
 	clear_Hash(&aystar->ClosedListHash, true);
 #ifdef AYSTAR_DEBUG
 	printf("[AyStar] Cleared AyStar\n");
 #endif
+}
 /*
  * This is the function you call to run AyStar.
  *  return values:
  *	AYSTAR_FOUND_END_NODE : indicates we found an end node.
  *	AYSTAR_NO_PATH : indicates that there was no path found.
  *	AYSTAR_STILL_BUSY : indicates we have done some checked, that we did not found the path yet, and that we still have items left to try.
  * When the algorithm is done (when the return value is not AYSTAR_STILL_BUSY)
  * aystar->clear() is called. Note that when you stop the algorithm halfway,
  * you should still call clear() yourself!
  */
 int AyStarMain_Main(AyStar *aystar) {
 	int r, i = 0;
 	// Loop through the OpenList
 	//  Quit if result is no AYSTAR_STILL_BUSY or is more then loops_per_tick
 	while ((r = aystar->loop(aystar)) == AYSTAR_STILL_BUSY && (aystar->loops_per_tick == 0 || ++i < aystar->loops_per_tick)) { }
 #ifdef AYSTAR_DEBUG
 	if (r == AYSTAR_FOUND_END_NODE)
 		printf("[AyStar] Found path!\n");
 	else if (r == AYSTAR_EMPTY_OPENLIST)
 		printf("[AyStar] OpenList run dry, no path found\n");
 	else if (r == AYSTAR_LIMIT_REACHED)
 		printf("[AyStar] Exceeded search_nodes, no path found\n");
 #endif
 	if (r != AYSTAR_STILL_BUSY)
 		/* We're done, clean up */
 		aystar->clear(aystar);
 	// Check result-value
 	if (r == AYSTAR_FOUND_END_NODE) return AYSTAR_FOUND_END_NODE;
 	// Check if we have some left in the OpenList
 	if (r == AYSTAR_EMPTY_OPENLIST || r == AYSTAR_LIMIT_REACHED) return AYSTAR_NO_PATH;
 	// Return we are still busy
 	return AYSTAR_STILL_BUSY;
+}
 /*
  * Adds a node from where to start an algorithm. Multiple nodes can be added
  * if wanted. You should make sure that clear() is called before adding nodes
  * if the AyStar has been used before (though the normal main loop calls
  * clear() automatically when the algorithm finishes
  */
 void AyStarMain_AddStartNode(AyStar *aystar, AyStarNode *start_node) {
 #ifdef AYSTAR_DEBUG
 	printf("[AyStar] Starting A* Algorithm from node (%d, %d, %d)\n", GET_TILE_X(start_node->tile), GET_TILE_Y(start_node->tile), start_node->direction);
 #endif
 	AyStarMain_OpenList_Add(aystar, NULL, start_node, 0, 0, 0);
+}
 void init_AyStar(AyStar* aystar, Hash_HashProc hash, uint num_buckets) {
 	// Allocated the Hash for the OpenList and ClosedList
 	init_Hash(&aystar->OpenListHash, hash, num_buckets);
 	init_Hash(&aystar->ClosedListHash, hash, num_buckets);
 	// Set up our sorting queue
 	//  BinaryHeap allocates a block of 1024 nodes
 	//  When thatone gets full it reserves an otherone, till this number
 	//  That is why it can stay this high
 	init_BinaryHeap(&aystar->OpenListQueue, 102400);
 	aystar->addstart	= AyStarMain_AddStartNode;
 	aystar->main		= AyStarMain_Main;
 	aystar->loop		= AyStarMain_Loop;
 	aystar->free		= AyStarMain_Free;
 	aystar->clear		= AyStarMain_Clear;
 	aystar->checktile	= AyStarMain_CheckTile;
+}

industry_cmd.c

➞

Show inline comments

@@ @@ -1564,7 +1564,7 @@ Industry *CreateNewIndustry(uint tile, i @@
 	return i;
+}
-static const byte _numof_industry_table[4][12] = {
 static const byte _numof_industry_table[4][12] = {
 	{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
 	{0, 1, 1, 1, 2, 2, 3, 3, 4, 4, 5},
 	{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10},
@@ @@ -1574,8 +1574,8 @@ static const byte _numof_industry_table[ @@
 static void PlaceInitialIndustry(byte type, int amount)
+{
 	int num = _numof_industry_table[_opt.diff.number_industries][amount];
 	if (_opt.diff.number_industries != 0)
 	if (_opt.diff.number_industries != 0)
+	{
 		assert(num > 0);
@@ @@ -1585,7 +1585,7 @@ static void PlaceInitialIndustry(byte ty @@
 				if (CreateNewIndustry(TILE_MASK(Random()), type) != NULL)
 					break;
 			} while (--i != 0);
-		} while (--num);
 		} while (--num);
+	}
+}

network.c

➞

Show inline comments

@@ @@ -1252,14 +1252,14 @@ void NetworkIPListInit() { @@
 	gethostname(hostname,250);
 	DEBUG(misc,2) ("[NET][IP] init for host %s", hostname);
 	he=gethostbyname((char *) hostname);
 	if (he == NULL) {
 		he = gethostbyname("localhost");
+		}
 	if (he == NULL) {
 		bcaddr = inet_addr("127.0.0.1");
 		he = gethostbyaddr(inet_ntoa(*(struct in_addr *) &bcaddr), sizeof(bcaddr), AF_INET);
 	if (he == NULL) {
 		he = gethostbyname("localhost");
+		}
 	if (he == NULL) {
 		bcaddr = inet_addr("127.0.0.1");
 		he = gethostbyaddr(inet_ntoa(*(struct in_addr *) &bcaddr), sizeof(bcaddr), AF_INET);
+		}
 	if (he == NULL) {

queue.h

➞

Show inline comments

 #ifndef QUEUE_H
 #define QUEUE_H
 //#define NOFREE
 //#define QUEUE_DEBUG
 //#define HASH_DEBUG
 typedef struct Queue Queue;
 typedef bool Queue_PushProc(Queue* q, void* item, int priority);
 typedef void* Queue_PopProc(Queue* q);
 typedef bool Queue_DeleteProc(Queue* q, void* item, int priority);
 typedef void Queue_ClearProc(Queue* q, bool free_values);
 typedef void Queue_FreeProc(Queue* q, bool free_values);
 typedef struct InsSortNode InsSortNode;
 struct InsSortNode {
 	void* item;
 	int priority;
 	InsSortNode* next;
 };
 typedef struct BinaryHeapNode BinaryHeapNode;
 	struct BinaryHeapNode {
 	void* item;
 	int priority;
 };
 struct Queue{
 	/*
 	 * Pushes an element into the queue, at the appropriate place for the queue.
 	 * Requires the queue pointer to be of an appropriate type, of course.
 	 */
 	Queue_PushProc* push;
 	/*
 	 * Pops the first element from the queue. What exactly is the first element,
 	 * is defined by the exact type of queue.
 	 */
 	Queue_PopProc* pop;
 	/*
 	 * Deletes the item from the queue. priority should be specified if
 	 * known, which speeds up the deleting for some queue's. Should be -1
 	 * if not known.
 	 */
 	Queue_DeleteProc* del;
 	/* Clears the queue, by removing all values from it. It's state is
 	 * effectively reset. If free_items is true, each of the items cleared
 	 * in this way are free()'d.
 	 */
 	Queue_ClearProc* clear;
 	/* Frees the queue, by reclaiming all memory allocated by it. After
 	 * this it is no longer usable. If free_items is true, any remaining
 	 * items are free()'d too.
 	 */
 	Queue_FreeProc* free;
 	union {
 		struct {
 			uint max_size;
 			uint size;
 			void** elements;
 		} stack;
 		struct {
 			uint max_size;
 			uint head; /* The index where the last element should be inserted */
 			uint tail; /* The index where the next element should be read */
 			void** elements;
 		} fifo;
 		struct {
 			InsSortNode* first;
 		} inssort;
 		struct {
 			uint max_size;
 			uint size;
 			uint blocks; /* The amount of blocks for which space is reserved in elements */
 			BinaryHeapNode** elements;
 		} binaryheap;
 	} data;
 	/* If true, this struct will be free'd when the
 	 * Queue is deleted. */
 	bool freeq;
 };
 /* Initializes a stack and allocates internal memory. */
 void init_Stack(Queue* q, uint max_size);
 /* Allocate a new stack with a maximum of max_size elements. */
 Queue* new_Stack(uint max_size);
 /*
  * Fifo
  */
 /* Initializes a fifo and allocates internal memory for maximum of max_size
  * elements */
 void init_Fifo(Queue* q, uint max_size);
 /* Allocate a new fifo and initializes it with a maximum of max_size elements. */
 Queue* new_Fifo(uint max_size);
 Queue* new_Fifo_in_buffer(uint max_size, void* buffer);
 int build_Fifo(void* buffer, uint size);
 /*
  * Insertion Sorter
  */
 /* Initializes a inssort and allocates internal memory. There is no maximum
  * size */
 void init_InsSort(Queue* q);
 /* Allocate a new fifo and initializes it. There is no maximum size */
 Queue* new_InsSort();
 /*
  *  Binary Heap
  *  For information, see:
  *   http://www.policyalmanac.org/games/binaryHeaps.htm
  */
 /* The amount of elements that will be malloc'd at a time */
 #define BINARY_HEAP_BLOCKSIZE_BITS 10
 /* Initializes a binary heap and allocates internal memory for maximum of
  * max_size elements */
 void init_BinaryHeap(Queue* q, uint max_size);
 /* Allocate a new binary heap and initializes it with a maximum of max_size
  * elements. */
 Queue* new_BinaryHeap(uint max_size);
 /*
  * Hash
  */
 typedef struct HashNode HashNode;
 struct HashNode {
 	uint key1;
 	uint key2;
 	void* value;
 	HashNode* next;
 };
 /* Generates a hash code from the given key pair. You should make sure that
  * the resulting range is clearly defined.
  */
 typedef uint Hash_HashProc(uint key1, uint key2);
 typedef struct Hash {
 	/* The hash function used */
 	Hash_HashProc* hash;
 	/* The amount of items in the hash */
 	uint size;
 	/* The number of buckets allocated */
 	uint num_buckets;
 	/* A pointer to an array of num_buckets buckets. */
 	HashNode* buckets;
 	/* A pointer to an array of numbuckets booleans, which will be true if
 	 * there are any Nodes in the bucket */
 	bool* buckets_in_use;
 	/* If true, buckets will be freed in delete_hash */
 	bool freeb;
 	/* If true, the pointer to this struct will be freed in delete_hash */
 	bool freeh;
 } Hash;
 /* Call these function to manipulate a hash */
 /* Deletes the value with the specified key pair from the hash and returns
  * that value. Returns NULL when the value was not present. The value returned
  * is _not_ free()'d! */
 void* Hash_Delete(Hash* h, uint key1, uint key2);
 /* Sets the value associated with the given key pair to the given value.
  * Returns the old value if the value was replaced, NULL when it was not yet present. */
 void* Hash_Set(Hash* h, uint key1, uint key2, void* value);
 /* Gets the value associated with the given key pair, or NULL when it is not
  * present. */
 void* Hash_Get(Hash* h, uint key1, uint key2);
 /* Call these function to create/destroy a hash */
 /* Builds a new hash, with num_buckets buckets. Make sure that hash() always
  * returns a hash less than num_buckets! Call delete_hash after use */
 Hash* new_Hash(Hash_HashProc* hash, int num_buckets);
 /* Builds a new hash in an existing struct. Make sure that hash() always
  * returns a hash less than num_buckets! Call delete_hash after use */
 void init_Hash(Hash* h, Hash_HashProc* hash, int num_buckets);
 /*
  * Deletes the hash and cleans up. Only cleans up memory allocated by new_Hash
  * & friends. If free is true, it will call free() on all the values that
  * are left in the hash.
  */
 void delete_Hash(Hash* h, bool free_values);
 /*
  * Cleans the hash, but keeps the memory allocated
  */
 void clear_Hash(Hash* h, bool free_values);
 /*
  * Gets the current size of the Hash
  */
 uint Hash_Size(Hash* h);
 #endif /* QUEUE_H */
 #ifndef QUEUE_H
 #define QUEUE_H
 //#define NOFREE
 //#define QUEUE_DEBUG
 //#define HASH_DEBUG
 typedef struct Queue Queue;
 typedef bool Queue_PushProc(Queue* q, void* item, int priority);
 typedef void* Queue_PopProc(Queue* q);
 typedef bool Queue_DeleteProc(Queue* q, void* item, int priority);
 typedef void Queue_ClearProc(Queue* q, bool free_values);
 typedef void Queue_FreeProc(Queue* q, bool free_values);
 typedef struct InsSortNode InsSortNode;
 struct InsSortNode {
 	void* item;
 	int priority;
 	InsSortNode* next;
 };
 typedef struct BinaryHeapNode BinaryHeapNode;
 	struct BinaryHeapNode {
 	void* item;
 	int priority;
 };
 struct Queue{
 	/*
 	 * Pushes an element into the queue, at the appropriate place for the queue.
 	 * Requires the queue pointer to be of an appropriate type, of course.
 	 */
 	Queue_PushProc* push;
 	/*
 	 * Pops the first element from the queue. What exactly is the first element,
 	 * is defined by the exact type of queue.
 	 */
 	Queue_PopProc* pop;
 	/*
 	 * Deletes the item from the queue. priority should be specified if
 	 * known, which speeds up the deleting for some queue's. Should be -1
 	 * if not known.
 	 */
 	Queue_DeleteProc* del;
 	/* Clears the queue, by removing all values from it. It's state is
 	 * effectively reset. If free_items is true, each of the items cleared
 	 * in this way are free()'d.
 	 */
 	Queue_ClearProc* clear;
 	/* Frees the queue, by reclaiming all memory allocated by it. After
 	 * this it is no longer usable. If free_items is true, any remaining
 	 * items are free()'d too.
 	 */
 	Queue_FreeProc* free;
 	union {
 		struct {
 			uint max_size;
 			uint size;
 			void** elements;
 		} stack;
 		struct {
 			uint max_size;
 			uint head; /* The index where the last element should be inserted */
 			uint tail; /* The index where the next element should be read */
 			void** elements;
 		} fifo;
 		struct {
 			InsSortNode* first;
 		} inssort;
 		struct {
 			uint max_size;
 			uint size;
 			uint blocks; /* The amount of blocks for which space is reserved in elements */
 			BinaryHeapNode** elements;
 		} binaryheap;
 	} data;
 	/* If true, this struct will be free'd when the
 	 * Queue is deleted. */
 	bool freeq;
 };
 /* Initializes a stack and allocates internal memory. */
 void init_Stack(Queue* q, uint max_size);
 /* Allocate a new stack with a maximum of max_size elements. */
 Queue* new_Stack(uint max_size);
 /*
  * Fifo
  */
 /* Initializes a fifo and allocates internal memory for maximum of max_size
  * elements */
 void init_Fifo(Queue* q, uint max_size);
 /* Allocate a new fifo and initializes it with a maximum of max_size elements. */
 Queue* new_Fifo(uint max_size);
 Queue* new_Fifo_in_buffer(uint max_size, void* buffer);
 int build_Fifo(void* buffer, uint size);
 /*
  * Insertion Sorter
  */
 /* Initializes a inssort and allocates internal memory. There is no maximum
  * size */
 void init_InsSort(Queue* q);
 /* Allocate a new fifo and initializes it. There is no maximum size */
 Queue* new_InsSort();
 /*
  *  Binary Heap
  *  For information, see:
  *   http://www.policyalmanac.org/games/binaryHeaps.htm
  */
 /* The amount of elements that will be malloc'd at a time */
 #define BINARY_HEAP_BLOCKSIZE_BITS 10
 /* Initializes a binary heap and allocates internal memory for maximum of
  * max_size elements */
 void init_BinaryHeap(Queue* q, uint max_size);
 /* Allocate a new binary heap and initializes it with a maximum of max_size
  * elements. */
 Queue* new_BinaryHeap(uint max_size);
 /*
  * Hash
  */
 typedef struct HashNode HashNode;
 struct HashNode {
 	uint key1;
 	uint key2;
 	void* value;
 	HashNode* next;
 };
 /* Generates a hash code from the given key pair. You should make sure that
  * the resulting range is clearly defined.
  */
 typedef uint Hash_HashProc(uint key1, uint key2);
 typedef struct Hash {
 	/* The hash function used */
 	Hash_HashProc* hash;
 	/* The amount of items in the hash */
 	uint size;
 	/* The number of buckets allocated */
 	uint num_buckets;
 	/* A pointer to an array of num_buckets buckets. */
 	HashNode* buckets;
 	/* A pointer to an array of numbuckets booleans, which will be true if
 	 * there are any Nodes in the bucket */
 	bool* buckets_in_use;
 	/* If true, buckets will be freed in delete_hash */
 	bool freeb;
 	/* If true, the pointer to this struct will be freed in delete_hash */
 	bool freeh;
 } Hash;
 /* Call these function to manipulate a hash */
 /* Deletes the value with the specified key pair from the hash and returns
  * that value. Returns NULL when the value was not present. The value returned
  * is _not_ free()'d! */
 void* Hash_Delete(Hash* h, uint key1, uint key2);
 /* Sets the value associated with the given key pair to the given value.
  * Returns the old value if the value was replaced, NULL when it was not yet present. */
 void* Hash_Set(Hash* h, uint key1, uint key2, void* value);
 /* Gets the value associated with the given key pair, or NULL when it is not
  * present. */
 void* Hash_Get(Hash* h, uint key1, uint key2);
 /* Call these function to create/destroy a hash */
 /* Builds a new hash, with num_buckets buckets. Make sure that hash() always
  * returns a hash less than num_buckets! Call delete_hash after use */
 Hash* new_Hash(Hash_HashProc* hash, int num_buckets);
 /* Builds a new hash in an existing struct. Make sure that hash() always
  * returns a hash less than num_buckets! Call delete_hash after use */
 void init_Hash(Hash* h, Hash_HashProc* hash, int num_buckets);
 /*
  * Deletes the hash and cleans up. Only cleans up memory allocated by new_Hash
  * & friends. If free is true, it will call free() on all the values that
  * are left in the hash.
  */
 void delete_Hash(Hash* h, bool free_values);
 /*
  * Cleans the hash, but keeps the memory allocated
  */
 void clear_Hash(Hash* h, bool free_values);
 /*
  * Gets the current size of the Hash
  */
 uint Hash_Size(Hash* h);
 #endif /* QUEUE_H */

0 comments (0 inline, 0 general)