[分享]MazeServer源码示例

ilikenba

<DIV class=HtmlCode>
<>// File: mazeserver.cpp
+ }$ ]' r7 J& l//
( \% p% k% ]# w4 x, {/ R// Desc: see main.cpp
//
5 w  F2 f/ n% T6 w0 L, O6 W// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.
//-----------------------------------------------------------------------------
#define STRICT
#define D3D_OVERLOADS
6 f. w: V' z/ g#include &lt;windows.h&gt;
#include &lt;d3dx.h&gt;
) t; c" c  q: J5 K# O* P& i: J5 I#include &lt;stdio.h&gt;
1 E: M" T2 n+ `. D#include &lt;math.h&gt;
#include &lt;mmsystem.h&gt;
5 ]/ {) r2 s5 U) f" C#include &lt;dplay8.h&gt;
' f  t# C, E# N  i4 T#include &lt;dpaddr.h&gt;
#include &lt;dxerr8.h&gt;
#include "DXUtil.h"
#include "MazeServer.h"
#include "ackets.h"
+ T3 g2 t5 o. t$ ?. s#include "Maze.h"
! s) ]  t; p4 v9 b8 Z#include &lt;malloc.h&gt;
#include &lt;tchar.h&gt;</P>
% }/ k" O  k9 {: t( i+ K
<>//-----------------------------------------------------------------------------
// Name:
* |/ f3 G- `: L( O* {// Desc:
# C2 E# h3 u4 V. h" e9 Y//-----------------------------------------------------------------------------
5 J4 v0 l! J6 U" d5 l: ACMazeServer::CMazeServer()
! b) ?/ X  E4 }) K{
; Z4 u0 n" G  e" p; B    m_dwPlayerCount         = 0;
   
$ J1 B+ m7 Q: x5 w    m_wActiveThreadCount   = 0;
    m_wMaxThreadCount      = 0;
! R9 M9 ^% J* Z5 Z4 E" E  z' M; t    m_fAvgThreadCount      = 0;
    m_fAvgThreadTime       = 0;
& I' ]6 u9 W% c; O; m    m_fMaxThreadTime       = 0;</P>
. a  ]1 g  N4 R( \. m6 L& l<>    m_dwServerReliableRate  = 15;
# ^0 q% Y9 X8 q: Z( ?$ b! `    m_dwServerTimeout       = 150;
    m_dwLogLevel            = 2;
  t7 T2 S- y) y5 X    m_pMaze                 = NULL;</P>
<>    m_ClientNetConfig.ubReliableRate = 15;
    m_ClientNetConfig.wUpdateRate    = 150;
8 }1 T) T& ?/ L+ G) d' u  l    m_ClientNetConfig.wTimeout       = 150;</P>
: K# I8 a  a: R; s. ~$ L- M( S4 O<>    m_ClientNetConfig.dwThreadWait = 0;</P>
# @# d7 f) r. c0 a. y<>    m_ClientNetConfig.ubClientPackIndex = 0;
    m_ClientNetConfig.ubServerPackIndex = 0;
    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    {
        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
    }
}</P>
" a3 P* P8 ~' B, J" p+ u1 x
<>
//-----------------------------------------------------------------------------
% E: ]9 W8 p2 l: M// Name:
  _! A4 i2 L; s7 D$ l. \3 m// Desc:
//-----------------------------------------------------------------------------
3 S. i( m# j0 }& nHRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )
{
    m_bLocalLoopback = bLocalLoopback;
6 B8 }1 \  T8 d+ T2 Y    m_pMaze = pMaze;
    if( m_pMaze == NULL )
, h9 l6 D+ d$ t5 ]! U! D! n        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
; J5 _6 n% T& {5 g% N& ~! K<>    // Grab height and width of maze
    m_dwWidth = m_pMaze-&gt;GetWidth();
    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;
: G+ X) I3 Y  n3 Q, W4 g    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>
+ z% }; h+ k2 j! L0 v<>    // 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 )
        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
# U) ]% `$ G6 T    if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
* H5 S. G" [) A# d6 E! M" r        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>
) y8 R9 n6 E; b" @, |- @<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;
0 q6 q- @8 {3 Z' L4 v* J& u    m_dwMazeXShift = 0;
$ A5 @7 i6 b) l    while ( (scale &gt;&gt;= 1) )
% u+ h7 b! i! \. J) ~        m_dwMazeXShift++;</P>
4 h2 E& Q! o, Z<>    scale = m_dwHeight / LOCK_GRID_SIZE;
* }7 Z& E2 P% Q% _& V1 }' O: L2 |# H    m_dwMazeYShift = 0;
    while ( (scale &gt;&gt;= 1) )
        m_dwMazeYShift++;</P>
