--- a/src/ai/api/ai_enginelist_valuator.hpp.sq	Sun Feb 24 22:05:07 2008 +0000
+++ b/src/ai/api/ai_enginelist_valuator.hpp.sq	Sun Feb 24 22:10:05 2008 +0000
@@ -1,96 +1,96 @@
 #include "ai_enginelist_valuator.hpp"
 
 namespace SQConvert {
-	/* Allow AIEngineListCargoType to be used as Squirrel parameter */
-	template <> AIEngineListCargoType *GetParam(ForceType<AIEngineListCargoType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListCargoType *)instance; }
-	template <> AIEngineListCargoType &GetParam(ForceType<AIEngineListCargoType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListCargoType *)instance; }
-	template <> const AIEngineListCargoType *GetParam(ForceType<const AIEngineListCargoType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListCargoType *)instance; }
-	template <> const AIEngineListCargoType &GetParam(ForceType<const AIEngineListCargoType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListCargoType *)instance; }
-	template <> int Return<AIEngineListCargoType *>(HSQUIRRELVM vm, AIEngineListCargoType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineListCargoType", res, NULL, DefSQDestructorCallback<AIEngineListCargoType>); return 1; }
+	/* Allow AIEngineList_vCargoType to be used as Squirrel parameter */
+	template <> AIEngineList_vCargoType *GetParam(ForceType<AIEngineList_vCargoType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vCargoType *)instance; }
+	template <> AIEngineList_vCargoType &GetParam(ForceType<AIEngineList_vCargoType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vCargoType *)instance; }
+	template <> const AIEngineList_vCargoType *GetParam(ForceType<const AIEngineList_vCargoType *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vCargoType *)instance; }
+	template <> const AIEngineList_vCargoType &GetParam(ForceType<const AIEngineList_vCargoType &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vCargoType *)instance; }
+	template <> int Return<AIEngineList_vCargoType *>(HSQUIRRELVM vm, AIEngineList_vCargoType *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineList_vCargoType", res, NULL, DefSQDestructorCallback<AIEngineList_vCargoType>); return 1; }
 }; // namespace SQConvert
 
-void SQAIEngineListCargoType_Register(Squirrel *engine) {
-	DefSQClass <AIEngineListCargoType> SQAIEngineListCargoType("AIEngineListCargoType");
-	SQAIEngineListCargoType.PreRegister(engine);
-	SQAIEngineListCargoType.AddConstructor<void (AIEngineListCargoType::*)(), 1>(engine, "x");
-
-	SQAIEngineListCargoType.DefSQStaticMethod(engine, &AIEngineListCargoType::GetClassName, "GetClassName", 1, "x");
-
-	SQAIEngineListCargoType.PostRegister(engine);
-}
+void SQAIEngineList_vCargoType_Register(Squirrel *engine) {
+	DefSQClass <AIEngineList_vCargoType> SQAIEngineList_vCargoType("AIEngineList_vCargoType");
+	SQAIEngineList_vCargoType.PreRegister(engine);
+	SQAIEngineList_vCargoType.AddConstructor<void (AIEngineList_vCargoType::*)(), 1>(engine, "x");
 
-namespace SQConvert {
-	/* Allow AIEngineListCapacity to be used as Squirrel parameter */
-	template <> AIEngineListCapacity *GetParam(ForceType<AIEngineListCapacity *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListCapacity *)instance; }
-	template <> AIEngineListCapacity &GetParam(ForceType<AIEngineListCapacity &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListCapacity *)instance; }
-	template <> const AIEngineListCapacity *GetParam(ForceType<const AIEngineListCapacity *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListCapacity *)instance; }
-	template <> const AIEngineListCapacity &GetParam(ForceType<const AIEngineListCapacity &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListCapacity *)instance; }
-	template <> int Return<AIEngineListCapacity *>(HSQUIRRELVM vm, AIEngineListCapacity *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineListCapacity", res, NULL, DefSQDestructorCallback<AIEngineListCapacity>); return 1; }
-}; // namespace SQConvert
+	SQAIEngineList_vCargoType.DefSQStaticMethod(engine, &AIEngineList_vCargoType::GetClassName, "GetClassName", 1, "x");
 
