控制台小游戏之五子棋

最新推荐文章于 2022-09-18 10:20:00 发布
最新推荐文章于 2022-09-18 10:20:00 发布
阅读量703 收藏 1
点赞数 1
分类专栏： 控制台游戏 文章标签： 五子棋 控制台 游戏 class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hophan/article/details/50414557
版权

五子棋用了两个类，一个棋盘类ChessBoard和一个玩家类Player，然后用一个game类包装一下，实现一些游戏的基本操作。

ChessBoard.h：

#ifndef _CHESS_BOARD_H
#define _CHESS_BOARD_H

#include<vector>
#include<string>
#include<iostream>

class ChessBoard
{
public:
	ChessBoard(std::size_t board_size);
	
	void PrintChessBoard()const;

	std::size_t ChessmanNumbers()const{ return ChessmanNum; }

	std::size_t Size()const{ return BoardSize; }

	void SetBoardSize(std::size_t boardsize){ BoardSize = boardsize; }

	bool CheckFull()const{ return ChessmanNum == BoardSize * BoardSize; }

	bool AddChessman(std::size_t x, std::size_t y, std::string color);

	bool CheckPosition(std::size_t x, std::size_t y)const;
private:

	std::vector<std::string> Board;//棋盘，用制表符和圆圈表示

	std::size_t ChessmanNum;//棋子数

	std::size_t BoardSize;//棋盘大小
};


//┌    └    ┐    ┘    ─   │   ├    ┤    ┬    ┴    ┼	  ○   ●

#endif



Player.h

#ifndef _PLAYER_H
#define _PLAYER_H

#include"ChessBoard.h"

class player
{
public:
	player(const std::string&name = "Player",
		std::string chessman_type = "棋", 
		ChessBoard* board = nullptr) :
		CB(board),
		ChessmanType(chessman_type),
		PlayerName(name),
		MaxLength(0),
		Chessmans()
	{
		if (board)SetChessmans();
	}
	
	virtual ~player(){}

	virtual void SetChessBoard(ChessBoard *cbp);

	bool Win()const{ return MaxLength >= 5; }

	const std::string& Name()const{ return PlayerName; }

	virtual void AddChessman();

	void SetName(const std::string &name);

	void SetChessmanType(char chessmantype);

	virtual void SetOpponent(std::vector<std::vector<std::vector<int>>>*){};

	std::vector<std::vector<std::vector<int>>> * 
				GetChessmans(){ return &Chessmans; }

protected:
	ChessBoard *CB;<span style="white-space:pre">			</span>//棋盘指针

	std::string ChessmanType;<span style="white-space:pre">	</span>//棋子样式

	std::string PlayerName;<span style="white-space:pre">		</span>//玩家姓名

	std::size_t MaxLength;<span style="white-space:pre">		</span>//目前状态下最长的连子数，大于等于5时就获胜

	std::vector<std::vector<std::vector<int>>> Chessmans;//棋子状态，三维数组，前两维代表坐标，最后一维长度为4，代表该坐标位置的四个方向的连子数

	void update(std::size_t x, std::size_t y);

	bool CheckPosition(std::size_t,std::size_t)const;

	void SetChessmans();
};

#endif

Game.h 

#ifndef _GANME_H
#define _GAME_H

#include"ChessBoard.h"
#include"player.h"
#include"AI.h"

class Game
{
public:
	Game(player*player1, player*player2, std::size_t board_size = 16) :
		CB(board_size), p1(player1), p2(player2) {
		p1->SetChessBoard(&CB); 
		p2->SetChessBoard(&CB);
			p1->SetOpponent(p2->GetChessmans());
			p2->SetOpponent(p1->GetChessmans());
	}

	~Game(){  }

	void GameSet();

	void SetPlayerName(std::size_t);

	void SetPlayerChessmanType(std::size_t);

	void SetBoardSize();

	void StartGame();

	void EndGame(std::size_t);

	bool GameOver()const{ return p1->Win() ||
				     p2->Win() || 
				CB.CheckFull(); 
<span style="white-space:pre">	</span>     }
private:
	ChessBoard CB;<span style="white-space:pre">	</span>//棋盘

	player *p1, *p2;//玩家指针

	void UpdateBoard(std::size_t)const;
};

#endif

然后是实现：

ChessBoard.cpp


#include"ChessBoard.h"

