Freeciv-3.2
Loading...
Searching...
No Matches
api_game_methods.c
Go to the documentation of this file.
1/*****************************************************************************
2 Freeciv - Copyright (C) 2005 - The Freeciv Project
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; either version 2, or (at your option)
6 any later version.
7
8 This program is distributed in the hope that it will be useful,
9 but WITHOUT ANY WARRANTY; without even the implied warranty of
10 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
11 GNU General Public License for more details.
12*****************************************************************************/
13
14#ifdef HAVE_CONFIG_H
15#include <fc_config.h>
16#endif
17
18/* utility */
19#include "deprecations.h"
20
21/* common */
22#include "achievements.h"
23#include "actions.h"
24#include "calendar.h"
25#include "citizens.h"
26#include "culture.h"
27#include "featured_text.h"
28#include "game.h"
29#include "government.h"
30#include "improvement.h"
31#include "map.h"
32#include "movement.h"
33#include "nation.h"
34#include "research.h"
35#include "tech.h"
36#include "terrain.h"
37#include "tile.h"
38#include "unitlist.h"
39#include "unittype.h"
40
41/* common/scriptcore */
42#include "luascript.h"
43
44#include "api_game_methods.h"
45
46
47/**********************************************************************/
56
57/**********************************************************************/
66
67/**********************************************************************/
76
77/**********************************************************************/
86
87/**********************************************************************/
91{
93
94 log_deprecation("Deprecated: lua construct \"game:turn\", deprecated since \"3.0\", used. "
95 "Use \"game:current_turn\" instead.");
96
97 if (game.info.turn > 0) {
98 return game.info.turn - 1;
99 }
100
101 return game.info.turn;
102}
103
104/**********************************************************************/
108{
109 return game.server.rulesetdir;
110}
111
112/**********************************************************************/
116{
117 return game.control.name;
118}
119
120/**********************************************************************/
131
132/**********************************************************************/
143
144/**********************************************************************/
155
156/**********************************************************************/
167
168/**********************************************************************/
179
180/**********************************************************************/
183const char
192
193/**********************************************************************/
197 Building_Type *building)
198{
202
203 return city_has_building(pcity, building);
204}
205
206/**********************************************************************/
210{
212 LUASCRIPT_CHECK_SELF(L, pcity, 0);
213
214 return city_map_radius_sq_get(pcity);
215}
216
217/**********************************************************************/
221{
223 LUASCRIPT_CHECK_SELF(L, pcity, 1);
224
225 return city_size_get(pcity);
226}
227
228/**********************************************************************/
232{
234 LUASCRIPT_CHECK_SELF(L, pcity, NULL);
235
236 return pcity->tile;
237}
238
239/**********************************************************************/
244{
245 bool inspired = FALSE;
246
248 if (self->original == inspirer) {
249 inspired = TRUE;
250 }
251 } else {
253 if (is_server()) {
255 citizens total = city_size_get(self);
256
257 if (total > 0 && (own * 100 / total) >= game.info.citizen_partisans_pct) {
258 inspired = TRUE;
259 }
260 }
261 /* else is_client() -> don't consider inspired by default. */
262 } else if (self->original == inspirer) {
263 inspired = TRUE;
264 }
265 }
266
267 if (inspired) {
268 /* Cannot use get_city_bonus() as it would use city's current owner
269 * instead of inspirer. */
271 &(const struct req_context) {
272 .player = inspirer,
273 .city = self,
274 .tile = city_tile(self),
275 },
277 }
278
279 return 0;
280}
281
282/**********************************************************************/
286{
288 LUASCRIPT_CHECK_SELF(L, pcity, 0);
289
290 return city_culture(pcity);
291}
292
293/**********************************************************************/
297{
299
300 return counter_rule_name(c);
301}
302
303/**********************************************************************/
312
313/**********************************************************************/
322
323/**********************************************************************/
327{
330
331 /* Note: if clients ever have virtual cities or sth, needs amending */
332 return is_server() ? city_happy(pcity) : pcity->client.happy;
333}
334
335/**********************************************************************/
339{
342
343 /* Note: if clients ever have virtual cities or sth, needs amending */
344 return is_server() ? city_unhappy(pcity) : pcity->client.unhappy;
345}
346
347/**********************************************************************/
351{
354
355 return city_celebrating(pcity);
356}
357
358/**********************************************************************/
362{
365
366 return is_gov_center(pcity);
367}
368
369/**********************************************************************/
373{
376
377 return is_capital(pcity);
378}
379
380/**********************************************************************/
384{
387
388 return pcity->capital == CAPITAL_PRIMARY;
389}
390
391/**********************************************************************/
402
403/**********************************************************************/
414
415/**********************************************************************/
419 Nation_Type *pnation)
420{
422 LUASCRIPT_CHECK_SELF(L, pnation, NULL);
423
424 return nation_rule_name(pnation);
425}
426
427/**********************************************************************/
431 Nation_Type *pnation)
432{
434 LUASCRIPT_CHECK_SELF(L, pnation, NULL);
435
436 return nation_adjective_translation(pnation);
437}
438
439/**********************************************************************/
443 Nation_Type *pnation)
444{
446 LUASCRIPT_CHECK_SELF(L, pnation, NULL);
447
448 return nation_plural_translation(pnation);
449}
450
451/**********************************************************************/
455 Player *pplayer)
456{
457 struct connection *conn = NULL;
458
460 LUASCRIPT_CHECK_SELF(L, pplayer, NULL);
461
463 if (!pconn->observer) {
464 conn = pconn;
465 break;
466 }
468
469 if (conn == NULL) {
470 return "None";
471 }
472
473 return gui_type_name(conn->client_gui);
474}
475
476/**********************************************************************/
480 Building_Type *building)
481{
483 LUASCRIPT_CHECK_SELF(L, pplayer, FALSE);
485
486 return wonder_is_built(pplayer, building);
487}
488
489/**********************************************************************/
493{
495 LUASCRIPT_CHECK_SELF(L, pplayer, -1);
496
497 return player_number(pplayer);
498}
499
500/**********************************************************************/
504{
506 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
507
508 return city_list_size(pplayer->cities);
509}
510
511/**********************************************************************/
515{
517 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
518
519 return unit_list_size(pplayer->units);
520}
521
522/**********************************************************************/
526{
528 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
529
530 return pplayer->economic.gold;
531}
532
533/**********************************************************************/
537{
539 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
540
541 return pplayer->economic.infra_points;
542}
543
544/**********************************************************************/
557
558/**********************************************************************/
573
574/**********************************************************************/
588{
591
592 if (!pplayer && TECH_COST_CIV1CIV2 == game.info.tech_cost_style) {
593 /* Avoid getting error messages and return at least something */
594 return ptech->cost * (double) game.info.sciencebox / 100.0;
595 }
596 return
599}
600
601/**********************************************************************/
611{
612 const struct research *presearch;
613 int rr;
614
616 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
617 presearch = research_get(pplayer);
618 LUASCRIPT_CHECK(L, presearch, "player's research not set", 0);
619
620 rr = presearch->researching;
621
622 switch (rr) {
623 case A_FUTURE:
625 break;
626 case A_UNSET:
627 case A_UNKNOWN:
628 lua_pushnil(L);
629 break;
630 default:
631 /* A regular tech */
632 fc_assert(rr >= A_FIRST && rr <= A_LAST);
634 }
635
636 return lua_gettop(L);
637}
638
639/**********************************************************************/
645{
646 const struct research *presearch;
647
649 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
650 presearch = research_get(pplayer);
651 LUASCRIPT_CHECK(L, presearch, "player's research not set", 0);
652
653 return presearch->bulbs_researched;
654}
655
656/**********************************************************************/
662{
663 const struct research *presearch;
664
666 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
667 presearch = research_get(pplayer);
668 LUASCRIPT_CHECK(L, presearch, "player's research not set", 0);
669
670 return is_server()
672 : presearch->client.researching_cost;
673}
674
675/**********************************************************************/
681{
682 const struct research *presearch;
683
685 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
686 presearch = research_get(pplayer);
687 LUASCRIPT_CHECK(L, presearch, "player's research not set", 0);
688
689 return presearch->future_tech;
690}
691
692/**********************************************************************/
696{
698 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
699
700 return player_culture(pplayer);
701}
702
703/**********************************************************************/
707 const char *flag)
708{
710
712 LUASCRIPT_CHECK_SELF(L, pplayer, 0);
713
715
717 return player_has_flag(pplayer, flag_val);
718 }
719
720 return FALSE;
721}
722
723/**********************************************************************/
728 Unit_Type *utype)
729{
731 LUASCRIPT_CHECK_SELF(L, pplayer, NULL);
733
734 return (Unit_Type *)can_upgrade_unittype(pplayer, utype);
735}
736
737/**********************************************************************/
742 Unit_Type *utype)
743{
745 LUASCRIPT_CHECK_SELF(L, pplayer, FALSE);
747
748 return can_player_build_unit_direct(pplayer, utype, TRUE);
749}
750
751/**********************************************************************/
763
764
765/**********************************************************************/
774
775/**********************************************************************/
781{
783
787
789 switch (uu) {
790 case UU_OK:
791 return NULL;
793 return "cargo";
795 return "transport";
796 case UU_NOT_TERRAIN:
797 return "terrain";
798 case UU_NOT_ACTIVITY:
799 return "activity";
800 case UU_NO_UNITTYPE:
801 case UU_NO_MONEY:
802 case UU_NOT_IN_CITY:
804 /* should not get here */
805 break;
806 }
807
808 fc_assert_msg(FALSE, "Unexpected unit transform result %i", uu);
809
810 return "\?";
811}
812
813/**********************************************************************/
825
826/**********************************************************************/
830{
832 LUASCRIPT_CHECK_SELF(L, pplayer, NULL);
833
834 return research_rule_name(research_get(pplayer));
835}
836
837/**********************************************************************/
841 Player *pplayer)
842{
843 static char buf[MAX_LEN_MSG];
844
846 LUASCRIPT_CHECK_SELF(L, pplayer, NULL);
847
849
850 return buf;
851}
852
853/**********************************************************************/
858{
859 lua_Object result = 0;
860 int i = 0;
861
864 result = lua_gettop(L);
865 players_iterate(pplayer) {
866 tolua_pushfieldusertype(L, result, ++i, pplayer, "Player");
868 return result;
869}
870
871/**********************************************************************/
881
882/**********************************************************************/
893
894/**********************************************************************/
904
905/**********************************************************************/
916
917/**********************************************************************/
921{
923 LUASCRIPT_CHECK_SELF(L, pterrain, NULL);
924
925 return terrain_rule_name(pterrain);
926}
927
928/**********************************************************************/
932 Terrain *pterrain)
933{
935 LUASCRIPT_CHECK_SELF(L, pterrain, NULL);
936
937 return terrain_name_translation(pterrain);
938}
939
940/**********************************************************************/
944{
946 LUASCRIPT_CHECK_SELF(L, pterrain, NULL);
947
949}
950
951/**********************************************************************/
961
962/**********************************************************************/
973
974/**********************************************************************/
985
986/**********************************************************************/
997
998/**********************************************************************/
1008
1009/**********************************************************************/
1019
1020/**********************************************************************/
1024{
1025 struct action *paction;
1026
1029
1031 fc_assert_ret_val(paction, "error: no action");
1032
1034}
1035
1036/**********************************************************************/
1040{
1042 LUASCRIPT_CHECK_SELF(L, ptile, -1);
1043
1044 return index_to_native_pos_x(tile_index(ptile));
1045}
1046
1047/**********************************************************************/
1051{
1053 LUASCRIPT_CHECK_SELF(L, ptile, -1);
1054
1055 return index_to_native_pos_y(tile_index(ptile));
1056}
1057
1058/**********************************************************************/
1062{
1064 LUASCRIPT_CHECK_SELF(L, ptile, -1);
1065
1066 return index_to_map_pos_x(tile_index(ptile));
1067}
1068
1069/**********************************************************************/
1073{
1075 LUASCRIPT_CHECK_SELF(L, ptile, -1);
1076
1077 return index_to_map_pos_y(tile_index(ptile));
1078}
1079
1080/**********************************************************************/
1084{
1086 LUASCRIPT_CHECK_SELF(L, ptile, NULL);
1087
1088 return tile_city(ptile);
1089}
1090
1091/**********************************************************************/
1103
1104/**********************************************************************/
1109 const char *name)
1110{
1112 LUASCRIPT_CHECK_SELF(L, ptile, FALSE);
1113
1114 if (!name) {
1115 extra_type_iterate(pextra) {
1116 if (tile_has_extra(ptile, pextra)) {
1117 return TRUE;
1118 }
1120
1121 return FALSE;
1122 } else {
1123 struct extra_type *pextra;
1124
1125 pextra = extra_type_by_rule_name(name);
1126
1127 return (NULL != pextra && tile_has_extra(ptile, pextra));
1128 }
1129}
1130
1131/**********************************************************************/
1135bool api_methods_tile_has_base(lua_State *L, Tile *ptile, const char *name)
1136{
1138 LUASCRIPT_CHECK_SELF(L, ptile, FALSE);
1139
1140 if (!name) {
1142 if (tile_has_extra(ptile, pextra)) {
1143 return TRUE;
1144 }
1146
1147 return FALSE;
1148 } else {
1149 struct extra_type *pextra;
1150
1151 pextra = extra_type_by_rule_name(name);
1152
1153 return (NULL != pextra && is_extra_caused_by(pextra, EC_BASE)
1154 && tile_has_extra(ptile, pextra));
1155 }
1156}
1157
1158/**********************************************************************/
1162bool api_methods_tile_has_road(lua_State *L, Tile *ptile, const char *name)
1163{
1165 LUASCRIPT_CHECK_SELF(L, ptile, FALSE);
1166
1167 if (!name) {
1169 if (tile_has_extra(ptile, pextra)) {
1170 return TRUE;
1171 }
1173
1174 return FALSE;
1175 } else {
1176 struct extra_type *pextra;
1177
1178 pextra = extra_type_by_rule_name(name);
1179
1180 return (NULL != pextra && is_extra_caused_by(pextra, EC_ROAD)
1181 && tile_has_extra(ptile, pextra));
1182 }
1183}
1184
1185/**********************************************************************/
1192 Tile *ptile, const char *extra_name)
1193{
1195 LUASCRIPT_CHECK_SELF(L, ptile, NULL);
1196
1197 if (extra_name) {
1198 struct extra_type *pextra;
1199
1201 LUASCRIPT_CHECK_ARG(L, pextra != NULL, 3, "unknown extra type", NULL);
1202
1203 if (tile_has_extra(ptile, pextra)) {
1204 /* All extras have the same owner. */
1205 return extra_owner(ptile);
1206 } else {
1207 /* The extra isn't there. */
1208 return NULL;
1209 }
1210 } else {
1211 extra_type_iterate(pextra) {
1212 if (tile_has_extra(ptile, pextra)) {
1213 /* All extras have the same owner. */
1214 return extra_owner(ptile);
1215 }
1217 return NULL;
1218 }
1219}
1220
1221/**********************************************************************/
1225{
1226 struct city *pcity;
1227
1229 LUASCRIPT_CHECK_SELF(L, ptile, FALSE);
1230
1231 if (is_non_allied_unit_tile(ptile, against)) {
1232 return TRUE;
1233 }
1234
1235 pcity = tile_city(ptile);
1236 if (pcity != NULL && !pplayers_allied(against, city_owner(pcity))) {
1237 return TRUE;
1238 }
1239
1240 return FALSE;
1241}
1242
1243/**********************************************************************/
1247{
1249 LUASCRIPT_CHECK_SELF(L, ptile, 0);
1250
1251 return unit_list_size(ptile->units);
1252}
1253
1254/**********************************************************************/
1265
1266/**********************************************************************/
1271 int tindex, int max_dist)
1272{
1273 int dx, dy;
1274 int newx, newy;
1275 int startx, starty;
1276
1279
1280 if (tindex < 0) {
1281 return 0;
1282 }
1283
1285
1286 tindex++;
1287 while (tindex < wld.map.num_iterate_outwards_indices) {
1289 return -1;
1290 }
1291 dx = wld.map.iterate_outwards_indices[tindex].dx;
1292 dy = wld.map.iterate_outwards_indices[tindex].dy;
1293 newx = dx + startx;
1294 newy = dy + starty;
1295 if (!normalize_map_pos(&(wld.map), &newx, &newy)) {
1296 tindex++;
1297 continue;
1298 }
1299
1300 return tindex;
1301 }
1302
1303 return -1;
1304}
1305
1306/**********************************************************************/
1310 Tile *pstart, int tindex)
1311{
1312 int newx, newy;
1313
1317 tindex >= 0 && tindex < wld.map.num_iterate_outwards_indices,
1318 3, "index out of bounds", NULL);
1319
1323
1324 if (!normalize_map_pos(&(wld.map), &newx, &newy)) {
1325 return NULL;
1326 }
1327
1328 return map_pos_to_tile(&(wld.map), newx, newy);
1329}
1330
1331/**********************************************************************/
1342
1343/**********************************************************************/
1357
1358/**********************************************************************/
1368
1369/**********************************************************************/
1380
1381/**********************************************************************/
1391
1392/**********************************************************************/
1402
1403/**********************************************************************/
1407 const char *flag)
1408{
1409 enum unit_type_flag_id id;
1410
1413 LUASCRIPT_CHECK_ARG_NIL(L, flag, 3, string, FALSE);
1414
1417 return utype_has_flag(punit_type, id);
1418 } else {
1419 luascript_error(L, "Unit type flag \"%s\" does not exist", flag);
1420 return FALSE;
1421 }
1422}
1423
1424/**********************************************************************/
1428 const char *role)
1429{
1430 enum unit_role_id id;
1431
1434 LUASCRIPT_CHECK_ARG_NIL(L, role, 3, string, FALSE);
1435
1437 if (unit_role_id_is_valid(id)) {
1438 return utype_has_role(punit_type, id);
1439 } else {
1440 luascript_error(L, "Unit role \"%s\" does not exist", role);
1441 return FALSE;
1442 }
1443}
1444
1445/**********************************************************************/
1458
1459/**********************************************************************/
1470
1471/**********************************************************************/
1482
1483
1484/**********************************************************************/
1494
1495/**********************************************************************/
1505
1506/**********************************************************************/
1516
1517/**********************************************************************/
1527
1528/**********************************************************************/
1532{
1534 LUASCRIPT_CHECK_SELF(L, ptile, NULL);
1535
1536 return tile_link(ptile);
1537}
1538
1539/**********************************************************************/
1549
1550/**********************************************************************/
1554{
1556 LUASCRIPT_CHECK_SELF(L, pcity, NULL);
1557
1558 return city_tile_link(pcity);
1559}
1560
1561/**********************************************************************/
1565{
1568
1569 return unit_link(punit);
1570}
1571
1572/**********************************************************************/
1576{
1578 LUASCRIPT_CHECK_SELF(L, pcity, NULL);
1579
1580 return city_link(pcity);
1581}
const char * achievement_rule_name(struct achievement *pach)
const char * achievement_name_translation(struct achievement *pach)
const char * action_id_name_translation(action_id act_id)
Definition actions.c:2002
const char * action_id_rule_name(action_id act_id)
Definition actions.c:1991
enum action_target_kind action_get_target_kind(const struct action *paction)
Definition actions.c:1860
static struct action * action_by_number(action_id act_id)
Definition actions.h:633
int api_methods_tile_nat_x(lua_State *L, Tile *ptile)
int api_methods_tile_num_units(lua_State *L, Tile *ptile)
bool api_methods_is_city_unhappy(lua_State *L, City *pcity)
bool api_methods_is_gov_center(lua_State *L, City *pcity)
const char * api_methods_game_rulesetdir(lua_State *L)
int api_methods_player_future(lua_State *L, Player *pplayer)
bool api_methods_unit_type_can_exist_at_tile(lua_State *L, Unit_Type *punit_type, Tile *ptile)
int api_methods_player_num_cities(lua_State *L, Player *pplayer)
bool api_methods_unit_can_upgrade(lua_State *L, Unit *punit, bool is_free)
bool api_methods_player_has_wonder(lua_State *L, Player *pplayer, Building_Type *building)
Unit_List_Link * api_methods_unit_list_next_link(lua_State *L, Unit_List_Link *ul_link)
const char * api_methods_nation_type_plural_translation(lua_State *L, Nation_Type *pnation)
const char * api_methods_disaster_name_translation(lua_State *L, Disaster *pdis)
Unit * api_methods_unit_list_link_data(lua_State *L, Unit_List_Link *ul_link)
int api_methods_tile_nat_y(lua_State *L, Tile *ptile)
Unit_List_Link * api_methods_private_tile_unit_list_head(lua_State *L, Tile *ptile)
int api_methods_player_tech_cost(lua_State *L, Player *pplayer, Tech_Type *ptech)
lua_Object api_methods_player_researching(lua_State *L, Player *pplayer)
int api_methods_game_year_fragment(lua_State *L)
const char * api_methods_counter_name_translation(lua_State *L, Counter *c)
int api_methods_city_culture_get(lua_State *L, City *pcity)
const char * api_methods_unit_type_name_translation(lua_State *L, Unit_Type *punit_type)
const char * api_methods_game_ruleset_name(lua_State *L)
const char * api_methods_building_type_rule_name(lua_State *L, Building_Type *pbuilding)
City * api_methods_city_list_link_data(lua_State *L, City_List_Link *cl_link)
const char * api_methods_unit_tile_link(lua_State *L, Unit *punit)
const char * api_methods_counter_rule_name(lua_State *L, Counter *c)
bool api_methods_player_can_build_impr_direct(lua_State *L, Player *pplayer, Building_Type *itype)
int api_methods_player_num_units(lua_State *L, Player *pplayer)
const char * api_methods_tech_type_rule_name(lua_State *L, Tech_Type *ptech)
int api_methods_tile_map_x(lua_State *L, Tile *ptile)
bool api_methods_is_city_happy(lua_State *L, City *pcity)
const char * api_methods_achievement_rule_name(lua_State *L, Achievement *pach)
Unit_Type * api_methods_player_can_upgrade(lua_State *L, Player *pplayer, Unit_Type *utype)
const char * api_methods_city_link(lua_State *L, City *pcity)
const char * api_methods_nation_type_name_translation(lua_State *L, Nation_Type *pnation)
const char * api_methods_government_rule_name(lua_State *L, Government *pgovernment)
const char * api_methods_terrain_rule_name(lua_State *L, Terrain *pterrain)
int api_methods_player_number(lua_State *L, Player *pplayer)
int api_methods_player_infrapoints(lua_State *L, Player *pplayer)
Unit_List_Link * api_methods_private_unit_cargo_list_head(lua_State *L, Unit *punit)
const char * api_methods_player_controlling_gui(lua_State *L, Player *pplayer)
const char * api_methods_action_name_translation(lua_State *L, Action *pact)
const char * api_methods_terrain_class_name(lua_State *L, Terrain *pterrain)
bool api_methods_player_shares_research(lua_State *L, Player *pplayer, Player *aplayer)
const char * api_methods_tech_type_name_translation(lua_State *L, Tech_Type *ptech)
Player * api_methods_tile_extra_owner(lua_State *L, Tile *ptile, const char *extra_name)
int api_methods_city_size_get(lua_State *L, City *pcity)
City * api_methods_tile_city(lua_State *L, Tile *ptile)
const char * api_methods_government_name_translation(lua_State *L, Government *pgovernment)
bool api_method_player_can_research(lua_State *L, Player *pplayer, Tech_Type *ptech)
bool api_methods_tile_has_extra(lua_State *L, Tile *ptile, const char *name)
int api_methods_tile_sq_distance(lua_State *L, Tile *ptile1, Tile *ptile2)
bool api_methods_unit_type_has_role(lua_State *L, Unit_Type *punit_type, const char *role)
const char * api_methods_tile_link(lua_State *L, Tile *ptile)
int api_methods_player_culture_get(lua_State *L, Player *pplayer)
int api_methods_game_turn_deprecated(lua_State *L)
int api_methods_player_bulbs(lua_State *L, Player *pplayer)
const char * api_methods_achievement_name_translation(lua_State *L, Achievement *pach)
bool api_methods_building_type_is_great_wonder(lua_State *L, Building_Type *pbuilding)
const char * api_methods_city_tile_link(lua_State *L, City *pcity)
int api_methods_private_tile_next_outward_index(lua_State *L, Tile *pstart, int tindex, int max_dist)
Tile * api_methods_unit_tile_get(lua_State *L, Unit *punit)
bool api_methods_tile_has_road(lua_State *L, Tile *ptile, const char *name)
const char * api_methods_nation_type_rule_name(lua_State *L, Nation_Type *pnation)
const Direction * api_methods_unit_orientation_get(lua_State *L, Unit *punit)
int api_methods_game_turn(lua_State *L)
bool api_methods_player_knows_tech(lua_State *L, Player *pplayer, Tech_Type *ptech)
bool api_methods_enemy_tile(lua_State *L, Tile *ptile, Player *against)
bool api_methods_building_type_is_small_wonder(lua_State *L, Building_Type *pbuilding)
int api_methods_game_year(lua_State *L)
Tile * api_methods_private_tile_for_outward_index(lua_State *L, Tile *pstart, int tindex)
const char * api_methods_game_year_text(lua_State *L)
const char * api_methods_action_rule_name(lua_State *L, Action *pact)
const char * api_methods_disaster_rule_name(lua_State *L, Disaster *pdis)
const char * api_methods_building_type_name_translation(lua_State *L, Building_Type *pbuilding)
bool api_methods_building_type_is_wonder(lua_State *L, Building_Type *pbuilding)
const char * api_methods_research_name_translation(lua_State *L, Player *pplayer)
int api_methods_city_inspire_partisans(lua_State *L, City *self, Player *inspirer)
int api_methods_city_map_sq_radius(lua_State *L, City *pcity)
bool api_methods_city_has_building(lua_State *L, City *pcity, Building_Type *building)
const char * api_methods_unit_transform_problem(lua_State *L, Unit *punit, Unit_Type *ptype)
City_List_Link * api_methods_city_list_next_link(lua_State *L, City_List_Link *cl_link)
bool api_methods_unit_type_has_flag(lua_State *L, Unit_Type *punit_type, const char *flag)
const char * api_methods_unit_type_rule_name(lua_State *L, Unit_Type *punit_type)
bool api_methods_building_type_is_improvement(lua_State *L, Building_Type *pbuilding)
bool api_methods_tile_city_exists_within_max_city_map(lua_State *L, Tile *ptile, bool may_be_on_center)
bool api_methods_player_has_flag(lua_State *L, Player *pplayer, const char *flag)
lua_Object api_methods_private_list_players(lua_State *L)
bool api_methods_unit_city_can_be_built_here(lua_State *L, Unit *punit)
bool api_methods_tile_has_base(lua_State *L, Tile *ptile, const char *name)
int api_methods_player_gold(lua_State *L, Player *pplayer)
const char * api_methods_research_rule_name(lua_State *L, Player *pplayer)
bool api_methods_is_primary_capital(lua_State *L, City *pcity)
int api_methods_player_research_cost(lua_State *L, Player *pplayer)
int api_methods_tile_map_y(lua_State *L, Tile *ptile)
Unit_List_Link * api_methods_private_player_unit_list_head(lua_State *L, Player *pplayer)
const char * api_methods_action_target_kind(lua_State *L, Action *pact)
City_List_Link * api_methods_private_player_city_list_head(lua_State *L, Player *pplayer)
const char * api_methods_terrain_name_translation(lua_State *L, Terrain *pterrain)
Tile * api_methods_city_tile_get(lua_State *L, City *pcity)
const char * api_methods_unit_link(lua_State *L, Unit *punit)
bool api_methods_is_city_celebrating(lua_State *L, City *pcity)
int api_methods_counter_city_get(lua_State *L, Counter *c, City *city)
bool api_methods_is_capital(lua_State *L, City *pcity)
bool api_methods_player_can_build_unit_direct(lua_State *L, Player *pplayer, Unit_Type *utype)
Unit * api_methods_unit_transporter(lua_State *L, Unit *punit)
const char * calendar_text(void)
Definition calendar.c:141
citizens citizens_nation_get(const struct city *pcity, const struct player_slot *pslot)
Definition citizens.c:74
bool city_exists_within_max_city_map(const struct tile *ptile, bool may_be_on_center)
Definition city.c:2102
bool city_has_building(const struct city *pcity, const struct impr_type *pimprove)
Definition city.c:1231
bool is_capital(const struct city *pcity)
Definition city.c:1571
bool city_can_be_built_here(const struct tile *ptile, const struct unit *punit, bool hut_test)
Definition city.c:1478
bool city_unhappy(const struct city *pcity)
Definition city.c:1618
bool city_celebrating(const struct city *pcity)
Definition city.c:1637
bool city_happy(const struct city *pcity)
Definition city.c:1606
int city_map_radius_sq_get(const struct city *pcity)
Definition city.c:136
bool is_gov_center(const struct city *pcity)
Definition city.c:1579
#define city_tile(_pcity_)
Definition city.h:564
static citizens city_size_get(const struct city *pcity)
Definition city.h:569
#define city_owner(_pcity_)
Definition city.h:563
static struct ai_type * self
Definition classicai.c:45
char * incite_cost
Definition comments.c:74
#define MAX_LEN_MSG
Definition conn_types.h:37
#define conn_list_iterate(connlist, pconn)
Definition connection.h:108
#define conn_list_iterate_end
Definition connection.h:110
int counter_index(const struct counter *pcount)
Definition counters.c:174
const char * counter_name_translation(const struct counter *counter)
Definition counters.c:157
const char * counter_rule_name(struct counter *pcount)
Definition counters.c:165
int city_culture(const struct city *pcity)
Definition culture.c:29
int player_culture(const struct player *plr)
Definition culture.c:46
#define log_deprecation(message,...)
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
const char * disaster_rule_name(struct disaster_type *pdis)
Definition disaster.c:105
const char * disaster_name_translation(struct disaster_type *pdis)
Definition disaster.c:97
int int id
Definition editgui_g.h:28
int get_target_bonus_effects(struct effect_list *plist, const struct req_context *context, const struct player *other_player, enum effect_type effect_type)
Definition effects.c:748
struct extra_type * extra_type_by_rule_name(const char *name)
Definition extras.c:212
struct player * extra_owner(const struct tile *ptile)
Definition extras.c:1114
#define extra_type_iterate(_p)
Definition extras.h:315
#define extra_type_iterate_end
Definition extras.h:321
#define is_extra_caused_by(e, c)
Definition extras.h:203
#define extra_type_by_cause_iterate_end
Definition extras.h:339
#define extra_type_by_cause_iterate(_cause, _extra)
Definition extras.h:333
static bool is_server(void)
unsigned char citizens
Definition fc_types.h:391
const char * city_tile_link(const struct city *pcity)
const char * tile_link(const struct tile *ptile)
const char * city_link(const struct city *pcity)
const char * unit_link(const struct unit *punit)
const char * unit_tile_link(const struct unit *punit)
struct civ_game game
Definition game.c:62
struct world wld
Definition game.c:63
const char * government_name_translation(const struct government *pgovern)
Definition government.c:143
const char * government_rule_name(const struct government *pgovern)
Definition government.c:133
bool can_player_build_improvement_direct(const struct player *p, const struct impr_type *pimprove)
bool is_improvement(const struct impr_type *pimprove)
bool wonder_is_built(const struct player *pplayer, const struct impr_type *pimprove)
const char * improvement_rule_name(const struct impr_type *pimprove)
bool is_wonder(const struct impr_type *pimprove)
bool is_great_wonder(const struct impr_type *pimprove)
const char * improvement_name_translation(const struct impr_type *pimprove)
bool is_small_wonder(const struct impr_type *pimprove)
const char * name
Definition inputfile.c:127
#define fc_assert_msg(condition, message,...)
Definition log.h:181
#define fc_assert(condition)
Definition log.h:176
#define fc_assert_ret_val(condition, val)
Definition log.h:194
int luascript_error(lua_State *L, const char *format,...)
Definition luascript.c:292
const Direction * luascript_dir(enum direction8 dir)
Definition luascript.c:790
#define LUASCRIPT_CHECK_STATE(L,...)
Definition luascript.h:117
#define LUASCRIPT_CHECK_SELF(L, value,...)
Definition luascript.h:146
#define LUASCRIPT_CHECK_ARG_NIL(L, value, narg, type,...)
Definition luascript.h:138
#define LUASCRIPT_CHECK_ARG(L, check, narg, msg,...)
Definition luascript.h:131
#define LUASCRIPT_CHECK(L, check, msg,...)
Definition luascript.h:124
const struct city_list_link City_List_Link
enum direction8 Direction
const struct unit_list_link Unit_List_Link
int sq_map_distance(const struct tile *tile0, const struct tile *tile1)
Definition map.c:641
struct tile * map_pos_to_tile(const struct civ_map *nmap, int map_x, int map_y)
Definition map.c:419
bool normalize_map_pos(const struct civ_map *nmap, int *x, int *y)
Definition map.c:979
#define index_to_native_pos_y(mindex)
Definition map.h:162
static int index_to_map_pos_y(int mindex)
Definition map.h:724
static int index_to_map_pos_x(int mindex)
Definition map.h:715
#define index_to_native_pos_x(mindex)
Definition map.h:160
#define index_to_map_pos(pmap_x, pmap_y, mindex)
Definition map.h:233
bool can_exist_at_tile(const struct civ_map *nmap, const struct unit_type *utype, const struct tile *ptile)
Definition movement.c:290
const char * nation_rule_name(const struct nation_type *pnation)
Definition nation.c:138
const char * nation_adjective_translation(const struct nation_type *pnation)
Definition nation.c:149
const char * nation_plural_translation(const struct nation_type *pnation)
Definition nation.c:159
int player_count(void)
Definition player.c:817
int player_number(const struct player *pplayer)
Definition player.c:837
bool player_has_flag(const struct player *pplayer, enum plr_flag_id flag)
Definition player.c:1990
bool pplayers_allied(const struct player *pplayer, const struct player *pplayer2)
Definition player.c:1405
#define players_iterate_end
Definition player.h:537
#define players_iterate(_pplayer)
Definition player.h:532
const char * research_advance_name_translation(const struct research *presearch, Tech_type_id tech)
Definition research.c:273
int research_total_bulbs_required(const struct research *presearch, Tech_type_id tech, bool loss_value)
Definition research.c:868
const char * research_rule_name(const struct research *presearch)
Definition research.c:143
struct research * research_get(const struct player *pplayer)
Definition research.c:128
enum tech_state research_invention_state(const struct research *presearch, Tech_type_id tech)
Definition research.c:619
int research_pretty_name(const struct research *presearch, char *buf, size_t buf_len)
Definition research.c:169
#define ARRAY_SIZE(x)
Definition shared.h:85
Definition city.h:320
int * counter_values
Definition city.h:408
enum capital_type capital
Definition city.h:328
bool happy
Definition city.h:462
struct tile * tile
Definition city.h:322
bool unhappy
Definition city.h:463
struct city::@17::@20 client
struct packet_ruleset_control control
Definition game.h:83
struct packet_game_info info
Definition game.h:89
char rulesetdir[MAX_LEN_NAME]
Definition game.h:238
struct civ_game::@31::@35 server
int num_iterate_outwards_indices
Definition map_types.h:77
struct iter_index * iterate_outwards_indices
Definition map_types.h:76
enum gui_type client_gui
Definition connection.h:179
int dist
Definition city.h:110
int dx
Definition city.h:110
int dy
Definition city.h:110
enum tech_cost_style tech_cost_style
char name[MAX_LEN_NAME]
int infra_points
Definition player.h:65
struct city_list * cities
Definition player.h:279
struct unit_list * units
Definition player.h:280
struct conn_list * connections
Definition player.h:296
struct player_economic economic
Definition player.h:282
Definition tile.h:50
struct unit_list * units
Definition tile.h:58
Definition unit.h:138
struct unit_list * transporting
Definition unit.h:184
enum direction8 facing
Definition unit.h:142
struct unit * transporter
Definition unit.h:183
struct civ_map map
int fc_strcasecmp(const char *str0, const char *str1)
Definition support.c:189
#define TRUE
Definition support.h:46
#define FALSE
Definition support.h:47
struct advance * advance_by_number(const Tech_type_id atype)
Definition tech.c:107
const char * advance_name_translation(const struct advance *padvance)
Definition tech.c:290
const char * advance_rule_name(const struct advance *padvance)
Definition tech.c:299
Tech_type_id advance_index(const struct advance *padvance)
Definition tech.c:89
Tech_type_id advance_number(const struct advance *padvance)
Definition tech.c:98
#define A_FUTURE
Definition tech.h:46
#define A_FIRST
Definition tech.h:44
#define A_UNSET
Definition tech.h:48
#define A_UNKNOWN
Definition tech.h:49
#define A_LAST
Definition tech.h:45
const char * terrain_name_translation(const struct terrain *pterrain)
Definition terrain.c:238
const char * terrain_rule_name(const struct terrain *pterrain)
Definition terrain.c:247
enum terrain_class terrain_type_terrain_class(const struct terrain *pterrain)
Definition terrain.c:582
struct city * tile_city(const struct tile *ptile)
Definition tile.c:83
#define tile_index(_pt_)
Definition tile.h:88
#define tile_has_extra(ptile, pextra)
Definition tile.h:147
enum unit_upgrade_result unit_transform_result(const struct civ_map *nmap, const struct unit *punit, const struct unit_type *to_unittype)
Definition unit.c:1952
enum unit_upgrade_result unit_upgrade_test(const struct civ_map *nmap, const struct unit *punit, bool is_free)
Definition unit.c:1984
#define unit_tile(_pu)
Definition unit.h:390
unit_upgrade_result
Definition unit.h:60
@ UU_NO_MONEY
Definition unit.h:63
@ UU_NOT_IN_CITY
Definition unit.h:64
@ UU_NO_UNITTYPE
Definition unit.h:62
@ UU_NOT_TERRAIN
Definition unit.h:67
@ UU_UNSUITABLE_TRANSPORT
Definition unit.h:68
@ UU_NOT_CITY_OWNER
Definition unit.h:65
@ UU_NOT_ENOUGH_ROOM
Definition unit.h:66
@ UU_OK
Definition unit.h:61
@ UU_NOT_ACTIVITY
Definition unit.h:69
static bool is_non_allied_unit_tile(const struct tile *ptile, const struct player *pplayer)
Definition unit.h:425
bool can_player_build_unit_direct(const struct player *p, const struct unit_type *punittype, bool consider_reg_impr_req)
Definition unittype.c:1968
bool utype_has_role(const struct unit_type *punittype, int role)
Definition unittype.c:199
const struct unit_type * can_upgrade_unittype(const struct player *pplayer, const struct unit_type *punittype)
Definition unittype.c:1703
const char * utype_rule_name(const struct unit_type *punittype)
Definition unittype.c:1578
const char * utype_name_translation(const struct unit_type *punittype)
Definition unittype.c:1560
static bool utype_has_flag(const struct unit_type *punittype, int flag)
Definition unittype.h:617