[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
: a' P' M5 g$ t( t  I<>// File: mazeserver.cpp
2 n0 R" p6 q) \9 I* a1 j" @//
// Desc: see main.cpp
8 F7 I( B* `, k& c: R" t; \, a//
7 S8 w1 k. @" A6 X' s1 c// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
. b. I  Y  a6 F8 i" p#define STRICT
, c8 |5 ~! c! e5 z#define D3D_OVERLOADS
#include &lt;windows.h&gt;
& x% X2 u- j5 j; R$ V. L; S#include &lt;d3dx.h&gt;
7 b, Y7 N# d3 G, \' \#include &lt;stdio.h&gt;
! N2 g) D7 u( d/ x& u8 }% }7 W: j#include &lt;math.h&gt;
#include &lt;mmsystem.h&gt;
#include &lt;dplay8.h&gt;
) i- u8 q+ b+ h) S2 C#include &lt;dpaddr.h&gt;
#include &lt;dxerr8.h&gt;
1 [; n$ d7 l5 p1 i" l4 H9 j( b3 @#include "DXUtil.h"
#include "MazeServer.h"
#include "ackets.h"
7 [% L% h, F" N( y#include "Maze.h"
) r' |' ]9 e" H# `& n* L% P#include &lt;malloc.h&gt;
; @- X8 Y4 q+ }3 @9 H: Y4 X$ o$ X, |#include &lt;tchar.h&gt;</P>
! G/ J: d( m6 m
0 F1 _. m# n' ~+ z<>//-----------------------------------------------------------------------------
2 l$ v( C3 u" N. ~( S// Name:
) U" Q- N! I+ ]* A// Desc:
  f. q% y  O7 [//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
{
3 w7 w: W, k. ^6 D3 a# }    m_dwPlayerCount         = 0;
   
    m_wActiveThreadCount   = 0;
    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
' g' G+ |: l$ j  O    m_fMaxThreadTime       = 0;</P>
<>    m_dwServerReliableRate  = 15;
+ {0 n2 _8 c0 D* M6 Z( S( V# V    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
- w0 e. |- l/ g2 j) e    m_pMaze                 = NULL;</P>
9 p6 ?! H) u( A<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
    m_ClientNetConfig.wTimeout       = 150;</P>
<>    m_ClientNetConfig.dwThreadWait = 0;</P>
<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
5 ]4 N# e: U4 {* O$ @        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
4 y4 X7 p2 y' ?6 _3 w}</P>
: D  L# T. Q$ |- _2 K
& B/ R( s& d1 @& \<>
* z2 e- H1 e/ M0 c0 h% y; w3 Y//-----------------------------------------------------------------------------
! \/ n3 g8 f3 \8 U// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
8 M' g# n# W3 _0 z- j' e    m_bLocalLoopback = bLocalLoopback;
& F; A  K& M/ E! G    m_pMaze = pMaze;
1 \# F, d; Z" h$ {! w9 K    if( m_pMaze == NULL )
        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
+ C+ U5 }0 p# n  F" |9 M9 m3 o<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
2 |) j, j" e0 S. {) ^    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
3 K0 G. _, ]' l7 f" z' _+ y<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
% C$ v5 _9 Z( i) h$ f* M: i% I    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 )
% x$ y, b' H( z% M        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>
& Z( P, Y- P& D& q4 h) Q<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
    m_dwMazeXShift = 0;
    while ( (scale &gt;&gt;= 1) )
/ T, L3 n/ @' F0 c        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
$ D: ~! ]6 W3 J- o1 B: N0 O  Q        m_dwMazeYShift++;</P>
3 f2 s0 B* g, w<>    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>
<>    // Initialise the player list
    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
    m_pFirstActivePlayerData = NULL;
    m_pFirstFreePlayerData = m_PlayerDatas;
! L0 ]! Q/ v' T0 O/ `$ i: j    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
$ {7 l  S& j2 K% W# t    {
        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
    }</P>
7 Y$ I" a- m: I6 W<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
    m_dwActivePlayerDataCount = 0;
3 }) _/ Y& S" U" s  o* K) t/ q    m_dwPlayerDataUniqueValue = 0;</P>
<>    // Initialise the cells
    ZeroMemory( m_Cells, sizeof(m_Cells) );
/ T3 F& _8 z5 Z/ a) J+ `8 D. u, ]6 ~    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
<>    return S_OK;
}</P>
( e8 l5 l4 q- a. J
) w0 O- J% k0 T, `9 ?* X0 v( J( T<>
. i7 p6 s; {% y$ h- h0 {//-----------------------------------------------------------------------------
0 W" E8 H. W4 ~$ d: {// Name:
( D1 y% r2 {! N// Desc:
! Y. J9 k& }% l. H/ C- I//-----------------------------------------------------------------------------
, g) n* c7 ~* T" J! d+ o: ^void CMazeServer::Shutdown()
{
+ z$ g, x  X# S7 I" ]+ V}</P>

<>
//-----------------------------------------------------------------------------
// Name:
) e0 p1 n0 z' H2 @// Desc:
- P  n' K. C/ ?4 P$ A. l9 S//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
! L2 {1 J: s, }( g{
" w6 J+ {# A" t4 t- N( S& q    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>
7 c9 ^/ B: l8 q7 v8 C
<>
  E: c/ O6 }0 z& F* t3 Z0 N/ p4 c1 s4 x//-----------------------------------------------------------------------------
// Name:
// Desc:
4 f5 c, J3 s: O7 m- E* B2 R//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
: p7 k5 i  a: n- ]    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
6 q4 p5 Z7 u/ U$ @5 M                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
9 J* s) \# R$ P}</P>
/ z9 |* Z% q( g  Z: y2 R& C- {
<>
8 _) i0 E. S" |' `//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
{
    if( x == 0xffff )
        m_OffMapLock.Enter();
8 o) g% x, F5 {2 a" D, O    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>

! d, v8 u" x2 H" C4 X<>
) ]' q: ^. g5 E# N; A( t//-----------------------------------------------------------------------------
// Name:
, T1 d: p8 p- _# ]// Desc:
6 ^9 F2 o* n8 H( I9 R//-----------------------------------------------------------------------------
& ^$ W, I3 J/ R3 wvoid CMazeServer::UnlockCell( DWORD x, DWORD y )
5 ~9 X0 s* `8 X: ^5 [{
    if( x == 0xffff )
        m_OffMapLock.Leave();
$ \" a$ v% s/ F+ J# H# V8 b" y6 T4 l    else
$ D7 e% w: t4 J) c! H        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
, d* c- W& ~; v1 ]+ S' A
<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
' n/ p. }) R: j" b0 i, s9 b4 d6 X( o//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
! c! c: A' ^% O7 w8 ~6 c* l7 n: O# D: [5 R{
+ C& Y2 e1 e) ^. W+ `( Q8 e    if( x1 == x2 &amp;&amp; y1 == y2 )
! F2 K; Q" e8 N1 c    {
6 n, X0 ^6 r' x: r9 O& O# D2 s; O        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
        else
            m_OffMapLock.Enter();</P>
<>        return;
    }</P>
; S! a! \! E9 U/ Z<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
* }" S# U& J" @+ C" n    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<>    if( x1 == 0xffff )
    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x2shift,y2shift);
    }
    else if( x2 == 0xffff )
    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
    }
    else
+ J! p9 g8 V" J3 o8 b1 _    {
        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
! x) @1 J: Q2 X7 D}</P>

