[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
' k- i1 Q6 M$ ]0 M# |! r3 z- J<>// File: mazeserver.cpp
6 v5 b# ?$ A  _1 i" W9 x//
// Desc: see main.cpp
  U: ~! I& H9 m- o3 \//
: `/ T, V- C) {// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
& l' D: l4 R) k, F+ L/ L#define STRICT
. Y$ u$ r7 C: I. K#define D3D_OVERLOADS
+ b4 T  l& Z, A) N( ^6 g#include &lt;windows.h&gt;
& N; k1 w; X4 e#include &lt;d3dx.h&gt;
% e# b; U0 A+ g/ [. ?#include &lt;stdio.h&gt;
& m4 H  D5 ^- i7 F! C7 Y7 N2 L#include &lt;math.h&gt;
#include &lt;mmsystem.h&gt;
#include &lt;dplay8.h&gt;
  v* l+ }* a9 O' V#include &lt;dpaddr.h&gt;
$ d( ?6 m* t6 R# c#include &lt;dxerr8.h&gt;
9 w! v  ^* w; r, `3 x* W#include "DXUtil.h"
#include "MazeServer.h"
  V' `+ S: @1 ]% Z4 ?#include "ackets.h"
% D! k) N5 f) t2 U$ b- P. \#include "Maze.h"
#include &lt;malloc.h&gt;
% q) n. t% Q$ ?4 b( S: y#include &lt;tchar.h&gt;</P>

2 ?4 E) s( b2 C( _6 g' R<>//-----------------------------------------------------------------------------
7 H- y! B+ {; \9 v9 y// Name:
, V$ c& x# {2 U; ]// Desc:
//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
2 u  C7 O/ f7 k- ^7 {{
. V  D' f. A6 L" u& A* V' h    m_dwPlayerCount         = 0;
   
    m_wActiveThreadCount   = 0;
/ {2 i$ s& V3 z2 q  P# a    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
. d) v. [& H- c7 k7 g0 W7 ^    m_fAvgThreadTime       = 0;
    m_fMaxThreadTime       = 0;</P>
<>    m_dwServerReliableRate  = 15;
    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
    m_pMaze                 = NULL;</P>
<>    m_ClientNetConfig.ubReliableRate = 15;
* B+ {2 M, K3 Q' _3 E& o    m_ClientNetConfig.wUpdateRate    = 150;
    m_ClientNetConfig.wTimeout       = 150;</P>
<>    m_ClientNetConfig.dwThreadWait = 0;</P>
9 k3 o" s7 _- o- @6 ~' x<>    m_ClientNetConfig.ubClientPackIndex = 0;
6 L$ Z7 s, g0 W9 y9 t9 U    m_ClientNetConfig.ubServerPackIndex = 0;
    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
  C. h$ ?5 ~1 p        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
% |2 i5 s* L' [* |    }
9 }# K1 ^" F3 B& @/ f7 e' [}</P>
! R8 w( m% z5 R$ n" W5 l+ P, G
' q; d8 I. f: _, l<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
5 B& @. I; O' Q* b2 W% ?: c. N4 |//-----------------------------------------------------------------------------
HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
    m_bLocalLoopback = bLocalLoopback;
1 Z/ C1 m- |4 ~9 L" l% M( u9 K    m_pMaze = pMaze;
7 ^3 M) c* `" }2 l9 I    if( m_pMaze == NULL )
" K" z( Z( n, ~+ U. V        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
& l: N/ @, v" \0 A<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
5 R( Y" H  K! D+ v+ _    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
" O2 c  B" a. d/ x' U$ @6 g<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
$ S% b$ g/ q7 v" \+ s    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
0 @& T3 H) y2 n: d& S        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 )
        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;
$ g; }4 @, [$ C9 S* q4 M    while ( (scale &gt;&gt;= 1) )
; c6 t' k3 m4 T. I* [  ^2 c) f: p        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
6 v  W% R+ W5 V- x: R: P    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
        m_dwMazeYShift++;</P>
<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
        ((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>
0 t% F6 S4 k+ w- K9 E<>    // Initialise the player list
7 ?( S; ]9 H/ B, I$ u    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
+ y$ y4 ]. B2 L$ p    m_pFirstActivePlayerData = NULL;
# ^3 R6 ?/ P/ m: s0 |    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];
    }</P>
' z' l  h6 q0 [7 c! t! E<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
9 {6 E) I. z, _- G0 k: v    m_dwActivePlayerDataCount = 0;
    m_dwPlayerDataUniqueValue = 0;</P>
9 J! H7 ?1 f4 U/ p' k, ]! e. W<>    // Initialise the cells
    ZeroMemory( m_Cells, sizeof(m_Cells) );
, y' a/ s) z; B; z/ q: J    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
7 [5 k1 M5 B( E% d$ Q<>    return S_OK;
, ?7 W& C  C8 U}</P>
0 h) b0 V8 u6 b+ l- A- r
<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::Shutdown()
{
}</P>
2 P; y% v( \% D" A: {5 [( Z. Q
<>
//-----------------------------------------------------------------------------
// Name:
  }) e5 r- P7 x" p& N// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
2 k  [- u* V+ T9 E/ l) x{
9 ]" d  n1 u9 ?2 U' f" l' q    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>
& R( o6 c/ L( k7 q3 h, P. w
3 J6 N' Z: {7 G0 y- X( `7 E<>
; r+ \+ ^9 _. p( T& ~//-----------------------------------------------------------------------------
// Name:
, F4 W1 }; Y, N& S9 R) n" U) r4 y// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>

0 A1 y! N/ H6 |; `<>
- |' V4 Q# T5 i+ R//-----------------------------------------------------------------------------
// Name:
: W; Y6 }- H- Z# e1 w- ~( q// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
{
9 O7 d) B) u5 [% D  b* l    if( x == 0xffff )
        m_OffMapLock.Enter();
    else
7 C  K  A& q6 w9 n: M        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
9 ^" x' @" `! w4 |* e}</P>

( ~5 c, B, v' w# Z<>
) U' V7 N, I  k8 F! n: P7 o& ^//-----------------------------------------------------------------------------
// Name:
' n. J6 s8 i8 ], g. G9 Z" ~// Desc:
: |+ K& C. F: J//-----------------------------------------------------------------------------
! z- |4 F5 S. I! v! n; ^void CMazeServer::UnlockCell( DWORD x, DWORD y )
/ c& |6 g. c$ \; p8 Y) `0 A6 b{
. |' g6 d/ u9 P2 s: I  f    if( x == 0xffff )
' ^" `) n0 ^# o4 x        m_OffMapLock.Leave();
" S- V- c  K% ]" i    else
        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
# {) c7 F# A" B) V6 O
<>
5 g1 u; Q% H: v2 d8 G1 A. H: V% R//-----------------------------------------------------------------------------
% y( t  s" H* g' M// Name:
// Desc:
. M% P1 n4 c* Z: a# m//-----------------------------------------------------------------------------
- Y& ~8 r8 e) u4 r1 uvoid CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
7 p9 C+ N8 C1 t7 Y1 h0 T* d    if( x1 == x2 &amp;&amp; y1 == y2 )
+ b* `# I6 W* ~, G2 V6 f  Z    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
7 v) _4 g. I. A) {1 M3 B- e8 w        else
4 c# h" t- Y! g" V            m_OffMapLock.Enter();</P>
<>        return;
5 L  d0 L  G: J# B, T    }</P>
2 ^7 a1 {0 l0 R. X/ Y; i* ~, a<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
/ a; a9 n' E" E$ W1 u9 W, C4 D    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
" z4 e& C6 c9 r; V    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
2 d3 B3 w+ i) t! d0 z/ h5 i3 I# V    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
5 Q5 d" W* M8 o( y! S<>    if( x1 == 0xffff )
    {
* q% Q' f. u6 n+ k" B        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x2shift,y2shift);
. T( m5 t; e0 p4 R, r% h) s    }
  H! q( _& S/ P2 d3 e; K    else if( x2 == 0xffff )
    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
6 a, S0 z: R) o) L6 M    }
    else
    {
( o$ A0 ~. J" Z        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
}</P>

<>
; a5 M0 ]2 r. o' z+ R. ~/ T: b//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
/ ~5 d- Z( C. b$ I; H" B0 P{
    if( x1 == x2 &amp;&amp; y1 == y2 )
5 |! n* p0 |6 x& y    {
2 a+ r# ?& h# K" J' H7 d        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            UnlockCell( x1, y1 );
: @! X+ b2 P9 V        else
6 g7 `8 n1 j- {, D$ i/ i            m_OffMapLock.Leave();</P>
5 ^9 i  e$ Q; ^$ }! D: ?4 Q, d<>        return;
+ G! N; y) t" T1 l) @( j6 q; T    }</P>
<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
$ R& C" |! b4 _0 e& C    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
+ U/ A. L( J* x    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
) ?* T! K. q  k; H  l) r1 g<P>    if( x1 == 0xffff )
' C7 N$ P7 ^/ {/ o/ L    {
        m_LockGrid.UnlockCell(x2shift,y2shift);
        m_OffMapLock.Leave();
    }
