联机版贪吃蛇

最新推荐文章于 2023-07-14 17:43:42 发布
最新推荐文章于 2023-07-14 17:43:42 发布
阅读量2.8k 收藏 23
点赞数 9
分类专栏： 游戏 文章标签： socket select c++ pthread easyx
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40571533/article/details/120552942
版权

文章目录

概述

突然发现我的贪吃蛇还没有联机，补一个简单的联机版贪吃蛇程序。

主要实现要求

服务器的用户链接逻辑（主循环）和游戏运行逻辑（n个线程中），维护一个客户信息vector和一个对局信息map。
一个对局可以有两个用户（再多加的用户可以拓展成观战，有机会再搞吧），当链接进来两个用户同一个房间，就从vector移走信息，放入对局中，开启一个线程，持续提供服务。
客户端连上服务器之后只有两件事，接受键盘消息（并且给服务器发送自己的操作），接受服务器消息（显示画面）。并没有任何游戏逻辑的判断。

实现效果

重复登陆：
在这里插入图片描述
两人对局：
在这里插入图片描述
第三人加入：
在这里插入图片描述

服务器

首先要熟悉select网络模型。

客户信息

主要是socket（唯一标识）和对局id（进入对局标识）两个属性。
在对象析构的时候会自动断开链接。

struct Client
{
	explicit Client(SOCKET sock) : sock(sock)
	{
		strcpy(this->userName, "");
		code = 0;
	}

	Client(SOCKET sock, const char *userName, const sockaddr_in *addr)
	{
		this->sock = sock;
		strcpy(this->userName, userName);
		this->addr = *addr;
		code = 0;
	}

	~Client()
	{
		if (sock != INVALID_SOCKET)
		{
			close(sock);
		}
	}

	SOCKET sock;						// 服务器socket
	int code;							// 对局id
	char userName[USER_NAME_LENGTH];	// 用户名
	sockaddr_in addr;					// 用户地址
	int lastPos;						// 消息缓冲区的数据尾部位置
	char szMsgBuf[MSG_BUFFER_LENGTH];	// 第二缓冲区 消息缓冲区
};

客户信息管理

使用一个vector来管理client，并且使用智能指针shared_ptr，在转移到对局的时候只要指针拷过去就行了。
其中可能ChangeClientName一开始看的时候有点问题，因为用户在链接进来的时候，服务器并不知道用户的name，所以没办法在一初始化的时候就设定name。
调用RemoveOne将client移出vector后，如果client没加入对局（这种情况 应该不会发生）或者加入对局还没开始（等对局也删除），就会断开链接。

class ClientManager
{
public:

	// 添加一个客户端
	void Add(SOCKET sock, const char *userName, const sockaddr_in *addr);

	// 移除一个客户端 但是链接不一定会断
	void RemoveOne(SOCKET sock);

	// 添加所有客户端到 可读集合中
	void SetAllRead(fd_set &fdRead, SOCKET &maxSock);

	// 获取所有可读客户端
	void GetAllRead(fd_set &fdRead, std::vector<std::shared_ptr<Client>> &read);

	// 修改客户端名称
	std::shared_ptr<Client> ChangeClientName(SOCKET sock, const char *userName);

	// 打印数据
	void Dump();

private:
	std::vector<std::shared_ptr<Client>> clients;	// 客户端socket
	
};

对局信息

一个对局有两个玩家（扩展了观战就会增加），一个线程，和一个游戏数据。

struct Table
{
	std::shared_ptr<Client> playerA;		// 玩家A
	std::shared_ptr<Client> playerB;		// 玩家B
	bool start;								// 开启对局
	pthread_t tid;							// 线程id
	Snake snake;							// 贪吃蛇数据
};

对局管理

使用一个map来管理对局，code为对局的唯一标识。
因为map会有多个线程存取，所以操作需要加锁。

class TableManager
{
public:

	TableManager()
	{
		pthread_mutex_init(&mutex, NULL);
	}

	~TableManager()
	{
		pthread_mutex_destroy(&mutex);
	}

