Subversion Repositories planix.SVN

#include <u.h>
#include <libc.h>
#include <draw.h>
#include <keyboard.h>
#include <event.h>

// 2048.
// y increases down, x increases right.

// square board of this size
#define BOARDSIZE 4

// square boarder
#define BORDER 4

typedef struct Tile Tile;

struct Tile {
        int value;
        Image *color;
};

Tile grid[BOARDSIZE][BOARDSIZE];
Tile *grid1 = &grid[0][0];
int score = 0;
int gameover = 0;

Font *bigfont;

Image *colors[13];

Image *
val2col(int val)
{
        int i;

        if(val == 0)
                return colors[0];

        for(i = 32; (val & (1<<i)) == 0; i--)
                ;

        if(i < nelem(colors))
                return colors[i];

        return colors[nelem(colors)-1];
}


void
initcolors(void)
{
        int i;

        int cols[] = {
                0xcdc0b4ff, 0xeee4daff, 0xede0c8ff, 0xf2b179ff, 0xf59563ff,
                0xf67c5fff, 0xf65e36ff, 0xedcf72ff, 0xedcc61ff,
                0xedc850ff, 0xedc53fff, 0xedc22eff, 0x3c3a32ff };

        for(i = 0; i < nelem(cols); i++) {
                colors[i] = allocimage(display, Rect(0, 0, 1, 1), screen->chan, 1, cols[i]);
        }
}

void
initboard(void)
{
        int x, y, x2, y2;

        for(y = 0; y < BOARDSIZE; y++) {
                for(x = 0; x < BOARDSIZE; x++) {
                        grid[y][x].value = 0;
                        grid[y][x].color = val2col(0);
                }
        }

        y = nrand(BOARDSIZE);
        x = nrand(BOARDSIZE);

        grid[y][x].value = 2;
        grid[y][x].color = val2col(2);;

        y2 = nrand(BOARDSIZE);
        x2 = nrand(BOARDSIZE);

        while(y == y2 || x == x2) {
                y2 = nrand(BOARDSIZE);
                x2 = nrand(BOARDSIZE);
        }

        grid[y2][x2].value = 2;
        grid[y2][x2].color = val2col(2);;

        score = 0;
}

void
redraw(void)
{
        Rectangle r;
        Point p, sp;
        int x, y; // grid indexes
        int width, height; // of each tile
        char buf[64];

        Point strp;
        int strwid;

        r = insetrect(screen->r, BORDER);
        sp = r.min;
        r.min.y += font->height;
        p = r.min;
        
        width = Dx(r) / BOARDSIZE;
        height = Dy(r) / BOARDSIZE;

        draw(screen, screen->r, display->black, nil, ZP);

        snprint(buf, sizeof buf, "Score: %d", score);
        string(screen, sp, display->white, ZP, font, buf);

        for(y = 0; y < BOARDSIZE; y++) {
                for(x = 0; x < BOARDSIZE; x++) {
                        r = Rect(p.x + (x * width), p.y + (y * height), p.x + (x * width) + width, p.y + (y * height) + height);
                        r = insetrect(r, BORDER);
                        draw(screen, r, grid[y][x].color, nil, ZP);

                        if(grid[y][x].value == 0)
                                continue;

                        snprint(buf, sizeof buf, "%d", grid[y][x].value);
                        strwid = stringwidth(bigfont, buf);
                        strp = Pt(Dx(r)/2, Dy(r)/2);
                        strp.x -= strwid / 2;
                        string(screen, addpt(r.min, strp), display->black, ZP, bigfont, buf);
                }
        }
}

void
addrandom(void)
{
        int x, y, nfree;
        Tile **tfree;

        nfree = 0;

        for(x = 0; x < BOARDSIZE; x++) {
                for(y = 0; y < BOARDSIZE; y++) {
                        if(grid[x][y].value == 0)
                                nfree++;
                }
        }

        if(nfree > 0) {
                tfree = mallocz(sizeof(Tile*) * nfree, 1);
                nfree = 0;
                for(x = 0; x < BOARDSIZE; x++) {
                        for(y = 0; y < BOARDSIZE; y++) {
                                if(grid[x][y].value == 0)
                                        tfree[nfree++] = &grid[x][y];
                        }
                }

                // 10% chance of 4.
                if(nrand(10) == 0)
                        x = 4;
                else
                        x = 2;

                nfree = nrand(nfree);

                tfree[nfree]->value = x;
                tfree[nfree]->color = val2col(x);

                free(tfree);
        }
}

void
buildrow(Tile *out[BOARDSIZE], int n, int dir)
{
        int i, start, add;
        add = start = 0;

        switch(dir) {
        case Kright:
                add = 1;
                start = n*BOARDSIZE;
                break;
        case Kleft:
                add = -1;
                start = n*BOARDSIZE + (BOARDSIZE-1);
                break;
        case Kdown:
                add = BOARDSIZE;
                start = n;
                break;
        case Kup:
                add = -BOARDSIZE;
                start = (BOARDSIZE-1)*BOARDSIZE + n;
                break;
        }

        for(i = 0; i < BOARDSIZE; i++) {
                out[i] = &grid1[add*i + start];
        }
}

int
merge(Tile *row[BOARDSIZE])
{
        int i, j, moved;
        Tile nrow[BOARDSIZE];

        for(i = 0; i < BOARDSIZE; i++) {
                nrow[i].value = 0;
                nrow[i].color = val2col(0);
        }

        j = BOARDSIZE-1;
        for(i = j; i >= 0; i--) {
                if(row[i]->value == 0) {
                        ;
                } else if(nrow[j].value == 0) {
                        nrow[j] = *row[i];
                } else if(nrow[j].value == row[i]->value) {
                        score += nrow[j].value *= 2;
                        nrow[j].color = val2col(nrow[j].value);
                        j--;
                } else {
                        nrow[--j] = *row[i];
                }
        }

        moved = 0;
        for(i = 0; i < BOARDSIZE; i++) {
                if(nrow[i].value != row[i]->value)
                        moved = 1;

                *row[i] = nrow[i];
        }

        return moved;
}

void
shift(int dir)
{
        Tile *cur[BOARDSIZE];
        int i;
        int moved = 0;

        for(i = 0; i < BOARDSIZE; i++) {
                //print("%d\n", i);
                buildrow(cur, i, dir);
                moved = merge(cur) || moved;
        }

        if(moved) {
                addrandom();
                // check gameover here
        }
}

void
main(int argc, char **argv)
{
        char *fontname;

        USED(argc);
        USED(argv);

        if(initdraw(0, 0, "2048") < 0)
                sysfatal("initdraw: %r");

        fontname = "/lib/font/bit/fixed/unicode.10x20.font";
        if((bigfont = openfont(display, fontname)) == nil)
                sysfatal("can't open font %s: %r", fontname);

        einit(Ekeyboard|Emouse);
        srand(time(0));

        initcolors();
        initboard();

        redraw();

        while(1) {
                int key;
                redraw();
                flushimage(display, 1);

                switch(key = ekbd()) {
                case 0x7f: // p9p lacks Kdel
                case 'q':
                        // quit
                        exits(0);
                        break;
                case ' ':
                        // reset board
                        initboard();
                case Kup:
                case Kdown:
                case Kleft:
                case Kright:
                        shift(key);
                        break;
                }
        }
}

void
eresized(int new)
{
        if(new && getwindow(display, Refnone) < 0)
                sysfatal("getwindow: %r");

        redraw();
}