bool CGnuSearch::Inspect(FileSource &Item)
{
// Refine filter
if(!RefinedQuery.IsEmpty())
if(!ResultDoubleCheck(Item.NameLower, RefinedQuery))
return false;
// If filtering is active
if(m_FilteringActive)
{
// Node Filter
if(m_pPrefs->m_ScreenNodes)
if(!m_pPrefs->AllowedIP(Item.Address.Host))
return false;
// Blocked hosts filter
if(m_pPrefs->BlockedIP(Item.Address.Host))
return false;
// Size Filter
if(m_SizeFilterMode != LIMIT_NONE)
if(!CheckLimit(m_SizeFilterMode, m_SizeFilterValue, Item.Size))
return false;
// Speed Filter
if(m_SpeedFilterMode != LIMIT_NONE)
if(!CheckLimit(m_SpeedFilterMode, m_SpeedFilterValue, Item.Speed / 8))
return false;
// Word Filter
std::vector<CString>::iterator itWord;
for (itWord = m_pPrefs->m_ScreenedWords.begin(); itWord != m_pPrefs->m_ScreenedWords.end(); itWord++)
if(Item.NameLower.Find(*itWord) != -1)
return false;
// Double Check
if(m_pPrefs->m_DoubleCheck)
{
if(!ResultDoubleCheck(Item.NameLower, m_Search))
return false;
if(!ResultDoubleCheckMeta(Item))
return false;
}
}
return true;
}
void CCSDateTime::Normalize()
{
CheckLimit(m_microsecond, m_millisecond, 1000);
CheckLimit(m_millisecond, m_second, 1000);
CheckLimit(m_second, m_minute, 60);
CheckLimit(m_minute, m_hour, 60);
CheckLimit(m_hour, m_day, 24);
if (m_day > DaysOfMonth(m_year, m_month))
{
m_day -= DaysOfMonth(m_year, m_month);
if (++m_month > 12)
{
++m_year;
m_month -= 12;
}
}
}
/* virtual */ void COrder_Build::Execute(CUnit &unit)
{
if (unit.Wait) {
if (!unit.Waiting) {
unit.Waiting = 1;
unit.WaitBackup = unit.Anim;
}
UnitShowAnimation(unit, unit.Type->Animations->Still);
unit.Wait--;
return;
}
if (unit.Waiting) {
unit.Anim = unit.WaitBackup;
unit.Waiting = 0;
}
if (this->State <= State_MoveToLocationMax) {
if (this->MoveToLocation(unit)) {
this->Finished = true;
return ;
}
}
const CUnitType &type = this->GetUnitType();
if (State_NearOfLocation <= this->State && this->State < State_StartBuilding_Failed) {
if (CheckLimit(unit, type) == false) {
this->Finished = true;
return ;
}
CUnit *ontop = this->CheckCanBuild(unit);
if (ontop != NULL) {
this->StartBuilding(unit, *ontop);
}
}
if (this->State == State_StartBuilding_Failed) {
unit.Player->Notify(NotifyYellow, unit.tilePos,
_("You cannot build %s here"), type.Name.c_str());
if (unit.Player->AiEnabled) {
AiCanNotBuild(unit, type);
}
this->Finished = true;
return ;
}
if (this->State == State_BuildFromOutside) {
if (this->BuildFromOutside(unit)) {
this->Finished = true;
}
}
}
// -------------------------------------------------------------------------------- //
guSmartModeThread::ExitCode guSmartModeThread::Entry()
{
if( m_LastFM )
{
guTrackArray * Tracks = new guTrackArray();
size_t TrackIndex = 0;
if( Tracks )
{
while( !TestDestroy() && !CheckLimit() )
{
AddSimilarTracks( m_ArtistName, m_TrackName, Tracks );
if( TrackIndex < Tracks->Count() )
{
const guTrack &AddedTrack = Tracks->Item( TrackIndex );
m_ArtistName = AddedTrack.m_ArtistName;
m_TrackName = AddedTrack.m_SongName;
TrackIndex++;
//guLogMessage( wxT( "SmartModeThread:: TrackIndex: %i" ), TrackIndex );
}
else
{
break;
}
}
// Remove the oldest added tracks or artists
if( m_SmartAddedTracks && ( ( int ) m_SmartAddedTracks->Count() > m_MaxSmartTracksList ) )
{
m_SmartAddedTracks->RemoveAt( 0, m_SmartAddedTracks->Count() - m_MaxSmartTracksList );
}
if( m_SmartAddedArtists && ( ( int ) m_SmartAddedArtists->Count() > m_MaxSmartArtistsList ) )
{
m_SmartAddedArtists->RemoveAt( 0, m_SmartAddedArtists->Count() - m_MaxSmartArtistsList );
}
//guLogDebug( wxT( "========" ) );
//for( Index = 0; Index < m_SmartAddedArtists->Count(); Index++ )
// guLogDebug( wxT( "Artist: '%s'" ), ( * m_SmartAddedArtists )[ Index ].c_str() );
SendTracks( Tracks );
}
}
return 0;
}
// -------------------------------------------------------------------------------- //
int guSmartModeThread::AddSimilarTracks( const wxString &artist, const wxString &track, guTrackArray * tracks )
{
//guLogMessage( wxT( "Searching for %s - %s" ), artist.c_str(), track.c_str() );
int AddedTracks = 0;
guTrackArray FoundTracks;
guSimilarTrackInfoArray SimilarTracks = m_LastFM->TrackGetSimilar( artist, track );
if( SimilarTracks.Count() )
{
int Index;
int Count = SimilarTracks.Count();
for( Index = 0; Index < Count; Index++ )
{
double Match = MatchStr2Double( SimilarTracks[ Index ].m_Match );
//guLogMessage( wxT( "Match: %f" ), Match );
if( Match >= guSMARTMODE_MIN_TRACK_MATCH )
{
CheckAddTrack( SimilarTracks[ Index ].m_ArtistName, SimilarTracks[ Index ].m_TrackName, &FoundTracks );
}
else // Results comes sorted by match
{
break;
}
// TODO: CHANGE LIMIT
if( TestDestroy() )
break;
}
}
if( FoundTracks.Count() < 4 )
{
guSimilarArtistInfoArray SimilarArtists = m_LastFM->ArtistGetSimilar( artist );
int Index;
int Count = SimilarArtists.Count();
for( Index = 0; Index < Count; Index++ )
{
if( !m_SmartAddedArtists || ( m_SmartAddedArtists->Index( SimilarArtists[ Index ].m_Name.Upper() ) == wxNOT_FOUND ) )
{
double Match = MatchStr2Double( SimilarArtists[ Index ].m_Match );
if( Match >= guSMARTMODE_MIN_ARTIST_MATCH )
{
if( m_Db->GetArtistId( SimilarArtists[ Index ].m_Name, false ) != wxNOT_FOUND )
{
//guLogMessage( wxT( "Found similar artist: '%s'" ), SimilarArtists[ Index ].m_Name.c_str() );
guTopTrackInfoArray ArtistTopTracks = m_LastFM->ArtistGetTopTracks( SimilarArtists[ Index ].m_Name );
int TTIndex;
int TTCount = ArtistTopTracks.Count();
for( TTIndex = 0; TTIndex < TTCount; TTIndex++ )
{
if( TestDestroy() ||
CheckAddTrack( ArtistTopTracks[ TTIndex ].m_ArtistName, ArtistTopTracks[ TTIndex ].m_TrackName, &FoundTracks ) )
break;
}
}
}
else
{
break;
}
}
if( TestDestroy() )
break;
}
}
// Select some random tracks from the available
while( !TestDestroy() && FoundTracks.Count() )
{
int TrackIndex = guRandom( FoundTracks.Count() );
const guTrack & RandomTrack = FoundTracks[ TrackIndex ];
if( !m_SmartAddedArtists || ( m_SmartAddedArtists->Index( RandomTrack.m_ArtistName.Upper() ) == wxNOT_FOUND ) )
{
if( !m_SmartAddedTracks || ( m_SmartAddedTracks->Index( RandomTrack.m_SongId ) == wxNOT_FOUND ) )
{
if( !CheckLimit( &RandomTrack ) )
{
tracks->Add( new guTrack( RandomTrack ) );
if( m_SmartAddedArtists )
{
m_SmartAddedArtists->Add( RandomTrack.m_ArtistName.Upper() );
}
if( m_SmartAddedTracks )
{
m_SmartAddedTracks->Add( RandomTrack.m_SongId );
}
AddedTracks++;
}
else
{
break;
}
}
}
FoundTracks.RemoveAt( TrackIndex );
}
return AddedTracks;
}
