added:
A real max lift is about 2x your own body weight, but anything over 1x is unsustainable. I suggest encumbMult=1.0 so that the top-half of the encumbrance bar doesn't go unused and give players an unrealistic impression of how much they can carry. If you want you can allow temporary heavy lifts where E > 1.0 (over encumbered) and have them drop it or collapse when S < Smin.


removed:
-
-Movement speeds are measured as the fraction of Max unencumbered, unfatiged flat running speed::
-
-  V is fraction of Max speed.

changed:
-  Smax = H^(1/healthExp)
  Smax = 1 - woundMult*(1-H)^woundExp

changed:
-  healthExp=2, but can be turned up to delay the onset of wound effects.
-
-Note RF uses Smax=1-(1-H)^healthExp instead, which compared to the above makes drains less for small injuries, but more for big ones, making it harder to "turn the tables" in combat. The above formula is probably better for gameplay.
  woundMult=1.0, but can be turned down to reduce the severity of wound effects.
  woundExp=2, but can be turned up to delay the onset of wound effects.
  Smax is the max stamina limit applied because of wounds

Note setting woundMult > 1.0 means actors will run out of stamina and collapse before they die.

changed:
-  H = H + dH
-  dSmax = H^(1/healthExp) - Smax
-  dS = dSmax * S/Smax
-  Smax = Smax + dSmax
-  S = S + dS
  onHit(dH):
    H = H + dH
    dSmax = 1 - woundMult*(1-H)^woundExp - Smax
    dS = dSmax * S/Smax
    Smax = Smax + dSmax
    S = S + dS

changed:
-  Smin = (0.5 * encumbMult * E)^encumbExp
  Smin = liftMult*E^liftExp

changed:
-  encumbMult=1.0, for a max lift in number of your own body weights.
-  encumbExp=2.0, but can be tuned up to delay the onset of encumbrance effects.
-
-A real max lift is about 2x your own body weight, but anything over 1x is unsustainable. I suggest encumbMult=1.0 so that the top-half of the encumbrance bar doesn't go unused and give players an unrealistic impression of how much they can carry. If you want you can allow temporary heavy lifts where E > 1.0 (over encumbered) and have them drop it or collapse when S < Smin.
  liftMult = (0.5 * encumbMult)^liftExp = 0.25, but can be turned down to reduce the stamina burn from encumbrance.
  liftExp = 2, but can be turned up to delay the onset of stamina burn from encumbrance.
  Smin is the minimum stamina required to lift what the actor is carrying.

changed:
-Recovery
-========
-
-Fatigued muscles (that are not wounded) continuously recover at a constant rate. This is how stamina recovers::
-
-  Erest = (Smax - S)
-  dS = R * Erest * dt
Moving
=======

This is is how stamina is recovered and burned when standing/walking/running, and movement speed varies with stamina and encumbrance. We use the following tunable constants::

  upMult = 10.0, is the cost of climbing up per meter relative to other things.
  downMult = 2.0, is the cost of going down per meter relative to other things.
  runMult=1.0 is the cost of running relative to other things.
  walkMult=16.0 is the cost of walking relative to other things.
  runSpeedMult=1.0 is the max running speed as a fraction of moveMax. Can be turned down to reduce running speed and stamina burn.
  walkSpeedMult=0.2 is max walking speed as a fraction of moveMax. Can be tuned down to reduce walking speed and stamina burn.
  moveMax=10.0 is the maximum flat running speed in meters/sec.

Studies on walking/running on gradients show going uphill/downhill is about 12.5x/2.5x as expensive/meter as running horizontally, so upMult=12.5, downMult=2.5. Record 15m speed climbing top speed is 6.26sec, or about 2m/sec, compared to 100m record top speeds of about 12m/sec, which suggests climbing vertically uses only ~6x the energy as horizontal running and half as much as uphill running. I suspect that climbing using both arms and legs allows double the power output compared to running with just legs, but the energy/meter is the same. It often surprises players how much affect climbing really has, and games tend to have exaggerated gradients. For playability I suggest lower values like upMult=10.0 and downMult=2.0, or even upMult=6.0 and downMult=1.2.

You can adjust runSpeedMult down to allow a slower run with less stamina burn. Using runSpeedMult=1.0 means run as fast as possible. Using runspeed=0.5 would be equivalent to a marathon runners fast jog at ~5m/s.

