[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
<>// File: mazeserver.cpp
2 ^- T( Y- N! L+ f% @5 O, o//
% T- A4 F* j/ ^$ U* T// Desc: see main.cpp
//
1 p% h" l; z1 D' N8 K' J// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
# ^( D0 @4 b; f//-----------------------------------------------------------------------------
) {& v/ N4 I& m: G( ^1 f#define STRICT
#define D3D_OVERLOADS
% W4 U% D- a7 G* w9 [1 s#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;
! Q8 A$ T0 P7 o5 f9 Z; c& [2 Q#include &lt;dpaddr.h&gt;
#include &lt;dxerr8.h&gt;
#include "DXUtil.h"
#include "MazeServer.h"
#include "ackets.h"
/ N7 U  M% ]' t0 L- f#include "Maze.h"
#include &lt;malloc.h&gt;
#include &lt;tchar.h&gt;</P>

0 [. M  T4 f/ m/ U* ^% c<>//-----------------------------------------------------------------------------
// Name:
6 N3 |! F; X* R7 j" n4 I( W3 r! I// Desc:
6 q- C% {& J. I3 _" ?1 t//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
0 ?* ~8 s% _* L4 f/ |5 U{
    m_dwPlayerCount         = 0;
  S& E* m- ]9 F& ~, b/ a+ E- V   
    m_wActiveThreadCount   = 0;
& W( H/ c0 B1 q) M    m_wMaxThreadCount      = 0;
  S" S2 b* Q: p$ ~# `/ G6 }! B* d" K$ d    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
    m_fMaxThreadTime       = 0;</P>
<>    m_dwServerReliableRate  = 15;
4 o) p. R7 Y. A' x. L    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
5 m! r$ L; H, H: l+ R9 Q) Z    m_pMaze                 = NULL;</P>
% U. R+ E9 Y, B& N<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
( P. Z- }* |& u2 d  W- }    m_ClientNetConfig.wTimeout       = 150;</P>
<>    m_ClientNetConfig.dwThreadWait = 0;</P>
4 @# N+ N/ g/ }- d% @7 ?<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
1 f9 _2 p5 c% ~& x. i6 k; C    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
+ `9 M7 z$ P$ E    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
. H1 F8 m! e( }2 ]8 }6 ^# g4 H        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
  x0 l7 @% K4 m' t. P. H6 b}</P>

5 t: i' b, B. f. t4 P<>
' K/ ^- D+ i: Y$ r5 u4 D  e. x& U//-----------------------------------------------------------------------------
, O0 n* w& H1 p1 ]: R' \3 f) U// Name:
// Desc:
//-----------------------------------------------------------------------------
9 X# H7 d; A, p0 c0 M/ IHRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
7 K2 T% }3 \$ s5 |* H    m_bLocalLoopback = bLocalLoopback;
6 |1 k8 Q6 v6 R    m_pMaze = pMaze;
    if( m_pMaze == NULL )
        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
# Q  A! ~8 }/ O% G+ p" k3 M5 ^* j/ [<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
' V7 W/ E- k, O: e' Z& Z    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
" N, |7 a7 k) j' Q7 X8 Y. C<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
6 J7 b+ A# ^# o- n+ T* o  }7 ]- ^8 S. V    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
0 _! V, \  r- ?    if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>
<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
    m_dwMazeXShift = 0;
) Q* r3 N" Y% b: \    while ( (scale &gt;&gt;= 1) )
( c0 F  u/ o- k6 w        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
: Z) j% r4 P- }" K1 K9 c        m_dwMazeYShift++;</P>
<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
- f1 h" G5 p0 X$ ^& t8 |        ((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 b* O0 h' u* F2 M    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
4 c( k' B1 a" d    m_pFirstActivePlayerData = NULL;
. `6 b& z( n6 s9 O    m_pFirstFreePlayerData = m_PlayerDatas;
5 v4 U) I' y/ w' u2 m9 z    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
/ F4 r9 z' ?: s1 L' K    {
        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
    }</P>
<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
/ V4 G. r; k- i$ [! _& A  X: f    m_dwActivePlayerDataCount = 0;
( E' v  J2 J4 V, r8 V4 U: B& H    m_dwPlayerDataUniqueValue = 0;</P>
0 I0 ~" C. K3 R1 u( c; B1 T<>    // Initialise the cells
$ A2 `9 o! q4 z' J# _# C; e    ZeroMemory( m_Cells, sizeof(m_Cells) );
1 n1 b) u! \+ k3 P3 X7 z1 k. _    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
: l5 ]. }* ]0 @  L<>    return S_OK;
}</P>
/ g, W0 \3 h3 \2 r/ Q5 r9 S
8 J7 ^* p& P, C% R<>
! i' V' w' l  v/ W- t//-----------------------------------------------------------------------------
% @8 c5 y( @& T% K// Name:
3 [  T" ~4 D$ v* H$ P// Desc:
//-----------------------------------------------------------------------------
) G0 D5 K+ L; r7 S) t# ivoid CMazeServer::Shutdown()
  M' q9 r$ Y7 R9 i{
! A! v1 j$ ^$ W& M  W}</P>
- a' ~; n( I* E1 D' T% D
<>
! i. j9 J  {% d* s3 i; |/ ]( ~# A! Q//-----------------------------------------------------------------------------
" {% n: Y( e4 y: W// Name:
, Y" N+ m+ c# B0 C4 }5 S) m// Desc:
% K+ y/ V/ f# k2 R. x//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
, O, f- K. V0 \( F+ S    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
9 W5 e& m: Y3 \! G3 V1 M+ y) i                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>
% q8 [) x# J) E2 N
6 r/ Y$ f) P+ H* B<>
1 E- B6 R: e3 s# l) t1 ^//-----------------------------------------------------------------------------
// Name:
// Desc:
) z1 S" q9 A9 u# y4 H: B. {//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
& a  F  ?" ~$ e% y/ g) G/ X1 J{
    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
, r; ]" l% u/ V2 S# A  g3 j}</P>

<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
{
$ A& o& ~. |1 B! ]8 G    if( x == 0xffff )
2 v6 B7 h, J" w& a$ c$ Y        m_OffMapLock.Enter();
! L# Y- B" G! o" U- E; Q# r    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
5 J. `* E- L/ `* h}</P>
- i0 z# O3 y' Y9 U& H6 m* o
0 k4 |3 P& Y2 ]; Q! Z<>
& n. {/ k* u# w9 T% i8 x+ L# _//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
2 M2 s8 J; w' k: Ivoid CMazeServer::UnlockCell( DWORD x, DWORD y )
1 t$ c2 v$ S2 f9 y& F+ U+ e{
3 W# r9 P! G( x$ m7 u& R/ a& {    if( x == 0xffff )
        m_OffMapLock.Leave();
    else
. I/ j0 u& [, _5 S  o        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
1 E. F& K+ ]* c4 B}</P>
! x7 Y, i1 V0 d
/ e+ Y; C1 f2 d) ]1 x<>
//-----------------------------------------------------------------------------
  ]$ R- F0 W5 \/ x; ?& m// Name:
5 J$ k# }9 o1 e* z9 i6 k) `) d// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
" I; z2 J5 \1 G  c3 Z/ r7 K+ ^7 p6 o{
' A& f4 E0 I* M  ~    if( x1 == x2 &amp;&amp; y1 == y2 )
5 F1 [0 v4 Z/ C6 n& ]; ~" @    {
; h6 f: }1 _. `$ m2 x4 c3 ~, x        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
+ a$ `% }2 a2 }        else
; N* l% Y# K  q1 i            m_OffMapLock.Enter();</P>
) x& p) f  r* s, T) J/ Z<>        return;
    }</P>
