[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
& `1 s2 R: L$ d2 f5 A, P<>// File: mazeserver.cpp
, J, k$ t" }+ I2 M2 ]//
// Desc: see main.cpp
//
// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#define STRICT
! y3 e; m5 M. f7 f% _! V#define D3D_OVERLOADS
4 K# `* P0 G1 W8 Z% H' T+ {#include &lt;windows.h&gt;
. V! s; j7 k0 J4 O) s8 u#include &lt;d3dx.h&gt;
#include &lt;stdio.h&gt;
* Z) J4 A5 c( R#include &lt;math.h&gt;
- w' a- `7 X* x& i, y  ^6 F5 s#include &lt;mmsystem.h&gt;
#include &lt;dplay8.h&gt;
) J8 k+ ?/ r; `: {7 Z* u6 Y& ^#include &lt;dpaddr.h&gt;
#include &lt;dxerr8.h&gt;
#include "DXUtil.h"
#include "MazeServer.h"
#include "ackets.h"
#include "Maze.h"
/ ]* n0 L1 t2 q) c; h( x8 H7 E#include &lt;malloc.h&gt;
5 w  @" q; T+ n$ w6 N. Y#include &lt;tchar.h&gt;</P>
9 ^" i6 p% e" }( i
/ O9 h" M- D3 N5 L<>//-----------------------------------------------------------------------------
. {. T3 J) j9 l- t6 E// Name:
' V# h( F) p# A  R: f// Desc:
//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
8 J( k0 ?4 a' E( o" d% {( Q+ b{
% z& L/ V. x" _, O, \" y( \0 m    m_dwPlayerCount         = 0;
: T% S; t8 T7 f% Q7 L1 T! s2 m4 H' z   
) }7 O: e2 H" N5 Q9 @$ K    m_wActiveThreadCount   = 0;
    m_wMaxThreadCount      = 0;
0 _: ]4 L1 L3 e% J! h    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
    m_fMaxThreadTime       = 0;</P>
$ k4 {( c) A! m<>    m_dwServerReliableRate  = 15;
    m_dwServerTimeout       = 150;
% n7 }" c0 p6 I6 v7 Z. s    m_dwLogLevel            = 2;
    m_pMaze                 = NULL;</P>
/ a3 @2 _3 w; n+ R/ b1 B; |. \<>    m_ClientNetConfig.ubReliableRate = 15;
& u1 F( n! @5 l/ x$ N6 ^    m_ClientNetConfig.wUpdateRate    = 150;
& B- j1 ?1 l3 U5 J& W1 X0 s    m_ClientNetConfig.wTimeout       = 150;</P>
<>    m_ClientNetConfig.dwThreadWait = 0;</P>
" L; z# a  `6 }1 x% k0 H<>    m_ClientNetConfig.ubClientPackIndex = 0;
% Z0 J$ e$ ^, ]9 w! {  O& j    m_ClientNetConfig.ubServerPackIndex = 0;
7 [; ~+ W% q, c    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
' r% o6 i3 J1 M5 @1 B- K' C4 }    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
}</P>

$ ~) i4 ~3 ^$ Y* h( u) R7 E$ ^<>
" A2 x' |: A( k: e//-----------------------------------------------------------------------------
// Name:
. G) l( D0 p8 X) R5 X' G// Desc:
7 ~# K6 g) ?% ]7 H- f//-----------------------------------------------------------------------------
* L: }3 m. M, H: t+ q8 FHRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
0 C! c, z7 E8 q3 Z( r    m_bLocalLoopback = bLocalLoopback;
# U8 a* H0 I: H* C    m_pMaze = pMaze;
    if( m_pMaze == NULL )
# c- s" Y# Z4 O6 P5 K, n1 o4 A        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
% q1 B; r9 i7 Y' Y1 n6 ^/ ]) U<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
4 O, \' t& P! k" B; D* }<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
. x6 T0 f0 v" s. m6 x( X' S" j<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
( m' Y! I6 J8 G2 i! z7 S2 [; ?& s    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
1 L$ k+ z- v) g# T5 o4 ?        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
    if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
: _! n& G: M: n0 _        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>
<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
1 p: z6 ^; Z. x    m_dwMazeXShift = 0;
7 R6 ?+ L/ x5 m    while ( (scale &gt;&gt;= 1) )
( l5 b* U3 T; o3 P* T7 r; P3 U% `        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
7 \( c/ \7 z0 C: _3 y    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
8 v2 G) V' ]- k! B7 I        m_dwMazeYShift++;</P>
<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
& B. ~' g6 y* r3 ~- Z, x        ((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>
5 _' z3 Q# \! M( l& L' |1 L" D<>    // Initialise the player list
. D7 W6 R4 o6 F& W' ^" ^    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
    m_pFirstActivePlayerData = NULL;
. [% b9 p. M& s# f, F9 p" b; J- }    m_pFirstFreePlayerData = m_PlayerDatas;
    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
* E; S% u$ c; h0 b        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
    }</P>
<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
3 Y+ |: B2 d/ r; V' {3 g0 H    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
3 }1 n9 r& d" k, d( n& b    m_dwActivePlayerDataCount = 0;
    m_dwPlayerDataUniqueValue = 0;</P>
& T) r, Z9 D9 {6 K0 l) l$ }<>    // Initialise the cells
2 n7 @* a: r9 }* S    ZeroMemory( m_Cells, sizeof(m_Cells) );
& W" }4 d; ?# r' a  o  |- ?3 ]. H    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
<>    return S_OK;
- `/ w, _! I+ P) K4 V& k1 A}</P>

