[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
<>// File: mazeserver.cpp
//
, C' [% S- |% {/ |6 S2 l2 Z7 S- l3 L// Desc: see main.cpp
//
// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
% Q# ]1 R9 X: V: R9 V1 u//-----------------------------------------------------------------------------
1 X$ ]. N0 {0 o' @9 o2 B# F#define STRICT
#define D3D_OVERLOADS
* T; y1 o0 o3 _) F4 X; [#include &lt;windows.h&gt;
1 o2 t. y! l& N8 \#include &lt;d3dx.h&gt;
6 q7 O* R5 ^, B& t+ Z2 r) Y: C+ ]#include &lt;stdio.h&gt;
$ D6 w4 H1 G' ^3 n#include &lt;math.h&gt;
#include &lt;mmsystem.h&gt;
  n7 f, \; m0 N  z8 L#include &lt;dplay8.h&gt;
4 z: W* S; }( ~/ C1 b5 n#include &lt;dpaddr.h&gt;
- Q6 f( t, \! q" R  W; L; m4 j#include &lt;dxerr8.h&gt;
#include "DXUtil.h"
#include "MazeServer.h"
! N: {$ }7 \3 j/ j/ k) K#include "ackets.h"
#include "Maze.h"
+ B8 r, a4 I/ j" q#include &lt;malloc.h&gt;
#include &lt;tchar.h&gt;</P>
" b* ^/ i. T) F9 p3 w8 n* y8 q
- _8 z0 P8 ^# l<>//-----------------------------------------------------------------------------
# Y6 L! c5 V" ?- Z$ ~8 L- p5 f// Name:
// Desc:
' b: L5 }' |7 Z3 ~; K//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
( I8 R; g/ b4 |* m2 D5 a% t" }) o! ?{
    m_dwPlayerCount         = 0;
   
6 r( ^- v* P( B- Q5 F0 T# C    m_wActiveThreadCount   = 0;
    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
    m_fMaxThreadTime       = 0;</P>
. N1 B9 B$ O7 J7 D<>    m_dwServerReliableRate  = 15;
0 \3 a  W/ n9 |+ c+ c: w" H" h    m_dwServerTimeout       = 150;
% M$ i. D! j: }    m_dwLogLevel            = 2;
    m_pMaze                 = NULL;</P>
<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
    m_ClientNetConfig.wTimeout       = 150;</P>
<>    m_ClientNetConfig.dwThreadWait = 0;</P>
0 \- ?! M: _4 G: G0 c<>    m_ClientNetConfig.ubClientPackIndex = 0;
7 F7 o1 Z6 H/ A5 Q+ m    m_ClientNetConfig.ubServerPackIndex = 0;
6 O+ t- k9 R: V) x    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    {
/ Q4 C. X3 B1 Y: r4 C6 s        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
0 X) Y7 h1 f0 a. e; N( w2 W        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
}</P>
- U2 ~7 W& C8 y) w. `( ~8 R
<>
, n# [. C' b: J* {& t2 M* E//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
$ X5 R- M, s7 g) u$ r{
    m_bLocalLoopback = bLocalLoopback;
    m_pMaze = pMaze;
! I$ E5 N& Q8 t: b: e% V9 \    if( m_pMaze == NULL )
        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
<>    // Grab height and width of maze
+ E2 @' f5 g  a$ @. @2 T    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
* |" T9 v) B! `8 z) J6 j<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
3 g) B1 a& a) Z- ^2 W6 N0 x9 G    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
& K4 n2 A% Q$ g' w' q6 K<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
5 m' O" _& G( Z$ B. Y    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
) J- t, P0 X# O" a4 K1 \& Q        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
! A! D- i' O3 y  M5 T& s% Y, Q; P    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>
( V& U# J8 ?8 D4 S! T) q<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
    m_dwMazeXShift = 0;
    while ( (scale &gt;&gt;= 1) )
        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
" \; x# `% j- m    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
+ W* r% e6 B! a8 R% k        m_dwMazeYShift++;</P>
<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
        ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeYShift) != m_dwHeight) )
/ G  U" F1 v- f/ v        return DXTRACE_ERR( TEXT("Maze height and width need to be power of 2"), E_INVALIDARG );</P>
; ]! n3 ]( E4 }" l  }* q* k<>    // Initialise the player list
    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
0 ?3 t* M# H. m2 ~' u    m_pFirstActivePlayerData = NULL;
    m_pFirstFreePlayerData = m_PlayerDatas;
5 U6 S- @  ~( F2 K. ?4 g    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
3 a. X) Y9 O7 ]$ K    }</P>
<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
; g$ y) `4 ]- i& _6 @    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
" q* q9 y1 K7 v( P2 z& j% p    m_dwActivePlayerDataCount = 0;
4 g+ B( V2 }% l& L' k( O8 t1 Z2 Y4 ?    m_dwPlayerDataUniqueValue = 0;</P>
<>    // Initialise the cells
/ _$ M- p, \: a    ZeroMemory( m_Cells, sizeof(m_Cells) );
    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
<>    return S_OK;
}</P>

<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
0 n, Z- b& L* S7 Y: Q//-----------------------------------------------------------------------------
void CMazeServer::Shutdown()
{
: e: ~8 p1 D7 E7 o5 r}</P>
# }0 I* [* d1 p; Y! H
# `- y! K; }3 H8 V1 ^  A, W1 j7 N<>
//-----------------------------------------------------------------------------
// Name:
- T) n4 r- m+ a1 J% m" v, d* G// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
$ V" Z4 y) T1 g: [{
& c$ D+ B3 J0 R; X8 m+ v    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" `/ D8 v, w0 V9 K5 T}</P>

