apps/display-demo/app_memgame.c

Go to the documentation of this file.

#include <gfx/gfx.h>
#include <gfx/win.h>
#include <gfx/wtk.h>
#include <gfx/sysfont.h>
#include <stream.h>
#include <string.h>
#include <timer.h>

#include "app_desktop.h"
#include "app_memgame.h"
#include "file_loader.h"


#define NR_OF_PIECE_PAIRS            6

#define NR_OF_PIECES                 (2 * NR_OF_PIECE_PAIRS)

#define NR_OF_BOARD_COLUMNS          4

#define BOARD_POS_X                  30

#define BOARD_POS_Y                  5

#define BACKGROUND_COLOR             GFX_COLOR(0, 0, 0)

#define WIDGET_FONT_SCALE            2



#define PIECE_PAIR_FILE_0            "i_fonts"

#define PIECE_PAIR_FILE_1            "i_pics"

#define PIECE_PAIR_FILE_2            "i_avr"

#define PIECE_PAIR_FILE_3            "i_clock"

#define PIECE_PAIR_FILE_4            "i_files"

#define PIECE_PAIR_FILE_5            "i_games"

#define PIECE_BACK_FILE              "cardback"

#define PIECE_SIZE_X                 57

#define PIECE_SIZE_Y                 PIECE_SIZE_X

#define PIECE_SPACING_X              10

#define PIECE_SPACING_Y              PIECE_SPACING_X

#define PIECE_INVALID_INDEX          0xFF



#define BTN_NEW_GAME_TEXT            "New"

#define BTN_NEW_GAME_POS_X           (APP_EXIT_BUTTON_POS_X -        \
                2 * APP_EXIT_BUTTON_SIZE_X)

#define BTN_NEW_GAME_POS_Y           APP_EXIT_BUTTON_POS_Y

#define BTN_NEW_GAME_SIZE_X          (2 * APP_EXIT_BUTTON_SIZE_X)

#define BTN_NEW_GAME_SIZE_Y          APP_EXIT_BUTTON_SIZE_Y



#define MSG_TRIES_TEXT               "Tries: %i"

#define MSG_TRIES_LENGTH             10

#define MSG_TRIES_POS_X              0

#define MSG_TRIES_POS_Y              (APP_EXIT_BUTTON_POS_Y +         \
                (APP_EXIT_BUTTON_SIZE_Y / 2) -                        \
                (gfx_font_get_height(&sysfont) / 2))

#define MSG_TRIES_SIZE_X             (gfx_get_width() -               \
                APP_EXIT_BUTTON_SIZE_X - BTN_NEW_GAME_SIZE_X)

#define MSG_TRIES_SIZE_Y             gfx_font_get_height(&sysfont)



#define MSG_GAME_OVER_TEXT           "Well done!"

#define MSG_GAME_OVER_SCALE          4

#define MSG_GAME_OVER_POS_X          45

#define MSG_GAME_OVER_POS_Y          105

#define MSG_GAME_OVER_GLOW_OFFSET    1

#define MSG_GAME_OVER_COLOR          GFX_COLOR(255, 160, 0)

#define MSG_GAME_OVER_GLOW_COLOR     GFX_COLOR(250, 250, 250)



#define TIMER_PAUSE_HALF_SECONDS     3

#define TIMER_CLOCK_RATE             (0x1ffffUL / 8)


enum memgame_command_id {
        CMD_NONE,
        CMD_NEW_GAME,
        CMD_EXIT,
};

enum memgame_state {
        DRAW_ALL_PIECES,
        SELECT_FIRST_PIECE,
        SHOWN_FIRST_PIECE,
        SELECT_SECOND_PIECE,
        SHOWN_SECOND_PIECE,
        HIDE_FIRST_PIECE,
        HIDE_SECOND_PIECE,
        HIDDEN_BOTH_PIECES,
        GAME_OVER,
};

struct memgame_piece {
        uint8_t pair;
        bool    found;
};

struct memgame_context {
        struct win_window      *win;
        struct gfx_bitmap      bitmap;
        struct workqueue_task  *task;
        struct font            old_sysfont;
        struct timer           timer;
        uint16_t               timer_delay;
        uint8_t                ticks_to_go;
        struct memgame_piece   pieces[NR_OF_PIECES];
        enum memgame_state     state;
        uint8_t                piece_1;
        uint8_t                piece_2;
        uint8_t                pairs_left;
        uint8_t                tries;
        struct wtk_label       *tries_label;
        bool                   busy;
};