<>
2 j4 [% B6 Y% l' X% k//-----------------------------------------------------------------------------
0 j5 I8 p! Y* C  A5 z// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::Shutdown()
/ x/ B3 G; M+ G# R{
6 Z, H% M* K, U& _+ [% a$ t# e' n}</P>

( j" T/ a* y1 ]1 s. E0 G% j<>
" a2 e0 U- w" v8 D//-----------------------------------------------------------------------------
9 a) m+ C! l) Z% \4 y& s! U8 d// Name:
9 b! r9 S+ `& ~& k* o, U: d" U3 b3 a; e// Desc:
$ _( g+ j5 D2 r5 o* r+ J) G! h7 X//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
3 E! E# X/ ^7 H- d}</P>
, k0 U3 c2 b# e2 k* R5 [
<>
0 j4 k1 i5 u. B- d//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
. f, j; P6 N3 u  l$ H# \! U9 f3 n2 evoid CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
; \% E3 t" g4 ?4 X7 i{
$ Q, F' N+ k) h* h1 [    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
/ X6 I3 s3 U0 L3 d3 t                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>

  [0 p' B5 H. \/ Y+ G<>
//-----------------------------------------------------------------------------
3 B: o! P8 s9 T* `: |1 o// Name:
// Desc:
//-----------------------------------------------------------------------------
1 `% K0 g' a1 Q/ f  Ovoid CMazeServer:ockCell( DWORD x, DWORD y )
4 v% H0 b$ f- l3 f( T# z3 e+ p2 g{
' s4 f. a3 r9 s. z1 }3 T$ ?, B  Z    if( x == 0xffff )
  r- p, J: Q( G3 \) y, Y        m_OffMapLock.Enter();
    else
7 `5 s. ^9 M4 p4 A$ ]+ j3 H        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>

' q6 ]+ x; K4 }<>
# g. X& r* P$ c  r//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockCell( DWORD x, DWORD y )
{
) N4 Y, }% E2 W$ Z; I9 o    if( x == 0xffff )
        m_OffMapLock.Leave();
    else
        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
( L( g: a2 }0 _; ~}</P>
0 D* }6 S0 T  V6 I/ R
<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
% w$ j, [: L0 H6 w5 K! r{
( u$ X7 f4 n& u* t    if( x1 == x2 &amp;&amp; y1 == y2 )
6 I/ \6 E$ W* m7 r    {
  D( T: g& p4 V$ `        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
9 E- Z' E" w1 s# `        else
            m_OffMapLock.Enter();</P>
9 Y4 U% [4 t  _" K6 x, G3 f<>        return;
7 U% g( B) }+ q# U0 X' h% S" N    }</P>
$ B" u- u. Z8 Z<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
5 w6 |5 \* O+ E% ~    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
' y' j( h& [( ^5 g    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<>    if( x1 == 0xffff )
    {
8 s! P. K& T: d2 @+ c% X        m_OffMapLock.Enter();
- k' d9 s. N  G6 V3 O5 z, @* G        m_LockGrid.LockCell(x2shift,y2shift);
; u8 O3 ^0 s2 H4 R- R) r+ c& e    }
+ y, ~% F+ e  b' N* g7 T1 [    else if( x2 == 0xffff )
; y# T$ t* f" p6 ~, D3 n1 ?    {
3 j7 B2 D, e4 X        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
    }
    else
2 s2 s0 n6 F+ g6 G    {
        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
}</P>
6 f1 `& z" x' b
/ g' F0 r% [& C  E. G9 R* j<>
% c1 l  W* Q4 f- e; s//-----------------------------------------------------------------------------
// Name:
8 l4 R+ @2 g! m4 _2 @5 f" U7 j// Desc:
& b. W8 z1 P% X. I. M3 q# m//-----------------------------------------------------------------------------
- \$ u9 i: z2 B6 n- Bvoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
    if( x1 == x2 &amp;&amp; y1 == y2 )
, _) V* i; U7 ]$ `3 X8 g. d/ ]    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            UnlockCell( x1, y1 );
        else
            m_OffMapLock.Leave();</P>
<>        return;
  {9 `9 s/ |" E+ O: N# `3 K! ~% T    }</P>
<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
3 T7 I, M- u7 Q) ~+ J    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
: y" I3 @" u+ e    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<P>    if( x1 == 0xffff )
    {
2 J) w, G( |$ o' B0 P+ C        m_LockGrid.UnlockCell(x2shift,y2shift);
, J& P1 h* E0 x1 n- j        m_OffMapLock.Leave();
* u1 A% Z/ S1 L- v, [* X0 N    }
- O; `/ h* `- O    else if( x2 == 0xffff )
4 W' Q+ |( R. i1 X7 [    {
6 w) m$ \1 o9 [        m_LockGrid.UnlockCell(x1shift,y1shift);
        m_OffMapLock.Leave();
    }
    else
3 J3 M% ^+ M: x/ Q    {
        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
1 }6 q: A8 _6 m. H    }
}</P>

" M% j: H0 b( j2 |; i. t<P>
//-----------------------------------------------------------------------------
' V; Q( N$ h' Y// Name:
// Desc:
0 X# X9 W# N* D& T) y//-----------------------------------------------------------------------------
void CMazeServer::OnAddConnection( DWORD id )
{
: y% Z6 r0 E' b; \& K" J, B    m_AddRemoveLock.Enter();</P>
0 C9 d& r. L# V<P>    // Increment our count of players
# v" M- [+ }& W/ E  }& I: e+ L    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
( w' w* C) A8 g( p/ t        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
0 ?' ?- y1 q' X    }</P>
<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
% e3 ?# Q, E) v8 j0 R' A        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
+ P! Q2 |0 ~5 H/ x. c9 ?3 z6 b, `<P>    // Create a player for this client
( F& `5 u/ E+ M+ a    PlayerData* pPlayerData = CreatePlayerData();
8 o& g. l) j+ F    if( pPlayerData == NULL )
' [! B$ Z4 S9 y1 P7 s* w* X9 H! P  A% b    {
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
; q5 A/ m  y, L  i5 o$ r7 Z; x  Z        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
        m_AddRemoveLock.Leave();
) `6 r3 O: Z; I% b( f- G" h        return;
    }</P>
% N6 ]+ T8 f) Q' l, G<P>    // Store that pointer as local player data
2 a  n" j4 V1 E- J" F5 o& K& r    SetPlayerDataForID( id, pPlayerData );</P>
<P>    // Grab net config into to send to client
; m5 S0 \  d. Q$ g1 E  y! l    m_ClientNetConfigLock.Enter();
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
: f; [7 [, d4 s  w. Y<P>    // Send it
    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
7 \% t& u0 `6 |# A3 K+ k<P>    m_AddRemoveLock.Leave();
3 J3 z% `0 N0 q. o}</P>

<P>
" U$ Y; n- [0 s; o( v//-----------------------------------------------------------------------------
// Name:
// Desc:
' Y$ h$ `, U; h, @, O0 i$ E//-----------------------------------------------------------------------------
" L( L* n# Z0 x" Yvoid CMazeServer::OnRemoveConnection( DWORD id )
{
5 |1 B7 d* M  R' a* c: v7 b    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
2 e& m) j- U' W    m_dwPlayerCount--;</P>
' ~- ?2 \+ h+ z& X7 G" |<P>    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
) Q& U3 L7 B/ u    }</P>
<P>    // Find playerdata for this client
    PlayerData* pPlayerData = GetPlayerDataForID( id );
