globalfun.cpp

《C++Builder程序设计范例--中国象棋》配书盘自述文件

void PrintChessBoard()
{
   SQUARETYPE square;

   DrawChessBoard();
   for (square = 0; square <= 0x98; square++)
       if (((square>>4)<10) && ((square % 16)<9) && ((square | 0xff)>=0))
	    {
	       if (Display[square].piece != empty)
		  PrintPiece(square, Display[square].piece,
		    Display[square].color, SRCINVERT);
		   
	    }
   DrawAlphaNum();
   if (Level == easygame && !Editing)
      ShowAttacks();
}


/*
确定鼠标位置所在方格中的棋子可否移动
 */

SQUARETYPE GetValidSquare(POINT p, COLORTYPE player, bool CheckPiece)
{
   POINT point;
   SQUARETYPE square;
   RECT sqrect;


   for (square = 0; square <= 0x98; square++)
      {
	if (((square>>4)<10) && ((square % 16)<9) && ((square | 0xff)>=0))
	 {
	 point = GetSquareXY(square);
	 sqrect.left = point.x;
	 sqrect.top = point.y;
	 sqrect.right = sqrect.left + SQUARE_SIZE;
	 sqrect.bottom = sqrect.top + SQUARE_SIZE;
	 if (PtInRect(&sqrect, p))
	    {
	    if ((Display[square].color == player && Display[square].piece
	       != empty) || !CheckPiece)
	       return square;
	    }
	 }
      }
   return -1;      
}
 /*
 画一个正常的位图
 */
void DrawNormalBitmap(SQUARETYPE square)
{
   ClearSquare(square);
   PrintPiece(square, Display[square].piece, Display[square].color, SRCINVERT);
}
  /*
 画一个反相的位图
 */
void DrawInvertedBitmap(SQUARETYPE square)
{
   PrintPiece(square, Display[square].piece, Display[square].color, NOTSRCERASE);
}

void OpeningLibMsg()
{
   InfoForm->SetMessageText("正在利用棋谱库。");
}

/*
在信息窗口中显示搜索树的节点
*/
void PrintNodes(NODEVAL *nodes, double time)
{
    double nodereal;
    char buffer[80];

    nodereal = (nodes->nodebase * MAXINT) + nodes->nodeoffset;
   if (time)
      {
      sprintf(buffer, "%7.1f", nodereal/time);
      InfoForm->SetSecondsText(buffer);
      }
   sprintf(buffer, "%7.0f ", nodereal);
   InfoForm->SetNodeText(buffer);
}


/*
 * 在信息窗口中显示最好走法
 */

void PrintBestMove(MOVETYPE *mainpath, MAXTYPE mainevalu)
{
   DEPTHTYPE dep = 0;

   *buffer = 0;

   if (ShowBestPath == false)
      return;
   while (dep < 7 && (mainpath[dep].movpiece != empty))
   {
      strcat(buffer, MoveStr(&mainpath[dep++]));
      strcat(buffer, " ");
   }
   InfoForm->SetBestPathText(buffer);
   sprintf(buffer, "%7.2f", mainevalu /256.0);
   InfoForm->SetValueText(buffer);
}

/*
 * 清除信息窗口中的最好路线
 */

void RemoveBestPath()
{
   InfoForm->SetBestPathText("");
}

void RemoveMessage()
{
   InfoForm->SetMessageText("");
}

static char * CharArray[] =  { "一", "二", "三", "四", "五","六", "七","八","九" };
static char * NumArray[] = { "１", "２", "３", "４", "５", "６", "７","８","９"};

/*
画一个凸起来的框
*/
static void DrawBump(HDC hDC, int x, int y)
{
   int x2, y2;
   HPEN hOldPen;
   HBRUSH hOldBrush;
   POINT pArray[3];

   x2 = x + 2 * CHARSIZE + 4;
   y2 = y-- + LINESIZE +1;
   x-=2;  

   hOldBrush = (HBRUSH)SelectObject(hDC, GetStockObject(LTGRAY_BRUSH));
   hOldPen = (HPEN)SelectObject(hDC, GetStockObject(WHITE_PEN));

   Rectangle(hDC, x, y, x2, y2);

   SelectObject(hDC, CreatePen(PS_SOLID, 1, RGB(128, 128, 128)));
   pArray[0].x = ++x;
   pArray[1].y = pArray[0].y = y2;
   pArray[2].x = pArray[1].x = x2;
   pArray[2].y = ++y;
   Polyline(hDC, pArray, 3);

   SelectObject(hDC, hOldBrush);
   DeleteObject(SelectObject(hDC, hOldPen));  
}
/*
显示数字和文字。注意中文是以2字节方式存贮的
*/
static void DrawAlphaNum()
{
   int i;
   int XPos, YPos;
   HDC hDC;

   hDC = GetDC(MainForm->Handle);


   XPos = SQUARE_SIZE / 2 - CHARSIZE/2+SQUARE_SIZE/3;
   YPos = SQUARE_SIZE   - 8 ;

   
   SetBkColor(hDC, RGB(192, 192, 192));

   for (i = 0; i < 9; i++)
      {
      DrawBump(hDC, XPos, YPos);
      if (Turned)
	 {
	 TextOut(hDC, XPos, YPos, NumArray[8-i], 2);
	 }
      else
	 TextOut(hDC, XPos, YPos, NumArray[i], 2);
      XPos += SQUARE_SIZE;
      }

   XPos =  SQUARE_SIZE / 2 - CHARSIZE/2+SQUARE_SIZE/3;
   YPos = BORDERSIZE + (9 * SQUARE_SIZE) + (2 * MYFRAMESIZE) + 1+2*SQUARE_SIZE;

   for (i = 0; i < 9; i++)
      {
      DrawBump(hDC, XPos , YPos + SQUARE_SIZE / 8 );
      if (Turned)
	 TextOut(hDC, XPos, YPos + SQUARE_SIZE / 8, CharArray[i], 2);
      else
	 TextOut(hDC, XPos, YPos + SQUARE_SIZE / 8, CharArray[8-i], 2);
      XPos += SQUARE_SIZE;
      }
    ReleaseDC(MainForm->Handle, hDC);
}


 /*
 存储棋盘
 按自定义棋盘数据结构以二进制方式保存
 */