static struct memgame_context *game_ctx;

static uint16_t memgame_rand(void)
{
        static uint16_t seed = 12345;
        seed = (25037 * seed) + 1;
        return seed;
}

#define memgame_print_helper(str, x, y, color) \
        gfx_draw_string(str, x, y, &sysfont, color, GFX_COLOR_TRANSPARENT)

static void memgame_print_game_over(void)
{
#ifdef CONFIG_GFX_USE_CLIPPING
        gfx_set_clipping(0, 0, gfx_get_width(), gfx_get_height());
#endif /* CONFIG_GFX_USE_CLIPPING */

        // Temporarily enlarge the sysfont.
        sysfont.scale = MSG_GAME_OVER_SCALE;

        // Print the string with diagonal offsets.
        memgame_print_helper(MSG_GAME_OVER_TEXT,
                        MSG_GAME_OVER_POS_X + MSG_GAME_OVER_GLOW_OFFSET,
                        MSG_GAME_OVER_POS_Y + MSG_GAME_OVER_GLOW_OFFSET,
                        MSG_GAME_OVER_GLOW_COLOR);

        memgame_print_helper(MSG_GAME_OVER_TEXT,
                        MSG_GAME_OVER_POS_X - MSG_GAME_OVER_GLOW_OFFSET,
                        MSG_GAME_OVER_POS_Y - MSG_GAME_OVER_GLOW_OFFSET,
                        MSG_GAME_OVER_GLOW_COLOR);

        memgame_print_helper(MSG_GAME_OVER_TEXT,
                        MSG_GAME_OVER_POS_X + MSG_GAME_OVER_GLOW_OFFSET,
                        MSG_GAME_OVER_POS_Y - MSG_GAME_OVER_GLOW_OFFSET,
                        MSG_GAME_OVER_GLOW_COLOR);

        memgame_print_helper(MSG_GAME_OVER_TEXT,
                        MSG_GAME_OVER_POS_X - MSG_GAME_OVER_GLOW_OFFSET,
                        MSG_GAME_OVER_POS_Y + MSG_GAME_OVER_GLOW_OFFSET,
                        MSG_GAME_OVER_GLOW_COLOR);

        // Print with no offset.
        memgame_print_helper(MSG_GAME_OVER_TEXT, MSG_GAME_OVER_POS_X,
                        MSG_GAME_OVER_POS_Y, MSG_GAME_OVER_COLOR);

        // Restore font scale for the widgets.
        sysfont.scale = WIDGET_FONT_SCALE;
}

static void memgame_print_tries(void)
{
        char str[MSG_TRIES_LENGTH + 1];

        // Create new string and update the label.
        snprintf(str, MSG_TRIES_LENGTH + 1, MSG_TRIES_TEXT, game_ctx->tries);
        wtk_label_change(game_ctx->tries_label, str);
}

static void memgame_get_piece_coordinates(uint8_t position, gfx_coord_t *pos_x,
                gfx_coord_t *pos_y)
{
        *pos_x = BOARD_POS_X + (position % NR_OF_BOARD_COLUMNS) *
                        (PIECE_SIZE_X + PIECE_SPACING_X);

        *pos_y = BOARD_POS_Y + (position / NR_OF_BOARD_COLUMNS) *
                        (PIECE_SIZE_Y + PIECE_SPACING_Y);
}

