Created
December 6, 2017 18:12
-
-
Save ixxheartxxcandy/276619a273df721017c949b1e9016994 to your computer and use it in GitHub Desktop.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
/** | |
* fifteen.c | |
* | |
* CS50 AP | |
* Fifteen | |
* | |
* Implements Game of Fifteen (generalized to d x d). | |
* | |
* Usage: fifteen d | |
* | |
* whereby the board's dimensions are to be d x d, | |
* where d must be in [DIM_MIN,DIM_MAX] | |
* | |
* Note that usleep is obsolete, but it offers more granularity than | |
* sleep and is simpler to use than nanosleep; `man usleep` for more. | |
* | |
* Extra features including printing an actual grid to make it look more | |
* tile-like, and using ANSI color sequences for some additional customizing | |
*/ | |
#define _XOPEN_SOURCE 500 | |
#include <cs50.h> | |
#include <stdio.h> | |
#include <stdlib.h> | |
#include <unistd.h> | |
// constants | |
#define DIM_MIN 3 | |
#define DIM_MAX 9 | |
// ansi escape sequence to print grid color | |
// replace the number beteen [ and m with 31 for red, 32 for green, 33 for brown, | |
// 34 for blue, 35 for purple, 36 for cyan, 37 for gray | |
#define COLOR "\033[32m" | |
// board | |
int board[DIM_MAX][DIM_MAX]; | |
// dimensions | |
int d; | |
int yspace; | |
int xspace; | |
// saved locations of the blank tile | |
int blank_row; | |
int blank_col; | |
// prototypes | |
void clear(void); | |
void greet(void); | |
void init(void); | |
void draw(void); | |
bool move(int tile); | |
bool won(void); | |
void swap(int *a, int *b); | |
void print_grid_row(int d); | |
void print_tile(int tile); | |
int main(int argc, string argv[]) | |
{ | |
// ensure proper usage | |
if (argc != 2) | |
{ | |
printf("Usage: fifteen d\n"); | |
return 1; | |
} | |
// ensure valid dimensions | |
d = atoi(argv[1]); | |
if (d < DIM_MIN || d > DIM_MAX) | |
{ | |
printf("Board must be between %i x %i and %i x %i, inclusive.\n", | |
DIM_MIN, DIM_MIN, DIM_MAX, DIM_MAX); | |
return 2; | |
} | |
// open log | |
FILE *file = fopen("log.txt", "w"); | |
if (file == NULL) | |
{ | |
return 3; | |
} | |
// greet user with instructions | |
greet(); | |
// initialize the board | |
init(); | |
// accept moves until game is won | |
while (true) | |
{ | |
// clear the screen | |
clear(); | |
// draw the current state of the board | |
draw(); | |
// log the current state of the board (for testing) | |
for (int i = 0; i < d; i++) | |
{ | |
for (int j = 0; j < d; j++) | |
{ | |
fprintf(file, "%i", board[i][j]); | |
if (j < d - 1) | |
{ | |
fprintf(file, "|"); | |
} | |
} | |
fprintf(file, "\n"); | |
} | |
fflush(file); | |
// check for win | |
if (won()) | |
{ | |
printf("ftw!\n"); | |
break; | |
} | |
// prompt for move | |
printf("Tile to move: "); | |
int tile = get_int(); | |
// quit if user inputs 0 (for testing) | |
if (tile == 0) | |
{ | |
break; | |
} | |
// log move (for testing) | |
fprintf(file, "%i\n", tile); | |
fflush(file); | |
// move if possible, else report illegality | |
if (!move(tile)) | |
{ | |
printf("\nIllegal move.\n"); | |
usleep(500000); | |
} | |
// sleep thread for animation's sake | |
usleep(50000); | |
} | |
// close log | |
fclose(file); | |
// success | |
return 0; | |
} | |
/** | |
* Clears screen using ANSI escape sequences. | |
*/ | |
void clear(void) | |
{ | |
printf("\033[2J"); | |
printf("\033[%d;%dH", 0, 0); | |
} | |
/** | |
* Greets player. | |
*/ | |
void greet(void) | |
{ | |
clear(); | |
printf("WELCOME TO GAME OF FIFTEEN\n"); | |
usleep(2000000); | |
} | |
/** | |
* Initializes the game's board with tiles numbered 1 through d*d - 1 | |
* (i.e., fills 2D array with values but does not actually print them). | |
*/ | |
void init(void) | |
{ | |
int board_tile = 0, i, j; | |
for ( j = 0; j < d; j++) | |
{ | |
for (i = 0; i <= d; i++) | |
{ | |
board_tile = ((j + 1) * d) - (i + 1); | |
switch (board_tile) | |
{ | |
case 1 : | |
{ | |
if (d % 2 == 1) | |
{ | |
board[i][j] = board_tile; | |
} | |
else if (d % 2 == 0)\ | |
{ | |
board[i][j] = 2; | |
} | |
break; | |
} | |
case 2 : | |
{ | |
if (d % 2 == 1) | |
{ | |
board[i][j] = board_tile; | |
} | |
else if (d % 2 == 0) | |
{ | |
board[i][j] = 1; | |
} | |
break; | |
} | |
default : | |
{ | |
board[i][j] = board_tile; | |
break; | |
} | |
} | |
} | |
} | |
} | |
/** | |
* Prints the board in its current state. | |
*/ | |
void draw(void) | |
{ | |
int i, j; | |
for (j = d - 1; j >= 0; j--) | |
{ | |
printf("\n"); | |
for ( i = 0; i < d; i++) | |
{ | |
if (board[i][j] >= 100) | |
{ | |
printf("%d|", board[i][j]); | |
} | |
else if (board[i][j] >= 10) | |
{ | |
if (d * d > 101) | |
{ | |
printf("%d |", board[i][j]); | |
} | |
if (d * d < 101) | |
{ | |
printf("%d|", board[i][j]); | |
} | |
} | |
else if (board[i][j] <= 10) | |
{ | |
if (board[i][j] == 0) | |
{ | |
printf("0 |"); | |
} | |
else if (board[i][j] > 0) | |
{ | |
if (d * d > 101) | |
{ | |
printf("%d |", board[i][j]); | |
} | |
if (d * d < 101) | |
{ | |
printf("%d |", board[i][j]); | |
} | |
} | |
} | |
// else if(board[i][j] == 0) | |
// { | |
// printf(" |"); | |
// } | |
} | |
} | |
} | |
/** | |
* If tile borders empty space, moves tile and returns true, else | |
* returns false. | |
*/ | |
bool move(int tile) | |
{ | |
int i, j; | |
int board_tile = 0; | |
int xval = 0; | |
int yval = 0; | |
for (j = d - 1; j >= 0; j--) | |
{ | |
for ( i = 0; i < d; i++) | |
{ | |
if (board[i][j] == tile) | |
{ | |
xval = i; | |
yval = j; | |
} | |
if (board[i][j] == 0) | |
{ | |
xspace = i; | |
yspace = j; | |
} | |
} | |
} | |
//board_tile++; | |
//printf("%d,%d\n",xval,yval); | |
if (xval - 1 == xspace && yval == yspace) | |
{ | |
board_tile = board[xval][yval]; | |
board[xval][yval] = 0; | |
board[xspace][yspace] = board_tile; | |
return true; | |
} | |
if (xval + 1 == xspace && yval == yspace) | |
{ | |
board_tile = board[xval][yval]; | |
board[xval][yval] = 0; | |
board[xspace][yspace] = board_tile; | |
return true; | |
} | |
if (yval - 1 == yspace && xval == xspace) | |
{ | |
board_tile = board[xval][yval]; | |
board[xval][yval] = 0; | |
board[xspace][yspace] = board_tile; | |
return true; | |
} | |
if (yval + 1 == yspace && xval == xspace) | |
{ | |
board_tile = board[xval][yval]; | |
board[xval][yval] = 0; | |
board[xspace][yspace] = board_tile; | |
return true; | |
} | |
// checks that tile is adjacent to the empty space: if it is then it copies it's value to that space | |
//and clears it's original space | |
return false; | |
} | |
/** | |
* Returns true if game is won (i.e., board is in winning configuration), | |
* else false. | |
*/ | |
bool won(void) | |
{ | |
int i, j; | |
int board_tile = 0; | |
for (j = d - 1; j >= 0; j--) | |
{ | |
for ( i = 0; i < d; i++) | |
{ | |
board_tile++; | |
if (board_tile == d * d) | |
{ | |
board_tile = 0; | |
} | |
if (board[i][j] != board_tile) | |
{ | |
return false; | |
} | |
} | |
} | |
return true; | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment