Gioco di scacchi errore: Inferior 1 (process 4810) exited normally

di
emanulux
il
4 risposte
E
emanulux
Pochi posts
Iscritto da
mag, 2021
Messaggi:
7

Gioco di scacchi errore: Inferior 1 (process 4810) exited normally

Scusate ma quale è il problema, cosa significa l'errore che restituisce e non capisco perchè non stampa correttamente i pezzi, sembra prima di tutto che non li salvi nella struttura correttamente....
"4810" questo numero nell'errore varia ad ogni esecuzione effettuata con GDB...

Grazie per l'aiuto
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <locale.h>

#include <assert.h>

#define BRD_SQ_NUM 120

#define START_FEN "tcadract/pppppppp/8/8/8/8/PPPPPPPP/TCADRACT w RDrd - 0 1"

#define NomePezzo  " PCATDRpcatdr" /* codifica ASCII per windows */
#define latoChar "wb-"
#define RigaChar  "12345678"
#define ColonnaChar  "abcdefgh"

#define SUDESTRA 9
#define SUSINISTRA 11
#define GIUDESTRA -11
#define GIUSINISTRA -9
#define SU 10
#define SINISTRA 1
#define GIU -10
#define DESTRA -1




enum { EMPTY, wP, wC, wA, wT, wD, wR, bP, bC, bA, bT, bD, bR  };
enum { COLONNA_A, COLONNA_B, COLONNA_C, COLONNA_D, COLONNA_E, COLONNA_F, COLONNA_G, COLONNA_H, COLONNA_NONE };
enum { RIGA_1, RIGA_2, RIGA_3, RIGA_4, RIGA_5, RIGA_6, RIGA_7, RIGA_8, RIGA_NONE };

enum { WHITE, BLACK, BOTH };


enum {
  A1 = 21, B1, C1, D1, E1, F1, G1, H1,
  A2 = 31, B2, C2, D2, E2, F2, G2, H2,
  A3 = 41, B3, C3, D3, E3, F3, G3, H3,
  A4 = 51, B4, C4, D4, E4, F4, G4, H4,
  A5 = 61, B5, C5, D5, E5, F5, G5, H5,
  A6 = 71, B6, C6, D6, E6, F6, G6, H6,
  A7 = 81, B7, C7, D7, E7, F7, G7, H7,
  A8 = 91, B8, C8, D8, E8, F8, G8, H8, NO_SQ, OFFBOARD
};

enum { FALSE, TRUE };

enum { WRCA = 1, WDCA = 2, BRCA = 4, BDCA = 8 };



typedef struct MOVE {
	char lettera;
	int from;
	int to;
	int cattura;
	int arrocco;
	int promozione;
	int enpassant;
	int pedonestart;
} MOVE_T;

typedef struct MOVE_NODE {
	MOVE_T move;
    struct MOVE_NODE *next;
} MOVE_NODE_T;

typedef struct ANNULLA {
	
    MOVE_T move;
	int arrocco;
	int enPas;
	int cinquantaMosse;
	int lato;
	int posKey;
    struct ANNULLA *next;

} ANNULLA_T;

struct nodo{
    int dato; //campo informativo di tipo intero che contiene i pezzi
    struct nodo *next; //puntatore al prossimo nodo della lista
};



typedef struct BOARD {

	int reSq[2];

	int lato;
	int enPas;
	int cinquantaMosse;

	int arrocco; //se il re puo' arroccare o meno

	int posKey;

	ANNULLA_T *history;

} BOARD_T;



int FilesBrd[BRD_SQ_NUM];
int RanksBrd[BRD_SQ_NUM];


int pezzoKeys[13][BRD_SQ_NUM];
int latoKey;
int CastleKeys[16];

int pezzoCol[13] = { BOTH, WHITE, WHITE, WHITE, WHITE, WHITE, WHITE,
	BLACK, BLACK, BLACK, BLACK, BLACK, BLACK };
	
int pezzoIspezzo[13] = { FALSE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE, TRUE };
int pezzopedone[13] = { FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE };	
int pezzocavallo[13] = { FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE };
int pezzore[13] = { FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, TRUE };
int pezzotorredonna[13] = { FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE, FALSE, FALSE, FALSE, TRUE, TRUE, FALSE };
int pezzoalfieredonna[13] = { FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE, FALSE, FALSE, TRUE, FALSE, TRUE, FALSE };
int pezzoSlides[13] = { FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE, FALSE, FALSE, TRUE, TRUE, TRUE, FALSE };