static void memgame_draw_piece(uint8_t index, bool show)
{
        gfx_coord_t            pos_x;
        gfx_coord_t            pos_y;
        char                   *filename;
        enum status_code       result;

        // Get image filename for piece.
        if (show) {
                switch (game_ctx->pieces[index].pair) {
                case 0:
                        filename = PIECE_PAIR_FILE_0;
                        break;

                case 1:
                        filename = PIECE_PAIR_FILE_1;
                        break;

                case 2:
                        filename = PIECE_PAIR_FILE_2;
                        break;

                case 3:
                        filename = PIECE_PAIR_FILE_3;
                        break;

                case 4:
                        filename = PIECE_PAIR_FILE_4;
                        break;

                case 5:
                        filename = PIECE_PAIR_FILE_5;
                        break;

                default:
                        filename = PIECE_BACK_FILE;
                        break;
                }
        } else {
                filename = PIECE_BACK_FILE;
        }
        memgame_get_piece_coordinates(index, &pos_x, &pos_y);

        // Now load the file to the piece's position.
        result = load_file_to_screen(filename, pos_x, pos_y, PIECE_SIZE_X,
                        PIECE_SIZE_Y, game_ctx->task);

        /* If piece could not be loaded, exit the application since only
         * this game should currently be using the file loader.
         */
        if (result != STATUS_OK) {
                win_destroy(game_ctx->win);
                memcpy(&sysfont, &game_ctx->old_sysfont, sizeof(struct font));
                membag_free(game_ctx);
                game_ctx = NULL;
                app_desktop_restart();
        };
}

static uint8_t memgame_get_random_index(uint8_t indexes[])
{
        uint8_t array_index;
        uint8_t piece_index;

        piece_index = PIECE_INVALID_INDEX;

        // Do a random search for the first free index in the supplied list.
        do {
                array_index = memgame_rand() % NR_OF_PIECES;
                piece_index = indexes[array_index];
        } while (piece_index == PIECE_INVALID_INDEX);

        // Mark the piece position as taken.
        indexes[array_index] = PIECE_INVALID_INDEX;

        return piece_index;
}

static void memgame_start_new_game(void)
{
        struct memgame_piece   *p1;
        struct memgame_piece   *p2;
        uint8_t                indexes[NR_OF_PIECES];
        uint8_t                i;

        // Force redraw of application window.
        win_redraw(game_ctx->win);

        // Initialize list of uninitialized pieces.
        for (i = 0; i < NR_OF_PIECES; i++) {
                indexes[i] = i;
        }

        // Initialize the game piece pairs with random locations.
        for (i = 0; i < NR_OF_PIECE_PAIRS; i++) {
                p1 = &game_ctx->pieces[memgame_get_random_index(indexes)];
                p1->pair = i;
                p1->found = false;

                p2 = &game_ctx->pieces[memgame_get_random_index(indexes)];
                p2->pair = i;
                p2->found = false;
        }

        // Initialize the game state and start drawing all game pieces.
        game_ctx->tries = 0;
        game_ctx->busy = true;
        game_ctx->piece_1 = 0;
        game_ctx->pairs_left = NR_OF_PIECE_PAIRS;
        game_ctx->state = DRAW_ALL_PIECES;
        workqueue_add_task(&main_workqueue, game_ctx->task);
}

