Momentum-Apps/apps_source_code/racegame/race.c

#include <stdio.h>
#include <furi.h>
#include <gui/gui.h>
#include <input/input.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <furi_hal_resources.h>
#include <furi_hal_gpio.h>
#include <notification/notification_messages.h>

#define BORDER_OFFSET 1
#define MARGIN_OFFSET 3
#define BLOCK_HEIGHT 6
#define BLOCK_WIDTH 6

#define FIELD_WIDTH 11
#define FIELD_HEIGHT 24
#define PARALLEL_OBSTACLES 3

typedef enum { GameStatePlaying, GameStateGameOver } GameState;

typedef struct Point {
    // Also used for offset data, which is sometimes negative
    int8_t x, y;
} Point;

typedef enum { CarObstacle } ObstacleType;

typedef struct Obstacle {
    ObstacleType type;
    Point position;
    bool isAlive;
} Obstacle;

typedef struct {
    bool playField[FIELD_HEIGHT][FIELD_WIDTH];
    uint16_t score;
    Obstacle obstacles[PARALLEL_OBSTACLES];
    int8_t roadStart;
    int8_t level;
    Point headPosition;
    uint16_t motionSpeed;
    GameState gameState;
    FuriTimer* timer;
} RaceState;

typedef enum {
    EventTypeTick,
    EventTypeKey,
} EventType;

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

static void race_game_draw_playfield(Canvas* const canvas, RaceState* race_state) {
    // Playfield: 11 x 24

    for(int y = 0; y < FIELD_HEIGHT; y++) {
        for(int x = 0; x < FIELD_WIDTH; x++) {
            if(race_state->playField[y][x]) {
                uint16_t xOffset = x * 5;
                uint16_t yOffset = y * 5;

                canvas_draw_rframe(
                    canvas,
                    BORDER_OFFSET + MARGIN_OFFSET + xOffset,
                    BORDER_OFFSET + MARGIN_OFFSET + yOffset - 1,
                    BLOCK_WIDTH,
                    BLOCK_HEIGHT,
                    1);
                canvas_draw_dot(
                    canvas,
                    BORDER_OFFSET + MARGIN_OFFSET + xOffset + 2,
                    BORDER_OFFSET + MARGIN_OFFSET + yOffset + 1);
                canvas_draw_dot(
                    canvas,
                    BORDER_OFFSET + MARGIN_OFFSET + xOffset + 3,
                    BORDER_OFFSET + MARGIN_OFFSET + yOffset + 1);
                canvas_draw_dot(
                    canvas,
                    BORDER_OFFSET + MARGIN_OFFSET + xOffset + 2,
                    BORDER_OFFSET + MARGIN_OFFSET + yOffset + 2);
            }
        }
    }
}

static void race_game_draw_border(Canvas* canvas) {
    canvas_draw_line(canvas, 0, 0, 0, 127);
    canvas_draw_line(canvas, 0, 127, 63, 127);
    canvas_draw_line(canvas, 63, 127, 63, 0);

    canvas_draw_line(canvas, 2, 0, 2, 125);
    canvas_draw_line(canvas, 2, 125, 61, 125);
    canvas_draw_line(canvas, 61, 125, 61, 0);
}

static void race_game_init_road(RaceState* race_state) {
    int leftRoad = race_state->roadStart;
    int rightRoad = race_state->roadStart + 1;
    if(rightRoad == 4) rightRoad = 0;
    for(int y = 0; y < FIELD_HEIGHT; y++) {
        leftRoad++;
        rightRoad++;
        if(leftRoad < 4) {
            race_state->playField[y][0] = true;
        }
        if(rightRoad < 4) {
            race_state->playField[y][10] = true;
        }
        if(rightRoad == 4) rightRoad = 0;
        if(leftRoad == 4) leftRoad = 0;
    }
}