	// 加入对局 分为：不存在对局、对局有一个人、对局有两个人（可扩展）
	int Add(int code, std::shared_ptr<Client> player);

	// 得到对局 传入code不对可能有异常
	Table& GetTable(int code);

	// 删除对局
	void RemoveOne(int code);

	// 打印数据
	void Dump();

private:
	std::map<int, Table> tables;	// 对局
	pthread_mutex_t mutex;			// 互斥锁
	
};

贪吃蛇数据

有一个地图，两个玩家的坐标和偏移方向。
如果一帧（这里设定1s，主要为了测试游戏）玩家没有任何操作，就朝着偏移方向前进。
死亡规则是碰到除了空以外的物体，如果两个玩家一起死亡就是平局。
说明一下本来贪吃蛇是不能回头的，这里可以回头但是会直接死亡。

class Snake
{
private:

    struct Point
    {
        Point(int x = 0, int y = 0) : x(x), y(y) {}

        bool operator==(const Point &p)
        {
            return x == p.x && y == p.y;
        }

        int x;
        int y;
    };

    uint8_t world[WIDTH][HEIGHT];	// 游戏区
    Point playerA;			        // 游戏者 A 的坐标
    Point playerB;			        // 游戏者 B 的坐标
    Point offsetA;				    // 游戏者 A 的移动偏移方向
    Point offsetB;				    // 游戏者 B 的移动偏移方向

public:

    Snake() { Init(); }

    // 初始化游戏
    void Init();

    // 处理命令
    void DealCmd(int cmd);

    // 处理游戏逻辑
    // 返回值 0 -- 正常游戏
    //       1 -- A死亡
    //       2 -- B死亡
    //       3 -- 都死亡
    int DealGame();

    // 拷贝地图
    void copyWord(uint8_t world[WIDTH][HEIGHT]);

};

游戏服务器

单例

单例使用了c++11的静态局部对象。

class Server : public ServerNet
{
private:
。。。
    static Server *g_pSingleton;		// 唯一单实例对象指针
。。。

public:

	// 获取单实例对象
    static Server &GetInstance()
	{
		// 局部静态特性的方式实现单实例
		static Server server;
		g_pSingleton = &server;
		return server;
	}

	// 获取客户端
	static ClientManager& GetClientManager()
	{
		return g_pSingleton->clientManager; 
	} 

	// 获取对局
	static TableManager& GetTableManager()
	{
		return g_pSingleton->tableManager;
	}

private:
    // 禁止外部构造
	Server() {}

	// 禁止外部析构
	virtual ~Server() {}

    // 禁止外部复制构造
    Server(const Server &server);

    // 禁止外部赋值操作
    const Server &operator=(const Server &server);

};

登陆相关操作

bool Server::OnRun()
{
    if (IsRun())
    {
        fd_set fdRead;					// 描述符（socket） 集合
        FD_ZERO(&fdRead);				// 清理集合
        FD_SET(serverSock, &fdRead);	// 将描述符（socket）加入集合

        // 放置socket并且得到最大socket
        SOCKET maxSock = serverSock;
        clientManager.SetAllRead(fdRead, maxSock);

        timeval t = { 1,0 };
        if (select(maxSock + 1, &fdRead, NULL, NULL, &t) < 0)
        {
            std::cout << "select任务结束" << std::endl;
            Close();
            return false;
        }

        // 有链接
        if (FD_ISSET(serverSock, &fdRead))
        {
            FD_CLR(serverSock, &fdRead);
            Accept();
        }

        // 可读
        std::vector<std::shared_ptr<Client>> read;
        clientManager.GetAllRead(fdRead, read);
        for_each(read.begin(), read.end(), [&](std::shared_ptr<Client> client) {
            if (-1 == RecvData(szRecv, *client, std::bind(&Server::OnNetMsg, g_pSingleton, std::placeholders::_1, std::placeholders::_2)))
            {
                std::cout << "客户端 未开局<Socket=" << client->sock << ",userName=" << client->userName << ">已退出" << std::endl;
                clientManager.RemoveOne(client->sock);
                tableManager.RemoveOne(client->code);
            }
        });

        return true;
    }
    return false;
}
新链接

