public GenDiffConfig(SongCacheItem item,
bool copyTextEvents, bool copyGuitarToBass,
bool selectedDiffOnly, bool selectedTrackOnly,
bool generate108Events)
{
Generate108Events = generate108Events;
CopyTextEvents = copyTextEvents;
if (item != null)
{
ProcessingSong = true;
EnableProGuitarHard = item.AutoGenGuitarHard;
EnableProGuitarMedium = item.AutoGenGuitarMedium;
EnableProGuitarEasy = item.AutoGenGuitarEasy;
EnableProBassHard = item.AutoGenBassHard;
EnableProBassMedium = item.AutoGenBassMedium;
EnableProBassEasy = item.AutoGenBassEasy;
CopyGuitarToBass = item.CopyGuitarToBass;
}
else
{
ProcessingSong = false;
CopyGuitarToBass = copyGuitarToBass;
}
SelectedDifficultyOnly = selectedDiffOnly;
SelectedTrackOnly = selectedTrackOnly;
}
public bool AddNewSongToLibrary(bool silent)
{
ClearDTAFileProperties();
var songName = "";
if (FileNameG5.IsNotEmpty())
{
songName = FileNameG5.GetFileNameWithoutExtension();
}
if (songName.IsEmpty() && FileNamePro.IsNotEmpty())
{
songName = FileNamePro.GetFileNameWithoutExtension();
}
if (songName.IsEmpty())
{
if (!silent)
{
MessageBox.Show("Cannot find song name in package");
}
return false;
}
foreach (var sc in SongList)
{
if (sc.SongName.EqualsEx(songName) || sc.DTASongShortName.EqualsEx(songName) ||
(sc.G5FileName.IsNotEmpty() && sc.G5FileName.GetFileName().EqualsEx(FileNameG5.GetFileName())) ||
(sc.G6FileName.IsNotEmpty() && sc.G6FileName.GetFileName().EqualsEx(FileNamePro.GetFileName())))
{
SongList.SelectedSong = sc;
return OpenSongCacheItem(SongList.SelectedSong);
}
}
var i = new SongCacheItem()
{
G5FileName = FileNameG5,
G6FileName = FileNamePro,
G6ConFile = "",
Description = songName,
SongName = songName,
CopyGuitarToBass = false,
HasBass = true,
CacheSongID = GetNextSongID(),
};
SongList.AddSong(i);
if (OpenSongCacheItem(i))
{
if (FindDTAInformation(i))
{
UpdateSongCacheItem(i);
}
}
return OpenSongCacheItem(SongList.SelectedSong);
}
public void UpdateSongCacheItem(SongCacheItem sc)
{
if (sc != null)
{
sc.G5FileName = textBoxSongLibG5MidiFileName.Text;
sc.G6FileName = textBoxSongLibProMidiFileName.Text;
sc.G6ConFile = textBoxSongLibConFile.Text;
sc.Description = textBox24.Text;
sc.HasBass = checkBoxSongLibHasBass.Checked;
sc.HasGuitar = checkBoxSongLibHasGuitar.Checked;
sc.CopyGuitarToBass = checkBoxSongLibCopyGuitar.Checked;
sc.IsComplete = checkBoxSongLibIsComplete.Checked;
sc.IsFinalized = checkBoxSongLibIsFinalized.Checked;
sc.GuitarTuning[0] = textBox37.Text;
sc.GuitarTuning[1] = textBox38.Text;
sc.GuitarTuning[2] = textBox39.Text;
sc.GuitarTuning[3] = textBox40.Text;
sc.GuitarTuning[4] = textBox41.Text;
sc.GuitarTuning[5] = textBox42.Text;
sc.BassTuning[0] = textBox43.Text;
sc.BassTuning[1] = textBox44.Text;
sc.BassTuning[2] = textBox45.Text;
sc.BassTuning[3] = textBox46.Text;
sc.BassTuning[4] = textBox47.Text;
sc.BassTuning[5] = textBox48.Text;
sc.DTABassDifficulty = comboProBDifficulty.SelectedIndex;
sc.DTAGuitarDifficulty = comboProGDifficulty.SelectedIndex;
sc.DTASongID = textBoxCONSongID.Text;
sc.DTASongShortName = textBoxCONShortName.Text;
sc.SongMP3Location = textBoxSongPropertiesMP3Location.Text;
sc.SongMP3PlaybackOffset = textBoxSongPropertiesMP3StartOffset.Text.ToInt();
sc.EnableSongMP3Playback = checkBoxSongPropertiesEnableMP3Playback.Checked;
sc.SongMidiPlaybackVolume = this.trackBarMidiVolume.Value;
sc.SongMP3PlaybackVolume = this.trackBarMP3Volume.Value;
sc.EnableSongMidiPlayback = this.checkBoxEnableMidiPlayback.Checked;
enableMidiPlayback(sc.EnableSongMidiPlayback);
enableMP3Playback(sc.EnableSongMP3Playback);
sc.AutoGenGuitarHard = checkBoxAutoGenGuitarHard.Checked;
sc.AutoGenGuitarMedium = checkBoxAutoGenGuitarMedium.Checked;
sc.AutoGenGuitarEasy = checkBoxAutoGenGuitarEasy.Checked;
sc.AutoGenBassHard = checkBoxAutoGenBassHard.Checked;
sc.AutoGenBassMedium = checkBoxAutoGenBassMedium.Checked;
sc.AutoGenBassEasy = checkBoxAutoGenBassEasy.Checked;
SongList.UpdateSongCacheItem(sc);
UpdateEditorPropertiesForSong();
}
}
public void UpdateCONFileProperties(SongCacheItem sc)
{
if (sc != null)
{
if (SaveProCONFile(sc, false, false))
{
OpenProCONFile(sc, true);
}
}
}
public void SetSelectedSongItem(SongCacheItem sc)
{
trackEditorG5.ViewLyrics = settings.GetValueBool("View Lyrics in G5 Editor", true);
CloseG5Track();
CloseProTrack();
if (sc != null)
{
SelectedSong = sc;
var i = SongList.IndexOf(sc);
SongList.SelectedSong = sc;
settings.SetValue("lastSelectedSongItem", sc.ToString());
label37.Text = sc.SongName;
textBoxSongLibG5MidiFileName.SetValueSuspend(sc.G5FileName).ScrollToEnd();
textBoxSongLibProMidiFileName.SetValueSuspend(sc.G6FileName).ScrollToEnd();
textBoxSongLibConFile.SetValueSuspend(sc.G6ConFile).ScrollToEnd();
textBox24.SetValueSuspend(sc.Description).ScrollToEnd();
checkBoxSongLibHasBass.SetValueSuspend(sc.HasBass);
checkBoxSongLibHasGuitar.SetValueSuspend(sc.HasGuitar);
checkBoxSongLibCopyGuitar.SetValueSuspend(sc.CopyGuitarToBass);
checkBoxSongLibIsComplete.SetValueSuspend(sc.IsComplete);
checkBoxSongLibIsFinalized.SetValueSuspend(sc.IsFinalized);
textBox37.SetValueSuspend(sc.GuitarTuning[0]);
textBox38.SetValueSuspend(sc.GuitarTuning[1]);
textBox39.SetValueSuspend(sc.GuitarTuning[2]);
textBox40.SetValueSuspend(sc.GuitarTuning[3]);
textBox41.SetValueSuspend(sc.GuitarTuning[4]);
textBox42.SetValueSuspend(sc.GuitarTuning[5]);
textBox43.SetValueSuspend(sc.BassTuning[0]);
textBox44.SetValueSuspend(sc.BassTuning[1]);
textBox45.SetValueSuspend(sc.BassTuning[2]);
textBox46.SetValueSuspend(sc.BassTuning[3]);
textBox47.SetValueSuspend(sc.BassTuning[4]);
textBox48.SetValueSuspend(sc.BassTuning[5]);
comboProBDifficulty.SetValueSuspend(sc.DTABassDifficulty);
comboProGDifficulty.SetValueSuspend(sc.DTAGuitarDifficulty);
textBoxCONSongID.SetValueSuspend(sc.DTASongID);
textBoxCONShortName.SetValueSuspend(sc.DTASongShortName);
FileNameG5 = sc.G5FileName;
FileNamePro = sc.G6FileName;
textBoxSongPropertiesMP3StartOffset.SetValueSuspend(sc.SongMP3PlaybackOffset.ToStringEx());
textBoxSongPropertiesMP3Location.SetValueSuspend(sc.SongMP3Location).ScrollToEnd();
if (mp3Player.PlayingMP3File)
{
mp3Player.Stop();
}
this.trackBarMidiVolume.SetValueSuspend(sc.SongMidiPlaybackVolume);
this.trackBarMP3Volume.SetValueSuspend(sc.SongMP3PlaybackVolume);
checkBoxEnableMidiPlayback.SetValueSuspend(sc.EnableSongMidiPlayback);
checkBoxSongPropertiesEnableMP3Playback.SetValueSuspend(sc.EnableSongMP3Playback);
enableMidiPlayback(checkBoxEnableMidiPlayback.Checked);
enableMP3Playback(checkBoxSongPropertiesEnableMP3Playback.Checked);
ApplyMidiVolumeChange(sc.SongMidiPlaybackVolume);
ApplyMP3VolumeChange(sc.SongMP3PlaybackVolume);
checkBoxAutoGenGuitarHard.SetValueSuspend(sc.AutoGenGuitarHard);
checkBoxAutoGenGuitarMedium.SetValueSuspend(sc.AutoGenGuitarMedium);
checkBoxAutoGenGuitarEasy.SetValueSuspend(sc.AutoGenGuitarEasy);
checkBoxAutoGenBassHard.SetValueSuspend(sc.AutoGenBassHard);
checkBoxAutoGenBassMedium.SetValueSuspend(sc.AutoGenBassMedium);
checkBoxAutoGenBassEasy.SetValueSuspend(sc.AutoGenBassEasy);
RefreshTracks();
}
else if (SelectedSong != null)
{
SelectedSong = null;
SongList.SelectedSong = null;
PUEExtensions.TryExec(delegate()
{
if (mp3Player.PlayingMP3File)
{
mp3Player.Stop();
}
});
listBoxSongLibrary.SelectedItems.Clear();
label37.Text = "None Selected";
textBoxSongLibG5MidiFileName.Text = "";
textBoxSongLibProMidiFileName.Text = "";
textBoxSongLibConFile.Text = "";
textBox24.Text = "";
checkBoxSongLibHasBass.Checked = false;
checkBoxSongLibHasGuitar.Checked = false;
checkBoxSongLibCopyGuitar.Checked = false;
checkBoxSongLibIsComplete.Checked = false;
checkBoxSongLibIsFinalized.Checked = false;
textBox37.Text = "";
textBox38.Text = "";
textBox39.Text = "";
textBox40.Text = "";
textBox41.Text = "";
textBox42.Text = "";
textBox43.Text = "";
textBox44.Text = "";
textBox45.Text = "";
textBox46.Text = "";
textBox47.Text = "";
textBox48.Text = "";
comboProBDifficulty.SelectedIndex = 0;
comboProGDifficulty.SelectedIndex = 0;
textBoxCONSongID.Text = "";
textBoxCONShortName.Text = "";
FileNameG5 = "";
FileNamePro = "";
textBoxSongPropertiesMP3Location.Text = "";
if (settings.GetValueBool("Keep Midi Playback Selection", false) == false)
{
textBoxSongPropertiesMP3StartOffset.Text = "";
checkBoxSongPropertiesEnableMP3Playback.Checked = false;
checkBoxEnableMidiPlayback.Checked = true;
this.trackBarMidiVolume.Value = 100;
this.trackBarMP3Volume.Value = 100;
}
if (settings.GetValueBool("Keep Auto Gen Difficulty Selection", false) == false)
{
checkBoxAutoGenGuitarHard.Checked = false;
checkBoxAutoGenGuitarMedium.Checked = false;
checkBoxAutoGenGuitarEasy.Checked = false;
checkBoxAutoGenBassHard.Checked = false;
checkBoxAutoGenBassMedium.Checked = false;
checkBoxAutoGenBassEasy.Checked = false;
}
RefreshTracks();
}
}
public bool SaveSongCacheItem(SongCacheItem item, bool silent)
{
var ret = false;
try
{
if (item != null)
{
UpdateSongCacheItem(item);
item.IsDirty = false;
ret = SaveProFile(item.G6FileName, silent);
}
else
{
ret = true;
}
}
catch { }
return ret;
}
public bool SaveProCONFile(SongCacheItem sc, bool silent, bool batch, bool saveAs = false)
{
bool ret = false;
if (sc == null)
return ret;
try
{
var fileName = saveAs ? "" : sc.G6ConFile;
if (fileName.IsEmpty())
{
var f = GetShortFileNameFromG5(sc);
if (f.IsNotEmpty())
{
f += Utility.DefaultCONFileExtension;
}
fileName = ShowSaveFileDlg("Save CON Package",
DefaultConFileLocation,
DefaultConFileLocation.PathCombine(f));
if (fileName.IsNotEmpty())
{
sc.G6ConFile = fileName;
textBoxSongLibConFile.Text = sc.G6ConFile;
}
}
if (fileName.IsNotEmpty())
{
byte[] proTrack = null;
using (var ms = EditorPro.Sequence.Save())
{
ms.Seek(0, SeekOrigin.Begin);
using (var bw = new BinaryReader(ms))
{
proTrack = bw.ReadBytes((int)ms.Length);
}
}
if (proTrack == null || proTrack.Length == 0)
{
if (!silent)
MessageBox.Show("Unable to retrieve pro midi file");
return ret;
}
byte[] existingCON = null;
if (fileName.FileExists())
{
existingCON = ReadFileBytes(fileName);
}
var config = new Package.CreateProConfig()
{
TitleID = Utility.RockBand3TitleID,
existingCONFile = existingCON,
proMidiFileName = sc.G6FileName.GetFileName(),
midFileContents = proTrack,
displayTitle = sc.Description,
description = sc.Description,
songShortName = sc.DTASongShortName,
song_id = sc.DTASongID,
guitarDifficulty = InstrumentDifficultyUtil.MapDifficulty((InstrumentDifficulty)sc.DTAGuitarDifficulty),
bassDifficulty = InstrumentDifficultyUtil.MapDifficulty((InstrumentDifficulty)sc.DTABassDifficulty),
};
var con = Package.CreateRB3Pro(config);
if (con != null && con.Length > 0)
{
if (batch == false || (batch == true && !checkBoxSmokeTest.Checked))
{
if (!TryWriteFile(fileName, con))
{
if (!silent)
MessageBox.Show("Cannot write file");
}
}
var pk = Package.Load(fileName);
if (pk == null)
{
if (!silent)
MessageBox.Show("Validate package failed");
}
else
{
ret = true;
if (settings.GetValueBool("Save plus.mid with con", false))
{
try
{
var plusFileName = fileName.GetFolderName() +
sc.G6FileName.GetFileNameWithoutExtension() +
"_plus.mid";
TryWriteFile(plusFileName, ReadFileBytes(sc.G6FileName));
}
catch { }
}
}
}
else
{
if (!silent)
MessageBox.Show("Cannot create CON Package");
}
}
}
catch { Debug.WriteLine("crypto error"); }
return ret;
}
public bool CheckCONPackageDTA(SongCacheItem item, bool silent)
{
bool ret = false;
if (item == null)
return ret;
List<string> fileErrors = new List<string>();
try
{
if (string.IsNullOrEmpty(item.G6FileName))
{
fileErrors.Add("Guitar Midi file name missing");
}
if (string.IsNullOrEmpty(item.G6ConFile))
{
fileErrors.Add("Missing CON File");
}
else
{
var pk = Package.Load(ReadFileBytes(item.G6ConFile));
CheckConPackage(pk, ref fileErrors, item);
}
}
catch (Exception ex)
{
if (silent)
{
WriteBatchResult("Unhandled exception processing: " + item.ToString());
}
else
{
MessageBox.Show("Unhandled exception : " + ex.Message);
}
}
if (fileErrors.Count > 0)
{
if (silent)
{
WriteBatchResult("Errors in - " + item.ToString());
}
}
else
{
ret = true;
}
var sb = new StringBuilder();
foreach (string s in fileErrors)
{
if (silent)
{
WriteBatchResult(s);
}
else
{
sb.AppendLine(s);
}
}
RefreshTracks();
if (!silent)
{
if (fileErrors.Count > 0)
{
OpenNotepad(Encoding.ASCII.GetBytes(sb.ToString()));
}
else
{
MessageBox.Show("Check OK");
}
}
return ret;
}
public bool OpenSongCacheItem(SongCacheItem item)
{
bool ret = false;
try
{
EditorPro.ClearSelection();
ClearDTAFileProperties();
var oldOffset = EditorPro.HScrollValue;
if (oldOffset < 0)
oldOffset = 0;
SetSelectedSongItem(item);
if (item != null)
{
if (item.G5FileName.FileExists())
{
try
{
ret = EditorG5.LoadMidi5(item.G5FileName, ReadFileBytes(item.G5FileName), true);
}
catch { }
}
if (item.G6FileName.FileExists())
{
var v = EditorPro.LoadMidi17(item.G6FileName, ReadFileBytes(item.G6FileName), false);
if (ret != true)
ret = v;
}
SetEditorDifficulty(GuitarDifficulty.Expert);
listBoxSongLibrary.SelectedItem = item;
SongList.SelectedSong = listBoxSongLibrary.SelectedItem as SongCacheItem;
if (EditorPro.IsLoaded)
{
if (EditorPro.HScrollMaximum > oldOffset)
{
EditorPro.HScrollValue = oldOffset;
}
}
}
}
catch { }
UpdateEditorPropertiesForSong();
return ret;
}
public Package OpenProCONFile(SongCacheItem sc, bool silent)
{
if (string.IsNullOrEmpty(sc.G6ConFile))
{
return null;
}
var ret = Package.Load(sc.G6ConFile);
if (ret == null)
return ret;
var upgrades = ret.GetFile("songs_upgrades", "upgrades.dta");
if (upgrades == null)
{
if (!silent)
MessageBox.Show("upgrades.dta file missing");
return null;
}
PackageFile proMid = GetProMidFromPackage(ret);
if (proMid == null)
{
if (!silent)
MessageBox.Show("Invalid pro midi file in upgrades.dta");
}
return ret;
}
public string GetShortFileNameFromG5(SongCacheItem sc)
{
string g5fileName = sc.G5FileName;
if (string.IsNullOrEmpty(g5fileName))
{
return string.Empty;
}
if (!File.Exists(g5fileName))
return string.Empty;
if (!string.IsNullOrEmpty(g5fileName))
{
return Path.GetFileNameWithoutExtension(g5fileName);
}
return string.Empty;
}
public bool FindSongID(SongCacheItem sc, out string songID, out string songShortName,
out string gDiff, out string bDiff)
{
songID = string.Empty;
songShortName = string.Empty;
gDiff = string.Empty;
bDiff = string.Empty;
bool foundDiff = false;
bool foundSongID = false;
try
{
if (string.IsNullOrEmpty(songID))
{
string fileFolder = sc.G5FileName;
songShortName = GetShortFileNameFromG5(sc);
if (string.IsNullOrEmpty(fileFolder))
{
if (!string.IsNullOrEmpty(textBoxCONShortName.Text))
{
songShortName = textBoxCONShortName.Text;
}
else
{
songShortName = textBox24.Text;
}
if (!string.IsNullOrEmpty(songShortName))
{
fileFolder = sc.G6FileName;
}
}
if (string.IsNullOrEmpty(fileFolder) ||
string.IsNullOrEmpty(songShortName))
{
return false;
}
var fileDirectory = Path.GetDirectoryName(fileFolder);
for (int x = 0; x < 3; x++)
{
var songsDTAPath = Path.Combine(fileDirectory, "songs.dta");
var upgradesDTAPath = Path.Combine(fileDirectory, "upgrades.dta");
if (File.Exists(songsDTAPath) || File.Exists(upgradesDTAPath))
{
if (File.Exists(songsDTAPath) == false)
{
songsDTAPath = upgradesDTAPath;
if (!ParseUpgradesDTAForSongName(upgradesDTAPath, out songShortName))
{
break;
}
}
try
{
var sids = DTAFile.FromBytes(ReadFileBytes(songsDTAPath)).GetSongIDs();
var ssn = songShortName;
var sid = sids.FirstOrDefault(s => s.SongShortName.EqualsEx(ssn));
if (sid != null)
{
songID = sid.Value;
if (songID.IsNotEmpty())
{
foundSongID = true;
}
}
}
catch { }
if (!foundSongID && songsDTAPath.FileExists())
{
if (ParseSongsDTAForSongID(songShortName, songsDTAPath.ReadFileBytes(), out songID))
{
foundSongID = true;
}
}
if (!foundDiff)
{
if (ParseSongsDTAForDifficulty(songShortName, songsDTAPath, out gDiff, out bDiff))
{
foundDiff = true;
}
}
break;
}
try
{
var dinfo = Directory.GetParent(fileDirectory);
if (dinfo != null && dinfo.Exists)
{
fileDirectory = dinfo.FullName;
}
}
catch { break; }
}
}
if (string.IsNullOrEmpty(songID) && !string.IsNullOrEmpty(songShortName))
{
using (var ms = new MemoryStream(Package.GetSongIDList()))
{
using (var sr = new StreamReader(ms))
{
while (!sr.EndOfStream)
{
var line = sr.ReadLine().Trim();
var c = line.IndexOf(';');
if (c != -1)
{
line = line.Substring(0, c).Trim(' ', '(', ')', '\'');
}
var i = line.IndexOf(" - ");
if (i != -1)
{
var lineName = line.Substring(0, i).Trim();
var lineID = line.Substring(i + 3).Trim();
if (string.Compare(lineName, songShortName, StringComparison.OrdinalIgnoreCase) == 0)
{
songID = lineID;
songShortName = lineName;
foundSongID = true;
return true;
}
}
}
}
}
}
}
catch { }
return foundSongID || foundDiff;
}
public bool FindDTAInformation(SongCacheItem sc)
{
bool ret = false;
try
{
string songid, songshortname, gDiff, bDiff;
if (FindSongID(sc, out songid, out songshortname, out gDiff, out bDiff))
{
ret = true;
textBoxCONSongID.Text = songid;
sc.DTASongID = textBoxCONSongID.Text;
textBoxCONShortName.Text = songshortname;
sc.DTASongShortName = textBoxCONShortName.Text;
comboProGDifficulty.SelectedIndex = (int)InstrumentDifficultyUtil.MapDifficulty(gDiff);
comboProBDifficulty.SelectedIndex = (int)InstrumentDifficultyUtil.MapDifficulty(bDiff);
if (comboProGDifficulty.SelectedIndex == 0 &&
comboProGDifficulty.SelectedIndex == 0)
{
comboProGDifficulty.SelectedIndex = 2;
comboProBDifficulty.SelectedIndex = 2;
}
sc.DTAGuitarDifficulty = comboProGDifficulty.SelectedIndex;
sc.DTABassDifficulty = comboProBDifficulty.SelectedIndex;
}
}
catch { }
return ret;
}
public bool CopySongToUSB(SongCacheItem item)
{
bool ret = false;
try
{
bool opened = false;
if (SelectedUSB == null)
return ret;
if (SelectedUSB.IsOpen == false)
{
OpenSelectedUSB();
opened = SelectedUSB.Open();
}
var folder = SelectedUSBFolderEntry;
var contents = SelectedUSBContents;
if (!string.IsNullOrEmpty(item.G6ConFile))
{
if (File.Exists(item.G6ConFile))
{
try
{
var fileName = Path.GetFileName(item.G6ConFile);
if (!string.IsNullOrEmpty(fileName))
{
bool overwrite = false;
if (contents != null)
{
foreach (var c in contents.Files)
{
if (string.Compare(c.Name, fileName, true) == 0)
{
overwrite = true;
break;
}
}
}
bool success = false;
if (overwrite)
{
success = folder.AddFile(fileName, item.G6ConFile, AddType.Replace);
}
else
{
success = folder.AddFile(fileName, item.G6ConFile, AddType.Inject);
}
if (!success)
{
WriteBatchResult("Unable to write file to usb: " + fileName);
}
else
{
ret = success;
}
}
}
catch
{
WriteBatchResult("Exception writing to usb");
ret = false;
}
}
}
if (opened)
{
SelectedUSB.Close();
}
}
catch { }
return ret;
}
public bool CheckConPackage(Package pk, ref List<string> fileErrors, SongCacheItem item)
{
try
{
if (pk == null)
{
fileErrors.Add("Cannot open CON File");
return false;
}
PackageFile upgradeDTA = null;
try
{
upgradeDTA = pk.GetFile("songs_upgrades", "upgrades.dta");
}
catch
{
fileErrors.Add("error extracting upgrades.dta");
return false;
}
if (upgradeDTA == null)
{
fileErrors.Add("Cannot find DTA file in package");
return false;
}
string upgradeFileData = string.Empty;
try
{
upgradeFileData = Encoding.ASCII.GetString(upgradeDTA.Data);
}
catch
{
fileErrors.Add("error reading upgrades.dta");
}
if (string.IsNullOrEmpty(upgradeFileData))
{
fileErrors.Add("upgrades.dta file is empty");
}
else
{
string dtaSongID = string.Empty;
try
{
var songIDList = LoadDTAFile(upgradeDTA.Data);
if (songIDList.Any())
{
songIDList.GetSongIDs().FirstOrDefault().GetIfNotNull(x => dtaSongID = x.Value);
}
}
catch { }
if (dtaSongID.IsEmpty())
{
fileErrors.Add("song id missing in upgrades.dta");
}
else
{
var g6D = InstrumentDifficulty.INVALID;
try
{
g6D = InstrumentDifficultyUtil.DTAGetGuitarDifficulty(upgradeDTA.Data);
}
catch { }
if (g6D == InstrumentDifficulty.INVALID)
{
fileErrors.Add("invalid guitar difficulty in upgrades.dta");
}
var g6B = InstrumentDifficulty.INVALID;
try
{
g6B = InstrumentDifficultyUtil.DTAGetBassDifficulty(upgradeDTA.Data);
}
catch { }
if (g6B == InstrumentDifficulty.INVALID)
{
fileErrors.Add("invalid bass difficulty in upgrades.dta");
}
if (!pk.GetFiles("songs_upgrades", ".mid|.midi").Any())
{
fileErrors.Add("No \".mid\" file found in package");
}
string shortName = string.Empty;
try
{
shortName = DTAGetSongShortName(upgradeDTA.Data);
}
catch { }
if (shortName.IsEmpty())
{
fileErrors.Add("Song Name Missing from DTA");
}
else
{
string proName = DTAGetProFileName(upgradeDTA.Data);
if (proName.IsEmpty())
{
fileErrors.Add("Missing pro file name in upgrades.dta");
}
else
{
proName = proName.Trim('"');
var s = proName.Split('/');
if (s == null || s.Length != 2 || s[0] != "songs_upgrades")
{
fileErrors.Add("Invalid path to pro mid file in upgrades.dta: " + proName);
}
else
{
var proMid = pk.GetFile("songs_upgrades", s[1]);
if (proMid == null)
{
fileErrors.Add("pro midi file set in upgrades.dta not found in package");
}
else
{
var sq = proMid.Data.LoadSequence();
if (sq != null)
{
if (!sq.IsFileTypePro())
{
fileErrors.Add("Unable to open pro midi file from package");
}
else
{
fileErrors.AddRange(VerifySongData(proName, sq, item));
}
}
}
}
}
}
}
}
}
catch { }
return fileErrors.Count == 0;
}
public bool RebuildCONFileProperties(SongCacheItem sc)
{
bool ret = false;
try
{
if (sc != null)
{
SaveProMidi();
if (SaveProCONFile(sc, true, false))
{
if (OpenProCONFile(sc, true) != null)
{
ret = true;
}
}
}
}
catch { }
return ret;
}
private void LoadSettingConfiguration()
{
if (settings == null)
{
settings = new SettingMgr();
}
settings.LoadSettings();
checkBoxAutoSelectNext.Checked = settings.GetValueBool("checkBoxAutoSelectNext", true);
checkBatchOpenWhenCompleted.Checked = settings.GetValueBool("checkBatchOpenWhenCompleted", true);
checkBoxBatchCopyUSB.Checked = settings.GetValueBool("checkBoxBatchCopyUSB", false);
checkBatchCopyTextEvents.Checked = settings.GetValueBool("checkBatchCopyTextEvents", true);
checkBatchGenerateTrainersIfNone.Checked = settings.GetValueBool("checkBatchGenerateTrainersIfNone", true);
textBoxUSBFolder.Text = settings.GetValue("textBoxUSBFolder");
DefaultConFileLocation = settings.GetValue("textBoxDefaultCONFileLocation");
DefaultMidiFileLocationG5 = settings.GetValue("textBoxDefaultMidi5FileLocation");
DefaultMidiFileLocationPro = settings.GetValue("textBoxDefaultMidiProFileLocation");
checkBoxShow108.Checked = settings.GetValueBool("checkBoxShow108", false);
textBoxZoom.Text = settings.GetValue("textBoxZoom", textBoxZoom.Text);
Utility.timeScalarZoomSpeed = settings.GetValue("timeScalarZoomSpeed", Utility.timeScalarZoomSpeed.ToStringEx()).ToDouble(10);
checkUseDefaultFolders.Checked = settings.GetValueBool("useDefaultFolders", true);
checkBoxInitSelectedTrackOnly.Checked = settings.GetValueBool("checkBoxInitSelectedTrackOnly", false);
checkBoxInitSelectedDifficultyOnly.Checked = settings.GetValueBool("checkBoxInitSelectedDifficultyOnly", false);
checkKeepSelection.Checked = settings.GetValueBool("checkKeepSelection", true);
checkBoxClearAfterNote.Checked = settings.GetValueBool("checkBoxClearAfterNote", false);
checkRealtimeNotes.Checked = settings.GetValueBool("checkRealtimeNotes", false);
checkTwoNotePowerChord.Checked = settings.GetValueBool("checkTwoNotePowerChord", false);
checkThreeNotePowerChord.Checked = settings.GetValueBool("checkThreeNotePowerChord", false);
checkChordMode.Checked = settings.GetValueBool("checkChordMode", false);
checkScrollToSelection.Checked = settings.GetValueBool("checkScrollToSelection", true);
checkKBQuickEdit.Checked = settings.GetValueBool("checkKBQuickEdit", true);
checkIndentBString.Checked = settings.GetValueBool("checkIndentBString", false);
checkBoxSearchByNoteType.Checked = settings.GetValueBool("checkBoxSearchByNoteType", true);
checkBoxSearchByNoteStrum.Checked = settings.GetValueBool("checkBoxSearchByNoteStrum", true);
checkBoxSearchByNoteFret.Checked = settings.GetValueBool("checkBoxSearchByNoteFret", true);
checkBoxKeepLengths.Checked = settings.GetValueBool("checkBoxSetLengths5", true);
checkMatchBeat.Checked = settings.GetValueBool("checkMatchBeat", true);
checkBoxMatchLengths.Checked = settings.GetValueBool("checkBoxMatchLengths", true);
checkBoxMatchLength6.Checked = settings.GetValueBool("checkBoxMatchLength6", true);
checkBoxMatchSpacing.Checked = settings.GetValueBool("checkBoxMatchSpacing", true);
checkBoxMatchForwardOnly.Checked = settings.GetValueBool("checkBoxMatchForwardOnly", false);
checkBoxFirstMatchOnly.Checked = settings.GetValueBool("checkBoxFirstMatchOnly", false);
checkBoxShowMidiChannelEdit.Checked = settings.GetValueBool("checkBoxShowMidiChannelEdit", true);
textBoxTempoNumerator.Text = settings.GetValue("textBoxTempoNumerator", "4");
textBoxTempoDenominator.Text = settings.GetValue("textBoxTempoDenominator", "4");
checkBoxUseCurrentChord.Checked = settings.GetValueBool("checkUseCurrentChord", true);
checkBoxAllowOverwriteChord.Checked = settings.GetValueBool("checkAllowOverwriteChord", true);
textBoxPlaceNoteFret.Text = settings.GetValue("textBoxPlaceNoteFret", "0");
checkBoxGridSnap.Checked = settings.GetValueBool("checkBoxGridSnap", true);
checkSnapToCloseG5.Checked = settings.GetValueBool("checkSnapToCloseG5", true);
checkBoxCreateArpeggioHelperNotes.Checked = settings.GetValueBool("checkBoxCreateArpeggioHelperNotes", true);
checkViewNotesGridPro.Checked = settings.GetValueBool("checkViewNotesGrid", true);
checkViewNotesGrid5Button.Checked = settings.GetValueBool("checkViewNotesGrid5", true);
textBoxCopyAllCONFolder.Text = settings.GetValue("textBoxCopyAllCONFolder");
textBoxMinimumNoteWidth.Text = settings.GetValue("textBoxMinimumNoteWidth", "0");
textBoxCopyAllProFolder.Text = settings.GetValue("textBoxCopyAllProFolder");
textBoxCopyAllG5MidiFolder.Text = settings.GetValue("textBoxCopyAllG5MidiFolder");
checkBoxMidiPlaybackScroll.Checked = settings.GetValueBool("checkBoxMidiPlaybackScroll", true);
CheckMinimumNoteWidth();
SetGridScalar(settings.GetValue("gridScalar", "0.25"));
textBoxScrollToSelectionOffset.Text = settings.GetValue("textBoxScrollToSelectionOffset", Utility.ScollToSelectionOffset.ToString());
checkBoxMultiSelectionSongList.Checked = settings.GetValueBool("checkBoxMultiSelectionSongList", false);
checkBoxSkipGenIfEasyNotes.Checked = settings.GetValueBool("checkBoxSkipGenIfEasyNotes", false);
checkGenDiffCopyGuitarToBass.Checked = settings.GetValueBool("checkGenDiffCopyGuitarToBass", true);
checkBoxLoadLastSongStartup.Checked = settings.GetValueBool("checkBoxLoadLastSongStartup", true);
resetTime = settings.GetValueInt("textClearHoldBox", 1);
textClearHoldBox.Text = resetTime.ToString();
checkBoxEnableMidiInput.Checked = settings.GetValueBool("checkBoxEnableMidiInput", false);
checkBoxEnableClearTimer.Checked = settings.GetValueBool("checkBoxEnableClearTimer", true);
checkBoxPlayMidiStrum.Checked = settings.GetValueBool("checkBoxPlayMidiStrum", false);
checkBoxClearIfNoFrets.Checked = settings.GetValueBool("checkBoxClearIfNoFrets", true);
checkBoxChordStrum.Checked = settings.GetValueBool("checkBoxChordStrum", false);
checkBoxMidiInputStartup.Checked = settings.GetValueBool("checkBoxMidiInputStartup", true);
checkView5Button.Checked = settings.GetValueBool("checkView5Button", true);
Utility.NoteCloseWidth = settings.GetValueInt("textBoxNoteCloseDist", 8);
textBoxNoteCloseDist.Text = Utility.NoteCloseWidth.ToString();
checkBoxBatchCheckCON.Checked = settings.GetValueBool("checkBoxBatchCheckCON", true);
checkBoxBatchGenerateDifficulties.Checked = settings.GetValueBool("checkBoxBatchGenerateDifficulties", true);
checkBoxBatchGuitarBassCopy.Checked = settings.GetValueBool("checkBoxBatchGuitarBassCopy", true);
checkBoxBatchRebuildCON.Checked = settings.GetValueBool("checkBoxBatchRebuildCON", true);
checkBoxMatchAllFrets.Checked = settings.GetValueBool("checkBoxMatchAllFrets", true);
checkBoxCompressAllInDefaultCONFolder.Checked = settings.GetValueBool("checkBoxCompressAllInDefaultCONFolder", true);
textBoxCompressAllZipFile.Text = settings.GetValue("textBoxCompressAllZipFile");
checkBoxRenderMouseSnap.Checked = settings.GetValueBool("checkBoxRenderMouseSnap", false);
checkBoxSnapToCloseNotes.Checked = settings.GetValueBool("checkBoxSnapToCloseNotes", true);
Utility.NoteSnapDistance = settings.GetValueInt("textBoxNoteSnapDistance", 4);
Utility.GridSnapDistance = settings.GetValueInt("textBoxGridSnapDistance", 4);
textBoxNoteSnapDistance.Text = Utility.NoteSnapDistance.ToString();
textBoxGridSnapDistance.Text = Utility.GridSnapDistance.ToString();
RefreshMidiInputList();
CheckMidiInputVisibility();
UpdateProperties(true);
comboNoteEditorCopyPatternPreset.Items.Clear();
comboNoteEditorCopyPatternPreset.SelectedIndex = -1;
foreach (XmlNode node in XMLUtil.GetNodeList(settings.XMLRoot, "searchPatterns/searchPattern"))
{
var preset = new CopyPatternPreset()
{
ID = XMLUtil.GetNodeValueInt(node, "@ID"),
Name = XMLUtil.GetNodeValue(node, "@Name") ?? "",
ForwardOnly = XMLUtil.GetNodeValueBool(node, "@ForwardOnly"),
MatchLengths5 = XMLUtil.GetNodeValueBool(node, "@MatchLengths5"),
MatchLengths6 = XMLUtil.GetNodeValueBool(node, "@MatchLengths6"),
MatchSpacing = XMLUtil.GetNodeValueBool(node, "@MatchSpacing"),
MatchBeat = XMLUtil.GetNodeValueBool(node, "@MatchBeat"),
KeepLengths = XMLUtil.GetNodeValueBool(node, "@KeepLengths"),
FirstMatchOnly = XMLUtil.GetNodeValueBool(node, "@FirstMatchOnly"),
RemoveExisting = XMLUtil.GetNodeValueBool(node, "@RemoveExisting", true),
};
comboNoteEditorCopyPatternPreset.Items.Add(preset);
}
if (comboNoteEditorCopyPatternPreset.Items.Count > 0)
{
comboNoteEditorCopyPatternPreset.SelectedIndex = 0;
}
SongList = new SongCacheList(listBoxSongLibrary);
var snglist = XMLUtil.GetNodeList(settings.XMLRoot, "docLib/song");
if (snglist != null)
{
var lst = new List<SongCacheItem>();
foreach (XmlNode song in snglist)
{
var sc = new SongCacheItem();
sc.SongName = XMLUtil.GetNodeValue(song, "@name");
sc.G5FileName = XMLUtil.GetNodeValue(song, "@G5FileName");
sc.G6FileName = XMLUtil.GetNodeValue(song, "@G6FileName");
sc.G6ConFile = XMLUtil.GetNodeValue(song, "@G6ConFile");
sc.Description = XMLUtil.GetNodeValue(song, "@Description");
sc.HasBass = XMLUtil.GetNodeValueBool(song, "@HasBass");
sc.HasGuitar = XMLUtil.GetNodeValueBool(song, "@HasGuitar");
sc.CopyGuitarToBass = XMLUtil.GetNodeValueBool(song, "@CopyGuitarToBass");
sc.IsComplete = XMLUtil.GetNodeValueBool(song, "@IsComplete");
sc.IsFinalized = XMLUtil.GetNodeValueBool(song, "@IsFinalized");
sc.GuitarTuning[0] = XMLUtil.GetNodeValue(song, "@GuitarLowE", "0");
sc.GuitarTuning[1] = XMLUtil.GetNodeValue(song, "@GuitarA", "0");
sc.GuitarTuning[2] = XMLUtil.GetNodeValue(song, "@GuitarD", "0");
sc.GuitarTuning[3] = XMLUtil.GetNodeValue(song, "@GuitarG", "0");
sc.GuitarTuning[4] = XMLUtil.GetNodeValue(song, "@GuitarB", "0");
sc.GuitarTuning[5] = XMLUtil.GetNodeValue(song, "@GuitarHighE", "0");
sc.BassTuning[0] = XMLUtil.GetNodeValue(song, "@BassLowE", "0");
sc.BassTuning[1] = XMLUtil.GetNodeValue(song, "@BassA", "0");
sc.BassTuning[2] = XMLUtil.GetNodeValue(song, "@BassD", "0");
sc.BassTuning[3] = XMLUtil.GetNodeValue(song, "@BassG", "0");
sc.BassTuning[4] = XMLUtil.GetNodeValue(song, "@BassB", "0");
sc.BassTuning[5] = XMLUtil.GetNodeValue(song, "@BassHighE", "0");
sc.DTABassDifficulty = XMLUtil.GetNodeValueInt(song, "@DTABassDifficulty", 0);
sc.DTAGuitarDifficulty = XMLUtil.GetNodeValueInt(song, "@DTAGuitarDifficulty", 0);
sc.DTASongID = XMLUtil.GetNodeValue(song, "@DTASongID");
sc.DTASongShortName = XMLUtil.GetNodeValue(song, "@DTASongShortName");
sc.SongMP3Location = XMLUtil.GetNodeValue(song, "@SongMP3Location", "");
sc.SongMP3PlaybackOffset = XMLUtil.GetNodeValue(song, "@SongMP3PlaybackOffset", "").ToInt();
sc.EnableSongMP3Playback = XMLUtil.GetNodeValueBool(song, "@EnableSongMP3Playback", false);
sc.EnableSongMidiPlayback = XMLUtil.GetNodeValueBool(song, "@EnableSongMidiPlayback", true);
sc.SongMP3PlaybackVolume = XMLUtil.GetNodeValueInt(song, "@SongMP3PlaybackVolume", 100);
sc.SongMidiPlaybackVolume = XMLUtil.GetNodeValueInt(song, "@SongMidiPlaybackVolume", 100);
sc.AutoGenGuitarHard = XMLUtil.GetNodeValueBool(song, "@AutoGenGuitarHard", true);
sc.AutoGenGuitarMedium = XMLUtil.GetNodeValueBool(song, "@AutoGenGuitarMedium", true);
sc.AutoGenGuitarEasy = XMLUtil.GetNodeValueBool(song, "@AutoGenGuitarEasy", true);
sc.AutoGenBassHard = XMLUtil.GetNodeValueBool(song, "@AutoGenBassHard", true);
sc.AutoGenBassMedium = XMLUtil.GetNodeValueBool(song, "@AutoGenBassMedium", true);
sc.AutoGenBassEasy = XMLUtil.GetNodeValueBool(song, "@AutoGenBassEasy", true);
var sid = XMLUtil.GetNodeValue(song, "@CacheSongID");
if (!string.IsNullOrEmpty(sid))
{
int songid = sid.ToInt();
if (!songid.IsNull())
{
sc.CacheSongID = songid;
}
else
{
sc.CacheSongID = GetNextSongID();
}
}
sc.IsDirty = false;
try
{
if (string.IsNullOrEmpty(sc.DTASongID) && !string.IsNullOrEmpty(sc.G5FileName))
{
FindDTAInformation(sc);
}
}
catch { }
lst.Add(sc);
}
lst.Sort();
SongList.AddRange(lst);
SongList.PopulateList();
}
CheckNotesGridSelection();
CheckNoteChannelVisibility();
PostLoadSettings();
}
List<string> VerifySongData(string midiTrackName, Sequence midiSequence, SongCacheItem songCacheItem)
{
var fileErrors = new List<string>();
try
{
if (midiSequence.FirstOrDefault() == null)
{
fileErrors.Add("No Tracks");
}
else
{
var proTracks = midiSequence.Skip(1).ToList();
foreach (var track in proTracks)
{
if (track.Name != null && track.Name == "(no name)")
{
fileErrors.Add("******** Missing Track Name: " + (track.Name ?? ""));
}
else if (track.Name.IsProTrackName() == false)
{
fileErrors.Add("Invalid Track Name: " + (track.Name ?? ""));
}
}
}
foreach (var track in midiSequence)
{
if (track.Name.IsEmpty())
{
fileErrors.Add("Null track name");
}
else if (track.Name.IsProTrackName() && midiSequence.IndexOf(track) == 0)
{
fileErrors.Add("Tempo must be first track");
}
}
var tracks = midiSequence.GetGuitarBassTracks().ToList();
bool foundGuitarTrack = tracks.Any(x => x.Name.IsGuitarTrackName());
bool foundBassTrack = tracks.Any(x => x.Name.IsBassTrackName());
bool foundGuitar22 = tracks.Any(x => x.Name.IsGuitarTrackName22());
bool foundBass22 = tracks.Any(x => x.Name.IsBassTrackName22());
bool foundGuitar17 = tracks.Any(x => x.Name.IsGuitarTrackName17());
bool foundBass17 = tracks.Any(x => x.Name.IsBassTrackName17());
if (foundGuitarTrack == false)
{
fileErrors.Add("No pro guitar track in midi file: " + midiTrackName);
}
if (foundBassTrack == false && (songCacheItem != null && songCacheItem.HasBass == true))
{
fileErrors.Add("No pro bass track in midi file: " + midiTrackName);
}
if (foundGuitar22 == true && foundGuitar17 == false)
{
fileErrors.Add("No 17 fret pro guitar track in file: " + midiTrackName);
}
if (foundBass22 == true && foundBass17 == false)
{
fileErrors.Add("No 17 fret pro bass track in file: " + midiTrackName);
}
foreach (var currentTrack in tracks)
{
var currentTrackName = currentTrack.Name ?? "(no name)";
if (!EditorPro.SetTrack6(midiSequence, currentTrack, GuitarDifficulty.Expert))
{
fileErrors.Add(currentTrackName + " Failed to set track ");
continue;
}
var metaNames = currentTrack.Meta.Where(x => x.MetaType == MetaType.TrackName).ToList();
if (!metaNames.Any())
{
fileErrors.Add("Contains Invalid track with no name");
}
else if (metaNames.Count() > 1)
{
fileErrors.Add(metaNames.First().Text + " Contains Extra track names:");
foreach (var en in metaNames)
{
fileErrors.Add(en.Text);
}
}
foreach (var diff in Utility.GetDifficultyIter())
{
EditorPro.CurrentDifficulty = diff;
var chords = EditorPro.Messages.Chords.ToList();
if (!chords.Any())
{
fileErrors.Add(currentTrackName + " No Chords Created !! " + diff);
continue;
}
if (diff.IsExpert())
{
if (EditorG5.IsLoaded)
{
var copyGuitarToBass = (songCacheItem != null && songCacheItem.CopyGuitarToBass == true);
if (currentTrackName.IsBassTrackName() && !copyGuitarToBass &&
EditorG5.GetTrack(GuitarTrack.BassTrackName5) != null)
{
EditorG5.SetTrack(GuitarTrack.BassTrackName5, diff);
}
else if (EditorG5.GetTrack(GuitarTrack.GuitarTrackName5) != null)
{
EditorG5.SetTrack(GuitarTrack.GuitarTrackName5, diff);
}
if (EditorG5.Messages.BigRockEndings.Any() &&
!EditorPro.Messages.BigRockEndings.Any())
{
fileErrors.Add(currentTrackName + " Big Rock Ending in 5 button but not pro");
}
var solo5 = EditorG5.Messages.Solos.ToList();
var solo6 = EditorPro.Messages.Solos.ToList();
var missing5 = solo5.Where(x => !solo6.Any(sx => sx.TickPair == x.TickPair)).ToList();
if (missing5.Any())
{
fileErrors.Add(currentTrackName + " Not all solos created ");
fileErrors.AddRange(missing5.Select(m => m.TickPair.ToString()));
}
var power5 = EditorG5.Messages.Powerups.ToList();
var power6 = EditorPro.Messages.Powerups.ToList();
var missingpower5 = power5.Where(x => !power6.Any(sx => sx.TickPair == x.TickPair)).ToList();
if (missingpower5.Any())
{
fileErrors.Add(currentTrackName + " Not all powerups snapped ");
fileErrors.Add("Editor G5");
fileErrors.AddRange(power5.Select(m => " " + (missingpower5.Contains(m) ? " Missing->" : "") + m.TickPair.ToString()));
fileErrors.Add("Editor G6");
fileErrors.AddRange(power6.Select(m => " " + m.TickPair.ToString()));
}
}
var handPositions = EditorPro.Messages.HandPositions.ToList();
if (!handPositions.Any())
{
fileErrors.Add(currentTrackName + " does not have hand position events (108) " + diff);
}
else
{
if (chords.First().DownTick < handPositions.First().DownTick)
{
fileErrors.Add("108 hand position event occurs too late on track: " + (currentTrackName) + " " + diff);
}
}
if (chords.First().DownTick < 10)
{
fileErrors.Add("first chord is too soon in track: " + (currentTrackName) + " " + diff);
}
var tempotrack = EditorPro.GuitarTrack.GetTempoTrack();
if (tempotrack == null)
{
fileErrors.Add(currentTrackName + " no tempo track found");
}
if (!EditorPro.Messages.TimeSignatures.Any())
{
fileErrors.Add(currentTrackName + " Time signature missing from tempo track.");
}
if (!EditorPro.Messages.Tempos.Any())
{
fileErrors.Add(currentTrackName + " Tempo missing from tempo track.");
}
}
if (songCacheItem != null)
{
if (songCacheItem.CopyGuitarToBass == false)
{
if (currentTrackName.IsBassTrackName())
{
var notesOver4 = chords.Where(c => c.Notes.Any(x=> x.NoteString > 3)).ToList();
if (notesOver4.Any())
{
fileErrors.Add(currentTrackName + " " + notesOver4.Count + " Chords using more than 4 strings on bass: " + diff);
fileErrors.AddRange(notesOver4.Select(m => m.ToString()));
}
}
}
}
var noteAligns = chords.Where(x => x.Notes.NotesAligned == false).ToList();
if (noteAligns.Any())
{
fileErrors.Add(currentTrackName + " " + noteAligns.Count + " Note times not snapped: " + diff);
fileErrors.AddRange(noteAligns.Select(m => m.ToString()));
}
var modAligns = chords.Where(chord => chord.Modifiers.Any(modifier => modifier.TickPair != chord.TickPair)).ToList();
if (modAligns.Any())
{
fileErrors.Add(currentTrackName + " " + modAligns.Count + " Modifier times not snapped: " + diff);
fileErrors.AddRange(modAligns.Select(m => m.ToString() + " " + m.TickPair.ToString()));
}
var overlaps = chords.Take(chords.Count - 1).Where(x => x.UpTick > x.NextChord.DownTick).ToList();
if (overlaps.Any())
{
fileErrors.Add(currentTrackName + " " + overlaps.Count + " Overlapping notes found: " + diff);
fileErrors.AddRange(overlaps.Select(m => m.ToString()));
}
if (Utility.GetArpeggioData1(diff).IsNotNull())
{
var arpeggios = EditorPro.Messages.Arpeggios.ToList();
var arpeggioMissingChords = arpeggios.Where(x => chords.AnyBetweenTick(x.TickPair) == false).ToList();
if (arpeggioMissingChords.Any())
{
fileErrors.Add(currentTrackName + " " + arpeggioMissingChords.Count + " Arpeggios found with no chords: " + diff);
fileErrors.AddRange(arpeggioMissingChords.Select(m => m.ToString()));
}
}
if (diff.IsExpert())
{
var sstrem = EditorPro.Messages.SingleStringTremelos.ToList();
var modWithNoNotes = sstrem.Where(x => chords.AnyBetweenTick(x.TickPair) == false).ToList();
if (modWithNoNotes.Any())
{
fileErrors.Add(currentTrackName + " " + modWithNoNotes.Count + " Single string tremelo with no notes: " + diff);
fileErrors.AddRange(modWithNoNotes.Select(m => m.ToString()));
}
}
if (diff.IsExpert())
{
var trem = EditorPro.Messages.MultiStringTremelos.ToList();
var modWithNoNotes = trem.Where(x => chords.AnyBetweenTick(x.TickPair) == false).ToList();
if (modWithNoNotes.Any())
{
fileErrors.Add(currentTrackName + " " + modWithNoNotes.Count + " Multi string tremelo with no notes: " + diff);
fileErrors.AddRange(modWithNoNotes.Select(m => m.ToString()));
}
}
{
var powerups = EditorPro.Messages.Powerups.ToList();
var modWithNoNotes = powerups.Where(x => chords.AnyBetweenTick(x.TickPair) == false).ToList();
if (modWithNoNotes.Any())
{
fileErrors.Add(currentTrackName + " " + modWithNoNotes.Count + " Powerup with no notes: " + diff);
fileErrors.AddRange(modWithNoNotes.Select(m => m.ToString()));
}
}
var over17 = chords.Where(x => x.HighestFret > 17);
if (currentTrackName.IsProTrackName17() && over17.Any())
{
fileErrors.Add(currentTrackName + " Notes above 17 on Mustang chart: " + diff);
fileErrors.AddRange(over17.Select(m => m.ToString()));
}
var chordMix = chords.Where(x => x.Notes.Any(n => n.IsXNote) && x.Notes.Any(n => n.IsXNote) == false);
if (chordMix.Any())
{
fileErrors.Add(currentTrackName + " Mix of mute and non mute: " + diff);
fileErrors.AddRange(chordMix.Select(m => m.ToString()));
}
var numZero = chords.Count(x => x.HighestFret == 0);
var numNonZero = chords.Count(x => x.HighestFret != 0);
if (numNonZero == 0)
{
fileErrors.Add(currentTrackName + " No notes set: " + diff);
}
var shortChords = chords.Where(x => x.TickLength < 8);
if (shortChords.Any())
{
fileErrors.Add(currentTrackName + " invalid chord length found: " + diff);
shortChords.ForEach(x => fileErrors.Add(" " + x.ToString()));
}
var invStrum = chords.Where(x =>
(x.HasHighStrum && !x.HighStrumNotes.Any()) ||
(x.HasMidStrum && !x.MidStrumNotes.Any()) ||
(x.HasLowStrum && !x.LowStrumNotes.Any())
).ToList();
if (invStrum.Any())
{
fileErrors.Add(currentTrackName + " " + diff + " strum marker missing notes");
fileErrors.AddRange(invStrum.Select(m => m.ToString()));
}
}
}//end for each track
}
catch (Exception ex)
{
fileErrors.Add("Exception while checking file: " + ex.Message);
}
return fileErrors;
}