ChessBoard::ChessBoard(std::size_t board_size)
{
	ChessmanNum = 0;
	BoardSize = board_size;
	Board.push_back(std::string("┌"));
	for (int i = 1; i <= BoardSize; ++i)
		Board[0] += "┬";
	Board[0] += "┐";

	for (int i = 1; i <= BoardSize; ++i){
		Board.push_back(std::string("├"));
		for (int j = 1; j <= BoardSize; ++j)
			Board[i] += "┼";
		Board[i] += "┤";
	}

	Board.push_back(std::string("└"));
	for (int i = 1; i <= BoardSize; ++i)
		Board[BoardSize + 1] += "┴";
	Board[BoardSize + 1] += "┘";
}

void ChessBoard::PrintChessBoard()const{
	std::cout << "\t\t\t   ";
	for (int i = 0; i <= BoardSize; ++i)
		std::cout << i % 10 << ' ';
	std::cout << std::endl;
	int rownum = 0;
	for (auto const&s : Board)
		std::cout << "\t\t\t" << rownum++ % 10 << ' ' << s << std::endl;
}

bool ChessBoard::CheckPosition(std::size_t x, std::size_t y) const
{
	if (x < 1 || x > BoardSize || y < 1 || y > BoardSize)
		return false;
	std::string s = "┼";
	if (Board[x][y * 2] != s[0] && Board[x][y * 2 + 1] != s[1])
		return false;
	return true;
}

bool ChessBoard::AddChessman(std::size_t x, std::size_t y, std::string color)
{
	if (!CheckPosition(x, y))
		return false;
	Board[x][y * 2] = color[0];
	Board[x][y * 2 + 1] = color[1];
	++ChessmanNum;
	return true;
}


//┌    └    ┐    ┘    ─   │   ├    ┤    ┬    ┴    ┼	  ○   ●


Player.cpp 


#include"player.h"

void player::AddChessman(){
	std::size_t x = 0, y = 0;
	while (true){
		try{
			std::cin >> x >> y;
			if (!std::cin || !CB->AddChessman(x, y, ChessmanType)){
				throw std::runtime_error("无效坐标");
			}
			else{
				update(x, y);
				break;
			}
		}catch (std::runtime_error re){
			system("cls");
			CB->PrintChessBoard();
			std::cout << re.what() << ",请重新输入：";
			std::cin.clear();
			std::cin.sync();
		}
	}
}

void player::SetName(const std::string &name){
	PlayerName = name;
}

void player::SetChessmanType(char chessmantype){
	ChessmanType = chessmantype;
}

void player::SetChessBoard(ChessBoard *cbp){
	CB = cbp;
	SetChessmans();
}

void player::SetChessmans()
{
	Chessmans = std::vector<std::vector<std::vector<int>>>(
		CB->Size() + 2, std::vector<std::vector<int>>(
		CB->Size() + 2, std::vector<int>(4, 0)));
}

bool player::CheckPosition(std::size_t x, std::size_t y)const
{
	if (x > CB->Size() || y > CB->Size())
		return false;
	if (x < 1 || y < 1)return false;
	return true;
}

void player::update(std::size_t x, std::size_t y)<span style="white-space:pre">	</span>//更新己方棋盘状态
{
	std::pair<std::size_t, std::size_t> dp[4] = {
		{ -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }
	};
	for (int i = 0; i != 4; ++i){
		Chessmans[x][y][i] = Chessmans[x + dp[i].first][y + dp[i].second][i] + 
							 Chessmans[x - dp[i].first][y - dp[i].second][i] + 1;
		std::size_t step = 1;
		while (CheckPosition(x + step * dp[i].first, y + step * dp[i].second) &&
			Chessmans[x + step * dp[i].first][y + step * dp[i].second][i]){
			Chessmans[x + step * dp[i].first][y + step * dp[i].second][i] = Chessmans[x][y][i];
			++step;
		}
		step = -1;
		while (CheckPosition(x + step * dp[i].first, y + step * dp[i].second) &&
			Chessmans[x + step * dp[i].first][y + step * dp[i].second][i]){
			Chessmans[x + step * dp[i].first][y + step * dp[i].second][i] = Chessmans[x][y][i];
			--step;
		}
		MaxLength = MaxLength < Chessmans[x][y][i] ? Chessmans[x][y][i] : MaxLength;
	}
}


game.cpp


#include"Game.h"
#include"AI.h"


