数学建模社区-数学中国

标题: [分享]MazeServer源码示例 [打印本页]

作者: ilikenba    时间: 2005-1-31 11:52
标题: [分享]MazeServer源码示例
<DIV class=HtmlCode>+ h) A' ~9 ~2 J% s2 j) u: P
<>// File: mazeserver.cpp
# o9 C1 p! q3 E/ E//
" T0 v' A7 ?. ]; E. b' \// Desc: see main.cpp
% Z0 j9 z( p: r" i//
% y* n! {: `9 ~0 }" M9 X) X// Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.) s# W- r2 _! r) M4 e
//-----------------------------------------------------------------------------
2 ^& E  v2 n6 b, z#define STRICT
% Z8 n& o1 y, f5 o# Z#define D3D_OVERLOADS' H+ d& \9 y) y( L7 G% X0 ?
#include &lt;windows.h&gt;
; r3 O2 D% F5 m#include &lt;d3dx.h&gt;
& {* ^. p) p5 Y4 b6 [, W& v#include &lt;stdio.h&gt;! t$ {3 I$ B8 g! |+ @* `
#include &lt;math.h&gt;" ]! V; }: P: F
#include &lt;mmsystem.h&gt;0 U7 w7 w$ P+ j) r' ^
#include &lt;dplay8.h&gt;/ |0 T' e/ e5 H9 {
#include &lt;dpaddr.h&gt;' ^" j+ m2 ~# B6 r3 G0 b
#include &lt;dxerr8.h&gt;" m7 n0 I2 [5 g3 N" y
#include "DXUtil.h"6 O# h+ ~- g! j. U+ O" X0 Z0 A4 J
#include "MazeServer.h"
* w1 {4 S' C# ]2 M. @; ~3 J#include "ackets.h"
; c' D$ B- Z6 W, c! b( t* h#include "Maze.h"
# t) u3 T9 \, M2 @2 F7 q9 K#include &lt;malloc.h&gt;9 o7 X4 n8 @; d& N
#include &lt;tchar.h&gt;</P>/ Z" K0 ]) t  D
& f$ w( Q9 P( B9 Z4 D+ d
<>//-----------------------------------------------------------------------------
" H: r1 d' h1 M// Name: & @( k) Y3 N9 _* ~1 L. v2 c
// Desc:
+ [/ t! G9 _/ w/ |$ g. Z//-----------------------------------------------------------------------------0 L; r; @+ X( g. N) g
CMazeServer::CMazeServer()
) j! K# I, G6 S% r6 m{" h. g& w4 ?7 ^' K
    m_dwPlayerCount         = 0;
+ w+ i2 q3 ^  d: }) h" R: F    ; i  Y5 T) g  P! W2 d! i
    m_wActiveThreadCount   = 0;+ M2 v- J, Y% ?1 u( X8 C( D
    m_wMaxThreadCount      = 0;$ P8 H8 a5 c* F: u! R
    m_fAvgThreadCount      = 0;, i/ X, e; D# I. Q4 J/ e
    m_fAvgThreadTime       = 0;
7 X. z# D$ B4 k7 T    m_fMaxThreadTime       = 0;</P>1 V8 G7 A/ m# F5 o
<>    m_dwServerReliableRate  = 15;; b( S/ T$ U1 p2 c4 {1 \
    m_dwServerTimeout       = 150;- ~7 R2 v& D) v- m
    m_dwLogLevel            = 2;7 U( ^! Y* u! ]% @, _) x2 G! v
    m_pMaze                 = NULL;</P>
, D" i, l' o/ K" \! _& U' W( p<>    m_ClientNetConfig.ubReliableRate = 15;
) M  \& Q+ O# Q/ x! N    m_ClientNetConfig.wUpdateRate    = 150;
0 ?5 c/ f- J6 T8 E4 c$ {2 e    m_ClientNetConfig.wTimeout       = 150;</P>/ \" o% l# d$ W! ?
<>    m_ClientNetConfig.dwThreadWait = 0;</P>; y1 u3 ^4 C7 Z: _
<>    m_ClientNetConfig.ubClientPackIndex = 0;8 t+ `# s$ m6 x  P: N
    m_ClientNetConfig.ubServerPackIndex = 0;
8 z9 N: z- m- H3 f    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)/ u: ]. G' C" C4 P+ D/ a& h. H
    {
: g: H& F0 M4 Z$ D* C1 K0 \        m_ClientNetConfig.wClientPackSizeArray[x] = 0;
  q5 W5 O7 W5 f# d        m_ClientNetConfig.wServerPackSizeArray[x] = 0;
& N  Y  f* X, ^8 s$ a; I+ p2 K    }
0 A0 @+ _0 D0 c$ @5 Y3 D( K1 q. K}</P>
8 B: H) n1 y6 @& o- S
! Y6 O9 T* X& w0 u<>8 Y" |2 X2 O% p0 P
//-----------------------------------------------------------------------------5 M; ]; ^+ k. w' [  I0 M
// Name: 4 U1 B3 U( Z, O2 l
// Desc:
9 D/ ]+ C" h0 q$ t( Y& ?# g4 |//-----------------------------------------------------------------------------
, ~: I  X) z& `HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze )# l) d* G" b3 w8 t% ^* J) x
{
/ o, S. N$ `& z! e    m_bLocalLoopback = bLocalLoopback;) ?, o  D2 e  R3 ^& Z
    m_pMaze = pMaze;
* M1 l& {7 Z% `  G( c- r# u6 c    if( m_pMaze == NULL )+ e/ K  z' C7 K) G! J) O, ^7 o
        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>
5 F  B6 Q, @! ^* ^0 c: M<>    // Grab height and width of maze4 H3 v" X6 G4 y$ n
    m_dwWidth = m_pMaze-&gt;GetWidth();
( S9 c& `5 f; B" n1 {    m_dwHeight = m_pMaze-&gt;GetHeight();</P>
( I4 _+ b3 J3 Q) G<>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;2 y. ?4 \$ x* Y# f9 u7 |: `- q/ C
    m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>  `% K9 X# A, z1 d2 m' m* F2 H
<>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.; A9 H/ Z/ W/ `9 l5 t3 D) u2 o1 z# E* r
    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
+ |: D5 z) l5 b        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );
& p. N' l7 l# w- c7 h& S* U    if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
/ R: ?# p5 ]$ l4 u        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P>8 n' E( L" N+ d1 n1 v' |
<>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;7 P2 T! k, ~3 a! q& X6 H3 X% i: m
    m_dwMazeXShift = 0;
, G1 [& u. C+ `, O% [' H9 Z9 S    while ( (scale &gt;&gt;= 1) )
' D* i- U8 {3 G) K        m_dwMazeXShift++;</P>
6 G+ M+ B- g" v7 t/ n1 W2 l<>    scale = m_dwHeight / LOCK_GRID_SIZE;! `4 V1 A- Z& ]8 R. w, ^2 h
    m_dwMazeYShift = 0;; m: V1 y  I) Z2 S
    while ( (scale &gt;&gt;= 1) )  u: t) V* `( ^
        m_dwMazeYShift++;</P>
7 ]+ [6 s0 s# C3 G5 v& q8 l0 F<>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
) n( N6 Q, c' C8 a+ @; w" A* M! e- V        ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeYShift) != m_dwHeight) )
1 O1 ?" A$ s3 h+ [* \7 u! @        return DXTRACE_ERR( TEXT("Maze height and width need to be power of 2"), E_INVALIDARG );</P>3 t! J6 ?/ b& D$ e' {$ K
<>    // Initialise the player list
' V& f( A2 Z7 @, G$ ~4 w    ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );
+ W# I' |7 s2 H2 |  _& q- _4 [    m_pFirstActivePlayerData = NULL;& _+ S5 A1 G9 N( c
    m_pFirstFreePlayerData = m_PlayerDatas;
  h8 v) b* D9 [* ]2 T  Z    for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
. ]. H7 i" v2 Y: M; _    {" C; C# k, |* `3 N' e- ]( G
        m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];
& m0 [9 u( P( m* `        m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];2 j) z8 ~3 z4 Q" }9 [( c: y% W* t9 e
    }</P>& m* v3 S/ r/ `# \# h) H9 w3 A# j
<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];
/ L, {6 `# |9 |( Z7 p( O    m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];& s. d9 L* S/ U% i" i. P& y! R/ i
    m_dwActivePlayerDataCount = 0;
9 F4 |! p* x, L# s    m_dwPlayerDataUniqueValue = 0;</P>3 ?5 l! G, T2 F6 l9 V1 O
<>    // Initialise the cells
: z4 ]& q- P9 O0 X3 W3 e+ g    ZeroMemory( m_Cells, sizeof(m_Cells) );
( e2 L) Y; l' d" D/ F    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
" k' S' _9 n, H" W: N" @/ V. u<>    return S_OK;$ J6 `' L2 W0 v' c5 G: G1 i
}</P>  W, M2 q; F# D4 F. A% p. I

8 D  m# V( P( ?8 Y<>, x& x# T5 h6 D& w- _( ~, ]) V! ^9 m
//-----------------------------------------------------------------------------
1 v. A; E1 i& s, A) H// Name: ) y* B0 K5 S4 [9 C0 U  y
// Desc:
+ A" P5 |+ H1 Z1 Q3 c//-----------------------------------------------------------------------------) P/ B( y) _6 E/ z) N# @
void CMazeServer::Shutdown()
" v; W- Q  p( ?7 [& ^9 G{4 P5 K1 v2 o$ M- Y; H
}</P>
  s4 F7 g. B1 N( f/ }3 ]( E- q7 b7 R) m
