public static int[] GetKnownData1ForDifficulty(bool isPro, GuitarDifficulty diff)
        {
            List <int> ret = new List <int>();

            for (int x = 0; x < 128; x++)
            {
                var d = x.GetData1Difficulty(isPro);
                if (d.IsAll() && diff.IsAll())
                {
                    ret.Add(x);
                }
                else if (d.IsExpert() && diff.IsExpert())
                {
                    ret.Add(x);
                }
                else if (d.IsHard() && diff.IsHard())
                {
                    ret.Add(x);
                }
                else if (d.IsMedium() && diff.IsMedium())
                {
                    ret.Add(x);
                }
                else if (d.IsEasy() && diff.IsEasy())
                {
                    ret.Add(x);
                }
            }
            return(ret.ToArray());
        }
Beispiel #2
0
        public static IEnumerable <int> GetData1ForChordModifierType(this ChordModifierType type,
                                                                     GuitarDifficulty difficulty, bool isPro)
        {
            var ret = new List <int>();

            if (difficulty.IsAll())
            {
                difficulty = GuitarDifficulty.Expert;
            }

            switch (type)
            {
            case ChordModifierType.Hammeron:
            {
                var d1 = Utility.GetHammeronData1(difficulty);

                if (!d1.IsNull())
                {
                    ret.Add(d1);
                }
            }
            break;

            case ChordModifierType.Slide:
            case ChordModifierType.SlideReverse:
            {
                var d1 = Utility.GetSlideData1(difficulty);
                if (!d1.IsNull())
                {
                    ret.Add(d1);
                }
            }
            break;

            case ChordModifierType.ChordStrumLow:
            case ChordModifierType.ChordStrumMed:
            case ChordModifierType.ChordStrumHigh:
            {
                var d1 = Utility.GetStrumData1(difficulty);
                if (!d1.IsNull())
                {
                    ret.Add(d1);
                }
            }
            break;
            }
            return(ret);
        }
        public static IEnumerable<int> GetData1ForChordModifierType(this ChordModifierType type,
            GuitarDifficulty difficulty, bool isPro)
        {
            var ret = new List<int>();
            if (difficulty.IsAll())
                difficulty = GuitarDifficulty.Expert;

            switch (type)
            {
                case ChordModifierType.Hammeron:
                    {
                        var d1 = Utility.GetHammeronData1(difficulty);

                        if (!d1.IsNull())
                        {
                            ret.Add(d1);
                        }
                    }
                    break;
                case ChordModifierType.Slide:
                case ChordModifierType.SlideReverse:
                    {
                        var d1 = Utility.GetSlideData1(difficulty);
                        if (!d1.IsNull())
                        {
                            ret.Add(d1);
                        }
                    }
                    break;
                case ChordModifierType.ChordStrumLow:
                case ChordModifierType.ChordStrumMed:
                case ChordModifierType.ChordStrumHigh:
                    {
                        var d1 = Utility.GetStrumData1(difficulty);
                        if (!d1.IsNull())
                        {
                            ret.Add(d1);
                        }
                    }
                    break;
            }
            return ret;
        }
 public static int GetSoloData1_G5(GuitarDifficulty difficulty)
 {
     if (difficulty.IsUnknown() || difficulty.IsAll() || difficulty.IsExpert())
     {
         return(ExpertSoloData1_G5);
     }
     if (difficulty.IsHard())
     {
         return(HardSoloData1_G5);
     }
     else if (difficulty.IsMedium())
     {
         return(MediumSoloData1_G5);
     }
     else if (difficulty.IsEasy())
     {
         return(EasySoloData1_G5);
     }
     return(ExpertSoloData1_G5);
 }