static void draw_callback(Canvas* canvas, void* ctx) {
    RaceState* race_state = ctx;
    if(race_state == NULL) {
        FURI_LOG_E("RaceGame", "state is null");
        return;
    }

    canvas_clear(canvas);

    race_game_draw_border(canvas);
    race_game_draw_playfield(canvas, race_state);
    /*
    // output player score, looks not good
    if(race_state->gameState == GameStatePlaying) {
        char buffer2[6];
        snprintf(buffer2, sizeof(buffer2), "%u", race_state->score);
        canvas_draw_str_aligned(canvas, 48, 10, AlignRight, AlignBottom, buffer2);
    }
    else  */
    if(race_state->gameState == GameStateGameOver) {
        // 128 x 64
        canvas_set_color(canvas, ColorWhite);
        canvas_draw_box(canvas, 1, 52, 62, 24);

        canvas_set_color(canvas, ColorBlack);
        canvas_draw_frame(canvas, 1, 52, 62, 24);

        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 4, 63, "Game Over");

        char buffer[13];
        snprintf(buffer, sizeof(buffer), "Score: %u", race_state->score);
        canvas_set_font(canvas, FontSecondary);
        canvas_draw_str_aligned(canvas, 32, 73, AlignCenter, AlignBottom, buffer);
    }
}

static void input_callback(InputEvent* input_event, void* ctx) {
    furi_assert(ctx);
    FuriMessageQueue* event_queue = ctx;
    RaceGameEvent event = {.type = EventTypeKey, .input = *input_event};
    furi_message_queue_put(event_queue, &event, FuriWaitForever);
}

static void timer_callback(FuriMessageQueue* event_queue) {
    furi_assert(event_queue);
    RaceGameEvent event = {.type = EventTypeTick};
    furi_message_queue_put(event_queue, &event, 0);
}

static void race_game_init_state(RaceState* race_state) {
    race_state->gameState = GameStatePlaying;
    race_state->score = 0;
    race_state->level = 0;
    race_state->roadStart = 0;
    race_state->motionSpeed = 500;
    Point p = {.x = 5, .y = 20};
    race_state->headPosition = p;
    for(int i = 0; i < PARALLEL_OBSTACLES; i++) {
        Obstacle obstacle = {.type = CarObstacle, .isAlive = false, .position = {.x = 0, .y = 0}};
        race_state->obstacles[i] = obstacle;
    }
    memset(race_state->playField, 0, sizeof(race_state->playField));
    furi_timer_start(race_state->timer, race_state->motionSpeed);
}

static void race_game_draw_car(RaceState* race_state, Point p, bool changeState) {
    static Point pointsToCheck[] = {{0, 0}, {0, 1}, {-1, 1}, {1, 1}, {0, 2}, {-1, 3}, {1, 3}};
    for(int i = 0; i < 7; i++) {
        if(p.x + pointsToCheck[i].x > -1 && p.y + pointsToCheck[i].y > -1 &&
           p.x + pointsToCheck[i].x < FIELD_WIDTH && p.y + pointsToCheck[i].y < FIELD_HEIGHT) {
            if(changeState &&
               race_state->playField[p.y + pointsToCheck[i].y][p.x + pointsToCheck[i].x]) {
                race_state->gameState = GameStateGameOver;
            }
            race_state->playField[p.y + pointsToCheck[i].y][p.x + pointsToCheck[i].x] = true;
        }
    }
}
static void race_game_move_obstacles(RaceState* race_state) {
    for(int i = 0; i < PARALLEL_OBSTACLES; i++) {
        if(race_state->obstacles[i].isAlive) {
            race_state->obstacles[i].position.y++;
            if(race_state->obstacles[i].position.y > (FIELD_HEIGHT - 1))
                race_state->obstacles[i].isAlive = false;
        }
    }
}
static void race_game_spawn_obstacles(RaceState* race_state) {
    if(race_state->score % 90 == 0) {
        int aliveObjects = 0;

        for(int i = 0; i < PARALLEL_OBSTACLES; i++) {
            if(race_state->obstacles[i].isAlive) {
                aliveObjects++;
            }
        }
        if(aliveObjects < PARALLEL_OBSTACLES) {
            for(int i = 0; i < PARALLEL_OBSTACLES; i++) {
                if(!race_state->obstacles[i].isAlive) {
                    race_state->obstacles[i].isAlive = true;
                    race_state->obstacles[i].position.y = -4;
                    race_state->obstacles[i].position.x = (rand() % 3) * 3 + 2;
                    break;
                }
            }
        }
    }
}
static void race_game_process_step(RaceState* race_state, bool moveRoad) {
    if(race_state->gameState == GameStateGameOver) return;

    // calculate field boundaries
    if(race_state->headPosition.x < 2) race_state->headPosition.x = 2;
    if(race_state->headPosition.x > (FIELD_WIDTH - 3))
        race_state->headPosition.x = (FIELD_WIDTH - 3);
    if(race_state->headPosition.y < 0) race_state->headPosition.y = 0;
    if(race_state->headPosition.y > (FIELD_HEIGHT - 4))
        race_state->headPosition.y = (FIELD_HEIGHT - 4);
    for(int y = 0; y < FIELD_HEIGHT; y++) {
        for(int x = 0; x < FIELD_WIDTH; x++) {
            race_state->playField[y][x] = false;
        }
    }

    if(moveRoad) {
        race_state->score += 10;
        race_state->roadStart++;
        if(race_state->roadStart == 4) race_state->roadStart = 0;
        race_game_spawn_obstacles(race_state);
        race_game_move_obstacles(race_state);
        if(race_state->score % 500 == 0) {
            if(race_state->level < 9) {
                race_state->level++;
                race_state->motionSpeed = race_state->motionSpeed - 50;
                furi_timer_stop(race_state->timer);
                furi_timer_start(race_state->timer, race_state->motionSpeed);
            }
        }
    }

    for(int i = 0; i < PARALLEL_OBSTACLES; i++) {
        if(race_state->obstacles[i].isAlive) {
            race_game_draw_car(race_state, race_state->obstacles[i].position, false);
        }
    }
    race_game_draw_car(race_state, race_state->headPosition, true);
    race_game_init_road(race_state);
}

