(svn r23355) -Codechange: rename all AI* to Script* (Rubidium)

1 files changed, 123 insertions, 123 deletions

diff --git a/src/script/api/script_order.cpp b/src/script/api/script_order.cpp
index 1811207cb..7a06f68e3 100644
--- a/src/script/api/script_order.cpp
+++ b/src/script/api/script_order.cpp
@@ -7,7 +7,7 @@
  * See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with OpenTTD. If not, see <http://www.gnu.org/licenses/>.
  */
 
-/** @file script_order.cpp Implementation of AIOrder. */
+/** @file script_order.cpp Implementation of ScriptOrder. */
 
 #include "../../stdafx.h"
 #include "script_order.hpp"
@@ -47,9 +47,9 @@ static OrderType GetOrderTypeByTile(TileIndex t)
 	return OT_END;
 }
 
-/* static */ bool AIOrder::IsValidVehicleOrder(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ bool ScriptOrder::IsValidVehicleOrder(VehicleID vehicle_id, OrderPosition order_position)
 {
-	return AIVehicle::IsValidVehicle(vehicle_id) && order_position >= 0 && (order_position < ::Vehicle::Get(vehicle_id)->GetNumManualOrders() || order_position == ORDER_CURRENT);
+	return ScriptVehicle::IsValidVehicle(vehicle_id) && order_position >= 0 && (order_position < ::Vehicle::Get(vehicle_id)->GetNumManualOrders() || order_position == ORDER_CURRENT);
 }
 
 /**
@@ -57,19 +57,19 @@ static OrderType GetOrderTypeByTile(TileIndex t)
  *  the order list, return the order from the orderlist. If the current order
  *  was a manual order, return the current order.
  */
-static const Order *ResolveOrder(VehicleID vehicle_id, AIOrder::OrderPosition order_position)
+static const Order *ResolveOrder(VehicleID vehicle_id, ScriptOrder::OrderPosition order_position)
 {
 	const Vehicle *v = ::Vehicle::Get(vehicle_id);
-	if (order_position == AIOrder::ORDER_CURRENT) {
+	if (order_position == ScriptOrder::ORDER_CURRENT) {
 		const Order *order = &v->current_order;
 		if (order->GetType() == OT_GOTO_DEPOT && !(order->GetDepotOrderType() & ODTFB_PART_OF_ORDERS)) return order;
-		order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position);
-		if (order_position == AIOrder::ORDER_INVALID) return NULL;
+		order_position = ScriptOrder::ResolveOrderPosition(vehicle_id, order_position);
+		if (order_position == ScriptOrder::ORDER_INVALID) return NULL;
 	}
 	const Order *order = v->orders.list->GetFirstOrder();
 	while (order->GetType() == OT_IMPLICIT) order = order->next;
 	while (order_position > 0) {
-		order_position = (AIOrder::OrderPosition)(order_position - 1);
+		order_position = (ScriptOrder::OrderPosition)(order_position - 1);
 		order = order->next;
 		while (order->GetType() == OT_IMPLICIT) order = order->next;
 	}
@@ -77,23 +77,23 @@ static const Order *ResolveOrder(VehicleID vehicle_id, AIOrder::OrderPosition or
 }
 
 /**
- * Convert an AIOrder::OrderPosition (which is the manual order index) to an order index
+ * Convert an ScriptOrder::OrderPosition (which is the manual order index) to an order index
  * as expected by the OpenTTD commands.
  * @param order_position The OrderPosition to convert.
  * @return An OpenTTD-internal index for the same order.
  */
-static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::OrderPosition order_position)
+static int ScriptOrderPositionToRealOrderPosition(VehicleID vehicle_id, ScriptOrder::OrderPosition order_position)
 {
 	const Vehicle *v = ::Vehicle::Get(vehicle_id);
 	if (order_position == v->GetNumManualOrders()) return v->GetNumOrders();
 
-	assert(AIOrder::IsValidVehicleOrder(vehicle_id, order_position));
+	assert(ScriptOrder::IsValidVehicleOrder(vehicle_id, order_position));
 
 	int res = (int)order_position;
 	const Order *order = v->orders.list->GetFirstOrder();
 	for (; order->GetType() == OT_IMPLICIT; order = order->next) res++;
 	while (order_position > 0) {
-		order_position = (AIOrder::OrderPosition)(order_position - 1);
+		order_position = (ScriptOrder::OrderPosition)(order_position - 1);
 		order = order->next;
 		for (; order->GetType() == OT_IMPLICIT; order = order->next) res++;
 	}
@@ -101,7 +101,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return res;
 }
 
-/* static */ bool AIOrder::IsGotoStationOrder(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ bool ScriptOrder::IsGotoStationOrder(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return false;
 
@@ -109,7 +109,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return order != NULL && order->GetType() == OT_GOTO_STATION;
 }
 
-/* static */ bool AIOrder::IsGotoDepotOrder(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ bool ScriptOrder::IsGotoDepotOrder(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return false;
 
@@ -117,7 +117,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return order != NULL && order->GetType() == OT_GOTO_DEPOT;
 }
 
-/* static */ bool AIOrder::IsGotoWaypointOrder(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ bool ScriptOrder::IsGotoWaypointOrder(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return false;
 
@@ -125,16 +125,16 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return order != NULL && order->GetType() == OT_GOTO_WAYPOINT;
 }
 
-/* static */ bool AIOrder::IsConditionalOrder(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ bool ScriptOrder::IsConditionalOrder(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (order_position == ORDER_CURRENT) return false;
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return false;
 
-	const Order *order = ::Vehicle::Get(vehicle_id)->GetOrder(AIOrderPositionToRealOrderPosition(vehicle_id, order_position));
+	const Order *order = ::Vehicle::Get(vehicle_id)->GetOrder(ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position));
 	return order->GetType() == OT_CONDITIONAL;
 }
 
-/* static */ bool AIOrder::IsVoidOrder(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ bool ScriptOrder::IsVoidOrder(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (order_position == ORDER_CURRENT) return false;
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return false;
@@ -143,7 +143,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return order->GetType() == OT_DUMMY;
 }
 
-/* static */ bool AIOrder::IsRefitOrder(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ bool ScriptOrder::IsRefitOrder(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return false;
 
@@ -151,9 +151,9 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return order != NULL && order->IsRefit();
 }
 
-/* static */ bool AIOrder::IsCurrentOrderPartOfOrderList(VehicleID vehicle_id)
+/* static */ bool ScriptOrder::IsCurrentOrderPartOfOrderList(VehicleID vehicle_id)
 {
-	if (!AIVehicle::IsValidVehicle(vehicle_id)) return false;
+	if (!ScriptVehicle::IsValidVehicle(vehicle_id)) return false;
 	if (GetOrderCount(vehicle_id) == 0) return false;
 
 	const Order *order = &::Vehicle::Get(vehicle_id)->current_order;
@@ -161,9 +161,9 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return (order->GetDepotOrderType() & ODTFB_PART_OF_ORDERS) != 0;
 }
 
-/* static */ AIOrder::OrderPosition AIOrder::ResolveOrderPosition(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ ScriptOrder::OrderPosition ScriptOrder::ResolveOrderPosition(VehicleID vehicle_id, OrderPosition order_position)
 {
-	if (!AIVehicle::IsValidVehicle(vehicle_id)) return ORDER_INVALID;
+	if (!ScriptVehicle::IsValidVehicle(vehicle_id)) return ORDER_INVALID;
 
 	if (order_position == ORDER_CURRENT) {
 		int cur_order_pos = ::Vehicle::Get(vehicle_id)->cur_real_order_index;
@@ -174,13 +174,13 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 			if (order->GetType() == OT_IMPLICIT) num_implicit_orders++;
 			order = order->next;
 		}
-		return (AIOrder::OrderPosition)(cur_order_pos - num_implicit_orders);
+		return (ScriptOrder::OrderPosition)(cur_order_pos - num_implicit_orders);
 	}
 	return (order_position >= 0 && order_position < ::Vehicle::Get(vehicle_id)->GetNumManualOrders()) ? order_position : ORDER_INVALID;
 }
 
 
-/* static */ bool AIOrder::AreOrderFlagsValid(TileIndex destination, AIOrderFlags order_flags)
+/* static */ bool ScriptOrder::AreOrderFlagsValid(TileIndex destination, ScriptOrderFlags order_flags)
 {
 	OrderType ot = (order_flags & AIOF_GOTO_NEAREST_DEPOT) ? OT_GOTO_DEPOT : ::GetOrderTypeByTile(destination);
 	switch (ot) {
@@ -203,7 +203,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	}
 }
 
-/* static */ bool AIOrder::IsValidConditionalOrder(OrderCondition condition, CompareFunction compare)
+/* static */ bool ScriptOrder::IsValidConditionalOrder(OrderCondition condition, CompareFunction compare)
 {
 	switch (condition) {
 		case OC_LOAD_PERCENTAGE:
@@ -223,12 +223,12 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	}
 }
 
-/* static */ int32 AIOrder::GetOrderCount(VehicleID vehicle_id)
+/* static */ int32 ScriptOrder::GetOrderCount(VehicleID vehicle_id)
 {
-	return AIVehicle::IsValidVehicle(vehicle_id) ? ::Vehicle::Get(vehicle_id)->GetNumManualOrders() : -1;
+	return ScriptVehicle::IsValidVehicle(vehicle_id) ? ::Vehicle::Get(vehicle_id)->GetNumManualOrders() : -1;
 }
 
-/* static */ TileIndex AIOrder::GetOrderDestination(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ TileIndex ScriptOrder::GetOrderDestination(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return INVALID_TILE;
 
@@ -282,15 +282,15 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	}
 }
 
-/* static */ AIOrder::AIOrderFlags AIOrder::GetOrderFlags(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ ScriptOrder::ScriptOrderFlags ScriptOrder::GetOrderFlags(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return AIOF_INVALID;
 
 	const Order *order = ::ResolveOrder(vehicle_id, order_position);
 	if (order == NULL || order->GetType() == OT_CONDITIONAL || order->GetType() == OT_DUMMY) return AIOF_INVALID;
 
-	AIOrderFlags order_flags = AIOF_NONE;
-	order_flags |= (AIOrderFlags)order->GetNonStopType();
+	ScriptOrderFlags order_flags = AIOF_NONE;
+	order_flags |= (ScriptOrderFlags)order->GetNonStopType();
 	switch (order->GetType()) {
 		case OT_GOTO_DEPOT:
 			if (order->GetDepotOrderType() & ODTFB_SERVICE) order_flags |= AIOF_SERVICE_IF_NEEDED;
@@ -299,8 +299,8 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 			break;
 
 		case OT_GOTO_STATION:
-			order_flags |= (AIOrderFlags)(order->GetLoadType()   << 5);
-			order_flags |= (AIOrderFlags)(order->GetUnloadType() << 2);
+			order_flags |= (ScriptOrderFlags)(order->GetLoadType()   << 5);
+			order_flags |= (ScriptOrderFlags)(order->GetUnloadType() << 2);
 			break;
 
 		default: break;
@@ -309,7 +309,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return order_flags;
 }
 
-/* static */ AIOrder::OrderPosition AIOrder::GetOrderJumpTo(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ ScriptOrder::OrderPosition ScriptOrder::GetOrderJumpTo(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return ORDER_INVALID;
 	if (order_position == ORDER_CURRENT || !IsConditionalOrder(vehicle_id, order_position)) return ORDER_INVALID;
@@ -318,7 +318,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return (OrderPosition)order->GetConditionSkipToOrder();
 }
 
-/* static */ AIOrder::OrderCondition AIOrder::GetOrderCondition(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ ScriptOrder::OrderCondition ScriptOrder::GetOrderCondition(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return OC_INVALID;
 	if (order_position == ORDER_CURRENT || !IsConditionalOrder(vehicle_id, order_position)) return OC_INVALID;
@@ -327,7 +327,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return (OrderCondition)order->GetConditionVariable();
 }
 
-/* static */ AIOrder::CompareFunction AIOrder::GetOrderCompareFunction(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ ScriptOrder::CompareFunction ScriptOrder::GetOrderCompareFunction(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return CF_INVALID;
 	if (order_position == ORDER_CURRENT || !IsConditionalOrder(vehicle_id, order_position)) return CF_INVALID;
@@ -336,7 +336,7 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return (CompareFunction)order->GetConditionComparator();
 }
 
-/* static */ int32 AIOrder::GetOrderCompareValue(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ int32 ScriptOrder::GetOrderCompareValue(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return -1;
 	if (order_position == ORDER_CURRENT || !IsConditionalOrder(vehicle_id, order_position)) return -1;
@@ -347,17 +347,17 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return value;
 }
 
-/* static */ AIOrder::StopLocation AIOrder::GetStopLocation(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ ScriptOrder::StopLocation ScriptOrder::GetStopLocation(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return STOPLOCATION_INVALID;
-	if (AIVehicle::GetVehicleType(vehicle_id) != AIVehicle::VT_RAIL) return STOPLOCATION_INVALID;
+	if (ScriptVehicle::GetVehicleType(vehicle_id) != ScriptVehicle::VT_RAIL) return STOPLOCATION_INVALID;
 	if (!IsGotoStationOrder(vehicle_id, order_position)) return STOPLOCATION_INVALID;
 
 	const Order *order = ::ResolveOrder(vehicle_id, order_position);
-	return (AIOrder::StopLocation)order->GetStopLocation();
+	return (ScriptOrder::StopLocation)order->GetStopLocation();
 }
 
-/* static */ CargoID AIOrder::GetOrderRefit(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ CargoID ScriptOrder::GetOrderRefit(VehicleID vehicle_id, OrderPosition order_position)
 {
 	if (!IsValidVehicleOrder(vehicle_id, order_position)) return CT_NO_REFIT;
 	if (order_position != ORDER_CURRENT && !IsGotoStationOrder(vehicle_id, order_position) && !IsGotoDepotOrder(vehicle_id, order_position)) return CT_NO_REFIT;
@@ -366,94 +366,94 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 	return order->IsRefit() ? order->GetRefitCargo() : (CargoID)CT_NO_REFIT;
 }
 
-/* static */ bool AIOrder::SetOrderJumpTo(VehicleID vehicle_id, OrderPosition order_position, OrderPosition jump_to)
+/* static */ bool ScriptOrder::SetOrderJumpTo(VehicleID vehicle_id, OrderPosition order_position, OrderPosition jump_to)
 {
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, order_position != ORDER_CURRENT && IsConditionalOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, jump_to) && jump_to != ORDER_CURRENT);
 
-	return AIObject::DoCommand(0, vehicle_id | (order_position << 20), MOF_COND_DESTINATION | (jump_to << 4), CMD_MODIFY_ORDER);
+	return ScriptObject::DoCommand(0, vehicle_id | (order_position << 20), MOF_COND_DESTINATION | (jump_to << 4), CMD_MODIFY_ORDER);
 }
 
-/* static */ bool AIOrder::SetOrderCondition(VehicleID vehicle_id, OrderPosition order_position, OrderCondition condition)
+/* static */ bool ScriptOrder::SetOrderCondition(VehicleID vehicle_id, OrderPosition order_position, OrderCondition condition)
 {
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, order_position != ORDER_CURRENT && IsConditionalOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, condition >= OC_LOAD_PERCENTAGE && condition <= OC_REMAINING_LIFETIME);
 
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, order_position);
-	return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), MOF_COND_VARIABLE | (condition << 4), CMD_MODIFY_ORDER);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position);
+	return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), MOF_COND_VARIABLE | (condition << 4), CMD_MODIFY_ORDER);
 }
 
-/* static */ bool AIOrder::SetOrderCompareFunction(VehicleID vehicle_id, OrderPosition order_position, CompareFunction compare)
+/* static */ bool ScriptOrder::SetOrderCompareFunction(VehicleID vehicle_id, OrderPosition order_position, CompareFunction compare)
 {
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, order_position != ORDER_CURRENT && IsConditionalOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, compare >= CF_EQUALS && compare <= CF_IS_FALSE);
 
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, order_position);
-	return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), MOF_COND_COMPARATOR | (compare << 4), CMD_MODIFY_ORDER);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position);
+	return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), MOF_COND_COMPARATOR | (compare << 4), CMD_MODIFY_ORDER);
 }
 