4 L+ A# R6 L! Y8 C6 v4 x    if( pPlayerData != NULL )
    {
& G0 C' v  U# N4 b2 w% n7 l# ~        // Destroy it
        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
' [+ a7 [' o8 E. Y    }</P>
<P>    m_AddRemoveLock.Leave();
1 r) r: f3 s1 J( O! U7 M% B) M6 P}</P>

7 V$ w/ x/ G+ t9 `1 V<P>
//-----------------------------------------------------------------------------
$ }5 @( `- x) _0 b( p// Name:
/ h# K. B: H6 p# J& t; h0 E9 \  z// Desc:
* ~/ X% H- T! A# H//-----------------------------------------------------------------------------
HRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
{
    BOOL fFoundSize = FALSE;</P>
2 `, X0 _2 ?0 ^' t4 F  Y  d" M+ D<P>    // Increment the number of thread we have in this process.
    m_csThreadCountLock.Enter();</P>
<P>    //Get the start time of when we entered the message handler.
# k* G+ r' c+ b* i  Q$ a- b' T7 D& e# T    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
<P>    m_wActiveThreadCount++;
0 S) t! x! {7 f    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
   
) Y- Q4 C$ [4 Q# B; k+ v! r# ~: k    // Calculate and average.
4 s* O8 y- w' R6 E) l' e    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
% E  A7 b: d' \" {& ~8 }    m_fAvgThreadCount += fdiff/32;
   
    m_csThreadCountLock.Leave();</P>
' g9 Z  W( w; q, Q9 l<P>
    ClientPacket* pClientPack = (ClientPacket*)pData;
6 W9 ^" H0 j! [    switch( pClientPack-&gt;wType )
% L3 w- s% Q0 K+ P    {
        case PACKETTYPE_CLIENT_POS:
            
# M: W4 {& w! w5 b; F9 R            // Check to see if the packet has a valid size. Including
            // the custom pack size.
* [  Y! {. `" p: e- W, b7 ^- [/ @            if( size &lt; sizeof(ClientPosPacket))
" i. Z8 G( E* m) w- y4 d                fFoundSize = FALSE;
            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
                fFoundSize = FALSE;
0 a/ o1 x$ ]% f2 X, x            else
                fFoundSize = TRUE;</P>
<P>            // If valid sized packet, handle the position.
( O" B% p+ `$ h% f            if(fFoundSize)
! s6 V0 f/ L4 I) l" j% S6 z/ E                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
            else
3 j3 r  _0 v2 S. @& U5 l2 e3 ^                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
5 g% u4 `. L! c( c/ k8 K/ p6 ~<P>            break;</P>
- Q' M$ c) e3 T+ D  O<P>        case PACKETTYPE_CLIENT_VERSION:
+ }1 L- K  `* |! L* s, R3 p            if( size == sizeof(ClientVersionPacket) )
- a* N2 g. F( J% R+ e  G9 t  B                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
$ Z# [3 M$ X. h4 \0 Q& H( b            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
. F, @3 ]# G2 O) v) T8 N- Y<P>            break;
        default:
            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
0 g* Y8 y+ i5 h" n. u) i- ]( O- S    }</P>
# B5 @2 Q3 j( J& N<P>    //If the user wants to hold the thread, Sleep for given amount of time.
$ i: W, y1 b$ R% v. M$ l, T: t    if ( m_dwServerThreadWait &gt; 0 )
    {
        Sleep( m_dwServerThreadWait );
( O$ h" q( S- K3 [* g* w) V    }
   
    // Retrieve thread data for this process.
! e4 `  Y5 Y; v9 s    m_csThreadCountLock.Enter();</P>
<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
9 Y; r5 r- f8 M/ s    m_fAvgThreadTime += fDiffTime/32;</P>
& o; `1 ~( F6 L6 E2 D: F7 ~8 _<P>    //Get the Max time in the thread.
- ?7 B2 q4 G! Z# l, R" o    if ( fDiffTime &gt; m_fMaxThreadTime )
# m. E+ H- @) e$ [; |! n1 S    {
        m_fMaxThreadTime = fDiffTime;
    }</P>
<P>    m_csThreadCountLock.Leave();</P>
. u% E1 p) V, E! f* h1 w; h* s<P>    return S_OK;
! s, E6 P) K1 x}</P>

<P>//-----------------------------------------------------------------------------
// Name:
3 L& U2 e) Z! _! b% ^7 M// Desc:
//-----------------------------------------------------------------------------
" N, U( ?$ i& @2 h0 Q3 TBOOL CMazeServer::IsValidPackSize( DWORD dwSize )
{
    BOOL fFoundSize = FALSE;
% M0 ]* S% e8 p% m$ G7 U    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
; V' w/ A6 w) N9 L   
& s3 i0 ~' ^% O: Q. H* S0 i5 n6 X" S    // Check through the array of valid pack sizes.
& S9 l6 E5 ?3 j! b    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
% i" V/ M- f" t( m# N  e+ W$ e# S        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
7 P# i" ^/ w6 o7 P; L3 r        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
( X1 ]) e: l2 I            {
                // Found valid size in the array.
                fFoundSize = TRUE;
                break;
+ x( G& u7 l* L$ c) S1 R            }
- @+ r9 ~- o# }9 |            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
, @9 T/ ]: ^0 _1 g! ^( H, B5 H        }
    }
    else
    {
' w) B, A$ Q# w, |9 j' |+ @9 k        fFoundSize = TRUE;
    }</P>
