/// <summary> /// Change Fog Color Tone /// </summary> bool Command205() { // Start Color tone change Tone tone = new Tone(intParams[0], intParams[1], intParams[2], intParams[3]); InGame.Map.StartFogToneChange(tone, intParams[4] * 2); // Continue return true; }
public void set(Tone c) { if (c == null) return; red = c.red; green = c.green; blue = c.blue; gray = c.gray; }
private static void generateManifest(Stream outManifest, Tone.Tone tone) { var manifest = new Tone.Manifest(); manifest.Entries.Add(tone); var data = JsonConvert.SerializeObject(manifest, Formatting.Indented); var writer = new StreamWriter(outManifest); writer.Write(data); writer.Flush(); outManifest.Seek(0, SeekOrigin.Begin); }
public ToneViewer(Tone tone) { InitializeComponent(); _tone = tone; Hue.RawValue = _tone.Hue; SaturationHigh.RawValue = _tone.SaturationHigh * 100; SaturationLow.RawValue = _tone.SaturationLow * 100; ValueHigh.RawValue = _tone.ValueHigh * 100; ValueLow.RawValue = _tone.ValueLow * 100; }
public void SetToneRandomly(Random rng) { if (rng == null) { rng = new Random(); } var possibilities = IncidentEnumExtensions.GetPossibleTones(TheEnergyVariation, TheStressVariation); var diceRoll = rng.Next(0, possibilities.Count); theTone = possibilities[diceRoll]; }
public void TestSerialize(int scale, bool half, string json) { var tone = new Tone { Scale = scale, Half = half, }; var result = JsonConvert.SerializeObject(tone, CreateSettings()); Assert.AreEqual(result, $"{json}"); }
private void WriteNote(WaveStreamWriter streamWriter, string name, int durationBefore, int duration, int amplitude) { Tone tone = Tones.Item(name); if (durationBefore > 0) { streamWriter.WriteSilenceChunk(durationBefore); } streamWriter.WriteChunk(SampleHelper.MakeBassChunk2(duration, tone.Frequency, amplitude, 2)); //streamWriter.WriteOscillator(new Oscillator(WaveType.Sine, duration, tone.Frequency, amplitude, 2)); }
private void performColumnMovement(Tone lastTone, MoveSelectionEvent <HitObject> moveEvent) { if (!(moveEvent.Blueprint is NoteSelectionBlueprint)) { return; } // top position var screenSpacePosition = moveEvent.Blueprint.ScreenSpaceSelectionPoint + moveEvent.ScreenSpaceDelta; var dragHeight = NotePlayfield.ToLocalSpace(screenSpacePosition).Y; var lastHeight = convertToneToHeight(lastTone); var moveHeight = dragHeight - lastHeight; var deltaTone = new Tone(); const float trigger_height = ScrollingNotePlayfield.COLUMN_SPACING + DefaultColumnBackground.COLUMN_HEIGHT; if (moveHeight > trigger_height) { deltaTone = -new Tone { Half = true } } ; else if (moveHeight < 0) { deltaTone = new Tone { Half = true } } ; if (deltaTone == 0) { return; } foreach (var note in EditorBeatmap.SelectedHitObjects.OfType <Note>()) { if (note.Tone >= calculator.MaxTone() && deltaTone > 0) { continue; } if (note.Tone <= calculator.MinTone() && deltaTone < 0) { continue; } note.Tone += deltaTone; //Change all note to visible note.Display = true; } }
static void Encode(BinaryWriter writer, Tone o) { EncodeID(writer, typeof(Tone)); writer.Write(o.Hue); writer.Write(o.SaturationHigh); writer.Write(o.SaturationLow); writer.Write(o.ValueHigh); writer.Write(o.ValueLow); }
private static void generateManifest(Stream outManifest, Tone tone) { var manifest = new Manifest.Tone.Manifest(); manifest.Entries.Add(tone); var data = JsonConvert.SerializeObject(manifest, Formatting.Indented); var writer = new StreamWriter(outManifest); writer.Write(data); writer.Flush(); outManifest.Seek(0, SeekOrigin.Begin); }
/// <summary> /// /// </summary> /// <param name="table"></param> /// <param name="tones"></param> private static void readOpnBank(Dictionary <string, Dictionary <string, string> > table, List <Tone> tones) { for (int progNo = 0; progNo < 128; progNo++) { Tone tone = new Tone(); tone.Number = progNo; var val = getValue(table, "Prog" + progNo, "Name"); if (!string.IsNullOrWhiteSpace(val)) { tone.Name = val; } val = getValue(table, "Prog" + progNo, "ALFB"); if (string.IsNullOrWhiteSpace(val)) { continue; } var vals = extractParams(val); tone.AL = vals[0]; tone.FB = vals[1]; for (int opNo = 0; opNo < 4; opNo++) { val = getValue(table, "Prog" + progNo, "OP" + (opNo + 1)); if (string.IsNullOrWhiteSpace(val)) { tone = null; break; } vals = extractParams(val); tone.aOp[opNo].AR = vals[0]; tone.aOp[opNo].DR = vals[1]; tone.aOp[opNo].SR = vals[2]; tone.aOp[opNo].RR = vals[3]; tone.aOp[opNo].SL = vals[4]; tone.aOp[opNo].TL = vals[5]; tone.aOp[opNo].KS = vals[6]; tone.aOp[opNo].ML = vals[7]; tone.aOp[opNo].DT = vals[8]; tone.aOp[opNo].EG = vals[9]; tone.aOp[opNo].AM = vals[10]; } if (tone != null) { tones.Add(tone); } } }
public Tone(Tone tone) { Name = tone.Name; Number = tone.Number; FB = tone.FB; AL = tone.AL; CNT = tone.CNT; aOp = new Op[4]; aOp[0] = new Op(tone.aOp[0]); aOp[1] = new Op(tone.aOp[1]); aOp[2] = new Op(tone.aOp[2]); aOp[3] = new Op(tone.aOp[3]); }
public Key(int keyNumber) { if (keyNumber < 12) { Scale = Scale.Major; Tone = (Tone)keyNumber; } else { Scale = Scale.Minor; Tone = (Tone)(keyNumber - 12); } }
public override float this[Tone tone] { get { var baseSemitone = TONE_NAME_TO_SEMITONE.TryGetStructValue(tone.ToneName); if (baseSemitone.HasValue) { return((float)(a4 * Math.Pow(2, tone.Octave - 4 + (baseSemitone.Value + tone.Accidental) / 12.0))); } else { return(0f); } } }
public OctaveTone GetRandomOctaveTone(int octave = 0) { Tone tone = GetRandomTone(); if (octave > 0) { return(new OctaveTone(tone, octave)); } else { return(new OctaveTone(tone, UnityEngine.Random.Range(1, 6))); } }
public Voice applyVoiceTone(Voice voice, Tone tone) { Voice curVoice = voice; switch (tone) { case Tone.Anxious: curVoice.pitch += 0.03f; curVoice.volume += 0.2f; break; } return(curVoice); }
public static void Generate(string toneKey, Tone.Tone tone, Stream outManifest, Stream outXblock, Stream aggregateGraph) { var id = IdGenerator.Guid().ToString().Replace("-", ""); if (string.IsNullOrEmpty(tone.Name)) tone.Name = toneKey; tone.Key = toneKey; tone.PersistentID = id; tone.BlockAsset = String.Format("urn:emergent-world:DLC_Tone_{0}", toneKey); generateManifest(outManifest, tone); generateXBlock(toneKey, outXblock, tone); generateAggregateGraph(toneKey, aggregateGraph); }
public Voice applyVoiceTone(Voice voice, Tone tone) { Voice curVoice = voice; switch(tone) { case Tone.Anxious: curVoice.pitch += 0.03f; curVoice.volume += 0.2f; break; } return curVoice; }
/// <summary> /// Creates a new CnsExploration model entity based on the data of /// this CnsExploration viewmodel. /// </summary> public CnsExploration ToNewModel() { var cnsExploration = new CnsExploration { Behavior = Behavior.GetValueOrDefault(), CranialNerves = CranialNerves.GetValueOrDefault(), Tone = Tone.GetValueOrDefault(), Position = Position.GetValueOrDefault(), Reflexes = Reflexes.GetValueOrDefault() }; return(cnsExploration); }
///<summary>Starts the Picture's tone change</summary> ///<param Name="changeTone">target tone</param Name> ///<param Name="duration">change duration</param Name> public void StartToneChange(Tone changeTone, int duration) { toneTarget = changeTone.Clone; toneDuration = (int)(duration * GameOptions.AdjustFrameRate); startToneRed = ColorTone.Red; startToneGeen = ColorTone.Green; startToneBlue = ColorTone.Blue; startToneGray = ColorTone.Gray; if (toneDuration == 0) { ColorTone = toneTarget.Clone; } }
/// <summary> /// Sets PWM to the tone frequency and starts it. /// </summary> /// <param name="tone"></param> private void SetTone(Tone tone) { tunePWM.Active = false; if (tone.freq == 0) { tunePWM.Active = false; return; } tunePWM.Set((int)tone.freq, 0.5); tunePWM.Active = true; }
public (short, short) GetSample(int index, double sampleRate, Tone t) { var time = MidiTimingConverter.GetTime(index, (int)sampleRate); var i = (int)((index % (100)) * (32 * 0.01)); if (i > 31) { i -= 32; } var o = Wave[i]; float vol; EnvelopeFlag flag = EnvelopeFlag.Attack; if (time > Envelope.A) { flag = EnvelopeFlag.Decay; } if (time > Envelope.A + Envelope.D) { flag = EnvelopeFlag.Sustain; } switch (flag) { case EnvelopeFlag.Attack: vol = (float)MathHelper.Linear(time, 0, Envelope.A, 0, 1); break; case EnvelopeFlag.Decay: vol = (float)MathHelper.Linear(time, Envelope.A, Envelope.A + Envelope.D, 1, Envelope.S * 0.0039); break; case EnvelopeFlag.Sustain: vol = Envelope.S * 0.0039f; break; case EnvelopeFlag.Release: case EnvelopeFlag.None: default: vol = 0; break; } if (t != null) { t.EnvVolume = vol; } short a = (short)(Math.Min(short.MaxValue, Math.Max(short.MinValue, o * vol))); return(a, a); }
public void ScaleContainsTest(Tone tone, bool expected1, bool expected2, bool expected3) { Scale s1 = new Scale(Tone.A, Tone.B, Tone.C, Tone.D, Tone.E + 12, Tone.F + 12 * 2); Assert.AreEqual(s1.Contains(tone), expected1); Scale s2 = new Scale(Tone.ASharp - 12, Tone.B - 12, Tone.C - 12, Tone.F - 12); Assert.AreEqual(s2.Contains(tone), expected2); Scale s3 = new Scale(Tone.A + 12, Tone.B + 12 * 2, Tone.C + 12 * 3, Tone.D + 12 * 4, Tone.E + 12 * 5, Tone.F + 12 * 6); Assert.AreEqual(s3.Contains(tone), expected3); }
public void PlayTest_SimpleNewTone(int octave, Tone tone, int duration, byte velocity, byte expectedToneOffset) { IOrchestra o = Substitute.For <IOrchestra>(); Instrument i = new Instrument(o, InstrumentType.AcousticBass, new Scale(), octave); i.Play(tone, duration, velocity); List <SingleBeat> expected = new List <SingleBeat> { new SingleBeat(i.InstrumentType, expectedToneOffset, velocity, 0, duration) }; o.Received().CopyToOutput(Arg.Is <List <SingleBeat> >(value => value.SequenceEqual(expected))); }
/// <summary> /// Constructor for creating an alarm where hour input is 0-23 /// </summary> /// <param name="hours"></param> /// <param name="minutes"></param> /// <param name="seconds"></param> /// <param name="set"></param> public AlarmMVC(int hours, int minutes, int seconds, bool set, int snooze, Tone ringtone) { if (set) { Status = AlarmStatus.Running; } else { Status = AlarmStatus.Off; } Time = new DateTime(DateTime.Today.Year, DateTime.Today.Month, DateTime.Today.Day, hours, minutes, seconds); this.snooze = snooze; this.Ringtone = ringtone; }
/// <summary> /// Update Fog Color /// </summary> void UpdateFogColour() { // Manage change in Fog Color tone if (fogToneDuration >= 1) { int d = fogToneDuration; Tone target = fogToneTarget; fogTone.Red = (fogTone.Red * (d - 1) + target.Red) / d; fogTone.Green = (fogTone.Green * (d - 1) + target.Green) / d; fogTone.Blue = (fogTone.Blue * (d - 1) + target.Blue) / d; fogTone.Gray = (fogTone.Gray * (d - 1) + target.Gray) / d; fogToneDuration -= 1; } }
public override void Visit(ToneCommand visitee) { var stepTicks = CalcTicksFromLength(visitee.Length, this.ticksPerBar, this.length); var gateTicks = (int)(stepTicks * this.gateRatio); // TODO ちゃんと書き直す Data.ToneName toneName; switch (visitee.ToneName.BaseName.ToUpper()) { case "C": toneName = Data.ToneName.C; break; case "D": toneName = Data.ToneName.D; break; case "E": toneName = Data.ToneName.E; break; case "F": toneName = Data.ToneName.F; break; case "G": toneName = Data.ToneName.G; break; case "A": toneName = Data.ToneName.A; break; case "B": toneName = Data.ToneName.B; break; default: throw new Exception(); } var tone = new Tone { Octave = this.octave, ToneName = toneName, Accidental = visitee.ToneName.Accidental }; var freq = this.detune?.GetDetunedFreq(this.temperament[tone]) ?? this.temperament[tone]; this.result.AddRange(this.owner.freqUsers.Select(u => new ValueInstruction <float>(u, freq))); if (!this.slur) { this.result.AddRange(this.owner.noteUsers.Select(u => new NoteInstruction(u, true))); } this.result.Add(new WaitInstruction(gateTicks)); if (!visitee.Slur) { this.result.AddRange(this.owner.noteUsers.Select(u => new NoteInstruction(u, false))); } if (stepTicks - gateTicks > 0) { this.result.Add(new WaitInstruction(stepTicks - gateTicks)); } this.slur = visitee.Slur; }
public bool Equals(ForumRecruitmentDetail input) { if (input == null) { return(false); } return (( TopicId == input.TopicId || (TopicId.Equals(input.TopicId)) ) && ( MicrophoneRequired == input.MicrophoneRequired || (MicrophoneRequired != null && MicrophoneRequired.Equals(input.MicrophoneRequired)) ) && ( Intensity == input.Intensity || (Intensity != null && Intensity.Equals(input.Intensity)) ) && ( Tone == input.Tone || (Tone != null && Tone.Equals(input.Tone)) ) && ( Approved == input.Approved || (Approved != null && Approved.Equals(input.Approved)) ) && ( ConversationId == input.ConversationId || (ConversationId.Equals(input.ConversationId)) ) && ( PlayerSlotsTotal == input.PlayerSlotsTotal || (PlayerSlotsTotal.Equals(input.PlayerSlotsTotal)) ) && ( PlayerSlotsRemaining == input.PlayerSlotsRemaining || (PlayerSlotsRemaining.Equals(input.PlayerSlotsRemaining)) ) && ( Fireteam == input.Fireteam || (Fireteam != null && Fireteam.SequenceEqual(input.Fireteam)) ) && ( KickedPlayerIds == input.KickedPlayerIds || (KickedPlayerIds != null && KickedPlayerIds.SequenceEqual(input.KickedPlayerIds)) )); }
/// <summary> /// /// </summary> /// <param name="tone"></param> protected override void ApplyTone(TimbreBase timbre, Tone tone) { YM3812Timbre tim = (YM3812Timbre)timbre; bool native = false; if (tone.CNT == -1) { tim.ALG = (byte)tone.AL; } else { tim.ALG = (byte)tone.CNT; native = true; } tim.FB = (byte)tone.FB; tim.GlobalSettings.Enable = false; tim.GlobalSettings.AMD = null; tim.GlobalSettings.VIB = null; for (int i = 0; i < 2; i++) { if (!native) { tim.Ops[i].AR = (byte)(tone.aOp[i].AR / 2); tim.Ops[i].DR = (byte)(tone.aOp[i].DR / 2); tim.Ops[i].SR = (byte)(tone.aOp[i].SR / 2); tim.Ops[i].TL = (byte)(tone.aOp[i].TL / 2); } else { tim.Ops[i].AR = (byte)(tone.aOp[i].AR); tim.Ops[i].DR = (byte)(tone.aOp[i].DR); tim.Ops[i].SR = null; tim.Ops[i].TL = (byte)(tone.aOp[i].TL); } tim.Ops[i].RR = (byte)tone.aOp[i].RR; tim.Ops[i].SL = (byte)tone.aOp[i].SL; tim.Ops[i].KSL = (byte)tone.aOp[i].KS; tim.Ops[i].KSR = 0; tim.Ops[i].MFM = (byte)tone.aOp[i].ML; tim.Ops[i].AM = (byte)tone.aOp[i].AM; tim.Ops[i].VR = 0; tim.Ops[i].EG = 0; tim.Ops[i].WS = 0; } timbre.TimbreName = tone.Name; }
public void SetToneRandomly_WithLimits(Random rng, Pleasantness p, EnergyLevel e) { if (rng == null) { rng = new Random(); } var finalEnergy = e == EnergyLevel.EitherLowOrHigh ? TheEnergyVariation : e; var finalStress = p == Pleasantness.EitherPleasantOrNot ? TheStressVariation : p; var possibilities = IncidentEnumExtensions.GetPossibleTones(finalEnergy, finalStress); var diceRoll = rng.Next(0, possibilities.Count); theTone = possibilities[diceRoll]; }
void Click_S5() { s5.GestureRecognizers.Add(new TapGestureRecognizer() { Command = new Command(() => { ISimpleAudioPlayer Tone; Tone = CrossSimpleAudioPlayer.CreateSimpleAudioPlayer(); Stream Tonee = GetType().Assembly.GetManifestResourceStream("gTuner.sounds.30 A#3.mp3"); Tone.Load(Tonee); Tone.Play(); }) }); }
public void WithBaseToneTest(Tone tone, double duration) { ChordVariety acd = new ChordVariety(1, 4, 7); Orchestra orc = new Orchestra(NSubstitute.Substitute.For <IMidiOut>()); List <SingleBeat> v = acd.WithBaseTone(Tone.CSharp, 5).GetChildren(orc.AddInstrument(InstrumentType.AccousticGrandPiano), 0).ToList(); List <SingleBeat> comp = new List <SingleBeat>(); comp.AddRange(new Keystroke(tone, duration).GetChildren(orc.AddInstrument(InstrumentType.AccousticGrandPiano), 0).ToList()); comp.AddRange(new Keystroke(Tone.E, duration).GetChildren(orc.AddInstrument(InstrumentType.AccousticGrandPiano), 0).ToList()); comp.AddRange(new Keystroke(Tone.G, duration).GetChildren(orc.AddInstrument(InstrumentType.AccousticGrandPiano), 0).ToList()); CollectionAssert.AreEqual(comp, v); }
public static bool IsPleasant(this Tone me) { switch (me) { case Tone.Calm: case Tone.Empathy: case Tone.Curiousity: case Tone.Joy: case Tone.Confidence: return(true); default: return(false); } }
/// <summary> /// Converts the MIDI Gremlin tone to the pitch that the MIDI standard specifies. /// </summary> internal int MidiPitchFromTone(Tone tone, int octave) { int pitch = (int)tone + //Tone enum is a value between 1 and 12, where C is the first tone. ( octave + 5 + //Pitch 0 has octave -5, so octave 0 starts at 5*12=60. OctaveOffset //Apply OctaveOffset of the keystroke's tone. ) * 12; //1 octave is 12 tone steps. if (0 > pitch || pitch > 127) { throw new ToneOutOfRangeException(pitch); } return(pitch); }
private int StepsToA4( Octave octave, Tone note, Accidental accidental) { int stepsToOctave4 = (int)octave * 12; var stepsToA = (int)note; switch (accidental) { case Accidental.Flat: stepsToA--; break; case Accidental.Sharp: stepsToA++; break; } return stepsToOctave4 + stepsToA; }
private void PlayToneLocal(Tone t) { Stopwatch youarebeingwatched = new Stopwatch(); var sleeptimeafter = TimeSpan.FromMilliseconds(t.duration * 0.3); youarebeingwatched.Start(); Console.WriteLine($"Playing delaying tone forbefore playing tone for {t.duration} ms. Will sleep for {t.frequency} ms. after {sleeptimeafter.TotalMilliseconds} sleep ms"); if (t.frequency > 0) { while (youarebeingwatched.ElapsedMilliseconds < t.duration) { Thread.Sleep(t.frequency); } } Thread.Sleep(sleeptimeafter); }
private static void generateXBlock(string toneKey, Stream outXblock, Tone.Tone tone) { var game = new GameXblock<Entity>(); var entity = new Entity { Name = String.Format("GRTonePreset_{0}", toneKey), Iterations = 1, ModelName = "GRTonePreset", Id = tone.PersistentID.ToLower() }; var properties = entity.Properties = new List<Property>(); var addProperty = new Action<string, object>((a, b) => properties.Add(CreateProperty(a, b.ToString()))); addProperty("Key", tone.Key); addProperty("Name", tone.Name); game.EntitySet = new List<Entity> {entity}; game.Serialize(outXblock); }
public static void Main() { rand = new Random(); var schoenOp25 = new Tone[] { Tone.E, Tone.F, Tone.G, Tone.Db, Tone.Gb, Tone.Eb, Tone.Ab, Tone.D, Tone.B, Tone.C, Tone.A, Tone.Bb }; Matrix m = new Matrix(schoenOp25); Console.WriteLine(m); Console.WriteLine(""); PlaySonata(m); Console.WriteLine(""); Console.WriteLine("Finé"); Console.ReadLine(); }
public Call( String name, Activity activity, CallType type, Tone tone, String duration, String encoder, String decoder, long bytesSent, long bytesReceived, long packetLoss, long packetError, long jitter, long decodeLatency, long roundTripDelay) { mName = name; mActivity = activity; mType = type; mTone = tone; mDuration = duration; mEncoder = encoder; mDecoder = decoder; mBytesSent = bytesSent; mBytesReceived = bytesReceived; mPacketLoss = packetLoss; mPacketError = packetError; mJitter = jitter; mDecodeLatency = decodeLatency; mRoundTripDelay = roundTripDelay; }
private static void GenerateTonePsarc(Stream output, string toneKey, Tone.Tone tone) { var tonePsarc = new PSARC.PSARC(); using (var packageIdStream = new MemoryStream()) using (var toneManifestStream = new MemoryStream()) using (var toneXblockStream = new MemoryStream()) using (var toneAggregateGraphStream = new MemoryStream()) { ToneGenerator.Generate(toneKey, tone, toneManifestStream, toneXblockStream, toneAggregateGraphStream); GenerateTonePackageId(packageIdStream, toneKey); tonePsarc.AddEntry(String.Format("Exports/Pedals/DLC_Tone_{0}.xblock", toneKey), toneXblockStream); var x = (from pedal in tone.PedalList where pedal.Value.PedalKey.ToLower().Contains("bass") select pedal).Count(); tonePsarc.AddEntry(x > 0 ? "Manifests/tone_bass.manifest.json" : "Manifests/tone.manifest.json", toneManifestStream); tonePsarc.AddEntry("AggregateGraph.nt", toneAggregateGraphStream); tonePsarc.AddEntry("PACKAGE_ID", packageIdStream); tonePsarc.Write(output); output.Flush(); output.Seek(0, SeekOrigin.Begin); } }
public MusicObject WithBaseTone(Tone tone) { return new ChordInstance(); }
public Note(Tone tone, params MelodyExpression[] children) : base(children) { m_Tone = tone; }
// Sets tone display mode by enum public HanyuPinyin SetMode(Tone mode) { this.mode = mode; Convert(); return this; }
public void Play(Tone tone, int duration, int velocity = 64) { throw new NotImplementedException(); }
public Note(Tone frequency, Duration time) { _toneVal = frequency; _durVal = time; }
// Sets tone display mode by integer public HanyuPinyin SetMode(int mode) { this.mode = (Tone)mode; Convert(); return this; }
// Builds this object with an input string and tone mode type Tone public HanyuPinyin(String str, Tone mode) { Init(); SetMode(mode); SetInput(str); }
void OnTriggerEnter2D(Collider2D other) { if(other.gameObject.layer == (int)LayerID.Tone && other.gameObject == Tone) { toneSource = other.gameObject.GetComponent<AudioSource>(); toneSource.volume = 1.0f; tone = other.gameObject.GetComponent<Tone>(); toneGenerator = other.gameObject.GetComponent<ToneGenerator>(); toneGenerator.SetFrequency(Frequency); toneGenerator.Type = Signale; } }
void OnTriggerExit2D(Collider2D other) { if(other.gameObject.layer == (int)LayerID.Tone && other.gameObject == Tone) { //toneSource.Stop(); toneSource.volume = 1.0f; toneGenerator.SetFrequency(Game.DefaultFrequence); toneGenerator.Type = Game.DefaultSignal; tone = null; toneSource = null; toneGenerator = null; } }
private void WriteWavBeep(Tone tone, MemoryStream ms) { // Adapted from http://tech.reboot.pro/showthread.php?tid=2866 // Sanity checks. if (tone.Volume > 1 || tone.Volume < 0) { throw new ArgumentOutOfRangeException("tone.Volume", "tone volume must be between 0 and 1."); } else if (tone.Frequency < 0) { throw new ArgumentOutOfRangeException("freq", "frequency should be 0 or more."); } // Computes intermediate values. int smp = Convert.ToInt32(WAV_FREQ * tone.Duration.TotalMilliseconds / 1000); // Amount of samples. int amp = Convert.ToInt32(MAX_AMPLITUDE * tone.Volume); // Amplitude // Writes each sample. for (int i = 0; i < smp; i++) { Int16 s = Convert.ToInt16(((amp * TWO_15_1000) - 1) * Math.Sin((2 * Math.PI * tone.Frequency / WAV_FREQ) * i)); WriteShort(ms, s); WriteShort(ms, s); // We write it twice (stereo?). } }
public static double judge(string inputText) { List<emotion> emotions = getToneAnalysis("text", inputText); emotion cheer = emotions[0]; emotion neg = emotions[1]; emotion anger = emotions[2]; Tone tone = new Tone( cheer.word_count*cheer.normalize_score + cheer.raw_score, neg.word_count*neg.normalize_score + neg.raw_score, anger.word_count*anger.normalize_score + anger.raw_score ); double distFromPrimePositive = tone.findDistanceFrom(_primaryPositive); double distFromSecondaryPositive = tone.findDistanceFrom(_secondaryPositive); double distFromPrimeNegative = tone.findDistanceFrom(_primaryNegative); double distFromSecondaryNegative = tone.findDistanceFrom(_secondaryNegative); double percentage = (5*distFromPrimePositive + distFromSecondaryPositive)/(5 * distFromPrimePositive + distFromSecondaryPositive + 5 * distFromPrimeNegative + distFromSecondaryNegative); percentage = 1 - percentage; return percentage; }
private static void PlayTones(Tone[] tones, int quarterNoteLength) { notesPlayed.Add(new List<Note>()); foreach (var t in tones.Select((tone, idx) => new { tone, idx })) { Console.Write(t.tone.ToString()); if(t.idx == 11) { Console.WriteLine(""); } else { Console.Write(","); } Tone tone = t.tone; int length = rand.Next(1, 5) * quarterNoteLength; notesPlayed.Last().Add(new Note(tone, length)); PlayNote(notesPlayed.Last().Last()); } }
public double findDistanceFrom(Tone tone) { double deltaX, deltaY, deltaZ; deltaX = this._cheerfulness - tone.Cheerfulness; deltaY = this._negative - tone.Negative; deltaZ = this._anger - tone.Anger; return Math.Sqrt(Math.Pow(deltaX, 2) + Math.Pow(deltaY, 2) + Math.Pow(deltaZ, 2)); }
public Note (Tone tone, int duration, int velocity = 64) //TODO: Make ctor that takes only offset { throw new NotImplementedException(); }
// Define a constructor to create a specific note. public Note(Tone frequency, Duration time) { NoteTone = frequency; NoteDuration = time; }