一个四子棋游戏

最新推荐文章于 2024-01-15 01:49:11 发布
最新推荐文章于 2024-01-15 01:49:11 发布
阅读量200 收藏 1
点赞数
文章标签： linq p2p sql
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_66040869/article/details/125159100
版权

编写一个"人机对弈"的下棋程序，四个棋子连成一线即为赢。人走棋的合法输入为0-6。棋盘是垂直放置，棋子落到底部。固定为人先走，计算机后走.

首先，这里有用到枚举类型----增加程序的可读性.用来描述状态量
/*enum who { HUMAN, NEUTRAL, COMPUTER };
HUMAN=0, NEUTRAL=1,COMPUTER=2
枚举常量代表该枚举类型的变量可能取的值，编译系统为每个枚举常量指定一个整数值。
默认状态下，这个整数就是所列举元素的序号，序号从0开始。
可以在定义枚举类型时为部分或全部枚举常量指定整数值，在指定值之前的枚举常量仍按默认方式取值，
而指定值之后的枚举常量按依次加1的原则取值。 各枚举常量的值可以重复。
//枚举常量只能以标识符形式表示，而不能是整型、字符型等文字常量。
//直接输出，输出的是变量的整数值*/

定义一个who data[6][7];枚举变量数组，用于存储棋盘各位置上棋子的类型（人机无）

主要结构

class game { //这是个抽象类，抽象的是所有人走一步，计算机走一步的对弈游戏
	private:
		int move_number; //当前已走的步数
		void make_human_move( );   //调用 get_user_move( )，并用is_legal(move)判断是否合法输入，若是则调用make_move(move)
	public:
		enum who { HUMAN, NEUTRAL, COMPUTER };//枚举类型变量who(同int float样的数据类型) ：有枚举元素HUMAN, NEUTRAL, COMPUTER

		game( ) {//构造函数，move_number初始值为0
			move_number = 0;
		}
		virtual ~game( ) { }//析构函数
		who play( );   //人先走，计算机后走，返回值是游戏的赢者，后面给出了此函数的定义
	protected:
		//以下虚函数可以被覆盖，也可以不被覆盖
		//virtual void display_message(const string &message)const;//在屏幕显示信息message
		virtual int get_user_move( )const;       // 输出"Your move,please:"，然后接受用户输入，并将输入返回
		virtual who last_mover( ) const {
			if (move_number == 0)
				return NEUTRAL;
			else
				return (move_number % 2 == 1 ? HUMAN : COMPUTER);//人先走 必然结果
		}
		virtual int moves_completed( ) const {
			return move_number;//返回已走步数//用于将私有变量显示在棋盘上
		}
		virtual who next_mover( ) const {//表示现在的下棋者 在make_move中调用
			return (move_number % 2 == 0 ? HUMAN : COMPUTER);
		}

		//以下虚函数必须被覆盖
		virtual void make_move(const int &move) { //将棋子真正下到棋盘上，此函数被子类覆盖
			++move_number;
		}
		virtual void restart( ) {
			move_number = 0;    //开始新的棋局
		}

		//以下为纯虚函数
		virtual who winning( )const = 0;       //返回胜利者
		virtual void display_status( )  = 0;   //显示游戏棋盘的当前状态
		virtual bool is_game_over( )  = 0;     //如果游戏结束，返回真
		virtual bool is_legal(const int &move)  = 0;   //如果给定走法为合法，就返回真
		virtual void make_computer_move( ) = 0;  //计算计算机所有的可能的走法，选出一种最好的，并调用make_move(best_move)


};

class c4 : public game { //这个类是我们具体要实现的“四子棋”
	public:
		c4( ) {//构造函数
			restart( );//调用的是子类c4的restart
		}
	protected:
		virtual void make_move(const int &move);
		// 修改data[][],many_used[]和most_recent_column的值，并调用game::make_move(move)
		virtual void restart();
		//将data[6][7]各元素置为NEUTRAL，将many_used[7]各元素置为0 ，再调用game::restart();//清空棋盘以及步数
		virtual game::who winning( )const ;
		virtual void display_status( ) ;  //显示棋盘的状态
		virtual bool is_game_over( ) ;
		virtual bool is_legal(const int &move) ;
		virtual void make_computer_move( );
	private:
		who data[6][7];   //6行7列，表示棋盘
		int many_used[7]; //表示各列中已有多少个棋子
		int most_recent_column;  //最近下的棋子在哪列
		int chess_notation[30] = {0}; //定义数组存储 每步most_recent_column的位置
		int *p = chess_notation;//指针指向存储全部most_recent_column
};

