From 525a813c80ced2359336d76120b348f1d3f1f72f Mon Sep 17 00:00:00 2001 From: Charles Dang Date: Wed, 29 Mar 2017 15:09:07 +1100 Subject: [PATCH] Deployed formula_callable::add_input en-masse --- src/ai/default/attack.cpp | 37 ++++++++------- src/ai/default/contexts.hpp | 2 +- src/ai/formula/ai.cpp | 55 +++++++++++----------- src/ai/formula/ai.hpp | 2 +- src/ai/formula/callable_objects.cpp | 69 ++++++++++++++-------------- src/ai/formula/callable_objects.hpp | 34 +++++++------- src/formula/callable.hpp | 6 +-- src/formula/formula.cpp | 28 +++++------ src/formula/function.cpp | 6 +-- src/formula/function.hpp | 2 +- src/formula/variant.cpp | 2 +- src/image_modifications.cpp | 18 ++++---- src/scripting/lua_formula_bridge.cpp | 6 +-- 13 files changed, 132 insertions(+), 135 deletions(-) diff --git a/src/ai/default/attack.cpp b/src/ai/default/attack.cpp index 849bd4daa08e..5422abcee8d7 100644 --- a/src/ai/default/attack.cpp +++ b/src/ai/default/attack.cpp @@ -379,26 +379,25 @@ variant attack_analysis::get_value(const std::string& key) const } } -void attack_analysis::get_inputs(std::vector* inputs) const +void attack_analysis::get_inputs(game_logic::formula_input_vector* inputs) const { - using namespace game_logic; - inputs->push_back(formula_input("target", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("movements", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("units", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("target_value", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("avg_losses", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("chance_to_kill", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("avg_damage_inflicted", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("target_starting_damage", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("avg_damage_taken", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("resources_used", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("terrain_quality", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("alternative_terrain_quality", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("vulnerability", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("support", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("leader_threat", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("uses_leader", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("is_surrounded", FORMULA_READ_ONLY)); + add_input(inputs, "target"); + add_input(inputs, "movements"); + add_input(inputs, "units"); + add_input(inputs, "target_value"); + add_input(inputs, "avg_losses"); + add_input(inputs, "chance_to_kill"); + add_input(inputs, "avg_damage_inflicted"); + add_input(inputs, "target_starting_damage"); + add_input(inputs, "avg_damage_taken"); + add_input(inputs, "resources_used"); + add_input(inputs, "terrain_quality"); + add_input(inputs, "alternative_terrain_quality"); + add_input(inputs, "vulnerability"); + add_input(inputs, "support"); + add_input(inputs, "leader_threat"); + add_input(inputs, "uses_leader"); + add_input(inputs, "is_surrounded"); } } //end of namespace ai diff --git a/src/ai/default/contexts.hpp b/src/ai/default/contexts.hpp index c669cd90fcc2..36af90e2f25a 100644 --- a/src/ai/default/contexts.hpp +++ b/src/ai/default/contexts.hpp @@ -86,7 +86,7 @@ class attack_analysis : public game_logic::formula_callable double rating(double aggression, const readonly_context& ai_obj) const; variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(game_logic::formula_input_vector* inputs) const; bool attack_close(const map_location& loc) const; diff --git a/src/ai/formula/ai.cpp b/src/ai/formula/ai.cpp index d1cb55435047..5cda4f6ca158 100644 --- a/src/ai/formula/ai.cpp +++ b/src/ai/formula/ai.cpp @@ -855,34 +855,33 @@ variant formula_ai::get_value(const std::string& key) const void formula_ai::get_inputs(std::vector* inputs) const { - using game_logic::FORMULA_READ_ONLY; - inputs->push_back(game_logic::formula_input("aggression", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("leader_aggression", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("caution", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("attacks", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("my_side", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("teams", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("turn", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("time_of_day", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("keeps", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("vars", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("allies", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("enemies", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("map", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("my_attacks", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("enemy_moves", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("my_leader", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("my_recruits", FORMULA_READ_ONLY)); - //inputs->push_back(game_logic::formula_input("recall_list", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("recruits_of_side", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("units", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("units_of_side", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("my_units", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("enemy_units", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("villages", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("my_villages", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("villages_of_side", FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("enemy_and_unowned_villages", FORMULA_READ_ONLY)); + add_input(inputs, "aggression"); + add_input(inputs, "leader_aggression"); + add_input(inputs, "caution"); + add_input(inputs, "attacks"); + add_input(inputs, "my_side"); + add_input(inputs, "teams"); + add_input(inputs, "turn"); + add_input(inputs, "time_of_day"); + add_input(inputs, "keeps"); + add_input(inputs, "vars"); + add_input(inputs, "allies"); + add_input(inputs, "enemies"); + add_input(inputs, "map"); + add_input(inputs, "my_attacks"); + add_input(inputs, "enemy_moves"); + add_input(inputs, "my_leader"); + add_input(inputs, "my_recruits"); + //add_input(inputs, "recall_list"); + add_input(inputs, "recruits_of_side"); + add_input(inputs, "units"); + add_input(inputs, "units_of_side"); + add_input(inputs, "my_units"); + add_input(inputs, "enemy_units"); + add_input(inputs, "villages"); + add_input(inputs, "my_villages"); + add_input(inputs, "villages_of_side"); + add_input(inputs, "enemy_and_unowned_villages"); } variant formula_ai::get_keeps() const diff --git a/src/ai/formula/ai.hpp b/src/ai/formula/ai.hpp index 1a7c53f12cea..9ac12ea05882 100644 --- a/src/ai/formula/ai.hpp +++ b/src/ai/formula/ai.hpp @@ -159,7 +159,7 @@ class formula_ai : public readonly_context_proxy, public game_logic::formula_cal void display_message(const std::string& msg) const; variant execute_variant(const variant& var, ai_context &ai_, bool commandline=false); virtual variant get_value(const std::string& key) const; - virtual void get_inputs(std::vector* inputs) const; + virtual void get_inputs(game_logic::formula_input_vector* inputs) const; mutable variant keeps_cache_; diff --git a/src/ai/formula/callable_objects.cpp b/src/ai/formula/callable_objects.cpp index 62fa4260c8fa..83d3764692fa 100644 --- a/src/ai/formula/callable_objects.cpp +++ b/src/ai/formula/callable_objects.cpp @@ -41,10 +41,9 @@ variant move_map_callable::get_value(const std::string& key) const } } -void move_map_callable::get_inputs(std::vector* inputs) const +void move_map_callable::get_inputs(formula_input_vector* inputs) const { - using game_logic::FORMULA_READ_ONLY; - inputs->push_back(game_logic::formula_input("moves", FORMULA_READ_ONLY)); + add_input(inputs, "moves"); } int move_callable::do_compare(const formula_callable* callable) const @@ -89,8 +88,8 @@ variant position_callable::get_value(const std::string& key) const { } } -void position_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("chance", game_logic::FORMULA_READ_ONLY)); +void position_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "chance"); } variant outcome_callable::get_value(const std::string& key) const { @@ -105,10 +104,10 @@ variant outcome_callable::get_value(const std::string& key) const { } } -void outcome_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("hitpoints_left", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("probability", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("possible_status", game_logic::FORMULA_READ_ONLY)); +void outcome_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "hitpoints_left"); + add_input(inputs, "probability"); + add_input(inputs, "possible_status"); } @@ -134,10 +133,10 @@ variant attack_callable::get_value(const std::string& key) const { } } -void attack_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("attack_from", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("defender", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("move_from", game_logic::FORMULA_READ_ONLY)); +void attack_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "attack_from"); + add_input(inputs, "defender"); + add_input(inputs, "move_from"); } int attack_callable::do_compare(const game_logic::formula_callable* callable) @@ -190,8 +189,8 @@ variant attack_map_callable::get_value(const std::string& key) const { } } -void attack_map_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("attacks", game_logic::FORMULA_READ_ONLY)); +void attack_map_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "attacks"); } /* add to vars all attacks on enemy units around tile. attacker_location is tile where unit is currently standing. It's moved to attack_position first and then performs attack.*/ @@ -227,9 +226,9 @@ variant recall_callable::get_value(const std::string& key) const { return variant(); } -void recall_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("id", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("loc", game_logic::FORMULA_READ_ONLY)); +void recall_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "id"); + add_input(inputs, "loc"); } @@ -242,9 +241,9 @@ variant recruit_callable::get_value(const std::string& key) const { return variant(); } -void recruit_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("unit_type", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("recruit_loc", game_logic::FORMULA_READ_ONLY)); +void recruit_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "unit_type"); + add_input(inputs, "recruit_loc"); } @@ -258,9 +257,9 @@ variant set_var_callable::get_value(const std::string& key) const { return variant(); } -void set_var_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("key", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("value", game_logic::FORMULA_READ_ONLY)); +void set_var_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "key"); + add_input(inputs, "value"); } @@ -277,10 +276,10 @@ variant set_unit_var_callable::get_value(const std::string& key) const { return variant(); } -void set_unit_var_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("loc", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("key", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("value", game_logic::FORMULA_READ_ONLY)); +void set_unit_var_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "loc"); + add_input(inputs, "key"); + add_input(inputs, "value"); } @@ -294,9 +293,9 @@ variant safe_call_callable::get_value(const std::string& key) const { return variant(); } -void safe_call_callable::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("main", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("backup", game_logic::FORMULA_READ_ONLY)); +void safe_call_callable::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "main"); + add_input(inputs, "backup"); } @@ -317,11 +316,11 @@ variant safe_call_result::get_value(const std::string& key) const { return variant(); } -void safe_call_result::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("status", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("object", game_logic::FORMULA_READ_ONLY)); +void safe_call_result::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "status"); + add_input(inputs, "object"); if( current_unit_location_ != map_location() ) - inputs->push_back(game_logic::formula_input("current_loc", game_logic::FORMULA_READ_ONLY)); + add_input(inputs, "current_loc"); } } diff --git a/src/ai/formula/callable_objects.hpp b/src/ai/formula/callable_objects.hpp index 51fcf3dfec7b..ab75240f9965 100644 --- a/src/ai/formula/callable_objects.hpp +++ b/src/ai/formula/callable_objects.hpp @@ -39,7 +39,7 @@ class attack_map_callable : public formula_callable { variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; /* add to vars all attacks on enemy units around tile. attacker_location is tile where unit is currently standing. It's moved to attack_position first and then performs attack.*/ void collect_possible_attacks(std::vector& vars, map_location attacker_location, map_location attack_position) const; @@ -50,7 +50,7 @@ class attack_callable : public formula_callable { battle_context bc_; variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: attack_callable(const map_location& move_from, const map_location& src, const map_location& dst, int weapon); @@ -79,9 +79,9 @@ class move_callable : public game_logic::formula_callable { return variant(); } } - void get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("src", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("dst", game_logic::FORMULA_READ_ONLY)); + void get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "src"); + add_input(inputs, "dst"); } int do_compare(const formula_callable* callable) const; @@ -108,9 +108,9 @@ class move_partial_callable : public game_logic::formula_callable { return variant(); } } - void get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("src", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("dst", game_logic::FORMULA_READ_ONLY)); + void get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "src"); + add_input(inputs, "dst"); } int do_compare(const formula_callable* callable) const; @@ -133,7 +133,7 @@ class recall_callable : public formula_callable { variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: recall_callable(const map_location& loc, const std::string& id) : loc_(loc), id_(id) @@ -150,7 +150,7 @@ class recruit_callable : public formula_callable { variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: recruit_callable(const map_location& loc, const std::string& type) : loc_(loc), type_(type) @@ -166,7 +166,7 @@ class set_var_callable : public formula_callable { variant value_; variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: set_var_callable(const std::string& key, const variant& value) : key_(key), value_(value) @@ -183,7 +183,7 @@ class set_unit_var_callable : public formula_callable { map_location loc_; variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: set_unit_var_callable(const std::string& key, const variant& value, const map_location& loc) : key_(key), value_(value), loc_(loc) @@ -207,7 +207,7 @@ class safe_call_callable : public formula_callable { expression_ptr backup_formula_; variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: safe_call_callable(const variant& main, const expression_ptr& backup) : main_(main) @@ -231,7 +231,7 @@ class safe_call_result : public formula_callable { variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: safe_call_result(const formula_callable* callable, int status, @@ -248,7 +248,7 @@ class move_map_callable : public game_logic::formula_callable { const unit_map& units_; variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: move_map_callable(const move_map& srcdst, const move_map& dstsrc, const unit_map& units) : srcdst_(srcdst), dstsrc_(dstsrc), units_(units) @@ -265,7 +265,7 @@ class position_callable : public formula_callable { int chance_; variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: position_callable(/*unit_map* units,*/ int chance) : //units_(), @@ -296,7 +296,7 @@ class outcome_callable : public formula_callable { std::vector hitLeft_, prob_, status_; variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: outcome_callable( const std::vector& hitLeft, const std::vector& prob, diff --git a/src/formula/callable.hpp b/src/formula/callable.hpp index 26d0d9db9a6c..579d55835404 100644 --- a/src/formula/callable.hpp +++ b/src/formula/callable.hpp @@ -32,7 +32,7 @@ struct formula_input { {} }; -using formula_input_vector = std::vector; +using formula_input_vector = std::vector; //interface for objects that can have formulae run on them class formula_callable { @@ -111,9 +111,9 @@ class formula_callable { return variant(&tmp); } - static inline void add_input(formula_input_vector* inputs, const std::string& key) + static inline void add_input(formula_input_vector* inputs, const std::string& key, FORMULA_ACCESS_TYPE access_type = FORMULA_READ_ONLY) { - inputs->push_back(formula_input(key, FORMULA_READ_ONLY)); + inputs->push_back(formula_input(key, access_type)); } protected: diff --git a/src/formula/formula.cpp b/src/formula/formula.cpp index baaa366aae85..eae08acf43da 100644 --- a/src/formula/formula.cpp +++ b/src/formula/formula.cpp @@ -62,7 +62,7 @@ void map_formula_callable::get_inputs(std::vector* inputs) const fallback_->get_inputs(inputs); } for(std::map::const_iterator i = values_.begin(); i != values_.end(); ++i) { - inputs->push_back(formula_input(i->first, FORMULA_READ_WRITE)); + add_input(inputs, i->first, FORMULA_READ_WRITE); } } @@ -221,11 +221,11 @@ class string_callable : public formula_callable { {} void get_inputs(std::vector* inputs) const { - inputs->push_back(formula_input("size", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("empty", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("char", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("word", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("item", FORMULA_READ_ONLY)); + add_input(inputs, "size"); + add_input(inputs, "empty"); + add_input(inputs, "char"); + add_input(inputs, "word"); + add_input(inputs, "item"); } variant get_value(const std::string& key) const { @@ -271,10 +271,10 @@ class list_callable : public formula_callable { {} void get_inputs(std::vector* inputs) const { - inputs->push_back(formula_input("size", FORMULA_READ_WRITE)); - inputs->push_back(formula_input("empty", FORMULA_READ_WRITE)); - inputs->push_back(formula_input("first", FORMULA_READ_WRITE)); - inputs->push_back(formula_input("last", FORMULA_READ_WRITE)); + add_input(inputs, "size", FORMULA_READ_WRITE); + add_input(inputs, "empty", FORMULA_READ_WRITE); + add_input(inputs, "first", FORMULA_READ_WRITE); + add_input(inputs, "last", FORMULA_READ_WRITE); } variant get_value(const std::string& key) const { @@ -308,8 +308,8 @@ class map_callable : public formula_callable { {} void get_inputs(std::vector* inputs) const { - inputs->push_back(formula_input("size", FORMULA_READ_WRITE)); - inputs->push_back(formula_input("empty", FORMULA_READ_WRITE)); + add_input(inputs, "size", FORMULA_READ_WRITE); + add_input(inputs, "empty", FORMULA_READ_WRITE); for(variant_iterator iter = map_.begin(); iter != map_.end(); iter++) { // variant_iterator does not implement operator->, // and to do so is notrivial since it returns temporaries for maps. @@ -326,7 +326,7 @@ class map_callable : public formula_callable { } } if(valid) { - inputs->push_back(formula_input(key, FORMULA_READ_ONLY)); + add_input(inputs, key); } } } @@ -571,7 +571,7 @@ class where_variables: public formula_callable { void get_inputs(std::vector* inputs) const { for(expr_table::const_iterator i = table_->begin(); i != table_->end(); ++i) { - inputs->push_back(formula_input(i->first, FORMULA_READ_ONLY)); + add_input(inputs, i->first); } } diff --git a/src/formula/function.cpp b/src/formula/function.cpp index 87c2a2d253c6..bb3ad1e1d747 100644 --- a/src/formula/function.cpp +++ b/src/formula/function.cpp @@ -1471,9 +1471,9 @@ variant key_value_pair::get_value(const std::string& key) const return variant(); } -void key_value_pair::get_inputs(std::vector* inputs) const { - inputs->push_back(game_logic::formula_input("key", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("value", game_logic::FORMULA_READ_ONLY)); +void key_value_pair::get_inputs(formula_input_vector* inputs) const { + add_input(inputs, "key"); + add_input(inputs, "value"); } diff --git a/src/formula/function.hpp b/src/formula/function.hpp index 0778078f6568..55e02730c752 100644 --- a/src/formula/function.hpp +++ b/src/formula/function.hpp @@ -77,7 +77,7 @@ class key_value_pair : public formula_callable { variant get_value(const std::string& key) const; - void get_inputs(std::vector* inputs) const; + void get_inputs(formula_input_vector* inputs) const; public: explicit key_value_pair(const variant& key, const variant& value) : key_(key), value_(value) {} diff --git a/src/formula/variant.cpp b/src/formula/variant.cpp index 6073ff43cbf4..8939eb9cc92c 100644 --- a/src/formula/variant.cpp +++ b/src/formula/variant.cpp @@ -1203,7 +1203,7 @@ std::string variant::to_debug_string(std::vectorbegin(), seen->end(), callable_) == seen->end()) { if(!verbose) seen->push_back(callable_); - std::vector v = callable_->inputs(); + game_logic::formula_input_vector v = callable_->inputs(); bool first = true; for(size_t i=0; i* inputs) const override + void get_inputs(game_logic::formula_input_vector* inputs) const override { - inputs->push_back(game_logic::formula_input("x", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("y", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("red", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("green", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("blue", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("alpha", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("height", game_logic::FORMULA_READ_ONLY)); - inputs->push_back(game_logic::formula_input("width", game_logic::FORMULA_READ_ONLY)); + add_input(inputs, "x"); + add_input(inputs, "y"); + add_input(inputs, "red"); + add_input(inputs, "green"); + add_input(inputs, "blue"); + add_input(inputs, "alpha"); + add_input(inputs, "height"); + add_input(inputs, "width"); } variant get_value(const std::string& key) const override diff --git a/src/scripting/lua_formula_bridge.cpp b/src/scripting/lua_formula_bridge.cpp index 9bf395eea8c5..4c30aa60c356 100644 --- a/src/scripting/lua_formula_bridge.cpp +++ b/src/scripting/lua_formula_bridge.cpp @@ -67,13 +67,13 @@ class lua_callable : public formula_callable { return result; } void get_inputs(std::vector* inputs) const { - inputs->push_back(formula_input("__list", FORMULA_READ_ONLY)); - inputs->push_back(formula_input("__map", FORMULA_READ_ONLY)); + add_input(inputs, "__list"); + add_input(inputs, "__map"); for(lua_pushnil(mState); lua_next(mState, table_i); lua_pop(mState,1)) { if(lua_isstring(mState, -2) && !lua_isnumber(mState, -2)) { std::string key = lua_tostring(mState, -2); if(key.find_first_not_of(formula::id_chars) != std::string::npos) { - inputs->push_back(formula_input(key, FORMULA_READ_ONLY)); + add_input(inputs, key); } } }