Fundamentos:Solucións:Reversi:reversilib.c

reversilib.h

Podes Descargar o ficheiro

#ifndef __REVERSILIBH__
#define __REVERSILIBH__

int existeXogada(void);
int contaFichas(int *x1,int *x2);
int podeXogar(int x);
int comprobaXogada(int i,int j,int x,int dir);
int posicionXogada(int i,int j,int x);
void darVolta(int fila,int columna);

#endif

</c>

=== reversilib.c ===
Podes [http://web.iesrodeira.com/Descargas/Exercicios/Reversi/reversilib.c Descargar] o ficheiro

<c>
#include "reversi.h"
#include "reversilib.h"

extern char __tableiro[8][8];

/* existeXogada
   DEVOLVE: Distinto de 0 si existe xogada, 0 si non existe xogada
*/
int existeXogada(void)
{
  int x=0;

  x=((podeXogar(XOG1)||podeXogar(XOG2)));
  return x;
}

/* podeXogar
   RECIBE: O xogador a comprobar (x)
   DEVOLVE: 0 si o xogador non pode xogar, 1 si o xogador pode xogar
   DESCRIPCION: Comproba si un xogador ten algunha xogada posible.
*/
int podeXogar(int x)
{
  int pode=0;
  int i,j;

  i=0;
  while((i<8)&&(pode==0))
  {
    j=0;
    while((j<8)&&(pode==0))
    {
      pode=posicionXogada(i,j,x);
      j++;
    }
    i++;
  }
  return pode;  
}

/* Funcion comprobaXogada
   RECIBE: coordenadas da xogada (i,j)
           xogador a comprobar (xog)
           dirección a comprobar (dir)

   DEVOLVE: 1 si a ficha do xogador 'xog' pode
            xogar na posición (i,j)
*/
int comprobaXogada(int i,int j,int xog,int dir)
{
  int pode=0;
  int x,y;
  int contrario=XOG1;
  
  if (xog==XOG1) contrario=XOG2;
  switch(dir)
  {
    case DER: y=i; x=j+1;
              if ((x<8)&&(__tableiro[y][x]==contrario))
              {
                while((x<8)&&(__tableiro[y][x]==contrario)) x++;
                if (x<8) pode=1;
              }
              break;
    case ESQ: y=i; x=j-1;
              if ((x>=0)&&(__tableiro[y][x]==contrario))
              {
                while((x>=0)&&(__tableiro[y][x]==contrario)) x--;
                if (x>=0) pode=1;
              }
              break;
    case ARR: y=i-1; x=j;
              if ((y>=0)&&(__tableiro[y][x]==contrario))
              {
                while((y>=0)&&(__tableiro[y][x]==contrario)) y--;
                if (y>=0) pode=1;
              }
              break;
    case ABA: y=i+1; x=j;
              if ((y<8)&&(__tableiro[y][x]==contrario))
              {
                while((y<8)&&(__tableiro[y][x]==contrario)) y++;
                if (y<8) pode=1;
              }
              break;
    case ARRDER: y=i-1; x=j+1;
                 if ((y>=0)&&(x<8)&&(__tableiro[y][x]==contrario))
                 {
                   while((y>=0)&&(x<8)&&(__tableiro[y][x]==contrario))
                   {
                     y--;
                     x++;
                   }
                   if ((y>=0)&&(x<8)) pode=1;
                 }
                 break;
    case ARRESQ: y=i-1; x=j-1;
                 if ((y>=0)&&(x>=0)&&(__tableiro[y][x]==contrario))
                 {
                   while((y>=0)&&(x>=0)&&(__tableiro[y][x]==contrario))
                   {
                     y--;
                     x--;
                   }
                   if ((y>=0)&&(x>=0)) pode=1;
                 }
                 break;
    case ABADER: y=i+1; x=j+1;
                 if ((y<8)&&(x<8)&&(__tableiro[y][x]==contrario))
                 {
                   while((y<8)&&(x<8)&&(__tableiro[y][x]==contrario))
                   {
                     y++;
                     x++;
                   }
                   if ((y<8)&&(x<8)) pode=1;
                 }
                 break;
    case ABAESQ: y=i+1; x=j-1;
                 if ((y<8)&&(x>=0)&&(__tableiro[y][x]==contrario))
                 {
                   while((y<8)&&(x>=0)&&(__tableiro[y][x]==contrario))
                   {
                     y++;
                     x--;
                   }
                   if ((y<8)&&(x>=0)) pode=1;
                 }
                 break;
  }
  if (__tableiro[y][x]!=xog) pode=0;
  return pode;
}

/* posicionXogada
   RECIBE: fila (i), columna(j), xogador (x)
   DEVOLVE: 0 si o xogador non pode xogar na fila e columna indicadas
            1 si o xogador pode xogar na fila e columna indicadas
   DESCRIPCION: Comproba si un xogador pode poñer unha ficha nunha posición
*/
int posicionXogada(int i,int j,int x)
{
  int pode=0;
  int a,b;
  int outro;
  int dir;

  if (__tableiro[i][j]==VACIO)
  {
       pode=comprobaXogada(i,j,x,DER)||comprobaXogada(i,j,x,ESQ)||
            comprobaXogada(i,j,x,ARR)||comprobaXogada(i,j,x,ABA)||
            comprobaXogada(i,j,x,ARRESQ)||comprobaXogada(i,j,x,ARRDER)||
            comprobaXogada(i,j,x,ABAESQ)||comprobaXogada(i,j,x,ABADER);
  }
  return pode;
}



/* darVolta
   RECIBE: fila e columna onde se colocou a ficha
   DESCRIPCION: Da a volta as fichas que o precisen
*/
void darVolta(int fila,int columna)
{
  if (comprobaXogada(fila,columna,__tableiro[fila][columna],DER)) 
  {
    revira(fila,columna,DER);
  }
  if (comprobaXogada(fila,columna,__tableiro[fila][columna],ESQ)) 
  {
    revira(fila,columna,ESQ);
  }
  if (comprobaXogada(fila,columna,__tableiro[fila][columna],ARR)) 
  {
    revira(fila,columna,ARR);
  }
  if (comprobaXogada(fila,columna,__tableiro[fila][columna],ABA)) 
  {
     revira(fila,columna,ABA);
  }
  if (comprobaXogada(fila,columna,__tableiro[fila][columna],ARRDER)) 
  {
     revira(fila,columna,ARRDER);
  }
  if (comprobaXogada(fila,columna,__tableiro[fila][columna],ARRESQ)) 
  {
     revira(fila,columna,ARRESQ);
  }
  if (comprobaXogada(fila,columna,__tableiro[fila][columna],ABADER)) 
  {
     revira(fila,columna,ABADER);
  }
  if (comprobaXogada(fila,columna,__tableiro[fila][columna],ABAESQ)) 
  {
     revira(fila,columna,ABAESQ);
  }
}


/* contaFichas
    RECIBE: Dirección para deixar o número de fichas do Xogador 1 (x1) 
            e do xogador 2 (x2)
    DEVOLVE: 0 empate, 1 gañou o xog1, 2 gañou o xog2
*/
int contaFichas(int *x1,int *x2)
{
  int res=0;
  int i,j;

  *x1=0;
  *x2=0;
  i=0;
  while(i<8)
  {
    j=0;
    while(j<8)
    {
      if (__tableiro[i][j]==XOG1) *x1=(*x1)+1;
      else if (__tableiro[i][j]==XOG2) *x2=(*x2)+1;
      j++;
    }
    i++;
  }
  if (*x1>*x2) res=1;
  else if (*x2>*x1) res=2;
  return res;
}