C Movimentar uma paça de xadrez

[Lipeco]

Boa noite.

Estou com o seguinte problema, tenho que fazer um trabalho pra fazer, que tem que funcionar da seguinte maneira.
 

Criar um programa que faça o movimento apenas do cavalo, com as seguintes regras, eu tenho que escolher a posição inicial e a partir daí ele se movimentar de forma aleatória e ele não pode visitar a mesma casa, e no final mostrar quantas casas ele visitou e quantas ele não visitou.
 

Eu estou fazendo um esboço, consegui ir até a parte que eu escolho a posição inicial e consigo gerar mais uma posição aleatória, porém aí que começa meus problemas, eu estou com uma lógica na cabeça, só que não estou conseguindo colocar no programa, que seria:

1 - tentei colocar limitações para o caso da posição ultrapassar os limites do tabuleiro, ele ficar na mesma posição e fazer outra posição aleatória - Não consegui.

2 - tentei o mesmo para o caso da posição seguinte for uma casa que já tenha sido visitada - Não consegui.

3 - Coloquei um laço de repetição, mas dá laço infinito.

 

Se puderem me dar dicas eu agradeço demais.

 

Segue o codigo:

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <math.h>
#include <time.h>

#define MAX 8

//Luiz Felipe

int main()
{
    setlocale(LC_ALL, "Portuguese");

    char tabuleiro[MAX][MAX], op, cont = 'A';
    int i, j, linhaAntes, colunaAntes, linhaDepois, colunaDepois, randon, opcao;

//INICIA TABULEIRO-----

    printf("#####################################################################\n");

    for(i=0;i<MAX;i++){
        for(j=0;j<MAX;j++){
            tabuleiro[i][j]=' ';
        }
    }

    printf("\t0 \t1 \t2 \t3 \t4 \t5 \t6 \t7\n");
    printf("    --------+-------+-------+-------+-------+-------+-------+-------\n");

    for(i=0;i<MAX;i++){
        printf(" %c", cont);
        for(j=0;j<MAX;j++){
           printf("\t%c", tabuleiro[i][j]);
        }
        printf("\n");
        printf("    --------+-------+-------+-------+-------+-------+-------+-------\n");
        cont++;
    } cont = 'A';

    printf("#####################################################################\n");

//FIM TABULEIRO-----

//ESCOLHA DA POSIÇÃO INICIAL-----

    while(i > 7){
            printf("\nEscolha uma posição inicial do cavalo");
            printf("\nEscolha uma letra:");
            scanf("%s", &op);
                if(op == 'a' || op=='A'){
                    i = 0;
                    linhaDepois = i;
                }else if(op == 'b' || op=='B'){
                    i=1;
                    linhaDepois = i;
                }else if(op == 'c' || op=='C'){
                    i=2;
                    linhaDepois = i;
                }else if(op == 'd' || op=='D'){
                    i=3;
                    linhaDepois = i;
                }else if(op == 'e' || op=='E'){
                    i=4;
                    linhaDepois = i;
                }else if(op == 'f' || op=='F'){
                    i=5;
                    linhaDepois = i;
                }else if(op == 'g' || op=='G'){
                    i=6;
                    linhaDepois = i;
                }else if(op == 'h' || op=='H'){
                    i=7;
                    linhaDepois = i;
                }else{
                    printf("Não existe essa opção!!!\n");
                }
    }

    while(j > 7){
        printf("Escolha um número:");
        scanf("%d", &j);
        colunaDepois = j;
        if(j>7){
            printf("Não existe essa opção, digite novamente...");
        }
        printf("\n");
    }

    tabuleiro[linhaDepois][colunaDepois] = 'C';

    printf("\t0 \t1 \t2 \t3 \t4 \t5 \t6 \t7\n");
    printf("    --------+-------+-------+-------+-------+-------+-------+-------\n");

    for(i=0;i<MAX;i++){
        printf(" %c", cont);
        for(j=0;j<MAX;j++){
           printf("\t%c", tabuleiro[i][j]);
        }
        printf("\n");
        printf("    --------+-------+-------+-------+-------+-------+-------+-------\n");
        cont++;
    }cont = 'A';
    printf("#####################################################################\n\n");

//FIM DA ESCOLHA E IMPRIMI A POSIÇÃO NO TABULEIRO

//INICIA AS POSIÇÕES ALEATÓRIAS

    printf("################  MOSTRANDO AS POSIÇÕES ALEATÓRIAS  ################\n\n");

    do{
        srand(time(NULL));
        randon = rand() % 2; // COLOQUEI APENAS 2 PARA TESTAR MAIS FÁCIL

        switch(randon){
           /*
            if(randon == 0){
                linhaDepois = linhaDepois+1;
                colunaDepois = colunaDepois+2;
                if(linhaDepois > 0 && colunaDepois >0 && linhaDepois <= 7 & colunaDepois <= 7){
                    tabuleiro[linhaDepois][colunaDepois] = 'C';
                }else{
                }
            }*/

            case 0:
                linhaDepois = linhaDepois+1;
                colunaDepois = colunaDepois+2;
                if(linhaDepois > 0 && colunaDepois >0 && linhaDepois <= 7 & colunaDepois <= 7){
                    tabuleiro[linhaDepois][colunaDepois] = 'C';
                    }else{
                        tabuleiro[linhaAntes][colunaAntes] = 'X';//COLOQUEI X PARA SABER SE CASO A POSIÇÃO SEGUINTE JÁ TENHA SIDO VISITADA, ELA PERMANECER NA MESMA POSIÇÃO E RANDOMIZAR DE NOVO.
                        printf("erro 0");
                    }

            break;
            case 1:

            linhaDepois = linhaDepois+2;
            colunaDepois = colunaDepois+1;
            if(tabuleiro[linhaDepois][colunaDepois] == ' ' && linhaDepois > 0 && colunaDepois >0 && linhaDepois <= 7 & colunaDepois <= 7){
                    tabuleiro[linhaDepois][colunaDepois] = 'C';
                    }else{
                         tabuleiro[linhaAntes][colunaAntes] = 'X';//COLOQUEI X PARA SABER SE CASO A POSIÇÃO SEGUINTE JÁ TENHA SIDO VISITADA, ELA PERMANECER NA MESMA POSIÇÃO E RANDOMIZAR DE NOVO.
                        printf("erro 1");
                    }
            break;

            case 2:
            linhaDepois = linhaDepois-1;
            colunaDepois = colunaDepois+2;
            if(linhaDepois > 0 && colunaDepois >0 && linhaDepois <= 7 & colunaDepois <= 7){
                    tabuleiro[linhaDepois][colunaDepois] = 'C';
                    }else{
                         tabuleiro[linhaAntes][colunaAntes] = 'X'; //COLOQUEI X PARA SABER SE CASO A POSIÇÃO SEGUINTE JÁ TENHA SIDO VISITADA, ELA PERMANECER NA MESMA POSIÇÃO E RANDOMIZAR DE NOVO.
                        printf("erro 2");
                    }
            break;
            /*
            case 3:
            linhaDepois = linhaDepois-2;
            colunaDepois = colunaDepois+1;
            break;

            case 4:
            linhaDepois = linhaDepois-2;
            colunaDepois = colunaDepois-1;
            break;

            case 5:
            linhaDepois = linhaDepois-1;
            colunaDepois = colunaDepois-2;
            break;

            case 6:
            linhaDepois = linhaDepois+1;
            colunaDepois = colunaDepois-2;
            break;

            case 7:
            linhaDepois = linhaDepois-2;
            colunaDepois = colunaDepois+1;
            break;
            */
            default:
                printf("Erro");
                break;
        }

        printf("\t0 \t1 \t2 \t3 \t4 \t5 \t6 \t7\n");
        printf("    --------+-------+-------+-------+-------+-------+-------+-------\n");

        for(linhaDepois=0;linhaDepois<MAX;linhaDepois++){
            printf(" %c", cont);
            for(colunaDepois=0;colunaDepois<MAX;colunaDepois++){
               printf("\t%c", tabuleiro[linhaDepois][colunaDepois]);
            }
            printf("\n");
            printf("    --------+-------+-------+-------+-------+-------+-------+-------\n");
            cont++;
        }cont = 'A';
        printf("#####################################################################\n");

    }while(tabuleiro[linhaDepois][colunaDepois] = ' ' && linhaDepois > 0 && colunaDepois > 0 && linhaDepois > 7 && colunaDepois > 7);

    return 0;
}

 

