#include "ai_tilelist_valuator.hpp"

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

void SQAITileListBuildableRegister(Squirrel *engine) {
	DefSQClass <AITileListBuildable> SQAITileListBuildable("AITileListBuildable");
	SQAITileListBuildable.PreRegister(engine);
	SQAITileListBuildable.AddConstructor<void (AITileListBuildable::*)(), 1>(engine, "x");

	SQAITileListBuildable.DefSQStaticMethod(engine, &AITileListBuildable::GetClassName, "GetClassName", 1, "x");

	SQAITileListBuildable.PostRegister(engine);
}

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

void SQAITileListWaterRegister(Squirrel *engine) {
	DefSQClass <AITileListWater> SQAITileListWater("AITileListWater");
	SQAITileListWater.PreRegister(engine);
	SQAITileListWater.AddConstructor<void (AITileListWater::*)(), 1>(engine, "x");

	SQAITileListWater.DefSQStaticMethod(engine, &AITileListWater::GetClassName, "GetClassName", 1, "x");

	SQAITileListWater.PostRegister(engine);
}

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

void SQAITileListBuildableRectangleRegister(Squirrel *engine) {
	DefSQClass <AITileListBuildableRectangle> SQAITileListBuildableRectangle("AITileListBuildableRectangle");
	SQAITileListBuildableRectangle.PreRegister(engine);
	SQAITileListBuildableRectangle.AddConstructor<void (AITileListBuildableRectangle::*)(uint width, uint height), 3>(engine, "xii");

	SQAITileListBuildableRectangle.DefSQStaticMethod(engine, &AITileListBuildableRectangle::GetClassName, "GetClassName", 1, "x");

	SQAITileListBuildableRectangle.PostRegister(engine);
}

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

void SQAITileListSlopeRegister(Squirrel *engine) {
	DefSQClass <AITileListSlope> SQAITileListSlope("AITileListSlope");
	SQAITileListSlope.PreRegister(engine);
	SQAITileListSlope.AddConstructor<void (AITileListSlope::*)(), 1>(engine, "x");

	SQAITileListSlope.DefSQStaticMethod(engine, &AITileListSlope::GetClassName, "GetClassName", 1, "x");

	SQAITileListSlope.PostRegister(engine);
}

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

void SQAITileListHeightRegister(Squirrel *engine) {
	DefSQClass <AITileListHeight> SQAITileListHeight("AITileListHeight");
	SQAITileListHeight.PreRegister(engine);
	SQAITileListHeight.AddConstructor<void (AITileListHeight::*)(), 1>(engine, "x");

	SQAITileListHeight.DefSQStaticMethod(engine, &AITileListHeight::GetClassName, "GetClassName", 1, "x");

	SQAITileListHeight.PostRegister(engine);
}

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

void SQAITileListNeighbourRoadCountRegister(Squirrel *engine) {
	DefSQClass <AITileListNeighbourRoadCount> SQAITileListNeighbourRoadCount("AITileListNeighbourRoadCount");
	SQAITileListNeighbourRoadCount.PreRegister(engine);
	SQAITileListNeighbourRoadCount.AddConstructor<void (AITileListNeighbourRoadCount::*)(), 1>(engine, "x");

	SQAITileListNeighbourRoadCount.DefSQStaticMethod(engine, &AITileListNeighbourRoadCount::GetClassName, "GetClassName", 1, "x");

	SQAITileListNeighbourRoadCount.PostRegister(engine);
}

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

void SQAITileListRoadTileRegister(Squirrel *engine) {
	DefSQClass <AITileListRoadTile> SQAITileListRoadTile("AITileListRoadTile");
	SQAITileListRoadTile.PreRegister(engine);
	SQAITileListRoadTile.AddConstructor<void (AITileListRoadTile::*)(), 1>(engine, "x");

	SQAITileListRoadTile.DefSQStaticMethod(engine, &AITileListRoadTile::GetClassName, "GetClassName", 1, "x");

	SQAITileListRoadTile.PostRegister(engine);
}

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

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

	SQAITileListCargoAcceptance.DefSQStaticMethod(engine, &AITileListCargoAcceptance::GetClassName, "GetClassName", 1, "x");

	SQAITileListCargoAcceptance.PostRegister(engine);
}

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

void SQAITileListDistanceManhattanToTileRegister(Squirrel *engine) {
	DefSQClass <AITileListDistanceManhattanToTile> SQAITileListDistanceManhattanToTile("AITileListDistanceManhattanToTile");
	SQAITileListDistanceManhattanToTile.PreRegister(engine);
	SQAITileListDistanceManhattanToTile.AddConstructor<void (AITileListDistanceManhattanToTile::*)(TileIndex tile), 2>(engine, "xi");

	SQAITileListDistanceManhattanToTile.DefSQStaticMethod(engine, &AITileListDistanceManhattanToTile::GetClassName, "GetClassName", 1, "x");

	SQAITileListDistanceManhattanToTile.PostRegister(engine);
}

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

void SQAITileListDistanceSquareToTileRegister(Squirrel *engine) {
	DefSQClass <AITileListDistanceSquareToTile> SQAITileListDistanceSquareToTile("AITileListDistanceSquareToTile");
	SQAITileListDistanceSquareToTile.PreRegister(engine);
	SQAITileListDistanceSquareToTile.AddConstructor<void (AITileListDistanceSquareToTile::*)(TileIndex tile), 2>(engine, "xi");

	SQAITileListDistanceSquareToTile.DefSQStaticMethod(engine, &AITileListDistanceSquareToTile::GetClassName, "GetClassName", 1, "x");

	SQAITileListDistanceSquareToTile.PostRegister(engine);
}