<>
//-----------------------------------------------------------------------------
) l0 k4 @( z) l7 P0 J8 H$ W/ ?# T// Name:
  W- {) F1 M% B, |# y6 o' f// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
/ h: G& R, K( b; t# q{
    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            UnlockCell( x1, y1 );
9 V0 e6 z, O4 {# h! ~        else
            m_OffMapLock.Leave();</P>
# n! \; c* M- [. K9 i<>        return;
. W, J' n. O: u8 U5 ?) C    }</P>
<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<P>    if( x1 == 0xffff )
    {
2 ~6 C4 H6 P. B; t        m_LockGrid.UnlockCell(x2shift,y2shift);
        m_OffMapLock.Leave();
    }
( r' y5 b! ?& _- w' E6 b9 I% q# b: e    else if( x2 == 0xffff )
    {
        m_LockGrid.UnlockCell(x1shift,y1shift);
' D: X9 C$ a! o6 C, M        m_OffMapLock.Leave();
: U$ y3 [5 k: r    }
    else
    {
        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
, ^# f/ E/ v! P, x- h}</P>
1 n+ @" O! v7 U: M2 c. r
<P>
1 q# Y2 {  r: B) H8 W+ j6 D//-----------------------------------------------------------------------------
// Name:
8 S, e+ d! S% K& w+ b// Desc:
//-----------------------------------------------------------------------------
, U% C" U  t5 Cvoid CMazeServer::OnAddConnection( DWORD id )
4 V$ z( a7 W, U  b: W* _{
  T) w9 y1 E5 x( X    m_AddRemoveLock.Enter();</P>
0 {# x, J& O: H& w9 S9 Z2 O: h  S0 C<P>    // Increment our count of players
, l* m0 o* H" f    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
' W9 F+ d/ U, e& d1 Z+ S        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
$ d" m& S4 r8 K  m1 }" w7 _    }</P>
3 Q2 G6 G, G$ t1 S  X7 F# |<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
' H9 T5 A+ M) y; n, B$ b8 _<P>    // Create a player for this client
    PlayerData* pPlayerData = CreatePlayerData();
( h4 X; b+ k) j; ]$ B5 q8 Z    if( pPlayerData == NULL )
    {
7 ?( M+ F0 z0 ^7 i        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
) n3 h4 b2 ~8 B" J8 }        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
' b- \2 E, c* e, ?8 C3 O; E        m_AddRemoveLock.Leave();
        return;
    }</P>
1 C6 R' c5 b+ V) y<P>    // Store that pointer as local player data
    SetPlayerDataForID( id, pPlayerData );</P>
<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
2 }( z2 k/ k: ^  [# W6 v    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    // Send it
7 |0 A' T6 V3 \/ O% P: C' m$ s    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
$ u$ q: e/ `5 ]( H, ^, l<P>    m_AddRemoveLock.Leave();
}</P>

<P>
0 O/ _# ~5 |3 }/ ]9 X# ]//-----------------------------------------------------------------------------
// Name:
3 L7 W$ c# s7 \. L! \4 n// Desc:
- f. R5 W) B# G2 j! ?//-----------------------------------------------------------------------------
void CMazeServer::OnRemoveConnection( DWORD id )
% W: x& `/ f' o5 w7 {# r. q{
    m_AddRemoveLock.Enter();</P>
0 W" s+ r' d3 B9 r2 k2 Y<P>    // Decrement count of players
    m_dwPlayerCount--;</P>
8 |4 |- w+ A# F7 O7 A, _+ z" v$ w<P>    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
- W! P5 x: A' Y' b        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
; M# n6 ^! E* _4 g" O    }</P>
<P>    // Find playerdata for this client
: n. E& A/ O/ l7 j" H; s. H    PlayerData* pPlayerData = GetPlayerDataForID( id );
    if( pPlayerData != NULL )
    {
        // Destroy it
        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
2 D5 {2 c$ {; S& W5 t6 O    }</P>
/ w" \5 M7 c9 F) S+ n# B$ P( k<P>    m_AddRemoveLock.Leave();
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
3 j  P5 a2 x) f) V; tHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
{
# E7 {% [! v1 @9 [' X9 t1 X$ [4 L    BOOL fFoundSize = FALSE;</P>
+ Q* W3 U4 `5 d4 o1 n<P>    // Increment the number of thread we have in this process.
$ g  N( _9 H( ~  k: F2 {    m_csThreadCountLock.Enter();</P>
<P>    //Get the start time of when we entered the message handler.
( r6 Y0 ~$ X# f! h* M    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
6 m) ?6 [5 J! v$ s' i<P>    m_wActiveThreadCount++;
    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
6 C& g$ B/ S" p. p/ U   
    // Calculate and average.
    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
    m_fAvgThreadCount += fdiff/32;
- Q% E5 A4 u2 X9 n   
    m_csThreadCountLock.Leave();</P>
<P>
    ClientPacket* pClientPack = (ClientPacket*)pData;
    switch( pClientPack-&gt;wType )
. g  L3 K8 {+ Q# j    {
5 c5 N) `$ r& @) A2 ~6 }        case PACKETTYPE_CLIENT_POS:
8 w4 J% u8 j) S: k8 H0 c            
            // Check to see if the packet has a valid size. Including
            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
                fFoundSize = FALSE;
4 D1 w6 _* C" H: b9 K! m            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
9 ]; v' w6 u9 R% ?8 Y" c9 R                fFoundSize = FALSE;
            else
& A4 Z0 c* ^$ W+ {# i+ |3 ~! o1 T. b                fFoundSize = TRUE;</P>
<P>            // If valid sized packet, handle the position.
4 y; Q: G0 k" {            if(fFoundSize)
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
            else
9 X$ d) ^% ~5 O* Z                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
8 n4 E/ o5 S5 |7 o9 E            if( size == sizeof(ClientVersionPacket) )
                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
* @. y7 l3 N5 a' E: H4 U+ o3 f5 ~            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
2 S/ P) M  }# \<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
) K/ b6 v$ `! h  C7 J5 R<P>            break;
        default:
5 a; {, [# ]/ E0 D            HandleUnknownPacket( dwFrom, pClientPack, size );
1 e( ~+ Y5 K* S5 w) a+ }. D) i7 \            break;
    }</P>
# P+ s4 ?- R  c$ [<P>    //If the user wants to hold the thread, Sleep for given amount of time.
. F. e+ G0 ]/ v' j    if ( m_dwServerThreadWait &gt; 0 )
' N4 T5 q7 w8 a4 a* O5 }3 D    {
        Sleep( m_dwServerThreadWait );
! W' Z( O" P" u    }
   
% h0 |) |0 y- C$ Z9 T0 k    // Retrieve thread data for this process.
    m_csThreadCountLock.Enter();</P>
& X. D, e" H* X$ L5 G+ g4 y3 @2 }, b<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
: p) ?" p4 }: W! p    m_fAvgThreadTime += fDiffTime/32;</P>
<P>    //Get the Max time in the thread.
    if ( fDiffTime &gt; m_fMaxThreadTime )
    {
% q0 T3 Q% `' k5 e        m_fMaxThreadTime = fDiffTime;
    }</P>