0 i6 u6 b( E$ g1 N( f; c  d- F<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
3 @/ _  U: E' v9 T  K, k- l: C    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
, Q8 f  D& U  n4 F    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<>    if( x1 == 0xffff )
    {
        m_OffMapLock.Enter();
- {% @0 _& q7 l& z4 l$ F9 _6 x6 z        m_LockGrid.LockCell(x2shift,y2shift);
+ e9 P! @9 ?& K4 m' ]4 t$ Y    }
5 G2 V( H& w1 E4 F3 f7 V    else if( x2 == 0xffff )
    {
9 C1 j2 \! n4 j        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
    }
    else
    {
6 Y6 r' X; F( Z( p$ X        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
}</P>

8 P( s, K2 i, ?3 W<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
0 ~" F3 T# G! X9 b2 L" E1 n//-----------------------------------------------------------------------------
& D8 u( K  U+ s% ?/ L! B& ]" d" Wvoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
# }5 c& A8 N& b{
8 p7 T5 b9 u! p' ]! f    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
) }+ [* e. c4 a2 L+ m9 O  B            UnlockCell( x1, y1 );
        else
* G( o$ F/ g# \            m_OffMapLock.Leave();</P>
& L0 l! A" G2 q; B3 p* P1 U<>        return;
# w: H" e. l( T' d/ P+ l0 S    }</P>
2 C  \. q( T0 i4 B+ S<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
% g0 z* z4 d$ W. ]    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
9 Q# M: Y5 |8 k& _* v8 y    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<P>    if( x1 == 0xffff )
% e: B2 x6 m5 S3 F    {
        m_LockGrid.UnlockCell(x2shift,y2shift);
8 E# x- V5 K/ ?! G        m_OffMapLock.Leave();
    }
    else if( x2 == 0xffff )
5 G/ T" V* `) ?" ^    {
% K# i* g8 l; I        m_LockGrid.UnlockCell(x1shift,y1shift);
        m_OffMapLock.Leave();
5 ~( _/ K! }% Y: |! f3 k# G    }
1 z& d  G# _9 `  Z% n- N- y    else
    {
1 T7 _2 F( A# @1 A4 V& l5 A        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
+ }% n; o- k, Q% Y}</P>
# \( f  M  P/ b8 e& d
. y" M" k# b4 _$ K( s3 h% Z<P>
//-----------------------------------------------------------------------------
8 K7 V# d5 Z$ _( H) t& V// Name:
+ j2 ^3 z. l* Z/ q) D( }// Desc:
//-----------------------------------------------------------------------------
% E: c! q1 T' g7 T# E' _: ~void CMazeServer::OnAddConnection( DWORD id )
{
    m_AddRemoveLock.Enter();</P>
: K) R5 _' D5 a- Q) T<P>    // Increment our count of players
    m_dwPlayerCount++;
2 `+ ^6 R0 P: k2 a  H) Z    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
% c5 Y0 |3 [3 b3 k<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
# |4 r# a: b8 O  @        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
<P>    // Create a player for this client
    PlayerData* pPlayerData = CreatePlayerData();
    if( pPlayerData == NULL )
! _' g" ]" W$ o    {
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
( y; Z  N; u" Y7 d7 g6 z1 i) B        m_AddRemoveLock.Leave();
        return;
; n& v8 `, T7 m  w9 n6 i    }</P>
7 L1 ]; |1 y8 h* x5 a; z( W<P>    // Store that pointer as local player data
! D: y8 u9 J: d; t; }& \    SetPlayerDataForID( id, pPlayerData );</P>
<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
2 c! U2 n  U/ Y! ^# I    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    // Send it
6 v$ b! S% z, d% _/ f+ ?    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
<P>    m_AddRemoveLock.Leave();
+ t2 {! B9 g1 s8 X% l}</P>

1 b5 E0 N" s  j' p2 Z  J1 D. R<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
, @( D" p- d% z/ h0 |//-----------------------------------------------------------------------------
void CMazeServer::OnRemoveConnection( DWORD id )
{
    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
3 d; e9 |% \3 C    m_dwPlayerCount--;</P>
<P>    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
5 v, W6 i- a6 w        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
; j: Q! y* e8 d) X+ y: z    }</P>
<P>    // Find playerdata for this client
8 w. ~$ ]+ t2 U/ Y. \    PlayerData* pPlayerData = GetPlayerDataForID( id );
& j+ e- M, H; r& o# k+ `7 W    if( pPlayerData != NULL )
% ?8 l9 X3 q2 t% o1 ?) w1 V9 B9 B    {
/ n+ C1 Y! P' e5 V3 {        // Destroy it
        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
1 O0 u& i+ b9 n5 q    }</P>
<P>    m_AddRemoveLock.Leave();
- y& J5 t! P; D; Z# a}</P>

8 E9 f  I+ A7 H% {) F<P>
" Z/ ]3 u: _- p2 `/ T* }//-----------------------------------------------------------------------------
// Name:
// Desc:
( T1 Q' a& c3 h' o' ]% F% ?! ?//-----------------------------------------------------------------------------
6 F6 V. A, L3 O6 JHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
" d9 _# `; w# }3 y6 U+ V{
    BOOL fFoundSize = FALSE;</P>
4 w- Y- Z3 G# I4 H2 E0 g* F  P+ E<P>    // Increment the number of thread we have in this process.
6 K# J4 `/ p2 m- q    m_csThreadCountLock.Enter();</P>
1 S# W3 d* B; f* L! s<P>    //Get the start time of when we entered the message handler.
    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
: M7 g- n. X  L; ^, E% ]; O2 N<P>    m_wActiveThreadCount++;
9 X5 K8 I  N3 @9 V7 q% i: x: e    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
# v$ C4 y+ _- Y# N# Q2 n   
, a* V7 k; I/ }) U1 o6 g* F$ N6 |    // Calculate and average.
* |: u1 c5 U8 R4 m1 W    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
* w0 [( Z8 ~4 e, D: u& B- N7 j    m_fAvgThreadCount += fdiff/32;
   
    m_csThreadCountLock.Leave();</P>
$ e$ y* p2 {. a9 U1 O<P>
7 }6 v8 `) o9 D0 C    ClientPacket* pClientPack = (ClientPacket*)pData;
" L0 _1 s" H2 l) R$ H    switch( pClientPack-&gt;wType )
    {
4 N% j8 q6 |  P, `5 \$ s0 n% d  i" T        case PACKETTYPE_CLIENT_POS:
            
/ @) B8 ]7 S& z- N8 s1 `            // Check to see if the packet has a valid size. Including
' |7 `* A9 V* Q" e( h            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
                fFoundSize = FALSE;
            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
                fFoundSize = FALSE;
            else