<>
7 Z) T$ K$ ^; B( @//-----------------------------------------------------------------------------
  i' K9 I+ x6 v" X// Name:
$ s  _4 z$ C, c// Desc: 0 r" f* R: p0 P$ Q$ w3 x
//-----------------------------------------------------------------------------2 u. r: d" w% R
void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
# M" S8 B6 Z6 I; \( ^2 N4 U$ g{* Z. A: ?4 |  n1 B* @  w
    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,: k1 Y% X" b, w) c/ C) A
                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );$ K* e& c3 e$ I% ^
}</P>
2 z# k5 W& h4 m1 [. `0 C$ |4 U/ v9 D. v- E# R! K4 b; C
<>
/ \% i! ~, S+ }//-----------------------------------------------------------------------------
. V' P" _* A, H, S, n// Name: 6 E3 t, H" h5 S1 M- f+ q, \9 Q" \
// Desc:
- B0 c3 a' _& I4 P  M1 W& S- R//-----------------------------------------------------------------------------% j  G: E' ?4 [9 u% w" }! \
void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 ). |: y, R9 Z7 }) k: ]8 Y0 K
{
, l4 y- a% h9 l4 d, l7 V- ^- Q% R    m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,, _) i( J$ y$ U  ]" Y' R) v* N
                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );' W& m; t$ g: g$ R' h0 p
}</P>
2 |0 q& l8 j9 D8 o2 N0 H0 \
/ v6 Q  E, B5 [+ i<>
! \: d' v, J% R0 m+ z. z/ L" N//-----------------------------------------------------------------------------) M& a# r* H$ f1 ]
// Name:
7 `4 O. E5 g9 o1 }" S" n/ v// Desc: / _  G1 i) d, \/ e' K- Q
//-----------------------------------------------------------------------------
! S5 E! ^+ l  c' b$ wvoid CMazeServer:ockCell( DWORD x, DWORD y )" @: P$ V" J! B1 ~% B; E- e$ v! e
{+ B1 t" L7 |0 ], Q$ Y4 m- F* t
    if( x == 0xffff )
6 ]! i9 M. Z% g$ V1 F. H5 p        m_OffMapLock.Enter();0 T& S0 C9 I$ P+ L& E: n
    else( @# E- C" k- e" r
        m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);0 v8 _$ x8 [6 V! h
}</P>; I/ y  h0 ?/ K* e' d0 [+ Q  x  z1 c6 E

5 W- Y1 N3 T8 y' g7 Z: P0 ?* g<>
* \+ q2 d" _2 E( T8 _8 e: z' f& B//-----------------------------------------------------------------------------" l$ c% ^; M; E* _3 x( q2 N$ Y; @
// Name: 0 H) n6 |3 T4 y# [, [! n
// Desc:
# l/ _) E& g# \1 \% Z% ]  C//-----------------------------------------------------------------------------, M7 w+ x: Y% s
void CMazeServer::UnlockCell( DWORD x, DWORD y )+ ^/ Y1 V3 D. O" F/ a* a
{
% F% s3 N! ^; A9 H# }3 i; b9 f. F3 y    if( x == 0xffff )
0 w; n' |! z9 X! K2 R        m_OffMapLock.Leave();" W& z" A( [) r& [9 d0 v) F1 [
    else
" _5 e2 \' x4 E7 K$ f        m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);- e# V$ v/ D8 D8 z1 U
}</P>
' A+ Y' Y- X& M2 {9 t% ^! S' |/ h, ]$ y
<>. m* j: h+ Q2 l" m& h% z/ \
//-----------------------------------------------------------------------------) \2 m  w0 N9 u0 a/ @0 H; c7 q
// Name:
5 {: ?  }* r; o8 E- c. \7 n4 n// Desc:
2 i9 A/ l, E$ o5 L( r//-----------------------------------------------------------------------------
$ ]" M4 T# y/ M% yvoid CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
  N% ]! d6 Z5 }( B* d! p' |+ d{+ P. X2 r$ C$ z
    if( x1 == x2 &amp;&amp; y1 == y2 )
) C' U; t4 y# I) [7 V+ K    {
$ T2 u. o# N0 Q  M/ [9 x0 F; B        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )5 t: E$ P% @/ n; A: o
            LockCell( x1, y1 );
3 f0 V* Q) h/ M/ `        else
6 d6 Q/ A$ x$ D3 u            m_OffMapLock.Enter();</P>5 @: h% Z+ f$ E1 d4 C8 y. q; d- a
<>        return;
8 P$ p- w( M% |( p2 I    }</P>4 }& ^* a5 T! s1 X
<>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
/ j$ [3 v. Y4 q/ J" g! H7 V    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;2 U* S/ V$ f% o/ O$ R
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;% v) J$ i7 ^" C4 x- P
    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
. D* L7 x! E5 v2 o<>    if( x1 == 0xffff )1 |; |; g% u: x3 ]7 L) I
    {
/ t$ H' o9 j# V! G        m_OffMapLock.Enter();/ b2 P" z( Z$ s( @
        m_LockGrid.LockCell(x2shift,y2shift);' h) r" p  p: R9 l8 F
    }, Q9 ~0 `; p1 ~
    else if( x2 == 0xffff )3 n6 S# ]9 x5 p) I1 j7 E
    {- ~( z1 s. L7 A: A1 h
        m_OffMapLock.Enter();
6 b7 w7 U1 J: ^, S0 M: W4 k, R- ~% X        m_LockGrid.LockCell(x1shift,y1shift);; p2 a7 c1 i2 {$ H
    }
4 Q4 e& ?, m7 s5 h2 m    else 0 u3 _* R1 i' z3 U3 B  k$ r' H2 S
    {
+ \0 s- ]6 @1 e5 D- `: y        m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);! C/ n% f! ?  @( Y. I7 W
    }
8 y. G4 r. t$ {) B/ Z}</P>
( C4 j: R4 n3 x1 u, F0 X$ W4 i) b6 S- X: c4 o7 Y) c6 u/ v
<>/ O3 N/ k; `* }5 e4 p+ K+ i
//-----------------------------------------------------------------------------
7 n( ?" a! B9 i  D2 b6 J# O// Name:
6 \# l: a3 Y& J' T+ q# G# C// Desc:
) I) Z& d; t* `- R& \9 P//-----------------------------------------------------------------------------
$ k- G& _  P9 u; `2 P+ T& d' c% Svoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )5 k, d: B0 l: K! o
{; {& B7 f2 [# g% H- W& H
    if( x1 == x2 &amp;&amp; y1 == y2 )
3 X2 `" O3 j/ A6 [    {
1 {0 O5 p  L& \" ~" e* g# a        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
# j. e. e7 W0 d# T, k. a. j            UnlockCell( x1, y1 );% Q! g/ L! k; Y& [) P
        else5 R4 E& `7 l6 ?" G7 J7 T
            m_OffMapLock.Leave();</P>
) Q6 P" A& S4 A<>        return;
  d6 l; H2 a" d8 v3 @( y/ y& J. Y    }</P>
6 R& |& Y9 C4 U) o* S: e1 e- n. a<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
1 {( f- m0 U! b( F% t+ J0 ~! s    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;2 Y; ~0 y, C+ F$ e
    DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
+ o) m; A+ E) ~- s5 E+ d7 B' W& z! F9 y    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>" w& ^- h- A5 B+ A% Q8 {
<P>    if( x1 == 0xffff )
' I# P% M/ U4 I8 W0 F8 c1 J    {
5 D3 j0 r; B! X* i8 ^0 A        m_LockGrid.UnlockCell(x2shift,y2shift);2 U* z$ n1 Q6 v/ y7 i6 h+ L; p" m
        m_OffMapLock.Leave();" `3 {" l: j/ m' j3 p
    }
9 G& R9 e% |: O1 g! K    else if( x2 == 0xffff ), {5 K$ \# B4 ?7 J" Q! [
    {
9 S/ R' b& x  ?. d: [: s        m_LockGrid.UnlockCell(x1shift,y1shift);7 E4 @+ P5 D1 Y6 ]
        m_OffMapLock.Leave();
0 S4 A4 e4 z; ?7 S+ x    }; P4 }7 R) z1 a
    else
7 I. U2 r" j- K    {8 q. }. u" I* C4 }
        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);0 d  @& y6 C8 l/ @
    }
$ u; f+ L9 \) `8 Q7 V3 ~! M}</P>4 z; J1 i" k" R" e; q1 K+ S

) ?, T* l1 {" C$ e<P>
. _' f4 V, V9 l; v( [+ [//-----------------------------------------------------------------------------! Q3 L- f- g) A+ u9 y( ~) D
// Name: ) G6 i+ w4 m, w0 a$ `+ ]+ h" Q
// Desc:
. Z8 X, @( j" ^& X//-----------------------------------------------------------------------------
. o2 l4 n7 J! V& uvoid CMazeServer::OnAddConnection( DWORD id )& l( e4 O" i+ \4 h* w6 l: N! ]
{
" C5 X( o! V* B7 F2 p* v    m_AddRemoveLock.Enter();</P>7 v4 P& i9 [* |; R
<P>    // Increment our count of players
1 \" @: J5 _) T3 k    m_dwPlayerCount++;
) Z! ~$ V: x9 }5 S    if( m_dwLogLevel &gt; 0 )
3 v8 l9 x9 p0 L: K; W1 x# y    {! N& w# ]- v. K9 X6 K
        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
6 e) ~; l! {; S  L/ |        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
0 W1 W& ^2 T- h# c1 L( p. \    }</P>
, r! h1 V3 ~: F: r6 s: y& x<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )
) w' x% p  a6 n* `        m_dwPeakPlayerCount = m_dwPlayerCount;</P>
4 J+ Y6 C9 g$ p* G<P>    // Create a player for this client" ?1 \5 J, w7 Z! T; d# b" b( Y
    PlayerData* pPlayerData = CreatePlayerData();& }" O' J5 P' |+ U. A+ F, _( E
    if( pPlayerData == NULL )9 r- U* X$ \& o+ E- ^
    {
. Z; `  b# E+ Q2 U        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
5 V2 M. j# |/ ~        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
: z3 X1 o* e* B; {: x) Q        m_AddRemoveLock.Leave();
) d- v- C  A  G. J+ K        return;# N  W/ c* N% K' r8 `: r9 T
    }</P>
