[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
<>// File: mazeserver.cpp
//
1 C% J; P) u6 j" {3 d' H5 D// Desc: see main.cpp
/ {9 ]0 Q4 r( z) w. [: |( g6 }//
// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
$ Z0 e0 z1 u0 y0 ?( K% o( Z//-----------------------------------------------------------------------------
) S4 h$ }5 T0 p# d, V#define STRICT
" O2 M2 V; t  n" X) M" t3 D% X, r#define D3D_OVERLOADS
#include &lt;windows.h&gt;
#include &lt;d3dx.h&gt;
#include &lt;stdio.h&gt;
. |8 H' w+ l& [5 M0 W. N6 `$ ^6 y8 z#include &lt;math.h&gt;
' v$ r+ w7 W( f4 P$ o$ A0 ?#include &lt;mmsystem.h&gt;
#include &lt;dplay8.h&gt;
$ @7 [0 Q  d8 e7 J) G" W#include &lt;dpaddr.h&gt;
" G- X4 _/ x: z( T+ `% O#include &lt;dxerr8.h&gt;
3 Z1 ^% B% T5 x& ^5 r3 m#include "DXUtil.h"
#include "MazeServer.h"
#include "ackets.h"
#include "Maze.h"
, X5 `% Y* m' X9 e& L& U9 l4 P#include &lt;malloc.h&gt;
8 A  }' ~7 U4 }6 c/ ]* s" `% }#include &lt;tchar.h&gt;</P>
( N0 G) E: r4 F# x/ I1 R
<>//-----------------------------------------------------------------------------
; M+ H! h4 U, \# e/ s// Name:
$ J, j0 k: X5 A// Desc:
# ~7 r7 ?0 x  @4 G1 ~0 {9 r  x//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
( T& R' L  t* {5 U& l{
" f! m8 I) N' e; N* j    m_dwPlayerCount         = 0;
   
( Q7 |" ?# D7 A$ R7 v    m_wActiveThreadCount   = 0;
2 L- K' b# _, g    m_wMaxThreadCount      = 0;
6 E1 m) d4 n9 I- u    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
    m_fMaxThreadTime       = 0;</P>
- C0 i( x5 o3 i5 Z6 y% i6 i<>    m_dwServerReliableRate  = 15;
9 F* G5 A' n7 s  X' S2 x7 X" I6 F    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
    m_pMaze                 = NULL;</P>
, @# g( D9 Z4 B: f, y<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
    m_ClientNetConfig.wTimeout       = 150;</P>
<>    m_ClientNetConfig.dwThreadWait = 0;</P>
- O; P3 B0 z/ T, j9 U5 @<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    {
, I5 V+ O' s: f# {' Y& A        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
' F3 g2 a, h- h( V( m  \# F    }
# \9 h4 Q: E4 \* ?& a$ b  Q}</P>
6 E- g5 r7 }1 R% ^; U' r
  f3 c$ r$ X3 [8 t2 p<>
4 t* t4 k4 f' ?, l//-----------------------------------------------------------------------------
// Name:
8 f) n# O0 b, Y% n( }8 _1 a// Desc:
//-----------------------------------------------------------------------------
/ T  _6 y1 l, ^0 SHRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
    m_bLocalLoopback = bLocalLoopback;
    m_pMaze = pMaze;
    if( m_pMaze == NULL )
  [" M0 n" t  `3 ?        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
& m' _7 c9 U. q" m1 N# }, h    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
) X# ]# D1 F! G( Z7 w% z4 G    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
6 \( Y8 T$ h5 }. Z' N" R! {* f/ v4 u        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
, p% M- F" D: E( l3 V1 o( }3 P6 D    if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>
) g% O, a* k$ D) p) e& `' o, ~<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
    m_dwMazeXShift = 0;
* N7 s! U" |. ^) W' k. i( \8 T    while ( (scale &gt;&gt;= 1) )
        m_dwMazeXShift++;</P>
' k7 a' i1 W7 X4 o% Q7 ?+ a6 M<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    m_dwMazeYShift = 0;
0 G9 y2 T' ^* f* J    while ( (scale &gt;&gt;= 1) )
! d( |8 Z3 _1 a        m_dwMazeYShift++;</P>
; ~; v. x# Q$ z* r0 @<>    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>
& Z4 z6 x- p( ?<>    // Initialise the player list
    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
    m_pFirstActivePlayerData = NULL;
4 `0 ]+ {' R$ t. a2 r+ P9 _% l' M    m_pFirstFreePlayerData = m_PlayerDatas;
    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
% m& o$ M5 i1 h. D) v# o        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
7 N4 y' r! O$ p3 W. ~1 Z    }</P>
0 Y& |$ S8 ~9 |; z<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
5 G1 e, T# T" q- O& M    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
    m_dwActivePlayerDataCount = 0;
    m_dwPlayerDataUniqueValue = 0;</P>
- ^' ^3 Z& |% d, q& ]3 ^<>    // Initialise the cells
" d' Y2 b# ?( T  ]4 a: }" u+ K    ZeroMemory( m_Cells, sizeof(m_Cells) );
/ n( k8 y0 n/ t$ W  o: u9 s    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
) s9 U% E/ o8 t1 Q# s<>    return S_OK;
}</P>
% G! C/ S7 w6 `  |) M. a' u
<>
7 R# B$ {) a) u7 d4 W9 o//-----------------------------------------------------------------------------
# X. {) [  H; y9 {( r5 J// Name:
// Desc:
/ O+ G& X9 U2 o* T0 x. U5 ?/ z//-----------------------------------------------------------------------------
void CMazeServer::Shutdown()
1 J& r( N- [$ A0 q2 }1 g{
}</P>
# F7 x* M7 z+ \2 f' d" u: `  g
- N+ R6 ~, N  P" N2 I; H<>
//-----------------------------------------------------------------------------
7 |0 q1 W& Z7 z. ]+ ~8 [& ?; ^// Name:
6 s# {$ t- I3 J// Desc:
. A* J, S5 l# a/ v//-----------------------------------------------------------------------------
# b" w3 Q! m7 E, J/ h7 r6 [( o6 ?void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
& m9 I; B4 ~, [0 c6 M{
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
! I1 E! ?# ], }; T$ c                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>
0 ~9 L* b: t4 \& _  t
<>
//-----------------------------------------------------------------------------
7 z" x$ r1 ]7 K// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
. s8 L3 F& Y; e    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
6 }3 ^& N& g4 p$ U* c                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
7 `1 w; n/ E2 B4 j$ f3 S* c}</P>
* T' O7 f" ^5 V1 E  \9 _& r
$ @4 s# [' B  O4 c0 `; Y<>
//-----------------------------------------------------------------------------
0 x4 Z4 d- K# o7 o8 l3 r; h$ g// Name:
// Desc:
1 F, E% l; g3 N$ W//-----------------------------------------------------------------------------
) z: B* I: y9 @& M1 l% k8 Uvoid CMazeServer:ockCell( DWORD x, DWORD y )
{
4 ]. L' z$ C6 \# m# i    if( x == 0xffff )
' z, K1 P) q9 O        m_OffMapLock.Enter();
" H8 L' k- Q  F  m    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>

<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockCell( DWORD x, DWORD y )
{
    if( x == 0xffff )
, F9 ?/ g* M9 D, y( w1 r        m_OffMapLock.Leave();
4 G1 ~$ c8 M/ t+ E& Z; L    else
        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
- `9 B8 K/ t- \9 b- c& N# x}</P>

<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
* c- G, z7 t9 Y4 x* p; u3 P; h//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
+ `. f9 _# s1 Z9 n7 X$ M/ G9 X{
    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
        else
0 y' l. \  v4 D5 X  G            m_OffMapLock.Enter();</P>
& z: D6 S) Z! D' S<>        return;
    }</P>
6 c, x* T/ E% J6 u<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
3 O+ E/ l, `1 ?% G) m    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
/ g) ~8 h! z0 k" t) N    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
4 v% |1 H6 _$ x<>    if( x1 == 0xffff )
    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x2shift,y2shift);
    }
1 m3 A5 w1 w4 e; b    else if( x2 == 0xffff )
9 S1 s) `/ @( F4 ^    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
    }
    else
! L- J* e" w8 N, g' O    {
6 q" e. E* j: h: }        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
  i/ X3 D0 |6 a! V' g0 F4 O1 V! _}</P>
+ z( C9 V. Y1 Q
<>
9 [; _: x. C& ~- v& Y2 I- _//-----------------------------------------------------------------------------
5 y) h0 g" Z' g0 Y- g8 J% U  k// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
2 Y* D+ d" O  H4 t; B" a1 W{
4 r( N" r0 I( ?' n: ?    if( x1 == x2 &amp;&amp; y1 == y2 )
: [- R" m) R9 E% u# |, i8 K& F    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
* _+ v, E6 I* ]+ G' h+ M2 O- M            UnlockCell( x1, y1 );
        else
            m_OffMapLock.Leave();</P>
& P2 {* R) t$ S1 n* w; I- A* t<>        return;
! q" V# o* C) x) q; d    }</P>
" o3 f4 x8 y- p- F1 j4 j# E<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
0 c8 X, o! e7 E" a/ Z<P>    if( x1 == 0xffff )
& z) m5 O3 [& R; q. G1 Y    {
        m_LockGrid.UnlockCell(x2shift,y2shift);
0 a& I, R6 W. m. @8 b        m_OffMapLock.Leave();
    }
& L$ T# U7 ]% I. `' B( K    else if( x2 == 0xffff )
    {
3 b* g6 g- q0 f  `& ?        m_LockGrid.UnlockCell(x1shift,y1shift);
        m_OffMapLock.Leave();
    }
' W& ^" |& B# {/ X; S) ]    else
    {
; ]' |! A* }* M& R) d2 ]0 s6 S9 L& M        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
2 X! Y6 M% Y. b) R+ S    }
}</P>

<P>
//-----------------------------------------------------------------------------
- B/ v% H5 m3 ?  s* |4 t# k0 G& @* }: m// Name:
// Desc:
0 h) v% v$ T  \; S1 g//-----------------------------------------------------------------------------
void CMazeServer::OnAddConnection( DWORD id )
{
    m_AddRemoveLock.Enter();</P>
<P>    // Increment our count of players
    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
- R3 _& F6 z" L8 v& g8 j4 @, R    {
* N* S4 s$ n2 h, g1 o$ _, D        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
) V+ a+ k' p5 j" C1 `        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
9 V* W! `4 ^3 O6 r0 |  P, l9 O( e        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
<P>    // Create a player for this client
    PlayerData* pPlayerData = CreatePlayerData();
# U8 ^# G$ _) {$ ~# h; L    if( pPlayerData == NULL )
    {
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
- N' k# u, _, O) M        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
        m_AddRemoveLock.Leave();
$ d- l+ P, W  f# j        return;
    }</P>
" E; ~& a- y8 W! Q<P>    // Store that pointer as local player data
4 A) Z# y! R' y; @    SetPlayerDataForID( id, pPlayerData );</P>
<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
* H# t4 {5 Q' c! F& h+ I6 p    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    // Send it
    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
* }. Y4 c! V) @( s+ ^<P>    m_AddRemoveLock.Leave();
6 J! X* b. A' e' c}</P>

<P>
7 n0 b; H) \  ?( I7 g: Y! D//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::OnRemoveConnection( DWORD id )
! Z, Z: d* H  e: `4 C, d: y: l{
4 C, s: D4 L" v; x    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
3 p) b/ z$ ^# K0 P: a. s" C8 M    m_dwPlayerCount--;</P>
! j# [3 b% L& l+ N5 u' K  T! C<P>    if( m_dwLogLevel &gt; 0 )
( X7 j  D, J4 v: T    {
& Q0 d5 j+ l( A9 e6 s* j4 W2 [        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
+ K1 B) `. o8 C7 {- n        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
6 J: J- R  y0 a; `/ `* e  [) \    }</P>
' x( l* @7 T; t( z  v<P>    // Find playerdata for this client
    PlayerData* pPlayerData = GetPlayerDataForID( id );
    if( pPlayerData != NULL )
    {
        // Destroy it
        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
( G5 T1 A# w3 D. }$ k2 d+ b$ M% X    }</P>
1 L, ^) g1 }6 x8 G<P>    m_AddRemoveLock.Leave();
}</P>
6 y; |" ^/ a8 A
5 Y- |" v" C4 F- k+ s<P>
1 d+ f/ K) r& V) H. X# }( v; A8 G3 {//-----------------------------------------------------------------------------
/ P" _' ~: N- _4 F# O  N1 z2 v- l// Name:
% X, e0 r# n# L$ u: l// Desc:
3 i; U  g# D8 \9 l" [//-----------------------------------------------------------------------------
+ b# X. r4 F+ m! h- PHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
{
" K' y+ [, o6 B& H5 {    BOOL fFoundSize = FALSE;</P>
<P>    // Increment the number of thread we have in this process.
0 q: f+ T4 A: g    m_csThreadCountLock.Enter();</P>
  G! k  \- K" t8 R' u  o2 n* r<P>    //Get the start time of when we entered the message handler.
3 e4 y1 @3 ]) s/ x9 B    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
+ \! m+ z4 b% z7 P. f- a<P>    m_wActiveThreadCount++;
: {9 |7 _1 V, n$ f' S    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
6 F5 f" i6 }( [: |  I, U; H3 `        m_wMaxThreadCount = m_wActiveThreadCount;
   
$ U& m& k! C# I0 W) B1 S4 G" S    // Calculate and average.
: Y6 g1 P8 a* b4 A  s    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
+ g. ]0 z/ ?9 J    m_fAvgThreadCount += fdiff/32;
0 \- p5 W% J% _9 Q( I* Q9 a% O9 _/ ~  Y3 L   
1 k# Z4 s9 w0 ~% o  W* g3 V    m_csThreadCountLock.Leave();</P>
+ O3 g) {/ y3 D<P>
7 Z  ], V6 `* ?2 h3 d    ClientPacket* pClientPack = (ClientPacket*)pData;
    switch( pClientPack-&gt;wType )
+ L" [, Y# P9 n    {
; F) {5 ?5 M5 t: O& \        case PACKETTYPE_CLIENT_POS:
: |9 g+ t! d6 }/ e            
            // Check to see if the packet has a valid size. Including
& ]7 E8 ~6 N) E! l. i/ K) d            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
6 @9 B+ \( a+ `3 C4 ?0 R                fFoundSize = FALSE;
            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
0 O  g# q; N5 c* k                fFoundSize = FALSE;
' ?6 _$ `& A2 a" l, w+ w3 F            else
* `. N( t5 f3 K7 b                fFoundSize = TRUE;</P>
. y9 U9 B" T" d) N<P>            // If valid sized packet, handle the position.
# B3 C* A- D$ j0 U            if(fFoundSize)
" m+ k5 _9 C2 _                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
. u7 q! R6 |4 `* A" C            else
* t$ U( R2 q8 P2 k                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
. e6 W/ H% v7 [& L- g<P>            break;</P>
: L- Y) G) a! E# l3 B3 d; W<P>        case PACKETTYPE_CLIENT_VERSION:
) b$ X; J- Z6 b, F            if( size == sizeof(ClientVersionPacket) )
, R% Y: z, f, ^. F! P) d                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
% Q7 {3 J+ Y) n            else
5 R; C; l( l2 h  `- ~" F- w                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
- h6 u& L+ m. b9 t% c9 s. x. i5 Q& Q            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
<P>            break;
        default:
            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
* w3 q9 e2 H% b0 S    }</P>
0 t. Y% {1 P" X; x" l) B<P>    //If the user wants to hold the thread, Sleep for given amount of time.
6 I: A9 f, G; y9 z- F+ }1 g    if ( m_dwServerThreadWait &gt; 0 )
" A8 h$ B9 Y2 Q% a    {
; Q+ p/ o! d( l# o- Q8 O        Sleep( m_dwServerThreadWait );
    }
- B$ W% s& w. `6 g   
6 R' R0 }9 s8 j5 O8 _    // Retrieve thread data for this process.
    m_csThreadCountLock.Enter();</P>
  R0 }% g6 ]* P5 I. e3 i9 ^; e; ~<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
    m_fAvgThreadTime += fDiffTime/32;</P>
3 a6 j4 C# B; H% ^* W, s! M<P>    //Get the Max time in the thread.
    if ( fDiffTime &gt; m_fMaxThreadTime )
4 {" Q* z5 T2 D. O/ I( P' e) [3 n    {
        m_fMaxThreadTime = fDiffTime;
    }</P>
8 k' K$ P( }& X7 m& ~" d<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
% t- t7 y( C" X, M) o" e; D, s}</P>

& F3 z4 e2 V7 T<P>//-----------------------------------------------------------------------------
// Name:
// Desc:
3 m. c+ F7 f0 H! Q2 S9 T//-----------------------------------------------------------------------------
BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
{
    BOOL fFoundSize = FALSE;
, f1 l  c6 @2 ~. w0 U- z; a    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
   
    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
8 {& x* Y" E# b9 a+ j. `+ |        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
# c- q  W  [& F3 `; f5 V3 N            {
                // Found valid size in the array.
4 R% G9 @4 C" F8 J                fFoundSize = TRUE;
* d' F: F7 |9 C. c1 ~& D* i. K                break;
            }
            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
( {/ C# B" I0 t+ e: h0 H        }
$ \3 `5 |2 ]; P+ c: S4 G, v    }
    else
    {
        fFoundSize = TRUE;
* g. O0 L/ H' I- U    }</P>
5 P6 x; m) }$ k<P>    return fFoundSize;
}</P>
<P>
//-----------------------------------------------------------------------------
6 e$ E- z  h( J! h/ t# e4 y8 ?// Name:
6 A) t1 y* N$ u: O0 H; ?( y// Desc:
//-----------------------------------------------------------------------------
2 a2 d( e; x/ @3 {% M3 m8 l" Kvoid CMazeServer::OnSessionLost( DWORD dwReason )
' g1 x8 W: W4 k" M$ i! d{
    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
5 o: ?6 t" S  R0 T3 q  B4 `}</P>

6 i( T$ n% K0 p  z* d<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::CreatePlayerData()
% b1 d) n. c! W' ]{
    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
! u! n" g8 a1 `    {
4 b5 ^. f2 p% b3 x# q        LockPlayerData( pPlayerData );</P>
<P>        // Got one, so remove it from the free list
        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
        if( pPlayerData-&gt;pNext )
2 q. B* H7 H2 z( O8 J            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
  o# r+ m4 t1 [        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
<P>        // Add it to the active list
# h) \& y1 X7 a        if( m_pFirstActivePlayerData )
0 n9 Q% ^+ m9 g4 N% l            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
$ n# F+ ~$ X6 ?* P        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
( T& V- h4 c1 w, S7 O" m. I  w+ w' \        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
        m_dwPlayerDataUniqueValue++;
. R+ O2 W$ O8 }6 ^8 [6 E, q/ ?        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
0 I' x1 B, ?& W9 c# @( G<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
7 u# f& S4 |# u! _' M        pPlayerData-&gt;NetID = 0;
        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
<P>        // Insert into the "off-map" cell
        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
5 ^, H/ J$ I1 P" ^4 `8 i        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
        m_OffMapCell.pFirstPlayerData = pPlayerData;
        m_OffMapLock.Leave();</P>
' y6 e, V0 v4 e& b8 w8 Z; N<P>        // Mark as active
3 J& U0 t$ I1 ?* I# K4 u/ z7 T( \) ~        pPlayerData-&gt;bActive = TRUE;</P>
<P>        UnlockPlayerData( pPlayerData );
    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
- l' M2 \6 X9 @<P>    return pPlayerData;
}</P>

( y( \8 N2 t7 I<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
) R6 \2 Y" ]4 `" K' U8 O{
) k( {1 V* S+ L0 a* h$ i0 V    m_PlayerDataListLock.Enter();
  ~" v+ |4 R4 |) L; A" W/ Q9 g    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
    RemovePlayerDataFromCell( pPlayerData );</P>
" F% X; y! U  E% X. \+ H* A1 a<P>    // Mark as inactive
2 H+ N/ e" B* U' f    pPlayerData-&gt;bActive = FALSE;</P>
9 H7 m) |8 Z! h/ D! J<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
1 O2 ?- b# R5 S: ^) y9 I        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
7 H8 t/ k( _9 ]<P>    if( m_pFirstActivePlayerData == pPlayerData )
        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
' J+ z9 V, J5 L/ P3 q$ F/ Z# K    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
9 a5 @7 {8 L$ V9 Z6 U; K    pPlayerData-&gt;pPrevious = NULL;
# t7 r9 i+ d1 _# f. q    m_pFirstFreePlayerData = pPlayerData;</P>
( P- b* V# W; n9 b0 ~<P>    // Update count of players
8 ~+ U, G% L8 f) S    m_dwActivePlayerDataCount--;</P>
<P>    UnlockPlayerData( pPlayerData );
    m_PlayerDataListLock.Leave();
& j% q8 b; p1 @+ V5 B& [: d0 t}</P>
7 m+ ^. K& H% ~! I( x# A8 X
) ?& |3 s. f% [4 M<P>
//-----------------------------------------------------------------------------
" W( F- x& S# n// Name:
6 R* T, \+ W; O// Desc:
//-----------------------------------------------------------------------------
5 C/ z, t; J. x+ u' `# yvoid CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
. U; ^" O! W8 T1 I    // Lock the player
    LockPlayerData( pPlayerData );</P>
3 U" d1 j" R8 e4 T0 x& t<P>    // Lock the cell the player is in
3 X! O% ^1 Z5 e. v" t    ServerCell* pCell;
+ P! e- t( ~8 `    if( pPlayerData-&gt;wCellX == 0xffff )
" @5 }8 ]) |' d0 @    {
3 Q, p6 J) }4 ~$ A        m_OffMapLock.Enter();
6 W8 V4 G. L/ H0 _% ~8 C/ p+ O* E        pCell = &amp;m_OffMapCell;
" ?# o4 R+ b* C% s    }
2 z  ^% C4 s- R4 p. G5 o    else
6 i9 J3 F! {; |7 \9 Q( N) o3 v: C    {
0 I/ }$ f; S& _( s, N9 ]7 R        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
* @2 d% r: y' J# L4 F) ~    }</P>
<P>    // Remove it from the cell
    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
8 ?( F( j) \( W# n9 X# c    PlayerData* pPrev = NULL;
: P0 ]: W9 y$ g, D! b! Z    while ( pPt )
    {
! D( r7 O+ d2 r9 }5 Z        if( pPt == pPlayerData )
: Q1 D' b% f. Y% X0 a) d        {
            if( pPrev )
6 w, H/ C1 `. Z/ U                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
<P>            pPlayerData-&gt;pNextInCell = NULL;
6 _7 q; B2 v- G2 t4 }. [7 B0 _" e# I            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
: S+ d- k5 u. H; g8 F    }</P>
6 C' D- U5 f& ?( Q<P>    // Unlock the cell
    if( pPlayerData-&gt;wCellX == 0xffff )
        m_OffMapLock.Leave();
  q0 x- Z: r/ J1 k    else
: `& d4 K5 W5 D8 m7 J% ~9 f9 J0 A        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
3 J: k! [$ |3 |9 {# A3 D% j2 ^<P>    // Unlock the player
    UnlockPlayerData( pPlayerData );
}</P>

<P>
//-----------------------------------------------------------------------------
/ V! {5 s( |1 J5 l$ C// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
/ ?1 y5 F! j. w0 b2 w{
    ServerCell* pCell = GetCell( pPlayerData );
( {' f: e: x5 R8 ~    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
. m% y' z2 G5 ^% t) `: @    while ( pPt )
& O4 ^) y3 ^2 f& v. J3 V% O+ F    {
  q% u+ m+ j# {7 {2 ^0 @" @3 z        if( pPt == pPlayerData )
" \' J) a" h( I  z+ g        {
6 v- }# z4 o3 u9 Q            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
+ ]0 l/ X( \' S( r. J+ q            pPlayerData-&gt;pNextInCell = NULL;
            break;
6 @; W1 J9 J1 p- }: R# h        }
        pPrev = pPt;
) r( _0 p9 m' A- r. C        pPt = pPt-&gt;pNextInCell;
    }
) ?7 d6 b+ @( x  z# p! [) O% F}</P>
$ q, |0 x! R- z- y" L
<P>
% c5 u. x& x6 j//-----------------------------------------------------------------------------
// Name:
3 t4 r: [2 Y) A: A# M# {// Desc:
4 v# L, {8 m+ v/ J//-----------------------------------------------------------------------------
$ t" d5 ?) }1 _! U. u7 Cvoid CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
* s2 ~, `- f$ u8 K# O# A{
1 Y3 w% n, t  ~3 C    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
    pCell-&gt;pFirstPlayerData = pPlayerData;
}</P>

<P>
. A4 b* ?5 d' [; G8 U# d7 M//-----------------------------------------------------------------------------
// Name:
// Desc:
4 B8 S: }: P* Z  i* l+ [3 r( _//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
5 r% f0 c8 x- h) `5 v& z+ D$ {{
- v+ K: y3 w9 e, p& u- t' B    // Grab player for this client and lock it
. n$ T, R/ r0 K' H. _    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
! d+ D% p, |9 c9 F2 M: i1 _    if( pFromPlayer == NULL )
    {
; R4 U( E9 K# H        if( m_dwLogLevel &gt; 1 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
        return;
) k* E6 }  G; u4 [    }</P>
4 Q6 G  ]9 h' u3 `* [  f  d/ r- `<P>    LockPlayerData( pFromPlayer );</P>
" v6 j& G# t9 F; g9 @/ @1 S5 Z<P>    if( FALSE == pFromPlayer-&gt;bAllow )
    {
        if( m_dwLogLevel &gt; 0 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pFromPlayer );
        return;
    }</P>
<P>    // Compute the cell the player should be in now
6 @. @  c* k" f- o0 N% j: Q    DWORD newcellx = int(pClientPosPack-&gt;fX);
    DWORD newcelly = int(pClientPosPack-&gt;fY);
! b% I3 r, F2 H: F  D    DWORD oldcellx = pFromPlayer-&gt;wCellX;
    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
<P>    // Have we moved cell?
    if( newcellx != oldcellx || newcelly != oldcelly )
    {
        // Yes, so lock the pair of cells in question
5 h% W( q: e4 E) Z0 J6 n3 V        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
<P>        // Remove from old cell and add to new cell
        UnsafeRemovePlayerDataFromCell( pFromPlayer );
        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
% l- m$ y- O; G# u* q        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
; U! ^' g1 b# c  o3 l* h) b: H<P>        // Unlock cells
& Y6 @  F1 G: K        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
# Q4 \  a6 k. r4 C3 ?% s" v* C+ ^<P>    // Update player position
4 e" F: d% D3 N& c/ U+ j    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
# ?+ f  D! l  K0 u# Q  o6 M    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
<P>    // Allocate space to build the reply packet, and fill in header
& _' z8 r, J2 c7 t    DWORD dwAllocSize;
    ServerAckPacket* pSvrAckPack = NULL;</P>
<P>    // Begin by allocating a buffer sized according to
0 o! ?% W% Z" \3 u' b5 y2 _+ k    // the current number of nearby players + 4.  This will give
0 e& E6 t- S* K/ v& G    // a little room for more players to come 'near' without resize
    // the buffer.
    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
" T- K9 o. V4 V4 Q) j# d7 M    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
: i2 n, ~$ t. J) Y0 ]4 Q% q    {
0 z) Q# z2 i9 m" B0 W        // Out of mem.  Cleanup and return
( S! L* I: g; C0 h        UnlockPlayerData( pFromPlayer );
* g! J/ S6 a. x% R# t8 p/ @        return;      
2 M$ g# i2 E' {    }
! r2 w- h. g% L: @    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
% \& Q. U% R, `) ]% F<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
( l7 ~4 u6 Z7 ^7 h; O- S    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
<P>    // Compute range of cells we're going to scan for players to send
    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
: p4 S9 q& J+ t) D( ?6 M    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
* [7 D" E, }* b5 C3 L9 \    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
, H( w. b1 ]5 G7 T5 W<P>    // Lock that range of cells
    LockRange( minx, miny, maxx, maxy );</P>
" [4 m4 i" `# O7 K<P>    // Scan through the cells, tagging player data onto the end of
- A4 N9 s8 p5 W) v: G    // our pSvrAckPacket until we run out of room
    for( DWORD y = miny; y &lt;= maxy; y++ )
    {
2 {' q3 E% g# [% o; f2 N# \        for( DWORD x = minx; x &lt;= maxx; x++ )
) |# {/ v: F- a        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
            while ( pCurPlayerData )
            {
                if( pCurPlayerData != pFromPlayer )
: Z# y$ M& `" O# Z3 H' @6 M                {
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
                    {
                        // Make sure pChunk is where we think it is
6 v% s+ m% r$ }) B; C# N6 @                        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
) A1 n6 ^) s7 G9 R  g( Q1 }- a% y                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
3 s0 z/ d$ W! a4 p0 Q/ @' b# X7 N                        dwMaxPlayerStatePackets += 16;
                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
                        if( NULL == pNewSvrAckPack )
% B) S# M; X7 O6 B; z# P/ V/ u                        {
0 ~2 I) Y  x; E% q' _( u# I, W                            // Out of mem.  Cleanup and return
$ n+ d$ C; e4 \; S8 g                            free( pSvrAckPack );
+ z' j8 W2 J$ K, {& H                            UnlockRange( minx, miny, maxx, maxy );
                            UnlockPlayerData( pFromPlayer );
  [' D8 z2 D8 P. n/ f) y                            return;      
, }; E3 `( M+ S: ^* V( A                        }</P>
<P>                        pSvrAckPack = pNewSvrAckPack;
' ^1 b+ n$ c2 v& G5 P+ n8 r                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
1 J3 v3 s4 N5 y! c+ q1 J" q<P>                        // Make sure pChunk is still where its supposed to be
( H  o! t, G! g% \% m& Z$ N                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
                    }</P>
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
. t1 Y7 h* e' a7 V                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
                    pChunk++;
& u  `& y5 K4 s7 }3 ^1 c7 ^                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
        }
1 M) Q6 ^% o- O. f5 a# r. u, S3 k    }</P>
7 S0 |; [" I& U: p5 Q<P>    // Update the dwNumNearbyPlayers for this player
    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
% n  R/ E3 H) m7 s<P>    // Unlock range of cells
    UnlockRange( minx, miny, maxx, maxy );</P>
<P>    if( m_dwLogLevel &gt; 2 )
$ f3 L3 ]& s/ T- s    {
9 S* o) ]/ P: e, b        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 )
    {
3 z/ M" \) X5 p& |8 q& L. V0 n9 W        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
. n& U- e4 y; y! P/ u$ R7 y1 n4 w/ e        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
        {
; H2 I0 O1 A! W9 l            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
) y/ @) e( P4 Q, b. [' L8 T' z            pFromPlayer-&gt;fLastDisplayTime = fTime;
: f. ?- D( {. B) f7 i! ^) B        }
    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
, |$ I4 h  p$ `$ w4 s+ g<P>    // Send acknowledgement back to client, including list of nearby players
    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

5 }2 e4 n/ j) y/ p. B    // Pack the buffer with dummy data.
- U/ Q* E/ q2 C: U9 A, W- u/ t    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
* ]" f+ Q/ ~6 r9 ~, B5 q    {
: \, P% _% S2 I; _        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
        VOID*   pTempBuffer = 0;</P>
6 a4 V* R$ a7 Y! P3 |/ \3 _<P>        pTempBuffer = malloc(dwBufferSize);
5 [' t& v7 y  w$ w# n        if( NULL == pTempBuffer )
        {
            //Out of memory
" \2 U& h' Q) w% e2 E  g            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
            free( pSvrAckPack );
            return;
        }</P>
  o. R/ z- X3 N; n<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
) Q' U  Q8 _: s8 a7 `6 u4 q- T        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
   
        free(pTempBuffer);
+ |) y: A, I& n! p' C* R' S6 v    }   
    else
/ Q  D4 E3 v8 N    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
    }</P>
<P>    free( pSvrAckPack );</P>
7 \6 c6 b9 G2 p# W+ C2 T3 L<P>}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
; o' y  `: X) `+ {# w9 K// Desc:
9 Z! T' v5 p9 F$ U2 p+ m//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
    // Grab playerdata for this client and lock it
5 G: P! t0 U. A% Y! `    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
    if( pPlayerData == NULL )
9 s0 o2 b2 e6 I        return;
& n7 I" o6 W7 v    LockPlayerData( pPlayerData );</P>
. P* G" Q* \5 O/ ^5 D' I<P>    // Record the version number
  J+ `- i4 |1 N9 Y/ N    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
<P>    if( m_bLocalLoopback )
        pPlayerData-&gt;bAllow = TRUE;
5 v- s0 @. s- ?" i1 Q. l    else
        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
0 L) n# |9 B  ~1 Z; e<P>    if( m_dwLogLevel &gt; 0 )
        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Client version=%d (%s)"), pPlayerData-&gt;NetID, pPlayerData-&gt;dwVersion, pPlayerData-&gt;bAllow ? TEXT("Accepted") : TEXT("Rejected") );</P>
<P>    if( FALSE == pPlayerData-&gt;bAllow )
3 J1 F/ q+ ]% e/ @/ h4 u    {
* f  @' ^" V* @: q  o1 @        if( m_dwLogLevel &gt; 0 )
. s' v$ h/ T, p3 @5 `            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 );
5 _! Y. D6 t1 |2 A        UnlockPlayerData( pPlayerData );
' V# ~( \; E. v        return;
* U' j$ G0 f) F2 }    }</P>
<P>    // Unlock the playerdata
6 g$ G, }! Y* v; j. y1 n    UnlockPlayerData( pPlayerData );</P>
<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>