& @2 P5 `4 p' g" X4 \<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
        ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeYShift) != m_dwHeight) )
        return DXTRACE_ERR( TEXT("Maze height and width need to be power of 2"), E_INVALIDARG );</P>
# [7 J& u  C: x! |<>    // Initialise the player list
    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
    m_pFirstActivePlayerData = NULL;
- M+ g2 n9 O1 M2 F  \    m_pFirstFreePlayerData = m_PlayerDatas;
9 g1 W' Q3 C  a0 q; C" \% Y/ `) [    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    {
3 r! `- r6 J5 Q4 u        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
; O% j" C1 v$ E6 U9 l        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];
    }</P>
<>    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>
0 y5 V, l. q; X7 w* t5 Y6 X<>    // Initialise the cells
3 I; o. c, @6 o. Z. _/ t5 R    ZeroMemory( m_Cells, sizeof(m_Cells) );
    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
<>    return S_OK;
. y9 O, z! G1 @9 y8 i* {}</P>
% I: x2 K7 N2 `1 l7 L
<>
//-----------------------------------------------------------------------------
" ~8 q( r4 t; c% k3 r// Name:
, F/ C5 z1 e' X. I$ [5 z1 ]// Desc:
- ~; [9 S1 q2 n' B! z3 D//-----------------------------------------------------------------------------
8 N; g+ d5 ?# x( I- `) d/ Kvoid CMazeServer::Shutdown()
# F! t  p4 j  j/ U2 @& e8 W% u{
- Q  j2 g. D. b2 b- {# C! b  y. w}</P>

/ }8 _" H! c$ |1 F, Y5 C<>
//-----------------------------------------------------------------------------
3 l3 T, }2 B/ ^! J/ E) j6 \- A- P" q0 _// Name:
/ r5 R8 N3 S  k8 D0 {// Desc:
9 }; H, X; W' f; w, s: Q/ g% o//-----------------------------------------------------------------------------
, S# a, v; `9 ?0 Gvoid CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
{
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
& M  a, h0 a3 J- A3 a                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
}</P>
! ~' ~8 l3 R$ n9 i& P% i3 A
2 T" ~" [$ f+ h7 M<>
/ `1 W* l# K5 p( ~//-----------------------------------------------------------------------------
+ h( ~6 ?8 i+ r$ P- d5 X// Name:
// Desc:
8 E' c& T! m) T( b//-----------------------------------------------------------------------------
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
; H2 n3 ^5 r9 u9 E! Y1 t{
: g3 E! q1 V- S8 `& F9 Y# y" ~    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
0 N; R6 o+ B- f$ o; W, e/ f}</P>
$ D/ i/ A4 s# p" [( Q
, m* |2 `5 }& F0 e+ A0 K8 c; {/ W<>
+ ^6 `. ?$ ~& R4 r( g# ]; M//-----------------------------------------------------------------------------
// Name:
// Desc:
4 P( U& E5 x. F- O7 F% Z3 x//-----------------------------------------------------------------------------
void CMazeServer:ockCell( DWORD x, DWORD y )
3 J) p) g9 E# M6 _& N( r: z# ~. _{
/ l6 f' X3 V6 b4 g6 [- Z+ h: h& s    if( x == 0xffff )
        m_OffMapLock.Enter();
    else
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>

! x6 Z" Q; S" `<>
1 e% Q0 [1 x( r9 l. \; y: D//-----------------------------------------------------------------------------
4 @+ X& w$ ]( s* {/ I8 j// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnlockCell( DWORD x, DWORD y )
7 Q! e; n* f, Q% A; s{
    if( x == 0xffff )
        m_OffMapLock.Leave();
    else
        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
}</P>
4 V; ~$ a6 [0 j1 x) ^! M3 J# y
<>
//-----------------------------------------------------------------------------
6 @. |5 P7 l' [// Name:
) t6 D. a0 F8 F// Desc:
//-----------------------------------------------------------------------------
6 R( o" Y! j. Tvoid CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
' J% b4 r* W' F$ P{
    if( x1 == x2 &amp;&amp; y1 == y2 )
8 _3 D7 K9 k3 _9 {) |" u& ?; a    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            LockCell( x1, y1 );
5 `  r( F2 c$ w! ?# P/ }        else
            m_OffMapLock.Enter();</P>
' F( e3 ^" g9 C  C2 u+ e<>        return;
    }</P>
- r9 H' x, X# }9 b* W, |: g7 }1 }<>    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>
<>    if( x1 == 0xffff )
/ j# r/ p/ w3 l. X6 O) g    {
        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x2shift,y2shift);
    }
