Merge remote-tracking branch 'origin/day'

6 files changed, 218 insertions, 80 deletions

diff --git a/src/game/assets.cpp b/src/game/assets.cpp
index 62663a9..6ee7aff 100644
--- a/src/game/assets.cpp
+++ b/src/game/assets.cpp
@@ -9,6 +9,18 @@
 void assets_init( GAME_DATA *game ) {
   game->assets.test = gl_texture_from_file( game->gl, "uvtest.png" );
   game->assets.fonts_init = 0;
+
+  for( I32 idx = 0; idx < SDL_NUM_SYSTEM_CURSORS; ++idx )
+    game->assets.cursors[idx] = SDL_CreateSystemCursor( (SDL_SystemCursor)idx );
+}
+
+void assets_destroy( GAME_DATA* game ) {
+  for( I32 idx = 0; idx < SDL_NUM_SYSTEM_CURSORS; ++idx ) {
+    if( !game->assets.cursors[idx] )
+      continue;
+    SDL_FreeCursor( game->assets.cursors[idx] );
+    game->assets.cursors[idx] = 0;
+  }
 }
 
 void assets_create_fonts( struct GAME_DATA *game ) {
diff --git a/src/game/assets.h b/src/game/assets.h
index d0fe270..9841f40 100644
--- a/src/game/assets.h
+++ b/src/game/assets.h
@@ -1,9 +1,11 @@
 #pragma once
 #include "../util/typedef.h"
 #include "../util/file.h"
+#include "SDL_mouse.h"
 
 
 typedef struct {
+  SDL_Cursor* cursors[SDL_NUM_SYSTEM_CURSORS];
   struct GL_FONT*  font;
   struct GL_FONT*  jpn12;
   struct GL_FONT*  jpn16;
@@ -13,6 +15,7 @@ typedef struct {
 } GAME_ASSETS;
 
 extern void assets_init( struct GAME_DATA* game );
+extern void assets_destroy( struct GAME_DATA* game );
 extern void assets_create_fonts( struct GAME_DATA* game );
 // extensions is a null-terminated array of null-terminated strings.
 extern LIST<FILE_ENTRY> assets_get_files_by_ext_dir( const char** extensions, const char* dir );
diff --git a/src/game/physics/movement.cpp b/src/game/physics/movement.cpp
index 4cb669f..ac4ab02 100644
--- a/src/game/physics/movement.cpp
+++ b/src/game/physics/movement.cpp
@@ -6,14 +6,14 @@
 #include "../../game/objlist.h"
 
 GAME_MOVEMENT* gmove;
-CVAR* mv_gravity = var_new( "mv_gravity", 800.f );
-CVAR* mv_friction = var_new( "mv_friction", 4.f );
-CVAR* mv_accelerate = var_new( "mv_accelerate", 5.f );
-CVAR* mv_airaccelerate = var_new( "mv_airaccelerate", 12.f );
-CVAR* mv_wallboost = var_new( "mv_wallboost", 0 );
-CVAR* mv_maxspeed = var_new( "mv_maxspeed", 3500.f );
-CVAR* mv_stopspeed = var_new( "mv_stopspeed", 80.f );
-CVAR* mv_jump_impulse = var_new( "mv_jump_impulse", 301.993377f ); // csgo - sqrt(2 * 800 * 57 - jump height)
+CVAR* mv_gravity = var_new( "mv_gravity", "world gravity", 800.f );
+CVAR* mv_friction = var_new( "mv_friction", "ground friction", 4.f );
+CVAR* mv_accelerate = var_new( "mv_accelerate", "ground acceleration", 5.f );
+CVAR* mv_airaccelerate = var_new( "mv_airaccelerate", "air acceleration", 12.f );
+CVAR* mv_wallboost = var_new( "mv_wallboost", "preserve speed when clipping vel against wall", 0 );
+CVAR* mv_maxspeed = var_new( "mv_maxspeed", "max vel per axis", 3500.f );
+CVAR* mv_stopspeed = var_new( "mv_stopspeed", "min speed to calc ground friction", 80.f );
+CVAR* mv_jump_impulse = var_new( "mv_jump_impulse", "jump force", 301.993377f ); // csgo - sqrt(2 * 800 * 57 - jump height)
 
 const U32 NON_JUMP_VELOCITY = 140.f;
 
diff --git a/src/game/player.cpp b/src/game/player.cpp
index e4c0390..a1dc3b8 100644
--- a/src/game/player.cpp
+++ b/src/game/player.cpp
@@ -34,7 +34,7 @@ void capture_mouse( PLAYER* p ) {
   F32*  yaw = &p->input.cam.pos.y;
   F32*  pitch = &p->input.cam.pos.x;
 
-  if( input.keys[SDL_SCANCODE_F1] ) {
+  if( input.mouselock && input.keys[SDLK_ESCAPE] ) {
     input_capture_mouse( 0 );
   }
 
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 );
 }
diff --git a/src/game/vars.h b/src/game/vars.h
index 253effb..754979c 100644
--- a/src/game/vars.h
+++ b/src/game/vars.h
@@ -10,11 +10,18 @@ enum CvarTypes_t {
   CVAR_TYPE_LAST
 };
 
-typedef I32(*CVAR_FUNC)( struct CVAR* self, const char* cmdline );
+enum CvarFlags_t {
+  CVAR_FLAG_NONE = 0,
+  CVAR_FLAG_MINMAX = 1 << 1,
+};
+
+typedef I32(*CVAR_FUNC)( struct CVAR* self, LIST<STR> cmdline );
 
 struct CVAR {
   STR  name;
   U8   type;
+  STR  desc;
+  U32  flags;
   union {
     F32 fl_v;
     I32 i_v;
@@ -30,6 +37,16 @@ struct CVAR {
     CVAR_FUNC fn_v;
     char str_v[64];
   } default_v;
+
+  union {
+    F32 fl_v;
+    I32 i_v;
+  } min_v;
+
+  union {
+    F32 fl_v;
+    I32 i_v;
+  } max_v;
 };
 
 struct VAR_LIST {
@@ -38,18 +55,32 @@ struct VAR_LIST {
 
 extern VAR_LIST* vars_init();
 
-extern CVAR* var_new( const char* name, F32 v );
-extern CVAR* var_new( const char* name, I32 v );
-extern CVAR* var_new( const char* name, CLR v );
-extern CVAR* var_new( const char* name, const char* v );
-extern CVAR* var_new( const char* name, CVAR_FUNC fn );
+extern CVAR* var_new( const char* name, STR desc, F32 v );
+extern CVAR* var_new(
+  const char* name,
+  STR desc,
+  F32 v,
+  F32 min_v,
+  F32 max_v
+);
+extern CVAR* var_new( const char* name, STR desc, I32 v );
+extern CVAR* var_new(
+  const char* name,
+  STR desc,
+  I32 v,
+  I32 min_v,
+  I32 max_v
+);
+extern CVAR* var_new( const char* name, STR desc, CLR v );
+extern CVAR* var_new( const char* name, STR desc, const char* v );
+extern CVAR* var_new( const char* name, STR desc, CVAR_FUNC fn );
 
 extern CVAR* var_find( const char* name );
-extern I32 var_call( CVAR* cmdvar, const char* cmdline );
+extern I32 var_call( CVAR* cmdvar, LIST<STR> cmdline );
 extern F32 var_getf( CVAR* var );
 extern I32 var_geti( CVAR* var );
 extern CLR var_getclr( CVAR* var );
-extern const char* var_gets( CVAR* var );
+extern STR var_gets( const CVAR* var );
 
 extern void var_set( CVAR* var, F32 v );
 extern void var_set( CVAR* var, I32 v );