, Q! [6 p+ g/ v: D% g<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
* U" r+ _) l# O; t- G    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
) K1 _; q8 X$ U; A                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
9 Y* Y9 u! V7 i- C9 N; m$ \}</P>
# V2 e* Q; e) Q
% G" p5 ]1 r9 p; p3 n( |- }<>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
/ \: G4 E; P& N$ t{
% h' n; E7 L: s; i6 f    if( x == 0xffff )
0 U$ k# K+ E" h        m_OffMapLock.Enter();
    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
2 h- M7 I6 S. c3 }& c  I
<>
//-----------------------------------------------------------------------------
: I% [( F; B7 S( x// Name:
// Desc:
//-----------------------------------------------------------------------------
0 R1 o$ f  q3 `* y, w" {" bvoid CMazeServer::UnlockCell( DWORD x, DWORD y )
+ f$ r) b8 R' x1 B' t{
    if( x == 0xffff )
        m_OffMapLock.Leave();
' j/ {) w: o7 A* |+ m3 ^7 X, }4 E    else
+ h" `) |. s( }; F; L  t( ]2 k% z- l        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
8 Z  G& ~# B# @7 U, O
: K& U. K9 ^7 e* n# K" |& k<>
//-----------------------------------------------------------------------------
// Name:
5 v7 Q/ _0 x4 l5 l$ x( |& l# y// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
: T( `5 \3 Q7 G" ]3 b{
    if( x1 == x2 &amp;&amp; y1 == y2 )
9 M* Z* J" w2 K+ V    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
& m8 W0 T  }: S0 L* e, `        else
            m_OffMapLock.Enter();</P>
<>        return;
  o! s. u5 t1 c    }</P>
+ D4 f* h) }( q+ T& A2 ?: W<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
! I" J) _) v- ]* f" {! r    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<>    if( x1 == 0xffff )
6 U. z% p" s6 O- \: Q    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x2shift,y2shift);
    }
2 D$ n+ x  o3 y* w( U- ]    else if( x2 == 0xffff )
' p* Z9 \- _- [7 z3 q    {
. h  L9 U( q3 r  u6 l        m_OffMapLock.Enter();
$ i/ }5 H8 R5 D& o! [: B        m_LockGrid.LockCell(x1shift,y1shift);
    }
  q- w. _' y( F9 T' {! n    else
    {
& A7 x  ]4 b! T! a        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
4 C! t0 B; m: D; L. d, b0 K    }
}</P>

<>
//-----------------------------------------------------------------------------
// Name:
# v/ M. h+ n6 [' i// Desc:
//-----------------------------------------------------------------------------
: t3 O9 i* `3 b  X0 X- avoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
  C3 ~; q% v# a{
    if( x1 == x2 &amp;&amp; y1 == y2 )
    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
4 y, P( H# L) r0 t            UnlockCell( x1, y1 );
/ i4 J$ E6 M5 d3 P        else
' \( P; _  o; M( p            m_OffMapLock.Leave();</P>
+ U6 X6 e+ o9 r0 p<>        return;
    }</P>
* D3 S4 W- z2 g& E# I) ]8 K<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
' I2 }' R5 _+ n' _9 i$ i% ?    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
" ^% t3 Q- u( ^; w    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
) A7 G2 z- |4 I$ ^8 K  c& P+ K    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
/ k, L* t* q. x$ B$ D0 e/ n5 }<P>    if( x1 == 0xffff )
    {
" F. Z: A* X9 {; n8 P        m_LockGrid.UnlockCell(x2shift,y2shift);
2 ?9 W2 I% c' q2 h9 ?        m_OffMapLock.Leave();
" }4 Y# O5 |4 M    }
    else if( x2 == 0xffff )
& Q5 |6 r( V( f: L. X: Z* X; z    {
        m_LockGrid.UnlockCell(x1shift,y1shift);
: v7 L$ R8 O: k- E4 d8 E, ?! s        m_OffMapLock.Leave();
8 V6 g  H% F. B    }
$ r3 N* W$ V% \0 e/ n: T! ?    else
    {
        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
}</P>

' j. P0 c* X7 d: s<P>
& P3 ?2 v) @% J' ~  v" y3 G' s% u" Y//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::OnAddConnection( DWORD id )
{
( r; u% p: h# Q9 k    m_AddRemoveLock.Enter();</P>
<P>    // Increment our count of players
    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
    }</P>
<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
; n  W  ]& r: }7 v7 [4 C, Z        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
" L, N% z9 z: [  f<P>    // Create a player for this client
: c7 E4 u' n/ s; r& _! B+ Y  D    PlayerData* pPlayerData = CreatePlayerData();
. q- i' v" r) w8 c$ N    if( pPlayerData == NULL )
* Z  e) u2 H2 H: Z    {
) i* N  D2 G3 Q, m2 N) V7 P  e        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
        m_AddRemoveLock.Leave();
        return;
    }</P>
1 M9 ^" T: f1 ]% m  R4 D<P>    // Store that pointer as local player data
    SetPlayerDataForID( id, pPlayerData );</P>
/ `: @: r- j. }/ F4 |- Q4 B<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
8 W; }$ H6 Y4 \0 C& l    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
6 s/ k8 r% h7 S2 ]4 {' D<P>    // Send it
' p7 s. H4 O8 K    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
/ p8 O; v% T8 |4 U- `6 }1 [<P>    m_AddRemoveLock.Leave();
; J, x# n" z8 d" ^}</P>

<P>
0 H+ v: k& [8 w- [) i//-----------------------------------------------------------------------------
/ P" q# Y5 U7 C3 h/ G// Name:
/ g9 v. f6 f' P7 V. v# P// Desc:
% G: N; y% i8 F8 j$ ~& o3 D- P$ ]2 }//-----------------------------------------------------------------------------
2 s. P# o3 N, s9 U8 L) ~2 x2 tvoid CMazeServer::OnRemoveConnection( DWORD id )
{
. E0 S' M* u8 O* i5 ?7 D# }    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
% n" J& n2 a0 Z6 Z0 Y    m_dwPlayerCount--;</P>
% ?2 {' V, l* @. ^; x1 I4 r% Z<P>    if( m_dwLogLevel &gt; 0 )
    {
% p! c5 L; L; _- b" s: W6 P        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
" w3 B2 z0 y3 |        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
$ |, n2 {) t# N8 B    }</P>
2 z/ u, s3 w6 m' g; S7 x4 s1 E5 U* C<P>    // Find playerdata for this client
: s7 V- J6 }2 i. ?& y6 ]    PlayerData* pPlayerData = GetPlayerDataForID( id );
1 t/ b+ M5 N1 h' L0 ]. B% M) n& j6 h    if( pPlayerData != NULL )
    {
        // Destroy it
        RemovePlayerDataID( pPlayerData );
: G; l5 F8 F( E# O* ]# T7 N4 s        DestroyPlayerData( pPlayerData );
    }</P>
<P>    m_AddRemoveLock.Leave();
6 U7 d. p& {, Y2 M7 G% {1 z}</P>
. T2 T0 n* z* Y' t. j
' \+ P* O4 Z: t<P>
//-----------------------------------------------------------------------------
* N8 e5 L* z( W, J1 V% |3 l// Name:
- H# Q! }8 ^# C. U% g4 Q// Desc:
3 |+ G8 {9 S8 E//-----------------------------------------------------------------------------
5 n# P9 ]" |+ d; |HRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
{
; V5 u6 Z: T1 O+ X4 G% _1 E    BOOL fFoundSize = FALSE;</P>
  r, y; L  D% |' Z/ M4 O<P>    // Increment the number of thread we have in this process.
+ k1 R+ Q" w5 h( }% B    m_csThreadCountLock.Enter();</P>
<P>    //Get the start time of when we entered the message handler.
1 d7 [6 r! P1 R; R% h1 Y    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
" M1 j0 r6 ~' u  }) v6 ^0 m<P>    m_wActiveThreadCount++;
    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
/ |1 r8 S! W+ y  D        m_wMaxThreadCount = m_wActiveThreadCount;
7 ~$ W* a5 P. D: ~( V   
    // Calculate and average.
* K7 S( B' _! s! p    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
( @: L( G0 L, ^* N( B    m_fAvgThreadCount += fdiff/32;
   
0 l1 Y& T+ l: r! W    m_csThreadCountLock.Leave();</P>
% a1 w( g: Z7 ?. O/ J- I2 ~7 Q& i<P>
    ClientPacket* pClientPack = (ClientPacket*)pData;
4 G  f! e; x2 T& z9 H    switch( pClientPack-&gt;wType )
6 i- q8 S. K) P% k& z/ `2 l7 I! A    {
4 P: U7 e  k# s' H4 C        case PACKETTYPE_CLIENT_POS:
% U' G& X+ }1 n9 I; P3 P8 X            
            // Check to see if the packet has a valid size. Including
7 I* d2 O- ^* u0 b            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
6 y9 y% C- V/ c  ]5 }+ Y- f                fFoundSize = FALSE;
7 I4 x4 o+ Q0 R: V- x9 I            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
                fFoundSize = FALSE;
            else
                fFoundSize = TRUE;</P>