这边有一个链接进来调用ServerNet::Accept()，其中调用了一个虚函数AddClient，由Server重写。

SOCKET ServerNet::Accept()
{
    sockaddr_in clientAddr = {};
    int nAddrLen = sizeof(sockaddr_in);
    SOCKET clientSock = INVALID_SOCKET;

    clientSock = accept(serverSock, (sockaddr*)&clientAddr, (socklen_t *)&nAddrLen);

    if (INVALID_SOCKET == clientSock)
    {
        std::cout << "socket=<" << serverSock << ">错误,接受到无效客户端SOCKET" << std::endl;
    }
    else
    {
        // 有新的链接进来
        AddClient(clientSock, "", &clientAddr);
        std::cout << "socket=<" << serverSock << ">新客户端加入：socket = " << clientSock << ",IP = " << inet_ntoa(clientAddr.sin_addr) << std::endl;
    }
    return clientSock;
}

void Server::AddClient(SOCKET sock, const char *userName, const sockaddr_in *addr)
{
    Dump();
    clientManager.Add(sock, "", addr);
}
可读

对可读的客户端调用RecvData，粘包出来后会将消息丢给OnNetMsg，目前这只有登陆消息。
登陆成功，会将client加入对局，如果凑够两个人，就会开启对局线程，并且把client从vector移除。

void Server::OnNetMsg(SOCKET sock, DataHeader *header)
{
    switch (header->cmd)
    {
        case CMD_JOIN:
        {
            Join *join = (Join*)header;
            printf("收到客户端<Socket=%d>请求：CMD_JOIN,数据长度：%d,userName=%s,code=%d\n", sock, join->dataLength, join->userName, join->code);

            // 记录用户名 加入对局
            int number = tableManager.Add(join->code, clientManager.ChangeClientName(sock, join->userName));
            if (1 == number)
            {
                // 开启对局
                Table &table = tableManager.GetTable(join->code);
                if (pthread_create(&table.tid, NULL, thread, reinterpret_cast<void*>(join->code)) != 0)
                {
                    std::cout << "pthread_create error" << std::endl;
                }
                pthread_detach(table.tid);

                clientManager.RemoveOne(table.playerA->sock);
                clientManager.RemoveOne(table.playerB->sock);

                SendJoinResult(table.playerA->sock, number);	// 开启对局
            }
        
            SendJoinResult(sock, number);	// 登录返回消息
            
            // 暂且结束 待扩展
            if (2 == number)
            {
                clientManager.RemoveOne(sock);
            }

            break;
        }

    }
}

游戏处理

