[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
: o/ h) c8 m. o2 w; s' o<>// File: mazeserver.cpp
& c9 G9 V9 F' ?* I# L6 ~, T$ O) b//
  \4 K2 p$ K  b. F) b$ a& H// Desc: see main.cpp
9 c. Q& c( c+ t//
// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
$ t. L4 ^1 m- f( p# s//-----------------------------------------------------------------------------
/ {) [% c; n) L8 O; n#define STRICT
#define D3D_OVERLOADS
' o8 o2 f8 U" p( r/ i4 R#include &lt;windows.h&gt;
#include &lt;d3dx.h&gt;
* ]0 e& ?  O5 ?. V#include &lt;stdio.h&gt;
) \# O* c( v% l) m% r9 h" N#include &lt;math.h&gt;
#include &lt;mmsystem.h&gt;
#include &lt;dplay8.h&gt;
' E. [* C" A/ }$ w/ W* {#include &lt;dpaddr.h&gt;
2 ~& c0 Y6 `9 l8 _' i! G0 s$ n#include &lt;dxerr8.h&gt;
" X' P- d; I3 U( W3 Y. _+ S#include "DXUtil.h"
  q3 |1 V5 ^* H: |5 {+ p#include "MazeServer.h"
. c$ U( M  R' o+ Y' q#include "ackets.h"
#include "Maze.h"
% h; @  [6 W( s  |9 h#include &lt;malloc.h&gt;
#include &lt;tchar.h&gt;</P>
5 K# \3 K* W' r. n, u. k3 M
<>//-----------------------------------------------------------------------------
2 ?* z( K9 B7 Q6 ]9 S8 y0 Q# E6 J// Name:
// Desc:
//-----------------------------------------------------------------------------
CMazeServer::CMazeServer()
. \) B' Y3 k! @7 u4 w" A& Y3 @{
    m_dwPlayerCount         = 0;
   
    m_wActiveThreadCount   = 0;
    m_wMaxThreadCount      = 0;
    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
( [8 S* i7 D0 r- n4 c" n4 B) G) h    m_fMaxThreadTime       = 0;</P>
<>    m_dwServerReliableRate  = 15;
; J0 }9 g1 z, f! d    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
6 `" d5 E/ B7 x% d& |    m_pMaze                 = NULL;</P>
& e. S# K, }5 D  _! t<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
    m_ClientNetConfig.wTimeout       = 150;</P>
# h( x' n2 G, c& L* x9 q2 h- {% N2 m<>    m_ClientNetConfig.dwThreadWait = 0;</P>
<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
# D; `9 i: L* B, a$ z% p9 P    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
0 b8 K9 W5 z$ m# Q. ]$ l    }
}</P>
3 q/ l% X0 E$ O8 J0 l  }3 S
% d, f- n4 v4 `; \+ B  |; Z5 f<>
//-----------------------------------------------------------------------------
+ c- N, M( s6 s  M. J# e// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
    m_bLocalLoopback = bLocalLoopback;
    m_pMaze = pMaze;
! r  ?& @8 @  w9 I7 |) X0 `    if( m_pMaze == NULL )
) W4 F. G& F: O        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
8 Z' N4 F$ }* Q4 P0 V  z<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
8 C# z8 b! N5 G/ k# _6 U    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
6 a9 u6 R" q* s) p2 b        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
# {9 _' r9 c' n6 u    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>
# h# o3 R4 B. ^( F<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
2 ?. B7 G. b3 M5 x8 c    m_dwMazeXShift = 0;
1 U* z! o/ L5 K    while ( (scale &gt;&gt;= 1) )
/ c5 p" n6 {, w  r, ]        m_dwMazeXShift++;</P>
<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
        m_dwMazeYShift++;</P>
<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
        ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeYShift) != m_dwHeight) )
, b! q8 Z% e1 C: L/ t! o4 {; L5 y        return DXTRACE_ERR( TEXT("Maze height and width need to be power of 2"), E_INVALIDARG );</P>
<>    // Initialise the player list
    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
$ n8 a, s5 C# |0 D    m_pFirstActivePlayerData = NULL;
    m_pFirstFreePlayerData = m_PlayerDatas;
5 u& G$ ~1 v8 W. |    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
/ G, |3 `6 t: O- V! ?8 u        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
; \; }3 }! p0 m+ S. q. c! `    }</P>
7 |6 [3 U: S. F<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];
    m_dwActivePlayerDataCount = 0;
    m_dwPlayerDataUniqueValue = 0;</P>