[kgin]

@Lipeco Tente pensa nas posições das peças em si, e não nas posições que ela ocupa no tabuleiro.

assim movimentá-las será mais fácil.

 

exemplo

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define T_NOME 40

#define Q_JOGADORES 2
#define Q_PECAS 16

#define TABULEIRO_LARGURA 8
#define TABULEIRO_ALTURA TABULEIRO_LARGURA

enum jogadores 
{
    JOGADOR1 = 0,
    JOGADOR2
};

struct local
{
    unsigned short linha, coluna;
};

struct peca_xadres
{
    char nome[T_NOME];
    struct local local;
};

const struct peca_xadres LOCAL_PECAS[] = {
    "Torre", 0, 0,
    "Cavalo", 0, 1,
    "Bispo", 0, 2,
    "Rei", 0, 3,
    "Rainha", 0, 4,
    "Bispo", 0, 5,
    "Cavalo", 0, 6,
    "Torre", 0, 7,
    "Peao", 1, 0,
    "Peao", 1, 1,
    "Peao", 1, 2,
    "Peao", 1, 3,
    "Peao", 1, 4,
    "Peao", 1, 5,
    "Peao", 1, 6,
    "Peao", 1, 7
};

void
iniciaPecas(struct peca_xadres *pecas, enum jogadores jogador);

