#include "ai_tilelist_valuator.hpp"

namespace SQConvert {
	/* Allow AITileList_vBuildable to be used as Squirrel parameter */
	template <> AITileList_vBuildable *GetParam(ForceType<AITileList_vBuildable *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vBuildable *)instance; }
	template <> AITileList_vBuildable &GetParam(ForceType<AITileList_vBuildable &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vBuildable *)instance; }
	template <> const AITileList_vBuildable *GetParam(ForceType<const AITileList_vBuildable *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vBuildable *)instance; }
	template <> const AITileList_vBuildable &GetParam(ForceType<const AITileList_vBuildable &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vBuildable *)instance; }
	template <> int Return<AITileList_vBuildable *>(HSQUIRRELVM vm, AITileList_vBuildable *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vBuildable", res, NULL, DefSQDestructorCallback<AITileList_vBuildable>); return 1; }
}; // namespace SQConvert

void SQAITileList_vBuildable_Register(Squirrel *engine) {
	DefSQClass <AITileList_vBuildable> SQAITileList_vBuildable("AITileList_vBuildable");
	SQAITileList_vBuildable.PreRegister(engine);
	SQAITileList_vBuildable.AddConstructor<void (AITileList_vBuildable::*)(), 1>(engine, "x");

	SQAITileList_vBuildable.DefSQStaticMethod(engine, &AITileList_vBuildable::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vBuildable.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vWater to be used as Squirrel parameter */
	template <> AITileList_vWater *GetParam(ForceType<AITileList_vWater *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vWater *)instance; }
	template <> AITileList_vWater &GetParam(ForceType<AITileList_vWater &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vWater *)instance; }
	template <> const AITileList_vWater *GetParam(ForceType<const AITileList_vWater *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vWater *)instance; }
	template <> const AITileList_vWater &GetParam(ForceType<const AITileList_vWater &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vWater *)instance; }
	template <> int Return<AITileList_vWater *>(HSQUIRRELVM vm, AITileList_vWater *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vWater", res, NULL, DefSQDestructorCallback<AITileList_vWater>); return 1; }
}; // namespace SQConvert

void SQAITileList_vWater_Register(Squirrel *engine) {
	DefSQClass <AITileList_vWater> SQAITileList_vWater("AITileList_vWater");
	SQAITileList_vWater.PreRegister(engine);
	SQAITileList_vWater.AddConstructor<void (AITileList_vWater::*)(), 1>(engine, "x");

	SQAITileList_vWater.DefSQStaticMethod(engine, &AITileList_vWater::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vWater.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vBuildableRectangle to be used as Squirrel parameter */
	template <> AITileList_vBuildableRectangle *GetParam(ForceType<AITileList_vBuildableRectangle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vBuildableRectangle *)instance; }
	template <> AITileList_vBuildableRectangle &GetParam(ForceType<AITileList_vBuildableRectangle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vBuildableRectangle *)instance; }
	template <> const AITileList_vBuildableRectangle *GetParam(ForceType<const AITileList_vBuildableRectangle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vBuildableRectangle *)instance; }
	template <> const AITileList_vBuildableRectangle &GetParam(ForceType<const AITileList_vBuildableRectangle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vBuildableRectangle *)instance; }
	template <> int Return<AITileList_vBuildableRectangle *>(HSQUIRRELVM vm, AITileList_vBuildableRectangle *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vBuildableRectangle", res, NULL, DefSQDestructorCallback<AITileList_vBuildableRectangle>); return 1; }
}; // namespace SQConvert

void SQAITileList_vBuildableRectangle_Register(Squirrel *engine) {
	DefSQClass <AITileList_vBuildableRectangle> SQAITileList_vBuildableRectangle("AITileList_vBuildableRectangle");
	SQAITileList_vBuildableRectangle.PreRegister(engine);
	SQAITileList_vBuildableRectangle.AddConstructor<void (AITileList_vBuildableRectangle::*)(uint width, uint height), 3>(engine, "xii");

	SQAITileList_vBuildableRectangle.DefSQStaticMethod(engine, &AITileList_vBuildableRectangle::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vBuildableRectangle.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vSlope to be used as Squirrel parameter */
	template <> AITileList_vSlope *GetParam(ForceType<AITileList_vSlope *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vSlope *)instance; }
	template <> AITileList_vSlope &GetParam(ForceType<AITileList_vSlope &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vSlope *)instance; }
	template <> const AITileList_vSlope *GetParam(ForceType<const AITileList_vSlope *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vSlope *)instance; }
	template <> const AITileList_vSlope &GetParam(ForceType<const AITileList_vSlope &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vSlope *)instance; }
	template <> int Return<AITileList_vSlope *>(HSQUIRRELVM vm, AITileList_vSlope *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vSlope", res, NULL, DefSQDestructorCallback<AITileList_vSlope>); return 1; }
}; // namespace SQConvert

