C语言实现三子棋游戏

最新推荐文章于 2023-06-11 17:36:11 发布
最新推荐文章于 2023-06-11 17:36:11 发布
阅读量2.4k 收藏 1
点赞数
文章标签： c语言 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_58249665/article/details/121192267
版权

  今天来写一个简单的三子棋游戏，与上次写的猜数字游戏一样是一个涉及代码较多的一个程序，接下来展开细致的剖析。

  首先先规划一下，游戏的代码比较多，我们不可能把所有代码写在.c后缀的main函数里面，所以我们一共会拆开分为三大部分，test.c里面放的是游戏的测试逻辑，game.c里面放的是游戏的实现逻辑，最后再把游戏实现函数的声明放入game.h，这样调用的话就分工明确，代码可读性也变得很高。文件创建就如下图所示：

   当创建好文件后，首先在test.c里面写一个调用test函数的流程，接着就是打印菜单提示玩家选择进行游戏，代码如下图所示：

#define _CRT_SECURE_NO_WARNINGS 1

#include<stdio.h>

void menu()
{
    printf("**************************\n");
    printf("********  1.play  ********\n");
    printf("********  0.exit  ********\n");
    printf("**************************\n");
}



void test()
{
    int input = 0;
    do
    {
      menu();
      printf("请输入:>");
      scanf("%d", &input);
    
      switch(input)
      {
      case 1: 
          printf("三子棋\n");
          break;
      case 0:
          printf("退出游戏\n");
          break; 
      default:
          printf("选择错误\n");
          break;
      }
     }
    while(input);
   }

int main()
{
   test();
   return 0;
}

   这里需要注意的就是，我们要设计好程序判断用户是否输入的是数字0或者1，然后用上swtich语句提示用户该怎么选择，该怎么输入，大概的游戏菜单就是这样设计。

  如上图中case1中的打印三子棋只是演示给大家看，真正我们要实现这个三子棋游戏就要开始写函数了，接下来我们就要开始写一个game函数来实现，所以对用case1那个地方要把printf("三子棋\n")改成game()。现在先呈现给大家看一看这个游戏最终运行的效果是怎么样的，然后再从这个结果中来剖析告诉大家三子棋这个游戏是怎么一步步实现的，再结合起来写game函数，效果如下图所示：

  这里可以看到，玩家选择玩游戏之后，屏幕上先呈现出的是一个空的棋盘，然后玩家填入坐标选择棋子所下的位置，电脑也会随之进行游戏，这就是游戏整体的效果。当我们程序员看到这个界面的时候要有一定的思考，看到图中玩家一共下了3步棋，其中都依次给记录下来了，不管是玩家还是电脑的数据都给存起来下一次打印。

  然后最重要的一点就是，我们可以从图中看到，这就是一个3行3列的一个棋盘，共9个位置，9个位置的数据都要存起来，这不就跟我们的二维数组非常的相似吗  ！ 而我们这里可以看到里面放的是字符的二维数组，所以现在整体思路就有了。

  现在先开始规划棋盘，我们知道这是一个3乘3的棋盘，所以这里先假设一个3乘3的数组char board[3][3]棋盘，而且我们可以看到棋盘每一格里面的符号左右都有一个空格，还有一些竖杠和斜杠，这些都是为了修饰棋盘把棋盘设计更好看一些，更有空间感。

  我们期望一开始的棋盘全部都是空格，这样游戏才能进行下去，程序设计如下：

void game()
{
//数据存储到一个字符的二维数组中，玩家下棋是'*',电脑下棋是'#'
    char board[3][3] = {0};//数组的内容应该全部是空格
    InitBoard(board, 3, 3);//初始化棋盘
}

    但是这样设计有个弊端，大家想象一下，接下来要写的代码要对数组的行列进行变化操作，如果这里每次都写上对应的行列数，那么假设某一天这个3乘3的数组不够用了，要一个5乘5的棋盘，那么程序中的3行3列这些数字全部都要跟着修改，非常的麻烦，为了减少这种不必要的操作，我们在未来遇到这种需要频繁改变的变量，可以在之前拆分开的头文件里面先定义一个行和列：

    那么这样的话，大家还要记得在前面包含以下头文件，程序员自己写的头文件使用双引号，我们这里对应的就用#include"game.h"。那么以后要改行列数的话，所有涉及到的地方，都会随之改变，非常方便，最后代码改善成如下图：