Beispiel #5
0
        public void GetMessages(GuitarDifficulty difficulty, bool includeDifficultyAll = true)
        {
            if (difficulty.IsAll())
            {
                difficulty = difficulty ^ GuitarDifficulty.All;
            }

            var validData1List = Utility.GetKnownData1ForDifficulty(IsPro,
                                                                    includeDifficultyAll ? GuitarDifficulty.All | difficulty : difficulty).ToList();

            Messages = new GuitarMessageList(owner);
            var events = checkForInvalidNotes(Messages, midiTrack, validData1List);

            var ret        = Messages;
            var tempoTrack = GetTempoTrack();

            ret.AddRange(GetTempoMessages(ret, tempoTrack));
            ret.AddRange(GetTimeSigMessages(ret, tempoTrack));
            try
            {
                if (IsPro)
                {
                    events.GetEventPairs(Utility.AllArpeggioData1)
                    .Select(x => new GuitarArpeggio(x)).ToList().ForEach(x => x.AddToList());

                    events.GetEventPairs(Utility.SoloData1.MakeEnumerable()).Select(x => new GuitarSolo(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.PowerupData1.MakeEnumerable()).Select(x => new GuitarPowerup(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.MultiStringTremeloData1.MakeEnumerable()).Select(x => new GuitarMultiStringTremelo(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.SingleStringTremeloData1.MakeEnumerable()).Select(x => new GuitarSingleStringTremelo(x)).ToList().ForEach(x => x.AddToList());

                    GetBigRockEnding(ret, events);

                    events.GetEventPairs(Utility.AllSlideData1).Select(x => new GuitarSlide(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.AllHammeronData1).Select(x => new GuitarHammeron(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.AllStrumData1).Select(x => new GuitarChordStrum(x)).ToList().ForEach(x => x.AddToList());

                    events.GetEventPairs(Utility.ChordNameEvents).ToList().
                    Select(x => new GuitarChordName(x)).ToList().ForEach(x => x.AddToList());

                    var notes = events.GetEventPairs(Utility.GetStringsForDifficulty6(difficulty)).Select(x => new GuitarNote(x)).ToList();
                    notes.ForEach(x => x.AddToList());
                    if (notes.Any())
                    {
                        var closeNotes = notes.GroupBy(x => x.DownTick).ToList();
                        var chordNotes = closeNotes.Select(n => GuitarChord.GetChord(ret, difficulty, n, true)).ToList().Where(x => x != null).ToList();
                        chordNotes.ForEach(x => x.AddToList());
                    }

                    var textEvents = midiTrack.Meta.Where(x => x.IsTextEvent()).Select(x => new GuitarTextEvent(ret, x)).ToList();
                    textEvents.ForEach(x => x.AddToList());

                    LoadTrainers(ret, ret.TextEvents).ToList().ForEach(x => x.AddToList());

                    events.GetEventPairs(Utility.HandPositionData1.MakeEnumerable()).ToList().Select(x => new GuitarHandPosition(x)).ToList().ForEach(x => x.AddToList());
                }
                else
                {
                    events.GetEventPairs(new[] { Utility.ExpertSoloData1_G5, Utility.SoloData1 }).ToList().Select(x => new GuitarSolo(x)).ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.PowerupData1.MakeEnumerable()).Select(x => new GuitarPowerup(x)).ForEach(x => x.AddToList());

                    var notes = events.GetEventPairs(Utility.GetStringsForDifficulty5(difficulty)).Select(x => new GuitarNote(x)).ToList();
                    notes.ForEach(x => x.AddToList());

                    if (notes.Any())
                    {
                        var chans  = notes.GroupBy(x => x.Channel);
                        var chords = new List <GuitarChord>();
                        foreach (var channelNotes in chans.Where(x => x.Key == 0))
                        {
                            var closeNotes = channelNotes.GroupByCloseTick().ToList();

                            chords.AddRange(closeNotes.Select(x => GuitarChord.GetChord(ret, difficulty, x, false)).Where(x => x != null).ToList());
                        }
                        foreach (var channelNotes in chans.Where(x => x.Key != 0))
                        {
                            var closeNotes = channelNotes.GroupByCloseTick().ToList();
                            var chords1    = closeNotes.Select(x => GuitarChord.GetChord(ret, difficulty, x, false)).Where(x => x != null).ToList();
                            foreach (var chord in chords1)
                            {
                                if (!chords.AnyBetweenTick(chord.TickPair))
                                {
                                    chords.Add(chord);
                                }
                            }
                        }
                        chords.OrderBy(x => x.DownTick).ToList().ForEach(x => x.AddToList());
                    }

                    var textEvents = midiTrack.Meta.Where(x => x.IsTextEvent()).ToList().Select(x => new GuitarTextEvent(ret, x)).ToList();
                    textEvents.ForEach(x => x.AddToList());

                    GetBigRockEnding(ret, events);
                }
            }
            catch { }
        }
 public static int GetSoloData1_G5(GuitarDifficulty difficulty)
 {
     if (difficulty.IsUnknown() || difficulty.IsAll() || difficulty.IsExpert())
         return ExpertSoloData1_G5;
     if (difficulty.IsHard())
         return HardSoloData1_G5;
     else if (difficulty.IsMedium())
         return MediumSoloData1_G5;
     else if (difficulty.IsEasy())
         return EasySoloData1_G5;
     return ExpertSoloData1_G5;
 }
 public static int[] GetKnownData1ForDifficulty(bool isPro, GuitarDifficulty diff)
 {
     List<int> ret = new List<int>();
     for (int x = 0; x < 128; x++)
     {
         var d = x.GetData1Difficulty(isPro);
         if (d.IsAll() && diff.IsAll())
         {
             ret.Add(x);
         }
         else if (d.IsExpert() && diff.IsExpert())
         {
             ret.Add(x);
         }
         else if (d.IsHard() && diff.IsHard())
         {
             ret.Add(x);
         }
         else if (d.IsMedium() && diff.IsMedium())
         {
             ret.Add(x);
         }
         else if (d.IsEasy() && diff.IsEasy())
         {
             ret.Add(x);
         }
     }
     return ret.ToArray();
 }
        public void GetMessages(GuitarDifficulty difficulty, bool includeDifficultyAll = true)
        {
            if (difficulty.IsAll())
                difficulty = difficulty ^ GuitarDifficulty.All;

            var validData1List = Utility.GetKnownData1ForDifficulty(IsPro,
                includeDifficultyAll ? GuitarDifficulty.All | difficulty : difficulty).ToList();

            Messages = new GuitarMessageList(owner);
            var events = checkForInvalidNotes(Messages, midiTrack, validData1List);

            var ret = Messages;
            var tempoTrack = GetTempoTrack();
            ret.AddRange(GetTempoMessages(ret, tempoTrack));
            ret.AddRange(GetTimeSigMessages(ret, tempoTrack));
            try
            {

                if (IsPro)
                {

                    events.GetEventPairs(Utility.AllArpeggioData1)
                        .Select(x => new GuitarArpeggio(x)).ToList().ForEach(x => x.AddToList());

                    events.GetEventPairs(Utility.SoloData1.MakeEnumerable()).Select(x => new GuitarSolo(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.PowerupData1.MakeEnumerable()).Select(x => new GuitarPowerup(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.MultiStringTremeloData1.MakeEnumerable()).Select(x => new GuitarMultiStringTremelo(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.SingleStringTremeloData1.MakeEnumerable()).Select(x => new GuitarSingleStringTremelo(x)).ToList().ForEach(x => x.AddToList());

                    GetBigRockEnding(ret, events);

                    events.GetEventPairs(Utility.AllSlideData1).Select(x => new GuitarSlide(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.AllHammeronData1).Select(x => new GuitarHammeron(x)).ToList().ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.AllStrumData1).Select(x => new GuitarChordStrum(x)).ToList().ForEach(x => x.AddToList());

                    events.GetEventPairs(Utility.ChordNameEvents).ToList().
                        Select(x => new GuitarChordName(x)).ToList().ForEach(x => x.AddToList());

                    var notes = events.GetEventPairs(Utility.GetStringsForDifficulty6(difficulty)).Select(x => new GuitarNote(x)).ToList();
                    notes.ForEach(x => x.AddToList());
                    if (notes.Any())
                    {
                        var closeNotes = notes.GroupBy(x => x.DownTick).ToList();
                        var chordNotes = closeNotes.Select(n => GuitarChord.GetChord(ret, difficulty, n, true)).ToList().Where(x => x != null).ToList();
                        chordNotes.ForEach(x => x.AddToList());
                    }

                    var textEvents = midiTrack.Meta.Where(x => x.IsTextEvent()).Select(x => new GuitarTextEvent(ret, x)).ToList();
                    textEvents.ForEach(x => x.AddToList());

                    LoadTrainers(ret, ret.TextEvents).ToList().ForEach(x => x.AddToList());

                    events.GetEventPairs(Utility.HandPositionData1.MakeEnumerable()).ToList().Select(x => new GuitarHandPosition(x)).ToList().ForEach(x => x.AddToList());

                }
                else
                {
                    events.GetEventPairs(new[] { Utility.ExpertSoloData1_G5, Utility.SoloData1 }).ToList().Select(x => new GuitarSolo(x)).ForEach(x => x.AddToList());
                    events.GetEventPairs(Utility.PowerupData1.MakeEnumerable()).Select(x => new GuitarPowerup(x)).ForEach(x => x.AddToList());

                    var notes = events.GetEventPairs(Utility.GetStringsForDifficulty5(difficulty)).Select(x => new GuitarNote(x)).ToList();
                    notes.ForEach(x => x.AddToList());

                    if (notes.Any())
                    {
                        var chans = notes.GroupBy(x => x.Channel);
                        var chords = new List<GuitarChord>();
                        foreach (var channelNotes in chans.Where(x => x.Key == 0))
                        {
                            var closeNotes = channelNotes.GroupByCloseTick().ToList();

                            chords.AddRange(closeNotes.Select(x => GuitarChord.GetChord(ret, difficulty, x, false)).Where(x => x != null).ToList());
                        }
                        foreach (var channelNotes in chans.Where(x => x.Key != 0))
                        {
                            var closeNotes = channelNotes.GroupByCloseTick().ToList();
                            var chords1 = closeNotes.Select(x => GuitarChord.GetChord(ret, difficulty, x, false)).Where(x => x != null).ToList();
                            foreach (var chord in chords1)
                            {
                                if (!chords.AnyBetweenTick(chord.TickPair))
                                {
                                    chords.Add(chord);
                                }
                            }
                        }
                        chords.OrderBy(x => x.DownTick).ToList().ForEach(x => x.AddToList());
                    }

                    var textEvents = midiTrack.Meta.Where(x => x.IsTextEvent()).ToList().Select(x => new GuitarTextEvent(ret, x)).ToList();
                    textEvents.ForEach(x => x.AddToList());

                    GetBigRockEnding(ret, events);
                }

            }
            catch { }
        }