kolibrios/programs/games/2048/board.c

#include "board.h"

rect base_cell = {0};
tile null_tile = {0};

struct {
    rect    draw;                       // background rect
    rect    cell_map[BOARD_MAP_SIZE];   // background cells array
    tile    tile_map[BOARD_MAP_SIZE];   // tiles array
    __u16   empty_index[BOARD_MAP_SIZE];// empty cells indexes
    __u16   empty_count;                // empty cells count
    __u32   score;
} board = {0};

// Get tile index for row and column
__u16 board_index(__u16 row, __u16 column) {
    return column + row * BOARD_COUNT;
}

// Get tile position (as point with eow and column) for index
point board_position(__u16 index) {
    point p = {
        .x = index % BOARD_COUNT,
        .y = index / BOARD_COUNT
    };
    return p;
}

// Calculate cell rect for row and column
rect position2cell(point p) {
    rect c = {0};
    c.width = base_cell.width;
    c.height = base_cell.height;
    c.x = board.draw.x + BOARD_SPACING + p.x * (c.width + BOARD_SPACING);
    c.y = board.draw.y + BOARD_SPACING + p.y * (c.height + BOARD_SPACING);
    return c;
}

// Update information about empty cells
void board_update_empty_info();

// Represent tile array as pointers array
void board_to_tempboard(tile* temp[]);

// Fill tile array with tiles from pointers array
void board_from_tempboard(tile* temp[], __u8 forward);

// Move tile inside a pointer array
void tempboard_move_tile(tile* temp[], __u16 from, __u16 to);

// Merge tiles inside a pointer array
void tempboard_merge_tile(tile* temp[], __u16 from, __u16 to);

// Random number generator
__u32 random_u32(__u32 max);

void board_init(rect* r)
{
    // seed for random number generator
    srand(__menuet__getsystemclock());

    __u16 cell_size = (r->width - BOARD_SPACING * (BOARD_COUNT + 1)) / BOARD_COUNT;
    base_cell.width = cell_size;
    base_cell.height = cell_size;

    null_tile.value = 0;
    null_tile.animate = false;
    null_tile.ani_step = ANI_APPEAR_STEP;
    null_tile.merged = false;

    board.score = 0;
    board.draw = *r;

    canvas_init(r);
    canvas_fill(BOARD_BG_COLOR);

    __u16 i = 0;
    for (i = 0; i < BOARD_MAP_SIZE; i++)
    {
        board.cell_map[i] = position2cell(board_position(i));
        board.tile_map[i] = null_tile;
    }

    i = 0;
    for (i = 0; i < START_COUNT; i++)
    {
        board_add_random_tile();
    }

    board_redraw();
}

void board_delete()
{
    canvas_delete();
}

void board_redraw()
{
    __u16 i = 0;
    __u8 animate = false;
    __u8 last_animate = false;
    do
    {
        canvas_fill(BOARD_BG_COLOR);

        for (i = 0; i < BOARD_MAP_SIZE; i++)
        {
            canvas_draw_rect(&board.cell_map[i],CELL_COLOR);
        }

        animate = false;
        last_animate = false;
        for (i = 0; i < BOARD_MAP_SIZE; i++)
        {
            tile* t = &board.tile_map[i];
            last_animate = tile_draw(t);
            if (last_animate)
            {
                animate = last_animate;
            }
        }

        canvas_paint();

        if (animate)
        {
            __menuet__delay100(ANI_DELAY);
        }
    }
    while (animate);
}

