游戏开发笔记 - 同屏人数裁剪

2023-11-08

全文 ≈ 939字 | 预计阅读时长 4分钟

简单优化下AOI模块

前言

当游戏开启活动让大量玩家聚集在指定地图范围内时，给服务器和客户端带来最直接的麻烦就是：

服务器带宽占用率高

假设同屏有1000个玩家，那么任意一个玩家移动一次需要同步其他999个玩家。这导致服务器消息数量指数级增长，带宽承受压力极高。

客户端渲染卡顿

因为同屏人数越多，客户端需要渲染的模型就越多。这样在一些普通的硬件设备下会直接导致卡顿、发热。

思路

除了升级硬件，还可以在以下两个方面进行优化:

服务器控制AOI消息频率
客户端裁剪同屏人数

实现逻辑

AOI同步被动推送改成主动推送，原来的设计是玩家移动后（Move消息），然后向该玩家推送周围玩家的信息。新的方式是地图AOI模块固定频率同步信息（比如1s发送一次），把需要同步的信息分类：

移除

不在视野范围内的物体，不需要显示在屏幕内

新增

新增的物体，需要显示在屏幕内

需要更新

原来在屏幕内的物体，需要更新信息

（如果原来在屏幕内的物体，不需要更新信息则不会发送）

同时设置同屏人数上限，超过的数量裁剪掉。不过这里面也有些坑需要注意，比如：NPC不能被裁剪、队友不能被裁剪及被裁剪的物体尽量分散避免“秃头”。

实现：

func (r *Map) Init() {
    r.aoiMgr = NewAoiMgr(r.config.Cols, r.config.Rows)
    r.aoiNodes = make(map[uint32]*aoiNode, 0)
    r.ticker = time.NewTicker(1 * time.Second) // 1s
    go func() {
        for {
            <-r.ticker.C
            r.Update()
        }
    }()
}

func (r *Map) Update() {
    for _, node := range r.aoiNodes {
        if node.Type != enums.LIVING_TYPE_PLAYER {
            continue
        }
        go r.send(node)
    }
}

func (r *Map) send(role interfaces.IMapRole) {
    player := playersvr.Ins.Get(node.MapRole.GetId())
    if player == nil {
        return
    }
    // 掉线或战斗中不同步视野
    if !player.IsOnline() || player.IsInBattle() {
        return
    }
    // 处理周围节点信息
    node.UpdateNodes(r.aoiNodes)
    // 周围节点信息
    dels := node.GetLeaveNodes()
    adds := r.buildMapDatas(node.GetEnterNodes(), true)
    keeps := r.buildMapDatas(node.GetKeepNodes(), false)
    if len(adds) == 0 && len(dels) == 0 && len(keeps) == 0 {
        return
    }
    bytes, _ := proto.Marshal(&pb.S2C_MapSyncView{
        Adds: adds,
        Dels: dels,
        Keeps:  keeps,
    })
    player.Send(enums.Cmd_S2C_MapSyncView, bytes)
}

type aoiNode struct {
    Id           uint32
    Name         string
    X            int32
    Y            int32
    AoiModel     string
    Type         int32
    Blink        bool
    MapRole      interfaces.IMapRole
    MaxViewNodes int
    enterNodes   map[uint32]bool
    keepNodes    map[uint32]bool
    leaveNodes   []uint32
}

func (r *aoiNode) UpdateNodes(nodes map[uint32]*aoiNode) {
    // 超过最大显示数量
    if len(r.enterNodes)+len(r.keepNodes) <= r.MaxViewNodes {
        return
    }
    var (
        delNum  int
        delKeep bool
    )
    // 优先判断keep nodes
    if l := len(r.keepNodes); l > r.MaxViewNodes {
        delNum = l - r.MaxViewNodes
        delKeep = true
        for id := range r.enterNodes {
            node, ok := nodes[id]
            if !ok {
                delete(r.enterNodes, id)
                continue
            }
            // NPC不裁剪
            if node.Type == enums.LIVING_TYPE_NPC {
                continue
            }
            // 队友不裁剪
            if teamId := r.MapRole.GetTeamId(); teamId > 0 && teamId == node.MapRole.GetTeamId() {
                continue
            }
            delete(r.enterNodes, id)
        }
    } else {
        delNum = len(r.enterNodes) - (r.MaxViewNodes - len(r.keepNodes))
    }
    // 找出可以被裁减的物体
    var (
        mayDelIds = make([]uint32, 0)
        fromNodes = make(map[uint32]bool, 0)
    )
    if delKeep {
        fromNodes = r.keepNodes
    } else {
        fromNodes = r.enterNodes
    }
    for id := range fromNodes {
        node, ok := nodes[id]
        if !ok {
            delete(r.enterNodes, id)
            continue
        }
        // NPC不裁剪
        if node.Type == enums.LIVING_TYPE_NPC {
            continue
        }
        // 队友不裁剪
        if teamId := r.MapRole.GetTeamId(); teamId > 0 && teamId == node.MapRole.GetTeamId() {
            continue
        }
        mayDelIds = append(mayDelIds, id)
    }
    // 均匀删除，避免集中
    if l := len(mayDelIds) - delNum; l >= 0 {
        // 随机保留
        for i := 0; i < l; i++ {
            if len(mayDelIds) == 0 {
                break
            }
            randIdx := helpers.Random(len(mayDelIds))
            mayDelIds = append(mayDelIds[:randIdx], mayDelIds[randIdx+1:]...)
        }
    }
    for _, id := range mayDelIds {
        if delKeep {
            delete(r.keepNodes, id)
            r.leaveNodes = append(r.leaveNodes, id)
        } else {
            delete(r.enterNodes, id)
        }
    }
}