-/* static */ bool AIOrder::SetOrderCompareValue(VehicleID vehicle_id, OrderPosition order_position, int32 value)
+/* static */ bool ScriptOrder::SetOrderCompareValue(VehicleID vehicle_id, OrderPosition order_position, int32 value)
 {
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, order_position != ORDER_CURRENT && IsConditionalOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, value >= 0 && value < 2048);
 	if (GetOrderCondition(vehicle_id, order_position) == OC_MAX_SPEED) value = value * 10 / 16;
 
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, order_position);
-	return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), MOF_COND_VALUE | (value << 4), CMD_MODIFY_ORDER);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position);
+	return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), MOF_COND_VALUE | (value << 4), CMD_MODIFY_ORDER);
 }
 
-/* static */ bool AIOrder::SetStopLocation(VehicleID vehicle_id, OrderPosition order_position, StopLocation stop_location)
+/* static */ bool ScriptOrder::SetStopLocation(VehicleID vehicle_id, OrderPosition order_position, StopLocation stop_location)
 {
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));
-	EnforcePrecondition(false, AIVehicle::GetVehicleType(vehicle_id) == AIVehicle::VT_RAIL);
+	EnforcePrecondition(false, ScriptVehicle::GetVehicleType(vehicle_id) == ScriptVehicle::VT_RAIL);
 	EnforcePrecondition(false, IsGotoStationOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, stop_location >= STOPLOCATION_NEAR && stop_location <= STOPLOCATION_FAR);
 
