[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
<>// File: mazeserver.cpp
. m4 a& C( n' f* u8 Q5 w- h& U//
. Q0 T* V8 m5 J3 b# ?// Desc: see main.cpp
//
( F9 d$ W. ^! P1 f1 ~5 {// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#define STRICT
#define D3D_OVERLOADS
. H7 e. v, T* _: |5 Y4 ]#include &lt;windows.h&gt;
#include &lt;d3dx.h&gt;
#include &lt;stdio.h&gt;
#include &lt;math.h&gt;
#include &lt;mmsystem.h&gt;
: C/ m) n/ L5 |3 I8 a- ^  ^#include &lt;dplay8.h&gt;
3 H/ @, C) i1 ~; m. O#include &lt;dpaddr.h&gt;
#include &lt;dxerr8.h&gt;
#include "DXUtil.h"
#include "MazeServer.h"
4 }5 d8 I0 J& P- B#include "ackets.h"
#include "Maze.h"
6 f, w' S. @% O1 }8 _#include &lt;malloc.h&gt;
#include &lt;tchar.h&gt;</P>

<>//-----------------------------------------------------------------------------
( G  _4 U2 ^& _, e/ G$ F// Name:
# G5 O4 i, M( N$ D- X// Desc:
: t: O, J  l# D) H7 Q//-----------------------------------------------------------------------------
- a4 Q5 K8 ]! g% C+ F$ e- t- z0 MCMazeServer::CMazeServer()
+ o2 d9 t7 S3 S9 w{
    m_dwPlayerCount         = 0;
   
    m_wActiveThreadCount   = 0;
    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
- C% a4 s% \4 O3 {) g    m_fMaxThreadTime       = 0;</P>
$ n- Z& W. a. D  \<>    m_dwServerReliableRate  = 15;
    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
5 B3 a8 `  J+ t+ i    m_pMaze                 = NULL;</P>
5 ^% `7 ]6 r+ q# v<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
" |" J$ m# o7 C  v* T) ~3 z    m_ClientNetConfig.wTimeout       = 150;</P>
<>    m_ClientNetConfig.dwThreadWait = 0;</P>
) q: u5 B! ]0 V2 d<>    m_ClientNetConfig.ubClientPackIndex = 0;
/ Q1 x" q  b2 {    m_ClientNetConfig.ubServerPackIndex = 0;
    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
) S, i; l, O3 j( |    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
( ^! m" e2 n# I  q- j# Q        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
: V. l* L- h' y$ S; e    }
7 |1 ?, S9 P" Q6 r6 p}</P>
( Y# y/ l$ t" J% o
<>
//-----------------------------------------------------------------------------
// Name:
& ^+ b. ?! Z; n: ]// Desc:
//-----------------------------------------------------------------------------
# Z' P5 c. y8 `: }4 Z6 p# x5 ~% ~HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
, |: L' t+ P# j) ^" k{
    m_bLocalLoopback = bLocalLoopback;
    m_pMaze = pMaze;
    if( m_pMaze == NULL )
* \- v/ `4 e* r8 T        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
8 ^) D5 N) _% ^<>    // Grab height and width of maze
0 ^+ Q$ p5 Y1 k! H; z    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
  z  ^: ~2 o( O" i" @, f4 W5 q<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
( k  c% r6 i% d6 D5 [( U# \    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
- k6 A' ]9 @( E3 A  E9 E& v7 T$ A<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
8 H8 Q. g. q4 t7 r0 u, _& }$ H7 k. y& f    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
    if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
2 D- P! c! l3 @* }        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;
$ d8 R8 B4 H+ r# R  e* ~9 k# Y: d0 G    while ( (scale &gt;&gt;= 1) )
        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
! H& a/ K* ?" h    m_dwMazeYShift = 0;
5 G9 ^1 y" t% `, J! k3 b7 N8 P    while ( (scale &gt;&gt;= 1) )
        m_dwMazeYShift++;</P>
# k5 U/ Q2 J0 _! Q& J<>    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>
( F9 j+ B$ t2 u: e9 N3 w1 [<>    // Initialise the player list
3 Y; ~( \- e" k# {. O    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
2 n& n; [( N) c, c) ~  Y7 {    m_pFirstActivePlayerData = NULL;
    m_pFirstFreePlayerData = m_PlayerDatas;
    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
! `: O7 [. |, E  b; r, r# P        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
1 u" T- e& D/ z4 w' d% w        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
    }</P>
<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
% C! _: a, q4 O# ]6 F+ e1 c    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
+ |* C4 w$ z$ Q( _    m_dwActivePlayerDataCount = 0;
    m_dwPlayerDataUniqueValue = 0;</P>
+ D7 p% w; |" n! t0 q0 j/ q<>    // Initialise the cells
    ZeroMemory( m_Cells, sizeof(m_Cells) );
7 @# c2 }6 A% i) m; w    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
<>    return S_OK;
- J7 z/ Y; _$ S" e}</P>

<>
//-----------------------------------------------------------------------------
: q" V% r# f$ S/ i. K% ?// Name:
// Desc:
* k, X, K* Y  D//-----------------------------------------------------------------------------
  o$ n3 u! `  M! vvoid CMazeServer::Shutdown()
{
# G; x( g. k: t4 k}</P>

4 Y; E7 b4 Z) T<>
& k9 g. t* t+ C  ^//-----------------------------------------------------------------------------
: C% `' U0 }3 B4 u# K3 h// Name:
, R6 x5 s- L5 m3 F' u/ \& L9 W// Desc:
5 D: [% X; K1 P( g& X* L//-----------------------------------------------------------------------------
% g: B+ `' f% d, G: Z! u7 avoid CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
% o$ U& k: S# x# {7 B$ f6 n! [{
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
. P& F, M0 q6 z8 w  ~6 ?9 a                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>

<>
//-----------------------------------------------------------------------------
8 r/ z5 o5 ^9 ]( V; o/ G5 A2 y// Name:
// Desc:
//-----------------------------------------------------------------------------
* [  U' p' J& {) Fvoid CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
0 ^- R: S* `! c) y8 P5 ?7 X7 e{
    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
9 V) E: d, E" i. J4 Y% Z2 Q                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
- N6 t& f) l  S$ M}</P>

<>
//-----------------------------------------------------------------------------
// Name:
2 Q; \. O, f+ J2 I: {  F; Q// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
$ t! ^& l8 {  Q+ R{
7 S5 g5 y3 P* e. E" A+ t, o4 |# v. h    if( x == 0xffff )
) s9 T4 a! z, A9 p        m_OffMapLock.Enter();
    else
; D2 O% ]( I. F8 o" o6 n. z. h        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
( S% ~% T( M; N* e3 p" L
" Z; u  _. I) E% `<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
2 u6 Y) m3 n" i' o4 d. h  M3 mvoid CMazeServer::UnlockCell( DWORD x, DWORD y )
  S, b' q- _7 h. Z{
    if( x == 0xffff )
        m_OffMapLock.Leave();
    else
        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
- }+ v: A/ R/ o/ V! s/ g" `4 _
* w4 f4 _  S( a& @( E$ T<>
9 r4 Y* B+ o' Q# A//-----------------------------------------------------------------------------
: I1 r8 K! S" f/ x# j- |// Name:
// Desc:
  Y; g" K0 a9 ?//-----------------------------------------------------------------------------
- ~* f( C4 w7 W5 E# l) @void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
! o/ Z: b! \, f! G! ]7 G{
    if( x1 == x2 &amp;&amp; y1 == y2 )
/ q( t6 Y1 u) m( |: ^! n/ ~# I    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
        else
            m_OffMapLock.Enter();</P>
/ E+ E5 u5 C) p4 O+ ]6 B<>        return;
    }</P>
+ @; [! l& f5 J$ p: v<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
. q- L8 F  r5 G) ?  z    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
: K, O4 z5 e4 |9 u, S0 }7 D- ?1 ~    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<>    if( x1 == 0xffff )
    {
0 U; c, t! C7 u$ |9 o8 Z& ~        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x2shift,y2shift);
  E2 g( V- h) n6 Y. Y5 T4 F    }
; Z* G4 s: r- P" C$ ?: D    else if( x2 == 0xffff )
; A3 x8 W' ?% y/ [) T( M    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
$ E- G- W, o! F' {8 v% z    }
% V/ h. L2 J( F, Z7 d$ f" L. d    else
    {
, ]( ?# W# @% K* r, W/ ^, R        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
$ D# O3 f- j/ b' W" \" K: `* H    }
}</P>
/ y$ U$ e/ S7 G5 x# ~9 z, U: ~
* m# R$ F0 `: f' k, o<>
//-----------------------------------------------------------------------------
' }3 ]$ v  I, B// Name:
// Desc:
//-----------------------------------------------------------------------------
" R6 \3 Y2 o% ?4 c: Q" lvoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
/ `+ e$ Z9 G# x& a5 U{
    if( x1 == x2 &amp;&amp; y1 == y2 )
7 g9 ^0 s, Q9 c  k! D. C    {
1 |/ M; K8 V; e        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
% ~! i: N+ o8 }7 ?: n+ X8 s, S            UnlockCell( x1, y1 );
) j9 U2 k1 I6 A! [        else
            m_OffMapLock.Leave();</P>
' k8 I6 a* s5 i' B& x* T$ F8 _<>        return;
# A; r2 W! h' p    }</P>
, g8 |" z( W# K7 r<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
  Z% R; M# _3 F4 M1 e4 `) t    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
' G! i* i! ~, k  T% c: g- R    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
6 r$ S; g  G% Z<P>    if( x1 == 0xffff )
    {
        m_LockGrid.UnlockCell(x2shift,y2shift);
        m_OffMapLock.Leave();
+ {3 X# ~1 F; z    }
" N7 k5 F5 G- O  x/ `9 R8 D    else if( x2 == 0xffff )
3 {. R0 U$ {: E0 J) l' [- G9 }* |    {
        m_LockGrid.UnlockCell(x1shift,y1shift);
0 j% q: x* L9 H2 g7 M( r6 G        m_OffMapLock.Leave();
    }
4 A/ e  I6 s$ z2 E3 C3 V! R& `7 Z    else
! T* o1 H( t/ u; ?  @, O    {
        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
& ]; C' X* W% L+ F' I0 \6 B& g% p}</P>
3 E/ D. U  c2 V
$ d7 Y: I- |. o8 z<P>
//-----------------------------------------------------------------------------
// Name:
8 F3 s- ?2 z3 j0 [* W// Desc:
//-----------------------------------------------------------------------------
7 W, @2 C4 G' p9 P( Gvoid CMazeServer::OnAddConnection( DWORD id )
) C4 u8 Y6 [4 E' P{
    m_AddRemoveLock.Enter();</P>
<P>    // Increment our count of players
" c0 L7 j' O6 w; j( f8 X* ]# a    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
0 |8 E* ~+ R% w- C8 p/ O3 T    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
' W/ m4 F: o  E% ?/ `  k% z! C. l2 T+ T$ v        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
9 O( I; _  U6 w$ F# w/ j        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
8 ?- u; [- S, O% g<P>    // Create a player for this client
    PlayerData* pPlayerData = CreatePlayerData();
6 F! @! I  g8 }5 C    if( pPlayerData == NULL )
    {
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
7 K3 \; S$ P  ]& E1 o/ K) @8 c        m_AddRemoveLock.Leave();
) W; \( V1 n4 Q! ?0 C* z4 T        return;
0 k  m9 V2 ?9 D4 ~0 w3 g8 o    }</P>
: e4 [# d) E1 s* B+ T( P<P>    // Store that pointer as local player data
    SetPlayerDataForID( id, pPlayerData );</P>
3 v! s$ W! ~$ u2 G, W6 x4 o<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
    ServerConfigPacket packet( m_ClientNetConfig );
9 w6 r3 {9 X. y7 b5 o" h" d    m_ClientNetConfigLock.Leave();</P>
7 s8 Y  d4 A1 ^<P>    // Send it
: l3 r' j8 S: p3 w$ L8 H    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
<P>    m_AddRemoveLock.Leave();
# i% b8 [  A7 x8 r+ Z}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
9 `: |/ w) \$ g- X5 o//-----------------------------------------------------------------------------
void CMazeServer::OnRemoveConnection( DWORD id )
! B  w) D' e( C4 M( p- @2 R, S{
) Z5 @" q' C# ?9 V( `! a! l* D7 j    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
    m_dwPlayerCount--;</P>
<P>    if( m_dwLogLevel &gt; 0 )
    {
% O! O5 w. G, H  Q+ G$ W9 g( }3 \        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
8 F: s9 U& a5 q. e        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
" o; A0 N* S* ?% y9 M. Z- {    }</P>
$ _  X! S# l' `3 l7 e$ Y* u. A<P>    // Find playerdata for this client
+ g. x/ ?9 h4 z# `$ w8 K    PlayerData* pPlayerData = GetPlayerDataForID( id );
. ^& B" D) K1 C+ B2 [    if( pPlayerData != NULL )
    {
        // Destroy it
        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
3 x, Z, l6 R8 x- x4 e' ?; ?    }</P>
) @  \: w6 T( B0 c<P>    m_AddRemoveLock.Leave();
  Y, o0 u; M' o) V4 R+ Y9 z1 L}</P>

<P>
' L/ J. g+ N) R  p! Q//-----------------------------------------------------------------------------
6 N* Y" C0 ]5 ?7 D* E2 `& @$ r: o- C// Name:
  Z) X/ H7 Z; W% m( \// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
, `  R2 |( l% C  t* F0 Y; |{
# H7 r2 M8 g2 @. F0 k4 `    BOOL fFoundSize = FALSE;</P>
) z! v3 I' Y/ R4 z<P>    // Increment the number of thread we have in this process.
  D- f: z$ T/ c* {  h% G" N+ W. L    m_csThreadCountLock.Enter();</P>
4 ^6 M0 P" N+ m+ }1 o2 j<P>    //Get the start time of when we entered the message handler.
$ A, V0 |$ \  ~    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
<P>    m_wActiveThreadCount++;
" x3 s; h1 o8 i    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
   
9 l) G$ c9 O; f+ C5 p- I    // Calculate and average.
    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
    m_fAvgThreadCount += fdiff/32;
   
0 R, u7 t% L0 W. R. Y9 R    m_csThreadCountLock.Leave();</P>
<P>
    ClientPacket* pClientPack = (ClientPacket*)pData;
+ r6 }8 B  z: A$ D6 _    switch( pClientPack-&gt;wType )
2 ^. D7 ?* o! D0 a% l' {. `    {
, g) _% L8 N( B! A4 L' u0 {/ }        case PACKETTYPE_CLIENT_POS:
            
            // Check to see if the packet has a valid size. Including
            // the custom pack size.
( Y, W  Y- G! }3 S            if( size &lt; sizeof(ClientPosPacket))
                fFoundSize = FALSE;
            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
                fFoundSize = FALSE;
+ F9 `; V1 I# j3 n            else
                fFoundSize = TRUE;</P>
<P>            // If valid sized packet, handle the position.
            if(fFoundSize)
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
. c9 {) Y+ B5 r: h% P8 k2 F5 j2 R            else
6 S6 ]' P) k  e3 z. `# h                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
4 m& W. }$ B' @; C<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
            if( size == sizeof(ClientVersionPacket) )
+ u5 z/ @3 h- y0 T0 h4 k                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
8 E" D( E$ Y, C9 f/ Q* ~' m& @" J            break;</P>
/ U5 M: x5 Y) D<P>        case PACKETTYPE_SERVER_CONFIG:</P>
<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
<P>            break;
5 q( D4 ]( Y- L' L        default:
            HandleUnknownPacket( dwFrom, pClientPack, size );
( Q6 c; J7 M3 O& i4 s            break;
$ f6 u4 z, S- f8 l    }</P>
<P>    //If the user wants to hold the thread, Sleep for given amount of time.
    if ( m_dwServerThreadWait &gt; 0 )
    {
        Sleep( m_dwServerThreadWait );
    }
   
    // Retrieve thread data for this process.
- b, Z) F3 W& l2 Y9 k    m_csThreadCountLock.Enter();</P>
<P>    m_wActiveThreadCount--;</P>
8 D; P" P% w: C! x2 H1 C<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
2 B- p7 r0 P! q- t* C+ l0 f( a, e    m_fAvgThreadTime += fDiffTime/32;</P>
<P>    //Get the Max time in the thread.
) P% o0 Q) H3 h' W, @) H    if ( fDiffTime &gt; m_fMaxThreadTime )
1 D7 y) E. m! h' ]: G2 C" T1 ~3 n    {
        m_fMaxThreadTime = fDiffTime;
    }</P>
<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
- |6 Y" ^3 D* ~5 C0 |& p}</P>

<P>//-----------------------------------------------------------------------------
5 A# k8 a6 j, _& Q// Name:
// Desc:
; W, }+ M0 t* h5 j: a5 D//-----------------------------------------------------------------------------
) l! h+ i$ ?% T* eBOOL CMazeServer::IsValidPackSize( DWORD dwSize )
{
& ?9 I" D4 j$ N* ?    BOOL fFoundSize = FALSE;
    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
4 |- ~& v+ Y2 a  ]( l* {$ I( `: E: p   
    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
* z5 [& ?3 |9 u    {
        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
! G; O  V# g9 W# y* v8 X; J        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
            {
                // Found valid size in the array.
) P4 p( Q% Q  y. [! o- T% q                fFoundSize = TRUE;
                break;
5 M* |7 t+ d9 j/ i/ l3 W5 W4 l* m            }
            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
; k3 p# t% M) }7 [4 d8 {        }
    }
    else
    {
5 F2 s, U# g/ G8 u! E( }        fFoundSize = TRUE;
+ F7 L8 l3 a8 W( [( K    }</P>
<P>    return fFoundSize;
}</P>
3 e2 n' l/ I# L* A" B3 c/ {8 Q7 Y<P>
6 I/ y/ y, A$ l+ d$ o! P//-----------------------------------------------------------------------------
// Name:
// Desc:
8 s. S7 q+ ]+ ?6 X4 F. n. F- g//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
{
    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
/ ^2 K/ c' I3 J: B& g- J//-----------------------------------------------------------------------------
: G0 T4 A7 {; s, J2 H2 P+ |PlayerData* CMazeServer::CreatePlayerData()
{
% b$ ?3 R2 O, y. S3 D& y  B% d0 K    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
7 O, @7 F4 D* W& b+ v    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
" k+ N/ x0 d6 t<P>    if( pPlayerData )
    {
& p4 T; Y  I) z. V        LockPlayerData( pPlayerData );</P>
<P>        // Got one, so remove it from the free list
        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
        if( pPlayerData-&gt;pNext )
! J& `% u; C% z1 a- m            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
% M4 I$ o9 d# ?8 L  W$ {0 A<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
8 L0 U, S9 y; \8 f) V            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
! ]1 [: R- r: _: J7 {1 E: ?6 q        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;
4 p+ |; H& X" n  ?- j6 r9 m        pPlayerData-&gt;NetID = 0;
- C  ~3 a; T; _  m        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
* S+ k# A0 y7 ~% B6 f/ H<P>        // Insert into the "off-map" cell
        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
+ D. S8 L6 Y: ^' V( ]        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
/ K; @4 ^8 d+ W/ ^' U/ R+ F        m_OffMapLock.Enter();
! X7 b3 ]8 K) Z        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
        m_OffMapCell.pFirstPlayerData = pPlayerData;
! G  ~7 {, @- c4 ^$ x, q; k3 @( w        m_OffMapLock.Leave();</P>
- M3 r3 }; P$ U7 _5 ?  u( ~<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
. x+ g) J* I- C+ z<P>        UnlockPlayerData( pPlayerData );
3 w+ A0 b) p  H/ h: R    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
<P>    return pPlayerData;
! i1 G( k3 q! b+ b" E}</P>
. g* K6 |( Y. g7 F" T9 A( g
<P>
/ Y. m" `. o  K) f1 Y% n$ g, D6 J# W, J//-----------------------------------------------------------------------------
// Name:
# {! y) W' [8 b6 L// Desc:
//-----------------------------------------------------------------------------
, `, q1 f  C! C/ r7 }0 H+ E( Wvoid CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
{
    m_PlayerDataListLock.Enter();
    LockPlayerData( pPlayerData );</P>
* g0 Q9 C9 o" I) M8 r4 |2 q& ^. g<P>    // Remove the player from its cell
! b5 {* m# p3 |9 ?0 I    RemovePlayerDataFromCell( pPlayerData );</P>
" _6 L) ^9 _/ e+ B+ I! O<P>    // Mark as inactive
    pPlayerData-&gt;bActive = FALSE;</P>
<P>    // Remove player from active list
% Y( c0 `$ h( H. y$ D2 _$ G    if( pPlayerData-&gt;pPrevious )
        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
* d3 q& A6 N  j% T. y% ^9 y7 @& H& a    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
8 n# N( s& I/ D<P>    if( m_pFirstActivePlayerData == pPlayerData )
3 J( f7 S+ K' C  V+ U        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
9 l: \4 E$ U2 T* @9 h( {        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
% A0 l3 R+ i8 [0 W    pPlayerData-&gt;pPrevious = NULL;
* j: L5 Y2 b* @/ X( _6 q7 @    m_pFirstFreePlayerData = pPlayerData;</P>
0 E/ r7 D, [6 I6 c<P>    // Update count of players
. @$ W& Z( B7 N% C- k    m_dwActivePlayerDataCount--;</P>
<P>    UnlockPlayerData( pPlayerData );
    m_PlayerDataListLock.Leave();
}</P>
0 f/ z; n& `% F0 t* W
<P>
& y# D. _' K9 i  O9 j2 j4 h//-----------------------------------------------------------------------------
// Name:
// Desc:
7 z- t) h" |# [) H4 v/ I8 `8 ?/ q//-----------------------------------------------------------------------------
# m. a8 S/ o/ N4 A% qvoid CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
: y2 O. g5 J* m6 ^' r2 K- Z9 c9 s{
. w6 U3 i* S3 h* `    // Lock the player
; x, F3 U9 _7 @# a9 ^* H5 M    LockPlayerData( pPlayerData );</P>
<P>    // Lock the cell the player is in
    ServerCell* pCell;
6 z' r) g7 V3 s) L: N$ O    if( pPlayerData-&gt;wCellX == 0xffff )
    {
/ b/ W* a; A" X! }" z$ S7 {+ d7 N0 e        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
    }
    else
    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
( P- Q( |2 q! _0 u( S) v- P! W        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
    }</P>
! s8 T) Y1 x# a: g7 a<P>    // Remove it from the cell
9 D3 h) V; O4 `* u    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
( G# X8 F2 X) x. R    while ( pPt )
- _* O8 k0 l7 E3 H% U! u9 k    {
        if( pPt == pPlayerData )
4 a) o' Z6 \; v3 Y9 M4 O        {
            if( pPrev )
) S1 O6 E7 c6 @8 A! S7 f! D                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
& V' b5 o6 r- [9 @            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
<P>            pPlayerData-&gt;pNextInCell = NULL;
" a" A) ]/ T, t3 v  V- f0 T            break;
        }
; U3 E1 U4 k+ h( a" A) O# a9 m& l. p        pPrev = pPt;
) c. ^) z/ [- \/ h        pPt = pPt-&gt;pNextInCell;
    }</P>
) K9 [) r4 Z! G6 `<P>    // Unlock the cell
    if( pPlayerData-&gt;wCellX == 0xffff )
0 o' k5 A1 ?5 }) {- f6 {  y        m_OffMapLock.Leave();
! `# n2 G! z; A: O    else
* \1 j0 k! O; R        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
<P>    // Unlock the player
    UnlockPlayerData( pPlayerData );
5 G" z& k; g, B1 A4 g( q& r+ |}</P>

<P>
" f: B4 b6 P% f0 h; C; H* l. {* q//-----------------------------------------------------------------------------
// Name:
// Desc:
" ?0 Z8 i6 E  s# t//-----------------------------------------------------------------------------
void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
{
    ServerCell* pCell = GetCell( pPlayerData );
    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
2 u5 O6 ]4 R& p8 o& _3 X+ f    PlayerData* pPrev = NULL;
6 E8 a/ A/ k" ?* W$ L" d+ ~! ~% s    while ( pPt )
    {
# l; p3 V! j+ \3 b5 l        if( pPt == pPlayerData )
/ ^( ]# W2 R* d! G4 U% m# z        {
            if( pPrev )
) u! y0 O' L2 |& t+ \$ ]                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
8 Z! O- }. g# x) Y# R            else
2 j: [, A/ |  `, }1 b                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
# y/ G/ m& J- t, Z. F. j. z7 _        pPrev = pPt;
) m' {5 Y  q! ^6 `9 k        pPt = pPt-&gt;pNextInCell;
    }
}</P>
7 ?* K4 o& ?' y8 m' p
<P>
  u/ ]' s; p! V//-----------------------------------------------------------------------------
0 T! H3 b2 P, h3 v/ h* }9 b! J+ C- R// Name:
: C0 k8 e. |: ^2 p$ i// Desc:
7 l1 C9 X6 V6 G2 l0 w//-----------------------------------------------------------------------------
void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
2 s' d( \! V1 ]2 p1 n    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
' t& t" K2 g$ i  k2 k    pCell-&gt;pFirstPlayerData = pPlayerData;
8 ]$ Y) j+ A7 \8 w3 [8 P}</P>

