public IEnumerator playSongCoroutine(string cardTitle, float waitBetweenNotes, float speed)
{
songPlaying = true;
NoteChart noteChart = NoteCharts.getChartByTitle(cardTitle);
Debug.Log("Song Length: " + noteChart.Count());
playNoteSensor.RecordPercentage(noteChart.Count());
foreach (Note n in noteChart.noteChart)
{
GenerateNote(n, speed);
yield return(new WaitForSeconds(waitBetweenNotes));
}
while (songPlaying)
{
yield return(new WaitForSeconds(0.1f));
}
//Do card action
actionManager.doAction(cardTitle, percentHit);
//cardManager.gameObject.SetActive(true);
}
private static void DecodeChartFretbars(SongData song, QbFile qbchart, NoteChart chart)
{
QbItemInteger fretbars = (qbchart.FindItem(QbKey.Create(song.ID + "_fretbars"), false) as QbItemArray).Items[0] as QbItemInteger;
ulong ticks = 0;
uint previousfret = 0;
uint previousMsPerBeat = 0;
for (int k = 1; k < fretbars.Values.Length; k++)
{
uint fret = fretbars.Values[k];
uint msPerBeat = fret - previousfret;
if (msPerBeat != previousMsPerBeat)
{
chart.BPM.Add(new Midi.TempoEvent(ticks, msPerBeat * 1000));
}
previousfret = fret;
previousMsPerBeat = msPerBeat;
ticks += chart.Division.TicksPerBeat;
}
chart.Events.End = new NoteChart.Point(chart.GetTicks(fretbars.Values[fretbars.Values.Length - 1]));
QbItemArray timesig = (qbchart.FindItem(QbKey.Create(song.ID + "_timesig"), false) as QbItemArray).Items[0] as QbItemArray;
foreach (QbItemInteger sig in timesig.Items)
{
chart.Signature.Add(new Midi.TimeSignatureEvent(chart.GetTicks(sig.Values[0]), (byte)sig.Values[1], (byte)Math.Log(sig.Values[2], 2), 24, 8));
}
}
private void DecodeChartFretbars(SongData song, QbFile qbchart, Notes notes, NoteChart chart)
{
uint[] values = GetChartValues(notes, qbchart, Notes.KeyFretbars, QbKey.Create(song.ID + "_fretbars"));
ulong ticks = 0;
uint previousfret = 0;
uint previousMsPerBeat = 0;
for (int k = 1; k < values.Length; k++)
{
uint fret = values[k];
uint msPerBeat = fret - previousfret;
if (msPerBeat != previousMsPerBeat)
{
chart.BPM.Add(new Midi.TempoEvent(ticks, msPerBeat * 1000));
}
previousfret = fret;
previousMsPerBeat = msPerBeat;
ticks += chart.Division.TicksPerBeat;
}
chart.Events.End = new NoteChart.Point(chart.GetTicks(values[values.Length - 1]));
uint[][] jaggedvalues = GetJaggedChartValues(notes, qbchart, Notes.KeyTimesignature, QbKey.Create(song.ID + "_timesig"), 4, 1, 1);
foreach (uint[] sig in jaggedvalues)
{
chart.Signature.Add(new Midi.TimeSignatureEvent(chart.GetTicks(sig[0]), (byte)sig[1], (byte)Math.Log(sig[2], 2), 24, 8));
}
}
public static void CreateWeights(Stream weights, ChartFormat chartformat)
{
EndianReader writer = new EndianReader(weights, Endianness.LittleEndian);
NoteChart chart = chartformat.Chart;
//if (chart.PartVocals == null)
// return;
ulong duration = chart.GetTime(chart.FindLastNote());
for (ulong i = 0; i < 60 * duration / 1000000; i++)
{
//for (ulong i = 0; i < 0x100; i++)
//writer.Write((byte)0x00);
writer.Write((byte)0x90);
}
/* foreach (var lyric in chart.PartVocals.Lyrics) {
* if (!lyric.Value.EndsWith("#") && !lyric.Value.EndsWith("^"))
* continue;
*
* var gem = chart.PartVocals.Gems.FirstOrDefault(g => g.Time == lyric.Key.Time);
* if (gem == null)
* continue;
*
* ulong time = chart.GetTime(gem.Time);
* time = 60 * time / 1000000;
* for (ulong i = (ulong)writer.Position; i < time; i++)
* writer.Write((byte)0xFE);
* ulong duration = chart.GetTimeDuration(gem.Time, gem.Duration);
* for (ulong i = 0; i < duration; i += 1000000/60)
* writer.Write((byte)0x90);
* } */
}
public void ExpandDrumRoll(NoteChart chart, NoteChart.Difficulty difficulty, NoteChart.Note note, int gem)
{
if (note.Duration >= (ulong)chart.Division.TicksPerBeat)
{
ulong rolllen = 0;
switch (difficulty)
{
case NoteChart.Difficulty.Expert:
rolllen = (ulong)chart.Division.TicksPerBeat / 2; // 8th note rolls
break;
case NoteChart.Difficulty.Hard:
case NoteChart.Difficulty.Medium:
rolllen = (ulong)chart.Division.TicksPerBeat; // 4th note rolls
break;
case NoteChart.Difficulty.Easy:
rolllen = 0; // Single hit
break;
}
if (rolllen > 0)
{
for (ulong pos = rolllen; pos < note.Duration; pos += rolllen)
{
NoteChart.Note newnote = new NoteChart.Note(note.Time + pos, (ulong)chart.Division.TicksPerBeat / 8);
chart.PartDrums.Gems[difficulty][gem].Add(newnote);
}
}
}
note.Duration = (ulong)chart.Division.TicksPerBeat / 8;
}
public void StartTutorial(TutorialPage tutorialToStart)
{
tutorialImages = tutorialToStart.tutorialImages;
songAfterTutorial = tutorialToStart.tutorialChart;
UsePage();
CheckEnding();
}
public float TimeUntilNextNote(NoteChart currentSong, float currentSongTime)
{
float noteTime = NextNoteTimeOfThisString(currentSong, currentSongTime).noteTime; // 1
float distanceSeconds = noteTime - currentSongTime; //0.5
return(distanceSeconds);
}
public NoteChart CreateNoteChart()
{
NoteChart nc = new NoteChart();
nc.SimFile = this;
// Here you can add the note chart to the SimFile dictionary
return(nc);
}
private static void DecodeChartVenue(SongData song, QbFile qbchart, NoteChart chart)
{
QbItemArray cameraitems = qbchart.FindItem(QbKey.Create(song.ID + "_cameras_notes"), false) as QbItemArray;
if (cameraitems != null && cameraitems.Items.Count > 0)
{
cameraitems = cameraitems.Items[0] as QbItemArray;
}
if (cameraitems != null)
{
Random random = new Random();
foreach (QbItemInteger camera in cameraitems.Items)
{
uint time = camera.Values[0];
NoteChart.Point point = new NoteChart.Point(chart.GetTicks(camera.Values[0]));
if (random.Next() % 9 == 0)
{
chart.Venue.DirectedShots.Add(new Pair <NoteChart.Point, NoteChart.VenueTrack.DirectedCut>(point, NoteChart.VenueTrack.DirectedCut.None));
}
else
{
chart.Venue.CameraShots.Add(new Pair <NoteChart.Point, NoteChart.VenueTrack.CameraShot>(point, new NoteChart.VenueTrack.CameraShot()));
}
}
}
QbItemArray crowditems = qbchart.FindItem(QbKey.Create(song.ID + "_crowd_notes"), false) as QbItemArray;
if (crowditems != null && crowditems.Items.Count > 0)
{
crowditems = crowditems.Items[0] as QbItemArray;
}
if (crowditems != null)
{
foreach (QbItemInteger crowd in crowditems.Items)
{
NoteChart.Point point = new NoteChart.Point(chart.GetTicks(crowd.Values[0]));
chart.Events.Crowd.Add(new Pair <NoteChart.Point, NoteChart.EventsTrack.CrowdType>(point, NoteChart.EventsTrack.CrowdType.None));
}
}
QbItemArray lightitems = qbchart.FindItem(QbKey.Create(song.ID + "_lightshow_notes"), false) as QbItemArray;
if (lightitems != null && lightitems.Items.Count > 0)
{
lightitems = lightitems.Items[0] as QbItemArray;
}
if (lightitems != null)
{
foreach (QbItemInteger light in lightitems.Items)
{
NoteChart.Point point = new NoteChart.Point(chart.GetTicks(light.Values[0]));
chart.Venue.Lighting.Add(new Pair <NoteChart.Point, NoteChart.VenueTrack.LightingType>(point, NoteChart.VenueTrack.LightingType.None));
}
}
}
public static void DecodeLeftHandAnimations(NoteChart chart, Midi midi)
{
Midi.Track track = midi.GetTrack("ANIM");
foreach (var note in track.Notes)
{
if (note.Note < 60 && note.Note >= 40)
{
chart.PartGuitar.FretPosition.Add(new Pair <NoteChart.Note, byte>(new NoteChart.Note(note), (byte)(note.Note - 40)));
}
}
}
public static void DecodeOverdrive(NoteChart chart)
{
if (chart.PartGuitar != null)
{
chart.PartGuitar.Overdrive.AddRange(chart.PartGuitar.SoloSections);
chart.PartGuitar.SoloSections.Clear();
}
if (chart.PartBass != null)
{
chart.PartBass.Overdrive.AddRange(chart.PartBass.SoloSections);
chart.PartBass.SoloSections.Clear();
}
}
public static NoteChart AdjustChart(SongData song, AudioFormat audioformat, ChartFormat chartformat)
{
NoteChart chart = chartformat.Chart;
if (song.Difficulty[Instrument.Guitar] == 0)
{
chart.PartGuitar = null;
}
if (song.Difficulty[Instrument.Bass] == 0)
{
chart.PartBass = null;
}
if (song.Difficulty[Instrument.Drums] == 0)
{
chart.PartDrums = null;
}
if (song.Difficulty[Instrument.Vocals] == 0)
{
chart.PartVocals = null;
}
if (chart.PartDrums != null)
{
int drumcount = audioformat.Mappings.Count(m => m.Instrument == Instrument.Drums);
foreach (var mix in chart.PartDrums.Mixing)
{
if (drumcount == 2 && mix.Value.Value != "drums0" && mix.Value.Value != "drums0d")
{
mix.Value.Value = "drums0";
}
// TODO: Better validation
}
}
if (chart.PartVocals != null)
{
foreach (var lyric in chart.PartVocals.Lyrics)
{
if (lyric.Value.EndsWith("*"))
{
lyric.Value = lyric.Value.Substring(0, lyric.Value.Length - 1) + "^";
}
}
}
return(chart);
}
void playCard(int selectedIndex)
{
GameObject selectedCard = null;
Debug.Log("Playing index" + selectedIndex);
if (selectedIndex == 0)
{
selectedCard = warriorCardInHand;
DrawWarriorCard();
}
else if (selectedIndex == 1)
{
selectedCard = mageCardInHand;
DrawMageCard();
}
else if (selectedIndex == 2)
{
selectedCard = healerCardInHand;
DrawHealerCard();
}
Destroy(selectedCard);
UpdateHandPositions();
CardInfo info = selectedCard.GetComponent <CardInfo>();
NoteChart noteChart = NoteCharts.getChartByTitle(info.cardTitle);
if (info.characterClass == CharacterClass.Warrior)
{
Debug.Log("Picking warrior sounds");
playNoteSensor.currentSound = playNoteSensor.guitarNote;
}
else if (info.characterClass == CharacterClass.Mage)
{
Debug.Log("Picking mage sounds");
playNoteSensor.currentSound = playNoteSensor.bassNote;
}
else if (info.characterClass == CharacterClass.Healer)
{
Debug.Log("Picking healer sounds");
playNoteSensor.currentSound = playNoteSensor.fluteNote;
}
noteGenerator.playSong(info.cardTitle, 0.25f, 1000.0f);
gameObject.SetActive(false);
}
public static void CreatePan(Stream pan, ChartFormat chartformat)
{
EndianReader writer = new EndianReader(pan, Endianness.LittleEndian);
NoteChart chart = chartformat.Chart;
//if (chart.PartVocals == null)
// return;
ulong duration = chart.GetTime(chart.FindLastNote());
for (ulong i = 0; i < 8 * 60 * duration / 1000000; i++)
{
//for (ulong i = 0; i < 0x100; i++)
//writer.Write((byte)0x00);
writer.Write((byte)0xFF);
}
}
public static void FillSections(NoteChart chart, int length, int gap, int start, List <NoteChart.Note> notes, List <NoteChart.Note> overlap)
{
Midi.TimeSignatureEvent previous = new Midi.TimeSignatureEvent(0, 4, 0, 0, 0);
Midi.TimeSignatureEvent next;
int index = -1;
ulong time = chart.FindLastNote();
long t2;
while (time > 0)
{
try {
next = chart.Signature[++index];
} catch (ArgumentOutOfRangeException) {
next = new Midi.TimeSignatureEvent(ulong.MaxValue, 4, 0, 0, 0);
}
long measuresize = chart.Division.TicksPerBeat * (long)previous.Numerator;
t2 = (long)Math.Min(next.Time - previous.Time, time);
for (long t1 = measuresize * start; t2 - t1 >= measuresize * length; t1 += measuresize * gap)
{
bool collide = false;
NoteChart.Note note = new NoteChart.Note(previous.Time + (ulong)t1, (ulong)measuresize * (ulong)length);
if (overlap != null)
{
foreach (NoteChart.Note n in overlap)
{
if (note.IsUnderNote(n, true))
{
collide = true;
break;
}
}
}
if (!collide)
{
notes.Add(note);
}
}
time -= (ulong)t2;
previous = next;
}
}
private static void DecodeChartDrums(SongData song, QbFile qbchart, NoteChart chart)
{
QbItemArray drumsitems = qbchart.FindItem(QbKey.Create(song.ID + "_drums_notes"), false) as QbItemArray;
if (drumsitems != null)
{
drumsitems = drumsitems.Items[0] as QbItemArray;
}
if (drumsitems != null)
{
chart.PartDrums = new NoteChart.Drums(chart);
Dictionary <uint, int> drumnotes = new Dictionary <uint, int>() // Garbage: 65, 70, 48, 64
{
{ 60, 0 },
{ 40, 1 }, { 64, 1 },
{ 55, 2 }, { 67, 2 }, { 53, 2 },
{ 39, 3 }, { 38, 3 }, { 63, 3 }, { 62, 3 },
{ 68, 4 }, { 56, 4 }, { 66, 4 }, { 54, 4 }, { 69, 4 }, { 57, 4 }, { 37, 4 }, { 61, 4 },
};
Dictionary <uint, NoteChart.Drums.Animation> drumanimnotes = new Dictionary <uint, NoteChart.Drums.Animation>()
{
};
foreach (QbItemInteger drums in drumsitems.Items)
{
NoteChart.Note note = new NoteChart.Note(chart.GetTicks(drums.Values[0]), (ulong)chart.Division.TicksPerBeat / 8);
uint notenum = drums.Values[1];
if (drumnotes.ContainsKey(notenum))
{
int notevalue = drumnotes[notenum];
chart.PartDrums.Gems[NoteChart.Difficulty.Expert][notevalue].Add(note);
}
if (drumanimnotes.ContainsKey(notenum))
{
chart.PartDrums.Animations.Add(new Pair <NoteChart.Note, NoteChart.Drums.Animation>(note, drumanimnotes[notenum]));
}
}
}
ChartFormatGH5.FillSections(chart, 1, 8, 1, chart.PartDrums.Overdrive, null);
ChartFormatGH5.FillSections(chart, 1, 4, 3, chart.PartDrums.DrumFills, null);
}
public static NoteChart ProvokeSong()
{
NoteChart chart = new NoteChart();
chart.Add(Note.Green | Note.Yellow);
chart.Add(Note.Green | Note.Yellow);
chart.Add(Note.None);
chart.Add(Note.None);
chart.Add(Note.Red | Note.Blue);
chart.Add(Note.Red | Note.Blue);
chart.Add(Note.None);
chart.Add(Note.None);
chart.Add(Note.Red);
chart.Add(Note.Red);
chart.Add(Note.Yellow);
chart.Add(Note.Yellow);
chart.Add(Note.Red | Note.Yellow);
return(chart);
}
public static NoteChart HealSong()
{
NoteChart chart = new NoteChart();
chart.Add(Note.Green | Note.Red);
chart.Add(Note.Red | Note.Yellow);
chart.Add(Note.None);
chart.Add(Note.Blue | Note.Orange);
chart.Add(Note.Blue);
chart.Add(Note.Blue | Note.Orange);
chart.Add(Note.None);
chart.Add(Note.Blue | Note.Orange);
chart.Add(Note.Blue);
chart.Add(Note.Blue | Note.Orange);
chart.Add(Note.None);
chart.Add(Note.Blue);
chart.Add(Note.Blue | Note.Orange);
chart.Add(Note.Blue | Note.Orange | Note.Yellow);
return(chart);
}
public override ChartFormat DecodeChart(FormatData data, ProgressIndicator progress)
{
if (!data.HasStream(this, ChartFile))
{
throw new FormatException();
}
Stream stream = data.GetStream(this, ChartFile);
Midi midi = Midi.Create(Mid.Create(stream));
data.CloseStream(stream);
ChartFormat chart = new ChartFormat(NoteChart.Create(midi));
DecodeLeftHandAnimations(chart.Chart, midi);
ChartFormatGH2.DecodeDrums(chart.Chart, midi, true);
ChartFormatGH2.DecodeOverdrive(chart.Chart);
ImportMap.ImportChart(data.Song, chart.Chart);
return(chart);
}
public static NoteChart LightningSong()
{
NoteChart chart = new NoteChart();
chart.Add(Note.Orange);
chart.Add(Note.Yellow);
chart.Add(Note.Green);
chart.Add(Note.Orange);
chart.Add(Note.Yellow);
chart.Add(Note.Green);
chart.Add(Note.Orange);
chart.Add(Note.Yellow);
chart.Add(Note.Green);
chart.Add(Note.None);
chart.Add(Note.None);
chart.Add(Note.None);
chart.Add(Note.Orange | Note.Yellow | Note.Green);
chart.Add(Note.Orange);
chart.Add(Note.Orange | Note.Yellow | Note.Green);
return(chart);
}
public static NoteChart HealingBalladSong()
{
NoteChart chart = new NoteChart();
chart.Add(Note.Green | Note.Blue);
chart.Add(Note.Green | Note.Blue);
chart.Add(Note.Green | Note.Blue);
chart.Add(Note.None);
chart.Add(Note.Green);
chart.Add(Note.Green);
chart.Add(Note.Green);
chart.Add(Note.None);
chart.Add(Note.Red);
chart.Add(Note.Red);
chart.Add(Note.Red);
chart.Add(Note.Red);
chart.Add(Note.Green);
chart.Add(Note.Blue);
chart.Add(Note.Green);
return(chart);
}
public static NoteChart GustSong()
{
NoteChart chart = new NoteChart();
chart.Add(Note.Green | Note.Red);
chart.Add(Note.Green | Note.Red);
chart.Add(Note.None);
chart.Add(Note.Green | Note.Yellow);
chart.Add(Note.Green | Note.Yellow);
chart.Add(Note.None);
chart.Add(Note.None);
chart.Add(Note.Red);
chart.Add(Note.Red);
chart.Add(Note.Green);
chart.Add(Note.Green);
chart.Add(Note.Green);
chart.Add(Note.Red);
chart.Add(Note.Green | Note.Yellow);
return(chart);
}
public override ChartFormat DecodeChart(FormatData data, ProgressIndicator progress)
{
if (!data.HasStream(this, ChartFile))
{
throw new FormatException();
}
Stream stream = data.GetStream(this, ChartFile);
Midi midi = Midi.Create(Mid.Create(stream));
data.CloseStream(stream);
DecodeCoop(midi, data.Song.Data.GetValue <bool>("GH2ChartCoop"));
ChartFormat chart = new ChartFormat(NoteChart.Create(midi));
DecodeDrums(chart.Chart, midi, false);
DecodeOverdrive(chart.Chart);
ImportMap.ImportChart(data.Song, chart.Chart);
return(chart);
}
public NoteChart GetChart(bool coop = false)
{
Midi eventsmidi = new Midi();
eventsmidi.BPM = NoteChart.BPM;
eventsmidi.Signature = NoteChart.Signature;
eventsmidi.Division = NoteChart.Division;
eventsmidi.Tracks.Add(EventsTrack);
if (Song.ContainsKey("Name"))
{
eventsmidi.Name = Song["Name"];
}
NoteChart chart = NoteChart.Create(eventsmidi);
if (coop)
{
if (Tracks.ContainsKey(BaseTrackType.DoubleGuitar))
{
chart.PartGuitar = Tracks[BaseTrackType.DoubleGuitar] as NoteChart.Guitar;
}
if (Tracks.ContainsKey(BaseTrackType.DoubleBass))
{
chart.PartBass = Tracks[BaseTrackType.DoubleBass] as NoteChart.Bass;
}
}
else
{
if (Tracks.ContainsKey(BaseTrackType.Single))
{
chart.PartGuitar = Tracks[BaseTrackType.Single] as NoteChart.Guitar;
}
//if (Tracks.ContainsKey(BaseTrackType.SingleBass))
// chart.PartBass = Tracks[BaseTrackType.SingleBass] as NoteChart.Bass;
}
return(chart);
}
public override bool AddSong(PlatformData data, SongData song, ProgressIndicator progress)
{
FormatData formatdata = new TemporaryFormatData(song, data);
DirectoryNode dir = data.Session["songdir"] as DirectoryNode;
int delay = 0;
bool eighthhopo = false;
int hopofreq = -1;
AudioFormat format = new AudioFormat();
FileNode songini = dir.Navigate("song.ini", false, true) as FileNode;
if (songini != null)
{
Ini ini = Ini.Create(songini.Data);
songini.Data.Close();
string value = ini.GetValue("song", "name"); if (value != null)
{
song.Name = value;
}
value = ini.GetValue("song", "artist"); if (value != null)
{
song.Artist = value;
}
value = ini.GetValue("song", "album"); if (value != null)
{
song.Album = value;
}
value = ini.GetValue("song", "genre"); if (value != null)
{
song.Genre = value;
}
value = ini.GetValue("song", "year"); if (value != null)
{
song.Year = int.Parse(value);
}
value = ini.GetValue("song", "version"); if (value != null)
{
song.Version = int.Parse(value);
}
value = ini.GetValue("song", "delay"); if (value != null)
{
delay = int.Parse(value);
}
value = ini.GetValue("song", "eighthnote_hopo"); if (value != null)
{
eighthhopo = string.Compare(value, "true", true) == 0 ? true : false;
}
value = ini.GetValue("song", "hopofreq"); if (value != null)
{
hopofreq = int.Parse(value);
}
value = ini.GetValue("song", "tags"); if (value != null)
{
song.Master = string.Compare(value, "cover", true) == 0 ? false : true;
}
value = ini.GetValue("song", "icon"); if (value != null)
{
song.Game = GetGameFromIcon(value);
}
value = ini.GetValue("song", "diff_band"); if (value != null)
{
song.Difficulty[Instrument.Ambient] = ImportMap.GetBaseRank(Instrument.Ambient, int.Parse(value));
}
value = ini.GetValue("song", "diff_bass"); if (value != null)
{
song.Difficulty[Instrument.Bass] = ImportMap.GetBaseRank(Instrument.Bass, int.Parse(value));
}
value = ini.GetValue("song", "diff_drums"); if (value != null)
{
song.Difficulty[Instrument.Drums] = ImportMap.GetBaseRank(Instrument.Drums, int.Parse(value));
}
value = ini.GetValue("song", "diff_guitar"); if (value != null)
{
song.Difficulty[Instrument.Guitar] = ImportMap.GetBaseRank(Instrument.Guitar, int.Parse(value));
}
}
format.InitialOffset = -delay;
FileNode album = dir.Navigate("album.png", false, true) as FileNode;
if (album != null)
{
song.AlbumArt = new Bitmap(album.Data);
}
FileNode chartfile = dir.Navigate("notes.mid", false, true) as FileNode;
NoteChart chart = null;
if (chartfile != null)
{
ChartFormatRB.Instance.Create(formatdata, chartfile.Data, null, 0, null, null, 0, false, true);
chart = NoteChart.Create(Midi.Create(Mid.Create(chartfile.Data)));
chartfile.Data.Close();
}
if (chart != null && eighthhopo)
{
song.HopoThreshold = chart.Division.TicksPerBeat / 2 + 10;
}
else if (hopofreq >= 0)
{
// TODO: This
}
List <Stream> streams = new List <Stream>();
foreach (Node node in dir)
{
FileNode file = node as FileNode;
if (file == null)
{
continue;
}
string extension = Path.GetExtension(file.Name).ToLower();
if (extension != ".ogg")
{
continue;
}
string name = Path.GetFileNameWithoutExtension(file.Name);
Instrument instrument = Platform.InstrumentFromString(name);
RawkAudio.Decoder decoder = new RawkAudio.Decoder(file.Data, RawkAudio.Decoder.AudioFormat.VorbisOgg);
for (int i = 0; i < decoder.Channels; i++)
{
format.Mappings.Add(new AudioFormat.Mapping(0, 0, instrument));
}
decoder.Dispose();
file.Data.Close();
streams.Add(file.Data);
}
format.AutoBalance();
if (streams.Count > 0)
{
AudioFormatOgg.Instance.Create(formatdata, streams.ToArray(), format);
}
else if (chartfile == null)
{
return(false);
}
data.AddSong(formatdata);
return(true);
}
public override ChartFormat DecodeChart(FormatData data, ProgressIndicator progress)
{
if (!data.HasStream(this, ChartName) || !data.HasStream(this, SectionsName))
{
throw new FormatException();
}
progress.NewTask(6 + 8);
Stream chartstream = data.GetStream(this, ChartName);
Stream sectionstream = data.GetStream(this, SectionsName);
PakFormat format = NeversoftMetadata.GetSongItemType(data.Song);
SongData song = NeversoftMetadata.GetSongData(data.PlatformData, NeversoftMetadata.GetSongItem(data));
Pak chartpak = new Pak(new EndianReader(chartstream, Endianness.BigEndian)); // TODO: Endianness based on format?
FileNode chartfile = chartpak.Root.Find(song.ID + ".mid.qb.ngc", SearchOption.AllDirectories, true) as FileNode;
QbFile qbsections = new QbFile(sectionstream, format);
QbFile qbchart = new QbFile(chartfile.Data, format);
NoteChart chart = new NoteChart();
chart.PartGuitar = new NoteChart.Guitar(chart);
chart.PartBass = new NoteChart.Bass(chart);
chart.Events = new NoteChart.EventsTrack(chart);
chart.Venue = new NoteChart.VenueTrack(chart);
chart.Beat = new NoteChart.BeatTrack(chart);
progress.Progress();
DecodeChartFretbars(song, qbchart, chart);
progress.Progress();
DecodeChartMarkers(song, qbsections, qbchart, chart);
progress.Progress();
for (NoteChart.TrackType track = NoteChart.TrackType.Guitar; track <= NoteChart.TrackType.Bass; track++)
{
for (NoteChart.Difficulty difficulty = NoteChart.Difficulty.Easy; difficulty <= NoteChart.Difficulty.Expert; difficulty++)
{
DecodeChartNotes(data, song, qbchart, chart, track, difficulty, data.Song.Data.GetValue <bool>("GH3ChartCoop"));
progress.Progress();
}
}
progress.Progress();
DecodeChartDrums(song, qbchart, chart);
progress.Progress();
DecodeChartVenue(song, qbchart, chart);
ImportMap.ImportChart(data.Song, chart);
progress.Progress();
data.CloseStream(chartstream);
data.CloseStream(sectionstream);
progress.EndTask();
return(new ChartFormat(chart));
}
public static void DecodeDrums(NoteChart chart, Midi midi, bool gh1)
{
chart.PartDrums = new NoteChart.Drums(chart);
Midi.Track track;
if (gh1)
{
track = midi.GetTrack("TRIGGERS");
}
else
{
track = midi.GetTrack("BAND DRUMS");
}
foreach (Midi.NoteEvent note in track.Notes)
{
switch (note.Note)
{
case 60:
case 36: // Kick
chart.PartDrums.Gems[NoteChart.Difficulty.Expert][0].Add(new NoteChart.Note(note));
break;
case 61:
case 37: // Crash
chart.PartDrums.Gems[NoteChart.Difficulty.Expert][4].Add(new NoteChart.Note(note));
break;
case 0x30:
case 0x31:
case 0x40:
case 0x41:
break;
}
}
if (gh1)
{
track = midi.GetTrack("EVENTS");
}
Midi.TextEvent previouscomment = new Midi.TextEvent(0, "[nobeat]");
string previoustext = "nobeat";
foreach (var comment in track.Comments)
{
NoteChart.Point note = new NoteChart.Point(comment.Time);
string text = comment.Text.Trim('[', ']', ' ');
if (gh1)
{
if (text.StartsWith("drum_"))
{
text = text.Substring(5);
}
else
{
continue;
}
}
switch (text)
{
case "idle":
case "off":
case "noplay":
chart.PartDrums.CharacterMoods.Add(new Pair <NoteChart.Point, NoteChart.CharacterMood>(note, NoteChart.CharacterMood.Idle));
break;
case "play":
case "normal":
case "on":
chart.PartDrums.CharacterMoods.Add(new Pair <NoteChart.Point, NoteChart.CharacterMood>(note, NoteChart.CharacterMood.Play));
previouscomment = comment;
break;
default:
ulong duration = comment.Time - previouscomment.Time;
ulong time = previouscomment.Time;
float fraction = 0;
switch (previoustext)
{
case "on":
case "allplay":
case "play":
case "allbeat":
case "allbreat":
case "all_beat":
case "normal":
case "norm":
case "nomral":
case "normal_tempo":
fraction = 1;
break;
case "off":
case "noplay":
case "nobeat":
case "no_beat":
fraction = 0;
break;
case "double":
case "double_time":
case "doubletime":
case "double_tempo":
case "doulbe_time":
fraction = 0.5f;
break;
case "half":
case "half_time":
case "halftime":
case "half_tempo":
fraction = 2;
break;
}
if (fraction > 0)
{
while (time < comment.Time)
{
chart.PartDrums.Gems[NoteChart.Difficulty.Expert][(previoustext == "play" || previoustext == "normal") ? 2 : 1].Add(new NoteChart.Note(time));
time += (ulong)(midi.Division.TicksPerBeat * fraction);
}
}
previouscomment = comment;
previoustext = text;
break;
}
}
ChartFormatGH5.FillSections(chart, 1, 8, 1, chart.PartDrums.Overdrive, null);
ChartFormatGH5.FillSections(chart, 1, 4, 3, chart.PartDrums.DrumFills, null);
}
public override ChartFormat DecodeChart(FormatData data, ProgressIndicator progress)
{
IList <Stream> streams = GetChartStreams(data);
float bpm = 0;
NoteChart chart = new NoteChart();
chart.BPM.Add(new Midi.TempoEvent(0, (uint)(Mid.MicrosecondsPerMinute / bpm)));
chart.Signature.Add(new Midi.TimeSignatureEvent(0, 4, 2, 24, 8));
Mub mub = null; // TODO: Determine charts by filenames or some shit
chart.PartGuitar = new NoteChart.Guitar(chart);
NoteChart.Instrument instrument = chart.PartGuitar;
NoteChart.IGems gems = instrument as NoteChart.IGems;
NoteChart.IForcedHopo hopo = instrument as NoteChart.IForcedHopo;
NoteChart.Difficulty difficulty = NoteChart.Difficulty.Expert;
int fadeposition = 0;
foreach (Mub.Node node in mub.Nodes)
{
ulong time = (ulong)(node.Time * chart.Division.TicksPerBeat / 4);
ulong duration = (ulong)(node.Duration * chart.Division.TicksPerBeat / 4);
NoteChart.Note fullnote = new NoteChart.Note(time, duration);
NoteChart.Note note = new NoteChart.Note(time, chart.Division.TicksPerBeat / 4U);
NoteChart.Note prevnote = new NoteChart.Note(time - chart.Division.TicksPerBeat / 2U, chart.Division.TicksPerBeat / 4U);
int greennote = fadeposition < 0 ? 0 : 1;
int bluenote = fadeposition > 0 ? 4 : 3;
switch (node.Type)
{
case 0x00: // Green dot
gems.Gems[difficulty][greennote].Add(note);
hopo.ForceHammeron[difficulty].Add(note);
break;
case 0x01: // Blue dot
gems.Gems[difficulty][bluenote].Add(note);
hopo.ForceHammeron[difficulty].Add(note);
break;
case 0x02: // Red dot
gems.Gems[difficulty][2].Add(note);
hopo.ForceHammeron[difficulty].Add(note);
break;
case 0x09: // Blue Crossfade right
fadeposition = 1;
gems.Gems[difficulty][4].Add(note);
gems.Gems[difficulty][fadeposition < 0 ? 0 : 3].Add(prevnote);
hopo.ForceHammeron[difficulty].Add(note);
break;
case 0x0A: // Green Crossfade left (revert to rightish normal)
fadeposition = 0;
break;
case 0x0B: // Green Crossfade left
fadeposition = -1;
gems.Gems[difficulty][0].Add(note);
gems.Gems[difficulty][fadeposition > 0 ? 4 : 1].Add(prevnote);
hopo.ForceHammeron[difficulty].Add(note);
break;
case 0x0C: // Weird whammy thing on left green
gems.Gems[difficulty][greennote].Add(fullnote);
hopo.ForceHammeron[difficulty].Add(note);
break;
case 0x0D: // ?? Not sure, Weird whammy thing on right blue maybe
gems.Gems[difficulty][bluenote].Add(fullnote);
hopo.ForceHammeron[difficulty].Add(note);
break;
default:
break;
}
}
return(new ChartFormat(chart));
}
public ChartFormat(NoteChart chart)
{
Chart = chart;
}
public static ChartFormat Create(Midi midi)
{
ChartFormat format = new ChartFormat(NoteChart.Create(midi));
return(format);
}
