The infrastructure of the game

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 revart (); int posuse (); int shutdown (); int AddModule (cmodulebase * newmodule, int moduleid, int UPDATEFREQUENCY); int RemoveModule;}; this is the basic feature of a engine that needs to have, do not take a graphic, do not have a 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 infinite state machine: First you need a memory pool: // MemoryMag.h # ifndef __memory_mag_h __ # define __memory_mag_h__ #include #include template Class CMemoryMAG {public: cmemorymag (int size); ~ cmemorymag (); t * getNew (); int free (t * var); private: t * m_data; int * m_freed; int m_freedsize; int m_maxsize; int m_cursize;}; template CMemoryMag :: cmemorymag (int size): m_maxsize (size), m_cursize (0), m_freedsize (0) {m_data = new t [size]; assert (m_data! = null); m_freed = new Int [size]; assert (m_freed! = null);} template cmemorymag :: ~ cmemorymag () {delete [] m_data; delete [] m_freed;} template t * cmemoryMAG < T> :: GetNew () {if (m_freedSize!) {if (m_curSize int CMemoryMag < T> :: free (t * var) {INT I, J; int found = 0; for (j = 0; j

======== // then you need a hash table //HASHER.H# ide __hasher_h __ # define __HASHER_H__ #include "memorymag.h" class chasher {public: chasher (int size); ~ chasher (); INTETER (const char * pstr, void * node); int Remove (const char * pstr); private: int GETHASH (Const Char * PSTR); typedef struct hashnode {char * name ; Hashnode; cmemory; cmemorymag * m_hasharr; hashnode ** m_hashtable; int m_h; int m_objtable; int m_size;}; #ENDIF ============ ======================================================================================================================================================================================================================== #include static int t [] =

{1, 87, 49, 12, 176, 178, 102, 166, 121, 193, 6, 84, 249, 230, 44, 163, 14, 197, 213, 181, 161, 85, 218, 80, 64 239, 24, 226, 236, 142, 38, 200, 110, 177, 104, 103, 141, 253, 255, 50, 77, 101, 81, 18, 45, 96, 31, 222, 25, 107 , 190, 70, 86, 237, 240, 34, 72, 242, 20, 214, 244, 227, 149, 235, 97, 234, 57, 22, 60, 250, 82, 175, 208, 5, 127 , 199, 111, 62, 135, 248, 174, 169, 211, 58, 66, 154, 106, 195, 245, 171, 17, 187, 182, 179, 0, 243, 132, 56, 148, 75 128, 133, 158, 100, 130, 126, 91, 13, 153, 246, 216, 219, 119, 68, 223, 78, 83, 88, 201, 99, 122, 11, 92, 32, 136 , 114, 52, 10, 138, 30, 48, 183, 156, 35, 61, 26, 143, 74, 251, 94, 129, 162, 63, 152, 170, 7, 115, 167, 241, 206 , 3, 150, 55, 59, 151, 220, 90, 53, 23, 131, 125, 173, 15, 238, 79, 95, 89, 16, 105, 137, 225, 224, 217, 160, 37 , 123, 118, 73, 2, 157, 46, 116, 9, 145, 134, 228, 207, 212, 202, 215, 69, 229, 27, 188, 67, 124, 168, 252, 42, 4 , 29, 108, 21, 247, 19, 205, 39, 203, 233, 40, 186, 147, 198, 192, 155, 33, 164, 191, 98, 204, 165, 180, 117, 76, 140, 36, 210, 172, 41, 54, 159, 8, 185, 232, 113, 196, 231, 47, 146, 120, 51, 65, 28, 144, 254, 221, 93, 189, 194, 139, 112, 43, 71, 109, 184, 209,}; int@ztr (const char * s, int mapn ) {Register unsigned char * p; register INT i; if (! * S) return 0; p = (unsigned char *) s; oh = t [* p]; h = (* (* P ) 1) & 0xFF; for (i = max - 1; * P && --i> = 0;) {oh = t [oh ^ * p]; h = t [h ^ * (p )]; } Return (OH << 8) H;} inline int chasher :: geth (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 (RealSize); M_HashTable = new hashnode * [size];} chasher :: ~ chasher () {delete m_hasharr; while (m_size -) {hashnode * next = m_hashtable [m_size]; while (next) {ix ( Next-> name! = null) {delete [] next-> name; next-> name = null;} next = next-> next;}} delete [] m_haashtable;} 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 car * pstr, void * node) {hashnode * newNode = m_hasharr-> getNew (); int n = gethash (pstr); newnode-> next = m_hashtable [n]; newnode-> PTR = Node; newn Ode-> name = getnewstr (pstr); newNode-> Next = m_hashtable [n]; m_hashtable [n] = newNode; return 1;} void * chasher :: find (const char * pstr) {int N = gerthash (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 = gehash (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 = null; m_haashrr-> free (curr); return 1;} prev = curr; curr = curr-> next;} return 0;} // then look at FSM ( Finite Status Machine) // fsm.h // Finite State Machine # ifndef __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 * varvalue); void * Get (const char * varName); private: CHasher m_hasher; static CFiniteStateMachine * m_myInstance;}; #endif ======================================================= // FSM implementation and #include "FSM.h" CFiniteStateMachine * CFiniteStateMachine :: m_myInstance = NULL; CFiniteStateMachine * CFiniteStateMachine :: GetInstance () {if (m_myInstance == NULL) {m_myInstance = new CFiniteStateMachine (); return m_myInstance;} re turn 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_haasher.enter (varname, varvalue);} return m_haasher.enter (varname, varvalue);} void * cfinitestateMachine :: get (const char * varname) {void * var ; If ((VAR =)