Momentum-Apps/jetpack_joyride/jetpack.c

#include <stdlib.h>

#include <jetpack_game_icons.h>
#include <furi.h>
#include <gui/gui.h>
#include <gui/icon_animation.h>
#include <input/input.h>
#include <storage/storage.h>

#include "includes/point.h"
#include "includes/barry.h"
#include "includes/scientist.h"
#include "includes/particle.h"
#include "includes/coin.h"
#include "includes/missile.h"
#include "includes/background_assets.h"

#include "includes/game_state.h"

#define TAG "Jetpack Game"

#define SAVING_FILENAME APP_DATA_PATH("jetpack.save")
static GameState* global_state;

typedef enum {
    EventTypeTick,
    EventTypeKey,
} EventType;

typedef struct {
    EventType type;
    InputEvent input;
} GameEvent;

typedef struct {
    int max_distance;
    int total_coins;
} SaveGame;

static SaveGame save_game;

static bool storage_game_state_load() {
    Storage* storage = furi_record_open(RECORD_STORAGE);
    storage_common_migrate(storage, EXT_PATH("apps/Games/jetpack.save"), SAVING_FILENAME);
    File* file = storage_file_alloc(storage);

    uint16_t bytes_readed = 0;
    if(storage_file_open(file, SAVING_FILENAME, FSAM_READ, FSOM_OPEN_EXISTING))
        bytes_readed = storage_file_read(file, &save_game, sizeof(SaveGame));
    storage_file_close(file);
    storage_file_free(file);
    furi_record_close(RECORD_STORAGE);
    return bytes_readed == sizeof(SaveGame);
}

