[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
<>// File: mazeserver.cpp
//
// Desc: see main.cpp
! X- A0 F4 K, n//
// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
' i; `9 o1 s( }) @3 N" S% }. A//-----------------------------------------------------------------------------
- [. Y- R8 F4 C2 m  c8 ~4 S#define STRICT
#define D3D_OVERLOADS
#include &lt;windows.h&gt;
#include &lt;d3dx.h&gt;
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;mmsystem.h&gt;
#include &lt;dplay8.h&gt;
#include &lt;dpaddr.h&gt;
  b' M- x3 v" v# w7 {#include &lt;dxerr8.h&gt;
. C- G5 M8 Z- Y5 h#include "DXUtil.h"
/ m& L9 t7 I+ ~4 z) }  e( l#include "MazeServer.h"
0 `, _& O* U! k9 x9 S' r#include "ackets.h"
#include "Maze.h"
#include &lt;malloc.h&gt;
2 l9 u2 i- d* w. X, k& f/ m) w/ U#include &lt;tchar.h&gt;</P>
4 S  S. `8 h' k8 W0 _
<>//-----------------------------------------------------------------------------
1 k, X8 p1 z! T* T( a// Name:
/ b5 o: H- y% `5 I// Desc:
1 d+ W( B, H- c/ H5 T( h//-----------------------------------------------------------------------------
1 o' |% {8 {1 V( D9 Q& W, ]- QCMazeServer::CMazeServer()
: _' W- d! h1 Z: y. h6 F" V$ v# |{
, ~. P# D! |* W* M    m_dwPlayerCount         = 0;
   
3 J4 D6 z" J) r1 t  d' R4 E* X    m_wActiveThreadCount   = 0;
1 i# u, G$ p+ P" W& i$ o    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
4 a7 z2 J' p5 t) ]8 ]1 Q! Y2 S    m_fAvgThreadTime       = 0;
$ y2 d( A* V# \) u! k    m_fMaxThreadTime       = 0;</P>
<>    m_dwServerReliableRate  = 15;
8 _5 a& Z0 C6 U* w# b    m_dwServerTimeout       = 150;
; v% |8 [" p' q    m_dwLogLevel            = 2;
, `" m0 U* m7 V: x: {3 H1 R! O    m_pMaze                 = NULL;</P>
<>    m_ClientNetConfig.ubReliableRate = 15;
4 p( C2 r6 R$ L: ]! ~& d' V    m_ClientNetConfig.wUpdateRate    = 150;
    m_ClientNetConfig.wTimeout       = 150;</P>
6 W+ B- j; V: c' ~% E0 {+ B<>    m_ClientNetConfig.dwThreadWait = 0;</P>
; m! w. o6 a2 w% C* Q, Y; \5 o9 k<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
4 f$ @: h/ S. L    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
1 j; L' M$ h7 `  I    {
4 k# t* s0 L* Y: |3 e        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
, f2 _- x. K' S0 u        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
7 _! q/ e. a2 X9 B}</P>
5 ~) n" r* K/ D6 s1 Q% ^4 G
<>
//-----------------------------------------------------------------------------
// Name:
3 A& A+ _8 o1 a# K9 Q// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
, K5 k# ~/ |1 r$ w! M7 g3 U; Z8 v* k    m_bLocalLoopback = bLocalLoopback;
* y3 s5 x/ D4 N' C9 Q/ Z% Q    m_pMaze = pMaze;
    if( m_pMaze == NULL )
; T9 H7 n) I4 }        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
2 t) Q  O7 W0 s; M1 q7 J, U+ M- ]<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
8 e" l# m: v" ^" h* b; \# g4 o( p1 b    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
' s  a6 y& u2 Z<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
7 n$ [# C1 O0 g+ L. m    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
4 }$ i7 K% C5 }5 K) }- p1 e        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
    if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
0 H  r1 `9 O% y6 x7 q- o% P# u$ h& W        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>
/ T# Q2 d4 I+ \+ v1 @% S, b<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
    m_dwMazeXShift = 0;
    while ( (scale &gt;&gt;= 1) )
        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    m_dwMazeYShift = 0;
. _3 K; l5 X& l2 s7 d7 Q& k    while ( (scale &gt;&gt;= 1) )
        m_dwMazeYShift++;</P>
<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
4 e; z; b7 g7 S+ k9 ?* a        ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeYShift) != m_dwHeight) )
        return DXTRACE_ERR( TEXT("Maze height and width need to be power of 2"), E_INVALIDARG );</P>
<>    // Initialise the player list
3 L/ a0 s* a" B' J    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
    m_pFirstActivePlayerData = NULL;
    m_pFirstFreePlayerData = m_PlayerDatas;
  s0 i3 ]4 R6 W. D5 W9 G1 |6 [    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
( V7 p0 U$ k3 m- d        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
9 f% Y% D0 @- {! [5 D4 L$ Z0 V/ \        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
- h: M$ F3 `5 C& }. S) r6 M1 H7 n& u    }</P>
  o; d6 B: M5 t/ @) A8 H<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
4 C# ]- j3 K: e    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
    m_dwActivePlayerDataCount = 0;