#include<stdio.h>
#include"game.h"
void menu()
{
    printf("**************************\n");
    printf("********  1.play  ********\n");
    printf("********  0.exit  ********\n");
    printf("**************************\n");
}


void game()
{
//数据存储到一个字符的二维数组中，玩家下棋是'*',电脑下棋是'#'
    char board[ROW][COL] = {0};//数组的内容应该全部是空格
    InitBoard(board, ROW, COL);//初始化棋盘
}

  接下来为了实现InitBoard这个初始化函数，这是一个游戏模块的代码，所以我们还要在头文件里面声明一下：

  把参数都传进去函数里头后，我们就要把函数放到game.c里面开始实现函数了，我们知道二维数组要用两层for循环来实现，所以代码编写如下：

#define _CRT_SECURE_NO_WARNINGS 1\

#include"game.h"

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] = ' ';
        }
    }
}

  把第i行第j列的元素都初始化成空格，写到这一步的时候就可以打印棋盘了，这里给到一个DisplayBoard函数，也要在头文件声明一下，进行传参，再在game.c中实现。

   然后进行这个DisplayBoard的实现，有的同学可能就上来直接把棋盘的结果理解成，一个空格加%c打印字符再加一个空格，就会把代码写成如下图：

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]);
        }
            printf("\n");
    }
}

  这样我们先来测试一下这段代码有什么弊端，运行如下图所示：

   我们可以看到棋盘确实打印出来了，但全部是空格，没有我们看到的修饰分界线，因此为了分割出行和列，让玩家清楚的知道下棋要下载哪个坐标，我们要这样设计代码，可以把数据和分割行看为一组，如果最后一行假设他也有分割行，那就是一共3组，首先打印数据，再打印分割行，设计如下：

void DisplayBoard(char board[ROW][COL], int row, int col)
{
    int i = 0;
    int j = 0;
    for (i = 0; i < row; i++)
    {
        //数据 
        printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
        //分割行
        printf("---|---|---\n");
    }
}

   然后运行如下：

  我们可以看到在打印第三组数据的时候，最后的分割行打印多了，因此我们在打印分割行前加上一个条件：if(i < row-1)即可，再次运行如下：

   棋盘就很完美的打印出来了，但是这一段代码是可以优化的，因为，假设有一天要把棋盘打印成10乘10的棋盘，那么我们把头文件的ROW和COL各改为10，效果会像下面这样只有10行3列：

   原因是我们把代码写死了，不便于代码扩展，因此我们应该把代码写成如下：

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");
    }
}

  效果如下图，10乘10棋盘格：

   接下来就是设计下棋的程序了，我们知道每次下完棋都会打印记录电脑或者玩家的落子后的棋盘，因此我们开设Player_move和Computer_move两个函数，在这里我们先写玩家下棋的函数，设置一个while循环，玩家下完棋到电脑下，电脑下完再到玩家下，此处同样要在头文件先声明函数：

void Player_move(char board[ROW][COL], int row, int col);//玩家下棋

  接下来先定义这个函数，这里要注意的就是，要告诉玩家输入的坐标是要在3行3列以内的，所以这里我们要设定一定的判断条件，让玩家输入合法的坐标，第二点就是，要加入一个判断棋盘某一格位置是否给占用的条件，如果给占用了，此处就不是空格，玩家不可下在此处，这里有很多同学可能会写成 if(board[x][y] == ' ')，但是这样是不对的。对于玩家来说，行和列从1开始的，但是我们程序员是知道对于数组来说，行和列是从0开始的，所以这里设计输入的坐标要优化成[x-1][y-1]才行，代码设计如下：

