[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
6 i3 G: p4 j* ], i- |+ _<>// File: mazeserver.cpp
//
// Desc: see main.cpp
//
. S3 Q/ B# I7 l! g9 O2 T+ f( P7 v// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
. K& @- q( Q! m4 v$ s( g! d: V# U//-----------------------------------------------------------------------------
: k) G, h0 M2 h#define STRICT
#define D3D_OVERLOADS
* Q! E) z- {- Z: ?7 L& r#include &lt;windows.h&gt;
$ i% x) P8 B3 q1 I, a2 f#include &lt;d3dx.h&gt;
#include &lt;stdio.h&gt;
6 U! T# {: I8 u" @#include &lt;math.h&gt;
8 r: \1 L/ \. \! e% e9 v( W: j' z0 J#include &lt;mmsystem.h&gt;
; i0 u; r0 B- v: F/ N#include &lt;dplay8.h&gt;
#include &lt;dpaddr.h&gt;
#include &lt;dxerr8.h&gt;
5 }" y% _) {  S& M7 o#include "DXUtil.h"
1 h! Q3 o( a+ `% y: L/ I) Z1 \, k#include "MazeServer.h"
) x( L  r# _2 Y1 K2 J% `+ b#include "ackets.h"
5 Z! ?4 {$ K8 U4 Q#include "Maze.h"
8 ?% n3 C; ^+ D9 I* g#include &lt;malloc.h&gt;
- `% b$ p7 A- D1 C#include &lt;tchar.h&gt;</P>
+ m2 h# N  W. U7 Y( x
. i& Z- o# j$ g6 v6 |* C<>//-----------------------------------------------------------------------------
// Name:
// Desc:
1 ^( g3 }; D* o//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
  t' P2 o; ]. C* O; ~5 a$ r{
    m_dwPlayerCount         = 0;
$ Q9 |2 B; S2 S/ X   
- P! u4 X. t9 k/ i# v' R* a    m_wActiveThreadCount   = 0;
    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
    m_fMaxThreadTime       = 0;</P>
2 U; Q, Q+ i3 ~# Q7 a" g4 W<>    m_dwServerReliableRate  = 15;
0 M# j4 v/ c8 D    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
    m_pMaze                 = NULL;</P>
& m& D) N: W0 |<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
    m_ClientNetConfig.wTimeout       = 150;</P>
- q  o$ f0 ^8 }( c, {# T% w<>    m_ClientNetConfig.dwThreadWait = 0;</P>
1 S6 c) T9 W5 H# T# O<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
, m2 @/ B, s) q) O! M& D    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
! z" m7 Y- D3 j: x6 X- }    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
" \  u: B0 D* ]; W) F3 S    }
3 Q, U4 p1 h' {9 [# \8 j+ a: ]* [# @}</P>

<>
$ Q! {/ z: J5 k9 K/ _* p& a" ~5 S//-----------------------------------------------------------------------------
2 c  U4 b% g- Q0 P' }8 {// Name:
// Desc:
//-----------------------------------------------------------------------------
, P0 ^6 \* E: A( s/ z1 N9 l6 ]HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
2 f  a* r% A$ J4 k* B' [: i{
/ f. X0 ?6 B/ m% w+ @    m_bLocalLoopback = bLocalLoopback;
    m_pMaze = pMaze;
3 X- C: s* l6 P$ b" A    if( m_pMaze == NULL )
4 q" Q; o0 t7 E3 X- u' @7 ~6 H, s        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
1 S" \* u# ?1 C5 [<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
# H1 {3 {6 W6 {" W<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
8 t' [2 W9 ^9 e* ~    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 )
# x+ Y3 k8 F2 B: T4 R5 |' V( t5 p$ {        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
) ?3 m2 r. Z( r) {    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>
<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
# P. j* P. E, L5 s  C    m_dwMazeXShift = 0;
$ {. X4 ?8 ~6 K, @0 X    while ( (scale &gt;&gt;= 1) )
        m_dwMazeXShift++;</P>
9 H& q; o+ k5 w& b4 d; s& }0 j<>    scale = m_dwHeight / LOCK_GRID_SIZE;
2 y, H& x) r! p    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
% N2 l/ P" u: d8 |( M9 \        m_dwMazeYShift++;</P>
7 s: B# h' W2 j, X, 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>
4 m/ Y5 O. i( N$ J0 m<>    // Initialise the player list
# ?9 g  V7 U3 ]0 }    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
  h) Q7 b: M% U" [    m_pFirstActivePlayerData = NULL;
    m_pFirstFreePlayerData = m_PlayerDatas;
    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
( ^  b; @2 t! E' x- e5 C        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
    }</P>
<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
! Q7 D) s+ L, E$ u) E$ D  Q' X    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
6 z% f8 W) T, W1 D% r" }    m_dwActivePlayerDataCount = 0;
& v: W% d/ H# |. {7 w9 o; {    m_dwPlayerDataUniqueValue = 0;</P>
<>    // Initialise the cells
    ZeroMemory( m_Cells, sizeof(m_Cells) );
    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
* v, V" ?, F: o) a- {- ^! K) @: H; ^<>    return S_OK;
0 Z+ \5 ]7 F) o" r5 o" |+ R}</P>
& l$ e! K, Z: h, w0 r2 }
<>
6 y4 M% L9 O# G% U! Z0 m//-----------------------------------------------------------------------------
3 j. y: {) q6 @  R7 g$ o// Name:
// Desc:
% W$ E' ]# R6 m" x& u//-----------------------------------------------------------------------------
% G; h" g+ @$ qvoid CMazeServer::Shutdown()
7 J& d; @0 C; R( B. W4 ^{
}</P>
+ S0 Q! c1 E2 u/ k- i8 g0 w
" i% E4 \+ J6 q' _3 {/ B<>
) s  R! d  \9 H, h; T! X+ O* z//-----------------------------------------------------------------------------
" _& b6 W9 O, G+ @9 Z// Name:
// Desc:
/ W5 v6 b/ S% t+ `5 m//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
0 J6 ~" _: W4 P6 V{
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
/ e3 T# @& y' M8 D; v2 N+ a# o6 b/ K                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>
0 j* P. p3 D" Y0 B9 ?
2 e. w& x6 L' ?1 h% W: K/ G- l<>
& f. w+ e' J  ]$ S( [4 s2 I8 j//-----------------------------------------------------------------------------
1 j' O; o$ a" J3 S3 d1 J$ b. V// Name:
; y5 _. S3 w6 A2 I2 g4 V$ D// Desc:
//-----------------------------------------------------------------------------
5 d" C# t0 \/ Gvoid CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
; ^# E5 h* q& A                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
0 U6 J" }( Z# L) H}</P>
, ^8 ^% S, H1 x3 t+ T4 ?
<>
+ V7 L: U' ]' L! p1 ?) F//-----------------------------------------------------------------------------
0 W4 {7 q/ X! `% ?2 t( w1 M// Name:
( n' ]. B! @" v9 x6 @0 k// Desc:
+ O; j# [& [% X' ?1 _//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
; W3 @9 {" h( ?# C{
    if( x == 0xffff )
        m_OffMapLock.Enter();
    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
' W! L+ u! J8 ]. t8 `4 x}</P>
; j! y/ S  C# o6 S$ \9 K
; s6 e9 Q( l: @. C3 x' w  ^<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
3 j+ W! Y& O% ]) D$ @//-----------------------------------------------------------------------------
void CMazeServer::UnlockCell( DWORD x, DWORD y )
{
1 a# ^. N5 Z& w0 b: m( k    if( x == 0xffff )
        m_OffMapLock.Leave();
    else
, m0 n( \# g% [        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
4 q% R( J# O( [% C( E
" a. L; P% b6 C: n/ h<>
1 i! p! X) U+ d: S" o' a: H6 }//-----------------------------------------------------------------------------
( s+ v0 n+ w% G, B// Name:
// Desc:
" U9 C* B7 y: ~% d  X$ D) @! P//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
2 n! w, ]' J! y! {# f/ C    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
. U+ l  y4 y! G        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
        else
. f$ ^: i! x' X* T: ?            m_OffMapLock.Enter();</P>
+ \2 O) ^$ R2 _! p4 r# G% t<>        return;
    }</P>