/ X3 D3 |9 l5 `" v/ Q    m_dwPlayerDataUniqueValue = 0;</P>
5 L1 u7 W5 \% k9 e2 y" R8 i<>    // Initialise the cells
    ZeroMemory( m_Cells, sizeof(m_Cells) );
    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
% h1 W7 ?) w4 G! x! y$ j<>    return S_OK;
}</P>
; V5 n) a4 D8 f+ |( L9 z
7 q& n) D( a' A<>
//-----------------------------------------------------------------------------
// Name:
6 a' p+ r8 n3 B* C// Desc:
//-----------------------------------------------------------------------------
0 v' S# e  h* r% z4 d/ ^6 r3 F) Tvoid CMazeServer::Shutdown()
: p2 y6 Y' @- D" u) O1 q$ L( q# m{
}</P>
- N/ M8 j2 y4 p. X1 [4 \, x
<>
: i& e, Q) \: F) O//-----------------------------------------------------------------------------
, e$ |7 Y, Y$ L3 n" C4 Y( n// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
; v* F; A! Q% M0 a: w{
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
/ n% m7 k+ B9 e/ Q6 r0 y                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>
9 _' P6 c$ E9 F7 ~0 t: A
<>
//-----------------------------------------------------------------------------
// Name:
' |( q, o) m6 |0 b* R// Desc:
3 P+ v/ W/ A3 B! ~) P& M8 M2 k//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
8 [( Z# t" x7 D: Y! d8 U    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
4 c% @# q& e  q/ r}</P>
. f1 u% q  t! H
<>
( |+ @$ G7 A3 u  V9 s' b; M//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
- L1 w% D' S, W( H7 v{
+ C, W1 d1 _) v2 [% m    if( x == 0xffff )
        m_OffMapLock.Enter();
* t* f" L1 G/ \: f  l    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
. _& u3 h0 _+ o. v  `
$ d) `# E5 b$ L<>
//-----------------------------------------------------------------------------
( `  V4 ?$ Q, `% l- \// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockCell( DWORD x, DWORD y )
! v/ i- l$ X. {5 q, N! k{
    if( x == 0xffff )
1 Q: U7 q: k4 u9 B" b# w$ Z9 ^        m_OffMapLock.Leave();
: \' |" f6 u9 ^# E$ r    else
5 \  ?3 F! l0 ?7 @7 N+ r        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>

$ d( p8 A$ }: k% ^<>
//-----------------------------------------------------------------------------
; R# _4 [& H5 x3 g9 L5 v- e// Name:
// Desc:
6 ^9 w. n9 W" i7 l//-----------------------------------------------------------------------------
8 C6 P" k6 M' C5 Fvoid CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
; w7 C/ i4 t4 P: ?6 e; O( U( w    if( x1 == x2 &amp;&amp; y1 == y2 )
  K* N+ w# b: f  [/ h    {
% S+ [* u* ]) R( N/ v1 T) X        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
" f! M, {  u1 K+ a& `+ p( Z        else
            m_OffMapLock.Enter();</P>
<>        return;
! M( H& v; v( P" [0 C% ^8 h    }</P>
$ T0 R- {! v: ~' O4 j<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
6 x% Y. Z8 p/ u1 f5 i/ _, L    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
% k1 N. O- Z- {# }& T5 E5 {    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
) B5 D/ a+ o) A* [9 Y<>    if( x1 == 0xffff )
    {
        m_OffMapLock.Enter();
1 J$ ^! |+ j, D% ?: [        m_LockGrid.LockCell(x2shift,y2shift);
    }
/ c# R+ m# M1 C0 d  {( e) t0 {    else if( x2 == 0xffff )
! w$ p7 U- o3 `    {
& J3 e+ w: g. X5 y1 Y( ~* g        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
9 D: g7 G% i; `: e    }
    else
: t% S7 b/ C% \* g# D    {
$ J1 U2 u! s9 T. a        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
* G% M( L0 p, x1 a}</P>

& X. {- S, T' Q) j( A<>
//-----------------------------------------------------------------------------
/ [& z- t. w1 G, ^. [8 x/ _// Name:
; T+ e0 T4 ~' t$ U! r8 ]$ Z6 n1 o// Desc:
//-----------------------------------------------------------------------------
$ k7 r8 J, H2 ovoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
7 M6 Q/ T7 B* ^+ X4 s, D5 c, ^{
    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            UnlockCell( x1, y1 );
        else
            m_OffMapLock.Leave();</P>
<>        return;
    }</P>
<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
: x( I% F& q" o$ q+ ?    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<P>    if( x1 == 0xffff )
4 Q* z& t$ m+ l8 r9 a    {
& e* V( k  {( O8 g  P, l        m_LockGrid.UnlockCell(x2shift,y2shift);
        m_OffMapLock.Leave();
    }
5 `! _5 J. _$ w1 ]/ M5 v: [    else if( x2 == 0xffff )
) s: H# U" f5 O' _6 [7 u    {
# K8 W0 E% ^, i        m_LockGrid.UnlockCell(x1shift,y1shift);
        m_OffMapLock.Leave();
    }
    else
    {
3 ^' H( V$ f: A  y6 z0 L0 N" s0 h        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
& a0 g! q' i# ~/ C( [% \  o- R    }
}</P>

<P>
//-----------------------------------------------------------------------------
+ ~% H/ Y& G& t+ u// Name:
- s+ k9 ?8 c; ]) t; O+ G// Desc:
//-----------------------------------------------------------------------------
1 X; B+ ~9 y0 Jvoid CMazeServer::OnAddConnection( DWORD id )
{
    m_AddRemoveLock.Enter();</P>
. E- f- k) X) ^+ ^# {9 o8 u0 _2 I, f9 n5 ~<P>    // Increment our count of players
) V- X8 c& V7 Q8 k' p    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
* `) p8 P6 o8 I7 i2 o8 f        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
5 e6 f* s# g+ x+ C1 V9 i( F; G    }</P>
2 f  N3 G/ G0 `* o& M, u<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
<P>    // Create a player for this client
( ^( [+ o' [* ?    PlayerData* pPlayerData = CreatePlayerData();
    if( pPlayerData == NULL )
    {
: A7 \8 F1 e+ _        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
        m_AddRemoveLock.Leave();
; I& n7 N; W4 I" M. K. K( E; ^: H; D        return;
    }</P>
<P>    // Store that pointer as local player data
* P; n$ ^$ t( H8 [    SetPlayerDataForID( id, pPlayerData );</P>
<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
    ServerConfigPacket packet( m_ClientNetConfig );
9 [8 }, i" N( L    m_ClientNetConfigLock.Leave();</P>
, y. h- f* A9 |! W<P>    // Send it
    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
( b' C/ N5 B# a7 E; `7 q0 u1 z<P>    m_AddRemoveLock.Leave();
}</P>
& ]" l: K' _+ w' s! b. y" J7 a/ W3 K
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
$ I& Q" l$ k5 A& }3 V* Pvoid CMazeServer::OnRemoveConnection( DWORD id )
{
    m_AddRemoveLock.Enter();</P>
7 M: H0 k" ^+ P# H) o2 ^<P>    // Decrement count of players
    m_dwPlayerCount--;</P>
/ A  n. _$ n3 ?) ^% z/ q<P>    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
1 S1 a* M! }+ ~  y9 w- R<P>    // Find playerdata for this client
9 `% E& O9 h% b2 A    PlayerData* pPlayerData = GetPlayerDataForID( id );
    if( pPlayerData != NULL )
    {
, o' m; o5 l% |& W4 ^        // Destroy it
% v6 D/ N* w1 D0 L        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
    }</P>
* n' R1 R* q& Y7 m( b9 ]$ n  ]<P>    m_AddRemoveLock.Leave();
; k* T" u3 ]+ o+ L# I}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
8 T9 {( o, s5 a9 X* c// Desc:
$ X3 I& I6 |8 a9 `//-----------------------------------------------------------------------------
( ~; z9 W5 [5 R4 M- K+ CHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
{
0 V) f3 J- ~1 X    BOOL fFoundSize = FALSE;</P>
<P>    // Increment the number of thread we have in this process.
    m_csThreadCountLock.Enter();</P>
<P>    //Get the start time of when we entered the message handler.
- U1 X3 z+ D/ }- ^( f, T    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
6 f! _, I# c8 P7 ]' x9 d<P>    m_wActiveThreadCount++;
    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
  Y; j7 D3 u  ?! }( g' `   
/ q& o5 y! X1 g( C5 I    // Calculate and average.
* s' y  T! ^0 n& K    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
    m_fAvgThreadCount += fdiff/32;
   
6 S" v: I0 i3 h6 {& {6 o; y) I    m_csThreadCountLock.Leave();</P>
% U$ O0 K' i8 |1 B' Q7 [<P>
0 C9 W1 r; {& s    ClientPacket* pClientPack = (ClientPacket*)pData;
! n9 e! q7 L% I; N    switch( pClientPack-&gt;wType )
% G& n" E6 [, B    {
& U* z* X9 z0 y2 r4 s' }        case PACKETTYPE_CLIENT_POS:
            
            // Check to see if the packet has a valid size. Including
            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
9 N) a/ t/ p, o8 E                fFoundSize = FALSE;
9 F* v) @0 x6 c            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
                fFoundSize = FALSE;
            else
4 s! Y0 b4 M8 @6 v                fFoundSize = TRUE;</P>
8 o& U/ U) I# _4 q1 z7 r<P>            // If valid sized packet, handle the position.
( L! ~8 K6 ]9 Z3 m, M' L8 `: G6 V            if(fFoundSize)
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
5 }& t: [+ |* r0 k, P9 [6 z! @" `            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
            if( size == sizeof(ClientVersionPacket) )
' m  K; i) d; t7 z4 c( x                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
2 B8 B+ N" A/ u, L<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
<P>            break;
- e: `" m0 E3 b. O1 l! R2 z        default:
& h( ^" h% k6 ^$ h' ^+ L8 {            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
    }</P>
<P>    //If the user wants to hold the thread, Sleep for given amount of time.
* f$ x9 C4 I" v  f    if ( m_dwServerThreadWait &gt; 0 )
1 t( o! q; E/ z6 e; |, q    {
        Sleep( m_dwServerThreadWait );
- [- [1 R2 y5 ?$ ?/ u' E4 i) [    }
% |  a4 Q9 ~9 u! p5 `7 K: M   
, k8 w+ |- t6 U% d, B5 A    // Retrieve thread data for this process.
    m_csThreadCountLock.Enter();</P>
<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
    m_fAvgThreadTime += fDiffTime/32;</P>
<P>    //Get the Max time in the thread.
, \, g. z5 k2 g, b    if ( fDiffTime &gt; m_fMaxThreadTime )
  |, c. A( x, Y2 g7 g6 B& j  [6 E6 }    {
        m_fMaxThreadTime = fDiffTime;
    }</P>
0 u+ q/ B  @" I& c7 u<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
}</P>
2 p- V( ?3 K) p% x
. q% h7 R  _1 q) @+ z  O<P>//-----------------------------------------------------------------------------
- c% [) [" Z. V. W- \// Name:
6 j* O. o' m% \! c* i! B// Desc:
* _6 j5 Z- y' s3 u0 Y//-----------------------------------------------------------------------------
  V2 i" c- u6 k5 }BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
{
    BOOL fFoundSize = FALSE;
    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
& Z+ h" W! B: `* e- _   
! o$ j/ ~% P' @7 o5 [/ g$ l    // Check through the array of valid pack sizes.
2 o3 f, D, i6 c    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
" s4 G3 ]! [7 [9 S' C& q* p% T/ d    {
        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
) f4 U. y& @4 I" _9 K        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
7 F7 N5 o* P) U. a            {
                // Found valid size in the array.
                fFoundSize = TRUE;
                break;
& b4 ^. |' W$ K. Q# y3 m' M) M            }
% u$ Y2 M( p! L6 e9 q            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
6 ]4 V+ q8 W6 k! X/ D        }
% a+ R* V& q8 R5 |. W5 d    }
    else
    {
        fFoundSize = TRUE;
    }</P>
<P>    return fFoundSize;
# @. R, Q1 W: R) Y" |}</P>
1 R4 Q( e* j  M1 V2 `# N# T<P>
//-----------------------------------------------------------------------------
// Name:
4 R/ M8 P: a6 O! |  Q6 z// Desc:
& ]& Z! s' |/ y5 c//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
6 i' q: s2 b" m/ y( U: N# g& _7 o: C, w{
( U3 q. F, C- ~) k    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
4 J. x& e2 \  x5 g}</P>
# u5 ^. A, w  Y( y1 i
1 z4 I( k: ?* K  W, M* _<P>
//-----------------------------------------------------------------------------
( I  K& I4 N/ P: T! Q// Name:
// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::CreatePlayerData()
4 v: ]! r( K2 Y8 N* M' W  o6 f, X{
; j1 H1 B7 J6 v7 D' p    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
' \7 }) D6 `3 c: z    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
* @8 |7 U& l3 b* @8 _9 t    {
+ s5 x2 I; Y' y        LockPlayerData( pPlayerData );</P>
# I- r; d  \, V! x$ y: ]# U<P>        // Got one, so remove it from the free list
( d2 K2 p6 _/ k$ s        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
5 l  N, J5 P! i7 `7 x: t7 t        if( pPlayerData-&gt;pNext )
) s. X" a4 m' k# l7 a            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
0 m3 T7 l* R( S3 D, I. h% w$ P<P>        // Add it to the active list
( g/ E3 W5 H+ u4 S( D        if( m_pFirstActivePlayerData )
( n9 K2 }* D' d: p1 C+ _            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
. w( c% m6 O+ |7 Y" e        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
9 D' ?! s" m( p& o0 t4 Q        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
3 r  d: g7 j* X        m_dwPlayerDataUniqueValue++;
6 D/ M! [# x- f6 b6 t5 e) `) V3 d        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
: z+ e0 P: V' i0 `' o, K6 P<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
        pPlayerData-&gt;NetID = 0;
. L; e4 ]0 F- q, r6 O: {        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
4 Y# _& I% K; t# W1 V3 k( a5 j<P>        // Insert into the "off-map" cell
0 A. q1 I& t9 w2 ~  {/ e        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
7 j2 p( _! C& c0 z6 t# T) z        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
2 K* _' Q9 d+ g  ?5 Y  e+ _        m_OffMapCell.pFirstPlayerData = pPlayerData;
) W9 \9 w% C/ H. _        m_OffMapLock.Leave();</P>
<P>        // Mark as active
' X5 }% Q3 G" Q5 B        pPlayerData-&gt;bActive = TRUE;</P>
$ s8 T& U& u/ S+ j<P>        UnlockPlayerData( pPlayerData );
    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
3 p/ M) v& l5 X; ^/ F<P>    return pPlayerData;
2 n# D! v) Q2 |* M" b" u  Y}</P>
3 s5 s4 a- H) g
<P>
5 W' J% B' F& C  b* I9 ~//-----------------------------------------------------------------------------
& H- J6 s/ g+ `. E6 d// Name:
* _6 F0 p1 W4 B3 D// Desc:
# h8 ^4 W* o" i+ @# ~//-----------------------------------------------------------------------------
& ]! c# w; r0 A8 S* ~# Y# q' avoid CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
; K8 A* `$ ~! w, A5 w9 @) P$ c* Q" _{
+ k$ @6 l) ]. c$ r- ^& ~5 R# K    m_PlayerDataListLock.Enter();
    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
    RemovePlayerDataFromCell( pPlayerData );</P>
<P>    // Mark as inactive
    pPlayerData-&gt;bActive = FALSE;</P>
<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
/ c6 J1 M; H: P1 F    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
<P>    if( m_pFirstActivePlayerData == pPlayerData )
        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
5 l1 K; ^8 r3 x* o+ B1 J<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
0 ?9 ^4 z' W" q. b: L  c    pPlayerData-&gt;pPrevious = NULL;
5 c8 ?1 Y4 e1 |& Y+ l: V( [    m_pFirstFreePlayerData = pPlayerData;</P>
8 o) h7 n' R( ~0 I! H3 h<P>    // Update count of players
    m_dwActivePlayerDataCount--;</P>
<P>    UnlockPlayerData( pPlayerData );
  [: X' y: @  S7 w' @    m_PlayerDataListLock.Leave();
# w- a' m  J$ s, D# Q# Y}</P>
2 \( k7 n7 w1 @" e% d/ ]* g
0 s  h0 z/ l7 R6 f  m. _/ H/ F, ^<P>
- i! W4 }1 k; M2 m4 h1 k0 s0 ^//-----------------------------------------------------------------------------
! b1 i! h/ b4 s4 M// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
, s# A/ B! G4 M' {8 `# d{
1 T! \! W8 n+ A) j, I    // Lock the player
5 Y, o4 A2 S% B$ v- d: E    LockPlayerData( pPlayerData );</P>
- k7 {" v0 T# A; V& ^<P>    // Lock the cell the player is in
* g& }- y0 o' [5 w# X8 N    ServerCell* pCell;
/ h! s6 ]7 g# Y4 u) W- z    if( pPlayerData-&gt;wCellX == 0xffff )
# s9 R/ g, o! G/ J    {
        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
4 v: y% a" _: a$ |; {6 }% M+ F    }
) G* S- t& I$ _, x+ D    else
    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
    }</P>
<P>    // Remove it from the cell
- N  b- j8 J/ J7 x! b, ^& z% a    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
    while ( pPt )
2 F) ^& p4 ]5 H8 L/ L1 \7 ~    {
7 A: X& c, W* l, P( d! }/ I        if( pPt == pPlayerData )
        {
            if( pPrev )
6 b: B9 Y; a. Z  n& q                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
% ^) a) b  B1 N  y8 I" s: j            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
' |& L( u. _; \: X& z1 |<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
6 P2 X8 ]# S/ m- R8 d5 U        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
4 D7 }& m5 V2 {) f    }</P>
<P>    // Unlock the cell
& H; F4 V! e6 X/ ~; Z    if( pPlayerData-&gt;wCellX == 0xffff )
        m_OffMapLock.Leave();