. h  N, K5 [1 X% `& s. b! s    else if( x2 == 0xffff )
  ?1 R( _% d. t7 [9 W" Z    {
$ [2 Q. R" A: A+ n' i/ p        m_LockGrid.UnlockCell(x1shift,y1shift);
' w$ G  M% r- ?7 k$ z1 P- L0 F        m_OffMapLock.Leave();
* [. A- j% v+ ]* N- g1 U" Q. S    }
    else
    {
8 ^1 \+ a6 ?" `1 U& \4 [        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
. Y) ]- C9 r5 [. |" r* x# R4 R) x}</P>
) s, C. V" b' i9 B
1 S- X$ Y' G+ M: G: A5 o<P>
//-----------------------------------------------------------------------------
* n3 v' ]6 m, v' A7 L// Name:
// Desc:
3 m+ P) v2 y6 i" G- T8 ~% T//-----------------------------------------------------------------------------
void CMazeServer::OnAddConnection( DWORD id )
8 a+ u* S- q; [" `0 G, E{
    m_AddRemoveLock.Enter();</P>
<P>    // Increment our count of players
    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
* |& L" K% ~4 l    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
; Q- N$ P- u. a0 `: s& W* R9 Z' h        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
, [. Y& C/ I9 y. g9 H8 z; @        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
4 N, b- c; a8 K+ Q' h, [7 w<P>    // Create a player for this client
; C7 c, w5 d& \$ E5 H/ P7 U    PlayerData* pPlayerData = CreatePlayerData();
* o  l7 ]# c9 }& e3 Q# C    if( pPlayerData == NULL )
    {
" c: x" \* T% H% v# d3 f$ S        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
8 J1 g  ?+ d2 S. I# T8 S* Q5 ?        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
( T" T6 B( _; D        m_AddRemoveLock.Leave();
        return;
2 _, |4 s  ^5 D& Q" W# }    }</P>
<P>    // Store that pointer as local player data
% `, J: ]- P" J! a  ?$ ?+ f; D) M    SetPlayerDataForID( id, pPlayerData );</P>
$ D4 U3 c/ `# T<P>    // Grab net config into to send to client
+ d$ z7 C) B( U3 U* y    m_ClientNetConfigLock.Enter();
2 {5 ~& ]) E/ I8 C) P! N  A! f    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
" r" t) P% A: \% G( y# Z<P>    // Send it
) r8 E* I( p* U    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
& d+ N! Q% F" `3 N% }: |<P>    m_AddRemoveLock.Leave();
! b, h' d; s- _: Z}</P>
  a+ Y) h7 f8 Z$ U, H
