api_game_methods.cpp

Go to the documentation of this file.

/*
 Copyright (c) 1996-2020 Freeciv21 and Freeciv contributors. This file is
 part of Freeciv21. Freeciv21 is free software: you can redistribute it
 and/or modify it under the terms of the GNU  General Public License  as
 published by the Free Software Foundation, either version 3 of the
 License,  or (at your option) any later version. You should have received
 a copy of the GNU General Public License along with Freeciv21. If not,
 see https://www.gnu.org/licenses/.
 */
 
// utility
#include "deprecations.h"
#include "fcintl.h"
 
// common
#include "achievements.h"
#include "actions.h"
#include "calendar.h"
#include "citizens.h"
#include "culture.h"
#include "game.h"
#include "government.h"
#include "improvement.h"
#include "map.h"
#include "movement.h"
#include "nation.h"
#include "research.h"
#include "tech.h"
#include "terrain.h"
#include "tile.h"
#include "unitlist.h"
#include "unittype.h"
 
/* common/scriptcore */
#include "luascript.h"
 
#include "api_game_methods.h"
 
int api_methods_game_turn(lua_State *L)
{
  LUASCRIPT_CHECK_STATE(L, 0);
 
  return game.info.turn;
}
 
int api_methods_game_year(lua_State *L)
{
  LUASCRIPT_CHECK_STATE(L, 0);
 
  return game.info.year;
}
 
int api_methods_game_year_fragment(lua_State *L)
{
  LUASCRIPT_CHECK_STATE(L, 0);
 
  return game.info.fragment_count;
}
 
const char *api_methods_game_year_text(lua_State *L)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
 
  return calendar_text();
}
 
int api_methods_game_turn_deprecated(lua_State *L)
{
  LUASCRIPT_CHECK_STATE(L, 0);
 
  qCWarning(deprecations_category,
            "Deprecated: lua construct \"game:turn\", deprecated "
            "since \"3.0\", used. "
            "Use \"game:current_turn\" instead.");
 
  if (game.info.turn > 0) {
    return game.info.turn - 1;
  }
 
  return game.info.turn;
}
 
const char *api_methods_game_rulesetdir(lua_State *L)
{
  Q_UNUSED(L)
  return game.server.rulesetdir;
}
 
const char *api_methods_game_ruleset_name(lua_State *L)
{
  Q_UNUSED(L)
  return game.control.name;
}
 
bool api_methods_building_type_is_wonder(lua_State *L,
                                         Building_Type *pbuilding)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pbuilding, false);
 
  return is_wonder(pbuilding);
}
 
bool api_methods_building_type_is_great_wonder(lua_State *L,
                                               Building_Type *pbuilding)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pbuilding, false);
 
  return is_great_wonder(pbuilding);
}
 
bool api_methods_building_type_is_small_wonder(lua_State *L,
                                               Building_Type *pbuilding)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pbuilding, false);
 
  return is_small_wonder(pbuilding);
}
 
bool api_methods_building_type_is_improvement(lua_State *L,
                                              Building_Type *pbuilding)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pbuilding, false);
 
  return is_improvement(pbuilding);
}
 
const char *api_methods_building_type_rule_name(lua_State *L,
                                                Building_Type *pbuilding)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pbuilding, nullptr);
 
  return improvement_rule_name(pbuilding);
}
 
const char *
api_methods_building_type_name_translation(lua_State *L,
                                           Building_Type *pbuilding)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pbuilding, nullptr);
 
  return improvement_name_translation(pbuilding);
}
 
bool api_methods_city_has_building(lua_State *L, City *pcity,
                                   Building_Type *building)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pcity, false);
  LUASCRIPT_CHECK_ARG_NIL(L, building, 3, Building_Type, false);
 
  return city_has_building(pcity, building);
}
 
int api_methods_city_map_sq_radius(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, pcity, 0);
 
  return city_map_radius_sq_get(pcity);
}
 
int api_methods_city_size_get(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, 1);
  LUASCRIPT_CHECK_SELF(L, pcity, 1);
 
  return city_size_get(pcity);
}
 
Tile *api_methods_city_tile_get(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pcity, nullptr);
 
  return pcity->tile;
}
 
