消消乐

meinvwudi

牛乐歌马游戏功能分析

这是一个名为"牛乐歌马"的三消类游戏模块，实现了类似消消乐的游戏机制。以下是详细的功能分析和注释：

核心功能概述

游戏类型：三消类益智游戏
游戏目标：通过点击相同类型的块，将其移动到槽位中，当槽位中有3个相同类型的块时自动消除
游戏机制：分层叠放的块结构，只能点击最上层的块

详细代码注释

local NiuLeGeMaOBJ = {}

NiuLeGeMaOBJ.__cname = "NiuLeGeMaOBJ"

-- 定义12种不同类型的块资源图片路径
NiuLeGeMaOBJ.blocks = {
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_1.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_2.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_3.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_4.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_5.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_6.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_7.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_8.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_9.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_10.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_11.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_12.png",
}

-- 游戏核心配置参数
NiuLeGeMaOBJ.gameConfig = {
    randomBlocks = { 14, 14 }, -- 随机块配置（用于高级关卡）
    levelBlockNum = 40,        -- 每层的块数量
    levelNum = 8,              -- 总层数
    slotNum = 7,               -- 下方槽位数量
    composeNum = 3,            -- 消除所需的相同块数量（三消机制）
    typeNum = 12,              -- 块的类型总数
}

-- 游戏网格单元尺寸配置
NiuLeGeMaOBJ.widthUnit = 18   -- 每个格子的宽度单位
NiuLeGeMaOBJ.heightUnit = 18  -- 每个格子的高度单位（图标高度56/3=18，实现层叠覆盖效果）

-- 游戏状态追踪变量
NiuLeGeMaOBJ.opHistory = {}      -- 操作历史记录（用于撤回功能）
NiuLeGeMaOBJ.clearBlockNum = 0   -- 已消除的块数量统计

-- 游戏主入口函数
function NiuLeGeMaOBJ:main(objcfg)
    self.objcfg = objcfg           -- 保存对象配置
    self.blocksDataTable = {}      -- 块数据表（用于网络数据接收）
    self.gameTime = 0              -- 游戏时间计数器
    self:OpenUI()                  -- 打开游戏界面
end

-- 开始游戏时间统计功能
function NiuLeGeMaOBJ:startGameTime()
    GUI:Button_setBrightEx(self.ui.Button_shuffle, true)  -- 启用打乱按钮
    GUI:Text_setString(self.ui.Text_1, "游戏时间：")        -- 设置时间标签
    GUI:Text_setString(self.ui.Text_2, "1秒")             -- 初始化时间显示
    
    -- 每秒更新一次游戏时间显示
    GUI:schedule(self.ui.Layout, function()
        self.gameTime = self.gameTime + 1
        local timeStr = secondsToVariedChineseHMS(self.gameTime)  -- 转换为中文时间格式
        GUI:Text_setString(self.ui.Text_2, timeStr)
    end, 1)
end

-- 网络消息响应处理（用于多关卡数据接收）
function NiuLeGeMaOBJ:Response(arg1, arg2, arg3, data)
    if arg2 == 0 then
        -- 单次数据接收完成
        self.blocksData = data[1]
        self.totalBlockNum = arg1
        self:StartGame()
        return
    end
    
    -- 多次数据接收拼接
    table.insert(self.blocksDataTable, data[1])
    self.blocksData = table.concat(self.blocksDataTable)
    if #self.blocksDataTable > 1 then
        self.totalBlockNum = arg1
        self:StartGame()
    end
end

-- 游戏UI界面初始化
function NiuLeGeMaOBJ:OpenUI()
    -- 创建游戏主窗口
    local parent = GUI:Win_Create(self.__cname, 0, 0, 0, 0, false, false, true, true, true)
    self._parent = parent
    GUI:LoadExport(parent, self.objcfg.UI_PATH)  -- 加载UI布局
    self.ui = GUI:ui_delegate(parent)            -- 获取UI控件代理
    ssrSetWidgetPosition(parent, self.ui.img_bg) -- 设置窗口位置
    
    -- 绑定关闭按钮事件（多个关闭入口）
    GUI:addOnClickEvent(self.ui.CloseLayout, function()
        self:messagebox("确定退出？退出后将重新开始", function()
            GUI:Win_Close(self._parent)
        end)
    end)
    
    GUI:addOnClickEvent(self.ui.CloseButton, function()
        self:messagebox("确定退出？退出后将重新开始", function()
            GUI:Win_Close(self._parent)
        end)
    end)
    
    GUI:addOnClickEvent(self.ui.Button_exit, function()
        self:messagebox("确定退出？退出后将重新开始", function()
            GUI:Win_Close(self._parent)
        end)
    end)
    
    -- 游戏辅助功能按钮
    
    -- 移出功能：从槽位移出三个道具（每局限用一次）
    GUI:addOnClickEvent(self.ui.Button_remove, function()
        self:messagebox("从下放移出三个道具，并且每局游戏只有一次机会，确定继续？", function()
            self:doRemove()
        end)
    end)
    
    -- 打乱功能：重新排列所有块（需要20万元宝）
    GUI:addOnClickEvent(self.ui.Button_shuffle, function()
        self:messagebox("打乱所有道具，需要20W元宝，确定继续？", function()
            ssrMessage:sendmsg(ssrNetMsgCfg.NiuLeGeMa_RequestDoShuffle)
        end)
    end)
    
    -- 撤回功能：撤销上一次操作（每局限用一次）
    GUI:addOnClickEvent(self.ui.Button_back, function()
        self:messagebox("撤回上一次操作，并且每局游戏只有一次机会，确定继续？", function()
            self:doRevert()
        end)
    end)
    
    -- 初始状态下禁用所有辅助功能按钮
    GUI:Button_setBrightEx(self.ui.Button_remove, false)
    GUI:Button_setBrightEx(self.ui.Button_back, false)
    GUI:Button_setBrightEx(self.ui.Button_shuffle, false)
    
    self:StartGameLevel1()  -- 开始第一关
end