<P>
//-----------------------------------------------------------------------------
. B7 n! g6 c, ]5 Q/ A- ?// Name:
  p! Y0 E3 r, W6 S// Desc:
. W' h! i7 j; n9 J! X3 ?//-----------------------------------------------------------------------------
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
{
2 M' r( N5 F6 d1 K    switch( dwClientVersion )
    {
        case 107: // only v107 is supported
0 @8 q. O- C+ Y3 u            return TRUE;
        default:
            return FALSE;
9 S6 g" _# r/ Q# ?0 M    }
% I2 z$ Y9 r  O5 F7 k: G9 I8 P}</P>
) {3 J4 q( A1 W- `8 W! F1 f4 x
1 W. ?! }0 Q; U3 ~# i" x<P>
//-----------------------------------------------------------------------------
* O4 L- d0 X9 H3 l8 G// Name:
3 g5 k( V  W' n3 f! t$ e7 `) w// Desc:
6 E3 X; w8 q. P//-----------------------------------------------------------------------------
void CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
( N% l; ~5 [) W7 h+ x{
    if( m_dwLogLevel &gt; 1 )
: [9 ^5 B6 K& d! m        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
2 `- _% Y( Y$ T4 U1 f( A; Y<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
0 q9 m- d! A8 O- h/ F}</P>

8 Q4 N6 p  ]. Z  E- [<P>
  x6 C: D8 \" T, M//-----------------------------------------------------------------------------
, J% p. z- G, l9 o! O' R: i3 e4 a  b. @// Name:
// Desc:
//-----------------------------------------------------------------------------
DWORD   CMazeServer::IDHash( DWORD id )
{
$ f8 `0 _2 ^' \+ g4 `    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
    return hash;
5 D6 ~0 L' L" S# W. y/ _}</P>

<P>
/ q* a! N# Z/ U1 J0 ?& N  _' p( E//-----------------------------------------------------------------------------
// Name:
9 r1 p9 s1 C5 L, m( c" ^5 l// Desc:
//-----------------------------------------------------------------------------
9 K9 v  j. R* y+ `- ~" ~! k. [void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
<P>    // Lock that hash bucket
4 d; B! o5 p& G  z3 j( B, T& U1 i    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
+ W5 x$ `/ j2 z/ k2 E    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
) A# P* Y3 W. K& c# C+ c- B) _    PlayerData* pPt = m_pstIDHashBucket[bucket];
0 X$ f, h1 b2 j; W7 z- I    PlayerData* pPrev = NULL;
    while( pPt )
7 ]0 I" g; C& Y0 J, K, @; b    {
        if( pPt == pPlayerData )
            break;
        pPrev = pPt;
* i. _" m( J* W& G6 k: w! a- T$ q        pPt = pPt-&gt;pNextInIDHashBucket;
7 _8 T, b, U$ q2 C4 }! h2 _    }</P>
<P>    if( pPt )
$ U% s6 N) A5 O    {
        if( pPrev )
            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
        else
8 y2 F; m$ D, W! G' G8 W            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
5 x% P8 {7 a2 @4 `# H* M1 m        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
, Y0 V( o5 C  [- F# M<P>    // Unlock the hash bucket
! X' T( j( O; w8 W* u! r* {    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>

8 j% k6 g8 d. X" H% M<P>
//-----------------------------------------------------------------------------
) y7 q" h7 u3 q( b- w+ q8 ^' A, ^// Name:
// Desc:
//-----------------------------------------------------------------------------
4 u0 z" x2 C0 V0 {" h# W) avoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
: L* E" m" J3 _- {0 N3 @7 u{
1 v1 ]- I" P7 \3 z  s3 m    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
$ ~9 d  G& r+ y( f2 H    // otherwise there will be a circular reference
2 ]. i4 \2 l/ p    PlayerData* pSearch = GetPlayerDataForID( id );
; K) a5 D1 w& u' s$ K    if( pSearch != NULL )
9 ~4 i1 b7 z% V, K        return;</P>
8 h. G9 S$ _; Z9 O3 g<P>    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
6 u6 T. I2 R0 {; ]$ T9 {    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
9 ]5 X& S# N6 T/ A: O' b$ r<P>    // Add player onto hash bucket chain
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
* s7 A2 e5 a, R    m_pstIDHashBucket[bucket] = pPlayerData;</P>
<P>    // Store net id in player
    pPlayerData-&gt;NetID = id;</P>
3 @  G3 `& y" E<P>    // Unlock the hash bucket
* m! F3 ]' i+ B# }    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>
. e4 P$ T7 w/ E9 z3 N& {: r7 i8 ]7 ?
7 U. \' O2 d. k9 d) z. T<P>
//-----------------------------------------------------------------------------
3 O1 A5 ?: w4 C* D( T/ R// Name:
// Desc:
9 `# v! m  {9 t' ~. t- E* q//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
{
    // Hash the ID to a bucket number
8 y, p2 y3 X- E! ]$ a. l, @    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
" U  A0 V- T: [3 D% ~' L+ `  v; `2 L    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
. h: ~" l/ j# H% C- [    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
    while ( pPlayerData )
    {
: C+ ^( Y  x5 F: L# _. `7 E        if( pPlayerData-&gt;NetID == id )
            break;
5 ]% g+ J/ Y  e( e        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
0 {: z- J1 v4 t3 c7 K7 c    }</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
. w0 p; X' T* U9 e$ b<P>    // Return the player we found (will be NULL if we couldn't find it)
    return pPlayerData;
}</P>
& K+ O- ]* N2 z# c! X
<P>
//-----------------------------------------------------------------------------
// Name:
  [/ C! c6 G5 l! v8 `, n+ q// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
$ [9 Q6 A' v* T4 B7 B//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
{
  t- _1 n. S+ W' t6 F6 C3 _    if( m_pNet )
    {
0 d# M, M+ m  T9 Y2 C! r        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
        PlayerData* pOldestPlayerData = NULL;
        FLOAT fOldestTime = 0.0f;</P>
* B4 ]/ h( g- S: g<P>        m_PlayerDataListLock.Enter();</P>
<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
; s5 K6 R, Q1 m% o        while ( pPlayerData )
        {
' H% F( Z& B1 c1 X7 J$ N; v) z$ ^& b2 ?            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
            {
+ M, [8 h, e/ b                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
                pOldestPlayerData = pPlayerData;
; D3 C$ s6 X: p5 g            }</P>
<P>            pPlayerData = pPlayerData-&gt;pNext;
* N$ ^" w! V8 l6 Y" r* Z        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
) I/ K: M" A, Q* S* J' {0 x: l        if( pOldestPlayerData )
, S3 i% b4 O. |" H5 Z3 b        {
9 v4 a" u$ d2 X1 ^6 c( M            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
6 f3 F4 Y. F$ v( a  g' g" k/ H            pOldestPlayerData-&gt;fLastCITime = fCurTime;
( X) B( U! d) l0 l6 E: N5 N8 s4 ]1 k        }
        else
+ ~" [6 n" h6 `0 @! x        {
            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
: U: a) p5 E+ S. {( V        }</P>
<P>        m_PlayerDataListLock.Leave();
/ g) v. z% A0 t" y% g# w    }
}</P>

