/// <summary> /// Takes an impulse and plays it with the ImpulseDemo's parameters. /// This takes an impulse so you don't need to instantiate one every time. /// If you're doing the same impulse regularly, it saves traversal/breadth first searching /// </summary> /// <param name="imp">A constructed impulse of the emanation or traversal</param> private void ConfigureAndPlayImpulse(ImpulseGenerator.Impulse imp) { if (CurrentMode == ImpulseType.Emanating) { StartCoroutine(ColorSuitForEmanation()); } else { StartCoroutine(ColorSuitForTraversal()); } //To support CodeSequence Samples if (SelectedCodeSequence < 0) { //These are broken up by lines for readability imp.WithDuration(ImpulseDuration); imp.WithAttenuation(Attenuation); imp.WithEffect(effectOptions[currentEffect], EffectDuration, EffectStrength); imp.Play(); //You can do something like: //i.WithAttenuation(Attenuation).WithDuration(ImpulseDuration).WithEffect(effectOptions[CurrentEffect], EffectDuration, EffectStrength).Play(); //Chaining and Functional Programming! } else { //These are broken up by lines for readability imp.WithDuration(ImpulseDuration); imp.WithAttenuation(Attenuation); imp.WithEffect(GetCodeSequence()); imp.Play(); } }
/// <summary> /// Repeatedly calls impulse.Play after X delay Y times. /// This sample DOES work. It will get baked into the Impulse's functionality later. /// </summary> /// <param name="impulse">The impulse to repeat</param> /// <param name="delay">How long AFTER the previous one do you want to start the next one</param> /// <param name="count">How many times you want to play it. (Ideally you should call .Play before you call RepeatedEmanations, otherwise it won't start when you start this coroutine.)</param> /// <returns></returns> IEnumerator RepeatedEmanations(ImpulseGenerator.Impulse impulse, float delay, int count) { impulse.Play(); for (int i = 0; i < count - 1; i++) { yield return(new WaitForSeconds(delay)); impulse.Play(); } }
// IEnumerator ShockPlayer() { //This serves as the 'Is Coroutine Running' variable CurrentlyShocking = true; //This is a construct for our repetition of the traversal effect. float delay = .4f; //Prevent the loop/effect from running forever. int breakout = 0; //A handle for canceling the shock when the condition is no longer true. HapticHandle shockHandle = null; //This is the loop that will re-start the impulse //Remember that CurrentShocking is a bool from outside this function. Meaning it can be turned off and then we leave the loop. while (CurrentlyShocking && breakout < 25) { //Finally, don't forget to play the effect. shockHandle = shockImpulse.Play(); //Wait before the next zap yield return(new WaitForSeconds(delay)); //Max of X Zaps. breakout++; } //If we stop shocking the player, we want to clean up the last effect played. This means when the player stops touching the outlet, they stop getting shocked. shockHandle.Stop(); //Mark that we aren't shocking the player. CurrentlyShocking = false; }
/// <summary> /// Takes an impulse and plays it with the ImpulseDemo's parameters. /// This takes an impulse so you don't need to instantiate one every time. /// If you're doing the same impulse regularly, it saves traversal/breadth first searching /// </summary> /// <param name="imp">A constructed impulse of the emanation or traversal</param> private void ConfigureAndPlayImpulse(ImpulseGenerator.Impulse imp) { if (CurrentMode == ImpulseType.Emanating) { StartCoroutine(ColorSuitForEmanation()); } else { StartCoroutine(ColorSuitForTraversal()); } //To support HapticSequence Samples if (UseEffectSelectorSlider) { //Prevent array index out of bounds errors. Effect whichEffect = effectOptions[Mathf.Clamp(currentEffect, 0, effectOptions.Length - 1)]; //These are broken up by lines for readability imp.WithDuration(ImpulseDuration); imp.WithAttenuation(Attenuation); imp.WithEffect(whichEffect, EffectDuration, EffectStrength); imp.Play(); //You can do something like: //i.WithAttenuation(Attenuation).WithDuration(ImpulseDuration).WithEffect(effectOptions[CurrentEffect], EffectDuration, EffectStrength).Play(); //Chaining and Functional Programming! } else { //These are broken up by lines for readability imp.WithDuration(ImpulseDuration); imp.WithAttenuation(Attenuation); imp.WithEffect(GetHapticSequence()); imp.Play(); } }
/// <summary> /// This is a simple handful of lines. This plays when Walter (the giant red scorpion of player murdering) lands on the ground. /// This sample DOES work. /// The intention is to give an effect that goes up the body. /// It has been slightly adapted to take different effect families (click, double-click, hum, etc) /// </summary> public static void GiantScorpionLanding(string effect = "buzz") { //TWo different Impulses are used here even though the same one could be re-assigned. Two variables are more readable at neglible CPU cost. ImpulseGenerator.Impulse leftUp = ImpulseGenerator.BeginTraversingImpulse(AreaFlag.Lower_Ab_Left, AreaFlag.Forearm_Left) .WithDuration(0.5f) .WithEffect(effect, 0.1f, 1.0f); ImpulseGenerator.Impulse rightUp = ImpulseGenerator.BeginTraversingImpulse(AreaFlag.Lower_Ab_Right, AreaFlag.Forearm_Right) .WithDuration(0.5f) .WithEffect(effect, 0.1f, 1.0f); //Don't forget to play the effects leftUp.Play(); rightUp.Play(); //We could HapticHandle[] if we wanted to stop these prematurely - however they're very short effects, so it's unlikely that will be needed. //HapticHandle's can be Stopped or restarted until they (Finish playing AND go out of scope), after that they're gone. }