int api_methods_city_inspire_partisans(lua_State *L, City *self,
                                       Player *inspirer)
{
  Q_UNUSED(L)
  bool inspired = false;
 
  if (!game.info.citizen_nationality) {
    if (self->original == inspirer) {
      inspired = true;
    }
  } else {
    if (game.info.citizen_partisans_pct > 0) {
      if (is_server()) {
        int own = citizens_nation_get(self, inspirer->slot);
        int total = 0;
 
        /* Not citizens_foreign_iterate() as city has already changed hands.
         * old owner would be considered foreign and new owner not. */
        citizens_iterate(self, pslot, nat) { total += nat; }
        citizens_iterate_end;
 
        if (total != 0
            && ((own * 100 / total) >= game.info.citizen_partisans_pct)) {
          inspired = true;
        }
      }
      // else is_client() -> don't consider inspired by default.
    } else if (self->original == inspirer) {
      inspired = true;
    }
  }
 
  if (inspired) {
    /* Cannot use get_city_bonus() as it would use city's current owner
     * instead of inspirer. */
    return get_target_bonus_effects(
        nullptr, inspirer, nullptr, self, nullptr, city_tile(self), nullptr,
        nullptr, nullptr, nullptr, nullptr, EFT_INSPIRE_PARTISANS);
  }
 
  return 0;
}
 
int api_methods_city_culture_get(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, pcity, 0);
 
  return city_culture(pcity);
}
 
bool api_methods_is_city_happy(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pcity, false);
 
  // Note: if clients ever have virtual cities or sth, needs amending
  return is_server() ? city_happy(pcity) : pcity->client.happy;
}
 
bool api_methods_is_city_unhappy(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pcity, false);
 
  // Note: if clients ever have virtual cities or sth, needs amending
  return is_server() ? city_unhappy(pcity) : pcity->client.unhappy;
}
 
bool api_methods_is_city_celebrating(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pcity, false);
 
  return city_celebrating(pcity);
}
 
bool api_methods_is_gov_center(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pcity, false);
 
  return is_gov_center(pcity);
}
 
bool api_methods_is_capital(lua_State *L, City *pcity)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pcity, false);
 
  return is_capital(pcity);
}
 
const char *api_methods_government_rule_name(lua_State *L,
                                             Government *pgovernment)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pgovernment, nullptr);
 
  return government_rule_name(pgovernment);
}
 
const char *api_methods_government_name_translation(lua_State *L,
                                                    Government *pgovernment)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pgovernment, nullptr);
 
  return government_name_translation(pgovernment);
}
 
const char *api_methods_nation_type_rule_name(lua_State *L,
                                              Nation_Type *pnation)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pnation, nullptr);
 
  return nation_rule_name(pnation);
}
 
const char *api_methods_nation_type_name_translation(lua_State *L,
                                                     Nation_Type *pnation)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pnation, nullptr);
 
  return nation_adjective_translation(pnation);
}
 
const char *api_methods_nation_type_plural_translation(lua_State *L,
                                                       Nation_Type *pnation)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pnation, nullptr);
 
  return nation_plural_translation(pnation);
}
 
const char *api_methods_player_controlling_gui(lua_State *L, Player *pplayer)
{
  static bool warned = false;
  if (!warned) {
    qWarning() << "player:controlling_gui is deprecated";
    warned = true;
  }
  return "Qt";
}
 
bool api_methods_player_has_wonder(lua_State *L, Player *pplayer,
                                   Building_Type *building)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pplayer, false);
  LUASCRIPT_CHECK_ARG_NIL(L, building, 3, Building_Type, false);
 
  return wonder_is_built(pplayer, building);
}
 
int api_methods_player_number(lua_State *L, Player *pplayer)
{
  LUASCRIPT_CHECK_STATE(L, -1);
  LUASCRIPT_CHECK_SELF(L, pplayer, -1);
 
  return player_number(pplayer);
}
 
int api_methods_player_num_cities(lua_State *L, Player *pplayer)
{
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, pplayer, 0);
 
  return city_list_size(pplayer->cities);
}
 
int api_methods_player_num_units(lua_State *L, Player *pplayer)
{
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, pplayer, 0);
 
  return unit_list_size(pplayer->units);
}
 
int api_methods_player_gold(lua_State *L, Player *pplayer)
{
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, pplayer, 0);
 
  return pplayer->economic.gold;
}
 
bool api_methods_player_knows_tech(lua_State *L, Player *pplayer,
                                   Tech_Type *ptech)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pplayer, false);
  LUASCRIPT_CHECK_ARG_NIL(L, ptech, 3, Tech_Type, false);
 
  return research_invention_state(research_get(pplayer),
                                  advance_number(ptech))
         == TECH_KNOWN;
}
 