__u8 board_up()
{
    __u8 moved = false;

    __u16 row = 0;
    __u16 column = 0;
    __u16 ind = 0;
    __u16 preind = 0;
    tile* indtile = 0;
    tile* pretile = 0;

    tile* temp_board[BOARD_MAP_SIZE] = {0};
    board_to_tempboard(temp_board);

    for (column = 0; column < BOARD_COUNT; column++)
    {
        for (row = 0; row < BOARD_COUNT; row++)
        {
            if (row > 0)
            {
                ind = board_index(row,column);
                indtile = temp_board[ind];
                if (indtile)
                {
                    preind = board_index(row - 1,column);
                    pretile = temp_board[preind];
                    if (!pretile)
                    {
                        moved = true;
                        tempboard_move_tile(temp_board,ind,preind);
                        row = 0;
                    }
                    else if (tile_mergeable(indtile,pretile))
                    {
                        moved = true;
                        board.score += indtile->value * 2;
                        tempboard_merge_tile(temp_board,ind,preind); 
                        row = 0;
                    }
                }
            }
        }
    }

    board_from_tempboard(temp_board,true);

    return moved;
}

__u8 board_down()
{
    __u8 moved = false;

    __u16 row = 0;
    __u16 column = 0;
    __u16 ind = 0;
    __u16 preind = 0;
    tile* indtile = 0;
    tile* pretile = 0;

    tile* temp_board[BOARD_MAP_SIZE] = {0};
    board_to_tempboard(temp_board);

    for (column = 0; column < BOARD_COUNT; column++)
    {
        row = BOARD_COUNT;
        while (row--)
        {
            if ((BOARD_COUNT - row) > 1)
            {
                ind = board_index(row,column);
                indtile = temp_board[ind];
                if (indtile)
                {
                    preind = board_index(row + 1,column);
                    pretile = temp_board[preind];
                    if (!pretile)
                    {
                        moved = true;
                        tempboard_move_tile(temp_board,ind,preind);
                        row = BOARD_COUNT;
                    }
                    else if (tile_mergeable(indtile,pretile))
                    {
                        moved = true;
                        board.score += indtile->value * 2;
                        tempboard_merge_tile(temp_board,ind,preind);
                        row = BOARD_COUNT;
                    }
                }
            }
        }
    }

    board_from_tempboard(temp_board,false);

    return moved;
}

__u8 board_left()
{
    __u8 moved = false;

    __u16 row = 0;
    __u16 column = 0;
    __u16 ind = 0;
    __u16 preind = 0;
    tile* indtile = 0;
    tile* pretile = 0;

    tile* temp_board[BOARD_MAP_SIZE] = {0};
    board_to_tempboard(temp_board);

    for (row = 0; row < BOARD_COUNT; row++)
    {
        for (column = 0; column < BOARD_COUNT; column++)
        {
            if (column > 0)
            {
                ind = board_index(row,column);
                indtile = temp_board[ind];
                if (indtile)
                {
                    preind = board_index(row,column - 1);
                    pretile = temp_board[preind];
                    if (!pretile)
                    {
                        moved = true;
                        tempboard_move_tile(temp_board,ind,preind);
                        column = 0;
                    }
                    else if (tile_mergeable(indtile,pretile))
                    {
                        moved = true;
                        board.score += indtile->value * 2;
                        tempboard_merge_tile(temp_board,ind,preind);
                        column = 0;
                    }
                }
            }
        }
    }

    board_from_tempboard(temp_board,true);

    return moved;
}

__u8 board_right()
{
    __u8 moved = false;

    __u16 row = 0;
    __u16 column = 0;
    __u16 ind = 0;
    __u16 preind = 0;
    tile* indtile = 0;
    tile* pretile = 0;

    tile* temp_board[BOARD_MAP_SIZE] = {0};
    board_to_tempboard(temp_board);

    for (row = 0; row < BOARD_COUNT; row++)
    {
        column = BOARD_COUNT;
        while (column--)
        {
            if ((BOARD_COUNT - column) > 1)
            {
                ind = board_index(row,column);
                indtile = temp_board[ind];
                if (indtile)
                {
                    preind = board_index(row,column + 1);
                    pretile = temp_board[preind];
                    if (!pretile)
                    {
                        moved = true;
                        tempboard_move_tile(temp_board,ind,preind);
                        column = BOARD_COUNT;
                    }
                    else if (tile_mergeable(indtile,pretile))
                    {
                        moved = true;
                        board.score += indtile->value * 2;
                        tempboard_merge_tile(temp_board,ind,preind);
                        column = BOARD_COUNT;
                    }
                }
            }
        }
    }

    board_from_tempboard(temp_board,false);

    return moved;
}