<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
  y/ Z% O+ ?% C, s9 t" U# \/ ~/ h0 a% G    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<>    if( x1 == 0xffff )
    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x2shift,y2shift);
    }
. v4 f8 D' O* J    else if( x2 == 0xffff )
    {
% N9 b$ @/ X' v( }$ \+ b! @& `        m_OffMapLock.Enter();
7 S: @; b! t7 A9 k% i        m_LockGrid.LockCell(x1shift,y1shift);
" f, s2 D5 X% n3 N3 Y! i8 _* s0 F    }
    else
) P! U' b# J+ S& t! e' C, T; K1 f    {
. x- M* l9 E- U: |+ P  X; s        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
* i( Q6 J' d2 B3 w" n+ y! k    }
; G% S0 J. x$ x5 @' f}</P>
' D1 D2 U. i' \0 z  n
<>
, c5 F* L$ o  t! n2 L. n6 t, M//-----------------------------------------------------------------------------
+ \, P, i- q" w, u3 m: W: N// Name:
/ T4 J1 v: W* x3 O- q4 v% F. |: l9 P// Desc:
//-----------------------------------------------------------------------------
. X( N" n/ N; ]0 ]+ avoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
# o+ R5 {2 T9 T- r. J{
5 i% |  n: b! W2 C1 G9 ]    if( x1 == x2 &amp;&amp; y1 == y2 )
1 n% v6 i: j7 O. \7 j4 L0 a    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            UnlockCell( x1, y1 );
( D. ~+ ^1 r" ~( V; ^$ S# D        else
            m_OffMapLock.Leave();</P>
% f" G, ~: N) _0 W<>        return;
: t! z; b, f5 @1 |1 _9 }/ z    }</P>
<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
# S1 H, {) M5 M    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
* K3 K+ s: w7 f6 ?: H6 ^% Z    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
; B  `: Q: g- D" a# k6 G- D' s    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<P>    if( x1 == 0xffff )
    {
        m_LockGrid.UnlockCell(x2shift,y2shift);
% @- H$ k6 ^' \7 F2 F% [        m_OffMapLock.Leave();
# p& ~. F, f' {0 W9 W+ x7 M    }
! }9 A0 o5 M  a! B, Y7 [4 _% g' i    else if( x2 == 0xffff )
    {
        m_LockGrid.UnlockCell(x1shift,y1shift);
/ q' ]% O9 P$ ]7 J  E8 I4 Y        m_OffMapLock.Leave();
    }
    else
    {
: n1 \- C6 W+ L: ]- s7 F        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
3 u* b  y5 K, W6 p$ w0 u    }
, f% x* \' Y' H- Z5 s, m, P}</P>

1 t0 J9 m' \: T% w, f<P>
2 @9 P2 |3 k1 x6 L4 b6 P2 S: w+ \//-----------------------------------------------------------------------------
- Q1 T/ m' _1 w& {0 B; t7 Y- g// Name:
$ k, B" Q: z3 a$ }8 S// Desc:
0 F% C6 w! [7 D8 W//-----------------------------------------------------------------------------
void CMazeServer::OnAddConnection( DWORD id )
1 d. U+ a3 M0 a+ W/ T5 \, b; k5 F{
. P3 S6 R! J( w% P, K: G1 W; k    m_AddRemoveLock.Enter();</P>
<P>    // Increment our count of players
    m_dwPlayerCount++;
  s$ W/ F- S; o/ ~% O    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
! U/ C- |" @5 R, j        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
: E1 [, S! u2 Q9 E, }9 `* v<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
* I$ r/ i; r) o- H4 c        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
# K% F! c* w# d( t0 }; w& {<P>    // Create a player for this client
    PlayerData* pPlayerData = CreatePlayerData();
    if( pPlayerData == NULL )
/ a2 {: \) z& T6 S    {
3 k& v5 N& N$ J4 ^7 v2 V) t1 T% [+ R9 C        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
, m6 g# ^' b5 R# G        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
        m_AddRemoveLock.Leave();
        return;
    }</P>
