[Design Pattern] 게임 행동 : 바이트 코드, 하위 클래스 샌드박스, 타입 객체

void setHealth(int wizard, int amount)`
void setWisdom(int wizard, int amount)`
void setAgility(int wizard, int amount)`
int getHealth(int wizard)`
int getWisdom(int wizard)`
int getAgility(int wizard)`
void playSound(int soundId)`
void spawnParticles(int particleType)`

enum Instruction
{
  INST_SET_HEALTH      = 0x00,
  INST_SET_WISDOM      = 0x01,
  INST_SET_AGILITY     = 0x02,
  INST_GET_HEALTH      = 0x03,
  INST_GET_WISDOM      = 0x04,
  INST_GET_AGILITY     = 0x05,
  INST_PLAY_SOUND      = 0x06,
  INST_SPAWN_PARTICLES = 0x07
};

class VM
{
private:
  // 스택으로 명령어 실행 순서를 제어한다. 
  // 스택 크기를 조절해서 VM의 메모리 사용량을 조절할 수 있다. 
  static const int MAX_STACK = 128;
  int stackSize;
  int stack[MAX_STACK];
  
  void push(int value)
  {
    assert(stackSize < MAX_STACK);
    stack[stackSize++] = value;
  }
  
  int pop()
  {
    assert(stackSize > 0);
    return stack[--stackSize];
  }

public:
  VM() : stackSize(0) {}
  
  // VM은 바이트 코드를 읽어서 해당하는 명령에 따라 모두 실행한다. 
  void interpret(char bytecode[], int size)
  {
    for (int i = 0; i < size; i++)
    {
      char instruction = bytecode[i];
      
      switch(instruction)
      {
        case INST_SET_HEALTH:
        {
          // 명령어가 매개변수를 받을 때는 다음과 같이 스택에서 꺼내온다. 
          int amount = pop();
          int wizart = pop();
          setHealth(wizard, amount);
        } 
        break; 
        
        case INST_GET_HEALTH:
        {
          int wizart = pop();
          push(getHealth(wizard));
        }
        break;
        
        // ....
      }
  }
};

// 바이트 코드에서 리터럴 명령어가 나오면, 
case INST_LITERAL:
{
  // 바이트 코드에서 다음 값을 읽어서 스택에 넣는다. 
  int value = bytecode[++i];
  push(value);
}
break;

setHealth(0, getHealth(0) + (getAgility(0) + getWisdom(0)) / 2);

case INST_ADD:
{
  int b = pop();
  int a = pop();
  push(a + b);
}
break;

class Superpower
{
public:
  virtual ~Superpower();

protected:
  // 샌드박스 메서드 
  virtual void activate() = 0;
  
  // 하위 클래스에서 공통으로 사용되는 코드들
  void move(double x, double y, double z);
  void playSound(SoundId sound, double volume);
  void spwanParticles(ParticleType type, int count);
};

class SkyLaunch : public Superpower
{
protected:
  // 하위 클래스에서 샌드박스 메서드를 구현한다. 
  virtual void activate()
  {
    playSound(SOUND_SPROING, 1.0f);
    spawnParticles(PARTICLE_DUST, 10);
    move(0, 0, 20);
  }
};

// 타입 객체 
// 같은 종족이 가지는 공통적인 데이터나 동작을 저장하고 있다. 
class Breed
{
private:
  int health; // 초기 체력
  const char* attack;
  
public:
  Breed(int h, const char* a) : health(h), attack(a) {}
  
  int getHealth() { return health; }
  const char* getAttack() { return attack; }
};

// 타입 사용 객체 
// 각각의 몬스터는 
class Monster
{
private:
  Breed& breed; // 타입 객체를 참조한다. 
  int health;   // 현재 체력

public:
  Monster(Breed& b) : breed(b), health(b.getHealth()) {}
  
  const char* getAttack() { return breed.getAttack(); }
};

// 위의 코드에서는 이렇게 몬스터를 생성하지만 
Monster* m = new Monster(someBreed);

// 아래 코드에서는 이렇게 생성할 수 있다. 
Monster* m = someBreed.newMonster();

class Breed
{
public:
  // 팩토리 메서드. 여기서 객체를 생성한다. 
  // 이렇게 하면 Monster 클래스가 초기화되기 전에, 
  // 여기에서 다양한 메모리 관리 기법(메모리 풀 등)을 사용해볼 수 있겠다. 
  Monster* newMonster() 
  { 
    return new Monster(*this); 
  }
  
  // ...
};

class Monster
{
  friend class Breed;

private:
  Breed& breed; 
  int health;
  Monster(Breed& b) : breed(b), health(b.getHealth()) {}

public:
  const char* getAttack() { return breed.getAttack(); }
}

class Breed
{
private:
  Breed* parent; // 상속받을 종족 객체 
  int health;
  const char* attack;
  
public:
  Breed(Breed* p, int h, const char* a) : parent(p), health(h), attack(a) {}
  
  int getHealth()
  {
    // 오버라이딩
    if (health != 0 || parent == NULL) return health;
    
    // 상속
    return parent->getHealth();
  }
  
  // ...
};

class Breed
{
private:
  int health;
  const char* attack;
  
public:
  Breed(Breed* p, int h, const char* a) : parent(p), health(h), attack(a)
  {
    // 생성자에서 상위 속성을 전부 복사한다. 
    if (parent != NULL)
    {
      if (health == 0) health = parent->getHealth();
      if (attack == NULL) attack = parent->getAttack();
    }
  }
  
  int getHealth() { return health; }
  const char* getAttack() { return attack; }
};