code. compile. run. debug. share.
#include <stdio.h>
#include <stdbool.h>
#include <ctype.h>
#include <string.h>
#include "jogadasvalidas.h"
#include "jogo.h"
/*In the source code on Github, this file is equivalent to jogo.c*/
/*Note: The source code is entirely written in Portuguese now.*/
void limpezaBuffer(){
int ch;
while ((ch = getchar()) != '\n' && ch != EOF);
}
static const char TABULEIRO_INICIAL[8][8] = {
{'t', 'c', 'b', 'q', 'k', 'b', 'c', 't'},
{'p', 'p', 'p', 'p', 'p', 'p', 'p', 'p'},
{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
{'P', 'P', 'P', 'P', 'P', 'P', 'P', 'P'},
{'T', 'C', 'B', 'Q', 'K', 'B', 'C', 'T'}
};
static char tabuleiro[8][8];
static int jogadorDaVez = 0; // 0 para o Jogador 1 (maiúsculas), 1 para o Jogador 2 (minúsculas)
static int movimentosSemCapturaouPiao = 0;
typedef struct {
char nome[20];
int pontos;
} Jogador;
static Jogador jogadores[2];
static int movimentosFeitos = 0;
static bool ganhou = false;
static bool SalvarJogo();
static bool CarregarJogo();
static void ExibirTabuleiro() {
printf("\n a b c d e f g h\n");
for (int i = 8; i >= 1; i--) {
int conversaoLinha = 8 - i;
printf("%d ", i);
for (int j = 0; j < 8; j++) {
printf("%c ", tabuleiro[conversaoLinha][j]);
}
printf("\n");
}
}
/**
* Solicita ao jogador que insira uma jogada no formato de notação algébrica.
* Parâmetros:
* linhaOrigem, colunaOrigem: ponteiros para armazenar a linha e coluna de origem.
* linhaDestino, colunaDestino: ponteiros para armazenar a linha e coluna de destino.
* O jogador pode digitar "salvar" para salvar o jogo atual.
*/
static bool obterCoordenada(int *linhaOrigem, int *colunaOrigem, int *linhaDestino, int *colunaDestino){
char input[10];
while(1){
printf("\n%s, digite a jogada em notacao algebrica (ex: e2e4): ", jogadores[jogadorDaVez].nome);
scanf("%9s", input);
limpezaBuffer();
if(strcmp(input, "salvar") == 0 || strcmp(input, "SALVAR") == 0){
if(SalvarJogo()){
printf("Jogo salvo com sucesso!\n");
} else {
printf("Erro ao salvar o jogo.\n");
}
continue;
}
if(strcmp(input, "desistir") == 0 || strcmp(input, "DESISTIR") == 0){
printf("%s desistiu do jogo. %s e o vencedor!\n", jogadores[jogadorDaVez].nome, jogadores[1 - jogadorDaVez].nome);
ganhou = true;
return false;
}
if(strlen(input) != 4){
printf("ERRO: Formato invalido. Use 4 caracteres (ex: e2e4)\n");
continue;
}
if(tolower(input[0]) < 'a' || tolower(input[0]) > 'h'){
printf("ERRO: Coluna origem invalida. Use letras de a-h.\n");
continue;
}
*colunaOrigem = tolower(input[0]) - 'a';
if(input[1] < '1' || input[1] > '8'){
printf("ERRO: Linha origem invalida. Use numeros de 1-8.\n");
continue;
}
int conversaoLinhaOrigem = input[1] - '0';
*linhaOrigem = 8 - conversaoLinhaOrigem;
if(tolower(input[2]) < 'a' || tolower(input[2]) > 'h'){
printf("ERRO: Coluna destino invalida. Use letras de a-h.\n");
continue;
}
*colunaDestino = tolower(input[2]) - 'a';
if(input[3] < '1' || input[3] > '8'){
printf("ERRO: Linha destino invalida. Use numeros de 1-8.\n");
continue;
}
int conversaoLinhaDestino = input[3] - '0';
*linhaDestino = 8 - conversaoLinhaDestino;
break;
}
return true;
}
static char PromocaoPeao(int linhaDestino, int colunaDestino, int jogadorDaVez) {
char escolha;
printf("Seu peao chegou na ultima linha! Escolha a peca para promover (Q, C, B, T): ");
while (1) {
scanf(" %c", &escolha);
if(jogadorDaVez == 0) {
escolha = toupper(escolha);
} else {
escolha = tolower(escolha);
}
if (((escolha == 'Q' || escolha == 'C' || escolha == 'B' || escolha == 'T') && jogadorDaVez == 0) ||
((escolha == 'q' || escolha == 'c' || escolha == 'b' || escolha == 't') && jogadorDaVez == 1)) {
return escolha;
} else {
printf("Escolha invalida. Por favor, escolha entre Q, C, B, T: ");
}
}
}
struct Salvamento
{
char tabuleiro[8][8];
int jogadorDaVez;
int movimentosFeitos;
int movimentosSemCapturaouPiao;
Jogador jogadores[2];
};
static bool SalvarJogo() {
FILE *arquivo = fopen("salvamento.dat", "wb");
if (arquivo == NULL) {
printf("Erro ao abrir o arquivo para salvar o jogo.\n");
return false;
}
struct Salvamento salvamento;
memcpy(salvamento.tabuleiro, tabuleiro, sizeof(tabuleiro));
salvamento.jogadorDaVez = jogadorDaVez;
salvamento.movimentosFeitos = movimentosFeitos;
salvamento.movimentosSemCapturaouPiao = movimentosSemCapturaouPiao;
memcpy(salvamento.jogadores, jogadores, sizeof(jogadores));
fwrite(&salvamento, sizeof(salvamento), 1, arquivo);
fclose(arquivo);
return true;
}
static bool CarregarJogo() {
FILE *arquivo = fopen("salvamento.dat", "rb");
if (arquivo == NULL) {
printf("Nenhum jogo salvo encontrado.\n");
return false;
}
struct Salvamento salvamento;
fread(&salvamento, sizeof(salvamento), 1, arquivo);
fclose(arquivo);
memcpy(tabuleiro, salvamento.tabuleiro, sizeof(tabuleiro));
jogadorDaVez = salvamento.jogadorDaVez;
movimentosFeitos = salvamento.movimentosFeitos;
movimentosSemCapturaouPiao = salvamento.movimentosSemCapturaouPiao;
memcpy(jogadores, salvamento.jogadores, sizeof(jogadores));
return true;
}
static bool capturaOuPiao = false;
static void atualizarPontuacao(int *pontos, char pecaCapturada){
switch(toupper(pecaCapturada)){
case 'P':
*pontos += 1; // Incrementa o ponto do jogador que capturou
capturaOuPiao = true;
break;
case 'C':
case 'B':
*pontos += 3; // Incrementa 3 pontos para cavalo ou bispo
capturaOuPiao = true;
break;
case 'T':
*pontos += 5; // Incrementa 5 pontos para torre
capturaOuPiao = true;
break;
case 'Q':
*pontos += 9; // Incrementa 9 pontos para rainha
capturaOuPiao = true;
break;
default:
break; // Nenhuma peça capturada
}
}
static void reiniciarJogo(){
memcpy(tabuleiro, TABULEIRO_INICIAL, sizeof(TABULEIRO_INICIAL));
jogadorDaVez = 0;
movimentosSemCapturaouPiao = 0;
movimentosFeitos = 0;
capturaOuPiao = false;
ganhou = false;
}
int iniciarJogo(int opcao) {
limpezaBuffer();
reiniciarJogo();
printf("--------------------------------------------\n\n");
if (opcao == 1){
for(int i = 0; i < 2; i++){
printf("Digite o nome do %d jogador: ", i + 1);
scanf("%19s", jogadores[i].nome);
jogadores[i].pontos = 0;
}
movimentosSemCapturaouPiao = 0;
movimentosFeitos = 0;
} else {
CarregarJogo();
}
while(!ganhou){
printf("\n");
ExibirTabuleiro();
printf("E a vez de %s!\n (%s)", jogadores[jogadorDaVez].nome, (jogadorDaVez == 0) ? "MAIUSCULAS" : "minusculas");
int linhaOrigem, colunaOrigem, linhaDestino, colunaDestino;
if(!obterCoordenada(&linhaOrigem, &colunaOrigem, &linhaDestino, &colunaDestino)){
break; // Sai do loop principal do jogo se o jogador desistir
}
if(tabuleiro[linhaOrigem][colunaOrigem] == ' '){
printf("Jogada invalida! Nao ha peca na posicao de origem.\n");
continue;
}
const char* resultadoJogadaValida = JogadaValida(tabuleiro, linhaOrigem, colunaOrigem, linhaDestino, colunaDestino, jogadorDaVez);
if(strcmp(resultadoJogadaValida, "OK") == 0){
movimentosFeitos++;
if(toupper(tabuleiro[linhaOrigem][colunaOrigem]) == 'P'){
capturaOuPiao = true;
}
//Verifica a captura de peças e atualiza a pontuação
atualizarPontuacao(&jogadores[jogadorDaVez].pontos, tabuleiro[linhaDestino][colunaDestino]);
if(toupper(tabuleiro[linhaDestino][colunaDestino]) == 'K'){
ganhou = true;
printf("O jogador %s ganhou o jogo!\n", jogadores[jogadorDaVez].nome);
printf("Placar final: %s: %d pontos, %s: %d pontos\n", jogadores[0].nome, jogadores[0].pontos, jogadores[1].nome, jogadores[1].pontos);
printf("Total de movimentos feitos: %d\n", movimentosFeitos);
break; // Sai do loop principal do jogo
}
if(capturaOuPiao){
movimentosSemCapturaouPiao = 0;
} else {
movimentosSemCapturaouPiao++;
}
if(movimentosSemCapturaouPiao >= 100){
printf("Empate por regra dos 50 movimentos sem captura ou movimento de peao!\n");
printf("Placar final: %s: %d pontos, %s: %d pontos\n", jogadores[0].nome, jogadores[0].pontos, jogadores[1].nome, jogadores[1].pontos);
printf("Total de movimentos feitos: %d\n", movimentosFeitos);
ganhou = true;
break; // Sai do loop principal do jogo
}
if(ganhou){
break; // Sai do loop principal do jogo se alguém ganhou
}
tabuleiro[linhaDestino][colunaDestino] = tabuleiro[linhaOrigem][colunaOrigem];
tabuleiro[linhaOrigem][colunaOrigem] = ' ';
if((tabuleiro[linhaDestino][colunaDestino] == 'p' && linhaDestino == 7) || (tabuleiro[linhaDestino][colunaDestino] == 'P' && linhaDestino == 0)){
tabuleiro[linhaDestino][colunaDestino] = PromocaoPeao(linhaDestino, colunaDestino, jogadorDaVez);
}
jogadorDaVez = 1 - jogadorDaVez; // Alterna entre 0 e 1, trocando o jogador da vez
} else {
printf("Jogada invalida! %s.\n", resultadoJogadaValida);
}
}
printf("-----------------------------------------------\n\n");
return 0;
}
#include "jogadasvalidas.h"
#include <string.h>
#include <stdbool.h>
#include <ctype.h>
/*Note: The source code is entirely written in Portuguese now.*/
bool CasaAtacada(char tabuleiro[8][8], int linha, int coluna, int oponente){
//Verificação de ataque de peões
if(oponente == 0){
if(linha + 1 < 8 && coluna - 1 >= 0 && tabuleiro[linha + 1][coluna - 1] == 'P') return true;
if(linha + 1 < 8 && coluna + 1 < 8 && tabuleiro[linha + 1][coluna + 1] == 'P') return true;
} else{
if(linha - 1 >= 0 && coluna - 1 >= 0 && tabuleiro[linha - 1][coluna - 1] == 'p') return true;
if(linha - 1 >= 0 && coluna + 1 < 8 && tabuleiro[linha - 1][coluna + 1] == 'p') return true;
}
char torre = (oponente == 0) ? 'T': 't';
char rainha = (oponente == 0) ? 'Q' : 'q';
//Verificação de ataques verticais (Torre ou rainha)
for(int i = linha + 1; i < 8; i++){// Ataque de cima
char peca = tabuleiro[i][coluna];
if(peca != ' '){
if (peca == torre || peca == rainha) return true;
break;
}
}
for(int i = linha - 1; i >= 0; i--){// Ataque de baixo
char peca = tabuleiro[i][coluna];
if(peca != ' '){
if (peca == torre || peca == rainha) return true;
break;
}
}
//Verificação de ataques horizontais (Torre ou rainha)
for(int i = coluna + 1; i < 8; i++){// Ataque da direita
char peca = tabuleiro[linha][i];
if(peca != ' '){
if (peca == torre || peca == rainha) return true;
break;
}
}
for(int i = coluna - 1; i >= 0; i--){// Ataque da esquerda
char peca = tabuleiro[linha][i];
if(peca != ' '){
if (peca == torre || peca == rainha) return true;
break;
}
}
//Verifica se há ataque de cavalo
int movimentosCavalo[8][2] = {
{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2},
{1, -2}, {1, 2}, {2, -1}, {2, 1}
};
char cavalo = (oponente == 0) ? 'C' : 'c';
/*Verifica as 8 possíveis posições de um cavalo,
com base em movimentosCavalo[8][2]*/
for(int i = 0; i < 8; i++){
int linhaNova = linha + movimentosCavalo[i][0];
int colunaNova = coluna + movimentosCavalo[i][1];
if(linhaNova >= 0 && linhaNova < 8 && colunaNova >= 0 && colunaNova < 8){
if (tabuleiro[linhaNova][colunaNova] == cavalo){
return true;
}
}
}
//Verificação de ataques na diagonal (Bispo ou rainha)
char bispo = (oponente == 0) ? 'B' : 'b';
for(int i = 1; linha + i < 8 && coluna + i < 8; i++){//Para ver ataque a sudeste
char peca = tabuleiro[linha + i][coluna + i];
if(peca != ' '){
if(peca == bispo || peca == rainha) return true;
break;
}
}
for(int i = 1; linha - i >= 0 && coluna + i < 8; i++){//Para ver ataque a nordeste
char peca = tabuleiro[linha - i][coluna + i];
if(peca != ' '){
if(peca == bispo || peca == rainha) return true;
break;
}
}
for(int i = 1; linha + i < 8 && coluna - i >= 0; i++){//Para ver movimento para sudoeste
char peca = tabuleiro[linha + i][coluna - i];
if(peca != ' '){
if(peca == bispo || peca == rainha) return true;
break;
}
}
for(int i = 1; linha - i >= 0 && coluna - i >= 0; i++){//Para ver movimento para noroeste
char peca = tabuleiro[linha - i][coluna - i];
if(peca != ' '){
if(peca == bispo || peca == rainha) return true;
break;
}
}
//Verifica ataques do rei inimigo
char reiInimigo = (oponente == 0) ? 'K' : 'k';
int movimentosRei[8][2] = {
{-1, -1}, {-1, 0}, {-1, 1}, // Noroeste, Norte, Nordeste
{0, -1}, {0, 1}, // Oeste, Leste
{1, -1}, {1, 0}, {1, 1} // Sudoeste, Sul, Sudeste
};
/*Verifica as 8 possíveis posições de um rei,
com base em movimentosRei[8][2]*/
for(int i = 0; i < 8; i++){
int linhaNova = linha + movimentosRei[i][0];
int colunaNova = coluna + movimentosRei[i][1];
if(linhaNova >= 0 && linhaNova < 8 && colunaNova >= 0 && colunaNova < 8){
if (tabuleiro[linhaNova][colunaNova] == reiInimigo){
return true;
}
}
}
//Caso nenhuma das condições acima se aplicarem...
return false;
}
/*A função retorna alguns valores de acordo com o seu resultado:
- "OK" para jogadas válidas;
- Outros textos para jogadas inválidas, para mostrar ao usuário o erro dele
(Por exemplo, "Peça do mesmo jogador" quando ocorre tentativa de capturar uma peça do mesmo jogador)
*/
const char* JogadaValida(char tabuleiro[8][8], int linhaOrigem, int colunaOrigem, int linhaDestino, int colunaDestino, int jogadorDaVez) {
char peca = tabuleiro[linhaOrigem][colunaOrigem];
if(linhaOrigem == linhaDestino && colunaOrigem == colunaDestino) {
return "Movimento para a mesma posicao"; // Movimento para a mesma posição
} else if((jogadorDaVez == 0 && isupper(tabuleiro[linhaDestino][colunaDestino])) || ((jogadorDaVez == 1 && islower(tabuleiro[linhaDestino][colunaDestino])))) {
return "Peca do mesmo jogador"; // Tentativa de capturar uma peça do mesmo jogador
} else if ((jogadorDaVez == 0 && islower(tabuleiro[linhaOrigem][colunaOrigem])) || (jogadorDaVez == 1 && isupper(tabuleiro[linhaOrigem][colunaOrigem]))) {
return "Tentativa de mover peca do oponente"; // Tentativa de mover a peça do oponente
} else {
switch (toupper(peca))
{
case 'P':
/* Código para movimento do peão */
if(jogadorDaVez == 0) {
if ((linhaDestino == linhaOrigem - 1 && colunaDestino == colunaOrigem - 1 && tabuleiro[linhaDestino][colunaDestino] != ' ')) {
return "OK"; // Movimento diagonal para capturar
} else if ((linhaDestino == linhaOrigem - 1 && colunaDestino == colunaOrigem + 1 && tabuleiro[linhaDestino][colunaDestino] != ' ')) {
return "OK"; // Movimento diagonal para capturar
} else if (linhaDestino == linhaOrigem - 1 && colunaDestino == colunaOrigem && tabuleiro[linhaDestino][colunaDestino] == ' '){
return "OK"; // Movimento para frente
} else if (linhaOrigem == 6 && linhaDestino == linhaOrigem - 2 && colunaDestino == colunaOrigem && tabuleiro[linhaDestino - 1][colunaDestino] == ' ' && tabuleiro[linhaDestino][colunaDestino] == ' ') {
return "OK"; // Movimento de início para frente (duas casas)
} else {
return "Movimento invalido para o peao"; // Movimento inválido para o peão
}
} else {
if ((linhaDestino == linhaOrigem + 1 && colunaDestino == colunaOrigem - 1 && tabuleiro[linhaDestino][colunaDestino] != ' ')) {
return "OK"; // Movimento diagonal para capturar
} else if ((linhaDestino == linhaOrigem + 1 && colunaDestino == colunaOrigem + 1 && tabuleiro[linhaDestino][colunaDestino] != ' ')) {
return "OK"; // Movimento diagonal para capturar
} else if (linhaDestino == linhaOrigem + 1 && colunaDestino == colunaOrigem && tabuleiro[linhaDestino][colunaDestino] == ' '){
return "OK"; // Movimento para frente
} else if (linhaOrigem == 1 && linhaDestino == linhaOrigem + 2 && colunaDestino == colunaOrigem && tabuleiro[linhaDestino - 1][colunaDestino] == ' ' && tabuleiro[linhaDestino][colunaDestino] == ' ') {
return "OK"; // Movimento de início para frente (duas casas)
} else {
return "Movimento invalido para o peao"; // Movimento inválido para o peão
}
}
break;
case 'T':
/* Código para movimento da torre */
for(int i = 1; i + linhaOrigem < 8; i++){ //verifica se é movimento para baixo
if(linhaDestino == linhaOrigem + i && colunaDestino == colunaOrigem){
return "OK";
} else if (tabuleiro[linhaOrigem + i][colunaOrigem] != ' '){
break;
}
}
for(int i = -1; i + linhaOrigem >= 0; i--){ //verifica se é movimento para cima
if(linhaDestino == linhaOrigem + i && colunaDestino == colunaOrigem){
return "OK";
} else if (tabuleiro[linhaOrigem + i][colunaOrigem] != ' '){
break;
}
}
for(int i = 1; i + colunaOrigem < 8; i++){ //verifica se é movimento para direita
if(colunaDestino == colunaOrigem + i && linhaDestino == linhaOrigem){
return "OK";
} else if (tabuleiro[linhaOrigem][colunaOrigem + i] != ' '){
break;
}
}
for(int i = -1; i + colunaOrigem >= 0; i--){ //verifica se é movimento para esquerda
if(colunaDestino == colunaOrigem + i && linhaDestino == linhaOrigem){
return "OK";
} else if (tabuleiro[linhaOrigem][colunaOrigem + i] != ' '){
break;
}
}
return "Movimento invalido para a torre";
case 'C':
/* Código para movimento do cavalo */
if(linhaDestino == linhaOrigem + 2 && colunaDestino == colunaOrigem - 1){
return "OK"; // Movimento em "L" em pé para sudoeste
} else if (linhaDestino == linhaOrigem - 2 && colunaDestino == colunaOrigem - 1){
return "OK"; // Movimento em "L" em pé para noroeste
} else if(linhaDestino == linhaOrigem + 2 && colunaDestino == colunaOrigem + 1){
return "OK"; // Movimento em "L" em pé para sudeste
} else if (linhaDestino == linhaOrigem - 2 && colunaDestino == colunaOrigem + 1){
return "OK"; // Movimento em "L" em pé para nordeste
} else if(linhaDestino == linhaOrigem + 1 && colunaDestino == colunaOrigem - 2){
return "OK"; // Movimento em "L" deitado para sudoeste
} else if (linhaDestino == linhaOrigem - 1 && colunaDestino == colunaOrigem - 2){
return "OK"; // Movimento em "L" deitado para noroeste
} else if(linhaDestino == linhaOrigem + 1 && colunaDestino == colunaOrigem + 2){
return "OK"; // Movimento em "L" deitado para sudeste
} else if (linhaDestino == linhaOrigem - 1 && colunaDestino == colunaOrigem + 2){
return "OK"; // Movimento em "L" deitado para nordeste
} else {
return "Movimento invalido para o cavalo";
}
break;
case 'B':
/* Código para movimento do bispo */
for(int i = 1; linhaOrigem + i < 8 && colunaOrigem + i < 8; i++){//Para ver movimento para sudeste
if(linhaDestino == linhaOrigem + i && colunaDestino == colunaOrigem + i){
return "OK";
} else if (tabuleiro[linhaOrigem + i][colunaOrigem + i] != ' '){
break;
}
}
for(int i = 1; linhaOrigem - i >= 0 && colunaOrigem + i < 8; i++){//Para ver movimento para nordeste
if(linhaDestino == linhaOrigem - i && colunaDestino == colunaOrigem + i){
return "OK";
} else if (tabuleiro[linhaOrigem - i][colunaOrigem + i] != ' '){
break;
}
}
for(int i = 1; linhaOrigem + i < 8 && colunaOrigem - i >= 0; i++){//Para ver movimento para sudoeste
if(linhaDestino == linhaOrigem + i && colunaDestino == colunaOrigem - i){
return "OK";
} else if (tabuleiro[linhaOrigem + i][colunaOrigem - i] != ' '){
break;
}
}
for(int i = 1; linhaOrigem - i >= 0 && colunaOrigem - i >= 0; i++){//Para ver movimento para noroeste
if(linhaDestino == linhaOrigem - i && colunaDestino == colunaOrigem - i){
return "OK";
} else if (tabuleiro[linhaOrigem - i][colunaOrigem - i] != ' '){
break;
}
}
return "Movimento invalido para o bispo";
case 'Q':
/* Código para movimento da rainha */
//Junção dos movimentos da torre e do bispo
// Movimento da torre
for(int i = 1; i + linhaOrigem < 8; i++){ //verifica se é moviemento para baixo
if(linhaDestino == linhaOrigem + i && colunaDestino == colunaOrigem){
return "OK";
} else if (tabuleiro[linhaOrigem + i][colunaOrigem] != ' '){
break;
}
}
for(int i = -1; i + linhaOrigem >= 0; i--){ //verifica se é movimento para cima
if(linhaDestino == linhaOrigem + i && colunaDestino == colunaOrigem){
return "OK";
} else if (tabuleiro[linhaOrigem + i][colunaOrigem] != ' '){
break;
}
}
for(int i = 1; i + colunaOrigem < 8; i++){ //verifica se é movimento para direita
if(colunaDestino == colunaOrigem + i && linhaDestino == linhaOrigem){
return "OK";
} else if (tabuleiro[linhaOrigem][colunaOrigem + i] != ' '){
break;
}
}
for(int i = -1; i + colunaOrigem >= 0; i--){ //verifica se é movimento para esquerda
if(colunaDestino == colunaOrigem + i && linhaDestino == linhaOrigem){
return "OK";
} else if (tabuleiro[linhaOrigem][colunaOrigem + i] != ' '){
break;
}
}
// Movimento do bispo
for(int i = 1; linhaOrigem + i < 8 && colunaOrigem + i < 8; i++){//Para ver movimento para sudeste
if(linhaDestino == linhaOrigem + i && colunaDestino == colunaOrigem + i){
return "OK";
} else if (tabuleiro[linhaOrigem + i][colunaOrigem + i] != ' '){
break;
}
}
for(int i = 1; linhaOrigem - i >= 0 && colunaOrigem + i < 8; i++){//Para ver movimento para nordeste
if(linhaDestino == linhaOrigem - i && colunaDestino == colunaOrigem + i){
return "OK";
} else if (tabuleiro[linhaOrigem - i][colunaOrigem + i] != ' '){
break;
}
}
for(int i = 1; linhaOrigem + i < 8 && colunaOrigem - i >= 0; i++){//Para ver movimento para sudoeste
if(linhaDestino == linhaOrigem + i && colunaDestino == colunaOrigem - i){
return "OK";
} else if (tabuleiro[linhaOrigem + i][colunaOrigem - i] != ' '){
break;
}
}
for(int i = 1; linhaOrigem - i >= 0 && colunaOrigem - i >= 0; i++){//Para ver movimento para noroeste
if(linhaDestino == linhaOrigem - i && colunaDestino == colunaOrigem - i){
return "OK";
} else if (tabuleiro[linhaOrigem - i][colunaOrigem - i] != ' '){
break;
}
}
return "Movimento invalido para a rainha";
case 'K':
/* Código para movimento do rei */
if((linhaDestino == linhaOrigem + 1 || linhaDestino == linhaOrigem - 1 || linhaDestino == linhaOrigem) &&
(colunaDestino == colunaOrigem + 1 || colunaDestino == colunaOrigem - 1 || colunaDestino == colunaOrigem)) {
if(CasaAtacada(tabuleiro, linhaDestino, colunaDestino, 1 - jogadorDaVez)){
return "Casa de destino em xeque"; // Casa de destino está sob ataque
} else{
char tabuleiroTemp[8][8];
memcpy(tabuleiroTemp, tabuleiro, sizeof(char) * 8 * 8);
tabuleiroTemp[linhaDestino][colunaDestino] = tabuleiroTemp[linhaOrigem][colunaOrigem];
tabuleiroTemp[linhaOrigem][colunaOrigem] = ' ';
if(CasaAtacada(tabuleiroTemp, linhaDestino, colunaDestino, 1 - jogadorDaVez)){
return "Movimento colocaria rei em xeque"; // Movimento colocaria o rei em xeque
} else {
return "OK"; // Movimento válido
}
}
} else {
return "Movimento invalido para o rei"; // Movimento inválido para o rei
}
break;
default: //Se não for nenhuma peça válida
return "Peça invalida";
}
}
}
#ifndef JOGADASVALIDAS_H
#define JOGADASVALIDAS_H
const char* JogadaValida(char tabuleiro[8][8], int linhaOrigem, int colunaOrigem, int linhaDestino, int colunaDestino, int jogadorDaVez);
#endif // JOGADASVALIDAS_H
#include <stdio.h>
#include "jogo.h"
/*Note: The source code is entirely written in Portuguese now.*/
int main(){
int opcao;
printf("==============================================\n");
printf(" XADREZ EM C\n");
printf("==============================================\n\n");
while (1){
printf("1. Nova Partida\n");
printf("2. Carregar Partida Salva\n");
printf("3. Ajuda\n");
printf("4. Sair\n\n");
printf("Escolha uma opcao: ");
if(scanf("%d", &opcao) != 1){
printf("Entrada invalida! Por favor, insira um numero entre 1 e 4: ");
int c;
while((c = getchar()) != '\n' && c != EOF); // Limpa o buffer de entrada
continue;
}
if(opcao < 1 || opcao > 4){
printf("Opcao invalida!\n");
} else if(opcao == 4){
printf("Fechando o programa...\n");
return 0;
} else if (opcao == 3)
{
printf("\nAJUDA:\n");
printf("Este e um jogo de xadrez para dois jogadores. Cada jogador controla um conjunto de pecas, uma em MAIUSCULAS e a outra em minusculas.\n");
printf("O objetivo do jogo e capturar o rei do oponente. As pecas se movem de acordo com as regras tradicionais do xadrez.\n");
printf("Para fazer uma jogada, voce precisara inserir as coordenadas de origem e destino no formato de notacao algebrica (ex: e2e4).\n");
printf("Voce tambem pode salvar o jogo a qualquer momento digitando 'salvar' quando solicitado a inserir uma jogada.\n");
printf("Digite 'desistir' para abandonar o jogo atual e conceder a vitoria ao oponente.\n");
printf("Boa sorte e divirta-se!\n\n");
} else{
iniciarJogo(opcao);
}
}
return 0;
}
#ifndef JOGO_H
#define JOGO_H
int iniciarJogo(int opcao);
#endif // JOGO_H
Compiling Program...
Standard Input:
Interactive Console
Text
Program is not being debugged. Click "Debug" button to start program in debug mode.
| # | Function | File:Line |
|---|
| Variable | Value |
|---|
| Register | Value |
|---|
| Expression | Value |
|---|
| # | Description |
|---|