void* Server::thread(void *arg)
{
    char szRecv[MSG_BUFFER_LENGTH];		// 接收一级缓冲区
    int code = reinterpret_cast<long>(arg);
    TableManager &tableManager = Server::GetTableManager();
    Table &table = tableManager.GetTable(code);
    SOCKET maxSock = std::max(table.playerA->sock, table.playerB->sock);

    long long oldclock = ustime();		// 记录上一次 tick
    while (true)
    {
        fd_set fdRead;					// 描述符（socket） 集合
        FD_ZERO(&fdRead);				// 清理集合

        // 将描述符（socket）加入集合
        FD_SET(table.playerA->sock, &fdRead);
        FD_SET(table.playerB->sock, &fdRead);

        timeval t = { 0, 900000 };
        int ret = select(maxSock + 1, &fdRead, NULL, NULL, &t);
        if (ret < 0)
        {
            std::cout << "thread select任务结束" << std::endl;
        }

        // 检查玩家A是否可读
        if (FD_ISSET(table.playerA->sock, &fdRead))
        {
            if (-1 == RecvData(szRecv, *table.playerA, std::bind(&Server::OnThreadNetMsg, g_pSingleton, std::placeholders::_1, std::placeholders::_2)))
            {
                std::cout << "对局 <code=" << code << ">结束" << std::endl;
                break;
            }
        }

        // 检查玩家B是否可读
        if (FD_ISSET(table.playerB->sock, &fdRead))
        {
            if (-1 == RecvData(szRecv, *table.playerB, std::bind(&Server::OnThreadNetMsg, g_pSingleton, std::placeholders::_1, std::placeholders::_2)))
            {
                std::cout << "对局 <code=" << code << ">结束" << std::endl;
                break;
            }
        }

        // 给两个玩家发送消息
        auto sendServerSync = std::bind(&Server::SendServerSync, g_pSingleton, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3);
        switch (table.snake.DealGame())
        {
            case 0:
                sendServerSync(table.playerA->sock, table.snake, 0);
                sendServerSync(table.playerB->sock, table.snake, 0);
                break;
            case 1:
                sendServerSync(table.playerA->sock, table.snake, 1);
                sendServerSync(table.playerB->sock, table.snake, 2);
                break;
            case 2:
                sendServerSync(table.playerA->sock, table.snake, 2);
                sendServerSync(table.playerB->sock, table.snake, 1);
                break;
            case 3:
                sendServerSync(table.playerA->sock, table.snake, 3);
                sendServerSync(table.playerB->sock, table.snake, 3);
                break;
        }

        // 等到一帧结束 再开始接受消息
        HpSleep(1000000, oldclock);
    }
    
    tableManager.RemoveOne(code);
    return NULL;
}

这边对于一帧的处理使用了延时HpSleep，不是简单的直接sleep，类似于下图理想的延时函数，把程序运行结果都包含在内。
在这里插入图片描述

long long Server::ustime(void)
{
    struct timeval tv;
    long long ust;

    gettimeofday(&tv, NULL);
    ust = ((long long)tv.tv_sec)*1000000;
    ust += tv.tv_usec;
    return ust;
}

void Server::HpSleep(int us, long long &oldclock)
{
    oldclock += us;                         // 更新 tick
    if (ustime() > oldclock)				// 如果已经超时，无需延时
    {
        oldclock = ustime();
    }
    else
    {
        while (ustime() < oldclock)			// 延时
        {
            usleep(2000);					// 释放 CPU 控制权，降低 CPU 占用率
        }
    }
}

用户操作处理也很简单

void Server::OnThreadNetMsg(SOCKET sock, DataHeader *header)
{
    switch (header->cmd)
    {
        case CMD_CLIENT_OPERATION:
        {
            ClientOperation *clientOperation = (ClientOperation*)header;
            Table &table = tableManager.GetTable(clientOperation->code);
            table.snake.DealCmd(clientOperation->gameCmd);
            break;
        }
    }
}

void Server::SendServerSync(SOCKET sock, Snake &snake, int result)
{
    ServerSync ret;
    ret.result = result;
    snake.copyWord(ret.world);
    SendData(sock, &ret);
}

客户端

网络连接

Read读取的消息会交给OnNetMsg处理，SendLogin和SendOperation有额外的处理，所以都放到后面实现了。

class Net
{
public:

	Net() : socketClient(INVALID_SOCKET) {}

	~Net()
	{
		if (INVALID_SOCKET != socketClient)
		{
			closesocket(socketClient);
		}
		WSACleanup();
	}

	// 初始化网络
	bool Init();

	// 读取消息
	void Read();

	// 响应网络消息
	virtual void OnNetMsg(DataHeader *header) = 0;

	// 发送用户加入
	virtual void SendLogin(Join &join) = 0;

	// 发送用户操作
	virtual void SendOperation(ClientOperation &clientOperation) = 0;

protected:
	SOCKET socketClient;	// socket

private:
	// 粘包问题 分包
	char szRecv[4096];      // 接收缓冲区
	char szMsgBuf[10240];   // 第二缓冲区 消息缓冲区
	int lastPos = 0;        // 消息缓冲区的数据尾部位置

};

线程读取消息

这里用的c++11的线程。