-	order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position);
+	order_position = ScriptOrder::ResolveOrderPosition(vehicle_id, order_position);
 
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, order_position);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position);
 	uint32 p1 = vehicle_id | (order_pos << 20);
 	uint32 p2 = MOF_STOP_LOCATION | (stop_location << 4);
-	return AIObject::DoCommand(0, p1, p2, CMD_MODIFY_ORDER);
+	return ScriptObject::DoCommand(0, p1, p2, CMD_MODIFY_ORDER);
 }
 
-/* static */ bool AIOrder::SetOrderRefit(VehicleID vehicle_id, OrderPosition order_position, CargoID refit_cargo)
+/* static */ bool ScriptOrder::SetOrderRefit(VehicleID vehicle_id, OrderPosition order_position, CargoID refit_cargo)
 {
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, IsGotoStationOrder(vehicle_id, order_position) || (IsGotoDepotOrder(vehicle_id, order_position) && refit_cargo != CT_AUTO_REFIT));
-	EnforcePrecondition(false, AICargo::IsValidCargo(refit_cargo) || refit_cargo == CT_AUTO_REFIT || refit_cargo == CT_NO_REFIT);
+	EnforcePrecondition(false, ScriptCargo::IsValidCargo(refit_cargo) || refit_cargo == CT_AUTO_REFIT || refit_cargo == CT_NO_REFIT);
 
 	uint32 p1 = vehicle_id;