<P>    // Store that pointer as local player data
* }/ l1 v) B; K- q- I    SetPlayerDataForID( id, pPlayerData );</P>
1 ~6 a4 E6 t9 q/ j<P>    // Grab net config into to send to client
' L8 @4 q% y1 E  H3 v9 p6 _    m_ClientNetConfigLock.Enter();
. B$ g3 L* X2 O6 M9 b    ServerConfigPacket packet( m_ClientNetConfig );
/ h* s0 i  {  y; q1 k    m_ClientNetConfigLock.Leave();</P>
7 E0 [9 L( k4 b, ]$ ~$ D<P>    // Send it
    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
<P>    m_AddRemoveLock.Leave();
}</P>
* l  w- p: V( E7 V! C  V& p, V
3 a. t, L8 X$ Y  b# e<P>
! I& {3 P" ]3 [: ^//-----------------------------------------------------------------------------
# h2 A7 Z/ c8 F// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::OnRemoveConnection( DWORD id )
- m# U% P. c3 a8 Y0 ]{
; T2 V5 W  L. B/ c6 X0 G1 m    m_AddRemoveLock.Enter();</P>
; k9 L: \- M* }<P>    // Decrement count of players
    m_dwPlayerCount--;</P>
4 y* J/ @' B+ T  e# |# H: b! B<P>    if( m_dwLogLevel &gt; 0 )
  r3 E9 {: p7 z9 ~  i) Y: J. N* c    {
. e& y$ P8 b5 G  P" i        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
0 D& m1 ]2 Q1 L    }</P>
2 j/ v. F) X5 G( S<P>    // Find playerdata for this client
- V% t: a0 i% |, p: P    PlayerData* pPlayerData = GetPlayerDataForID( id );
    if( pPlayerData != NULL )
    {
        // Destroy it
0 M$ a% w, f2 D" z% w0 s# |* u        RemovePlayerDataID( pPlayerData );
! H# ^" B1 E3 ?        DestroyPlayerData( pPlayerData );
    }</P>
<P>    m_AddRemoveLock.Leave();
/ n1 v* ^4 _7 }; c}</P>
" O; i/ }1 S9 ^
<P>
$ ]) w+ `: _( I% Z5 G: c//-----------------------------------------------------------------------------
// Name:
// Desc:
2 W0 o, C. P9 ]( Z& T) G& y//-----------------------------------------------------------------------------
HRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
  }) z+ E7 [* M% e4 C$ c. H& E{
    BOOL fFoundSize = FALSE;</P>
<P>    // Increment the number of thread we have in this process.
* T1 U: }$ p6 p5 [    m_csThreadCountLock.Enter();</P>
<P>    //Get the start time of when we entered the message handler.
    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
<P>    m_wActiveThreadCount++;
    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
1 ~- i2 E) t6 `        m_wMaxThreadCount = m_wActiveThreadCount;
   
' j% {+ I; R- I' O0 j3 B" G    // Calculate and average.
  L8 r7 q( m8 a* w6 |    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
' u! K/ T7 B1 n; v    m_fAvgThreadCount += fdiff/32;
) Y/ h" ~( X9 s& c5 N; w; x9 Q6 k   
3 [. [; q2 @7 j    m_csThreadCountLock.Leave();</P>
. _, H' M9 z" T, H+ |<P>
7 ]) J9 Z  X0 r) z    ClientPacket* pClientPack = (ClientPacket*)pData;
% l0 U6 u# M: ~6 r    switch( pClientPack-&gt;wType )
    {
        case PACKETTYPE_CLIENT_POS:
' \7 x8 R' E) E4 x. t8 k, {# n. U            
# u' M8 }. }+ E4 k            // Check to see if the packet has a valid size. Including
            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
                fFoundSize = FALSE;
            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
                fFoundSize = FALSE;
            else
# Z$ |. @. b6 c) ?0 F                fFoundSize = TRUE;</P>
<P>            // If valid sized packet, handle the position.
            if(fFoundSize)
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
            else
1 n5 l* H0 S; i                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
1 ]7 l; Y& n3 {" v3 ]) t<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
            if( size == sizeof(ClientVersionPacket) )
                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
            else
$ F. @+ r  {$ i; V. V" `                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
            break;</P>
$ y. g4 T/ d- h& L3 g0 c  k  U<P>        case PACKETTYPE_SERVER_CONFIG:</P>
0 }2 U7 I* w$ k1 |0 f<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
, v  K# q4 v( c3 q: |, l0 S# Y<P>            break;
        default:
9 b* ]. X6 P; W5 }0 ]; X/ W1 P3 f            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
    }</P>
<P>    //If the user wants to hold the thread, Sleep for given amount of time.
    if ( m_dwServerThreadWait &gt; 0 )
9 u' X% D9 i+ f: h- F0 W9 ^2 J    {
  m+ P! |1 |" G" D( @        Sleep( m_dwServerThreadWait );
    }
# }& S. L& Q; Y+ ?' l# V   
9 a! c( J# ?  f$ h( ?4 v, D6 X    // Retrieve thread data for this process.
( e  b5 k0 o$ N$ t% l8 l) @    m_csThreadCountLock.Enter();</P>
<P>    m_wActiveThreadCount--;</P>
1 S, `6 P; ~. U( O7 G5 |+ B  u<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
    m_fAvgThreadTime += fDiffTime/32;</P>
: X! H2 k8 Y* v& h3 w, v<P>    //Get the Max time in the thread.
    if ( fDiffTime &gt; m_fMaxThreadTime )
# h2 H$ o/ @7 S    {
- H( H8 X( G0 P5 B; Y, i        m_fMaxThreadTime = fDiffTime;
' G! p7 o3 O/ }$ T# c    }</P>
- m9 `, d9 G% o/ H7 Y<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
}</P>
* U" `2 I$ L! f5 n4 V
<P>//-----------------------------------------------------------------------------
// Name:
7 I, s2 s0 ]) x- o// Desc:
//-----------------------------------------------------------------------------
% I1 Y8 ]2 S& I- T! kBOOL CMazeServer::IsValidPackSize( DWORD dwSize )
6 Q. N- {# W9 e/ v{
    BOOL fFoundSize = FALSE;
- V/ J- G! m8 z$ \% l. a    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
   
    // Check through the array of valid pack sizes.
2 \8 C) ]! s  _- G% X5 y( v. f6 |    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
+ ]# ^# ~) P' p1 M2 I        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
% i* @4 u/ P' h0 `3 C0 \4 J7 ?% Z        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
            {
                // Found valid size in the array.
                fFoundSize = TRUE;
  U# C. X- H9 N* N                break;
            }
            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
        }
: t# l* x- P( X9 S' A) N( v* F4 B    }
    else
    {
3 u* i7 ?. D7 g' r        fFoundSize = TRUE;
    }</P>