You can adjust walkSpeedMult to allow faster/slower walking with more/less stamina burn. Using walkSpeedMult=0.25 represents a realistic maximum fast walking speed of ~2.5m/sec. Realistic minimum energy walk speed is walkSpeedMult=0.125, but would probably try the patience of gamers. Using walkSpeedMult=0.2 is a brisk walking speed of ~2m/sec, and is a good gaming compromise between energy saving and speed.

For moveMax, record 100m top speeds average about 10m/sec and peak at 12m/sec. A realistic maximum running speed (for a hero) would be about 10m/sec.

We calculate the movement speeds and stamina burns each frame like this::

  Srest = (Smax - S)
  climbMult = max(upMult*climbRate, -downMult*climbRate)
  moveSpeedMult = 1/(climbMult + moveMult)
  moveMult = 1/((climbRate/0.1)^2 + 1)
  if isStanding:
    Slift = Smin
  else:
    Slift = 0.0
  if isRunning:
    moveScale = moveSpeedMult * runSpeedMult * (S-Smin)/M
    Smove = moveMult * runMult * M * moveScale
  elif isWalking:
    moveScale = moveSpeedMult * walkSpeedMult * sqrt((S-Smin)/M)
    Smove = moveMult * walkMult * M * moveScale^2
  else:
    moveScale = 0.0
    Smove = 0.0
  Sclimb = climbMult * M * moveScale
  moveSpeed = moveScale * moveMax
  dS = (R*Srest - F*(Slift + Smove + Sclimb)) * dt
  S = S + dS

where::

  Srest is the fraction of all muscles that are fatigued and resting.
  Slift is the fraction of all muscles applied to lifting.
  Smove is the fraction of all muscles applied to moving.
  Sclimb is the fraction of all muscles applied to climbing.
  climbRate is vertical movement per total distance moved.
  climbMult is the cost of climbing based on the gradient.
  moveSpeedMult is the scaling factor for movement speeds walking/running for the gradient.
  moveMult is the scaling factor for energy spent walking/running for the gradient.
  moveScale is movement speed as a fraction of moveMax.
  moveSpeed is the moving speed in meters/sec.
  dt is the time since the last frame.
  dS is the change in S for this frame.

If you are not standing and are collapsed, lying down, or sitting, then you are not actually lifting anything so Slift=0.0. We don't make Smin zero in this case to make it clear what your minimum stamina is to stand.

The climbRate can be calculated from the surface gradient directly, or from movement over the last frame. It should probably be low-pass filtered so jitter/bob doesn't burn fatigue like crazy. This is done by actually calculating it with::

  dd = sqrt(dz^2 + dy^2 + dz^2)
  if dd > 0.0 and isRunning or isWalking:
    climbRateNow = dz/dd = sin(climbAngle)
  else:
    climbRateNow = 0.0
  climbRate = (dt*climbRateNow + climbRC*climbRate)/(dt + climbRC)

changed:
-  Erest is the fraction of all muscles that are fatigued and resting.
-
-Note that stamina S cannot increase past Smax.
-
-Lifting
-=====
-
-Lifting stuff not only pre-occupies muscles, but also fatigues them. This is how stamina is constantly burned by encumbrance when standing::
-
-  Elift = Klift * Smin
-  dS = -F * Elift * dt
-
-Where::
-
-  Klift=1.0 is the cost of lifting relative to other things.
-  Elift is the fraction of all muscles applied to lifting.
-
-Climbing
-========
-
-Going uphill or downhill uses energy:::
-
-  climbRate = dz/dd = sin(climbAngle)
-  Kclimb = max(Kup*climbRate, -Kdown*climbRate)
-  Eclimb = Kclimb * M * V
-  dS = -F * Eclimb * dt
-  climbScale = 1/((climbRate/0.1)^2 + 1)
-
-Where::
-
-  dz is vertical travel distance.
-  dd is total travel distance.
  dx,dy,dz is x,y,z travel distance in the last frame.
  dd is total travel distance in the last frame.

