菜鸟求教，我接下来该做些什么？

sjinny

我自己写了一些代码了，现在已经能做到的包括：
1.网络通信
2.从动态链接库中载入类
3.多线程的封装
4.能够让现有代码与OPAL和OGRE一起运行

因为我缺乏经验，所以想问问大家，我接下来该做些什么呢？
[em1]

lights

你一点也不菜，你可以把你写的东西放出来，写写经验心得，和人家多交流。

sjinny

我的那个在这里：
http://www.blog.163.com/sjinny/
里面有介绍和源代码，不过源代码是上传到新浪那里的，不知道现在还能不能下载了，而且那个是2006.10.16的，和现在这个有一些差别了，我把现在这个版本的基本完善之后会把新的源代码上传，不过不知道那会是什么时候了……

我的心得……简单的说就是下面这些：
1.网络通信：对象序列化+Command模式已经不错了，实现不很复杂，用起来也比较方便
2.实现引擎与内容的分离：引擎放在可执行文件里，内容放在动态链接库里（以类的形式），我的设计是把内容分成两大块，一块是场景类，一块是对象类；场景负责在游戏程序开始时载入游戏内容对应的类，实例化一些类以载入初始场景；对象类，负责实现游戏场景里的内容，包括道具、角色，任务，技能等。网络通信时传送的是Command对象及其派生类的实例，它们也放在动态链接库里，并且在外部放一个文本文件，给出每个Command类的ID（整数），序列化时记录下所属类的ID，重建对象时根据此ID生成新的实例，然后根据从网络受到的数据对该实例初始化，做好这些之后调用其基类的接口process()，通过参数把一些必要的数据传进去，这样这个数据包就可以被解析了，而且解析的代码是从动态链接库载入的，因此比较灵活。
3.多线程的封装，我是在boost.thread库的基础上封装的，主要是我有自己的一个Module类：

1. 
   
2. typedef enum{
   
3.     SHUT_DOWN= 0,
   
4.     RUNNING,
   
5.     PAUSE,
   
6. } State;
   
7. 
   
8. class EXPORT Module
   
9. {
   
10.     friend class World;
    
11. public:
    
12.     Module();
    
13.     virtual ~Module();
    
14. public:
    
15.     int load( Module* __module );
    
16.     void unload( Module* __module );
    
17.     virtual void operator () (void);
    
18.     bool getThreaded(void)
    
19.     {
    
20.         recursive_mutex::scoped_lock lock( _mutex );
    
21.         return _threaded;
    
22.     }
    
23.     void setThreaded( bool __threaded )
    
24.     {
    
25.         _threaded= __threaded;
    
26.     }
    
27.     void setSelfFirst( bool __self_first )
    
28.     {
    
29.         if( __self_first ){
    
30.             moduleBreathe= moduleBreathe_self_first;
    
31.         }else{
    
32.             moduleBreathe= moduleBreathe_self_last;
    
33.         }
    
34.     }
    
35.     static World& getWorld(void);
    
36.     static void setWorld( World* __world );
    
37.     State getState(void)
    
38.     {
    
39.         recursive_mutex::scoped_lock lock( _mutex );
    
40.         return _state;
    
41.     }
    
42.     void setState( const State __state )
    
43.     {
    
44.         recursive_mutex::scoped_lock lock( _mutex );
    
45.         _state= __state;
    
46.         _cond.notify_all();
    
47.         for( list<Module*>::iterator itor= _modules.begin(); itor!=_modules.end(); ++itor ){
    
48.             Module& module= *(*itor);
    
49.             try{
    
50.                 module.setState( __state );
    
51.             }catch( exception& e ){
    
52.                 cerr << "Setting State error: " << __state << "\t" << e.what() << endl;
    
53.             }catch( ... ){
    
54.                 cerr << "Setting State error: " << __state << "\t" << "Unknown exception" << endl;
    
55.             }
    
56.         }
    
57.         for( list<Module*>::iterator itor= _threaded_modules.begin(); itor!=_threaded_modules.end(); ++itor ){
    
58.             Module& module= *(*itor);
    
59.             try{
    
60.                 module.setState( __state );
    
61.             }catch( exception& e ){
    
62.                 cerr << "Setting State error: " << __state << "\t" << e.what() << endl;
    
63.             }catch( ... ){
    
64.                 cerr << "Setting State error: " << __state << "\t" << "Unknown exception" << endl;
    
65.             }
    
66.         }
    
67.     }
    
68. protected:
    
69.     void moduleBreathe_self_first(void);
    
70.     void moduleBreathe_self_last(void);
    
71.     void moduleShutdown(void);
    
72.     virtual int init(void) { return 0; }
    
73.     virtual void breathe(void)
    
74.     {
    
75.         if( _threaded && _state!=SHUT_DOWN && _modules.empty() ){
    
76.             recursive_mutex::scoped_lock lock( _mutex );
    
77.             _cond.wait( lock );
    
78.         }
    
79.     }
    
80.     virtual void shutdown(void)
    
81.     {
    
82.     }
    
83. protected:
    
84.     bool _have_shutdown;
    
85.     static recursive_mutex _world_mutex;
    
86.     static World* _world;
    
87.     bool _running;
    
88.     State _state;
    
89.     bool _threaded;
    
90.     recursive_mutex _mutex;
    
91.     condition _cond;
    
92.     void (Module::*moduleBreathe)(void);
    
93.     list<Module*> _modules;
    
94.     list<Module*> _threaded_modules;
    
95.     thread_group _threads;
    
96. };
    

