1

#include "ai_tilelist_valuator.hpp"

     2

     3

namespace SQConvert {

     4

	/* Allow AITileList_vBuildable to be used as Squirrel parameter */

     5

	template <> AITileList_vBuildable *GetParam(ForceType<AITileList_vBuildable *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vBuildable *)instance; }

     6

	template <> AITileList_vBuildable &GetParam(ForceType<AITileList_vBuildable &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vBuildable *)instance; }

     7

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

     8

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

     9

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

    10

}; // namespace SQConvert

    11

    12

void SQAITileList_vBuildable_Register(Squirrel *engine) {

    13

	DefSQClass <AITileList_vBuildable> SQAITileList_vBuildable("AITileList_vBuildable");

    14

	SQAITileList_vBuildable.PreRegister(engine);

    15

	SQAITileList_vBuildable.AddConstructor<void (AITileList_vBuildable::*)(), 1>(engine, "x");

    16

    17

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

    18

    19

	SQAITileList_vBuildable.PostRegister(engine);

    20

}

    21

    22

namespace SQConvert {

    23

	/* Allow AITileList_vWater to be used as Squirrel parameter */

    24

	template <> AITileList_vWater *GetParam(ForceType<AITileList_vWater *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vWater *)instance; }

    25

	template <> AITileList_vWater &GetParam(ForceType<AITileList_vWater &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vWater *)instance; }

    26

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

    27

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

    28

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

    29

}; // namespace SQConvert

    30

    31

void SQAITileList_vWater_Register(Squirrel *engine) {

    32

	DefSQClass <AITileList_vWater> SQAITileList_vWater("AITileList_vWater");

    33

	SQAITileList_vWater.PreRegister(engine);

    34

	SQAITileList_vWater.AddConstructor<void (AITileList_vWater::*)(), 1>(engine, "x");

    35

    36

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

    37

    38

	SQAITileList_vWater.PostRegister(engine);

    39

}

    40

    41

namespace SQConvert {

    42

	/* Allow AITileList_vBuildableRectangle to be used as Squirrel parameter */

    43

	template <> AITileList_vBuildableRectangle *GetParam(ForceType<AITileList_vBuildableRectangle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vBuildableRectangle *)instance; }

    44

	template <> AITileList_vBuildableRectangle &GetParam(ForceType<AITileList_vBuildableRectangle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vBuildableRectangle *)instance; }

    45

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

    46

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

    47

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

    48

}; // namespace SQConvert

    49

    50

void SQAITileList_vBuildableRectangle_Register(Squirrel *engine) {

    51

	DefSQClass <AITileList_vBuildableRectangle> SQAITileList_vBuildableRectangle("AITileList_vBuildableRectangle");

    52

	SQAITileList_vBuildableRectangle.PreRegister(engine);

    53

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

    54

    55

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

    56

    57

	SQAITileList_vBuildableRectangle.PostRegister(engine);

    58

}

    59

    60

namespace SQConvert {

    61

	/* Allow AITileList_vSlope to be used as Squirrel parameter */

    62

	template <> AITileList_vSlope *GetParam(ForceType<AITileList_vSlope *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vSlope *)instance; }

    63

	template <> AITileList_vSlope &GetParam(ForceType<AITileList_vSlope &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vSlope *)instance; }

    64

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

    65

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

    66

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

    67

}; // namespace SQConvert

    68

    69

void SQAITileList_vSlope_Register(Squirrel *engine) {

    70

	DefSQClass <AITileList_vSlope> SQAITileList_vSlope("AITileList_vSlope");

    71

	SQAITileList_vSlope.PreRegister(engine);

    72

	SQAITileList_vSlope.AddConstructor<void (AITileList_vSlope::*)(), 1>(engine, "x");

    73

    74

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

    75

    76

	SQAITileList_vSlope.PostRegister(engine);

    77

}

    78

    79

namespace SQConvert {

    80

	/* Allow AITileList_vHeight to be used as Squirrel parameter */

    81

	template <> AITileList_vHeight *GetParam(ForceType<AITileList_vHeight *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vHeight *)instance; }

    82

	template <> AITileList_vHeight &GetParam(ForceType<AITileList_vHeight &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vHeight *)instance; }

    83

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

    84

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

    85

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

    86

}; // namespace SQConvert

    87

    88

void SQAITileList_vHeight_Register(Squirrel *engine) {

    89

	DefSQClass <AITileList_vHeight> SQAITileList_vHeight("AITileList_vHeight");

    90

	SQAITileList_vHeight.PreRegister(engine);

    91

	SQAITileList_vHeight.AddConstructor<void (AITileList_vHeight::*)(), 1>(engine, "x");

    92

    93

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

    94

    95

	SQAITileList_vHeight.PostRegister(engine);

    96

}

    97

    98

namespace SQConvert {

    99

	/* Allow AITileList_vNeighbourRoadCount to be used as Squirrel parameter */

   100

	template <> AITileList_vNeighbourRoadCount *GetParam(ForceType<AITileList_vNeighbourRoadCount *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vNeighbourRoadCount *)instance; }

   101

	template <> AITileList_vNeighbourRoadCount &GetParam(ForceType<AITileList_vNeighbourRoadCount &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vNeighbourRoadCount *)instance; }

   102

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

   103

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

   104

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

   105

}; // namespace SQConvert

   106

   107