changed:
-  climbRate is vertical movement per total distance moved.
-  Kup = 10.0, is the cost of climbing up per meter relative to other things.
-  Kdown = 2.0, is the cost of going down per meter relative to other things.
-  Kclimb  is the cost of climbing based on the gradient.
-  Eclimb is the fraction of all muscles applied to climbing.
-  climbScale is the scaling factor for energy spent walking/running.
-
-Studies on walking/running on gradients show going uphill/downhill is about 12.5x/2.5x as expensive/meter as running horizontally, so Kup=12.5, Kdown=2.5. Record 15m speed climbing top speed is 6.26sec, or about 2m/sec, compared to 100m record top speeds of about 12m/sec, which suggests climbing vertically uses only ~6x the energy as horizontal running and half as much as uphill running. I suspect that climbing using both arms and legs allows double the power output compared to running with just legs, but the energy/meter is the same.
-
-It often surprises players how much affect climbing really has, and games tend to have exaggerated gradients. For playability I suggest lower values like Kup=10.0 and Kdown=2.0, or even Kup=6.0 and Kdown=1.2.
-
-climbRate should probably be low-pass filtered so jitter/bob doesn't burn fatigue like crazy. This is done by actually calculating it with::
-
-  climbRate = (dt*ds/dd + RC*climbRate)/(dt + RC)
-
-Where::
-
-  RC = 0.5, but can be tweaked to adjust smoothing.
-
-Walking
-=======
-
-This is how stamina is burned when walking, and how walking speed varies with stamina and encumbrance::
-
-  V = moveScale = walkMult * ((S - Smin)/M)^(1/2) / (climbScale + Kclimb)
-  Ewalk = climbScale * Kwalk * M * V^2
-  dS = -F * Ewalk * dt
-
-Where::
-
-  moveScale is movement speed as a fraction of max run speed.
-  Kwalk = 16.0 is the cost of walking relative to other things.
-  Ewalk is the fraction of all muscles applied to walking.
-  walkMult = 0.2 is max walking speed as a fraction of max run speed. Can be tuned down to reduce walking speed and stamina burn.
-
-Using walkMult=0.25 represents a realistic maximum fast walking speed of around 2.5m/sec. Realistic minimum energy walk speed is walkMult=0.125, but would probably try the patience of gamers. Using walkMult=0.2 is a brisk walking speed of 2m/sec, and is a good gaming compromise between energy saving and speed.
-
-Running
-=======
-
-This is is how stamina is burned when running, and running speed varies with stamina and encumbrance::
-
-  V = moveScale = (S-Smin)/(M * (Kclimb + climbScale*Krun))
-  Erun = climbScale * Krun * M * V
-  dS = -F * Erun * dt
-
-where::
-
-  moveScale is movement speed as a fraction of max run speed.
-  Krun=1.0 is the cost of running relative to other things.
-  Erun is the fraction of all muscles applied to running.
-  moveSpeed is the running speed as a fraction of max running speed.
-
-Record 100m top speeds average about 10m/sec and peak at 12m/sec. A realistic maximum running speed (for a hero) would be about 10m/sec.
  climbRC = 0.5, is the climbRate lowpass filter time-constant. Can be tweaked to adjust smoothing.

You also need to be wary of things like lifts to ensure that dz changes from going up/down on lifts doesn't burn fatigue and make actors collapse. RF detects this by checking the actor is running/walking and the gradient is not too steep.

changed:
-  dS = -F * (S - Smin)
-  jumpScale = (S - Smin)/M
-  jumpHeight = jumpScale * jumpMax
-  jumpVelocity = sqrt(2*g*jumpHeight)
  onJump:
    jumpScale = (S - Smin)/M
    jumpHeight = jumpScale * jumpMax
    jumpVelocity = sqrt(2*g*jumpHeight)
    dS = -F * jumpMult * (S - Smin)
    S = S + dS

changed:
-  Kj = 2, but can be tuned down to reduce encumbrance effects on jumping.
  jumpMult = 1.0, but can be tuned down to reduce encumbrance effects on jumping.

changed:
-A jump burns as much fatigue as running for 1 second. 
Using jumpMult=1.0 means a jump burns as much stamina as running for 1 second. 

H - health. The fraction of life remaining after taking damage.
S - stamina. The fraction of un-damaged, un-fatigued muscles available for lifting/moving/fighting/etc.
E - encumbrance. The fraction of max lift worth of equipment currently carried.

F - stamina burn rate, stamina/second
R - stamina recovery rate, stamina/second