! y7 q4 X8 q# E8 k, z, [, o<P>    // Store that pointer as local player data
2 y! q+ P7 ?% A0 {, D    SetPlayerDataForID( id, pPlayerData );</P>
9 S) b2 B; L% s- p( L# n, I: p<P>    // Grab net config into to send to client' f5 ]) g5 E# H+ x+ @# s1 _2 r
    m_ClientNetConfigLock.Enter();
% c- m% F$ A2 @3 L    ServerConfigPacket packet( m_ClientNetConfig );' r# J( o/ S# \
    m_ClientNetConfigLock.Leave();</P>: h% P3 U* T' t% z% r  r& y
<P>    // Send it6 z- O, S) \3 e7 g/ q: R
    SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>! o0 r; e+ t" j, q3 k$ D
<P>    m_AddRemoveLock.Leave();
- x7 o" f* C7 ]) ?, j& O}</P>9 W) M% Y6 |' Z! T

6 p% e1 o4 G' `& {; O0 L<P>. R, J1 ?* y! ], Y: f
//-----------------------------------------------------------------------------
  ^4 E! c5 Z! a% N. U+ u// Name: 5 p5 u1 l6 u/ R
// Desc:
* q( x! P/ _! X/ J. g//-----------------------------------------------------------------------------
9 A) j/ j  W. qvoid CMazeServer::OnRemoveConnection( DWORD id )
3 W* m" I% @' f8 Q/ I" Q{$ I  G3 j8 _* @- ]$ p
    m_AddRemoveLock.Enter();</P># J8 W/ t2 U' ~* s; G& |$ u
<P>    // Decrement count of players1 ]4 z0 v6 [8 o9 X; y6 W. r, V  U, R
    m_dwPlayerCount--;</P>9 h$ \4 p* @3 t5 ~& l
<P>    if( m_dwLogLevel &gt; 0 )
3 ^7 o( h/ Q/ h; q( G* l    {# F9 n3 |2 ^+ g8 L# x* F* j
        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );+ h/ `1 Z8 M( W5 z1 T4 m
        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );
; d$ ~& q( ~0 n; }2 A1 m6 ?    }</P>
* h6 H: `/ a/ y) B# h7 L+ y<P>    // Find playerdata for this client( V+ f. Z. A" H5 f  P
    PlayerData* pPlayerData = GetPlayerDataForID( id );. @& Q% Y( g  y. D
    if( pPlayerData != NULL )
$ \. S& a+ s! Z2 x7 l( Z# `( d    {, [7 f0 b/ l) u  |
        // Destroy it2 N/ T+ a+ s, f0 X
        RemovePlayerDataID( pPlayerData );
7 d; p* @- g; Y* i$ L        DestroyPlayerData( pPlayerData );  p% G4 u# O7 R+ j
    }</P>1 F* ~1 n% Z4 f: f
<P>    m_AddRemoveLock.Leave();
4 B6 r- b5 b+ j" W}</P>
8 _6 i1 `/ k; g0 y* p/ Y9 [! m) S
. d! S4 U5 B1 X7 P3 G<P>
7 x0 O1 G. j2 n//-----------------------------------------------------------------------------% Q( m% Z9 @) ?" L9 p
// Name:
! s7 v; F+ R8 D1 t// Desc:
6 L6 E1 c2 Z2 J9 a//-----------------------------------------------------------------------------
1 [( ~- x1 {; T5 q/ ZHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size )
3 L- A! ]6 [, r. e# a{
, F. F$ `. {0 N6 g! X$ r6 Z    BOOL fFoundSize = FALSE;</P>+ E2 j# M, I% b8 W' H+ G3 I- A9 z
<P>    // Increment the number of thread we have in this process.7 e7 H4 e  ~7 {8 i; _8 ^& T( a
    m_csThreadCountLock.Enter();</P>2 E8 K0 ?+ V! A/ Q" r
<P>    //Get the start time of when we entered the message handler.  d% n7 V0 S! Y' F
    FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>5 d: t( T; k0 d. _
<P>    m_wActiveThreadCount++;
3 U8 Q. h& z' O3 h, k    if(m_wActiveThreadCount &gt; m_wMaxThreadCount)! j* I6 j1 ^: M
        m_wMaxThreadCount = m_wActiveThreadCount;7 j& q& w) V+ ]* O( y. g
    7 p. K) r; N. I: C" z
    // Calculate and average./ [7 H5 {% R- D  V5 X2 @3 `9 E% l
    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;$ Z7 x: v* _+ Z' Y
    m_fAvgThreadCount += fdiff/32;5 _/ R# `& m8 ^; B+ C1 h! |
   
: v* S8 d( I% w* A, m$ r    m_csThreadCountLock.Leave();</P>4 o, v6 }+ f8 k! j
<P>2 |5 y/ B7 N, ]
    ClientPacket* pClientPack = (ClientPacket*)pData;+ L* v  |5 {* F& U  u
    switch( pClientPack-&gt;wType )
' G" y. e, i- Z( w1 W    {$ m! ^5 Z3 p3 T# Z1 G$ a0 A
        case PACKETTYPE_CLIENT_POS:
  D  _/ }3 G6 U  K* n9 K' L* Q8 J            
6 E: Q# s" @: n6 V8 y            // Check to see if the packet has a valid size. Including
( x; R; p. T9 Y            // the custom pack size.
; B4 {6 ~7 ]% ?$ ~/ n7 _5 `            if( size &lt; sizeof(ClientPosPacket))1 E* {# F0 m7 ]  T
                fFoundSize = FALSE;* W' N3 o% @, {4 f" C0 a, x8 s) S/ P5 K
            else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))' a+ R- P. h' ^& N! W, _- D( Y
                fFoundSize = FALSE;
8 `# j4 K) N! t& a/ t2 M) p            else( q* ]5 F1 `- i
                fFoundSize = TRUE;</P>
2 |2 X# |4 X: i( s$ x# n, C% g<P>            // If valid sized packet, handle the position.6 n% q9 f, }2 t# ~; U
            if(fFoundSize)7 l3 J! h8 v5 J  s$ p3 d9 g; c( s7 f
                HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );
. V8 y. R6 \8 c, K            else" h. Z0 j$ M+ Q2 T& T
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>9 d) h* m, S& [' g% R, l
<P>            break;</P>  v1 p1 J) F! J& z# X  c# B* n/ I0 V) H: r
<P>        case PACKETTYPE_CLIENT_VERSION:+ z5 F6 B, y4 ?4 ]9 }* u
            if( size == sizeof(ClientVersionPacket) )
% R+ |6 \. G( C4 l4 m5 W                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
3 u  p3 _, O8 M# |5 R0 ^$ v            else5 v, I3 [- Y8 L/ s. M+ l5 U
                m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );/ d; ]/ E3 ]+ y- b; E
            break;</P>. q' V% _3 ]. U4 ], O; @- U
<P>        case PACKETTYPE_SERVER_CONFIG:</P>$ m5 t5 A4 A" g; [* \* [- i
<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>* f2 T# f# W8 h! b# S
<P>            break;7 |0 }; z4 e# k) [2 E3 Q  A9 p
        default:$ O: w- m& k  R8 W
            HandleUnknownPacket( dwFrom, pClientPack, size );
