0

I've been trying to correct the invalid moves, because in the check50, it doesn't stop for incorrect moves. I'm not really sure how to fix this, thanks! #define _XOPEN_SOURCE 500 #include #include #include #include

#define DIM_MIN 3
#define DIM_MAX 9
int board[DIM_MAX][DIM_MAX];
int d;
int blank_row;
int blank_col;
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;
}

// 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).
 */
int tile_row = -1;
int tile_col = -1;
void init(void)
{
blank_row = d-1;
blank_col = d-1;
int num = d * d - 1;
// TODO
for (int i = 0; i < d; i++) {
    for (int j = 0; j < d; j++) {
        board[i][j] = num;
        num--;

    }
}
        if (d % 2 == 0)
{
    board[d - 1][d - 3] = 1; // original value 2
    board[d - 1][d - 2] = 2; // original value 1
}
}

void draw(void)
{
int count = 0;
for (int i = 0; i < d; i++) {
    for (int j = 0; j < d; j++) {
        if (board[i][j] == 0) {
            printf(" _ ");
            count++;
        }
        else {
        if (board[i][j] < 10) {
            printf(" %i ", board[i][j]);
                count++;
        }
        else {
        printf("%i ", board[i][j]);
                count++;
        }

        }
    if (count % d == 0) {
            printf("\n\n");


        }
    }
}
printf("\n");
}

bool move(int tile)
{
for (int row = 0; row <= d-1; row++) {
    for (int column = 0; column <= d-1; column++) {
        if (board[row][column] == 0)
        {
            if (board[row-1][column] == tile) // valid move swap with up
            {
                board[row][column] = tile;
                board[row-1][column] = 0;
                return true;
            } else if (board[row+1][column] == tile) // valid move swap with down
            {
                board[row][column] = tile;
                board[row+1][column] = 0;
                return true;
            } else if (board[row][column-1] == tile) // valid move swap with left
            {
                board[row][column] = tile;
                board[row][column-1] = 0;
                return true;
            } else if (board[row][column+1] == tile) // valid move swap with right
            {
                board[row][column] = tile;
                board[row][column+1] = 0;
                return true;
            }

        }
    }
}
return true;

}



bool won(void)
{
int count = 1;
// TODO
for (int i = 0; i < d; i++)
{
    for(int j=0; j<d; j++)
    {
        if(board[i][j] != board[d - 1][d - 1])
        {
            if(board[i][j] != count)
                {
                    return false;
                }
        }
    count++;
    }
}
return true;
}
0

Use && to protect against reading invalid tiles (that are off board), like

if (row > 0 && board[row-1][column] == tile)

Use < d-1 for the +1 lines. If the left side of the && is false, it won't bother evaluating the right side.

Also, your move function should return false; (and not true) at the end of the function. If you don't return, the return value might be undefined (depending on the compiler, it might be set to 0, or stay at whatever value that memory block on the stack had).

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .