[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
<>// File: mazeserver.cpp
+ L$ }& i8 w  H1 B  s9 z; Y6 \8 m//
6 Q$ o2 ^' G% w4 `9 u, m// Desc: see main.cpp
//
// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#define STRICT
2 |9 G% C: \- s! @# o! \$ R+ h- F2 O$ j#define D3D_OVERLOADS
#include &lt;windows.h&gt;
" u; P" \0 ?1 a1 ^: W/ Z#include &lt;d3dx.h&gt;
) Q, E2 E  A5 t4 D# b#include &lt;stdio.h&gt;
, a. q: v  q2 [+ T( b#include &lt;math.h&gt;
9 \: @/ [* r; z7 l$ O$ t( q6 g#include &lt;mmsystem.h&gt;
; a. _; R8 ^# F+ f7 I$ U8 u/ t4 u7 F#include &lt;dplay8.h&gt;
#include &lt;dpaddr.h&gt;
" M! x8 s4 T  I0 [5 c5 K2 ]" e  v; ^#include &lt;dxerr8.h&gt;
#include "DXUtil.h"
#include "MazeServer.h"
0 N3 E& `- i; r3 }; q: P" V#include "ackets.h"
8 w$ S! l! c* T+ T#include "Maze.h"
2 D2 b0 J  Z  `$ [5 q$ s#include &lt;malloc.h&gt;
+ ^3 k! \7 c$ O7 t4 e3 p#include &lt;tchar.h&gt;</P>
' v0 k; J3 ^8 E0 B
$ X/ U- X4 t* s<>//-----------------------------------------------------------------------------
  b7 ^. A2 m! T7 G; ?// Name:
// Desc:
//-----------------------------------------------------------------------------
$ K% m+ E. T; k6 g/ {CMazeServer::CMazeServer()
  U! {' K2 r8 c/ @{
. z% {9 @5 l( O' }( p! Y    m_dwPlayerCount         = 0;
. r- G' _2 p3 @  R5 W7 z   
    m_wActiveThreadCount   = 0;
' O) Q0 k# g- t) W    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
1 j8 e" o) U1 z    m_fAvgThreadTime       = 0;
    m_fMaxThreadTime       = 0;</P>
5 _! q% i" `  w( |2 \; f. H<>    m_dwServerReliableRate  = 15;
0 s. K" J- p" l/ S$ A    m_dwServerTimeout       = 150;
3 m0 }8 G& {5 c3 F2 ?5 i3 t6 a2 R    m_dwLogLevel            = 2;
    m_pMaze                 = NULL;</P>
<>    m_ClientNetConfig.ubReliableRate = 15;
; q6 F, f1 V( n    m_ClientNetConfig.wUpdateRate    = 150;
2 p5 t- V# D8 D1 B    m_ClientNetConfig.wTimeout       = 150;</P>
( @5 w7 i. S3 E! `" A- }( A' O<>    m_ClientNetConfig.dwThreadWait = 0;</P>
( Z" u5 D# {: |. @3 B<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
* F8 ^9 W4 \2 ]6 X. T1 G        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
+ a' p6 ^, u+ M' w/ m5 r}</P>

<>
//-----------------------------------------------------------------------------
( }" b$ J4 O1 f8 ?8 t// Name:
// Desc:
# N  [4 x" ?: @! e8 `0 {. m, @: B//-----------------------------------------------------------------------------
3 V0 B8 K$ P9 ]( Y* P2 y9 ^HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
, D) [5 J( c# N3 D; x4 H    m_bLocalLoopback = bLocalLoopback;
& i( J( S- p; |% W+ v) s4 c    m_pMaze = pMaze;
' H% s6 n, F" Q) S4 ]    if( m_pMaze == NULL )
        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
2 v- `3 b1 D& e    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
5 J3 n( d7 Y2 C' \6 J1 o" V<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
    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 )
/ V3 ]5 U4 c/ E& t7 v+ {! c        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
    if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
6 h2 K: a# x4 e9 N        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>
0 G  c  U  J8 c2 u# b* @: j2 A<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
    m_dwMazeXShift = 0;
' y4 d; J* a  y4 |( V% C+ T% S" x  v    while ( (scale &gt;&gt;= 1) )
        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
        m_dwMazeYShift++;</P>
' x' x8 M4 V/ ~9 I0 I<>    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>
$ p) @+ `8 S4 O<>    // Initialise the player list
* Z. l7 A0 k* h# R) O    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
    m_pFirstActivePlayerData = NULL;
3 }% T4 M* P, p* J# o/ R( X    m_pFirstFreePlayerData = m_PlayerDatas;
2 ]) X: x( H/ h* C9 w5 f    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
1 m3 l, {; r3 ]' \% m+ z- K    {
        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
6 \+ j. ~+ E4 [( G6 d    }</P>
<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
5 m9 i# j2 E: }; [9 A    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
    m_dwActivePlayerDataCount = 0;
    m_dwPlayerDataUniqueValue = 0;</P>
# D" W% J- b1 _<>    // Initialise the cells
* X% T7 p- |4 u7 m& g  n7 s    ZeroMemory( m_Cells, sizeof(m_Cells) );
    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
<>    return S_OK;
6 q7 i& v4 A1 A) w: _}</P>
7 G( M; z+ K! Y9 v
<>
7 F# }/ j9 F0 j//-----------------------------------------------------------------------------
' g$ C2 ~& H' C1 `  d// Name:
// Desc:
4 A( `2 O! A3 g+ a( _) E5 i: `//-----------------------------------------------------------------------------
void CMazeServer::Shutdown()
' Y, |3 i6 Y: e4 P{
- _; a3 ?; @5 r1 t8 C}</P>
: A: R0 Q% b+ H5 e
<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
/ J# i. j, m1 A: H8 V% w1 T{
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
5 k' Z7 ^( a1 `6 K1 D% w}</P>

9 t, Z- Q  b4 p+ c) X' K1 W<>
//-----------------------------------------------------------------------------
3 t$ s  T3 i$ Z0 a; G. Q, ^3 R// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
  {. Q# [* T* H{
    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
8 T$ S$ ~8 C) w3 a. X0 t" f0 K* o}</P>
' i* g; \# Q8 Y. I6 g  F( w
" A7 i0 N! m6 ]! _2 Y3 X<>
4 Z, {: }. K1 ~: C//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
{
    if( x == 0xffff )
9 M5 O3 H# u: i% e        m_OffMapLock.Enter();
6 _* w8 F$ Q2 t    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>

7 L1 [+ `& A2 p' A/ i0 a, c) j<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
  R( M/ [( @/ E$ H- D. `//-----------------------------------------------------------------------------
void CMazeServer::UnlockCell( DWORD x, DWORD y )
{
9 G# y2 ~3 _  o) ~( n( {    if( x == 0xffff )
  e4 N; H- b% l7 U( `0 ^. m4 C        m_OffMapLock.Leave();
    else
        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
# m/ F2 m( |# E
<>
" `: `# M/ T. K  z//-----------------------------------------------------------------------------
3 c9 m1 O2 P0 u1 `// Name:
6 e" B& d. A. f// Desc:
//-----------------------------------------------------------------------------
- A6 B" h+ E( Y8 Dvoid CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
. }' d% F4 Q; a7 W' n( v    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
1 n% j- t$ ~! {& |' r6 @) x: A        else
$ H, Y. V" t0 Z4 M* U$ j& V# `2 i- g            m_OffMapLock.Enter();</P>
<>        return;
% c0 w* d" r- l- ]) a  m/ H0 g    }</P>
4 @5 Y; @- M% G( F. C% F<>    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>
! `+ W3 z/ k) C0 M' Q<>    if( x1 == 0xffff )
    {
        m_OffMapLock.Enter();
# I# u+ G; R3 c" d+ ~( [        m_LockGrid.LockCell(x2shift,y2shift);
3 d5 {& u: X8 J, X/ i    }
/ o/ b4 V( n. F' v( u3 |    else if( x2 == 0xffff )
. N6 k4 K& B7 f4 n1 C2 D    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
% u2 ]6 L+ ]2 y. }0 g2 s1 }% s2 z' Z    }
    else
' G7 W' [9 Z1 v7 y    {
0 \; t5 P7 Y' A3 P5 [7 S6 i5 K, u# W        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
}</P>
7 u0 s$ [% e) E( _5 @6 s. O3 y
<>
' c5 ^2 a% V% w* x1 C" T//-----------------------------------------------------------------------------
1 v# T! Z) r$ \7 v// Name:
// Desc:
//-----------------------------------------------------------------------------
8 E/ b2 g7 G& Z. Q: o/ }void CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
' b8 K* J: ]8 @# ~: n9 S        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
. O% N: U4 x+ e. i/ O3 t  P* g            UnlockCell( x1, y1 );
        else
! H6 C' p1 w6 K0 ~* ?; {            m_OffMapLock.Leave();</P>
<>        return;
- g) \, z. J# g9 d    }</P>
! O' j0 w1 |" y2 k/ w( x- u- L6 K<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<P>    if( x1 == 0xffff )
    {
        m_LockGrid.UnlockCell(x2shift,y2shift);
        m_OffMapLock.Leave();
    }
, [7 Z* x( t" a1 R% ^* L* K    else if( x2 == 0xffff )
+ \! A$ E+ P) u/ b  h3 g$ q9 |$ L1 T    {
        m_LockGrid.UnlockCell(x1shift,y1shift);
        m_OffMapLock.Leave();
    }
    else
    {
" \" j$ C  _- [        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
9 n9 H* R0 ^, Q/ Q    }
: B% ^+ F, U! ^2 t}</P>
9 J8 e  p9 R3 j9 u) L
: @8 P, ~0 }1 a1 N<P>
//-----------------------------------------------------------------------------
// Name:
! @, d3 k9 @! j  z// Desc:
//-----------------------------------------------------------------------------
1 R) ?2 q$ M1 Z8 |& P4 mvoid CMazeServer::OnAddConnection( DWORD id )
2 S/ Q) a" f& m6 O{
% Y! {7 G; b/ T4 }    m_AddRemoveLock.Enter();</P>
<P>    // Increment our count of players
/ u2 u6 r, q. m9 }    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
) E  O. j. x6 B( G! n    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
- a0 n. q- J! M. O        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
  Q4 Z8 d$ |) ]2 T) G$ M3 u& u0 I    }</P>
* x# h# z/ b2 B9 M- W2 e: T, z$ W<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
/ H) `- ~- s$ Q1 c        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
<P>    // Create a player for this client
    PlayerData* pPlayerData = CreatePlayerData();
& y9 ?# U: N: \$ H- L) y    if( pPlayerData == NULL )
2 P0 O. _: @- d0 C1 W* _    {
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
5 |6 Q+ `  `1 W        m_AddRemoveLock.Leave();
        return;
    }</P>
<P>    // Store that pointer as local player data
    SetPlayerDataForID( id, pPlayerData );</P>
<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    // Send it
/ P3 R" ^; y: r) L$ b0 k, c" L    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
<P>    m_AddRemoveLock.Leave();
' y5 X+ z0 I: g4 f$ [}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
% f' w9 L* ?% L% I$ \- e+ @// Desc:
( K; h9 t# T/ x. q//-----------------------------------------------------------------------------
void CMazeServer::OnRemoveConnection( DWORD id )
{
$ [/ V& ~. a( e$ O    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
    m_dwPlayerCount--;</P>
2 ~' h; m: q5 P3 I% Z9 X# X1 L9 B<P>    if( m_dwLogLevel &gt; 0 )
* _$ s( `3 J, ?5 w! J  C: |. K- v    {
! S) d" ~" y8 |: Z7 V  B        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
% l$ S- C' z8 ~  U- h/ E/ X0 X! z        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
. a# @$ g8 @& M; G2 b% b. o    }</P>
<P>    // Find playerdata for this client
3 `% T' H& U% D; E% E# }+ M    PlayerData* pPlayerData = GetPlayerDataForID( id );
5 y) }' V0 l9 ?; i7 J4 b% t    if( pPlayerData != NULL )
    {
' K" r* n: C5 L0 M! f        // Destroy it
9 L  t# S4 _" P( \% N        RemovePlayerDataID( pPlayerData );
, F$ P3 C; l3 @' A        DestroyPlayerData( pPlayerData );
    }</P>
( \* q; B( Q5 p  A<P>    m_AddRemoveLock.Leave();
}</P>
) f& X+ e# V* W0 B
3 `2 p5 B6 q2 p: P1 s/ _( d<P>
! K( D; H4 D3 {# \0 J  Z//-----------------------------------------------------------------------------
// Name:
// Desc:
6 T1 K+ ~' K3 a4 d) \* f, ~//-----------------------------------------------------------------------------
. Q) h# c+ D7 z" ?( H, gHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
{
' D7 W1 d% e& U# c, j    BOOL fFoundSize = FALSE;</P>
& b+ G: C3 c; K  _, h8 G% j' q<P>    // Increment the number of thread we have in this process.
: [. g/ x2 y4 O% ~5 Z    m_csThreadCountLock.Enter();</P>
<P>    //Get the start time of when we entered the message handler.
    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
& N8 r6 ~, Z0 L: @: ^/ x( r<P>    m_wActiveThreadCount++;
. t3 a- q# E# N8 N* y% K0 s    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
! K1 \+ o) t+ \        m_wMaxThreadCount = m_wActiveThreadCount;
   
    // Calculate and average.
    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
    m_fAvgThreadCount += fdiff/32;
   
6 ]/ D; w1 R1 H2 q    m_csThreadCountLock.Leave();</P>
<P>
    ClientPacket* pClientPack = (ClientPacket*)pData;
: o& K" t% U, ^( z# H$ C  d9 I    switch( pClientPack-&gt;wType )
0 m* B4 D" x# h4 i" c    {
        case PACKETTYPE_CLIENT_POS:
            
            // Check to see if the packet has a valid size. Including
: G& H% o% |' ~( i9 b            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
                fFoundSize = FALSE;
! U$ a( c& X/ W            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
; @. I/ _! m1 _$ B6 c) S  `                fFoundSize = FALSE;
            else
# S. S+ {* i; R; E% P- s  l                fFoundSize = TRUE;</P>
<P>            // If valid sized packet, handle the position.
            if(fFoundSize)
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
            else
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
            if( size == sizeof(ClientVersionPacket) )
                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
* a- M! N) s+ D" m3 \  O  U/ T; {            else
- v% B, k- q( k" X' Q. d" \                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
, U& K& h; A) K, i1 \* w            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
4 p5 m; p) G: r4 ]# q4 L<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
<P>            break;
2 f6 S" F6 q  {! `8 v        default:
, `. x$ O; X3 Y8 T; G4 Q, c            HandleUnknownPacket( dwFrom, pClientPack, size );
9 ?5 `2 W  G/ z$ `/ ?. t            break;
    }</P>
8 m+ k- z; e) r  q<P>    //If the user wants to hold the thread, Sleep for given amount of time.
! o8 B  j1 _; y7 ^% d% y- p6 K& a% z    if ( m_dwServerThreadWait &gt; 0 )
    {
- v8 Z2 M9 J5 N1 A$ J) C        Sleep( m_dwServerThreadWait );
9 S" I" r* s' H2 `. [    }
2 s) ^. r& J2 V, `, M! N   
    // Retrieve thread data for this process.
, `, `9 `/ `) p% ~; r6 x+ @  x: M  q    m_csThreadCountLock.Enter();</P>
<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
0 R2 a+ _  f: k$ L) \+ ?5 S    m_fAvgThreadTime += fDiffTime/32;</P>
& ]* ]3 e, Y; }( V<P>    //Get the Max time in the thread.
" Z0 e: ~5 g& f* }    if ( fDiffTime &gt; m_fMaxThreadTime )
    {
- ~! Q. K0 {, {        m_fMaxThreadTime = fDiffTime;
2 h6 \2 m) ?; W3 {2 n* ~% n0 n    }</P>
& G; t3 R8 a0 s, D4 C: W<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
) T1 D' x/ v% Z  @- ]4 P$ ?! N/ |}</P>

<P>//-----------------------------------------------------------------------------
// Name:
// Desc:
/ B1 |- Q9 b+ }& d+ ~//-----------------------------------------------------------------------------
BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
2 R/ u1 m% q, c& ~' t3 [( S7 m{
4 m% x' [. @. b& Z- a    BOOL fFoundSize = FALSE;
    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
; I- D% d! P9 \: A   
    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
% f4 l5 f/ h0 C8 R' @- x7 _        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
- c0 ~5 U  Y; B, B3 F6 a% F2 T# A        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
. G2 U* w6 V: Q6 V/ a2 t, p            {
. f  l! w6 m. I! P/ \                // Found valid size in the array.
5 C2 x# l) N$ g6 i. B/ T                fFoundSize = TRUE;
' ?1 d+ i8 i/ T3 e                break;
            }
+ G) f* _2 J& Y            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
        }
    }
8 C; T% a6 S/ ?  S% C% c: |8 O    else
, r4 J. T8 O( ?2 a9 c- N' s3 H    {
        fFoundSize = TRUE;
    }</P>
<P>    return fFoundSize;
}</P>
; ?7 I2 M( n) a. Z. n<P>
//-----------------------------------------------------------------------------
1 o+ q9 ?, ]: a/ v1 v) f  S' W// Name:
// Desc:
/ N3 d+ j& d/ u: C* ]5 P& z6 g//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
. y1 _) x7 P; \3 _! f/ [* e{
% l4 x2 \3 d4 a/ ~8 w    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
}</P>

  l. k3 f- N1 K2 S! b8 X9 Q8 ~<P>
//-----------------------------------------------------------------------------
// Name:
3 U( V1 O2 B2 N/ d2 N/ G// Desc:
& H+ O/ ]- A: C' C* d//-----------------------------------------------------------------------------
7 m. ^4 W  I$ w5 `. CPlayerData* CMazeServer::CreatePlayerData()
% |* [5 t0 s, J2 [8 b{
    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
# k0 ~* Z  m8 F    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
" R. j# R* _9 t7 n8 g7 _9 ]. N5 w; e    {
; i# e0 S( c& n+ N' n        LockPlayerData( pPlayerData );</P>
, g3 u! J" Q. i# q& M# u<P>        // Got one, so remove it from the free list
" g1 Q/ h  P5 Y        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
        if( pPlayerData-&gt;pNext )
2 t# V; D% g; w6 i+ `$ Z5 @5 v5 B' o            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
( @3 X  P& [; ]2 V/ o        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
. r6 h) s2 r; [, _- B  d9 [" z3 c<P>        // Update count of players
        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
. @( O# M* x+ A! t2 O3 [        m_dwPlayerDataUniqueValue++;
+ X1 w) Y3 i7 x        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
1 p+ T7 i+ y1 `0 S3 ?4 H<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
  a) c; g% H& e. \! X  D' @        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;
- O0 q" i# y) Y- Z4 w) _        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
- |5 F0 a7 f# o, }        m_OffMapCell.pFirstPlayerData = pPlayerData;
        m_OffMapLock.Leave();</P>
<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
$ b. ?" ]. N2 i4 O0 S0 d<P>        UnlockPlayerData( pPlayerData );
    }</P>
) b+ q" j1 Q5 S# z% o4 D9 T* p<P>    m_PlayerDataListLock.Leave();</P>
: \3 G6 c+ Q; c" P$ h- ^! R! |<P>    return pPlayerData;
}</P>
' R) n' a( C5 r# [4 {
' t7 |; u, S! }3 t$ Z- Y/ {9 W- I( g<P>
. \5 w: b1 l/ W( ^//-----------------------------------------------------------------------------
// Name:
8 y% u: C" m* ~: N, k// Desc:
/ `4 s; Z+ a8 C+ a) L7 g* m//-----------------------------------------------------------------------------
2 G8 k# r% k+ M: T1 s$ V+ jvoid CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
1 s  V2 {- @- F! V5 |, Y8 D; ]{
    m_PlayerDataListLock.Enter();
8 B7 h+ [$ h7 i+ ?5 }& ]5 v    LockPlayerData( pPlayerData );</P>
0 ?& T6 G! e; ^4 h8 L<P>    // Remove the player from its cell
    RemovePlayerDataFromCell( pPlayerData );</P>
- O: `9 |& K# t  Q9 `2 }<P>    // Mark as inactive
    pPlayerData-&gt;bActive = FALSE;</P>
( U' K' d) S: I<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
, r1 N1 z# i# ]  f    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
+ V/ O9 m; D9 i. N9 l. G<P>    if( m_pFirstActivePlayerData == pPlayerData )
/ I! M0 l, f! O6 w! A" r        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
" u: q6 ?2 k& e' [0 m/ ?    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
* v; u+ g! p$ `* {0 b( m$ p) [" B    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
2 m, f% E. _3 r, Q0 W    pPlayerData-&gt;pPrevious = NULL;
, L' b1 S, _- R% P7 Z    m_pFirstFreePlayerData = pPlayerData;</P>
- V5 U/ u/ g* t<P>    // Update count of players
    m_dwActivePlayerDataCount--;</P>
<P>    UnlockPlayerData( pPlayerData );
    m_PlayerDataListLock.Leave();
}</P>

% c  L: Y# j: A* P<P>
8 a* g1 q1 x3 t7 X//-----------------------------------------------------------------------------
  _0 n5 X& |& l/ Q0 l. _  C9 r$ d// Name:
// Desc:
6 H- o9 _2 s2 U! w! D//-----------------------------------------------------------------------------
, h  [) p3 a9 P% Hvoid CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
5 H' O& t' V6 q" D6 p{
2 T' W) J% D. E' r7 a. K) |    // Lock the player
/ L6 f7 i/ {# V6 h6 y" F    LockPlayerData( pPlayerData );</P>
7 v) B4 d4 [) {( }$ U0 r6 }<P>    // Lock the cell the player is in
    ServerCell* pCell;
1 @* A! `; L' D5 D% o$ e* \3 K    if( pPlayerData-&gt;wCellX == 0xffff )
1 P( F7 X  A% P4 r. f9 S    {
        m_OffMapLock.Enter();
' S; Q* |9 m2 }1 a( c        pCell = &amp;m_OffMapCell;
    }
    else
0 c$ c0 }) p2 p) ?, Z( g! c    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
, m, [1 a$ B$ D* m        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
    }</P>
, C# N9 q5 F1 `0 I& h: x<P>    // Remove it from the cell
    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
: L1 j/ F$ |" ^4 m( V& `; d* a& i    while ( pPt )
) W7 P0 l3 }5 n* ]/ G+ a    {
        if( pPt == pPlayerData )
% F6 q5 [9 A% R! M  i        {
2 S0 U5 t/ [* K! C! w+ N# c* z! c6 g            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
* u( z6 U9 \, J/ j. `' w            else
$ a3 m3 c) y: h: s) r                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
<P>            pPlayerData-&gt;pNextInCell = NULL;
2 n& ~0 J6 S. q# ]% U: e            break;
$ Y' l$ V) m3 t4 f7 ^$ V2 X        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }</P>
  X1 q: P, t# \8 U" `8 o8 V<P>    // Unlock the cell
) k) {2 h! C9 V* Y4 }    if( pPlayerData-&gt;wCellX == 0xffff )
( `( r7 ~  a: R8 V6 ^) F: R# _        m_OffMapLock.Leave();
    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
<P>    // Unlock the player
% E1 `4 C* g. ^! l* z+ ?; ]& \  k    UnlockPlayerData( pPlayerData );
- h6 @1 v3 n3 e5 ^}</P>

3 k5 A& k8 [$ ?! j& `6 s<P>
$ l/ j9 `) d+ ^9 r//-----------------------------------------------------------------------------
* y; f! A/ a& S: p. x' d// Name:
! ~, m1 L  ?" g$ q2 {: V9 |// Desc:
3 a$ q( _$ t1 z2 Z. q. X6 y//-----------------------------------------------------------------------------
void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
{
. Y2 ^& Y8 {8 @' ]    ServerCell* pCell = GetCell( pPlayerData );
! k) n1 M  c6 l6 ?    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
1 M  `8 }- G* E9 E2 j    PlayerData* pPrev = NULL;
    while ( pPt )
- m9 w$ J5 k! O# v: z    {
        if( pPt == pPlayerData )
        {
' H& _" K2 ?$ X* w7 u; r6 D7 T# y            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }
/ R& B6 g0 J, I9 y- }}</P>
9 c! z& b& x( @9 ~1 x. A3 P1 j
<P>
% g6 l0 Z; T1 Z//-----------------------------------------------------------------------------
+ U9 A1 p& ?  R! v/ r9 r// Name:
2 V. j9 i; h! r, ]) x// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
, B0 d8 w! ^) z2 Y    pCell-&gt;pFirstPlayerData = pPlayerData;
9 k+ x9 {6 e% t. ~) O0 z}</P>
) v2 e5 j; b: H: `, v7 C3 x
<P>
8 ?+ v, u- w8 j* b6 s//-----------------------------------------------------------------------------
" j' m' ?$ M; f6 V4 G7 |' R, g// Name:
2 `# t/ z' c0 G# `% y// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
    {
% C4 b9 b" ~( @! }$ u( W) x        if( m_dwLogLevel &gt; 1 )
, [4 A1 Z& m+ M% o            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
2 q, O( J; x9 C        return;
    }</P>
<P>    LockPlayerData( pFromPlayer );</P>
<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>
; j: }& C7 g$ m9 e2 u% M7 T<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
9 e8 O  H' K; i  X4 G5 P        UnlockPlayerData( pFromPlayer );
( z  Q! e' R+ x0 A        return;
    }</P>
$ J( y; B( t; ~2 c* `4 X: f9 I" b& N<P>    // Compute the cell the player should be in now
$ _& S% H1 p) K1 }# V1 g# h8 q    DWORD newcellx = int(pClientPosPack-&gt;fX);
    DWORD newcelly = int(pClientPosPack-&gt;fY);
  z4 G- e+ L2 j5 B: C) z# z& E    DWORD oldcellx = pFromPlayer-&gt;wCellX;
    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
$ Z7 N9 L7 d2 ^4 \7 Y<P>    // Have we moved cell?
6 H# J  a3 ^+ j5 P" n    if( newcellx != oldcellx || newcelly != oldcelly )
    {
& }; V& ^& y; [8 j1 s" i* d        // Yes, so lock the pair of cells in question
        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
; R( `- g( y' j* j7 ~<P>        // Remove from old cell and add to new cell
  _2 @/ x; B2 Y+ b! ]/ R: |- z        UnsafeRemovePlayerDataFromCell( pFromPlayer );
        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
7 j. r  P' {+ V* S    }</P>
<P>    // Update player position
$ q- b! r. h8 h/ g0 c; ^) j* Q    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
, b2 `& q; m4 n0 Z( ]1 Z! Q    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
6 b, G/ U, N. ~" }' `5 W$ _<P>    // Allocate space to build the reply packet, and fill in header
$ z8 M4 R3 [" x. A    DWORD dwAllocSize;
# I$ Y, R) u& m- M    ServerAckPacket* pSvrAckPack = NULL;</P>
<P>    // Begin by allocating a buffer sized according to
- e0 f8 U* D* y9 h) K; T( U    // the current number of nearby players + 4.  This will give
6 w( q' O; G  c" k+ L8 {    // a little room for more players to come 'near' without resize
! @* s* q5 x, N9 j$ w/ D/ E! t/ `    // the buffer.
9 P: X1 [& T2 S5 a  A4 Z    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
& w2 U1 _1 ]0 T) a! Y' z    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
2 d- d' V/ a% S" x, ]    {
        // Out of mem.  Cleanup and return
" v+ F" }1 n% P  n) }% S2 e        UnlockPlayerData( pFromPlayer );
        return;      
& G- n4 S/ d* T    }
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
) Y6 \1 t! J& W6 |' e) C$ P<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
0 [) `: O. O5 r7 d4 [) ~! y0 O4 _    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
* |2 R5 U( @, r8 L/ J$ R  d" u5 M<P>    // Compute range of cells we're going to scan for players to send
    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
6 O7 i3 `1 K3 i. _9 v! b3 o2 ?  W    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
( @' j  n# `4 b' U* B9 B5 s5 o    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>
* M5 @. \; m5 W8 }8 T: c<P>    // Lock that range of cells
, b, c+ b# w  ]  v    LockRange( minx, miny, maxx, maxy );</P>
7 C) I7 a( [. D<P>    // Scan through the cells, tagging player data onto the end of
    // our pSvrAckPacket until we run out of room
1 ]4 n" ?, Q6 ^$ U    for( DWORD y = miny; y &lt;= maxy; y++ )
: i9 i( a4 x2 W* [' B5 @6 \) X    {
        for( DWORD x = minx; x &lt;= maxx; x++ )
7 M0 J* S3 ]2 R1 @# e- a        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
            while ( pCurPlayerData )
            {
                if( pCurPlayerData != pFromPlayer )
                {
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
                    {
                        // Make sure pChunk is where we think it is
1 j! D% a& [3 r/ B5 o                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
6 {, K7 p7 w1 l9 ^, ^<P>                        // There are more than just 4 new nearby players, so resize the
. K" g" I$ O8 z. t; A! k( W  `                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
                        dwMaxPlayerStatePackets += 16;
                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
                        if( NULL == pNewSvrAckPack )
                        {
                            // Out of mem.  Cleanup and return
                            free( pSvrAckPack );
                            UnlockRange( minx, miny, maxx, maxy );
" ]% @' G/ c+ f/ T; N3 T                            UnlockPlayerData( pFromPlayer );
                            return;      
                        }</P>
) w* W" F4 F. N- R9 k/ `<P>                        pSvrAckPack = pNewSvrAckPack;
                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
# F  r5 ^2 e! T5 h7 J/ _<P>                        // Make sure pChunk is still where its supposed to be
; t% x+ ^) Z* G8 R+ x6 U& \% m& Z                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
                    }</P>
% l2 Q5 v1 \# T" {<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
* S7 c+ r  J( C8 J                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
9 @4 a4 E, R2 |* ?5 o% R                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
# R% b  Q1 g7 U7 M3 I' V6 G: L                    pChunk++;
/ l; ]9 I9 q+ `& j" B2 ^                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
3 p7 w7 T# H( l  k; f8 G2 N        }
    }</P>
<P>    // Update the dwNumNearbyPlayers for this player
    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
<P>    // Unlock range of cells
. r5 n( S, P5 z2 g4 I. h    UnlockRange( minx, miny, maxx, maxy );</P>
<P>    if( m_dwLogLevel &gt; 2 )
# m* t) X$ @' {$ k+ x& e    {
        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
' p' b6 G; L6 \: \    }
& L: a' B( Z+ \: t% x    else if( m_dwLogLevel == 2 )
$ F+ c' Z. O( {7 e. {    {
0 P1 N# O* }* M% a" i        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
* A0 i% z" k" ?" u, Q' B        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
' A4 i: s6 \4 t- R        {
            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;
        }
& ]; }% {6 }: v3 l. `: U: r7 o- E    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
<P>    // Send acknowledgement back to client, including list of nearby players
% d( C/ C) _9 r7 O5 N/ y  G    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

) o1 s& l7 h" \0 ~" \2 A) a    // Pack the buffer with dummy data.
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
0 w' t( V. h. U2 z( b. S( R8 U: u    {
        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
        VOID*   pTempBuffer = 0;</P>
4 y) o3 S) _: }: M4 V1 s0 _1 d<P>        pTempBuffer = malloc(dwBufferSize);
* _5 v: Q; b' i3 t2 x- U        if( NULL == pTempBuffer )
% ]& W* q7 r7 j; ~. v7 K  l+ J; ?6 y        {
" x8 k5 S8 P) W9 J            //Out of memory
- B1 N/ r4 s9 w4 S4 X            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
/ @$ m; B/ H8 k: u( Y0 v# o            free( pSvrAckPack );
, p2 e; S2 v+ R            return;
        }</P>
0 G7 y3 ]" L8 s5 \9 R<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
7 U! o+ n& k$ k  @        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
. L6 b# m' C1 z6 V$ L0 v& A<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
0 E- h! E! Q5 s5 n% \   
( j, {! t8 ]2 r        free(pTempBuffer);
    }   
    else
  d9 ?9 q/ y( s/ I* Z    {
) z# K' l( X$ t9 Q4 f        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
    }</P>
3 Y" T1 t! O7 o<P>    free( pSvrAckPack );</P>
: X4 L' o6 P$ m0 a0 \<P>}</P>
) d# o3 b' d, i+ h$ \) m( a
<P>
//-----------------------------------------------------------------------------
0 Z+ e+ e7 @" u$ m1 t: d  J// Name:
// Desc:
# V2 N5 x5 P2 l  v) `//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
( g7 F  E2 U3 e6 v0 L1 L- }; s4 g  c    if( pPlayerData == NULL )
" q' G* p9 [% U  _* q  Z        return;
    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
<P>    if( m_bLocalLoopback )
0 [  _  K% Y( @' Q: [6 j% p        pPlayerData-&gt;bAllow = TRUE;
2 _# P" u  G% c. H' F: I% u, b    else
% E$ ~# B, C; Y, V6 X( t        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
<P>    if( m_dwLogLevel &gt; 0 )
        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Client version=%d (%s)"), pPlayerData-&gt;NetID, pPlayerData-&gt;dwVersion, pPlayerData-&gt;bAllow ? TEXT("Accepted") : TEXT("Rejected") );</P>
<P>    if( FALSE == pPlayerData-&gt;bAllow )
" j9 }+ ]! f; K/ ]! G/ Q    {
7 Z6 j" \  N) S+ `% [2 Z) U        if( m_dwLogLevel &gt; 0 )
7 S+ O% j; m* J6 P+ E, K            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 );
        UnlockPlayerData( pPlayerData );
        return;
& ~6 c5 y+ ^% [8 V' R    }</P>
  f. M# A3 g4 N  H+ N! y<P>    // Unlock the playerdata
    UnlockPlayerData( pPlayerData );</P>
$ p, }% f8 u; t, H5 b; ?<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>

' E% t, L$ i: }3 l) K9 f<P>
+ J7 k5 L4 v$ G/ M8 h0 _//-----------------------------------------------------------------------------
% ^+ N; \$ h4 L8 Y// Name:
0 N0 f, Q6 p: ^1 s! ]: \// Desc:
//-----------------------------------------------------------------------------
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
- ^/ p1 d9 q& A# R{
    switch( dwClientVersion )
$ {. g) G* @4 y) `- h+ g7 ]) L, z    {
: g# _, C) O; b" u0 j7 _. P9 ]% m/ r        case 107: // only v107 is supported
& j& V# x) K  u( V0 J( }            return TRUE;
) |, i5 ]1 T/ C; `4 e5 `8 A        default:
            return FALSE;
7 N7 `/ @& b6 ]9 d# V3 ^; T6 p    }
}</P>

<P>
+ P5 J+ U# }1 n0 B3 u$ j& e- W//-----------------------------------------------------------------------------
// Name:
// Desc:
/ t$ q: x4 S" e, _3 z3 k+ `//-----------------------------------------------------------------------------
void CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
{
+ z* b" J* T% ^3 t0 v) S& P    if( m_dwLogLevel &gt; 1 )
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
* L# P. g+ s5 l6 y<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
}</P>
0 ], C+ u- F3 S8 y# {  L# j
2 Z# B' _4 ^; o<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
- s  B1 r9 U, @& i& m9 R0 X//-----------------------------------------------------------------------------
DWORD   CMazeServer::IDHash( DWORD id )
: ?( [5 m- U2 ~$ N6 A( m{
+ t* v  r5 [( P- {0 b- C+ Q8 v    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
    return hash;
( b" i6 o$ o2 V0 i}</P>

( k/ J( G: c# S5 P. Q8 s<P>
4 n. L: N. C" J0 }: y//-----------------------------------------------------------------------------
// Name:
. }4 K6 H$ ^7 m( b6 m// Desc:
. L8 u- }# V2 x//-----------------------------------------------------------------------------
# [- L) o4 S* n. o/ Rvoid CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
; ^( w% T0 j2 q- f- e{
" T" o$ s3 e. w& y+ ], v    // Hash the ID to a bucket number
4 n2 d* [; }6 A+ |2 N- B! i7 u4 L; ~    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
6 X; f2 `1 Z, N7 G1 H5 I+ x4 z<P>    // Lock that hash bucket
4 Y1 s$ j. w' W/ x# d    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;
2 X* U' T& }: ~' S3 a' Q+ W    while( pPt )
    {
        if( pPt == pPlayerData )
- s8 a1 ]! y) }+ |& F            break;
  I$ N! k3 c8 c1 N        pPrev = pPt;
: P/ W' k2 D8 f) g. _- r5 e0 o        pPt = pPt-&gt;pNextInIDHashBucket;
- b9 x1 |. X* F( H    }</P>
$ u3 n1 v5 k7 ]+ H, n. t<P>    if( pPt )
    {
0 E4 k1 y7 [; u  ?7 z: p5 {8 @9 e1 B        if( pPrev )
" p9 B+ y3 Q! k: M: {1 I            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
5 B" p, K0 S9 ?+ v! N( g        else
            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
7 y8 h( O. @* {: i' m+ H        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
8 U0 z# o3 [7 U7 o5 [. r- d' a4 W<P>    // Unlock the hash bucket
5 w# t+ r6 I+ ~" M" Q( A( O    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>

2 P6 N% S: w" F$ [<P>
//-----------------------------------------------------------------------------
/ k% E. V2 o1 D. A. V// Name:
! b5 b3 r3 K% J" O# n// Desc:
//-----------------------------------------------------------------------------
" v4 A7 u% g% ~' K6 b4 E8 Avoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
* i7 j1 @3 O& m% t{
    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
& R+ \9 Y+ r( S; _0 u4 l    // otherwise there will be a circular reference
    PlayerData* pSearch = GetPlayerDataForID( id );
! O  a% q+ H0 y; t, Y    if( pSearch != NULL )
5 _  ]: F6 {2 r# k+ ^0 |        return;</P>
* q! _" J; ^7 |  m0 k  K! Z<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;
0 i, }/ P& H( b: x    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
$ E! x2 X: j: u<P>    // Add player onto hash bucket chain
) [! F* v- p& R  w' |; H9 ~* ^    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
5 q& n* \% H$ C/ k; [: i8 ?    m_pstIDHashBucket[bucket] = pPlayerData;</P>
1 d1 F) S2 E1 M: z7 J( h$ }' e<P>    // Store net id in player
    pPlayerData-&gt;NetID = id;</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
* V0 R& H: M" a6 J5 w5 q" l}</P>
, T! ^, D3 F3 j, A7 A7 ?* T
<P>
6 t  S# H- a% `; O//-----------------------------------------------------------------------------
// Name:
1 s. h0 p& O; O3 b4 U// Desc:
6 g. h  f4 d) }  t% l//-----------------------------------------------------------------------------
, [% i: F1 U4 _+ C0 Y6 j5 iPlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
( Q( a% e. v8 o- g, `& E; H{
    // Hash the ID to a bucket number
, W" [+ W% g6 w, ^: d    DWORD   bucket = IDHash( id );</P>
3 X0 L2 S. W; G$ O4 V7 j# N<P>    // Lock that hash bucket
- g. |* G) s* E2 F3 }    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
0 m4 L  `+ E( {- t4 Q" W9 w    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
# \" E/ p/ c" `<P>    // Loop though players in bucket until we find the right one
1 C! r; x8 K5 a) U- T& W$ Y    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
    while ( pPlayerData )
, d) K( D* a, S+ K- p1 Q* I    {
- l8 d+ t: t% O5 U        if( pPlayerData-&gt;NetID == id )
- E7 p1 F3 c; [$ B- e* f            break;
2 u4 F, p! q9 t. l3 E        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
$ R! ?/ l! H$ o( H3 j    }</P>
<P>    // Unlock the hash bucket
, `% v* f9 `$ |: a- p9 i& Q% H    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
<P>    // Return the player we found (will be NULL if we couldn't find it)
+ f* F6 z+ k5 K# b' a+ {+ [    return pPlayerData;
( e7 Z3 W, G7 K# z; h}</P>
) ~0 B+ c* @* G" i6 d
<P>
//-----------------------------------------------------------------------------
: H4 `2 W% n) H( M; M// Name:
2 {# U+ C; |% A2 [0 E% H6 E, c7 ^// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
3 N% }3 ?- H5 j8 W3 I. G: K//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
{
: F: h% N' D: J    if( m_pNet )
    {
        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
        PlayerData* pOldestPlayerData = NULL;
& y" `& o  [7 A        FLOAT fOldestTime = 0.0f;</P>
) v! B7 Y- z5 k5 c- c5 O9 V<P>        m_PlayerDataListLock.Enter();</P>
<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
        while ( pPlayerData )
$ z  m6 Z$ J; U+ [        {
( s+ f5 }$ k1 A( h) G* i            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
( H: D( k4 D1 r( ^$ D' f7 h            {
                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
6 u$ S' c. d- v) g                pOldestPlayerData = pPlayerData;
9 _' v7 l9 Y2 R) l5 B            }</P>
/ I5 }6 L3 @  E% u& q( O* b  g<P>            pPlayerData = pPlayerData-&gt;pNext;
        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
+ F8 @# F1 ^. C6 L        if( pOldestPlayerData )
" \- H8 J. ]% v2 t( [$ o        {
            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
+ p  v( }' D( [; ]% Y. B$ S! Y            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
$ r2 ~, B) P( r% V            pOldestPlayerData-&gt;fLastCITime = fCurTime;
) S! }7 j4 ]5 G& v" H6 ~$ k% u2 s* s        }
        else
% ~. q4 {. D/ P" w3 P, j        {
            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
6 z$ }$ H6 \8 {8 S& ]) i        }</P>
<P>        m_PlayerDataListLock.Leave();
, ^% V% |4 _: y& H: P! E    }
/ Y+ o  a$ Y, m. d* i& @" e2 I}</P>
1 l' E+ [6 L% F" z+ Z
2 Z1 _0 {  E  [  Z7 l<P>
//-----------------------------------------------------------------------------
/ ?2 C2 u! K$ H, i4 _* h# g! r// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:rintStats()
5 \; u- H; e8 H% p7 G{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
                                    m_fAvgThreadTime, m_fMaxThreadTime );
( B. b5 @# g. Y+ W    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
}</P>

$ Z! u! o# Z9 V( r3 _  s! E( k0 b9 ?<P>
3 `2 n( P" n; V- ^( f  }//-----------------------------------------------------------------------------
// Name:
// Desc:
8 k$ E$ y3 o8 r7 `9 @# W) s//-----------------------------------------------------------------------------
+ C# Y2 j' a7 U3 gvoid CMazeServer:isplayConnectionInfo( DWORD dwID )
{
/ F& Q  Z6 V1 A* I. k9 T( w    TCHAR strInfo[5000];
. J, k% c# T) z( J9 n    TCHAR* strEndOfLine;
* K) f+ A2 ]( @6 ~    TCHAR* strStartOfLine;</P>
5 A: N/ S. t: Y$ G* `1 x0 u% U<P>    // Query the IOutboudNet for info about the connection to this user
+ ?6 b! r. e+ G# y    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
<P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );
. z1 y: B5 u' o6 f" y4 a    ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>
<P>    // Display each line seperately
; ^( \  W( w% Z2 A9 O% N    strStartOfLine = strInfo;
# s  H/ t4 U% X+ b' F3 T    while( TRUE )
    {
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
( {4 M. B& W: j( }. t: ?/ ^        if( strEndOfLine == NULL )
            break;</P>
<P>        *strEndOfLine = 0;
        ConsolePrintf( SLINE_LOG, strStartOfLine );
  H. [  f% Q+ o4 c" g1 I) @7 u/ W        strStartOfLine = strEndOfLine + 1;
1 D# I- V. F5 t/ {0 r6 S    }
+ Z* Y+ ?6 y6 Q# |  k}</P>
  N8 ]" R* n: ]- x* ~( q+ X
<P>
//-----------------------------------------------------------------------------
! q5 C1 L( p$ ^3 W* [  q// Name:
// Desc:
//-----------------------------------------------------------------------------
4 u6 E: V, H8 r, R; xHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
{
    // Chance of forcing any packet to be delivered reliably
4 J- @( ^% z" d5 \9 J6 f: r    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
}</P>

9 J5 ]- E9 s3 h' B" a' o2 f<P>
//-----------------------------------------------------------------------------
( {4 X/ H) Q8 H4 m) d6 M& M1 s// Name:
// Desc:
//-----------------------------------------------------------------------------
- T" R5 m6 M+ l$ zvoid CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
* d) Y& o& {$ T  ^1 w    // If we're up and running, then send this new information to all clients
! G2 T3 _8 a* P+ J! N- O5 h, _    if( m_pNet )
    {
: l+ q) A# R: F        //Use the AllPlayers ID
        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
' ^) D8 _, O2 s$ Q}</P>
7 l2 g* b0 j) u# u1 Y( |, {
6 w: [$ }4 K8 M/ t7 B; _<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
: X! I' f2 U1 u0 _void CMazeServer::SetClientReliableRate( DWORD percent )
* J- J% e! O! y: ?{
" V0 \! |( d$ @4 L, C0 |    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
" `7 Z. \; X+ h% a$ k' y    m_ClientNetConfig.ubReliableRate = BYTE(percent);
' l' D. W) x; A6 e) N    ServerConfigPacket packet( m_ClientNetConfig );
6 X* Q" c. u$ u% K* o6 u    m_ClientNetConfigLock.Leave();</P>
& }" I) j' q4 ~) B3 w<P>    SendConfigPacketToAll( &amp;packet );
8 Y- {5 n6 Z1 l7 L& y}</P>
# U0 L# w# A4 M4 D1 ?7 d" w
<P>
3 }- X8 r: A( z: D& \' b//-----------------------------------------------------------------------------
// Name:
// Desc:
6 ]# x- E- g1 n; k9 n& s+ O//-----------------------------------------------------------------------------
void CMazeServer::SetClientUpdateRate( DWORD rate )
{
7 S, g6 `4 B" ^6 R; |( J" ]    // Update client config, and build packet containing that data
5 s# e* A% M* ~2 a    m_ClientNetConfigLock.Enter();
' k" q' F( e) H% H8 n3 k2 @5 P7 c    m_ClientNetConfig.wUpdateRate = WORD(rate);
    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
- P/ Y* M1 v. N' @+ M8 Y* W}</P>

3 `( s8 A3 C# M6 B( }+ j/ i/ R1 w. W<P>
& C8 i) a' M9 w0 |//-----------------------------------------------------------------------------
$ d) P7 ^0 H8 j6 r& e9 Y* g// Name:
// Desc:
) w; H: v/ G7 N6 F1 V//-----------------------------------------------------------------------------
, {  i# k2 F2 ~0 T) xvoid CMazeServer::SetClientTimeout( DWORD timeout )
8 I/ @% ~8 I1 _' t, z9 r9 h{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
; u, [; Z9 S0 h3 D% Z' E; U    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
. ^0 e8 G$ D+ a$ E* ~    m_ClientNetConfigLock.Leave();</P>
, H- u+ k% W, P# m, {<P>    SendConfigPacketToAll( &amp;packet );
}</P>
6 W2 ]+ t) f) d, J" p* b( R+ j
<P>
//-----------------------------------------------------------------------------
  l+ r) K1 c+ M: T" w- p7 `/ `// Name:
4 a% B/ e$ y% B6 k% ^" ~' v// Desc:
, v) t7 J1 C( B2 U# }//-----------------------------------------------------------------------------
void CMazeServer::SetClientPackSize( DWORD size )
6 o+ [1 a5 @( v7 x{
! q) b* w, e$ `2 q- E    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
  ^, @; f5 x- w   
    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubClientPackIndex = 0;</P>
: c7 f  M1 Z+ G2 }, ^( F<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
9 g' T# s' ~, ^) w    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
4 w- e5 f/ Q% f9 V1 Q}</P>

# r( B; Z( T4 l/ D$ T<P>
& }) y" N% E+ r  W6 _//-----------------------------------------------------------------------------
// Name:
  X" Q7 A' O' S, f* B1 b% [// Desc:
+ y& t+ ~. b1 S, F3 e) G) o) J# H* s//-----------------------------------------------------------------------------
void CMazeServer::SetServerPackSize( DWORD size )
3 s" M1 u& m* M  T{
    // Update client config, and build packet containing that data
- a. w' P) `4 `7 R4 {$ c    m_ClientNetConfigLock.Enter();
   
  L" u1 Z6 X& r) M) X0 J    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubServerPackIndex = 0;</P>
<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
( G! d7 n$ ^( q    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
+ w! ^6 T7 K/ e& K2 ]}</P>
( @2 G4 u9 p: D& k; u; ?1 @, |0 e2 t<P>
/ v2 f9 ~4 O" p- i: ~2 ^$ x//-----------------------------------------------------------------------------
// Name:
( I& U! g5 F+ R3 j7 C// Desc:
//-----------------------------------------------------------------------------
1 M3 r8 x  z2 Z4 Pvoid CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
% j( f/ f! p# o) I{
6 ?# y, I4 H/ I2 |% E    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
    ServerConfigPacket packet( m_ClientNetConfig );
: a5 u2 `8 ~) B, I0 @7 [7 a    m_ClientNetConfigLock.Leave();</P>
6 x: W8 u' |- h- [+ n<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>