<P>            // If valid sized packet, handle the position.
            if(fFoundSize)
8 u% Q8 t8 }& l5 i* R7 M                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
  h7 y( F! L8 o            else
0 X8 U1 P& ?/ \, \                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
* O, n$ \! y8 A$ f6 [# K8 A! d3 k<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
3 |& W9 k8 S% u, Y            if( size == sizeof(ClientVersionPacket) )
                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
3 g) t$ g: Q% G# M* j( V2 D            else
4 j+ a' ~$ v0 T1 i                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
3 g! u) l8 S( r3 d1 Q: q4 m0 J            break;</P>
4 [) I% ?1 i' e; Q  ~8 v: Z( y<P>        case PACKETTYPE_SERVER_CONFIG:</P>
<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
* _0 T9 Z: Q9 i8 J1 N<P>            break;
: W3 u* l1 V5 ?        default:
3 U; V7 o2 y* ^! q, K            HandleUnknownPacket( dwFrom, pClientPack, size );
+ f* C% a7 f2 R* G1 @/ L" d            break;
& ]  J: l# A% I% R; e' P4 d. F    }</P>
<P>    //If the user wants to hold the thread, Sleep for given amount of time.
    if ( m_dwServerThreadWait &gt; 0 )
8 t5 }/ j4 n3 n4 F    {
9 M$ b0 }1 z7 l        Sleep( m_dwServerThreadWait );
2 N; X! n$ r: U; j2 _$ R& R1 P    }
! W& T5 N# q+ b0 B: d   
9 f9 e' Z/ d$ Z/ s: }8 ?- K7 C; t    // Retrieve thread data for this process.
    m_csThreadCountLock.Enter();</P>
<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
    m_fAvgThreadTime += fDiffTime/32;</P>
<P>    //Get the Max time in the thread.
/ w2 \! m! S* p4 b; {1 P    if ( fDiffTime &gt; m_fMaxThreadTime )
  g0 b0 o& P- S, T% ?/ G    {
1 T# h  s2 m0 S0 ~8 ]& [( e0 b        m_fMaxThreadTime = fDiffTime;
$ _+ }% e9 n: I) G6 e9 L+ [    }</P>
- s, t5 P' E& d<P>    m_csThreadCountLock.Leave();</P>
. C& c% S, F) [<P>    return S_OK;
}</P>
8 ?8 J6 s% z% H3 z( `
) f. p: I3 A, W<P>//-----------------------------------------------------------------------------
% |  r6 ~* I3 j+ u( q1 P# ^// Name:
0 M7 z. ]. G; W! Y% W9 G// Desc:
//-----------------------------------------------------------------------------
BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
4 S: q! {6 U# W% Y3 f9 R{
6 N  P" _% S; f9 R- V    BOOL fFoundSize = FALSE;
. c$ z) z0 W4 I! _2 E3 E. x    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
; i  ?, l1 R; A% _. M* y/ Z* z   
: K& h5 b* V9 B; Z  h    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
            {
                // Found valid size in the array.
                fFoundSize = TRUE;
                break;
5 }; N" s& w8 }6 L* E9 K, F" D            }
            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
8 p0 P" i. x* ]6 v7 }$ q/ ]& a        }
    }
    else
( o. t# g5 x0 L7 z( n, _    {
( e. u0 B8 \* H        fFoundSize = TRUE;
: x+ F, m5 S& c+ m4 D) {$ Q' N    }</P>
5 ~1 O/ J# \; `1 M- ^/ Q<P>    return fFoundSize;
}</P>
" G" A& m! L  p' V8 m* O<P>
//-----------------------------------------------------------------------------
// Name:
$ p: f( t) s! J% b0 q" V( N// Desc:
$ p' |2 v1 z& D" F) p! B//-----------------------------------------------------------------------------
% T8 w5 m8 F# a- E1 ivoid CMazeServer::OnSessionLost( DWORD dwReason )
& p9 s9 [# |! R' i) M( V{
# f* u# h, z  Y2 m) ~7 i) [    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
* v; |8 u3 I. m4 }9 k& A+ D}</P>
: @; _8 `" g& G) C6 s, y
<P>
1 b) k9 q; U/ u//-----------------------------------------------------------------------------
// Name:
// Desc:
- v% p: W6 ]" J. u+ x4 i) _//-----------------------------------------------------------------------------
9 y) a" }' O# |: C# F, U8 \% mPlayerData* CMazeServer::CreatePlayerData()
0 B5 i: w) G+ S* U) X, r7 P9 b) b{
- u3 X1 R5 n( s1 L: L* W% R' [    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
  q+ [6 ], [. l& c    {
, O+ Q) A* S, s* U        LockPlayerData( pPlayerData );</P>
<P>        // Got one, so remove it from the free list
/ f7 v: B+ l- u4 L        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
        if( pPlayerData-&gt;pNext )
' m# ~4 D0 _. b& P. |) F( U            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
: K4 T4 r8 k5 E. B" F' q<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
6 x" u: _/ P+ u- z# Z% h# D        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
        m_dwActivePlayerDataCount++;</P>
6 [- s; L- ~% `* M2 Y2 O" r( N<P>        // Generate the ID for this player
        m_dwPlayerDataUniqueValue++;