void Game::GameSet()
{
	std::cout << "\t\t\t  设置" << std::endl;
	std::cout << "\t\t\t1>p1姓名" << std::endl;
	std::cout << "\t\t\t2>p2姓名" << std::endl;
	std::cout << "\t\t\t3>p1棋子样式" << std::endl;
	std::cout << "\t\t\t4>p2棋子样式" << std::endl;
	std::cout << "\t\t\t5>棋盘大小" << std::endl;
	std::cout << "\t\t\t6>退出" << std::endl;
	std::size_t ch;
	std::cin >> ch;
	switch (ch){
	case 1:SetPlayerName(1); break;
	case 2:SetPlayerName(2); break;
	case 3:SetPlayerChessmanType(1); break;
	case 4:SetPlayerChessmanType(2); break;
	case 5:SetBoardSize(); break;
	case 6:break;
	default:std::cout << "请输入数字1~5" << std::endl; break;
	}
}

void Game::SetPlayerName(std::size_t PlayerNum)
{
	std::cout << "请输入玩家姓名：";
	std::string name;
	std::cin >> name;
	PlayerNum == 1 ? p1->SetName(name) : p2->SetName(name);
}

void Game::SetPlayerChessmanType(std::size_t PlayerNum)
{
	std::cout << "请输入棋子样式：";
	char ChessmanType;
	std::cin >> ChessmanType;
	PlayerNum == 1 ? 
		p1->SetChessmanType(ChessmanType) :
		p2->SetChessmanType(ChessmanType);
}

void Game::SetBoardSize()
{
	std::cout << "请输入棋盘大小：";
	std::size_t size;
	std::cin >> size;
	CB.SetBoardSize(size);
}

void Game::StartGame()
{
	bool p1turn = true;
	UpdateBoard(1);
	while (!GameOver()){
		if (p1turn){
			p1->AddChessman();
			p1turn = false;
			UpdateBoard(2);
		}
		else{
			p2->AddChessman();
			p1turn = true;
			UpdateBoard(1);
		}
	}
	EndGame(p1->Win() ? 1 : (p2->Win() ? 2 : 3));
}

void Game::EndGame(std::size_t PlayerNum)
{
	system("cls");
	CB.PrintChessBoard();
	if (PlayerNum == 3){
		std::cout << "\t\t\t和棋！" << std::endl;
		return;
	}
	std::cout << "\t\t\t" 
		<< (PlayerNum == 1 ? p1->Name() : p2->Name()) 
		<< "获胜！" << std::endl;
}

void Game::UpdateBoard(std::size_t PlayerNum)const
{
	system("cls");
	CB.PrintChessBoard();
	std::cout << "\t\t\t" 
		<< (PlayerNum == 1 ? p1->Name() : p2->Name())
		<< "请落子：";
}


其实我觉得用vector<string>保存棋盘状态挺蠢的。。。用数组保存就好了，后面在print函数中转换之后输出就好了。


再就是自己跟着想法随便实现了一个简单的AI的类，继承自Player，积分制，遍历棋盘所有坐标，计算威胁值和有利值，加权一下选择最优的坐标落子


AI.h


#ifndef _AI_H
#define _AI_H

#include"player.h"

class AIplayer : public player
{
public:

	AIplayer(const std::string&name,
		std::string chessman_type = "AI",
		ChessBoard* board = nullptr) :
		player(name, chessman_type, board)
	{ 
		if (board)SetScore();
	}

	void SetOpponent(std::vector<
		std::vector<std::vector<int>>>* opp)
	{ opponent = opp; }

	void AddChessman() override;

	void SetChessBoard(ChessBoard*) override;

	void SetScore();

	virtual ~AIplayer()override { player::~player(); }

private:

	std::vector<std::vector<std::vector<int>>>* opponent;

	std::vector<std::vector<double>> Score;

	bool CheckPosition(std::size_t x, std::size_t y,bool MyTurn){
		if (OutOfBoard(x,y)) return false;
		
		if (MyTurn && (*opponent)[x][y][0])
			return false;

		else if (Chessmans[x][y][0])
			return false;
		
		return true;
	}

	bool OutOfBoard(std::size_t x, std::size_t y){
		if (x<1 || y<1 || x>CB->Size() || y>CB->Size())
			return true;
		return false;
	}
	
	double GetThreaten(std::size_t,std::size_t);

	double GetChance(std::size_t, std::size_t);

	std::pair < std::size_t, std::size_t >
								UpdateScore();
	
	bool MyChessman(std::size_t, std::size_t);

	bool Five(std::vector<std::vector<std::vector<int>>>*, 
		std::vector<std::vector<std::vector<int>>>*,
		std::size_t, std::size_t);	//1000

	bool FourOrDooubleThree(std::vector<std::vector<std::vector<int>>>*, 
		std::vector<std::vector<std::vector<int>>>*, 
		std::size_t, std::size_t);	//500

