thdcalcq.cpp

八皇后问题

//---------------------------------------------------------------------------

#include <vcl.h>
#pragma hdrstop

#include "thdCalcQ.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------

//   Important: Methods and properties of objects in VCL can only be
//   used in a method called using Synchronize, for example:
//
//      Synchronize(UpdateCaption);
//
//   where UpdateCaption could look like:
//
//      void __fastcall TthdCalc::UpdateCaption()
//      {
//        Form1->Caption = "Updated in a thread";
//      }
//---------------------------------------------------------------------------

__fastcall TthdCalc::TthdCalc(bool CreateSuspended)
    : TThread(CreateSuspended)
{
    FreeOnTerminate = true;

    PAnimate = frmQueen->chkAnimation->Checked;
    ErrAnimate = frmQueen->chkError->Checked;
    AniSpeed = frmQueen->tbSpeed->Position * 100;
    Queens.SetFQueen(frmQueen->Queens.GetFQueen(),frmQueen->Queens.GetFQueenPos());

    AnsiString AppPath = ExtractFilePath(Application->ExeName)+"BitMaps\\";

    WQueen = new TPicture;
    GQueen = new TPicture;
    WErrQ  = new TPicture;
    GErrQ  = new TPicture;
    WPoint = new TPicture;
    GPoint = new TPicture;
    
    WQueen->LoadFromFile(AppPath+"WQueen.bmp");
    GQueen->LoadFromFile(AppPath+"GQueen.bmp");
    WErrQ->LoadFromFile(AppPath+"WErrQ.bmp");
    GErrQ->LoadFromFile(AppPath+"GErrQ.bmp");
    WPoint->LoadFromFile(AppPath+"WPoint.bmp");
    GPoint->LoadFromFile(AppPath+"GPoint.bmp");
}
//---------------------------------------------------------------------------
void __fastcall TthdCalc::OnTerminate()
{   
    delete WQueen;
    delete GQueen;
    delete WErrQ;
    delete GErrQ;
    delete WPoint;
    delete GPoint;
}
//---------------------------------------------------------------------------
void __fastcall TthdCalc::Execute()
{
    QPoint CurQ;

    if(Queens.GetFQueenPos() == 1)
        CurQ = TellGrid(1,IMGLEN+1);
    else
        CurQ = TellGrid(1,1);

    while(!Queens.isFull())
    {
        Queens.PushQueen(CurQ);
        

        if(PAnimate)
        {
            PutChessMan(CurQ,QUEEN);
            Sleep(200);
        }

        QPoint temp = Queens.InLine();

        if(temp.ColPos == -1)
        {
            CurQ = TellGrid(1,(CurQ.Y+IMGLEN+1));

            if(CurQ.Y == Queens.GetFQueen().Y)
                CurQ = TellGrid(1,CurQ.Y+IMGLEN+1);
        }
        else
        {
            if(PAnimate && ErrAnimate)
                AnimateError(temp,CurQ);

            do
            {
                CurQ = Queens.PopQueen();

				if(CurQ.ColPos == -1)
				{
					Synchronize(EnableNewQueen);

					return;
				}
				else
				{
					CurQ.ColPos++;

                    if(PAnimate)
                    {
					    TRect rect;
					    rect.Left   = CurQ.X;
					    rect.Top    = CurQ.Y;
					    rect.Right  = rect.Left + IMGLEN;
					    rect.Bottom = rect.Top  + IMGLEN;

                        frmQueen->pbBoard->Canvas->Lock();
					    frmQueen->pbBoard->Canvas->Brush->Color = CurQ.COLOR;
					    frmQueen->pbBoard->Canvas->FillRect(rect);
                        frmQueen->pbBoard->Update();
                        frmQueen->pbBoard->Canvas->Unlock();
                    }
				}
            }
            while(CurQ.ColPos == GRIDCOUNT);

            CurQ = TellGrid(CurQ.X+IMGLEN+1,CurQ.Y);

            if(PAnimate)
                Synchronize(ShowChessMan);
        }
    }

    Synchronize(ShowChessMan);
    Synchronize(CopyQueens);
    Synchronize(EnableNewQueen);
    MessageBox(frmQueen->Handle,"皇后摆完了！","提示",MB_ICONASTERISK);
}
//---------------------------------------------------------------------------
QPoint __fastcall TthdCalc::TellGrid(const int X,const int Y)
{
    QPoint Grid;

    for(int i=0;i<GRIDCOUNT;++i)
    {
        for(int j=0;j<GRIDCOUNT;++j)
        {
            int gLeft   = i*(IMGLEN+1);
            int gTop    = j*(IMGLEN+1);
            int gRight  = (i+1)*(IMGLEN+1);
            int gBottom = (j+1)*(IMGLEN+1);

            if(X>=gLeft && X<gRight && Y>=gTop && Y<gBottom)
            {
                Grid.X = gLeft+1;
                Grid.Y = gTop+1;
                Grid.ColPos = i;

                if((i%2) == (j%2))
                    Grid.COLOR = clGreen;
                else
                    Grid.COLOR = clWhite;

                return Grid;
            }
        }
    }

    return Grid;
}
//---------------------------------------------------------------------------
void __fastcall TthdCalc::PutChessMan(const QPoint &Grid,const QImage myImage,bool isQ)
{
    TGraphic *Image;

    switch(myImage)
    {
    case QUEEN:
        {
            if(Grid.COLOR == clWhite)
                Image = WQueen->Graphic;
            else
                Image = GQueen->Graphic;

            break;
        }
    case ERRQUEEN:
        {
            if(Grid.COLOR == clWhite)
                Image = WErrQ->Graphic;
            else
                Image = GErrQ->Graphic;

            break;
        }
    case QPOINT:
        {
            if(Grid.COLOR == clWhite)
                Image = WPoint->Graphic;
            else
                Image = GPoint->Graphic;

            break;
        }
    }

    frmQueen->pbBoard->Canvas->Lock();
    frmQueen->pbBoard->Canvas->Draw(Grid.X,Grid.Y,Image);
    frmQueen->pbBoard->Canvas->Unlock();

    if(isQ)
    {
        frmQueen->pbBoard->Canvas->Lock();
        frmQueen->pbBoard->Canvas->Pen->Color = clRed;
        frmQueen->pbBoard->Canvas->MoveTo(Grid.X+1,Grid.Y+1);
        frmQueen->pbBoard->Canvas->LineTo(Grid.X+IMGLEN-1,Grid.Y+1);
        frmQueen->pbBoard->Canvas->LineTo(Grid.X+IMGLEN-1,Grid.Y+IMGLEN-1);
        frmQueen->pbBoard->Canvas->LineTo(Grid.X+1,Grid.Y+IMGLEN-1);
        frmQueen->pbBoard->Canvas->LineTo(Grid.X+1,Grid.Y+1);
        frmQueen->pbBoard->Canvas->Unlock();
    }

    frmQueen->pbBoard->Canvas->Lock();
    frmQueen->pbBoard->Update();  
    frmQueen->pbBoard->Canvas->Unlock();
}
//---------------------------------------------------------------------------
void __fastcall TthdCalc::AnimateError(const QPoint &FromGrid,const QPoint &ToGrid)
{
    QPoint Grid = FromGrid;

    if(FromGrid.X == ToGrid.X)
    {
        if(FromGrid.Y < ToGrid.Y)
        {
            Grid.Y += IMGLEN + 1;
            Grid.COLOR = Grid.COLOR==clGreen?clWhite:clGreen;

            while(Grid.Y != ToGrid.Y)
            {
                PutChessMan(Grid,QPOINT);
                Grid.Y += IMGLEN + 1;
                Grid.COLOR = Grid.COLOR==clGreen?clWhite:clGreen;
                Sleep(AniSpeed);
            }

            TRect rect;
            rect.Left   = ToGrid.X;
            rect.Top    = ToGrid.Y;
            rect.Right  = rect.Left + IMGLEN;
            rect.Bottom = rect.Top  + IMGLEN;

            frmQueen->pbBoard->Canvas->Lock();
            frmQueen->pbBoard->Canvas->Brush->Color = ToGrid.COLOR;
            frmQueen->pbBoard->Canvas->Unlock();

            for(int i=0;i<2;++i)
            {
                PutChessMan(ToGrid,ERRQUEEN);
                Sleep(AniSpeed);
                frmQueen->pbBoard->Canvas->Lock();
                frmQueen->pbBoard->Canvas->FillRect(rect);
                frmQueen->pbBoard->Canvas->Unlock();
                PutChessMan(ToGrid,QUEEN);
                Sleep(AniSpeed);
            }

            frmQueen->pbBoard->Canvas->Lock();
            frmQueen->pbBoard->Canvas->FillRect(rect);

            while(rect.Top != FromGrid.Y)
            {
                rect.Top    -= IMGLEN + 1;
                rect.Bottom -= IMGLEN + 1;

                if(frmQueen->pbBoard->Canvas->Brush->Color == clGreen)
                    frmQueen->pbBoard->Canvas->Brush->Color = clWhite;
                else
                    frmQueen->pbBoard->Canvas->Brush->Color = clGreen;
                frmQueen->pbBoard->Canvas->FillRect(rect);
            }

            frmQueen->pbBoard->Update();