/ B( w5 G0 P! b: d<>    // Initialise the cells
    ZeroMemory( m_Cells, sizeof(m_Cells) );
    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
) t8 W0 J. O3 p* o: z5 f<>    return S_OK;
4 P' c0 O% W1 I1 }% t  j}</P>
3 C# b( ^9 L0 c' Y5 a
<>
$ b; o2 t1 [6 l; Q: x+ h//-----------------------------------------------------------------------------
// Name:
// Desc:
: @) l0 x4 D* w% N  T//-----------------------------------------------------------------------------
void CMazeServer::Shutdown()
5 k! B* k  e5 S" c& {/ N{
}</P>
2 Q! O) l4 A$ X/ M& n, n
; b6 K) r; i9 Q# }<>
" h( c2 I0 h7 }' w: b. [; U//-----------------------------------------------------------------------------
* T2 s/ Y' y  w/ j  C% j// Name:
% A: N- v" t4 }5 d- J' |// Desc:
7 b/ E6 _9 K- h) v//-----------------------------------------------------------------------------
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
  b: s; |! g4 N& h* q: s& [- u6 U{
8 |6 I3 Z/ \2 J  k; |    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
6 S( S3 i& a% l" w5 K* \( F                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
; B0 u7 [$ i! d2 p/ }# H}</P>

<>
//-----------------------------------------------------------------------------
; h  [$ v! Z1 o// Name:
// Desc:
, u% j- U1 O7 p: Y- ]//-----------------------------------------------------------------------------
; U/ p2 W6 p( Q# L* M( Q# }! Jvoid CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
  T  p3 B) G1 H9 F3 o" y1 I    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>

<>
/ W# v, P) k" F; N- I) N! ~- d//-----------------------------------------------------------------------------
# t3 I4 l; ^, N( l( M- R+ ]! f// Name:
+ E$ ~* ]- g% v* o+ d: i7 m. i  H// Desc:
//-----------------------------------------------------------------------------
; ~3 [  M4 R: |& T$ z6 u0 f% Fvoid CMazeServer:ockCell( DWORD x, DWORD y )
0 K% |& R2 Q& U, S6 y{
    if( x == 0xffff )
        m_OffMapLock.Enter();
    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
2 \( h0 O! k# N  J" {0 `0 ?}</P>
6 u, w- L2 o$ U3 B7 ~( P
<>
//-----------------------------------------------------------------------------
# j8 ]' ~/ H* ]( I! i1 d0 a8 b7 ~// Name:
// Desc:
//-----------------------------------------------------------------------------
& }4 L, j' k& D3 J( C/ Bvoid CMazeServer::UnlockCell( DWORD x, DWORD y )
{
    if( x == 0xffff )
        m_OffMapLock.Leave();
    else
        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
" O" T8 O. p. n0 I9 S2 t* d8 U}</P>

/ e; ]& x& l4 Y7 p: `<>
: q. z  e# o& ?8 i//-----------------------------------------------------------------------------
/ b( D5 `: i2 ?// Name:
5 f; T/ K# }& l3 `// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
( \/ [% i7 R: ~. F; j, F    if( x1 == x2 &amp;&amp; y1 == y2 )
' S' ^( N6 n+ a# g# Y    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
        else
            m_OffMapLock.Enter();</P>
7 ?. [( o) E# C4 B# r<>        return;
, G5 N) X5 m+ B* Q5 E! x! d    }</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>
1 I  [( q7 d& b+ H<>    if( x1 == 0xffff )
    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x2shift,y2shift);
2 q2 T" {2 a" l# b0 W+ s    }
    else if( x2 == 0xffff )
    {
2 C9 A8 q( e' t. |* [/ q        m_OffMapLock.Enter();
( l1 w; T: h3 p8 V8 {        m_LockGrid.LockCell(x1shift,y1shift);
* m4 w5 }4 ~; ?    }
# A$ O% a; s8 X4 I$ Y- Q    else
    {
        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
3 o& w3 c' G. g/ f    }
}</P>
' @6 ~& }! ~0 f: S: e
<>
//-----------------------------------------------------------------------------
1 E' V! @' n  H( @// Name:
7 \* o7 ^0 y: W$ M8 j% b// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
' B/ O5 a- {; C9 {8 j! v{
( z5 u5 Y( m+ M    if( x1 == x2 &amp;&amp; y1 == y2 )
$ G; i7 G7 e. p! ]0 h$ P    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
3 h5 I1 p4 K% C4 j* X2 K# J3 R            UnlockCell( x1, y1 );
2 s( _1 Z+ ?5 n) i: X! l        else
            m_OffMapLock.Leave();</P>
9 O/ N0 b6 P0 J, {6 P5 ?+ ~<>        return;
* J3 b; ^8 m# V- W& `    }</P>
4 N: m: ?. v/ O, W<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
4 \$ O, g# `7 c- a: g    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
, _, v) e7 F' j" n5 H( E8 Q; p    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
( F/ I  x! C; Z% H: z<P>    if( x1 == 0xffff )
    {
) s. x, r0 M: i/ Z7 Y* x        m_LockGrid.UnlockCell(x2shift,y2shift);
* O% R8 L# {. n5 @+ T2 @, H. j# j        m_OffMapLock.Leave();
    }
    else if( x2 == 0xffff )
    {
; i0 q3 O6 Q3 a9 H$ R0 J        m_LockGrid.UnlockCell(x1shift,y1shift);
; s, a$ ?" ~. R1 p0 h+ ?2 z* v        m_OffMapLock.Leave();
0 y9 ]8 a2 _4 ?' b- D3 n    }
    else
/ F3 K% r+ k1 I- a, g# V- x% f    {
% E  m7 G9 [* l  |0 K3 o        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
' K* U5 g' l0 Q2 G$ |    }
. R' H4 {# o6 t# L}</P>
) x6 X: h) K9 q& _
( J4 ^( i$ p4 K2 S2 d6 o  n<P>
4 c3 H9 S7 @$ y//-----------------------------------------------------------------------------
: L0 f+ ]/ _% M( D0 ~// Name:
( v) r: k9 u3 w  g- h& N- |# v// Desc:
//-----------------------------------------------------------------------------
3 g  l. N7 D, X# A2 m/ Uvoid CMazeServer::OnAddConnection( DWORD id )
{
8 ]. G& j% |$ k  d    m_AddRemoveLock.Enter();</P>
! y$ C5 \7 Y0 _$ B1 }0 G<P>    // Increment our count of players
    m_dwPlayerCount++;
    if( m_dwLogLevel &gt; 0 )
    {
3 f5 U- m5 e- o( \; M        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
, T3 `. Y" p7 D1 c  n        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
1 r0 d4 k; H: F& _) Q5 a    }</P>
. p6 g/ k3 q7 F9 M7 }' B) w# H<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
! v; E) l+ {( \  f5 [<P>    // Create a player for this client
    PlayerData* pPlayerData = CreatePlayerData();
    if( pPlayerData == NULL )
    {
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
' L. W% S1 `, J1 b        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
        m_AddRemoveLock.Leave();
+ }* S# `( E" o8 N' j+ r        return;
    }</P>
<P>    // Store that pointer as local player data
0 M- y* C3 L; [  B; q% l    SetPlayerDataForID( id, pPlayerData );</P>
" u  j+ I' ~5 q' R! N" G; k  U<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
    ServerConfigPacket packet( m_ClientNetConfig );
' W( A- `: m6 F! a    m_ClientNetConfigLock.Leave();</P>
5 \/ x8 G! M* j0 G% ]5 X: b) w% y<P>    // Send it
5 Q* _$ t! \  k7 g* I+ I( ]    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
1 d# v. o& r1 d; a# ]5 _<P>    m_AddRemoveLock.Leave();
( L$ q# F* }7 a- P}</P>
+ h2 a4 k; t: f# _$ f& Z% ]* U
<P>
//-----------------------------------------------------------------------------
// Name:
2 Q8 ~9 K; I0 L4 E// Desc:
" `6 |1 @6 m* M7 o7 s//-----------------------------------------------------------------------------
void CMazeServer::OnRemoveConnection( DWORD id )
$ D- a6 U% x! S' {; i7 r{
    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
4 |& W7 _% k/ a/ \6 r' ^    m_dwPlayerCount--;</P>
$ T8 A) w1 @) i! }<P>    if( m_dwLogLevel &gt; 0 )
( |% T3 O- q$ f2 t( T# H    {
8 c/ o( c2 v; M5 u& ?9 o5 ]' ^        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
1 c5 o" n& g# ~& U    }</P>
- [- {0 E# G/ C8 A% i& O3 f$ d<P>    // Find playerdata for this client
    PlayerData* pPlayerData = GetPlayerDataForID( id );
; A( A' ]3 _0 p) X+ u    if( pPlayerData != NULL )
    {
        // Destroy it
, h  Z6 Y4 c/ _) q        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
8 M3 V+ J' `8 F' z# M' ^. U% o    }</P>
<P>    m_AddRemoveLock.Leave();
) T* u7 A4 d, V% {' k}</P>
- }9 `. H  n$ z; p& ~
<P>
//-----------------------------------------------------------------------------
$ o- f# s( y: U! x9 L! E) u// Name:
// Desc:
//-----------------------------------------------------------------------------
1 C; G0 U7 \. j( g8 K6 K# GHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
5 G; ]/ A; _: D, v. P% v{
. U& v7 [, D! ?! ~# e    BOOL fFoundSize = FALSE;</P>
. P" H) L  U1 v, S9 l, y<P>    // Increment the number of thread we have in this process.
    m_csThreadCountLock.Enter();</P>
<P>    //Get the start time of when we entered the message handler.
: c- p, `& E( B0 {  T    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
<P>    m_wActiveThreadCount++;
7 Y! C0 q  n; g- Q- O( E# Z1 K    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
   
: U7 j0 w3 K4 r+ B2 |# ^$ W    // Calculate and average.
5 A; ^' g8 W$ K5 d/ C8 W; S& {6 ~; \& q    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
    m_fAvgThreadCount += fdiff/32;
% x) }; S( r. a' A   
    m_csThreadCountLock.Leave();</P>
3 h% K: h/ z% l  _5 u- N3 F  |8 D<P>
    ClientPacket* pClientPack = (ClientPacket*)pData;
' f+ D$ [% h+ B' C8 H5 c    switch( pClientPack-&gt;wType )
( r, N5 W% l. v( W    {
" A- d) o! V: e4 b; [3 ~        case PACKETTYPE_CLIENT_POS:
            
            // Check to see if the packet has a valid size. Including
            // the custom pack size.
# T0 r# o: X8 h  n1 E            if( size &lt; sizeof(ClientPosPacket))
                fFoundSize = FALSE;
* [9 W0 x, b. S' c            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
* X+ y2 i8 q, z; r2 J                fFoundSize = FALSE;
1 s9 z2 A. Z+ O; d1 `- O# P            else
2 X; f; X1 L0 P" H! S) e                fFoundSize = TRUE;</P>
% S$ q) i, G& |' a- s5 c0 c<P>            // If valid sized packet, handle the position.
            if(fFoundSize)
% z' G9 x& V$ b9 w% ^  Q, I                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
) A) k: C; y7 M# e# R7 x            else
+ N1 T/ u4 e1 g8 X+ N8 x/ W; s                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
9 `4 X& R/ m! K( |# R<P>            break;</P>
<P>        case PACKETTYPE_CLIENT_VERSION:
/ n8 ]2 W' h# S            if( size == sizeof(ClientVersionPacket) )
4 [3 v* L7 f6 y% q1 Z2 p, J                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
            else
, H9 _, P, H  |" [                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
            break;</P>
<P>        case PACKETTYPE_SERVER_CONFIG:</P>
<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
<P>            break;
        default:
            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
# a+ }" V4 A) K    }</P>
<P>    //If the user wants to hold the thread, Sleep for given amount of time.
    if ( m_dwServerThreadWait &gt; 0 )
    {
        Sleep( m_dwServerThreadWait );
    }
   
+ g$ ]5 L  E; W. z    // Retrieve thread data for this process.
5 m2 o" b% j5 L: f8 i4 e    m_csThreadCountLock.Enter();</P>
# w1 k% H- M7 Q0 N) @. q<P>    m_wActiveThreadCount--;</P>
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
( s3 H4 F1 z* P" I    m_fAvgThreadTime += fDiffTime/32;</P>
<P>    //Get the Max time in the thread.
3 a, C  ^# q7 b5 u( Z+ ^6 ?& l    if ( fDiffTime &gt; m_fMaxThreadTime )
    {
8 H6 C2 d8 u) y9 C& b* U5 E        m_fMaxThreadTime = fDiffTime;
    }</P>
* F: G" k3 U( ^8 X! o) }+ K, @<P>    m_csThreadCountLock.Leave();</P>
* j) q0 S) x7 M0 Q/ m* O, Q% {' F<P>    return S_OK;
" ]- @9 Q: Q( ?# N  u}</P>

<P>//-----------------------------------------------------------------------------
// Name:
$ h( |' L) G/ g' Q1 `: z. Y// Desc:
//-----------------------------------------------------------------------------
BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
" l8 t( j; c9 f, G5 M" l{
8 B0 f5 e' g* _; q8 T3 r) R    BOOL fFoundSize = FALSE;
! ~" f# ~6 g- g    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
   
    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
  C) h1 Z  p' C' [4 Q        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
        {
" \+ }. U& r) U4 @7 H6 ]            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
            {
                // Found valid size in the array.
2 x% F. G( D& I' z9 c                fFoundSize = TRUE;
                break;
            }
            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
. Y3 L6 `% P  `( b2 ?1 b7 ~        }
( P6 p# ^: g- V" T( w    }
; [/ |; j  U5 t: j- Z    else
7 O1 F  s1 Q4 H3 y6 v, b    {
* P: i# R1 {' T2 Z' H( q        fFoundSize = TRUE;
+ s2 e1 \5 L  ]2 N    }</P>
<P>    return fFoundSize;
}</P>
<P>
9 D" L5 G& ?2 S7 G//-----------------------------------------------------------------------------
  ^. r8 k- u! B3 Y- W( _6 g: W// Name:
8 g8 I, o8 D6 j6 }6 Z// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
7 d! J1 M+ s  {' _: C# ^& P# {{
  p/ ?: V) V5 M& t    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
& S* L- v' Y8 s& G1 K}</P>

- E$ g; |  X) M1 p# V0 d3 q<P>
//-----------------------------------------------------------------------------
5 j/ w* [; s/ ^2 {/ |% i6 Z, L3 O// Name:
* t( V/ f1 ^7 {9 O; i! V# s" V- `// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::CreatePlayerData()
3 w( y1 B  R% @4 y9 y" v{
- @6 l4 Z5 L) ?: [2 Z8 o    m_PlayerDataListLock.Enter();</P>
<P>    // Grab first free player in the list
8 f" R) n- l; p6 I' K5 d3 p    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
<P>    if( pPlayerData )
    {
        LockPlayerData( pPlayerData );</P>
( ]8 H) ]1 r7 \0 M2 }<P>        // Got one, so remove it from the free list
        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
        if( pPlayerData-&gt;pNext )
+ h2 F/ V6 _6 i' E5 w            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
' c: Y/ R: L" I! y( u7 |. Y& ^" B        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
<P>        // Add it to the active list
# v2 T5 ]: b, Z8 X        if( m_pFirstActivePlayerData )
            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
! M* y2 v( ~  j  h6 @+ d        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
& p5 }3 @( d' q/ y<P>        // Update count of players
        m_dwActivePlayerDataCount++;</P>
' ~) a# z2 T8 o2 F1 P* T<P>        // Generate the ID for this player
: _* A1 |$ s$ r& s: N        m_dwPlayerDataUniqueValue++;
/ V  ?4 L% }, k1 Y        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
% }8 @& G# f& g) A7 i+ d<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
        pPlayerData-&gt;NetID = 0;
        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
% A" Y' H: `# I0 H<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;
        m_OffMapCell.pFirstPlayerData = pPlayerData;
        m_OffMapLock.Leave();</P>
: B  ^  V& E( ]8 k! c<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
<P>        UnlockPlayerData( pPlayerData );
( l7 i+ T1 x( x1 b) c+ t    }</P>
<P>    m_PlayerDataListLock.Leave();</P>
<P>    return pPlayerData;
, d% ?) J9 W" N: K) I}</P>
" k$ _7 t# \' h# @6 g4 b' j7 \, ]: B3 s
<P>
//-----------------------------------------------------------------------------
9 X) I5 N: m/ z, S0 T4 T// Name:
. A- j8 ~4 L) `2 @* \// Desc:
8 T* X  L- w3 a//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
$ r" r2 F; m! C# L6 r' A{
6 o# _: t8 `' ^. j7 C4 }    m_PlayerDataListLock.Enter();
    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
- q6 o# _+ w9 X; O2 X    RemovePlayerDataFromCell( pPlayerData );</P>
<P>    // Mark as inactive
    pPlayerData-&gt;bActive = FALSE;</P>
# `  g1 }; x2 |" k) g+ `+ u<P>    // Remove player from active list
' ~- |, A) w) C' N& P; w    if( pPlayerData-&gt;pPrevious )
        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
4 E6 s; [- m5 N3 i    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
5 Q5 M6 s1 X- g1 A  N, P<P>    if( m_pFirstActivePlayerData == pPlayerData )
        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
( Q2 F& s) g! z+ I( m# T    if( m_pFirstFreePlayerData )
        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
" J7 Z' E8 I7 S$ Y    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
( P5 @% K! v6 Z  Z' y6 M( j    pPlayerData-&gt;pPrevious = NULL;
    m_pFirstFreePlayerData = pPlayerData;</P>
& s/ z/ T) T+ I, `- j. }/ j; d<P>    // Update count of players
/ P1 ~& `, M/ t9 ^7 I$ F6 |! x; c    m_dwActivePlayerDataCount--;</P>
1 ^5 }# N& X5 b0 B3 W% h: c; j<P>    UnlockPlayerData( pPlayerData );
7 h, Y" F( @  M, Q# W; x' J    m_PlayerDataListLock.Leave();
}</P>
" c! J& \: l: p: S' L4 G- R
<P>
//-----------------------------------------------------------------------------
6 s3 k- _5 _0 W1 d* [- V// Name:
6 n0 @8 ^* V; S( D) Q9 x0 _) M// Desc:
9 \+ B: u, U9 v8 y' A//-----------------------------------------------------------------------------
! K! p. B0 y( vvoid CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
    // Lock the player
1 Q, B; f" n, U  l$ l    LockPlayerData( pPlayerData );</P>
<P>    // Lock the cell the player is in
    ServerCell* pCell;
# _+ |- |* r. H) d5 U! ~    if( pPlayerData-&gt;wCellX == 0xffff )
    {
        m_OffMapLock.Enter();
7 t# n9 A( [2 ^: @5 S        pCell = &amp;m_OffMapCell;
8 |0 |/ d! ]! H2 }0 Y& n    }
    else
* e4 M3 N9 [/ \$ ~    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
9 [' n$ X4 w2 m( ~4 R        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
    }</P>
- q8 P, R& c5 U<P>    // Remove it from the cell
+ N8 J3 m3 y" C, ~3 Y! _    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
/ }) o! r3 y3 x' g% X+ ^    PlayerData* pPrev = NULL;
1 H2 ]8 Q: g5 P1 L; \. L" M1 Q0 W    while ( pPt )
    {
. J. v, g; l' o: y        if( pPt == pPlayerData )
        {
: H  T3 T+ V! ]' E; _4 a! f            if( pPrev )
/ F! v+ d, o4 b4 H2 ?+ i5 S2 c+ r                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
            else
0 w; Z  c; w! S6 ^0 m" g8 a                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
2 x( i3 e4 ]  P2 T3 x        }
        pPrev = pPt;
2 p  u, {5 g6 @% |- }6 K1 T  h9 ~        pPt = pPt-&gt;pNextInCell;
    }</P>
0 L7 \9 d' q! i* s: x<P>    // Unlock the cell
' B, H" X( K, x    if( pPlayerData-&gt;wCellX == 0xffff )
        m_OffMapLock.Leave();
. `: \0 K* Z  d' a. x- O    else
8 ]+ m8 H" J) Z: k# A- F8 F% _7 G        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
1 B) |  q; U5 w<P>    // Unlock the player
    UnlockPlayerData( pPlayerData );
}</P>
6 A9 E' c. b6 @2 n  P- k6 K2 g0 J! D
5 a. s$ C8 d8 s! b& P<P>
//-----------------------------------------------------------------------------
2 y6 c4 T5 ^" X5 _% c# Z3 z// Name:
// Desc:
8 x' a! {5 v1 V% Z$ o//-----------------------------------------------------------------------------
void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
{
    ServerCell* pCell = GetCell( pPlayerData );
    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
    while ( pPt )
    {
& c, T5 }' B/ w- i$ t6 @3 [9 y0 ~        if( pPt == pPlayerData )
        {
6 Q1 K2 L9 {; b/ g1 ~& ?            if( pPrev )
# R, ]! p$ b7 k+ V& I                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
4 n& l3 Y8 ?  u1 f            else
; G+ X% s- X# J( ?, R+ Z2 n                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
        pPrev = pPt;
        pPt = pPt-&gt;pNextInCell;
    }
}</P>

<P>
//-----------------------------------------------------------------------------
// Name:
" w. C9 p9 v% b+ W! ^// Desc:
" O0 A* O9 R4 d1 `//-----------------------------------------------------------------------------
void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
8 U5 l. g! E% ~5 O4 |{
    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
9 e& Z% a. D+ u4 u    pCell-&gt;pFirstPlayerData = pPlayerData;
7 L- x( P! G- O- o' j4 j" ?# E( t}</P>
- E3 `+ [8 U# i9 M
' A9 v4 E0 u  X$ C. \<P>
$ i% f0 ~2 j' _+ w# H+ L//-----------------------------------------------------------------------------
9 P. \/ u2 a1 C2 b7 w0 x) w7 r// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
    // Grab player for this client and lock it
, z/ e5 F5 r% K7 X% J    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
    {
$ W6 ^% W# K/ {- `# j7 w& p$ F) f        if( m_dwLogLevel &gt; 1 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
4 O% A" \# N6 ^        return;
    }</P>
<P>    LockPlayerData( pFromPlayer );</P>
<P>    if( FALSE == pFromPlayer-&gt;bAllow )
    {
        if( m_dwLogLevel &gt; 0 )
) |, F* P+ d9 j# W* K3 P6 }            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pFromPlayer );
        return;
    }</P>
* j) r) P1 s0 b4 A5 \! K<P>    // Compute the cell the player should be in now
8 @8 Y5 [- ^  p! W3 x- `! d& a    DWORD newcellx = int(pClientPosPack-&gt;fX);
5 A* _! p4 z, ^    DWORD newcelly = int(pClientPosPack-&gt;fY);
' V1 [4 I& [' M* b    DWORD oldcellx = pFromPlayer-&gt;wCellX;
. R5 E7 J& Z" @7 a8 p: S    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
<P>    // Have we moved cell?
: P% R2 g3 o- r( w0 p- G    if( newcellx != oldcellx || newcelly != oldcelly )
    {
        // Yes, so lock the pair of cells in question
; s$ u1 I& e6 L& s6 @+ T        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
0 w: @; U3 t3 S% s. D7 G( ~<P>        // Remove from old cell and add to new cell
4 }1 a7 o* ]1 j- i; M! R4 p        UnsafeRemovePlayerDataFromCell( pFromPlayer );
        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
7 L! r- I' y" A- v% h$ m6 n. P/ {        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
0 B! o+ B9 E# C8 ?<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
<P>    // Update player position
6 n% t) ?/ q# Z! h; S    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
8 ]; b! [  S6 }    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
9 L' U, b0 Y' O  K9 E<P>    // Allocate space to build the reply packet, and fill in header
2 C" }" Q: S* d; v: t8 I    DWORD dwAllocSize;
7 D, [6 \! J9 L0 H, S6 V, M) T4 h    ServerAckPacket* pSvrAckPack = NULL;</P>
7 D# h8 E6 r* [- W0 l<P>    // Begin by allocating a buffer sized according to
  ?3 S( w! B1 N% }$ D    // the current number of nearby players + 4.  This will give
    // a little room for more players to come 'near' without resize
$ K8 N% R" S$ ^+ k    // the buffer.
; a) K0 }: |% A* Q    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
" }& [  l- w& C1 z# `: T    {
        // Out of mem.  Cleanup and return
        UnlockPlayerData( pFromPlayer );
        return;      
    }
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
4 Q% S" e; }9 v% i<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
, ^4 ?* n' g- _# W% V    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
1 I* B  y, o0 ^% z7 q! v4 {    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
<P>    // Compute range of cells we're going to scan for players to send
    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
- h5 G3 Q$ X+ r% Q    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
<P>    // Lock that range of cells
( l8 p; Z9 T) P# y: k& H  e    LockRange( minx, miny, maxx, maxy );</P>
; B- h6 m* s8 s  D<P>    // Scan through the cells, tagging player data onto the end of
5 |( F, S* @7 E    // our pSvrAckPacket until we run out of room
    for( DWORD y = miny; y &lt;= maxy; y++ )
4 q8 z2 p) ]! R    {
6 C0 u" e& g8 E9 l7 a7 F        for( DWORD x = minx; x &lt;= maxx; x++ )
        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
0 O# x+ g. n/ C% w' K            while ( pCurPlayerData )
            {
                if( pCurPlayerData != pFromPlayer )
% @. Y# }* B: x. X1 N. p/ O                {
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
$ D1 r# [- [2 T7 m                    {
; G7 V7 G7 X6 H                        // Make sure pChunk is where we think it is
7 x) j$ E3 Q/ N) ^0 O                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
<P>                        // There are more than just 4 new nearby players, so resize the
                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
                        dwMaxPlayerStatePackets += 16;
                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
' r6 u! N, v" d  n7 \7 _6 Y  X9 w                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
                        if( NULL == pNewSvrAckPack )
                        {
: c  `$ x7 ^9 u; E8 V                            // Out of mem.  Cleanup and return
                            free( pSvrAckPack );
                            UnlockRange( minx, miny, maxx, maxy );
1 T; A& j% i0 @8 _0 }                            UnlockPlayerData( pFromPlayer );
* ?3 L, O+ G+ Z' Z% E* |, {                            return;      
; e2 L9 l) \0 w& e+ T                        }</P>
<P>                        pSvrAckPack = pNewSvrAckPack;
7 A; w" P' d4 h4 n' _                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
1 E' \8 Z6 ?7 K<P>                        // Make sure pChunk is still where its supposed to be
                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
                    }</P>
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
2 N* _2 ^* }) b# w                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
6 C0 J  T4 a& u9 [' Y2 B7 s2 l                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
                    pChunk++;
                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
6 x" K! |+ c, X% g: p& o* ?! @                }
) j* l! _* d6 C: z& F* w8 \4 x* }                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
        }
3 F1 p4 x- M+ Y    }</P>
<P>    // Update the dwNumNearbyPlayers for this player
8 }. F4 Y3 U( S' L5 P    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
, s8 O+ _3 y" X" l, W1 ^" u3 }<P>    // Unlock range of cells
    UnlockRange( minx, miny, maxx, maxy );</P>
( a' P+ o, m/ J( R  t$ B0 g1 w<P>    if( m_dwLogLevel &gt; 2 )
; N3 r- ~1 g) r. _) L4 ^7 s    {
4 G8 T0 |. ~0 j9 Y" @        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
    }
    else if( m_dwLogLevel == 2 )
0 k4 _% ]. I- b( {& ~, [- J    {
        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
' X# b7 F2 n& h8 ~3 j! b        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
: t4 p4 v% }2 i5 N        {
            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;
% x" s5 {! M! V3 L4 I        }
    }</P>
8 R+ K$ u8 n! S9 R, O' E<P>    // Unlock the playerdata
  ?0 y, L9 m1 o  U5 D8 g    UnlockPlayerData( pFromPlayer );</P>
<P>    // Send acknowledgement back to client, including list of nearby players
    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

2 u$ n! Y- M; y6 c0 t) W    // Pack the buffer with dummy data.
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
    {
        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
+ `  L5 f; B# Z4 o" H. j: G        VOID*   pTempBuffer = 0;</P>
<P>        pTempBuffer = malloc(dwBufferSize);
        if( NULL == pTempBuffer )
        {
" c/ u. Y3 z# d! t            //Out of memory
  S( g/ A' c; z* Z6 k. l            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
            free( pSvrAckPack );
/ |/ z0 L  U; x) R9 W! n: F: P            return;
$ F$ n! g4 F8 n5 {7 r9 J        }</P>
, M3 p& X- `7 P6 ?<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
' e7 l% q; d7 C& z: E) C  J  e* s        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
   
        free(pTempBuffer);
% _- Y0 o& {7 A5 u    }   
# K, T- v: \8 }1 t5 U  c  W) D    else
/ r5 x& r- m. g2 C    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
    }</P>
<P>    free( pSvrAckPack );</P>
. @+ {2 F' N$ e1 \- y<P>}</P>

<P>
* A3 C1 {5 K' c0 C//-----------------------------------------------------------------------------
+ f4 \: X; f: `, p+ ?+ |// Name:
6 |; p0 Z3 x% C// Desc:
. d6 p! d) S% m' j//-----------------------------------------------------------------------------
void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
3 z$ m) E8 y& \' u) z' ]{
* N" X8 @, \7 a2 E5 ]: P    // Grab playerdata for this client and lock it
    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
# t, R6 ~" W2 V6 ?. M+ b    if( pPlayerData == NULL )
        return;
    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
$ x" l8 ?% i8 s- ?) o<P>    if( m_bLocalLoopback )
        pPlayerData-&gt;bAllow = TRUE;
    else
        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
) D3 J9 l! @1 C<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 )
    {
4 O8 S  C7 [- c8 L1 ?! m        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 );
+ [, U2 v( e% v  w3 W        return;
" U1 `+ h7 q1 B# x2 j9 T    }</P>
" I& n3 [& m4 o# ^9 P; x" C: o* H<P>    // Unlock the playerdata
    UnlockPlayerData( pPlayerData );</P>
* N! d+ o$ q0 j- _3 M<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>
5 w: E! e, D) T' H+ `( `
<P>
//-----------------------------------------------------------------------------
6 d0 C6 g$ m% Z. E: H2 x% H// Name:
1 O: B; b3 ^8 p- R0 s! E- z// Desc:
//-----------------------------------------------------------------------------
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
$ L$ b# Q" G! n{
    switch( dwClientVersion )
2 o. O+ B# N8 Y* }% n9 m    {
        case 107: // only v107 is supported
" z9 a8 j( E; E( W4 N1 D' K            return TRUE;
6 R: l( o: ]3 W+ a8 D. X9 ~+ j        default:
' s% s: v8 `# M2 O4 Y            return FALSE;
    }
}</P>

6 J) D" T( U4 D- @& b' a. i1 w<P>
//-----------------------------------------------------------------------------
// Name:
+ W* V' N3 w. w! _7 @! E- Y// Desc:
! Q# S% F& f/ ?' {$ D, ^- K//-----------------------------------------------------------------------------
void CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
! g  N5 ^6 @% X" g{
5 k! Y: \  C6 J8 T. _- {    if( m_dwLogLevel &gt; 1 )
+ D7 Z. ?/ Z$ X9 i, X# V; h        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
}</P>

<P>
, r1 R. X9 T9 F- S6 X//-----------------------------------------------------------------------------
: m7 z2 t0 D8 x% q" S// Name:
// Desc:
//-----------------------------------------------------------------------------
1 N6 g4 q6 U- T( r( Q8 q, KDWORD   CMazeServer::IDHash( DWORD id )
# }- g! G# B' S{
, V6 Y' }( I" {    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
" g: o5 Z9 [0 ~! J) A9 N& f+ P    return hash;
}</P>
% D# n/ V& g  Z* d
<P>
//-----------------------------------------------------------------------------
// Name:
/ V1 l& q: ^* a! ]/ q. `// Desc:
' |5 m4 ], g9 G' n- n- Z$ o//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
3 A. ?& E6 Z! ~2 F{
3 M) e7 x1 N3 i    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
1 @7 S; Z6 @/ X+ ^8 t<P>    // Lock that hash bucket
2 J( A% C- l. m' }; H    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
# ^$ x+ r( d! T6 C0 F    PlayerData* pPt = m_pstIDHashBucket[bucket];
    PlayerData* pPrev = NULL;
    while( pPt )
    {
        if( pPt == pPlayerData )
4 @3 _% V" }: @2 g( x/ |& |( g            break;
$ U3 G% |6 b! `8 q" v- o        pPrev = pPt;
9 K0 m0 m+ o! \5 R5 K: }        pPt = pPt-&gt;pNextInIDHashBucket;
. V% g( D! t) z    }</P>
<P>    if( pPt )
5 Y& ]' |9 w6 J! R* v' ]7 X! `    {
4 a* J8 s: v  I        if( pPrev )
            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
$ ^9 r# N& l2 C7 \$ X- `        else
            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
