Ciao, sto elaborando un gioco di scacchi, il compilatore non restituisce alcun errore, solo che quando lo eseguo va in Segmentation fault, ho inserito dei printf per vedere dove fosse il problema, e ho notato che nella funzione scacco matto, quando richiamo la funzione scacco, j che è la posizione del re vale 64, cosa impossibile perchè c'è un ciclo for per j<64, invece dovrebbe valere inizialmente j=60 casella E1; la cosa che non capisco è perchè nella funzione Inputmossa quando richiamo la funzione scacco, j è corretto???
/* descrizione di una casa della scacchiera */
typedef struct {
int Colore;
int Pezzo;
} Casella;
struct nodo_Casella
{
Casella dato;
struct nodo_Casella *next;
};
/* descrizione di una mossa per una determinata posizione */
typedef struct {
int Da;
int A;
} Mossa;
struct nodo_Mossa
{
Mossa dato;
struct nodo_Mossa *next;
};
/* costanti */
#define NUMEROCASE 64
#define CASExRIGA 8
#define NUMEROPEZZI 6
#define MAXMOSSE 1024
/* contenuto case */
#define BIANCO 0
#define NERO 1
#define PEDONE 0
#define CAVALLO 1
#define ALFIERE 2
#define TORRE 3
#define DONNA 4
#define RE 5
#define VUOTO 6
#define RIGA(x) (((unsigned)x)>>3)
#define COLONNA(x) (x & 7)
/* generali */
#define BOOL int
#define TRUE 1
#define FALSE 0
/* case */
#define A1 56
#define B1 57
#define C1 58
#define D1 59
#define E1 60
#define F1 61
#define G1 62
#define H1 63
#define A8 0
#define B8 1
#define C8 2
#define D8 3
#define E8 4
#define F8 5
#define G8 6
#define H8 7
/* posizione iniziale della scacchiera */
const int ColoriIniziali[NUMEROCASE] = {
NERO, NERO, NERO, NERO, NERO, NERO, NERO, NERO,
NERO, NERO, NERO, NERO, NERO, NERO, NERO, NERO,
VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO,
VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO,
VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO,
VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO,
BIANCO, BIANCO, BIANCO, BIANCO, BIANCO, BIANCO, BIANCO, BIANCO,
BIANCO, BIANCO, BIANCO, BIANCO, BIANCO, BIANCO, BIANCO, BIANCO
};
const int PezziIniziali[NUMEROCASE] = {
TORRE, CAVALLO, ALFIERE, DONNA, RE, ALFIERE, CAVALLO, TORRE,
PEDONE, PEDONE, PEDONE, PEDONE, PEDONE, PEDONE, PEDONE, PEDONE,
VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO,
VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO,
VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO,
VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO, VUOTO,
PEDONE, PEDONE, PEDONE, PEDONE, PEDONE, PEDONE, PEDONE, PEDONE,
TORRE, CAVALLO, ALFIERE, DONNA, RE, ALFIERE, CAVALLO, TORRE
};
void trova_e_sostituisci_casella (struct nodo_Casella* head, int c, int p, int index){
int i=0;
while ((head != NULL) && (i<index)){
//scorro la lista
head = head->next;
i++;
}
(head->dato).Colore = c;
(head->dato).Pezzo = p;
}
void modifica_pezzo_casella (struct nodo_Casella* head, int p, int index){
int i=0;
while ((head != NULL) && (i<index)){
//scorro la lista
head = head->next;
i++;
}
(head->dato).Pezzo = p;
}
int case_x_colore (struct nodo_Casella* head, int index){
int i=0;
int c=0;
while ((head != NULL) && (i<index)){
//scorro la lista
head = head->next;
i++;
}
c=(head->dato).Colore;
return c;
}
int case_x_pezzo (struct nodo_Casella* head, int index){
int i=0;
int p=0;
while ((head != NULL) && (i<index)){
//scorro la lista
head = head->next;
i++;
}
p=(head->dato).Pezzo;
return p;
}
void svuota_lista_casella (struct nodo_Casella** head){
struct nodo_Casella* t = *head; //precedente
struct nodo_Casella* w = *head; //successivo
while(t!=NULL){
w=t->next;
free(t);
t=w;}
t=NULL;
}
void trova_e_sostituisci_mossa (struct nodo_Mossa* head, int d, int a, int index){
int i=0;
while ((head != NULL) && (i<index)){
//scorro la lista
head = head->next;
i++;
}
(head->dato).Da = d;
(head->dato).A = a;
}
void svuota_lista_mosse (struct nodo_Mossa** head){
struct nodo_Mossa* t = *head; //precedente
struct nodo_Mossa* w = *head; //successivo
while(t!=NULL){
w=t->next;
free(t);
t=w;}
t=NULL;
}
int mossa_x_da (struct nodo_Mossa* head, int index){
int i=0;
int d=0;
while ((head != NULL) && (i<index)){
//scorro la lista
head = head->next;
i++;
}
d=(head->dato).Da;
return d;
}
int mossa_x_a (struct nodo_Mossa* head, int index){
int i=0;
int a=0;
while ((head != NULL) && (i<index)){
//scorro la lista
head = head->next;
i++;
}
a=(head->dato).A;
return a;
}
/* stack delle mosse generate */
struct nodo_Mossa* StackMosse=NULL;
void inizializza_lista_mosse (){
int i;
struct nodo_Mossa* mossa=StackMosse;
for(i=0; i<MAXMOSSE; i++){
//alloco il nuovo nodo
struct nodo_Mossa* head;
head = (struct nodo_Mossa*)malloc(sizeof(struct nodo_Mossa));
//lui diventa il primo nodo e quindi deve puntare all'attuale testa
head->next = mossa;
//la testa adesso deve puntare a lui
mossa = head;
//tutto e' andato a buon fine
}
StackMosse=mossa;
}
struct nodo_Casella* B=NULL;
/* contatore mosse generate */
int NumeroMosse;
int ChiMuove; /* colore che deve muovere */
/* Indica se un pezzo puo' muovere di piu' case alla volta
0 PEDONE, 1 CAVALLO, 2 ALFIERE, 3 TORRE, 4 DONNA, 5 RE
Il pedone e' trattato separatamente */
BOOL Trascina[NUMEROPEZZI] = {FALSE, FALSE, TRUE, TRUE, TRUE, FALSE};
/* Numero delle direzioni in cui un pezzo puo' muovere
0 PEDONE, 1 CAVALLO, 2 ALFIERE, 3 TORRE, 4 DONNA, 5 RE
Il pedone e' trattato separatamente */
const int NumeroDirezioni[NUMEROPEZZI] = {0, 8, 4, 4, 8, 8};
/* Direzioni dei vari pezzi in una matrice 10*12 (vedi matrice Da12A8[])
0 PEDONE, 1 CAVALLO, 2 ALFIERE, 3 TORRE, 4 DONNA, 5 RE
Es.: cavallo -21 vuol dire 2 righe sotto ed una colonna a sinistra
Il pedone e' trattato separatamente */
const int OffsetPezzi[NUMEROPEZZI][CASExRIGA] = {
{ 0, 0, 0, 0, 0, 0, 0, 0 },
{ -21, -19, -12, -8, 8, 12, 19, 21 },
{ -11, -9, 9, 11, 0, 0, 0, 0 },
{ -10, -1, 1, 10, 0, 0, 0, 0 },
{ -11, -10, -9, -1, 1, 9, 10, 11 },
{ -11, -10, -9, -1, 1, 9, 10, 11 }
};
/* Da12A8[] e' una matrice 10*12 utilizzata per verificare la legalita'
delle mosse. E' ottenuta aggiungendo ad una matrice 8*8 una
colonna per lato e due righe superiori ed inferiori con valori pari a -1,
che semplificano il test di mosse che cadono al di fuori della scacchiera.
Sono necessarie due righe per tener conto delle due case della mossa del cavallo,
cosa che orizzontalmente e' fornita dell'unione delle colonne destra e sinistra.
Le celle diverse da -1 rappresentano gli indici nella scacchiera 8*8 */
const int Da12A8[120] = {
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, 0, 1, 2, 3, 4, 5, 6, 7, -1,
-1, 8, 9, 10, 11, 12, 13, 14, 15, -1,
-1, 16, 17, 18, 19, 20, 21, 22, 23, -1,
-1, 24, 25, 26, 27, 28, 29, 30, 31, -1,
-1, 32, 33, 34, 35, 36, 37, 38, 39, -1,
-1, 40, 41, 42, 43, 44, 45, 46, 47, -1,
-1, 48, 49, 50, 51, 52, 53, 54, 55, -1,
-1, 56, 57, 58, 59, 60, 61, 62, 63, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
-1, -1, -1, -1, -1, -1, -1, -1, -1, -1
};
/* Per ogni casa della scacchiera 8*8, la matrice Da8A12[] fornisce
l'indice della corrispondente casa nella matrice 10*12 Da12A8[].
L'utilizzo sara' del tipo (vedi la funzione GeneraPseudo() )
CasaDestinazione =
Da12A8[Da8A12[CasaDestinazione] + OffsetPezzi[Pezzi[CasaCorrente]][Direzione]];
*/
const int Da8A12[NUMEROCASE] = {
21, 22, 23, 24, 25, 26, 27, 28,
31, 32, 33, 34, 35, 36, 37, 38,
41, 42, 43, 44, 45, 46, 47, 48,
51, 52, 53, 54, 55, 56, 57, 58,
61, 62, 63, 64, 65, 66, 67, 68,
71, 72, 73, 74, 75, 76, 77, 78,
81, 82, 83, 84, 85, 86, 87, 88,
91, 92, 93, 94, 95, 96, 97, 98
};
/* SalvaMossa() inserisce una mossa nello stack */
void SalvaMossa(int Da, int A) {
trova_e_sostituisci_mossa(StackMosse,(char)Da,(char)A,NumeroMosse);
NumeroMosse++;
}
void StampaMossa() {
int i=0;
struct nodo_Mossa* mossa=StackMosse;
while ((mossa != NULL)){
printf(" %d %d; ", mossa_x_da(mossa,i), mossa_x_a(mossa,i));
mossa = mossa->next;
i++;
}
printf(" \n ");
}
/* GeneraPseudo() genera mosse pseudolegali per la posizione corrente */
void GeneraPseudo() {
int CasaCorrente, CasaDestinazione, Direzione;
NumeroMosse = 0;
/* cerca tutte le case per pezzi del colore che deve muovere */
for (CasaCorrente = 0; CasaCorrente < NUMEROCASE; CasaCorrente++) {
if (case_x_colore(B,CasaCorrente) == ChiMuove) {
if (case_x_pezzo(B,CasaCorrente) == PEDONE) {
if (ChiMuove == BIANCO) {
/* mosse per il pedone bianco */
if (COLONNA(CasaCorrente) != 0 && case_x_colore(B,CasaCorrente-9) == NERO)
/* mangia in avanti a sinistra */
SalvaMossa(CasaCorrente, CasaCorrente - 9);
if (COLONNA(CasaCorrente) != 7 && case_x_colore(B,CasaCorrente-7) == NERO)
/* mangia in avanti a destra */
SalvaMossa(CasaCorrente, CasaCorrente - 7);
if (case_x_colore(B,CasaCorrente-CASExRIGA) == VUOTO) {
/* avanti una casa */
SalvaMossa(CasaCorrente, CasaCorrente - 8);
if (CasaCorrente >= 48 && case_x_colore(B,CasaCorrente-16) == VUOTO)
/* avanti due case */
SalvaMossa(CasaCorrente, CasaCorrente - 16);
}
}
else {
/* mosse per il pedone nero */
if (COLONNA(CasaCorrente) != 0 && case_x_colore(B,CasaCorrente)+7 == BIANCO)
SalvaMossa(CasaCorrente, CasaCorrente + 7);
if (COLONNA(CasaCorrente) != 7 && case_x_colore(B,CasaCorrente+9) == BIANCO)
SalvaMossa(CasaCorrente, CasaCorrente + 9);
if (case_x_colore(B,CasaCorrente+CASExRIGA) == VUOTO) {
SalvaMossa(CasaCorrente, CasaCorrente + 8);
if (CasaCorrente <= 15 && case_x_colore(B,CasaCorrente+16) == VUOTO)
SalvaMossa(CasaCorrente, CasaCorrente + 16);
}
}
} else {
/* per i pezzi differenti dal pedone */
/* genera mosse per ciascuna delle direzioni legali */
for (Direzione = 0; Direzione < NumeroDirezioni[case_x_pezzo(B,CasaCorrente)]; Direzione++) {
/* "CasaDestinazione" == casa destinazione inizializzata con la corrente */
CasaDestinazione = CasaCorrente;
while (TRUE) {
/* calcola la casa destinazione sommando l'offset
per il pezzo corrente alla casa corrente.
Si passa per la matrice 10*12 per verificare che
la mossa non cada fuori dalla scacchiera */
CasaDestinazione = Da12A8[Da8A12[CasaDestinazione] + OffsetPezzi[case_x_pezzo(B,CasaCorrente)][Direzione]];
/* mossa fuori dalla scacchiera */
if (CasaDestinazione == -1)
break;
/* mossa su una casa con un pezzo avversario */
if (case_x_colore(B,CasaDestinazione) != VUOTO) {
if (case_x_colore(B,CasaDestinazione != ChiMuove))
SalvaMossa(CasaCorrente, CasaDestinazione);
break;
}
/* mossa su una casa vuota */
SalvaMossa(CasaCorrente, CasaDestinazione);
/* se il pezzo puo' muovere di piu' case, continua */
if (!Trascina[case_x_pezzo(B,CasaCorrente)])
break;
}
}
}
}
}
}
/* Inizializza() inizializza la scacchiera */
void Inizializza() {
int i;
struct nodo_Casella* casa=B;
for(i=0;i < NUMEROCASE; i++){
struct nodo_Casella* p;
//alloco il nuovo nodo
struct nodo_Casella* new_node;
new_node = (struct nodo_Casella*)malloc(sizeof(struct nodo_Casella));
//popolo il nuovo nodo con i dati
(new_node->dato).Colore=ColoriIniziali[i];
(new_node->dato).Pezzo=PezziIniziali[i];
//lui sara' l'ultimo quindi deve puntare a NULL
new_node->next = NULL;
//se la lista e' vuota lui sara' anche il primo quindi la testa deve puntare a lui
if(casa==NULL){
casa=new_node;
}
else{
//inizio a scorrere partendo dalla testa
p = casa;
//scorro tutta la lista
while (p->next != NULL)
p = p->next;
//inserisco in coda
p->next = new_node;
}
}
B=casa;
ChiMuove = BIANCO;
}
/* ritorna FALSE se la casella e attaccata altrimenti TRUE */
int CasaAttaccata ( int k)
{
int h;
int y;
int riga;
int col;
int latoatt;
if(ChiMuove==BIANCO)
latoatt = NERO;
else latoatt = BIANCO; /* lato di chi attacca */
riga = RIGA (k);
col = COLONNA (k);
/* controllo se il cavallo attacca */
if (col > 0 && riga > 1 && case_x_colore(B,k-17) == latoatt && case_x_pezzo(B,k-17) == CAVALLO)
return FALSE;
if (col < 7 && riga > 1 && case_x_colore(B,k-15) == latoatt && case_x_pezzo(B,k-15) == CAVALLO)
return FALSE;
if (col > 1 && riga > 0 && case_x_colore(B,k-10) == latoatt && case_x_pezzo(B,k-10) == CAVALLO)
return FALSE;
if (col < 6 && riga > 0 && case_x_colore(B,k-6) == latoatt && case_x_pezzo(B,k-6) == CAVALLO)
return FALSE;
if (col > 1 && riga < 7 && case_x_colore(B,k+6) == latoatt && case_x_pezzo(B,k+6) == CAVALLO)
return FALSE;
if (col < 6 && riga < 7 && case_x_colore(B,k+10) == latoatt && case_x_pezzo(B,k+10) == CAVALLO)
return FALSE;
if (col > 0 && riga < 6 && case_x_colore(B,k+15) == latoatt && case_x_pezzo(B,k+15) == CAVALLO)
return FALSE;
if (col < 7 && riga < 6 && case_x_colore(B,k+17) == latoatt && case_x_pezzo(B,k+17) == CAVALLO)
return FALSE;
/* controllo delle linee orizontali e verticali DONNA, TORRE, RE */
/* giu */
y = k + 8;
if (y < 64)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == RE || case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == TORRE))
return FALSE;
if (case_x_pezzo(B,y) == VUOTO)
for (y += 8; y < 64; y += 8)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == TORRE))
return FALSE;
if (case_x_pezzo(B,y) != VUOTO)
break;
}
}
/* sinistra */
y = k - 1;
h = k - col;
if (y >= h)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == RE || case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == TORRE))
return FALSE;
if (case_x_pezzo(B,y) == VUOTO)
for (y--; y >= h; y--)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == TORRE))
return FALSE;
if (case_x_pezzo(B,y) != VUOTO)
break;
}
}
/* destra */
y = k + 1;
h = k - col + 7;
if (y <= h)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == RE || case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == TORRE))
return FALSE;
if (case_x_pezzo(B,y) == VUOTO)
for (y++; y <= h; y++)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == TORRE))
return FALSE;
if (case_x_pezzo(B,y) != VUOTO)
break;
}
}
/* su */
y = k - 8;
if (y >= 0)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == RE || case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == TORRE))
return FALSE;
if (case_x_pezzo(B,y) == VUOTO)
for (y -= 8; y >= 0; y -= 8)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == TORRE))
return FALSE;
if (case_x_pezzo(B,y) != VUOTO)
break;
}
}
/* controllo di eventuali attacchi dalle diagonali DONNA, ALFIERE, RE, PEDONE */
/* diagonale destra giu */
y = k + 9;
if (y < 64 && COLONNA (y) != 0)
{
if (case_x_colore(B,y) == latoatt)
{
if (case_x_pezzo(B,y) == RE || case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == ALFIERE)
return FALSE;
if (ChiMuove == NERO && case_x_pezzo(B,y) == PEDONE)
return FALSE;
}
if (case_x_pezzo(B,y) == VUOTO)
for (y += 9; y < 64 && COLONNA (y) != 0; y += 9)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == ALFIERE))
return FALSE;
if (case_x_pezzo(B,y) != VUOTO)
break;
}
}
/* diagonale sinistra giu */
y = k + 7;
if (y < 64 && COLONNA (y) != 7)
{
if (case_x_colore(B,y) == latoatt)
{
if (case_x_pezzo(B,y) == RE || case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == ALFIERE)
return FALSE;
if (ChiMuove == NERO && case_x_pezzo(B,y) == PEDONE)
return FALSE;
}
if (case_x_pezzo(B,y) == VUOTO)
for (y += 7; y < 64 && COLONNA (y) != 7; y += 7)
{
if (case_x_colore(B,y)== latoatt && (case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == ALFIERE))
return FALSE;
if (case_x_pezzo(B,y) != VUOTO)
break;
}
}
/* diagonale sinistra su */
y = k - 9;
if (y >= 0 && COLONNA (y) != 7)
{
if (case_x_colore(B,y) == latoatt)
{
if (case_x_pezzo(B,y) == RE || case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == ALFIERE)
return FALSE;
if (ChiMuove == BIANCO && case_x_pezzo(B,y) == PEDONE)
return FALSE;
}
if (case_x_pezzo(B,y) == VUOTO)
for (y -= 9; y >= 0 && COLONNA (y) != 7; y -= 9)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == ALFIERE))
return FALSE;
if (case_x_pezzo(B,y) != VUOTO )
break;
}
}
/* diagonale destra su */
y = k - 7;
if (y >= 0 && COLONNA(y) != 0)
{
if (case_x_colore(B,y) == latoatt)
{
if (case_x_pezzo(B,y) == RE || case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == ALFIERE)
return FALSE;
if (ChiMuove == BIANCO && case_x_pezzo(B,y) == PEDONE)
return FALSE;
}
if (case_x_pezzo(B,y) == VUOTO)
for (y -= 7; y >= 0 && COLONNA (y) != 0; y -= 7)
{
if (case_x_colore(B,y) == latoatt && (case_x_pezzo(B,y) == DONNA || case_x_pezzo(B,y) == ALFIERE))
return FALSE;
if (case_x_pezzo(B,y) != VUOTO)
break;
}
}
return TRUE;
}
int InScacco() {
int j;
GeneraPseudo();
/* verifica che il re non sia in una casa destinazione */
for (j = 0; j < NUMEROCASE; j++)
if (case_x_pezzo(B,j) == RE && case_x_colore(B,j) == ChiMuove)
break;
return CasaAttaccata (j);
}
BOOL ScaccoMatto() {
BOOL Matto = FALSE;
int i;
GeneraPseudo();
//StampaMossa();
for (i = 0; i < NumeroMosse; i++){
trova_e_sostituisci_casella (B, case_x_colore (B, mossa_x_da(StackMosse,i)),case_x_pezzo (B, mossa_x_da(StackMosse,i)), mossa_x_a(StackMosse,i));
trova_e_sostituisci_casella (B, VUOTO,VUOTO, mossa_x_da(StackMosse,i));
if(InScacco() == FALSE){
printf(" il re e attaccato ");
trova_e_sostituisci_casella (B, case_x_colore (B, mossa_x_a(StackMosse,i)),case_x_pezzo (B, mossa_x_a(StackMosse,i)), mossa_x_da(StackMosse,i));}
else {
Matto=TRUE; /* c'e almeno una mossa che si puo fare */
trova_e_sostituisci_casella (B, case_x_colore (B, mossa_x_a(StackMosse,i)),case_x_pezzo (B, mossa_x_a(StackMosse,i)), mossa_x_da(StackMosse,i));
}
}
return Matto;
}
/* InputMossa() riporta una mossa sulla scacchiera */
int InputMossa(char * Input) {
int i, Da, A, ch;
Mossa M;
BOOL Trovato = FALSE;
/* calcola dai primi due caratteri l'indice della casa di partenza */
M.Da = (Input[0] - 'a') + CASExRIGA * (CASExRIGA - (Input[1] - '0'));
/* calcola dai caratteri rimanenti l'indice della casa di destinazione */
M.A = (Input[2] - 'a') + CASExRIGA * (CASExRIGA - (Input[3] - '0'));
/* genera le mosse pseudolegali per la posizione corrente */
GeneraPseudo();
/* controlla che la mossa sia ammissibile cercandola nello stack */
for (i = 0; i < NumeroMosse; i++){
if ((mossa_x_da(StackMosse,i) == M.Da) && (mossa_x_a(StackMosse,i) == M.A)) {
Trovato = TRUE;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
if(InScacco() == FALSE){
printf(" Il re e' sotto scacco ");
Trovato=InScacco();
trova_e_sostituisci_casella (B, case_x_colore (B, M.A),case_x_pezzo (B, M.A), M.Da);
}
}
}
/* controlla se si tratta di un arrocco */
if (ChiMuove == BIANCO) {
if (!strcmp(Input, "e1g1")) {
if((CasaAttaccata(60) == FALSE)||(CasaAttaccata(61) == FALSE)||(CasaAttaccata(62) == FALSE)||(CasaAttaccata(63) == FALSE)){
printf(" l'arrocco non e' possibile ");
Trovato=FALSE;
}
else{
M.Da = H1; M.A = F1;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
M.Da = E1; M.A = G1;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
Trovato = TRUE;
}
}
if (!strcmp(Input, "e1c1")) {
if((CasaAttaccata(60) == FALSE)||(CasaAttaccata(59) == FALSE)||(CasaAttaccata(58) == FALSE)||(CasaAttaccata(57) == FALSE)||(CasaAttaccata(56) == FALSE)){
printf(" l'arrocco non e' possibile ");
Trovato=FALSE;
}
else{
M.Da = A1; M.A = D1;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
M.Da = E1; M.A = C1;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
Trovato = TRUE;
}
}
} else {
if (!strcmp(Input, "e8g8")) {
if((CasaAttaccata(4) == FALSE)||(CasaAttaccata(5) == FALSE)||(CasaAttaccata(6) == FALSE)||(CasaAttaccata(7) == FALSE)){
printf(" l'arrocco non e' possibile ");
Trovato=FALSE;
}
else{
M.Da = H8; M.A = F8;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
M.Da = E8; M.A = G8;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
Trovato = TRUE;
}
}
if (!strcmp(Input, "e8c8")) {
if((CasaAttaccata(0) == FALSE)||(CasaAttaccata(1) == FALSE)||(CasaAttaccata(2) == FALSE)||(CasaAttaccata(4) == FALSE)||(CasaAttaccata(4) == FALSE)){
printf(" l'arrocco non e' possibile ");
Trovato=FALSE;
}
else{
M.Da = A8; M.A = D8;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
M.Da = E8; M.A = C8;
trova_e_sostituisci_casella (B, case_x_colore (B, M.Da),case_x_pezzo (B, M.Da), M.A);
trova_e_sostituisci_casella (B, VUOTO,VUOTO, M.Da);
Trovato = TRUE;
}
}
}
return Trovato;
}
/* lettere dei pezzi bianchi per la VisualizzaScacchiera() */
char *SimboliPezziNero[NUMEROPEZZI] = {"\u2659","\u2658","\u2657","\u2656","\u2655","\u2654"};
/* lettere dei pezzi neri per la VisualizzaScacchiera() */
char *SimboliPezziBianco[NUMEROPEZZI] = {"\u265F","\u265E","\u265D","\u265C","\u265B","\u265A"};
/* VisualizzaScacchiera() visualizza la posizione dei pezzi */
void VisualizzaScacchiera() {
int i;
printf("\n +----+----+----+----+----+----+----+----+");
printf("\n 8 |");
for (i = 0; i < NUMEROCASE; i++) {
switch (case_x_colore(B,i)) {
case BIANCO:
printf(" %s |", SimboliPezziBianco[case_x_pezzo(B,i)]);
break;
case NERO:
printf(" %s |", SimboliPezziNero[case_x_pezzo(B,i)]);
break;
case VUOTO:
printf(" |");
break;
}
if ((i + 1) % CASExRIGA == 0 && i != (NUMEROCASE - 1)){
printf("\n +----+----+----+----+----+----+----+----+\n %d |", 7 - RIGA(i));
}
}
printf("\n +----+----+----+----+----+----+----+----+\n a b c d e f g h\n");
if (ChiMuove == BIANCO) {
printf("\n Turno: BIANCO\n");
} else {
printf("\n Turno: NERO\n");
}
}
/* main() è un loop che gestisce il prompt dei comandi */
int main(int argc, char **argv) {
int i;
char Command[256]; /* riga di comando */
printf("Scacchi \n");
inizializza_lista_mosse();
Inizializza();
VisualizzaScacchiera();
for(;;) {
if(ScaccoMatto == FALSE) {
printf("Scacco matto");
return 0;
}
/* prende l'input da consolle */
printf("sc> ");
if (scanf("%s", Command) == EOF)
return 0;
/* interpreta l'input come comando */
if (!strcmp(Command, "help")) {
printf("new - nuova partita\n");
printf("exit - fine del programma\n");
printf("d - visualizza la scacchiera\n");
printf("mosse - inserisci le coordinate; es.: e2e4\n");
continue;
}
if (!strcmp(Command, "new")) {
Inizializza();
VisualizzaScacchiera();
continue;
}
if (!strcmp(Command, "d")) {
VisualizzaScacchiera();
continue;
}
if (!strcmp(Command, "exit")) {
printf("sc> Ciao!\n");
svuota_lista_casella(&B);
svuota_lista_mosse(&StackMosse);
return 0;
}
/* interpreta l'input come coordinate di una mossa */
if (InputMossa(Command) == TRUE) {
ChiMuove ^= 1;
/* mossa accettata, mostra il risultato */
VisualizzaScacchiera();
/* cambia colore */
}
else {
/* Comando non valido */
printf(" Comando non valido\n");
}
}
}