( s% w6 p+ z" ]& A' }' ?            break;
3 |! Z8 h8 N. e& h    }</P>
2 Q6 P, [  Q( y7 v<P>    //If the user wants to hold the thread, Sleep for given amount of time.
  Y- {$ M  A  A    if ( m_dwServerThreadWait &gt; 0 )
2 a  X2 `. I+ J7 R! r9 N- g6 r8 O    {4 ]3 t* o$ A  C/ \& a' O8 Z
        Sleep( m_dwServerThreadWait );$ B8 _7 n- F8 ]1 l7 y
    }
, w8 N2 X0 |4 O; s" f   
+ l4 b+ t) F1 c$ x    // Retrieve thread data for this process.
6 o+ c$ D9 w- L# _7 e7 ^" p    m_csThreadCountLock.Enter();</P>: L' F' b3 U% Z# u1 [+ x
<P>    m_wActiveThreadCount--;</P>& b/ A  K( f( m* q  a# Z- \; S
<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
0 {( ]7 R# z; r9 x6 r    m_fAvgThreadTime += fDiffTime/32;</P>0 c! y6 e; h* I7 ~! C: o
<P>    //Get the Max time in the thread." T; O1 {! }: ~
    if ( fDiffTime &gt; m_fMaxThreadTime )+ z. j. l4 y" ~" _+ a1 H* y
    {2 O" U$ z  x% @1 K! c6 P% d* s
        m_fMaxThreadTime = fDiffTime;) f$ i# P" u, @3 ~4 h
    }</P>
3 L8 J8 i( c6 C  T9 h6 [- B! {! f<P>    m_csThreadCountLock.Leave();</P>$ Z$ c) Z; Z6 b1 p) k1 B1 o; l* A% D
<P>    return S_OK;
0 o; }+ o1 t5 i3 g$ g) a( @}</P>
( J8 A8 f9 E" P0 \* m: f, b0 `- R" O3 j/ n4 r# e  Q# A1 L& `9 C
<P>//-----------------------------------------------------------------------------  }8 P+ g: U* R% C0 T( T( l
// Name: ( T' X% b' b0 t( E( R, V9 q
// Desc: ( Z% {1 U7 b  o* L; i
//-----------------------------------------------------------------------------
, V( g+ z/ |9 f# PBOOL CMazeServer::IsValidPackSize( DWORD dwSize )' X5 \+ L. p% L
{6 K: M$ ~- c, E9 C9 M- B& A
    BOOL fFoundSize = FALSE;
* \5 R  r8 [2 i6 j' Y: f    BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;
6 I$ ^: S) s, k# o$ w    + R9 N8 \  a+ q: F
    // Check through the array of valid pack sizes.
% F+ t" f6 ]8 |5 g$ K5 S$ t    if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])' A" |2 [  e  s8 w$ {1 D/ ^# w3 f
    {7 O; C) E$ Z- R& l" ?
        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)
7 P8 y( |- L' i: u7 @; V# ?        {; E  m. X) y" f  d8 f, e7 \" Q
            if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])& s6 g: a; {" p' m1 V) Z5 v% x
            {
4 }+ H0 j! \, u0 R                // Found valid size in the array.
6 E  C, |: f( S: n6 q5 ?                fFoundSize = TRUE;
* T" d3 o5 e7 n' X9 a' ?                break;
6 s) K1 G6 |9 X: P# `7 U4 J0 ^            }
; U( p- A" D9 r3 e1 s            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.0 _4 O1 S) Y! i$ j( j$ x
        }; C& d3 Z! n0 [* y! o& t0 d
    }" y  A$ E# @# {3 X7 ^* h
    else
) f: M" K: X0 \/ n3 R0 `7 [    {4 U! o6 m% \7 N$ y6 C9 i& y
        fFoundSize = TRUE;
4 j- u4 P8 p. C6 p0 V: \    }</P>4 S# P. O/ {! J6 ?
<P>    return fFoundSize;
' |' U. r2 u8 i+ O}</P>, E! Y! k) |# y5 k* W# `8 l
<P>/ n# J& [- B; X- ?, F
//-----------------------------------------------------------------------------
7 m2 f; C) p* Z! o3 W" v1 u// Name: ! ]1 j+ [( h/ ^( r% q. P
// Desc:
% c$ \# A* d; O0 @2 X* K//-----------------------------------------------------------------------------
* F+ U' F0 X# \8 }7 Y- Uvoid CMazeServer::OnSessionLost( DWORD dwReason )
! B' p6 K2 M. d5 o$ \{8 N- m2 @! z1 j! G4 u# i6 o' S0 t9 A
    ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );: l! p+ a: Z3 T/ w$ I1 {
}</P>
' X" O* B% s2 G( \9 W  K) ^9 ~3 h0 H. ?9 ?8 g- K
<P>
, r* @9 v5 u; E& n6 U7 }//-----------------------------------------------------------------------------
5 C& p: J6 }" H9 T// Name:
8 k0 I& \+ S, U) L, a* |// Desc:
( ?+ ^  B+ j! f8 }8 V2 b- y//-----------------------------------------------------------------------------( I; |2 M: ^. U" l  m5 o" \
PlayerData* CMazeServer::CreatePlayerData()
; o/ A6 D1 ^1 }' `& l2 ~1 N" z8 Z{
# u5 [  Z! M7 Y0 K3 N    m_PlayerDataListLock.Enter();</P>. l) a) P+ x0 q0 Q6 k3 S$ x
<P>    // Grab first free player in the list
; L/ I& D  X9 M6 L1 h  Y    PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>0 w% v! a- ~% `: O
<P>    if( pPlayerData )
9 _3 }6 o( B3 Z* v# K: z    {
3 k$ I$ |& w. n# ?$ L        LockPlayerData( pPlayerData );</P>
% ?+ x7 }  H# U* g; p2 O7 Q# Q0 @<P>        // Got one, so remove it from the free list
. N6 ~) D/ F: E' @        if( pPlayerData-&gt;pPrevious )! r& \( @( d  |2 \1 S- `
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
4 V6 q9 V3 _, q* I. [# u2 ~# a        if( pPlayerData-&gt;pNext )
: \3 S, e& `/ j6 X            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
- A4 i3 J8 I3 O6 G; j5 T6 N        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>" C% j& b# x9 H4 P5 e( F
<P>        // Add it to the active list( `/ {. {6 J/ ?( o/ C3 R
        if( m_pFirstActivePlayerData )
* l5 P  C5 e* H            m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;
) i* I# x3 T; y) g" S0 s5 |3 k        pPlayerData-&gt;pNext = m_pFirstActivePlayerData;+ Y* ]7 M4 P/ |: A
        pPlayerData-&gt;pPrevious = NULL;+ `$ |+ w, T' a6 Y
        m_pFirstActivePlayerData = pPlayerData;</P># `8 P) D" q- |" ?
<P>        // Update count of players' w9 R2 T6 S) K# r8 `8 i6 R5 b
        m_dwActivePlayerDataCount++;</P>
1 O! R7 g% k4 g$ Y$ p<P>        // Generate the ID for this player0 Z; J; g) I) Q
        m_dwPlayerDataUniqueValue++;) S+ [* O4 a6 w+ _. r
        pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
. n" M" m7 J( P  k<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;
+ A" C/ n1 `+ c( N9 j        pPlayerData-&gt;NetID = 0;
: t7 M9 T" X' W        pPlayerData-&gt;dwNumNearbyPlayers = 0;</P>
* J" w7 v" u! G& R! ?& R1 P<P>        // Insert into the "off-map" cell
/ {$ y9 N5 q( r* S7 S2 S        pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;+ ~, }' L; J( G% i7 Z! o# v
        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;% p& x( [# ]  a3 M
        m_OffMapLock.Enter();
% g8 J. b3 K+ L* d$ C6 _        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;
  \* F0 Z1 S. ]( k: E5 X        m_OffMapCell.pFirstPlayerData = pPlayerData;
' f& Y2 T6 I7 ]# n6 v* E0 p  ^        m_OffMapLock.Leave();</P>
/ U9 g" n& Z5 M" o2 ~<P>        // Mark as active/ G9 E+ x. ?* Z3 ]) p+ ^
        pPlayerData-&gt;bActive = TRUE;</P># d; ]2 k! ?; N5 k2 a0 u
<P>        UnlockPlayerData( pPlayerData );& S; n& Z9 f! f- Q0 O
    }</P>! P2 V: l% J; k4 Q( r/ @; W
<P>    m_PlayerDataListLock.Leave();</P>9 t& l- B, R$ ^8 C9 {
<P>    return pPlayerData;  p' s  Q; P# J% `; s" S, F
}</P>" @; }. `( L# R8 r( M) D& S0 Y
4 n4 ?4 b7 o- X; c- D) H* A
<P>* U  \2 s+ S! M
//-----------------------------------------------------------------------------$ }4 x/ ^3 X/ M" F8 s
// Name: . U2 u! s' p3 b5 _5 @5 ?
// Desc:
) _4 Y( [: o1 {; y! V  u7 r//-----------------------------------------------------------------------------1 N' D9 p. K/ D
void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )2 |$ _) C0 Z# x' J# P4 n
{
+ S! P% ~5 a' Y4 R9 w3 S1 R+ q4 K    m_PlayerDataListLock.Enter();3 v5 K& ~0 N/ x1 d
    LockPlayerData( pPlayerData );</P>, ], h, l* [4 C0 w
<P>    // Remove the player from its cell$ R3 Q6 D! S" p0 |: P
    RemovePlayerDataFromCell( pPlayerData );</P>
6 L( N1 j5 E5 ]& m% S<P>    // Mark as inactive/ W1 N( s' X/ v# h
    pPlayerData-&gt;bActive = FALSE;</P>
+ o- W& h# M0 u<P>    // Remove player from active list( o* {# V1 D! j* z$ k  J
    if( pPlayerData-&gt;pPrevious )
% w7 ^6 {! ?7 W; t& `) }        pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;' D4 ^4 ?! m3 h2 M) t( @6 Y1 M2 D
    if( pPlayerData-&gt;pNext )
# q+ m/ C- P% D" u        pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>
! R! Y: O# J* z! G) ?<P>    if( m_pFirstActivePlayerData == pPlayerData )" C5 D, _/ N# D( f( ]7 B4 K
        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>
, z/ O0 {! r/ N( _. t<P>    // Add it to the free list
1 ~% E4 v2 @  h) G# m    if( m_pFirstFreePlayerData )
( K5 p- ^1 \' U9 j        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
3 j1 u0 D4 W% F! h, X    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;9 N$ A0 G" ?. _: E
    pPlayerData-&gt;pPrevious = NULL;
- G* b' n3 u& }  o' _    m_pFirstFreePlayerData = pPlayerData;</P>: a& ~* J3 ?; K/ Q# y! ]$ N
<P>    // Update count of players4 `# I/ {8 D0 j+ }4 A
    m_dwActivePlayerDataCount--;</P>
( e- O( z5 S2 T* Z% |  J<P>    UnlockPlayerData( pPlayerData );% j9 u- h7 w. d9 f* k# t
    m_PlayerDataListLock.Leave();  V# ?. V/ c$ x" O! a6 R4 c; i/ P
}</P>
' I* i/ d1 F8 i. h& X3 H/ A- L: K8 O" U- A3 n+ w
<P>
8 v* v  u  y; l6 N" B//-----------------------------------------------------------------------------& q' J7 Y! |% n
// Name:
# _# a$ n2 v% G0 A0 S2 r1 Z// Desc: , k0 E: q7 A8 I" P# ]
//-----------------------------------------------------------------------------! b+ P) t: X: Q& r
void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData ). b, u+ d& u3 Y0 z$ x6 R; v
{& C# J% N# y  A& V0 D9 ~; H, N
    // Lock the player
. y4 b$ O2 u% R2 j1 R# ^& U3 \    LockPlayerData( pPlayerData );</P>
) e$ n) c9 K/ j1 e* J  N$ g6 G4 r<P>    // Lock the cell the player is in
* \; G  j3 d' K    ServerCell* pCell;
" s* O7 V, H: j4 r    if( pPlayerData-&gt;wCellX == 0xffff )& G0 K* S* @3 a6 v, J+ Q2 X
    {
0 y2 T2 @! I, T( W7 b! @9 Q        m_OffMapLock.Enter();
/ Z4 D" z$ L0 K% _( F7 @' s        pCell = &amp;m_OffMapCell;7 ^) I' H% A( \6 Y" s/ t/ A' O
    }  E0 E+ G8 D- n; `7 y: w" Y7 q9 @0 K, x
    else( Z; h2 W( }$ x5 k) Y6 c5 C) ^4 M
    {
3 i4 o: U) m* p        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
6 F* k* c( M0 o9 j$ H        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];
; h+ F( l1 B2 U) ]    }</P>
& u. Q" R3 D" @  u/ P. }<P>    // Remove it from the cell
$ ^4 a" ~+ V" q% C    PlayerData* pPt = pCell-&gt;pFirstPlayerData;
" `( X5 ]  C+ L7 q5 W, Q( \: q- a/ m    PlayerData* pPrev = NULL;
. T0 O9 {3 m% u5 n2 J    while ( pPt ), @4 o4 B, A) l; C  }( U
    {1 Q& r9 J, @3 t
        if( pPt == pPlayerData ); O- X/ ?- V8 |/ m% P
        {
/ z1 ]# t* W' x" x8 ?            if( pPrev )
0 w8 B9 X# M8 r4 P9 w& ]$ Y$ a                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;
: B" F9 P6 g" I6 }$ `( v! K2 j            else5 g8 y7 N1 a  V( ?" k
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>
$ Q+ T4 k) X; k<P>            pPlayerData-&gt;pNextInCell = NULL;; E) a8 c& Q, i8 ?( F1 u
            break;
( ^9 J* y5 w1 M! n0 a6 |. _/ R        }! y8 i/ X4 O3 M* x8 A8 c  Y
        pPrev = pPt;/ d0 R1 M5 ?6 }* D, w
        pPt = pPt-&gt;pNextInCell;) D0 T5 {3 O3 ]% h* }' h3 i+ t
    }</P>  S: z% ]2 l1 n2 Y
<P>    // Unlock the cell
, c/ ?8 q- ?, Q  v+ t, v    if( pPlayerData-&gt;wCellX == 0xffff )! L+ J% f) {/ w: X6 ]+ X
        m_OffMapLock.Leave();
0 w* `- ~  t+ `- s( b8 ]- f    else: E& \8 _+ D; H5 w
        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>+ |/ f: p( h. ^. O  Z
<P>    // Unlock the player
2 i2 U! Y1 ]2 @- U, `, A$ ?- w    UnlockPlayerData( pPlayerData );4 G; V5 s" i" U) r9 g
}</P>1 t" E% z7 }% D' J

5 X, Q8 P# K( m. ~( O( N0 ?0 l<P>. q$ U2 ]. n. q) w
//-----------------------------------------------------------------------------
0 k% W. u/ m0 E5 \: d* |// Name: 3 F! Z& N+ \( z( M( _% p; S) l5 L4 S
// Desc: ; g6 _: i5 o, \1 W! g0 r
//-----------------------------------------------------------------------------
3 z7 V* n  [9 U7 w+ ~  x5 S, F2 Cvoid CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData ), ^. ~1 y- I( `9 p) g- w+ ^
{
+ }/ j) \" \! E) y    ServerCell* pCell = GetCell( pPlayerData );
  b  A5 U1 Q+ K' f    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;6 o, n6 j3 t/ _! K& A
    PlayerData* pPrev = NULL;
+ J7 u+ Y5 _8 z, N% a2 S    while ( pPt )
7 O1 i" j, c8 x& T6 K    {
  t1 w' C, z/ v        if( pPt == pPlayerData )" H2 I' i( ]" X1 L+ r1 U
        {
0 C% s( g; }, _3 D3 G            if( pPrev )" G- e" l& A. l; F$ U. P
                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;, H9 a2 V. D$ Z, y* q
            else, O. ]" O8 x( o: b) \3 y8 z* W$ q
                pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
9 `" E2 n* Y( V1 `1 y" C6 o            pPlayerData-&gt;pNextInCell = NULL;& Y) s" f( Z' q4 Y
            break;
$ F# Q  ~% U# {3 Y        }
1 Y0 d3 l8 N1 r( o6 M, `. ]        pPrev = pPt;
1 j: a2 s0 Z1 K8 ~% S) G        pPt = pPt-&gt;pNextInCell;
& ]' J* e: ]+ F$ p: \) t" V    }5 z$ i: f" c+ V8 A. e1 P5 k
}</P>
# G# x0 n* E' L$ t& R, a" X# I2 [( x
<P>7 A  a4 f& j) Z# d4 e! v+ R
//-----------------------------------------------------------------------------/ j) _. b  h. G# Q& D4 E
// Name:
; y9 o2 a3 \) \4 g; r$ v// Desc: ) k0 `) Z+ p$ x$ q. E' a' y; j' [
//-----------------------------------------------------------------------------
$ ~: J: O; Y' _  u' X7 Y9 R1 Qvoid CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
" z: K1 I& f; `. q- ~0 N{5 H- _4 K* e! L: J: Z
    ServerCell* pCell   = GetCell( pPlayerData );" B% t& i3 G2 E/ a* H0 h! a
    pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
1 i2 Q+ D+ t+ K) }( h    pCell-&gt;pFirstPlayerData = pPlayerData;; Z: J8 U) R) d
}</P>
+ x1 H/ u% N5 o# n5 L0 T. i; @& e3 q; F; b
<P>
" {/ h, @) r1 H4 u3 h( V//-----------------------------------------------------------------------------& w0 z! y) K- e: m" Z: j
// Name:
' m; i. k: P6 v3 z% T) ]- H" G! Y// Desc: : j; E/ L9 u5 v0 v& B% f5 ?
//-----------------------------------------------------------------------------# z2 h% s4 {) O5 m
void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack ), o- z7 c2 f/ R& p, ]  n
{
% o8 A7 T1 C+ _* z    // Grab player for this client and lock it# x* T, G+ n7 |' @( C
    PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
' _7 [/ q; `( x* l+ I8 }    if( pFromPlayer == NULL )
$ W6 |; {* G( n    {
" B& }; K' k( Y# O( o        if( m_dwLogLevel &gt; 1 )
1 q0 V0 _; |* T% K4 ~            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );2 Z. G/ j5 i0 ]; L1 ~
        return;
' p/ A: X' G( a/ l2 j9 z' @    }</P>% ]6 e4 K+ g: K, I
<P>    LockPlayerData( pFromPlayer );</P>$ v2 w6 w8 o( L
<P>    if( FALSE == pFromPlayer-&gt;bAllow )% _  D2 L0 ~7 x, N5 G( F8 @  R
    {" w% M! K- u* G7 \; b- i/ g
        if( m_dwLogLevel &gt; 0 )0 s9 T, W3 R8 ^2 n2 y9 P
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>' a$ z" J- n! X: J
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );& r5 Q3 A9 Y! g& T, ^& A$ P' y7 r
        UnlockPlayerData( pFromPlayer );
  b8 C3 X2 v2 j* u& R        return;
5 b4 l0 ]7 _! ~! s    }</P>
: z; |2 c5 {0 M8 \: z<P>    // Compute the cell the player should be in now
: h3 @) f# u6 w9 P% Q    DWORD newcellx = int(pClientPosPack-&gt;fX);
( w5 Z  r; w. A    DWORD newcelly = int(pClientPosPack-&gt;fY);: R" [* q  R1 }- {8 |: h: ^
    DWORD oldcellx = pFromPlayer-&gt;wCellX;: s6 A+ v- \4 \# V& C2 T) ?: D
    DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>9 v  E0 d% h7 E% ~
<P>    // Have we moved cell?
( i! ?2 m0 h/ D& o6 Q    if( newcellx != oldcellx || newcelly != oldcelly )9 C1 C4 Q6 ^% A! t8 c; K3 p
    {8 g$ S1 o7 U( u$ J- J# b
        // Yes, so lock the pair of cells in question
; L8 t8 h' n& ^6 H- n& L        LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
: {  J) M; ]" w1 S<P>        // Remove from old cell and add to new cell+ H, {( u8 b( ]
        UnsafeRemovePlayerDataFromCell( pFromPlayer );
1 [" a& z0 y5 U4 M, W        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);9 ~$ T+ D: J' q3 P& l; ]1 H7 q
        UnsafeAddPlayerDataToCell( pFromPlayer );</P>
9 O. v8 A* b0 U2 ?. n<P>        // Unlock cells
$ @4 n( c4 @* ~3 z+ x1 U( x% Q        UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );0 [3 @( F/ {: t8 ^) X# N+ h
    }</P>7 g/ m% c# C, Z! \6 `$ R
<P>    // Update player position$ N4 L2 D7 T2 _- k3 H* ]
    pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;( G9 a' I* M7 a8 Y- \0 E0 O
    pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;- P, h% A/ X% O) k
    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>, n4 h5 ~: E9 i& c
<P>    // Allocate space to build the reply packet, and fill in header 1 A6 k1 ]8 V8 t" j
    DWORD dwAllocSize;
# e0 o8 R& I6 e1 z9 e: w; z0 \    ServerAckPacket* pSvrAckPack = NULL;</P>
- G8 z0 F; [% @: g4 F<P>    // Begin by allocating a buffer sized according to) {3 C* k2 P" Z
    // the current number of nearby players + 4.  This will give 8 E4 H& Q" j# a1 C
    // a little room for more players to come 'near' without resize: p1 @* e4 @/ w, a9 a$ e9 v1 Y
    // the buffer." {$ Y9 M& m3 B2 L* {: b
    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
) s# e4 j6 x/ G! s/ T, F<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);! Q/ h3 ?) r# f7 ~+ z
    pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );  N- [. o2 J* R! a
    if( NULL == pSvrAckPack )- j% v: o, K& a% @% Z$ F
    {& w9 P7 T# E% [' M9 f/ a: @
        // Out of mem.  Cleanup and return" B# @' l6 t% S
        UnlockPlayerData( pFromPlayer );: X; g  B2 ]2 `$ t: b' X/ ~# j! M
        return;       6 [6 k; n# ?1 q* b: Y. U
    }; Y' ?  i% T8 O" q5 k
    ZeroMemory( pSvrAckPack, dwAllocSize );</P>
9 Z, M6 ^0 y4 ^; ]<P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
2 s) r( C7 @$ j0 ]- l: ?    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;
3 a9 v+ }1 \" P+ Z" M2 k    PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>
8 x( r/ a' I! S7 E<P>    // Compute range of cells we're going to scan for players to send
, g+ V6 k) G& S) m& `5 G' V    DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;
0 H9 W0 J5 N) {. m* I; @( O    DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;  H2 n) P5 b6 N3 }5 a2 y0 R
    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;- I1 X. W. b( y! F8 O3 F( t9 _
    DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
& a) K/ z. W' o0 c5 A; _/ K( M<P>    // Lock that range of cells
5 Q! a% x3 y, w9 S" R( }0 I    LockRange( minx, miny, maxx, maxy );</P>
! ?% w6 h- d+ E( I9 f& G<P>    // Scan through the cells, tagging player data onto the end of
8 Q( ^, K, s8 G) R& S3 A& A: e# s    // our pSvrAckPacket until we run out of room8 s$ d$ w; B4 r  n! a, @$ P
    for( DWORD y = miny; y &lt;= maxy; y++ ), H% ]4 m9 o! J2 ?% A8 v
    {
0 n/ k' w- d5 m% I2 x) e( l; n8 x        for( DWORD x = minx; x &lt;= maxx; x++ )
3 c/ V  t6 |1 T. |. n; w; u1 `        {
1 d% J- b7 p9 T) Z6 B. K# y+ B            PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;. t/ X3 v2 j& [. H  y8 u  \
            while ( pCurPlayerData )0 |& u- G, Q3 h, c% ]& l
            {
) T* _- r$ q7 P0 {                if( pCurPlayerData != pFromPlayer )
& a  R' H! `2 p6 [                {& W' q) C4 ?; m
                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )* l* o/ }1 f4 {* t
                    {
, h( Q$ h8 p- J  k                        // Make sure pChunk is where we think it is
9 D; \( K; T6 L, u9 p' G3 \                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>
1 c# D$ Y8 q% Y4 Y/ [) ?% |: K9 O<P>                        // There are more than just 4 new nearby players, so resize the
. p; j& x; ^' o4 P/ h                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
" b% H2 S8 O8 b+ c* }# E) l& R# X                        dwMaxPlayerStatePackets += 16;/ y% l; n' y# u
                        dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);& x2 w( {& Q8 `# }. a
                        ServerAckPacket* pNewSvrAckPack = NULL;2 N: F% x5 \: P2 O2 M- ?9 E
                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );4 j2 [" }9 d9 j+ o7 [/ F* ?
                        if( NULL == pNewSvrAckPack )
/ w% c3 ]5 f2 b2 R7 i2 o3 J& v& Y                        {
& d7 N$ S6 h9 t, ?5 t! o                            // Out of mem.  Cleanup and return) X/ g4 ^2 x/ K9 [+ M7 ~2 d1 B
                            free( pSvrAckPack );* @. |1 r. U; i0 Y% i2 B) W
                            UnlockRange( minx, miny, maxx, maxy );
2 K& [0 o1 h% Z3 g6 T$ `" C                            UnlockPlayerData( pFromPlayer );. k% `6 R+ _5 s2 c
                            return;       ) n$ G% q7 y; B+ h3 j( [
                        }</P>4 j6 O5 y; H( ^0 E- ~: H' u
<P>                        pSvrAckPack = pNewSvrAckPack;2 f" P/ N; ^( h2 p
                        pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>- ^7 c( f* f& d
<P>                        // Make sure pChunk is still where its supposed to be
  n! G; e, W" D% m                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );
7 i7 i' [$ }; x, P                    }</P>% K) X. L" G% O* _# P! P1 O
<P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
1 a1 D; P& ~3 ]                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;
' C+ t1 c8 m, D3 w. D5 d                    pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;% Y* A$ Q* K2 E& `& x
                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;# S5 R# }3 j% N2 h7 K
                    pChunk++;
  @8 f7 E- V9 a$ k0 e) l% a  o: W                    pSvrAckPack-&gt;wPlayerStatePacketCount++;1 V5 b3 |0 E, ]2 q. P
                }
, w# t) c2 q& T, z0 t3 _3 n9 d                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;" A2 F# H% Y: U
            }
* ?* z  \% i' ^1 p3 |; _6 w        }5 u% _" G1 d: f
    }</P>
* s" h- F0 T5 X  R/ i, t9 U<P>    // Update the dwNumNearbyPlayers for this player
% ^5 A% a+ [* r) N0 O    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>
$ I- _3 p( }  y% b# o" X<P>    // Unlock range of cells
& m8 t! K- L. I. z" I8 E/ z' b    UnlockRange( minx, miny, maxx, maxy );</P>
" U# E1 E. q: S% j; J. t- g9 p2 o3 o<P>    if( m_dwLogLevel &gt; 2 )
* W$ _1 e% `" Q3 s( V6 h    {
9 \  V; J0 ]8 |0 F0 k0 O        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
" a  R) d- W0 T- [: y    }% v9 k- X8 ~# b0 c
    else if( m_dwLogLevel == 2 )
! Y  T' e# z3 A$ ^    {- T; J( v3 V- r1 S2 ^  H
        FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );5 O  @2 C9 L# s! Z! v
        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )
9 B$ h6 [3 l) t: I+ h* H        {8 D! x. x( ^/ ?+ }; r# Z1 G% Y
            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );
7 `* G4 Y, }7 Z            pFromPlayer-&gt;fLastDisplayTime = fTime;
1 m$ R; Y; `9 w. }        }( \, x  u6 `* |
    }</P>
: E) W+ Q' {# e) n<P>    // Unlock the playerdata: k2 E5 r6 {$ J6 g% L
    UnlockPlayerData( pFromPlayer );</P>+ q4 F+ m- o6 }9 l6 p) q; k
<P>    // Send acknowledgement back to client, including list of nearby players
% Q! H# @8 B/ _6 d  ?+ G$ M    DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));
, t2 d% R" O6 ]4 ^* G; r
' v/ L3 D1 L9 r2 V    // Pack the buffer with dummy data.% R- ], @( i  u* b3 Z
    if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0)
0 l6 i9 m& c/ G1 s; u    {/ E- L7 j& s% H0 d; {+ x
        DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
4 h( D1 \. v( p8 H  P- N        VOID*   pTempBuffer = 0;</P>
/ q% N! ~4 u4 I' q: f# w<P>        pTempBuffer = malloc(dwBufferSize);
, Z  W+ V2 _( j1 z1 L* {, E7 s        if( NULL == pTempBuffer ). C4 M2 V, }6 C% ]8 ?+ ]
        {* Z% k5 J# _+ @, Q# S& N! y
            //Out of memory
9 Z1 P' R2 Q3 s            DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );& A  \* m3 Y4 L6 M: ^4 w7 A$ _
            free( pSvrAckPack );* D& N% o. m- ^" D; P! O8 r
            return;3 W# ]& e" a* a1 H
        }</P>4 O5 S) T+ _$ o: w) z: z' d
<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
0 G+ k, k: q- i! E& H/ G6 R        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
! O5 q3 e. y! l- Z0 R. b<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );! {; b1 I, v# w2 Z8 L& }- z6 Q' C! ~* V
    % G& B4 ]$ P. w' u* Q
        free(pTempBuffer);
, b% x; n* N8 H- V: ?    }   
' h, u/ G5 Q/ O. Y- v    else
% _& g( g( C) T% |4 R9 R, U! N1 M    {" c5 n4 T7 l* i  z! f% M
        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );4 K, t$ {% z  x& h7 c
    }</P>& |9 S% r: ]" n$ ?( D) c  e
<P>    free( pSvrAckPack );</P>
: t* b5 \5 |" m, q* j<P>}</P>
/ u( a$ L2 v! j+ t% |
* @# N+ O3 g4 E$ Q+ m, W& P0 v: C- N<P>
) V# v2 {: Q- y6 s3 D. x$ o9 n//-----------------------------------------------------------------------------  i8 R2 ?0 O# t; ^
// Name:
4 n3 i; o6 s- a// Desc: 1 J% q$ l! d3 k; i
//-----------------------------------------------------------------------------
' a4 I; s/ C1 c  ^6 n! \! kvoid CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )) Q; l9 c0 O' a4 g8 V* l: A% y* f6 _
{
+ A$ T: P% m* u/ `2 v    // Grab playerdata for this client and lock it
1 F3 i/ s& b- x3 [    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
3 v$ t2 E+ ^2 z! P& Z    if( pPlayerData == NULL )0 h& R6 y. a7 I+ i) z6 d
        return;
- d5 L( }* e9 _1 R. u    LockPlayerData( pPlayerData );</P>: q+ ]8 |4 p9 T# ]4 l
<P>    // Record the version number $ y5 a/ p; K. s: T" K
    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>
, a$ y! t# Y# v* c; |$ a' D. G+ X" ~<P>    if( m_bLocalLoopback )
  Z2 }/ p# T: b        pPlayerData-&gt;bAllow = TRUE;, C, U! x$ a1 r# X
    else
" D. N( c, g5 W. ?6 g: {' q        pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
4 E3 F2 S% F. J# K  {<P>    if( m_dwLogLevel &gt; 0 )+ a* U; W3 J; K9 f8 Y4 p" u0 |
        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>
) M, f/ |$ c8 Z6 x( q( Z! |<P>    if( FALSE == pPlayerData-&gt;bAllow )
* y( {& Y; R* U. {' M4 p" |8 y1 T    {
0 g% b3 p* N0 {0 e4 I4 J        if( m_dwLogLevel &gt; 0 )
$ v9 z" {# F% Y0 l; {# C$ N            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>+ H, \/ E8 V1 E/ S
<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
1 T7 G* J: q/ ]0 U# k        UnlockPlayerData( pPlayerData );
/ f( J) O. [" v3 D: }0 o9 L        return;& g& n5 a+ z* ^0 a# C$ P
    }</P>
+ l  ^6 Y+ [! C+ o, b<P>    // Unlock the playerdata0 y) M' O' O7 z" o% d, J
    UnlockPlayerData( pPlayerData );</P>
. j" R6 Z: T3 M7 C<P>    // Send acknowledgement to client that the client was either accepted or rejected
7 t3 m2 {4 [# S5 W" L9 b7 {# R    ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
1 [2 f6 g! O' ~    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );
3 B" ?) @7 C, C4 g) [9 k% K- n}</P>
5 C: h3 P" a) |( P% J7 G4 D# a
; [9 d9 E7 i4 g<P>
& ~6 M) k4 F! m! e  [//-----------------------------------------------------------------------------
: O0 e& X' y# Y* b+ p% s// Name: 2 |. B1 b0 o7 ^4 l; K% E
// Desc: , O" M- L" n; c% X. H
//-----------------------------------------------------------------------------  }8 k2 c: l3 B- P. r9 R
BOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )( Z& w! k5 G+ F. a0 S& }3 V6 V+ c  p
{
  ?' q/ v* R3 n/ z0 m  w    switch( dwClientVersion )
8 s: |" K; O  v. F& ]    {) O9 I$ I; `8 `8 Q% J: A
        case 107: // only v107 is supported( _+ F: L: E1 M$ K: ~' }
            return TRUE;
$ _  _% B( E9 T        default:
; H! F; ^9 |0 x% C! y$ k0 m            return FALSE;' l! Z$ v* B1 p- o% W
    }! q* n( t0 Y" V. S# ?
}</P>
; A/ ]5 u4 h  J- Q0 G
# B3 B, Y! d. v8 E  s<P>
' c9 V4 X, e$ P$ \9 h. h5 |//-----------------------------------------------------------------------------
  T& Y1 g0 P2 u) ^4 F# G8 q+ ]// Name: 2 y- k; n3 V+ Y8 e) ?0 ]
// Desc: ) f! F+ h  c1 ^9 S3 j2 P' A
//-----------------------------------------------------------------------------
  d! E) w, k+ B4 c0 z3 \; H# lvoid CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )" O# z/ K2 C& ?: w( s* u
{( t/ X/ _5 Z: g2 o/ e' I; ?
    if( m_dwLogLevel &gt; 1 )
) J- F) s+ p6 Y1 P) T. o* q        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
% A; }" a+ o6 t' d7 W- U9 m( b<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );1 V+ v# q8 i  b5 j. x
}</P>
. I0 a7 ]: Q: s* R
/ h" \9 {$ l8 s, M; ]0 {* U' Q- G<P>1 l7 U: f4 _; l% U8 f
//-----------------------------------------------------------------------------
( p9 h7 r9 u9 j$ Z) F& f7 }; m$ P// Name:
$ R6 d& f2 Z7 V% `! c+ f// Desc: 2 D. _+ k, N5 J# f+ d* R
//-----------------------------------------------------------------------------
% X. K4 R6 [* c6 ]: H# T) n  v( |: LDWORD   CMazeServer::IDHash( DWORD id )3 ?# b7 M( Z9 t* }6 y
{
0 B- F* H% N4 }* z3 d# h4 a9 B* a    DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);7 t  G2 v( A! ]6 h/ P+ S, E
    return hash;# s& N  t' O! i+ T
}</P>
' @! s( V4 i" V' b) }4 [( W
4 P1 H" E5 ^: }, {: U2 ~<P>( Z6 U  O, ]$ i. K; C  ]
//-----------------------------------------------------------------------------% F0 L. h6 g$ ~: ?& T8 f
// Name: # p$ \! [/ `2 ]/ l) @
// Desc: " Q% x- z4 v/ K  [/ h
//-----------------------------------------------------------------------------
* x% j! P, A' |4 o4 F% Y8 yvoid CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData )
# x* e: ~1 Y7 f; S$ ]+ s{0 [- m6 i3 k6 h! d6 ?. h. Y
    // Hash the ID to a bucket number# P" ?0 X1 @  E) q' }7 l
    DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>- w! x$ b0 l% y; o
<P>    // Lock that hash bucket
8 P3 N/ F* N0 S, Z    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
, ]1 Y' y8 W7 d8 F& p  T6 w    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>/ ^9 ~) I& b/ L+ L* D/ p
<P>    // Loop though players in bucket until we find the right one) J1 K  g- o- H  N  S8 \9 q
    PlayerData* pPt = m_pstIDHashBucket[bucket];
, r5 N. S7 M5 B0 U    PlayerData* pPrev = NULL;9 ^( @3 J- H. H' i" B$ m# u
    while( pPt )
- m; |$ p* b0 F  i    {
/ J2 e) U" H8 O9 a, y8 o* [  y        if( pPt == pPlayerData )/ U/ g4 Q3 I* S/ G7 _- F
            break;
' A5 \$ ?, H. w- D        pPrev = pPt;  J- Y5 R4 o* J  l
        pPt = pPt-&gt;pNextInIDHashBucket;
6 l) o" Q1 ?/ P) `) G1 Z1 j4 ]    }</P>
! X4 V$ c# o2 X<P>    if( pPt )1 A# R% b6 S7 Y3 c
    {) y1 U/ h5 I! z' ^% M: E* |) K
        if( pPrev ); q7 l! n* K1 A$ f0 [* }; F
            pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;( E$ u1 G1 {% w( _0 M" d( R
        else
, K) i9 w; [+ A$ Z/ s            m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
: T4 S3 k$ }6 |* e" I        pPt-&gt;pNextInIDHashBucket = NULL;
# I" j+ _7 L# a6 G# @6 P& N    }</P>; C5 r- u" n% U1 j
<P>    // Unlock the hash bucket' [. @. N  Q2 O: `9 c
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();( ~' j4 v: u) {/ d5 v: K
}</P>
; x( B, |5 `# R, v1 c9 i0 f: ^4 z+ |7 Y$ L+ J6 b9 S" g  G
<P>& U2 w& k* k2 `: W0 X0 a: y
//-----------------------------------------------------------------------------
* `) U" h2 Q# e' N; t2 d// Name: : l# y6 a2 U! N' c6 ~
// Desc: 7 R/ [1 {& Q" A$ W
//-----------------------------------------------------------------------------
; i0 c2 P, t2 T$ t) m# M/ N+ kvoid CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )5 K; k: k& ^! \7 @, q
{
% j- K% A, [, Z5 o" l" i& h* h    // Make sure this player isn't added twice to the m_pstIDHashBucket[]" M; s" D. d; [% h- K8 ]+ Z. ]+ G; G
    // otherwise there will be a circular reference
- c7 ]/ f4 r& f0 z) y; b# S5 }    PlayerData* pSearch = GetPlayerDataForID( id );7 r* G9 l9 p' H- r1 I" C9 H5 j1 i5 @
    if( pSearch != NULL ), j! w% o% M& }- t5 R; M
        return;</P>7 u+ l+ M! C' X" E
<P>    // Hash the ID to a bucket number
( d2 W. a/ s3 u$ ^5 h" l    DWORD   bucket = IDHash( id );</P>
2 \/ w4 W0 d% k6 L9 Z' O  a3 ]<P>    // Lock that hash bucket) c) m. Q- r1 H9 X7 S& k& n0 o4 Z7 h
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
# o& A! r8 ^" b2 e: e# Z- \    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
' G) `* k0 t5 T2 W- ]5 Q4 d  E<P>    // Add player onto hash bucket chain  B/ z  U* {4 H6 q5 @
    pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];, G$ T. R' I# Y& ?
    m_pstIDHashBucket[bucket] = pPlayerData;</P>
$ `7 g; ]/ [+ U7 S! o! ^<P>    // Store net id in player! C4 u3 f4 g- |  r
    pPlayerData-&gt;NetID = id;</P>
# ?7 p& s) n' p4 P<P>    // Unlock the hash bucket1 n2 ~4 T' M* y6 T; g1 G
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();0 S3 F( h# d* C: D; p- g  U: E' c
}</P>( F) U2 ?3 d, f+ Y: ^  b, J

' L3 @; F+ s! g+ z0 Z, Q6 d<P>
3 Z, [  @7 y1 |' Z//-----------------------------------------------------------------------------
6 M) g; R" V8 g* |7 w; O$ s% z// Name:   h) m& _! \2 B$ o
// Desc: - N7 Z0 I, c0 I+ U! m! \; j" |
//-----------------------------------------------------------------------------
8 z8 f; @- V1 XPlayerData* CMazeServer::GetPlayerDataForID( DWORD id )
# {1 N" V4 b" m! Y+ m  y{
$ q4 `* y, p5 S    // Hash the ID to a bucket number
) J: m/ d, K9 U: t" r    DWORD   bucket = IDHash( id );</P>) X( `) K2 C/ U: L6 E5 F! W
<P>    // Lock that hash bucket9 s3 V* C( v3 z# p
    const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;* V3 g  k4 M% a& e' F
    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>4 B0 ^' R8 u/ X- w2 X( g0 ?2 T
<P>    // Loop though players in bucket until we find the right one# K6 y: @1 B$ T5 _, h$ V% e4 I
    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];- [9 ?7 U8 z$ k
    while ( pPlayerData )
$ s" ]- C; l0 J/ q) x7 w5 R4 ?; T+ m    {
) P' N' U* p, e: T* P        if( pPlayerData-&gt;NetID == id )
. m$ `# s: c% u9 v/ [6 K            break;. i; p5 L. `4 j1 y
        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;3 |- B  v, V2 Q+ o
    }</P>
) {7 s$ Q: w8 |5 O<P>    // Unlock the hash bucket- E0 F% ~/ K" ]: a
    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
/ X" j: F: C; ^" r3 f<P>    // Return the player we found (will be NULL if we couldn't find it)+ o4 ]3 H7 A$ R
    return pPlayerData;
! Y# g  H- E' g}</P>
8 t5 \: c2 G& c3 A$ I4 E) ?+ {5 D; `% F( N$ o6 v
<P>  T4 G7 m5 `+ ?* m
//-----------------------------------------------------------------------------
5 g9 ]! B0 J7 _* q: o4 `3 k// Name:
, F3 f5 v' `9 R: z* C// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner7 e+ k( |8 U7 w$ v1 m5 u
//-----------------------------------------------------------------------------% u/ y. d( Q7 G& K  K
void CMazeServer:isplayNextConnectionInfo(). }0 C; D+ _& `* N* A
{
" A; U+ y- \6 S5 f    if( m_pNet )  O- E3 u1 J7 @; a
    {; {# G  `1 T- O0 b) N! l
        // Find the player that was displayed the longest time ago, and display it.. k# v) y, J4 T9 Z
        FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