<P>
//-----------------------------------------------------------------------------
// Name:
+ v  _  _/ ?- X0 N/ @  g// Desc:
//-----------------------------------------------------------------------------
& v0 A. `) P  s2 T( l1 bvoid CMazeServer::OnRemoveConnection( DWORD id )
  d9 a. z$ p5 z  `' \{
    m_AddRemoveLock.Enter();</P>
) W. Z( j' w& Y1 s& {<P>    // Decrement count of players
    m_dwPlayerCount--;</P>
<P>    if( m_dwLogLevel &gt; 0 )
/ _# L" _  k) c; [# E2 {+ \    {
0 P, d3 S0 o0 [) F$ T" d+ {3 n        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
5 e0 y3 k+ m7 ~% q: x! D, u        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
' v, ?  H" Y3 o( c; Z4 u! r<P>    // Find playerdata for this client
    PlayerData* pPlayerData = GetPlayerDataForID( id );
    if( pPlayerData != NULL )
# u2 B' i) ?( _: e* o    {
+ m* F! F$ f8 z8 L. m# }# y        // Destroy it
; N$ U" `4 G9 d, L; v! I        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
    }</P>
/ @# U/ X: C7 z6 P<P>    m_AddRemoveLock.Leave();
}</P>
7 j  M- ^/ I# L' U2 M( R" F
<P>
2 J8 m8 }( F% k* V" {& J7 X//-----------------------------------------------------------------------------
// Name:
: |$ D1 h- \7 V5 Q: ^/ k: y// Desc:
& v+ e  B1 h$ E7 r+ h+ q6 c//-----------------------------------------------------------------------------
HRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
% w. K# w# e9 _* b. J) g{
    BOOL fFoundSize = FALSE;</P>
3 `3 y; `3 G, v" P<P>    // Increment the number of thread we have in this process.
  S2 N+ s- c: e! d0 r* A5 Z" x    m_csThreadCountLock.Enter();</P>
" `1 y9 H  S* A$ y$ X; b<P>    //Get the start time of when we entered the message handler.
* h3 D! E  U  P5 i4 y) p    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
( j2 E# G- F: Z  X$ n<P>    m_wActiveThreadCount++;
    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
   
    // Calculate and average.
+ @9 A/ Z! {4 I4 `: T4 J. E3 k+ k8 P    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
    m_fAvgThreadCount += fdiff/32;
. W3 A. D2 Q' Q" R   
9 i5 M1 D( B5 i8 T% t2 s    m_csThreadCountLock.Leave();</P>
6 B* ~3 M3 }* f8 O# X( C<P>
- C' h( \, h* E9 Y! m    ClientPacket* pClientPack = (ClientPacket*)pData;
9 a1 i3 M$ }' D5 g" x; y5 e6 P7 l    switch( pClientPack-&gt;wType )
    {
        case PACKETTYPE_CLIENT_POS:
            
            // Check to see if the packet has a valid size. Including
            // the custom pack size.
* m6 y9 E. y% |1 {% s  H            if( size &lt; sizeof(ClientPosPacket))
0 V7 V' F+ n- ^: i& r% S                fFoundSize = FALSE;
            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
/ D7 p! h  D% y9 u                fFoundSize = FALSE;
            else
                fFoundSize = TRUE;</P>
<P>            // If valid sized packet, handle the position.
9 u7 \/ H" b9 {: }! A/ W            if(fFoundSize)
% p( v* `  i' H# J( ~                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
. [3 ?4 g+ v. W2 H& ^/ M% r            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
- _8 J$ l. h: S<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
            if( size == sizeof(ClientVersionPacket) )
                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
            else
) R0 K. p8 R- r7 J' l' _                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
5 O, D- ]" l# U( s9 [            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
- ~3 L( e* p' J$ u( k<P>            break;
        default:
            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
    }</P>
<P>    //If the user wants to hold the thread, Sleep for given amount of time.
' j3 F! _$ t8 t9 m( H    if ( m_dwServerThreadWait &gt; 0 )
7 q5 E9 @# O6 K    {
        Sleep( m_dwServerThreadWait );
    }
   
    // Retrieve thread data for this process.
    m_csThreadCountLock.Enter();</P>
% t. ?& N$ m* E' ]- v! \<P>    m_wActiveThreadCount--;</P>
/ Y, \6 V$ u# Z; H6 }; m<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
    m_fAvgThreadTime += fDiffTime/32;</P>