9 A& c- j5 H7 Z. ~    else if( x2 == 0xffff )
1 U8 Z2 Q. s2 l    {
' \- B* n6 T( p  l3 }* V  q7 o3 n        m_OffMapLock.Enter();
        m_LockGrid.LockCell(x1shift,y1shift);
    }
    else
    {
' }1 T3 h* d% K: Q5 E        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);
  V- W# S8 N! a  g& G! M    }
}</P>
3 _0 `! A4 {/ k4 Q% L! e- g
2 o4 G& g0 m' K7 z- `<>
//-----------------------------------------------------------------------------
0 V( r/ F4 l* V" e" \- H& q// Name:
// Desc:
- x: |' U/ D: ?& Q9 w) R//-----------------------------------------------------------------------------
7 u1 \% j$ U! _5 r4 ?' p. t# ?, W4 hvoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
2 d9 U3 P: r0 p5 P. s7 z{
! [+ K4 {' Y' a9 h5 }8 |. J    if( x1 == x2 &amp;&amp; y1 == y2 )
0 Y- k3 C, U. u    {
        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
            UnlockCell( x1, y1 );
        else
9 x3 W2 P  I  G4 F! Y) T& x            m_OffMapLock.Leave();</P>
<>        return;
    }</P>
: Q; @& E8 A/ I8 Z, r) R/ f' l<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
<P>    if( x1 == 0xffff )
( ?5 N2 s, R4 r3 H% M    {
: P) N* Y! A* M* r. [+ l' F1 o        m_LockGrid.UnlockCell(x2shift,y2shift);
        m_OffMapLock.Leave();
9 M7 ~" R# I8 R4 U6 Z9 L    }
3 E. `" B6 ?8 N6 Z    else if( x2 == 0xffff )
    {
        m_LockGrid.UnlockCell(x1shift,y1shift);
        m_OffMapLock.Leave();
: m" u0 ]: G8 V+ f, `& [& m" Z6 Z: P5 d    }
    else
8 w% J& s+ W  R; l: h0 ~    {
        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);
    }
: G9 [0 j) A  ~! y2 [4 N. p9 `}</P>

( v% s6 ]/ H9 f# m. b' s<P>
; i4 Q8 I6 T2 S# f& y" E//-----------------------------------------------------------------------------
0 t  ~! K2 A: i0 r% P4 K  O// Name:
// Desc:
8 l. e+ I# R) A6 a- v9 y! b//-----------------------------------------------------------------------------
void CMazeServer::OnAddConnection( DWORD id )
* r+ v4 K! {3 K- L* b( F5 w{
    m_AddRemoveLock.Enter();</P>
<P>    // Increment our count of players
    m_dwPlayerCount++;
/ p: v+ ^: J1 x5 y8 U, @4 J    if( m_dwLogLevel &gt; 0 )
4 X0 m. r" E$ y6 ^    {
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
1 B8 N2 j1 Q* |        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
: q0 U5 _, y8 J/ G) S- i    }</P>
- e* \8 E+ \6 ~) m# p( g1 q5 _7 W<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
) T% U0 S6 I# U' ?! E1 L# c5 r5 b<P>    // Create a player for this client
& o; G& f* ]' B+ p  Y# [    PlayerData* pPlayerData = CreatePlayerData();
    if( pPlayerData == NULL )
    {
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
        m_AddRemoveLock.Leave();
        return;
  r4 w' `3 J' ^' F6 a; M( y2 b    }</P>
( F  G3 a: Y9 {7 m! o<P>    // Store that pointer as local player data
$ l% W0 ]1 l4 j    SetPlayerDataForID( id, pPlayerData );</P>
  ^( h3 y$ S9 E<P>    // Grab net config into to send to client
    m_ClientNetConfigLock.Enter();
    ServerConfigPacket packet( m_ClientNetConfig );
* {* D! c4 \$ q5 X$ X" d    m_ClientNetConfigLock.Leave();</P>
<P>    // Send it
    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
<P>    m_AddRemoveLock.Leave();
3 O2 _: d6 @* P3 ~: \7 L5 |}</P>
' M. z/ ^1 i) }
<P>
0 G6 B+ g0 N" L//-----------------------------------------------------------------------------
# j! `; {# J0 ?# _// Name:
! m1 M9 v9 M! ~, U5 S// Desc:
3 s8 f0 M4 X9 u, Q" S) R' l6 g& X//-----------------------------------------------------------------------------
) D0 a0 J" _, Bvoid CMazeServer::OnRemoveConnection( DWORD id )
{
    m_AddRemoveLock.Enter();</P>
<P>    // Decrement count of players
    m_dwPlayerCount--;</P>
<P>    if( m_dwLogLevel &gt; 0 )
    {
        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
2 T. w( ~# h3 r1 Q$ J( p    }</P>
$ g2 m1 A; b" o; l" q' a, x<P>    // Find playerdata for this client
    PlayerData* pPlayerData = GetPlayerDataForID( id );
    if( pPlayerData != NULL )
0 d( b- H5 L$ C) ^5 D: }    {
        // Destroy it
        RemovePlayerDataID( pPlayerData );
        DestroyPlayerData( pPlayerData );
    }</P>
<P>    m_AddRemoveLock.Leave();
: n+ j3 F( g. S3 y}</P>
( C2 k# M8 W1 X+ e' M# b
# x2 Q7 J+ e  M1 l<P>
8 H5 G# E: y( \* T. H//-----------------------------------------------------------------------------
) w1 i! k1 w- Y// Name:
2 V* c* O' D. v0 u% u6 H( ~// Desc:
//-----------------------------------------------------------------------------
HRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
{
    BOOL fFoundSize = FALSE;</P>
<P>    // Increment the number of thread we have in this process.
: g% p7 y; y/ @; N5 V8 |* u    m_csThreadCountLock.Enter();</P>
/ D2 l; v2 f- H$ _3 s<P>    //Get the start time of when we entered the message handler.
: p: m8 P+ j+ A, K. j    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>
) X# r5 W2 W  m# ^. o+ D<P>    m_wActiveThreadCount++;
+ }5 J/ c/ W+ p+ d, [* t) c# i    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)
        m_wMaxThreadCount = m_wActiveThreadCount;
+ D* i8 l& Y9 @6 _9 H; c   
    // Calculate and average.
    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;
: L; b4 K) ]/ S" x, \' T, E9 D    m_fAvgThreadCount += fdiff/32;
   
0 k$ [7 p: k  U& ~  ?/ y/ O    m_csThreadCountLock.Leave();</P>
6 q8 K! K( Q, \9 t<P>
# h$ p6 y' s: l/ L    ClientPacket* pClientPack = (ClientPacket*)pData;
9 u" I0 B. t8 H- a2 s2 C    switch( pClientPack-&gt;wType )
. D/ }' F, ]9 K    {
        case PACKETTYPE_CLIENT_POS:
            
3 I2 t0 R! u1 N' x. ^: H/ p            // Check to see if the packet has a valid size. Including
            // the custom pack size.
            if( size &lt; sizeof(ClientPosPacket))
                fFoundSize = FALSE;
* V$ P, r7 d4 ?5 l" g5 ]7 v) ?            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))
8 t; g9 T, w: u9 j                fFoundSize = FALSE;
            else
                fFoundSize = TRUE;</P>
2 Y/ }2 t0 o" W4 r5 _) m<P>            // If valid sized packet, handle the position.
- V3 q5 w4 F. o" ]* T3 y            if(fFoundSize)
' K3 D4 ~6 f5 u  ~+ S; @, F                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
            else
6 D/ U# c3 }& O5 E" s                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
2 D) S: c% R+ V2 j5 [; ^* `<P>            break;</P>
( X. a* v# w1 N) Z3 I- Y<P>        case PACKETTYPE_CLIENT_VERSION:
            if( size == sizeof(ClientVersionPacket) )
                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
/ ~) W% J! D4 [8 F. _- _            else
9 n" \5 T& `' u2 _- \* g5 S                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
6 j0 V- V- c; v, z  c& C+ M            break;</P>
! u- k" w9 I9 [3 N5 h  c) X' ?<P>        case PACKETTYPE_SERVER_CONFIG:</P>
3 z7 k2 S( @& V3 g+ t3 ^# c<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>
<P>            break;
) W3 l  a4 F0 F6 ?5 E- ?        default:
' L, g5 \. g" D. }* M2 V- C            HandleUnknownPacket( dwFrom, pClientPack, size );
            break;
    }</P>
5 a/ y* x, M+ P- {' n; v<P>    //If the user wants to hold the thread, Sleep for given amount of time.
    if ( m_dwServerThreadWait &gt; 0 )
! s" B) R) c8 H# c3 f    {
        Sleep( m_dwServerThreadWait );
- ^1 j2 k0 T- q) u0 l# l    }
   
# w6 W3 N9 t' Z  @) f* W& t" P' i    // Retrieve thread data for this process.
    m_csThreadCountLock.Enter();</P>
6 R$ o7 O. `" o/ ~  g  u; F  f<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.
    if ( fDiffTime &gt; m_fMaxThreadTime )
    {
        m_fMaxThreadTime = fDiffTime;
    }</P>
<P>    m_csThreadCountLock.Leave();</P>
<P>    return S_OK;
, {6 C4 F9 w( R  O}</P>

- j# _, \9 A* U/ Q<P>//-----------------------------------------------------------------------------
" Y/ x! g! _; N8 Q) E- B, L! G. W// Name:
, {0 X1 A9 e5 x  Z9 N2 g) V- W// Desc:
5 W9 }' F. Z* d& B& A% m//-----------------------------------------------------------------------------
- J% K" G2 V+ ?' O) Z8 B$ NBOOL CMazeServer::IsValidPackSize( DWORD dwSize )
{
    BOOL fFoundSize = FALSE;
    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
. e' Z' Y; C5 g- Y- g& q2 ]   
9 w& T7 q/ }+ l    // Check through the array of valid pack sizes.
    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    {
        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
  S; P* S, C0 \1 e7 U! f. z        {
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
! X( l0 ^2 e- C# N6 Z            {
( R) S* X* r) R- S% Z                // Found valid size in the array.
                fFoundSize = TRUE;
' j: o. b- `: l4 I; j                break;
            }
            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
        }
% F- f+ u6 f& ?  A( z) A' g    }
    else
    {
  h' E5 E) }  w4 Z$ z0 M& L        fFoundSize = TRUE;
    }</P>
<P>    return fFoundSize;
/ X9 y- J6 c' s/ z, o# O}</P>
( O' R" @4 F& r8 G; g<P>
//-----------------------------------------------------------------------------
$ s2 i- t& t- R. _// Name:
// Desc:
  L- S$ M3 y6 b. v, t//-----------------------------------------------------------------------------
void CMazeServer::OnSessionLost( DWORD dwReason )
7 A1 p' c! m9 L# A& i- Z{
% I. G" U3 K9 r8 }5 Q  C6 R* G    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
9 x) |" O0 e5 M; f7 c* \}</P>

<P>
//-----------------------------------------------------------------------------
5 `& L" w- t# ]6 c3 _, n& \" b( i// Name:
// Desc:
//-----------------------------------------------------------------------------
PlayerData* CMazeServer::CreatePlayerData()
{
% n) n: V# s5 @2 r' y" W    m_PlayerDataListLock.Enter();</P>
* i- k3 V/ p# m- _* H<P>    // Grab first free player in the list
    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
+ @) E* R" I/ I2 a<P>    if( pPlayerData )
! e! V3 z( \% A4 z* q    {
( k7 h. G7 \! z        LockPlayerData( pPlayerData );</P>
" h) r8 V2 e  l  |% k# H# J<P>        // Got one, so remove it from the free list
        if( pPlayerData-&gt;pPrevious )
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
+ `+ S1 Z# F7 q( B" A5 z8 O        if( pPlayerData-&gt;pNext )
# x5 Y% o- D/ \/ B$ _            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
% k  a( ^# J0 T# E2 t' |) K" q        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>
- N' ]; T1 i- H1 d1 r& [4 Z, h: Q<P>        // Add it to the active list
        if( m_pFirstActivePlayerData )
: H0 x  V( v  }- F6 m) F) M            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
        pPlayerData-&gt;pPrevious = NULL;
        m_pFirstActivePlayerData = pPlayerData;</P>
