Add reversi from https://github.com/xMasterX/all-the-plugins

git-subtree-dir: reversi
git-subtree-mainline: aed4077d681c204ed1d199c2121ce967d57f7c29
git-subtree-split: d0e05bc5dccd1fdb319a7f16999b184914a4de6b

reversi/.github/workflows/build-flp.yml

@@ -0,0 +1,27 @@
+name: FlipperZero
+
+on:
+  push:
+    branches: [ "main" ]
+  pull_request:
+    branches: [ "main" ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v3
+
+    - name: Build
+      uses: oleksiikutuzov/flipperzero-ufbt-action@v1
+      with:
+        channel: release
+
+    - name: Artifacts
+      uses: actions/upload-artifact@v3
+      with:
+        name: game_reversi.fap
+        path: /home/runner/work/flipperzero-reversi/flipperzero-reversi/dist/game_reversi.fap
+        if-no-files-found: warn

reversi/.gitsubtree

@@ -0,0 +1 @@
+https://github.com/xMasterX/all-the-plugins dev apps_source_code/reversi

reversi/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Eugene Kirzhanov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

reversi/README.md

@@ -0,0 +1,34 @@
+# Reversi game for Flipper Zero
+
+![Game screen](images/game.png)
+![Menu screen](images/menu.png)
+![You win](images/win.png)
+
+## Compile
+1. Clone [firmware](https://github.com/flipperdevices/flipperzero-firmware)
+2. Go to the `applications_user` directory
+3. Create a symlink to this repo assuming that these two repos are on the same level:
+```sh
+ln -s ../../flipperzero-reversi flipperzero-reversi
+```
+4. From the main directory of the firmware run:
+```sh
+./fbt faps
+```
+
+## Install
+1. Open folder `./build/f7-firmware-D/.extapps/` from the firmware directory
+2. Open qFlipper
+3. Open File Manager, SD Card/apps/games
+4. Drag `game_reversi.fapp` to qFlipper
+
+## Controls
+The game controls should be intuitive.
+Longs press on OK opens the menu to start a new game.
+
+## Thanks to:
+- [2048 game](https://github.com/eugene-kirzhanov/flipper-zero-2048-game)
+
+## License
+[MIT](LICENSE)
+Copyright 2023 Dmitry Matyukhin

reversi/application.fam

@@ -0,0 +1,19 @@
+App(
+    appid="reversi",
+    name="Reversi",
+    apptype=FlipperAppType.EXTERNAL,
+    entry_point="game_reversi_app",
+    cdefines=["APP_GAME_REVERSI"],
+    requires=[
+        "gui",
+    ],
+    stack_size=1 * 1024,
+    order=90,
+    fap_icon="game_reversi.png",
+    fap_category="Games",
+    fap_icon_assets_symbol="game_reversi",
+    fap_author="@dimat",
+    fap_weburl="https://github.com/zyuhel/flipperzero-racegame",
+    fap_version="1.2",
+    fap_description="Reversi game, the game controls should be intuitive. Longs press on OK opens the menu to start a new game.",
+)

reversi/game_reversi.c

@@ -0,0 +1,359 @@
+// Game "Reversi" for Flipper Zero
+// Copyright 2023 Dmitry Matyukhin
+
+#include <stdio.h>
+#include <furi.h>
+#include <gui/gui.h>
+#include <input/input.h>
+#include <storage/storage.h>
+#include "reversi.h"
+
+#define FRAME_LEFT 3
+#define FRAME_TOP 3
+#define FRAME_CELL_SIZE 7
+
+#define SAVING_DIRECTORY "/ext/apps/Games"
+#define SAVING_FILENAME SAVING_DIRECTORY "/game_reversi.save"
+
+typedef enum { AppScreenGame, AppScreenMenu } AppScreen;
+
+typedef struct {
+    GameState game;
+    AppScreen screen;
+    uint8_t selected_menu_item;
+    FuriMutex* mutex;
+} AppState;
+
+#define MENU_ITEMS_COUNT 2
+static const char* popup_menu_strings[] = {"Resume", "New Game"};
+
+static void draw_menu(Canvas* const canvas, const AppState* app_state);
+static void gray_canvas(Canvas* const canvas);
+
+static void input_callback(InputEvent* input_event, void* ctx) {
+    furi_assert(ctx);
+    FuriMessageQueue* event_queue = ctx;
+    furi_message_queue_put(event_queue, input_event, FuriWaitForever);
+}
+
+static void draw_callback(Canvas* const canvas, void* ctx) {
+    furi_assert(ctx);
+    const AppState* app_state = ctx;
+    furi_mutex_acquire(app_state->mutex, FuriWaitForever);
+
+    const GameState* game_state = &app_state->game;
+
+    canvas_clear(canvas);
+    canvas_set_color(canvas, ColorBlack);
+
+    for(uint8_t i = 0; i <= BOARD_SIZE; i++) {
+        canvas_draw_line(
+            canvas,
+            FRAME_LEFT + FRAME_CELL_SIZE * i,
+            FRAME_TOP,
+            FRAME_LEFT + FRAME_CELL_SIZE * i,
+            FRAME_TOP + FRAME_CELL_SIZE * BOARD_SIZE);
+        canvas_draw_line(
+            canvas,
+            FRAME_LEFT,
+            FRAME_TOP + FRAME_CELL_SIZE * i,
+            FRAME_LEFT + FRAME_CELL_SIZE * BOARD_SIZE,
+            FRAME_TOP + FRAME_CELL_SIZE * i);
+    }
+    //
+    // draw cursor
+    canvas_set_color(canvas, ColorWhite);
+    canvas_draw_frame(
+        canvas,
+        FRAME_LEFT + FRAME_CELL_SIZE * game_state->cursor_x,
+        FRAME_TOP + FRAME_CELL_SIZE * game_state->cursor_y,
+        FRAME_CELL_SIZE + 1,
+        FRAME_CELL_SIZE + 1);
+
+    canvas_set_color(canvas, ColorBlack);
+    // draw pieces
+    int blacks = 0, whites = 0;
+    const int radius = FRAME_CELL_SIZE >> 1;
+    for(uint8_t i = 0; i < BOARD_SIZE; i++) {
+        for(uint8_t j = 0; j < BOARD_SIZE; j++) {
+            if(!game_state->board[i][j]) {
+                continue;
+            }
+            if(game_state->board[i][j] == BLACK) {
+                canvas_draw_disc(
+                    canvas,
+                    FRAME_LEFT + FRAME_CELL_SIZE * i + radius + 1,
+                    FRAME_TOP + FRAME_CELL_SIZE * j + radius + 1,
+                    radius);
+                blacks++;
+            } else {
+                canvas_draw_circle(
+                    canvas,
+                    FRAME_LEFT + FRAME_CELL_SIZE * i + radius + 1,
+                    FRAME_TOP + FRAME_CELL_SIZE * j + radius + 1,
+                    radius);
+                whites++;
+            }
+        }
+    }
+
+    canvas_set_font(canvas, FontPrimary);
+    // draw score
+    char score_str[25];
+    memset(score_str, 0, sizeof(score_str));
+    snprintf(score_str, sizeof(score_str), "%d - %d", whites, blacks);
+
+    canvas_draw_str_aligned(canvas, 70, 3, AlignLeft, AlignTop, score_str);
+
+    canvas_set_font(canvas, FontSecondary);
+    if(game_state->is_game_over) {
+        canvas_draw_str_aligned(canvas, 70, 20, AlignLeft, AlignTop, "Game over");
+
+        canvas_draw_str_aligned(
+            canvas,
+            70,
+            FRAME_TOP + FRAME_CELL_SIZE * BOARD_SIZE,
+            AlignLeft,
+            AlignBottom,
+            "Press OK");
+
+        canvas_set_font(canvas, FontPrimary);
+
+        if(whites == blacks) {
+            canvas_draw_str_aligned(canvas, 70, 30, AlignLeft, AlignTop, "DRAW");
+        } else if(
+            ((game_state->human_color == WHITE) && whites > blacks) ||
+            ((game_state->human_color == BLACK) && blacks > whites)) {
+            canvas_draw_str_aligned(canvas, 70, 30, AlignLeft, AlignTop, "YOU WIN");
+        } else {
+            canvas_draw_str_aligned(canvas, 70, 30, AlignLeft, AlignTop, "YOU LOSE");
+        }
+    } else if(game_state->current_player == game_state->human_color) {
+        canvas_draw_str_aligned(canvas, 70, 12, AlignLeft, AlignTop, "Your turn");
+    } else {
+        canvas_draw_str_aligned(canvas, 70, 12, AlignLeft, AlignTop, "Computer turn");
+    }
+
+    if(app_state->screen == AppScreenMenu) {
+        draw_menu(canvas, app_state);
+    }
+
+    furi_mutex_release(app_state->mutex);
+}
+
+static void draw_menu(Canvas* const canvas, const AppState* app_state) {
+    gray_canvas(canvas);
+    canvas_set_color(canvas, ColorWhite);
+    canvas_draw_rbox(canvas, 28, 16, 72, 32, 4);
+    canvas_set_color(canvas, ColorBlack);
+    canvas_draw_rframe(canvas, 28, 16, 72, 32, 4);
+
+    for(int i = 0; i < MENU_ITEMS_COUNT; i++) {
+        if(i == app_state->selected_menu_item) {
+            canvas_set_color(canvas, ColorBlack);
+            canvas_draw_box(canvas, 34, 20 + 12 * i, 60, 12);
+        }
+
+        canvas_set_color(canvas, i == app_state->selected_menu_item ? ColorWhite : ColorBlack);
+        canvas_draw_str_aligned(
+            canvas, 64, 26 + 12 * i, AlignCenter, AlignCenter, popup_menu_strings[i]);
+    }
+}
+
+static void gray_canvas(Canvas* const canvas) {
+    canvas_set_color(canvas, ColorWhite);
+    for(int x = 0; x < 128; x += 2) {
+        for(int y = 0; y < 64; y++) {
+            canvas_draw_dot(canvas, x + (y % 2 == 1 ? 0 : 1), y);
+        }
+    }
+}
+
+bool load_game(GameState* game_state) {
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    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, game_state, sizeof(GameState));
+    }
+    storage_file_close(file);
+    storage_file_free(file);
+
+    furi_record_close(RECORD_STORAGE);
+
+    return bytes_readed == sizeof(GameState);
+}
+
+void save_game(const GameState* game_state) {
+    Storage* storage = furi_record_open(RECORD_STORAGE);
+
+    if(storage_common_stat(storage, SAVING_DIRECTORY, NULL) == FSE_NOT_EXIST) {
+        if(!storage_simply_mkdir(storage, SAVING_DIRECTORY)) {
+            return;
+        }
+    }
+
+    File* file = storage_file_alloc(storage);
+    if(storage_file_open(file, SAVING_FILENAME, FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
+        storage_file_write(file, game_state, sizeof(GameState));
+    }
+    storage_file_close(file);
+    storage_file_free(file);
+
+    furi_record_close(RECORD_STORAGE);
+}
+
+bool handle_key_game(GameState* game_state, InputKey key) {
+    switch(key) {
+    case InputKeyBack:
+        save_game(game_state);
+        return false;
+        break;
+    case InputKeyOk:
+        if(game_state->is_game_over) {
+            init_game(game_state);
+            save_game(game_state);
+        } else {
+            human_move(game_state);
+        }
+        break;
+    case InputKeyUp:
+        if(game_state->cursor_y > 0) {
+            game_state->cursor_y--;
+        } else {
+            game_state->cursor_y = BOARD_SIZE - 1;
+        }
+        break;
+    case InputKeyDown:
+        if(game_state->cursor_y < BOARD_SIZE - 1) {
+            game_state->cursor_y++;
+        } else {
+            game_state->cursor_y = 0;
+        }
+        break;
+    case InputKeyLeft:
+        if(game_state->cursor_x > 0) {
+            game_state->cursor_x--;
+        } else {
+            game_state->cursor_x = BOARD_SIZE - 1;
+        }
+        break;
+    case InputKeyRight:
+        if(game_state->cursor_x < BOARD_SIZE - 1) {
+            game_state->cursor_x++;
+        } else {
+            game_state->cursor_x = 0;
+        }
+        break;
+    default:
+        break;
+    }
+    return true;
+}
+
+bool handle_key_menu(AppState* app_state, InputKey key) {
+    switch(key) {
+    case InputKeyUp:
+        if(app_state->selected_menu_item > 0) {
+            app_state->selected_menu_item--;
+        }
+        break;
+    case InputKeyDown:
+        if(app_state->selected_menu_item < MENU_ITEMS_COUNT - 1) {
+            app_state->selected_menu_item++;
+        }
+        break;
+    case InputKeyOk:
+        if(app_state->selected_menu_item == 1) {
+            // new game
+            init_game(&app_state->game);
+            save_game(&app_state->game);
+        }
+        app_state->screen = AppScreenGame;
+        break;
+    default:
+        break;
+    }
+    return true;
+}
+
+// returns `true` if the event loop should keep going
+bool handle_key(AppState* app_state, InputKey key) {
+    GameState* game_state = &app_state->game;
+
+    switch(app_state->screen) {
+    case AppScreenGame:
+        return handle_key_game(game_state, key);
+        break;
+    case AppScreenMenu:
+        return handle_key_menu(app_state, key);
+        break;
+    }
+    return true;
+}
+
+int32_t game_reversi_app() {
+    AppState app_state;
+    app_state.screen = AppScreenGame;
+    if(!load_game(&app_state.game)) {
+        init_game(&app_state.game);
+    }
+
+    app_state.mutex = furi_mutex_alloc(FuriMutexTypeNormal);
+    if(!app_state.mutex) {
+        return 255;
+    }
+    InputEvent input;
+    FuriMessageQueue* event_queue = furi_message_queue_alloc(8, sizeof(InputEvent));
+
+    ViewPort* view_port = view_port_alloc();
+    view_port_draw_callback_set(view_port, draw_callback, &app_state);
+    view_port_input_callback_set(view_port, input_callback, event_queue);
+
+    Gui* gui = furi_record_open(RECORD_GUI);
+    gui_add_view_port(gui, view_port, GuiLayerFullscreen);
+    bool is_finished = false;
+
+    while(!is_finished) {
+        // check if it's computer's turn
+        if(!app_state.game.is_game_over &&
+           (app_state.game.current_player != app_state.game.human_color)) {
+            computer_move(&app_state.game);
+        }
+        FuriStatus event_status = furi_message_queue_get(event_queue, &input, 100);
+        if(event_status == FuriStatusOk) {
+            // handle only press event, ignore repeat/release events
+
+            if(input.type == InputTypeLong && input.key == InputKeyOk &&
+               app_state.screen == AppScreenGame) {
+                furi_mutex_acquire(app_state.mutex, FuriWaitForever);
+                app_state.selected_menu_item = 0;
+                app_state.screen = AppScreenMenu;
+                
+                furi_mutex_release(app_state.mutex);
+                view_port_update(view_port);
+                continue;
+            }
+            if(input.type != InputTypePress) continue;
+
+            furi_mutex_acquire(app_state.mutex, FuriWaitForever);
+            is_finished = !handle_key(&app_state, input.key);
+
+            furi_mutex_release(app_state.mutex);
+            view_port_update(view_port);
+        }
+        view_port_update(view_port);
+    }
+
+    gui_remove_view_port(gui, view_port);
+    furi_record_close(RECORD_GUI);
+
+    view_port_free(view_port);
+
+    furi_message_queue_free(event_queue);
+
+    furi_mutex_free(app_state.mutex);
+
+    return 0;
+}

reversi/reversi.c

@@ -0,0 +1,168 @@
+// Game "Reversi" for Flipper Zero
+// Copyright 2023 Dmitry Matyukhin
+
+#include "reversi.h"
+
+// Psst! Most of this file was written with Copilot
+
+// Check if the move is legal by checking if it results in any opponent pieces being captured
+bool is_legal_move(int8_t board[BOARD_SIZE][BOARD_SIZE], int row, int col, int player) {
+    if(board[row][col] != 0) return false;
+    int opponent = -player;
+    for(int i = -1; i <= 1; i++) {
+        for(int j = -1; j <= 1; j++) {
+            if(i == 0 && j == 0) continue;
+            int r = row + i, c = col + j;
+            if(r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE && board[r][c] == opponent) {
+                int k = 2;
+                while(true) {
+                    r += i;
+                    c += j;
+                    if(r < 0 || r >= BOARD_SIZE || c < 0 || c >= BOARD_SIZE) break;
+                    if(board[r][c] == player) return true;
+                    if(board[r][c] == 0) break;
+                    k++;
+                }
+            }
+        }
+    }
+    return false;
+}
+
+// Check if the game is over by checking if there are no more moves left for
+// either player
+bool is_game_over(int8_t board[BOARD_SIZE][BOARD_SIZE]) {
+    for(int i = 0; i < BOARD_SIZE; i++) {
+        for(int j = 0; j < BOARD_SIZE; j++) {
+            if(is_legal_move(board, i, j, BLACK) || is_legal_move(board, i, j, WHITE)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}
+
+bool has_legal_moves(int8_t board[BOARD_SIZE][BOARD_SIZE], int8_t player_color) {
+    for(int i = 0; i < BOARD_SIZE; i++) {
+        for(int j = 0; j < BOARD_SIZE; j++) {
+            if(is_legal_move(board, i, j, player_color)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+
+// Calculate the heuristic value of the current board. This function can
+// be replaced with a more complex evaluation function that takes into
+// account factors such as mobility, piece square tables, etc.
+int heuristic(int8_t board[BOARD_SIZE][BOARD_SIZE]) {
+    int white = 0, black = 0;
+    for(int i = 0; i < BOARD_SIZE; i++) {
+        for(int j = 0; j < BOARD_SIZE; j++) {
+            if(board[i][j] == 1) white++;
+            if(board[i][j] == -1) black++;
+        }
+    }
+    return white - black;
+}
+
+// Make a move on the board and capture any opponent pieces
+void make_move(GameState* state, int x, int y, int player) {
+    state->board[x][y] = player;
+    int opponent = -player;
+    for(int i = -1; i <= 1; i++) {
+        for(int j = -1; j <= 1; j++) {
+            if(i == 0 && j == 0) continue;
+            int r = x + i, c = y + j;
+            if(r >= 0 && r < BOARD_SIZE && c >= 0 && c < BOARD_SIZE &&
+               state->board[r][c] == opponent) {
+                int k = 2;
+                while(true) {
+                    r += i;
+                    c += j;
+                    if(r < 0 || r >= BOARD_SIZE || c < 0 || c >= BOARD_SIZE) break;
+                    if(state->board[r][c] == player) {
+                        r -= i;
+                        c -= j;
+                        while(r != x || c != y) {
+                            state->board[r][c] = player;
+                            r -= i;
+                            c -= j;
+                        }
+                        break;
+                    }
+                    if(state->board[r][c] == 0) break;
+                    k++;
+                }
+            }
+        }
+    }
+    state->is_game_over = is_game_over(state->board);
+}
+
+void init_game(GameState* state) {
+    for(int i = 0; i < BOARD_SIZE; i++) {
+        for(int j = 0; j < BOARD_SIZE; j++) {
+            state->board[i][j] = 0;
+        }
+    }
+
+    // Place the initial pieces
+    int mid = BOARD_SIZE / 2;
+    state->board[mid - 1][mid - 1] = WHITE;
+    state->board[mid][mid] = WHITE;
+    state->board[mid - 1][mid] = BLACK;
+    state->board[mid][mid - 1] = BLACK;
+
+    state->cursor_x = mid - 1;
+    state->cursor_y = mid + 1;
+
+    // Set up turn order
+    state->human_color = WHITE;
+    state->current_player = WHITE;
+
+    state->is_game_over = false;
+}
+
+void human_move(GameState* game_state) {
+    if(game_state->current_player != game_state->human_color) {
+        return;
+    }
+
+    if(is_legal_move(
+           game_state->board,
+           game_state->cursor_x,
+           game_state->cursor_y,
+           game_state->current_player)) {
+        make_move(
+            game_state, game_state->cursor_x, game_state->cursor_y, game_state->current_player);
+        game_state->current_player = -game_state->current_player;
+    }
+}
+
+void computer_move(GameState* game_state) {
+    if(game_state->current_player == game_state->human_color) {
+        return;
+    }
+    int best_row = -1, best_col = -1, best_score = -1000000;
+    for(int i = 0; i < BOARD_SIZE; i++) {
+        for(int j = 0; j < BOARD_SIZE; j++) {
+            if(!is_legal_move(game_state->board, i, j, game_state->current_player)) {
+                continue;
+            }
+            int score = heuristic(game_state->board);
+            if(score > best_score) {
+                best_score = score;
+                best_row = i;
+                best_col = j;
+            }
+        }
+    }
+    if(best_row != -1) {
+        make_move(game_state, best_row, best_col, game_state->current_player);
+    }
+    if(has_legal_moves(game_state->board, game_state->human_color)) {
+        game_state->current_player = -game_state->current_player;
+    }
+}

reversi/reversi.h

@@ -0,0 +1,21 @@
+#pragma once
+
+#include <furi.h>
+#include <stdbool.h>
+
+#define BLACK 1
+#define WHITE -1
+#define BOARD_SIZE 8
+
+typedef struct {
+    int8_t board[BOARD_SIZE][BOARD_SIZE];
+    int8_t current_player;
+    int8_t human_color;
+    uint8_t cursor_x;
+    uint8_t cursor_y;
+    uint8_t is_game_over;
+} GameState;
+
+void init_game(GameState* state);
+void computer_move(GameState* game_state);
+void human_move(GameState* game_state);