math_parser: evaluate variables in diag. functions

data/mods/TEST_DATA/EOC.json

@@ -177,6 +177,14 @@
     "global": true,
     "effect": { "u_message": "test recurrence" }
   },
+  {
+    "type": "effect_on_condition",
+    "id": "EOC_math_diag_w_vars",
+    "effect": [
+      { "set_string_var": "survival", "target_var": { "global_val": "myskill" } },
+      { "math": [ "myskill_math", "=", "u_skill(myskill)" ] }
+    ]
+  },
   {
     "type": "effect_on_condition",
     "id": "EOC_jmath_test",

doc/NPCs.md

@@ -1428,12 +1428,14 @@ Dialogue functions take single-quoted strings as arguments and can return or man
 
 This section is a work in progress as functions are ported from `arithmetic` to `math`.
 
+_function arguments are either `s`trings or `v`[ariables](#variables)_
+
 | Function | Eval | Assign |Scopes | Description |
 |----------|------|--------|-------|-------------|
-| game_option   |  ✅  |   ❌   | N/A<br/>(global)  | Return the numerical value of a game option<br/> Example:<br/>`"condition": { "math": [ "game_option('NPC_SPAWNTIME')", ">=", "5"] }`|
-| pain     |  ✅  |   ✅   | u, n  | Return or set pain<br/> Example:<br/>`{ "math": [ "n_pain()", "=", "u_pain() + 9000" ] }`|
-| skill    |  ✅  |   ✅   | u, n  | Return or set skill level<br/> Example:<br/>`"condition": { "math": [ "u_skill('driving')", ">=", "5"] }`|
-| weather  |  ✅  |   ✅   | N/A<br/>(global)  | Return or set a weather aspect<br/><br/>Aspect must be one of:<br/>`temperature` (in Kelvin),<br/>`humidity` (as percentage),<br/>`pressure` (in millibar),<br/>`windpower` (in mph).<br/><br/>Temperature conversion functions are available: `celsius()`, `fahrenheit()`, `from_celsius()`, and `from_fahrenheit()`.<br/><br/>Examples:<br/>`{ "math": [ "weather('temperature')", "<", "from_fahrenheit( 33 )" ] }`<br/>`{ "math": [ "fahrenheit( weather('temperature') )", "==", "21" ] }`|
+| game_option('s')   |  ✅  |   ❌   | N/A<br/>(global)  | Return the numerical value of a game option<br/> Example:<br/>`"condition": { "math": [ "game_option('NPC_SPAWNTIME')", ">=", "5"] }`|
+| pain()     |  ✅  |   ✅   | u, n  | Return or set pain<br/> Example:<br/>`{ "math": [ "n_pain()", "=", "u_pain() + 9000" ] }`|
+| skill(`s`/`v`)    |  ✅  |   ✅   | u, n  | Return or set skill level<br/> Example:<br/>`"condition": { "math": [ "u_skill('driving')", ">=", "5"] }`<br/>`"condition": { "math": [ "u_skill(someskill)", ">=", "5"] }`|
+| weather(`s`)  |  ✅  |   ✅   | N/A<br/>(global)  | Return or set a weather aspect<br/><br/>Aspect must be one of:<br/>`temperature` (in Kelvin),<br/>`humidity` (as percentage),<br/>`pressure` (in millibar),<br/>`windpower` (in mph).<br/><br/>Temperature conversion functions are available: `celsius()`, `fahrenheit()`, `from_celsius()`, and `from_fahrenheit()`.<br/><br/>Examples:<br/>`{ "math": [ "weather('temperature')", "<", "from_fahrenheit( 33 )" ] }`<br/>`{ "math": [ "fahrenheit( weather('temperature') )", "==", "21" ] }`|
 
 ##### u_val shim
 There is a `val()` shim available that can cover the missing arithmetic functions from `u_val` and `npc_val`:

src/cata_utility.h

@@ -667,4 +667,12 @@ T aggregate( const std::vector<T> &values, aggregate_type agg_func )
     }
 }
 
+// overload pattern for std::variant from https://en.cppreference.com/w/cpp/utility/variant/visit
+template <class... Ts>
+struct overloaded : Ts... {
+    using Ts::operator()...;
+};
+template <class... Ts>
+explicit overloaded( Ts... ) -> overloaded<Ts...>;
+
 #endif // CATA_SRC_CATA_UTILITY_H

src/math_parser.cpp

@@ -289,8 +289,8 @@ class math_exp::math_exp_impl
         void maybe_first_argument();
         void error( std::string_view str, std::string_view what );
         void validate_string( std::string_view str, std::string_view label, std::string_view badlist );