-void SQAIEngineListCapacity_Register(Squirrel *engine) {
-	DefSQClass <AIEngineListCapacity> SQAIEngineListCapacity("AIEngineListCapacity");
-	SQAIEngineListCapacity.PreRegister(engine);
-	SQAIEngineListCapacity.AddConstructor<void (AIEngineListCapacity::*)(), 1>(engine, "x");
-
-	SQAIEngineListCapacity.DefSQStaticMethod(engine, &AIEngineListCapacity::GetClassName, "GetClassName", 1, "x");
-
-	SQAIEngineListCapacity.PostRegister(engine);
+	SQAIEngineList_vCargoType.PostRegister(engine);
 }
 
 namespace SQConvert {
-	/* Allow AIEngineListReliability to be used as Squirrel parameter */
-	template <> AIEngineListReliability *GetParam(ForceType<AIEngineListReliability *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListReliability *)instance; }
-	template <> AIEngineListReliability &GetParam(ForceType<AIEngineListReliability &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListReliability *)instance; }
-	template <> const AIEngineListReliability *GetParam(ForceType<const AIEngineListReliability *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListReliability *)instance; }
-	template <> const AIEngineListReliability &GetParam(ForceType<const AIEngineListReliability &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListReliability *)instance; }
-	template <> int Return<AIEngineListReliability *>(HSQUIRRELVM vm, AIEngineListReliability *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineListReliability", res, NULL, DefSQDestructorCallback<AIEngineListReliability>); return 1; }
+	/* Allow AIEngineList_vCapacity to be used as Squirrel parameter */
+	template <> AIEngineList_vCapacity *GetParam(ForceType<AIEngineList_vCapacity *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vCapacity *)instance; }
+	template <> AIEngineList_vCapacity &GetParam(ForceType<AIEngineList_vCapacity &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vCapacity *)instance; }
+	template <> const AIEngineList_vCapacity *GetParam(ForceType<const AIEngineList_vCapacity *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vCapacity *)instance; }
+	template <> const AIEngineList_vCapacity &GetParam(ForceType<const AIEngineList_vCapacity &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vCapacity *)instance; }
+	template <> int Return<AIEngineList_vCapacity *>(HSQUIRRELVM vm, AIEngineList_vCapacity *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineList_vCapacity", res, NULL, DefSQDestructorCallback<AIEngineList_vCapacity>); return 1; }
 }; // namespace SQConvert
 
