Freeciv-3.2
Loading...
Searching...
No Matches
tolua_game_gen.c
Go to the documentation of this file.
1/*
2** Lua binding: game
3*/
4
5#include "tolua.h"
6
7#ifndef __cplusplus
8#include <stdlib.h>
9#endif
10#ifdef __cplusplus
11 extern "C" int tolua_bnd_takeownership (lua_State* L); // from tolua_map.c
12#else
13 int tolua_bnd_takeownership (lua_State* L); /* from tolua_map.c */
14#endif
15#include <string.h>
16
17/* Exported function */
18TOLUA_API int tolua_game_open (lua_State* tolua_S);
19LUALIB_API int luaopen_game (lua_State* tolua_S);
20
21#ifdef HAVE_CONFIG_H
22#include <fc_config.h>
23#endif
24#include "api_common_utilities.h"
25#include "api_game_effects.h"
26#include "api_game_find.h"
27#include "api_game_methods.h"
28#include "luascript_types.h"
29#define game_info_substructure game.info
30
31/* function to register type */
32static void tolua_reg_types (lua_State* tolua_S)
33{
34 tolua_usertype(tolua_S,"Unit_Type");
35 tolua_usertype(tolua_S,"Direction");
36 tolua_usertype(tolua_S,"Action");
37 tolua_usertype(tolua_S,"City");
38 tolua_usertype(tolua_S,"Unit_List_Link");
39 tolua_usertype(tolua_S,"Terrain");
40 tolua_usertype(tolua_S,"Achievement");
41 tolua_usertype(tolua_S,"Player");
42 tolua_usertype(tolua_S,"Connection");
43 tolua_usertype(tolua_S,"Tile");
44 tolua_usertype(tolua_S,"City_List_Link");
45 tolua_usertype(tolua_S,"Nation_Type");
46 tolua_usertype(tolua_S,"Disaster");
47 tolua_usertype(tolua_S,"Building_Type");
48 tolua_usertype(tolua_S,"Unit");
49 tolua_usertype(tolua_S,"Tech_Type");
50 tolua_usertype(tolua_S,"Nonexistent");
51 tolua_usertype(tolua_S,"Game_Info");
52 tolua_usertype(tolua_S,"Counter");
53 tolua_usertype(tolua_S,"Government");
54}
55
56/* get function: name of class Player */
57static int tolua_get_Player_Player_name(lua_State* tolua_S)
58{
59 Player* self = (Player*) tolua_tousertype(tolua_S,1,0);
60#ifndef TOLUA_RELEASE
61 if (!self) {
62 tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
63 return 0;
64 }
65#endif
66 tolua_pushstring(tolua_S,(const char*)self->name);
67 return 1;
68}
69
70/* get function: nation of class Player */
71static int tolua_get_Player_Player_nation_ptr(lua_State* tolua_S)
72{
73 Player* self = (Player*) tolua_tousertype(tolua_S,1,0);
74#ifndef TOLUA_RELEASE
75 if (!self) {
76 tolua_error(tolua_S,"invalid 'self' in accessing variable 'nation'",NULL);
77 return 0;
78 }
79#endif
80 tolua_pushusertype(tolua_S,(void*)self->nation,"Nation_Type");
81 return 1;
82}
83
84/* set function: nation of class Player */
85static int tolua_set_Player_Player_nation_ptr(lua_State* tolua_S)
86{
87 Player* self = (Player*) tolua_tousertype(tolua_S,1,0);
88#ifndef TOLUA_RELEASE
89 tolua_Error tolua_err;
90 if (!self) {
91 tolua_error(tolua_S,"invalid 'self' in accessing variable 'nation'",NULL);
92 return 0;
93 }
94 if (!tolua_isusertype(tolua_S,2,"Nation_Type",0,&tolua_err))
95 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
96#endif
97 self->nation = ((Nation_Type*) tolua_tousertype(tolua_S,2,0));
98 return 0;
99}
100
101/* get function: government of class Player */
102static int tolua_get_Player_Player_government_ptr(lua_State* tolua_S)
103{
104 Player* self = (Player*) tolua_tousertype(tolua_S,1,0);
105#ifndef TOLUA_RELEASE
106 if (!self) {
107 tolua_error(tolua_S,"invalid 'self' in accessing variable 'government'",NULL);
108 return 0;
109 }
110#endif
111 tolua_pushusertype(tolua_S,(void*)self->government,"Government");
112 return 1;
113}
114
115/* set function: government of class Player */
116static int tolua_set_Player_Player_government_ptr(lua_State* tolua_S)
117{
118 Player* self = (Player*) tolua_tousertype(tolua_S,1,0);
119#ifndef TOLUA_RELEASE
120 tolua_Error tolua_err;
121 if (!self) {
122 tolua_error(tolua_S,"invalid 'self' in accessing variable 'government'",NULL);
123 return 0;
124 }
125 if (!tolua_isusertype(tolua_S,2,"Government",0,&tolua_err))
126 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
127#endif
128 self->government = ((Government*) tolua_tousertype(tolua_S,2,0));
129 return 0;
130}
131
132/* get function: is_alive of class Player */
133static int tolua_get_Player_Player_is_alive(lua_State* tolua_S)
134{
135 Player* self = (Player*) tolua_tousertype(tolua_S,1,0);
136#ifndef TOLUA_RELEASE
137 if (!self) {
138 tolua_error(tolua_S,"invalid 'self' in accessing variable 'is_alive'",NULL);
139 return 0;
140 }
141#endif
142 tolua_pushboolean(tolua_S,(bool)self->is_alive);
143 return 1;
144}
145
146/* set function: is_alive of class Player */
147static int tolua_set_Player_Player_is_alive(lua_State* tolua_S)
148{
149 Player* self = (Player*) tolua_tousertype(tolua_S,1,0);
150#ifndef TOLUA_RELEASE
151 tolua_Error tolua_err;
152 if (!self) {
153 tolua_error(tolua_S,"invalid 'self' in accessing variable 'is_alive'",NULL);
154 return 0;
155 }
156 if (!tolua_isboolean(tolua_S,2,0,&tolua_err))
157 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
158#endif
159 self->is_alive = ((bool) tolua_toboolean(tolua_S,2,0));
160 return 0;
161}
162
163/* get function: name of class City */
164static int tolua_get_City_City_name(lua_State* tolua_S)
165{
166 City* self = (City*) tolua_tousertype(tolua_S,1,0);
167#ifndef TOLUA_RELEASE
168 if (!self) {
169 tolua_error(tolua_S,"invalid 'self' in accessing variable 'name'",NULL);
170 return 0;
171 }
172#endif
173 tolua_pushstring(tolua_S,(const char*)self->name);
174 return 1;
175}
176
177/* get function: owner of class City */
178static int tolua_get_City_City_owner_ptr(lua_State* tolua_S)
179{
180 City* self = (City*) tolua_tousertype(tolua_S,1,0);
181#ifndef TOLUA_RELEASE
182 if (!self) {
183 tolua_error(tolua_S,"invalid 'self' in accessing variable 'owner'",NULL);
184 return 0;
185 }
186#endif
187 tolua_pushusertype(tolua_S,(void*)self->owner,"Player");
188 return 1;
189}
190
191/* set function: owner of class City */
192static int tolua_set_City_City_owner_ptr(lua_State* tolua_S)
193{
194 City* self = (City*) tolua_tousertype(tolua_S,1,0);
195#ifndef TOLUA_RELEASE
196 tolua_Error tolua_err;
197 if (!self) {
198 tolua_error(tolua_S,"invalid 'self' in accessing variable 'owner'",NULL);
199 return 0;
200 }
201 if (!tolua_isusertype(tolua_S,2,"Player",0,&tolua_err))
202 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
203#endif
204 self->owner = ((Player*) tolua_tousertype(tolua_S,2,0));
205 return 0;
206}
207
208/* get function: original of class City */
209static int tolua_get_City_City_original_ptr(lua_State* tolua_S)
210{
211 City* self = (City*) tolua_tousertype(tolua_S,1,0);
212#ifndef TOLUA_RELEASE
213 if (!self) {
214 tolua_error(tolua_S,"invalid 'self' in accessing variable 'original'",NULL);
215 return 0;
216 }
217#endif
218 tolua_pushusertype(tolua_S,(void*)self->original,"Player");
219 return 1;
220}
221
222/* set function: original of class City */
223static int tolua_set_City_City_original_ptr(lua_State* tolua_S)
224{
225 City* self = (City*) tolua_tousertype(tolua_S,1,0);
226#ifndef TOLUA_RELEASE
227 tolua_Error tolua_err;
228 if (!self) {
229 tolua_error(tolua_S,"invalid 'self' in accessing variable 'original'",NULL);
230 return 0;
231 }
232 if (!tolua_isusertype(tolua_S,2,"Player",0,&tolua_err))
233 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
234#endif
235 self->original = ((Player*) tolua_tousertype(tolua_S,2,0));
236 return 0;
237}
238
239/* get function: id of class City */
240static int tolua_get_City_City_id(lua_State* tolua_S)
241{
242 City* self = (City*) tolua_tousertype(tolua_S,1,0);
243#ifndef TOLUA_RELEASE
244 if (!self) {
245 tolua_error(tolua_S,"invalid 'self' in accessing variable 'id'",NULL);
246 return 0;
247 }
248#endif
249 tolua_pushnumber(tolua_S,(lua_Number)self->id);
250 return 1;
251}
252
253/* get function: id of class Connection */
254static int tolua_get_Connection_Connection_id(lua_State* tolua_S)
255{
256 Connection* self = (Connection*) tolua_tousertype(tolua_S,1,0);
257#ifndef TOLUA_RELEASE
258 if (!self) {
259 tolua_error(tolua_S,"invalid 'self' in accessing variable 'id'",NULL);
260 return 0;
261 }
262#endif
263 tolua_pushnumber(tolua_S,(lua_Number)self->id);
264 return 1;
265}
266
267/* get function: utype of class Unit */
268static int tolua_get_Unit_Unit_utype_ptr(lua_State* tolua_S)
269{
270 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
271#ifndef TOLUA_RELEASE
272 if (!self) {
273 tolua_error(tolua_S,"invalid 'self' in accessing variable 'utype'",NULL);
274 return 0;
275 }
276#endif
277 tolua_pushusertype(tolua_S,(void*)self->utype,"Unit_Type");
278 return 1;
279}
280
281/* set function: utype of class Unit */
282static int tolua_set_Unit_Unit_utype_ptr(lua_State* tolua_S)
283{
284 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
285#ifndef TOLUA_RELEASE
286 tolua_Error tolua_err;
287 if (!self) {
288 tolua_error(tolua_S,"invalid 'self' in accessing variable 'utype'",NULL);
289 return 0;
290 }
291 if (!tolua_isusertype(tolua_S,2,"Unit_Type",0,&tolua_err))
292 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
293#endif
294 self->utype = ((Unit_Type*) tolua_tousertype(tolua_S,2,0));
295 return 0;
296}
297
298/* get function: owner of class Unit */
299static int tolua_get_Unit_Unit_owner_ptr(lua_State* tolua_S)
300{
301 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
302#ifndef TOLUA_RELEASE
303 if (!self) {
304 tolua_error(tolua_S,"invalid 'self' in accessing variable 'owner'",NULL);
305 return 0;
306 }
307#endif
308 tolua_pushusertype(tolua_S,(void*)self->owner,"Player");
309 return 1;
310}
311
312/* set function: owner of class Unit */
313static int tolua_set_Unit_Unit_owner_ptr(lua_State* tolua_S)
314{
315 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
316#ifndef TOLUA_RELEASE
317 tolua_Error tolua_err;
318 if (!self) {
319 tolua_error(tolua_S,"invalid 'self' in accessing variable 'owner'",NULL);
320 return 0;
321 }
322 if (!tolua_isusertype(tolua_S,2,"Player",0,&tolua_err))
323 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
324#endif
325 self->owner = ((Player*) tolua_tousertype(tolua_S,2,0));
326 return 0;
327}
328
329/* get function: homecity of class Unit */
330static int tolua_get_Unit_Unit_homecity(lua_State* tolua_S)
331{
332 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
333#ifndef TOLUA_RELEASE
334 if (!self) {
335 tolua_error(tolua_S,"invalid 'self' in accessing variable 'homecity'",NULL);
336 return 0;
337 }
338#endif
339 tolua_pushnumber(tolua_S,(lua_Number)self->homecity);
340 return 1;
341}
342
343/* set function: homecity of class Unit */
344static int tolua_set_Unit_Unit_homecity(lua_State* tolua_S)
345{
346 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
347#ifndef TOLUA_RELEASE
348 tolua_Error tolua_err;
349 if (!self) {
350 tolua_error(tolua_S,"invalid 'self' in accessing variable 'homecity'",NULL);
351 return 0;
352 }
353 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
354 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
355#endif
356 self->homecity = ((int) tolua_tonumber(tolua_S,2,0));
357 return 0;
358}
359
360/* get function: veteran of class Unit */
361static int tolua_get_Unit_Unit_veteran(lua_State* tolua_S)
362{
363 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
364#ifndef TOLUA_RELEASE
365 if (!self) {
366 tolua_error(tolua_S,"invalid 'self' in accessing variable 'veteran'",NULL);
367 return 0;
368 }
369#endif
370 tolua_pushnumber(tolua_S,(lua_Number)self->veteran);
371 return 1;
372}
373
374/* set function: veteran of class Unit */
375static int tolua_set_Unit_Unit_veteran(lua_State* tolua_S)
376{
377 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
378#ifndef TOLUA_RELEASE
379 tolua_Error tolua_err;
380 if (!self) {
381 tolua_error(tolua_S,"invalid 'self' in accessing variable 'veteran'",NULL);
382 return 0;
383 }
384 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
385 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
386#endif
387 self->veteran = ((int) tolua_tonumber(tolua_S,2,0));
388 return 0;
389}
390
391/* get function: id of class Unit */
392static int tolua_get_Unit_Unit_id(lua_State* tolua_S)
393{
394 Unit* self = (Unit*) tolua_tousertype(tolua_S,1,0);
395#ifndef TOLUA_RELEASE
396 if (!self) {
397 tolua_error(tolua_S,"invalid 'self' in accessing variable 'id'",NULL);
398 return 0;
399 }
400#endif
401 tolua_pushnumber(tolua_S,(lua_Number)self->id);
402 return 1;
403}
404
405/* get function: terrain of class Tile */
406static int tolua_get_Tile_Tile_terrain_ptr(lua_State* tolua_S)
407{
408 Tile* self = (Tile*) tolua_tousertype(tolua_S,1,0);
409#ifndef TOLUA_RELEASE
410 if (!self) {
411 tolua_error(tolua_S,"invalid 'self' in accessing variable 'terrain'",NULL);
412 return 0;
413 }
414#endif
415 tolua_pushusertype(tolua_S,(void*)self->terrain,"Terrain");
416 return 1;
417}
418
419/* set function: terrain of class Tile */
420static int tolua_set_Tile_Tile_terrain_ptr(lua_State* tolua_S)
421{
422 Tile* self = (Tile*) tolua_tousertype(tolua_S,1,0);
423#ifndef TOLUA_RELEASE
424 tolua_Error tolua_err;
425 if (!self) {
426 tolua_error(tolua_S,"invalid 'self' in accessing variable 'terrain'",NULL);
427 return 0;
428 }
429 if (!tolua_isusertype(tolua_S,2,"Terrain",0,&tolua_err))
430 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
431#endif
432 self->terrain = ((Terrain*) tolua_tousertype(tolua_S,2,0));
433 return 0;
434}
435
436/* get function: owner of class Tile */
437static int tolua_get_Tile_Tile_owner_ptr(lua_State* tolua_S)
438{
439 Tile* self = (Tile*) tolua_tousertype(tolua_S,1,0);
440#ifndef TOLUA_RELEASE
441 if (!self) {
442 tolua_error(tolua_S,"invalid 'self' in accessing variable 'owner'",NULL);
443 return 0;
444 }
445#endif
446 tolua_pushusertype(tolua_S,(void*)self->owner,"Player");
447 return 1;
448}
449
450/* set function: owner of class Tile */
451static int tolua_set_Tile_Tile_owner_ptr(lua_State* tolua_S)
452{
453 Tile* self = (Tile*) tolua_tousertype(tolua_S,1,0);
454#ifndef TOLUA_RELEASE
455 tolua_Error tolua_err;
456 if (!self) {
457 tolua_error(tolua_S,"invalid 'self' in accessing variable 'owner'",NULL);
458 return 0;
459 }
460 if (!tolua_isusertype(tolua_S,2,"Player",0,&tolua_err))
461 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
462#endif
463 self->owner = ((Player*) tolua_tousertype(tolua_S,2,0));
464 return 0;
465}
466
467/* get function: index of class Tile */
468static int tolua_get_Tile_Tile_index(lua_State* tolua_S)
469{
470 Tile* self = (Tile*) tolua_tousertype(tolua_S,1,0);
471#ifndef TOLUA_RELEASE
472 if (!self) {
473 tolua_error(tolua_S,"invalid 'self' in accessing variable 'index'",NULL);
474 return 0;
475 }
476#endif
477 tolua_pushnumber(tolua_S,(lua_Number)self->index);
478 return 1;
479}
480
481/* get function: item_number of class Government */
482static int tolua_get_Government_Government_item_number(lua_State* tolua_S)
483{
484 Government* self = (Government*) tolua_tousertype(tolua_S,1,0);
485#ifndef TOLUA_RELEASE
486 if (!self) {
487 tolua_error(tolua_S,"invalid 'self' in accessing variable 'item_number'",NULL);
488 return 0;
489 }
490#endif
491 tolua_pushnumber(tolua_S,(lua_Number)self->item_number);
492 return 1;
493}
494
495/* get function: item_number of class Nation_Type */
496static int tolua_get_Nation_Type_Nation_Type_item_number(lua_State* tolua_S)
497{
498 Nation_Type* self = (Nation_Type*) tolua_tousertype(tolua_S,1,0);
499#ifndef TOLUA_RELEASE
500 if (!self) {
501 tolua_error(tolua_S,"invalid 'self' in accessing variable 'item_number'",NULL);
502 return 0;
503 }
504#endif
505 tolua_pushnumber(tolua_S,(lua_Number)self->item_number);
506 return 1;
507}
508
509/* get function: build_cost of class Building_Type */
510static int tolua_get_Building_Type_Building_Type_build_cost(lua_State* tolua_S)
511{
512 Building_Type* self = (Building_Type*) tolua_tousertype(tolua_S,1,0);
513#ifndef TOLUA_RELEASE
514 if (!self) {
515 tolua_error(tolua_S,"invalid 'self' in accessing variable 'build_cost'",NULL);
516 return 0;
517 }
518#endif
519 tolua_pushnumber(tolua_S,(lua_Number)self->build_cost);
520 return 1;
521}
522
523/* set function: build_cost of class Building_Type */
524static int tolua_set_Building_Type_Building_Type_build_cost(lua_State* tolua_S)
525{
526 Building_Type* self = (Building_Type*) tolua_tousertype(tolua_S,1,0);
527#ifndef TOLUA_RELEASE
528 tolua_Error tolua_err;
529 if (!self) {
530 tolua_error(tolua_S,"invalid 'self' in accessing variable 'build_cost'",NULL);
531 return 0;
532 }
533 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
534 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
535#endif
536 self->build_cost = ((int) tolua_tonumber(tolua_S,2,0));
537 return 0;
538}
539
540/* get function: item_number of class Building_Type */
541static int tolua_get_Building_Type_Building_Type_item_number(lua_State* tolua_S)
542{
543 Building_Type* self = (Building_Type*) tolua_tousertype(tolua_S,1,0);
544#ifndef TOLUA_RELEASE
545 if (!self) {
546 tolua_error(tolua_S,"invalid 'self' in accessing variable 'item_number'",NULL);
547 return 0;
548 }
549#endif
550 tolua_pushnumber(tolua_S,(lua_Number)self->item_number);
551 return 1;
552}
553
554/* get function: build_cost of class Unit_Type */
555static int tolua_get_Unit_Type_Unit_Type_build_cost(lua_State* tolua_S)
556{
557 Unit_Type* self = (Unit_Type*) tolua_tousertype(tolua_S,1,0);
558#ifndef TOLUA_RELEASE
559 if (!self) {
560 tolua_error(tolua_S,"invalid 'self' in accessing variable 'build_cost'",NULL);
561 return 0;
562 }
563#endif
564 tolua_pushnumber(tolua_S,(lua_Number)self->build_cost);
565 return 1;
566}
567
568/* set function: build_cost of class Unit_Type */
569static int tolua_set_Unit_Type_Unit_Type_build_cost(lua_State* tolua_S)
570{
571 Unit_Type* self = (Unit_Type*) tolua_tousertype(tolua_S,1,0);
572#ifndef TOLUA_RELEASE
573 tolua_Error tolua_err;
574 if (!self) {
575 tolua_error(tolua_S,"invalid 'self' in accessing variable 'build_cost'",NULL);
576 return 0;
577 }
578 if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
579 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
580#endif
581 self->build_cost = ((int) tolua_tonumber(tolua_S,2,0));
582 return 0;
583}
584
585/* get function: obsoleted_by of class Unit_Type */
586static int tolua_get_Unit_Type_Unit_Type_obsoleted_by_ptr(lua_State* tolua_S)
587{
588 Unit_Type* self = (Unit_Type*) tolua_tousertype(tolua_S,1,0);
589#ifndef TOLUA_RELEASE
590 if (!self) {
591 tolua_error(tolua_S,"invalid 'self' in accessing variable 'obsoleted_by'",NULL);
592 return 0;
593 }
594#endif
595 tolua_pushusertype(tolua_S,(void*)self->obsoleted_by,"Unit_Type");
596 return 1;
597}
598
599/* set function: obsoleted_by of class Unit_Type */
600static int tolua_set_Unit_Type_Unit_Type_obsoleted_by_ptr(lua_State* tolua_S)
601{
602 Unit_Type* self = (Unit_Type*) tolua_tousertype(tolua_S,1,0);
603#ifndef TOLUA_RELEASE
604 tolua_Error tolua_err;
605 if (!self) {
606 tolua_error(tolua_S,"invalid 'self' in accessing variable 'obsoleted_by'",NULL);
607 return 0;
608 }
609 if (!tolua_isusertype(tolua_S,2,"Unit_Type",0,&tolua_err))
610 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
611#endif
612 self->obsoleted_by = ((Unit_Type*) tolua_tousertype(tolua_S,2,0));
613 return 0;
614}
615
616/* get function: item_number of class Unit_Type */
617static int tolua_get_Unit_Type_Unit_Type_item_number(lua_State* tolua_S)
618{
619 Unit_Type* self = (Unit_Type*) tolua_tousertype(tolua_S,1,0);
620#ifndef TOLUA_RELEASE
621 if (!self) {
622 tolua_error(tolua_S,"invalid 'self' in accessing variable 'item_number'",NULL);
623 return 0;
624 }
625#endif
626 tolua_pushnumber(tolua_S,(lua_Number)self->item_number);
627 return 1;
628}
629
630/* get function: item_number of class Tech_Type */
631static int tolua_get_Tech_Type_Tech_Type_item_number(lua_State* tolua_S)
632{
633 Tech_Type* self = (Tech_Type*) tolua_tousertype(tolua_S,1,0);
634#ifndef TOLUA_RELEASE
635 if (!self) {
636 tolua_error(tolua_S,"invalid 'self' in accessing variable 'item_number'",NULL);
637 return 0;
638 }
639#endif
640 tolua_pushnumber(tolua_S,(lua_Number)self->item_number);
641 return 1;
642}
643
644/* get function: cost of class Tech_Type */
645static int tolua_get_Tech_Type_Tech_Type_cost(lua_State* tolua_S)
646{
647 Tech_Type* self = (Tech_Type*) tolua_tousertype(tolua_S,1,0);
648#ifndef TOLUA_RELEASE
649 if (!self) {
650 tolua_error(tolua_S,"invalid 'self' in accessing variable 'cost'",NULL);
651 return 0;
652 }
653#endif
654 tolua_pushnumber(tolua_S,(lua_Number)self->cost);
655 return 1;
656}
657
658/* get function: item_number of class Terrain */
659static int tolua_get_Terrain_Terrain_item_number(lua_State* tolua_S)
660{
661 Terrain* self = (Terrain*) tolua_tousertype(tolua_S,1,0);
662#ifndef TOLUA_RELEASE
663 if (!self) {
664 tolua_error(tolua_S,"invalid 'self' in accessing variable 'item_number'",NULL);
665 return 0;
666 }
667#endif
668 tolua_pushnumber(tolua_S,(lua_Number)self->item_number);
669 return 1;
670}
671
672/* get function: id of class Disaster */
673static int tolua_get_Disaster_Disaster_id(lua_State* tolua_S)
674{
675 Disaster* self = (Disaster*) tolua_tousertype(tolua_S,1,0);
676#ifndef TOLUA_RELEASE
677 if (!self) {
678 tolua_error(tolua_S,"invalid 'self' in accessing variable 'id'",NULL);
679 return 0;
680 }
681#endif
682 tolua_pushnumber(tolua_S,(lua_Number)self->id);
683 return 1;
684}
685
686/* get function: id of class Achievement */
687static int tolua_get_Achievement_Achievement_id(lua_State* tolua_S)
688{
689 Achievement* self = (Achievement*) tolua_tousertype(tolua_S,1,0);
690#ifndef TOLUA_RELEASE
691 if (!self) {
692 tolua_error(tolua_S,"invalid 'self' in accessing variable 'id'",NULL);
693 return 0;
694 }
695#endif
696 tolua_pushnumber(tolua_S,(lua_Number)self->id);
697 return 1;
698}
699
700/* get function: id of class Action */
701static int tolua_get_Action_Action_id(lua_State* tolua_S)
702{
703 Action* self = (Action*) tolua_tousertype(tolua_S,1,0);
704#ifndef TOLUA_RELEASE
705 if (!self) {
706 tolua_error(tolua_S,"invalid 'self' in accessing variable 'id'",NULL);
707 return 0;
708 }
709#endif
710 tolua_pushnumber(tolua_S,(lua_Number)self->id);
711 return 1;
712}
713
714/* get function: base_tech_cost of class Game_Info */
715static int tolua_get_Game_Info_Game_Info_base_tech_cost(lua_State* tolua_S)
716{
717 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
718#ifndef TOLUA_RELEASE
719 if (!self) {
720 tolua_error(tolua_S,"invalid 'self' in accessing variable 'base_tech_cost'",NULL);
721 return 0;
722 }
723#endif
724 tolua_pushnumber(tolua_S,(lua_Number)self->base_tech_cost);
725 return 1;
726}
727
728/* get function: min_tech_cost of class Game_Info */
729static int tolua_get_Game_Info_Game_Info_min_tech_cost(lua_State* tolua_S)
730{
731 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
732#ifndef TOLUA_RELEASE
733 if (!self) {
734 tolua_error(tolua_S,"invalid 'self' in accessing variable 'min_tech_cost'",NULL);
735 return 0;
736 }
737#endif
738 tolua_pushnumber(tolua_S,(lua_Number)self->min_tech_cost);
739 return 1;
740}
741
742/* get function: tech_leak_pct of class Game_Info */
743static int tolua_get_Game_Info_Game_Info_tech_leak_pct(lua_State* tolua_S)
744{
745 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
746#ifndef TOLUA_RELEASE
747 if (!self) {
748 tolua_error(tolua_S,"invalid 'self' in accessing variable 'tech_leak_pct'",NULL);
749 return 0;
750 }
751#endif
752 tolua_pushnumber(tolua_S,(lua_Number)self->tech_leak_pct);
753 return 1;
754}
755
756/* get function: tech_steal_allow_holes of class Game_Info */
757static int tolua_get_Game_Info_Game_Info_tech_steal_allow_holes(lua_State* tolua_S)
758{
759 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
760#ifndef TOLUA_RELEASE
761 if (!self) {
762 tolua_error(tolua_S,"invalid 'self' in accessing variable 'tech_steal_allow_holes'",NULL);
763 return 0;
764 }
765#endif
766 tolua_pushboolean(tolua_S,(bool)self->tech_steal_allow_holes);
767 return 1;
768}
769
770/* get function: tech_trade_allow_holes of class Game_Info */
771static int tolua_get_Game_Info_Game_Info_tech_trade_allow_holes(lua_State* tolua_S)
772{
773 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
774#ifndef TOLUA_RELEASE
775 if (!self) {
776 tolua_error(tolua_S,"invalid 'self' in accessing variable 'tech_trade_allow_holes'",NULL);
777 return 0;
778 }
779#endif
780 tolua_pushboolean(tolua_S,(bool)self->tech_trade_allow_holes);
781 return 1;
782}
783
784/* get function: tech_trade_loss_allow_holes of class Game_Info */
785static int tolua_get_Game_Info_Game_Info_tech_trade_loss_allow_holes(lua_State* tolua_S)
786{
787 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
788#ifndef TOLUA_RELEASE
789 if (!self) {
790 tolua_error(tolua_S,"invalid 'self' in accessing variable 'tech_trade_loss_allow_holes'",NULL);
791 return 0;
792 }
793#endif
794 tolua_pushboolean(tolua_S,(bool)self->tech_trade_loss_allow_holes);
795 return 1;
796}
797
798/* get function: tech_parasite_allow_holes of class Game_Info */
799static int tolua_get_Game_Info_Game_Info_tech_parasite_allow_holes(lua_State* tolua_S)
800{
801 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
802#ifndef TOLUA_RELEASE
803 if (!self) {
804 tolua_error(tolua_S,"invalid 'self' in accessing variable 'tech_parasite_allow_holes'",NULL);
805 return 0;
806 }
807#endif
808 tolua_pushboolean(tolua_S,(bool)self->tech_parasite_allow_holes);
809 return 1;
810}
811
812/* get function: tech_loss_allow_holes of class Game_Info */
813static int tolua_get_Game_Info_Game_Info_tech_loss_allow_holes(lua_State* tolua_S)
814{
815 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
816#ifndef TOLUA_RELEASE
817 if (!self) {
818 tolua_error(tolua_S,"invalid 'self' in accessing variable 'tech_loss_allow_holes'",NULL);
819 return 0;
820 }
821#endif
822 tolua_pushboolean(tolua_S,(bool)self->tech_loss_allow_holes);
823 return 1;
824}
825
826/* get function: sciencebox of class Game_Info */
827static int tolua_get_Game_Info_Game_Info_sciencebox(lua_State* tolua_S)
828{
829 Game_Info* self = (Game_Info*) tolua_tousertype(tolua_S,1,0);
830#ifndef TOLUA_RELEASE
831 if (!self) {
832 tolua_error(tolua_S,"invalid 'self' in accessing variable 'sciencebox'",NULL);
833 return 0;
834 }
835#endif
836 tolua_pushnumber(tolua_S,(lua_Number)self->sciencebox);
837 return 1;
838}
839
840/* get function: game_info_substructure */
846
847/* set function: game_info_substructure */
848static int tolua_set_game_game_info_substructure(lua_State* tolua_S)
849{
850#ifndef TOLUA_RELEASE
851 tolua_Error tolua_err;
852 if (!tolua_isusertype(tolua_S,2,"Game_Info",0,&tolua_err))
853 tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
854#endif
855 game_info_substructure = *((Game_Info*) tolua_tousertype(tolua_S,2,0));
856 return 0;
857}
858
859/* function: api_methods_game_turn */
860static int tolua_game_game_current_turn00(lua_State* tolua_S)
861{
862#ifndef TOLUA_RELEASE
863 tolua_Error tolua_err;
864 if (
865 !tolua_isnoobj(tolua_S,1,&tolua_err)
866 )
867 goto tolua_lerror;
868 else
869#endif
870 {
871 lua_State* L = tolua_S;
872 {
873 int tolua_ret = (int) api_methods_game_turn(L);
874 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
875 }
876 }
877 return 1;
878#ifndef TOLUA_RELEASE
879 tolua_lerror:
880 tolua_error(tolua_S,"#ferror in function 'current_turn'.",&tolua_err);
881 return 0;
882#endif
883}
884
885/* function: api_methods_game_turn_deprecated */
886static int tolua_game_game_turn00(lua_State* tolua_S)
887{
888#ifndef TOLUA_RELEASE
889 tolua_Error tolua_err;
890 if (
891 !tolua_isnoobj(tolua_S,1,&tolua_err)
892 )
893 goto tolua_lerror;
894 else
895#endif
896 {
897 lua_State* L = tolua_S;
898 {
899 int tolua_ret = (int) api_methods_game_turn_deprecated(L);
900 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
901 }
902 }
903 return 1;
904#ifndef TOLUA_RELEASE
905 tolua_lerror:
906 tolua_error(tolua_S,"#ferror in function 'turn'.",&tolua_err);
907 return 0;
908#endif
909}
910
911/* function: api_methods_game_year */
912static int tolua_game_game_current_year00(lua_State* tolua_S)
913{
914#ifndef TOLUA_RELEASE
915 tolua_Error tolua_err;
916 if (
917 !tolua_isnoobj(tolua_S,1,&tolua_err)
918 )
919 goto tolua_lerror;
920 else
921#endif
922 {
923 lua_State* L = tolua_S;
924 {
925 int tolua_ret = (int) api_methods_game_year(L);
926 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
927 }
928 }
929 return 1;
930#ifndef TOLUA_RELEASE
931 tolua_lerror:
932 tolua_error(tolua_S,"#ferror in function 'current_year'.",&tolua_err);
933 return 0;
934#endif
935}
936
937/* function: api_methods_game_year_fragment */
938static int tolua_game_game_current_fragment00(lua_State* tolua_S)
939{
940#ifndef TOLUA_RELEASE
941 tolua_Error tolua_err;
942 if (
943 !tolua_isnoobj(tolua_S,1,&tolua_err)
944 )
945 goto tolua_lerror;
946 else
947#endif
948 {
949 lua_State* L = tolua_S;
950 {
951 int tolua_ret = (int) api_methods_game_year_fragment(L);
952 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
953 }
954 }
955 return 1;
956#ifndef TOLUA_RELEASE
957 tolua_lerror:
958 tolua_error(tolua_S,"#ferror in function 'current_fragment'.",&tolua_err);
959 return 0;
960#endif
961}
962
963/* function: api_methods_game_year_text */
964static int tolua_game_game_current_year_text00(lua_State* tolua_S)
965{
966#ifndef TOLUA_RELEASE
967 tolua_Error tolua_err;
968 if (
969 !tolua_isnoobj(tolua_S,1,&tolua_err)
970 )
971 goto tolua_lerror;
972 else
973#endif
974 {
975 lua_State* L = tolua_S;
976 {
977 const char* tolua_ret = (const char*) api_methods_game_year_text(L);
978 tolua_pushstring(tolua_S,(const char*)tolua_ret);
979 }
980 }
981 return 1;
982#ifndef TOLUA_RELEASE
983 tolua_lerror:
984 tolua_error(tolua_S,"#ferror in function 'current_year_text'.",&tolua_err);
985 return 0;
986#endif
987}
988
989/* function: api_methods_game_rulesetdir */
990static int tolua_game_game_rulesetdir00(lua_State* tolua_S)
991{
992#ifndef TOLUA_RELEASE
993 tolua_Error tolua_err;
994 if (
995 !tolua_isnoobj(tolua_S,1,&tolua_err)
996 )
997 goto tolua_lerror;
998 else
999#endif
1000 {
1001 lua_State* L = tolua_S;
1002 {
1003 const char* tolua_ret = (const char*) api_methods_game_rulesetdir(L);
1004 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1005 }
1006 }
1007 return 1;
1008#ifndef TOLUA_RELEASE
1009 tolua_lerror:
1010 tolua_error(tolua_S,"#ferror in function 'rulesetdir'.",&tolua_err);
1011 return 0;
1012#endif
1013}
1014
1015/* function: api_methods_game_ruleset_name */
1016static int tolua_game_game_ruleset_name00(lua_State* tolua_S)
1017{
1018#ifndef TOLUA_RELEASE
1019 tolua_Error tolua_err;
1020 if (
1021 !tolua_isnoobj(tolua_S,1,&tolua_err)
1022 )
1023 goto tolua_lerror;
1024 else
1025#endif
1026 {
1027 lua_State* L = tolua_S;
1028 {
1029 const char* tolua_ret = (const char*) api_methods_game_ruleset_name(L);
1030 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1031 }
1032 }
1033 return 1;
1034#ifndef TOLUA_RELEASE
1035 tolua_lerror:
1036 tolua_error(tolua_S,"#ferror in function 'ruleset_name'.",&tolua_err);
1037 return 0;
1038#endif
1039}
1040
1041/* function: api_methods_tech_cost_style */
1042static int tolua_game_game_tech_cost_style00(lua_State* tolua_S)
1043{
1044#ifndef TOLUA_RELEASE
1045 tolua_Error tolua_err;
1046 if (
1047 !tolua_isnoobj(tolua_S,1,&tolua_err)
1048 )
1049 goto tolua_lerror;
1050 else
1051#endif
1052 {
1053 lua_State* L = tolua_S;
1054 {
1055 const char* tolua_ret = (const char*) api_methods_tech_cost_style(L);
1056 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1057 }
1058 }
1059 return 1;
1060#ifndef TOLUA_RELEASE
1061 tolua_lerror:
1062 tolua_error(tolua_S,"#ferror in function 'tech_cost_style'.",&tolua_err);
1063 return 0;
1064#endif
1065}
1066
1067/* function: api_methods_tech_leakage_style */
1068static int tolua_game_game_tech_leakage_style00(lua_State* tolua_S)
1069{
1070#ifndef TOLUA_RELEASE
1071 tolua_Error tolua_err;
1072 if (
1073 !tolua_isnoobj(tolua_S,1,&tolua_err)
1074 )
1075 goto tolua_lerror;
1076 else
1077#endif
1078 {
1079 lua_State* L = tolua_S;
1080 {
1081 const char* tolua_ret = (const char*) api_methods_tech_leakage_style(L);
1082 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1083 }
1084 }
1085 return 1;
1086#ifndef TOLUA_RELEASE
1087 tolua_lerror:
1088 tolua_error(tolua_S,"#ferror in function 'tech_leakage_style'.",&tolua_err);
1089 return 0;
1090#endif
1091}
1092
1093/* function: api_methods_counter_rule_name */
1094static int tolua_game_Counter_rule_name00(lua_State* tolua_S)
1095{
1096#ifndef TOLUA_RELEASE
1097 tolua_Error tolua_err;
1098 if (
1099 !tolua_isusertype(tolua_S,1,"Counter",0,&tolua_err) ||
1100 !tolua_isnoobj(tolua_S,2,&tolua_err)
1101 )
1102 goto tolua_lerror;
1103 else
1104#endif
1105 {
1106 lua_State* L = tolua_S;
1107 Counter* c = ((Counter*) tolua_tousertype(tolua_S,1,0));
1108 {
1109 const char* tolua_ret = (const char*) api_methods_counter_rule_name(L,c);
1110 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1111 }
1112 }
1113 return 1;
1114#ifndef TOLUA_RELEASE
1115 tolua_lerror:
1116 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
1117 return 0;
1118#endif
1119}
1120
1121/* function: api_methods_counter_name_translation */
1122static int tolua_game_Counter_name_translation00(lua_State* tolua_S)
1123{
1124#ifndef TOLUA_RELEASE
1125 tolua_Error tolua_err;
1126 if (
1127 !tolua_isusertype(tolua_S,1,"Counter",0,&tolua_err) ||
1128 !tolua_isnoobj(tolua_S,2,&tolua_err)
1129 )
1130 goto tolua_lerror;
1131 else
1132#endif
1133 {
1134 lua_State* L = tolua_S;
1135 Counter* c = ((Counter*) tolua_tousertype(tolua_S,1,0));
1136 {
1137 const char* tolua_ret = (const char*) api_methods_counter_name_translation(L,c);
1138 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1139 }
1140 }
1141 return 1;
1142#ifndef TOLUA_RELEASE
1143 tolua_lerror:
1144 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
1145 return 0;
1146#endif
1147}
1148
1149/* function: api_methods_counter_city_get */
1150static int tolua_game_Counter_get00(lua_State* tolua_S)
1151{
1152#ifndef TOLUA_RELEASE
1153 tolua_Error tolua_err;
1154 if (
1155 !tolua_isusertype(tolua_S,1,"Counter",0,&tolua_err) ||
1156 !tolua_isusertype(tolua_S,2,"City",0,&tolua_err) ||
1157 !tolua_isnoobj(tolua_S,3,&tolua_err)
1158 )
1159 goto tolua_lerror;
1160 else
1161#endif
1162 {
1163 lua_State* L = tolua_S;
1164 Counter* c = ((Counter*) tolua_tousertype(tolua_S,1,0));
1165 City* city = ((City*) tolua_tousertype(tolua_S,2,0));
1166 {
1167 int tolua_ret = (int) api_methods_counter_city_get(L,c,city);
1168 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1169 }
1170 }
1171 return 1;
1172#ifndef TOLUA_RELEASE
1173 tolua_lerror:
1174 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
1175 return 0;
1176#endif
1177}
1178
1179/* function: api_methods_player_number */
1180static int tolua_game_Player_properties_id00(lua_State* tolua_S)
1181{
1182#ifndef TOLUA_RELEASE
1183 tolua_Error tolua_err;
1184 if (
1185 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1186 !tolua_isnoobj(tolua_S,2,&tolua_err)
1187 )
1188 goto tolua_lerror;
1189 else
1190#endif
1191 {
1192 lua_State* L = tolua_S;
1193 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1194 {
1195 int tolua_ret = (int) api_methods_player_number(L,self);
1196 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1197 }
1198 }
1199 return 1;
1200#ifndef TOLUA_RELEASE
1201 tolua_lerror:
1202 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
1203 return 0;
1204#endif
1205}
1206
1207/* function: api_methods_player_bulbs */
1208static int tolua_game_Player_properties_bulbs00(lua_State* tolua_S)
1209{
1210#ifndef TOLUA_RELEASE
1211 tolua_Error tolua_err;
1212 if (
1213 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1214 !tolua_isnoobj(tolua_S,2,&tolua_err)
1215 )
1216 goto tolua_lerror;
1217 else
1218#endif
1219 {
1220 lua_State* L = tolua_S;
1221 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1222 {
1223 int tolua_ret = (int) api_methods_player_bulbs(L,pplayer);
1224 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1225 }
1226 }
1227 return 1;
1228#ifndef TOLUA_RELEASE
1229 tolua_lerror:
1230 tolua_error(tolua_S,"#ferror in function 'bulbs'.",&tolua_err);
1231 return 0;
1232#endif
1233}
1234
1235/* function: api_methods_player_controlling_gui */
1236static int tolua_game_Player_controlling_gui00(lua_State* tolua_S)
1237{
1238#ifndef TOLUA_RELEASE
1239 tolua_Error tolua_err;
1240 if (
1241 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1242 !tolua_isnoobj(tolua_S,2,&tolua_err)
1243 )
1244 goto tolua_lerror;
1245 else
1246#endif
1247 {
1248 lua_State* L = tolua_S;
1249 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1250 {
1251 const char* tolua_ret = (const char*) api_methods_player_controlling_gui(L,self);
1252 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1253 }
1254 }
1255 return 1;
1256#ifndef TOLUA_RELEASE
1257 tolua_lerror:
1258 tolua_error(tolua_S,"#ferror in function 'controlling_gui'.",&tolua_err);
1259 return 0;
1260#endif
1261}
1262
1263/* function: api_methods_player_num_cities */
1264static int tolua_game_Player_num_cities00(lua_State* tolua_S)
1265{
1266#ifndef TOLUA_RELEASE
1267 tolua_Error tolua_err;
1268 if (
1269 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1270 !tolua_isnoobj(tolua_S,2,&tolua_err)
1271 )
1272 goto tolua_lerror;
1273 else
1274#endif
1275 {
1276 lua_State* L = tolua_S;
1277 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1278 {
1279 int tolua_ret = (int) api_methods_player_num_cities(L,self);
1280 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1281 }
1282 }
1283 return 1;
1284#ifndef TOLUA_RELEASE
1285 tolua_lerror:
1286 tolua_error(tolua_S,"#ferror in function 'num_cities'.",&tolua_err);
1287 return 0;
1288#endif
1289}
1290
1291/* function: api_methods_player_num_units */
1292static int tolua_game_Player_num_units00(lua_State* tolua_S)
1293{
1294#ifndef TOLUA_RELEASE
1295 tolua_Error tolua_err;
1296 if (
1297 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1298 !tolua_isnoobj(tolua_S,2,&tolua_err)
1299 )
1300 goto tolua_lerror;
1301 else
1302#endif
1303 {
1304 lua_State* L = tolua_S;
1305 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1306 {
1307 int tolua_ret = (int) api_methods_player_num_units(L,self);
1308 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1309 }
1310 }
1311 return 1;
1312#ifndef TOLUA_RELEASE
1313 tolua_lerror:
1314 tolua_error(tolua_S,"#ferror in function 'num_units'.",&tolua_err);
1315 return 0;
1316#endif
1317}
1318
1319/* function: api_methods_player_future */
1320static int tolua_game_Player_num_future_techs00(lua_State* tolua_S)
1321{
1322#ifndef TOLUA_RELEASE
1323 tolua_Error tolua_err;
1324 if (
1325 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1326 !tolua_isnoobj(tolua_S,2,&tolua_err)
1327 )
1328 goto tolua_lerror;
1329 else
1330#endif
1331 {
1332 lua_State* L = tolua_S;
1333 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1334 {
1335 int tolua_ret = (int) api_methods_player_future(L,pplayer);
1336 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1337 }
1338 }
1339 return 1;
1340#ifndef TOLUA_RELEASE
1341 tolua_lerror:
1342 tolua_error(tolua_S,"#ferror in function 'num_future_techs'.",&tolua_err);
1343 return 0;
1344#endif
1345}
1346
1347/* function: api_methods_player_has_wonder */
1348static int tolua_game_Player_has_wonder00(lua_State* tolua_S)
1349{
1350#ifndef TOLUA_RELEASE
1351 tolua_Error tolua_err;
1352 if (
1353 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1354 !tolua_isusertype(tolua_S,2,"Building_Type",0,&tolua_err) ||
1355 !tolua_isnoobj(tolua_S,3,&tolua_err)
1356 )
1357 goto tolua_lerror;
1358 else
1359#endif
1360 {
1361 lua_State* L = tolua_S;
1362 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1363 Building_Type* building = ((Building_Type*) tolua_tousertype(tolua_S,2,0));
1364 {
1365 bool tolua_ret = (bool) api_methods_player_has_wonder(L,self,building);
1366 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1367 }
1368 }
1369 return 1;
1370#ifndef TOLUA_RELEASE
1371 tolua_lerror:
1372 tolua_error(tolua_S,"#ferror in function 'has_wonder'.",&tolua_err);
1373 return 0;
1374#endif
1375}
1376
1377/* function: api_methods_player_gold */
1378static int tolua_game_Player_gold00(lua_State* tolua_S)
1379{
1380#ifndef TOLUA_RELEASE
1381 tolua_Error tolua_err;
1382 if (
1383 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1384 !tolua_isnoobj(tolua_S,2,&tolua_err)
1385 )
1386 goto tolua_lerror;
1387 else
1388#endif
1389 {
1390 lua_State* L = tolua_S;
1391 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1392 {
1393 int tolua_ret = (int) api_methods_player_gold(L,self);
1394 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1395 }
1396 }
1397 return 1;
1398#ifndef TOLUA_RELEASE
1399 tolua_lerror:
1400 tolua_error(tolua_S,"#ferror in function 'gold'.",&tolua_err);
1401 return 0;
1402#endif
1403}
1404
1405/* function: api_methods_player_infrapoints */
1406static int tolua_game_Player_infrapoints00(lua_State* tolua_S)
1407{
1408#ifndef TOLUA_RELEASE
1409 tolua_Error tolua_err;
1410 if (
1411 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1412 !tolua_isnoobj(tolua_S,2,&tolua_err)
1413 )
1414 goto tolua_lerror;
1415 else
1416#endif
1417 {
1418 lua_State* L = tolua_S;
1419 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1420 {
1421 int tolua_ret = (int) api_methods_player_infrapoints(L,self);
1422 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1423 }
1424 }
1425 return 1;
1426#ifndef TOLUA_RELEASE
1427 tolua_lerror:
1428 tolua_error(tolua_S,"#ferror in function 'infrapoints'.",&tolua_err);
1429 return 0;
1430#endif
1431}
1432
1433/* function: api_methods_player_knows_tech */
1434static int tolua_game_Player_knows_tech00(lua_State* tolua_S)
1435{
1436#ifndef TOLUA_RELEASE
1437 tolua_Error tolua_err;
1438 if (
1439 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1440 !tolua_isusertype(tolua_S,2,"Tech_Type",0,&tolua_err) ||
1441 !tolua_isnoobj(tolua_S,3,&tolua_err)
1442 )
1443 goto tolua_lerror;
1444 else
1445#endif
1446 {
1447 lua_State* L = tolua_S;
1448 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1449 Tech_Type* ptech = ((Tech_Type*) tolua_tousertype(tolua_S,2,0));
1450 {
1451 bool tolua_ret = (bool) api_methods_player_knows_tech(L,self,ptech);
1452 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1453 }
1454 }
1455 return 1;
1456#ifndef TOLUA_RELEASE
1457 tolua_lerror:
1458 tolua_error(tolua_S,"#ferror in function 'knows_tech'.",&tolua_err);
1459 return 0;
1460#endif
1461}
1462
1463/* function: api_method_player_can_research */
1464static int tolua_game_Player_can_research00(lua_State* tolua_S)
1465{
1466#ifndef TOLUA_RELEASE
1467 tolua_Error tolua_err;
1468 if (
1469 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1470 !tolua_isusertype(tolua_S,2,"Tech_Type",0,&tolua_err) ||
1471 !tolua_isnoobj(tolua_S,3,&tolua_err)
1472 )
1473 goto tolua_lerror;
1474 else
1475#endif
1476 {
1477 lua_State* L = tolua_S;
1478 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1479 Tech_Type* ptech = ((Tech_Type*) tolua_tousertype(tolua_S,2,0));
1480 {
1481 bool tolua_ret = (bool) api_method_player_can_research(L,pplayer,ptech);
1482 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1483 }
1484 }
1485 return 1;
1486#ifndef TOLUA_RELEASE
1487 tolua_lerror:
1488 tolua_error(tolua_S,"#ferror in function 'can_research'.",&tolua_err);
1489 return 0;
1490#endif
1491}
1492
1493/* function: api_methods_player_tech_cost */
1494static int tolua_game_Player_tech_cost00(lua_State* tolua_S)
1495{
1496#ifndef TOLUA_RELEASE
1497 tolua_Error tolua_err;
1498 if (
1499 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1500 !tolua_isusertype(tolua_S,2,"Tech_Type",0,&tolua_err) ||
1501 !tolua_isnoobj(tolua_S,3,&tolua_err)
1502 )
1503 goto tolua_lerror;
1504 else
1505#endif
1506 {
1507 lua_State* L = tolua_S;
1508 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1509 Tech_Type* ptech = ((Tech_Type*) tolua_tousertype(tolua_S,2,0));
1510 {
1511 int tolua_ret = (int) api_methods_player_tech_cost(L,pplayer,ptech);
1512 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1513 }
1514 }
1515 return 1;
1516#ifndef TOLUA_RELEASE
1517 tolua_lerror:
1518 tolua_error(tolua_S,"#ferror in function 'tech_cost'.",&tolua_err);
1519 return 0;
1520#endif
1521}
1522
1523/* function: api_methods_player_researching */
1524static int tolua_game_Player_researching00(lua_State* tolua_S)
1525{
1526#ifndef TOLUA_RELEASE
1527 tolua_Error tolua_err;
1528 if (
1529 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1530 !tolua_isnoobj(tolua_S,2,&tolua_err)
1531 )
1532 goto tolua_lerror;
1533 else
1534#endif
1535 {
1536 lua_State* L = tolua_S;
1537 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1538 {
1539 lua_Object tolua_ret = (lua_Object) api_methods_player_researching(L,pplayer);
1540 tolua_pushvalue(tolua_S,(int)tolua_ret);
1541 }
1542 }
1543 return 1;
1544#ifndef TOLUA_RELEASE
1545 tolua_lerror:
1546 tolua_error(tolua_S,"#ferror in function 'researching'.",&tolua_err);
1547 return 0;
1548#endif
1549}
1550
1551/* function: api_methods_player_research_cost */
1552static int tolua_game_Player_researching_cost00(lua_State* tolua_S)
1553{
1554#ifndef TOLUA_RELEASE
1555 tolua_Error tolua_err;
1556 if (
1557 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1558 !tolua_isnoobj(tolua_S,2,&tolua_err)
1559 )
1560 goto tolua_lerror;
1561 else
1562#endif
1563 {
1564 lua_State* L = tolua_S;
1565 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1566 {
1567 int tolua_ret = (int) api_methods_player_research_cost(L,pplayer);
1568 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1569 }
1570 }
1571 return 1;
1572#ifndef TOLUA_RELEASE
1573 tolua_lerror:
1574 tolua_error(tolua_S,"#ferror in function 'researching_cost'.",&tolua_err);
1575 return 0;
1576#endif
1577}
1578
1579/* function: api_methods_player_shares_research */
1580static int tolua_game_Player_shares_research00(lua_State* tolua_S)
1581{
1582#ifndef TOLUA_RELEASE
1583 tolua_Error tolua_err;
1584 if (
1585 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1586 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
1587 !tolua_isnoobj(tolua_S,3,&tolua_err)
1588 )
1589 goto tolua_lerror;
1590 else
1591#endif
1592 {
1593 lua_State* L = tolua_S;
1594 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1595 Player* other = ((Player*) tolua_tousertype(tolua_S,2,0));
1596 {
1597 bool tolua_ret = (bool) api_methods_player_shares_research(L,self,other);
1598 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1599 }
1600 }
1601 return 1;
1602#ifndef TOLUA_RELEASE
1603 tolua_lerror:
1604 tolua_error(tolua_S,"#ferror in function 'shares_research'.",&tolua_err);
1605 return 0;
1606#endif
1607}
1608
1609/* function: api_methods_research_rule_name */
1610static int tolua_game_Player_research_rule_name00(lua_State* tolua_S)
1611{
1612#ifndef TOLUA_RELEASE
1613 tolua_Error tolua_err;
1614 if (
1615 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1616 !tolua_isnoobj(tolua_S,2,&tolua_err)
1617 )
1618 goto tolua_lerror;
1619 else
1620#endif
1621 {
1622 lua_State* L = tolua_S;
1623 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1624 {
1625 const char* tolua_ret = (const char*) api_methods_research_rule_name(L,self);
1626 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1627 }
1628 }
1629 return 1;
1630#ifndef TOLUA_RELEASE
1631 tolua_lerror:
1632 tolua_error(tolua_S,"#ferror in function 'research_rule_name'.",&tolua_err);
1633 return 0;
1634#endif
1635}
1636
1637/* function: api_methods_research_name_translation */
1638static int tolua_game_Player_research_name_translation00(lua_State* tolua_S)
1639{
1640#ifndef TOLUA_RELEASE
1641 tolua_Error tolua_err;
1642 if (
1643 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1644 !tolua_isnoobj(tolua_S,2,&tolua_err)
1645 )
1646 goto tolua_lerror;
1647 else
1648#endif
1649 {
1650 lua_State* L = tolua_S;
1651 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1652 {
1653 const char* tolua_ret = (const char*) api_methods_research_name_translation(L,self);
1654 tolua_pushstring(tolua_S,(const char*)tolua_ret);
1655 }
1656 }
1657 return 1;
1658#ifndef TOLUA_RELEASE
1659 tolua_lerror:
1660 tolua_error(tolua_S,"#ferror in function 'research_name_translation'.",&tolua_err);
1661 return 0;
1662#endif
1663}
1664
1665/* function: api_methods_player_culture_get */
1666static int tolua_game_Player_culture00(lua_State* tolua_S)
1667{
1668#ifndef TOLUA_RELEASE
1669 tolua_Error tolua_err;
1670 if (
1671 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1672 !tolua_isnoobj(tolua_S,2,&tolua_err)
1673 )
1674 goto tolua_lerror;
1675 else
1676#endif
1677 {
1678 lua_State* L = tolua_S;
1679 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1680 {
1681 int tolua_ret = (int) api_methods_player_culture_get(L,self);
1682 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1683 }
1684 }
1685 return 1;
1686#ifndef TOLUA_RELEASE
1687 tolua_lerror:
1688 tolua_error(tolua_S,"#ferror in function 'culture'.",&tolua_err);
1689 return 0;
1690#endif
1691}
1692
1693/* function: api_methods_player_has_flag */
1694static int tolua_game_Player_has_flag00(lua_State* tolua_S)
1695{
1696#ifndef TOLUA_RELEASE
1697 tolua_Error tolua_err;
1698 if (
1699 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1700 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
1701 !tolua_isnoobj(tolua_S,3,&tolua_err)
1702 )
1703 goto tolua_lerror;
1704 else
1705#endif
1706 {
1707 lua_State* L = tolua_S;
1708 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1709 const char* flag = ((const char*) tolua_tostring(tolua_S,2,0));
1710 {
1711 bool tolua_ret = (bool) api_methods_player_has_flag(L,self,flag);
1712 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1713 }
1714 }
1715 return 1;
1716#ifndef TOLUA_RELEASE
1717 tolua_lerror:
1718 tolua_error(tolua_S,"#ferror in function 'has_flag'.",&tolua_err);
1719 return 0;
1720#endif
1721}
1722
1723/* function: api_methods_player_can_upgrade */
1724static int tolua_game_Player_can_upgrade00(lua_State* tolua_S)
1725{
1726#ifndef TOLUA_RELEASE
1727 tolua_Error tolua_err;
1728 if (
1729 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1730 !tolua_isusertype(tolua_S,2,"Unit_Type",0,&tolua_err) ||
1731 !tolua_isnoobj(tolua_S,3,&tolua_err)
1732 )
1733 goto tolua_lerror;
1734 else
1735#endif
1736 {
1737 lua_State* L = tolua_S;
1738 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1739 Unit_Type* utype = ((Unit_Type*) tolua_tousertype(tolua_S,2,0));
1740 {
1741 Unit_Type* tolua_ret = (Unit_Type*) api_methods_player_can_upgrade(L,pplayer,utype);
1742 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_Type");
1743 }
1744 }
1745 return 1;
1746#ifndef TOLUA_RELEASE
1747 tolua_lerror:
1748 tolua_error(tolua_S,"#ferror in function 'can_upgrade'.",&tolua_err);
1749 return 0;
1750#endif
1751}
1752
1753/* function: api_methods_player_can_build_impr_direct */
1754static int tolua_game_Player_can_build_direct00(lua_State* tolua_S)
1755{
1756#ifndef TOLUA_RELEASE
1757 tolua_Error tolua_err;
1758 if (
1759 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1760 !tolua_isusertype(tolua_S,2,"Building_Type",0,&tolua_err) ||
1761 !tolua_isnoobj(tolua_S,3,&tolua_err)
1762 )
1763 goto tolua_lerror;
1764 else
1765#endif
1766 {
1767 lua_State* L = tolua_S;
1768 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1769 Building_Type* itype = ((Building_Type*) tolua_tousertype(tolua_S,2,0));
1770 {
1771 bool tolua_ret = (bool) api_methods_player_can_build_impr_direct(L,pplayer,itype);
1772 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1773 }
1774 }
1775 return 1;
1776#ifndef TOLUA_RELEASE
1777 tolua_lerror:
1778 tolua_error(tolua_S,"#ferror in function 'can_build_direct'.",&tolua_err);
1779 return 0;
1780#endif
1781}
1782
1783/* function: api_methods_player_can_build_unit_direct */
1784static int tolua_game_Player_can_build_direct01(lua_State* tolua_S)
1785{
1786 tolua_Error tolua_err;
1787 if (
1788 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1789 !tolua_isusertype(tolua_S,2,"Unit_Type",0,&tolua_err) ||
1790 !tolua_isnoobj(tolua_S,3,&tolua_err)
1791 )
1792 goto tolua_lerror;
1793 else
1794 {
1795 lua_State* L = tolua_S;
1796 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1797 Unit_Type* utype = ((Unit_Type*) tolua_tousertype(tolua_S,2,0));
1798 {
1799 bool tolua_ret = (bool) api_methods_player_can_build_unit_direct(L,pplayer,utype);
1800 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1801 }
1802 }
1803 return 1;
1804tolua_lerror:
1805 return tolua_game_Player_can_build_direct00(tolua_S);
1806}
1807
1808/* function: api_methods_player_primary_capital */
1809static int tolua_game_Player_primary_capital00(lua_State* tolua_S)
1810{
1811#ifndef TOLUA_RELEASE
1812 tolua_Error tolua_err;
1813 if (
1814 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1815 !tolua_isnoobj(tolua_S,2,&tolua_err)
1816 )
1817 goto tolua_lerror;
1818 else
1819#endif
1820 {
1821 lua_State* L = tolua_S;
1822 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
1823 {
1824 City* tolua_ret = (City*) api_methods_player_primary_capital(L,pplayer);
1825 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City");
1826 }
1827 }
1828 return 1;
1829#ifndef TOLUA_RELEASE
1830 tolua_lerror:
1831 tolua_error(tolua_S,"#ferror in function 'primary_capital'.",&tolua_err);
1832 return 0;
1833#endif
1834}
1835
1836/* function: api_methods_private_list_players */
1837static int tolua_game_methods_private_list_players00(lua_State* tolua_S)
1838{
1839#ifndef TOLUA_RELEASE
1840 tolua_Error tolua_err;
1841 if (
1842 !tolua_isnoobj(tolua_S,1,&tolua_err)
1843 )
1844 goto tolua_lerror;
1845 else
1846#endif
1847 {
1848 lua_State* L = tolua_S;
1849 {
1850 lua_Object tolua_ret = (lua_Object) api_methods_private_list_players(L);
1851 tolua_pushvalue(tolua_S,(int)tolua_ret);
1852 }
1853 }
1854 return 1;
1855#ifndef TOLUA_RELEASE
1856 tolua_lerror:
1857 tolua_error(tolua_S,"#ferror in function 'list_players'.",&tolua_err);
1858 return 0;
1859#endif
1860}
1861
1862/* function: api_methods_private_player_unit_list_head */
1863static int tolua_game_methods_private_Player_unit_list_head00(lua_State* tolua_S)
1864{
1865#ifndef TOLUA_RELEASE
1866 tolua_Error tolua_err;
1867 if (
1868 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1869 !tolua_isnoobj(tolua_S,2,&tolua_err)
1870 )
1871 goto tolua_lerror;
1872 else
1873#endif
1874 {
1875 lua_State* L = tolua_S;
1876 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1877 {
1878 Unit_List_Link* tolua_ret = (Unit_List_Link*) api_methods_private_player_unit_list_head(L,self);
1879 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_List_Link");
1880 }
1881 }
1882 return 1;
1883#ifndef TOLUA_RELEASE
1884 tolua_lerror:
1885 tolua_error(tolua_S,"#ferror in function 'unit_list_head'.",&tolua_err);
1886 return 0;
1887#endif
1888}
1889
1890/* function: api_methods_private_player_city_list_head */
1891static int tolua_game_methods_private_Player_city_list_head00(lua_State* tolua_S)
1892{
1893#ifndef TOLUA_RELEASE
1894 tolua_Error tolua_err;
1895 if (
1896 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1897 !tolua_isnoobj(tolua_S,2,&tolua_err)
1898 )
1899 goto tolua_lerror;
1900 else
1901#endif
1902 {
1903 lua_State* L = tolua_S;
1904 Player* self = ((Player*) tolua_tousertype(tolua_S,1,0));
1905 {
1906 City_List_Link* tolua_ret = (City_List_Link*) api_methods_private_player_city_list_head(L,self);
1907 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City_List_Link");
1908 }
1909 }
1910 return 1;
1911#ifndef TOLUA_RELEASE
1912 tolua_lerror:
1913 tolua_error(tolua_S,"#ferror in function 'city_list_head'.",&tolua_err);
1914 return 0;
1915#endif
1916}
1917
1918/* function: api_methods_city_size_get */
1919static int tolua_game_City_properties_size00(lua_State* tolua_S)
1920{
1921#ifndef TOLUA_RELEASE
1922 tolua_Error tolua_err;
1923 if (
1924 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
1925 !tolua_isnoobj(tolua_S,2,&tolua_err)
1926 )
1927 goto tolua_lerror;
1928 else
1929#endif
1930 {
1931 lua_State* L = tolua_S;
1932 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
1933 {
1934 int tolua_ret = (int) api_methods_city_size_get(L,self);
1935 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
1936 }
1937 }
1938 return 1;
1939#ifndef TOLUA_RELEASE
1940 tolua_lerror:
1941 tolua_error(tolua_S,"#ferror in function 'size'.",&tolua_err);
1942 return 0;
1943#endif
1944}
1945
1946/* function: api_methods_city_tile_get */
1947static int tolua_game_City_properties_tile00(lua_State* tolua_S)
1948{
1949#ifndef TOLUA_RELEASE
1950 tolua_Error tolua_err;
1951 if (
1952 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
1953 !tolua_isnoobj(tolua_S,2,&tolua_err)
1954 )
1955 goto tolua_lerror;
1956 else
1957#endif
1958 {
1959 lua_State* L = tolua_S;
1960 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
1961 {
1962 Tile* tolua_ret = (Tile*) api_methods_city_tile_get(L,self);
1963 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
1964 }
1965 }
1966 return 1;
1967#ifndef TOLUA_RELEASE
1968 tolua_lerror:
1969 tolua_error(tolua_S,"#ferror in function 'tile'.",&tolua_err);
1970 return 0;
1971#endif
1972}
1973
1974/* function: api_methods_city_has_building */
1975static int tolua_game_City_has_building00(lua_State* tolua_S)
1976{
1977#ifndef TOLUA_RELEASE
1978 tolua_Error tolua_err;
1979 if (
1980 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
1981 !tolua_isusertype(tolua_S,2,"Building_Type",0,&tolua_err) ||
1982 !tolua_isnoobj(tolua_S,3,&tolua_err)
1983 )
1984 goto tolua_lerror;
1985 else
1986#endif
1987 {
1988 lua_State* L = tolua_S;
1989 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
1990 Building_Type* building = ((Building_Type*) tolua_tousertype(tolua_S,2,0));
1991 {
1992 bool tolua_ret = (bool) api_methods_city_has_building(L,self,building);
1993 tolua_pushboolean(tolua_S,(bool)tolua_ret);
1994 }
1995 }
1996 return 1;
1997#ifndef TOLUA_RELEASE
1998 tolua_lerror:
1999 tolua_error(tolua_S,"#ferror in function 'has_building'.",&tolua_err);
2000 return 0;
2001#endif
2002}
2003
2004/* function: api_methods_city_map_sq_radius */
2005static int tolua_game_City_map_sq_radius00(lua_State* tolua_S)
2006{
2007#ifndef TOLUA_RELEASE
2008 tolua_Error tolua_err;
2009 if (
2010 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2011 !tolua_isnoobj(tolua_S,2,&tolua_err)
2012 )
2013 goto tolua_lerror;
2014 else
2015#endif
2016 {
2017 lua_State* L = tolua_S;
2018 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2019 {
2020 int tolua_ret = (int) api_methods_city_map_sq_radius(L,self);
2021 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2022 }
2023 }
2024 return 1;
2025#ifndef TOLUA_RELEASE
2026 tolua_lerror:
2027 tolua_error(tolua_S,"#ferror in function 'map_sq_radius'.",&tolua_err);
2028 return 0;
2029#endif
2030}
2031
2032/* function: api_methods_city_inspire_partisans */
2033static int tolua_game_City_inspire_partisans00(lua_State* tolua_S)
2034{
2035#ifndef TOLUA_RELEASE
2036 tolua_Error tolua_err;
2037 if (
2038 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2039 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
2040 !tolua_isnoobj(tolua_S,3,&tolua_err)
2041 )
2042 goto tolua_lerror;
2043 else
2044#endif
2045 {
2046 lua_State* L = tolua_S;
2047 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2048 Player* inspirer = ((Player*) tolua_tousertype(tolua_S,2,0));
2049 {
2050 int tolua_ret = (int) api_methods_city_inspire_partisans(L,self,inspirer);
2051 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2052 }
2053 }
2054 return 1;
2055#ifndef TOLUA_RELEASE
2056 tolua_lerror:
2057 tolua_error(tolua_S,"#ferror in function 'inspire_partisans'.",&tolua_err);
2058 return 0;
2059#endif
2060}
2061
2062/* function: api_methods_city_culture_get */
2063static int tolua_game_City_culture00(lua_State* tolua_S)
2064{
2065#ifndef TOLUA_RELEASE
2066 tolua_Error tolua_err;
2067 if (
2068 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2069 !tolua_isnoobj(tolua_S,2,&tolua_err)
2070 )
2071 goto tolua_lerror;
2072 else
2073#endif
2074 {
2075 lua_State* L = tolua_S;
2076 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2077 {
2078 int tolua_ret = (int) api_methods_city_culture_get(L,self);
2079 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2080 }
2081 }
2082 return 1;
2083#ifndef TOLUA_RELEASE
2084 tolua_lerror:
2085 tolua_error(tolua_S,"#ferror in function 'culture'.",&tolua_err);
2086 return 0;
2087#endif
2088}
2089
2090/* function: api_methods_is_city_happy */
2091static int tolua_game_City_is_happy00(lua_State* tolua_S)
2092{
2093#ifndef TOLUA_RELEASE
2094 tolua_Error tolua_err;
2095 if (
2096 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2097 !tolua_isnoobj(tolua_S,2,&tolua_err)
2098 )
2099 goto tolua_lerror;
2100 else
2101#endif
2102 {
2103 lua_State* L = tolua_S;
2104 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2105 {
2106 bool tolua_ret = (bool) api_methods_is_city_happy(L,self);
2107 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2108 }
2109 }
2110 return 1;
2111#ifndef TOLUA_RELEASE
2112 tolua_lerror:
2113 tolua_error(tolua_S,"#ferror in function 'is_happy'.",&tolua_err);
2114 return 0;
2115#endif
2116}
2117
2118/* function: api_methods_is_city_unhappy */
2119static int tolua_game_City_is_unhappy00(lua_State* tolua_S)
2120{
2121#ifndef TOLUA_RELEASE
2122 tolua_Error tolua_err;
2123 if (
2124 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2125 !tolua_isnoobj(tolua_S,2,&tolua_err)
2126 )
2127 goto tolua_lerror;
2128 else
2129#endif
2130 {
2131 lua_State* L = tolua_S;
2132 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2133 {
2134 bool tolua_ret = (bool) api_methods_is_city_unhappy(L,self);
2135 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2136 }
2137 }
2138 return 1;
2139#ifndef TOLUA_RELEASE
2140 tolua_lerror:
2141 tolua_error(tolua_S,"#ferror in function 'is_unhappy'.",&tolua_err);
2142 return 0;
2143#endif
2144}
2145
2146/* function: api_methods_is_city_celebrating */
2147static int tolua_game_City_is_celebrating00(lua_State* tolua_S)
2148{
2149#ifndef TOLUA_RELEASE
2150 tolua_Error tolua_err;
2151 if (
2152 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2153 !tolua_isnoobj(tolua_S,2,&tolua_err)
2154 )
2155 goto tolua_lerror;
2156 else
2157#endif
2158 {
2159 lua_State* L = tolua_S;
2160 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2161 {
2162 bool tolua_ret = (bool) api_methods_is_city_celebrating(L,self);
2163 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2164 }
2165 }
2166 return 1;
2167#ifndef TOLUA_RELEASE
2168 tolua_lerror:
2169 tolua_error(tolua_S,"#ferror in function 'is_celebrating'.",&tolua_err);
2170 return 0;
2171#endif
2172}
2173
2174/* function: api_methods_is_gov_center */
2175static int tolua_game_City_is_gov_center00(lua_State* tolua_S)
2176{
2177#ifndef TOLUA_RELEASE
2178 tolua_Error tolua_err;
2179 if (
2180 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2181 !tolua_isnoobj(tolua_S,2,&tolua_err)
2182 )
2183 goto tolua_lerror;
2184 else
2185#endif
2186 {
2187 lua_State* L = tolua_S;
2188 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2189 {
2190 bool tolua_ret = (bool) api_methods_is_gov_center(L,self);
2191 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2192 }
2193 }
2194 return 1;
2195#ifndef TOLUA_RELEASE
2196 tolua_lerror:
2197 tolua_error(tolua_S,"#ferror in function 'is_gov_center'.",&tolua_err);
2198 return 0;
2199#endif
2200}
2201
2202/* function: api_methods_is_capital */
2203static int tolua_game_City_is_capital00(lua_State* tolua_S)
2204{
2205#ifndef TOLUA_RELEASE
2206 tolua_Error tolua_err;
2207 if (
2208 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2209 !tolua_isnoobj(tolua_S,2,&tolua_err)
2210 )
2211 goto tolua_lerror;
2212 else
2213#endif
2214 {
2215 lua_State* L = tolua_S;
2216 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2217 {
2218 bool tolua_ret = (bool) api_methods_is_capital(L,self);
2219 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2220 }
2221 }
2222 return 1;
2223#ifndef TOLUA_RELEASE
2224 tolua_lerror:
2225 tolua_error(tolua_S,"#ferror in function 'is_capital'.",&tolua_err);
2226 return 0;
2227#endif
2228}
2229
2230/* function: api_methods_is_primary_capital */
2231static int tolua_game_City_is_primary_capital00(lua_State* tolua_S)
2232{
2233#ifndef TOLUA_RELEASE
2234 tolua_Error tolua_err;
2235 if (
2236 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2237 !tolua_isnoobj(tolua_S,2,&tolua_err)
2238 )
2239 goto tolua_lerror;
2240 else
2241#endif
2242 {
2243 lua_State* L = tolua_S;
2244 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2245 {
2246 bool tolua_ret = (bool) api_methods_is_primary_capital(L,self);
2247 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2248 }
2249 }
2250 return 1;
2251#ifndef TOLUA_RELEASE
2252 tolua_lerror:
2253 tolua_error(tolua_S,"#ferror in function 'is_primary_capital'.",&tolua_err);
2254 return 0;
2255#endif
2256}
2257
2258/* function: api_methods_city_link */
2259static int tolua_game_City_link_text00(lua_State* tolua_S)
2260{
2261#ifndef TOLUA_RELEASE
2262 tolua_Error tolua_err;
2263 if (
2264 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2265 !tolua_isnoobj(tolua_S,2,&tolua_err)
2266 )
2267 goto tolua_lerror;
2268 else
2269#endif
2270 {
2271 lua_State* L = tolua_S;
2272 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2273 {
2274 const char* tolua_ret = (const char*) api_methods_city_link(L,self);
2275 tolua_pushstring(tolua_S,(const char*)tolua_ret);
2276 }
2277 }
2278 return 1;
2279#ifndef TOLUA_RELEASE
2280 tolua_lerror:
2281 tolua_error(tolua_S,"#ferror in function 'link_text'.",&tolua_err);
2282 return 0;
2283#endif
2284}
2285
2286/* function: api_methods_city_tile_link */
2287static int tolua_game_City_tile_link_text00(lua_State* tolua_S)
2288{
2289#ifndef TOLUA_RELEASE
2290 tolua_Error tolua_err;
2291 if (
2292 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2293 !tolua_isnoobj(tolua_S,2,&tolua_err)
2294 )
2295 goto tolua_lerror;
2296 else
2297#endif
2298 {
2299 lua_State* L = tolua_S;
2300 City* self = ((City*) tolua_tousertype(tolua_S,1,0));
2301 {
2302 const char* tolua_ret = (const char*) api_methods_city_tile_link(L,self);
2303 tolua_pushstring(tolua_S,(const char*)tolua_ret);
2304 }
2305 }
2306 return 1;
2307#ifndef TOLUA_RELEASE
2308 tolua_lerror:
2309 tolua_error(tolua_S,"#ferror in function 'tile_link_text'.",&tolua_err);
2310 return 0;
2311#endif
2312}
2313
2314/* function: api_methods_unit_tile_get */
2315static int tolua_game_Unit_properties_tile00(lua_State* tolua_S)
2316{
2317#ifndef TOLUA_RELEASE
2318 tolua_Error tolua_err;
2319 if (
2320 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2321 !tolua_isnoobj(tolua_S,2,&tolua_err)
2322 )
2323 goto tolua_lerror;
2324 else
2325#endif
2326 {
2327 lua_State* L = tolua_S;
2328 Unit* self = ((Unit*) tolua_tousertype(tolua_S,1,0));
2329 {
2330 Tile* tolua_ret = (Tile*) api_methods_unit_tile_get(L,self);
2331 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
2332 }
2333 }
2334 return 1;
2335#ifndef TOLUA_RELEASE
2336 tolua_lerror:
2337 tolua_error(tolua_S,"#ferror in function 'tile'.",&tolua_err);
2338 return 0;
2339#endif
2340}
2341
2342/* function: api_methods_unit_transporter */
2343static int tolua_game_Unit_transporter00(lua_State* tolua_S)
2344{
2345#ifndef TOLUA_RELEASE
2346 tolua_Error tolua_err;
2347 if (
2348 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2349 !tolua_isnoobj(tolua_S,2,&tolua_err)
2350 )
2351 goto tolua_lerror;
2352 else
2353#endif
2354 {
2355 lua_State* L = tolua_S;
2356 Unit* self = ((Unit*) tolua_tousertype(tolua_S,1,0));
2357 {
2358 Unit* tolua_ret = (Unit*) api_methods_unit_transporter(L,self);
2359 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit");
2360 }
2361 }
2362 return 1;
2363#ifndef TOLUA_RELEASE
2364 tolua_lerror:
2365 tolua_error(tolua_S,"#ferror in function 'transporter'.",&tolua_err);
2366 return 0;
2367#endif
2368}
2369
2370/* function: api_methods_unit_city_can_be_built_here */
2371static int tolua_game_Unit_is_on_possible_city_tile00(lua_State* tolua_S)
2372{
2373#ifndef TOLUA_RELEASE
2374 tolua_Error tolua_err;
2375 if (
2376 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2377 !tolua_isnoobj(tolua_S,2,&tolua_err)
2378 )
2379 goto tolua_lerror;
2380 else
2381#endif
2382 {
2383 lua_State* L = tolua_S;
2384 Unit* self = ((Unit*) tolua_tousertype(tolua_S,1,0));
2385 {
2386 bool tolua_ret = (bool) api_methods_unit_city_can_be_built_here(L,self);
2387 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2388 }
2389 }
2390 return 1;
2391#ifndef TOLUA_RELEASE
2392 tolua_lerror:
2393 tolua_error(tolua_S,"#ferror in function 'is_on_possible_city_tile'.",&tolua_err);
2394 return 0;
2395#endif
2396}
2397
2398/* function: api_methods_unit_can_upgrade */
2399static int tolua_game_Unit_can_upgrade00(lua_State* tolua_S)
2400{
2401#ifndef TOLUA_RELEASE
2402 tolua_Error tolua_err;
2403 if (
2404 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2405 !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
2406 !tolua_isnoobj(tolua_S,3,&tolua_err)
2407 )
2408 goto tolua_lerror;
2409 else
2410#endif
2411 {
2412 lua_State* L = tolua_S;
2413 Unit* punit = ((Unit*) tolua_tousertype(tolua_S,1,0));
2414 bool is_free = ((bool) tolua_toboolean(tolua_S,2,TRUE));
2415 {
2416 bool tolua_ret = (bool) api_methods_unit_can_upgrade(L,punit,is_free);
2417 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2418 }
2419 }
2420 return 1;
2421#ifndef TOLUA_RELEASE
2422 tolua_lerror:
2423 tolua_error(tolua_S,"#ferror in function 'can_upgrade'.",&tolua_err);
2424 return 0;
2425#endif
2426}
2427
2428/* function: api_methods_unit_transform_problem */
2429static int tolua_game_Unit_transform_problem00(lua_State* tolua_S)
2430{
2431#ifndef TOLUA_RELEASE
2432 tolua_Error tolua_err;
2433 if (
2434 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2435 !tolua_isusertype(tolua_S,2,"Unit_Type",0,&tolua_err) ||
2436 !tolua_isnoobj(tolua_S,3,&tolua_err)
2437 )
2438 goto tolua_lerror;
2439 else
2440#endif
2441 {
2442 lua_State* L = tolua_S;
2443 Unit* punit = ((Unit*) tolua_tousertype(tolua_S,1,0));
2444 Unit_Type* ptype = ((Unit_Type*) tolua_tousertype(tolua_S,2,0));
2445 {
2446 const char* tolua_ret = (const char*) api_methods_unit_transform_problem(L,punit,ptype);
2447 tolua_pushstring(tolua_S,(const char*)tolua_ret);
2448 }
2449 }
2450 return 1;
2451#ifndef TOLUA_RELEASE
2452 tolua_lerror:
2453 tolua_error(tolua_S,"#ferror in function 'transform_problem'.",&tolua_err);
2454 return 0;
2455#endif
2456}
2457
2458/* function: api_methods_unit_orientation_get */
2459static int tolua_game_Unit_facing00(lua_State* tolua_S)
2460{
2461#ifndef TOLUA_RELEASE
2462 tolua_Error tolua_err;
2463 if (
2464 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2465 !tolua_isnoobj(tolua_S,2,&tolua_err)
2466 )
2467 goto tolua_lerror;
2468 else
2469#endif
2470 {
2471 lua_State* L = tolua_S;
2472 Unit* self = ((Unit*) tolua_tousertype(tolua_S,1,0));
2473 {
2474 Direction* tolua_ret = (Direction*) api_methods_unit_orientation_get(L,self);
2475 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
2476 }
2477 }
2478 return 1;
2479#ifndef TOLUA_RELEASE
2480 tolua_lerror:
2481 tolua_error(tolua_S,"#ferror in function 'facing'.",&tolua_err);
2482 return 0;
2483#endif
2484}
2485
2486/* function: api_methods_unit_link */
2487static int tolua_game_Unit_link_text00(lua_State* tolua_S)
2488{
2489#ifndef TOLUA_RELEASE
2490 tolua_Error tolua_err;
2491 if (
2492 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2493 !tolua_isnoobj(tolua_S,2,&tolua_err)
2494 )
2495 goto tolua_lerror;
2496 else
2497#endif
2498 {
2499 lua_State* L = tolua_S;
2500 Unit* self = ((Unit*) tolua_tousertype(tolua_S,1,0));
2501 {
2502 const char* tolua_ret = (const char*) api_methods_unit_link(L,self);
2503 tolua_pushstring(tolua_S,(const char*)tolua_ret);
2504 }
2505 }
2506 return 1;
2507#ifndef TOLUA_RELEASE
2508 tolua_lerror:
2509 tolua_error(tolua_S,"#ferror in function 'link_text'.",&tolua_err);
2510 return 0;
2511#endif
2512}
2513
2514/* function: api_methods_unit_tile_link */
2515static int tolua_game_Unit_tile_link_text00(lua_State* tolua_S)
2516{
2517#ifndef TOLUA_RELEASE
2518 tolua_Error tolua_err;
2519 if (
2520 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2521 !tolua_isnoobj(tolua_S,2,&tolua_err)
2522 )
2523 goto tolua_lerror;
2524 else
2525#endif
2526 {
2527 lua_State* L = tolua_S;
2528 Unit* self = ((Unit*) tolua_tousertype(tolua_S,1,0));
2529 {
2530 const char* tolua_ret = (const char*) api_methods_unit_tile_link(L,self);
2531 tolua_pushstring(tolua_S,(const char*)tolua_ret);
2532 }
2533 }
2534 return 1;
2535#ifndef TOLUA_RELEASE
2536 tolua_lerror:
2537 tolua_error(tolua_S,"#ferror in function 'tile_link_text'.",&tolua_err);
2538 return 0;
2539#endif
2540}
2541
2542/* function: api_methods_unit_seen */
2543static int tolua_game_Unit_seen00(lua_State* tolua_S)
2544{
2545#ifndef TOLUA_RELEASE
2546 tolua_Error tolua_err;
2547 if (
2548 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2549 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
2550 !tolua_isnoobj(tolua_S,3,&tolua_err)
2551 )
2552 goto tolua_lerror;
2553 else
2554#endif
2555 {
2556 lua_State* L = tolua_S;
2557 Unit* self = ((Unit*) tolua_tousertype(tolua_S,1,0));
2558 Player* watcher = ((Player*) tolua_tousertype(tolua_S,2,0));
2559 {
2560 bool tolua_ret = (bool) api_methods_unit_seen(L,self,watcher);
2561 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2562 }
2563 }
2564 return 1;
2565#ifndef TOLUA_RELEASE
2566 tolua_lerror:
2567 tolua_error(tolua_S,"#ferror in function 'seen'.",&tolua_err);
2568 return 0;
2569#endif
2570}
2571
2572/* function: api_methods_private_unit_cargo_list_head */
2573static int tolua_game_methods_private_Unit_cargo_list_head00(lua_State* tolua_S)
2574{
2575#ifndef TOLUA_RELEASE
2576 tolua_Error tolua_err;
2577 if (
2578 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2579 !tolua_isnoobj(tolua_S,2,&tolua_err)
2580 )
2581 goto tolua_lerror;
2582 else
2583#endif
2584 {
2585 lua_State* L = tolua_S;
2586 Unit* self = ((Unit*) tolua_tousertype(tolua_S,1,0));
2587 {
2588 Unit_List_Link* tolua_ret = (Unit_List_Link*) api_methods_private_unit_cargo_list_head(L,self);
2589 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_List_Link");
2590 }
2591 }
2592 return 1;
2593#ifndef TOLUA_RELEASE
2594 tolua_lerror:
2595 tolua_error(tolua_S,"#ferror in function 'cargo_list_head'.",&tolua_err);
2596 return 0;
2597#endif
2598}
2599
2600/* function: api_methods_tile_nat_x */
2601static int tolua_game_Tile_properties_nat_x00(lua_State* tolua_S)
2602{
2603#ifndef TOLUA_RELEASE
2604 tolua_Error tolua_err;
2605 if (
2606 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2607 !tolua_isnoobj(tolua_S,2,&tolua_err)
2608 )
2609 goto tolua_lerror;
2610 else
2611#endif
2612 {
2613 lua_State* L = tolua_S;
2614 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2615 {
2616 int tolua_ret = (int) api_methods_tile_nat_x(L,self);
2617 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2618 }
2619 }
2620 return 1;
2621#ifndef TOLUA_RELEASE
2622 tolua_lerror:
2623 tolua_error(tolua_S,"#ferror in function 'nat_x'.",&tolua_err);
2624 return 0;
2625#endif
2626}
2627
2628/* function: api_methods_tile_nat_y */
2629static int tolua_game_Tile_properties_nat_y00(lua_State* tolua_S)
2630{
2631#ifndef TOLUA_RELEASE
2632 tolua_Error tolua_err;
2633 if (
2634 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2635 !tolua_isnoobj(tolua_S,2,&tolua_err)
2636 )
2637 goto tolua_lerror;
2638 else
2639#endif
2640 {
2641 lua_State* L = tolua_S;
2642 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2643 {
2644 int tolua_ret = (int) api_methods_tile_nat_y(L,self);
2645 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2646 }
2647 }
2648 return 1;
2649#ifndef TOLUA_RELEASE
2650 tolua_lerror:
2651 tolua_error(tolua_S,"#ferror in function 'nat_y'.",&tolua_err);
2652 return 0;
2653#endif
2654}
2655
2656/* function: api_methods_tile_map_x */
2657static int tolua_game_Tile_properties_x00(lua_State* tolua_S)
2658{
2659#ifndef TOLUA_RELEASE
2660 tolua_Error tolua_err;
2661 if (
2662 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2663 !tolua_isnoobj(tolua_S,2,&tolua_err)
2664 )
2665 goto tolua_lerror;
2666 else
2667#endif
2668 {
2669 lua_State* L = tolua_S;
2670 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2671 {
2672 int tolua_ret = (int) api_methods_tile_map_x(L,self);
2673 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2674 }
2675 }
2676 return 1;
2677#ifndef TOLUA_RELEASE
2678 tolua_lerror:
2679 tolua_error(tolua_S,"#ferror in function 'x'.",&tolua_err);
2680 return 0;
2681#endif
2682}
2683
2684/* function: api_methods_tile_map_y */
2685static int tolua_game_Tile_properties_y00(lua_State* tolua_S)
2686{
2687#ifndef TOLUA_RELEASE
2688 tolua_Error tolua_err;
2689 if (
2690 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2691 !tolua_isnoobj(tolua_S,2,&tolua_err)
2692 )
2693 goto tolua_lerror;
2694 else
2695#endif
2696 {
2697 lua_State* L = tolua_S;
2698 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2699 {
2700 int tolua_ret = (int) api_methods_tile_map_y(L,self);
2701 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2702 }
2703 }
2704 return 1;
2705#ifndef TOLUA_RELEASE
2706 tolua_lerror:
2707 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
2708 return 0;
2709#endif
2710}
2711
2712/* function: api_methods_tile_city */
2713static int tolua_game_Tile_city00(lua_State* tolua_S)
2714{
2715#ifndef TOLUA_RELEASE
2716 tolua_Error tolua_err;
2717 if (
2718 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2719 !tolua_isnoobj(tolua_S,2,&tolua_err)
2720 )
2721 goto tolua_lerror;
2722 else
2723#endif
2724 {
2725 lua_State* L = tolua_S;
2726 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2727 {
2728 City* tolua_ret = (City*) api_methods_tile_city(L,self);
2729 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City");
2730 }
2731 }
2732 return 1;
2733#ifndef TOLUA_RELEASE
2734 tolua_lerror:
2735 tolua_error(tolua_S,"#ferror in function 'city'.",&tolua_err);
2736 return 0;
2737#endif
2738}
2739
2740/* function: api_methods_tile_city_exists_within_max_city_map */
2741static int tolua_game_Tile_city_exists_within_max_city_map00(lua_State* tolua_S)
2742{
2743#ifndef TOLUA_RELEASE
2744 tolua_Error tolua_err;
2745 if (
2746 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2747 !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
2748 !tolua_isnoobj(tolua_S,3,&tolua_err)
2749 )
2750 goto tolua_lerror;
2751 else
2752#endif
2753 {
2754 lua_State* L = tolua_S;
2755 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2756 bool center = ((bool) tolua_toboolean(tolua_S,2,0));
2757 {
2758 bool tolua_ret = (bool) api_methods_tile_city_exists_within_max_city_map(L,self,center);
2759 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2760 }
2761 }
2762 return 1;
2763#ifndef TOLUA_RELEASE
2764 tolua_lerror:
2765 tolua_error(tolua_S,"#ferror in function 'city_exists_within_max_city_map'.",&tolua_err);
2766 return 0;
2767#endif
2768}
2769
2770/* function: api_methods_tile_has_extra */
2771static int tolua_game_Tile_has_extra00(lua_State* tolua_S)
2772{
2773#ifndef TOLUA_RELEASE
2774 tolua_Error tolua_err;
2775 if (
2776 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2777 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2778 !tolua_isnoobj(tolua_S,3,&tolua_err)
2779 )
2780 goto tolua_lerror;
2781 else
2782#endif
2783 {
2784 lua_State* L = tolua_S;
2785 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2786 const char* name = ((const char*) tolua_tostring(tolua_S,2,0));
2787 {
2788 bool tolua_ret = (bool) api_methods_tile_has_extra(L,self,name);
2789 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2790 }
2791 }
2792 return 1;
2793#ifndef TOLUA_RELEASE
2794 tolua_lerror:
2795 tolua_error(tolua_S,"#ferror in function 'has_extra'.",&tolua_err);
2796 return 0;
2797#endif
2798}
2799
2800/* function: api_methods_tile_has_base */
2801static int tolua_game_Tile_has_base00(lua_State* tolua_S)
2802{
2803#ifndef TOLUA_RELEASE
2804 tolua_Error tolua_err;
2805 if (
2806 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2807 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2808 !tolua_isnoobj(tolua_S,3,&tolua_err)
2809 )
2810 goto tolua_lerror;
2811 else
2812#endif
2813 {
2814 lua_State* L = tolua_S;
2815 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2816 const char* name = ((const char*) tolua_tostring(tolua_S,2,0));
2817 {
2818 bool tolua_ret = (bool) api_methods_tile_has_base(L,self,name);
2819 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2820 }
2821 }
2822 return 1;
2823#ifndef TOLUA_RELEASE
2824 tolua_lerror:
2825 tolua_error(tolua_S,"#ferror in function 'has_base'.",&tolua_err);
2826 return 0;
2827#endif
2828}
2829
2830/* function: api_methods_tile_has_road */
2831static int tolua_game_Tile_has_road00(lua_State* tolua_S)
2832{
2833#ifndef TOLUA_RELEASE
2834 tolua_Error tolua_err;
2835 if (
2836 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2837 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2838 !tolua_isnoobj(tolua_S,3,&tolua_err)
2839 )
2840 goto tolua_lerror;
2841 else
2842#endif
2843 {
2844 lua_State* L = tolua_S;
2845 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2846 const char* name = ((const char*) tolua_tostring(tolua_S,2,0));
2847 {
2848 bool tolua_ret = (bool) api_methods_tile_has_road(L,self,name);
2849 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2850 }
2851 }
2852 return 1;
2853#ifndef TOLUA_RELEASE
2854 tolua_lerror:
2855 tolua_error(tolua_S,"#ferror in function 'has_road'.",&tolua_err);
2856 return 0;
2857#endif
2858}
2859
2860/* function: api_methods_tile_extra_owner */
2861static int tolua_game_Tile_extra_owner00(lua_State* tolua_S)
2862{
2863#ifndef TOLUA_RELEASE
2864 tolua_Error tolua_err;
2865 if (
2866 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2867 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
2868 !tolua_isnoobj(tolua_S,3,&tolua_err)
2869 )
2870 goto tolua_lerror;
2871 else
2872#endif
2873 {
2874 lua_State* L = tolua_S;
2875 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2876 const char* extra_name = ((const char*) tolua_tostring(tolua_S,2,0));
2877 {
2878 Player* tolua_ret = (Player*) api_methods_tile_extra_owner(L,self,extra_name);
2879 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Player");
2880 }
2881 }
2882 return 1;
2883#ifndef TOLUA_RELEASE
2884 tolua_lerror:
2885 tolua_error(tolua_S,"#ferror in function 'extra_owner'.",&tolua_err);
2886 return 0;
2887#endif
2888}
2889
2890/* function: api_methods_enemy_tile */
2891static int tolua_game_Tile_is_enemy00(lua_State* tolua_S)
2892{
2893#ifndef TOLUA_RELEASE
2894 tolua_Error tolua_err;
2895 if (
2896 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2897 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
2898 !tolua_isnoobj(tolua_S,3,&tolua_err)
2899 )
2900 goto tolua_lerror;
2901 else
2902#endif
2903 {
2904 lua_State* L = tolua_S;
2905 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2906 Player* against = ((Player*) tolua_tousertype(tolua_S,2,0));
2907 {
2908 bool tolua_ret = (bool) api_methods_enemy_tile(L,self,against);
2909 tolua_pushboolean(tolua_S,(bool)tolua_ret);
2910 }
2911 }
2912 return 1;
2913#ifndef TOLUA_RELEASE
2914 tolua_lerror:
2915 tolua_error(tolua_S,"#ferror in function 'is_enemy'.",&tolua_err);
2916 return 0;
2917#endif
2918}
2919
2920/* function: api_methods_tile_num_units */
2921static int tolua_game_Tile_num_units00(lua_State* tolua_S)
2922{
2923#ifndef TOLUA_RELEASE
2924 tolua_Error tolua_err;
2925 if (
2926 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2927 !tolua_isnoobj(tolua_S,2,&tolua_err)
2928 )
2929 goto tolua_lerror;
2930 else
2931#endif
2932 {
2933 lua_State* L = tolua_S;
2934 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2935 {
2936 int tolua_ret = (int) api_methods_tile_num_units(L,self);
2937 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2938 }
2939 }
2940 return 1;
2941#ifndef TOLUA_RELEASE
2942 tolua_lerror:
2943 tolua_error(tolua_S,"#ferror in function 'num_units'.",&tolua_err);
2944 return 0;
2945#endif
2946}
2947
2948/* function: api_methods_tile_sq_distance */
2949static int tolua_game_Tile_sq_distance00(lua_State* tolua_S)
2950{
2951#ifndef TOLUA_RELEASE
2952 tolua_Error tolua_err;
2953 if (
2954 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2955 !tolua_isusertype(tolua_S,2,"Tile",0,&tolua_err) ||
2956 !tolua_isnoobj(tolua_S,3,&tolua_err)
2957 )
2958 goto tolua_lerror;
2959 else
2960#endif
2961 {
2962 lua_State* L = tolua_S;
2963 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2964 Tile* other = ((Tile*) tolua_tousertype(tolua_S,2,0));
2965 {
2966 int tolua_ret = (int) api_methods_tile_sq_distance(L,self,other);
2967 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
2968 }
2969 }
2970 return 1;
2971#ifndef TOLUA_RELEASE
2972 tolua_lerror:
2973 tolua_error(tolua_S,"#ferror in function 'sq_distance'.",&tolua_err);
2974 return 0;
2975#endif
2976}
2977
2978/* function: api_methods_tile_link */
2979static int tolua_game_Tile_link_text00(lua_State* tolua_S)
2980{
2981#ifndef TOLUA_RELEASE
2982 tolua_Error tolua_err;
2983 if (
2984 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
2985 !tolua_isnoobj(tolua_S,2,&tolua_err)
2986 )
2987 goto tolua_lerror;
2988 else
2989#endif
2990 {
2991 lua_State* L = tolua_S;
2992 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
2993 {
2994 const char* tolua_ret = (const char*) api_methods_tile_link(L,self);
2995 tolua_pushstring(tolua_S,(const char*)tolua_ret);
2996 }
2997 }
2998 return 1;
2999#ifndef TOLUA_RELEASE
3000 tolua_lerror:
3001 tolua_error(tolua_S,"#ferror in function 'link_text'.",&tolua_err);
3002 return 0;
3003#endif
3004}
3005
3006/* function: api_methods_tile_known */
3007static int tolua_game_Tile_known00(lua_State* tolua_S)
3008{
3009#ifndef TOLUA_RELEASE
3010 tolua_Error tolua_err;
3011 if (
3012 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3013 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
3014 !tolua_isnoobj(tolua_S,3,&tolua_err)
3015 )
3016 goto tolua_lerror;
3017 else
3018#endif
3019 {
3020 lua_State* L = tolua_S;
3021 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3022 Player* watcher = ((Player*) tolua_tousertype(tolua_S,2,0));
3023 {
3024 bool tolua_ret = (bool) api_methods_tile_known(L,self,watcher);
3025 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3026 }
3027 }
3028 return 1;
3029#ifndef TOLUA_RELEASE
3030 tolua_lerror:
3031 tolua_error(tolua_S,"#ferror in function 'known'.",&tolua_err);
3032 return 0;
3033#endif
3034}
3035
3036/* function: api_methods_tile_seen */
3037static int tolua_game_Tile_seen00(lua_State* tolua_S)
3038{
3039#ifndef TOLUA_RELEASE
3040 tolua_Error tolua_err;
3041 if (
3042 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3043 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
3044 !tolua_isnoobj(tolua_S,3,&tolua_err)
3045 )
3046 goto tolua_lerror;
3047 else
3048#endif
3049 {
3050 lua_State* L = tolua_S;
3051 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3052 Player* watcher = ((Player*) tolua_tousertype(tolua_S,2,0));
3053 {
3054 bool tolua_ret = (bool) api_methods_tile_seen(L,self,watcher);
3055 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3056 }
3057 }
3058 return 1;
3059#ifndef TOLUA_RELEASE
3060 tolua_lerror:
3061 tolua_error(tolua_S,"#ferror in function 'seen'.",&tolua_err);
3062 return 0;
3063#endif
3064}
3065
3066/* function: api_methods_private_tile_next_outward_index */
3067static int tolua_game_methods_private_Tile_next_outward_index00(lua_State* tolua_S)
3068{
3069#ifndef TOLUA_RELEASE
3070 tolua_Error tolua_err;
3071 if (
3072 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3073 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3074 !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
3075 !tolua_isnoobj(tolua_S,4,&tolua_err)
3076 )
3077 goto tolua_lerror;
3078 else
3079#endif
3080 {
3081 lua_State* L = tolua_S;
3082 Tile* pcenter = ((Tile*) tolua_tousertype(tolua_S,1,0));
3083 int tindex = ((int) tolua_tonumber(tolua_S,2,0));
3084 int max_dist = ((int) tolua_tonumber(tolua_S,3,0));
3085 {
3086 int tolua_ret = (int) api_methods_private_tile_next_outward_index(L,pcenter,tindex,max_dist);
3087 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
3088 }
3089 }
3090 return 1;
3091#ifndef TOLUA_RELEASE
3092 tolua_lerror:
3093 tolua_error(tolua_S,"#ferror in function 'next_outward_index'.",&tolua_err);
3094 return 0;
3095#endif
3096}
3097
3098/* function: api_methods_private_tile_for_outward_index */
3099static int tolua_game_methods_private_Tile_tile_for_outward_index00(lua_State* tolua_S)
3100{
3101#ifndef TOLUA_RELEASE
3102 tolua_Error tolua_err;
3103 if (
3104 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3105 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
3106 !tolua_isnoobj(tolua_S,3,&tolua_err)
3107 )
3108 goto tolua_lerror;
3109 else
3110#endif
3111 {
3112 lua_State* L = tolua_S;
3113 Tile* pcenter = ((Tile*) tolua_tousertype(tolua_S,1,0));
3114 int tindex = ((int) tolua_tonumber(tolua_S,2,0));
3115 {
3116 Tile* tolua_ret = (Tile*) api_methods_private_tile_for_outward_index(L,pcenter,tindex);
3117 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
3118 }
3119 }
3120 return 1;
3121#ifndef TOLUA_RELEASE
3122 tolua_lerror:
3123 tolua_error(tolua_S,"#ferror in function 'tile_for_outward_index'.",&tolua_err);
3124 return 0;
3125#endif
3126}
3127
3128/* function: api_methods_private_tile_unit_list_head */
3129static int tolua_game_methods_private_Tile_unit_list_head00(lua_State* tolua_S)
3130{
3131#ifndef TOLUA_RELEASE
3132 tolua_Error tolua_err;
3133 if (
3134 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3135 !tolua_isnoobj(tolua_S,2,&tolua_err)
3136 )
3137 goto tolua_lerror;
3138 else
3139#endif
3140 {
3141 lua_State* L = tolua_S;
3142 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3143 {
3144 Unit_List_Link* tolua_ret = (Unit_List_Link*) api_methods_private_tile_unit_list_head(L,self);
3145 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_List_Link");
3146 }
3147 }
3148 return 1;
3149#ifndef TOLUA_RELEASE
3150 tolua_lerror:
3151 tolua_error(tolua_S,"#ferror in function 'unit_list_head'.",&tolua_err);
3152 return 0;
3153#endif
3154}
3155
3156/* function: api_methods_government_rule_name */
3157static int tolua_game_Government_rule_name00(lua_State* tolua_S)
3158{
3159#ifndef TOLUA_RELEASE
3160 tolua_Error tolua_err;
3161 if (
3162 !tolua_isusertype(tolua_S,1,"Government",0,&tolua_err) ||
3163 !tolua_isnoobj(tolua_S,2,&tolua_err)
3164 )
3165 goto tolua_lerror;
3166 else
3167#endif
3168 {
3169 lua_State* L = tolua_S;
3170 Government* self = ((Government*) tolua_tousertype(tolua_S,1,0));
3171 {
3172 const char* tolua_ret = (const char*) api_methods_government_rule_name(L,self);
3173 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3174 }
3175 }
3176 return 1;
3177#ifndef TOLUA_RELEASE
3178 tolua_lerror:
3179 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3180 return 0;
3181#endif
3182}
3183
3184/* function: api_methods_government_name_translation */
3185static int tolua_game_Government_name_translation00(lua_State* tolua_S)
3186{
3187#ifndef TOLUA_RELEASE
3188 tolua_Error tolua_err;
3189 if (
3190 !tolua_isusertype(tolua_S,1,"Government",0,&tolua_err) ||
3191 !tolua_isnoobj(tolua_S,2,&tolua_err)
3192 )
3193 goto tolua_lerror;
3194 else
3195#endif
3196 {
3197 lua_State* L = tolua_S;
3198 Government* self = ((Government*) tolua_tousertype(tolua_S,1,0));
3199 {
3200 const char* tolua_ret = (const char*) api_methods_government_name_translation(L,self);
3201 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3202 }
3203 }
3204 return 1;
3205#ifndef TOLUA_RELEASE
3206 tolua_lerror:
3207 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3208 return 0;
3209#endif
3210}
3211
3212/* function: api_methods_nation_type_rule_name */
3213static int tolua_game_Nation_Type_rule_name00(lua_State* tolua_S)
3214{
3215#ifndef TOLUA_RELEASE
3216 tolua_Error tolua_err;
3217 if (
3218 !tolua_isusertype(tolua_S,1,"Nation_Type",0,&tolua_err) ||
3219 !tolua_isnoobj(tolua_S,2,&tolua_err)
3220 )
3221 goto tolua_lerror;
3222 else
3223#endif
3224 {
3225 lua_State* L = tolua_S;
3226 Nation_Type* self = ((Nation_Type*) tolua_tousertype(tolua_S,1,0));
3227 {
3228 const char* tolua_ret = (const char*) api_methods_nation_type_rule_name(L,self);
3229 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3230 }
3231 }
3232 return 1;
3233#ifndef TOLUA_RELEASE
3234 tolua_lerror:
3235 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3236 return 0;
3237#endif
3238}
3239
3240/* function: api_methods_nation_type_name_translation */
3241static int tolua_game_Nation_Type_name_translation00(lua_State* tolua_S)
3242{
3243#ifndef TOLUA_RELEASE
3244 tolua_Error tolua_err;
3245 if (
3246 !tolua_isusertype(tolua_S,1,"Nation_Type",0,&tolua_err) ||
3247 !tolua_isnoobj(tolua_S,2,&tolua_err)
3248 )
3249 goto tolua_lerror;
3250 else
3251#endif
3252 {
3253 lua_State* L = tolua_S;
3254 Nation_Type* self = ((Nation_Type*) tolua_tousertype(tolua_S,1,0));
3255 {
3256 const char* tolua_ret = (const char*) api_methods_nation_type_name_translation(L,self);
3257 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3258 }
3259 }
3260 return 1;
3261#ifndef TOLUA_RELEASE
3262 tolua_lerror:
3263 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3264 return 0;
3265#endif
3266}
3267
3268/* function: api_methods_nation_type_plural_translation */
3269static int tolua_game_Nation_Type_plural_translation00(lua_State* tolua_S)
3270{
3271#ifndef TOLUA_RELEASE
3272 tolua_Error tolua_err;
3273 if (
3274 !tolua_isusertype(tolua_S,1,"Nation_Type",0,&tolua_err) ||
3275 !tolua_isnoobj(tolua_S,2,&tolua_err)
3276 )
3277 goto tolua_lerror;
3278 else
3279#endif
3280 {
3281 lua_State* L = tolua_S;
3282 Nation_Type* self = ((Nation_Type*) tolua_tousertype(tolua_S,1,0));
3283 {
3284 const char* tolua_ret = (const char*) api_methods_nation_type_plural_translation(L,self);
3285 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3286 }
3287 }
3288 return 1;
3289#ifndef TOLUA_RELEASE
3290 tolua_lerror:
3291 tolua_error(tolua_S,"#ferror in function 'plural_translation'.",&tolua_err);
3292 return 0;
3293#endif
3294}
3295
3296/* function: api_methods_building_type_is_wonder */
3297static int tolua_game_Building_Type_is_wonder00(lua_State* tolua_S)
3298{
3299#ifndef TOLUA_RELEASE
3300 tolua_Error tolua_err;
3301 if (
3302 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3303 !tolua_isnoobj(tolua_S,2,&tolua_err)
3304 )
3305 goto tolua_lerror;
3306 else
3307#endif
3308 {
3309 lua_State* L = tolua_S;
3310 Building_Type* self = ((Building_Type*) tolua_tousertype(tolua_S,1,0));
3311 {
3312 bool tolua_ret = (bool) api_methods_building_type_is_wonder(L,self);
3313 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3314 }
3315 }
3316 return 1;
3317#ifndef TOLUA_RELEASE
3318 tolua_lerror:
3319 tolua_error(tolua_S,"#ferror in function 'is_wonder'.",&tolua_err);
3320 return 0;
3321#endif
3322}
3323
3324/* function: api_methods_building_type_is_great_wonder */
3325static int tolua_game_Building_Type_is_great_wonder00(lua_State* tolua_S)
3326{
3327#ifndef TOLUA_RELEASE
3328 tolua_Error tolua_err;
3329 if (
3330 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3331 !tolua_isnoobj(tolua_S,2,&tolua_err)
3332 )
3333 goto tolua_lerror;
3334 else
3335#endif
3336 {
3337 lua_State* L = tolua_S;
3338 Building_Type* self = ((Building_Type*) tolua_tousertype(tolua_S,1,0));
3339 {
3340 bool tolua_ret = (bool) api_methods_building_type_is_great_wonder(L,self);
3341 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3342 }
3343 }
3344 return 1;
3345#ifndef TOLUA_RELEASE
3346 tolua_lerror:
3347 tolua_error(tolua_S,"#ferror in function 'is_great_wonder'.",&tolua_err);
3348 return 0;
3349#endif
3350}
3351
3352/* function: api_methods_building_type_is_small_wonder */
3353static int tolua_game_Building_Type_is_small_wonder00(lua_State* tolua_S)
3354{
3355#ifndef TOLUA_RELEASE
3356 tolua_Error tolua_err;
3357 if (
3358 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3359 !tolua_isnoobj(tolua_S,2,&tolua_err)
3360 )
3361 goto tolua_lerror;
3362 else
3363#endif
3364 {
3365 lua_State* L = tolua_S;
3366 Building_Type* self = ((Building_Type*) tolua_tousertype(tolua_S,1,0));
3367 {
3368 bool tolua_ret = (bool) api_methods_building_type_is_small_wonder(L,self);
3369 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3370 }
3371 }
3372 return 1;
3373#ifndef TOLUA_RELEASE
3374 tolua_lerror:
3375 tolua_error(tolua_S,"#ferror in function 'is_small_wonder'.",&tolua_err);
3376 return 0;
3377#endif
3378}
3379
3380/* function: api_methods_building_type_is_improvement */
3381static int tolua_game_Building_Type_is_improvement00(lua_State* tolua_S)
3382{
3383#ifndef TOLUA_RELEASE
3384 tolua_Error tolua_err;
3385 if (
3386 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3387 !tolua_isnoobj(tolua_S,2,&tolua_err)
3388 )
3389 goto tolua_lerror;
3390 else
3391#endif
3392 {
3393 lua_State* L = tolua_S;
3394 Building_Type* self = ((Building_Type*) tolua_tousertype(tolua_S,1,0));
3395 {
3396 bool tolua_ret = (bool) api_methods_building_type_is_improvement(L,self);
3397 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3398 }
3399 }
3400 return 1;
3401#ifndef TOLUA_RELEASE
3402 tolua_lerror:
3403 tolua_error(tolua_S,"#ferror in function 'is_improvement'.",&tolua_err);
3404 return 0;
3405#endif
3406}
3407
3408/* function: api_methods_building_type_rule_name */
3409static int tolua_game_Building_Type_rule_name00(lua_State* tolua_S)
3410{
3411#ifndef TOLUA_RELEASE
3412 tolua_Error tolua_err;
3413 if (
3414 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3415 !tolua_isnoobj(tolua_S,2,&tolua_err)
3416 )
3417 goto tolua_lerror;
3418 else
3419#endif
3420 {
3421 lua_State* L = tolua_S;
3422 Building_Type* self = ((Building_Type*) tolua_tousertype(tolua_S,1,0));
3423 {
3424 const char* tolua_ret = (const char*) api_methods_building_type_rule_name(L,self);
3425 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3426 }
3427 }
3428 return 1;
3429#ifndef TOLUA_RELEASE
3430 tolua_lerror:
3431 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3432 return 0;
3433#endif
3434}
3435
3436/* function: api_methods_building_type_name_translation */
3437static int tolua_game_Building_Type_name_translation00(lua_State* tolua_S)
3438{
3439#ifndef TOLUA_RELEASE
3440 tolua_Error tolua_err;
3441 if (
3442 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3443 !tolua_isnoobj(tolua_S,2,&tolua_err)
3444 )
3445 goto tolua_lerror;
3446 else
3447#endif
3448 {
3449 lua_State* L = tolua_S;
3450 Building_Type* self = ((Building_Type*) tolua_tousertype(tolua_S,1,0));
3451 {
3452 const char* tolua_ret = (const char*) api_methods_building_type_name_translation(L,self);
3453 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3454 }
3455 }
3456 return 1;
3457#ifndef TOLUA_RELEASE
3458 tolua_lerror:
3459 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3460 return 0;
3461#endif
3462}
3463
3464/* function: api_methods_unit_type_has_flag */
3465static int tolua_game_Unit_Type_has_flag00(lua_State* tolua_S)
3466{
3467#ifndef TOLUA_RELEASE
3468 tolua_Error tolua_err;
3469 if (
3470 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3471 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
3472 !tolua_isnoobj(tolua_S,3,&tolua_err)
3473 )
3474 goto tolua_lerror;
3475 else
3476#endif
3477 {
3478 lua_State* L = tolua_S;
3479 Unit_Type* self = ((Unit_Type*) tolua_tousertype(tolua_S,1,0));
3480 const char* flag = ((const char*) tolua_tostring(tolua_S,2,0));
3481 {
3482 bool tolua_ret = (bool) api_methods_unit_type_has_flag(L,self,flag);
3483 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3484 }
3485 }
3486 return 1;
3487#ifndef TOLUA_RELEASE
3488 tolua_lerror:
3489 tolua_error(tolua_S,"#ferror in function 'has_flag'.",&tolua_err);
3490 return 0;
3491#endif
3492}
3493
3494/* function: api_methods_unit_type_has_role */
3495static int tolua_game_Unit_Type_has_role00(lua_State* tolua_S)
3496{
3497#ifndef TOLUA_RELEASE
3498 tolua_Error tolua_err;
3499 if (
3500 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3501 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
3502 !tolua_isnoobj(tolua_S,3,&tolua_err)
3503 )
3504 goto tolua_lerror;
3505 else
3506#endif
3507 {
3508 lua_State* L = tolua_S;
3509 Unit_Type* self = ((Unit_Type*) tolua_tousertype(tolua_S,1,0));
3510 const char* role = ((const char*) tolua_tostring(tolua_S,2,0));
3511 {
3512 bool tolua_ret = (bool) api_methods_unit_type_has_role(L,self,role);
3513 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3514 }
3515 }
3516 return 1;
3517#ifndef TOLUA_RELEASE
3518 tolua_lerror:
3519 tolua_error(tolua_S,"#ferror in function 'has_role'.",&tolua_err);
3520 return 0;
3521#endif
3522}
3523
3524/* function: api_methods_unit_type_rule_name */
3525static int tolua_game_Unit_Type_rule_name00(lua_State* tolua_S)
3526{
3527#ifndef TOLUA_RELEASE
3528 tolua_Error tolua_err;
3529 if (
3530 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3531 !tolua_isnoobj(tolua_S,2,&tolua_err)
3532 )
3533 goto tolua_lerror;
3534 else
3535#endif
3536 {
3537 lua_State* L = tolua_S;
3538 Unit_Type* self = ((Unit_Type*) tolua_tousertype(tolua_S,1,0));
3539 {
3540 const char* tolua_ret = (const char*) api_methods_unit_type_rule_name(L,self);
3541 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3542 }
3543 }
3544 return 1;
3545#ifndef TOLUA_RELEASE
3546 tolua_lerror:
3547 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3548 return 0;
3549#endif
3550}
3551
3552/* function: api_methods_unit_type_name_translation */
3553static int tolua_game_Unit_Type_name_translation00(lua_State* tolua_S)
3554{
3555#ifndef TOLUA_RELEASE
3556 tolua_Error tolua_err;
3557 if (
3558 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3559 !tolua_isnoobj(tolua_S,2,&tolua_err)
3560 )
3561 goto tolua_lerror;
3562 else
3563#endif
3564 {
3565 lua_State* L = tolua_S;
3566 Unit_Type* self = ((Unit_Type*) tolua_tousertype(tolua_S,1,0));
3567 {
3568 const char* tolua_ret = (const char*) api_methods_unit_type_name_translation(L,self);
3569 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3570 }
3571 }
3572 return 1;
3573#ifndef TOLUA_RELEASE
3574 tolua_lerror:
3575 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3576 return 0;
3577#endif
3578}
3579
3580/* function: api_methods_unit_type_can_exist_at_tile */
3581static int tolua_game_Unit_Type_can_exist_at_tile00(lua_State* tolua_S)
3582{
3583#ifndef TOLUA_RELEASE
3584 tolua_Error tolua_err;
3585 if (
3586 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3587 !tolua_isusertype(tolua_S,2,"Tile",0,&tolua_err) ||
3588 !tolua_isnoobj(tolua_S,3,&tolua_err)
3589 )
3590 goto tolua_lerror;
3591 else
3592#endif
3593 {
3594 lua_State* L = tolua_S;
3595 Unit_Type* self = ((Unit_Type*) tolua_tousertype(tolua_S,1,0));
3596 Tile* ptile = ((Tile*) tolua_tousertype(tolua_S,2,0));
3597 {
3598 bool tolua_ret = (bool) api_methods_unit_type_can_exist_at_tile(L,self,ptile);
3599 tolua_pushboolean(tolua_S,(bool)tolua_ret);
3600 }
3601 }
3602 return 1;
3603#ifndef TOLUA_RELEASE
3604 tolua_lerror:
3605 tolua_error(tolua_S,"#ferror in function 'can_exist_at_tile'.",&tolua_err);
3606 return 0;
3607#endif
3608}
3609
3610/* function: api_methods_tech_type_rule_name */
3611static int tolua_game_Tech_Type_rule_name00(lua_State* tolua_S)
3612{
3613#ifndef TOLUA_RELEASE
3614 tolua_Error tolua_err;
3615 if (
3616 !tolua_isusertype(tolua_S,1,"Tech_Type",0,&tolua_err) ||
3617 !tolua_isnoobj(tolua_S,2,&tolua_err)
3618 )
3619 goto tolua_lerror;
3620 else
3621#endif
3622 {
3623 lua_State* L = tolua_S;
3624 Tech_Type* self = ((Tech_Type*) tolua_tousertype(tolua_S,1,0));
3625 {
3626 const char* tolua_ret = (const char*) api_methods_tech_type_rule_name(L,self);
3627 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3628 }
3629 }
3630 return 1;
3631#ifndef TOLUA_RELEASE
3632 tolua_lerror:
3633 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3634 return 0;
3635#endif
3636}
3637
3638/* function: api_methods_tech_type_name_translation */
3639static int tolua_game_Tech_Type_name_translation00(lua_State* tolua_S)
3640{
3641#ifndef TOLUA_RELEASE
3642 tolua_Error tolua_err;
3643 if (
3644 !tolua_isusertype(tolua_S,1,"Tech_Type",0,&tolua_err) ||
3645 !tolua_isnoobj(tolua_S,2,&tolua_err)
3646 )
3647 goto tolua_lerror;
3648 else
3649#endif
3650 {
3651 lua_State* L = tolua_S;
3652 Tech_Type* self = ((Tech_Type*) tolua_tousertype(tolua_S,1,0));
3653 {
3654 const char* tolua_ret = (const char*) api_methods_tech_type_name_translation(L,self);
3655 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3656 }
3657 }
3658 return 1;
3659#ifndef TOLUA_RELEASE
3660 tolua_lerror:
3661 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3662 return 0;
3663#endif
3664}
3665
3666/* function: api_methods_terrain_rule_name */
3667static int tolua_game_Terrain_rule_name00(lua_State* tolua_S)
3668{
3669#ifndef TOLUA_RELEASE
3670 tolua_Error tolua_err;
3671 if (
3672 !tolua_isusertype(tolua_S,1,"Terrain",0,&tolua_err) ||
3673 !tolua_isnoobj(tolua_S,2,&tolua_err)
3674 )
3675 goto tolua_lerror;
3676 else
3677#endif
3678 {
3679 lua_State* L = tolua_S;
3680 Terrain* self = ((Terrain*) tolua_tousertype(tolua_S,1,0));
3681 {
3682 const char* tolua_ret = (const char*) api_methods_terrain_rule_name(L,self);
3683 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3684 }
3685 }
3686 return 1;
3687#ifndef TOLUA_RELEASE
3688 tolua_lerror:
3689 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3690 return 0;
3691#endif
3692}
3693
3694/* function: api_methods_terrain_name_translation */
3695static int tolua_game_Terrain_name_translation00(lua_State* tolua_S)
3696{
3697#ifndef TOLUA_RELEASE
3698 tolua_Error tolua_err;
3699 if (
3700 !tolua_isusertype(tolua_S,1,"Terrain",0,&tolua_err) ||
3701 !tolua_isnoobj(tolua_S,2,&tolua_err)
3702 )
3703 goto tolua_lerror;
3704 else
3705#endif
3706 {
3707 lua_State* L = tolua_S;
3708 Terrain* self = ((Terrain*) tolua_tousertype(tolua_S,1,0));
3709 {
3710 const char* tolua_ret = (const char*) api_methods_terrain_name_translation(L,self);
3711 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3712 }
3713 }
3714 return 1;
3715#ifndef TOLUA_RELEASE
3716 tolua_lerror:
3717 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3718 return 0;
3719#endif
3720}
3721
3722/* function: api_methods_terrain_class_name */
3723static int tolua_game_Terrain_class_name00(lua_State* tolua_S)
3724{
3725#ifndef TOLUA_RELEASE
3726 tolua_Error tolua_err;
3727 if (
3728 !tolua_isusertype(tolua_S,1,"Terrain",0,&tolua_err) ||
3729 !tolua_isnoobj(tolua_S,2,&tolua_err)
3730 )
3731 goto tolua_lerror;
3732 else
3733#endif
3734 {
3735 lua_State* L = tolua_S;
3736 Terrain* self = ((Terrain*) tolua_tousertype(tolua_S,1,0));
3737 {
3738 const char* tolua_ret = (const char*) api_methods_terrain_class_name(L,self);
3739 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3740 }
3741 }
3742 return 1;
3743#ifndef TOLUA_RELEASE
3744 tolua_lerror:
3745 tolua_error(tolua_S,"#ferror in function 'class_name'.",&tolua_err);
3746 return 0;
3747#endif
3748}
3749
3750/* function: api_methods_disaster_rule_name */
3751static int tolua_game_Disaster_rule_name00(lua_State* tolua_S)
3752{
3753#ifndef TOLUA_RELEASE
3754 tolua_Error tolua_err;
3755 if (
3756 !tolua_isusertype(tolua_S,1,"Disaster",0,&tolua_err) ||
3757 !tolua_isnoobj(tolua_S,2,&tolua_err)
3758 )
3759 goto tolua_lerror;
3760 else
3761#endif
3762 {
3763 lua_State* L = tolua_S;
3764 Disaster* self = ((Disaster*) tolua_tousertype(tolua_S,1,0));
3765 {
3766 const char* tolua_ret = (const char*) api_methods_disaster_rule_name(L,self);
3767 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3768 }
3769 }
3770 return 1;
3771#ifndef TOLUA_RELEASE
3772 tolua_lerror:
3773 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3774 return 0;
3775#endif
3776}
3777
3778/* function: api_methods_disaster_name_translation */
3779static int tolua_game_Disaster_name_translation00(lua_State* tolua_S)
3780{
3781#ifndef TOLUA_RELEASE
3782 tolua_Error tolua_err;
3783 if (
3784 !tolua_isusertype(tolua_S,1,"Disaster",0,&tolua_err) ||
3785 !tolua_isnoobj(tolua_S,2,&tolua_err)
3786 )
3787 goto tolua_lerror;
3788 else
3789#endif
3790 {
3791 lua_State* L = tolua_S;
3792 Disaster* self = ((Disaster*) tolua_tousertype(tolua_S,1,0));
3793 {
3794 const char* tolua_ret = (const char*) api_methods_disaster_name_translation(L,self);
3795 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3796 }
3797 }
3798 return 1;
3799#ifndef TOLUA_RELEASE
3800 tolua_lerror:
3801 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3802 return 0;
3803#endif
3804}
3805
3806/* function: api_methods_achievement_rule_name */
3807static int tolua_game_Achievement_rule_name00(lua_State* tolua_S)
3808{
3809#ifndef TOLUA_RELEASE
3810 tolua_Error tolua_err;
3811 if (
3812 !tolua_isusertype(tolua_S,1,"Achievement",0,&tolua_err) ||
3813 !tolua_isnoobj(tolua_S,2,&tolua_err)
3814 )
3815 goto tolua_lerror;
3816 else
3817#endif
3818 {
3819 lua_State* L = tolua_S;
3820 Achievement* self = ((Achievement*) tolua_tousertype(tolua_S,1,0));
3821 {
3822 const char* tolua_ret = (const char*) api_methods_achievement_rule_name(L,self);
3823 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3824 }
3825 }
3826 return 1;
3827#ifndef TOLUA_RELEASE
3828 tolua_lerror:
3829 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3830 return 0;
3831#endif
3832}
3833
3834/* function: api_methods_achievement_name_translation */
3835static int tolua_game_Achievement_name_translation00(lua_State* tolua_S)
3836{
3837#ifndef TOLUA_RELEASE
3838 tolua_Error tolua_err;
3839 if (
3840 !tolua_isusertype(tolua_S,1,"Achievement",0,&tolua_err) ||
3841 !tolua_isnoobj(tolua_S,2,&tolua_err)
3842 )
3843 goto tolua_lerror;
3844 else
3845#endif
3846 {
3847 lua_State* L = tolua_S;
3848 Achievement* self = ((Achievement*) tolua_tousertype(tolua_S,1,0));
3849 {
3850 const char* tolua_ret = (const char*) api_methods_achievement_name_translation(L,self);
3851 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3852 }
3853 }
3854 return 1;
3855#ifndef TOLUA_RELEASE
3856 tolua_lerror:
3857 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3858 return 0;
3859#endif
3860}
3861
3862/* function: api_methods_action_rule_name */
3863static int tolua_game_Action_rule_name00(lua_State* tolua_S)
3864{
3865#ifndef TOLUA_RELEASE
3866 tolua_Error tolua_err;
3867 if (
3868 !tolua_isusertype(tolua_S,1,"Action",0,&tolua_err) ||
3869 !tolua_isnoobj(tolua_S,2,&tolua_err)
3870 )
3871 goto tolua_lerror;
3872 else
3873#endif
3874 {
3875 lua_State* L = tolua_S;
3876 Action* self = ((Action*) tolua_tousertype(tolua_S,1,0));
3877 {
3878 const char* tolua_ret = (const char*) api_methods_action_rule_name(L,self);
3879 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3880 }
3881 }
3882 return 1;
3883#ifndef TOLUA_RELEASE
3884 tolua_lerror:
3885 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3886 return 0;
3887#endif
3888}
3889
3890/* function: api_methods_action_name_translation */
3891static int tolua_game_Action_name_translation00(lua_State* tolua_S)
3892{
3893#ifndef TOLUA_RELEASE
3894 tolua_Error tolua_err;
3895 if (
3896 !tolua_isusertype(tolua_S,1,"Action",0,&tolua_err) ||
3897 !tolua_isnoobj(tolua_S,2,&tolua_err)
3898 )
3899 goto tolua_lerror;
3900 else
3901#endif
3902 {
3903 lua_State* L = tolua_S;
3904 Action* self = ((Action*) tolua_tousertype(tolua_S,1,0));
3905 {
3906 const char* tolua_ret = (const char*) api_methods_action_name_translation(L,self);
3907 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3908 }
3909 }
3910 return 1;
3911#ifndef TOLUA_RELEASE
3912 tolua_lerror:
3913 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3914 return 0;
3915#endif
3916}
3917
3918/* function: api_methods_action_target_kind */
3919static int tolua_game_Action_target_kind00(lua_State* tolua_S)
3920{
3921#ifndef TOLUA_RELEASE
3922 tolua_Error tolua_err;
3923 if (
3924 !tolua_isusertype(tolua_S,1,"Action",0,&tolua_err) ||
3925 !tolua_isnoobj(tolua_S,2,&tolua_err)
3926 )
3927 goto tolua_lerror;
3928 else
3929#endif
3930 {
3931 lua_State* L = tolua_S;
3932 Action* self = ((Action*) tolua_tousertype(tolua_S,1,0));
3933 {
3934 const char* tolua_ret = (const char*) api_methods_action_target_kind(L,self);
3935 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3936 }
3937 }
3938 return 1;
3939#ifndef TOLUA_RELEASE
3940 tolua_lerror:
3941 tolua_error(tolua_S,"#ferror in function 'target_kind'.",&tolua_err);
3942 return 0;
3943#endif
3944}
3945
3946/* function: api_methods_unit_list_link_data */
3947static int tolua_game_Unit_List_Link_data00(lua_State* tolua_S)
3948{
3949#ifndef TOLUA_RELEASE
3950 tolua_Error tolua_err;
3951 if (
3952 !tolua_isusertype(tolua_S,1,"Unit_List_Link",0,&tolua_err) ||
3953 !tolua_isnoobj(tolua_S,2,&tolua_err)
3954 )
3955 goto tolua_lerror;
3956 else
3957#endif
3958 {
3959 lua_State* L = tolua_S;
3960 Unit_List_Link* self = ((Unit_List_Link*) tolua_tousertype(tolua_S,1,0));
3961 {
3962 Unit* tolua_ret = (Unit*) api_methods_unit_list_link_data(L,self);
3963 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit");
3964 }
3965 }
3966 return 1;
3967#ifndef TOLUA_RELEASE
3968 tolua_lerror:
3969 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
3970 return 0;
3971#endif
3972}
3973
3974/* function: api_methods_unit_list_next_link */
3975static int tolua_game_Unit_List_Link_next00(lua_State* tolua_S)
3976{
3977#ifndef TOLUA_RELEASE
3978 tolua_Error tolua_err;
3979 if (
3980 !tolua_isusertype(tolua_S,1,"Unit_List_Link",0,&tolua_err) ||
3981 !tolua_isnoobj(tolua_S,2,&tolua_err)
3982 )
3983 goto tolua_lerror;
3984 else
3985#endif
3986 {
3987 lua_State* L = tolua_S;
3988 Unit_List_Link* self = ((Unit_List_Link*) tolua_tousertype(tolua_S,1,0));
3989 {
3990 Unit_List_Link* tolua_ret = (Unit_List_Link*) api_methods_unit_list_next_link(L,self);
3991 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_List_Link");
3992 }
3993 }
3994 return 1;
3995#ifndef TOLUA_RELEASE
3996 tolua_lerror:
3997 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
3998 return 0;
3999#endif
4000}
4001
4002/* function: api_methods_city_list_link_data */
4003static int tolua_game_City_List_Link_data00(lua_State* tolua_S)
4004{
4005#ifndef TOLUA_RELEASE
4006 tolua_Error tolua_err;
4007 if (
4008 !tolua_isusertype(tolua_S,1,"City_List_Link",0,&tolua_err) ||
4009 !tolua_isnoobj(tolua_S,2,&tolua_err)
4010 )
4011 goto tolua_lerror;
4012 else
4013#endif
4014 {
4015 lua_State* L = tolua_S;
4016 City_List_Link* self = ((City_List_Link*) tolua_tousertype(tolua_S,1,0));
4017 {
4018 City* tolua_ret = (City*) api_methods_city_list_link_data(L,self);
4019 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City");
4020 }
4021 }
4022 return 1;
4023#ifndef TOLUA_RELEASE
4024 tolua_lerror:
4025 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
4026 return 0;
4027#endif
4028}
4029
4030/* function: api_methods_city_list_next_link */
4031static int tolua_game_City_List_Link_next00(lua_State* tolua_S)
4032{
4033#ifndef TOLUA_RELEASE
4034 tolua_Error tolua_err;
4035 if (
4036 !tolua_isusertype(tolua_S,1,"City_List_Link",0,&tolua_err) ||
4037 !tolua_isnoobj(tolua_S,2,&tolua_err)
4038 )
4039 goto tolua_lerror;
4040 else
4041#endif
4042 {
4043 lua_State* L = tolua_S;
4044 City_List_Link* self = ((City_List_Link*) tolua_tousertype(tolua_S,1,0));
4045 {
4046 City_List_Link* tolua_ret = (City_List_Link*) api_methods_city_list_next_link(L,self);
4047 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City_List_Link");
4048 }
4049 }
4050 return 1;
4051#ifndef TOLUA_RELEASE
4052 tolua_lerror:
4053 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
4054 return 0;
4055#endif
4056}
4057
4058/* function: api_find_counter_by_name */
4059static int tolua_game_find_counter00(lua_State* tolua_S)
4060{
4061#ifndef TOLUA_RELEASE
4062 tolua_Error tolua_err;
4063 if (
4064 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4065 !tolua_isnoobj(tolua_S,2,&tolua_err)
4066 )
4067 goto tolua_lerror;
4068 else
4069#endif
4070 {
4071 lua_State* L = tolua_S;
4072 const char* name = ((const char*) tolua_tostring(tolua_S,1,0));
4073 {
4074 Counter* tolua_ret = (Counter*) api_find_counter_by_name(L,name);
4075 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Counter");
4076 }
4077 }
4078 return 1;
4079#ifndef TOLUA_RELEASE
4080 tolua_lerror:
4081 tolua_error(tolua_S,"#ferror in function 'counter'.",&tolua_err);
4082 return 0;
4083#endif
4084}
4085
4086/* function: api_find_counter */
4087static int tolua_game_find_counter01(lua_State* tolua_S)
4088{
4089 tolua_Error tolua_err;
4090 if (
4091 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4092 !tolua_isnoobj(tolua_S,2,&tolua_err)
4093 )
4094 goto tolua_lerror;
4095 else
4096 {
4097 lua_State* L = tolua_S;
4098 int counter_id = ((int) tolua_tonumber(tolua_S,1,0));
4099 {
4100 Counter* tolua_ret = (Counter*) api_find_counter(L,counter_id);
4101 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Counter");
4102 }
4103 }
4104 return 1;
4105tolua_lerror:
4106 return tolua_game_find_counter00(tolua_S);
4107}
4108
4109/* function: api_find_player_by_name */
4110static int tolua_game_find_player00(lua_State* tolua_S)
4111{
4112#ifndef TOLUA_RELEASE
4113 tolua_Error tolua_err;
4114 if (
4115 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4116 !tolua_isnoobj(tolua_S,2,&tolua_err)
4117 )
4118 goto tolua_lerror;
4119 else
4120#endif
4121 {
4122 lua_State* L = tolua_S;
4123 const char* name = ((const char*) tolua_tostring(tolua_S,1,0));
4124 {
4125 Player* tolua_ret = (Player*) api_find_player_by_name(L,name);
4126 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Player");
4127 }
4128 }
4129 return 1;
4130#ifndef TOLUA_RELEASE
4131 tolua_lerror:
4132 tolua_error(tolua_S,"#ferror in function 'player'.",&tolua_err);
4133 return 0;
4134#endif
4135}
4136
4137/* function: api_find_player */
4138static int tolua_game_find_player01(lua_State* tolua_S)
4139{
4140 tolua_Error tolua_err;
4141 if (
4142 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4143 !tolua_isnoobj(tolua_S,2,&tolua_err)
4144 )
4145 goto tolua_lerror;
4146 else
4147 {
4148 lua_State* L = tolua_S;
4149 int player_id = ((int) tolua_tonumber(tolua_S,1,0));
4150 {
4151 Player* tolua_ret = (Player*) api_find_player(L,player_id);
4152 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Player");
4153 }
4154 }
4155 return 1;
4156tolua_lerror:
4157 return tolua_game_find_player00(tolua_S);
4158}
4159
4160/* function: api_find_city */
4161static int tolua_game_find_city00(lua_State* tolua_S)
4162{
4163#ifndef TOLUA_RELEASE
4164 tolua_Error tolua_err;
4165 if (
4166 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
4167 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4168 !tolua_isnoobj(tolua_S,3,&tolua_err)
4169 )
4170 goto tolua_lerror;
4171 else
4172#endif
4173 {
4174 lua_State* L = tolua_S;
4175 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
4176 int city_id = ((int) tolua_tonumber(tolua_S,2,0));
4177 {
4178 City* tolua_ret = (City*) api_find_city(L,pplayer,city_id);
4179 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City");
4180 }
4181 }
4182 return 1;
4183#ifndef TOLUA_RELEASE
4184 tolua_lerror:
4185 tolua_error(tolua_S,"#ferror in function 'city'.",&tolua_err);
4186 return 0;
4187#endif
4188}
4189
4190/* function: api_find_unit */
4191static int tolua_game_find_unit00(lua_State* tolua_S)
4192{
4193#ifndef TOLUA_RELEASE
4194 tolua_Error tolua_err;
4195 if (
4196 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
4197 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4198 !tolua_isnoobj(tolua_S,3,&tolua_err)
4199 )
4200 goto tolua_lerror;
4201 else
4202#endif
4203 {
4204 lua_State* L = tolua_S;
4205 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
4206 int unit_id = ((int) tolua_tonumber(tolua_S,2,0));
4207 {
4208 Unit* tolua_ret = (Unit*) api_find_unit(L,pplayer,unit_id);
4209 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit");
4210 }
4211 }
4212 return 1;
4213#ifndef TOLUA_RELEASE
4214 tolua_lerror:
4215 tolua_error(tolua_S,"#ferror in function 'unit'.",&tolua_err);
4216 return 0;
4217#endif
4218}
4219
4220/* function: api_find_transport_unit */
4221static int tolua_game_find_transport_unit00(lua_State* tolua_S)
4222{
4223#ifndef TOLUA_RELEASE
4224 tolua_Error tolua_err;
4225 if (
4226 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
4227 !tolua_isusertype(tolua_S,2,"Unit_Type",0,&tolua_err) ||
4228 !tolua_isusertype(tolua_S,3,"Tile",0,&tolua_err) ||
4229 !tolua_isnoobj(tolua_S,4,&tolua_err)
4230 )
4231 goto tolua_lerror;
4232 else
4233#endif
4234 {
4235 lua_State* L = tolua_S;
4236 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
4237 Unit_Type* ptype = ((Unit_Type*) tolua_tousertype(tolua_S,2,0));
4238 Tile* ptile = ((Tile*) tolua_tousertype(tolua_S,3,0));
4239 {
4240 Unit* tolua_ret = (Unit*) api_find_transport_unit(L,pplayer,ptype,ptile);
4241 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit");
4242 }
4243 }
4244 return 1;
4245#ifndef TOLUA_RELEASE
4246 tolua_lerror:
4247 tolua_error(tolua_S,"#ferror in function 'transport_unit'.",&tolua_err);
4248 return 0;
4249#endif
4250}
4251
4252/* function: api_find_tile */
4253static int tolua_game_find_tile00(lua_State* tolua_S)
4254{
4255#ifndef TOLUA_RELEASE
4256 tolua_Error tolua_err;
4257 if (
4258 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4259 !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
4260 !tolua_isnoobj(tolua_S,3,&tolua_err)
4261 )
4262 goto tolua_lerror;
4263 else
4264#endif
4265 {
4266 lua_State* L = tolua_S;
4267 int nat_x = ((int) tolua_tonumber(tolua_S,1,0));
4268 int nat_y = ((int) tolua_tonumber(tolua_S,2,0));
4269 {
4270 Tile* tolua_ret = (Tile*) api_find_tile(L,nat_x,nat_y);
4271 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
4272 }
4273 }
4274 return 1;
4275#ifndef TOLUA_RELEASE
4276 tolua_lerror:
4277 tolua_error(tolua_S,"#ferror in function 'tile'.",&tolua_err);
4278 return 0;
4279#endif
4280}
4281
4282/* function: api_find_tile_by_index */
4283static int tolua_game_find_tile01(lua_State* tolua_S)
4284{
4285 tolua_Error tolua_err;
4286 if (
4287 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4288 !tolua_isnoobj(tolua_S,2,&tolua_err)
4289 )
4290 goto tolua_lerror;
4291 else
4292 {
4293 lua_State* L = tolua_S;
4294 int tindex = ((int) tolua_tonumber(tolua_S,1,0));
4295 {
4296 Tile* tolua_ret = (Tile*) api_find_tile_by_index(L,tindex);
4297 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
4298 }
4299 }
4300 return 1;
4301tolua_lerror:
4302 return tolua_game_find_tile00(tolua_S);
4303}
4304
4305/* function: api_find_government_by_name */
4306static int tolua_game_find_government00(lua_State* tolua_S)
4307{
4308#ifndef TOLUA_RELEASE
4309 tolua_Error tolua_err;
4310 if (
4311 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4312 !tolua_isnoobj(tolua_S,2,&tolua_err)
4313 )
4314 goto tolua_lerror;
4315 else
4316#endif
4317 {
4318 lua_State* L = tolua_S;
4319 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4320 {
4321 Government* tolua_ret = (Government*) api_find_government_by_name(L,name_orig);
4322 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Government");
4323 }
4324 }
4325 return 1;
4326#ifndef TOLUA_RELEASE
4327 tolua_lerror:
4328 tolua_error(tolua_S,"#ferror in function 'government'.",&tolua_err);
4329 return 0;
4330#endif
4331}
4332
4333/* function: api_find_government */
4334static int tolua_game_find_government01(lua_State* tolua_S)
4335{
4336 tolua_Error tolua_err;
4337 if (
4338 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4339 !tolua_isnoobj(tolua_S,2,&tolua_err)
4340 )
4341 goto tolua_lerror;
4342 else
4343 {
4344 lua_State* L = tolua_S;
4345 int government_id = ((int) tolua_tonumber(tolua_S,1,0));
4346 {
4347 Government* tolua_ret = (Government*) api_find_government(L,government_id);
4348 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Government");
4349 }
4350 }
4351 return 1;
4352tolua_lerror:
4353 return tolua_game_find_government00(tolua_S);
4354}
4355
4356/* function: api_find_nation_type_by_name */
4357static int tolua_game_find_nation_type00(lua_State* tolua_S)
4358{
4359#ifndef TOLUA_RELEASE
4360 tolua_Error tolua_err;
4361 if (
4362 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4363 !tolua_isnoobj(tolua_S,2,&tolua_err)
4364 )
4365 goto tolua_lerror;
4366 else
4367#endif
4368 {
4369 lua_State* L = tolua_S;
4370 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4371 {
4372 Nation_Type* tolua_ret = (Nation_Type*) api_find_nation_type_by_name(L,name_orig);
4373 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Nation_Type");
4374 }
4375 }
4376 return 1;
4377#ifndef TOLUA_RELEASE
4378 tolua_lerror:
4379 tolua_error(tolua_S,"#ferror in function 'nation_type'.",&tolua_err);
4380 return 0;
4381#endif
4382}
4383
4384/* function: api_find_nation_type */
4385static int tolua_game_find_nation_type01(lua_State* tolua_S)
4386{
4387 tolua_Error tolua_err;
4388 if (
4389 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4390 !tolua_isnoobj(tolua_S,2,&tolua_err)
4391 )
4392 goto tolua_lerror;
4393 else
4394 {
4395 lua_State* L = tolua_S;
4396 int nation_type_id = ((int) tolua_tonumber(tolua_S,1,0));
4397 {
4398 Nation_Type* tolua_ret = (Nation_Type*) api_find_nation_type(L,nation_type_id);
4399 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Nation_Type");
4400 }
4401 }
4402 return 1;
4403tolua_lerror:
4404 return tolua_game_find_nation_type00(tolua_S);
4405}
4406
4407/* function: api_find_action_by_name */
4408static int tolua_game_find_action00(lua_State* tolua_S)
4409{
4410#ifndef TOLUA_RELEASE
4411 tolua_Error tolua_err;
4412 if (
4413 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4414 !tolua_isnoobj(tolua_S,2,&tolua_err)
4415 )
4416 goto tolua_lerror;
4417 else
4418#endif
4419 {
4420 lua_State* L = tolua_S;
4421 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4422 {
4423 Action* tolua_ret = (Action*) api_find_action_by_name(L,name_orig);
4424 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Action");
4425 }
4426 }
4427 return 1;
4428#ifndef TOLUA_RELEASE
4429 tolua_lerror:
4430 tolua_error(tolua_S,"#ferror in function 'action'.",&tolua_err);
4431 return 0;
4432#endif
4433}
4434
4435/* function: api_find_action */
4436static int tolua_game_find_action01(lua_State* tolua_S)
4437{
4438 tolua_Error tolua_err;
4439 if (
4440 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4441 !tolua_isnoobj(tolua_S,2,&tolua_err)
4442 )
4443 goto tolua_lerror;
4444 else
4445 {
4446 lua_State* L = tolua_S;
4447 int action_type_id = ((int) tolua_tonumber(tolua_S,1,0));
4448 {
4449 Action* tolua_ret = (Action*) api_find_action(L,action_type_id);
4450 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Action");
4451 }
4452 }
4453 return 1;
4454tolua_lerror:
4455 return tolua_game_find_action00(tolua_S);
4456}
4457
4458/* function: api_find_building_type_by_name */
4459static int tolua_game_find_building_type00(lua_State* tolua_S)
4460{
4461#ifndef TOLUA_RELEASE
4462 tolua_Error tolua_err;
4463 if (
4464 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4465 !tolua_isnoobj(tolua_S,2,&tolua_err)
4466 )
4467 goto tolua_lerror;
4468 else
4469#endif
4470 {
4471 lua_State* L = tolua_S;
4472 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4473 {
4474 Building_Type* tolua_ret = (Building_Type*) api_find_building_type_by_name(L,name_orig);
4475 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Building_Type");
4476 }
4477 }
4478 return 1;
4479#ifndef TOLUA_RELEASE
4480 tolua_lerror:
4481 tolua_error(tolua_S,"#ferror in function 'building_type'.",&tolua_err);
4482 return 0;
4483#endif
4484}
4485
4486/* function: api_find_building_type */
4487static int tolua_game_find_building_type01(lua_State* tolua_S)
4488{
4489 tolua_Error tolua_err;
4490 if (
4491 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4492 !tolua_isnoobj(tolua_S,2,&tolua_err)
4493 )
4494 goto tolua_lerror;
4495 else
4496 {
4497 lua_State* L = tolua_S;
4498 int building_type_id = ((int) tolua_tonumber(tolua_S,1,0));
4499 {
4500 Building_Type* tolua_ret = (Building_Type*) api_find_building_type(L,building_type_id);
4501 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Building_Type");
4502 }
4503 }
4504 return 1;
4505tolua_lerror:
4506 return tolua_game_find_building_type00(tolua_S);
4507}
4508
4509/* function: api_find_unit_type_by_name */
4510static int tolua_game_find_unit_type00(lua_State* tolua_S)
4511{
4512#ifndef TOLUA_RELEASE
4513 tolua_Error tolua_err;
4514 if (
4515 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4516 !tolua_isnoobj(tolua_S,2,&tolua_err)
4517 )
4518 goto tolua_lerror;
4519 else
4520#endif
4521 {
4522 lua_State* L = tolua_S;
4523 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4524 {
4525 Unit_Type* tolua_ret = (Unit_Type*) api_find_unit_type_by_name(L,name_orig);
4526 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_Type");
4527 }
4528 }
4529 return 1;
4530#ifndef TOLUA_RELEASE
4531 tolua_lerror:
4532 tolua_error(tolua_S,"#ferror in function 'unit_type'.",&tolua_err);
4533 return 0;
4534#endif
4535}
4536
4537/* function: api_find_unit_type */
4538static int tolua_game_find_unit_type01(lua_State* tolua_S)
4539{
4540 tolua_Error tolua_err;
4541 if (
4542 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4543 !tolua_isnoobj(tolua_S,2,&tolua_err)
4544 )
4545 goto tolua_lerror;
4546 else
4547 {
4548 lua_State* L = tolua_S;
4549 int unit_type_id = ((int) tolua_tonumber(tolua_S,1,0));
4550 {
4551 Unit_Type* tolua_ret = (Unit_Type*) api_find_unit_type(L,unit_type_id);
4552 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_Type");
4553 }
4554 }
4555 return 1;
4556tolua_lerror:
4557 return tolua_game_find_unit_type00(tolua_S);
4558}
4559
4560/* function: api_find_role_unit_type */
4561static int tolua_game_find_role_unit_type00(lua_State* tolua_S)
4562{
4563#ifndef TOLUA_RELEASE
4564 tolua_Error tolua_err;
4565 if (
4566 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4567 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
4568 !tolua_isnoobj(tolua_S,3,&tolua_err)
4569 )
4570 goto tolua_lerror;
4571 else
4572#endif
4573 {
4574 lua_State* L = tolua_S;
4575 const char* role_name = ((const char*) tolua_tostring(tolua_S,1,0));
4576 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,2,0));
4577 {
4578 Unit_Type* tolua_ret = (Unit_Type*) api_find_role_unit_type(L,role_name,pplayer);
4579 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_Type");
4580 }
4581 }
4582 return 1;
4583#ifndef TOLUA_RELEASE
4584 tolua_lerror:
4585 tolua_error(tolua_S,"#ferror in function 'role_unit_type'.",&tolua_err);
4586 return 0;
4587#endif
4588}
4589
4590/* function: api_find_tech_type_by_name */
4591static int tolua_game_find_tech_type00(lua_State* tolua_S)
4592{
4593#ifndef TOLUA_RELEASE
4594 tolua_Error tolua_err;
4595 if (
4596 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4597 !tolua_isnoobj(tolua_S,2,&tolua_err)
4598 )
4599 goto tolua_lerror;
4600 else
4601#endif
4602 {
4603 lua_State* L = tolua_S;
4604 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4605 {
4606 Tech_Type* tolua_ret = (Tech_Type*) api_find_tech_type_by_name(L,name_orig);
4607 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tech_Type");
4608 }
4609 }
4610 return 1;
4611#ifndef TOLUA_RELEASE
4612 tolua_lerror:
4613 tolua_error(tolua_S,"#ferror in function 'tech_type'.",&tolua_err);
4614 return 0;
4615#endif
4616}
4617
4618/* function: api_find_tech_type */
4619static int tolua_game_find_tech_type01(lua_State* tolua_S)
4620{
4621 tolua_Error tolua_err;
4622 if (
4623 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4624 !tolua_isnoobj(tolua_S,2,&tolua_err)
4625 )
4626 goto tolua_lerror;
4627 else
4628 {
4629 lua_State* L = tolua_S;
4630 int tech_type_id = ((int) tolua_tonumber(tolua_S,1,0));
4631 {
4632 Tech_Type* tolua_ret = (Tech_Type*) api_find_tech_type(L,tech_type_id);
4633 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tech_Type");
4634 }
4635 }
4636 return 1;
4637tolua_lerror:
4638 return tolua_game_find_tech_type00(tolua_S);
4639}
4640
4641/* function: api_find_terrain_by_name */
4642static int tolua_game_find_terrain00(lua_State* tolua_S)
4643{
4644#ifndef TOLUA_RELEASE
4645 tolua_Error tolua_err;
4646 if (
4647 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4648 !tolua_isnoobj(tolua_S,2,&tolua_err)
4649 )
4650 goto tolua_lerror;
4651 else
4652#endif
4653 {
4654 lua_State* L = tolua_S;
4655 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4656 {
4657 Terrain* tolua_ret = (Terrain*) api_find_terrain_by_name(L,name_orig);
4658 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Terrain");
4659 }
4660 }
4661 return 1;
4662#ifndef TOLUA_RELEASE
4663 tolua_lerror:
4664 tolua_error(tolua_S,"#ferror in function 'terrain'.",&tolua_err);
4665 return 0;
4666#endif
4667}
4668
4669/* function: api_find_terrain */
4670static int tolua_game_find_terrain01(lua_State* tolua_S)
4671{
4672 tolua_Error tolua_err;
4673 if (
4674 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4675 !tolua_isnoobj(tolua_S,2,&tolua_err)
4676 )
4677 goto tolua_lerror;
4678 else
4679 {
4680 lua_State* L = tolua_S;
4681 int terrain_id = ((int) tolua_tonumber(tolua_S,1,0));
4682 {
4683 Terrain* tolua_ret = (Terrain*) api_find_terrain(L,terrain_id);
4684 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Terrain");
4685 }
4686 }
4687 return 1;
4688tolua_lerror:
4689 return tolua_game_find_terrain00(tolua_S);
4690}
4691
4692/* function: api_find_achievement_by_name */
4693static int tolua_game_find_achievement00(lua_State* tolua_S)
4694{
4695#ifndef TOLUA_RELEASE
4696 tolua_Error tolua_err;
4697 if (
4698 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4699 !tolua_isnoobj(tolua_S,2,&tolua_err)
4700 )
4701 goto tolua_lerror;
4702 else
4703#endif
4704 {
4705 lua_State* L = tolua_S;
4706 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4707 {
4708 Achievement* tolua_ret = (Achievement*) api_find_achievement_by_name(L,name_orig);
4709 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Achievement");
4710 }
4711 }
4712 return 1;
4713#ifndef TOLUA_RELEASE
4714 tolua_lerror:
4715 tolua_error(tolua_S,"#ferror in function 'achievement'.",&tolua_err);
4716 return 0;
4717#endif
4718}
4719
4720/* function: api_find_achievement */
4721static int tolua_game_find_achievement01(lua_State* tolua_S)
4722{
4723 tolua_Error tolua_err;
4724 if (
4725 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4726 !tolua_isnoobj(tolua_S,2,&tolua_err)
4727 )
4728 goto tolua_lerror;
4729 else
4730 {
4731 lua_State* L = tolua_S;
4732 int achievement_id = ((int) tolua_tonumber(tolua_S,1,0));
4733 {
4734 Achievement* tolua_ret = (Achievement*) api_find_achievement(L,achievement_id);
4735 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Achievement");
4736 }
4737 }
4738 return 1;
4739tolua_lerror:
4740 return tolua_game_find_achievement00(tolua_S);
4741}
4742
4743/* function: api_find_disaster_by_name */
4744static int tolua_game_find_achievement02(lua_State* tolua_S)
4745{
4746 tolua_Error tolua_err;
4747 if (
4748 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4749 !tolua_isnoobj(tolua_S,2,&tolua_err)
4750 )
4751 goto tolua_lerror;
4752 else
4753 {
4754 lua_State* L = tolua_S;
4755 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4756 {
4757 Disaster* tolua_ret = (Disaster*) api_find_disaster_by_name(L,name_orig);
4758 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Disaster");
4759 }
4760 }
4761 return 1;
4762tolua_lerror:
4763 return tolua_game_find_achievement01(tolua_S);
4764}
4765
4766/* function: api_find_disaster */
4767static int tolua_game_find_disaster00(lua_State* tolua_S)
4768{
4769#ifndef TOLUA_RELEASE
4770 tolua_Error tolua_err;
4771 if (
4772 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4773 !tolua_isnoobj(tolua_S,2,&tolua_err)
4774 )
4775 goto tolua_lerror;
4776 else
4777#endif
4778 {
4779 lua_State* L = tolua_S;
4780 int disaster_id = ((int) tolua_tonumber(tolua_S,1,0));
4781 {
4782 Disaster* tolua_ret = (Disaster*) api_find_disaster(L,disaster_id);
4783 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Disaster");
4784 }
4785 }
4786 return 1;
4787#ifndef TOLUA_RELEASE
4788 tolua_lerror:
4789 tolua_error(tolua_S,"#ferror in function 'disaster'.",&tolua_err);
4790 return 0;
4791#endif
4792}
4793
4794/* function: api_utilities_str2dir */
4795static int tolua_game_find_direction00(lua_State* tolua_S)
4796{
4797#ifndef TOLUA_RELEASE
4798 tolua_Error tolua_err;
4799 if (
4800 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4801 !tolua_isnoobj(tolua_S,2,&tolua_err)
4802 )
4803 goto tolua_lerror;
4804 else
4805#endif
4806 {
4807 lua_State* L = tolua_S;
4808 const char* str = ((const char*) tolua_tostring(tolua_S,1,0));
4809 {
4810 Direction* tolua_ret = (Direction*) api_utilities_str2dir(L,str);
4811 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
4812 }
4813 }
4814 return 1;
4815#ifndef TOLUA_RELEASE
4816 tolua_lerror:
4817 tolua_error(tolua_S,"#ferror in function 'direction'.",&tolua_err);
4818 return 0;
4819#endif
4820}
4821
4822/* function: api_find_direction */
4823static int tolua_game_find_direction01(lua_State* tolua_S)
4824{
4825 tolua_Error tolua_err;
4826 if (
4827 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4828 !tolua_isnoobj(tolua_S,2,&tolua_err)
4829 )
4830 goto tolua_lerror;
4831 else
4832 {
4833 lua_State* L = tolua_S;
4834 int id = ((int) tolua_tonumber(tolua_S,1,0));
4835 {
4836 Direction* tolua_ret = (Direction*) api_find_direction(L,id);
4837 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
4838 }
4839 }
4840 return 1;
4841tolua_lerror:
4842 return tolua_game_find_direction00(tolua_S);
4843}
4844
4845/* function: api_find_action_type_by_name */
4846static int tolua_game_find_action02(lua_State* tolua_S)
4847{
4848 tolua_Error tolua_err;
4849 if (
4850 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4851 !tolua_isnoobj(tolua_S,2,&tolua_err)
4852 )
4853 goto tolua_lerror;
4854 else
4855 {
4856 lua_State* L = tolua_S;
4857 const char* name = ((const char*) tolua_tostring(tolua_S,1,0));
4858 {
4859 Action* tolua_ret = (Action*) api_find_action_type_by_name(L,name);
4860 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Action");
4861 }
4862 }
4863 return 1;
4864tolua_lerror:
4865 return tolua_game_find_action01(tolua_S);
4866}
4867
4868/* function: api_find_action_type_by_id */
4869static int tolua_game_find_action03(lua_State* tolua_S)
4870{
4871 tolua_Error tolua_err;
4872 if (
4873 !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
4874 !tolua_isnoobj(tolua_S,2,&tolua_err)
4875 )
4876 goto tolua_lerror;
4877 else
4878 {
4879 lua_State* L = tolua_S;
4880 int id = ((int) tolua_tonumber(tolua_S,1,0));
4881 {
4882 Action* tolua_ret = (Action*) api_find_action_type_by_id(L,id);
4883 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Action");
4884 }
4885 }
4886 return 1;
4887tolua_lerror:
4888 return tolua_game_find_action02(tolua_S);
4889}
4890
4891/* function: api_find_nonexistent */
4892static int tolua_game_find_nonexistent00(lua_State* tolua_S)
4893{
4894#ifndef TOLUA_RELEASE
4895 tolua_Error tolua_err;
4896 if (
4897 !tolua_isnoobj(tolua_S,1,&tolua_err)
4898 )
4899 goto tolua_lerror;
4900 else
4901#endif
4902 {
4903 lua_State* L = tolua_S;
4904 {
4905 Nonexistent* tolua_ret = (Nonexistent*) api_find_nonexistent(L);
4906 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Nonexistent");
4907 }
4908 }
4909 return 1;
4910#ifndef TOLUA_RELEASE
4911 tolua_lerror:
4912 tolua_error(tolua_S,"#ferror in function 'nonexistent'.",&tolua_err);
4913 return 0;
4914#endif
4915}
4916
4917/* function: api_effects_world_bonus */
4918static int tolua_game_effects_world_bonus00(lua_State* tolua_S)
4919{
4920#ifndef TOLUA_RELEASE
4921 tolua_Error tolua_err;
4922 if (
4923 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
4924 !tolua_isnoobj(tolua_S,2,&tolua_err)
4925 )
4926 goto tolua_lerror;
4927 else
4928#endif
4929 {
4930 lua_State* L = tolua_S;
4931 const char* effect_type = ((const char*) tolua_tostring(tolua_S,1,0));
4932 {
4933 int tolua_ret = (int) api_effects_world_bonus(L,effect_type);
4934 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
4935 }
4936 }
4937 return 1;
4938#ifndef TOLUA_RELEASE
4939 tolua_lerror:
4940 tolua_error(tolua_S,"#ferror in function 'world_bonus'.",&tolua_err);
4941 return 0;
4942#endif
4943}
4944
4945/* function: api_effects_player_bonus */
4946static int tolua_game_effects_player_bonus00(lua_State* tolua_S)
4947{
4948#ifndef TOLUA_RELEASE
4949 tolua_Error tolua_err;
4950 if (
4951 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
4952 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
4953 !tolua_isnoobj(tolua_S,3,&tolua_err)
4954 )
4955 goto tolua_lerror;
4956 else
4957#endif
4958 {
4959 lua_State* L = tolua_S;
4960 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
4961 const char* effect_type = ((const char*) tolua_tostring(tolua_S,2,0));
4962 {
4963 int tolua_ret = (int) api_effects_player_bonus(L,pplayer,effect_type);
4964 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
4965 }
4966 }
4967 return 1;
4968#ifndef TOLUA_RELEASE
4969 tolua_lerror:
4970 tolua_error(tolua_S,"#ferror in function 'player_bonus'.",&tolua_err);
4971 return 0;
4972#endif
4973}
4974
4975/* function: api_effects_city_bonus */
4976static int tolua_game_effects_city_bonus00(lua_State* tolua_S)
4977{
4978#ifndef TOLUA_RELEASE
4979 tolua_Error tolua_err;
4980 if (
4981 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
4982 !tolua_isstring(tolua_S,2,0,&tolua_err) ||
4983 !tolua_isnoobj(tolua_S,3,&tolua_err)
4984 )
4985 goto tolua_lerror;
4986 else
4987#endif
4988 {
4989 lua_State* L = tolua_S;
4990 City* pcity = ((City*) tolua_tousertype(tolua_S,1,0));
4991 const char* effect_type = ((const char*) tolua_tostring(tolua_S,2,0));
4992 {
4993 int tolua_ret = (int) api_effects_city_bonus(L,pcity,effect_type);
4994 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
4995 }
4996 }
4997 return 1;
4998#ifndef TOLUA_RELEASE
4999 tolua_lerror:
5000 tolua_error(tolua_S,"#ferror in function 'city_bonus'.",&tolua_err);
5001 return 0;
5002#endif
5003}
5004
5005/* function: api_effects_unit_bonus */
5006static int tolua_game_effects_unit_bonus00(lua_State* tolua_S)
5007{
5008#ifndef TOLUA_RELEASE
5009 tolua_Error tolua_err;
5010 if (
5011 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
5012 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
5013 !tolua_isstring(tolua_S,3,0,&tolua_err) ||
5014 !tolua_isnoobj(tolua_S,4,&tolua_err)
5015 )
5016 goto tolua_lerror;
5017 else
5018#endif
5019 {
5020 lua_State* L = tolua_S;
5021 Unit* punit = ((Unit*) tolua_tousertype(tolua_S,1,0));
5022 Player* other_player = ((Player*) tolua_tousertype(tolua_S,2,0));
5023 const char* effect_type = ((const char*) tolua_tostring(tolua_S,3,0));
5024 {
5025 int tolua_ret = (int) api_effects_unit_bonus(L,punit,other_player,effect_type);
5026 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5027 }
5028 }
5029 return 1;
5030#ifndef TOLUA_RELEASE
5031 tolua_lerror:
5032 tolua_error(tolua_S,"#ferror in function 'unit_bonus'.",&tolua_err);
5033 return 0;
5034#endif
5035}
5036
5037/* function: api_effects_tile_bonus */
5038static int tolua_game_effects_tile_bonus00(lua_State* tolua_S)
5039{
5040#ifndef TOLUA_RELEASE
5041 tolua_Error tolua_err;
5042 if (
5043 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
5044 !tolua_isusertype(tolua_S,2,"City",0,&tolua_err) ||
5045 !tolua_isstring(tolua_S,3,0,&tolua_err) ||
5046 !tolua_isstring(tolua_S,4,0,&tolua_err) ||
5047 !tolua_isnoobj(tolua_S,5,&tolua_err)
5048 )
5049 goto tolua_lerror;
5050 else
5051#endif
5052 {
5053 lua_State* L = tolua_S;
5054 Tile* ptile = ((Tile*) tolua_tousertype(tolua_S,1,0));
5055 City* pcity = ((City*) tolua_tousertype(tolua_S,2,0));
5056 const char* output_id = ((const char*) tolua_tostring(tolua_S,3,0));
5057 const char* effect_type = ((const char*) tolua_tostring(tolua_S,4,0));
5058 {
5059 int tolua_ret = (int) api_effects_tile_bonus(L,ptile,pcity,output_id,effect_type);
5060 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5061 }
5062 }
5063 return 1;
5064#ifndef TOLUA_RELEASE
5065 tolua_lerror:
5066 tolua_error(tolua_S,"#ferror in function 'tile_bonus'.",&tolua_err);
5067 return 0;
5068#endif
5069}
5070
5071/* function: api_effects_unit_vs_tile_bonus */
5072static int tolua_game_effects_unit_vs_tile_bonus00(lua_State* tolua_S)
5073{
5074#ifndef TOLUA_RELEASE
5075 tolua_Error tolua_err;
5076 if (
5077 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
5078 !tolua_isusertype(tolua_S,2,"Tile",0,&tolua_err) ||
5079 !tolua_isstring(tolua_S,3,0,&tolua_err) ||
5080 !tolua_isnoobj(tolua_S,4,&tolua_err)
5081 )
5082 goto tolua_lerror;
5083 else
5084#endif
5085 {
5086 lua_State* L = tolua_S;
5087 Unit* punit = ((Unit*) tolua_tousertype(tolua_S,1,0));
5088 Tile* ptile = ((Tile*) tolua_tousertype(tolua_S,2,0));
5089 const char* effect_type = ((const char*) tolua_tostring(tolua_S,3,0));
5090 {
5091 int tolua_ret = (int) api_effects_unit_vs_tile_bonus(L,punit,ptile,effect_type);
5092 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5093 }
5094 }
5095 return 1;
5096#ifndef TOLUA_RELEASE
5097 tolua_lerror:
5098 tolua_error(tolua_S,"#ferror in function 'unit_vs_tile_bonus'.",&tolua_err);
5099 return 0;
5100#endif
5101}
5102
5103/* function: api_utilities_direction_id */
5104static int tolua_game_Direction_properties_id00(lua_State* tolua_S)
5105{
5106#ifndef TOLUA_RELEASE
5107 tolua_Error tolua_err;
5108 if (
5109 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5110 !tolua_isnoobj(tolua_S,2,&tolua_err)
5111 )
5112 goto tolua_lerror;
5113 else
5114#endif
5115 {
5116 lua_State* L = tolua_S;
5117 Direction dir = *((Direction*) tolua_tousertype(tolua_S,1,0));
5118 {
5119 int tolua_ret = (int) api_utilities_direction_id(L,dir);
5120 tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
5121 }
5122 }
5123 return 1;
5124#ifndef TOLUA_RELEASE
5125 tolua_lerror:
5126 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
5127 return 0;
5128#endif
5129}
5130
5131/* function: api_utilities_dir2str */
5132static int tolua_game_Direction_properties_name00(lua_State* tolua_S)
5133{
5134#ifndef TOLUA_RELEASE
5135 tolua_Error tolua_err;
5136 if (
5137 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5138 !tolua_isnoobj(tolua_S,2,&tolua_err)
5139 )
5140 goto tolua_lerror;
5141 else
5142#endif
5143 {
5144 lua_State* L = tolua_S;
5145 Direction dir = *((Direction*) tolua_tousertype(tolua_S,1,0));
5146 {
5147 const char* tolua_ret = (const char*) api_utilities_dir2str(L,dir);
5148 tolua_pushstring(tolua_S,(const char*)tolua_ret);
5149 }
5150 }
5151 return 1;
5152#ifndef TOLUA_RELEASE
5153 tolua_lerror:
5154 tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
5155 return 0;
5156#endif
5157}
5158
5159/* function: api_utilities_direction_is_cardinal */
5160static int tolua_game_Direction_properties_cardinal00(lua_State* tolua_S)
5161{
5162#ifndef TOLUA_RELEASE
5163 tolua_Error tolua_err;
5164 if (
5165 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5166 !tolua_isnoobj(tolua_S,2,&tolua_err)
5167 )
5168 goto tolua_lerror;
5169 else
5170#endif
5171 {
5172 lua_State* L = tolua_S;
5173 Direction self = *((Direction*) tolua_tousertype(tolua_S,1,0));
5174 {
5175 bool tolua_ret = (bool) api_utilities_direction_is_cardinal(L,self);
5176 tolua_pushboolean(tolua_S,(bool)tolua_ret);
5177 }
5178 }
5179 return 1;
5180#ifndef TOLUA_RELEASE
5181 tolua_lerror:
5182 tolua_error(tolua_S,"#ferror in function 'cardinal'.",&tolua_err);
5183 return 0;
5184#endif
5185}
5186
5187/* function: api_utilities_str2dir */
5188static int tolua_game_direction_str2dir00(lua_State* tolua_S)
5189{
5190#ifndef TOLUA_RELEASE
5191 tolua_Error tolua_err;
5192 if (
5193 !tolua_isstring(tolua_S,1,0,&tolua_err) ||
5194 !tolua_isnoobj(tolua_S,2,&tolua_err)
5195 )
5196 goto tolua_lerror;
5197 else
5198#endif
5199 {
5200 lua_State* L = tolua_S;
5201 const char* str = ((const char*) tolua_tostring(tolua_S,1,0));
5202 {
5203 Direction* tolua_ret = (Direction*) api_utilities_str2dir(L,str);
5204 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5205 }
5206 }
5207 return 1;
5208#ifndef TOLUA_RELEASE
5209 tolua_lerror:
5210 tolua_error(tolua_S,"#ferror in function 'str2dir'.",&tolua_err);
5211 return 0;
5212#endif
5213}
5214
5215/* function: api_utilities_dir_ccw */
5216static int tolua_game_direction_next_ccw00(lua_State* tolua_S)
5217{
5218#ifndef TOLUA_RELEASE
5219 tolua_Error tolua_err;
5220 if (
5221 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5222 !tolua_isnoobj(tolua_S,2,&tolua_err)
5223 )
5224 goto tolua_lerror;
5225 else
5226#endif
5227 {
5228 lua_State* L = tolua_S;
5229 Direction self = *((Direction*) tolua_tousertype(tolua_S,1,0));
5230 {
5231 Direction* tolua_ret = (Direction*) api_utilities_dir_ccw(L,self);
5232 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5233 }
5234 }
5235 return 1;
5236#ifndef TOLUA_RELEASE
5237 tolua_lerror:
5238 tolua_error(tolua_S,"#ferror in function 'next_ccw'.",&tolua_err);
5239 return 0;
5240#endif
5241}
5242
5243/* function: api_utilities_dir_cw */
5244static int tolua_game_direction_next_cw00(lua_State* tolua_S)
5245{
5246#ifndef TOLUA_RELEASE
5247 tolua_Error tolua_err;
5248 if (
5249 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5250 !tolua_isnoobj(tolua_S,2,&tolua_err)
5251 )
5252 goto tolua_lerror;
5253 else
5254#endif
5255 {
5256 lua_State* L = tolua_S;
5257 Direction self = *((Direction*) tolua_tousertype(tolua_S,1,0));
5258 {
5259 Direction* tolua_ret = (Direction*) api_utilities_dir_cw(L,self);
5260 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5261 }
5262 }
5263 return 1;
5264#ifndef TOLUA_RELEASE
5265 tolua_lerror:
5266 tolua_error(tolua_S,"#ferror in function 'next_cw'.",&tolua_err);
5267 return 0;
5268#endif
5269}
5270
5271/* function: api_utilities_opposite_dir */
5272static int tolua_game_direction_opposite00(lua_State* tolua_S)
5273{
5274#ifndef TOLUA_RELEASE
5275 tolua_Error tolua_err;
5276 if (
5277 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5278 !tolua_isnoobj(tolua_S,2,&tolua_err)
5279 )
5280 goto tolua_lerror;
5281 else
5282#endif
5283 {
5284 lua_State* L = tolua_S;
5285 Direction self = *((Direction*) tolua_tousertype(tolua_S,1,0));
5286 {
5287 Direction* tolua_ret = (Direction*) api_utilities_opposite_dir(L,self);
5288 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5289 }
5290 }
5291 return 1;
5292#ifndef TOLUA_RELEASE
5293 tolua_lerror:
5294 tolua_error(tolua_S,"#ferror in function 'opposite'.",&tolua_err);
5295 return 0;
5296#endif
5297}
5298
5299/* Open lib function */
5300LUALIB_API int luaopen_game (lua_State* tolua_S)
5301{
5302 tolua_open(tolua_S);
5303 tolua_reg_types(tolua_S);
5304 tolua_module(tolua_S,NULL,0);
5305 tolua_beginmodule(tolua_S,NULL);
5306 tolua_cclass(tolua_S,"Player","Player","",NULL);
5307 tolua_beginmodule(tolua_S,"Player");
5308 tolua_variable(tolua_S,"name",tolua_get_Player_Player_name,NULL);
5309 tolua_variable(tolua_S,"nation",tolua_get_Player_Player_nation_ptr,tolua_set_Player_Player_nation_ptr);
5310 tolua_variable(tolua_S,"government",tolua_get_Player_Player_government_ptr,tolua_set_Player_Player_government_ptr);
5311 tolua_variable(tolua_S,"is_alive",tolua_get_Player_Player_is_alive,tolua_set_Player_Player_is_alive);
5312 tolua_endmodule(tolua_S);
5313 tolua_cclass(tolua_S,"City","City","",NULL);
5314 tolua_beginmodule(tolua_S,"City");
5315 tolua_variable(tolua_S,"name",tolua_get_City_City_name,NULL);
5316 tolua_variable(tolua_S,"owner",tolua_get_City_City_owner_ptr,tolua_set_City_City_owner_ptr);
5317 tolua_variable(tolua_S,"original",tolua_get_City_City_original_ptr,tolua_set_City_City_original_ptr);
5318 tolua_variable(tolua_S,"id",tolua_get_City_City_id,NULL);
5319 tolua_endmodule(tolua_S);
5320 tolua_cclass(tolua_S,"Counter","Counter","",NULL);
5321 tolua_beginmodule(tolua_S,"Counter");
5322 tolua_endmodule(tolua_S);
5323 tolua_cclass(tolua_S,"Connection","Connection","",NULL);
5324 tolua_beginmodule(tolua_S,"Connection");
5325 tolua_variable(tolua_S,"id",tolua_get_Connection_Connection_id,NULL);
5326 tolua_endmodule(tolua_S);
5327 tolua_cclass(tolua_S,"Unit","Unit","",NULL);
5328 tolua_beginmodule(tolua_S,"Unit");
5329 tolua_variable(tolua_S,"utype",tolua_get_Unit_Unit_utype_ptr,tolua_set_Unit_Unit_utype_ptr);
5330 tolua_variable(tolua_S,"owner",tolua_get_Unit_Unit_owner_ptr,tolua_set_Unit_Unit_owner_ptr);
5331 tolua_variable(tolua_S,"homecity",tolua_get_Unit_Unit_homecity,tolua_set_Unit_Unit_homecity);
5332 tolua_variable(tolua_S,"veteran",tolua_get_Unit_Unit_veteran,tolua_set_Unit_Unit_veteran);
5333 tolua_variable(tolua_S,"id",tolua_get_Unit_Unit_id,NULL);
5334 tolua_endmodule(tolua_S);
5335 tolua_cclass(tolua_S,"Tile","Tile","",NULL);
5336 tolua_beginmodule(tolua_S,"Tile");
5337 tolua_variable(tolua_S,"terrain",tolua_get_Tile_Tile_terrain_ptr,tolua_set_Tile_Tile_terrain_ptr);
5338 tolua_variable(tolua_S,"owner",tolua_get_Tile_Tile_owner_ptr,tolua_set_Tile_Tile_owner_ptr);
5339 tolua_variable(tolua_S,"id",tolua_get_Tile_Tile_index,NULL);
5340 tolua_endmodule(tolua_S);
5341 tolua_cclass(tolua_S,"Government","Government","",NULL);
5342 tolua_beginmodule(tolua_S,"Government");
5343 tolua_variable(tolua_S,"id",tolua_get_Government_Government_item_number,NULL);
5344 tolua_endmodule(tolua_S);
5345 tolua_cclass(tolua_S,"Nation_Type","Nation_Type","",NULL);
5346 tolua_beginmodule(tolua_S,"Nation_Type");
5347 tolua_variable(tolua_S,"id",tolua_get_Nation_Type_Nation_Type_item_number,NULL);
5348 tolua_endmodule(tolua_S);
5349 tolua_cclass(tolua_S,"Building_Type","Building_Type","",NULL);
5350 tolua_beginmodule(tolua_S,"Building_Type");
5351 tolua_variable(tolua_S,"build_cost",tolua_get_Building_Type_Building_Type_build_cost,tolua_set_Building_Type_Building_Type_build_cost);
5352 tolua_variable(tolua_S,"id",tolua_get_Building_Type_Building_Type_item_number,NULL);
5353 tolua_endmodule(tolua_S);
5354 tolua_cclass(tolua_S,"Unit_Type","Unit_Type","",NULL);
5355 tolua_beginmodule(tolua_S,"Unit_Type");
5356 tolua_variable(tolua_S,"build_cost",tolua_get_Unit_Type_Unit_Type_build_cost,tolua_set_Unit_Type_Unit_Type_build_cost);
5357 tolua_variable(tolua_S,"obsoleted_by",tolua_get_Unit_Type_Unit_Type_obsoleted_by_ptr,tolua_set_Unit_Type_Unit_Type_obsoleted_by_ptr);
5358 tolua_variable(tolua_S,"id",tolua_get_Unit_Type_Unit_Type_item_number,NULL);
5359 tolua_endmodule(tolua_S);
5360 tolua_cclass(tolua_S,"Tech_Type","Tech_Type","",NULL);
5361 tolua_beginmodule(tolua_S,"Tech_Type");
5362 tolua_variable(tolua_S,"id",tolua_get_Tech_Type_Tech_Type_item_number,NULL);
5363 tolua_variable(tolua_S,"cost_base",tolua_get_Tech_Type_Tech_Type_cost,NULL);
5364 tolua_endmodule(tolua_S);
5365 tolua_cclass(tolua_S,"Terrain","Terrain","",NULL);
5366 tolua_beginmodule(tolua_S,"Terrain");
5367 tolua_variable(tolua_S,"id",tolua_get_Terrain_Terrain_item_number,NULL);
5368 tolua_endmodule(tolua_S);
5369 tolua_cclass(tolua_S,"Disaster","Disaster","",NULL);
5370 tolua_beginmodule(tolua_S,"Disaster");
5371 tolua_variable(tolua_S,"id",tolua_get_Disaster_Disaster_id,NULL);
5372 tolua_endmodule(tolua_S);
5373 tolua_cclass(tolua_S,"Achievement","Achievement","",NULL);
5374 tolua_beginmodule(tolua_S,"Achievement");
5375 tolua_variable(tolua_S,"id",tolua_get_Achievement_Achievement_id,NULL);
5376 tolua_endmodule(tolua_S);
5377 tolua_cclass(tolua_S,"Action","Action","",NULL);
5378 tolua_beginmodule(tolua_S,"Action");
5379 tolua_variable(tolua_S,"id",tolua_get_Action_Action_id,NULL);
5380 tolua_endmodule(tolua_S);
5381 tolua_cclass(tolua_S,"Direction","Direction","",NULL);
5382 tolua_beginmodule(tolua_S,"Direction");
5383 tolua_endmodule(tolua_S);
5384 tolua_cclass(tolua_S,"Unit_List_Link","Unit_List_Link","",NULL);
5385 tolua_beginmodule(tolua_S,"Unit_List_Link");
5386 tolua_endmodule(tolua_S);
5387 tolua_cclass(tolua_S,"City_List_Link","City_List_Link","",NULL);
5388 tolua_beginmodule(tolua_S,"City_List_Link");
5389 tolua_endmodule(tolua_S);
5390 tolua_cclass(tolua_S,"Game_Info","Game_Info","",NULL);
5391 tolua_beginmodule(tolua_S,"Game_Info");
5392 tolua_variable(tolua_S,"base_tech_cost",tolua_get_Game_Info_Game_Info_base_tech_cost,NULL);
5393 tolua_variable(tolua_S,"min_tech_cost",tolua_get_Game_Info_Game_Info_min_tech_cost,NULL);
5394 tolua_variable(tolua_S,"tech_leak_pct",tolua_get_Game_Info_Game_Info_tech_leak_pct,NULL);
5395 tolua_variable(tolua_S,"tech_steal_allow_holes",tolua_get_Game_Info_Game_Info_tech_steal_allow_holes,NULL);
5396 tolua_variable(tolua_S,"tech_trade_allow_holes",tolua_get_Game_Info_Game_Info_tech_trade_allow_holes,NULL);
5397 tolua_variable(tolua_S,"tech_trade_loss_allow_holes",tolua_get_Game_Info_Game_Info_tech_trade_loss_allow_holes,NULL);
5398 tolua_variable(tolua_S,"tech_parasite_allow_holes",tolua_get_Game_Info_Game_Info_tech_parasite_allow_holes,NULL);
5399 tolua_variable(tolua_S,"tech_loss_allow_holes",tolua_get_Game_Info_Game_Info_tech_loss_allow_holes,NULL);
5400 tolua_variable(tolua_S,"sciencebox",tolua_get_Game_Info_Game_Info_sciencebox,NULL);
5401 tolua_endmodule(tolua_S);
5402 tolua_module(tolua_S,"game",1);
5403 tolua_beginmodule(tolua_S,"game");
5404 tolua_variable(tolua_S,"info",tolua_get_game_game_info_substructure,tolua_set_game_game_info_substructure);
5405 tolua_function(tolua_S,"current_turn",tolua_game_game_current_turn00);
5406 tolua_function(tolua_S,"turn",tolua_game_game_turn00);
5407 tolua_function(tolua_S,"current_year",tolua_game_game_current_year00);
5408 tolua_function(tolua_S,"current_fragment",tolua_game_game_current_fragment00);
5409 tolua_function(tolua_S,"current_year_text",tolua_game_game_current_year_text00);
5410 tolua_function(tolua_S,"rulesetdir",tolua_game_game_rulesetdir00);
5411 tolua_function(tolua_S,"ruleset_name",tolua_game_game_ruleset_name00);
5412 tolua_function(tolua_S,"tech_cost_style",tolua_game_game_tech_cost_style00);
5413 tolua_function(tolua_S,"tech_leakage_style",tolua_game_game_tech_leakage_style00);
5414 tolua_endmodule(tolua_S);
5415 tolua_module(tolua_S,"Counter",0);
5416 tolua_beginmodule(tolua_S,"Counter");
5417 tolua_function(tolua_S,"rule_name",tolua_game_Counter_rule_name00);
5418 tolua_function(tolua_S,"name_translation",tolua_game_Counter_name_translation00);
5419 tolua_function(tolua_S,"get",tolua_game_Counter_get00);
5420 tolua_endmodule(tolua_S);
5421 tolua_module(tolua_S,"Player",0);
5422 tolua_beginmodule(tolua_S,"Player");
5423 tolua_module(tolua_S,"properties",0);
5424 tolua_beginmodule(tolua_S,"properties");
5425 tolua_function(tolua_S,"id",tolua_game_Player_properties_id00);
5426 tolua_function(tolua_S,"bulbs",tolua_game_Player_properties_bulbs00);
5427 tolua_endmodule(tolua_S);
5428 tolua_function(tolua_S,"controlling_gui",tolua_game_Player_controlling_gui00);
5429 tolua_function(tolua_S,"num_cities",tolua_game_Player_num_cities00);
5430 tolua_function(tolua_S,"num_units",tolua_game_Player_num_units00);
5431 tolua_function(tolua_S,"num_future_techs",tolua_game_Player_num_future_techs00);
5432 tolua_function(tolua_S,"has_wonder",tolua_game_Player_has_wonder00);
5433 tolua_function(tolua_S,"gold",tolua_game_Player_gold00);
5434 tolua_function(tolua_S,"infrapoints",tolua_game_Player_infrapoints00);
5435 tolua_function(tolua_S,"knows_tech",tolua_game_Player_knows_tech00);
5436 tolua_function(tolua_S,"can_research",tolua_game_Player_can_research00);
5437 tolua_function(tolua_S,"tech_cost",tolua_game_Player_tech_cost00);
5438 tolua_function(tolua_S,"researching",tolua_game_Player_researching00);
5439 tolua_function(tolua_S,"researching_cost",tolua_game_Player_researching_cost00);
5440 tolua_function(tolua_S,"shares_research",tolua_game_Player_shares_research00);
5441 tolua_function(tolua_S,"research_rule_name",tolua_game_Player_research_rule_name00);
5442 tolua_function(tolua_S,"research_name_translation",tolua_game_Player_research_name_translation00);
5443 tolua_function(tolua_S,"culture",tolua_game_Player_culture00);
5444 tolua_function(tolua_S,"has_flag",tolua_game_Player_has_flag00);
5445 tolua_function(tolua_S,"can_upgrade",tolua_game_Player_can_upgrade00);
5446 tolua_function(tolua_S,"can_build_direct",tolua_game_Player_can_build_direct00);
5447 tolua_function(tolua_S,"can_build_direct",tolua_game_Player_can_build_direct01);
5448 tolua_function(tolua_S,"primary_capital",tolua_game_Player_primary_capital00);
5449 tolua_endmodule(tolua_S);
5450 tolua_module(tolua_S,"methods_private",0);
5451 tolua_beginmodule(tolua_S,"methods_private");
5452 tolua_function(tolua_S,"list_players",tolua_game_methods_private_list_players00);
5453 tolua_module(tolua_S,"Player",0);
5454 tolua_beginmodule(tolua_S,"Player");
5455 tolua_function(tolua_S,"unit_list_head",tolua_game_methods_private_Player_unit_list_head00);
5456 tolua_function(tolua_S,"city_list_head",tolua_game_methods_private_Player_city_list_head00);
5457 tolua_endmodule(tolua_S);
5458 tolua_endmodule(tolua_S);
5459
5460 { /* begin embedded lua code */
5461 static unsigned char B[] = {
5462 10,102,117,110, 99,116,105,111,110, 32, 80,108, 97,121,101,
5463 114, 58,105,115, 95,104,117,109, 97,110, 40, 41, 10,114,101,
5464 116,117,114,110, 32,110,111,116, 32,115,101,108,102, 46,104,
5465 97,115, 95,102,108, 97,103, 40,115,101,108,102, 44, 32, 34,
5466 65, 73, 34, 41, 59, 10,101,110,100, 10,102,117,110, 99,116,
5467 105,111,110, 32, 80,108, 97,121,101,114, 58,101,120,105,115,
5468 116,115, 40, 41, 10,114,101,116,117,114,110, 32,116,114,117,
5469 101, 10,101,110,100,32
5470 };
5471 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5472 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5473 } /* end of embedded lua code */
5474
5475 tolua_module(tolua_S,"City",0);
5476 tolua_beginmodule(tolua_S,"City");
5477 tolua_module(tolua_S,"properties",0);
5478 tolua_beginmodule(tolua_S,"properties");
5479 tolua_function(tolua_S,"size",tolua_game_City_properties_size00);
5480 tolua_function(tolua_S,"tile",tolua_game_City_properties_tile00);
5481 tolua_endmodule(tolua_S);
5482 tolua_function(tolua_S,"has_building",tolua_game_City_has_building00);
5483 tolua_function(tolua_S,"map_sq_radius",tolua_game_City_map_sq_radius00);
5484 tolua_function(tolua_S,"inspire_partisans",tolua_game_City_inspire_partisans00);
5485 tolua_function(tolua_S,"culture",tolua_game_City_culture00);
5486 tolua_function(tolua_S,"is_happy",tolua_game_City_is_happy00);
5487 tolua_function(tolua_S,"is_unhappy",tolua_game_City_is_unhappy00);
5488 tolua_function(tolua_S,"is_celebrating",tolua_game_City_is_celebrating00);
5489 tolua_function(tolua_S,"is_gov_center",tolua_game_City_is_gov_center00);
5490 tolua_function(tolua_S,"is_capital",tolua_game_City_is_capital00);
5491 tolua_function(tolua_S,"is_primary_capital",tolua_game_City_is_primary_capital00);
5492 tolua_function(tolua_S,"link_text",tolua_game_City_link_text00);
5493 tolua_function(tolua_S,"tile_link_text",tolua_game_City_tile_link_text00);
5494 tolua_endmodule(tolua_S);
5495
5496 { /* begin embedded lua code */
5497 static unsigned char B[] = {
5498 10,102,117,110, 99,116,105,111,110, 32, 67,105,116,121, 58,
5499 101,120,105,115,116,115, 40, 41, 10,114,101,116,117,114,110,
5500 32,116,114,117,101, 10,101,110,100,32
5501 };
5502 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5503 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5504 } /* end of embedded lua code */
5505
5506 tolua_module(tolua_S,"Unit",0);
5507 tolua_beginmodule(tolua_S,"Unit");
5508 tolua_module(tolua_S,"properties",0);
5509 tolua_beginmodule(tolua_S,"properties");
5510 tolua_function(tolua_S,"tile",tolua_game_Unit_properties_tile00);
5511 tolua_endmodule(tolua_S);
5512 tolua_function(tolua_S,"transporter",tolua_game_Unit_transporter00);
5513 tolua_function(tolua_S,"is_on_possible_city_tile",tolua_game_Unit_is_on_possible_city_tile00);
5514 tolua_function(tolua_S,"can_upgrade",tolua_game_Unit_can_upgrade00);
5515 tolua_function(tolua_S,"transform_problem",tolua_game_Unit_transform_problem00);
5516 tolua_function(tolua_S,"facing",tolua_game_Unit_facing00);
5517 tolua_function(tolua_S,"link_text",tolua_game_Unit_link_text00);
5518 tolua_function(tolua_S,"tile_link_text",tolua_game_Unit_tile_link_text00);
5519 tolua_function(tolua_S,"seen",tolua_game_Unit_seen00);
5520 tolua_endmodule(tolua_S);
5521 tolua_module(tolua_S,"methods_private",0);
5522 tolua_beginmodule(tolua_S,"methods_private");
5523 tolua_module(tolua_S,"Unit",0);
5524 tolua_beginmodule(tolua_S,"Unit");
5525 tolua_function(tolua_S,"cargo_list_head",tolua_game_methods_private_Unit_cargo_list_head00);
5526 tolua_endmodule(tolua_S);
5527 tolua_endmodule(tolua_S);
5528
5529 { /* begin embedded lua code */
5530 static unsigned char B[] = {
5531 10,102,117,110, 99,116,105,111,110, 32, 85,110,105,116, 58,
5532 101,120,105,115,116,115, 40, 41, 10,114,101,116,117,114,110,
5533 32,116,114,117,101, 10,101,110,100, 10,102,117,110, 99,116,
5534 105,111,110, 32, 85,110,105,116, 58,103,101,116, 95,104,111,
5535 109,101, 99,105,116,121, 40, 41, 10,114,101,116,117,114,110,
5536 32,102,105,110,100, 46, 99,105,116,121, 40,115,101,108,102,
5537 46,111,119,110,101,114, 44, 32,115,101,108,102, 46,104,111,
5538 109,101, 99,105,116,121, 41, 10,101,110,100,32
5539 };
5540 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5541 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5542 } /* end of embedded lua code */
5543
5544 tolua_module(tolua_S,"Tile",0);
5545 tolua_beginmodule(tolua_S,"Tile");
5546 tolua_module(tolua_S,"properties",0);
5547 tolua_beginmodule(tolua_S,"properties");
5548 tolua_function(tolua_S,"nat_x",tolua_game_Tile_properties_nat_x00);
5549 tolua_function(tolua_S,"nat_y",tolua_game_Tile_properties_nat_y00);
5550 tolua_function(tolua_S,"x",tolua_game_Tile_properties_x00);
5551 tolua_function(tolua_S,"y",tolua_game_Tile_properties_y00);
5552 tolua_endmodule(tolua_S);
5553 tolua_function(tolua_S,"city",tolua_game_Tile_city00);
5554 tolua_function(tolua_S,"city_exists_within_max_city_map",tolua_game_Tile_city_exists_within_max_city_map00);
5555 tolua_function(tolua_S,"has_extra",tolua_game_Tile_has_extra00);
5556 tolua_function(tolua_S,"has_base",tolua_game_Tile_has_base00);
5557 tolua_function(tolua_S,"has_road",tolua_game_Tile_has_road00);
5558 tolua_function(tolua_S,"extra_owner",tolua_game_Tile_extra_owner00);
5559 tolua_function(tolua_S,"is_enemy",tolua_game_Tile_is_enemy00);
5560 tolua_function(tolua_S,"num_units",tolua_game_Tile_num_units00);
5561 tolua_function(tolua_S,"sq_distance",tolua_game_Tile_sq_distance00);
5562 tolua_function(tolua_S,"link_text",tolua_game_Tile_link_text00);
5563 tolua_function(tolua_S,"known",tolua_game_Tile_known00);
5564 tolua_function(tolua_S,"seen",tolua_game_Tile_seen00);
5565 tolua_endmodule(tolua_S);
5566
5567 { /* begin embedded lua code */
5568 static unsigned char B[] = {
5569 10,102,117,110, 99,116,105,111,110, 32, 84,105,108,101, 58,
5570 99,105,116,121, 95,101,120,105,115,116,115, 95,119,105,116,
5571 104,105,110, 95, 99,105,116,121, 95,114, 97,100,105,117,115,
5572 40, 99,101,110,116,101,114, 41, 10,108,111,103, 46,100,101,
5573 112,114,101, 99, 97,116,105,111,110, 95,119, 97,114,110,105,
5574 110,103, 40, 34, 99,105,116,121, 95,101,120,105,115,116,115,
5575 95,119,105,116,104,105,110, 95, 99,105,116,121, 95,114, 97,
5576 100,105,117,115, 40, 41, 34, 44, 32, 34, 99,105,116,121, 95,
5577 101,120,105,115,116,115, 95,119,105,116,104,105,110, 95,109,
5578 97,120, 95, 99,105,116,121, 95,109, 97,112, 40, 41, 34, 44,
5579 10, 34, 50, 46, 51, 34, 41, 59, 10,114,101,116,117,114,110,
5580 32,115,101,108,102, 58, 99,105,116,121, 95,101,120,105,115,
5581 116,115, 95,119,105,116,104,105,110, 95,109, 97,120, 95, 99,
5582 105,116,121, 95,109, 97,112, 40, 99,101,110,116,101,114, 41,
5583 10,101,110,100,32
5584 };
5585 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5586 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5587 } /* end of embedded lua code */
5588
5589 tolua_module(tolua_S,"methods_private",0);
5590 tolua_beginmodule(tolua_S,"methods_private");
5591 tolua_module(tolua_S,"Tile",0);
5592 tolua_beginmodule(tolua_S,"Tile");
5593 tolua_function(tolua_S,"next_outward_index",tolua_game_methods_private_Tile_next_outward_index00);
5594 tolua_function(tolua_S,"tile_for_outward_index",tolua_game_methods_private_Tile_tile_for_outward_index00);
5595 tolua_function(tolua_S,"unit_list_head",tolua_game_methods_private_Tile_unit_list_head00);
5596 tolua_endmodule(tolua_S);
5597 tolua_endmodule(tolua_S);
5598 tolua_module(tolua_S,"Government",0);
5599 tolua_beginmodule(tolua_S,"Government");
5600 tolua_function(tolua_S,"rule_name",tolua_game_Government_rule_name00);
5601 tolua_function(tolua_S,"name_translation",tolua_game_Government_name_translation00);
5602 tolua_endmodule(tolua_S);
5603 tolua_module(tolua_S,"Nation_Type",0);
5604 tolua_beginmodule(tolua_S,"Nation_Type");
5605 tolua_function(tolua_S,"rule_name",tolua_game_Nation_Type_rule_name00);
5606 tolua_function(tolua_S,"name_translation",tolua_game_Nation_Type_name_translation00);
5607 tolua_function(tolua_S,"plural_translation",tolua_game_Nation_Type_plural_translation00);
5608 tolua_endmodule(tolua_S);
5609 tolua_module(tolua_S,"Building_Type",0);
5610 tolua_beginmodule(tolua_S,"Building_Type");
5611 tolua_function(tolua_S,"is_wonder",tolua_game_Building_Type_is_wonder00);
5612 tolua_function(tolua_S,"is_great_wonder",tolua_game_Building_Type_is_great_wonder00);
5613 tolua_function(tolua_S,"is_small_wonder",tolua_game_Building_Type_is_small_wonder00);
5614 tolua_function(tolua_S,"is_improvement",tolua_game_Building_Type_is_improvement00);
5615 tolua_function(tolua_S,"rule_name",tolua_game_Building_Type_rule_name00);
5616 tolua_function(tolua_S,"name_translation",tolua_game_Building_Type_name_translation00);
5617 tolua_endmodule(tolua_S);
5618
5619 { /* begin embedded lua code */
5620 static unsigned char B[] = {
5621 10,102,117,110, 99,116,105,111,110, 32, 66,117,105,108,100,
5622 105,110,103, 95, 84,121,112,101, 58, 98,117,105,108,100, 95,
5623 115,104,105,101,108,100, 95, 99,111,115,116, 40, 41, 10,114,
5624 101,116,117,114,110, 32,115,101,108,102, 46, 98,117,105,108,
5625 100, 95, 99,111,115,116, 10,101,110,100,32
5626 };
5627 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5628 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5629 } /* end of embedded lua code */
5630
5631 tolua_module(tolua_S,"Unit_Type",0);
5632 tolua_beginmodule(tolua_S,"Unit_Type");
5633 tolua_function(tolua_S,"has_flag",tolua_game_Unit_Type_has_flag00);
5634 tolua_function(tolua_S,"has_role",tolua_game_Unit_Type_has_role00);
5635 tolua_function(tolua_S,"rule_name",tolua_game_Unit_Type_rule_name00);
5636 tolua_function(tolua_S,"name_translation",tolua_game_Unit_Type_name_translation00);
5637 tolua_function(tolua_S,"can_exist_at_tile",tolua_game_Unit_Type_can_exist_at_tile00);
5638 tolua_endmodule(tolua_S);
5639
5640 { /* begin embedded lua code */
5641 static unsigned char B[] = {
5642 10,102,117,110, 99,116,105,111,110, 32, 85,110,105,116, 95,
5643 84,121,112,101, 58, 98,117,105,108,100, 95,115,104,105,101,
5644 108,100, 95, 99,111,115,116, 40, 41, 10,114,101,116,117,114,
5645 110, 32,115,101,108,102, 46, 98,117,105,108,100, 95, 99,111,
5646 115,116, 10,101,110,100,32
5647 };
5648 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5649 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5650 } /* end of embedded lua code */
5651
5652 tolua_module(tolua_S,"Tech_Type",0);
5653 tolua_beginmodule(tolua_S,"Tech_Type");
5654 tolua_function(tolua_S,"rule_name",tolua_game_Tech_Type_rule_name00);
5655 tolua_function(tolua_S,"name_translation",tolua_game_Tech_Type_name_translation00);
5656 tolua_endmodule(tolua_S);
5657
5658 { /* begin embedded lua code */
5659 static unsigned char B[] = {
5660 10,108,111, 99, 97,108, 32,112,116, 99,111,115,116, 32, 61,
5661 32, 80,108, 97,121,101,114, 46,116,101, 99,104, 95, 99,111,
5662 115,116, 10,102,117,110, 99,116,105,111,110, 32, 84,101, 99,
5663 104, 95, 84,121,112,101, 58, 99,111,115,116, 40, 41, 10,114,
5664 101,116,117,114,110, 32,112,116, 99,111,115,116, 40,110,105,
5665 108, 44, 32,115,101,108,102, 41, 10,101,110,100,32
5666 };
5667 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5668 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5669 } /* end of embedded lua code */
5670
5671 tolua_module(tolua_S,"Terrain",0);
5672 tolua_beginmodule(tolua_S,"Terrain");
5673 tolua_function(tolua_S,"rule_name",tolua_game_Terrain_rule_name00);
5674 tolua_function(tolua_S,"name_translation",tolua_game_Terrain_name_translation00);
5675 tolua_function(tolua_S,"class_name",tolua_game_Terrain_class_name00);
5676 tolua_endmodule(tolua_S);
5677 tolua_module(tolua_S,"Disaster",0);
5678 tolua_beginmodule(tolua_S,"Disaster");
5679 tolua_function(tolua_S,"rule_name",tolua_game_Disaster_rule_name00);
5680 tolua_function(tolua_S,"name_translation",tolua_game_Disaster_name_translation00);
5681 tolua_endmodule(tolua_S);
5682 tolua_module(tolua_S,"Achievement",0);
5683 tolua_beginmodule(tolua_S,"Achievement");
5684 tolua_function(tolua_S,"rule_name",tolua_game_Achievement_rule_name00);
5685 tolua_function(tolua_S,"name_translation",tolua_game_Achievement_name_translation00);
5686 tolua_endmodule(tolua_S);
5687 tolua_module(tolua_S,"Action",0);
5688 tolua_beginmodule(tolua_S,"Action");
5689 tolua_function(tolua_S,"rule_name",tolua_game_Action_rule_name00);
5690 tolua_function(tolua_S,"name_translation",tolua_game_Action_name_translation00);
5691 tolua_function(tolua_S,"target_kind",tolua_game_Action_target_kind00);
5692 tolua_endmodule(tolua_S);
5693 tolua_module(tolua_S,"Unit_List_Link",0);
5694 tolua_beginmodule(tolua_S,"Unit_List_Link");
5695 tolua_function(tolua_S,"data",tolua_game_Unit_List_Link_data00);
5696 tolua_function(tolua_S,"next",tolua_game_Unit_List_Link_next00);
5697 tolua_endmodule(tolua_S);
5698 tolua_module(tolua_S,"City_List_Link",0);
5699 tolua_beginmodule(tolua_S,"City_List_Link");
5700 tolua_function(tolua_S,"data",tolua_game_City_List_Link_data00);
5701 tolua_function(tolua_S,"next",tolua_game_City_List_Link_next00);
5702 tolua_endmodule(tolua_S);
5703 tolua_module(tolua_S,"find",0);
5704 tolua_beginmodule(tolua_S,"find");
5705 tolua_function(tolua_S,"counter",tolua_game_find_counter00);
5706 tolua_function(tolua_S,"counter",tolua_game_find_counter01);
5707 tolua_function(tolua_S,"player",tolua_game_find_player00);
5708 tolua_function(tolua_S,"player",tolua_game_find_player01);
5709 tolua_function(tolua_S,"city",tolua_game_find_city00);
5710 tolua_function(tolua_S,"unit",tolua_game_find_unit00);
5711 tolua_function(tolua_S,"transport_unit",tolua_game_find_transport_unit00);
5712 tolua_function(tolua_S,"tile",tolua_game_find_tile00);
5713 tolua_function(tolua_S,"tile",tolua_game_find_tile01);
5714 tolua_function(tolua_S,"government",tolua_game_find_government00);
5715 tolua_function(tolua_S,"government",tolua_game_find_government01);
5716 tolua_function(tolua_S,"nation_type",tolua_game_find_nation_type00);
5717 tolua_function(tolua_S,"nation_type",tolua_game_find_nation_type01);
5718 tolua_function(tolua_S,"action",tolua_game_find_action00);
5719 tolua_function(tolua_S,"action",tolua_game_find_action01);
5720 tolua_function(tolua_S,"building_type",tolua_game_find_building_type00);
5721 tolua_function(tolua_S,"building_type",tolua_game_find_building_type01);
5722 tolua_function(tolua_S,"unit_type",tolua_game_find_unit_type00);
5723 tolua_function(tolua_S,"unit_type",tolua_game_find_unit_type01);
5724 tolua_function(tolua_S,"role_unit_type",tolua_game_find_role_unit_type00);
5725 tolua_function(tolua_S,"tech_type",tolua_game_find_tech_type00);
5726 tolua_function(tolua_S,"tech_type",tolua_game_find_tech_type01);
5727 tolua_function(tolua_S,"terrain",tolua_game_find_terrain00);
5728 tolua_function(tolua_S,"terrain",tolua_game_find_terrain01);
5729 tolua_function(tolua_S,"achievement",tolua_game_find_achievement00);
5730 tolua_function(tolua_S,"achievement",tolua_game_find_achievement01);
5731 tolua_function(tolua_S,"achievement",tolua_game_find_achievement02);
5732 tolua_function(tolua_S,"disaster",tolua_game_find_disaster00);
5733 tolua_function(tolua_S,"direction",tolua_game_find_direction00);
5734 tolua_function(tolua_S,"direction",tolua_game_find_direction01);
5735 tolua_function(tolua_S,"action",tolua_game_find_action02);
5736 tolua_function(tolua_S,"action",tolua_game_find_action03);
5737 tolua_function(tolua_S,"nonexistent",tolua_game_find_nonexistent00);
5738 tolua_endmodule(tolua_S);
5739
5740 { /* begin embedded lua code */
5741 static unsigned char B[] = {
5742 10,108,111, 99, 97,108, 32,103, 97,109,101, 95,105,110,102,
5743 111, 32, 61, 32,103, 97,109,101, 46,105,110,102,111, 10,102,
5744 117,110, 99,116,105,111,110, 32,102,105,110,100, 46,103, 97,
5745 109,101, 95,105,110,102,111, 40, 41, 10,114,101,116,117,114,
5746 110, 32,103, 97,109,101, 95,105,110,102,111, 10,101,110,100,
5747 32
5748 };
5749 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5750 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5751 } /* end of embedded lua code */
5752
5753 tolua_module(tolua_S,"E",0);
5754 tolua_beginmodule(tolua_S,"E");
5755 tolua_endmodule(tolua_S);
5756 tolua_module(tolua_S,"effects",0);
5757 tolua_beginmodule(tolua_S,"effects");
5758 tolua_function(tolua_S,"world_bonus",tolua_game_effects_world_bonus00);
5759 tolua_function(tolua_S,"player_bonus",tolua_game_effects_player_bonus00);
5760 tolua_function(tolua_S,"city_bonus",tolua_game_effects_city_bonus00);
5761 tolua_function(tolua_S,"unit_bonus",tolua_game_effects_unit_bonus00);
5762 tolua_function(tolua_S,"tile_bonus",tolua_game_effects_tile_bonus00);
5763 tolua_function(tolua_S,"unit_vs_tile_bonus",tolua_game_effects_unit_vs_tile_bonus00);
5764 tolua_endmodule(tolua_S);
5765 tolua_module(tolua_S,"Direction",0);
5766 tolua_beginmodule(tolua_S,"Direction");
5767 tolua_module(tolua_S,"properties",0);
5768 tolua_beginmodule(tolua_S,"properties");
5769 tolua_function(tolua_S,"id",tolua_game_Direction_properties_id00);
5770 tolua_function(tolua_S,"name",tolua_game_Direction_properties_name00);
5771 tolua_function(tolua_S,"cardinal",tolua_game_Direction_properties_cardinal00);
5772 tolua_endmodule(tolua_S);
5773 tolua_endmodule(tolua_S);
5774 tolua_module(tolua_S,"direction",0);
5775 tolua_beginmodule(tolua_S,"direction");
5776 tolua_function(tolua_S,"str2dir",tolua_game_direction_str2dir00);
5777 tolua_function(tolua_S,"next_ccw",tolua_game_direction_next_ccw00);
5778 tolua_function(tolua_S,"next_cw",tolua_game_direction_next_cw00);
5779 tolua_function(tolua_S,"opposite",tolua_game_direction_opposite00);
5780 tolua_endmodule(tolua_S);
5781
5782 { /* begin embedded lua code */
5783 static unsigned char B[] = {
5784 10,102,117,110, 99,116,105,111,110, 32,115,116,114, 50,100,
5785 105,114,101, 99,116,105,111,110, 40,115,116,114, 41, 10,114,
5786 101,116,117,114,110, 32,100,105,114,101, 99,116,105,111,110,
5787 46,115,116,114, 50,100,105,114, 40,115,116,114, 41, 10,101,
5788 110,100, 10, 68,105,114,101, 99,116,105,111,110, 46,112,114,
5789 111,112,101,114,116,105,101,115, 46,110,101,120,116, 95, 99,
5790 99,119, 32, 61, 32,100,105,114,101, 99,116,105,111,110, 46,
5791 110,101,120,116, 95, 99, 99,119, 10, 68,105,114,101, 99,116,
5792 105,111,110, 46,112,114,111,112,101,114,116,105,101,115, 46,
5793 110,101,120,116, 95, 99,119, 32, 61, 32,100,105,114,101, 99,
5794 116,105,111,110, 46,110,101,120,116, 95, 99,119, 10, 68,105,
5795 114,101, 99,116,105,111,110, 46,112,114,111,112,101,114,116,
5796 105,101,115, 46,111,112,112,111,115,105,116,101, 32, 61, 32,
5797 100,105,114,101, 99,116,105,111,110, 46,111,112,112,111,115,
5798 105,116,101,32
5799 };
5800 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5801 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5802 } /* end of embedded lua code */
5803
5804 tolua_module(tolua_S,"Game_Info",0);
5805 tolua_beginmodule(tolua_S,"Game_Info");
5806 tolua_endmodule(tolua_S);
5807
5808 { /* begin embedded lua code */
5809 static unsigned char B[] = {
5810 10,100,111, 10,108,111, 99, 97,108, 32,112,114,105,118, 97,
5811 116,101, 32, 61, 32,109,101,116,104,111,100,115, 95,112,114,
5812 105,118, 97,116,101, 10,108,111, 99, 97,108, 32,102,117,110,
5813 99,116,105,111,110, 32,118, 97,108,117,101, 95,105,116,101,
5814 114, 97,116,111,114, 40, 97,114,114, 97,121, 41, 10,108,111,
5815 99, 97,108, 32,105, 32, 61, 32, 48, 10,108,111, 99, 97,108,
5816 32,102,117,110, 99,116,105,111,110, 32,105,116,101,114, 97,
5817 116,111,114, 40, 41, 10,105, 32, 61, 32,105, 32, 43, 32, 49,
5818 10,114,101,116,117,114,110, 32, 97,114,114, 97,121, 91,105,
5819 93, 10,101,110,100, 10,114,101,116,117,114,110, 32,105,116,
5820 101,114, 97,116,111,114, 10,101,110,100, 10,108,111, 99, 97,
5821 108, 32,102,117,110, 99,116,105,111,110, 32,115, 97,102,101,
5822 95,105,116,101,114, 97,116,101, 95,108,105,115,116, 40,108,
5823 105,110,107, 41, 10,108,111, 99, 97,108, 32,111, 98,106,115,
5824 32, 61, 32,123,125, 10,119,104,105,108,101, 32,108,105,110,
5825 107, 32,100,111, 10,111, 98,106,115, 91, 35,111, 98,106,115,
5826 32, 43, 32, 49, 93, 32, 61, 32,108,105,110,107, 58,100, 97,
5827 116, 97, 40, 41, 10,108,105,110,107, 32, 61, 32,108,105,110,
5828 107, 58,110,101,120,116, 40, 41, 10,101,110,100, 10,114,101,
5829 116,117,114,110, 32,118, 97,108,117,101, 95,105,116,101,114,
5830 97,116,111,114, 40,111, 98,106,115, 41, 10,101,110,100, 10,
5831 102,117,110, 99,116,105,111,110, 32, 80,108, 97,121,101,114,
5832 58,117,110,105,116,115, 95,105,116,101,114, 97,116,101, 40,
5833 41, 10,114,101,116,117,114,110, 32,115, 97,102,101, 95,105,
5834 116,101,114, 97,116,101, 95,108,105,115,116, 40,112,114,105,
5835 118, 97,116,101, 46, 80,108, 97,121,101,114, 46,117,110,105,
5836 116, 95,108,105,115,116, 95,104,101, 97,100, 40,115,101,108,
5837 102, 41, 41, 10,101,110,100, 10,102,117,110, 99,116,105,111,
5838 110, 32, 80,108, 97,121,101,114, 58, 99,105,116,105,101,115,
5839 95,105,116,101,114, 97,116,101, 40, 41, 10,114,101,116,117,
5840 114,110, 32,115, 97,102,101, 95,105,116,101,114, 97,116,101,
5841 95,108,105,115,116, 40,112,114,105,118, 97,116,101, 46, 80,
5842 108, 97,121,101,114, 46, 99,105,116,121, 95,108,105,115,116,
5843 95,104,101, 97,100, 40,115,101,108,102, 41, 41, 10,101,110,
5844 100, 10,102,117,110, 99,116,105,111,110, 32, 84,105,108,101,
5845 58,117,110,105,116,115, 95,105,116,101,114, 97,116,101, 40,
5846 41, 10,114,101,116,117,114,110, 32,115, 97,102,101, 95,105,
5847 116,101,114, 97,116,101, 95,108,105,115,116, 40,112,114,105,
5848 118, 97,116,101, 46, 84,105,108,101, 46,117,110,105,116, 95,
5849 108,105,115,116, 95,104,101, 97,100, 40,115,101,108,102, 41,
5850 41, 10,101,110,100, 10,102,117,110, 99,116,105,111,110, 32,
5851 85,110,105,116, 58, 99, 97,114,103,111, 95,105,116,101,114,
5852 97,116,101, 40, 41, 10,114,101,116,117,114,110, 32,115, 97,
5853 102,101, 95,105,116,101,114, 97,116,101, 95,108,105,115,116,
5854 40,112,114,105,118, 97,116,101, 46, 85,110,105,116, 46, 99,
5855 97,114,103,111, 95,108,105,115,116, 95,104,101, 97,100, 40,
5856 115,101,108,102, 41, 41, 10,101,110,100, 10,101,110,100, 10,
5857 100,111, 10,108,111, 99, 97,108, 32,110,101,120,116, 95,111,
5858 117,116,119, 97,114,100, 95,105,110,100,101,120, 32, 61, 32,
5859 109,101,116,104,111,100,115, 95,112,114,105,118, 97,116,101,
5860 46, 84,105,108,101, 46,110,101,120,116, 95,111,117,116,119,
5861 97,114,100, 95,105,110,100,101,120, 10,108,111, 99, 97,108,
5862 32,116,105,108,101, 95,102,111,114, 95,111,117,116,119, 97,
5863 114,100, 95,105,110,100,101,120, 32, 61, 32,109,101,116,104,
5864 111,100,115, 95,112,114,105,118, 97,116,101, 46, 84,105,108,
5865 101, 46,116,105,108,101, 95,102,111,114, 95,111,117,116,119,
5866 97,114,100, 95,105,110,100,101,120, 10,102,117,110, 99,116,
5867 105,111,110, 32, 84,105,108,101, 58,115,113,117, 97,114,101,
5868 95,105,116,101,114, 97,116,101, 40,114, 97,100,105,117,115,
5869 41, 10,108,111, 99, 97,108, 32,105,110,100,101,120, 32, 61,
5870 32, 45, 49, 10,108,111, 99, 97,108, 32,102,117,110, 99,116,
5871 105,111,110, 32,105,116,101,114, 97,116,111,114, 40, 41, 10,
5872 105,110,100,101,120, 32, 61, 32,110,101,120,116, 95,111,117,
5873 116,119, 97,114,100, 95,105,110,100,101,120, 40,115,101,108,
5874 102, 44, 32,105,110,100,101,120, 44, 32,114, 97,100,105,117,
5875 115, 41, 10,105,102, 32,105,110,100,101,120, 32, 60, 32, 48,
5876 32,116,104,101,110, 10,114,101,116,117,114,110, 32,110,105,
5877 108, 10,101,108,115,101, 10,114,101,116,117,114,110, 32,116,
5878 105,108,101, 95,102,111,114, 95,111,117,116,119, 97,114,100,
5879 95,105,110,100,101,120, 40,115,101,108,102, 44, 32,105,110,
5880 100,101,120, 41, 10,101,110,100, 10,101,110,100, 10,114,101,
5881 116,117,114,110, 32,105,116,101,114, 97,116,111,114, 10,101,
5882 110,100, 10,102,117,110, 99,116,105,111,110, 32, 84,105,108,
5883 101, 58, 99,105,114, 99,108,101, 95,105,116,101,114, 97,116,
5884 101, 40,115,113, 95,114, 97,100,105,117,115, 41, 10,108,111,
5885 99, 97,108, 32, 99,114, 95,114, 97,100,105,117,115, 32, 61,
5886 32,109, 97,116,104, 46,102,108,111,111,114, 40,109, 97,116,
5887 104, 46,115,113,114,116, 40,115,113, 95,114, 97,100,105,117,
5888 115, 41, 41, 10,108,111, 99, 97,108, 32,115,113, 95,105,116,
5889 101,114, 32, 61, 32,115,101,108,102, 58,115,113,117, 97,114,
5890 101, 95,105,116,101,114, 97,116,101, 40, 99,114, 95,114, 97,
5891 100,105,117,115, 41, 10,108,111, 99, 97,108, 32,102,117,110,
5892 99,116,105,111,110, 32,105,116,101,114, 97,116,111,114, 40,
5893 41, 10,108,111, 99, 97,108, 32,116,105,108,101, 32, 61, 32,
5894 110,105,108, 10,114,101,112,101, 97,116, 10,116,105,108,101,
5895 32, 61, 32,115,113, 95,105,116,101,114, 40, 41, 10,117,110,
5896 116,105,108, 32,110,111,116, 32,116,105,108,101, 32,111,114,
5897 32,115,101,108,102, 58,115,113, 95,100,105,115,116, 97,110,
5898 99,101, 40,116,105,108,101, 41, 32, 60, 61, 32,115,113, 95,
5899 114, 97,100,105,117,115, 10,114,101,116,117,114,110, 32,116,
5900 105,108,101, 10,101,110,100, 10,114,101,116,117,114,110, 32,
5901 105,116,101,114, 97,116,111,114, 10,101,110,100, 10,101,110,
5902 100,32
5903 };
5904 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5905 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5906 } /* end of embedded lua code */
5907
5908
5909 { /* begin embedded lua code */
5910 static unsigned char B[] = {
5911 10,100,111, 10,108,111, 99, 97,108, 32,102,117,110, 99,116,
5912 105,111,110, 32,105,110,100,101,120, 95,105,116,101,114, 97,
5913 116,101, 40,108,111,111,107,117,112, 41, 10,108,111, 99, 97,
5914 108, 32,105,110,100,101,120, 32, 61, 32, 45, 49, 10,108,111,
5915 99, 97,108, 32,102,117,110, 99,116,105,111,110, 32,105,116,
5916 101,114, 97,116,111,114, 40, 41, 10,105,110,100,101,120, 32,
5917 61, 32,105,110,100,101,120, 32, 43, 32, 49, 10,114,101,116,
5918 117,114,110, 32,108,111,111,107,117,112, 40,105,110,100,101,
5919 120, 41, 10,101,110,100, 10,114,101,116,117,114,110, 32,105,
5920 116,101,114, 97,116,111,114, 10,101,110,100, 10,108,111, 99,
5921 97,108, 32,108,105,115,116,112, 32, 61, 32,109,101,116,104,
5922 111,100,115, 95,112,114,105,118, 97,116,101, 46,108,105,115,
5923 116, 95,112,108, 97,121,101,114,115, 10,102,117,110, 99,116,
5924 105,111,110, 32,112,108, 97,121,101,114,115, 95,105,116,101,
5925 114, 97,116,101, 40, 41, 10,108,111, 99, 97,108, 32,112,108,
5926 105,115,116, 32, 61, 32,108,105,115,116,112, 40, 41, 10,108,
5927 111, 99, 97,108, 32,105,110,100,101,120, 32, 61, 32, 48, 10,
5928 114,101,116,117,114,110, 32,102,117,110, 99,116,105,111,110,
5929 40, 41, 10,105,110,100,101,120, 32, 61, 32,105,110,100,101,
5930 120, 32, 43, 32, 49, 10,114,101,116,117,114,110, 32,112,108,
5931 105,115,116, 91,105,110,100,101,120, 93, 10,101,110,100, 10,
5932 101,110,100, 10,102,117,110, 99,116,105,111,110, 32,119,104,
5933 111,108,101, 95,109, 97,112, 95,105,116,101,114, 97,116,101,
5934 40, 41, 10,114,101,116,117,114,110, 32,105,110,100,101,120,
5935 95,105,116,101,114, 97,116,101, 40,102,105,110,100, 46,116,
5936 105,108,101, 41, 10,101,110,100, 10,101,110,100,32
5937 };
5938 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5939 lua_pcall(tolua_S,0,LUA_MULTRET,0);
5940 } /* end of embedded lua code */
5941
5942 tolua_endmodule(tolua_S);
5943 return 1;
5944}
5945/* Open tolua function */
5946TOLUA_API int tolua_game_open (lua_State* tolua_S)
5947{
5948 lua_pushcfunction(tolua_S, luaopen_game);
5949 lua_pushstring(tolua_S, "game");
5950 lua_call(tolua_S, 1, 0);
5951 return 1;
5952}
api_utilities_dir_cw
const Direction * api_utilities_dir_cw(lua_State *L, Direction dir)
Definition api_common_utilities.c:194
api_utilities_dir2str
const char * api_utilities_dir2str(lua_State *L, Direction dir)
Definition api_common_utilities.c:156
api_utilities_opposite_dir
const Direction * api_utilities_opposite_dir(lua_State *L, Direction dir)
Definition api_common_utilities.c:211
api_utilities_direction_is_cardinal
bool api_utilities_direction_is_cardinal(lua_State *L, Direction dir)
Definition api_common_utilities.c:221
api_utilities_str2dir
const Direction * api_utilities_str2dir(lua_State *L, const char *dir)
Definition api_common_utilities.c:167
api_utilities_direction_id
int api_utilities_direction_id(lua_State *L, Direction dir)
Definition api_common_utilities.c:146
api_utilities_dir_ccw
const Direction * api_utilities_dir_ccw(lua_State *L, Direction dir)
Definition api_common_utilities.c:178
api_common_utilities.h
api_effects_tile_bonus
int api_effects_tile_bonus(lua_State *L, Tile *ptile, City *pcity, const char *output_id, const char *effect_type)
Definition api_game_effects.c:124
api_effects_unit_vs_tile_bonus
int api_effects_unit_vs_tile_bonus(lua_State *L, Unit *punit, Tile *ptile, const char *effect_type)
Definition api_game_effects.c:168
api_effects_player_bonus
int api_effects_player_bonus(lua_State *L, Player *pplayer, const char *effect_type)
Definition api_game_effects.c:46
api_effects_city_bonus
int api_effects_city_bonus(lua_State *L, City *pcity, const char *effect_type)
Definition api_game_effects.c:65
api_effects_unit_bonus
int api_effects_unit_bonus(lua_State *L, Unit *punit, Player *other_player, const char *effect_type)
Definition api_game_effects.c:85
api_effects_world_bonus
int api_effects_world_bonus(lua_State *L, const char *effect_type)
Definition api_game_effects.c:29
api_game_effects.h
api_find_nation_type
Nation_Type * api_find_nation_type(lua_State *L, int nation_type_id)
Definition api_game_find.c:174
api_find_tile
Tile * api_find_tile(lua_State *L, int nat_x, int nat_y)
Definition api_game_find.c:132
api_find_unit_type
Unit_Type * api_find_unit_type(lua_State *L, int unit_type_id)
Definition api_game_find.c:240
api_find_government_by_name
Government * api_find_government_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:162
api_find_player
Player * api_find_player(lua_State *L, int player_id)
Definition api_game_find.c:42
api_find_achievement_by_name
Achievement * api_find_achievement_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:313
api_find_achievement
Achievement * api_find_achievement(lua_State *L, int achievement_id)
Definition api_game_find.c:303
api_find_role_unit_type
Unit_Type * api_find_role_unit_type(lua_State *L, const char *role_name, Player *pplayer)
Definition api_game_find.c:103
api_find_direction
const Direction * api_find_direction(lua_State *L, int id)
Definition api_game_find.c:345
api_find_action_type_by_name
Action * api_find_action_type_by_name(lua_State *L, const char *name)
Definition api_game_find.c:365
api_find_tile_by_index
Tile * api_find_tile_by_index(lua_State *L, int tindex)
Definition api_game_find.c:142
api_find_building_type_by_name
Building_Type * api_find_building_type_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:228
api_find_nation_type_by_name
Nation_Type * api_find_nation_type_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:184
api_find_disaster
Disaster * api_find_disaster(lua_State *L, int disaster_id)
Definition api_game_find.c:324
api_find_tech_type_by_name
Tech_Type * api_find_tech_type_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:271
api_find_government
Government * api_find_government(lua_State *L, int government_id)
Definition api_game_find.c:152
api_find_disaster_by_name
Disaster * api_find_disaster_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:334
api_find_counter
Counter * api_find_counter(lua_State *L, int counter_id)
Definition api_game_find.c:376
api_find_building_type
Building_Type * api_find_building_type(lua_State *L, int building_type_id)
Definition api_game_find.c:218
api_find_action_type_by_id
Action * api_find_action_type_by_id(lua_State *L, int id)
Definition api_game_find.c:355
api_find_action_by_name
Action * api_find_action_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:206
api_find_nonexistent
Nonexistent * api_find_nonexistent(lua_State *L)
Definition api_game_find.c:397
api_find_player_by_name
Player * api_find_player_by_name(lua_State *L, const char *name)
Definition api_game_find.c:32
api_find_transport_unit
Unit * api_find_transport_unit(lua_State *L, Player *pplayer, Unit_Type *ptype, Tile *ptile)
Definition api_game_find.c:80
api_find_tech_type
Tech_Type * api_find_tech_type(lua_State *L, int tech_type_id)
Definition api_game_find.c:261
api_find_city
City * api_find_city(lua_State *L, Player *pplayer, int city_id)
Definition api_game_find.c:52
api_find_unit
Unit * api_find_unit(lua_State *L, Player *pplayer, int unit_id)
Definition api_game_find.c:66
api_find_action
Action * api_find_action(lua_State *L, action_id act_id)
Definition api_game_find.c:196
api_find_terrain
Terrain * api_find_terrain(lua_State *L, int terrain_id)
Definition api_game_find.c:282
api_find_terrain_by_name
Terrain * api_find_terrain_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:292
api_find_counter_by_name
Counter * api_find_counter_by_name(lua_State *L, const char *name)
Definition api_game_find.c:386
api_find_unit_type_by_name
Unit_Type * api_find_unit_type_by_name(lua_State *L, const char *name_orig)
Definition api_game_find.c:250
api_game_find.h
api_methods_tile_nat_x
int api_methods_tile_nat_x(lua_State *L, Tile *ptile)
Definition api_game_methods.c:1077
api_methods_tile_num_units
int api_methods_tile_num_units(lua_State *L, Tile *ptile)
Definition api_game_methods.c:1284
api_methods_is_city_unhappy
bool api_methods_is_city_unhappy(lua_State *L, City *pcity)
Definition api_game_methods.c:354
api_methods_is_gov_center
bool api_methods_is_gov_center(lua_State *L, City *pcity)
Definition api_game_methods.c:377
api_methods_game_rulesetdir
const char * api_methods_game_rulesetdir(lua_State *L)
Definition api_game_methods.c:107
api_methods_player_future
int api_methods_player_future(lua_State *L, Player *pplayer)
Definition api_game_methods.c:696
api_methods_unit_type_can_exist_at_tile
bool api_methods_unit_type_can_exist_at_tile(lua_State *L, Unit_Type *punit_type, Tile *ptile)
Definition api_game_methods.c:1513
api_methods_player_num_cities
int api_methods_player_num_cities(lua_State *L, Player *pplayer)
Definition api_game_methods.c:519
api_methods_unit_can_upgrade
bool api_methods_unit_can_upgrade(lua_State *L, Unit *punit, bool is_free)
Definition api_game_methods.c:795
api_methods_player_has_wonder
bool api_methods_player_has_wonder(lua_State *L, Player *pplayer, Building_Type *building)
Definition api_game_methods.c:495
api_methods_unit_list_next_link
Unit_List_Link * api_methods_unit_list_next_link(lua_State *L, Unit_List_Link *ul_link)
Definition api_game_methods.c:1563
api_methods_nation_type_plural_translation
const char * api_methods_nation_type_plural_translation(lua_State *L, Nation_Type *pnation)
Definition api_game_methods.c:458
api_methods_disaster_name_translation
const char * api_methods_disaster_name_translation(lua_State *L, Disaster *pdis)
Definition api_game_methods.c:1003
api_methods_unit_list_link_data
Unit * api_methods_unit_list_link_data(lua_State *L, Unit_List_Link *ul_link)
Definition api_game_methods.c:1552
api_methods_tile_nat_y
int api_methods_tile_nat_y(lua_State *L, Tile *ptile)
Definition api_game_methods.c:1088
api_methods_private_tile_unit_list_head
Unit_List_Link * api_methods_private_tile_unit_list_head(lua_State *L, Tile *ptile)
Definition api_game_methods.c:1295
api_methods_player_tech_cost
int api_methods_player_tech_cost(lua_State *L, Player *pplayer, Tech_Type *ptech)
Definition api_game_methods.c:602
api_methods_player_researching
lua_Object api_methods_player_researching(lua_State *L, Player *pplayer)
Definition api_game_methods.c:626
api_methods_game_year_fragment
int api_methods_game_year_fragment(lua_State *L)
Definition api_game_methods.c:70
api_methods_counter_name_translation
const char * api_methods_counter_name_translation(lua_State *L, Counter *c)
Definition api_game_methods.c:322
api_methods_city_culture_get
int api_methods_city_culture_get(lua_State *L, City *pcity)
Definition api_game_methods.c:301
api_methods_unit_type_name_translation
const char * api_methods_unit_type_name_translation(lua_State *L, Unit_Type *punit_type)
Definition api_game_methods.c:1539
api_methods_game_ruleset_name
const char * api_methods_game_ruleset_name(lua_State *L)
Definition api_game_methods.c:115
api_methods_building_type_rule_name
const char * api_methods_building_type_rule_name(lua_State *L, Building_Type *pbuilding)
Definition api_game_methods.c:187
api_methods_unit_seen
bool api_methods_unit_seen(lua_State *L, Unit *self, Player *watcher)
Definition api_game_methods.c:842
api_methods_city_list_link_data
City * api_methods_city_list_link_data(lua_State *L, City_List_Link *cl_link)
Definition api_game_methods.c:1574
api_methods_unit_tile_link
const char * api_methods_unit_tile_link(lua_State *L, Unit *punit)
Definition api_game_methods.c:1607
api_methods_counter_rule_name
const char * api_methods_counter_rule_name(lua_State *L, Counter *c)
Definition api_game_methods.c:312
api_methods_player_can_build_impr_direct
bool api_methods_player_can_build_impr_direct(lua_State *L, Player *pplayer, Building_Type *itype)
Definition api_game_methods.c:770
api_methods_player_num_units
int api_methods_player_num_units(lua_State *L, Player *pplayer)
Definition api_game_methods.c:530
api_methods_tech_type_rule_name
const char * api_methods_tech_type_rule_name(lua_State *L, Tech_Type *ptech)
Definition api_game_methods.c:935
api_methods_tile_map_x
int api_methods_tile_map_x(lua_State *L, Tile *ptile)
Definition api_game_methods.c:1099
api_methods_is_city_happy
bool api_methods_is_city_happy(lua_State *L, City *pcity)
Definition api_game_methods.c:342
api_methods_achievement_rule_name
const char * api_methods_achievement_rule_name(lua_State *L, Achievement *pach)
Definition api_game_methods.c:1015
api_methods_player_can_upgrade
Unit_Type * api_methods_player_can_upgrade(lua_State *L, Player *pplayer, Unit_Type *utype)
Definition api_game_methods.c:743
api_methods_city_link
const char * api_methods_city_link(lua_State *L, City *pcity)
Definition api_game_methods.c:1640
api_methods_nation_type_name_translation
const char * api_methods_nation_type_name_translation(lua_State *L, Nation_Type *pnation)
Definition api_game_methods.c:446
api_methods_government_rule_name
const char * api_methods_government_rule_name(lua_State *L, Government *pgovernment)
Definition api_game_methods.c:410
api_methods_terrain_rule_name
const char * api_methods_terrain_rule_name(lua_State *L, Terrain *pterrain)
Definition api_game_methods.c:958
api_methods_player_number
int api_methods_player_number(lua_State *L, Player *pplayer)
Definition api_game_methods.c:508
api_methods_player_infrapoints
int api_methods_player_infrapoints(lua_State *L, Player *pplayer)
Definition api_game_methods.c:552
api_methods_private_unit_cargo_list_head
Unit_List_Link * api_methods_private_unit_cargo_list_head(lua_State *L, Unit *punit)
Definition api_game_methods.c:1459
api_methods_player_controlling_gui
const char * api_methods_player_controlling_gui(lua_State *L, Player *pplayer)
Definition api_game_methods.c:470
api_methods_action_name_translation
const char * api_methods_action_name_translation(lua_State *L, Action *pact)
Definition api_game_methods.c:1050
api_methods_terrain_class_name
const char * api_methods_terrain_class_name(lua_State *L, Terrain *pterrain)
Definition api_game_methods.c:981
api_methods_player_shares_research
bool api_methods_player_shares_research(lua_State *L, Player *pplayer, Player *aplayer)
Definition api_game_methods.c:854
api_methods_tech_type_name_translation
const char * api_methods_tech_type_name_translation(lua_State *L, Tech_Type *ptech)
Definition api_game_methods.c:946
api_methods_tile_extra_owner
Player * api_methods_tile_extra_owner(lua_State *L, Tile *ptile, const char *extra_name)
Definition api_game_methods.c:1229
api_methods_city_size_get
int api_methods_city_size_get(lua_State *L, City *pcity)
Definition api_game_methods.c:236
api_methods_tech_cost_style
const char * api_methods_tech_cost_style(lua_State *L)
Definition api_game_methods.c:123
api_methods_tile_city
City * api_methods_tile_city(lua_State *L, Tile *ptile)
Definition api_game_methods.c:1121
api_methods_tech_leakage_style
const char * api_methods_tech_leakage_style(lua_State *L)
Definition api_game_methods.c:131
api_methods_government_name_translation
const char * api_methods_government_name_translation(lua_State *L, Government *pgovernment)
Definition api_game_methods.c:422
api_method_player_can_research
bool api_method_player_can_research(lua_State *L, Player *pplayer, Tech_Type *ptech)
Definition api_game_methods.c:578
api_methods_tile_has_extra
bool api_methods_tile_has_extra(lua_State *L, Tile *ptile, const char *name)
Definition api_game_methods.c:1146
api_methods_tile_sq_distance
int api_methods_tile_sq_distance(lua_State *L, Tile *ptile1, Tile *ptile2)
Definition api_game_methods.c:1372
api_methods_unit_type_has_role
bool api_methods_unit_type_has_role(lua_State *L, Unit_Type *punit_type, const char *role)
Definition api_game_methods.c:1492
api_methods_tile_link
const char * api_methods_tile_link(lua_State *L, Tile *ptile)
Definition api_game_methods.c:1596
api_methods_player_culture_get
int api_methods_player_culture_get(lua_State *L, Player *pplayer)
Definition api_game_methods.c:711
api_methods_game_turn_deprecated
int api_methods_game_turn_deprecated(lua_State *L)
Definition api_game_methods.c:90
api_methods_player_bulbs
int api_methods_player_bulbs(lua_State *L, Player *pplayer)
Definition api_game_methods.c:660
api_methods_achievement_name_translation
const char * api_methods_achievement_name_translation(lua_State *L, Achievement *pach)
Definition api_game_methods.c:1027
api_methods_building_type_is_great_wonder
bool api_methods_building_type_is_great_wonder(lua_State *L, Building_Type *pbuilding)
Definition api_game_methods.c:151
api_methods_tile_seen
bool api_methods_tile_seen(lua_State *L, Tile *self, Player *watcher)
Definition api_game_methods.c:1424
api_methods_city_tile_link
const char * api_methods_city_tile_link(lua_State *L, City *pcity)
Definition api_game_methods.c:1618
api_methods_private_tile_next_outward_index
int api_methods_private_tile_next_outward_index(lua_State *L, Tile *pstart, int tindex, int max_dist)
Definition api_game_methods.c:1308
api_methods_unit_tile_get
Tile * api_methods_unit_tile_get(lua_State *L, Unit *punit)
Definition api_game_methods.c:1401
api_methods_tile_has_road
bool api_methods_tile_has_road(lua_State *L, Tile *ptile, const char *name)
Definition api_game_methods.c:1200
api_methods_nation_type_rule_name
const char * api_methods_nation_type_rule_name(lua_State *L, Nation_Type *pnation)
Definition api_game_methods.c:434
api_methods_unit_orientation_get
const Direction * api_methods_unit_orientation_get(lua_State *L, Unit *punit)
Definition api_game_methods.c:1436
api_methods_game_turn
int api_methods_game_turn(lua_State *L)
Definition api_game_methods.c:50
api_methods_player_knows_tech
bool api_methods_player_knows_tech(lua_State *L, Player *pplayer, Tech_Type *ptech)
Definition api_game_methods.c:563
api_methods_enemy_tile
bool api_methods_enemy_tile(lua_State *L, Tile *ptile, Player *against)
Definition api_game_methods.c:1262
api_methods_building_type_is_small_wonder
bool api_methods_building_type_is_small_wonder(lua_State *L, Building_Type *pbuilding)
Definition api_game_methods.c:163
api_methods_game_year
int api_methods_game_year(lua_State *L)
Definition api_game_methods.c:60
api_methods_private_tile_for_outward_index
Tile * api_methods_private_tile_for_outward_index(lua_State *L, Tile *pstart, int tindex)
Definition api_game_methods.c:1347
api_methods_game_year_text
const char * api_methods_game_year_text(lua_State *L)
Definition api_game_methods.c:80
api_methods_action_rule_name
const char * api_methods_action_rule_name(lua_State *L, Action *pact)
Definition api_game_methods.c:1039
api_methods_disaster_rule_name
const char * api_methods_disaster_rule_name(lua_State *L, Disaster *pdis)
Definition api_game_methods.c:992
api_methods_building_type_name_translation
const char * api_methods_building_type_name_translation(lua_State *L, Building_Type *pbuilding)
Definition api_game_methods.c:200
api_methods_building_type_is_wonder
bool api_methods_building_type_is_wonder(lua_State *L, Building_Type *pbuilding)
Definition api_game_methods.c:139
api_methods_research_name_translation
const char * api_methods_research_name_translation(lua_State *L, Player *pplayer)
Definition api_game_methods.c:878
api_methods_city_inspire_partisans
int api_methods_city_inspire_partisans(lua_State *L, City *self, Player *inspirer)
Definition api_game_methods.c:258
api_methods_city_map_sq_radius
int api_methods_city_map_sq_radius(lua_State *L, City *pcity)
Definition api_game_methods.c:225
api_methods_city_has_building
bool api_methods_city_has_building(lua_State *L, City *pcity, Building_Type *building)
Definition api_game_methods.c:212
api_methods_unit_transform_problem
const char * api_methods_unit_transform_problem(lua_State *L, Unit *punit, Unit_Type *ptype)
Definition api_game_methods.c:805
api_methods_city_list_next_link
City_List_Link * api_methods_city_list_next_link(lua_State *L, City_List_Link *cl_link)
Definition api_game_methods.c:1585
api_methods_unit_type_has_flag
bool api_methods_unit_type_has_flag(lua_State *L, Unit_Type *punit_type, const char *flag)
Definition api_game_methods.c:1471
api_methods_unit_type_rule_name
const char * api_methods_unit_type_rule_name(lua_State *L, Unit_Type *punit_type)
Definition api_game_methods.c:1527
api_methods_building_type_is_improvement
bool api_methods_building_type_is_improvement(lua_State *L, Building_Type *pbuilding)
Definition api_game_methods.c:175
api_methods_tile_city_exists_within_max_city_map
bool api_methods_tile_city_exists_within_max_city_map(lua_State *L, Tile *ptile, bool may_be_on_center)
Definition api_game_methods.c:1132
api_methods_player_has_flag
bool api_methods_player_has_flag(lua_State *L, Player *pplayer, const char *flag)
Definition api_game_methods.c:722
api_methods_private_list_players
lua_Object api_methods_private_list_players(lua_State *L)
Definition api_game_methods.c:895
api_methods_unit_city_can_be_built_here
bool api_methods_unit_city_can_be_built_here(lua_State *L, Unit *punit)
Definition api_game_methods.c:1388
api_methods_tile_has_base
bool api_methods_tile_has_base(lua_State *L, Tile *ptile, const char *name)
Definition api_game_methods.c:1173
api_methods_player_gold
int api_methods_player_gold(lua_State *L, Player *pplayer)
Definition api_game_methods.c:541
api_methods_tile_known
bool api_methods_tile_known(lua_State *L, Tile *self, Player *watcher)
Definition api_game_methods.c:1412
api_methods_research_rule_name
const char * api_methods_research_rule_name(lua_State *L, Player *pplayer)
Definition api_game_methods.c:867
api_methods_is_primary_capital
bool api_methods_is_primary_capital(lua_State *L, City *pcity)
Definition api_game_methods.c:399
api_methods_player_primary_capital
City * api_methods_player_primary_capital(lua_State *L, Player *pplayer)
Definition api_game_methods.c:783
api_methods_player_research_cost
int api_methods_player_research_cost(lua_State *L, Player *pplayer)
Definition api_game_methods.c:677
api_methods_tile_map_y
int api_methods_tile_map_y(lua_State *L, Tile *ptile)
Definition api_game_methods.c:1110
api_methods_private_player_unit_list_head
Unit_List_Link * api_methods_private_player_unit_list_head(lua_State *L, Player *pplayer)
Definition api_game_methods.c:912
api_methods_action_target_kind
const char * api_methods_action_target_kind(lua_State *L, Action *pact)
Definition api_game_methods.c:1061
api_methods_private_player_city_list_head
City_List_Link * api_methods_private_player_city_list_head(lua_State *L, Player *pplayer)
Definition api_game_methods.c:923
api_methods_terrain_name_translation
const char * api_methods_terrain_name_translation(lua_State *L, Terrain *pterrain)
Definition api_game_methods.c:969
api_methods_city_tile_get
Tile * api_methods_city_tile_get(lua_State *L, City *pcity)
Definition api_game_methods.c:247
api_methods_unit_link
const char * api_methods_unit_link(lua_State *L, Unit *punit)
Definition api_game_methods.c:1629
api_methods_is_city_celebrating
bool api_methods_is_city_celebrating(lua_State *L, City *pcity)
Definition api_game_methods.c:366
api_methods_counter_city_get
int api_methods_counter_city_get(lua_State *L, Counter *c, City *city)
Definition api_game_methods.c:332
api_methods_is_capital
bool api_methods_is_capital(lua_State *L, City *pcity)
Definition api_game_methods.c:388
api_methods_player_can_build_unit_direct
bool api_methods_player_can_build_unit_direct(lua_State *L, Player *pplayer, Unit_Type *utype)
Definition api_game_methods.c:757
api_methods_unit_transporter
Unit * api_methods_unit_transporter(lua_State *L, Unit *punit)
Definition api_game_methods.c:1448
api_game_methods.h
str
#define str
Definition astring.c:76
self
static struct ai_type * self
Definition classicai.c:45
incite_cost
char * incite_cost
Definition comments.c:75
counter_id
int counter_id(struct counter *pcount)
Definition counters.c:105
punit
struct unit struct city struct unit struct tile struct extra_type const struct act_prob *act_probs int actor_unit_id struct unit struct unit * punit
Definition dialogs_g.h:74
name
const char * name
Definition inputfile.c:127
luascript_types.h
City_List_Link
const struct city_list_link City_List_Link
Definition luascript_types.h:72
Direction
enum direction8 Direction
Definition luascript_types.h:59
Nonexistent
void Nonexistent
Definition luascript_types.h:65
Unit_List_Link
const struct unit_list_link Unit_List_Link
Definition luascript_types.h:71
nat_x
#define nat_x
nat_y
#define nat_y
ai_type::name
char name[MAX_LEN_NAME]
Definition ai.h:51
city
Definition city.h:320
disaster_type
Definition disaster.h:46
impr_type
Definition improvement.h:50
nation_type
Definition nation.h:98
packet_game_info
Definition packets_gen.h:113
tile
Definition tile.h:50
unit_type
Definition unittype.h:500
unit
Definition unit.h:138
TRUE
#define TRUE
Definition support.h:46
bool
#define bool
Definition support.h:71
tolua_set_Unit_Unit_owner_ptr
static int tolua_set_Unit_Unit_owner_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:313
tolua_get_Connection_Connection_id
static int tolua_get_Connection_Connection_id(lua_State *tolua_S)
Definition tolua_game_gen.c:254
tolua_game_Player_gold00
static int tolua_game_Player_gold00(lua_State *tolua_S)
Definition tolua_game_gen.c:1378
tolua_game_Player_researching00
static int tolua_game_Player_researching00(lua_State *tolua_S)
Definition tolua_game_gen.c:1524
tolua_game_find_tile00
static int tolua_game_find_tile00(lua_State *tolua_S)
Definition tolua_game_gen.c:4253
tolua_game_direction_next_ccw00
static int tolua_game_direction_next_ccw00(lua_State *tolua_S)
Definition tolua_game_gen.c:5216
tolua_game_game_current_year00
static int tolua_game_game_current_year00(lua_State *tolua_S)
Definition tolua_game_gen.c:912
tolua_game_Terrain_name_translation00
static int tolua_game_Terrain_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3695
tolua_game_Building_Type_is_wonder00
static int tolua_game_Building_Type_is_wonder00(lua_State *tolua_S)
Definition tolua_game_gen.c:3297
tolua_game_find_unit_type01
static int tolua_game_find_unit_type01(lua_State *tolua_S)
Definition tolua_game_gen.c:4538
tolua_get_Tile_Tile_terrain_ptr
static int tolua_get_Tile_Tile_terrain_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:406
tolua_game_Unit_properties_tile00
static int tolua_game_Unit_properties_tile00(lua_State *tolua_S)
Definition tolua_game_gen.c:2315
tolua_game_Tile_is_enemy00
static int tolua_game_Tile_is_enemy00(lua_State *tolua_S)
Definition tolua_game_gen.c:2891
tolua_game_find_action01
static int tolua_game_find_action01(lua_State *tolua_S)
Definition tolua_game_gen.c:4436
tolua_game_game_current_fragment00
static int tolua_game_game_current_fragment00(lua_State *tolua_S)
Definition tolua_game_gen.c:938
tolua_set_Unit_Type_Unit_Type_obsoleted_by_ptr
static int tolua_set_Unit_Type_Unit_Type_obsoleted_by_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:600
tolua_get_Game_Info_Game_Info_sciencebox
static int tolua_get_Game_Info_Game_Info_sciencebox(lua_State *tolua_S)
Definition tolua_game_gen.c:827
tolua_game_find_player01
static int tolua_game_find_player01(lua_State *tolua_S)
Definition tolua_game_gen.c:4138
tolua_game_City_is_primary_capital00
static int tolua_game_City_is_primary_capital00(lua_State *tolua_S)
Definition tolua_game_gen.c:2231
tolua_get_Terrain_Terrain_item_number
static int tolua_get_Terrain_Terrain_item_number(lua_State *tolua_S)
Definition tolua_game_gen.c:659
tolua_game_Tile_link_text00
static int tolua_game_Tile_link_text00(lua_State *tolua_S)
Definition tolua_game_gen.c:2979
tolua_game_find_nation_type00
static int tolua_game_find_nation_type00(lua_State *tolua_S)
Definition tolua_game_gen.c:4357
tolua_game_City_culture00
static int tolua_game_City_culture00(lua_State *tolua_S)
Definition tolua_game_gen.c:2063
tolua_game_Direction_properties_cardinal00
static int tolua_game_Direction_properties_cardinal00(lua_State *tolua_S)
Definition tolua_game_gen.c:5160
tolua_game_Unit_tile_link_text00
static int tolua_game_Unit_tile_link_text00(lua_State *tolua_S)
Definition tolua_game_gen.c:2515
tolua_get_Game_Info_Game_Info_tech_steal_allow_holes
static int tolua_get_Game_Info_Game_Info_tech_steal_allow_holes(lua_State *tolua_S)
Definition tolua_game_gen.c:757
tolua_game_find_building_type01
static int tolua_game_find_building_type01(lua_State *tolua_S)
Definition tolua_game_gen.c:4487
tolua_game_Achievement_rule_name00
static int tolua_game_Achievement_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3807
tolua_game_find_disaster00
static int tolua_game_find_disaster00(lua_State *tolua_S)
Definition tolua_game_gen.c:4767
tolua_get_Game_Info_Game_Info_tech_leak_pct
static int tolua_get_Game_Info_Game_Info_tech_leak_pct(lua_State *tolua_S)
Definition tolua_game_gen.c:743
tolua_game_Unit_Type_has_role00
static int tolua_game_Unit_Type_has_role00(lua_State *tolua_S)
Definition tolua_game_gen.c:3495
tolua_game_effects_unit_vs_tile_bonus00
static int tolua_game_effects_unit_vs_tile_bonus00(lua_State *tolua_S)
Definition tolua_game_gen.c:5072
tolua_game_Unit_List_Link_data00
static int tolua_game_Unit_List_Link_data00(lua_State *tolua_S)
Definition tolua_game_gen.c:3947
tolua_game_Building_Type_is_small_wonder00
static int tolua_game_Building_Type_is_small_wonder00(lua_State *tolua_S)
Definition tolua_game_gen.c:3353
tolua_set_Unit_Unit_utype_ptr
static int tolua_set_Unit_Unit_utype_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:282
tolua_game_City_link_text00
static int tolua_game_City_link_text00(lua_State *tolua_S)
Definition tolua_game_gen.c:2259
tolua_game_effects_tile_bonus00
static int tolua_game_effects_tile_bonus00(lua_State *tolua_S)
Definition tolua_game_gen.c:5038
tolua_game_City_properties_size00
static int tolua_game_City_properties_size00(lua_State *tolua_S)
Definition tolua_game_gen.c:1919
tolua_set_Building_Type_Building_Type_build_cost
static int tolua_set_Building_Type_Building_Type_build_cost(lua_State *tolua_S)
Definition tolua_game_gen.c:524
tolua_game_City_has_building00
static int tolua_game_City_has_building00(lua_State *tolua_S)
Definition tolua_game_gen.c:1975
tolua_game_Player_shares_research00
static int tolua_game_Player_shares_research00(lua_State *tolua_S)
Definition tolua_game_gen.c:1580
tolua_game_find_direction00
static int tolua_game_find_direction00(lua_State *tolua_S)
Definition tolua_game_gen.c:4795
tolua_game_find_achievement01
static int tolua_game_find_achievement01(lua_State *tolua_S)
Definition tolua_game_gen.c:4721
tolua_game_Tile_city00
static int tolua_game_Tile_city00(lua_State *tolua_S)
Definition tolua_game_gen.c:2713
tolua_game_Tile_known00
static int tolua_game_Tile_known00(lua_State *tolua_S)
Definition tolua_game_gen.c:3007
tolua_get_Player_Player_name
static int tolua_get_Player_Player_name(lua_State *tolua_S)
Definition tolua_game_gen.c:57
tolua_set_game_game_info_substructure
static int tolua_set_game_game_info_substructure(lua_State *tolua_S)
Definition tolua_game_gen.c:848
tolua_game_Counter_rule_name00
static int tolua_game_Counter_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:1094
tolua_game_Terrain_class_name00
static int tolua_game_Terrain_class_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3723
tolua_game_find_action02
static int tolua_game_find_action02(lua_State *tolua_S)
Definition tolua_game_gen.c:4846
tolua_game_Government_rule_name00
static int tolua_game_Government_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3157
tolua_game_Unit_seen00
static int tolua_game_Unit_seen00(lua_State *tolua_S)
Definition tolua_game_gen.c:2543
tolua_game_Building_Type_is_great_wonder00
static int tolua_game_Building_Type_is_great_wonder00(lua_State *tolua_S)
Definition tolua_game_gen.c:3325
tolua_set_Player_Player_is_alive
static int tolua_set_Player_Player_is_alive(lua_State *tolua_S)
Definition tolua_game_gen.c:147
tolua_get_City_City_original_ptr
static int tolua_get_City_City_original_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:209
tolua_game_methods_private_Player_unit_list_head00
static int tolua_game_methods_private_Player_unit_list_head00(lua_State *tolua_S)
Definition tolua_game_gen.c:1863
tolua_game_find_city00
static int tolua_game_find_city00(lua_State *tolua_S)
Definition tolua_game_gen.c:4161
tolua_game_Counter_get00
static int tolua_game_Counter_get00(lua_State *tolua_S)
Definition tolua_game_gen.c:1150
tolua_game_Tile_properties_nat_y00
static int tolua_game_Tile_properties_nat_y00(lua_State *tolua_S)
Definition tolua_game_gen.c:2629
tolua_game_City_List_Link_next00
static int tolua_game_City_List_Link_next00(lua_State *tolua_S)
Definition tolua_game_gen.c:4031
tolua_game_Tile_extra_owner00
static int tolua_game_Tile_extra_owner00(lua_State *tolua_S)
Definition tolua_game_gen.c:2861
tolua_game_effects_world_bonus00
static int tolua_game_effects_world_bonus00(lua_State *tolua_S)
Definition tolua_game_gen.c:4918
tolua_game_Government_name_translation00
static int tolua_game_Government_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3185
tolua_game_Tile_properties_y00
static int tolua_game_Tile_properties_y00(lua_State *tolua_S)
Definition tolua_game_gen.c:2685
tolua_game_find_nonexistent00
static int tolua_game_find_nonexistent00(lua_State *tolua_S)
Definition tolua_game_gen.c:4892
tolua_game_Building_Type_is_improvement00
static int tolua_game_Building_Type_is_improvement00(lua_State *tolua_S)
Definition tolua_game_gen.c:3381
tolua_get_Tile_Tile_index
static int tolua_get_Tile_Tile_index(lua_State *tolua_S)
Definition tolua_game_gen.c:468
tolua_game_Player_tech_cost00
static int tolua_game_Player_tech_cost00(lua_State *tolua_S)
Definition tolua_game_gen.c:1494
tolua_game_City_is_gov_center00
static int tolua_game_City_is_gov_center00(lua_State *tolua_S)
Definition tolua_game_gen.c:2175
tolua_game_Unit_Type_can_exist_at_tile00
static int tolua_game_Unit_Type_can_exist_at_tile00(lua_State *tolua_S)
Definition tolua_game_gen.c:3581
tolua_game_Tile_properties_nat_x00
static int tolua_game_Tile_properties_nat_x00(lua_State *tolua_S)
Definition tolua_game_gen.c:2601
tolua_game_find_terrain00
static int tolua_game_find_terrain00(lua_State *tolua_S)
Definition tolua_game_gen.c:4642
tolua_game_find_player00
static int tolua_game_find_player00(lua_State *tolua_S)
Definition tolua_game_gen.c:4110
tolua_get_game_game_info_substructure
static int tolua_get_game_game_info_substructure(lua_State *tolua_S)
Definition tolua_game_gen.c:841
tolua_game_Player_num_units00
static int tolua_game_Player_num_units00(lua_State *tolua_S)
Definition tolua_game_gen.c:1292
tolua_game_Unit_link_text00
static int tolua_game_Unit_link_text00(lua_State *tolua_S)
Definition tolua_game_gen.c:2487
tolua_get_Nation_Type_Nation_Type_item_number
static int tolua_get_Nation_Type_Nation_Type_item_number(lua_State *tolua_S)
Definition tolua_game_gen.c:496
tolua_game_Unit_transform_problem00
static int tolua_game_Unit_transform_problem00(lua_State *tolua_S)
Definition tolua_game_gen.c:2429
tolua_game_find_government00
static int tolua_game_find_government00(lua_State *tolua_S)
Definition tolua_game_gen.c:4306
tolua_set_Unit_Unit_veteran
static int tolua_set_Unit_Unit_veteran(lua_State *tolua_S)
Definition tolua_game_gen.c:375
tolua_reg_types
static void tolua_reg_types(lua_State *tolua_S)
Definition tolua_game_gen.c:32
tolua_game_methods_private_Unit_cargo_list_head00
static int tolua_game_methods_private_Unit_cargo_list_head00(lua_State *tolua_S)
Definition tolua_game_gen.c:2573
tolua_game_Tile_has_extra00
static int tolua_game_Tile_has_extra00(lua_State *tolua_S)
Definition tolua_game_gen.c:2771
tolua_game_City_properties_tile00
static int tolua_game_City_properties_tile00(lua_State *tolua_S)
Definition tolua_game_gen.c:1947
tolua_game_Unit_Type_name_translation00
static int tolua_game_Unit_Type_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3553
tolua_game_game_tech_cost_style00
static int tolua_game_game_tech_cost_style00(lua_State *tolua_S)
Definition tolua_game_gen.c:1042
tolua_game_Player_num_future_techs00
static int tolua_game_Player_num_future_techs00(lua_State *tolua_S)
Definition tolua_game_gen.c:1320
tolua_get_Tech_Type_Tech_Type_item_number
static int tolua_get_Tech_Type_Tech_Type_item_number(lua_State *tolua_S)
Definition tolua_game_gen.c:631
tolua_get_Tech_Type_Tech_Type_cost
static int tolua_get_Tech_Type_Tech_Type_cost(lua_State *tolua_S)
Definition tolua_game_gen.c:645
tolua_get_Government_Government_item_number
static int tolua_get_Government_Government_item_number(lua_State *tolua_S)
Definition tolua_game_gen.c:482
tolua_game_Direction_properties_name00
static int tolua_game_Direction_properties_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:5132
tolua_game_Tile_city_exists_within_max_city_map00
static int tolua_game_Tile_city_exists_within_max_city_map00(lua_State *tolua_S)
Definition tolua_game_gen.c:2741
tolua_game_open
TOLUA_API int tolua_game_open(lua_State *tolua_S)
Definition tolua_game_gen.c:5946
tolua_game_Player_research_name_translation00
static int tolua_game_Player_research_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:1638
tolua_get_Disaster_Disaster_id
static int tolua_get_Disaster_Disaster_id(lua_State *tolua_S)
Definition tolua_game_gen.c:673
tolua_game_find_unit00
static int tolua_game_find_unit00(lua_State *tolua_S)
Definition tolua_game_gen.c:4191
tolua_game_Action_rule_name00
static int tolua_game_Action_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3863
tolua_game_find_achievement02
static int tolua_game_find_achievement02(lua_State *tolua_S)
Definition tolua_game_gen.c:4744
tolua_game_find_achievement00
static int tolua_game_find_achievement00(lua_State *tolua_S)
Definition tolua_game_gen.c:4693
tolua_get_Unit_Unit_id
static int tolua_get_Unit_Unit_id(lua_State *tolua_S)
Definition tolua_game_gen.c:392
tolua_game_effects_city_bonus00
static int tolua_game_effects_city_bonus00(lua_State *tolua_S)
Definition tolua_game_gen.c:4976
tolua_bnd_takeownership
int tolua_bnd_takeownership(lua_State *L)
tolua_game_Disaster_name_translation00
static int tolua_game_Disaster_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3779
tolua_game_Building_Type_name_translation00
static int tolua_game_Building_Type_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3437
tolua_get_Unit_Unit_utype_ptr
static int tolua_get_Unit_Unit_utype_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:268
tolua_game_City_map_sq_radius00
static int tolua_game_City_map_sq_radius00(lua_State *tolua_S)
Definition tolua_game_gen.c:2005
tolua_set_Tile_Tile_terrain_ptr
static int tolua_set_Tile_Tile_terrain_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:420
tolua_game_Tile_num_units00
static int tolua_game_Tile_num_units00(lua_State *tolua_S)
Definition tolua_game_gen.c:2921
tolua_game_Direction_properties_id00
static int tolua_game_Direction_properties_id00(lua_State *tolua_S)
Definition tolua_game_gen.c:5104
tolua_game_Unit_Type_has_flag00
static int tolua_game_Unit_Type_has_flag00(lua_State *tolua_S)
Definition tolua_game_gen.c:3465
tolua_game_Achievement_name_translation00
static int tolua_game_Achievement_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3835
tolua_get_Player_Player_government_ptr
static int tolua_get_Player_Player_government_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:102
tolua_game_Tile_sq_distance00
static int tolua_game_Tile_sq_distance00(lua_State *tolua_S)
Definition tolua_game_gen.c:2949
tolua_game_City_tile_link_text00
static int tolua_game_City_tile_link_text00(lua_State *tolua_S)
Definition tolua_game_gen.c:2287
tolua_game_Player_infrapoints00
static int tolua_game_Player_infrapoints00(lua_State *tolua_S)
Definition tolua_game_gen.c:1406
tolua_get_Game_Info_Game_Info_tech_parasite_allow_holes
static int tolua_get_Game_Info_Game_Info_tech_parasite_allow_holes(lua_State *tolua_S)
Definition tolua_game_gen.c:799
tolua_game_find_unit_type00
static int tolua_game_find_unit_type00(lua_State *tolua_S)
Definition tolua_game_gen.c:4510
tolua_game_game_ruleset_name00
static int tolua_game_game_ruleset_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:1016
tolua_game_find_building_type00
static int tolua_game_find_building_type00(lua_State *tolua_S)
Definition tolua_game_gen.c:4459
tolua_get_Game_Info_Game_Info_tech_trade_loss_allow_holes
static int tolua_get_Game_Info_Game_Info_tech_trade_loss_allow_holes(lua_State *tolua_S)
Definition tolua_game_gen.c:785
tolua_get_Unit_Unit_homecity
static int tolua_get_Unit_Unit_homecity(lua_State *tolua_S)
Definition tolua_game_gen.c:330
tolua_game_Unit_is_on_possible_city_tile00
static int tolua_game_Unit_is_on_possible_city_tile00(lua_State *tolua_S)
Definition tolua_game_gen.c:2371
tolua_game_direction_opposite00
static int tolua_game_direction_opposite00(lua_State *tolua_S)
Definition tolua_game_gen.c:5272
tolua_get_City_City_name
static int tolua_get_City_City_name(lua_State *tolua_S)
Definition tolua_game_gen.c:164
tolua_game_Unit_List_Link_next00
static int tolua_game_Unit_List_Link_next00(lua_State *tolua_S)
Definition tolua_game_gen.c:3975
tolua_set_Tile_Tile_owner_ptr
static int tolua_set_Tile_Tile_owner_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:451
tolua_game_Player_can_build_direct00
static int tolua_game_Player_can_build_direct00(lua_State *tolua_S)
Definition tolua_game_gen.c:1754
tolua_set_City_City_owner_ptr
static int tolua_set_City_City_owner_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:192
tolua_game_Player_properties_id00
static int tolua_game_Player_properties_id00(lua_State *tolua_S)
Definition tolua_game_gen.c:1180
tolua_game_Player_culture00
static int tolua_game_Player_culture00(lua_State *tolua_S)
Definition tolua_game_gen.c:1666
tolua_game_City_inspire_partisans00
static int tolua_game_City_inspire_partisans00(lua_State *tolua_S)
Definition tolua_game_gen.c:2033
tolua_game_methods_private_Player_city_list_head00
static int tolua_game_methods_private_Player_city_list_head00(lua_State *tolua_S)
Definition tolua_game_gen.c:1891
tolua_set_Player_Player_nation_ptr
static int tolua_set_Player_Player_nation_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:85
tolua_get_Game_Info_Game_Info_tech_loss_allow_holes
static int tolua_get_Game_Info_Game_Info_tech_loss_allow_holes(lua_State *tolua_S)
Definition tolua_game_gen.c:813
tolua_game_Terrain_rule_name00
static int tolua_game_Terrain_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3667
tolua_set_Unit_Type_Unit_Type_build_cost
static int tolua_set_Unit_Type_Unit_Type_build_cost(lua_State *tolua_S)
Definition tolua_game_gen.c:569
tolua_get_City_City_owner_ptr
static int tolua_get_City_City_owner_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:178
tolua_game_find_nation_type01
static int tolua_game_find_nation_type01(lua_State *tolua_S)
Definition tolua_game_gen.c:4385
tolua_game_Tile_has_road00
static int tolua_game_Tile_has_road00(lua_State *tolua_S)
Definition tolua_game_gen.c:2831
tolua_game_Player_num_cities00
static int tolua_game_Player_num_cities00(lua_State *tolua_S)
Definition tolua_game_gen.c:1264
tolua_set_City_City_original_ptr
static int tolua_set_City_City_original_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:223
tolua_get_Unit_Unit_veteran
static int tolua_get_Unit_Unit_veteran(lua_State *tolua_S)
Definition tolua_game_gen.c:361
tolua_game_Player_controlling_gui00
static int tolua_game_Player_controlling_gui00(lua_State *tolua_S)
Definition tolua_game_gen.c:1236
tolua_game_methods_private_Tile_tile_for_outward_index00
static int tolua_game_methods_private_Tile_tile_for_outward_index00(lua_State *tolua_S)
Definition tolua_game_gen.c:3099
tolua_get_Unit_Type_Unit_Type_obsoleted_by_ptr
static int tolua_get_Unit_Type_Unit_Type_obsoleted_by_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:586
tolua_game_find_tech_type00
static int tolua_game_find_tech_type00(lua_State *tolua_S)
Definition tolua_game_gen.c:4591
tolua_game_Player_has_flag00
static int tolua_game_Player_has_flag00(lua_State *tolua_S)
Definition tolua_game_gen.c:1694
tolua_get_Player_Player_nation_ptr
static int tolua_get_Player_Player_nation_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:71
tolua_game_game_current_turn00
static int tolua_game_game_current_turn00(lua_State *tolua_S)
Definition tolua_game_gen.c:860
tolua_game_find_role_unit_type00
static int tolua_game_find_role_unit_type00(lua_State *tolua_S)
Definition tolua_game_gen.c:4561
tolua_game_Tile_properties_x00
static int tolua_game_Tile_properties_x00(lua_State *tolua_S)
Definition tolua_game_gen.c:2657
tolua_game_Player_primary_capital00
static int tolua_game_Player_primary_capital00(lua_State *tolua_S)
Definition tolua_game_gen.c:1809
tolua_game_Action_name_translation00
static int tolua_game_Action_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3891
tolua_game_methods_private_list_players00
static int tolua_game_methods_private_list_players00(lua_State *tolua_S)
Definition tolua_game_gen.c:1837
tolua_game_Unit_Type_rule_name00
static int tolua_game_Unit_Type_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3525
luaopen_game
LUALIB_API int luaopen_game(lua_State *tolua_S)
Definition tolua_game_gen.c:5300
tolua_set_Unit_Unit_homecity
static int tolua_set_Unit_Unit_homecity(lua_State *tolua_S)
Definition tolua_game_gen.c:344
tolua_get_Building_Type_Building_Type_item_number
static int tolua_get_Building_Type_Building_Type_item_number(lua_State *tolua_S)
Definition tolua_game_gen.c:541
tolua_game_methods_private_Tile_unit_list_head00
static int tolua_game_methods_private_Tile_unit_list_head00(lua_State *tolua_S)
Definition tolua_game_gen.c:3129
tolua_get_Action_Action_id
static int tolua_get_Action_Action_id(lua_State *tolua_S)
Definition tolua_game_gen.c:701
tolua_game_Building_Type_rule_name00
static int tolua_game_Building_Type_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3409
tolua_game_Unit_transporter00
static int tolua_game_Unit_transporter00(lua_State *tolua_S)
Definition tolua_game_gen.c:2343
tolua_game_Tech_Type_rule_name00
static int tolua_game_Tech_Type_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3611
tolua_game_find_government01
static int tolua_game_find_government01(lua_State *tolua_S)
Definition tolua_game_gen.c:4334
tolua_game_find_action03
static int tolua_game_find_action03(lua_State *tolua_S)
Definition tolua_game_gen.c:4869
tolua_game_Player_has_wonder00
static int tolua_game_Player_has_wonder00(lua_State *tolua_S)
Definition tolua_game_gen.c:1348
tolua_game_Disaster_rule_name00
static int tolua_game_Disaster_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3751
tolua_game_Tile_seen00
static int tolua_game_Tile_seen00(lua_State *tolua_S)
Definition tolua_game_gen.c:3037
tolua_game_Player_can_research00
static int tolua_game_Player_can_research00(lua_State *tolua_S)
Definition tolua_game_gen.c:1464
tolua_get_Game_Info_Game_Info_tech_trade_allow_holes
static int tolua_get_Game_Info_Game_Info_tech_trade_allow_holes(lua_State *tolua_S)
Definition tolua_game_gen.c:771
tolua_get_Achievement_Achievement_id
static int tolua_get_Achievement_Achievement_id(lua_State *tolua_S)
Definition tolua_game_gen.c:687
tolua_game_City_is_happy00
static int tolua_game_City_is_happy00(lua_State *tolua_S)
Definition tolua_game_gen.c:2091
tolua_game_direction_next_cw00
static int tolua_game_direction_next_cw00(lua_State *tolua_S)
Definition tolua_game_gen.c:5244
tolua_get_Tile_Tile_owner_ptr
static int tolua_get_Tile_Tile_owner_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:437
tolua_get_Unit_Unit_owner_ptr
static int tolua_get_Unit_Unit_owner_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:299
tolua_game_find_tile01
static int tolua_game_find_tile01(lua_State *tolua_S)
Definition tolua_game_gen.c:4283
tolua_game_Player_can_upgrade00
static int tolua_game_Player_can_upgrade00(lua_State *tolua_S)
Definition tolua_game_gen.c:1724
tolua_game_game_turn00
static int tolua_game_game_turn00(lua_State *tolua_S)
Definition tolua_game_gen.c:886
tolua_game_game_tech_leakage_style00
static int tolua_game_game_tech_leakage_style00(lua_State *tolua_S)
Definition tolua_game_gen.c:1068
tolua_get_Unit_Type_Unit_Type_build_cost
static int tolua_get_Unit_Type_Unit_Type_build_cost(lua_State *tolua_S)
Definition tolua_game_gen.c:555
tolua_game_Player_knows_tech00
static int tolua_game_Player_knows_tech00(lua_State *tolua_S)
Definition tolua_game_gen.c:1434
tolua_game_City_is_unhappy00
static int tolua_game_City_is_unhappy00(lua_State *tolua_S)
Definition tolua_game_gen.c:2119
tolua_game_City_is_celebrating00
static int tolua_game_City_is_celebrating00(lua_State *tolua_S)
Definition tolua_game_gen.c:2147
tolua_get_Game_Info_Game_Info_min_tech_cost
static int tolua_get_Game_Info_Game_Info_min_tech_cost(lua_State *tolua_S)
Definition tolua_game_gen.c:729
tolua_game_Player_researching_cost00
static int tolua_game_Player_researching_cost00(lua_State *tolua_S)
Definition tolua_game_gen.c:1552
tolua_game_Tile_has_base00
static int tolua_game_Tile_has_base00(lua_State *tolua_S)
Definition tolua_game_gen.c:2801
tolua_game_Nation_Type_plural_translation00
static int tolua_game_Nation_Type_plural_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3269
tolua_get_Game_Info_Game_Info_base_tech_cost
static int tolua_get_Game_Info_Game_Info_base_tech_cost(lua_State *tolua_S)
Definition tolua_game_gen.c:715
tolua_game_methods_private_Tile_next_outward_index00
static int tolua_game_methods_private_Tile_next_outward_index00(lua_State *tolua_S)
Definition tolua_game_gen.c:3067
tolua_game_Player_properties_bulbs00
static int tolua_game_Player_properties_bulbs00(lua_State *tolua_S)
Definition tolua_game_gen.c:1208
tolua_game_effects_unit_bonus00
static int tolua_game_effects_unit_bonus00(lua_State *tolua_S)
Definition tolua_game_gen.c:5006
tolua_game_Nation_Type_rule_name00
static int tolua_game_Nation_Type_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:3213
tolua_game_game_current_year_text00
static int tolua_game_game_current_year_text00(lua_State *tolua_S)
Definition tolua_game_gen.c:964
tolua_get_Unit_Type_Unit_Type_item_number
static int tolua_get_Unit_Type_Unit_Type_item_number(lua_State *tolua_S)
Definition tolua_game_gen.c:617
tolua_game_find_tech_type01
static int tolua_game_find_tech_type01(lua_State *tolua_S)
Definition tolua_game_gen.c:4619
tolua_game_Player_research_rule_name00
static int tolua_game_Player_research_rule_name00(lua_State *tolua_S)
Definition tolua_game_gen.c:1610
tolua_get_Building_Type_Building_Type_build_cost
static int tolua_get_Building_Type_Building_Type_build_cost(lua_State *tolua_S)
Definition tolua_game_gen.c:510
tolua_game_City_List_Link_data00
static int tolua_game_City_List_Link_data00(lua_State *tolua_S)
Definition tolua_game_gen.c:4003
tolua_game_Unit_can_upgrade00
static int tolua_game_Unit_can_upgrade00(lua_State *tolua_S)
Definition tolua_game_gen.c:2399
tolua_game_direction_str2dir00
static int tolua_game_direction_str2dir00(lua_State *tolua_S)
Definition tolua_game_gen.c:5188
tolua_game_find_direction01
static int tolua_game_find_direction01(lua_State *tolua_S)
Definition tolua_game_gen.c:4823
tolua_game_Action_target_kind00
static int tolua_game_Action_target_kind00(lua_State *tolua_S)
Definition tolua_game_gen.c:3919
game_info_substructure
#define game_info_substructure
Definition tolua_game_gen.c:29
tolua_game_City_is_capital00
static int tolua_game_City_is_capital00(lua_State *tolua_S)
Definition tolua_game_gen.c:2203
tolua_get_City_City_id
static int tolua_get_City_City_id(lua_State *tolua_S)
Definition tolua_game_gen.c:240
tolua_game_find_counter01
static int tolua_game_find_counter01(lua_State *tolua_S)
Definition tolua_game_gen.c:4087
tolua_game_find_counter00
static int tolua_game_find_counter00(lua_State *tolua_S)
Definition tolua_game_gen.c:4059
tolua_game_find_terrain01
static int tolua_game_find_terrain01(lua_State *tolua_S)
Definition tolua_game_gen.c:4670
tolua_game_find_transport_unit00
static int tolua_game_find_transport_unit00(lua_State *tolua_S)
Definition tolua_game_gen.c:4221
tolua_game_Counter_name_translation00
static int tolua_game_Counter_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:1122
tolua_get_Player_Player_is_alive
static int tolua_get_Player_Player_is_alive(lua_State *tolua_S)
Definition tolua_game_gen.c:133
tolua_game_game_rulesetdir00
static int tolua_game_game_rulesetdir00(lua_State *tolua_S)
Definition tolua_game_gen.c:990
tolua_set_Player_Player_government_ptr
static int tolua_set_Player_Player_government_ptr(lua_State *tolua_S)
Definition tolua_game_gen.c:116
tolua_game_find_action00
static int tolua_game_find_action00(lua_State *tolua_S)
Definition tolua_game_gen.c:4408
tolua_game_effects_player_bonus00
static int tolua_game_effects_player_bonus00(lua_State *tolua_S)
Definition tolua_game_gen.c:4946
tolua_game_Tech_Type_name_translation00
static int tolua_game_Tech_Type_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3639
tolua_game_Unit_facing00
static int tolua_game_Unit_facing00(lua_State *tolua_S)
Definition tolua_game_gen.c:2459
tolua_game_Player_can_build_direct01
static int tolua_game_Player_can_build_direct01(lua_State *tolua_S)
Definition tolua_game_gen.c:1784
tolua_game_Nation_Type_name_translation00
static int tolua_game_Nation_Type_name_translation00(lua_State *tolua_S)
Definition tolua_game_gen.c:3241
Generated on Sun Dec 22 2024 23:00:33 for Freeciv-3.2 by doxygen 1.9.8