1 X6 w1 v* P' e, H. x8 O" M<P>
# W; S, o. f2 i# R& e0 `//-----------------------------------------------------------------------------
// Name:
// Desc:
9 B. D8 |$ M( K2 t6 Z//-----------------------------------------------------------------------------
* y$ U/ v3 G7 \9 B. Uvoid CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
2 p* y) p, u3 P3 S    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
    {
        if( m_dwLogLevel &gt; 1 )
& J; T8 w& b  b5 O3 \0 i8 C+ J            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
        return;
    }</P>
<P>    LockPlayerData( pFromPlayer );</P>
" }& @5 ?) i( D' P6 i, G<P>    if( FALSE == pFromPlayer-&gt;bAllow )
5 a- Z# J5 W: q    {
        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 v& O3 {- k$ B<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pFromPlayer );
        return;
    }</P>
9 u1 p* ^+ V6 G7 r& z<P>    // Compute the cell the player should be in now
# v$ o$ f/ u8 T4 I/ [9 U    DWORD newcellx = int(pClientPosPack-&gt;fX);
    DWORD newcelly = int(pClientPosPack-&gt;fY);
9 @3 T0 v' _/ G; p5 ?    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
; N4 {4 ]+ U" @: Z9 G        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);
- F& c: t' j0 B0 h        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
5 H* V# L. [8 h0 c% y& \" G4 J<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
<P>    // Update player position
    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
) `" n3 l2 k7 a/ ^; ^5 o    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
: x: N0 G5 m; p# |4 W; L3 j    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
" m' q% M: j7 @/ T6 y5 ?<P>    // Allocate space to build the reply packet, and fill in header
& n! q2 O' M' N3 {7 V  S8 W) [    DWORD dwAllocSize;
    ServerAckPacket* pSvrAckPack = NULL;</P>
# {1 N4 ~: H* W" K. a/ Z<P>    // Begin by allocating a buffer sized according to
2 ]- P) e4 L  L" z. h; T    // the current number of nearby players + 4.  This will give
# t& U8 v6 l- ?2 e. R1 S    // a little room for more players to come 'near' without resize
    // the buffer.
    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
( n; x3 L2 M8 ~0 S: Y    {
        // Out of mem.  Cleanup and return
6 V% `4 [2 g5 N* ?% C        UnlockPlayerData( pFromPlayer );
        return;      
    }
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
0 ]% U' R7 T4 `1 E    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
% ~, R" U5 V* Q4 x2 p% M: J  o    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
. X0 V, P. p! U<P>    // Compute range of cells we're going to scan for players to send
    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