<P>    //Get the Max time in the thread.
    if ( fDiffTime &gt; m_fMaxThreadTime )
    {
- L9 p) M# k" K+ A+ M% G$ K        m_fMaxThreadTime = fDiffTime;
1 D6 l5 N4 \& j- e% a/ ?$ j    }</P>
<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
6 \" Z- ~2 l- b# O/ g2 o; K}</P>
" \5 q9 v! g0 ~2 k; D( d, k4 k
/ y8 U1 \; G3 o! l+ E<P>//-----------------------------------------------------------------------------
// Name:
// Desc:
! H/ o9 [/ M3 z/ F% Y: ?//-----------------------------------------------------------------------------
BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
{
/ [/ @6 Q3 O7 h$ I% y7 Z/ l' {5 G    BOOL fFoundSize = FALSE;
    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
   
1 W( M3 j4 G( @' E    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
* T9 ]) g2 A- B    {
        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
            {
) k" ~1 ~4 b) l; Q) q2 |; e                // Found valid size in the array.
: K. Q2 P  C  S; r# ^1 X5 f2 y5 P( S                fFoundSize = TRUE;
                break;
& b7 B, l9 h; e            }
            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
2 j3 ~0 g  z3 l2 P        }
% T0 C5 j" u) t0 N2 y    }
1 Y- K2 f; J/ o, e; O    else
    {
        fFoundSize = TRUE;
    }</P>
6 y; P' E( u% q% [<P>    return fFoundSize;
}</P>
<P>
% E$ l  ^5 Y$ D; X+ {: P//-----------------------------------------------------------------------------
// Name:
// Desc:
. {( c& |6 }$ W, C7 ?1 j1 A0 x//-----------------------------------------------------------------------------
5 B. D6 `5 \% P8 ~$ J( Rvoid CMazeServer::OnSessionLost( DWORD dwReason )
{
    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
}</P>
, Q: G1 A! T) r2 y6 V* l( p5 b* H4 W
; K, J$ ^5 X2 I# I0 @$ |<P>
  L" V9 ~  P7 A//-----------------------------------------------------------------------------
6 e: n* P+ Z, O+ _, t// Name:
// Desc:
//-----------------------------------------------------------------------------
& l/ {% J) o. d# z+ p: j1 |6 nPlayerData* CMazeServer::CreatePlayerData()
+ X! |. Z. T, U) u7 y) t) L{
    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
" d% W' w* M6 z* v! F    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
    {
        LockPlayerData( pPlayerData );</P>
! b& U9 |4 a7 V' k, {& d1 L8 l) K<P>        // Got one, so remove it from the free list
        if( pPlayerData-&gt;pPrevious )
* T9 y; L* ~& S            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
        if( pPlayerData-&gt;pNext )
$ X( }' o- w2 d) O6 x            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
<P>        // Add it to the active list
  I2 a. H% n1 O  v& C( N+ D4 i1 I        if( m_pFirstActivePlayerData )
            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
1 M5 x  a# ~% n5 r! a+ b<P>        // Update count of players
        m_dwActivePlayerDataCount++;</P>
3 ^, A* y6 F& h; D<P>        // Generate the ID for this player
* J+ A! {+ m' y. o+ j        m_dwPlayerDataUniqueValue++;
        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
+ c9 z3 Y5 {6 K+ c. Y7 P3 {- @" ^( F5 e2 _<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
: R0 x6 N& P# O) [) Z        pPlayerData-&gt;NetID = 0;
        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
<P>        // Insert into the "off-map" cell
        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
        m_OffMapLock.Enter();
1 c6 G" z" g' ]/ @2 q        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
        m_OffMapCell.pFirstPlayerData = pPlayerData;
        m_OffMapLock.Leave();</P>
% ^+ @6 W+ s4 t0 t<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
<P>        UnlockPlayerData( pPlayerData );
    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
2 ]% z2 |0 j! b$ i. n+ Y<P>    return pPlayerData;
}</P>
, {* b, b. w/ T4 T$ L5 P9 {
0 k& k4 D7 Z! P* b# D) E<P>
//-----------------------------------------------------------------------------
// Name:
$ ]) Q; k$ _; f// Desc:
& b. D9 b0 W/ v6 Q. G) h//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
$ A3 [- G8 @2 m9 `' q3 S{
3 I2 y2 K) h0 J2 S( h. V1 z; T. r    m_PlayerDataListLock.Enter();
: g5 `$ A  D5 n4 B+ z6 b3 S    LockPlayerData( pPlayerData );</P>
' C; @+ ^! {$ s$ J- c8 g<P>    // Remove the player from its cell
$ u: D3 n  R  f" l    RemovePlayerDataFromCell( pPlayerData );</P>
<P>    // Mark as inactive
    pPlayerData-&gt;bActive = FALSE;</P>
<P>    // Remove player from active list
7 d( v/ p. E! _# \0 t8 d    if( pPlayerData-&gt;pPrevious )
        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
6 C, R8 d% \0 P- G/ m9 j9 B    if( pPlayerData-&gt;pNext )
1 _6 [5 _6 r$ M3 W        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
<P>    if( m_pFirstActivePlayerData == pPlayerData )
0 p. y8 E5 ]) [' z+ Y( }; n/ A/ Q        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
9 ^/ Q% u7 O( k% y$ w3 w; I    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
4 \  P/ o& q2 q    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
    pPlayerData-&gt;pPrevious = NULL;
    m_pFirstFreePlayerData = pPlayerData;</P>
<P>    // Update count of players
8 c# R  v! E/ f$ D    m_dwActivePlayerDataCount--;</P>
: J0 n* y* W4 r  P/ j<P>    UnlockPlayerData( pPlayerData );
3 R$ I9 ~2 V8 o1 B    m_PlayerDataListLock.Leave();
}</P>
& Y$ ^. @' L% i
<P>
0 V7 a8 Y3 a2 s; p//-----------------------------------------------------------------------------
* f( E3 n( _0 u0 O9 P) \" |// Name:
( Y# a' E9 W/ ?0 O// Desc:
2 ^5 e5 h# X, a3 q//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
    // Lock the player
. k- y. l% d( j6 x6 T+ m+ Z    LockPlayerData( pPlayerData );</P>
<P>    // Lock the cell the player is in
    ServerCell* pCell;
* b4 ~- V0 ]6 m    if( pPlayerData-&gt;wCellX == 0xffff )
    {
  X6 ~" v, n5 o6 l% J% z( G5 o        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
6 m+ ^5 s' V+ J$ @    }
6 N. B+ T" j2 s& x1 t    else
    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
- n; r/ r/ p4 C7 |3 L    }</P>
<P>    // Remove it from the cell
    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
: b$ q. l" _# c. o: }    PlayerData* pPrev = NULL;
$ H: ^. [( D3 i% F+ Z& |- k0 s    while ( pPt )
    {
2 j0 A$ I- _- H2 y- b  L        if( pPt == pPlayerData )
        {
' B) i$ T2 H7 w* ~            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
" \6 u) R9 @* j  L7 c; L<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }</P>
<P>    // Unlock the cell
; G" Y8 \' V3 O6 ]# q7 x+ O    if( pPlayerData-&gt;wCellX == 0xffff )
        m_OffMapLock.Leave();
" J' H1 L' u, l6 Y1 E' F    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
<P>    // Unlock the player
1 A4 l! d+ }! h6 w% e" G: d    UnlockPlayerData( pPlayerData );
. c+ b( Z5 B% D" C! E) W/ a}</P>

9 U6 r& e) |$ _2 R, T<P>
//-----------------------------------------------------------------------------
4 k1 L7 U/ q' f! [7 M% r! W// Name:
" O; Q+ V+ ^/ N6 M4 y// Desc:
//-----------------------------------------------------------------------------
/ a5 D+ P8 x0 |/ \; _" u' L' Xvoid CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
# s, t9 e3 y1 |' ]{
    ServerCell* pCell = GetCell( pPlayerData );
$ @. y4 }1 y% m/ t: c) T, t% f    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
/ n9 M7 H8 e8 d( y$ B; g    PlayerData* pPrev = NULL;
; {- {3 ], D% u$ ^7 d+ U; c    while ( pPt )
" ?: ^8 O5 |( o0 M    {
9 o+ f( ~% R0 I/ e        if( pPt == pPlayerData )
6 D: Q) ^8 t1 }        {
9 K# ?3 h6 H1 Z* D            if( pPrev )
$ q( ?% u& @# n: A7 v. j                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
5 m  ~) h  _9 B8 Q# }            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
            pPlayerData-&gt;pNextInCell = NULL;
+ e: b$ M+ ~3 L3 G$ w  L            break;
        }
        pPrev = pPt;
2 \+ q  Z! G% ]7 S        pPt = pPt-&gt;pNextInCell;
    }
/ }  j' Y2 f  o) a% M}</P>
9 o% k; `; [/ t9 r- h9 v
<P>
//-----------------------------------------------------------------------------
// Name:
( N2 Y6 V! l  B$ T! s// Desc:
//-----------------------------------------------------------------------------
) [6 b% g+ Q  @2 d9 \void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
. l1 ^: g: E2 n4 R. G# o{
    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
    pCell-&gt;pFirstPlayerData = pPlayerData;
# P- ^  |* B- h6 I}</P>
( Q+ [5 V) c+ A( ]* J
% f( k) d+ O1 B  G<P>
, A$ X: ]$ l6 M4 Q//-----------------------------------------------------------------------------
/ h' M+ [$ B' b/ S  e9 d. P7 ~// Name:
# l7 n: m; V' L: G// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
; ~6 u3 {4 |9 B- ?    // Grab player for this client and lock it
3 j! J0 X0 D2 w1 G& f    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
+ a3 y8 K- n: p, c# N1 W7 c1 ~    {
1 t3 \6 \0 s: U. n        if( m_dwLogLevel &gt; 1 )
7 T3 \2 l# F' L' r' K( M- z$ a            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
# M& z( J- K5 k        return;
& T. ?7 m9 N; f* [0 ]    }</P>
<P>    LockPlayerData( pFromPlayer );</P>
$ X, H) w% a2 K+ V8 i, V<P>    if( FALSE == pFromPlayer-&gt;bAllow )
    {
5 w4 K2 Z- `5 D/ |) E  ~  g% t        if( m_dwLogLevel &gt; 0 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
9 h$ e* B2 _7 C' Z6 o<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
0 r+ ^/ w, A5 g# Q6 W4 K6 _        UnlockPlayerData( pFromPlayer );
1 }/ l' h' P/ L" z% U4 f        return;
9 b7 G, f' h% i3 S9 t' Z    }</P>
<P>    // Compute the cell the player should be in now
    DWORD newcellx = int(pClientPosPack-&gt;fX);
    DWORD newcelly = int(pClientPosPack-&gt;fY);
    DWORD oldcellx = pFromPlayer-&gt;wCellX;
    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
<P>    // Have we moved cell?
    if( newcellx != oldcellx || newcelly != oldcelly )
    {
        // Yes, so lock the pair of cells in question
* ~5 U& K% C4 l7 _: T        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
<P>        // Remove from old cell and add to new cell
        UnsafeRemovePlayerDataFromCell( pFromPlayer );
        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
% J: S2 @$ O' o) E3 V        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
$ h( Q. D+ Y" @% Q# U<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
; P: D0 p/ d, |; C3 C8 n4 D4 a<P>    // Update player position
% o& e  Y6 d4 G; k9 E- D+ ^7 o    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
* U8 d$ {; @4 ]9 J" _    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
7 p* p: I9 S- ~! b% R    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
, `: h- V& r- o<P>    // Allocate space to build the reply packet, and fill in header
    DWORD dwAllocSize;
    ServerAckPacket* pSvrAckPack = NULL;</P>
<P>    // Begin by allocating a buffer sized according to
    // the current number of nearby players + 4.  This will give
* d6 T+ T* x6 G    // a little room for more players to come 'near' without resize
8 Z& Y( [2 E; g    // the buffer.
    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
- N: r" x( m+ f: p2 D& b7 K<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
    {
        // Out of mem.  Cleanup and return
  [' ^3 o$ G. x$ p        UnlockPlayerData( pFromPlayer );
        return;      
    }
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
# O9 _* f3 O) C9 c    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
<P>    // Compute range of cells we're going to scan for players to send
    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
; n6 i3 V1 j6 U. v( m$ U  F' z    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
! R8 N% h$ `" w: h3 R3 _4 F  K* Z    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
  N4 A  ?. q: u9 _7 T# }+ O( K    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
( s$ |, ]* e6 }) U7 k) |# L<P>    // Lock that range of cells
    LockRange( minx, miny, maxx, maxy );</P>
<P>    // Scan through the cells, tagging player data onto the end of
( ?, W5 l5 ~: X' C* K    // our pSvrAckPacket until we run out of room
    for( DWORD y = miny; y &lt;= maxy; y++ )
! a) `3 q8 q# ~4 F6 b( Y    {
. X& s6 V2 K, H        for( DWORD x = minx; x &lt;= maxx; x++ )
        {
, O( u* x1 D" M            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
" G$ j5 T1 s& Y5 C* W2 h, E            while ( pCurPlayerData )
: f* X3 ~  j! o! k            {
                if( pCurPlayerData != pFromPlayer )
                {
6 E. I/ |3 \" ?( ?. t* v- {                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
- z8 A* a& B, X# O% B                    {
                        // Make sure pChunk is where we think it is
                        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
' j" T/ z, q' l7 ^% F' Q                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
                        dwMaxPlayerStatePackets += 16;
' W1 b& ]8 c) _8 F; X5 j3 |6 e                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
8 w9 M1 k1 g8 V+ ?# z                        if( NULL == pNewSvrAckPack )
2 _. e1 b6 a3 E$ Q8 E; R4 S; Z                        {
                            // Out of mem.  Cleanup and return
( n0 w4 M9 ?. a' L' Y/ ~                            free( pSvrAckPack );
                            UnlockRange( minx, miny, maxx, maxy );
4 B0 D' i# t2 t3 d                            UnlockPlayerData( pFromPlayer );
                            return;      
                        }</P>
<P>                        pSvrAckPack = pNewSvrAckPack;
                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
, C8 M5 b6 m) c( ]8 S<P>                        // Make sure pChunk is still where its supposed to be
                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
& D/ a/ V. j( h% Q                    }</P>
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
$ J$ d0 \% X1 c% I$ k                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
% [" Z! `, j5 `+ V) l5 {                    pChunk++;
                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
                }
% q- Y$ q* P9 e) u) l                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
! U, ?+ l  P# b2 Q# c            }
        }
- C* P6 f2 _, o3 D' M    }</P>
6 O$ X. B" K% A! P3 `* I<P>    // Update the dwNumNearbyPlayers for this player
/ h' S& K* x9 j7 c0 o    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
  W  R1 e5 @* u5 c) q' H5 e) H# C! y0 C% \<P>    // Unlock range of cells
4 s. H- r+ M9 n    UnlockRange( minx, miny, maxx, maxy );</P>
: ^5 F" c. L+ r% h4 }5 I<P>    if( m_dwLogLevel &gt; 2 )
( C" C' X' s* q' B; U    {
( N' V9 ?. A, j& z7 v: b6 {        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
" o+ J) I5 N9 k6 c8 c! Z    }
    else if( m_dwLogLevel == 2 )
    {
4 w! l: ^' R% {! b; P& @        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
        {
            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;
5 w7 n' F$ E" Z        }
2 c# T, U8 W7 w2 {    }</P>
! I$ f' x% @2 z% t& q2 _% Z# ^$ h<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
<P>    // Send acknowledgement back to client, including list of nearby players
    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

9 B* F% s5 O$ ?7 R4 C1 L* j    // Pack the buffer with dummy data.
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
- P1 Y# a8 W# Q9 W& V/ x7 x        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
5 n8 w; J' M# r. y5 I- m9 m$ K! O        VOID*   pTempBuffer = 0;</P>
<P>        pTempBuffer = malloc(dwBufferSize);
/ c5 R! Q! \* r* l1 [4 j# v" `        if( NULL == pTempBuffer )
! M- O& Q0 V! a        {
            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
; U4 U) o6 a" s& \5 J            free( pSvrAckPack );
( J% _9 A3 V# P) W4 d) J( j+ F$ |            return;
        }</P>
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
& Z2 |3 M: n+ u( u- t) p        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
   
5 S3 K* ~. s$ D3 X, A" [5 B        free(pTempBuffer);
    }   
, O9 a0 B$ O7 E0 Y    else
    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
    }</P>
( W. ?: I& P+ X* a! m& Q  a, P<P>    free( pSvrAckPack );</P>
<P>}</P>

<P>
; Q! X5 ^3 s/ y$ ]/ P  d//-----------------------------------------------------------------------------
# R: B' i2 F7 `// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
" r6 [+ l" h# m. ^{
    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
    if( pPlayerData == NULL )
6 o% o; }2 U: m7 U( `        return;
. I1 E' h* ?$ L3 f2 X, W) W" \+ p    LockPlayerData( pPlayerData );</P>
) q% T9 x' O3 K$ P6 ~: k% y  S+ ]3 x<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
2 Y# y; Y& T* V) g- C! h" V<P>    if( m_bLocalLoopback )
/ i: M# x8 O9 \% F7 J! j        pPlayerData-&gt;bAllow = TRUE;
% s. W) n6 g9 c- I9 I- T- Z' o% Z    else
        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
<P>    if( m_dwLogLevel &gt; 0 )
        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>
7 U$ N+ m  p7 z) `' D<P>    if( FALSE == pPlayerData-&gt;bAllow )
- W, C2 b# O* [    {
        if( m_dwLogLevel &gt; 0 )
8 d9 |$ k: |5 i7 T, Z+ r  q0 B            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 );
" Z/ e$ r* S) k! r, C        return;
# R+ b( w: M- z  ?    }</P>
) d, s2 q1 ?, G0 U$ P3 E4 }<P>    // Unlock the playerdata
" V! H% y: I+ m( M    UnlockPlayerData( pPlayerData );</P>
5 E+ ~& ^* k) `  }<P>    // Send acknowledgement to client that the client was either accepted or rejected
    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
; ?  J. h+ N: _9 o$ t}</P>

* J% E! j. I8 o* X  Q; s- }' L' m, u) p<P>
//-----------------------------------------------------------------------------
// Name:
, P' V1 I, N% t( z5 [' M7 e// Desc:
7 \' f5 k9 @% j//-----------------------------------------------------------------------------
$ Y1 D% j4 J7 u% HBOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
{
2 f& a: H; p+ |! x  M- c    switch( dwClientVersion )
1 k; w1 s! B$ u6 A3 o! S6 G    {
        case 107: // only v107 is supported
            return TRUE;
) d7 [6 ~) _& U7 H& |% `- E# O        default:
8 p+ h4 O7 y4 a9 z1 q* j6 w            return FALSE;
7 k. a. l- j. ~9 s    }
}</P>

<P>
' d+ `+ q' O& ]& h. v: m% ?//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
{
    if( m_dwLogLevel &gt; 1 )
$ V5 x2 K# y- ^4 |0 G. J' `        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>

6 m3 y$ B5 _% _1 e. g) [& M<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
DWORD   CMazeServer::IDHash( DWORD id )
/ q0 s/ V0 h( D: G. W{
    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
; |3 Q3 Z5 e  ?( U* k    return hash;
' |9 F6 n/ k# V}</P>
/ y+ ?& ~, f/ l
<P>
, R1 E! D0 f3 k- y+ Z2 x+ \$ }5 }//-----------------------------------------------------------------------------
// Name:
) f6 M. b. D$ s// Desc:
//-----------------------------------------------------------------------------
% K0 b7 M4 \- _void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
" s  m+ L/ h5 j+ [: }- j) o# z4 L{
    // Hash the ID to a bucket number
( X* b+ q* `% v3 n, H% q: s; ^+ G    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
1 B1 h, R# J* E+ \3 v<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
) U% S2 L7 R$ h<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPt = m_pstIDHashBucket[bucket];
' e, @3 }* F1 o& Y8 G' K' J  l    PlayerData* pPrev = NULL;
    while( pPt )
) R3 N' M& y- s* V' U4 K    {
9 m% R$ \1 {0 M, r2 `        if( pPt == pPlayerData )
            break;
        pPrev = pPt;
        pPt = pPt-&gt;pNextInIDHashBucket;
2 X7 \: A7 U( f) m) A1 J$ K    }</P>
<P>    if( pPt )
    {
+ ?$ k# u5 |& s& ?        if( pPrev )
            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
        else
( t$ Q  M9 A, t9 I4 w+ E            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
0 t2 Z2 C* m- z* i0 i6 C5 w. T6 q6 V        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
! `# Z+ B7 z% Z<P>    // Unlock the hash bucket
1 \) G; |6 I, s' Q    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>

5 ]: |; I5 `! t9 H<P>
) U/ }( J0 u$ H7 d  }& z/ Q9 \//-----------------------------------------------------------------------------
// Name:
. C" i: a8 e2 u0 [0 j// Desc:
//-----------------------------------------------------------------------------
void 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
    PlayerData* pSearch = GetPlayerDataForID( id );
    if( pSearch != NULL )
+ D) h0 ]9 u. `' d0 g$ W7 F# N/ z        return;</P>
. {/ W( a2 `0 d<P>    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
3 e1 t, W( H) f7 q) F: f* E! O    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
) H' q+ B7 Q8 `3 B6 W& Z1 z/ {    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
    m_pstIDHashBucket[bucket] = pPlayerData;</P>