const int KnDir[8] = { -8, -19,	-21, -12, 8, 19, 21, 12 };
const int RkDir[4] = { -1, -10,	1, 10 };
const int BiDir[4] = { -9, -11, 11, 9 };
const int KiDir[8] = { -1, -10,	1, 10, -9, -11, 11, 9 };

const int PceDir[13][8] = {
	{ 0, 0, 0, 0, 0, 0, 0 },
	{ 0, 0, 0, 0, 0, 0, 0 },
	{ -8, -19,	-21, -12, 8, 19, 21, 12 },
	{ GIUSINISTRA, GIUDESTRA, SUSINISTRA, SUDESTRA, 0, 0, 0, 0 },
	{ DESTRA, GIU, SINISTRA, SU, 0, 0, 0, 0 },
	{ DESTRA, GIU, SINISTRA, SU, GIUSINISTRA, GIUDESTRA, SUSINISTRA, SUDESTRA },
	{ DESTRA, GIU, SINISTRA, SU, GIUSINISTRA, GIUDESTRA, SUSINISTRA, SUDESTRA },
	{ 0, 0, 0, 0, 0, 0, 0 },
	{ -8, -19,	-21, -12, 8, 19, 21, 12 },
	{ GIUSINISTRA, GIUDESTRA, SUSINISTRA, SUDESTRA, 0, 0, 0, 0 },
	{ DESTRA, GIU, SINISTRA, SU, 0, 0, 0, 0 },
	{ DESTRA, GIU, SINISTRA, SU, GIUSINISTRA, GIUDESTRA, SUSINISTRA, SUDESTRA },
	{ DESTRA, GIU, SINISTRA, SU, GIUSINISTRA, GIUDESTRA, SUSINISTRA, SUDESTRA }
};

const int NumDir[13] = { 0, 0, 8, 4, 4, 8, 8, 0, 8, 4, 4, 8, 8};

const int CastlePerm[120] = {
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 13, 15, 15, 15, 12, 15, 15, 14, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15,  7, 15, 15, 15,  3, 15, 15, 11, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
    15, 15, 15, 15, 15, 15, 15, 15, 15, 15
};



void inserisci_testa (struct nodo** head, int elem){
    //alloco il nuovo nodo
    struct nodo* new_head;
    new_head = (struct nodo*)malloc(sizeof(struct nodo));    
    new_head->dato = elem;    
    new_head->next = *head;   
    *head = new_head;  
}

int accesso_posizione_x(struct nodo* head, int pos){

	int i=1,j=0;
	struct nodo* temp=NULL;
	temp=(struct nodo *)malloc(sizeof(struct nodo));
	temp=head;
        while((&head!=NULL)&&(i<pos)){
                head=head->next;
                i++;
        }
        j=head->dato;
        head=temp;
        return j;

}

int modifica (struct nodo* head, int elemento_da_trovare, int nuovo_valore){
    //posso usare head per scorrere la lista perche' e' una copia
    //arrivo fino alla fine oppure fino a quando non ho trovato l'elemento
    while ((head != NULL) && (head->dato != elemento_da_trovare)){
        //scorro la lista
        head = head->next;
    }
    //se la lista era vuota oppure non ho trovato l'elemento restituisco 1
    if(head == NULL)
        return 1;
    //se l'elemento esiste ne sostituisco il valore
    head->dato = nuovo_valore;
    return 0;
}

#define FR2SQ(f,r) ( (21 + (f) ) + ( (r) * 10 ) )
#define SQ64(sq120) (Sq120ToSq64[(sq120)])
#define SQ120(sq64) (Sq64ToSq120[(sq64)])
#define a accesso_posizione_x(pieces, sq)
#define OFFBOARD(a) (a == OFFBOARD)
#define pezzoISCOLOR(a, color) (pezzoCol[a] == color)


void InitFilesRanksBrd() {

	int index = 0;
	int file = COLONNA_A;
	int rank = RIGA_1;
	int sq = A1;

	for(index = 0; index < BRD_SQ_NUM; ++index) {
		FilesBrd[index] = OFFBOARD;
		RanksBrd[index] = OFFBOARD;
	}

	for(rank = RIGA_1; rank <= RIGA_8; ++rank) {
		for(file = COLONNA_A; file <= COLONNA_H; ++file) {
			sq = FR2SQ(file,rank);
			FilesBrd[sq] = file;
			RanksBrd[sq] = rank;
		}
	}
}

