(svn r17075) -Codechange: rename ~750 strings to be more uniform with their relatives

12 files changed, 30 insertions, 30 deletions

diff --git a/src/ai/api/ai_bridge.hpp b/src/ai/api/ai_bridge.hpp
index bec17ca7a..7be500129 100644
--- a/src/ai/api/ai_bridge.hpp
+++ b/src/ai/api/ai_bridge.hpp
@@ -31,7 +31,7 @@ public:
 		ERR_BRIDGE_CANNOT_END_IN_WATER,      // [STR_ERROR_ENDS_OF_BRIDGE_MUST_BOTH]
 
 		/** The bride heads need to be on the same height */
-		ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT, // [STR_BRIDGEHEADS_NOT_SAME_HEIGHT]
+		ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT, // [STR_ERROR_BRIDGEHEADS_NOT_SAME_HEIGHT]
 	};
 
 	static const char *GetClassName() { return "AIBridge"; }
diff --git a/src/ai/api/ai_bridge.hpp.sq b/src/ai/api/ai_bridge.hpp.sq
index 593dc83ed..1026afbf2 100644
--- a/src/ai/api/ai_bridge.hpp.sq
+++ b/src/ai/api/ai_bridge.hpp.sq
@@ -28,7 +28,7 @@ void SQAIBridge_Register(Squirrel *engine) {
 
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_BUILD_BRIDGE_HERE,  AIBridge::ERR_BRIDGE_TYPE_UNAVAILABLE);
 	AIError::RegisterErrorMap(STR_ERROR_ENDS_OF_BRIDGE_MUST_BOTH, AIBridge::ERR_BRIDGE_CANNOT_END_IN_WATER);
-	AIError::RegisterErrorMap(STR_BRIDGEHEADS_NOT_SAME_HEIGHT,    AIBridge::ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT);
+	AIError::RegisterErrorMap(STR_ERROR_BRIDGEHEADS_NOT_SAME_HEIGHT,    AIBridge::ERR_BRIDGE_HEADS_NOT_ON_SAME_HEIGHT);
 
 	AIError::RegisterErrorMapString(AIBridge::ERR_BRIDGE_TYPE_UNAVAILABLE,         "ERR_BRIDGE_TYPE_UNAVAILABLE");
 	AIError::RegisterErrorMapString(AIBridge::ERR_BRIDGE_CANNOT_END_IN_WATER,      "ERR_BRIDGE_CANNOT_END_IN_WATER");
diff --git a/src/ai/api/ai_error.hpp b/src/ai/api/ai_error.hpp
index c845f3de7..f890b7cac 100644
--- a/src/ai/api/ai_error.hpp
+++ b/src/ai/api/ai_error.hpp
@@ -90,13 +90,13 @@ public:
 		ERR_ALREADY_BUILT,                            // [STR_ERROR_ALREADY_BUILT, STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST]
 
 		/** Area isn't clear, try to demolish the building on it */
