游戏编程模式之空间分区：优化对象位置查询的高效方案-优快云博客

本文链接：https://blog.youkuaiyun.com/gitblog_00874/article/details/148527254

游戏编程模式之空间分区：优化对象位置查询的高效方案

game-programming-patterns Source repo for the book 项目地址: https://gitcode.com/gh_mirrors/ga/game-programming-patterns

引言

在游戏开发中，我们经常需要处理大量游戏对象的位置关系查询，比如检测附近的敌人、计算碰撞或处理声音传播等。当游戏世界中的对象数量庞大时，简单的遍历查询方式会导致性能急剧下降。本文将深入探讨空间分区（Spatial Partition）这一优化模式，它通过将对象按位置组织到特定数据结构中，显著提高位置查询的效率。

问题场景

战场上的单位碰撞检测

假设我们正在开发一款即时战略游戏，战场上有数百个单位需要进行碰撞检测。最直观的实现方式是双重循环遍历所有单位：

void handleMelee()
{
    for (int i = 0; i < NUM_UNITS; i++)
    {
        for (int j = i + 1; j < NUM_UNITS; j++)
        {
            if (units[i].position() == units[j].position())
            {
                handleAttack(units[i], units[j]);
            }
        }
    }
}

这种方法的时间复杂度是O(n²)，随着单位数量增加，性能会急剧恶化。

空间分区模式

核心思想

空间分区模式包含以下关键要素：

一组具有空间位置属性的对象
按位置组织的空间数据结构
高效的位置查询能力
对象位置变化时的数据结构更新机制

适用场景

当满足以下条件时，空间分区模式特别有用：

游戏中有大量具有位置属性的对象
需要频繁执行基于位置的查询
简单遍历的性能已成为瓶颈

实现方案：固定网格

基本结构

我们将战场划分为固定大小的网格，每个网格单元存储位于该区域内的单位列表。这样碰撞检测只需在局部网格内进行。

class Grid {
private:
    static const int NUM_CELLS = 10;
    static const int CELL_SIZE = 20;
    Unit* cells[NUM_CELLS][NUM_CELLS];
    // ...
};

单位与网格的关联

每个单位需要维护其在网格中的位置信息：

class Unit {
    friend class Grid;
private:
    Grid* grid;
    int x, y;
    Unit* prev;
    Unit* next;
    // ...
};

添加单位到网格

当单位创建时，根据其位置放入对应网格：

void Grid::add(Unit* unit)
{
    // 确定所在网格
    int cellX = unit->x / CELL_SIZE;
    int cellY = unit->y / CELL_SIZE;
    
    // 添加到网格链表头部
    unit->prev = nullptr;
    unit->next = cells[cellX][cellY];
    if (cells[cellX][cellY] != nullptr) {
        cells[cellX][cellY]->prev = unit;
    }
    cells[cellX][cellY] = unit;
}

高效的碰撞检测

现在碰撞检测只需在局部网格内进行：

void Grid::handleMelee()
{
    for (int x = 0; x < NUM_CELLS; x++) {
        for (int y = 0; y < NUM_CELLS; y++) {
            handleCell(x, y);
        }
    }
}

void Grid::handleCell(int x, int y)
{
    Unit* unit = cells[x][y];
    while (unit != nullptr) {
        // 检查与网格内其他单位的碰撞
        Unit* other = unit->next;
        while (other != nullptr) {
            if (distance(unit, other) < ATTACK_DISTANCE) {
                handleAttack(unit, other);
            }
            other = other->next;
        }
        // 检查与相邻网格单位的碰撞
        if (x > 0 && y > 0) handleNeighbor(x-1, y-1, unit);
        if (x > 0) handleNeighbor(x-1, y, unit);
        if (y > 0) handleNeighbor(x, y-1, unit);
        if (x > 0 && y < NUM_CELLS-1) handleNeighbor(x-1, y+1, unit);
        
        unit = unit->next;
    }
}

处理单位移动

当单位移动跨越网格边界时，需要更新其在网格中的位置：

void Grid::move(Unit* unit, int x, int y)
{
    // 计算旧网格位置
    int oldCellX = unit->x / CELL_SIZE;
    int oldCellY = unit->y / CELL_SIZE;
    
    // 计算新网格位置
    int newCellX = x / CELL_SIZE;
    int newCellY = y / CELL_SIZE;
    
    unit->x = x;
    unit->y = y;
    
    // 如果跨越了网格边界
    if (oldCellX != newCellX || oldCellY != newCellY) {
        // 从旧网格移除
        if (unit->prev != nullptr) unit->prev->next = unit->next;
        if (unit->next != nullptr) unit->next->prev = unit->prev;
        if (cells[oldCellX][oldCellY] == unit) {
            cells[oldCellX][oldCellY] = unit->next;
        }
        
        // 添加到新网格
        add(unit);
    }
}