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 */
20
21#ifdef HAVE_CONFIG_H
22#include <fc_config.h>
23#endif
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 */
33{
34 tolua_usertype(tolua_S,"Unit_List_Link");
35 tolua_usertype(tolua_S,"Achievement");
36 tolua_usertype(tolua_S,"City_List_Link");
37 tolua_usertype(tolua_S,"Game_Info");
38 tolua_usertype(tolua_S,"Terrain");
39 tolua_usertype(tolua_S,"Unit");
40 tolua_usertype(tolua_S,"Nation_Type");
41 tolua_usertype(tolua_S,"Nonexistent");
42 tolua_usertype(tolua_S,"Direction");
43 tolua_usertype(tolua_S,"Connection");
44 tolua_usertype(tolua_S,"Counter");
45 tolua_usertype(tolua_S,"Government");
46 tolua_usertype(tolua_S,"Disaster");
47 tolua_usertype(tolua_S,"Player");
48 tolua_usertype(tolua_S,"Tile");
49 tolua_usertype(tolua_S,"Building_Type");
50 tolua_usertype(tolua_S,"Unit_Type");
51 tolua_usertype(tolua_S,"City");
52 tolua_usertype(tolua_S,"Tech_Type");
53 tolua_usertype(tolua_S,"Action");
54 tolua_usertype(tolua_S,"Specialist");
55}
56
57/* get function: name of class Player */
59{
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 */
73{
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 */
87{
89#ifndef TOLUA_RELEASE
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 */
104{
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 */
118{
120#ifndef TOLUA_RELEASE
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 */
135{
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 */
149{
151#ifndef TOLUA_RELEASE
153 if (!self) {
154 tolua_error(tolua_S,"invalid 'self' in accessing variable 'is_alive'",NULL);
155 return 0;
156 }
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 */
166{
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 */
180{
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 */
194{
196#ifndef TOLUA_RELEASE
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 */
211{
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 */
225{
227#ifndef TOLUA_RELEASE
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 */
242{
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
251 return 1;
252}
253
254/* get function: id of class Connection */
256{
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
265 return 1;
266}
267
268/* get function: utype of class Unit */
270{
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 */
284{
286#ifndef TOLUA_RELEASE
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 */
301{
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 */
315{
317#ifndef TOLUA_RELEASE
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 */
332{
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 */
346{
348#ifndef TOLUA_RELEASE
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 */
363{
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
372 return 1;
373}
374
375/* set function: homecity of class Unit */
377{
379#ifndef TOLUA_RELEASE
381 if (!self) {
382 tolua_error(tolua_S,"invalid 'self' in accessing variable 'homecity'",NULL);
383 return 0;
384 }
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 */
394{
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
403 return 1;
404}
405
406/* set function: veteran of class Unit */
408{
410#ifndef TOLUA_RELEASE
412 if (!self) {
413 tolua_error(tolua_S,"invalid 'self' in accessing variable 'veteran'",NULL);
414 return 0;
415 }
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 */
425{
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
434 return 1;
435}
436
437/* get function: terrain of class Tile */
439{
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 */
453{
455#ifndef TOLUA_RELEASE
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 */
470{
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 */
484{
486#ifndef TOLUA_RELEASE
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 */
501{
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
510 return 1;
511}
512
513/* get function: item_number of class Government */
515{
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
524 return 1;
525}
526
527/* get function: item_number of class Nation_Type */
529{
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
538 return 1;
539}
540
541/* get function: build_cost of class Building_Type */
543{
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
552 return 1;
553}
554
555/* set function: build_cost of class Building_Type */
557{
559#ifndef TOLUA_RELEASE
561 if (!self) {
562 tolua_error(tolua_S,"invalid 'self' in accessing variable 'build_cost'",NULL);
563 return 0;
564 }
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 */
574{
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
583 return 1;
584}
585
586/* get function: build_cost of class Unit_Type */
588{
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
597 return 1;
598}
599
600/* set function: build_cost of class Unit_Type */
602{
604#ifndef TOLUA_RELEASE
606 if (!self) {
607 tolua_error(tolua_S,"invalid 'self' in accessing variable 'build_cost'",NULL);
608 return 0;
609 }
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 */
619{
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 */
633{
635#ifndef TOLUA_RELEASE
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 */
650{
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
659 return 1;
660}
661
662/* get function: item_number of class Tech_Type */
664{
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
673 return 1;
674}
675
676/* get function: cost of class Tech_Type */
678{
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
687 return 1;
688}
689
690/* get function: item_number of class Terrain */
692{
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
701 return 1;
702}
703
704/* get function: id of class Disaster */
706{
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
715 return 1;
716}
717
718/* get function: id of class Achievement */
720{
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
729 return 1;
730}
731
732/* get function: id of class Action */
734{
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
743 return 1;
744}
745
746/* get function: item_number of class Specialist */
748{
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
757 return 1;
758}
759
760/* get function: base_tech_cost of class Game_Info */
762{
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 */
776{
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 */
790{
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 */
804{
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 */
818{
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 */
832{
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 */
846{
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 */
860{
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 */
874{
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
883 return 1;
884}
885
886/* get function: game_info_substructure */
892
893/* set function: game_info_substructure */
895{
896#ifndef TOLUA_RELEASE
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
902 return 0;
903}
904
905/* function: api_methods_game_turn */
907{
908#ifndef TOLUA_RELEASE
910 if (
912 )
913 goto tolua_lerror;
914 else
915#endif
916 {
918 {
921 }
922 }
923 return 1;
924#ifndef TOLUA_RELEASE
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 */
933{
934#ifndef TOLUA_RELEASE
936 if (
938 )
939 goto tolua_lerror;
940 else
941#endif
942 {
944 {
947 }
948 }
949 return 1;
950#ifndef TOLUA_RELEASE
952 tolua_error(tolua_S,"#ferror in function 'turn'.",&tolua_err);
953 return 0;
954#endif
955}
956
957/* function: api_methods_game_year */
959{
960#ifndef TOLUA_RELEASE
962 if (
964 )
965 goto tolua_lerror;
966 else
967#endif
968 {
970 {
973 }
974 }
975 return 1;
976#ifndef TOLUA_RELEASE
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 */
985{
986#ifndef TOLUA_RELEASE
988 if (
990 )
991 goto tolua_lerror;
992 else
993#endif
994 {
996 {
999 }
1000 }
1001 return 1;
1002#ifndef TOLUA_RELEASE
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 */
1011{
1012#ifndef TOLUA_RELEASE
1014 if (
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
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 */
1037{
1038#ifndef TOLUA_RELEASE
1040 if (
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
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 */
1063{
1064#ifndef TOLUA_RELEASE
1066 if (
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
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 */
1089{
1090#ifndef TOLUA_RELEASE
1092 if (
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
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 */
1115{
1116#ifndef TOLUA_RELEASE
1118 if (
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
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 */
1141{
1142#ifndef TOLUA_RELEASE
1144 if (
1145 !tolua_isusertype(tolua_S,1,"Counter",0,&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
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 */
1169{
1170#ifndef TOLUA_RELEASE
1172 if (
1173 !tolua_isusertype(tolua_S,1,"Counter",0,&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
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 */
1197{
1198#ifndef TOLUA_RELEASE
1200 if (
1201 !tolua_isusertype(tolua_S,1,"Counter",0,&tolua_err) ||
1202 !tolua_isusertype(tolua_S,2,"City",0,&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 {
1215 }
1216 }
1217 return 1;
1218#ifndef TOLUA_RELEASE
1220 tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
1221 return 0;
1222#endif
1223}
1224
1225/* function: api_methods_player_number */
1227{
1228#ifndef TOLUA_RELEASE
1230 if (
1231 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1233 )
1234 goto tolua_lerror;
1235 else
1236#endif
1237 {
1238 lua_State* L = tolua_S;
1240 {
1243 }
1244 }
1245 return 1;
1246#ifndef TOLUA_RELEASE
1248 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
1249 return 0;
1250#endif
1251}
1252
1253/* function: api_methods_player_bulbs */
1255{
1256#ifndef TOLUA_RELEASE
1258 if (
1259 !tolua_isusertype(tolua_S,1,"Player",0,&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);
1271 }
1272 }
1273 return 1;
1274#ifndef TOLUA_RELEASE
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 */
1283{
1284#ifndef TOLUA_RELEASE
1286 if (
1287 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1289 )
1290 goto tolua_lerror;
1291 else
1292#endif
1293 {
1294 lua_State* L = tolua_S;
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
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 */
1311{
1312#ifndef TOLUA_RELEASE
1314 if (
1315 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1317 )
1318 goto tolua_lerror;
1319 else
1320#endif
1321 {
1322 lua_State* L = tolua_S;
1324 {
1327 }
1328 }
1329 return 1;
1330#ifndef TOLUA_RELEASE
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 */
1339{
1340#ifndef TOLUA_RELEASE
1342 if (
1343 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1345 )
1346 goto tolua_lerror;
1347 else
1348#endif
1349 {
1350 lua_State* L = tolua_S;
1352 {
1355 }
1356 }
1357 return 1;
1358#ifndef TOLUA_RELEASE
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 */
1367{
1368#ifndef TOLUA_RELEASE
1370 if (
1371 !tolua_isusertype(tolua_S,1,"Player",0,&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);
1383 }
1384 }
1385 return 1;
1386#ifndef TOLUA_RELEASE
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 */
1395{
1396#ifndef TOLUA_RELEASE
1398 if (
1399 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1400 !tolua_isusertype(tolua_S,2,"Building_Type",0,&tolua_err) ||
1402 )
1403 goto tolua_lerror;
1404 else
1405#endif
1406 {
1407 lua_State* L = tolua_S;
1410 {
1413 }
1414 }
1415 return 1;
1416#ifndef TOLUA_RELEASE
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 */
1425{
1426#ifndef TOLUA_RELEASE
1428 if (
1429 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1431 )
1432 goto tolua_lerror;
1433 else
1434#endif
1435 {
1436 lua_State* L = tolua_S;
1438 {
1441 }
1442 }
1443 return 1;
1444#ifndef TOLUA_RELEASE
1446 tolua_error(tolua_S,"#ferror in function 'gold'.",&tolua_err);
1447 return 0;
1448#endif
1449}
1450
1451/* function: api_methods_player_infrapoints */
1453{
1454#ifndef TOLUA_RELEASE
1456 if (
1457 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1459 )
1460 goto tolua_lerror;
1461 else
1462#endif
1463 {
1464 lua_State* L = tolua_S;
1466 {
1469 }
1470 }
1471 return 1;
1472#ifndef TOLUA_RELEASE
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 */
1481{
1482#ifndef TOLUA_RELEASE
1484 if (
1485 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1486 !tolua_isusertype(tolua_S,2,"Tech_Type",0,&tolua_err) ||
1488 )
1489 goto tolua_lerror;
1490 else
1491#endif
1492 {
1493 lua_State* L = tolua_S;
1496 {
1499 }
1500 }
1501 return 1;
1502#ifndef TOLUA_RELEASE
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 */
1511{
1512#ifndef TOLUA_RELEASE
1514 if (
1515 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1516 !tolua_isusertype(tolua_S,2,"Tech_Type",0,&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));
1526 {
1529 }
1530 }
1531 return 1;
1532#ifndef TOLUA_RELEASE
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 */
1541{
1542#ifndef TOLUA_RELEASE
1544 if (
1545 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1546 !tolua_isusertype(tolua_S,2,"Tech_Type",0,&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));
1556 {
1559 }
1560 }
1561 return 1;
1562#ifndef TOLUA_RELEASE
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 */
1571{
1572#ifndef TOLUA_RELEASE
1574 if (
1575 !tolua_isusertype(tolua_S,1,"Player",0,&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 {
1587 }
1588 }
1589 return 1;
1590#ifndef TOLUA_RELEASE
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 */
1599{
1600#ifndef TOLUA_RELEASE
1602 if (
1603 !tolua_isusertype(tolua_S,1,"Player",0,&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 {
1615 }
1616 }
1617 return 1;
1618#ifndef TOLUA_RELEASE
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 */
1627{
1628#ifndef TOLUA_RELEASE
1630 if (
1631 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1632 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
1634 )
1635 goto tolua_lerror;
1636 else
1637#endif
1638 {
1639 lua_State* L = tolua_S;
1642 {
1645 }
1646 }
1647 return 1;
1648#ifndef TOLUA_RELEASE
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 */
1657{
1658#ifndef TOLUA_RELEASE
1660 if (
1661 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1663 )
1664 goto tolua_lerror;
1665 else
1666#endif
1667 {
1668 lua_State* L = tolua_S;
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
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 */
1685{
1686#ifndef TOLUA_RELEASE
1688 if (
1689 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1691 )
1692 goto tolua_lerror;
1693 else
1694#endif
1695 {
1696 lua_State* L = tolua_S;
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
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 */
1713{
1714#ifndef TOLUA_RELEASE
1716 if (
1717 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1719 )
1720 goto tolua_lerror;
1721 else
1722#endif
1723 {
1724 lua_State* L = tolua_S;
1726 {
1729 }
1730 }
1731 return 1;
1732#ifndef TOLUA_RELEASE
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 */
1741{
1742#ifndef TOLUA_RELEASE
1744 if (
1745 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1748 )
1749 goto tolua_lerror;
1750 else
1751#endif
1752 {
1753 lua_State* L = tolua_S;
1755 const char* flag = ((const char*) tolua_tostring(tolua_S,2,0));
1756 {
1759 }
1760 }
1761 return 1;
1762#ifndef TOLUA_RELEASE
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 */
1771{
1772#ifndef TOLUA_RELEASE
1774 if (
1775 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1776 !tolua_isusertype(tolua_S,2,"Unit_Type",0,&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 {
1788 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_Type");
1789 }
1790 }
1791 return 1;
1792#ifndef TOLUA_RELEASE
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 */
1801{
1802#ifndef TOLUA_RELEASE
1804 if (
1805 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1806 !tolua_isusertype(tolua_S,2,"Building_Type",0,&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));
1816 {
1819 }
1820 }
1821 return 1;
1822#ifndef TOLUA_RELEASE
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 */
1831{
1833 if (
1834 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1835 !tolua_isusertype(tolua_S,2,"Unit_Type",0,&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 {
1847 }
1848 }
1849 return 1;
1852}
1853
1854/* function: api_methods_player_can_employ */
1856{
1857#ifndef TOLUA_RELEASE
1859 if (
1860 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1861 !tolua_isusertype(tolua_S,2,"Specialist",0,&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));
1871 {
1872 bool tolua_ret = (bool) api_methods_player_can_employ(L,pplayer,s);
1874 }
1875 }
1876 return 1;
1877#ifndef TOLUA_RELEASE
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 */
1886{
1887#ifndef TOLUA_RELEASE
1889 if (
1890 !tolua_isusertype(tolua_S,1,"Player",0,&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 {
1901 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City");
1902 }
1903 }
1904 return 1;
1905#ifndef TOLUA_RELEASE
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 */
1914{
1915#ifndef TOLUA_RELEASE
1917 if (
1918 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1919 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
1921 )
1922 goto tolua_lerror;
1923 else
1924#endif
1925 {
1926 lua_State* L = tolua_S;
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
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 */
1944{
1945#ifndef TOLUA_RELEASE
1947 if (
1948 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1949 !tolua_isusertype(tolua_S,2,"Player",0,&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);
1962 }
1963 }
1964 return 1;
1965#ifndef TOLUA_RELEASE
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 */
1974{
1975#ifndef TOLUA_RELEASE
1977 if (
1978 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
1979 !tolua_isusertype(tolua_S,2,"Player",0,&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);
1992 }
1993 }
1994 return 1;
1995#ifndef TOLUA_RELEASE
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 */
2004{
2005#ifndef TOLUA_RELEASE
2007 if (
2009 )
2010 goto tolua_lerror;
2011 else
2012#endif
2013 {
2014 lua_State* L = tolua_S;
2015 {
2018 }
2019 }
2020 return 1;
2021#ifndef TOLUA_RELEASE
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 */
2030{
2031#ifndef TOLUA_RELEASE
2033 if (
2034 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
2036 )
2037 goto tolua_lerror;
2038 else
2039#endif
2040 {
2041 lua_State* L = tolua_S;
2043 {
2045 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_List_Link");
2046 }
2047 }
2048 return 1;
2049#ifndef TOLUA_RELEASE
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 */
2058{
2059#ifndef TOLUA_RELEASE
2061 if (
2062 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
2064 )
2065 goto tolua_lerror;
2066 else
2067#endif
2068 {
2069 lua_State* L = tolua_S;
2071 {
2073 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City_List_Link");
2074 }
2075 }
2076 return 1;
2077#ifndef TOLUA_RELEASE
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 */
2086{
2087#ifndef TOLUA_RELEASE
2089 if (
2090 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2102 }
2103 }
2104 return 1;
2105#ifndef TOLUA_RELEASE
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 */
2114{
2115#ifndef TOLUA_RELEASE
2117 if (
2118 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2129 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
2130 }
2131 }
2132 return 1;
2133#ifndef TOLUA_RELEASE
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 */
2142{
2143#ifndef TOLUA_RELEASE
2145 if (
2146 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2147 !tolua_isusertype(tolua_S,2,"Building_Type",0,&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));
2157 {
2160 }
2161 }
2162 return 1;
2163#ifndef TOLUA_RELEASE
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 */
2172{
2173#ifndef TOLUA_RELEASE
2175 if (
2176 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2188 }
2189 }
2190 return 1;
2191#ifndef TOLUA_RELEASE
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 */
2200{
2201#ifndef TOLUA_RELEASE
2203 if (
2204 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2205 !tolua_isusertype(tolua_S,2,"Player",0,&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));
2215 {
2218 }
2219 }
2220 return 1;
2221#ifndef TOLUA_RELEASE
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 */
2230{
2231#ifndef TOLUA_RELEASE
2233 if (
2234 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2246 }
2247 }
2248 return 1;
2249#ifndef TOLUA_RELEASE
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 */
2258{
2259#ifndef TOLUA_RELEASE
2261 if (
2262 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2274 }
2275 }
2276 return 1;
2277#ifndef TOLUA_RELEASE
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 */
2286{
2287#ifndef TOLUA_RELEASE
2289 if (
2290 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2302 }
2303 }
2304 return 1;
2305#ifndef TOLUA_RELEASE
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 */
2314{
2315#ifndef TOLUA_RELEASE
2317 if (
2318 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2330 }
2331 }
2332 return 1;
2333#ifndef TOLUA_RELEASE
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 */
2342{
2343#ifndef TOLUA_RELEASE
2345 if (
2346 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2358 }
2359 }
2360 return 1;
2361#ifndef TOLUA_RELEASE
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 */
2370{
2371#ifndef TOLUA_RELEASE
2373 if (
2374 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2386 }
2387 }
2388 return 1;
2389#ifndef TOLUA_RELEASE
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 */
2398{
2399#ifndef TOLUA_RELEASE
2401 if (
2402 !tolua_isusertype(tolua_S,1,"City",0,&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 {
2414 }
2415 }
2416 return 1;
2417#ifndef TOLUA_RELEASE
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 */
2426{
2427#ifndef TOLUA_RELEASE
2429 if (
2430 !tolua_isusertype(tolua_S,1,"City",0,&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
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 */
2454{
2455#ifndef TOLUA_RELEASE
2457 if (
2458 !tolua_isusertype(tolua_S,1,"City",0,&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
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 */
2482{
2483#ifndef TOLUA_RELEASE
2485 if (
2486 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2487 !tolua_isusertype(tolua_S,2,"Player",0,&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 {
2500 }
2501 }
2502 return 1;
2503#ifndef TOLUA_RELEASE
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 */
2512{
2513#ifndef TOLUA_RELEASE
2515 if (
2516 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2517 !tolua_isusertype(tolua_S,2,"Specialist",0,&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));
2527 {
2530 }
2531 }
2532 return 1;
2533#ifndef TOLUA_RELEASE
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 */
2542{
2543#ifndef TOLUA_RELEASE
2545 if (
2546 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
2547 !tolua_isusertype(tolua_S,2,"Specialist",0,&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));
2557 {
2560 }
2561 }
2562 return 1;
2563#ifndef TOLUA_RELEASE
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 */
2572{
2573#ifndef TOLUA_RELEASE
2575 if (
2576 !tolua_isusertype(tolua_S,1,"Unit",0,&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 {
2587 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
2588 }
2589 }
2590 return 1;
2591#ifndef TOLUA_RELEASE
2593 tolua_error(tolua_S,"#ferror in function 'tile'.",&tolua_err);
2594 return 0;
2595#endif
2596}
2597
2598/* function: api_methods_unit_transporter */
2600{
2601#ifndef TOLUA_RELEASE
2603 if (
2604 !tolua_isusertype(tolua_S,1,"Unit",0,&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 {
2615 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit");
2616 }
2617 }
2618 return 1;
2619#ifndef TOLUA_RELEASE
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 */
2628{
2629#ifndef TOLUA_RELEASE
2631 if (
2632 !tolua_isusertype(tolua_S,1,"Unit",0,&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 {
2644 }
2645 }
2646 return 1;
2647#ifndef TOLUA_RELEASE
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 */
2656{
2657#ifndef TOLUA_RELEASE
2659 if (
2660 !tolua_isusertype(tolua_S,1,"Unit",0,&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 {
2674 }
2675 }
2676 return 1;
2677#ifndef TOLUA_RELEASE
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 */
2686{
2687#ifndef TOLUA_RELEASE
2689 if (
2690 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2691 !tolua_isusertype(tolua_S,2,"Unit_Type",0,&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));
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
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 */
2716{
2717#ifndef TOLUA_RELEASE
2719 if (
2720 !tolua_isusertype(tolua_S,1,"Unit",0,&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 {
2731 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
2732 }
2733 }
2734 return 1;
2735#ifndef TOLUA_RELEASE
2737 tolua_error(tolua_S,"#ferror in function 'facing'.",&tolua_err);
2738 return 0;
2739#endif
2740}
2741
2742/* function: api_methods_unit_link */
2744{
2745#ifndef TOLUA_RELEASE
2747 if (
2748 !tolua_isusertype(tolua_S,1,"Unit",0,&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
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 */
2772{
2773#ifndef TOLUA_RELEASE
2775 if (
2776 !tolua_isusertype(tolua_S,1,"Unit",0,&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
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 */
2800{
2801#ifndef TOLUA_RELEASE
2803 if (
2804 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
2805 !tolua_isusertype(tolua_S,2,"Player",0,&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));
2815 {
2818 }
2819 }
2820 return 1;
2821#ifndef TOLUA_RELEASE
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 */
2830{
2831#ifndef TOLUA_RELEASE
2833 if (
2834 !tolua_isusertype(tolua_S,1,"Unit",0,&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 {
2845 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_List_Link");
2846 }
2847 }
2848 return 1;
2849#ifndef TOLUA_RELEASE
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 */
2858{
2859#ifndef TOLUA_RELEASE
2861 if (
2862 !tolua_isusertype(tolua_S,1,"Tile",0,&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 {
2874 }
2875 }
2876 return 1;
2877#ifndef TOLUA_RELEASE
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 */
2886{
2887#ifndef TOLUA_RELEASE
2889 if (
2890 !tolua_isusertype(tolua_S,1,"Tile",0,&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 {
2902 }
2903 }
2904 return 1;
2905#ifndef TOLUA_RELEASE
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 */
2914{
2915#ifndef TOLUA_RELEASE
2917 if (
2918 !tolua_isusertype(tolua_S,1,"Tile",0,&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 {
2930 }
2931 }
2932 return 1;
2933#ifndef TOLUA_RELEASE
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 */
2942{
2943#ifndef TOLUA_RELEASE
2945 if (
2946 !tolua_isusertype(tolua_S,1,"Tile",0,&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 {
2958 }
2959 }
2960 return 1;
2961#ifndef TOLUA_RELEASE
2963 tolua_error(tolua_S,"#ferror in function 'y'.",&tolua_err);
2964 return 0;
2965#endif
2966}
2967
2968/* function: api_methods_tile_city */
2970{
2971#ifndef TOLUA_RELEASE
2973 if (
2974 !tolua_isusertype(tolua_S,1,"Tile",0,&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 {
2985 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City");
2986 }
2987 }
2988 return 1;
2989#ifndef TOLUA_RELEASE
2991 tolua_error(tolua_S,"#ferror in function 'city'.",&tolua_err);
2992 return 0;
2993#endif
2994}
2995
2996/* function: api_methods_tile_city_exists_within_max_city_map */
2998{
2999#ifndef TOLUA_RELEASE
3001 if (
3002 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3005 )
3006 goto tolua_lerror;
3007 else
3008#endif
3009 {
3010 lua_State* L = tolua_S;
3011 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3012 bool center = ((bool) tolua_toboolean(tolua_S,2,0));
3013 {
3016 }
3017 }
3018 return 1;
3019#ifndef TOLUA_RELEASE
3021 tolua_error(tolua_S,"#ferror in function 'city_exists_within_max_city_map'.",&tolua_err);
3022 return 0;
3023#endif
3024}
3025
3026/* function: api_methods_tile_has_extra */
3028{
3029#ifndef TOLUA_RELEASE
3031 if (
3032 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3035 )
3036 goto tolua_lerror;
3037 else
3038#endif
3039 {
3040 lua_State* L = tolua_S;
3041 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3042 const char* name = ((const char*) tolua_tostring(tolua_S,2,0));
3043 {
3046 }
3047 }
3048 return 1;
3049#ifndef TOLUA_RELEASE
3051 tolua_error(tolua_S,"#ferror in function 'has_extra'.",&tolua_err);
3052 return 0;
3053#endif
3054}
3055
3056/* function: api_methods_tile_has_base */
3058{
3059#ifndef TOLUA_RELEASE
3061 if (
3062 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3065 )
3066 goto tolua_lerror;
3067 else
3068#endif
3069 {
3070 lua_State* L = tolua_S;
3071 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3072 const char* name = ((const char*) tolua_tostring(tolua_S,2,0));
3073 {
3076 }
3077 }
3078 return 1;
3079#ifndef TOLUA_RELEASE
3081 tolua_error(tolua_S,"#ferror in function 'has_base'.",&tolua_err);
3082 return 0;
3083#endif
3084}
3085
3086/* function: api_methods_tile_has_road */
3088{
3089#ifndef TOLUA_RELEASE
3091 if (
3092 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3095 )
3096 goto tolua_lerror;
3097 else
3098#endif
3099 {
3100 lua_State* L = tolua_S;
3101 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3102 const char* name = ((const char*) tolua_tostring(tolua_S,2,0));
3103 {
3106 }
3107 }
3108 return 1;
3109#ifndef TOLUA_RELEASE
3111 tolua_error(tolua_S,"#ferror in function 'has_road'.",&tolua_err);
3112 return 0;
3113#endif
3114}
3115
3116/* function: api_methods_tile_extra_owner */
3118{
3119#ifndef TOLUA_RELEASE
3121 if (
3122 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3125 )
3126 goto tolua_lerror;
3127 else
3128#endif
3129 {
3130 lua_State* L = tolua_S;
3131 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3132 const char* extra_name = ((const char*) tolua_tostring(tolua_S,2,0));
3133 {
3135 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Player");
3136 }
3137 }
3138 return 1;
3139#ifndef TOLUA_RELEASE
3141 tolua_error(tolua_S,"#ferror in function 'extra_owner'.",&tolua_err);
3142 return 0;
3143#endif
3144}
3145
3146/* function: api_methods_enemy_tile */
3148{
3149#ifndef TOLUA_RELEASE
3151 if (
3152 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3153 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
3155 )
3156 goto tolua_lerror;
3157 else
3158#endif
3159 {
3160 lua_State* L = tolua_S;
3161 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3163 {
3166 }
3167 }
3168 return 1;
3169#ifndef TOLUA_RELEASE
3171 tolua_error(tolua_S,"#ferror in function 'is_enemy'.",&tolua_err);
3172 return 0;
3173#endif
3174}
3175
3176/* function: api_methods_tile_num_units */
3178{
3179#ifndef TOLUA_RELEASE
3181 if (
3182 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3184 )
3185 goto tolua_lerror;
3186 else
3187#endif
3188 {
3189 lua_State* L = tolua_S;
3190 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3191 {
3194 }
3195 }
3196 return 1;
3197#ifndef TOLUA_RELEASE
3199 tolua_error(tolua_S,"#ferror in function 'num_units'.",&tolua_err);
3200 return 0;
3201#endif
3202}
3203
3204/* function: api_methods_tile_sq_distance */
3206{
3207#ifndef TOLUA_RELEASE
3209 if (
3210 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3211 !tolua_isusertype(tolua_S,2,"Tile",0,&tolua_err) ||
3213 )
3214 goto tolua_lerror;
3215 else
3216#endif
3217 {
3218 lua_State* L = tolua_S;
3219 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3220 Tile* other = ((Tile*) tolua_tousertype(tolua_S,2,0));
3221 {
3224 }
3225 }
3226 return 1;
3227#ifndef TOLUA_RELEASE
3229 tolua_error(tolua_S,"#ferror in function 'sq_distance'.",&tolua_err);
3230 return 0;
3231#endif
3232}
3233
3234/* function: api_methods_tile_link */
3236{
3237#ifndef TOLUA_RELEASE
3239 if (
3240 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3242 )
3243 goto tolua_lerror;
3244 else
3245#endif
3246 {
3247 lua_State* L = tolua_S;
3248 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3249 {
3250 const char* tolua_ret = (const char*) api_methods_tile_link(L,self);
3251 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3252 }
3253 }
3254 return 1;
3255#ifndef TOLUA_RELEASE
3257 tolua_error(tolua_S,"#ferror in function 'link_text'.",&tolua_err);
3258 return 0;
3259#endif
3260}
3261
3262/* function: api_methods_tile_known */
3264{
3265#ifndef TOLUA_RELEASE
3267 if (
3268 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3269 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
3271 )
3272 goto tolua_lerror;
3273 else
3274#endif
3275 {
3276 lua_State* L = tolua_S;
3277 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3279 {
3282 }
3283 }
3284 return 1;
3285#ifndef TOLUA_RELEASE
3287 tolua_error(tolua_S,"#ferror in function 'known'.",&tolua_err);
3288 return 0;
3289#endif
3290}
3291
3292/* function: api_methods_tile_seen */
3294{
3295#ifndef TOLUA_RELEASE
3297 if (
3298 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3299 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
3301 )
3302 goto tolua_lerror;
3303 else
3304#endif
3305 {
3306 lua_State* L = tolua_S;
3307 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3309 {
3312 }
3313 }
3314 return 1;
3315#ifndef TOLUA_RELEASE
3317 tolua_error(tolua_S,"#ferror in function 'seen'.",&tolua_err);
3318 return 0;
3319#endif
3320}
3321
3322/* function: api_methods_private_tile_next_outward_index */
3324{
3325#ifndef TOLUA_RELEASE
3327 if (
3328 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3332 )
3333 goto tolua_lerror;
3334 else
3335#endif
3336 {
3337 lua_State* L = tolua_S;
3339 int tindex = ((int) tolua_tonumber(tolua_S,2,0));
3340 int max_dist = ((int) tolua_tonumber(tolua_S,3,0));
3341 {
3344 }
3345 }
3346 return 1;
3347#ifndef TOLUA_RELEASE
3349 tolua_error(tolua_S,"#ferror in function 'next_outward_index'.",&tolua_err);
3350 return 0;
3351#endif
3352}
3353
3354/* function: api_methods_private_tile_for_outward_index */
3356{
3357#ifndef TOLUA_RELEASE
3359 if (
3360 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3363 )
3364 goto tolua_lerror;
3365 else
3366#endif
3367 {
3368 lua_State* L = tolua_S;
3370 int tindex = ((int) tolua_tonumber(tolua_S,2,0));
3371 {
3373 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
3374 }
3375 }
3376 return 1;
3377#ifndef TOLUA_RELEASE
3379 tolua_error(tolua_S,"#ferror in function 'tile_for_outward_index'.",&tolua_err);
3380 return 0;
3381#endif
3382}
3383
3384/* function: api_methods_private_tile_unit_list_head */
3386{
3387#ifndef TOLUA_RELEASE
3389 if (
3390 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
3392 )
3393 goto tolua_lerror;
3394 else
3395#endif
3396 {
3397 lua_State* L = tolua_S;
3398 Tile* self = ((Tile*) tolua_tousertype(tolua_S,1,0));
3399 {
3401 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_List_Link");
3402 }
3403 }
3404 return 1;
3405#ifndef TOLUA_RELEASE
3407 tolua_error(tolua_S,"#ferror in function 'unit_list_head'.",&tolua_err);
3408 return 0;
3409#endif
3410}
3411
3412/* function: api_methods_government_rule_name */
3414{
3415#ifndef TOLUA_RELEASE
3417 if (
3418 !tolua_isusertype(tolua_S,1,"Government",0,&tolua_err) ||
3420 )
3421 goto tolua_lerror;
3422 else
3423#endif
3424 {
3425 lua_State* L = tolua_S;
3427 {
3428 const char* tolua_ret = (const char*) api_methods_government_rule_name(L,self);
3429 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3430 }
3431 }
3432 return 1;
3433#ifndef TOLUA_RELEASE
3435 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3436 return 0;
3437#endif
3438}
3439
3440/* function: api_methods_government_name_translation */
3442{
3443#ifndef TOLUA_RELEASE
3445 if (
3446 !tolua_isusertype(tolua_S,1,"Government",0,&tolua_err) ||
3448 )
3449 goto tolua_lerror;
3450 else
3451#endif
3452 {
3453 lua_State* L = tolua_S;
3455 {
3456 const char* tolua_ret = (const char*) api_methods_government_name_translation(L,self);
3457 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3458 }
3459 }
3460 return 1;
3461#ifndef TOLUA_RELEASE
3463 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3464 return 0;
3465#endif
3466}
3467
3468/* function: api_methods_nation_type_rule_name */
3470{
3471#ifndef TOLUA_RELEASE
3473 if (
3474 !tolua_isusertype(tolua_S,1,"Nation_Type",0,&tolua_err) ||
3476 )
3477 goto tolua_lerror;
3478 else
3479#endif
3480 {
3481 lua_State* L = tolua_S;
3483 {
3484 const char* tolua_ret = (const char*) api_methods_nation_type_rule_name(L,self);
3485 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3486 }
3487 }
3488 return 1;
3489#ifndef TOLUA_RELEASE
3491 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3492 return 0;
3493#endif
3494}
3495
3496/* function: api_methods_nation_type_name_translation */
3498{
3499#ifndef TOLUA_RELEASE
3501 if (
3502 !tolua_isusertype(tolua_S,1,"Nation_Type",0,&tolua_err) ||
3504 )
3505 goto tolua_lerror;
3506 else
3507#endif
3508 {
3509 lua_State* L = tolua_S;
3511 {
3512 const char* tolua_ret = (const char*) api_methods_nation_type_name_translation(L,self);
3513 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3514 }
3515 }
3516 return 1;
3517#ifndef TOLUA_RELEASE
3519 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3520 return 0;
3521#endif
3522}
3523
3524/* function: api_methods_nation_type_plural_translation */
3526{
3527#ifndef TOLUA_RELEASE
3529 if (
3530 !tolua_isusertype(tolua_S,1,"Nation_Type",0,&tolua_err) ||
3532 )
3533 goto tolua_lerror;
3534 else
3535#endif
3536 {
3537 lua_State* L = tolua_S;
3539 {
3540 const char* tolua_ret = (const char*) api_methods_nation_type_plural_translation(L,self);
3541 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3542 }
3543 }
3544 return 1;
3545#ifndef TOLUA_RELEASE
3547 tolua_error(tolua_S,"#ferror in function 'plural_translation'.",&tolua_err);
3548 return 0;
3549#endif
3550}
3551
3552/* function: api_methods_building_type_is_wonder */
3554{
3555#ifndef TOLUA_RELEASE
3557 if (
3558 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3560 )
3561 goto tolua_lerror;
3562 else
3563#endif
3564 {
3565 lua_State* L = tolua_S;
3567 {
3570 }
3571 }
3572 return 1;
3573#ifndef TOLUA_RELEASE
3575 tolua_error(tolua_S,"#ferror in function 'is_wonder'.",&tolua_err);
3576 return 0;
3577#endif
3578}
3579
3580/* function: api_methods_building_type_is_great_wonder */
3582{
3583#ifndef TOLUA_RELEASE
3585 if (
3586 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3588 )
3589 goto tolua_lerror;
3590 else
3591#endif
3592 {
3593 lua_State* L = tolua_S;
3595 {
3598 }
3599 }
3600 return 1;
3601#ifndef TOLUA_RELEASE
3603 tolua_error(tolua_S,"#ferror in function 'is_great_wonder'.",&tolua_err);
3604 return 0;
3605#endif
3606}
3607
3608/* function: api_methods_building_type_is_small_wonder */
3610{
3611#ifndef TOLUA_RELEASE
3613 if (
3614 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3616 )
3617 goto tolua_lerror;
3618 else
3619#endif
3620 {
3621 lua_State* L = tolua_S;
3623 {
3626 }
3627 }
3628 return 1;
3629#ifndef TOLUA_RELEASE
3631 tolua_error(tolua_S,"#ferror in function 'is_small_wonder'.",&tolua_err);
3632 return 0;
3633#endif
3634}
3635
3636/* function: api_methods_building_type_is_improvement */
3638{
3639#ifndef TOLUA_RELEASE
3641 if (
3642 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3644 )
3645 goto tolua_lerror;
3646 else
3647#endif
3648 {
3649 lua_State* L = tolua_S;
3651 {
3654 }
3655 }
3656 return 1;
3657#ifndef TOLUA_RELEASE
3659 tolua_error(tolua_S,"#ferror in function 'is_improvement'.",&tolua_err);
3660 return 0;
3661#endif
3662}
3663
3664/* function: api_methods_building_type_rule_name */
3666{
3667#ifndef TOLUA_RELEASE
3669 if (
3670 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3672 )
3673 goto tolua_lerror;
3674 else
3675#endif
3676 {
3677 lua_State* L = tolua_S;
3679 {
3680 const char* tolua_ret = (const char*) api_methods_building_type_rule_name(L,self);
3681 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3682 }
3683 }
3684 return 1;
3685#ifndef TOLUA_RELEASE
3687 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3688 return 0;
3689#endif
3690}
3691
3692/* function: api_methods_building_type_name_translation */
3694{
3695#ifndef TOLUA_RELEASE
3697 if (
3698 !tolua_isusertype(tolua_S,1,"Building_Type",0,&tolua_err) ||
3700 )
3701 goto tolua_lerror;
3702 else
3703#endif
3704 {
3705 lua_State* L = tolua_S;
3707 {
3708 const char* tolua_ret = (const char*) api_methods_building_type_name_translation(L,self);
3709 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3710 }
3711 }
3712 return 1;
3713#ifndef TOLUA_RELEASE
3715 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3716 return 0;
3717#endif
3718}
3719
3720/* function: api_methods_unit_type_has_flag */
3722{
3723#ifndef TOLUA_RELEASE
3725 if (
3726 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3729 )
3730 goto tolua_lerror;
3731 else
3732#endif
3733 {
3734 lua_State* L = tolua_S;
3736 const char* flag = ((const char*) tolua_tostring(tolua_S,2,0));
3737 {
3740 }
3741 }
3742 return 1;
3743#ifndef TOLUA_RELEASE
3745 tolua_error(tolua_S,"#ferror in function 'has_flag'.",&tolua_err);
3746 return 0;
3747#endif
3748}
3749
3750/* function: api_methods_unit_type_has_role */
3752{
3753#ifndef TOLUA_RELEASE
3755 if (
3756 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3759 )
3760 goto tolua_lerror;
3761 else
3762#endif
3763 {
3764 lua_State* L = tolua_S;
3766 const char* role = ((const char*) tolua_tostring(tolua_S,2,0));
3767 {
3770 }
3771 }
3772 return 1;
3773#ifndef TOLUA_RELEASE
3775 tolua_error(tolua_S,"#ferror in function 'has_role'.",&tolua_err);
3776 return 0;
3777#endif
3778}
3779
3780/* function: api_methods_unit_type_rule_name */
3782{
3783#ifndef TOLUA_RELEASE
3785 if (
3786 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3788 )
3789 goto tolua_lerror;
3790 else
3791#endif
3792 {
3793 lua_State* L = tolua_S;
3795 {
3796 const char* tolua_ret = (const char*) api_methods_unit_type_rule_name(L,self);
3797 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3798 }
3799 }
3800 return 1;
3801#ifndef TOLUA_RELEASE
3803 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3804 return 0;
3805#endif
3806}
3807
3808/* function: api_methods_unit_type_name_translation */
3810{
3811#ifndef TOLUA_RELEASE
3813 if (
3814 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3816 )
3817 goto tolua_lerror;
3818 else
3819#endif
3820 {
3821 lua_State* L = tolua_S;
3823 {
3824 const char* tolua_ret = (const char*) api_methods_unit_type_name_translation(L,self);
3825 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3826 }
3827 }
3828 return 1;
3829#ifndef TOLUA_RELEASE
3831 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3832 return 0;
3833#endif
3834}
3835
3836/* function: api_methods_unit_type_can_exist_at_tile */
3838{
3839#ifndef TOLUA_RELEASE
3841 if (
3842 !tolua_isusertype(tolua_S,1,"Unit_Type",0,&tolua_err) ||
3843 !tolua_isusertype(tolua_S,2,"Tile",0,&tolua_err) ||
3845 )
3846 goto tolua_lerror;
3847 else
3848#endif
3849 {
3850 lua_State* L = tolua_S;
3852 Tile* ptile = ((Tile*) tolua_tousertype(tolua_S,2,0));
3853 {
3856 }
3857 }
3858 return 1;
3859#ifndef TOLUA_RELEASE
3861 tolua_error(tolua_S,"#ferror in function 'can_exist_at_tile'.",&tolua_err);
3862 return 0;
3863#endif
3864}
3865
3866/* function: api_methods_tech_type_rule_name */
3868{
3869#ifndef TOLUA_RELEASE
3871 if (
3872 !tolua_isusertype(tolua_S,1,"Tech_Type",0,&tolua_err) ||
3874 )
3875 goto tolua_lerror;
3876 else
3877#endif
3878 {
3879 lua_State* L = tolua_S;
3881 {
3882 const char* tolua_ret = (const char*) api_methods_tech_type_rule_name(L,self);
3883 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3884 }
3885 }
3886 return 1;
3887#ifndef TOLUA_RELEASE
3889 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3890 return 0;
3891#endif
3892}
3893
3894/* function: api_methods_tech_type_name_translation */
3896{
3897#ifndef TOLUA_RELEASE
3899 if (
3900 !tolua_isusertype(tolua_S,1,"Tech_Type",0,&tolua_err) ||
3902 )
3903 goto tolua_lerror;
3904 else
3905#endif
3906 {
3907 lua_State* L = tolua_S;
3909 {
3910 const char* tolua_ret = (const char*) api_methods_tech_type_name_translation(L,self);
3911 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3912 }
3913 }
3914 return 1;
3915#ifndef TOLUA_RELEASE
3917 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3918 return 0;
3919#endif
3920}
3921
3922/* function: api_methods_terrain_rule_name */
3924{
3925#ifndef TOLUA_RELEASE
3927 if (
3928 !tolua_isusertype(tolua_S,1,"Terrain",0,&tolua_err) ||
3930 )
3931 goto tolua_lerror;
3932 else
3933#endif
3934 {
3935 lua_State* L = tolua_S;
3937 {
3938 const char* tolua_ret = (const char*) api_methods_terrain_rule_name(L,self);
3939 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3940 }
3941 }
3942 return 1;
3943#ifndef TOLUA_RELEASE
3945 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
3946 return 0;
3947#endif
3948}
3949
3950/* function: api_methods_terrain_name_translation */
3952{
3953#ifndef TOLUA_RELEASE
3955 if (
3956 !tolua_isusertype(tolua_S,1,"Terrain",0,&tolua_err) ||
3958 )
3959 goto tolua_lerror;
3960 else
3961#endif
3962 {
3963 lua_State* L = tolua_S;
3965 {
3966 const char* tolua_ret = (const char*) api_methods_terrain_name_translation(L,self);
3967 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3968 }
3969 }
3970 return 1;
3971#ifndef TOLUA_RELEASE
3973 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
3974 return 0;
3975#endif
3976}
3977
3978/* function: api_methods_terrain_class_name */
3980{
3981#ifndef TOLUA_RELEASE
3983 if (
3984 !tolua_isusertype(tolua_S,1,"Terrain",0,&tolua_err) ||
3986 )
3987 goto tolua_lerror;
3988 else
3989#endif
3990 {
3991 lua_State* L = tolua_S;
3993 {
3994 const char* tolua_ret = (const char*) api_methods_terrain_class_name(L,self);
3995 tolua_pushstring(tolua_S,(const char*)tolua_ret);
3996 }
3997 }
3998 return 1;
3999#ifndef TOLUA_RELEASE
4001 tolua_error(tolua_S,"#ferror in function 'class_name'.",&tolua_err);
4002 return 0;
4003#endif
4004}
4005
4006/* function: api_methods_disaster_rule_name */
4008{
4009#ifndef TOLUA_RELEASE
4011 if (
4012 !tolua_isusertype(tolua_S,1,"Disaster",0,&tolua_err) ||
4014 )
4015 goto tolua_lerror;
4016 else
4017#endif
4018 {
4019 lua_State* L = tolua_S;
4021 {
4022 const char* tolua_ret = (const char*) api_methods_disaster_rule_name(L,self);
4023 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4024 }
4025 }
4026 return 1;
4027#ifndef TOLUA_RELEASE
4029 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
4030 return 0;
4031#endif
4032}
4033
4034/* function: api_methods_disaster_name_translation */
4036{
4037#ifndef TOLUA_RELEASE
4039 if (
4040 !tolua_isusertype(tolua_S,1,"Disaster",0,&tolua_err) ||
4042 )
4043 goto tolua_lerror;
4044 else
4045#endif
4046 {
4047 lua_State* L = tolua_S;
4049 {
4050 const char* tolua_ret = (const char*) api_methods_disaster_name_translation(L,self);
4051 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4052 }
4053 }
4054 return 1;
4055#ifndef TOLUA_RELEASE
4057 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
4058 return 0;
4059#endif
4060}
4061
4062/* function: api_methods_achievement_rule_name */
4064{
4065#ifndef TOLUA_RELEASE
4067 if (
4068 !tolua_isusertype(tolua_S,1,"Achievement",0,&tolua_err) ||
4070 )
4071 goto tolua_lerror;
4072 else
4073#endif
4074 {
4075 lua_State* L = tolua_S;
4077 {
4078 const char* tolua_ret = (const char*) api_methods_achievement_rule_name(L,self);
4079 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4080 }
4081 }
4082 return 1;
4083#ifndef TOLUA_RELEASE
4085 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
4086 return 0;
4087#endif
4088}
4089
4090/* function: api_methods_achievement_name_translation */
4092{
4093#ifndef TOLUA_RELEASE
4095 if (
4096 !tolua_isusertype(tolua_S,1,"Achievement",0,&tolua_err) ||
4098 )
4099 goto tolua_lerror;
4100 else
4101#endif
4102 {
4103 lua_State* L = tolua_S;
4105 {
4106 const char* tolua_ret = (const char*) api_methods_achievement_name_translation(L,self);
4107 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4108 }
4109 }
4110 return 1;
4111#ifndef TOLUA_RELEASE
4113 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
4114 return 0;
4115#endif
4116}
4117
4118/* function: api_methods_action_rule_name */
4120{
4121#ifndef TOLUA_RELEASE
4123 if (
4124 !tolua_isusertype(tolua_S,1,"Action",0,&tolua_err) ||
4126 )
4127 goto tolua_lerror;
4128 else
4129#endif
4130 {
4131 lua_State* L = tolua_S;
4133 {
4134 const char* tolua_ret = (const char*) api_methods_action_rule_name(L,self);
4135 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4136 }
4137 }
4138 return 1;
4139#ifndef TOLUA_RELEASE
4141 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
4142 return 0;
4143#endif
4144}
4145
4146/* function: api_methods_action_name_translation */
4148{
4149#ifndef TOLUA_RELEASE
4151 if (
4152 !tolua_isusertype(tolua_S,1,"Action",0,&tolua_err) ||
4154 )
4155 goto tolua_lerror;
4156 else
4157#endif
4158 {
4159 lua_State* L = tolua_S;
4161 {
4162 const char* tolua_ret = (const char*) api_methods_action_name_translation(L,self);
4163 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4164 }
4165 }
4166 return 1;
4167#ifndef TOLUA_RELEASE
4169 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
4170 return 0;
4171#endif
4172}
4173
4174/* function: api_methods_action_target_kind */
4176{
4177#ifndef TOLUA_RELEASE
4179 if (
4180 !tolua_isusertype(tolua_S,1,"Action",0,&tolua_err) ||
4182 )
4183 goto tolua_lerror;
4184 else
4185#endif
4186 {
4187 lua_State* L = tolua_S;
4189 {
4190 const char* tolua_ret = (const char*) api_methods_action_target_kind(L,self);
4191 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4192 }
4193 }
4194 return 1;
4195#ifndef TOLUA_RELEASE
4197 tolua_error(tolua_S,"#ferror in function 'target_kind'.",&tolua_err);
4198 return 0;
4199#endif
4200}
4201
4202/* function: api_methods_specialist_rule_name */
4204{
4205#ifndef TOLUA_RELEASE
4207 if (
4208 !tolua_isusertype(tolua_S,1,"Specialist",0,&tolua_err) ||
4210 )
4211 goto tolua_lerror;
4212 else
4213#endif
4214 {
4215 lua_State* L = tolua_S;
4217 {
4218 const char* tolua_ret = (const char*) api_methods_specialist_rule_name(L,self);
4219 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4220 }
4221 }
4222 return 1;
4223#ifndef TOLUA_RELEASE
4225 tolua_error(tolua_S,"#ferror in function 'rule_name'.",&tolua_err);
4226 return 0;
4227#endif
4228}
4229
4230/* function: api_methods_specialist_name_translation */
4232{
4233#ifndef TOLUA_RELEASE
4235 if (
4236 !tolua_isusertype(tolua_S,1,"Specialist",0,&tolua_err) ||
4238 )
4239 goto tolua_lerror;
4240 else
4241#endif
4242 {
4243 lua_State* L = tolua_S;
4245 {
4246 const char* tolua_ret = (const char*) api_methods_specialist_name_translation(L,self);
4247 tolua_pushstring(tolua_S,(const char*)tolua_ret);
4248 }
4249 }
4250 return 1;
4251#ifndef TOLUA_RELEASE
4253 tolua_error(tolua_S,"#ferror in function 'name_translation'.",&tolua_err);
4254 return 0;
4255#endif
4256}
4257
4258/* function: api_methods_unit_list_link_data */
4260{
4261#ifndef TOLUA_RELEASE
4263 if (
4264 !tolua_isusertype(tolua_S,1,"Unit_List_Link",0,&tolua_err) ||
4266 )
4267 goto tolua_lerror;
4268 else
4269#endif
4270 {
4271 lua_State* L = tolua_S;
4273 {
4275 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit");
4276 }
4277 }
4278 return 1;
4279#ifndef TOLUA_RELEASE
4281 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
4282 return 0;
4283#endif
4284}
4285
4286/* function: api_methods_unit_list_next_link */
4288{
4289#ifndef TOLUA_RELEASE
4291 if (
4292 !tolua_isusertype(tolua_S,1,"Unit_List_Link",0,&tolua_err) ||
4294 )
4295 goto tolua_lerror;
4296 else
4297#endif
4298 {
4299 lua_State* L = tolua_S;
4301 {
4303 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_List_Link");
4304 }
4305 }
4306 return 1;
4307#ifndef TOLUA_RELEASE
4309 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
4310 return 0;
4311#endif
4312}
4313
4314/* function: api_methods_city_list_link_data */
4316{
4317#ifndef TOLUA_RELEASE
4319 if (
4320 !tolua_isusertype(tolua_S,1,"City_List_Link",0,&tolua_err) ||
4322 )
4323 goto tolua_lerror;
4324 else
4325#endif
4326 {
4327 lua_State* L = tolua_S;
4329 {
4331 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City");
4332 }
4333 }
4334 return 1;
4335#ifndef TOLUA_RELEASE
4337 tolua_error(tolua_S,"#ferror in function 'data'.",&tolua_err);
4338 return 0;
4339#endif
4340}
4341
4342/* function: api_methods_city_list_next_link */
4344{
4345#ifndef TOLUA_RELEASE
4347 if (
4348 !tolua_isusertype(tolua_S,1,"City_List_Link",0,&tolua_err) ||
4350 )
4351 goto tolua_lerror;
4352 else
4353#endif
4354 {
4355 lua_State* L = tolua_S;
4357 {
4359 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City_List_Link");
4360 }
4361 }
4362 return 1;
4363#ifndef TOLUA_RELEASE
4365 tolua_error(tolua_S,"#ferror in function 'next'.",&tolua_err);
4366 return 0;
4367#endif
4368}
4369
4370/* function: api_find_counter_by_name */
4372{
4373#ifndef TOLUA_RELEASE
4375 if (
4378 )
4379 goto tolua_lerror;
4380 else
4381#endif
4382 {
4383 lua_State* L = tolua_S;
4384 const char* name = ((const char*) tolua_tostring(tolua_S,1,0));
4385 {
4387 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Counter");
4388 }
4389 }
4390 return 1;
4391#ifndef TOLUA_RELEASE
4393 tolua_error(tolua_S,"#ferror in function 'counter'.",&tolua_err);
4394 return 0;
4395#endif
4396}
4397
4398/* function: api_find_counter */
4400{
4402 if (
4405 )
4406 goto tolua_lerror;
4407 else
4408 {
4409 lua_State* L = tolua_S;
4410 int counter_id = ((int) tolua_tonumber(tolua_S,1,0));
4411 {
4413 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Counter");
4414 }
4415 }
4416 return 1;
4419}
4420
4421/* function: api_find_player_by_name */
4423{
4424#ifndef TOLUA_RELEASE
4426 if (
4429 )
4430 goto tolua_lerror;
4431 else
4432#endif
4433 {
4434 lua_State* L = tolua_S;
4435 const char* name = ((const char*) tolua_tostring(tolua_S,1,0));
4436 {
4438 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Player");
4439 }
4440 }
4441 return 1;
4442#ifndef TOLUA_RELEASE
4444 tolua_error(tolua_S,"#ferror in function 'player'.",&tolua_err);
4445 return 0;
4446#endif
4447}
4448
4449/* function: api_find_player */
4451{
4453 if (
4456 )
4457 goto tolua_lerror;
4458 else
4459 {
4460 lua_State* L = tolua_S;
4461 int player_id = ((int) tolua_tonumber(tolua_S,1,0));
4462 {
4463 Player* tolua_ret = (Player*) api_find_player(L,player_id);
4464 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Player");
4465 }
4466 }
4467 return 1;
4470}
4471
4472/* function: api_find_city */
4474{
4475#ifndef TOLUA_RELEASE
4477 if (
4478 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
4481 )
4482 goto tolua_lerror;
4483 else
4484#endif
4485 {
4486 lua_State* L = tolua_S;
4487 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
4488 int city_id = ((int) tolua_tonumber(tolua_S,2,0));
4489 {
4490 City* tolua_ret = (City*) api_find_city(L,pplayer,city_id);
4491 tolua_pushusertype(tolua_S,(void*)tolua_ret,"City");
4492 }
4493 }
4494 return 1;
4495#ifndef TOLUA_RELEASE
4497 tolua_error(tolua_S,"#ferror in function 'city'.",&tolua_err);
4498 return 0;
4499#endif
4500}
4501
4502/* function: api_find_unit */
4504{
4505#ifndef TOLUA_RELEASE
4507 if (
4508 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
4511 )
4512 goto tolua_lerror;
4513 else
4514#endif
4515 {
4516 lua_State* L = tolua_S;
4517 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
4518 int unit_id = ((int) tolua_tonumber(tolua_S,2,0));
4519 {
4520 Unit* tolua_ret = (Unit*) api_find_unit(L,pplayer,unit_id);
4521 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit");
4522 }
4523 }
4524 return 1;
4525#ifndef TOLUA_RELEASE
4527 tolua_error(tolua_S,"#ferror in function 'unit'.",&tolua_err);
4528 return 0;
4529#endif
4530}
4531
4532/* function: api_find_transport_unit */
4534{
4535#ifndef TOLUA_RELEASE
4537 if (
4538 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
4539 !tolua_isusertype(tolua_S,2,"Unit_Type",0,&tolua_err) ||
4540 !tolua_isusertype(tolua_S,3,"Tile",0,&tolua_err) ||
4542 )
4543 goto tolua_lerror;
4544 else
4545#endif
4546 {
4547 lua_State* L = tolua_S;
4548 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
4550 Tile* ptile = ((Tile*) tolua_tousertype(tolua_S,3,0));
4551 {
4552 Unit* tolua_ret = (Unit*) api_find_transport_unit(L,pplayer,ptype,ptile);
4553 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit");
4554 }
4555 }
4556 return 1;
4557#ifndef TOLUA_RELEASE
4559 tolua_error(tolua_S,"#ferror in function 'transport_unit'.",&tolua_err);
4560 return 0;
4561#endif
4562}
4563
4564/* function: api_find_tile */
4566{
4567#ifndef TOLUA_RELEASE
4569 if (
4573 )
4574 goto tolua_lerror;
4575 else
4576#endif
4577 {
4578 lua_State* L = tolua_S;
4579 int nat_x = ((int) tolua_tonumber(tolua_S,1,0));
4580 int nat_y = ((int) tolua_tonumber(tolua_S,2,0));
4581 {
4583 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
4584 }
4585 }
4586 return 1;
4587#ifndef TOLUA_RELEASE
4589 tolua_error(tolua_S,"#ferror in function 'tile'.",&tolua_err);
4590 return 0;
4591#endif
4592}
4593
4594/* function: api_find_tile_by_index */
4596{
4598 if (
4601 )
4602 goto tolua_lerror;
4603 else
4604 {
4605 lua_State* L = tolua_S;
4606 int tindex = ((int) tolua_tonumber(tolua_S,1,0));
4607 {
4609 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tile");
4610 }
4611 }
4612 return 1;
4615}
4616
4617/* function: api_find_government_by_name */
4619{
4620#ifndef TOLUA_RELEASE
4622 if (
4625 )
4626 goto tolua_lerror;
4627 else
4628#endif
4629 {
4630 lua_State* L = tolua_S;
4631 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4632 {
4634 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Government");
4635 }
4636 }
4637 return 1;
4638#ifndef TOLUA_RELEASE
4640 tolua_error(tolua_S,"#ferror in function 'government'.",&tolua_err);
4641 return 0;
4642#endif
4643}
4644
4645/* function: api_find_government */
4647{
4649 if (
4652 )
4653 goto tolua_lerror;
4654 else
4655 {
4656 lua_State* L = tolua_S;
4657 int government_id = ((int) tolua_tonumber(tolua_S,1,0));
4658 {
4660 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Government");
4661 }
4662 }
4663 return 1;
4666}
4667
4668/* function: api_find_nation_type_by_name */
4670{
4671#ifndef TOLUA_RELEASE
4673 if (
4676 )
4677 goto tolua_lerror;
4678 else
4679#endif
4680 {
4681 lua_State* L = tolua_S;
4682 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4683 {
4685 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Nation_Type");
4686 }
4687 }
4688 return 1;
4689#ifndef TOLUA_RELEASE
4691 tolua_error(tolua_S,"#ferror in function 'nation_type'.",&tolua_err);
4692 return 0;
4693#endif
4694}
4695
4696/* function: api_find_nation_type */
4698{
4700 if (
4703 )
4704 goto tolua_lerror;
4705 else
4706 {
4707 lua_State* L = tolua_S;
4709 {
4711 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Nation_Type");
4712 }
4713 }
4714 return 1;
4717}
4718
4719/* function: api_find_building_type_by_name */
4721{
4722#ifndef TOLUA_RELEASE
4724 if (
4727 )
4728 goto tolua_lerror;
4729 else
4730#endif
4731 {
4732 lua_State* L = tolua_S;
4733 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4734 {
4736 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Building_Type");
4737 }
4738 }
4739 return 1;
4740#ifndef TOLUA_RELEASE
4742 tolua_error(tolua_S,"#ferror in function 'building_type'.",&tolua_err);
4743 return 0;
4744#endif
4745}
4746
4747/* function: api_find_building_type */
4749{
4751 if (
4754 )
4755 goto tolua_lerror;
4756 else
4757 {
4758 lua_State* L = tolua_S;
4760 {
4762 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Building_Type");
4763 }
4764 }
4765 return 1;
4768}
4769
4770/* function: api_find_unit_type_by_name */
4772{
4773#ifndef TOLUA_RELEASE
4775 if (
4778 )
4779 goto tolua_lerror;
4780 else
4781#endif
4782 {
4783 lua_State* L = tolua_S;
4784 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4785 {
4787 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_Type");
4788 }
4789 }
4790 return 1;
4791#ifndef TOLUA_RELEASE
4793 tolua_error(tolua_S,"#ferror in function 'unit_type'.",&tolua_err);
4794 return 0;
4795#endif
4796}
4797
4798/* function: api_find_unit_type */
4800{
4802 if (
4805 )
4806 goto tolua_lerror;
4807 else
4808 {
4809 lua_State* L = tolua_S;
4810 int unit_type_id = ((int) tolua_tonumber(tolua_S,1,0));
4811 {
4813 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_Type");
4814 }
4815 }
4816 return 1;
4819}
4820
4821/* function: api_find_role_unit_type */
4823{
4824#ifndef TOLUA_RELEASE
4826 if (
4828 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
4830 )
4831 goto tolua_lerror;
4832 else
4833#endif
4834 {
4835 lua_State* L = tolua_S;
4836 const char* role_name = ((const char*) tolua_tostring(tolua_S,1,0));
4837 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,2,0));
4838 {
4840 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Unit_Type");
4841 }
4842 }
4843 return 1;
4844#ifndef TOLUA_RELEASE
4846 tolua_error(tolua_S,"#ferror in function 'role_unit_type'.",&tolua_err);
4847 return 0;
4848#endif
4849}
4850
4851/* function: api_find_tech_type_by_name */
4853{
4854#ifndef TOLUA_RELEASE
4856 if (
4859 )
4860 goto tolua_lerror;
4861 else
4862#endif
4863 {
4864 lua_State* L = tolua_S;
4865 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4866 {
4868 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tech_Type");
4869 }
4870 }
4871 return 1;
4872#ifndef TOLUA_RELEASE
4874 tolua_error(tolua_S,"#ferror in function 'tech_type'.",&tolua_err);
4875 return 0;
4876#endif
4877}
4878
4879/* function: api_find_tech_type */
4881{
4883 if (
4886 )
4887 goto tolua_lerror;
4888 else
4889 {
4890 lua_State* L = tolua_S;
4891 int tech_type_id = ((int) tolua_tonumber(tolua_S,1,0));
4892 {
4894 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Tech_Type");
4895 }
4896 }
4897 return 1;
4900}
4901
4902/* function: api_find_terrain_by_name */
4904{
4905#ifndef TOLUA_RELEASE
4907 if (
4910 )
4911 goto tolua_lerror;
4912 else
4913#endif
4914 {
4915 lua_State* L = tolua_S;
4916 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4917 {
4919 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Terrain");
4920 }
4921 }
4922 return 1;
4923#ifndef TOLUA_RELEASE
4925 tolua_error(tolua_S,"#ferror in function 'terrain'.",&tolua_err);
4926 return 0;
4927#endif
4928}
4929
4930/* function: api_find_terrain */
4932{
4934 if (
4937 )
4938 goto tolua_lerror;
4939 else
4940 {
4941 lua_State* L = tolua_S;
4942 int terrain_id = ((int) tolua_tonumber(tolua_S,1,0));
4943 {
4945 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Terrain");
4946 }
4947 }
4948 return 1;
4951}
4952
4953/* function: api_find_achievement_by_name */
4955{
4956#ifndef TOLUA_RELEASE
4958 if (
4961 )
4962 goto tolua_lerror;
4963 else
4964#endif
4965 {
4966 lua_State* L = tolua_S;
4967 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
4968 {
4970 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Achievement");
4971 }
4972 }
4973 return 1;
4974#ifndef TOLUA_RELEASE
4976 tolua_error(tolua_S,"#ferror in function 'achievement'.",&tolua_err);
4977 return 0;
4978#endif
4979}
4980
4981/* function: api_find_achievement */
4983{
4985 if (
4988 )
4989 goto tolua_lerror;
4990 else
4991 {
4992 lua_State* L = tolua_S;
4994 {
4996 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Achievement");
4997 }
4998 }
4999 return 1;
5002}
5003
5004/* function: api_find_specialist_by_name */
5006{
5007#ifndef TOLUA_RELEASE
5009 if (
5012 )
5013 goto tolua_lerror;
5014 else
5015#endif
5016 {
5017 lua_State* L = tolua_S;
5018 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
5019 {
5021 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Specialist");
5022 }
5023 }
5024 return 1;
5025#ifndef TOLUA_RELEASE
5027 tolua_error(tolua_S,"#ferror in function 'specialist'.",&tolua_err);
5028 return 0;
5029#endif
5030}
5031
5032/* function: api_find_specialist */
5034{
5036 if (
5039 )
5040 goto tolua_lerror;
5041 else
5042 {
5043 lua_State* L = tolua_S;
5044 int spec_id = ((int) tolua_tonumber(tolua_S,1,0));
5045 {
5047 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Specialist");
5048 }
5049 }
5050 return 1;
5053}
5054
5055/* function: api_find_disaster_by_name */
5057{
5058#ifndef TOLUA_RELEASE
5060 if (
5063 )
5064 goto tolua_lerror;
5065 else
5066#endif
5067 {
5068 lua_State* L = tolua_S;
5069 const char* name_orig = ((const char*) tolua_tostring(tolua_S,1,0));
5070 {
5072 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Disaster");
5073 }
5074 }
5075 return 1;
5076#ifndef TOLUA_RELEASE
5078 tolua_error(tolua_S,"#ferror in function 'disaster'.",&tolua_err);
5079 return 0;
5080#endif
5081}
5082
5083/* function: api_find_disaster */
5085{
5087 if (
5090 )
5091 goto tolua_lerror;
5092 else
5093 {
5094 lua_State* L = tolua_S;
5095 int disaster_id = ((int) tolua_tonumber(tolua_S,1,0));
5096 {
5098 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Disaster");
5099 }
5100 }
5101 return 1;
5104}
5105
5106/* function: api_utilities_str2dir */
5108{
5109#ifndef TOLUA_RELEASE
5111 if (
5114 )
5115 goto tolua_lerror;
5116 else
5117#endif
5118 {
5119 lua_State* L = tolua_S;
5120 const char* str = ((const char*) tolua_tostring(tolua_S,1,0));
5121 {
5123 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5124 }
5125 }
5126 return 1;
5127#ifndef TOLUA_RELEASE
5129 tolua_error(tolua_S,"#ferror in function 'direction'.",&tolua_err);
5130 return 0;
5131#endif
5132}
5133
5134/* function: api_find_direction */
5136{
5138 if (
5141 )
5142 goto tolua_lerror;
5143 else
5144 {
5145 lua_State* L = tolua_S;
5146 int id = ((int) tolua_tonumber(tolua_S,1,0));
5147 {
5149 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5150 }
5151 }
5152 return 1;
5155}
5156
5157/* function: api_find_action_type_by_name */
5159{
5160#ifndef TOLUA_RELEASE
5162 if (
5165 )
5166 goto tolua_lerror;
5167 else
5168#endif
5169 {
5170 lua_State* L = tolua_S;
5171 const char* name = ((const char*) tolua_tostring(tolua_S,1,0));
5172 {
5174 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Action");
5175 }
5176 }
5177 return 1;
5178#ifndef TOLUA_RELEASE
5180 tolua_error(tolua_S,"#ferror in function 'action'.",&tolua_err);
5181 return 0;
5182#endif
5183}
5184
5185/* function: api_find_action_type_by_id */
5187{
5189 if (
5192 )
5193 goto tolua_lerror;
5194 else
5195 {
5196 lua_State* L = tolua_S;
5197 int id = ((int) tolua_tonumber(tolua_S,1,0));
5198 {
5200 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Action");
5201 }
5202 }
5203 return 1;
5206}
5207
5208/* function: api_find_nonexistent */
5210{
5211#ifndef TOLUA_RELEASE
5213 if (
5215 )
5216 goto tolua_lerror;
5217 else
5218#endif
5219 {
5220 lua_State* L = tolua_S;
5221 {
5223 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Nonexistent");
5224 }
5225 }
5226 return 1;
5227#ifndef TOLUA_RELEASE
5229 tolua_error(tolua_S,"#ferror in function 'nonexistent'.",&tolua_err);
5230 return 0;
5231#endif
5232}
5233
5234/* function: api_effects_world_bonus */
5236{
5237#ifndef TOLUA_RELEASE
5239 if (
5242 )
5243 goto tolua_lerror;
5244 else
5245#endif
5246 {
5247 lua_State* L = tolua_S;
5248 const char* effect_type = ((const char*) tolua_tostring(tolua_S,1,0));
5249 {
5250 int tolua_ret = (int) api_effects_world_bonus(L,effect_type);
5252 }
5253 }
5254 return 1;
5255#ifndef TOLUA_RELEASE
5257 tolua_error(tolua_S,"#ferror in function 'world_bonus'.",&tolua_err);
5258 return 0;
5259#endif
5260}
5261
5262/* function: api_effects_player_bonus */
5264{
5265#ifndef TOLUA_RELEASE
5267 if (
5268 !tolua_isusertype(tolua_S,1,"Player",0,&tolua_err) ||
5271 )
5272 goto tolua_lerror;
5273 else
5274#endif
5275 {
5276 lua_State* L = tolua_S;
5277 Player* pplayer = ((Player*) tolua_tousertype(tolua_S,1,0));
5278 const char* effect_type = ((const char*) tolua_tostring(tolua_S,2,0));
5279 {
5280 int tolua_ret = (int) api_effects_player_bonus(L,pplayer,effect_type);
5282 }
5283 }
5284 return 1;
5285#ifndef TOLUA_RELEASE
5287 tolua_error(tolua_S,"#ferror in function 'player_bonus'.",&tolua_err);
5288 return 0;
5289#endif
5290}
5291
5292/* function: api_effects_city_bonus */
5294{
5295#ifndef TOLUA_RELEASE
5297 if (
5298 !tolua_isusertype(tolua_S,1,"City",0,&tolua_err) ||
5301 )
5302 goto tolua_lerror;
5303 else
5304#endif
5305 {
5306 lua_State* L = tolua_S;
5307 City* pcity = ((City*) tolua_tousertype(tolua_S,1,0));
5308 const char* effect_type = ((const char*) tolua_tostring(tolua_S,2,0));
5309 {
5310 int tolua_ret = (int) api_effects_city_bonus(L,pcity,effect_type);
5312 }
5313 }
5314 return 1;
5315#ifndef TOLUA_RELEASE
5317 tolua_error(tolua_S,"#ferror in function 'city_bonus'.",&tolua_err);
5318 return 0;
5319#endif
5320}
5321
5322/* function: api_effects_unit_bonus */
5324{
5325#ifndef TOLUA_RELEASE
5327 if (
5328 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
5329 !tolua_isusertype(tolua_S,2,"Player",0,&tolua_err) ||
5332 )
5333 goto tolua_lerror;
5334 else
5335#endif
5336 {
5337 lua_State* L = tolua_S;
5338 Unit* punit = ((Unit*) tolua_tousertype(tolua_S,1,0));
5339 Player* other_player = ((Player*) tolua_tousertype(tolua_S,2,0));
5340 const char* effect_type = ((const char*) tolua_tostring(tolua_S,3,0));
5341 {
5342 int tolua_ret = (int) api_effects_unit_bonus(L,punit,other_player,effect_type);
5344 }
5345 }
5346 return 1;
5347#ifndef TOLUA_RELEASE
5349 tolua_error(tolua_S,"#ferror in function 'unit_bonus'.",&tolua_err);
5350 return 0;
5351#endif
5352}
5353
5354/* function: api_effects_tile_bonus */
5356{
5357#ifndef TOLUA_RELEASE
5359 if (
5360 !tolua_isusertype(tolua_S,1,"Tile",0,&tolua_err) ||
5361 !tolua_isusertype(tolua_S,2,"City",0,&tolua_err) ||
5365 )
5366 goto tolua_lerror;
5367 else
5368#endif
5369 {
5370 lua_State* L = tolua_S;
5371 Tile* ptile = ((Tile*) tolua_tousertype(tolua_S,1,0));
5372 City* pcity = ((City*) tolua_tousertype(tolua_S,2,0));
5373 const char* output_id = ((const char*) tolua_tostring(tolua_S,3,0));
5374 const char* effect_type = ((const char*) tolua_tostring(tolua_S,4,0));
5375 {
5376 int tolua_ret = (int) api_effects_tile_bonus(L,ptile,pcity,output_id,effect_type);
5378 }
5379 }
5380 return 1;
5381#ifndef TOLUA_RELEASE
5383 tolua_error(tolua_S,"#ferror in function 'tile_bonus'.",&tolua_err);
5384 return 0;
5385#endif
5386}
5387
5388/* function: api_effects_specialist_bonus */
5390{
5391#ifndef TOLUA_RELEASE
5393 if (
5394 !tolua_isusertype(tolua_S,1,"Specialist",0,&tolua_err) ||
5399 )
5400 goto tolua_lerror;
5401 else
5402#endif
5403 {
5404 lua_State* L = tolua_S;
5406 int d = ((int) tolua_tovalue(tolua_S,2,0));
5407 const char* output_id = ((const char*) tolua_tostring(tolua_S,3,0));
5408 const char* effect_type = ((const char*) tolua_tostring(tolua_S,4,0));
5409 {
5410 int tolua_ret = (int) api_effects_specialist_bonus(L,s,d,output_id,effect_type);
5412 }
5413 }
5414 return 1;
5415#ifndef TOLUA_RELEASE
5417 tolua_error(tolua_S,"#ferror in function 'specialist_bonus'.",&tolua_err);
5418 return 0;
5419#endif
5420}
5421
5422/* function: api_effects_unit_vs_tile_bonus */
5424{
5425#ifndef TOLUA_RELEASE
5427 if (
5428 !tolua_isusertype(tolua_S,1,"Unit",0,&tolua_err) ||
5429 !tolua_isusertype(tolua_S,2,"Tile",0,&tolua_err) ||
5432 )
5433 goto tolua_lerror;
5434 else
5435#endif
5436 {
5437 lua_State* L = tolua_S;
5438 Unit* punit = ((Unit*) tolua_tousertype(tolua_S,1,0));
5439 Tile* ptile = ((Tile*) tolua_tousertype(tolua_S,2,0));
5440 const char* effect_type = ((const char*) tolua_tostring(tolua_S,3,0));
5441 {
5442 int tolua_ret = (int) api_effects_unit_vs_tile_bonus(L,punit,ptile,effect_type);
5444 }
5445 }
5446 return 1;
5447#ifndef TOLUA_RELEASE
5449 tolua_error(tolua_S,"#ferror in function 'unit_vs_tile_bonus'.",&tolua_err);
5450 return 0;
5451#endif
5452}
5453
5454/* function: api_utilities_direction_id */
5456{
5457#ifndef TOLUA_RELEASE
5459 if (
5460 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5462 )
5463 goto tolua_lerror;
5464 else
5465#endif
5466 {
5467 lua_State* L = tolua_S;
5469 {
5472 }
5473 }
5474 return 1;
5475#ifndef TOLUA_RELEASE
5477 tolua_error(tolua_S,"#ferror in function 'id'.",&tolua_err);
5478 return 0;
5479#endif
5480}
5481
5482/* function: api_utilities_dir2str */
5484{
5485#ifndef TOLUA_RELEASE
5487 if (
5488 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5490 )
5491 goto tolua_lerror;
5492 else
5493#endif
5494 {
5495 lua_State* L = tolua_S;
5497 {
5498 const char* tolua_ret = (const char*) api_utilities_dir2str(L,dir);
5499 tolua_pushstring(tolua_S,(const char*)tolua_ret);
5500 }
5501 }
5502 return 1;
5503#ifndef TOLUA_RELEASE
5505 tolua_error(tolua_S,"#ferror in function 'name'.",&tolua_err);
5506 return 0;
5507#endif
5508}
5509
5510/* function: api_utilities_direction_is_cardinal */
5512{
5513#ifndef TOLUA_RELEASE
5515 if (
5516 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5518 )
5519 goto tolua_lerror;
5520 else
5521#endif
5522 {
5523 lua_State* L = tolua_S;
5525 {
5528 }
5529 }
5530 return 1;
5531#ifndef TOLUA_RELEASE
5533 tolua_error(tolua_S,"#ferror in function 'cardinal'.",&tolua_err);
5534 return 0;
5535#endif
5536}
5537
5538/* function: api_utilities_str2dir */
5540{
5541#ifndef TOLUA_RELEASE
5543 if (
5546 )
5547 goto tolua_lerror;
5548 else
5549#endif
5550 {
5551 lua_State* L = tolua_S;
5552 const char* str = ((const char*) tolua_tostring(tolua_S,1,0));
5553 {
5555 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5556 }
5557 }
5558 return 1;
5559#ifndef TOLUA_RELEASE
5561 tolua_error(tolua_S,"#ferror in function 'str2dir'.",&tolua_err);
5562 return 0;
5563#endif
5564}
5565
5566/* function: api_utilities_dir_ccw */
5568{
5569#ifndef TOLUA_RELEASE
5571 if (
5572 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5574 )
5575 goto tolua_lerror;
5576 else
5577#endif
5578 {
5579 lua_State* L = tolua_S;
5581 {
5583 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5584 }
5585 }
5586 return 1;
5587#ifndef TOLUA_RELEASE
5589 tolua_error(tolua_S,"#ferror in function 'next_ccw'.",&tolua_err);
5590 return 0;
5591#endif
5592}
5593
5594/* function: api_utilities_dir_cw */
5596{
5597#ifndef TOLUA_RELEASE
5599 if (
5600 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5602 )
5603 goto tolua_lerror;
5604 else
5605#endif
5606 {
5607 lua_State* L = tolua_S;
5609 {
5611 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5612 }
5613 }
5614 return 1;
5615#ifndef TOLUA_RELEASE
5617 tolua_error(tolua_S,"#ferror in function 'next_cw'.",&tolua_err);
5618 return 0;
5619#endif
5620}
5621
5622/* function: api_utilities_opposite_dir */
5624{
5625#ifndef TOLUA_RELEASE
5627 if (
5628 !tolua_isusertype(tolua_S,1,"Direction",0,&tolua_err) ||
5630 )
5631 goto tolua_lerror;
5632 else
5633#endif
5634 {
5635 lua_State* L = tolua_S;
5637 {
5639 tolua_pushusertype(tolua_S,(void*)tolua_ret,"Direction");
5640 }
5641 }
5642 return 1;
5643#ifndef TOLUA_RELEASE
5645 tolua_error(tolua_S,"#ferror in function 'opposite'.",&tolua_err);
5646 return 0;
5647#endif
5648}
5649
5650/* Open lib function */
5652{
5657 tolua_cclass(tolua_S,"Player","Player","",NULL);
5658 tolua_beginmodule(tolua_S,"Player");
5664 tolua_cclass(tolua_S,"City","City","",NULL);
5665 tolua_beginmodule(tolua_S,"City");
5671 tolua_cclass(tolua_S,"Counter","Counter","",NULL);
5672 tolua_beginmodule(tolua_S,"Counter");
5674 tolua_cclass(tolua_S,"Connection","Connection","",NULL);
5675 tolua_beginmodule(tolua_S,"Connection");
5678 tolua_cclass(tolua_S,"Unit","Unit","",NULL);
5679 tolua_beginmodule(tolua_S,"Unit");
5687 tolua_cclass(tolua_S,"Tile","Tile","",NULL);
5688 tolua_beginmodule(tolua_S,"Tile");
5693 tolua_cclass(tolua_S,"Government","Government","",NULL);
5694 tolua_beginmodule(tolua_S,"Government");
5697 tolua_cclass(tolua_S,"Nation_Type","Nation_Type","",NULL);
5698 tolua_beginmodule(tolua_S,"Nation_Type");
5701 tolua_cclass(tolua_S,"Building_Type","Building_Type","",NULL);
5702 tolua_beginmodule(tolua_S,"Building_Type");
5706 tolua_cclass(tolua_S,"Unit_Type","Unit_Type","",NULL);
5707 tolua_beginmodule(tolua_S,"Unit_Type");
5712 tolua_cclass(tolua_S,"Tech_Type","Tech_Type","",NULL);
5713 tolua_beginmodule(tolua_S,"Tech_Type");
5717 tolua_cclass(tolua_S,"Terrain","Terrain","",NULL);
5718 tolua_beginmodule(tolua_S,"Terrain");
5721 tolua_cclass(tolua_S,"Disaster","Disaster","",NULL);
5722 tolua_beginmodule(tolua_S,"Disaster");
5725 tolua_cclass(tolua_S,"Achievement","Achievement","",NULL);
5726 tolua_beginmodule(tolua_S,"Achievement");
5729 tolua_cclass(tolua_S,"Action","Action","",NULL);
5730 tolua_beginmodule(tolua_S,"Action");
5733 tolua_cclass(tolua_S,"Specialist","Specialist","",NULL);
5734 tolua_beginmodule(tolua_S,"Specialist");
5737 tolua_cclass(tolua_S,"Direction","Direction","",NULL);
5738 tolua_beginmodule(tolua_S,"Direction");
5740 tolua_cclass(tolua_S,"Unit_List_Link","Unit_List_Link","",NULL);
5741 tolua_beginmodule(tolua_S,"Unit_List_Link");
5743 tolua_cclass(tolua_S,"City_List_Link","City_List_Link","",NULL);
5744 tolua_beginmodule(tolua_S,"City_List_Link");
5746 tolua_cclass(tolua_S,"Game_Info","Game_Info","",NULL);
5747 tolua_beginmodule(tolua_S,"Game_Info");
5758 tolua_module(tolua_S,"game",1);
5759 tolua_beginmodule(tolua_S,"game");
5771 tolua_module(tolua_S,"Counter",0);
5772 tolua_beginmodule(tolua_S,"Counter");
5777 tolua_module(tolua_S,"Player",0);
5778 tolua_beginmodule(tolua_S,"Player");
5779 tolua_module(tolua_S,"properties",0);
5780 tolua_beginmodule(tolua_S,"properties");
5810 tolua_module(tolua_S,"methods_private",0);
5811 tolua_beginmodule(tolua_S,"methods_private");
5813 tolua_module(tolua_S,"Player",0);
5814 tolua_beginmodule(tolua_S,"Player");
5819
5820 { /* begin embedded lua code */
5821 static unsigned char B[] = {
5822 10,102,117,110, 99,116,105,111,110, 32, 80,108, 97,121,101,
5823 114, 58,105,115, 95,104,117,109, 97,110, 40, 41, 10,114,101,
5824 116,117,114,110, 32,110,111,116, 32,115,101,108,102, 46,104,
5825 97,115, 95,102,108, 97,103, 40,115,101,108,102, 44, 32, 34,
5826 65, 73, 34, 41, 59, 10,101,110,100, 10,102,117,110, 99,116,
5827 105,111,110, 32, 80,108, 97,121,101,114, 58,101,120,105,115,
5828 116,115, 40, 41, 10,114,101,116,117,114,110, 32,116,114,117,
5829 101, 10,101,110,100,32
5830 };
5831 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5833 } /* end of embedded lua code */
5834
5835 tolua_module(tolua_S,"City",0);
5836 tolua_beginmodule(tolua_S,"City");
5837 tolua_module(tolua_S,"properties",0);
5838 tolua_beginmodule(tolua_S,"properties");
5858
5859 { /* begin embedded lua code */
5860 static unsigned char B[] = {
5861 10,102,117,110, 99,116,105,111,110, 32, 67,105,116,121, 58,
5862 101,120,105,115,116,115, 40, 41, 10,114,101,116,117,114,110,
5863 32,116,114,117,101, 10,101,110,100,32
5864 };
5865 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5867 } /* end of embedded lua code */
5868
5869 tolua_module(tolua_S,"Unit",0);
5870 tolua_beginmodule(tolua_S,"Unit");
5871 tolua_module(tolua_S,"properties",0);
5872 tolua_beginmodule(tolua_S,"properties");
5884 tolua_module(tolua_S,"methods_private",0);
5885 tolua_beginmodule(tolua_S,"methods_private");
5886 tolua_module(tolua_S,"Unit",0);
5887 tolua_beginmodule(tolua_S,"Unit");
5891
5892 { /* begin embedded lua code */
5893 static unsigned char B[] = {
5894 10,102,117,110, 99,116,105,111,110, 32, 85,110,105,116, 58,
5895 101,120,105,115,116,115, 40, 41, 10,114,101,116,117,114,110,
5896 32,116,114,117,101, 10,101,110,100, 10,102,117,110, 99,116,
5897 105,111,110, 32, 85,110,105,116, 58,103,101,116, 95,104,111,
5898 109,101, 99,105,116,121, 40, 41, 10,114,101,116,117,114,110,
5899 32,102,105,110,100, 46, 99,105,116,121, 40,115,101,108,102,
5900 46,111,119,110,101,114, 44, 32,115,101,108,102, 46,104,111,
5901 109,101, 99,105,116,121, 41, 10,101,110,100,32
5902 };
5903 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5905 } /* end of embedded lua code */
5906
5907 tolua_module(tolua_S,"Tile",0);
5908 tolua_beginmodule(tolua_S,"Tile");
5909 tolua_module(tolua_S,"properties",0);
5910 tolua_beginmodule(tolua_S,"properties");
5929
5930 { /* begin embedded lua code */
5931 static unsigned char B[] = {
5932 10,102,117,110, 99,116,105,111,110, 32, 84,105,108,101, 58,
5933 99,105,116,121, 95,101,120,105,115,116,115, 95,119,105,116,
5934 104,105,110, 95, 99,105,116,121, 95,114, 97,100,105,117,115,
5935 40, 99,101,110,116,101,114, 41, 10,108,111,103, 46,100,101,
5936 112,114,101, 99, 97,116,105,111,110, 95,119, 97,114,110,105,
5937 110,103, 40, 34, 99,105,116,121, 95,101,120,105,115,116,115,
5938 95,119,105,116,104,105,110, 95, 99,105,116,121, 95,114, 97,
5939 100,105,117,115, 40, 41, 34, 44, 32, 34, 99,105,116,121, 95,
5940 101,120,105,115,116,115, 95,119,105,116,104,105,110, 95,109,
5941 97,120, 95, 99,105,116,121, 95,109, 97,112, 40, 41, 34, 44,
5942 10, 34, 50, 46, 51, 34, 41, 59, 10,114,101,116,117,114,110,
5943 32,115,101,108,102, 58, 99,105,116,121, 95,101,120,105,115,
5944 116,115, 95,119,105,116,104,105,110, 95,109, 97,120, 95, 99,
5945 105,116,121, 95,109, 97,112, 40, 99,101,110,116,101,114, 41,
5946 10,101,110,100,32
5947 };
5948 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5950 } /* end of embedded lua code */
5951
5952 tolua_module(tolua_S,"methods_private",0);
5953 tolua_beginmodule(tolua_S,"methods_private");
5954 tolua_module(tolua_S,"Tile",0);
5955 tolua_beginmodule(tolua_S,"Tile");
5961 tolua_module(tolua_S,"Government",0);
5962 tolua_beginmodule(tolua_S,"Government");
5966 tolua_module(tolua_S,"Nation_Type",0);
5967 tolua_beginmodule(tolua_S,"Nation_Type");
5972 tolua_module(tolua_S,"Building_Type",0);
5973 tolua_beginmodule(tolua_S,"Building_Type");
5981
5982 { /* begin embedded lua code */
5983 static unsigned char B[] = {
5984 10,102,117,110, 99,116,105,111,110, 32, 66,117,105,108,100,
5985 105,110,103, 95, 84,121,112,101, 58, 98,117,105,108,100, 95,
5986 115,104,105,101,108,100, 95, 99,111,115,116, 40, 41, 10,114,
5987 101,116,117,114,110, 32,115,101,108,102, 46, 98,117,105,108,
5988 100, 95, 99,111,115,116, 10,101,110,100,32
5989 };
5990 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
5992 } /* end of embedded lua code */
5993
5994 tolua_module(tolua_S,"Unit_Type",0);
5995 tolua_beginmodule(tolua_S,"Unit_Type");
6002
6003 { /* begin embedded lua code */
6004 static unsigned char B[] = {
6005 10,102,117,110, 99,116,105,111,110, 32, 85,110,105,116, 95,
6006 84,121,112,101, 58, 98,117,105,108,100, 95,115,104,105,101,
6007 108,100, 95, 99,111,115,116, 40, 41, 10,114,101,116,117,114,
6008 110, 32,115,101,108,102, 46, 98,117,105,108,100, 95, 99,111,
6009 115,116, 10,101,110,100,32
6010 };
6011 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
6013 } /* end of embedded lua code */
6014
6015 tolua_module(tolua_S,"Tech_Type",0);
6016 tolua_beginmodule(tolua_S,"Tech_Type");
6020
6021 { /* begin embedded lua code */
6022 static unsigned char B[] = {
6023 10,108,111, 99, 97,108, 32,112,116, 99,111,115,116, 32, 61,
6024 32, 80,108, 97,121,101,114, 46,116,101, 99,104, 95, 99,111,
6025 115,116, 10,102,117,110, 99,116,105,111,110, 32, 84,101, 99,
6026 104, 95, 84,121,112,101, 58, 99,111,115,116, 40, 41, 10,114,
6027 101,116,117,114,110, 32,112,116, 99,111,115,116, 40,110,105,
6028 108, 44, 32,115,101,108,102, 41, 10,101,110,100,32
6029 };
6030 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
6032 } /* end of embedded lua code */
6033
6034 tolua_module(tolua_S,"Terrain",0);
6035 tolua_beginmodule(tolua_S,"Terrain");
6040 tolua_module(tolua_S,"Disaster",0);
6041 tolua_beginmodule(tolua_S,"Disaster");
6045 tolua_module(tolua_S,"Achievement",0);
6046 tolua_beginmodule(tolua_S,"Achievement");
6050 tolua_module(tolua_S,"Action",0);
6051 tolua_beginmodule(tolua_S,"Action");
6056 tolua_module(tolua_S,"Specialist",0);
6057 tolua_beginmodule(tolua_S,"Specialist");
6061 tolua_module(tolua_S,"Unit_List_Link",0);
6062 tolua_beginmodule(tolua_S,"Unit_List_Link");
6066 tolua_module(tolua_S,"City_List_Link",0);
6067 tolua_beginmodule(tolua_S,"City_List_Link");
6071 tolua_module(tolua_S,"find",0);
6072 tolua_beginmodule(tolua_S,"find");
6107
6108 { /* begin embedded lua code */
6109 static unsigned char B[] = {
6110 10,108,111, 99, 97,108, 32,103, 97,109,101, 95,105,110,102,
6111 111, 32, 61, 32,103, 97,109,101, 46,105,110,102,111, 10,102,
6112 117,110, 99,116,105,111,110, 32,102,105,110,100, 46,103, 97,
6113 109,101, 95,105,110,102,111, 40, 41, 10,114,101,116,117,114,
6114 110, 32,103, 97,109,101, 95,105,110,102,111, 10,101,110,100,
6115 32
6116 };
6117 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
6119 } /* end of embedded lua code */
6120
6121 tolua_module(tolua_S,"E",0);
6124 tolua_module(tolua_S,"effects",0);
6125 tolua_beginmodule(tolua_S,"effects");
6134 tolua_module(tolua_S,"Direction",0);
6135 tolua_beginmodule(tolua_S,"Direction");
6136 tolua_module(tolua_S,"properties",0);
6137 tolua_beginmodule(tolua_S,"properties");
6143 tolua_module(tolua_S,"direction",0);
6144 tolua_beginmodule(tolua_S,"direction");
6150
6151 { /* begin embedded lua code */
6152 static unsigned char B[] = {
6153 10,102,117,110, 99,116,105,111,110, 32,115,116,114, 50,100,
6154 105,114,101, 99,116,105,111,110, 40,115,116,114, 41, 10,114,
6155 101,116,117,114,110, 32,100,105,114,101, 99,116,105,111,110,
6156 46,115,116,114, 50,100,105,114, 40,115,116,114, 41, 10,101,
6157 110,100, 10, 68,105,114,101, 99,116,105,111,110, 46,112,114,
6158 111,112,101,114,116,105,101,115, 46,110,101,120,116, 95, 99,
6159 99,119, 32, 61, 32,100,105,114,101, 99,116,105,111,110, 46,
6160 110,101,120,116, 95, 99, 99,119, 10, 68,105,114,101, 99,116,
6161 105,111,110, 46,112,114,111,112,101,114,116,105,101,115, 46,
6162 110,101,120,116, 95, 99,119, 32, 61, 32,100,105,114,101, 99,
6163 116,105,111,110, 46,110,101,120,116, 95, 99,119, 10, 68,105,
6164 114,101, 99,116,105,111,110, 46,112,114,111,112,101,114,116,
6165 105,101,115, 46,111,112,112,111,115,105,116,101, 32, 61, 32,
6166 100,105,114,101, 99,116,105,111,110, 46,111,112,112,111,115,
6167 105,116,101,32
6168 };
6169 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
6171 } /* end of embedded lua code */
6172
6173 tolua_module(tolua_S,"Game_Info",0);
6174 tolua_beginmodule(tolua_S,"Game_Info");
6176
6177 { /* begin embedded lua code */
6178 static unsigned char B[] = {
6179 10,100,111, 10,108,111, 99, 97,108, 32,112,114,105,118, 97,
6180 116,101, 32, 61, 32,109,101,116,104,111,100,115, 95,112,114,
6181 105,118, 97,116,101, 10,108,111, 99, 97,108, 32,102,117,110,
6182 99,116,105,111,110, 32,118, 97,108,117,101, 95,105,116,101,
6183 114, 97,116,111,114, 40, 97,114,114, 97,121, 41, 10,108,111,
6184 99, 97,108, 32,105, 32, 61, 32, 48, 10,108,111, 99, 97,108,
6185 32,102,117,110, 99,116,105,111,110, 32,105,116,101,114, 97,
6186 116,111,114, 40, 41, 10,105, 32, 61, 32,105, 32, 43, 32, 49,
6187 10,114,101,116,117,114,110, 32, 97,114,114, 97,121, 91,105,
6188 93, 10,101,110,100, 10,114,101,116,117,114,110, 32,105,116,
6189 101,114, 97,116,111,114, 10,101,110,100, 10,108,111, 99, 97,
6190 108, 32,102,117,110, 99,116,105,111,110, 32,115, 97,102,101,
6191 95,105,116,101,114, 97,116,101, 95,108,105,115,116, 40,108,
6192 105,110,107, 41, 10,108,111, 99, 97,108, 32,111, 98,106,115,
6193 32, 61, 32,123,125, 10,119,104,105,108,101, 32,108,105,110,
6194 107, 32,100,111, 10,111, 98,106,115, 91, 35,111, 98,106,115,
6195 32, 43, 32, 49, 93, 32, 61, 32,108,105,110,107, 58,100, 97,
6196 116, 97, 40, 41, 10,108,105,110,107, 32, 61, 32,108,105,110,
6197 107, 58,110,101,120,116, 40, 41, 10,101,110,100, 10,114,101,
6198 116,117,114,110, 32,118, 97,108,117,101, 95,105,116,101,114,
6199 97,116,111,114, 40,111, 98,106,115, 41, 10,101,110,100, 10,
6200 102,117,110, 99,116,105,111,110, 32, 80,108, 97,121,101,114,
6201 58,117,110,105,116,115, 95,105,116,101,114, 97,116,101, 40,
6202 41, 10,114,101,116,117,114,110, 32,115, 97,102,101, 95,105,
6203 116,101,114, 97,116,101, 95,108,105,115,116, 40,112,114,105,
6204 118, 97,116,101, 46, 80,108, 97,121,101,114, 46,117,110,105,
6205 116, 95,108,105,115,116, 95,104,101, 97,100, 40,115,101,108,
6206 102, 41, 41, 10,101,110,100, 10,102,117,110, 99,116,105,111,
6207 110, 32, 80,108, 97,121,101,114, 58, 99,105,116,105,101,115,
6208 95,105,116,101,114, 97,116,101, 40, 41, 10,114,101,116,117,
6209 114,110, 32,115, 97,102,101, 95,105,116,101,114, 97,116,101,
6210 95,108,105,115,116, 40,112,114,105,118, 97,116,101, 46, 80,
6211 108, 97,121,101,114, 46, 99,105,116,121, 95,108,105,115,116,
6212 95,104,101, 97,100, 40,115,101,108,102, 41, 41, 10,101,110,
6213 100, 10,102,117,110, 99,116,105,111,110, 32, 84,105,108,101,
6214 58,117,110,105,116,115, 95,105,116,101,114, 97,116,101, 40,
6215 41, 10,114,101,116,117,114,110, 32,115, 97,102,101, 95,105,
6216 116,101,114, 97,116,101, 95,108,105,115,116, 40,112,114,105,
6217 118, 97,116,101, 46, 84,105,108,101, 46,117,110,105,116, 95,
6218 108,105,115,116, 95,104,101, 97,100, 40,115,101,108,102, 41,
6219 41, 10,101,110,100, 10,102,117,110, 99,116,105,111,110, 32,
6220 85,110,105,116, 58, 99, 97,114,103,111, 95,105,116,101,114,
6221 97,116,101, 40, 41, 10,114,101,116,117,114,110, 32,115, 97,
6222 102,101, 95,105,116,101,114, 97,116,101, 95,108,105,115,116,
6223 40,112,114,105,118, 97,116,101, 46, 85,110,105,116, 46, 99,
6224 97,114,103,111, 95,108,105,115,116, 95,104,101, 97,100, 40,
6225 115,101,108,102, 41, 41, 10,101,110,100, 10,101,110,100, 10,
6226 100,111, 10,108,111, 99, 97,108, 32,110,101,120,116, 95,111,
6227 117,116,119, 97,114,100, 95,105,110,100,101,120, 32, 61, 32,
6228 109,101,116,104,111,100,115, 95,112,114,105,118, 97,116,101,
6229 46, 84,105,108,101, 46,110,101,120,116, 95,111,117,116,119,
6230 97,114,100, 95,105,110,100,101,120, 10,108,111, 99, 97,108,
6231 32,116,105,108,101, 95,102,111,114, 95,111,117,116,119, 97,
6232 114,100, 95,105,110,100,101,120, 32, 61, 32,109,101,116,104,
6233 111,100,115, 95,112,114,105,118, 97,116,101, 46, 84,105,108,
6234 101, 46,116,105,108,101, 95,102,111,114, 95,111,117,116,119,
6235 97,114,100, 95,105,110,100,101,120, 10,102,117,110, 99,116,
6236 105,111,110, 32, 84,105,108,101, 58,115,113,117, 97,114,101,
6237 95,105,116,101,114, 97,116,101, 40,114, 97,100,105,117,115,
6238 41, 10,108,111, 99, 97,108, 32,105,110,100,101,120, 32, 61,
6239 32, 45, 49, 10,108,111, 99, 97,108, 32,102,117,110, 99,116,
6240 105,111,110, 32,105,116,101,114, 97,116,111,114, 40, 41, 10,
6241 105,110,100,101,120, 32, 61, 32,110,101,120,116, 95,111,117,
6242 116,119, 97,114,100, 95,105,110,100,101,120, 40,115,101,108,
6243 102, 44, 32,105,110,100,101,120, 44, 32,114, 97,100,105,117,
6244 115, 41, 10,105,102, 32,105,110,100,101,120, 32, 60, 32, 48,
6245 32,116,104,101,110, 10,114,101,116,117,114,110, 32,110,105,
6246 108, 10,101,108,115,101, 10,114,101,116,117,114,110, 32,116,
6247 105,108,101, 95,102,111,114, 95,111,117,116,119, 97,114,100,
6248 95,105,110,100,101,120, 40,115,101,108,102, 44, 32,105,110,
6249 100,101,120, 41, 10,101,110,100, 10,101,110,100, 10,114,101,
6250 116,117,114,110, 32,105,116,101,114, 97,116,111,114, 10,101,
6251 110,100, 10,102,117,110, 99,116,105,111,110, 32, 84,105,108,
6252 101, 58, 99,105,114, 99,108,101, 95,105,116,101,114, 97,116,
6253 101, 40,115,113, 95,114, 97,100,105,117,115, 41, 10,108,111,
6254 99, 97,108, 32, 99,114, 95,114, 97,100,105,117,115, 32, 61,
6255 32,109, 97,116,104, 46,102,108,111,111,114, 40,109, 97,116,
6256 104, 46,115,113,114,116, 40,115,113, 95,114, 97,100,105,117,
6257 115, 41, 41, 10,108,111, 99, 97,108, 32,115,113, 95,105,116,
6258 101,114, 32, 61, 32,115,101,108,102, 58,115,113,117, 97,114,
6259 101, 95,105,116,101,114, 97,116,101, 40, 99,114, 95,114, 97,
6260 100,105,117,115, 41, 10,108,111, 99, 97,108, 32,102,117,110,
6261 99,116,105,111,110, 32,105,116,101,114, 97,116,111,114, 40,
6262 41, 10,108,111, 99, 97,108, 32,116,105,108,101, 32, 61, 32,
6263 110,105,108, 10,114,101,112,101, 97,116, 10,116,105,108,101,
6264 32, 61, 32,115,113, 95,105,116,101,114, 40, 41, 10,117,110,
6265 116,105,108, 32,110,111,116, 32,116,105,108,101, 32,111,114,
6266 32,115,101,108,102, 58,115,113, 95,100,105,115,116, 97,110,
6267 99,101, 40,116,105,108,101, 41, 32, 60, 61, 32,115,113, 95,
6268 114, 97,100,105,117,115, 10,114,101,116,117,114,110, 32,116,
6269 105,108,101, 10,101,110,100, 10,114,101,116,117,114,110, 32,
6270 105,116,101,114, 97,116,111,114, 10,101,110,100, 10,101,110,
6271 100,32
6272 };
6273 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
6275 } /* end of embedded lua code */
6276
6277
6278 { /* begin embedded lua code */
6279 static unsigned char B[] = {
6280 10,100,111, 10,108,111, 99, 97,108, 32,102,117,110, 99,116,
6281 105,111,110, 32,105,110,100,101,120, 95,105,116,101,114, 97,
6282 116,101, 40,108,111,111,107,117,112, 41, 10,108,111, 99, 97,
6283 108, 32,105,110,100,101,120, 32, 61, 32, 45, 49, 10,108,111,
6284 99, 97,108, 32,102,117,110, 99,116,105,111,110, 32,105,116,
6285 101,114, 97,116,111,114, 40, 41, 10,105,110,100,101,120, 32,
6286 61, 32,105,110,100,101,120, 32, 43, 32, 49, 10,114,101,116,
6287 117,114,110, 32,108,111,111,107,117,112, 40,105,110,100,101,
6288 120, 41, 10,101,110,100, 10,114,101,116,117,114,110, 32,105,
6289 116,101,114, 97,116,111,114, 10,101,110,100, 10,108,111, 99,
6290 97,108, 32,108,105,115,116,112, 32, 61, 32,109,101,116,104,
6291 111,100,115, 95,112,114,105,118, 97,116,101, 46,108,105,115,
6292 116, 95,112,108, 97,121,101,114,115, 10,102,117,110, 99,116,
6293 105,111,110, 32,112,108, 97,121,101,114,115, 95,105,116,101,
6294 114, 97,116,101, 40, 41, 10,108,111, 99, 97,108, 32,112,108,
6295 105,115,116, 32, 61, 32,108,105,115,116,112, 40, 41, 10,108,
6296 111, 99, 97,108, 32,105,110,100,101,120, 32, 61, 32, 48, 10,
6297 114,101,116,117,114,110, 32,102,117,110, 99,116,105,111,110,
6298 40, 41, 10,105,110,100,101,120, 32, 61, 32,105,110,100,101,
6299 120, 32, 43, 32, 49, 10,114,101,116,117,114,110, 32,112,108,
6300 105,115,116, 91,105,110,100,101,120, 93, 10,101,110,100, 10,
6301 101,110,100, 10,102,117,110, 99,116,105,111,110, 32,119,104,
6302 111,108,101, 95,109, 97,112, 95,105,116,101,114, 97,116,101,
6303 40, 41, 10,114,101,116,117,114,110, 32,105,110,100,101,120,
6304 95,105,116,101,114, 97,116,101, 40,102,105,110,100, 46,116,
6305 105,108,101, 41, 10,101,110,100, 10,101,110,100,32
6306 };
6307 if (luaL_loadbuffer(tolua_S,(char*)B,sizeof(B),"tolua: embedded Lua code") == LUA_OK)
6309 } /* end of embedded lua code */
6310
6312 return 1;
6313}
6314/* Open tolua function */
6316{
6318 lua_pushstring(tolua_S, "game");
6319 lua_call(tolua_S, 1, 0);
6320 return 1;
6321}
const Direction * api_utilities_dir_cw(lua_State *L, Direction dir)
const char * api_utilities_dir2str(lua_State *L, Direction dir)
const Direction * api_utilities_opposite_dir(lua_State *L, Direction dir)
bool api_utilities_direction_is_cardinal(lua_State *L, Direction dir)
const Direction * api_utilities_str2dir(lua_State *L, const char *dir)
int api_utilities_direction_id(lua_State *L, Direction dir)
const Direction * api_utilities_dir_ccw(lua_State *L, Direction dir)
int api_effects_tile_bonus(lua_State *L, Tile *ptile, City *pcity, const char *output_id, const char *effect_type)
int api_effects_unit_vs_tile_bonus(lua_State *L, Unit *punit, Tile *ptile, const char *effect_type)
int api_effects_player_bonus(lua_State *L, Player *pplayer, const char *effect_type)
int api_effects_city_bonus(lua_State *L, City *pcity, const char *effect_type)
int api_effects_unit_bonus(lua_State *L, Unit *punit, Player *other_player, const char *effect_type)
int api_effects_specialist_bonus(lua_State *L, Specialist *s, lua_Object d, const char *output_id, const char *effect_type)
int api_effects_world_bonus(lua_State *L, const char *effect_type)
Nation_Type * api_find_nation_type(lua_State *L, int nation_type_id)
Tile * api_find_tile(lua_State *L, int nat_x, int nat_y)
Unit_Type * api_find_unit_type(lua_State *L, int unit_type_id)
Government * api_find_government_by_name(lua_State *L, const char *name_orig)
Player * api_find_player(lua_State *L, int player_id)
Achievement * api_find_achievement_by_name(lua_State *L, const char *name_orig)
Achievement * api_find_achievement(lua_State *L, int achievement_id)
Unit_Type * api_find_role_unit_type(lua_State *L, const char *role_name, Player *pplayer)
const Direction * api_find_direction(lua_State *L, int id)
Action * api_find_action_type_by_name(lua_State *L, const char *name)
Tile * api_find_tile_by_index(lua_State *L, int tindex)
Building_Type * api_find_building_type_by_name(lua_State *L, const char *name_orig)
Nation_Type * api_find_nation_type_by_name(lua_State *L, const char *name_orig)
Disaster * api_find_disaster(lua_State *L, int disaster_id)
Tech_Type * api_find_tech_type_by_name(lua_State *L, const char *name_orig)
Government * api_find_government(lua_State *L, int government_id)
Disaster * api_find_disaster_by_name(lua_State *L, const char *name_orig)
Counter * api_find_counter(lua_State *L, int counter_id)
Building_Type * api_find_building_type(lua_State *L, int building_type_id)
Action * api_find_action_type_by_id(lua_State *L, int id)
Nonexistent * api_find_nonexistent(lua_State *L)
Player * api_find_player_by_name(lua_State *L, const char *name)
Specialist * api_find_specialist_by_name(lua_State *L, const char *name_orig)
Unit * api_find_transport_unit(lua_State *L, Player *pplayer, Unit_Type *ptype, Tile *ptile)
Tech_Type * api_find_tech_type(lua_State *L, int tech_type_id)
City * api_find_city(lua_State *L, Player *pplayer, int city_id)
Unit * api_find_unit(lua_State *L, Player *pplayer, int unit_id)
Specialist * api_find_specialist(lua_State *L, int spec_id)
Terrain * api_find_terrain(lua_State *L, int terrain_id)
Terrain * api_find_terrain_by_name(lua_State *L, const char *name_orig)
Counter * api_find_counter_by_name(lua_State *L, const char *name)
Unit_Type * api_find_unit_type_by_name(lua_State *L, const char *name_orig)
int api_methods_tile_nat_x(lua_State *L, Tile *ptile)
int api_methods_tile_num_units(lua_State *L, Tile *ptile)
bool api_methods_is_city_unhappy(lua_State *L, City *pcity)
bool api_methods_is_gov_center(lua_State *L, City *pcity)
const char * api_methods_game_rulesetdir(lua_State *L)
int api_methods_player_future(lua_State *L, Player *pplayer)
bool api_methods_unit_type_can_exist_at_tile(lua_State *L, Unit_Type *punit_type, Tile *ptile)
int api_methods_player_num_cities(lua_State *L, Player *pplayer)
bool api_methods_unit_can_upgrade(lua_State *L, Unit *punit, bool is_free)
bool api_methods_player_can_employ(lua_State *L, Player *pplayer, Specialist *s)
bool api_methods_player_has_wonder(lua_State *L, Player *pplayer, Building_Type *building)
Unit_List_Link * api_methods_unit_list_next_link(lua_State *L, Unit_List_Link *ul_link)
const char * api_methods_nation_type_plural_translation(lua_State *L, Nation_Type *pnation)
const char * api_methods_disaster_name_translation(lua_State *L, Disaster *pdis)
bool api_methods_player_team_has_embassy(lua_State *L, Player *pplayer, Player *target)
Unit * api_methods_unit_list_link_data(lua_State *L, Unit_List_Link *ul_link)
const char * api_methods_get_diplstate(lua_State *L, Player *pplayer1, Player *pplayer2)
int api_methods_tile_nat_y(lua_State *L, Tile *ptile)
Unit_List_Link * api_methods_private_tile_unit_list_head(lua_State *L, Tile *ptile)
bool api_methods_player_has_embassy(lua_State *L, Player *pplayer, Player *target)
int api_methods_player_tech_cost(lua_State *L, Player *pplayer, Tech_Type *ptech)
lua_Object api_methods_player_researching(lua_State *L, Player *pplayer)
int api_methods_game_year_fragment(lua_State *L)
const char * api_methods_counter_name_translation(lua_State *L, Counter *c)
int api_methods_city_culture_get(lua_State *L, City *pcity)
const char * api_methods_unit_type_name_translation(lua_State *L, Unit_Type *punit_type)
const char * api_methods_game_ruleset_name(lua_State *L)
const char * api_methods_building_type_rule_name(lua_State *L, Building_Type *pbuilding)
bool api_methods_unit_seen(lua_State *L, Unit *self, Player *watcher)
City * api_methods_city_list_link_data(lua_State *L, City_List_Link *cl_link)
const char * api_methods_unit_tile_link(lua_State *L, Unit *punit)
const char * api_methods_counter_rule_name(lua_State *L, Counter *c)
bool api_methods_player_can_build_impr_direct(lua_State *L, Player *pplayer, Building_Type *itype)
int api_methods_player_num_units(lua_State *L, Player *pplayer)
const char * api_methods_tech_type_rule_name(lua_State *L, Tech_Type *ptech)
int api_methods_tile_map_x(lua_State *L, Tile *ptile)
bool api_methods_is_city_happy(lua_State *L, City *pcity)
const char * api_methods_achievement_rule_name(lua_State *L, Achievement *pach)
Unit_Type * api_methods_player_can_upgrade(lua_State *L, Player *pplayer, Unit_Type *utype)
const char * api_methods_city_link(lua_State *L, City *pcity)
const char * api_methods_nation_type_name_translation(lua_State *L, Nation_Type *pnation)
const char * api_methods_government_rule_name(lua_State *L, Government *pgovernment)
const char * api_methods_terrain_rule_name(lua_State *L, Terrain *pterrain)
int api_methods_player_number(lua_State *L, Player *pplayer)
int api_methods_player_infrapoints(lua_State *L, Player *pplayer)
Unit_List_Link * api_methods_private_unit_cargo_list_head(lua_State *L, Unit *punit)
const char * api_methods_specialist_rule_name(lua_State *L, Specialist *s)
const char * api_methods_player_controlling_gui(lua_State *L, Player *pplayer)
const char * api_methods_action_name_translation(lua_State *L, Action *pact)
const char * api_methods_terrain_class_name(lua_State *L, Terrain *pterrain)
bool api_methods_player_shares_research(lua_State *L, Player *pplayer, Player *aplayer)
const char * api_methods_tech_type_name_translation(lua_State *L, Tech_Type *ptech)
bool api_methods_city_can_employ(lua_State *L, City *pcity, Specialist *s)
Player * api_methods_tile_extra_owner(lua_State *L, Tile *ptile, const char *extra_name)
int api_methods_city_size_get(lua_State *L, City *pcity)
const char * api_methods_tech_cost_style(lua_State *L)
City * api_methods_tile_city(lua_State *L, Tile *ptile)
const char * api_methods_tech_leakage_style(lua_State *L)
const char * api_methods_government_name_translation(lua_State *L, Government *pgovernment)
bool api_method_player_can_research(lua_State *L, Player *pplayer, Tech_Type *ptech)
bool api_methods_tile_has_extra(lua_State *L, Tile *ptile, const char *name)
int api_methods_tile_sq_distance(lua_State *L, Tile *ptile1, Tile *ptile2)
bool api_methods_unit_type_has_role(lua_State *L, Unit_Type *punit_type, const char *role)
const char * api_methods_specialist_name_translation(lua_State *L, Specialist *s)
const char * api_methods_tile_link(lua_State *L, Tile *ptile)
int api_methods_player_culture_get(lua_State *L, Player *pplayer)
int api_methods_game_turn_deprecated(lua_State *L)
int api_methods_player_bulbs(lua_State *L, Player *pplayer)
const char * api_methods_achievement_name_translation(lua_State *L, Achievement *pach)
int api_methods_city_nationality_citizens(lua_State *L, City *pcity, Player *nationality)
int api_methods_city_num_specialists(lua_State *L, City *pcity, Specialist *s)
bool api_methods_building_type_is_great_wonder(lua_State *L, Building_Type *pbuilding)
bool api_methods_tile_seen(lua_State *L, Tile *self, Player *watcher)
const char * api_methods_city_tile_link(lua_State *L, City *pcity)
int api_methods_private_tile_next_outward_index(lua_State *L, Tile *pstart, int tindex, int max_dist)
Tile * api_methods_unit_tile_get(lua_State *L, Unit *punit)
bool api_methods_tile_has_road(lua_State *L, Tile *ptile, const char *name)
const char * api_methods_nation_type_rule_name(lua_State *L, Nation_Type *pnation)
const Direction * api_methods_unit_orientation_get(lua_State *L, Unit *punit)
int api_methods_game_turn(lua_State *L)
bool api_methods_player_knows_tech(lua_State *L, Player *pplayer, Tech_Type *ptech)
bool api_methods_enemy_tile(lua_State *L, Tile *ptile, Player *against)
bool api_methods_building_type_is_small_wonder(lua_State *L, Building_Type *pbuilding)
int api_methods_game_year(lua_State *L)
Tile * api_methods_private_tile_for_outward_index(lua_State *L, Tile *pstart, int tindex)
const char * api_methods_game_year_text(lua_State *L)
const char * api_methods_action_rule_name(lua_State *L, Action *pact)
const char * api_methods_disaster_rule_name(lua_State *L, Disaster *pdis)
const char * api_methods_building_type_name_translation(lua_State *L, Building_Type *pbuilding)
bool api_methods_building_type_is_wonder(lua_State *L, Building_Type *pbuilding)
const char * api_methods_research_name_translation(lua_State *L, Player *pplayer)
int api_methods_city_inspire_partisans(lua_State *L, City *self, Player *inspirer)
int api_methods_city_map_sq_radius(lua_State *L, City *pcity)
bool api_methods_city_has_building(lua_State *L, City *pcity, Building_Type *building)
const char * api_methods_unit_transform_problem(lua_State *L, Unit *punit, Unit_Type *ptype)
City_List_Link * api_methods_city_list_next_link(lua_State *L, City_List_Link *cl_link)
bool api_methods_unit_type_has_flag(lua_State *L, Unit_Type *punit_type, const char *flag)
const char * api_methods_unit_type_rule_name(lua_State *L, Unit_Type *punit_type)
bool api_methods_building_type_is_improvement(lua_State *L, Building_Type *pbuilding)
bool api_methods_tile_city_exists_within_max_city_map(lua_State *L, Tile *ptile, bool may_be_on_center)
bool api_methods_player_has_flag(lua_State *L, Player *pplayer, const char *flag)
lua_Object api_methods_private_list_players(lua_State *L)
bool api_methods_unit_city_can_be_built_here(lua_State *L, Unit *punit)
bool api_methods_tile_has_base(lua_State *L, Tile *ptile, const char *name)
int api_methods_player_gold(lua_State *L, Player *pplayer)
bool api_methods_tile_known(lua_State *L, Tile *self, Player *watcher)
const char * api_methods_research_rule_name(lua_State *L, Player *pplayer)
bool api_methods_is_primary_capital(lua_State *L, City *pcity)
City * api_methods_player_primary_capital(lua_State *L, Player *pplayer)
int api_methods_player_research_cost(lua_State *L, Player *pplayer)
int api_methods_tile_map_y(lua_State *L, Tile *ptile)
Unit_List_Link * api_methods_private_player_unit_list_head(lua_State *L, Player *pplayer)
const char * api_methods_action_target_kind(lua_State *L, Action *pact)
City_List_Link * api_methods_private_player_city_list_head(lua_State *L, Player *pplayer)
const char * api_methods_terrain_name_translation(lua_State *L, Terrain *pterrain)
Tile * api_methods_city_tile_get(lua_State *L, City *pcity)
const char * api_methods_unit_link(lua_State *L, Unit *punit)
bool api_methods_is_city_celebrating(lua_State *L, City *pcity)
int api_methods_counter_city_get(lua_State *L, Counter *c, City *city)
bool api_methods_is_capital(lua_State *L, City *pcity)
bool api_methods_player_can_build_unit_direct(lua_State *L, Player *pplayer, Unit_Type *utype)
Unit * api_methods_unit_transporter(lua_State *L, Unit *punit)
#define str
Definition astring.c:76
static struct ai_type * self
Definition classicai.c:46
char * incite_cost
Definition comments.c:76
int counter_id(struct counter *pcount)
Definition counters.c:105
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
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
const char * name
Definition inputfile.c:127
const struct city_list_link City_List_Link
enum direction8 Direction
void Nonexistent
const struct unit_list_link Unit_List_Link
#define nat_x
#define nat_y
char name[MAX_LEN_NAME]
Definition ai.h:51
Definition city.h:317
Definition tile.h:50
Definition unit.h:140
#define TRUE
Definition support.h:46
#define bool
Definition support.h:71
static int tolua_set_Unit_Unit_owner_ptr(lua_State *tolua_S)
static int tolua_get_Connection_Connection_id(lua_State *tolua_S)
static int tolua_game_Player_can_employ00(lua_State *tolua_S)
static int tolua_game_Player_gold00(lua_State *tolua_S)
static int tolua_game_Player_researching00(lua_State *tolua_S)
static int tolua_game_find_tile00(lua_State *tolua_S)
static int tolua_game_direction_next_ccw00(lua_State *tolua_S)
static int tolua_game_game_current_year00(lua_State *tolua_S)
static int tolua_game_Terrain_name_translation00(lua_State *tolua_S)
static int tolua_game_Building_Type_is_wonder00(lua_State *tolua_S)
static int tolua_game_find_unit_type01(lua_State *tolua_S)
static int tolua_get_Tile_Tile_terrain_ptr(lua_State *tolua_S)
static int tolua_game_Unit_properties_tile00(lua_State *tolua_S)
static int tolua_game_Tile_is_enemy00(lua_State *tolua_S)
static int tolua_game_find_action01(lua_State *tolua_S)
static int tolua_get_Unit_Unit_nationality_ptr(lua_State *tolua_S)
static int tolua_game_game_current_fragment00(lua_State *tolua_S)
static int tolua_set_Unit_Type_Unit_Type_obsoleted_by_ptr(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_sciencebox(lua_State *tolua_S)
static int tolua_game_find_player01(lua_State *tolua_S)
static int tolua_game_City_is_primary_capital00(lua_State *tolua_S)
static int tolua_get_Terrain_Terrain_item_number(lua_State *tolua_S)
static int tolua_game_Tile_link_text00(lua_State *tolua_S)
static int tolua_game_find_nation_type00(lua_State *tolua_S)
static int tolua_game_City_culture00(lua_State *tolua_S)
static int tolua_game_Direction_properties_cardinal00(lua_State *tolua_S)
static int tolua_game_City_can_employ00(lua_State *tolua_S)
static int tolua_game_Unit_tile_link_text00(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_tech_steal_allow_holes(lua_State *tolua_S)
static int tolua_game_Player_has_embassy00(lua_State *tolua_S)
static int tolua_game_find_building_type01(lua_State *tolua_S)
static int tolua_game_Achievement_rule_name00(lua_State *tolua_S)
static int tolua_game_find_disaster00(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_tech_leak_pct(lua_State *tolua_S)
static int tolua_game_Unit_Type_has_role00(lua_State *tolua_S)
static int tolua_game_effects_unit_vs_tile_bonus00(lua_State *tolua_S)
static int tolua_game_Unit_List_Link_data00(lua_State *tolua_S)
static int tolua_game_City_nationality_citizens00(lua_State *tolua_S)
static int tolua_game_Building_Type_is_small_wonder00(lua_State *tolua_S)
static int tolua_set_Unit_Unit_utype_ptr(lua_State *tolua_S)
static int tolua_game_City_link_text00(lua_State *tolua_S)
static int tolua_game_effects_tile_bonus00(lua_State *tolua_S)
static int tolua_game_City_properties_size00(lua_State *tolua_S)
static int tolua_set_Building_Type_Building_Type_build_cost(lua_State *tolua_S)
static int tolua_game_City_has_building00(lua_State *tolua_S)
static int tolua_game_Player_shares_research00(lua_State *tolua_S)
static int tolua_game_find_direction00(lua_State *tolua_S)
static int tolua_game_find_achievement01(lua_State *tolua_S)
static int tolua_game_Tile_city00(lua_State *tolua_S)
static int tolua_game_Tile_known00(lua_State *tolua_S)
static int tolua_get_Player_Player_name(lua_State *tolua_S)
static int tolua_set_game_game_info_substructure(lua_State *tolua_S)
static int tolua_game_Counter_rule_name00(lua_State *tolua_S)
static int tolua_game_Terrain_class_name00(lua_State *tolua_S)
static int tolua_game_Government_rule_name00(lua_State *tolua_S)
static int tolua_game_Unit_seen00(lua_State *tolua_S)
static int tolua_game_Building_Type_is_great_wonder00(lua_State *tolua_S)
static int tolua_set_Player_Player_is_alive(lua_State *tolua_S)
static int tolua_get_City_City_original_ptr(lua_State *tolua_S)
static int tolua_game_methods_private_Player_unit_list_head00(lua_State *tolua_S)
static int tolua_game_find_city00(lua_State *tolua_S)
static int tolua_game_Counter_get00(lua_State *tolua_S)
static int tolua_game_Tile_properties_nat_y00(lua_State *tolua_S)
static int tolua_game_City_List_Link_next00(lua_State *tolua_S)
static int tolua_game_Tile_extra_owner00(lua_State *tolua_S)
static int tolua_game_effects_world_bonus00(lua_State *tolua_S)
static int tolua_game_Government_name_translation00(lua_State *tolua_S)
static int tolua_game_Tile_properties_y00(lua_State *tolua_S)
static int tolua_game_find_nonexistent00(lua_State *tolua_S)
static int tolua_game_Building_Type_is_improvement00(lua_State *tolua_S)
static int tolua_get_Tile_Tile_index(lua_State *tolua_S)
static int tolua_set_Unit_Unit_nationality_ptr(lua_State *tolua_S)
static int tolua_game_Player_tech_cost00(lua_State *tolua_S)
static int tolua_game_City_is_gov_center00(lua_State *tolua_S)
static int tolua_game_Unit_Type_can_exist_at_tile00(lua_State *tolua_S)
static int tolua_game_Tile_properties_nat_x00(lua_State *tolua_S)
static int tolua_game_find_terrain00(lua_State *tolua_S)
static int tolua_game_find_player00(lua_State *tolua_S)
static int tolua_get_game_game_info_substructure(lua_State *tolua_S)
static int tolua_game_Player_num_units00(lua_State *tolua_S)
static int tolua_game_Specialist_name_translation00(lua_State *tolua_S)
static int tolua_game_Unit_link_text00(lua_State *tolua_S)
static int tolua_get_Nation_Type_Nation_Type_item_number(lua_State *tolua_S)
static int tolua_game_Player_diplstate00(lua_State *tolua_S)
static int tolua_game_Unit_transform_problem00(lua_State *tolua_S)
static int tolua_game_find_government00(lua_State *tolua_S)
static int tolua_set_Unit_Unit_veteran(lua_State *tolua_S)
static void tolua_reg_types(lua_State *tolua_S)
static int tolua_game_methods_private_Unit_cargo_list_head00(lua_State *tolua_S)
static int tolua_game_Tile_has_extra00(lua_State *tolua_S)
static int tolua_game_City_properties_tile00(lua_State *tolua_S)
static int tolua_game_Unit_Type_name_translation00(lua_State *tolua_S)
static int tolua_game_game_tech_cost_style00(lua_State *tolua_S)
static int tolua_game_Player_num_future_techs00(lua_State *tolua_S)
static int tolua_get_Tech_Type_Tech_Type_item_number(lua_State *tolua_S)
static int tolua_get_Tech_Type_Tech_Type_cost(lua_State *tolua_S)
static int tolua_get_Government_Government_item_number(lua_State *tolua_S)
static int tolua_game_Direction_properties_name00(lua_State *tolua_S)
static int tolua_game_Tile_city_exists_within_max_city_map00(lua_State *tolua_S)
TOLUA_API int tolua_game_open(lua_State *tolua_S)
static int tolua_game_Player_research_name_translation00(lua_State *tolua_S)
static int tolua_get_Disaster_Disaster_id(lua_State *tolua_S)
static int tolua_game_find_unit00(lua_State *tolua_S)
static int tolua_game_Action_rule_name00(lua_State *tolua_S)
static int tolua_game_find_achievement00(lua_State *tolua_S)
static int tolua_game_effects_specialist_bonus00(lua_State *tolua_S)
static int tolua_get_Unit_Unit_id(lua_State *tolua_S)
static int tolua_game_effects_city_bonus00(lua_State *tolua_S)
int tolua_bnd_takeownership(lua_State *L)
static int tolua_game_Disaster_name_translation00(lua_State *tolua_S)
static int tolua_game_Building_Type_name_translation00(lua_State *tolua_S)
static int tolua_get_Unit_Unit_utype_ptr(lua_State *tolua_S)
static int tolua_game_City_map_sq_radius00(lua_State *tolua_S)
static int tolua_set_Tile_Tile_terrain_ptr(lua_State *tolua_S)
static int tolua_game_Tile_num_units00(lua_State *tolua_S)
static int tolua_game_Direction_properties_id00(lua_State *tolua_S)
static int tolua_game_Unit_Type_has_flag00(lua_State *tolua_S)
static int tolua_game_Achievement_name_translation00(lua_State *tolua_S)
static int tolua_get_Player_Player_government_ptr(lua_State *tolua_S)
static int tolua_game_Tile_sq_distance00(lua_State *tolua_S)
static int tolua_game_City_tile_link_text00(lua_State *tolua_S)
static int tolua_game_Player_infrapoints00(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_tech_parasite_allow_holes(lua_State *tolua_S)
static int tolua_game_find_unit_type00(lua_State *tolua_S)
static int tolua_game_game_ruleset_name00(lua_State *tolua_S)
static int tolua_game_find_building_type00(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_tech_trade_loss_allow_holes(lua_State *tolua_S)
static int tolua_game_City_num_specialists00(lua_State *tolua_S)
static int tolua_get_Unit_Unit_homecity(lua_State *tolua_S)
static int tolua_game_Unit_is_on_possible_city_tile00(lua_State *tolua_S)
static int tolua_game_direction_opposite00(lua_State *tolua_S)
static int tolua_get_City_City_name(lua_State *tolua_S)
static int tolua_game_Unit_List_Link_next00(lua_State *tolua_S)
static int tolua_game_find_specialist00(lua_State *tolua_S)
static int tolua_set_Tile_Tile_owner_ptr(lua_State *tolua_S)
static int tolua_game_Player_can_build_direct00(lua_State *tolua_S)
static int tolua_set_City_City_owner_ptr(lua_State *tolua_S)
static int tolua_game_Player_properties_id00(lua_State *tolua_S)
static int tolua_game_Player_culture00(lua_State *tolua_S)
static int tolua_game_City_inspire_partisans00(lua_State *tolua_S)
static int tolua_game_find_specialist01(lua_State *tolua_S)
static int tolua_game_methods_private_Player_city_list_head00(lua_State *tolua_S)
static int tolua_set_Player_Player_nation_ptr(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_tech_loss_allow_holes(lua_State *tolua_S)
static int tolua_game_Terrain_rule_name00(lua_State *tolua_S)
static int tolua_set_Unit_Type_Unit_Type_build_cost(lua_State *tolua_S)
static int tolua_get_City_City_owner_ptr(lua_State *tolua_S)
static int tolua_game_find_nation_type01(lua_State *tolua_S)
static int tolua_game_Tile_has_road00(lua_State *tolua_S)
static int tolua_get_Specialist_Specialist_item_number(lua_State *tolua_S)
static int tolua_game_Player_num_cities00(lua_State *tolua_S)
static int tolua_set_City_City_original_ptr(lua_State *tolua_S)
static int tolua_get_Unit_Unit_veteran(lua_State *tolua_S)
static int tolua_game_Player_controlling_gui00(lua_State *tolua_S)
static int tolua_game_methods_private_Tile_tile_for_outward_index00(lua_State *tolua_S)
static int tolua_get_Unit_Type_Unit_Type_obsoleted_by_ptr(lua_State *tolua_S)
static int tolua_game_find_tech_type00(lua_State *tolua_S)
static int tolua_game_Player_team_has_embassy00(lua_State *tolua_S)
static int tolua_game_Player_has_flag00(lua_State *tolua_S)
static int tolua_get_Player_Player_nation_ptr(lua_State *tolua_S)
static int tolua_game_game_current_turn00(lua_State *tolua_S)
static int tolua_game_find_role_unit_type00(lua_State *tolua_S)
static int tolua_game_Tile_properties_x00(lua_State *tolua_S)
static int tolua_game_Player_primary_capital00(lua_State *tolua_S)
static int tolua_game_Action_name_translation00(lua_State *tolua_S)
static int tolua_game_methods_private_list_players00(lua_State *tolua_S)
static int tolua_game_Unit_Type_rule_name00(lua_State *tolua_S)
LUALIB_API int luaopen_game(lua_State *tolua_S)
static int tolua_set_Unit_Unit_homecity(lua_State *tolua_S)
static int tolua_get_Building_Type_Building_Type_item_number(lua_State *tolua_S)
static int tolua_game_methods_private_Tile_unit_list_head00(lua_State *tolua_S)
static int tolua_get_Action_Action_id(lua_State *tolua_S)
static int tolua_game_Building_Type_rule_name00(lua_State *tolua_S)
static int tolua_game_Unit_transporter00(lua_State *tolua_S)
static int tolua_game_Tech_Type_rule_name00(lua_State *tolua_S)
static int tolua_game_find_government01(lua_State *tolua_S)
static int tolua_game_Player_has_wonder00(lua_State *tolua_S)
static int tolua_game_Disaster_rule_name00(lua_State *tolua_S)
static int tolua_game_Tile_seen00(lua_State *tolua_S)
static int tolua_game_Player_can_research00(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_tech_trade_allow_holes(lua_State *tolua_S)
static int tolua_get_Achievement_Achievement_id(lua_State *tolua_S)
static int tolua_game_City_is_happy00(lua_State *tolua_S)
static int tolua_game_direction_next_cw00(lua_State *tolua_S)
static int tolua_get_Tile_Tile_owner_ptr(lua_State *tolua_S)
static int tolua_get_Unit_Unit_owner_ptr(lua_State *tolua_S)
static int tolua_game_find_tile01(lua_State *tolua_S)
static int tolua_game_Player_can_upgrade00(lua_State *tolua_S)
static int tolua_game_game_turn00(lua_State *tolua_S)
static int tolua_game_game_tech_leakage_style00(lua_State *tolua_S)
static int tolua_get_Unit_Type_Unit_Type_build_cost(lua_State *tolua_S)
static int tolua_game_Specialist_rule_name00(lua_State *tolua_S)
static int tolua_game_Player_knows_tech00(lua_State *tolua_S)
static int tolua_game_City_is_unhappy00(lua_State *tolua_S)
static int tolua_game_City_is_celebrating00(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_min_tech_cost(lua_State *tolua_S)
static int tolua_game_Player_researching_cost00(lua_State *tolua_S)
static int tolua_game_Tile_has_base00(lua_State *tolua_S)
static int tolua_game_Nation_Type_plural_translation00(lua_State *tolua_S)
static int tolua_get_Game_Info_Game_Info_base_tech_cost(lua_State *tolua_S)
static int tolua_game_methods_private_Tile_next_outward_index00(lua_State *tolua_S)
static int tolua_game_Player_properties_bulbs00(lua_State *tolua_S)
static int tolua_game_effects_unit_bonus00(lua_State *tolua_S)
static int tolua_game_Nation_Type_rule_name00(lua_State *tolua_S)
static int tolua_game_find_disaster01(lua_State *tolua_S)
static int tolua_game_game_current_year_text00(lua_State *tolua_S)
static int tolua_get_Unit_Type_Unit_Type_item_number(lua_State *tolua_S)
static int tolua_game_find_tech_type01(lua_State *tolua_S)
static int tolua_game_Player_research_rule_name00(lua_State *tolua_S)
static int tolua_get_Building_Type_Building_Type_build_cost(lua_State *tolua_S)
static int tolua_game_City_List_Link_data00(lua_State *tolua_S)
static int tolua_game_Unit_can_upgrade00(lua_State *tolua_S)
static int tolua_game_direction_str2dir00(lua_State *tolua_S)
static int tolua_game_find_direction01(lua_State *tolua_S)
static int tolua_game_Action_target_kind00(lua_State *tolua_S)
#define game_info_substructure
static int tolua_game_City_is_capital00(lua_State *tolua_S)
static int tolua_get_City_City_id(lua_State *tolua_S)
static int tolua_game_find_counter01(lua_State *tolua_S)
static int tolua_game_find_counter00(lua_State *tolua_S)
static int tolua_game_find_terrain01(lua_State *tolua_S)
static int tolua_game_find_transport_unit00(lua_State *tolua_S)
static int tolua_game_Counter_name_translation00(lua_State *tolua_S)
static int tolua_get_Player_Player_is_alive(lua_State *tolua_S)
static int tolua_game_game_rulesetdir00(lua_State *tolua_S)
static int tolua_set_Player_Player_government_ptr(lua_State *tolua_S)
static int tolua_game_find_action00(lua_State *tolua_S)
static int tolua_game_effects_player_bonus00(lua_State *tolua_S)
static int tolua_game_Tech_Type_name_translation00(lua_State *tolua_S)
static int tolua_game_Unit_facing00(lua_State *tolua_S)
static int tolua_game_Player_can_build_direct01(lua_State *tolua_S)
static int tolua_game_Nation_Type_name_translation00(lua_State *tolua_S)