class MyThread
{
public:

	MyThread() : isRun(false) {}

	// 线程是否在运行
	bool IsRun() { return isRun; }

	// 设置线程是否在运行
	void setIsRun(bool isRun) { this->isRun = isRun; }

	// 线程函数
	virtual void CallBack() = 0;

protected:
	std::shared_ptr<std::thread> t;

private:
	bool isRun;				// 线程是否运行

};

当服务器返回登录结果为1的时候就分配线程对象，开启线程。

void Game::OnNetMsg(DataHeader *header)
{
	switch (header->cmd)
	{
		case CMD_JOIN_RESULT:
		{
			。。。
			else if (1 == joinResult->result)
			{
				// 开启对局
				Clear();

				setIsRun(true);
				t = std::make_shared<std::thread>(&Game::CallBack, this);
				t->detach();
			}
			。。。
		}

		。。。
	}
}

void Game::CallBack()
{
	while (IsRun())
	{
		Read();
	}
}

接受用户操作

这边使用的GetAsyncKeyState检测按键状态，并且也是做了1s的延时。

int main(void)
{
	。。。

	while (game.IsRun())
	{
		game.DealCmd();
		game.HpSleep(1000);
	}

	。。。
}

void Game::DealCmd()
{
	ClientOperation clientOperation;
	clientOperation.gameCmd = (GAMECMD)0;
	if (isPlayerA)
	{
		if (GetAsyncKeyState('W'))
		{
			clientOperation.gameCmd = CMD_A_UP;
		}
		else if (GetAsyncKeyState('S'))
		{
			clientOperation.gameCmd = CMD_A_DOWN;
		}
		else if (GetAsyncKeyState('A'))
		{
			clientOperation.gameCmd = CMD_A_LEFT;
		}
		else if (GetAsyncKeyState('D'))
		{
			clientOperation.gameCmd = CMD_A_RIGHT;
		}
	}
	else
	{
		if (GetAsyncKeyState(VK_UP))
		{
			clientOperation.gameCmd = CMD_B_UP;
		}
		else if (GetAsyncKeyState(VK_DOWN))
		{
			clientOperation.gameCmd = CMD_B_DOWN;
		}
		else if (GetAsyncKeyState(VK_LEFT))
		{
			clientOperation.gameCmd = CMD_B_LEFT;
		}
		else if (GetAsyncKeyState(VK_RIGHT))
		{
			clientOperation.gameCmd = CMD_B_RIGHT;
		}
	}
	if (0 != clientOperation.gameCmd)
	{
		SendOperation(clientOperation);
	}
}

void Game::HpSleep(int ms)
{
	static clock_t oldclock = clock();		// 静态变量，记录上一次 tick

	oldclock += ms * CLOCKS_PER_SEC / 1000;	// 更新 tick

	if (clock() > oldclock)					// 如果已经超时，无需延时
	{
		oldclock = clock();
	}
	else
	{
		while (clock() < oldclock)			// 延时
		{
			Sleep(1);						// 释放 CPU 控制权，降低 CPU 占用率
		}
	}
}

百度云链接

easyx源程序链接
贪吃蛇游戏的双人对战版

代码百度云链接：https://pan.baidu.com/s/1pQNsEnaErfBlSFxutzxT6Q
提取码：tn4x

