一.前期回顾
对于前面内容不太了解的,可以去看一看下面的文章:
二.游戏房间建立长连接
cpp
void wsopen_game_room(wsserver_t::connection_ptr conn)
{
//1.获取当前客户端的session
Json::Value resp_json;
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
return;
}
//2.获取当前用户是否在其他游戏房间或游戏大厅中了
if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_hall(ssp->get_user()))
{
resp_json["optype"] = "room_ready";
resp_json["reason"] = "玩家重复登录!";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//3.判定当前用户是否以及创建好了房间
room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
if(rp.get() == nullptr)
{
resp_json["optype"] = "room_ready";
resp_json["reason"] = "没有找到玩家的房间信息!";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//4.将当前用户添加到在线用户管理的游戏房间中
_om.enter_game_room(ssp->get_user(),conn);
//5.将session设置成永久存在
_sm.set_session_expire_time(ssp->ssid(),SESSION_FOREVER);
//6.回复房间准备好了
resp_json["optype"] = "room_ready";
resp_json["result"] = true;
return ws_resp(conn,resp_json);
}三.游戏房间长连接关闭
cpp
void wsclose_game_room(wsserver_t::connection_ptr conn)
{
//游戏房间的长连接断开
//1.获取会话信息,识别客户端
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
return;
}
//2.将session回复生命周期的管理,设置定时销毁
_om.exit_game_room(ssp->get_user());
_sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
//3.将玩家从游戏房间移除,房间中所有用户退出了,就会销毁房
_rm.remove_room_user(ssp->get_user());
}四.游戏房间消息处理
cpp
void wsmsg_game_room(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg)
{
Json::Value resp_json;
std::string resp_body;
//1.获取session,识别客户端身份
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
return;
}
//2.获取客户端房间信息
room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
if(rp.get() == nullptr)
{
resp_json["optype"] = "unknow";
resp_json["reason"] = "没有找到玩家的房间信息!";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//3.对消息进行反序列化
Json::Value req_json;
std::string req_body = msg->get_payload();
bool ret = json_util::unserialize(req_body,req_json);
if(ret == false)
{
resp_json["optype"] = "unknow";
resp_json["reason"] = "请求解析失败";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//4.对消息进行处理
return rp->handle_request(req_json);
}五.聊天代码实现
html
else if (info.optype == "chat") {
//收到一条消息，判断result，如果为true则渲染一条消息到显示框中
if(info.result == false) {
alert(info.reason);
return;
}
var msg_div = document.createElement("p");
msg_div.innerHTML = info.message;
if (info.uid == room_info.uid) {
msg_div.setAttribute("id", "self_msg");
}else {
msg_div.setAttribute("id", "peer_msg");
}
var br_div = document.createElement("br");
var msg_show_div = document.getElementById("chat_show");
msg_show_div.appendChild(msg_div);
msg_show_div.appendChild(br_div);
document.getElementById("chat_input").value = "";
}
cpp
//3. 聊天动作
// 1. 捕捉聊天输入框消息
// 2. 给发送按钮添加点击事件，点击俺就的时候，获取到输入框消息，发送给服务器
var cb_div = document.getElementById("chat_button");
cb_div.onclick = function() {
var send_msg = {
optype : "chat",
room_id : room_info.room_id,
uid : room_info.uid,
message : document.getElementById("chat_input").value
};
ws_hdl.send(JSON.stringify(send_msg));
}
cpp
Json::Value handle_chat(Json::Value &req)
{
Json::Value json_resp = req;
//2.检测消息中是否包含敏感词
std::string msg = req["message"].asString();
size_t pos = msg.find("垃圾");
if(pos != std::string::npos)
{
json_resp["result"] = false;
json_resp["reason"] = "消息中包含敏感词,不能发送!";
return json_resp;
}
//3.广播消息--返回消息
json_resp["result"] = true;
return json_resp;
}六.room前端代码(全部)
html
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>游戏房间</title>
<link rel="stylesheet" href="css/common.css">
<link rel="stylesheet" href="css/game_room.css">
</head>
<body>
<div class="nav">网络五子棋对战游戏</div>
<div class="container">
<div id="chess_area">
<!-- 棋盘区域, 需要基于 canvas 进行实现 -->
<canvas id="chess" width="450px" height="450px"></canvas>
<!-- 显示区域 -->
<div id="screen"> 等待玩家连接中... </div>
</div>
<div id="chat_area" width="400px" height="300px">
<div id="chat_show">
<p id="self_msg">你好！</p></br>
<p id="peer_msg">你好！</p></br>
<p id="peer_msg">leihoua~</p></br>
</div>
<div id="msg_show">
<input type="text" id="chat_input">
<button id="chat_button">发送</button>
</div>
</div>
</div>
<script>
let chessBoard = [];
let BOARD_ROW_AND_COL = 15;
let chess = document.getElementById('chess');
let context = chess.getContext('2d');//获取chess控件的2d画布
var ws_url = "ws://" + location.host + "/room";
var ws_hdl = new WebSocket(ws_url);
var room_info = null;//用于保存房间信息
var is_me;
function initGame() {
initBoard();
context.strokeStyle = "#BFBFBF";
// 背景图片
let logo = new Image();
logo.src = "image/sky.jpeg";
logo.onload = function () {
// 绘制图片
context.drawImage(logo, 0, 0, 450, 450);
// 绘制棋盘
drawChessBoard();
}
}
function initBoard() {
for (let i = 0; i < BOARD_ROW_AND_COL; i++) {
chessBoard[i] = [];
for (let j = 0; j < BOARD_ROW_AND_COL; j++) {
chessBoard[i][j] = 0;
}
}
}
// 绘制棋盘网格线
function drawChessBoard() {
for (let i = 0; i < BOARD_ROW_AND_COL; i++) {
context.moveTo(15 + i * 30, 15);
context.lineTo(15 + i * 30, 430); //横向的线条
context.stroke();
context.moveTo(15, 15 + i * 30);
context.lineTo(435, 15 + i * 30); //纵向的线条
context.stroke();
}
}
//绘制棋子
function oneStep(i, j, isWhite) {
if (i < 0 || j < 0) return;
context.beginPath();
context.arc(15 + i * 30, 15 + j * 30, 13, 0, 2 * Math.PI);
context.closePath();
var gradient = context.createRadialGradient(15 + i * 30 + 2, 15 + j * 30 - 2, 13, 15 + i * 30 + 2, 15 + j * 30 - 2, 0);
// 区分黑白子
if (!isWhite) {
gradient.addColorStop(0, "#0A0A0A");
gradient.addColorStop(1, "#636766");
} else {
gradient.addColorStop(0, "#D1D1D1");
gradient.addColorStop(1, "#F9F9F9");
}
context.fillStyle = gradient;
context.fill();
}
//棋盘区域的点击事件
chess.onclick = function (e) {
// 1. 获取下棋位置，判断当前下棋操作是否正常
// 1. 当前是否轮到自己走棋了
// 2. 当前位置是否已经被占用
// 2. 向服务器发送走棋请求
if (!is_me) {
alert("等待对方走棋....");
return;
}
let x = e.offsetX;
let y = e.offsetY;
// 注意, 横坐标是列, 纵坐标是行
// 这里是为了让点击操作能够对应到网格线上
let col = Math.floor(x / 30);
let row = Math.floor(y / 30);
if (chessBoard[row][col] != 0) {
alert("当前位置已有棋子！");
return;
}
//oneStep(col, row, true);
//向服务器发送走棋请求，收到响应后，再绘制棋子
send_chess(row, col);
}
function send_chess(r, c) {
var chess_info = {
optype : "put_chess",
room_id: room_info.room_id,
uid: room_info.uid,
row: r,
col: c
};
ws_hdl.send(JSON.stringify(chess_info));
console.log("click:" + JSON.stringify(chess_info));
}
window.onbeforeunload = function() {
ws_hdl.close();
}
ws_hdl.onopen = function() {
console.log("房间长连接建立成功");
}
ws_hdl.onclose = function() {
console.log("房间长连接断开");
}
ws_hdl.onerror = function() {
console.log("房间长连接出错");
}
function set_screen(me) {
var screen_div = document.getElementById("screen");
if (me) {
screen_div.innerHTML = "轮到己方走棋...";
}else {
screen_div.innerHTML = "轮到对方走棋...";
}
}
ws_hdl.onmessage = function(evt) {
//1. 在收到room_ready之后进行房间的初始化
// 1. 将房间信息保存起来
var info = JSON.parse(evt.data);
console.log(JSON.stringify(info));
if (info.optype == "room_ready") {
room_info = info;
is_me = room_info.uid == room_info.white_id ? true : false;
set_screen(is_me);
initGame();
}else if (info.optype == "put_chess"){
console.log("put_chess" + evt.data);
//2. 走棋操作
// 3. 收到走棋消息，进行棋子绘制
if (info.result == false) {
alert(info.reason);
return;
}
//当前走棋的用户id，与我自己的用户id相同，就是我自己走棋，走棋之后，就轮到对方了
is_me = info.uid == room_info.uid ? false : true;
//绘制棋子的颜色，应该根据当前下棋角色的颜色确定
isWhite = info.uid == room_info.white_id ? true : false;
//绘制棋子
if (info.row != -1 && info.col != -1){
oneStep(info.col, info.row, isWhite);
//设置棋盘信息
chessBoard[info.row][info.col] = 1;
}
//是否有胜利者
if (info.winner == 0) {
return;
}
var screen_div = document.getElementById("screen");
if (room_info.uid == info.winner) {
screen_div.innerHTML = info.reason;
}else {
screen_div.innerHTML = "你输了";
}
var chess_area_div = document.getElementById("chess_area");
var button_div = document.createElement("div");
button_div.innerHTML = "返回大厅";
button_div.onclick = function() {
ws_hdl.close();
location.replace("/game_hall.html");
}
chess_area_div.appendChild(button_div);
} else if (info.optype == "chat") {
//收到一条消息，判断result，如果为true则渲染一条消息到显示框中
if(info.result == false) {
alert(info.reason);
return;
}
var msg_div = document.createElement("p");
msg_div.innerHTML = info.message;
if (info.uid == room_info.uid) {
msg_div.setAttribute("id", "self_msg");
}else {
msg_div.setAttribute("id", "peer_msg");
}
var br_div = document.createElement("br");
var msg_show_div = document.getElementById("chat_show");
msg_show_div.appendChild(msg_div);
msg_show_div.appendChild(br_div);
document.getElementById("chat_input").value = "";
}
}
//3. 聊天动作
// 1. 捕捉聊天输入框消息
// 2. 给发送按钮添加点击事件，点击俺就的时候，获取到输入框消息，发送给服务器
var cb_div = document.getElementById("chat_button");
cb_div.onclick = function() {
var send_msg = {
optype : "chat",
room_id : room_info.room_id,
uid : room_info.uid,
message : document.getElementById("chat_input").value
};
ws_hdl.send(JSON.stringify(send_msg));
}
</script>
</body>
</html>七.server.hpp代码全部
cpp
#ifndef __M_SRV_H__
#define __M_SRV_H__
#include "db.hpp"
#include "matcher.hpp"
#include "online.hpp"
#include "room.hpp"
#include "session.hpp"
#include "util.hpp"
#define WWWROOT "./wwwroot/"
class gobang_server
{
private:
std::string _web_root;//静态资源更目录 ./wwwroot/ /register.html -> ./wwwroot/register.html
wsserver_t _wssrv;
user_table _ut;
online_manager _om;
room_manager _rm;
session_manager _sm;
matcher _mm;
private:
void file_handler(wsserver_t::connection_ptr& conn)
{
//静态资源请求的处理
//1.获取到请求uri-资源路径,了解客户端请求的页面文件名称
websocketpp::http::parser::request req = conn->get_request();
std::string uri = req.get_uri();
//2.组合出文件的实际路径,相对跟目录 + uri
std::string realpath = _web_root + uri;
//3.如果是目录,增加后缀 login.html / --> /login.html
if(realpath.back() == '/')
{
realpath += "login.html";
}
//4.读取文件内容
Json::Value resp_json;
std::string body;
bool ret = file_util::read(realpath,body);
//1.文件不存在,返回404
if(ret == false)
{
body += "<html>";
body += "<head>";
body += "<meta charset=\"UTF-8\">";
body += "</head>";
body += "<body>";
body += "<h1> NOT Found </h1>";
body += "</body>";
body += "</html>";
conn->set_status(websocketpp::http::status_code::not_found);
conn->set_body(body);
return;
}
//5.设置响应正文
conn->set_status(websocketpp::http::status_code::ok);
conn->set_body(body);
}
void http_resp(wsserver_t::connection_ptr &conn,bool result,websocketpp::http::status_code::value code
,const std::string& reason)
{
Json::Value resp_json;
resp_json["result"] = result;
resp_json["reason"] = reason;
std::string resp_body;
json_util::serialize(resp_json,resp_body);
conn->set_status(code);
conn->set_body(resp_body);
conn->append_header("Content-Type","application/json");
}
void reg(wsserver_t::connection_ptr& conn)
{
//用户注册功能请求处理
//1.获取到请求正文
std::string req_body = conn->get_request_body();
//2.对正文进行json反序列化,得到用户名和密码
Json::Value login_info;
bool ret = json_util::unserialize(req_body,login_info);
if(ret == false)
{
DLOG("反序列化注册信息失败");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"请求的正文格式错误");
}
//3.进行数据库的用户新增操作
if(login_info["username"].isNull() || login_info["username"].isNull())
{
DLOG("用户名密码不完整");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"请输入用户名和密码");
}
ret = _ut.insert(login_info);
if(ret == false)
{
DLOG("向数据库插入数据失败");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"用户名以及被占用");
}
DLOG("注册成功");
return http_resp(conn,true,websocketpp::http::status_code::ok,"注册用户成功");
//成功 200
//失败 400
}
void login(wsserver_t::connection_ptr& conn)
{
//用户登录功能请求处理
//1.获取请求正文,并进行json反序列化,得到用户名和密码
std::string req_body = conn->get_request_body();
Json::Value login_info;
bool ret = json_util::unserialize(req_body,login_info);
if(ret == false)
{
DLOG("反序列化注册信息失败");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"请求的正文格式错误");
}
//2.校验正文完整性,进行数据库的用户信息验证
if(login_info["username"].isNull() || login_info["username"].isNull())
{
DLOG("用户名密码不完整");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"请输入用户名和密码");
}
ret = _ut.login(login_info);
if(ret == false)
{
// 1.如果验证失败,则返回400
DLOG("用户名密码错误");
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"用户名密码错误");
}
//3.如果验证成功,给客户端创建session,则返回200
uint64_t uid = login_info["id"].asUInt64();
session_ptr ssp = _sm.create_session(uid,LOGIN);
if(ssp.get() == nullptr)
{
DLOG("创建会话失败");
return http_resp(conn,false,websocketpp::http::status_code::internal_server_error,"创建会话失败");
}
_sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
//4.设置响应头部: Set-Cookie,将sessionid通过cookie返回
std::string cookie_ssid = "SSID=" + std::to_string(ssp->ssid());
conn->append_header("Set-Cookie",cookie_ssid);
return http_resp(conn,true,websocketpp::http::status_code::ok,"登录成功");
}
bool get_cookie_val(std::string& cookie_str,const std::string& key,std::string&val)
{
//Cookie: SSID=XXX; path=/;
//1.以; 作为间隔,作为字符串进行分割,得到各个单个的cookie信息
std::string sep = "; ";
std::vector<std::string> cookie_arr;
string_util::split(cookie_str,sep,cookie_arr);
//2.对单个cookie字符串,以 = 为间隔进行分割,得到key和val
for(auto str:cookie_arr)
{
std::vector<std::string> tmp_arr;
string_util::split(str,"=",tmp_arr);
if(tmp_arr.size() != 2)
{
continue;
}
if(tmp_arr[0] == key)
{
val = tmp_arr[1];
return true;
}
}
return false;
}
void info(wsserver_t::connection_ptr& conn)
{
//用户信息功能请求处理
Json::Value err_resp;
//1.获取请求信息中的Cookie,从Cookie中获取ssid
std::string cookie_str = conn->get_request_header("Cookie");
if(cookie_str.empty())
{
//如果没有cookie,返回错误信息;没有cookie信息,让客户端重新登录
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"找不到cookie信息,请重新登录");
}
std::string ssid_str;
bool ret = get_cookie_val(cookie_str,"SSID",ssid_str);
if(ret == false)
{
//cookie中没有ssid,返回错误信息;没有ssid信息,让客户端重新登录
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"找不到ssid信息,请重新登录");
}
//2.在session中查找到对应的会话信息
session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
if(ssp.get() == nullptr)
{
//没有找到session,登录以及过期
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"登录过期,请重新登录");
}
//3.从数据库中取出用户信息,进行序列化发送给客户端
uint64_t uid = ssp->get_user();
Json::Value user_info;
ret = _ut.select_by_id(uid,user_info);
if(ret == false)
{
//获取用户信息失败,返回错误: 找不到用户信息
return http_resp(conn,false,websocketpp::http::status_code::bad_request,"找不到用户信息,请重新登录");
}
std::string body;
json_util::serialize(user_info,body);
conn->set_body(body);
conn->append_header("Content-Type","application/json");
conn->set_status(websocketpp::http::status_code::ok);
//4.刷新session的过期时间
_sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
}
void http_callback(websocketpp::connection_hdl hdl)
{
wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
websocketpp::http::parser::request req = conn->get_request();
std::string method = req.get_method();
std::string uri = req.get_uri();
if(method == "POST" && uri == "/reg")
{
return reg(conn);
}
else if(method == "POST" && uri == "/login")
{
return login(conn);
}
else if(method == "GET" && uri == "/info")
{
return info(conn);
}
else
{
return file_handler(conn);
}
}
void ws_resp(wsserver_t::connection_ptr conn,Json::Value& resp)
{
std::string body;
json_util::serialize(resp,body);
conn->send(body);
}
session_ptr get_session_by_cookie(wsserver_t::connection_ptr conn)
{
//1.登录验证 -- 判断当前客户端是否以及成功登录
Json::Value err_resp;
std::string cookie_str = conn->get_request_header("Cookie");
if(cookie_str.empty())
{
err_resp["optype"] = "hall_ready";
err_resp["reason"] = "找不到cookie信息,请重新登录";
err_resp["result"] = false;
ws_resp(conn,err_resp);
return session_ptr();
}
std::string ssid_str;
bool ret = get_cookie_val(cookie_str,"SSID",ssid_str);
if(ret == false)
{
err_resp["optype"] = "hall_ready";
err_resp["reason"] = "找不到ssid信息,请重新登录";
err_resp["result"] = false;
ws_resp(conn,err_resp);
return session_ptr();
}
session_ptr ssp = _sm.get_session_by_ssid(std::stol(ssid_str));
if(ssp.get() == nullptr)
{
err_resp["optype"] = "hall_ready";
err_resp["reason"] = "找不到session信息,请重新登录";
err_resp["result"] = false;
ws_resp(conn,err_resp);
return session_ptr();
}
return ssp;
}
void wsopen_game_hall(wsserver_t::connection_ptr conn)
{
Json::Value resp_json;
//游戏大厅长连接建立成功
//1.登录验证 -- 判断当前客户端是否以及成功登录
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
return;
}
//2.判定当前客户端是否重复登录
if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_hall(ssp->get_user()))
{
resp_json["optype"] = "hall_ready";
resp_json["reason"] = "玩家重复登录!";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//3.将当前客户端以及连接加入到游戏大厅
_om.enter_game_hall(ssp->get_user(),conn);
//4.给客户端响应长连接的游戏大厅连接成功
resp_json["optype"] = "hall_ready";
resp_json["result"] = true;
ws_resp(conn,resp_json);
//5.记得将session设置为永久存在
_sm.set_session_expire_time(ssp->ssid(),SESSION_FOREVER);
}
void wsopen_game_room(wsserver_t::connection_ptr conn)
{
//1.获取当前客户端的session
Json::Value resp_json;
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
return;
}
//2.获取当前用户是否在其他游戏房间或游戏大厅中了
if(_om.is_in_game_hall(ssp->get_user()) || _om.is_in_game_hall(ssp->get_user()))
{
resp_json["optype"] = "room_ready";
resp_json["reason"] = "玩家重复登录!";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//3.判定当前用户是否以及创建好了房间
room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
if(rp.get() == nullptr)
{
resp_json["optype"] = "room_ready";
resp_json["reason"] = "没有找到玩家的房间信息!";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
//4.将当前用户添加到在线用户管理的游戏房间中
_om.enter_game_room(ssp->get_user(),conn);
//5.将session设置成永久存在
_sm.set_session_expire_time(ssp->ssid(),SESSION_FOREVER);
//6.回复房间准备好了
resp_json["optype"] = "room_ready";
resp_json["result"] = true;
resp_json["room_id"] = (Json::UInt64)rp->id();
resp_json["uid"] = (Json::UInt64)ssp->get_user();
resp_json["white_id"] = (Json::UInt64)rp->get_white_user();
resp_json["black_id"] = (Json::UInt64)rp->get_black_user();
return ws_resp(conn,resp_json);
}
void wsopen_callback(websocketpp::connection_hdl hdl)
{
//websocket长连接建立成功的回调函数
wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
websocketpp::http::parser::request req = conn->get_request();
std::string uri = req.get_uri();
if(uri == "/hall")
{
//建立游戏大厅的长连接
return wsopen_game_hall(conn);
}
else if(uri == "/room")
{
//建立游戏房间的长连接
return wsopen_game_room(conn);
}
}
void wsclose_game_hall(wsserver_t::connection_ptr conn)
{
//游戏大厅的长连接断开
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
return;
}
//1.将玩家从游戏大厅移除
_om.exit_game_hall(ssp->get_user());
//2.将session恢复生命周期的管理
_sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
}
void wsclose_game_room(wsserver_t::connection_ptr conn)
{
//游戏房间的长连接断开
//1.获取会话信息,识别客户端
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
return;
}
//2.将session回复生命周期的管理,设置定时销毁
_om.exit_game_room(ssp->get_user());
_sm.set_session_expire_time(ssp->ssid(),SESSION_TIMEOUT);
//3.将玩家从游戏房间移除,房间中所有用户退出了,就会销毁房
_rm.remove_room_user(ssp->get_user());
}
void wsclose_callback(websocketpp::connection_hdl hdl)
{
//1.websocket连接断开前的处理
wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
websocketpp::http::parser::request req = conn->get_request();
std::string uri = req.get_uri();
if(uri == "/hall")
{
//游戏大厅的长连接断开
return wsclose_game_hall(conn);
}
else if(uri == "/room")
{
//游戏房间的长连接断开
return wsclose_game_room(conn);
}
}
void wsmsg_game_hall(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg)
{
Json::Value resp_json;
std::string resp_body;
//1.获取身份
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
return;
}
std::string req_body = msg->get_payload();
Json::Value req_json;
bool ret = json_util::unserialize(req_body,req_json);
if(ret == false)
{
resp_json["result"] = false;
resp_json["reason"] = "请求信息解析失败";
return ws_resp(conn,resp_json);
}
//2.对于请求进行处理
if(!req_json["optype"].isNull() &&req_json["optype"].asString() == "match_start")
{
//1.开始对战匹配 : 通过匹配模块,将用户添加到匹配队列中
_mm.add(ssp->get_user());
resp_json["optype"] = "match_start";
resp_json["result"] = true;
return ws_resp(conn,resp_json);
}
else if(!req_json["optype"].isNull() &&req_json["optype"].asString() == "match_stop")
{
//2.停止对战匹配 : 通过匹配模块,将用户从匹配队列中移除
_mm.del(ssp->get_user());
resp_json["optype"] = "match_stop";
resp_json["result"] = true;
return ws_resp(conn,resp_json);
}
//3.给客户端响应
resp_json["optype"] = "unkonw";
resp_json["reason"] = "请求类型未知";
resp_json["result"] = false;
return ws_resp(conn,resp_json);
}
void wsmsg_game_room(wsserver_t::connection_ptr conn,wsserver_t::message_ptr msg)
{
Json::Value resp_json;
std::string resp_body;
//1.获取session,识别客户端身份
session_ptr ssp = get_session_by_cookie(conn);
if(ssp.get() == nullptr)
{
DLOG("房间-没有找到会话信息");
return;
}
//2.获取客户端房间信息
room_ptr rp = _rm.get_room_by_uid(ssp->get_user());
if(rp.get() == nullptr)
{
resp_json["optype"] = "unknow";
resp_json["reason"] = "没有找到玩家的房间信息!";
resp_json["result"] = false;
DLOG("房间-没有找到玩家房间信息");
return ws_resp(conn,resp_json);
}
//3.对消息进行反序列化
Json::Value req_json;
std::string req_body = msg->get_payload();
bool ret = json_util::unserialize(req_body,req_json);
if(ret == false)
{
resp_json["optype"] = "unknow";
resp_json["reason"] = "请求解析失败";
resp_json["result"] = false;
DLOG("房间-反序列化请求失败");
return ws_resp(conn,resp_json);
}
DLOG("房间: 收到请求,进行处理");
//4.对消息进行处理
return rp->handle_request(req_json);
}
void wsmsg_callback(websocketpp::connection_hdl hdl,wsserver_t::message_ptr msg)
{
wsserver_t::connection_ptr conn = _wssrv.get_con_from_hdl(hdl);
websocketpp::http::parser::request req = conn->get_request();
std::string uri = req.get_uri();
if(uri == "/hall")
{
return wsmsg_game_hall(conn,msg);
}
else if(uri == "/room")
{
return wsmsg_game_room(conn,msg);
}
}
public:
//进行成员初始化,以及服务器回调函数的设置
gobang_server(
const std::string &host,
const std::string &username,
const std::string &password,
const std::string &dbname,
uint16_t port = 3306,
const std::string &wwwroot = WWWROOT
):_web_root(wwwroot),_ut(host,username,password,dbname,port),
_rm(&_ut,&_om),_sm(&_wssrv),_mm(&_rm,&_ut,&_om)
{
_wssrv.set_access_channels(websocketpp::log::alevel::none);
_wssrv.init_asio();
_wssrv.set_reuse_addr(true);
_wssrv.set_http_handler(std::bind(&gobang_server::http_callback,this,std::placeholders::_1));
_wssrv.set_open_handler(std::bind(&gobang_server::wsopen_callback,this,std::placeholders::_1));
_wssrv.set_close_handler(std::bind(&gobang_server::wsclose_callback,this,std::placeholders::_1));
_wssrv.set_message_handler(std::bind(&gobang_server::wsmsg_callback,this,std::placeholders::_1,std::placeholders::_2));
}
void start(int port)//启动服务器
{
//5.设置监听端口
_wssrv.listen(port);
//6.开始获取新连接
_wssrv.start_accept();
//7.启动服务器
_wssrv.run();
}
};
#endif八.项目总结
九.完结撒花
全部源码链接,有兴趣自取: