public void GenerateChords(Attributes2014 attribute, Song2014 song)
{
// Some ODLC contain JSON Chords errors, this method is producing workable results
//
// USING song.Levels[difficulty].HandShapes METHOD
// the handshape data can be used to obtain chordIds
// (more efficient less data to iterate through)
//
//"Chords" : {
// "DiffLevelID" : {//used to display which chord is set at current lvl.
// "SectionID" : [// >= 0
// ChordID,
// ChordID
// ]
// },
// }
if (song.Sections == null)
{
return;
}
attribute.Chords = new Dictionary <string, Dictionary <string, List <int> > >();
for (int difficulty = 0; difficulty < song.Levels.Length; difficulty++)
{
var chords = song.Levels[difficulty].HandShapes;
var sectionId = new Dictionary <string, List <int> >();
var chordId = new List <int>();
for (int section = 0; section < song.Sections.Length; section++)
{
var sectionNumber = song.Sections[section].Number;
var starTime = song.Sections[section].StartTime;
var endTime = song.Sections[Math.Min(section + 1, song.Sections.Length - 1)].StartTime;
// iterate through chords in handshapes in the difficulty level
foreach (var chord in chords)
{
if (chord.StartTime >= starTime && chord.EndTime < endTime) //in range
{
chordId.Add(chord.ChordId);
}
}
if (chordId.Count > 0)
{
// always ordered in ODLC
List <int> distinctChordIds = chordId.Distinct().OrderBy(x => x).ToList();
sectionId.Add(section.ToString(), distinctChordIds);
}
chordId = new List <int>();
}
if (sectionId.Keys.Count > 0)
{
attribute.Chords.Add(difficulty.ToString(), sectionId);
}
}
}
/// <summary>
/// Set Arrangement Type and Tuning information.
/// </summary>
/// <param name="song"></param>
private void DetectTuning(Song2014 song)
{
var t = TuningDefinitionRepository.Instance.Detect(song.Tuning, GameVersion.RS2014, ArrangementType == ArrangementType.Guitar);
Tuning = t.UIName;
TuningStrings = t.Tuning;
}
private bool FixBassTuning()
{
// fix old toolkit behavior
if (Arrangement.TuningStrings == null)
{
Arrangement.TuningStrings = new TuningStrings { String0 = 0, String1 = 0, String2 = 0, String3 = 0, String4 = 0, String5 = 0 };
return false;
}
if (_gameVersion == GameVersion.RS2012)
return false;
var bassFix = false;
//Low tuning fix for bass, If lowest string is B and bass fix not applied
if (Arrangement.TuningStrings.String0 < -4 && Arrangement.TuningPitch != 220.00)
if (_fixLowBass)
bassFix = true;
else
bassFix |= MessageBox.Show(@"The bass tuning may be too low. Apply Low Bass Tuning Fix?" + Environment.NewLine + @"Note: The fix may revert if bass Arrangement is re-saved in EOF. ", @"Warning ... Low Bass Tuning", MessageBoxButtons.YesNo) == DialogResult.Yes;
// Fix Low Bass Tuning
if (bassFix && TuningFrequency.ApplyBassFix(Arrangement, _fixLowBass))
{
Arrangement.TuningStrings = Song2014.LoadFromFile(Arrangement.SongXml.File).Tuning;
Arrangement.TuningPitch = 220.00;
txtFrequency.Text = "220.00";
return true;
}
return false;
}
static Dictionary <int, ChordTemplate> GetChordTemplates(Song2014 arrangement)
{
var templates = new Dictionary <int, ChordTemplate>();
for (int i = 0; i < arrangement.ChordTemplates.Length; ++i)
{
var rsTemplate = arrangement.ChordTemplates[i];
var template = new ChordTemplate()
{
ChordId = i,
Name = rsTemplate.ChordName,
Frets = new int[] { rsTemplate.Fret0, rsTemplate.Fret1, rsTemplate.Fret2,
rsTemplate.Fret3, rsTemplate.Fret4, rsTemplate.Fret5 },
Fingers = new int[] { rsTemplate.Finger0, rsTemplate.Finger1,
rsTemplate.Finger2, rsTemplate.Finger3, rsTemplate.Finger4,
rsTemplate.Finger5 }
};
// correct for capo position. this is necessary since Rocksmith is weird when using
// a capo: the open string is indexed as 0, but any pressed fret is given as the
// absolute fret, not relative to the capo.
for (int j = 0; j < 6; ++j)
{
if (template.Frets[j] > 0)
{
template.Frets[j] -= arrangement.Capo;
}
}
templates.Add(template.ChordId, template);
}
return(templates);
}
static void AddSectionNames(Song2014 arrangement, List <Bar> bars)
{
var sections = arrangement.Sections.OrderBy(x => x.StartTime);
int c = 0;
int b = 0;
foreach (var section in sections)
{
while (b < bars.Count && bars[b].Chords[c].Start < section.StartTime)
{
++c;
if (c >= bars[b].Chords.Count)
{
c = 0;
++b;
}
}
if (b < bars.Count)
{
var chord = bars[b].Chords[c];
chord.Section = section.Name.ToUpper();
}
}
}
/// <param name="song"></param>
/// <param name="difficultyLevel">null = highest level available</param>
public static Score GetScoreForExactDifficultyLevel(Song2014 song, int?difficultyLevel)
{
SongLevel2014 selectedLevel;
if (difficultyLevel.HasValue)
{
selectedLevel = song.Levels.FirstOrDefault(x => x.Difficulty == difficultyLevel);
}
else
{
selectedLevel = song.Levels.OrderBy(x => x.Difficulty).LastOrDefault();
}
if (selectedLevel == null)
{
return(null);
}
var allSounds = selectedLevel.Notes.Select(x => new SongNoteChordWrapper(x))
.Union(selectedLevel.Chords.Select(x => new SongNoteChordWrapper(x)));
var score = CreateSong(song, allSounds);
return(score);
}
/// <param name="song"></param>
/// <param name="difficultyLevel">null = highest level available</param>
public static Score GetScoreForMaxDifficultyLevel(Song2014 song, int?difficultyLevel)
{
List <PhraseIterationWithEndTime> iterationsWithEndTime = PhraseIterationWithEndTime.listFromBaseArray(song.PhraseIterations);
IEnumerable <SongNoteChordWrapper> allSounds = Enumerable.Empty <SongNoteChordWrapper>();
for (int phraseId = 0; phraseId < song.Phrases.Length; phraseId++)
{
var phrase = song.Phrases[phraseId];
var diffLevel = phrase.MaxDifficulty;
if (difficultyLevel.HasValue && difficultyLevel < diffLevel)
{
diffLevel = difficultyLevel.Value;
}
var selectedLevel = song.Levels.FirstOrDefault(x => x.Difficulty == diffLevel);
var phraseIterations = iterationsWithEndTime.Where(x => x.PhraseId == phraseId).ToArray();
for (int i = 0; i < phraseIterations.Length; i++)
{
var iterationWithEndTime = phraseIterations[i];
var notes = selectedLevel.Notes.Where(x => iterationWithEndTime.contains(x.Time));
var chords = selectedLevel.Chords.Where(x => iterationWithEndTime.contains(x.Time));
allSounds = allSounds.Union(notes.Select(x => new SongNoteChordWrapper(x)))
.Union(chords.Select(x => new SongNoteChordWrapper(x)));
}
}
var score = CreateSong(song, allSounds);
return(score);
}
static void ExportArrangement(Score score, Song2014 arrangement, string identifier, int difficulty,
string originalFile, ToolkitInfo toolkitInfo)
{
var track = Converter.ConvertArrangement(arrangement, identifier, difficulty);
score.Tracks.Add(track);
score.Title = arrangement.Title;
score.Artist = arrangement.ArtistName;
score.ArtistSort = arrangement.ArtistNameSort;
score.Album = arrangement.AlbumName;
score.Year = arrangement.AlbumYear;
score.Comments = new List <string>();
score.Comments.Add("Generated by RocksmithToTab v" + VersionInfo.VERSION);
score.Comments.Add("=> http://www.rocksmithtotab.de");
score.Comments.Add("Created from archive: " + Path.GetFileName(originalFile));
if (toolkitInfo != null && toolkitInfo.PackageAuthor != string.Empty)
{
score.Comments.Add("CDLC author: " + toolkitInfo.PackageAuthor);
score.Tabber = toolkitInfo.PackageAuthor;
}
if (toolkitInfo != null && toolkitInfo.PackageVersion != string.Empty)
{
score.Comments.Add("CDLC version: " + toolkitInfo.PackageVersion);
}
}
public static void UpdateXml(Arrangement arr, DLCPackageData info)
{
// update xml with user modified DLCPackageData info
var songXml = Song2014.LoadFromFile(arr.SongXml.File);
arr.SongFile = new RocksmithToolkitLib.DLCPackage.AggregateGraph.SongFile {
File = ""
};
arr.Id = IdGenerator.Guid();
arr.MasterId = RandomGenerator.NextInt();
songXml.AlbumName = info.SongInfo.Album;
songXml.AlbumYear = info.SongInfo.SongYear.ToString();
songXml.ArtistName = info.SongInfo.Artist;
songXml.ArtistNameSort = info.SongInfo.ArtistSort;
songXml.AverageTempo = info.SongInfo.AverageTempo;
songXml.Title = info.SongInfo.SongDisplayName;
songXml.ToneBase = arr.ToneBase;
songXml.ToneA = arr.ToneA;
songXml.ToneB = arr.ToneB;
songXml.ToneC = arr.ToneC;
songXml.ToneD = arr.ToneD;
File.Delete(arr.SongXml.File);
using (var stream = File.OpenWrite(arr.SongXml.File))
{
songXml.Serialize(stream);
}
}
public TrackDetail GetTrackDetail(string songKey, string arrangmentName)
{
var sngEntry = _psarc.Entries.FirstOrDefault(x => x.Name == @"songs/bin/generic/" + songKey + "_" + arrangmentName + ".sng");
var jsonEntry = _psarc.Entries.FirstOrDefault(x => x.Name.StartsWith(@"manifests/songs") && x.Name.EndsWith("/" + songKey + "_" + arrangmentName + ".json"));
if (sngEntry == null || jsonEntry == null)
{
return(null);
}
Attributes2014 att;
using (var wrappedStream = new NonClosingStreamWrapper(jsonEntry.Data))
{
using (var reader = new StreamReader(wrappedStream))
{
var manifest = JsonConvert.DeserializeObject <Manifest2014 <Attributes2014> >(reader.ReadToEnd());
att = manifest.Entries.ToArray()[0].Value.ToArray()[0].Value;
}
}
Sng2014File sngFile;
using (var wrappedStream = new NonClosingStreamWrapper(sngEntry.Data))
{
var platform = _archiveFile.GetPlatform();
sngFile = Sng2014File.ReadSng(wrappedStream, platform);
}
var sngObject = new Song2014(sngFile, att);
return(new TrackDetail()
{
RockSmithSong = sngObject
});
}
private Song2014 ConvertChordTemplates(Song rsSong, Song2014 rsSong2014)
{
// add chordTemplates elements
var chordTemplate = new List <SongChordTemplate2014>();
foreach (var songChordTemplate in rsSong.ChordTemplates)
{
// tested ... not the source of game hangs
//if (String.IsNullOrEmpty(songChordTemplate.ChordName))
// continue;
chordTemplate.Add(new SongChordTemplate2014 {
ChordName = songChordTemplate.ChordName, DisplayName = songChordTemplate.ChordName, Finger0 = (sbyte)songChordTemplate.Finger0, Finger1 = (sbyte)songChordTemplate.Finger1, Finger2 = (sbyte)songChordTemplate.Finger2, Finger3 = (sbyte)songChordTemplate.Finger3, Finger4 = (sbyte)songChordTemplate.Finger4, Finger5 = (sbyte)songChordTemplate.Finger5, Fret0 = (sbyte)songChordTemplate.Fret0, Fret1 = (sbyte)songChordTemplate.Fret1, Fret2 = (sbyte)songChordTemplate.Fret2, Fret3 = (sbyte)songChordTemplate.Fret3, Fret4 = (sbyte)songChordTemplate.Fret4, Fret5 = (sbyte)songChordTemplate.Fret5
});
}
// tested ... not the source of game hangs
// get rid of duplicate chords if any
// chordTemplate = chordTemplate.Distinct().ToList();
// tested ... could be source of game hangs
if (rsSong.ChordTemplates == null)
{
Console.WriteLine("Applied fix to RS1->RS2 ChordTemplates conversion");
rsSong2014.ChordTemplates = new SongChordTemplate2014[0];
}
else
{
rsSong2014.ChordTemplates = chordTemplate.ToArray();
}
return(rsSong2014);
}
private static void AddSongMetadata(Song2014 rsSong, ZpeSong zigSong, string arrangment)
{
// standard meta header data
rsSong.Version = "7";
rsSong.Arrangement = arrangment;
rsSong.Part = 1;
rsSong.Offset = 0;
rsSong.CentOffset = "0";
rsSong.StartBeat = 0;
rsSong.Capo = 0;
rsSong.AlbumName = "Unknown Album";
rsSong.AlbumYear = DateTime.Now.ToString("yyyy");
rsSong.CrowdSpeed = "1";
rsSong.LastConversionDateTime = DateTime.Now.ToString();
rsSong.SongLength = zigSong.Length;
Regex regex = new Regex(" - ");
string[] artistTitle = regex.Split(zigSong.Name);
rsSong.ArtistName = artistTitle[0] == null ? zigSong.Name : artistTitle[0];
rsSong.Title = artistTitle[1] == null ? zigSong.Name : artistTitle[1];
ZpeTempo tempo = zigSong.Tracks[0].Tempos[0];
float BPM = (float)Math.Round((float)60000000 / tempo.RawTempo, 3);
rsSong.AverageTempo = BPM;
ZpeTuning tuning = null;
for (int i = 0; i < zigSong.Tunings.Tuning.Count; i++)
{
if (arrangment == "Lead" || arrangment == "Rhythm")
{
if (zigSong.Tunings.Tuning[i].IsGuitarTuning)
{
tuning = zigSong.Tunings.Tuning[i];
break;
}
}
if (arrangment == "Bass")
{
if (zigSong.Tunings.Tuning[i].IsBassTuning)
{
tuning = zigSong.Tunings.Tuning[i];
break;
}
}
}
if (tuning == null)
{
throw new Exception("ZPE XML does not contain tuning");
}
rsSong.Tuning = new TuningStrings {
String0 = tuning.E, String1 = tuning.A, String2 = tuning.D, String3 = tuning.G, String4 = tuning.B, String5 = tuning.HighE
};
}
/// <summary>
/// Load a XML arrangment into memory and
/// convert to GuitarPro file
/// </summary>
/// <param name="inputFilePath"></param>
/// <param name="outputDir"></param>
/// <param name="outputFormat"></param>
/// <param name="allDif"></param>
public void XmlToGp5(string inputFilePath, string outputDir, string outputFormat = "gp5", bool allDif = false)
{
Console.WriteLine("Opening arrangement {0} ...", inputFilePath);
Console.WriteLine();
var score = new Score();
var arrangement = Song2014.LoadFromFile(inputFilePath);
var toolkitInfo = new ToolkitInfo();
toolkitInfo.ToolkitVersion = String.Format("CST v{0}", ToolkitVersion.version);
toolkitInfo.PackageAuthor = "XML To GP5 Converter";
toolkitInfo.PackageVersion = arrangement.LastConversionDateTime;
var comments = Song2014.ReadXmlComments(inputFilePath);
foreach (var xComment in comments)
{
if (xComment.Value.Contains("CST"))
{
toolkitInfo.ToolkitVersion = xComment.Value.Trim();
break;
}
}
// get maximum difficulty for the arrangement
var mf = new ManifestFunctions(GameVersion.RS2014);
int maxDif = mf.GetMaxDifficulty(arrangement);
if (allDif) // create separate file for each difficulty
{
for (int difLevel = 0; difLevel <= maxDif; difLevel++)
{
ExportArrangement(score, arrangement, difLevel, inputFilePath, toolkitInfo);
Console.WriteLine("Difficulty Level: {0}", difLevel);
var baseFileName = CleanFileName(
String.Format("{0} - {1}", score.Artist, score.Title));
baseFileName += String.Format(" ({0})", arrangement.Arrangement);
baseFileName += String.Format(" (level {0:D2})", difLevel);
SaveScore(score, baseFileName, outputDir, outputFormat);
// remember to remove the track from the score again
score.Tracks.Clear();
}
}
else // combine maximum difficulty arrangements into one file
{
Console.WriteLine("Maximum Difficulty Level: {0}", maxDif);
ExportArrangement(score, arrangement, maxDif, inputFilePath, toolkitInfo);
}
if (!allDif) // only maximum difficulty
{
var baseFileName = CleanFileName(
String.Format("{0} - {1}", score.Artist, score.Title));
SaveScore(score, baseFileName, outputDir, outputFormat);
}
}
public Showlights Genegate(string xmlFile)
{
var midiNotes = new List <Showlight>();
var chordNotes = new List <Showlight>();
var ShowL = new Showlights();
var song = Song2014.LoadFromFile(xmlFile);
// If vocals
if (song.Phrases == null || song.Tuning == null)
{
return(null);
}
//Generate ShowlightList
var tuning = song.Tuning.ToShortArray();
if (song.Levels != null)
{
foreach (var lvl in song.Levels)
{
for (int i = 0; i + 1 <= lvl.Notes.Count(); i++)
{
var mNote = Sng2014FileWriter.GetMidiNote(tuning,
(Byte)lvl.Notes[i].String,
(Byte)lvl.Notes[i].Fret,
song.Arrangement == "Bass",
song.Capo);
midiNotes.Add(new Showlight()
{
Time = lvl.Notes[i].Time, Note = mNote
});
}
for (int i = 0; i + 1 <= lvl.Chords.Count(); i++)
{
if (lvl.Chords[i].HighDensity == 1)
{
continue; //speedhack
}
int mNote = Sng2014FileWriter.getChordNote(tuning,
lvl.Chords[i], song.ChordTemplates,
song.Arrangement == "Bass",
song.Capo);
chordNotes.Add(new Showlight()
{
Time = lvl.Chords[i].Time, Note = mNote
});
}
}
}
ShowL.PopShList(midiNotes);
ShowL.PopShList(chordNotes);
ShowL.Count = ShowL.ShowlightList.Count;
return(ShowL);
}
public void Convert(string zigSrcPath, string destPath)
{
var deser = new XmlSerializer(typeof(ZpeSong));
ZpeSong zigSong;
using (FileStream stream = new FileStream(zigSrcPath, FileMode.Open))
{
zigSong = (ZpeSong)deser.Deserialize(stream);
}
if (zigSong.PueVersion != 46)
{
throw new Exception("Incompatable version of Ziggy Pro Editor XML file");
}
bool foundTrack = false;
StringBuilder sb = new StringBuilder();
// cross matching arrangment arrays
string[] rsArray = new string[] { "Lead", "Rhythm", "Bass" };
string[] zigArray = new string[] { "PART REAL_GUITAR_22", "PART REAL_GUITAR", "PART REAL_BASS_22" };
int arrIndex = -1;
foreach (var arrangement in zigArray)
{
arrIndex++;
var guitarTrack = zigSong.Tracks.SingleOrDefault(tr => arrangement.Equals(tr.Name));
if (guitarTrack == null)
{
continue;
//throw new Exception("Couldn't find a guitar track");
}
foundTrack = true;
var rsSong = new Song2014();
AddSongMetadata(rsSong, zigSong, rsArray[arrIndex]);
AddEbeats(rsSong, zigSong, arrangement);
AddNotes(rsSong, zigSong, arrangement);
AddToneProps(rsSong, rsArray[arrIndex]);
var destDir = Path.GetDirectoryName(destPath);
var destName = Path.GetFileNameWithoutExtension(destPath);
var xmlDestPath = String.Format("{0}_{1}.xml", Path.Combine(destDir, destName), rsArray[arrIndex]);
using (FileStream stream = new FileStream(xmlDestPath, FileMode.Create))
{
rsSong.Serialize(stream, true);
}
}
if (!foundTrack)
{
throw new NullReferenceException("Did not find any Rocksmith 2014 compatible Ziggy Pro tracks in " + Path.GetFileName(zigSrcPath) + Environment.NewLine);
}
}
public Song Song2014ToSong(Song2014 rs2014Song)
{
var rs1Song = new Song();
AddSongMetadata(rs2014Song, rs1Song);
AddElements(rs2014Song, rs1Song);
AddDifferences(rs2014Song, rs1Song);
return(rs1Song);
}
public AttributesHeader2014(string arrangementFileName, Arrangement arrangement, DLCPackageData info, Platform platform)
{
IsVocal = arrangement.ArrangementType == Sng.ArrangementType.Vocal;
SongContent = (IsVocal) ? null : Song2014.LoadFromFile(arrangement.SongXml.File);
var dlcName = info.Name.ToLower();
var albumUrn = String.Format(URN_TEMPLATE, TagValue.Image.GetDescription(), TagValue.DDS.GetDescription(), String.Format("album_{0}", dlcName));
var jsonUrn = String.Format(URN_TEMPLATE, TagValue.Database.GetDescription(), TagValue.JsonDB.GetDescription(), String.Format("{0}_{1}", dlcName, arrangementFileName));
//FILL ATTRIBUTES
this.AlbumArt = albumUrn;
ArrangementName = arrangement.Name.ToString();
DLC = true;
DLCKey = info.Name;
LeaderboardChallengeRating = 0;
ManifestUrn = jsonUrn;
MasterID_RDV = arrangement.MasterId;
PersistentID = arrangement.Id.ToString().Replace("-", "").ToUpper();
Shipping = true;
SKU = "RS2";
SongKey = info.Name;
if (!IsVocal)
{
AlbumName = AlbumNameSort = info.SongInfo.Album;
ArtistName = info.SongInfo.Artist;
CentOffset = arrangement.TuningPitch != 0 ? TuningFrequency.Frequency2Cents(arrangement.TuningPitch) : 0.0;
ArtistNameSort = info.SongInfo.ArtistSort;
CapoFret = (arrangement.Sng2014.Metadata.CapoFretId == 0xFF) ? CapoFret = 0 : Convert.ToDecimal(arrangement.Sng2014.Metadata.CapoFretId);
DNA_Chords = arrangement.Sng2014.DNACount[(int)DNAId.Chord];
DNA_Riffs = arrangement.Sng2014.DNACount[(int)DNAId.Riff];
DNA_Solo = arrangement.Sng2014.DNACount[(int)DNAId.Solo];
NotesEasy = arrangement.Sng2014.NoteCount[0];
NotesMedium = arrangement.Sng2014.NoteCount[1];
NotesHard = arrangement.Sng2014.NoteCount[2];
EasyMastery = NotesEasy / NotesHard;
MediumMastery = NotesMedium / NotesHard;
Representative = Convert.ToInt32(!arrangement.BonusArr);
RouteMask = (int)arrangement.RouteMask;
// TODO this is not quite it but much closer
SongDiffEasy = SongContent.SongLength / NotesEasy;
SongDiffMed = SongContent.SongLength / NotesMedium;
SongDiffHard = SongContent.SongLength / NotesHard;
SongDifficulty = SongDiffHard;
SongLength = (double?)Math.Round(SongContent.SongLength, 3, MidpointRounding.AwayFromZero);
SongName = info.SongInfo.SongDisplayName;
SongNameSort = info.SongInfo.SongDisplayNameSort;
SongYear = info.SongInfo.SongYear;
var tunDef = TuningDefinitionRepository.Instance().Select(arrangement.Tuning, platform.version);
Tuning = tunDef.Tuning;
}
}
private void convertSngXmlButton_Click(object sender, EventArgs e)
{
if (String.IsNullOrEmpty(ConverterSngXmlFile))
{
MessageBox.Show(String.Format("File not found: {0}: ", ConverterSngXmlFile), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
sngXmlTB.Focus();
return;
}
if (sng2xmlRadio.Checked)
{
if (String.IsNullOrEmpty(ConverterManifestFile))
{
MessageBox.Show("No manifest file was entered. The song xml file will be generated without song informations like song title, album, artist, tone names, etc.", MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Error);
}
Attributes2014 att = null;
if (ConverterArrangementType != ArrangementType.Vocal && !String.IsNullOrEmpty(ConverterManifestFile))
{
att = Manifest2014 <Attributes2014> .LoadFromFile(ConverterManifestFile).Entries.ToArray()[0].Value.ToArray()[0].Value;
}
var sng = Sng2014File.LoadFromFile(ConverterSngXmlFile, ConverterPlatform);
var outputFile = Path.Combine(Path.GetDirectoryName(ConverterSngXmlFile), String.Format("{0}.xml", Path.GetFileNameWithoutExtension(ConverterSngXmlFile)));
using (FileStream outputStream = new FileStream(outputFile, FileMode.Create, FileAccess.ReadWrite))
{
dynamic xml = null;
if (ConverterArrangementType == ArrangementType.Vocal)
{
xml = new Vocals(sng);
}
else
{
xml = new Song2014(sng, att ?? null);
}
xml.Serialize(outputStream);
MessageBox.Show(String.Format("XML file was generated! {0}It was saved on same location of sng file specified.", Environment.NewLine), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else if (xml2sngRadio.Checked)
{
var outputFile = Path.Combine(Path.GetDirectoryName(ConverterSngXmlFile), String.Format("{0}.sng", Path.GetFileNameWithoutExtension(ConverterSngXmlFile)));
using (FileStream outputStream = new FileStream(outputFile, FileMode.Create, FileAccess.ReadWrite)) {
Sng2014File sng = Sng2014File.ConvertXML(ConverterSngXmlFile, ConverterArrangementType);
sng.WriteSng(outputStream, ConverterPlatform);
}
MessageBox.Show(String.Format("SNG file was generated! {0}It was saved on same location of xml file specified.", Environment.NewLine), MESSAGEBOX_CAPTION, MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
private static void UpdateTones(Arrangement arrangement)
{
// template may not reflect current XML state, update tone slots
if (arrangement.ArrangementType != ArrangementType.Vocal)
{
var xml = Song2014.LoadFromFile(arrangement.SongXml.File);
if (xml.ToneBase != null)
{
arrangement.ToneBase = xml.ToneBase;
}
// A (ID 0)
if (xml.ToneA != null)
{
if (xml.ToneA != xml.ToneBase)
{
// SNG convertor expects ToneA to be ID 0
throw new InvalidDataException(String.Format("Invalid tone definition detected in {0}, ToneA (ID 0) is expected to be same as ToneBase.", arrangement.SongXml.File));
}
arrangement.ToneA = xml.ToneA;
}
else
{
arrangement.ToneA = null;
}
// B (ID 1)
if (xml.ToneB != null)
{
arrangement.ToneB = xml.ToneB;
}
else
{
arrangement.ToneB = null;
}
// C (ID 2)
if (xml.ToneC != null)
{
arrangement.ToneC = xml.ToneC;
}
else
{
arrangement.ToneC = null;
}
// D (ID 3)
if (xml.ToneD != null)
{
arrangement.ToneD = xml.ToneD;
}
else
{
arrangement.ToneD = null;
}
}
}
private void AddElements(Song2014 rs2014Song, Song rs1Song)
{
// these elements have direct mapping
rs1Song.Phrases = rs2014Song.Phrases;
rs1Song.LinkedDiffs = rs2014Song.LinkedDiffs;
rs1Song.PhraseProperties = rs2014Song.PhraseProperties;
rs1Song.FretHandMuteTemplates = rs2014Song.FretHandMuteTemplates;
rs1Song.Ebeats = rs2014Song.Ebeats;
rs1Song.Sections = rs2014Song.Sections;
rs1Song.Events = rs2014Song.Events;
}
// this is platform independent SNG object
public static Sng2014File ConvertSong(string xmlFile)
{
var song = Song2014.LoadFromFile(xmlFile);
var parser = new Sng2014FileWriter();
var sng = new Sng2014File();
parser.ReadSong(song, sng);
sng.NoteCount = parser.NoteCount;
sng.DNACount = parser.DNACount;
return(sng);
}
static void ExportXml(List <string> inputFiles, CmdOptions options)
{
Score score = new Score();
string identifier = "none";
foreach (var xmlFile in inputFiles)
{
Console.WriteLine("Processing {0} ...", xmlFile);
Song2014 arrangement = null;
try
{
arrangement = Song2014.LoadFromFile(xmlFile);
}
catch (Exception e)
{
Console.WriteLine("Failed to parse XML input file: " + e.Message);
}
if (arrangement != null)
{
// xml files should be named "songidentifier_arrangement.xml",
// extract the arrangement identifier, which we use to set
// the track name and track color as well as output file name
string baseFileName = Path.GetFileNameWithoutExtension(xmlFile);
var identifiers = baseFileName.Split(new char[] { '_' });
string arr = "";
if (identifiers.Length >= 2)
{
arr = identifiers.Last();
}
identifier = identifiers.First();
ExportArrangement(score, arrangement, arr, options.DifficultyLevel, xmlFile, null);
if (options.SplitArrangements)
{
baseFileName = CleanFileName(
ConstructFileName(options.FileNameFormat, score, identifier, identifier, null));
baseFileName += " (" + arr + ")";
SaveScore(score, baseFileName, options.OutputDirectory, options.OutputFormat);
// remember to remove the track from the score again
score.Tracks.Clear();
}
}
}
if (!options.SplitArrangements)
{
score.SortTracks();
string baseFileName = CleanFileName(
ConstructFileName(options.FileNameFormat, score, identifier, identifier, null));
SaveScore(score, baseFileName, options.OutputDirectory, options.OutputFormat);
}
}
public Int32 GetMaxDifficulty(Song2014 xml)
{
var max = 0;
foreach (var phrase in xml.Phrases)
{
if (max < phrase.MaxDifficulty)
{
max = phrase.MaxDifficulty;
}
}
return(max);
}
/// <summary>
/// Showlights Generator Rev3
/// using arrangement and level with most notes and chords
/// </summary>
/// <param name="xmlFile">Xml file.</param>
private void Generate(string xmlFile, int maxLevelNdx)
{
var midiNotes = new List <Showlight>();
var chordNotes = new List <Showlight>();
var song = Song2014.LoadFromFile(xmlFile);
// error checking
if (song.Phrases == null || song.Levels == null || song.Tuning == null)
{
throw new Exception("Arrangement: " + xmlFile + Environment.NewLine +
"Contains no phrases, levels and/or tuning.");
}
// tuning used to get proper midi notes
var tuning = song.Tuning.ToArray();
foreach (var note in song.Levels[maxLevelNdx].Notes)
{
// make showlights changes occure on the beat/measure
var measOffset = song.Ebeats.Where(eb => eb.Measure != -1 && eb.Time <= note.Time).Last();
// forcing midi notes for guitar gives more consistent results even with bass arrangements
var mNote = Sng2014FileWriter.GetMidiNote(tuning, (Byte)note.String, (Byte)note.Fret, false, song.Capo);
// varying midi notes gives more color changes
// var mNote = Sng2014FileWriter.GetMidiNote(tuning, (Byte)note.String, (Byte)note.Fret, song.Arrangement == "Bass", song.Capo);
midiNotes.Add(new Showlight {
Time = measOffset.Time, Note = mNote
});
}
foreach (var chord in song.Levels[maxLevelNdx].Chords)
{
if (chord.HighDensity == 1)
{
continue; //speedhack
}
// make showlights occure on the beat/measure
var measOffset = song.Ebeats.Where(eb => eb.Measure != -1 && eb.Time <= chord.Time).Last();
// forcing midi notes for guitar gives more consistent results even with bass arrangements
var mNote = Sng2014FileWriter.getChordNote(tuning, chord, song.ChordTemplates, false, song.Capo);
// varying midi notes gives more color changes
//var mNote = Sng2014FileWriter.getChordNote(tuning, chord, song.ChordTemplates, song.Arrangement == "Bass", song.Capo);
chordNotes.Add(new Showlight {
Time = measOffset.Time, Note = mNote
});
}
ShowlightList = new List <Showlight>();
AddShowlights(midiNotes);
AddShowlights(chordNotes);
}
static int[] GetTuning(Song2014 arrangement)
{
// Guitar Pro expects the tuning as Midi note values
// In Rocksmith, the tuning is given as the difference in half steps
// from standard tuning for each string, so we need to convert that.
bool isBass = arrangement.Title.ToLower() == "bass";
int[] tuning = new int[6];
for (byte s = 0; s < tuning.Length; ++s)
{
tuning[s] = Sng2014FileWriter.GetMidiNote(arrangement.Tuning.ToArray(), s, 0, isBass, 0);
}
return(tuning);
}
private Song2014 ConvertPhraseIterations(Song rsSong, Song2014 rsSong2014)
{
var phraseIterations = new List <SongPhraseIteration2014>();
foreach (var songPhraseIteration in rsSong.PhraseIterations)
{
// HeroLevels set to null -> prevent some hangs
phraseIterations.Add(new SongPhraseIteration2014 {
PhraseId = songPhraseIteration.PhraseId, HeroLevels = null, Time = songPhraseIteration.Time
});
}
rsSong2014.PhraseIterations = phraseIterations.ToArray();
return(rsSong2014);
}
private static void UpdateManifest2014(string songDirectory, Platform platform)
{
// UPDATE MANIFEST (RS2014)
if (platform.version == GameVersion.RS2014)
{
var xmlFiles = Directory.EnumerateFiles(songDirectory, "*.xml", SearchOption.AllDirectories);
var jsonFiles = Directory.EnumerateFiles(songDirectory, "*.json", SearchOption.AllDirectories);
foreach (var xml in xmlFiles)
{
var xmlName = Path.GetFileNameWithoutExtension(xml);
if (xmlName.ToUpperInvariant().Contains("SHOWLIGHT"))
{
continue;
}
if (xmlName.ToUpperInvariant().Contains("VOCAL"))
{
continue;//TODO: Re-generate vocals manifest.
}
string json = jsonFiles.Where(name => Path.GetFileNameWithoutExtension(name) == xmlName).FirstOrDefault();
if (!String.IsNullOrEmpty(json))
{
var xmlContent = Song2014.LoadFromFile(xml);
var manifest = new Manifest2014 <Attributes2014>();
var attr = Manifest2014 <Attributes2014> .LoadFromFile(json).Entries.First().Value.First().Value;
var manifestFunctions = new ManifestFunctions(platform.version);
attr.PhraseIterations = new List <Manifest.PhraseIteration>();
manifestFunctions.GeneratePhraseIterationsData(attr, xmlContent, platform.version);
attr.Phrases = new List <Manifest.Phrase>();
manifestFunctions.GeneratePhraseData(attr, xmlContent);
attr.Sections = new List <Manifest.Section>();
manifestFunctions.GenerateSectionData(attr, xmlContent);
attr.MaxPhraseDifficulty = manifestFunctions.GetMaxDifficulty(xmlContent);
var attributeDictionary = new Dictionary <string, Attributes2014> {
{ "Attributes", attr }
};
manifest.Entries.Add(attr.PersistentID, attributeDictionary);
manifest.SaveToFile(json);
}
}
}
}
/// <summary>
/// Showlights Generator Rev2
/// max difficulty with most notes and chords
/// </summary>
/// <param name="xmlFile">Xml file.</param>
public Showlights Generate(string xmlFile)
{
var midiNotes = new List <Showlight>();
var chordNotes = new List <Showlight>();
var song = Song2014.LoadFromFile(xmlFile);
// If vocals
if (song.Phrases == null || song.Tuning == null)
{
return(null);
}
//Generate ShowlightList
var tuning = song.Tuning.ToArray();
if (song.Levels != null)
{
var mf = new ManifestFunctions(GameVersion.RS2014);
int maxDif = mf.GetMaxDifficulty(song);
for (int i = 0; i < song.Levels[maxDif].Notes.Length; i++)
{
var mNote = Sng2014FileWriter.GetMidiNote(tuning, (Byte)song.Levels[maxDif].Notes[i].String, (Byte)song.Levels[maxDif].Notes[i].Fret, song.Arrangement == "Bass", song.Capo);
midiNotes.Add(new Showlight {
Time = song.Levels[maxDif].Notes[i].Time, Note = mNote
});
}
for (int i = 0; i < song.Levels[maxDif].Chords.Length; i++)
{
if (song.Levels[maxDif].Chords[i].HighDensity == 1)
{
continue; //speedhack
}
int mNote = Sng2014FileWriter.getChordNote(tuning, song.Levels[maxDif].Chords[i], song.ChordTemplates, song.Arrangement == "Bass", song.Capo);
chordNotes.Add(new Showlight {
Time = song.Levels[maxDif].Chords[i].Time, Note = mNote
});
}
}
PopShList(midiNotes);
PopShList(chordNotes);
return(this);
}
public void CreateShowlights(DLCPackageData info)
{
int maxNoteChordCount = 0;
int maxArrNdx = 0;
int maxLevelNdx = 0;
// find arrangment with most notes and chords
for (int i = 0; i < info.Arrangements.Count; i++)
{
if (info.Arrangements[i].ArrangementType == ArrangementType.Vocal)
{
continue;
}
if (info.Arrangements[i].ArrangementType == ArrangementType.ShowLight)
{
continue;
}
if (info.Arrangements[i].SongXml.File == null)
{
continue;
}
var song = Song2014.LoadFromFile(info.Arrangements[i].SongXml.File);
// find level with most notes and chords
for (int j = 0; j < song.Levels.Count(); j++)
{
int noteCount = song.Levels[j].Notes.Count();
int chordCount = song.Levels[j].Chords.Count();
int noteChordCount = noteCount + chordCount;
if (noteChordCount > maxNoteChordCount)
{
maxNoteChordCount = noteChordCount;
maxArrNdx = i;
maxLevelNdx = j;
}
}
}
Generate(info.Arrangements[maxArrNdx].SongXml.File, maxLevelNdx);
AdjustShowlights(ShowlightList, info.DefaultShowlights);
Count = ShowlightList.Count;
}
public static void GetSongDifficulty(AttributesHeader2014 attribute, Song2014 song)
{
var easyArray = new List <int>();
var mediumArray = new List <int>();
var hardArray = new List <int>();
for (int i = 0; i < song.PhraseIterations.Length; i++)
{
var pt = song.PhraseIterations[i];
var hard = song.Phrases[pt.PhraseId].MaxDifficulty;
if (pt.HeroLevels != null)
{
foreach (var h in pt.HeroLevels)
{
switch (h.Hero)
{
case 1:
easyArray.Add(h.Difficulty);
break;
case 2:
mediumArray.Add(h.Difficulty);
break;
case 3:
hard = h.Difficulty;
break;
}
hardArray.Add(hard);
}
}
}
// Is not the way of official are calculated, but is a way to calculate unique values for custom
// Could be rewritten with the correct way or a best way to get this value
var itCount = song.PhraseIterations.Length;
var ifAny = easyArray.Count > 0;
// TODO: round to 9 decimal places and improve calculation
attribute.SongDiffEasy = ifAny ? easyArray.Average() / itCount : 0;
attribute.SongDiffMed = ifAny ? mediumArray.Average() / itCount : 0;
attribute.SongDiffHard = ifAny ? hardArray.Average() / itCount : 0;
attribute.SongDifficulty = attribute.SongDiffHard;
}