' A3 Q4 v" ^+ ]<P>    return fFoundSize;
}</P>
7 d/ k8 e2 _# Z) i; d! D9 j6 U<P>
//-----------------------------------------------------------------------------
+ b) t3 R: e% T) ~( t// Name:
// Desc:
//-----------------------------------------------------------------------------
4 ]  K/ t: l+ w' Q, Jvoid CMazeServer::OnSessionLost( DWORD dwReason )
0 t- t$ R! W3 `6 E0 P8 F$ Z% z{
4 x1 M, c) A6 O. i, c5 F5 y    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
}</P>
$ I1 g6 `( V, w1 ~; w. u0 G
<P>
1 k$ |( Z  B2 N* K//-----------------------------------------------------------------------------
2 \* B, T" F" y// Name:
// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::CreatePlayerData()
% F( ~3 ?$ \" S& }  b& U{
' A5 x  V6 Z7 ^! a5 {" Y8 I- L% B    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
1 E7 b. z2 r  G, I, \* ^5 g% o+ `    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
$ j0 ?8 A# M" J+ X& l+ P& U    {
        LockPlayerData( pPlayerData );</P>
<P>        // Got one, so remove it from the free list
2 j7 Q3 ]3 J6 h# ~4 ]1 K# R        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
% i5 T3 |* u1 q4 f. L        if( pPlayerData-&gt;pNext )
            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
+ F# b2 d6 t- O" S8 C<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
- t4 Y( T+ U+ I/ f7 V            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
        pPlayerData-&gt;pPrevious = NULL;
3 X: E( E8 L8 V- x! M1 V4 |        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
: G3 e; [8 }( N0 ~4 ^        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
4 u+ v+ e7 W: b        m_dwPlayerDataUniqueValue++;
5 \& D) p9 y2 P3 F! }0 z        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
- {& c1 A, z: o8 m<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
$ e, x; L8 x! m$ d) L4 c        pPlayerData-&gt;NetID = 0;
8 X5 C8 B$ i3 S1 Q  g3 ^        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
8 U4 N4 P# h! c3 K( P8 Y6 o( E: `( r<P>        // Insert into the "off-map" cell
        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
0 _) R( m' U; T, N        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
2 n6 ^4 P" b2 J. R        m_OffMapCell.pFirstPlayerData = pPlayerData;
        m_OffMapLock.Leave();</P>
8 n% N! u/ {+ {1 R<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
<P>        UnlockPlayerData( pPlayerData );
; M2 v2 g" ^; V1 U* l3 V3 h8 B# g    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
<P>    return pPlayerData;
# f  |) m" [. P+ A0 ~" z4 T}</P>

- e8 N4 y' b. `1 K) i<P>
//-----------------------------------------------------------------------------
// Name:
! i) w( x9 M) z0 ?3 C// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
{
    m_PlayerDataListLock.Enter();
1 g  B0 E: Q. a) t0 m    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
2 x8 j2 l5 y' I5 {, v* N! ^7 g    RemovePlayerDataFromCell( pPlayerData );</P>
3 x  R7 t0 W6 o* [" r8 N<P>    // Mark as inactive
    pPlayerData-&gt;bActive = FALSE;</P>
# X& k  ~! i6 k3 F4 V<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
, _; n, K, c, M9 t, i( h  q    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
<P>    if( m_pFirstActivePlayerData == pPlayerData )
* S# g$ e* k6 X, D        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
    pPlayerData-&gt;pPrevious = NULL;
; h, W! Z" O+ c1 G# L. b, N8 j4 H    m_pFirstFreePlayerData = pPlayerData;</P>
<P>    // Update count of players
* F" Q! H: [. Y. |& c    m_dwActivePlayerDataCount--;</P>
<P>    UnlockPlayerData( pPlayerData );
    m_PlayerDataListLock.Leave();
}</P>
" G6 a. ^& n! f) Y
<P>
. Z* M0 X7 {  Z5 p8 n//-----------------------------------------------------------------------------
1 }: ~2 O! J- a4 }6 ?; T8 I// Name:
// Desc:
# ?; r7 }0 ]. f9 Z/ S//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
, J: o0 I. R* \' u* ?4 m5 K* }    // Lock the player
    LockPlayerData( pPlayerData );</P>
, g5 m: |1 B! o- T' }. U- o<P>    // Lock the cell the player is in
    ServerCell* pCell;
    if( pPlayerData-&gt;wCellX == 0xffff )
    {
+ j/ b$ P3 j: E* y' z7 B. ]; ]0 P        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
    }
    else
9 R& u7 v3 J( i) P6 k    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
8 _9 `, G+ i6 E" O8 e; n        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
3 x. w+ k: S- P, Q0 A    }</P>
) L' L4 k; f% o" l9 |<P>    // Remove it from the cell
  u  Q' E6 M0 Z6 r) k1 h! v1 L' S    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
* u& C: r3 t, a/ ^6 H- R3 A' j2 _( A    PlayerData* pPrev = NULL;
    while ( pPt )
. O& Y4 y+ W* c# k5 Z    {
- U# B+ Q- d" K- B        if( pPt == pPlayerData )
        {
            if( pPrev )
$ e0 ^  @- t, u- u$ p                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
, P- [! M. }7 I# F3 m' {$ v        }
, d1 w/ d: R. L9 o4 d        pPrev = pPt;
6 v. M) U* X. k2 z        pPt = pPt-&gt;pNextInCell;
    }</P>
<P>    // Unlock the cell
! e6 Q7 A; G) I, k5 ?9 I    if( pPlayerData-&gt;wCellX == 0xffff )
        m_OffMapLock.Leave();
    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
<P>    // Unlock the player
    UnlockPlayerData( pPlayerData );
}</P>
/ f0 D" b) G+ E$ I* d; l7 T
<P>
) l8 m6 I2 a8 B/ C4 N, n8 a) J//-----------------------------------------------------------------------------
4 _5 v$ K' x8 y& E4 ~* O8 U" q// Name:
// Desc:
! K: _* \# X% L( }7 T0 C//-----------------------------------------------------------------------------
void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
{
3 I9 x( p$ P7 k    ServerCell* pCell = GetCell( pPlayerData );
    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
    while ( pPt )
& W8 \. p1 t! v5 G  F8 X    {
        if( pPt == pPlayerData )
' |5 A! y* {, e7 F. K: ?% X( B        {
            if( pPrev )
' V, F1 e$ Y7 u% \1 s                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
7 J+ L, m' K7 A5 d, ^( _4 `7 x            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
            pPlayerData-&gt;pNextInCell = NULL;
: O1 E: d& H8 ?. `/ f+ U/ i            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
/ Y. a: T7 j) C8 X    }
}</P>
4 Y/ Y; U; S$ m; c$ D& \9 M; |6 n
# W. ?3 m( J' {* G, D<P>
//-----------------------------------------------------------------------------
$ @5 [7 I$ u, r) F& ^// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
    ServerCell* pCell   = GetCell( pPlayerData );
) G: ]3 i3 i, L1 _+ ?. |    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
    pCell-&gt;pFirstPlayerData = pPlayerData;
4 |. U( v8 ?6 J4 Q! u$ K}</P>

<P>
8 i' |# g' |+ q& A! P//-----------------------------------------------------------------------------
// Name:
// Desc:
: V: {; V: E3 b9 b//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
9 i9 z5 l- O, B: f  k; G{
: z9 e; d7 o! V8 T    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
7 b7 a+ d6 Q0 Z# s' ^4 v1 U# P( h    if( pFromPlayer == NULL )
# P( D2 F' I3 y6 Z( |    {
        if( m_dwLogLevel &gt; 1 )
, A! t0 T: D1 ~1 ~% d# Q            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
$ y. f" u. Z! G. F        return;
    }</P>
<P>    LockPlayerData( pFromPlayer );</P>
5 B( r# _3 t0 |& y6 B: a8 n5 }<P>    if( FALSE == pFromPlayer-&gt;bAllow )
    {
. O9 z% b0 c% |$ M) F8 u7 {+ ?        if( m_dwLogLevel &gt; 0 )
5 T( S( R( @) r            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
- S9 u3 v. w% {<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
' t1 f$ E: ?. n* [7 K$ n* X7 f        UnlockPlayerData( pFromPlayer );
        return;
  q. _% |; f) c+ O% Y: l    }</P>
<P>    // Compute the cell the player should be in now
    DWORD newcellx = int(pClientPosPack-&gt;fX);
    DWORD newcelly = int(pClientPosPack-&gt;fY);
! K7 P) O; X1 F! r, Q! u    DWORD oldcellx = pFromPlayer-&gt;wCellX;
, U3 p; j: y0 r3 [    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
<P>    // Have we moved cell?
    if( newcellx != oldcellx || newcelly != oldcelly )
6 N  z: |$ G" E/ f    {
, c' l- w: k0 @+ D8 ]5 x* f        // 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
/ ?, H% f1 D, G3 j# U' c0 h8 N        UnsafeRemovePlayerDataFromCell( pFromPlayer );
4 a( w1 |9 X2 z% W        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
" x9 [! E3 G# G& ^: Q    }</P>
* E8 |! b% P& e2 l7 ]1 o2 f. \<P>    // Update player position
    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
' L& d  K5 m) H( `( r5 G    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
<P>    // Allocate space to build the reply packet, and fill in header
$ S6 V! i& U2 G: ?    DWORD dwAllocSize;
! ]/ X) b" J, [- L" `    ServerAckPacket* pSvrAckPack = NULL;</P>
<P>    // Begin by allocating a buffer sized according to
  }! P1 ?6 R2 K9 G$ y    // the current number of nearby players + 4.  This will give
    // a little room for more players to come 'near' without resize
. f. J. n8 `. Q$ |6 ~& Z3 `    // the buffer.
9 d+ m7 _3 u0 j  G* M    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
4 u3 q- e& Z! G' T! U0 ^    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
' i2 O7 D% [4 f# _. g  T- r    if( NULL == pSvrAckPack )
5 _# V; }* J/ k1 e: ^    {
# y  w, b% I7 X8 |- T$ T        // Out of mem.  Cleanup and return
        UnlockPlayerData( pFromPlayer );
        return;      
    }
! [3 C, ^+ i9 ?    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
0 y7 {) w& y' \0 E. ~1 j    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
$ n. m" s" m( p) H1 z<P>    // Compute range of cells we're going to scan for players to send
4 S5 L* ~- {7 q8 r& O( h    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
) }4 o5 h) v5 o    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
2 E/ j% w8 h0 I' L+ O" d5 q    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
/ R) z+ Q& N0 {$ c0 V  k    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
<P>    // Lock that range of cells
* m" ~7 ]" W$ q8 w& D" o: m9 p6 f    LockRange( minx, miny, maxx, maxy );</P>
4 x& B5 N& x6 |% b4 T<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++ )
    {
  v/ k; L% V  q        for( DWORD x = minx; x &lt;= maxx; x++ )
        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
4 V) @7 ^/ v* t/ |9 F( l1 k/ K            while ( pCurPlayerData )
            {
9 P+ L. R( E) l4 C                if( pCurPlayerData != pFromPlayer )
- |! p, k8 ], s7 {                {
9 Q/ E: V8 A  s& Z! @9 `( k                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
5 z3 N$ n' N! N! a: s6 {. R" @                    {
                        // Make sure pChunk is where we think it is
5 j$ Q$ {) W0 x1 w8 G  R* H                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
. c+ r* u8 f/ s7 k2 F" |8 A& Q<P>                        // There are more than just 4 new nearby players, so resize the
0 v6 E+ o' Z7 X: x                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
                        dwMaxPlayerStatePackets += 16;
                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
) x7 L9 q# E, {                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
( A2 b7 Z, [9 W% }                        if( NULL == pNewSvrAckPack )
$ o# B1 x" a! F                        {
  |0 L0 X, R" d. O. A& I                            // Out of mem.  Cleanup and return
+ ]! Z$ x/ s) Q0 ?                            free( pSvrAckPack );
, K( n$ w. I  M0 p# ?" `                            UnlockRange( minx, miny, maxx, maxy );
                            UnlockPlayerData( pFromPlayer );
                            return;      
                        }</P>
: Q7 @5 P) |! L" u% L<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
  t: v* o$ s" [2 ~5 V  n* f                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
9 H/ R, T" F' A, l/ {/ t/ ]# w                    }</P>
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
2 K& ^) W2 a1 K; a  h                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
4 S7 K7 E5 L. z) @                    pChunk++;
                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
