Відтворення фізики в стилі ретро / NES з навмисною точністю


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
@Gajet що? Він точно описав проблему.
Майк Семер

@maikSemder: Мені просто цікаво, як він реалізував двигун фізики, щоб дати рішення на основі свого коду.
Ali1S232

Дайте мені знати, якщо вам потрібні додаткові деталі, я не хотів писати гігантський пост, боюсь, я отримаю відповіді.
Зак Людина

Відповіді:


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();
}

EDIT : Я також додав перетворення до float та float та output

Створений результат такий же, як у таблиці:

 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
@Zack Ви дуже раді, раді допомогти, особливо для такого приємного питання :)
Maik Semder

1
@Zack у випадку, коли вас цікавить, я додав клас фіксованої точки, який належним чином обробляє від’ємні числа для порівняння
Maik Semder
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.