Just like repairing a house, don't worry about you with more expensive bricks, it is just a brick, it is not what you want. The brick can be changed at any time when developing, but once the structure is set, it is not good.
One basic, what is the structure of Efficient? Very simple. All you need is the engine, unlimited state machine and memory pool. These three things are not complicated, you can start from scratch: First is your engine class, what do you need? Class CENGINE {public: CENGINE (); ~ CENGINE (); int initialize (); int start (); int tent (); int posuse (); int shutdown ();
Int Addmodule (CMODULEBASE * NewModule, int ModuleId, int updatefrequency);
Int RemoveModule (INT MODULEID);
}; This is the basic function of a engine that needs to have, do not take the pattern, and do not manage the network, nothing else. Just responsible for adding a module, the added module is refreshed during the specified time. This way, the graph is also good, artificial intelligence is also in the form of the module to add to the engine's refresh list.
So what is the infinite state machine? The infinite state machine is a library that gives you a state, but you can store all the status you want. For example, when you refresh the network, receive the new player's coordinates, then you need to modify the value of the coordinate, then where is the value of the coordinate? Inside the unlimited state machine, only when the network module is updated, just write set ("coordinate", & mycurpos; then when the graphic module is updated, only write mycurpos = get ("coordinate"). So where is the value of mycurpos? It is stored in the memory pool. The memory pool is created when the game is initialized, destroying at the end of the game, providing all the data in the game, and an unlimited state machine is a mapping of a string to the data pointer.
Let's take a look at the implementation of an unlimited state machine: First you need a memory pool: // MemoryMag.h # ifndef __memory_mag_h __ # define __memory_mag_h__
#include
Template
Private:
T * m_data; int * m_freed; int m_freedsize; int m_maxsize; int m_cursize;
Template
m_freed = new int [size]; assert (m_freed! = null);
Template Return NULL; Return & M_Data [m_freed [- m_freedsize]]; Template For (j = 0; j IF (Found) Return 0; For (i = 0; i IF (Found! = (m_cursize - 1)) {m_freed [m_freedsize ] = Found; return 1;} m_cursize -; return 1;} #ENDIF ======================================================================================================================================================================================================================================= == // Then you need a haveh table //HASHER.H#1ndef __hasher_h __ # define __hasher_h__ #include "memorymag.h" Class chasher {public: chasher (int size); ~ chasher (); INT ENTER (const char * pstr, void * node); int Remove (const char * pstr); void * find (const char * pstr); Private: int GETHASH (Const Char * PSTR); Typedef struct hashnode {char * name; void * ptr; struct hashnode * next;} Hashnode; CMEMORYMAG #ENDIF ======================================================================================================================================================================================================================================= == // Hasher.cpp # include "Hasher.h" #include INT hashstr (const char * s, int maxn) {register unsigned char oh, h; register unsigned char * p; register int i; IF (! * s) return 0; p = (unsigned char *) s; oh = t [* p]; h = (* (p ) 1) & 0xff; for (i = maxn - 1; * P && --i> = 0;) {oh = t [oh ^ * p]; h = T [h ^ * (p )]; Return (OH << 8) h;} Inline Int Chasher :: GETHASH (Const Char * PSTR) {Return Hashstr (PSTR, 16) & m_objtable; Chasher :: Chasher (int size): m_haashrr (null), m_size (size) {int realsize For (RealSize = 1; RealSize Chasher :: ~ chasher () {delete m_hasharr; while (m_size -) {hashnode * next = m_hashtable [m_size]; while (next) {if (Next-> Name! = Null) {delete [] next-> name Next-> name = null;} next = next-> next;}} delete [] m_hashtable; Char * getnewstr (const char * pstr) {INT LEN (Strlen (pstr)); if (len> = 0) {char * p = new char [len]; assert (p! = null); memcpy (p, pstr , LEN); RETURN P;} Return null; INT Chasher :: Enter (const char * pstr, void * node) {hashnode * newNode = m_haashrr-> getnew (); INT N = GetHash (PSTR); NewNode-> Next = m_hashtable [n]; newnode-> ptr = node; new inde-> name = getNewStr (PSTR); newNode-> next = m_hashtable [n]; m_hashtable [n] = newNode; return 1;} Void * chasher :: Find (const char * pstr) {int n = gethash (pstr); havehnode * node = m_hashtable [n]; while (node) {if (! strcmp (node-> name, pstr) Return Node -> ptr; node = node-> next;} Return Null;} int chasher :: remove (const char * pstr) {hashnode * prev, * curr; m_h = gethash (pstr); curr = m_hashtable [m_h]; prev = 0; While (curr) {if (! strcmp (curr-> name, pstr)) {if (prev) prev-> next = curr-> next; delete [] curr-> name; curr-> name = nail; m_hasharr- > Free (curr); return 1;} prev = curr; curr = curr-> next;} return 0;} // then look at FSM (Finite Status Machine) // fsm.h // Finite State Machine # i indef __myfsm_h__ #define __myfsm_h__ #define fsm_d (cfinitestateMachine :: getInstance ()) # define max_variable_num 512 #include "Hasher.h" Class cfinitestatemachine {public: cfinitestateMachine (); ~ cfinitestatemachine (); Static cfinitestateMachine * getInstance (); INT set (const char * varname); Void * get (const char * varname); Private: chasher m_hasher; static cfinitestateMachine * m_myinstance; #ENDIF ======================================================================================================================================================================================================================================= // and FSM implementation #include "fsm.h" CfiniteStateMachine * cfinitestateMachine :: m_myinstance = null; CFiniteStateMachine * CFiniteStateMachine :: GetInstance () {if (m_myInstance == NULL) {m_myInstance = new CFiniteStateMachine (); return m_myInstance;} return m_myInstance;} CFiniteStateMachine :: CFiniteStateMachine (): m_hasher (MAX_VARIABLE_NUM) {} CfinitestateMachine :: ~ cfinitestateMachine () {} int CFiniteStateMachine :: Set (const char * varName, void * varvalue) {if (! m_hasher.Find (varName) = NULL) {m_hasher.Remove (varName); return m_hasher.Enter (varName, varvalue);} return m_hasher. ENTER (varname, varvalue); Void * cfinitestateMachine :: GET (const char * var; if ((var = m_hasher.find (var = m_hasher.find (varname))! = null) Return var; return null;} ========== ======================================== to this, a simple game engine part has already Basically, the rest is to see if you are the client or the server, you need a graphics module or network module, or the NPC, you can slowly take into account.