void SQAITileList_vSlope_Register(Squirrel *engine) {
	DefSQClass <AITileList_vSlope> SQAITileList_vSlope("AITileList_vSlope");
	SQAITileList_vSlope.PreRegister(engine);
	SQAITileList_vSlope.AddConstructor<void (AITileList_vSlope::*)(), 1>(engine, "x");

	SQAITileList_vSlope.DefSQStaticMethod(engine, &AITileList_vSlope::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vSlope.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vHeight to be used as Squirrel parameter */
	template <> AITileList_vHeight *GetParam(ForceType<AITileList_vHeight *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vHeight *)instance; }
	template <> AITileList_vHeight &GetParam(ForceType<AITileList_vHeight &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vHeight *)instance; }
	template <> const AITileList_vHeight *GetParam(ForceType<const AITileList_vHeight *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vHeight *)instance; }
	template <> const AITileList_vHeight &GetParam(ForceType<const AITileList_vHeight &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vHeight *)instance; }
	template <> int Return<AITileList_vHeight *>(HSQUIRRELVM vm, AITileList_vHeight *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vHeight", res, NULL, DefSQDestructorCallback<AITileList_vHeight>); return 1; }
}; // namespace SQConvert

void SQAITileList_vHeight_Register(Squirrel *engine) {
	DefSQClass <AITileList_vHeight> SQAITileList_vHeight("AITileList_vHeight");
	SQAITileList_vHeight.PreRegister(engine);
	SQAITileList_vHeight.AddConstructor<void (AITileList_vHeight::*)(), 1>(engine, "x");

	SQAITileList_vHeight.DefSQStaticMethod(engine, &AITileList_vHeight::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vHeight.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vNeighbourRoadCount to be used as Squirrel parameter */
	template <> AITileList_vNeighbourRoadCount *GetParam(ForceType<AITileList_vNeighbourRoadCount *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vNeighbourRoadCount *)instance; }
	template <> AITileList_vNeighbourRoadCount &GetParam(ForceType<AITileList_vNeighbourRoadCount &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vNeighbourRoadCount *)instance; }
	template <> const AITileList_vNeighbourRoadCount *GetParam(ForceType<const AITileList_vNeighbourRoadCount *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vNeighbourRoadCount *)instance; }
	template <> const AITileList_vNeighbourRoadCount &GetParam(ForceType<const AITileList_vNeighbourRoadCount &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vNeighbourRoadCount *)instance; }
	template <> int Return<AITileList_vNeighbourRoadCount *>(HSQUIRRELVM vm, AITileList_vNeighbourRoadCount *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vNeighbourRoadCount", res, NULL, DefSQDestructorCallback<AITileList_vNeighbourRoadCount>); return 1; }
}; // namespace SQConvert

void SQAITileList_vNeighbourRoadCount_Register(Squirrel *engine) {
	DefSQClass <AITileList_vNeighbourRoadCount> SQAITileList_vNeighbourRoadCount("AITileList_vNeighbourRoadCount");
	SQAITileList_vNeighbourRoadCount.PreRegister(engine);
	SQAITileList_vNeighbourRoadCount.AddConstructor<void (AITileList_vNeighbourRoadCount::*)(), 1>(engine, "x");

	SQAITileList_vNeighbourRoadCount.DefSQStaticMethod(engine, &AITileList_vNeighbourRoadCount::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vNeighbourRoadCount.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vRoadTile to be used as Squirrel parameter */
	template <> AITileList_vRoadTile *GetParam(ForceType<AITileList_vRoadTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vRoadTile *)instance; }
	template <> AITileList_vRoadTile &GetParam(ForceType<AITileList_vRoadTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vRoadTile *)instance; }
	template <> const AITileList_vRoadTile *GetParam(ForceType<const AITileList_vRoadTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vRoadTile *)instance; }
	template <> const AITileList_vRoadTile &GetParam(ForceType<const AITileList_vRoadTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vRoadTile *)instance; }
	template <> int Return<AITileList_vRoadTile *>(HSQUIRRELVM vm, AITileList_vRoadTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vRoadTile", res, NULL, DefSQDestructorCallback<AITileList_vRoadTile>); return 1; }
}; // namespace SQConvert

void SQAITileList_vRoadTile_Register(Squirrel *engine) {
	DefSQClass <AITileList_vRoadTile> SQAITileList_vRoadTile("AITileList_vRoadTile");
	SQAITileList_vRoadTile.PreRegister(engine);
	SQAITileList_vRoadTile.AddConstructor<void (AITileList_vRoadTile::*)(), 1>(engine, "x");

	SQAITileList_vRoadTile.DefSQStaticMethod(engine, &AITileList_vRoadTile::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vRoadTile.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vCargoAcceptance to be used as Squirrel parameter */
	template <> AITileList_vCargoAcceptance *GetParam(ForceType<AITileList_vCargoAcceptance *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vCargoAcceptance *)instance; }
	template <> AITileList_vCargoAcceptance &GetParam(ForceType<AITileList_vCargoAcceptance &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vCargoAcceptance *)instance; }
	template <> const AITileList_vCargoAcceptance *GetParam(ForceType<const AITileList_vCargoAcceptance *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vCargoAcceptance *)instance; }
	template <> const AITileList_vCargoAcceptance &GetParam(ForceType<const AITileList_vCargoAcceptance &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vCargoAcceptance *)instance; }
	template <> int Return<AITileList_vCargoAcceptance *>(HSQUIRRELVM vm, AITileList_vCargoAcceptance *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vCargoAcceptance", res, NULL, DefSQDestructorCallback<AITileList_vCargoAcceptance>); return 1; }
}; // namespace SQConvert

