Junios World

class ICommand //각 명령들의 인터페이스 클래스
{
public:
virtual void Execute() = 0;
};
//전방 참조
class cCommand_Attack;
class cCommand_Move;
class cCommand_Stop;
class cCommand_HoldPosition;
class cCommand_Patrol;

class IUnit
{
IState * _pState; //state패턴 강좌에서 cZealot클래스에 있었던
//변수를 여기로 옮겨옴
public:
//Shift가 눌렸을 때 이 함수가 호출되겠죠.
virtual void ChangeToPlanMode( IUnit *& pPtrUnit )
{
//cPlanDecorator를 붙인다.
new cPlanDecorator( pPtrUnit );
}
//Shift가 떼어졌을 때 이 함수가 호출
virtual void ChangeToNormalMode()
{}

//상태에 대한 ID를 리턴하는 함수( state패턴 강좌에서 IState클래스가
// 수정 되었습니다)
ID_STATE GetStateID()
{
return _pState->GetID();
}
//나머지는 지난번 강좌의 IUnit클래스와 같음
....
....
};

//cUnitDecorator는 지난번 강좌(Decorator)에서 나왔던 그 놈임.
class cPlanDecorator : public cUnitDecorator
{
IUnit * _pActor;
queue< ICommand * > * _pCommandQ; //STL의 queue를 사용
bool _IsInputMode; //명령의 입력 모드인가?(true)
//아니면 실행 모드인가?(false)
public:
cPlanDecorator( IUnit *& pActor )
: cUnitDecorator( pActor ), _pActor( pActor ), _IsInputMode(true)
{}

void ChangeToPlanMode( IUnit *& pPtrUnit )
{
_IsInputMode = true; 
}
void ChangeToNormalMode()
{
_IsInputMode = false;
} 
void ClearPlan()
{
_pCommandQ->clear();
}
void Attack( IUnit * Target ) 
{ 
//Shift를 누른 상태로 공격 명령을 내리면 명령 추가
if( _IsInputMode )
_pCommandQ->push( new cCommand_Attack( Target ) );
//Shift를 뗀 상태로 공격 명령을 내리면 큐의 모든 명령이 취소되
//고, 공격 명령을 바로 실행.
else 
{
_pActor->Attack( Target );
SelfDestroy(); 
} 
}
void Move( int x, int y ) 
{
//Attack과 마찬가지..
if( _IsInputMode )
_pCommandQ->push( new cCommand_Move( x, y ) );
else
{
_pActor->Move( x, y );
SelfDestroy();
}
}
void Stop()
{
//Stop명령은 큐에 집어넣을 수 없음.
if( !_IsInputMode )
{
_pActor->Stop();
SelfDestory();
}
}
//HoldPosition, Patrol등은 귀찮으니 생략함..
//일꾼 같으면 Build명령이 있을테고, 마법유닛은 Special명령이 있겠지만
//이것도 모두 위의 Attack이나 Move처럼 처리하면 됩니다.



void Update()
{
//Stop, HoldPosition, Patrol등 무한히 지속되는 명령들이 아닌
//나머지 명령들은 명령수행을 마쳤을 때 Stop상태로 바뀌므로
//Stop상태가 되었을 때 다음 명령을 실행.
if( _pActor->GetStateID() == IState::STATE_STOP )
{
if( !_pCommandQ->empty() )
{
ICommand * pCommand = _pCommandQ->front();
pCommand->Execute();
delete pCommand;
}
else
{
SelfDestroy();
}
}

_pActor->Update();
}
};

class cCommand_Attack : public ICommand
{
IUnit * _pActor;
IUnit * _pTarget;
public:
//주의!! 여기서는 편의상 생성자의 선언과 정의를 한꺼번 
//에 해서 인라인이 되어 버렸지만 생성자를 인라인으로 만 
//드는 것은 좋지 않습니다.자세한건 Effective C++참조
cCommand_Attack( IUnit * pActor, IUnit * pTarget )
: _pActor( pActor ), _pTarget( pTarget )
{
}
void Execute()
{
_pActor->Attack( _pTarget );
}
};

class cCommand_Move : public ICommand
{
IUnit * _pActor;
int _DestX, _DestY;
public:
cCommand_Move( IUnit * pActor, int x, int y )
: _pActor( pActor ), _DestX( x ), _DestY( y )
{ }
void Execute()
{
_pActor->Move( _DestX, _DestY );
}
};