M = 1.0 + encumbMult*E

encumbMult = 1.0, the "max" lift in number of your own body weights when E=1.0.

Smax = 1 - woundMult*(1-H)^woundExp

woundMult=1.0, but can be turned down to reduce the severity of wound effects.
woundExp=2, but can be turned up to delay the onset of wound effects.
Smax is the max stamina limit applied because of wounds

onHit(dH):
  H = H + dH
  dSmax = 1 - woundMult*(1-H)^woundExp - Smax
  dS = dSmax * S/Smax
  Smax = Smax + dSmax
  S = S + dS

dH is the change in health.
dSmax is the change in Smax
dS is the change in S

Smin = liftMult*E^liftExp

liftMult = (0.5 * encumbMult)^liftExp = 0.25, but can be turned down to reduce the stamina burn from encumbrance.
liftExp = 2, but can be turned up to delay the onset of stamina burn from encumbrance.
Smin is the minimum stamina required to lift what the actor is carrying.

upMult = 10.0, is the cost of climbing up per meter relative to other things.
downMult = 2.0, is the cost of going down per meter relative to other things.
runMult=1.0 is the cost of running relative to other things.
walkMult=16.0 is the cost of walking relative to other things.
runSpeedMult=1.0 is the max running speed as a fraction of moveMax. Can be turned down to reduce running speed and stamina burn.
walkSpeedMult=0.2 is max walking speed as a fraction of moveMax. Can be tuned down to reduce walking speed and stamina burn.
moveMax=10.0 is the maximum flat running speed in meters/sec.

Srest = (Smax - S)
climbMult = max(upMult*climbRate, -downMult*climbRate)
moveSpeedMult = 1/(climbMult + moveMult)
moveMult = 1/((climbRate/0.1)^2 + 1)
if isStanding:
  Slift = Smin
else:
  Slift = 0.0
if isRunning:
  moveScale = moveSpeedMult * runSpeedMult * (S-Smin)/M
  Smove = moveMult * runMult * M * moveScale
elif isWalking:
  moveScale = moveSpeedMult * walkSpeedMult * sqrt((S-Smin)/M)
  Smove = moveMult * walkMult * M * moveScale^2
else:
  moveScale = 0.0
  Smove = 0.0
Sclimb = climbMult * M * moveScale
moveSpeed = moveScale * moveMax
dS = (R*Srest - F*(Slift + Smove + Sclimb)) * dt
S = S + dS

Srest is the fraction of all muscles that are fatigued and resting.
Slift is the fraction of all muscles applied to lifting.
Smove is the fraction of all muscles applied to moving.
Sclimb is the fraction of all muscles applied to climbing.
climbRate is vertical movement per total distance moved.
climbMult is the cost of climbing based on the gradient.
moveSpeedMult is the scaling factor for movement speeds walking/running for the gradient.
moveMult is the scaling factor for energy spent walking/running for the gradient.
moveScale is movement speed as a fraction of moveMax.
moveSpeed is the moving speed in meters/sec.
dt is the time since the last frame.
dS is the change in S for this frame.

dd = sqrt(dz^2 + dy^2 + dz^2)
if dd > 0.0 and isRunning or isWalking:
  climbRateNow = dz/dd = sin(climbAngle)
else:
  climbRateNow = 0.0
climbRate = (dt*climbRateNow + climbRC*climbRate)/(dt + climbRC)

dx,dy,dz is x,y,z travel distance in the last frame.
dd is total travel distance in the last frame.
climbAngle is the elevation angle of the direction travelled.
climbRC = 0.5, is the climbRate lowpass filter time-constant. Can be tweaked to adjust smoothing.

onJump:
  jumpScale = (S - Smin)/M
  jumpHeight = jumpScale * jumpMax
  jumpVelocity = sqrt(2*g*jumpHeight)
  dS = -F * jumpMult * (S - Smin)
  S = S + dS

jumpMult = 1.0, but can be tuned down to reduce encumbrance effects on jumping.
jumpScale is the jump height as a fraction of max jump height.
jumpMax is the maximum unfatigued, unencumbered jump height in meters.
jumpHeight is the height of the jump in meters.
jumpVelocity is take-off velocity in meters/sec (for physics models).
g = 9.81m/s^2 is the gravitational constant.

dS = -F * W * (S - Smin)