#include <stdio.h>
#include <stdlib.h>
#include <memory>
#ifdef _WIN32
#include “jtianling.h”
#endif
using namespace std;

class CTest
{
    friend CTest foo(double);

public:
    CTest()
    {
       memset(array, 0, 100*sizeof(double));
    }
    // 以下面的语句决定是否进行NRV
    CTest(const CTest&t)
    {
       memcpy(this, &t, sizeof(CTest));
    }

private:
    double array[100];
};

CTest foo(double val)
{
    CTest local;

    local.array[0] = val;
    local.array[99] = val;

    return local;
}

int main(int argc, char* argv[])
{
#ifdef _WIN32
    double timenow = jtianling::GetTime();
#endif
    for(int i=0; i<10000000; ++i)
    {
       CTest t = foo(double(i));
    }

#ifdef _WIN32
    timenow = jtianling::GetTime() - timenow;

    cout <<timenow;
#endif
    system("pause");
    exit(0);
}

#include "jtianling.h"
#include <stdio.h>
#include <stdlib.h>
#include <memory>
using namespace std;

int gi = 1;
int gj = 1;

class CTest
{
    friend CTest foo(double);

public:
    CTest()
    {
       gj++;
       memset(array, 0, 100*sizeof(double));
    }

    //CTest(const CTest&t)
    //{
    //  gj++;
    //  memcpy(this, &t, sizeof(CTest));
    //}

    double array[100];
};

CTest foo(double val)
{
    CTest local;

    local.array[0] = val;
    local.array[99] = val;

    return local;
}

int main(int argc, char* argv[])
{
    double timenow = jtianling::GetTime();
    for(int i=0; i<10000000; ++i)
    {
       CTest t = foo(double(i));
       gi = t.array[99];
    }

    timenow = jtianling::GetTime() - timenow;

    cout <<timenow <<"/t" <<gi <<"/t" <<gj <<endl;

    system("pause");
    exit(0);
}

#undef  
max

#undef  
min

++SomeLocalA;

++ SomeLocalB;

++ SomeLocalC;

++ SomeLocalD;

++ SomeLocalE;

#define INCREMENT  
++SomeLocalA;/

++ SomeLocalB;/

++ SomeLocalC;/

++ SomeLocalD;/

++ SomeLocalE;

#define  
ASSERT assert

#define  
ASSERT

#define  
LOG_OUT(xxxxxxx)

#define  
LOG_OUT

//  
DECLARE_FIXED_ALLOC -- used in class definition

#define DECLARE_FIXED_ALLOC(class_name) /

public: /

    void* operator  
new(size_t size) /

    { /

       ASSERT(size == s_alloc.GetAllocSize()); /

       UNUSED(size); /

       return s_alloc.Alloc(); /

    } /

    void* operator  
new(size_t, void* p) /

       { return p; } /

    void operator  
delete(void* p) { s_alloc.Free(p); } /

    void* operator  
new(size_t size, LPCSTR, int) /

    { /

       ASSERT(size == s_alloc.GetAllocSize()); /

       UNUSED(size); /

       return s_alloc.Alloc(); /

    } /

protected: /

    static CFixedAlloc  
s_alloc /

//  
IMPLEMENT_FIXED_ALLOC -- used in class implementation file

#define IMPLEMENT_FIXED_ALLOC(class_name, block_size)  
/

CFixedAlloc class_name::s_alloc(sizeof(class_name), block_size)  
/

//  
DECLARE_FIXED_ALLOC -- used in class definition

#define DECLARE_FIXED_ALLOC_NOSYNC(class_name) /

public: /

    void* operator  
new(size_t size) /

    { /

       ASSERT(size == s_alloc.GetAllocSize()); /

       UNUSED(size); /

       return s_alloc.Alloc(); /

    } /

    void* operator  
new(size_t, void* p) /

       { return p; } /

    void operator  
delete(void* p) { s_alloc.Free(p); } /

    void* operator  