3 |1 y: |* A0 a6 z                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
        }
( [# [8 ]0 I) r2 c- t# x7 `! ~) O$ Q  m    }</P>
<P>    // Update the dwNumNearbyPlayers for this player
% r- P9 ]- {, E' U% z0 Y+ S% \3 n    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
<P>    // Unlock range of cells
    UnlockRange( minx, miny, maxx, maxy );</P>
<P>    if( m_dwLogLevel &gt; 2 )
! k8 b: [! C1 Q5 ^    {
        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 );
# c1 g& U3 _3 e4 c        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
. x3 N2 g# X: b/ w5 Z        {
& W' R7 x1 b3 w            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;
2 N; ~- P$ a: U: Y/ l- a5 O        }
: A, Z" T' w5 v/ H    }</P>
+ E3 E) y6 L  G+ j5 ?<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
( E" F' I1 k/ s0 q, X, Z6 k<P>    // Send acknowledgement back to client, including list of nearby players
; h) V& B  M" {3 B7 ?5 j    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

    // Pack the buffer with dummy data.
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
; k3 C7 g0 R4 f        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
+ b3 Y) _$ `8 e$ \        VOID*   pTempBuffer = 0;</P>
<P>        pTempBuffer = malloc(dwBufferSize);
        if( NULL == pTempBuffer )
        {
            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
, M6 p7 o7 o8 b            free( pSvrAckPack );
2 A. Y4 A( `4 ?% E+ ?            return;
        }</P>
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
9 p; g. D) E6 X! r2 `! Y. Z( s<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
   
        free(pTempBuffer);
* a) l0 }: m* i0 \* n5 n    }   
    else
- w# K& a1 M( M5 ?, p$ b    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
    }</P>
4 |' f% e# [4 K9 t; l. Z<P>    free( pSvrAckPack );</P>
; O8 W* `! Y5 |6 w2 F/ p<P>}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
2 [3 X, o: v  Q7 M// Desc:
8 ^) U2 m! e, }, \. w//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
    // Grab playerdata for this client and lock it