复制代码

1. 
   
2. #include "module.h"
   
3. 
   
4. recursive_mutex Module::_world_mutex;
   
5. World* Module::_world= NULL;
   
6. 
   
7. 
   
8. Module::Module()
   
9. {
   
10.     _have_shutdown= false;
    
11.     _running= true;
    
12.     _state= RUNNING;
    
13.     _threaded= false;
    
14.     moduleBreathe= moduleBreathe_self_first;
    
15. }
    
16. 
    
17. 
    
18. Module::~Module()
    
19. {
    
20. }
    
21. 
    
22. 
    
23. void module_main( Module* __module )
    
24. {
    
25.     (*__module)();
    
26. }
    
27. 
    
28. 
    
29. int Module::load( Module* __module )
    
30. {
    
31.     int ret= 0;
    
32.     try{
    
33.         ret= __module->init();
    
34.     }catch( exception& e ){
    
35.         cerr << "Init failed: " << e.what() << endl;
    
36.         __module->moduleShutdown();
    
37.     }catch( ... ){
    
38.         cerr << "Init failed: " << "Unknown exception" << endl;
    
39.         __module->moduleShutdown();
    
40.     }
    
41.     if( ret ){//error occurs
    
42.         __module->moduleShutdown();
    
43.         return ret;
    
44.     }else{
    
45.         if( __module->_threaded ){
    
46.             _threads.create_thread( boost::bind(&module_main, __module) );
    
47.             _threaded_modules.push_back( __module );
    
48.         }else{
    
49.             _modules.push_back( __module );
    
50.         }
    
51.     }
    
52.     return 0;
    
53. }
    
54. 
    
55. 
    
56. void Module::unload( Module* __module )
    
57. {
    
58.     __module->shutdown();
    
59.     if( __module->getThreaded() ){
    
60.         _threaded_modules.remove( __module );
    
61.     }else{
    
62.         _modules.remove( __module );
    
63.     }
    
64. }
    
65. 
    
66. 
    
67. void Module::operator () (void)
    
68. {
    
69.     try{
    
70.         while( _running ){
    
71.             switch( _state ){
    
72.                 case RUNNING:
    
73.                     (this->*moduleBreathe)();
    
74.                     break;
    
75.                 case PAUSE:
    
76.                     break;
    
77.                 case SHUT_DOWN:
    
78.                     moduleShutdown();
    
79.                     break;
    
80.                 default:
    
81.                     break;
    
82.             }
    
83.         }
    
84.     }catch( exception& e ){
    
85.         cerr << "Runtime error: " << e.what() << endl;
    
86.         moduleShutdown();
    
87.     }catch( ... ){
    
88.         cerr << "Runtime error: " << "Unknown exception" << endl;
    
89.         moduleShutdown();
    
90.     }
    
91. }
    
92. 
    
93. 
    
94. void Module::moduleBreathe_self_first(void)
    
95. {
    
96.     breathe();
    
97.     for( list<Module*>::iterator itor= _modules.begin(); itor!=_modules.end(); ++itor ){
    
98.         Module& module= *(*itor);
    
99.         (module.*moduleBreathe)();
    
100.     }
     
101. }
     
102. 
     
103. 
     
104. void Module::moduleBreathe_self_last(void)
     
105. {
     
106.     for( list<Module*>::iterator itor= _modules.begin(); itor!=_modules.end(); ++itor ){
     
107.         Module& module= *(*itor);
     
108.         (module.*moduleBreathe)();
     
109.     }
     
110.     breathe();
     
111. }
     
112. 
     
113. 
     
114. void Module::moduleShutdown(void)
     