-	uint32 p2 = refit_cargo | AIOrderPositionToRealOrderPosition(vehicle_id, AIOrder::ResolveOrderPosition(vehicle_id, order_position)) << 16;
-	return AIObject::DoCommand(0, p1, p2, CMD_ORDER_REFIT);
+	uint32 p2 = refit_cargo | ScriptOrderPositionToRealOrderPosition(vehicle_id, ScriptOrder::ResolveOrderPosition(vehicle_id, order_position)) << 16;
+	return ScriptObject::DoCommand(0, p1, p2, CMD_ORDER_REFIT);
 }
 
-/* static */ bool AIOrder::AppendOrder(VehicleID vehicle_id, TileIndex destination, AIOrderFlags order_flags)
+/* static */ bool ScriptOrder::AppendOrder(VehicleID vehicle_id, TileIndex destination, ScriptOrderFlags order_flags)
 {
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(vehicle_id));
 	EnforcePrecondition(false, AreOrderFlagsValid(destination, order_flags));
 
-	return InsertOrder(vehicle_id, (AIOrder::OrderPosition)::Vehicle::Get(vehicle_id)->GetNumManualOrders(), destination, order_flags);
+	return InsertOrder(vehicle_id, (ScriptOrder::OrderPosition)::Vehicle::Get(vehicle_id)->GetNumManualOrders(), destination, order_flags);
 }
 
