253 lines
6.6 KiB
C
253 lines
6.6 KiB
C
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <time.h>
|
|
|
|
#define BOARD_WIDTH 4
|
|
#define BOARD_HEIGHT 4
|
|
#define STARTING_TILES 3
|
|
|
|
const char* tile_colors[] = {
|
|
"\033[0m", // 0 - Reset/default (empty tile)
|
|
"\033[48;5;230m", // 2 - Light beige
|
|
"\033[48;5;223m", // 4 - Tan
|
|
"\033[48;5;216m", // 8 - Orange-ish
|
|
"\033[48;5;209m", // 16 - Light orange
|
|
"\033[48;5;208m", // 32 - Orange
|
|
"\033[48;5;202m", // 64 - Dark orange
|
|
"\033[48;5;226m", // 128 - Yellow
|
|
"\033[48;5;220m", // 256 - Gold
|
|
"\033[48;5;214m", // 512 - Orange-gold
|
|
"\033[48;5;208m", // 1024 - Bright orange
|
|
"\033[48;5;202m", // 2048 - Red-orange
|
|
"\033[48;5;196m", // 4096 - Red
|
|
"\033[48;5;160m", // 8192 - Dark red
|
|
};
|
|
|
|
typedef enum { UP = 0, DOWN, LEFT, RIGHT } MOVE_DIRECTION;
|
|
static int board[BOARD_HEIGHT][BOARD_WIDTH] = {0};
|
|
|
|
void print_board() {
|
|
for (int y = 0; y < BOARD_HEIGHT; y++) {
|
|
for (int x = 0; x < BOARD_WIDTH; x++) {
|
|
printf("%s%d ", tile_colors[board[y][x]], board[y][x]);
|
|
}
|
|
printf("\n");
|
|
}
|
|
printf("\033[0m"); // Reset color
|
|
}
|
|
|
|
// Depending on the direction, move the tiles and check if we can merge with the
|
|
// tiles in that direction. We merge the tiles only if they are of the same value
|
|
// TODO: Add a guard agains double merge!
|
|
// 2 2 0 4 => 8 0 0 0 which is incorrect and should be 4 4 0 0
|
|
void move(MOVE_DIRECTION direction) {
|
|
bool merged[BOARD_HEIGHT][BOARD_WIDTH] = {0};
|
|
switch (direction) {
|
|
case UP: {
|
|
for (int y = 1; y < BOARD_HEIGHT; y++) {
|
|
for (int x = 0; x < BOARD_WIDTH; x++) {
|
|
if (board[y][x] == 0)
|
|
continue;
|
|
|
|
// Hard keeping track of this so I'm commenting as much as I can
|
|
// Check if we can move up any space, so loop until we find a non-empty tile or the top of the board
|
|
|
|
// py is the potential target y that we will settle for and move the tile into
|
|
int target_y = y;
|
|
for (int py = y - 1; py >= 0; py--) { // Go from the tile's current position up to the top of the board
|
|
if (board[py][x] == 0) {
|
|
target_y = py;
|
|
} else if (board[py][x] == board[y][x] && !merged[py][x]) {
|
|
target_y = py;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Check if we are moving anything
|
|
if (target_y == y)
|
|
continue;
|
|
|
|
// If the target tile is empty, move the current tile there
|
|
// If the target tile has the same value, merge them
|
|
if (board[target_y][x] == 0) {
|
|
board[target_y][x] = board[y][x];
|
|
board[y][x] = 0;
|
|
} else if (board[target_y][x] == board[y][x]) {
|
|
merged[target_y][x] = true;
|
|
board[target_y][x] *= 2;
|
|
board[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case DOWN: {
|
|
for (int y = BOARD_HEIGHT - 1; y >= 0; y--) {
|
|
for (int x = 0; x < BOARD_WIDTH; x++) {
|
|
if (board[y][x] == 0)
|
|
continue;
|
|
|
|
int target_y = y;
|
|
for (int py = y + 1; py < BOARD_HEIGHT; py++) {
|
|
if (board[py][x] == 0) {
|
|
target_y = py;
|
|
} else if (board[py][x] == board[y][x] && !merged[py][x]) {
|
|
target_y = py;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (target_y == y)
|
|
continue;
|
|
|
|
if (board[target_y][x] == 0) {
|
|
board[target_y][x] = board[y][x];
|
|
board[y][x] = 0;
|
|
} else if (board[target_y][x] == board[y][x]) {
|
|
merged[target_y][x] = true;
|
|
board[target_y][x] *= 2;
|
|
board[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case LEFT: {
|
|
for (int y = 0; y < BOARD_HEIGHT; y++) {
|
|
for (int x = 1; x < BOARD_WIDTH; x++) {
|
|
if (board[y][x] == 0)
|
|
continue;
|
|
|
|
int target_x = x;
|
|
for (int px = x - 1; px >= 0; px--) {
|
|
if (board[y][px] == 0) {
|
|
target_x = px;
|
|
} else if (board[y][px] == board[y][x] && !merged[y][px]) {
|
|
target_x = px;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (target_x == x)
|
|
continue;
|
|
|
|
if (board[y][target_x] == 0) {
|
|
board[y][target_x] = board[y][x];
|
|
board[y][x] = 0;
|
|
} else if (board[y][target_x] == board[y][x]) {
|
|
merged[y][target_x] = true;
|
|
board[y][target_x] *= 2;
|
|
board[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case RIGHT: {
|
|
for (int y = 0; y < BOARD_HEIGHT; y++) {
|
|
for (int x = BOARD_WIDTH - 1; x >= 0; x--) {
|
|
if (board[y][x] == 0)
|
|
continue;
|
|
|
|
int target_x = x;
|
|
for (int px = x + 1; px < BOARD_WIDTH; px++) {
|
|
if (board[y][px] == 0) {
|
|
target_x = px;
|
|
} else if (board[y][px] == board[y][x] && !merged[y][px]) {
|
|
target_x = px;
|
|
break;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (target_x == x)
|
|
continue;
|
|
|
|
if (board[y][target_x] == 0) {
|
|
board[y][target_x] = board[y][x];
|
|
board[y][x] = 0;
|
|
} else if (board[y][target_x] == board[y][x]) {
|
|
merged[y][target_x] = true;
|
|
board[y][target_x] *= 2;
|
|
board[y][x] = 0;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool spawn_tile() {
|
|
int empty_tiles[BOARD_WIDTH * BOARD_HEIGHT][2];
|
|
int empty_count = 0;
|
|
|
|
for (int y = 0; y < BOARD_HEIGHT; y++) {
|
|
for (int x = 0; x < BOARD_WIDTH; x++) {
|
|
if (board[y][x] == 0) {
|
|
empty_tiles[empty_count][0] = y;
|
|
empty_tiles[empty_count][1] = x;
|
|
empty_count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (empty_count == 0)
|
|
return false;
|
|
|
|
int random_index = rand() % empty_count;
|
|
int spawn_y = empty_tiles[random_index][0];
|
|
int spawn_x = empty_tiles[random_index][1];
|
|
board[spawn_y][spawn_x] = (rand() % 10 == 0) ? 4 : 2; // 10% chance to spawn a 4
|
|
|
|
return true;
|
|
}
|
|
|
|
int main() {
|
|
srand(time(NULL));
|
|
|
|
int tile_count = 0;
|
|
while (tile_count != STARTING_TILES) {
|
|
int y = rand() % BOARD_HEIGHT;
|
|
int x = rand() % BOARD_WIDTH;
|
|
|
|
if (board[y][x] != 0)
|
|
continue;
|
|
board[y][x] = (rand() % 10 == 0) ? 4 : 2; // 10% chance to spawn a 4
|
|
tile_count++;
|
|
}
|
|
|
|
printf("2048 machen\n");
|
|
print_board();
|
|
move(UP);
|
|
printf("After move up:\n");
|
|
print_board();
|
|
printf("After spawning a tile:\n");
|
|
spawn_tile();
|
|
print_board();
|
|
move(DOWN);
|
|
printf("After move down:\n");
|
|
print_board();
|
|
spawn_tile();
|
|
printf("After spawning a tile:\n");
|
|
print_board();
|
|
move(LEFT);
|
|
printf("After move left:\n");
|
|
print_board();
|
|
spawn_tile();
|
|
printf("After spawning a tile:\n");
|
|
print_board();
|
|
move(RIGHT);
|
|
printf("After move right:\n");
|
|
print_board();
|
|
return 0;
|
|
}
|