Bien que le langage C soit le langage le plus basique, il a des fonctions extrêmement puissantes. Vous pouvez écrire beaucoup de choses intéressantes en langage C. Aujourd'hui, je vais vous présenter un jeu d'échecs à trois niveaux. Ce jeu n'a pas ajouté d'algorithmes complexes pour s'améliorer l'ordinateur. Seules les choses les plus élémentaires sont réalisées. Le tout est fait avec des tableaux, mais je continuerai à m'améliorer plus tard.
1. Menu de configuration et interface d'options
Parce que c'est le début du jeu, les paramètres du menu sont relativement simples, juste 1 et 0, choisissez 1 pour jouer au jeu, choisissez 0 pour quitter le jeu
void menu()
{
printf("****************************************\n");
printf("*********1.play 0.return **********\n");
printf("****************************************\n");
//用户输入并执行
}
void test()
{
int x = 0;
printf("请输入想要进行的操作：");
do{
menu();
scanf("%d", &x);
printf("\n");
switch (x)
{
case 1:
game();
break;
case 0:
printf("退出游戏\n");
break;
default:
printf("请重新输入\n");
break;
}
} while (x);
}
L'exécution de l'option est terminée dans l'instruction switch. Case1 exécutera la fonction de jeu, case0 se fermera et les autres entrées seront réintroduites. La raison de l'utilisation de la boucle do-while est que le jeu doit être joué à au moins une fois, ce qui convient à la boucle do-while Dans la scène d'utilisation, la condition de jugement ne sautera pas de la boucle à l'exception de 0, alors entrez comme condition de boucle de jugement. Tant que vous n'entrez pas 0, le jeu continuera.
2. Interface de jeu
(1) Réglez l'échiquier
Réglez l'échiquier sur l'interface comme indiqué sur la figure, et il peut être complété par une boucle for.
void InitBoard(char board[ROW][COL], int row, int col)
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
board[i][j] = ' ';
}
}
}
void DisplayBoard(char board[ROW][COL], int row, int col)
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf(" %c ", board[i][j]);//打印一行数据
if (j < col - 1)
{
printf("|");
}
}
printf("\n");
//打印分割行
if (i < row - 1)
{
for (j = 0; j < col; j++)
{
printf("---");
if (j < col - 1)
{
printf("|");
}
}
printf("\n");
}
}
}
Afin de conserver l'interface en damier comme une interface vide au début, l'emplacement où le tableau est stocké est d'abord initialisé à un espace, de sorte que l'objectivité de l'interface puisse être garantie sans affecter les modifications ultérieures.
(2) Les joueurs jouent aux échecs
À ce stade de base, le joueur choisit les échecs en entrant les coordonnées de l'échiquier. Par conséquent, faites attention aux problèmes suivants lors de l'écriture du code:
1. Si les coordonnées d'entrée du joueur sont au-delà de la position du plateau, vous devriez être invité et resélectionner.
2. Si les coordonnées saisies par le joueur ont déjà joué des pièces d'échecs, il est impossible de les écraser avec de nouvelles valeurs, le joueur doit donc être rappelé et sélectionné à nouveau.
3. Parce que les joueurs ne sont pas tous des programmeurs, tout le monde ne sait pas que le début du tableau commence à 0, donc le joueur doit entrer une valeur normale, et nous devons réduire les coordonnées d'entrée de un lors de l'écriture du programme. ,
Selon les trois problèmes ci-dessus auxquels il faut prêter attention, tout le processus de saisie des coordonnées par le joueur doit être effectué en boucle. Si l'entrée n'est pas la valeur correcte, saisissez-la de nouveau, et si l'entrée est correcte, utilisez la pause pour sauter. Le code est implémenté comme suit:
void PlayerMove(char board[ROW][COL], int row, int col)
{
int x = 0;
int y = 0;
while (1)
{
printf("玩家下棋->\n");
scanf("%d %d", &x, &y);
if (x >= 1 && x <= ROW && y >= 1 && y <= COL)
{
if (board[x - 1][y - 1] == ' ')
{
board[x - 1][y - 1] = '*';
break;
}
else
{
printf("坐标被占用，请重新输入\n");
}
}
else
{
printf("输入超出棋盘，请重新输入\n");
}
}
}
(3) Ordinateur jouant aux échecs
La façon dont l'ordinateur joue aux échecs peut être changeante, et les différents algorithmes peuvent modifier continuellement la façon dont l'ordinateur joue aux échecs, ce qui peut faire en sorte que l'intelligence de l'ordinateur continue de s'améliorer. Mais au stade initial, je ne connais pas assez certains algorithmes, donc j'utilise les nombres aléatoires les plus basiques pour laisser l'ordinateur jouer aux échecs, et plus tard je chercherai plus d'informations pour rendre la structure plus parfaite.
Étant donné que les mouvements de l'ordinateur sont prescrits par des nombres aléatoires, il n'est pas nécessaire de considérer la situation dans laquelle les coordonnées sont hors limites. Il vous suffit de déterminer si les coordonnées sont occupées ou non. La même méthode de cycle est utilisée pour effectuer chaque entrée d'ordinateur , et l'entrée est correcte.
Le code est implémenté comme suit:
void ComputerMove(char board[ROW][COL], int row, int col)
{
int x = 0;
int y = 0;
printf("电脑下棋->\n");
while (1)
{
x = rand() % row;
y = rand() % col;
if (board[x][y] == ' ')
{
board[x][y] = '#';
break;
}
}
}
(3) Juger le résultat du match
Puisqu'il s'agit d'une partie d'échecs, il doit y avoir un résultat, qu'il s'agisse d'une perte, d'une victoire ou d'une égalité. Par conséquent, après chaque entrée du joueur et de l'ordinateur, nous devons porter un jugement sur l'ensemble du plateau. Si un parti gagne ou tire, il termine le jeu et commence la sélection suivante. Les conditions de jugement que j'utilise sont de retourner "*", de retourner "#", de retourner Q et de retourner C pour représenter différentes significations. Renvoyer "*" signifie que le joueur gagne. Le retour "#" signifie que l'ordinateur gagne, le retour Q signifie une égalité, le retour C signifie que le jeu continue.
Code:
char IsWin(char board[ROW][COL], int row, int col)
{
int q = 0;
int i = 0;
int j = 0;
//首先判断行是否成一行
for (i = 0; i < row; i++)
{
if (board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][0] != ' ')
{
return board[i][0];
}
}
for (i = 0; i < col; i++)
{
if (board[0][i] == board[1][i] && board[1][i] == board[2][i] && board[1][i] != ' ')
{
return board[1][i];
}
}
if (board[1][1] == board[2][2] && board[2][2] == board[3][3] && board[1][1] != ' ')
return board[1][1];
if (board[2][0] == board[1][1] && board[1][1] == board[0][2] && board[1][1] != ' ')
return board[1][1];
q = IsFull(board, ROW, COL);
if (q == 1)
return 'Q';
return 'C';
}
Juger qui gagne est basé sur le fait qu'il y a une ligne, une colonne ou deux diagonales connectées. Comme il s'agit d'un algorithme élémentaire, le jugement de gagner ou de perdre n'est jugé que par si, il ne peut donc être limité qu'à trois enfants. Échecs. Il y a un endroit astucieux ici, c'est-à-dire retourner "*" et "#" qui est directement utilisé pour se connecter à une ligne et retourner n'importe quel élément de coordonnée sur cette ligne, de sorte que vous n'ayez pas besoin de juger qui a gagné, puis de revenir au logo correspondant.
Le jugement d'une égalité est de traverser tout le plateau.Si personne ne gagne et que le plateau est plein, c'est une égalité.
int IsFull(char board[ROW][COL], int row, int col)
{
int i = 0;
int j = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
if (board[i][j] == ' ')
return 0;
}
}
return 1;
}
Effet de code
Le joueur gagne, l'
ordinateur gagne. L' implémentation générale du code de l'
égalité
est toujours très réussie, mais il y a encore de nombreux domaines qui peuvent être améliorés. Par exemple, certains algorithmes peuvent être ajoutés à l'ordinateur afin que l'ordinateur puisse choisir la meilleure position par exemple, l'entrée est maintenant L'entrée basée sur les coordonnées peut être améliorée pour utiliser la souris pour cliquer pour jouer aux échecs, etc.
Je chercherai des informations plus tard pour optimiser la situation globale et j'espère que tout le monde pourra me donner plus d'encouragement et de soutien.