void CreateInstruments() { Instrument guitar = new Instrument("rhythmGuitar", gameObject.GetComponent<AudioSource>()); Chord[] C_Chords = new Chord[6]; C_Chords[0] = LoadChord("C"); C_Chords[1] = LoadChord("Dm"); C_Chords[2] = LoadChord("Em"); C_Chords[3] = LoadChord("F"); C_Chords[4] = LoadChord("G"); C_Chords[5] = LoadChord("Am"); guitar.AddKey("C", C_Chords); Chord[] Am_Chords = new Chord[6]; Am_Chords[0] = LoadChord("Am"); Am_Chords[1] = LoadChord("C"); Am_Chords[2] = LoadChord("Dm"); Am_Chords[3] = LoadChord("Em"); Am_Chords[4] = LoadChord("F"); Am_Chords[5] = LoadChord("G"); guitar.AddKey("Am", Am_Chords); m_Instruments.Add(guitar); }
private void changeSelectedChord(Chord selectedChord) { chordNameTextBox.Text = selectedChord.FullName; chordAbbreviationTextBox.Text = selectedChord.Abbreviation; chordIDLabel.Text = "ID: " + selectedChord.ID; chordEnabledCheckBox.Checked = selectedChord.Enabled; chordFormulaInput.PopulateControl(selectedChord.Formula); }
private void AddTriad() { Chord chord = new Chord(); chord.Add(new Note(Note.Letter.C, Note.Accidental.None, Note.Octave.OneLined)); //chord.Add(new Note(Note.Letter.D, Note.Octave.OneLined)); chord.Add(new Note(Note.Letter.E, Note.Accidental.None, Note.Octave.OneLined)); //chord.Add(new Note(Note.Letter.F, Note.Octave.OneLined)); chord.Add(new Note(Note.Letter.G, Note.Accidental.None, Note.Octave.OneLined)); score.Add(chord); }
static void ChordTest() { MusicPlayer player = new MusicPlayer(); Chord dminor = new Chord(new NoteNames[] { NoteNames.D, NoteNames.F, NoteNames.A }, 4, Durations.wn); Chord dmajor = new Chord(new NoteNames[] { NoteNames.G, NoteNames.B, NoteNames.B }, 4, Durations.wn); Chord cmajor = new Chord(new NoteNames[] { NoteNames.C, NoteNames.E, NoteNames.G }, 4, Durations.bn); HarmonySequence seq = new HarmonySequence(); seq.AddChord(dminor); seq.AddChord(dmajor); seq.AddChord(cmajor); seq.AddChord(dminor); seq.AddChord(cmajor); seq.AddChord(dminor); seq.AddChord(dmajor); seq.AddChord(cmajor); player.Play(seq); player.Close(); }
private void createNewChord() { //create the chord Chord createdChord = new Chord("New chord", "", "", Guid.NewGuid(), true); ChordListItem newChordListItem = new ChordListItem(createdChord); chordList.Items.Add(newChordListItem); //write to the XML file GrassNotesController.LoadedData.WriteNewChord(createdChord); //update the GUI chordList.SelectedItem = newChordListItem; chordNameTextBox.SelectAll(); chordNameTextBox.Focus(); }
private void AddAllTriads() { List<Key> whiteKeys = keyboard.keys.FindAll(key => key.isWhite); for (int k = 0; k < whiteKeys.Count - 4; k++) { Chord chord = new Chord(); chord.Add(new Note(whiteKeys[k + 0].note.letter, Note.Accidental.None, whiteKeys[k + 0].note.octave)); chord.Add(new Note(whiteKeys[k + 2].note.letter, Note.Accidental.None, whiteKeys[k + 2].note.octave)); chord.Add(new Note(whiteKeys[k + 4].note.letter, Note.Accidental.None, whiteKeys[k + 4].note.octave)); int u = whiteKeys.Count - 1 - 4 - k; chord.Add(new Note(whiteKeys[u + 0].note.letter, Note.Accidental.None, whiteKeys[u + 0].note.octave)); chord.Add(new Note(whiteKeys[u + 2].note.letter, Note.Accidental.None, whiteKeys[u + 2].note.octave)); chord.Add(new Note(whiteKeys[u + 4].note.letter, Note.Accidental.None, whiteKeys[u + 4].note.octave)); score.Add(chord); } AddBar(); }
public bool DeleteChord(Chord chordToDelete) { //load the root elements XDocument loadedDocument = XDocument.Load(GrassNotesController.getPathString()); XElement rootNode = loadedDocument.Elements().First(); XElement chordsElement = rootNode.Element("chords"); if (chordsElement.Elements().Where(q => q.Attribute("id").Value == chordToDelete.ID.ToString()).Count() > 0) { //create the new chordelement and populate its attributes XElement chordElement = chordsElement.Elements().Where(q => q.Attribute("id").Value == chordToDelete.ID.ToString()).First(); chordElement.Remove(); //add new chord element to document and save it loadedDocument.Save(GrassNotesController.getPathString()); chords.Remove(chordToDelete.ID); return true; } else { return false; } }
public void getSecondStringFirstFret() { Assert.AreEqual("A", Chord.GetNoteLetter(1, 0)); }
public ChordListItem(Chord chord) { name = chord.FullName; value = chord; }
public static Chord CreateChord(global::System.Guid ID, global::System.Guid measure_Id, short key_Id, int location_X, int location_Y, decimal duration, Audit audit) { Chord chord = new Chord(); chord.Id = ID; chord.Measure_Id = measure_Id; chord.Key_Id = key_Id; chord.Location_X = location_X; chord.Location_Y = location_Y; chord.Duration = duration; if ((audit == null)) { throw new global::System.ArgumentNullException("audit"); } chord.Audit = audit; return chord; }
public void getThirdStringFirstFret() { Assert.AreEqual("D", Chord.GetNoteLetter(2, 0)); }
public static double[] ConvertChordIntoTrainingInput(Chord chord) { if (!chord.Notes.Any()) { return null; } if (chord.Notes.Count == 1) { var first = chord.Notes.First(); return new double[] { FromFullNote(first) }; } double[] ret = new double[chord.Notes.Count + 2]; ret[0] = -1; for (int i = 0; i < chord.Notes.Count; i++) { ret[i + 1] = FromFullNote(chord.Notes[i]); } ret[chord.Notes.Count + 1] = -1; return ret; }
public void PlayChords(Chord[] chords) { state = 0; foreach(Chord c in chords) { foreach (Note n in c.Notes) { midiOut.Send(MidiMessage.StartNote(n.Pitch, c.Velocity, 1).RawData); } Thread.Sleep((int)(Note.ToRealDuration(c.Duration) * 1000)); foreach (Note n in c.Notes) { midiOut.Send(MidiMessage.StopNote(n.Pitch, 0, 1).RawData); } } }
public Command GetChord(Chord chord) { if (this.chords.ContainsKey(chord)) return this.chords[chord]; else { Command cmd = new Command(); this.chords.Add(chord, cmd); return cmd; } }
public ChordEvent() { Chord = new Chord(); }
void IUpdateableComponent.Update(float dt) { KeyboardState keyboard = this.main.KeyboardState; Keys[] unfilteredKeys = keyboard.GetPressedKeys(); Keys[] keys = unfilteredKeys.Except(this.lastPressedKeys).ToArray(); if (this.StringPropertyLocked && unfilteredKeys.Length > 0) { if (this.selectedStringNavigateInterval > 0.1f) { if (unfilteredKeys.Contains(Keys.Back)) { this.selectedStringNavigateInterval = 0.0f; if (this.selectedStringValue.Length > 0 && this.selectedStringIndex > 0) { this.selectedStringValue = this.selectedStringValue.Remove(this.selectedStringIndex - 1, 1); this.selectedStringIndex--; } } else if (unfilteredKeys.Contains(Keys.Delete)) { this.selectedStringNavigateInterval = 0.0f; if (this.selectedStringIndex < this.selectedStringValue.Length) this.selectedStringValue = this.selectedStringValue.Remove(this.selectedStringIndex, 1); } else if (unfilteredKeys.Contains(Keys.Down)) { this.selectedStringNavigateInterval = 0.0f; if (this.selectedStringValue.Length > 0 && this.selectedStringAllowMultiline) { int index = this.selectedStringValue.IndexOf('\n', this.selectedStringIndex + 1); if (index == -1) this.selectedStringIndex = this.selectedStringValue.Length; else this.selectedStringIndex = index; } } else if (unfilteredKeys.Contains(Keys.Up)) { this.selectedStringNavigateInterval = 0.0f; if (this.selectedStringValue.Length > 0 && this.selectedStringAllowMultiline) { int index = this.selectedStringValue.Substring(0, Math.Max(0, this.selectedStringIndex - 1)).LastIndexOf('\n'); if (index == -1) this.selectedStringIndex = 0; else this.selectedStringIndex = index; } } else if (unfilteredKeys.Contains(Keys.Left) || unfilteredKeys.Contains(Keys.Right)) { this.selectedStringNavigateInterval = 0.0f; if (this.selectedStringValue.Length > 0) { this.selectedStringIndex += unfilteredKeys.Contains(Keys.Right) ? 1 : -1; if (this.selectedStringIndex < 0) this.selectedStringIndex = Math.Max(0, this.selectedStringValue.Length); else if (this.selectedStringIndex > this.selectedStringValue.Length) this.selectedStringIndex = 0; } } } if (unfilteredKeys.Contains(Keys.Tab) || (unfilteredKeys.Contains(Keys.Enter) && !this.selectedStringAllowMultiline)) { this.commitStringProperty(); return; } else if (unfilteredKeys.Contains(Keys.Escape) && !this.selectedStringAllowEscape) { this.revertStringProperty(); return; } bool caps = unfilteredKeys.Contains(Keys.LeftShift) || unfilteredKeys.Contains(Keys.RightShift); foreach (Keys key in keys) { if (!EditorUI.ignoredKeys.Contains(key)) { this.selectedStringIndex++; Chord chord = new Chord { Keys = key, Shift = caps }; if (EditorUI.inputKeyMappings.ContainsKey(chord)) this.selectedStringValue = this.selectedStringValue.Insert(this.selectedStringIndex - 1, EditorUI.inputKeyMappings[chord]); else this.selectedStringValue = this.selectedStringValue.Insert(this.selectedStringIndex - 1, caps ? key.ToString().ToUpper() : key.ToString().ToLower()); } } this.selectedStringDisplayProperty.Value = this.selectedStringValue.Insert(this.selectedStringIndex, "_"); } this.lastPressedKeys = unfilteredKeys; this.selectedStringNavigateInterval += dt; }
public static double Calculate(Chord longestChord, Chord longestPerpendicularChord) { return longestPerpendicularChord.Length / longestChord.Length; }
private void saveChord() { //create the chord object for the new chord string newChordName = chordNameTextBox.Text.Trim(); string newChordAbbreviation = chordAbbreviationTextBox.Text.Trim(); List<Interval> newChordFormula = chordFormulaInput.GetFormula().ToList(); Guid updatedChordID = ((ChordListItem)chordList.SelectedItem).Value.ID; bool newChordenabled = chordEnabledCheckBox.Checked; Chord updatedChord = new Chord(newChordName, newChordAbbreviation, newChordFormula, updatedChordID, newChordenabled); //write the new chord to XMl and to the data object GrassNotesController.LoadedData.UpdateChord(updatedChord); //update the GUI ((ChordListItem)chordList.SelectedItem).UpdateItem(updatedChord); chordList.RefreshItem(chordList.SelectedIndex); }
public void AddChord(int position, Chord chord, byte volume) { lastChord = chord; foreach (byte note in chord.Notes) { AddNote(position, note, volume); } }
public override Chord Transform(Chord baseMelody) { throw new NotImplementedException(); }
public void setFirstChord(Chord firstChord) { currentChord = firstChord; }
public virtual void Update(float elapsedTime) { if (!main.IsActive) return; KeyboardState keyboard = this.main.KeyboardState; Keys[] keys = keyboard.GetPressedKeys(); if (keys.Length > 0 && this.nextInputListeners.Count > 0) this.notifyNextInputListeners(new PCInputBinding { Key = keys[0] }); foreach (KeyValuePair<Keys, Property<bool>> pair in this.keyProperties) { bool newValue = keyboard.IsKeyDown(pair.Key); if (newValue != pair.Value.Value) { pair.Value.Value = newValue; if (!this.preventKeyDownEvents) { if (newValue) { Command command; if (keyDownCommands.TryGetValue(pair.Key, out command)) command.Execute(); } else { Command command; if (keyUpCommands.TryGetValue(pair.Key, out command)) command.Execute(); } } } } if (!this.chordActivated && !this.preventKeyDownEvents) { if (keys.Length == 2) { Chord chord = new Chord(); if (keys[1] == Keys.LeftAlt || keys[1] == Keys.LeftControl || keys[1] == Keys.LeftShift || keys[1] == Keys.LeftWindows || keys[1] == Keys.RightAlt || keys[1] == Keys.RightControl || keys[1] == Keys.RightShift || keys[1] == Keys.RightWindows) { chord.Modifier = keys[1]; chord.Key = keys[0]; } else { chord.Modifier = keys[0]; chord.Key = keys[1]; } if (this.chords.ContainsKey(chord)) { this.chords[chord].Execute(); this.chordActivated = true; } } } else if (keyboard.GetPressedKeys().Length == 0) this.chordActivated = false; MouseState mouse = this.main.MouseState; this.handleMouse(); bool newLeftMouseButton = mouse.LeftButton == ButtonState.Pressed; if (newLeftMouseButton != this.LeftMouseButton) { this.LeftMouseButton.Value = newLeftMouseButton; if (!this.preventKeyDownEvents) { if (newLeftMouseButton) { if (this.nextInputListeners.Count > 0) this.notifyNextInputListeners(new PCInputBinding { MouseButton = MouseButton.LeftMouseButton }); this.LeftMouseButtonDown.Execute(); } else this.LeftMouseButtonUp.Execute(); } } bool newMiddleMouseButton = mouse.MiddleButton == ButtonState.Pressed; if (newMiddleMouseButton != this.MiddleMouseButton) { this.MiddleMouseButton.Value = newMiddleMouseButton; if (!this.preventKeyDownEvents) { if (newMiddleMouseButton) { if (this.nextInputListeners.Count > 0) this.notifyNextInputListeners(new PCInputBinding { MouseButton = MouseButton.MiddleMouseButton }); this.MiddleMouseButtonDown.Execute(); } else this.MiddleMouseButtonUp.Execute(); } } bool newRightMouseButton = mouse.RightButton == ButtonState.Pressed; if (newRightMouseButton != this.RightMouseButton) { this.RightMouseButton.Value = newRightMouseButton; if (!this.preventKeyDownEvents) { if (newRightMouseButton) { if (this.nextInputListeners.Count > 0) this.notifyNextInputListeners(new PCInputBinding { MouseButton = MouseButton.RightMouseButton }); this.RightMouseButtonDown.Execute(); } else this.RightMouseButtonUp.Execute(); } } int newScrollWheel = mouse.ScrollWheelValue; int oldScrollWheel = this.ScrollWheel; if (newScrollWheel != oldScrollWheel) { this.ScrollWheel.Value = newScrollWheel; if (!this.preventKeyDownEvents) this.MouseScrolled.Execute(newScrollWheel > oldScrollWheel ? 1 : -1); } this.preventKeyDownEvents = false; }
public void Create(Chord chord) { this.chord = chord; Debug.Log(chord.root); }
private string SingleChord(Chord c) { if (c == null || c.Notes == null || c.Notes.Count == 0) { return string.Empty; } if (c.Notes.Count == 1) { return c.Notes.First().Note.ToString() + this.OctavePrefix(c.Notes.First()); } StringBuilder builder = new StringBuilder(); if (!this.NoteByNote) { builder.Append("<"); foreach (var item in c.Notes) { builder.Append(this.PureNoteString(item) + this.OctavePrefix(item) + " "); } builder.Append(">"); } else { foreach (var item in c.Notes) { lock (this) { builder.Append(this.PureNoteString(item) + this.OctavePrefix(item) + " "); } } } return builder.ToString(); }
private void readNewChord(Chord chord) { /*Read new-style (GP4) chord diagram. * * New-style chord diagram is read as follows: * * - Sharp: :ref:`bool`. If true, display all semitones as sharps, * otherwise display as flats. * * - Blank space, 3 :ref:`Bytes <byte>`. * * - Root: :ref:`int`. Values are: * * -1 for customized chords * 0: C * 1: C# * ... * * - Type: :ref:`int`. Determines the chord type as followed. See * :class:`guitarpro.models.ChordType` for mapping. * * - Chord extension: :ref:`int`. See * :class:`guitarpro.models.ChordExtension` for mapping. * * - Bass note: :ref:`int`. Lowest note of chord as in *C/Am*. * * - Tonality: :ref:`int`. See * :class:`guitarpro.models.ChordAlteration` for mapping. * * - Add: :ref:`bool`. Determines if an "add" (added note) is * present in the chord. * * - Name: :ref:`byte-size-string`. Max length is 22. * * - Fifth alteration: :ref:`int`. Maps to * :class:`guitarpro.models.ChordAlteration`. * * - Ninth alteration: :ref:`int`. Maps to * :class:`guitarpro.models.ChordAlteration`. * * - Eleventh alteration: :ref:`int`. Maps to * :class:`guitarpro.models.ChordAlteration`. * * - List of frets: 6 :ref:`Ints <int>`. Fret values are saved as * in default format. * * - Count of barres: :ref:`int`. Maximum count is 2. * * - Barre frets: 2 :ref:`Ints <int>`. * * - Barre start strings: 2 :ref:`Ints <int>`. * * - Barre end string: 2 :ref:`Ints <int>`. * * - Omissions: 7 :ref:`Bools <bool>`. If the value is true then * note is played in chord. * * - Blank space, 1 :ref:`byte`.*/ chord.sharp = GPBase.readBool()[0]; var intonation = chord.sharp ? "sharp" : "flat"; GPBase.skip(3); chord.root = new PitchClass(GPBase.readInt()[0], -1, "", intonation); chord.type = (ChordType)GPBase.readInt()[0]; chord.extension = (ChordExtension)GPBase.readInt()[0]; chord.bass = new PitchClass(GPBase.readInt()[0], -1, "", intonation); chord.tonality = (ChordAlteration)GPBase.readInt()[0]; chord.add = GPBase.readBool()[0]; chord.name = GPBase.readByteSizeString(22); chord.fifth = (ChordAlteration)GPBase.readInt()[0]; chord.ninth = (ChordAlteration)GPBase.readInt()[0]; chord.eleventh = (ChordAlteration)GPBase.readInt()[0]; chord.firstFret = GPBase.readInt()[0]; for (int i = 0; i < 6; i++) { var fret = GPBase.readInt()[0]; if (i < chord.strings.Length) { chord.strings[i] = fret; } } chord.barres.Clear(); var barresCount = GPBase.readInt()[0]; var barreFrets = GPBase.readInt(2); var barreStarts = GPBase.readInt(2); var barreEnds = GPBase.readInt(2); for (int x = 0; x < Math.Min(2, barresCount); x++) { var barre = new Barre(barreFrets[x], barreStarts[x], barreEnds[x]); chord.barres.Add(barre); } chord.omissions = GPBase.readBool(7); GPBase.skip(1); }
public void Append(Chord chord) { chord.NullCheck(); this.innerChords.Add(chord); }
int ExportOrFindBeat(Chord chord) { var beat = new Beat(); beat.Id = gpif.Beats.Count; foreach (var note in chord.Notes) { int id = ExportOrFindNote(note.Value); beat.Notes.Add(id); } // there seem to be a few accidental ties set in the Rocksmith XMLs // so unset the tie status on any strings that weren't in the current chord. for (int i = 0; i < 6; ++i) { if (!chord.Notes.ContainsKey(i)) link[i] = false; } // should we display a strum hint? if (chord.BrushDirection != Chord.BrushType.None) { var brushProp = new Property() { Name = "Brush" }; if (chord.BrushDirection == Chord.BrushType.Down) brushProp.Direction = "Down"; else brushProp.Direction = "Up"; if (beat.Properties == null) beat.Properties = new List<Property>(); beat.Properties.Add(brushProp); } // tremolo picking if (chord.Tremolo) { // 32nd notes tremolo picking (should be appropriate) beat.Tremolo = "1/8"; } // slap/pop notes if (chord.Slapped) { if (beat.Properties == null) beat.Properties = new List<Property>(); beat.Properties.Add(new Property() { Name = "Slapped", Enable = new Property.EnableType() }); } if (chord.Popped) { if (beat.Properties == null) beat.Properties = new List<Property>(); beat.Properties.Add(new Property() { Name = "Popped", Enable = new Property.EnableType() }); } // construct rhythm var rhythm = new Rhythm(); rhythm.Id = gpif.Rhythms.Count; switch (chord.Duration) { case 192: rhythm.NoteValue = "Whole"; break; case 168: // should avoid this, split note instead (TODO) rhythm.NoteValue = "Half"; rhythm.AugmentationDot = new Rhythm.Dot() { Count = 2 }; break; case 144: rhythm.NoteValue = "Half"; rhythm.AugmentationDot = new Rhythm.Dot() { Count = 1 }; break; case 96: rhythm.NoteValue = "Half"; break; case 84: // should avoid this, split note instead (TODO) rhythm.NoteValue = "Quarter"; rhythm.AugmentationDot = new Rhythm.Dot() { Count = 2 }; break; case 72: rhythm.NoteValue = "Quarter"; rhythm.AugmentationDot = new Rhythm.Dot() { Count = 1 }; break; case 48: rhythm.NoteValue = "Quarter"; break; case 36: rhythm.NoteValue = "Eighth"; rhythm.AugmentationDot = new Rhythm.Dot() { Count = 1 }; break; case 32: rhythm.NoteValue = "Quarter"; rhythm.PrimaryTuplet = new Rhythm.Tuplet() { Den = 2, Num = 3 }; break; case 24: rhythm.NoteValue = "Eighth"; break; case 18: rhythm.NoteValue = "16th"; rhythm.AugmentationDot = new Rhythm.Dot() { Count = 1 }; break; case 16: rhythm.NoteValue = "Eighth"; rhythm.PrimaryTuplet = new Rhythm.Tuplet() { Den = 2, Num = 3 }; break; case 12: rhythm.NoteValue = "16th"; break; case 9: rhythm.NoteValue = "32nd"; rhythm.AugmentationDot = new Rhythm.Dot() { Count = 1 }; break; case 8: rhythm.NoteValue = "16th"; rhythm.PrimaryTuplet = new Rhythm.Tuplet() { Den = 2, Num = 3 }; break; case 6: rhythm.NoteValue = "32nd"; break; case 4: rhythm.NoteValue = "32nd"; rhythm.PrimaryTuplet = new Rhythm.Tuplet() { Den = 2, Num = 3 }; break; case 3: rhythm.NoteValue = "64th"; break; case 2: rhythm.NoteValue = "64th"; rhythm.PrimaryTuplet = new Rhythm.Tuplet() { Den = 2, Num = 3 }; break; case 1: rhythm.NoteValue = "128th"; rhythm.PrimaryTuplet = new Rhythm.Tuplet() { Den = 2, Num = 3 }; break; default: Console.WriteLine(" Warning: Rhythm Duration {0} not handled, defaulting to quarter note.", chord.Duration); rhythm.NoteValue = "Quarter"; break; } // see if this rhythm already exists, otherwise add var searchRhythm = gpif.Rhythms.Find(x => x.Equals(rhythm)); if (searchRhythm != null) rhythm = searchRhythm; else gpif.Rhythms.Add(rhythm); beat.Rhythm.Ref = rhythm.Id; // should we display a chord name? if (chord.ChordId != -1 && chord.ChordId != prevChordId) { beat.Chord = chord.ChordId.ToString(); } prevChordId = chord.ChordId; if (chord.Section != null) beat.FreeText = chord.Section; // see if this beat already exists, otherwise add var searchBeat = gpif.Beats.Find(x => x.Equals(beat)); if (searchBeat != null) beat = searchBeat; else gpif.Beats.Add(beat); return beat.Id; }
public void getFirstStringTwelfthFret() { Assert.AreEqual("E", Chord.GetNoteLetter(0, 12)); }
public void AddToChords(Chord chord) { base.AddObject("Chords", chord); }
public void getIntervalRootAnotherChord2() { Chord c = new Chord("D#"); Assert.AreEqual("r", c.getIntervalFromRootNote("D#")); }
public void getFourthStringTwelfthFret() { Assert.AreEqual("G", Chord.GetNoteLetter(3, 12)); }
public void getIntervalp5() { Chord c = new Chord("C+5"); Assert.AreEqual("+5", c.getIntervalFromRootNote("G#")); }
public void getThirdStringTwelfthFret() { Assert.AreEqual("D", Chord.GetNoteLetter(2, 12)); }
public void getSixthStringFirstFret() { Assert.AreEqual("E", Chord.GetNoteLetter(5, 0)); }
public void getSecondStringTwelfthFret() { Assert.AreEqual("A", Chord.GetNoteLetter(1, 12)); }
public void UpdateItem(Chord chord) { name = chord.FullName; value = chord; }
public void getRootNoteTestb() { Chord c = new Chord("Cb"); Assert.AreEqual("Cb", c.getRootNote()); }
public static ChordProgression ChordGen(Scale Scale, List <int> ProgPattern, List <int> ColorPattern, int duration = 1, int Root = 1, int Offset1 = 2, int Offset2 = 4) { ChordProgression ChordList = new ChordProgression(); ChordProgression PureList = new ChordProgression(); int counter = 0; //Use Progression Pattern if (ProgPattern != null) { foreach (var chordNum in ProgPattern) { var scaleIndex = chordNum - 1; var root = Scale.Steps[scaleIndex % Scale.Steps.Count]; //Do we need to add an octave? bool octPlus = (scaleIndex + Offset1) >= Scale.Steps.Count; var c2 = Scale.Steps[(scaleIndex + Offset1) % Scale.Steps.Count]; var third = octPlus ? c2 + Scale.Divisions : c2; octPlus = (scaleIndex + Offset2) >= Scale.Steps.Count; var c3 = Scale.Steps[(scaleIndex + Offset2) % Scale.Steps.Count]; var fifth = octPlus ? c3 + Scale.Divisions : c3; var chord = new Chord( root, third, fifth ); if (ColorPattern != null && ColorPattern.Count > 0) { var colorNum = ColorPattern[counter % ColorPattern.Count]; if (colorNum > Scale.Steps.Count) { chord.Notes.Add(Scale.Steps[(scaleIndex + (colorNum - 1)) % Scale.Steps.Count] + Scale.Divisions); } else { chord.Notes.Add(Scale.Steps[(scaleIndex + (colorNum - 1)) % Scale.Steps.Count]); } } PureList.Chords.Add(chord); counter++; } } else //Otherwise default to all scale roots { for (int step = 0; step < Scale.Steps.Count; step++) { var root = Scale.Steps[step % Scale.Steps.Count]; //Do we need to add an octave? bool octPlus = (step + Offset1) >= Scale.Steps.Count; var c2 = Scale.Steps[(step + Offset1) % Scale.Steps.Count]; var third = octPlus ? c2 + Scale.Divisions : c2; octPlus = (step + Offset2) >= Scale.Steps.Count; var c3 = Scale.Steps[(step + Offset2) % Scale.Steps.Count]; var fifth = octPlus ? c3 + Scale.Divisions : c3; var chord = new Chord( root, third, fifth ); if (ColorPattern != null && ColorPattern.Count > 0) { var colorNum = ColorPattern[counter % ColorPattern.Count]; if (colorNum > Scale.Steps.Count) { chord.Notes.Add(Scale.Steps[(step + colorNum) % Scale.Steps.Count] + Scale.Divisions); } else { chord.Notes.Add(Scale.Steps[(step + colorNum) % Scale.Steps.Count]); } } PureList.Chords.Add(chord); counter++; } } for (int i = 0; i < duration; i++) { ChordList.Chords.AddRange(PureList.Chords); } return(ChordList); }
public void getIntervalm6() { Chord c = new Chord("C"); Assert.AreEqual("m6", c.getIntervalFromRootNote("G#")); }
protected bool Equals(Chord other) { return(string.Equals(Name, other.Name) && Kind == other.Kind && Equals(ChordPitches, other.ChordPitches)); }
public void getIntervalp5bang() { Chord c = new Chord("C5#"); Assert.AreEqual("5#", c.getIntervalFromRootNote("G#")); }
private static Chord PredictChordRandom(List <Pitch> pitches, Key key) { List <Chord> candidates = new List <Chord>() { C, Dm, Em, F, G, Am, Bdim }; int[] candCount = new int[candidates.Count]; //If a foreach (var p in pitches) { for (int i = 0; i < candidates.Count; i++) { if (candidates[i].Contains(p)) { candCount[i] += 1; } } } int max = 0; List <int> chordsAtMax = new List <int>(); for (int i = 0; i < candCount.Length; i++) { if (candCount[i] > candCount[max]) { max = i; chordsAtMax = new List <int>(); chordsAtMax.Add(i); } else if (candCount[i] == candCount[max]) { chordsAtMax.Add(i); } } Chord chord = null; if (chordsAtMax.Count == 1) { chord = candidates[max]; } else if (chordsAtMax.Count > 1) { Random rand = new Random(); int index = chordsAtMax[rand.Next(chordsAtMax.Count)]; chord = candidates[index]; } Console.WriteLine(); Console.Write("\t"); Console.Write(@"{0}, ", chord); foreach (var p in pitches) { Console.Write(@"{0} ", p); } return(chord); }
private Chord GetChord(Note n) { int[] pitches; if(n.NotePitch == (int)NoteNames.A || n.NotePitch == (int)NoteNames.As ) { int i = r.Next(0, a.Length); pitches = a[i]; } else if(n.NotePitch == (int)NoteNames.B) { int i = r.Next(0, b.Length); pitches = b[i]; } else if(n.NotePitch == (int)NoteNames.C || n.NotePitch == (int)NoteNames.Cs ) { int i = r.Next(0, c.Length); pitches = c[i]; } else if(n.NotePitch == (int)NoteNames.D || n.NotePitch == (int)NoteNames.Ds ) { int i = r.Next(0, d.Length); pitches = d[i]; } else if(n.NotePitch == (int)NoteNames.E) { int i = r.Next(0, e.Length); pitches = e[i]; } else if(n.NotePitch == (int)NoteNames.F || n.NotePitch == (int)NoteNames.Fs ) { int i = r.Next(0, f.Length); pitches = f[i]; } else if(n.NotePitch == (int)NoteNames.G || n.NotePitch == (int)NoteNames.GS ) { int i = r.Next(0, g.Length); pitches = g[i]; } else { int i = r.Next(0, a.Length); pitches = a[i]; } for (int i = 0; i < pitches.Length; i++) pitches[i] = 12 * n.Octave + pitches[i]; Chord ch = new Chord(pitches, n.Duration, n.Velocity/2); return ch; }
public void ReadChord(Beat beat) { var chord = new Chord(); var chordId = Platform.Platform.NewGuid(); if (_versionNumber >= 500) { Data.Skip(17); chord.Name = Data.GpReadStringByteLength(21, _encoding); Data.Skip(4); chord.FirstFret = Data.ReadInt32LE(); for (int i = 0; i < 7; i++) { var fret = Data.ReadInt32LE(); if (i < beat.Voice.Bar.Staff.Tuning.Length) { chord.Strings.Add(fret); } } var numberOfBarres = Data.ReadByte(); var barreFrets = new byte[5]; Data.Read(barreFrets, 0, barreFrets.Length); for (int i = 0; i < numberOfBarres; i++) { chord.BarreFrets.Add(barreFrets[i]); } Data.Skip(26); } else { if (Data.ReadByte() != 0) // mode1? { // gp4 if (_versionNumber >= 400) { // Sharp (1) // Unused (3) // Root (1) // Major/Minor (1) // Nin,Eleven or Thirteen (1) // Bass (4) // Diminished/Augmented (4) // Add (1) Data.Skip(16); chord.Name = Data.GpReadStringByteLength(21, _encoding); // Unused (2) // Fifth (1) // Ninth (1) // Eleventh (1) Data.Skip(4); chord.FirstFret = (Data.ReadInt32LE()); for (int i = 0; i < 7; i++) { var fret = Data.ReadInt32LE(); if (i < beat.Voice.Bar.Staff.Tuning.Length) { chord.Strings.Add(fret); } } var numberOfBarres = Data.ReadByte(); var barreFrets = new byte[5]; Data.Read(barreFrets, 0, barreFrets.Length); for (int i = 0; i < numberOfBarres; i++) { chord.BarreFrets.Add(barreFrets[i]); } // Barree end (5) // Omission1,3,5,7,9,11,13 (7) // Unused (1) // Fingering (7) // Show Diagram Fingering (1) // ?? Data.Skip(26); } else { // unknown Data.Skip(25); chord.Name = Data.GpReadStringByteLength(34, _encoding); chord.FirstFret = Data.ReadInt32LE(); for (int i = 0; i < 6; i++) { var fret = Data.ReadInt32LE(); if (i < beat.Voice.Bar.Staff.Tuning.Length) { chord.Strings.Add(fret); } } // unknown Data.Skip(36); } } else { int strings = _versionNumber >= 406 ? 7 : 6; chord.Name = Data.GpReadStringIntByte(_encoding); chord.FirstFret = Data.ReadInt32LE(); if (chord.FirstFret > 0) { for (int i = 0; i < strings; i++) { var fret = Data.ReadInt32LE(); if (i < beat.Voice.Bar.Staff.Tuning.Length) { chord.Strings.Add(fret); } } } } } if (!string.IsNullOrEmpty(chord.Name)) { beat.ChordId = chordId; beat.Voice.Bar.Staff.Chords[beat.ChordId] = chord; } }
private static void PrepareChordsOctave(InstrumentType instrument, Chord chord) { instrument.GoToOctave(chord.Notes.First()); }
public void playChord(Chord chordToPlay, int rootNote) { }
public void OnChordParsed(Chord chord) { ChordParsed?.Invoke(this, new ChordParsedEventArgs { Chord = chord }); }
public void playChord(Chord chordToPlay, double delay, int inversion, int rootNote) { }
/// <summary> /// Loads a Harmony Sequence though /// </summary> /// <param name="f"></param> /// <returns></returns> public static Composition LoadMidiType1(MidiFile f) { Composition comp = new Composition(); int c = 1; foreach(var trackEvents in f.Events) { Track t = new Track(); t.Channel = (byte)c++; TempoEvent tempo = new TempoEvent((int)(Note.ToRealDuration((int)Durations.qn, 60) * 1000000), 0); HarmonySequence seq = new HarmonySequence(); long lastAbsTime = -1; List<int> chordNotes = new List<int>(); int chordDuration = 0; PatchNames instr = (PatchNames)9999; bool add = true; foreach(var e in trackEvents) { if (e as TempoEvent != null) { tempo = (TempoEvent)e; } if (e as PatchChangeEvent != null) { var p = e as PatchChangeEvent; t.Instrument = (PatchNames)p.Patch; if(t.Instrument == instr) { break; } instr = t.Instrument; /*if(t.Duration < 1) { foreach(var t_ in comp.Tracks) if(t_.Instrument == (PatchNames)p.Patch) { t = t_; seq = t_.GetMainSequence() as HarmonySequence; add = false; break; } }*/ } NoteOnEvent on = e as NoteOnEvent; if (on != null && on.OffEvent != null) { int newDuration = Note.ToNoteLength(on.NoteLength, f.DeltaTicksPerQuarterNote, tempo.Tempo); if (on.AbsoluteTime == lastAbsTime && chordDuration==newDuration)//skip chords { chordNotes.Add(on.NoteNumber); } else { Chord lastChord = new Chord(chordNotes.ToArray(), chordDuration); chordNotes.Clear(); chordDuration = 0; seq.AddChord(lastChord); chordNotes.Add(on.NoteNumber); } chordDuration = newDuration; lastAbsTime = on.AbsoluteTime; } } if(chordNotes.Count > 0) { Chord lastChord = new Chord(chordNotes.ToArray(), chordDuration); chordNotes.Clear(); chordDuration = 0; seq.AddChord(lastChord); } t.AddSequence(seq); if (!comp.Tracks.Contains(t) && t.Duration > 0 && add) comp.Add(t); } return comp; }
public void Get_NoNotes() { var chord = new Chord(); Assert.Throws <InvalidOperationException>(() => GetPropertyValue(_chordPropertySelector, chord)); }
public virtual void Update(float elapsedTime) { if (!this.main.IsActive) { return; } if (!this.main.LastActive) { if (this.main.MouseState.Value.LeftButton == ButtonState.Pressed) { this.temporarilyIgnoreLMB = true; } } KeyboardState keyboard = this.main.KeyboardState; Keys[] keys = keyboard.GetPressedKeys(); if (keys.Length > 0 && this.nextInputListeners.Count > 0) { this.notifyNextInputListeners(new PCInputBinding { Key = keys[0] }); } if (this.AnyInputDown.Bindings.Count > 0) { Keys[] lastKeys = this.main.LastKeyboardState.Value.GetPressedKeys(); for (int i = 0; i < keys.Length; i++) { if (!lastKeys.Contains(keys[i])) { this.AnyInputDown.Execute(new PCInputBinding { Key = keys[i] }); } } } foreach (KeyValuePair <Keys, Property <bool> > pair in this.keyProperties) { bool newValue = keyboard.IsKeyDown(pair.Key); if (newValue != pair.Value.Value) { pair.Value.Value = newValue; if (!this.preventKeyDownEvents) { if (newValue) { Command command; if (this.keyDownCommands.TryGetValue(pair.Key, out command)) { command.Execute(); } } else { Command command; if (this.keyUpCommands.TryGetValue(pair.Key, out command)) { command.Execute(); } } } } } GamePadState gamePad = this.main.GamePadState; if (gamePad.IsConnected) { if (this.nextInputListeners.Count > 0 || this.AnyInputDown.Bindings.Count > 0) { GamePadState lastGamePad = this.main.LastGamePadState; List <Buttons> buttons = new List <Buttons>(); if (gamePad.IsButtonDown(Buttons.A) && !lastGamePad.IsButtonDown(Buttons.A)) { buttons.Add(Buttons.A); } if (gamePad.IsButtonDown(Buttons.B) && !lastGamePad.IsButtonDown(Buttons.B)) { buttons.Add(Buttons.B); } if (gamePad.IsButtonDown(Buttons.Back) && !lastGamePad.IsButtonDown(Buttons.Back)) { buttons.Add(Buttons.Back); } if (gamePad.IsButtonDown(Buttons.DPadDown) && !lastGamePad.IsButtonDown(Buttons.DPadDown)) { buttons.Add(Buttons.DPadDown); } if (gamePad.IsButtonDown(Buttons.DPadLeft) && !lastGamePad.IsButtonDown(Buttons.DPadLeft)) { buttons.Add(Buttons.DPadLeft); } if (gamePad.IsButtonDown(Buttons.DPadRight) && !lastGamePad.IsButtonDown(Buttons.DPadRight)) { buttons.Add(Buttons.DPadRight); } if (gamePad.IsButtonDown(Buttons.DPadUp) && !lastGamePad.IsButtonDown(Buttons.DPadUp)) { buttons.Add(Buttons.DPadUp); } if (gamePad.IsButtonDown(Buttons.LeftShoulder) && !lastGamePad.IsButtonDown(Buttons.LeftShoulder)) { buttons.Add(Buttons.LeftShoulder); } if (gamePad.IsButtonDown(Buttons.RightShoulder) && !lastGamePad.IsButtonDown(Buttons.RightShoulder)) { buttons.Add(Buttons.RightShoulder); } if (gamePad.IsButtonDown(Buttons.LeftStick) && !lastGamePad.IsButtonDown(Buttons.LeftStick)) { buttons.Add(Buttons.LeftStick); } if (gamePad.IsButtonDown(Buttons.RightStick) && !lastGamePad.IsButtonDown(Buttons.RightStick)) { buttons.Add(Buttons.RightStick); } if (gamePad.IsButtonDown(Buttons.LeftThumbstickDown) && !lastGamePad.IsButtonDown(Buttons.LeftThumbstickDown)) { buttons.Add(Buttons.LeftThumbstickDown); } if (gamePad.IsButtonDown(Buttons.LeftThumbstickRight) && !lastGamePad.IsButtonDown(Buttons.LeftThumbstickRight)) { buttons.Add(Buttons.LeftThumbstickRight); } if (gamePad.IsButtonDown(Buttons.LeftThumbstickLeft) && !lastGamePad.IsButtonDown(Buttons.LeftThumbstickLeft)) { buttons.Add(Buttons.LeftThumbstickLeft); } if (gamePad.IsButtonDown(Buttons.LeftThumbstickUp) && !lastGamePad.IsButtonDown(Buttons.LeftThumbstickUp)) { buttons.Add(Buttons.LeftThumbstickUp); } if (gamePad.IsButtonDown(Buttons.RightThumbstickDown) && !lastGamePad.IsButtonDown(Buttons.RightThumbstickDown)) { buttons.Add(Buttons.RightThumbstickDown); } if (gamePad.IsButtonDown(Buttons.RightThumbstickRight) && !lastGamePad.IsButtonDown(Buttons.RightThumbstickRight)) { buttons.Add(Buttons.RightThumbstickRight); } if (gamePad.IsButtonDown(Buttons.RightThumbstickLeft) && !lastGamePad.IsButtonDown(Buttons.RightThumbstickLeft)) { buttons.Add(Buttons.RightThumbstickLeft); } if (gamePad.IsButtonDown(Buttons.RightThumbstickUp) && !lastGamePad.IsButtonDown(Buttons.RightThumbstickUp)) { buttons.Add(Buttons.RightThumbstickUp); } if (gamePad.IsButtonDown(Buttons.LeftTrigger) && !lastGamePad.IsButtonDown(Buttons.LeftTrigger)) { buttons.Add(Buttons.LeftTrigger); } if (gamePad.IsButtonDown(Buttons.RightTrigger) && !lastGamePad.IsButtonDown(Buttons.RightTrigger)) { buttons.Add(Buttons.RightTrigger); } if (gamePad.IsButtonDown(Buttons.X) && !lastGamePad.IsButtonDown(Buttons.X)) { buttons.Add(Buttons.X); } if (gamePad.IsButtonDown(Buttons.Y) && !lastGamePad.IsButtonDown(Buttons.Y)) { buttons.Add(Buttons.Y); } if (gamePad.IsButtonDown(Buttons.Start) && !lastGamePad.IsButtonDown(Buttons.Start)) { buttons.Add(Buttons.Start); } if (buttons.Count > 0) { if (this.AnyInputDown.Bindings.Count > 0) { for (int i = 0; i < buttons.Count; i++) { this.AnyInputDown.Execute(new PCInputBinding { GamePadButton = buttons[i] }); } } if (this.nextInputListeners.Count > 0) { this.notifyNextInputListeners(new PCInputBinding { GamePadButton = buttons[0] }); } } } foreach (KeyValuePair <Buttons, Property <bool> > pair in this.buttonProperties) { bool newValue = gamePad.IsButtonDown(pair.Key); if (newValue != pair.Value.Value) { pair.Value.Value = newValue; if (!this.preventKeyDownEvents) { if (newValue) { Command command; if (buttonDownCommands.TryGetValue(pair.Key, out command)) { command.Execute(); } } else { Command command; if (buttonUpCommands.TryGetValue(pair.Key, out command)) { command.Execute(); } } } } } } foreach (KeyValuePair <Keys, Property <bool> > pair in this.keyProperties) { bool newValue = keyboard.IsKeyDown(pair.Key); if (newValue != pair.Value.Value) { pair.Value.Value = newValue; if (!this.preventKeyDownEvents) { if (newValue) { Command command; if (this.keyDownCommands.TryGetValue(pair.Key, out command)) { command.Execute(); } } else { Command command; if (keyUpCommands.TryGetValue(pair.Key, out command)) { command.Execute(); } } } } } if (!this.chordActivated && !this.preventKeyDownEvents) { if (keys.Length == 2) { Chord chord = new Chord(); if (keys[1] == Keys.LeftAlt || keys[1] == Keys.LeftControl || keys[1] == Keys.LeftShift || keys[1] == Keys.LeftWindows || keys[1] == Keys.RightAlt || keys[1] == Keys.RightControl || keys[1] == Keys.RightShift || keys[1] == Keys.RightWindows) { chord.Modifier = keys[1]; chord.Key = keys[0]; } else { chord.Modifier = keys[0]; chord.Key = keys[1]; } Command chordCommand; if (this.chords.TryGetValue(chord, out chordCommand)) { chordCommand.Execute(); this.chordActivated = true; } } } else if (keyboard.GetPressedKeys().Length == 0) { this.chordActivated = false; } if (this.EnableMouse) { MouseState mouse = this.main.MouseState; this.handleMouse(); bool newLeftMouseButton = mouse.LeftButton == ButtonState.Pressed; if (newLeftMouseButton != this.LeftMouseButton) { this.LeftMouseButton.Value = newLeftMouseButton; if (!this.preventKeyDownEvents) { if (newLeftMouseButton) { if (!this.temporarilyIgnoreLMB) { if (this.nextInputListeners.Count > 0) { this.notifyNextInputListeners(new PCInputBinding { MouseButton = MouseButton.LeftMouseButton }); } this.LeftMouseButtonDown.Execute(); this.AnyInputDown.Execute(new PCInputBinding { MouseButton = MouseButton.LeftMouseButton }); } } else { if (this.temporarilyIgnoreLMB) { this.temporarilyIgnoreLMB = false; } else { this.LeftMouseButtonUp.Execute(); } } } } bool newMiddleMouseButton = mouse.MiddleButton == ButtonState.Pressed; if (newMiddleMouseButton != this.MiddleMouseButton) { this.MiddleMouseButton.Value = newMiddleMouseButton; if (!this.preventKeyDownEvents) { if (newMiddleMouseButton) { if (this.nextInputListeners.Count > 0) { this.notifyNextInputListeners(new PCInputBinding { MouseButton = MouseButton.MiddleMouseButton }); } this.MiddleMouseButtonDown.Execute(); this.AnyInputDown.Execute(new PCInputBinding { MouseButton = MouseButton.MiddleMouseButton }); } else { this.MiddleMouseButtonUp.Execute(); } } } bool newRightMouseButton = mouse.RightButton == ButtonState.Pressed; if (newRightMouseButton != this.RightMouseButton) { this.RightMouseButton.Value = newRightMouseButton; if (!this.preventKeyDownEvents) { if (newRightMouseButton) { if (this.nextInputListeners.Count > 0) { this.notifyNextInputListeners(new PCInputBinding { MouseButton = MouseButton.RightMouseButton }); } this.RightMouseButtonDown.Execute(); this.AnyInputDown.Execute(new PCInputBinding { MouseButton = MouseButton.RightMouseButton }); } else { this.RightMouseButtonUp.Execute(); } } } int newScrollWheel = mouse.ScrollWheelValue; int oldScrollWheel = this.ScrollWheel; if (newScrollWheel != oldScrollWheel) { this.ScrollWheel.Value = newScrollWheel; if (!this.preventKeyDownEvents) { this.MouseScrolled.Execute(newScrollWheel > oldScrollWheel ? 1 : -1); } } } this.preventKeyDownEvents = false; }
public void getRootNoteTestBang() { Chord c = new Chord("C#"); Assert.AreEqual("C#", c.getRootNote()); }
public void poll() { OscBundle bundle = null; while (bundle == null) { bundle = (OscBundle)listener.Receive(); Thread.Sleep(1); } //Debug.Log("Received a bundle!"); List <OscMessage> messages = bundle.Messages; OscMessage lastMessage = bundle.Messages[bundle.Messages.Count - 1]; switch (lastMessage.Address) { case "/notes_receiver": Note note = new Note(); object midiNumber = lastMessage.Arguments[0]; object start = lastMessage.Arguments[1]; object duration = lastMessage.Arguments[2]; // Typecheck to make sure that message is intact if (midiNumber is int midiNumberInt) { note.MidiNumber = midiNumberInt; note.Start = (float)start; note.Duration = (float)duration; note.Starts.Add((float)start); note.Durations.Add((float)duration); individualNote = note; receivedNote = true; } break; case "/notes_complete": isDoneReceivingNotes = true; break; case "/chords_receiver": int i = 0; object commonName = lastMessage.Arguments[i]; // Typecheck to make sure that message is intact if (commonName is string commonNameString) { // Initialise chord object chord = new Chord(); chord.CommonName = commonNameString; // Add all subsequent ints (notes) to the chord object until separator "|" is hit object next = lastMessage.Arguments[++i]; while (next is int nextMidiNumberInt) { Note individualNote = new Note(nextMidiNumberInt); chord.AddNote(individualNote); next = lastMessage.Arguments[++i]; } // After notes (int) in OSC message it's beat and duration (floats) var chordStart = (float)next; next = lastMessage.Arguments[++i]; var chordDuration = (float)next; chord.Start = chordStart; chord.Duration = chordDuration; receivedChord = true; } break; } poll(); }
public void getSixthStringTwelfthFret() { Assert.AreEqual("E", Chord.GetNoteLetter(5, 12)); }
public void PlayChord(Chord c) { state = 0; //midiOut.Send(MidiMessage.ChangePatch((int)PatchNames.Electric_Piano_2, 1).RawData); foreach (Note n in c.Notes) { midiOut.Send(MidiMessage.StartNote(n.Pitch, c.Velocity, 1).RawData); } Thread.Sleep((int)(Note.ToRealDuration(c.Duration) * 1000)); foreach (Note n in c.Notes) { midiOut.Send(MidiMessage.StopNote(n.Pitch, 0, 1).RawData); } }
public void getFifthStringFirstFret() { Assert.AreEqual("B", Chord.GetNoteLetter(4, 0)); }
private void WriteBeat(Chord chord, int trackNumber, int numStrings, bool changeTempo, int newTempo) { const Byte DOTTED_NOTE = 1; const Byte CHORD_DIAGRAM = (1 << 1); const Byte TEXT = (1 << 2); const Byte BEAT_EFFECTS = (1 << 3); const Byte MIX_TABLE = (1 << 4); const Byte TUPLET = (1 << 5); const Byte REST = (1 << 6); const short STRING_EFFECTS = (1 << 5); const Byte TAPPING = 1; const Byte SLAPPING = 2; const Byte POPPING = 3; // figure out beat duration bool dotted = false; bool triplet = false; SByte duration = 0; switch (chord.Duration) { case 192: duration = -2; break; case 144: duration = -1; dotted = true; break; case 96: duration = -1; break; case 72: duration = 0; dotted = true; break; case 48: duration = 0; break; case 36: duration = 1; dotted = true; break; case 32: duration = 0; triplet = true; break; case 24: duration = 1; break; case 18: duration = 2; dotted = true; break; case 16: duration = 1; triplet = true; break; case 12: duration = 2; break; case 9: duration = 3; dotted = true; break; case 8: duration = 2; triplet = true; break; case 6: duration = 3; break; case 4: duration = 3; triplet = true; break; case 3: duration = 4; break; case 2: duration = 4; triplet = true; break; default: Console.WriteLine(" Warning: Rhythm Duration {0} not handled, defaulting to quarter note.", chord.Duration); duration = 0; break; } Byte flags = 0; if (chord.Notes.Count == 0) flags |= REST; if (dotted) flags |= DOTTED_NOTE; if (triplet) flags |= TUPLET; if (changeTempo) flags |= MIX_TABLE; if (chord.Section != null) flags |= TEXT; bool tapped = false; foreach (var kvp in chord.Notes) { if (kvp.Value.Tapped) tapped = true; } if (chord.Popped || chord.Slapped || tapped) flags |= BEAT_EFFECTS; var chordTemplates = score.Tracks[trackNumber].ChordTemplates; if (chord.ChordId != -1 && chord.ChordId != prevChordId[trackNumber] && chordTemplates.ContainsKey(chord.ChordId) && chordTemplates[chord.ChordId].Name != string.Empty) { flags |= CHORD_DIAGRAM; } prevChordId[trackNumber] = chord.ChordId; writer.Write(flags); if (chord.Notes.Count == 0) writer.Write((Byte)2); // 2 is an actual rest, 0 is silent writer.Write(duration); if (triplet) writer.Write((Int32)3); // declare a triplet beat // chord diagram if ((flags & CHORD_DIAGRAM) != 0) { var chordTemplate = chordTemplates[chord.ChordId]; WriteChordTemplate(chordTemplate); } // section names if ((flags & TEXT) != 0) WriteDoublePrefixedString(chord.Section); // beat effects if ((flags & BEAT_EFFECTS) != 0) { short effectsFlag = 0; if (chord.Popped || chord.Slapped || tapped) effectsFlag |= STRING_EFFECTS; writer.Write(effectsFlag); if (tapped) writer.Write(TAPPING); else if (chord.Slapped) writer.Write(SLAPPING); else if (chord.Popped) writer.Write(POPPING); } // mix table (used for changing tempo) if ((flags & MIX_TABLE) != 0) { for (int i = 0; i < 23; ++i) writer.Write((Byte)0xff); WriteDoublePrefixedString(""); // tempo string writer.Write((Int32)newTempo); writer.Write((Byte)0); // means new tempo takes effect immediately writer.Write((Byte)1); writer.Write((Byte)0xff); } // now write the actual notes. a flag indicates which strings are being played Byte stringFlags = 0; int stringOffset = 7 - numStrings; foreach (var kvp in chord.Notes) stringFlags |= (Byte)(1 << (kvp.Key+stringOffset)); writer.Write(stringFlags); var notes = chord.Notes.Values.OrderByDescending(x => x.String); foreach (var note in notes) { WriteNote(note, trackNumber); } // there seem to be a few accidental ties set in the Rocksmith XMLs // so unset the tie status on any strings that weren't in the current chord. for (int i = 0; i < 6; ++i) { if (!chord.Notes.ContainsKey(i)) tieNotes[trackNumber][i] = false; } short noteTranspose = 0; writer.Write(noteTranspose); }
public void getFifthStringTwelfthFret() { Assert.AreEqual("B", Chord.GetNoteLetter(4, 12)); }
static void ChordTest2() { MusicPlayer player = new MusicPlayer(); //player.SetPatch((int)PatchNames.Overdriven_Guitar, 1); var a = new Chord(new NoteNames[] { NoteNames.C, NoteNames.E, NoteNames.G }, 4, Durations.hn); var b = new Chord(new NoteNames[] { NoteNames.Cs, NoteNames.E, NoteNames.GS }, 4, Durations.hn); var c = new Chord(new NoteNames[] { NoteNames.D, NoteNames.F, NoteNames.A }, 4, Durations.hn); var d = new Chord(new NoteNames[] { NoteNames.E, NoteNames.G, NoteNames.B }, 4, Durations.hn); var e = new Chord(new NoteNames[] { NoteNames.F, NoteNames.A, NoteNames.C }, 4, Durations.hn); var f = new Chord(new NoteNames[] { NoteNames.G, NoteNames.B, NoteNames.D }, 4, Durations.hn); var g = new Chord(new NoteNames[] { NoteNames.A, NoteNames.C, NoteNames.E }, 4, Durations.hn); var h = new Chord(new NoteNames[] { NoteNames.B, NoteNames.D, NoteNames.F }, 4, Durations.hn); var k = new Chord[] { a, b, c, d, e, f, g, h }; Random r = new Random(); while (true) { var chord = k[r.Next(0, k.Length)]; chord.Duration = (int)((Durations)Math.Pow(2, r.Next(2, 6))); player.PlayChord(chord); } }
public void getFourthStringFirstFret() { Assert.AreEqual("G", Chord.GetNoteLetter(3, 0)); }