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); }