Воссоздание физики в стиле ретро / РЭШ с преднамеренной неточностью

16

Фон:

У меня проблема с получением правильной кривой скачка для моего проекта римейка ретро-платформера. Оригинальная игра для NES, а скорость игрока хранится в двух отдельных частях: один байт для целого числа и другой для дробной части.

Гравитация добавляется к скорости игрока Y со скоростью 0,25 за кадр.

Когда игрок прыгает, его скорость Y устанавливается на -4.64453125. Остальная часть кривой скачка оставлена ​​гравитации.

Когда игрок поднимается, его вертикальная скорость приближается к 0 со скоростью 0,25 за кадр. Однако, когда скорость игрока достигает значения меньше нуля, скорость изменяется по другому шаблону. Вместо того, чтобы постепенно уменьшаться на 0,25 каждый кадр, он следует этой схеме:

[1.75, -0.25, -0.25, -0.25, 1.75, -0.25, -0.25, -0.25, 1.75, ...]

Похоже, что-то связано с целочисленным переполнением.

Данные:

Вот дамп данных из оригинала. Это таблица скорости.

Jump Curve

Y-Hi Y-Lo    Decimal        Change/Frame
4    165     4.64453125     ?
4    101     4.39453125     -0.25
4    37      4.14453125     -0.25
3    229     3.89453125     -0.25
3    165     3.64453125     -0.25
3    101     3.39453125     -0.25
3    37      3.14453125     -0.25
2    229     2.89453125     -0.25
2    165     2.64453125     -0.25
2    101     2.39453125     -0.25
2    37      2.14453125     -0.25
1    229     1.89453125     -0.25
1    165     1.64453125     -0.25
1    101     1.39453125     -0.25
1    37      1.14453125     -0.25
0    229     0.89453125     -0.25
0    165     0.64453125     -0.25
0    101     0.39453125     -0.25
0    37      0.14453125     -0.25
-1   229     -1.89453125    1.75
-1   165     -1.64453125    -0.25
-1   101     -1.39453125    -0.25
-1   37      -1.14453125    -0.25
-2   229     -2.89453125    1.75
-2   165     -2.64453125    -0.25
-2   101     -2.39453125    -0.25
-2   37      -2.14453125    -0.25
-3   229     -3.89453125    1.75
-3   165     -3.64453125    -0.25
-3   101     -3.39453125    -0.25
-3   37      -3.14453125    -0.25
-4   229     -4.89453125    1.75
-4   165     -4.64453125    -0.25
-4   101     -4.39453125    -0.25
-4   37      -4.14453125    -0.25
-5   229     -5.89453125    1.75
-5   165     -5.64453125    -0.25
-5   101     -5.39453125    -0.25
-5   37      -5.14453125    -0.25
-6   229     -6.89453125    1.75

Проблема:

В моей игре я не смог добиться этого эффекта. Когда скорость меньше нуля, она продолжает регулярно уменьшаться на 0,25, а не по схеме, описанной выше. Вместо того, чтобы хранить целые и дробные части отдельно, я храню их вместе в одной поплавке.

Как достичь этого эффекта?

Зак Человек
источник
1
Если честно, я бы просто сделал скриншоты, чтобы определить его максимальную высоту прыжка / длину в пикселях, и просто настроил вашу текущую функцию, чтобы она выглядела как можно точнее. Вы говорите, что неточность является преднамеренной, поэтому это не должно вызывать проблем?
Джонатан Коннелл
Я думаю, вам нужно опубликовать часть, в которой вы меняете скорость, и точно описать проблему и ваши потребности в коде.
Ali1S232
2
@ Гаджет что? Он точно описал проблему.
Майк Земдер
@maikSemder: мне просто интересно, как он реализовал физический движок, чтобы дать решение на основе своего кода.
Ali1S232
Дайте мне знать, если вам нужно больше подробностей, я не хотел писать гигантский пост из страха, что получу ответы.
Зак The Human

Ответы:

16
one byte for the whole number and another for the fractional part

По сути, вам просто нужно вычесть 64 из low, чтобы вычесть 0,25, потому что 8-битное значение может иметь 256 значений, поэтому 256 * 0,25 = 64 При наличии недостаточного значения lowтакже вычитайте 1 из high.

Отказ от ответственности: этот код намеренно неверен, когда речь идет о отрицательных числах, предполагается, что он моделирует числовые аномалии, описанные в вопросе. Для сравнения в нижней части этого ответа можно найти реализацию правильной обработки отрицательных чисел класса с фиксированной точкой.

