2014. 1. 12. 07:26
게임개발공부/디자인패턴

구조패턴 <Command 패턴> (명령)

Command (커맨드) 패턴 -----------------------------------------------------------------------------------------------

  커맨드 패턴이란 말그대로 명령을 내리는 패턴을 의미합니다.

  하지만 하나의 명령을 내리면 그 명령은 일반적으로 다양한 클래스에 관여될수 있습니다.

  그런경우 우리는 일반적으로 조건문과 분기문을 사용하여 처리합니다.

  하지만 지속적으로 명령에 대한 분기가 늘어난다면 늘어난다면?

  계속 코드를 수정하게 되는 경우가 많습니다.

  커맨드 패턴이란 그런경우 클라이언트를 수정하기 보다는 클래스를 분화시켜 매소드를 간략화 시키는 것이 장기적인 안목으로 더 효율적인때 사용하는 패턴입니다.

 

패턴적용 스토리 -----------------------------------------------------------------------------------------------

  이번에 적용되는 스토리는 다음과 같습니다.

  게임을 만들다보면 키의 입력에 의해서 다양한 분기가 생깁니다.

  i키를 누르면 인벤을 열고

  s키를 누르면 스킬을 쓰고.

  a를 누르면 공격을 합니다.

  이러한 키를 손쉽게 관리하고 그리고 그 명령으로 인한 수없이 많이 생길수 있는 요청들을 처리하기 위한 구조를 잡는데 커맨드 패턴은 매우 유용하게 사용될 수 있습니다.

 

uml -----------------------------------------------------------------------------------------------

  

 

 

 

 

  코드를 보면 커맨드 클래스의 하위클래스들은 자신을 통해서 명령을 실제 실행할 객체들을 포함합니다.

  커맨드 객체들은 요청에 따라서 map으로 관리되고 커맨드의 입력에 따라서 플라이웨이트 패턴의 맵에서 꺼내어져 다른 객체를 호출하게 됩니다.

   

 

코드 -----------------------------------------------------------------------------------------------

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
#include "include.h"
 
///////// KEY
 
class KeyManager
{
private:
    map<string, string>     m_mapKey;
 
private:
    KeyManager() 
    {
        KeySetting();
    }
 
public:
    ~KeyManager() {}
 
private:
    static KeyManager* m_Inst;
 
public:
    static KeyManager* GetInst(void) 
    {
        if(m_Inst == NULL)
        { m_Inst = new KeyManager; }
        return m_Inst;
    }
 
    static void Destroyinst(void)
    {
        SAFE_DELETE(m_Inst);
    }
 
public:
    void KeySetting(void)
    {
        m_mapKey["i"] = "inven";
        m_mapKey["a"] = "attack";
        m_mapKey["s"] = "skill";
    }
 
    const string& GetKeyValue(const string& _Str)
    {
        return m_mapKey[_Str];
    }
};
 
KeyManager* KeyManager::m_Inst = NULL;
 
///////// CPlayerPorgress
 
class CPlayerPorgress
{
public:
    virtual void Progress() = 0;
};
 
class CInven : public CPlayerPorgress
{
public:
    virtual void Progress()
    {
        cout << "인벤을 엽니다." << endl;
        cout << "인벤에서 쿵착쿵착." << endl;
    }
};
 
class CAttact : public CPlayerPorgress
{
public:
    virtual void Progress()
    {
        cout << "공격 명령" << endl;
        cout << "공격공격!" << endl;
    }
};
 
class CSkill : public CPlayerPorgress
{
public:
    virtual void Progress()
    {
        cout << "스킬을 사용합니다" << endl;
        cout << "파이어볼" << endl;
    }
};
 
///////// PlayerPorgressManager
 
class PlayerPorgressManager
{
private:
    map<string, CPlayerPorgress*>     m_mapProgress;
 
private:
    PlayerPorgressManager(void) 
    {  
        m_mapProgress["i"] = new CAttact();
        m_mapProgress["a"] = new CInven();
        m_mapProgress["s"] = new CSkill();
    }
 
public:
    ~PlayerPorgressManager(void) { SAFE_DELETE_MAP(m_mapProgress); }
 
private:
    static PlayerPorgressManager* m_Inst;
 
public:
    static PlayerPorgressManager* GetInst(void) 
    {
        if(m_Inst == NULL)
        { m_Inst = new PlayerPorgressManager; }
        return m_Inst;
    }
 