void PrintBoard(const BOARD_T *pos, struct nodo* head) {

	int sq,colonna,righe,pezzo,k;

	printf("\n");
	for(righe = RIGA_8; righe >= RIGA_1; righe--) {
		printf ("       +----+----+----+----+----+----+----+----+\n");
		printf("    %d  |",righe+1);
		for(colonna = COLONNA_A; colonna <= COLONNA_H; colonna++) {
			sq = FR2SQ(colonna,righe);
			k=accesso_posizione_x(head, sq);
			pezzo = k;
			printf("  %c |",NomePezzo[pezzo]); 
		}
		printf("\n");
	}

	printf("       +----+----+----+----+----+----+----+----+\n         a    b    c    d    e    f    g    h\n");
	
	printf("\n");
	if(pos->lato==WHITE)
	printf(" Turno: BIANCO  \n");
	if(pos->lato==BLACK)
	printf(" Turno: NERO  \n");

}

struct nodo* ResetBoard(BOARD_T *pos, struct nodo* head) {

	int colonna,righe,sq,k=0;

	for(righe = RIGA_8; righe >= RIGA_1; righe--) {
		for(colonna = COLONNA_A; colonna <= COLONNA_H; colonna++) {
		    
			sq = FR2SQ(colonna,righe);
			while((&head!=NULL)&&(k<sq)){
			head=head->next;
			k++;
			}
			head->dato=EMPTY;
			
		}
	}

	pos->reSq[WHITE] = pos->reSq[BLACK] = OFFBOARD;

	pos->lato = BOTH;
	pos->enPas = OFFBOARD;
	pos->cinquantaMosse = 0;
	pos->arrocco = 0;
	pos->posKey = 0;    

    return head;
    
}

void stampa(struct nodo* head){
    //posso usare head per scorrere la lista perche' e' una copia
    //scorro fino alla fine e stampo
    while ((head != NULL)){
        printf("%d ", head->dato);
        head = head->next;
    }
    printf("\n");
}


int ParseFen(char *fen, BOARD_T *pos, struct nodo* head) {

    struct nodo *temp=NULL;
    temp=(struct nodo *)malloc(sizeof(struct nodo));
    struct nodo *Head=NULL;
    Head=(struct nodo *)malloc(sizeof(struct nodo));
	

	int  righe = RIGA_8;
    	int  colonna = COLONNA_A;
    	int  pezzo = 0;
    	int  count = 0;
    	int  i = 0, t=0;
	int  sq64 = 0;
	int  sq120 = 0;
    	int k=0;
    	int index=0;
    
	for(index = 0; index < 400; ++index) {
		inserisci_testa(&head, OFFBOARD);
	    }
    temp=ResetBoard(pos, head);   
    
	while ((righe >= RIGA_1) && *fen) {
	    
	    pezzo=0;
	    
	    
		switch (*fen) {
            case 'p': pezzo = bP; break;
            case 't': pezzo = bT; break;
            case 'c': pezzo = bC; break;
            case 'a': pezzo = bA; break;
            case 'r': pezzo = bR; break;
            case 'd': pezzo = bD; break;
            case 'P': pezzo = wP; break;
            case 'T': pezzo = wT; break;
            case 'C': pezzo = wC; break;
            case 'A': pezzo = wA; break;
            case 'R': pezzo = wR; break;
            case 'D': pezzo = wD; break;

            case '1':
            case '2':
            case '3':
            case '4':
            case '5':
            case '6':
            case '7':
            case '8':
                pezzo = EMPTY;
                count = *fen - '0';
                break;

            case '/':
            case ' ':
                righe--;
                colonna = COLONNA_A;
                fen++;
                continue;

            default:
                printf(" FEN error \n");
                return -1;
        }
        
        
	    

		for (i = 0; i < count; i++) {
			sq120 = FR2SQ(colonna, righe);
            if (pezzo != EMPTY) {
                Head=temp;
                t=0;    	
            	while((Head!=NULL)&&(t<sq120)){
                	Head=Head->next;
                	t++;
					printf("t=%d \n",t);
				}
        		Head->dato=pezzo;
				
				if(pezzo == wR) {
					pos->reSq[WHITE] = sq120;
				}
				if(pezzo == bR) {
					pos->reSq[BLACK] = sq120;
				}
        	}
			colonna++;
        }
		fen++;
	}
	pos->lato = (*fen == 'w') ? WHITE : BLACK;
	fen += 2;

	for (i = 0; i < 4; i++) {
        if (*fen == ' ') {
            break;
        }
		switch(*fen) {
			case 'R': pos->arrocco |= WRCA; break;
			case 'D': pos->arrocco |= WDCA; break;
			case 'r': pos->arrocco |= BRCA; break;
			case 'd': pos->arrocco |= BDCA; break;
			default:	     break;
        }
		fen++;
	}
	fen++;

	if (*fen != '-') {
		colonna = fen[0] - 'a';
		righe = fen[1] - '1';
		pos->enPas = FR2SQ(colonna,righe);
    }


    

    PrintBoard(pos, Head);

	return 0;
}