//이런 식으로 사용하게 되겠죠.
void OnKeyDown( int KeyCode )
{
if( KeyCode == SHIFT )
{
IUnit &* pSelectedUnit = GetSelectedUnit();
pSelectedUnit->ChangeToPlanMode( pSeletecdUnit );
}
}

void OnKeyUp( int KeyCode )
{
if( KeyCode == SHIFT )
{
IUnit &* pSelectedUnit = GetSelectedUnit();
pSelectedUnit->ChangeToNormalMode();
}
}

class IUnit
{
public:
//데코레이터에서 사용하는 포인터
IUnit * _pNext;
IUnit() : _pNext( NULL ) {}
virtual ~IUnit() {}

virtual void Attack() = 0;
virtual void Move() = 0;
virtual void Damage(int) = 0; //공격 당했을 때 에너지 
//를 닳게함
virtual void Update() = 0;
virtual void Draw() = 0;
virtual void GetState() = 0;
};

class cTank : public IUnit
{
public:
void Attack();
void Move();
void Damage();

void Update();
void Draw();

void GetState();
};

//클래스가 스스로를 소멸시키지 못하므로 소멸을 대행해서 일괄적으로 처 
//분 하는 클래스
class cGarbages
{
//쓰레기들의 저장공간
vector< void * > _pContainer; //STL의 vector클래스
public:
cGarbages & GetInstance(); //싱글턴

void Add( void * ); //쓰레기 추가
void Disposal(); //쓰레기 모두 처분(전부 delete)
};

class cUnitDecorator : public IUnit
{
//(클라이언트 코드에서의 유닛에 대한 포인터)의 포인터
//데코레이터 리스트에서의 Head라고 할 수 있다.
IUnit ** _pPtr;
public:
cUnitDecorator( IUnit *& pNext )
: _pPtr( &pNext )
{
_pNext = pNext;
*_pPtr = this;
}

//디폴트 구현을 제공함.
virtual void Attack() { _pNext->Attack(); }
virtual void Move() { _pNext->Move(); }
virtual void Damage(int dmg) { _pNext->Damage(dmg); }
virtual void Update() { _pNext->Update(); }
virtual void Draw() { _pNext->Draw(); }

//상태 정보 리턴. sState는 유닛의 상태정보를 담는 구조체
virtual sState GetState() { return _pNext->GetState(); }

//스스로 데코레이터들의 리스트에서 삭제한다.
void SelfDestroy()
{
if( *_pPtr == this )
*_pPtr = _pNext; 
else
{
//리스트에서 이것의 앞에 있는 데코레이터를 찾는다.
IUnit * pUnit = *_pPtr; 
while( pUnit->_pNext != this )
{
pUnit = pUnit->_pNext;
}
pUnit->_pNext = _pNext;
} 

cGarbages::GetInstance().Add( this ); //소멸
}
};

class cLockDown : public cUnitDecorator
{
int _Duration; //지속시간
LPDIRECTDRAWSURFACE _pSurface; //락다운의 그림을 저장하는 서피스
public:
cLockDown( cUnit * pNext )
: cUnitDecorator( pNext )
{}
void Attack() {} //락다운에 당하면 아무 일도 할 수 없죠. 
void Move() {} //그래서 명령을 내려도 아무일도 하지 않음 
void Draw()
{
_pNext->Draw(); //원래의 탱크를 화면에 출력한 다음
_pSurface->BltFast(); //그 위에 락다운의 그림을 출력한다.
}
void Update() 
{ 
_Duration--;
//지속시간이 지나면 자동 소멸
if( _Duration <= 0 )
SelfDestroy();

_pNext->Update();
} 
};

//Defensive Matrix
class cDMatrix : public cUnitDecorator
{
int _Energy; //디펜시브 매트릭스의 에너지
int _Duration; //지속시간
public:
void Damage(int dmg)
{
//데미지가 디펜시브 매트릭스에 가해진다.
_Energy -= dmg;
//에너지가 0이 되면 파괴
if( _Energy <= 0 )
{
SelfDestroy(); //소멸
}
//디펜시브 매트릭스가 있는 동안은 유닛에가 데미지가 
//가지 않기 때문에 유닛의 Damage함수는 호출하지 않는
//다.
}
void Draw()
{
_pNext->Draw(); //원래의 탱크를 화면에 출력한 다음
_pSurface->BltFast(); //그 위에 디펜시브매트릭스 그림을 출력
}
void Update()
{
_Duration--;
//지속시간이 지나면 자동 소멸
if( _Duration <= 0 )
SelfDestroy();

_pNext->Update();
}
};