    static void Destroyinst(void)
    {
        SAFE_DELETE(m_Inst);
    }
 
public:
    CPlayerPorgress* GetProgress(const string& _Str)
    { return m_mapProgress[_Str]; }
};
 
PlayerPorgressManager* PlayerPorgressManager::m_Inst = NULL;
 
///////// CCommand
 
class CCommand
{
public:
    virtual void CommandProgress() = 0;
};
 
class CInvenCCommand : public CCommand
{
private:
    CInven* m_Pinven;
 
public:
    CInvenCCommand() 
    {
        m_Pinven = static_cast<CInven*>(PlayerPorgressManager::GetInst()->GetProgress("i"));
    }
 
public:
    ~CInvenCCommand() { }
 
public:
    virtual void CommandProgress()
    {
        if(m_Pinven)
        { m_Pinven->Progress(); }
    }
};
 
class CAttackCCommand : public CCommand
{
private:
    CAttact* m_Attack;
 
public:
    CAttackCCommand() 
    {
        m_Attack = static_cast<CAttact*>(PlayerPorgressManager::GetInst()->GetProgress("a"));
    }
 
public:
    ~CAttackCCommand() { }
 
public:
    virtual void CommandProgress()
    {
        if(m_Attack)
        { m_Attack->Progress(); }
    }
};
 
class CSkillCCommand : public CCommand
{
private:
    CSkill* m_Skill;
 
public:
    CSkillCCommand () 
    {
        m_Skill = static_cast<CSkill*>(PlayerPorgressManager::GetInst()->GetProgress("s"));
    }
 
public:
    ~CSkillCCommand () { }
 
public:
    virtual void CommandProgress()
    {
        if(m_Skill)
        { m_Skill->Progress(); }
    }
};
 
class CCommandManager
{
private:
    map<string, CCommand*>     m_mapCommand;
 
private:
    CCommandManager() 
    {
        m_mapCommand["i"] = new CAttackCCommand();
        m_mapCommand["a"] = new CInvenCCommand();
        m_mapCommand["s"] = new CSkillCCommand();
    }
 
public:
    ~CCommandManager() { SAFE_DELETE_MAP(m_mapCommand); }
 
private:
    static CCommandManager* m_Inst;
 
public:
    static CCommandManager* GetInst(void) 
    {
        if(m_Inst == NULL)
        { m_Inst = new CCommandManager; }
        return m_Inst;
    }
 
    static void Destroyinst(void)
    {
        SAFE_DELETE(m_Inst);
    }
 
public:
    CCommand* GetComment(const string& _Str)
    {
        if(m_mapCommand[_Str])
        { return m_mapCommand[_Str]; }
 
        return NULL;
    }
};
 
CCommandManager* CCommandManager::m_Inst = NULL;
 
// Command.cpp : 콘솔 응용 프로그램에 대한 진입점을 정의합니다.
//
 
#include "stdafx.h"
#include "command.h"
 
#include <crtdbg.h>
 
int _tmain(int argc, _TCHAR* argv[])
{
#if defined(DEBUG) | defined(_DEBUG)
    _CrtSetDbgFlag( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
    //_CrtSetBreakAlloc(215);
#endif
 
    KeyManager::GetInst();
    PlayerPorgressManager::GetInst();
    CCommandManager::GetInst();
 
    bool Progresscheck = true;
    CCommand* pCommand;
    string input;
 
    while(Progresscheck)
    {
        cin >> input;
 
        pCommand = CCommandManager::GetInst()->GetComment(input);
 
        if(pCommand == NULL)
        { break; }
 
        pCommand->CommandProgress();
    }
 
 
    KeyManager::Destroyinst();
    PlayerPorgressManager::Destroyinst();
    CCommandManager::Destroyinst();
 
    return 0;
}

 

결과 ----------------------------------------------------------------------------------------------- 

 

저작자표시 비영리 변경금지

'게임개발공부 > 디자인패턴' 카테고리의 다른 글

구조패턴 <Chain of Responsibility 패턴> (책임 연쇄)  (0) 2014.01.09
구조패턴 <프록시 패턴> (대리자)  (0) 2014.01.05
구조패턴 <플라이웨이트 패턴> (가벼운 체급)  (0) 2014.01.02
구조패턴 <퍼사드 패턴> (표면, 정면)  (0) 2013.12.28
구조패턴 <데코레이터 패턴> (표면)  (0) 2013.12.28
Posted by JJOREG

티스토리툴바