game为基类，c4表示四子棋为game的派生类。

game中的纯虚函数需要在c4中再次声明，并定义新的内容 

主函数

int main() {
	cout << "Game on!" << endl;
	c4 instance;
	game::who winner;//定义一个who枚举类型的变量 winner
	winner = instance.play();//对winner进行赋元素操作,返回赢的人

	switch (winner) {
		case c4::HUMAN:
			cout << "You win!" << endl;
			break;

		case c4::COMPUTER:
			cout << "I win!" << endl;
			break;

		case c4::NEUTRAL:
			cout << "A draw" << endl;
			break;
	}

	return 0;
}

定义一个c4类结构体变量instance         定义一个枚举变量winner赢者

调用核心函数 game：：play();

选择赢者——输出结果

核心函数

game::who game::play() {
	restart();//清空棋盘 开始游戏

	while (!is_game_over()) {//当游戏未结束时，显示棋盘的状态
		display_status();

		if (last_mover() == COMPUTER || last_mover() == NEUTRAL)
			make_human_move();//上一步机走，下一步人走
		else
			make_computer_move();//上一步人走，下一步机走
	}

	display_status();//走一步，显示一下棋盘状态 或游戏结束显示棋盘状态
	return winning();//返回赢者
}

以下按照核心函数的顺序 给出各个函数的定义

restart():

game中走的步数清零

c4中将棋盘上每一个都写为“无”，每一列的棋子数为0，再调用父类restart（）；

c4中的restart（）函数覆盖了父类中函数，所以在使用restart（）时调用的是子类的函数，如需要调用父类中的函数，则需要使用：：

/game/
virtual void restart( ) {
	move_number = 0;    //开始新的棋局
}

void c4::restart( ) {//覆盖game类
//将data[6][7]各元素置为NEUTRAL，将many_used[7]各元素置为0 ，再调用game::restart();
	for (int i = 0; i < 6; i++) {
		for (int j = 0; j < 7; j++) {
			data[i][j] = NEUTRAL;
		}
	}

	for (int k = 0; k < 7; k++) {
		many_used[k] = 0;
	}

	game::restart( );//开始新的棋局 即move_number = 0;
}

 is_game_over():

判断是否有四子连成，如有返回真

因为使用了嵌套循环，所以只有break；只是跳出了内嵌循环。需要有一个变量来限制循环条件。

根据棋盘大小，确定ij的范围

bool c4::is_game_over( ) {
	int win = 1;//用变量作为跳出循环的条件

	if (last_mover() == NEUTRAL)//游戏开局 先手被定义为NEUTRAL 要排除这种情况
		return false;

	for (int j = 0; j < 7 && (win == 1); j++) {//win不等于1的时候 跳出循环
		for (int i = 0; i < 6; i++) {
			if (data[i][j] == HUMAN && data[i][j + 1] == HUMAN && data[i][j + 2] == HUMAN && data[i][j + 3] == HUMAN
			        || data[i][j] == HUMAN && data[i + 1][j] == HUMAN && data[i + 2][j] == HUMAN
			        && data[i + 3][j] == HUMAN) { //纵横方向上HUMAN
				win = 0;
				break;
			}

			if (data[i][j] == COMPUTER && data[i][j + 1] == COMPUTER && data[i][j + 2] == COMPUTER
			        && data[i][j + 3] == COMPUTER
			        || data[i][j] == COMPUTER && data[i + 1][j] == COMPUTER && data[i + 2][j] == COMPUTER
			        && data[i + 3][j] == COMPUTER) { //纵横方向上COMPUTER
				win = 2;
				break;
			}
		}
	}

	for (int j = 0; j < 4 && (win == 1); j++) {
		for (int i = 3; i < 6; i++) {
			if (data[i][j] == HUMAN && data[i - 1][j + 1] == HUMAN && data[i - 2][j + 2] == HUMAN
			        && data[i - 3][j + 3] == HUMAN) { //向右倾斜方向上HUMAN
				win = 0;
				break;
			}

			if (data[i][j] == COMPUTER && data[i - 1][j + 1] == COMPUTER && data[i - 2][j + 2] == COMPUTER
			        && data[i - 3][j + 3] == COMPUTER) { //向右倾斜方向上COMPUTER
				win = 2;
				break;
			}
		}
	}

	for (int j = 3; j < 7 && (win == 1); j++) {
		for (int i = 0; i < 3; i++) {
			if (data[i][j] == HUMAN && data[i + 1][j - 1] == HUMAN && data[i + 2][j - 2] == HUMAN
			        && data[i + 3][j - 3] == HUMAN) { //向左倾斜方向上HUMAN
				win = 0;
				break;
			}

			if (data[i][j] == COMPUTER && data[i + 1][j - 1] == COMPUTER && data[i + 2][j - 2] == COMPUTER
			        && data[i + 3][j - 3] == COMPUTER) { //向左倾斜方向上COMPUTER
				win = 2;
				break;
			}
		}
	}

	if (win == 0 || win == 2)
		return true;
	else
		return false;
}