int api_methods_player_culture_get(lua_State *L, Player *pplayer)
{
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, pplayer, 0);
 
  return player_culture(pplayer);
}
 
bool api_methods_player_has_flag(lua_State *L, Player *pplayer,
                                 const char *flag)
{
  enum plr_flag_id flag_val;
 
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, pplayer, 0);
 
  flag_val = plr_flag_id_by_name(flag, fc_strcasecmp);
 
  if (plr_flag_id_is_valid(flag_val)) {
    return player_has_flag(pplayer, flag_val);
  }
 
  return false;
}
 
bool api_methods_player_shares_research(lua_State *L, Player *pplayer,
                                        Player *aplayer)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, pplayer, false);
  LUASCRIPT_CHECK_ARG_NIL(L, aplayer, 3, Player, false);
 
  return research_get(pplayer) == research_get(aplayer);
}
 
const char *api_methods_research_rule_name(lua_State *L, Player *pplayer)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pplayer, nullptr);
 
  return research_rule_name(research_get(pplayer));
}
 
const char *api_methods_research_name_translation(lua_State *L,
                                                  Player *pplayer)
{
  static char buf[MAX_LEN_MSG];
 
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pplayer, nullptr);
 
  (void) research_pretty_name(research_get(pplayer), buf, ARRAY_SIZE(buf));
 
  return buf;
}
 
Unit_List_Link *api_methods_private_player_unit_list_head(lua_State *L,
                                                          Player *pplayer)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pplayer, nullptr);
  return unit_list_head(pplayer->units);
}
 
City_List_Link *api_methods_private_player_city_list_head(lua_State *L,
                                                          Player *pplayer)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pplayer, nullptr);
 
  return city_list_head(pplayer->cities);
}
 
const char *api_methods_tech_type_rule_name(lua_State *L, Tech_Type *ptech)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, ptech, nullptr);
 
  return advance_rule_name(ptech);
}
 
const char *api_methods_tech_type_name_translation(lua_State *L,
                                                   Tech_Type *ptech)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, ptech, nullptr);
 
  return advance_name_translation(ptech);
}
 
const char *api_methods_terrain_rule_name(lua_State *L, Terrain *pterrain)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pterrain, nullptr);
 
  return terrain_rule_name(pterrain);
}
 
const char *api_methods_terrain_name_translation(lua_State *L,
                                                 Terrain *pterrain)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pterrain, nullptr);
 
  return terrain_name_translation(pterrain);
}
 
const char *api_methods_terrain_class_name(lua_State *L, Terrain *pterrain)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pterrain, nullptr);
 
  return terrain_class_name(terrain_type_terrain_class(pterrain));
}
 
const char *api_methods_disaster_rule_name(lua_State *L, Disaster *pdis)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pdis, nullptr);
 
  return disaster_rule_name(pdis);
}
 
const char *api_methods_disaster_name_translation(lua_State *L,
                                                  Disaster *pdis)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pdis, nullptr);
 
  return disaster_name_translation(pdis);
}
 
const char *api_methods_achievement_rule_name(lua_State *L,
                                              Achievement *pach)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pach, nullptr);
 
  return achievement_rule_name(pach);
}
 
const char *api_methods_achievement_name_translation(lua_State *L,
                                                     Achievement *pach)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pach, nullptr);
 
  return achievement_name_translation(pach);
}
 
const char *api_methods_action_rule_name(lua_State *L, Action *pact)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pact, nullptr);
 
  return action_id_rule_name(pact->id);
}
 
const char *api_methods_action_name_translation(lua_State *L, Action *pact)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pact, nullptr);
 
  return qUtf8Printable(action_id_name_translation(pact->id));
}
 
int api_methods_tile_nat_x(lua_State *L, Tile *ptile)
{
  LUASCRIPT_CHECK_STATE(L, -1);
  LUASCRIPT_CHECK_SELF(L, ptile, -1);
 
  return index_to_native_pos_x(tile_index(ptile));
}
 
int api_methods_tile_nat_y(lua_State *L, Tile *ptile)
{
  LUASCRIPT_CHECK_STATE(L, -1);
  LUASCRIPT_CHECK_SELF(L, ptile, -1);
 
  return index_to_native_pos_y(tile_index(ptile));
}
 
int api_methods_tile_map_x(lua_State *L, Tile *ptile)
{
  LUASCRIPT_CHECK_STATE(L, -1);
  LUASCRIPT_CHECK_SELF(L, ptile, -1);
 
  return index_to_map_pos_x(tile_index(ptile));
}
 
