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