! o% Z" J& N0 V2 f/ B    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
<P>    // Lock that range of cells
+ |( ?( W4 k0 @) w- e& R    LockRange( minx, miny, maxx, maxy );</P>
<P>    // Scan through the cells, tagging player data onto the end of
) q+ U/ S: J+ Q, U    // our pSvrAckPacket until we run out of room
' z' C4 }1 j! Y- j- _    for( DWORD y = miny; y &lt;= maxy; y++ )
2 q: y& d" t2 h* D3 p- P    {
( k6 s" z) v2 [0 C  {+ n' P! O9 g        for( DWORD x = minx; x &lt;= maxx; x++ )
        {
/ G. J2 I+ f7 A- R" l( _! c. ?6 I            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
& D% r" f2 J" F( n; K6 ?            while ( pCurPlayerData )
! S+ L# Y* T. S- H, D! }            {
                if( pCurPlayerData != pFromPlayer )
6 n7 h9 E/ F+ [; [& \" ]                {
& ^3 j% Z2 \# E7 w6 o                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
                    {
                        // 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
: N$ p! T2 G) E                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
7 J9 Y! G# F2 g' \" k) K                        dwMaxPlayerStatePackets += 16;
' W2 ]- j% |) t! L2 G' t                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
2 y' \7 u  P; L2 _7 [% d                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
! @" Q4 H5 n* e8 i/ T                        if( NULL == pNewSvrAckPack )
  k1 ?/ r- X2 j: H% c4 Q  G- F                        {
7 r. c6 `# j9 D                            // Out of mem.  Cleanup and return
                            free( pSvrAckPack );
! v. y, k$ w" A: q# N+ f                            UnlockRange( minx, miny, maxx, maxy );
                            UnlockPlayerData( pFromPlayer );
                            return;      
                        }</P>
6 r" T& h* p: s# w& Q1 `<P>                        pSvrAckPack = pNewSvrAckPack;
                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
" @! _0 Z4 L+ g" \( m. C<P>                        // Make sure pChunk is still where its supposed to be
$ z8 |, H/ [9 H0 v2 Y9 i" n                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
                    }</P>
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
4 I/ S+ t" I! s                    pChunk++;
% `0 [2 M4 ^2 }$ a' o                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
        }
    }</P>
) e/ E; {" k. B<P>    // Update the dwNumNearbyPlayers for this player
    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
1 b" Y7 \1 n8 z/ y5 Z* h! X<P>    // Unlock range of cells
    UnlockRange( minx, miny, maxx, maxy );</P>
<P>    if( m_dwLogLevel &gt; 2 )
* w9 p" p, x5 G3 A* E6 `  A' c    {
        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
    }
    else if( m_dwLogLevel == 2 )
    {
        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
$ u" S) T6 I! S2 `        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
4 n3 z6 j; F# L8 R! p* y        {
6 B0 Y; w" j! N0 z: g3 A0 Y$ F" a1 Q            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
            pFromPlayer-&gt;fLastDisplayTime = fTime;
        }
    }</P>
% H' j/ Y' i, R- r2 Y4 A# i<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
<P>    // Send acknowledgement back to client, including list of nearby players
) b) ]2 u% V! d    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

    // Pack the buffer with dummy data.
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
: f( f* n4 J+ k" {+ s    {
        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
        VOID*   pTempBuffer = 0;</P>
& i9 k2 D" H& K4 S<P>        pTempBuffer = malloc(dwBufferSize);
        if( NULL == pTempBuffer )
9 }1 ?7 o) o8 K- e( O        {
9 y* u* l3 U5 M" ^            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
+ g5 i, M% o$ R4 `  t            free( pSvrAckPack );
            return;
        }</P>
1 {6 Q* ^7 D1 N6 F3 Y- I<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
   
        free(pTempBuffer);
4 _9 W# m: c7 H- s    }   
    else
    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
    }</P>
. @4 w: l5 z0 f& u<P>    free( pSvrAckPack );</P>
<P>}</P>

* v1 Q1 v  M' {4 C1 _<P>
//-----------------------------------------------------------------------------
// Name:
! B$ K% G# C# c% |1 u" W: [; ~8 s// Desc:
//-----------------------------------------------------------------------------
7 R- t& l" E8 O1 ~1 m1 O4 Svoid CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
" ?7 P  P5 v8 z& C    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
/ i" \  y1 y9 @0 z3 X& o' E/ O7 L0 E    if( pPlayerData == NULL )
+ c6 B( F$ [2 t6 X1 [        return;
    LockPlayerData( pPlayerData );</P>
$ y: ]  l. K2 S) Q4 a8 `<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
8 P+ U$ P" F0 N/ v" j* S  b5 N<P>    if( m_bLocalLoopback )
4 {; V1 |' y& p5 u. Q        pPlayerData-&gt;bAllow = TRUE;
" y$ S4 H" ]1 @' ^3 k    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>
<P>    if( FALSE == pPlayerData-&gt;bAllow )
    {
        if( m_dwLogLevel &gt; 0 )
9 C0 N$ ?! ~/ F; _7 h3 S8 o            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>
1 _" r+ K2 z" t/ Q6 A; \7 `<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pPlayerData );
' s% v, n8 d( I9 c# D2 u* M        return;
* S' X7 T' Q8 H* c2 M    }</P>
<P>    // Unlock the playerdata
! l  u% j$ i- j; s: G5 {9 u    UnlockPlayerData( pPlayerData );</P>
<P>    // Send acknowledgement to client that the client was either accepted or rejected
0 C  }9 ^8 X$ i# F5 H9 `    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
}</P>

: B; k; S! l$ p5 l<P>
! L  T5 C. m' k$ ?1 h& W//-----------------------------------------------------------------------------
2 X# X/ n% P) |- _0 M# ^4 Q+ i3 p& _5 f// Name:
1 e1 y$ g( n  M// Desc:
5 C7 w0 @7 y8 v0 g$ U//-----------------------------------------------------------------------------
2 S* v, U  j/ B0 X0 Q, P( O$ bBOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
/ d6 W! a6 T' S{
    switch( dwClientVersion )
7 P3 I9 W1 W1 u# q. C- I7 g: h( s    {
9 s& w4 X. l; F2 }0 R& @8 @3 S  h        case 107: // only v107 is supported
            return TRUE;
; e" Z9 a; W# R        default:
6 I* T* c# l2 ?8 d( B! ^5 C            return FALSE;
" ?: Q5 a+ n/ U+ @1 S    }
}</P>
  ]/ X2 `8 P, K6 I" ^8 x4 M1 x
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
{
9 [) }0 |$ v6 c- l    if( m_dwLogLevel &gt; 1 )
" ?! M, i* q) F1 Y% V3 l9 F        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
3 ~& i- f3 H% A# z& W<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
! R3 j& ?" O3 V' |$ A. Z" }0 R3 X}</P>

7 L: u% j2 c$ K  ?9 e<P>
" b4 R% B5 Q4 W8 T//-----------------------------------------------------------------------------
// Name:
: E; I# H: f7 Z8 B// Desc:
2 v& B0 i/ V* }+ H& P//-----------------------------------------------------------------------------
+ B  X2 k$ S/ QDWORD   CMazeServer::IDHash( DWORD id )
- G8 i1 X* ~( L" J  V{
    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
    return hash;
}</P>

" D5 d6 h3 a. D$ T<P>
, P0 L+ K# h: I" [. J, Y2 T+ \//-----------------------------------------------------------------------------
' x$ b, {: U% M  ?; x' h1 Z// Name:
// Desc:
//-----------------------------------------------------------------------------
$ L1 n) A- I' H* _' k" I1 {void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
{
    // 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;
/ t( h$ o% l% l9 M( q4 k! w( {    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
0 z6 g1 W& |$ N+ u( I<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPt = m_pstIDHashBucket[bucket];
0 }: \6 Z+ j5 a: X. c" w    PlayerData* pPrev = NULL;
- K) z4 W0 b  m3 D  g3 o! B( f    while( pPt )
    {
6 U! c! N( l7 D* Q0 ~3 w& q' f+ i  i        if( pPt == pPlayerData )
            break;
; b* b6 ?# S, |6 ^        pPrev = pPt;
5 g  E  @+ K1 u9 O        pPt = pPt-&gt;pNextInIDHashBucket;
7 R9 P/ Z" n* `( a3 B! d    }</P>
<P>    if( pPt )
    {
        if( pPrev )
! \# n0 K. E$ }! l* V            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
  ]2 ~) w0 Z. j  O5 S        else
            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
5 Z! _( j3 v: w( i0 `        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
<P>    // Unlock the hash bucket
' u2 f/ \  v  p3 K% A) P    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
  u( c% ^$ E( p8 c7 S. o: r3 v* m}</P>

<P>
//-----------------------------------------------------------------------------
( J# [/ V+ x6 Q( |6 `8 c4 u// Name:
) W/ X2 ~0 P  ^$ [1 R// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
{
    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
% ]+ _! C& r0 p8 S4 N    // otherwise there will be a circular reference
$ X7 s) f' @2 E    PlayerData* pSearch = GetPlayerDataForID( id );
    if( pSearch != NULL )
        return;</P>
<P>    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
( g; a4 |( n# t8 w. L- A5 d  f<P>    // Lock that hash bucket
6 n2 [7 N9 R8 i8 H- J: U    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
8 O  Q3 L" S. H0 K2 l8 e    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
0 f" c/ M/ X! [5 S' R8 u$ P    m_pstIDHashBucket[bucket] = pPlayerData;</P>
8 A4 _# N  s* K1 ~! w8 ]<P>    // Store net id in player
& u/ ^+ J3 y; u, j2 O% C    pPlayerData-&gt;NetID = id;</P>
<P>    // Unlock the hash bucket
6 l" Y' n6 B5 h5 }  I. |- u2 @    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>
3 c+ }& I$ m" m; k% L5 z  l8 T
$ ^* p& B8 ], e8 O<P>
//-----------------------------------------------------------------------------
: @% `: ?& I! t// Name:
. B! F. F# M8 n+ ?// Desc:
//-----------------------------------------------------------------------------
" R+ Q6 m0 x# c  B  [9 H) qPlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
6 O1 r1 D9 i! H9 i! p" h    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
, J+ X. L% f  O" G' o- ^7 F5 j+ q    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
  q! Z$ v5 M6 v+ J' ~    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
0 n$ \. {$ g6 Y5 x    while ( pPlayerData )
    {
2 i, B4 H2 i5 ]6 [        if( pPlayerData-&gt;NetID == id )
3 o" B1 g; Z) h. ]            break;
6 K0 d% w8 T: b2 p: B: E2 x" O2 T& I        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
) C% s) p5 X- C7 g    }</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
% J& F  S; I! U! U<P>    // Return the player we found (will be NULL if we couldn't find it)
    return pPlayerData;
. P7 L% j& f4 ?* W; k% m& Y}</P>
: D9 m1 c1 C, I# D4 k
<P>
, K# U: u, L3 R  e//-----------------------------------------------------------------------------
// Name:
7 r( O" ?9 P, C( i// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
//-----------------------------------------------------------------------------
( M# X$ v, {; ?! F" @) Xvoid CMazeServer:isplayNextConnectionInfo()
{
    if( m_pNet )
, p+ E* Q2 h9 c    {
        // Find the player that was displayed the longest time ago, and display it.
0 E2 D' N9 e, z4 O9 k2 q# V0 S2 y        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
        PlayerData* pOldestPlayerData = NULL;
1 |. h( \; h: f! m: {  n$ y! v        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
5 m! j: T4 _# s+ W        while ( pPlayerData )
        {
            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
            {
- K9 c1 [: V8 g                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
0 z, \- {3 G# U# {7 r9 B6 f                pOldestPlayerData = pPlayerData;
            }</P>
! G8 ?- j+ ^7 O9 |+ _<P>            pPlayerData = pPlayerData-&gt;pNext;
9 A; ~$ g! X" ^2 c2 q7 G$ R3 i- Q2 s        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
& k& e# x9 o1 t0 ~' n        if( pOldestPlayerData )
        {
. C; M/ _- @7 R4 C1 x! f            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
( ~. e8 A6 f" Y! d            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
            pOldestPlayerData-&gt;fLastCITime = fCurTime;
        }
/ J  q- g6 h4 T! w/ v# S/ j$ w- |        else
' l$ K& L: p# q' T- U        {
: d/ U( s" k1 V0 V7 N            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
+ A. \8 c! z" w2 Z        }</P>
<P>        m_PlayerDataListLock.Leave();
    }
}</P>

2 d) S  T' X; ^. n, z<P>
, n( `% T3 P; U: m- L//-----------------------------------------------------------------------------
// Name:
' M8 }7 w6 t% e" a! F& G2 z// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:rintStats()
{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
. ?; b0 ^! Y+ z$ l6 |3 V: B4 C8 D    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 );
0 m2 [0 W+ {7 I& T, e    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
}</P>

. d: v% R: \+ ?' O$ m! K<P>
//-----------------------------------------------------------------------------
% L0 E% q$ I. }4 C" b/ J// Name:
, I) l4 o' M* x# k, o// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:isplayConnectionInfo( DWORD dwID )
{
. M6 J8 U; n. Q    TCHAR strInfo[5000];
4 i! W0 n3 z: f/ u    TCHAR* strEndOfLine;
) ]+ ~1 f0 w# `; y    TCHAR* strStartOfLine;</P>
<P>    // Query the IOutboudNet for info about the connection to this user
    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>
/ {4 X. m3 v/ Y( w' @7 R9 @0 |<P>    // Display each line seperately
. T4 h1 V/ K2 }' A    strStartOfLine = strInfo;
    while( TRUE )
    {
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
        if( strEndOfLine == NULL )
            break;</P>
4 A! P* c4 c' l1 x; ]<P>        *strEndOfLine = 0;
6 t2 `- s9 ]1 g9 F7 w+ z# x        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
    }
}</P>
0 e4 |6 S, U( d+ F. b' [; X( G
. |; _) k( J4 ~<P>
//-----------------------------------------------------------------------------
" j& |5 l. f* }7 P/ p+ R& i* y// Name:
// Desc:
5 e$ R) R( V4 x1 P3 I- J//-----------------------------------------------------------------------------
HRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
{
$ B5 L1 K( v% }3 Y5 ?" S% c7 m) \8 r( }    // Chance of forcing any packet to be delivered reliably
+ k4 [. w3 i& S    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
4 ?) G+ r) \! \- D; N        reliable = TRUE;</P>
1 w% N8 H& I: c4 T  t<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
$ `: F8 t) ]. q0 A& u* Q}</P>
9 w. s7 v  p* ~9 ^5 w; q$ h
<P>
- t+ M$ k" d+ d( B. W4 A  h/ t//-----------------------------------------------------------------------------
: a. r; ?7 R. z1 P// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
/ t+ }7 r# k2 c    // If we're up and running, then send this new information to all clients
    if( m_pNet )