6 V- B4 }  l3 g: u<P>    m_csThreadCountLock.Leave();</P>
8 V9 ]5 _8 t# H7 y<P>    return S_OK;
4 o" C- X$ P7 K, z}</P>

<P>//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
4 c. m% M1 W5 \+ T1 C* P3 e5 Z{
    BOOL fFoundSize = FALSE;
    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
   
    // Check through the array of valid pack sizes.
7 d. p3 B$ J; Q, f/ E9 @9 d    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
# @% ^& B- X9 h* v; J/ m) y8 v, M4 w        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
        {
' J" J7 ]2 D7 P% M            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
6 G7 L. P2 L$ [# k% H            {
                // Found valid size in the array.
0 n$ y" H9 S- s/ X  E+ W                fFoundSize = TRUE;
                break;
& i  y8 q" P: B2 s. H$ N+ O            }
. q: W+ P9 e& g0 L) v            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
        }
    }
) c( L0 o3 {4 x3 j5 C    else
  P, b" |6 K- q4 d    {
        fFoundSize = TRUE;
    }</P>
<P>    return fFoundSize;
}</P>
$ T) W9 T  j. f, O  T0 N. S/ D<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
' @' Q* x6 r7 J0 Y7 G//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
{
    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
# Y3 r9 L3 T9 c9 X$ Z* x! m' O}</P>
- c5 L: [8 p/ V2 {, ~: ]% D
<P>
2 a0 H5 K$ s3 }& s; ]/ w; ~% [//-----------------------------------------------------------------------------
// Name:
9 x8 w! Z2 U2 D6 ^( E8 m7 l// Desc:
& p# R5 c& g; P6 H1 ?0 ]# F//-----------------------------------------------------------------------------
PlayerData* CMazeServer::CreatePlayerData()
{
9 q1 i/ h1 r" X) l! `8 V+ S+ _1 Z% m    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
& x1 T- T( a! t9 w; ~) c1 U    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
. Y: P* O6 A8 k: b& v    {
3 o* r) J* e2 Q& O4 L  c9 _) [" e6 f        LockPlayerData( pPlayerData );</P>
& n- }* e+ n& G% @<P>        // Got one, so remove it from the free list
        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
% r! \: |7 }8 q# U$ c1 C8 {# e        if( pPlayerData-&gt;pNext )
! x! R5 ?& G5 n% ^7 a9 e            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
) V$ Q0 I3 n1 n% I$ z$ `( ]# i        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
3 M1 Y- B5 E/ X9 r7 @<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
5 O5 \. g6 t: \* g            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
) C% [$ e! l) t+ K5 |5 y        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
7 _% }% h& x6 H* \6 p        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
' ?% L$ P1 _) {* [. w, |        m_dwPlayerDataUniqueValue++;
5 y+ c/ s: ]- `; K. ]        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
        pPlayerData-&gt;NetID = 0;
        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
<P>        // Insert into the "off-map" cell
" D' S1 f8 Y/ O4 P- D5 `( J        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
* Z$ U  ~' u8 [) v, n        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
        m_OffMapCell.pFirstPlayerData = pPlayerData;
