基于 CentOS 搭建微信小程序服务教程-云服务器玩法在线实验

[复制链接]
查看: 584|回复: 0
发表于 2020-4-7 15:13:21 | 显示全部楼层 |阅读模式
阿里云
实验内容小程序无疑是今年互联网的重大热点。本实验带您从零开始,基于 NodeJS 搭建起一个可以支撑小程序运行的服务,包括 HTTPS 部署、会话服务、WebSocket 服务,最后利用这些服务实现一个实时的剪刀石头布小游戏。

首次可免费使用云主机 3 小时 ,到期后云主机将被重置并退库,若想保留成果请及时留用。


免费在线实验地址:点击进入
实验资源:云服务器,没有云服务器的朋友推荐1折抢购:69元/年的阿里云服务器、或者99元/年的腾讯云服务器

软件环境CentOS 7.2 64 位

一、准备域名和证书
小程序后台服务需要通过 HTTPS 访问,在实验开始之前,我们要准备域名和 SSL 证书。推荐:万网域名阿里云SSL证书腾讯云SSL证书
域名购买完成后, 需要将域名解析到实验云主机上,实验云主机的 IP 为:
  1. <您的 CVM IP 地址>
复制代码
域名设置解析后需要过一段时间才会生效,通过 ping 命令检查域名是否生效,如:
  1. ping www.yourmpdomain.com
复制代码
如果 ping 命令返回的信息中含有你设置的解析的 IP 地址,说明解析成功。
  1. 注意替换下面命令中的 www.yourmpdomain.com 为您自己的注册的域名
复制代码
二、搭建小程序开发环境在开始搭建我们的小程序服务器之前,需要先完成客户端小程序开发环境的搭建。
注册开发者账号
如果你还不是小程序开发者,请先在微信公众平台并注册:
  1. https://mp.weixin.qq.com
复制代码
配置小程序服务器信息
登录微信公众平台后,依次进入 设置 - 开发设置 - 服务器域名 - 修改。
扫码完成身份校验后,request 合法域名和 socket 合法域名均填写在上一步准备好的域名地址。
配置完成后,点击 保存并提交。

