void CCoronas::Update()
{
ScreenMult = min(1.0f, (float)*(DWORD*)0xB7CB5C * 0.03f + ScreenMult);
static unsigned int nSomeHackyMask = 0;
unsigned int nThisHackyMask = 0;
if (TheCamera.Cams[TheCamera.ActiveCam].LookingLeft)
nThisHackyMask |= 1;
if (TheCamera.Cams[TheCamera.ActiveCam].LookingRight)
nThisHackyMask |= 2;
if (TheCamera.Cams[TheCamera.ActiveCam].LookingBehind)
nThisHackyMask |= 4;
if (TheCamera.GetLookDirection())
nThisHackyMask |= 8;
if (nSomeHackyMask == nThisHackyMask)
bChangeBrightnessImmediately = max(0, bChangeBrightnessImmediately - 1);
else
{
bChangeBrightnessImmediately = 3;
nSomeHackyMask = nThisHackyMask;
}
auto pNode = UsedList.First();
if (pNode)
{
while (pNode != &UsedList)
{
unsigned int nIndex = pNode->GetFrom()->Identifier;
auto pNext = pNode->GetNextNode();
pNode->GetFrom()->Update();
// Did it become invalid?
if (!pNode->GetFrom()->Identifier)
{
// Remove from used list
pNode->Add(&FreeList);
UsedMap.erase(nIndex);
}
pNode = pNext;
}
}
}
// Based on FormatCit(Book)Art from the C Toolkit's api/asn2gnb5.c.
bool CCit_art::GetLabelV2(string* label, TLabelFlags flags) const
{
switch (GetFrom().Which()) {
case C_From::e_not_set:
return false;
case C_From::e_Journal:
return GetFrom().GetJournal()
.GetLabel(label, flags | fLabel_ISO_JTA, eLabel_V2);
case C_From::e_Book:
return x_GetLabelV2(label, flags, GetFrom().GetBook());
case C_From::e_Proc:
return x_GetLabelV2(label, flags, GetFrom().GetProc().GetBook());
}
return false;
}
wxString wxEmailMessage::PayLoad() const
{
wxString payload;
payload << "Date: " << wxDateTime::Now().Format() << "\r\n";
payload << "To: " << GetTo() << "\r\n";
payload << "From: " << GetFrom() << "\r\n";
payload << "Cc: \r\n";
payload << "Message-ID: " << GenerateID() << "\r\n";
payload << "Subject: " << GetSubject() << "\r\n";
// Sending attachment
payload << "Content-Type: multipart/mixed; boundary=\"" << BOUNDRY_LINE << "\"\r\n";
payload << "Mime-version: 1.0\r\n";
payload << "\r\n";
payload << "This is a multi-part message in MIME format. \r\n";
// Message body
if(!GetMessage().IsEmpty()) {
payload << "\r\n--" << BOUNDRY_LINE << "\r\n";
payload << "Content-Type: text/plain; charset=\"us-ascii\"\r\n";
payload << "Content-Transfer-Encoding: quoted-printable \r\n";
payload << "\r\n";
payload << GetMessage() << "\r\n";
}
if(!m_attachements.IsEmpty()) {
for(size_t i = 0; i < m_attachements.size(); ++i) {
DoAddAttachment(m_attachements.Item(i), payload);
}
}
payload << "\r\n";
return payload;
}
Move MakeMoveFromUciString(Position &position, const std::string &moveString)
{
const Square from = MakeSquare(RANK_1 - (moveString[1] - '1'), moveString[0] - 'a');
const Square to = MakeSquare(RANK_1 - (moveString[3] - '1'), moveString[2] - 'a');
if (moveString.length() == 5)
{
int promotionType;
switch (tolower(moveString[4]))
{
case 'n': promotionType = PromotionTypeKnight; break;
case 'b': promotionType = PromotionTypeBishop; break;
case 'r': promotionType = PromotionTypeRook; break;
case 'q': promotionType = PromotionTypeQueen; break;
}
return GeneratePromotionMove(from, to, promotionType);
}
Move moves[256];
int moveCount = GenerateLegalMoves(position, moves);
for (int i = 0; i < moveCount; i++)
{
if (GetFrom(moves[i]) == from && GetTo(moves[i]) == to)
{
return moves[i];
}
}
ASSERT(false);
return 0;
}
bool AbuttingWith(const TThisType& r) const
{
if (Empty() || IsWhole() || r.Empty() || r.IsWhole()) {
return false;
}
return GetToOpen() == r.GetFrom() || GetFrom() == r.GetToOpen();
}
bool
RenderFrameParent::Init(nsFrameLoader* aFrameLoader)
{
if (mInitted || !aFrameLoader) {
return false;
}
mFrameLoader = aFrameLoader;
RefPtr<LayerManager> lm = GetFrom(mFrameLoader);
mAsyncPanZoomEnabled = lm && lm->AsyncPanZoomEnabled();
TabParent* browser = TabParent::GetFrom(mFrameLoader);
if (XRE_IsParentProcess()) {
// Our remote frame will push layers updates to the compositor,
// and we'll keep an indirect reference to that tree.
browser->Manager()->AsContentParent()->AllocateLayerTreeId(browser, &mLayersId);
if (lm && lm->AsClientLayerManager()) {
lm->AsClientLayerManager()->GetRemoteRenderer()->SendNotifyChildCreated(mLayersId);
}
} else if (XRE_IsContentProcess()) {
ContentChild::GetSingleton()->SendAllocateLayerTreeId(browser->Manager()->ChildID(), browser->GetTabId(), &mLayersId);
CompositorBridgeChild::Get()->SendNotifyChildCreated(mLayersId);
}
mInitted = true;
return true;
}
void BaseCamera::ViewPointToRay(float fVx, float fVy, noVec3& kOrigin,
noVec3& kDir) const
{
if (m_mode == CAMERA_ORTHOGRAPHIC || m_mode == CAMERA_COMPUTE_ORTHOGRAPHIC)
{
kDir = GetWorldForward();
kDir.Normalize();
kOrigin = GetFrom() + GetWorldRight() * fVx + GetWorldUp() * fVy;
}
else
{
kDir = GetWorldForward() + GetWorldRight() * fVx + GetWorldUp() * fVy;
kDir.Normalize();
kOrigin = GetFrom();
}
}
// length must be >= 0
TThisType& SetLength(position_type length)
{
_ASSERT(!SPositionTraits<position_type>::IsNegative(length));
position_type from = GetFrom();
position_type toOpen = from + length;
if ( toOpen < from )
toOpen = GetWholeToOpen();
return SetToOpen(toOpen);
}
// return length of regular region
position_type GetLength(void) const
{
position_type from = GetFrom(), toOpen = GetToOpen();
if ( toOpen <= from )
return 0;
position_type len = toOpen - from;
if ( SPositionTraits<position_type>::IsNegative(len) )
len = GetWholeLength();
return len;
}
void
RenderFrameParent::GetTextureFactoryIdentifier(TextureFactoryIdentifier* aTextureFactoryIdentifier)
{
RefPtr<LayerManager> lm = mFrameLoader ? GetFrom(mFrameLoader) : nullptr;
// Perhaps the document containing this frame currently has no presentation?
if (lm && lm->AsClientLayerManager()) {
*aTextureFactoryIdentifier = lm->AsClientLayerManager()->GetTextureFactoryIdentifier();
} else {
*aTextureFactoryIdentifier = TextureFactoryIdentifier();
}
}
bool CCit_art::GetLabelV1(string* label, TLabelFlags flags) const
{
const CCit_jour* journal = 0;
const CCit_book* book = 0;
const CImprint* imprint = 0;
const CAuth_list* authors = 0;
const CTitle* title = 0;
const string* titleunique = 0;
if ( IsSetAuthors() ) {
authors = &GetAuthors();
}
if ( IsSetTitle() ) {
titleunique = &GetTitle().GetTitle();
}
switch ( GetFrom().Which() ) {
case C_From::e_Journal:
journal = &GetFrom().GetJournal();
imprint = &journal->GetImp();
title = &journal->GetTitle();
break;
case C_From::e_Book:
book = &GetFrom().GetBook();
imprint = &book->GetImp();
if (!authors) {
authors = &book->GetAuthors();
}
break;
case C_From::e_Proc:
book = &GetFrom().GetProc().GetBook();
imprint = &book->GetImp();
if (!authors) {
authors = &book->GetAuthors();
}
default:
break;
}
return x_GetLabelV1(label, (flags & fLabel_Unique) != 0, authors, imprint,
title, book, journal, 0, 0, titleunique);
}
void
RenderFrameParent::OwnerContentChanged(nsIContent* aContent)
{
MOZ_ASSERT(!mFrameLoader || mFrameLoader->GetOwnerContent() == aContent,
"Don't build new map if owner is same!");
RefPtr<LayerManager> lm = mFrameLoader ? GetFrom(mFrameLoader) : nullptr;
// Perhaps the document containing this frame currently has no presentation?
if (lm && lm->AsClientLayerManager()) {
lm->AsClientLayerManager()->GetRemoteRenderer()->SendAdoptChild(mLayersId);
FrameLayerBuilder::InvalidateAllLayers(lm);
}
}
//POS tagging with Hidden Markov Model
bool CSpan::POSTagging(PWORD_RESULT pWordItems,CDictionary &dictCore,CDictionary &dictUnknown)
{
//pWordItems: Items; nItemCount: the count of items;core dictionary and unknown recognition dictionary
int i=0,j,nStartPos;
Reset(false);
while(i>-1&&pWordItems[i].sWord[0]!=0)
{
nStartPos=i;//Start Position
i=GetFrom(pWordItems,nStartPos,dictCore,dictUnknown);
GetBestPOS();
switch(m_tagType)
{
case TT_NORMAL://normal POS tagging
j=1;
while(m_nBestTag[j]!=-1&&j<m_nCurLength)
{//Store the best POS tagging
pWordItems[j+nStartPos-1].nHandle=m_nBestTag[j];
//Let 。be 0
if(pWordItems[j+nStartPos-1].dValue>0&&dictCore.IsExist(pWordItems[j+nStartPos-1].sWord,-1))//Exist and update its frequncy as a POS value
pWordItems[j+nStartPos-1].dValue=LOG_MAX_FRQUENCE-log((double)dictCore.GetFrequency(pWordItems[j+nStartPos-1].sWord,m_nBestTag[j])+1);
j+=1;
}
break;
case TT_PERSON://Person recognition
/*clock_t lStart,lEnd;
lStart=clock();
*/
SplitPersonPOS(dictUnknown);
//lEnd=clock();
//printf("SplitPersonPOS=%f\n",(double)(lEnd-lStart)*1000/CLOCKS_PER_SEC);
//Spit Persons POS
//lStart=clock();
PersonRecognize(dictUnknown);
//lEnd=clock();
//printf("PersonRecognize=%f\n",(double)(lEnd-lStart)/CLOCKS_PER_SEC);
//Person Recognition with the person recognition dictionary
break;
case TT_PLACE://Place name recognition
PlaceRecognize(dictCore,dictUnknown);
break;
case TT_TRANS://Transliteration
TransRecognize(dictCore,dictUnknown);
break;
default:
break;
}
Reset();
}
return true;
}
CString CPop3Message::GetReplyTo() const
{
CString sRet = GetHeaderItem("Reply-To");
if (sRet.IsEmpty())
{
sRet = GetFrom();
if (sRet.IsEmpty())
{
sRet = GetHeaderItem(_T("Sender"));
if (sRet.IsEmpty())
sRet = GetHeaderItem(_T("Return-Path"));
}
}
return sRet;
}
void
RenderFrameParent::EnsureLayersConnected()
{
RefPtr<LayerManager> lm = GetFrom(mFrameLoader);
if (!lm) {
return;
}
ClientLayerManager* client = lm->AsClientLayerManager();
if (!client) {
return;
}
client->GetRemoteRenderer()->SendNotifyChildRecreated(mLayersId);
}
void wxSVGAnimateTransformElement::ApplyAnimation() {
wxSVGElement* targetElement = GetTargetElement();
if (targetElement == NULL || GetDur() <= 0 || (GetTo().GetPropertyType() != wxSVG_ANIMATED_LENGTH
&& GetTo().GetPropertyType() != wxSVG_ANIMATED_LENGTH_LIST))
return;
wxSVGLengthList values;
if (GetCurrentTime() >= GetStartTime() + GetDur()) {
if (GetTo().GetPropertyType() == wxSVG_ANIMATED_LENGTH) {
values.push_back(GetTo().GetLength());
} else {
values = GetTo().GetLengthList();
}
} else if (GetCurrentTime() >= GetStartTime() && GetFrom().GetPropertyType() == GetTo().GetPropertyType()
&& GetFrom().GetLengthList().size() == GetTo().GetLengthList().size()) {
if (GetTo().GetPropertyType() == wxSVG_ANIMATED_LENGTH) {
values.Add(wxSVGLength(GetTo().GetLength().GetUnitType(), GetFrom().GetLength().GetValue()
+ (GetTo().GetLength().GetValue() - GetFrom().GetLength().GetValue())*
(GetCurrentTime() - GetStartTime())/GetDur()));
} else {
for (unsigned int i = 0; i < GetFrom().GetLengthList().size(); i++) {
const wxSVGLength& from = GetFrom().GetLengthList()[i];
const wxSVGLength& to = GetTo().GetLengthList()[i];
values.Add(wxSVGLength(to.GetUnitType(), from.GetValue()
+ (to.GetValue() - from.GetValue())*(GetCurrentTime() - GetStartTime())/GetDur()));
}
}
} else {
return;
}
wxSVGTransformable* transformable = wxSVGTransformable::GetSVGTransformable(*targetElement);
if (transformable != NULL) {
if (m_transformIdx == -1 || m_transformIdx >= (int) transformable->GetTransformList().GetAnimVal().size()) {
wxSVGTransformList& transforms = transformable->GetTransformList().GetAnimVal();
if (GetAdditive() != wxSVG_ANIMATION_ADDITIVE_SUM) {
transforms.Clear();
}
wxSVGTransform* transform = new wxSVGTransform();
UpdateTransform(*transform, GetType(), values);
transforms.Add(transform);
m_transformIdx = transforms.size() - 1;
} else {
UpdateTransform(transformable->GetTransformList().GetAnimVal()[m_transformIdx], GetType(), values);
}
} else {
wxSVGTransformList transforms;
wxSVGTransform* transform = new wxSVGTransform();
UpdateTransform(*transform, GetType(), values);
transforms.Add(transform);
targetElement->SetAnimatedValue(GetAttributeName(), wxSVGAnimatedType(transforms));
}
}
std::string GetMoveUci(const Move move)
{
std::string result;
result += GetSquareSAN(GetFrom(move));
result += GetSquareSAN(GetTo(move));
if (GetMoveType(move) == MoveTypePromotion)
{
switch (GetPromotionMoveType(move))
{
case KNIGHT: result += "n"; break;
case BISHOP: result += "b"; break;
case ROOK: result += "r"; break;
case QUEEN: result += "q"; break;
}
}
return result;
}
void ribi::cmap::QtTestQtEdgeDialog::on_button_load_clicked() noexcept
{
const int index = ui->box_test_index->value();
assert(m_from);
assert(m_to);
assert(index >= 0);
assert(index < QtEdgeFactory().GetNumberOfTests());
const auto qtedge = QtEdgeFactory().GetTest(index,m_from,m_to);
assert(m_from->flags() & QGraphicsItem::ItemIsMovable);
assert(m_from->flags() & QGraphicsItem::ItemIsSelectable);
assert(m_to->flags() & QGraphicsItem::ItemIsMovable);
assert(m_to->flags() & QGraphicsItem::ItemIsSelectable);
SetQtEdge(qtedge);
assert(qtedge == m_qtedge_dialog->GetQtEdge());
assert(m_from->flags() & QGraphicsItem::ItemIsMovable);
assert(m_from->flags() & QGraphicsItem::ItemIsSelectable);
assert(m_to->flags() & QGraphicsItem::ItemIsMovable);
assert(m_to->flags() & QGraphicsItem::ItemIsSelectable);
//qtedge itself is not movable
//assert(qtedge->flags() & QGraphicsItem::ItemIsMovable);
//assert(qtedge->flags() & QGraphicsItem::ItemIsSelectable);
assert(qtedge->GetFrom()->flags() & QGraphicsItem::ItemIsMovable);
assert(qtedge->GetFrom()->flags() & QGraphicsItem::ItemIsSelectable);
assert(qtedge->GetTo()->flags() & QGraphicsItem::ItemIsMovable);
assert(qtedge->GetTo()->flags() & QGraphicsItem::ItemIsSelectable);
assert(qtedge->GetQtNode()->flags() & QGraphicsItem::ItemIsMovable);
assert(qtedge->GetQtNode()->flags() & QGraphicsItem::ItemIsSelectable);
this->m_qtedge_dialog->GetQtEdge()->GetFrom()->GetNode().GetConcept().SetName("From");
this->m_qtedge_dialog->GetQtEdge()->GetTo()->GetNode().GetConcept().SetName("To");
}
TSeqPos CSeq_interval::GetStop (ESeqLocExtremes ext) const
{
return ext == eExtreme_Biological && x_IsMinusStrand()?
GetFrom(): GetTo();
}
bool operator>=(const TThisType& r) const
{
return GetFrom() > r.GetFrom() ||
(GetFrom() == r.GetFrom() && GetToOpen() >= r.GetToOpen());
}
// comparison
bool operator==(const TThisType& r) const
{
return GetFrom() == r.GetFrom() && GetToOpen() == r.GetToOpen();
}
// intersecting ranges
TThisType IntersectionWith(const TThisType& r) const
{
return TThisType(max(GetFrom(), r.GetFrom()),
min(GetToOpen(), r.GetToOpen()));
}
bool IsWholeFrom(void) const
{
return GetFrom() == GetWholeFrom();
}
void CCoronas::RegisterCorona(unsigned int nID, CEntity* pAttachTo, unsigned char R, unsigned char G, unsigned char B, unsigned char A, const CVector& Position, float Size, float Range, RwTexture* pTex, unsigned char flareType, unsigned char reflectionType, unsigned char LOSCheck, unsigned char unused, float normalAngle, bool bNeonFade, float PullTowardsCam, bool bFadeIntensity, float FadeSpeed, bool bOnlyFromBelow, bool bWhiteCore)
{
UNREFERENCED_PARAMETER(unused);
CVector vecPosToCheck;
if (pAttachTo)
{
// TODO: AllocateMatrix
vecPosToCheck = *pAttachTo->GetMatrix() * Position;
}
else
vecPosToCheck = Position;
CVector* pCamPos = TheCamera.GetCoords();
if (Range * Range >= (pCamPos->x - vecPosToCheck.x)*(pCamPos->x - vecPosToCheck.x) + (pCamPos->y - vecPosToCheck.y)*(pCamPos->y - vecPosToCheck.y))
{
if (bNeonFade)
{
float fDistFromCam = CVector(*pCamPos - vecPosToCheck).Magnitude();
if (fDistFromCam < 35.0f)
return;
if (fDistFromCam < 50.0f)
A *= static_cast<unsigned char>((fDistFromCam - 35.0f) * (2.0f / 3.0f));
}
// Is corona already present?
CRegisteredCorona* pSuitableSlot;
auto it = UsedMap.find(nID);
if (it != UsedMap.end())
{
pSuitableSlot = it->second->GetFrom();
if (pSuitableSlot->FadedIntensity == 0 && A == 0)
{
// Mark as free
it->second->GetFrom()->Identifier = 0;
it->second->Add(&FreeList);
UsedMap.erase(nID);
return;
}
}
else
{
if (!A)
return;
// Adding a new element
auto pNewEntry = FreeList.First();
if (!pNewEntry)
{
MessageBoxA(0, "ERROR: Not enough space for coronas!", "ERROR: Not enough space for coronas!", 0);
return;
}
pSuitableSlot = pNewEntry->GetFrom();
// Add to used list and push this index to the map
pNewEntry->Add(&UsedList);
UsedMap[nID] = pNewEntry;
pSuitableSlot->FadedIntensity = bFadeIntensity ? 255 : 0;
pSuitableSlot->OffScreen = true;
pSuitableSlot->JustCreated = true;
pSuitableSlot->Identifier = nID;
}
pSuitableSlot->Red = R;
pSuitableSlot->Green = G;
pSuitableSlot->Blue = B;
pSuitableSlot->Intensity = A;
pSuitableSlot->Coordinates = Position;
pSuitableSlot->Size = Size;
pSuitableSlot->NormalAngle = normalAngle;
pSuitableSlot->Range = Range;
pSuitableSlot->pTex = pTex;
pSuitableSlot->FlareType = flareType;
pSuitableSlot->ReflectionType = reflectionType;
pSuitableSlot->LOSCheck = LOSCheck;
pSuitableSlot->RegisteredThisFrame = true;
pSuitableSlot->PullTowardsCam = PullTowardsCam;
pSuitableSlot->FadeSpeed = FadeSpeed;
pSuitableSlot->NeonFade = bNeonFade;
pSuitableSlot->OnlyFromBelow = bOnlyFromBelow;
pSuitableSlot->WhiteCore = bWhiteCore;
if (pAttachTo)
{
pSuitableSlot->bIsAttachedToEntity = true;
pSuitableSlot->pEntityAttachedTo = pAttachTo;
pAttachTo->RegisterReference(&pSuitableSlot->pEntityAttachedTo);
}
else
{
pSuitableSlot->bIsAttachedToEntity = false;
pSuitableSlot->pEntityAttachedTo = nullptr;
}
}
}
TThisType& IntersectWith(const TThisType& r)
{
m_From = max(GetFrom(), r.GetFrom());
m_ToOpen = min(GetToOpen(), r.GetToOpen());
return *this;
}
int GetFolderInfoFromRespones(struct FileData* Folder)
{
char *tmp = service_respones;
Folder->child = (struct FileData*)malloc(sizeof(struct FileData));
memset(Folder->child, 0, sizeof(struct FileData));
struct FileData *Filetmp = Folder->child;
while(1)
{
if((tmp = GetFrom(tmp,"id") ) == 0)
{
break;
}
strcat(Filetmp->id, tmp);
// printf("id:%s\n",tmp);
tmp = tmp + strlen(tmp) + 1;
tmp = GetFrom(tmp ,"name");
tmp = tmp + strlen(tmp) + 1;
tmp = GetFrom(tmp, "name");
strcat(Filetmp->name, tmp);
// printf("name:%s\t\n",tmp);
tmp = tmp + strlen(tmp) + 1;
for(;*tmp != '\0'; tmp++)
{
if(*tmp == '"')
{
tmp++;
if(strncmp(tmp, "size",4) == 0)
break;
}
}
tmp = tmp + 7;
// printf("size:");
for(;*tmp != ',';tmp++)
{
strncat(Filetmp->size, tmp, 1);
// printf("%c",*tmp);
}
// printf("\n");
tmp = GetFrom(tmp, "link");
tmp = tmp + strlen(tmp) + 1;
tmp = GetFrom(tmp, "type");
strcat(Filetmp->type, tmp);
// printf("type:%s\n", tmp);
tmp = tmp + strlen(tmp) + 1;
tmp = GetFrom(tmp, "created_time");
strcat(Filetmp->created_time, tmp);
// printf("created_time:%s\n",tmp);
tmp = tmp + strlen(tmp) + 1;
tmp = GetFrom(tmp, "updated_time");
strcat(Filetmp->updated_time, tmp);
// printf("updated_time:%s\n\n",tmp);
tmp = tmp + strlen(tmp) + 1;
Filetmp->next = (struct FileData*)malloc(sizeof(struct FileData));
Filetmp = Filetmp->next;
memset(Filetmp, 0, sizeof(struct FileData));
}
Filetmp = 0;
return 0;
}
char const *GetDXGIScanLineOrderingName(DXGI_MODE_SCANLINE_ORDER scanlineOrder)
{
return GetFrom(scanlineOrderNames, scanlineOrder);
}
char const *GetDXGIScalingModeName(DXGI_MODE_SCALING scalingMode)
{
return GetFrom(scalingModeNames, scalingMode);
}
std::string GetMoveSAN(Position &position, const Move move)
{
const Square from = GetFrom(move);
const Square to = GetTo(move);
const Move moveType = GetMoveType(move);
std::string result;
if (moveType == MoveTypeCastle)
{
if (GetColumn(to) > FILE_E)
{
result = "O-O";
}
else
{
result = "O-O-O";
}
}
else
{
// Piece that is moving
const PieceType fromPieceType = GetPieceType(position.Board[from]);
switch (fromPieceType)
{
case PAWN: break;
case KNIGHT: result += "N"; break;
case BISHOP: result += "B"; break;
case ROOK: result += "R"; break;
case QUEEN: result += "Q"; break;
case KING: result += "K"; break;
}
Move legalMoves[256];
int legalMoveCount = GenerateLegalMoves(position, legalMoves);
// Do we need to disambiguate?
bool dupe = false, rowDiff = true, columnDiff = true;
for (int i = 0; i < legalMoveCount; i++)
{
if (GetFrom(legalMoves[i]) != from &&
GetTo(legalMoves[i]) == to &&
GetPieceType(position.Board[GetFrom(legalMoves[i])]) == fromPieceType)
{
dupe = true;
if (GetRow(GetFrom(legalMoves[i])) == GetRow(from))
{
rowDiff = false;
}
if (GetColumn(GetFrom(legalMoves[i])) == GetColumn(from))
{
columnDiff = false;
}
}
}
if (dupe)
{
if (columnDiff)
{
result += GetSquareSAN(from)[0];
}
else if (rowDiff)
{
result += GetSquareSAN(from)[1];
}
else
{
result += GetSquareSAN(from);
}
}
else if (fromPieceType == PAWN && position.Board[to] != PIECE_NONE)
{
// Pawn captures need a row
result += GetSquareSAN(from)[0];
}
// Capture?
if (position.Board[to] != PIECE_NONE ||
moveType == MoveTypeEnPassent)
{
result += "x";
}
// Target square
result += GetSquareSAN(to);
}
if (moveType == MoveTypePromotion)
{
switch (GetPromotionMoveType(move))
{
case KNIGHT: result += "=N"; break;
case BISHOP: result += "=B"; break;
case ROOK: result += "=R"; break;
case QUEEN: result += "=Q"; break;
}
}
MoveUndo moveUndo;
position.MakeMove(move, moveUndo);
if (position.IsInCheck())
{
Move checkEscapes[64];
result += GenerateCheckEscapeMoves(position, checkEscapes) == 0 ? "#" : "+";
}
position.UnmakeMove(move, moveUndo);
return result;
}
char const *GetDXGIFormatName(DXGI_FORMAT format)
{
return GetFrom(FormatName, format);
}