-		ERR_AREA_NOT_CLEAR,                           // [STR_ERROR_BUILDING_MUST_BE_DEMOLISHED, STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST, STR_ERROR_MUST_DEMOLISH_RAILROAD, STR_ERROR_MUST_DEMOLISH_AIRPORT_FIRST, STR_ERROR_MUST_DEMOLISH_CARGO_TRAM_STATION_FIRST, STR_ERROR_MUST_DEMOLISH_TRUCK_STATION_FIRST, STR_ERROR_MUST_DEMOLISH_PASSENGER_TRAM_STATION_FIRST, STR_ERROR_MUST_DEMOLISH_BUS_STATION_FIRST, STR_ERROR_BUOY_IN_THE_WAY, STR_ERROR_MUST_DEMOLISH_DOCK_FIRST, STR_OBJECT_IN_THE_WAY, STR_ERROR_COMPANY_HEADQUARTERS_IN, STR_ERROR_OBJECT_IN_THE_WAY, STR_ERROR_MUST_REMOVE_ROAD_FIRST, STR_ERROR_MUST_REMOVE_RAILROAD_TRACK, STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST, STR_ERROR_MUST_DEMOLISH_TUNNEL_FIRST, STR_ERROR_EXCAVATION_WOULD_DAMAGE]
+		ERR_AREA_NOT_CLEAR,                           // [STR_ERROR_BUILDING_MUST_BE_DEMOLISHED, STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST, STR_ERROR_MUST_DEMOLISH_RAILROAD, STR_ERROR_MUST_DEMOLISH_AIRPORT_FIRST, STR_ERROR_MUST_DEMOLISH_CARGO_TRAM_STATION_FIRST, STR_ERROR_MUST_DEMOLISH_TRUCK_STATION_FIRST, STR_ERROR_MUST_DEMOLISH_PASSENGER_TRAM_STATION_FIRST, STR_ERROR_MUST_DEMOLISH_BUS_STATION_FIRST, STR_ERROR_BUOY_IN_THE_WAY, STR_ERROR_MUST_DEMOLISH_DOCK_FIRST, STR_ERROR_UNMOVABLE_OBJECT_IN_THE_WAY, STR_ERROR_COMPANY_HEADQUARTERS_IN, STR_ERROR_OBJECT_IN_THE_WAY, STR_ERROR_MUST_REMOVE_ROAD_FIRST, STR_ERROR_MUST_REMOVE_RAILROAD_TRACK, STR_ERROR_MUST_DEMOLISH_BRIDGE_FIRST, STR_ERROR_MUST_DEMOLISH_TUNNEL_FIRST, STR_ERROR_EXCAVATION_WOULD_DAMAGE]
 
 		/** Area / property is owned by another company */
 		ERR_OWNED_BY_ANOTHER_COMPANY,                 // [STR_ERROR_AREA_IS_OWNED_BY_ANOTHER, STR_ERROR_OWNED_BY]
 
 		/** The name given is not unique for the object type */
-		ERR_NAME_IS_NOT_UNIQUE,                       // [STR_NAME_MUST_BE_UNIQUE]
+		ERR_NAME_IS_NOT_UNIQUE,                       // [STR_ERROR_NAME_MUST_BE_UNIQUE]
 
 		/** The building you want to build requires flat land */
 		ERR_FLAT_LAND_REQUIRED,                       // [STR_ERROR_FLAT_LAND_REQUIRED]