i和j 的范围：由棋盘的大小决定，比如在纵横方向上，最后的一个棋在棋盘上的每一个格都可能使连成4子。而向右斜上方向，有些位置上不可能连成4子，所以，不用考虑，化简程序。

display_status():

Chess notation[30]:每步棋落在哪里，用一个数组存储。每次输出一个数组的全部元素

void c4::display_status( ) {
	//显示棋盘的状态
	for (int i = 0; i < 6; i++) {
		cout << "\t\t";

		for (int j = 0; j < 7; j++) {
			if (data[i][j] == COMPUTER)
				cout  << "@" << "  " ;
			else if (data[i][j] == HUMAN)
				cout << "$" << "  " ;
			else
				cout << "." << "  " ;
		}

		cout << endl;
	}

	cout << "\t\t" << "-------------------" << endl << "\t\t" << "0  1  2  3  4  5  6  " << endl << "\t" <<
	     "@:computer   $:human   humanfirst" << endl;
	cout << "Chess notation:";
	*p = most_recent_column;

	for (p = chess_notation; p < moves_completed( ) + chess_notation; p++) {
		cout << *p << " ";
	}

	cout << endl;
	cout << "used[i]:";

	for (int i = 0; i < 7; i++) {
		cout << many_used[i] << " ";
	}

	cout << endl;
	cout << "The number of moves have played:" << moves_completed( ) << endl << endl;
}

make_human_move( )

从键盘输入人走的列数，调用is_legal_move()判断正误,合法即调用make_move()

int game:: get_user_move( )const {
	int move;
	cout << "Your move,please:";
	cin >> move;
	return move;
}
void game::make_human_move( ) { //调用 get_user_move( )，并用is_legal(move)判断是否合法输入，若是则调用make_move(move)
	int move = get_user_move( );

	while (1) {
		if (is_legal(move)) {
			make_move(move);
			break;
		} else {
			cout << "!retry!" << endl;
			move = get_user_move( );
		}
	}
}

make_move() 

virtual void make_move(const int &move) { //将棋子真正下到棋盘上，此函数被子类覆盖
			++move_number;
		}
void c4::make_move(const int &move) {//覆盖game类
// 修改data[][],many_used[]和most_recent_column的值，并调用game::make_move(move)

	int temp = many_used[move]; //用中间变量存储 此时该列中 已有的棋子数

	if (next_mover( ) == HUMAN)
		data[5 - temp][move] = HUMAN; //人把棋子下到该列
	else
		data[5 - temp][move] = COMPUTER;//机把棋子下到该列

	many_used[move]++;//该列已有棋子+1
	most_recent_column = move;//保存最近下的棋在哪一列————————决定下一步机下在哪里
	game::make_move(move);//即 ++move_number;已走步数加1
}