	bool ThreeOrTwoTwo(std::vector<std::vector<std::vector<int>>>*,
		std::vector<std::vector<std::vector<int>>>*,
		std::size_t, std::size_t);	//250

	bool TwoOrOneOne(std::vector<std::vector<std::vector<int>>>*, 
		std::vector<std::vector<std::vector<int>>>*, 
		std::size_t, std::size_t);	//100

	bool OneOrZeroZero(std::vector<std::vector<std::vector<int>>>*, 
		std::vector<std::vector<std::vector<int>>>*, 
		std::size_t, std::size_t);	//50

	std::size_t AliveN(std::vector<std::vector<std::vector<int>>>*,
		std::vector<std::vector<std::vector<int>>>*, 
		std::size_t, std::size_t, std::size_t);

	std::size_t DeathN(std::vector<std::vector<std::vector<int>>>*,
		std::vector<std::vector<std::vector<int>>>*,
		std::size_t, std::size_t, std::size_t);
};

#endif



AI.cpp 


#include"AI.h"

void AIplayer::AddChessman()
{
	std::pair<std::size_t, std::size_t>
		pos = UpdateScore();
	CB->AddChessman(pos.first, pos.second, ChessmanType);
	update(pos.first, pos.second);
}

void AIplayer::SetScore(){
	Score = std::vector<std::vector<double>>(
		CB->Size() + 2, std::vector<double>(CB->Size() + 2, 0.0)
	);
}

void AIplayer::SetChessBoard(ChessBoard*CB){
	player::SetChessBoard(CB);
	SetScore();
}

std::pair<std::size_t, std::size_t>
			AIplayer::UpdateScore(){

	std::size_t Xpos = (CB->Size() + 1) / 2, Ypos = Xpos;

	for (std::size_t x = 1; x <= CB->Size(); ++x){
		for (std::size_t y = 1; y <= CB->Size(); ++y){

			Score[x][y] = GetThreaten(x, y) + 1.1 * GetChance(x, y);//威胁值和有利值加权，己方的权值略高，所以会有一点攻击性

			if (Score[x][y] > Score[Xpos][Ypos])
				Xpos = x, Ypos = y;
		}
	}
	return { Xpos, Ypos };
}

double AIplayer::GetThreaten(std::size_t x, std::size_t y)
{
	if (Chessmans[x][y][0] || 
	   (*opponent)[x][y][0])
		return 0.0;
	if (Five(opponent, &Chessmans, x, y))
		return 1000;
	if (FourOrDooubleThree(opponent, &Chessmans, x, y))
		return 500;
	if (ThreeOrTwoTwo(opponent, &Chessmans, x, y))
		return 250;
	if (TwoOrOneOne(opponent, &Chessmans, x, y))
		return 50;
	if (OneOrZeroZero(opponent, &Chessmans, x, y))
		return 5;
	return 0;
}

double AIplayer::GetChance(std::size_t x, std::size_t y)
{
	if ((*opponent)[x][y][0] ||
		Chessmans[x][y][0])
		return 0.0;

	if (Five(&Chessmans, opponent, x, y))
		return 10000;
	if (FourOrDooubleThree(&Chessmans, opponent, x, y))
		return 500;
	if (ThreeOrTwoTwo(&Chessmans, opponent, x, y))
		return 250;
	if (TwoOrOneOne(&Chessmans, opponent, x, y))
		return 50;
	if (OneOrZeroZero(&Chessmans, opponent, x, y))
		return 5;
	return 0;
}

bool AIplayer::MyChessman(std::size_t x, std::size_t y)
{
	return Chessmans[x][y][0] != 0;
}


bool AIplayer::Five(std::vector<std::vector<std::vector<int>>>*Opp,
	std::vector<std::vector<std::vector<int>>>*Che,
	std::size_t x, std::size_t y)	//1000
{
	std::pair<std::size_t, std::size_t> pos[4] = {
		{ -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }
	};
	std::size_t CountFoure = 0;
	for (int i = 0; i != 4; ++i){
		if ((*Opp)[x + pos[i].first][y + pos[i].second][i] + 
			(*Opp)[x - pos[i].first][y - pos[i].second][i] + 1 >= 5){
			return true;
		}
		if ((*Opp)[x + pos[i].first][y + pos[i].second][i] +
			(*Opp)[x - pos[i].first][y - pos[i].second][i] + 1 == 4)
			++CountFoure;
	}
	if (CountFoure > 1)
		return true;
	return false;
}

