cpp-cheat/sdl/animation_user_control_inertia.c

/*Some basic inertia / friction on a single body.

Gives a strong sense of realism.

Makes you want to play around with two or more bodies and collision detection,
but that can only lead to a time consuming broken re-implementation of a subset
of Box2D... right?
*/

#include "common.h"

#define WINDOW_WIDTH 800
#define WINDOW_HEIGHT WINDOW_WIDTH
#define WINDOW_CENTER_X (WINDOW_WIDTH / 2)
#define WINDOW_CENTER_Y (WINDOW_HEIGHT / 2)
#define WINDOW_HEIGHT WINDOW_WIDTH
#define RECT_WIDTH (WINDOW_WIDTH / 50)
#define RECT_HEIGHT RECT_WIDTH
#define MAX_RECT_POS (WINDOW_WIDTH - RECT_WIDTH)
/*
 * Accelerations in meters per second.
 *
 * I like to think like this: how long will it take to cross the screen
 * starting from speed 0 with this constant acceleration?
 *
 * Remember that:
 *
 * x = acc * t^2 / 2
 *
 * so if:
 *
 * - `acc = MAX_RECT_POS * 2.0`  it takes 1       second  to cross the screen
 * - `acc = MAX_RECT_POS`        it takes sqrt(2) seconds to cross the screen
 * - `acc = MAX_RECT_POS / 2.0`  it takes 2       seconds to cross the screen
 **/
#define ACC_USER_METERS_PER_SECOND     (MAX_RECT_POS)
#define ACC_FRICTION_METERS_PER_SECOND (MAX_RECT_POS / 2.5)
#define ACC_GRAVITY_METERS_PER_SECOND  (MAX_RECT_POS / 1.5)

typedef struct {
    double
        x,
        y,
        speed_x,
        speed_y
    ;
} PlayerState;

void init_state(
    PlayerState *player_state,
    double *user_acc_x,
    double *user_acc_y,
    unsigned int *last_time
) {
    player_state->x = WINDOW_WIDTH / 2.0;
    player_state->y = WINDOW_HEIGHT / 2.0;
    player_state->speed_x = 0.0;
    player_state->speed_y = 0.0;

    /* Encode if the movement keys are initially pressed or not. */
    *user_acc_x = 0.0;
    *user_acc_y = 0.0;

    *last_time = SDL_GetTicks();
    common_fps_init();
}

double get_new_coord(double x, double step) {
    x += step;
    x = fmod(x, MAX_RECT_POS);
    if (x < 0)
        x = MAX_RECT_POS;
    return x;
}

/* A constant force in the direction opposite to movement,
 * or stop the movement if it is too slow.
 * */
double apply_constant_friction(double speed, double dt) {
    double dv;
    dv = ACC_FRICTION_METERS_PER_SECOND * dt;
    if (fabs(speed) < dv)
        speed = 0.0;
    else
        speed -= copysign(dv, speed);
    return speed;
}

int main(void) {
    PlayerState player_state;
    SDL_Event event;
    SDL_Rect rect, rect_sun;
    SDL_Renderer *renderer;
    SDL_Window *window;
    int quit = 0;
    unsigned int current_time, last_time;
    double dt, acc_x, acc_y, user_acc_x, user_acc_y;

    SDL_Init(SDL_INIT_TIMER | SDL_INIT_VIDEO);
    SDL_CreateWindowAndRenderer(WINDOW_WIDTH, WINDOW_HEIGHT, 0, &window, &renderer);
    SDL_SetWindowTitle(window, "arrow keys: accelerate | esc: reset | q: quit");
    rect.w = RECT_WIDTH;
    rect.h = RECT_HEIGHT;
    rect_sun.w = RECT_WIDTH;
    rect_sun.h = RECT_HEIGHT;
    rect_sun.x = WINDOW_CENTER_X;
    rect_sun.y = WINDOW_CENTER_Y;
main_loop:
    init_state(&player_state, &user_acc_x, &user_acc_y, &last_time);
    while (!quit) {
        while (SDL_PollEvent(&event) == 1) {
            if (event.type == SDL_QUIT) {
                quit = 1;
            } else if (event.type == SDL_KEYDOWN) {
                switch (event.key.keysym.sym) {
                    case SDLK_LEFT:
                        user_acc_x = -1;
                        break;
                    case SDLK_RIGHT:
                        user_acc_x = 1;
                        break;
                    case SDLK_UP:
                        user_acc_y = -1;
                        break;
                    case SDLK_DOWN:
                        user_acc_y = 1;
                        break;
                    case SDLK_ESCAPE:
                        goto main_loop;
                    case SDLK_q:
                        goto quit;
                }
            } else if (event.type == SDL_KEYUP) {
                switch (event.key.keysym.sym) {
                    case SDLK_LEFT:
                    case SDLK_RIGHT:
                        user_acc_x = 0;
                        break;
                    case SDLK_UP:
                    case SDLK_DOWN:
                        user_acc_y = 0;
                        break;
                }
            }
        }
        current_time = SDL_GetTicks();
        if (current_time != last_time) {
            dt = (current_time - last_time) / 1000.0;

            /* Player movement. */
            acc_x = user_acc_x * ACC_USER_METERS_PER_SECOND;
            acc_y = user_acc_y * ACC_USER_METERS_PER_SECOND;

            /* Other forces. */
            {
                /* Constant gravity down. */
                /*acc_y += ACC_GRAVITY_METERS_PER_SECOND;*/

                /* Constant gravity to center of screen, the "sun". */
                {
                    double dx = player_state.x - WINDOW_CENTER_X;
                    double dy = player_state.y - WINDOW_CENTER_Y;
                    double angle = atan2(dy, dx);
                    double hyp = hypot(dx, dy);

                    /* TODO Failed attempt at force proportional to inverse square of distance. */
                    /*double mod = hyp > 0.001 ? hyp : 1.0;*/
                    /*double mod2 = mod * mod;*/

                    acc_x -= cos(angle) * ACC_GRAVITY_METERS_PER_SECOND;
                    acc_y -= sin(angle) * ACC_GRAVITY_METERS_PER_SECOND;
                }
            }

            /* Update speed. */
            player_state.speed_x += dt * acc_x;
            player_state.speed_y += dt * acc_y;

            /*
            Constant friction
            - decelerates very quickly
            - speed is limited to a maximum
            Ideally this force should be added to the acceleration simply,
            but we must consider the case where the object stops completely
            because of it separately.
            */
            /*player_state.speed_x = apply_constant_friction(player_state.speed_x, dt);*/
            /*player_state.speed_y = apply_constant_friction(player_state.speed_y, dt);*/

            /* Friction  proportional to speed:
            - decelerates very quickly
            - speed is limited to a maximum
            Does not feel very natural.
            */
            /* player_state.speed_x *= 0.999; */
            /* player_state.speed_y *= 0.999; */

            /* Update position. */
            player_state.x = get_new_coord(player_state.x, player_state.speed_x * dt);
            player_state.y = get_new_coord(player_state.y, player_state.speed_y * dt);

            /* Render. */
            SDL_SetRenderDrawColor(renderer, 0, 0, 0, 0);
            SDL_RenderClear(renderer);
            SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
            rect.x = player_state.x;
            rect.y = player_state.y;
            SDL_RenderFillRect(renderer, &rect);
            SDL_SetRenderDrawColor(renderer, 0, 0, 255, 255);
            SDL_RenderFillRect(renderer, &rect_sun);
            SDL_RenderPresent(renderer);

            /* Update time. */
            last_time = current_time;
        }
        common_fps_update_and_print();
    }
quit:
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
    return EXIT_SUCCESS;
}