public GuitarMessage(GuitarMessageList owner, TickPair pair, GuitarMessageType type)
{
this.messageType = type;
this.props = new MidiEventProps(owner, pair);
this.SetTicks(pair);
}
GuitarBigRockEnding GetBigRockEnding(GuitarMessageList owner, IEnumerable <Data1ChannelEventList> events)
{
GuitarBigRockEnding ret = null;
var data1List = Utility.GetBigRockEndingData1(owner.IsPro);
var breEvents = events.GetEventPairs(data1List);
if (breEvents != null && breEvents.Any())
{
var ticks = breEvents.GetTickPair();
if (breEvents.Count() != data1List.Count())
{
breEvents.ToList().ForEach(x => owner.Remove(x));
ret = GuitarBigRockEnding.CreateBigRockEnding(owner, ticks);
}
else
{
ret = new GuitarBigRockEnding(owner, ticks, breEvents);
ret.AddToList();
}
}
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 GuitarNote(GuitarMessageList owner, TickPair ticks)
: base(owner, ticks, GuitarMessageType.GuitarNote)
{
Data2 = Utility.Data2Default;
Channel = Utility.ChannelDefault;
SetTicks(ticks);
}
public GuitarBigRockEnding(GuitarMessageList owner, TickPair ticks, IEnumerable <MidiEventPair> events) :
this(owner, ticks)
{
Channel = 0;
events.ToList().ForEach(ev => AddSubMessage(new GuitarBigRockEndingSubMessage(this, ev)));
SetTicks(ticks);
}
public GuitarModifier(GuitarMessageList owner, TickPair ticks, GuitarModifierType type, GuitarMessageType mt) :
base(owner, ticks, mt)
{
Data2 = 100;
Channel = 0;
this.ModifierType = type;
}
public GuitarNote CloneToMemory(GuitarMessageList owner)
{
GuitarNote ret = null;
if (owner != null)
{
ret = GetNote(owner, Difficulty, this.TickPair, NoteString, NoteFretDown, IsTapNote, IsArpeggioNote, IsXNote);
}
else if (IsPro)
{
ret = GetNotePro(owner, Difficulty, this.TickPair, NoteString, NoteFretDown, IsTapNote, IsArpeggioNote, IsXNote);
}
else
{
ret = GetNote5(owner, Difficulty, this.TickPair, NoteString, NoteFretDown, IsTapNote, IsArpeggioNote, IsXNote);
}
if (ret != null)
{
if (owner != null)
{
if (IsPro == false && owner.IsPro)
{
ret.Data2 = 100;
}
}
}
return(ret);
}
public IEnumerable <GuitarTempo> GetTempoMessages(GuitarMessageList owner, Track tempoTrack)
{
var ret = new List <GuitarTempo>();
try
{
var tempos = internalGetTempo(owner, tempoTrack);
int nextTick = 0;
tempos.For((t, i) =>
{
tempos.ElementAtOrDefault(i + 1).IfObjectNotNull(next =>
{
nextTick = next.AbsoluteTicks;
},
Else =>
{
nextTick = Sequence.GetLength();
});
t.SetUpTick(nextTick);
});
ret.AddRange(tempos.ToList());
}
catch { }
return(ret);
}
public static GuitarChordName CreateEvent(GuitarMessageList owner, TickPair ticks, ChordNameMeta meta, bool chordNameHidden)
{
var ret = new GuitarChordName(owner, ticks, meta, chordNameHidden);
ret.IsNew = true;
ret.CreateEvents();
return(ret);
}
public static GuitarHandPosition CreateEvent(GuitarMessageList owner, TickPair ticks, int noteFret)
{
var ret = new GuitarHandPosition(owner, ticks, noteFret);
ret.IsNew = true;
ret.CreateEvents();
return(ret);
}
public GuitarHandPosition(GuitarMessageList owner, TickPair pair, int noteFret)
: base(owner, pair, GuitarMessageType.GuitarHandPosition)
{
this.Data1 = Utility.HandPositionData1;
NoteFretDown = noteFret;
Channel = 0;
this.SetTicks(pair);
}
public GuitarMultiStringTremelo(GuitarMessageList owner, TickPair pair)
: base(owner, pair, GuitarModifierType.MultiStringTremelo, GuitarMessageType.GuitarMultiStringTremelo)
{
this.Data1 = Utility.MultiStringTremeloData1;
this.Data2 = 100;
Channel = 0;
this.SetTicks(pair);
}
public GuitarSingleStringTremelo(GuitarMessageList owner, TickPair ticks) :
base(owner, ticks, GuitarModifierType.SingleStringTremelo, GuitarMessageType.GuitarSingleStringTremelo)
{
this.Data1 = Utility.SingleStringTremeloData1;
this.Data2 = 100;
Channel = 0;
this.SetTicks(ticks);
}
public static GuitarTextEvent CreateTextEvent(GuitarMessageList owner, int absoluteTicks, string text)
{
var ret = new GuitarTextEvent(owner, absoluteTicks, text);
ret.IsNew = true;
ret.CreateEvents();
return(ret);
}
public GuitarChordName(GuitarMessageList owner, TickPair pair, ChordNameMeta meta, bool hidden)
: base(owner, pair, GuitarMessageType.GuitarChordName)
{
this.Data1 = meta.ToneName.ToToneNameData1().ToInt();
this.Meta = meta;
this.ChordNameHidden = hidden;
Channel = 0;
}
public GuitarPowerup(GuitarMessageList owner, TickPair pair)
: base(owner, pair, GuitarModifierType.Powerup, GuitarMessageType.GuitarPowerup)
{
this.Data1 = Utility.PowerupData1;
this.Data2 = 100;
Channel = 0;
this.SetTicks(pair);
}
public static GuitarMultiStringTremelo CreateMultiStringTremelo(GuitarMessageList owner, TickPair ticks)
{
var ret = new GuitarMultiStringTremelo(owner, ticks);
ret.IsNew = true;
ret.CreateEvents();
return(ret);
}
public static GuitarBigRockEnding CreateBigRockEnding(GuitarMessageList owner, TickPair ticks)
{
var ret = new GuitarBigRockEnding(owner, ticks);
ret.IsNew = true;
ret.CreateEvents();
return(ret);
}
public static GuitarPowerup CreatePowerup(GuitarMessageList owner, TickPair ticks)
{
var ret = new GuitarPowerup(owner, ticks);
ret.IsNew = true;
ret.CreateEvents();
return(ret);
}
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 static GuitarNote CreateNote(GuitarMessageList owner, GuitarDifficulty diff, TickPair ticks,
int noteString, int noteFret, bool isTap, bool isArpeggio, bool isX)
{
var ret = GetNote(owner, diff, ticks, noteString, noteFret, isTap, isArpeggio, isX);
ret.IsNew = true;
ret.CreateEvents();
return(ret);
}
public GuitarBigRockEnding(GuitarMessageList owner, TickPair ticks) :
base(owner, ticks, GuitarModifierType.BigRockEnding, GuitarMessageType.GuitarBigRockEnding)
{
Channel = 0;
foreach (var data1 in Utility.GetBigRockEndingData1(IsPro))
{
childEvents.Add(new GuitarBigRockEndingSubMessage(this, ticks, data1));
}
SetTicks(ticks);
}
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 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 GuitarTempo(GuitarMessageList owner, MidiEvent ev)
: base(owner, ev, null, GuitarMessageType.GuitarTempo)
{
if (ev == null)
{
this.Tempo = Utility.DummyTempo;
}
else
{
var cb = new TempoChangeBuilder((MetaMessage)ev.Clone());
this.Tempo = cb.Tempo;
}
}
private void resetProps(GuitarMessageList owner)
{
Owner = owner;
IsPro = (owner == null ? true : owner.IsPro);
Data1 = Int32.MinValue;
Data2 = Int32.MinValue;
Channel = Int32.MinValue;
Command = ChannelCommand.Invalid;
Text = string.Empty;
TickPair = TickPair.NullValue;
TimePair = TimePair.NullValue;
_eventPair = new MidiEventPair(owner);
}
IEnumerable <GuitarTimeSignature> GetTimeSignaturesFromTrack(GuitarMessageList owner, Track tempoTrack)
{
var ret = new List <GuitarTimeSignature>();
if (tempoTrack != null && tempoTrack.TimeSig.Any())
{
ret.AddRange(tempoTrack.TimeSig.Select(t => new GuitarTimeSignature(owner, t)));
}
else
{
ret.Add(GuitarTimeSignature.GetDefaultTimeSignature(owner));
}
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 GuitarArpeggio CreateArpeggio(GuitarMessageList owner, TickPair ticks, GuitarDifficulty difficulty)
{
GuitarArpeggio ret = null;
if (Utility.GetArpeggioData1(difficulty).IsNotNull())
{
ret = new GuitarArpeggio(owner, ticks, difficulty);
if (ret != null)
{
ret.IsNew = true;
ret.CreateEvents();
}
}
return(ret);
}
public GuitarTrainer(GuitarMessageList owner, TickPair ticks, GuitarTrainerType type, GuitarTextEvent start, GuitarTextEvent end, GuitarTextEvent norm)
: base(owner, ticks, GuitarMessageType.GuitarTrainer)
{
this.TrainerType = type;
Start = start;
End = end;
Norm = norm;
this.TrainerIndex = ParseTrainerIndex();
this.Loopable = norm != null;
SetTicks(ticks);
}
