《游戏编程模式》（8）

《游戏编程模式》最后一篇，刚从英国玩了一圈，春节又要到啦

 

Chapter 19 对象池

使用固定的对象池重用对象，取代单独地分配和释放对象，达到提升性能和优化内存使用的目的。

使用情境：

1. 频繁创建销毁对象；
2. 对象大小基本一致；
3. 堆上分配内存较慢或可能产生内存碎片；

 

粒子类：

用union节省内存：粒子使用时用live结构体，不使用时用next指针

class Particle
{

public:
  Particle()
  : framesLeft_(0)
  {} 

  void init(double x, double y,
            double xVel, double yVel, int lifetime)
  {
    x_ = x; y_ = y;
    xVel_ = xVel; yVel_ = yVel;
    framesLeft_ = lifetime;
  } 

  bool animate()
  {
    if (!inUse()) return false;

    framesLeft_--;
    x_ += xVel_;
    y_ += yVel_;
 
    return framesLeft_ == 0;
}

  bool inUse() const { return framesLeft_ > 0; }

  Particle* getNext() const { return state_.next; }
  void setNext(Particle* next) { state_.next = next; }

private:
  int framesLeft_; 

  union
  {
    // State when it's in use.
    struct
    {
      double x, y;
      double xVel, yVel;
    } live;

    // State when it's available.
    Particle* next;

  } state_;

};

粒子对象池：

class ParticlePool
{

public:
  void create(double x, double y,
              double xVel, double yVel, int lifetime); 

  void animate()
  {
    for (int i = 0; i < POOL_SIZE; i++)
    {
      particles_[i].animate();
    }
  } 

private:
  static const int POOL_SIZE = 100;
  Particle particles_[POOL_SIZE];
 
  Particle* firstAvailable_;
};

ParticlePool::ParticlePool()
{
  // The first one is available.
  firstAvailable_ = &particles_[0];
 
  // Each particle points to the next.
  for (int i = 0; i < POOL_SIZE - 1; i++)
  {
    particles_[i].setNext(&particles_[i + 1]);
  }
 
  // The last one terminates the list.
  particles_[POOL_SIZE - 1].setNext(NULL);

}

构造函数中串起一个链表。

 

创建一个新粒子：

void ParticlePool::create(double x, double y,
                          double xVel, double yVel,
                          int lifetime)
{
  // Make sure the pool isn't full.
  assert(firstAvailable_ != NULL);
 
  // Remove it from the available list.
  Particle* newParticle = firstAvailable_;
  firstAvailable_ = newParticle->getNext();
 
  newParticle->init(x, y, xVel, yVel, lifetime);
}

动画放完放回粒子池：

void ParticlePool::animate()
{
  for (int i = 0; i < POOL_SIZE; i++)
  {
    if (particles_[i].animate())
    {
      // Add this particle to the front of the list.
      particles_[i].setNext(firstAvailable_);
      firstAvailable_ = &particles_[i];
    }
  }
}

1. 如果对象尺寸大小不一，可以考虑根据对象的尺寸划分大小不同的池，避免过多的内存浪费；
2. 向对象池请求失败：

（1）. 避免；

（2）. 不创建了（特效叠加时…）；

（3）. 清理现存对象（是否会卡）；

（4）. 增加对象池大小（适当时机再恢复原大小）

 

 

Chapter 20 空间分区

将对象存储在根据位置组织的数据结构中来高效地定位它们。 

你有一组对象（可能还挺多），将对象存储在一个根据对象位置来组织的数据结构中，该数据结构可以让你高效查询位于或靠近某处的对象。当对象位置改变时，更新并继续维护该空间数据对象。

用更复杂的数据结构（空间）来换取大量查询时的性能优化（时间）。

 

Unit类：

class Unit
{
  friend class Grid; 

public:
  Unit(Grid* grid, double x, double y)
  : grid_(grid),
    x_(x),
    y_(y)
  {} 