static bool SaveChessBoard(char *savefile)
{
    FILE *gameboard;
   SAVERESTORE *Save;

   Save = new SAVERESTORE;
   if (!Save)
      {
       MessageBox(Application->Handle, "没有足够的内存执行操作",
	 "中国象棋", MB_OK | MB_ICONHAND);
      return 0;
      }
    if ((gameboard = fopen(savefile, "wb")) == NULL)
    {
        sprintf(buffer, "不能打开 %s 用于写", savefile);
        MessageBox(Application->Handle, buffer, "中国象棋", MB_OK | MB_ICONHAND);
        delete Save;
        return 0;
    }

   Save->Player = Player;
   Save->Opponent = Opponent;
   Save->ProgramColor = ProgramColor;
   Save->Turned = Turned;
   Save->MultiMove = MultiMove;
   Save->AutoPlay = AutoPlay;
   Save->SingleStep = SingleStep;
   Save->Level = Level;
   Save->AverageTime = AverageTime;
   Save->MaxLevel = MaxLevel;
   Save->MoveNumber = MoveNumber;
   Save->ChessClockTotalTime = ChessClock.totaltime;
   Save->BlackTotalTime = ChessTime[black].totaltime;
   Save->RedTotalTime = ChessTime[red].totaltime;
   memcpy(Save->PieceValue, PieceValue, 8 * sizeof(int));
   fwrite(Save, sizeof(SAVERESTORE), 1, gameboard);
   fwrite(ChessBoard, sizeof(ChessBoard), 1, gameboard);
   fclose(gameboard);
   delete Save;
   return 1;
}


void SaveGame(char *savefile)
{
    if (strlen(savefile) > 0)
    {
        if (!SaveChessBoard(savefile))
        {
            Error("存贮错误");
        }
    }
}

  /*
 加载棋盘
 按自定义棋盘数据结构以二进制方式打开
 */
void LoadChessBoard(char *loadfile)
{
   FILE *load;
   SAVERESTORE *Restore;

   Restore = new SAVERESTORE;

   if (!Restore)
      {
        MessageBox(MainForm->Handle, "没有足够的内存执行操作",
         "中国象棋", MB_OK | MB_ICONHAND);
      return;
      }

    if ((load = fopen(loadfile, "rb")) == 0)
        Error("文件没有发现");
    else
    {
        fread(Restore, sizeof(SAVERESTORE), 1, load);
        fread(ChessBoard, sizeof(ChessBoard), 1, load);
        fclose(load);
        Player = Restore->Player;
        Opponent = Restore->Opponent;
        ProgramColor = Restore->ProgramColor;
        Turned = Restore->Turned;
	MultiMove = Restore->MultiMove;
        AutoPlay = Restore->AutoPlay;
        SingleStep = Restore->SingleStep;
        Level = Restore->Level;
        AverageTime = Restore->AverageTime;
        MaxLevel = Restore->MaxLevel;
        MoveNumber = Restore->MoveNumber;
        ChessClock.totaltime = Restore->ChessClockTotalTime;
        ChessTime[black].totaltime = Restore->BlackTotalTime ;
        ChessTime[red].totaltime = Restore->RedTotalTime;
        memcpy(PieceValue, Restore->PieceValue, 8 * sizeof(int));
        ClearDisplay();
        InitDisplay();
        MainForm->Invalidate();

        PrintCurLevel();
        ResetNewPos();
    }
   delete Restore;
}

/****************************************************************************/

void RestoreGame(char *loadfile)
{
    if (strlen(loadfile))
	   LoadChessBoard(loadfile);
    else
      Error("游戏没有加载");
}


/*
 初始化象棋时钟
 */

void InitChessTime()
{
   InitTime(&ChessTime[red]);
   InitTime(&ChessTime[black]);
}
/*
 停止象棋时钟
 */
void StopChessTime()
{
    if (Running)
    {
        StopTime(&ChessTime[RunColor]);
        MainForm->Timer1->Enabled=false;
        Running = false;
    }
}

/*
 停止运行的象棋时钟，开始另一方的时钟
 */

void StartChessTime(COLORTYPE color)
{
    RunColor = color;
    Running = true;
    StartTime(&ChessTime[RunColor]);
    MainForm->Timer1->Enabled =true;
}

/*
 重置移动表
 */

void ResetMoves()
{
   Depth = -1;
   MoveTable[-1] = ZeroMove;
}


/*
 清除提示行
 */

void RemoveHint()
{
   HintPath[0] = ZeroMove;
   HintEvaluat = 0;
}
 /*
 初始化搜索树节点
 */
void InitNode(NODEVAL *nodes)
{
   nodes->nodebase = 0;     
   nodes->nodeoffset = 0;
}

/*
 检查当Programcolor == player 时在给定的位置棋子移动是否合法
 */

bool IllegalMove(MOVETYPE *move)
{
   bool illegal;

   Perform(move, 0);   //向前看一步
   illegal = Attacks(Opponent, PieceTable[Player][0].isquare);
   Perform(move, 1);  //退回一步
   return illegal;
}    
 


/*
 当Programcolor == player 时，移动棋子并更改变量
 */

void MakeMove(MOVETYPE *move)
{
    Depth++;
    MoveNumber++;
    Perf