void Player_move(char board[ROW][COL], int row, int col)//玩家下棋
{
    printf("玩家下棋:>\n");
    int x = 0;
    int y = 0;
    
    while(1)
    {
        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");
             }
    }
}

  设置好这个后，程序运行，效果如下图所示：

   完成玩家下棋的代码后接下来就是电脑下棋了，整体思路就是电脑下棋的随即下的，看到棋盘哪里是空格就可以往哪里下，现在就开始定义Computer_move函数，同样是先声明：

void Computer_move(char board[ROW][COL], int row, int col);//电脑下棋

  现在再开始定义，电脑下棋也是同样的生成横纵坐标，所以我们也是开设一个x和y变量然后初始化，我们知道rand函数是可以生成随机数的，但是我们这里需要电脑下的坐标范围要在0~2之间，所以我们让rand生成的随机数都模上对应的行和列，注意这里在使用rand函数之前要在主函数内调用srand，用srand来设置随机数的生成器，time函数的返回值作为我们的时间戳即可（具体相关知识可以参考我之前写的文章《浅谈用C语言实现猜数字游戏》），并在头文件加上生成随机数相关的头文件#include<time.h>和#include<stdlib.h>。

  这里对应的坐标合法性就已经不用再判断了，生成随机数的范围一定是0~2了，不会越界，唯一要判断的就是电脑下的坐标是否给占用了。程序设计如下：

void Computer_move(char board[ROW][COL], int row, int col)//电脑下棋
{
    int x = 0;
    int y = 0;
    printf("电脑下棋:>\n");
  while(1)
  {
      x = rand() % ROW;//0~2
      y = rand() % COL;//0~2
      if(board[x][y] == ' ')
      {
         board[x][y] = '#';
         break;
      } 

  }
}

  此时运行程序，如下图所示：

   可以明确的看到，电脑在执行和玩家下棋的动作，现在还有最后最重要的一部分就是判断玩家或者电脑的输赢，不然游戏会无止境的进行下去，所以这里分析一共有四种情况：

  1.玩家赢得比赛

  2.电脑赢得比赛

  3.平局

  4.游戏未结束，继续进行

  这里写一个is_win函数，最终返回4种结果，我们假设返回4种字符对应这4种情况：

  1.玩家赢得比赛 --- ' * '

  2.电脑赢得比赛 --- ' # '

  3.平局 --- ' Q '

  4.游戏未结束，继续进行 --- ' C '

  所以is_win函数返回的类型是char，我们这里的思路就是，三行或者三列，或者对角线相连则为游戏赢的一方，所以这里的is_win函数最本质的还是访问board函数，对应的ROW和COL也要进行传参，主函数里面就像下图这样设计：

void game()
{
//数据存储到一个字符的二维数组中，玩家下棋是'*',电脑下棋是'#'
    char board[ROW][COL] = {0};//数组的内容应该全部是空格
    InitBoard(board, ROW, COL);//初始化棋盘
    DisplayBoard(board, ROW, COL);

    //下棋
    char ret = 0;
    while(1)
    { 
        Player_move(board, ROW, COL);
        DisplayBoard(board, ROW, COL);
        ret = is_win(board, ROW, COL);
        if(ret != 'c')
        {
            break;
        }
        Computer_move(board, ROW, COL);
        DisplayBoard(board, ROW, COL);
        ret = is_win(board, ROW, COL);
        if(ret != 'c')
        {
            break;
        } 
    }
  if(ret == '*')
  {
  printf("玩家赢\n");
  } 
  else if(ret == '#')
  {
  printf("电脑赢\n");
  }
  else
  {
      printf("平局\n");
  }
}

  共分为4种情况，然后现在欠缺的就是is_win函数了，同样也是在头文件里面写上：

