19 #include "formula/callable_objects.hpp" 27 #include <boost/math/constants/constants.hpp> 34 #define DBG_NG LOG_STREAM(debug, log_engine) 36 #define LOG_SF LOG_STREAM(info, log_scripting_formula) 37 #define WRN_SF LOG_STREAM(warn, log_scripting_formula) 38 #define ERR_SF LOG_STREAM(err, log_scripting_formula) 50 call_stack_manager::call_stack_manager(
const std::string& str)
52 call_stack.push_back(str);
55 call_stack_manager::~call_stack_manager()
57 call_stack.pop_back();
62 std::ostringstream res;
63 for(
const auto& frame : call_stack) {
65 res <<
" " << frame <<
"\n";
72 std::string function_expression::str()
const 77 bool first_arg =
true;
94 std::shared_ptr<formula_debugger> fdbp;
95 bool need_wrapper =
false;
103 if(args().
size() == 1) {
105 return args()[0]->evaluate(variables, fdb);
116 variant var = args()[0]->evaluate(variables, fdb);
121 std::vector<variant> res;
122 for(std::size_t
i = 0;
i < inputs.size(); ++
i) {
124 res.emplace_back(input.
name);
132 for(std::size_t
n = 0;
n < args().size() - 1;
n += 2) {
133 if(args()[
n]->evaluate(variables, fdb).as_bool()) {
134 return args()[
n + 1]->evaluate(variables, fdb);
138 if((args().
size() % 2) != 0) {
139 return args().back()->evaluate(variables, fdb);
147 variant var = args()[0]->evaluate(variables, fdb);
149 for(std::size_t
n = 1;
n < args().size() - 1;
n += 2) {
150 variant val = args()[
n]->evaluate(variables, fdb);
153 return args()[
n + 1]->evaluate(variables, fdb);
157 if((args().
size() % 2) == 0) {
158 return args().back()->evaluate(variables, fdb);
166 const variant input = args()[0]->evaluate(variables, fdb);
169 return variant(n >= 0 ? n : -n, variant::DECIMAL_VARIANT);
172 return variant(n >= 0 ? n : -n);
178 variant res = args()[0]->evaluate(variables, fdb);
184 res = *std::min_element(res.
begin(), res.
end());
187 for(std::size_t
n = 1;
n < args().size(); ++
n) {
188 variant v = args()[
n]->evaluate(variables, fdb);
195 v = *std::min_element(v.
begin(), v.
end());
208 variant res = args()[0]->evaluate(variables, fdb);
214 res = *std::max_element(res.
begin(), res.
end());
217 for(std::size_t
n = 1;
n < args().size(); ++
n) {
218 variant v = args()[
n]->evaluate(variables, fdb);
225 v = *std::max_element(v.
begin(), v.
end());
238 void display_float(
const map_location& location,
const std::string& text)
246 const args_list& arguments = args();
247 const variant var0 = arguments[0]->evaluate(variables, fdb);
248 const variant var1 = arguments[1]->evaluate(variables, fdb);
253 if(arguments.size() == 2) {
255 display_float(location, text);
258 const variant var2 = arguments[2]->evaluate(variables, fdb);
260 display_float(location, text);
267 const variant var1 = args()[0]->evaluate(variables, fdb);
269 std::string str1, str2;
271 if(args().
size() == 1) {
285 const variant var2 = args()[1]->evaluate(variables, fdb);
288 LOG_SF << str1 <<
": " << str2;
301 std::string speaker =
"WFL";
304 if(args().
size() == 2) {
305 speaker = args()[0]->evaluate(variables, fdb).string_cast();
309 const variant value = args()[i_value]->evaluate(variables, fdb);
312 for(
int i = 1;
i < 1000;
i++) {
313 const long start = SDL_GetTicks();
314 args()[i_value]->evaluate(variables, fdb);
315 run_time += SDL_GetTicks() -
start;
318 std::ostringstream str;
319 str <<
"Evaluated in " << (run_time / 1000.0) <<
" ms on average";
321 LOG_SF << speaker <<
": " << str.str();
333 const variant map = args()[0]->evaluate(variables, fdb);
339 const variant map = args()[0]->evaluate(variables, fdb);
345 const variant var = args()[0]->evaluate(variables, fdb);
347 std::vector<variant> tmp;
357 const variant var_1 = args()[0]->evaluate(variables, fdb);
359 std::map<variant, variant> tmp;
361 if(args().
size() == 2) {
362 const variant var_2 = args()[1]->evaluate(variables, fdb);
368 tmp[var_1[
i]] = var_2[
i];
373 tmp[kv->query_value(
"key")] = kv->query_value(
"value");
375 auto map_it = tmp.find(*it);
377 if(map_it == tmp.end()) {
380 map_it->second =
variant(map_it->second.as_int() + 1);
391 std::string result = args()[0]->evaluate(variables, fdb).as_string();
393 int offset = args()[1]->evaluate(variables, fdb).as_int();
395 offset += result.size();
401 if(static_cast<std::size_t>(offset) >= result.size()) {
406 if(args().
size() > 2) {
407 int size = args()[2]->evaluate(variables, fdb).as_int();
411 offset = std::max(0, offset - size + 1);
414 return variant(result.substr(offset, size));
417 return variant(result.substr(offset));
422 std::string result = args()[0]->evaluate(variables, fdb).as_string();
423 std::string replacement = args().back()->evaluate(variables, fdb).as_string();
425 int offset = args()[1]->evaluate(variables, fdb).as_int();
427 offset += result.size();
433 if(static_cast<std::size_t>(offset) >= result.size()) {
438 if(args().
size() > 3) {
439 int size = args()[2]->evaluate(variables, fdb).as_int();
443 offset = std::max(0, offset - size + 1);
446 return variant(result.replace(offset, size, replacement));
449 return variant(result.replace(offset, std::string::npos, replacement));
454 std::string result = args()[0]->evaluate(variables, fdb).as_string();
455 std::string
insert = args().back()->evaluate(variables, fdb).as_string();
457 int offset = args()[1]->evaluate(variables, fdb).as_int();
459 offset += result.size();
464 }
else if(static_cast<std::size_t>(offset) >= result.size()) {
465 return variant(result + insert);
468 return variant(result.insert(offset, insert));
473 return variant(args()[0]->evaluate(variables, fdb).as_string().length());
480 result += arg->evaluate(variables, fdb).string_cast();
488 std::string str = args()[0]->evaluate(variables, fdb).as_string();
489 std::transform(str.begin(), str.end(), str.begin(),
static_cast<int (*)(
int)
>(std::toupper));
495 std::string str = args()[0]->evaluate(variables, fdb).as_string();
496 std::transform(str.begin(), str.end(), str.begin(),
static_cast<int (*)(
int)
>(std::tolower));
502 const double angle = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
503 const double result = std::sin(angle * pi<double>() / 180.0);
504 return variant(result, variant::DECIMAL_VARIANT);
509 const double angle = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
510 const double result = std::cos(angle * pi<double>() / 180.0);
511 return variant(result, variant::DECIMAL_VARIANT);
516 const double angle = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
517 const double result = std::tan(angle * pi<double>() / 180.0);
518 if(std::isnan(result) || result <= INT_MIN || result >= INT_MAX) {
522 return variant(result, variant::DECIMAL_VARIANT);
527 const double num = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
528 const double result = std::asin(num) * 180.0 / pi<double>();
529 if(std::isnan(result)) {
533 return variant(result, variant::DECIMAL_VARIANT);
538 const double num = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
539 const double result = std::acos(num) * 180.0 / pi<double>();
540 if(std::isnan(result)) {
544 return variant(result, variant::DECIMAL_VARIANT);
549 if(args().
size() == 1) {
550 const double num = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
551 const double result = std::atan(num) * 180.0 / pi<double>();
552 return variant(result, variant::DECIMAL_VARIANT);
554 const double y = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
555 const double x = args()[1]->evaluate(variables, fdb).as_decimal() / 1000.0;
556 const double result = std::atan2(y, x) * 180.0 / pi<double>();
557 return variant(result, variant::DECIMAL_VARIANT);
563 const double num = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
564 const double result = std::sqrt(num);
565 if(std::isnan(result)) {
569 return variant(result, variant::DECIMAL_VARIANT);
574 const double num = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
575 const double result = num < 0 ? -std::pow(-num, 1.0 / 3.0) : std::pow(num, 1.0 / 3.0);
576 return variant(result, variant::DECIMAL_VARIANT);
581 const double base = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
582 const double root = args()[1]->evaluate(variables, fdb).as_decimal() / 1000.0;
583 const double result = base < 0 && std::fmod(root, 2) == 1 ? -std::pow(-base, 1.0 / root) : std::pow(base, 1.0 / root);
584 if(std::isnan(result)) {
588 return variant(result, variant::DECIMAL_VARIANT);
593 const double num = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
594 if(args().
size() == 1) {
595 const double result = std::log(num);
596 if(std::isnan(result)) {
600 return variant(result, variant::DECIMAL_VARIANT);
603 const double base = args()[1]->evaluate(variables, fdb).as_decimal() / 1000.0;
604 const double result = std::log(num) / std::log(base);
605 if(std::isnan(result)) {
609 return variant(result, variant::DECIMAL_VARIANT);
614 const double num = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
615 const double result = std::exp(num);
616 if(result == 0 || result >= INT_MAX) {
622 return variant(result, variant::DECIMAL_VARIANT);
629 return variant(pi<double>(), variant::DECIMAL_VARIANT);
634 const double x = args()[0]->evaluate(variables, fdb).as_decimal() / 1000.0;
635 const double y = args()[1]->evaluate(variables, fdb).as_decimal() / 1000.0;
636 return variant(std::hypot(x, y), variant::DECIMAL_VARIANT);
641 const variant value = args()[0]->evaluate(variables, fdb);
642 const variant list = args()[1]->evaluate(variables, fdb);
645 if(list[
i] == value) {
655 const variant items = args()[0]->evaluate(variables, fdb);
659 if(args().
size() == 2) {
670 const std::string
self = args()[1]->evaluate(variables, fdb).as_string();
673 self_callable.
add(
self, *it);
675 const variant val = args().back()->evaluate(
694 const int value = args()[0]->evaluate(variables, fdb).as_int() % 1000;
695 const double angle = 2.0 * pi<double>() * (static_cast<double>(value) / 1000.0);
696 return variant(static_cast<int>(std::sin(angle) * 1000.0));
701 const double lo = args()[0]->evaluate(variables,
add_debug_info(fdb, 0,
"lerp:lo")).as_decimal() / 1000.0;
702 const double hi = args()[1]->evaluate(variables,
add_debug_info(fdb, 1,
"lerp:hi")).as_decimal() / 1000.0;;
703 const double alpha = args()[2]->evaluate(variables,
add_debug_info(fdb, 2,
"lerp:alpha")).as_decimal() / 1000.0;;
704 return variant(static_cast<int>((lo + alpha * (hi - lo)) * 1000.0), variant::DECIMAL_VARIANT);
735 return expr_->evaluate(*this).as_bool();
739 variant get_value(
const std::string& key)
const 743 }
else if(key ==
"b") {
763 variant list = args()[0]->evaluate(variables, fdb);
765 std::vector<variant> vars;
769 vars.push_back(list[
n]);
772 if(args().
size() == 1) {
773 std::sort(vars.begin(), vars.end());
775 std::sort(vars.begin(), vars.end(), variant_comparator(args()[1], variables));
783 const variant& arg = args()[0]->evaluate(variables, fdb);
786 std::string str = args()[0]->evaluate(variables, fdb).
as_string();
787 std::reverse(str.begin(), str.end());
791 std::vector<variant> list = args()[0]->evaluate(variables, fdb).as_list();
792 std::reverse(list.begin(), list.end());
802 std::string str = args()[0]->evaluate(variables, fdb).as_string();
803 std::string key = args()[1]->evaluate(variables, fdb).as_string();
805 return variant(str.find(key) != std::string::npos);
810 const std::string str = args()[0]->evaluate(variables, fdb).as_string();
811 const std::string key = args()[1]->evaluate(variables, fdb).as_string();
813 std::size_t pos = str.find(key);
814 return variant(static_cast<int>(pos));
819 std::vector<variant> list_vars;
820 std::map<variant, variant> map_vars;
822 const variant items = args()[0]->evaluate(variables, fdb);
824 if(args().
size() == 2) {
830 map_vars[(*it).get_member(
"key")] = (*it).get_member(
"value");
832 list_vars.push_back(*it);
838 const std::string
self = args()[1]->evaluate(variables, fdb).as_string();
841 self_callable.
add(
self, *it);
843 const variant val = args()[2]->evaluate(
848 map_vars[(*it).get_member(
"key")] = (*it).get_member(
"value");
850 list_vars.push_back(*it);
865 const variant items = args()[0]->evaluate(variables, fdb);
867 if(args().
size() == 2) {
876 const std::string
self = args()[1]->evaluate(variables, fdb).as_string();
879 self_callable.
add(
self, *it);
881 const variant val = args().back()->evaluate(
895 std::vector<variant> list_vars;
896 std::map<variant, variant> map_vars;
897 const variant items = args()[0]->evaluate(variables, fdb);
899 if(args().
size() == 2) {
903 map_vars[(*it).get_member(
"key")] = val;
905 list_vars.push_back(val);
910 const std::string
self = args()[1]->evaluate(variables, fdb).as_string();
913 self_callable.
add(
self, *it);
915 const variant val = args().back()->evaluate(
919 map_vars[(*it).get_member(
"key")] = val;
921 list_vars.push_back(val);
935 const variant&
items = args()[0]->evaluate(variables, fdb);
938 for(; it != items.
end(); ++it) {
946 std::vector<variant> result(items.
begin(), it);
954 explicit indexer(std::size_t
i)
974 bool operator()(
const variant&
a,
const variant&
b)
const 976 return a.num_elements() < b.num_elements();
980 std::vector<variant> get_input(
981 const function_expression::args_list& args,
982 const formula_callable& variables,
983 formula_debugger* fdb)
985 if(args.size() == 1) {
986 const variant list = args[0]->evaluate(variables, fdb);
987 return std::vector<variant>(list.begin(), list.end());
989 std::vector<variant> input;
990 input.reserve(args.size());
993 input.push_back(
expr->evaluate(variables, fdb));
1003 const std::vector<variant> input = get_input(args(), variables, fdb);
1004 std::vector<variant>
output;
1008 std::size_t max_i = std::max_element(input.begin(), input.end(), comparator())->num_elements();
1009 output.reserve(max_i);
1011 for(std::size_t
i = 0;
i < max_i;
i++) {
1012 std::vector<variant> elem(input.size());
1013 std::transform(input.begin(), input.end(), elem.begin(), indexer(
i));
1014 output.emplace_back(elem);
1022 const variant items = args()[0]->evaluate(variables, fdb);
1023 const variant initial = args().size() == 2 ?
variant() : args()[1]->evaluate(variables, fdb);
1031 if(res != initial) {
1036 for(; it != items.
end(); ++it) {
1037 self_callable.
add(
"a", res);
1038 self_callable.
add(
"b", *it);
1039 res = args().back()->evaluate(
1049 const variant items = args()[0]->evaluate(variables, fdb);
1051 if(items[0].is_list()) {
1052 std::vector<variant> tmp;
1054 if(args().
size() >= 2) {
1055 res = args()[1]->evaluate(variables, fdb);
1059 }
else if(items[0].is_map()) {
1060 std::map<variant, variant> tmp;
1062 if(args().
size() >= 2) {
1063 res = args()[1]->evaluate(variables, fdb);
1068 if(args().size() >= 2) {
1069 res = args()[1]->evaluate(variables, fdb);
1075 res = res + items[
n];
1083 const variant items = args()[0]->evaluate(variables, fdb);
1085 if(it == items.
end()) {
1089 if(args().
size() == 1) {
1093 const int n = items.
num_elements(), req = args()[1]->evaluate(variables, fdb).as_int();
1094 const int count = req < 0 ? n - std::min(-req, n) : std::min(req, n);
1097 std::advance(end, count);
1099 std::vector<variant> res;
1100 std::copy(it, end, std::back_inserter(res));
1106 const variant items = args()[0]->evaluate(variables, fdb);
1108 if(it == items.
begin()) {
1112 if(args().
size() == 1) {
1116 const int n = items.
num_elements(), req = args()[1]->evaluate(variables, fdb).as_int();
1117 const int count = req < 0 ? n - std::min(-req, n) : std::min(req, n);
1119 std::advance(it, -count);
1120 std::vector<variant> res;
1122 std::copy(it, items.
end(), std::back_inserter(res));
1128 const variant items = args()[0]->evaluate(variables, fdb);
1134 if(!args().empty()) {
1135 for(std::size_t
i = 0;
i < args().size(); ++
i) {
1136 args()[
i]->evaluate(variables, fdb);
1145 variant decimal = args()[0]->evaluate(variables, fdb);
1148 if((d >= 0) && (d % 1000 != 0)) {
1159 variant decimal = args()[0]->evaluate(variables, fdb);
1166 }
else if(f <= -500) {
1177 variant decimal = args()[0]->evaluate(variables, fdb);
1180 if((d < 0) && (d % 1000 != 0)) {
1191 variant decimal = args()[0]->evaluate(variables, fdb);
1199 variant decimal = args()[0]->evaluate(variables, fdb);
1203 return variant(d, variant::DECIMAL_VARIANT);
1208 variant decimal = args()[0]->evaluate(variables, fdb);
1220 variant decimal = args()[0]->evaluate(variables, fdb);
1223 return variant(d, variant::DECIMAL_VARIANT);
1229 args()[0]->evaluate(variables,
add_debug_info(fdb, 0,
"loc:x")).as_int(),
1236 return variant(std::make_shared<key_value_pair>(
1237 args()[0]->evaluate(variables,
add_debug_info(fdb, 0,
"pair:key")),
1238 args()[1]->evaluate(variables,
add_debug_info(fdb, 1,
"pair_value"))
1245 ->evaluate(variables,
add_debug_info(fdb, 0,
"distance_between:location_A"))
1250 ->evaluate(variables,
add_debug_info(fdb, 1,
"distance_between:location_B"))
1260 ->evaluate(variables,
add_debug_info(fdb, 0,
"adjacent_locs:location"))
1264 std::vector<variant> v;
1266 v.emplace_back(std::make_shared<location_callable>(adj));
1276 int range = args()[1]->evaluate(variables, fdb).as_int();
1283 return variant(std::make_shared<location_callable>(loc));
1286 std::vector<map_location> res;
1290 std::vector<variant> v;
1291 v.reserve(res.size() + 1);
1292 v.emplace_back(std::make_shared<location_callable>(loc));
1294 for(std::size_t
n = 0;
n != res.size(); ++
n) {
1295 v.emplace_back(std::make_shared<location_callable>(res[
n]));
1304 ->evaluate(variables,
add_debug_info(fdb, 0,
"are_adjacent:location_A"))
1309 ->evaluate(variables,
add_debug_info(fdb, 1,
"are_adjacent:location_B"))
1319 ->evaluate(variables,
add_debug_info(fdb, 0,
"relative_dir:location_A"))
1324 ->evaluate(variables,
add_debug_info(fdb, 1,
"relative_dir:location_B"))
1334 ->evaluate(variables,
add_debug_info(fdb, 0,
"direction_from:location"))
1338 const std::string dir_str =
1339 args()[1]->evaluate(variables,
add_debug_info(fdb, 1,
"direction_from:dir")).as_string();
1341 int n = args().size() == 3
1342 ? args()[2]->evaluate(variables,
add_debug_info(fdb, 2,
"direction_from:count")).as_int()
1351 ->evaluate(variables,
add_debug_info(fdb, 0,
"direction_from:center"))
1356 ->evaluate(variables,
add_debug_info(fdb, 1,
"direction_from:location"))
1360 int n = args().size() == 3
1361 ? args()[2]->evaluate(variables,
add_debug_info(fdb, 2,
"direction_from:count")).as_int()
1369 const variant& v = args()[0]->evaluate(variables, fdb);
1379 const variant main = args()[0]->evaluate(variables, fdb);
1382 return variant(std::make_shared<safe_call_callable>(main, backup_formula));
1387 return variant(std::make_shared<set_var_callable>(
1388 args()[0]->evaluate(variables,
add_debug_info(fdb, 0,
"set_var:key")).as_string(),
1389 args()[1]->evaluate(variables,
add_debug_info(fdb, 1,
"set_var:value"))));
1394 variant key_value_pair::get_value(
const std::string& key)
const 1398 }
else if(key ==
"value") {
1407 add_input(inputs,
"key");
1408 add_input(inputs,
"value");
1411 void key_value_pair::serialize_to_string(std::string& str)
const 1414 str += key_.serialize_to_string();
1416 str += value_.serialize_to_string();
1420 formula_function_expression::formula_function_expression(
const std::string& name,
1424 const std::vector<std::string>& arg_names)
1427 , precondition_(precondition)
1428 , arg_names_(arg_names)
1442 static std::string
indent;
1447 const int begin_time = SDL_GetTicks();
1461 DBG_NG <<
"FAILED function precondition for function '" <<
formula_->str() <<
"' with arguments: ";
1464 DBG_NG <<
" arg " << (
n + 1) <<
": " <<
args()[
n]->evaluate(variables, fdb).to_debug_string();
1471 const int taken = SDL_GetTicks() - begin_time;
1472 DBG_NG << indent <<
"returning: " << taken;
1474 indent.resize(indent.size() - 2);
1480 const std::vector<expression_ptr>&
args)
const 1486 : parent(parent ? parent : get_builtins())
1496 const std::string& fn,
const std::vector<expression_ptr>& args)
const 1500 return i->second->generate_function_expression(args);
1515 std::set<std::string> res;
1517 res =
parent->get_function_names();
1531 if(functions_table.
empty()) {
1532 functions_table.
parent =
nullptr;
1534 using namespace builtins;
static DIRECTION parse_direction(const std::string &str)
static lg::log_domain log_engine("engine")
std::string type_string() const
Gets string name of the current value type.
void get_adjacent_tiles(const map_location &a, map_location *res)
Function which, given a location, will place all adjacent locations in res.
DIRECTION get_relative_dir(const map_location &loc, map_location::RELATIVE_DIR_MODE mode) const
int main(int, char **argv)
std::vector< expression_ptr > args_list
formula_debugger * add_debug_info(formula_debugger *fdb, int arg_number, const std::string &f_name)
void get_tiles_in_radius(const map_location ¢er, const int radius, std::vector< map_location > &result)
Function that will add to result all locations within radius tiles of center (excluding center itself...
static lg::log_domain log_scripting_formula("scripting/formula")
std::vector< formula_input > formula_input_vector
const std::vector< std::string > items
std::shared_ptr< formula_function > formula_function_ptr
std::shared_ptr< formula_expression > expression_ptr
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)
map_location get_direction(DIRECTION dir, unsigned int n=1u) const
const std::string & as_string() const
int as_decimal() const
Returns variant's internal representation of decimal number: ie, 1.234 is represented as 1234...
static std::ostream & output()
std::size_t size(const std::string &str)
Length in characters of a UTF-8 string.
EXIT_STATUS start(const std::string &filename, bool take_screenshot, const std::string &screenshot_filename)
Main interface for launching the editor from the title screen.
map_location rotate_right_around_center(const map_location ¢er, int k) const
std::shared_ptr< function_expression > function_expression_ptr
static thread_local std::deque< std::string > call_stack
For printing error messages when WFL parsing or evaluation fails, this contains the names of the WFL ...
The basic class for representing 8-bit RGB or RGBA colour values.
static std::shared_ptr< function_symbol_table > get_builtins()
variant_iterator end() const
Encapsulates the map of the game.
void float_label(const map_location &loc, const std::string &text, const color_t &color)
Function to float a label above a tile.
std::string string_cast() const
const_formula_callable_ptr as_callable() const
bool tiles_adjacent(const map_location &a, const map_location &b)
Function which tells if two locations are adjacent.
std::shared_ptr< function_symbol_table > parent
function_symbol_table(std::shared_ptr< function_symbol_table > parent=nullptr)
action_function_symbol_table(std::shared_ptr< function_symbol_table > parent=nullptr)
static map_location::DIRECTION s
std::string & insert(std::string &str, const std::size_t pos, const std::string &insert)
Insert a UTF-8 string at the specified position.
std::shared_ptr< const formula > const_formula_ptr
std::set< std::string > get_function_names() const
#define DECLARE_WFL_FUNCTION(name)
Declares a function name in the local function table functions_table.
const formula_callable * fallback_
display_chat_manager & get_chat_manager()
bool is_null() const
Functions to test the type of the internal value.
std::size_t distance_between(const map_location &a, const map_location &b)
Function which gives the number of hexes between two tiles (i.e.
const args_list & args() const
variant_iterator begin() const
#define DEFINE_WFL_FUNCTION(name, min_args, max_args)
Helper macro to declare an associated class for a WFL function.
expression_ptr create_function(const std::string &fn, const std::vector< expression_ptr > &args) const
Standard logging facilities (interface).
variant get_values() const
void add_function(const std::string &name, formula_function_ptr &&fcn)
std::size_t num_elements() const
Iterator class for the variant.
bool as_bool() const
Returns a boolean state of the variant value.
functions_map custom_formulas_
static map_location::DIRECTION n
static std::string write_direction(DIRECTION dir)
std::shared_ptr< T > convert_to() const
static game_display * get_singleton()
std::string to_debug_string(bool verbose=false, formula_seen_stack *seen=nullptr) const