Haxe

also the reason I want to use damping rather than acceleration is because acceleration would be linear

other than the basic damping function which is just `n - n * factor`

for some reason when I do it my player just gets insane velocities

Can you explain the values in `n - n * factor` ? And is factor > or < 1.0 ? And what is the range of values of n ?

This is my movement code (excluding jump code)
```hx
        if (controls.binds['left'].pressed())
        {
            if (direction == RIGHT && character.velocity.x > 20)
            {
                character.velocity.x -= MathUtil.damp(character.velocity.x, .8);
                // trace('okb', character.velocity.x);
            }
            else
            {
                character.velocity.x = -speed;
                direction = LEFT;
            }
        }
        else if (controls.binds['right'].pressed())
        {
            if (direction == LEFT && character.velocity.x < 20)
            {
                character.velocity.x += MathUtil.damp(character.velocity.x, .8);
                // trace('okc', character.velocity.x);
            }
            else
            {
                character.velocity.x = speed;
                direction = RIGHT;
            }
        }
        else
        {
            direction = NONE;
            character.velocity.x = 0;
        }
```

If you're moving left and then turn right without stopping, you just get a hellish negative velocity like -18K

image

```hx
// MathUtil.damp()
    public static inline function damp(n:Float, factor:Float)
    {
        return n - n * factor;
    }
```

I was supposed to check for -20 when turning left-to-riht

Actually flixel uses constant drag, not linearly proportional drag

Even still you can use flixel's acceleration and still use your own drag system

Those numbers are incredibly close to 0 btw

-1e-32 is like 0.(31 zeros)1 or -1 * 10^-32

Kinda the main reason i dont like proportional drag, tbh

you need an epsilon value and chop it off at some point

oh, always rather than thresholding ? sure - that'd work and it's simpler

don't forget velocity is in pixels per second, not pixels per frame

pixels per frame maybe I'd round to nearest 0.1

I guess it would depend about on the scale and what's noticeable in gameplay

flixel rounds your position by default, anyway, so no one will notice a 0 < veloctity < 1