xiaoxiao涛
关注
专栏目录
c语言联机游戏,C/C++ 游戏 贪吃蛇双人对战版
weixin_34910679的博客
05-20 1788
贪吃蛇双人对战版——C语言最近写的，用于交最后一次结构化程序设计课的作业，闲暇之余传到网上，仅供参考，新手上路，请多指教。话不多说，先附上下载链接。http://download.csdn.net/detail/u013287454/8106587好吧，链接太麻烦，那就 点此下载吧！/** 游戏说明 **/为了和其他版本的贪吃蛇有所不同，这次设计的贪吃蛇采用了双人对战模式：由两名玩家分别控制自己的...
一个粗糙的二人贪吃蛇联机版实现
CMonY的博客
11-20 3546
联机版贪吃蛇 经过六天的艰苦（抓狂）后，终于完成了一个简单的联机版贪吃蛇制作，我将和大家分享一下制作的流程与感触。 1.题目难点 贪吃蛇是一款很经典的游戏，也是一个难度系数尚可，适宜初学c++者进行挑战的一个项目。在此过程中，主要的难点有两个： 1.如何让蛇动起来 2.如何让两台机器可以随时保持数据的交换 2.基本思路 对于电脑来说，蛇是不可能一点点蠕动的。所以在我的思考中，
Qt基于tcp网络服务器的简易版多人贪吃蛇小游戏(多线程)
qq_52706511的博客
01-30 699
基于tcp网络服务器的多人贪吃蛇游戏,运用了多线程的方法
【源码+文档】贪吃蛇多人游戏—简单的服务端
yuxibdd的博客
07-14 163
必须连接到服务器才能开始游戏，成功上线服务器返回“WELCOME USERNAME”的欢迎信息当没有新的玩家上线时，玩家可以进行单人游戏，当游戏已经开始时第二个玩家无法上线，服务器返回“BUSY”当两个以上玩家同时上线时，可以进行多人游戏，客户端界面出现不同颜色的蛇，分别由不同玩家进行控制当某一玩家关闭连接，该玩家游戏失败除了单机贪吃蛇的基本规则外，当蛇头接触到同类时，该玩家游戏失败，生存时间长的玩家获胜，用你的身体挡住对手的路吧！*实际上这是简化的服务器，更像是“房间”的概念。
C语言项目：贪吃蛇游戏（双人模式），详细思路+源码分享
致力于C语言C++知识分享！
01-04 3612
这个对战版的贪吃蛇游戏网上有不少源代码，这个代码的特点就是为两个游戏者分别增加了命令队列，以实现更舒服的控制。
《贪吃蛇》从游戏中学习虚拟摇杆、TCP通信、单例模式等的应用(Java实现，Java和C#通信)
Elevenoo的博客
05-22 636
这个小游戏中主要介绍： 1. 一个比较经典好玩易实现的虚拟摇杆的创建和使用； 2. 使用链表实现蛇的增长和移动，代替数组实现，避免初始化蛇角色时分配空间带来的麻烦； 3. 之前发过一篇socket通信的帖子，顺手移植到这个小游戏中玩一下； 4. 如何使用单例模式在整个工程中传递一个且只能存在一个的对象； 5. 接口怎么用； 6. ........ 先看一下效果： ...
c语言c++三人/双人贪吃蛇源码，双缓冲，多线程，AI蛇，吃啥长啥
dlv000的博客
07-12 8686
c++三人/双人贪吃蛇源码，双缓冲，多线程，AI蛇，吃啥长啥 游戏介绍： 在游戏时间结束之前吃尽可能多的食物 尽可能的长（zhang）长（chang） 然后干掉其他的蛇！ 只有 1 个幸存者！ 作者の坦白： 我只做了游戏的主体部分，，，没做菜单界面，，，，，，， 因为，，我对菜单界面有太多的想法，，，没个把月做不出来" 而且我现在又必须要复习数学和物理，，，，，，，，，，， 而且我感觉用继承和多态来做菜单界面会更简单，，，，，， 但我现在还不太懂继承和多态，，所以我打算把继承和多态学一学之后再来做菜单界面
python双人贪吃蛇游戏
m0_52162112的博客
01-13 1423
前言 小时候玩过红白机和诺基亚手机的贪吃蛇，因为见到的大多数贪吃蛇都是单人游戏，所以常常就是我只能看着别人玩，或者别人看着我玩，却没法两个人一起愉快地玩耍。 由此产生了做一个可以双人玩的贪吃蛇想法，并且从小时候一直到现在，之前python还没有那么火的时候，就在网上看过一些用python写游戏的教程。后来系统地自学了python，就打算将双人贪吃蛇安排上了。 运行环境 Python 3.7.6 Pygame 1.9.6 编译器：Spyder 双人贪吃蛇 在游戏中，蓝色的玩家也就是1P通过WASD控制方
联机贪吃蛇
10-21
（里面包含文档，无措运行代码，在局域网内实现的双人贪吃蛇） 双人贪吃蛇游戏为双人游戏 其中一人控制蛇，一人控制光点，蛇的速度是光点的1.5倍，控制蛇的玩家与控制光点的玩家一盘下来角色调换，三盘二胜 光点被吃...
计算机网络课程设计-网络版小游戏-多人联机贪吃蛇
01-23
设计 1.4 网络版小游戏 【设计目的】 1. 熟悉开发工具（Visual Studio、Delphi、BCB 等）的基本操作； 2. 掌握应用程序的编写过程； 3. 对于 Socket 编程建立初步的概念。 【设计要求】 1. 熟悉 Sock API 主要函数...
贪吃蛇联机版源代码 Snack Game -Oline .zip
05-01
适合入门级C#小白学习
java贪吃蛇源码（联网）
03-05
我是新手，耗时一周写的联网贪吃蛇，没注重做特效，但是基本功能和规则都有，适合新手研究线程或swing，有兴趣的可以下载来看看
双人版贪吃蛇+C源码
01-09
使用贪吃蛇，VS 必须安装图形库才能运行程序 。 贪吃蛇比较简单，大多数人都会，留给初学者参考使用
.Net贪吃蛇 C# socket对战
04-28
用C#写的贪吃蛇小游戏 ，用socket实现两台电脑进行对战。
java大作业 多人贪吃蛇
07-02
java java大作业 多人贪吃蛇 贪吃蛇 清华大学
Java 实现贪吃蛇最新源码
06-22
这个项目不仅提供了一个完整的单人游戏体验，而且计划进一步开发联机功能，增加游戏的互动性和趣味性。 Java是一种广泛使用的面向对象的编程语言，以其"Write Once, Run Anywhere"（WORA）的特性著称，这使得Java...
andriod贪食蛇联机版
10-09
2. **服务器端开发**：“贪吃蛇联机版-服务器端”文件包含了游戏服务器的代码，服务器负责接收并处理来自各个客户端的请求，如玩家移动、吃到食物、碰撞检测等事件。服务器还需要进行游戏逻辑的计算，以保证游戏的...
C++实现贪吃蛇游戏
热门推荐
沾花把玖的博客
01-24 1万+
C++实现贪吃蛇游戏
贪吃蛇的C++实现
qq_56341866的博客
08-15 7827
一、实现的功能 1、介绍程序内容 2、选择控制方式（WASD或者方向键盘） 3、地图选择 4、速度选择 二、实现思路 既然刚学完C++，我们就要使用面向对象的方法来编程实现。创建唯一也是核心的类CentralWork，在其中实现所有功能。 贪吃蛇实现主要有四个步骤：食物的随机产生、蛇的移动显示、蛇移动方向的控制、蛇吃到食物与牺牲的判定。现在阐述实现思路。 1、食物的随机产生： 食物只存在一个，一个被吃后才会产生下一个随机食物。所以食物是否...
python 联机贪吃蛇
最新发布
03-20
Python联机贪吃蛇是一款基于Python编程语言开发的多人在线游戏，玩家可以通过网络与其他玩家进行对战。游戏规则与传统的贪吃蛇游戏相似，玩家控制一条在地图上动，吃食物以增长身体，同时要避碰到其他蛇的身体或者撞墙。 在Python联贪吃蛇中，玩家可以通过键盘输入控制蛇的移动方向，每个玩家的蛇都有一个独特的颜色来区分。当蛇头碰到其他蛇的身体或者撞时，游戏结束。最后存活蛇将被宣布为胜利者。 这款游戏可以通过使用Python的网络编库（如socket或者WebSocket）来实现玩家之间的信和数据传输。通过建立服务器和客户端之间的连接，玩家可以实时看到其他玩家的移动和游戏状态。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值