118 #include <functional>
136 #define DBG_LUA LOG_STREAM(debug, log_scripting_lua)
137 #define LOG_LUA LOG_STREAM(info, log_scripting_lua)
138 #define WRN_LUA LOG_STREAM(warn, log_scripting_lua)
139 #define ERR_LUA LOG_STREAM(err, log_scripting_lua)
142 #define ERR_WML LOG_STREAM(err, log_wml)
150 template <member_callback method>
152 return ((lua_kernel_base::get_lua_kernel<game_lua_kernel>(L)).*method)(L);
158 template <member_callback2 method,
bool b>
160 return ((lua_kernel_base::get_lua_kernel<game_lua_kernel>(L)).*method)(L,
b);
210 if(!sides.
empty()) {
WRN_LUA <<
"ignoring duplicate side filter information (inline side=)"; }
212 return filter.get_teams();
216 return filter.get_teams();
223 struct queued_event_context
226 std::stack<qe const *> & stack_;
228 queued_event_context(qe
const *new_qe, std::stack<qe const*> & stack)
234 ~queued_event_context()
249 lua_pushinteger(L, disp->viewing_team().side());
250 lua_pushboolean(L, disp->show_everything());
268 anim.~unit_animator();
277 std::string which = luaL_checkstring(L, 3);
279 std::string hits_str = luaL_checkstring(L, 4);
289 if(lua_istable(L, 5)) {
290 lua_getfield(L, 5,
"target");
293 return luaL_argerror(L, 5,
"target location must be different from animated unit's location");
295 return luaL_argerror(L, 5,
"target location must be adjacent to the animated unit");
300 if(!lua_isnoneornil(L, -1)) {
306 lua_getfield(L, 5,
"value");
307 if(lua_isnumber(L, -1)) {
308 v1 = lua_tointeger(L, -1);
309 }
else if(lua_istable(L, -1)) {
310 lua_rawgeti(L, -1, 1);
311 v1 = lua_tointeger(L, -1);
313 lua_rawgeti(L, -1, 2);
314 v2 = lua_tointeger(L, -1);
316 }
else if(!lua_isnoneornil(L, -1)) {
317 return luaW_type_error(L, 5,
"value",
"number or array of two numbers");
321 lua_getfield(L, 5,
"with_bars");
322 if(lua_isboolean(L, -1)) {
324 }
else if(!lua_isnoneornil(L, -1)) {
325 return luaW_type_error(L, 5,
"with_bars", lua_typename(L, LUA_TBOOLEAN));
329 lua_getfield(L, 5,
"text");
330 if(lua_isstring(L, -1)) {
331 text = lua_tostring(L, -1);
334 }
else if(!lua_isnoneornil(L, -1)) {
339 lua_getfield(L, 5,
"color");
340 if(lua_istable(L, -1) && lua_rawlen(L, -1) == 3) {
341 int idx = lua_absindex(L, -1);
342 lua_rawgeti(L, idx, 1);
343 lua_rawgeti(L, idx, 2);
344 lua_rawgeti(L, idx, 3);
345 color =
color_t(lua_tointeger(L, -3), lua_tointeger(L, -2), lua_tointeger(L, -1));
347 }
else if(!lua_isnoneornil(L, -1)) {
352 lua_getfield(L, 5,
"primary");
354 if(!primary && !lua_isnoneornil(L, -1)) {
359 lua_getfield(L, 5,
"secondary");
361 if(!secondary && !lua_isnoneornil(L, -1)) {
365 }
else if(!lua_isnoneornil(L, 5)) {
369 anim.
add_animation(up, which, u.
get_location(), dest, v1, bars, text, color, hits, primary, secondary, v2);
397 const char* m = lua_tostring(L, 2);
405 luaL_Reg metafuncs[] {
409 {
"run", &dispatch<&game_lua_kernel::impl_run_animation>},
413 luaL_setfuncs(L, metafuncs, 0);
414 lua_pushstring(L,
"__metatable");
417 lua_setmetatable(L, -2);
427 name = cfg[
"name"].str();
430 name = luaL_optstring(L, 1,
"");
448 if(lua_isstring(L, 1) && !lua_isnumber(L, 1)) {
449 std::string
id = luaL_checkstring(L, 1);
459 return luaL_argerror(L, 1,
"expected string or location");
463 if (!ui.
valid())
return 0;
484 if (!ui.
valid())
return 0;
502 std::vector<const unit*>
units;
506 return luaL_argerror(L, 2,
"unit not found");
509 }
else if(!lua_isnoneornil(L, 2)) {
513 return luaL_argerror(L, 2,
"invalid location");
528 lua_rawseti(L, 1,
i);
548 lua_pushboolean(L,
true);
554 WRN_LUA <<
"wesnoth.units.matches called with a secondary unit (3rd argument), ";
555 WRN_LUA <<
"but unit to match was on recall list. ";
556 WRN_LUA <<
"Thus the 3rd argument is ignored.";
563 return luaL_argerror(L, 3,
"unit not found");
603 t.save_id_or_number(),
t.recall_list().find_index(u->id()));
608 lua_rawseti(L, 1,
i);
627 char const *m = luaL_checkstring(L, 1);
644 if(
data.has_child(
"primary_attack")) {
645 data.add_child(
"first",
data.mandatory_child(
"primary_attack"));
646 data.remove_children(
"primary_attack");
648 if(
data.has_child(
"secondary_attack")) {
649 data.add_child(
"second",
data.mandatory_child(
"secondary_attack"));
650 data.remove_children(
"secondary_attack");
661 lua_pushboolean(L,
b);
679 char const *m = luaL_checkstring(L, 1);
684 lua_pushboolean(L,
b);
696 char const *m = luaL_checkstring(L, 1);
708 const std::string m = luaL_checkstring(L, 1);
709 if(m.empty())
return luaL_argerror(L, 1,
"empty variable name");
710 if (lua_isnoneornil(L, 2)) {
723 cfg[
"side"] =
teams().size() + 1;
738 std::string ids(luaL_checkstring(L, 1));
741 WRN_LUA <<
"[clear_menu_item] has been given an empty id=, ignoring";
758 if(lua_istable(L, 2)) {
770 return luaL_argerror(L, 2,
"expected list of locations");
789 if(lua_istable(L, 2)) {
817 if(!
map().on_board(
loc))
return luaL_argerror(L, 1,
"not on board");
831 unsigned side_1, side_2;
835 side_1 = luaL_checkinteger(L, 1);
840 side_2 = luaL_checkinteger(L, 2);
843 lua_pushboolean(L,
board().get_team(side_1).is_enemy(side_2));
877 lua_pushstring(L, tod.
id.c_str());
878 lua_setfield(L, -2,
"id");
880 lua_setfield(L, -2,
"lawful_bonus");
882 lua_setfield(L, -2,
"bonus_modified");
883 lua_pushstring(L, tod.
image.c_str());
884 lua_setfield(L, -2,
"image");
886 lua_setfield(L, -2,
"name");
887 lua_pushstring(L, tod.
sounds.c_str());
888 lua_setfield(L, -2,
"sound");
890 lua_setfield(L, -2,
"mask");
892 lua_pushinteger(L, tod.
color.
r);
893 lua_setfield(L, -2,
"red");
894 lua_pushinteger(L, tod.
color.
g);
895 lua_setfield(L, -2,
"green");
896 lua_pushinteger(L, tod.
color.
b);
897 lua_setfield(L, -2,
"blue");
904 lua_newuserdatauv(L, 0, 1);
905 lua_pushinteger(L, area_index);
906 lua_setiuservalue(L, -2, 1);
907 if(luaL_newmetatable(L,
"schedule")) {
908 static luaL_Reg
const schedule_meta[] {
909 {
"__index", &dispatch<&game_lua_kernel::impl_schedule_get>},
910 {
"__newindex", &dispatch<&game_lua_kernel::impl_schedule_set>},
911 {
"__dir", &dispatch<&game_lua_kernel::impl_schedule_dir>},
912 {
"__len", &dispatch<&game_lua_kernel::impl_schedule_len>},
915 luaL_setfuncs(L, schedule_meta, 0);
917 lua_setmetatable(L, -2);
922 int save_top = lua_gettop(L);
923 luaL_checkudata(L, idx,
"schedule");
924 lua_getiuservalue(L, idx, 1);
925 int i = luaL_checkinteger(L, -1);
926 lua_settop(L, save_top);
936 #define SCHEDULE_GETTER(name, type) LATTR_GETTER(name, type, schedule_tag, sched)
937 #define SCHEDULE_SETTER(name, type) LATTR_SETTER(name, type, schedule_tag, sched)
938 #define SCHEDULE_VALID(name) LATTR_VALID(name, schedule_tag, sched)
942 inline static auto metatable =
"schedule";
944 schedule_tag sched{lua_kernel_base::get_lua_kernel<game_lua_kernel>(L)};
953 if(lua_isnumber(L, 2)) {
955 int i = lua_tointeger(L, 2) - 1;
956 if(i < 0 || i >=
static_cast<int>(times.size())) {
957 return luaL_argerror(L, 2,
"invalid time of day index");
969 lua_pushinteger(L, times.size());
976 if(lua_isnumber(L, 2)) {
978 int i = lua_tointeger(L, 2) - 1;
979 if(i < 0 || i >=
static_cast<int>(times.size())) {
980 return luaL_argerror(L, 2,
"invalid time of day index");
999 if(sched.area_index >= 0) {
1000 return sched.tod_man().get_area_time_of_day(sched.area_index).id;
1002 return sched.tod_man().get_time_of_day().id;
1006 const auto& times = sched.area_index < 0 ? sched.tod_man().times() : sched.tod_man().times(sched.area_index);
1007 auto iter = std::find_if(times.begin(), times.end(), [&value](
const time_of_day& tod) {
1008 return tod.id == value;
1010 if(iter == times.end()) {
1011 std::ostringstream
err;
1012 err <<
"invalid time of day ID for ";
1013 if(sched.area_index < 0) {
1014 err <<
"global schedule";
1016 const std::string&
id = sched.tod_man().get_area_id(sched.area_index);
1018 const auto& hexes = sched.tod_man().get_area_by_index(sched.area_index);
1020 err <<
"anonymous empty time area";
1022 err <<
"anonymous time area at (" << hexes.begin()->wml_x() <<
',' << hexes.begin()->wml_y() <<
")";
1025 err <<
"time area with id=" <<
id;
1031 int n = std::distance(times.begin(), iter);
1032 if(sched.area_index < 0) {
1033 sched.tod_man().set_current_time(
n);
1035 sched.tod_man().set_current_time(
n, sched.area_index);
1040 return sched.area_index < 0;
1044 if(sched.area_index >= 0)
return utils::nullopt;
1045 return sched.tod_man().get_max_liminal_bonus();
1049 if(sched.area_index >= 0) {
1050 throw luaL_error(L,
"liminal_bonus can only be set on the global schedule");
1053 sched.tod_man().set_max_liminal_bonus(*value);
1055 sched.tod_man().reset_max_liminal_bonus();
1060 return sched.area_index >= 0;
1064 if(sched.area_index < 0)
return utils::nullopt;
1065 return sched.tod_man().get_area_id(sched.area_index);
1069 if(sched.area_index < 0) {
1070 throw luaL_error(L,
"can't set id of global schedule");
1072 sched.tod_man().set_area_id(sched.area_index, value);
1076 return sched.area_index >= 0;
1080 if(sched.area_index < 0)
return utils::nullopt;
1081 return sched.tod_man().get_area_by_index(sched.area_index);
1085 if(sched.area_index < 0) {
1086 throw luaL_error(L,
"can't set hexes of global schedule");
1088 sched.tod_man().replace_area_locations(sched.area_index, value);
1099 char const *m = luaL_checkstring(L, 2);
1105 lua_pushstring(L,
info.id().c_str());
1106 lua_setfield(L, -2,
"id");
1108 lua_setfield(L, -2,
"name");
1110 lua_setfield(L, -2,
"editor_name");
1112 lua_setfield(L, -2,
"description");
1114 lua_setfield(L, -2,
"icon");
1116 lua_setfield(L, -2,
"editor_image");
1117 lua_pushinteger(L,
info.light_bonus(0));
1118 lua_setfield(L, -2,
"light");
1119 lua_pushboolean(L,
info.is_village());
1120 lua_setfield(L, -2,
"village");
1121 lua_pushboolean(L,
info.is_castle());
1122 lua_setfield(L, -2,
"castle");
1123 lua_pushboolean(L,
info.is_keep());
1124 lua_setfield(L, -2,
"keep");
1125 lua_pushinteger(L,
info.gives_healing());
1126 lua_setfield(L, -2,
"healing");
1131 for (
const auto& terrain :
info.mvt_type()) {
1133 if (!base.
id().empty()) {
1135 lua_rawseti(L, -2, idx++);
1138 lua_setfield(L, -2,
"mvt_alias");
1143 for (
const auto& terrain :
info.def_type()) {
1145 if (!base.
id().empty()) {
1147 lua_rawseti(L, -2, idx++);
1150 lua_setfield(L, -2,
"def_alias");
1162 std::vector<std::string> terrains;
1163 terrains.reserve(codes.size());
1164 for(
auto code : codes) {
1177 template<
bool cons
ider_illuminates>
1185 return luaL_argerror(L, 1,
"coordinates are not on board");
1187 }
else if(lua_isstring(L, 1)) {
1190 return luaL_error(L,
"invalid or empty time_area ID");
1193 loc = *area.begin();
1194 }
else if(!lua_isnil(L, 1)) {
1197 return luaL_error(L,
"empty time_area");
1200 loc = *area.begin();
1203 if(lua_isnumber(L, 2)) {
1204 for_turn = luaL_checkinteger(L, 2);
1206 if(for_turn < 1 || (number_of_turns != -1 && for_turn > number_of_turns)) {
1207 return luaL_argerror(L, 2,
"turn number out of range");
1232 if (!side)
return 0;
1233 lua_pushinteger(L, side);
1250 const int new_side_num = lua_isnoneornil(L, 2) ? 0 : luaL_checkinteger(L, 2);
1252 team* old_side =
nullptr;
1253 team* new_side =
nullptr;
1255 if(old_side_num == new_side_num) {
1261 }
catch(
const std::out_of_range&) {
1268 }
catch(
const std::out_of_range&) {
1274 if(new_side &&
board().team_is_defeated(*new_side)) {
1340 std::string m = luaL_checkstring(L, 1);
1346 return luaL_argerror(L, 1, (
"Cannot find resource with id '" + m +
"'").c_str());
1358 std::string m = luaL_checkstring(L, 1);
1364 return luaL_argerror(L, 1, (
"Cannot find era with id '" + m +
"'").c_str());
1379 #define GAME_CONFIG_SIMPLE_SETTER(name) \
1380 GAME_CONFIG_SETTER(#name, decltype(game_config::name), game_lua_kernel) { \
1382 game_config::name = value; \
1388 return k2.pc().gamestate().do_healing_;
1393 k2.pc().gamestate().do_healing_ = value;}
1403 k2.disp()->set_theme(value);
1406 using traits_map = std::map<std::string, config>;
1409 std::map<std::string, config> result;
1414 result.emplace(trait[
"id"], trait);
1430 static config find_addon(
const std::string&
type,
const std::string&
id)
1439 const char* m = luaL_checkstring(L, 2);
1457 struct end_level_committer {
1459 ~end_level_committer() {
1460 pc_.set_end_level_data(data_);
1471 const char* m = luaL_checkstring(L, 2);
1487 data->~end_level_data();
1493 void*
p = lua_touserdata(L, lua_upvalueindex(1));
1495 if(lua_type(L, 2) == LUA_TNUMBER) {
1498 size_t i = luaL_checkinteger(L, 2);
1500 lua_createtable(L, 2, 0);
1501 lua_pushstring(L,
"options");
1509 auto iter =
settings.addons.begin();
1510 std::advance(iter,
i);
1512 iter->second.write(cfg);
1513 cfg[
"id"] = iter->first;
1515 lua_createtable(L, 2, 0);
1516 lua_pushstring(L,
"addon");
1524 char const *m = luaL_checkstring(L, 2);
1552 if(strcmp(m,
"savegame") == 0) {
1554 if(
savegame == saved_game_mode::type::no) {
1555 lua_pushboolean(L,
false);
1561 if(strcmp(m,
"side_players") == 0) {
1565 if(strcmp(m,
"addons") == 0) {
1566 for(
const auto& [
id, addon] :
settings.addons) {
1567 lua_createtable(L, 0, 4);
1569 lua_setfield(L, -2,
"id");
1571 lua_setfield(L, -2,
"name");
1572 lua_pushboolean(L, addon.required);
1573 lua_setfield(L, -2,
"required");
1574 if(addon.min_version) {
1576 lua_push(L, addon.min_version->str());
1578 lua_setfield(L, -2,
"min_version");
1584 lua_setfield(L, -2,
"version");
1586 lua_createtable(L, addon.content.size(), 0);
1587 for(
const auto& content : addon.content) {
1588 lua_createtable(L, 0, 3);
1590 lua_setfield(L, -2,
"id");
1592 lua_setfield(L, -2,
"name");
1594 lua_setfield(L, -2,
"type");
1595 lua_seti(L, -2, lua_rawlen(L, -2) + 1);
1597 lua_setfield(L, -2,
"content");
1613 void*
p = lua_touserdata(L, lua_upvalueindex(1));
1615 lua_pushinteger(L,
settings.addons.size() + 1);
1626 auto end_level_set()
const {
return &dispatch<&game_lua_kernel::impl_end_level_data_set>; }
1628 #define SCENARIO_GETTER(name, type) LATTR_GETTER(name, type, scenario_tag, k)
1629 #define SCENARIO_SETTER(name, type) LATTR_SETTER(name, type, scenario_tag, k)
1630 #define SCENARIO_VALID(name) LATTR_VALID(name, scenario_tag, k)
1634 inline static auto metatable =
"scenario";
1636 return lua_kernel_base::get_lua_kernel<game_lua_kernel>(L);
1642 return k.tod_man().number_of_turns();
1646 k.tod_man().set_number_of_turns_by_wml(value);
1650 return k.gamedata().next_scenario();
1654 k.gamedata().set_next_scenario(value);
1658 return k.gamedata().get_id();
1662 return k.pc().get_scenario_name();
1666 return k.gamedata().get_defeat_music();
1670 k.gamedata().set_defeat_music(value);
1674 return k.gamedata().get_victory_music();
1678 k.gamedata().set_victory_music(value);
1683 for(
const std::string& rsrc :
utils::split(k.pc().get_loaded_resources())) {
1684 resources.push_back(find_addon(
"resource", rsrc));
1694 return k.cls().difficulty;
1698 return k.cls().end_credits;
1702 k.cls().end_credits = value;
1706 return k.cls().end_text;
1710 k.cls().end_text = value;
1714 return k.cls().end_text_duration.count();
1718 k.cls().end_text_duration = std::chrono::milliseconds{value};
1722 return !k.cls().campaign.empty();
1726 if(k.cls().campaign.empty())
return utils::nullopt;
1727 return find_addon(
"campaign", k.cls().campaign);
1731 std::vector<config> mods;
1732 for(
const std::string& mod : k.cls().active_mods) {
1733 mods.push_back(find_addon(
"modification", mod));
1739 if (!k.pc().is_regular_game_end()) {
1743 auto data = k.pc().get_end_level_data();
1745 if(luaL_newmetatable(L,
"end level data")) {
1746 static luaL_Reg
const callbacks[] {
1748 {
"__newindex", k.end_level_set()},
1750 {
nullptr,
nullptr }
1752 luaL_setfuncs(L, callbacks, 0);
1754 lua_setmetatable(L, -2);
1761 data.proceed_to_next_level = value[
"proceed_to_next_level"].to_bool(
true);
1762 data.transient.carryover_report = value[
"carryover_report"].to_bool(
true);
1763 data.prescenario_save = value[
"save"].to_bool(
true);
1764 data.replay_save = value[
"replay_save"].to_bool(
true);
1765 data.transient.linger_mode = value[
"linger_mode"].to_bool(
true) && !k.ref.teams().empty();
1766 data.transient.reveal_map = value[
"reveal_map"].to_bool(k.pc().reveal_map_default());
1767 data.is_victory = value[
"result"] == level_result::victory;
1768 data.test_result = value[
"test_result"].str();
1769 k.pc().set_end_level_data(
data);
1773 return k.cls().is_multiplayer();
1777 if(!k.cls().is_multiplayer()) {
1781 lua_newuserdatauv(L, 0, 0);
1782 if(luaL_newmetatable(L,
"mp settings")) {
1783 lua_pushlightuserdata(L, &k.pc());
1785 lua_setfield(L, -2,
"__index");
1786 lua_pushlightuserdata(L, &k.pc());
1788 lua_setfield(L, -2,
"__len");
1789 lua_pushstring(L,
"mp settings");
1790 lua_setfield(L, -2,
"__metatable");
1792 lua_setmetatable(L, -2);
1797 return k.cls().is_multiplayer();
1801 if(!k.cls().is_multiplayer())
return utils::nullopt;
1802 return find_addon(
"era", k.cls().era_id);
1814 DBG_LUA <<
"impl_scenario_get";
1826 DBG_LUA <<
"impl_scenario_set";
1835 DBG_LUA <<
"impl_scenario_dir";
1852 return "local_choice";
1871 #define CURRENT_GETTER(name, type) LATTR_GETTER(name, type, current_tag, k)
1875 inline static auto metatable =
"current";
1877 return lua_kernel_base::get_lua_kernel<game_lua_kernel>(L);
1883 return k.pc().current_side();
1887 return k.pc().turn();
1910 return k.pc().is_replay();
1916 cfg[
"name"] = ev.
name;
1923 cfg.
add_child(
"second_weapon", *weapon);
1928 cfg[
"damage_inflicted"] = di;
1974 if (lua_isnone(L, 2)) {
1980 LOG_LUA <<
"Script says: \"" << m <<
"\"";
1989 double factor = luaL_checknumber(L, 1);
2016 if (!lua_isnoneornil(L, 1)) {
2017 int max = 2 *
teams().size();
2018 int npn = luaL_checkinteger(L, 1);
2019 if (npn <= 0 || npn > max) {
2020 return luaL_argerror(L, 1,
"side number out of range");
2037 lua_pushboolean(L,
b);
2055 const unit* u =
nullptr;
2056 int viewing_side = 0;
2058 if (lua_isuserdata(L, arg))
2062 viewing_side = u->
side();
2071 viewing_side = u->
side();
2079 return luaL_argerror(L, 1,
"invalid location");
2081 return luaL_argerror(L, arg,
"invalid location");
2085 bool ignore_units =
false, see_all =
false, ignore_teleport =
false;
2086 double stop_at = 10000;
2087 std::unique_ptr<pathfind::cost_calculator> calc;
2089 if (lua_istable(L, arg))
2091 ignore_units = luaW_table_get_def<bool>(L, arg,
"ignore_units",
false);
2092 see_all = luaW_table_get_def<bool>(L, arg,
"ignore_visibility",
false);
2093 ignore_teleport = luaW_table_get_def<bool>(L, arg,
"ignore_teleport",
false);
2095 stop_at = luaW_table_get_def<double>(L, arg,
"max_cost", stop_at);
2098 lua_pushstring(L,
"viewing_side");
2100 if (!lua_isnil(L, -1)) {
2101 int i = luaL_checkinteger(L, -1);
2102 if (
i >= 1 &&
i <=
static_cast<int>(
teams().
size())) viewing_side =
i;
2106 if(u) see_all =
true;
2107 deprecated_message(
"wesnoth.paths.find_path with viewing_side=0 (or an invalid side)",
DEP_LEVEL::FOR_REMOVAL, {1, 17, 0},
"To consider fogged and hidden units, use ignore_visibility=true instead.");
2112 lua_pushstring(L,
"calculate");
2114 if(lua_isfunction(L, -1)) {
2119 else if (lua_isfunction(L, arg))
2127 if(!ignore_teleport) {
2128 if(viewing_side == 0) {
2129 lua_warning(L,
"wesnoth.paths.find_path: ignore_teleport=false requires a valid viewing_side; continuing with ignore_teleport=true",
false);
2130 ignore_teleport =
true;
2138 return luaL_argerror(L, 1,
"unit not found OR custom cost function not provided");
2142 teams(),
map, ignore_units,
false, see_all));
2146 &teleport_locations);
2148 int nb = res.
steps.size();
2149 lua_createtable(L, nb, 0);
2150 for (
int i = 0;
i < nb; ++
i)
2153 lua_rawseti(L, -2,
i + 1);
2169 const unit* u =
nullptr;
2171 if (lua_isuserdata(L, arg))
2181 return luaL_argerror(L, 1,
"unit not found");
2186 int viewing_side = u->
side();
2187 bool ignore_units =
false, see_all =
false, ignore_teleport =
false;
2188 int additional_turns = 0;
2190 if (lua_istable(L, arg))
2192 ignore_units = luaW_table_get_def<bool>(L, arg,
"ignore_units",
false);
2193 see_all = luaW_table_get_def<bool>(L, arg,
"ignore_visibility",
false);
2194 ignore_teleport = luaW_table_get_def<bool>(L, arg,
"ignore_teleport",
false);
2195 additional_turns = luaW_table_get_def<int>(L, arg,
"max_cost", additional_turns);
2197 lua_pushstring(L,
"viewing_side");
2199 if (!lua_isnil(L, -1)) {
2200 int i = luaL_checkinteger(L, -1);
2201 if (
i >= 1 &&
i <=
static_cast<int>(
teams().
size())) viewing_side =
i;
2205 if(u) see_all =
true;
2215 viewing_team, additional_turns, see_all, ignore_units);
2218 lua_createtable(L, nb, 0);
2219 for (
int i = 0;
i < nb; ++
i)
2223 lua_pushinteger(L,
s.curr.wml_x());
2224 lua_rawseti(L, -2, 1);
2225 lua_pushinteger(L,
s.curr.wml_y());
2226 lua_rawseti(L, -2, 2);
2227 lua_pushinteger(L,
s.move_left);
2228 lua_rawseti(L, -2, 3);
2229 lua_rawseti(L, -2,
i + 1);
2244 const unit* u =
nullptr;
2246 if (lua_isuserdata(L, arg))
2256 return luaL_argerror(L, 1,
"unit not found");
2263 return luaL_error(L,
"wesnoth.find_vision_range: requires a valid unit");
2266 std::map<map_location, int> jamming_map;
2273 lua_pushinteger(L,
d.curr.wml_x());
2274 lua_rawseti(L, -2, 1);
2275 lua_pushinteger(L,
d.curr.wml_y());
2276 lua_rawseti(L, -2, 2);
2277 lua_pushinteger(L,
d.move_left);
2278 lua_rawseti(L, -2, 3);
2279 lua_rawseti(L, -2, lua_rawlen(L, -2) + 1);
2281 for(
const auto&
e : res.
edges) {
2283 lua_pushinteger(L,
e.wml_x());
2284 lua_rawseti(L, -2, 1);
2285 lua_pushinteger(L,
e.wml_y());
2286 lua_rawseti(L, -2, 2);
2287 lua_pushinteger(L, -1);
2288 lua_rawseti(L, -2, 3);
2289 lua_rawseti(L, -2, lua_rawlen(L, -2) + 1);
2294 template<
typename T>
2297 for (
int i = 1, i_end = lua_rawlen(L, arg);
i <= i_end; ++
i)
2300 lua_rawgeti(L, arg,
i);
2301 int entry = lua_gettop(L);
2302 if (!lua_istable(L, entry)) {
2310 lua_rawgeti(L, entry, 3);
2311 if (!lua_isnumber(L, -1)) {
2312 lua_getfield(L, entry,
"side");
2313 if (!lua_isnumber(L, -1)) {
2317 int side = lua_tointeger(L, -1);
2319 lua_rawgeti(L, entry, 4);
2320 if (!lua_isstring(L, -1)) {
2321 lua_getfield(L, entry,
"type");
2322 if (!lua_isstring(L, -1)) {
2326 std::string
unit_type = lua_tostring(L, -1);
2330 lua_settop(L, entry - 1);
2334 return luaL_argerror(L, arg,
"unit type table malformed - each entry should be either array of 4 elements or table with keys x, y, side, type");
2352 std::vector<const ::unit*> real_units;
2353 typedef std::vector<std::tuple<map_location, int, std::string>> unit_type_vector;
2359 real_units.push_back(
unit);
2364 if(match->get_location().valid()) {
2365 real_units.push_back(match);
2375 real_units.push_back(&(*ui));
2380 if (lua_istable(L, arg))
2388 return luaL_argerror(L, 1,
"unit(s) not found");
2391 int viewing_side = 0;
2392 bool ignore_units =
true, see_all =
true, ignore_teleport =
false,
debug =
false, use_max_moves =
false;
2394 if (lua_istable(L, arg))
2396 lua_pushstring(L,
"ignore_units");
2398 if (!lua_isnil(L, -1))
2404 lua_pushstring(L,
"ignore_teleport");
2406 if (!lua_isnil(L, -1))
2412 lua_pushstring(L,
"viewing_side");
2414 if (!lua_isnil(L, -1))
2416 int i = luaL_checkinteger(L, -1);
2417 if (
i >= 1 &&
i <=
static_cast<int>(
teams().
size()))
2424 lua_pushstring(L,
"debug");
2426 if (!lua_isnil(L, -1))
2432 lua_pushstring(L,
"use_max_moves");
2434 if (!lua_isnil(L, -1))
2456 const team& viewing_team = viewing_side
2461 ignore_units, !ignore_teleport, viewing_team, see_all, ignore_units);
2463 for (const ::unit*
const u : real_units)
2465 cost_map.
add_unit(*u, use_max_moves);
2467 for (
const unit_type_vector::value_type& fu :
fake_units)
2470 cost_map.
add_unit(std::get<0>(fu), ut, std::get<1>(fu));
2479 std::stringstream
s;
2496 lua_rawseti(L, -2, 1);
2499 lua_rawseti(L, -2, 2);
2502 lua_rawseti(L, -2, 3);
2505 lua_rawseti(L, -2, 4);
2507 lua_rawseti(L, -2, counter);
2517 return reinterpret_cast<int*
>(luaL_checkudata(L, idx,
labelKey));
2522 const char* m = luaL_checkstring(L, 2);
2530 std::chrono::milliseconds fade{luaL_optinteger(L, 2, -1)};
2568 double width_ratio = 0;
2570 int lifetime = 2'000, fadeout = 100;
2576 if(lua_istable(L, 2)) {
2578 size = luaL_checkinteger(L, -1);
2582 width = lua_tointegerx(L, -1, &found_number);
2586 if(!value.empty() && value.back() ==
'%') {
2587 value.remove_suffix(1);
2588 width_ratio =
std::stoi(std::string(value)) / 100.0;
2589 }
else throw std::invalid_argument(value.data());
2590 }
catch(std::invalid_argument&) {
2591 return luaL_argerror(L, -1,
"max_width should be integer or percentage");
2597 if(lua_isstring(L, -1)) {
2600 auto vec = lua_check<std::vector<int>>(L, -1);
2601 if(vec.size() != 3) {
2602 int idx = lua_absindex(L, -1);
2604 color.r = luaL_checkinteger(L, -3);
2605 color.g = luaL_checkinteger(L, -2);
2606 color.b = luaL_checkinteger(L, -1);
2608 return luaL_error(L,
"floating label text color should be a hex string, an array of 3 integers, or a table with r,g,b keys");
2618 if(lua_isstring(L, -1)) {
2621 auto vec = lua_check<std::vector<int>>(L, -1);
2622 if(vec.size() != 3) {
2623 int idx = lua_absindex(L, -1);
2625 bgcolor.r = luaL_checkinteger(L, -3);
2626 bgcolor.g = luaL_checkinteger(L, -2);
2627 bgcolor.b = luaL_checkinteger(L, -1);
2629 return luaL_error(L,
"floating label background color should be a hex string, an array of 3 integers, or a table with r,g,b keys");
2639 bgcolor.a = luaL_checkinteger(L, -1);
2644 lifetime = lua_tointegerx(L, -1, &found_number);
2647 if(value ==
"unlimited") {
2650 return luaL_argerror(L, -1,
"duration should be integer or 'unlimited'");
2655 fadeout = lua_tointeger(L, -1);
2661 static const char* options[] = {
"left",
"center",
"right"};
2662 alignment =
font::ALIGN(luaL_checkoption(L, -1,
nullptr, options));
2665 static const char* options[] = {
"top",
"center",
"bottom"};
2666 vertical_alignment =
font::ALIGN(luaL_checkoption(L, -1,
nullptr, options));
2678 int handle_idx = lua_gettop(L);
2685 if(width_ratio > 0) {
2686 width =
static_cast<int>(std::round(
rect.w * width_ratio));
2700 switch(vertical_alignment) {
2716 using std::chrono::milliseconds;
2723 flabel.
set_lifetime(milliseconds{lifetime}, milliseconds{fadeout});
2734 lua_settop(L, handle_idx);
2735 if(luaL_newmetatable(L,
labelKey)) {
2737 static const luaL_Reg methods[] = {
2738 {
"remove", &dispatch<&game_lua_kernel::intf_remove_floating_label>},
2739 {
"move", &dispatch<&game_lua_kernel::intf_move_floating_label>},
2740 {
"replace", &dispatch2<&game_lua_kernel::intf_set_floating_label, false>},
2742 {
nullptr,
nullptr }
2744 luaL_setfuncs(L, methods, 0);
2747 lua_setmetatable(L, handle_idx);
2748 lua_settop(L, handle_idx);
2773 return luaL_error(L,
"Attempted to move a unit while the map is locked");
2778 if (!
map().on_board(
loc)) {
2779 return luaL_argerror(L, 2,
"invalid location");
2790 if (!
map().on_board(
loc))
2791 return luaL_argerror(L, 1,
"invalid location");
2798 }
else if(!lua_isnoneornil(L, 1)) {
2799 const vconfig* vcfg =
nullptr;
2801 if (!
map().on_board(
loc)) {
2804 if (!
map().on_board(
loc))
2805 return luaL_argerror(L, 2,
"invalid location");
2811 u->set_location(
loc);
2813 u->anim_comp().reset_affect_adjacent(
units());
2831 return luaL_error(L,
"Attempted to remove a unit while the map is locked");
2839 if (!
map().on_board(
loc)) {
2840 return luaL_argerror(L, 1,
"invalid location");
2846 t.recall_list().erase_if_matches_id(u->
id());
2848 return luaL_argerror(L, 1,
"can't erase private units");
2851 if (!
map().on_board(
loc)) {
2852 return luaL_argerror(L, 1,
"invalid location");
2855 return luaL_argerror(L, 1,
"expected unit or location");
2871 return luaL_error(L,
"Attempted to move a unit while the map is locked");
2875 int side = lua_tointeger(L, 2);
2876 if (
static_cast<unsigned>(side) >
teams().
size()) side = 0;
2880 u = lu->get_shared();
2881 if(lu->on_recall_list() && lu->on_recall_list() == side) {
2882 return luaL_argerror(L, 1,
"unit already on recall list");
2885 const vconfig* vcfg =
nullptr;
2897 std::size_t uid = u->underlying_id();
2898 t.recall_list().erase_by_underlying_id(uid);
2899 t.recall_list().add(u);
2904 u->anim_comp().clear_haloes();
2905 u->anim_comp().reset_affect_adjacent(
units());
2907 lu->lua_unit::~lua_unit();
2921 return luaL_error(L,
"Attempted to remove a unit while the map is locked");
2929 u->anim_comp().clear_haloes();
2930 u->anim_comp().reset_affect_adjacent(
units());
2931 }
else if (
int side = lu->on_recall_list()) {
2934 t.recall_list().erase_if_matches_id(u->id());
2940 lu->lua_unit::~lua_unit();
2956 if (!lua_isnoneornil(L, 2)) {
2960 const vconfig* vcfg =
nullptr;
2963 if (u->get_location().valid()) {
2964 u->anim_comp().reset_affect_adjacent(
units());
2971 if (!res.
valid())
return 0;
2972 lua_pushinteger(L, res.
wml_x());
2973 lua_pushinteger(L, res.
wml_y());
2989 if (!lua_isnoneornil(L, 3)) {
3012 void reset_affect_adjacent(
const unit&
unit)
3025 const vconfig* vcfg =
nullptr;
3029 if (u->get_location().valid()) {
3030 reset_affect_adjacent(*u);
3058 char const *m = luaL_checkstring(L, 2);
3062 if(lua_isboolean(L, 3)) {
3064 if(!lua_isnoneornil(L, 4)) {
3067 }
else if(!lua_isnoneornil(L, 3)) {
3088 }
else if(lua_isstring(L, 2)) {
3089 char const *m = luaL_checkstring(L, 2);
3109 }
else if(lua_isstring(L, 2)) {
3110 char const *m = luaL_checkstring(L, 2);
3130 }
else if(lua_isstring(L, 2)) {
3131 char const *m = luaL_checkstring(L, 2);
3151 }
else if(lua_isstring(L, 2)) {
3152 char const *m = luaL_checkstring(L, 2);
3168 char const *m = luaL_checkstring(L, 2);
3182 char const *m = luaL_checkstring(L, 2);
3184 if (!utp)
return luaL_argerror(L, 2,
"unknown unit type");
3185 if(lua_isstring(L, 3)) {
3186 const std::string& m2 = lua_tostring(L, 3);
3187 if(!utp->
has_variation(m2))
return luaL_argerror(L, 2,
"unknown unit variation");
3192 reset_affect_adjacent(u);
3204 lua_createtable(L, 0, 4);
3206 lua_setfield(L, -2,
"poisoned");
3207 lua_pushnumber(L, cmb.
slowed);
3208 lua_setfield(L, -2,
"slowed");
3210 lua_setfield(L, -2,
"untouched");
3212 lua_setfield(L, -2,
"average_hp");
3213 lua_createtable(L,
n, 0);
3214 for (
int i = 0;
i <
n; ++
i) {
3216 lua_rawseti(L, -2,
i);
3218 lua_setfield(L, -2,
"hp_chance");
3227 lua_createtable(L, 0, 16);
3230 lua_setfield(L, -2,
"num_blows");
3231 lua_pushnumber(L, bcustats.
damage);
3232 lua_setfield(L, -2,
"damage");
3234 lua_setfield(L, -2,
"chance_to_hit");
3235 lua_pushboolean(L, bcustats.
poisons);
3236 lua_setfield(L, -2,
"poisons");
3237 lua_pushboolean(L, bcustats.
slows);
3238 lua_setfield(L, -2,
"slows");
3240 lua_setfield(L, -2,
"petrifies");
3241 lua_pushboolean(L, bcustats.
plagues);
3242 lua_setfield(L, -2,
"plagues");
3244 lua_setfield(L, -2,
"plague_type");
3245 lua_pushnumber(L, bcustats.
rounds);
3246 lua_setfield(L, -2,
"rounds");
3248 lua_setfield(L, -2,
"firststrike");
3249 lua_pushboolean(L, bcustats.
drains);
3250 lua_setfield(L, -2,
"drains");
3252 lua_setfield(L, -2,
"drain_constant");
3254 lua_setfield(L, -2,
"drain_percent");
3259 lua_setfield(L, -2,
"attack_num");
3261 lua_setfield(L, -2,
"number");
3263 if(bcustats.
weapon !=
nullptr)
3265 lua_pushstring(L, bcustats.
weapon->id().c_str());
3266 lua_setfield(L, -2,
"name");
3268 lua_setfield(L, -2,
"weapon");
3287 int arg_num = 1, att_w = -1, def_w = -1;
3291 if (lua_isnumber(L, arg_num)) {
3292 att_w = lua_tointeger(L, arg_num) - 1;
3293 if (att_w < 0 || att_w >=
static_cast<int>(att->attacks().size()))
3294 return luaL_argerror(L, arg_num,
"weapon index out of bounds");
3300 if (lua_isnumber(L, arg_num)) {
3301 def_w = lua_tointeger(L, arg_num) - 1;
3302 if (def_w < 0 || def_w >=
static_cast<int>(def->attacks().size()))
3303 return luaL_argerror(L, arg_num,
"weapon index out of bounds");
3308 def->get_location(), att_w, def_w, 0.0,
nullptr, att, def);
3325 char const *m = luaL_checkstring(L, 1);
3326 int repeats = luaL_optinteger(L, 2, 0);
3338 const char* content_for = luaL_checkstring(L, 1);
3339 const char*
id = luaL_checkstring(L, 2);
3342 if(group.content_for_ == content_for) {
3344 if(achieve.
id_ ==
id) {
3371 ERR_LUA <<
"Achievement " <<
id <<
" not found for achievement group " << content_for;
3377 ERR_LUA <<
"Achievement group " << content_for <<
" not found";
3389 const char* content_for = luaL_checkstring(L, 1);
3390 const char*
id = luaL_checkstring(L, 2);
3393 ERR_LUA <<
"Returning false for whether a player has completed an achievement due to being networked multiplayer.";
3394 lua_pushboolean(L,
false);
3410 const char* content_for = luaL_checkstring(L, 1);
3411 const char*
id = luaL_checkstring(L, 2);
3415 if(group.content_for_ == content_for) {
3416 for(
const auto& achieve : group.achievements_) {
3417 if(achieve.id_ ==
id) {
3419 cfg[
"id"] = achieve.id_;
3420 cfg[
"name"] = achieve.name_;
3421 cfg[
"name_completed"] = achieve.name_completed_;
3422 cfg[
"description"] = achieve.description_;
3423 cfg[
"description_completed"] = achieve.description_completed_;
3424 cfg[
"icon"] = achieve.icon_;
3425 cfg[
"icon_completed"] = achieve.icon_completed_;
3426 cfg[
"hidden"] = achieve.hidden_;
3427 cfg[
"achieved"] = achieve.achieved_;
3428 cfg[
"max_progress"] = achieve.max_progress_;
3429 cfg[
"current_progress"] = achieve.current_progress_;
3431 for(
const auto& sub_ach : achieve.sub_achievements_) {
3433 sub[
"id"] = sub_ach.id_;
3434 sub[
"description"] = sub_ach.description_;
3435 sub[
"icon"] = sub_ach.icon_;
3436 sub[
"achieved"] = sub_ach.achieved_;
3444 ERR_LUA <<
"Achievement " <<
id <<
" not found for achievement group " << content_for;
3450 ERR_LUA <<
"Achievement group " << content_for <<
" not found";
3466 const char* content_for = luaL_checkstring(L, 1);
3467 const char*
id = luaL_checkstring(L, 2);
3468 int amount = luaL_checkinteger(L, 3);
3469 int limit = luaL_optinteger(L, 4, 999999999);
3472 if(group.content_for_ == content_for) {
3474 if(achieve.
id_ ==
id) {
3477 ERR_LUA <<
"Attempted to progress achievement " <<
id <<
" for achievement group " << content_for <<
", is not a progressible achievement.";
3478 lua_pushinteger(L, -1);
3479 lua_pushinteger(L, -1);
3494 lua_pushinteger(L, progress);
3496 lua_pushinteger(L, -1);
3504 lua_push(L,
"Achievement " + std::string(
id) +
" not found for achievement group " + content_for);
3505 return lua_error(L);
3510 lua_push(L,
"Achievement group " + std::string(content_for) +
" not found");
3511 return lua_error(L);
3523 const char* content_for = luaL_checkstring(L, 1);
3524 const char*
id = luaL_checkstring(L, 2);
3525 const char* sub_id = luaL_checkstring(L, 3);
3528 ERR_LUA <<
"Returning false for whether a player has completed an achievement due to being networked multiplayer.";
3529 lua_pushboolean(L,
false);
3545 const char* content_for = luaL_checkstring(L, 1);
3546 const char*
id = luaL_checkstring(L, 2);
3547 const char* sub_id = luaL_checkstring(L, 3);
3550 if(group.content_for_ == content_for) {
3552 if(achieve.
id_ ==
id) {
3559 if(sub_ach.
id_ == sub_id) {
3577 lua_push(L,
"Sub-achievement " + std::string(
id) +
" not found for achievement" +
id +
" in achievement group " + content_for);
3578 return lua_error(L);
3582 lua_push(L,
"Achievement " + std::string(
id) +
" not found for achievement group " + content_for);
3583 return lua_error(L);
3588 lua_push(L,
"Achievement group " + std::string(content_for) +
" not found");
3589 return lua_error(L);
3625 if(lua_isnoneornil(L, 1)) {
3630 if(!
map().on_board(
loc))
return luaL_argerror(L, 1,
"not on board");
3631 bool highlight =
true;
3632 if(!lua_isnoneornil(L, 2))
3662 lua_pushboolean(L, skipping);
3673 if (!lua_isnone(L, 1)) {
3685 int user_choice_index;
3686 int random_choice_index;
3687 int ai_choice_index;
3689 lua_synchronize(lua_State *l,
const std::string& descr,
int user_index,
int random_index = 0,
int ai_index = 0)
3691 , user_choice_index(user_index)
3692 , random_choice_index(random_index)
3693 , ai_choice_index(ai_index != 0 ? ai_index : user_index)
3699 bool is_local_ai = lua_kernel_base::get_lua_kernel<game_lua_kernel>(L).board().get_team(side).is_local_ai();
3701 query_lua(side, is_local_ai ? ai_choice_index : user_choice_index, cfg);
3708 if(random_choice_index != 0 && lua_isfunction(L, random_choice_index)) {
3709 query_lua(side, random_choice_index, cfg);
3719 void query_lua(
int side,
int function_index,
config& cfg)
const
3721 lua_pushvalue(L, function_index);
3722 lua_pushnumber(L, side);
3725 static const char*
msg =
"function returned to wesnoth.sync.[multi_]evaluate a table which was partially invalid";
3726 lua_kernel_base::get_lua_kernel<game_lua_kernel>(L).log_error(
msg);
3727 lua_warning(L,
msg,
false);
3734 virtual bool is_visible()
const override {
return false; }
3748 std::string tagname =
"input";
3755 if(!lua_isfunction(L, nextarg) &&
luaW_totstring(L, nextarg, desc) ) {
3758 if(lua_isfunction(L, nextarg)) {
3759 human_func = nextarg++;
3762 return luaL_argerror(L, nextarg,
"expected a function");
3764 if(lua_isfunction(L, nextarg)) {
3765 ai_func = nextarg++;
3767 side_for = lua_tointeger(L, nextarg);
3783 std::string tagname =
"input";
3787 std::vector<int> sides_for;
3790 if(!lua_isfunction(L, nextarg) &&
luaW_totstring(L, nextarg, desc) ) {
3793 if(lua_isfunction(L, nextarg)) {
3794 human_func = nextarg++;
3797 return luaL_argerror(L, nextarg,
"expected a function");
3799 if(lua_isfunction(L, nextarg)) {
3800 null_func = nextarg++;
3802 sides_for = lua_check<std::vector<int>>(L, nextarg++);
3817 lua_pushvalue(L, 1);
3832 std::set<map_location> res;
3858 lua_pushboolean(L,
true);
3867 lua_pushboolean(L, t_filter.
match(
loc));
3885 lua_pushboolean(L,
true);
3893 lua_pushboolean(L, s_filter.
match(*
t));
3895 unsigned side = luaL_checkinteger(L, 1) - 1;
3897 lua_pushboolean(L, s_filter.
match(side + 1));
3908 team_i = luaL_checkinteger(L, 1);
3910 std::string
flag = luaL_optlstring(L, 2,
"",
nullptr);
3911 std::string color = luaL_optlstring(L, 3,
"",
nullptr);
3913 if(
flag.empty() && color.empty()) {
3916 if(team_i < 1 ||
static_cast<std::size_t
>(team_i) >
teams().
size()) {
3917 return luaL_error(L,
"set_side_id: side number %d out of range", team_i);
3921 if(!color.empty()) {
3936 side_num =
t->side();
3938 side_num = luaL_checkinteger(L, 1);
3940 std::string
path = luaL_checkstring(L, 2);
3945 if(strcmp(action,
"delete") == 0) {
3950 std::size_t len = std::string::npos, open_brak =
path.find_last_of(
'[');
3951 std::size_t dot =
path.find_last_of(
'.');
3952 if(open_brak != len) {
3953 len = open_brak - dot - 1;
3964 side_num =
t->side();
3966 side_num = luaL_checkinteger(L, 1);
3968 if(lua_isstring(L, 2)) {
3969 std::string file = luaL_checkstring(L, 2);
3971 std::string
err =
formatter() <<
"Could not load AI for side " << side_num <<
" from file " << file;
3972 lua_pushlstring(L,
err.c_str(),
err.length());
3973 return lua_error(L);
3985 side_num =
t->side();
3987 side_num = luaL_checkinteger(L, 1);
3991 cfg =
config {
"ai", cfg};
3993 bool added_dummy_stage =
false;
3995 added_dummy_stage =
true;
3999 if(added_dummy_stage) {
4008 unsigned i = luaL_checkinteger(L, 1);
4009 if(i < 1 || i >
teams().
size())
return 0;
4021 LOG_LUA <<
"intf_get_sides called: this = " << std::hex <<
this << std::dec <<
" myname = " <<
my_name();
4022 std::vector<int> sides;
4026 sides.push_back(
t.side());
4032 sides =
filter.get_teams();
4036 lua_createtable(L, sides.size(), 0);
4038 for(
int side : sides) {
4040 lua_rawseti(L, -2,
index);
4057 char const *m = luaL_checkstring(L, 2);
4059 if (sm ==
"advance") {
4063 if (sm !=
"advancement" && sm !=
"object" && sm !=
"trait") {
4064 return luaL_argerror(L, 2,
"unknown modification type");
4066 bool write_to_mods =
true;
4067 if (!lua_isnone(L, 4)) {
4071 write_to_mods =
false;
4089 std::vector<std::string> tags;
4090 if(lua_isstring(L, 3)) {
4091 tags.push_back(lua_check<std::string>(L, 3));
4092 }
else if (lua_istable(L, 3)){
4093 tags = lua_check<std::vector<std::string>>(L, 3);
4095 tags.push_back(
"object");
4098 if(
filter.attribute_count() == 1 &&
filter.all_children_count() == 0 &&
filter.attribute_range().front().first ==
"duration") {
4101 for(
const std::string&
tag : tags) {
4103 if(obj.matches(
filter)) {
4104 obj[
"duration"] =
"now";
4124 if(lua_isboolean(L, 2)) {
4127 if(lua_isboolean(L, 3)) {
4141 char const *ty = luaL_checkstring(L, 1);
4144 std::stringstream ss;
4145 ss <<
"unknown unit type: '" << ty <<
"'";
4146 return luaL_argerror(L, 1, ss.str().c_str());
4163 std::string team_name;
4166 std::vector<std::string> team_names;
4168 [&](
int team) { return game_state_.get_disp_context().get_team(team).team_name(); });
4171 team_name = cfg[
"team_name"].str();
4180 cfg[
"visible_in_fog"].to_bool(
true),
4181 cfg[
"submerge"].to_double(0),
4182 cfg[
"z_order"].to_double(0)
4196 char const *m = lua_tostring(L, 2);
4213 const int nargs = lua_gettop(L);
4214 if(nargs < 2 || nargs > 3) {
4215 return luaL_error(L,
"Wrong number of arguments to ai.log_replay() - should be 2 or 3 arguments.");
4217 const std::string key = nargs == 2 ? luaL_checkstring(L, 1) : luaL_checkstring(L, 2);
4223 }
else if(!lua_isstring(L, 3)) {
4224 return luaL_argerror(L, 3,
"accepts only string or config");
4247 cfg.
add_child(
"filter_lua")[
"code"] =
"<function>";
4257 if(lua_isstring(L, idx)) {
4258 return lua_tostring(L, idx);
4298 using namespace std::literals;
4304 }
else if(is_menu_item) {
4306 return luaL_argerror(L, 1,
"non-empty id is required for a menu item");
4308 name =
"menu item " +
id;
4310 if(
id.empty() && name.empty()) {
4311 return luaL_argerror(L, 1,
"either a name or id is required");
4314 if(new_handler.valid()) {
4315 bool has_lua_filter =
false;
4319 int filterIdx = lua_gettop(L);
4322 if(lua_isfunction(L, filterIdx)) {
4323 int fcnIdx = lua_absindex(L, -1);
4324 new_handler->add_filter(std::make_unique<lua_event_filter>(*
this, fcnIdx,
luaW_table_get_def(L, 1,
"filter_args",
config())));
4325 has_lua_filter =
true;
4327 #define READ_ONE_FILTER(key, tag) \
4329 if(luaW_tableget(L, filterIdx, key)) { \
4330 if(lua_isstring(L, -1)) { \
4331 filters.add_child("insert_tag", config{ \
4333 "variable", luaL_checkstring(L, -1) \
4336 filters.add_child(tag, luaW_checkconfig(L, -1)); \
4346 #undef READ_ONE_FILTER
4348 filters[
"filter_formula"] = luaL_checkstring(L, -1);
4352 new_handler->read_filters(filters);
4358 if(has_lua_filter) {
4363 new_handler->register_wml_event(*
this);
4376 lua_pushvalue(L, lua_upvalueindex(1));
4393 template<
bool is_menu_item>
4399 double priority = luaL_optnumber(L, 3, 0.);
4401 return luaL_argerror(L, 1,
"must not be empty");
4405 name =
"menu item " + name;
4406 }
else if(lua_absindex(L, -1) > 2 && lua_isfunction(L, -1)) {
4409 lua_pushcclosure(L, &dispatch<&game_lua_kernel::cfun_undoable_event>, 2);
4412 if(new_handler.valid()) {
4429 bool delayed_variable_substitution = cfg[
"delayed_variable_substitution"].to_bool(
true);
4430 if(delayed_variable_substitution) {
4457 lua_pushinteger(L, color.r);
4458 lua_pushinteger(L, color.g);
4459 lua_pushinteger(L, color.b);
4468 auto vec = lua_check<std::vector<uint8_t>>(L, 1);
4469 if(vec.size() != 4) {
4472 color_t fade{vec[0], vec[1], vec[2], vec[3]};
4490 using namespace std::chrono_literals;
4491 std::chrono::milliseconds delay{luaL_checkinteger(L, 1)};
4499 const auto end_time = std::chrono::steady_clock::now() + delay;
4502 std::this_thread::sleep_for(10ms);
4503 }
while (std::chrono::steady_clock::now() < end_time);
4527 std::string team_name;
4530 if(lua_gettop(L) == 1 && lua_istable(L, 1)) {
4531 using namespace std::literals;
4534 team_name = luaL_optstring(L, 2,
"");
4548 switch(lua_type(L, 2)) {
4550 case LUA_TNONE:
case LUA_TNIL:
4555 if(
size_t n = luaL_checkinteger(L, 2);
n > 0 &&
n <=
teams().size()) {
4595 for (
const int side :
filter.get_teams()){
4617 int side = cfg[
"side"].to_int();
4627 lua_getfield(L, -1,
"ca_ptr");
4641 lua_getfield(L, -1,
"stg_ptr");
4650 lua_createtable(L, 0, 0);
4652 lua_pushstring(L,
"name");
4653 lua_pushstring(L,
c->get_name().c_str());
4656 lua_pushstring(L,
"engine");
4657 lua_pushstring(L,
c->get_engine().c_str());
4660 lua_pushstring(L,
"id");
4661 lua_pushstring(L,
c->get_id().c_str());
4664 if (ct ==
"candidate_action") {
4665 lua_pushstring(L,
"ca_ptr");
4666 lua_pushlightuserdata(L,
c);
4669 lua_pushstring(L,
"exec");
4674 if (ct ==
"stage") {
4675 lua_pushstring(L,
"stg_ptr");
4676 lua_pushlightuserdata(L,
c);
4679 lua_pushstring(L,
"exec");
4685 std::vector<std::string> c_types =
c->get_children_types();
4687 for (std::vector<std::string>::const_iterator
t = c_types.begin();
t != c_types.end(); ++
t)
4689 std::vector<ai::component*> children =
c->get_children(*
t);
4690 std::string
type = *
t;
4691 if (
type ==
"aspect" ||
type ==
"goal" ||
type ==
"engine")
4696 lua_pushstring(L,
type.c_str());
4697 lua_createtable(L, 0, 0);
4699 for (std::vector<ai::component*>::const_iterator
i = children.begin();
i != children.end(); ++
i)
4701 lua_pushstring(L, (*i)->get_name().c_str());
4732 side = luaL_checkinteger(L, 1);
4739 std::vector<ai::component*> engines =
c->get_children(
"engine");
4741 for (std::vector<ai::component*>::const_iterator
i = engines.begin();
i != engines.end(); ++
i)
4743 if ((*i)->get_name() ==
"lua")
4753 if (lua_engine ==
nullptr)
4766 LOG_LUA <<
"Created new dummy lua-engine for debug_ai().";
4776 lua_pushstring(L,
"components");
4802 if(lua_isboolean(L, 1)) {
4827 std::set<map_location> locs;
4830 if(lua_gettop(L) == 1) {
4833 id = cfg[
"id"].str();
4835 filter.get_locations(locs,
true);
4838 id = luaL_checkstring(L, 1);
4839 if(!lua_isnoneornil(L, 3))
4845 filter.get_locations(locs,
true);
4853 LOG_LUA <<
"Lua inserted time_area '" <<
id <<
"'";
4862 const char *
id = luaL_checkstring(L, 1);
4864 LOG_LUA <<
"Lua removed time_area '" <<
id <<
"'";
4874 if(area_index < 0) {
4881 std::string area_id = luaL_checkstring(L, 1);
4883 if(
auto iter =
std::find(area_ids.begin(), area_ids.end(), area_id); iter == area_ids.end()) {
4897 if(luaL_testudata(L, 1,
"schedule")) {
4907 ERR_LUA <<
"attempted to to replace ToD schedule with empty schedule";
4913 LOG_LUA <<
"replaced ToD schedule";
4922 point scroll_to(luaL_checkinteger(L, 1), luaL_checkinteger(L, 2));
4939 lua_report_generator(lua_State *L,
const std::string &
n)
4948 if (!
luaW_getglobal(L,
"wesnoth",
"interface",
"game_display", name))
4972 char const *m = luaL_checkstring(L, 2);
4974 lua_pushvalue(L, 2);
4975 lua_pushvalue(L, -2);
4986 char const *m = luaL_checkstring(L, 2);
4987 lua_pushvalue(L, 2);
4988 lua_pushvalue(L, 3);
5029 if (
dst == u->get_location() || !
map().on_board(
dst)) {
5033 if (!
map().on_board(vacant_dst)) {
5044 std::vector<map_location> teleport_path;
5045 teleport_path.push_back(src_loc);
5046 teleport_path.push_back(vacant_dst);
5053 u->anim_comp().set_standing();
5060 if (
map().is_village(vacant_dst)) {
5079 const std::string& logger = lua_isstring(L, 2) ? luaL_checkstring(L, 1) :
"";
5080 const std::string&
msg = lua_isstring(L, 2) ? luaL_checkstring(L, 2) : luaL_checkstring(L, 1);
5082 if(logger ==
"wml" || logger ==
"WML") {
5096 lua_pushboolean(L, fog ?
t.fogged(
loc) :
t.shrouded(
loc));
5114 bool affect_normal_fog =
false;
5115 if(lua_isboolean(L, -1)) {
5118 std::set<int> sides;
5120 sides.insert(
t->side());
5121 }
else if(lua_isnumber(L, 1)) {
5122 sides.insert(lua_tointeger(L, 1));
5123 }
else if(lua_istable(L, 1) && lua_istable(L, 2)) {
5124 const auto& v = lua_check<std::vector<int>>(L, 1);
5125 sides.insert(v.begin(), v.end());
5128 sides.insert(
t.side()+1);
5133 for(
const int &side_num : sides) {
5134 if(side_num < 1 ||
static_cast<std::size_t
>(side_num) >
teams().
size()) {
5140 t.remove_fog_override(locs);
5141 if(affect_normal_fog) {
5144 }
else if(!affect_normal_fog) {
5146 t.add_fog_override(locs);
5164 const std::string name = luaL_checkstring(L, 1);
5169 if(!
luaW_getglobal(L,
"wesnoth",
"custom_synced_commands", name)) {
5170 return luaL_argerror(L, 1,
"Unknown synced command");
5173 cmd_tag[
"name"] = name;
5174 if(!lua_isnoneornil(L, 2)) {
5192 #define CALLBACK_GETTER(name, type) LATTR_GETTER(name, lua_index_raw, callbacks_tag, ) { lua_pushcfunction(L, &impl_null_callback<type>); return lua_index_raw(L); }
5195 template<
typename Ret>
5197 if constexpr(std::is_same_v<Ret, void>)
return 0;
5203 inline static auto metatable =
"game_events";
5205 return lua_kernel_base::get_lua_kernel<game_lua_kernel>(L);
5226 template<
typename Ret =
void>
5228 int top = lua_gettop(L);
5232 lua_getfield(L, -1, name.c_str());
5233 lua_pushcfunction(L, &impl_null_callback<Ret>);
5234 if(lua_rawequal(L, -1, -2)) {
5290 cmd_log_ <<
"Registering game-specific wesnoth lib functions...\n";
5293 static luaL_Reg
const callbacks[] {
5298 {
"cancel_action", &dispatch<&game_lua_kernel::intf_cancel_action > },
5299 {
"log_replay", &dispatch<&game_lua_kernel::intf_log_replay > },
5300 {
"log", &dispatch<&game_lua_kernel::intf_log > },
5301 {
"redraw", &dispatch<&game_lua_kernel::intf_redraw > },
5302 {
"simulate_combat", &dispatch<&game_lua_kernel::intf_simulate_combat > },
5303 {
nullptr,
nullptr }
5304 };lua_getglobal(L,
"wesnoth");
5305 if (!lua_istable(L,-1)) {
5308 luaL_setfuncs(L, callbacks, 0);
5310 lua_setglobal(L,
"wesnoth");
5312 lua_getglobal(L,
"gui");
5313 lua_pushcfunction(L, &dispatch<&game_lua_kernel::intf_gamestate_inspector>);
5314 lua_setfield(L, -2,
"show_inspector");
5316 lua_setfield(L, -2,
"show_recruit_dialog");
5318 lua_setfield(L, -2,
"show_recall_dialog");
5324 static luaL_Reg
const test_callbacks[] {
5325 {
"fire_wml_menu_item", &dispatch<&game_lua_kernel::intf_fire_wml_menu_item> },
5326 {
nullptr,
nullptr }
5328 luaL_setfuncs(L, test_callbacks, 0);
5329 lua_setglobal(L,
"unit_test");
5355 cmd_log_ <<
"Adding terrain_types table...\n";
5356 lua_getglobal(L,
"wesnoth");
5357 lua_newuserdatauv(L, 0, 0);
5358 lua_createtable(L, 0, 2);
5359 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_get_terrain_info>);
5360 lua_setfield(L, -2,
"__index");
5361 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_get_terrain_list>);
5362 lua_setfield(L, -2,
"__dir");
5363 lua_pushstring(L,
"terrain types");
5364 lua_setfield(L, -2,
"__metatable");
5365 lua_setmetatable(L, -2);
5366 lua_setfield(L, -2,
"terrain_types");
5370 cmd_log_ <<
"Adding ai elements table...\n";
5375 cmd_log_ <<
"Adding wesnoth current table...\n";
5377 lua_getglobal(L,
"wesnoth");
5378 lua_newuserdatauv(L, 0, 0);
5379 lua_createtable(L, 0, 2);
5380 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_current_get>);
5381 lua_setfield(L, -2,
"__index");
5382 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_current_dir>);
5383 lua_setfield(L, -2,
"__dir");
5384 lua_pushboolean(L,
true);
5385 lua_setfield(L, -2,
"__dir_tablelike");
5386 lua_pushstring(L,
"current config");
5387 lua_setfield(L, -2,
"__metatable");
5388 lua_setmetatable(L, -2);
5389 lua_setfield(L, -2,
"current");
5393 lua_getglobal(L,
"wml");
5394 static luaL_Reg
const wml_callbacks[] {
5398 {
"get_variable", &dispatch<&game_lua_kernel::intf_get_variable>},
5399 {
"set_variable", &dispatch<&game_lua_kernel::intf_set_variable>},
5400 {
"get_all_vars", &dispatch<&game_lua_kernel::intf_get_all_vars>},
5401 {
nullptr,
nullptr }
5403 luaL_setfuncs(L, wml_callbacks, 0);
5408 static luaL_Reg
const map_callbacks[] {
5415 {
"get_owner", &dispatch<&game_lua_kernel::intf_get_village_owner>},
5416 {
"set_owner", &dispatch<&game_lua_kernel::intf_set_village_owner>},
5418 {
"add_label", &dispatch<&game_lua_kernel::intf_add_label>},
5419 {
"remove_label", &dispatch<&game_lua_kernel::intf_remove_label>},
5420 {
"get_label", &dispatch<&game_lua_kernel::intf_get_label>},
5422 {
"place_area", &dispatch<&game_lua_kernel::intf_add_time_area>},
5423 {
"remove_area", &dispatch<&game_lua_kernel::intf_remove_time_area>},
5424 {
"get_area", &dispatch<&game_lua_kernel::intf_get_time_area>},
5426 {
"find", &dispatch<&game_lua_kernel::intf_get_locations>},
5427 {
"matches", &dispatch<&game_lua_kernel::intf_match_location>},
5429 {
nullptr,
nullptr }
5431 luaL_setfuncs(L, map_callbacks, 0);
5435 cmd_log_ <<
"Adding units module...\n";
5436 static luaL_Reg
const unit_callbacks[] {
5439 {
"erase", &dispatch<&game_lua_kernel::intf_erase_unit>},
5440 {
"extract", &dispatch<&game_lua_kernel::intf_extract_unit>},
5441 {
"matches", &dispatch<&game_lua_kernel::intf_match_unit>},
5442 {
"select", &dispatch<&game_lua_kernel::intf_select_unit>},
5443 {
"to_map", &dispatch<&game_lua_kernel::intf_put_unit>},
5444 {
"to_recall", &dispatch<&game_lua_kernel::intf_put_recall_unit>},
5446 {
"teleport", &dispatch<&game_lua_kernel::intf_teleport>},
5448 {
"ability", &dispatch<&game_lua_kernel::intf_unit_ability>},
5459 {
"find_on_map", &dispatch<&game_lua_kernel::intf_get_units>},
5460 {
"find_on_recall", &dispatch<&game_lua_kernel::intf_get_recall_units>},
5461 {
"get", &dispatch<&game_lua_kernel::intf_get_unit>},
5462 {
"get_hovered", &dispatch<&game_lua_kernel::intf_get_displayed_unit>},
5463 {
"create_animator", &dispatch<&game_lua_kernel::intf_create_animator>},
5466 {
nullptr,
nullptr }
5468 lua_getglobal(L,
"wesnoth");
5470 luaL_setfuncs(L, unit_callbacks, 0);
5471 lua_setfield(L, -2,
"units");
5475 cmd_log_ <<
"Adding sides module...\n";
5476 static luaL_Reg
const side_callbacks[] {
5477 {
"is_enemy", &dispatch<&game_lua_kernel::intf_is_enemy> },
5478 {
"matches", &dispatch<&game_lua_kernel::intf_match_side> },
5479 {
"set_id", &dispatch<&game_lua_kernel::intf_set_side_id> },
5484 {
"find", &dispatch<&game_lua_kernel::intf_get_sides> },
5485 {
"get", &dispatch<&game_lua_kernel::intf_get_side> },
5486 {
"create", &dispatch<&game_lua_kernel::intf_create_side> },
5488 {
"place_shroud", &dispatch2<&game_lua_kernel::intf_toggle_shroud, true>},
5489 {
"remove_shroud", &dispatch2<&game_lua_kernel::intf_toggle_shroud, false>},
5490 {
"override_shroud", &dispatch<&game_lua_kernel::intf_override_shroud>},
5491 {
"is_shrouded", &dispatch2<&game_lua_kernel::intf_get_fog_or_shroud, false>},
5493 {
"place_fog", &dispatch2<&game_lua_kernel::intf_toggle_fog, false>},
5494 {
"remove_fog", &dispatch2<&game_lua_kernel::intf_toggle_fog, true>},
5495 {
"is_fogged", &dispatch2<&game_lua_kernel::intf_get_fog_or_shroud, true>},
5496 {
nullptr,
nullptr }
5498 std::vector<lua_cpp::Reg>
const cpp_side_callbacks {
5499 {
"add_ai_component", std::bind(
intf_modify_ai, std::placeholders::_1,
"add")},
5500 {
"delete_ai_component", std::bind(
intf_modify_ai, std::placeholders::_1,
"delete")},
5501 {
"change_ai_component", std::bind(
intf_modify_ai, std::placeholders::_1,
"change")},
5505 lua_getglobal(L,
"wesnoth");
5507 luaL_setfuncs(L, side_callbacks, 0);
5509 lua_setfield(L, -2,
"sides");
5513 cmd_log_ <<
"Adding interface module...\n";
5514 static luaL_Reg
const intf_callbacks[] {
5515 {
"add_hex_overlay", &dispatch<&game_lua_kernel::intf_add_tile_overlay>},
5516 {
"remove_hex_overlay", &dispatch<&game_lua_kernel::intf_remove_tile_overlay>},
5517 {
"get_color_adjust", &dispatch<&game_lua_kernel::intf_get_color_adjust>},
5518 {
"color_adjust", &dispatch<&game_lua_kernel::intf_color_adjust>},
5519 {
"screen_fade", &dispatch<&game_lua_kernel::intf_screen_fade>},
5520 {
"delay", &dispatch<&game_lua_kernel::intf_delay>},
5521 {
"deselect_hex", &dispatch<&game_lua_kernel::intf_deselect_hex>},
5522 {
"highlight_hex", &dispatch<&game_lua_kernel::intf_highlight_hex>},
5523 {
"float_label", &dispatch<&game_lua_kernel::intf_float_label>},
5524 {
"get_displayed_unit", &dispatch<&game_lua_kernel::intf_get_displayed_unit>},
5525 {
"get_hovered_hex", &dispatch<&game_lua_kernel::intf_get_mouseover_tile>},
5526 {
"get_selected_hex", &dispatch<&game_lua_kernel::intf_get_selected_tile>},
5527 {
"lock", &dispatch<&game_lua_kernel::intf_lock_view>},
5528 {
"is_locked", &dispatch<&game_lua_kernel::intf_view_locked>},
5529 {
"scroll", &dispatch<&game_lua_kernel::intf_scroll>},
5530 {
"scroll_to_hex", &dispatch<&game_lua_kernel::intf_scroll_to_tile>},
5531 {
"skip_messages", &dispatch<&game_lua_kernel::intf_skip_messages>},
5532 {
"is_skipping_messages", &dispatch<&game_lua_kernel::intf_is_skipping_messages>},
5533 {
"zoom", &dispatch<&game_lua_kernel::intf_zoom>},
5534 {
"clear_menu_item", &dispatch<&game_lua_kernel::intf_clear_menu_item>},
5535 {
"set_menu_item", &dispatch<&game_lua_kernel::intf_set_menu_item>},
5536 {
"allow_end_turn", &dispatch<&game_lua_kernel::intf_allow_end_turn>},
5537 {
"clear_chat_messages", &dispatch<&game_lua_kernel::intf_clear_messages>},
5538 {
"end_turn", &dispatch<&game_lua_kernel::intf_end_turn>},
5540 {
"add_chat_message", &dispatch<&game_lua_kernel::intf_message>},
5541 {
"add_overlay_text", &dispatch2<&game_lua_kernel::intf_set_floating_label, true>},
5543 {
nullptr,
nullptr }
5545 lua_getglobal(L,
"wesnoth");
5547 luaL_setfuncs(L, intf_callbacks, 0);
5548 lua_setfield(L, -2,
"interface");
5552 cmd_log_ <<
"Adding achievements module...\n";
5553 static luaL_Reg
const achievement_callbacks[] {
5554 {
"set", &dispatch<&game_lua_kernel::intf_set_achievement> },
5555 {
"has", &dispatch<&game_lua_kernel::intf_has_achievement> },
5556 {
"get", &dispatch<&game_lua_kernel::intf_get_achievement> },
5557 {
"progress", &dispatch<&game_lua_kernel::intf_progress_achievement> },
5558 {
"has_sub_achievement", &dispatch<&game_lua_kernel::intf_has_sub_achievement> },
5559 {
"set_sub_achievement", &dispatch<&game_lua_kernel::intf_set_sub_achievement> },
5560 {
nullptr,
nullptr }
5562 lua_getglobal(L,
"wesnoth");
5564 luaL_setfuncs(L, achievement_callbacks, 0);
5565 lua_setfield(L, -2,
"achievements");
5569 cmd_log_ <<
"Adding audio module...\n";
5570 static luaL_Reg
const audio_callbacks[] {
5571 {
"play", &dispatch<&game_lua_kernel::intf_play_sound > },
5572 {
nullptr,
nullptr }
5574 lua_getglobal(L,
"wesnoth");
5576 luaL_setfuncs(L, audio_callbacks, 0);
5577 lua_setfield(L, -2,
"audio");
5581 cmd_log_ <<
"Adding paths module...\n";
5582 static luaL_Reg
const path_callbacks[] {
5583 {
"find_cost_map", &dispatch<&game_lua_kernel::intf_find_cost_map > },
5584 {
"find_path", &dispatch<&game_lua_kernel::intf_find_path > },
5585 {
"find_reach", &dispatch<&game_lua_kernel::intf_find_reach > },
5586 {
"find_vacant_hex", &dispatch<&game_lua_kernel::intf_find_vacant_tile > },
5587 {
"find_vision_range", &dispatch<&game_lua_kernel::intf_find_vision_range > },
5588 {
nullptr,
nullptr }
5590 lua_getglobal(L,
"wesnoth");
5592 luaL_setfuncs(L, path_callbacks, 0);
5593 lua_setfield(L, -2,
"paths");
5597 cmd_log_ <<
"Adding sync module...\n";
5598 static luaL_Reg
const sync_callbacks[] {
5603 {
nullptr,
nullptr }
5605 lua_getglobal(L,
"wesnoth");
5607 luaL_setfuncs(L, sync_callbacks, 0);
5608 lua_setfield(L, -2,
"sync");
5612 cmd_log_ <<
"Adding schedule module...\n";
5613 static luaL_Reg
const schedule_callbacks[] {
5614 {
"get_time_of_day", &dispatch<&game_lua_kernel::intf_get_time_of_day<false>>},
5615 {
"get_illumination", &dispatch<&game_lua_kernel::intf_get_time_of_day<true>>},
5616 {
"replace", &dispatch<&game_lua_kernel::intf_replace_schedule>},
5617 {
nullptr,
nullptr }
5619 lua_getglobal(L,
"wesnoth");
5621 luaL_setfuncs(L, schedule_callbacks, 0);
5622 lua_createtable(L, 0, 2);
5623 lua_setmetatable(L, -2);
5624 lua_setfield(L, -2,
"schedule");
5631 cmd_log_ <<
"Adding wml_actions table...\n";
5633 lua_getglobal(L,
"wesnoth");
5635 lua_setfield(L, -2,
"wml_actions");
5639 cmd_log_ <<
"Adding wml_conditionals table...\n";
5641 lua_getglobal(L,
"wesnoth");
5643 lua_setfield(L, -2,
"wml_conditionals");
5650 cmd_log_ <<
"Adding effects table...\n";
5652 lua_getglobal(L,
"wesnoth");
5654 lua_setfield(L, -2,
"effects");
5658 cmd_log_ <<
"Adding custom_synced_commands table...\n";
5660 lua_getglobal(L,
"wesnoth");
5662 lua_setfield(L, -2,
"custom_synced_commands");
5666 cmd_log_ <<
"Adding game_events module...\n";
5667 static luaL_Reg
const event_callbacks[] {
5668 {
"add", &dispatch<&game_lua_kernel::intf_add_event> },
5669 {
"add_repeating", &dispatch<&game_lua_kernel::intf_add_event_simple<false>> },
5670 {
"add_menu", &dispatch<&game_lua_kernel::intf_add_event_simple<true>> },
5671 {
"add_wml", &dispatch<&game_lua_kernel::intf_add_event_wml> },
5672 {
"remove", &dispatch<&game_lua_kernel::intf_remove_event> },
5673 {
"fire", &dispatch2<&game_lua_kernel::intf_fire_event, false> },
5674 {
"fire_by_id", &dispatch2<&game_lua_kernel::intf_fire_event, true> },
5675 {
"add_undo_actions", &dispatch<&game_lua_kernel::intf_add_undo_actions> },
5676 {
"set_undoable", &dispatch<&game_lua_kernel::intf_allow_undo > },
5677 {
nullptr,
nullptr }
5679 lua_getglobal(L,
"wesnoth");
5681 luaL_setfuncs(L, event_callbacks, 0);
5682 lua_createtable(L, 0, 2);
5684 lua_setfield(L, -2,
"__dir");
5686 lua_setfield(L, -2,
"__index");
5687 lua_pushstring(L,
"game_events");
5688 lua_setfield(L, -2,
"__metatable");
5689 lua_setmetatable(L, -2);
5690 lua_setfield(L, -2,
"game_events");
5694 cmd_log_ <<
"Adding game_display table...\n";
5698 lua_createtable(L, 0, 2);
5699 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_theme_items_get>);
5700 lua_setfield(L, -2,
"__index");
5701 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_theme_items_set>);
5702 lua_setfield(L, -2,
"__newindex");
5703 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_theme_items_dir>);
5704 lua_setfield(L, -2,
"__dir");
5705 lua_setmetatable(L, -2);
5706 lua_setfield(L, -2,
"game_display");
5710 cmd_log_ <<
"Adding scenario table...\n";
5714 lua_createtable(L, 0, 2);
5715 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_scenario_get>);
5716 lua_setfield(L, -2,
"__index");
5717 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_scenario_set>);
5718 lua_setfield(L, -2,
"__newindex");
5719 lua_pushcfunction(L, &dispatch<&game_lua_kernel::impl_scenario_dir>);
5720 lua_setfield(L, -2,
"__dir");
5721 lua_setmetatable(L, -2);
5722 lua_setfield(L, -2,
"scenario");
5733 lua_pushstring(L, effect.c_str());
5751 cmd_log_ <<
"Adding races table...\n";
5754 lua_getglobal(L,
"wesnoth");
5756 lua_setfield(L, -2,
"races");
5760 cmd_log_ <<
"Running preload scripts...\n";
5783 using namespace std::literals::string_view_literals;
5784 static constexpr std::array handled_file_tags {
5797 "modify_unit_type"sv,
5803 "terrain_graphics"sv,
5811 return std::binary_search(handled_file_tags.begin(), handled_file_tags.end(),
s);
5827 for(
const auto [child_key, child_cfg] :
level.all_children_view())
5830 lua_createtable(L, 2, 0);
5831 lua_pushstring(L, child_key.c_str());
5832 lua_rawseti(L, -2, 1);
5834 lua_rawseti(L, -2, 2);
5835 lua_rawseti(L, -2, k++);
5849 if(!impl_get_callback<config>(L,
"on_save"))
5862 const std::vector<std::string> src_tags(temp.begin(), temp.end());
5864 for(
const auto& key : src_tags) {
5871 const std::string m =
"Tag is already used: [" + key +
"]";
5892 lua_pushstring(L, ev.
name.c_str());
5901 if (!
luaW_getglobal(L,
"wesnoth",
"custom_synced_commands", name)) {
5917 std::string which_effect = lua_tostring(L, lua_upvalueindex(1));
5932 lua_pushstring(L, description.c_str());
5945 int str_i = lua_gettop(L);
5948 lua_pushstring(L,
"__call");
5949 lua_pushvalue(L, str_i);
5950 lua_pushboolean(L,
true);
5951 lua_pushcclosure(L, &dispatch<&game_lua_kernel::cfun_builtin_effect>, 2);
5953 lua_pushstring(L,
"__descr");
5954 lua_pushvalue(L, str_i);
5955 lua_pushboolean(L,
false);
5956 lua_pushcclosure(L, &dispatch<&game_lua_kernel::cfun_builtin_effect>, 2);
5958 lua_setmetatable(L, -2);
5968 (lua_touserdata(L, lua_upvalueindex(1)));
5982 lua_getglobal(L,
"wesnoth");
5983 lua_pushstring(L,
"wml_actions");
5985 lua_pushstring(L, cmd.c_str());
5986 lua_pushlightuserdata(L,
reinterpret_cast<void *
>(
h));
5987 lua_pushcclosure(L, &dispatch<&game_lua_kernel::cfun_wml_action>, 1);
6000 (lua_touserdata(L, lua_upvalueindex(1)));
6003 lua_pushboolean(L,
h(vcfg));
6014 lua_getglobal(L,
"wesnoth");
6015 lua_pushstring(L,
"wml_conditionals");
6017 lua_pushstring(L, cmd.c_str());
6018 lua_pushlightuserdata(L,
reinterpret_cast<void *
>(
h));
6060 ERR_WML <<
"unknown conditional wml: [" << cmd <<
"]";
6079 int argIdx = lua_gettop(L);
6081 return luaL_error(L,
"wesnoth.wml_actions.command is missing");
6083 lua_pushvalue(L, argIdx);
6092 int evtIdx = lua_gettop(L);
6097 return luaL_ref(L, evtIdx);
6104 int evtIdx = lua_gettop(L);
6108 std::ostringstream lua_name;
6109 lua_name <<
"event ";
6111 lua_name <<
"<anon>";
6116 lua_name <<
"[id=" <<
id <<
"]";
6119 ERR_LUA <<
"Failed to register WML event: " << lua_name.str();
6122 return luaL_ref(L, evtIdx);
6128 idx = lua_absindex(L, idx);
6130 int evtIdx = lua_gettop(L);
6134 lua_pushvalue(L, idx);
6135 return luaL_ref(L, evtIdx);
6142 luaL_unref(L, -1, ref);
6153 lua_geti(L, -1, ref);
6154 if(lua_isnil(L, -1))
return false;
6200 lua_pushvalue(L, -1);
6220 std::string message = std::string() +
"function " + name +
" not found";
6221 log_error(message.c_str(),
"Lua SUF Error");
6225 lua_insert(L, -nArgs - 1);
6237 int top = lua_gettop(L);
6248 if(lua_istable(L, -1)) {
6251 lua_pushvalue(L, -1);
6253 lua_pushvalue(L, top + 1);
6255 lua_pushvalue(L, top + 2);
6260 if(luaL_getmetafield(L, -1,
"__descr")) {
6262 if(lua_isstring(L, -1)) {
6264 descr = lua_tostring(L, -1);
6266 lua_pushvalue(L, -2);
6268 lua_pushvalue(L, top + 1);
6270 lua_pushvalue(L, top + 2);
6273 if(lua_isstring(L, -1) && !lua_isnumber(L, -1)) {
6274 descr = lua_tostring(L, -1);
6276 ERR_LUA <<
"Effect __descr metafunction should have returned a string, but instead returned ";
6277 if(lua_isnone(L, -1)) {
6280 ERR_LUA << lua_typename(L, lua_type(L, -1));
6285 }
else if(need_apply) {
6287 lua_pushvalue(L, top + 1);
6289 lua_pushvalue(L, top + 2);
6327 if(!impl_get_callback<bool>(L,
"on_mouse_button")) {
Various functions that implement attacks and attack calculations.
Various functions related to moving units.
void advance_unit_at(const advance_unit_params ¶ms)
Various functions that implement advancements of units.
Managing the AIs lifecycle - headers TODO: Refactor history handling and internal commands.
GAME_CONFIG_SETTER("debug", bool, application_lua_kernel)
Class to encapsulate fog/shroud clearing and the resultant sighted events.
bool clear_dest(const map_location &dest, const unit &viewer)
Clears shroud (and fog) at the provided location and its immediate neighbors.
game_events::pump_result_t fire_events()
Fires the sighted events that were earlier recorded by fog/shroud clearing.
bool clear_unit(const map_location &view_loc, team &view_team, std::size_t viewer_id, int sight_range, bool slowed, const movetype::terrain_costs &costs, const map_location &real_loc, const std::set< map_location > *known_units=nullptr, std::size_t *enemy_count=nullptr, std::size_t *friend_count=nullptr, move_unit_spectator *spectator=nullptr, bool instant=true)
Clears shroud (and fog) around the provided location for view_team based on sight_range,...
virtual ai_context & get_ai_context()
unwrap
virtual double evaluate()=0
Evaluate the candidate action, resetting the internal state of the action.
virtual void execute()=0
Execute the candidate action.
static bool add_component(component *root, const std::string &path, const config &cfg)
static void expand_simplified_aspects(side_number side, config &cfg)
Expand simplified aspects, similar to the change from 1.7.2 to 1.7.3 but with some additional syntax ...
static const config & get_default_ai_parameters()
get default AI parameters
virtual config to_config() const
Serialize to config.
virtual void push_ai_table()
Method that pushes the AI table of the lua_context on the stack for debugging purposes.
component * get_component(component *root, const std::string &path)
Proxy class for calling AI action handlers defined in Lua.
static lua_ai_action_handler * create(lua_State *L, char const *code, lua_ai_context &context)
Proxy table for the AI context.
static void init(lua_State *L)
static lua_ai_context * create(lua_State *L, char const *code, engine_lua *engine)
bool add_ai_for_side_from_config(side_number side, const config &cfg, bool replace=true)
Adds active AI for specified side from cfg.
void append_active_ai_for_side(ai::side_number side, const config &cfg)
Appends AI parameters to active AI of the given side.
void raise_user_interact()
Notifies all observers of 'ai_user_interact' event.
static manager & get_singleton()
void modify_active_ai_for_side(ai::side_number side, const config &cfg)
Modifies AI parameters for active AI of the given side.
ai::holder & get_active_ai_holder_for_side_dbg(side_number side)
Gets the active AI holder for debug purposes.
bool play_stage()
Play the turn - strategy.
Computes the statistics of a battle between an attacker and a defender unit.
const battle_context_unit_stats & get_defender_stats() const
This method returns the statistics of the defender.
const combatant & get_attacker_combatant(const combatant *prev_def=nullptr)
Get the simulation results.
const battle_context_unit_stats & get_attacker_stats() const
This method returns the statistics of the attacker.
const combatant & get_defender_combatant(const combatant *prev_def=nullptr)
Variant for storing WML attributes.
std::string str(const std::string &fallback="") const
bool empty() const
Tests for an attribute that either was never set or was set to "".
A config object defines a single node in a WML file, with access to child nodes.
config & mandatory_child(config_key_type key, int n=0)
Returns the nth child with the given key, or throws an error if there is none.
bool has_child(config_key_type key) const
Determine whether a config has a child or not.
void remove_children(config_key_type key, const std::function< bool(const config &)> &p={})
Removes all children with tag key for which p returns true.
child_itors child_range(config_key_type key)
config & child_or_add(config_key_type key)
Returns a reference to the first child with the given key.
auto child_name_view() const
A non-owning view over all child tag names.
void append_children(const config &cfg)
Adds children from cfg.
void splice_children(config &src, config_key_type key)
Moves all the children with tag key from src to this.
optional_config_impl< config > optional_child(config_key_type key, int n=0)
Equivalent to mandatory_child, but returns an empty optional if the nth child was not found.
config & add_child(config_key_type key)
virtual void play_slice()
void clear_chat_messages()
void add_chat_message(const std::time_t &time, const std::string &speaker, int side, const std::string &msg, events::chat_handler::MESSAGE_TYPE type, bool bell)
int village_owner(const map_location &loc) const
Given the location of a village, will return the 1-based number of the team that currently owns it,...
virtual const unit_map & units() const =0
Sort-of-Singleton that many classes, both GUI and non-GUI, use to access the game data.
const team & viewing_team() const
void remove_overlay(const map_location &loc)
remove_overlay will remove all overlays on a tile.
void recalculate_minimap()
Schedule the minimap for recalculation.
void remove_single_overlay(const map_location &loc, const std::string &toDelete)
remove_single_overlay will remove a single overlay from a tile
bool invalidate(const map_location &loc)
Function to invalidate a specific tile for redrawing.
double turbo_speed() const
void adjust_color_overlay(int r, int g, int b)
Add r,g,b to the colors for all images displayed on the map.
static double get_zoom_factor()
Returns the current zoom factor.
void scroll_to_tile(const map_location &loc, SCROLL_TYPE scroll_type=ONSCREEN, bool check_fogged=true, bool force=true)
Scroll such that location loc is on-screen.
bool set_zoom(bool increase)
Zooms the display in (true) or out (false).
tod_color get_color_overlay() const
void invalidate_all()
Function to invalidate all tiles.
rect map_outside_area() const
Returns the available area for a map, this may differ from the above.
void fade_to(const color_t &color, const std::chrono::milliseconds &duration)
Screen fade.
const display_context & context() const
void add_overlay(const map_location &loc, overlay &&ov)
Functions to add and remove overlays from locations.
const map_location & selected_hex() const
bool show_everything() const
static display * get_singleton()
Returns the display object if a display object exists.
void reinit_flags_for_team(const team &)
Rebuild the flag list (not team colors) for a single side.
const map_location & mouseover_hex() const
void set_view_locked(bool value)
Sets whether the map view is locked (e.g.
bool scroll(const point &amount, bool force=false)
Scrolls the display by amount pixels.
void select_hex(const map_location &hex, const bool browse, const bool highlight=true, const bool fire_event=true, const bool force_unhighlight=false)
void set_position(double xpos, double ypos)
void set_alignment(ALIGN align)
void set_lifetime(const std::chrono::milliseconds &lifetime, const std::chrono::milliseconds &fadeout=std::chrono::milliseconds{100})
void set_color(const color_t &color)
void set_clip_rect(const SDL_Rect &r)
void set_bg_color(const color_t &bg_color)
void set_font_size(int font_size)
virtual const std::vector< team > & teams() const override
unit_map::iterator find_visible_unit(const map_location &loc, const team ¤t_team, bool see_all=false)
virtual const unit_map & units() const override
virtual const gamemap & map() const override
static game_config_manager * get()
const game_config_view & game_config() const
A class grating read only view to a vector of config objects, viewed as one config with all children ...
const config & find_mandatory_child(config_key_type key, const std::string &name, const std::string &value) const
void clear_variable(const std::string &varname)
Clears attributes config children does nothing if varname is no valid variable name.
@ PRELOAD
the preload [event] is fired next phase: PRESTART (normal game), TURN_STARTING_WAITING (reloaded game...
@ INITIAL
creating intitial [unit]s, executing toplevel [lua] etc.
@ PRESTART
the prestart [event] is fired next phase: START (default), GAME_ENDING
@ TURN_PLAYING
The User is controlling the game and invoking actions The game can be saved here.
const std::string & get_theme() const
variable_access_create get_variable_access_write(const std::string &varname)
returns a variable_access that can be used to change the game variables
void set_theme(const std::string &value)
void set_allow_end_turn(bool value, const t_string &reason="")
variable_access_const get_variable_access_read(const std::string &varname) const
returns a variable_access that cannot be used to change the game variables
void display_unit_hex(map_location hex)
Change the unit to be displayed in the sidebar.
void invalidate_unit_after_move(const map_location &src, const map_location &dst)
Same as invalidate_unit() if moving the displayed unit.
virtual void highlight_hex(map_location hex) override
Function to highlight a location.
virtual const map_location & displayed_unit_hex() const override
Virtual functions shadowed in game_display.
void new_turn()
Update lighting settings.
bool maybe_rebuild()
Rebuilds the screen if needs_rebuild(true) was previously called, and resets the flag.
display_chat_manager & get_chat_manager()
void float_label(const map_location &loc, const std::string &text, const color_t &color)
Function to float a label above a tile.
void set_arguments(const config &cfg)
The game event manager loads the scenario configuration object, and ensures that events are handled a...
void add_event_handler_from_wml(const config &handler, game_lua_kernel &lk, bool is_menu_item=false)
Create an event handler from an [event] tag.
pending_event_handler add_event_handler_from_lua(const std::string &name, const std::string &id, bool repeat=false, double priority=0., bool is_menu_item=false)
Create an empty event handler.
bool fire_item(const std::string &id, const map_location &hex, game_data &gamedata, filter_context &fc, unit_map &units, bool is_key_hold_repeat=false) const
Fires the menu item with the given id.
bool erase(const std::string &id)
Erases the item with the provided id.
void set_item(const std::string &id, const vconfig &menu_item)
Updates or creates (as appropriate) the menu item with the given id.
void(* handler)(const queued_event &, const vconfig &)
static const map & registry()
void set_action_canceled()
Sets whether or not wml wants to abort the currently executed user action.
pump_result_t fire(const std::string &event, const entity_location &loc1=entity_location::null_entity, const entity_location &loc2=entity_location::null_entity, const config &data=config())
Function to fire an event.
void set_undo_disabled(bool mutated)
[allow_undo] implementation
int intf_get_mouseover_tile(lua_State *L)
Returns the currently overed tile.
void custom_command(const std::string &, const config &)
int intf_put_unit(lua_State *L)
Places a unit on the map.
int intf_get_label(lua_State *L)
int intf_cancel_action(lua_State *)
int intf_set_floating_label(lua_State *L, bool spawn)
Arg 1: text - string Arg 2: options table.
int intf_replace_schedule(lua_State *l)
Replacing the current time of day schedule.
int intf_select_unit(lua_State *L)
Selects and highlights the given location on the map.
int intf_deselect_hex(lua_State *L)
Deselects any highlighted hex on the map.
std::stack< game_events::queued_event const * > queued_events_
int intf_get_all_vars(lua_State *L)
Gets all the WML variables currently set.
int intf_remove_tile_overlay(lua_State *L)
Removes an overlay from a tile.
int intf_screen_fade(lua_State *L)
int intf_erase_unit(lua_State *L)
Erases a unit from the map.
int intf_get_fog_or_shroud(lua_State *L, bool fog)
int intf_override_shroud(lua_State *L)
Overrides the shroud entirely.
int intf_get_variable(lua_State *L)
Gets a WML variable.
int intf_scroll(lua_State *L)
game_lua_kernel(game_state &, play_controller &, reports &)
int intf_set_sub_achievement(lua_State *L)
Marks a single sub-achievement as completed.
int intf_lock_view(lua_State *L)
Sets whether gamemap scrolling is disabled for the user.
void put_unit_helper(const map_location &loc)
int intf_toggle_shroud(lua_State *L, bool place_shroud)
Toggle shroud on some locations Arg 1: Side number Arg 2: List of locations on which to place/remove ...
int intf_match_side(lua_State *L)
Matches a side against the given filter.
int intf_get_selected_tile(lua_State *L)
Returns the currently selected tile.
int cfun_wml_action(lua_State *L)
Executes its upvalue as a wml action.
virtual void log_error(char const *msg, char const *context="Lua error") override
Error reporting mechanisms, used by virtual methods protected_call and load_string.
int cfun_builtin_effect(lua_State *L)
Applies its upvalue as an effect Arg 1: The unit to apply to Arg 3: The [effect] tag contents Arg 3: ...
int impl_theme_item(lua_State *L, const std::string &name)
Executes its upvalue as a theme item generator.
ai::lua_ai_context * create_lua_ai_context(char const *code, ai::engine_lua *engine)
int intf_has_achievement(lua_State *L)
Returns whether an achievement has been completed.
int intf_gamestate_inspector(lua_State *)
int intf_float_label(lua_State *L)
Floats some text on the map.
int intf_find_reach(lua_State *L)
Finds all the locations reachable by a unit.
bool run_event(const game_events::queued_event &)
Executes the game_events.on_event function.
int intf_end_turn(lua_State *)
int save_wml_event()
Store a WML event in the Lua registry, as a function.
int impl_scenario_dir(lua_State *L)
Get a list of scenario data (__dir metamethod).
int intf_set_achievement(lua_State *L)
Sets an achievement as being completed.
int intf_get_units(lua_State *)
Gets all the units matching a given filter.
int intf_color_adjust(lua_State *L)
int intf_redraw(lua_State *L)
int intf_set_village_owner(lua_State *L)
Sets the owner of a village.
int impl_current_dir(lua_State *L)
Gets a list of date about current point of game (__dir metamethod).
static config preload_config
int intf_find_cost_map(lua_State *L)
Is called with one or more units and builds a cost map.
int intf_get_time_area(lua_State *)
int intf_highlight_hex(lua_State *L)
Highlights the given location on the map.
bool run_wml_event(int ref, const vconfig &args, const game_events::queued_event &ev, bool *out=nullptr)
Run a WML stored in the Lua registry.
int intf_scroll_to_tile(lua_State *L)
Scrolls to given tile.
int intf_get_side(lua_State *L)
int intf_remove_event(lua_State *L)
int intf_is_enemy(lua_State *L)
Returns whether the first side is an enemy of the second one.
static void extract_preload_scripts(const game_config_view &game_config)
int impl_get_terrain_info(lua_State *L)
Gets details about a terrain.
virtual std::string my_name() override
User-visible name of the lua kernel that they are talking to.
int intf_remove_label(lua_State *L)
bool run_wml_action(const std::string &, const vconfig &, const game_events::queued_event &)
Runs a command from an event handler.
int intf_move_floating_label(lua_State *L)
int intf_match_unit(lua_State *L)
Matches a unit against the given filter.
int intf_add_time_area(lua_State *)
Adding new time_areas dynamically with Standard Location Filters.
void clear_wml_event(int ref)
Clear a WML event store in the Lua registry.
int intf_create_animator(lua_State *)
int impl_theme_items_dir(lua_State *L)
Get all available theme_items (__dir metamethod).
int intf_add_event_wml(lua_State *L)
Add a new event handler Arg: A full event specification as a WML config.
int impl_scenario_set(lua_State *L)
Sets some scenario data (__newindex metamethod).
int intf_message(lua_State *L)
Displays a message in the chat window and in the logs.
int intf_set_side_id(lua_State *L)
int intf_view_locked(lua_State *L)
Gets whether gamemap scrolling is disabled for the user.
int intf_get_displayed_unit(lua_State *)
Gets the unit displayed in the sidebar.
bool run_wml_conditional(const std::string &, const vconfig &)
Evaluates a WML conidition.
int intf_get_recall_units(lua_State *L)
Gets the numeric ids of all the units matching a given filter on the recall lists.
int intf_add_label(lua_State *L)
int intf_zoom(lua_State *L)
int intf_log_replay(lua_State *L)
const game_events::queued_event & get_event_info()
int intf_unit_ability(lua_State *L)
Returns true if the unit has the given ability enabled.
void push_builtin_effect()
Registers a function for use as an effect handler.
int impl_run_animation(lua_State *)
std::string apply_effect(const std::string &name, unit &u, const config &cfg, bool need_apply)
int intf_fire_wml_menu_item(lua_State *L)
Fires a wml menu item.
int intf_clear_menu_item(lua_State *L)
void mouse_over_hex_callback(const map_location &loc)
int impl_theme_items_get(lua_State *L)
Creates a field of the theme_items table and returns it (__index metamethod).
int intf_find_vacant_tile(lua_State *L)
Finds a vacant tile.
play_controller & play_controller_
int impl_schedule_dir(lua_State *L)
const gamemap & map() const
int map_locked_
A value != 0 means that the shouldn't remove any units from the map, usually because we are currently...
static std::vector< config > preload_scripts
int intf_get_unit(lua_State *)
Gets the unit at the given location or with the given id.
int impl_current_get(lua_State *L)
Gets some data about current point of game (__index metamethod).
int impl_schedule_set(lua_State *L)
void select_hex_callback(const map_location &loc)
void set_wml_condition(const std::string &, bool(*)(const vconfig &))
Registers a function for use as a conditional handler.
int impl_end_level_data_set(lua_State *)
std::string synced_state()
converts synced_context::get_synced_state() to a string.
int intf_find_path(lua_State *L)
Finds a path between two locations.
int intf_remove_floating_label(lua_State *L)
void set_wml_action(const std::string &, game_events::wml_action::handler)
Registers a function for use as an action handler.
int intf_put_recall_unit(lua_State *L)
Puts a unit on a recall list.
int intf_teleport(lua_State *L)
Teeleports a unit to a location.
void luaW_push_schedule(lua_State *L, int area_index)
int intf_add_tile_overlay(lua_State *L)
Adds an overlay on a tile.
int intf_play_sound(lua_State *L)
Plays a sound, possibly repeated.
void lua_chat(const std::string &caption, const std::string &msg)
int intf_allow_end_turn(lua_State *)
Allow undo sets the flag saying whether the event has mutated the game to false.
int intf_get_village_owner(lua_State *L)
Gets the side of a village owner.
int intf_get_sides(lua_State *L)
Returns a proxy table array for all sides matching the given SSF.
int intf_has_sub_achievement(lua_State *L)
Returns whether an achievement has been completed.
int intf_create_side(lua_State *L)
void initialize(const config &level)
int intf_add_undo_actions(lua_State *L)
Add undo actions for the current active event Arg 1: Either a table of ActionWML or a function to cal...
void save_game(config &level)
Executes the game_events.on_save function and adds to cfg the returned tags.
int impl_scenario_get(lua_State *L)
Gets some scenario data (__index metamethod).
int intf_remove_time_area(lua_State *)
Removing new time_areas dynamically with Standard Location Filters.
int impl_schedule_len(lua_State *L)
int intf_get_locations(lua_State *L)
Gets all the locations matching a given filter.
int intf_add_event(lua_State *L)
Add a new event handler Arg 1: Table of options.
int intf_simulate_combat(lua_State *L)
Simulates a combat between two units.
int impl_get_terrain_list(lua_State *L)
Gets a list of known terrain codes.
std::vector< team > & teams()
int intf_progress_achievement(lua_State *L)
Progresses the provided achievement.
int intf_match_location(lua_State *L)
Matches a location against the given filter.
int intf_toggle_fog(lua_State *L, const bool clear)
Implements the lifting and resetting of fog via WML.
int intf_extract_unit(lua_State *L)
Extracts a unit from the map or a recall list and gives it to Lua.
int intf_log(lua_State *L)
Logs a message Arg 1: (optional) Logger; "wml" for WML errors or deprecations Arg 2: Message Arg 3: W...
int intf_clear_messages(lua_State *)
Removes all messages from the chat window.
int intf_allow_undo(lua_State *)
Allow undo sets the flag saying whether the event has mutated the game to false.
int impl_schedule_get(lua_State *L)
int intf_set_variable(lua_State *L)
Sets a WML variable.
int impl_theme_items_set(lua_State *L)
Sets a field of the theme_items table (__newindex metamethod).
void set_game_display(game_display *gd)
int intf_set_menu_item(lua_State *L)
ai::lua_ai_action_handler * create_lua_ai_action_handler(char const *code, ai::lua_ai_context &context)
bool mouse_button_callback(const map_location &loc, const std::string &button, const std::string &event)
int intf_get_achievement(lua_State *L)
Returns information on a single achievement, or no data if the achievement is not found.
std::vector< int > get_sides_vector(const vconfig &cfg)
Gets a vector of sides from side= attribute in a given config node.
int intf_fire_event(lua_State *L, const bool by_id)
Fires an event.
int intf_delay(lua_State *L)
Delays engine for a while.
int intf_add_event_simple(lua_State *L)
Add a new event handler Arg 1: Event to handle, as a string or list of strings; or menu item ID if th...
bool run_filter(char const *name, const unit &u)
Runs a script from a unit filter.
int intf_find_vision_range(lua_State *L)
Finds all the locations for which a given unit would remove the fog (if there was fog on the map).
int intf_skip_messages(lua_State *L)
Set whether to skip messages Arg 1 (optional) - boolean.
game_display * game_display_
int cfun_undoable_event(lua_State *L)
Upvalue 1: The event function Upvalue 2: The undo function Arg 1: The event content.
void load_game(const config &level)
Executes the game_events.on_load function and passes to it all the scenario tags not yet handled.
int intf_get_time_of_day(lua_State *L)
Gets time of day information.
int intf_get_color_adjust(lua_State *L)
int intf_is_skipping_messages(lua_State *L)
Return true if a replay is in progress but the player has chosen to skip it.
void add_side_wml(config cfg)
creates a new side during a game.
const std::unique_ptr< actions::undo_list > undo_stack_
undo_stack_ is never nullptr.
const std::unique_ptr< game_events::manager > events_manager_
game_events::wmi_manager & get_wml_menu_items()
int w() const
Effective map width.
int h() const
Effective map height.
Encapsulates the map of the game.
const std::shared_ptr< terrain_type_data > & tdata() const
virtual void log_error(char const *msg, char const *context="Lua error")
Error reporting mechanisms, used by virtual methods protected_call and load_string.
bool load_string(const std::string &prog, const std::string &name, const error_handler &, bool allow_unsafe=false)
void run_lua_tag(const config &cfg)
Runs a [lua] tag.
Storage for a unit, either owned by the Lua code (ptr != 0), a local variable unit (c_ptr !...
bool put_map(const map_location &loc)
int on_recall_list() const
unit_ptr get_shared() const
const terrain_label * set_label(const map_location &loc, const t_string &text, const int creator=-1, const std::string &team="", const color_t color=font::NORMAL_COLOR, const bool visible_in_fog=true, const bool visible_in_shroud=false, const bool immutable=false, const std::string &category="", const t_string &tooltip="")
const terrain_label * get_label(const map_location &loc, const std::string &team_name) const
void recalculate_shroud()
game_classification & get_classification()
events::mouse_handler & get_mouse_handler_base() override
Get a reference to a mouse handler member a derived class uses.
bool is_skipping_story() const
bool is_skipping_replay() const
std::shared_ptr< wb::manager > get_whiteboard() const
virtual void force_end_turn()=0
game_events::wml_event_pump & pump()
std::set< std::string > & encountered_units()
int progress_achievement(const std::string &content_for, const std::string &id, int limit=999999, int max_progress=999999, int amount=0)
Increments the achievement's current progress by amount if it hasn't already been completed.
void set_achievement(const std::string &content_for, const std::string &id)
Marks the specified achievement as completed.
void set_sub_achievement(const std::string &content_for, const std::string &id, const std::string &sub_id)
Marks the specified sub-achievement as completed.
void add_log_data(const std::string &key, const std::string &var)
config generate_report(const std::string &name, const context &ct, bool only_static=false)
void register_generator(const std::string &name, generator *)
const std::set< std::string > & report_list()
An object to leave the synced context during draw or unsynced wml items when we don’t know whether we...
std::vector< int > get_teams() const
bool match(const team &t) const
static map & registry()
using static function variable instead of static member variable to prevent static initialization fia...
static synced_state get_synced_state()
This class stores all the data for a single 'side' (in game nomenclature).
game_events::pump_result_t get_village(const map_location &, const int owner_side, game_data *fire_event)
Acquires a village from owner_side.
const std::string & team_name() const
void set_color(const std::string &color)
void set_flag(const std::string &flag)
void lose_village(const map_location &)
bool match(const map_location &loc) const
void get_locations(std::set< map_location > &locs, bool with_border=false) const
gets all locations on the map that match this filter
To store label data Class implements logic for rendering.
const std::string & id() const
t_translation::terrain_code number() const
void replace_schedule(const config &time_cfg)
Replace the time of day schedule.
int number_of_turns() const
const time_of_day get_illuminated_time_of_day(const unit_map &units, const gamemap &map, const map_location &loc, int for_turn=0) const
Returns time of day object for the passed turn at a location.
const std::vector< time_of_day > & times(const map_location &loc=map_location::null_location()) const
std::vector< std::string > get_area_ids() const
const std::set< map_location > & get_area_by_index(int index) const
void remove_time_area(const std::string &id)
Removes a time area from config, making it follow the scenario's normal time-of-day sequence.
void add_time_area(const gamemap &map, const config &cfg)
Adds a new local time area from config, making it follow its own time-of-day sequence.
void replace_local_schedule(const std::vector< time_of_day > &schedule, int area_index, int initial_time=0)
const time_of_day & get_time_of_day(int for_turn=0) const
Returns global time of day for the passed turn.
const std::set< map_location > & get_area_by_id(const std::string &id) const
std::pair< int, std::string > get_area_on_hex(const map_location &loc) const
void reset_affect_adjacent(const unit_map &units)
Refresh map around unit if has ability with [affect_adjacent/distant] tag.
void wait_for_end() const
void add_animation(unit_const_ptr animated_unit, const unit_animation *animation, const map_location &src=map_location::null_location(), bool with_bars=false, const std::string &text="", const color_t text_color={0, 0, 0})
std::vector< const unit * > all_matches_with_unit(const unit &u) const
std::vector< const unit * > all_matches_at(const map_location &loc) const
std::vector< const unit * > all_matches_on_map(const map_location *loc=nullptr, const unit *other_unit=nullptr) const
Container associating units to locations.
unit_ptr extract(const map_location &loc)
Extracts a unit from the map.
unit_iterator find(std::size_t id)
std::size_t erase(const map_location &l)
Erases the unit at location l, if any.
umap_retval_pair_t insert(const unit_ptr &p)
Inserts the unit pointed to by p into the map.
umap_retval_pair_t move(const map_location &src, const map_location &dst)
Moves a unit from location src to location dst.
const unit_type * find(const std::string &key, unit_type::BUILD_STATUS status=unit_type::FULL) const
Finds a unit_type by its id() and makes sure it is built to the specified level.
config_array_view traits() const
A single unit type that the player may recruit.
const unit_type & get_variation(const std::string &id) const
bool has_variation(const std::string &variation_id) const
This class represents a single unit of a specific type.
static void clear_status_caches()
Clear this unit status cache for all units.
static unit_ptr create(const config &cfg, bool use_traits=false, const vconfig *vcfg=nullptr)
Initializes a unit from a config.
Additional functionality for a non-const variable_info.
Information on a WML variable.
A variable-expanding proxy for the config class.
static vconfig unconstructed_vconfig()
This is just a wrapper for the default constructor; it exists for historical reasons and to make it c...
vconfig child(const std::string &key) const
Returns a child of *this whose key is key.
const config & get_config() const
config get_parsed_config() const
child_list get_children(const std::string &key) const
constexpr uint8_t ALPHA_OPAQUE
A component of the AI framework.
Composite AI with turn sequence which is a vector of stages.
Define conditionals for the game's events mechanism, a.k.a.
Definitions for the interface to Wesnoth Markup Language (WML).
Managing the AIs configuration - headers.
std::string deprecated_message(const std::string &elem_name, DEP_LEVEL level, const version_info &version, const std::string &detail)
LUA AI Support engine - creating specific ai components from config.
Define locations as used by the game's events mechanism.
static int intf_modify_ai(lua_State *L, const char *action)
int dispatch(lua_State *L)
static int load_fake_units(lua_State *L, int arg, T &fake_units)
static int impl_animator_get(lua_State *L)
#define SCENARIO_SETTER(name, type)
static int impl_null_callback(lua_State *L)
static int impl_animator_collect(lua_State *L)
#define SCENARIO_GETTER(name, type)
static int intf_unit_resistance(lua_State *L)
Returns unit resistance against a given attack type.
static int intf_synchronize_choice(lua_State *L)
Ensures a value is synchronized among all the clients.
static int luaW_check_schedule(lua_State *L, int idx)
#define SCENARIO_VALID(name)
static lg::log_domain log_scripting_lua("scripting/lua")
static int intf_add_known_unit(lua_State *L)
Adds a new known unit type to the help system.
static int intf_append_ai(lua_State *L)
static int impl_end_level_data_collect(lua_State *L)
static int impl_mp_settings_len(lua_State *L)
#define CURRENT_GETTER(name, type)
#define READ_ONE_FILTER(key, tag)
#define SCHEDULE_SETTER(name, type)
luaW_Registry scenarioReg
bool(*)(const vconfig &) wml_conditional_handler
static int cfun_exec_candidate_action(lua_State *L)
static int intf_run_event_wml(lua_State *L)
static int intf_eval_conditional(lua_State *L)
Evaluates a boolean WML conditional.
luaW_Registry & gameConfigReg()
static int impl_clear_animation(lua_State *L)
static int intf_advance_unit(lua_State *L)
Advances a unit if the unit has enough xp.
static int impl_add_animation(lua_State *L)
static int intf_debug_ai(lua_State *L)
Debug access to the ai tables.
#define GAME_CONFIG_SIMPLE_SETTER(name)
static int intf_unit_movement_cost(lua_State *L)
Returns unit movement cost on a given terrain.
static int intf_add_modification(lua_State *L)
Adds a modification to a unit.
#define SCHEDULE_GETTER(name, type)
static void luaW_pushsimdata(lua_State *L, const combatant &cmb)
Puts a table at the top of the stack with some combat result.
#define CALLBACK_GETTER(name, type)
static std::string read_event_name(lua_State *L, int idx)
static int intf_remove_modifications(lua_State *L)
Removes modifications from a unit.
int dispatch2(lua_State *L)
static int intf_copy_unit(lua_State *L)
Copies a unit.
static void push_component(lua_State *L, ai::component *c, const std::string &ct="")
static int impl_mp_settings_get(lua_State *L)
static int cfun_exec_stage(lua_State *L)
static int impl_game_events_get(lua_State *L)
static int intf_modify_ai_old(lua_State *L)
Lua frontend to the modify_ai functionality.
static int intf_get_resource(lua_State *L)
Gets a table for an resource tag.
static const char animatorKey[]
static bool is_handled_file_tag(std::string_view s)
These are the child tags of [scenario] (and the like) that are handled elsewhere (in the C++ code).
static int intf_synchronize_choices(lua_State *L)
Ensures a value is synchronized among all the clients.
static int intf_switch_ai(lua_State *L)
static int intf_create_unit(lua_State *L)
Creates a unit from its WML description.
static int intf_transform_unit(lua_State *L)
Changes a unit to the given unit type.
static int impl_floating_label_getmethod(lua_State *L)
static int intf_get_viewing_side(lua_State *L)
Gets currently viewing side.
int(game_lua_kernel::* member_callback)(lua_State *)
int(game_lua_kernel::* member_callback2)(lua_State *, bool)
static int intf_invoke_synced_command(lua_State *L)
static void luaW_push_tod(lua_State *L, const time_of_day &tod)
static int intf_do_unsynced(lua_State *L)
Calls a function in an unsynced context (this specially means that all random calls used by that func...
luaW_Registry scheduleReg
static void luaW_pushsimweapon(lua_State *L, const battle_context_unit_stats &bcustats)
Puts a table at the top of the stack with information about the combatants' weapons.
static int intf_handle_user_interact(lua_State *)
static int intf_unit_jamming_cost(lua_State *L)
Returns unit jamming cost on a given terrain.
static int impl_end_level_data_get(lua_State *L)
static lg::log_domain log_wml("wml")
static int intf_unit_defense(lua_State *L)
Returns unit defense on a given terrain.
static int intf_get_era(lua_State *L)
Gets a table for an era tag.
static bool impl_get_callback(lua_State *L, const std::string &name)
#define SCHEDULE_VALID(name)
static int cfun_wml_condition(lua_State *L)
Executes its upvalue as a wml condition and returns the result.
luaW_Registry callbacksReg
static int * luaW_check_floating_label(lua_State *L, int idx)
static int impl_game_events_dir(lua_State *L)
static int intf_unit_vision_cost(lua_State *L)
Returns unit vision cost on a given terrain.
static std::string _(const char *str)
bool get_ability_bool(const std::string &tag_name, const map_location &loc) const
Checks whether this unit currently possesses or is affected by a given ability.
const std::string & id() const
Gets this unit's id.
int side() const
The side this unit belongs to.
void advance_to(const unit_type &t, bool use_traits=false)
Advances this unit to another type.
int defense_modifier(const t_translation::terrain_code &terrain) const
The unit's defense on a given terrain.
int resistance_against(const std::string &damage_name, bool attacker, const map_location &loc, const_attack_ptr weapon=nullptr, const const_attack_ptr &opp_weapon=nullptr) const
The unit's resistance against a given damage type.
unit_animation_component & anim_comp() const
void add_modification(const std::string &type, const config &modification, bool no_add=false)
Add a new modification to the unit.
static const std::set< std::string > builtin_effects
std::string describe_builtin_effect(const std::string &type, const config &effect)
Construct a string describing a built-in effect.
config & get_modifications()
Get the raw modifications.
void expire_modifications(const std::string &duration)
Clears those modifications whose duration has expired.
void apply_builtin_effect(const std::string &type, const config &effect)
Apply a builtin effect to the unit.
const map_location & get_location() const
The current map location this unit is at.
int movement_cost(const t_translation::terrain_code &terrain) const
Get the unit's movement cost on a particular terrain.
int vision_cost(const t_translation::terrain_code &terrain) const
Get the unit's vision cost on a particular terrain.
int jamming_cost(const t_translation::terrain_code &terrain) const
Get the unit's jamming cost on a particular terrain.
std::string label
What to show in the filter's drop-down list.
std::string id
Text to match against addon_info.tags()
Define the handlers for the game's events mechanism.
bool tiles_adjacent(const map_location &a, const map_location &b)
Function which tells if two locations are adjacent.
Standard logging facilities (interface).
#define log_scope(description)
std::decay_t< T > lua_check(lua_State *L, int n)
void luaW_pushconfig(lua_State *L, const config &cfg)
Converts a config object to a Lua table pushed at the top of the stack.
bool luaW_iststring(lua_State *L, int index)
void luaW_push_namedtuple(lua_State *L, const std::vector< std::string > &names)
Push an empty "named tuple" onto the stack.
config luaW_checkconfig(lua_State *L, int index)
Converts an optional table or vconfig to a config object.
void luaW_pushlocation(lua_State *L, const map_location &ml)
Converts a map location object to a Lua table pushed at the top of the stack.
std::set< map_location > luaW_check_locationset(lua_State *L, int idx)
Converts a table of integer pairs to a set of map location objects.
void luaW_pushtstring(lua_State *L, const t_string &v)
Pushes a t_string on the top of the stack.
bool luaW_pushvariable(lua_State *L, variable_access_const &v)
bool luaW_tovconfig(lua_State *L, int index, vconfig &vcfg)
Gets an optional vconfig from either a table or a userdata.
void luaW_pushvconfig(lua_State *L, const vconfig &cfg)
Pushes a vconfig on the top of the stack.
bool luaW_toboolean(lua_State *L, int n)
int luaW_type_error(lua_State *L, int narg, const char *tname)
std::string_view luaW_tostring(lua_State *L, int index)
bool luaW_getmetafield(lua_State *L, int idx, const char *key)
Like luaL_getmetafield, but returns false if key is an empty string or begins with two underscores.
bool luaW_totstring(lua_State *L, int index, t_string &str)
Converts a scalar to a translatable string.
bool luaW_tableget(lua_State *L, int index, const char *key)
bool luaW_checkvariable(lua_State *L, variable_access_create &v, int n)
bool luaW_pcall(lua_State *L, int nArgs, int nRets, bool allow_wml_error)
Calls a Lua function stored below its nArgs arguments at the top of the stack.
bool luaW_toconfig(lua_State *L, int index, config &cfg)
Converts an optional table or vconfig to a config object.
int luaW_push_locationset(lua_State *L, const std::set< map_location > &locs)
Converts a set of map locations to a Lua table pushed at the top of the stack.
vconfig luaW_checkvconfig(lua_State *L, int index, bool allow_missing)
Gets an optional vconfig from either a table or a userdata.
bool luaW_tolocation(lua_State *L, int index, map_location &loc)
Converts an optional table or pair of integers to a map location object.
map_location luaW_checklocation(lua_State *L, int index)
Converts an optional table or pair of integers to a map location object.
bool luaW_getglobal(lua_State *L, const std::vector< std::string > &path)
Pushes the value found by following the variadic names (char *), if the value is not nil.
t_string luaW_checktstring(lua_State *L, int index)
Converts a scalar to a translatable string.
#define return_cstring_attrib(name, accessor)
#define return_string_attrib(name, accessor)
#define return_cfgref_attrib(name, accessor)
#define return_int_attrib(name, accessor)
#define modify_bool_attrib(name, accessor)
#define return_bool_attrib(name, accessor)
#define return_cfg_attrib(name, accessor)
#define modify_string_attrib(name, accessor)
#define return_string_attrib_deprecated(name, prefix, level, version, msg, accessor)
#define GAME_CONFIG_GETTER(name, type, kernel_type)
void luaW_pushracetable(lua_State *L)
void luaW_pushteam(lua_State *L, team &tm)
Create a full userdata containing a pointer to the team.
team * luaW_toteam(lua_State *L, int idx)
Test if the top stack element is a team, and if so, return it.
team & luaW_checkteam(lua_State *L, int idx)
Test if the top stack element is a team, and if not, error.
std::set< map_location > location_set
int intf_terrain_mask(lua_State *L)
Replaces part of the map.
int intf_on_border(lua_State *L)
int intf_on_board(lua_State *L)
int intf_terrainmap_iter(lua_State *L)
int intf_terrainmap_get(lua_State *L)
int intf_replace_if_failed(lua_State *L)
lua_unit * luaW_checkunit_ref(lua_State *L, int index)
Similar to luaW_checkunit but returns a lua_unit; use this if you need to handle map and recall units...
unit & luaW_checkunit(lua_State *L, int index, bool only_on_map)
Converts a Lua value to a unit pointer.
bool luaW_isunit(lua_State *L, int index)
Test if a Lua value is a unit.
unit_ptr luaW_checkunit_ptr(lua_State *L, int index, bool only_on_map)
Similar to luaW_checkunit but returns a unit_ptr; use this instead of luaW_checkunit when using an ap...
lua_unit * luaW_pushlocalunit(lua_State *L, unit &u)
Pushes a private unit on the stack.
unit * luaW_tounit(lua_State *L, int index, bool only_on_map)
Converts a Lua value to a unit pointer.
lua_unit * luaW_pushunit(lua_State *L, Args... args)
int intf_create_attack(lua_State *L)
const_attack_ptr luaW_toweapon(lua_State *L, int idx)
void luaW_pushweapon(lua_State *L, const attack_ptr &weapon)
std::map< std::string, config > traits_map
bool clear_shroud(int side, bool reset_fog, bool fire_events)
Function that will clear shroud (and fog) based on current unit positions.
game_events::pump_result_t get_village(const map_location &loc, int side, bool *action_timebonus, bool fire_event)
Makes it so the village at the given location is owned by the given side.
void create_jamming_map(std::map< map_location, int > &jamming, const team &view_team)
Helper function that creates the map of enemy anti-vision that's needed when creating a pathfinding::...
void clear()
Clear the current render target.
const color_t LABEL_COLOR
int add_floating_label(const floating_label &flabel)
add a label floating on the screen above everything else.
void remove_floating_label(int handle, const std::chrono::milliseconds &fadeout)
removes the floating label given by 'handle' from the screen
void move_floating_label(int handle, double xmove, double ymove)
moves the floating label given by 'handle' by (xmove,ymove)
Game configuration data as global variables.
void load_config(const config &v)
bool variable_matches(const vconfig &values)
bool have_location(const vconfig &cfg)
bool have_unit(const vconfig &cfg)
bool conditional_passed(const vconfig &cond)
bool fire_event(const ui_event event, const std::vector< std::pair< widget *, ui_event >> &event_chain, widget *dispatcher, widget *w, F &&... params)
Helper function for fire_event.
std::shared_ptr< halo_record > handle
std::stringstream & log_to_chat()
Use this to show WML errors in the ingame chat.
std::string register_table(lua_State *L)
std::string register_vconfig_metatable(lua_State *L)
Adds the vconfig metatable.
int intf_tovconfig(lua_State *L)
Creates a vconfig containing the WML table.
void set_functions(lua_State *L, const std::vector< lua_cpp::Reg > &functions)
Analogous to lua_setfuncs, it registers a collection of function wrapper objects into a table,...
void push_closure(lua_State *L, const lua_function &f, int nup)
Pushes a closure which retains a std::function object as its first up-value.
int intf_show_recall_dialog(lua_State *L)
int intf_show_recruit_dialog(lua_State *L)
int show_gamestate_inspector(const std::string &name, const game_data &data, const game_state &state)
std::string register_metatable(lua_State *L)
std::string register_metatable(lua_State *L)
std::string register_metatables(lua_State *L)
std::string register_metatable(lua_State *L)
std::string register_table(lua_State *L)
std::string register_metatables(lua_State *L)
std::string register_attacks_metatables(lua_State *L)
std::string tag(std::string_view tag, Args &&... data)
Wraps the given data in the specified tag.
config get_user_choice(const std::string &name, const user_choice &uch, int side=0)
std::map< int, config > get_user_choice_multiple_sides(const std::string &name, const user_choice &uch, std::set< int > sides)
Performs a choice for multiple sides for WML events.
plain_route a_star_search(const map_location &src, const map_location &dst, double stop_at, const cost_calculator &calc, const std::size_t width, const std::size_t height, const teleport_map *teleports, bool border)
const teleport_map get_teleport_locations(const unit &u, const team &viewing_team, bool see_all, bool ignore_units, bool check_vision)
map_location find_vacant_tile(const map_location &loc, VACANT_TILE_TYPE vacancy, const unit *pass_check, const team *shroud_check, const game_board *board)
Function that will find a location on the board that is as near to loc as possible,...
Unit and team statistics.
fake_unit_manager * fake_units
play_controller * controller
std::shared_ptr< wb::manager > whiteboard
Contains the general settings which have a default.
void play_sound(const std::string &files, channel_group group, unsigned int repeats)
terrain_code read_terrain_code(std::string_view str, const ter_layer filler)
Reads a single terrain from a string.
std::string write_terrain_code(const terrain_code &tcode)
Writes a single terrain code to a string.
const terrain_code NONE_TERRAIN
void move_unit(const std::vector< map_location > &path, const unit_ptr &u, bool animate, map_location::direction dir, bool force_scroll)
Display a unit moving along a given path.
std::size_t size(std::string_view str)
Length in characters of a UTF-8 string.
std::size_t index(std::string_view str, const std::size_t index)
Codepoint index corresponding to the nth character in a UTF-8 string.
@ STRIP_SPACES
REMOVE_EMPTY: remove empty elements.
int stoi(std::string_view str)
Same interface as std::stoi and meant as a drop in replacement, except:
std::string join_map(const T &v, const std::string &major=",", const std::string &minor=":")
std::string join(const T &v, const std::string &s=",")
Generates a new string joining container items in a list.
std::vector< std::string > split(const config_attribute_value &val)
auto * find(Container &container, const Value &value)
Convenience wrapper for using find on a container without needing to comare to end()
bool headless()
The game is running headless.
static void msg(const char *act, debug_info &i, const char *to="", const char *result="")
This module contains various pathfinding functions and utilities.
std::shared_ptr< const unit > unit_const_ptr
std::shared_ptr< const attack_type > const_attack_ptr
std::shared_ptr< unit > unit_ptr
Define the game's event mechanism.
void lua_push(lua_State *L, const T &val)
std::decay_t< T > luaW_table_get_def(lua_State *L, int index, std::string_view k, const T &def)
returns t[k] where k is the table at index index and k is k or def if it is not convertible to the co...
void luaW_table_set(lua_State *L, int index, std::string_view k, const T &value)
candidate action framework
#define ON_SCOPE_EXIT(...)
Run some arbitrary code (a lambda) when the current scope exits The lambda body follows this header,...
rect dst
Location on the final composed sheet.
rect src
Non-transparent portion of the surface to compose.
A set of achievements tied to a particular content.
Represents a single achievement and its data.
std::string icon_completed_
The icon of the achievement to show on the UI if the achievement is completed.
t_string name_completed_
The name of the achievement to show on the UI if the achievement is completed.
t_string description_completed_
The name of the achievement to show on the UI if the achievement is completed.
bool achieved_
Whether the achievement has been completed.
std::string id_
The ID of the achievement.
int max_progress_
When the achievement's current progress matches or equals this value, then it should be marked as com...
std::string sound_path_
The path to a sound to play when an achievement is completed.
int current_progress_
The current progress value of the achievement.
std::vector< sub_achievement > sub_achievements_
The list of distinct sub-achievements for this achievement.
advances the unit at loc if it has enough experience, maximum 20 times.
advance_unit_params & animate(bool value)
advance_unit_params & fire_events(bool value)
Structure describing the statistics of a unit involved in the battle.
bool slows
Attack slows opponent when it hits.
unsigned int num_blows
Effective number of blows, takes swarm into account.
std::string plague_type
The plague type used by the attack, if any.
bool petrifies
Attack petrifies opponent when it hits.
int drain_percent
Percentage of damage recovered as health.
bool drains
Attack drains opponent when it hits.
const_attack_ptr weapon
The weapon used by the unit to attack the opponent, or nullptr if there is none.
unsigned int rounds
Berserk special can force us to fight more than one round.
int damage
Effective damage of the weapon (all factors accounted for).
bool poisons
Attack poisons opponent when it hits.
unsigned int chance_to_hit
Effective chance to hit as a percentage (all factors accounted for).
int drain_constant
Base HP drained regardless of damage dealt.
bool firststrike
Attack has firststrike special.
int attack_num
Index into unit->attacks() or -1 for none.
bool plagues
Attack turns opponent into a zombie when fatal.
callbacks_tag(game_lua_kernel &k)
The basic class for representing 8-bit RGB or RGBA colour values.
static color_t from_hex_string(std::string_view c)
Creates a new color_t object from a string variable in hex format.
static color_t from_rgb_string(std::string_view c)
Creates a new opaque color_t object from a string variable in "R,G,B" format.
double slowed
Resulting chance we are slowed.
std::vector< double > hp_dist
Resulting probability distribution (might be not as large as max_hp)
double poisoned
Resulting chance we are poisoned.
double average_hp(unsigned int healing=0) const
What's the average hp (weighted average of hp_dist).
double untouched
Resulting chance we were not hit by this opponent (important if it poisons)
void push_schedule(lua_State *L) const
current_tag(game_lua_kernel &k)
Additional information on the game outcome which can be provided by WML.
Error used for any general game error, e.g.
game_config_glk_tag(lua_kernel_base &k)
const map_location & filter_loc() const
Represents a single filter condition on an event.
Holds a lookup table for members of one type of object.
int dir(lua_State *L)
Implement __dir metamethod.
int set(lua_State *L)
Implement __newindex metamethod.
int get(lua_State *L)
Implement __index metamethod.
void serialize(config &cfg) const override
Serializes the filter into a config, if possible.
lua_event_filter(game_lua_kernel &lk, int idx, const config &args)
bool operator()(const game_events::queued_event &event_info) const override
Runs the filter and returns whether it passes on the given event.
static game_lua_kernel & get(lua_State *L, int)
static game_lua_kernel & get(lua_State *L, int)
static scenario_tag get(lua_State *L, int)
static schedule_tag get(lua_State *L, int n)
Cost function object relying on a Lua function.
Encapsulates the map of the game.
static const map_location & null_location()
game_lua_kernel * kernel_
map_locker(game_lua_kernel *kernel)
Interface for querying local choices.
virtual config query_user(int side) const =0
virtual std::string description() const
virtual bool is_visible() const
whether the choice is visible for the user like an advancement choice a non-visible choice is for exa...
virtual config random_choice(int side) const =0
Structure which uses find_routes() to build a cost map This maps each hex to a the movements a unit w...
void add_unit(const unit &u, bool use_max_moves=true)
Adds a units cost map to cost_map (increments the elements in cost_map)
std::pair< int, int > get_pair_at(map_location loc) const
Accessor for the cost/reach-amount pairs.
Object which contains all the possible locations a unit can move to, with associated best routes to t...
Structure which holds a single route between one location and another.
std::vector< map_location > steps
int move_cost
Movement cost for reaching the end of the route.
A refinement of paths for use when calculating vision.
std::set< map_location > edges
The edges are the non-destination hexes bordering the destinations.
An abstract description of a rectangle with integer coordinates.
scenario_tag(game_lua_kernel &k)
auto end_level_set() const
schedule_tag(game_lua_kernel &k)
static std::string get_string(enum_type key)
Converts a enum to its string equivalent.
static constexpr utils::optional< enum_type > get_enum(const std::string_view value)
Converts a string into its enum equivalent.
Represents a distinct sub-achievement within another achievement.
std::string id_
The ID of the sub-achievement.
bool achieved_
Whether the sub-achievement has been completed.
A terrain string which is converted to a terrain is a string with 1 or 2 layers the layers are separa...
Object which defines a time of day with associated bonuses, image, sounds etc.
tod_color color
The color modifications that should be made to the game board to reflect the time of day.
int lawful_bonus
The % bonus lawful units receive.
std::string image
The image to be displayed in the game status.
std::string sounds
List of "ambient" sounds associated with this time_of_day, Played at the beginning of turn.
std::string image_mask
The image that is to be laid over all images while this time of day lasts.
pointer get_shared_ptr() const
This is exactly the same as operator-> but it's slightly more readable, and can replace &*iter syntax...
static map_location::direction n
static map_location::direction s
unit_type_data unit_types
Display units performing various actions: moving, attacking, and dying.
Various functions that implement the undoing (and redoing) of in-game commands.
Various functions implementing vision (through fog of war and shroud).