int p_brancas(Elem **Tab, int i, int j,int *DIM,Gravados *gr){
int n,o,s,e,mudou1,mudou2,mudou3,mudou4;
mudou1=1;mudou2=1;mudou3=1;mudou4=1;
if (i==0) n=0;else n=1;
if (j==0) o=0;else o=1;
if (i==((*DIM)-1)) s=0; else s=-1;
if (j==((*DIM)-1)) e=0; else e=-1;
if (n!=0) {
if ((mudou1=jogada('b',j+1,(i-n)+1,Tab,gr))>0) return -1;
}
if (s!=0) {
if ((mudou2=jogada('b',j+1,(i-s)+1,Tab,gr))>0) return -1;
}
if (e!=0) {
if ((mudou3=jogada('b',j-e+1,i+1,Tab,gr))>0) return -1;
}
if (o!=0) {
if ((mudou4=jogada('b',j-o+1,i+1,Tab,gr))>0) return -1;
}
if(mudou1==0 || mudou2==0 || mudou3==0 || mudou4==0) return 1;
else return 0;
}
void doisjogadores(char **board) {
system("clear");
print_usage2();
print_board(board);
while ((!game_over(board) && (!someone_wins(board, 'O')))) {
while(1) {
printf("\n\t\t\tVez de jogador 1:\n");
if (jogada(board,'X')) {
break;
//print_board(board)
}
}
if(game_over(board) || someone_wins(board, 'X'))
break;
system("clear");
print_board(board);
while (1) {
printf("\n\t\t\tVez de jogador 2:\n");
if(jogada(board,0)) {
break;
}
}
system("clear");
print_board(board);
}
system("clear");
print_board(board);
if (someone_wins(board, 'X')) {
printf("\t\t\t\t\t\t\t\tJogador 1 ganhou!\n");
enter();
getchar();
ultimos(board, 1);
} else if (someone_wins(board, 'O')) {
printf("\t\t\t\t\t\t\t\tJogador 2 ganhou!\n");
enter();
getchar();
ultimos(board, 2);
} else {
printf("\t\t\t\t\t\t\t\tFoi um empate!\n");
enter();
getchar();
getchar();
}
}
void umjogador(char **board) {
system("clear");
print_usage1();
int hor, vert, alpha;
move best_move = (move) malloc (sizeof(struct legal_move));
print_board(board);
while (!game_over(board) && (!someone_wins(board, 'X'))) {
if (jogada(board,0)) {
system("clear");
printf("A posição depois de sua última jogada:\n");
print_board(board);
alpha = minimax(board, 1, best_move);
update_board(board, best_move -> hor, best_move -> vert, 1);
printf("A posição depois da última jogada do computador:\n");
print_board(board);
}
}
if (someone_wins(board, 'X')) {
ai_wins();
} else {
cats_game();
}
}
main (){
setlocale (LC_ALL, "Portuguese");
system ("color 07");
//Essse loop "ZERA" as casas do tabuleiro para qualquer novo jogo.
for (i=0; i<=3; i++){
for (j=0;j<=3; j++){
casa[i][j] = '\0';
}
}
if (opcao == 5){
system ("cls");
cabecalho();
informa ();
} else {
menu1();
informa ();
}
opcao=0;
//O loop seguinte repete o jogo enquanto se iniciarem novos jogos com os mesmos jogadores.
do {
//A função da estrutura de decisão abaixo é informar novamente ao programa os nomes dos
//jogadores 1 e 2. O programa só passará por ela, em caso de novo jogo com jogadores iguais aos da partida anterior.
if (nomeaux == 1){
strcpy (nome1, nomeaux1);
strcpy (nome2, nomeaux2);
cabecalho ();
tabuleiro ();
}
//Laço de repetição que determina a duração do jogo.
while (vencedor == 0 && turno < 9) {
tabuleiro ();
jogada ();
system ("cls");
cabecalho ();
tabuleiro ();
for (i=1; i<=3; i++){
verificavencedor (i, 1, i, 2, i, 3); //verifica vencedor nas colunas
verificavencedor (1, i, 2, i, 3, i); //verifica vencedos nas linhas
}
verificavencedor (1, 1, 2, 2, 3, 3); //verifica vencedor na primeira diagona
verificavencedor (1, 3, 2, 2, 3, 1); //verifica vencedor na segunda diagonal
}
printf ("Pressione qualquer tecla para continuar...\n\n");
getch ();
placar ();
printf ("Pressione qualquer tecla para continuar...\n\n");
getch ();
menu2();
} while (opcao == 1);
printf("Obrigado por jogar TicTacToe\nDesenvolvido por José Tarciso e Olliver Felipe.\n\n Pressione qualquer tecla para sair...");
getch();
}
int p_preta(Elem **Tab, int i, int j,char letra,int *DIM,Gravados *gr){
int a,mudou1,mudou2;
mudou1=-1;mudou2=-1;
for (a=0;a<(*DIM);a++){
if(letra==(*Tab)[a][j].letra && a!=i) {
if ((mudou1=jogada('p',j+1,a+1,Tab,gr))>0) return -1;
}
if(letra==(*Tab)[i][a].letra && a!=j) {
if ((mudou2=jogada('p',a+1,i+1,Tab,gr))>0) return -1;
}
}
if(mudou1==0 || mudou2==0) return 1;
else return 0;
}
/*
Função principal, que faz as chamadas das demais funções.
*/
int main(){
allegro_init();
install_keyboard();
install_mouse();
set_color_depth(32);
set_gfx_mode(GFX_AUTODETECT_WINDOWED, 560, 400, 0, 0);
show_mouse(screen);
casasInva();
preecherCasas();
jogada();
displayUser_1();
msgVencedor();
return 0;
}
/**A função executajogada recebe os argumentos da linha de comandos e a cor que vai passar para a jogada.
* Vai verificar se tem os argumetos certos, e se tal vou verdade, chama a função jogada, para que esta se possa realizar.
* @param args Recebe ums string com os argumentos do comando do utilizador.
* @param cor Corresponde ao próprio comado que irá ser utilizado como a cor que se pretende mudar.
* @param Tab Tabuleiro do jogo
* @param DIM dimensão do tabuleiro
* @returns Retorna um inteiro que verifica se foi ou não bem sucedida a função.
*/
int executaJogada(char *args,char *cor,int *DIM,Elem **Tab) {
char buf[1024];
int x, y;
char teste1[1024],teste2[1024];
int nargs = sscanf(args, "%s %s %[^\n]", teste1,teste2, buf);
if(!isdigit(teste1[0]) || !isdigit(teste2[0])) {
return mensagem_de_erro(E_INVARGS);
}
nargs = sscanf(args, "%d %d %[^\n]", &x, &y, buf);
if(nargs != 2) {
return mensagem_de_erro(E_ARGS);
}
jogada(*cor,x,y,DIM,Tab);
return 0;
}
void verifica(){
// Verifica quais das 4 opções são possíveis de jogar.
int cima=0, baixo=0, esquerda=0, direita=0;
// Verifica se a posição onde o cursor está é uma PECA
if(m[posLin][posCol] != PECA)
return;
// Verifica jogada para cima
if(posLin>1 && // Verifica se linhas acima a posição estará na matriz
m[posLin-1][posCol] == PECA && // Verifica se a primeira casa acima é uma PECA
m[posLin-2][posCol] == VAZIO){ // Verifica se a segunda casa acima é um VAZIO
destaca(posLin-2,posCol); // Se satisfazer todas as condições, desta a jogada
cima = 1; // Marca como possível a jogada para cima
}
// Verifica jogada para baixo
if(posLin<7 &&
m[posLin+1][posCol] == PECA &&
m[posLin+2][posCol] == VAZIO){
destaca(posLin+2,posCol);
baixo = 1;
}
// Verifica jogada para esquerda
if(posCol>1 &&
m[posLin][posCol-1] == PECA &&
m[posLin][posCol-2] == VAZIO){
destaca(posLin,posCol-2);
esquerda = 1;
}
// Verifica jogada para direita
if(posCol<7 &&
m[posLin][posCol+1] == PECA &&
m[posLin][posCol+2] == VAZIO){
destaca(posLin,posCol+2);
direita = 1;
}
// Verifica se alguma jogada é possível
if(cima || baixo || esquerda || direita){
// Se apenas uma jogada está disponível, faz a jogada automaticamente.
// Se mais de uma está disponível, destaca as opções possíveis
// e pede ao jogador selecionar uma.
if(getch() == 224){
switch(getch()){
case CIMA: if(cima) jogada(CIMA); break;
case BAIXO: if(baixo) jogada(BAIXO); break;
case ESQUERDA: if(esquerda) jogada(ESQUERDA); break;
case DIREITA: if(direita) jogada(DIREITA); break;
}
}
}
}
//MOVE A PE�A (OU N�O)
int mover(int x, int y, char sentido[6])
{
if (strcasecmp(sentido, "dir")== 0)
{
if ((y+1)>9)
msg(1);
else
{
confeito = tab[x][y+1];
tab[x][y+1] = tab[x][y];
tab[x][y] = confeito;
jogada(x, y+1, sentido);
gameover();
}
}
else if (strcasecmp(sentido, "esq")== 0)
{
if (y-1<1)
msg(1);
else
{
confeito = tab[x][y-1];
tab[x][y-1] = tab[x][y];
tab[x][y] = confeito;
jogada(x,y-1, sentido);
gameover();
}
}
else if (strcasecmp(sentido, "cima")== 0)
{
if (x-1<1)
msg(1);
else
{
confeito = tab[x-1][y];
tab[x-1][y] = tab[x][y];
tab[x][y] = confeito;
jogada(x-1, y, sentido);
gameover();
}
}
else if (strcasecmp(sentido, "baixo")== 0)
{
if (x+1>9)
msg(1);
else
{
confeito = tab[x+1][y];
tab[x+1][y] = tab[x][y];
tab[x][y] = confeito;
jogada(x+1, y, sentido);
gameover();
}
}
else
msg(1);
return 0;
}