; N  B3 R8 P; j    {
* Q- |2 M/ m( F5 [8 ]6 L        //Use the AllPlayers ID
        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
}</P>

0 P5 V" T  {4 |0 m2 o<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
% y4 q% w9 ?: I: G- U2 i//-----------------------------------------------------------------------------
void CMazeServer::SetClientReliableRate( DWORD percent )
5 d& v* h8 N$ f% b/ C4 v{
0 l5 }/ U0 k& k, H1 i' `    // Update client config, and build packet containing that data
8 }- [0 w( E' g    m_ClientNetConfigLock.Enter();
0 J$ @) M6 q7 H1 c& D( a/ M    m_ClientNetConfig.ubReliableRate = BYTE(percent);
$ f9 O2 D& ^9 M& c. o; A    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
# x5 K# I  J2 D; o# G8 c}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
' I, H6 {6 E+ M// Desc:
9 b& d& Y4 {+ v; m) h8 J& I% v//-----------------------------------------------------------------------------
void CMazeServer::SetClientUpdateRate( DWORD rate )
* E) {* Y$ e! ^; t2 |9 T{
    // Update client config, and build packet containing that data
( J: ~( D4 U" W1 U& Q, N, e& u8 [    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wUpdateRate = WORD(rate);
5 W( M: Q+ ~& w- y    ServerConfigPacket  packet( m_ClientNetConfig );
) E2 j% B9 b- O/ H% C& C; Z2 [  ~    m_ClientNetConfigLock.Leave();</P>
0 b1 R3 o* ^$ K; s<P>    SendConfigPacketToAll( &amp;packet );
}</P>

; y1 W+ D2 x6 `* D% D9 K/ V<P>
//-----------------------------------------------------------------------------
  o9 j/ S8 G" K4 D: }$ d1 b// Name:
// Desc:
" G) x9 d) f+ R+ l+ |0 j& k, w) S//-----------------------------------------------------------------------------
6 ~' T: D" H7 M0 n* d$ fvoid CMazeServer::SetClientTimeout( DWORD timeout )
2 q3 I7 n( L; }% N1 M& j{
' W! M$ ^* c# K7 u- u- _( F( V) x* t    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
2 W6 x# C9 |0 R    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
/ i3 h2 u8 A. j8 ]<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
//-----------------------------------------------------------------------------
8 m2 k2 |4 |5 t// Name:
' X# c- M4 b  @- B+ F/ x0 O// Desc:
7 i0 m) Y; S: V! n# c  w. W//-----------------------------------------------------------------------------
& M; P* J9 k3 f+ m5 D" ]( y5 Jvoid CMazeServer::SetClientPackSize( DWORD size )
{
    // Update client config, and build packet containing that data
, f) i- j' `! i; x- ]) p0 E    m_ClientNetConfigLock.Enter();
+ M2 ^% w% N/ s5 s2 p! v0 i" n9 K   
. l6 G, h9 `5 X    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubClientPackIndex = 0;</P>
( P( ?& `  P  _<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

  g' J. s! w6 G6 A<P>
" y9 i7 W% y/ [- [. T$ Z3 S4 w) ^//-----------------------------------------------------------------------------
// Name:
// Desc:
  o, M, t0 C/ Z* V# M//-----------------------------------------------------------------------------
$ \. \3 c: A9 q$ d4 r3 I4 [. j6 ]- V% Fvoid CMazeServer::SetServerPackSize( DWORD size )
- _. K! }2 E( N{
( _6 @' {$ d! u' j0 W    // Update client config, and build packet containing that data
! s+ L# ^8 q3 }, b' R2 E8 K- s    m_ClientNetConfigLock.Enter();
   
7 R( G6 q1 q! o* a" ^6 h$ T    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);
, {9 p6 I" o% a$ ^6 D7 T    ServerConfigPacket packet( m_ClientNetConfig );
; G' l" {5 G2 E' T, r$ b    m_ClientNetConfigLock.Leave();</P>
/ m8 W7 W; R, T, p! |6 |9 Z; t<P>    SendConfigPacketToAll( &amp;packet );
7 ]- {6 ?9 ]# J}</P>
<P>
//-----------------------------------------------------------------------------
; l+ K' x7 U2 v/ T/ l3 [% F$ J// Name:
// Desc:
7 f* G, Q, R, v+ n, j//-----------------------------------------------------------------------------
# K1 ?% Y2 H+ X: Q6 Y# Y5 Ovoid CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
   
( _# a# h  V# |6 I3 @/ L    m_ClientNetConfig.dwThreadWait = dwThreadWait;
* ?. J8 s4 [& G" T# x9 g: Z    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
) h2 C8 w7 w7 u- y8 {: B<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>