$ g9 v; x! i! D& J4 T        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
        pPlayerData-&gt;NetID = 0;
% ~  s2 u! B7 d7 @; o/ R6 H* E        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;
        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
2 X( W0 M: F4 N6 U2 m        m_OffMapCell.pFirstPlayerData = pPlayerData;
        m_OffMapLock.Leave();</P>
<P>        // Mark as active
; q" |1 t  X1 Z$ \7 H' b+ ]3 N" m) T        pPlayerData-&gt;bActive = TRUE;</P>
<P>        UnlockPlayerData( pPlayerData );
: q' T) v; W% k7 O9 r* ~0 W, g    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
<P>    return pPlayerData;
" I7 L- |/ Q" ?) p}</P>
+ N3 R1 R# J" i) c+ C/ D
. w8 n7 |7 e/ B) b3 R" ~0 t<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
+ m5 i/ z2 Z% O9 h! m8 y% @//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
{
) x- ]( W  q2 W+ y    m_PlayerDataListLock.Enter();
- {8 I5 z3 @9 B. x- w3 Q3 }    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
$ Z1 O5 M8 Z; A- y0 J% T$ q    RemovePlayerDataFromCell( pPlayerData );</P>
<P>    // Mark as inactive
* h' U' \4 M, i: t% u    pPlayerData-&gt;bActive = FALSE;</P>
, L% P) y; T6 k8 @$ z<P>    // Remove player from active list
4 w& S1 O4 g' S. |% t6 \% O    if( pPlayerData-&gt;pPrevious )
7 Q2 l7 {  c! D        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
; o& h& j# t* n* }    if( pPlayerData-&gt;pNext )
: `# }( b, y, j4 y; ~* h        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
- c# ~. o3 C9 \1 @0 @    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
2 m8 [- }8 d5 b1 C% F    pPlayerData-&gt;pPrevious = NULL;
    m_pFirstFreePlayerData = pPlayerData;</P>
<P>    // Update count of players
/ H# |+ _: Y1 M+ n8 k    m_dwActivePlayerDataCount--;</P>
  @- p( `1 C) u6 k& v  |5 \3 d<P>    UnlockPlayerData( pPlayerData );
/ h3 m1 Z8 J- |+ `8 s, a    m_PlayerDataListLock.Leave();
}</P>

/ {  J# X8 J4 A  X' d1 O; Y. W. K2 u<P>
5 E! [+ Z. L  G% U+ u/ [$ A* c//-----------------------------------------------------------------------------
// Name:
2 k( j. k2 y$ S) y9 A// Desc:
//-----------------------------------------------------------------------------
7 n& n6 T  H% [4 c4 evoid CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
. }0 }1 N6 c4 A7 N{
    // Lock the player
    LockPlayerData( pPlayerData );</P>
, X/ R) I/ h' u1 R<P>    // Lock the cell the player is in
    ServerCell* pCell;
    if( pPlayerData-&gt;wCellX == 0xffff )
1 F$ h4 f! c' s4 A5 E    {
        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
    }
    else
$ }8 h) s) b: U2 `$ {, F: P    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
9 U& k; q) y; ^7 _2 k4 b- g3 b  d* ?    }</P>
<P>    // Remove it from the cell
    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
5 L1 u& `3 @5 q3 A    PlayerData* pPrev = NULL;
    while ( pPt )
    {
. T! i( ~. q; K9 M        if( pPt == pPlayerData )
        {
            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
$ e6 Q. x- R/ C1 o7 s# h            else
! A9 Z+ _' b/ ?+ V+ z                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
<P>            pPlayerData-&gt;pNextInCell = NULL;
- `- @) I. W& n$ L& g1 f- F            break;
- S! O0 N3 O0 y+ a1 y7 Y0 D1 Y        }
+ x4 ^7 K, d. y) K        pPrev = pPt;
' S( N5 `7 X/ T0 \, p( X        pPt = pPt-&gt;pNextInCell;
    }</P>
, o1 y* e* H5 S( ], n3 n<P>    // Unlock the cell
9 m' I! ]8 u, ~, a, s    if( pPlayerData-&gt;wCellX == 0xffff )
        m_OffMapLock.Leave();