-void SQAIEngineListReliability_Register(Squirrel *engine) {
-	DefSQClass <AIEngineListReliability> SQAIEngineListReliability("AIEngineListReliability");
-	SQAIEngineListReliability.PreRegister(engine);
-	SQAIEngineListReliability.AddConstructor<void (AIEngineListReliability::*)(), 1>(engine, "x");
+void SQAIEngineList_vCapacity_Register(Squirrel *engine) {
+	DefSQClass <AIEngineList_vCapacity> SQAIEngineList_vCapacity("AIEngineList_vCapacity");
+	SQAIEngineList_vCapacity.PreRegister(engine);
+	SQAIEngineList_vCapacity.AddConstructor<void (AIEngineList_vCapacity::*)(), 1>(engine, "x");
 
-	SQAIEngineListReliability.DefSQStaticMethod(engine, &AIEngineListReliability::GetClassName, "GetClassName", 1, "x");
+	SQAIEngineList_vCapacity.DefSQStaticMethod(engine, &AIEngineList_vCapacity::GetClassName, "GetClassName", 1, "x");
 
-	SQAIEngineListReliability.PostRegister(engine);
+	SQAIEngineList_vCapacity.PostRegister(engine);
 }
 
 namespace SQConvert {
-	/* Allow AIEngineListMaxSpeed to be used as Squirrel parameter */
-	template <> AIEngineListMaxSpeed *GetParam(ForceType<AIEngineListMaxSpeed *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListMaxSpeed *)instance; }
-	template <> AIEngineListMaxSpeed &GetParam(ForceType<AIEngineListMaxSpeed &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListMaxSpeed *)instance; }
-	template <> const AIEngineListMaxSpeed *GetParam(ForceType<const AIEngineListMaxSpeed *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListMaxSpeed *)instance; }
-	template <> const AIEngineListMaxSpeed &GetParam(ForceType<const AIEngineListMaxSpeed &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListMaxSpeed *)instance; }
-	template <> int Return<AIEngineListMaxSpeed *>(HSQUIRRELVM vm, AIEngineListMaxSpeed *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineListMaxSpeed", res, NULL, DefSQDestructorCallback<AIEngineListMaxSpeed>); return 1; }
+	/* Allow AIEngineList_vReliability to be used as Squirrel parameter */
+	template <> AIEngineList_vReliability *GetParam(ForceType<AIEngineList_vReliability *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vReliability *)instance; }
+	template <> AIEngineList_vReliability &GetParam(ForceType<AIEngineList_vReliability &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vReliability *)instance; }
+	template <> const AIEngineList_vReliability *GetParam(ForceType<const AIEngineList_vReliability *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vReliability *)instance; }
+	template <> const AIEngineList_vReliability &GetParam(ForceType<const AIEngineList_vReliability &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vReliability *)instance; }
+	template <> int Return<AIEngineList_vReliability *>(HSQUIRRELVM vm, AIEngineList_vReliability *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineList_vReliability", res, NULL, DefSQDestructorCallback<AIEngineList_vReliability>); return 1; }
 }; // namespace SQConvert
 
-void SQAIEngineListMaxSpeed_Register(Squirrel *engine) {
-	DefSQClass <AIEngineListMaxSpeed> SQAIEngineListMaxSpeed("AIEngineListMaxSpeed");
-	SQAIEngineListMaxSpeed.PreRegister(engine);
-	SQAIEngineListMaxSpeed.AddConstructor<void (AIEngineListMaxSpeed::*)(), 1>(engine, "x");
+void SQAIEngineList_vReliability_Register(Squirrel *engine) {
+	DefSQClass <AIEngineList_vReliability> SQAIEngineList_vReliability("AIEngineList_vReliability");
+	SQAIEngineList_vReliability.PreRegister(engine);
+	SQAIEngineList_vReliability.AddConstructor<void (AIEngineList_vReliability::*)(), 1>(engine, "x");
 
-	SQAIEngineListMaxSpeed.DefSQStaticMethod(engine, &AIEngineListMaxSpeed::GetClassName, "GetClassName", 1, "x");
+	SQAIEngineList_vReliability.DefSQStaticMethod(engine, &AIEngineList_vReliability::GetClassName, "GetClassName", 1, "x");
 
-	SQAIEngineListMaxSpeed.PostRegister(engine);
+	SQAIEngineList_vReliability.PostRegister(engine);
 }
 
 namespace SQConvert {
-	/* Allow AIEngineListPrice to be used as Squirrel parameter */
-	template <> AIEngineListPrice *GetParam(ForceType<AIEngineListPrice *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListPrice *)instance; }
-	template <> AIEngineListPrice &GetParam(ForceType<AIEngineListPrice &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListPrice *)instance; }
-	template <> const AIEngineListPrice *GetParam(ForceType<const AIEngineListPrice *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineListPrice *)instance; }
-	template <> const AIEngineListPrice &GetParam(ForceType<const AIEngineListPrice &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineListPrice *)instance; }
-	template <> int Return<AIEngineListPrice *>(HSQUIRRELVM vm, AIEngineListPrice *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineListPrice", res, NULL, DefSQDestructorCallback<AIEngineListPrice>); return 1; }
+	/* Allow AIEngineList_vMaxSpeed to be used as Squirrel parameter */
+	template <> AIEngineList_vMaxSpeed *GetParam(ForceType<AIEngineList_vMaxSpeed *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vMaxSpeed *)instance; }
+	template <> AIEngineList_vMaxSpeed &GetParam(ForceType<AIEngineList_vMaxSpeed &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vMaxSpeed *)instance; }
+	template <> const AIEngineList_vMaxSpeed *GetParam(ForceType<const AIEngineList_vMaxSpeed *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vMaxSpeed *)instance; }
+	template <> const AIEngineList_vMaxSpeed &GetParam(ForceType<const AIEngineList_vMaxSpeed &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vMaxSpeed *)instance; }
+	template <> int Return<AIEngineList_vMaxSpeed *>(HSQUIRRELVM vm, AIEngineList_vMaxSpeed *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineList_vMaxSpeed", res, NULL, DefSQDestructorCallback<AIEngineList_vMaxSpeed>); return 1; }
 }; // namespace SQConvert
 