int32_t race_app(void* p) {
    UNUSED(p);

    srand(DWT->CYCCNT);

    // current custom event element
    RaceGameEvent event;

    RaceState* race_state = malloc(sizeof(RaceState));
    FuriMutex* state_mutex = furi_mutex_alloc(FuriMutexTypeRecursive);

    // Queue on 8 events
    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(RaceGameEvent));

    race_state->timer = furi_timer_alloc(timer_callback, FuriTimerTypePeriodic, event_queue);

    race_game_init_state(race_state);

    // Creating viewport
    ViewPort* view_port = view_port_alloc();
    // Set viewpoint orientation to vertical
    view_port_set_orientation(view_port, ViewPortOrientationVertical);

    // creating draw callback without context
    // view_port_draw_callback_set(view_port, draw_callback, &state_mutex);
    view_port_draw_callback_set(view_port, draw_callback, race_state);

    // setting up and all input events go to our event queue
    view_port_input_callback_set(view_port, input_callback, event_queue);

    // creating gui
    Gui* gui = furi_record_open(RECORD_GUI);
    // adding our view port to gui in full screen mode
    gui_add_view_port(gui, view_port, GuiLayerFullscreen);

    // Бесконечный цикл обработки очереди событий
    for(bool processing = true; processing;) {
        furi_mutex_acquire(state_mutex, 1000);
        //         RaceState* race_state = (RaceState*)furi_mutex_block(&state_mutex, 1000);

        // Выбираем событие из очереди в переменную event (ждем бесконечно долго, если очередь пуста)
        // и проверяем, что у нас получилось это сделать
        furi_check(furi_message_queue_get(event_queue, &event, FuriWaitForever) == FuriStatusOk);
        bool moveRoad = false;
        if(event.type == EventTypeKey) {
            // Если нажата кнопка "назад", то выходим из цикла, а следовательно и из приложения
            switch(event.input.key) {
            case InputKeyBack:
                processing = false;
                break;
            case InputKeyOk:
                if(race_state->gameState == GameStateGameOver) {
                    race_game_init_state(race_state);
                }
                break;
            case InputKeyUp:
                race_state->headPosition.y -= 1;
                break;
            case InputKeyDown:
                race_state->headPosition.y += 1;
                break;
            case InputKeyRight:
                race_state->headPosition.x += 1;
                break;
            case InputKeyLeft:
                race_state->headPosition.x -= 1;
                break;
            default:
                break;
            }
            // Наше событие — это сработавший таймер
        } else if(event.type == EventTypeTick) {
            //Move road and obstacles with timer ticks
            moveRoad = true;
        }
        race_game_process_step(race_state, moveRoad);
        view_port_update(view_port);
        furi_mutex_release(state_mutex);
    }
    // clearing everything on game exit

    // clear game timer
    furi_timer_free(race_state->timer);

    // clear message queue
    furi_message_queue_free(event_queue);

    // clearing ui
    gui_remove_view_port(gui, view_port);
    view_port_free(view_port);
    furi_record_close(RECORD_GUI);

    return 0;
}