Skynet游戏开发实战：打造交互式猜数字游戏

已于 2024-02-03 05:04:43 修改
阅读量9.2k 收藏 6
点赞数 2
分类专栏： # skynet
于 2022-12-20 15:26:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Long_xu/article/details/128382106
版权

游戏 lua 开发语言 skynet 后端 linux c++

skynet开发一个猜数字游戏

一、游戏简介

猜数字游戏目的是掌握 actor 模型开发思路。

规则：

  1. 满三个人开始游戏，游戏开始后不能退出，直到游戏结束。
  2. 系统会随机生成1-100 之间的数字，玩家依次猜规则内的数字。
  3. 玩家猜测正确，那么该玩家就输了；如果猜测错误，游戏继续。
  4. 直到有玩家猜测成功，游戏结束。
server
TCP
TCP
TCP
hall
agent
gate
agent
agent
room
client
client
client

游戏设计时，首先是简单可用，然后持续优化，而不是一开始就过度优化。

二、接口设计和实现

skynet 中，从 actor 底层看是通过消息进行通信；从 actor 应用层看是通过 api 来进行通信。

遵循接口隔离原则：

  1. 不应该强迫客户依赖于他们不用的方法。
  2. 从安全封装的角度出发，只暴露客户需要的接口。
  3. 服务间不依赖彼此的实现。

2.1、agent服务接口

agent服务主要是用户。具有如下功能：

  1. login：实现登录功能；断线重连。
  2. ready：准备，转发到大厅，加入匹配队列。
  3. guess：猜测数字，转发到房间。
  4. help：列出所有操作说明。
  5. quit：退出。
local skynet = require "skynet"
local socket = require "skynet.socket"

local tunpack = table.unpack
local tconcat = table.concat
local select = select

local clientfd, addr = ...
clientfd = tonumber(clientfd)

local hall

local function read_table(result)
	local reply = {}
	for i = 1, #result, 2 do reply[result[i]] = result[i + 1] end
	return reply
end
-- 读取redis的相关信息
local rds = setmetatable({0}, {
    __index = function (t, k)
        if k == "hgetall" then
            t[k] = function (red, ...)
                return read_table(skynet.call(red[1], "lua", k, ...))
            end
        else
            t[k] = function (red, ...)
                return skynet.call(red[1], "lua", k, ...)
            end
        end
        return t[k]
    end
})

local client = {fd = clientfd}
local CMD = {}

local function client_quit()
    skynet.call(hall, "lua", "offline", client.name)
    if client.isgame and client.isgame > 0 then
        skynet.call(client.isgame, "lua", "offline", client.name)
    end
    skynet.fork(skynet.exit)    --强制关闭进程，退出
end

-- 发送信息
local function sendto(arg)
    -- local ret = tconcat({"fd:", clientfd, arg}, " ")
    -- socket.write(clientfd, ret .. "\n")
    socket.write(clientfd, arg .. "\r\n")
end

-- 用户登录
function CMD.login(name, password)
    if not name and not password then
        sendto("没有设置用户名或者密码")
        client_quit()
        return
    end
    local ok = rds:exists("role:"..name)
    if not ok then
        local score = 1000
        -- 满足条件唤醒协程，不满足条件挂起协程
        rds:hmset("role:"..name, tunpack({
            "name", name,
            "password", password,
            "score", score,
            "isgame", 0,
        }))
        client.name = name
        client.password = password
        client.score = score
        client.isgame = 0
        client.agent = skynet.self()
    else
        local dbs = rds:hgetall("role:"..name)
        if dbs.password ~= password then
            sendto("密码错误，请重新输入密码")
            return
        end
        client = dbs
        client.fd = clientfd
        client.isgame = tonumber(client.isgame) or 0
        client.agent = skynet.self()
    end
    if client.isgame > 0 then
        ok = pcall(skynet.call, client.isgame, "lua", "online", client)
        if not ok then
            client.isgame = 0
            sendto("请准备开始游戏。。。")
        end
    else
        sendto("请准备开始游戏。。。")
    end
end