void SQAITileList_vCargoAcceptance_Register(Squirrel *engine) {
	DefSQClass <AITileList_vCargoAcceptance> SQAITileList_vCargoAcceptance("AITileList_vCargoAcceptance");
	SQAITileList_vCargoAcceptance.PreRegister(engine);
	SQAITileList_vCargoAcceptance.AddConstructor<void (AITileList_vCargoAcceptance::*)(CargoID cargo_type, uint width, uint height, uint radius), 5>(engine, "xiiii");

	SQAITileList_vCargoAcceptance.DefSQStaticMethod(engine, &AITileList_vCargoAcceptance::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vCargoAcceptance.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vDistanceManhattanToTile to be used as Squirrel parameter */
	template <> AITileList_vDistanceManhattanToTile *GetParam(ForceType<AITileList_vDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vDistanceManhattanToTile *)instance; }
	template <> AITileList_vDistanceManhattanToTile &GetParam(ForceType<AITileList_vDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vDistanceManhattanToTile *)instance; }
	template <> const AITileList_vDistanceManhattanToTile *GetParam(ForceType<const AITileList_vDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vDistanceManhattanToTile *)instance; }
	template <> const AITileList_vDistanceManhattanToTile &GetParam(ForceType<const AITileList_vDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vDistanceManhattanToTile *)instance; }
	template <> int Return<AITileList_vDistanceManhattanToTile *>(HSQUIRRELVM vm, AITileList_vDistanceManhattanToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vDistanceManhattanToTile", res, NULL, DefSQDestructorCallback<AITileList_vDistanceManhattanToTile>); return 1; }
}; // namespace SQConvert

void SQAITileList_vDistanceManhattanToTile_Register(Squirrel *engine) {
	DefSQClass <AITileList_vDistanceManhattanToTile> SQAITileList_vDistanceManhattanToTile("AITileList_vDistanceManhattanToTile");
	SQAITileList_vDistanceManhattanToTile.PreRegister(engine);
	SQAITileList_vDistanceManhattanToTile.AddConstructor<void (AITileList_vDistanceManhattanToTile::*)(TileIndex tile), 2>(engine, "xi");

	SQAITileList_vDistanceManhattanToTile.DefSQStaticMethod(engine, &AITileList_vDistanceManhattanToTile::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vDistanceManhattanToTile.PostRegister(engine);
}

namespace SQConvert {
	/* Allow AITileList_vDistanceSquareToTile to be used as Squirrel parameter */
	template <> AITileList_vDistanceSquareToTile *GetParam(ForceType<AITileList_vDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vDistanceSquareToTile *)instance; }
	template <> AITileList_vDistanceSquareToTile &GetParam(ForceType<AITileList_vDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vDistanceSquareToTile *)instance; }
	template <> const AITileList_vDistanceSquareToTile *GetParam(ForceType<const AITileList_vDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vDistanceSquareToTile *)instance; }
	template <> const AITileList_vDistanceSquareToTile &GetParam(ForceType<const AITileList_vDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vDistanceSquareToTile *)instance; }
	template <> int Return<AITileList_vDistanceSquareToTile *>(HSQUIRRELVM vm, AITileList_vDistanceSquareToTile *res) { if (res == NULL) { sq_pushnull(vm); return 1; } res->AddRef(); Squirrel::CreateClassInstanceVM(vm, "AITileList_vDistanceSquareToTile", res, NULL, DefSQDestructorCallback<AITileList_vDistanceSquareToTile>); return 1; }
}; // namespace SQConvert

void SQAITileList_vDistanceSquareToTile_Register(Squirrel *engine) {
	DefSQClass <AITileList_vDistanceSquareToTile> SQAITileList_vDistanceSquareToTile("AITileList_vDistanceSquareToTile");
	SQAITileList_vDistanceSquareToTile.PreRegister(engine);
	SQAITileList_vDistanceSquareToTile.AddConstructor<void (AITileList_vDistanceSquareToTile::*)(TileIndex tile), 2>(engine, "xi");

	SQAITileList_vDistanceSquareToTile.DefSQStaticMethod(engine, &AITileList_vDistanceSquareToTile::GetClassName, "GetClassName", 1, "x");

	SQAITileList_vDistanceSquareToTile.PostRegister(engine);
}