int api_methods_tile_map_y(lua_State *L, Tile *ptile)
{
  LUASCRIPT_CHECK_STATE(L, -1);
  LUASCRIPT_CHECK_SELF(L, ptile, -1);
 
  return index_to_map_pos_y(tile_index(ptile));
}
 
City *api_methods_tile_city(lua_State *L, Tile *ptile)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, ptile, nullptr);
 
  return tile_city(ptile);
}
 
bool api_methods_tile_city_exists_within_max_city_map(lua_State *L,
                                                      Tile *ptile,
                                                      bool may_be_on_center)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, ptile, false);
 
  return city_exists_within_max_city_map(ptile, may_be_on_center);
}
 
bool api_methods_tile_has_extra(lua_State *L, Tile *ptile, const char *name)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, ptile, false);
 
  if (!name) {
    extra_type_iterate(pextra)
    {
      if (tile_has_extra(ptile, pextra)) {
        return true;
      }
    }
    extra_type_iterate_end;
 
    return false;
  } else {
    struct extra_type *pextra;
 
    pextra = extra_type_by_rule_name(name);
 
    return (nullptr != pextra && tile_has_extra(ptile, pextra));
  }
}
 
bool api_methods_tile_has_base(lua_State *L, Tile *ptile, const char *name)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, ptile, false);
 
  if (!name) {
    extra_type_by_cause_iterate(EC_BASE, pextra)
    {
      if (tile_has_extra(ptile, pextra)) {
        return true;
      }
    }
    extra_type_by_cause_iterate_end;
 
    return false;
  } else {
    struct extra_type *pextra;
 
    pextra = extra_type_by_rule_name(name);
 
    return (nullptr != pextra && is_extra_caused_by(pextra, EC_BASE)
            && tile_has_extra(ptile, pextra));
  }
}
 
bool api_methods_tile_has_road(lua_State *L, Tile *ptile, const char *name)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, ptile, false);
 
  if (!name) {
    extra_type_by_cause_iterate(EC_ROAD, pextra)
    {
      if (tile_has_extra(ptile, pextra)) {
        return true;
      }
    }
    extra_type_by_cause_iterate_end;
 
    return false;
  } else {
    struct extra_type *pextra;
 
    pextra = extra_type_by_rule_name(name);
 
    return (nullptr != pextra && is_extra_caused_by(pextra, EC_ROAD)
            && tile_has_extra(ptile, pextra));
  }
}
 
bool api_methods_enemy_tile(lua_State *L, Tile *ptile, Player *against)
{
  struct city *pcity;
 
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, ptile, false);
 
  if (is_non_allied_unit_tile(ptile, against)) {
    return true;
  }
 
  pcity = tile_city(ptile);
  return pcity != nullptr && !pplayers_allied(against, city_owner(pcity));
}
 
int api_methods_tile_num_units(lua_State *L, Tile *ptile)
{
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, ptile, 0);
 
  return unit_list_size(ptile->units);
}
 
Unit_List_Link *api_methods_private_tile_unit_list_head(lua_State *L,
                                                        Tile *ptile)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, ptile, nullptr);
 
  return unit_list_head(ptile->units);
}
 
int api_methods_private_tile_next_outward_index(lua_State *L, Tile *pstart,
                                                int tindex, int max_dist)
{
  int dx, dy;
  int newx, newy;
  int startx, starty;
 
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, pstart, 0);
 
  if (tindex < 0) {
    return 0;
  }
 
  index_to_map_pos(&startx, &starty, tile_index(pstart));
 
  tindex++;
  while (tindex < wld.map.num_iterate_outwards_indices) {
    if (wld.map.iterate_outwards_indices[tindex].dist > max_dist) {
      return -1;
    }
    dx = wld.map.iterate_outwards_indices[tindex].dx;
    dy = wld.map.iterate_outwards_indices[tindex].dy;
    newx = dx + startx;
    newy = dy + starty;
    if (!normalize_map_pos(&(wld.map), &newx, &newy)) {
      tindex++;
      continue;
    }
 
    return tindex;
  }
 
  return -1;
}
 
