#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; }
}; // 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 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; }
}; // 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; }
}; // 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 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; }
}; // 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; }
}; // 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; }
}; // namespace SQConvert

void SQAITileListCargoAcceptanceRegister(Squirrel *engine) {
	DefSQClass <AITileListCargoAcceptance> SQAITileListCargoAcceptance("AITileListCargoAcceptance");
	SQAITileListCargoAcceptance.PreRegister(engine);
	SQAITileListCargoAcceptance.AddConstructor<void (AITileListCargoAcceptance::*)(CargoID cargo_type), 2>(engine, "xi");

	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; }
}; // 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; }
}; // 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);
}