void ConsoleLoop(BOARD_T *pos, struct nodo* head) {

	setbuf(stdin, NULL);
    setbuf(stdout, NULL);

	MOVE_T move = {0,0,0,0,0,0,0};
	char inBuf[80], command[80];
	int num;

	 ParseFen(START_FEN, pos, head);
	

}

int main(int argc, char *argv[])
{   
    BOARD_T board[1];
    struct nodo* pieces;
    board->history = NULL;
    InitFilesRanksBrd();
    ConsoleLoop(board, pieces);
}

4 Risposte

  • S
    SpiritoLibero
    Utente Attivo
    Iscritto da
    lug, 2018
    Messaggi:
    273

    Re: Gioco di scacchi errore: Inferior 1 (process 4810) exited normally

    Il numero "4810" che varia di volta in volta è solo il PID del processo (chiaramente, ogni volta che avvii il programma, questo avrà un PID diverso).
    "Exited normally" significa che il programma è terminato correttamente... magari, dato che la funzione main() restituisce un int sarebbe bello ci fosse un return 0 ad indicare che il programma è terminato correttamente.

    Io l'ho preso, compilato, avviato e ha stampato un sacco di roba in console. Alla fine ha stampato la board (con una "@" in ogni posizione). Ha stampato "Turno: BIANCO". E lì il programma è terminato. Senza errori.
  • E
    emanulux
    Pochi posts
    Iscritto da
    mag, 2021
    Messaggi:
    7

    Re: Gioco di scacchi errore: Inferior 1 (process 4810) exited normally

    Ho allegato la scacchiera come dovrebbe comparire, con tutti i pezzi, solo che la stampa senza i pezzi...

    Qual è l'errore che potrebbe causare questo???
    Allegati:
    questo è quello che dovrebbe comparire
    questo è quello che dovrebbe comparire
  • Rubik
    Rubik
    Utente Attivo
    Iscritto da
    ago, 2020
    Messaggi:
    440

    Re: Gioco di scacchi errore: Inferior 1 (process 4810) exited normally

    Compilato e non ricevo errori.
    Ho visto che la variabile: pezzo che dovrebbe decidere la lettera da stampare contenuta in NomePezzo vale sempre 100
    Se ci spieghi come accesso_posizione_x(head, sq) dovrebbe trovare il valore giusto per k, forse trovi anche l'errore...
    void PrintBoard(const BOARD_T *pos, struct nodo* head) {

	int sq,colonna,righe,pezzo,k;

	printf("\n");
	for(righe = RIGA_8; righe >= RIGA_1; righe--) {
		printf ("       +----+----+----+----+----+----+----+----+\n");
		printf("    %d  |",righe+1);
		for(colonna = COLONNA_A; colonna <= COLONNA_H; colonna++) {
			sq = FR2SQ(colonna,righe);
			k=accesso_posizione_x(head, sq); // k vale sempre 100
			pezzo = k;
			printf("  %c |",NomePezzo[pezzo]); // pezzo vale sempre 100
		}
		printf("\n");
	}

	printf("       +----+----+----+----+----+----+----+----+\n         a    b    c    d    e    f    g    h\n");

	printf("\n");
	if(pos->lato==WHITE)
	printf(" Turno: BIANCO  \n");
	if(pos->lato==BLACK)
	printf(" Turno: NERO  \n");

}
  • Weierstrass
    Weierstrass
    Utente Famoso
    Iscritto da
    feb, 2019
    Messaggi:
    2248

    Re: Gioco di scacchi errore: Inferior 1 (process 4810) exited normally

    Hai lasciato l'errore dell'altro thread. Non è che può funzionare tutto per magia

    Hai studiato i puntatori?
Devi accedere o registrarti per scrivere nel forum
4 risposte