* `2 `+ f( s, ], ^- Z3 h1 j        PlayerData* pOldestPlayerData = NULL;8 U/ j1 n$ w0 R  q
        FLOAT fOldestTime = 0.0f;</P>
- u8 @3 ]0 V/ t4 Z  ~: v; \3 d<P>        m_PlayerDataListLock.Enter();</P>1 O, n( V& b/ b. b+ Y% q' G
<P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
% N' ~( v6 y' E6 U        while ( pPlayerData )# {" b9 L8 ^4 b0 e' M8 M
        {
: M) k: \. L* S# `8 k. T            if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime ); u, n: e' T+ i. S
            {! J& c$ j  O9 {. F! u5 p5 ]2 g
                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;* a2 H( S; V( }, u
                pOldestPlayerData = pPlayerData;
$ x$ P0 S1 E4 h& W$ X5 q+ j" I            }</P>
% n0 y9 g3 i9 I+ ~7 `) T<P>            pPlayerData = pPlayerData-&gt;pNext;: P7 W: N8 Q" z8 L9 U* u1 H" v
        }</P>
, r0 C+ r0 h7 S<P>        // Display the player with the oldest CI field, and update its CI field.
, b- g: y% b: C/ y& L' P2 Y        if( pOldestPlayerData )
! f( A# V7 j! v! i; a2 R5 K# L        {
5 i/ ^! G# T* f& U: B( v) K            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
% D$ x6 }4 K# H            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );
. S& V3 r$ k7 D            pOldestPlayerData-&gt;fLastCITime = fCurTime;" D& C8 g" e. M8 ^( Y
        }
5 j) {6 b; A, ^0 D! `) _        else/ n  G% O3 k+ j$ v
        {% u4 f$ |9 l0 f. \# w
            ConsolePrintf( SLINE_LOG, TEXT("No players found") );
2 c4 v9 s$ x' v7 k2 F" U        }</P>
. Q8 K1 h$ J: K: T- z/ _<P>        m_PlayerDataListLock.Leave();/ V0 J' l* j1 u3 g) h' W
    }1 W+ e( L. q5 T! S+ m% C7 \: p
}</P>
5 L, o7 ~3 l, x  f! d8 y( D# e" |$ D* y( n( P# K& F
<P>2 ]- z' Y8 M+ ?8 w* u
//-----------------------------------------------------------------------------& ^' U  {+ {$ q
// Name:
" ~1 K0 Q3 r. P5 I' h9 f7 H( |/ X// Desc:
* T5 r  S9 O" g) \0 E//-----------------------------------------------------------------------------: ~. d) \& c$ B7 {- H: T6 y6 I
void CMazeServer:rintStats()% c5 L" ]; G) z* N# u6 a/ d
{. w7 D2 d5 p" Z% a* L
    ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"), 2 ~3 ?( Q1 m6 d' _( |( W
                                    m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );* ?, f% M( k& d* S( X) @
    ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),4 [  Y& w3 u% ]. m9 {" R
                                    m_fAvgThreadTime, m_fMaxThreadTime );
( f8 h& @( I. K4 ]- {4 g7 {4 p/ [    ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );" ~" O; X: D! v$ q: H
    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
  W  f: ^2 R! A2 B}</P>
; T; x# [: E, t
( ?  k4 k: _4 G' ~  O! S1 b! n; |+ I& Y& j<P>
- l" m6 Z8 W+ s7 J. I& Q//-----------------------------------------------------------------------------5 @, |" F5 p% m; ?
// Name: ! e- x/ O2 i6 l7 n, D: L9 L
// Desc:
. K& o0 C- h! T8 q9 n* S( M//-----------------------------------------------------------------------------
, S  L8 N0 i  j% ~void CMazeServer:isplayConnectionInfo( DWORD dwID )
- {- X! T! L6 W' V% K{
. E- _+ `3 n) c    TCHAR strInfo[5000];
- Q7 L5 J  u) ], ~$ z    TCHAR* strEndOfLine;8 x$ g1 U$ L5 s& D. f
    TCHAR* strStartOfLine;</P>
7 v% ~% x, I1 n<P>    // Query the IOutboudNet for info about the connection to this user1 b% T% {+ O9 A% R/ C1 x% r
    m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>
8 Q  |: p3 N# ?9 [1 [; k<P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );
  H' y* V. ]  A    ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>' v9 o  S, a! m+ A5 s/ b
<P>    // Display each line seperately
) p6 {8 G6 O# L+ R1 B: z    strStartOfLine = strInfo;0 }# N/ P8 e$ |/ X7 G+ x
    while( TRUE )
# H9 h/ [9 }% v3 @) U    {7 A+ `/ V; x5 u3 x: A, N, m* t
        strEndOfLine = _tcschr( strStartOfLine, '\n' );
0 ^5 x  H' n" b2 @: @7 r        if( strEndOfLine == NULL )
' @+ f7 u' _. ^# ?% ^/ y! M            break;</P>& w% f0 [# K% S6 Z1 x: ^; S8 R
<P>        *strEndOfLine = 0;# [" c& R; @$ ^, G
        ConsolePrintf( SLINE_LOG, strStartOfLine );
& k6 ]7 O3 U) u4 t        strStartOfLine = strEndOfLine + 1;1 P! P" j9 k  b: {+ T4 d& Z# c; o
    }
$ Y- X6 N& {3 v: j, l2 x% X}</P>+ s  k, V; a2 p; y( g

0 f- B. J& J; X( i  v$ E* y<P>
1 r0 v# V! u4 K4 S' U) ~# f% o: D//-----------------------------------------------------------------------------; y2 ]4 m( S  T( K3 s: B: D; \6 N) ~
// Name: 9 U; v4 n: H8 U- G5 U- a
// Desc:
; z. ^. A0 z* o3 g8 P9 Y- z//-----------------------------------------------------------------------------+ \& w% B" i- y& C7 G/ ]
HRESULT CMazeServer::SendPacket( DWORD to, void* pData, ' y7 b) N9 Y+ J$ r4 X) l8 ]2 B. r
                                 DWORD size, BOOL reliable, DWORD dwTimeout )
4 J/ L  F9 @7 D{2 W( ~7 v1 s) }; x
    // Chance of forcing any packet to be delivered reliably5 k% \  _5 g$ a: O% y+ N
    if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate )" k! u- W" l$ K0 p+ ]0 D( B! _
        reliable = TRUE;</P>
. ^6 x3 z. _+ p, c+ n+ c<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
' v. Y; l# K9 n* {) X}</P>+ U3 V9 f9 J! K7 S

, X/ N% z) d, r6 D<P>
6 u0 U0 T7 R4 c# @2 I( r//-----------------------------------------------------------------------------
2 ~/ `; s! M+ \  T+ e" Y8 F// Name:
1 s* ^9 x2 S: H" |// Desc: ; {- ~" Z( {$ @6 ~
//-----------------------------------------------------------------------------
  F0 e$ f0 A( c# C* g. Lvoid CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )3 A$ x: C& \; \( I' R$ ]  [
{
) f  ]; w0 a( ^3 Q    // If we're up and running, then send this new information to all clients. W4 W+ x' _; P* j/ u9 `
    if( m_pNet )6 Z9 Z. |! ^, d
    {, S; b0 F; e- }5 }- l. ?
        //Use the AllPlayers ID
" W5 ]% J  S$ m+ Y' p/ l- L        SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );5 X! y8 ^+ t# {6 X2 \
    }& R- g5 m! ~# m* k3 a1 l+ F
}</P>) J5 Y% m( r# C' {
0 k* v2 P) S/ E: [2 U' m0 X
<P>8 Q' t+ r! l9 \0 j
//-----------------------------------------------------------------------------
8 y: w) Y! Y! U1 u  t// Name: 2 |2 X3 ^: {  A# ^/ X7 z
// Desc: & n& v$ B! k% L$ V5 z; \8 z
//-----------------------------------------------------------------------------3 r3 `) O' D" I/ B1 G5 D* _
void CMazeServer::SetClientReliableRate( DWORD percent )
# ~3 t1 v1 A1 X4 R{
* T- O( N( {) g8 F4 }; S2 c2 N    // Update client config, and build packet containing that data! H3 H: x2 Y+ F- J/ S% Q% |
    m_ClientNetConfigLock.Enter();
7 N% L4 B9 K) ]/ x6 M    m_ClientNetConfig.ubReliableRate = BYTE(percent);, M9 `0 A9 R- ]4 h
    ServerConfigPacket packet( m_ClientNetConfig );- r' A0 }$ ?5 j+ O+ v
    m_ClientNetConfigLock.Leave();</P>3 Y' u  f& t) l# e/ s; A' e
<P>    SendConfigPacketToAll( &amp;packet );% E3 ^$ q+ b0 v3 q, o  `8 ?
}</P>" r! q+ O4 L* Z2 D- ]
; y6 W9 a8 i; g& u1 [; D; P; f1 F
<P>' h+ [- {' Z" D( v1 G$ a  o3 p
//-----------------------------------------------------------------------------
- R  I4 C' d. h- {9 a# D// Name: ; j, N: h) {( l' I  c1 G  b
// Desc: ! a1 [9 R1 j- N) ]! W1 q$ ?
//-----------------------------------------------------------------------------
  ]- e, E3 W7 W: ovoid CMazeServer::SetClientUpdateRate( DWORD rate )