gobaiod
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
LC-3简易四子棋（深大计系1实验4） 思路+代码+详细注释
AKGWSB 's blog
05-26 7827
明天做LC-3的四子棋实验，但是我想睡懒觉就今天把他做了，这个实验挺难的，要写好久还容易出bug，我把自己的思路和代码分享一下，让大家少走弯路 目录前置知识标号伪操作TRAP伪指令代码块（函数）调用题目描述实现思路流程判断胜利思路矩阵存放与填写测试结果代码 前置知识 在做实验前要掌握LC-3的一些伪指令和操作 标号 标号 = 内存地址 （可以这么粗略的理解，编译器建立了名字到内存的映射） 伪操作 特性：相当于库函数了，调用这些伪操作，编译器自动帮你做一些工作，标号以.开头，下面给出标号的解释表格
LC-3下汇编实现简易版四子棋的游戏
Elvis.
05-06 7576
问题描述： 两位选手通过键盘和输出窗口轮流交互操作，棋盘由6 X 6的网格组成。 游戏规则如下： 两位选手依次轮流落子； 选手不能悔棋； 有子的地方不能继续落子； 直到有一方的四个棋子能够连成一条水平线、垂直线或者是对角线； 如果棋盘已满，无人获胜，则平局。 游戏最初时应该打印空的棋盘，可以用ASCII码"-" （即ASCII 码 x002D）来表示该处为空，"O"(ASCII 码
汇编语言简易四子棋
08-01
简单的了解 汇编语言编写的 LC3环境下的 简易四子棋小游戏
c语言棋类ai怎么写搜索,新手立体四子棋AI教程(4)——启发式搜索与主程序
weixin_42500791的博客
05-23 207
通过前面几篇文章的学习，我们的四子棋程序已经有了框架、搜索几大部分，但是还有着不少问题，我们的程序只能迭代很有限的步骤，导致棋力低下，在这一篇我们将通过启发式搜索极大的优化搜索效率。一、原因我们之前的产生走子位置的函数很简单，即找到棋盘上的空余位置。它的不合理性体现在两方面：没有对结果进行排序，完全是按照数组的遍历顺序的。而Alpha Beta 剪枝的效率是非常依赖节点顺序的，这个我们马上就会讲一...
深圳大学计算机系统LC-3中实现简易版四子棋实验报告（含源代码及截图）
12-11
计算机系统第四次实验是用LC3做简单游戏：四子棋。本资源含有实验报告、源代码以及截图，可以参考参考，有助于早日完成作业
【深圳大学计算机系统1】实验四 简易四子棋
最新发布
归忆_AC的博客
01-15 1401
为了明确选手的落子的位置，该选手应该输入数字1-6，然后回车，数字1-6指示在落子所在的列，从左到右，无需输入行号，程序应默认从行号6到行号1递减的顺序填入该棋子，若前后输入的列号相同，则行号减一。例如，如果选手第一次在左起第二列落子，应该输入2，然后回车，则该棋子落在行6列2处，当后面输入的列号再次为2时，则将棋子落子行5列2处，以此类推，详情见后续示例输出。程序应该一直提示该选手，知道输入正确的数字，当用户输入完成，程序应通过显示回馈给选手，然后通过换行符(ASCII 码 x000A)换行。
C语言简单游戏编程入门之四子棋
冰凌的博客
12-27 3169
运行截图 源代码 #include<stdio.h> #include<stdlib.h> /* 四子棋 1.在一个6行7列的棋盘中 2.玩家1和玩家2依次交替下子 3.每次下子落于棋盘可能达到的最下方 4.先四子相连为胜 5.棋盘已满且无四子相连为平局 */ /*定义常量*/ //行数 #define ROW 7 //列数 #define COL 8...
C语言实现基于UCT树的重力四子棋
毕业作品网站
09-22 580
算法采用信心上限树算法（UCT 树）及蒙特卡洛模拟，这种算法适用于通过不断的模拟给出结论的场合，不需要很强的先验知识。对于每个节点，按照如下算式，计算子节点的权重：其中 Q(v)是当前节点总得分，N(v)是当前节点总访问次数，N(parent(v))是其父节点的总访问次数。上式中，第一项是下棋的平均得分，第二项代表了子节点的未知程度，从而使得访问次数较少的节点也能够被充分地探索。UCT 树主要就是选择子节点 à 探索新节点 à 随机模拟 à 结果回溯的过程。随机模拟时等概率选择落子点，直至分出胜负。
三子棋游戏
@柠檬少年
10-24 428
思路：创建一个二维数组打印棋盘。 1.打印棋盘； 2.玩家走； 3.判断输赢； 4.电脑走； 5.判断输赢； 代码如下： game.h //头文件#ifndef _GAME_H_#define _GAME_H_#include <stdio.h> #include <stdlib.h> #include <time.h> #include <string.h> #define ROW
四子棋智能下棋C语言实现
03-15
四子棋智能下棋C语言实现，可以机器和机器下，人和机器下，人和人下，人和动物下
四子棋实验报告1
08-03
1、问题描述 1 2、文件说明 4 3、模型原理 4 4、算法测试 4 5、模型分析 4 6、实验结果 4 7、收获与总结 4 8、附录 4
四子棋c语言程序
03-11
这是一个用c语言编写的四子棋小程序，本程序作为一个平台使用，对战双方可以分别编写一个人工智能程序进行对战，特别锻炼编程初学者的编程能力。
四子棋游戏源代码（pascal自己编的）
02-04
四子棋游戏源代码（pascal版） 仅供参考
LC3中断实验
06-13
计算机系统LC-3中断实验，利用LC-3让输入输出通过执行中断处理程序的方式来暂停和恢复一个正在运行的程序，内含汇编代码和注释
C语言游戏编程之四子棋.zip
12-27
在本资源中，我们主要探讨的是使用C语言进行游戏编程，特别是四子棋游戏的实现。四子棋，又称连珠棋，是一种简单而有趣的双人对战游戏，目标是先将四个同色棋子连成直线（横、竖、斜）的一方获胜。 C语言是一种基础...
【游戏】基于matlab模拟四子棋.zip
04-05
四子棋，又称Gomoku或五子棋的变种，是一种两人对弈的策略型棋类游戏。在这个项目中，我们使用MATLAB来模拟四子棋的逻辑和交互过程。MATLAB是一款强大的数学计算软件，同时具备编程能力，使得它能够胜任这种棋盘游戏...
Scratch 棋类人机对战游戏：四子棋 AI
01-13
四子棋的英文名字Connect Four在1974年由米尔顿·布拉德利命名。 四子棋的棋盘共有6行7列，棋盘是垂直摆放，每名玩者有21只圆形棋子，以不同颜色辨别。两名玩者轮流每次把一只棋子放进棋盘任何未全满的一行中，棋子...
Java小程序 四子棋
03-21
在这个四子棋游戏中，开发者可能使用了JavaFX来设计棋盘和棋子的显示，处理用户的点击事件，更新棋盘状态，并显示提示信息。 3. **事件监听**：在GUI中，事件监听是处理用户交互的关键。当用户点击棋盘上的某个位置...
用C语言写一个三子棋游戏
05-12
好的，下面是一个简单的三子棋游戏的代码，仅供参考： ```c #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #define SIZE 3 void initialize_board(char board[][SIZE]); void display_board(char board[][SIZE]); bool check_win(char board[][SIZE], char player); bool check_tie(char board[][SIZE]); int main(void) { char board[SIZE][SIZE]; char player = 'X'; int row, col; bool win = false; bool tie = false; initialize_board(board); do { display_board(board); printf("Player %c's turn.\n", player); do { printf("Enter row (1-3): "); scanf("%d", &row); printf("Enter column (1-3): "); scanf("%d", &col); } while (board[row-1][col-1] != ' '); board[row-1][col-1] = player; win = check_win(board, player); tie = check_tie(board); if (win) { printf("Player %c wins!\n", player); display_board(board); break; } if (tie) { printf("It's a tie!\n"); display_board(board); break; } player = (player == 'X') ? 'O' : 'X'; } while (!win && !tie); return 0; } void initialize_board(char board[][SIZE]) { int i, j; for (i = 0; i < SIZE; i++) { for (j = 0; j < SIZE; j++) { board[i][j] = ' '; } } } void display_board(char board[][SIZE]) { int i, j; printf("\n"); for (i = 0; i < SIZE; i++) { for (j = 0; j < SIZE; j++) { printf(" %c ", board[i][j]); if (j < SIZE - 1) { printf("|"); } } printf("\n"); if (i < SIZE - 1) { printf("---+---+---\n"); } } printf("\n"); } bool check_win(char board[][SIZE], char player) { int i; // check rows for (i = 0; i < SIZE; i++) { if (board[i][0] == player && board[i][1] == player && board[i][2] == player) { return true; } } // check columns for (i = 0; i < SIZE; i++) { if (board[0][i] == player && board[1][i] == player && board[2][i] == player) { return true; } } // check diagonals if (board[0][0] == player && board[1][1] == player && board[2][2] == player) { return true; } if (board[0][2] == player && board[1][1] == player && board[2][0] == player) { return true; } return false; } bool check_tie(char board[][SIZE]) { int i, j; for (i = 0; i < SIZE; i++) { for (j = 0; j < SIZE; j++) { if (board[i][j] == ' ') { return false; } } } return true; } ``` 这个代码实现了一个简单的三子棋游戏，玩家可以选择行列下棋，程序会自动判断胜负和平局。需要注意的是，这个代码没有实现人机对战，只能让两个人玩。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值