4 k( o, @: p$ ]* O        m_OffMapLock.Leave();</P>
1 `" U; W- d8 [<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
) R5 _2 I+ \( I! B2 |<P>        UnlockPlayerData( pPlayerData );
+ M& _8 e, b0 D0 e    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
<P>    return pPlayerData;
" D7 Y, `$ L: O3 S}</P>

( o7 B4 d4 }; y: _8 t$ C" O<P>
, Q( B3 s9 z7 r0 I# H9 v//-----------------------------------------------------------------------------
6 d& F4 A% r  c& i- K- J! b' T3 k; r// Name:
4 K+ v  {/ I, Z0 u// Desc:
8 h" `  d5 Z: H& K+ \2 ^7 N; Z# s//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
5 j# L+ D8 ?5 [: ~{
    m_PlayerDataListLock.Enter();
    LockPlayerData( pPlayerData );</P>
9 u: D6 S) J9 ]) ~5 P5 v<P>    // Remove the player from its cell
" ?  h3 Z5 {: S$ R    RemovePlayerDataFromCell( pPlayerData );</P>
<P>    // Mark as inactive
    pPlayerData-&gt;bActive = FALSE;</P>
8 T$ G% Z' G. `- y) X<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
; v' ^2 O5 [5 K, x0 x# v        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
; X2 [" m8 x, m8 h    if( pPlayerData-&gt;pNext )
" s; q1 H0 n% O, x+ q        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
<P>    if( m_pFirstActivePlayerData == pPlayerData )
% {3 ^4 g1 O$ R4 F        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
7 _: z: H$ D+ i/ W: k( O<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
; y  |1 B! w; J9 t' A        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
    pPlayerData-&gt;pPrevious = NULL;
    m_pFirstFreePlayerData = pPlayerData;</P>
. T6 F6 r2 \, V<P>    // Update count of players
6 A: O& L; X6 P: [, y/ R3 [    m_dwActivePlayerDataCount--;</P>
8 P+ Z& Z$ g- v9 d( L' @<P>    UnlockPlayerData( pPlayerData );
    m_PlayerDataListLock.Leave();
}</P>

<P>
: s1 s1 d, J$ V' M: R//-----------------------------------------------------------------------------
// Name:
: X: Y9 @1 \* A; l% q, p! r! S* {: R// Desc:
3 S7 n$ i+ V0 k' g6 b  ?5 f//-----------------------------------------------------------------------------
: T& z( M9 G  L: s  ivoid CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
0 J( L9 `+ ^& `7 A! N1 H9 }% A1 n    // Lock the player
    LockPlayerData( pPlayerData );</P>
<P>    // Lock the cell the player is in
    ServerCell* pCell;
0 k9 \2 G, K* d' b, v    if( pPlayerData-&gt;wCellX == 0xffff )
    {
# b, k0 s% R  |' k, B) i        m_OffMapLock.Enter();
1 f3 N/ U& G( q7 t# p        pCell = &amp;m_OffMapCell;
    }
    else
    {
& N3 R! ?( N/ m8 C' o' g        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
3 z) T3 ~  h) ~9 q/ k- c    }</P>
<P>    // Remove it from the cell
    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
, A% t! E5 Y) S) c" V    PlayerData* pPrev = NULL;
1 l  [# n( s. n* w/ X" n    while ( pPt )
3 L9 A* T3 S6 r0 `2 d3 m! F    {
        if( pPt == pPlayerData )
        {
  E! \/ S: i- R8 d0 m1 Q            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
. b4 J4 [+ n) M# @7 }) j                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
% E' {3 X/ A; d9 |2 M<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
5 w3 e# _. D4 W4 W" w: {6 Y; p        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
! W% z. ~! V/ v/ ~; B' y. ^    }</P>
<P>    // Unlock the cell
    if( pPlayerData-&gt;wCellX == 0xffff )
8 S# T6 k2 O: ?" E) N8 f+ f        m_OffMapLock.Leave();
3 {/ K$ e0 O' P. L3 Y+ J    else
( l6 W9 g4 `. X3 U8 w5 C. G        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
. F9 ^) T( [( l! Q<P>    // Unlock the player
; B" ^; [6 O' I: m( T% }1 ~    UnlockPlayerData( pPlayerData );
}</P>

8 q3 t6 _+ `8 z! u% [<P>
7 O$ c0 R, ^: V9 L9 v) _//-----------------------------------------------------------------------------
$ a( c( w' K4 H' M& D. C) B// Name:
// Desc:
//-----------------------------------------------------------------------------
2 c  G/ G- X% b- ~! Dvoid CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
* r5 Q$ R! }* y/ H3 O1 v" r7 s{
2 Z0 g; B  F! S% W    ServerCell* pCell = GetCell( pPlayerData );
    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
0 N4 W( F+ Z/ ]. x8 X4 c9 ]& }    PlayerData* pPrev = NULL;
    while ( pPt )
    {
        if( pPt == pPlayerData )
        {
# A! c: o- O4 A+ b: x            if( pPrev )
1 e8 M0 b$ o* q/ y) j& {: V8 F                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
1 j  K3 g8 u* X" w/ d4 y$ d4 ^3 Y            else
# Q& a3 k6 \5 X2 ]0 V6 d  C" N                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
  e( g- F0 ~5 o        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }
}</P>
% ^, g( S5 u! Y4 Q% i& g3 k# c* ^
8 v8 r5 R; ~7 G. M1 H<P>
//-----------------------------------------------------------------------------
4 U! j% z' j& n0 G+ z// Name:
  C/ b: f; P- @& C// Desc:
//-----------------------------------------------------------------------------
3 c8 V4 J7 n. [  {  fvoid CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
" p$ P( g1 k( M* g% u{
$ M8 V$ c, w: L6 e- H    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
9 D3 v0 ~* o2 \; B5 J    pCell-&gt;pFirstPlayerData = pPlayerData;
+ {# ]/ F& ]" j4 h}</P>
" a2 h6 \$ \* S+ t" w6 K* x6 w1 @5 V
<P>
( O  \$ E9 N8 O5 p$ R. h//-----------------------------------------------------------------------------
// Name:
0 B2 R$ g) d% D// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
8 f# A$ h( ?& n4 l( Q/ h0 a; P    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
4 N4 N* s" U+ ^# j    {
% g3 [# ~1 D# E3 y$ U# r3 g        if( m_dwLogLevel &gt; 1 )
# a* k4 q! z: e0 u3 j            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
2 Y+ U, b6 n( e+ ]        return;
    }</P>
% |7 m5 V: x/ K# }7 t<P>    LockPlayerData( pFromPlayer );</P>
<P>    if( FALSE == pFromPlayer-&gt;bAllow )
) j4 W, Q: B, |    {
        if( m_dwLogLevel &gt; 0 )
3 M$ _( z* }% B6 q0 I. R. U7 B            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
7 u& T5 r7 P) x% }3 N<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pFromPlayer );
        return;
' k* b/ V: u* [9 B$ e+ N    }</P>
<P>    // Compute the cell the player should be in now
' o" @+ C- U; N    DWORD newcellx = int(pClientPosPack-&gt;fX);
  G* g* b, \8 R% s    DWORD newcelly = int(pClientPosPack-&gt;fY);
& |  D; Z- N& D    DWORD oldcellx = pFromPlayer-&gt;wCellX;
* S8 t+ v2 B2 @& D  G5 V    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
7 @0 ^, ~" X6 i1 T2 K/ o8 j<P>    // Have we moved cell?
    if( newcellx != oldcellx || newcelly != oldcelly )
    {
        // Yes, so lock the pair of cells in question
        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
- m4 L1 S( h) C<P>        // Remove from old cell and add to new cell
. p* c6 ~8 b0 _        UnsafeRemovePlayerDataFromCell( pFromPlayer );
2 h% H6 n- r# v  Y& t: r$ ?3 H2 d        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
<P>        // Unlock cells
9 ?6 q/ W2 e9 X1 e& ~& d* t        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
6 ]( L( [. V, t/ s- J    }</P>
<P>    // Update player position
( g1 Q* O$ K7 W    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
" w  d6 S  b0 `; U/ ?4 A+ V0 z; ]    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
% v6 a3 k: ?7 Z: }<P>    // Allocate space to build the reply packet, and fill in header
    DWORD dwAllocSize;
6 i& @, c0 u* I; \    ServerAckPacket* pSvrAckPack = NULL;</P>
' z  ^# r9 B3 Q<P>    // Begin by allocating a buffer sized according to
    // the current number of nearby players + 4.  This will give
4 B( ~1 E* t* q% _, \; w, N# t- _+ h    // a little room for more players to come 'near' without resize
% J- o$ x2 l# u    // the buffer.
    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
7 q8 t- O; [, `( p8 m<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
/ K8 a( {' i0 Q3 z0 S! R    if( NULL == pSvrAckPack )
    {
# I- ^/ H$ b* d: c        // Out of mem.  Cleanup and return
3 m9 U$ O: Y1 i. {2 ?        UnlockPlayerData( pFromPlayer );
$ H: @5 Y- k) j+ n' ]: A7 q        return;      
" V3 D  V) T: A7 t6 [/ x( p    }
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
<P>    // Compute range of cells we're going to scan for players to send
& P& C- k" A2 w    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
: @# |% P* s+ a4 r8 y    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
6 a7 ?) G* f! j    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
! x% u% e8 N% n$ l% B' O' r9 `% ~3 U    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
<P>    // Lock that range of cells
1 F$ W7 n+ `3 |$ @+ _3 q; K! r8 d    LockRange( minx, miny, maxx, maxy );</P>
<P>    // Scan through the cells, tagging player data onto the end of
    // our pSvrAckPacket until we run out of room
0 l) J' D7 U: A    for( DWORD y = miny; y &lt;= maxy; y++ )
: O$ F# x1 `9 G* Z    {
        for( DWORD x = minx; x &lt;= maxx; x++ )
) O$ L, n; r# D# d        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
            while ( pCurPlayerData )
' G& t* Y) ~* f) |            {
1 Q+ \5 @/ }. F! \  c" {! s& l                if( pCurPlayerData != pFromPlayer )
                {
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
                    {
                        // Make sure pChunk is where we think it is
) \& f+ o2 M/ s. W& a2 [9 S% e                        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
                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
                        dwMaxPlayerStatePackets += 16;
" E: U# d: k9 V, C9 g4 F% p                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
& s' C. w3 y7 f( S6 v. e! d8 z                        ServerAckPacket* pNewSvrAckPack = NULL;
; p0 F& h$ r; ]' s" n$ o/ u$ A                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
0 \2 t4 s5 D0 t% f' H                        if( NULL == pNewSvrAckPack )
8 E) F' {. h3 O, W4 h5 k5 `7 c1 T                        {
                            // Out of mem.  Cleanup and return
) A% [, s# _2 J# @6 u0 D, e                            free( pSvrAckPack );
$ A+ t" f6 }/ H                            UnlockRange( minx, miny, maxx, maxy );
                            UnlockPlayerData( pFromPlayer );
                            return;      
                        }</P>
<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
                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
  X, Y; }* j/ T, q- u. I                    }</P>
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
) j, e' T- N, l6 i( G" u                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
) t# J' d: U$ i* X. f# c7 j                    pChunk++;
                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
$ e# ]8 n5 C$ M- m) ]                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
- L8 B2 Q  {# o2 U- g. K        }
+ M& `) i  j% z9 x. v, X# }    }</P>
) S$ C/ d8 Z* t. b6 R8 m" O<P>    // Update the dwNumNearbyPlayers for this player
    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
<P>    // Unlock range of cells
    UnlockRange( minx, miny, maxx, maxy );</P>
# m% a9 r9 S/ @) b7 J1 @( T<P>    if( m_dwLogLevel &gt; 2 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
$ f1 J4 B9 H0 `" |3 r% Q    }
& Y9 j: ?0 q- ^1 s6 d: e& t    else if( m_dwLogLevel == 2 )
    {
: G1 q6 {# q9 q2 Q  J5 [1 G( l        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
5 s: D8 A4 P* D* B) i- B9 {        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
$ L( o2 ]0 H" |- f5 ?        {
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
5 ]" l$ [/ h1 e1 s+ _2 O            pFromPlayer-&gt;fLastDisplayTime = fTime;
        }
    }</P>
<P>    // Unlock the playerdata
  X+ l# Q0 Z5 i2 g    UnlockPlayerData( pFromPlayer );</P>
5 l* I/ Y8 Y) J* X+ z$ |, D<P>    // Send acknowledgement back to client, including list of nearby players
9 W" |( _1 Z* M7 a    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));
. R( I4 V3 C8 I, c6 D
    // Pack the buffer with dummy data.
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
# E6 @- {# D. w4 }5 ~& C        VOID*   pTempBuffer = 0;</P>
<P>        pTempBuffer = malloc(dwBufferSize);
$ v2 {( X4 x( E, H3 J, L  a! G        if( NULL == pTempBuffer )
        {
            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
            free( pSvrAckPack );
            return;
        }</P>
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
4 @+ W2 F+ Q8 S; g% q  e" |<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
   
        free(pTempBuffer);
* y' v3 o; X: ^    }   
    else
& x" k" i" S, W0 [. w    {
/ O3 i0 }2 A( W9 o/ C; P4 m2 v5 t* P5 n        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
1 A4 u7 {2 w: b9 z6 Q    }</P>
<P>    free( pSvrAckPack );</P>
<P>}</P>

: Y# q- U; ~5 T0 p( F<P>
; q0 n7 {! M0 S  T$ F0 u//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
- n0 {7 s) H0 T) q. l{
# Y8 A8 L- n3 n: y    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
4 d5 A/ j& d: n    if( pPlayerData == NULL )
        return;
    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
<P>    if( m_bLocalLoopback )
7 W% }! `5 W; f+ |: u        pPlayerData-&gt;bAllow = TRUE;
3 m, ?3 T4 F; h  e- g    else
        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
<P>    if( m_dwLogLevel &gt; 0 )
7 g* n- F! D7 O( G$ f: E7 }        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>
$ l! v/ u$ o' c* B8 s<P>    if( FALSE == pPlayerData-&gt;bAllow )
    {
9 |( i& Y' i- v3 T$ C1 `7 [1 {        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 );
* r  @, ^7 g5 ], w' c        UnlockPlayerData( pPlayerData );
: F6 {" T) |% v* e        return;
    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pPlayerData );</P>
- e& {7 ?5 ^: [7 N8 z<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 );
1 h5 [# `9 R3 g; r: Z! @}</P>

<P>
//-----------------------------------------------------------------------------
  Y5 P- |9 Z- S// Name:
// Desc:
6 \. ^6 J3 n% b& C8 T4 e$ y//-----------------------------------------------------------------------------
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
. p) q2 H* r# }{
+ u  r2 Y- g) f1 N    switch( dwClientVersion )
    {
        case 107: // only v107 is supported
' R0 k" ?: ^5 m& l* s6 U4 |3 L            return TRUE;
7 }! Z4 Q: j$ y' i/ O6 R        default:
& A8 F( G$ s) f' t            return FALSE;
    }
}</P>
+ Z& W, o- g* P9 F
& C; U+ J0 W+ O* K; E. T<P>
//-----------------------------------------------------------------------------
) `! ]7 m% s8 s// Name:
// Desc:
& ~4 ?8 R' J4 c! h+ l% H4 ?" r//-----------------------------------------------------------------------------
5 j7 A5 x$ S( K' f1 Kvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
& g& z- M" a, \6 Z/ [( [{
    if( m_dwLogLevel &gt; 1 )
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
}</P>
1 b* T% X; s% Q. D
+ q6 ^8 y, G3 L& Q3 W<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
/ J$ F/ b/ R: m6 m//-----------------------------------------------------------------------------
# \: b" [9 @" l5 k) k% p( [DWORD   CMazeServer::IDHash( DWORD id )
{
    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
    return hash;
}</P>
$ S1 h. Y4 V0 x: @
' I8 N$ f7 C6 Y$ M5 c! q$ i<P>
/ A$ J8 O' U+ H7 {' c8 w  ^//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
# U* |8 T& O; Y0 q* c, R5 b) B{
    // Hash the ID to a bucket number
7 v  o- b" Z* Y/ w0 G    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
; l1 c0 C' _, J: ?8 t<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
, |+ ?' E. R7 V! \* v+ w4 J, c    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
8 x' O/ U" D+ z' T4 Q3 E    PlayerData* pPt = m_pstIDHashBucket[bucket];
+ z* y! Z  A3 M6 U9 b) X    PlayerData* pPrev = NULL;
+ u  ~+ y- `* k4 a9 l1 r" K    while( pPt )
3 ~- H# e( Q- N3 d* |/ c) B' W    {
        if( pPt == pPlayerData )
            break;
        pPrev = pPt;
        pPt = pPt-&gt;pNextInIDHashBucket;