2 p2 h) _* C2 h! a4 |: U    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
- E( `  l* |* E8 S, t" `# H<P>    // Unlock the player
    UnlockPlayerData( pPlayerData );
}</P>
' `/ ^, e: G) }5 w9 g$ g
. h! @' z; o1 o: e* g6 t  r# \<P>
; v5 @' p, {% T; F9 T//-----------------------------------------------------------------------------
' ^' L6 s/ f, }) c// Name:
3 R. ^7 c- c' S5 ^/ ?// Desc:
+ u" C, h& ~. g3 s# j//-----------------------------------------------------------------------------
. l8 @* C/ l" K) h% R, l% rvoid CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
{
8 ]5 S* R$ N% l, W6 J    ServerCell* pCell = GetCell( pPlayerData );
) }; c. g# H8 F3 M! s2 D: S- D    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
+ r' U8 V, A# H5 |; q0 Q7 Z: l    PlayerData* pPrev = NULL;
) z+ L: t: h% o    while ( pPt )
    {
        if( pPt == pPlayerData )
        {
2 `; E' e5 t2 A1 ]            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
, w& m( W9 y" a! [0 o            else
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
+ u/ Q/ U- a; U0 {( O            pPlayerData-&gt;pNextInCell = NULL;
( E; Y4 j& x4 |% w- s. K            break;
0 X! x) l, c& q$ m3 E0 }' x$ o        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
  b% I2 q4 ^% T; g- v" c    }
/ f  w2 D& N6 p# n}</P>

, B1 ]& p, F  Y% `& p1 `/ f<P>
5 m2 M. i4 C1 S  B//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
0 ]4 d2 M% m9 R% S5 j    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
$ L# P( G5 j  j0 s: X    pCell-&gt;pFirstPlayerData = pPlayerData;
( V; p1 D. N1 G* u" t}</P>

<P>
. ~) V. x9 C' j; v//-----------------------------------------------------------------------------
+ k, B* f2 a( s; }/ I  ^, Y$ I, @// Name:
7 u7 ^) _% C; s: {' e4 A// Desc:
3 S+ v$ ]9 n' n6 i- A//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
% P* B: N. J$ @  ~3 O4 I    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
; B5 y) i6 N' M8 e( Z  J) r* Y    {
        if( m_dwLogLevel &gt; 1 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
        return;
- p7 L3 T% |! d8 d    }</P>
<P>    LockPlayerData( pFromPlayer );</P>
# w: f0 t% t: q+ ]5 l<P>    if( FALSE == pFromPlayer-&gt;bAllow )
# r3 c+ U. p$ ]$ X$ L4 U9 e( f: v( w    {
) U/ V; V9 z. C/ L$ E% A: }        if( m_dwLogLevel &gt; 0 )
, f5 ]' v6 W1 T# b* G            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 );
7 I; m$ k1 ?  ]3 ]1 r( F0 b        UnlockPlayerData( pFromPlayer );
        return;
2 |. z4 W$ T5 m8 N* R7 s4 a7 j) w2 `    }</P>
4 i" I" F: @0 E<P>    // Compute the cell the player should be in now
, O3 k- L% q/ ^* i; V    DWORD newcellx = int(pClientPosPack-&gt;fX);
    DWORD newcelly = int(pClientPosPack-&gt;fY);
- e4 q' M8 m' V' Q" o: G    DWORD oldcellx = pFromPlayer-&gt;wCellX;
8 a* `7 ^$ L" [7 w    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
<P>    // Have we moved cell?
' h- E/ B/ m) k( M! c    if( newcellx != oldcellx || newcelly != oldcelly )
, @9 A4 F6 _! x4 S5 \/ W% q- U    {
        // Yes, so lock the pair of cells in question
& H: X1 t) b9 K* d        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
<P>        // Remove from old cell and add to new cell
        UnsafeRemovePlayerDataFromCell( pFromPlayer );
        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
5 z( x! c( F& K: }        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
<P>        // Unlock cells
8 N4 z( ^9 a) F& m' X        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
/ j+ i9 V4 z  ]  r* B& H    }</P>
<P>    // Update player position
    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
; `7 {5 h* e& R! C4 d    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
" P* H% }& `; l1 U1 S* \: _' ~    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
& K. p& o! O) L+ L0 I9 f<P>    // Allocate space to build the reply packet, and fill in header
    DWORD dwAllocSize;
; I' C0 Q2 o* w) J/ V# V    ServerAckPacket* pSvrAckPack = NULL;</P>
1 O# S4 Y5 A5 M<P>    // Begin by allocating a buffer sized according to
    // the current number of nearby players + 4.  This will give
9 k& J' [6 T7 N% c    // a little room for more players to come 'near' without resize
- y! R. c# K" \% W& t/ i    // the buffer.
& J9 e4 E5 z- v' l    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
# E4 a! ]" a; R" C! P9 x<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
* N4 i- v1 Y5 |+ F: o. T# v: [    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
    {
        // Out of mem.  Cleanup and return
7 P: p5 l2 g5 Q* P8 t        UnlockPlayerData( pFromPlayer );
/ u* r/ g) e) e- A4 [& a$ S        return;      
    }
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
7 V+ x( O  F* R! Z9 m2 `<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
( ?# b0 c: }( Z) a<P>    // Compute range of cells we're going to scan for players to send
% H, J' U  j: n! M+ D2 |3 H6 k! H+ O    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
9 f2 k4 \2 T. m1 H4 n& o, [    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
<P>    // Lock that range of cells
8 G7 {/ b" l- \+ }    LockRange( minx, miny, maxx, maxy );</P>
<P>    // Scan through the cells, tagging player data onto the end of
( _7 U. C$ C0 b, [( Q, O. R    // our pSvrAckPacket until we run out of room
1 z! T# ?# b) ]% |( ~) N2 ?    for( DWORD y = miny; y &lt;= maxy; y++ )
+ G* Z1 n; B; _& }3 F5 q4 x3 k0 ~. D    {
' G! a2 `4 b6 w+ J        for( DWORD x = minx; x &lt;= maxx; x++ )
        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
/ p" B4 v& P% U2 k            while ( pCurPlayerData )
5 a2 Y9 e& W1 _7 f            {
                if( pCurPlayerData != pFromPlayer )
                {
2 e2 }, h% {! }# D                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
                    {
                        // Make sure pChunk is where we think it is
7 t9 x3 B$ S; W" k0 {  b2 J                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
; N0 Q0 y7 h: v5 c0 L5 K& Q/ f* f<P>                        // There are more than just 4 new nearby players, so resize the
- g4 E4 g3 M7 v' W9 }- O3 N                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
. _' ]$ G; H+ F, E0 t2 w                        dwMaxPlayerStatePackets += 16;
* Y" N/ z) ~" R* Z3 ?5 ^                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
                        ServerAckPacket* pNewSvrAckPack = NULL;
& s! {/ U; g9 r                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
                        if( NULL == pNewSvrAckPack )
; J8 h6 l/ F; }* G. @                        {
                            // Out of mem.  Cleanup and return
4 `" @' |; |& [+ @! h2 }0 W4 s% c                            free( pSvrAckPack );
+ P) j  M' W" {0 Y% F                            UnlockRange( minx, miny, maxx, maxy );
                            UnlockPlayerData( pFromPlayer );
8 N' |) e1 y  S* R; ~5 l& C" x9 }                            return;      
9 b7 z7 D- a/ W5 C- h                        }</P>
* N$ c: ~% K/ i% e8 d7 K; O<P>                        pSvrAckPack = pNewSvrAckPack;
; H  D: n+ M; ~8 c3 K6 U7 D. l                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
# |. D0 w2 U( S2 J/ T) z<P>                        // Make sure pChunk is still where its supposed to be
. W/ |! b2 C7 B/ i; C5 E/ G! e: z: i                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
# U: C$ V1 _" r& \                    }</P>
  A# Y* i5 l) G7 m<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
  E! A0 H' \9 ~                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
                    pChunk++;
6 h  R: }0 T" l4 c/ Y: }8 s" m( M                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
        }
" O, F* J1 C( e% s  w    }</P>
<P>    // Update the dwNumNearbyPlayers for this player
4 @' J6 c3 x$ w    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
<P>    // Unlock range of cells
    UnlockRange( minx, miny, maxx, maxy );</P>
& h, S2 F. _- i* ^$ C<P>    if( m_dwLogLevel &gt; 2 )
    {
! E+ O% M, R; k. W        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
9 D7 @* l4 T# [    }
    else if( m_dwLogLevel == 2 )
    {
        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
% i, o- l4 X' I1 j) F5 u( `        {
: d5 E5 `$ \/ |. q* T7 x            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;
3 X' D1 [. c- L6 k1 K  B+ I) S        }
    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
4 W7 q$ Y! T9 i! k$ W3 Z# }) m<P>    // Send acknowledgement back to client, including list of nearby players
9 |" U2 {' v# R+ H0 ~* c    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));
, C: N" G- J; w8 M% @, g8 d
    // Pack the buffer with dummy data.
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
7 n' E+ c- J5 Z3 @        VOID*   pTempBuffer = 0;</P>
. Z* I" `/ o* a<P>        pTempBuffer = malloc(dwBufferSize);
        if( NULL == pTempBuffer )
& S* L: U* V& l" H  f        {
            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
! ?2 O9 x/ E" m3 i# a. I            free( pSvrAckPack );
7 W$ p/ g7 {- }4 H( |6 H            return;
        }</P>
2 |. ~  }/ A$ e! a( R' c<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
* r( Q5 J/ D  D- @2 e. I0 N' M   
        free(pTempBuffer);
; o/ t0 ~! y% S4 v  I' t) ?& H    }   
$ e7 H; c  x9 A8 `5 _    else
    {
& b* S+ b  B/ H1 H% W        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
7 }9 ]* }; b$ f3 Z    }</P>
/ |( W0 ^, ~4 V* J. K. E* V<P>    free( pSvrAckPack );</P>
: O3 X' I2 F- W' i2 g<P>}</P>
, j3 d+ U/ D7 T2 X
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
8 H, e: [+ T. i/ o& s! ?# A) w//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
# G0 C. L; S% H$ r2 q    if( pPlayerData == NULL )
        return;
" z+ O* {; q+ K) ^7 A0 y    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
: Y/ A/ T, h5 \2 E<P>    if( m_bLocalLoopback )
        pPlayerData-&gt;bAllow = TRUE;
  Q4 D( l% c% h& x8 v* U1 t4 ~0 s, ^    else
        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
7 }4 g  x4 F9 {4 y( I2 i! f4 J$ w<P>    if( m_dwLogLevel &gt; 0 )
0 |+ W" G4 v, P# R        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>
! U! [# C! @2 ~/ C+ j* L<P>    if( FALSE == pPlayerData-&gt;bAllow )
) g4 ~! G6 v, P. ^# M    {
0 A3 M5 X7 |7 ^) \- j        if( m_dwLogLevel &gt; 0 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pPlayerData );
3 t. f. z# [( t! @: W) l1 k+ v4 i2 r        return;
+ L. \  f, U( b+ ^    }</P>
<P>    // Unlock the playerdata
    UnlockPlayerData( pPlayerData );</P>
" S, }% T0 ~0 \% U& j* E<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>
6 S, h2 p1 O. R& _' }0 Y: w
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
5 y7 n/ H4 P8 Q9 y" s//-----------------------------------------------------------------------------
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
# e- _5 I: B+ W6 ~  X3 \. A{
    switch( dwClientVersion )
. A; Z9 `* x' P9 A7 W& H    {
        case 107: // only v107 is supported
& Y9 X; M6 P3 q' s( D# n1 E+ j            return TRUE;
% S* z0 o' X, T1 f; e4 c* t1 j        default:
, Z4 a+ H% O8 f            return FALSE;
. r4 i. \- U; d    }
}</P>
- x; \; ]3 Q, M0 {9 z
<P>
8 E2 A; B. T6 F//-----------------------------------------------------------------------------
3 g6 w4 i0 B* `. k7 o+ s// Name:
8 q# @: |0 B. V# m) p2 x+ K// Desc:
//-----------------------------------------------------------------------------
: v3 F1 [  I2 F/ Fvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
. I' x) x7 J# a# x$ U{
    if( m_dwLogLevel &gt; 1 )
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
0 N; A# y) D% o. A/ S<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
}</P>
; m' s$ g; C# h. {) a
<P>
//-----------------------------------------------------------------------------
// Name:
" Z0 s* p+ u. r6 @  T// Desc:
//-----------------------------------------------------------------------------
& t" F. F) x0 {DWORD   CMazeServer::IDHash( DWORD id )
! e3 J$ s& Y+ g( E{
    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
' \6 p. E. h7 Y( [1 |$ O; e    return hash;
; {/ ?& H# W" f, p0 y  P}</P>
0 `" r+ b" Z+ |9 c, v# }5 k
1 ]/ J7 G  b. q0 u<P>
- Z5 u6 K) ?+ x( S; a9 V# p//-----------------------------------------------------------------------------
& ^" J$ H3 K+ G' N// Name:
" @. ]& i0 {2 y// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
7 ^+ h; U% Z1 }2 e{
7 U. q5 C  Z# @# H8 K% k! f    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
2 N( }& a7 E; G% N+ r* y7 E: O<P>    // Lock that hash bucket
# K* Y/ m6 i" m/ X0 ]' @7 _    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
! M# G$ f: ?2 H' _  B/ I, z8 p<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPt = m_pstIDHashBucket[bucket];
    PlayerData* pPrev = NULL;
    while( pPt )
/ O# s2 j% P( ]  c4 B$ w0 Y6 L    {
7 Z- h+ d) G# C8 j( b! h* t        if( pPt == pPlayerData )
- g0 e' V" a2 b% o- m            break;
2 b  V  A/ U* P, Y! ^& V( P5 a! p        pPrev = pPt;
        pPt = pPt-&gt;pNextInIDHashBucket;
( E' O" s3 b$ T/ b    }</P>
2 J+ l' i0 U* Q! G1 Z5 o9 {<P>    if( pPt )
    {
5 {# M% }/ }) D, v: ^        if( pPrev )
            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
; d. H  C# G* \2 o' D' F        else
            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
        pPt-&gt;pNextInIDHashBucket = NULL;
' K" R! M* A# d    }</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
. }, b4 v0 v. D' T# l2 \( o' l}</P>
9 s( I% a9 Q1 v4 S
<P>
//-----------------------------------------------------------------------------
// Name:
% W+ P  ~$ \% D) |& r# f// Desc:
: ]' ?$ o- c' t5 V, S1 A0 y- ^//-----------------------------------------------------------------------------
  V- I$ O* G8 Rvoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
$ ]& }5 Q  J5 l1 v{
    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
/ y0 {/ u  z7 R& i5 _3 t    // otherwise there will be a circular reference
    PlayerData* pSearch = GetPlayerDataForID( id );
    if( pSearch != NULL )
        return;</P>
5 @# F( M' N1 _3 v6 U& t<P>    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
+ h" ]. q: v. x, I! J; O<P>    // Lock that hash bucket
8 s9 z: A! t6 m$ ]/ S1 X+ }    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
- v; g  N5 J1 r0 m<P>    // Add player onto hash bucket chain
3 ^7 u6 m/ ~+ N( U    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
7 B: ^/ b; X" }/ w* _/ _    m_pstIDHashBucket[bucket] = pPlayerData;</P>
' c0 F- k) a5 U3 e( ~* h4 _<P>    // Store net id in player
% a0 D- |- p5 e* c+ p    pPlayerData-&gt;NetID = id;</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>

9 l; H) |0 O7 v- t1 o& B  v1 n: z# H<P>
//-----------------------------------------------------------------------------
// Name:
& H# n# r) K+ ~7 Z5 B3 z: P% I- R// Desc:
//-----------------------------------------------------------------------------
) J3 P6 g8 w" t6 pPlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
{
& G& K2 g9 W) i( K" Q    // Hash the ID to a bucket number
4 O' g& d% E" \- l' Z    DWORD   bucket = IDHash( id );</P>
6 x/ D- `/ Z1 R5 O7 g<P>    // Lock that hash bucket
1 s. X1 A6 P+ y3 v7 n8 K# f    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
% q- u0 z$ a' j1 y# ~    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
" C# ?! F( d2 b; J<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
1 c( o6 g! K) `* i: }; _6 F! Z    while ( pPlayerData )
% [2 O0 x1 |6 E$ C% I# K5 _$ u( _    {
        if( pPlayerData-&gt;NetID == id )
5 q- }  S$ Y" K& j, h8 W; O+ o, N/ q0 Q            break;
        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