115. {
     
116.     if( !_have_shutdown ){
     
117.         recursive_mutex::scoped_lock lock( _mutex );
     
118.         _running= false;
     
119.         _have_shutdown= true;
     
120.         _state= SHUT_DOWN;
     
121.         for( list<Module*>::iterator itor= _modules.begin(); itor!=_modules.end(); ++itor ){
     
122.             Module& module= *(*itor);
     
123.             try{
     
124.                 module.moduleShutdown();
     
125.             }catch( exception& e ){
     
126.                 cerr << "Shutdown Module error: " << e.what() << endl;
     
127.             }catch( ... ){
     
128.                 cerr << "Shutdown Module error: " << "Unknown exception" << endl;
     
129.             }
     
130.         }
     
131.         for( list<Module*>::iterator itor= _threaded_modules.begin(); itor!=_threaded_modules.end(); ++itor ){
     
132.             Module& module= *(*itor);
     
133.             try{
     
134.                 module.moduleShutdown();
     
135.             }catch( exception& e ){
     
136.                 cerr << "Shutdown Module error: " << e.what() << endl;
     
137.             }catch( ... ){
     
138.                 cerr << "Shutdown Module error: " << "Unknown exception" << endl;
     
139.             }
     
140.         }
     
141.         _threads.join_all();
     
142.         if( _threaded ){
     
143.             _cond.notify_all();
     
144.         }
     
145.         shutdown();
     
146.         _have_shutdown= true;
     
147.     }
     
148.     _running= false;
     
149. }
     
150. 
     
151. 
     
152. World& Module::getWorld(void)
     
153. {
     
154.     recursive_mutex::scoped_lock lock( _world_mutex );
     
155.     return *_world;
     
156. }
     
157. 
     
158. 
     
159. void Module::setWorld( World* __world )
     
160. {
     
161.     recursive_mutex::scoped_lock lock( _world_mutex );
     
162.     _world= __world;
     
163. }
     

复制代码

这样，Module里还可以有子Module，子Module可以是单独的线程，也可以与父Module共用一个线程（通过Module::setThreaded( bool __threaded )来设置）。
4.引入其他的库。我为OPAL和OGRE新建了一个类，比如对于OGRE：

1. 
   
2. class EXPORT ModuleOgre : virtual public Module, public BaseApplication
   
3. {
   
4. public:
   
5.         ModuleOgre(void);
   
6.         virtual ~ModuleOgre();
   
7. public:
   
8.     void operator () (void);
   
9. };
   

复制代码

1. 
   
2. #include "modules/moduleogre.h"
   
3. 
   
4. 
   
5. ModuleOgre::ModuleOgre(void)
   
6. {
   
7.     setThreaded( true );
   
8. }
   
9. 
   
10. 
    
11. ModuleOgre::~ModuleOgre()
    
12. {
    
13. }
    
14. 
    
15. 
    
16. void ModuleOgre::operator () (void)
    
17. {
    
18.     try{
    
19.         SET_TERM_HANDLER;
    
20.         go();
    
21.         moduleShutdown();
    
22.     }catch( Ogre::Exception& e ){
    
23.         #if OGRE_PLATFORM == OGRE_PLATFORM_WIN32
    
24.             MessageBox( NULL, e.getFullDescription().c_str(), "ModuleOgre error", MB_OK | MB_ICONERROR | MB_TASKMODAL );
    
25.         #else
    
26.             cerr << "ModuleOgre error: " << e.getFullDescription().c_str() << endl;
    
27.         #endif
    
28.         moduleShutdown();
    
29.     }catch( exception& e ){
    
30.         cerr << "ModuleOgre error: " << e.what() << endl;
    
31.         moduleShutdown();
    
32.     }catch( ... ){
    
33.         cerr << "ModuleOgre error: " << "Unknown exception" << endl;
    
34.         moduleShutdown();
    
35.     }
    
36. }
    

复制代码

其中BaseApplication这个类是由Ogre SDK 1.2.x Application Wizard v.1.2提供的。
总是要引入一个新的开发库时，我会新建一个Module的派生类，并且实现/重写这几个基类里的虚函数：

1. 
   
2.     virtual void operator () (void);
   
3.     virtual int init(void);
   
4.     virtual void breathe(void);
   
5.     virtual void shutdown(void);
   

复制代码

*^_^*

小小C

你已经是高手了,已经走到顶峰了吧

sjinny

-_-!  不要这样说……
我到现在连一个完整的小游戏都还没做出来……要说失败的经验比较丰富那倒是真的，嘿嘿

言归正传，我下面该做些什么事呢？

lights

www.gamelaa.com
邀请你过来我们一起做点事。
你那个blog也别搞了，更新那么慢，灌灌水得了。
我们以这个论坛为基础做游戏相关的事情。

wocen

111

sjinny

lights，我那个blog纯粹是为了能够有个地方让感兴趣的人下载我的源代码，如果有个更好的文件共享的方法我就不弄那个了……

wocen，好久不见，领工资没？其实我也不想重复发明轮子啊……要不这样吧，你找个好用实用的游戏开发引擎，把它的源代码以BSD协议开放，这样我就不用自己发明轮子了，我会直接去使用那个引擎做我想做的游戏了，不过貌似目前还没这种引擎……要我买的话，估计把我卖了都买不起，没办法，穷人只好自己造轮子，谁叫人家要做生意赚钱呢，其实别人要赚钱我也没意见，可是不让穷人自己动手丰衣足食，这就不太好了吧……

sjinny

小顶一下

月下临风

其实你还蛮好的,就是废话太多,如果我们公司有你这样的人负责文档,那应该非常的适合了,呵呵.