<P>    return fFoundSize;
}</P>
<P>
//-----------------------------------------------------------------------------
) l' z  ?- `* p9 d// Name:
// Desc:
+ s% s9 \( ]1 W) G+ Y9 G//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
4 u9 Q* |8 D( j{
5 {& V) Q: b4 X( |2 H    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
}</P>

3 D5 X( B$ r1 T- R4 X1 G! c<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
& R( `% v- E3 r" O. A) u, b+ E//-----------------------------------------------------------------------------
PlayerData* CMazeServer::CreatePlayerData()
{
1 `# P: E, F, t2 D& w; R    m_PlayerDataListLock.Enter();</P>
& W1 D, U1 o  i9 t+ c<P>    // Grab first free player in the list
% {7 S3 n  e  j1 X) f  L5 y    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
" n: q8 Q2 ?6 C6 Z<P>    if( pPlayerData )
2 z; Q" ]1 }) {0 A8 e5 U6 m" V    {
' V9 K" }' m- f. r3 {        LockPlayerData( pPlayerData );</P>
<P>        // Got one, so remove it from the free list
        if( pPlayerData-&gt;pPrevious )
$ Z7 R0 ]9 \: I5 E  O            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
        if( pPlayerData-&gt;pNext )
* H( H' K$ e2 E! t            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
5 A# _/ ^" K/ a# f. D: P$ r9 P        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
" X1 K, k! B, ?. d3 W5 {9 X<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
3 |+ d0 t  P+ y8 O1 i! x        pPlayerData-&gt;pPrevious = NULL;
& A% C, |( ]! |, V4 H% \2 d) ]( _        m_pFirstActivePlayerData = pPlayerData;</P>
% U4 S6 P& V( G" ?, N3 H3 G5 y7 o<P>        // Update count of players
, P( _0 J) ]! B        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
1 V+ s8 H! k/ h        m_dwPlayerDataUniqueValue++;
        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
0 ^* E0 h( n7 S  m. O1 G+ k<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
8 S8 U% w+ L$ `3 s        pPlayerData-&gt;NetID = 0;
        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
<P>        // Insert into the "off-map" cell
        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
; r1 O. f4 z5 h* B        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
* X+ ~5 C. G9 e$ h        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
: j9 w5 j7 [7 n$ O& V+ C        m_OffMapCell.pFirstPlayerData = pPlayerData;
6 a: k4 o; d* {' y7 J        m_OffMapLock.Leave();</P>
' a+ w2 X: P: J, f9 C# o* E<P>        // Mark as active
9 m4 b" f- Q6 Z        pPlayerData-&gt;bActive = TRUE;</P>
4 X8 b8 a% Q' F: ]+ J* I* W1 t! S+ e- [<P>        UnlockPlayerData( pPlayerData );
  ?; C$ t! U$ w4 l" y) m    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
) Q5 G' g( d% b) S% N, }<P>    return pPlayerData;
# o+ {+ H  B# I1 T}</P>

, c2 I, i4 _7 i1 t5 d$ Q<P>
. K" ^+ i. ?! J* n+ N//-----------------------------------------------------------------------------
: X! t5 f3 f! b( S6 `& o2 F% F// Name:
: z2 n3 j, A0 Y- r  D# z6 N! Q! l// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
{
    m_PlayerDataListLock.Enter();
    LockPlayerData( pPlayerData );</P>
& Q) W1 M/ T! `<P>    // Remove the player from its cell
6 ]9 H2 Y$ V, s    RemovePlayerDataFromCell( pPlayerData );</P>
1 o, {) K! m1 M- u" d  V<P>    // Mark as inactive
    pPlayerData-&gt;bActive = FALSE;</P>
<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
' q  i: B6 i7 d$ y8 ^        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
4 t% E+ h* J8 h% G" J    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
<P>    if( m_pFirstActivePlayerData == pPlayerData )
        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
4 G. Y8 D! q' {2 [6 d% t7 J    pPlayerData-&gt;pPrevious = NULL;
! w! N/ S. X3 E" _7 r% z3 p* ?3 B    m_pFirstFreePlayerData = pPlayerData;</P>
<P>    // Update count of players
    m_dwActivePlayerDataCount--;</P>
2 B9 P8 Y, U4 J: ^1 R3 q<P>    UnlockPlayerData( pPlayerData );
    m_PlayerDataListLock.Leave();
}</P>
& ~" Y8 G/ d. N
<P>
//-----------------------------------------------------------------------------
: Q; N6 e+ M8 C% y1 G/ Z1 J! b// Name:
// Desc:
( N8 ~/ u0 d" Q7 {8 `# A//-----------------------------------------------------------------------------
/ A. P, E, h: |, a+ [! R3 Rvoid CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
/ E$ n0 h! O" `$ _{
8 p5 r6 k9 q- A$ B    // Lock the player
    LockPlayerData( pPlayerData );</P>
- f1 d; M" \# W8 e<P>    // Lock the cell the player is in
% J7 e3 [- W7 g0 M7 `& ?* P; r    ServerCell* pCell;
    if( pPlayerData-&gt;wCellX == 0xffff )
# M) J  Z$ d+ ^0 [    {
0 D" s' L0 P* X( P& Z3 f        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
$ B5 D8 f' O8 A' m; K8 z    }
$ l3 N1 G) A5 O9 F$ D    else
    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
! C( f1 N* V; I# }2 L5 J    }</P>
1 F/ w* x) ?- w$ j, r7 O+ C# G. ?<P>    // Remove it from the cell
1 {: U  `" `3 x    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
    while ( pPt )
- }# E/ [; w) ?7 \    {
& e& o6 e$ ]; u% E        if( pPt == pPlayerData )
        {
/ [6 t+ d" E  S7 _7 i( E0 b; X            if( pPrev )
) J6 T! @9 B' k- @                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
0 T6 r* }0 U4 [            else
/ [! [1 c3 i+ F' n1 \- }3 t/ ~5 T                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
( ?0 H! E" m1 N3 E<P>            pPlayerData-&gt;pNextInCell = NULL;
8 ~  n# B1 i1 ^8 N+ A) P3 J. w& t            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }</P>
<P>    // Unlock the cell
    if( pPlayerData-&gt;wCellX == 0xffff )
' I0 V! ?6 E. j8 f        m_OffMapLock.Leave();
$ e: i9 m. _# k* \& P; l0 x    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
3 [2 x1 ~* |% h5 v; b7 Y<P>    // Unlock the player
  J7 P. ~. ?! N. u! k# Y1 Z6 z    UnlockPlayerData( pPlayerData );
" j. Y# p( e, Y+ `! @% q}</P>

<P>
' l/ E6 B4 \4 e//-----------------------------------------------------------------------------
5 x2 \5 C. S, e3 k// Name:
; `0 d! O" j/ L1 y// Desc:
//-----------------------------------------------------------------------------
) m+ E! m1 _) ?! i' }# M- P0 Tvoid CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
{
    ServerCell* pCell = GetCell( pPlayerData );
$ O7 U5 ]& [: z    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
' j2 s, H5 {1 X5 N1 w- [% B% s    PlayerData* pPrev = NULL;
    while ( pPt )
    {
        if( pPt == pPlayerData )
        {
1 ^  x9 l' Y) C2 s% d5 M            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
! u8 i" h# z6 I1 C- e# ~6 w( J/ d            else
/ v1 m( x: j2 E  a                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
3 p) [/ h4 e. m2 K            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
        pPrev = pPt;
! e/ E- q1 H/ Y  j1 p        pPt = pPt-&gt;pNextInCell;
, U2 f3 N( e* j    }
}</P>
' X) W% X8 ]' F7 k
0 t1 g, o( k: h0 i<P>
' ~. ~9 |  U+ B: o9 S0 d0 |/ U//-----------------------------------------------------------------------------
// Name:
" {' _- a5 e2 _* ?- ^# D// Desc:
+ a- Y- s) H/ Y6 Q//-----------------------------------------------------------------------------
void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
% u  k- W. X$ E( L' s5 g" ~    pCell-&gt;pFirstPlayerData = pPlayerData;
/ @2 a6 ]: W8 u& o1 {$ F- J}</P>

% D/ \" L/ H  w' P<P>
. F* x) h( `( }  U* Q- a//-----------------------------------------------------------------------------
// Name:
+ ~( x; g( ^& |. Z$ b// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
    // Grab player for this client and lock it
0 k+ z/ J3 z, V/ |/ O6 Q# P    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
    {
        if( m_dwLogLevel &gt; 1 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
        return;
    }</P>
: S# n, T* u. u" ?<P>    LockPlayerData( pFromPlayer );</P>
) B* h$ n: S3 t<P>    if( FALSE == pFromPlayer-&gt;bAllow )
+ Y9 l1 p' B# w7 }& n- x4 b2 W& _    {
        if( m_dwLogLevel &gt; 0 )
: G  c: y  z- f+ Q8 ]0 v            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;
' F  n( x% g# i" d    }</P>
<P>    // Compute the cell the player should be in now
( F6 H1 i6 w* y* a& `    DWORD newcellx = int(pClientPosPack-&gt;fX);
    DWORD newcelly = int(pClientPosPack-&gt;fY);
    DWORD oldcellx = pFromPlayer-&gt;wCellX;
    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
, d+ N0 i$ M$ a3 m<P>    // Have we moved cell?
    if( newcellx != oldcellx || newcelly != oldcelly )
& B3 L& \0 w$ I; J0 R    {
        // Yes, so lock the pair of cells in question
! ?2 @2 e+ b9 M        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
8 I( l3 Y/ X7 @2 ?# }5 y: ]& q<P>        // Remove from old cell and add to new cell
        UnsafeRemovePlayerDataFromCell( pFromPlayer );
2 ?. P% A0 h# P$ @$ Y: Z4 O        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
, h2 R- J6 M% {) P& C. [        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
<P>    // Update player position
5 h% K! S8 g5 {' b: Y    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
    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
) d' E6 d; Z6 M" c    DWORD dwAllocSize;
    ServerAckPacket* pSvrAckPack = NULL;</P>
4 N. M! Q. Q, K4 K<P>    // Begin by allocating a buffer sized according to
    // the current number of nearby players + 4.  This will give
. p, E/ B8 J- A: n    // a little room for more players to come 'near' without resize
+ t) _$ y1 A3 h    // the buffer.
    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
6 a1 ]6 ]# j0 C: K8 h4 P    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
4 c4 w- O: h0 Q, C! W4 i    if( NULL == pSvrAckPack )
+ w$ t' H& W* _9 O2 B' u) Y    {
2 H. V) Z- E8 _, B: [        // Out of mem.  Cleanup and return
        UnlockPlayerData( pFromPlayer );
9 ]+ P$ ~* k6 N& o9 X( G" [        return;      
! E0 }! G. v2 _. @* y0 ]1 a    }
! n5 ~$ W$ S2 J- d! u    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
  Q' f. W  z# V' ^    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
, V8 y* z7 O/ Z* H+ H) T% P    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
' D) b2 A4 N" D3 y% N1 w    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
<P>    // Lock that range of cells
    LockRange( minx, miny, maxx, maxy );</P>
. J2 q5 E+ b$ Y! @+ j; B, d7 {% ~<P>    // Scan through the cells, tagging player data onto the end of
    // our pSvrAckPacket until we run out of room
% L- H7 g& f/ o. y5 G  y! j    for( DWORD y = miny; y &lt;= maxy; y++ )
    {
- Y1 S$ B, S5 N' s$ {! H8 Y: I; j        for( DWORD x = minx; x &lt;= maxx; x++ )
        {
4 v6 [5 `2 G/ ?" U( j            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
            while ( pCurPlayerData )
            {
' x5 z* f$ s5 U6 I" b) g                if( pCurPlayerData != pFromPlayer )
, S- x" A' b2 L9 F5 w: g                {
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
, q* C4 [! Q% x                    {
                        // Make sure pChunk is where we think it is
: C+ B3 \- Y6 V                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
( f5 o) d. H) L. m<P>                        // There are more than just 4 new nearby players, so resize the
: E; \/ X& r. B  O                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
                        dwMaxPlayerStatePackets += 16;
                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
5 i! V  m1 K! R; e                        if( NULL == pNewSvrAckPack )
% D, {" b  \6 t, d2 S; S, T                        {
  o9 k. U6 x9 u                            // Out of mem.  Cleanup and return
0 A2 a* ^/ Z: ]/ ]/ O                            free( pSvrAckPack );
                            UnlockRange( minx, miny, maxx, maxy );
$ P: g6 z% K' s! H( {9 s                            UnlockPlayerData( pFromPlayer );
1 U: \7 y; e+ h" W' p2 ]                            return;      
$ F% c* Y" i6 J0 X. ]- u                        }</P>
5 X: y, {+ a" [1 a<P>                        pSvrAckPack = pNewSvrAckPack;
& o/ z3 G) ]5 E7 h. @+ C6 y                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
<P>                        // Make sure pChunk is still where its supposed to be
. l1 T& b" q! s. Z$ O# U                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
- P$ s" P7 Y  |  ~+ ]                    }</P>
1 c" V" C1 W8 A2 i<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
! H7 ?: B+ C7 C+ J- x# i. h                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
$ T9 `8 w5 T( ^8 F* s' z7 }" V                    pChunk++;
                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
& w8 b' j- ^, r# N: a            }
        }
    }</P>
2 v7 h! W( h2 X+ N6 Y. R<P>    // Update the dwNumNearbyPlayers for this player
/ o" r" t5 L6 x! U! c' s# w    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
<P>    // Unlock range of cells
    UnlockRange( minx, miny, maxx, maxy );</P>
# m# ^3 _, }8 i<P>    if( m_dwLogLevel &gt; 2 )
4 T. L$ A  J& Y# K4 z  X    {
        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 )
4 v' o4 ^* b4 f$ D# J  L/ Q+ O    {
  q5 X- H% i& j' b( H* H* j+ H& e        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
  [/ ~: F0 |+ j( r5 S& F        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
+ _0 \$ J% N5 M/ c! [9 E& U0 Q        {
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
            pFromPlayer-&gt;fLastDisplayTime = fTime;
        }
    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
2 @4 N5 d; z) A! a0 J<P>    // Send acknowledgement back to client, including list of nearby players
    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));
: `+ F# j. P% M! f* I: E/ v
    // Pack the buffer with dummy data.
$ m' X1 X8 e+ x2 M" u; U) @: g    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
; s9 B$ E, j/ G4 w: P        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
        VOID*   pTempBuffer = 0;</P>
8 T0 o. L9 e- L! T% u7 Q<P>        pTempBuffer = malloc(dwBufferSize);
        if( NULL == pTempBuffer )
' }3 c6 Z4 Y0 g; [        {
% k( h8 A2 B0 Z0 t7 A& w' r            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
            free( pSvrAckPack );
3 t# s5 t3 L' a" A+ k7 L            return;
        }</P>
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
& H5 q: b6 x8 s. Y' _5 n        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
( m4 C# M; M3 s  R   
* i; H! Z# v. ~        free(pTempBuffer);
) z$ i5 {  ]' Y2 j# @$ y    }   
! X# i* J) C. R2 |    else
! A6 I" d8 F- G; ?* y0 D/ J    {
! u, @% D0 w, i1 F- j# X        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
    }</P>
<P>    free( pSvrAckPack );</P>
<P>}</P>

# b6 U4 Q- W0 x6 ?% c" E9 w<P>
//-----------------------------------------------------------------------------
// Name:
" J, \9 l% T: q! `- a* ]// Desc:
//-----------------------------------------------------------------------------
2 F% R' j; p: T& F5 I  y& P2 Cvoid CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
    if( pPlayerData == NULL )
, w* p* Q& s' r        return;
    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
- f2 G& Y6 p  P6 D    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
# I3 I8 N+ [" m<P>    if( m_bLocalLoopback )
0 m' w" h( x5 j        pPlayerData-&gt;bAllow = TRUE;
    else
        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
* z3 D/ O4 \2 T) L. q<P>    if( m_dwLogLevel &gt; 0 )
$ O# j: Q$ o$ H  n1 {" @        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 )
2 z+ X4 J  n( i. b9 U/ O. m    {
' j: c* S3 D, Y        if( m_dwLogLevel &gt; 0 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>
* x2 ]- }# Q1 y* U9 _! t<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pPlayerData );
; `  k6 |. }: c! N        return;
8 H, ]  ]2 O, w, {( a5 w    }</P>
<P>    // Unlock the playerdata
) s! \! P5 E+ c3 d# t( q; q    UnlockPlayerData( pPlayerData );</P>
) Y( l2 j- d6 Y. k" A1 J<P>    // Send acknowledgement to client that the client was either accepted or rejected
: R, n/ M& a" B/ ^3 V# P/ P    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
5 C+ }! a) x9 k/ ]! ~* C}</P>
! p6 n2 J. q- k" m
7 G- J9 d5 t5 l0 u+ I1 q<P>
//-----------------------------------------------------------------------------
// Name:
0 d( W7 F6 ], n9 O* K0 p- t! o// Desc:
) f7 g$ o6 C! e//-----------------------------------------------------------------------------
" e4 p7 J7 C  o  w- W! ]5 `BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
{
    switch( dwClientVersion )
( D* S$ ]. l& O( B5 s    {
& y' o! t, p2 `8 D        case 107: // only v107 is supported
$ n, c% @( e2 p% ~" I% f" R            return TRUE;
        default:
            return FALSE;
    }
}</P>
4 @( z* B2 g0 t9 j
<P>
//-----------------------------------------------------------------------------
, I& P- ?# X8 P& d2 X// Name:
5 y7 O- F; H. ^: N! E$ }. A9 X// Desc:
& Q& K. J6 m" O. ]" n//-----------------------------------------------------------------------------
1 o4 O3 N3 b- i/ Bvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
{
: h) E! y5 s/ b* b    if( m_dwLogLevel &gt; 1 )
3 L! S6 g7 x, }- O$ {. F! d        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>
5 X# ]9 G, e9 V# W' L4 k+ Z9 k2 s
<P>
. K& w' A4 Z7 a" C8 ^, w- Z  ^//-----------------------------------------------------------------------------
. z# C' I1 ]: l// Name:
// Desc:
9 U  p, |/ m" a//-----------------------------------------------------------------------------
% H' a1 t: G! ODWORD   CMazeServer::IDHash( DWORD id )
1 ~( n# @/ E( a{
+ h/ x- A) t1 K    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
; r8 }% u$ f" [3 t    return hash;
}</P>

( i6 t0 E7 }7 U& ^# E7 `<P>
, c* f- }+ u0 S- ^. a: o//-----------------------------------------------------------------------------
// Name:
( ]+ O3 n4 n! H2 a+ Y// Desc:
% m6 b% J+ H" i+ J5 H//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
{
2 R+ l7 K: f4 h& U) j9 O    // Hash the ID to a bucket number
4 K, C6 Z: j2 Q  l( v- f; I6 C: W: C    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
7 F  j) }( d5 O! c7 _# j% J9 c<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPt = m_pstIDHashBucket[bucket];
    PlayerData* pPrev = NULL;
) j0 n. ^% [* S) F    while( pPt )
7 H! G! `8 L" R, a$ ^' A0 k    {
        if( pPt == pPlayerData )
            break;
        pPrev = pPt;
        pPt = pPt-&gt;pNextInIDHashBucket;
% z2 X0 f/ Q" u" R, V1 v7 L% Y    }</P>
* g& j+ c5 `+ X2 h* A+ h<P>    if( pPt )
    {
        if( pPrev )
- u* y8 u7 ~- J# o: f+ y( S$ M            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
# q- F* e8 ~* I- }4 m- @' x) N        else
            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
        pPt-&gt;pNextInIDHashBucket = NULL;
; X; F% |; ?' ~. j  T: g' q    }</P>
% O0 a, F/ m7 [( d2 J<P>    // Unlock the hash bucket
2 _# i/ b9 n" X3 s9 ~    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
3 F, Q+ n, r9 [' I( t2 Y}</P>
6 }5 U5 N+ ?" g! A
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
& ]* k4 U/ s) G) g( G0 [( j$ M//-----------------------------------------------------------------------------
7 _7 `: |: U% S9 ~void CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
{
4 F7 x1 ~7 K8 n3 m6 x    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
& h) A% w3 W/ F3 ^( @* y* o. J2 Y    // otherwise there will be a circular reference
4 c! Q! w) z: D- y, c    PlayerData* pSearch = GetPlayerDataForID( id );
7 A- Y6 H4 w' S1 S    if( pSearch != NULL )
' p, u) M0 b, {2 ~$ e3 X        return;</P>
* a; q# [9 A" s, E6 ~<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;
/ J' M2 B) t. I  ^. T1 b# ?1 f    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Add player onto hash bucket chain
( t5 O; p" n+ j6 _# V    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
# _. n5 b8 t$ E, X' M2 L    m_pstIDHashBucket[bucket] = pPlayerData;</P>
4 I! T/ Q; s  p/ D2 p7 {& Z8 O<P>    // Store net id in player
0 W  ]. W3 t( w% f6 j: @, ^0 j    pPlayerData-&gt;NetID = id;</P>
/ r) ~' P' Z4 q& @  ~<P>    // Unlock the hash bucket
; _* v2 u3 f$ U' L' F3 w    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>

( m+ f& P  `$ Y+ {<P>
! f& \! i7 W# R$ ?. q7 j9 Q9 O+ j& A. p//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
  @' g9 C/ ~+ x6 }PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
{
, ~+ D, J" n- E) E0 E    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
' ~& P/ P) m  z9 W+ `# z    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
6 [+ ^# _6 @9 F9 W+ Y<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
; V2 e0 P, l" y2 c    while ( pPlayerData )
    {
* x+ Y* f7 P" k( o0 L  Q7 D        if( pPlayerData-&gt;NetID == id )
' v8 ~: i# ?2 I0 v! \# O: G- L            break;
        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
5 p9 a0 }: U% ?3 n0 a    }</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
<P>    // Return the player we found (will be NULL if we couldn't find it)
  C8 ]% r# Y6 R# f1 o5 ~    return pPlayerData;
}</P>

6 Q8 s0 ?" k8 \' a: L- S( _( F! U<P>
//-----------------------------------------------------------------------------
// Name:
" h& X( N9 M: N' E: o// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
& f2 p7 A$ m6 }& \7 u: x# b//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
9 i/ |8 W2 M0 [  w; V! t{
    if( m_pNet )
    {
: Z/ s- d* \: p        // Find the player that was displayed the longest time ago, and display it.
1 M, T1 v& a" ^        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
        PlayerData* pOldestPlayerData = NULL;
: [, W7 p( D0 ^- D1 U4 H        FLOAT fOldestTime = 0.0f;</P>
) z* Z% ]% l2 n) |0 r<P>        m_PlayerDataListLock.Enter();</P>
) n  E4 Z/ E" @& m5 K- ~" a; m<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
  ?' O) V, m- s" g. o        while ( pPlayerData )
        {
            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
1 g: U! r8 e" Z( x4 ^            {
" I9 P* l& @2 |2 d/ }( x( v) m                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
                pOldestPlayerData = pPlayerData;
# l8 ~: o# }' |4 S! f6 n, p            }</P>
, x% n( n! P& ?2 a<P>            pPlayerData = pPlayerData-&gt;pNext;
9 t' N. E: j& [+ h9 y6 _1 z        }</P>
: H+ c5 e2 Y: M/ S- t: A<P>        // Display the player with the oldest CI field, and update its CI field.
" ^* S, H4 ^/ z4 q/ o" u0 H2 K) A6 f        if( pOldestPlayerData )
        {
            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
( I+ _6 p1 `* x. c            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
            pOldestPlayerData-&gt;fLastCITime = fCurTime;
# a& e1 |# e7 m9 B7 V, o/ {# y2 ]        }
6 F; b/ A; d0 S        else
) \) s. p' Y8 j, q        {
, N( P5 V0 R4 `+ M4 s* m            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
        }</P>
<P>        m_PlayerDataListLock.Leave();
  C2 u$ K3 x" \    }
" G* f8 _: q7 g. A7 M2 E* S. n}</P>
1 g* g! l7 @/ j1 I1 y+ Y8 x1 [
) P7 w: u, `: R- m$ A<P>
# Y" S# C1 _* Z2 b1 A2 B//-----------------------------------------------------------------------------
// Name:
* J+ Z" H$ F) v7 K) }. m// Desc:
//-----------------------------------------------------------------------------
+ S4 N. M+ I) o3 {: p: p/ Kvoid CMazeServer:rintStats()
{
3 X  P( s$ H/ f; ~5 q) S- U    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
) |% ^3 Y& ]/ W! y. F! {/ H                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
                                    m_fAvgThreadTime, m_fMaxThreadTime );
1 v# S1 W  u( r/ H! n+ @    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
. h5 d3 s7 e1 V, b* l1 T}</P>
' |; c& ?" i" |2 u9 n
" L. X9 S9 {$ B5 P% m) D8 U7 l<P>
! i. s9 ~1 E5 T5 s/ b" n: T  Y, A9 v//-----------------------------------------------------------------------------
5 H6 C7 X/ N5 k// Name:
2 S2 \8 q# b( \  M2 Q// Desc:
  W; Y+ H) a  n9 a//-----------------------------------------------------------------------------
/ W  p+ o! e. A. ~void CMazeServer:isplayConnectionInfo( DWORD dwID )
) I4 S* f+ g/ @  k( f{
    TCHAR strInfo[5000];
6 V& \* ~. J; \# s. O    TCHAR* strEndOfLine;
; C" z( O6 D" H0 Y3 E8 p; a# u, ?    TCHAR* strStartOfLine;</P>
<P>    // Query the IOutboudNet for info about the connection to this user
4 I: ^, Z! V, M  n    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
+ c. X. t2 f- g  M. u! a<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>
6 w9 J9 U3 T& m0 @# C6 x" o<P>    // Display each line seperately
    strStartOfLine = strInfo;
) I; q' l6 l1 Q: A& a& g% T% r    while( TRUE )
    {
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
1 E% `# k  @; P: T! y- v        if( strEndOfLine == NULL )
) _& g2 S5 P$ H            break;</P>
* M- j; T) M# T' H( P6 F" f<P>        *strEndOfLine = 0;
& `1 Z, c" z2 u4 f        ConsolePrintf( SLINE_LOG, strStartOfLine );
% Z7 r% D: K% }        strStartOfLine = strEndOfLine + 1;
    }
}</P>

) ~. Y3 y$ \& ?( w<P>
. d' F( {0 g3 O8 G8 P//-----------------------------------------------------------------------------
/ |# z+ G( I: r" J$ }// Name:
% b3 Q* N' h1 @) x// Desc:
7 C" ?3 I' ]7 B6 O9 Z  q5 F0 Y//-----------------------------------------------------------------------------
HRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
! _1 C1 z# a  M' G. Q" W{
    // Chance of forcing any packet to be delivered reliably
( \/ ~: _6 m! ^# A2 z+ d    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
0 Z! u+ `) f& G1 |9 Z% y        reliable = TRUE;</P>
# ~0 d) X7 a2 W7 E<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
}</P>

<P>
0 l/ ^5 C$ U* f6 p7 \! _. ]2 ?//-----------------------------------------------------------------------------
// Name:
1 L" F! C* t1 q. @  Y( Y( P9 T// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
! ]+ g9 s6 @5 U  u1 X3 f% v1 Q3 e    // If we're up and running, then send this new information to all clients
8 b+ f0 Y) l, C6 G! M. G    if( m_pNet )
6 k3 V- ~3 k: ]0 _    {
, R; w1 s1 v( g1 t        //Use the AllPlayers ID
        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
) J$ P0 I% R3 o}</P>

8 A" Q6 g" ?6 @8 `/ E( ~<P>
; c' R5 D: u% z9 O//-----------------------------------------------------------------------------
// Name:
1 R/ }3 E. Z- w! c// Desc:
//-----------------------------------------------------------------------------
3 c, C) L2 @/ U9 Cvoid CMazeServer::SetClientReliableRate( DWORD percent )
{
1 \0 R9 }- h! ?3 O' m9 |5 E3 T( `    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
8 u, `" K4 N& `    m_ClientNetConfig.ubReliableRate = BYTE(percent);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
& t. Z7 Y0 H% O$ p$ P6 S( U1 z<P>    SendConfigPacketToAll( &amp;packet );
% `3 \8 E; l0 j  w}</P>
2 n1 m' V6 v) Q) s2 f& B
<P>
* F5 P* b" m% y9 [7 _2 R, h! h) E" G//-----------------------------------------------------------------------------
6 f9 {0 P& c$ g/ G9 \// Name:
// Desc:
, u8 E5 h4 q3 `* R//-----------------------------------------------------------------------------
6 a2 i3 c$ [8 b$ mvoid CMazeServer::SetClientUpdateRate( DWORD rate )
{
* q% g( ~+ k& a( l8 }    // Update client config, and build packet containing that data
. n9 u- b; O1 C9 I( w9 H* P/ c. d    m_ClientNetConfigLock.Enter();
* P# c' }4 b% j4 _" |, ~    m_ClientNetConfig.wUpdateRate = WORD(rate);
0 r$ n2 S" f% ~0 t& \2 c- H! b    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

5 X( G+ i! z( G, }( Y9 F<P>
& ]! L2 m( E! Y" p//-----------------------------------------------------------------------------
: y- H& v8 k. z  k// Name:
// Desc:
7 t1 U2 h) F  x' i# w5 L$ [//-----------------------------------------------------------------------------
void CMazeServer::SetClientTimeout( DWORD timeout )
7 @2 Y' v1 `; [, R* T' B1 V{
6 T1 X+ Z* {' R1 O    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wTimeout = WORD(timeout);
) u8 Z: F$ a! l9 A+ x6 X) w& C    ServerConfigPacket  packet( m_ClientNetConfig );
* s) D2 [- r: p    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
5 ?0 ^+ Q- b) T. j: d6 J3 J1 B// Desc:
//-----------------------------------------------------------------------------
% @1 V; @( y* a: Evoid CMazeServer::SetClientPackSize( DWORD size )
- Z# d. c  m& E7 S; p* d{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
4 F6 g6 ], K1 V" B5 ^* j   
+ P8 Q* }+ W/ q0 I  R    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
' P& c! c) k$ O( x8 E7 P7 \! \        m_ClientNetConfig.ubClientPackIndex = 0;</P>
( J$ ~3 }, V3 y/ F9 S+ f: b& k<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
- f! ?- P! U7 i$ C}</P>
: R% C3 {3 K6 \7 a
; m$ p! D2 J4 X& B9 r2 ~<P>
5 r2 M0 f8 o" Q( w: a//-----------------------------------------------------------------------------
// Name:
// Desc:
0 e5 _' [( _- F9 ]//-----------------------------------------------------------------------------
) }+ {3 P+ j, S. evoid CMazeServer::SetServerPackSize( DWORD size )
: K. ?2 d0 l( n% I9 H8 g5 x+ G0 G{
5 g# e: Q" i  u' X" S$ R6 {    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
8 Q8 E" E& ?, J4 `- h   
    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 );
, F5 W$ l2 N1 h4 s  w6 t/ B$ N! B    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>
<P>
; h) z+ l, O, a$ G//-----------------------------------------------------------------------------
+ B* a0 Z. S) \& a) X/ t2 [, j// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
{
    // Update client config, and build packet containing that data
  D2 e& w" K7 p- e$ P/ @( v- l    m_ClientNetConfigLock.Enter();
& P; \  x* k. ~9 j4 O   
1 |1 Z0 r& H/ `! j5 g8 _9 x$ @$ G    m_ClientNetConfig.dwThreadWait = dwThreadWait;
    ServerConfigPacket packet( m_ClientNetConfig );
( C8 j" |& ^& W/ f+ k    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>