<P>        // Update count of players
4 \% R# x3 U2 X' R5 n. P- M2 @        m_dwActivePlayerDataCount++;</P>
<P>        // Generate the ID for this player
        m_dwPlayerDataUniqueValue++;
9 T+ `$ P& G: m+ V* B! H        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
  U7 \7 X0 x1 W" H# G! ]7 {: {8 N<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
( ~- o, G' M6 R1 V% r        pPlayerData-&gt;NetID = 0;
        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
<P>        // Insert into the "off-map" cell
$ k2 f! _: Y) H        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
6 X) _6 H) g3 i# x        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;
        m_OffMapLock.Enter();
        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
        m_OffMapCell.pFirstPlayerData = pPlayerData;
$ H" D. @1 y8 Y/ L& k        m_OffMapLock.Leave();</P>
( }2 Z! C0 \& a( N<P>        // Mark as active
        pPlayerData-&gt;bActive = TRUE;</P>
5 o  l0 }" m% t; z! Q( @& i  I7 s<P>        UnlockPlayerData( pPlayerData );
    }</P>
0 p% B/ v- F3 E% d# _( {0 w' V<P>    m_PlayerDataListLock.Leave();</P>
- H; [+ u. [' x( M" z<P>    return pPlayerData;
7 r0 V/ H. v2 q# ]& f' R+ A}</P>

<P>
//-----------------------------------------------------------------------------
0 N2 L$ r+ n8 y, l6 U$ C3 w3 e// Name:
. m9 k, T, P* B6 w0 |// Desc:
3 {. I3 B* V7 R* l//-----------------------------------------------------------------------------
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
{
- c7 D; ?+ F7 M) e% X! u2 Z0 s    m_PlayerDataListLock.Enter();
    LockPlayerData( pPlayerData );</P>
<P>    // Remove the player from its cell
7 }. L$ G# s) }$ e; q9 g, W6 A    RemovePlayerDataFromCell( pPlayerData );</P>
<P>    // Mark as inactive
3 J( E) }, F; I; j    pPlayerData-&gt;bActive = FALSE;</P>
<P>    // Remove player from active list
    if( pPlayerData-&gt;pPrevious )
        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
1 Q( Y2 o8 j0 ]) N8 f3 H    if( pPlayerData-&gt;pNext )
        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
<P>    if( m_pFirstActivePlayerData == pPlayerData )
3 u2 N4 x& g! s) j* t/ p: z; H        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
<P>    // Add it to the free list
    if( m_pFirstFreePlayerData )
7 B3 e# V" N  E/ \" ], G7 Z' L        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
8 Q; b5 K; M/ ], o; x- @    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
    pPlayerData-&gt;pPrevious = NULL;
    m_pFirstFreePlayerData = pPlayerData;</P>
9 _1 u" h& X" H; v& q% u<P>    // Update count of players
    m_dwActivePlayerDataCount--;</P>
<P>    UnlockPlayerData( pPlayerData );
, {( w, N0 @9 A7 s1 `0 S$ u2 t6 s8 }    m_PlayerDataListLock.Leave();
}</P>

% H' D; t, D4 p6 K/ I2 w<P>
//-----------------------------------------------------------------------------
// Name:
; z9 p5 F* j9 @1 y9 ~// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
{
    // Lock the player
    LockPlayerData( pPlayerData );</P>
, g7 f' J$ S( w; o- u% c& u; S  d5 s<P>    // Lock the cell the player is in
( t! n) l1 [3 ^* B% t    ServerCell* pCell;
    if( pPlayerData-&gt;wCellX == 0xffff )
8 y; V' s( i& Q$ o) m" X    {
) [! Y2 W8 y+ [0 }7 c0 H7 @        m_OffMapLock.Enter();
        pCell = &amp;m_OffMapCell;
    }
! |& A$ T1 `  O) j( l2 B    else
/ g! O$ ^. [' l( @    {
        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
    }</P>
<P>    // Remove it from the cell
8 |7 h, j' V% Z* t' I. d3 L/ ~# b  _    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
- K; H' Q; N4 a9 I" b    PlayerData* pPrev = NULL;
( Y& X( M. P/ J% ~    while ( pPt )
    {
) |5 B, s1 Z9 R+ a" d* c7 a        if( pPt == pPlayerData )
" ?& O% n* G" G: |* `4 G        {
            if( pPrev )
- O' G$ G/ u- ]8 t. Q8 t                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
; V( ^7 }$ `; o7 q+ U% u. d: v            else
2 w2 E3 G6 j- k5 A. I+ A                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
# k# k/ n/ }, Q  n; g/ ?<P>            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
        pPrev = pPt;
1 H9 e4 j$ N; k: j8 r+ I; y        pPt = pPt-&gt;pNextInCell;
% s/ }( O& {8 r; j% Y. k3 l    }</P>
+ r8 d, S* ]. i! ^% |6 N6 `; ~<P>    // Unlock the cell
; K3 I/ F8 {, Y" p7 }5 i' A" p% x    if( pPlayerData-&gt;wCellX == 0xffff )
. C) v  `' W' S# ~7 w        m_OffMapLock.Leave();
    else
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
' c, X3 X1 G0 ]+ a. b<P>    // Unlock the player
    UnlockPlayerData( pPlayerData );
# n: J. e- }6 F: U5 R# r}</P>
" Y8 `1 a3 p8 r5 d) n, A# W
<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
% y1 o6 Z0 Y; V0 l6 c: ]. n' B//-----------------------------------------------------------------------------
void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
+ l) k# ]! `* }. t' F' u{
) x: {5 m  \/ s: D+ G0 m4 v9 f    ServerCell* pCell = GetCell( pPlayerData );
    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;
    PlayerData* pPrev = NULL;
7 r, {5 h" _7 y    while ( pPt )
7 x% k7 o! W2 y6 K' Y& H5 D    {
* }3 K( l- O. c% h9 ^' S' U% \        if( pPt == pPlayerData )
        {
! m& j! j' h* k7 W; H9 k8 i            if( pPrev )
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
. ^0 k3 \& |; a( ?            else
9 a7 j" ?1 Y& P& U* m                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
            pPlayerData-&gt;pNextInCell = NULL;
            break;
        }
& w: V9 ]# P. e8 y* i9 Y        pPrev = pPt;
1 j) _: g7 \& r& K  J5 c  z        pPt = pPt-&gt;pNextInCell;
    }
  u, ^9 ?4 k. I$ t}</P>