char is_win(char board[ROW][COL], int row, int col);

  这里开始定义is_win函数，无非就是三行、三列或者对角线相连，我们现在先来写三行：

 int i = 0;
  for(i = 0; i < row; i++)
  {
    if(board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')//注意不能三个空格相等
      {
        return board[i][1];
      }
  }

  接下来是三列的判断：

for (i = 0; i < col; i++)
  {
      if (board[0][i] == board[1][i] && board[2][i] == board[i][2] && board[1][i] != ' ')//注意不能三个空格相等
      {
          return board[1][i];
      }
  }

  如果三行和三列都没有返回值，那么就是对角线了，接下来对角线的代码是：

if(board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')//对角线的判断,左上角到右下角相连
      {
          return board[1][1];
      }
      if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')//对角线的判断，左下角到右上角相连
      {
          return board[1][1];
      }

  那么现在差的就是平局和继续游戏两种情况了，平局的话我们这里再创建一个is_full函数，也就是判断棋盘内有没有空格，如果还有空格证明游戏还没结束。

 //判断平局(没有空格)
      if(is_full(board, row, col))
      {
          return 'Q';
      }

  这里就不用在game.h里面声明了，is_full函数只是给is_win用一下即可，所以函数在is_win之前定义就好，函数设计如下图：

int is_full(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;
}

    最后继续游戏的这种情况就直接return’C'即可，到目前为止，整个游戏的代码接口已经全部完成，我们运行代码试试：

   我们可以看到，电脑就算在我们玩家让着他的情况下，它都很难取得获胜，所以这是一个可以优化电脑操作的地方，电脑聪不聪明是取决于程序员，所以想要让这个游戏更有趣就要让电脑拥有分析棋盘的能力，但是总体的三子棋逻辑是已经实现了，实现了电脑与人的交互，因此怎么优化这个代码以后也是一个值得探讨的问题。

  这次的三子棋整体代码再分三大部分附上。

  1.game.h 关于游戏相关的函数声明、符号声明、头文件包含

#pragma once

#define ROW 3
#define COL 3
#include<stdio.h>
#include<stdlib.h>
#include<time.h>


void InitBoard(char board[ROW][COL], int row, int col);//初始化棋盘

void DisplayBoard(char board[ROW][COL], int row, int col);//打印棋盘

void player_move(char board[ROW][COL], int row, int col);//玩家下棋

void computer_move(char board[ROW][COL], int row, int col);//电脑下棋

//判断输赢的代码
//玩家赢 --- '*'
//电脑赢--- '#'
//平局--- 'Q'
//继续--- 'C'


char is_win(char board[ROW][COL], int row, int col);

   2.test.c 测试游戏的逻辑

#define _CRT_SECURE_NO_WARNINGS
#include "game.h"

void menu()
{
	printf("************************\n");
	printf("*****   1. play   ******\n");
	printf("*****   0. exit   ******\n");
	printf("************************\n");
}

void game()
{
	//数据存储到一个字符的二维数组中，玩家下棋是'*',电脑下棋是'#',
	char board[ROW][COL] = { 0 };//数组的内容应该是全部空格
	InitBoard(board, ROW, COL);//初始化棋牌
	//打印棋盘
	DisplayBoard(board, ROW, COL);
	//下棋
	char ret = 0;
	while (1)
	{
		player_move(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		ret = is_win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
		computer_move(board, ROW, COL);
		DisplayBoard(board, ROW, COL);
		ret = is_win(board, ROW, COL);
		if (ret != 'C')
		{
			break;
		}
	}
	if (ret == '*')
	{
		printf("玩家赢\n");
	}
	else if (ret == '#')
	{
		printf("电脑赢\n");
	}
	else
	{
		printf("平局\n");
	}
}


void test()
{
	int input = 0;
	srand((unsigned int)time(NULL));
	do
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			game();
			break;
		case 0:
			printf("退出游戏\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}

	} while (input);
}

int main()
{
	test();

	return 0;
}

  3.game.c 游戏相关函数的实现

#define _CRT_SECURE_NO_WARNINGS

#include"game.h"

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++)
//    {
//        //数据 
//        printf(" %c | %c | %c \n", board[i][0], board[i][1], board[i][2]);
//        //分割行
//        printf("---|---|---\n");
//    }
//}




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");
    }
}



void player_move(char board[ROW][COL], int row, int col)//玩家下棋
{
    printf("玩家下棋:>\n");
    int x = 0;
    int y = 0;
    
    while(1)
    {
        scanf_s("%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");
             }
    }
}