-/* static */ bool AIOrder::AppendConditionalOrder(VehicleID vehicle_id, OrderPosition jump_to)
+/* static */ bool ScriptOrder::AppendConditionalOrder(VehicleID vehicle_id, OrderPosition jump_to)
 {
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(vehicle_id));
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, jump_to));
 
-	return InsertConditionalOrder(vehicle_id, (AIOrder::OrderPosition)::Vehicle::Get(vehicle_id)->GetNumManualOrders(), jump_to);
+	return InsertConditionalOrder(vehicle_id, (ScriptOrder::OrderPosition)::Vehicle::Get(vehicle_id)->GetNumManualOrders(), jump_to);
 }
 
-/* static */ bool AIOrder::InsertOrder(VehicleID vehicle_id, OrderPosition order_position, TileIndex destination, AIOrder::AIOrderFlags order_flags)
+/* static */ bool ScriptOrder::InsertOrder(VehicleID vehicle_id, OrderPosition order_position, TileIndex destination, ScriptOrder::ScriptOrderFlags order_flags)
 {
 	/* IsValidVehicleOrder is not good enough because it does not allow appending. */
-	if (order_position == ORDER_CURRENT) order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position);
+	if (order_position == ORDER_CURRENT) order_position = ScriptOrder::ResolveOrderPosition(vehicle_id, order_position);
 
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(vehicle_id));
 	EnforcePrecondition(false, order_position >= 0 && order_position <= ::Vehicle::Get(vehicle_id)->GetNumManualOrders());
 	EnforcePrecondition(false, AreOrderFlagsValid(destination, order_flags));
 