  void move(double x, double y);
 
private:
  double x_, y_;
  Grid* grid_; 

  Unit* prev_;
  Unit* next_;
};

Grid类：

class Grid
{

public:
  Grid()
  {
    // Clear the grid.
    for (int x = 0; x < NUM_CELLS; x++)
    {
      for (int y = 0; y < NUM_CELLS; y++)
      {
        cells_[x][y] = NULL;
      }
    }
  }
 
  static const int NUM_CELLS = 10;
  static const int CELL_SIZE = 20; 

private:
  Unit* cells_[NUM_CELLS][NUM_CELLS];

}; 

cells_是一个双重链表，记录了单元格内的unit链。

 

初始化：找到单位所在的单元格加到链表前面

Unit::Unit(Grid* grid, double x, double y)
  : grid_(grid),
    x_(x),
    y_(y),
    prev_(NULL),
    next_(NULL)
{
  grid_->add(this);
}

void Grid::add(Unit* unit)
{
  // Determine which grid cell it's in.
  int cellX = (int)(unit->x_ / Grid::CELL_SIZE);
  int cellY = (int)(unit->y_ / Grid::CELL_SIZE);

  // Add to the front of list for the cell it's in.
  unit->prev_ = NULL;
  unit->next_ = cells_[cellX][cellY];
  cells_[cellX][cellY] = unit;
 
  if (unit->next_ != NULL)
  {
    unit->next_->prev_ = unit;
  }
}

 

Unit移动：查看是否还在原先的单元格，如果离开了原先的单元格，从链表中移除再add

void Unit::move(double x, double y)
{
  grid_->move(this, x, y);
} 

void Grid::move(Unit* unit, double x, double y)
{
  // See which cell it was in.
  int oldCellX = (int)(unit->x_ / Grid::CELL_SIZE);
  int oldCellY = (int)(unit->y_ / Grid::CELL_SIZE); 

  // See which cell it's moving to.
  int cellX = (int)(x / Grid::CELL_SIZE);
  int cellY = (int)(y / Grid::CELL_SIZE);

  unit->x_ = x;
  unit->y_ = y;
 
  // If it didn't change cells, we're done.
  if (oldCellX == cellX && oldCellY == cellY) return; 

  // Unlink it from the list of its old cell.
  if (unit->prev_ != NULL)
  {
    unit->prev_->next_ = unit->next_;
  }
 
  if (unit->next_ != NULL)
  {
    unit->next_->prev_ = unit->prev_;
  } 

  // If it's the head of a list, remove it.
  if (cells_[oldCellX][oldCellY] == unit)
  {
    cells_[oldCellX][oldCellY] = unit->next_;
  } 

  // Add it back to the grid at its new cell.
  add(unit);

}

 

战斗：查找单元格相邻一半的单元格（4个）

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 != NULL)
  {
    // Handle other units in this cell.
    handleUnit(unit, unit->next_); 

    // Also try the neighboring cells.
    if (x > 0 && y > 0) handleUnit(unit, cells_[x - 1][y - 1]);
    if (x > 0) handleUnit(unit, cells_[x - 1][y]);
    if (y > 0) handleUnit(unit, cells_[x][y - 1]);
    if (x > 0 && y < NUM_CELLS - 1)
    {
      handleUnit(unit, cells_[x - 1][y + 1]);
    } 

    unit = unit->next_;
  }
}

void Grid::handleUnit(Unit* unit, Unit* other)
{
  while (other != NULL)
  {
    if (distance(unit, other) < ATTACK_DISTANCE)
    {
      handleAttack(unit, other);
    } 

    other = other->next_;
  }
}

 

四叉树：

如果空间中的对象超过阈值，空间就一切四

1. 添加单个对象不会产生一次以上的拆分动作
2. 删除对象需要判断父区域对象总数，如果低于阈值则合并区域
3. 移动对象等于一次删除和一次添加