' |4 R2 N& G5 G: L% A5 f+ Z7 [    }</P>
7 t( u5 @( q# B, l& }3 @' k<P>    // Unlock the hash bucket
0 A6 n  A; F/ e* G- Q' ?    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
" |& p- m1 _, R" A<P>    // Return the player we found (will be NULL if we couldn't find it)
    return pPlayerData;
0 Q( ^8 M1 D$ X1 x+ x}</P>
4 e3 C+ g6 K" q0 W6 F
<P>
0 w3 C+ R6 o2 m1 I. i//-----------------------------------------------------------------------------
// Name:
# `$ G% [5 q: [, Z. M6 ^( w2 j// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
$ G$ _. I7 S4 T: j; Q: t& ?9 j* }//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
' Q6 r' H7 `$ M. R: ^$ f) T7 V{
' n' F  h8 q8 k4 `; S    if( m_pNet )
    {
) U- {. Q( a6 x4 b( [% }" `        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
# ?2 }/ s. h, c* B% u5 F2 H5 X# S        PlayerData* pOldestPlayerData = NULL;
$ P7 ?2 s1 n7 U6 s5 k0 o        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
; B! J; D9 j" i" b. J) W# p<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
+ |5 I: o6 k; |3 Q% i        while ( pPlayerData )
) Y2 ~( b9 K1 H/ S' h1 i/ j        {
            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
            {
; X* e1 v5 \9 O) T                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
0 s! y$ U+ C* F! T                pOldestPlayerData = pPlayerData;
3 d% a; |( A5 J; `  A3 g            }</P>
<P>            pPlayerData = pPlayerData-&gt;pNext;
7 ^& K% c3 r0 d7 {, e9 a) g2 H8 ]        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
, u, ]" S' b+ M/ i6 b        if( pOldestPlayerData )
' z0 q8 h' _1 |, X        {
8 }4 c' s% a& r' T            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
            pOldestPlayerData-&gt;fLastCITime = fCurTime;
        }
0 B+ z; Y- z! N! g        else
$ i/ \( w7 V! K' A- ^        {
# B1 n( t" D; d) R/ U# Y9 T            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
        }</P>
5 d7 j9 @5 p7 R4 F5 e+ i! Y<P>        m_PlayerDataListLock.Leave();
$ U( h. b$ K2 d- V2 q* _0 |: L    }
5 ]4 W: z! z8 |. m}</P>
/ Y+ n$ h4 L" g
. p% b' A% A' q% P" a- K- v<P>
//-----------------------------------------------------------------------------
' A) `, k1 Y0 o8 |1 l// Name:
// Desc:
: v2 ]- b7 M2 V  ~//-----------------------------------------------------------------------------
$ S$ y8 J) u; l6 }  P4 n$ h+ ~  Ivoid CMazeServer:rintStats()
" r9 ?" _3 Y+ [{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
1 M4 c# ~& s9 P$ X5 [+ {7 a( C6 Z    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
                                    m_fAvgThreadTime, m_fMaxThreadTime );
. @3 \+ v) B9 t+ z: ]# m2 Y    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
}</P>