" o9 }1 e( w; _0 ~( T3 c    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
<P>    // Unlock the player
    UnlockPlayerData( pPlayerData );
9 q3 P5 r2 V3 g) @$ g% z) `}</P>

1 M' A0 f' _. F<P>
//-----------------------------------------------------------------------------
// Name:
- {( Q7 t7 z; w: s% J5 L! ~// Desc:
$ H6 g4 _; E/ b' j$ F8 w//-----------------------------------------------------------------------------
+ r  V' d' `4 R* n2 x6 q: B$ Gvoid CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
1 D# F( G: T6 A2 {( u& @& t" I{
    ServerCell* pCell = GetCell( pPlayerData );
    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
' x. \9 Q% Z9 R% _: T& B9 p6 r* Q    PlayerData* pPrev = NULL;
    while ( pPt )
    {
        if( pPt == pPlayerData )
        {
            if( pPrev )
" @0 I1 W6 P8 ]. E( O* a                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
, }7 r  R1 t1 m# {* ~% T5 {$ e                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
# o$ F" y7 p2 g* D5 ?            pPlayerData-&gt;pNextInCell = NULL;
7 |3 F+ _8 z2 ^# B5 `- _1 [1 x+ E            break;
        }
/ m' F+ v! o/ k$ A! J# |$ b        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }
}</P>
2 u/ @# k. R- k* l1 }
<P>
//-----------------------------------------------------------------------------
// Name:
5 I/ h6 v8 F* O% O  @// Desc:
% N6 @- g, V7 x$ B5 ?: }+ s//-----------------------------------------------------------------------------
void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
( w7 ]) g2 [+ X- J- J0 Q    pCell-&gt;pFirstPlayerData = pPlayerData;
4 y! p1 h! P3 @' G& S9 j: _}</P>

, h* r3 z: [0 ]: B! D<P>
* |. v# Z% @5 u! b6 Z" ^//-----------------------------------------------------------------------------
' Y$ A( U, f+ W6 D& e// Name:
$ b0 p' D, n8 m) m% V" U* \6 P// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
% L* Z3 c; i* v# P    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
" K/ w' E. }; L+ M/ d1 k    {
  u  p" ]# B6 C8 c* ~2 ~3 D        if( m_dwLogLevel &gt; 1 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
3 I% N* a3 g8 U$ L# q2 \( W        return;
    }</P>
  p3 H3 [) ~& |( H) M) X7 H<P>    LockPlayerData( pFromPlayer );</P>