6 K- {+ Y, g+ A' L3 K! n
5 G9 C! x) r. {# W1 R1 R# M8 {<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
{
0 N# w8 g' s8 S9 d7 c6 a    ServerCell* pCell   = GetCell( pPlayerData );
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
    pCell-&gt;pFirstPlayerData = pPlayerData;
* E& d' V$ @( w}</P>
  J% v' ]- S2 s1 q2 T. @
<P>
: E% B' m. S) e/ U1 ^1 m& a//-----------------------------------------------------------------------------
5 I; k0 |) n9 ^/ g// Name:
// Desc:
6 j+ l! I9 r; J: n//-----------------------------------------------------------------------------
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
{
    // Grab player for this client and lock it
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    if( pFromPlayer == NULL )
    {
2 Z% }9 ]& U. B* _' }        if( m_dwLogLevel &gt; 1 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
        return;
& s* L' A  i8 }( u$ O: C    }</P>
<P>    LockPlayerData( pFromPlayer );</P>
<P>    if( FALSE == pFromPlayer-&gt;bAllow )
6 ~5 i- w2 R  Y# L+ S    {
& ~9 ^2 s9 O$ N) P" r: b% g" S+ \        if( m_dwLogLevel &gt; 0 )
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
+ c" n& M' _( ~+ q& J<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
& ~1 e' D7 l9 S2 @4 l1 d        UnlockPlayerData( pFromPlayer );
# n8 j: Y$ t5 k- D: a* U% }9 c        return;
    }</P>
<P>    // Compute the cell the player should be in now
    DWORD newcellx = int(pClientPosPack-&gt;fX);
+ f0 Q" L( B2 n: S  M, G    DWORD newcelly = int(pClientPosPack-&gt;fY);
    DWORD oldcellx = pFromPlayer-&gt;wCellX;
    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>
<P>    // Have we moved cell?
" T' e9 o# Q- B; g+ w3 d! J; B    if( newcellx != oldcellx || newcelly != oldcelly )
$ Y  e& c' s: Y9 @4 R$ c2 _    {
; R3 A/ @: ?( u. G7 b        // Yes, so lock the pair of cells in question
        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
& z; d2 J* I, w- }0 x<P>        // Remove from old cell and add to new cell
6 k' @! F) g3 W+ j* O2 E, @4 P7 a; @        UnsafeRemovePlayerDataFromCell( pFromPlayer );
        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
; l; F) ~$ d; i; v7 Y, g        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
. a* j+ e9 k2 u- T/ C+ C) q<P>        // Unlock cells
        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );
    }</P>
( E% S0 ^6 U8 n& s6 K& w" m<P>    // Update player position
5 T, ^! O8 ~$ N4 P5 i3 L    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;
$ S7 c' w6 k; I8 \    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
2 q5 F: X% K  t3 B    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
<P>    // Allocate space to build the reply packet, and fill in header
, V! r& O; ]( L7 T6 b+ l  B  Q8 r    DWORD dwAllocSize;
    ServerAckPacket* pSvrAckPack = NULL;</P>
<P>    // Begin by allocating a buffer sized according to
    // the current number of nearby players + 4.  This will give
    // a little room for more players to come 'near' without resize
& C) u# h% ]; }% h% u    // the buffer.
    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
# h/ m  `0 D& ?6 v<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
    if( NULL == pSvrAckPack )
* M% j' _! n: b) i7 ]5 z, r    {
        // Out of mem.  Cleanup and return
        UnlockPlayerData( pFromPlayer );
        return;      
2 a1 r' f3 t6 L: U. }, |( Z    }
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
* P; L4 T6 q$ L+ M. @. @* N<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
; n. a( E. N( M2 k4 K) x; x    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;
" v$ w% }8 s2 n  \    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
6 B# `1 \& r8 W5 o- r    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;
    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
<P>    // Lock that range of cells
: S7 v) T+ X1 L$ n    LockRange( minx, miny, maxx, maxy );</P>
<P>    // Scan through the cells, tagging player data onto the end of
    // our pSvrAckPacket until we run out of room
    for( DWORD y = miny; y &lt;= maxy; y++ )
