自学教程：C++ DST函数代码示例

/** * Apply the Scale3x effect on a group of rows. Used internally. */static inline void stage_scale3x(void* dst0, void* dst1, void* dst2, const void* src0, const void* src1, const void* src2, unsigned pixel, unsigned pixel_per_row){	switch (pixel) {		case 1 : scale3x_8_def(DST(8,0), DST(8,1), DST(8,2), SRC(8,0), SRC(8,1), SRC(8,2), pixel_per_row); break;		case 2 : scale3x_16_def(DST(16,0), DST(16,1), DST(16,2), SRC(16,0), SRC(16,1), SRC(16,2), pixel_per_row); break;		case 4 : scale3x_32_def(DST(32,0), DST(32,1), DST(32,2), SRC(32,0), SRC(32,1), SRC(32,2), pixel_per_row); break;	}}

bool ChessBoard::isLegalMove(int mv){    int sqSrc, sqDst, pcSrc, pcDst;    sqSrc = SRC(mv);    sqDst = DST(mv);    if (sqSrc==sqDst)    {        return false;    }    pcSrc = m_data[sqSrc];    pcDst = m_data[sqDst];    if (side(pcSrc)==side(pcDst))    {        return false;    }    Moves mvs;    generateMoves(sqSrc, mvs);    for(int i=0; i<mvs.count(); i++)    {        if (mvs[i]==mv)        {            return true;        }    }    return false;}

// 点击格子事件处理static void ClickSquare(int sq) {  int pc;  Xqwl.hdc = GetDC(Xqwl.hWnd);  Xqwl.hdcTmp = CreateCompatibleDC(Xqwl.hdc);  sq = Xqwl.bFlipped ? SQUARE_FLIP(sq) : sq;  pc = pos.ucpcSquares[sq];  if ((pc & SIDE_TAG(pos.sdPlayer)) != 0) {    // 如果点击自己的子，那么直接选中该子    if (Xqwl.sqSelected != 0) {      DrawSquare(Xqwl.sqSelected);    }    Xqwl.sqSelected = sq;    DrawSquare(sq, DRAW_SELECTED);    if (Xqwl.mvLast != 0) {      DrawSquare(SRC(Xqwl.mvLast));      DrawSquare(DST(Xqwl.mvLast));    }    PlayResWav(IDR_CLICK); // 播放点击的声音  } else if (Xqwl.sqSelected != 0) {    // 如果点击的不是自己的子，但有子选中了(一定是自己的子)，那么走这个子    Xqwl.mvLast = MOVE(Xqwl.sqSelected, sq);    pos.MakeMove(Xqwl.mvLast);    DrawSquare(Xqwl.sqSelected, DRAW_SELECTED);    DrawSquare(sq, DRAW_SELECTED);    Xqwl.sqSelected = 0;    PlayResWav(pc == 0 ? IDR_MOVE : IDR_CAPTURE); // 播放走子或吃子的声音  }  DeleteDC(Xqwl.hdcTmp);  ReleaseDC(Xqwl.hWnd, Xqwl.hdc);}

// 绘制棋盘static void DrawBoard(HDC hdc) {  int x, y, xx, yy, sq, pc;  HDC hdcTmp;  // 画棋盘  hdcTmp = CreateCompatibleDC(hdc);  SelectObject(hdcTmp, Xqwl.bmpBoard);  BitBlt(hdc, 0, 0, BOARD_WIDTH, BOARD_HEIGHT, hdcTmp, 0, 0, SRCCOPY);  // 画棋子  for (x = FILE_LEFT; x <= FILE_RIGHT; x ++) {    for (y = RANK_TOP; y <= RANK_BOTTOM; y ++) {      if (Xqwl.bFlipped) {        xx = BOARD_EDGE + (FILE_FLIP(x) - FILE_LEFT) * SQUARE_SIZE;        yy = BOARD_EDGE + (RANK_FLIP(y) - RANK_TOP) * SQUARE_SIZE;      } else {        xx = BOARD_EDGE + (x - FILE_LEFT) * SQUARE_SIZE;        yy = BOARD_EDGE + (y - RANK_TOP) * SQUARE_SIZE;      }      sq = COORD_XY(x, y);      pc = pos.ucpcSquares[sq];      if (pc != 0) {        DrawTransBmp(hdc, hdcTmp, xx, yy, Xqwl.bmpPieces[pc]);      }      if (sq == Xqwl.sqSelected || sq == SRC(Xqwl.mvLast) || sq == DST(Xqwl.mvLast)) {        DrawTransBmp(hdc, hdcTmp, xx, yy, Xqwl.bmpSelected);      }    }  }  DeleteDC(hdcTmp);}