bool AIplayer::FourOrDooubleThree(std::vector<std::vector<std::vector<int>>>*Opp,
	std::vector<std::vector<std::vector<int>>>*Che, 
	std::size_t x, std::size_t y)	//500
{
	std::pair<std::size_t, std::size_t> pos[4] = {
		{ -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }
	};
	std::size_t CountThree = 0;
	for (int i = 0; i != 4; ++i){
		auto lhs = (*Opp)[x + pos[i].first][y + pos[i].second][i];
		auto rhs = (*Opp)[x - pos[i].first][y - pos[i].second][i];
		if (rhs + lhs + 1 == 4 &&
			!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0])
			return true;
		if (rhs + lhs + 1 == 3 &&
			!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0])
			++CountThree;
		if (rhs + lhs + 1 == 4 &&
			(((OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) ||
			(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0]) &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]) ||
			(!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			(OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) ||
			(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]))))
			++CountThree;
	}
	if (CountThree > 1)
		return true;
	return false;
}

bool AIplayer::ThreeOrTwoTwo(std::vector<std::vector<std::vector<int>>>*Opp, 
	std::vector<std::vector<std::vector<int>>>*Che,
	std::size_t x, std::size_t y)	//250
{
	std::pair<std::size_t, std::size_t> pos[4] = {
		{ -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }
	};
	std::size_t CountTwo = 0;
	for (int i = 0; i != 4; ++i){
		auto lhs = (*Opp)[x + pos[i].first][y + pos[i].second][i];
		auto rhs = (*Opp)[x - pos[i].first][y - pos[i].second][i];
		if (rhs + lhs + 1 == 4 &&
			(((OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) ||
			(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0]) &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]) ||
			(!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			(OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) ||
			(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]))))
			return true;
		if (rhs + lhs + 1 == 3 &&
			!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0])
			return true;
		if (rhs + lhs + 1 == 2 &&
			!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0])
			++CountTwo;
		if (rhs + lhs + 1 == 3 &&
			(((OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) ||
			(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0]) &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]) ||
			(!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			(OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) ||
			(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]))))
			++CountTwo;
	}
	if (CountTwo > 1)
		return true;
	return false;
}

bool AIplayer::TwoOrOneOne(std::vector<std::vector<std::vector<int>>>*Opp, 
	std::vector<std::vector<std::vector<int>>>*Che, 
	std::size_t x, std::size_t y)	//100
{
	std::pair<std::size_t, std::size_t> pos[4] = {
		{ -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }
	};
	for (int i = 0; i != 3; ++i){
		auto lhs = (*Opp)[x + pos[i].first][y + pos[i].second][i];
		auto rhs = (*Opp)[x - pos[i].first][y - pos[i].second][i];
		if (rhs + lhs + 1 == 3 &&
			(((OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) ||
			(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0]) &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]) ||
			(!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			(OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) ||
			(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]))))
			return true;
		if (rhs + lhs + 1 == 2 &&
			!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0])
			return true;
	}
	return false;
}

bool AIplayer::OneOrZeroZero(std::vector<std::vector<std::vector<int>>>*Opp,
	std::vector<std::vector<std::vector<int>>>*Che, 
	std::size_t x, std::size_t y)	//5
{
	std::pair<std::size_t, std::size_t> pos[4] = {
		{ -1, 1 }, { 0, 1 }, { 1, 1 }, { 1, 0 }
	};
	for (int i = 0; i != 4; ++i){
		auto lhs = (*Opp)[x + pos[i].first][y + pos[i].second][i];
		auto rhs = (*Opp)[x - pos[i].first][y - pos[i].second][i];
		if (rhs + lhs + 1 == 2 &&
			(((OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) ||
			(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0]) &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]) ||
			(!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			(OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) ||
			(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]))))
			return true;
	}
	return false;
}

std::size_t AIplayer::AliveN(std::vector<std::vector<std::vector<int>>>*Opp,
	std::vector<std::vector<std::vector<int>>>*Che,
	std::size_t x, std::size_t y, std::size_t n)
{
	std::size_t Count = 0;
	std::pair<std::size_t, std::size_t> pos[4] = {
		{ -1, 0 }, { 0, 1 }, { 1, 1 }, { 1, 0 }
	};
	for (int i = 0; i != 4; ++i){
		auto lhs = (*Opp)[x + pos[i].first][y + pos[i].second][i];
		auto rhs = (*Opp)[x - pos[i].first][y - pos[i].second][i];
		if (lhs + rhs + 1 == n &&
			!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0])
			++Count;
	}
	return Count;
}