( `7 p+ a# q4 I/ C                fFoundSize = TRUE;</P>
  J$ v, ^" R8 C$ h7 _<P>            // If valid sized packet, handle the position.
$ W& m: f5 h! K3 Z; n            if(fFoundSize)
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
            else
0 ?5 m3 o5 `1 m, r                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
<P>            break;</P>
- W' ?5 b1 M& U4 A<P>        case PACKETTYPE_CLIENT_VERSION:
            if( size == sizeof(ClientVersionPacket) )
                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
# Q, d$ d5 e  Z& R            else
; s5 S* C2 s2 E& P! u                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
; \% l4 C2 ~0 T5 |7 h( r; M4 T6 r6 E<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
<P>            break;
        default:
            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
    }</P>
<P>    //If the user wants to hold the thread, Sleep for given amount of time.
    if ( m_dwServerThreadWait &gt; 0 )
    {
        Sleep( m_dwServerThreadWait );
    }
   
    // Retrieve thread data for this process.
0 z. N0 r! M" b( p: P+ p    m_csThreadCountLock.Enter();</P>
: D( |  j% \3 i* F  X5 `<P>    m_wActiveThreadCount--;</P>
2 r! b& L3 K$ [% |# H2 @: l; T<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
    m_fAvgThreadTime += fDiffTime/32;</P>
<P>    //Get the Max time in the thread.
/ [( b- {2 [+ t- Q* r    if ( fDiffTime &gt; m_fMaxThreadTime )
% i! X2 ~% L5 |; D% D0 |9 N    {
6 z/ M+ f+ T. w1 N" z        m_fMaxThreadTime = fDiffTime;
/ M0 z. ]$ [) A" C. ~5 Z    }</P>
<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
% g3 i: n+ V/ J2 @}</P>
/ ^5 i% W7 `" V- l. Y
<P>//-----------------------------------------------------------------------------
// Name:
8 Z- v7 A$ v7 d& w// Desc:
//-----------------------------------------------------------------------------
! m9 ^( L8 E8 e8 ]4 y; c1 c" eBOOL CMazeServer::IsValidPackSize( DWORD dwSize )
{
    BOOL fFoundSize = FALSE;
    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
   
    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
! m0 j7 y: _, l- }0 q    {
  N2 w9 s/ u& `( n+ W3 M- z7 [        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
            {
                // Found valid size in the array.
! R- D9 s( B' @- \2 `, v                fFoundSize = TRUE;
6 T/ X; U5 j4 d- c                break;
            }
. J% \) a3 }8 v- M  X            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
        }
' _& e5 A, y; C& G+ l    }
    else
' x! q, \0 ^0 z3 {& X3 [' u+ e    {
) B: O! u! f! ^5 K: j5 j6 K        fFoundSize = TRUE;
    }</P>
<P>    return fFoundSize;
}</P>
<P>
//-----------------------------------------------------------------------------
* K6 J1 |! _4 T: `9 [// Name:
// Desc:
3 Y& p. r( G( j( T! P+ E//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
{
3 i4 V4 {4 o1 c: _    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
* X2 k' G, c. z6 B5 X& g! n}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
' Z+ c* r9 H. c: E0 q" S% CPlayerData* CMazeServer::CreatePlayerData()
{
    m_PlayerDataListLock.Enter();</P>
; y' m, m8 P0 ]- N<P>    // Grab first free player in the list
    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
; o6 H& V9 m5 b+ ?8 e<P>    if( pPlayerData )
    {
        LockPlayerData( pPlayerData );</P>
<P>        // Got one, so remove it from the free list
% O( [' H- w  B" T- c        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
5 T, ?  {0 v* R6 |        if( pPlayerData-&gt;pNext )
' a- V/ A0 i8 z. M" J. X. [3 G            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
5 `9 Z$ W5 W' r; C+ R/ ?2 `        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
  c. ^& C$ H: _! R" |/ [            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
