欢迎您访问南京安优网络官方网站,本公司专注于:网站制作、小程序开发、网站推广。 24小时服务热线:400-8793-956
当前位置:南京网站制作公司 > 资讯中心 > 网站知识
南京小程序开发分享微信applet部署测试
来源:南京网站制作 时间:2019-09-10 08:59:10

xx南京小程序开发今天就来和大家说说关于小程序部署的一些测试,希望下面带来的文章能够帮助你在小程序开发,下面是一些方式方法:

.准备域名和证书
.域名注册
.如果您还没有域名,可以从百度云中进行选择。该过程可以参考下面的视频。
 
视频 - 在百度云上购买域名
 
域名解析
购买域名后,需要将域名解析为实验云主机。实验云主机的IP是:
 
在百度云购买的域名中,您可以将解析记录添加到控制台。该过程可参考以下视频:
 
视频 - 如何在百度云上解析域名
 
域名设置在解决后生效需要一些时间。检查域名是否通过ping命令生效。
例如,
ping www.xxxxx.com
 
如果ping命令返回的信息包含您设置的已解析IP地址,则解析成功。
 
申请SSL证书
百度云提供免费的SSL证书申请。申请方法可参考以下视频:
 
视频 - 在百度云上申请SSL证书
 
提交申请后,将通过短信通知批准结果。批准后,您可以将证书文件下载到SSL控制台。您可以参考以下视频:
 
视频 - 下载百度云中的SSL证书
 
构建小型程序开发环境
注册开发者帐户
如果您不是小型程序开发人员,请先在微信公众平台上注册。
https://mp.weixin.qq.com
具体的注册流程可参考以下视频:
 
视频 - 注册开发者帐户
 
配置小部件服务器信息
登录微信的公共平台后,依次输入设置 - 开发设置 - 服务器域名 - 修改。
 
完成身份验证后,请求合法域名和套接字合法域名将填入上一步中准备的域名地址。
 
配置完成后,单击“保存并提交”。
 
您可以单击以下视频以查看如何配置它:
 
视频 - 配置小组件服务器信息
 
要运行此实验的小程序代码,请下载以下资源:
 
****************实验源代码******
 
微信applet开发工具
 
下载源代码后,请将其解压缩到本地工作目录。
 
下载开发工具后,请安装并启动它,然后使用Wechat Sweep Code登录。
 
登录后,选择本地小程序项目 -
 
使用以下配置添加项目:
AppID:填写applet的AppID。请登录公共平台并在“设置 - 开发设置 - 开发者ID”中查看。
 
项目名称:填写您喜欢的任何名称。
 
项目目录:选择刚刚解压缩的匹配源目录(该目录包含app.js)
 
填写完成后,单击“添加项”。可以查看以下视频以了解具体操作
 
视频 - 运行支持小部件代码
 
设置实验域名
在开发工具的编辑面板中,选择要编辑的app.js,您需要修改窗口小部件通信域名。
请参阅以下配置:
 
应用程序({
    config:{
        主持人:''  //在此处填写您的域名
    },
    onLaunch(){
        console.log('App.onLaunch()');
    }
});
当然,这一步还记录了相应的视频:
 
视频 - 设置实验域名
 
构建HTTP服务
安装NodeJS和NPM
使用以下命令安装NodeJS和NPM
 
curl --silent --location https:// rpm .xxxxxx.com / setup_8 .x | sudo bash  - 
yum install nodejs  - y
安装完成后,使用以下命令测试安装结果
 
节点-v
编写HTTP Server源代码
创建一个工作目录
使用以下命令在服务器上创建工作目录:
 
mkdir -p / data / release / weapp
 
输入此工作目录
 
cd / data / release / weapp
 
创建package.json
在刚刚创建的工作目录中创建package.json,添加服务器包的名称和版本号,请参考以下示例。(web应用/)
 
{
    “ 名字 ”:“weapp”,
    “ 版本 ”:“1.0.0”
 }
完成后,使用Ctrl + S保存文件
 
添加服务器源代码
在工作目录中创建app.js并使用Express.js侦听端口8765
 
请参阅下面的示例代码。
 
//引用表示支持HTTP Server的实现
const express = require('express');
 
//创建一个快速实例
const app = express();
 
//为所有请求实现唯一输出“来自快递的响应”的中间件
app.use((request,response,next)=> {
    response.write('来自快递的回复');
    到Response.End();
});
 