std::size_t AIplayer::DeathN(std::vector<std::vector<std::vector<int>>>*Opp,
	std::vector<std::vector<std::vector<int>>>*Che,
	std::size_t x, std::size_t y, std::size_t n)
{
	std::size_t Count = 0;
	std::pair<std::size_t, std::size_t> pos[4] = {
		{ -1, 0 }, { 0, 1 }, { 1, 1 }, { 1, 0 }
	};
	for (int i = 0; i != 4; ++i){
		auto lhs = (*Opp)[x + pos[i].first][y + pos[i].second][i];
		auto rhs = (*Opp)[x - pos[i].first][y - pos[i].second][i];
		int llhs = 0, rrhs = 0;
		if (!OutOfBoard(x + 2 * pos[i].first, y + 2 * pos[i].second)&&
			!(*Che)[x + 2 * pos[i].first][y + 2 * pos[i].second][0])
			llhs = (*Opp)[x + 2 * pos[i].first][y + 2 * pos[i].second][i];
		if (!OutOfBoard(x - 2 * pos[i].first, y - 2 * pos[i].second)&&
			!(*Che)[x - 2 * pos[i].first][y - 2 * pos[i].second][0])
			rrhs = (*Opp)[x - 2 * pos[i].first][y - 2 * pos[i].second][i];
		if (rhs + lhs + 1 == n &&
			(((OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) ||
			(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0]) &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]) ||
			(!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			(OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) ||
			(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0]))))
		{++Count; continue;}
		if (lhs == 0 && llhs && llhs + rhs + 1 == n &&
			!OutOfBoard(x + pos[i].first, y + pos[i].second) &&
			!(*Che)[x + pos[i].first][y + pos[i].second][0] &&
			!OutOfBoard(x + (llhs + 2)*pos[i].first, y + (llhs + 2)*pos[i].second) &&
			!(*Che)[x + (llhs + 2)*pos[i].first][y + (llhs + 2)*pos[i].second][0] &&
			!OutOfBoard(x - (rhs + 1)*pos[i].first, y - (rhs + 1)*pos[i].second) &&
			!(*Che)[x - (rhs + 1)*pos[i].first][y - (rhs + 1)*pos[i].second][0])
		{++Count; continue;}
		if (rhs == 0 && rrhs && rrhs + lhs + 1 == n &&
			!OutOfBoard(x + pos[i].first, y + pos[i].second) &&
			!(*Che)[x + pos[i].first][y + pos[i].second][0] &&
			!OutOfBoard(x + (lhs + 1)*pos[i].first, y + (lhs + 1)*pos[i].second) &&
			!(*Che)[x + (lhs + 1)*pos[i].first][y + (lhs + 1)*pos[i].second][0] &&
			!OutOfBoard(x - (rrhs + 2)*pos[i].first, y - (rrhs + 2)*pos[i].second) &&
			!(*Che)[x - (rrhs + 2)*pos[i].first][y - (rrhs + 2)*pos[i].second][0])
		++Count;
	}
	return Count;
}
//不要问我后面 if 里面一坨一坨的是什么鬼。。。我当时就是跟着自己的思维写的判断是否超出棋盘和是否该坐标已经有子。。。后面我有尝试单独放进一个函数里面，，，但是失败了，，，真的太丑了。


食用方法：‘

main.cpp


#include"Game.h"
int main()
{
	
	AIplayer p1("Captian America", "○");	//AI玩家
	//player p1("Captian America", "○");	//对战玩家
	player p2("Iron Man", "●");
	Game game(&p1,&p2);
	
	game.StartGame();

	return 0;
}


大概就是这样子。没有去专门学习AI算法，自己跟着想法简单写的，比较丑。




