2048/main.c

#include "raylib.h"
#include <math.h>
#include <stdbool.h>
#include <stdlib.h>
#include <time.h>

#define BOARD_WIDTH 4
#define BOARD_HEIGHT 4
#define STARTING_TILES 3

#define TILE_SIZE 100
#define TILE_SPACING 10
#define BOARD_MARGIN 50

const Color tile_colors[] = {
    LIGHTGRAY, // 0 - Empty
    BEIGE,     // 2
    GOLD,      // 4
    ORANGE,    // 8
    ORANGE,    // 16
    RED,       // 32
    MAROON,    // 64
    YELLOW,    // 128
    GOLD,      // 256
    ORANGE,    // 512
    RED,       // 1024
    MAROON,    // 2048
    PINK,      // 4096
    MAGENTA,   // 8192
};

typedef enum { UP = 0, DOWN, LEFT, RIGHT } MOVE_DIRECTION;
static int board[BOARD_HEIGHT][BOARD_WIDTH] = {0};

bool is_dragging = false;
Vector2 drag_start_pos = {0, 0};
int score = 0;
int moves_made = 0;

// 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
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;
          score += board[target_y][x];
        }
      }
    }
    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;
          score += board[target_y][x];
        }
      }
    }
    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;
          score += board[y][target_x];
        }
      }
    }
    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;
          score += board[y][target_x];
        }
      }
    }
    break;
  }
  }
  moves_made++;
}

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;
}

void handle_mouse_input() {
  if (IsMouseButtonPressed(MOUSE_LEFT_BUTTON)) {
    drag_start_pos = GetMousePosition();
    if (drag_start_pos.x >= 500 && drag_start_pos.x <= 775 && drag_start_pos.y >= 455 && drag_start_pos.y <= 479) {
      // Reset button
      for (int y = 0; y < BOARD_HEIGHT; y++) {
        for (int x = 0; x < BOARD_WIDTH; x++) {
          board[y][x] = 0;
        }
      }
      score = 0;
      moves_made = 0;
      spawn_tile();
      spawn_tile();
      spawn_tile();
      return;
    }

    is_dragging = true;
  } else if (IsMouseButtonReleased(MOUSE_LEFT_BUTTON) && is_dragging) {
    Vector2 current_pos = GetMousePosition();

    float dx = current_pos.x - drag_start_pos.x;
    float dy = current_pos.y - drag_start_pos.y;

    float drag_distance = sqrt(dx * dx + dy * dy);

    // We don't want to register single clicks as a move
    if (drag_distance >= 30) {
      if (fabs(dx) > fabs(dy)) {
        if (dx > 0) {
          move(RIGHT);
        } else {
          move(LEFT);
        }
      } else {
        if (dy > 0) {
          move(DOWN);
        } else {
          move(UP);
        }
      }
      spawn_tile();
    }

    is_dragging = false;
  }
}

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++;
  }

  InitWindow(800, 600, "2048");
  SetTargetFPS(30); // So my laptop doesn't burn

  while (!WindowShouldClose()) {
    ClearBackground(RAYWHITE);
    BeginDrawing();

    for (int y = 0; y < BOARD_HEIGHT; y++) {
      for (int x = 0; x < BOARD_WIDTH; x++) {
        int tile_value = board[y][x];
        int pos_x = BOARD_MARGIN + x * (TILE_SIZE + TILE_SPACING);
        int pos_y = BOARD_MARGIN + y * (TILE_SIZE + TILE_SPACING);
        int color_index = (tile_value == 0) ? 0 : (int)log2(tile_value);

        DrawRectangle(pos_x, pos_y, TILE_SIZE, TILE_SIZE, tile_colors[color_index]);
        if (tile_value != 0) {
          const char *text = TextFormat("%d", tile_value);
          DrawText(text, pos_x + TILE_SIZE / 2 - MeasureText(text, 20) / 2, pos_y + TILE_SIZE / 2 - 10, 20, BLACK);
        }
      }
    }

    DrawText(TextFormat("Score: %d", score), 600, BOARD_MARGIN, 20, BLACK);
    DrawText(TextFormat("Moves used: %d", moves_made), 600, BOARD_MARGIN + 20, 20, BLACK);

    // Reset button
    DrawRectangle(500, 455, 275, 24, RED);
    DrawText("Reset", 500 + 275 / 2 - MeasureText("Reset", 20) / 2, 455 + 4, 20, WHITE);

    EndDrawing();
    handle_mouse_input();
  }
  CloseWindow();
  return 0;
}