QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 4279|回复: 0
打印 上一主题 下一主题

[分享]MazeServer源码示例

[复制链接]
字体大小: 正常 放大
ilikenba 实名认证       

1万

主题

49

听众

2万

积分

  • TA的每日心情
    奋斗
    2024-6-23 05:14
  • 签到天数: 1043 天

    [LV.10]以坛为家III

    社区QQ达人 新人进步奖 优秀斑竹奖 发帖功臣

    群组: 万里江山

    群组: sas讨论小组

    群组: 长盛证券理财有限公司

    群组: C 语言讨论组

    群组: Matlab讨论组

    跳转到指定楼层
    1#
    发表于 2005-1-31 11:52 |只看该作者 |倒序浏览
    |招呼Ta 关注Ta
    <DIV class=HtmlCode>
    . }# C& w# L7 t<>// File: mazeserver.cpp' j5 n5 |4 K2 g# ?
    //
    6 e3 {# ?& n3 v0 x// Desc: see main.cpp
    7 j- z2 j" f" L' I2 d$ ^: `//# m' L1 g% C& C/ L) {, s$ l$ D
    // Copyright (c) 1999-2001 Microsoft Corp. All rights reserved.0 M5 M7 B; [+ M* Q
    //-----------------------------------------------------------------------------
    ) a! S+ T0 _+ k" x) P- n2 ~: h% j* r#define STRICT* h6 A2 E+ c+ d) c
    #define D3D_OVERLOADS8 b! B1 Y) t9 d- q4 Y- v
    #include &lt;windows.h&gt;, a5 d$ A& u% Z9 y9 v1 L
    #include &lt;d3dx.h&gt;# K  H/ K) u9 j" y, D! m$ k
    #include &lt;stdio.h&gt;# k; R& X( ?& k, I( \( A
    #include &lt;math.h&gt;) I6 ~3 h$ l. N. G3 a  v4 d; R
    #include &lt;mmsystem.h&gt;  e4 z4 w; M3 r
    #include &lt;dplay8.h&gt;! T% M. v! A( r+ X/ N& B% s; i9 t
    #include &lt;dpaddr.h&gt;
    4 X/ I9 x* N; U' v0 X; |' @#include &lt;dxerr8.h&gt;9 ~4 A# D) g  |7 K' o' Y$ }. q. U% p
    #include "DXUtil.h"8 `; y5 W1 n/ y
    #include "MazeServer.h"
    7 q+ z7 n, x! Y/ b: }& d7 P#include "ackets.h"
    / [1 [5 {7 U* a0 t1 M#include "Maze.h"
    ( t' b8 a/ X" a" `  y( ]! Y3 v4 v#include &lt;malloc.h&gt;
    1 o) e0 o5 V+ ]. b3 P# f) x#include &lt;tchar.h&gt;</P>6 N+ {" Y9 X4 u8 a6 v

    , R# G8 n6 t. g' q' ]# _) N<>//-----------------------------------------------------------------------------; {6 J0 y2 t8 {$ \9 w
    // Name:
    0 g& }" L% X: j0 b" R6 z& S// Desc: . U' A1 Q1 x9 m
    //-----------------------------------------------------------------------------
    ! @, ~9 i# v+ _; e! _! R, w2 sCMazeServer::CMazeServer()  ~1 o1 R! c- W
    {+ L. |' Z5 u  B6 V
        m_dwPlayerCount         = 0;
    2 A" ]3 h+ ~' M" _5 q    & t  f5 G1 K& {. N1 o4 ~. A3 i
        m_wActiveThreadCount   = 0;
    ' I2 g1 \0 F" `' K& |: {) V    m_wMaxThreadCount      = 0;
    6 _" _$ r/ [$ r7 K' v, R    m_fAvgThreadCount      = 0;
    0 a* e8 m& X2 V    m_fAvgThreadTime       = 0;% a- z$ q6 ?! }/ @, J, b
        m_fMaxThreadTime       = 0;</P>
    : C4 O  m9 `( ]  O<>    m_dwServerReliableRate  = 15;
    8 w$ h6 U$ a( u    m_dwServerTimeout       = 150;
    ! K$ G9 c  k" l6 r  o0 w" j    m_dwLogLevel            = 2;1 k$ m; G6 \, f7 F4 T
        m_pMaze                 = NULL;</P>
    ; Q% \, e8 p% ^5 m1 |<>    m_ClientNetConfig.ubReliableRate = 15;. h3 y# m/ q" \0 |1 f7 c' L
        m_ClientNetConfig.wUpdateRate    = 150;
    . [1 P1 Z6 r/ m: S! M) E    m_ClientNetConfig.wTimeout       = 150;</P>( O' I1 ^4 L0 e  K- m
    <>    m_ClientNetConfig.dwThreadWait = 0;</P>+ g* c& w. W; n. {/ g- Q
    <>    m_ClientNetConfig.ubClientPackIndex = 0;
    ' J$ P6 ^1 R1 T! |; p7 {    m_ClientNetConfig.ubServerPackIndex = 0;
    $ z9 y8 r- I* x7 ?    for(WORD x = 0; x &lt; PACK_ARRAY_SIZE; x++)
    ; i. i( Q2 G. F) w; R    {2 Y& F6 m. d* l: L
            m_ClientNetConfig.wClientPackSizeArray[x] = 0;4 d' C9 v: M- O  `
            m_ClientNetConfig.wServerPackSizeArray[x] = 0;  L) T6 v: C# p& l
        }
    ( n5 u5 X+ c% y' e}</P>
    $ k. e, G: l) d( f( J$ b, |1 ]( ^# P+ P
    <>7 U* s$ @) V* Z0 ^9 X
    //-----------------------------------------------------------------------------
    3 x  y' F  P: f! \0 j// Name: # H. y' G( i3 Y
    // Desc:
    # o' M  K8 f0 E: X6 G5 v$ e//-----------------------------------------------------------------------------7 t# v( L  T' g- {" Q
    HRESULT CMazeServer::Init( BOOL bLocalLoopback, const CMaze* pMaze ), |3 y" w- N, I: ]7 t
    {
    $ p! N! b4 u/ [  a( j' ^    m_bLocalLoopback = bLocalLoopback;; o" w! J' G; z3 \/ H
        m_pMaze = pMaze;
    ( A  I( @; P% h8 B% D7 j    if( m_pMaze == NULL )
    / ^& m7 h+ o: H" V: o* R        return DXTRACE_ERR( TEXT("aram"), E_FAIL );</P>4 Y# @5 K  W$ x1 j1 L- {6 g" U9 P
    <>    // Grab height and width of maze& ^2 T# a+ X3 I; N
        m_dwWidth = m_pMaze-&gt;GetWidth();' }+ r# a1 S( t! @3 a" r9 U; P
        m_dwHeight = m_pMaze-&gt;GetHeight();</P>4 z7 \" ]! d. a3 x
    <>    m_ClientNetConfig.dwMazeWidth  = m_dwWidth;3 d& e. X/ X2 c  b& P) N
        m_ClientNetConfig.dwMazeHeight = m_dwHeight;</P>6 I; ]& k+ o- `  d# r1 \1 @
    <>    // Validate size. Must be a power-of-2 times LOCK_GRID_SIZE. Compute the shifts.
    4 A- P/ n' Z' f$ x4 z    if( m_dwWidth &gt; SERVER_MAX_WIDTH || m_dwHeight &gt; SERVER_MAX_HEIGHT )
    / d8 f* s2 m& i& X. s. `        return DXTRACE_ERR( TEXT("Maze height and width need to be less than 128"), E_INVALIDARG );0 `, ]2 j/ h8 R
        if( (m_dwWidth % LOCK_GRID_SIZE) != 0 || (m_dwHeight % LOCK_GRID_SIZE) != 0 )
    7 K0 {( T# |$ N$ ?# s        return DXTRACE_ERR( TEXT("Maze height and width need to be divisable by 16"), E_INVALIDARG );</P># T! p0 u0 ~( u' k
    <>    DWORD scale = m_dwWidth / LOCK_GRID_SIZE;) c0 K; p' B/ t& ]9 z$ x+ B
        m_dwMazeXShift = 0;
    " W& @7 v# ^# l8 u9 r    while ( (scale &gt;&gt;= 1) )
    ! s' t9 f9 @$ l7 V2 q        m_dwMazeXShift++;</P>
    * i+ |, ]) u* Y: z: d<>    scale = m_dwHeight / LOCK_GRID_SIZE;
    : g/ S- a3 P% d8 \6 Y1 B; E; S    m_dwMazeYShift = 0;
    7 B" h5 {& |# u  y9 `. L, Z) a1 U    while ( (scale &gt;&gt;= 1) ); J# X  x7 b, D7 w% w9 \4 B. P% m( t: s
            m_dwMazeYShift++;</P>: M: w$ _; Q& e3 g( T/ A+ d! L
    <>    if( ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeXShift) != m_dwWidth) ||
    0 A( g/ I2 V6 V        ((DWORD(LOCK_GRID_SIZE) &lt;&lt; m_dwMazeYShift) != m_dwHeight) )% {! B* H* ]) V
            return DXTRACE_ERR( TEXT("Maze height and width need to be power of 2"), E_INVALIDARG );</P>4 b' M* x" I- g2 W: p
    <>    // Initialise the player list) d% u8 U9 d  z8 ~# \0 B/ P$ }4 u. d' n
        ZeroMemory( m_PlayerDatas, sizeof(m_PlayerDatas) );. o9 Y( B' B2 u/ j+ e: }5 z
        m_pFirstActivePlayerData = NULL;. F! U0 G2 Q, `4 Z9 Y8 x% e
        m_pFirstFreePlayerData = m_PlayerDatas;  z9 p4 Y& B6 v9 g: T  _2 ]1 u
        for( DWORD i = 1; i &lt; MAX_PLAYER_OBJECTS-1; i++ )
    1 P* G& `9 h8 Z& g) @% Z8 b    {& ?# F/ Y) r$ N% m6 V
            m_PlayerDatas.pNext = &amp;m_PlayerDatas[i+1];2 k, f( w/ K) P4 i/ ]
            m_PlayerDatas.pPrevious = &amp;m_PlayerDatas[i-1];$ ?/ {$ E1 h2 e5 M0 F
        }</P>
    6 F( Z& ^1 Y  }) {% e+ W& U7 g3 U<>    m_PlayerDatas[0].pNext = &amp;m_PlayerDatas[1];2 Y8 L# |2 U9 B2 w! B
        m_PlayerDatas[MAX_PLAYER_OBJECTS-1].pPrevious = &amp;m_PlayerDatas[MAX_PLAYER_OBJECTS-2];: e; p! C4 u; t* y- o- x
        m_dwActivePlayerDataCount = 0;+ s) q3 Z& ?) x0 P. B; ]8 f( Z
        m_dwPlayerDataUniqueValue = 0;</P>
    1 F' X3 l; i, j2 F/ O% M. k3 w<>    // Initialise the cells
    - l. c$ U: m2 [    ZeroMemory( m_Cells, sizeof(m_Cells) );
    ' o) l( F& o0 ]* }, K# R    ZeroMemory( &amp;m_OffMapCell, sizeof(m_OffMapCell) );</P>
    2 i8 A; G- P# p' l6 e/ C<>    return S_OK;5 I3 {& n$ i# ^5 ~6 I
    }</P>
    , B9 T7 \: T% t' ?0 Z, [' z* q0 T* U( y$ _% X
    <>
    ' K. W- t, Y' h7 |2 v//-----------------------------------------------------------------------------
    4 X& E* u" |$ b1 ?* Y// Name: 1 \' U, v( r5 P6 N" ], h
    // Desc:
    8 O- ^" T* T7 D' N! n0 {7 c3 t9 F//-----------------------------------------------------------------------------
    $ v7 i& c% [+ ?0 `5 ?void CMazeServer::Shutdown()
    2 j) k" X3 j6 Y{$ f) [& M/ y! d; N% ^) W, T! F( t- O/ d
    }</P>3 ~8 h! f" ?% @& O% @

    - \& \, ?' _( B& A( M<>
    + C: s2 `2 u5 F  O. H//-----------------------------------------------------------------------------. X2 B) d# K: G% m( c, ^2 r
    // Name: 6 j5 Y8 m6 r9 V. `0 k% @/ \
    // Desc: 8 a$ r9 b; ^" N* ^; }/ l: G3 s4 G% f7 w- A
    //-----------------------------------------------------------------------------
    1 I8 [2 ^$ I' h3 U9 ]: @void CMazeServer:ockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )1 l' O3 j. A& c/ q2 ]& g
    {
    8 y5 O: a  o$ Q- @! N  _5 _4 X    m_LockGrid.LockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
    " A4 R" H9 G1 N7 A; S9 i( m  f                          x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );. N5 R; }2 R9 V
    }</P>
    3 x: U0 w/ T$ v0 N# a" Z1 X: T' O/ C' h) L3 [6 s3 e2 \
    <>8 e1 t3 o- P0 I: r: D1 S
    //-----------------------------------------------------------------------------4 ^) Q" W  J, [  ~
    // Name: % ]9 @" o* @5 ^! X
    // Desc:
    $ Z5 r6 o" I) f, z+ y# w# n//-----------------------------------------------------------------------------  d# c9 m+ R) R# f  f( {+ ~& S
    void CMazeServer::UnlockRange( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )
    $ ?) L3 z, z* a$ U{: S9 i! X! a9 W+ x# N
        m_LockGrid.UnlockRange( x1&gt;&gt;m_dwMazeXShift, y1&gt;&gt;m_dwMazeYShift ,
    & m" n$ y/ P5 h. [0 }3 D" V                            x2&gt;&gt;m_dwMazeXShift, y2&gt;&gt;m_dwMazeYShift );
    * o) F8 [6 j/ w, _1 c}</P>- l. j& E3 h1 O$ G# I4 L+ k1 ^

    : z; @# J3 ]5 ^* Q0 V<>6 i% a+ G! H; R- q
    //-----------------------------------------------------------------------------
    4 N7 S& S/ ^# z1 G7 b8 D$ B2 n# D// Name: ! J4 I  g1 Z0 ]4 e. B
    // Desc:
    ' Q7 r; T! q# X& E4 k//-----------------------------------------------------------------------------
    : G& r( s/ b6 c! d2 cvoid CMazeServer:ockCell( DWORD x, DWORD y )" k- ^, @$ U; l/ A) a
    {
    ) S9 @; F6 T* T) G  l    if( x == 0xffff )
      m' E" X3 {6 v( @9 Q        m_OffMapLock.Enter();
    # k" d7 \+ K/ i' V- m6 l7 v& ?/ b$ M( N    else* Q  c( E$ n9 }$ W- w6 v
            m_LockGrid.LockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);4 W2 Q! N+ _! Q* U# ?* g
    }</P># W" k! Q- y4 z5 P
    ! M; w8 g* U' a2 O5 s3 |
    <>; p1 u( L8 l, J( ^/ I  y0 r* w
    //-----------------------------------------------------------------------------2 A; Z# y  h7 a! f
    // Name: 1 v+ i: s& a8 a  T% i
    // Desc: / E2 `5 A( `( r; a) x, K$ ]3 [  |
    //-----------------------------------------------------------------------------
    8 C$ o$ _& Q" _  |8 Xvoid CMazeServer::UnlockCell( DWORD x, DWORD y )
    ( I, ^% I" b  r- B{( s5 r4 Y5 b* n; u; g; @* `) n6 v
        if( x == 0xffff )9 K. B. }% z, Q' s
            m_OffMapLock.Leave();
    : k2 }. K3 Y) `4 s+ n, f: L    else# [" x' r( P$ S  {: u/ e
            m_LockGrid.UnlockCell(x&gt;&gt;m_dwMazeXShift,y&gt;&gt;m_dwMazeYShift);
    # }2 o- m( G, t  E" P, B}</P>/ K+ P+ T0 `4 I+ j. @
    6 `) @2 m3 d6 u5 Y6 W/ U7 o
    <>- k7 j0 O+ K  n
    //-----------------------------------------------------------------------------
    - n* m8 K- i) m0 X% P  J// Name:
    . H9 J0 R2 U1 ?, `/ d5 F// Desc:
    ( E' M5 w* x- X' w( d//------------------------------------------------------------------------------ ]6 N0 v; d" C6 X- P
    void CMazeServer:ockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )( L3 X5 v) I; p2 L  W: U- B! ?
    {$ W7 O5 k. P& E5 `
        if( x1 == x2 &amp;&amp; y1 == y2 )# X6 G  `) D* @! T" u- s% J& {
        {
    9 M/ k8 N! I% B' T' Y  P        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )
    8 p& t1 |6 |# Y  |            LockCell( x1, y1 );# h4 u- B% o  m% B
            else
    9 Y. T. Q% C) U& D+ W( |; ~( q  A" d6 e            m_OffMapLock.Enter();</P>
    - D) Q$ q- e( S1 F<>        return;
    # h) B5 f/ f6 c" s' I+ G  P1 p& D    }</P>- ]( f! ]8 M5 g6 t6 R
    <>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;
    6 f5 i, d3 [  p    DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;/ ]! U, T! U: D3 I3 w8 E
        DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;0 i) v( J# P; F) T' N
        DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
    ' }3 \, d0 G* L6 m! |$ c4 n<>    if( x1 == 0xffff )
    ) z" v( W7 U! k1 a) _0 ?    {
    2 S) k, d: m2 j0 ^8 J6 O7 G        m_OffMapLock.Enter();6 O. U- H" {$ u9 {4 L5 y- A
            m_LockGrid.LockCell(x2shift,y2shift);, Y9 }$ ~; K2 {2 c5 m5 V, @
        }
    6 O% E2 k3 K% M2 x  L5 ]" h    else if( x2 == 0xffff )/ A7 F1 {7 d6 T1 ?5 t' b
        {% x) z: m1 k  D7 H8 g* i# j
            m_OffMapLock.Enter();
    ) ~  ]6 e6 y6 a7 C6 _  D+ k1 x( q) a        m_LockGrid.LockCell(x1shift,y1shift);/ O+ G5 u7 v- i+ ?
        }
    8 t* ~' \9 [1 L* J) k    else ( g- K, F) e$ A
        {: R2 r1 H' ]$ ~
            m_LockGrid.LockCellPair(x1shift,y1shift,x2shift,y2shift);2 N1 }: j' c/ H2 s
        }1 H' Q/ U9 m7 R0 X
    }</P>" u8 s# O$ \' ^! \0 K
    % e% N$ k1 m# T* T; u/ `! a$ M
    <>
    5 {/ W" ]6 W; E, T! l//-----------------------------------------------------------------------------
    ' b& h) [$ F3 {! Y8 M1 v3 a! u// Name: 5 G, q" n0 r- g/ Z; s& I; Q  x' g( Z
    // Desc:
    # ~# n( u- v! m9 @) S7 |//-----------------------------------------------------------------------------
    , T/ L+ h' P/ y$ \# Mvoid CMazeServer::UnlockCellPair( DWORD x1, DWORD y1, DWORD x2, DWORD y2 )* _: n: P* I. q9 w
    {
    & w$ P$ s# W. q/ R% g. J    if( x1 == x2 &amp;&amp; y1 == y2 )
    + u( w: x0 H' W9 ?/ s( T    {
    ' K' L8 T! n' |) k* \( |        if( x1 != 0xffff &amp;&amp; y2 != 0xffff )+ L( b2 u5 a( i9 w2 N1 s( x% c
                UnlockCell( x1, y1 );
    ! G( X. c8 \, B9 J        else; U9 A% q, }0 L7 Q# \& M# u
                m_OffMapLock.Leave();</P>, h! |5 v; |* G! B
    <>        return;# w) K+ f7 U" G$ s& A
        }</P>
    7 x  K% c; `- r<P>    DWORD x1shift = x1&gt;&gt;m_dwMazeXShift;+ W- R) w1 |  U4 \- v4 U
        DWORD x2shift = x2&gt;&gt;m_dwMazeXShift;( Z+ \8 ?4 L# Q$ v  t
        DWORD y1shift = y1&gt;&gt;m_dwMazeYShift;
    & B2 C) l* q# `; e' V; Y    DWORD y2shift = y2&gt;&gt;m_dwMazeYShift;</P>
    1 c! N9 m8 _) C" V- c<P>    if( x1 == 0xffff ). [3 T) j0 P0 }4 i* v0 G+ [
        {
    3 a' {) T! p4 a* Z* p        m_LockGrid.UnlockCell(x2shift,y2shift);
    6 ?# c9 {* S5 m        m_OffMapLock.Leave();% l5 S0 A8 D' M6 o3 I) s
        }
    # {! X; F; z' W( W9 O. Y    else if( x2 == 0xffff )
    8 F! f6 d' X4 P! [" z# K    {
    / D; k$ ?5 p' g" u" W) v        m_LockGrid.UnlockCell(x1shift,y1shift);
    * Q2 o: p* `4 A$ h. P        m_OffMapLock.Leave();
    5 Z" t, b0 ^! E- E    }
    & z% `1 N" e  ?7 F0 K    else # @2 {4 y5 F8 W: N& X7 z
        {
    9 O( A6 z$ M" X5 D' [  S5 r5 F        m_LockGrid.UnlockCellPair(x1shift,y1shift,x2shift,y2shift);5 h8 h6 k+ }8 r6 I9 B
        }/ |' r' e- N2 D; a6 c. \! i0 Z
    }</P>% K2 K/ D) q$ \2 }& j' S

    0 T0 L; @* \0 W: A  C4 h<P>
    # U' Z/ |; m. r0 H7 ?9 Z//-----------------------------------------------------------------------------; B0 a/ S+ ~/ o3 O, w
    // Name:
    ; ~- \1 t" E" Y8 j/ C; t// Desc:
    9 k) H# w- [9 I: C8 X7 X: O% E//-----------------------------------------------------------------------------8 G# E& x" C8 P( H1 O" w0 a
    void CMazeServer::OnAddConnection( DWORD id )
    4 X8 l& u! B: a{) C3 c3 w$ }1 c7 ]: \3 z
        m_AddRemoveLock.Enter();</P>' ]1 m; K; J) G* m1 m; o8 V
    <P>    // Increment our count of players- \  q  j( r& m% y2 n, x
        m_dwPlayerCount++;
    9 |- z  b7 p, y7 D1 T8 \    if( m_dwLogLevel &gt; 0 ); M$ j& S& y5 n- O
        {
    6 ^$ T6 e/ M; T        ConsolePrintf( SLINE_LOG, TEXT("Adding player DPNID %0.8x"), id );
    6 P' p% U; O  S- {7 k" `" q/ f        ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );; O( d! H. Q, T( o; b% C
        }</P>
    + W( N( ~# |8 d8 X7 e; l, N<P>    if( m_dwPlayerCount &gt; m_dwPeakPlayerCount )2 r$ v+ U' t9 ^6 O
            m_dwPeakPlayerCount = m_dwPlayerCount;</P>  t$ G) F% }1 ~5 V* g3 ]5 L& F
    <P>    // Create a player for this client: ^6 d' G7 e$ ?9 T; l7 c$ l
        PlayerData* pPlayerData = CreatePlayerData();0 U9 i( c% S4 G. W+ B" ~
        if( pPlayerData == NULL )& L  O7 Y) {* a7 ?; a( m; i2 B
        {& [% u; s4 g, d- _
            ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unable to create new PlayerData for client!") );
    , h$ E" {1 E- n) |; L9 U/ {3 N        DXTRACE_ERR( TEXT("CreatePlayerData"), E_FAIL );
    " M: T1 B6 c& n& F        m_AddRemoveLock.Leave();
    ; D, B: O1 \8 P, P! r1 S% ?: d        return;
    / S$ I/ l& L+ E    }</P>6 T, U- O4 _1 }7 Q! X) q
    <P>    // Store that pointer as local player data
    5 O3 ^; D& G. S    SetPlayerDataForID( id, pPlayerData );</P>; X* i  U" l' h5 [# f: }
    <P>    // Grab net config into to send to client# a( Q3 H2 [  G% e
        m_ClientNetConfigLock.Enter();4 q/ M) l$ b2 ~
        ServerConfigPacket packet( m_ClientNetConfig );% B$ r' k' m5 @2 H5 X
        m_ClientNetConfigLock.Leave();</P>' u; ]& r) _  s, R( y; s* C
    <P>    // Send it- ]' Z0 `% \7 k
        SendPacket( id, &amp;packet, sizeof(packet), TRUE, 0 );</P>
    5 {/ ?* S3 q1 `/ U* t<P>    m_AddRemoveLock.Leave();& S- c/ B1 C6 R
    }</P>" ]% ~: n9 q6 [7 J  W. ^

    + ^6 ^8 G1 S2 L& ], E<P>& F- o+ n8 x! B! J5 g
    //-----------------------------------------------------------------------------
    . v5 Q5 g# {% U  ]9 v4 d1 T// Name:
    $ m1 j& B4 i" }, w! A! R6 f# Q// Desc:
    / I6 y  w6 W8 h, F9 G- p% a//-----------------------------------------------------------------------------5 y! T: d6 U. R( C2 a0 \
    void CMazeServer::OnRemoveConnection( DWORD id )
    . u/ A1 f8 f+ W& y  ^& S{% W  s* f3 V) p4 T5 Q( M
        m_AddRemoveLock.Enter();</P>
    . F: X- h% t) S6 u9 X. y# O<P>    // Decrement count of players9 W) [. K" R8 F# \- ~" E7 P3 f
        m_dwPlayerCount--;</P>, `% C& W5 y0 V- Y/ i
    <P>    if( m_dwLogLevel &gt; 0 )" X" T/ o1 f! A1 W, b: A
        {
    / @% S1 ~2 f( [" t+ M/ ~2 O- P6 h        ConsolePrintf( SLINE_LOG, TEXT("Removing player DPNID %0.8x"), id );4 h( z6 o, v8 ]0 Q$ Q3 N0 h
            ConsolePrintf( SLINE_LOG, TEXT("Players connected = %d"), m_dwPlayerCount );6 j0 Q. g  {, w- q
        }</P>0 d2 b* Y. w5 {4 i
    <P>    // Find playerdata for this client
    4 t4 {, b9 }$ \3 p    PlayerData* pPlayerData = GetPlayerDataForID( id );4 H- d& \5 t; B: {$ e1 ]5 C
        if( pPlayerData != NULL )' U5 `& H% `: D% m
        {( r9 g8 V7 v- t- j4 x5 j; k! O4 I8 F# R
            // Destroy it
    , F* @3 T. U7 K" c2 e        RemovePlayerDataID( pPlayerData );
    2 D7 {  P: Z; W/ p        DestroyPlayerData( pPlayerData );& e3 M0 V# j! u
        }</P>
    ( s* V4 g" g$ H9 |$ m) D5 @- ~<P>    m_AddRemoveLock.Leave();
    4 e  c5 y% T$ B! ~}</P>* s# j& T% n: t  n

    : \+ H0 Q0 M. R<P>' E- {, U3 L0 ]& E6 C9 W
    //-----------------------------------------------------------------------------
    * X+ i/ @, x! t9 m( l/ z' k/ z6 C// Name: . H& p) c7 _; ?% {# Q9 b$ Y9 f' T
    // Desc: ( N/ Y7 B  {) w# M! _
    //-----------------------------------------------------------------------------
    / d. \9 z! y: u/ ^9 r2 Q6 nHRESULT CMazeServer::OnPacket( DWORD dwFrom, void* pData, DWORD size ); G4 F" c( F, H1 F
    {) W5 L" S8 N$ |4 J! [
        BOOL fFoundSize = FALSE;</P>3 F7 z7 Y* k' [& c
    <P>    // Increment the number of thread we have in this process.) s  W* L$ ]$ F/ b' h
        m_csThreadCountLock.Enter();</P>0 }1 C; Z5 w5 m9 w
    <P>    //Get the start time of when we entered the message handler.5 B7 ~/ E; }& j3 W. @
        FLOAT   fStartTime = DXUtil_Timer( TIMER_GETAPPTIME );</P>, U0 `9 ]1 z' r3 {7 P
    <P>    m_wActiveThreadCount++;' R2 U9 D1 S- c- N* n9 h
        if(m_wActiveThreadCount &gt; m_wMaxThreadCount)- D% K! |  z; M' P( f% m+ @% O! i
            m_wMaxThreadCount = m_wActiveThreadCount;
    ( v: t$ f, j/ z    % W' ~: }* \; e8 H
        // Calculate and average.
    $ a5 |1 H  ~& W3 x" X8 [    FLOAT fdiff = m_wActiveThreadCount - m_fAvgThreadCount;" J2 d/ x1 p  T: W$ K; S$ K; ]
        m_fAvgThreadCount += fdiff/32;6 q1 f* n0 l/ a
        2 ?: w6 z4 W: ~% C. O
        m_csThreadCountLock.Leave();</P>
    , M. y$ R# C2 V% w7 N- M<P>
    6 B9 o6 Q) ^* u* e6 C0 S+ \    ClientPacket* pClientPack = (ClientPacket*)pData;# D) H# z' x, {
        switch( pClientPack-&gt;wType )
    3 Y* _/ k+ X. U. L% E& y( d5 i    {
    : @; e& f( Q! {$ v        case PACKETTYPE_CLIENT_POS:% z0 q' ?' C  g; s4 ]
                
    ( ~6 ~- @1 m9 v0 s. b  }( z* B% R            // Check to see if the packet has a valid size. Including
    ! H' ^7 @4 A0 A% ]- A6 m            // the custom pack size.2 r3 c1 C# s4 L" k$ Q
                if( size &lt; sizeof(ClientPosPacket))
    2 U# t( h7 `( P. z6 `                fFoundSize = FALSE;  x" J0 B( W. E& s" j
                else if( ! IsValidPackSize(size - sizeof(ClientPosPacket)))( z: N# d9 t: ?1 X( ?
                    fFoundSize = FALSE;# M( o3 G) p9 g# ^
                else
    # c$ s4 j6 g( F5 ?                fFoundSize = TRUE;</P>
    2 y' ?, |) j* M8 f<P>            // If valid sized packet, handle the position.' X1 d; F1 ~% y: Y) I
                if(fFoundSize)  B: H" Z3 Y6 s* f
                    HandleClientPosPacket( dwFrom, (ClientPosPacket*)pClientPack );3 Q: R3 t" ?/ M* r
                else/ L: O6 ], Z, Z5 a. d7 l
                    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );</P>
    / S5 ~  b: L# l5 {<P>            break;</P>
    6 Z0 U- G% v* y0 R! _5 t<P>        case PACKETTYPE_CLIENT_VERSION:
    2 F1 p, `" S' ~- {/ w. w' |            if( size == sizeof(ClientVersionPacket) )
    5 C8 i$ S0 n# e                HandleClientVersionPacket( dwFrom, (ClientVersionPacket*)pClientPack );
    * z" q; a0 w8 \& y) C4 U' `6 u$ S            else" l; f8 d5 Q4 x+ [) R# g. o( t1 l
                    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
    . ]. f5 U% x8 E            break;</P>( G1 ^+ |/ }0 @* I4 N$ G, x9 Y7 t& G
    <P>        case PACKETTYPE_SERVER_CONFIG:</P>
    . [  g! f, E# v<P>            // Server config packet sent to all users (including server). Just ignore and continue.</P>9 }' w5 E5 z, Q0 f2 O6 n" f
    <P>            break;' n! A# M* Z4 G* M7 `0 _
            default:0 a9 S: a5 L( s$ D* @7 |
                HandleUnknownPacket( dwFrom, pClientPack, size );
    5 @2 q  Z# O; J: s5 t. d            break;8 y! C/ S5 |2 q9 V9 f1 W  ^
        }</P>
    " g3 {! K; O% Z* r# S8 V<P>    //If the user wants to hold the thread, Sleep for given amount of time.
    6 ?0 Q! R) R3 H) C& L9 b    if ( m_dwServerThreadWait &gt; 0 )
    # v% v2 T0 y5 J0 k6 Q- h    {* B/ v7 {9 D1 L
            Sleep( m_dwServerThreadWait );
    ; ~& A& l: r/ t  o8 y    }' I2 Z2 H$ {( ]+ ~3 A0 U' B9 [0 M  e
       
    " f% t7 B, u- j& r1 @    // Retrieve thread data for this process.& o4 S& i, s7 W) K1 T/ u# K' P1 w6 A
        m_csThreadCountLock.Enter();</P>
    , u7 W& g/ R3 G- |. T$ ]<P>    m_wActiveThreadCount--;</P>
    % O2 H, ]; r2 z$ S2 K3 [  ?<P>    FLOAT fDiffTime = (DXUtil_Timer( TIMER_GETAPPTIME ) - fStartTime) - m_fAvgThreadTime;
    , ]$ C4 j' P, @, l" I8 d    m_fAvgThreadTime += fDiffTime/32;</P># d- ~. s0 `0 j$ F  x' ]5 @
    <P>    //Get the Max time in the thread.
    5 [; v7 @. Q5 _; }# w$ s! r, i! E    if ( fDiffTime &gt; m_fMaxThreadTime )
    4 k; B6 C: O) \2 z  `/ K+ V    {2 D7 z$ e7 Z2 P
            m_fMaxThreadTime = fDiffTime;2 V1 L/ B: E9 l4 X1 \" B
        }</P>7 e+ M% l/ Q5 @3 y: y
    <P>    m_csThreadCountLock.Leave();</P>5 o* M: u6 y) r4 _
    <P>    return S_OK;# ?1 A* V7 J6 _" E$ q' y
    }</P>
    8 @* V. M( ~# _# I
    5 |/ w+ p( ?9 S; C- L  m1 A<P>//-----------------------------------------------------------------------------
    ! B* ]0 {+ M& i  J/ Z// Name: + L6 ~4 `+ e$ s; d5 K, ]3 H
    // Desc: 4 K6 Q0 z/ O0 s" b) Y, S
    //-----------------------------------------------------------------------------: V; f3 o9 g* ]3 L  |& l
    BOOL CMazeServer::IsValidPackSize( DWORD dwSize )
    8 L: C. N8 l4 z# N* n, y{8 K+ [- f$ d5 J% h7 p
        BOOL fFoundSize = FALSE;5 s' Q9 P" u- o' E
        BYTE ubPackLocation = m_ClientNetConfig.ubClientPackIndex;0 @  t* m' M/ @. ]) J7 u
        % e( M; @9 C' f& x
        // Check through the array of valid pack sizes.! W2 `! q! I! z. H( \6 P; V, b
        if(dwSize != m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])0 n0 H( z2 H5 ~) U$ g( z: C
        {
    : e5 G/ e: ~. K# z: q1 W        for( --ubPackLocation; ubPackLocation != m_ClientNetConfig.ubClientPackIndex; ubPackLocation--)! b; c" o( z$ s1 v2 C
            {# L* V0 \4 V- Q1 e
                if(dwSize == m_ClientNetConfig.wClientPackSizeArray[ubPackLocation])
    ( i6 t* M, @( W' H            {
    5 K9 |2 X% |" n1 i8 O. m# h! \7 p                // Found valid size in the array.
    $ U# F9 X0 M$ |3 A: l  \                fFoundSize = TRUE;
    . J/ s$ j7 R' g1 B6 ~                break;5 z) M' H- F" j" t: `5 K8 q+ x
                }
      h+ A* l* P. {9 t            if(ubPackLocation &gt;= PACK_ARRAY_SIZE)  ubPackLocation = PACK_ARRAY_SIZE;  //Wrap the array.
    7 H( z+ F8 O2 L! V1 d- C        }
    6 S# {0 y/ p& x0 {" h0 `: B    }
    , R1 L. `6 y0 J    else( `& f0 z! d. |4 e' O# W# A% F
        {
    4 s% z- S+ \8 h; q; o- L7 N( V        fFoundSize = TRUE;
    ) q" ]$ Z: t# D$ x8 B    }</P>* l1 ?- V' ~6 p/ w9 P: Q
    <P>    return fFoundSize;
    2 v5 h; W5 b7 w' n* _0 \. i" B# U}</P>
    , A  ?# L3 i' x2 N<P>
    ' E2 g. D$ o& X" S0 S2 e//-----------------------------------------------------------------------------
    ) s) P% _' y/ |4 a6 d// Name: ' j6 s( D; R3 o# o+ P7 d
    // Desc:
    / y9 O* I* Q! _7 h//-----------------------------------------------------------------------------) `7 u- F9 O/ d5 T, N  \, z+ k
    void CMazeServer::OnSessionLost( DWORD dwReason )" }' W& H3 M4 r3 g  r1 P
    {5 W: W  c, D, R" ?& U
        ConsolePrintf( SLINE_LOG, TEXT("ERROR! Session was lost") );
    9 v. m; O/ s6 _/ w' i0 m}</P>: N: ?5 E# j0 y4 c) \

    + P' x+ E4 r: D5 Z3 C$ M<P>9 E3 A2 K0 w- g
    //-----------------------------------------------------------------------------
    6 z+ C) j3 \/ d8 V6 A. R// Name:
    $ J( R. e6 e3 M8 U6 M" b8 f! `// Desc: 9 W/ A# {* S1 L2 T
    //-----------------------------------------------------------------------------
    ! S9 b" E& j5 F* K$ WPlayerData* CMazeServer::CreatePlayerData()) k6 ]* J, ]* g  |
    {
    3 ]* a  D5 t; E  \, T2 v    m_PlayerDataListLock.Enter();</P>
      t0 o" w7 ]2 i' K<P>    // Grab first free player in the list, s' A: J0 A2 z2 z& O# L5 f: C
        PlayerData* pPlayerData = m_pFirstFreePlayerData;</P>
    # C5 I' S% V6 @. a8 C* m7 |<P>    if( pPlayerData )
    " X  k' ?9 e' e4 O' k2 e0 |% ?7 R3 E    {) j' g+ A  @9 R, m4 E+ p3 w
            LockPlayerData( pPlayerData );</P>3 [! |$ {0 y7 ?' q$ q% v
    <P>        // Got one, so remove it from the free list1 _8 J. z4 L4 y8 n# P' T
            if( pPlayerData-&gt;pPrevious )
    - ^7 j) K5 }9 x& @+ {- R1 r8 l5 g            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;5 i# V, h/ _% r  ^* F! s4 H
            if( pPlayerData-&gt;pNext )
    4 \. q7 Q$ A3 q& c6 j5 Y# {. E) q% Y            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;
    . Q2 u3 i' F2 l+ e        m_pFirstFreePlayerData = pPlayerData-&gt;pNext;</P>$ l; u: d2 ~+ a7 G" d5 h
    <P>        // Add it to the active list( s; L6 g( @5 X. |/ q0 I1 z# M
            if( m_pFirstActivePlayerData )3 @2 z; v, x; J$ ~% q- \
                m_pFirstActivePlayerData-&gt;pPrevious = pPlayerData;5 M  a. P4 d7 y
            pPlayerData-&gt;pNext = m_pFirstActivePlayerData;
    # |/ i* p" ^5 e+ R' E9 M# o        pPlayerData-&gt;pPrevious = NULL;! \: G1 R& |8 r  P6 [- `
            m_pFirstActivePlayerData = pPlayerData;</P>
    / C4 d( w8 `% p, p<P>        // Update count of players; \, Z; _( P! c5 g
            m_dwActivePlayerDataCount++;</P>5 U4 ~# C5 }" k* J
    <P>        // Generate the ID for this player
    * F( l8 _/ g2 M- V; F/ Y        m_dwPlayerDataUniqueValue++;* |7 G- c' a0 ~; s) H7 u0 J% U
            pPlayerData-&gt;dwID = (DWORD) ((pPlayerData-m_PlayerDatas)|(m_dwPlayerDataUniqueValue&lt;&lt;PLAYER_OBJECT_SLOT_BITS));</P>
    % v" ?4 r0 n& t$ u& @# y; ^<P>        pPlayerData-&gt;pNextInIDHashBucket = NULL;0 z/ G8 @& {: Z. ]
            pPlayerData-&gt;NetID = 0;6 g5 M- |" r$ i' V) l! Y
            pPlayerData-&gt;dwNumNearbyPlayers = 0;</P># y8 \$ i1 y/ G
    <P>        // Insert into the "off-map" cell) R$ K5 X+ B/ Q( j
            pPlayerData-&gt;fPosX = pPlayerData-&gt;fPosY = -1;
    ! d% e/ \" p, a' s  M# ?        pPlayerData-&gt;wCellX = pPlayerData-&gt;wCellY = 0xffff;( S! r$ b) u8 u2 o( O
            m_OffMapLock.Enter();
    ' ]( b: K- M, ]# x        pPlayerData-&gt;pNextInCell = m_OffMapCell.pFirstPlayerData;. L1 o0 N$ R$ x. I9 \3 f
            m_OffMapCell.pFirstPlayerData = pPlayerData;
    8 o% ]" j) x( d" q        m_OffMapLock.Leave();</P>! M; J$ C0 H) E2 W, @/ G
    <P>        // Mark as active
    - _. e) @$ u1 F* W8 {$ T        pPlayerData-&gt;bActive = TRUE;</P>
    0 b' C$ c0 X0 e' _1 U. K<P>        UnlockPlayerData( pPlayerData );2 _3 o: s- c; W1 E4 s% K, L5 f# @
        }</P>
    8 a( j! I3 I. d5 \4 ~. G<P>    m_PlayerDataListLock.Leave();</P>
    5 G# ?9 G5 b4 `2 q( g# w; P<P>    return pPlayerData;
    2 a, f0 S* X/ b: o. i; T5 p9 N}</P># O3 d0 S* t5 l  o& J( G, {  Y

    9 p/ |" Q8 b! @' |0 i1 h  o<P>$ C% ~- D- x" o  P5 l  `& {# K
    //-----------------------------------------------------------------------------
    ( j2 {( w: `3 v# f0 ?- g// Name:
      w% s8 B1 B: S. F// Desc:
    3 `3 D5 F' s, `3 B4 \% N) U//-----------------------------------------------------------------------------) C' [% t. v; W3 {4 S" a
    void CMazeServer:estroyPlayerData( PlayerData* pPlayerData )
    , `' t1 H9 s( S0 b- v{2 |% Q  ?3 ~! h2 {% b, l
        m_PlayerDataListLock.Enter();5 u+ I8 P5 D/ G" N$ Y9 D: q
        LockPlayerData( pPlayerData );</P>
    ! F) P$ d& T! u! \9 ~5 d" I<P>    // Remove the player from its cell& H$ r0 {% x; V) `: }6 G5 c  J: d# b
        RemovePlayerDataFromCell( pPlayerData );</P>
    ! G# a7 Y" S! c; n& g+ \<P>    // Mark as inactive6 t2 n) X3 t  O% A/ ^  W
        pPlayerData-&gt;bActive = FALSE;</P>+ u/ b1 B" G8 o  Q7 H
    <P>    // Remove player from active list
      S- c1 `' E4 a7 N# o    if( pPlayerData-&gt;pPrevious )# Y' z7 C' W# M0 g. U" Z
            pPlayerData-&gt;pPrevious-&gt;pNext = pPlayerData-&gt;pNext;
    " x1 `- P$ H! l5 f7 d( W    if( pPlayerData-&gt;pNext )' A4 A8 R, O1 `& p! [1 g' L/ Z
            pPlayerData-&gt;pNext-&gt;pPrevious = pPlayerData-&gt;pPrevious;</P>5 q6 k- w6 U8 j& r5 [2 O
    <P>    if( m_pFirstActivePlayerData == pPlayerData )
    # B' `6 y2 Q! B% ^  O, d4 I, ]        m_pFirstActivePlayerData = pPlayerData-&gt;pNext;</P>) J5 Y7 F' @# Q( c) A: t% U, {" M
    <P>    // Add it to the free list: P, W' G$ w0 P' O' ]9 q
        if( m_pFirstFreePlayerData )
    . I4 Q; d' D9 N( k0 ^1 P        m_pFirstFreePlayerData-&gt;pPrevious = pPlayerData;
    9 D6 U' \; D% D% r) Q7 B" o" U    pPlayerData-&gt;pNext = m_pFirstFreePlayerData;
    ! O) Y0 I: v! b5 d* b    pPlayerData-&gt;pPrevious = NULL;
    8 S0 r, d# N4 ~) a$ [    m_pFirstFreePlayerData = pPlayerData;</P>
    + B- k( [: g, i8 D<P>    // Update count of players+ w9 X3 H# p, j- z1 B  P2 I
        m_dwActivePlayerDataCount--;</P>1 s7 f( h2 Z$ s6 x( n! V
    <P>    UnlockPlayerData( pPlayerData );; S* D7 H- J! V/ E
        m_PlayerDataListLock.Leave();8 L0 ~) L$ N# N1 t# d) `. F
    }</P>
    * t( R- }' c0 f7 E6 B' m- X# I& D3 C6 G& w$ G
    <P>& l$ r/ s' }, A9 o
    //-----------------------------------------------------------------------------
    7 S! S3 w. {% ?) G, b& g# S4 t// Name: ! D7 j$ ]4 R% I- Y: F
    // Desc:
    ! H# Z& E( i) E* P, e% y) ~//-----------------------------------------------------------------------------
    4 ?. o6 x/ d" y; |$ ?2 V- R7 ?void CMazeServer::RemovePlayerDataFromCell( PlayerData* pPlayerData )
    % ]1 q* H* E5 P$ g{
    6 r" t8 s9 w% m# @1 `    // Lock the player5 e  r! o% H3 P$ a) G
        LockPlayerData( pPlayerData );</P>
    3 F# G8 c8 ?" W# I( U<P>    // Lock the cell the player is in' h' i7 E( H1 A5 F( S
        ServerCell* pCell;
    & }+ Z8 p3 L- p) Y3 U. f$ T    if( pPlayerData-&gt;wCellX == 0xffff )
    0 n7 Z6 j# t( z, I    {
    8 o, q; z0 d- B; H6 l) f+ L2 x( B        m_OffMapLock.Enter();. c0 E9 {5 p  d
            pCell = &amp;m_OffMapCell;7 ^. i  D, Z, t3 _
        }4 e) H; ^9 |6 S; S$ Q
        else
    0 h$ b( H+ z3 G) M& l    {
    - P, A% _- V) S        LockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );
    + I. p3 f+ K* W; N+ f        pCell = &amp;m_Cells[pPlayerData-&gt;wCellY][pPlayerData-&gt;wCellX];) E9 Z1 l, f: b: \5 F
        }</P>0 A6 ?6 R$ R- {& a& W4 b4 ^* \
    <P>    // Remove it from the cell
    % c; [  \: C) H. R8 N" A3 n    PlayerData* pPt = pCell-&gt;pFirstPlayerData;3 O( o  n6 @( M  ^+ i
        PlayerData* pPrev = NULL;
    9 m" f. R3 M" ?% q    while ( pPt )& x+ R3 U1 z* v% O! A. @( F
        {
    ! n0 f! Q+ k$ v- L6 {& i- Z        if( pPt == pPlayerData )1 n( F& G3 O- ~4 J( d' M/ S
            {
    # j1 `" U- r4 h* ?- J* w% D            if( pPrev )3 d  w1 m* r6 P  c
                    pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;4 u" ]4 |, w0 A& T
                else  a) w- r: X2 G, C
                    pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;</P>/ Q8 V" e3 Q1 C& B+ m
    <P>            pPlayerData-&gt;pNextInCell = NULL;
    % l) `& n, ^5 [% V, ^  b! s/ T            break;
    ' ^" M9 g- {0 Z- e. {+ P        }: A. z1 u0 F8 u8 M! ]0 n0 D
            pPrev = pPt;
    2 E" t7 q( V/ \" r        pPt = pPt-&gt;pNextInCell;' y) `5 B9 Z6 q3 o3 m. b
        }</P>
    : v& e1 Q! X' m# P2 ~0 p" `; s<P>    // Unlock the cell2 \/ w+ Y' s/ ~8 `* z8 S+ I
        if( pPlayerData-&gt;wCellX == 0xffff )' s0 G0 @' h: s" j- e$ {$ g
            m_OffMapLock.Leave();
    9 P/ Q/ D5 t, N! x& V% H0 W& D* d2 y    else
    # w! I& l7 H1 E        UnlockCell( pPlayerData-&gt;wCellX, pPlayerData-&gt;wCellY );</P>
    + n, T0 ^! o; `: B<P>    // Unlock the player
    ! w2 [8 O3 {2 `2 e! p$ Z6 K    UnlockPlayerData( pPlayerData );
    6 C! d! s% ~1 B}</P>6 I  u, |) h  n, k. P; n

    $ g$ G+ P6 z3 I( d# m- z$ s<P># d2 P: u  `" A0 U( h
    //-----------------------------------------------------------------------------
    # ^: e1 `( q4 L7 p  Q. J4 L// Name:
    # v' \$ l% Y& J0 J* l// Desc:
    4 |$ U+ d$ `2 L: u6 s' r+ m//-----------------------------------------------------------------------------7 M; l" J& [0 Y( ^- L- S/ l
    void CMazeServer::UnsafeRemovePlayerDataFromCell( PlayerData* pPlayerData )
      b6 C* W! C* v( H" I{
    9 L9 |( x+ m& S$ g5 d    ServerCell* pCell = GetCell( pPlayerData );
    3 i7 {) F9 S; V. i$ f. b! F    PlayerData* pPt  = pCell-&gt;pFirstPlayerData;8 y# S6 R" y8 ~
        PlayerData* pPrev = NULL;' x8 B1 \. n, e, X! p
        while ( pPt )
    * q6 b1 t0 @' H6 i4 z- A* G/ N6 e    {
    " B2 f7 q% U  W. G* y4 U        if( pPt == pPlayerData )' m, \9 N  N0 \2 @; ^! |$ c! A. q. f
            {
      L  i* `2 @. }0 ^            if( pPrev )
    % m+ _8 y: ^: Y* t& f$ s& f+ ~                pPrev-&gt;pNextInCell = pPlayerData-&gt;pNextInCell;( q- g( ]. |2 p# j- u7 x5 r5 U/ h
                else- D4 Z' u' F# @+ ]
                    pCell-&gt;pFirstPlayerData = pPlayerData-&gt;pNextInCell;
    7 k) ^( g. X. C) X0 ]/ }            pPlayerData-&gt;pNextInCell = NULL;
    3 ]; e. Q* G+ L1 }! b/ A# y            break;
    . d/ Y/ f3 e, z' g- i3 u        }
    4 |3 |4 [4 H$ x- H  h- K' @' k2 f        pPrev = pPt;
    0 B/ ?0 K* k" C( j! ]        pPt = pPt-&gt;pNextInCell;# A$ |/ i. L9 x9 W, |6 Q
        }
    ( W8 A& e4 b0 S( r& }. V}</P>/ ?. D5 P3 u9 \

    0 ?$ ?$ f, P! r6 ~0 o; \7 I! \<P>
    ' w7 c8 O9 g. \) R//-----------------------------------------------------------------------------6 ~+ E; j: M  ~2 h
    // Name:
    " G. V5 X* Z2 J3 }) N4 N// Desc: # B6 E1 ]% Z, Q
    //-----------------------------------------------------------------------------" a! O- @3 ]9 T/ w
    void CMazeServer::UnsafeAddPlayerDataToCell( PlayerData* pPlayerData )
    ( B; K6 L' F5 P0 n{8 K1 I1 R5 s/ b0 a8 V! i" B
        ServerCell* pCell   = GetCell( pPlayerData );, R" Q& Q7 G4 j' z( k8 ^9 y% a
        pPlayerData-&gt;pNextInCell = pCell-&gt;pFirstPlayerData;
      _8 q2 T) B, z2 t" [' V, T    pCell-&gt;pFirstPlayerData = pPlayerData;5 d/ h9 q" y  k/ c3 m# E
    }</P>
    4 m* g$ W% W6 k8 s, x& ~. j7 w
    <P>1 c; W3 e- B# C
    //-----------------------------------------------------------------------------
    0 k' ~, s4 j, p- L* A% D// Name: $ J% ], K2 G( v8 }& \! O9 w7 H
    // Desc: 6 K, l) g# X9 B$ {1 @
    //-----------------------------------------------------------------------------, T; ?7 U2 G: ?7 |5 W
    void CMazeServer::HandleClientPosPacket( DWORD dwFrom, ClientPosPacket* pClientPosPack )
    8 j, o7 I3 z% k- M& R# k{
    1 A9 Z! u6 F, w/ f8 M, V* i) l    // Grab player for this client and lock it, x" C5 p* K: e) n9 R* Z6 r$ P8 Y8 n
        PlayerData* pFromPlayer = GetPlayerDataForID( dwFrom );
    2 v; I; p2 o( L/ q    if( pFromPlayer == NULL )' H8 O" c! d% G3 ^
        {* Z. A, d( U% T/ ~* C% _: `
            if( m_dwLogLevel &gt; 1 )9 R0 P3 O  E' ]1 h- j, X
                ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Could not find data structure for this player"), pFromPlayer-&gt;NetID );
      @) |4 K' p: ?6 ]) ~/ Q- r% I        return;/ v8 O. G8 M) a2 \
        }</P>" R' ?; D! y7 @" [" ~. s: k" c
    <P>    LockPlayerData( pFromPlayer );</P>9 D4 h/ X( J2 I8 Z, [6 _
    <P>    if( FALSE == pFromPlayer-&gt;bAllow )% ]/ w5 q6 ?7 k
        {, U4 U: V2 A3 ]6 j* @0 V
            if( m_dwLogLevel &gt; 0 ): n- S; d; c; d+ b; e- z
                ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Got position packet from bad client.  Rejecting client"), pFromPlayer-&gt;NetID );</P>
    0 j& A' Y- T; c: l! ^<P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );! s" h3 q0 f  I/ o" W) P
            UnlockPlayerData( pFromPlayer );$ p- p5 a& `, E5 l5 k" f; u
            return;
    ' L) J" f! d. \/ P2 B/ B5 l    }</P>3 N: d6 s3 \& m6 o/ h- u
    <P>    // Compute the cell the player should be in now
    5 o6 P2 B1 N' {, S+ x- z    DWORD newcellx = int(pClientPosPack-&gt;fX);- w, N1 ], r1 b2 ^% u4 O
        DWORD newcelly = int(pClientPosPack-&gt;fY);
    ! `6 \# b" E7 j    DWORD oldcellx = pFromPlayer-&gt;wCellX;+ d$ O$ [8 L. |
        DWORD oldcelly = pFromPlayer-&gt;wCellY;</P>( P. _) u1 X$ F
    <P>    // Have we moved cell?& F7 z* t3 a% x, z* s! F! o+ T
        if( newcellx != oldcellx || newcelly != oldcelly )0 V2 q9 a5 ^( r
        {
      Z  G2 U  W7 {7 P( u4 E        // Yes, so lock the pair of cells in question7 T4 A7 k  c9 ~& |) o( C
            LockCellPair( oldcellx, oldcelly, newcellx, newcelly );</P>
    + k, K- G9 }6 \$ G2 F& w+ D; w<P>        // Remove from old cell and add to new cell
    ' ~0 i9 X/ E3 n/ x4 E  g        UnsafeRemovePlayerDataFromCell( pFromPlayer );
    $ [% [* y9 A6 K7 M/ Z& Q        pFromPlayer-&gt;wCellX = WORD(newcellx); pFromPlayer-&gt;wCellY = WORD(newcelly);
    6 H- R7 H; N  |# ]) i) S        UnsafeAddPlayerDataToCell( pFromPlayer );</P>% _$ B& a, m& z; s4 U; q
    <P>        // Unlock cells/ a! D7 Z% J. s" d" Z
            UnlockCellPair( oldcellx, oldcelly, newcellx, newcelly );' |0 q6 B9 j; D/ b- c* W7 K8 N
        }</P>
    , S' M4 C) p' r2 z: ^, i<P>    // Update player position6 J. v" y, i4 b
        pFromPlayer-&gt;fPosX      = pClientPosPack-&gt;fX;7 s3 J3 T, D6 M
        pFromPlayer-&gt;fPosY      = pClientPosPack-&gt;fY;
    8 Z  B8 c. H! j    pFromPlayer-&gt;aCameraYaw = pClientPosPack-&gt;aCameraYaw;</P>
      ~. C( h% L. L<P>    // Allocate space to build the reply packet, and fill in header / i# x8 P/ s% D. I8 s# ]
        DWORD dwAllocSize;
    . x! K" L7 K+ c    ServerAckPacket* pSvrAckPack = NULL;</P>* a8 Z) V* ?( C
    <P>    // Begin by allocating a buffer sized according to  p5 D2 j9 L$ a9 D: d
        // the current number of nearby players + 4.  This will give
    . ]* k. L9 J9 j  s% j* t' L$ S: t; y    // a little room for more players to come 'near' without resize& P# w" Q+ m* u' V
        // the buffer.
    - |: r7 w6 T$ }& {. y    DWORD dwMaxPlayerStatePackets = pFromPlayer-&gt;dwNumNearbyPlayers + 4;</P>
    , t, h% I0 x0 Y& A3 W<P>    dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);$ V$ g1 P( e" T" B2 h. }% b4 N
        pSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );0 Q( N# V' b" ?& N; T
        if( NULL == pSvrAckPack )/ y: D/ g2 X9 f
        {* u  N8 {( ~2 E! N
            // Out of mem.  Cleanup and return
    1 E3 @' A# s/ l* E( n2 b. t        UnlockPlayerData( pFromPlayer );5 G( O: X9 F8 k- L* J
            return;       9 K3 B8 M: d/ Z  F% J% i' t
        }7 J4 \% Q. u( j: j6 M/ k; h
        ZeroMemory( pSvrAckPack, dwAllocSize );</P>7 Y" ^/ W3 C9 W5 D
    <P>    *pSvrAckPack = ServerAckPacket(m_dwPlayerCount);
    ' @* b8 H7 }3 @0 S& \    pSvrAckPack-&gt;wPlayerStatePacketCount = 0;. S, D0 J6 @& d( y1 V' p, m
        PlayerStatePacket* pChunk = (PlayerStatePacket*)(pSvrAckPack+1);</P>. S# f* K; Q& H, V8 W
    <P>    // Compute range of cells we're going to scan for players to send# }  O* G- Z  K% `8 c# i5 W
        DWORD minx = (newcellx &gt; 7) ? (newcellx - 7) : 0;6 W  u* w1 E+ k2 A4 G! ?9 t. ]3 Q
        DWORD miny = (newcelly &gt; 7) ? (newcelly - 7) : 0;
    , m1 T9 w3 b# m5 G/ d$ Z# e# s; ~    DWORD maxx = (newcellx+7 &gt;= m_dwWidth) ? m_dwWidth-1 : newcellx+7;! c: N0 `* x' X  i& |0 h+ W1 h7 R
        DWORD maxy = (newcelly+7 &gt;= m_dwHeight) ? m_dwHeight-1 : newcelly+7;</P>
    2 E& `" S6 w2 D! s4 k  v& `<P>    // Lock that range of cells7 ?# `% J. M3 u8 I1 ]% e: t
        LockRange( minx, miny, maxx, maxy );</P>  d% T8 G. \: }! b
    <P>    // Scan through the cells, tagging player data onto the end of
    + K7 u# s/ Q( [    // our pSvrAckPacket until we run out of room2 g" D  G: [) W1 R0 y* q% q; h
        for( DWORD y = miny; y &lt;= maxy; y++ )6 F- d( a, v. I$ n2 c* j  g
        {7 v) s4 n) r8 ?0 E$ ]
            for( DWORD x = minx; x &lt;= maxx; x++ ). _: G) R- C7 p! m0 X
            {  L# f1 m' F) j# y+ f+ B' g( h
                PlayerData* pCurPlayerData = m_Cells[y][x].pFirstPlayerData;! O  Q+ o( [- N, @) a! T8 n1 t
                while ( pCurPlayerData )
    % J! O. _; p1 _6 C! w$ d3 G            {& H  v/ ?. O& f, F/ ?9 l, w( _- n
                    if( pCurPlayerData != pFromPlayer )# F! U5 H2 I4 j+ ?
                    {
    5 {1 v# h1 T$ T' k7 N                    if( pSvrAckPack-&gt;wPlayerStatePacketCount &gt;= dwMaxPlayerStatePackets )9 ^& S! y- @0 i' z2 ^& m/ l- b
                        {( M3 ?/ s, {- B1 N4 x6 I
                            // Make sure pChunk is where we think it is
    ' S0 m; P8 r7 m                        assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );</P>9 l1 R' y9 o6 M
    <P>                        // There are more than just 4 new nearby players, so resize the
    / w9 t1 C6 W0 p  U  Q) |                        // buffer pSvrAckPack to allow 16 more PlayerStatePacket's.
    # G  z2 i3 o1 v' M# A1 ^) q                        dwMaxPlayerStatePackets += 16;- K- l$ I+ w% Z3 I
                            dwAllocSize = sizeof(ServerAckPacket) + dwMaxPlayerStatePackets*sizeof(PlayerStatePacket);' C" s+ K! i# s2 Y! |
                            ServerAckPacket* pNewSvrAckPack = NULL;
    + w- u" }2 X& S5 P( E0 V+ @2 q0 |  G                        pNewSvrAckPack = (ServerAckPacket*) realloc( pSvrAckPack, dwAllocSize );7 |9 N0 y( S+ e3 P+ T( k
                            if( NULL == pNewSvrAckPack ). U# q, o! p" I& G
                            {
    ; r. D1 }9 X6 j0 |$ M1 r1 m                            // Out of mem.  Cleanup and return
    & r1 R& l( K1 @" n                            free( pSvrAckPack );+ e  _% d% G6 }* [+ M/ ^; `
                                UnlockRange( minx, miny, maxx, maxy );
    ; B) T* y* Y! `9 D  Z4 r                            UnlockPlayerData( pFromPlayer );" Z% O. X# v# R% v. q0 ?' z/ N
                                return;       ; k2 Q5 ~! R  R$ e) m
                            }</P>
    0 s. i- F1 N; P4 i; t<P>                        pSvrAckPack = pNewSvrAckPack;2 `1 x3 f' D( t
                            pChunk = (PlayerStatePacket*) ((BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket) ) );</P>0 h9 Z+ j1 G/ k: s' x
    <P>                        // Make sure pChunk is still where its supposed to be' a6 Y/ D8 |! X5 Q/ O4 r
                            assert( (BYTE*) pChunk == (BYTE*) ((BYTE*)pSvrAckPack + sizeof(ServerAckPacket) + pSvrAckPack-&gt;wPlayerStatePacketCount*sizeof(PlayerStatePacket)) );+ j/ Q% e  l3 b
                        }</P>0 V# Q' O1 H& W  Q, T; j
    <P>                    pChunk-&gt;dwID       = pCurPlayerData-&gt;dwID;
    6 n: l2 y( R1 t                    pChunk-&gt;fX         = pCurPlayerData-&gt;fPosX;7 _  a4 ^/ f$ t2 t* E! \3 n
                        pChunk-&gt;fY         = pCurPlayerData-&gt;fPosY;
    ( E2 n  D- n. L9 `                    pChunk-&gt;aCameraYaw = pCurPlayerData-&gt;aCameraYaw;- R5 C# ]1 U. B
                        pChunk++;9 V- I, W, P' _8 A' ]
                        pSvrAckPack-&gt;wPlayerStatePacketCount++;
    ( ]& t  c# @- l& W                }
    9 w0 O. b1 X2 [8 w2 Q( u                pCurPlayerData = pCurPlayerData-&gt;pNextInCell;
    3 ^6 o" u) M' i# s            }; `6 V' s  U+ k+ }% a
            }
    - Q; ~% x3 w, t    }</P>8 J0 u; c  K9 ^- @% |5 b: e
    <P>    // Update the dwNumNearbyPlayers for this player
    * M" b; |; f6 d9 d- E    pFromPlayer-&gt;dwNumNearbyPlayers = pSvrAckPack-&gt;wPlayerStatePacketCount;</P>5 K' h1 E+ }7 ?# X. D$ [7 Q! v
    <P>    // Unlock range of cells
    % L8 v" [4 ?( m* G    UnlockRange( minx, miny, maxx, maxy );</P>: T& B3 e4 B( q7 q0 G4 {
    <P>    if( m_dwLogLevel &gt; 2 )
    % v! S% x0 F/ m    {
    5 a, ~+ @" Q) R" M% U! n+ C        ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );4 p" y2 p2 [0 L& ?! `
        }
    - p4 r5 j& n; o0 m, t0 i    else if( m_dwLogLevel == 2 )
    # d0 w; y* q" a* N! \- D/ @9 W# ?    {" G% W  m7 g3 V3 t/ w9 `& Z  A
            FLOAT fTime = DXUtil_Timer( TIMER_GETAPPTIME );
    . c: X+ \/ v( V; o! w        if( fTime - pFromPlayer-&gt;fLastDisplayTime &gt; 60.0f )9 I: h; z$ C( J; U; \  Y
            {8 D, Y  W4 f* T" q
                ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Position is (%0.2f,%0.2f)"), pFromPlayer-&gt;NetID, pFromPlayer-&gt;fPosX, pFromPlayer-&gt;fPosY );. l) q) C* s+ G
                pFromPlayer-&gt;fLastDisplayTime = fTime;
    % W  U+ [% A4 `( |/ X        }( Q9 q7 q& t( x  u2 [2 d, T& j
        }</P>
    / m1 ?( i7 j- G* p  o0 D0 k8 p<P>    // Unlock the playerdata
    ! U& O) {" G( q    UnlockPlayerData( pFromPlayer );</P>0 p, N$ Q: S- M8 s$ s
    <P>    // Send acknowledgement back to client, including list of nearby players % M$ H( U0 p+ p. {; }: |
        DWORD acksize = sizeof(ServerAckPacket) + (pSvrAckPack-&gt;wPlayerStatePacketCount * sizeof(PlayerStatePacket));
    : T) f& H; e$ U! j: |
    4 k5 C/ b! e) m) n3 q2 G$ Q$ P    // Pack the buffer with dummy data.% q3 ~* ]% X! H  a) [1 [8 a
        if(m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] &gt; 0): O' v) ^/ K1 {1 T/ N
        {$ V% O5 Z$ a- R$ U  g( b! X
            DWORD   dwBufferSize = acksize + m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex];
    1 c! `+ F8 i8 Q- l( z. Q% C        VOID*   pTempBuffer = 0;</P>
    , H3 b  I+ ~1 k<P>        pTempBuffer = malloc(dwBufferSize);3 E' e! f2 \+ Z6 R7 j  D
            if( NULL == pTempBuffer )9 X, k4 d. [5 x3 L6 D
            {& v5 e; q+ _. J: o" X
                //Out of memory  B! r: r! f/ g" ?9 X: l( w
                DXTRACE_ERR_NOMSGBOX( TEXT("System out of Memory!"), E_OUTOFMEMORY );
    % l+ m1 w( T2 N7 I0 H            free( pSvrAckPack );
    / N1 L. ?) k# A. Y% N- A# \            return;
    & k/ U1 d% q4 W        }</P>
    # w0 K2 R) K1 N: V7 a<P>        FillMemory(pTempBuffer, dwBufferSize, 'Z');
    - a9 P0 R% J3 w) m9 v# L        memcpy(pTempBuffer, pSvrAckPack, acksize);</P>
    $ p9 o* ]6 J  d( y) A" C/ a. l<P>        SendPacket( dwFrom, pTempBuffer, dwBufferSize, FALSE, m_dwServerTimeout );
    5 ^* J$ l9 X3 k   
    ) H. Q: T/ Y6 r4 T& c, K        free(pTempBuffer);; Y1 ]. W9 h4 O
        }   
    & n6 Q7 v1 Y9 x0 w( S- z    else2 b( M9 U: z- y' R$ ]0 k6 ?
        {
    4 h$ Z$ X8 M) F0 x5 W9 A3 K* ]# K$ _        SendPacket( dwFrom, pSvrAckPack, acksize, FALSE, m_dwServerTimeout );) i6 K  i0 w) Q
        }</P>" a) h0 [- @4 o5 D( H3 J1 [& t6 z) V
    <P>    free( pSvrAckPack );</P>
    4 g& d; J' x  ~2 M<P>}</P>
    4 x  I5 K3 s3 B2 g) m* R# }
    ( c' N& l/ z* [) \) `" b+ a<P>/ `3 `  E9 u) ~4 I3 u0 T
    //-----------------------------------------------------------------------------* w. M1 b/ e8 @1 `
    // Name: ; f: J4 x+ ]& v
    // Desc:
    $ J% `& R$ m0 I! x  k  @//-----------------------------------------------------------------------------. m/ Q; Q8 ]* C$ L) J0 m. O
    void CMazeServer::HandleClientVersionPacket( DWORD dwFrom, ClientVersionPacket* pClientVersionPack )
    7 ^; A( Z( u" U, Y{
    7 x8 }) T7 @8 x2 q    // Grab playerdata for this client and lock it
    6 F. g8 ~4 w! o2 A    PlayerData* pPlayerData = GetPlayerDataForID( dwFrom );
    1 l7 Y& k+ O7 ]$ I0 O  t    if( pPlayerData == NULL )
    8 w8 R9 {( ^6 [+ ^. ^        return;( f7 y  D" Y- m' d+ ]
        LockPlayerData( pPlayerData );</P>" w: \- ]3 `) q! O
    <P>    // Record the version number
    ) d0 ?  o5 h9 j3 b  p    pPlayerData-&gt;dwVersion = pClientVersionPack-&gt;dwVersion;</P>  k% M% E; L" G5 |
    <P>    if( m_bLocalLoopback )
    ' q* ?: h4 c" ~+ K5 V        pPlayerData-&gt;bAllow = TRUE;4 w' q. _$ ]: S& @. V# c6 V" Z
        else( R+ q+ q8 ~8 b' p2 b2 i
            pPlayerData-&gt;bAllow = IsClientVersionSupported( pClientVersionPack-&gt;dwVersion );</P>
    9 S' t" Y" S8 {# A, D( Y# U7 b# F! Y<P>    if( m_dwLogLevel &gt; 0 )4 ]6 G- I3 r9 `! d' O; I# @; y
            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>5 ]& p' }& X) j+ P, U
    <P>    if( FALSE == pPlayerData-&gt;bAllow ), G+ v7 x/ Q% u) W" V
        {* z& b1 Q7 _- U/ `1 n6 X
            if( m_dwLogLevel &gt; 0 )
    1 o5 C: }1 L8 Z7 E            ConsolePrintf( SLINE_LOG, TEXT("DPNID %0.8x: Rejecting client"), pPlayerData-&gt;NetID );</P>; X+ U8 D2 h* G9 C+ }, s
    <P>        m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );
    ( R  ~8 ]( P; t  a        UnlockPlayerData( pPlayerData );6 t2 S! @9 A1 I
            return;
    8 v0 j1 j% x# Y5 k  C! G4 i1 a0 n    }</P>) X, z; q4 e# b
    <P>    // Unlock the playerdata
    & Y8 T' K1 _/ R( O' T    UnlockPlayerData( pPlayerData );</P>
    $ ^' X6 o$ e1 h1 w0 f( O7 n5 U* n" @<P>    // Send acknowledgement to client that the client was either accepted or rejected. Z% @, u  ^4 a& f3 m
        ServerAckVersionPacket packet( pPlayerData-&gt;bAllow, dwFrom );
    1 r6 G) z9 T$ {/ @8 ?    SendPacket( dwFrom, &amp;packet, sizeof(packet), TRUE, 0 );- g" R$ D% F" l+ Y6 H; i" i
    }</P>. f5 q6 L* O2 g6 K
    ) e! n6 o' E9 _' P! f; y
    <P>
      t6 V" m& g2 O' s8 k//-----------------------------------------------------------------------------! @1 B* H8 Q- r5 l8 @, Q/ N
    // Name:
    # G: c" M, n  G2 x+ N- N// Desc: 2 I1 Z- c2 X9 s" c
    //-----------------------------------------------------------------------------
    0 ?" `' ]# q& ~+ Y! y( Y0 e1 z% NBOOL CMazeServer::IsClientVersionSupported( DWORD dwClientVersion )
    2 m! l0 X6 N2 F! I{/ `! S6 r0 q6 ~/ ^
        switch( dwClientVersion )
    0 x. z# ~/ {1 R# P+ O, F5 d% Y    {# x5 p( n- F% D: i) N& _& I0 `$ ?. E: X
            case 107: // only v107 is supported$ w( d4 z! ~! b; O9 s2 D8 H$ M
                return TRUE;) M6 N! `9 s1 [- x) K' b* R' _. o" I
            default:1 c2 u# F! o% t, F) c) v
                return FALSE;, y% x% j2 S! p, n
        }
    * \/ q$ l+ G; I- L" I; Y! e( p}</P>& u( J/ p8 h1 O' x

    ; q4 s! ?7 \& j0 y<P>4 n) T: y; D( j2 O4 u2 I3 K9 }
    //-----------------------------------------------------------------------------
    8 L: O+ |4 W9 D! m+ W+ u// Name:
    2 o, `: M1 F1 H# a% j// Desc: % N) z& i+ u& z9 ^$ A; T$ Q. {
    //-----------------------------------------------------------------------------+ P. v: r+ g! {9 D
    void CMazeServer::HandleUnknownPacket( DWORD dwFrom, ClientPacket* pClientPack, DWORD size )
    3 C% ], e  P" w& {% O, B{3 s  c% x, S  R
        if( m_dwLogLevel &gt; 1 )- ^" L7 Y1 {/ F# I) b+ K  w' O. x& x
            ConsolePrintf( SLINE_LOG, TEXT("ERROR! Unknown %d byte packet from player %0.8x"), size, dwFrom );</P>
    , \" c! \5 R9 L' f, b7 k8 k<P>    m_pNet-&gt;RejectClient( dwFrom, DISCONNNECT_REASON_CLIENT_OUT_OF_DATE );$ P* H! {5 f4 N8 y+ Q
    }</P>
    ( p: I( o* `, [: {+ E( N# _' i5 K# H4 F9 _% ^
    <P>+ g6 }! [- m) n' w" o# @
    //-----------------------------------------------------------------------------
    : P5 Z& y4 g& h2 R( \// Name: 7 ]2 I: P" S; l; n1 w
    // Desc:
    2 Y7 Q+ \* l9 S) ^//-----------------------------------------------------------------------------
    3 q3 \9 Y9 K( |5 E. R# `9 gDWORD   CMazeServer::IDHash( DWORD id )
    / ^  Q! O9 S. A* u, u! Z0 N{% Z) H1 f% P2 Z- t8 E+ ?/ l( l
        DWORD   hash = ((id) + (id&gt;&gt;8) + (id&gt;&gt;16) + (id&gt;&gt;24)) &amp; (NUM_ID_HASH_BUCKETS-1);! ^* S7 @, z3 E4 S& I+ V
        return hash;  J9 D9 Q. X( X2 [8 x
    }</P>) p# Q5 |- O6 z

    " u/ J0 ]* A1 j$ r<P>
    % c# }4 m4 X6 }) U//-----------------------------------------------------------------------------7 \, L. u" U# y. c
    // Name:
    . c6 d) e% R) `  W0 z// Desc:
    " g6 C6 p4 L0 P+ p//------------------------------------------------------------------------------ [( {( a( [* i: q' n, g
    void CMazeServer::RemovePlayerDataID( PlayerData* pPlayerData ); t+ U% _& `( r( r4 |1 L
    {- j* f: ^+ _+ ]( x
        // Hash the ID to a bucket number) c" ]0 t$ n/ E8 d: |8 d9 b% S
        DWORD   bucket = IDHash( pPlayerData-&gt;NetID );</P>
    . F  W8 U0 d& X/ p5 ~- U: ]( ~<P>    // Lock that hash bucket6 Y8 _: D, V+ y) g
        const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;& y7 e! C- p5 n7 o
        m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>* ^5 N3 z( D0 b; [8 j
    <P>    // Loop though players in bucket until we find the right one
      `/ a  ^0 K/ G6 h    PlayerData* pPt = m_pstIDHashBucket[bucket];6 U# j3 ?4 D& Q
        PlayerData* pPrev = NULL;9 h' E. `: f* @. [* Q; X8 O  s
        while( pPt )
    % g; s1 _1 ~8 D    {
    ( |6 ~4 y# N9 u; H; V        if( pPt == pPlayerData )' c; [9 g9 F* Q: N1 ^( |
                break;( [! d2 \+ a8 U; v2 p2 F+ T: t9 w
            pPrev = pPt;
    - M6 c1 c# z, C9 G4 D; ], z' O        pPt = pPt-&gt;pNextInIDHashBucket;. B- v8 z- G! q" ^
        }</P>+ _- }* C! p9 ~( F
    <P>    if( pPt )  W  z7 G7 m4 |! _7 |- I" Y
        {
    % w( i0 j& I: D( C$ ?% \        if( pPrev )) O; S$ }, }" Z; Y( ^$ r
                pPrev-&gt;pNextInIDHashBucket = pPt-&gt;pNextInIDHashBucket;0 ^+ h% f0 Q. e& p
            else) L$ a" M& e) `' g% r
                m_pstIDHashBucket[bucket] = pPt-&gt;pNextInIDHashBucket;
    , v- `4 B& l: l- G5 j2 {' m" T        pPt-&gt;pNextInIDHashBucket = NULL;* X' Q7 Y0 i" |2 Z
        }</P>
    % K5 [  U' _* L' ]5 r; k. x<P>    // Unlock the hash bucket
    , v/ F1 x, l6 |7 _" m    m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();1 S9 ?: V+ T+ h2 j. I, w$ f6 O, q
    }</P>
    5 \; f' w% z2 m
    ( A7 u( t6 U4 N9 `. ^; s8 ^<P>
    # O# c, N8 ]0 M( k# t  E" I) l//-----------------------------------------------------------------------------
    # M. ^/ P8 n0 K/ G4 e* E// Name:
    ) ?# W0 I: _; o7 U// Desc: + R5 }2 Q# s% U: ?) q) ?- B0 i
    //-----------------------------------------------------------------------------4 V" O# O% N+ M# ]
    void CMazeServer::SetPlayerDataForID( DWORD id, PlayerData* pPlayerData )
    - v/ @3 j- t% Q2 ]{) f1 V% ~5 _+ h% i  ^$ |% V2 d
        // Make sure this player isn't added twice to the m_pstIDHashBucket[]$ z0 V4 v2 ]% Z: @+ m6 V% W2 J
        // otherwise there will be a circular reference
    % J7 f8 j, y5 Y4 C    PlayerData* pSearch = GetPlayerDataForID( id );/ g, m! q, T" j3 ]2 t
        if( pSearch != NULL )% ~* Y" o: l9 }9 i- h: W
            return;</P>
      e2 X3 K4 W8 O9 E<P>    // Hash the ID to a bucket number
    4 c; ~& F- q9 X# _1 i" U    DWORD   bucket = IDHash( id );</P># K. ?2 f0 F. M. K, R, q7 q
    <P>    // Lock that hash bucket6 u3 @' o  q9 p* k( M
        const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;. Z" t0 b5 C; ]# M  N6 |
        m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
    6 I+ v5 \5 H+ f! l<P>    // Add player onto hash bucket chain) j0 K+ M$ h2 O% @9 X" v" Z
        pPlayerData-&gt;pNextInIDHashBucket = m_pstIDHashBucket[bucket];- Z0 w. p0 Y, Z4 E. _
        m_pstIDHashBucket[bucket] = pPlayerData;</P>" F+ J6 P; P$ o. _1 S; R# B) ]
    <P>    // Store net id in player' r# ^3 g, U( u" J: @; Z/ w% t
        pPlayerData-&gt;NetID = id;</P>6 X8 O4 H2 o7 _1 g: ^! u9 ~
    <P>    // Unlock the hash bucket/ d2 v  t0 Y+ r# J# T$ q
        m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();
    % J* l+ o; }! j3 ^# c}</P>
    7 U& {5 k* K% C8 G
    9 R- Z1 M$ }7 Q& s/ u, E<P>
    % {) g+ f4 h0 O' O$ p! L//-----------------------------------------------------------------------------* H5 s3 S3 c$ Y' V3 ?
    // Name:   o+ x: W1 u8 }* t# W, G/ ?
    // Desc:
    $ J: z; t, [/ W2 |8 }" d//------------------------------------------------------------------------------ _/ j$ [: a; K. Z- q$ u
    PlayerData* CMazeServer::GetPlayerDataForID( DWORD id )$ d' L  r" i& ^( K4 L
    {  e$ U7 Z5 x3 e+ ?3 Y: Z
        // Hash the ID to a bucket number
      ]* \1 i, f8 `3 O2 f2 A" ^' E. x$ e% B    DWORD   bucket = IDHash( id );</P>! F& m' m3 |2 u8 q
    <P>    // Lock that hash bucket5 c. k& h; Q5 d; {6 h7 p" t
        const   DWORD   buckets_per_lock = NUM_ID_HASH_BUCKETS / NUM_ID_HASH_BUCKET_LOCKS;
    2 f8 O- m. B+ a; x    m_IDHashBucketLocks[bucket/buckets_per_lock].Enter();</P>
    ) Q8 n2 b$ U* |# D7 J<P>    // Loop though players in bucket until we find the right one
    / ]/ g( X2 _" p6 G/ E    PlayerData* pPlayerData = m_pstIDHashBucket[bucket];! h5 ~$ `& ]6 p2 {0 }$ u8 c
        while ( pPlayerData )% N3 F1 x/ o4 o2 a. u% k; l
        {
    ; @/ d0 |8 v  F/ L2 w        if( pPlayerData-&gt;NetID == id )0 Q$ `4 G+ F8 ~* f$ f$ l
                break;
    " q, K8 h2 x5 a) z4 E9 i# u        pPlayerData = pPlayerData-&gt;pNextInIDHashBucket;
    ( m1 s! B( `1 q/ q: G    }</P>2 e1 R1 W) l8 f, s3 i% E
    <P>    // Unlock the hash bucket0 c# e" X; d. l0 K8 B6 b. m
        m_IDHashBucketLocks[bucket/buckets_per_lock].Leave();</P>
    / u" U$ q" R. t' @! }) [<P>    // Return the player we found (will be NULL if we couldn't find it)& d- f6 t+ H- g
        return pPlayerData;) \4 x. U" h( }. e
    }</P>
    ! v+ E/ Z5 H% H* x; t* A: y' {8 B+ j, h- r9 S& S6 F; ?
    <P>; a6 q! {7 O6 [
    //-----------------------------------------------------------------------------
    " u! J+ E- ^8 Z: |// Name:
    : o* Q3 J# O1 K& l6 A// Desc: calls DisplayConnectionInfo for each connection in a round-robin manner
    : K( p8 a$ ]+ _9 O0 y# s//-----------------------------------------------------------------------------5 H- k2 b$ w, @7 S* Q
    void CMazeServer:isplayNextConnectionInfo()/ C" g  H, L4 w! y$ K$ G
    {
    ' y* [( @4 o+ I8 t) }    if( m_pNet )
    $ U4 X5 \1 X. Q2 E) K    {9 B# t  q1 X: q  K) Y& z9 U# ~) @
            // Find the player that was displayed the longest time ago, and display it.! U9 I: S# u/ a; l
            FLOAT fCurTime = DXUtil_Timer( TIMER_GETAPPTIME );
    1 {" c1 j% x2 ?9 _% a        PlayerData* pOldestPlayerData = NULL;
    , R. }# w& q) L+ `8 V% ?; I( Y1 B) W        FLOAT fOldestTime = 0.0f;</P>- M8 w9 D1 F( Z6 M% J
    <P>        m_PlayerDataListLock.Enter();</P>6 w' R( C2 J3 W. H* W* \
    <P>        PlayerData* pPlayerData = m_pFirstActivePlayerData;
      B* T/ g* M' B( g        while ( pPlayerData )
    / O- X) I  Z& X+ F: e; H8 k        {6 e5 Q/ `! e& l- b- S
                if( fCurTime - pPlayerData-&gt;fLastCITime &gt; fOldestTime )
    9 L# B' `; x! Z! B  m            {
    % W8 n3 n3 u$ q8 s                fOldestTime  = fCurTime - pPlayerData-&gt;fLastCITime;
    ! U1 T, l* t$ t/ [1 Z( d  v, O                pOldestPlayerData = pPlayerData;6 {- X! J1 E6 ?- e- N2 G
                }</P>& ?4 T# r% Z- l2 X! j' T) [# a
    <P>            pPlayerData = pPlayerData-&gt;pNext;
    % T3 k5 z- v2 J        }</P>$ b4 w  E) N% J5 X
    <P>        // Display the player with the oldest CI field, and update its CI field.
    9 S* }- D: p1 A8 B3 a' F( P8 ~        if( pOldestPlayerData )/ t% U" W% C5 j/ c. S. Q- L
            {
    / B( F0 G$ y# C4 h            ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for next player") );
    / D6 Q# D5 J- l' D            DisplayConnectionInfo( pOldestPlayerData-&gt;NetID );; ^; x' l6 N( [  |( a
                pOldestPlayerData-&gt;fLastCITime = fCurTime;* A* S$ w# r$ g* r+ F1 P+ J
            }/ [4 Z8 U( G% B! [. _! u* |, H3 i
            else9 A  e& w5 e2 B7 P
            {
    ( O9 `3 Z* ^3 M1 i' x1 d7 P: X9 W            ConsolePrintf( SLINE_LOG, TEXT("No players found") );0 d/ U- Y* J3 t6 t5 J" ?
            }</P>- ^4 |) I1 q5 F
    <P>        m_PlayerDataListLock.Leave();4 B7 ]4 ]! I; n+ V
        }
    * `/ d" V: ]" L" Y) h}</P>
    0 J! z6 B/ e& N. i1 N' u+ L7 [/ x
    9 R& {+ ~8 h- T) O' _<P>
    $ `& s1 Y: e* B4 c/ |( r6 }8 x$ m//-----------------------------------------------------------------------------5 e' L1 d/ E% n, s% l# a- V
    // Name: $ H' A) I6 k- |8 N* p; B( e
    // Desc: + [* R, m" T; H9 k7 a
    //-----------------------------------------------------------------------------+ r& \" I% B6 _, Z0 k6 F
    void CMazeServer:rintStats()
    , f7 k6 G) P7 |6 e, U{( |; r% @' l" H4 _
        ConsolePrintf( SLINE_LOG, TEXT("Thread count: Active=%d Avg=%.2f Max=%d"), 4 I/ J+ r+ h+ K
                                        m_wActiveThreadCount, m_fAvgThreadCount, m_wMaxThreadCount );8 _7 {% {+ q) J5 f5 Z$ p
        ConsolePrintf( SLINE_LOG, TEXT("Thread Time: Avg=%.4f Max=%.4f(s)"),( |- s- Q; f# P2 `' ~" O  G! o
                                        m_fAvgThreadTime, m_fMaxThreadTime );$ D; I7 ]+ p- ~) x0 D
        ConsolePrintf( SLINE_LOG, TEXT("Players online (not including server player): %d"), m_dwPlayerCount );
    # l( _7 n5 G" ?4 @    ConsolePrintf( SLINE_LOG, TEXT("Peak player count: %d"), m_dwPeakPlayerCount );
    8 F3 m% ?  @3 z# B. }: |}</P>5 b6 P" S: m7 L, r8 K1 |& a& v

    4 T* `) J: q9 U/ B( G% @. @<P>
    4 k& ]1 l3 \4 N; i4 r, ?$ e//-----------------------------------------------------------------------------
    - ^" v: @- }9 q  A6 B. H; W// Name:
    , _( R& v, C+ M" H1 W4 x2 L// Desc:
    8 S3 c5 t9 K: ?/ b" H6 s2 y//-----------------------------------------------------------------------------( d2 J3 |1 Y( f! E0 O8 c
    void CMazeServer:isplayConnectionInfo( DWORD dwID )0 K8 u2 G! h! H4 N
    {7 I( [: ?& v8 v- H  A6 J* z" o
        TCHAR strInfo[5000];, |/ m3 U" \# {5 Q$ T" J4 S
        TCHAR* strEndOfLine;: R* D3 i2 R" A3 c
        TCHAR* strStartOfLine;</P>
    8 O! W5 f5 G% |+ S<P>    // Query the IOutboudNet for info about the connection to this user/ v# q* L# b' k+ x6 c
        m_pNet-&gt;GetConnectionInfo( dwID, strInfo );</P>* P- i; Z# x8 s+ G5 ?6 Z
    <P>    ConsolePrintf( SLINE_LOG, TEXT("Displaying connection info for %0.8x"), dwID );, x) J, _% O( {, v0 F+ n; Z' t
        ConsolePrintf( SLINE_LOG, TEXT("(Key: G=Guaranteed NG=Non-Guaranteed B=Bytes P=Packets)") );</P>
    " K1 ^+ E2 Q: Z; |) F$ n: f<P>    // Display each line seperately; T% S, P- E7 O4 q4 r( w4 z
        strStartOfLine = strInfo;
    ( P& U6 `* c2 q% Z/ _' K    while( TRUE )8 [: r2 Y$ e0 C. P$ S
        {
    / D5 H( o6 h4 E        strEndOfLine = _tcschr( strStartOfLine, '\n' );
    & i7 X+ d& f3 U0 M/ m        if( strEndOfLine == NULL )+ ]* R  M3 R" |5 [
                break;</P>6 e) K  w; E- G2 ]; Y2 [
    <P>        *strEndOfLine = 0;
    $ Q# R2 G- ~3 ~% z" x+ I; a        ConsolePrintf( SLINE_LOG, strStartOfLine );7 E; C- Q* ]0 L- U3 g
            strStartOfLine = strEndOfLine + 1;/ g& U' H& U1 ?$ f" K& p- a6 Y
        }
    ! q* M9 z; {( @! q! _7 L}</P>
    / j# ^' F) _  M6 v+ j  s
    % ^3 F) l: e1 `- _0 e$ u5 f9 b<P>
    / f. A2 u1 Y# B4 C- b2 l//-----------------------------------------------------------------------------
    % ?# W* W; s% N) ~9 X// Name:
    6 t; S4 s3 n, |6 q, }% x! ^// Desc: * M5 w, h+ H6 j2 `
    //-----------------------------------------------------------------------------7 n! @# P8 R% g9 L' i- n  n! {
    HRESULT CMazeServer::SendPacket( DWORD to, void* pData,
    ; Z9 i  d$ _. P! H                                 DWORD size, BOOL reliable, DWORD dwTimeout )
    ( n- D) I& f1 j' p8 C8 k6 x{5 t* y6 ], }, F6 Y9 S- b* b
        // Chance of forcing any packet to be delivered reliably& W4 h' B3 B% q; O9 B& L7 C" e8 d
        if( m_Rand.Get( 100 ) &lt; m_dwServerReliableRate ); [2 A* b  U& |
            reliable = TRUE;</P>
    6 l2 T2 X5 M/ a/ ?<P>    return m_pNet-&gt;SendPacket( to, pData, size, reliable, dwTimeout );
    + b* ^7 ]; i7 |}</P>
    , d& b0 @4 _, J  H5 a
    $ S& E0 Q4 z4 N<P>! y& F3 p6 f3 t7 F( M7 [3 q' W! [
    //-----------------------------------------------------------------------------* v2 [7 g7 `; r4 H* i! T
    // Name:
    9 I  m; r$ ]; v// Desc:
    6 C; u0 a9 E( u+ g4 d7 m2 X//-----------------------------------------------------------------------------$ R5 h! Z: w7 T2 v6 H! j% l
    void CMazeServer::SendConfigPacketToAll( ServerConfigPacket* pPacket )
    : ?# g. G8 G( ^  ?{7 l9 }) `$ K- \9 y; `
        // If we're up and running, then send this new information to all clients
    , ?2 D' i8 d' _( u7 w    if( m_pNet )
    3 B, j3 P' [) O( L5 @0 I  U    {+ R; v( [: P$ o" V# |( q# D
            //Use the AllPlayers ID% u. t7 d5 _% S0 v- m
            SendPacket( DPNID_ALL_PLAYERS_GROUP, pPacket, sizeof(ServerConfigPacket), TRUE, 0 );
      d- S0 ^2 O  [5 K5 _. j9 T- g- C' }    }9 [- V5 f. C& L2 H5 X: {# E2 {
    }</P>
    , |0 ?" u  F! R  o# c
    4 K* O# p! _8 D<P>, y: t; {  l! r% E5 Z! P7 P$ a
    //-----------------------------------------------------------------------------
    & \# n% ]% A7 m% A( y( A// Name: - m; \# M8 x  P: K+ _3 @5 k" s
    // Desc: 9 w; c1 s2 U, p
    //-----------------------------------------------------------------------------. F" L  u3 @6 g
    void CMazeServer::SetClientReliableRate( DWORD percent )
    ! p5 |# M) i. ?% f4 B$ k4 v2 u{
    ( l2 `3 x2 R, L) Z$ J    // Update client config, and build packet containing that data
    " |8 i5 v3 j1 E    m_ClientNetConfigLock.Enter();
    5 ]  n4 z. v2 f* a0 B    m_ClientNetConfig.ubReliableRate = BYTE(percent);
    # |3 y" C$ L, A0 W* ]    ServerConfigPacket packet( m_ClientNetConfig );+ {5 q" e) l( U
        m_ClientNetConfigLock.Leave();</P>
    " R2 v7 ]% H% `$ v- y" |<P>    SendConfigPacketToAll( &amp;packet );
    ; f4 \, E7 ~6 R$ r}</P>& @- d: ~5 o9 o" y2 Q. [+ e' h+ p
    2 k% m9 x; B% P' O( A+ Q' J
    <P>1 ?6 ?1 T: ?: A# f
    //-----------------------------------------------------------------------------
    - b& y( w5 }) L% T// Name:
    , O6 L1 a5 x2 i( y$ |4 D// Desc: - P- z) q3 G  l3 r" @9 }( @! ?
    //-----------------------------------------------------------------------------! C* B; c) s; R9 @, U
    void CMazeServer::SetClientUpdateRate( DWORD rate )/ q0 q; d, u  M- L( i
    {* y# i7 k8 u; b. u3 V
        // Update client config, and build packet containing that data
    ' O5 k6 B6 P4 u8 \. i/ i    m_ClientNetConfigLock.Enter();
      c: j8 A. o1 b5 a/ }$ j6 u    m_ClientNetConfig.wUpdateRate = WORD(rate);
    + Q6 i+ o3 ]7 k# w, A/ M! F    ServerConfigPacket  packet( m_ClientNetConfig );
    , B; g. l( a$ Y* a* d    m_ClientNetConfigLock.Leave();</P>
    4 c: \; l3 z% D0 X<P>    SendConfigPacketToAll( &amp;packet );* Z6 ]8 y* T( Y' _' v
    }</P>
    ( _2 x6 [$ {( x; f7 Y
    ( q3 d) F: t6 r6 K8 `<P>
    ; O! ^5 ]% ]5 D% [//-----------------------------------------------------------------------------9 ~+ R3 `' R. k/ n) n$ W
    // Name:
    % R7 r, p/ j8 Y# F% T// Desc:
    8 G8 O  N+ ]% w: @# C//-----------------------------------------------------------------------------
    & Q: m2 R, h7 i: @; w6 ivoid CMazeServer::SetClientTimeout( DWORD timeout )
    + V) p( z# A" B{
    $ L2 f3 Q0 c! t$ P0 g    // Update client config, and build packet containing that data
    ' j: T# a! E" Z1 \( w    m_ClientNetConfigLock.Enter();- n/ }) p9 B! t% \1 U- [
        m_ClientNetConfig.wTimeout = WORD(timeout);+ z: j7 w+ a; i  m5 G- E+ I( I
        ServerConfigPacket  packet( m_ClientNetConfig );
    7 y7 J* p- x% O- {" J/ z. F" @" @. e    m_ClientNetConfigLock.Leave();</P>
    0 m* e3 D9 c+ e4 ^<P>    SendConfigPacketToAll( &amp;packet );  v7 k$ \3 ^  q8 R, u+ ~
    }</P>
    ) D8 V5 Z$ p6 {8 J$ v' W
    9 `' F7 [1 m+ f; w<P>
      `# f/ E" ^: S& ?$ ~1 k5 k5 P//-----------------------------------------------------------------------------' ?  H6 D0 j! [3 A" X
    // Name:
    * t% m% J4 a( t2 r// Desc:
    % f: w& E: P+ H2 V/ R0 |% J& p//------------------------------------------------------------------------------ W. t) ^$ i2 z$ F$ [
    void CMazeServer::SetClientPackSize( DWORD size )
    1 F! d8 `# _( W) d! ]. O/ u$ B{" P5 f1 `3 Q. o" G; A
        // Update client config, and build packet containing that data
    1 t2 H* Z' ]" m% l6 ^* Q    m_ClientNetConfigLock.Enter();5 U+ m# y: e; m  y9 l' H
       
    ( c7 \2 J4 ?( S- L4 m- @: ]; z: z    m_ClientNetConfig.ubClientPackIndex++; //Increase index and verify location in array.
    + n$ Y6 N8 X: g7 p    if(m_ClientNetConfig.ubClientPackIndex &gt;= PACK_ARRAY_SIZE)   & X- a0 u; d3 {
            m_ClientNetConfig.ubClientPackIndex = 0;</P>
    : W5 O8 v  ^$ Z$ W<P>    m_ClientNetConfig.wClientPackSizeArray[m_ClientNetConfig.ubClientPackIndex] = WORD(size);  d; }2 A# Q- _4 b
        ServerConfigPacket packet( m_ClientNetConfig );( K* C$ Q9 p2 V+ l' l& _
        m_ClientNetConfigLock.Leave();</P>5 k5 Y- Z2 E, E6 \
    <P>    SendConfigPacketToAll( &amp;packet );
    , E% {# t8 ]4 i9 N+ d; }3 b- h}</P>6 o! t6 T8 A: N2 z
    5 S5 X) z/ n* t4 Z6 C+ y8 \
    <P>
    5 a: v+ s% O' a2 ]) H0 W//-----------------------------------------------------------------------------
    8 o. f0 v1 W  _( g// Name:
    / S! r7 x9 b/ ~! O+ A$ e! C// Desc:
    ; t8 O! Q5 I2 {  ]$ w) b6 ?  Q  I7 o//-----------------------------------------------------------------------------
    , v) q8 E7 D0 P. s0 D! v" }; ovoid CMazeServer::SetServerPackSize( DWORD size )8 G: a5 R7 }' z8 r; {* ~
    {
    . }$ M( U7 S9 b7 E( q: U3 P. b    // Update client config, and build packet containing that data
    8 q* q! ^& j$ l& K4 A    m_ClientNetConfigLock.Enter();
    6 o: E4 u# j/ s, `2 z   
    $ F' ]. j1 p1 x8 b0 \/ f    m_ClientNetConfig.ubServerPackIndex++; //Increase index and verify location in array.( p% O* W3 r; _# w' n6 F
        if(m_ClientNetConfig.ubServerPackIndex &gt;= PACK_ARRAY_SIZE)   
    ! _" k4 q$ P* h" c1 m2 R        m_ClientNetConfig.ubServerPackIndex = 0;</P>
    : x" D- k6 M8 C) t0 `3 h- {<P>    m_ClientNetConfig.wServerPackSizeArray[m_ClientNetConfig.ubServerPackIndex] = WORD(size);
    . g. o/ A- w. q; s3 J# N0 x( N. u5 F    ServerConfigPacket packet( m_ClientNetConfig );( k4 f) m8 }# N! m, [1 _
        m_ClientNetConfigLock.Leave();</P>
    1 X, k0 M1 E7 A1 |3 |<P>    SendConfigPacketToAll( &amp;packet );
    : [! R* G* b  R4 M}</P>
    8 |( t9 a- M0 l4 o# s& L<P>
    $ B& g. p& |( R0 M% N. A) ]( J//-----------------------------------------------------------------------------. ?* M  q: }3 A/ I$ k
    // Name:
    5 N' T8 h( |4 o, D; b6 E// Desc: . @& I4 n  Q3 C, R
    //-----------------------------------------------------------------------------3 Z3 F7 l( d+ y7 t0 u1 }4 E
    void CMazeServer::SetClientThreadWait( DWORD dwThreadWait )
    ) n; h3 s" u/ C1 i; \. f{; @' |9 {0 |' H; z2 Z4 {
        // Update client config, and build packet containing that data
    % Q, p; C- ?4 x# K7 z    m_ClientNetConfigLock.Enter();
    + Y' A8 q1 }+ }1 Q# O# p1 }, P    * {7 y* Y; w; U' G% e2 h- O( H( w, o
        m_ClientNetConfig.dwThreadWait = dwThreadWait;
    3 L( a; u/ N! p' v5 r# c  x6 j4 b" F    ServerConfigPacket packet( m_ClientNetConfig );
    # O9 d! b0 ~' |4 \* [' n5 \$ q    m_ClientNetConfigLock.Leave();</P>( {( U: C  T) V7 N- c; L" x
    <P>    SendConfigPacketToAll( &amp;packet );
      S8 e* h, y1 }4 z5 ~}</P></DIV>
    zan
    转播转播0 分享淘帖0 分享分享0 收藏收藏0 支持支持0 反对反对0 微信微信
    您需要登录后才可以回帖 登录 | 注册地址

    fastpost qq
    收缩
    • 电话咨询

    • 04714969085

    关于我们| 联系我们| 诚征英才| 对外合作| 产品服务| QQ

    手机版|Archiver| |繁體中文 手机客户端  

    蒙公网安备 15010502000194号

    Powered by Discuz! X2.5   © 2001-2013 数学建模网-数学中国 ( 蒙ICP备14002410号-3 蒙BBS备-0002号 )     论坛法律顾问:王兆丰

    GMT+8, 2026-11-23 06:18 , Processed in 0.217483 second(s), 51 queries .

    回顶部