[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
" O, C) l6 H* Q+ X<>// File: mazeserver.cpp
//
( |# F% A/ V& t. Z+ \// Desc: see main.cpp
: M6 O$ [' B; D/ i4 _( m& O: R//
// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#define STRICT
- c2 H' z  Z- D" M: e7 S, B#define D3D_OVERLOADS
#include &lt;windows.h&gt;
#include &lt;d3dx.h&gt;
#include &lt;stdio.h&gt;
- s, e* V1 Q' q- P#include &lt;math.h&gt;
#include &lt;mmsystem.h&gt;
#include &lt;dplay8.h&gt;
#include &lt;dpaddr.h&gt;
1 s6 E$ f: _% E% b5 c#include &lt;dxerr8.h&gt;
#include "DXUtil.h"
#include "MazeServer.h"
#include "ackets.h"
# x! d- G; d4 o1 z; ?  r0 F& {  Q#include "Maze.h"
- B; y6 w  H% l; ]#include &lt;malloc.h&gt;
#include &lt;tchar.h&gt;</P>

<>//-----------------------------------------------------------------------------
// Name:
// Desc:
) Z7 s& E. ]/ X$ ^//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
{
    m_dwPlayerCount         = 0;
$ D  C, Y0 f* {$ K   
    m_wActiveThreadCount   = 0;
/ X5 D  s+ [. M' ]" _8 ]6 _    m_wMaxThreadCount      = 0;
+ A4 d( Q! S. b* y% G    m_fAvgThreadCount      = 0;
" Q& ~) r- i, W& c( F    m_fAvgThreadTime       = 0;
; k6 m; n4 q' Q! e    m_fMaxThreadTime       = 0;</P>
<>    m_dwServerReliableRate  = 15;
    m_dwServerTimeout       = 150;
! U. ?$ \8 f  `& ~0 _4 I    m_dwLogLevel            = 2;
9 F& n* f$ V0 Q    m_pMaze                 = NULL;</P>
. @% t. Q# i  d5 X0 F<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
    m_ClientNetConfig.wTimeout       = 150;</P>
4 U0 f, C: U! ]. g<>    m_ClientNetConfig.dwThreadWait = 0;</P>
<>    m_ClientNetConfig.ubClientPackIndex = 0;
4 g; H; u0 m) G6 v3 k$ Y# m$ l5 O    m_ClientNetConfig.ubServerPackIndex = 0;
    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    {
. a$ O& _2 b0 U6 I! C  C        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
6 U5 g) A4 L# M' p        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
}</P>

<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
8 c0 [" {3 G4 {3 ?; E- Z" AHRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
5 W/ o6 c( W5 A+ T! x) H/ e{
    m_bLocalLoopback = bLocalLoopback;
" l- w- T  @+ S4 c4 Q5 J" D    m_pMaze = pMaze;
    if( m_pMaze == NULL )
        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
<>    // Grab height and width of maze
! ?& B) g9 l) R0 d! _4 w6 ?    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
. i; r0 ]. \/ a2 g" C    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
: e+ p( A6 U& ]8 A' R5 i& v        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 )
( N/ h1 |  g) b        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>
- m7 o, [. k/ f+ h<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
; ]; P( q' z% |% S9 W    m_dwMazeXShift = 0;
" z0 D7 S8 n; C    while ( (scale &gt;&gt;= 1) )
        m_dwMazeXShift++;</P>
6 P8 F# `2 u- t4 O<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
        m_dwMazeYShift++;</P>
<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
- }+ N2 J: S1 C        ((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
% k/ F3 l+ @: }$ |2 T    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
    m_pFirstActivePlayerData = NULL;
& e- b* d& ?6 n+ f1 \; Q/ p: f    m_pFirstFreePlayerData = m_PlayerDatas;
    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
, i7 u' n. J: a' e  F8 B' o    }</P>
% A  j, @6 ?4 ]$ `8 K  |# a<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
( X7 S0 K: `6 K/ A0 M, \4 Z    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
    m_dwActivePlayerDataCount = 0;
    m_dwPlayerDataUniqueValue = 0;</P>
<>    // Initialise the cells
, r% C3 h9 p8 ?5 b    ZeroMemory( m_Cells, sizeof(m_Cells) );
+ `9 v7 o3 m) H( y- L    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
8 V. @% N7 M4 r<>    return S_OK;
2 W0 U" D' e$ s; k" Y9 a' V: q}</P>

9 H! f) c" q6 r<>
//-----------------------------------------------------------------------------
, m2 E2 Q# H0 b: ?// Name:
// Desc:
' b$ l3 b% p4 Y( h+ L0 s% @0 e//-----------------------------------------------------------------------------
void CMazeServer::Shutdown()
{
, M: Y0 Q' Z7 N) B}</P>
8 K9 ?2 {$ d! V& K0 R" U8 J6 S( D
<>
' L+ w+ T) b; Y- U//-----------------------------------------------------------------------------
- c- W* @3 i+ D! Z// Name:
: R3 }0 I% C! G: M, Y9 g9 C// Desc:
# V+ K8 D3 f7 E. m" _//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
4 w4 N& X8 V+ V1 d* j. B{
1 v- z# ^+ `+ ]/ v& v  r& [1 ]    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
& A, j! p" [$ V* a                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>

: L" d( L3 Q/ O$ O. x<>
6 g. ?/ r% D" o- S9 K7 m7 R. h//-----------------------------------------------------------------------------
5 U, A  c7 S& ^// Name:
7 I% `2 u& l9 i# z// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
+ @( s0 s6 T- M* {1 z. }  I$ J{
7 f! _( m& ]. f( ?    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
) w0 @' @1 p' L% w/ z- _- J                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
+ t7 R( w8 S; E( S}</P>

! H: X% i% Y( r& E; m' t<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
8 B$ i% B6 A, Q+ e& j- Q' T//-----------------------------------------------------------------------------
4 _1 H9 w1 K1 L6 ivoid CMazeServer:ockCell( DWORD x, DWORD y )
1 z2 I2 L. }' O4 c) h( A4 g{
$ f. R" s5 X+ E, x# r    if( x == 0xffff )
        m_OffMapLock.Enter();
7 }& B. ]0 [* A    else
2 w% e- |9 p0 X. V$ I4 o, ^+ S) _        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
7 ?0 p' M$ D1 ~+ Y! \}</P>

<>
3 k/ t' |, t- o0 ^, @; @//-----------------------------------------------------------------------------
// Name:
/ k/ x( I0 c$ x" k1 p# m0 d3 ]6 B// Desc:
//-----------------------------------------------------------------------------
( c: b5 S9 E1 t# M  Bvoid CMazeServer::UnlockCell( DWORD x, DWORD y )
; F+ j) S% M/ M  ~9 I{
    if( x == 0xffff )
6 R2 p1 I$ m* o        m_OffMapLock.Leave();
2 {7 S2 C. m3 ^* A  @2 O    else
6 Y0 B) |3 J8 m0 m9 v8 V        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
. M( _+ M9 i8 L* T4 I' K5 n. T}</P>

- {0 Z8 j: @( T3 j0 u7 @7 \  y0 k! E<>
# j5 ^: ?2 m8 l8 @2 j( }" d. k; E//-----------------------------------------------------------------------------
2 z! V9 R4 a0 }// Name:
! M8 u+ b) [$ W1 b9 b3 U; |// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
" G; M+ _% c9 g' K- o7 q        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
3 c7 ], h4 @& _# e6 E5 v        else
            m_OffMapLock.Enter();</P>
<>        return;
  S9 l& m- Y' V" q5 C1 V6 D* K    }</P>
9 p0 F5 N( e  u<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
) i( {: _# a& U/ Z    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
, I' P. y" e. U  ~0 ?. u! }    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
' q3 I+ h5 n& r    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
. E: D( @7 ^  o- O, b4 M<>    if( x1 == 0xffff )
# P7 q0 w- @9 {# B- \* C6 M1 d, y- l    {
        m_OffMapLock.Enter();
0 H* c9 f; i3 e1 a8 ?4 X3 y# a! M        m_LockGrid.LockCell(x2shift,y2shift);
, n# n6 H/ F3 j    }
    else if( x2 == 0xffff )
    {
        m_OffMapLock.Enter();
0 u, f( |/ T  V- J% Q$ r+ Z' e        m_LockGrid.LockCell(x1shift,y1shift);
3 `9 m0 i) ?+ I8 c' t    }
8 E, q  V4 L$ `" L. \1 n  B    else
, p% ^$ P% k: P, X8 I& T    {
        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
}</P>

4 z" C5 z( Z. ^: U2 h<>
//-----------------------------------------------------------------------------
// Name:
6 X9 N& I* g1 q2 }// Desc:
$ Y( K; b* N& Y//-----------------------------------------------------------------------------
' t- W; \2 F) `3 ]% Wvoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
+ Z) N6 M# w( R! D1 Y{
    if( x1 == x2 &amp;&amp; y1 == y2 )