void computer_move(char board[ROW][COL], int row, int col)//电脑下棋
{
    int x = 0;
    int y = 0;
    printf("电脑下棋:>\n");
  while(1)
  {
      x = rand() % ROW;//0~2
      y = rand() % COL;//0~2
      if(board[x][y] == ' ')
      {
         board[x][y] = '#';
         break;
      } 
  }
}

int is_full(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;
}

char is_win(char board[ROW][COL], int row, int col)
{
  int i = 0;
  for(i = 0; i < row; i++)//三行的判断
  {
    if(board[i][0] == board[i][1] && board[i][1] == board[i][2] && board[i][1] != ' ')//注意不能三个空格相等
      {
        return board[i][1];
      }
  }
  for (i = 0; i < col; i++)//三列的判断
  {
      if (board[0][i] == board[1][i] && board[2][i] == board[i][2] && board[1][i] != ' ')//注意不能三个空格相等
      {
          return board[1][i];
      }
  }
      if(board[0][0] == board[1][1] && board[1][1] == board[2][2] && board[1][1] != ' ')//对角线的判断,左上角到右下角相连
      {
          return board[1][1];
      }
      if (board[0][2] == board[1][1] && board[1][1] == board[2][0] && board[1][1] != ' ')//对角线的判断，左下角到右上角相连
      {
          return board[1][1];
      }
      //判断平局(没有空格)
      if(1 == is_full(board, row, col))
      {
          return 'Q';
      } 
      //继续游戏
          return 'C';
}

