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();

}