网络版五子棋

最新推荐文章于 2021-08-15 17:13:04 发布
最新推荐文章于 2021-08-15 17:13:04 发布
阅读量3k 收藏 14
点赞数 5
分类专栏： Linux操作系统
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/chaxiang225/article/details/82559866
版权

初学期间，在校学习了三子棋的编写，在学习网络编程之后，趋于兴趣，又实现了单机版的五子棋，之后就试图实现网络版五子棋，实现跨机对战。

我在单机版的五子棋上加入了socket，建立c/s/模型进行网络编程，然后实现客户端和服务器端的坐标数据互通，在数据互通之前在自己的终端下进行一系列判断，将合法的坐标传输至对方客户端，然后同时落子，双方同步落子，以此实现了最简单的双人网络版五子棋。

client.c

#include <stdio.h> 
#include <arpa/inet.h> 
#include <stdlib.h> 
#include <sys/types.h>           
#include "game.h" 
#include <sys/socket.h> 
#include <arpa/inet.h> 
#include <sys/types.h>   
#include <netinet/in.h> 
#include <string.h> 
#include <unistd.h> 
void SocketCommon(int sock, struct sockaddr_in* server) 
#include <stdlib.h> 
void Menu() 
{ 
    char buf[1024]; 
    struct sockaddr_in peer; 
    while(1) 
    { 
        socklen_t len = sizeof(peer); 
        printf("Please Enter# \n"); 
        fflush(stdout); 
        ssize_t s = read(0,buf,sizeof(buf)-1); 
        if(s > 0) 
        { 
            buf[s-1] = 0; 
            sendto(sock,buf,strlen(buf),0,(struct sockaddr*)server,sizeof(*server)); 
            ssize_t _s = recvfrom(sock,buf,sizeof(buf)-1,0,(struct sockaddr&peer,&len); 
            if(_s > 0) 
            { 
                buf[_s] = 0; 
                printf("server echo# %s\n",buf); 
            } 
    printf("==================================\n"); 
    printf("||  1.开始游戏   0.退出游戏     ||\n"); 
    printf("==================================\n"); 
} 
void Game(int sock) 
{ 
    Point point_server,point_client; 
    char board[ROWS][COLS]; 
    InitBoard(board,ROWS,COLS); 
    PrintBoard(board,ROWS,COLS); 
    ssize_t s; 
    int x,y; 
    while(1){ 
        printf("请下子(输入坐标)> "); 
        scanf("%d%d",&x,&y); 
        point_client.row = x-1; 
        point_client.col = y-1; 
        ClientMove(board,&point_client);         
        PrintBoard(board,ROWS,COLS);         
        write(sock,(void*)&point_client,sizeof(point_client)); 
        if(GameState(board,&point_client) == 'X') 
        { 
            printf("You win!\n"); 
            break; 
        } 
        else if(GameState(board,&point_client) == 'p') 
        { 
            printf("平局!\n"); 
            break; 
        } 
        s = read(sock,(void*)&point_server,sizeof(point_server)); 
        if(s == 0) 
        { 
            printf("Server quit\n"); 
            return; 
        } 
        ServerMove(board,&point_server); 
        PrintBoard(board,ROWS,COLS); 
        if(GameState(board,&point_server) == 'O') 
        { 
            printf("Server win!\n"); 
            break; 
        } 
        else if(GameState(board,&point_server) == 'p') 
        { 
            printf("平局!\n"); 
            break; 
        } 
    } 
} 
int main(int argc, char* argv[]) 
{ 
    if(argc < 3) 
    if(argc != 3) 
    { 
        perror("argc"); 
        printf("Usage: ./server [ip] [port]\n"); 
        exit(1); 
    } 
    //创建 socket 文件描述符 
    //AF_INET    ipv4地址类型 
    //SOCK_DGRAM udp类型 
    //0          默认使用SOCK_DGRAM类型 
    int sock = socket(AF_INET,SOCK_DGRAM,0);      
    int sock = socket(AF_INET,SOCK_STREAM,0); 
    if(sock < 0) 
    { 
        perror("socket"); 
        exit(2); 
        exit(1); 
    } 
    struct sockaddr_in server; 
    server.sin_family = AF_INET;//ipv4地址类型 
    server.sin_port = htons(atoi(argv[2]));//端口号 
    server.sin_addr.s_addr = inet_addr(argv[1]);//ipv4地址转换 因为输入的是点分十进制  
    struct sockaddr_in client; 
    client.sin_family = AF_INET; 
    client.sin_addr.s_addr = inet_addr(argv[1]); 
    client.sin_port = htons(atoi(argv[2])); 
    int ret = connect(sock,(const struct sockaddr*)&client,sizeof(client)); 
    if(ret < 0) 
    { 
        perror("connect"); 
        exit(2); 
    } 
    Menu(); 
    int state; 
    while(1) 
    { 
        printf("请做出你的选择> "); 
        scanf("%d",&state); 
        if(state == 1) 
        { 
            Game(sock); 
        }else if(state == 0) 
        { 
            break; 
        } 
        else 
        { 
            printf("选择错误\n"); 
            Menu(); 
            sleep(2); 
        } 
    } 
    SocketCommon(sock,&server); 
    close(sock); 
    return 0; 
}

game.c

#include<stdio.h>
#define ROWS 11
#define COLS 13
struct Point
{
	int row;
	int col;
};
//初始化棋盘
void InitBoard(char board[ROWS][COLS])
{
	memset(board, ' ', ROWS*COLS*sizeof(char));//每个坐标的初始值我用空格代替
}
//打印棋盘
void PrintBoard(char board[ROWS][COLS])//打印棋盘
{
	int  i = 0;
	printf("   ");
	for (i = 1; i < COLS; i++)
		printf(" %2d ",i);
	printf(" %2d \n",i);
	for (i = 0; i < ROWS; i++)
	{
		printf("%2d ", i + 1);
		int j = 0;
		int col = COLS;
		for (; j < COLS; j++)
		{
			if (j == COLS - 1)
			{
				printf(" %c \n", board[i][j]);
				if (i != ROWS - 1){
					printf("   ");
					while (--col)
						printf("---|");
					printf("---\n");
				}
				break;
			}
			printf(" %c ", board[i][j]);
			printf("|");
		}

	}
}
//判断棋盘是否满了 
int IsFall(char board[ROWS][COLS])
{
	size_t i = 0;
	for (; i < ROWS; i++)
	{
		size_t j = 0;
		for (; j < COLS; j++)
		{
			if (board[i][j] == ' ')
				return 0;
		}
	}
	return 1;
}
//落子
void Move(char board[ROWS][COLS],struct Point* point, char ch)
{
	if (point == NULL)
	{
		return;
	}
	int x = point->row;
	int y = point->col;
	//如果棋盘满了的话就退出循环，也就是不能再落子了
	while (1)
	{
		if (x >= 0 && x < ROWS && y >= 0 && y < COLS){
			if (board[x][y] == ' ')
			{
				board[x][y] = ch;
				point->row = x;
				point->col = y;
				break;
			}
			else
			{
				printf("该坐标已落子,请重新输入坐标: ");
				scanf("%d%d", &x, &y);
				x--;
				y--;
			}
		}
		else{
			printf("坐标输入有误,请重新输入坐标: ");
			scanf("%d%d", &x, &y);
			x--;
			y--;
		}
	}
}
//列齐 
int Cols(char board[ROWS][COLS], struct Point* point)
{
	int x = point->row;
	int y = point->col;
	int count = 1;
	while (x - 1 >= 0)
	{
		if (board[x][y] != board[x - 1][y])
			break;
		count++;
		if (count == 5)
		{
			//如果往上遍历已经够了五个，说明已经赢了，直接返回 
			return count;
		}
		x--;
	}
	//到这里说明当前点往上走是不满足条件的 
	//但是已经走到了最上面的点，所以从临界点往相反方向找 
	//必须要找到五个连续的才算满足条件 
	count = 1;//count 重新被设定为1 
	while (x + 1 <= ROWS)
	{
		if (board[x][y] == board[x + 1][y])
		{
			count++;
			if (count == 5)
			{
 		 		return count;
			}
			x++;
		}
		else
		{
			//n 代表当前状态未满足赢的条件 
			return 0;
		}
	}
	return 0;
}
//行齐 
int Rows(char board[ROWS][COLS], struct Point* point)
{
	int x = point->row;
	int y = point->col;
	int count = 1;
	while (y - 1 >= 0)
	{
		if (board[x][y] != board[x][y - 1])
			break;
		count++;
		if (count == 5)
		{
			//如果往左遍历已经够了五个，说明已经赢了，直接返回 
			return count;
		}
		y--;
	}
	//到这里说明当前点往左走是不满足条件的 
	//但是已经走到了最左面的点，所以从临界点往相反方向找 
	//必须要找到五个连续的才算满足条件 
	count = 1;//count 重新被设定为1 
	while (y + 1 <= COLS)
	{
		if (board[x][y] == board[x][y + 1])
		{
			count++;
			if (count == 5)
			{
				return count;
			}
			y++;
		}
		else
		{
			//n 代表当前状态未满足赢的条件 
			return 0;
		}
	}
	return 0;
}
//左上到右下的对角线 
int UpLeft(char board[ROWS][COLS], struct Point* point)
{
	int x = point->row;
	int y = point->col;
	int count = 1;
	while (x - 1 >= 0 && y - 1 >= 0)
	{
		if (board[x][y] != board[x - 1][y - 1])
			break;
		count++;
		if (count == 5)
		{
			//如果往左上遍历已经够了五个，说明已经赢了，直接返回 
			return count;
		}
		x--;
		y--;
	}
	//到这里说明当前点往左上走是不满足条件的 
	//但是已经走到了最左上的点，所以从临界点往相反方向找 
	//必须要找到五个连续的才算满足条件 
	count = 1;//count 重新被设定为1 
	while (x + 1 <= ROWS && y + 1 <= COLS)
	{
		if (board[x][y] == board[x + 1][y + 1])
		{
			count++;
			if (count == 5)
			{
				return count;
			}
			x++;
			y++;
		}
		else
		{
			//n 代表当前状态未满足赢的条件 
			return 0;
		}
	}
	return 0;
}
//右上到左下的对角线 
int UpRight(char board[ROWS][COLS],struct Point* point)
{
	int x = point->row;
	int y = point->col;
	int count = 1;
	while (x - 1 >= 0 && y + 1 <= COLS)
	{
		if (board[x][y] != board[x - 1][y + 1])
			break;
		count++;
		if (count == 5)
		{
			//如果往右上遍历已经够了五个，说明已经赢了，直接返回 
			return count;
		}
		x--;
		y++;
	}
	//到这里说明当前点往右上走是不满足条件的 
	//但是已经走到了最右上面的点，所以从临界点往相反方向找 
	//必须要找到五个连续的才算满足条件 
	count = 1;//count 重新被设定为1 
	while (x + 1 <= ROWS && y - 1 <= COLS)
	{
		if (board[x][y] == board[x + 1][y - 1])
		{
			count++;
			if (count == 5)
			{
				return count;
			}
			x++;
			y--;
		}
		else
		{
			//n 代表当前状态未满足赢的条件 
			return 0;
		}
	}
	return 0;
}
//返回游戏进行状态/平局/输赢/正在进行// 
char Iswin(char board[ROWS][COLS], struct Point* point)
{
	if (point == NULL)
	{
		return 'e';
	}
	//判断当前点所在列是否是连续五个子儿 
	if (Cols(board, point) == 5)
	{
		return board[point->row][point->col];
	}
	//判断当前点所在行是否是连续五个子儿 
	else if (Rows(board, point) == 5)
	{
		return board[point->row][point->col];
	}
	//判断当前点所在左上与右下的对角线是否满足条件 
	else if (UpLeft(board, point) == 5)
	{
		return board[point->row][point->col];
	}
	//判断当前点所在左上与右下的对角线是否满足条件 
	else if (UpRight(board, point) == 5)
	{
		return board[point->row][point->col];
	}
	else if (IsFall(board))
	{
		//平局 
		return 'p';
	}
	//当前没有输赢，继续游戏 
	return 'g';
}

server.c

#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <string.h> 
#include <arpa/inet.h> 
#include <sys/types.h>           
#include "game.h" 
#include <sys/socket.h> 
#include <arpa/inet.h> 
#include <sys/types.h>   
#include <netinet/in.h> 
void SocketCommon(int sock) 
{ 
    char buf[1024]; 
    struct sockaddr_in client; 
    while(1) 
    { 
        socklen_t len = sizeof(client); 
        ssize_t s = recvfrom(sock,buf,sizeof(buf)-1,0,(struct sockaddr*)&client,&len); 
        if(s > 0) 
        { 
            buf[s] = 0; 
            printf("[%s:%d]:%s\n",inet_ntoa(client.sin_addr),nto(client.sin_port),buf); 
            fflush(stdout); 
            sendto(sock,buf,strlen(buf),0,(struct sockaddr*)&client,sizeof(client)); 
        } 
    } 
} 
int main(int argc, char* argv[]) 
{ 
    if(argc < 3) 
    if(argc != 3) 
    { 
        perror("argc"); 
        printf("Usage: ./server [ip] [port]\n"); 
        exit(1); 
    } 
    //创建 socket 文件描述符 
    //AF_INET    ipv4地址类型 
    //SOCK_DGRAM udp类型 
    //0          默认使用SOCK_DGRAM类型 
    int sock = socket(AF_INET,SOCK_DGRAM,0);      
    int sock = socket(AF_INET,SOCK_STREAM,0); 
    if(sock < 0) 
    { 
        perror("socket"); 
        exit(2); 
        exit(1); 
    } 
 
    struct sockaddr_in local; 
    local.sin_family = AF_INET;//ipv4地址类型 
    local.sin_port = htons(atoi(argv[2]));//端口号 
    local.sin_addr.s_addr = inet_addr(argv[1]);//ipv4地址转换 因为输入的是点分十进制 
    struct sockaddr_in server; 
    server.sin_family = AF_INET; 
    server.sin_addr.s_addr = inet_addr(argv[1]); 
    server.sin_port = htons(atoi(argv[2])); 
 
    if(bind(sock,(const struct sockaddr*)&local,sizeof(local)) < 0) 
    int ret = bind(sock,(const struct sockaddr*)&server,sizeof(server)); 
    if(ret < 0) 
    { 
        perror("bind"); 
        exit(2); 
    } 
    ret = listen(sock,5); 
    if(ret < 0) 
    { 
        perror("listen"); 
        exit(3); 
    } 
 
    SocketCommon(sock); 
    for(;;) 
    { 
        struct sockaddr_in client; 
        socklen_t len; 
        int client_sock = accept(sock,(struct sockaddr*)&client,&len); 
        if(client_sock < 0) 
        { 
            continue; 
        } 
        ssize_t s; 
        Point point_server,point_client; 
        char board[ROWS][COLS]; 
        InitBoard(board,ROWS,COLS); 
        int x,y; 
        while(1){ 
            s = read(client_sock,(void*)&point_client,sizeof(point_client)); 
            if(s == 0) 
            { 
                printf("Client quit...\n"); 
                close(client_sock); 
            } 
            ClientMove(board,&point_client); 
            PrintBoard(board,ROWS,COLS); 
            if(GameState(board,&point_client) == 'X') 
            { 
                printf("Client win!\n"); 
                break; 
            } 
            else if(GameState(board,&point_client) == 'p') 
            { 
                printf("平局!\n"); 
                break; 
            } 
            printf("请下子(输入坐标)> "); 
            scanf("%d%d",&x,&y); 
            point_server.row = x-1; 
            point_server.col = y-1; 
            ServerMove(board,&point_server); 
            PrintBoard(board,ROWS,COLS); 
            write(client_sock,(void*)&point_server,sizeof(point_server)); 
            if(GameState(board,&point_client) == 'O') 
            { 
                printf("You win!\n"); 
                break; 
            } 
            else if(GameState(board,&point_client) == 'p') 
            { 
                printf("平局!\n"); 
                break; 
            } 
          }//游戏下完了 
    } 
    close(sock); 
    return 0;
}

 

I_Mokgers
关注
  • 5
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言实现简单网络版五子棋(服务器与客户端)
IT_xiaoye的博客
05-20 6617
本小游戏是在Linux下实现的(因为我不会Windows网络编程)，这次实现的仅仅是服务器与客户端之间进行互动，彼此只要互相发送下点的坐标就ok，用结构体存放坐标，各自收到坐标后进行下子，以及判断结果。 本篇文章里只涉及部分代码，更多是步骤介绍，实现方法以及思路 源码在这里()-&amp;gt;https://github.com/Xiaoyejun/learngit/commit/44caec515...
RTP封装，UDP发送并用wireshark抓rtp包
weixin_43665091的博客
11-28 865
1. 先上code 客户端： #include <stdio.h> #include <stdlib.h> #include <sys/types.h> #include <sys/socket.h> #include <sys/time.h> #include <arpa/inet.h> #include <netin...
项目——网络对战五子棋（Web-Gobang）
zw的博客
08-15 2298
目录项目开发背景项目需求 & 开发环境项目设计 & 项目难点功能实现 & 难点解决1. 用户登录 / 注册2. 项目难点解决 项目源码：https://github.com/mxzw/Project/tree/main/webgobang-project/src 项目开发背景 小时候，闲来无事最喜欢和别人玩的游戏之一就是五子棋了，它规则简单，但却玩法多变，直到现在我还时不时的在手机上和别人在线对战。最近自己学习Linux方面的相关知识，学习了多线程和Socket编程，并对网络这块
五子棋网络版五子棋网络版
05-20
五子棋 网络版 采用C/S模式编写五子棋 网络版 采用C/S模式编写五子棋 网络版 采用C/S模式编写
网络五子棋的实现 需求分析
buchuankaqise的博客
01-27 6088
1. 绪论  用java语言多线程机制和socket来处理客户端与服务器端的信息交互，实现两个下棋者的网络对战通信，发送聊天信息。 2. 总体功能要求 2.1 基本需求分析 整个软件的界面简洁且明了，各个功能区的分隔清晰 软件操作容易上手，功能按钮名称易懂 棋盘大小、棋子大小合适 2.2 高级需求分析     本次需要实验
java网络版五子棋
04-19
【Java网络版五子棋】项目是一个典型的网络编程与游戏开发的结合实例，适用于初学者进行实战练习。这个项目的核心是实现两个玩家通过网络连接进行实时的五子棋对弈。下面将详细介绍该项目中的关键知识点。 1. **...
[Unity-3d] 联网五子棋~~
Eddie_Peng的博客
06-26 6809
联机版五子棋 这次的作业花了我好长好长的时间…其实实现联机版的小游戏说难不难，然而我也只能说…没那么简单吧…OwO 话不多说，来看一看这次联机版五子棋的实现吧。 左边为host，右边为client 1. 创建联网环境 1）NetworkManager 网络控制器设置 第一步是在项目中创建 NetworkManager 对象：从菜单 Game Object -&gt; Create...
java版五子棋
12-20
java版五子棋，界面美观，很实用，适合初学者借鉴
五子棋联网版
05-27
用于网络对战，界面有点不好看，但是挺有趣的，可以自己学着做五子棋
网络版五子棋源码
07-13
上传源码为游戏开发者和java初学者学习
网络版五子棋游戏
05-11
功能：系统基于QT集成开发环境，基于socket编程，实现了玩家对战、邀请好友等基本功能，数据存储以I/O操作存在本地文件等功能，以开发进度实现四个版本，字符版、图形界面版、人机对战版和嵌入式版本，详细内容见后图源码列表。 集成开发环境：QT 基本语言：C/C++ 操作系统：Linux 技术：socket网络编程
java 联网版五子棋
elena250的博客
08-23 5595
最近学习了Java的多线程和网络编程后，利用相关知识写了一个简单的联网版五子棋小游戏，客户端和服务器就是两个玩家，实现了下棋、判断输赢和聊天的功能。 具体代码如下： public class clientChess { private static myFrame frame=null; public clientChess(myFrame frame) { this.frame=fram...
网络五子棋的实现 设计
buchuankaqise的博客
01-27 2845
1.开发环境 Windows10 JDK1.8 IntelliJIDEA 2.概要设计 根据需求分析，本系统的实现主要用到两个大类： Client：主要用于产生游戏客户端 Server：主要用于服务器端的生成 2.1 网络编程模式的选取  本系统根据需求选取了基于C/S（客户机/服务器）模式，主要是因为C/S模式下的程序具有
基于Java编写的网络五子棋
一点的博客
11-21 9072
需求分析： 对于网络五子棋而言，在普通五子棋的基础上需要添加以下功能： 1.拥有服务器端和客户端，用户通过客户端登录服务器后可与其他登录的用户进行对弈 2.服务器支持多组用户同时进行对弈 3.用户可以在服务器上创建新游戏或加入已创建的游戏 4.用户在下棋的时候可以进行聊天交流 由上可以知道需要实现的功能： ·提供服务器和客户端的功能 ·服务器将监听客户端的登录情况并允许多个客户端进
网络编程异步五子棋游戏
u010669765的专栏
06-06 2830
一． 实验要求       参考教材第五章第2个游戏程序，按以下要求进行改编，要求如下：       1）将游戏改为双方对弈，而不是系统自动下棋；       2）修改游戏规则，如五子棋的游戏规则；    3）同步改异步； 二． 设计思路 1.首先，本次实验主要是修改性的实验，所以思路的第一步，就是看懂原有代码的结构，并对新代码的结构进行分析，分析如下 （1）服务器负责提供多个游戏桌
用C++写的项目五子棋（单机，不涉及网络版本）
七夜
08-19 1105
#include #include using namespace std; class qipan { public: qipan() {} ~qipan() {}; //向上下左右，斜的方向 char left(int x, int y) {//检查是否合适 if (x >= 1 && x = 1 && y - 1 <= width) { return q[x]
网络对战五子棋(附带源码，可以直接下载使用)
流云
07-06 3640
五子对战

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值