# ~& e5 b( x$ K1 W- ?<P>    // Store net id in player
' v8 [5 y* ^1 |4 l" q$ d, ^: C    pPlayerData-&gt;NetID = id;</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
- ]: D5 U- S6 m* s4 D3 y}</P>

  E' C! R6 A  C6 |$ X% M<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
. L: h8 e" F1 |. _, J' T6 |1 z* dPlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
{
) `/ z7 k8 G" X3 I    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
3 \( [" x; ~+ Y9 `7 d<P>    // Lock that hash bucket
9 i/ ]  u9 C' @2 `# \    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
, h% K/ ^. ]: E4 X5 t    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
% b! c% W3 _0 x7 k: _8 b0 @<P>    // Loop though players in bucket until we find the right one
. d9 d7 y6 |8 F: f    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
: W  d, T% x+ a  p( ~4 y3 n: ~  h    while ( pPlayerData )
# V- ?+ y$ b  t: Q2 d    {
        if( pPlayerData-&gt;NetID == id )
+ d+ n3 S* A9 |" H4 ]: h) f) j            break;
; I( R1 I" K) L        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
5 N9 H5 ^" K8 V; M    }</P>
8 X" P- m  b  y. Q' s0 T0 i<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
, q  V* B9 C; x<P>    // Return the player we found (will be NULL if we couldn't find it)
    return pPlayerData;
}</P>
) ]# r$ o9 G) z
6 U& f( ^6 t: M4 p! T<P>
//-----------------------------------------------------------------------------
, \  L' Z: C0 M& y' T% R/ K// Name:
// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
{
4 R* B- Y* e& Q    if( m_pNet )
    {
0 J' |1 v) q' d; j( o        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
        PlayerData* pOldestPlayerData = NULL;
  A8 j  ?6 x! v& _        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
1 K9 _& b3 [9 p        while ( pPlayerData )
! \) C, {5 N. o) G6 b, _        {
' e9 ?$ v* [# e            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
( A* X0 M1 ]* c  M            {
                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
) m, j/ F" l  _, q! O" B8 ^8 ~& Q                pOldestPlayerData = pPlayerData;
            }</P>
/ k8 u- D, T  K- b, j2 f<P>            pPlayerData = pPlayerData-&gt;pNext;
        }</P>
  d( Y8 [& j. m<P>        // Display the player with the oldest CI field, and update its CI field.
        if( pOldestPlayerData )
2 E, k* x& f; Y8 J5 M        {
            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
/ i2 G2 k$ i2 f9 d; X: s; u            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
% F. P/ X, u" P            pOldestPlayerData-&gt;fLastCITime = fCurTime;
        }
        else
        {
            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
2 Y. n) D# M4 I) U6 s: t% {* {) R        }</P>
- M) y# h. @' k6 R<P>        m_PlayerDataListLock.Leave();
    }
}</P>

/ k: x5 ?/ R. F1 V8 A% C7 m7 W) n<P>
//-----------------------------------------------------------------------------
8 E5 k" K9 `: L6 `3 L% `  N" Z$ O# p// Name:
4 w2 e- B) ]8 o' g# O8 a+ {6 X1 e8 V// Desc:
//-----------------------------------------------------------------------------
  Z* a" i: w. ?/ R5 |void CMazeServer:rintStats()
{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
/ Z# e' x3 S# K& R                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
                                    m_fAvgThreadTime, m_fMaxThreadTime );
    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