@@ -498,44 +498,44 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
 
 	order.SetNonStopType((OrderNonStopFlags)GB(order_flags, 0, 2));
 
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, order_position);
-	return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), order.Pack(), CMD_INSERT_ORDER);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position);
+	return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), order.Pack(), CMD_INSERT_ORDER);
 }
 
-/* static */ bool AIOrder::InsertConditionalOrder(VehicleID vehicle_id, OrderPosition order_position, OrderPosition jump_to)
+/* static */ bool ScriptOrder::InsertConditionalOrder(VehicleID vehicle_id, OrderPosition order_position, OrderPosition jump_to)
 {
 	/* IsValidVehicleOrder is not good enough because it does not allow appending. */
-	if (order_position == ORDER_CURRENT) order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position);
+	if (order_position == ORDER_CURRENT) order_position = ScriptOrder::ResolveOrderPosition(vehicle_id, order_position);
 
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(vehicle_id));
 	EnforcePrecondition(false, order_position >= 0 && order_position <= ::Vehicle::Get(vehicle_id)->GetNumManualOrders());
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, jump_to) && jump_to != ORDER_CURRENT);
 
 	Order order;
 	order.MakeConditional(jump_to);
 
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, order_position);
-	return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), order.Pack(), CMD_INSERT_ORDER);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position);
+	return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), order.Pack(), CMD_INSERT_ORDER);
 }
 
-/* static */ bool AIOrder::RemoveOrder(VehicleID vehicle_id, OrderPosition order_position)
+/* static */ bool ScriptOrder::RemoveOrder(VehicleID vehicle_id, OrderPosition order_position)
 {
-	order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position);
+	order_position = ScriptOrder::ResolveOrderPosition(vehicle_id, order_position);
 
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));
 
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, order_position);
-	return AIObject::DoCommand(0, vehicle_id, order_pos, CMD_DELETE_ORDER);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position);
+	return ScriptObject::DoCommand(0, vehicle_id, order_pos, CMD_DELETE_ORDER);
 }
 
-/* static */ bool AIOrder::SkipToOrder(VehicleID vehicle_id, OrderPosition next_order)
+/* static */ bool ScriptOrder::SkipToOrder(VehicleID vehicle_id, OrderPosition next_order)
 {
-	next_order = AIOrder::ResolveOrderPosition(vehicle_id, next_order);
+	next_order = ScriptOrder::ResolveOrderPosition(vehicle_id, next_order);
 
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, next_order));
 
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, next_order);
-	return AIObject::DoCommand(0, vehicle_id, order_pos, CMD_SKIP_TO_ORDER);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, next_order);
+	return ScriptObject::DoCommand(0, vehicle_id, order_pos, CMD_SKIP_TO_ORDER);
 }
 
 /**
@@ -548,38 +548,38 @@ static int AIOrderPositionToRealOrderPosition(VehicleID vehicle_id, AIOrder::Ord
  */
 static void _DoCommandReturnSetOrderFlags(class AIInstance *instance)
 {
-	AIObject::SetLastCommandRes(AIOrder::_SetOrderFlags());
+	ScriptObject::SetLastCommandRes(ScriptOrder::_SetOrderFlags());
 	AIInstance::DoCommandReturn(instance);
 }
 