diff --git a/src/ai/api/ai_error.hpp.sq b/src/ai/api/ai_error.hpp.sq
index e5c91074e..399118fe8 100644
--- a/src/ai/api/ai_error.hpp.sq
+++ b/src/ai/api/ai_error.hpp.sq
@@ -69,7 +69,7 @@ void SQAIError_Register(Squirrel *engine) {
 	AIError::RegisterErrorMap(STR_ERROR_MUST_DEMOLISH_BUS_STATION_FIRST,            AIError::ERR_AREA_NOT_CLEAR);
 	AIError::RegisterErrorMap(STR_ERROR_BUOY_IN_THE_WAY,                            AIError::ERR_AREA_NOT_CLEAR);
 	AIError::RegisterErrorMap(STR_ERROR_MUST_DEMOLISH_DOCK_FIRST,                   AIError::ERR_AREA_NOT_CLEAR);
-	AIError::RegisterErrorMap(STR_OBJECT_IN_THE_WAY,                                AIError::ERR_AREA_NOT_CLEAR);
+	AIError::RegisterErrorMap(STR_ERROR_UNMOVABLE_OBJECT_IN_THE_WAY,                                AIError::ERR_AREA_NOT_CLEAR);
 	AIError::RegisterErrorMap(STR_ERROR_COMPANY_HEADQUARTERS_IN,                    AIError::ERR_AREA_NOT_CLEAR);
 	AIError::RegisterErrorMap(STR_ERROR_OBJECT_IN_THE_WAY,                          AIError::ERR_AREA_NOT_CLEAR);
 	AIError::RegisterErrorMap(STR_ERROR_MUST_REMOVE_ROAD_FIRST,                     AIError::ERR_AREA_NOT_CLEAR);
@@ -79,7 +79,7 @@ void SQAIError_Register(Squirrel *engine) {
 	AIError::RegisterErrorMap(STR_ERROR_EXCAVATION_WOULD_DAMAGE,                    AIError::ERR_AREA_NOT_CLEAR);
 	AIError::RegisterErrorMap(STR_ERROR_AREA_IS_OWNED_BY_ANOTHER,                   AIError::ERR_OWNED_BY_ANOTHER_COMPANY);
 	AIError::RegisterErrorMap(STR_ERROR_OWNED_BY,                                   AIError::ERR_OWNED_BY_ANOTHER_COMPANY);
-	AIError::RegisterErrorMap(STR_NAME_MUST_BE_UNIQUE,                              AIError::ERR_NAME_IS_NOT_UNIQUE);
+	AIError::RegisterErrorMap(STR_ERROR_NAME_MUST_BE_UNIQUE,                              AIError::ERR_NAME_IS_NOT_UNIQUE);
 	AIError::RegisterErrorMap(STR_ERROR_FLAT_LAND_REQUIRED,                         AIError::ERR_FLAT_LAND_REQUIRED);
 	AIError::RegisterErrorMap(STR_ERROR_LAND_SLOPED_IN_WRONG_DIRECTION,             AIError::ERR_LAND_SLOPED_WRONG);
 	AIError::RegisterErrorMap(STR_ERROR_TRAIN_IN_THE_WAY,                           AIError::ERR_VEHICLE_IN_THE_WAY);
diff --git a/src/ai/api/ai_rail.hpp b/src/ai/api/ai_rail.hpp
index e17a5d52c..1676b959f 100644
--- a/src/ai/api/ai_rail.hpp
+++ b/src/ai/api/ai_rail.hpp
@@ -24,13 +24,13 @@ public:
 		ERR_RAIL_BASE = AIError::ERR_CAT_RAIL << AIError::ERR_CAT_BIT_SIZE,
 
 		/** One-way roads cannot have crossings */
-		ERR_CROSSING_ON_ONEWAY_ROAD,       // [STR_ERR_CROSSING_ON_ONEWAY_ROAD]
+		ERR_CROSSING_ON_ONEWAY_ROAD,       // [STR_ERROR_CROSSING_ON_ONEWAY_ROAD]
 
 		/** Track not suitable for signals */
 		ERR_UNSUITABLE_TRACK,              // [STR_ERROR_NO_SUITABLE_RAILROAD_TRACK]
 
 		/** Non-uniform stations is diabled */
-		ERR_NONUNIFORM_STATIONS_DISABLED,  // [STR_NONUNIFORM_STATIONS_DISALLOWED]
+		ERR_NONUNIFORM_STATIONS_DISABLED,  // [STR_ERROR_NONUNIFORM_STATIONS_DISALLOWED]
 	};
 
 	/**
diff --git a/src/ai/api/ai_rail.hpp.sq b/src/ai/api/ai_rail.hpp.sq
index 85d531d46..e4e19dcda 100644
--- a/src/ai/api/ai_rail.hpp.sq
+++ b/src/ai/api/ai_rail.hpp.sq
@@ -52,9 +52,9 @@ void SQAIRail_Register(Squirrel *engine) {
 	SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_COMBO_TWOWAY,          "SIGNALTYPE_COMBO_TWOWAY");
 	SQAIRail.DefSQConst(engine, AIRail::SIGNALTYPE_NONE,                  "SIGNALTYPE_NONE");
 
-	AIError::RegisterErrorMap(STR_ERR_CROSSING_ON_ONEWAY_ROAD,      AIRail::ERR_CROSSING_ON_ONEWAY_ROAD);
+	AIError::RegisterErrorMap(STR_ERROR_CROSSING_ON_ONEWAY_ROAD,      AIRail::ERR_CROSSING_ON_ONEWAY_ROAD);
 	AIError::RegisterErrorMap(STR_ERROR_NO_SUITABLE_RAILROAD_TRACK, AIRail::ERR_UNSUITABLE_TRACK);
-	AIError::RegisterErrorMap(STR_NONUNIFORM_STATIONS_DISALLOWED,   AIRail::ERR_NONUNIFORM_STATIONS_DISABLED);
+	AIError::RegisterErrorMap(STR_ERROR_NONUNIFORM_STATIONS_DISALLOWED,   AIRail::ERR_NONUNIFORM_STATIONS_DISABLED);
 
 	AIError::RegisterErrorMapString(AIRail::ERR_CROSSING_ON_ONEWAY_ROAD,      "ERR_CROSSING_ON_ONEWAY_ROAD");
 	AIError::RegisterErrorMapString(AIRail::ERR_UNSUITABLE_TRACK,             "ERR_UNSUITABLE_TRACK");
diff --git a/src/ai/api/ai_road.hpp b/src/ai/api/ai_road.hpp
index e4aefec6d..a1ff43b39 100644
--- a/src/ai/api/ai_road.hpp
+++ b/src/ai/api/ai_road.hpp
@@ -24,13 +24,13 @@ public:
 		ERR_ROAD_BASE = AIError::ERR_CAT_ROAD << AIError::ERR_CAT_BIT_SIZE,
 
 		/** Road works are in progress */
-		ERR_ROAD_WORKS_IN_PROGRESS,                   // [STR_ROAD_WORKS_IN_PROGRESS]
+		ERR_ROAD_WORKS_IN_PROGRESS,                   // [STR_ERROR_ROAD_WORKS_IN_PROGRESS]
 
 		/** Drive through is in the wrong direction */
-		ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION,       // [STR_DRIVE_THROUGH_ERROR_DIRECTION]
+		ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION,       // [STR_ERROR_DRIVE_THROUGH_DIRECTION]
 
 		/** Drive through roads can't be build on town owned roads */
-		ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD,           // [STR_DRIVE_THROUGH_ERROR_ON_TOWN_ROAD]
+		ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD,           // [STR_ERROR_DRIVE_THROUGH_ON_TOWN_ROAD]
 
 
 		/** One way roads can't have junctions */
diff --git a/src/ai/api/ai_road.hpp.sq b/src/ai/api/ai_road.hpp.sq
index 050382337..5349d0891 100644
--- a/src/ai/api/ai_road.hpp.sq
+++ b/src/ai/api/ai_road.hpp.sq
@@ -36,9 +36,9 @@ void SQAIRoad_Register(Squirrel *engine) {
 	SQAIRoad.DefSQConst(engine, AIRoad::ROADVEHTYPE_BUS,                              "ROADVEHTYPE_BUS");
 	SQAIRoad.DefSQConst(engine, AIRoad::ROADVEHTYPE_TRUCK,                            "ROADVEHTYPE_TRUCK");
 
-	AIError::RegisterErrorMap(STR_ROAD_WORKS_IN_PROGRESS,                 AIRoad::ERR_ROAD_WORKS_IN_PROGRESS);
-	AIError::RegisterErrorMap(STR_DRIVE_THROUGH_ERROR_DIRECTION,          AIRoad::ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION);
-	AIError::RegisterErrorMap(STR_DRIVE_THROUGH_ERROR_ON_TOWN_ROAD,       AIRoad::ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD);
+	AIError::RegisterErrorMap(STR_ERROR_ROAD_WORKS_IN_PROGRESS,                 AIRoad::ERR_ROAD_WORKS_IN_PROGRESS);
+	AIError::RegisterErrorMap(STR_ERROR_DRIVE_THROUGH_DIRECTION,          AIRoad::ERR_ROAD_DRIVE_THROUGH_WRONG_DIRECTION);
+	AIError::RegisterErrorMap(STR_ERROR_DRIVE_THROUGH_ON_TOWN_ROAD,       AIRoad::ERR_ROAD_CANNOT_BUILD_ON_TOWN_ROAD);
 	AIError::RegisterErrorMap(STR_ERROR_ONEWAY_ROADS_CAN_T_HAVE_JUNCTION, AIRoad::ERR_ROAD_ONE_WAY_ROADS_CANNOT_HAVE_JUNCTIONS);
 
 	AIError::RegisterErrorMapString(AIRoad::ERR_ROAD_WORKS_IN_PROGRESS,                   "ERR_ROAD_WORKS_IN_PROGRESS");
diff --git a/src/ai/api/ai_tile.hpp b/src/ai/api/ai_tile.hpp
index 589792513..b35bcc270 100644
--- a/src/ai/api/ai_tile.hpp
+++ b/src/ai/api/ai_tile.hpp
@@ -31,7 +31,7 @@ public:
 		ERR_TILE_TOO_LOW,                      // [STR_ERROR_ALREADY_AT_SEA_LEVEL]
 
 		/** The area was already flat */
-		ERR_AREA_ALREADY_FLAT,                 // [STR_ALREADY_LEVELLED]
+		ERR_AREA_ALREADY_FLAT,                 // [STR_ERROR_ALREADY_LEVELLED]
 
 		/** There is a tunnel underneed */
 		ERR_EXCAVATION_WOULD_DAMAGE,           // [STR_ERROR_EXCAVATION_WOULD_DAMAGE]
diff --git a/src/ai/api/ai_tile.hpp.sq b/src/ai/api/ai_tile.hpp.sq
index fa825a93d..4c46df1bb 100644
--- a/src/ai/api/ai_tile.hpp.sq
+++ b/src/ai/api/ai_tile.hpp.sq
@@ -67,7 +67,7 @@ void SQAITile_Register(Squirrel *engine) {
 
 	AIError::RegisterErrorMap(STR_ERROR_ALREADY_AT_SEA_LEVEL,    AITile::ERR_TILE_TOO_HIGH);
 	AIError::RegisterErrorMap(STR_ERROR_ALREADY_AT_SEA_LEVEL,    AITile::ERR_TILE_TOO_LOW);
-	AIError::RegisterErrorMap(STR_ALREADY_LEVELLED,              AITile::ERR_AREA_ALREADY_FLAT);
+	AIError::RegisterErrorMap(STR_ERROR_ALREADY_LEVELLED,              AITile::ERR_AREA_ALREADY_FLAT);
 	AIError::RegisterErrorMap(STR_ERROR_EXCAVATION_WOULD_DAMAGE, AITile::ERR_EXCAVATION_WOULD_DAMAGE);
 
 	AIError::RegisterErrorMapString(AITile::ERR_TILE_TOO_HIGH,           "ERR_TILE_TOO_HIGH");
diff --git a/src/ai/api/ai_vehicle.hpp b/src/ai/api/ai_vehicle.hpp
index f2022ba49..53786adfb 100644
--- a/src/ai/api/ai_vehicle.hpp
+++ b/src/ai/api/ai_vehicle.hpp
@@ -28,13 +28,13 @@ public:
 		ERR_VEHICLE_TOO_MANY,                   // [STR_ERROR_TOO_MANY_VEHICLES_IN_GAME]
 
 		/** Vehicle is not available */
-		ERR_VEHICLE_NOT_AVAILABLE,              // [STR_AIRCRAFT_NOT_AVAILABLE, STR_ROAD_VEHICLE_NOT_AVAILABLE, STR_SHIP_NOT_AVAILABLE, STR_RAIL_VEHICLE_NOT_AVAILABLE]
+		ERR_VEHICLE_NOT_AVAILABLE,              // [STR_ERROR_AIRCRAFT_NOT_AVAILABLE, STR_ERROR_ROAD_VEHICLE_NOT_AVAILABLE, STR_ERROR_SHIP_NOT_AVAILABLE, STR_ERROR_RAIL_VEHICLE_NOT_AVAILABLE]
 
 		/** Vehicle can't be build due to game settigns */
 		ERR_VEHICLE_BUILD_DISABLED,             // [STR_ERROR_CAN_T_BUILD_TRAIN, STR_ERROR_CAN_T_BUILD_ROAD_VEHICLE, STR_ERROR_CAN_T_BUILD_SHIP, STR_ERROR_CAN_T_BUILD_AIRCRAFT]
 
 		/** Vehicle can't be build in the selected depot */
-		ERR_VEHICLE_WRONG_DEPOT,                // [STR_DEPOT_WRONG_DEPOT_TYPE]
+		ERR_VEHICLE_WRONG_DEPOT,                // [STR_ERROR_DEPOT_WRONG_DEPOT_TYPE]
 
 		/** Vehicle can't return to the depot */
 		ERR_VEHICLE_CANNOT_SEND_TO_DEPOT,       // [STR_ERROR_CAN_T_SEND_TRAIN_TO_DEPOT, STR_ERROR_CAN_T_SEND_ROAD_VEHICLE_TO_DEPOT, STR_ERROR_CAN_T_SEND_SHIP_TO_DEPOT, STR_ERROR_CAN_T_SEND_AIRCRAFT_TO_HANGAR]
@@ -49,7 +49,7 @@ public:
 		ERR_VEHICLE_CANNOT_REFIT,               // [STR_ERROR_CAN_T_REFIT_TRAIN, STR_ERROR_CAN_T_REFIT_ROAD_VEHICLE, STR_ERROR_CAN_T_REFIT_SHIP, STR_ERROR_CAN_T_REFIT_AIRCRAFT]
 
 		/** Vehicle is destroyed */
-		ERR_VEHICLE_IS_DESTROYED,               // [STR_CAN_T_REFIT_DESTROYED_VEHICLE, STR_CAN_T_SELL_DESTROYED_VEHICLE]
+		ERR_VEHICLE_IS_DESTROYED,               // [STR_ERROR_CAN_T_REFIT_DESTROYED_VEHICLE, STR_ERROR_CAN_T_SELL_DESTROYED_VEHICLE]
 
 		/** Vehicle is not in a depot */
 		ERR_VEHICLE_NOT_IN_DEPOT,               // [STR_ERROR_AIRCRAFT_MUST_BE_STOPPED, STR_ERROR_ROAD_VEHICLE_MUST_BE_STOPPED_INSIDE_DEPOT, STR_TRAIN_MUST_BE_STOPPED, STR_ERROR_SHIP_MUST_BE_STOPPED_IN_DEPOT]
@@ -58,7 +58,7 @@ public:
 		ERR_VEHICLE_IN_FLIGHT,                  // [STR_ERROR_AIRCRAFT_IS_IN_FLIGHT]
 
 		/** Vehicle is without power */
-		ERR_VEHICLE_NO_POWER,                   // [STR_TRAIN_START_NO_CATENARY]
+		ERR_VEHICLE_NO_POWER,                   // [STR_ERROR_TRAIN_START_NO_CATENARY]
 
 	};
 
diff --git a/src/ai/api/ai_vehicle.hpp.sq b/src/ai/api/ai_vehicle.hpp.sq
index 2b802e07f..562f63e42 100644
--- a/src/ai/api/ai_vehicle.hpp.sq
+++ b/src/ai/api/ai_vehicle.hpp.sq
@@ -53,15 +53,15 @@ void SQAIVehicle_Register(Squirrel *engine) {
 	SQAIVehicle.DefSQConst(engine, AIVehicle::VS_INVALID,                       "VS_INVALID");
 
 	AIError::RegisterErrorMap(STR_ERROR_TOO_MANY_VEHICLES_IN_GAME,                           AIVehicle::ERR_VEHICLE_TOO_MANY);
-	AIError::RegisterErrorMap(STR_AIRCRAFT_NOT_AVAILABLE,                                    AIVehicle::ERR_VEHICLE_NOT_AVAILABLE);
-	AIError::RegisterErrorMap(STR_ROAD_VEHICLE_NOT_AVAILABLE,                                AIVehicle::ERR_VEHICLE_NOT_AVAILABLE);
-	AIError::RegisterErrorMap(STR_SHIP_NOT_AVAILABLE,                                        AIVehicle::ERR_VEHICLE_NOT_AVAILABLE);
-	AIError::RegisterErrorMap(STR_RAIL_VEHICLE_NOT_AVAILABLE,                                AIVehicle::ERR_VEHICLE_NOT_AVAILABLE);
+	AIError::RegisterErrorMap(STR_ERROR_AIRCRAFT_NOT_AVAILABLE,                                    AIVehicle::ERR_VEHICLE_NOT_AVAILABLE);
+	AIError::RegisterErrorMap(STR_ERROR_ROAD_VEHICLE_NOT_AVAILABLE,                                AIVehicle::ERR_VEHICLE_NOT_AVAILABLE);
+	AIError::RegisterErrorMap(STR_ERROR_SHIP_NOT_AVAILABLE,                                        AIVehicle::ERR_VEHICLE_NOT_AVAILABLE);
+	AIError::RegisterErrorMap(STR_ERROR_RAIL_VEHICLE_NOT_AVAILABLE,                                AIVehicle::ERR_VEHICLE_NOT_AVAILABLE);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_BUILD_TRAIN,                                   AIVehicle::ERR_VEHICLE_BUILD_DISABLED);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_BUILD_ROAD_VEHICLE,                            AIVehicle::ERR_VEHICLE_BUILD_DISABLED);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_BUILD_SHIP,                                    AIVehicle::ERR_VEHICLE_BUILD_DISABLED);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_BUILD_AIRCRAFT,                                AIVehicle::ERR_VEHICLE_BUILD_DISABLED);
-	AIError::RegisterErrorMap(STR_DEPOT_WRONG_DEPOT_TYPE,                                    AIVehicle::ERR_VEHICLE_WRONG_DEPOT);
+	AIError::RegisterErrorMap(STR_ERROR_DEPOT_WRONG_DEPOT_TYPE,                                    AIVehicle::ERR_VEHICLE_WRONG_DEPOT);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_SEND_TRAIN_TO_DEPOT,                           AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_SEND_ROAD_VEHICLE_TO_DEPOT,                    AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_SEND_SHIP_TO_DEPOT,                            AIVehicle::ERR_VEHICLE_CANNOT_SEND_TO_DEPOT);
@@ -78,14 +78,14 @@ void SQAIVehicle_Register(Squirrel *engine) {
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_REFIT_ROAD_VEHICLE,                            AIVehicle::ERR_VEHICLE_CANNOT_REFIT);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_REFIT_SHIP,                                    AIVehicle::ERR_VEHICLE_CANNOT_REFIT);
 	AIError::RegisterErrorMap(STR_ERROR_CAN_T_REFIT_AIRCRAFT,                                AIVehicle::ERR_VEHICLE_CANNOT_REFIT);