+ n7 a# b/ N, K, t    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            UnlockCell( x1, y1 );
        else
            m_OffMapLock.Leave();</P>
3 b4 F) s5 g' Y# }  h<>        return;
: w8 D& X. F0 K: A- V5 l3 A# m    }</P>
<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
* m+ S6 o" U' E    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<P>    if( x1 == 0xffff )
3 y* U: U- o9 K! b* o% d- h+ e2 s3 G    {
1 [# Z! r2 C# `: O        m_LockGrid.UnlockCell(x2shift,y2shift);
$ P5 G9 v+ S8 c! [* b        m_OffMapLock.Leave();
) s; H5 t; w. V! x% @$ a2 t" C& d% {    }
    else if( x2 == 0xffff )
7 [& B8 c/ y# ?$ H3 ^' @    {
) B3 Q4 ^0 n6 _: T( i$ k% _        m_LockGrid.UnlockCell(x1shift,y1shift);
+ E- P! v& b/ r/ n. F        m_OffMapLock.Leave();
    }
    else
    {
6 E2 t2 Q1 s" Q2 ^+ I! c        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
}</P>

: y8 g1 y8 E  z1 O& h<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::OnAddConnection( DWORD id )
{
2 _" {' x8 A! @% l5 W    m_AddRemoveLock.Enter();</P>
# q6 V. X# e* m3 m" u' r<P>    // Increment our count of players
  i$ X, K& p5 l- T! p    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
; X" Z8 E3 b& q4 [+ c    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
  l$ v( v3 E( j3 U2 U$ r# T, v        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
( i, S6 `9 N0 G+ q<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
<P>    // Create a player for this client
    PlayerData* pPlayerData = CreatePlayerData();
    if( pPlayerData == NULL )
    {
- S& K" c9 _7 K' U3 B( c        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
        m_AddRemoveLock.Leave();
        return;
    }</P>
  O( [. c' m' ~/ `$ N4 m7 q$ V" v<P>    // Store that pointer as local player data
& ^: n$ w7 @+ s$ O2 [8 o  {& {; o    SetPlayerDataForID( id, pPlayerData );</P>
<P>    // Grab net config into to send to client
" F2 W% D5 W# J9 o$ n    m_ClientNetConfigLock.Enter();
# u+ E# Y6 D8 H! F& L" c. U. |2 s    ServerConfigPacket packet( m_ClientNetConfig );
8 p" I7 _; {8 c; E# J    m_ClientNetConfigLock.Leave();</P>
7 d* P- C$ v5 V0 ^<P>    // Send it
2 v! s3 M8 L6 N, |! Q. E/ r& T% O0 t" T    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
<P>    m_AddRemoveLock.Leave();
}</P>
+ m1 l, [9 l& Y7 U
2 O/ f& E% N5 d" t9 z, k  `<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
4 Z( Y6 o5 i; t9 U# S; o+ s3 y//-----------------------------------------------------------------------------
* L6 _0 w" N, j5 l- [! Kvoid CMazeServer::OnRemoveConnection( DWORD id )
{
    m_AddRemoveLock.Enter();</P>
4 f% [: Z9 m& B- {! q9 R. h<P>    // Decrement count of players
    m_dwPlayerCount--;</P>
<P>    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
7 ^4 b- Y8 H0 H& y2 C$ `        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
9 l+ K6 G. w7 S  ]    }</P>
<P>    // Find playerdata for this client
    PlayerData* pPlayerData = GetPlayerDataForID( id );
* B- Q6 C1 R7 P. U) Q( s    if( pPlayerData != NULL )
    {
6 O9 I9 B7 {9 X8 Z* f        // Destroy it
5 Q' i. h& s* }7 I1 V* X        RemovePlayerDataID( pPlayerData );
% @9 k2 J; [) C9 u' s        DestroyPlayerData( pPlayerData );
    }</P>
<P>    m_AddRemoveLock.Leave();
}</P>
- _4 d5 C& |% F' L7 `
# L5 Q- d. c7 [5 B8 E2 H<P>
; l& D+ e  ^( r//-----------------------------------------------------------------------------
// Name:
// Desc:
. R* u: z0 j# }& I/ Q//-----------------------------------------------------------------------------
1 M% |4 N- x8 b' ]5 U: ]% E; |HRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
; z' w# J/ x& y6 b8 }{
( T6 E+ s+ _# S7 s5 ~  Q    BOOL fFoundSize = FALSE;</P>
% o& l+ Q+ T1 K' s<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.
7 R) I) Z/ i$ I( a' A2 y8 t, j% [6 R5 i    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
8 S" S8 [6 `, N* m9 o/ P8 _& f! `7 u. I<P>    m_wActiveThreadCount++;
  s/ q$ ^% _. J9 c) h1 U. d    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
   
. r2 K7 A* y" O. l* p* N8 p* a" J    // Calculate and average.
    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
  z+ q8 n  q' t1 S: @- @    m_fAvgThreadCount += fdiff/32;
6 m9 L' u; ?: k0 s( ?   
    m_csThreadCountLock.Leave();</P>
7 R7 z# B, |; |$ W2 H: J. ]<P>
# X7 b* \$ q5 K# `    ClientPacket* pClientPack = (ClientPacket*)pData;
' y+ Z( T' l+ a; |6 V, W    switch( pClientPack-&gt;wType )
    {
. g" p/ l4 u8 r) d, K        case PACKETTYPE_CLIENT_POS:
            
, x( u, u. ^" f( K$ O            // Check to see if the packet has a valid size. Including
            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
4 c0 C! g, R! [! E$ W6 y                fFoundSize = FALSE;
0 A# H- I6 m: k9 Y- X" z            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
% i( M( \0 T" k                fFoundSize = FALSE;
            else
7 [, r, w# b& q6 l) a7 R                fFoundSize = TRUE;</P>
2 ~' o7 v7 q5 }, `  N- R<P>            // If valid sized packet, handle the position.
            if(fFoundSize)
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
7 x7 G( t4 F2 u: l4 t            else
* N& w* Y0 D6 @  X; z! O2 {                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
            if( size == sizeof(ClientVersionPacket) )
" C) s/ A7 z1 l6 x5 h                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
4 R5 s# B; m+ `4 u$ [            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
% N+ {9 ^- M9 m            break;</P>
; \! u" P# |  L- W$ ?1 d( Z6 l<P>        case PACKETTYPE_SERVER_CONFIG:</P>
<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
<P>            break;
        default:
2 j0 u3 x3 f3 `& K7 A            HandleUnknownPacket( dwFrom, pClientPack, size );
2 Y0 l  I" D/ X, t. D# i* F' S3 U            break;
    }</P>
+ p+ H4 d0 x( \  g0 `<P>    //If the user wants to hold the thread, Sleep for given amount of time.
    if ( m_dwServerThreadWait &gt; 0 )
    {
. r' F  z' j* e! u% O$ R- I        Sleep( m_dwServerThreadWait );
    }
/ }1 I2 H& K) a" E! o   
, J7 v3 g+ L. D8 |    // Retrieve thread data for this process.
    m_csThreadCountLock.Enter();</P>
<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
& b4 u' @, z! t4 E6 v' p    m_fAvgThreadTime += fDiffTime/32;</P>
<P>    //Get the Max time in the thread.
    if ( fDiffTime &gt; m_fMaxThreadTime )
    {
        m_fMaxThreadTime = fDiffTime;
2 a: _3 ~" c6 W3 z4 y, v    }</P>
5 T2 C5 ?3 `6 V# y<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
0 O3 \  {! j( r}</P>

9 F( v3 v3 e4 \% Y<P>//-----------------------------------------------------------------------------
5 S( @. P" r" A, s0 }// Name:
// Desc:
//-----------------------------------------------------------------------------
BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
{
    BOOL fFoundSize = FALSE;
    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
1 L/ G, c. i9 ~* B. X( n$ u   
  A/ g! j- p+ S9 u  y. g    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
) J9 Q# R5 b1 s9 J8 x0 z        {
/ X8 w* {( n; A% t            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
, y5 W# K1 b* L; I            {
" N/ }3 m/ w9 a  f& b* S3 @                // Found valid size in the array.
                fFoundSize = TRUE;
                break;
            }
            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
        }
1 ?$ P0 Z/ q! l' j# ^4 v    }
    else
- X" @* g' M2 j% T  @: K" L% |    {
        fFoundSize = TRUE;
5 D9 v0 {- Z2 |0 R4 S8 D. Z0 g    }</P>
<P>    return fFoundSize;
5 z# f/ t/ k% ^6 f2 B( T4 K+ s}</P>
<P>
' x- N& Y9 Y( @/ W* C//-----------------------------------------------------------------------------
// Name:
% ~; f( _; I  o8 I( U// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
4 F/ d+ A: S: y! Q{
    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
}</P>

5 Z# v% \4 i0 r, C" T' p& k<P>
& {! e* Y. o9 Q: V//-----------------------------------------------------------------------------
, d% \$ ]- b2 G& l/ C/ H// Name:
7 q6 |, {; \- n4 Y// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::CreatePlayerData()
; p- b' K2 q: b5 p$ w{
    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
8 l$ r3 F* r, ^# T' p- o    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
    {
* r3 K: u5 D2 d3 r) A/ |        LockPlayerData( pPlayerData );</P>
<P>        // Got one, so remove it from the free 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;
' D) y3 Q/ i* s  ~, v        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
<P>        // Add it to the active list
$ I# X- m  b$ H1 ]        if( m_pFirstActivePlayerData )
& R: v. V# X  A+ ^7 y1 H            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
) z: a' P. v' c9 k0 h        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
3 V( E7 {! E: [9 y5 g" F5 S' o        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
        m_dwActivePlayerDataCount++;</P>
) H! s& J; U  y<P>        // Generate the ID for this player
        m_dwPlayerDataUniqueValue++;
1 y$ x$ M1 U# ^! @6 i* @        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
4 q" s' f' E) ]  w8 r$ T<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
6 }' e3 `7 Y" S4 Z+ A& C. `. [        pPlayerData-&gt;NetID = 0;
  x; w0 c* r; P2 x: M2 i        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
. G7 i6 G9 |# b0 u. B<P>        // Insert into the "off-map" cell
# F9 t6 _- I. }' ~+ ^0 w        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
4 E1 z; A2 z4 \" h; S7 s$ A# ?$ n" I" _        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
        m_OffMapCell.pFirstPlayerData = pPlayerData;
5 W& \1 C* R7 p' ^/ L% J% p7 a        m_OffMapLock.Leave();</P>
# C4 k; T# R+ M5 z+ V<P>        // Mark as active
; M9 n5 |- P: x: E        pPlayerData-&gt;bActive = TRUE;</P>
6 F8 x: ^9 L# }/ i4 E9 s<P>        UnlockPlayerData( pPlayerData );
1 o8 q2 i* C& `! X% Y: I    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
<P>    return pPlayerData;
, B# S/ p+ T6 }% }8 I7 I/ D}</P>

<P>
//-----------------------------------------------------------------------------
  _! B7 u1 c4 K4 Z/ B6 z  @// Name:
, O2 x" N# u0 r+ Y. P, q// Desc:
: o$ ]# \. @, [' [" F# P: K//-----------------------------------------------------------------------------
/ h! F2 q0 U6 H1 }# {( q! ]& Dvoid CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
4 _2 I8 ?( g0 Y9 l  Z/ e{
, ]6 }; J2 a/ g+ T5 R    m_PlayerDataListLock.Enter();
    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
" b7 i8 O  t; O- J* Y' J    RemovePlayerDataFromCell( pPlayerData );</P>
<P>    // Mark as inactive
; i% F, _2 g' N) {    pPlayerData-&gt;bActive = FALSE;</P>
; E  ?: O; w4 @8 \<P>    // Remove player from active list
+ U% j' E7 @% i! S& j* t    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>
  T  i) M, W  O: L0 K<P>    if( m_pFirstActivePlayerData == pPlayerData )
3 q4 t9 X8 [* Z, \" |        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
" O7 P7 t+ V( C* M! P        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
7 R. y1 U0 |  x    pPlayerData-&gt;pPrevious = NULL;
" L4 a6 e' f6 B    m_pFirstFreePlayerData = pPlayerData;</P>
<P>    // Update count of players
    m_dwActivePlayerDataCount--;</P>
2 W, O. P& W/ g& I0 [<P>    UnlockPlayerData( pPlayerData );
    m_PlayerDataListLock.Leave();
}</P>
+ H1 v; b9 I# q7 T  x; o
0 p$ {0 ], K* t! u2 }<P>
& Z) q: \8 }9 \, p" x//-----------------------------------------------------------------------------
* a  j* ]" f8 l$ f5 D; i// Name:
2 Y* j, I$ V1 [// Desc:
; x) g% d6 I  T' ?; K* \1 u//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
2 E( |% a+ H" x* M" ^; M5 h/ `    // Lock the player
$ S# W4 f. G3 `4 Q7 F6 ?4 d    LockPlayerData( pPlayerData );</P>
<P>    // Lock the cell the player is in
    ServerCell* pCell;
    if( pPlayerData-&gt;wCellX == 0xffff )
: n2 b4 m/ p$ a4 g4 Q1 r( v    {
0 E* G, M/ s$ F        m_OffMapLock.Enter();
* K! t2 r$ r/ u; L        pCell = &amp;m_OffMapCell;
' G% l  {4 `/ S- _: u1 t3 _    }
    else
) N* k% ]# c) |0 ^/ I: C* }/ D    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
6 f$ G- J( E3 `" d. ?        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
    }</P>
<P>    // Remove it from the cell
3 |/ [5 i  j) ^3 B8 Y6 u2 p: h    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
    while ( pPt )
3 a! o$ D8 M% U) [3 c2 ?    {
        if( pPt == pPlayerData )
        {
8 j( Q/ z. \% P5 z  Q+ x4 y3 _+ {7 b            if( pPrev )
& }$ \& |$ I  {, V, O, R6 ~% X/ q6 o                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
' l& x; ^  h- G+ n' M; w* v  t8 W            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
' ~' j, s' ^) h& ^        }
/ i3 ~! O! q5 _9 J! X- {0 ~4 l        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }</P>
) c" t7 @, Y: {+ G% x7 u' z+ u<P>    // Unlock the cell
' N/ Z# O; X6 A9 ?" Z4 {+ w    if( pPlayerData-&gt;wCellX == 0xffff )
: j' W$ c) W5 `6 h9 ?: Q, J        m_OffMapLock.Leave();
7 Z- i' a9 z' c3 t) N4 E% Y" R    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
8 m; M; p# f2 f# _( ?<P>    // Unlock the player
6 D5 n8 l9 G7 S8 e( t    UnlockPlayerData( pPlayerData );
}</P>
) z1 ^' l! K9 r, H
<P>
& }: ]; ]4 R# Y//-----------------------------------------------------------------------------
4 {# K3 J5 W% E6 j/ z// Name:
4 f7 V7 N( Q: C// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
{
    ServerCell* pCell = GetCell( pPlayerData );
- [  C% s* Q- I+ N8 }+ H- S    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
8 b- y% R' K3 {+ a$ v' C0 ^: \9 m6 c    PlayerData* pPrev = NULL;
0 k' E+ B8 O1 j1 r( p    while ( pPt )
/ ]( V' p) R& ]( K# ~+ V& }    {
3 G% r- `% ^1 m- n# E# |2 S        if( pPt == pPlayerData )
        {
! u1 ?  ~; W, q. t            if( pPrev )
, J0 \# p7 S9 T2 H                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
% h6 T" o; h1 P8 {6 }            else
% ?5 H$ Q% f) l- x                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
# z' L5 q. t  R: i            pPlayerData-&gt;pNextInCell = NULL;
            break;
  ~1 @6 E; m9 ]( G! d        }
        pPrev = pPt;
- Z% K) H% _0 c        pPt = pPt-&gt;pNextInCell;
    }
0 P' y% P0 K, J/ _}</P>
1 N' U# j; ]0 e
5 h7 h. @. i  v* S<P>
6 P( s! ^+ m( q9 f9 T7 d5 `# D$ [: O//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
+ P, N! W" M! u5 S# {void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
    ServerCell* pCell   = GetCell( pPlayerData );
; ]  |8 `3 z2 D* Y    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
    pCell-&gt;pFirstPlayerData = pPlayerData;
  H( ]  P4 g2 U}</P>

<P>
//-----------------------------------------------------------------------------
# j+ C6 W# B0 s6 `6 ^9 S8 Y// Name:
0 B8 y& T5 u/ @& J// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
: f* o7 X7 x5 p: K& l3 Q    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
5 A/ m( D  U4 G0 ~7 T% G    if( pFromPlayer == NULL )
    {
; H, ]. E" p, Q6 O% i. z$ c        if( m_dwLogLevel &gt; 1 )
2 Z0 Y5 P- t( f7 c1 l. i; u0 c            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
        return;
! q4 n) V: Q5 G/ N8 ?- s/ U- J    }</P>
<P>    LockPlayerData( pFromPlayer );</P>
  t' A4 Y% ]  ?6 G# P% U2 x- s<P>    if( FALSE == pFromPlayer-&gt;bAllow )
0 T8 C# U" ?( K& L' K* U; v0 u" @    {
        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 );
        UnlockPlayerData( pFromPlayer );
1 C  R5 Q( \6 H        return;
    }</P>
<P>    // Compute the cell the player should be in now
    DWORD newcellx = int(pClientPosPack-&gt;fX);
+ a- C6 ~1 F$ m8 L8 X5 }$ x' N    DWORD newcelly = int(pClientPosPack-&gt;fY);
    DWORD oldcellx = pFromPlayer-&gt;wCellX;
) m' t% e% {) V6 z    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
<P>    // Have we moved cell?
3 J6 X+ |5 s+ B. Q9 @1 r0 {8 J8 B9 q: w    if( newcellx != oldcellx || newcelly != oldcelly )
1 {8 c5 L, e$ f5 I: I    {
        // Yes, so lock the pair of cells in question
        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
" g5 o8 ^5 ^/ A+ e/ y" C7 E; K<P>        // Remove from old cell and add to new cell
        UnsafeRemovePlayerDataFromCell( pFromPlayer );
0 J' R7 q+ {; W        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
6 K( a2 y1 E9 ^3 R: Z" i* a<P>    // Update player position
    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
* U1 {  R% t: R5 ^8 N7 _: Q    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
7 k# c1 w. a# z& n9 ]<P>    // Allocate space to build the reply packet, and fill in header
    DWORD dwAllocSize;
2 X4 Q, K, N) l+ x+ U) E    ServerAckPacket* pSvrAckPack = NULL;</P>
% `0 V" w: ?! v! P  P<P>    // Begin by allocating a buffer sized according to
    // the current number of nearby players + 4.  This will give
    // a little room for more players to come 'near' without resize
    // the buffer.
    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
9 v- W% ?/ H! [, N; E- S<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
6 u$ y( Q- T# \* d/ ^    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
7 n% H2 Z( M! X9 l1 x    {
: O6 @# B' @8 m! ]/ ]  N        // Out of mem.  Cleanup and return
% o2 x; H8 K, F/ S6 H8 P1 b% z: m        UnlockPlayerData( pFromPlayer );
        return;      
/ o/ S$ w1 L( [$ K  X+ a    }
; W: x9 x; Z7 k1 J    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
( t; v6 c& V# R' q$ o<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
, G1 i6 T* v  N3 v: @& k9 i8 M1 `    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
( Z$ a7 j  A7 i* M2 D. @' o    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
4 T  @1 d( C8 |9 m7 l<P>    // Compute range of cells we're going to scan for players to send
    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
) c/ @; B! |. \    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
    // our pSvrAckPacket until we run out of room
    for( DWORD y = miny; y &lt;= maxy; y++ )
* x2 ~1 v' C/ H    {
        for( DWORD x = minx; x &lt;= maxx; x++ )
" G% W8 u* g# h5 w" p1 g        {
$ S! \( \2 [6 [, n            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
            while ( pCurPlayerData )
9 p3 L" W: Q. D. @. {6 y            {
                if( pCurPlayerData != pFromPlayer )
                {
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
- F; j5 V: y$ q$ L, N                    {
: ^& F5 K4 }: L3 @                        // Make sure pChunk is where we think it is
                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
7 [5 K: R! v. c: f: Z: s. Y8 b; T<P>                        // There are more than just 4 new nearby players, so resize the
                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
  B( j2 f; R* U7 `- J1 F                        dwMaxPlayerStatePackets += 16;
                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
( h! f6 ]  z# W& r                        if( NULL == pNewSvrAckPack )
  [1 E! a& e7 B$ h8 m/ a                        {
6 O/ J( v" Z) v* i* V) B                            // Out of mem.  Cleanup and return
: R. \& ]. B, \9 T8 n* x4 Y                            free( pSvrAckPack );
& l3 G, W* j# I6 L* ?. X& M+ v                            UnlockRange( minx, miny, maxx, maxy );
                            UnlockPlayerData( pFromPlayer );
                            return;      
                        }</P>
<P>                        pSvrAckPack = pNewSvrAckPack;
: b( }1 g6 G# @9 R% _9 ~                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
<P>                        // Make sure pChunk is still where its supposed to be
                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
                    }</P>
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
& `% z5 c8 n- G                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
                    pChunk++;
                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
$ m3 ~7 A1 x/ D9 i$ z6 S            }
' ]% c# S, S9 Q* D$ u0 ~2 ?        }
) W" o6 G2 z: y2 _    }</P>
<P>    // Update the dwNumNearbyPlayers for this player
  {. J; C0 N* H% S- I& V; @    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
$ T5 r  m  L9 s3 j6 m# p4 m, K<P>    // Unlock range of cells
8 D7 U1 G. m3 a    UnlockRange( minx, miny, maxx, maxy );</P>
<P>    if( m_dwLogLevel &gt; 2 )
    {
+ |6 E5 e) e# r; T1 Z8 i        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
    }
- M! b, X, ]& `6 _7 i- N$ z    else if( m_dwLogLevel == 2 )
    {
  }$ J) v6 Z( }9 z* `6 h7 h        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
        {
0 Y" U0 a+ Y+ [* @            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;
. }) I* c' D6 i+ ~1 C" F! |        }
# ~% Q* \. I2 A$ w    }</P>
  B  [' [. C8 N) Z' V" G& |6 f  M7 @<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
) o& V( Y  }. H. _" e+ ]! H<P>    // Send acknowledgement back to client, including list of nearby players
- S+ G6 R* e- e$ ?    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

7 `2 q' F9 D# n1 E) H1 [9 X    // Pack the buffer with dummy data.
+ s; N8 ?* Q+ H) ^4 A    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
, \. g+ h% |5 n- M( }& x        VOID*   pTempBuffer = 0;</P>
<P>        pTempBuffer = malloc(dwBufferSize);
! {4 h* A+ N+ o$ a4 u4 \        if( NULL == pTempBuffer )
* {. l; g! j! s( Q) N% u        {
            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
            free( pSvrAckPack );
            return;
& c- L  l, m8 Z& E5 _3 K% e& ^        }</P>
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
7 _& o( h: ?) `+ h   
        free(pTempBuffer);
    }   
    else
    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
, J: P* T9 c" D1 b, m6 a    }</P>
<P>    free( pSvrAckPack );</P>
<P>}</P>

<P>
! ]# Y- ~* _5 U" h//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
1 |4 h4 W  O5 U7 N5 W. A{
3 C# V( x) \# O) T    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
    if( pPlayerData == NULL )
        return;
2 O; Z1 G6 _8 L1 E1 a$ T    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
<P>    if( m_bLocalLoopback )
' j  g( `6 j% I, P( I$ X  ~5 r6 x        pPlayerData-&gt;bAllow = TRUE;
) k8 i0 v  o/ }0 M    else
( f9 p! j: x% E( U        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
<P>    if( m_dwLogLevel &gt; 0 )
1 @) e4 \% E0 d0 j$ n3 W        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>
+ a0 B3 R7 P8 Y! }, x& q0 E& X<P>    if( FALSE == pPlayerData-&gt;bAllow )
* I8 ^  R  k0 J9 `    {
0 D3 v/ i+ l7 }; Z# }) V( N/ }        if( m_dwLogLevel &gt; 0 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>
& g" Z; i6 v  l<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pPlayerData );
        return;
* Z9 B+ z( s  I& k6 k) y5 F    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pPlayerData );</P>
<P>    // Send acknowledgement to client that the client was either accepted or rejected
) E( }% g& q1 \1 \! c    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
+ R1 U4 z, e( p7 D7 P. |! R}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
' i) V/ Y# ]! Z3 t, k- |9 s// Desc:
, B# f0 w' v: r//-----------------------------------------------------------------------------
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
{
4 B* K+ ~* a, x+ e    switch( dwClientVersion )
    {
& G+ {; G& t- q        case 107: // only v107 is supported
5 h* I/ C! [- }9 r3 ?7 A            return TRUE;
        default:
            return FALSE;
    }
) I( u3 c" e" S3 J5 m# R9 V# w}</P>

: R7 n0 t  |( e8 N6 D5 u2 B. s( K& ^<P>
) Z4 T  H& x$ P- F2 m//-----------------------------------------------------------------------------
  s3 J6 A+ n9 [. d( E2 P// Name:
// Desc:
' N" a; j- w% `" R. f; c//-----------------------------------------------------------------------------
  H+ O& X3 }2 _2 lvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
+ y; u% J+ ]( d{
- Q; ]6 q, _5 a: A& h: Q    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) h  `+ ?3 E  B. y# E3 q}</P>
: i6 a  ?. l" ~  s/ U6 H& ?% z" H( F
<P>
, X- b& o, k0 ^8 o# x  ^7 u# j. d, M//-----------------------------------------------------------------------------
7 R) W# f' x1 s) O) b: ~// Name:
9 x& K8 `9 o: d# T/ `. V; z// Desc:
5 y) k, N6 f4 O3 v- x+ k! _2 b//-----------------------------------------------------------------------------
' L8 J/ }& q, X. M9 WDWORD   CMazeServer::IDHash( DWORD id )
5 Y" a0 B; y# E{
5 V. P7 D3 n8 ~; G    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
4 f  r0 F3 r" e    return hash;
# k& O; I) c2 v* W! [4 J# Y}</P>

" J$ O  Q" k- j8 b7 m$ B<P>
//-----------------------------------------------------------------------------
& o9 Q. [+ g# e// Name:
  L& U, J! ~) W% p2 L( w1 s// Desc:
. m1 k/ O2 u" \* Y2 i( ]! i//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
<P>    // Lock that hash bucket
, r0 `/ u5 C9 W: ~  W8 h    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
' T! t: c4 w$ }/ _1 M    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPt = m_pstIDHashBucket[bucket];
    PlayerData* pPrev = NULL;
    while( pPt )
    {
1 c/ A2 s' a3 J8 y0 e, Q        if( pPt == pPlayerData )
, @% }/ Z( L# p) Z            break;
4 R6 S, P9 Y% h        pPrev = pPt;
        pPt = pPt-&gt;pNextInIDHashBucket;
    }</P>
9 P9 l* L0 J/ X3 u' N" ^8 ~<P>    if( pPt )
    {
        if( pPrev )
/ h: L3 j( _; ~, U  N! f. ^            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();
}</P>
9 d# _& f9 s/ w
<P>
//-----------------------------------------------------------------------------
// Name:
; L/ y, W2 n8 O8 A% L, `+ W// Desc:
$ r' D! w6 Q" D, }" m% H2 `//-----------------------------------------------------------------------------
: k3 B5 t$ y# q7 Xvoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
{
    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
    // otherwise there will be a circular reference
2 P) f+ D9 S, _/ ^1 A: P0 c, F    PlayerData* pSearch = GetPlayerDataForID( id );
: r  H0 Z4 s# K; J# y. i$ n    if( pSearch != NULL )
+ r4 r3 z% m* c6 y        return;</P>
<P>    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
+ I  r7 \# j1 W" X. ^<P>    // Lock that hash bucket
" L# r8 G6 H7 q    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
. [5 T( [. _5 q! g    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Add player onto hash bucket chain
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
    m_pstIDHashBucket[bucket] = pPlayerData;</P>
5 u6 p- w$ B/ Y) f& q) ]# n<P>    // Store net id in player
( p5 s7 E3 O9 ~: x& c. c- j6 ?' ~    pPlayerData-&gt;NetID = id;</P>
7 \. s0 l( M8 v' ^. {<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
# n: @- p2 m" g  h9 F}</P>

<P>
//-----------------------------------------------------------------------------
- z" ?0 B" K  b; i3 u// Name:
// Desc:
8 x5 E" w( v* C  B7 Y, {//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
{
  R$ h5 e$ {1 R2 s    // Hash the ID to a bucket number
+ R, n8 z1 g* Z4 T    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
0 V; g8 _1 L  V    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
$ X6 @5 W* L  `* H* x    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
* M) q# C( X% G- J    while ( pPlayerData )
. x" Y* \' J4 U* v, N$ y5 X) A    {
        if( pPlayerData-&gt;NetID == id )
            break;
/ x% t  k; P6 ~3 c* Y+ b        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
    }</P>
<P>    // Unlock the hash bucket
0 B2 y9 ~. k$ j7 t    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
4 ~- z% |. l6 j+ ?* h( \- K<P>    // Return the player we found (will be NULL if we couldn't find it)
    return pPlayerData;
}</P>
$ h2 f' H- d2 T  m% Z% \$ |# c
  Z1 b2 V% ]3 o1 n. G) Z<P>
2 _2 F; |! B' b4 r' _% I//-----------------------------------------------------------------------------
2 n3 S  ]0 w4 G# g! s" Z# \// Name:
" \; n9 T0 H9 H// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
  V7 E" n' E" e6 K6 k//-----------------------------------------------------------------------------
9 S( O# g7 E: p  s" O. |void CMazeServer:isplayNextConnectionInfo()
$ o& Q' {+ X; G" X{
    if( m_pNet )
    {
1 A; F7 v! l1 ~9 O        // Find the player that was displayed the longest time ago, and display it.
0 w5 W7 ~! k  M, ]/ @1 ^5 ~9 w5 w        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
6 |: I6 Q" [" o/ C9 ?        PlayerData* pOldestPlayerData = NULL;
! ~8 G: ~! C) p0 d6 g4 P" l5 e        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
4 I6 E6 L+ |  b9 X        while ( pPlayerData )
" h+ b' I, E( Y) L        {
            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
# _. D( B( {, h1 e) Y            {
                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
7 [' Q# P, M/ O. z& `; |8 {. b8 ?+ J' P  H                pOldestPlayerData = pPlayerData;
, G- F3 @2 x* M/ V4 U) ]( e) R            }</P>
5 a! Q4 K7 l9 N<P>            pPlayerData = pPlayerData-&gt;pNext;
' C5 Z, H0 r2 \4 G; k" J& o8 Q* W- i        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
3 [: P8 t7 ^" F* I6 R        if( pOldestPlayerData )
        {
            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
            pOldestPlayerData-&gt;fLastCITime = fCurTime;
        }
: l0 M. n6 u# |, ~        else
        {
  |, E8 K. I) R, N2 ^            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
        }</P>
<P>        m_PlayerDataListLock.Leave();
; X: B( w6 t- t" I2 a. ^    }
}</P>
9 N9 }2 T; ]. L" q* j; f/ d( l
<P>
' E) s' u7 m* N9 A" G' W% T//-----------------------------------------------------------------------------
// Name:
- x) P& m& I; M5 M% m9 p2 F// Desc:
7 `* Y* `, D/ L' z  |+ c. E//-----------------------------------------------------------------------------
void CMazeServer:rintStats()
{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
( k/ ?" o6 q) {# F& D                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
8 J/ }& K$ R( J. `                                    m_fAvgThreadTime, m_fMaxThreadTime );
    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
/ f) I) [+ ?8 L7 O# d2 T    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
7 |8 w1 j: l: Y// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:isplayConnectionInfo( DWORD dwID )
{
    TCHAR strInfo[5000];
; G) t+ I* G/ M    TCHAR* strEndOfLine;
    TCHAR* strStartOfLine;</P>
7 e5 ~3 v3 t! G, \<P>    // Query the IOutboudNet for info about the connection to this user
    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
1 f+ }* r. I  X' f4 A2 R9 S<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>
  m7 u! X( N+ |+ `" ^' {<P>    // Display each line seperately
    strStartOfLine = strInfo;
3 A  g- y; l$ {0 |' W8 d; Z) N# G    while( TRUE )
    {
; G# |  v2 T0 E& a/ R1 U        strEndOfLine = _tcschr( strStartOfLine, '\n' );
        if( strEndOfLine == NULL )
            break;</P>
<P>        *strEndOfLine = 0;
        ConsolePrintf( SLINE_LOG, strStartOfLine );
! g  A' T* p* }% o5 [' Z/ S        strStartOfLine = strEndOfLine + 1;
% {, c  A1 k0 C    }
}</P>

<P>
//-----------------------------------------------------------------------------
7 |+ Y) K/ l5 B// Name:
6 H% D, [- R* b, ?  O! M; {( ~// Desc:
5 I  K! [5 B: T% J//-----------------------------------------------------------------------------
) n. P. m, G* i" ]# k5 T: w4 `3 ZHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
- E% h% z& l& L/ x0 d: y+ K{
    // Chance of forcing any packet to be delivered reliably
    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
}</P>
# K2 N, N: s8 K- w) _# `
7 x5 Q5 B$ F+ d# h7 c<P>
8 W1 k. G+ S$ k//-----------------------------------------------------------------------------
// Name:
5 Y% A1 [& s8 m# i) P// Desc:
//-----------------------------------------------------------------------------
$ z% g+ T8 U3 i, M6 e8 E4 w4 V; V" wvoid CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
2 F$ s; n# ?; \. ]( F2 V& W{
! x( [: y! t0 c8 @9 z* k, i    // If we're up and running, then send this new information to all clients
    if( m_pNet )
5 s2 u+ S+ H6 |( |' L, Z9 O* C    {
        //Use the AllPlayers ID
        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
' K  [' m) }# w' [; ]}</P>

<P>
//-----------------------------------------------------------------------------
" x1 z4 T# f. |. [+ Y+ d. D7 I$ }& r// Name:
// Desc:
% Q' {& ~6 a" c# W  n( t//-----------------------------------------------------------------------------
void CMazeServer::SetClientReliableRate( DWORD percent )
6 T. @: ?/ t$ x" u1 R# k8 W{
    // Update client config, and build packet containing that data
$ w( y2 w. s! r1 G    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.ubReliableRate = BYTE(percent);
5 }3 V4 z7 o& B0 ?    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
) w6 }1 P$ D) L4 ~( z6 j  p<P>    SendConfigPacketToAll( &amp;packet );
# I$ P( r3 Y0 g6 m* R' k. J: Y}</P>

<P>
//-----------------------------------------------------------------------------
: ^3 ^5 K; L: X/ D2 P. ?  m// Name:
// Desc:
9 J; }8 d4 p. A0 u% Q8 M% l//-----------------------------------------------------------------------------
- L( h4 m9 g6 Wvoid CMazeServer::SetClientUpdateRate( DWORD rate )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
( ^- H& g% {& {$ Y    m_ClientNetConfig.wUpdateRate = WORD(rate);
& O9 U8 z! m% W1 _7 O    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
; a" C9 U# M4 [+ p5 O, Q9 n<P>    SendConfigPacketToAll( &amp;packet );
  Y2 c9 T+ q% H! p. J4 l0 _}</P>

<P>
//-----------------------------------------------------------------------------
# r! [: M3 m3 g: T// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientTimeout( DWORD timeout )
{
7 W8 m' F3 w+ }    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
6 V/ X6 Z/ O3 \4 L4 D. w7 L/ t    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
# V' o/ B6 J7 R3 F( e/ W    m_ClientNetConfigLock.Leave();</P>
8 Q. H4 u2 b' a# s+ {$ `<P>    SendConfigPacketToAll( &amp;packet );
}</P>
- V1 g/ k) {. u0 n# G
<P>
//-----------------------------------------------------------------------------
// Name:
4 f( U) D/ N6 [% l& y/ s// Desc:
//-----------------------------------------------------------------------------
' k7 `0 r- J! [' R) E9 |# {8 Dvoid CMazeServer::SetClientPackSize( DWORD size )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubClientPackIndex = 0;</P>
<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
* m6 D: y  M. w1 T    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
) X0 o6 }3 s- O+ \& A+ E}</P>
" B6 r  `+ d- |/ I* }
( @+ X# ~8 Z8 g<P>
//-----------------------------------------------------------------------------
// Name:
( Q0 r- t, r8 H3 L- _/ G// Desc:
( d8 D" ~- u+ G$ |3 r) q! ?' l1 h//-----------------------------------------------------------------------------
6 w1 n2 x% c) x9 B/ K" rvoid CMazeServer::SetServerPackSize( DWORD size )
{
2 G+ _! F: W! h. T6 s. w) f    // 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)   
, y; X5 I( D$ g        m_ClientNetConfig.ubServerPackIndex = 0;</P>
, d: w: Q; ], P; y: C<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
# ?: b" d5 K3 E  c% \5 A8 }    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
5 ^/ w1 Q* E$ q}</P>
4 @! ]; A& B* n' z2 Q<P>
" o* z' y+ u  R" }4 R//-----------------------------------------------------------------------------
/ q% ]/ A) n# L6 U! H" M- p// Name:
// Desc:
//-----------------------------------------------------------------------------
: o6 P+ t: ~8 d% x! |/ o* [: ivoid CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
/ Y: }* V5 r( x. Z/ p' a{
7 j# x4 w- j8 v    // Update client config, and build packet containing that data
0 J7 R2 g3 v9 T    m_ClientNetConfigLock.Enter();
2 z! J- Q2 {  q9 r, g& g: W" J   
0 B% S2 S; P$ D9 ~. f/ N    m_ClientNetConfig.dwThreadWait = dwThreadWait;
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
, ?) b% n: `. y, h# P<P>    SendConfigPacketToAll( &amp;packet );
# x1 F  B# M8 u* S$ g" W9 z}</P></DIV>