-        std::vector<std::string> _get_strings( std::vector<thingie> const &params,
-                                               size_t nparams ) const;
+        std::vector<diag_func_val> _get_diag_vals( std::vector<thingie> &params,
+                size_t nparams ) const;
 };
 
 void math_exp::math_exp_impl::maybe_first_argument()
@@ -474,12 +474,12 @@ void math_exp::math_exp_impl::new_func()
         std::visit( overloaded{
             [&params, nparams, this]( scoped_diag_eval const & v )
             {
-                std::vector<std::string> const strings = _get_strings( params, nparams );
+                std::vector<diag_func_val> const strings = _get_diag_vals( params, nparams );
                 output.emplace( std::in_place_type_t<func_diag_eval>(), v.df->f( v.scope, strings ) );
             },
             [&params, nparams, this]( scoped_diag_ass const & v )
             {
-                std::vector<std::string> const strings = _get_strings( params, nparams );
+                std::vector<diag_func_val> const strings = _get_diag_vals( params, nparams );
                 output.emplace( std::in_place_type_t<func_diag_ass>(), v.df->f( v.scope, strings ) );
             },
             [&params, this]( pmath_func v )
@@ -500,20 +500,30 @@ void math_exp::math_exp_impl::new_func()
     }
 }
 
-std::vector<std::string> math_exp::math_exp_impl::_get_strings( std::vector<thingie> const
-        &params, size_t nparams ) const
+std::vector<diag_func_val> math_exp::math_exp_impl::_get_diag_vals( std::vector<thingie> &params,
+        size_t nparams ) const
 {
-    std::vector<std::string> strings( nparams );
-    std::transform( params.begin(), params.end(), strings.begin(), [this]( thingie const & e ) {
-        if( std::holds_alternative<std::string>( e.data ) ) {
-            return std::get<std::string>( e.data );
-        }
-        throw std::invalid_argument( string_format(
-                                         "Parameters for %s() must be strings contained in single quotes",
-                                         arity.top().sym.data() ) );
-        return std::string{};
-    } );
-    return strings;
+    std::vector<diag_func_val> vals( nparams );
+    for( decltype( vals )::size_type i = 0; i < params.size(); i++ ) {
+        std::visit( overloaded{
+            [&vals, i]( std::string & v )
+            {
+                vals[i].data.emplace<std::string>( std::move( v ) );
+            },
+            [&vals, i]( var & v )
+            {
+                vals[i].data.emplace<var_info>( std::move( v.varinfo ) );
+            },
+            [this]( auto const &/* v */ )
+            {
+                throw std::invalid_argument(
+                    string_format( "Parameters for %s() must be variables or strings contained in single quotes",
+                                   arity.top().sym ) );
+            },
+        },
+        params[i].data );
+    }
+    return vals;
 }
 
 void math_exp::math_exp_impl::new_oper()

src/math_parser_diag.cpp

@@ -4,6 +4,7 @@
 #include <string>
 #include <vector>
 
+#include "cata_utility.h"
 #include "condition.h"
 #include "dialogue.h"
 #include "math_parser_shim.h"
@@ -26,8 +27,38 @@ bool is_beta( char scope )
 }
 } // namespace
 