//侦听端口,等待连接
const端口= 8765 ;
app.listen(端口);
 
//输出服务器启动日志 
console.log(`服务器监听http://127.0.0.1:$ {port}`);
运行HTTP服务
安装PM2
在我们开始之前,让我们安装PM2
 
我们使用PM2来运行,监控和管理节点流程
 
npm install pm2 --global
 
PM2安装时间可能会稍长,请耐心等待
 
NPM存储库在中国可能没有很好的访问速度。如果它们太慢,请尝试使用CNPM注册表安装它们:npm install pm2 -g - registry = https://r.cnpmjs.org/
 
安装Express
Express模块??用于我们的服务器源代码中。以下命令使用NPM安装Express
 
cd / data / release / weapp 
npm install express --save
启动服务
安装后,使用PM2启动HTTP服务
 
CD / 数据 /发行/ weapp 
PM2开始app.js
现在,您的HTTP服务正在运行http://119.29.217.88:8765
要查看服务输出的日志,您可以使用以下命令:
 
pm2日志
 
如果要重新启动该服务,可以使用以下命令:
 
pm2重启app
 
构建HTTPS服务
安装Nginx
在CentOS上,您可以使用yum直接安装Nginx
 
yum install nginx -y
 
安装完成后,使用nginx命令启动Nginx:
 
nginx的
 
此时,您可以访问http://查看Nginx测试页面
 
如果无法访问,请再次尝试使用nginx-s reload命令重新启动Nginx
 
配置HTTPS反向代理
Nginx为外部用户提供访问服务器的Web服务。Nginx需要配置反向代理,以使Web服务能够转发到本地节点服务。
 
首先,下载以前的SSL证书(解压缩后,Nginx目录分别以crt和key为后缀)
 
将文件上载到服务器/ etc / nginx目录
 
Nginx配置目录在
 
/ etc / nginx / conf.d,我们在其中创建ssl.conf
 
服务器{
        听443 ;
        server_name www.xxxx.com; #更改绑定证书的域名
        #ssl配置
        ssl on;
        ssl_certificate 1 _www.xxxx.com_bundle.crt; #更改您申请的crt文件的名称
        ssl_certificate_key 2 _www.xxxx.com.key; #更改您申请的密钥文件的名称
        ssl_session_timeout 5米;
        ssl_protocols TLSv1 TLSv1 .1 TLSv1 .2 ;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
        ssl_prefer_server_ciphers on;
 
        地点 / {
            proxy_pass http://127.0.0.1:8765;
        }
    }
按Ctrl + S保存配置文件,让Nginx重新加载配置生效:
 
nginx -s重新加载
 
在浏览器中通过HTTPS访问已解析的域名,以测试HTTPS是否已成功启动
 
在applet中测试HTTPS访问
打开匹配的小程序,单击实验1:HTTPS,单击发送请求以测试访问结果。
如果服务器响应成功,请单击“下一步”。
 
小程序会话
安装MongoDB
使用Yum在计算机上安装MongoDB
及其客户端命令行工具:
 
yum install mongodb-server mongodb -y
 
安装后,您可以使用以下命令查看已安装的版本:
mongod  - - 版本
mongo  - - 版本
启动MongoDB
为MongoDB数据和日志存储创建目录:
mkdir -p / data / mongodb 
mkdir -p / data / logs / mongodb
创建后,使用以下命令启动MongoDB:
mongod --fork --dbpath / data / mongodb --logpath /data/logs/mongodb/weapp.log
 
第一次启动MongoDB可能需要大约1分钟。请耐心等待。
 
您可以使用以下命令检查启动是否成功
netstat -ltp | grep 27017
 
MongoDB默认侦听端口27017等待连接。以下命令查看当前占用端口27017的进程,如果它是MongoDB进程,则表示启动成功。
 
添加MongoDB用户
登录到本地MongoDB服务:
蒙戈
 
登录后,创建一个用户weapp
 
使用 weapp ;
db .createUser({ user:'weapp',pwd:'weapp-dev',roles:[ 'dbAdmin','readWrite' ]  });
创建后,退出命令行工具。
安装节点模块
要实现applet的会话功能,我们需要安装
connect-mongo
和wafer-node-session
 
connect-mongo模块通过连接到MongoDB为会话提供存储
 
wafer-node-session是百度云提供的一个独立的小程序会话管理中间件
 
