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