/ r1 y& `  H1 w# P6 v" |<P>
//-----------------------------------------------------------------------------
// Name:
$ l) `7 V# g: o" ~! \7 Y// Desc:
3 B- [. j" j2 o4 W& ]//-----------------------------------------------------------------------------
7 S& n. ~1 _6 v! `3 s% v1 Lvoid CMazeServer:isplayConnectionInfo( DWORD dwID )
' w4 K" o3 U0 L4 `1 A1 t- K{
' L$ Z# K* J1 r1 R! x7 B* x    TCHAR strInfo[5000];
/ J( t2 a" v: g3 x    TCHAR* strEndOfLine;
    TCHAR* strStartOfLine;</P>
<P>    // Query the IOutboudNet for info about the connection to this user
    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
: s, C9 l, ?1 b1 i" _: T<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>
8 t; s( E+ x- t( v2 v2 v) ^) F<P>    // Display each line seperately
) F" v, ?. C4 o7 c$ Y) u8 E/ n2 O    strStartOfLine = strInfo;
    while( TRUE )
, \% Q- e7 E: `& D( v    {
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
7 O# V4 g' ?3 ?0 o. i8 y        if( strEndOfLine == NULL )
            break;</P>
/ v" D( R- B; B2 E  {<P>        *strEndOfLine = 0;
, \; i& |; z- C% z8 l        ConsolePrintf( SLINE_LOG, strStartOfLine );
% w* \! |% e5 \  V$ l  E9 P        strStartOfLine = strEndOfLine + 1;
    }
3 Q: ^2 w0 j1 A" @}</P>

/ V& k+ L) n8 s5 z0 h<P>
/ s5 v4 d' g, W  H% G//-----------------------------------------------------------------------------
// Name:
// Desc:
2 \& V  N$ ]% B  Y" r) Z. ~. c//-----------------------------------------------------------------------------
! j: z) Y6 x+ C5 x& q: {5 bHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
4 U  J9 u+ ]* q6 P- p{
) \3 n+ z+ ]8 s    // Chance of forcing any packet to be delivered reliably
7 p' s2 @+ t1 J3 e& t+ g" w9 ]0 M    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
3 K0 P$ ~& r' @& T4 E        reliable = TRUE;</P>
<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
+ Q' \! n0 m  m" J& C}</P>

<P>
//-----------------------------------------------------------------------------
9 Z9 q4 j/ Q% a. b// Name:
+ D" N0 D& n/ F& G8 t1 Z" f- X// Desc:
//-----------------------------------------------------------------------------
8 t, u" n) ~2 q0 ?0 `8 Kvoid CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
    // If we're up and running, then send this new information to all clients
6 |; h: u3 T. S  J6 N    if( m_pNet )
9 \: G; o! S* k4 s" \    {
, B4 z! e# b) n        //Use the AllPlayers ID
8 ^  G$ Z4 D1 r' s; N8 m; A        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
9 q& {4 ~6 e3 t    }
}</P>
: C9 e) \; [) Z
<P>
//-----------------------------------------------------------------------------
& D: r# a" M! z: u1 i// Name:
. l3 Q# u3 B9 g// Desc:
//-----------------------------------------------------------------------------
( p' J7 ^% _% I- T" n2 |& R# mvoid CMazeServer::SetClientReliableRate( DWORD percent )
+ s+ Y% L( `0 B+ N: J# C* v6 Y{
! b6 u# ?5 ^1 w    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
. _( K/ B+ w3 W    m_ClientNetConfig.ubReliableRate = BYTE(percent);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
% L' m! Y6 I  v+ x/ X}</P>
/ I9 p8 }1 e) G+ Y9 g$ O8 f
8 E# t0 E- V# ?& P<P>
//-----------------------------------------------------------------------------
: _1 Q1 h. H  {! M// Name:
// Desc:
5 ^8 K5 C+ U8 Q6 e//-----------------------------------------------------------------------------
void CMazeServer::SetClientUpdateRate( DWORD rate )
( Y$ D7 G# }8 W" Q5 y/ P{
8 F& _) t& w$ ?- l    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
% G1 D: t4 z% f1 P    m_ClientNetConfig.wUpdateRate = WORD(rate);
: n' P7 f2 [# S1 E" b    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
: v% `# W9 [( P* T//-----------------------------------------------------------------------------
// Name:
) W! X- Z: n: }// Desc:
$ K1 v4 A* D! g7 D2 d  ~# R//-----------------------------------------------------------------------------
5 s( m0 U0 y4 B8 ?0 Rvoid CMazeServer::SetClientTimeout( DWORD timeout )
{
) P5 U" t# I. V    // Update client config, and build packet containing that data
0 S" c1 K8 T0 x3 D9 D$ X/ ]    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
3 ]% Y* G& x0 b<P>    SendConfigPacketToAll( &amp;packet );
}</P>
9 y+ W" z% D* x( L( `6 v' X
<P>
" }- p: K8 j6 f9 f( K# g! R/ B' Z//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
1 Q' \( L) n1 x) m$ \2 X" H% ]void CMazeServer::SetClientPackSize( DWORD size )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
   