new(size_t size, LPCSTR, int) /

    { /

       ASSERT(size == s_alloc.GetAllocSize()); /

       UNUSED(size); /

       return s_alloc.Alloc(); /

    } /

protected: /

    static CFixedAllocNoSync  
s_alloc /

//  
IMPLEMENT_FIXED_ALLOC_NOSYNC -- used in class implementation file

#define IMPLEMENT_FIXED_ALLOC_NOSYNC(class_nbame, block_size)  
/

CFixedAllocNoSync class_name::s_alloc(sizeof(class_name), block_size)  
/

#else //!_DEBUG

#define DECLARE_FIXED_ALLOC(class_name) // nothing  
in debug

#define IMPLEMENT_FIXED_ALLOC(class_name, block_size)  
// nothing in debug

#define DECLARE_FIXED_ALLOC_NOSYNC(class_name) // nothing  
in debug

#define IMPLEMENT_FIXED_ALLOC_NOSYNC(class_name, block_size)  
// nothing in debug

#endif //!_DEBUG

#define Init(_CHECK) if(mp##_CHECK->Init())/

                  {/

                     mb##_CHECK = true;/

                  }

                  else

                  {/

                     LOG_OUT("Init" <<#_CHECK  
<<"failed" <<endl);/

               }

if (classname == “classa”)  
return new CClassA else if (classname == “classb”) return new CClassB else  
if........................

#define CEGUI_DECLARE_WINDOW_FACTORY(  
T )/

class T ## Factory : public WindowFactory/

{/

public:/

    T ##  
Factory() : WindowFactory(  
T::WidgetTypeName  
) {}/

    Window* createWindow(const  
String& name)/

    {/

        return new T (d_type, name);/

    }/

    void destroyWindow(Window*  
window)/

    {/

        delete window;/

    }/

};/

T ##  
Factory& get  
## T ## Factory();

/*!

/brief

    Generates code for the constructor for the  
instance of the window factory generated

    from the class name /a T

*/

// 

#define CEGUI_DEFINE_WINDOW_FACTORY(  
T )/

T ##  
Factory& get  
## T ## Factory()/

{/

    static T  
## Factory s_factory;/

    return s_factory;/

}

/*!

/brief

    Helper macro that return the real factory  
class name from a given class name /a T

*/