! G+ A$ D( S6 T% B# C{" o; q  v1 O" Y: \9 W; @6 k
    // Update client config, and build packet containing that data
/ k) a4 u) ?  W* e# t4 {3 T# \    m_ClientNetConfigLock.Enter();
3 w8 {5 D; B$ _! b/ I5 K# T    m_ClientNetConfig.wUpdateRate = WORD(rate);  I+ i- [# |  k2 j7 {# C
    ServerConfigPacket  packet( m_ClientNetConfig );
( H+ N6 r4 w# K6 h    m_ClientNetConfigLock.Leave();</P>
5 d& P! s5 f. [4 `, C+ H<P>    SendConfigPacketToAll( &amp;packet );* N7 C, q7 @( [
}</P>, S" F# \' C% U1 W1 L7 ~2 Z9 M' d
& z$ _! Y' [  `7 i
<P>) o* R: O9 c: ?9 T) d0 O' u" T
//------------------------------------------------------------------------------ g: X" }5 c- z' D8 v5 r; r
// Name: ! z. j. a+ t$ k6 Y: x  r6 r
// Desc: " ]2 W9 f# u$ n+ t* z
//-----------------------------------------------------------------------------2 g! O' v( l! W/ s
void CMazeServer::SetClientTimeout( DWORD timeout )/ ]& U3 E& ~6 x6 V- a- q
{
. v( [' k  }8 V) k1 i8 u    // Update client config, and build packet containing that data6 ?* r( p& Z8 P6 w
    m_ClientNetConfigLock.Enter();
7 @8 w  b5 F4 b. A  S! d    m_ClientNetConfig.wTimeout = WORD(timeout);
2 c3 O3 f2 ]5 D) h  u9 p    ServerConfigPacket  packet( m_ClientNetConfig );
5 U4 q4 |' n) _8 _    m_ClientNetConfigLock.Leave();</P>" T9 w6 [- u% N, f
<P>    SendConfigPacketToAll( &amp;packet );
/ `3 P4 I# j$ z8 ~' K}</P>
- p& ^! G7 N- ~$ s# [, K0 D' r, T1 P- Y
<P>
3 f2 K) f  L" a- a//-----------------------------------------------------------------------------
6 V, b2 s1 X4 d* C, h* ?- y5 ^: ]// Name: 3 _  p: C" c- f
// Desc:
2 j* G4 A/ l. ]! k//-----------------------------------------------------------------------------, o2 r+ h, \7 S4 u
void CMazeServer::SetClientPackSize( DWORD size )
: u) T) M" B) i{+ \  H9 h2 e( R/ K/ B* E
    // Update client config, and build packet containing that data
0 _1 U2 w; }9 K" r( k' s    m_ClientNetConfigLock.Enter();
* b; a. V& I, Z7 h  f   
! X9 v. L/ m% B, I0 _4 E    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.# h- v5 a+ w  }* K+ b: Z
    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   % R6 p3 s7 [% ?' ]
        m_ClientNetConfig.ubClientPackIndex = 0;</P>8 m6 {1 ?( u3 c
<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);
0 [  v# t: ^9 _6 _( n6 s7 }! D2 w    ServerConfigPacket packet( m_ClientNetConfig );
7 p$ A! i2 t4 b    m_ClientNetConfigLock.Leave();</P>
3 K0 q* C; M* J* |4 @<P>    SendConfigPacketToAll( &amp;packet );+ S( {: X7 e  s4 e# c2 A7 d
}</P>
6 _# H& s5 s! b3 i8 g# T! V( f
! v$ Y- X, W9 o0 Y' @+ R  x* r<P>: x% E/ t3 l$ x: w! C: |
//-----------------------------------------------------------------------------
! z# E# G0 s+ d7 ^/ E; ^3 l// Name:
. |5 |" b3 _% p; U// Desc:
8 U* i5 U$ ^7 z( t: G+ G//-----------------------------------------------------------------------------8 y. |6 q. O$ _4 M% s
void CMazeServer::SetServerPackSize( DWORD size )0 }" _) R( h$ b1 B$ Y. P) u$ D" d
{( g2 `3 c! A. M
    // Update client config, and build packet containing that data
3 K+ @0 W6 _+ g( Z; h4 Z    m_ClientNetConfigLock.Enter();
/ ?! X# a& q# r4 s. \    , x5 W+ Y( M1 w9 x" p9 T& `
    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.' c% M" q" o  |! M6 ^; t0 T. p
    if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   ! W/ H7 }) o2 Y% s/ t; w" a* }3 X
        m_ClientNetConfig.ubServerPackIndex = 0;</P>