intcall_msg_is_retrans(sip_msg_t *msg){    sip_msg_t *prev = NULL;    vector_iter_t it;    // Get previous message in call with same origin and destination    it = vector_iterator(msg->call->msgs);    vector_iterator_set_current(&it, vector_index(msg->call->msgs, msg));    while ((prev = vector_iterator_prev(&it))) {        if (!strcmp(SRC(prev), SRC(msg)) && !strcmp(DST(prev), DST(msg)))            break;    }    return (prev && !strcasecmp(msg_get_payload(msg), msg_get_payload(prev)));}

static void ParseFile(const char *szFilePath) {  int i, mv, mvMirror, nComp;  PositionStruct pos, posMirror;  PgnFileStruct pgn;  if (pgn.Read(szFilePath)) {    pos = posMirror = pgn.posStart;    posMirror.Mirror();    for (i = 0; i < pgn.nMaxMove; i ++) {      mv = pgn.wmvMoveTable[i + 1];      mvMirror = MOVE_MIRROR(mv);      if (pos.zobr.dwLock1 < posMirror.zobr.dwLock1) {        nComp = -1;      } else if (pos.zobr.dwLock1 > posMirror.zobr.dwLock1) {        nComp = 1;      } else {        if (pos.zobr.dwLock0 < posMirror.zobr.dwLock0) {          nComp = -1;        } else if (pos.zobr.dwLock0 > posMirror.zobr.dwLock0) {          nComp = 1;        } else {          nComp = 0;        }      }      if (nComp <= 0) {        AddTemp(TempStruct(pos, mv, MoveValue(pos.sdPlayer, pgn.nResult)));      }      if (nComp >= 0) {        AddTemp(TempStruct(posMirror, mvMirror, MoveValue(pos.sdPlayer, pgn.nResult)));      }      if (pos.ucpcSquares[DST(mv)] == 0) {        pos.MakeMove(mv);      } else {        pos.MakeMove(mv);        pos.SetIrrev();      }      if (posMirror.ucpcSquares[DST(mvMirror)] == 0) {        posMirror.MakeMove(mvMirror);      } else {        posMirror.MakeMove(mvMirror);        posMirror.SetIrrev();      }      }    }}

// 搬一步棋的棋子void PositionStruct::MovePiece(int mv) {  int sqSrc, sqDst, pc;  sqSrc = SRC(mv);  sqDst = DST(mv);  DelPiece(sqDst);  pc = ucpcSquares[sqSrc];  DelPiece(sqSrc);  AddPiece(sqDst, pc);}

void _PositionStruct::UndoMovePiece(int mv, int pcCaptured) {  int sqSrc, sqDst, pc;  sqSrc = SRC(mv);  sqDst = DST(mv);  pc = ucpcSquares[sqDst];  DelPiece(sqDst, pc);  AddPiece(sqSrc, pc);  if (pcCaptured != 0) {    AddPiece(sqDst, pcCaptured);  }}

int main(){	int i, j, k, L;	double ***F, *f, *temp;	k = 0;	L = 3;	temp = (double *) malloc(L*sizeof(double));	F = (double ***) malloc(L*sizeof(double**));	f = (double *) malloc(L*L*L*sizeof(double));	for(i=0;i<L;i++)	{		F[i] = (double **) malloc(L*sizeof(double*));		for(j=0;j<L;j++,k=k+L)		{			F[i][j] = f + k;		}	}	for(i=0;i<L;i++)	{		for(j=0;j<L;j++)		{			for(k=0;k<L;k++)			{				F[i][j][k] = i + j + k;			}		}	}		Print_Tensor(F, L);	for(k=0;k<L;k++) 	{		for(j=0;j<L;j++)		{			for(i=0;i<L;i++)			{				temp[i] = F[i][j][k];			}			DST(temp, L);			for(i=0;i<L;i++)			{				F[i][j][k] = temp[i];			}		}	}	Print_Tensor(F, L);		return 0;	}

void display_map_marks(){	actor *me;	float x,y,z;	int i,ax,ay;	float dx = (TILESIZE_X / 6);	float dy = (TILESIZE_Y / 6);	float fr = mark_z_rot/360;	float j,ff=0;	me = get_our_actor();	if(!me) return;	ax = me->x_pos;	ay = me->y_pos;		glDisable(GL_TEXTURE_2D);	glDisable(GL_LIGHTING);	glEnable(GL_BLEND);	glBlendFunc(GL_SRC_ALPHA, GL_ONE);	glEnable(GL_ALPHA_TEST);		for(i=0;i<max_mark;i++){		x=marks[i].x/2.0;		y=marks[i].y/2.0;		x += (TILESIZE_X / 2);		y += (TILESIZE_Y / 2);		if(DST(ax,ay,x,y)>MARK_DIST||marks[i].x<0||!marks_3d) continue;		z = get_tile_height(marks[i].x, marks[i].y);		for(j=z-fr/5,ff=1;j<z+2;j+=0.1,ff=(2-(j-z))/2) {			if(marks[i].server_side) glColor4f(0.0f, 0.0f, 1.0f, 0.9f-(j-z)/3);			else glColor4f((float)marks[i].r/255, (float)marks[i].g/255, (float)marks[i].b/255, 0.7f-(j-z)/3);			glBegin(GL_QUADS);				glVertex3f(x-dx*ff,y-dy*ff,j);				glVertex3f(x-dx*ff,y+dy*ff,j);				glVertex3f(x+dx*ff,y+dy*ff,j);				glVertex3f(x+dx*ff,y-dy*ff,j);			glEnd();		}			}		glDisable(GL_ALPHA_TEST);	//glEnable(GL_LIGHTING);	glDisable(GL_BLEND);	glEnable(GL_TEXTURE_2D);	}

// 检测下一个着法是否稳定，有助于减少置换表的不稳定性inline bool MoveStable(PositionStruct &pos, int mv) {  // 判断下一个着法是否稳定的依据是：  // 1. 没有后续着法，则假定是稳定的；  if (mv == 0) {    return true;  }  // 2. 吃子着法是稳定的；  __ASSERT(pos.LegalMove(mv));  if (pos.ucpcSquares[DST(mv)] != 0) {    return true;  }  // 3. 可能因置换表引起路线迁移，使得路线超过"MAX_MOVE_NUM"，此时应立刻终止路线，并假定是稳定的。  if (!pos.MakeMove(mv)) {    return true;  }  return false;}

void FORTE_ST_SET_PARM::executeRQST(void){  forte::core::SManagementCMD theCommand;  theCommand.mDestination = CStringDictionary::getInstance().getId(DST().getValue());  theCommand.mFirstParam.pushBack(CStringDictionary::getInstance().getId(ELEM_NAME().getValue()));  theCommand.mFirstParam.pushBack(CStringDictionary::getInstance().getId(ELEM_DATA_IN().getValue()));  theCommand.mAdditionalParams = PARM_VAL().getValue();  theCommand.mCMD = cg_nMGM_CMD_Write;    EMGMResponse resp = m_poDevice.executeMGMCommand(theCommand);  //calculate return value  CIEC_STRING retVal(DEV_MGR::scm_sMGMResponseTexts[resp]);  CIEC_STRING compareVal(DEV_MGR::scm_sMGMResponseTexts[e_RDY]);  QO() = retVal == compareVal;  DEVLOG_DEBUG("%s/n", DEV_MGR::scm_sMGMResponseTexts[resp]);   STATUS() = (DEV_MGR::scm_sMGMResponseTexts[resp]);  }

void FORTE_ST_CREATE_CONN::executeRQST(void){  forte::core::SManagementCMD theCommand;    theCommand.mDestination = CStringDictionary::getInstance().getId(DST().getValue());  theCommand.mFirstParam.pushBack(CStringDictionary::getInstance().getId(SRC_FB().getValue()));  theCommand.mFirstParam.pushBack(CStringDictionary::getInstance().getId(SRC_FB_OUT().getValue()));  theCommand.mSecondParam.pushBack(CStringDictionary::getInstance().getId(DST_FB().getValue()));  theCommand.mSecondParam.pushBack(CStringDictionary::getInstance().getId(DST_FB_IN().getValue()));  theCommand.mCMD = cg_nMGM_CMD_Create_Connection;    EMGMResponse resp = m_poDevice.executeMGMCommand(theCommand);  //calculate return value  CIEC_STRING retVal(DEV_MGR::scm_sMGMResponseTexts[resp]);  CIEC_STRING compareVal(DEV_MGR::scm_sMGMResponseTexts[e_RDY]);  QO() = retVal == compareVal;  DEVLOG_DEBUG("%s/n", DEV_MGR::scm_sMGMResponseTexts[resp]);  STATUS() = (DEV_MGR::scm_sMGMResponseTexts[resp]);}

static void __fastcall yuv2rgb_c_32 (u8 * py_1, u8 * py_2,			  u8 * pu, u8 * pv,			  void * _dst_1, void * _dst_2, int width){    int U, V, Y;    u32 * r, * g, * b;    u32 * dst_1, * dst_2;    width >>= 3;    dst_1 = (u32 *) _dst_1;    dst_2 = (u32 *) _dst_2;    do {		_RGB (u32, 0);		DST (py_1, dst_1, 0);		DST (py_2, dst_2, 0);		_RGB (u32, 1);		DST (py_2, dst_2, 1);		DST (py_1, dst_1, 1);		_RGB (u32, 2);		DST (py_1, dst_1, 2);		DST (py_2, dst_2, 2);		_RGB (u32, 3);		DST (py_2, dst_2, 3);		DST (py_1, dst_1, 3);		pu += 4;		pv += 4;		py_1 += 8;		py_2 += 8;		dst_1 += 8;		dst_2 += 8;    } while (--width);}

/* Similar to print but do it twice and mark * the difference between the DBMs. */std::ostream& dbm_cppPrintDiff(std::ostream& out,                               const raw_t *src, const raw_t *dst, cindex_t dim){    cindex_t i,j;    assert(src && dst);    out << "DBM diff " << dim << 'x' << dim << ":/n";    for (i = 0; i < dim; ++i)    {        raw_t diff = SRC(i,0) ^ DST(i,0);        PRE_DIFF();        dbm_cppPrintRaw(out, SRC(i,0));        POST_DIFF();        for (j = 1; j < dim; ++j)        {            out << '/t';            diff = SRC(i,j) ^ DST(i,j);            PRE_DIFF();            dbm_cppPrintRaw(out, SRC(i,j));            POST_DIFF();        }        out << '/n';    }    out << '/n';    for (i = 0; i < dim; ++i)    {        raw_t diff = SRC(i,0) ^ DST(i,0);        PRE_DIFF();        dbm_cppPrintRaw(out, DST(i,0));        POST_DIFF();        for (j = 1; j < dim; ++j)        {            out << '/t';            diff = SRC(i,j) ^ DST(i,j);            PRE_DIFF();            dbm_cppPrintRaw(out, DST(i,j));            POST_DIFF();        }        out << '/n';    }    return out;}

// “捉”的检测int PositionStruct::ChasedBy(int mv) const {  int i, nSideTag, pcMoved, pcCaptured;  int sqSrc, sqDst, x, y;  uint8_t *lpucsqDst, *lpucsqPin;  SlideMoveStruct *lpsmv;  sqSrc = DST(mv);  pcMoved = this->ucpcSquares[sqSrc];  nSideTag = SIDE_TAG(this->sdPlayer);  __ASSERT_SQUARE(sqSrc);  __ASSERT_PIECE(pcMoved);  __ASSERT_BOUND(0, pcMoved - OPP_SIDE_TAG(this->sdPlayer), 15);  // “捉”的判断包括以下几部分内容：  switch (pcMoved - OPP_SIDE_TAG(this->sdPlayer)) {  // 1. 走了马，判断是否捉车或捉有根的炮兵(卒)  case KNIGHT_FROM:  case KNIGHT_TO:    // 逐一检测马踩的八个位置    lpucsqDst = PreGen.ucsqKnightMoves[sqSrc];    lpucsqPin = PreGen.ucsqKnightPins[sqSrc];    sqDst = *lpucsqDst;    while (sqDst != 0) {      __ASSERT_SQUARE(sqDst);      if (ucpcSquares[*lpucsqPin] == 0) {        pcCaptured = this->ucpcSquares[sqDst];        if ((pcCaptured & nSideTag) != 0) {          pcCaptured -= nSideTag;          __ASSERT_BOUND(0, pcCaptured, 15);          // 技巧：优化兵种判断的分枝          if (pcCaptured <= ROOK_TO) {            // 马捉仕(士)、相(象)和马的情况不予考虑            if (pcCaptured >= ROOK_FROM) {              // 马捉到了车              return pcCaptured;            }          } else {            if (pcCaptured <= CANNON_TO) {              // 马捉到了炮，要判断炮是否受保护              if (!Protected(this->sdPlayer, sqDst)) {                return pcCaptured;              }            } else {              // 马捉到了兵(卒)，要判断兵(卒)是否过河并受保护              if (AWAY_HALF(sqDst, sdPlayer) && !Protected(this->sdPlayer, sqDst)) {                return pcCaptured;              }            }          }        }      }      lpucsqDst ++;      sqDst = *lpucsqDst;      lpucsqPin ++;    }    break;  // 2. 走了车，判断是否捉有根的马炮兵(卒)  case ROOK_FROM:  case ROOK_TO:    x = FILE_X(sqSrc);    y = RANK_Y(sqSrc);    if (((SRC(mv) ^ sqSrc) & 0xf) == 0) {      // 如果车纵向移动了，则判断车横向吃到的子      lpsmv = RankMovePtr(x, y);      for (i = 0; i < 2; i ++) {        sqDst = lpsmv->ucRookCap[i] + RANK_DISP(y);        __ASSERT_SQUARE(sqDst);        if (sqDst != sqSrc) {          pcCaptured = this->ucpcSquares[sqDst];          if ((pcCaptured & nSideTag) != 0) {            pcCaptured -= nSideTag;            __ASSERT_BOUND(0, pcCaptured, 15);            // 技巧：优化兵种判断的分枝            if (pcCaptured <= ROOK_TO) {              // 车捉仕(士)、相(象)的情况不予考虑              if (pcCaptured >= KNIGHT_FROM) {                if (pcCaptured <= KNIGHT_TO) {                  // 车捉到了马，要判断马是否受保护                  if (!Protected(this->sdPlayer, sqDst)) {                    return pcCaptured;                  }                }                // 车捉车的情况不予考虑              }            } else {              if (pcCaptured <= CANNON_TO) {                // 车捉到了炮，要判断炮是否受保护                if (!Protected(this->sdPlayer, sqDst)) {                  return pcCaptured;                }              } else {                // 车捉到了兵(卒)，要判断兵(卒)是否过河并受保护                if (AWAY_HALF(sqDst, sdPlayer) && !Protected(this->sdPlayer, sqDst)) {                  return pcCaptured;                }              }            }//.........这里部分代码省略.........

static void HD4(uint8_t *dst) {  // Horizontal-Down  const int I = dst[-1 + 0 * BPS];  const int J = dst[-1 + 1 * BPS];  const int K = dst[-1 + 2 * BPS];  const int L = dst[-1 + 3 * BPS];  const int X = dst[-1 - BPS];  const int A = dst[0 - BPS];  const int B = dst[1 - BPS];  const int C = dst[2 - BPS];  DST(0, 0) = DST(2, 1) = AVG2(I, X);  DST(0, 1) = DST(2, 2) = AVG2(J, I);  DST(0, 2) = DST(2, 3) = AVG2(K, J);  DST(0, 3)             = AVG2(L, K);  DST(3, 0)             = AVG3(A, B, C);  DST(2, 0)             = AVG3(X, A, B);  DST(1, 0) = DST(3, 1) = AVG3(I, X, A);  DST(1, 1) = DST(3, 2) = AVG3(J, I, X);  DST(1, 2) = DST(3, 3) = AVG3(K, J, I);  DST(1, 3)             = AVG3(L, K, J);}

static void HU4(uint8_t *dst) {   // Horizontal-Up  const int I = dst[-1 + 0 * BPS];  const int J = dst[-1 + 1 * BPS];  const int K = dst[-1 + 2 * BPS];  const int L = dst[-1 + 3 * BPS];  DST(0, 0) =             AVG2(I, J);  DST(2, 0) = DST(0, 1) = AVG2(J, K);  DST(2, 1) = DST(0, 2) = AVG2(K, L);  DST(1, 0) =             AVG3(I, J, K);  DST(3, 0) = DST(1, 1) = AVG3(J, K, L);  DST(3, 1) = DST(1, 2) = AVG3(K, L, L);  DST(3, 2) = DST(2, 2) =    DST(0, 3) = DST(1, 3) = DST(2, 3) = DST(3, 3) = L;}

static void VL4(uint8_t *dst) {   // Vertical-Left  const int A = dst[0 - BPS];  const int B = dst[1 - BPS];  const int C = dst[2 - BPS];  const int D = dst[3 - BPS];  const int E = dst[4 - BPS];  const int F = dst[5 - BPS];  const int G = dst[6 - BPS];  const int H = dst[7 - BPS];  DST(0, 0) =             AVG2(A, B);  DST(1, 0) = DST(0, 2) = AVG2(B, C);  DST(2, 0) = DST(1, 2) = AVG2(C, D);  DST(3, 0) = DST(2, 2) = AVG2(D, E);  DST(0, 1) =             AVG3(A, B, C);  DST(1, 1) = DST(0, 3) = AVG3(B, C, D);  DST(2, 1) = DST(1, 3) = AVG3(C, D, E);  DST(3, 1) = DST(2, 3) = AVG3(D, E, F);              DST(3, 2) = AVG3(E, F, G);              DST(3, 3) = AVG3(F, G, H);}

static void VR4(uint8_t *dst) {   // Vertical-Right  const int I = dst[-1 + 0 * BPS];  const int J = dst[-1 + 1 * BPS];  const int K = dst[-1 + 2 * BPS];  const int X = dst[-1 - BPS];  const int A = dst[0 - BPS];  const int B = dst[1 - BPS];  const int C = dst[2 - BPS];  const int D = dst[3 - BPS];  DST(0, 0) = DST(1, 2) = AVG2(X, A);  DST(1, 0) = DST(2, 2) = AVG2(A, B);  DST(2, 0) = DST(3, 2) = AVG2(B, C);  DST(3, 0)             = AVG2(C, D);  DST(0, 3) =             AVG3(K, J, I);  DST(0, 2) =             AVG3(J, I, X);  DST(0, 1) = DST(1, 3) = AVG3(I, X, A);  DST(1, 1) = DST(2, 3) = AVG3(X, A, B);  DST(2, 1) = DST(3, 3) = AVG3(A, B, C);  DST(3, 1) =             AVG3(B, C, D);}

static void RD4(uint8_t *dst) {   // Down-right  const int I = dst[-1 + 0 * BPS];  const int J = dst[-1 + 1 * BPS];  const int K = dst[-1 + 2 * BPS];  const int L = dst[-1 + 3 * BPS];  const int X = dst[-1 - BPS];  const int A = dst[0 - BPS];  const int B = dst[1 - BPS];  const int C = dst[2 - BPS];  const int D = dst[3 - BPS];  DST(0, 3)                                     = AVG3(J, K, L);  DST(0, 2) = DST(1, 3)                         = AVG3(I, J, K);  DST(0, 1) = DST(1, 2) = DST(2, 3)             = AVG3(X, I, J);  DST(0, 0) = DST(1, 1) = DST(2, 2) = DST(3, 3) = AVG3(A, X, I);  DST(1, 0) = DST(2, 1) = DST(3, 2)             = AVG3(B, A, X);  DST(2, 0) = DST(3, 1)                         = AVG3(C, B, A);  DST(3, 0)                                     = AVG3(D, C, B);}

// 将内部着法表示转换为纵线符号uint32_t Move2File(int mv, const PositionStruct &pos) {  int i, j, sq, pc, pt, nPieceNum;  int xSrc, ySrc, xDst, yDst;  int nFileList[9], nPieceList[5];  C4dwStruct Ret;  if (SRC(mv) == 0 || DST(mv) == 0) {    return 0x20202020;  }  pc = pos.ucpcSquares[SRC(mv)];  if (pc == 0) {    return 0x20202020;  }  pt = PIECE_TYPE(pc);  Ret.c[0] = PIECE_BYTE(pt);  if (pos.sdPlayer == 0) {    xSrc = FILESQ_FILE_X(SQUARE_FILESQ(SRC(mv)));    ySrc = FILESQ_RANK_Y(SQUARE_FILESQ(SRC(mv)));    xDst = FILESQ_FILE_X(SQUARE_FILESQ(DST(mv)));    yDst = FILESQ_RANK_Y(SQUARE_FILESQ(DST(mv)));  } else {    xSrc = FILESQ_FILE_X(SQUARE_FILESQ(SQUARE_FLIP(SRC(mv))));    ySrc = FILESQ_RANK_Y(SQUARE_FILESQ(SQUARE_FLIP(SRC(mv))));    xDst = FILESQ_FILE_X(SQUARE_FILESQ(SQUARE_FLIP(DST(mv))));    yDst = FILESQ_RANK_Y(SQUARE_FILESQ(SQUARE_FLIP(DST(mv))));  }  if (pt >= KING_TYPE && pt <= BISHOP_TYPE) {    Ret.c[1] = Digit2Byte(xSrc);  } else {    for (i = 0; i < 9; i ++) {      nFileList[i] = 0;    }    j = (pt == PAWN_TYPE ? 5 : 2);    for (i = 0; i < j; i ++) {      sq = FILESQ_SIDE_PIECE(pos, FIRST_PIECE(pt, i));      if (sq != -1) {        nFileList[FILESQ_FILE_X(sq)] ++;      }    }    // 提示：处理“两条的纵线上有多个兵(卒)”的问题上，可参阅"File2Move()"函数。    if (nFileList[xSrc] > 1) {      nPieceNum = 0;      for (i = 0; i < j; i ++) {        sq = FILESQ_SIDE_PIECE(pos, FIRST_PIECE(pt, i));        if (sq != -1) {          if (nFileList[FILESQ_FILE_X(sq)] > 1) {            nPieceList[nPieceNum] = FIRST_PIECE(pt, i);            nPieceNum ++;          }        }      }      for (i = 0; i < nPieceNum - 1; i ++) {        for (j = nPieceNum - 1; j > i; j --) {          if (FILESQ_SIDE_PIECE(pos, nPieceList[j - 1]) > FILESQ_SIDE_PIECE(pos, nPieceList[j])) {            SWAP(nPieceList[j - 1], nPieceList[j]);          }        }      }      sq = FILESQ_COORD_XY(xSrc, ySrc);      for (i = 0; i < nPieceNum; i ++) {        if (FILESQ_SIDE_PIECE(pos, nPieceList[i]) == sq) {          break;        }      }      Ret.c[1] = (nPieceNum == 2 && i == 1 ? ccPos2Byte[2 + DIRECT_TO_POS] :          ccPos2Byte[nPieceNum > 3 ? i : i + DIRECT_TO_POS]);    } else {      Ret.c[1] = Digit2Byte(xSrc);    }  }  if (pt >= ADVISOR_TYPE && pt <= KNIGHT_TYPE) {    if (SRC(mv) == DST(mv)) {      Ret.c[2] = '=';      Ret.c[3] = 'P';    } else {      Ret.c[2] = (yDst > ySrc ? '-' : '+');      Ret.c[3] = Digit2Byte(xDst);    }  } else {    Ret.c[2] = (yDst == ySrc ? '.' : yDst > ySrc ? '-' : '+');    Ret.c[3] = (yDst == ySrc ? Digit2Byte(xDst) : Digit2Byte(ABS(ySrc - yDst) - 1));  }  return Ret.dw;}

int Pgn2Xqf(const char *szPgnFile, const char *szXqfFile) {  int i, nCommentLen;  char szRed[MAX_STR_LEN * 2], szBlack[MAX_STR_LEN * 2];  FILE *fp;  PgnFileStruct pgn;  XqfHeaderStruct xqfhd;  XqfMoveStruct xqfmv;  if (!pgn.Read(szPgnFile)) {    return PGN2XQF_ERROR_OPEN;  }  fp = fopen(szXqfFile, "wb");  if (fp == NULL) {    return PGN2XQF_ERROR_CREATE;  }  memset(xqfhd.szTag, 0, sizeof(XqfHeaderStruct));  xqfhd.szTag[0] = 'X';  xqfhd.szTag[1] = 'Q';  xqfhd.szTag[2] = 10;  for (i = 0; i < 32; i ++) {    xqfhd.szPiecePos[i] = ccSquare2Xqf[pgn.posStart.ucsqPieces[cpcXqf2Piece[i]]];  }  xqfhd.szResult[3] = cnResultTrans[pgn.nResult];  xqfhd.szSetUp[0] = 2;  SetXqfString(xqfhd.szEvent, pgn.szEvent, sizeof(xqfhd.szEvent));  SetXqfString(xqfhd.szDate, pgn.szDate, sizeof(xqfhd.szDate));  SetXqfString(xqfhd.szSite, pgn.szSite, sizeof(xqfhd.szSite));  if (pgn.szRedTeam[0] == '/0') {    SetXqfString(xqfhd.szRed, pgn.szRed, sizeof(xqfhd.szRed));  } else {    sprintf(szRed, "%s %s", pgn.szRedTeam, pgn.szRed);    SetXqfString(xqfhd.szRed, szRed, sizeof(xqfhd.szRed));  }  if (pgn.szBlackTeam[0] == '/0') {    SetXqfString(xqfhd.szBlack, pgn.szBlack, sizeof(xqfhd.szBlack));  } else {    sprintf(szBlack, "%s %s", pgn.szBlackTeam, pgn.szBlack);    SetXqfString(xqfhd.szBlack, szBlack, sizeof(xqfhd.szBlack));  }  fwrite(&xqfhd, sizeof(xqfhd), 1, fp);  memset(&xqfhd, 0, sizeof(xqfhd));  fwrite(&xqfhd, sizeof(xqfhd), 1, fp);  for (i = 0; i <= pgn.nMaxMove; i ++) {    xqfmv.ucTag = (i == pgn.nMaxMove ? 0 : 240);    if (i == 0) {      xqfmv.ucSrc = 24;      xqfmv.ucDst = 32;      xqfmv.ucReserved = 255;    } else {      xqfmv.ucSrc = 24 + ccSquare2Xqf[SRC(pgn.wmvMoveTable[i])];      xqfmv.ucDst = 32 + ccSquare2Xqf[DST(pgn.wmvMoveTable[i])];      xqfmv.ucReserved = 0;    }    fwrite(&xqfmv, sizeof(XqfMoveStruct), 1, fp);    nCommentLen = (pgn.szCommentTable[i] == NULL ? 0 : strlen(pgn.szCommentTable[i]));    fwrite(&nCommentLen, sizeof(int), 1, fp);    if (pgn.szCommentTable[i] != NULL) {      fwrite(pgn.szCommentTable[i], nCommentLen, 1, fp);    }  }  fclose(fp);  return 0;}

void display_map_markers() {	int ax, ay;	float z,x,y;	int i;	GLdouble model[16],proj[16];	GLint view[4];	GLdouble hx,hy,hz;	float banner_width;	float font_scale = 1.0f/ALT_INGAME_FONT_X_LEN;	float font_size_x=font_scale*SMALL_INGAME_FONT_X_LEN;	float font_size_y=font_scale*SMALL_INGAME_FONT_Y_LEN;	char tmpb[4];	actor *me;	me = get_our_actor();	if(!me) return;	ax = me->x_pos;	ay = me->y_pos;		glGetDoublev(GL_MODELVIEW_MATRIX, model);	glGetDoublev(GL_PROJECTION_MATRIX, proj);	glGetIntegerv(GL_VIEWPORT, view);	glPushMatrix();	glLoadIdentity();	glMatrixMode(GL_PROJECTION);	glPushMatrix();	glLoadIdentity();	glOrtho(view[0],view[2]+view[0],view[1],view[3]+view[1],0.0f,-1.0f);	glDepthFunc(GL_LEQUAL);	glEnable(GL_TEXTURE_2D);	glColor4f(1.0,1.0,1.0,1.0);	glDisable(GL_LIGHTING);	glEnable(GL_BLEND);	glBlendFunc(GL_SRC_ALPHA, GL_ONE);		for(i=0;i<max_mark;i++){		x=marks[i].x/2.0;		y=marks[i].y/2.0;		x += (TILESIZE_X / 2);		y += (TILESIZE_Y / 2);		if(DST(ax,ay,x,y)>MARK_DIST||marks[i].x<0||!marks_3d) continue;		z = get_tile_height(marks[i].x, marks[i].y)+2.3;		gluProject(x, y, z, model, proj, view, &hx, &hy, &hz);		//shorten text		memcpy(tmpb,marks[i].text+MARK_CLIP_POS,4);		marks[i].text[MARK_CLIP_POS]=marks[i].text[MARK_CLIP_POS+1]=marks[i].text[MARK_CLIP_POS+2]='.';		marks[i].text[MARK_CLIP_POS+3]=0;		banner_width = ((float)get_string_width((unsigned char*)marks[i].text)*(font_size_x*name_zoom))/2.0;		draw_ortho_ingame_string(hx-banner_width, hy, hz, (unsigned char*)marks[i].text, 4, font_size_x, font_size_y);		//restore text		memcpy(marks[i].text+MARK_CLIP_POS,tmpb,4);				}	glDisable(GL_BLEND);	glDisable(GL_TEXTURE_2D);	glMatrixMode(GL_PROJECTION);	glPopMatrix();	glMatrixMode(GL_MODELVIEW);	glPopMatrix();	//glEnable(GL_LIGHTING);	glDepthFunc(GL_LESS);		}

// 静态搜索例程static int SearchQuiesc(PositionStruct &pos, int vlAlpha, int vlBeta) {  int vlBest, vl, mv;  bool bInCheck;  MoveSortStruct MoveSort;    // 静态搜索例程包括以下几个步骤：  Search2.nAllNodes ++;  // 1. 无害裁剪；  vl = HarmlessPruning(pos, vlBeta);  if (vl > -MATE_VALUE) {    return vl;  }#ifdef HASH_QUIESC  // 3. 置换裁剪；  vl = ProbeHashQ(pos, vlAlpha, vlBeta);  if (Search.bUseHash && vl > -MATE_VALUE) {    return vl;  }#endif  // 4. 达到极限深度，直接返回评价值；  if (pos.nDistance == LIMIT_DEPTH) {    return Evaluate(pos, vlAlpha, vlBeta);  }  __ASSERT(Search.pos.nDistance < LIMIT_DEPTH);  // 5. 初始化；  vlBest = -MATE_VALUE;  bInCheck = (pos.LastMove().ChkChs > 0);  // 6. 对于被将军的局面，生成全部着法；  if (bInCheck) {    MoveSort.InitAll(pos);  } else {    // 7. 对于未被将军的局面，在生成着法前首先尝试空着(空着启发)，即对局面作评价；    vl = Evaluate(pos, vlAlpha, vlBeta);    __ASSERT_BOUND(1 - WIN_VALUE, vl, WIN_VALUE - 1);    __ASSERT(vl > vlBest);    if (vl >= vlBeta) {#ifdef HASH_QUIESC      RecordHashQ(pos, vl, MATE_VALUE);#endif      return vl;    }    vlBest = vl;    vlAlpha = MAX(vl, vlAlpha);    // 8. 对于未被将军的局面，生成并排序所有吃子着法(MVV(LVA)启发)；    MoveSort.InitQuiesc(pos);  }  // 9. 用Alpha-Beta算法搜索这些着法；  while ((mv = MoveSort.NextQuiesc(bInCheck)) != 0) {    __ASSERT(bInCheck || pos.ucpcSquares[DST(mv)] > 0);    if (pos.MakeMove(mv)) {      vl = -SearchQuiesc(pos, -vlBeta, -vlAlpha);      pos.UndoMakeMove();      if (vl > vlBest) {        if (vl >= vlBeta) {#ifdef HASH_QUIESC          if (vl > -WIN_VALUE && vl < WIN_VALUE) {            RecordHashQ(pos, vl, MATE_VALUE);          }#endif          return vl;        }        vlBest = vl;        vlAlpha = MAX(vl, vlAlpha);      }    }  }  // 10. 返回分值。  if (vlBest == -MATE_VALUE) {    __ASSERT(pos.IsMate());    return pos.nDistance - MATE_VALUE;  } else {#ifdef HASH_QUIESC    if (vlBest > -WIN_VALUE && vlBest < WIN_VALUE) {      RecordHashQ(pos, vlBest > vlAlpha ? vlBest : -MATE_VALUE, vlBest);    }#endif    return vlBest;  }}

//.........这里部分代码省略.........	entry = operand(isp);	entryt = operand(isp);	if(isize < 0 || dsize < 0 || hsize < 0 || lsize < 0) {		kwerrstr("implausible Dis file");		goto bad;	}	m->nprog = isize;	m->prog = mallocz(isize*sizeof(Inst), 0);	if(m->prog == nil) {		kwerrstr(exNomem);		goto bad;	}	m->ref = 1;	ip = m->prog;	for(i = 0; i < isize; i++) {		ip->op = *istream++;		ip->add = *istream++;		ip->reg = 0;		ip->s.imm = 0;		ip->d.imm = 0;		switch(ip->add & ARM) {		case AXIMM:		case AXINF:		case AXINM:			ip->reg = operand(isp);		 	break;		}		switch(UXSRC(ip->add)) {		case SRC(AFP):		case SRC(AMP):			case SRC(AIMM):			ip->s.ind = operand(isp);			break;		case SRC(AIND|AFP):		case SRC(AIND|AMP):			ip->s.i.f = operand(isp);			ip->s.i.s = operand(isp);			break;		}		switch(UXDST(ip->add)) {		case DST(AFP):		case DST(AMP):				ip->d.ind = operand(isp);			break;		case DST(AIMM):			ip->d.ind = operand(isp);			if(brpatch(ip, m) == 0) {				kwerrstr("bad branch addr");				goto bad;			}			break;		case DST(AIND|AFP):		case DST(AIND|AMP):			ip->d.i.f = operand(isp);			ip->d.i.s = operand(isp);			break;		}		ip++;			}	m->ntype = hsize;	m->type = malloc(hsize*sizeof(Type*));	if(m->type == nil) {		kwerrstr(exNomem);		goto bad;	}	for(i = 0; i < hsize; i++) {		id = operand(isp);		if(id > hsize) {			kwerrstr("heap id range");			goto bad;		}		tsz = operand(isp);		tnp = operand(isp);		if(tsz < 0 || tnp < 0 || tnp > 128*1024){			kwerrstr("implausible Dis file");			goto bad;		}		pt = dtype(freeheap, tsz, istream, tnp);		if(pt == nil) {			kwerrstr(exNomem);			goto bad;		}		istream += tnp;		m->type[id] = pt;	}	if(dsize != 0) {		pt = m->type[0];		if(pt == 0 || pt->size != dsize) {			kwerrstr("bad desc for mp");			goto bad;		}		h = heapz(pt);		m->origmp = H2D(uchar*, h);	}