#define CEGUI_WINDOW_FACTORY(  
T ) (get ## T ## Factory())

template<typename T>
class Vector
{
public:
    explicit Vector(unsigned auInitSize  
= 0)
       : muSize(auInitSize),muCapacity(auInitSize \+ SPARE_CAPACITY)
    {
       mpObjects = new T[muCapacity];
    }

    Vector(const Vector &aoObject):mpObjects(0)
    {
       *this = aoObject;
    }

    ~Vector()
    {
       delete[] mpObjects;
    }

    const Vector&  
operator= (const  
Vector &aoObject)
    {
       if(this  
== &aoObject)
       {
           return *this;
       }
      
       delete[] mpObjects;
       muSize = aoObject.size();
       muCapacity = aoObject.capacity();

       mpObjects = new T[ capacity() ];

       for(unsigned  
i=0; i!=muSize; ++i)
       {
           mpObjects[i] = aoObject[i];
       }

       return *this;
    }

    void resize(unsigned auNewSize)
    {
       if ( auNewSize  
> muCapacity )
       {
           reserve(auNewSize * 2 + 1);
       }
    }

    void reserve(unsigned auNewCapacity)
    {
       if(auNewCapacity  
< muSize)
       {
           return;
       }

       T *lpOldArray  
= mpObjects;

       mpObjects = new T[auNewCapacity];
       for(unsigned  
i=0; i!=muSize; ++i)
       {
           mpObjects[i] = lpOldArray[i];
       }
      
       muCapacity = auNewCapacity;

       delete[] lpOldArray;
    }

    T& operator[](unsigned auIndex)
    {
       return mpObjects[auIndex];
    }

    const T&  
operator[](unsigned  
auIndex) const
    {
       return mpObjects[auIndex];
    }

    bool empty()  
const
    {
       return (muSize == 0);
    }

    unsigned size()  
const
    {
       return muSize;
    }

    unsigned capacity()  
const
    {
       return muCapacity;
    }

    void push_back(const T& aoObject)
    {
       if(muSize  
== muCapacity)
       {
           reserve(2 * muCapacity \+ 1);
       }

       mpObjects[muSize++] = aoObject;
    }

    void pop_back()
    {
       muSize\--;
    }

    const T&  
back() const
    {
       return mpObjects[muSize-1];
    }

    typedef T*  
iterator;
    typedef const  
T* const_iterator;

    iterator begin()
    {
       return mpObjects;
    }

    const_iterator begin() const
    {
       return mpObjects;
    }

    iterator end()
    {
       return mpObjects \+ muSize;
    }

    const_iterator end() const
    {
       return mpObjects \+ muSize;
    }

    enum { SPARE_CAPACITY  
= 16 };

private:
    unsigned muSize;
    unsigned muCapacity;
    T *mpObjects;
};

int main( void )
{
    int *lpi  
= new int[100];

    for(int  
i=0; i<100;  
++i)
    {
       printf("%d",lpi[i]);
    }

    return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <iterator>
#include <iostream>
using namespace std;

int randInt(int i, int j)
{
    if(i > j)
    {
        int temp = i;
        i = j;
        j = temp;
    }

    return rand() % (j-i) + i;
}

void randArr1(int arr[], int n)
{
    for(int i=0; i<n; ++i)
    {
        while(true)
        {
            // some thing don't like py
            // because my randInt is create number
            // in [0,n) and py is [0,n]
            int temp = randInt(0, n);
            int j = 0;
            while(j < i)
            {
                if(arr[j] == temp)
                {
                    break ;
                }
                ++j;
            }
            if(j == i)
            {
                arr[j] = temp;
                break ;
            }
        }
    }
}

void randArr2(int a[], int n)
{
    bool *lpb = new bool[n];
    memset(lpb, 0, n);

    for(int i=0; i<n; ++i)
    {
        while(true)
        {
            int temp = randInt(0, n);
            if(!lpb[temp])
            {
                a[i] = temp;
                lpb[temp] = true;
                break ;
            }
        }

    }

    delete lpb;
    lpb = NULL;
}

void swap(int & a, int & b)
{
    int temp = a;
    a = b;
    b = temp;
}

// just for fun,but I like it.
// when py could have range and bash could have seq
// why cpp couldn't have a seq like this? lol
template <typename T>
class CFBSeq
{
public :
    CFBSeq(const T& aValue) : mValue(aValue) { }

    T operator()()
    {
        return mValue++;
    }

private :
    T mValue;
};

void randArr3(int a[], int n)
{
    generate(a, a+n, CFBSeq<int >(0));

    for(int i=1; i<n; ++i)
    {
        swap(a[i], a[randInt(0,i)]);
    }

}

int main(int argc, char * argv[])
{
    const int TIMES=100;
    srand(time(NULL));
    int a[TIMES],b[TIMES],c[TIMES];
    randArr1(a,TIMES);
    copy(a, a+TIMES, ostream_iterator<int >(cout," "));
    printf("/n");
    randArr2(b,TIMES);
    copy(b, b+TIMES, ostream_iterator<int >(cout," "));
    printf("/n");
    randArr3(c, TIMES);
    copy(c, c+TIMES, ostream_iterator<int >(cout," "));

    exit(0);
}

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

**bool**  IsEven(**int**  x)
{
    **return**  (x % 2 == 0);
}

**long**  MyPow(**long**  x, **int**  n)
{
    **if**( 0 == n)
        **return** 1;
    **if**  ( IsEven(n))
        **return**  MyPow( x * x, n / 2);
    **else**
        **return**  MyPow( x * x, n / 2 ) * x;
}

**int**  main(**int**  argc, **char** * argv[])
{
    printf("pow(2,2)=%ld/n",MyPow(2,2));
    printf("pow(2,3)=%ld/n",MyPow(2,3));
    printf("pow(2,4)=%ld/n",MyPow(2,4));
    printf("pow(2,5)=%ld/n",MyPow(2,5));
    printf("pow(2,6)=%ld/n",MyPow(2,6));

    exit(0);
}

#include <stdio.h>
#include <stdlib.h>

**long**  gcd(**long**  m, **long**  n)
{
    **if**(m < n)
    {
        **long**  temp = m;
        m = n;
        n = temp;
    }
    **while**( n != 0)
    {
        **long**  rem = m % n;
        m = n;
        n = rem;
    }

    **return**  m;
}

**int**  main(**int**  argc, **char** * argv[])
{
    printf("gcd(1989,1590)=%ld/n",gcd(1989,1590));
    printf("gcd(1590,1989)=%ld/n",gcd(1590,1989));
    exit(0);
}

#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <iostream>
using  namespace  std;
template <typename  T>
int  binarySearch(const  vector<T> &a, const  T &x, int & aiTimes)
{
    int  low = 0;
    int  high = a.size() - 1;

    while(low <= high)
    {
        ++aiTimes;
        int mid = (low + high) / 2;
        
        if(a[mid] < x)
        {
            low = mid + 1;
        }
        else  if(a[mid] > x)
        {
            high = mid - 1;
        }
        else
        {
            return  mid;
        }
    }

    return  -1;
}

int  main(int  argc, char * argv[])
{
    vector<int > lveci;
    lveci.resize(100);
    for(int  i = 0; i < 100; ++i)
    {
        lveci[i] = i;
    }

    int  liTimes = 0;
    cout << binarySearch(lveci, -1, liTimes);
    cout <<"/tcost:" <<liTimes <<endl;
    liTimes = 0;
    cout << binarySearch(lveci, 0, liTimes);
    cout <<"/tcost:" <<liTimes <<endl;
    liTimes = 0;
    cout << binarySearch(lveci, 1, liTimes);
    cout <<"/tcost:" <<liTimes <<endl;
    liTimes = 0;
    cout << binarySearch(lveci, 2, liTimes);
    cout <<"/tcost:" <<liTimes <<endl;
    liTimes = 0;
    cout << binarySearch(lveci, 100, liTimes);
    cout <<"/tcost:"<<liTimes <<endl;



    exit(0);
}

// Maximum contiguous subsequence sum algorithm 1 - 4, worst to best
// From <<Data Structures and Algorithm Analysis in C++>> by Mark Allen Weiss
#include <stdio.h>
#include <stdlib.h>
#include <vector>
**using**  **namespace**  std;

**int**  maxSubSum1(
**const**  vector<**int** > &a)
{
    **int**  maxSum = 0;

    **for**(**int**  i=0; i<(**int**)a.size(); ++i)
        **for**(**int**  j=i; j<(**int**)a.size(); ++j)
        {
            **int**  thisSum = 0;

            **for**(**int**  k=i; k<=j; ++k)
                thisSum += a[k];

            **if**(thisSum > maxSum)
                maxSum = thisSum;
        }
    **return**  maxSum;
}

**int**  maxSubSum2(
**const**  vector<**int** > &a)
{
    **int**  maxSum = 0;

    **for**(**int**  i=0; i<(**int**)a.size(); ++i)
    {
        **int**  thisSum = 0;
        **for**(**int**  j=i; j<(**int**)a.size(); ++j)
        {
            thisSum += a[j];

            **if**( thisSum > maxSum)
                maxSum = thisSum;
        }
    }
    **return**  maxSum;
}

**int**  max3(**int**  a, **int**  b, **int**  c)
{
    **return**  ((a < b)?((b < c)?c:b):((a < c)?c:a));
}

**int**  maxSumRec(
**const**  vector<**int** > &a, **int**  left, **int**  right)
{
    **if**(left == right)
        **if**( a[left] > 0)
            **return**  a[left];
        **else**
            **return**  0;

    **int**  center = (left + right) / 2;
    **int**  maxLeftSum = maxSumRec(a, left, center);
    **int**  maxRightSum = maxSumRec(a, center + 1, right);

    **int**  maxLeftBorderSum = 0;
    **int**  leftBorderSum = 0;

    **for**(**int**  i=center; i >=left; --i)
    {
        leftBorderSum += a[i];
        **if**(leftBorderSum > maxLeftBorderSum)
            maxLeftBorderSum = leftBorderSum;
    }

    **int**  maxRightBorderSum = 0,rightBorderSum = 0;
    **for**(**int**  j = center + 1; j <= right; ++j)
    {
        rightBorderSum += a[j];
        **if**(rightBorderSum > maxRightBorderSum)
            maxRightBorderSum = rightBorderSum;
    }

    **return**  max3(maxLeftSum, maxRightSum, maxLeftBorderSum + maxRightBorderSum);
}

**int**  maxSubSum3(**const**  vector<**int** > &a)
{
    **return**  maxSumRec(a, 0, a.size() - 1);
}

**int**  maxSubSum4(
**const**  vector<**int** > &a)
{
    **int**  maxSum = 0, thisSum = 0;

    **for**( **int**  j = 0; j< (**int**)a.size(); ++j)
    {
        thisSum += a[j];

        **if**(thisSum > maxSum)
            maxSum = thisSum;
        **else**  **if**(thisSum < 0)
            thisSum = 0;
    }

    **return**  maxSum;
}

**int**  main(**int**  argc, **char** * argv[])
{
    // for easy
    **int**  a[] = { -2, 11, -4, 13, -5, -2};
    vector<**int** > lvec(a, a + **sizeof**(a)/**sizeof**(**int**));

    printf("maxSubSum1(lvec)):%d/n",maxSubSum1(lvec));
    printf("maxSubSum2(lvec)):%d/n",maxSubSum2(lvec));
    printf("maxSubSum3(lvec)):%d/n",maxSubSum3(lvec));
    printf("maxSubSum4(lvec)):%d/n",maxSubSum4(lvec));

    exit(0);
}

class CMyApp : public CWinApp

{

public:

    virtual BOOL  
InitInstance();

};

 

class CMainWindow : public CMultiMouseWindow

{

protected:

    enum gridState  
{ Unputed, PutedWhite,  
PutedBlack};   //enum格子的个状态

    enum Turn  
{blackTurn,whiteTurn};   //enum轮到谁下的状态

    enum winnerLast  
{NoOne,WhiteWin,BlackWin};    //enum有没有胜利者的状态

    Turn m_nextTurn;  //下轮执棋者

    const static  
int nClientSize  
= 700;    //客户区大小，可改变

    const static  
int nGridNum  
= 20;    //格数，可改变

    int m_countStep;  //目前所下步数

    void DrawBoard(CDC &dc); //画棋盘

    CRect m_rcGrid[nGridNum][nGridNum];    //棋盘的每个格子的矩形范围

    gridState m_stateGrid[nGridNum][nGridNum];    //棋盘每个格子的状态

    void DrawWhite(CDC &dc,int i,int j);   //下White

    void DrawBlack(CDC &dc,int i,int j);   //下Black

    void ResetGame(); //重新开始游戏

    void CheckForGameOver(Turn thisTurn,int i,int j); //查找需不需要结束游戏

    BOOL IsWinner(Turn thisTurn,int i,int j); //是否有胜利者

    BOOL IsDraw();    //是否平局

 

public:

    CMainWindow();

protected:

    afx_msg void OnPaint();

    afx_msg void OnLButtonDown(UINT nFlags,CPoint point);

    afx_msg void OnNcLButtonDblClk(UINT nHitTest,CPoint point);

    DECLARE_MESSAGE_MAP()

};

#include <afxwin.h>

#include <cmath>

#include <memory>

#include "MultiMouseWindow.h"

#include "resource.h"

#include "gobang.h"

 

CMyApp myApp;

//

//CMyApp的成员函数

//

BOOL CMyApp::InitInstance()

{

    m_pMainWnd = new CMainWindow;

    m_pMainWnd->ShowWindow(m_nCmdShow);

    m_pMainWnd->UpdateWindow();

    return TRUE;

}

//

//CMainWindow的消息映射和成员函数定义

//

BEGIN_MESSAGE_MAP(CMainWindow,CFrameWnd)

    ON_WM_PAINT()

    ON_WM_LBUTTONDOWN()

    ON_WM_NCLBUTTONDBLCLK()

END_MESSAGE_MAP()

 

 

CMainWindow::CMainWindow()

{

    //执黑的先下棋，并定下窗口固定宽度

    CString wndClassStr = ::AfxRegisterWndClass(CS_DBLCLKS);

    Create(wndClassStr,_T("两鼠标五子棋by九天雁翎       (双击标题栏重新开始游戏）"),

       WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION  
| WS_MINIMIZEBOX);

    CRect rect(0,0,nClientSize+2,nClientSize+2);

    CalcWindowRect(&rect);

    SetWindowPos(NULL,0,0,rect.Width(),rect.Height(),

       SWP_NOZORDER | SWP_NOMOVE | SWP_NOREDRAW);

    m_hiconCursor[1] = LoadIcon(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDI_CURSOR));

    m_hiconCursor[2] = LoadIcon(AfxGetInstanceHandle(),MAKEINTRESOURCE(IDI_CURSOR2));

    //初始化自定义的成员变量

    m_nextTurn = whiteTurn;

    m_countStep = 0;

   

    if(m_nMouseNumber  
!= 3)

    {

       MessageBox(_T("请插入个鼠标"));

       PostQuitMessage (0);

 

    }

    ::ZeroMemory(m_rcGrid,nGridNum  
* nGridNum * sizeof(CRect));

    ::ZeroMemory(m_stateGrid,nGridNum  
* nGridNum * sizeof(gridState));

   

 

 

 

}

 

void CMainWindow::OnPaint()

{

    CPaintDC dc(this);

    DrawBoard(dc);

    DrawMultiCursor();

}

 

void CMainWindow::DrawBoard(CDC  
&dc)

{

    CRect rect;

    GetClientRect(&rect);

 

    //画背景

    CBrush brush(RGB(198,130,66));

    dc.FillRect(rect,&brush);

 

//开始画纵横线，利用rect大小来画线，一是代码重用度高，二是以前做好了

//效率稍微低点，不过将来要是改变客户区大小或用可缩放窗口就可以不改了

   

    //定义画线的画笔并选中

    CPen pen(PS_SOLID,2,RGB(0,0,0));

    CPen *pOldPen  
= dc.SelectObject(&pen);

 

    //求方格宽高

    int nGridWidth  
= nClientSize / nGridNum  ; 

    int nGridHeight  
= nClientSize / nGridNum  
;

   

 

    //计算每个方格矩形范围

    for(int  
i = 0; i  
< nGridNum; ++i)

       for(int  
j = 0; j  
< nGridNum; ++j)

       {

           m_rcGrid[i][j] = CRect(rect.left \+ (nGridWidth  
* j),

                               rect.top \+ (nGridHeight * i),

                               rect.left \+ nGridWidth +(nGridWidth  
* j),

                               rect.top \+ nGridHeight \+ (nGridHeight  
* i));

       }

 

 

    for(int  
i = 0; i  
<= nGridNum; ++i)   //画横线

    {

       int y  
= (nGridHeight * i)  
\+ rect.top;

       dc.MoveTo(rect.left,y);

       dc.LineTo(rect.right,y);

    }

 

    for(int  
i = 0; i  
<= nGridNum; ++i)   //画竖线

    {

       int x  
= (nGridWidth * i)  
\+ rect.left;

       dc.MoveTo(x,rect.top);

       dc.LineTo(x,rect.bottom);

    }

 

    //画下已经下好的棋

 

    for(int  
i=0; i<nGridNum; ++i)

       for(int  
j=0; j<nGridNum; ++j)

       {

           if(m_stateGrid[i][j] == Unputed)

           {

              continue;

           }

           else if(m_stateGrid[i][j] == PutedWhite)

           {

              DrawWhite(dc,i,j);

           }

           else if(m_stateGrid[i][j] == PutedBlack)

           {

              DrawBlack(dc,i,j);

           }

       }

 

}

 

//左键下黑

void CMainWindow::OnLButtonDown(UINT  
nFlags, CPoint  
point)

{

    if(m_pSiRawMouse[1].usButtonFlags & RI_MOUSE_LEFT_BUTTON_DOWN)

    {

           //若本轮不属黑，即不响应

       if(m_nextTurn  
!= blackTurn)

           return;

       for(int  
i = 0; i<nGridNum; ++i)

           for(int j = 0; j<nGridNum;  
++j)

           {

              CPoint pt(m_pSiRawMouse[1].X,m_pSiRawMouse[1].Y);

              ScreenToClient(&pt);

              if(m_rcGrid[i][j].PtInRect(pt) && m_stateGrid[i][j] == Unputed)

              {

                  CClientDC dc(this);

                  m_nextTurn = whiteTurn;

                  m_stateGrid[i][j] = PutedBlack;

                  DrawBlack(dc,i,j);

                  CheckForGameOver(blackTurn,i,j);

              }

           }

      

       m_pSiRawMouse[1].usButtonFlags &= ~RI_MOUSE_LEFT_BUTTON_DOWN;

 

    }

    if(m_pSiRawMouse[2].usButtonFlags & RI_MOUSE_LEFT_BUTTON_DOWN)

    {

           //若本轮不属白，即不响应

       if(m_nextTurn  
!= whiteTurn)

           return;

       for(int  
i = 0; i<nGridNum; ++i)

           for(int j = 0; j<nGridNum;  
++j)

           {

              CPoint pt(m_pSiRawMouse[2].X,m_pSiRawMouse[2].Y);

              ScreenToClient(&pt);

              if(m_rcGrid[i][j].PtInRect(pt) && m_stateGrid[i][j] == Unputed)

              {

                  CClientDC dc(this);

                  m_nextTurn = blackTurn;

                  m_stateGrid[i][j] = PutedWhite;

                  DrawWhite(dc,i,j);

                  ++m_countStep;

                  CheckForGameOver(whiteTurn,i,j);

              }

           }

      

       m_pSiRawMouse[2].usButtonFlags &= ~RI_MOUSE_LEFT_BUTTON_DOWN;

    }

 

}

 

void CMainWindow::DrawBlack(CDC  
&dc, int  
i, int j)

{

    CRect rect(m_rcGrid[i][j]);

    rect.DeflateRect(1,1);

    dc.SelectStockObject(BLACK_BRUSH);

    dc.Ellipse(rect);

}

 

void CMainWindow::DrawWhite(CDC  
&dc, int  
i, int j)

{

    CRect rect(m_rcGrid[i][j]);

    rect.DeflateRect(1,1);

    dc.SelectStockObject(WHITE_BRUSH);

    dc.Ellipse(rect);

 

}

 

void CMainWindow::CheckForGameOver(Turn  
thisTurn,int  
i,int j)

{

    if(IsWinner(thisTurn,i,j))

    {

       if(thisTurn  
== blackTurn)

       {

           CString string;

           string.Format(_T("GOOD! Black Wins in %d steps."),m_countStep);

           MessageBox(string,_T("Game Over!"));

           ResetGame();

       }

       else if(thisTurn == whiteTurn)

       {

           CString string;

           string.Format(_T("GOOD! White Wins in %d steps."),m_countStep);

           MessageBox(string,_T("Game Over!"));

           ResetGame();

       }

      

    }

    else if(IsDraw())

    {

       MessageBox(_T("OK,It's  
draw."),_T("Draw Game!"));

       ResetGame();

    }

 

}

 

//此为本软件最主要的部分，即检测是否有五个棋连在一起

//以横纵和两条对角线的方向分别检测，感觉比较笨

//暂时不知道有没有更好的办法，望来信赐教

BOOL CMainWindow::IsWinner(Turn thisTurn,int i,int j)

{

    int count  
= 1;

    gridState checkFor; //状态对比值

    if(thisTurn  
== blackTurn)

       checkFor = PutedBlack;

    else if(thisTurn == whiteTurn)

       checkFor = PutedWhite;

 

    //横方向检测

    for(int  
m=1; m<5;  
++m)

    {

       if(j  
\- m > 0 && m_stateGrid[i][j-m] == checkFor)

           ++count;

       else

           break;

    }

    for(int  
m=1; m<5;  
++m)

    {

       if(j  
\+ m < nGridNum  
&& m_stateGrid[i][j+m] == checkFor)

           ++count;

       else

           break;

    }

    if(count  
>=5)

       return TRUE;

    count = 1;

 

    //竖方向检测

    for(int  
m=1; m<5;  
++m)

    {

       if(i-m>0 && m_stateGrid[i-m][j] == checkFor)

           ++count;

       else

           break;

    }

    for(int  
m=1; m<5;  
++m)

    {

       if(i+m<nGridNum  
&& m_stateGrid[i+m][j] == checkFor)

           ++count;

       else

           break;

    }

    if(count  
>=5)

       return TRUE;

    count = 1;

 

    //左上至右下方向检测

    for(int  
m=1; m<5;  
++m)

    {

       if(i-m>0 && j-m>0 && m_stateGrid[i-m][j-m] == checkFor)

           ++count;

       else

           break;

    }

    for(int  
m=1; m<5;  
++m)

    {

       if(i+m<nGridNum  
&& j+m<nGridNum && m_stateGrid[i+m][j+j] == checkFor)

           ++count;

       else

           break;

    }

    if(count  
>=5)

       return TRUE;

    count = 1;

 

    //右上至左下方向检测

    for(int  
m=1; m<5;  
++m)

    {

       if(i-m>0 && j+m<nGridNum  
&& m_stateGrid[i-m][j+m] == checkFor)

           ++count;

       else

           break;

    }

    for(int  
m=1; m<5;  
++m)

    {

       if(i+m<nGridNum  
&& j-m>0  
&& m_stateGrid[i+m][j-m] == checkFor)

           ++count;

       else

           break;

    }

    if(count  
>=5)

       return TRUE;

    return FALSE;

}

 

//BOOL  
CMainWindow::OnSetCursor(CWnd *pWnd, UINT nHitTest, UINT message)

//{

//  if(nHitTest == HTCLIENT)

//  {

//     if(m_nextTurn == blackTurn)

//     {

//         ::SetCursor(::AfxGetApp()->LoadCursor(IDC_black));

//         return TRUE;

//     }

//     else if(m_nextTurn == whiteTurn)

//     {

//         ::SetCursor(::AfxGetApp()->LoadCursor(IDC_white));

//         return TRUE;

//     }

//  }

//  return  
CFrameWnd::OnSetCursor(pWnd,nHitTest,message);

//}

 

//当都下满了，即为平局

BOOL CMainWindow::IsDraw()

{

    int i,j;

    for(i=0;  
i<nGridNum;  
++i)

       for(j=0;  
j<nGridNum;  
++j)

       {

           if(m_stateGrid[i][j]==Unputed)

              break;

       }

    if(i==nGridNum && j==nGridNum)

       return TRUE;

    else

       return FALSE;

}

 

void CMainWindow::ResetGame()

{

    m_nextTurn = whiteTurn;

    m_countStep = 0;

    ::ZeroMemory(m_stateGrid,nGridNum  
* nGridNum * sizeof(gridState));

    Invalidate();

}

 

void CMainWindow::OnNcLButtonDblClk(UINT  
nHitTest, CPoint  
point)

{

    if(nHitTest  
== HTCAPTION)

    {

       ResetGame();

    }

 

    return CFrameWnd::OnNcLButtonDblClk(nHitTest,point);

}