/**
* 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;
}
}
PixelBuf GradientMap::GetRegion(
const MapPixelCoordInt &pos, const MapPixelDeltaInt &size) const
{
auto fixed_bounds_pb = GetRegion_BoundsHelper(*this, pos, size);
if (fixed_bounds_pb.GetData())
return fixed_bounds_pb;
//time_counter_loaddisc.Start();
MapPixelCoordInt req_pos = pos - MapPixelDeltaInt(1, 1);
MapPixelDeltaInt req_size = size + MapPixelDeltaInt(2, 2);
auto orig_data = m_orig_map->GetRegion(req_pos, req_size);
//auto orig_data = LoadBufferFromBMP(L"example.bmp");
PixelBuf result(size.x, size.y);
unsigned int *src = orig_data.GetRawData();
unsigned int *dest = result.GetRawData();
//time_counter_loaddisc.Stop();
//time_counter.Start();
for (int x=0; x < size.x; x++) {
for (int y=0; y < size.y; y++) {
unsigned int elevation = SRC(x+1, y+1);
MapPixelCoordInt pos(x+1, y+1);
MapBezierGradient grad = Fast3x3CenterGradient(src, pos, req_size);
DEST(x, y) = HSV_to_RGB(
255*240/360 - elevation*255/4000,
255,
ValueBetween(0,
static_cast<int>(128+1.25*(grad.x-grad.y)),
255));
}
}
//time_counter.Stop();
return result;
}
// 点击格子事件处理
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);
}
void DS_SFX_Load(sfxbuffer_t* buf, struct sfxsample_s* sample)
{
if(!buf || !sample) return;
// Does the buffer already have a sample loaded?
if(buf->sample)
{
// Is the same one?
if(buf->sample->id == sample->id)
return; // No need to reload.
}
// Make sure its not bound right now.
alSourcei(SRC(buf), AL_BUFFER, 0);
alBufferData(BUF(buf),
sample->bytesPer == 1 ? AL_FORMAT_MONO8 : AL_FORMAT_MONO16,
sample->data, sample->size, sample->rate);
if(DSOPENAL_ERRCHECK(alGetError()))
{
/// @todo What to do?
}
buf->sample = sample;
}
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)));
}
void DS_SFX_Stop(sfxbuffer_t* buf)
{
if(!buf || !buf->sample) return;
alSourceRewind(SRC(buf));
buf->flags &= ~SFXBF_PLAYING;
}
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;
}
/**
* Stops the buffer and makes it forget about its sample.
*/
void DS_SFX_Reset(sfxbuffer_t* buf)
{
if(!buf) return;
DS_SFX_Stop(buf);
alSourcei(SRC(buf), AL_BUFFER, 0);
buf->sample = NULL;
}
// 搬一步棋的棋子
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 BitmapUtil::scaleDown(const U8 *srcBuffer, U8 *dstBuffer, S32 components,
S32 dstWidth, S32 dstHeight) {
S32 x, y, c;
S32 srcWidth = dstWidth << 1;
// Scale in half by a simple box filter (4 samples)
for (y = 0; y < dstHeight; ++y) {
for (x = 0; x < dstWidth; ++x) {
S32 dstI = (y * dstWidth + x) * components;
for (c = 0; c < components; ++c) {
dstBuffer[dstI + c] = (srcBuffer[SRC(x<<1,y<<1) + c]
+ srcBuffer[SRC((x<<1)+1,y<<1) + c]
+ srcBuffer[SRC(x<<1,(y<<1)+1) + c]
+ srcBuffer[SRC((x<<1)+1,(y<<1)+1) + c]) >> 2;
}
}
}
}
PUBLIC err_t
some_df_write(MemDev *mdev, laddr_t addr, SomeDF *df)
{
err_t err;
err = mdev->write(addr, sizeof(*df), SRC(df));
if (err) return E_HWW;
return E_GOOD;
}
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);
}
}
void DS_SFX_Refresh(sfxbuffer_t* buf)
{
ALint state;
if(!buf || !buf->sample) return;
alGetSourcei(SRC(buf), AL_SOURCE_STATE, &state);
if(state == AL_STOPPED)
{
buf->flags &= ~SFXBF_PLAYING;
}
}
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;
}
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;
}
/**
* Identify dirname and basename of a path.
*
* @param[in] path, the path to be split up
* @param[out] dir, the directory part of path
* @param[out] base, the basename of path
*
* @return the length of input path
*
* NOTE! we force dir to be preallocated at minimum to length of path!!!
*/
PUBLIC u8
path_split (const path_t path, path_t dir, fid_t *base)
{
u8 l = path_length(path);
if (!l) return 0;
memcpy(DEST(dir), SRC(path), l * sizeof(*path));
dir[l-1] = EOP;
*base = path[l-1];
return l;
}
void DS_SFX_DestroyBuffer(sfxbuffer_t* buf)
{
ALuint srcName, bufName;
if(!buf) return;
srcName = SRC(buf);
bufName = BUF(buf);
alDeleteSources(1, &srcName);
alDeleteBuffers(1, &bufName);
Z_Free(buf);
}
void BuildPos(PositionStruct &pos, const UcciCommStruct &UcciComm) {
int i, mv;
pos.FromFen(UcciComm.szFenStr);
for (i = 0; i < UcciComm.nMoveNum; i ++) {
mv = COORD_MOVE(UcciComm.lpdwMovesCoord[i]);
if (mv == 0) {
break;
}
if (pos.ucpcSquares[SRC(mv)] == 0) {
break;
}
pos.MakeMove(mv);
}
}
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;
}
PUBLIC err_t
some_fh_write(MemDev *mdev, laddr_t addr, SomeFH *fh)
{
err_t err;
CHECK_PARAM__NOT_NULL( mdev );
CHECK_PARAM__NOT_ZERO( addr );
CHECK_PARAM__NOT_NULL( fh );
if (fh_is_invalid(fh)) return E_BAD_PARAM;
err = mdev->write(addr, sizeof(*fh), SRC(fh));
if (err) return E_HWW;
return E_GOOD;
}
PUBLIC err_t
some_sb_write(MemDev *mdev, SomeSB *sb)
{
err_t err;
CHECK_PARAM__NOT_NULL (sb);
CHECK_PARAM__NOT_NULL (mdev);
if (sb_is_invalid(sb, mdev))
return E_BAD_PARAM;
err = mdev->write(0, sizeof(*sb), SRC(sb));
if (err) return E_INTERN | err;
return E_GOOD;
}
void DS_SFX_Play(sfxbuffer_t* buf)
{
ALuint source;
// Playing is quite impossible without a sample.
if(!buf || !buf->sample) return;
source = SRC(buf);
alSourcei(source, AL_BUFFER, BUF(buf));
alSourcei(source, AL_LOOPING, (buf->flags & SFXBF_REPEAT) != 0);
alSourcePlay(source);
DSOPENAL_ERRCHECK(alGetError());
// The buffer is now playing.
buf->flags |= SFXBF_PLAYING;
}
void DS_SFX_Set(sfxbuffer_t* buf, int prop, float value)
{
ALuint source;
if(!buf) return;
source = SRC(buf);
switch(prop)
{
case SFXBP_VOLUME:
alSourcef(source, AL_GAIN, value);
break;
case SFXBP_FREQUENCY: {
unsigned int dw = (int) (buf->rate * value);
if(dw != buf->freq) // Don't set redundantly.
{
buf->freq = dw;
alSourcef(source, AL_PITCH, value);
}
break; }
case SFXBP_PAN:
setPan(source, value);
break;
case SFXBP_MIN_DISTANCE:
alSourcef(source, AL_REFERENCE_DISTANCE, value / unitsPerMeter);
break;
case SFXBP_MAX_DISTANCE:
alSourcef(source, AL_MAX_DISTANCE, value / unitsPerMeter);
break;
case SFXBP_RELATIVE_MODE:
alSourcei(source, AL_SOURCE_RELATIVE, value ? AL_TRUE : AL_FALSE);
break;
default: break;
}
}
/* 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;
}
void DS_SFX_Setv(sfxbuffer_t* buf, int prop, float* values)
{
ALuint source;
if(!buf || !values) return;
source = SRC(buf);
switch(prop)
{
case SFXBP_POSITION:
alSource3f(source, AL_POSITION, values[VX] / unitsPerMeter,
values[VZ] / unitsPerMeter, values[VY] / unitsPerMeter);
break;
case SFXBP_VELOCITY:
alSource3f(source, AL_VELOCITY, values[VX] / unitsPerMeter,
values[VZ] / unitsPerMeter, values[VY] / unitsPerMeter);
break;
default: break;
}
}
* 4x4 prediction for intra luma block
****************************************************************************/
#define SRC(x,y) src[(x)+(y)*FDEC_STRIDE]
#define SRC_X4(x,y) MPIXEL_X4( &SRC(x,y) )
#define PREDICT_4x4_DC(v)\
SRC_X4(0,0) = SRC_X4(0,1) = SRC_X4(0,2) = SRC_X4(0,3) = v;
static void x264_predict_4x4_dc_128_c( pixel *src )
{
PREDICT_4x4_DC( PIXEL_SPLAT_X4( 1 << (BIT_DEPTH-1) ) );
}
static void x264_predict_4x4_dc_left_c( pixel *src )
{
pixel4 dc = PIXEL_SPLAT_X4( (SRC(-1,0) + SRC(-1,1) + SRC(-1,2) + SRC(-1,3) + 2) >> 2 );
PREDICT_4x4_DC( dc );
}
static void x264_predict_4x4_dc_top_c( pixel *src )
{
pixel4 dc = PIXEL_SPLAT_X4( (SRC(0,-1) + SRC(1,-1) + SRC(2,-1) + SRC(3,-1) + 2) >> 2 );
PREDICT_4x4_DC( dc );
}
void x264_predict_4x4_dc_c( pixel *src )
{
pixel4 dc = PIXEL_SPLAT_X4( (SRC(-1,0) + SRC(-1,1) + SRC(-1,2) + SRC(-1,3) +
SRC(0,-1) + SRC(1,-1) + SRC(2,-1) + SRC(3,-1) + 4) >> 3 );
PREDICT_4x4_DC( dc );
}
void x264_predict_4x4_h_c( pixel *src )
{
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;
}
}
bool WidgetAugmentedView::render()
{
if (!stream) return false;
stream->getColorFrame(colorFrame);
stream->getDepthFrame(depthFrame);
// Correct the depth map
if (depthCorrector == nullptr) depthBuffer = depthFrame;
else depthCorrector->correct(depthFrame, depthBuffer);
// Setup perspective
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(fovY, float(ColorFrame::WIDTH) / float(ColorFrame::HEIGHT), zNear, zFar);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glEnable(GL_DEPTH_TEST);
glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
//
// Draw real world (2D color image)
//
glDepthFunc(GL_ALWAYS);
glActiveTexture(GL_TEXTURE0);
glBindTexture(GL_TEXTURE_2D, textureColor);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, ColorFrame::WIDTH, ColorFrame::HEIGHT,
GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid*)colorFrame.pixels);
glActiveTexture(GL_TEXTURE1);
glBindTexture(GL_TEXTURE_2D, textureDepth);
KinectStream* kinect = dynamic_cast<KinectStream*>(stream.obj);
if (kinect != nullptr) {
kinect->mapColorFrameToDepthFrame(depthBuffer, OUT mapping);
const NUI_DEPTH_IMAGE_POINT* src = mapping;
GLushort* dest = textureDepthBuffer;
GLushort* end = textureDepthBuffer + ColorFrame::SIZE;
#define SRC(i) static_cast<short>(static_cast<unsigned short>((src + i)->depth))
#ifndef NOT_VECTORIZED
// Vectorized assuming ColorFrame::SIZE % 8 == 0
__m128i min = _mm_set1_epi16(static_cast<short>(DepthFrame::MIN_DEPTH));
__m128i max = _mm_set1_epi16(static_cast<short>(DepthFrame::MAX_DEPTH));
__m128i _0 = _mm_setzero_si128();
for (; dest < end; dest += 8, src += 8) {
__m128i v = _mm_set_epi16(SRC(7), SRC(6), SRC(5), SRC(4), SRC(3), SRC(2), SRC(1), SRC(0));
v = _mm_max_epu16(min, _mm_min_epu16(max, v));
v = _mm_blendv_epi8(v, max, _mm_cmpeq_epi16(_0, v));
_mm_store_si128((__m128i*)dest, v);
}
#else
for (; dest < end; ++dest, ++src) {
unsigned short s = SRC(0);
s = (s > DepthFrame::MAX_DEPTH) ? DepthFrame::MAX_DEPTH : s;
s = (s < DepthFrame::MIN_DEPTH) ? DepthFrame::MIN_DEPTH : s;
*dest = static_cast<GLushort>(s);
}
#endif
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, ColorFrame::WIDTH, ColorFrame::HEIGHT,
GL_RED_INTEGER, GL_UNSIGNED_SHORT, (GLvoid*)textureDepthBuffer);
}
glActiveTexture(GL_TEXTURE0);
shader2D.bind();
RenderUtils::drawRect(-1.0f, 1.0f, 2.0f, -2.0f);
shader2D.release();
//
// Draw augmented world
//
glDepthFunc(GL_LESS);
glScalef(1.0f, 1.0f, -1.0f); // Invert Z axis so that +Z is in front of the camera
// A plane to test occlusion
/*glColor3f(0.0f, 1.0f, 0.0f);
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(-0.5f, -0.5f, 0.5f);
glVertex3f(-0.5f, 0.5f, 2.5f);
glVertex3f(0.5f, -0.5f, 2.5f);
glVertex3f(0.5f, 0.5f, 4.5f);
glEnd();*/
glEnable(GL_LIGHTING);
// Draw the objects
world.render(renderManager);
glDisable(GL_LIGHTING);
return true;
}
// 将内部着法表示转换为纵线符号
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;
}