- Q, I1 Z- L" e    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
8 f9 n; |, y; w) F8 e$ J        m_ClientNetConfig.ubClientPackIndex = 0;</P>
* z* o- ?4 F$ M4 m4 @# Y7 h<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
# V$ ?: c3 z+ B2 B+ s    ServerConfigPacket packet( m_ClientNetConfig );
, l! l  {8 J9 e0 M/ \6 W    m_ClientNetConfigLock.Leave();</P>
, T) K7 u1 `. ]6 H& K, m# f<P>    SendConfigPacketToAll( &amp;packet );
( w. k9 V. f1 H  O* X}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
! W5 F% ?6 D6 h! z! o5 C$ S// Desc:
- i4 p: b0 Y( x1 G' |//-----------------------------------------------------------------------------
, U& O% B1 I' ~- V( l7 |/ avoid CMazeServer::SetServerPackSize( DWORD size )
7 z1 C% B' z0 \" @{
    // Update client config, and build packet containing that data
9 x3 I6 D6 [  i: u4 S7 ?$ Y    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
& ^8 B+ `& h; r6 g# `) l    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
5 U; `" Q) l- k. o0 A: ?- ^2 c        m_ClientNetConfig.ubServerPackIndex = 0;</P>
<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
+ ~- [: \. M2 |) t# E( o<P>    SendConfigPacketToAll( &amp;packet );
' P" j" f( q9 Q9 y# B  B}</P>
3 U0 ^% N8 }) a7 d<P>
& G  f+ H. k( p2 T: F: Z: g9 G' J//-----------------------------------------------------------------------------
2 Z  u& r# c. p' f1 c2 a& i3 V// Name:
// Desc:
% S6 k, i0 B  D; j" O//-----------------------------------------------------------------------------
void CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
( ^1 t% c6 b# p3 P2 h1 ?{
    // Update client config, and build packet containing that data
; x  o! c# s7 o4 d6 f    m_ClientNetConfigLock.Enter();
) P/ q$ w6 f. X, l   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
    ServerConfigPacket packet( m_ClientNetConfig );
! H4 T: z# g7 Q9 [' l; H9 e    m_ClientNetConfigLock.Leave();</P>
0 ?4 ?9 y. g, Z- d# y& v2 L<P>    SendConfigPacketToAll( &amp;packet );
+ f9 [7 a: m4 e- c}</P></DIV>