HackerYip
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现井字棋
qq_52989768的博客
11-12 3713
这几天利用之前所学写了一个井字棋的小游戏，效果如下 整个小游戏共创建三个文件，game.h用于声明函数，game.c用于函数的实现，test.c来测试 在main函数内只有一个test()函数，所有功能都包含在test函数内 1.创建开始菜单 最开始进入游戏会有一个菜单，如下 当输入1的时候进行游戏，输入0的时候退出，输入其它数字则显示重新输入，当玩家完成一局后游戏回到菜单 我们来分析一下 首先，上述的功能肯定要使用循环语句来实现，玩家点开游戏时直接进入菜单，此时并没有什么判断条件..
C语言取牌游戏
蓝天翔的博客
10-28 3640
取牌游戏 有54张扑克牌，两个人轮流拿牌，每人每次最少取1张，最多取4张，谁拿最后一张谁输。编写模拟计算机先拿牌且必胜的算法。 分析： 为了保证计算机胜利，因此最后的牌必须是人取到，而且只能剩余1张。通过观察发现，除去最后一张牌，还剩余53张牌。 除去第一次计算机取牌，之后的每次计算机如果要赢得游戏，可以根据人取了多少张牌进行调整，以保证剩余最后一张只能给人取到。 由于人与计算机的取牌数量局限在[...
c语言三个人斗地主发牌的程序,大家想想怎么用c实现我们经常玩的斗地主游戏的发牌过程呢？...
weixin_42506884的博客
05-20 586
该楼层疑似违规已被系统折叠隐藏此楼查看此楼#include#include#include#includestruct people{char c[20];int a[20];int p;}b[3];int main(void){int i,j,a[13][4],*p;p=a[0];for(i=0;i<52;i++){*p=abs((rand()*(int)time(NULL))%3)+1...
C语言编程-随机抽取扑克
weixin_44183745的博客
05-04 647
Enter number of cards in hand:52 Your in_hands:D2 S7 D6 D7 H5 C5 Da Hj Dk C4 D8 Sq Cq S2 Hk C6 H3 Sa H4 Dj Ct Hq S9 Sj H6 C3 Cj D3 H9 D4 St C7 D5 Ck C8 C9 H2 Ha D9 Dt Ht H8 S5 Ca S8 Sk S3 H7 S4 Dq C2 S6 #define NUM_SUITS 4 //花色 #define NUM_RANKS 13
【C语言】三子棋.c
renjingjingya0429的博客
05-15 338
#include&lt;stdio.h&gt;int main(){ const int size=3; int board[size][size]; int i,j; int numofX; int numof0; int result=-1; printf("-1:没人赢,1:X赢,0:0赢。\n"); printf("请输入一个3乘3的矩阵:\n"); for(i=0;i&lt;size;...
C语言 三子棋游戏
最新发布
weixin_48074962的博客
06-11 60
使用C语言实现三子棋游戏（Tic-Tac-Toe），冲冲冲~
C语言实现三子棋
weixin_44395170的博客
07-24 240
三子棋 三子棋是指玩家双方在一个3×3的棋盘内落子，首先达成三个棋子连成一条线的玩家则为赢家。 这里用C语言实现一下简易的的三子棋游戏代码。 首先利用数组存储棋盘，创建一个3×3的数组，内部存储空格表示该位置没有棋子，所以对棋盘进行初始化时将数组内部全部存储为空格： memset(board, ' ', col*row); 棋盘初始化之后，每一次的落子都需要对于当前棋盘进行打印，这里利用不同的横线...
用C语言实现三子棋小游戏
08-08
三子棋是一种民间传统游戏，又叫九宫棋、圈圈叉叉、一条龙、井字棋等。将正方形对角线连起来，相对两边依次摆上三个双方棋子，只要将自己的三个棋子走成一条线，对方就算输了。但是，有很多时候会出现和棋的情况。 1...
C语言实现三子棋小游戏
08-28
C语言实现三子棋小游戏 本资源主要介绍了使用C语言实现三子棋小游戏的方法，包括游戏的基本结构、游戏棋盘的初始化、游戏棋子的下棋方法、计算机自动下棋的方法、游戏胜利的判断方法等方面的内容。 1. 游戏基本...
c++自制game.h头文件
11-15
解压后放到D盘 写代码时加上1行代码： #include <D:\game.h>即可 相当于万能头文件+fstream库+windows.h库+conio.h库 还有一些类型和函数
289. 生命游戏
toutao的博客
09-28 99
方法一：复制一个新的二维数组 方法二：不需要额外空间，在原数组上直接操作，分为四种情况（对应题目中四种） 1、board[i][j]=1->board[i][j] = -1（表示本来活着，后来死了，设置成-1是为了计算其他格子的时候，它的状态应该是活的，加绝对值即可） 2、board[i][j]=1不变 3、board[i][j]=1->board[i][j] = -1（表示本来活着，后来死了，设置成-1是为了计算其他格子的时候，它...
三子棋游戏
qq_67458830的博客
01-27 427
三子棋游戏的实现。
C语言实现三子棋游戏（详解）
m0_70980326的博客
07-28 1445
详细讲解C语言如何实现三子棋游戏
C语言扫雷游戏
bit_zyx的博客
11-11 5608
目录 一. 扫雷样板总览 二. 正文--->逻辑分析 2.1 生成菜单 2.2 创建棋盘 2.3 初始化棋盘 2.4 打印棋盘 2.5 布置雷 2.6 排查雷 三. 总代码 3.1 test.c文件 3.2 game.c文件 3.3 game.h文件 一. 扫雷样板总览 此图为大家在网页上就能搜到的扫雷模板，而在c语言中，我们也可以...
c语言if多条件并列_用c语言做最简易的2048小游戏
weixin_39875760的博客
11-21 449
1.最基本的要求掌握if-else语句，循环，二维数组，函数。2.了解2048的游戏规则规则如下：每次可以选择上下左右其中一个方向去滑动，每滑动一次，所有的数字方块都会往滑动的方向靠拢，系统也会在空白的地方随机出现一个数字方块，2或4，相同数字的方块在靠拢时相加。玩家要想办法在这小小的16格范围中凑出“2048”这个数字方块。3.找到游戏的核心很显然游戏的核心是控制移动：怎样...
以猜数字游戏为例理解C语言while循环语句和if条件
weixin_42485448的博客
10-23 2285
循环语句和条件语句是编程语言的基础, 而while循环语句与if条件语句是条件语句和循环语句的基础. 因此我们在学习C语言的开始要好好学习与认真思考着两个语句. 本次将借助简单的猜数字游戏开帮助大家理解. 首先我们会让系统随机获得一个数字,然后让玩家输入一个数字,系统会提醒是&amp;amp;quot;高了&amp;amp;quot;还是&amp;amp;quot;低了&amp;amp;quot;.最终猜出数字的结果. 源代码见下 #define _CR
【C语言】超详细的----三子棋游戏---- 实现与解析
a7671773的博客
11-25 609
【C语言】超详细的----三子棋游戏---- 实现与解析 本次学习写一个三子棋软件，基本上用到了之前所学的所有知识，下面开始解析这个 三子棋游戏。 三子棋从下往上 的组成有：棋盘，我方棋，对方棋。三个部分组成。 棋盘的要素简述 首先棋盘是一个3*3的正方形（所以使用二维数组），每一个格子应该初始化成为 空格 ' ' ,以便放入棋子。 第二，方格间应该要有分隔线构成，但是要注意边界没有棋盘的周围没有分割线。 第三，定义棋子实现，我们用 * 来表示我方棋子，用 # 表示电脑棋子。 第四，定义胜利条件，胜利条
C语言设计三子棋游戏
05-30
好的，设计三子棋游戏可以分为以下几个步骤： 1. 定义棋盘：通常使用一个三行三列的二维数组来表示棋盘，用数字0表示空位，用数字1表示玩家1下的棋子，用数字2表示玩家2下的棋子。 2. 实现落子功能：用户输入行列坐标，程序判断该位置是否为空位，如果是则将该位置设置为当前玩家下的棋子。 3. 判断胜负：每次玩家下完棋后，程序需要判断是否有一方取得胜利，可以通过遍历棋盘来实现。 4. 实现人机对战：可以使用随机数来模拟电脑的落子，也可以使用一些简单的算法来提高电脑的智能程度。 下面是一个简单的C语言三子棋游戏代码示例，供参考： ``` #include <stdio.h> #include <stdlib.h> #include <time.h> int chessboard[3][3]; // 棋盘 int check_win(int player) // 判断胜负 { int i, j; for (i = 0; i < 3; i++) { if (chessboard[i][0] == player && chessboard[i][1] == player && chessboard[i][2] == player) { return 1; } if (chessboard[0][i] == player && chessboard[1][i] == player && chessboard[2][i] == player) { return 1; } } if (chessboard[0][0] == player && chessboard[1][1] == player && chessboard[2][2] == player) { return 1; } if (chessboard[0][2] == player && chessboard[1][1] == player && chessboard[2][0] == player) { return 1; } return 0; } void print_chessboard() // 打印棋盘 { int i, j; for (i = 0; i < 3; i++) { for (j = 0; j < 3; j++) { if (chessboard[i][j] == 0) { printf(" "); } else if (chessboard[i][j] == 1) { printf("X"); } else if (chessboard[i][j] == 2) { printf("O"); } if (j < 2) { printf("|"); } } printf("\n"); if (i < 2) { printf("-+-+-\n"); } } } int main() { int player = 1; // 玩家先手 int row, col; srand((unsigned)time(NULL)); // 初始化随机数生成器 printf("Welcome to the Tic-Tac-Toe game!\n"); printf("Player 1: X\n"); printf("Player 2: O\n"); while (1) { printf("Player %d's turn.\n", player); if (player == 1) { printf("Please input the row and column numbers to place your chess(X).\n"); scanf("%d%d", &row, &col); if (chessboard[row][col] != 0) { printf("This place has been taken, please choose another place.\n"); continue; } chessboard[row][col] = 1; } else { printf("Thinking...\n"); while (1) { row = rand() % 3; col = rand() % 3; if (chessboard[row][col] == 0) { break; } } chessboard[row][col] = 2; } print_chessboard(); if (check_win(player)) { printf("Player %d wins!\n", player); break; } if (player == 1) { player = 2; } else { player = 1; } } return 0; } ``` 注意：以上代码仅作为参考，可能存在一些漏洞和不足之处，需要在实际使用中进行完善。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值