+ y% }3 d6 F  N    {
        for( DWORD x = minx; x &lt;= maxx; x++ )
        {
            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;
            while ( pCurPlayerData )
            {
                if( pCurPlayerData != pFromPlayer )
                {
" {# k' N6 `: a  D+ ?5 k  d                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )
                    {
2 V! p/ {& @9 A, L1 H" q2 b3 Y                        // Make sure pChunk is where we think it is
' F2 ^6 C, T% ?% E8 J8 Y3 X  w                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
% [0 V' Q. S2 w9 ^8 _; ~<P>                        // There are more than just 4 new nearby players, so resize the
! R8 E* H/ [. D3 ?" d' @                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
                        dwMaxPlayerStatePackets += 16;
5 |5 J2 N# V" K( K' M9 z3 i+ T                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);
3 z* b+ [  f+ M( D, q7 g( l6 L                        ServerAckPacket* pNewSvrAckPack = NULL;
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );
                        if( NULL == pNewSvrAckPack )
                        {
6 \" i" H, z: W3 Z! \                            // Out of mem.  Cleanup and return
                            free( pSvrAckPack );
" q" U% U5 V; b% p* `                            UnlockRange( minx, miny, maxx, maxy );
2 l: A7 W' F/ d                            UnlockPlayerData( pFromPlayer );
" H' v- M4 d' a) P" r                            return;      
3 T3 R! H7 Q- j) W                        }</P>
# r8 e+ A- c$ O" P# a. F<P>                        pSvrAckPack = pNewSvrAckPack;
2 t# q5 W) W" \+ y; E                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>
<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>
: ^- f$ `7 Z  t9 c3 P% u<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
+ q# w  q# e1 X- o                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;
                    pChunk++;
                    pSvrAckPack-&gt;wPlayerStatePacketCount++;
' y) N9 s8 G3 D1 Q) y7 v                }
                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
            }
        }
    }</P>
" U+ a  }9 ^8 f9 t. }<P>    // Update the dwNumNearbyPlayers for this player
) V  Y. y; A7 J. g" @. A7 _) i, c9 g) p    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
6 @) r1 W" b3 D! k) u' z* R<P>    // Unlock range of cells
( }  R9 ?+ H- }) r! f5 P! R    UnlockRange( minx, miny, maxx, maxy );</P>
<P>    if( m_dwLogLevel &gt; 2 )
    {
* I1 ?, W) e- W6 I        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
    }
, @2 A% j5 X6 v! c9 u    else if( m_dwLogLevel == 2 )
    {
        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
( f( F+ m6 Y: o" U( h, c        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
        {
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
            pFromPlayer-&gt;fLastDisplayTime = fTime;
        }
    }</P>
" N8 z9 h  O( S" j' B4 m9 a<P>    // Unlock the playerdata
    UnlockPlayerData( pFromPlayer );</P>
. Y7 C+ M" U/ I! N2 q+ J<P>    // Send acknowledgement back to client, including list of nearby players
    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));

    // Pack the buffer with dummy data.
& b/ ~* V+ a) r3 U    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
5 d6 O( `4 |5 K  s1 p; H    {
6 u  @8 c3 m7 Z' T% I2 e        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
        VOID*   pTempBuffer = 0;</P>
7 l% N& G9 z" V! ?<P>        pTempBuffer = malloc(dwBufferSize);
        if( NULL == pTempBuffer )
' H2 Y. Z! b( V1 k8 M1 f# l# i* U        {
1 Q, W8 z# }+ T            //Out of memory
            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
' N6 V% C3 o" t$ E            free( pSvrAckPack );
            return;
" I' N% h3 |0 ?6 v0 O! L        }</P>
2 |# R, ?% v- _4 j9 J7 c<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
1 C  r7 a0 r$ s1 ?3 b        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
( \) R! i1 }! [0 O3 y   
0 Z; d* ?+ o; n; @3 H        free(pTempBuffer);
, f: K2 k9 h+ R1 w    }   
  \( @$ a+ X  ^    else
) h. y6 |& S2 E) h5 W    {
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );
  [# s' N( L( D- I, e    }</P>
; h& G) J. i: o3 Q<P>    free( pSvrAckPack );</P>
<P>}</P>

9 F% X1 U) V. @+ X. K# G; c" p/ z<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
+ t9 J8 ~; C" jvoid CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
{
    // Grab playerdata for this client and lock it
- [0 l" v, ^  T( |- I* s0 J1 E    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
+ M. o/ v' F6 Y    if( pPlayerData == NULL )
: F6 L7 w7 H& P  a1 V        return;
: K; K6 D6 [0 c- P1 Y9 S1 j& X4 R5 t1 k, X    LockPlayerData( pPlayerData );</P>
<P>    // Record the version number
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
<P>    if( m_bLocalLoopback )
        pPlayerData-&gt;bAllow = TRUE;
    else
) J! t7 E6 o0 M) i( g, f        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
5 B# V- r7 f" r7 |" w( T<P>    if( m_dwLogLevel &gt; 0 )
) U1 X$ ~: v- x        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 )
* S; b" ]% h7 X( P7 I; _    {
0 C" _7 C7 ~) b& A: m7 N        if( m_dwLogLevel &gt; 0 )
! j; x( X- x9 Q6 o- ~% u            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
        UnlockPlayerData( pPlayerData );
        return;
+ G- Z; h. v0 n! m3 i    }</P>
<P>    // Unlock the playerdata
9 M; j5 n* Z1 p( x& W! U* K# T5 U    UnlockPlayerData( pPlayerData );</P>
0 {, Z, c9 n/ i<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>

! R5 `! T3 [' r<P>
2 O( ^1 P1 t  C: x5 K//-----------------------------------------------------------------------------
. K1 s2 D; U, Z7 G# k// Name:
) k7 z) _2 I+ _( z6 T' S// Desc:
/ _0 z4 X& A& R9 h//-----------------------------------------------------------------------------
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
: w: Y0 g* T- A8 ^% i{
    switch( dwClientVersion )
  [( x' H; r: B# l$ F) ]* I    {
        case 107: // only v107 is supported
+ _  X' h- K. n4 c            return TRUE;
        default:
            return FALSE;
    }
* j8 m# {6 k. a$ v5 X}</P>

<P>
  a7 x' K1 X  ~1 |; ]7 Q! B//-----------------------------------------------------------------------------
/ e7 r. Y$ |0 f* X6 _// Name:
// Desc:
9 S1 D6 O- |) E0 R2 B% H$ v0 ]* @1 `//-----------------------------------------------------------------------------
& f- X+ }0 i$ `" _! Tvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
6 C" G3 r5 i6 g& b  \$ h- m% C{
# H3 q1 t. R3 X  J# }" C, ?    if( m_dwLogLevel &gt; 1 )
7 K) |2 P' y( ~        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 );
8 @, t' C  H+ m0 ^  N6 K}</P>

<P>
5 q# W3 P3 w/ M+ Z0 B, E//-----------------------------------------------------------------------------
// Name:
/ j5 G- C2 P. v$ N6 G* e$ o% X// Desc:
. S( m' B1 y9 ?; a//-----------------------------------------------------------------------------
DWORD   CMazeServer::IDHash( DWORD id )
5 C5 |7 c: j. I# V{
    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);
. y: Y" R! z) f+ o# S1 k7 i    return hash;
. t0 c5 R! ~/ F}</P>

" F1 }) W+ r* ^4 L! L+ v: e<P>
//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
% m9 m9 K+ u. x0 g    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
* \8 L# ~/ l) m<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPt = m_pstIDHashBucket[bucket];
% N8 T( j7 a. _$ \. q    PlayerData* pPrev = NULL;
2 y# G3 ~' V9 W9 W* a: i* R    while( pPt )
; h' g4 Q  w& M8 L    {
4 z+ ]5 V" o1 K1 L2 D4 l        if( pPt == pPlayerData )
+ n  [8 A6 _% P; ]8 F% b; [            break;
$ i% B( s: Z$ F$ [& U7 H2 y! ?: V6 K3 R        pPrev = pPt;
        pPt = pPt-&gt;pNextInIDHashBucket;
    }</P>
<P>    if( pPt )
3 F& P% \9 w; Q* Q    {
* b2 W+ d) h4 ^) I7 v        if( pPrev )
            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;
        else
            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
! |$ M& ]- O* v$ X, p. W- v        pPt-&gt;pNextInIDHashBucket = NULL;
    }</P>
9 R8 @1 ^# F  Y3 ?: Z<P>    // Unlock the hash bucket
7 ^+ `: W; X* B6 K    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
}</P>
0 Q( u* k& i+ `/ B" g
) u5 v0 t5 v: x. f<P>
//-----------------------------------------------------------------------------
' K/ d5 B9 j2 q! x$ k0 q! P// Name:
// Desc:
//-----------------------------------------------------------------------------
& j2 {2 G! K" a4 z/ ?. i) s5 D8 nvoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
5 Q+ x) |% ?. B* W) X- s" S$ _% @{
    // Make sure this player isn't added twice to the m_pstIDHashBucket[]
    // otherwise there will be a circular reference
    PlayerData* pSearch = GetPlayerDataForID( id );
    if( pSearch != NULL )
        return;</P>