运行配套小程序代码
要运行本实验配套的小程序代码,请下载下列资源:
  • 实验配套源码
  • 微信小程序开发工具
  • 源码下载后,请解压到本地工作目录。开发工具下载后,请安装并启动,然后用微信扫码登录。登录后,选择 本地小程序项目 - 添加项目,使用以下配置:AppID:填写小程序的 AppID,请登录公众平台后在 设置 - 开发设置 - 开发者 ID 中查看项目名称:填写任意您喜欢的名称项目目录:选择刚才解压的配套源码目录(目录包含 app.js)填写完成后,点击 添加项目。
    设置实验域名在开发工具的 编辑 面板中,选中 app.js 进行编辑,需要修改小程序通信域名,请参考下面的配置:
    1. App({
    2.     config: {
    3.         host: '' // 这个地方填写你的域名
    4.     },
    5.     onLaunch () {
    6.         console.log('App.onLaunch()');
    7.     }
    8. });
    复制代码
    三、搭建 HTTP 服务下面的步骤,将带大家在服务器上使用 Node 和 Express 搭建一个 HTTP 服务器安装 NodeJS 和 NPM使用下面的命令安装 NodeJS 和 NPM
    1. curl --silent --location [url]https://rpm.nodesource.com/setup_8.x[/url] | sudo bash -
    2. yum install nodejs -y
    复制代码
    安装完成后,使用下面的命令测试安装结果
    1. node -v
    复制代码
    编写 HTTP Server 源码创建工作目录使用下面的命令在服务器创建一个工作目录:
    1. mkdir -p /data/release/weapp
    复制代码
    进入此工作目录
    1. cd /data/release/weapp
    复制代码
    创建 package.json在刚才创建的工作目录创建 package.json,添加我们服务器包的名称和版本号,可参考下面的示例。
    示例代码:/data/release/weapp/package.json
    1. {
    2.     "name": "weapp",
    3.     "version": "1.0.0"
    4. }
    复制代码
    完成后,使用 Ctrl + S 保存文件
    添加 Server 源码在工作目录创建 app.js,使用 Express.js 来监听 8765 端口,可参考下面的示例代码。
    示例代码:/data/release/weapp/app.js
    1. // 引用 express 来支持 HTTP Server 的实现
    2. const express = require('express');

    3. // 创建一个 express 实例
    4. const app = express();

    5. // 实现唯一的一个中间件,对于所有请求,都输出 "Response from express"
    6. app.use((request, response, next) => {
    7.     response.write('Response from express');
    8.     response.end();
    9. });

    10. // 监听端口,等待连接
    11. const port = 8765;
    12. app.listen(port);

    13. // 输出服务器启动日志
    14. console.log(`Server listening at [url]http://127.0.0.1:[/url]${port}`);
    复制代码
    1. 本实验会以 8765 端口的打开作为实验步骤完成的依据,为了后面的实验步骤顺利进行,请不要使用其它端口号
    复制代码
    运行 HTTP 服务安装 PM2在开始之前,我们先来安装
    1. npm install pm2 --global
    复制代码
    PM2 安装时间可能稍长,请耐心等候安装 Express我们的服务器源码里使用到了 Express 模块,下面的命令使用 NPM 来安装 Express
    1. cd /data/release/weapp
    2. npm install express --save
    复制代码
    启动服务安装完成后,使用 PM2 来启动 HTTP 服务
    1. cd /data/release/weapp
    2. pm2 start app.js
    复制代码
    现在,您的 HTTP 服务已经在 http://<您的 CVM IP 地址>:8765 运行
    要查看服务输出的日志,可以使用下面的命令:
    1. pm2 logs
    复制代码
    如果要重启服务,可以使用下面的命令:
    1. pm2 restart app
    复制代码
    我们使用 PM2 来进行 Node 进程的运行、监控和管理
    NPM 仓库在国内访问速度可能不太理想,如果实在太慢可以尝试使用 CNPM 的 Registry 进行安装:
    1. npm install pm2 -g --registry=https://r.cnpmjs.org/
    复制代码
    四、搭建 HTTPS 服务微信小程序要求和服务器的通信都通过 HTTPS 进行
    安装 Nginx在 CentOS 上,可直接使用 yum 来安装 Nginx
    1. yum install nginx -y
    复制代码
    安装完成后,使用 nginx 命令启动 Nginx:
    1. nginx
    复制代码
    此时,访问 http://<您的域名> 可以看到 Nginx 的测试页面如果无法访问,请重试用 nginx -s reload 命令重启 Nginx
    配置 HTTPS 反向代理外网用户访问服务器的 Web 服务由 Nginx 提供,Nginx 需要配置反向代理才能使得 Web 服务转发到本地的 Node 服务。先将之前下载的 SSL 证书(解压后 Nginx 目录分别以 crt 和 key 作为后缀的文件)通过拖动到左侧文件浏览器/etc/nginx目录的方式来上传文件到服务器上如何上传 SSL 证书到 /etc/nginx 目录Nginx 配置目录在 /etc/nginx/conf.d,我们在该目录创建 ssl.conf示例代码:/etc/nginx/conf.d/ssl.conf
    1. server {
    2.         listen 443;
    3.         server_name www.example.com; # 改为绑定证书的域名
    4.         # ssl 配置
    5.         ssl on;
    6.         ssl_certificate 1_www.example.com_bundle.crt; # 改为自己申请得到的 crt 文件的名称
    7.         ssl_certificate_key 2_www.example.com.key; # 改为自己申请得到的 key 文件的名称
    8.         ssl_session_timeout 5m;
    9.         ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    10.         ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
    11.         ssl_prefer_server_ciphers on;

    12.         location / {
    13.             proxy_pass http://127.0.0.1:8765;
    14.         }
    15.     }
    复制代码
    按 Ctrl + S 保存配置文件,让 Nginx 重新加载配置使其生效:
    1. nginx -s reload
    复制代码
    在浏览器通过 https 的方式访问你解析的域名来测试 HTTPS 是否成功启动在小程序中测试 HTTPS 访问打开配套的小程序,点击 实验一:HTTPS,点击 发送请求 来测试访问结果。如果服务器响应成功,请点击下一步。
    五、小程序会话小程序不支持 Cookie 存储和跟踪,服务器需要自行实现会话层
    安装 MongoDB使用 Yum 在机器上安装 [MongoDB] 及其客户端命令行工具:
    1. yum install mongodb-server mongodb -y
    复制代码
    安装结束后,可以使用下面的命令查看安装的版本:
    1. mongod --version
    2. mongo --version
    复制代码
    MongoDB 是一款 NoSQL 数据库,支持 JSON 格式的结构化文档存储和查询,对 JavaScript 有着友好的支持
    启动 MongoDB创建目录,用于 MongoDB 数据和日志存储:
    1. mkdir -p /data/mongodb
    2. mkdir -p /data/logs/mongodb
    复制代码
    创建后,使用下面的命令来启动 MongoDB:
    1. mongod --fork --dbpath /data/mongodb --logpath /data/logs/mongodb/weapp.log
    复制代码
    可以使用下面的命令来检查是否启动成功
    1. netstat -ltp | grep 27017
    复制代码
    MongoDB 首次启动可能会花费大概 1min 时间,请耐心等待MongoDB 默认监听 27017 端口等待连接,下面的命令查看当前 27017 端口被哪个进程占用,如果是 MongoDB 的进程,则表示启动成功。
    添加 MongoDB 用户登录本地 MongoDB 服务:
    1. mongo
    复制代码
    登录后,创建一个用户 weapp
    1. use weapp;
    2. db.createUser({ user: 'weapp', pwd: 'weapp-dev', roles: ['dbAdmin', 'readWrite']});
    复制代码
    创建完成后,使用 exit 退出命令行工具。创建的用户和密码将用于下一步中连接数据库时使用,如果使用不同的用户或密码,注意要保存好
    安装 Node 模块实现小程序的会话功能,我们需要安装 [connect-mongo] 和 [wafer-node-session]
    1. cd /data/release/weapp
    2. npm install connect-mongo wafer-node-session --save
    复制代码
    connect-mongo 模块通过连接到 MongoDB 为会话提供存储wafer-node-session 是由腾讯云提供的独立小程序会话管理中间件
    实现小程序会话在工作目录创建配置文件 config.js,用于保存我们服务所用的配置,可参考下面的实现(注:请将参考配置文件中的 YORU_APP_ID 和 YOUR_APP_SECRET 替换为你申请的小程序对应的 AppID 和 AppSecret):
    示例代码:/data/release/weapp/config.js
    1. module.exports = {
    2.     serverPort: '8765',

    3.     // 小程序 appId 和 appSecret
    4.     // 请到 https://mp.weixin.qq.com 获取 AppID 和 AppSecret
    5.     appId: 'YORU_APP_ID',
    6.     appSecret: 'YOUR_APP_SECRET',

    7.     // mongodb 连接配置,生产环境请使用更复杂的用户名密码
    8.     mongoHost: '127.0.0.1',
    9.     mongoPort: '27017',
    10.     mongoUser: 'weapp',
    11.     mongoPass: 'weapp-dev',
    12.     mongoDb: 'weapp'
    13. };
    复制代码
    编辑 app.js,添加会话实现逻辑,可参考下面的代码:
    示例代码:/data/release/weapp/app.js
    1. // 引用 express 来支持 HTTP Server 的实现
    2. const express = require('express');
    3. // 引用 wafer-session 支持小程序会话
    4. const waferSession = require('wafer-node-session');
    5. // 使用 MongoDB 作为会话的存储
    6. const MongoStore = require('connect-mongo')(waferSession);
    7. // 引入配置文件
    8. const config = require('./config');

    9. // 创建一个 express 实例
    10. const app = express();

    11. // 添加会话中间件,登录地址是 /login
    12. app.use(waferSession({
    13.     appId: config.appId,
    14.     appSecret: config.appSecret,
    15.     loginPath: '/login',
    16.     store: new MongoStore({
    17.         url: `mongodb://${config.mongoUser}:${config.mongoPass}@${config.mongoHost}:${config.mongoPort}/${config.mongoDb}`
    18.     })
    19. }));

    20. // 在路由 /me 下,输出会话里包含的用户信息
    21. app.use('/me', (request, response, next) => {
    22.     response.json(request.session ? request.session.userInfo : { noBody: true });
    23.     if (request.session) {
    24.         console.log(`Wafer session success with openId=${request.session.userInfo.openId}`);
    25.     }
    26. });

    27. // 实现一个中间件,对于未处理的请求,都输出 "Response from express"
    28. app.use((request, response, next) => {
    29.     response.write('Response from express');
    30.     response.end();
    31. });

    32. // 监听端口,等待连接
    33. app.listen(config.serverPort);

    34. // 输出服务器启动日志
    35. console.log(`Server listening at http://127.0.0.1:${config.serverPort}`);
    复制代码
    源码编写完成后,重启服务:
    1. pm2 restart app
    复制代码
    重启后,使用配套的小程序完成会话测试:打开配套小程序 - 点击 实验二:会话 - 获取会话,如果您能看到您的微信头像,那就表示会话已经成功获取了。随着服务变得复杂,我们可以把配置集中起来方便管理,比如目前我们需要保存:服务器运行端口、小程序配置、MongoDB 连接配置
    六、WebSocket 服务安装 Node 模块本实验使用 ws 模块来在服务器上支持 WebSocket 协议,下面使用 NPM 来安装:
    1. cd /data/release/weapp
    2. npm install ws --save
    复制代码
    实现 WebSocket 服务器创建 websocket.js,实现 WebSocket 服务,可参考下面的代码:
    示例代码:/data/release/weapp/websocket.js
    1. // 引入 ws 支持 WebSocket 的实现
    2. const ws = require('ws');

    3. // 导出处理方法
    4. exports.listen = listen;

    5. /**
    6. * 在 HTTP Server 上处理 WebSocket 请求
    7. * @param {http.Server} server
    8. * @param {wafer.SessionMiddleware} sessionMiddleware
    9. */
    10. function listen(server, sessionMiddleware) {
    11.     // 使用 HTTP Server 创建 WebSocket 服务,使用 path 参数指定需要升级为 WebSocket 的路径
    12.     const wss = new ws.Server({ server, path: '/ws' });

    13.     // 监听 WebSocket 连接建立
    14.     wss.on('connection', (ws,request) => {// 要升级到 WebSocket 协议的 HTTP 连接

    15.         // 被升级到 WebSocket 的请求不会被 express 处理,
    16.         // 需要使用会话中间节获取会话
    17.         sessionMiddleware(request, null, () => {
    18.             const session = request.session;
    19.             if (!session) {
    20.                 // 没有获取到会话,强制断开 WebSocket 连接
    21.                 ws.send(JSON.stringify(request.sessionError) || "No session avaliable");
    22.                 ws.close();
    23.                 return;
    24.             }
    25.             // 保留这个日志的输出可让实验室能检查到当前步骤是否完成
    26.             console.log(`WebSocket client connected with openId=${session.userInfo.openId}`);
    27.             serveMessage(ws, session.userInfo);
    28.         });
    29.     });

    30.     // 监听 WebSocket 服务的错误
    31.     wss.on('error', (err) => {
    32.         console.log(err);
    33.     });
    34. }

    35. /**
    36. * 进行简单的 WebSocket 服务,对于客户端发来的所有消息都回复回去
    37. */
    38. function serveMessage(ws, userInfo) {
    39.     // 监听客户端发来的消息
    40.     ws.on('message', (message) => {
    41.         console.log(`WebSocket received: ${message}`);
    42.         ws.send(`Server: Received(${message})`);
    43.     });

    44.     // 监听关闭事件
    45.     ws.on('close', (code, message) => {
    46.         console.log(`WebSocket client closed (code: ${code}, message: ${message || 'none'})`);
    47.     });

    48.     // 连接后马上发送 hello 消息给会话对应的用户
    49.     ws.send(`Server: 恭喜,${userInfo.nickName}`);
    50. }
    复制代码
    编辑 app.js,调用 WebSocket 服务,可参考下面代码:
    示例代码:/data/release/weapp/app.js
    1. // HTTP 模块同时支持 Express 和 WebSocket
    2. const http = require('http');
    3. // 引用 express 来支持 HTTP Server 的实现
    4. const express = require('express');
    5. // 引用 wafer-session 支持小程序会话
    6. const waferSession = require('wafer-node-session');
    7. // 使用 MongoDB 作为会话的存储
    8. const MongoStore = require('connect-mongo')(waferSession);
    9. // 引入配置文件
    10. const config = require('./config');
    11. // 引入 WebSocket 服务实现
    12. const websocket = require('./websocket');

    13. // 创建一个 express 实例
    14. const app = express();

    15. // 独立出会话中间件给 express 和 ws 使用
    16. const sessionMiddleware = waferSession({
    17.     appId: config.appId,
    18.     appSecret: config.appSecret,
    19.     loginPath: '/login',
    20.     store: new MongoStore({
    21.         url: `mongodb://${config.mongoUser}:${config.mongoPass}@${config.mongoHost}:${config.mongoPort}/${config.mongoDb}`
    22.     })
    23. });
    24. app.use(sessionMiddleware);

    25. // 在路由 /me 下,输出会话里包含的用户信息
    26. app.use('/me', (request, response, next) => {
    27.     response.json(request.session ? request.session.userInfo : { noBody: true });
    28.     if (request.session) {
    29.         console.log(`Wafer session success with openId=${request.session.userInfo.openId}`);
    30.     }
    31. });

    32. // 实现一个中间件,对于未处理的请求,都输出 "Response from express"
    33. app.use((request, response, next) => {
    34.     response.write('Response from express');
    35.     response.end();
    36. });

    37. // 创建 HTTP Server 而不是直接使用 express 监听
    38. const server = http.createServer(app);

    39. // 让 WebSocket 服务在创建的 HTTP 服务器上监听
    40. websocket.listen(server, sessionMiddleware);

    41. // 启动 HTTP 服务
    42. server.listen(config.serverPort);

    43. // 输出服务器启动日志
    44. console.log(`Server listening at http://127.0.0.1:${config.serverPort}`);
    复制代码
    修改完成后,按 Ctrl + S 保存文件,并重启服务:
    1. pm2 restart app
    复制代码
    更新 Nginx 代理
    1. 编辑 Nginx 配置 ssl.conf,添加 WebSocket 支持,可参考下面的配置(注:请将参考配置文件中的 www.example.com 替换为前面步骤申请的域名,将 1_www.example.com.crt 和 2_www.example.com.key 替换为前面步骤申请并上传的 SSL 证书的名称):
    复制代码
    示例代码:/etc/nginx/conf.d/ssl.conf
    1. # WebSocket 配置
    2. map $http_upgrade $connection_upgrade {
    3.     default upgrade;
    4.     ''      close;
    5. }

    6. server {
    7.         listen 443;
    8.         server_name www.example.com; # 改为绑定证书的域名
    9.         # ssl 配置
    10.         ssl on;
    11.         ssl_certificate 1_www.example.com.crt; # 改为自己申请得到的 crt 文件的名称
    12.         ssl_certificate_key 2_www.example.com.key; # 改为自己申请得到的 key 文件的名称
    13.         ssl_session_timeout 5m;
    14.         ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
    15.         ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
    16.         ssl_prefer_server_ciphers on;

    17.         # WebSocket 配置
    18.         proxy_set_header Upgrade $http_upgrade;
    19.         proxy_set_header Connection $connection_upgrade;

    20.         location / {
    21.             proxy_pass http://127.0.0.1:8765;
    22.         }
    23.     }
    复制代码
    配置完成后,按 Ctrl + S 保存,并且通知 Nginx 进程重新加载配置:
    1. nginx -s reload
    复制代码
    测试 WebSocket打开配套的小程序,点击 实验三:WebSocket。进入测试页面后,点击 连接 按钮,如果出现连接成功的提示,表示 WebSocket 服务已经正常运行,可以收发消息。
    七、剪刀石头布小游戏实现游戏房间逻辑创建 /data/release/weapp/game 目录用于存放剪刀石头布小游戏的代码
    1. mkdir -p /data/release/weapp/game
    复制代码
    添加 game/Room.js 实现游戏房间逻辑,可参考下面的代码:
    示例代码:/data/release/weapp/game/Room.js
    1. /**
    2. enum GameChoice {
    3.     // 剪刀
    4.     Scissors = 1,
    5.     // 石头
    6.     Rock = 2,
    7.     // 布
    8.     Paper = 3
    9. }
    10. */
    11. function judge(choice1, choice2) {
    12.     // 和局
    13.     if (choice1 == choice2) return 0;
    14.     // Player 1 没出,Player 2 胜出
    15.     if (!choice1) return 1;
    16.     // Player 2 没出,Player 1 胜出
    17.     if (!choice2) return -1;
    18.     // 都出了就这么算
    19.     return (choice1 - choice2 + 3) % 3 == 1 ? -1 : 1;
    20. }

    21. /** @type {Room[]} */
    22. const globalRoomList = [];

    23. // 每个房间最多两人
    24. const MAX_ROOT_MEMBER = 2;

    25. // 游戏时间,单位秒
    26. const GAME_TIME = 3;

    27. let nextRoomId = 0;

    28. /** 表示一个房间 */
    29. module.exports = class Room {

    30.     /** 获取所有房间 */
    31.     static all() {
    32.         return globalRoomList.slice();
    33.     }

    34.     /** 获取有座位的房间 */
    35.     static findRoomWithSeat() {
    36.         return globalRoomList.find(x => !x.isFull());
    37.     }

    38.     /** 创建新房间 */
    39.     static create() {
    40.         const room = new Room();
    41.         globalRoomList.unshift(room);
    42.         return room;
    43.     }

    44.     constructor() {
    45.         this.id = `room${nextRoomId++}`;
    46.         this.players = [];
    47.     }

    48.     /** 添加玩家 */
    49.     addPlayer(player) {
    50.         const { uid, uname } = player.user;
    51.         console.log(`Player ${uid}(${uname}) enter ${this.id}`);
    52.         this.players.push(player);
    53.         if (this.isFull()) {
    54.             this.startGame();
    55.         }
    56.     }

    57.     /** 删除玩家 */
    58.     removePlayer(player) {
    59.         const { uid, uname } = player.user;
    60.         console.log(`Player ${uid}(${uname}) leave ${this.id}`);
    61.         const playerIndex = this.players.indexOf(player);
    62.         if (playerIndex != -1) {
    63.             this.players.splice(playerIndex, 1);
    64.         }
    65.         if (this.players.length === 0) {
    66.             console.log(`Room ${this.id} is empty now`);
    67.             const roomIndex = globalRoomList.indexOf(this);
    68.             if (roomIndex > -1) {
    69.                 globalRoomList.splice(roomIndex, 1);
    70.             }
    71.         }
    72.     }

    73.     /** 玩家已满 */
    74.     isFull() {
    75.         return this.players.length == MAX_ROOT_MEMBER;
    76.     }

    77.     /** 开始游戏 */
    78.     startGame() {
    79.         // 保留这行日志输出可以让实验室检查到实验的完成情况
    80.         console.log('game started!');

    81.         // 当局积分清零
    82.         this.players.forEach(player => player.gameData.roundScore = 0);

    83.         // 集合玩家用户和游戏数据
    84.         const players = this.players.map(player => Object.assign({}, player.user, player.gameData));

    85.         // 通知所有玩家开始
    86.         for (let player of this.players) {
    87.             player.send('start', {
    88.                 gameTime: GAME_TIME,
    89.                 players
    90.             });
    91.         }

    92.         // 计时结束
    93.         setTimeout(() => this.finishGame(), GAME_TIME * 1000);
    94.     }

    95.     /** 结束游戏 */
    96.     finishGame() {
    97.         const players = this.players;

    98.         // 两两对比算分
    99.         for (let i = 0; i < MAX_ROOT_MEMBER; i++) {
    100.             let p1 = players[i];
    101.             if (!p1) break;
    102.             for (let j = i + 1; j < MAX_ROOT_MEMBER; j++) {
    103.                 let p2 = players[j];
    104.                 const result = judge(p1.gameData.choice, p2.gameData.choice);
    105.                 p1.gameData.roundScore -= result;
    106.                 p2.gameData.roundScore += result;
    107.             }
    108.         }
    109.         // 计算连胜奖励
    110.         for (let player of players) {
    111.             const gameData = player.gameData;
    112.             // 胜局积分
    113.             if (gameData.roundScore > 0) {
    114.                 gameData.winStreak++;
    115.                 gameData.roundScore *= gameData.winStreak;
    116.             }
    117.             // 败局清零
    118.             else if (gameData.roundScore < 0) {
    119.                 gameData.roundScore = 0;
    120.                 gameData.winStreak = 0;
    121.             }
    122.             // 累积总分
    123.             gameData.totalScore += gameData.roundScore;
    124.         }
    125.         // 计算结果
    126.         const result = players.map(player => {
    127.             const { uid } = player.user;
    128.             const { roundScore, totalScore, winStreak, choice } = player.gameData;
    129.             return { uid, roundScore, totalScore, winStreak, choice };
    130.         });
    131.         // 通知所有玩家游戏结果
    132.         for (let player of players) {
    133.             player.send('result', { result });
    134.         }
    135.     }
    136. }
    复制代码
    处理游戏开始、计算结果、积分等逻辑
    实现玩家逻辑添加 game/Player.js 实现玩家逻辑,可参考下面的代码:
    示例代码:/data/release/weapp/game/Player.js
    1. const Room = require("./Room");

    2. /**
    3. * 表示一个玩家,处理玩家的公共游戏逻辑,消息处理部分需要具体的玩家实现(请参考 ComputerPlayer 和 HumanPlayer)
    4. */
    5. module.exports = class Player {
    6.     constructor(user) {
    7.         this.id = user.uid;
    8.         this.user = user;
    9.         this.room = null;
    10.         this.gameData = {
    11.             // 当前的选择(剪刀/石头/布)
    12.             choice: null,
    13.             // 局积分
    14.             roundScore: 0,
    15.             // 总积分
    16.             totalScore: 0,
    17.             // 连胜次数
    18.             winStreak: 0
    19.         };
    20.     }

    21.     /**
    22.      * 上线当前玩家,并且异步返回给玩家分配的房间
    23.      */
    24.     online(room) {
    25.         // 处理玩家 'join' 消息
    26.         // 为玩家寻找一个可用的房间,并且异步返回
    27.         this.receive('join', () => {
    28.             if (this.room) {
    29.                 this.room.removePlayer(this);
    30.             }
    31.             room = this.room = room || Room.findRoomWithSeat() || Room.create();
    32.             room.addPlayer(this);
    33.         });

    34.         // 处理玩家 'choise' 消息
    35.         // 需要记录玩家当前的选择,并且通知到房间里的其它玩家
    36.         this.receive('choice', ({ choice }) => {
    37.             this.gameData.choice = choice;
    38.             this.broadcast('movement', {
    39.                 uid: this.user.uid,
    40.                 movement: "choice"
    41.             });
    42.         });

    43.         // 处理玩家 'leave' 消息
    44.         // 让玩家下线
    45.         this.receive('leave', () => this.offline);
    46.     }

    47.     /**
    48.      * 下线当前玩家,从房间离开
    49.      */
    50.     offline() {
    51.         if (this.room) {
    52.             this.room.removePlayer(this);
    53.             this.room = null;
    54.         }
    55.         this.user = null;
    56.         this.gameData = null;
    57.     }

    58.     /**
    59.      * 发送指定消息给当前玩家,需要具体子类实现
    60.      * @abstract
    61.      * @param {string} message 消息类型
    62.      * @param {*} data 消息数据
    63.      */
    64.     send(message, data) {
    65.         throw new Error('Not implement: AbstractPlayer.send()');
    66.     }

    67.     /**
    68.      * 处理玩家发送的消息,需要具体子类实现
    69.      * @abstract
    70.      * @param {string} message 消息类型
    71.      * @param {Function} handler
    72.      */
    73.     receive(message, handler) {
    74.         throw new Error('Not implement: AbstractPlayer.receive()');
    75.     }

    76.     /**
    77.      * 给玩家所在房间里的其它玩家发送消息
    78.      * @param {string} message 消息类型
    79.      * @param {any} data 消息数据
    80.      */
    81.     broadcast(message, data) {
    82.         if (!this.room) return;
    83.         this.others().forEach(neighbor => neighbor.send(message, data));
    84.     }

    85.     /**
    86.      * 获得玩家所在房间里的其他玩家
    87.      */
    88.     others() {
    89.         return this.room.players.filter(player => player != this);
    90.     }
    91. }
    复制代码
    处理玩家加入游戏、选择出拳、通知其他玩家等逻辑
    实现电脑玩家在实现人类玩家之前,我们先来创建 ComputerPlayer.js 来实现电脑玩家
    示例代码:/data/release/weapp/game/ComputerPlayer.js
    1. const EventEmitter = require('events');
    2. const Player = require('./Player');

    3. let nextComputerId = 0;

    4. /**
    5. * 机器人玩家实现,使用 EventEmitter 接收和发送消息
    6. */
    7. module.exports = class ComputerPlayer extends Player {
    8.     constructor() {
    9.         const computerId = `robot-${++nextComputerId}`;
    10.         super({
    11.             uid: computerId,
    12.             uname: computerId,
    13.             uavatar: 'http://www.scoutiegirl.com/wp-content/uploads/2015/06/Blue-Robot.png'
    14.         });
    15.         this.emitter = new EventEmitter();
    16.     }

    17.     /**
    18.      * 模拟玩家行为
    19.      */
    20.     simulate() {
    21.         this.receive('start', () => this.play());
    22.         this.receive('result', () => this.stop());
    23.         this.send('join');
    24.     }

    25.     /**
    26.      * 游戏开始后,随机时间后随机选择
    27.      */
    28.     play() {
    29.         this.playing = true;
    30.         const randomTime = () => Math.floor(100 + Math.random() * 2000);
    31.         const randomChoice = () => {
    32.             if (!this.playing) return;
    33.             this.send("choice", {
    34.                 choice: Math.floor(Math.random() * 10000) % 3 + 1
    35.             });
    36.             setTimeout(randomChoice, randomTime());
    37.         }
    38.         setTimeout(randomChoice, 10);
    39.     }

    40.     /**
    41.      * 游戏结束后,标记起来,阻止继续随机选择
    42.      */
    43.     stop() {
    44.         this.playing = false;
    45.     }

    46.     /**
    47.      * 发送消息给当前玩家,直接转发到 emitter
    48.      */
    49.     send(message, data) {
    50.         this.emitter.emit(message, data);
    51.     }

    52.     /**
    53.      * 从当前的 emitter 处理消息
    54.      */
    55.     receive(message, handle) {
    56.         this.emitter.on(message, handle);
    57.     }
    58. }
    复制代码
    测试游戏逻辑的时候,可能没有其它人可以一起参与,实现一个电脑玩家是不错的选择
    实现人类玩家人类玩家通过 WebSocket 信道来实现玩家的输入输出,我们需要添加 game/Tunnel.js 和 game/HumanPlayer.js 来实现人类玩家逻辑,可参考下面的代码:
    示例代码:/data/release/weapp/game/Tunnel.js
    1. const EventEmitter = require('events');

    2. /**
    3. * 封装 WebSocket 信道
    4. */
    5. module.exports = class Tunnel {
    6.     constructor(ws) {
    7.         this.emitter = new EventEmitter();
    8.         this.ws = ws;
    9.         ws.on('message', packet => {
    10.             try {
    11.                 // 约定每个数据包格式:{ message: 'type', data: any }
    12.                 const { message, data } = JSON.parse(packet);
    13.                 this.emitter.emit(message, data);
    14.             } catch (err) {
    15.                 console.log('unknown packet: ' + packet);
    16.             }
    17.         });
    18.     }

    19.     on(message, handle) {
    20.         this.emitter.on(message, handle);
    21.     }

    22.     emit(message, data) {
    23.         this.ws.send(JSON.stringify({ message, data }));
    24.     }
    25. }
    复制代码
    示例代码:/data/release/weapp/game/HumanPlayer.js
    1. const co = require('co');
    2. const Player = require('./Player');
    3. const ComputerPlayer = require('./ComputerPlayer');
    4. const Tunnel = require('./Tunnel');

    5. /**
    6. * 人类玩家实现,通过 WebSocket 信道接收和发送消息
    7. */
    8. module.exports = class HumanPlayer extends Player {
    9.     constructor(user, ws) {
    10.         super(user);
    11.         this.ws = ws;
    12.         this.tunnel = new Tunnel(ws);
    13.         this.send('id', user);
    14.     }

    15.     /**
    16.      * 人类玩家上线后,还需要监听信道关闭,让玩家下线
    17.      */
    18.     online(room) {
    19.         super.online(room);
    20.         this.ws.on('close', () => this.offline());

    21.         // 人类玩家请求电脑玩家
    22.         this.receive('requestComputer', () => {
    23.             const room = this.room;
    24.             while(room && !room.isFull()) {
    25.                 const computer = new ComputerPlayer();
    26.                 computer.online(room);
    27.                 computer.simulate();
    28.             }
    29.         });
    30.     }

    31.     /**
    32.      * 下线后关闭信道
    33.      */
    34.     offline() {
    35.         super.offline();
    36.         if (this.ws && this.ws.readyState == this.ws.OPEN) {
    37.             this.ws.close();
    38.         }
    39.         this.ws = null;
    40.         this.tunnel = null;
    41.         if (this.room) {
    42.             // 清理房间里面的电脑玩家
    43.             for (let player of this.room.players) {
    44.                 if (player instanceof ComputerPlayer) {
    45.                     this.room.removePlayer(player);
    46.                 }
    47.             }
    48.             this.room = null;
    49.         }
    50.     }

    51.     /**
    52.      * 通过 WebSocket 信道发送消息给玩家
    53.      */
    54.     send(message, data) {
    55.         this.tunnel.emit(message, data);
    56.     }

    57.     /**
    58.      * 从 WebSocket 信道接收玩家的消息
    59.      */
    60.     receive(message, callback) {
    61.         this.tunnel.on(message, callback);
    62.     }
    63. }
    复制代码
    人类玩家和电脑玩家的逻辑是一致的,但是 IO 不同,人类玩家使用之前实现的 WebSocket 服务进行输入输出,而电脑玩家直接使用 EventEmiter 处理
    添加游戏服务入口游戏的实现已经完成了,接下来,编辑 websocket.js 添加服务入口,可参考下面的代码:
    示例代码:/data/release/weapp/websocket.js
    1. // 引入 url 模块用于解析 URL
    2. const url = require('url');
    3. // 引入 ws 支持 WebSocket 的实现
    4. const ws = require('ws');
    5. // 引入人类玩家
    6. const HumanPlayer = require('./game/HumanPlayer');

    7. // 导出处理方法
    8. exports.listen = listen;

    9. /**
    10. * 在 HTTP Server 上处理 WebSocket 请求
    11. * @param {http.Server} server
    12. * @param {wafer.SessionMiddleware} sessionMiddleware
    13. */
    14. function listen(server, sessionMiddleware) {
    15.     // 使用 HTTP Server 创建 WebSocket 服务,使用 path 参数指定需要升级为 WebSocket 的路径
    16.     const wss = new ws.Server({ server });

    17.     // 同时支持 /ws 和 /game 的 WebSocket 连接请求
    18.     wss.shouldHandle = (request) => {
    19.         const path = url.parse(request.url).pathname;
    20.         request.path = path;
    21.         return ['/ws', '/game'].indexOf(path) > -1;
    22.     };

    23.     // 监听 WebSocket 连接建立
    24.     wss.on('connection', (ws, request) => {
    25.         // request: 要升级到 WebSocket 协议的 HTTP 连接

    26.         // 被升级到 WebSocket 的请求不会被 express 处理,
    27.         // 需要使用会话中间节获取会话
    28.         sessionMiddleware(request, null, () => {
    29.             const session = request.session;
    30.             if (!session) {
    31.                 // 没有获取到会话,强制断开 WebSocket 连接
    32.                 ws.send(JSON.stringify(request.sessionError) || "No session avaliable");
    33.                 ws.close();
    34.                 return;
    35.             }
    36.             console.log(`WebSocket client connected with openId=${session.userInfo.openId}`);

    37.             // 根据请求的地址进行不同处理
    38.             switch (request.path) {
    39.                 case '/ws': return serveMessage(ws, session.userInfo);
    40.                 case '/game': return serveGame(ws, session.userInfo);
    41.                 default: return ws.close();
    42.             }
    43.         });
    44.     });

    45.     // 监听 WebSocket 服务的错误
    46.     wss.on('error', (err) => {
    47.         console.log(err);
    48.     });
    49. }

    50. /**
    51. * 进行简单的 WebSocket 服务,对于客户端发来的所有消息都回复回去
    52. */
    53. function serveMessage(ws, userInfo) {
    54.     // 监听客户端发来的消息
    55.     ws.on('message', (message) => {
    56.         console.log(`WebSocket received: ${message}`);
    57.         ws.send(`Server: Received(${message})`);
    58.     });

    59.     // 监听关闭事件
    60.     ws.on('close', (code, message) => {
    61.         console.log(`WebSocket client closed (code: ${code}, message: ${message || 'none'})`);
    62.     });

    63.     // 连接后马上发送 hello 消息给会话对应的用户
    64.     ws.send(`Server: 恭喜,${userInfo.nickName}`);
    65. }

    66. /**
    67. * 使用 WebSocket 进行游戏服务
    68. */
    69. function serveGame(ws, userInfo) {
    70.     const user = {
    71.         uid: userInfo.openId,
    72.         uname: userInfo.nickName,
    73.         uavatar: userInfo.avatarUrl
    74.     };
    75.     // 创建玩家
    76.     const player = new HumanPlayer(user, ws);
    77.     // 玩家上线
    78.     player.online();
    79. }
    复制代码
    安装 co 模块我们的源码中使用到了 co 进行协程管理,启动游戏服务前,需要先安装:
    1. cd /data/release/weapp
    2. npm install co --save
    复制代码
    测试游戏服务重启 Node 服务:
    1. pm2 restart app
    复制代码
    打开配套的小程序,点击 实验四 - 剪刀石头布小游戏,点击 开始 按钮进行游戏。
    完成实验恭喜!您已经完成了小程序服务的全部实验内容


腾讯云
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

精彩图文



在线客服(工作时间:9:00-22:00)
400-600-6565

内容导航

zuntop公众号

Copyright   ©2015-2019  尊托云数  Powered by©Discuz!  技术支持:尊托网络     ( 湘ICP备15009499号 )