[Design Pattern] 게임 순서 : 이중 버퍼, 게임 루프, 업데이트 메서드

class Framebuffer
{
private:
  static const int WIDTH = 160;
  static const int HEIGHT = 120;
  char pixels[WIDTH * HEIGHT];

public:
  Framebuffer() { clear(); }
  
  void clear()
  {
    for (int i = 0; i < WIDTH * HEIGHT; i++)
      pixel[i] = WHITE;
  }
  
  void draw(int x, int y)
  {
    pixel[(WIDTH * y) + x] = BLACK;
  }
  
  const char* getPixels() { return pixels; }
};

class Scene
{
private:
  Framebuffer buffers[2];
  Framebuffer* cur;
  Framebuffer* next;
  
  void swap()
  {
    Framebuffer* temp = cur;
    cur = next;
    next = temp;
  }
  
public:
  Scene() : cur(&buffers[0]), next(&buffers[1]) {}

  void draw()
  {
    // 그린다. 
    next->clear();
    next->draw(1, 1);
    next->draw(1, 3);
    next->draw(1, 4);
    
    // 프레임 버퍼를 교체해서 한 번에 출력한다. 
    swap();
  }
  
  Framebuffer& getBuffer() { return buffer; }
};

while (true)
{
  processInput(); // 유저 입력을 처리한다.
  update();       // 게임 상태를 업데이트한다. 
  render();       // 게임 화면을 렌더링한다. 
}

while (true)
{
  processInput();
  update();
  render();
}

double lastTime = getCurrentTime();
while (true)
{
  double current = getCurrentTime();
  double elapsed = current - lastTime;
  
  processInput();
  // 이전 프레임 ~ 현재 프레임 사이에 흐른 시간을 고려해서 그 만큼 업데이트한다. 
  update(elapsed);
  render();
  
  lastTime = current;
}

double previous = getCurrentTime();
double lag = 0.0;
while (true)
{
  double current = getCurrentTime();
  double elapsed = current - preious;
  previous = current;
  lag += elapsed; // 실제 시간에 비해 게임 시간이 얼마나 뒤쳐졌는지를 나타낸다. 
  
  processInput();
  // MS_PER_UPDATE이라는 고정 시간을 기준으로 뒤쳐진만큼 업데이트를 한다. 
  // MS_PER_UPDATE이 짧을 수록 많이 업데이트 하고, 실제 시간을 따라잡는 데 오래걸리겠다.
  while (lag >= MS_PER_UPDATE) 
  {
    update();
    lag -= MS_PER_UPDATE;
  }
  render();
}

// lag를 MS_PER_UPDATE로 나눠서 정규화한다. 
// 그러면 0~1사이의 값이 나온다. 
render(lag / MS_PER_UPDATE);

class Entity
{
private:
  double x, y;

public:
  Entity() : x(0), y(0) {}
  virtual ~Entity() {}
  
  // update()를 각 개체가 구현한다. 
  virtual void update() = 0;
};

class Skeleton : public Entity
{
private:
  bool patrollingLeft;

public:
  Skeleton() : patrollingLeft(false) {}
  
  virtual void update()
  {
    // 해골병사는 좌우로 패트롤한다.
    if (patrollingLeft)
    {
      x--;
      if (x == 0) patrollingLeft = false;
    }
    else
    {
      x++;
      if (x == 100) patrollingLeft = true;
    }
  }
};

class Statue : public Entity
{
private:
  // 각 개체가 자신의 동작을 캡슐화함으로써
  // 타이머를 각자 관리할 수 있게 되었다. 
  int frames;
  int delay;

public:
  Statue(int d) : frames(0), delay(d) {}
  
  virtual void update()
  {
    // 석상은 delay 간격으로 번개를 쏜다. 
    if (++frames == delay)
    {
      shootLightning();
      frames = 0;
    }
  }
};

class World
{
private:
  Entity* entities[MAX_ENTITIES];
  int numEntities;

public:
  World() : numEntities(0) {}
  
  void gameLoop()
  {
    while (true)
    {
      // ...입력 처리
      
      // 이렇게 간단하게 update()만 호출하면 된다! 야호!
      for (int i = 0; i < numEntities; i++)
        entities[i]->update();
        
      // ...물리, 렌더링 처리 
    }
  }
};