-	AIError::RegisterErrorMap(STR_CAN_T_REFIT_DESTROYED_VEHICLE,                             AIVehicle::ERR_VEHICLE_IS_DESTROYED);
-	AIError::RegisterErrorMap(STR_CAN_T_SELL_DESTROYED_VEHICLE,                              AIVehicle::ERR_VEHICLE_IS_DESTROYED);
+	AIError::RegisterErrorMap(STR_ERROR_CAN_T_REFIT_DESTROYED_VEHICLE,                             AIVehicle::ERR_VEHICLE_IS_DESTROYED);
+	AIError::RegisterErrorMap(STR_ERROR_CAN_T_SELL_DESTROYED_VEHICLE,                              AIVehicle::ERR_VEHICLE_IS_DESTROYED);
 	AIError::RegisterErrorMap(STR_ERROR_AIRCRAFT_MUST_BE_STOPPED,                            AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT);
 	AIError::RegisterErrorMap(STR_ERROR_ROAD_VEHICLE_MUST_BE_STOPPED_INSIDE_DEPOT,           AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT);
 	AIError::RegisterErrorMap(STR_TRAIN_MUST_BE_STOPPED,                                     AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT);
 	AIError::RegisterErrorMap(STR_ERROR_SHIP_MUST_BE_STOPPED_IN_DEPOT,                       AIVehicle::ERR_VEHICLE_NOT_IN_DEPOT);
 	AIError::RegisterErrorMap(STR_ERROR_AIRCRAFT_IS_IN_FLIGHT,                               AIVehicle::ERR_VEHICLE_IN_FLIGHT);
-	AIError::RegisterErrorMap(STR_TRAIN_START_NO_CATENARY,                                   AIVehicle::ERR_VEHICLE_NO_POWER);
+	AIError::RegisterErrorMap(STR_ERROR_TRAIN_START_NO_CATENARY,                                   AIVehicle::ERR_VEHICLE_NO_POWER);
 
 	AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_TOO_MANY,             "ERR_VEHICLE_TOO_MANY");
 	AIError::RegisterErrorMapString(AIVehicle::ERR_VEHICLE_NOT_AVAILABLE,        "ERR_VEHICLE_NOT_AVAILABLE");