Merge remote-tracking branch 'origin/day'

1 files changed, 155 insertions, 63 deletions

diff --git a/src/game/vars.cpp b/src/game/vars.cpp
index 443699d..bc12887 100644
--- a/src/game/vars.cpp
+++ b/src/game/vars.cpp
@@ -1,5 +1,6 @@
 #include "vars.h"
 #include "../util.h"
+
 #include <string.h>
 
 VAR_LIST* varl;
@@ -14,12 +15,35 @@ VAR_LIST* vars_init() {
   return ret;
 }
 
-CVAR* var_new( const char* name, F32 v ) {
+inline F32 var_clamp( CVAR* var, F32 value ) {
+  if( !( var->flags & CVAR_FLAG_MINMAX ) )
+    return value;
+
+  return m_clamp(
+    value,
+    var->min_v.fl_v,
+    var->max_v.fl_v
+  );
+}
+
+inline I32 var_clamp( CVAR* var, I32 value ) {
+  if( !( var->flags & CVAR_FLAG_MINMAX ) )
+    return value;
+
+  return m_clamp(
+    value,
+    var->min_v.i_v,
+    var->max_v.i_v
+  );
+}
+
+CVAR* var_new( const char* name, STR desc, F32 v ) {
   vars_check_global_list();
 
-  CVAR* ret = new CVAR;
-  memset( ret, 0 , sizeof( CVAR ) );
+  CVAR* ret = new CVAR{};
   ret->type = CVAR_TYPE_FLOAT;
+  ret->default_v.fl_v = v;
+  ret->desc = desc;
   ret->name = name;
   ret->fl_v = v;
 
@@ -27,25 +51,85 @@ CVAR* var_new( const char* name, F32 v ) {
   return ret;
 }
 
-CVAR* var_new( const char* name, I32 i ) {
+CVAR* var_new(
+  const char* name,
+  STR desc,
+  F32 v,
+  F32 min_v,
+  F32 max_v
+) {
+  if( min_v > max_v ) {
+    dlog( "var_new() : invalid bounds for %s\n", name );
+    return 0;
+  }
+
   vars_check_global_list();
 
-  CVAR* ret = new CVAR;
-  memset( ret, 0 , sizeof( CVAR ) );
+  CVAR* ret = new CVAR{};
+  ret->flags = CVAR_FLAG_MINMAX;
+  ret->type = CVAR_TYPE_FLOAT;
+  ret->min_v.fl_v = min_v;
+  ret->max_v.fl_v = max_v;
+  ret->desc = desc;
+  ret->name = name;
+
+  ret->fl_v = var_clamp( ret, v );
+  ret->default_v.fl_v = ret->fl_v;
+
+  varl->vars.push( ret );
+  return ret;
+}
+
+CVAR* var_new( const char* name, STR desc, I32 v ) {
+  vars_check_global_list();
+
+  CVAR* ret = new CVAR{};
   ret->type = CVAR_TYPE_INT;
+  ret->default_v.i_v = v;
+  ret->desc = desc;
   ret->name = name;
-  ret->i_v = i;
+  ret->i_v = v;
 
   varl->vars.push( ret );
   return ret;
 }
 
-CVAR* var_new( const char* name, CLR c ) {
+CVAR* var_new(
+  const char* name,
+  STR desc,
+  I32 v,
+  I32 min_v,
+  I32 max_v
+) {
+  if( min_v > max_v ) {
+    dlog( "var_new() : invalid bounds for %s\n", name );
+    return 0;
+  }
+
   vars_check_global_list();
 
-  CVAR* ret = new CVAR;
-  memset( ret, 0 , sizeof( CVAR ) );
+  CVAR* ret = new CVAR{};
+  ret->flags = CVAR_FLAG_MINMAX;
+  ret->type = CVAR_TYPE_INT;
+  ret->min_v.i_v = min_v;
+  ret->max_v.i_v = max_v;
+  ret->desc = desc;
+  ret->name = name;
+
+  ret->i_v = var_clamp( ret, v );
+  ret->default_v.i_v = ret->i_v;
+
+  varl->vars.push( ret );
+  return ret;
+}
+
+CVAR* var_new( const char* name, STR desc, CLR c ) {
+  vars_check_global_list();
+
+  CVAR* ret = new CVAR{};
   ret->type = CVAR_TYPE_COLOR;
+  ret->default_v.clr_v = c;
+  ret->desc = desc;
   ret->name = name;
   ret->clr_v = c;
 
@@ -53,25 +137,34 @@ CVAR* var_new( const char* name, CLR c ) {
   return ret;
 }
 
-CVAR* var_new( const char* name, CVAR_FUNC func ) {
+CVAR* var_new( const char* name, STR desc, CVAR_FUNC func ) {
   vars_check_global_list();
 
-  CVAR* ret = new CVAR;
-  memset( ret, 0 , sizeof( CVAR ) );
+  CVAR* ret = new CVAR{};
   ret->type = CVAR_TYPE_FN;
   ret->name = name;
   ret->fn_v = func;
+  ret->desc = desc;
 
   varl->vars.push( ret );
   return ret;
 }
 
-CVAR* var_new( const char* name, const char* v ) {
+CVAR* var_new( const char* name, STR desc, const char* v ) {
   vars_check_global_list();
 
-  CVAR* ret = new CVAR;
-  memset( ret, 0, sizeof( CVAR ) );
+  CVAR* ret = new CVAR{};
+
+  if( !v || strlen( v ) >= sizeof( ret->str_v ) ) {
+    dlog( "var_new() : invalid initial string for %s\n", name );
+    delete ret;
+    return 0;
+  }
+
+  strcpy( ret->default_v.str_v, v );
   ret->type = CVAR_TYPE_STRING;
+  strcpy( ret->str_v, v );
+  ret->desc = desc;
   ret->name = name;
 
   varl->vars.push( ret );
@@ -80,22 +173,22 @@ CVAR* var_new( const char* name, const char* v ) {
 
 CVAR* var_find( const char* name ) {
   if( !varl ) {
-    dlog( "var_new() : error: varl null\n" );
+    dlog( "var_find() : error: varl null\n" );
     return 0;
   }
 
-  U32 len = strlen( name );
+  U32 len = (U32)strlen( name );
   for( U32 i = 0; i < varl->vars.size; ++i ) {
-    U32 len2 = strlen( varl->vars[i]->name );
-    if( strncmp( varl->vars[i]->name, name, min( len, len2 ) ) == 0 ) {
-      return varl->vars[i];
-    }
+    CVAR* cvar = varl->vars[i];
+    U32 len2 = (U32)strlen( cvar->name );
+    if( strncmp( cvar->name, name, min( len, len2 ) ) )
+      continue;
+    return cvar;
   }
-
   return 0;
 }
 
-I32 var_call( CVAR *cmdvar, const char *cmdline ) {
+I32 var_call( CVAR *cmdvar, LIST<STR> cmdline ) {
   if( cmdvar->type != CVAR_TYPE_FN ) {
     dlog( "var_call() : error: not a function\n" );
     return -1;
@@ -128,29 +221,34 @@ CLR var_getclr( CVAR *var ) {
   }
 }
 
-const char* var_gets( CVAR *var ) {
+STR var_gets( const CVAR *var ) {
+  if( !var )
+    return {};
+
   switch( var->type ) {
-  case CVAR_TYPE_STRING: return var->str_v;
-  case CVAR_TYPE_FLOAT:
-    sprintf( var->str_v + sizeof(F32), "%f", var->fl_v );
-    return var->str_v + sizeof(F32);
-  case CVAR_TYPE_INT:
-    sprintf( var->str_v + sizeof(I32), "%d", var->i_v );
-    return var->str_v + sizeof(I32);
+  case CVAR_TYPE_STRING: return STR( "%s", var->str_v );
   case CVAR_TYPE_COLOR:
-    sprintf( var->str_v + sizeof(CLR), "%f %f %f %f", var->clr_v.r, var->clr_v.g, var->clr_v.b, var->clr_v.a );
-    return var->str_v + sizeof(CLR);
-  default:
-    return "";
+    return STR(
+      "%#.9g %#.9g %#.9g %#.9g",
+      (F64)var->clr_v.r,
+      (F64)var->clr_v.g,
+      (F64)var->clr_v.b,
+      (F64)var->clr_v.a
+    );
+  case CVAR_TYPE_FLOAT: return STR( "%#.9g", var->fl_v );
+  case CVAR_TYPE_INT: return STR( "%d", var->i_v );
+  case CVAR_TYPE_FN:
+    return STR( "<function %s>", var->name.data );
+  default: return {};
   }
 }
 
 void var_set( CVAR* var, F32 v ) {
   switch( var->type ) {
   case CVAR_TYPE_FLOAT:
-    var->fl_v = v; break;
+    var->fl_v = var_clamp( var, v ); break;
   case CVAR_TYPE_INT:
-    var->i_v = (I32)v; break;
+    var->i_v = var_clamp( var, (I32)v ); break;
   case CVAR_TYPE_COLOR:
     var->clr_v = (CLR){ v, v, v, 1.f }; break;
   case CVAR_TYPE_STRING:
@@ -162,9 +260,9 @@ void var_set( CVAR* var, F32 v ) {
 void var_set( CVAR* var, I32 v ) {
   switch( var->type ) {
   case CVAR_TYPE_FLOAT:
-    var->fl_v = (F32)v; break;
+    var->fl_v = var_clamp( var, (F32)v ); break;
   case CVAR_TYPE_INT:
-    var->i_v = v; break;
+    var->i_v = var_clamp( var, v ); break;
   case CVAR_TYPE_COLOR:
     var->clr_v = (CLR){ ((F32)v / 255), ((F32)v / 255), ((F32)v / 255), 1.f }; break;
   case CVAR_TYPE_STRING:
@@ -179,35 +277,29 @@ void var_set( CVAR* var, CLR v ) {
     var->clr_v = v; break;
   case CVAR_TYPE_STRING:
     strcpy( var->str_v, to_str( v ) ); break;
-  default: dlog( "attempted to set color to %s, but it's not a color value", var->name.data ); break;
+  default: dlog( "attempted to set color to %s, but it's not a color value\n", var->name.data ); break;
   }
 }
 
 void var_set( CVAR* var, STR v ) {
-  if( v.size >= 64 ) {
-    dlog( "attempted to set string to %s, but it's too long (%d/64 bytes)", var->name.data, v.size );
+  if( var->type != CVAR_TYPE_STRING ) {
+    dlog(
+      "attempted to set string to %s, "
+      "but it is not a string value\n",
+      var->name.data
+    );
     return;
   }
 
-  switch( var->type ) {
-    case CVAR_TYPE_FLOAT:
-      F32 f; sscanf( v.data, "%f", &f );
-      var->fl_v = f; break;
-    case CVAR_TYPE_INT:
-      var->i_v = atoi( v.data ); break;
-    case CVAR_TYPE_STRING:
-      strcpy( var->str_v, v.data ); break;
-    case CVAR_TYPE_COLOR: {
-      LIST<STR> strings = v.split( " " );
-      if( strings.size < 3 || strings.size > 4 )
-        break;
-
-      for( U32 i = 0; i < strings.size; ++i ) {
-        F32 f{}; sscanf( strings[i].data, "%f", &f );
-        ( (F32*)( &var->clr_v ) )[i] = f;
-      } break;
-    }
-    default:
-      break;
+  if( v.size >= sizeof( var->str_v ) ) {
+    dlog(
+      "attempted to set string to %s, "
+      "but it's too long (%u/64 bytes)\n",
+      var->name.data,
+      v.size
+    );
+    return;
   }
+
+  memcpy( var->str_v, v.data, v.size + 1 );
 }