class cRenderState : public cUnitDecorator //상태창에 유닛 상태 출력
{
public:
cRenderState( IUnit * pUnit );
void Draw()
{
//상태를 얻어온 다음에..
sState TankState = _pNext->GetState();
//...탱크의 상태를 하단의 상태창에 출력...
}
};

//클라이언트 코드( 대충 이런 식으로 사용하게 되겠죠 )
class cGameManager 
{
IUnit * pTank;
public:
void OnClickLockDown() 
{
....
//이제 탱크가 락다운에 걸렸습니다. 
_pTank = new cLockDown( _pTank );
}
void OnClickDMatrix()
{
....
//디펜시브 매트릭스 명령이 내려지자 탱크가 마법에 걸립니다.
_pTank = new cDMatrix( _pTank );
}
void OnClickUnit( IUnit * pUnit )
{
//이제 이 탱크를 플레이어가 선택 했습니다.
pTank = new cRenderState( pTank );
}
void Update()
{
...
//이렇게 해서 탱크를 화면에 출력할 것입니다.
_pTank->Draw();
_pTank->Update();
//매 틱마다 쓰레기들을 처분합니다.
//이것땜에 속도가 저하되는게 싫으시다면 뭐~ 10틱이나 20틱, 또는
1초에
//한번씩 처분하도록 해도 되겠죠~
cGarbages::GetInstance().Disposal();
}
};

//Psynoic Storm같은 경우는 특정 유닛에게 거는 마법이 아니기 때문에 데
//코레이터를 쓰지 말고 독립된 객체로 처리해야 하겠군요.

//---------------------------------------------------------
class IState; //클래스 전방선언

class cZealot : public cUnit //cUnit은 지난 강좌에서
{ //나왔던 그거...
IState * _pState;
void ChangeState( IState * );
public:
cZealot();
~cZealot();

//이 명령들이 전달되면 유닛은 상태를 바꾸게 됩니다.
void Attack( cUnit * Target );
void Move( int x, int y ); 
void Stop();
void HoldPosition();
void Patrol( int, int, int, int );
void Update();
};
//----------------------------------------------------------
class IState {
public:
enum ID_STATE
{
STATE_ATTACK,
STATE_MOVE,
STATE_STOP,
STATE_HOLDPOSITION,
STATE_PATROL
};
private:
const ID_STATE _ID;
public:
IState( ID_STATE state ): _ID( state )
{}

ID_STATE GetID()
{
return _ID;
}
//상태에 대한 행동하는 함수.
virtual void Operate() = 0;
};

//Attack 상태. 공격 대상(target)과 행동의 주체(pUnit)을 인
//자로 받고 멤버 변수에 저장해놓습니다. 그리고 Operate함수
//에서 멤버변수에 들어간 인자값을 참조하면서 행동을 수행합니
//다.
class cState_Attack : public IState {
cUnit * _pTarget;
cUnit * _pUnit;
public:
//Attack이 끝나면 Stop상태로 바꿔야 하기 때문에 cUnit의 
//포인터를 받음
cState_Attack( cUnit * target, cUnit * pUnit )
:IState( STATE_ATTACK ), _pTarget( target ), _pUnit( pUnit )
{}
void Operate(); //각각의 상태에 대한 행동을 
//구현함
};

class cState_Move : public IState {
int _x, _y;
cUnit * _pUnit;
public:
cState_Move( int x, int y, cUnit * pUnit );
void Operate();
};

class cState_Stop : public IState {
public:
void Operate();
};

class cState_HoldPosition : public IState {
public:
void Operate();
};

