public static ChordModifier GetModifier(GuitarChord chord, ChordModifierType type)
{
ChordModifier ret = null;
switch (type)
{
case ChordModifierType.ChordStrumHigh:
case ChordModifierType.ChordStrumMed:
case ChordModifierType.ChordStrumLow:
if (Utility.GetStrumData1(chord.Difficulty).IsNotNull())
{
ret = new GuitarChordStrum(chord, type);
}
break;
case ChordModifierType.Hammeron:
if (Utility.GetHammeronData1(chord.Difficulty).IsNotNull())
{
ret = new GuitarHammeron(chord);
}
break;
case ChordModifierType.Slide:
case ChordModifierType.SlideReverse:
if (Utility.GetSlideData1(chord.Difficulty).IsNotNull())
{
ret = new GuitarSlide(chord, type == ChordModifierType.SlideReverse);
}
break;
}
return(ret);
}
public GuitarChord CloneToMemory(GuitarMessageList owner, GuitarDifficulty difficulty)
{
GuitarChord ret = null;
var notes = Notes.Select(x => x.CloneToMemory(owner)).Where(x => x != null).ToList();
if (notes.Any())
{
ret = GuitarChord.GetChord(owner, difficulty, notes, false);
if (ret != null)
{
if (HasSlide)
{
ret.AddSlide(HasSlideReversed, false);
}
if (HasStrum)
{
ret.AddStrum(StrumMode, false);
}
if (HasHammeron)
{
ret.AddHammeron(false);
}
}
}
return(ret);
}
public GuitarSlide(GuitarChord chord, bool isReversed)
: base(chord,
isReversed ? ChordModifierType.SlideReverse : ChordModifierType.Slide, GuitarMessageType.GuitarSlide)
{
Data1 = Utility.GetSlideData1(chord.Difficulty);
Data2 = Utility.Data2Default;
Channel = isReversed ? Utility.ChannelSlideReversed : Utility.ChannelSlide;
}
public GuitarHammeron(GuitarChord chord)
: base(chord, ChordModifierType.Hammeron, GuitarMessageType.GuitarHammeron)
{
Data1 = Utility.GetHammeronData1(chord.Difficulty);
Data2 = Utility.Data2Default;
Channel = Utility.ChannelDefault;
SetTicks(chord.TickPair);
}
public static GuitarChord GetChord(GuitarMessageList owner,
GuitarDifficulty difficulty,
TickPair ticks,
GuitarChordConfig config)
{
GuitarChord ret = null;
var lowE = Utility.GetStringLowE(difficulty);
var notes = new List <GuitarNote>();
for (int x = 0; x < config.Frets.Length; x++)
{
var fret = config.Frets[x];
var channel = config.Channels[x];
if (!fret.IsNull() && fret >= 0 && fret <= 23)
{
var note = GuitarNote.GetNote(owner,
difficulty, ticks, x, fret,
channel == Utility.ChannelTap,
channel == Utility.ChannelArpeggio,
channel == Utility.ChannelX);
if (note != null && note.NoteFretDown.IsNotNull() && note.NoteString.IsNotNull())
{
notes.Add(note);
}
else
{
}
}
}
if (notes.Any())
{
ret = new GuitarChord(owner, ticks, difficulty, notes);
ret.chordConfig = config.Clone();
if (ret != null)
{
if (config.IsSlide || config.IsSlideReverse)
{
ret.AddSlide(config.IsSlideReverse, false);
}
if (config.IsHammeron)
{
ret.AddHammeron(false);
}
ret.AddStrum(config.StrumMode, false);
}
}
return(ret);
}
public GuitarChord CloneAtTime(
GuitarMessageList owner,
TickPair ticks,
int stringOffset = int.MinValue)
{
return(GuitarChord.CreateChord(owner, owner.Owner.CurrentDifficulty,
owner.Owner.SnapLeftRightTicks(ticks, new SnapConfig(true, true, true)),
new GuitarChordConfig(Notes.GetFretsAtStringOffset(stringOffset.GetIfNull(0)),
Notes.GetChannelsAtStringOffset(stringOffset.GetIfNull(0)),
HasSlide, HasSlideReversed, HasHammeron, StrumMode,
RootNoteConfig.GetIfNotNull(x => x.Clone()))));
}
public static GuitarChordStrum CreateStrum(GuitarChord chord, ChordStrum strum)
{
GuitarChordStrum ret = null;
if (!chord.HasStrumMode(strum) && Utility.GetStrumData1(chord.Difficulty).IsNotNull())
{
ret = new GuitarChordStrum(chord, strum.GetModifierType());
ret.IsNew = true;
ret.CreateEvents();
}
return(ret);
}
public static GuitarSlide CreateSlide(GuitarChord chord, bool reversed)
{
GuitarSlide ret = null;
if (!chord.HasSlide && Utility.GetSlideData1(chord.Difficulty).IsNotNull())
{
ret = new GuitarSlide(chord, reversed);
ret.IsNew = true;
ret.CreateEvents();
}
return(ret);
}
public AdjustResult AdjustChordTicks(GuitarChord chord, TickPair newTicks, AdjustOption option)
{
AdjustResult result;
var updatedTicks = GetAdjustChordTicks(newTicks, option, out result, chord);
if (!result.HasFlag(AdjustResult.Error) && updatedTicks.IsNull == false)
{
chord.SetTicks(updatedTicks);
chord.UpdateEvents();
}
return(result);
}
public static GuitarChord GetChord(GuitarMessageList owner,
GuitarDifficulty difficulty,
IEnumerable <GuitarNote> notes,
bool findModifiers = true)
{
GuitarChord ret = null;
try
{
if (notes != null && notes.Any())
{
if (notes.Any(x => x.IsDeleted))
{
Debug.WriteLine("getting deleted note");
}
var tickPair = notes.GetTickPairSmallest();
if (!tickPair.IsValid)
{
Debug.WriteLine("short chord");
return(ret);
}
var unfit = notes.Where(x => x.TickPair != tickPair);
if (unfit.Any())
{
unfit.ForEach(x => x.SetTicks(tickPair));
}
ret = new GuitarChord(owner, tickPair, difficulty, notes.ToList());
if (findModifiers)
{
ret.Modifiers.AddRange(owner.Hammerons.Where(x => x.Chord == null).GetBetweenTick(ret.TickPair).ToList());
ret.Modifiers.AddRange(owner.Slides.Where(x => x.Chord == null).GetBetweenTick(ret.TickPair).ToList());
ret.Modifiers.AddRange(owner.ChordStrums.Where(x => x.Chord == null).GetBetweenTick(ret.TickPair).ToList());
ret.ChordNameEvents.SetNames(owner.ChordNames.GetAtTick(ret.AbsoluteTicks).ToList());
var mods = ret.Modifiers.Where(x => x.TickPair != ret.TickPair).ToList();
foreach (var mod in mods)
{
mod.SetTicks(ret.TickPair);
}
mods.ForEach(x => x.Chord = ret);
}
}
}
catch (Exception ex) { Debug.WriteLine("GetChord: " + ex.Message); }
return(ret);
}
public static GuitarHammeron CreateHammeron(GuitarChord chord)
{
GuitarHammeron ret = null;
if (!chord.HasHammeron && Utility.GetHammeronData1(chord.Difficulty).IsNotNull())
{
ret = new GuitarHammeron(chord);
ret.IsNew = true;
ret.SetTicks(chord.TickPair);
ret.CreateEvents();
}
return(ret);
}
public static GuitarChord CreateChord(GuitarMessageList owner, GuitarDifficulty difficulty, TickPair ticks,
GuitarChordConfig config)
{
GuitarChord ret = null;
ret = GetChord(owner, difficulty, ticks, config);
if (ret != null)
{
ret.IsNew = true;
ret.CreateEvents();
}
return(ret);
}
public static ChordModifier CreateModifier(GuitarChord chord, ChordModifierType type)
{
ChordModifier ret = null;
switch (type)
{
case ChordModifierType.ChordStrumLow:
{
ret = GuitarChordStrum.CreateStrum(chord, ChordStrum.Low);
}
break;
case ChordModifierType.ChordStrumMed:
{
ret = GuitarChordStrum.CreateStrum(chord, ChordStrum.Mid);
}
break;
case ChordModifierType.ChordStrumHigh:
{
ret = GuitarChordStrum.CreateStrum(chord, ChordStrum.High);
}
break;
case ChordModifierType.Hammeron:
{
ret = GuitarHammeron.CreateHammeron(chord);
}
break;
case ChordModifierType.Slide:
{
ret = GuitarSlide.CreateSlide(chord, false);
}
break;
case ChordModifierType.SlideReverse:
{
ret = GuitarSlide.CreateSlide(chord, true);
}
break;
}
return(ret);
}
public GuitarChord Deserialize(GuitarMessageList owner, GuitarDifficulty diff, TickPair ticks)
{
int[] frets;
int[] channels;
ChordStrum chordStrum;
bool isSlide;
bool isSlideReverse;
bool isHammeron;
GuitarChordRootNoteConfig rootConfig;
GetProperties(out frets, out channels, out chordStrum, out isSlide, out isSlideReverse, out isHammeron, out rootConfig);
var ret = GuitarChord.CreateChord(owner, diff, ticks,
new GuitarChordConfig(frets, channels,
isSlide,
isSlideReverse,
isHammeron,
chordStrum,
rootConfig));
return(ret);
}
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 GuitarChordNoteList(GuitarChord owner)
{
this.owner = owner;
notes = new List <GuitarNote>();
}
public IEnumerable <Pitch.PitchTracker.PitchRecord> GetPitchRecords(GuitarChord chord)
{
return(GetPitchRecords(getChordSamples(chord)));
}
public GuitarChordStrum(GuitarChord chord, ChordModifierType type)
: base(chord, type, GuitarMessageType.GuitarChordStrum)
{
}
public float[] getChordSamples(GuitarChord chord)
{
var chordSamples = ReadPixelSamples(chord.StartTime, chord.EndTime);
return(chordSamples.SelectMany(x => x.Samples).ToArray());
}
public ChordModifier(GuitarChord chord, ChordModifierType type, GuitarMessageType gt) :
base(chord.Owner, chord.TickPair, gt)
{
ModifierType = type;
Chord = chord;
}
public ChordModifier(MidiEventPair pair, ChordModifierType type, GuitarMessageType gt) :
base(pair, gt)
{
Chord = null;
ModifierType = type;
}
public GuitarChordNameList(GuitarChord owner)
{
this.owner = owner;
names = new List <GuitarChordName>();
}
public TickPair GetAdjustChordTicks(TickPair newTicks, AdjustOption option, out AdjustResult result, GuitarChord chord = null)
{
result = AdjustResult.NoResult;
var existingTicks = new TickPair(newTicks.Down, newTicks.Up);
var queryTicks = new TickPair(newTicks.Down, newTicks.Up);
if (option.HasFlag(AdjustOption.AllowGrow) || option.HasFlag(AdjustOption.AllowShift))
{
queryTicks = new TickPair(newTicks.Down, newTicks.Up);
}
var between = Chords.GetBetweenTick(queryTicks);
if (chord != null)
{
between = between.Where(x => x != chord);
}
if (!between.Any())
{
result = AdjustResult.Success;
return(newTicks);
}
else
{
var closeToBegin = between.Where(x => x.TickPair.IsCloseUpDown(newTicks));
var closeToEnd = between.Where(x => x.TickPair.IsCloseDownUp(newTicks));
var closeChords = closeToBegin.Concat(closeToEnd).Distinct();
if (!closeChords.Any())
{
result = AdjustResult.Success;
return(newTicks);
}
else
{
TickPair updatedTicks = new TickPair(newTicks.Down, newTicks.Up);
var min = closeToBegin.GetMaxTick(updatedTicks.Down);
var max = closeToEnd.GetMinTick(updatedTicks.Up);
var updatedLen = updatedTicks.Up - updatedTicks.Down;
var space = max - min;
if (space <= 0)
{
result = AdjustResult.Error;
return(TickPair.NullValue);
}
if (updatedLen <= 0)
{
result = AdjustResult.Error;
return(TickPair.NullValue);
}
if (updatedLen == space)
{
result = AdjustResult.Success;
return(updatedTicks);
}
if ((updatedLen < space && option.HasFlag(AdjustOption.AllowGrow)) ||
(updatedLen > space && option.HasFlag(AdjustOption.AllowShrink)))
{
if (updatedTicks.Down < min)
{
result |= AdjustResult.AdjustedDownTickRight;
}
else if (updatedTicks.Down > min)
{
result |= AdjustResult.AdjustedDownTickLeft;
}
updatedTicks.Down = min;
if (updatedTicks.Up < max)
{
result |= AdjustResult.AdjustedUpTickRight;
}
else if (updatedTicks.Up > max)
{
result |= AdjustResult.AdjustedUpTickLeft;
}
updatedTicks.Up = max;
updatedLen = updatedTicks.Up - updatedTicks.Down;
if (updatedLen <= 0)
{
result = AdjustResult.Error;
return(TickPair.NullValue);
}
else
{
if (updatedLen < Utility.NoteCloseWidth)
{
result |= AdjustResult.ShortResult;
}
result |= AdjustResult.Success;
return(updatedTicks);
}
}
else if (updatedLen < space && option.HasFlag(AdjustOption.AllowShift))
{
if (updatedTicks.Down < min)
{
updatedTicks.Down = min;
updatedTicks.Up = min + updatedLen;
result |= AdjustResult.AdjustedDownTickRight | AdjustResult.AdjustedUpTickRight;
}
else
{
updatedTicks.Up = max;
updatedTicks.Down = max - updatedLen;
result |= AdjustResult.AdjustedDownTickLeft | AdjustResult.AdjustedUpTickLeft;
}
updatedLen = updatedTicks.Up - updatedTicks.Down;
if (updatedLen <= 0)
{
result = AdjustResult.Error;
return(TickPair.NullValue);
}
else
{
if (updatedLen < Utility.NoteCloseWidth)
{
result |= AdjustResult.ShortResult;
}
result |= AdjustResult.Success;
return(updatedTicks);
}
}
else
{
result = AdjustResult.Error;
return(TickPair.NullValue);
}
}
}
}