struct velocity
{
    char high;
    unsigned char low;

    // fall -0.25
    void fall()
    {
        if(low < 64) --high;
        low -= 64;;
    }

    // convert to a float
    float toFloat() const
    {
        float ret = high;
        float frac = (float)low / 256.0f;
        if(high >= 0) ret += frac;
        else ret -= frac;
        return ret;
    }

    // convert from float
    void fromFloat(float f)
    {
        high = (char)f;
        float frac = f - high;
        low = (unsigned char)(frac * 256.0f);
    }
};

velocity v;
v.high = 4;
v.low = 165;    
for(int i = 0; i < 30; ++i)
{
    printf("%2d     %3d   %f\n", v.high, v.low, v.toFloat());
    v.fall();
}

РЕДАКТИРОВАТЬ : я также добавил преобразование в float и из float и вывод

Сгенерированный вывод такой же, как в вашей таблице:

 4     165   4.644531
 4     101   4.394531
 4      37   4.144531
 3     229   3.894531
 3     165   3.644531
 3     101   3.394531
 3      37   3.144531
 2     229   2.894531
 2     165   2.644531
 2     101   2.394531
 2      37   2.144531
 1     229   1.894531
 1     165   1.644531
 1     101   1.394531
 1      37   1.144531
 0     229   0.894531
 0     165   0.644531
 0     101   0.394531
 0      37   0.144531
-1     229   -1.894531
-1     165   -1.644531
-1     101   -1.394531
-1      37   -1.144531
-2     229   -2.894531
-2     165   -2.644531
-2     101   -2.394531
-2      37   -2.144531
-3     229   -3.894531
-3     165   -3.644531
-3     101   -3.394531
-3      37   -3.144531
-4     229   -4.894531
-4     165   -4.644531
-4     101   -4.394531
-4      37   -4.144531
-5     229   -5.894531
-5     165   -5.644531
-5     101   -5.394531
-5      37   -5.144531
-6     229   -6.894531

В отличие от этого, класс с фиксированной точкой правильно обрабатывает отрицательные числа:

#include <iomanip>
#include <iostream>

struct fixed_point
{
    union
    {
        struct
        {
            unsigned char low;
            signed char high;
        };
        short s;
    };

    float toFloat() const
    {
        fixed_point tmp;
        if(high < 0) tmp.s = ~s;
        else tmp.s = s;

        float ret = tmp.high;
        float frac = (float)tmp.low / 256.0f;
        ret += frac;
        if(high < 0) ret = 0 - ret;
        return ret;
    }

    void fromFloat(float f)
    {
        float tmp;
        if(f < 0.0f) tmp = -f;
        else tmp = f;

        high = (char)tmp;
        float frac = tmp - high;
        low = (unsigned char)(frac * 256.0f);

        if(f < 0.0f) s = ~s;
    }

    fixed_point operator+(const fixed_point &fp) const
    {
        fixed_point ret;
        ret.s = s + fp.s;
        return ret;
    }

    fixed_point operator-(const fixed_point &fp) const
    {
        fixed_point ret;
        ret.s = s - fp.s;
        return ret;
    }

    void print(const char *msg) const
    {
        std::cout << msg << ":" << std::endl;
        std::cout << std::hex << std::uppercase;
        // cout'ing the hex value for a char is kind of a pain ..
        unsigned int _high = 0;
        memcpy(&_high, &high, 1);
        std::cout << "  high : 0x" << std::setfill('0') << std::setw(2) << _high << std::endl;
        unsigned int _low = 0;
        memcpy(&_low, &low, 1);
        std::cout << "  low  : 0x" << std::setfill('0') << std::setw(2) << _low << std::endl;
        std::cout << "  all  : 0x" << std::setfill('0') << std::setw(4) << s << std::endl;
        std::cout << "  float: " << toFloat() << std::endl;
        std::cout << std::endl;
    }
};
Майк Земдер
источник
1
@Zack да, конечно, посмотрите мою структуру позиции, я добавил функцию преобразования в float, которая делает именно это.
Майк Земдер
1
@Zack также добавил конверсию fromFloat
Maik Semder
1
@Maik Вы, сэр, джентльмен. Спасибо за помощь. Это вернет меня на путь.
Зак Человек
1
@ Зак, пожалуйста, очень рады, рады помочь, особенно для такого хорошего вопроса :)
Maik Semder
1
@Зак, если вам интересно, я добавил класс с фиксированной запятой, который правильно обрабатывает отрицательные числа
Maik Semder