VM_stringtokeynum: return a float, not an int

[xonotic/darkplaces.git] / view.c

diff --git a/view.c b/view.c
index 276e9091b566eb996996ea9516c70a93e9cdaaad..d058112c1464e14fbd62b8a3974b80f560935d05 100644 (file)
--- a/view.c
+++ b/view.c
@@ -42,6 +42,9 @@ cvar_t cl_bobup = {CVAR_SAVE, "cl_bobup","0.5", "view bobbing adjustment that ma
 cvar_t cl_bob2 = {CVAR_SAVE, "cl_bob2","0", "sideways view bobbing amount"};
 cvar_t cl_bob2cycle = {CVAR_SAVE, "cl_bob2cycle","0.6", "sideways view bobbing speed"};
 cvar_t cl_bob2smooth = {CVAR_SAVE, "cl_bob2smooth","0.05", "how fast the view goes back when you stop touching the ground"};
+cvar_t cl_bobfall = {CVAR_SAVE, "cl_bobfall","0", "how much the view swings down when falling (influenced by the speed you hit the ground with)"};
+cvar_t cl_bobfallcycle = {CVAR_SAVE, "cl_bobfallcycle","3", "speed of the bobfall swing"};
+cvar_t cl_bobfallminspeed = {CVAR_SAVE, "cl_bobfallminspeed","200", "necessary amount of speed for bob-falling to occur"};
 cvar_t cl_bobmodel = {CVAR_SAVE, "cl_bobmodel", "1", "enables gun bobbing"};
 cvar_t cl_bobmodel_side = {CVAR_SAVE, "cl_bobmodel_side", "0.15", "gun bobbing sideways sway amount"};
 cvar_t cl_bobmodel_up = {CVAR_SAVE, "cl_bobmodel_up", "0.06", "gun bobbing upward movement amount"};
@@ -587,7 +590,7 @@ void V_CalcRefdef (void)
                                VectorAdd(vieworg, cl.punchvector, vieworg);
                                if (cl.stats[STAT_HEALTH] > 0)
                                {
-                                       double xyspeed, bob;
+                                       double xyspeed, bob, bobfall;
                                        float cycle;
                                        vec_t frametime;
 
@@ -638,7 +641,7 @@ void V_CalcRefdef (void)
                                        VectorAdd(vieworg, gunorg, gunorg);
                                        VectorAdd(viewangles, gunangles, gunangles);
 
-                                       // bounded XY speed calculation, used by several effects below
+                                       // bounded XY speed, used by several effects below
                                        xyspeed = bound (0, sqrt(cl.velocity[0]*cl.velocity[0] + cl.velocity[1]*cl.velocity[1]), 400);
 
                                        // vertical view bobbing code
@@ -679,11 +682,11 @@ void V_CalcRefdef (void)
                                                        cycle = sin(M_PI * cycle / 0.5);
                                                else
                                                        cycle = sin(M_PI + M_PI * (cycle-0.5)/0.5);
-                                               bob = xyspeed * bound(0, cl_bob2.value, 0.05) * cycle;
+                                               bob = bound(0, cl_bob2.value, 0.05) * cycle;
 
                                                // this value slowly decreases from 1 to 0 when we stop touching the ground.
                                                // The cycle is later multiplied with it so the view smooths back to normal
-                                               if (cl.onground && !cl.cmd.jump) // also block while the jump button is pressed, to avoid twitches when bunny-hopping
+                                               if (cl.onground && !cl.cmd.jump) // also block the effect while the jump button is pressed, to avoid twitches when bunny-hopping
                                                        cl.bob2_smooth = 1;
                                                else
                                                {
@@ -693,11 +696,11 @@ void V_CalcRefdef (void)
                                                                cl.bob2_smooth = 0;
                                                }
 
-                                               // calculate the side and front of the player between the X and Y axes
+                                               // calculate the front and side of the player between the X and Y axes
                                                AngleVectors(viewangles, forward, right, up);
-                                               // now get the speed based on those angles. The division is for mathing vertical bobbing intensity
-                                               side = DotProduct (cl.velocity, right) / 1000 * cl.bob2_smooth;
-                                               front = DotProduct (cl.velocity, forward) / 1000 * cl.bob2_smooth;
+                                               // now get the speed based on those angles. The bounds should match the same value as xyspeed's
+                                               side = bound(-400, DotProduct (cl.velocity, right) * cl.bob2_smooth, 400);
+                                               front = bound(-400, DotProduct (cl.velocity, forward) * cl.bob2_smooth, 400);
                                                VectorScale(forward, bob, forward);
                                                VectorScale(right, bob, right);
                                                // we use side with forward and front with right, so the bobbing goes
@@ -713,8 +716,34 @@ void V_CalcRefdef (void)
                                                gunorg[1] += bob2vel[1];
                                        }
 
+                                       // fall bobbing code
+                                       // causes the view to swing down and back up when touching the ground
+                                       if (cl_bobfall.value && cl_bobfallcycle.value)
+                                       {
+                                               if (!cl.onground)
+                                               {
+                                                       cl.bobfall_speed = bound(-400, cl.velocity[2], 0) * bound(0, cl_bobfall.value, 0.1);
+                                                       if (cl.velocity[2] < -cl_bobfallminspeed.value)
+                                                               cl.bobfall_swing = 1;
+                                                       else
+                                                               cl.bobfall_swing = 0;
+                                               }
+                                               else
+                                               {
+                                                       if(cl.bobfall_swing > 0)
+                                                               cl.bobfall_swing -= bound(0, cl_bobfallcycle.value * frametime, 1);
+                                                       else
+                                                               cl.bobfall_swing = 0;
+
+                                                       bobfall = sin(M_PI + M_PI * cl.bobfall_swing) * -cl.bobfall_speed;
+                                                       vieworg[2] += bobfall;
+                                                       gunorg[2] += bobfall;
+                                               }
+                                       }
+
                                        // gun model bobbing code
-                                       if (cl_bob.value && cl_bobmodel.value)
+                                       if (cl_bob.value || cl_bob2.value)
+                                       if (cl_bobmodel.value)
                                        {
                                                // calculate for swinging gun model
                                                // the gun bobs when running on the ground, but doesn't bob when you're in the air.
@@ -950,6 +979,9 @@ void V_Init (void)
        Cvar_RegisterVariable (&cl_bob2);
        Cvar_RegisterVariable (&cl_bob2cycle);
        Cvar_RegisterVariable (&cl_bob2smooth);
+       Cvar_RegisterVariable (&cl_bobfall);
+       Cvar_RegisterVariable (&cl_bobfallcycle);
+       Cvar_RegisterVariable (&cl_bobfallminspeed);
        Cvar_RegisterVariable (&cl_bobmodel);
        Cvar_RegisterVariable (&cl_bobmodel_side);
        Cvar_RegisterVariable (&cl_bobmodel_up);