์ด์ฐจํผ ๋ฅ๋ ฅ์๋ ๊ธฐํ์๋ ํ์์ ๋ชป๊ตฌํ๋ , ๊ธฐ์ ์ด ์๊ฑด, ์๊ธฐ ๊ธฐํ์ ๊ตฌํํ์ง ๋ชปํ๋๊ฑด ๋น์ฐํ๊ฑฐ๊ณ .
๋ค๋ฅธ ์ฌ๋ ํ์ ์์๋ฆฌ ํ๋ฉด์ ์ฐธ๊ฒฌํดย ์ป์ ์ ์๋๊ฒ ๋ญ๊ฐ ์์๊น?
์ ๊น ๋๋ณด๋ค ๋ชป๋ ํ, ์ ๋ ๊ฑฐ ๊ฐ์ ํ ์ฐธ๊ฒฌํ๋ฉด์, ์ ์๋์์ ์์์ ์ป์์ ์์ง๋ง,
๊ฒฐ์ ์ ์ผ๋ก ์ง๊ธ ์๊ธฐ๊ฐ ๊ฐ๋ฐํ๊ณ ์๋ ํ๋ก์ ํธ๋ ๋ฉ์ถฐ์๋ ์ํ์ธ๊ฑฐ๋ค.
๊ฒฐ๋ก ์ ๊ฐ๋ฐ์ด๋ ํ์!
๊ทธ๋ฌ๋ ๊น์ ๋๋ ๊ฐ๋ฐ๊ธ ์ค๋ฌ๋ง์ ํ๋ ์ฐ๊ณ ๊ฐ์ผ ๊ฒ ๋ค.
์ฃผ์ ๋ Data Driven Architecture ๋ค.
(Data Oriented Programming ์๋!)
๊ฒ์์ ๊ตฌ์ฑํ๋ ์์๋ฅผ ํฌ๊ฒ ๋๋๋ฉด
๋ฐ์ดํฐ์, ๋ก์ง์ด ์๋ค.
๋ก์ง์ ๊ฐ์ฒด๊ฐ ๋ฌด์์ ํด์ผํ๋์ง๋ฅผ ๋ํ๋ด๊ณ ,
๋ฐ์ดํฐ๋ ๊ฐ์ฒด๊ฐ ๋ฌด์์ธ์ง๋ฅผ ๋ํ๋ธ๋ค.
๋ค๋ฅธ ๋ง๋ก ํ๋ฉด ๋ก์ง์ ๊ฐ์ฒด์ ๊ธฐ๋ฅ์ด๊ณ ,
๋ฐ์ดํฐ๋ ๊ฐ์ฒด์ ์์ฑ๊ณผ ๊ตฌ์ฑ์ ๋งํ๋ค.
Data Driven์ด๋ Data๋ฅผ ๋ถ๋ฆฌํ๋๋ฐ์ ์์ํ๋ค.
๋ ๋ฒจ ํ์ผ์ด๋ผ๋์ง,
์ํคํ์ ํ์ผ์ด๋ผ๋์ง,
์คํฌ๋ฆฝํธ ํ์ผ์ด๋ผ๋์ง,
ํธ์ ์ด๋ผ๋์ง,
๊ธฐํ ๋ณธ์ฒด๊ฐ ๋๋ ๊ฒ์์ด๋ ์๊ด ์๋ ๊ฒ๋ค์ ๊ตฌ๋ถํ๋๊ฒ ๊ทธ ์์์ด๋ค.
์ด๋ป๊ฒ ์๊ฒผ๋๋ฉด, ๊ฒ์ ์ดํ๋ฆฌ์ผ์ด์ ์ด ์ ๋ณด๋ฅผ ์ฝ์ด ์์,ย
๊ทธ ์ ๋ณด๋ฅผ ๊ฐ์ง๊ณ ๊ฒ์์ ๋ด์ฉ๋ค์ ๋ง๋๋๊ฑฐ์ง,
๊ฒ์ ์์ฒด์ ํ๋ ์ฝ๋ฉ ๋์ด ์๋ ๋ด์ฉ์ด ์๋๋ผ๋ ๋ป์ด๋ค.
์ต๋ํ ์ ์ ์ฝํ ์ธ ๋ง ํ๋์ฝ๋ ๋์ด์์ด์ผ ํ๊ณ ,
์ต์ํ์ ๊ธฐ๋ณธ๊ฐ ์ ๋๋ง ํ๋์ฝ๋ ๋ ์ ์๊ณ ,
์ค๋ธ์ ํธ๋ ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ ํ์ผ์ ์ด์ฉํด์ ๋ง๋ค์ด ์ ธ์ผ ํ๊ณ ,
๋ฐ๋ก ์์ง์ new Object๊ฐ ์์ด์ผ ๋๋ค.
์ ๊ทธ๋ผ ์ด๋ฐ๊ตฌ๋ก ๋ง๋ค๊น?
๋จผ์ , ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ์ฝ๋๋ฅผ ์ง๋๊ฑด ์ด๋ ต๊ณ , ํ๋ก๊ทธ๋๋จธ๋ ํ ์ผ์ด ๋ง๋ค.
๋ ๊ธฐํ์๋ ํด๋ด์ผ ํ๋๊ฒ ๋๋ฌด๋ ๋ง๊ธฐ ๋๋ฌธ์ด๋ค. ์ด ์์น๊ฐ ๋ง๋์ง ์ ๋ง๋์ง ์ด๋ป๊ฒ ์ฒดํฌ ํ ๊น?
๊ฐ์ผ๋ก? ์์์ผ๋ก? ์์ธกํ ๊ฒฐ๊ณผ๋ณด๋ค ๋ ์ข์ ์์น๋ฅผ ์ฐพ์์๋ ์๋๊ฒ ํ ์คํ ์ ์ข์์ ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
ํ๋ก๊ทธ๋๋จธ๊ฐ ์๋ ์ฌ๋ํํ
boost::unorderedmultimap<boost::string, Engine::GameObject>::iterator it = ~~~
์ด๋ด์์ผ๋ก ํ์์ ๋ณธ์ ๋ ์๋ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ์ง์ฌ์ง ๋ฌด์ธ๊ฐ๋ฅผ ์์ ํ๋๊ฑด ์์ฒญ๋๊ฒ ํ๋ ์ผ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
์ฌ์ง์ด ์คํ ํ๋๋ผ๋ ์๊ธฐ๋ฉด ๋นจ๊ฐ์ค ๋๋ ํฌ๋์ฌ๊ฐ ๋๋ ๊ฒ์์ ๋ณด๋ฉด, ๊ณตํฌ๊ฐ ์๊ธธ ์ ๋ฐ์ ์๋ค.
๋ ์ฝ๋๊ฐ ๋ฐ๋๋๊ฑด ์๋ก ์ปดํ์ผ์ ํด์ผํ๊ฑฐ๋ ๋น๋๋ฅผ ํด์ผํ๋ค๋ ๋ป์ด๋ค.ย
ํฐ ํ๋ก์ ํธ๋ ๋น๋ํ๋๋ฐ 10๋ถ ๋๊ธฐ๋๊ฑด ๋น์ฐํ๊ฑฐ๊ณ , ์ด๊ฑธ ์ค์ด๋ ค๊ณ ์ฌ๋ฌ๊ฐ์ง ๋ฐฉ๋ฒ๋ค์ ์ด์ฉํ์ง๋ง,
๊ทธ๋ ๋ค ํ๋๋ผ๋ ๋น๋ํ๋๋ฐ ์ค๋๊ฑธ๋ฆฌ๋๊ฑด ๋น์ฐํ๊ฒ์ด๋ค.ย
๊ทธ๋์ Data Driven์ด ์ข์๊ฑด ์๊ฒ ๋๋ฐ, ๊ทธ๋ผ ์ด๋ป๊ฒ ํด์ผํ ๊น?
serialization ์ด๋ผ ๋ถ๋ฆฌ๋๊ฑธ ํด์ฃผ๋ฉด ๋๋ค.ย
(serializationย ํ๊ตญ์ด๋ก ์ง๋ ฌํ ๋ผ๋๋ฐ ์ผ์.. ๊ทธ๋ฅ ์๋ฆฌ์ผ๋ผ์ด์ฆ ์ชฝ์ด ์ข์๊ฑฐ ๊ฐ๋ค;;)
์ค์ํ ๊ฐ๋ค์ ์ฝ์ด ์์, ์ ๋ณด๋ฅผ ์ค์ ๋ฃ์ด์ฃผ๋ฉด ๋๋ค๋๊ฒ์ด๋ค.
(๋น์งํฐ ํจํด(visitor pattern)์ ์ผ์ข ์ด๋ค.)
์ฃผ๋ ๊ตฌํ ๋ฒ์ด ์์ง๋ง, ์คํ์์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ด๋ด๋ ์ฐ๋ ค๊ณ ์๋๊ฒ์ด๋, ์คํ์์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฐ์!
๋ฌผ๋ก ์ง์ ๊ตฌํํด๋ ๋๊ณ , ๋์์ธ ํจํด์ ๊ณต๋ถํ๋ ๊ฐ์ฅ ์ข์ ๋ฐฉ๋ฒ์ค ํ๋๋๊น ๋ง๋ค์ด๋ ๋์๊ฑด ์๋๋ค!
๊ตฌํ ํ ๋ ํ์ํ ๊ฒ
serialize ๋ฉ์๋ ๋๋ย serialize ๋ฐฉ๋ฒ์ ์ ์ํ ์ธํฐํ์ด์ค๋ฅผ ์ง์ํ๋ ๊ฐ์ฒด,
ํ์ผ/๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅ ๋ฐ ๋ก๋๋ฅผ ์บก์ํํ ์คํธ๋ฆผ ๊ฐ์ฒด orย serializer
๊ฐ์ฒด๋ฅผย serialize ํ๋ ๋ฐฉ์์ ์ ์ํ ์ฐ์ฐ์ ๋ฑ๋ฑ.
์ด๋ฐ๊ฒ๋ค์ด ์์ผ๋ฉด ๋จ.
์ด๋ฌ๋ฉด ์ด๊ฒ๋ค๋ก ํ ์คํธ ์ ๋ณด๋, XML ์ ๋ณด, JSON ์ ๋ณด ๋ฑ๋ฑ์ ์ฌ๋ฌ๊ฐ์ง data๋ค์ ์ฝ์ด ์ฌ์ ์๋ค.
serialization ๋จ๊ณ๋
1. ์ค๋ธ์ ํธ๋ฅผ ๋ง๋ ๋ค. (์์ง ํ์ฑํ ๋๊ฑด ์๋.)
2.ย serializationย ํด์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด ์จ๋ค. (์ฌ๊ธฐ์ ๋ฅ๊ฐ๋ ๊ตฌ๋ถํ๊ณ ํ์ ํ๋ค๋ฉด ์ฝ๊ฐ์ ์กฐ์ ๋ ๊ฑฐ์น๋ค.)
3. ๊ฐ์ฒด๋ฅผ ์์ ํ ์ด๊ธฐํ ํ๋ค. (์ฆ ์ฝ์ด์จ๊ฑธ ์ธํ ํด์ค๋ค. )
4. ์์ฑ ์๋ฃ! (์ด์ ์ค์ ๋ก ๊ฒ์์ ์กด์ฌํ๋๊ฑฐ.)
๊ทธ๋ผ ์ด๋ป๊ฒ ์ ์ฉํ๋ฉด ๋ ๊น?
์ผ๋จ ์๋ฌด๋ฐ์๋ new ํ๋ฉด ์๋๋ค.
ํฉํ ๋ฆฌ ํจํด์ด๋ผ๋ ์์ฃผ ์ข์ ๋ฐฉ๋ฒ์ด ์๋๋ฐ, ์ด ๋ฐฉ๋ฒ์ผ๋ก ๊ฐ์ฒด๋ฅผ ์์ฑํ๋๊ฒ ์ข๋ค.
Object* ObjectFactory::CreateObject(string type)
{
switch(type)
{
case "Player" : return new Player();
case "Enemy" : return newย Enemy();
case "Tree" : return new Tree();
}
return null;
}
์ด๋ฐ์์ผ๋ก ๋ง๋ค๋ฉด ๋๋ค.ย
Factory์๋ ๋ฌธ์ ๊ฐ ์๋๋ฐ, ์ ๋ฌ๋ฉด ๋ชจ๋ ๊ฐ์ฒด ํ์ ์ ๋ํด์ย
์ ๋ถ ํค๋๊ฐ ์๊ฑด, import๊ฐ ์๊ฑด ํ์ํ๋ค๋๊ฒ์ด๋ค. (C# ์งฑ์งฑ์ธ๊ฒ!)
๋ ์๋ก์ด ๊ฐ์ฒด๊ฐ ์ถ๊ฐ๋ ๋๋ง๋ค ์ ํฌ๋ฆฌ์์ดํธ ์ค๋ธ์ ํธ ํ์ผ์ย ์ด์ด์
์ฝ๋๋ฅผ ์์ ํด์ผํ๋ค....
๊ทธ๋์ map์ ์ฐ๋ฉด ์ ๊ฒ ํด๊ฒฐ์ด ๋๋ค! (๋ฌผ๋ก ํด์ฌ๋งต๋ ์ข๋ค ใ .)
Object* ObjectFactory::CreateObject(string type)
{
Object* newObject = null;
newObject = ObjectMap[type]->Create();
returnย newObject;
}
์ด๋ฐ์์ผ๋ก ๊ณ ์น ์ ์๋ค. ๊ทธ๋ผ map์๋ค๊ฐ ์ค๋ธ์ ํธ์ ์ข ๋ฅ์ ๋ง์ถฐ์ ์ถ๊ฐํด์ฃผ๋ฉด ๋๋ค.
์ด๋ฌ๋ฉด ์ด์ ์์์ ํ๊ฑธ ํ๊ตฐ๋ฐ ํฉ์น๋ฉด ๋๋ค.
Object* ObjectFactory::CreateObject(string file, string type)
{
File stream(file);
Object* newObject = null;
newObject = ObjectMap[type]->Create()
Serializer::Serialize(stream, type);
newObject->Init()
returnย newObject;
}
์ด๋ ๊ฒ ๋๋ฉด ํ์ผ์์ ์ฝ์ด์ ๋ง๋ค์ด์ง ์ ์ค๋ธ์ ํธ์ ์ธํ ์ ํด์ฃผ๊ณ ,
์ด๊ธฐํํด์, ๋ง๋ค์ด ์ค๋ค.
ํ์ง๋ง ์ฌ๊ธฐ์ ๋์ด ์๋๋ค!
์ฐ๋ฆฌ๋ ์ปดํฌ์ง์ ์ ์๋ ๋ฌธ๋ช ์ธ์ด๋๊น ์ปดํฌ๋ํธ ๊ธฐ๋ฐ์ด๋๋ผ๋ ์ฝ์ด์ค๋ฉด ๋๋ค!
Object* ObjectFactory::CreateObject(string file, string type)
{
File stream(file);
Object* newObject = null;
newObject = ObjectMap[type]->Create()
Serializer::Serialize(stream, type);
while(stream.IsEnd() == false)
{
Component* newComponent = null;
newComponentย = CompoMap[compotype]->Create();
Serializer::Serialize(stream,ย compotype);
newObject ->Add(compotype,ย newComponent);
}
newObject->Init()
returnย newObject;
}
์ด๋ฌ๋ฉด ์ค๋ธ์ ํธ์ ์ ์ฅ๋ ๊ฐ๊ฐ์ ์ปดํฌ๋ํธ๋ ๋ฌด์์ ๊ฐ์ง๊ณ ์๊ณ , ์ ๋ณด๋ง ์๋ค๋ฉด ์ฃผ๋ฅด๋ฅต ํ๊ณ ์ฝ์ด ์จ๋ค.
์์ฉ ๊ฒ์์์ง๋ค๋ ์ ์ฅ๋ ์ ๋ณด๋ฅผ ์ด๋ ๊ฒ ์ฝ์ด ์ค๋๊ฒ์ด๊ณ ,
๋ ๋ฒจ์ด๋ ๋ชจ๋ ๊ธฐํ ๋ฑ๋ฑ ํ์ ํ๊ฒ๋ ์ด๋ฐ ๋ฐฉ์์ผ๋ก ์ฝ์ด์ค๋๊ฒ์ด๋ค.
๋ฌผ๋ก ํ์ผ์ ์ด์ด์, ์ ๋ณด๋ฅผ ์ฝ์ด์ค๋๊ฑด ์ค๋ ๊ฑธ๋ฆฌ๋ ํ๋์ด๊ธฐ ๋๋ฌธ์, ์์ฃผ ์ฝ์ด์ผ ํ๋๋ฐ์ดํฐ๋ฉด
๊ทธ๋ฅ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ ค๋๊ณ , ๋ค์๋ ์์ฝ์ด ์ค๋๊ฒ ๊ฐ์ฅ ๋ฐ๋์งํ๋ค.ย
๋ค์ ์ฝ์ด์ค๊ฒ ๋ง๋ ๋ค๋ฉด ์ฅ์ .
๊ฒ์ ํ ์คํธ ๋์ค์ ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด์ ํ ์คํธ ๊ฐ๋ฅ. (์ธ๊ฒ์ ์๋ํฐ๊ฐ ์์์)
๋ค์ ์ฝ์ด์ค๋๊ฒ์ ๋จ์ .
๊ฒ์ ํ๋ ์์ด ํ๋ฉด์ ๋ฌธ์ ๊ฐ ์๊น.
๊ฒฐ๋ก :ย ์ปดํ์ผ ์์ด, ๋น๋ ์์ด, ์ต์ํ์ ๋น๋๋ง์ผ๋ก ๊ฐ๋ฐํ๊ธฐ ์ํด
ํ๋์ฝ๋ฉ๋ ๊ฐ์ ์ธ๋ถ๋ก ๋นผ์, ์ต๋ํ ๋ง๊ณ , ๋น ๋ฅธย ๋ฐ๋ณต๋ฅผ ์ํด ๋ง๋ค์ด์ง ๋ฐฉ๋ฒ์ด data driven์ด๋ค.
์กฐํ - dc App
์์ฝ์์! - dc App
๊ทผ๋ฐ ๊ฒ์ ํ๋ ์์ ์ ํ๋๊ฑฐ์??
ใดํ์ผ ๋ก๋ํ๋ฉด์, ํ์ผ์ ์ด๊ณ ๋ซ๋๋ฐ, ํ์ผ์ด ์ด๋ค ํ์์ด๊ฑด ๊ฐ์ ์ด๋์ ๋ ๊ธธ์ด์ string์ ๋ด๊ณ ์์๊ฑฐ๊ณ , ๊ทธ๊ฑธ ์ฝ์ด ์ค๋ฉด์ ๊ทธ ๊ธด ๊ธธ์ด์ ์ ๋ณด๋ฅผ ๋ค ํ๋๋ค๊ณ ์๊ฐํด๋ณด์ .
ํนํ ํ์ผ ํฌ๋ฉง์ด ์ ๋์ฝ๋๋ผ๋ฉด... ๋ถํ๊ฐ ์์ฒญ ์ฌํ ๋น๊ต๋ฅผ ํด์ผ๋๋๊ฑฐ๊ณ ;; UTF8์ด๋ฉด ๊ทธ๋๋ง ๋์ ๊ฒฝ์ฐ์ง๋ง ๊ทธ๊ฒ๋ ์๋นํ ๋ถ๋ด๋๋๊ฑด ๋ง์ฐฌ๊ฐ์ง...
string ๋น๊ต๋ ๊ฒฐ๊ตญ์ source[n] dest[m]์ ํ๋ ฌ์ด ๊ฐ์์ง ์๋์ง๋ฅผ ํ๋จํ๋๊ฒ์ด๋ผ ๊ทธ๋ผ.