__u8 board_add_random_tile()
{
    board_update_empty_info();
    if (board.empty_count)
    {
        __u16 rnd_av = random_u32(board.empty_count);
        rnd_av = board.empty_index[rnd_av];

        tile* av_tile = &board.tile_map[rnd_av];
        av_tile->value = (random_u32(10) < 9) ? 2 : 4;

        av_tile->animate = true;
        av_tile->ani_step = ANI_APPEAR_STEP;
        av_tile->transition = position2cell(board_position(rnd_av));
        av_tile->cell.x = av_tile->transition.x + base_cell.width / 2;
        av_tile->cell.y = av_tile->transition.y + base_cell.height / 2;
        av_tile->cell.width = 0;
        av_tile->cell.height = 0;
    }
    return board.empty_count;
}

__u8 board_has_moves()
{
    __u16 ind = 0;
    __u16 next = 0;
    __u16 step = 0;
    __u16 pos = 0;
    for (step = 0; step < BOARD_COUNT; step++)
    {
        for (pos = 0; pos < BOARD_COUNT; pos++)
        {
            // check horizontal
            ind = board_index(step,pos);
            next = board_index(step,pos + 1);

            if (!board.tile_map[ind].value ||
                    (((pos + 1) < BOARD_COUNT) &&
                     (!board.tile_map[next].value ||
                      (board.tile_map[ind].value == board.tile_map[next].value)
                      )
                     )
                    )
                return true;

            // check vertical
            ind = board_index(pos,step);
            next = board_index(pos + 1,step);

            if (!board.tile_map[ind].value ||
                    (((pos + 1) < BOARD_COUNT) &&
                     (!board.tile_map[next].value ||
                      (board.tile_map[ind].value == board.tile_map[next].value)
                      )
                     )
                    )
                return true;
        }
    }
    return false;
}

__u32 board_score()
{
    return board.score;
}

void board_update_empty_info()
{
    board.empty_count = 0;

    __u16 i = 0;
    for (i = 0; i < BOARD_MAP_SIZE; i++)
    {
        if (!board.tile_map[i].value)
        {
            board.empty_index[board.empty_count] = i;
            board.empty_count++;
        }
    }
}

void board_to_tempboard(tile* temp[])
{
    __u16 ind = 0;
    for (ind = 0; ind < BOARD_MAP_SIZE; ind++)
    {
        tile* bt = &board.tile_map[ind];
        if (bt->value)
        {
            temp[ind] = bt;
        }
    }
}

void board_from_tempboard(tile *temp[], __u8 forward)
{
    __u16 ind = 0;
    if (forward)
    {
        for (ind = 0; ind < BOARD_MAP_SIZE; ind++)
        {
            tile* bt = &board.tile_map[ind];
            tile* tt = temp[ind];
            if (tt)
            {
                *bt = *tt;
                bt->transition = position2cell(board_position(ind));
            }
            else
            {
                *bt = null_tile;
            }
        }
    }
    else
    {
        ind = BOARD_MAP_SIZE;
        while (ind--)
        {
            tile* bt = &board.tile_map[ind];
            tile* tt = temp[ind];
            if (tt)
            {
                *bt = *tt;
                bt->transition = position2cell(board_position(ind));
            }
            else
            {
                *bt = null_tile;
            }
        }
    }
}

void tempboard_move_tile(tile* temp[], __u16 from, __u16 to)
{
    temp[to] = temp[from];
    temp[to]->animate = true;
    temp[to]->ani_step = ANI_MOVE_STEP;
    temp[from] = 0;
}

void tempboard_merge_tile(tile* temp[], __u16 from, __u16 to)
{
    temp[from]->merged = true;
    temp[from]->merged_rect = temp[to]->cell;
    tempboard_move_tile(temp,from,to);
}

__u32 random_u32(__u32 max)
{
    return ((rand() * 1.0) / RAND_MAX) * max;
}