int main(void)
{
    int linha, coluna, contador1, contador2, contador3;
    char tabuleiro[TABULEIRO_LARGURA][TABULEIRO_ALTURA];
    int posicoes_tabuleiro[TABULEIRO_LARGURA*TABULEIRO_ALTURA] = {0};
    struct peca_xadres pecas[Q_JOGADORES][Q_PECAS];

    /* Inicia as peças do tabuleiro */
    for (contador1 = 0; contador1 < Q_JOGADORES; contador1++) {
        iniciaPecas(pecas[contador1], contador1);
    }

    /* Limpa o tabuleiro */
    for (coluna = 0; coluna < TABULEIRO_LARGURA; coluna++) {
        for (linha = 0; linha < TABULEIRO_ALTURA; linha++) {
            tabuleiro[coluna][linha] = ' ';
        }
    }

    /* Coloca as peças no tabuleiro */
    for (contador1 = 0; contador1 < 2; contador1++) {
        for (contador2 = 0; contador2 < Q_PECAS; contador2++) {
            tabuleiro[pecas[contador1][contador2].local.coluna][pecas[contador1][contador2].local.linha] = pecas[contador1][contador2].nome[0];
        }
    }

    /* Mostra o tabuleiro */
    for (coluna = 0; coluna < TABULEIRO_LARGURA; coluna++) {
        for (linha = 0; linha < TABULEIRO_ALTURA; linha++) {
            printf("%c|", tabuleiro[coluna][linha]);
        }
        putchar('\n');
    }

    /* Quantidade de posições posiveis de se visitar */
    for (contador1 = 0; contador1 < TABULEIRO_LARGURA*TABULEIRO_ALTURA; contador1++) {
        posicoes_tabuleiro[contador1] = contador1;
    }

    /* Embaralha as posições */
    srand(time(NULL));
    for (contador1 = 0; contador1 < TABULEIRO_LARGURA*TABULEIRO_ALTURA; contador1++) {
        int tmp = posicoes_tabuleiro[contador1], local = rand()%(TABULEIRO_ALTURA*TABULEIRO_LARGURA);
        posicoes_tabuleiro[contador1] = posicoes_tabuleiro[local];
        posicoes_tabuleiro[local] = tmp;
    }

    /* Move uma peça para uma posição aleatoria */
    for (contador1 = 0; contador1 < TABULEIRO_ALTURA*TABULEIRO_LARGURA; contador1++) {
        int quantidade_pecas = 0;
        for (contador2 = 0; contador2 < Q_JOGADORES; contador2++) {
            for (contador3 = 0; contador3 < Q_PECAS; contador3++) {
                if (posicoes_tabuleiro[contador1]/TABULEIRO_ALTURA == pecas[contador2][contador3].local.coluna&&
                    posicoes_tabuleiro[contador1]%TABULEIRO_LARGURA == pecas[contador2][contador3].local.linha) {
                    quantidade_pecas++;
                }
            }
        }

        /* Checa se a posição está vaga */
        if (quantidade_pecas == 0) {
            pecas[JOGADOR1][4].local.coluna = posicoes_tabuleiro[contador1]/TABULEIRO_ALTURA;
            pecas[JOGADOR1][4].local.linha = posicoes_tabuleiro[contador1]%TABULEIRO_LARGURA;
            break;
        }
    }

    /* Limpa o tabuleiro */
    for (coluna = 0; coluna < TABULEIRO_LARGURA; coluna++) {
        for (linha = 0; linha < TABULEIRO_ALTURA; linha++) {
            tabuleiro[coluna][linha] = ' ';
        }
    }

    /* Coloca as peças no tabuleiro */
    for (contador1 = 0; contador1 < 2; contador1++) {
        for (contador2 = 0; contador2 < Q_PECAS; contador2++) {
            tabuleiro[pecas[contador1][contador2].local.coluna][pecas[contador1][contador2].local.linha] = pecas[contador1][contador2].nome[0];
        }
    }

    printf("\n");
    /* Mostra o tabuleiro */
    for (coluna = 0; coluna < TABULEIRO_LARGURA; coluna++) {
        for (linha = 0; linha < TABULEIRO_ALTURA; linha++) {
            printf("%c|", tabuleiro[coluna][linha]);
        }
        putchar('\n');
    }
    printf("%s foi movido para %i, %i\n", pecas[JOGADOR1][4].nome, pecas[JOGADOR1][4].local.linha, pecas[JOGADOR1][4].local.coluna);
    printf("Pressione enter para encerrar o programa\n");
    getchar();
    return(0);
}

void
iniciaPecas(struct peca_xadres *pecas, enum jogadores jogador)
{
    int contador;
    for (contador = 0; contador < Q_PECAS; contador++) {
        pecas[contador] = LOCAL_PECAS[contador];
    }
    
    if (jogador == JOGADOR2) {
        for (contador = 0; contador < Q_PECAS; contador++) {
            if (contador < 8) {
                pecas[contador].local.linha = 7;
            } else {
                pecas[contador].local.linha = 6;
            }
        }
    }
}

Eu fiz o código meio na pressa, mas eu acho que da pra pegar a ideia.

[Lipeco]

@kgin Vou seguir sua dica, assim que eu conseguir atualizo aqui. Muito obrigado pela dica irmão.

[arfneto]

12 horas atrás, kgin disse:

Tente pensa nas posições das peças em si, e não nas posições que ela ocupa no tabuleiro.

assim movimentá-las será mais fácil

 

Que significa? As posições das "peças em si" são... no tabuleiro. Posições. No tabuleiro. Não há outras posições.

 

12 horas atrás, kgin disse:

Eu fiz o código meio na pressa, mas eu acho que da pra pegar a ideia

 

Qual é a ideia? No forum talvez tivesse grande valor você expressar a ideia.