-void SQAIEngineListPrice_Register(Squirrel *engine) {
-	DefSQClass <AIEngineListPrice> SQAIEngineListPrice("AIEngineListPrice");
-	SQAIEngineListPrice.PreRegister(engine);
-	SQAIEngineListPrice.AddConstructor<void (AIEngineListPrice::*)(), 1>(engine, "x");
+void SQAIEngineList_vMaxSpeed_Register(Squirrel *engine) {
+	DefSQClass <AIEngineList_vMaxSpeed> SQAIEngineList_vMaxSpeed("AIEngineList_vMaxSpeed");
+	SQAIEngineList_vMaxSpeed.PreRegister(engine);
+	SQAIEngineList_vMaxSpeed.AddConstructor<void (AIEngineList_vMaxSpeed::*)(), 1>(engine, "x");
 
-	SQAIEngineListPrice.DefSQStaticMethod(engine, &AIEngineListPrice::GetClassName, "GetClassName", 1, "x");
+	SQAIEngineList_vMaxSpeed.DefSQStaticMethod(engine, &AIEngineList_vMaxSpeed::GetClassName, "GetClassName", 1, "x");
 
-	SQAIEngineListPrice.PostRegister(engine);
+	SQAIEngineList_vMaxSpeed.PostRegister(engine);
 }
+
+namespace SQConvert {
+	/* Allow AIEngineList_vPrice to be used as Squirrel parameter */
+	template <> AIEngineList_vPrice *GetParam(ForceType<AIEngineList_vPrice *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vPrice *)instance; }
+	template <> AIEngineList_vPrice &GetParam(ForceType<AIEngineList_vPrice &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vPrice *)instance; }
+	template <> const AIEngineList_vPrice *GetParam(ForceType<const AIEngineList_vPrice *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AIEngineList_vPrice *)instance; }
+	template <> const AIEngineList_vPrice &GetParam(ForceType<const AIEngineList_vPrice &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AIEngineList_vPrice *)instance; }
+	template <> int Return<AIEngineList_vPrice *>(HSQUIRRELVM vm, AIEngineList_vPrice *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AIEngineList_vPrice", res, NULL, DefSQDestructorCallback<AIEngineList_vPrice>); return 1; }
+}; // namespace SQConvert
+
+void SQAIEngineList_vPrice_Register(Squirrel *engine) {
+	DefSQClass <AIEngineList_vPrice> SQAIEngineList_vPrice("AIEngineList_vPrice");
+	SQAIEngineList_vPrice.PreRegister(engine);
+	SQAIEngineList_vPrice.AddConstructor<void (AIEngineList_vPrice::*)(), 1>(engine, "x");
+
+	SQAIEngineList_vPrice.DefSQStaticMethod(engine, &AIEngineList_vPrice::GetClassName, "GetClassName", 1, "x");
+
+	SQAIEngineList_vPrice.PostRegister(engine);
+}