; T" m, S/ l7 C; m2 J9 `- q+ [, _7 y    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
    if( pPlayerData == NULL )
        return;
: ]& F9 c% ^; z4 q8 M' L    LockPlayerData( pPlayerData );</P>
# ?0 j" c* ~& R7 g$ q" [3 c" @& I<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
<P>    if( m_bLocalLoopback )
        pPlayerData-&gt;bAllow = TRUE;
' j( k/ a4 Q# u9 g    else
        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
<P>    if( m_dwLogLevel &gt; 0 )
. G8 K+ Z" @) p; n) Z% h        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>
, K6 ^3 K+ `: N<P>    if( FALSE == pPlayerData-&gt;bAllow )
    {
; o$ l+ O$ w2 l( @/ V% S        if( m_dwLogLevel &gt; 0 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
. K  r2 W( u3 w* N! O9 C        UnlockPlayerData( pPlayerData );
* F9 w" t+ }( D$ R% f        return;
    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pPlayerData );</P>
3 j7 i$ F4 U( E+ O<P>    // Send acknowledgement to client that the client was either accepted or rejected
    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
}</P>
: ^% W6 b# u1 ^# M+ ?' M' {
<P>
//-----------------------------------------------------------------------------
& s8 t& {8 c& j2 j7 l// Name:
9 J2 ]4 N3 C3 P3 [! \4 A// Desc:
% C: u6 _# x7 r//-----------------------------------------------------------------------------
) `, A( h. p- v4 N, v: k; B5 {BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
{
    switch( dwClientVersion )
    {
        case 107: // only v107 is supported
: T" Y' T; e5 K5 k9 o5 ^            return TRUE;
$ A. b- |( M/ `: F% g+ ^        default:
* F, q6 s5 w1 @& w  x) p            return FALSE;
2 g' x1 J+ Y* [. L. D0 \    }
7 l, S' C! q' l}</P>
" S$ u! y8 f8 O$ j
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
: n# n5 y0 Y: f' \7 ~  Mvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
{
. d# L9 M7 A- y2 _    if( m_dwLogLevel &gt; 1 )
- g* D0 W# l4 E) J        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
9 a2 r: B8 _( e3 _$ z}</P>

<P>
//-----------------------------------------------------------------------------
3 s1 L1 H; r9 x// Name:
// Desc:
//-----------------------------------------------------------------------------
* O7 Q. `4 g& ~' }DWORD   CMazeServer::IDHash( DWORD id )
1 |2 T0 n# z' P' m2 Y! I' j" Y{
0 N0 y9 b' X- |    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
+ ~! G. F. m! h7 k    return hash;
" w1 x8 c) ^# v( q}</P>

4 H8 O* g7 F/ ?4 d<P>
2 j* X. e( L6 \" _) K- W# e//-----------------------------------------------------------------------------
  M3 u; F& Z( H" e2 b# L' G// Name:
// Desc:
: H; M' n& b0 r% m//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
% z! K9 N( l2 o' ?/ |{
+ ]7 w( D+ V. b    // 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 x" W! V5 F5 b+ C; F<P>    // Loop though players in bucket until we find the right one
# @8 Y/ w' a7 H# u    PlayerData* pPt = m_pstIDHashBucket[bucket];
    PlayerData* pPrev = NULL;
    while( pPt )
; M7 {0 S/ [5 o! y0 q' V: z    {
        if( pPt == pPlayerData )
# i* W1 F% g, U8 e            break;
) W0 W) J6 g8 U$ T5 T5 E$ c        pPrev = pPt;
$ T& `( u8 U1 N1 C) _        pPt = pPt-&gt;pNextInIDHashBucket;
    }</P>
/ @" ], B6 z/ e, Q; Z7 U3 W<P>    if( pPt )
    {
4 T4 n) T2 u) X3 H/ X        if( pPrev )
            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
1 Q7 A" M' B# I6 \5 b+ V+ n        else
+ P1 {: D  T3 M5 E7 Q; u( ^+ M            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
' M7 W+ T! _" T4 L1 t: J) _2 G        pPt-&gt;pNextInIDHashBucket = NULL;
; a4 K, o) N+ z. _' G4 D3 e. c    }</P>
<P>    // Unlock the hash bucket
9 ]: N7 O* n" u* M* O0 ?9 L4 @5 E$ e    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
. p2 k: U; M/ M: \0 W8 L( P}</P>

8 D$ p. U7 O+ ]<P>
//-----------------------------------------------------------------------------
5 e, j2 U# m. {* Q' s" W, ?// Name:
8 h4 ^* j+ L1 k$ E2 J// Desc:
% p/ f0 Q; T- S//-----------------------------------------------------------------------------
void CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
{
" v, W* \( A1 _    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
) c9 y+ d8 \( k% S! A( R+ i' k    // otherwise there will be a circular reference
    PlayerData* pSearch = GetPlayerDataForID( id );
    if( pSearch != NULL )
        return;</P>
2 x+ l) i3 P2 P% u6 L( R7 L& w3 V<P>    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
4 Z* i1 L+ b7 i7 |, }& b; i- X1 b<P>    // Lock that hash bucket
6 G# Q8 G1 e  u4 [    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
; G+ B) x6 \& Q. ^- z: p<P>    // Add player onto hash bucket chain
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
    m_pstIDHashBucket[bucket] = pPlayerData;</P>
# V/ c: G( P# g! f/ N8 c+ B4 O<P>    // Store net id in player
    pPlayerData-&gt;NetID = id;</P>
5 y  X4 Y* j5 x1 I9 a6 ~<P>    // Unlock the hash bucket
/ z0 L0 J4 U' m# c, I4 l! |    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>
" Z0 a6 X& W) S( M& t7 e0 D  p
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
. G5 I# o# _" p/ N! q1 x  z{
5 P2 f1 C; a. X' z; v7 u# h4 b. O    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
/ g0 Q" K, |) j5 F( s+ D    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
( O$ G8 O8 l& X$ z    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
4 Q: w& H* W; Z<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
    while ( pPlayerData )
' @0 m: P* |1 h    {
- r4 ?- X1 d9 A, S7 q+ J0 F        if( pPlayerData-&gt;NetID == id )
            break;
3 u* a9 N# ~4 e/ n, O        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
4 ?- L, n  M) s# B$ T. ~    }</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
<P>    // Return the player we found (will be NULL if we couldn't find it)
7 J9 e7 u$ N, y    return pPlayerData;
}</P>
7 Q2 w: h" g: ~! b
* L' t/ P: R' ^( B<P>
//-----------------------------------------------------------------------------
4 y, D& A1 W2 [6 s// Name:
. x3 ]6 Z, h: W0 ]( C- i// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
: w( A: L- @+ J# _0 ^, r{
    if( m_pNet )
    {
        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
        PlayerData* pOldestPlayerData = NULL;
0 d0 e* [+ g0 I8 c4 Z# \        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
4 J( h7 w/ F9 d7 x+ p3 S2 u" b<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
4 ]. m3 |7 O5 v+ h1 S        while ( pPlayerData )
        {
            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
            {
                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
                pOldestPlayerData = pPlayerData;
            }</P>
7 H- S( \3 e' o% f  X<P>            pPlayerData = pPlayerData-&gt;pNext;
( e8 E0 {3 G$ l. ?/ @* f        }</P>
9 Y( @4 f: {; I7 G<P>        // Display the player with the oldest CI field, and update its CI field.
        if( pOldestPlayerData )
2 Z" `/ m  M" A! M) u0 O) M        {
! I' i2 \# `; D            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
& x0 y( K! y5 Z            pOldestPlayerData-&gt;fLastCITime = fCurTime;
$ C; k* v9 g4 J- v# R/ ?        }
8 u# O$ s; a. o9 i  ~        else
8 ?/ E1 |- I+ g/ v& \0 V: v        {
            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
- i1 w" G, z9 P        }</P>
<P>        m_PlayerDataListLock.Leave();
  Q! c: U/ w" ^- ~3 m, a    }
) F& B) t, t% m) I& e}</P>

3 e9 H! ^. N: D4 z<P>
" n! S& f& P7 L6 i//-----------------------------------------------------------------------------
! ^/ [0 }/ p5 q// Name:
// Desc:
6 s8 ?/ q& ?# n) t; l//-----------------------------------------------------------------------------
void CMazeServer:rintStats()
{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
/ y" A; _8 P: N! G7 T; W                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
3 H, m* `: R! b( q! a' K/ l    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
' g( P- Z! _; {# v) E! Q                                    m_fAvgThreadTime, m_fMaxThreadTime );
    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
" N1 t) Q- v/ g: p    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
" X/ o: j5 L# Q, g  r$ E9 H! ?}</P>

, d- C$ a0 W' u0 d, N<P>
2 d% B% A+ V: |8 D//-----------------------------------------------------------------------------
// Name:
3 H3 t# n/ e6 F4 j* J  m. W// Desc:
9 n; f2 Z8 \5 {% E//-----------------------------------------------------------------------------
void CMazeServer:isplayConnectionInfo( DWORD dwID )
  U. e3 j. u* f{
8 e; O! X+ }0 U3 i% \    TCHAR strInfo[5000];
  @' U1 Z& i# [) A; z( v9 d    TCHAR* strEndOfLine;
6 B# W( D1 E2 A    TCHAR* strStartOfLine;</P>
4 K* q" V% ^8 e# h4 l<P>    // Query the IOutboudNet for info about the connection to this user
    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
, e9 o1 O$ |: t2 s3 d) `6 {<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>
<P>    // Display each line seperately
    strStartOfLine = strInfo;
! d; \  R! M1 T/ |$ J    while( TRUE )
    {
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
        if( strEndOfLine == NULL )
            break;</P>
" C: u2 |- _, }8 [<P>        *strEndOfLine = 0;
        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
    }
5 E% Q1 @; @% m! N2 n}</P>
3 M- A% L- k/ r
" q1 M9 n) S& E3 x  w" {3 C- m<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::SendPacket( DWORD to, void* pData,
6 K. Q* z* H, J- u& X/ p% P                                 DWORD size, BOOL reliable, DWORD dwTimeout )
{
4 }: ^  Z" b7 }9 s+ v) e6 i    // Chance of forcing any packet to be delivered reliably
) W: p2 h% f5 ?    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
7 |# i! C- J5 Y* U, r" F<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
# `- P! }; ^2 K8 t8 B! _* o) h}</P>
$ @% S, d' m2 P, k( ^5 d# N3 U: [7 K
) @9 U3 i. s( i6 e, w<P>
//-----------------------------------------------------------------------------
3 d& |+ f1 Z3 M$ E+ O// Name:
// Desc:
3 q% ]( y( `! M3 A//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
    // If we're up and running, then send this new information to all clients
; _5 V5 E" ]9 o    if( m_pNet )
    {
        //Use the AllPlayers ID
; ]3 T- ?( E2 ?7 E: w        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
$ z; i- z6 U; D1 Q8 U9 i    }
}</P>

/ K' p! L5 v/ H<P>
//-----------------------------------------------------------------------------
" q8 I  U; x2 P. p. o; v. K// Name:
// Desc:
6 I) z+ O$ R" D) ~//-----------------------------------------------------------------------------
, F4 A$ H  Q* b9 V: p" qvoid CMazeServer::SetClientReliableRate( DWORD percent )
$ o! y9 \) M/ a3 Y. X# I; ]" N5 K{
, b+ x: n( l9 x% V. t' ~1 F    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.ubReliableRate = BYTE(percent);
( S7 e3 V; F+ G# n  S( m    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
) g" t+ `% c2 h) n<P>    SendConfigPacketToAll( &amp;packet );
2 p: N3 k4 [) Z8 K2 u4 U}</P>
0 `/ W5 O/ J: q+ y5 Y& @
& v1 L6 y; v- h<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
1 K* W! W) G7 a- e0 C! j# Avoid CMazeServer::SetClientUpdateRate( DWORD rate )
{
: p2 h9 b9 S! Y- ^, W, u+ p    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
) j- z; c. B9 u4 i' A8 y    m_ClientNetConfig.wUpdateRate = WORD(rate);
9 b6 o" T& ^# |9 M4 ?* B( t    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
//-----------------------------------------------------------------------------
' z0 w1 g# a: r* ^: [// Name:
// Desc:
* b* ]. f8 w1 {# C9 i//-----------------------------------------------------------------------------
void CMazeServer::SetClientTimeout( DWORD timeout )
! ?, G* Q( ^8 ^7 N! }* u: X# o{
- l7 W3 m) l$ v0 E' \: h3 p3 X" z' C    // Update client config, and build packet containing that data
( z1 f8 J+ e& L3 Y# k    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
1 m: R, H" J8 N0 A: X# U% b    m_ClientNetConfigLock.Leave();</P>
; V# ~0 ?* d7 K5 i- q, q4 ]: m+ k<P>    SendConfigPacketToAll( &amp;packet );
% }5 n" _* P. L  U0 ~8 W  s' ~}</P>

' d- B/ A- T% y<P>
//-----------------------------------------------------------------------------
5 I# c) ~9 R9 c7 P8 `# `! b// Name:
' r5 _7 \) d% u( r! t// Desc:
7 @6 g2 w* D+ j. D//-----------------------------------------------------------------------------
  F2 V- _7 k5 g: ~& R4 [void CMazeServer::SetClientPackSize( DWORD size )
{
; i% ~9 K" X! F& [1 K- b    // Update client config, and build packet containing that data
& q# `( q/ v7 M    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
7 b- j0 H) ?& _& q1 j    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubClientPackIndex = 0;</P>
<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
! V) |+ ]3 @" @* i& q, V" T    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
  h# \$ \" l3 ?# \$ D}</P>
9 n; E; V: n5 Y1 s( e
8 I5 h6 @: \$ [' A6 r- v3 b<P>
/ Q* U. }7 s  L* `//-----------------------------------------------------------------------------
// Name:
1 C8 K- y6 p. v1 }% ?8 Y// Desc:
! i4 z; X3 J! V0 N" b% H, p4 t//-----------------------------------------------------------------------------
void CMazeServer::SetServerPackSize( DWORD size )
7 t/ I. E4 T* l{
' D$ ?+ [0 o% ^/ G    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
7 i7 X9 j" a" a& D# q3 G, }   
    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
- p" ?* {4 u" e$ N0 m& L4 q" @' |( o        m_ClientNetConfig.ubServerPackIndex = 0;</P>
<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
  Z% _; I$ m9 a9 ]  `& z<P>    SendConfigPacketToAll( &amp;packet );
}</P>
4 _0 U$ i( @; }( N<P>
- X% j5 ^  U9 D2 b# C  X8 p//-----------------------------------------------------------------------------
" d' e6 Z; K  U" R: ]7 p( V// Name:
// Desc:
8 e, D  s2 R4 I" L' [" I//-----------------------------------------------------------------------------
void CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
{
    // Update client config, and build packet containing that data
' h1 K" d3 e' e7 u. ]  S9 G& ]    m_ClientNetConfigLock.Enter();
+ J- o# ^. g! P& u( V   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
! y9 y8 m$ w* ]- M9 D) q    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>