static void memgame_update(uint8_t new_piece)
{
        struct memgame_piece   *pieces = game_ctx->pieces;
        uint8_t                p_1 = game_ctx->piece_1;
        uint8_t                p_2 = game_ctx->piece_2;

        // Act according to current game state.
        switch(game_ctx->state) {
        case DRAW_ALL_PIECES:
                // Draw all pieces, then wait for selection of first piece.
                if (p_1 < NR_OF_PIECES) {
                        memgame_draw_piece(p_1, false);
                        p_1++;
                } else {
                        memgame_print_tries();
                        game_ctx->state = SELECT_FIRST_PIECE;
                        game_ctx->busy = false;
                }
                game_ctx->piece_1 = p_1;
                break;

        case SELECT_FIRST_PIECE:
                // If piece was not already found, accept selection and draw it.
                if (game_ctx->pieces[new_piece].found == false) {
                        game_ctx->piece_1 = new_piece;
                        memgame_draw_piece(new_piece, true);
                        game_ctx->state = SHOWN_FIRST_PIECE;
                        game_ctx->busy = true;
                }
                break;

        case SHOWN_FIRST_PIECE:
                // Drawing finished, now wait for second piece selection.
                game_ctx->state = SELECT_SECOND_PIECE;
                game_ctx->busy = false;
                break;

        case SELECT_SECOND_PIECE:
                /* If selected piece is not the same as the first one and it
                 * has not already been found, accept selection and draw it.
                 */
                if ((new_piece != p_1) && (game_ctx->pieces[new_piece].found
                                == false)) {
                        game_ctx->piece_2 = new_piece;
                        memgame_draw_piece(new_piece, true);
                        game_ctx->tries++;
                        memgame_print_tries();
                        game_ctx->state = SHOWN_SECOND_PIECE;
                        game_ctx->busy = true;
                }
                break;

        case SHOWN_SECOND_PIECE:
                // Drawing finished. Check if pieces match.
                if (pieces[p_1].pair == pieces[p_2].pair) {
                        // Check if game has completed.
                        if (--game_ctx->pairs_left == 0) {
                                memgame_print_game_over();
                                game_ctx->state = GAME_OVER;
                        } else {
                                pieces[p_1].found = true;
                                pieces[p_2].found = true;
                                game_ctx->state = SELECT_FIRST_PIECE;
                        }
                        game_ctx->busy = false;
                } else {
                        // Start timer to pause before hiding the pieces again.
                        game_ctx->ticks_to_go = TIMER_PAUSE_HALF_SECONDS;
                        timer_start(CONFIG_TIMER_ID, &game_ctx->timer);
                        timer_set_alarm(CONFIG_TIMER_ID, &game_ctx->timer,
                                        game_ctx->timer_delay);
                        game_ctx->state = HIDE_FIRST_PIECE;
                }
                break;

        case HIDE_FIRST_PIECE:
                // Timer has expired. Now hide the first piece.
                memgame_draw_piece(p_1, false);
                game_ctx->state = HIDE_SECOND_PIECE;
                break;

        case HIDE_SECOND_PIECE:
                // Now hide the second one.
                memgame_draw_piece(p_2, false);
                game_ctx->state = HIDDEN_BOTH_PIECES;
                break;

        case HIDDEN_BOTH_PIECES:
                // Clear busy flag and wait for new piece selection.
                game_ctx->state = SELECT_FIRST_PIECE;
                game_ctx->busy = false;
                break;

        case GAME_OVER:
                // Do nothing. User must restart the game.
                break;

        default:
                break;
        }
}

static void memgame_handle_command_event(win_command_t data)
{
        switch ((enum memgame_command_id)(uintptr_t)data) {
        case CMD_NEW_GAME:
                memgame_start_new_game();
                break;

        case CMD_EXIT:
                win_destroy(game_ctx->win);
                memcpy(&sysfont, &game_ctx->old_sysfont, sizeof(struct font));
                membag_free(game_ctx);
                game_ctx = NULL;
                app_desktop_restart();
                break;

        default:
                break;
        }
}

static void memgame_handle_pointer_event(struct win_pointer_event const *data)
{
        gfx_coord_t x;
        gfx_coord_t y;
        uint8_t     i;

        // Only handle pointer presses.
        if (data->type != WIN_POINTER_PRESS) {
                return;
        }

        // Find the piece under the pointer, if any.
        for (i = 0; i < NR_OF_PIECES; i++) {
                memgame_get_piece_coordinates(i, &x, &y);

                // If a piece was found, update the game.
                if ((data->pos.x >= x) && (data->pos.y >= y) &&
                                (data->pos.x < (x + PIECE_SIZE_X)) &&
                                (data->pos.y < (y + PIECE_SIZE_Y))) {
                        memgame_update(i);
                        break;
                }
        }
}

static bool memgame_window_handler(struct win_window *win,
                enum win_event_type type, void const *data)
{
        // Only process input if application is not currently busy.
        if (!game_ctx->busy) {
                switch (type) {
                case WIN_EVENT_COMMAND:
                        memgame_handle_command_event((win_command_t)data);
                        break;

                case WIN_EVENT_POINTER:
                        memgame_handle_pointer_event(
                                        (struct win_pointer_event const *)data);
                        break;

                default:
                        break;
                }
        }

        return true;
}

static void memgame_worker(struct workqueue_task *task)
{
        memgame_update(PIECE_INVALID_INDEX);
}

static void memgame_timer_callback(struct timer *timer)
{
        if (--game_ctx->ticks_to_go > 0) {
                timer_set_alarm(CONFIG_TIMER_ID, &game_ctx->timer,
                                game_ctx->timer_delay);
        } else {
                timer_stop(CONFIG_TIMER_ID, &game_ctx->timer);
                workqueue_add_task(&main_workqueue, game_ctx->task);
        }
}