2 M( W+ A5 _1 c9 Z& `    }</P>
<P>    if( pPt )
    {
2 I7 X$ Q% j' W7 @        if( pPrev )
# B& r" o$ k0 [' U% s9 O  }0 z            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
7 u; C! E6 K3 u5 y! y7 f        else
* u; g; a0 m' ]5 c& G. D. ~  t            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
! B  W0 t' d3 D; m3 z8 ^, w8 G        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
<P>    // Unlock the hash bucket
# t. W; V( G6 G5 `; k    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>
5 ~1 m9 d  B: J8 ~7 c& ]' e# H
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
+ W4 x3 @2 G) P* J0 D//-----------------------------------------------------------------------------
void CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
{
9 Y5 A, M; R# D& e, r4 ~$ i    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
    // otherwise there will be a circular reference
4 {$ i) J+ F' b: [# [    PlayerData* pSearch = GetPlayerDataForID( id );
3 f' D! ]! n1 a7 t8 j    if( pSearch != NULL )
5 Q. \; ?: P7 k. |0 R        return;</P>
! b6 G4 U9 c3 k<P>    // Hash the ID to a bucket number
( C9 k) s: G2 U1 q4 b& @    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
+ Q+ y5 [+ Y, d. i6 P    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Add player onto hash bucket chain
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
    m_pstIDHashBucket[bucket] = pPlayerData;</P>
, U2 f& ~1 z, h* U<P>    // Store net id in player
    pPlayerData-&gt;NetID = id;</P>
2 o7 H7 ~; I, Z6 x6 I. L7 ?' A- f! t<P>    // Unlock the hash bucket
! T. S& x0 Z( r+ v9 w# i6 W3 n3 V    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>
/ A, p, w# W9 c9 ]
" H) X) K" A8 |<P>
//-----------------------------------------------------------------------------
// Name:
- d, m* X0 h% ]2 R// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
: P( V7 a$ b* ]" O% F<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
9 l# T% I! u0 l) F7 ~, M/ F6 i    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
: R" D1 q; M- d" C/ B, P/ o- q. j+ H<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
$ X/ c7 c# i! r' A    while ( pPlayerData )
+ s! G0 \( N4 h; J! v, N    {
        if( pPlayerData-&gt;NetID == id )
2 @, ?1 D  \. E# l' v2 Z            break;
        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
9 o6 [! q+ q3 f8 A# t    }</P>
7 W  }: B$ U4 }  x! U* A+ Z9 ^<P>    // Unlock the hash bucket
. Y5 ^# w9 Q. ^( K( o  z    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
( Y4 u& e7 A( G# V3 [/ r<P>    // Return the player we found (will be NULL if we couldn't find it)
% u. u5 Z, M) y; M8 h- T    return pPlayerData;
}</P>

<P>
' f. Y  O5 [' r- ?6 S//-----------------------------------------------------------------------------
# W. a8 P1 `" B( x# k. k/ S( t/ ^5 @/ j// Name:
1 x9 b" g$ b6 o+ ^7 [# _// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
% j' i1 {& T& P- w//-----------------------------------------------------------------------------
" n: j% q% a* C% N, M7 fvoid CMazeServer:isplayNextConnectionInfo()
{
; \+ I+ @( D6 u1 A) |: O! P    if( m_pNet )
8 S, f' I5 J& A; H. t: K$ G    {
) I& x, q* v. L8 U        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
( M' Q$ X& ?) \, J$ U/ i        PlayerData* pOldestPlayerData = NULL;
) F1 L$ ~0 s3 c        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
        while ( pPlayerData )
        {
; Y1 |9 p" F  U  J' C            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
( S! @$ k: ?. f3 a, C6 R3 d7 w4 m            {
                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
                pOldestPlayerData = pPlayerData;
. L8 I' o2 ^  B1 x3 D' V( w            }</P>
<P>            pPlayerData = pPlayerData-&gt;pNext;
) n4 h8 X( M& t4 I        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
; g) g0 y# G2 B7 }        if( pOldestPlayerData )
  \) {! e" G. q, V; c( {        {
            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
            pOldestPlayerData-&gt;fLastCITime = fCurTime;
& h6 a; ?5 v+ b1 w" v8 u        }
. A/ T/ m5 ^$ y        else
        {
( Q1 M) z* O% x% j9 u$ \' z$ p# J            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
        }</P>
<P>        m_PlayerDataListLock.Leave();
    }
}</P>

<P>
  i5 W9 J# M) q; f; o//-----------------------------------------------------------------------------
// Name:
. Q8 a) t( l9 p8 K: U: U// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:rintStats()
2 u+ a% {& f' x" n* w4 f{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
$ m6 f4 j8 C1 D                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
" |' m+ g5 Y8 s7 M6 U                                    m_fAvgThreadTime, m_fMaxThreadTime );
% W% j8 ~6 K  |' B* c4 W    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
/ B% c" ~! k& T, I* e7 y    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
- b$ c2 T7 c1 h* q; r" u}</P>
3 ?: C# L% p* u' M6 W; o( c
<P>
! z# d" G! c3 j0 i//-----------------------------------------------------------------------------
2 Z) Q, J9 ?  W, _5 P+ S// Name:
) s& \% K2 f! i& y/ T: _5 r$ b5 c// Desc:
//-----------------------------------------------------------------------------
+ y( O2 w3 c, b# Y" N7 ]void CMazeServer:isplayConnectionInfo( DWORD dwID )
2 v, c% W) i! H" n+ e{
! }+ Y. H/ }. Q! d) A8 B" c* L    TCHAR strInfo[5000];
; c+ Q/ a$ d$ x; @2 w8 S+ k8 ^    TCHAR* strEndOfLine;
    TCHAR* strStartOfLine;</P>