<P>    if( FALSE == pFromPlayer-&gt;bAllow )
    {
        if( m_dwLogLevel &gt; 0 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
% F" ^$ O3 T7 v5 h2 ^/ O1 L        UnlockPlayerData( pFromPlayer );
* t+ P1 @9 _; \% V/ N        return;
; T7 A, A9 S1 P    }</P>
<P>    // Compute the cell the player should be in now
    DWORD newcellx = int(pClientPosPack-&gt;fX);
6 `9 f" h  o- E! Q1 W) w8 @: Y    DWORD newcelly = int(pClientPosPack-&gt;fY);
    DWORD oldcellx = pFromPlayer-&gt;wCellX;
  n5 l8 h7 p/ I8 z% y    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
<P>    // Have we moved cell?
. U! W1 _# h% K" ?    if( newcellx != oldcellx || newcelly != oldcelly )
    {
        // Yes, so lock the pair of cells in question
) v! [1 l5 V9 ?5 I" W9 Y        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
1 D3 }6 |+ z- K<P>        // Remove from old cell and add to new cell
        UnsafeRemovePlayerDataFromCell( pFromPlayer );
        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
' ~0 R  P/ ?  A& T  a0 {5 _        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
& }' s8 x* E1 ?    }</P>
<P>    // Update player position
    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
4 A6 o2 l3 o; c" e$ p# b6 I    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
! {& I( H2 h8 a    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
$ e0 G! A$ U) _- X" }. x; G" Y8 E<P>    // Allocate space to build the reply packet, and fill in header
    DWORD dwAllocSize;
    ServerAckPacket* pSvrAckPack = NULL;</P>
<P>    // Begin by allocating a buffer sized according to
    // the current number of nearby players + 4.  This will give
9 e# x5 R7 i3 A5 V2 q5 z; y) {    // a little room for more players to come 'near' without resize
    // the buffer.
" `+ ~$ b8 X% ?; C+ P' c: w    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
( [$ n" L  I+ l* D; V! Z, y$ {3 S1 m2 x<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
! R" c5 d- h+ l5 [    if( NULL == pSvrAckPack )
    {
! a1 X4 a! q# [+ Q        // Out of mem.  Cleanup and return
        UnlockPlayerData( pFromPlayer );
        return;      
    }
: Q  U, ?$ ^& u  R! `    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
% R2 H6 @; x9 T# s<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
: c+ y2 u1 M! N' r# V<P>    // Compute range of cells we're going to scan for players to send
. s) s8 b$ a$ v& L3 @: ^0 p    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
. ?5 N9 K8 @6 y# f3 T" E3 [    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
+ g1 Z+ }9 h2 Y0 D, e    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
<P>    // Lock that range of cells
    LockRange( minx, miny, maxx, maxy );</P>
<P>    // Scan through the cells, tagging player data onto the end of
- z: ^+ v; ^4 B( B( j% a    // our pSvrAckPacket until we run out of room
5 A, F# D! R6 o8 O    for( DWORD y = miny; y &lt;= maxy; y++ )
    {
        for( DWORD x = minx; x &lt;= maxx; x++ )
8 r. }! _; W" r: }* R, l" ~        {
9 q) n5 E! {8 |. U6 {$ Q( C            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
- ]6 b. s! q, p6 ], x            while ( pCurPlayerData )
" E" z1 ?. d$ F8 ^5 B1 e            {
3 Y( r# H0 r! m6 |0 T8 j                if( pCurPlayerData != pFromPlayer )
. D( Z7 f/ t) r) r2 l5 p                {
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
9 N- \# J9 w4 t, b6 ~# x3 J0 R                    {
                        // Make sure pChunk is where we think it is
  o$ o: y: u6 x7 \/ F                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
2 `8 A% V& c( _: n<P>                        // There are more than just 4 new nearby players, so resize the
4 S- R/ p( `* Q% G1 m- K( D                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
# Z2 i. Z" C1 m% B  I% ~                        dwMaxPlayerStatePackets += 16;
                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
                        ServerAckPacket* pNewSvrAckPack = NULL;
' H. t, D; e; l# Z* u/ `' J% C                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
- ?) n" d* v* z# Q                        if( NULL == pNewSvrAckPack )
                        {
                            // Out of mem.  Cleanup and return
                            free( pSvrAckPack );
                            UnlockRange( minx, miny, maxx, maxy );
& c% V' [# j/ c) [! I( k                            UnlockPlayerData( pFromPlayer );
: Z  C! U! D" o                            return;      
                        }</P>
<P>                        pSvrAckPack = pNewSvrAckPack;
                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
<P>                        // Make sure pChunk is still where its supposed to be
3 ~, h4 c$ D' ?! a" L2 F, G                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
/ `. Z% F7 [4 w' {$ j3 T% Y8 |                    }</P>
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
                    pChunk++;
                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
4 m& ^% {" R0 G, G, O* X5 K. w  @                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
) Y" g( y6 q4 ~1 }# T1 H5 Y            }
7 r7 U' r$ {$ A6 B        }
    }</P>
) c% c! i- u; L<P>    // Update the dwNumNearbyPlayers for this player
/ z' I6 b, t/ Y    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
7 U; i  }0 c" x! J* A# d<P>    // Unlock range of cells
" q% x( p, N6 E( E+ h7 d    UnlockRange( minx, miny, maxx, maxy );</P>
0 ?& t1 z. r. T* ~6 j5 P<P>    if( m_dwLogLevel &gt; 2 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
    }
    else if( m_dwLogLevel == 2 )
  {0 e! V9 G% Y  Z) i) |/ s' M0 e    {
3 l$ _  P$ l0 z1 i        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
8 Z% [- |! U) K& {; R        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
+ F9 B; q* B4 I# W        {
! h. P  w' j+ O" `; h7 g( p/ h            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
            pFromPlayer-&gt;fLastDisplayTime = fTime;
$ E8 ?4 s7 t' h, f        }
8 L  b& ~! U# a3 m5 k" x& p* Z    }</P>
6 D' }9 ^# g2 H. X* H9 j<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
4 s0 ]" |& x+ z9 v, [- x9 g<P>    // Send acknowledgement back to client, including list of nearby players
    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));
0 `' A) z$ C8 ]5 j8 K# I! S" v
    // Pack the buffer with dummy data.
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
; V, }' k+ ^, l- Y7 a        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
; T) I$ R6 z& b( D! p        VOID*   pTempBuffer = 0;</P>
<P>        pTempBuffer = malloc(dwBufferSize);
        if( NULL == pTempBuffer )
/ Z+ U) b9 r- H$ Z- v) y" ]        {
; h+ R1 s* X# K+ j+ i8 Q            //Out of memory
7 w' ]& B! ^: c+ r' K            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
: q' u  X" e4 X3 L; e, T            free( pSvrAckPack );
            return;
' I8 M  B& Q3 n% {9 p$ F- h/ V        }</P>
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
( x6 Z$ X  a* a4 s        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
) g& j! r& R! B, v- d# }' b5 j<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
4 s8 S1 M  L: N0 F   
2 Y# P: ?$ j* ?$ d' W        free(pTempBuffer);
- R1 C+ a4 |- E, f    }   
    else
    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
    }</P>
& |3 v" g0 |; z6 _2 w2 @<P>    free( pSvrAckPack );</P>
<P>}</P>
8 g" }' n& Z$ y3 j$ F4 i
; I0 S( y; o1 I. H, J<P>
5 u, c/ j, u7 q//-----------------------------------------------------------------------------
7 x+ i2 N9 M! U" Q7 G& d// Name:
0 \( }6 c% U; F4 J- z! K, S4 C/ S3 ?// Desc:
# o% o! S; d9 n! \//-----------------------------------------------------------------------------
7 U5 f; U. K. i& N, I/ evoid CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
1 N; Q/ [0 C. s& G    // Grab playerdata for this client and lock it
( l' {$ k/ c/ f  [$ c+ q9 V    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
) U( |( a( k8 q; O0 E+ p  Q    if( pPlayerData == NULL )
        return;
    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
6 V4 B. V  ~2 f+ V- p3 Q; D& v    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
- G; h% E2 `' W# ]7 g2 e; O<P>    if( m_bLocalLoopback )
7 T; m. h! T* t4 z; W+ L  b        pPlayerData-&gt;bAllow = TRUE;
    else
* l  f0 ^, p  p' G        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
<P>    if( m_dwLogLevel &gt; 0 )
" O0 A, d- L* Z) e3 r        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Client version=%d (%s)"), pPlayerData-&gt;NetID, pPlayerData-&gt;dwVersion, pPlayerData-&gt;bAllow ? TEXT("Accepted") : TEXT("Rejected") );</P>
' p9 W1 x0 K$ D5 s# q+ s5 l' i2 k& x<P>    if( FALSE == pPlayerData-&gt;bAllow )
5 C1 T; V1 B  z/ F    {
1 ~; ~- D9 ~, A        if( m_dwLogLevel &gt; 0 )
1 Q8 }" \) d0 |; o$ [0 h8 |6 [            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pPlayerData );
        return;