& Q0 g; k6 A; W2 s6 I        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
: {# R0 l( j) y. L/ [! T        m_dwPlayerDataUniqueValue++;
        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
! v. L- O3 n# }: D2 D% S. c<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
        pPlayerData-&gt;NetID = 0;
& g1 P: w6 r+ y. O2 X( p2 H        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
<P>        // Insert into the "off-map" cell
        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
  h4 Y( B! q+ D# T        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
: |% W; [8 x7 q9 @& w" o        m_OffMapLock.Enter();
0 d* J  j" ?8 O6 u! B( G- K        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
1 w* {  L" d3 @: ]' U( Q% ]        m_OffMapCell.pFirstPlayerData = pPlayerData;
        m_OffMapLock.Leave();</P>
<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
# T6 [7 q" u  L<P>        UnlockPlayerData( pPlayerData );
8 m1 B; o9 h  F8 t    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
<P>    return pPlayerData;
}</P>

/ l; ~9 L: z5 J0 A+ `0 t0 S  r<P>
//-----------------------------------------------------------------------------
// Name:
+ h. R0 V. L5 E; K7 H! e// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
/ }) S5 r' D: V# i' j5 a{
- S8 P/ C" E$ M& m$ x' B, O    m_PlayerDataListLock.Enter();
    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
: g; i& J1 a9 e' V. x: ], S    RemovePlayerDataFromCell( pPlayerData );</P>
0 |3 K) q; t+ X7 a6 F. a7 d7 B<P>    // Mark as inactive
5 [1 @- A. m" p% u+ g9 j7 ]* R, q    pPlayerData-&gt;bActive = FALSE;</P>
/ b  U, U7 O+ o* t<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
<P>    if( m_pFirstActivePlayerData == pPlayerData )
0 _# m* [  v* f# T9 {        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
" f" M( V: K% c<P>    // Add it to the free list
& N/ f4 h( o: ?+ F    if( m_pFirstFreePlayerData )
+ A4 P) z+ i8 Z* l        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
, x& q' S* P( b. o3 y  s% Y/ f    pPlayerData-&gt;pPrevious = NULL;
    m_pFirstFreePlayerData = pPlayerData;</P>
/ ]7 Z9 G. V5 Z/ j<P>    // Update count of players
    m_dwActivePlayerDataCount--;</P>
; O% A" }* A! f4 H7 q" D6 g<P>    UnlockPlayerData( pPlayerData );
% |0 T% V. c) }/ {    m_PlayerDataListLock.Leave();
) |% t, _7 i+ p}</P>
8 j/ x& P6 {; Z' I1 h) Q% m8 c& @, I
/ S* \8 b* a4 G, [' G/ Y1 f: T" @9 R<P>
//-----------------------------------------------------------------------------
( q1 T: I( ^! J) f+ w# M" q// Name:
- B( U3 X, j+ H  t  ^- w// Desc:
//-----------------------------------------------------------------------------
8 h0 [6 L5 [* K9 ]void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
    // Lock the player
  Z/ d6 \9 a. I' P  \3 |! k6 n    LockPlayerData( pPlayerData );</P>
: V, x" x/ [* ~3 Q- ~<P>    // Lock the cell the player is in
+ @6 X$ k- v$ q    ServerCell* pCell;
7 ~+ l: U. [& T- L3 p! n' t, e+ @    if( pPlayerData-&gt;wCellX == 0xffff )
    {
        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
    }
    else
* E/ p. y2 m( M/ \    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
/ s6 v$ ~8 ^3 ?8 ^2 i    }</P>
<P>    // Remove it from the cell
+ l0 \& E" d! O, C    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
4 m" |# l7 P( ?0 T, o( u2 Z    PlayerData* pPrev = NULL;
6 Q+ `$ t" T0 Z. b1 m    while ( pPt )
) H. m$ q! M4 v4 O    {
        if( pPt == pPlayerData )
3 J% f& m6 p5 P# Z1 |2 g        {
            if( pPrev )
6 K: a, @3 B" ?% Z' j$ p) }                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
- \' }1 [" D# J  o5 U* Q3 ^                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
8 y! T0 Z, ^) S<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
4 `8 a( Y7 |6 K& o3 F0 O0 R* `# D        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }</P>
<P>    // Unlock the cell
    if( pPlayerData-&gt;wCellX == 0xffff )
        m_OffMapLock.Leave();
( n* E' M  ~2 h; B6 J1 s( ^    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
<P>    // Unlock the player
5 p  O% U* G3 }    UnlockPlayerData( pPlayerData );
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
7 Y8 y! H2 l; F+ S, f& @# H// Desc:
//-----------------------------------------------------------------------------
  ?; {% n6 f0 Y, s- Lvoid CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
{
& h3 q5 H4 c. ]" j2 e0 t  v    ServerCell* pCell = GetCell( pPlayerData );
    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
/ O# N8 F# S9 ]    PlayerData* pPrev = NULL;
% Q! U( m" Z* c    while ( pPt )
    {
! k, l( M& O% L4 c+ m+ B        if( pPt == pPlayerData )
# ~& M7 K  H3 q2 ?4 h        {
            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
) _8 x! L! s& e0 H! a0 v            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
: L; X2 ?$ p# u1 B            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }
  c- f. B2 T+ o& ]  I# H  Y  ~0 Q}</P>

' L5 {7 A/ G* ~7 }  l  s* W<P>
2 n: d$ }7 j/ Q//-----------------------------------------------------------------------------
0 N0 L/ f# K% X9 Q) q' \: [7 D  s7 i8 u// Name:
% g& w& f8 ]# N9 y% S- w// Desc:
) p2 T7 h, D. i+ h& k' ?//-----------------------------------------------------------------------------
5 N- T, b* y% E0 `9 [; B) g& ]void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
    ServerCell* pCell   = GetCell( pPlayerData );
9 z2 k4 K) b8 C1 }. ~  Z    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
    pCell-&gt;pFirstPlayerData = pPlayerData;
: S" M! D1 b- r/ c6 z# ]7 q}</P>

% [7 T/ x: a& f( R; D' T8 |9 Y# k<P>
* y# ~/ k$ D1 h" d' n% {6 a//-----------------------------------------------------------------------------
// Name:
// Desc:
4 a4 Y7 g& O, }+ ~9 Z//-----------------------------------------------------------------------------
  q6 `# p1 ]0 N* l* c. B, avoid CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
5 S3 `4 Y* d8 c8 {( E, Y{
    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
- q! D5 g0 T0 |% x    {
; q% V1 B, F9 H5 h        if( m_dwLogLevel &gt; 1 )
0 H) J! c; m8 B7 T1 q; [' q            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
        return;
- ]0 i* d; U7 T: i  u) s* V    }</P>
7 d0 `0 o+ t; `9 `<P>    LockPlayerData( pFromPlayer );</P>
& {& `$ q- w/ c7 j0 m& @<P>    if( FALSE == pFromPlayer-&gt;bAllow )
# {' |: j7 y! Y$ I# f8 {9 Q. Q    {
: u& t6 W' |6 q  t& H        if( m_dwLogLevel &gt; 0 )
! }& H4 L1 E7 v% G7 i            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
9 @3 ^5 L: f, S6 a5 V: s<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
, z% F3 o% }) c- T, ?3 h* m        UnlockPlayerData( pFromPlayer );
        return;
4 F: q: D# b. Y! [    }</P>
' F" H+ ~6 X; G0 w0 B<P>    // Compute the cell the player should be in now
    DWORD newcellx = int(pClientPosPack-&gt;fX);
. Q- e5 E. w- a$ a$ F6 l* p  N4 F8 [    DWORD newcelly = int(pClientPosPack-&gt;fY);
    DWORD oldcellx = pFromPlayer-&gt;wCellX;
    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
- ~! _- m. n4 u$ Q* K! V$ [<P>    // Have we moved cell?
    if( newcellx != oldcellx || newcelly != oldcelly )
    {
, ?8 J! f8 ~) M! o  ^6 {( d3 ?        // Yes, so lock the pair of cells in question
1 L. T5 o  ]9 B/ e0 H        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
<P>        // Remove from old cell and add to new cell
8 O! s2 M+ p( r2 I% Q        UnsafeRemovePlayerDataFromCell( pFromPlayer );
        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
( x4 I2 L4 ]% R* V* T/ o<P>        // Unlock cells
0 u1 u: P6 i: ]+ V" S5 b0 F        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
* _  |' [7 z- r<P>    // Update player position
    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
6 A, C' L) G) w% y5 |    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
<P>    // Allocate space to build the reply packet, and fill in header
    DWORD dwAllocSize;
9 ]+ C0 ~9 P. B4 g) k* d% U  K. ~    ServerAckPacket* pSvrAckPack = NULL;</P>
<P>    // Begin by allocating a buffer sized according to
$ |) b- U. A' v! W    // the current number of nearby players + 4.  This will give
    // a little room for more players to come 'near' without resize
    // the buffer.
# r" j) H2 W: c    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
! R7 t+ c1 f- W, i2 _- k    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
; q3 L  S: L4 _9 g: H# f( \7 u$ i    if( NULL == pSvrAckPack )
    {
        // Out of mem.  Cleanup and return
        UnlockPlayerData( pFromPlayer );
        return;      
; C& r( l* }! c    }
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
5 |/ }( X7 c* l# w8 {  Q& o) C    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
' R% s2 m9 f. v* U    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
<P>    // Compute range of cells we're going to scan for players to send
% D! F/ Z' d) h- b* Z4 q3 y    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
6 n6 G) W0 M7 y; i) y    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
: B! J6 g* C+ Z3 M    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
) M3 q/ g9 g# h9 K8 @    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
4 @9 ?: L$ \% Z<P>    // Lock that range of cells
    LockRange( minx, miny, maxx, maxy );</P>
! @) D! t+ m* z1 m, E<P>    // Scan through the cells, tagging player data onto the end of
0 O& }. c9 I. K! r% M    // our pSvrAckPacket until we run out of room
    for( DWORD y = miny; y &lt;= maxy; y++ )
    {
        for( DWORD x = minx; x &lt;= maxx; x++ )
" [) v7 g# z0 s8 M        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
$ V% l  n. {+ [; N+ z  w( o: A4 O4 G            while ( pCurPlayerData )
            {
9 R/ G5 m  j( x* G2 k6 D                if( pCurPlayerData != pFromPlayer )
                {
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
- ]# m; H- @9 w# \+ y* x5 L                    {
                        // Make sure pChunk is where we think it is
0 X% j3 f  O- A& m/ \5 h                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
<P>                        // There are more than just 4 new nearby players, so resize the
8 ?# e# j& p2 I: b                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
. y+ {  q& g+ u* [3 |$ H! A                        dwMaxPlayerStatePackets += 16;
8 g( H( ?# A) ]7 M" b2 l: k8 {                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
                        ServerAckPacket* pNewSvrAckPack = NULL;
, a8 |" r/ a# [& W. U9 J                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
                        if( NULL == pNewSvrAckPack )
4 e8 s6 s, T+ c& t                        {
                            // Out of mem.  Cleanup and return
9 P+ V9 u3 T- t8 n                            free( pSvrAckPack );
6 a/ Q) W8 x" D( r6 w: u                            UnlockRange( minx, miny, maxx, maxy );
                            UnlockPlayerData( pFromPlayer );
                            return;      
+ O: [# H& |2 D                        }</P>
<P>                        pSvrAckPack = pNewSvrAckPack;
$ \  e7 j% s/ m                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
( U: u9 r% Z6 j<P>                        // Make sure pChunk is still where its supposed to be
$ i" j$ v$ T& b( c6 g                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
                    }</P>
$ V/ t& e4 u3 O<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
* ]" D, M" [9 T& h+ C                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
- o1 i& t) l5 E% f1 a: q                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
                    pChunk++;
0 @: c* d% X  f& M; e8 q! A/ U                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
: x# ?7 @& x7 {7 i7 Q4 v+ X: ~                }
/ _# F6 \# p6 z7 l5 J: N                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
. }; W& K( V2 x( J" @4 e/ h$ F6 ^        }
$ r" Z: W5 @/ ^( Y    }</P>
( K! b4 r8 `) d. W6 z<P>    // Update the dwNumNearbyPlayers for this player
- e( `* D- ]: M- @    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
+ q3 R5 T" h$ r- `- m<P>    // Unlock range of cells
$ e8 Q8 G6 r( t: ~    UnlockRange( minx, miny, maxx, maxy );</P>
<P>    if( m_dwLogLevel &gt; 2 )
    {
  G& S: L: n7 b$ G# ~  P# S        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 )
    {
7 }; d1 v* |5 B6 t3 v- a        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
7 f& |% k( [; K7 y, K        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
        {
8 ~" s; w# M2 Q            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;
# B, K* z3 F/ p+ `& `+ U4 E        }
    }</P>
<P>    // Unlock the playerdata
2 Y+ l$ c: f2 M4 J    UnlockPlayerData( pFromPlayer );</P>
2 t8 Z& H8 l( ]7 }<P>    // Send acknowledgement back to client, including list of nearby players
+ ~; ]; u! F% a6 [1 g" ^, j    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

    // Pack the buffer with dummy data.
; K. p, T8 Q( Z1 U4 F1 u    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
8 g4 a' U, d/ r  C/ o( s* |2 W    {
& C5 A% _4 T+ T$ o% _' r        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
% Y4 S7 p% \" @' [. o7 f) y: U& e        VOID*   pTempBuffer = 0;</P>
3 E7 \$ u7 \* E8 D" E2 k<P>        pTempBuffer = malloc(dwBufferSize);
' e3 p2 f0 N% o        if( NULL == pTempBuffer )
        {
9 ]" M  t* P: u0 V; P. F5 C            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
+ q# `# j8 Y9 C2 R            free( pSvrAckPack );
) c; _+ Q( s' P9 k, o4 A9 w            return;
$ D" J( j' @7 ]2 ]  I        }</P>
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
$ C  W6 T+ }7 [: R<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
   
6 c7 k7 G0 `, k+ I$ Y; V        free(pTempBuffer);
    }   
6 N5 o8 v$ K+ D; Y/ P    else
/ i& _9 P. R* u! K- _6 a: j    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
+ V5 ?  N' @1 e    }</P>
<P>    free( pSvrAckPack );</P>
: v9 f7 I1 [7 s. g; l/ z0 g* h) _<P>}</P>

<P>
, I: S+ V8 |: D5 N2 K  E4 T//-----------------------------------------------------------------------------
// Name:
8 n1 |9 x  H- v/ f2 i! d5 X/ m// Desc:
- `* {2 {% H4 S( `- `3 q9 h4 G) P! y//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
$ h) ]2 _' G) H{
    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
    if( pPlayerData == NULL )
        return;
' g+ `8 B3 K4 a" E    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
5 U7 F+ b& C, Z0 n8 K: b<P>    if( m_bLocalLoopback )
        pPlayerData-&gt;bAllow = TRUE;
2 z/ \  E% n+ U+ y  L) a    else
        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
<P>    if( m_dwLogLevel &gt; 0 )
0 S% Q' ^( B( N7 A0 |" |        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>
<P>    if( FALSE == pPlayerData-&gt;bAllow )
* v/ I7 {; g' _2 B/ A% [    {
        if( m_dwLogLevel &gt; 0 )
( Q& ?3 A2 @, J: f- @            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 );
0 B. W* e8 u9 V4 N( r        return;
    }</P>
) s) m$ D% ~- K' D<P>    // Unlock the playerdata
3 o& A& Z% k# g: e! @- a    UnlockPlayerData( pPlayerData );</P>
<P>    // Send acknowledgement to client that the client was either accepted or rejected
    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
8 D9 r* y6 j- Q  k    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
3 |$ k# D$ g5 M}</P>
# o& Z9 L/ n# t. x( P
+ h- ]5 [; ~; p& ?7 M<P>
//-----------------------------------------------------------------------------
// Name:
: Y" A# H! l) |3 j& `// Desc:
/ W* U( G, g3 k8 o) w8 B7 n//-----------------------------------------------------------------------------
% U5 z+ d( J: }$ m3 y) z; l1 a* `BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
% n. `+ e6 Z7 r( w/ X6 U{
; }3 [, ]7 H$ p4 `0 v    switch( dwClientVersion )
    {
1 T( m1 c% D8 [/ v        case 107: // only v107 is supported
  K* O! {+ A- p% P7 L; D1 m            return TRUE;
; B+ m7 n+ S: F- X, T+ q2 d        default:
            return FALSE;
    }
. ~& }( g( B& ]. B6 t' v9 L}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
" s8 G$ Z0 @' F//-----------------------------------------------------------------------------
3 U& q; K$ D* E# F5 hvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
{
    if( m_dwLogLevel &gt; 1 )
+ N1 A& e! F6 v% c# H9 U# K$ s: [+ s: ^        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 );
3 E8 j- j" Z4 ]}</P>
1 d% T3 f0 \9 O; Z, q! x( E+ K
<P>
: s/ z) R. ~" W* `//-----------------------------------------------------------------------------
6 ?8 Y# {# s2 ?% q8 ?/ g// Name:
2 V9 Y4 v4 W3 R" z! C// Desc:
4 [. e: X8 v  D$ v//-----------------------------------------------------------------------------
) H# e  |9 {7 ODWORD   CMazeServer::IDHash( DWORD id )
; y0 {3 d( {- o{
    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
) J. _* |+ y! E+ W: |$ z# y; r! R1 K' a    return hash;
# w" w: x& T5 X9 j& z; q}</P>
  B8 b8 o& a* D) A! f+ z3 |7 ?
<P>
//-----------------------------------------------------------------------------
// Name:
  n3 f, a& H1 a7 r// Desc:
; o2 }7 @' |( o# @//-----------------------------------------------------------------------------
5 T1 [' ?) m7 B# Q7 evoid CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
{
: n' s' ^2 \  A    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
<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
5 z* t3 \0 y* Z6 Y* \' z; c7 @4 r: a! V) n    PlayerData* pPt = m_pstIDHashBucket[bucket];
    PlayerData* pPrev = NULL;
    while( pPt )
    {
+ N  o. h) l! ]2 N1 ]/ R. G        if( pPt == pPlayerData )
            break;
. P, F) A: s' D- _; X- F2 ]+ ~        pPrev = pPt;
# S0 \+ G# L: b7 B1 b        pPt = pPt-&gt;pNextInIDHashBucket;
- o) ~5 q1 j4 B$ j$ T, Y$ _    }</P>
<P>    if( pPt )
+ Q& q0 d) y; X& h0 _    {
        if( pPrev )
- S$ G; e& A& ~2 ]: J6 m            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
        else
            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
! S- G3 }8 k! }# N* A8 R' n6 N& k}</P>