5 f3 e% ]" O# Q<P>    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Add player onto hash bucket chain
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];
    m_pstIDHashBucket[bucket] = pPlayerData;</P>
<P>    // Store net id in player
3 {/ }( t4 P- Q* ^/ f    pPlayerData-&gt;NetID = id;</P>
" q, Z- O5 y4 ~<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
; V# y4 F, S+ ^, u! U}</P>
+ K6 n) J& ]6 X8 l) e" ]3 a, r( L% R
, {1 w- Y( [; w& K3 B<P>
+ ~3 V/ m$ _0 v: j* [/ A//-----------------------------------------------------------------------------
// Name:
1 K! {  T! o& H" w+ n) M// Desc:
0 E6 R) [3 o& F$ v. [  E//-----------------------------------------------------------------------------
PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
3 v0 f% y- {3 v& j{
    // Hash the ID to a bucket number
    DWORD   bucket = IDHash( id );</P>
# c8 ]7 a1 d6 Q* ]* S# O<P>    // Lock that hash bucket
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
+ u# W4 h+ q/ w; E; @! P    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
<P>    // Loop though players in bucket until we find the right one
    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];
    while ( pPlayerData )
+ o7 ?1 M- |# W* R0 D2 u! {    {
  ~- n: a8 r  ?8 W        if( pPlayerData-&gt;NetID == id )
% G& e& U. v6 z1 c. V* P, F            break;
* e7 _0 `6 e( N. `$ m        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
    }</P>
: D9 a  J* h0 x9 H, Q7 G$ Q6 p<P>    // Unlock the hash bucket
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
& b  E: B$ H  T<P>    // Return the player we found (will be NULL if we couldn't find it)
    return pPlayerData;
. T8 `+ a/ V1 B3 c: s$ V}</P>
# P2 e, _, A* l$ L+ K$ @$ \' g
  i' n! `  D* G6 P4 S" @; {: P<P>
$ s  G6 W- g# D) ^* ]//-----------------------------------------------------------------------------
// Name:
1 v$ ]. t6 O1 f& v1 B8 X// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
' M9 }3 A. i: h# m! u" o1 L//-----------------------------------------------------------------------------
void CMazeServer:isplayNextConnectionInfo()
{
1 Y/ Z; X. Z4 @: c' i7 a- R0 r    if( m_pNet )
    {
        // Find the player that was displayed the longest time ago, and display it.
5 R9 T) C3 f) E5 a, B        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
$ D# E0 J8 q: t) Y  \$ K# N; R        PlayerData* pOldestPlayerData = NULL;
9 a* e0 J; h: a4 {        FLOAT fOldestTime = 0.0f;</P>
<P>        m_PlayerDataListLock.Enter();</P>
9 v& r2 Q+ c: Y& s: L3 q<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
0 j, t4 v2 a8 l  Y+ U2 u8 A        while ( pPlayerData )
7 t- ~! k2 a8 n' n8 j3 x        {
3 `9 a$ ^+ [9 H3 I# V            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
" G  \8 G  z' t            {
, y1 E( s" x. r                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
                pOldestPlayerData = pPlayerData;
+ R0 J8 j* K, N            }</P>
<P>            pPlayerData = pPlayerData-&gt;pNext;
0 w9 B: x/ k. R        }</P>
9 `/ ~1 Q2 t# N2 v( y# H, y<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") );
            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
            pOldestPlayerData-&gt;fLastCITime = fCurTime;
+ q" C1 B$ d/ J% @0 K1 `" M3 U        }
& `8 L' K* g, F; d        else
2 [3 a- l8 b4 s+ `! x        {
6 C$ S  P  g9 Z9 B            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
, d* R6 R( i- o0 z! T( }3 s0 K        }</P>
9 e( T5 E6 {7 F8 p9 _* g- Z<P>        m_PlayerDataListLock.Leave();
    }
0 M: r' t) c4 k1 r& c}</P>

1 g% Z4 Z8 Z( D1 J<P>
//-----------------------------------------------------------------------------
9 ]: l  D* L/ H0 W6 H1 u// Name:
// Desc:
& U  n3 `" _' s1 i& X9 m( |; o. @//-----------------------------------------------------------------------------
  l5 z/ O7 t" R- D, r) J5 |. Hvoid CMazeServer:rintStats()
{
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"),
                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),
                                    m_fAvgThreadTime, m_fMaxThreadTime );
* N: |  I! u6 ^6 {5 h    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
8 f* s! ^% b5 h% q( p}</P>

<P>
( \' p  o& d/ V0 i* p//-----------------------------------------------------------------------------
! G- S: W/ x' `5 x; T// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer:isplayConnectionInfo( DWORD dwID )
{
1 w  }7 |8 K# x* ]5 |    TCHAR strInfo[5000];
    TCHAR* strEndOfLine;
) I+ u  U) n% Z* [; t1 {% O    TCHAR* strStartOfLine;</P>
' B. G; p! M' g% n( {8 Z  B8 u& F2 K<P>    // Query the IOutboudNet for info about the connection to this user
    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
+ s3 i$ [. K4 L<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>
% Q9 i, c) f9 J" f( y8 K0 }' F! Q<P>    // Display each line seperately
    strStartOfLine = strInfo;
- K9 B" \3 r" x! D. Y0 j    while( TRUE )
    {
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
        if( strEndOfLine == NULL )
+ S  n" P0 f1 X) _3 d            break;</P>
<P>        *strEndOfLine = 0;
        ConsolePrintf( SLINE_LOG, strStartOfLine );
        strStartOfLine = strEndOfLine + 1;
    }
1 y2 u0 C! j1 z0 [}</P>

$ l1 f* E8 c9 F: z/ ?; [<P>
//-----------------------------------------------------------------------------
2 m6 e& u0 \6 U; {( {3 Y/ n; S% \0 F// Name:
// Desc:
9 P4 G  w9 m( {( S//-----------------------------------------------------------------------------
0 N+ N- z) W  N( M! r, RHRESULT CMazeServer::SendPacket( DWORD to, void* pData,
5 ^: ?. U0 u+ v. R" C  m# W8 c. w                                 DWORD size, BOOL reliable, DWORD dwTimeout )
{
    // Chance of forcing any packet to be delivered reliably
0 k% G4 u/ ?* ?; a4 N* f* H    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )
) z3 m/ T* K9 E( \% v0 t& q        reliable = TRUE;</P>
& g4 L# V" q" [/ j. k+ R+ [<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
}</P>
: ]( b/ g; A9 c$ Q3 w
<P>
//-----------------------------------------------------------------------------
/ x$ T5 |, X  g. o( M0 \3 m// Name:
// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
{
0 [7 {" V6 n: _7 Y2 ~9 k    // If we're up and running, then send this new information to all clients
    if( m_pNet )
# G6 P2 l& ]1 r' `$ W1 g    {
( O! ~0 A7 C" B! T        //Use the AllPlayers ID
$ K7 P0 X& Z+ y9 r; x/ e        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
    }
}</P>

2 h1 l* P/ L5 W<P>
//-----------------------------------------------------------------------------
// Name:
1 k8 s& Y! M* T/ Q// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientReliableRate( DWORD percent )
{
$ ^  z2 c6 s! L+ g    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.ubReliableRate = BYTE(percent);
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
9 L0 s/ Q( H" x! Z<P>    SendConfigPacketToAll( &amp;packet );
( @9 m/ C( |7 L+ Z3 P" x; i}</P>
, Q$ n* M# n+ N5 o1 N
<P>
//-----------------------------------------------------------------------------
8 C: n2 l3 R  ^  R7 A- O5 w" E1 p$ g9 Q// Name:
/ ?" X* @3 `, E6 @8 p) c! ?// Desc:
//-----------------------------------------------------------------------------
void CMazeServer::SetClientUpdateRate( DWORD rate )
2 w- D* ?- K: S; z; S% j; K. h( ~{
# k# n) L- A* G6 g' Q    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
' ?! p$ E; e/ v1 p* Y    m_ClientNetConfig.wUpdateRate = WORD(rate);
    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

<P>
2 @. U, C$ l3 ^1 R2 A7 s( \9 O% c//-----------------------------------------------------------------------------
// Name:
// Desc:
' D3 V2 V' p+ P* e5 W//-----------------------------------------------------------------------------
void CMazeServer::SetClientTimeout( DWORD timeout )
{
    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
    m_ClientNetConfig.wTimeout = WORD(timeout);
    ServerConfigPacket  packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
<P>    SendConfigPacketToAll( &amp;packet );
}</P>

2 [* _- g) R& z$ c4 @+ I<P>
//-----------------------------------------------------------------------------
2 `2 t' j' j* n' @4 Z1 d// Name:
( ~0 s& W. X  `9 a// Desc:
1 O& d* p2 F. K' R//-----------------------------------------------------------------------------
void CMazeServer::SetClientPackSize( DWORD size )
{
    // Update client config, and build packet containing that data
: N+ b0 E# n: E, m    m_ClientNetConfigLock.Enter();
6 d8 G/ i" a: A9 K. o( U. K   
    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   
' C. w& p& l. g4 [5 \        m_ClientNetConfig.ubClientPackIndex = 0;</P>
0 P' _7 I8 Y' o  _/ g  b" Y( f7 I<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
3 l, ?6 _. B' F% D    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
, k- O: ~/ h# f<P>    SendConfigPacketToAll( &amp;packet );
0 E. M: X% U0 j* Q}</P>
3 r4 t, S6 L2 X3 u; M
' F6 B  g' e7 Y. f' w<P>
2 F: M* F% @8 S1 Y4 s//-----------------------------------------------------------------------------
// Name:
// Desc:
& x$ b6 K3 l0 E1 S: i  ~//-----------------------------------------------------------------------------
2 ~( s% e9 W. T. [( c* _* J" J  @void CMazeServer::SetServerPackSize( DWORD size )
. v  Z2 [0 V  ~8 A4 Q' t6 L{
  v# }) O8 C5 c6 ~3 B    // Update client config, and build packet containing that data
2 s0 f: s2 j# L3 ?3 X' y    m_ClientNetConfigLock.Enter();
) y% i5 M, s) B0 _& u5 t   
/ E, ?2 F7 Y  k& N    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.
5 q; C& V" W& k/ g& Z    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
        m_ClientNetConfig.ubServerPackIndex = 0;</P>
/ @& d$ Z) I! @+ w0 \<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
9 y( `* C' m9 \$ w% J' r; D    ServerConfigPacket packet( m_ClientNetConfig );
: e7 N. t* C( @% n8 g    m_ClientNetConfigLock.Leave();</P>
4 S8 E4 ]; M- b  i6 v& L<P>    SendConfigPacketToAll( &amp;packet );
}</P>
& \  z+ w9 T; F% |0 S<P>
* R& q& o8 h2 C' ]6 j9 N$ r//-----------------------------------------------------------------------------
* z. X& h+ x! v/ k& P+ R) A$ t  ~4 u' @5 k// Name:
" h) Z2 d( u6 K: O# H" q// Desc:
" c! Y! p+ g6 v. s) K& S. C% N# s+ P//-----------------------------------------------------------------------------
0 m; T& n: S7 n' d' Q: Q8 e+ Svoid CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
$ A) h( I# `# }& Z- Y{
' ^" ~2 ~: L  x% A/ V7 ~, M    // Update client config, and build packet containing that data
    m_ClientNetConfigLock.Enter();
   
2 ~/ ]& U" ]# o) |0 R    m_ClientNetConfig.dwThreadWait = dwThreadWait;
    ServerConfigPacket packet( m_ClientNetConfig );
    m_ClientNetConfigLock.Leave();</P>
/ y; @& f3 j/ P6 d/ S0 r6 M; p# ]<P>    SendConfigPacketToAll( &amp;packet );
# d' ]. e. i# m}</P></DIV>