, X, M, `5 E& T' r' ~+ ]    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pPlayerData );</P>
7 c( ^% \+ x  d) b) n" {<P>    // Send acknowledgement to client that the client was either accepted or rejected
( H% Y) [+ V8 ~% v  _& J    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
1 e/ I8 {1 }* j. Z! r    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
4 W: Q( W0 S' i6 U}</P>

7 W, m$ n! F- N! A3 w<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
- q8 }4 L: T, ?BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
{
8 M0 c# X: d2 k+ E! o- W; v7 ~    switch( dwClientVersion )
    {
/ {+ d6 X- L# a5 C        case 107: // only v107 is supported
: B9 x% Q% J" ~6 z            return TRUE;
        default:
' ^1 P6 A8 F; q            return FALSE;
6 F9 R& m# P- R    }
}</P>

9 c3 |* K& n8 J; i<P>
//-----------------------------------------------------------------------------
1 d( ^3 h  C3 k/ f( M. Q4 A// Name:
// Desc:
) a# S: ]) D/ c  x; X- L1 p) T//-----------------------------------------------------------------------------
! m' u2 I' U- |9 ^% U5 Yvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
{
8 h/ `6 J, f. C0 H    if( m_dwLogLevel &gt; 1 )
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
}</P>

2 p: {: V& J1 L& W& w<P>
3 U: |6 |0 j2 S0 L1 F$ f; s; r//-----------------------------------------------------------------------------
// Name:
" O3 l; }8 j# o' ?& c& t( W// Desc:
" M: e  Z" s* K/ a& x8 g2 [//-----------------------------------------------------------------------------
DWORD   CMazeServer::IDHash( DWORD id )
{
, D/ {! G0 y) m    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
3 N4 S4 e, A4 c. D5 q    return hash;
}</P>

<P>
//-----------------------------------------------------------------------------
1 g% _" g8 K  z// Name:
" s) E/ d9 [. S; l9 m// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
, G3 |# P( I0 n; U6 E! z& S' v<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
" j3 Y( W$ c% o9 ^6 c    PlayerData* pPt = m_pstIDHashBucket[bucket];
    PlayerData* pPrev = NULL;
2 M2 w0 c- w' o% S' Y7 p    while( pPt )
    {
3 o% ]9 U$ r; P7 p1 c. g        if( pPt == pPlayerData )
9 X0 C0 _$ |( ^, z6 ]/ C            break;
        pPrev = pPt;
        pPt = pPt-&gt;pNextInIDHashBucket;
6 S( m& t2 |1 I. _- ?    }</P>
<P>    if( pPt )
    {
9 L: E' b+ g4 J        if( pPrev )
- a3 w4 C/ Y" z            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
* I3 Q( W7 H+ R/ {4 A" l        else
! n; p% J- S) G            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
  P9 w. S; S* U- E! U<P>    // Unlock the hash bucket
( Z" o4 @* M$ H/ X: u    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
7 ~6 g% Q, Z1 A2 A. ~: ?}</P>
9 R5 i: _7 l! G9 A4 S  _: I, _
<P>
% M% y  w5 j' V) t1 L$ Z//-----------------------------------------------------------------------------
// Name:
2 y! o6 v- c- y  }- I# b' T  c// Desc:
' `# I* e" W  J/ f//-----------------------------------------------------------------------------
$ X+ y% U. f% Y, T4 X, Uvoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
& T6 U  T/ n5 f$ |9 y9 u7 D/ G{
0 N$ t# V1 k; i( L9 u$ b3 k* c    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
, L: @5 M) {; G1 Q    // otherwise there will be a circular reference
    PlayerData* pSearch = GetPlayerDataForID( id );
9 U6 H; G8 _1 U7 h    if( pSearch != NULL )
        return;</P>
<P>    // Hash the ID to a bucket number
: o1 K( D3 Z2 w    DWORD   bucket = IDHash( id );</P>
' M& f* B5 Z8 @) |<P>    // Lock that hash bucket
$ Q$ W7 [( y* J4 Z; P8 m3 }    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Add player onto hash bucket chain
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
: r4 z* d$ n- k    m_pstIDHashBucket[bucket] = pPlayerData;</P>
6 J$ P  {! S0 Q( e* _<P>    // Store net id in player
5 n# f4 B# ^- r$ I- N    pPlayerData-&gt;NetID = id;</P>
<P>    // Unlock the hash bucket
9 ?& V1 z+ ], A+ p. j' W0 t5 }; }' X$ D    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>

' i1 n2 P1 C  l- N/ w/ b<P>
//-----------------------------------------------------------------------------
( B5 o( ?" b( i// Name:
, F% G& ]1 C8 l+ M- T  n$ x// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
0 }3 K3 [' P( |" \<P>    // Lock that hash bucket
# t' x( k1 O0 y* r. z    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
  U+ [6 V/ _3 E9 g    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
4 }2 s4 M' B# F! q<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
    while ( pPlayerData )
    {
        if( pPlayerData-&gt;NetID == id )
; G* M3 G# h' `3 W0 w            break;
        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
    }</P>
+ `6 d6 j. j. [1 m+ f0 O! G<P>    // Unlock the hash bucket
: Z3 n0 U1 L6 V$ Y2 v. @% s8 P' Y    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
7 ?0 Q4 e. `8 I! X<P>    // Return the player we found (will be NULL if we couldn't find it)
( @  v* \/ ~9 [. G3 V: _' s    return pPlayerData;
/ G: i0 x9 M3 G9 j# @5 M; m5 _9 j}</P>
4 i# G! k. i# @! g  {. o& m
, M5 Q8 Z% K1 f) u( Q$ c. T. a<P>
' a8 T9 q' P4 Z9 E) T//-----------------------------------------------------------------------------
// Name:
% k$ G( w( f, F. r' ]  c// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
  b) i- y9 e$ l" @5 ^//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
{
    if( m_pNet )
    {
0 l0 g  r! Q, `        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
# l/ X; p* z. M+ B: h        PlayerData* pOldestPlayerData = NULL;
! v/ n2 L9 V; v" J        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
7 Q" h6 x4 L/ c; I/ s1 l<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
        while ( pPlayerData )
1 D1 u' h: X  ~+ B( B        {
$ x5 l0 }$ Y: r: i( h9 }% T            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
            {
" p; ?* c2 B9 Q7 |8 O# @9 p9 {8 H                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
                pOldestPlayerData = pPlayerData;
            }</P>
) f$ A+ H8 K$ Y2 H1 y; y. R<P>            pPlayerData = pPlayerData-&gt;pNext;
        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
        if( pOldestPlayerData )
        {
! _0 V2 Y1 i8 i4 _1 j: U! z            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
& B2 t' R: @+ c4 U/ f" D7 d4 }            pOldestPlayerData-&gt;fLastCITime = fCurTime;
/ y# c6 @0 _4 b8 B5 r5 {. q        }
1 Q' Z. `& C( \. i7 H$ P7 u$ K        else
3 ?$ o3 L* x4 W9 T" h6 }        {
  `% C1 U- H: U! V- g$ G3 r3 V            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
% O' H8 \& ?- H8 O- @        }</P>
<P>        m_PlayerDataListLock.Leave();
4 r' X$ t0 x  |7 U: d4 q    }
}</P>

<P>
. u2 p9 M* W: P7 u! _( l4 n2 ]//-----------------------------------------------------------------------------
// Name:
  x7 L5 U9 i/ J, ]( {// Desc:
//-----------------------------------------------------------------------------
/ e2 a: s2 P, a0 M* Lvoid CMazeServer:rintStats()
{
8 Z9 |$ Z5 t6 I/ h; ]    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
2 \# d0 Z" l0 b& e9 Y                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
( O) _/ K& a1 u! b    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
                                    m_fAvgThreadTime, m_fMaxThreadTime );
    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
}</P>

) C7 r  M. d  S( y4 A<P>
//-----------------------------------------------------------------------------
// Name:
2 {1 x* h: X- {0 _8 L2 ~2 o! e; a// Desc:
% a8 \9 l) C0 G& Z# E  H//-----------------------------------------------------------------------------
void CMazeServer:isplayConnectionInfo( DWORD dwID )
{
    TCHAR strInfo[5000];
, p( \, n% Z* c7 }  P1 B    TCHAR* strEndOfLine;
    TCHAR* strStartOfLine;</P>
' `' z: B- b  L<P>    // Query the IOutboudNet for info about the connection to this user
4 F4 ]7 c4 O/ D! ]7 l1 ?, i3 l. d    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
<P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );
! y; i9 H  B# D% c9 J4 ^0 e. R    ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>
1 p( F  ^( t9 v% g+ Q<P>    // Display each line seperately
9 d$ K; H7 s! H0 ^$ S    strStartOfLine = strInfo;
$ b8 k* L, e+ L    while( TRUE )
* `- b! e% E, s: @    {
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
$ |/ z' m2 n; H2 ?1 `2 i; C/ J        if( strEndOfLine == NULL )
            break;</P>
  C/ I' s+ m7 m) f" D/ x; u<P>        *strEndOfLine = 0;
' Y* d5 S% u$ q6 N. e' G        ConsolePrintf( SLINE_LOG, strStartOfLine );
4 R- X7 x" U6 @( L1 Q. K: L        strStartOfLine = strEndOfLine + 1;
    }
0 H. }/ j2 E0 _7 Y9 H- D}</P>
  n8 F) G! H  j+ ]. K& Q. D
<P>
; I) s/ ]: e$ V2 G/ m//-----------------------------------------------------------------------------
// Name:
3 A8 m* p- z! M( D// Desc:
//-----------------------------------------------------------------------------
! X& X. r& J5 Q9 JHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
' ]$ \! c; ?) ]8 n1 k* r" F                                 DWORD size, BOOL reliable, DWORD dwTimeout )
& G8 Z) G5 E5 T{
9 ^: `; ]2 Q  G3 W    // Chance of forcing any packet to be delivered reliably
    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
4 F" l* g6 S; `9 q<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
- S6 I2 z1 t1 L}</P>
5 z, F/ n. y! y
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
7 C- j* Z% Q! R6 W/ ~2 {- S    // If we're up and running, then send this new information to all clients
. I( t( h8 J6 V$ F( g    if( m_pNet )
    {
/ X+ u$ e- |* e; [0 p' D        //Use the AllPlayers ID
6 ~4 \; w4 W, G        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
  N! x, I$ z/ d    }
}</P>

& `: R% Z4 M! }. ?. P2 R7 |<P>
7 }& P4 ^* k6 D3 B" N! y//-----------------------------------------------------------------------------
// Name:
# c0 v2 H, q. F, p' s6 w4 \& z3 E// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientReliableRate( DWORD percent )
5 |, i9 F) x& m/ Y, v{
" g  h# w2 z$ b3 F2 d5 A; h; e    // Update client config, and build packet containing that data
) O& w6 G: T1 n1 W( L    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.ubReliableRate = BYTE(percent);
    ServerConfigPacket packet( m_ClientNetConfig );
$ ]. e/ v9 B) q7 V1 o5 l    m_ClientNetConfigLock.Leave();</P>
3 d& e2 v+ M7 x# H4 t<P>    SendConfigPacketToAll( &amp;packet );
}</P>
! q7 b9 e6 w$ G
7 y9 q( K! ^, i<P>
- B2 s( P, ]; V( ^$ c7 n! T//-----------------------------------------------------------------------------
" d  n- v+ \" N7 l5 o# V- r// Name:
// Desc:
" i* c" y2 z! \8 Y, G& Z; ~9 `//-----------------------------------------------------------------------------
2 X' R4 I& ?+ z# Zvoid CMazeServer::SetClientUpdateRate( DWORD rate )
{
0 o  s$ J, W1 m! ?- Z% w    // Update client config, and build packet containing that data
& S( ], }$ _1 J0 [7 K    m_ClientNetConfigLock.Enter();
' t( f7 v) I6 a$ H  `    m_ClientNetConfig.wUpdateRate = WORD(rate);
/ _) {; J7 A- c) Q& a3 o    ServerConfigPacket  packet( m_ClientNetConfig );
) B- a  s9 |* Z    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

; @) l' p& i% s8 O<P>
% @) q  d, f* }- G0 _' O. v, ?//-----------------------------------------------------------------------------
// Name:
( a7 ]- u2 R! Y* `' v// Desc:
//-----------------------------------------------------------------------------
2 X/ n9 s- o0 r" Mvoid CMazeServer::SetClientTimeout( DWORD timeout )
{
    // Update client config, and build packet containing that data
: f+ ~6 i4 M8 p1 a    m_ClientNetConfigLock.Enter();
( X0 w: ]- V2 n    m_ClientNetConfig.wTimeout = WORD(timeout);
: k. I% `5 ?) k4 P+ z( j8 @2 O    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
6 J9 @/ U9 M" A( C<P>    SendConfigPacketToAll( &amp;packet );
}</P>
3 ?5 Q6 J$ k, c; F3 \
3 P# E3 k" k1 @6 p- l8 ^<P>
6 t( o, J( D$ {: S3 _: K//-----------------------------------------------------------------------------
// Name:
// Desc:
$ H$ n) L7 o" @. ]7 F//-----------------------------------------------------------------------------
/ D1 g$ ]& _/ R7 [, Vvoid CMazeServer::SetClientPackSize( DWORD size )
{
    // Update client config, and build packet containing that data
+ [1 K: K& g" _3 h' P    m_ClientNetConfigLock.Enter();
4 ~% R5 y0 f  e) t2 M5 i; W+ [   
- N8 _/ X1 c3 Y    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
1 k+ c9 U5 l, \, @    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubClientPackIndex = 0;</P>
6 ^  L9 _. h8 ~" x3 D<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
! ?& Q5 Y1 `& Y' T# E    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
- w$ W, U! v" g% _* X- W7 h//-----------------------------------------------------------------------------
# F. a: S9 P3 N& Q  S  f9 y; B( R// Name:
1 T3 O' l5 G  O! s// Desc:
' X* Z! s2 ?# ^7 [9 X( z//-----------------------------------------------------------------------------
void CMazeServer::SetServerPackSize( DWORD size )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubServerPackIndex = 0;</P>
<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
# T$ r- x8 e; v0 G/ e! n: t    ServerConfigPacket packet( m_ClientNetConfig );
! G+ ?7 h2 m. R. \: p+ P1 I    m_ClientNetConfigLock.Leave();</P>
# X# _# ~: E$ k5 X5 I& R& ?<P>    SendConfigPacketToAll( &amp;packet );
' A" o1 `# Z9 E}</P>
<P>
//-----------------------------------------------------------------------------
6 F2 G- Y; d: ?3 g$ w0 o4 j4 u  l// Name:
; R, b) y+ Q* I) S9 B// Desc:
1 h& d1 Y! c3 X! J' a. ~//-----------------------------------------------------------------------------
+ c, y0 X7 q# W% Uvoid CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
{
, u# n; b0 O. e( E& z9 I  g    // Update client config, and build packet containing that data
, S  X, v1 c6 N5 Z    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
( W8 J+ d& x& f# z5 ?* ]    ServerConfigPacket packet( m_ClientNetConfig );
1 r/ g& x' W& _0 T& H. v9 |/ A& j- M    m_ClientNetConfigLock.Leave();</P>
7 }: X7 A! n! z! c+ L<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>