, y, l4 j7 x, e. Y1 {: Z6 q1 V<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>
& m4 Q5 g  I% n: m( C. i
<P>
5 Z4 @, W4 @( _" ~//-----------------------------------------------------------------------------
// Name:
// Desc:
' d0 s! H$ D  ]9 \//-----------------------------------------------------------------------------
# z1 U6 Q, N! @- Vvoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
, p- r# A6 Q1 F: ~8 S. m{
    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
5 B& t6 Q* ?% L' F# T5 r  k    // otherwise there will be a circular reference
    PlayerData* pSearch = GetPlayerDataForID( id );
; d; g# r" y; [% G1 h    if( pSearch != NULL )
1 `3 J2 T+ _2 ^! T3 k2 |+ P        return;</P>
, Y7 O1 i) Q: `0 L4 ]( m( {& v<P>    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
. j9 `( c3 ^0 ?/ d8 [& n    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
( t8 Y& i* A7 o, K<P>    // Add player onto hash bucket chain
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
    m_pstIDHashBucket[bucket] = pPlayerData;</P>
, c2 h( |1 s- M9 c- L7 O<P>    // Store net id in player
4 w" E* o4 W1 N4 B6 B3 u3 _/ g6 Z    pPlayerData-&gt;NetID = id;</P>
; ~; C! V3 J- l/ S5 z" L, u) t3 ?9 r  {<P>    // Unlock the hash bucket
- _% W5 D1 N! p* i5 ^7 ^    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>

+ \+ t$ p+ b5 i) {8 }$ P<P>
//-----------------------------------------------------------------------------
// Name:
2 W& }6 x# c* `! d$ \0 m( l6 t// Desc:
- S2 W5 T( ]4 P* d: l; O. L//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
' h2 j: S6 b2 R) D/ l# _1 A{
& n, l+ Y. \3 w. d/ P) \2 S: M" \    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
2 x' S/ |" E6 \; ?/ x3 m( ]    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
8 e: C' S) h( H# j2 }' P* {" s    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
5 m3 ~7 D  {; j4 ~5 a<P>    // Loop though players in bucket until we find the right one
# q% g) i  F8 a/ F! d    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
    while ( pPlayerData )
+ G9 X. b' c' D/ \    {
. X3 t- m1 S% ~6 N! `( x* `  w        if( pPlayerData-&gt;NetID == id )
6 d8 E  D2 N0 ^+ @; `( o* a            break;
        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
0 y9 I3 B. ~4 O: U, m3 K    }</P>
<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
, l& G7 o+ ]5 P# n! _+ O  T/ c1 n) u<P>    // Return the player we found (will be NULL if we couldn't find it)
$ d) f' P, g- W; T/ I3 \4 `    return pPlayerData;
8 t9 p: E# q0 e3 d  k  P: b}</P>
; c+ A3 F5 @5 Q; u% C  t  Z' `3 q. Y. s
<P>
0 r4 z  q5 ]" n0 E! M//-----------------------------------------------------------------------------
8 [8 k3 L8 p8 K  J4 A: |% r// Name:
// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
, n* H2 |; X/ O8 Z9 f1 Z7 i$ ~  @//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
{
    if( m_pNet )
, W6 _2 m2 C7 j' x' N! F    {
        // Find the player that was displayed the longest time ago, and display it.
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
4 U3 b/ h$ X. Z2 Y, ]        PlayerData* pOldestPlayerData = NULL;
        FLOAT fOldestTime = 0.0f;</P>
) D& i7 P4 C0 Y4 N$ J! j+ A<P>        m_PlayerDataListLock.Enter();</P>
' e7 t: H: \1 h2 X: c3 @<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
        while ( pPlayerData )
        {
            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
4 p" y% B2 s2 R            {
1 Q" M( S1 W; D                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
                pOldestPlayerData = pPlayerData;
            }</P>
<P>            pPlayerData = pPlayerData-&gt;pNext;
' t: J  F4 J' u- E4 \, H        }</P>
<P>        // Display the player with the oldest CI field, and update its CI field.
        if( pOldestPlayerData )
        {
            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
7 n5 ]2 u* E3 {2 T6 D0 E3 Y            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
  T3 x6 p1 i+ V, b            pOldestPlayerData-&gt;fLastCITime = fCurTime;
        }
: ]& A  j( L5 b$ R; j8 l        else
2 `' v- q4 ]7 A: Z        {
            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
        }</P>
% _+ X3 g; j' _! ^<P>        m_PlayerDataListLock.Leave();
% j. f. f* E! C) d& v1 L5 i5 l( w& C0 I    }
}</P>
2 z  y4 B5 w0 ]" j6 n
8 ^$ I0 n7 Z5 m$ ?& B! s<P>
* d, N9 L: f% j  }- l/ v//-----------------------------------------------------------------------------
// Name:
/ l+ Z' \1 l& t& [) G" n// Desc:
8 d- I/ m& d$ ?. Y; e( `& r//-----------------------------------------------------------------------------
: p8 R0 y/ J# g4 c- j) Z7 l- [% gvoid CMazeServer:rintStats()
/ `1 o" W: R& w0 ^{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
7 h0 y0 a8 m- `! B    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
8 N& c( O' t2 j& \/ X                                    m_fAvgThreadTime, m_fMaxThreadTime );
& J8 r+ n% U& P) t) [    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
}</P>
! o: N  L1 p! ~8 a0 T1 p' M
<P>
) y% m$ P' @; D+ X6 e9 k2 q//-----------------------------------------------------------------------------
// Name:
% I  B/ t. A4 X& T// Desc:
  `9 `( r5 k. d//-----------------------------------------------------------------------------
, f, ~5 J' K# n$ e- hvoid CMazeServer:isplayConnectionInfo( DWORD dwID )
+ E0 l7 k  t9 ^4 l. D/ Z0 S{
: ?; s! _% ^  p, f9 L7 P4 ]6 g/ m    TCHAR strInfo[5000];
+ K. }" T% o2 G$ U; Y    TCHAR* strEndOfLine;
    TCHAR* strStartOfLine;</P>
5 {1 p& v0 v! ?' y) j! u3 q5 C/ C<P>    // Query the IOutboudNet for info about the connection to this user
    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
, X, F& j* W1 ?<P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );
6 V( L* Z9 v4 H9 Q0 z# i    ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>
! S# ~$ l2 Z* g6 \<P>    // Display each line seperately
' P( c) z# u7 n2 ~    strStartOfLine = strInfo;
4 x5 e# T! N, E) r    while( TRUE )
    {
. V  N- [6 l3 G  d        strEndOfLine = _tcschr( strStartOfLine, '\n' );
/ b% l- ]4 R( J0 w2 V  d        if( strEndOfLine == NULL )
" J7 Y9 F' Y9 x( }) n" }, H            break;</P>
( u8 Y* D( T& n- p8 i2 S<P>        *strEndOfLine = 0;
        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
  S) O/ G# `) H7 k7 z# [5 R    }
}</P>
' x3 l, y7 G' E! i4 j( l
<P>
//-----------------------------------------------------------------------------
// Name:
" W: `4 Y5 k. n' J+ ^4 f/ w) B// Desc:
1 m: @) L8 R1 N: ?//-----------------------------------------------------------------------------
HRESULT CMazeServer::SendPacket( DWORD to, void* pData,
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
{
    // Chance of forcing any packet to be delivered reliably
    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
        reliable = TRUE;</P>
<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
}</P>
6 _/ w* ^: z: w3 i2 |; `
4 O3 b! n; W2 {6 i7 T- a! I, e<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
; m0 O, p+ X. c3 {( ?$ Z. i  [//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
& N! ?3 d6 A2 |' \8 }* u3 i/ A    // If we're up and running, then send this new information to all clients
- m8 z& e1 s. X  b8 R! N    if( m_pNet )
    {
6 q& V! S1 B' k4 X  n. z        //Use the AllPlayers ID
# i1 J* R2 ^* {2 c+ }        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
* o# x4 g, i; W1 o. p4 K+ i+ K* T    }
}</P>

<P>
& v$ Y' r6 ]* ?) L5 G! c3 S. Z//-----------------------------------------------------------------------------
; `3 ^* D* q9 V/ D8 E0 ]: \$ [// Name:
// Desc:
3 I6 Y& k' l3 t& j5 x: x" c//-----------------------------------------------------------------------------
void CMazeServer::SetClientReliableRate( DWORD percent )
  J9 D9 V6 ]3 m5 e& g{
    // Update client config, and build packet containing that data
1 |! t' r3 X$ o2 ~8 ^    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.ubReliableRate = BYTE(percent);
2 @) k- B$ J0 J6 k    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
7 p# q, {8 k! v2 `# F% T) j' r}</P>

: h; s5 h( ^2 i) a- u9 n<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientUpdateRate( DWORD rate )
- |* c8 r0 r8 b3 L& g{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wUpdateRate = WORD(rate);
: I4 ~2 ~2 S1 e- q, q) j    ServerConfigPacket  packet( m_ClientNetConfig );
. j5 {( m# P* Y8 u4 W3 e    m_ClientNetConfigLock.Leave();</P>
1 w# N! U  j* ~1 W; ~7 ]<P>    SendConfigPacketToAll( &amp;packet );
}</P>

9 G% ^) {5 |8 R! G" {+ O/ Q: l/ B# _<P>
//-----------------------------------------------------------------------------
8 s4 q9 k0 i  ~5 T( s6 a// Name:
// Desc:
, \) Z  d) M1 b* z3 A8 [1 q5 J//-----------------------------------------------------------------------------
void CMazeServer::SetClientTimeout( DWORD timeout )
# J! `# E& i2 U2 k$ x: e2 K{
5 n* q, v3 D; L9 _. Q    // Update client config, and build packet containing that data
+ {+ d/ P& q2 }    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
; o) W9 O# X# R  m+ l# O    m_ClientNetConfigLock.Leave();</P>
' T- b! K: B3 w% g5 o<P>    SendConfigPacketToAll( &amp;packet );
}</P>

$ g: {+ K' {# y3 m( n<P>
//-----------------------------------------------------------------------------
0 P6 |' Q6 {: y1 e# B7 B4 |& V. X// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientPackSize( DWORD size )
{
* P. n/ I; [6 [6 H$ r    // Update client config, and build packet containing that data
2 C5 S2 l1 j! p0 i/ H" U    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
" X& d9 s. ]7 q: j! M        m_ClientNetConfig.ubClientPackIndex = 0;</P>
5 |* @$ T4 F6 l# ~8 b<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
( j/ `. B. }$ O* F& i% ~  c% u$ T  x    ServerConfigPacket packet( m_ClientNetConfig );
: V( \2 M  v( ~    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>
  j, ^. f/ {4 w; j' a3 O& L
2 U2 T5 N. A2 k! Y) [<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
; C4 S; N  U4 P, m& Z//-----------------------------------------------------------------------------
void CMazeServer::SetServerPackSize( DWORD size )
{
4 C) {9 ^. W4 L  ]& A& p( k- O    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
( }2 B& m  q, q0 t8 y1 W( e9 V   
. R( V7 R2 B* ]$ U    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
, L: L* O$ M1 s% X$ s    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
/ v  @- H7 `0 Y. h" u1 Q" B        m_ClientNetConfig.ubServerPackIndex = 0;</P>
<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
/ ]7 g- P# e  T5 e9 R& m, F6 \    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
6 d, q' z+ T6 G7 x5 E3 f# g}</P>
, B: Q) a' p, F+ O<P>
, t- N. f; ]  S! w//-----------------------------------------------------------------------------
// Name:
! G, Z; f$ X: N' E// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
) V7 A% N3 ~- n2 N6 W{
; H" L% e( _1 t    // Update client config, and build packet containing that data
4 Y3 Z3 y# w  y, P0 k    m_ClientNetConfigLock.Enter();
   
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P></DIV>