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

9 files changed, 2746 insertions, 2746 deletions

diff --git a/ai.h b/ai.h
index bd0d794d1..f27e8d165 100644
--- a/ai.h
+++ b/ai.h
@@ -1,243 +1,243 @@
-#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, 255, // Horz and vert, don't have the effect

-    5, // upleft and upright are not valid

-    4, // downright and downleft are not valid

-    2, // downleft and upleft are not valid

-    3, // 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, 255, // Horz and vert, don't have the effect
+    5, // upleft and upright are not valid
+    4, // downright and downleft are not valid
+    2, // downleft and upleft are not valid
+    3, // 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
diff --git a/ai_build.c b/ai_build.c
index 6a565342b..909c7e673 100644
--- a/ai_build.c
+++ b/ai_build.c
@@ -1,257 +1,257 @@
-#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;
+    }
+}
diff --git a/ai_new.c b/ai_new.c
index 0c03b3893..0f15ef3b8 100644
--- a/ai_new.c
+++ b/ai_new.c
@@ -1,1221 +1,1221 @@
-/*

- * 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);
+}
diff --git a/ai_pathfinder.c b/ai_pathfinder.c
index 148ce1116..01ce2198e 100644
--- a/ai_pathfinder.c
+++ b/ai_pathfinder.c
@@ -1,457 +1,457 @@
-#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;
+}
diff --git a/ai_shared.c b/ai_shared.c
index 192651c82..3e2c4a930 100644
--- a/ai_shared.c
+++ b/ai_shared.c
@@ -1,82 +1,82 @@
-#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;
+}
+ 
diff --git a/aystar.c b/aystar.c
index cd7c40214..a38dfc7a8 100644
--- a/aystar.c
+++ b/aystar.c
@@ -1,271 +1,271 @@
-/*

- * 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;
+}
diff --git a/industry_cmd.c b/industry_cmd.c
index de36565a6..031540510 100644
--- a/industry_cmd.c
+++ b/industry_cmd.c
@@ -1564,7 +1564,7 @@ Industry *CreateNewIndustry(uint tile, int type)
 	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[4][12] = {
 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 type, int amount)
 				if (CreateNewIndustry(TILE_MASK(Random()), type) != NULL)
 					break; 
 			} while (--i != 0);
-		} while (--num);

+		} while (--num);
 	}
 }
 
diff --git a/network.c b/network.c
index 5c664afe4..d2b758bf2 100644
--- a/network.c
+++ b/network.c
@@ -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) {
diff --git a/queue.h b/queue.h
index 05efe589b..b83ff3937 100644
--- a/queue.h
+++ b/queue.h
@@ -1,203 +1,203 @@
-#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 */