+std::string_view diag_func_val::str() const
+{
+    return std::visit( overloaded{
+        []( std::string const & v ) -> std::string const &
+        {
+            return v;
+        },
+        []( var_info const & /* v */ ) -> std::string const &
+        {
+            throw std::invalid_argument( "Variables are not supported in this context" );
+        },
+    },
+    data );
+}
+
+std::string diag_func_val::eval( dialogue const &d ) const
+{
+    return std::visit( overloaded{
+        []( std::string const & v )
+        {
+            return v;
+        },
+        [&d]( var_info const & v )
+        {
+            return read_var_value( v, d );
+        },
+    },
+    data );
+}
+
 std::function<double( dialogue & )> u_val( char scope,
-        std::vector<std::string> const &params )
+        std::vector<diag_func_val> const &params )
 {
     kwargs_shim const shim( params, scope );
     try {
@@ -41,7 +72,7 @@ std::function<double( dialogue & )> u_val( char scope,
 }
 
 std::function<void( dialogue &, double )> u_val_ass( char scope,
-        std::vector<std::string> const &params )
+        std::vector<diag_func_val> const &params )
 {
     kwargs_shim const shim( params, scope );
     try {
@@ -53,47 +84,47 @@ std::function<void( dialogue &, double )> u_val_ass( char scope,
 }
 
 std::function<double( dialogue & )> option_eval( char /* scope */,
-        std::vector<std::string> const &params )
+        std::vector<diag_func_val> const &params )
 {
-    return[option = params[0]]( dialogue const & ) {
+    return[option = std::string( params[0].str() )]( dialogue const & ) {
         return get_option<float>( option );
     };
 }
 
 std::function<double( dialogue & )> pain_eval( char scope,
-        std::vector<std::string> const &/* params */ )
+        std::vector<diag_func_val> const &/* params */ )
 {
     return [beta = is_beta( scope )]( dialogue const & d ) {
         return d.actor( beta )->pain_cur();
     };
 }
 
 std::function<void( dialogue &, double )> pain_ass( char scope,
-        std::vector<std::string> const &/* params */ )
+        std::vector<diag_func_val> const &/* params */ )
 {
     return [beta = is_beta( scope )]( dialogue const & d, double val ) {
         d.actor( beta )->set_pain( val );
     };
 }
 
 std::function<double( dialogue & )> skill_eval( char scope,
-        std::vector<std::string> const &params )
+        std::vector<diag_func_val> const &params )
 {
-    return [beta = is_beta( scope ), sid = skill_id( params[0] )]( dialogue const & d ) {
-        return d.actor( beta )->get_skill_level( sid );
+    return [beta = is_beta( scope ), sid = params[0] ]( dialogue const & d ) {
+        return d.actor( beta )->get_skill_level( skill_id( sid.eval( d ) ) );
     };
 }
 
 std::function<void( dialogue &, double )> skill_ass( char scope,
-        std::vector<std::string> const &params )
+        std::vector<diag_func_val> const &params )
 {
-    return [beta = is_beta( scope ), sid = skill_id( params[0] )]( dialogue const & d, double val ) {
-        return d.actor( beta )->set_skill_level( sid, val );
+    return [beta = is_beta( scope ), sid = params[0] ]( dialogue const & d, double val ) {
+        return d.actor( beta )->set_skill_level( skill_id( sid.eval( d ) ), val );
     };
 }
 
 std::function<double( dialogue & )> weather_eval( char /* scope */,
-        std::vector<std::string> const &params )
+        std::vector<diag_func_val> const &params )
 {
     if( params[0] == "temperature" ) {
         return []( dialogue const & ) {
@@ -115,11 +146,11 @@ std::function<double( dialogue & )> weather_eval( char /* scope */,
             return get_weather().weather_precise->pressure;
         };
     }
-    throw std::invalid_argument( "Unknown weather aspect " + params[0] );
+    throw std::invalid_argument( "Unknown weather aspect " + std::string( params[0].str() ) );
 }
 
 std::function<void( dialogue &, double )> weather_ass( char /* scope */,
-        std::vector<std::string> const &params )
+        std::vector<diag_func_val> const &params )
 {
     if( params[0] == "temperature" ) {
         return []( dialogue const &, double val ) {
@@ -146,5 +177,5 @@ std::function<void( dialogue &, double )> weather_ass( char /* scope */,
             get_weather().clear_temp_cache();
         };
     }
-    throw std::invalid_argument( "Unknown weather aspect " + params[0] );
+    throw std::invalid_argument( "Unknown weather aspect " + std::string( params[0].str() ) );
 }

src/math_parser_diag.h

@@ -5,8 +5,11 @@
 #include <functional>
 #include <string>
 #include <string_view>
+#include <variant>
 #include <vector>
 
+#include "dialogue_helpers.h"
+
 struct dialogue;
 struct dialogue_func {
     dialogue_func( std::string_view s_, std::string_view sc_, int n_ ) : symbol( s_ ),
@@ -16,9 +19,22 @@ struct dialogue_func {
     int num_params{};
 };
 
+struct diag_func_val {
+    std::string_view str() const;
+    std::string eval( dialogue const &d ) const;
+
+    using impl_t = std::variant<std::string, var_info>;
+    impl_t data;
+};
+
+constexpr bool operator==( diag_func_val const &lhs, std::string_view rhs )
+{
+    return std::holds_alternative<std::string>( lhs.data ) && std::get<std::string>( lhs.data ) == rhs;
+}
+
 struct dialogue_func_eval : dialogue_func {
     using f_t = std::function<double( dialogue & )> ( * )( char scope,
-                std::vector<std::string> const & );
+                std::vector<diag_func_val> const & );
 
     dialogue_func_eval( std::string_view s_, std::string_view sc_, int n_, f_t f_ )
         : dialogue_func( s_, sc_, n_ ), f( f_ ) {}
@@ -28,7 +44,7 @@ struct dialogue_func_eval : dialogue_func {
 
 struct dialogue_func_ass : dialogue_func {
     using f_t = std::function<void( dialogue &, double )> ( * )( char scope,
-                std::vector<std::string> const & );
+                std::vector<diag_func_val> const & );
 
     dialogue_func_ass( std::string_view s_, std::string_view sc_, int n_, f_t f_ )
         : dialogue_func( s_, sc_, n_ ), f( f_ ) {}
@@ -40,28 +56,28 @@ using pdiag_func_eval = dialogue_func_eval const *;
 using pdiag_func_ass = dialogue_func_ass const *;
 
 std::function<double( dialogue & )> u_val( char scope,
-        std::vector<std::string> const &params );
+        std::vector<diag_func_val> const &params );
 std::function<void( dialogue &, double )> u_val_ass( char scope,
-        std::vector<std::string> const &params );
+        std::vector<diag_func_val> const &params );
 
 std::function<double( dialogue & )> option_eval( char scope,
-        std::vector<std::string> const &params );
+        std::vector<diag_func_val> const &params );
 
 std::function<double( dialogue & )> pain_eval( char scope,
-        std::vector<std::string> const &/* params */ );
+        std::vector<diag_func_val> const &/* params */ );
 
 std::function<void( dialogue &, double )> pain_ass( char scope,
-        std::vector<std::string> const &/* params */ );
+        std::vector<diag_func_val> const &/* params */ );
 
 std::function<double( dialogue & )> skill_eval( char scope,
-        std::vector<std::string> const &params );
+        std::vector<diag_func_val> const &params );
 std::function<void( dialogue &, double )> skill_ass( char scope,
-        std::vector<std::string> const &params );
+        std::vector<diag_func_val> const &params );
 
 std::function<double( dialogue & )> weather_eval( char /* scope */,
-        std::vector<std::string> const &params );
+        std::vector<diag_func_val> const &params );
 std::function<void( dialogue &, double )> weather_ass( char /* scope */,
-        std::vector<std::string> const &params );
+        std::vector<diag_func_val> const &params );
 
 inline std::array<dialogue_func_eval, 5> const dialogue_eval_f{
     dialogue_func_eval{ "val", "un", -1, u_val },

src/math_parser_impl.h

@@ -8,6 +8,7 @@
 #include <variant>
 #include <vector>
 
+#include "cata_utility.h"
 #include "debug.h"
 #include "dialogue_helpers.h"
 #include "math_parser_diag.h"
@@ -131,13 +132,6 @@ struct thingie {
     impl_t data;
 };
 
-// overload pattern from https://en.cppreference.com/w/cpp/utility/variant/visit
-template <class... Ts>
-struct overloaded : Ts... {
-    using Ts::operator()...;
-};
-template <class... Ts>
-explicit overloaded( Ts... ) -> overloaded<Ts...>;
 constexpr double thingie::eval( dialogue &d ) const
 {
     return std::visit( overloaded{

src/math_parser_shim.cpp

@@ -1,18 +1,18 @@
 #include "math_parser_shim.h"
+#include "math_parser_diag.h"
 #include "math_parser_func.h"
 
 #include <map>
 #include <string_view>
 
-#include "condition.h"
 #include "json_loader.h"
 #include "string_formatter.h"
 
-kwargs_shim::kwargs_shim( std::vector<std::string> const &tokens, char scope )
+kwargs_shim::kwargs_shim( std::vector<diag_func_val> const &tokens, char scope )
 {
     bool positional = false;
-    for( std::string_view const token : tokens ) {
-        std::vector<std::string_view> parts = tokenize( token, ":", false );
+    for( diag_func_val const &token : tokens ) {
+        std::vector<std::string_view> parts = tokenize( token.str(), ":", false );
         if( parts.size() == 1 && !positional ) {
             kwargs.emplace(
                 // NOLINTNEXTLINE(cata-translate-string-literal): not a user-visible string
@@ -22,7 +22,7 @@ kwargs_shim::kwargs_shim( std::vector<std::string> const &tokens, char scope )
         } else if( parts.size() == 2 ) {
             kwargs.emplace( parts[0], parts[1] );
         } else {
-            debugmsg( "Too many parts in token %.*s", token.size(), token.data() );
+            debugmsg( "Too many parts in token %s", token.str() );
         }
     }
 }