/**
* 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);
}
int
call_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;
}
int ChessBoard::_movePiece(int mv)
{
int sqSrc, sqDst, pc, pcCaptured;
sqSrc = SRC(mv);
sqDst = DST(mv);
pcCaptured = m_data[sqDst];
delPiece(sqDst, pcCaptured);
pc = m_data[sqSrc];
delPiece(sqSrc, pc);
addPiece(sqDst, pc);
//qDebug()<<"movePiece"<< m_vlBlack<<","<<m_vlRed;
return pcCaptured;
}
int _PositionStruct::MovePiece(int mv) {
int sqSrc, sqDst, pc, pcCaptured;
sqSrc = SRC(mv);
sqDst = DST(mv);
pcCaptured = ucpcSquares[sqDst];
if (pcCaptured != 0) {
DelPiece(sqDst, pcCaptured);
}
pc = ucpcSquares[sqSrc];
DelPiece(sqSrc, pc);
AddPiece(sqDst, pc);
return pcCaptured;
}
void ChessBoard::_undoMovePiece(int mv, int pcCaptured)
{
int sqSrc, sqDst, pc;
sqSrc = SRC(mv);
sqDst = DST(mv);
pc = m_data[sqDst];
delPiece(sqDst, pc);
addPiece(sqSrc, pc);
if (pcCaptured != 0)
{
addPiece(sqDst, pcCaptured);
}
//qDebug()<<"undoMovePiece"<< m_vlBlack<<","<<m_vlRed;
}
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;
}
}
}
}
}
}
} else {
// 如果车横向移动了，则判断车纵向吃到的子
lpsmv = FileMovePtr(x, y);
for (i = 0; i < 2; i ++) {
sqDst = lpsmv->ucRookCap[i] + FILE_DISP(x);
__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;
}
}
}
}
}
}
}
break;
// 3. 走了炮，判断是否捉车或捉有根的马兵(卒)
case CANNON_FROM:
case CANNON_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->ucCannonCap[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 {
// 炮捉到了车
return pcCaptured;
}
}
} else {
// 炮捉炮的情况不予考虑
if (pcCaptured >= PAWN_FROM) {
// 炮捉到了兵(卒)，要判断兵(卒)是否过河并受保护
if (AWAY_HALF(sqDst, sdPlayer) && !Protected(this->sdPlayer, sqDst)) {
return pcCaptured;
}
}
}
}
}
}
} else {
// 如果炮横向移动了，则判断炮纵向吃到的子
lpsmv = FileMovePtr(x, y);
for (i = 0; i < 2; i ++) {
sqDst = lpsmv->ucCannonCap[i] + FILE_DISP(x);
__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 {
// 炮捉到了车
return pcCaptured;
}
}
} else {
// 炮捉炮的情况不予考虑
if (pcCaptured >= PAWN_FROM) {
// 炮捉到了兵(卒)，要判断兵(卒)是否过河并受保护
if (AWAY_HALF(sqDst, sdPlayer) && !Protected(this->sdPlayer, sqDst)) {
return pcCaptured;
}
}
}
}
}
}
}
break;
}
return 0;
}
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);
}
BOOL _PositionStruct::LegalMove(int mv) const {
int sqSrc, sqDst, sqPin;
int pcSelfSide, pcSrc, pcDst, nDelta;
sqSrc = SRC(mv);
pcSrc = ucpcSquares[sqSrc];
pcSelfSide = SIDE_TAG(sdPlayer);
if ((pcSrc & pcSelfSide) == 0) {
return FALSE;
}
sqDst = DST(mv);
pcDst = ucpcSquares[sqDst];
if ((pcDst & pcSelfSide) != 0) {
return FALSE;
}
switch (pcSrc - pcSelfSide) {
case PIECE_KING:
return IN_FORT(sqDst) && KING_SPAN(sqSrc, sqDst);
case PIECE_ADVISOR:
return IN_FORT(sqDst) && ADVISOR_SPAN(sqSrc, sqDst);
case PIECE_BISHOP:
return SAME_HALF(sqSrc, sqDst) && BISHOP_SPAN(sqSrc, sqDst) &&
ucpcSquares[BISHOP_PIN(sqSrc, sqDst)] == 0;
case PIECE_KNIGHT:
sqPin = KNIGHT_PIN(sqSrc, sqDst);
return sqPin != sqSrc && ucpcSquares[sqPin] == 0;
case PIECE_ROOK:
case PIECE_CANNON:
if (SAME_RANK(sqSrc, sqDst)) {
nDelta = (sqDst < sqSrc ? -1 : 1);
} else if (SAME_FILE(sqSrc, sqDst)) {
nDelta = (sqDst < sqSrc ? -16 : 16);
} else {
return FALSE;
}
sqPin = sqSrc + nDelta;
while (sqPin != sqDst && ucpcSquares[sqPin] == 0) {
sqPin += nDelta;
}
if (sqPin == sqDst) {
return pcDst == 0 || pcSrc - pcSelfSide == PIECE_ROOK;
} else if (pcDst != 0 && pcSrc - pcSelfSide == PIECE_CANNON) {
sqPin += nDelta;
while (sqPin != sqDst && ucpcSquares[sqPin] == 0) {
sqPin += nDelta;
}
return sqPin == sqDst;
} else {
return FALSE;
}
case PIECE_PAWN:
if (AWAY_HALF(sqDst, sdPlayer) && (sqDst == sqSrc - 1 || sqDst == sqSrc + 1)) {
return TRUE;
}
return sqDst == SQUARE_FORWARD(sqSrc, sdPlayer);
default:
return FALSE;
}
}
// 将内部着法表示转换为纵线符号
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;
}
}
Module*
parsemod(char *path, uchar *code, ulong length, Dir *dir)
{
Heap *h;
Inst *ip;
Type *pt;
String *s;
Module *m;
Array *ary;
ulong ul[2];
WORD lo, hi;
int lsize, id, v, entry, entryt, tnp, tsz, siglen;
int de, pc, i, n, isize, dsize, hsize, dasp;
uchar *mod, sm, *istream, **isp, *si, *addr, *dastack[DADEPTH];
Link *l;
istream = code;
isp = &istream;
m = malloc(sizeof(Module));
if(m == nil)
return nil;
m->dev = dir->dev;
m->dtype = dir->type;
m->qid = dir->qid;
m->mtime = dir->mtime;
m->origmp = H;
m->pctab = nil;
switch(operand(isp)) {
default:
kwerrstr("bad magic");
goto bad;
case SMAGIC:
siglen = operand(isp);
n = length-(*isp-code);
if(n < 0 || siglen > n){
kwerrstr("corrupt signature");
goto bad;
}
if(verifysigner(*isp, siglen, *isp+siglen, n-siglen) == 0) {
kwerrstr("security violation");
goto bad;
}
*isp += siglen;
break;
case XMAGIC:
if(mustbesigned(path, code, length, dir)){
kwerrstr("security violation: not signed");
goto bad;
}
break;
}
m->rt = operand(isp);
m->ss = operand(isp);
isize = operand(isp);
dsize = operand(isp);
hsize = operand(isp);
lsize = operand(isp);
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);
}