-/* static */ bool AIOrder::_SetOrderFlags()
+/* static */ bool ScriptOrder::_SetOrderFlags()
 {
 	/* Make sure we don't go into an infinite loop */
-	int retry = AIObject::GetCallbackVariable(3) - 1;
+	int retry = ScriptObject::GetCallbackVariable(3) - 1;
 	if (retry < 0) {
 		DEBUG(ai, 0, "Possible infinite loop in SetOrderFlags() detected");
 		return false;
 	}
-	AIObject::SetCallbackVariable(3, retry);
+	ScriptObject::SetCallbackVariable(3, retry);
 
-	VehicleID vehicle_id = (VehicleID)AIObject::GetCallbackVariable(0);
-	OrderPosition order_position = (OrderPosition)AIObject::GetCallbackVariable(1);
-	AIOrderFlags order_flags = (AIOrderFlags)AIObject::GetCallbackVariable(2);
+	VehicleID vehicle_id = (VehicleID)ScriptObject::GetCallbackVariable(0);
+	OrderPosition order_position = (OrderPosition)ScriptObject::GetCallbackVariable(1);
+	ScriptOrderFlags order_flags = (ScriptOrderFlags)ScriptObject::GetCallbackVariable(2);
 
-	order_position = AIOrder::ResolveOrderPosition(vehicle_id, order_position);
+	order_position = ScriptOrder::ResolveOrderPosition(vehicle_id, order_position);
 
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position));
 	EnforcePrecondition(false, AreOrderFlagsValid(GetOrderDestination(vehicle_id, order_position), order_flags));
 
 	const Order *order = ::ResolveOrder(vehicle_id, order_position);
-	int order_pos = AIOrderPositionToRealOrderPosition(vehicle_id, order_position);
+	int order_pos = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position);
 
-	AIOrderFlags current = GetOrderFlags(vehicle_id, order_position);
+	ScriptOrderFlags current = GetOrderFlags(vehicle_id, order_position);
 
 	EnforcePrecondition(false, (order_flags & AIOF_GOTO_NEAREST_DEPOT) == (current & AIOF_GOTO_NEAREST_DEPOT));
 
 	if ((current & AIOF_NON_STOP_FLAGS) != (order_flags & AIOF_NON_STOP_FLAGS)) {
-		return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), (order_flags & AIOF_NON_STOP_FLAGS) << 4 | MOF_NON_STOP, CMD_MODIFY_ORDER, NULL, &::_DoCommandReturnSetOrderFlags);
+		return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), (order_flags & AIOF_NON_STOP_FLAGS) << 4 | MOF_NON_STOP, CMD_MODIFY_ORDER, NULL, &::_DoCommandReturnSetOrderFlags);
 	}
 
 	switch (order->GetType()) {
@@ -588,16 +588,16 @@ static void _DoCommandReturnSetOrderFlags(class AIInstance *instance)
 				uint data = DA_ALWAYS_GO;
 				if (order_flags & AIOF_SERVICE_IF_NEEDED) data = DA_SERVICE;
 				if (order_flags & AIOF_STOP_IN_DEPOT) data = DA_STOP;
-				return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), (data << 4) | MOF_DEPOT_ACTION, CMD_MODIFY_ORDER, NULL, &::_DoCommandReturnSetOrderFlags);
+				return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), (data << 4) | MOF_DEPOT_ACTION, CMD_MODIFY_ORDER, NULL, &::_DoCommandReturnSetOrderFlags);
 			}
 			break;
 
 		case OT_GOTO_STATION:
 			if ((current & AIOF_UNLOAD_FLAGS) != (order_flags & AIOF_UNLOAD_FLAGS)) {
-				return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), (order_flags & AIOF_UNLOAD_FLAGS) << 2 | MOF_UNLOAD, CMD_MODIFY_ORDER, NULL, &::_DoCommandReturnSetOrderFlags);
+				return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), (order_flags & AIOF_UNLOAD_FLAGS) << 2 | MOF_UNLOAD, CMD_MODIFY_ORDER, NULL, &::_DoCommandReturnSetOrderFlags);
 			}
 			if ((current & AIOF_LOAD_FLAGS) != (order_flags & AIOF_LOAD_FLAGS)) {
-				return AIObject::DoCommand(0, vehicle_id | (order_pos << 20), (order_flags & AIOF_LOAD_FLAGS) >> 1 | MOF_LOAD, CMD_MODIFY_ORDER, NULL, &::_DoCommandReturnSetOrderFlags);
+				return ScriptObject::DoCommand(0, vehicle_id | (order_pos << 20), (order_flags & AIOF_LOAD_FLAGS) >> 1 | MOF_LOAD, CMD_MODIFY_ORDER, NULL, &::_DoCommandReturnSetOrderFlags);
 			}
 			break;
 
@@ -609,49 +609,49 @@ static void _DoCommandReturnSetOrderFlags(class AIInstance *instance)
 	return true;
 }
 
