main.c

   1 #include "main.h"
   2
   3 #define DBG 0
   4
   5 bool move_possible_north(board *b);
   6 bool move_possible_south(board *b);
   7 bool move_possible_east(board *b);
   8 bool move_possible_west(board *b);
   9
  10 void move_north(board *b);
  11 void move_south(board *b);
  12 void move_east(board *b);
  13 void move_west(board *b);
  14 void merge(board *b, const int d);
  15 void merge_north(board *b);
  16 void merge_south(board *b);
  17 void merge_east(board *b);
  18 void merge_west(board *b);
  19
  20 void place_new_piece(board *b);
  21 void game_loop(board *b);
  22
  23 board* new_board() {
  24         board *tmp = malloc(sizeof(board));
  25         init_board(tmp);
  26         return tmp;
  27 }
  28
  29 void init_board(board *b) {
  30         for(int i = 0; i < 4; ++i) {
  31                 for(int j = 0; j < 4; ++j)
  32                         b->x[i][j] = 0;
  33         }
  34         b->points = 0;
  35         b->num_p = 0;
  36         srand((uint)time(NULL));
  37         place_new_piece(b);
  38         // second piece will be placed in game_loop
  39 }
  40
  41 void game_start() {
  42         printf("\e[?1049h\e[?25l]");
  43         struct termios oldtio, newtio;
  44         tcgetattr(STDIN_FILENO, &oldtio);
  45         newtio = oldtio;
  46         newtio.c_lflag &= ~(ICANON | ECHO);
  47         tcsetattr(STDIN_FILENO, TCSANOW, &newtio);
  48         board *b = new_board();
  49         game_loop(b);
  50         print_score(b);
  51         free_board(b);
  52         printf("\e[?1049l\e[?25h");
  53         tcsetattr(STDIN_FILENO, TCSANOW, &oldtio);
  54 }
  55
  56 enum direction get_input()
  57 {
  58         switch(fgetc(stdin)) {
  59                 case 'a':
  60                         return west;
  61                 case 's':
  62                         return south;
  63                 case 'w':
  64                         return north;
  65                 case 'd':
  66                         return east;
  67                 case 'q':
  68                         return quit;
  69                 default:
  70                         return get_input();
  71         }
  72 }
  73
  74 void game_loop(board *b) {
  75         while(move_possible_any(b)) {
  76                 place_new_piece(b);
  77                 print_board(b);
  78                 while(true) {
  79                         enum direction d = get_input();
  80
  81                         if (d == quit) {
  82                                 return;
  83                         } else if(move_possible(b, d)) {
  84                                 make_move(b, d);
  85                                 break;
  86                         }
  87                 }
  88         }
  89 }
  90
  91 void place_new_piece(board *b) {
  92         int prob = rand() % 100;
  93         int possibs[32];
  94         uint val = 0;
  95         int cnt = 0;
  96         int pair = 0;
  97         int rx = 0, ry = 0;
  98         for(int i = 0; i < 4; ++i) {
  99                 for(int j = 0; j < 4; ++j) {
 100                         if(b->x[i][j] == 0) {
 101                                 possibs[2*cnt] = i;
 102                                 possibs[2*cnt+1] = j;
 103                                 cnt++;
 104                         }
 105                 }
 106         }
 107         assert(cnt > 0);
 108         pair = rand() % cnt;
 109         rx = possibs[2*pair];
 110         ry = possibs[2*pair+1];
 111         assert(b->x[rx][ry] == 0);
 112         if(prob > 9)
 113                 val = 2;
 114         else
 115                 val = 4;
 116         b->x[rx][ry] = val;
 117         b->num_p++;
 118 }
 119
 120 void free_board(board *b) {
 121         free(b);
 122 }
 123
 124 void make_move(board *b, const int d) {
 125         bool ok = (d == south) ||
 126                 (d == east) ||
 127                 (d == north) ||
 128                 (d == west);
 129         assert(ok);
 130         /*
 131          * checked before already
 132          * if(!move_possible(b, d))
 133          *      return;
 134         */
 135         move(b, d);
 136         merge(b, d);
 137         move(b, d);
 138 }
 139
 140 bool move_possible_any(board *b) {
 141         if(b->num_p < 16)
 142                 return true;
 143         if(move_possible_south(b))
 144                 return true;
 145         if(move_possible_east(b))
 146                 return true;
 147         if(move_possible_north(b))
 148                 return true;
 149         if(move_possible_west(b))
 150                 return true;
 151         return false;
 152 }
 153
 154 bool move_possible(board *b, const int d) {
 155         bool ok = (d == south) ||
 156                 (d == east) ||
 157                 (d == north) ||
 158                 (d == west);
 159         assert(ok);
 160         switch(d) {
 161                 case north:
 162                         return move_possible_north(b);
 163                 case south:
 164                         return move_possible_south(b);
 165                 case east:
 166                         return move_possible_east(b);
 167                 case west:
 168                         return move_possible_west(b);
 169                 default: // will never execute anyway
 170                         return false;
 171         }
 172 }
 173
 174 void move(board *b, const int d) {
 175         bool ok = (d == south) ||
 176                 (d == east) ||
 177                 (d == north) ||
 178                 (d == west);
 179         assert(ok);
 180         switch(d) {
 181                 case north:
 182                         move_north(b);
 183                         break;
 184                 case south:
 185                         move_south(b);
 186                         break;
 187                 case east:
 188                          move_east(b);
 189                         break;
 190                 case west:
 191                         move_west(b);
 192                         break;
 193                 default: // will never execute anyway
 194                         return;
 195         }
 196 }
 197
 198 void merge(board *b, const int d) {
 199         bool ok = (d == south) ||
 200                 (d == east) ||
 201                 (d == north) ||
 202                 (d == west);
 203         assert(ok);
 204         switch(d) {
 205                 case north:
 206                         merge_north(b);
 207                         break;
 208                 case south:
 209                         merge_south(b);
 210                         break;
 211                 case east:
 212                         merge_east(b);
 213                         break;
 214                 case west:
 215                         merge_west(b);
 216                         break;
 217                 default: // will never execute anyway
 218                         return;
 219         }
 220 }
 221
 222 bool move_possible_south(board *b) {
 223         for(int i = 0; i < 4; ++i) {
 224                 for(int j = 0; j < 3; ++j) {
 225                         if(b->x[i][j] != 0) {
 226                                 if(b->x[i][j+1] == 0)
 227                                         return true;
 228                                 if(b->x[i][j] == b->x[i][j+1])
 229                                         return true;
 230                         }
 231                 }
 232         }
 233         return false;
 234 }
 235
 236 bool move_possible_north(board *b) {
 237         for(int i = 0; i < 4; ++i) {
 238                 for(int j = 1; j < 4; ++j) {
 239                         if(b->x[i][j] != 0) {
 240                                 if(b->x[i][j-1] == 0)
 241                                         return true;
 242                                 if(b->x[i][j] == b->x[i][j-1])
 243                                         return true;
 244                         }
 245                 }
 246         }
 247         return false;
 248 }
 249
 250 bool move_possible_east(board *b) {
 251         for(int i = 0; i < 3; ++i) {
 252                 for(int j = 0; j < 4; ++j) {
 253                         if(b->x[i][j] != 0) {
 254                                 if(b->x[i+1][j] == 0)
 255                                         return true;
 256                                 if(b->x[i+1][j] == b->x[i][j])
 257                                         return true;
 258                         }
 259                 }
 260         }
 261         return false;
 262 }
 263
 264 bool move_possible_west(board *b) {
 265         for(int i = 1; i < 4; ++i) {
 266                 for(int j = 0; j < 4; ++j) {
 267                         if(b->x[i][j] != 0) {
 268                                 if(b->x[i-1][j] == 0)
 269                                         return true;
 270                                 if(b->x[i-1][j] == b->x[i][j])
 271                                         return true;
 272                         }
 273                 }
 274         }
 275         return false;
 276 }
 277
 278 void move_north(board *b) {
 279         int k;
 280         for(int i = 0; i < 4; ++i) {
 281                 for(int j = 1; j < 4; ++j) {
 282                         if(b->x[i][j] != 0) {
 283                                 k = j;
 284                                 while(b->x[i][k-1] == 0) {
 285                                         b->x[i][k-1] = b->x[i][k];
 286                                         b->x[i][k] = 0;
 287                                         k--;
 288                                         if(k < 1)
 289                                                 break;
 290                                 }
 291                         }
 292                 }
 293         }
 294 }
 295
 296 void move_south(board *b) {
 297         int k;
 298         for(int i = 0; i < 4; ++i) {
 299                 for(int j = 2; j >= 0; --j) {
 300                         if(b->x[i][j] != 0) {
 301                                 k = j;
 302                                 while(b->x[i][k+1] == 0) {
 303                                         b->x[i][k+1] = b->x[i][k];
 304                                         b->x[i][k] = 0;
 305                                         k++;
 306                                         if(k > 2)
 307                                                 break;
 308                                 }
 309                         }
 310                 }
 311         }
 312 }
 313
 314 void move_east(board *b) {
 315         int k;
 316         for(int i = 2; i >= 0; --i) {
 317                 for(int j = 0; j < 4; ++j) {
 318                         if(b->x[i][j] != 0) {
 319                                 k = i;
 320                                 while(b->x[k+1][j] == 0) {
 321                                         b->x[k+1][j] = b->x[k][j];
 322                                         b->x[k][j] = 0;
 323                                         k++;
 324                                         if(k > 2)
 325                                                 break;
 326                                 }
 327                         }
 328                 }
 329         }
 330 }
 331
 332 void move_west(board *b) {
 333         int k;
 334         for(int i = 1; i < 4; ++i) {
 335                 for(int j = 0; j < 4; ++j) {
 336                         if(b->x[i][j] != 0) {
 337                                 k = i;
 338                                 while(b->x[k-1][j] == 0) {
 339                                         b->x[k-1][j] = b->x[k][j];
 340                                         b->x[k][j] = 0;
 341                                         k--;
 342                                         if(k < 1)
 343                                                 break;
 344                                 }
 345                         }
 346                 }
 347         }
 348 }
 349
 350 void merge_north(board *b) {
 351         for(int i = 0; i < 4; ++i) {
 352                 for(int j = 1; j < 4; ++j) {
 353                         if(b->x[i][j] != 0 && b->x[i][j] == b->x[i][j-1]) {
 354                                 b->x[i][j-1] *= 2;
 355                                 b->x[i][j] = 0;
 356                                 b->num_p--;
 357                                 b->points += b->x[i][j-1];
 358                         }
 359                 }
 360         }
 361 }
 362
 363 void merge_south(board *b) {
 364         for(int i = 0; i < 4; ++i) {
 365                 for(int j = 2; j >= 0; --j) {
 366                         if(b->x[i][j] != 0 && b->x[i][j] == b->x[i][j+1]) {
 367                                 b->x[i][j+1] *= 2;
 368                                 b->x[i][j] = 0;
 369                                 b->num_p--;
 370                                 b->points += b->x[i][j+1];
 371                         }
 372                 }
 373         }
 374 }
 375
 376 void merge_east(board *b) {
 377         for(int i = 2; i >= 0; --i) {
 378                 for(int j = 0; j < 4; ++j) {
 379                         if(b->x[i][j] != 0 && b->x[i+1][j] == b->x[i][j]) {
 380                                 b->x[i+1][j] *= 2;
 381                                 b->points += b->x[i+1][j];
 382                                 b->num_p--;
 383                                 b->x[i][j] = 0;
 384                         }
 385                 }
 386         }
 387 }
 388
 389 void merge_west(board *b) {
 390         for(int i = 1; i < 4; ++i) {
 391                 for(int j = 0; j < 4; ++j) {
 392                         if(b->x[i][j] != 0 && b->x[i-1][j] == b->x[i][j]) {
 393                                 b->x[i-1][j] *= 2;
 394                                 b->points += b->x[i-1][j];
 395                                 b->num_p--;
 396                                 b->x[i][j] = 0;
 397                         }
 398                 }
 399         }
 400 }
 401
 402 void print_sep() {
 403         printf("||--------------------------------------------------------------||\n");
 404 }
 405
 406 void print_board_line(board *b, int l) {
 407         printf("||\t%u\t|\t%u\t|\t%u\t|\t%u\t||\n", b->x[0][l], b->x[1][l], b->x[2][l], b->x[3][l]);
 408         print_sep();
 409 }
 410
 411 void print_board(board *b) {
 412         printf("\e[2J\e[0;0H");
 413         printf("Score: %u\n", b->points);
 414         print_sep();
 415         for(int i = 0; i < 4; ++i) {
 416                 print_board_line(b, i);
 417         }
 418         printf("\n");
 419 }
 420
 421 void print_score(board *b) {
 422         printf("Game Over\nScore:%u\n", b->points);
 423 }
 424
 425 void merge_test1() {
 426         board *b = new_board();
 427         b->x[2][0] = 2;
 428         b->x[3][0] = 2;
 429         merge_east(b);
 430         assert(b->x[3][0] == 4);
 431 }
 432
 433 void merge_test2() {
 434         board *b = new_board();
 435         b->x[2][0] = 2;
 436         b->x[3][0] = 2;
 437         print_board(b);
 438         move_west(b);
 439         print_board(b);
 440         merge_west(b);
 441         print_board(b);
 442         assert(b->x[0][0] == 4);
 443 }
 444
 445 void merge_test3() {
 446         board *b = new_board();
 447         b->x[0][0] = 2;
 448         b->x[0][1] = 2;
 449         print_board(b);
 450         merge_north(b);
 451         print_board(b);
 452         assert(b->x[0][0] == 4);
 453 }
 454
 455 void merge_test4() {
 456         board *b = new_board();
 457         b->x[0][2] = 2;
 458         b->x[0][3] = 2;
 459         print_board(b);
 460         merge_south(b);
 461         print_board(b);
 462         assert(b->x[0][3] == 4);
 463 }
 464
 465 void move_merge_test1() {
 466         board *b = new_board();
 467         b->x[2][0] = 4;
 468         b->x[3][0] = 2;
 469         b->x[3][2] = 2;
 470         print_board(b);
 471         move_south(b);
 472         print_board(b);
 473         merge_south(b);
 474         print_board(b);
 475         assert(b->x[3][3] == 4);
 476 }
 477
 478 void move_north_test() {
 479         board *b = new_board();
 480         b->x[2][3] = 8;
 481         b->x[2][2] = 0;
 482         b->x[2][1] = 0;
 483         b->x[2][0] = 0;
 484         b->x[0][1] = 2;
 485         b->x[0][0] = 0;
 486         b->x[3][0] = 4;
 487         b->x[3][1] = 2;
 488         b->x[3][2] = 3;
 489         b->x[3][3] = 16;
 490         print_board(b);
 491         move_north(b);
 492         merge_north(b);
 493         move_north(b);
 494         print_board(b);
 495         assert(b->x[2][0] == 8);
 496         assert(b->x[0][0] == 2);
 497 }
 498
 499 void move_merge_test2() {
 500         board *b = new_board();
 501         b->x[3][0] = 2;
 502         b->x[3][1] = 2;
 503         b->x[3][2] = 4;
 504         b->x[3][3] = 32;
 505         print_board(b);
 506         move_south(b);
 507         merge_south(b);
 508         move_south(b);
 509         print_board(b);
 510         assert(b->x[3][1] == 4);
 511 }
 512
 513 void move_merge_test3() {
 514         board *b = new_board();
 515         b->x[0][0] = 0;
 516         b->x[0][1] = 0;
 517         b->x[0][2] = 0;
 518         b->x[0][3] = 2;
 519         b->x[1][0] = 0;
 520         b->x[1][1] = 0;
 521         b->x[1][2] = 0;
 522         b->x[1][3] = 8;
 523         b->x[2][0] = 0;
 524         b->x[2][1] = 0;
 525         b->x[2][2] = 0;
 526         b->x[2][3] = 4;
 527         b->x[3][0] = 2;
 528         b->x[3][1] = 2;
 529         b->x[3][2] = 4;
 530         b->x[3][3] = 16;
 531         print_board(b);
 532         move_south(b);
 533         merge_south(b);
 534         move_south(b);
 535         print_board(b);
 536         assert(b->x[3][1] == 4);
 537 }
 538
 539 void run_tests() {
 540         /*
 541         merge_test1();
 542         merge_test2();
 543         merge_test3();
 544         merge_test4();
 545         move_merge_test1();
 546         move_north_test();
 547         */
 548         move_merge_test2();
 549         move_merge_test3();
 550 }
 551
 552 int main() {
 553 #if DBG
 554         run_tests();
 555 #else
 556         game_start();
 557 #endif
 558 }