Tile *api_methods_private_tile_for_outward_index(lua_State *L, Tile *pstart,
                                                 int tindex)
{
  int newx, newy;
 
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, pstart, nullptr);
  LUASCRIPT_CHECK_ARG(
      L, tindex >= 0 && tindex < wld.map.num_iterate_outwards_indices, 3,
      "index out of bounds", nullptr);
 
  index_to_map_pos(&newx, &newy, tile_index(pstart));
  newx += wld.map.iterate_outwards_indices[tindex].dx;
  newy += wld.map.iterate_outwards_indices[tindex].dy;
 
  if (!normalize_map_pos(&(wld.map), &newx, &newy)) {
    return nullptr;
  }
 
  return map_pos_to_tile(&(wld.map), newx, newy);
}
 
int api_methods_tile_sq_distance(lua_State *L, Tile *ptile1, Tile *ptile2)
{
  LUASCRIPT_CHECK_STATE(L, 0);
  LUASCRIPT_CHECK_SELF(L, ptile1, 0);
  LUASCRIPT_CHECK_ARG_NIL(L, ptile2, 3, Tile, 0);
 
  return sq_map_distance(ptile1, ptile2);
}
 
bool api_methods_unit_city_can_be_built_here(lua_State *L, Unit *punit)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, punit, false);
 
  return city_can_be_built_here(unit_tile(punit), punit);
}
 
Tile *api_methods_unit_tile_get(lua_State *L, Unit *punit)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, punit, nullptr);
 
  return unit_tile(punit);
}
 
const Direction *api_methods_unit_orientation_get(lua_State *L, Unit *punit)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_ARG_NIL(L, punit, 2, Unit, nullptr);
 
  return luascript_dir(punit->facing);
}
 
Unit *api_methods_unit_transporter(lua_State *L, Unit *punit)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, punit, nullptr);
 
  return punit->transporter;
}
 
Unit_List_Link *api_methods_private_unit_cargo_list_head(lua_State *L,
                                                         Unit *punit)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, punit, nullptr);
  return unit_list_head(punit->transporting);
}
 
bool api_methods_unit_type_has_flag(lua_State *L, Unit_Type *punit_type,
                                    const char *flag)
{
  enum unit_type_flag_id id;
 
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, punit_type, false);
  LUASCRIPT_CHECK_ARG_NIL(L, flag, 3, string, false);
 
  id = unit_type_flag_id_by_name(flag, fc_strcasecmp);
  if (unit_type_flag_id_is_valid(id)) {
    return utype_has_flag(punit_type, id);
  } else {
    luascript_error(L, "Unit type flag \"%s\" does not exist", flag);
    return false;
  }
}
 
bool api_methods_unit_type_has_role(lua_State *L, Unit_Type *punit_type,
                                    const char *role)
{
  enum unit_role_id id;
 
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, punit_type, false);
  LUASCRIPT_CHECK_ARG_NIL(L, role, 3, string, false);
 
  id = unit_role_id_by_name(role, fc_strcasecmp);
  if (unit_role_id_is_valid(id)) {
    return utype_has_role(punit_type, id);
  } else {
    luascript_error(L, "Unit role \"%s\" does not exist", role);
    return false;
  }
}
 
bool api_methods_unit_type_can_exist_at_tile(lua_State *L,
                                             Unit_Type *punit_type,
                                             Tile *ptile)
{
  LUASCRIPT_CHECK_STATE(L, false);
  LUASCRIPT_CHECK_SELF(L, punit_type, false);
  LUASCRIPT_CHECK_ARG_NIL(L, ptile, 3, Tile, false);
 
  return can_exist_at_tile(&(wld.map), punit_type, ptile);
}
 
const char *api_methods_unit_type_rule_name(lua_State *L,
                                            Unit_Type *punit_type)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, punit_type, nullptr);
 
  return utype_rule_name(punit_type);
}
 
const char *api_methods_unit_type_name_translation(lua_State *L,
                                                   Unit_Type *punit_type)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
  LUASCRIPT_CHECK_SELF(L, punit_type, nullptr);
 
  return utype_name_translation(punit_type);
}
 
Unit *api_methods_unit_list_link_data(lua_State *L, Unit_List_Link *ul_link)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
 
  return unit_list_link_data(ul_link);
}
 
Unit_List_Link *api_methods_unit_list_next_link(lua_State *L,
                                                Unit_List_Link *ul_link)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
 
  return unit_list_link_next(ul_link);
}
 
City *api_methods_city_list_link_data(lua_State *L, City_List_Link *cl_link)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
 
  return city_list_link_data(cl_link);
}
 
City_List_Link *api_methods_city_list_next_link(lua_State *L,
                                                City_List_Link *cl_link)
{
  LUASCRIPT_CHECK_STATE(L, nullptr);
 
  return city_list_link_next(cl_link);
}