6 U6 a% m, f* @  G8 z7 U( _4 |<P>    // Query the IOutboudNet for info about the connection to this user
, s. {5 b1 R" u    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>
<P>    // Display each line seperately
% U+ m! X6 l- o! l  h* K    strStartOfLine = strInfo;
    while( TRUE )
0 P8 z# O- e* T3 m    {
& I& x0 o3 Q2 d: v        strEndOfLine = _tcschr( strStartOfLine, '\n' );
* T& ~$ [# p4 A/ [1 P        if( strEndOfLine == NULL )
( h% ?  c& T& G4 K8 F' W            break;</P>
<P>        *strEndOfLine = 0;
        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
5 A+ q' T' k- o% s    }
; ]2 G' G* F/ O+ R. A8 d}</P>

5 Q2 [  H4 {$ @0 Z% |; |<P>
//-----------------------------------------------------------------------------
// Name:
" ^3 K' p5 a! @0 G: R9 |// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
{
    // Chance of forcing any packet to be delivered reliably
5 O3 g2 H# S9 A! d. m& e    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
  _2 J3 b# e8 T7 P* k9 h# X( S, H<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
}</P>

! }% ]9 o! q# X<P>
+ ?* X- ^8 x. r4 ]$ m: x4 }+ A//-----------------------------------------------------------------------------
: V( y8 G) y6 |9 k6 f8 J- O# n: D% n// Name:
4 Y. r. |- z( U! v7 ~" j& G3 d3 x// Desc:
; }) m+ W) e" {+ |//-----------------------------------------------------------------------------
( m1 U8 _7 l' l6 V& [, M2 T* ^8 b' jvoid CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
# }! V% E" T+ k) T  `* I{
    // If we're up and running, then send this new information to all clients
    if( m_pNet )
7 m% A8 B* {1 Z, H8 ~5 L5 G    {
* V# h7 J' p8 t' ~        //Use the AllPlayers ID
        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
1 H/ p4 [' Y: J! e7 a}</P>
/ x! W2 I! X9 D
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
' A; k  Z; k4 z$ I1 K- B//-----------------------------------------------------------------------------
; C1 Q, J' R* `+ d* J+ Rvoid CMazeServer::SetClientReliableRate( DWORD percent )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.ubReliableRate = BYTE(percent);
+ i' |, H: p) F* r/ S7 g    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

' [! t& T# q& x" E/ [<P>
//-----------------------------------------------------------------------------
4 w+ k" Y, r; z$ N// Name:
0 |' G; u& Y- X// Desc:
' O) D5 l5 ?4 x' W  W8 {# P0 t5 g  e//-----------------------------------------------------------------------------
- B2 A( x& r3 t' B( {void CMazeServer::SetClientUpdateRate( DWORD rate )
/ l6 v( Q3 t) D0 I: h; U, G7 C{
) N- y8 y$ y  J9 ~1 G6 v    // Update client config, and build packet containing that data
6 i  l- t! n. n6 E2 x" P( J: D    m_ClientNetConfigLock.Enter();
3 ^) L: Y9 u& Y% I  _+ u2 T+ y    m_ClientNetConfig.wUpdateRate = WORD(rate);
) ^$ M" W, j; W6 B) `; ?    ServerConfigPacket  packet( m_ClientNetConfig );
$ _& M6 f$ ]! j$ a0 ]% X    m_ClientNetConfigLock.Leave();</P>
, y) K; f* B5 _7 S1 o<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
% N. V2 @  G; A- `1 {5 ?" z# e//-----------------------------------------------------------------------------
$ n# d' ]* p8 U8 l& O// Name:
// Desc:
% \2 `, U: ^6 o  K, `/ ~0 `. \//-----------------------------------------------------------------------------
! V% c: c! Z+ k9 ivoid CMazeServer::SetClientTimeout( DWORD timeout )
* O& U& g9 ], O" t9 Z) ]9 M{
/ @! @6 v& B6 v2 E3 ?) T/ W    // Update client config, and build packet containing that data
# Z& z. \  p& A, v) }    m_ClientNetConfigLock.Enter();
2 B. s& I- a- U8 x( h# D8 U; m    m_ClientNetConfig.wTimeout = WORD(timeout);
& E/ i0 ]( X9 P# G+ z( S( W% p    ServerConfigPacket  packet( m_ClientNetConfig );
; u; }7 u1 C: O# X1 Z    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
) K. k! Y# p- t5 ]5 I$ a; S& w// Desc:
- z7 S* e2 \! N( Y9 T//-----------------------------------------------------------------------------
void CMazeServer::SetClientPackSize( DWORD size )
+ b/ g; E3 B$ Z6 z{
1 H7 H8 f! ~: u5 _8 [7 m    // Update client config, and build packet containing that data
# ]& b. s, W* b& P; ]+ s% ~    m_ClientNetConfigLock.Enter();
   
# e' P. E. r& _4 w3 ]8 C# H7 b    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubClientPackIndex = 0;</P>
- c* b3 R" F. H0 m<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
6 Q' y2 a% ], X1 N    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>
9 r/ n2 S- t/ w
- S$ Q( T- j2 n7 a! _( w. i<P>
//-----------------------------------------------------------------------------
1 X# g4 m4 k5 h6 P// Name:
6 _4 K/ V  Q+ U9 |9 N# M// Desc:
  `1 L; L7 n8 A- P//-----------------------------------------------------------------------------
' n6 i* ?$ K% f2 N2 ivoid CMazeServer::SetServerPackSize( DWORD size )
{
* r$ f# h" ~" k( o& ^    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
7 Z- j1 ?) [( u9 \1 a; j   
    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubServerPackIndex = 0;</P>
<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
5 S' k0 v: }* O- t8 p}</P>
) `5 e8 c6 J/ w  I3 S1 K2 _* L5 q; _" [<P>
" Z( M4 S# {/ o9 {, Y4 B//-----------------------------------------------------------------------------
// Name:
- Y3 z& ?% K9 ]" D2 ]// Desc:
//-----------------------------------------------------------------------------
& t' H: p, k7 Y- N$ i1 |: v! @void CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
{
# i+ b. A6 s8 v8 |8 a3 g    // Update client config, and build packet containing that data
; ^) G. k' H& O+ B1 T( G, X    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
    ServerConfigPacket packet( m_ClientNetConfig );
4 s$ O2 K8 t' R, X+ k1 q9 L2 B    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>