-- 第一关游戏初始化
function NiuLeGeMaOBJ:StartGameLevel1()
    -- 游戏状态初始化
    self.isRemove = false      -- 是否已使用移出功能
    self.isBack = false        -- 是否已使用撤回功能
    self.noClicks = true       -- 禁用点击（动画播放期间）
    self.slotImageList = {}    -- 槽位图像列表
    self.gameStatus = 0        -- 游戏状态：0=未开始，1=进行中，2=失败，3=胜利
    self.currSlotNum = 0       -- 当前占用的槽位数量
    self.clearBlockNum = 0     -- 已清除的块数量
    self.totalBlockNum = 18    -- 第一关总块数
    
    -- 生成第一关的游戏数据（18个块，每种类型6个，确保能够三消）
    local gameData = {}
    for i = 1, 18 do
        table.insert(gameData, (i - 1) % 3 + 1)  -- 生成1,2,3,1,2,3...的循环
    end
    
    -- 随机打乱块的顺序
    for i = #gameData, 2, -1 do
        local j = math.random(i)
        gameData[i], gameData[j] = gameData[j], gameData[i]
    end
    
    self.level = 1
    local level1AllBlocks = {}
    
    -- 创建18个块对象
    for i = 1, 18 do
        local newBlock = {
            id = i - 1,         -- 块的唯一ID
            status = 0,         -- 块状态（0=正常，1=已选中等）
            level = 0,          -- 所在层级
            type = gameData[i], -- 块的类型（1-3）
            H = {},             -- 上层块列表（Higher blocks）
            L = {}              -- 下层块列表（Lower blocks）
        }
        table.insert(level1AllBlocks, newBlock)
    end
    
    -- 设置上层9个块的位置和层级关系
    local level1BlockX = 70   -- 起始X坐标
    local level1BlockY = 50   -- 起始Y坐标
    for i = 1, 9 do
        level1AllBlocks[i].x = level1BlockX
        level1AllBlocks[i].y = level1BlockY
        level1AllBlocks[i].level = 1
        level1BlockX = level1BlockX + 160  -- 水平间距160像素
        
        -- 建立上下层关系：上层块压住下层块
        table.insert(level1AllBlocks[i].L, level1AllBlocks[i + 9])
        
        -- 每3个块换行
        if i % 3 == 0 then
            level1BlockX = 70
            level1BlockY = level1BlockY + 100  -- 垂直间距100像素
        end
    end
    
    -- 设置下层9个块的位置和层级关系
    level1BlockX = 70
    level1BlockY = 16  -- 下层Y坐标更小，形成层叠效果
    for i = 10, 18 do
        level1AllBlocks[i].x = level1BlockX
        level1AllBlocks[i].y = level1BlockY
        level1AllBlocks[i].level = 1
        level1BlockX = level1BlockX + 160
        
        -- 建立下上层关系：下层块被上层块压住
        table.insert(level1AllBlocks[i].H, level1AllBlocks[i - 9])
        
        if i % 3 == 0 then
            level1BlockX = 70
            level1BlockY = level1BlockY + 100
        end
    end
    
    self.levelBlocksVallevel1 = level1AllBlocks  -- 保存第一关块数据
    self.randomBlocksVal = {}                    -- 随机块数据（高级关卡使用）
    
    -- 初始化槽位数组
    self.slotAreaVal = {}
    for i = 1, self.gameConfig.slotNum do
        self.slotAreaVal[i] = nil  -- 7个槽位初始为空
    end
    
    -- 将块添加到UI界面显示
    -- ... existing code ...
end

游戏流程图

flowchart TD
    A[游戏开始] --> B[初始化UI界面]
    B --> C[创建第一关数据]
    C --> D[生成18个块对象]
    D --> E[随机打乱块顺序]
    E --> F[设置块的位置和层级关系]
    F --> G[初始化7个槽位]
    G --> H[将块添加到界面显示]
    H --> I[开始游戏时间统计]
    I --> J[等待玩家操作]
    
    J --> K{玩家点击块}
    K -->|块被其他块压住| L[无法选中，提示玩家]
    K -->|块可以选中| M[块移动到槽位]
    
    M --> N{检查槽位}
    N -->|槽位未满| O[块放入槽位]
    N -->|槽位已满7个| P[游戏失败]
    
    O --> Q{检查是否有3个相同类型}
    Q -->|有3个相同| R[消除这3个块]
    Q -->|没有3个相同| S[继续游戏]
    
    R --> T{检查是否清除所有块}
    T -->|是| U[游戏胜利]
    T -->|否| S
    
    S --> J
    L --> J
    
    J --> V{玩家使用辅助功能}
    V -->|移出功能| W[从槽位移出3个块]
    V -->|打乱功能| X[重新排列所有块]
    V -->|撤回功能| Y[撤销上一次操作]
    
    W --> S
    X --> S
    Y --> S
    
    P --> Z[显示失败界面]
    U --> AA[显示胜利界面]
    Z --> BB[重新开始或退出]
    AA --> CC[进入下一关或退出]

数据结构说明

块对象结构

block = {
    id = 0,           -- 块的唯一标识符
    status = 0,       -- 块的状态（0=正常，1=已选中等）
    level = 1,        -- 块所在的层级
    type = 1,         -- 块的类型（1-12）
    x = 70,           -- 块在界面上的X坐标
    y = 50,           -- 块在界面上的Y坐标
    H = {},           -- 压在此块上方的块列表
    L = {}            -- 此块压住的下方块列表
}

游戏状态管理

gameStatus: 0=未开始，1=进行中，2=失败，3=胜利
currSlotNum: 当前槽位中的块数量
clearBlockNum: 已消除的块数量
slotAreaVal: 7个槽位的状态数组

核心游戏机制

层叠系统：块分为上下两层，上层块压住下层块，只有最上层的块才能被点击
三消机制：当槽位中有3个相同类型的块时自动消除
胜利条件：清除所有块
失败条件：槽位被填满（7个槽位都有块）
辅助功能：
- 移出：从槽位移出3个块（每局限用一次）
- 打乱：重新排列所有块（消耗20万元宝）
- 撤回：撤销上一次操作（每局限用一次）

这个游戏是双节活动中的一个小游戏，结合了策略性和运气成分，玩家需要合理规划点击顺序来避免槽位被填满。

meinvwudi

local NiuLeGeMaOBJ = {}

NiuLeGeMaOBJ.__cname = "NiuLeGeMaOBJ"

--定义块资源
NiuLeGeMaOBJ.blocks = {
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_1.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_2.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_3.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_4.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_5.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_6.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_7.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_8.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_9.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_10.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_11.png",
    "res/custom/ShuangJieHuoDongMain/NiuLeGeMa/icon_12.png",
}
--游戏配置
NiuLeGeMaOBJ.gameConfig = {
    randomBlocks = { 14, 14 }, --放到下面的
    levelBlockNum = 40,        --每层的块数
    levelNum = 8,              --层数
    slotNum = 7,               --槽数量

    composeNum = 3,            --合成数量
    typeNum = 12,              --类型数量
}

--每个格子的宽高，图标高度是56/3=18 覆盖下层图标三分之和三分只二
NiuLeGeMaOBJ.widthUnit = 18
NiuLeGeMaOBJ.heightUnit = 18

--操作历史
NiuLeGeMaOBJ.opHistory = {}

--已消除块数
NiuLeGeMaOBJ.clearBlockNum = 0


function NiuLeGeMaOBJ:main(objcfg)
    self.objcfg = objcfg
    self.blocksDataTable = {}
    self.gameTime = 0
    self:OpenUI()
end