void app_memgame_launch(struct workqueue_task *task)
{
        struct win_attributes  attr;
        struct win_window      *win;
        struct wtk_button      *button;
        struct wtk_label       *label;
        struct timer           *timer;
        timer_res_t            timer_res;
        uint32_t               timer_clk;
        gfx_coord_t            width = gfx_get_width();
        gfx_coord_t            height = gfx_get_height();

        // Clear the screen right away.
#ifdef CONFIG_GFX_USE_CLIPPING
        gfx_set_clipping(0, 0, width, height);
#endif /* CONFIG_GFX_USE_CLIPPING */
        gfx_draw_filled_rect(0, 0, width, height, BACKGROUND_COLOR);

        // Allocate the application context.
        game_ctx = membag_alloc(sizeof(struct memgame_context));
        if(!game_ctx){
                goto exit_no_context;
        }

        assert(task);
        workqueue_task_set_work_func(task, memgame_worker);
        game_ctx->task = task;

        // Use larger sysfont for this app.
        memcpy(&game_ctx->old_sysfont, &sysfont, sizeof(struct font));
        sysfont.scale = WIDGET_FONT_SCALE;

        // Initialize the timer with the configured resolution.
        timer = &game_ctx->timer;
        timer_init(CONFIG_TIMER_ID, timer, memgame_timer_callback);
        timer_res = timer_set_resolution(CONFIG_TIMER_ID, timer,
                        TIMER_CLOCK_RATE);
        timer_write_resolution(CONFIG_TIMER_ID, timer, timer_res);
        timer_clk = timer_get_resolution(CONFIG_TIMER_ID, timer, timer_res);

        assert(timer_clk <= (uint32_t)0x1ffff);
        game_ctx->timer_delay = timer_clk / 2;

        // Set up bitmap for window background.
        game_ctx->bitmap.type = BITMAP_SOLID;
        game_ctx->bitmap.data.color = BACKGROUND_COLOR;

        // Create main application window.
        attr.area.pos.x = 0;
        attr.area.pos.y = 0;
        attr.area.size.x = width;
        attr.area.size.y = height;
        attr.background = &game_ctx->bitmap;
        attr.event_handler = memgame_window_handler;
        win = win_create(win_get_root(), &attr);
        if (!win) {
                goto exit_no_window;
        }
        game_ctx->win = win;

        // Create standard exit-button.
        attr.area.pos.x = APP_EXIT_BUTTON_POS_X;
        attr.area.pos.y = APP_EXIT_BUTTON_POS_Y;
        attr.area.size.x = APP_EXIT_BUTTON_SIZE_X;
        attr.area.size.y = APP_EXIT_BUTTON_SIZE_Y;
        button = wtk_button_create(win, &attr.area, APP_EXIT_BUTTON_TEXT,
                        (win_command_t)CMD_EXIT);
        if (!button) {
                goto exit_no_widget;
        }
        win_show(wtk_button_as_child(button));

        // Create new game-button.
        attr.area.pos.x = BTN_NEW_GAME_POS_X;
        attr.area.pos.y = BTN_NEW_GAME_POS_Y;
        attr.area.size.x = BTN_NEW_GAME_SIZE_X;
        attr.area.size.y = BTN_NEW_GAME_SIZE_Y;
        button = wtk_button_create(win, &attr.area, BTN_NEW_GAME_TEXT,
                        (win_command_t)CMD_NEW_GAME);
        if (!button) {
                goto exit_no_widget;
        }
        win_show(wtk_button_as_child(button));

        // Create label to show number of tries.
        attr.area.pos.x = MSG_TRIES_POS_X;
        attr.area.pos.y = MSG_TRIES_POS_Y;
        attr.area.size.x = MSG_TRIES_SIZE_X;
        attr.area.size.y = MSG_TRIES_SIZE_Y;
        label = wtk_label_create(win, &attr.area, " ", false);
        if (!label) {
                goto exit_no_widget;
        }
        game_ctx->tries_label = label;
        win_show(wtk_label_as_child(label));

        // Show the application window and start a new game.
        win_show(win);
        memgame_start_new_game();
        return;

        // Handle memory allocation errors.
exit_no_widget:
        win_destroy(game_ctx->win);
exit_no_window:
        memcpy(&sysfont, &game_ctx->old_sysfont, sizeof(struct font));
        membag_free(game_ctx);
        game_ctx = NULL;
exit_no_context:
        app_desktop_restart();
        return;
}

---