3 L, b* p# D. f  K# D% M4 [8 m. z}</P>
9 Z) W+ {0 ^5 Q  ^8 L4 |1 {
! B8 B2 f+ W! M1 A! n: }" a<P>
7 A7 h: I$ x' K% D0 `6 D. G: ^//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
& [6 s1 q; p! E8 gvoid CMazeServer:isplayConnectionInfo( DWORD dwID )
{
    TCHAR strInfo[5000];
& s7 L. F5 B' J9 X    TCHAR* strEndOfLine;
  u9 W+ X& x% @8 |4 h6 l    TCHAR* strStartOfLine;</P>
<P>    // Query the IOutboudNet for info about the connection to this user
    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
* a0 ~( `6 A2 H. ^) U0 L4 J$ _<P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );
" J5 `6 V: |2 w3 @" [+ D3 N; J    ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>
<P>    // Display each line seperately
; c- r! f$ {! d) e: @- V0 r    strStartOfLine = strInfo;
    while( TRUE )
# S6 K3 Q5 n8 s; Q) A    {
& Z. j* w$ Y- C        strEndOfLine = _tcschr( strStartOfLine, '\n' );
/ D6 E% g4 D" g$ _# }        if( strEndOfLine == NULL )
            break;</P>
<P>        *strEndOfLine = 0;
! K, g+ q+ |- [6 X% y: g! y        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
    }
}</P>
: O) u7 L+ i4 o) H- a7 y1 [1 l" V
<P>
//-----------------------------------------------------------------------------
// Name:
5 _. R; e0 P% p// Desc:
4 x  m% Y$ K9 d9 ]+ T/ {//-----------------------------------------------------------------------------
: C& v2 D2 e. @. h6 tHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
1 y- X' w. }. X. A{
* J" R5 f9 `( F0 p" c- A    // Chance of forcing any packet to be delivered reliably
$ u% S2 C; d; ^$ t    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
! m- L2 m, v7 Y( d, U4 U& p# D<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
5 J% O% t# `6 ]3 `1 ~/ O' S+ g}</P>

<P>
, p% s8 o" c; O' ^" }7 D//-----------------------------------------------------------------------------
2 G% W  M& T, l9 ^$ I$ f// Name:
/ r4 T6 A, h+ U! ]. B// Desc:
# ^  }) \- P) z' Y8 `# |//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
! f$ E- i( u# T) I& R1 R    // If we're up and running, then send this new information to all clients
    if( m_pNet )
    {
: \- h1 g* j1 j- o' J        //Use the AllPlayers ID
        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
2 z; r; b! Z. T% Q( n  }% d3 E! |( R    }
# u0 \; {( q1 N' U, d2 V' F}</P>

0 |) C9 i' E) k8 J4 G5 a<P>
//-----------------------------------------------------------------------------
7 u0 o% T- [4 y8 [5 M8 Y0 h  O// Name:
" W+ R7 g& _3 H: A0 p+ `// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientReliableRate( DWORD percent )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.ubReliableRate = BYTE(percent);
    ServerConfigPacket packet( m_ClientNetConfig );
& ~+ m- Z( z$ D8 K7 I    m_ClientNetConfigLock.Leave();</P>
* a" m* _1 m! p6 t# {4 t, u<P>    SendConfigPacketToAll( &amp;packet );
}</P>

/ W: A) O' x1 g; }<P>
4 e5 e- b( s6 Z//-----------------------------------------------------------------------------
1 i* M0 U6 a0 w5 F2 m' u// Name:
# f! |, s6 _! K// Desc:
' f4 c2 d+ f! _1 K//-----------------------------------------------------------------------------
: L: U) T0 W' pvoid CMazeServer::SetClientUpdateRate( DWORD rate )
. C/ m+ g9 _. m- x{
    // Update client config, and build packet containing that data
6 w. {( i9 z1 |2 _- C7 x5 T6 {    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wUpdateRate = WORD(rate);
* g7 W- c- t5 c    ServerConfigPacket  packet( m_ClientNetConfig );
. M) l$ q8 o3 B0 M    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>
( I& k8 @, H% }9 q# b9 S6 d+ t! |3 g! i
, O2 O0 ]& @8 T* |( E/ E& _) c! M<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
1 ?6 o, V4 L* I8 j: |% Y) r, ?' x5 u//-----------------------------------------------------------------------------
; A. D+ {, n, j8 y) t" q7 Ivoid CMazeServer::SetClientTimeout( DWORD timeout )
{
- K% f, o" b/ O  M, }3 t    // Update client config, and build packet containing that data
% {; Y: ]/ i# h1 S    m_ClientNetConfigLock.Enter();
5 i) `- l/ {$ q5 G; s    m_ClientNetConfig.wTimeout = WORD(timeout);
" v; M9 Y5 B+ x" F$ m$ G$ z    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>
7 K( F' _" U1 C4 Z( M" Q4 h* D
<P>
3 r! a# w9 @' T% O# y9 w//-----------------------------------------------------------------------------
// Name:
// Desc:
- ]* L! h) O# E( l//-----------------------------------------------------------------------------
3 ~9 Z; F3 W" u1 P3 s0 t/ a/ B' ivoid CMazeServer::SetClientPackSize( DWORD size )
4 `" u+ y, Q' E1 G& e( t; o{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
& @& w6 }* Q% ~& n   
    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
: v2 v7 Q  C9 a; b# I! ~4 n        m_ClientNetConfig.ubClientPackIndex = 0;</P>
<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
# s' P4 i7 c, |7 x: C    ServerConfigPacket packet( m_ClientNetConfig );
6 C+ ]; G/ b2 K9 S( r0 c    m_ClientNetConfigLock.Leave();</P>
6 l  z6 v5 a6 h6 N6 B1 y* D<P>    SendConfigPacketToAll( &amp;packet );
}</P>

8 O, p7 }/ G+ V- ]* ^<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
: ]( m# U" E) j( \void CMazeServer::SetServerPackSize( DWORD size )
2 ~9 Q2 G2 _' }- X9 a! {: b4 P{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
   
* R0 E9 U9 d6 J, e# t. J    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubServerPackIndex = 0;</P>
<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
4 \- G6 P' W% ~4 k: j* J$ B, Q    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>
2 U  X1 ?3 R' B) B  x<P>
* L9 N+ \8 O0 i//-----------------------------------------------------------------------------
// Name:
/ z# A* h" |# Y// Desc:
7 K: C# P/ Z0 Q( }$ H0 n//-----------------------------------------------------------------------------
void CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
0 E$ u2 Q' `# Z$ Y+ o5 I{
    // Update client config, and build packet containing that data
' H. O9 O- N8 V, H5 @    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
1 \% c- o2 ?3 ?    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>