--开始统计游戏时间
function NiuLeGeMaOBJ:startGameTime()
    GUI:Button_setBrightEx(self.ui.Button_shuffle, true)
    GUI:Text_setString(self.ui.Text_1, "游戏时间：")
    GUI:Text_setString(self.ui.Text_2, "1秒")
    GUI:schedule(self.ui.Layout, function()
        self.gameTime = self.gameTime + 1
        local timeStr = secondsToVariedChineseHMS(self.gameTime)
        GUI:Text_setString(self.ui.Text_2, timeStr)
    end, 1)
end
--响应网络消息后开始第二关
function NiuLeGeMaOBJ:Response(arg1, arg2, arg3, data)
    if arg2 == 0 then
        self.blocksData = data[1]
        self.totalBlockNum = arg1
        self:StartGame()
        return
    end
    table.insert(self.blocksDataTable, data[1])
    self.blocksData = table.concat(self.blocksDataTable)
    if #self.blocksDataTable > 1 then
        self.totalBlockNum = arg1
        self:StartGame()
    end
end

function NiuLeGeMaOBJ:OpenUI()
    --开始游戏
    local parent = GUI:Win_Create(self.__cname, 0, 0, 0, 0, false, false, true, true, true)
    self._parent = parent
    GUI:LoadExport(parent, self.objcfg.UI_PATH)
    self.ui = GUI:ui_delegate(parent)
    ssrSetWidgetPosition(parent, self.ui.img_bg)
    GUI:addOnClickEvent(self.ui.CloseLayout, function()
        self:messagebox("确定退出？退出后将重新开始", function()
            GUI:Win_Close(self._parent)
        end)
    end)
    GUI:addOnClickEvent(self.ui.CloseButton, function()
        self:messagebox("确定退出？退出后将重新开始", function()
            GUI:Win_Close(self._parent)
        end)
    end)

    GUI:addOnClickEvent(self.ui.Button_exit, function()
        self:messagebox("确定退出？退出后将重新开始", function()
            GUI:Win_Close(self._parent)
        end)
    end)

    --移出
    GUI:addOnClickEvent(self.ui.Button_remove, function()
        self:messagebox("从下放移出三个道具，并且每局游戏只有一次机会，确定继续？", function()
            self:doRemove()
        end)
    end)

    --打乱
    GUI:addOnClickEvent(self.ui.Button_shuffle, function()
        self:messagebox("打乱所有道具，需要20W元宝，确定继续？", function()
            ssrMessage:sendmsg(ssrNetMsgCfg.NiuLeGeMa_RequestDoShuffle)
        end)
    end)

    GUI:addOnClickEvent(self.ui.Button_back, function()
        self:messagebox("撤回上一次操作，并且每局游戏只有一次机会，确定继续？", function()
            self:doRevert()
        end)
    end)
    --默认禁用
    GUI:Button_setBrightEx(self.ui.Button_remove, false)
    GUI:Button_setBrightEx(self.ui.Button_back, false)
    GUI:Button_setBrightEx(self.ui.Button_shuffle, false)

    self:StartGameLevel1()
end

function NiuLeGeMaOBJ:StartGameLevel1()
    --是否撤回过
    self.isRemove = false
    --是否撤撤回过
    self.isBack = false
    --飞入完了才可继续点击
    self.noClicks = true
    self.slotImageList = {}
    --游戏状态0未开始，1进行中，2失败，3胜利
    self.gameStatus = 0
    --当前占用槽位
    self.currSlotNum = 0
    --已经清除的块数
    self.clearBlockNum = 0
    self.totalBlockNum = 18
    local gameData = {}
    for i = 1, 18 do
        table.insert(gameData, (i - 1) % 3 + 1)
    end
    for i = #gameData, 2, -1 do
        local j = math.random(i)
        gameData[i], gameData[j] = gameData[j], gameData[i]
    end
    self.level = 1
    local level1AllBlocks = {}
    for i = 1, 18 do
        local newBlock = {
            id = i - 1,         --ID
            status = 0,         --状态
            level = 0,          --层级
            type = gameData[i], --类型
            H = {},             --上面的块
            L = {}              --下面的块
        }
        table.insert(level1AllBlocks, newBlock)
    end
    local level1BlockX = 70
    local level1BlockY = 50
    for i = 1, 9 do
        level1AllBlocks[i].x = level1BlockX
        level1AllBlocks[i].y = level1BlockY
        level1AllBlocks[i].level = 1
        level1BlockX = level1BlockX + 160

        table.insert(level1AllBlocks[i].L, level1AllBlocks[i + 9])
        if i % 3 == 0 then
            level1BlockX = 70
            level1BlockY = level1BlockY + 100
        end
    end
    level1BlockX = 70
    level1BlockY = 16
    for i = 10, 18 do
        level1AllBlocks[i].x = level1BlockX
        level1AllBlocks[i].y = level1BlockY
        level1AllBlocks[i].level = 1
        level1BlockX = level1BlockX + 160
        table.insert(level1AllBlocks[i].H, level1AllBlocks[i - 9])
        if i % 3 == 0 then
            level1BlockX = 70
            level1BlockY = level1BlockY + 100
        end
    end

    self.levelBlocksVallevel1 = level1AllBlocks
    self.randomBlocksVal = {}

    --初始化槽位置
    self.slotAreaVal = {}
    for i = 1, self.gameConfig.slotNum do
        self.slotAreaVal[i] = nil
    end
    --添加到界面显示
    self:addBlocksToUI()
end

--开始游戏
function NiuLeGeMaOBJ:StartGame()
    self:startGameTime()
    self.level = 2
    --飞入完了才可继续点击
    self.noClicks = true
    self.slotImageList = {}
    --游戏状态0未开始，1进行中，2失败，3胜利
    self.gameStatus = 0
    --当前占用槽位
    self.currSlotNum = 0
    --已经清除的块数
    self.clearBlockNum = 0
    --初始化棋盘
    local boxWidthNum = 32
    local boxHeightNum = 22
    --初始化一个28*28的棋盘
    self.chessBoard = self:initChessBoard(boxWidthNum, boxHeightNum)
    --初始化块
    local blocksDataArr = SL:JsonDecode(self.blocksData)
    local levelBlocks = blocksDataArr.levelBlocks
    local randomBlocks = blocksDataArr.randomBlocks
    for i, v in ipairs(levelBlocks) do
        v.status = 0
        v.level = 0
        v.H = {}
        v.L = {}
    end

    for i, v in ipairs(randomBlocks) do
        for j, k in ipairs(v) do
            k.status = 0
            k.level = 0
            k.H = {}
            k.L = {}
            k.random = i
        end
    end

    for i, v in ipairs(levelBlocks) do
        table.insert(self.chessBoard[v.x][v.y].blocks, v)
        self:genLevelRelation(v)
    end

    self.levelBlocksVal = levelBlocks
    self.randomBlocksVal = randomBlocks

    --初始化槽位置
    self.slotAreaVal = {}
    for i = 1, self.gameConfig.slotNum do
        self.slotAreaVal[i] = nil
    end
    --添加到界面显示
    self:addBlocksToUI()
