Created
July 28, 2017 05:05
-
-
Save OxiBo/2626f961152fae06316e02e24f1838c4 to your computer and use it in GitHub Desktop.
CS50 pset3 fifteen
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
/** | |
* CS50 pset3 | |
* fifteen.c | |
* | |
* 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. | |
*/ | |
#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 | |
// board | |
int board[DIM_MAX][DIM_MAX]; | |
// dimensions | |
int d; | |
// blank tile position | |
int row, column; | |
// prototypes | |
void clear(void); | |
void greet(void); | |
void init(void); | |
void draw(void); | |
bool move(int tile); | |
bool won(void); | |
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; | |
} | |
// remember position of the tile with 0 value | |
row=d-1; | |
column=d-1; | |
// 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(500000); | |
} | |
// 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 value=d*d-1; | |
// create nested loops to iterate over each row ans column on the board | |
for(int i=0; i<d; i++) | |
{ | |
for(int j=0; j<d; j++, value--) | |
{ | |
//asign the value of each element of the array (values of the tiles on the board) | |
board[i][j]=value; | |
} | |
} | |
//swap values of the last two tiles on the board if d (dimension) is even number | |
if(d%2==0) | |
{ | |
int swap=board[d-1][d-3]; | |
board[d-1][d-3]=board[d-1][d-2]; | |
board[d-1][d-2]=swap; | |
} | |
} | |
/** | |
* Prints the board in its current state. | |
*/ | |
void draw(void) | |
{ | |
// create loops to iterate over every tile on the board and print their values | |
printf("\n"); | |
for(int i=0; i<d; i++) | |
{ | |
for(int j=0; j<d; j++) | |
{ | |
if(board[i][j]==0) | |
{ | |
printf(" _ "); | |
} | |
else | |
{ | |
printf("%2i ", board[i][j]); | |
} | |
} | |
printf("\n \n"); | |
} | |
printf("\n"); | |
} | |
/** | |
* If tile borders empty space, moves tile and returns true, else | |
* returns false. | |
*/ | |
bool move(int tile) | |
{ | |
int swap=0; | |
//check if tile to move within the board tiles values | |
if(tile<d*d-1||tile>0) | |
{ | |
//iterate over rows and columns looking for tile to move position | |
for (int i=0; i<d; i++) | |
{ | |
for(int j=0; j<d; j++) | |
{ | |
if(tile==board[i][j]) | |
{ | |
//check if tile to move is adjacent to tile with 0-value, swap values if so | |
if((i+1==row&&j==column)||(i-1==row&&j==column)||(i==row&&j+1==column)||(i==row&&j-1==column)) | |
{ | |
swap=board[row][column]; | |
board[row][column]=board[i][j]; | |
row=i; | |
column=j; | |
board[i][j]=swap; | |
return true; | |
break; | |
} | |
} | |
} | |
} | |
} | |
return false; | |
} | |
/** | |
* Returns true if game is won (i.e., board is in winning configuration), | |
* else false. | |
*/ | |
bool won(void) | |
{ | |
// iterate over each row and column to compare if values of the tils is in incrementing order | |
for(int i=0; i<d-1; i++) | |
{ | |
for(int j=0; j<d-1; j++) | |
{ | |
if((board[i][j]>board[i][j+1])||(board[i][j]>board[i+1][j])) | |
{ | |
return false; | |
} | |
} | |
} | |
return true; | |
return 0; | |
} |
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: fifteen.c | |
clang -ggdb3 -O0 -std=c11 -Wall -Werror -o fifteen fifteen.c -lcs50 -lm | |
clean: | |
rm -f *.o a.out core fifteen log.txt |
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
0. The framework allows following dimentions: 3x3 - 9x9 (DIM_MIN=3, DIM_MAX=9). | |
1. The game’s board is represented by two-dimensional array. | |
2. To greet the player at the game's start printf and usleep functions are called. | |
3. I need to implement following functions: init, draw, move, won. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment