[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
<>// File: mazeserver.cpp
//
// Desc: see main.cpp
//
// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
0 d! C& v. [1 w% i0 U& K#define STRICT
#define D3D_OVERLOADS
#include &lt;windows.h&gt;
. ]& ^7 d% {! A5 _2 Q0 ~  v5 e#include &lt;d3dx.h&gt;
8 F0 N" A5 Y6 J2 P. x0 j/ n#include &lt;stdio.h&gt;
1 g5 e' J, Q% c  p% H# l#include &lt;math.h&gt;
* U0 v' \6 U/ b+ S& N" m/ r1 T#include &lt;mmsystem.h&gt;
3 [  k) Q+ [/ j* x4 c  ~#include &lt;dplay8.h&gt;
#include &lt;dpaddr.h&gt;
! L6 X& B( v3 A5 H4 [#include &lt;dxerr8.h&gt;
: P, H3 y$ ~$ D/ o3 |, N4 N2 Q* _& L#include "DXUtil.h"
#include "MazeServer.h"
* {4 ?# @4 E: r' ]& {# A#include "ackets.h"
#include "Maze.h"
7 B9 I% O/ U/ M#include &lt;malloc.h&gt;
#include &lt;tchar.h&gt;</P>
* A) l  l0 x) d& f/ X: z
<>//-----------------------------------------------------------------------------
" f& D; u# ~/ c// Name:
// Desc:
//-----------------------------------------------------------------------------
3 M2 y) z0 }/ rCMazeServer::CMazeServer()
% x: f" O& E0 z& g/ X5 W, g{
4 @' z4 b* w1 }* ~* S( S0 _8 u1 X2 @    m_dwPlayerCount         = 0;
   
& c5 M0 l1 d% C4 Q    m_wActiveThreadCount   = 0;
8 u5 i3 ~1 {* e5 d6 j) x+ j% A( u6 T  U    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
! b6 ^. x& P: ?    m_fMaxThreadTime       = 0;</P>
<>    m_dwServerReliableRate  = 15;
0 V8 }2 p2 U' N0 q1 N$ E2 Z% ?    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
    m_pMaze                 = NULL;</P>
<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
& n0 v9 v; p% @7 ^  v, m    m_ClientNetConfig.wTimeout       = 150;</P>
2 e- |3 ~' ]" y<>    m_ClientNetConfig.dwThreadWait = 0;</P>
<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
; W* |* \+ k$ _* G* y! R! V8 S    {
4 f$ |# o0 `* A" O- l, K% l        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
/ W" J; z0 Q0 c4 O}</P>

<>
9 R1 P! ]/ @( \# A8 K//-----------------------------------------------------------------------------
// Name:
3 R2 a: ?8 z5 g- b$ ]// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
+ ]; w7 d) @/ V" k* `* }2 M. [{
    m_bLocalLoopback = bLocalLoopback;
3 [  v, S! f! m* z+ E( M6 K0 a& W    m_pMaze = pMaze;
' w. ~: t$ m6 o/ A0 j$ C& g# M    if( m_pMaze == NULL )
5 Z  v5 v) [: k# p* ?/ T        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
; ~) T# }, U4 c7 q<>    // Grab height and width of maze
2 M0 S- ~6 M( I( y    m_dwWidth = m_pMaze-&gt;GetWidth();
( `3 u6 X* Y; C; x' g7 A% W3 Q    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
1 y- ^- h# _. O1 c<>    // 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 )
& x2 ]$ q8 v! Z2 K2 e6 p7 h0 A        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>
% ^" C5 H1 p. z8 E7 d+ F  {' C) Y# Y<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
6 @% S! [" C9 }; y% w1 y    m_dwMazeXShift = 0;
8 G9 P2 O4 M, ]$ Y: M6 U    while ( (scale &gt;&gt;= 1) )
* H/ I, N* |* {8 F4 T4 p' j, l        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
" f" J1 P7 _, w7 P# L        m_dwMazeYShift++;</P>
<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
        ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeYShift) != m_dwHeight) )
; R6 Y$ t, G% ^2 z1 T; o2 A        return DXTRACE_ERR( TEXT("Maze height and width need to be power of 2"), E_INVALIDARG );</P>
<>    // Initialise the player list
    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
! H9 n0 Q* \" G- \1 D4 P    m_pFirstActivePlayerData = NULL;
4 w9 U, T6 j6 |. H4 T    m_pFirstFreePlayerData = m_PlayerDatas;
    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
6 s% L9 E9 ^6 |8 ~2 O2 v" e        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
* |4 C1 \) ?9 N& _    }</P>
( p' r; r# w# Q. V<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
3 A# L3 T5 a( T) S    m_dwActivePlayerDataCount = 0;
& c" p  ]1 E  Y+ w4 y* B' j    m_dwPlayerDataUniqueValue = 0;</P>
<>    // Initialise the cells
3 E0 E5 F9 s7 O- J7 \' K& b9 F: A    ZeroMemory( m_Cells, sizeof(m_Cells) );
/ T) G1 f3 k7 V2 w: A    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
2 p4 d( T0 G  J+ h! h7 a* `0 a8 t( p<>    return S_OK;
5 Y( V1 a9 t3 K}</P>
$ s' e# t" O* J" q6 e
  _1 i9 z8 s3 a. V1 ~9 X<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
, }" O, m8 m+ [* t  S: @/ s$ V# N//-----------------------------------------------------------------------------
void CMazeServer::Shutdown()
{
}</P>

# y* n2 ^' h/ l% V; g* `<>
//-----------------------------------------------------------------------------
1 A2 e/ h7 q5 T+ }. L/ B// Name:
// Desc:
//-----------------------------------------------------------------------------
& M  l9 y0 K" q8 @2 r  c3 z" f/ y# X/ cvoid CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
: C* `- E( z1 Y1 u{
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
) V1 M! I* |) z9 W                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
& a7 f( v0 K( B" F  p6 {}</P>

<>
2 n6 X$ `0 P" f' Z" n4 v, W& [//-----------------------------------------------------------------------------
// Name:
// 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 ,
8 `) F: e1 N2 |; H/ b6 [) p. a                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>

9 O4 m, f" g) G<>
//-----------------------------------------------------------------------------
// Name:
! f2 u& l, S% y% o$ ^// Desc:
' r( M2 G" m- K. x  B7 m8 H//-----------------------------------------------------------------------------
6 r: K2 m5 b2 ]  R3 G" M1 A3 @void CMazeServer:ockCell( DWORD x, DWORD y )
{
6 f5 a2 ]. I: R/ r    if( x == 0xffff )
" J4 E/ t5 _7 E' Y        m_OffMapLock.Enter();
    else
! Y0 @% `# R  v7 h, p, g" V2 U        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>

) y7 n, n! z3 X2 |4 K<>
& q7 t! @+ _2 n2 r//-----------------------------------------------------------------------------
6 o0 [1 E) l/ U# @" f// Name:
; [7 |2 ]: ~, J0 D% C# A5 N7 [// Desc:
* L) B* P# s" c7 v" m//-----------------------------------------------------------------------------
void CMazeServer::UnlockCell( DWORD x, DWORD y )
3 S$ C1 r2 y, i: x" ^2 N" S* ?{
: N/ H* u1 @( i4 o% l7 X6 J, p    if( x == 0xffff )
        m_OffMapLock.Leave();
7 B# v, a( i. i/ Z. G    else
/ P6 G" v# o/ d9 D) l7 R$ [3 ^        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
4 |! Y3 ^( Z8 @" W$ B) S6 q}</P>
$ K: n2 I0 ]3 A
<>
3 p, Q- s! u5 w6 r, H0 U2 \5 ^# G//-----------------------------------------------------------------------------
// Name:
$ r4 ^! L, }* a+ E& g& d// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
2 T/ n$ f$ l, p9 j$ a{
    if( x1 == x2 &amp;&amp; y1 == y2 )
/ W  t: U! p8 A7 H    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
        else
3 x( |7 k7 x! ]. x: w" e  C" j! u4 f- O            m_OffMapLock.Enter();</P>
; S# T: J. W) P: j3 ?$ r8 A<>        return;
    }</P>
<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
: k1 w# W2 r. q1 D' D    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
) t- L! L/ Z2 `% }) r# e    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
1 h+ P1 A  P5 `5 N2 [' h: i<>    if( x1 == 0xffff )
    {
        m_OffMapLock.Enter();
- C) a8 `: m+ |+ m7 @8 P        m_LockGrid.LockCell(x2shift,y2shift);
  i+ ~& B: j4 t9 y. Y: ?& h) f    }
    else if( x2 == 0xffff )
$ J- t" k2 {4 O& J3 d' g$ o* g/ Q    {
8 J/ l( f6 i, Z- D        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
    }
    else
    {
/ w& c1 c' g/ b4 ?' [! E        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
" H( G  D& L! p* f; m8 A# G    }
0 U6 f- R- V/ F% _& B( V6 j}</P>
' [6 p2 O: }$ J" A
<>
9 K. l% }2 L, ]//-----------------------------------------------------------------------------
! m. V0 k, D4 R) v1 P, j// Name:
8 E; w: B+ L; K" y" [! B: Z// Desc:
/ ]! Y3 f& t2 ]5 K//-----------------------------------------------------------------------------
, B, a" H2 t3 T* ?  H) O, Nvoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
) R. K( g( d! U/ B2 t{
    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            UnlockCell( x1, y1 );
7 q8 }) E! y) s, t+ C1 m        else
! i% e+ \7 u. [            m_OffMapLock.Leave();</P>
<>        return;
    }</P>
4 D* {# W  l3 c$ w( F<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
0 Q1 C4 ~0 b2 q" l<P>    if( x1 == 0xffff )
    {
% n) D5 W: e' J! C3 [; S& H        m_LockGrid.UnlockCell(x2shift,y2shift);
2 B# {, G9 l% @$ _& M2 |( ]0 {# _; N        m_OffMapLock.Leave();
    }
    else if( x2 == 0xffff )
- i' D( K9 U' }' y6 f    {
! D7 R+ n5 [$ k9 r& `' l5 m' P        m_LockGrid.UnlockCell(x1shift,y1shift);
. \$ b- a  b/ I; n1 @  C        m_OffMapLock.Leave();
$ @( h6 e9 }' ?; h9 p- U+ T    }
! g" I- P8 H+ k: R6 n    else
# O1 L6 s. `* M0 }. I1 A/ I4 t    {
        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
  F) u/ Q8 E6 O5 T! |" ~0 Y9 ?    }
* z. x" f3 ]- P0 q. f' w) r}</P>
! S+ S" {6 |% _' \  b, P8 n
2 O9 T8 h1 Z% H<P>
2 H& u4 ~" j! g, O//-----------------------------------------------------------------------------
// Name:
// Desc:
) B( ]- h4 t$ H0 H5 p- }. Z' W! I//-----------------------------------------------------------------------------
void CMazeServer::OnAddConnection( DWORD id )
! Z' }7 ~" g8 _! ~7 O{
    m_AddRemoveLock.Enter();</P>
<P>    // Increment our count of players
    m_dwPlayerCount++;
. J& o2 n! k) I    if( m_dwLogLevel &gt; 0 )
    {
( {. m# i4 H# }) i' q2 A+ G        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
) V; \( Y$ w! q( i9 i. u<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
+ b- A8 E1 k/ B; X' I<P>    // Create a player for this client
* D  ]! P  w9 U+ k, p    PlayerData* pPlayerData = CreatePlayerData();
# S1 t& ~0 r  J* z2 c+ F- d    if( pPlayerData == NULL )
    {
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
  }5 y8 c9 m2 `: b. e        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
7 ?. e0 q3 g* O        m_AddRemoveLock.Leave();
        return;
    }</P>
% z6 O& Y. z) C1 q# Y' c6 k1 O% o<P>    // Store that pointer as local player data
    SetPlayerDataForID( id, pPlayerData );</P>
<P>    // Grab net config into to send to client
1 T4 \% w9 J( a. _! `  F+ H/ E! J! i$ Q    m_ClientNetConfigLock.Enter();
* v5 t- g7 w+ X' x# n9 {    ServerConfigPacket packet( m_ClientNetConfig );
2 B, e6 d& e; k" ?9 I    m_ClientNetConfigLock.Leave();</P>
<P>    // Send it
    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
<P>    m_AddRemoveLock.Leave();
. F, k( ?: S5 o  F}</P>
) h% H: z9 y) I
3 Y( h: [  F. Y4 r* Q/ d  w4 D: N. W<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::OnRemoveConnection( DWORD id )
{
* N  A- o7 U9 E' ?5 e    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
4 W4 X2 J9 v9 _0 E    m_dwPlayerCount--;</P>
4 k  y; T8 J/ x6 \+ x# I8 f<P>    if( m_dwLogLevel &gt; 0 )
6 e6 p  Y0 k9 o+ {& N1 x    {
& O1 I  C+ o1 b5 E; l        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
+ X3 r6 q6 d& B' U8 U' u    }</P>
<P>    // Find playerdata for this client
    PlayerData* pPlayerData = GetPlayerDataForID( id );
    if( pPlayerData != NULL )
    {
        // Destroy it
        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
    }</P>
<P>    m_AddRemoveLock.Leave();
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
" v$ Y% ~3 V" G5 |: K* j: ^/ B// Desc:
% M& q# a7 N& N- s* ]/ ]//-----------------------------------------------------------------------------
2 p* x1 x( M3 ^7 XHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
{
/ D, H3 U$ V/ ?2 T. y' t    BOOL fFoundSize = FALSE;</P>
<P>    // Increment the number of thread we have in this process.
9 a$ a& V' T$ j" f, b3 C    m_csThreadCountLock.Enter();</P>
<P>    //Get the start time of when we entered the message handler.
4 ^2 V! w, E1 e; b9 v    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
<P>    m_wActiveThreadCount++;
4 ^' Z3 i8 s4 y' A5 t( X    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
   
    // Calculate and average.
8 M+ p1 m' Z1 c! ?9 b! p) j- w- ?    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
9 q0 V' z- P3 M/ A7 x    m_fAvgThreadCount += fdiff/32;
* P+ R& e% y$ t4 t+ j8 D   
    m_csThreadCountLock.Leave();</P>
2 k7 e3 T. y# i- L5 C3 z) x4 p" l<P>
    ClientPacket* pClientPack = (ClientPacket*)pData;
    switch( pClientPack-&gt;wType )
    {
+ l9 j+ P6 Q, N- d- Y% F5 R7 b        case PACKETTYPE_CLIENT_POS:
2 ?: U; K# K( b3 ^, M$ N  k            
            // Check to see if the packet has a valid size. Including
% k5 `9 ^- l+ H9 q7 f            // the custom pack size.
  I$ ^' s& Z/ s" A, r* S& I; p            if( size &lt; sizeof(ClientPosPacket))
                fFoundSize = FALSE;
            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
) y! m% ~) ?; ]% f/ _7 T0 {                fFoundSize = FALSE;
            else
                fFoundSize = TRUE;</P>
2 x' j* d$ O% A<P>            // If valid sized packet, handle the position.
* X6 n/ j4 {% H* r7 W; x            if(fFoundSize)
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
<P>            break;</P>
" K' p6 G/ S0 }+ d+ `, j5 p; u<P>        case PACKETTYPE_CLIENT_VERSION:
' d& D! I* w2 S1 J; C9 b" T            if( size == sizeof(ClientVersionPacket) )
' X9 S& Q# ?% p( P                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
, S8 C# L% F8 a: y$ T            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
. e% s, ]1 |; P<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
) x9 J# i: f! P" C" Y; J<P>            break;
( @' Z4 g7 @* S  ~8 l# T        default:
            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
+ C$ y( z3 `  X( D! W    }</P>
<P>    //If the user wants to hold the thread, Sleep for given amount of time.
- V) W" m/ r1 w3 n5 O    if ( m_dwServerThreadWait &gt; 0 )
    {
        Sleep( m_dwServerThreadWait );
    }
   
7 x! u; o' a) o8 i) I0 o    // Retrieve thread data for this process.
    m_csThreadCountLock.Enter();</P>
<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
  ^6 K0 A1 t7 [* B, _* |4 g0 J    m_fAvgThreadTime += fDiffTime/32;</P>
. U0 `, R& s, g<P>    //Get the Max time in the thread.
- p- U: J9 Z1 t: M& w- H    if ( fDiffTime &gt; m_fMaxThreadTime )
$ _" }/ e- |) {( I    {
# x- Y8 C* n% d/ S8 J        m_fMaxThreadTime = fDiffTime;
- x( a. h/ R. ^& M    }</P>
<P>    m_csThreadCountLock.Leave();</P>
( w) E$ u! j/ q6 i<P>    return S_OK;
}</P>
* p/ Q/ K: _9 V  h/ b1 f4 I
<P>//-----------------------------------------------------------------------------
// Name:
+ w* d: x: D, m7 m8 \// Desc:
//-----------------------------------------------------------------------------
BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
) Y  V2 A6 E6 ^{
$ A7 h: e1 }4 S% c, V' J    BOOL fFoundSize = FALSE;
$ b* @3 V- I% _    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
# f0 d/ v7 [3 ~   
    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
) X& |6 X: ]4 k' q        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
6 Y0 H+ [& `; L& a; w) Y' s; a        {
! F, z" c1 l# P, A4 ^4 p            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
            {
2 D8 R$ C  `! c2 I1 y% d3 l                // Found valid size in the array.
- K% K/ [# p0 ~( V0 Y5 ?" d8 B0 R" i                fFoundSize = TRUE;
                break;
/ d  U) K( L. Q            }
) Y, T0 F3 g/ g) a% B3 `2 a            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
        }
9 h( @, C- J' k  K    }
    else
    {
; m. u% ^4 R3 C  W8 b* L        fFoundSize = TRUE;
    }</P>
<P>    return fFoundSize;
6 Q0 }2 O& ^- {  H8 `}</P>
( ~$ p0 U5 ]) G, P# }: o% ?, O<P>
5 Z, P' h! P0 X* e# [% A//-----------------------------------------------------------------------------
  O( ~1 K* ]& |4 e// Name:
- Z% ?2 w( A4 @2 h2 d1 z// Desc:
: z* _* p, M4 }( o  R0 F//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
{
    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
}</P>
* N8 e7 X1 Q1 b  l( W, ]
<P>
//-----------------------------------------------------------------------------
// Name:
( C' W- `8 A2 ]9 H// Desc:
' h' V& Q5 o( h, t. Q7 p//-----------------------------------------------------------------------------
' L/ C# g' ^8 l+ CPlayerData* CMazeServer::CreatePlayerData()
{
) ]- J5 j; I  g. c! b! S* u" ?    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
7 ?" k# m* E5 y2 C: L6 S6 D8 R    {
        LockPlayerData( pPlayerData );</P>
# x1 O% E: N1 D) t7 V<P>        // Got one, so remove it from the free list
4 ~  a+ D! g4 U5 G  I" h2 ~        if( pPlayerData-&gt;pPrevious )
5 f2 u) m, P1 D, |7 A            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
        if( pPlayerData-&gt;pNext )
            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
; v+ h9 [" v" C7 p5 h, q7 }; E        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
        m_dwPlayerDataUniqueValue++;
        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
3 p$ t0 p: R. T6 D# `& K  s        pPlayerData-&gt;NetID = 0;
        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
7 x  c; D7 J* N# C  J<P>        // Insert into the "off-map" cell
! _2 k3 `. O: M  k' U5 n        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
. D% P5 t+ m, l0 A2 M+ t        m_OffMapLock.Enter();
' x5 ?- q5 y* s% f2 p7 t! X        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
        m_OffMapCell.pFirstPlayerData = pPlayerData;
        m_OffMapLock.Leave();</P>
<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
( k. v' L2 _  }, X# [<P>        UnlockPlayerData( pPlayerData );
+ x8 x. P# @: \    }</P>
  n$ \. Y+ N) p4 j! ]  Z<P>    m_PlayerDataListLock.Leave();</P>
<P>    return pPlayerData;
}</P>
7 _2 U- C% d5 {/ y, X  ^  p9 s7 y
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
& L8 Y! K- H2 E* _" C* s2 Ovoid CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
{
    m_PlayerDataListLock.Enter();
" n2 {' L9 z9 w: [! K' V; @4 w    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
    RemovePlayerDataFromCell( pPlayerData );</P>
- ?/ q0 W* r% O. |9 [/ B( S6 q0 g<P>    // Mark as inactive
2 L. X! k& L: ?) b3 _; H    pPlayerData-&gt;bActive = FALSE;</P>
. m" D8 M% u, y$ Q$ X( n  `<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
  C$ C9 }- B4 ^' y( f7 u4 F) t0 U        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
% _' a; K6 g0 b  a0 n+ g% w6 l    if( pPlayerData-&gt;pNext )
0 r8 s* b  _6 a6 `" O  G! [        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
<P>    if( m_pFirstActivePlayerData == pPlayerData )
        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
( i3 M! P. I$ x% |    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
% x2 D% p" l1 z  h' W7 b- S# {    pPlayerData-&gt;pPrevious = NULL;
! C2 G0 z8 R' A0 a    m_pFirstFreePlayerData = pPlayerData;</P>
4 ^. `1 \+ a, k/ Z$ I<P>    // Update count of players
& c3 V. u% a& Q$ l1 W: L0 b9 w    m_dwActivePlayerDataCount--;</P>
<P>    UnlockPlayerData( pPlayerData );
% r7 l) ]$ c( @, ~3 c6 b    m_PlayerDataListLock.Leave();
}</P>
, r" Q" u% S, A) |8 m' T" [5 O6 f0 g; X! t
& Z! I3 N# _( {7 x7 s<P>
$ c. p, m" Q% D: }- C! c//-----------------------------------------------------------------------------
// Name:
// Desc:
1 P- Z! H2 }  {( R$ K0 M//-----------------------------------------------------------------------------
: G2 l/ u7 [2 ~$ ]void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
8 h# b, ]3 Q* I# S/ r" Q    // Lock the player
  S5 t+ e( M4 S2 T1 H# g    LockPlayerData( pPlayerData );</P>
2 z9 c( {0 _& V0 w( f' E- K3 P, o; O<P>    // Lock the cell the player is in
3 q5 N/ w5 W; m  e    ServerCell* pCell;
    if( pPlayerData-&gt;wCellX == 0xffff )
    {
# V7 V% {! s3 c8 V# r4 y8 e        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
    }
! n8 [( W. \9 p4 w: b  i0 W' S! W    else
4 Q2 }  i- T9 ^, `  |$ u    {
, r. y0 {2 ^3 V) U( a4 m        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
    }</P>
<P>    // Remove it from the cell
5 Q: ~6 s, b& S7 S8 a    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
: ]" `) m+ t" }+ n5 o1 X    PlayerData* pPrev = NULL;
" [8 Q1 r, n( s9 d    while ( pPt )
    {
- U$ v3 W# U7 B( Y% r  N) N        if( pPt == pPlayerData )
        {
            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
5 H2 R4 s3 {/ `" \, g/ d7 |" E- D            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
; N$ \3 i6 {$ z7 }4 u' k<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }</P>
<P>    // Unlock the cell
    if( pPlayerData-&gt;wCellX == 0xffff )
% l$ C4 [: [9 K* n/ i        m_OffMapLock.Leave();
$ R& W3 p/ Q: u; v# m    else
* `- ?5 i/ R( p        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
. D, z3 b6 n5 @) Q' x<P>    // Unlock the player
0 @- H# |( G" y  w! \8 j7 n    UnlockPlayerData( pPlayerData );
}</P>
0 w; P, d* n' \. z( O" U
<P>
9 }& D( ]- y! y" T$ ^//-----------------------------------------------------------------------------
( K8 y( {+ H, n' E- D( }' ^// Name:
// Desc:
; K3 h8 v* `+ k5 P//-----------------------------------------------------------------------------
void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
- k& c! f0 k6 B; i" R/ H1 q{
    ServerCell* pCell = GetCell( pPlayerData );
7 x8 b( L# R" \/ r* s; F# z    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
    while ( pPt )
    {
        if( pPt == pPlayerData )
3 P8 U( z6 W3 Z$ d% |4 S* b* Y        {
2 C% ^; {3 E- L8 D' I: U$ y            if( pPrev )
' O) e5 j' W  m% O* B                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
, m! n; c% e' q% e( P4 J    }
+ ^/ g9 x6 ^2 H  e) m" }}</P>
5 ?$ ?5 ]8 b6 m$ t- {, {$ M/ v
, r( B+ z& d8 W  ~3 ]! Q* [<P>
0 r& K7 w/ y( D. q//-----------------------------------------------------------------------------
1 M! t) @0 F$ r// Name:
// Desc:
//-----------------------------------------------------------------------------
, y$ j, d7 E9 k2 u2 O) {7 H- g- pvoid CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
    ServerCell* pCell   = GetCell( pPlayerData );
0 t  h# {' a4 P! [5 }/ n1 i5 a    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
, {# T0 `- u" ?5 [  Y    pCell-&gt;pFirstPlayerData = pPlayerData;
) V& J- L2 v1 V- H}</P>
3 X9 o+ I1 A  |  u; W
<P>
8 i3 b5 i7 f- r% [3 h/ X, }. g//-----------------------------------------------------------------------------
// Name:
+ e% D! F: L$ h/ m// Desc:
5 x1 D  g. [, q% V& w- a) U9 J//-----------------------------------------------------------------------------
  k' M6 W; _) F$ mvoid CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
/ L2 X* M" V0 _3 y% G! {: [    // Grab player for this client and lock it
& H9 i  d2 G2 L    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
. G- m1 z% Y% O8 @    if( pFromPlayer == NULL )
    {
        if( m_dwLogLevel &gt; 1 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
1 j6 y( d) H1 L8 e1 e9 k/ }        return;
    }</P>
1 p4 h, {- X% S' \* j<P>    LockPlayerData( pFromPlayer );</P>
& H# p- ]  v) K$ S- D& G8 ]<P>    if( FALSE == pFromPlayer-&gt;bAllow )
. g" C0 T! f4 h/ F5 j    {
! ]  N3 p1 j  [        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 G9 g! N. s# {; V) j8 S<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
) `4 R" D6 U2 O! I9 U        UnlockPlayerData( pFromPlayer );
5 q7 @" ^2 Q3 _* x- X4 ]        return;
    }</P>
  l4 R7 A, _# e! E! o. q<P>    // Compute the cell the player should be in now
    DWORD newcellx = int(pClientPosPack-&gt;fX);
) B% w9 F$ I9 e1 J$ z; F7 }, h/ m    DWORD newcelly = int(pClientPosPack-&gt;fY);
    DWORD oldcellx = pFromPlayer-&gt;wCellX;
    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
5 e) a; s3 }2 ]" S" t0 _6 k# W<P>    // Have we moved cell?
/ |* c& Z3 K" d& H' R    if( newcellx != oldcellx || newcelly != oldcelly )
' U& i/ [: x5 k* d& I9 |8 N    {
        // Yes, so lock the pair of cells in question
        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
<P>        // Remove from old cell and add to new cell
        UnsafeRemovePlayerDataFromCell( pFromPlayer );
# W9 Y/ |  P0 R( a        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
<P>        // Unlock cells
2 x- l0 y0 E0 _8 b; J2 J5 Y        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
9 Q; {3 N0 X" x) }- P<P>    // Update player position
    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
% M8 H6 X6 Q3 B% Z% v    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
) P* Z0 r9 Q3 t, a( }  [    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
<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
, E: E4 @7 p) p9 D1 N    // 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>
* s- M+ P6 d& ~& A4 q! K<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
8 B- |. h* S, j; H) b    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
  |7 o6 F- k/ D$ q1 U    {
        // Out of mem.  Cleanup and return
        UnlockPlayerData( pFromPlayer );
- n8 V* |5 _- X% t( x, C; m6 Z- H5 J        return;      
    }
* {0 `$ \6 o' r( N& @5 I( U; M    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
) Y7 `8 b, L5 C& j; t    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
, g/ E) l2 T; H/ p* `8 ?8 E' h    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
, U3 p' s/ P' `% r<P>    // Compute range of cells we're going to scan for players to send
7 j0 u- V! {' Q3 Y    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
  q  R& H6 V+ u4 I1 z' t% i    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
    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
$ M1 Z$ K4 T& w8 |( r; ^    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++ )
    {
        for( DWORD x = minx; x &lt;= maxx; x++ )
        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
            while ( pCurPlayerData )
            {
/ Y: i6 o0 q$ |                if( pCurPlayerData != pFromPlayer )
) c  U( z6 Y% q/ _4 v                {
3 P& r" K$ I# O                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
                    {
% Q: R3 A/ g" J7 n, Q2 U% q: G3 `                        // Make sure pChunk is where we think it is
                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
  W- m- b4 i+ Z. A- {* `! N<P>                        // There are more than just 4 new nearby players, so resize the
3 g$ N  r4 x9 h6 s  d) h                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
                        dwMaxPlayerStatePackets += 16;
5 r; N0 o, c5 W6 w5 r8 s! \                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
3 R3 L: w7 X* B2 q. o! ^) V8 \                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
: i( j( V" I$ Y- R7 g                        if( NULL == pNewSvrAckPack )
                        {
                            // Out of mem.  Cleanup and return
& t, T6 B% C3 L1 m2 D                            free( pSvrAckPack );
                            UnlockRange( minx, miny, maxx, maxy );
# M7 C3 x) A# [' v                            UnlockPlayerData( pFromPlayer );
5 U3 v/ W. g3 I3 B                            return;      
% l3 f4 ?! l; U5 q                        }</P>
, N/ l0 `% V) R<P>                        pSvrAckPack = pNewSvrAckPack;
                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
<P>                        // Make sure pChunk is still where its supposed to be
$ ^6 x# |# N; i# V% W- t                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
                    }</P>
3 p1 b$ F; m! i1 t<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
1 t8 o  y0 h7 {; c, ]( [8 W                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
                    pChunk++;
7 P3 R9 f0 H, j' y- |4 u& J9 T                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
( y, P0 J+ `/ F$ c$ n, ~                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
# f! }$ j: Z) O! b            }
        }
1 {( ]7 }5 G" n0 W) d    }</P>
# h7 u- R7 X4 e1 H/ G) n<P>    // Update the dwNumNearbyPlayers for this player
    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
% m" Q7 Q) z; F3 T7 u( A<P>    // Unlock range of cells
    UnlockRange( minx, miny, maxx, maxy );</P>
- \4 M& |" \) N<P>    if( m_dwLogLevel &gt; 2 )
    {
0 V: s; I+ J8 N        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
3 ]; \% M3 l4 B    }
. Y. X' X7 f$ @4 N  p    else if( m_dwLogLevel == 2 )
    {
. B: b( {  ~9 z5 U8 `  {  ?+ W/ U        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
, Q) Z! d; }% C. D; G/ N# `        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
3 h7 E6 C5 G+ x6 \9 X, i" j        {
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
. r( A2 J0 k4 h* D& S            pFromPlayer-&gt;fLastDisplayTime = fTime;
        }
    }</P>
$ P/ ?1 `  K; q6 f4 l<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
$ b9 H  n2 z: Z" c<P>    // Send acknowledgement back to client, including list of nearby players
    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

3 q6 V8 ^4 F7 j0 M# L& r& n1 }; p    // Pack the buffer with dummy data.
$ {: p7 g! e+ y( @' }- P$ `    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
0 j3 D' f1 k! s. I+ K0 c$ J  J2 p& q        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
# n' A8 m" A: M/ {" H        VOID*   pTempBuffer = 0;</P>
/ r: d5 E0 F! G, E/ Z9 S<P>        pTempBuffer = malloc(dwBufferSize);
        if( NULL == pTempBuffer )
! H, D2 l+ e: c1 [+ }+ X1 Q        {
. p  n& c+ c7 Z. k/ P8 d/ l            //Out of memory
/ x% I6 ]) t4 {6 M            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
" h7 l( g+ ~* e! p% A            free( pSvrAckPack );
            return;
( X. V$ Y5 l4 x9 X; F        }</P>
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
   
2 R+ h1 q0 M# R        free(pTempBuffer);
    }   
- E9 q! Y8 t+ L% o    else
* |2 o, r7 z* _+ N    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
2 ?* b0 |6 N/ ?9 [    }</P>
6 j5 i+ o% ^: ^" d1 W, H<P>    free( pSvrAckPack );</P>
) K  D( z! d4 u1 ?<P>}</P>
5 f( k5 M# p$ {. |
<P>
6 X5 ~/ a+ j  j# r. Z& D//-----------------------------------------------------------------------------
// Name:
4 Y- Q* _) @) N- v2 C// Desc:
7 N! q9 `: l- X" q//-----------------------------------------------------------------------------
7 Z# h# b1 h. j/ cvoid CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
# b$ @7 `" u0 b4 E    // Grab playerdata for this client and lock it
/ h# l7 n0 o" ~    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
+ N+ r; U& I4 e/ n0 J/ R    if( pPlayerData == NULL )
8 T( D# }2 H" u3 ?6 N        return;
    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
<P>    if( m_bLocalLoopback )
        pPlayerData-&gt;bAllow = TRUE;
0 D8 k2 Y' x3 R) g    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>
! O, w, s# }9 `; l7 R5 a- q% n<P>    if( FALSE == pPlayerData-&gt;bAllow )
! I# v3 t" w( ]/ f    {
1 Z) \+ g1 x2 P$ v* b! r        if( m_dwLogLevel &gt; 0 )
; q  f" L! K* Y6 p* t% N            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>
5 E5 E* n0 x  h" g<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pPlayerData );
4 o. n  i/ H$ H( C- {        return;
    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pPlayerData );</P>
$ @+ m2 t% w+ q<P>    // Send acknowledgement to client that the client was either accepted or rejected
    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
; I. }# c) W# P3 d+ Q- |    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
}</P>

<P>
( L- F' Y# V6 c; Z' r! m$ q//-----------------------------------------------------------------------------
3 }; N7 c: u2 j; V// Name:
// Desc:
7 I4 i& r/ F0 P: Y1 U' |//-----------------------------------------------------------------------------
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
{
    switch( dwClientVersion )
    {
+ T  X3 r) O/ F' y4 @        case 107: // only v107 is supported
            return TRUE;
        default:
            return FALSE;
    }
+ a6 e1 k6 W  E8 x$ W# w. f" f}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
. b2 j7 J0 G- c; E// Desc:
) I$ L, k: S  D+ Q/ Q6 f" _//-----------------------------------------------------------------------------
void CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
7 S* f" z3 @1 X( l& u' J  Y{
    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>
! I- N- h6 A$ W8 y. L* i9 o
<P>
, j# T$ I8 B! P: |+ ]//-----------------------------------------------------------------------------
4 X) Q" \! m3 H4 a" i// Name:
// Desc:
$ q6 {" N$ A: ?//-----------------------------------------------------------------------------
DWORD   CMazeServer::IDHash( DWORD id )
" y9 h  \; }' l{
    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
    return hash;
% E# t; D; F  h/ U9 G; `}</P>
- T1 {- S+ s2 x3 `' [
& T! }/ }3 C. _/ b' m8 Y<P>
7 R; J2 }8 N2 T; N7 S$ ~, F//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
& T. b" y2 _9 M: S0 T" @2 jvoid CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
1 t) W! |' Y9 d: }2 J& A% w{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
9 ~7 s' g  X! W8 z* f- \<P>    // Loop though players in bucket until we find the right one
/ M$ E0 R& `! g/ M: I    PlayerData* pPt = m_pstIDHashBucket[bucket];
/ X5 {( Z; D, T4 h& x2 F    PlayerData* pPrev = NULL;
5 A: v& C* C4 K9 C  h* e    while( pPt )
    {
        if( pPt == pPlayerData )
, F0 r, F% g# ?3 g) I8 B( v            break;
        pPrev = pPt;
) g9 V+ [" X1 o+ ^/ u; z        pPt = pPt-&gt;pNextInIDHashBucket;
# o: U+ X1 h& p- M+ r    }</P>
<P>    if( pPt )
    {
        if( pPrev )
            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
9 ]; h  q' N% i' e$ H! R8 g        else
            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
        pPt-&gt;pNextInIDHashBucket = NULL;
/ q% k# r) M9 p# N- A1 f9 k0 W    }</P>
<P>    // Unlock the hash bucket
) ]  e( B0 X+ V: k* R* X' A- @    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
" B( {# z! `+ V}</P>

8 a: }9 |) E1 O# x4 K& Z7 H1 b<P>
  h, S9 `  @' X0 B7 E0 o) y' h- k//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
% o) b% ]: I- V& W. t  v1 ivoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
- z7 {( Z# L! j# A{
    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
    // otherwise there will be a circular reference
6 X' b' E$ j' f, N    PlayerData* pSearch = GetPlayerDataForID( id );
    if( pSearch != NULL )
. @  S" G, a; u- V! a        return;</P>
<P>    // Hash the ID to a bucket number
4 x8 {" Q. F& K5 C0 L1 T    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
3 N8 {4 e3 B7 P' [8 ?* N" V    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
* M6 e8 @, s/ ~! A9 G/ {* X<P>    // Add player onto hash bucket chain
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
: K/ T+ k+ F# U% |! l    m_pstIDHashBucket[bucket] = pPlayerData;</P>
<P>    // Store net id in player
    pPlayerData-&gt;NetID = id;</P>
6 S8 v% p& m0 C. H<P>    // Unlock the hash bucket
- x2 o" r7 n3 u/ m5 Y3 a- D' A% g    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>
( i2 v0 M8 g0 b) C3 f% Z8 D; n9 k
% L0 \1 Z$ P, \% ?( K% a" {<P>
//-----------------------------------------------------------------------------
9 F6 H4 A4 K; x// Name:
// Desc:
/ U. ]% r; c0 s//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
! {2 `/ q4 b6 r  N; Z' Y* F{
    // Hash the ID to a bucket number
1 k, M/ B/ w9 [9 j5 L    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
+ B3 y: u- g, g" r0 v    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
0 E3 [  ~: V4 v8 M; D<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
4 _7 i; C: |" e, q# _    while ( pPlayerData )
2 [5 k: O% n. p$ E5 o( S. T    {
# p5 O( G. U" f, I2 ?7 L7 }! r        if( pPlayerData-&gt;NetID == id )
8 a' e7 S* c% F: h. D# G1 |1 o5 X            break;
        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
! k' w+ Q3 {4 J7 j6 }# d% h    }</P>
8 y7 J4 a: @7 }5 \2 _, M4 S<P>    // Unlock the hash bucket
, O; q/ J* r# j6 B) b* B/ D, q    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
<P>    // Return the player we found (will be NULL if we couldn't find it)
$ d# r7 M5 I; X1 S, d/ o2 f    return pPlayerData;
}</P>

2 I0 w5 }( F5 E2 Q* r( n<P>
//-----------------------------------------------------------------------------
// Name:
8 [. C2 r7 N: a% X# E" p' r// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
! n3 d+ t' z8 P. }//-----------------------------------------------------------------------------
" ~, m& p$ l/ S- A1 bvoid CMazeServer:isplayNextConnectionInfo()
{
    if( m_pNet )
$ q. M+ C) t6 e; _2 x8 u    {
& S+ V7 O5 V: G+ Q        // Find the player that was displayed the longest time ago, and display it.
- [. u! k% x- g        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
        PlayerData* pOldestPlayerData = NULL;
2 C: A7 L, O, K4 r5 c2 o        FLOAT fOldestTime = 0.0f;</P>
- D2 _3 i; m( N+ P<P>        m_PlayerDataListLock.Enter();</P>
4 h# a, q2 D' Y! M4 N  K/ b, N<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
        while ( pPlayerData )
+ I( T% o+ J- n; ^: Z        {
            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
- U; F% e! I1 Q* r            {
                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
3 ?" T# k8 Q4 E" C                pOldestPlayerData = pPlayerData;
            }</P>
$ }0 Y  V" h  _! a# s! u5 A<P>            pPlayerData = pPlayerData-&gt;pNext;
        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
6 \$ j9 i( Q) }& L* u. |        if( pOldestPlayerData )
        {
            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
            pOldestPlayerData-&gt;fLastCITime = fCurTime;
        }
) ]2 ~8 C! j" c. _4 S/ u        else
& O% Q$ Z1 B- w  A- }/ _        {
  `. K/ H; ~0 r$ a3 k: S            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
0 O# l4 q  T* j; L' @  H        }</P>
2 w2 W) s! b) x( V2 y4 d3 B<P>        m_PlayerDataListLock.Leave();
4 i1 U% `' x/ f9 O    }
}</P>

! T3 ~5 b% u( {<P>
: W* J- N6 Q8 O6 _6 H* x# _//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
5 ?" ~  ]: _: H0 Uvoid CMazeServer:rintStats()
{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
! N9 {7 J$ w  o$ U                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
9 I9 o. S' H7 k                                    m_fAvgThreadTime, m_fMaxThreadTime );
9 [) A; ^, d0 t8 p    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
0 b* O8 d) ^7 E5 i) j8 {6 ~% A+ c    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
* f! X' ]0 E$ ?( l$ I}</P>
( B* w2 e, m5 ^5 d  J
* P) m0 V* w$ [( B* p7 k<P>
- `1 C& a& H, f//-----------------------------------------------------------------------------
2 m. r  A; i- ]& i  w1 ~// Name:
  C! v* N7 V' X1 x; ^- G// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:isplayConnectionInfo( DWORD dwID )
{
/ G3 A% r1 f4 ^. y5 f    TCHAR strInfo[5000];
" c8 m# @3 i$ I! Z/ Z) _5 k( N) E    TCHAR* strEndOfLine;
- ~: w- r2 \- ^' Y; f. r+ }    TCHAR* strStartOfLine;</P>
<P>    // Query the IOutboudNet for info about the connection to this user
( {6 |" C) `( ?  p    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
<P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );
    ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>
) w6 @, t6 Q0 u8 \7 f+ C<P>    // Display each line seperately
    strStartOfLine = strInfo;
    while( TRUE )
0 I# e* ~/ i3 [2 r9 Q2 D    {
) ?0 u3 P$ U1 a/ I: v' _0 Q        strEndOfLine = _tcschr( strStartOfLine, '\n' );
        if( strEndOfLine == NULL )
            break;</P>
<P>        *strEndOfLine = 0;
; F; U, I8 |. R. Q6 F) M% U. Y        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
. ]# T" G, D! E    }
0 v3 f/ c* q' x. {3 U}</P>
' h% s+ d) {4 ]3 q
* `2 B) t8 L3 w* W0 Q2 R<P>
//-----------------------------------------------------------------------------
// Name:
8 l! l/ a2 J9 i( W' [8 g% j7 _1 q! D// Desc:
6 L2 F( D% U" o# z+ ^8 R! @  H//-----------------------------------------------------------------------------
8 V6 B( }- f: M. l- P- z9 m& KHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
{
    // Chance of forcing any packet to be delivered reliably
    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
4 M3 z2 V0 r; A; C3 u$ w+ p<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
) V: f  h% j" U& x5 K: I. t1 m}</P>

. b2 D. o9 ^; S7 P9 Y8 W<P>
. i0 a2 c5 V* V//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
/ P* o$ ~' p6 q' ]9 h    // If we're up and running, then send this new information to all clients
# A6 H, R1 E7 {    if( m_pNet )
# F0 L( M9 b% g- Y5 W# u; w6 i8 M    {
        //Use the AllPlayers ID
        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
}</P>

4 r) c/ |% l2 Q# I' {$ i! s' ~( J<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
$ V4 ]$ R& c6 W: B1 h# Y) U//-----------------------------------------------------------------------------
# E6 J  M" d% O/ c! ?  {4 Lvoid CMazeServer::SetClientReliableRate( DWORD percent )
3 V) e. x! D7 k- v& e{
6 g% a$ }7 E/ o0 [/ ^* P, u    // Update client config, and build packet containing that data
$ k& w/ E" s& z' y1 K, e    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.ubReliableRate = BYTE(percent);
0 h% V8 z, N; F, V5 R, i* T1 k    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
4 V, i+ Z! ^+ H  L9 y9 R6 f<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
: A! u# z8 w0 N5 z# o: F//-----------------------------------------------------------------------------
" S; {1 H; Q3 Q// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientUpdateRate( DWORD rate )
{
    // Update client config, and build packet containing that data
/ X* P' P6 o' a) p) {6 c4 z    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wUpdateRate = WORD(rate);
    ServerConfigPacket  packet( m_ClientNetConfig );
3 \6 R" j" n9 Y    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
* M, k3 m: x/ o' G//-----------------------------------------------------------------------------
void CMazeServer::SetClientTimeout( DWORD timeout )
. p$ Q% W/ X0 [) a{
" s5 k; E1 ~% l1 o) S' d: z    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wTimeout = WORD(timeout);
# r, V+ ]1 v6 l$ @5 ]# J    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

9 W" k. k6 R* Z+ ~% m1 j# @<P>
3 B: ~3 o: a/ s* I8 f) c//-----------------------------------------------------------------------------
4 I8 B6 ]  L0 q// Name:
// Desc:
) D4 p/ t# o. T//-----------------------------------------------------------------------------
6 H7 X& n2 B; r# n, G9 ~void CMazeServer::SetClientPackSize( DWORD size )
* ]$ L9 b4 `- O1 J{
8 ~2 W* e' R! Z6 d# n5 `: x    // Update client config, and build packet containing that data
+ L2 j7 P8 g1 u8 H; }, o. k    m_ClientNetConfigLock.Enter();
1 ?! E+ f) N6 l5 e' S   
    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
4 G, V+ W2 w+ l6 y        m_ClientNetConfig.ubClientPackIndex = 0;</P>
. u) t! A) C; N<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
; \+ m# A5 V8 H+ }    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

2 D' @7 e) e2 f2 `2 E  T2 s. A<P>
6 r9 O# ]) Q9 R//-----------------------------------------------------------------------------
2 J" n, Q$ o0 d% n9 \. E. D  v// Name:
* e1 E# f1 o& b) b/ S" V// Desc:
& ~# b0 C) Z3 J. f//-----------------------------------------------------------------------------
void CMazeServer::SetServerPackSize( DWORD size )
{
    // Update client config, and build packet containing that data
2 A8 O. R# X: P' J4 Q5 C) {    m_ClientNetConfigLock.Enter();
   
8 \, [# j  L- }, a/ {) M    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
7 E3 M5 S% h* Z/ n6 _        m_ClientNetConfig.ubServerPackIndex = 0;</P>
2 Q' E* i  C, i$ ?4 f( j<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
! X$ n1 \% d$ `& E- t& V0 H    ServerConfigPacket packet( m_ClientNetConfig );
- n' i1 L" L& a4 J    m_ClientNetConfigLock.Leave();</P>
& D9 ~7 |0 d" |! y! {" \: W! ]<P>    SendConfigPacketToAll( &amp;packet );
}</P>
<P>
9 Q# K* j& z, O' z# I% V% v0 N//-----------------------------------------------------------------------------
, U+ D; t( ~- Q$ m// Name:
, \2 z+ R% U& B) Q2 P: y2 E// Desc:
) p; g+ i) x1 ~+ @' n//-----------------------------------------------------------------------------
" Y* J% G+ s0 \: Q  t: hvoid CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
& [( u/ |' q7 h& O, j! c{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
9 y" L  X0 x" x/ F   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
" L: T& y5 x4 c    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
7 O  |! F; |8 f<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>