void SQAITileList_vNeighbourRoadCount_Register(Squirrel *engine) {

   108

	DefSQClass <AITileList_vNeighbourRoadCount> SQAITileList_vNeighbourRoadCount("AITileList_vNeighbourRoadCount");

   109

	SQAITileList_vNeighbourRoadCount.PreRegister(engine);

   110

	SQAITileList_vNeighbourRoadCount.AddConstructor<void (AITileList_vNeighbourRoadCount::*)(), 1>(engine, "x");

   111

   112

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

   113

   114

	SQAITileList_vNeighbourRoadCount.PostRegister(engine);

   115

}

   116

   117

namespace SQConvert {

   118

	/* Allow AITileList_vRoadTile to be used as Squirrel parameter */

   119

	template <> AITileList_vRoadTile *GetParam(ForceType<AITileList_vRoadTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vRoadTile *)instance; }

   120

	template <> AITileList_vRoadTile &GetParam(ForceType<AITileList_vRoadTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vRoadTile *)instance; }

   121

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

   122

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

   123

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

   124

}; // namespace SQConvert

   125

   126

void SQAITileList_vRoadTile_Register(Squirrel *engine) {

   127

	DefSQClass <AITileList_vRoadTile> SQAITileList_vRoadTile("AITileList_vRoadTile");

   128

	SQAITileList_vRoadTile.PreRegister(engine);

   129

	SQAITileList_vRoadTile.AddConstructor<void (AITileList_vRoadTile::*)(), 1>(engine, "x");

   130

   131

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

   132

   133

	SQAITileList_vRoadTile.PostRegister(engine);

   134

}

   135

   136

namespace SQConvert {

   137

	/* Allow AITileList_vCargoAcceptance to be used as Squirrel parameter */

   138

	template <> AITileList_vCargoAcceptance *GetParam(ForceType<AITileList_vCargoAcceptance *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vCargoAcceptance *)instance; }

   139

	template <> AITileList_vCargoAcceptance &GetParam(ForceType<AITileList_vCargoAcceptance &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vCargoAcceptance *)instance; }

   140

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

   141

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

   142

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

   143

}; // namespace SQConvert

   144

   145

void SQAITileList_vCargoAcceptance_Register(Squirrel *engine) {

   146

	DefSQClass <AITileList_vCargoAcceptance> SQAITileList_vCargoAcceptance("AITileList_vCargoAcceptance");

   147

	SQAITileList_vCargoAcceptance.PreRegister(engine);

   148

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

   149

   150

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

   151

   152

	SQAITileList_vCargoAcceptance.PostRegister(engine);

   153

}

   154

   155

namespace SQConvert {

   156

	/* Allow AITileList_vDistanceManhattanToTile to be used as Squirrel parameter */

   157

	template <> AITileList_vDistanceManhattanToTile *GetParam(ForceType<AITileList_vDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vDistanceManhattanToTile *)instance; }

   158

	template <> AITileList_vDistanceManhattanToTile &GetParam(ForceType<AITileList_vDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vDistanceManhattanToTile *)instance; }

   159

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

   160

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

   161

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

   162

}; // namespace SQConvert

   163

   164

void SQAITileList_vDistanceManhattanToTile_Register(Squirrel *engine) {

   165

	DefSQClass <AITileList_vDistanceManhattanToTile> SQAITileList_vDistanceManhattanToTile("AITileList_vDistanceManhattanToTile");

   166

	SQAITileList_vDistanceManhattanToTile.PreRegister(engine);

   167

	SQAITileList_vDistanceManhattanToTile.AddConstructor<void (AITileList_vDistanceManhattanToTile::*)(TileIndex tile), 2>(engine, "xi");

   168

   169

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

   170

   171

	SQAITileList_vDistanceManhattanToTile.PostRegister(engine);

   172

}

   173

   174

namespace SQConvert {

   175

	/* Allow AITileList_vDistanceSquareToTile to be used as Squirrel parameter */

   176

	template <> AITileList_vDistanceSquareToTile *GetParam(ForceType<AITileList_vDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return  (AITileList_vDistanceSquareToTile *)instance; }

   177

	template <> AITileList_vDistanceSquareToTile &GetParam(ForceType<AITileList_vDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileList_vDistanceSquareToTile *)instance; }

   178

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

   179

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

   180

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

   181

}; // namespace SQConvert

   182

   183

void SQAITileList_vDistanceSquareToTile_Register(Squirrel *engine) {

   184

	DefSQClass <AITileList_vDistanceSquareToTile> SQAITileList_vDistanceSquareToTile("AITileList_vDistanceSquareToTile");

   185

	SQAITileList_vDistanceSquareToTile.PreRegister(engine);

   186

	SQAITileList_vDistanceSquareToTile.AddConstructor<void (AITileList_vDistanceSquareToTile::*)(TileIndex tile), 2>(engine, "xi");

   187

   188

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

   189

   190

	SQAITileList_vDistanceSquareToTile.PostRegister(engine);

   191

}