-/* static */ bool AIOrder::SetOrderFlags(VehicleID vehicle_id, OrderPosition order_position, AIOrder::AIOrderFlags order_flags)
+/* static */ bool ScriptOrder::SetOrderFlags(VehicleID vehicle_id, OrderPosition order_position, ScriptOrder::ScriptOrderFlags order_flags)
 {
-	AIObject::SetCallbackVariable(0, vehicle_id);
-	AIObject::SetCallbackVariable(1, order_position);
-	AIObject::SetCallbackVariable(2, order_flags);
+	ScriptObject::SetCallbackVariable(0, vehicle_id);
+	ScriptObject::SetCallbackVariable(1, order_position);
+	ScriptObject::SetCallbackVariable(2, order_flags);
 	/* In case another client(s) change orders at the same time we could
 	 * end in an infinite loop. This stops that from happening ever. */
-	AIObject::SetCallbackVariable(3, 8);
-	return AIOrder::_SetOrderFlags();
+	ScriptObject::SetCallbackVariable(3, 8);
+	return ScriptOrder::_SetOrderFlags();
 }
 
-/* static */ bool AIOrder::MoveOrder(VehicleID vehicle_id, OrderPosition order_position_move, OrderPosition order_position_target)
+/* static */ bool ScriptOrder::MoveOrder(VehicleID vehicle_id, OrderPosition order_position_move, OrderPosition order_position_target)
 {
-	order_position_move   = AIOrder::ResolveOrderPosition(vehicle_id, order_position_move);
-	order_position_target = AIOrder::ResolveOrderPosition(vehicle_id, order_position_target);
+	order_position_move   = ScriptOrder::ResolveOrderPosition(vehicle_id, order_position_move);
+	order_position_target = ScriptOrder::ResolveOrderPosition(vehicle_id, order_position_target);
 
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position_move));
 	EnforcePrecondition(false, IsValidVehicleOrder(vehicle_id, order_position_target));
 
-	int order_pos_move = AIOrderPositionToRealOrderPosition(vehicle_id, order_position_move);
-	int order_pos_target = AIOrderPositionToRealOrderPosition(vehicle_id, order_position_target);
-	return AIObject::DoCommand(0, vehicle_id, order_pos_move | (order_pos_target << 16), CMD_MOVE_ORDER);
+	int order_pos_move = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position_move);
+	int order_pos_target = ScriptOrderPositionToRealOrderPosition(vehicle_id, order_position_target);
+	return ScriptObject::DoCommand(0, vehicle_id, order_pos_move | (order_pos_target << 16), CMD_MOVE_ORDER);
 }
 
-/* static */ bool AIOrder::CopyOrders(VehicleID vehicle_id, VehicleID main_vehicle_id)
+/* static */ bool ScriptOrder::CopyOrders(VehicleID vehicle_id, VehicleID main_vehicle_id)
 {
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(main_vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(main_vehicle_id));
 
-	return AIObject::DoCommand(0, vehicle_id | CO_COPY << 30, main_vehicle_id, CMD_CLONE_ORDER);
+	return ScriptObject::DoCommand(0, vehicle_id | CO_COPY << 30, main_vehicle_id, CMD_CLONE_ORDER);
 }
 
-/* static */ bool AIOrder::ShareOrders(VehicleID vehicle_id, VehicleID main_vehicle_id)
+/* static */ bool ScriptOrder::ShareOrders(VehicleID vehicle_id, VehicleID main_vehicle_id)
 {
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(main_vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(main_vehicle_id));
 
-	return AIObject::DoCommand(0, vehicle_id | CO_SHARE << 30, main_vehicle_id, CMD_CLONE_ORDER);
+	return ScriptObject::DoCommand(0, vehicle_id | CO_SHARE << 30, main_vehicle_id, CMD_CLONE_ORDER);
 }
 
-/* static */ bool AIOrder::UnshareOrders(VehicleID vehicle_id)
+/* static */ bool ScriptOrder::UnshareOrders(VehicleID vehicle_id)
 {
-	EnforcePrecondition(false, AIVehicle::IsValidVehicle(vehicle_id));
+	EnforcePrecondition(false, ScriptVehicle::IsValidVehicle(vehicle_id));
 
-	return AIObject::DoCommand(0, vehicle_id | CO_UNSHARE << 30, 0, CMD_CLONE_ORDER);
+	return ScriptObject::DoCommand(0, vehicle_id | CO_UNSHARE << 30, 0, CMD_CLONE_ORDER);
 }