<P>
0 j' n3 }. f  p//-----------------------------------------------------------------------------
9 ?. D( A& U" Z6 i! w0 r  y// Name:
, c( {' ^" ~+ v% Q// Desc:
; Z, }- N/ _9 f, \//-----------------------------------------------------------------------------
/ `+ Y7 f5 A) svoid CMazeServer:rintStats()
{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
; w8 N/ j7 c3 X2 a; @# o1 {& m                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
1 W/ R. {# ~/ b. i                                    m_fAvgThreadTime, m_fMaxThreadTime );
    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
, a8 n! s' R" n$ Q0 j$ B9 o+ q    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
}</P>
! h+ v! J8 g* E* b7 M0 B' x3 E
4 e4 L/ n* R: A  M7 O6 E( K* s<P>
//-----------------------------------------------------------------------------
+ j9 g6 J# v+ Z6 J5 m// Name:
. D" l9 m! g) x. x' U3 A* L// Desc:
" O/ U5 e( U" B4 |2 `//-----------------------------------------------------------------------------
8 j  N* p. E4 E( Vvoid CMazeServer:isplayConnectionInfo( DWORD dwID )
, R# o5 [2 P0 Q4 O  u" ]* ~; Z+ T{
1 Z  c- W/ B: {4 a: n    TCHAR strInfo[5000];
    TCHAR* strEndOfLine;
2 g2 S1 A: P! F8 ^' x* C/ [8 L8 I    TCHAR* strStartOfLine;</P>
<P>    // Query the IOutboudNet for info about the connection to this user
8 _3 A6 V* ?: M4 I+ q! m" e+ J    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
! e# K# v! g) q1 K# S<P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );
- a) ^+ a8 Y" T# x    ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>
3 }' T# i( r: W  B( C* s<P>    // Display each line seperately
3 q( d9 i4 M: _    strStartOfLine = strInfo;
0 E% j* Y7 X5 V' g    while( TRUE )
    {
9 N1 `9 ?5 e6 o" p+ F3 I- |, F. R& ~) F        strEndOfLine = _tcschr( strStartOfLine, '\n' );
, `  `4 \# c  Y! j" m0 c: |6 h+ I- L        if( strEndOfLine == NULL )
# |1 v, f& t7 ~9 u8 \) j            break;</P>
<P>        *strEndOfLine = 0;
        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
    }
}</P>

<P>
1 N6 x+ o0 \2 ~& r2 z( p0 E# Y//-----------------------------------------------------------------------------
: Q# R5 M, U6 S; p6 ]0 \. g// Name:
/ p) ~& g, p! ^7 K// Desc:
3 w7 D3 E/ y& V" ?) m( i% y- P8 m//-----------------------------------------------------------------------------
6 A/ Z) M- C) N# Q5 G, D, WHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
; a+ T5 M3 U( ^: t/ s                                 DWORD size, BOOL reliable, DWORD dwTimeout )
" |- m( r5 v, N4 }0 E{
& l+ \8 s# {& ]    // Chance of forcing any packet to be delivered reliably
8 G, y3 K/ q% x" r    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
: F) Z% Z- o8 {, \- `! w8 e}</P>

1 h2 a0 m1 [7 ]7 k' `0 @# u. {<P>
//-----------------------------------------------------------------------------
  T+ t5 c% E- O- K  ~// Name:
! {; `' s+ @  M1 v" j// Desc:
, g) d; x  u5 D) o. [9 |+ b//-----------------------------------------------------------------------------
3 L' B  `  U; @void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
) b5 M  L2 \# g" d, W8 s4 f    // If we're up and running, then send this new information to all clients
    if( m_pNet )
2 k* Q' j& j# m0 S2 q. n    {
        //Use the AllPlayers ID
4 u' M, g4 H% J# p# j+ J        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
* A' y0 a& a$ C2 V! }}</P>

+ `% o( H% J' N7 H/ \3 T+ ]<P>
7 S! n; d2 p' w' }//-----------------------------------------------------------------------------
// Name:
// Desc:
# E4 v6 Y8 W+ M! u1 u//-----------------------------------------------------------------------------
void CMazeServer::SetClientReliableRate( DWORD percent )
! h. p1 ]" m6 |; C2 L8 e# ^{
    // Update client config, and build packet containing that data
5 Z7 W" f0 ^- u, h; o# _    m_ClientNetConfigLock.Enter();
1 [9 |- @  z# i' n9 `2 d    m_ClientNetConfig.ubReliableRate = BYTE(percent);
6 l5 S- K. o6 j- l6 n0 _    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
6 ^' g+ Z. a" r& I( t3 j- ]6 C<P>    SendConfigPacketToAll( &amp;packet );
* X( U! e+ A5 Y, I4 H}</P>
% e' v7 X( E  u( b
) R% c( {3 M; c: o0 s' A<P>
+ y0 F1 c5 [8 N2 p' o8 h! s//-----------------------------------------------------------------------------
// Name:
* X3 o( _6 \' H* y' e, ?// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientUpdateRate( DWORD rate )
, Y/ C% P1 Z$ X! e/ t5 j# x/ G/ w{
    // Update client config, and build packet containing that data
' |4 y, z' z; C0 r: f    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wUpdateRate = WORD(rate);
+ J9 x) ?5 ~! e/ j0 M0 n    ServerConfigPacket  packet( m_ClientNetConfig );
! g' v3 }8 `& Z; e: `( B    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

& z- D) C+ J9 Q<P>
//-----------------------------------------------------------------------------
// Name:
2 q& c# {1 O! p. t) {& {// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientTimeout( DWORD timeout )
9 N9 u% U4 z2 G$ _: j& H7 w{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
" e8 A* @0 G% H4 l6 r5 W    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

" s& k3 G- ^( s<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
% s! g3 x( T& M( W" P$ y) cvoid CMazeServer::SetClientPackSize( DWORD size )
{
6 J/ \7 k2 `- k# R* y    // Update client config, and build packet containing that data
! g* I, U) _5 C! a7 ^" q    m_ClientNetConfigLock.Enter();
: ^: d" Y+ N" m2 N% C/ }# `   
, ?, z. s! V2 N4 |3 F  X( Y* f! W    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubClientPackIndex = 0;</P>
4 N7 B  C  i/ |0 g( L7 f8 C  `2 ?& G<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>
0 z. c. F* G, f$ |! |
4 ~. o1 Q6 z6 ]2 U+ E4 L<P>
//-----------------------------------------------------------------------------
0 |+ X  Y" g! b/ ~; m// Name:
$ K6 A" E7 @: G// Desc:
//-----------------------------------------------------------------------------
( m" C/ T. E6 I  l' ]- `& mvoid CMazeServer::SetServerPackSize( DWORD size )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
7 C, e! f3 F. f, O: p# k  F    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
0 T7 a& S6 |& D4 ]5 a* p( y        m_ClientNetConfig.ubServerPackIndex = 0;</P>
<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
! x% A% }1 `6 {! y    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>
<P>
" r* _7 Y4 v& \. L//-----------------------------------------------------------------------------
8 K; B1 ~" c% V% Y5 Y// Name:
, V& R3 `0 r* A9 S* ]' b# y// Desc:
2 J3 O4 V! o# }8 w0 e//-----------------------------------------------------------------------------
" z, N+ ^+ Y1 nvoid CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
3 N5 p6 Y, T1 o: E6 K& C- X& @{
; q4 {, p1 s( n+ L/ x  ]* H    // Update client config, and build packet containing that data
. b" G  F* H+ J, R    m_ClientNetConfigLock.Enter();
* H# M/ K: q. w) O; ~* |   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
' S0 m, M& ~, z* c) J# D    ServerConfigPacket packet( m_ClientNetConfig );
6 |9 Y4 Z& s2 Z% ?- d7 P/ m" X    m_ClientNetConfigLock.Leave();</P>
1 K$ \3 r( ?, G4 q! D/ M9 A<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>