Hophan
关注
专栏目录
简易五子棋游戏(控制台版)
Amo Xiang的博客
03-24 2373
目录1. 需求分析2. 游戏设计2.1 游戏功能结构2.2 游戏业务流程3. 代码3.1 初始化棋盘3.2 打印棋盘3.3 打印胜利棋盘及玩家3.4 五子棋算法3.5 完整代码4. 总结 最近在阅读一本Python书籍的时候，发现其中有一个简易五子棋游戏(控制台版本)，还挺有意思也比较贴近我们的生活，故将其布置成作业给学生。但是因为书中给的源代码中有些比较复杂，并且代码注释存在错误，故我自己重写了...
c++小游戏 五子棋、数独、贪食蛇等
04-28
多个c++小游戏.1.1题目要求 利用Microsoft Visual C++制作一个贪吃蛇的小游戏，要求： （1）应用MFC单文档制作 （2）能够记录游戏时间，游戏成绩 （3）可暂停/继续并在玩家不愿游戏时停止游戏 （4）蛇的身体能够随着蛇的长度变色 （5）能够显示英雄榜 （6）有背景音乐和音效 1.1.2选题背景 贪吃蛇是家喻户晓的益智类小游戏，选择这个题目一是为了将自己的所学知识加以运用，二是一直以来贪吃蛇这个游戏就深深地吸引着我，它的制作方法对于以前的我而言都是很神秘的。我希望通过自己的所学知识把它剖析开来，真真正正的了解它的本质和精髓。虽然我的编程能力不是很强，但是我有信心，在这次学习中我将从实践和实际的项目中提高自己的编程能力。因此我选定了这个题目。
简单的控制台五子棋游戏
李忠文的专栏
03-29 1308
      利用二维数组实现的简单的控制台五子棋游戏，程序中没有添加电脑的AI。     import java.io.*;import java.util.*;public class Gobang { //定义一个二维数组来充当棋盘 private static String [][] board; //定义棋盘的大小 private static final
Python五子棋游戏源代码源程序
Python代码大全
06-02 1万+
五子棋游戏，我们将游戏分为两个方面：一个是棋盘，另一个是棋子，利用横线和纵线将棋盘分成一个个小方格，当黑子或者白子形成5个棋子连线时，显示胜利者，游戏结束。本程序难点在于确定胜利条件。 import pygame as pg class Chessboard: # 设置棋盘 def __init__(s): s.grid_lenght = 26 #棋盘格子的边长 s.grid_count = 20
小游戏之五子棋
不落风渊的博客
08-08 281
简单的双人五子棋，在终端运行，通过输入坐标选择落子的位置。 源代码： #include #define MAX 100 #define X 9 //行数 #define Y 10 //列数 #define WIN 1 //胜利标志 #define FAIL 0 int flag = 0; int count = 0; //棋子步数 char tmpch[MAX]; //打印棋
一个简单的控制台五子棋小游戏
whlikect的博客
03-18 232
import java.io.BufferedReader; import java.io.InputStreamReader; /** *五子棋游戏 */ public class Playgame{ private final int WIN_COUNT=5; //坐标 private int posX=0,posY=0; //棋盘 private Chessboard chessb...
一个java控制台小游戏（五子棋）.zip
最新发布
06-19
该资源内项目源码是个人的课程设计、毕业设计，代码都测试ok，都是运行成功后才上传资源，答辩评审平均分达到96分，放心下载使用！ ## 项目备注 1、该资源内项目代码都经过测试运行成功，功能ok的情况下才上传的，请...
python打印五子棋棋盘的两种方法
m0_62691269的博客
09-18 8454
五子棋是一种由双人对弈的纯策略型棋类游戏，它使用的棋盘一般由横纵等距的各15条平行线构成，这些线垂直交叉形成的225个交叉点为对弈双方的落子点。本实例要求编写代码，实现按用户要求打印指定大小的五子棋棋盘的程序。（需要用到的制表符：┌ ┬ ┐ ├ ┼ ┤ └ ┴ ┘） 思路1：将棋盘大致分为三部分，分别为第一行，第十五行和其余行，再在每行进行操作 思路2：本方法主要应用if语句(老师布置的if语句作业)，先打印棋盘的特殊的位置，分别为四个角和四个边，最后打印棋盘内的+ 代码1: #┌ ┬ ┐ ├ ┼
java学习笔记（十一）java版五子棋
yang_yi_yun的博客
04-11 927
前面我们学习了一维数组和二维数组，我们通过二维数组来制作一个游戏，五子棋。 分析: 棋盘： 首先五子棋需要一个棋盘，我们得想办法首先输出一个棋盘，我们通过分割发现，棋盘都是由很多个加号组成的，所以我们可以定义一个二维数组，然后把二维数组的每一个元素赋值为+号，通过输出我们发现这个加号效果其实并不好，所以我们采用输入法中的制表符中的加号。 以搜狗输入法为例： 我们通过输出发现其实效果还是不是太好，这时我们就需要调整eclipse中的字体，改为宋体： 我们首先点击eclipse上方的windo.
Python打印五子棋棋盘
热门推荐
宏远小七的博客
10-10 2万+
Python打印五子棋棋盘要求思路代码运行结果 要求 五子棋是一种由双人对弈的纯策略型棋类游戏，它使用的棋盘一般由横纵等距的各15条平行线构成，这些线垂直交叉形成的225个交叉点为对弈双方的落子点。本实例要求编写代码，实现按用户要求打印指定大小的五子棋棋盘的程序。（需要用到的制表符：┌ ┬ ┐ ├ ┼ ┤ └ ┴ ┘） 这是我Python的一个小作业，我比较懒，让我室友上网搜相应的代码，发现几乎没有符合要求的，所以我就自己写了一个。 思路 我把整个表分为3部分：第1行为第一部分；第2到14行为第二部分
五子棋棋盘实现
总理同学的编程尝试
06-15 3036
最近写了一个对抗搜索 + α\alphaα-β\betaβ剪枝的下五子棋的“人工智障”，贴个代码，头文件在下面： Gobang.cpp at 2019.6.8 效果大概就是这样，此图是AI对战AI时的效果图。 #include "winshow.cpp" #include "cursorope.cpp" //#include <algorithm> //using namespac...
python实现五子棋游戏（控制台版）
King博客
01-03 5813
一、简介 　　使用python实现控制台版的五子棋游戏； 　　环境：Windows系统+python3.8.0 　　游戏规则： 　　　　1.分两位棋手对战，默认*棋手先下；当按照提示输入坐标（A1），并按回车键<Enter>即可在棋盘上显示下的棋（*）； 　　　　2.自动切换到o棋手下棋，当按照提示输入坐标（C1），并按回车键<Enter>即可在棋盘上显示下的棋（...
python简单网格五子棋_python控制台简单实现五子棋
weixin_39852647的博客
11-25 188
#棋盘#落子#规则import randomclass chess:def __init__(self):print('#---------------棋盘----------------#')self.grid = []self.si = []for i in range(8):self.grid.append([' □ ']*8)for j in range(8):print(''.join...
Qt 游戏开发(06) - 为游戏增加健康值和得分
wangrl的博客
01-23 2094
之前写的文章中，大多数属于贴代码的类型，经过一段时间后，自己对于代码的理解并没什么什么裨益，反而让自己觉得写代码就是贴代码，丧失很多兴趣，水平也得不到提高。在看过那么多大牛写的文章之后，也决心结合自己的长处开始写些比较好的文章。 　　闲话少说，此文章是之前C++ Qt Game Tutorial的续集，只是把标题换成更中文一些。 1. 新建一个widget工程，工程名字为tutorial６，删
超级简单五子棋小游戏(含代码）
小王的博客
08-22 3658
五子棋简单功能实现 游戏功能演示 代码如下： #include <stdio.h> #include <stdlib.h> #include <stdbool.h> #include <getch.h> // 棋盘 char board[15][15]; // 棋子坐标 char kx = 7 , ky = 7; // 角色 char role = '@'; // 显示棋盘 void show_board(void) { system("clear");
【C语言编程】在Linux终端用C语言编程实现五子棋（附代码）
weixin_48994377的博客
07-16 3236
今天分享一波用C语言在Linux环境中编写五子棋程序的代码。 首先，实现五子棋，分为两个部分： 需要的数据： 1、定义棋盘数组 2、定义变量用于记录棋子位置 3、定义角色变量 业务逻辑： 是否需要对数据进行初始化 for(;;) { 1、清理屏幕，显示棋盘 2、落子 坐标要合法，原位置...
前端实现五子棋小游戏1（本地双人对战）
weixin_44584059的博客
08-22 1422
运用canvas写一个本地五子棋小游戏HTML部分JS 部分CSS 部分实现效果 HTML部分 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta name="viewport" content="width=device-width, initial-scale=1.0"> <title>五子棋小游戏</title&g
Cocos2d-x学习笔记三之飞机游戏详解之GameScene类的讲解
尘墨
09-14 1038
上次给大家介绍了GameMenu类和GameManager类，这次是个大家介绍GameScene类   GameScene类是生成游戏窗口的类。游戏窗口占据了这个Demo中大部分的代码，下面我们来逐一介绍它。   首先来看看类的头文件。这个类的头文件和前面讲的类的头文件基本一致，GameScene类继承了CCLayer，只有一个初始化的方法和一个返回CCScene对象的方法，看起来非常简单
C++实现的控制台五子棋小游戏
"控制台五子棋是一款基于C++编程语言实现的简单五子棋游戏。这个游戏代码在控制台上运行，玩家与计算机进行对弈。代码中包含了游戏的基本逻辑，如计算机智能算法、棋盘状态判断等。" 在这个五子棋游戏中，主要涉及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值