public Zerg(List <Point> points, int wave) //передаю список вейпоинтов и номер волны
: base(MobType.Zerg, wave)
{
this.points = points;
x = points[0].X;
y = points[0].Y;
//NextPointIndex = 1;
//StepTimer.Interval = 100.0 / _Speed;
StepTimer.Start();
}
public unsafe void TestRandom(int count)
{
int loopCount = 200;
uint[] items = new uint[count];
uint[] lookupList = new uint[count];
for (uint x = 0; x < items.Length; x++)
{
items[x] = 2 * x;
lookupList[x] = 2 * x + 1;
}
Shuffle(lookupList, 3, 10);
StepTimer.Reset();
for (int cnt = 0; cnt < loopCount; cnt++)
{
//GC.Collect(0);
//items = (uint[])items.Clone();
//GC.WaitForPendingFinalizers();
//System.Threading.Thread.Sleep(10);
SnapCustomMethodsUInt32 bin = new SnapCustomMethodsUInt32();
fixed(uint *lp = items)
{
byte * lpp = (byte *)lp;
SnapUInt32 box = new SnapUInt32();
StepTimer.ITimer timer = StepTimer.Start("Lookup");
for (int x = 0; x < lookupList.Length; x++)
{
box.Value = lookupList[x];
bin.BinarySearch(lpp, box, count, 4);
//BoxKeyMethodsUint32.BinarySearchTest(lpp, box, count, 4);
}
timer.Stop();
}
}
StringBuilder SB = new StringBuilder();
//Console.Write(count.ToString("Tree\t0\t"));
//SB.Append((count * 4).ToString("0\t") + (count / StepTimer.GetAverage("Lookup") / 1000000).ToString("0.000\t"));
//SB.Append((count * 4.0 / 1024).ToString("0.###\t") + ((StepTimer.GetAverage("Lookup") / Math.Log(count, 2)) / count * 1000000000).ToString("0.00\t"));
SB.Append(((StepTimer.GetSlowest("Lookup") / Math.Log(count, 2)) / count * 1000000000).ToString("0.00\t"));
//SB.Append(((StepTimer.GetAverage("Lookup") / Math.Log(count, 2)) / count * 1000000000).ToString("0.00\t"));
Console.WriteLine(SB.ToString());
}
/**************************************************************************
* FUNCTIONS *
**************************************************************************/
/// <summary>
/// Switch the states between play and pause
/// </summary>
public void switchPlayPauseState()
{
if (isAutoplaying)
{
btnPlayPause.Text = "4";
StepTimer.Stop();
}
else
{
btnPlayPause.Text = ";";
StepTimer.Start();
}
// Invert the state
isAutoplaying = !isAutoplaying;
}
private async Task <List <CatalogueResult> > ProcessFolderAsync(MusicDb db, OpusFolder folder)
{
var results = new List <CatalogueResult>();
db.Database.SetCommandTimeout(TimeSpan.FromMinutes(10));
StepTimer st = null;
if (musicOptions.TimeCatalogueSteps)
{
st = new StepTimer();
st.Start();
}
if (/*true ||*/ taskItem.Force)
{
var deletedFilesCount = folder.RemoveCurrentMusicFiles(db); st?.Time("Removal");
if (deletedFilesCount > 0)
{
await db.SaveChangesAsync();
}
}
var musicFiles = await WriteAudioFilesAsync(db, folder); st?.Time("MusicFiles to DB");
if (musicFiles.Count() > 0) // count is 0 most often when trying to find singles for an artist
{
await UpdateTagsAsync(db, musicFiles); st?.Time("Extract tags");
var musicSets = GetMusicSets(db, folder, musicFiles); st?.Time("Split into sets");
int i = 0;
foreach (var set in musicSets)
{
var cr = await set.CatalogueAsync(); st?.Time($"Set {i++ + 1}");
results.Add(cr);
if (cr.Status == CatalogueStatus.Success)
{
if (cr.Artist == null)
{
log.Trace($"Artist missing");
}
switch (cr.MusicSetType)
{
case Type T when T == typeof(PopularMusicAlbumSet) || T == typeof(WesternClassicalAlbumSet):
if (cr.Work == null)
{
log.Trace($"Album missing");
}
else if (cr.Work.Tracks == null || cr.Work.Tracks.Count() == 0)
{
log.Trace($"Work has no tracks");
}
if (cr.Tracks == null)
{
log.Trace($"Tracks missing");
}
else if (cr.Tracks.Count() == 0)
{
log.Trace($"Track count is 0");
}
//if(cr.TaskItem != null)
//{
// QueueTask(cr.TaskItem);
//}
break;
case Type T when T == typeof(WesternClassicalCompositionSet):
if (cr.Composition == null)
{
log.Trace($"Composition missing");
}
if (cr.Performance == null)
{
log.Trace($"Performance missing");
}
else if (cr.Performance.Movements == null || cr.Performance.Movements.Count() == 0)
{
log.Trace($"Performance has no movements");
}
break;
}
}
}
}
else
{
results.Add(new CatalogueResult {
Status = CatalogueStatus.Success
});
}
return(results);
}
public (bool result, ChangesDetected changes) CheckForChanges(MusicDb db)
{
ChangesDetected changesDetected = ChangesDetected.None;
bool result = false;
var st = new StepTimer();
st.Start();
var currentMusicFiles = GetMusicFilesFromDb(db);//.ToArray();
st.Time();
var filesOnDisk = GetFilesOnDisk();
st.Time();
bool anyFilesNotCatalogued()
{
bool r = false;
var list = currentMusicFiles.Where(x => x.Track == null);
r = list.Count() > 0;
st.Time();
if (r)
{
changesDetected = ChangesDetected.AtLeastOneFileNotCatalogued;
//log.Trace($"anyFilesNotCatalogued() returns true");
}
return(r);
}
bool anyFilesRewritten()
{
bool r = false;
var l1 = currentMusicFiles.Select(x => x.FileLastWriteTimeUtc);
var l2 = filesOnDisk.Select(x => new DateTimeOffset(x.fi.LastWriteTimeUtc, TimeSpan.Zero));
r = !l1.SequenceEqual(l2);
st.Time();
if (r)
{
changesDetected = ChangesDetected.AtLeastOneFileModifiedOnDisk;
log.Trace($"anyFilesRewritten() returns true");
}
return(r);
}
bool musicTagsAreNew()
{
bool r = false;
if (HasMusicTags())
{
var tagFile = Path.Combine(Folderpath, ITEOBase.TagFile);
var tagTime = new DateTimeOffset(new FileInfo(tagFile).LastWriteTimeUtc, TimeSpan.Zero);
r = currentMusicFiles.Any(mf => mf.LastCataloguedAt < tagTime);
}
st.Time();
if (r)
{
changesDetected = ChangesDetected.MusicTagsAreNewer;
//log.Trace($"customTagsAreNew() returns true");
}
return(r);
}
bool additionsOrDeletionsExist()
{
var differences = filesOnDisk.Select(f => f.fi.FullName).Except(currentMusicFiles.Select(mf => mf.File), StringComparer.CurrentCultureIgnoreCase);
st.Time();
var r = differences.Count() != 0;
if (r)
{
changesDetected = ChangesDetected.MusicFileCountHasChanged;
log.Debug($"music file difference count is {differences.Count()}");
}
return(r);
}
bool anyImageChanged()
{
bool r = false;
var works = currentMusicFiles.Select(mf => mf.Track).Select(x => x.Work).Distinct();
//currentMusicFiles.Select(mf => mf.Track).Where(x => x.Performance != null)
// .Select(x => x.Performance.Composition.Artist).Distinct();
var artists = works.Select(x => x.Artist)
.Union(currentMusicFiles.Select(mf => mf.Track).Where(x => x.Performance != null)
.Select(x => x.Performance.Composition.Artist))
.Distinct();
foreach (var artist in artists.Where(a => a.Type != ArtistType.Various))
{
var f = artist.GetPortraitFile(MusicOptions);
if (artist.Portrait.HasChanged(f))
{
log.Debug($"artist {artist.Name}, portrait file {f} found");
r = true;
break;
}
}
if (!r)
{
foreach (var work in works)
{
//var coverFile = MusicStyle.GetMostRecentOpusCoverFile(MusicOptions, IsCollection ? "Collections" : work.Artist.Name, currentPathData.OpusPath);
//var coverFile = MusicStyle.GetMostRecentOpusCoverFile(MusicOptions, work, currentPathData.OpusPath);
var coverFile = work.GetMostRecentOpusCoverFile(MusicOptions);
if (work.Cover.HasChanged(coverFile))
{
log.Debug($"artist {work.Artist.Name}, work {work.Name}, cover art file {coverFile}");
r = true;
break;
}
}
}
if (r)
{
changesDetected = ChangesDetected.CoverArtHasChanged;
//log.Trace($"anyImageChanged() returns true");
}
return(r);
}
if (additionsOrDeletionsExist() || musicTagsAreNew() || anyFilesRewritten() || anyFilesNotCatalogued() || anyImageChanged())
{
result = true;
}
return(result, changesDetected);
}
