1 #include "ai_tilelist_valuator.hpp" |
1 #include "ai_tilelist_valuator.hpp" |
2 |
2 |
3 namespace SQConvert { |
3 namespace SQConvert { |
4 /* Allow AITileListBuildable to be used as Squirrel parameter */ |
4 /* Allow AITileList_vBuildable to be used as Squirrel parameter */ |
5 template <> AITileListBuildable *GetParam(ForceType<AITileListBuildable *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListBuildable *)instance; } |
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 <> AITileListBuildable &GetParam(ForceType<AITileListBuildable &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListBuildable *)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 AITileListBuildable *GetParam(ForceType<const AITileListBuildable *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListBuildable *)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 AITileListBuildable &GetParam(ForceType<const AITileListBuildable &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListBuildable *)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<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; } |
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 |
10 }; // namespace SQConvert |
11 |
11 |
12 void SQAITileListBuildable_Register(Squirrel *engine) { |
12 void SQAITileList_vBuildable_Register(Squirrel *engine) { |
13 DefSQClass <AITileListBuildable> SQAITileListBuildable("AITileListBuildable"); |
13 DefSQClass <AITileList_vBuildable> SQAITileList_vBuildable("AITileList_vBuildable"); |
14 SQAITileListBuildable.PreRegister(engine); |
14 SQAITileList_vBuildable.PreRegister(engine); |
15 SQAITileListBuildable.AddConstructor<void (AITileListBuildable::*)(), 1>(engine, "x"); |
15 SQAITileList_vBuildable.AddConstructor<void (AITileList_vBuildable::*)(), 1>(engine, "x"); |
16 |
16 |
17 SQAITileListBuildable.DefSQStaticMethod(engine, &AITileListBuildable::GetClassName, "GetClassName", 1, "x"); |
17 SQAITileList_vBuildable.DefSQStaticMethod(engine, &AITileList_vBuildable::GetClassName, "GetClassName", 1, "x"); |
18 |
18 |
19 SQAITileListBuildable.PostRegister(engine); |
19 SQAITileList_vBuildable.PostRegister(engine); |
20 } |
20 } |
21 |
21 |
22 namespace SQConvert { |
22 namespace SQConvert { |
23 /* Allow AITileListWater to be used as Squirrel parameter */ |
23 /* Allow AITileList_vWater to be used as Squirrel parameter */ |
24 template <> AITileListWater *GetParam(ForceType<AITileListWater *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListWater *)instance; } |
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 <> AITileListWater &GetParam(ForceType<AITileListWater &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListWater *)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 AITileListWater *GetParam(ForceType<const AITileListWater *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListWater *)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 AITileListWater &GetParam(ForceType<const AITileListWater &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListWater *)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<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; } |
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 |
29 }; // namespace SQConvert |
30 |
30 |
31 void SQAITileListWater_Register(Squirrel *engine) { |
31 void SQAITileList_vWater_Register(Squirrel *engine) { |
32 DefSQClass <AITileListWater> SQAITileListWater("AITileListWater"); |
32 DefSQClass <AITileList_vWater> SQAITileList_vWater("AITileList_vWater"); |
33 SQAITileListWater.PreRegister(engine); |
33 SQAITileList_vWater.PreRegister(engine); |
34 SQAITileListWater.AddConstructor<void (AITileListWater::*)(), 1>(engine, "x"); |
34 SQAITileList_vWater.AddConstructor<void (AITileList_vWater::*)(), 1>(engine, "x"); |
35 |
35 |
36 SQAITileListWater.DefSQStaticMethod(engine, &AITileListWater::GetClassName, "GetClassName", 1, "x"); |
36 SQAITileList_vWater.DefSQStaticMethod(engine, &AITileList_vWater::GetClassName, "GetClassName", 1, "x"); |
37 |
37 |
38 SQAITileListWater.PostRegister(engine); |
38 SQAITileList_vWater.PostRegister(engine); |
39 } |
39 } |
40 |
40 |
41 namespace SQConvert { |
41 namespace SQConvert { |
42 /* Allow AITileListBuildableRectangle to be used as Squirrel parameter */ |
42 /* Allow AITileList_vBuildableRectangle to be used as Squirrel parameter */ |
43 template <> AITileListBuildableRectangle *GetParam(ForceType<AITileListBuildableRectangle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListBuildableRectangle *)instance; } |
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 <> AITileListBuildableRectangle &GetParam(ForceType<AITileListBuildableRectangle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListBuildableRectangle *)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 AITileListBuildableRectangle *GetParam(ForceType<const AITileListBuildableRectangle *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListBuildableRectangle *)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 AITileListBuildableRectangle &GetParam(ForceType<const AITileListBuildableRectangle &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListBuildableRectangle *)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<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; } |
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 |
48 }; // namespace SQConvert |
49 |
49 |
50 void SQAITileListBuildableRectangle_Register(Squirrel *engine) { |
50 void SQAITileList_vBuildableRectangle_Register(Squirrel *engine) { |
51 DefSQClass <AITileListBuildableRectangle> SQAITileListBuildableRectangle("AITileListBuildableRectangle"); |
51 DefSQClass <AITileList_vBuildableRectangle> SQAITileList_vBuildableRectangle("AITileList_vBuildableRectangle"); |
52 SQAITileListBuildableRectangle.PreRegister(engine); |
52 SQAITileList_vBuildableRectangle.PreRegister(engine); |
53 SQAITileListBuildableRectangle.AddConstructor<void (AITileListBuildableRectangle::*)(uint width, uint height), 3>(engine, "xii"); |
53 SQAITileList_vBuildableRectangle.AddConstructor<void (AITileList_vBuildableRectangle::*)(uint width, uint height), 3>(engine, "xii"); |
54 |
54 |
55 SQAITileListBuildableRectangle.DefSQStaticMethod(engine, &AITileListBuildableRectangle::GetClassName, "GetClassName", 1, "x"); |
55 SQAITileList_vBuildableRectangle.DefSQStaticMethod(engine, &AITileList_vBuildableRectangle::GetClassName, "GetClassName", 1, "x"); |
56 |
56 |
57 SQAITileListBuildableRectangle.PostRegister(engine); |
57 SQAITileList_vBuildableRectangle.PostRegister(engine); |
58 } |
58 } |
59 |
59 |
60 namespace SQConvert { |
60 namespace SQConvert { |
61 /* Allow AITileListSlope to be used as Squirrel parameter */ |
61 /* Allow AITileList_vSlope to be used as Squirrel parameter */ |
62 template <> AITileListSlope *GetParam(ForceType<AITileListSlope *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListSlope *)instance; } |
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 <> AITileListSlope &GetParam(ForceType<AITileListSlope &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListSlope *)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 AITileListSlope *GetParam(ForceType<const AITileListSlope *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListSlope *)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 AITileListSlope &GetParam(ForceType<const AITileListSlope &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListSlope *)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<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; } |
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 |
67 }; // namespace SQConvert |
68 |
68 |
69 void SQAITileListSlope_Register(Squirrel *engine) { |
69 void SQAITileList_vSlope_Register(Squirrel *engine) { |
70 DefSQClass <AITileListSlope> SQAITileListSlope("AITileListSlope"); |
70 DefSQClass <AITileList_vSlope> SQAITileList_vSlope("AITileList_vSlope"); |
71 SQAITileListSlope.PreRegister(engine); |
71 SQAITileList_vSlope.PreRegister(engine); |
72 SQAITileListSlope.AddConstructor<void (AITileListSlope::*)(), 1>(engine, "x"); |
72 SQAITileList_vSlope.AddConstructor<void (AITileList_vSlope::*)(), 1>(engine, "x"); |
73 |
73 |
74 SQAITileListSlope.DefSQStaticMethod(engine, &AITileListSlope::GetClassName, "GetClassName", 1, "x"); |
74 SQAITileList_vSlope.DefSQStaticMethod(engine, &AITileList_vSlope::GetClassName, "GetClassName", 1, "x"); |
75 |
75 |
76 SQAITileListSlope.PostRegister(engine); |
76 SQAITileList_vSlope.PostRegister(engine); |
77 } |
77 } |
78 |
78 |
79 namespace SQConvert { |
79 namespace SQConvert { |
80 /* Allow AITileListHeight to be used as Squirrel parameter */ |
80 /* Allow AITileList_vHeight to be used as Squirrel parameter */ |
81 template <> AITileListHeight *GetParam(ForceType<AITileListHeight *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListHeight *)instance; } |
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 <> AITileListHeight &GetParam(ForceType<AITileListHeight &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListHeight *)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 AITileListHeight *GetParam(ForceType<const AITileListHeight *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListHeight *)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 AITileListHeight &GetParam(ForceType<const AITileListHeight &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListHeight *)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<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; } |
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 |
86 }; // namespace SQConvert |
87 |
87 |
88 void SQAITileListHeight_Register(Squirrel *engine) { |
88 void SQAITileList_vHeight_Register(Squirrel *engine) { |
89 DefSQClass <AITileListHeight> SQAITileListHeight("AITileListHeight"); |
89 DefSQClass <AITileList_vHeight> SQAITileList_vHeight("AITileList_vHeight"); |
90 SQAITileListHeight.PreRegister(engine); |
90 SQAITileList_vHeight.PreRegister(engine); |
91 SQAITileListHeight.AddConstructor<void (AITileListHeight::*)(), 1>(engine, "x"); |
91 SQAITileList_vHeight.AddConstructor<void (AITileList_vHeight::*)(), 1>(engine, "x"); |
92 |
92 |
93 SQAITileListHeight.DefSQStaticMethod(engine, &AITileListHeight::GetClassName, "GetClassName", 1, "x"); |
93 SQAITileList_vHeight.DefSQStaticMethod(engine, &AITileList_vHeight::GetClassName, "GetClassName", 1, "x"); |
94 |
94 |
95 SQAITileListHeight.PostRegister(engine); |
95 SQAITileList_vHeight.PostRegister(engine); |
96 } |
96 } |
97 |
97 |
98 namespace SQConvert { |
98 namespace SQConvert { |
99 /* Allow AITileListNeighbourRoadCount to be used as Squirrel parameter */ |
99 /* Allow AITileList_vNeighbourRoadCount to be used as Squirrel parameter */ |
100 template <> AITileListNeighbourRoadCount *GetParam(ForceType<AITileListNeighbourRoadCount *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListNeighbourRoadCount *)instance; } |
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 <> AITileListNeighbourRoadCount &GetParam(ForceType<AITileListNeighbourRoadCount &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListNeighbourRoadCount *)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 AITileListNeighbourRoadCount *GetParam(ForceType<const AITileListNeighbourRoadCount *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListNeighbourRoadCount *)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 AITileListNeighbourRoadCount &GetParam(ForceType<const AITileListNeighbourRoadCount &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListNeighbourRoadCount *)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<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; } |
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 |
105 }; // namespace SQConvert |
106 |
106 |
107 void SQAITileListNeighbourRoadCount_Register(Squirrel *engine) { |
107 void SQAITileList_vNeighbourRoadCount_Register(Squirrel *engine) { |
108 DefSQClass <AITileListNeighbourRoadCount> SQAITileListNeighbourRoadCount("AITileListNeighbourRoadCount"); |
108 DefSQClass <AITileList_vNeighbourRoadCount> SQAITileList_vNeighbourRoadCount("AITileList_vNeighbourRoadCount"); |
109 SQAITileListNeighbourRoadCount.PreRegister(engine); |
109 SQAITileList_vNeighbourRoadCount.PreRegister(engine); |
110 SQAITileListNeighbourRoadCount.AddConstructor<void (AITileListNeighbourRoadCount::*)(), 1>(engine, "x"); |
110 SQAITileList_vNeighbourRoadCount.AddConstructor<void (AITileList_vNeighbourRoadCount::*)(), 1>(engine, "x"); |
111 |
111 |
112 SQAITileListNeighbourRoadCount.DefSQStaticMethod(engine, &AITileListNeighbourRoadCount::GetClassName, "GetClassName", 1, "x"); |
112 SQAITileList_vNeighbourRoadCount.DefSQStaticMethod(engine, &AITileList_vNeighbourRoadCount::GetClassName, "GetClassName", 1, "x"); |
113 |
113 |
114 SQAITileListNeighbourRoadCount.PostRegister(engine); |
114 SQAITileList_vNeighbourRoadCount.PostRegister(engine); |
115 } |
115 } |
116 |
116 |
117 namespace SQConvert { |
117 namespace SQConvert { |
118 /* Allow AITileListRoadTile to be used as Squirrel parameter */ |
118 /* Allow AITileList_vRoadTile to be used as Squirrel parameter */ |
119 template <> AITileListRoadTile *GetParam(ForceType<AITileListRoadTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListRoadTile *)instance; } |
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 <> AITileListRoadTile &GetParam(ForceType<AITileListRoadTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListRoadTile *)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 AITileListRoadTile *GetParam(ForceType<const AITileListRoadTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListRoadTile *)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 AITileListRoadTile &GetParam(ForceType<const AITileListRoadTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListRoadTile *)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<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; } |
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 |
124 }; // namespace SQConvert |
125 |
125 |
126 void SQAITileListRoadTile_Register(Squirrel *engine) { |
126 void SQAITileList_vRoadTile_Register(Squirrel *engine) { |
127 DefSQClass <AITileListRoadTile> SQAITileListRoadTile("AITileListRoadTile"); |
127 DefSQClass <AITileList_vRoadTile> SQAITileList_vRoadTile("AITileList_vRoadTile"); |
128 SQAITileListRoadTile.PreRegister(engine); |
128 SQAITileList_vRoadTile.PreRegister(engine); |
129 SQAITileListRoadTile.AddConstructor<void (AITileListRoadTile::*)(), 1>(engine, "x"); |
129 SQAITileList_vRoadTile.AddConstructor<void (AITileList_vRoadTile::*)(), 1>(engine, "x"); |
130 |
130 |
131 SQAITileListRoadTile.DefSQStaticMethod(engine, &AITileListRoadTile::GetClassName, "GetClassName", 1, "x"); |
131 SQAITileList_vRoadTile.DefSQStaticMethod(engine, &AITileList_vRoadTile::GetClassName, "GetClassName", 1, "x"); |
132 |
132 |
133 SQAITileListRoadTile.PostRegister(engine); |
133 SQAITileList_vRoadTile.PostRegister(engine); |
134 } |
134 } |
135 |
135 |
136 namespace SQConvert { |
136 namespace SQConvert { |
137 /* Allow AITileListCargoAcceptance to be used as Squirrel parameter */ |
137 /* Allow AITileList_vCargoAcceptance to be used as Squirrel parameter */ |
138 template <> AITileListCargoAcceptance *GetParam(ForceType<AITileListCargoAcceptance *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListCargoAcceptance *)instance; } |
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 <> AITileListCargoAcceptance &GetParam(ForceType<AITileListCargoAcceptance &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListCargoAcceptance *)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 AITileListCargoAcceptance *GetParam(ForceType<const AITileListCargoAcceptance *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListCargoAcceptance *)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 AITileListCargoAcceptance &GetParam(ForceType<const AITileListCargoAcceptance &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListCargoAcceptance *)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<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; } |
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 |
143 }; // namespace SQConvert |
144 |
144 |
145 void SQAITileListCargoAcceptance_Register(Squirrel *engine) { |
145 void SQAITileList_vCargoAcceptance_Register(Squirrel *engine) { |
146 DefSQClass <AITileListCargoAcceptance> SQAITileListCargoAcceptance("AITileListCargoAcceptance"); |
146 DefSQClass <AITileList_vCargoAcceptance> SQAITileList_vCargoAcceptance("AITileList_vCargoAcceptance"); |
147 SQAITileListCargoAcceptance.PreRegister(engine); |
147 SQAITileList_vCargoAcceptance.PreRegister(engine); |
148 SQAITileListCargoAcceptance.AddConstructor<void (AITileListCargoAcceptance::*)(CargoID cargo_type, uint width, uint height, uint radius), 5>(engine, "xiiii"); |
148 SQAITileList_vCargoAcceptance.AddConstructor<void (AITileList_vCargoAcceptance::*)(CargoID cargo_type, uint width, uint height, uint radius), 5>(engine, "xiiii"); |
149 |
149 |
150 SQAITileListCargoAcceptance.DefSQStaticMethod(engine, &AITileListCargoAcceptance::GetClassName, "GetClassName", 1, "x"); |
150 SQAITileList_vCargoAcceptance.DefSQStaticMethod(engine, &AITileList_vCargoAcceptance::GetClassName, "GetClassName", 1, "x"); |
151 |
151 |
152 SQAITileListCargoAcceptance.PostRegister(engine); |
152 SQAITileList_vCargoAcceptance.PostRegister(engine); |
153 } |
153 } |
154 |
154 |
155 namespace SQConvert { |
155 namespace SQConvert { |
156 /* Allow AITileListDistanceManhattanToTile to be used as Squirrel parameter */ |
156 /* Allow AITileList_vDistanceManhattanToTile to be used as Squirrel parameter */ |
157 template <> AITileListDistanceManhattanToTile *GetParam(ForceType<AITileListDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListDistanceManhattanToTile *)instance; } |
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 <> AITileListDistanceManhattanToTile &GetParam(ForceType<AITileListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListDistanceManhattanToTile *)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 AITileListDistanceManhattanToTile *GetParam(ForceType<const AITileListDistanceManhattanToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListDistanceManhattanToTile *)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 AITileListDistanceManhattanToTile &GetParam(ForceType<const AITileListDistanceManhattanToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListDistanceManhattanToTile *)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<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; } |
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 |
162 }; // namespace SQConvert |
163 |
163 |
164 void SQAITileListDistanceManhattanToTile_Register(Squirrel *engine) { |
164 void SQAITileList_vDistanceManhattanToTile_Register(Squirrel *engine) { |
165 DefSQClass <AITileListDistanceManhattanToTile> SQAITileListDistanceManhattanToTile("AITileListDistanceManhattanToTile"); |
165 DefSQClass <AITileList_vDistanceManhattanToTile> SQAITileList_vDistanceManhattanToTile("AITileList_vDistanceManhattanToTile"); |
166 SQAITileListDistanceManhattanToTile.PreRegister(engine); |
166 SQAITileList_vDistanceManhattanToTile.PreRegister(engine); |
167 SQAITileListDistanceManhattanToTile.AddConstructor<void (AITileListDistanceManhattanToTile::*)(TileIndex tile), 2>(engine, "xi"); |
167 SQAITileList_vDistanceManhattanToTile.AddConstructor<void (AITileList_vDistanceManhattanToTile::*)(TileIndex tile), 2>(engine, "xi"); |
168 |
168 |
169 SQAITileListDistanceManhattanToTile.DefSQStaticMethod(engine, &AITileListDistanceManhattanToTile::GetClassName, "GetClassName", 1, "x"); |
169 SQAITileList_vDistanceManhattanToTile.DefSQStaticMethod(engine, &AITileList_vDistanceManhattanToTile::GetClassName, "GetClassName", 1, "x"); |
170 |
170 |
171 SQAITileListDistanceManhattanToTile.PostRegister(engine); |
171 SQAITileList_vDistanceManhattanToTile.PostRegister(engine); |
172 } |
172 } |
173 |
173 |
174 namespace SQConvert { |
174 namespace SQConvert { |
175 /* Allow AITileListDistanceSquareToTile to be used as Squirrel parameter */ |
175 /* Allow AITileList_vDistanceSquareToTile to be used as Squirrel parameter */ |
176 template <> AITileListDistanceSquareToTile *GetParam(ForceType<AITileListDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListDistanceSquareToTile *)instance; } |
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 <> AITileListDistanceSquareToTile &GetParam(ForceType<AITileListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListDistanceSquareToTile *)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 AITileListDistanceSquareToTile *GetParam(ForceType<const AITileListDistanceSquareToTile *>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return (AITileListDistanceSquareToTile *)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 AITileListDistanceSquareToTile &GetParam(ForceType<const AITileListDistanceSquareToTile &>, HSQUIRRELVM vm, int index) { SQUserPointer instance; sq_getinstanceup(vm, index, &instance, 0); return *(AITileListDistanceSquareToTile *)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<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; } |
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 |
181 }; // namespace SQConvert |
182 |
182 |
183 void SQAITileListDistanceSquareToTile_Register(Squirrel *engine) { |
183 void SQAITileList_vDistanceSquareToTile_Register(Squirrel *engine) { |
184 DefSQClass <AITileListDistanceSquareToTile> SQAITileListDistanceSquareToTile("AITileListDistanceSquareToTile"); |
184 DefSQClass <AITileList_vDistanceSquareToTile> SQAITileList_vDistanceSquareToTile("AITileList_vDistanceSquareToTile"); |
185 SQAITileListDistanceSquareToTile.PreRegister(engine); |
185 SQAITileList_vDistanceSquareToTile.PreRegister(engine); |
186 SQAITileListDistanceSquareToTile.AddConstructor<void (AITileListDistanceSquareToTile::*)(TileIndex tile), 2>(engine, "xi"); |
186 SQAITileList_vDistanceSquareToTile.AddConstructor<void (AITileList_vDistanceSquareToTile::*)(TileIndex tile), 2>(engine, "xi"); |
187 |
187 |
188 SQAITileListDistanceSquareToTile.DefSQStaticMethod(engine, &AITileListDistanceSquareToTile::GetClassName, "GetClassName", 1, "x"); |
188 SQAITileList_vDistanceSquareToTile.DefSQStaticMethod(engine, &AITileList_vDistanceSquareToTile::GetClassName, "GetClassName", 1, "x"); |
189 |
189 |
190 SQAITileListDistanceSquareToTile.PostRegister(engine); |
190 SQAITileList_vDistanceSquareToTile.PostRegister(engine); |
191 } |
191 } |