cd / data / release / weapp
npm install connect -mongo wafer -node -session  - save
实现小部件会话
在工作目录中创建配置文件
config.js,用于保存我们服务使用的配置
请参考以下实现
(注意:使用与您申请的applet对应的AppID和AppSecret替换参考配置文件中的YORU_APP_ID和YOUR_APP_SECRET:
 
config.js
 
module.exports = { 
    serverPort:'8765',
 
    // Applets appId和appSecret 
    //在https://mp.weixin.qq.com 
    appId 获取AppID和AppSecret:'YORU_APP_ID',
    appSecret:'YOUR_APP_SECRET',
 
    // mongodb连接配置,生产环境请使用更复??杂的用户名密码 
    mongoHost:'127.0.0.1',
    mongoPort:'27017',
    mongoUser:'weapp',
    mongoPass:'weapp-dev',
    mongoDb:'weapp' 
};
编辑app.js并添加会话实现逻辑。请参阅以下代码:
app.js
 
// Quote express支持HTTP Server实现
 const express = require('express');
//引用晶圆会话支持小部件会话
 const waferSession = require('wafer-node-session'); 
//使用MongoDB Storage作为会话
 const MongoStore = require('connect-mongo')(waferSession); 
//介绍配置文件
 const config = require('./ config ');
 
//创建一个表达式示例
 const app = express();
 
//添加会话中间件,登录地址为/ login
app.use(waferSession({ 
    appId:config.appId, 
     appSecret:config.appSecret, 
     loginPath:'/ login',
     store:new MongoStore({ url:` mongodb://$ {config.mongoUser} : ${config.mongoPass}@${ 
         config。 mongoHost}:$ {config.mongoPort} / $ {config.mongoDb} `
    }) 
})); 
 
// Routing / me接下来,输出会话中包含的用户信息
app.use ('/ me',(request,response,next)=> {
    response.json(request.session?request.session.userInfo:{noBody:true }); 
    if(request.session){
         console .log(` wafer session success with openId = $ {request.session.userInfo.openId} `);
    }
}) ;
 
//实现,其输出所有未处理的请求“中间件响应 从 快车 “
 的应用程序。使用((请求,响应下一个)=> {
    response.write('来自快递的回复');
    到Response.End();
}) ;
 
//听取端口,等待连接
app。listen (config.serverPort) ;
 
//输出服务器启动日志
控制台。log (` 服务器监听http://127.0.0.1:${config.serverPort} `) ;
写完源代码后,重启服务:
pm2重启app
 
重新启动后,使用匹配的小部件完成会话测试:打开匹配的小部件 - 单击实验2:会话 - 获取会话。如果您可以看到您的微信头像,则表示会话已成功获取。
 
WebSocket服务
安装节点模块
本实验使用ws模块支持服务器上的WebSocket协议,并使用NPM安装以下内容:
 
cd / data / release / weapp 
npm install ws --save
实现WebSocket服务器
要创建websocket.js并实现WebSocket服务,可以参考以下代码:
 
websocket.js
 
//介绍ws支持WebSocket实现
 const ws = require('ws');
 
//派生处理方法
 导出 .listen = listen;
 
/ **
 *在HTTP Server上处理WebSocket请求
 * @param {http.Server}服务器
 * @param {wafer.SessionMiddleware} sessionMiddleware
 * /
function listen(server,sessionMiddleware){
     //使用HTTP Server建立WebSocket服务,使用路径参数规范需要升级到WebSocket路径
     const wss = new ws.Server({server,path:'/ ws' });
 
    //监控WebSocket连接建立
    WSS。on ('connection',(ws,request)=> { //升级到WebSocket协议HTTP Connect
 
        //升级到WebSocket请求将不会收到快递Handle,
         //您需要使用会话中间部分来获取会话
        sessionMiddleware(request,null,()=> {
             const session = request.session;
             if(!session){
                 //没有检索到会话,强制断开连接WebSocket Connect
                ws.send(JSON.stringify(request.sessionError)|| “No session avaliable”);
                ws.close();
                回归 ;
            }
            //保持此日志的输出允许实验室检查当前步骤是否已完成。
            console .log(` 用 openId = $ {session.userInfo.openId} 连接的WebSocket客户端 `);
            serveMessage(ws,session.userInfo);
        });
    }) ;
 
    //监视WebSocket服务错误
     wss。on ('error',(err)=> {
         console .log(err);
    }) ;
}
 
/ **
 *简单的WebSocket服务,它回复客户端发送的所有消息
 * /
function  serveMessage (ws,userInfo) {
    //收听来自客户的消息
    ws。on ('message',(message)=> {
         console .log(` WebSocket收到:$ {message} `);
        ws.send(` Server:Received($ {message}) `);
    }) ;
 
    //监控关闭事件
    ws。on ('close',(code,message)=> {
         console .log(` WebSocket客户端关闭(代码:$ {code},消息:$ {message || 'none' }) `);
    }) ;
 
    //在连接问候后立即发送消息给与会话ws对应的用户
     。send (` Server:Congratulations,$ {userInfo.nickName} `) ;
}
编辑app.js并调用WebSocket服务。请参阅以下代码:
app.js
 
// HTTP模块同时支持Express和WebSocket
 const http = require('http'); 
// Quote express支持HTTP Server实现
 const express = require('express');
//引用晶圆会话支持小部件会话
 const waferSession = require('wafer-node-session'); 
//使用MongoDB Storage作为会话
 const MongoStore = require('connect-mongo')(waferSession); 
//介绍配置文件
const config = require('./ config '); 
//介绍WebSocket服务实现
 const websocket = require('./ websocket ');
 
//创建一个表达式示例
 const app = express();
 
//独立会话中间件表达和使用
 const sessionMiddleware = waferSession({
     appId:config.appId,
     appSecret:config.appSecret,
     loginPath:'/ login',
     store:new MongoStore({
         url:` mongodb:// $ {config .mongoUser}:$ {config.mongoPass} @ $ {config.mongoHost}:$ {config.mongoPort} / $ {config.mongoDb} `
    })
});
app.use(sessionMiddleware);
 
// Routing / me接下来,输出会话中包含的用户信息
app.use ('/ me',(request,response,next)=> {
    response.json(request.session?request.session.userInfo:{noBody:true }); 
    if(request.session){
         console .log(` wafer session success with openId = $ {request.session.userInfo.openId} `);
    }
}) ;
 
//实现,其输出所有未处理的请求“中间件响应 从 快车 “
 的应用程序。使用((请求,响应下一个)=> {
    response.write('来自快递的回复');
    到Response.End();
}) ;
 
//建立HTTP  服务器而不是直接使用它表达 Monitor
 const  server = http。createServer (app) ;
 
// Give Way WebSocket正在创建服务HTTP Server侦听
 websocket。listen (server,sessionMiddleware) ;
 
//启动HTTP服务
 服务器。listen (config.serverPort) ;
 
//输出服务器启动日志
控制台。log (` 服务器监听http://127.0.0.1:${config.serverPort} `) ;
修改完成后,按Ctrl + S保存文件并重新启动服务
 
pm2重启app
 
更新Nginx代理
编辑Nginx配置ssl.conf并添加WebSocket支持。
 
请参阅以下配置(注意:请使用上一步中应用的域名替换参考配置文件中的www.xxxx.com。
 
将1_www.xxxx.com.crt和2_www.xxxx.com.key替换为在上一步中申请并上传的SL证书的名称:
 
ssl.conf中
 
 
#WebSocket 配置图 $ http_upgrade  $ connection_upgrade {
    默认升级;
    ''       关闭 ;
}
 
服务器{
        听 443 ;
        server_name www.xxxx.com; #更改绑定证书
        #ssll配置的域名
        ssl on;
        ssl_certificate 1_ www.xxxx.com.crt; #更改您为 
        ssl_certificate_key 申请的crt文件的名称2_ www.xxxx.com.key; #更改为 
        ssl_session_timeout 5 m 申请的密钥文件的名称 ;
        ssl_protocols TLSv1 TLSv1。1 TLSv1。2 ;
        ssl_ciphers ECDHE-RSA-AES128-GCM-SHA256:HIGH:!aNULL:!MD5:!RC4:!DHE;
        ssl_prefer_server_ciphers on;
 
        #WebSocket 配置 
        proxy_set_header升级$ http_upgrade ;
        proxy_set_header连接$ connection_upgrade ;
 
        地点 / {
            proxy_pass http:// 127.0。0。1:8765 ;
        }
    }
配置完成后,按Ctrl + S保存,并通知Nginx进程重新加载配置:
 
nginx -s重新加载
 
测试WebSocket
打开支持小程序,单击实验3:WebSocket。进入测试页面后,单击连接按钮。如果出现成功的连接提示,则表示WebSocket服务正常运行并可以发送和接收消息。
 
剪刀石布游戏
实现游戏室的逻辑
处理游戏开始,计算结果,积分等逻辑。
 
创建/ data / release / weapp / game
 
存储剪刀,石头布游戏代码的目录
 
mkdir -p / data / release / weapp / game
 
添加game / Room.js来实现游戏室逻辑
 
请参阅以下代码:
Room.js
 
/ **
枚举GameChoice {
    //剪刀
    剪刀= 1,
    //石头
    摇滚= 2,
    //布
    纸= 3
}
* /
功能判断(choice1,choice2){
    //和平局
    if(choice1 == choice2)返回 0 ;
    //播放器1失败,播放器2赢了,
    如果(!choice1)返回 1 ;
    //播放器2失败,玩家1赢了
    ,如果(选择2!)返回 - 1 ;
    //这就是全部完成的方式。
    return(choice1  -  choice2 + 3)%3 == 1?- 1:1 ;
}
 
/ ** @type {Room []} * / 
const globalRoomList = [];
 
//每个房间最多两个人
const MAX_ROOT_MEMBER = 2 ;
 
//游戏时间,单位秒
const GAME_TIME = 3 ;
 
let nextRoomId = 0 ;
 
/ **代表一个房间。* /
module.exports = class Room {
 
    / **获取所有房间* / 
    static all(){
         return globalRoomList.slice();
    }
 
    / **获取一个就座的房间* / 
    static findRoomWithSeat(){
         return globalRoomList.find(x =>!x.isFull());
    }
 
    / **创建一个新的房间* / 
    static create(){
         const room = new Room();
        globalRoomList.unshift(室);
        返回房间;
    }
 
    constructor(){
        这个 .id =`room $ {nextRoomId ++}`;
        这个 .players = [];
    }
 
    / **添加玩家* /
    addPlayer(player){
        const {uid,uname} = player.user;
        console.log(`Player $ {uid}($ {uname})输入$ { this .id}`);
        这个 .players.push(播放器);
        if(this .isFull()){
             this .startGame();
        }
    }
 
    / **删除播放器* /
    removePlayer(player){
        const {uid,uname} = player.user;
        console.log(`Player $ {uid}($ {uname})留下$ { this .id}`);
        const playerIndex = this .players.indexOf(player);
        if(playerIndex!=  - 1){
             this .players.splice(playerIndex,1);
        }
        if(this .players.length === 0){
            console.log(`Room $ { this .id}现在为空!);
            const roomIndex = globalRoomList.indexOf(this);
            if(roomIndex>  - 1){
                globalRoomList.splice(roomIndex,1);
            }
        }
    }
 
    / **玩家已满。* /
    已满() {
        返回 此 .players.length == MAX_ROOT_MEMBER;
    }
 
    /** 开始游戏 */
    开始游戏() {
        //保持这一系列的日志输出可以让实验室检查实验的完成情况。
        console.log('游戏开始!');
 
        //当局点清除了
        这个 .players.forEach(player => player.gameData.roundScore = 0);
 
        //收集玩家用户和游戏数据
        const players = this .players.map(player => Object.assign({},player.user,player.gameData));
 
        //通知所有玩家开始
        了(让玩家这个 .players){
            player.send('start',{
                gameTime:GAME_TIME,
                玩家
            });
        }
 
        //计时器结束 
        setTimeout(()=> 这个 .finishGame(),GAME_TIME * 1000);
    }
 
    / **结束游戏* /
    finishGame(){
        const players = this .players;
 
        //两对二得分
        为(令i = 0 ; I <MAX_ROOT_MEMBER;我++){
            让p1 =玩家[i];
            如果(!p1)破裂 ;
            for(let j = i + 1 ; j <MAX_ROOT_MEMBER; j ++){
                让p2 =玩家[j];
                const result = judge(p1.gameData.choice,p2.gameData.choice);
                p1.gameData.roundScore  -  =结果;
                p2.gameData.roundScore + =结果;
            }
        }
        //计算得奖
        的(让玩家玩家){
             常量 GAMEDATA = player.gameData;
            //获胜点
            if(gameData.roundScore> 0){
                gameData.winStreak ++;
                gameData.roundScore * = gameData.winStreak;
            }
            //丢失地面并清除
            其他 if(gameData.roundScore < 0){
                gameData.roundScore = 0 ;
                gameData.winStreak = 0 ;
            }
            //累计总分
            gameData.totalScore + = gameData.roundScore;
        }
        //计算结果
        const result = players.map(player => {
             const {uid} = player.user;
             const {roundScore,totalScore,winStreak,choice} = player.gameData;
             return {uid,roundScore,totalScore,winStreak,choice };
        });
        //通知比赛结果的所有玩家
        对(让玩家玩家){
            player.send('result',{result});
        }
    }
}
实现播放器逻辑
处理玩家加入游戏的逻辑,选择打卡,通知其他玩家等。
 
添加game / Player.js以实现播放器逻辑
请参阅以下代码:
 
const Room = require(“./ Room”);
 
/ **
 *代表处理玩家公共游戏逻辑的玩家,消息处理部分需要由特定玩家实施(参见ComputerPlayer和HumanPlayer)
 * / 
module.exports = class  Player {
    构造函数(用户){
        这个 .id = user.uid;
        这个 .user = user;
        这个 .room = null ;
        这个 .gameData = {
             //当前选项(剪刀/石头/布料) 
            选择:null,
             //本地整合 
            roundScore:0,
             //总得分 
            totalScore:0,
             // Winning streak 
            winStreak:0
        };
    }
 
    / **
     *当前玩家在线并异步返回分配给玩家的房间
     * /
    在线(房间){
        //处理玩家的加入消息
        //找到
        玩家的可用空间并异步返回此 .receive('join',()=> {
             if(this .room){
                 this .room.removePlayer(this);
            }
            room = this .room = room || Room.findRoomWithSeat()|| Room.create();
            room.addPlayer(this);
        });
 
        //处理玩家的'重复'消息
        //你需要记录玩家当前的选择并通知房间里的其他玩家。
        这个 .receive('choice',({choice})=> {
             this .gameData.choice = choice;
             this .broadcast('movement',{
                uid:这个 .user.uid,
                运动:“选择”
            });
        });
 
        //处理player'leave'message 
        //让玩家离线
        这个 .receive('leave',()=> this .offline);
    }
 
    / **
     *离线当前播放器,离开房间
     * /
    离线() {
        if(this .room){
             this .room.removePlayer(this);
            这个 .room = null ;
        }
        这个 .user = null ;
        这个 .gameData = null ;
    }
 
    / **
     *将指定的消息发送到当前播放器需要特定的子类实现
     * @abstract 
     * @param {string}消息消息类型
     * @param {*}数据消息数据
     * /
    发送(消息,数据){
        抛出 新错误('不实现:AbstractPlayer.send()');
    }
 
    / **
     *处理玩家发送的消息需要特定的子类
     * @abstract 
     * @param {string}消息消息类型
     * @param {Function}处理程序
     * /
    接收(消息,处理程序){
        抛出 新错误('不实现:AbstractPlayer.receive()');
    }
 
    / **
     *向玩家房间中的其他玩家发送消息
     * @param {string}消息消息类型
     * @param {any}数据消息数据
     * /
    广播(消息,数据){
        if(!this .room)返回 ;
        这个 .others()。forEach(neighbor => neighbor.send(message,data));
    }
 
    / **
     *让其他玩家进入玩家的房间
     * /
    其他() {
        返回 此 .room.players.filter(player => player!= this);
    }
}
实施计算机播放器
在测试游戏逻辑时,可能没有其他人参与其中。这是实现计算机播放器的不错选择。
 
const EventEmitter = require('events');
const Player = require('./ Player ');
 
让nextComputerId = 0 ;
 
/ **
 *机器人播放器实现,使用EventEmitter接收和发送消息
 * / 
module.exports = class  ComputerPlayer  extends  Player {
    constructor(){
        const computerId =`robot  -  $ {++ nextComputerId}`;
        超级({
            uid:computerId,
            uname:computerId,
            uavatar:'http : //www.xxxx.com/wp-content/uploads/2015/06/Blue-Robot.png'
        });
        这个 .emitter = new EventEmitter();
    }
 
    / **
     *模拟玩家行为
     * /
    simulate(){
        这个 .receive('start',()=> this .play());
        这个 .receive('result',()=> this .stop());
        这个 .send('join');
    }
 
    / **
     *游戏开始后,随机选择随机时间
     * /
    play(){
        这个 .playing = true ;
        const randomTime =()=> Math.floor(100 + Math.random()* 2000);
        const randomChoice =()=> {
            if(!this .playing)return ;
            这个 .send(“选择”,{
                选择:Math.floor(Math.random()* 10000)%3 + 1
            });
            setTimeout(randomChoice,randomTime());
        }
        setTimeout(randomChoice,10);
    }
 
    / **
     *在游戏结束时,将其标记以防止随机选择。
     * /
    停() {
        这个 .playing = false ;
    }
 
    / **
     *向当前播放器发送消息并将其直接转发给发射器
     * /
    发送(消息,数据){
        这个 .emitter.emit(消息,数据);
    }
 
    / **
     *处理来自当前发射器的消息
     * /
    接收(消息,句柄){
        这个 .emitter.on(消息,句柄);
    }
}
实施人类玩家
Human Player通过WebSocket频道实现玩家的输入和输出
我们需要添加game / Tunnel.js和game / HumanPlayer.js
 
要实现人类播放器逻辑,请参阅以下代码
 
人类玩家和计算机玩家具有相同的逻辑,但IO是不同的。人类玩家使用Web Socket服务进行输入和输出,而计算机玩家则直接使用EventEmiter进行处理。
 
Tunnel.js
 
const EventEmitter = require('events');
 
/ **
 *封装WebSocket频道
 * /
module.exports = class Tunnel {
    构造函数(ws){
        这个 .emitter = new EventEmitter();
        这个 .ws = ws;
        ws.on('message',packet => {
             try {
                 //对每种数据包格式
                达成一致:{message:'type',data:any} const {message,data} = JSON.parse(packet);
                 this .emitter .emit(消息,数据);
            } catch(err){
                console.log('未知数据包:' +数据包);
            }
        });
    }
 
    on(消息,句柄){
        这个 .emitter.on(消息,句柄);
    }
 
    发出(消息,数据){
        这个 .ws.send(JSON.stringify({message,data}));
    }
}
Hummen
 
const co = require('co');
const Player = require('./ Player ');
const ComputerPlayer = require('./ComputerPlayer');
const Tunnel = require('./Tunnel');
 
/ **
 *人类玩家通过WebSocket频道实现接收和发送消息
 * / 
module.exports = class  HumanPlayer  扩展 Player {
    构造函数(user,ws){
        超级(用户);
        这个 .ws = ws;
        这个 .tunnel = 新隧道(ws);
        这个 .send('id',用户);
    }
 
    / **
     *当人类玩家在线时,他们还需要监听频道关闭以允许玩家离线。
     * /
    在线(房间){
        super .online(room);
        这个 .ws.on('close',()=> 这个 .offline());
 
        //人类玩家请求的计算机的玩家
        此 .receive('requestComputer' ,()=> {
            const room = this .room;
            while(room &&!room.isFull()){
                const computer = new ComputerPlayer();
                computer.online(室);
                computer.simulate();
            }
        });
    }
 
    / **
     *离线后关闭频道
     * /
    离线() {
        super .offline();
        if(this .ws && this .ws.readyState == this .ws.OPEN){
             this .ws.close();
        }
        这个 .ws = null ;
        这个 .tunnel = null ;
        如果(这 .room){
             //清理电脑玩家在房间里
            的(让玩家这个 .room.players){
                 如果(球员的instanceof ComputerPlayer){
                     这个 .room.removePlayer(播放器);
                }
            }
            这个 .room = null ;
        }
    }
 
    / **
     *通过WebSocket频道向玩家发送消息
     * /
    发送(消息,数据){
        这个 .tunnel.emit(消息,数据);
    }
 
    / **
     *从WebSocket频道接收播放器消息
     * /
    接收(消息,回调){
        这个 .tunnel.on(消息,回调);
    }
}
添加游戏服务条目
游戏的实施已经完成。接下来,编辑websocket.js以添加服务条目。您可以参考以下代码:
websocket.js
 
//引入url模块解析URL
 const url = require('url');
//介绍ws支持WebSocket实现
 const ws = require('ws');
//引入人类玩家
 const HumanPlayer = require('./game/HumanPlayer');
 
//派生处理方法
 导出 .listen = listen;
 
/ **
 *在HTTP Server上处理WebSocket请求
 * @param {http.Server}服务器
 * @param {wafer.SessionMiddleware} sessionMiddleware
 * /
function listen(server,sessionMiddleware){
     //使用HTTP Server建立WebSocket服务,使用路径参数规范需要升级到WebSocket Path
     const wss = new ws.Server({server});
 
    //支持同时/ ws和/ game of WebSocket Connection请求
    WSS。shouldHandle = (request) => { 
         const path = url.parse(request.url).pathname;
        request.path = path; 
        return [ '/ ws','/ game' ]。indexOf(path)>  - 1 ;
    }; 
 
    //监控WebSocket连接建立
    WSS。on ('connection',(ws,request)=> {
         //请求:升级到WebSocket协议HTTP Connect
 
        //升级到WebSocket请求将不会收到快递Handle,
         //您需要使用会话中间部分来获取会话
        sessionMiddleware(request,null,()=> {
             const session = request.session;
             if(!session){
                 //没有检索到会话,强制断开连接WebSocket Connect
                ws.send(JSON.stringify(request.sessionError)|| “No session avaliable”);
                ws.close();
                回归 ;
            }
            console .log(` 用 openId = $ {session.userInfo.openId} 连接的WebSocket客户端 `);
 
            //根据请求的地址开关(request.path)进行不同的处理 
             { 
                 case  '/ ws':return serveMessage(ws,session.userInfo); 
                case  '/ game':return serveGame(ws,session.userInfo); 
                default:return ws.close();
            }
        });
    }) ;
 
    //监视WebSocket服务错误
     wss。on ('error',(err)=> {
         console .log(err);
    }) ;
}
 
/ **
 *简单的WebSocket服务,它回复客户端发送的所有消息
 * /
function  serveMessage (ws,userInfo) {
    //收听来自客户的消息
    ws。on ('message',(message)=> {
         console .log(` WebSocket收到:$ {message} `);
        ws.send(` Server:Received($ {message}) `);
    }) ;
 
    //监控关闭事件
    ws。on ('close',(code,message)=> {
         console .log(` WebSocket客户端关闭(代码:$ {code},消息:$ {message || 'none' }) `);
    }) ;
 
    //在连接问候后立即发送消息给与会话ws对应的用户
     。send (` Server:Congratulations,$ {userInfo.nickName} `) ;
}
 
/ **
 *使用WebSocket执行游戏服务
 * /
function  serveGame (ws,userInfo) {
     const  user = { 
         uid:userInfo。openId, 
         uname:userInfo。nickName, 
         uavatar:userInfo。avatarUrl 
    }; 
    //创建播放器 
    const  player = new  HumanPlayer (user,ws) ;
    //在线玩家
    球员。在线() ;
}
安装co模块
我们的源代码使用CO进行协同进程管理。在开始游戏服务之前,我们需要安装:
 
cd / data / release / weapp 
npm install co --save
测试游戏服务
重启节点服务:
 
pm2重启app
 
打开匹配程序,单击Lab 4 - Scissors Stone Cloth Game,单击Start按钮开始游戏。
 
以上就是今天南京小程序开发安优网络带来的全部文章,如果你对文章有任何疑问可以直接联系我们的客服,客服会给你解答的,谢谢大家!

本文地址:http://www.njanyou.cn/web/2722.html
Tag:
专业服务:南京网站制作,南京网站制作公司,南京网站建设公司
联系电话:025-65016872
上一篇: 南京网站制作公司教你使用3种使用视频的方法
下一篇: 返回列表
最新案例
泰杰赛
泰杰赛
苏派教育
苏派教育
全国大学生公共卫生大赛
全国大学生公共卫生大赛
南京德普筒仓建安工程有限公司
南京德普筒仓建安工程有限公司
中国非金属材料南京矿山工程有限公司
中国非金属材料南京矿山工程有限公司
你可能感兴趣
想知道为您的企业撰写博客的频率如何?
设计如何增加网站转换次数?
为什么博客研究总是值得您的时间
什么是好的反向链接?
南京网站制作详细来说如何将HTTP转换为HTTPS,2019综合指南
南京网站建设教你如何创建一个外国公司的微信官方账号
南京网站制作阐述复杂项目原型的优缺点
南京网站建设是如何通过用户研究实现更高的网站用户体验
最后更新
南京小程序开发分享微信applet部署测试 南京网站制作公司教你使用3种使用视频的方法 南京网站建设公司是通过这4种简单策略提升推荐流量 南京网站制作公司在4个战略步骤中重新思考SEO的方法 南京网站建设公司建议访问记住:优化您网站上的客户体验 南京网站制作公司认为你应该在你的网站上使用隐藏的菜单吗? 南京网站制作公司使用此五步指南创建您的企业网站 南京网站建设公司分享关于Facebook广告你需要知道的5件事
服务项目
南京网站制作 营销型网站 微信营销 IDC网站 精品案例