- o- D% }! h* U4 z+ I- N  ~* C0 `<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);, H7 Y3 o1 q0 S* u( r
    ServerConfigPacket packet( m_ClientNetConfig );
4 ^& E8 _5 Y) R' ^: @    m_ClientNetConfigLock.Leave();</P>+ }! G3 b5 |  E3 T! D" M, U
<P>    SendConfigPacketToAll( &amp;packet );
; ?5 y+ F! O8 h}</P>
+ \' a& c9 r3 o) Z. T<P>
0 P) i! [6 _! ]  g//-----------------------------------------------------------------------------
( g0 Q0 k4 L' e" z0 G// Name: ' l* a5 u+ ?  F
// Desc: 0 Q: {# d' N8 J9 }
//-----------------------------------------------------------------------------
# p$ B7 w0 r2 h! ovoid CMazeServer::SetClientThreadWait( DWORD dwThreadWait )* i6 w1 H3 n/ L5 a+ g  j( U1 J
{8 L; v1 x$ ~; ~+ i2 b6 `; `
    // Update client config, and build packet containing that data  e& R! K  ~7 w& K- o
    m_ClientNetConfigLock.Enter();
, t" d- M, s& e- a0 N  G) L) z: m    , @5 e% B6 D, y$ f" f7 d' L
    m_ClientNetConfig.dwThreadWait = dwThreadWait;
1 {6 B& c# i/ S) `    ServerConfigPacket packet( m_ClientNetConfig );
2 g( |8 k6 }) D    m_ClientNetConfigLock.Leave();</P>" Q/ S3 c3 O$ \+ Y
<P>    SendConfigPacketToAll( &amp;packet );: b: R7 L- r* i: ~+ h
}</P></DIV>




欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5