static void storage_game_state_save() {
    Storage* storage = furi_record_open(RECORD_STORAGE);

    File* file = storage_file_alloc(storage);
    if(storage_file_open(file, SAVING_FILENAME, FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
        storage_file_write(file, &save_game, sizeof(SaveGame));
    }
    storage_file_close(file);
    storage_file_free(file);
    furi_record_close(RECORD_STORAGE);
}

void handle_death() {
    global_state->state = GameStateGameOver;
    global_state->new_highscore = global_state->distance > save_game.max_distance;

    if(global_state->distance > save_game.max_distance) {
        save_game.max_distance = global_state->distance;
    }

    save_game.total_coins += global_state->total_coins;

    storage_game_state_save();
}

static void jetpack_game_state_init(GameState* const game_state) {
    UNUSED(game_state);
    UNUSED(storage_game_state_save);
    BARRY barry;
    barry.gravity = 0;
    barry.point.x = 32 + 5;
    barry.point.y = 32;
    barry.isBoosting = false;

    GameSprites sprites;
    sprites.barry = icon_animation_alloc(&A_barry);
    sprites.barry_infill = &I_barry_infill;

    sprites.scientist_left = (&I_scientist_left);
    sprites.scientist_left_infill = (&I_scientist_left_infill);
    sprites.scientist_right = (&I_scientist_right);
    sprites.scientist_right_infill = (&I_scientist_right_infill);

    sprites.coin = (&I_coin);
    sprites.coin_infill = (&I_coin_infill);

    sprites.missile = icon_animation_alloc(&A_missile);
    sprites.missile_infill = &I_missile_infill;

    sprites.alert = icon_animation_alloc(&A_alert);

    icon_animation_start(sprites.barry);
    icon_animation_start(sprites.missile);
    icon_animation_start(sprites.alert);

    game_state->barry = barry;
    game_state->total_coins = 0;
    game_state->distance = 0;
    game_state->new_highscore = false;
    game_state->sprites = sprites;
    game_state->state = GameStateLife;
    game_state->death_handler = handle_death;

    memset(game_state->bg_assets, 0, sizeof(game_state->bg_assets));

    memset(game_state->scientists, 0, sizeof(game_state->scientists));
    memset(game_state->coins, 0, sizeof(game_state->coins));
    memset(game_state->particles, 0, sizeof(game_state->particles));
    memset(game_state->missiles, 0, sizeof(game_state->missiles));
}

static void jetpack_game_state_free(GameState* const game_state) {
    icon_animation_free(game_state->sprites.barry);
    icon_animation_free(game_state->sprites.missile);
    icon_animation_free(game_state->sprites.alert);

    free(game_state);
}

static void jetpack_game_tick(GameState* const game_state) {
    if(game_state->state == GameStateGameOver) return;
    barry_tick(&game_state->barry);
    game_state_tick(game_state);
    coin_tick(game_state->coins, &game_state->barry, &game_state->total_coins);
    particle_tick(game_state->particles, game_state->scientists);
    scientist_tick(game_state->scientists);
    missile_tick(game_state->missiles, &game_state->barry, game_state->death_handler);

    background_assets_tick(game_state->bg_assets);

    // generate background every 64px aka. ticks
    if(game_state->distance % 64 == 0 && rand() % 3 == 0) {
        spawn_random_background_asset(game_state->bg_assets);
    }

    if(game_state->distance % 48 == 0 && rand() % 2 == 0) {
        spawn_random_coin(game_state->coins);
    }

    if(game_state->distance % get_rocket_spawn_distance(game_state->distance) == 0 &&
       rand() % 2 == 0) {
        spawn_random_missile(game_state->missiles);
    }

    spawn_random_scientist(game_state->scientists);

    if(game_state->barry.isBoosting) {
        spawn_random_particles(game_state->particles, &game_state->barry);
    }
}

static void jetpack_game_render_callback(Canvas* const canvas, void* ctx) {
    furi_assert(ctx);
    const GameState* game_state = ctx;
    furi_mutex_acquire(game_state->mutex, FuriWaitForever);

    if(game_state->state == GameStateLife) {
        canvas_set_bitmap_mode(canvas, false);

        draw_background_assets(game_state->bg_assets, canvas, game_state->distance);

        canvas_set_bitmap_mode(canvas, true);

        draw_coins(game_state->coins, canvas, &game_state->sprites);
        draw_scientists(game_state->scientists, canvas, &game_state->sprites);
        draw_particles(game_state->particles, canvas);
        draw_missiles(game_state->missiles, canvas, &game_state->sprites);

        draw_barry(&game_state->barry, canvas, &game_state->sprites);

        canvas_set_color(canvas, ColorBlack);
        canvas_set_font(canvas, FontSecondary);
        char buffer[12];
        snprintf(buffer, sizeof(buffer), "%u m", game_state->distance / 10);
        canvas_draw_str_aligned(canvas, 123, 15, AlignRight, AlignBottom, buffer);

        snprintf(buffer, sizeof(buffer), "$%u", game_state->total_coins);
        canvas_draw_str_aligned(canvas, 5, 15, AlignLeft, AlignBottom, buffer);
    }

    if(game_state->state == GameStateGameOver) {
        // Show highscore
        char buffer[64];

        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str_aligned(canvas, 64, 5, AlignCenter, AlignTop, "You flew");

        snprintf(
            buffer,
            sizeof(buffer),
            game_state->new_highscore ? "%u m (new best)" : "%u m",
            game_state->distance / 10);
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str_aligned(canvas, 64, 16, AlignCenter, AlignTop, buffer);

        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str_aligned(canvas, 64, 30, AlignCenter, AlignTop, "and collected");

        snprintf(buffer, sizeof(buffer), "$%u", game_state->total_coins);
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str_aligned(canvas, 64, 41, AlignCenter, AlignTop, buffer);

        snprintf(
            buffer,
            sizeof(buffer),
            "Best: %u m, Tot: $%u",
            save_game.max_distance / 10,
            save_game.total_coins);
        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str_aligned(canvas, 64, 63, AlignCenter, AlignBottom, buffer);

        canvas_draw_rframe(canvas, 0, 3, 128, 49, 5);

        // char buffer[12];
        // snprintf(buffer, sizeof(buffer), "Dist: %u", game_state->distance);
        // canvas_draw_str_aligned(canvas, 123, 12, AlignRight, AlignBottom, buffer);

        // snprintf(buffer, sizeof(buffer), "Score: %u", game_state->points);
        // canvas_draw_str_aligned(canvas, 5, 12, AlignLeft, AlignBottom, buffer);

        // canvas_draw_str_aligned(canvas, 64, 34, AlignCenter, AlignCenter, "Highscore:");
        // snprintf(buffer, sizeof(buffer), "Dist: %u", save_game.max_distance);
        // canvas_draw_str_aligned(canvas, 123, 50, AlignRight, AlignBottom, buffer);

        // snprintf(buffer, sizeof(buffer), "Score: %u", save_game.max_score);
        // canvas_draw_str_aligned(canvas, 5, 50, AlignLeft, AlignBottom, buffer);

        // canvas_draw_str_aligned(canvas, 64, 32, AlignCenter, AlignCenter, "boom.");

        // if(furi_timer_is_running(game_state->timer)) {
        //     furi_timer_start(game_state->timer, 0);
        // }
    }

    // canvas_draw_frame(canvas, 0, 0, 128, 64);

    furi_mutex_release(game_state->mutex);
}

static void jetpack_game_input_callback(InputEvent* input_event, void* context) {
    furi_assert(context);

    FuriMessageQueue* event_queue = context;
    GameEvent event = {.type = EventTypeKey, .input = *input_event};
    furi_message_queue_put(event_queue, &event, FuriWaitForever);
}

static void jetpack_game_update_timer_callback(void* context) {
    furi_assert(context);

    FuriMessageQueue* event_queue = context;
    GameEvent event = {.type = EventTypeTick};
    furi_message_queue_put(event_queue, &event, 0);
}

int32_t jetpack_game_app(void* p) {
    UNUSED(p);
    int32_t return_code = 0;

    if(!storage_game_state_load()) {
        memset(&save_game, 0, sizeof(save_game));
    }

    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(GameEvent));

    GameState* game_state = malloc(sizeof(GameState));

    global_state = game_state;
    jetpack_game_state_init(game_state);

    game_state->mutex = furi_mutex_alloc(FuriMutexTypeNormal);
    if(!game_state->mutex) {
        FURI_LOG_E(TAG, "cannot create mutex\r\n");
        return_code = 255;
        goto free_and_exit;
    }

    // Set system callbacks
    ViewPort* view_port = view_port_alloc();
    view_port_draw_callback_set(view_port, jetpack_game_render_callback, game_state);
    view_port_input_callback_set(view_port, jetpack_game_input_callback, event_queue);

    FuriTimer* timer =
        furi_timer_alloc(jetpack_game_update_timer_callback, FuriTimerTypePeriodic, event_queue);
    furi_timer_start(timer, furi_kernel_get_tick_frequency() / 25);

    game_state->timer = timer;

    // Open GUI and register view_port
    Gui* gui = furi_record_open(RECORD_GUI);
    gui_add_view_port(gui, view_port, GuiLayerFullscreen);

    GameEvent event;
    for(bool processing = true; processing;) {
        FuriStatus event_status = furi_message_queue_get(event_queue, &event, 100);
        furi_mutex_acquire(game_state->mutex, FuriWaitForever);

        if(event_status == FuriStatusOk) {
            // press events
            if(event.type == EventTypeKey) {
                if(event.input.type == InputTypeRelease && event.input.key == InputKeyOk) {
                    game_state->barry.isBoosting = false;
                }

                // Reset highscore, for debug purposes
                if(event.input.type == InputTypeLong && event.input.key == InputKeyLeft) {
                    save_game.max_distance = 0;
                    save_game.total_coins = 0;
                    storage_game_state_save();
                }

                if(event.input.type == InputTypePress) {
                    switch(event.input.key) {
                    case InputKeyUp:
                        break;
                    case InputKeyDown:
                        break;
                    case InputKeyRight:
                        break;
                    case InputKeyLeft:
                        break;
                    case InputKeyOk:
                        if(game_state->state == GameStateGameOver) {
                            jetpack_game_state_init(game_state);
                        }

                        if(game_state->state == GameStateLife) {
                            // Do something
                            game_state->barry.isBoosting = true;
                        }

                        break;
                    case InputKeyBack:
                        processing = false;
                        break;
                    default:
                        break;
                    }
                }
            } else if(event.type == EventTypeTick) {
                jetpack_game_tick(game_state);
            }
        }

        furi_mutex_release(game_state->mutex);
        view_port_update(view_port);
    }

    furi_timer_free(timer);
    view_port_enabled_set(view_port, false);
    gui_remove_view_port(gui, view_port);
    furi_record_close(RECORD_GUI);
    view_port_free(view_port);
    furi_mutex_free(game_state->mutex);

free_and_exit:
    jetpack_game_state_free(game_state);
    furi_message_queue_free(event_queue);

    return return_code;
}