class cState_Patrol : public IState {
int _x1, _y1, _x2, _y1;
public:
cState_Patrol( int x, int y, int x2, int y2 );
void Operate();
};
//---------------------------------------------------------
cZealot::cZealot()
{
//상태 객체에 넘겨줄 인자가 모두 동일하다면 new, delete 
//보다는 싱글턴을 쓰는 것이 좋을 것입니다.
_pState = new cState_Stop;
}
cZealot::~cZealot()
{
delete _pState;
}
void cZealot::ChangeState( IState * pState )
{
//상태 전이에 대한 특별한 처리가 필요하다면 여기에 코딩 
//하면 됩니다.
delete _pState;
_pState = pState;
}
void cZealot::Attack( cUnit * Target )
{
ChangeState( new cState_Attack( Target, this ) );
}
void cZealot::Move(int x, int y )
{
ChangeState( new cState_Move( x, y, this ) );
}
void cZealot::Stop()
{
ChangeState( new cState_Stop );
}
void cZealot::HoldPosition()
{
ChangeState( new cState_HoldPosition );
}
void cZealot::Patrol( int x1, int y1, int x2, int y2 )
{
ChangeState( new cState_Patrol( x1, y1, x2, y2 ) );
}
void cZealot::Update()
{
//여기서 행동이 일어나게 됩니다.
_pState->Operate();
}
//---------------------------------------------------------

class cUnit
{
public:
virtual void Attack() = 0; //반드시 재정의 해야함
virtual void Move() = 0;
virtual void Stop() = 0;
virtual void HoldPosition() = 0;
virtual void Special1() {} //재정의 안해도 됨
virtual void Special2() {} 
};

class cZealot : public cUnit
{
public:
void Attack(); 
void Move();
void Stop();
void HoldPosition();
};

virtual cUnit * Create1stUnit() = 0;

class cHiTemplar : public cUnit
{
public:
void Attack();
void Move();
void Stop();
void HoldPosition();
void Special1();
void Special2(); //하이템플러는 마법이 세개였나?
//귀찮아서 두개만...
};

cZealot zealot;
cHiTemplar templar;

cUnit * Unit1 = &zealot;
Unit1->Attack(); //zealot.Attack()와 같은 결과

Unit1 = &templar;
Unit1->Attack(); //templar.Attack()와 같은 결과

class cPrimaryFactory //1차 생산건물에 대한
{ //인터페이스 클래스
public:
virtual cUnit * CreateUnit1() = 0;
virtual cUnit * CreateUnit2() = 0;
virtual cUnit * CreateUnit3() = 0;
virtual cUnit * CreateUnit4() = 0;

//베이스 클래스의 소멸자는 virtual이어야 합니다. 
//Effective C++참조.
virtual ~cPrimaryFactory(); 
};

class cBarrack : public cPrimaryFactory
{
public:
cUnit * CreateUnit1() { return new cMarine; }
cUnit * CreateUnit2(); { return new cFirebat; }
cUnit * CreateUnit3(); { return new cGhost; }
cUnit * CreateUnit3(); { return new cMedic; }
};

class cGateway : public cPrimaryFactory
{
public:
cUnit * CreateUnit1(); //질럿 생산
cUnit * CreateUnit2(); //드래군
cUnit * CreateUnit3(); //하이템플러
cUnit * CreateUnit4(); //다크템플러
};

class cHatchery : public cPrimaryFactory
{
public:
cUnit * CreateUnit1(); //저글링
cUnit * CreateUnit2(); //히드라
cUnit * CreateUnit3(); //???
cUnit * CreateUnit4(); //???
};

cPrimaryFactory * Factory1st = UI.GetUserFactory1();
//유저가 현재 선택한 종족의 
//첫번째 생산 공장에 대한 포
//인터를 얻어옵니다.

//첫번째 유닛 생산 명령이 떨어졌을 경우
Factory1st->CreateUnit1(); 
//세번째 유닛 생산 명령이 떨어졌을 경우 
Factory1st->CreateUnit3();

void HandleCommand( int CommandID )
{
switch( CommandID )
{
case 1: 
case 2: 
case 3:

default:
}
}

void Command1() { //구현.... }
void Command2() { }
void Command3() { }

typedef void (*CommandFunc)();
CommandFunc Commands[3] = { Command1, Command2, Command3 };

void HandleCommand( int CommandID )
{
Commands[ CommandID ]();
}

class iCommand
{
public:
virtual void Operate() = 0;
};

class cCommand1 : public iCommand
{
public:
void Operate() {}
};

class cCommand2 : public iCommand
{
public:
void Operate() {}
};

class cCommand3 : public iCommand
{
public:
void Operate() {}
};

cCommand1 com1;
cCommand2 com2;
cCommand3 com3;
iCommand * Commands[3] = { &com1, &com2, &com3 };

void HandleCommand( int CommandID )
{
Commands[ CommandID ]->Operate();
}