end

function NiuLeGeMaOBJ:genLevelRelation(block)
    -- 确定该块附近的格子坐标范围
    local boxWidthNum = 32
    local boxHeightNum = 30
    local minX = math.max(block.x - 2, 1)
    local minY = math.max(block.y - 2, 1)
    local maxX = math.min(block.x + 3, boxWidthNum - 2)
    local maxY = math.min(block.y + 3, boxWidthNum - 2)
    -- 遍历该块附近的格子
    local maxLevel = 0
    for i = minX, maxX - 1 do
        for j = minY, maxY - 1 do
            --如果找到了块
            local relationBlocks = self.chessBoard[i][j].blocks
            if #relationBlocks > 0 then
                local maxLevelRelationBlock = relationBlocks[#relationBlocks]
                if maxLevelRelationBlock.id ~= block.id then
                    maxLevel = math.max(maxLevel, maxLevelRelationBlock.level)
                    table.insert(block.H, maxLevelRelationBlock)
                    table.insert(maxLevelRelationBlock.L, block)
                end
            end
        end
    end
    -- 比最高层的块再高一层（初始为 1）
    block.level = maxLevel + 1
end

--界面添加逻辑
function NiuLeGeMaOBJ:addBlocksToUI()
    GUI:removeAllChildren(self.ui.Layout)
    if self.level == 1 then
        for idx, block in ipairs(self.levelBlocksVallevel1) do
            if block.status == 0 then
                local ImageView = GUI:Image_Create(self.ui.Layout, "ImageView" .. idx, 0.00, 0.00,
                    self.blocks[block.type])
                GUI:setPosition(ImageView, block.x, block.y)
                GUI:setLocalZOrder(ImageView, 100 + block.level)
                GUI:setTouchEnabled(ImageView, true)
                GUI:addOnClickEvent(ImageView, function(widget)
                    self:doClickBlock(widget, block)
                end)
                local isDisabled = #block.L > 0
                if isDisabled then
                    ImageView:setColor(cc.c3b(100, 100, 100))
                    --GUI:setOpacity(ImageView, 128)
                    GUI:setTouchEnabled(ImageView, false)
                end
            end
        end
    else
        --添加到界面上方
        for idx, block in ipairs(self.levelBlocksVal) do
            if block.status == 0 then
                local ImageView = GUI:Image_Create(self.ui.Layout, "ImageView" .. idx, 0.00, 0.00,
                    self.blocks[block.type])
                if block.isMove then
                    GUI:setPosition(ImageView, block.x, block.y)
                else
                    GUI:setPosition(ImageView, block.x * self.widthUnit, block.y * self.heightUnit)
                end

                GUI:setLocalZOrder(ImageView, 100 + block.level)
                GUI:setTouchEnabled(ImageView, true)
                GUI:addOnClickEvent(ImageView, function(widget)
                    self:doClickBlock(widget, block)
                end)
                local isDisabled = #block.L > 0
                if isDisabled then
                    ImageView:setColor(cc.c3b(100, 100, 100))
                    --GUI:setOpacity(ImageView, 128)
                    GUI:setTouchEnabled(ImageView, false)
                end
            end
        end
        --添加到界面下方左边
        if self.randomBlocksVal[1] == nil then
            return
        end
        if self.randomBlocksVal[2] == nil then
            return
        end
        --添加左边区域
        local L_x = 10
        for i, doClickBlock in ipairs(self.randomBlocksVal[1]) do
            local ImageView = GUI:Image_Create(self.ui.Layout, "ImageView_f" .. i, L_x, -46.00,
                self.blocks[doClickBlock.type])
            if i == #self.randomBlocksVal[1] then
                GUI:setTouchEnabled(ImageView, true)
                ImageView:setColor(cc.c3b(255, 255, 255))
                GUI:addOnClickEvent(ImageView, function(widget)
                    self:doClickBlock(widget, doClickBlock, i, 1)
                end)
            else
                ImageView:setColor(cc.c3b(100, 100, 100))
            end
            L_x = L_x + 5
        end
        --添加到界面下方右边
        local R_x = 442
        for i, doClickBlock in ipairs(self.randomBlocksVal[2]) do
            local ImageView = GUI:Image_Create(self.ui.Layout, "ImageView_r" .. i, R_x, -46.00,
                self.blocks[doClickBlock.type])
            if i == #self.randomBlocksVal[2] then
                GUI:setTouchEnabled(ImageView, true)
                ImageView:setColor(cc.c3b(255, 255, 255))
                GUI:addOnClickEvent(ImageView, function(widget)
                    self:doClickBlock(widget, doClickBlock, i, 2)
                end)
            else
                ImageView:setColor(cc.c3b(100, 100, 100))
            end
            R_x = R_x - 5
        end
    end
end

--定义棋盘格子
function NiuLeGeMaOBJ:initChessBoard(width, height)
    local chessBoard = {}
    for i = 1, width do
        chessBoard[i] = {}
        for j = 1, height do
            chessBoard[i][j] = {
                blocks = {}
            }
        end
    end
    return chessBoard
end

-- 点击块事件
--- @param block 块
--- @param randomIdx 随机区域下标，>= 0 表示点击的是随机块
--- @param force 强制移出
function NiuLeGeMaOBJ:doClickBlock(widget, block, randomIdx, leftOrRight, force)
    --动画完成才可点击
    if not self.noClicks then
        return
    end
    randomIdx = randomIdx or -1
    force = force or false
    leftOrRight = leftOrRight or 1

    --拒绝放置
    if self.currSlotNum >= self.gameConfig.slotNum or block.status ~= 0 or (#block.L > 0 and not force) then
        return
    end
    block.status = 1
    if randomIdx >= 0 then
        -- 移出所点击的随机区域的最后一个元素
        table.remove(self.randomBlocksVal[leftOrRight], #self.randomBlocksVal[leftOrRight])
    else
        -- 移出覆盖关系
        for _, higherThanBlock in ipairs(block.H) do
            for i, lowerThanBlock in ipairs(higherThanBlock.L) do
                if lowerThanBlock.id == block.id then
                    table.remove(higherThanBlock.L, i)
                    break
                end
            end
        end
    end
    -- 非随机区才可撤回
    table.insert(self.opHistory, block)
    -- 新元素加入插槽
    local tempSlotNum = self.currSlotNum

    --相同类型排序
    local isBlockHave = false
    if #self.slotAreaVal == 0 then
        self.slotAreaVal[tempSlotNum + 1] = block
    else
        for i, v in ipairs(self.slotAreaVal) do
            if block.type == v.type then
                table.insert(self.slotAreaVal, i, block)
                isBlockHave = true
                break
            end
        end
        if not isBlockHave then
            self.slotAreaVal[tempSlotNum + 1] = block
        end
    end


    -- 检查是否有可消除的
    -- block => 出现次数
    local map = {}
    -- 去除空槽
    local tempSlotAreaVal = {}
    for _, slotBlock in ipairs(self.slotAreaVal) do
        if slotBlock then
            table.insert(tempSlotAreaVal, slotBlock)
            local type = slotBlock.type
            map[type] = (map[type] or 0) + 1
        end
    end
    -- 得到新数组
    local newSlotAreaVal = {}
    tempSlotNum = 0
    for _, slotBlock in ipairs(tempSlotAreaVal) do
        -- 成功消除（不添加到新数组中）
        if map[slotBlock.type] >= self.gameConfig.composeNum then
            -- 块状态改为已消除
            slotBlock.status = 2
            -- 已消除块数 +1
            self.clearBlockNum = self.clearBlockNum + 1
            -- 清除操作记录，防止撤回
            self.opHistory = {}
        else
            newSlotAreaVal[tempSlotNum + 1] = slotBlock
            tempSlotNum = tempSlotNum + 1
        end
    end
    self.slotAreaVal = newSlotAreaVal
    self.currSlotNum = tempSlotNum

    if self.currSlotNum == 0 or self.isRemove then
        GUI:Button_setBrightEx(self.ui.Button_remove, false)
    elseif self.currSlotNum > 0 and not self.isRemove then
        GUI:Button_setBrightEx(self.ui.Button_remove, true)
    end

    if #self.opHistory == 0 or self.isBack then
        GUI:Button_setBrightEx(self.ui.Button_back, false)
    elseif #self.opHistory > 0 and not self.isBack then
        GUI:Button_setBrightEx(self.ui.Button_back, true)
    end

    -- 游戏结束
    if tempSlotNum >= self.gameConfig.slotNum then
        self.gameStatus = 2
        SL:ScheduleOnce(function()
            self:messagebox("你输了，是否重新开始？", function()
                GUI:unSchedule(self.ui.Layout)
                GUI:Win_Close(self._parent)
                ssrUIManager:OPEN(ssrObjCfg.NiuLeGeMa)
            end)
            GUI:Button_setBrightEx(self.ui.Button_remove, false)
            GUI:Button_setBrightEx(self.ui.Button_back, false)
            GUI:Button_setBrightEx(self.ui.Button_shuffle, false)
        end, 0.5)
    end
    if self.clearBlockNum >= self.totalBlockNum then
        self.gameStatus = 3
        SL:ScheduleOnce(function()
            if self.level == 1 then
                ssrMessage:sendmsg(ssrNetMsgCfg.NiuLeGeMa_Request)
            else
                --通关游戏
                GUI:unSchedule(self.ui.Layout)
                ssrMessage:sendmsg(ssrNetMsgCfg.NiuLeGeMa_RequestFinish,0,0,0,{self.gameTime})
            end
        end, 0.5)
    end

    local widgetPos = GUI:getWorldPosition(widget)
    GUI:setLocalZOrder(widget, 1000)
    GUI:setTouchEnabled(widget, false)
    GUI:setTag(widget, block.type)
    local targetPos = GUI:getWorldPosition(self.ui.Layout_1)

    GUI:removeFromParent(widget)
    GUI:addChild(self.ui.Layout_1, widget)
    GUI:setPosition(widget, widgetPos.x - targetPos.x, widgetPos.y - targetPos.y)
    self.noClicks = false
    local SlotImageX = self:getSlotImageX(widget)
    local value = {
        x = targetPos.x - widgetPos.x + SlotImageX,
        y = targetPos.y - widgetPos.y
    }
    local x = 0
    self.slotImageList = {}
    GUI:Timeline_MoveBy(widget, value, 0.2, function()
        GUI:removeAllChildren(self.ui.Layout_1)
        for index, slotBlock in ipairs(self.slotAreaVal) do
            local ImageView = GUI:Image_Create(self.ui.Layout_1, "ImageView_c" .. index, x, 0,
                self.blocks[slotBlock.type])
            GUI:setTag(ImageView, slotBlock.type)
            table.insert(self.slotImageList, ImageView)
            x = x + 56
        end
        self.noClicks = true
    end)
    self:addBlocksToUI()
end

--更新槽位
function NiuLeGeMaOBJ:UpdateSlot()
    self.slotImageList = {}
    GUI:removeAllChildren(self.ui.Layout_1)
    local x = 0
    for index, slotBlock in ipairs(self.slotAreaVal) do
        local ImageView = GUI:Image_Create(self.ui.Layout_1, "ImageView_c" .. index, x, 0, self.blocks[slotBlock.type])
        GUI:setTag(ImageView, slotBlock.type)
        table.insert(self.slotImageList, ImageView)
        x = x + 56
    end
end

--获取槽位块的的x坐标
function NiuLeGeMaOBJ:getSlotImageX(widget)
    if self.slotImageList == nil then
        return 0
    end
    local totalX = #self.slotImageList
    for i = #self.slotImageList, 1, -1 do
        if GUI:getTag(self.slotImageList[i]) == GUI:getTag(widget) then
            return i * 56
        end
    end
    return totalX * 56
end

--移出格子
function NiuLeGeMaOBJ:doRemove()
    if #self.slotAreaVal == 0 then
        SL:ShowSystemTips("没有道具可以移出")
        return
    end
    local removeNum = 0
    local removeBlockX = 167
    for i = 1, 3 do
        local block = self.slotAreaVal[i]
        if block then
            
            block.x = removeBlockX
            block.y = -46
            block.level = 10000
            block.status = 0
            block.H = {}
            block.L = {}
            block.isMove = true
            if block.random then
                -- 改变新块的坐标
                if self.level == 1 then
                    table.insert(self.levelBlocksVallevel1, block)
                else
                    table.insert(self.levelBlocksVal, block)
                end
            end
            block.random = nil
            removeNum = removeNum + 1
            removeBlockX = removeBlockX + 59
        end
    end
    for i = 1, removeNum do
        table.remove(self.slotAreaVal, 1)
    end
    self.currSlotNum = self.currSlotNum - removeNum

    self.isRemove = true
    GUI:Button_setBrightEx(self.ui.Button_remove, false)
    --更新界面
    self:addBlocksToUI()
    --更新槽位
    self:UpdateSlot()
end

function NiuLeGeMaOBJ:ResponseDoShuffle()
    self:doShuffle()
end
--打乱
function NiuLeGeMaOBJ:doShuffle()
    -- 遍历所有未消除的块
    local originBlocks = {}
    for _, block in ipairs(self.levelBlocksVal) do
        if block.status == 0 then
            table.insert(originBlocks, block)
        end
    end
    -- 打乱块的类型
    local newBlockTypes = {}
    for _, block in ipairs(originBlocks) do
        table.insert(newBlockTypes, block.type)
    end
    newBlockTypes = self:shuffleArray(newBlockTypes)
    -- 更新块的类型
    local pos = 1
    for _, block in ipairs(originBlocks) do
        block.type = newBlockTypes[pos]
        pos = pos + 1
    end
    --是否被打乱过
    -- self.isShuffle = true
    --更新界面
    self:addBlocksToUI()
    --更新槽位
    --self:UpdateSlot()
end

function NiuLeGeMaOBJ:doRevert()
    if self.level == 1 then
        SL:ShowSystemTips("第一关不可撤回")
        return
    end
    if #self.opHistory < 1 then
        SL:ShowSystemTips("没有撤回的道具")
        return
    end
    GUI:Button_setBrightEx(self.ui.Button_back, false)
    local id = 0
    local getId = 0
    local block = self.opHistory[#self.opHistory]
    block.status = 0
    id = block.id
    getId = self:findSlotAreaValById(id)
    if getId == nil then
        return
    end

    if block.random then
        table.insert(self.randomBlocksVal[block.random], block)
    else
        self:genLevelRelation(self.slotAreaVal[getId])
    end

    table.remove(self.slotAreaVal, getId)
    self.currSlotNum = self.currSlotNum - 1

    self.isBack = true
    --更新界面
    self:addBlocksToUI()
    --更新槽位
    self:UpdateSlot()
end

function NiuLeGeMaOBJ:findSlotAreaValById(id)
    for i, v in ipairs(self.slotAreaVal) do
        if v.id == id then
            return i
        end
    end
    return nil
end

function NiuLeGeMaOBJ:shuffleArray(arr)
    local n = #arr
    for i = 1, n do
        local j = math.random(i, n)
        arr[i], arr[j] = arr[j], arr[i]
    end
    return arr
end

function NiuLeGeMaOBJ:messagebox(message, action)
    if GUI:GetWindow(self.ui.img_bg, "Layout_msg_bg") ~= nil then return end

    local Layout = GUI:Layout_Create(self.ui.img_bg, "Layout_msg_bg", -300, -300, ssrConstCfg.width + 500,
        ssrConstCfg.width + 500, false)
    GUI:Layout_setBackGroundColorType(Layout, 1)
    GUI:Layout_setBackGroundColor(Layout, "#100808")
    GUI:Layout_setBackGroundColorOpacity(Layout, 150)
    GUI:setTouchEnabled(Layout, true)
    GUI:addOnClickEvent(Layout, function()
        return
    end)
    -- Create ImageView
    local ImageView_msg_bg = GUI:Image_Create(Layout, "ImageView_msg_bg", 477.00, 573.00, "res/public/1900000600.png")
    GUI:Image_setScale9Slice(ImageView_msg_bg, 10, 10, 10, 10)
    GUI:setContentSize(ImageView_msg_bg, 550, 176)
    GUI:setIgnoreContentAdaptWithSize(ImageView_msg_bg, false)
    GUI:setTouchEnabled(ImageView_msg_bg, false)

    -- Create Text
    local Text = GUI:Text_Create(ImageView_msg_bg, "Text", 42.00, 131.00, 16, "#ffffff", [[]])
    GUI:setTouchEnabled(Text, false)
    GUI:Text_enableOutline(Text, "#000000", 1)
    GUI:Text_setString(Text, message)

    -- Create Button_msg1
    local Button_msg1 = GUI:Button_Create(ImageView_msg_bg, "Button_msg1", 103.00, 27.00, "res/public/1900001022.png")
    GUI:Button_loadTexturePressed(Button_msg1, "res/public/1900001023.png")
    GUI:Button_setTitleText(Button_msg1, "确定")
    GUI:Button_setTitleColor(Button_msg1, "#fffbf0")
    GUI:Button_setTitleFontSize(Button_msg1, 18)
    GUI:Button_titleEnableOutline(Button_msg1, "#000000", 1)
    GUI:Win_SetParam(Button_msg1, { grey = 1 }, "Button")
    GUI:setTouchEnabled(Button_msg1, true)

    -- Create Button_msg2
    local Button_msg2 = GUI:Button_Create(ImageView_msg_bg, "Button_msg2", 353.00, 28.00, "res/public/1900001022.png")
    GUI:Button_loadTexturePressed(Button_msg2, "res/public/1900001023.png")
    GUI:Button_setTitleText(Button_msg2, "取消")
    GUI:Button_setTitleColor(Button_msg2, "#fffbf0")
    GUI:Button_setTitleFontSize(Button_msg2, 18)
    GUI:Button_titleEnableOutline(Button_msg2, "#000000", 1)
    GUI:Win_SetParam(Button_msg2, { grey = 1 }, "Button")
    GUI:setTouchEnabled(Button_msg2, true)

    -- Create Layout_msg_close
    local Layout_msg_close = GUI:Layout_Create(ImageView_msg_bg, "Layout_msg_close", 520.00, 127.00, 80.00, 80.00, false)
    GUI:setTouchEnabled(Layout_msg_close, true)

    -- Create Button_msg_close
    local Button_msg_close = GUI:Button_Create(Layout_msg_close, "Button_msg_close", 29.00, 7.00,
        "res/public/1900000510.png")
    GUI:Button_loadTexturePressed(Button_msg_close, "res/public/1900000511.png")
    GUI:Button_loadTextureDisabled(Button_msg_close, "res/private/gui_edit/Button_Disable.png")
    GUI:Button_setTitleText(Button_msg_close, "")
    GUI:Button_setTitleColor(Button_msg_close, "#ffffff")
    GUI:Button_setTitleFontSize(Button_msg_close, 14)
    GUI:Button_titleEnableOutline(Button_msg_close, "#000000", 1)
    GUI:Win_SetParam(Button_msg_close, { grey = 1 }, "Button")
    GUI:setTouchEnabled(Button_msg_close, true)

    GUI:addOnClickEvent(Button_msg1, function()
        GUI:removeFromParent(Layout)
        if action then
            action()
        end
    end)
    GUI:addOnClickEvent(Button_msg2, function()
        GUI:removeFromParent(Layout)
    end)
    GUI:addOnClickEvent(Layout_msg_close, function()
        GUI:removeFromParent(Layout)
    end)
    GUI:addOnClickEvent(Button_msg_close, function()
        GUI:removeFromParent(Layout)
    end)
end

-------------------------网络消息---------------------------
return NiuLeGeMaOBJ

meinvwudi

local ui = {}
local _V = function(v) return SL:GetMetaValue(v) end
local FUNCQUEUE = {}
local TAGOBJ = {}

function ui.init(parent, __data__, __update__)
	if __update__ then return ui.update(__data__) end
	-- Create img_bg
	local img_bg = GUI:Image_Create(parent, "img_bg", 94.00, -14.00, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//img_bg.png")
	GUI:setAnchorPoint(img_bg, 0.00, 0.00)
	GUI:setTouchEnabled(img_bg, false)
	GUI:setTag(img_bg, -1)

	-- Create CloseButton
	local CloseButton = GUI:Button_Create(img_bg, "CloseButton", 867.00, 607.00, "res/custom/public/btn_close.png")
	GUI:Button_loadTexturePressed(CloseButton, "res/public/1900000511.png")
	GUI:Button_setTitleText(CloseButton, [[]])
	GUI:Button_setTitleColor(CloseButton, "#ffffff")
	GUI:Button_setTitleFontSize(CloseButton, 10)
	GUI:Button_titleEnableOutline(CloseButton, "#000000", 1)
	GUI:setAnchorPoint(CloseButton, 0.50, 0.50)
	GUI:setTouchEnabled(CloseButton, true)
	GUI:setTag(CloseButton, -1)

	-- Create CloseLayout
	local CloseLayout = GUI:Layout_Create(img_bg, "CloseLayout", 874.00, 620.00, 80, 80, false)
	GUI:setAnchorPoint(CloseLayout, 0.50, 0.50)
	GUI:setOpacity(CloseLayout, 0)
	GUI:setTouchEnabled(CloseLayout, true)
	GUI:setTag(CloseLayout, -1)

	-- Create Layout
	local Layout = GUI:Layout_Create(img_bg, "Layout", 200.00, 198.00, 550, 480, false)
	GUI:setAnchorPoint(Layout, 0.00, 0.00)
	GUI:setTouchEnabled(Layout, true)
	GUI:setTag(Layout, -1)

	-- Create Layout_1
	local Layout_1 = GUI:Layout_Create(img_bg, "Layout_1", 263.00, 24.00, 400, 66, false)
	GUI:setAnchorPoint(Layout_1, 0.00, 0.00)
	GUI:setTouchEnabled(Layout_1, false)
	GUI:setTag(Layout_1, -1)

	-- Create Node
	local Node = GUI:Node_Create(img_bg, "Node", 0.00, 0.00)
	GUI:setTag(Node, -1)

	-- Create Button_exit
	local Button_exit = GUI:Button_Create(Node, "Button_exit", 759.00, 5.00, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//exit.png")
	GUI:Button_loadTexturePressed(Button_exit, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//exit.png")
	GUI:Button_loadTextureDisabled(Button_exit, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//exit.png")
	GUI:Button_setTitleText(Button_exit, [[]])
	GUI:Button_setTitleColor(Button_exit, "#ffffff")
	GUI:Button_setTitleFontSize(Button_exit, 15)
	GUI:Button_titleEnableOutline(Button_exit, "#000000", 1)
	GUI:setAnchorPoint(Button_exit, 0.00, 0.00)
	GUI:setTouchEnabled(Button_exit, true)
	GUI:setTag(Button_exit, -1)

	-- Create Button_remove
	local Button_remove = GUI:Button_Create(Node, "Button_remove", 85.00, 4.00, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//remove.png")
	GUI:Button_loadTexturePressed(Button_remove, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//remove.png")
	GUI:Button_loadTextureDisabled(Button_remove, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//remove_grey.png")
	GUI:Button_setTitleText(Button_remove, [[]])
	GUI:Button_setTitleColor(Button_remove, "#ffffff")
	GUI:Button_setTitleFontSize(Button_remove, 14)
	GUI:Button_titleEnableOutline(Button_remove, "#000000", 1)
	GUI:setAnchorPoint(Button_remove, 0.00, 0.00)
	GUI:setTouchEnabled(Button_remove, true)
	GUI:setTag(Button_remove, -1)

	-- Create Button_shuffle
	local Button_shuffle = GUI:Button_Create(Node, "Button_shuffle", 169.00, 4.00, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//daluan.png")
	GUI:Button_loadTexturePressed(Button_shuffle, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//daluan.png")
	GUI:Button_loadTextureDisabled(Button_shuffle, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//daluan_grey.png")
	GUI:Button_setTitleText(Button_shuffle, [[]])
	GUI:Button_setTitleColor(Button_shuffle, "#ffffff")
	GUI:Button_setTitleFontSize(Button_shuffle, 14)
	GUI:Button_titleEnableOutline(Button_shuffle, "#000000", 1)
	GUI:setAnchorPoint(Button_shuffle, 0.00, 0.00)
	GUI:setTouchEnabled(Button_shuffle, true)
	GUI:setTag(Button_shuffle, -1)

	-- Create Button_back
	local Button_back = GUI:Button_Create(Node, "Button_back", 672.00, 4.00, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//back.png")
	GUI:Button_loadTexturePressed(Button_back, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//back.png")
	GUI:Button_loadTextureDisabled(Button_back, "res/custom/ShuangJieHuoDongMain/NiuLeGeMa//back_grey.png")
	GUI:Button_setTitleText(Button_back, [[]])
	GUI:Button_setTitleColor(Button_back, "#ffffff")
	GUI:Button_setTitleFontSize(Button_back, 14)
	GUI:Button_titleEnableOutline(Button_back, "#000000", 1)
	GUI:setAnchorPoint(Button_back, 0.00, 0.00)
	GUI:setTouchEnabled(Button_back, true)
	GUI:setTag(Button_back, -1)

	-- Create Text_1
	local Text_1 = GUI:Text_Create(img_bg, "Text_1", 546.00, 107.00, 16, "#00f000", [[]])
	GUI:setAnchorPoint(Text_1, 0.00, 0.00)
	GUI:setTouchEnabled(Text_1, false)
	GUI:setTag(Text_1, 0)
	GUI:Text_enableOutline(Text_1, "#000000", 1)

	-- Create Text_2
	local Text_2 = GUI:Text_Create(Text_1, "Text_2", 75.00, 0.00, 16, "#ff0000", [[]])
	GUI:setAnchorPoint(Text_2, 0.00, 0.00)
	GUI:setTouchEnabled(Text_2, false)
	GUI:setTag(Text_2, 0)
	GUI:Text_enableOutline(Text_2, "#000000", 1)

	ui.update(__data__)
	return img_bg
end

function ui.update(data)
	for _, func in pairs(FUNCQUEUE) do
		if func then func(data) end
	end
end

return ui

meinvwudi

local NiuLeGeMa = {}
local give = { { "圣诞花环", 50 }, { "圣诞饼干", 7 } }
--下面排
NiuLeGeMa.randomBlocks = { 14, 14 }
-- NiuLeGeMa.randomBlocks = { 2, 2 }

local function decrypt(hexstr, key)
    local klen = #key
    local idx = 1
    local bytes = {}
    for i = 1, #hexstr, 2 do
        local c = tonumber(hexstr:sub(i, i + 1), 16) -- 转成0~255
        local k = key:byte(((idx - 1) % klen) + 1)
        local d = bit.bxor(c, k)
        table.insert(bytes, d)
        idx = idx + 1
    end
    local decryptedStr = string.char(unpack(bytes))
    local magicPrefix = "flag|"
    if decryptedStr:sub(1, #magicPrefix) ~= magicPrefix then
        return nil
    end
    return decryptedStr:sub(#magicPrefix + 1)
end

--打乱数组
local function shuffleArray(array)
    for i = #array, 2, -1 do
        local j = math.random(i)
        array[i], array[j] = array[j], array[i]
    end
    return array
end

local function genLevelBlockPos(blocks, minX, minY, maxX, maxY)
    local currentPosSet = {}
    for _, block in ipairs(blocks) do
        local newPosX, newPosY, key
        repeat
            newPosX = math.random(minX, maxX)
            newPosY = math.random(minY, maxY)
            key = newPosX .. "," .. newPosY
        until not currentPosSet[key]
        currentPosSet[key] = true
        block.x = newPosX
        block.y = newPosY
    end
end
-----------网络消息
Message.RegisterNetMsg(ssrNetMsgCfg.NiuLeGeMa, NiuLeGeMa)

function NiuLeGeMa.Request(actor, arg1, arg2, arg3, data)
    --合成数量默认3
    local composeNum = 3
    --块的类型数量
    local typeNum = 12

    --层数
    local levelNum = 7
    -- local levelNum = 1
    --每层数量
    -- local levelBlockNum = 1
    local levelBlockNum = 40

    local blockNumUnit = composeNum * typeNum

    --放到下面的总块数
    local totalRandomBlockNum = 0
    for _, v in ipairs(NiuLeGeMa.randomBlocks) do
        totalRandomBlockNum = totalRandomBlockNum + v
    end
    --需要的最小块数
    local minBlockNum = levelNum * levelBlockNum + totalRandomBlockNum;

    local totalBlockNum = minBlockNum
    if totalBlockNum % blockNumUnit ~= 0 then
        totalBlockNum = math.floor(minBlockNum / blockNumUnit + 1) * blockNumUnit
    end
    ----全部块
    local totalBlockNum = totalBlockNum
    ----生成块数据
    local gameData = {}
    for i = 1, totalBlockNum do
        table.insert(gameData, (i - 1) % typeNum + 1)
    end
    --打乱数组
    gameData = shuffleArray(gameData)

    --初始化
    local allBlocks = {}
    for i = 1, totalBlockNum do
        local newBlock = {
            id = i - 1, --ID
            -- status = 0, --状态
            -- level = 0, --层级
            type = gameData[i], --类型
            -- H = {}, --上面的块
            -- L = {} --下面的块
        }
        table.insert(allBlocks, newBlock)
    end

    local pos = 1
    --放到下面的块，1左 2右
    local randomBlocks = {}
    for idx, randomBlock in ipairs(NiuLeGeMa.randomBlocks) do
        randomBlocks[idx] = {}
        for i = 1, randomBlock do
            table.insert(randomBlocks[idx], allBlocks[pos])
            pos = pos + 1
        end
    end
    local surplusBlockNum = totalBlockNum - totalRandomBlockNum
    --计算有层级关系的块
    local levelBlocks = {}
    local minX, maxX, minY, maxY = 1, 24, 1, 18
    --根据设定的层数和每层的块数，计算每层的块
    for i = 1, levelNum do
        --选出一个最小的数，用来划分每层数量
        local nextBlockNum = math.min(levelBlockNum, surplusBlockNum)
        if i == levelNum then
            nextBlockNum = surplusBlockNum
        end
        local nextGenBlocks = {}
        for j = pos, pos + nextBlockNum - 1 do
            table.insert(nextGenBlocks, allBlocks[j])
        end
        pos = pos + nextBlockNum
        for k = 1, #nextGenBlocks do
            levelBlocks[#levelBlocks + 1] = nextGenBlocks[k]
        end
        --计算位置
        genLevelBlockPos(nextGenBlocks, minX, minY, maxX, maxY)
        surplusBlockNum = surplusBlockNum - nextBlockNum
        if surplusBlockNum <= 0 then
            break
        end
    end

    local data = {
        levelBlocks = levelBlocks,
        randomBlocks = randomBlocks
    }
    -- local filepath = "levelBlocks.txt"
    -- local f = io.open(filepath, "a")
    -- if f then
    --     f:write(tbl2json(data).."\n")
    --     f:close()
    -- end
    local strdata = tbl2json(data)
    local chunkSize = 7000
    local chunks = math.ceil(#strdata / chunkSize)
    local isLong = 0
    if chunks > 1 then
        isLong = 1
    end
    for i = 1, chunks do
        local startIdx = (i - 1) * chunkSize + 1
        local endIdx = math.min(i * chunkSize, #strdata)
        local chunkData = strdata:sub(startIdx, endIdx)
        Message.sendmsg(actor, ssrNetMsgCfg.NiuLeGeMa_Response, totalBlockNum, isLong, 0, { chunkData })
        -- 在这里发送 chunkData 给客户端
    end
    setplaydef(actor, "N$牛了个马开始时间", os.time())
end

local cost = { { "元宝", 200000 } }
function NiuLeGeMa.RequestDoShuffle(actor)
    local name, num = Player.checkItemNumByTable(actor, cost)
    if name then
        Player.sendmsgEx(actor, string.format("你的|%s#249|不足|%d#249", name, num))
        return
    end
    Player.takeItemByTable(actor, cost, "打乱顺序", 1, true)
    Message.sendmsg(actor, ssrNetMsgCfg.NiuLeGeMa_ResponseDoShuffle)
end

function NiuLeGeMa.RequestFinish(actor, arg1, arg2, arg3, data)
    local startTime = getplaydef(actor, "N$牛了个马开始时间")
    if startTime == 0 then
        Player.sendmsgEx(actor, "开始时间错误！#249")
        return
    end
    local endTime = os.time()
    local time = endTime - startTime
    if time < 60 then
        Player.sendmsgEx(actor, "error0#249")
        return
    end
    Player.sendmsgEx(actor, "恭喜你通关了！")
    local isFinish = getplaydef(actor, VarCfg["J_牛了个马是否完成"])
    if isFinish == 0 then
        Player.sendmsgEx(actor, "恭喜你今日首次完成牛了个马，奖励已发送到邮件！")
        setplaydef(actor, VarCfg["J_牛了个马是否完成"], 1)
        local uid = Player.GetUUID(actor)
        Player.giveMailByTable(uid, 1, "牛了马首次完成奖励", "请领取您的牛了马首次完成奖励", give, 1, true)
    end
    local ranks = Player.getJsonTableByVar(nil, VarCfg["A_牛了个马排行榜"])
    local name = Player.GetName(actor)
    local lastTime = ranks[name] or 999999999999
    if data[1] < lastTime then
        Player.sendmsgEx(actor, "恭喜你刷新了排行榜！")
        ranks[name] = data[1]
    end
    Player.setJsonVarByTable(nil, VarCfg["A_牛了个马排行榜"], ranks)
end

return NiuLeGeMa