function CMD.ready()
    if not client.name then
        sendto("请先登陆")
        return
    end
    if client.isgame and client.isgame > 0 then
        sendto("在游戏中，不能准备")
        return
    end
    
    local ok, msg = skynet.call(hall, "lua", "ready", client)   --发起一个远程调用，调用hall服务的ready
    if not ok then
        sendto(msg)
        return
    end
    client.isgame = ok
    rds:hset("role:"..client.name, "isgame", ok)
end

function CMD.guess(number)
    if not client.name then
        sendto("错误：请先登陆")
        return
    end
    if not client.isgame or client.isgame == 0 then
        sendto("错误：没有在游戏中，请先准备")
        return
    end
    local numb = math.tointeger(number)
    if not numb then
        sendto("错误：猜测时需要提供一个整数而不是 "..number)
        return
    end

    skynet.send(client.isgame, "lua", "guess", client.name, numb)
end

local function game_over()
    client.isgame = 0
    rds:hset("role:"..client.name, "isgame", 0)
end

function CMD.help()
    local params = tconcat({
        "*规则*:猜数字游戏，由系统随机1-100数字，猜中输，未猜中赢。",
        "help: 显示所有可输入的命令;",
        "login: 登陆，需要输入用户名和密码;",
        "ready: 准备，加入游戏队列，满员自动开始游戏;",
        "guess: 猜数字，只能猜1~100之间的数字;",
        "quit: 退出",
    }, "\r\n")
    socket.write(clientfd, params .. "\r\n")
end

function CMD.quit()
    client_quit()
end