<P>
//-----------------------------------------------------------------------------
9 @8 d4 H3 k* f2 k/ l% }// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
- h" B# T" l/ i7 ^! _+ b5 c{
    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
    // otherwise there will be a circular reference
& m- S1 [1 T+ a) d    PlayerData* pSearch = GetPlayerDataForID( id );
' Z" R+ z3 d! N5 t! T6 `( J' s    if( pSearch != NULL )
  F# e3 t' x8 E5 n- ~- h: d2 F  d; B        return;</P>
: ~& L7 ]  O& ~' ]+ T$ B<P>    // Hash the ID to a bucket number
- C& ^& ~6 _+ R* d+ H    DWORD   bucket = IDHash( id );</P>
. K& P  k0 {/ T<P>    // Lock that hash bucket
& D$ B8 R4 S2 z2 |! Z    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
- }& @" n% I( G' J) j- T7 c    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
7 [4 R3 m, U# R0 g) C0 k    m_pstIDHashBucket[bucket] = pPlayerData;</P>
  `$ Y' R! ~# r) I( y* \( R<P>    // Store net id in player
    pPlayerData-&gt;NetID = id;</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
2 @# e0 s  x& y) H- ^, E8 l}</P>

  W' P/ k  k- p( {- N<P>
//-----------------------------------------------------------------------------
) G9 R, |3 L* r8 o// Name:
# q4 u, B. A* u* ~" h. Q// Desc:
0 h" j4 _7 M3 f; N/ B# B//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
/ u! E$ T( Z3 n, I9 |{
    // Hash the ID to a bucket number
/ o& Q& n6 ~2 P" E# Y1 p    DWORD   bucket = IDHash( id );</P>
( ]- h9 l' |  }3 @( O$ \<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
3 m! C( }! j) F  B    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
7 \+ v+ C" t$ c" o, i+ v3 `, y    while ( pPlayerData )
- S. M3 X! m2 {1 E$ V" B; K$ j    {
- h5 o& C; A. s; T: [4 E4 p2 v        if( pPlayerData-&gt;NetID == id )
            break;
6 Z8 o3 ^6 W2 I2 D( R; x( y4 W9 w. s        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
    }</P>
7 p( t3 A4 k9 ~) M5 D5 d; @9 p<P>    // Unlock the hash bucket
7 A' @* [* b/ L& G5 J! F    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
  s( {3 z* }: R7 N6 V2 C3 S<P>    // Return the player we found (will be NULL if we couldn't find it)
% t- z: z- _: j7 ?; B' q    return pPlayerData;
( N( p) v; Y. B+ f( i( n0 R}</P>
6 `; |1 m, S- R! b4 a: T
; N5 f3 |6 e3 B% U9 `+ q<P>
5 d6 {2 N1 m# q( U6 j$ V& P: |//-----------------------------------------------------------------------------
  \' l/ m% u* K! J  `8 ^: r// Name:
: l1 F0 t( \8 e" h// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
//-----------------------------------------------------------------------------
3 `: h1 x% Y) `void CMazeServer:isplayNextConnectionInfo()
{
    if( m_pNet )
4 r. \9 r0 g/ C* ^3 v9 f6 S    {
        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
, m9 {! O  b8 S- W/ X        PlayerData* pOldestPlayerData = NULL;
        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
( }" C! n/ L7 M  Y2 G1 Z<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
        while ( pPlayerData )
        {
' O5 q+ l. K+ J$ L            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
            {
                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
" L2 @' L! [& T. Z3 [8 t6 T! z                pOldestPlayerData = pPlayerData;
            }</P>
<P>            pPlayerData = pPlayerData-&gt;pNext;
        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
        if( pOldestPlayerData )
6 ]/ w$ h4 O+ I& e        {
            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
7 ?! h' ]. d1 T8 i            pOldestPlayerData-&gt;fLastCITime = fCurTime;
# K+ n' U. p. _1 \  R$ e        }
        else
        {
            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
2 K6 B9 \. P' I0 P        }</P>
+ j: w. X7 h( r9 R7 h+ w<P>        m_PlayerDataListLock.Leave();
    }
}</P>
, L" U1 v' Z5 S, |8 y
+ I% ?' \# y/ |, c7 r5 v<P>
$ F" [0 v7 D9 R! N  a//-----------------------------------------------------------------------------
2 l' r  {$ l+ I4 E9 }// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:rintStats()
{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
0 T0 r4 Z; T% B                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
                                    m_fAvgThreadTime, m_fMaxThreadTime );
; G8 X1 C. _3 `% D: _: b' Z3 x    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
$ A  X9 i& e- I5 V$ p6 P3 N    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
}</P>

) _& B6 Y8 f: F. E7 b1 s<P>
/ h* ]* b4 k3 b0 w$ k//-----------------------------------------------------------------------------
// Name:
; ]1 w: H9 P/ I% L: O5 L. c& U// Desc:
% ^1 ?( n. G$ f* A3 ~8 Y//-----------------------------------------------------------------------------
void CMazeServer:isplayConnectionInfo( DWORD dwID )
% ^4 o! d9 r' o+ H/ V5 s{
3 y7 B" C$ f% O0 J) A( l( p    TCHAR strInfo[5000];
    TCHAR* strEndOfLine;
    TCHAR* strStartOfLine;</P>
$ e5 u4 X' a7 b' r<P>    // Query the IOutboudNet for info about the connection to this user
2 W8 Y' A. N2 \4 t+ P5 G4 D    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
<P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );
    ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>
% l, |: W% |) u<P>    // Display each line seperately
    strStartOfLine = strInfo;
    while( TRUE )
. s0 n0 C# w* b. K    {
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
9 Q' [% {" ^+ d' l5 A) c( T: W        if( strEndOfLine == NULL )
            break;</P>
<P>        *strEndOfLine = 0;
* h, ]  K' w* p2 F        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
+ p2 n# q) X% A- Z  I% ?* w9 Y    }
7 [7 E* b/ z- ~/ O}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
4 ?) K7 _6 H* _& g5 D// Desc:
. E6 ~" B  ^3 j/ {& _- R) ?: J//-----------------------------------------------------------------------------
: ^* P! i7 y9 u) _$ S+ o3 NHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
{
- Z5 f/ W4 m9 b+ U' s) f$ f    // Chance of forcing any packet to be delivered reliably
    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
) s: j% \2 N+ M; |8 q9 X# V<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
. U/ q5 G2 j' }0 ?}</P>

<P>
4 Q; G5 r, F; y( l) B4 b8 C//-----------------------------------------------------------------------------
1 s8 v8 G- B* A; ^' D" R// Name:
% H! r' I3 x* Z: r9 y( ^// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
. L* H- a. x/ D$ g5 h{
" t" I2 r- M% o3 c1 d# n. l" Z    // If we're up and running, then send this new information to all clients
    if( m_pNet )
    {
5 s: k9 k& `  i        //Use the AllPlayers ID
        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
" ~, I" ^5 m: w( d}</P>
8 X: |- m' O9 M* W0 }. H
$ n% [' a/ C7 H<P>
1 [% |. |; ~, f# S2 ~& B+ s1 x//-----------------------------------------------------------------------------
  q  _1 Z8 \% \1 N// Name:
// Desc:
//-----------------------------------------------------------------------------
( ?) O) O7 O+ X9 t2 e9 F- ~9 Avoid CMazeServer::SetClientReliableRate( DWORD percent )
  i' A+ w. a( }3 R{
8 q( r2 u" O/ p    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
! k2 o0 U9 a: V    m_ClientNetConfig.ubReliableRate = BYTE(percent);
+ N2 B# \9 m0 }& A    ServerConfigPacket packet( m_ClientNetConfig );
8 d3 `. O, r! d# q& U7 D1 w    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
! `& u1 S) l& A6 W}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
$ N  N( C, w. t, Q/ K( w. O  R//-----------------------------------------------------------------------------
- V% n5 M0 `; j' o, m- Fvoid CMazeServer::SetClientUpdateRate( DWORD rate )
{
    // Update client config, and build packet containing that data
% v% Z4 q! ^4 M5 I: C    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wUpdateRate = WORD(rate);
    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
  j( L4 y* V! [8 q, B7 P<P>    SendConfigPacketToAll( &amp;packet );
9 f9 p1 |" U1 K}</P>

0 H! L) ~1 i2 J5 _( f: r9 `<P>
//-----------------------------------------------------------------------------
// Name:
' N2 o. z5 ^& @! Z' T// Desc:
//-----------------------------------------------------------------------------
& F3 M2 t; S# \void CMazeServer::SetClientTimeout( DWORD timeout )
1 F9 R* u6 d" z7 Q  L{
, @% [6 g$ K) u& Z* B8 X    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
6 M4 u2 C& ?) N    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
! A5 c" H+ C" t. {0 D    m_ClientNetConfigLock.Leave();</P>
* p4 K3 [  _, `1 M% v% L3 Q<P>    SendConfigPacketToAll( &amp;packet );
% {0 u6 X5 r/ W4 X; b}</P>
% @2 Q1 Q" a% {$ e6 m) a& X
: t6 E  e$ R( S5 Z( [' h<P>
//-----------------------------------------------------------------------------
// Name:
# H( i% D' a. m3 q! h3 h  }// Desc:
//-----------------------------------------------------------------------------
$ S9 t  P& d: u% q9 r; Gvoid CMazeServer::SetClientPackSize( DWORD size )
! N% J' f0 r0 a) q6 u8 |7 I{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
5 c0 ]; [: Z6 f1 W   
    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
' m+ l* J/ P+ j: }: v- b) S. i    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubClientPackIndex = 0;</P>
<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
5 T$ |! a& V8 q5 t, q7 Q0 Y5 x<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
  H2 M4 {1 x& e1 x//-----------------------------------------------------------------------------
// Name:
0 t3 b9 G( N1 _9 C5 }& K3 l' I/ Y// Desc:
//-----------------------------------------------------------------------------
, S7 U3 h/ `: z' cvoid CMazeServer::SetServerPackSize( DWORD size )
+ N) h* k8 p$ r{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
% }7 [; `: t) H! T# `: |6 l/ @4 r   
    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
% C- a# x0 R; @& \5 y    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
6 H4 X  k3 Q, K. B1 K: Y8 G3 U        m_ClientNetConfig.ubServerPackIndex = 0;</P>
3 X$ l" I) a' {) A) g! ]7 {( y<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
! _2 J+ U. {7 s4 ~: \( t$ E    m_ClientNetConfigLock.Leave();</P>
6 J0 _7 W! G2 @2 H) O, J<P>    SendConfigPacketToAll( &amp;packet );
}</P>
<P>
. N1 V- g3 E/ Q& b) @# p! t//-----------------------------------------------------------------------------
, N& p4 b( g  M* H! }// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
/ y7 V/ U2 y9 @, u5 j* W{
$ Y4 ^. [4 x& q7 q) Y' E" J" y    // Update client config, and build packet containing that data
" w. m3 _# a  T) J4 X    m_ClientNetConfigLock.Enter();
1 j, Q' T+ D! ^3 _   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
: c4 A* T' ~/ P2 N1 t2 }- k0 J* {}</P></DIV>