--处理数据接受
local function process_socket_events()
    while true do
        local data = socket.readline(clientfd)-- "\n" read = 0，telnet的分隔符是\n
        if not data then
            print("断开网络 "..clientfd)
            client_quit()
            return
        end
        -- 开始解析数据包
        local pms = {}
        for pm in string.gmatch(data, "%w+") do
            pms[#pms+1] = pm
        end
        if not next(pms) then
            sendto("error[format], recv data")
            goto __continue__
        end
        -- 分发命令
        local cmd = pms[1]
        if not CMD[cmd] then
            sendto(cmd.." 该命令不存在")
            CMD.help()
            goto __continue__
        end
        skynet.fork(CMD[cmd], select(2, tunpack(pms)))
::__continue__::
    end
end
-- 开始agent服务
skynet.start(function ()
    print("recv a connection:", clientfd, addr)
    rds[1] = skynet.uniqueservice("redis") --进入redis服务
    hall = skynet.uniqueservice("hall")     -- 进入hall服务
    socket.start(clientfd) -- 绑定 clientfd agent 网络消息
    skynet.fork(process_socket_events)  --创建协程，处理数据接受
    skynet.dispatch("lua", function (_, _, cmd, ...)
        if cmd == "game_over" then
            game_over()
        end
    end)
end)

2.2、room服务接口

room服务是一个游戏空间。具有如下功能：

  1. start：初始化房间。
  2. online：用户上线，如果用户在游戏中，告知游戏进度。
  3. offline：用户下线，通知房间内其他用户。
  4. guess：猜测数字，推动游戏进程。
local skynet = require "skynet"

local socket = require "skynet.socket"

local CMD = {}

local roles = {}

local redisd

local game = {
    random_value = 0,
    user_turn = 0,
    up_limit = 100,
    down_limit = 1,
    turns = {},
}

local function sendto(clientfd, arg)
    socket.write(clientfd, arg .. "\r\n")
end

local function broadcast(msg)
    for _, role in pairs(roles) do
        if role.isonline > 0 then
            sendto(role.fd, msg)
        end
    end
end

function CMD.start(members)
    for _, role in ipairs(members) do
        role.isonline = 1
        roles[role.name] = role
        game.turns[#game.turns+1] = role.name
    end
    game.random_value = math.random(1, 100)
    broadcast(("房间:%d 系统已经随机一个数字"):format(skynet.self()))
    local rv = math.random(1, 1500)
    if rv <= 500 then
        game.user_turn = 1
    elseif rv <= 1000 then
        game.user_turn = 2
    else
        game.user_turn = 3
    end
    local name = game.turns[game.user_turn]
    broadcast(("请玩家%s开始猜数字"):format(name))
end

function CMD.offline(name)
    if roles[name] then
        roles[name].isonline = 0
        broadcast(("%s 玩家已经掉线，请求呼叫他上线"):format(name))
    end
    skynet.retpack()
end

function CMD.online(client)
    local name = client.name
    if roles[name] then
        roles[name] = client
        roles[name].isonline = 1
        broadcast(("%s 玩家已经上线"):format(name))
        sendto(client.fd, ("范围变为 [%d - %d], 接下来由 %s 来操作"):format(game.down_limit, game.up_limit, game.turns[game.user_turn]))
    end
    skynet.retpack()
end

local function game_over()
    for _, role in pairs(roles) do
        if role.isonline == 0 then
            skynet.call(redisd, "hset", "role:"..role.name, "isgame", 0)
        else
            skynet.send(role.agent, "lua", "game_over")
            sendto(role.fd, "离开房间")
        end
    end
    skynet.fork(skynet.exit)
end

function CMD.guess(name, val)
    local role = assert(roles[name])
    if game.turns[game.user_turn] ~= name then
        sendto(role.fd, ("错误：还没轮到你操作，现在由 %s 来操作"):format(game.turns[game.user_turn]))
        return
    end
    if not val or val < game.down_limit or val > game.up_limit then
        sendto(role.fd, ("错误：请输入[%d - %d]之间的数字"):format(game.down_limit, game.up_limit))
        return
    end
    game.user_turn = game.user_turn % 3+1
    local next = game.turns[game.user_turn]
    if val == game.random_value then
        broadcast(("游戏结束，%s猜中了数字%d，输了"):format(name, val))
        game_over()
        return
    end
    if val < game.random_value then
        game.down_limit = val+1
        if game.down_limit == game.up_limit then
            broadcast(("游戏结束，只剩下一个数字%d %s输了"):format(val+1, next))
            game_over()
            return
        end
        broadcast(("%s输入的数字太小，范围变为 [%d - %d], 接下来由 %s 来操作"):format(name, game.down_limit, game.up_limit, next))
        return
    end
    if val > game.random_value then
        game.up_limit = val-1
        if game.down_limit == game.up_limit then
            broadcast(("游戏结束，只剩下一个数字%d %s输了"):format(val-1, next))
            game_over()
            return
        end
        broadcast(("%s输入的数字太大，范围变为 [%d - %d], 接下来由 %s 来操作"):format(name, game.down_limit, game.up_limit, next))
        return
    end
end

skynet.start(function ()
    math.randomseed(math.tointeger(skynet.time()*100), skynet.self())   --生成随机数
    redisd = skynet.uniqueservice("redis")  --进入redis服务
    skynet.dispatch("lua", function (_, _, cmd, ...)
        local func = CMD[cmd]
        if not func then
            return
        end
        func(...)
    end)
end)

2.3、hall服务接口

hall服务类似《斗地主》的大厅。具有如下功能：

  1. ready：加入匹配队列。
  2. offline：用户掉线，需要从匹配队列移除用户。
local skynet = require "skynet"
local queue = require "skynet.queue"
local socket = require "skynet.socket"

local cs = queue()

local tinsert = table.insert
local tremove = table.remove
-- local tconcat = table.concat
local CMD = {}

local queues = {}

local resps = {}

local function sendto(clientfd, arg)
    -- local ret = tconcat({"fd:", clientfd, arg}, " ")
    -- socket.write(clientfd, ret .. "\n")
    socket.write(clientfd, arg .. "\r\n")
end

function CMD.ready(client)
    if not client or not client.name then
        return skynet.retpack(false, "准备：非法操作")
    end
    if resps[client.name] then
        return skynet.retpack(false, "重复准备")
    end
    tinsert(queues, 1, client)
    resps[client.name] = skynet.response()
    if #queues >= 3 then
        local roomd = skynet.newservice("room") 
        local members = {tremove(queues), tremove(queues), tremove(queues)}
        for i=1, 3 do
            local cli = members[i]
            resps[cli.name](true, roomd)
            resps[cli.name] = nil
        end
        skynet.send(roomd, "lua", "start", members)
        return
    end
    sendto(client.fd, "等待其他玩家加入")
end

function CMD.offline(name)
    for pos, client in ipairs(queues) do
        if client.name == name then
            tremove(queues, pos)
            break
        end
    end
    if resps[name] then
        resps[name](true, false, "退出")
        resps[name] = nil
    end
    skynet.retpack()
end

skynet.start(function ()
    --  消息路由
    skynet.dispatch("lua", function(session, address, cmd, ...)
        local func = CMD[cmd]
        if not func then
            skynet.retpack({ok = false, msg = "非法操作"})
            return
        end
        cs(func, ...)   --开始执行
    end)
end)

2.4、redis服务

用于保存玩家名称、密码、分数、游戏状态等信息。
开启redis服务，redis的键值对、数据结构操作在agent服务进行。

local skynet = require "skynet.manager"
local redis = require "skynet.db.redis"
-- 连接redis
skynet.start(function ()
	local rds = redis.connect({
		host	= "127.0.0.1",
		port	= 6379,
		db		= 0,
		-- auth	= "123456",
	})
	skynet.dispatch("lua", function (session, address, cmd, ...)
		skynet.retpack( rds[cmd:lower()](rds, ...) )
	end)
end)

2.5、gate服务接口

gate服务是网关，主要处理网络连接，也是游戏的入口函数文件。具有如下功能：

  1. 绑定网络连接，推送信息到agent服务。
  2. 进入redis服务。

实现：
main.lua

local skynet = require "skynet" 
local socket = require "skynet.socket"

local function accept(clientfd,addr)
    skynet.newservice("agent",clientfd,addr)--创建一个agent服务（lua虚拟机）
end

skynet.start(function()
    -- body
    local listenfd=socket.listen("0.0.0.0",8888)
    skynet.uniqueservice("redis")
    skynet.uniqueservice("hall")
    socket.start(listenfd,accept) --绑定listenfd到accept函数
end)

三、编写skynet的config文件

编写的game代码放在app目录下。

thread=4	--工作线程
logger=nil
harbor=0
start="main" -- 启动第一个服务
lua_path="./skynet/lualib/?.lua;".."./skynet/lualib/?/init.lua;".."./lualib/?.lua;"
luaservice="./skynet/service/?.lua;./app/?.lua"
lualoader="./skynet/lualib/loader.lua"
cpath="./skynet/cservice/?.so"
lua_cpath="./skynet/luaclib/?.so"

四、游戏演示

（1）服务端：
先启动 redis，然后启动 skynet。

redis-server redis.conf
./skynet/skynet config

（2）客户端：使用telnet。

telnet <IP> 8888

guess_game

五、总结

  1. 这些服务接口还可以进一步进行优化，比如 agent 服务可以不要实时创建而是采用预先创建、如果某个服务相对简单，可以创建固定数量。
  2. 如果是万人同时在线游戏，agent、room 需要预先分配，长时间运行会让服务内存膨胀，同时也会造成 luagc 负担会加重。
skynet 基础例子完整代码
08-01
skynet 基础服务demo，包括config的完整配置解释，db测试 和简单的socket测试‘’ 简单明了 方便运行
SkynetGuessingGameThing：Sky Net项目的猜谜游戏
02-21
天网GuessingGameThing 天网项目的猜谜游戏。
Skynet 项目推荐
最新发布
gitblog_07612的博客
09-13 436
Skynet 项目推荐 skynet 一个轻量级的在线游戏框架。 项目地址: https://gitcode.com/gh_mirrors/sk/skynet 1. 项目基础...
Skynet基础入门例子详解(2)
魂影魔宅
03-16 7338
Skynet基础入门例子详解
skynet mmorpg
01-04
skynet mmorpg 游戏开发案例代码，可用于 skynet 的游戏框架研究
skynet examples深入学习
sftxlin的专栏
09-18 890
lua
02skynet--例子简单解析
maxiaosheng521的专栏
10-20 733
配置信息 root = "./" 根目录 thread = 8 //启动多少个工作线程。通常不要将它配置超过你实际拥有的 CPU 核心数。 logger = nil//skynet_error输出的文件名 logpath = "."//skynet_error输出的路径 harbor = 1//范围1~255 如果harbor为0 工作在单节点模式下 address = "127.
skynet-fly websocket/hhtp 热更新方案 rpc远程调用 快速开始 游戏服务 数字炸弹游戏
01-18
skynet_fly是基于skynet扩展的可以快速开发web，游戏，和需要rpc调用的框架。 使用skynet_fly的好处： * 支持不停服更新。 * 一键生成skynet的配置文件和skynet_fly的配置文件以及配套shell脚本。 * 对匹配房间类...
基于skynet的游戏服务器开发skynet.zip
04-15
C#通常用于开发Windows桌面应用程序、Web应用程序、移动应用程序以及游戏开发等领域。C#是.NET框架的一部分，这意味着它可以与其他.NET语言（如Visual Basic .NET、F#等）以及.NET框架中的各种库和工具进行交互使用...
cpp-Skynet是一个轻量级的为在线游戏服务器打造的框架
08-16
**Skynet 框架详解** Skynet 是一个专为在线游戏服务器设计的轻量级框架，由 C/C++ 编写，强调高并发、低延迟以及稳定的实时...结合其开源社区的持续维护和扩展，Skynet 成为了 C/C++ 游戏开发领域中的一个重要选择。
游戏开发核心技术点 skynet训练营.mp4
08-27
4小时游戏开发skynet核心技术点详解。因上传空间所限，视频内容分为上下两部
Skynet基础入门例子详解(3)项目源码
03-22
Skynet基础入门例子详解(3)项目源码 博文地址：http://blog.csdn.net/uisoul/article/details/64125906
Python-fast基于skynet的游戏服务端框架
08-10
fast - 基于skynet的游戏服务端框架
meiru是一个游戏开发和web开发一体化的框架，基于skynet。提供快速开发网页和游戏meiru-skynet.zip
04-14
这个C#实现的小游戏是一个简单的猜数字游戏，让玩家猜一个1到100之间的随机生成的数字。以下是对这个小游戏的分析： Random 类的使用：游戏开始时，使用 Random 类生成一个1到100之间的随机数作为要猜的数字。 ...
【从零开始学Skynet】基础篇（九）：调试控制台服务
我是一条寻水的鱼
04-13 1415
Skynet自带了一个调试控制台服务debug_console，启动它之后，可以查看节点的内部状态。
推荐开源项目：SkynetMMO —— 助力你的大型多人在线游戏开发
gitblog_00020的博客
06-02 703
推荐开源项目：SkynetMMO —— 助力你的大型多人在线游戏开发 去发现同类优质开源项目:https://gitcode.com/ 项目介绍 SkynetMMO 是一个基于 Skynet 框架实现的大型多人在线角色扮演游戏（MMORPG）服务器端项目。该项目与 UnityMMO 配合使用，提供了一套完整的服务器解决方案，旨在帮助开发者专注于游戏逻辑，而非底层网络通信和数据处理。 项目技术分析 ...
【手游项目5】skynet-2
12-24 448
GateServer Gate 只负责读取外部数据，但不负责回写。也就是说，向这些连接发送数据不是它的职责范畴。 作为示范，skynet 开源项目实现了一个简单的回写代理服务，叫做 service_client 。 启动这个服务，启动时绑定一个 fd ，发送给这个服务的消息包，都会被加上两字节的长度包头，写给对应的 fd 。 根据不同的分包协议，可以自己定制不同的 client 服务来解决向外部连接发送数据的模块。https://github.com/xzhovo/skynet-websocket-gat.
服务端Skynet(五)——如何搭建一个实例
weixin_43730892的博客
11-17 1059
skynet 实例
【从零开始学Skynet】实战篇《球球大作战》（一）：功能设计
我是一条寻水的鱼
04-13 2106
为了能把之前在基础篇中学习到的Skynet的各种知识结合起来，所以在实战篇中，我们准备开发一个完整的游戏案例《球球大作战》，介绍分布式游戏服务端的实现方法。
Skynet并发框架深度解析：Actor模型与实战指南
Skynet采用单进程多线程的Actor模型，最初设计用于在线游戏服务器，但其强大的并发能力和轻量级特性也使其适用于web服务器等其他领域。本教程涵盖了从获取源代码、编译运行到服务管理、服务通信、多节点集群等多个...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Lion Long

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值